Training-LatentDynamics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a316912f-5b10-4dfa-83db-2d9e8197c718",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from matplotlib import cm\n",
    "\n",
    "import zarr\n",
    "import xarray as xr\n",
    "import os\n",
    "from sklearn import preprocessing\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.autograd import Variable\n",
    "import torch.utils.data as data_utils\n",
    "from torch.nn import Linear, Conv1d, ConvTranspose1d\n",
    "\n",
    "from torch.nn import Sequential as Seq, Linear as Lin, ReLU, Sigmoid, ConstantPad1d\n",
    "from torch.functional import F\n",
    "from torch.optim.lr_scheduler import OneCycleLR, ReduceLROnPlateau\n",
    "from tqdm import tqdm\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a8e64ee0-abb0-49ee-8a4d-82eced7b78e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from models import DriverDatasets, VAElatentdynamics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47dea496-06fe-4b16-bcc5-72bf84cd515a",
   "metadata": {},
   "source": [
    "## Load the Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3c575fb5-46d9-4515-ab5e-5b0c7b93b680",
   "metadata": {},
   "outputs": [],
   "source": [
    "trainloader=torch.load('/home/jovyan/neural-dsds/neural-dsds/data/trainloader_onecat.pth')\n",
    "valloader=torch.load('/home/jovyan/neural-dsds/neural-dsds/data/valloader_onecat.pth')\n",
    "testloader=torch.load('/home/jovyan/neural-dsds/neural-dsds/data/testloader_onecat.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8e86ce49-c4a1-415d-bd27-22ab5826cfd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def recon_loss(recon_x,x):\n",
    "    mseloss = torch.nn.MSELoss()\n",
    "    mse = mseloss(recon_x,x)\n",
    "\n",
    "    return mse\n",
    "def vae_loss(recon_x,x,mu,logvar):\n",
    "    mseloss = torch.nn.MSELoss()\n",
    "\n",
    "    reconloss = mseloss(recon_x,x)\n",
    "    \n",
    "    kldweight = 1e-6\n",
    "    kldloss = torch.mean(-0.5*torch.sum(1+logvar-mu**2-logvar.exp(),dim=1),dim=0)\n",
    "    \n",
    "    loss = reconloss+kldweight*kldloss\n",
    "    \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "780336db-8333-4bcb-811c-485b0672bec7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a0 = 1 \n",
    "b = 1e0\n",
    "c = 1e2\n",
    "d = 1e0\n",
    "\n",
    "def train(model,dataloader,criterion,device,epoch):\n",
    "    model.train()\n",
    "    \n",
    "    for data in dataloader:\n",
    "        M,dMdt,bin0,bin1coal,bin1condevap,binmag,M1,dM1dt,M2,dM2dt=data\n",
    "        bin1 = bin1coal \n",
    "\n",
    "        bin0 = bin0.to(device)\n",
    "        bin1 = bin1.to(device)\n",
    "        binmag = binmag.to(device)\n",
    "        bs = bin1.size(0)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        normRt0,normRt1,Lit1,Lit1_pred,binmagRt0,binmagRt1,Lit0,mu0,logvar0,mu1,logvar1 = model(torch.Tensor(bin0).float(),\n",
    "                            torch.Tensor(bin1).float(),binmag[:,0:2].float(),binmag[:,2:4].float())\n",
    "\n",
    "        normbin0 = bin0.float()*torch.broadcast_to(binmag[:,0:2].float().unsqueeze(dim=2),(bs,2,35))\n",
    "        normbin1 = bin1.float()*torch.broadcast_to(binmag[:,2:4].float().unsqueeze(dim=2),(bs,2,35))\n",
    "            \n",
    "        Rloss0 = vae_loss(normRt0,normbin0,mu0,logvar0)\n",
    "        Rloss1 = vae_loss(normRt1,normbin1,mu1,logvar1) \n",
    "        \n",
    "        Lloss = recon_loss(Lit1,Lit1_pred)+d*recon_loss((Lit1-Lit0)**2,(Lit1_pred-Lit0)**2)\n",
    "\n",
    "        loss = a0*Rloss0+b*Rloss1+c*Lloss\n",
    "\n",
    "        loss.backward()\n",
    "\n",
    "        optimizer.step()\n",
    "        \n",
    "    return model\n",
    "def test(model,dataloader,criterion,device,val=False):\n",
    "    model.eval()\n",
    "    correct = 0\n",
    "    R0all = 0\n",
    "    R1all = 0\n",
    "    Lall = 0\n",
    "    losstot = 0\n",
    "    recon = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for data in dataloader:\n",
    "            M,dMdt,bin0,bin1coal,bin1condevap,binmag,M1,dM1dt,M2,dM2dt=data\n",
    "            bin1 = bin1coal\n",
    "            bin0 = bin0.to(device)\n",
    "            bin1 = bin1.to(device)\n",
    "            binmag = binmag.to(device)\n",
    "        \n",
    "            bs = bin1.size(0)\n",
    "            normRt0,normRt1,Lit1,Lit1_pred,binmagRt0,binmagRt1,Lit0,mu0,logvar0,mu1,logvar1 = model(torch.Tensor(bin0).float(),\n",
    "                        torch.Tensor(bin1).float(),binmag[:,0:2].float(),binmag[:,2:4].float())\n",
    "            \n",
    "            normbin0 = bin0.float()*torch.broadcast_to(binmag[:,0:2].float().unsqueeze(dim=2),(bs,2,35))\n",
    "            normbin1 = bin1.float()*torch.broadcast_to(binmag[:,2:4].float().unsqueeze(dim=2),(bs,2,35))\n",
    "            \n",
    "            Rloss0 = vae_loss(normRt0,normbin0,mu0,logvar0)\n",
    "            Rloss1 = vae_loss(normRt1,normbin1,mu1,logvar1) \n",
    "            Lloss = recon_loss(Lit1,Lit1_pred)+d*recon_loss((Lit1-Lit0)**2,(Lit1_pred-Lit0)**2)\n",
    "        \n",
    "            lossall = a0*Rloss0+b*Rloss1+c*Lloss\n",
    "            \n",
    "            nn = len(dataloader.dataset)\n",
    "            R0all = R0all+Rloss0\n",
    "            R1all = R1all+Rloss1\n",
    "            Lall = Lall+Lloss\n",
    "            losstot = losstot+lossall\n",
    "            \n",
    "        if val==True:\n",
    "            sched.step(losstot/nn)\n",
    "\n",
    "        return losstot/nn,R0all/nn,R1all/nn,Lall/nn\n",
    "\n",
    "def inference(model,dataloader,device,nlatent,singlecat=True):\n",
    "    model.eval()\n",
    "    dataset = dataloader.dataset\n",
    "\n",
    "    ntargets = nlatent #+2\n",
    "    nmoms = 4\n",
    "    nrates = 3\n",
    "    bs = 500\n",
    "    print(len(dataset))\n",
    "    \n",
    "    pred = np.zeros((len(dataset),ntargets,nrates))\n",
    "    real = np.zeros((len(dataset),ntargets,nrates))\n",
    "    \n",
    "    #[500, 3, 3, 2]) torch.Size([500, 3, 3, 2] \n",
    "    if singlecat:\n",
    "        realM = np.zeros((len(dataset),nmoms,nrates))\n",
    "        realdMdt = np.zeros((len(dataset),nmoms,nrates))\n",
    "    else:\n",
    "        realM = np.zeros((len(dataset),3,3,2))\n",
    "        realdMdt = np.zeros((len(dataset),3,3,2))    \n",
    "    \n",
    "    \n",
    "    realbin1 = np.zeros((len(dataset),2,35))\n",
    "    realbin0 = np.zeros((len(dataset),2,35))\n",
    "    predbin0 = np.zeros((len(dataset),2,35))\n",
    "    predbin1 = np.zeros((len(dataset),2,35))\n",
    " \n",
    "    Lt0= np.zeros((len(dataset),ntargets))\n",
    "    predL = np.zeros((len(dataset),ntargets))\n",
    "    realL = np.zeros((len(dataset),ntargets))\n",
    "\n",
    "    jj = 0\n",
    "    i = 0\n",
    "\n",
    "    for data in dataloader:\n",
    "        M,dMdt,bin0,bin1coal,bin1condevap,binmag,M1,dM1dt,M2,dM2dt=data\n",
    "        bin1 = bin1coal \n",
    "        bin0 = bin0.to(device)\n",
    "        bin1 = bin1.to(device)\n",
    "        binmag = binmag.to(device)\n",
    "        \n",
    "        normRt0,normRt1,Lit1,Lit1_pred,binmagRt0,binmagRt1,Lit0,mu0,logvar0,mu1,logvar1 = model(torch.Tensor(bin0).float(),\n",
    "                        torch.Tensor(bin1).float(),binmag[:,0:2].float(),binmag[:,2:4].float())\n",
    "        bs = normRt0.size(0)\n",
    "        \n",
    "        normbin0 = bin0.float()*torch.broadcast_to(binmag[:,0:2].float().unsqueeze(dim=2),(bs,2,35))\n",
    "        normbin1 = bin1.float()*torch.broadcast_to(binmag[:,2:4].float().unsqueeze(dim=2),(bs,2,35))\n",
    "        \n",
    "        if normRt0 is not(None):\n",
    "            if singlecat:\n",
    "                realM[jj:jj+bs,:,:] = M1.cpu().detach().numpy().reshape(bs,nmoms,nrates)\n",
    "                realdMdt[jj:jj+bs,:,:] = dM1dt.cpu().detach().numpy().reshape(bs,nmoms,nrates)\n",
    "            else:\n",
    "                realM[jj:jj+bs,:,:] = M2.cpu().detach().numpy().reshape(bs,3,3,2)\n",
    "                realdMdt[jj:jj+bs,:,:] = dM2dt.cpu().detach().numpy().reshape(bs,3,3,2)\n",
    "            realbin0[jj:jj+bs,:] = normbin0.cpu().detach().numpy().reshape(bs,2,35)\n",
    "            realbin1[jj:jj+bs,:] = normbin1.cpu().detach().numpy().reshape(bs,2,35)\n",
    "            predbin0[jj:jj+bs,:] = normRt0.cpu().detach().numpy().reshape(bs,2,35)\n",
    "            predbin1[jj:jj+bs,:] = normRt1.cpu().detach().numpy().reshape(bs,2,35)\n",
    "            predL[jj:jj+bs,:] = Lit1_pred.cpu().detach().numpy().reshape(bs,ntargets)\n",
    "            realL[jj:jj+bs,:] = Lit1.cpu().detach().numpy().reshape(bs,ntargets)\n",
    "            Lt0[jj:jj+bs,:] = Lit0.cpu().detach().numpy().reshape(bs,ntargets)\n",
    "            \n",
    "            jj=jj+bs\n",
    "            i = i+1\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    return realM,realdMdt,realbin0,realbin1,predbin0,predbin1,predL,realL,Lt0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db4e4cec-361b-48c6-886d-39be1f3a5e25",
   "metadata": {},
   "source": [
    "## Train the model for 10 random initializations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "68ef3601-e242-4363-94de-0216cd089757",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model n =  0\n",
      "Training model n =  1\n",
      "Training model n =  2\n",
      "Training model n =  3\n",
      "Training model n =  4\n",
      "Training model n =  5\n",
      "Training model n =  6\n",
      "Training model n =  7\n",
      "Training model n =  8\n",
      "Training model n =  9\n"
     ]
    }
   ],
   "source": [
    "n_rep = 10\n",
    "\n",
    "for j in range(0,n_rep):\n",
    "    print(\"Training model n = \",str(j))\n",
    "    init_lr = 1e-3\n",
    "    weight_decay = 1e-3\n",
    "    #total_epochs = 1000\n",
    "\n",
    "    # Learning rate strings so its in the correct format for the filenames\n",
    "    lrval='{:3.0e}'.format(init_lr)[0]\n",
    "    lrexp = '{:3.0e}'.format(init_lr)[4]\n",
    "\n",
    "    model = VAElatentdynamics(n_bins=35,n_latent=3,n_hidden=20)\n",
    "\n",
    "    # Check if there is a gpu\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "    model = model.to(device)\n",
    "\n",
    "    optimizer = torch.optim.AdamW(model.parameters(), lr=init_lr, weight_decay=weight_decay)\n",
    "\n",
    "    sched =  ReduceLROnPlateau(optimizer, 'min')\n",
    "    criterion = torch.nn.MSELoss()\n",
    "    \n",
    "    val_loss_all = []\n",
    "    train_loss_all = []\n",
    "\n",
    "    val_R0_all = []\n",
    "    train_R0_all = []\n",
    "\n",
    "    val_R1_all = []\n",
    "    train_R1_all = []\n",
    "\n",
    "    val_L_all = []\n",
    "    train_L_all = []\n",
    "    \n",
    "    e0 = 0\n",
    "    epochs = 500\n",
    "    best_epoch = 0\n",
    "    \n",
    "    min_loss = 1e10\n",
    "\n",
    "    for epoch in tqdm(range(e0,epochs)):\n",
    "        mod = train(model,trainloader,criterion,device,epoch)\n",
    "        train_loss,train_R0,train_R1,train_L = test(model,trainloader,criterion,device)\n",
    "        val_loss,val_R0,val_R1,val_L = test(model,valloader,criterion,device,val=True)\n",
    "    \n",
    "        train_loss_all.append(train_loss.cpu())\n",
    "        val_loss_all.append(val_loss.cpu())\n",
    "    \n",
    "        train_R0_all.append(train_R0.cpu())\n",
    "        val_R0_all.append(val_R0.cpu())\n",
    "    \n",
    "        train_R1_all.append(train_R1.cpu())\n",
    "        val_R1_all.append(val_R1.cpu())    \n",
    "    \n",
    "        train_L_all.append(train_L.cpu())\n",
    "        val_L_all.append(val_L.cpu())\n",
    "    \n",
    "        if epoch%50==0:\n",
    "            print(f'{epoch:03d}, Train: {train_loss:.8e}, Val.: {val_loss:.8e}')\n",
    "            \n",
    "        if val_loss<min_loss:\n",
    "            bestmodel = model\n",
    "            min_loss = val_loss\n",
    "            best_epoch = epoch\n",
    "    tmp_trainloss = \"LatentDynamicsModels/VAELatentDynamics3var_CNN_n{}_{}epochs_Sigmoid_magnitude_expdynLin_nobias_updatedata_Li_dLdt2_c1e2_losses.npz\".format(j,epochs)\n",
    "    \n",
    "    mod_weights = \"LatentDynamicsModels/VAELatentDynamics3var_CNN_n{}_{}epochs_Sigmoid_magnitude_expdynLin_nobias_updatedata_Li_dLdt2_c1e2\".format(j,epochs)\n",
    "    \n",
    "    print(tmp_trainloss)\n",
    "    print(mod_weights)\n",
    "    print(best_epoch)\n",
    "    \n",
    "    torch.save(bestmodel.state_dict(),mod_weights)\n",
    "    \n",
    "    train_loss_np = np.array(train_loss_all)\n",
    "    val_loss_np = np.array(val_loss_all)\n",
    "    \n",
    "    train_R0_np = np.array(train_R0_all)\n",
    "    val_R0_np = np.array(val_R0_all)\n",
    "    \n",
    "    train_R1_np = np.array(train_R1_all)\n",
    "    val_R1_np = np.array(val_R1_all)\n",
    "    \n",
    "    train_L_np = np.array(train_L_all)\n",
    "    val_L_np = np.array(val_L_all)\n",
    "    \n",
    "    np.savez(tmp_trainloss,trainl=train_loss_np,vall=val_loss_np,trainr0 = train_R0_np, valr0 = val_R0_np, train_r1 = train_R1_np, val_r1 = val_R1_np, train_lin = train_L_np, val_lin = val_L_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f382696a-4e80-47fe-804e-4c3a9973292e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00, 499, Train: 6.92866081e-07, Val.: 7.04305421e-07, Val R0: 3.40603719e-07, Val. R1: 3.39958177e-07, Tr. L: 2.30934175e-10, Val. L: 2.37436404e-10\n",
      "01, 499, Train: 7.66758490e-07, Val.: 7.84807412e-07, Val R0: 3.87104052e-07, Val. R1: 3.86858090e-07, Tr. L: 1.05632822e-10, Val. L: 1.08453226e-10\n",
      "02, 499, Train: 4.51334614e-07, Val.: 4.63983724e-07, Val R0: 2.28044996e-07, Val. R1: 2.27873144e-07, Tr. L: 7.98318911e-11, Val. L: 8.06551770e-11\n",
      "03, 499, Train: 6.19825698e-07, Val.: 6.32519914e-07, Val R0: 3.09316249e-07, Val. R1: 3.08937757e-07, Tr. L: 1.31234176e-10, Val. L: 1.42658496e-10\n",
      "04, 499, Train: 4.17449826e-07, Val.: 4.27494683e-07, Val R0: 2.08905107e-07, Val. R1: 2.08721062e-07, Tr. L: 9.48583434e-11, Val. L: 9.86850532e-11\n",
      "05, 499, Train: 4.40816990e-07, Val.: 4.50609178e-07, Val R0: 2.19768637e-07, Val. R1: 2.19571902e-07, Tr. L: 1.07496692e-10, Val. L: 1.12686679e-10\n",
      "06, 499, Train: 4.31109044e-07, Val.: 4.45230569e-07, Val R0: 2.16828283e-07, Val. R1: 2.16599062e-07, Tr. L: 1.13388944e-10, Val. L: 1.18031654e-10\n",
      "07, 499, Train: 6.67640450e-07, Val.: 6.82850271e-07, Val R0: 3.34909515e-07, Val. R1: 3.35020189e-07, Tr. L: 1.24882049e-10, Val. L: 1.29206285e-10\n",
      "08, 499, Train: 5.61982688e-07, Val.: 5.76404034e-07, Val R0: 2.82955824e-07, Val. R1: 2.83505955e-07, Tr. L: 9.63863295e-11, Val. L: 9.94239621e-11\n",
      "09, 499, Train: 4.95696781e-07, Val.: 5.07487357e-07, Val R0: 2.47646938e-07, Val. R1: 2.47435253e-07, Tr. L: 1.19166441e-10, Val. L: 1.24051325e-10\n"
     ]
    }
   ],
   "source": [
    "val_loss_all = []\n",
    "train_loss_all = []\n",
    "\n",
    "val_R0_all = []\n",
    "train_R0_all = []\n",
    "\n",
    "val_R1_all = []\n",
    "train_R1_all = []\n",
    "\n",
    "val_L_all = []\n",
    "train_L_all = []\n",
    "\n",
    "n_rep = 10\n",
    "epoch = 499\n",
    "epochs = 500\n",
    "for j in range(0,n_rep):\n",
    "    fnloss = \"LatentDynamicsModels/VAELatentDynamics3var_CNN_n{}_{}epochs_Sigmoid_magnitude_expdynLin_nobias_updatedata_Li_dLdt2_c1e2_losses.npz\".format(j,epochs)\n",
    "        \n",
    "    loss = np.load(fnloss)\n",
    "    train_loss_all.append(loss['trainl'])\n",
    "    val_loss_all.append(loss['vall'])\n",
    "    \n",
    "    val_R0_all.append(loss['trainr0'])\n",
    "    train_R0_all.append(loss['valr0'])\n",
    "\n",
    "    val_R1_all.append(loss['train_r1'])\n",
    "    train_R1_all.append(loss['val_r1'])\n",
    "\n",
    "    val_L_all.append(loss['train_lin'])\n",
    "    train_L_all.append(loss['val_lin'])\n",
    "    \n",
    "    trainl = loss['trainl'][-1]\n",
    "    vall = loss['vall'][-1]\n",
    "    valr0 = loss['valr0'][-1]\n",
    "    val_r1 = loss['val_r1'][-1]\n",
    "    train_lin = loss['train_lin'][-1]\n",
    "    val_lin = loss['val_lin'][-1]\n",
    "    \n",
    "    print(f'{j:02d}, {epoch:03d}, Train: {trainl:.8e}, Val.: {vall:.8e}, Val R0: {valr0:.8e}, Val. R1: {val_r1:.8e}, Tr. L: {train_lin:.8e}, Val. L: {val_lin:.8e}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8b7d72ff-68cc-4021-9eff-f3bceb6d9d1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAKACAYAAAAB9u5NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzde3yU5Z3//9c9mUzOCTkQSCAc6gHEEA0Hu1hArIALJVpAsdVFqcCWr9iKWWrFqmVVYBd2+eFKsEBBbD3gAdGuS0BKRbAVhQlUA1Q5R5GDCSEJOUySmfv3xyQThhxIyCQzgffz8ZgHua/7yn1/YK7W+3NfJ8M0TRMREREREZFWsPg7ABERERER6fiUWIiIiIiISKspsRARERERkVZTYiEiIiIiIq2mxEJERERERFpNiYWIiIiIiLSaEgsREREREWk1JRYiIiIiItJqVn8HEOhcLhfffvstUVFRGIbh73BERERERNqNaZqUlJSQnJyMxdJ0n4QSi4v49ttvSUlJ8XcYIiIiIiJ+8/XXX9O9e/cm6yixuIioqCjA/Y8ZHR3t52hERERERNpPcXExKSkpnmfipiixuIja4U/R0dFKLERERETkitScKQGavC0iIiIiIq2mxEJERERERFpNiYWIiIiIiLSaEgsREREREWk1JRYiIiIiItJqSixERERERKTVlFiIiIiIiEirKbEQEREREZFWU2LRiKysLPr168fgwYP9HYqIiIiISMAzTNM0/R1EICsuLiYmJoaioiLtvC0iIiIiV5SWPAurx0JERERERFpNiYWIiIiIiLSaEgsRERHxmREjRjBr1qw2uXZBQQGJiYkcPXq0Ta7va3fddReLFy/2dxhXJLXDOu3ZDpVYiIiIXGEMw2jyM2XKlEu+9jvvvMOzzz7ru2DPs2DBAjIyMujVq5enbPjw4RiGweuvv+5Vd9myZSQmJrZJHOffo3fv3oSGhjJw4EC2b9/udf7pp59m3rx5FBcXt2kcHZXaYevNnTu33r9b165dveq0ZztUYiEiInKFOXHihOezZMkSoqOjvcqef/75er9TWVnZrGvHxcURFRXl65ApLy9n1apVTJs2zVNmmiZ79uwhKSmJdevWedXPyclhwIABPo+j1htvvMGsWbP4zW9+w+7duxk2bBhjxowhLy/PUyctLY1evXrx6quvtlkcHZnaoW9cf/31Xv9uX3zxhdf59myHSixERESuMF27dvV8YmJiPG85zy8bMWIEDz/8MJmZmSQkJDBq1CgANm7cyNChQ+nUqRPx8fGMGzeOQ4cOea594RCUESNG8Mtf/pLHHnuMuLg4unbtyty5c1scc3Z2NlarlSFDhnjKDhw4QElJCU8++STZ2dmUlZV5ztntdgYOHNjyf5xmWrx4MVOnTmXatGlcd911LFmyhJSUFF588UWvenfccUe9t9jipnboG1ar1evfrXPnzvXqtFc7VGIhIiLiI6ZpUlpa6ZdPW6we//LLL2O1WvnrX//K8uXLASgtLSUzM5OdO3eyZcsWLBYL48ePx+VyNXmdiIgIPv30UxYuXMgzzzzD5s2bWxTLtm3bGDRokFeZ3W4nNDSUadOmER0dTXZ2NgAOh4O9e/c2+aZ4/vz5REZGNvm5cGhTrcrKSux2O6NHj/YqHz16NH/729+8ym666SY+++wzHA5Hi/6+rWGaJqVl/vmoHbZfO6x14MABkpOT6d27Nz/5yU84fPhwvTrt1Q6tbXp1ERGRK0hZWRVRUfP9cu+SkieIiLD59JpXX301Cxcu9CqbOHGi1/GqVatITExk3759pKamNnidtLQ0fvvb3wJwzTXXsHTpUrZs2eJ5+9wcR48eJTk52assJyeHtLQ0bDYb48eP5+2332bixIl8/vnnVFVVNfmmeMaMGUyaNKnJe3br1q3B8vz8fJxOJ126dPEq79KlCydPnqx3DYfDwcmTJ+nZs2eT9/OVsnKIGnTxem2hZBdEhPv2mmqHDbdDgO9///v84Q9/4Nprr+XUqVM899xz3Hzzzezdu5f4+Hiva7RHO1RiISIiIg268M0swKFDh3jqqafYsWMH+fn5njfEeXl5TT7QnS8pKYnTp0+3KJby8nJCQ0O9yux2u+dt8IQJE5gwYQIOhwO73U5cXJzX5NoLxcXFERcX16IYLmQYhtexaZr1ysLCwgC8hsdIy6gdNm7MmDGen/v378+QIUO46qqrePnll8nMzPSca692qMRCRETER8LDgykpecJv9/a1iIiIemUZGRmkpKSwcuVKkpOTcblcpKamNjmpNjjYOzbDMJocstKQhIQECgsLvcp2797NvffeC7jH0NtsNjZt2kROTg7p6elNXm/+/PnMn99071J2djbDhg1rMJagoKB6vROnT5+u14tx5swZgAbHvbeV8DB3z4E/hIf5/ppqhw23w4ZERETQv39/Dhw44FXeXu1QiYWIiIiPGIbh8+FIgaSgoID9+/ezfPlyz4POxx9/3C73Tk9P55VXXvEcHz58mLNnz3reFFutVjIyMli3bh25ubmMHDmyyeu1ZgiKzWZj4MCBbN68mfHjx3vKN2/ezJ133ulVNzc3l+7du5OQkNDkvXzJMAyfD0cKJGqHjXM4HOzfv79eItJe7VCJhYiIiDRLbGws8fHxrFixgqSkJPLy8nj88cfb5d633347c+bMobCwkNjYWOx2OzabzWvYy8SJE5k8eTJlZWU89thjTV6vtUNQMjMzmTx5MoMGDWLIkCGsWLGCvLw8ZsyY4VVv+/bt9SZ5S+uoHdaZPXs2GRkZ9OjRg9OnT/Pcc89RXFzMAw884FWvvdqhVoUKYEVFFfzmN1t48skt/g5FREQEi8XC2rVrsdvtpKam8uijj7Jo0aJWX3fNmjX15iZcqH///gwaNIg333wTcE+YTU1NxWar6yEaNWoUTqeTysrKNt874J577mHJkiU888wz3HjjjWzbto0NGzZ4TYytqKhg/fr1TJ8+vU1judKoHdb55ptv+OlPf0qfPn2YMGECNpuNHTt2+K0dGmZbrAt2GSkuLiYmJoaioiKio6Pb9d65uafo39+9HrZpzm3Xe4uIiLSXuXPnsnXrVrZu3dpkvQ0bNjB79mxyc3OxWAL/3WhWVhbvvfceH3zwgb9DkWZQO2xYS56FNRQqgJ2fNLtcrg7ReEVERFpq06ZNDe6yfKGxY8dy4MABjh8/TkpKSjtE1jrBwcG88MIL/g5DmkntsPXUY3ER/uyxOHCggGuvdTcEh+NJbDblgSIiIiLSflryLHxFvAJ///336dOnD9dccw2///3v/R1Os9lsdV9PZaXTj5GIiIiIiDTtsn8FXl1dTWZmJh9++CHR0dEMGDCACRMmtHpTnPYQHBzk+VmJhYiIiIgEssu+x+Kzzz7j+uuvp1u3bkRFRTF27Fg2bdrk77CaxWZTYiEiIiIiHUPAJxbbtm0jIyOD5ORkDMPg3XffrVdn2bJl9O7dm9DQUAYOHMj27ds957799luvjUW6d+/O8ePH2yP0VgsJqetQcjiUWIiIiIhI4Ar4xKK0tJQbbriBpUuXNnj+jTfeYNasWfzmN79h9+7dDBs2jDFjxpCXlwdAQ3PTL7ZGcaAICanrsaiubtmW8yIiIiIi7SngE4sxY8bw3HPPMWHChAbPL168mKlTpzJt2jSuu+46lixZQkpKCi++6N7/oVu3bl49FN988w1JSUntErsvGIb7ExVlu3hlERERERE/CfjEoimVlZXY7fZ6W5SPHj2av/3tbwDcdNNN5Obmcvz4cUpKStiwYQO33357o9d0OBwUFxd7ffzl5MlzmCaYJjidWhVYRERERAJXh04s8vPzcTqddOnSxau8S5cunDx5EgCr1cp///d/c+utt5Kens6vfvUr4uPjG73mggULiImJ8Xz8ufFJcbHD87PTqaFQIiIiIhK4OnRiUevCOROmaXqV3XHHHXz11VccPHiQf/3Xf23yWnPmzKGoqMjz+frrr9sk5uY4f/L2N98U+S0OEREREZGL6dCJRUJCAkFBQZ7eiVqnT5+u14vRXCEhIURHR3t9/OX8ydtnzlT4LQ4REZHGjBgxglmzZrX6OgUFBSQmJnL06NFWX6s93HXXXSxevNjfYUgNtcPA0KETC5vNxsCBA9m8ebNX+ebNm7n55ptbde2srCz69evH4MGDW3Wd1jh/H4vS0kq/xSEiIpeXjIwMRo4c2eC5Tz75BMMwyMnJadeYFixYQEZGBr169fKUDR8+HMMweP31173qLlu2jMTExDaNp6ml7AGefvpp5s2b59e5mB2d2mHT5s6di2EYXp+uXbt61Qm0dhjwicW5c+fYs2cPe/bsAeDIkSPs2bPHs5xsZmYmv//971m9ejX79+/n0UcfJS8vjxkzZrTqvjNnzmTfvn3s3LmztX+FSxYaWjcUqqysym9xiIjI5WXq1Kn85S9/4dixY/XOrV69mhtvvJEBAwa0Wzzl5eWsWrWKadOmecpM02TPnj0kJSWxbt06r/o5OTltGt/FlrIHSEtLo1evXrz66qttFsflTu3w4q6//npOnDjh+XzxxRde5wOtHQZ8YrFr1y7S09NJT08H3IlEeno6Tz/9NAD33HMPS5Ys4ZlnnuHGG29k27ZtbNiwgZ49e/ozbJ84P7EoL6/2YyQiInI5GTduHImJiaxZs8arvKysjDfeeIOpU6cCsHHjRoYOHUqnTp2Ij49n3LhxHDp0yOfxZGdnY7VaGTJkiKfswIEDlJSU8OSTT5KdnU1ZWZnnnN1uZ+DAgT6Po9bFlrKvdccdd9R7iy3Np3Z4cVarla5du3o+nTt3rlcnkNphwCcWI0aMwDTNep/zG+FDDz3E0aNHcTgc2O12hg8f7r+Afej8oVBKLERExFesViv3338/a9as8dpI9q233qKyspL77rsPcG9Sm5mZyc6dO9myZQsWi4Xx48fjcvl2pcJt27YxaNAgrzK73U5oaCjTpk0jOjqa7OxswL0s/N69e5t8Uzx//nwiIyOb/Fw4tKlWc5ayr3XTTTfx2Wef4XA4kJZTO2y8HdY6cOAAycnJ9O7dm5/85CccPny4Xp1AaofWi1e5MmVlZZGVlYXT6fRbDBZLXd7n6//xiIhI22lqXlxQkEFoaHCz6losBmFhF68bEdHyTVQffPBBFi1axNatW7n11lsB9/CTCRMmEBsbC8DEiRO9fmfVqlUkJiayb98+UlNTW3zPxhw9epTk5GSvspycHNLS0rDZbIwfP563336biRMn8vnnn1NVVdXkm+IZM2YwadKkJu/ZrVu3Bsubs5T9+ddwOBycPHkyIEdKlJY1vgdWUBCEhhjNqmuxQFjoxetGhBsNljdF7bDhdgjw/e9/nz/84Q9ce+21nDp1iueee46bb76ZvXv3em2dEEjtUIlFI2bOnMnMmTMpLi4mJibG3+EQFBTwnUsiIlIjKmp+o+fGjr2G99+/z3PcpcuiRufR3XJLLz78cIrnuHfvJeTnl9Wr53LNbXGMffv25eabb2b16tXceuutHDp0iO3bt/PBBx946hw6dIinnnqKHTt2kJ+f73nJlZeX59MHuvLyckJDQ73K7Ha7523whAkTmDBhgmdkQlxcnNfk2gvFxcURFxfXqpgutpQ9QFhYGIDX8JhAEjWo8XNjh8P7v6s77jIMysobrnvLYPjw5brj3qMgv7B+Pde+lseodti4MWPGeH7u378/Q4YM4aqrruLll18mMzPTcy6Q2qGeVgNc7f+HpaT4P7kREZHLy9SpU1m3bh3FxcW89NJL9OzZk9tuu81zPiMjg4KCAlauXMmnn37Kp59+CriHC/lSQkIChYXeT6q7d+/2vA0eMWIENpuNTZs2kZOT45l32ZjWDEFpyVL2Z86cAWhw3Ls0n9ph80RERNC/f38OHDjgVR5I7VA9FgHOMAxM06S8XKtCiYh0FCUlTzR6LijI+633qVO/arSuxeJd98iRWa2K60KTJk3ikUce4bXXXuPll19m+vTpnrfyBQUF7N+/n+XLlzNs2DAAPv74Y5/ev1Z6ejqvvPKK5/jw4cOcPXvW86bYarWSkZHBunXryM3NbXSJ0lqtGYJy/lL248eP95Rv3ryZO++806tubm4u3bt3JyEhocl7+UvJrsbPBQV5H59q4vnWcsFr6CObG653qdQOm8fhcLB//37Pv0OtQGqHSiwC2PFiJ645U8GEr78+4u9wRESkmVoy56Gt6jZHZGQk99xzD0888QRFRUVMmTLFcy42Npb4+HhWrFhBUlISeXl5PP74401eb+nSpaxfv54tW7a0KI7bb7+dOXPmUFhYSGxsLHa7HZvN5jXMZeLEiUyePJmysjIee+yxJq/X2iEomZmZTJ48mUGDBjFkyBBWrFjR4FL227dvrzfJO5C0ZM5DW9VtDrXDhs2ePZuMjAx69OjB6dOnee655yguLuaBBx7wqhdI7VBDoRoRCBvkffGPAuiRDD2TOHbsrN/iEBGRy9fUqVMpLCxk5MiR9OjRw1NusVhYu3Ytdrud1NRUHn30URYtWtTktfLz8+stA7pmzZp6cxMu1L9/fwYNGsSbb74JuCfMpqamYrPVJVKjRo3C6XRSWVnZ5nsHNGcp+4qKCtavX8/06dPbNJYrhdphfd988w0//elP6dOnDxMmTMBms7Fjx46AboeGef76XlJP7eTtoqIioqOj2/Xe/7crn3G73Znu3VvW8ebau9v1/iIiIq01d+5ctm7dytatW5ust2HDBmbPnk1ubq7XqoiBKisri/fee89rkrEELrXDS9eSZ2ENhQpgUWF1AyDPVWq5WRER6Xg2bdrE888/f9F6Y8eO5cCBAxw/fpyUlJR2iKx1goODeeGFF/wdhjST2mH7UI/FRfizx2L3oWIG/CUSgBF/eosP//eedr2/iIiIiFzZWvIsHPh9PFewmIi6DqVy/+3TJyIiIiJyUUosGhEIk7djw+sSC4cSCxEREREJYEosGjFz5kz27dvHzp07/RZD5HlzLExrUBM1RURERET8S4lFALNa674ea7hv1y4XEREREfElJRYB7Gg+ULMYVK9uUX6NRURERESkKUosAlhJBVCzZpezosqvsYiIiIiINEWJRQALDsLTY3Hs+Dm/xiIiIiIi0hQlFgHs/PnaJ4qq/ReIiIiIiMhFKLFoRCAsNxscBAS7fy6N0BwLEREREQlcSiwaEQjLzVot1M2xsGi5WREREREJXEosAlipAXwP6K19LEREpGMYMWIEs2bNapNrFxQUkJiYyNGjR9vk+r521113sXjxYn+HcUVSO6zTnu1QiUUAKzCBLu6Py2K9WHUREZFmMQyjyc+UKVMu+drvvPMOzz77rO+CPc+CBQvIyMigV69enrLhw4djGAavv/66V91ly5aRmJjYJnEAbNu2jYyMDJKTkzEMg3fffbdenaeffpp58+ZRXFzcZnF0ZGqHvnH8+HH+5V/+hfj4eMLDw7nxxhux2+2e8+3ZDpVYBDDbeblEtUVflYiI+MaJEyc8nyVLlhAdHe1V9vzzz9f7ncrKymZdOy4ujqgo388LLC8vZ9WqVUybNs1TZpome/bsISkpiXXr1nnVz8nJYcCAAT6Po1ZpaSk33HADS5cubbROWloavXr14tVXX22zODoytcPWKyws5Ac/+AHBwcFkZ2ezb98+/vu//5tOnTp56rRnO9TTagCLOC+xMGz6qkRExDe6du3q+cTExGAYRr2yESNG8PDDD5OZmUlCQgKjRo0CYOPGjQwdOpROnToRHx/PuHHjOHTokOfaFw5BGTFiBL/85S957LHHiIuLo2vXrsydO7fFMWdnZ2O1WhkyZIin7MCBA5SUlPDkk0+SnZ1NWVmZ55zdbmfgwIEt/8dppjFjxvDcc88xYcKEJuvdcccd9d5ii5vaYev953/+JykpKbz00kvcdNNN9OrVi9tuu42rrrrKq157tUM9rQaw0PO+naBQm/8CERGRK9LLL7+M1Wrlr3/9K8uXLwfcb+ozMzPZuXMnW7ZswWKxMH78eFwuV5PXiYiI4NNPP2XhwoU888wzbN68uUWxbNu2jUGDBnmV2e12QkNDmTZtGtHR0WRnZwPgcDjYu3dvk2+K58+fT2RkZJOf7du3tyjGhtx000189tlnOByOVl/rSqV22Hg7/NOf/sSgQYO4++67SUxMJD09nZUrV9ar117tUAP3A1jIeYlFdIj/4hARkeYxTZOysiq/3Ds8PBjDMHx6zauvvpqFCxd6lU2cONHreNWqVSQmJrJv3z5SU1MbvE5aWhq//e1vAbjmmmtYunQpW7Zs8bx9bo6jR4+SnJzsVZaTk0NaWho2m43x48fz9ttvM3HiRD7//HOqqqqafFM8Y8YMJk2a1OQ9u3Xr1uz4mrqGw+Hg5MmT9OzZs9XXaw7TNClr3oghnwu3oXbYju3w8OHDvPjii2RmZvLEE0/w2Wef8ctf/pKQkBDuv/9+r2u0RztUYtGIrKwssrKycDqdfovh/NFPrirTb3GIiEjzlJVVERU13y/3Lil5gogI3/ZuX/hmFuDQoUM89dRT7Nixg/z8fM8b4ry8vCYf6M6XlJTE6dOnWxRLeXk5oaGhXmV2u93zNnjChAlMmDABh8OB3W4nLi7Oa3LtheLi4oiLi2tRDJciLCwMwGt4TFsrq4So/9dut/NS8iJE+PhlqNph41wuF4MGDWL+fPf/76Snp7N3715efPFFr8SivdqhhkI1IhD2sTj/Pw/nKhvv2hMREWkLERER9coyMjIoKChg5cqVfPrpp3z66adA05Nqg4ODvY4Nw2hyyEpDEhISKCws9CrbvXu3523wiBEjsNlsbNq0iZycHNLT05u8XnsNhTpz5gwAnTt3bvW1rlRqh423w6SkJPr16+dVdt1115GXl+dV1l7tUD0WAez8oVCOkODGK4qISEAIDw+mpOQJv927rRUUFLB//36WL1/OsGHDAPj444/b/L7gfhP7yiuveI4PHz7M2bNnPW+KrVYrGRkZrFu3jtzcXEaOHNnk9dprKFRubi7du3cnISGh1ddqrnCbu+fAH8LbYUqo2mGdH/zgB3z55ZdeZV999VW94U7t1Q6VWAQw2/lDFGM6+SsMERFpJsMwfD4cKZDExsYSHx/PihUrSEpKIi8vj8cff7xd7n377bczZ84cCgsLiY2NxW63Y7PZvIa9TJw4kcmTJ1NWVsZjjz3W5PVaOwTl3LlzHDx40HN85MgR9uzZQ1xcHD169PCUb9++ndGjR1/yfS6FYRg+H44USNQO6zz66KPcfPPNzJ8/n0mTJvHZZ5+xYsUKVqxY4VWvvdqhhkIFsOPHz5u5H6wcUERE/MtisbB27Vrsdjupqak8+uijLFq0qNXXXbNmzUUn/Pbv359Bgwbx5ptvAu4Js6mpqdhsdYncqFGjcDqdVFZWtuneAQC7du0iPT3dM9QlMzOT9PR0nn76aU+diooK1q9fz/Tp09s0liuN2mGdwYMHs379el5//XVSU1N59tlnWbJkCffdd5+nTnu2Q8M0Tc0KbkJxcTExMTEUFRURHR3drvfOzT1Hf1c4GMAbxzGfS2nX+4uIiLSHuXPnsnXrVrZu3dpkvQ0bNjB79mxyc3OxdICNY7Oysnjvvff44IMP/B2KNIPaYcNa8iys1+ABLCTEAhU1B+H6qkRE5PK0adOmBndZvtDYsWM5cOAAx48fJyUl8F+2BQcH88ILL/g7DGkmtcPWU4/FRfizx+Lrryvocbama23Td5izu7Tr/UVERETkytaSZ+HA77+5goWFnb/1tm83mxERERER8SUlFgEsNPS8r8eqr0pEREREApeeVhuRlZVFv379GDx4sN9iOD+xMBxVfotDRERERORilFg0IhB23rae30vh0lAoEREREQlcSiwCXc3UetOixEJEREREApcSi44iRF+ViIiIiAQuPa0Gutp9LKxhfg1DRERERKQpSiwCXe0uI1puVkREREQCmBKLAHbSrCJl4FekXPcVWIL8HY6IiIiISKOs/g5AGmcBDEtNl0WkeixEREREJHCpxyKAleCqO7CZjVcUERHxkxEjRjBr1qxWX6egoIDExESOHj3a6mu1h7vuuovFixf7OwypoXYYGJRYBLBQ6nopDKsSCxER8Y2MjAxGjhzZ4LlPPvkEwzDIyclp15gWLFhARkYGvXr18pQNHz4cwzB4/fXXveouW7aMxMTENotl27ZtZGRkkJycjGEYvPvuu/XqPP3008ybN4/i4uI2i+Nyp3Z4ccePH+df/uVfiI+PJzw8nBtvvBG73e45H2jtUIlFAAs97+sxgpVYiIiIb0ydOpW//OUvHDt2rN651atXc+ONNzJgwIB2i6e8vJxVq1Yxbdo0T5lpmuzZs4ekpCTWrVvnVT8nJ6dN4ystLeWGG25g6dKljdZJS0ujV69evPrqq20Wx+VO7bBphYWF/OAHPyA4OJjs7Gz27dvHf//3f9OpUydPnUBrh0osAljY+T0WOP0YiYiIXE7GjRtHYmIia9as8SovKyvjjTfeYOrUqQBs3LiRoUOH0qlTJ+Lj4xk3bhyHDh3yeTzZ2dlYrVaGDBniKTtw4AAlJSU8+eSTZGdnU1ZW5jlnt9sZOHCgz+OoNWbMGJ577jkmTJjQZL077rij3ltsaT61w6b953/+JykpKbz00kvcdNNN9OrVi9tuu42rrrrKq14gtUMlFgHs/B4Li+FqoqaIiASS0tLKRj8VFVXNrlte3ry6LWW1Wrn//vtZs2YNplnXI/7WW29RWVnJfffdV3O/UjIzM9m5cydbtmzBYrEwfvx4XC7f/jdp27ZtDBo0yKvMbrcTGhrKtGnTiI6OJjs7GwCHw8HevXubfFM8f/58IiMjm/xs37691XHfdNNNfPbZZzgcjlZfqy2UOsxGPxVVZrPrllc2r25LqR023Q7/9Kc/MWjQIO6++24SExNJT09n5cqV9eoFUjvUqlABzGIYdftY2PwaioiItEBU1PxGz40dew3vv3+f57hLl0WUlVU1WPeWW3rx4YdTPMe9ey8hP7+sXj2Xa26LY3zwwQdZtGgRW7du5dZbbwXcw08mTJhAbGwsABMnTvT6nVWrVpGYmMi+fftITU1t8T0bc/ToUZKTk73KcnJySEtLw2azMX78eN5++20mTpzI559/TlVVVZNvimfMmMGkSZOavGe3bt1aHXe3bt1wOBycPHmSnj17tvp6vhb1/xo/NzYN3p9Vd9zlEShrJEe9pQ98+Ou6496/gvxz9eu5Vrc8RrXDxtvh4cOHefHFF8nMzOSJJ57gs88+45e//CUhISHcf//9XtcIlHaoxKIRWVlZZGVl4XQGxhAki+ZYiIiID/Xt25ebb76Z1atXc+utt3Lo0CG2b9/OBx984Klz6NAhnnrqKXbs2EF+fr7nDXFeXp5PH+jKy8sJDQ31KrPb7Z63wRMmTGDChAk4HA7sdjtxcXFek2svFBcXR1xcnM/ia0xYWBiA1/AYaRm1w8a5XC4GDRrE/PnuFxXp6ens3buXF1980SuxCKR2qMSiETNnzmTmzJkUFxcTExPjtzhMEwwDzCp9VSIiHUVJyRONngsK8t6X6NSpXzVa12LxrnvkyKxWxXWhqVOn8vDDD5OVlcVLL71Ez549ue222zznMzIySElJYeXKlSQnJ+NyuUhNTaWysuXDr5qSkJBAYWGhV9nu3bu59957AfdSojabjU2bNpGTk0N6enqT15s/f77nYawx2dnZDBs2rFVxnzlzBoDOnTu36jptpeTFxs8FXTAY/tTzjde9oBlyZNGlx9QQtcOG22FSUhL9+vXzKrvuuuvqTSIPpHaop9UAZ1YFYdicmE5NhxER6SgiIpo/frWt6jbHpEmTeOSRR3jttdd4+eWXmT59OobhfoosKChg//79LF++3PPg8/HHH/v0/rXS09N55ZVXPMeHDx/m7NmznjfFVquVjIwM1q1bR25ubqNLlNZqr6FQubm5dO/enYSEhFZfqy1EhDR/c922qtscaocN+8EPfsCXX37pVfbVV1/VG+4USO1QiUUAKypyYdrc/8Py7MAtIiLiI5GRkdxzzz088cQTFBUVMWXKFM+52NhY4uPjWbFiBUlJSeTl5fH44483eb2lS5eyfv16tmzZ0qI4br/9dubMmUNhYSGxsbHY7XZsNpvXMJeJEycyefJkysrKeOyxx5q8XmuHoJw7d46DBw96jo8cOcKePXuIi4ujR48envLt27czevToS76PuKkdNuzRRx/l5ptvZv78+UyaNInPPvuMFStWsGLFCq96gdQO9Ro8gB05AqZZ81YgXKtCiYiI702dOpXCwkJGjhzp9dBssVhYu3Ytdrud1NRUHn30URYtanoMTH5+fr1lQNesWeN5+9yY/v37M2jQIN58803APWE2NTUVm62uh2bUqFE4nU4qKyvbfG+DXbt2kZ6e7hnqkpmZSXp6Ok8//bSnTkVFBevXr2f69OltGsuVQu2wvsGDB7N+/Xpef/11UlNTefbZZ1myZIlntSwIvHZomOev7yX11M6xKCoqIjo6ul3vvXevi7F9vwQDznzVmZK+/u/iEhERaYm5c+eydetWtm7d2mS9DRs2MHv2bHJzc7FYAv+9Z1ZWFu+9957XJGMJXGqHl64lz8IaChXAQkLqfjYCv22LiIjUs2nTJp5/vomZwTXGjh3LgQMHOH78OCkpKe0QWesEBwfzwgsv+DsMaSa1w/ahHouL8GePxbFjLoZ1+wrDYnL2SAJFV/l/tr+IiIiIXDla8iys9+AB7LwhfRjaeVtEREREApgSiwBms1G383aQOpZEREREJHApsQhg7h6LuuVmNWpNRERERAKVEosAFhLi3nkbwDBMqqud/g1IRERERKQRSiwCmNVq4KoIAsB0WKioqPZzRCIiIiIiDVNiEcAsFoOqQveas9VlNiUWIiIiIhKwlFgEONNVN8fiXLmGQomIiIhIYFJiEcAO5ZmYQTUHNpNiJRYiIiIiEqCUWASwsnIIiasAIDSujMJSDYUSERERkcCkxCKAea0KZTE5V6lN8kREREQkMF0RicX48eOJjY3lrrvu8ncoLRISDNTMscAwsYaF+DUeERGRixkxYgSzZs1qk2sXFBSQmJjI0aNH2+T6vnbXXXexePFif4dxRVI7rNOe7fCKSCx++ctf8oc//MHfYbSYu8eiZvK2YVJdqTkWIiLSeoZhNPmZMmXKJV/7nXfe4dlnn/VdsOdZsGABGRkZ9OrVy1M2fPhwDMPg9ddf96q7bNkyEhMT2ySO2lgGDx5MVFQUiYmJ/PjHP+bLL7/0qvP0008zb948iouL2yyOjkztsPV69erV4L/dzJkzPXXasx1eEYnFrbfeSlRUlL/DaLGQYKB2s22LicWpORYiItJ6J06c8HyWLFlCdHS0V9nzzz9f73cqKyubde24uLg2+W9ueXk5q1atYtq0aZ4y0zTZs2cPSUlJrFu3zqt+Tk4OAwYM8HkctT766CNmzpzJjh072Lx5M9XV1YwePZrS0lJPnbS0NHr16sWrr77aZnF0ZGqHrbdz506vf7PNmzcDcPfdd3vqtGc79HtisW3bNjIyMkhOTsYwDN599916dZYtW0bv3r0JDQ1l4MCBbN++vf0D9YNQ23nLzRpw8PBZ/wYkIiKXha5du3o+MTExGIZRr2zEiBE8/PDDZGZmkpCQwKhRowDYuHEjQ4cOpVOnTsTHxzNu3DgOHTrkufaFQ1BGjBjBL3/5Sx577DHi4uLo2rUrc+fObXHM2dnZWK1WhgwZ4ik7cOAAJSUlPPnkk2RnZ1NWVuY5Z7fbGThwYMv/cZpp48aNTJkyheuvv54bbriBl156iby8POx2u1e9O+64o95bbHFTO2y9zp07e/2bvf/++1x11VXccsstXvXaqx36PbEoLS3lhhtuYOnSpQ2ef+ONN5g1axa/+c1v2L17N8OGDWPMmDHk5eV56gwcOJDU1NR6n2+//ba9/hptwmbDa47FqTMVfo1HRESaZpompaWVfvmYtat9+NDLL7+M1Wrlr3/9K8uXLwfc/93OzMxk586dbNmyBYvFwvjx43G5Gl9g5OWXXyYiIoJPP/2UhQsX8swzz3jerDbXtm3bGDRokFeZ3W4nNDSUadOmER0dTXZ2NgAOh4O9e/c2+aZ4/vz5REZGNvlpyYvMoqIiwP2m/Hw33XQTn332GQ6Ho9nXai3TNCmt8s9H7dB/7bCyspJXXnmFBx98EMMwvM61Vzu0tunVm2HMmDGMGTOm0fOLFy9m6tSpni6nJUuWsGnTJl588UUWLFgAUO/tQGs4HA6vf3R/josMCjJwFQVBPJhVFg6X+j0PFBGRJpSVVREVNd8v9y4peYKICJtPr3n11VezcOFCr7KJEyd6Ha9atYrExET27dtHampqg9dJS0vjt7/9LQDXXHMNS5cuZcuWLZ63z81x9OhRkpOTvcpycnJIS0vDZrMxfvx43n77bSZOnMjnn39OVVVVk2+KZ8yYwaRJk5q8Z7du3ZoVm2maZGZmMnTo0Hr/Bt26dcPhcHDy5El69uzZrOu1Vlk1RL3cLreqp+QBiAj27TXVDpvXDt99913Onj3b4NyU9mqHfk8smlJZWYndbufxxx/3Kh89ejR/+9vf2uSeCxYs4N///d/b5NqXwvFtKGHfO0d1mY1ShyZvi4hI+7nwzSzAoUOHeOqpp9ixYwf5+fmeN8R5eXlNPtCdLykpidOnT7colvLyckJDQ73K7Ha7523whAkTmDBhAg6HA7vdTlxcnNfk2gvFxcXV6124VA8//DCff/45H3/8cb1zYWFhAF7DY6Rl1A6bZ9WqVYwZM6Ze4gPt1w4DOrHIz8/H6XTSpUsXr/IuXbpw8uTJZl/n9ttvJycnh9LSUrp378769esZPHhwg3XnzJlDZmam57i4uJiUlJRL+wv4gFld05VlMSl1+L57UUREfCc8PJiSkif8dm9fi4iIqFeWkZFBSkoKK1euJDk5GZfLRWpqapOTaoODvWMzDKPJISsNSUhIoLCw0Kts9+7d3HvvvYB7DL3NZmPTpk3k5OSQnp7e5PXmz5/P/PlN9y5lZ2czbNiwJuv84he/4E9/+hPbtm2je/fu9c6fOXMGcI+Fby/hVnfPgT+Et8GTpdrhxdvhsWPH+POf/8w777zT4Pn2aocBnVjUunCcmGma9cqasmnTpmbXDQkJISQkgPaLsNVM3rZCebUSCxGRQGYYhs+HIwWSgoIC9u/fz/Llyz0POg29pW8L6enpvPLKK57jw4cPc/bsWc+bYqvVSkZGBuvWrSM3N5eRI0c2eb3WDkExTZNf/OIXrF+/nq1bt9K7d+8G6+Xm5tK9e3cSEhKavJcvGYbh8+FIgUTtsL6XXnqJxMREfvSjHzV4vr3aYUAnFgkJCQQFBdXrnTh9+nS9XozLVXBX94TtkKhyKqqUWIiIiP/ExsYSHx/PihUrSEpKIi8vr95w5bZy++23M2fOHAoLC4mNjcVut2Oz2byGvUycOJHJkydTVlbGY4891uT1WjsEZebMmbz22mu89957REVFeZ5VYmJiPMNOALZv387o0aMv+T5Sn9qhN5fLxUsvvcQDDzyA1drwo317tcOAng1ss9kYOHBgvRn7mzdv5uabb27Te2dlZdGvX79Gh0y1m9oeOsOkKrC/LhERucxZLBbWrl2L3W4nNTWVRx99lEWLFrX6umvWrLnoSIT+/fszaNAg3nzzTcA9YTY1NRWbra6HaNSoUTidTiorK9t07wCAF198kaKiIkaMGEFSUpLn88Ybb3jqVFRUsH79eqZPn96msVxp1A69/fnPfyYvL48HH3ywwfPt2Q4Nsy3WBWuBc+fOcfDgQcDdvbR48WJuvfVW4uLi6NGjB2+88QaTJ0/md7/7HUOGDGHFihWsXLmSvXv3tsvqCsXFxcTExFBUVER0dHSb3+9C8fu/JbJPES6nhcR/r8L+XMMTkkRERDqquXPnsnXrVrZu3dpkvQ0bNjB79mxyc3OxWAL/ZVtWVhbvvfceH3zwgb9DkWZQO2xYS56F/T4UateuXdx6662e49qJ0w888ABr1qzhnnvuoaCggGeeeYYTJ06QmprKhg0b2m3JNn8znXWZc2xo4DdeERGRltq0aVODuyxfaOzYsRw4cIDjx4/7dWGV5goODuaFF17wdxjSTGqHref3HotA5+8ei9jPTxKdWojpsjDw2XOs//e2271RREREROR8LXkW1ivwRgTKHAvPcrOYfPNtiV9jERERERFpjBKLRsycOZN9+/axc+dOv8ZRl1jAd2cq/BiJiIiIiEjjlFgEONdp91dkugzOxrXf5joiIiIiIi2hxCLAOY+7t413VVlxNX9PQBERERGRdqXEIsC5qmp+sJg4TWUWIiIiIhKYlFg0ImAmb9vcX5FhMXFdZNMWERERERF/UWLRiECZvB2U4O6yCAquxmXo6xIRERGRwKQn1QBnOs47UIeFiIiIiAQoJRYBznTUfUUWq983ShcRERERaZASiwBnOuq6KcJMpx8jERERERFpnBKLRgTM5G1X3VcUUljkx0hERETqGzFiBLNmzWr1dQoKCkhMTOTo0aOtvlZ7uOuuu1i8eLG/w5AaaoeBQYlFIwJl8rZZUddjUVJe7cdIRETkcpGRkcHIkSMbPPfJJ59gGAY5OTntGtOCBQvIyMigV69enrLhw4djGAavv/66V91ly5aRmJjYprEMHjyYqKgoEhMT+fGPf8yXX37pVefpp59m3rx5FBcXt1kclzu1w6b16tULwzDqfWbOnOmpE2jtUIlFgHNV1iUWFWgolIiItN7UqVP5y1/+wrFjx+qdW716NTfeeCMDBgxot3jKy8tZtWoV06ZN85SZpsmePXtISkpi3bp1XvVzcnLaNL6PPvqImTNnsmPHDjZv3kx1dTWjR4+mtLTUUyctLY1evXrx6quvtlkclzu1w6bt3LmTEydOeD6bN28G4O677/bUCbR2qMQiwAXn131FZt/ufoxEREQuF+PGjSMxMZE1a9Z4lZeVlfHGG28wdepUADZu3MjQoUPp1KkT8fHxjBs3jkOHDvk8nuzsbKxWK0OGDPGUHThwgJKSEp588kmys7MpKyvznLPb7QwcONDncdTauHEjU6ZM4frrr+eGG27gpZdeIi8vD7vd7lXvjjvuqPcWW5pP7bBpnTt3pmvXrp7P+++/z1VXXcUtt9ziVS+Q2qESiwBnKws67yio0XoiIhI4SksrG/1UVFQ1u255efPqtpTVauX+++9nzZo1mKbpKX/rrbeorKzkvvvuq7lfKZmZmezcuZMtW7ZgsVgYP348LpfrEv5VGrdt2zYGDRrkVWa32wkNDWXatGlER0eTnZ0NgMPhYO/evU2+KZ4/fz6RkZFNfrZv397s+IqK3HMc4+LivMpvuukmPvvsMxwOR0O/5nelVWajn4pqs9l1y5tZt6XUDpvfDisrK3nllVd48MEHMS7YMDmQ2qHWLw105//3wqrEQkSkI4iKmt/oubFjr+H99+/zHHfpsoiysqoG695ySy8+/HCK57h37yXk55fVq+dyzW1xjA8++CCLFi1i69at3HrrrYB7+MmECROIjY0FYOLEiV6/s2rVKhITE9m3bx+pqaktvmdjjh49SnJysldZTk4OaWlp2Gw2xo8fz9tvv83EiRP5/PPPqaqqavJN8YwZM5g0aVKT9+zWrVuzYjNNk8zMTIYOHVrv79ytWzccDgcnT56kZ8+ezbpee4p6ufFzY1Pg/dvrjru8CmWNTOW8JQk+/FHdce83IL+ifj3XtPplF6N22Lx2+O6773L27FmmTJnS4DUCpR0qsQhw5aZBrGmAYWIEa4c8ERHxjb59+3LzzTezevVqbr31Vg4dOsT27dv54IMPPHUOHTrEU089xY4dO8jPz/e8Ic7Ly/PpA115eTmhoaFeZXa73fM2eMKECUyYMAGHw4HdbicuLs5rcu2F4uLi6vUuXKqHH36Yzz//nI8//rjeubCwMACv4THSMmqHzbNq1SrGjBlTL/GBwGqHSiwakZWVRVZWFk6nfydMO62A4e4etMb6NRQREWmmkpInGj0XFOT9kujUqV81Wtdi8a575MisVsV1oalTp/Lwww+TlZXFSy+9RM+ePbnttts85zMyMkhJSWHlypUkJyfjcrlITU2lsrLlw6+akpCQQGFhoVfZ7t27uffeewH3UqI2m41NmzaRk5NDenp6k9ebP38+8+c33msE7vH0w4YNa7LOL37xC/70pz+xbds2unevP8/xzJkzgHssfCAqeaDxcxc0Q07d13A9gAuaIUfuufSYGqJ22HQ7PHbsGH/+85955513GjwfSO1QiUUjZs6cycyZMykuLiYmJsZvcQSV1/1shKrHQkSkI4iIsPm9bnNMmjSJRx55hNdee42XX36Z6dOne8ZvFxQUsH//fpYvX+558Gnorb0vpKen88orr3iODx8+zNmzZz1viq1WKxkZGaxbt47c3NxGlyit1dohKKZp8otf/IL169ezdetWevfu3WC93NxcunfvTkJCQpP38peIFox0aKu6zaF22LSXXnqJxMREfvSjHzV4PpDaoRKLAGec12FiBPsvDhERufxERkZyzz338MQTT1BUVOQ1fjs2Npb4+HhWrFhBUlISeXl5PP74401eb+nSpaxfv54tW7a0KI7bb7+dOXPmUFhYSGxsLHa7HZvN5jXMZeLEiUyePJmysjIee+yxJq/X2iEoM2fO5LXXXuO9994jKiqKkydPAhATE+MZdgKwfft2Ro8efcn3ETe1w8a5XC5eeuklHnjgAazWhh/bA6kdalWoAGd4jcTSBnkiIuJbU6dOpbCwkJEjR9KjRw9PucViYe3atdjtdlJTU3n00UdZtGhRk9fKz8+vtwzomjVr6q1ic6H+/fszaNAg3nzzTcA9YTY1NRWbra6HZtSoUTidTiorK9t8b4MXX3yRoqIiRowYQVJSkufzxhtveOpUVFSwfv16pk+f3qaxXCnUDhv25z//mby8PB588MEGzwdaOzTM89f3knpqh0IVFRURHR3d7ve3/YuLpD+4d/s882I1JTP7t3sMIiIil2ru3Lls3bqVrVu3Nllvw4YNzJ49m9zcXCyWwH/vmZWVxXvvvec1yVgCl9rhpWvJs7CGQgU6J2ACBuDbobUiIiJtbtOmTTz//PMXrTd27FgOHDjA8ePHSUlJaYfIWic4OJgXXnjB32FIM6kdtg/1WFyEv3ssIu9zEfeHrzAMk8I/VlL8wA3tHoOIiIiIXJla8iwc+H08fpKVlUW/fv0YPHiwX+PohOHusQBI9N/qVCIiIiIiTVFi0YiZM2eyb98+du7c6dc4YkKg0hECQHWxRq6JiIiISGBSYhHgDJeJ6XJ/TYZN+1iIiIiISGBSYhHgCgvAdLkTCkuIEgsRERERCUxKLAJcWQVYg6sACOnl263rRURERER8RYlFgAtxgGFxz94OCnfhdDov8hsiIiIiIu1PiUWAs1rAVTMUygg2KSlRr4WIiIiIBB4lFgEuyAKmWTN5O8iF06ltR0REREQk8CixCHBmcN3kbcNwUVmpoVAiIiIiEniUWAQ4i0HdcrNWk4qKaj9HJCIiIiJSnxKLRgTKztsRYefNsbDCsWNn/RqPiIhIU0aMGMGsWbPa5NoFBQUkJiZy9OjRNrm+r911110sXrzY32FckdQO67RnO1Ri0YhA2Xk7pauBWR3kPrBYOHKk0K/xiIhIx2cYRpOfKVOmXPK133nnHZ599lnfBXueBQsWkJGRQa9evTxlw4cPxzAMXn/9da+6y5YtIzExsU3iAHjxxRdJS0sjOjqa6OhohgwZQnZ2tledp59+mnnz5lFcXNxmcXRkaoetV11dzZNPPknv3r0JCwvje9/7Hs888wwul8tTpz3boRKLAJcUDxXF4QBUFwdTWFjh54hERKSjO3HihOezZMkSoqOjvcqef/75er9TWdm8VQnj4uKIiorydciUl5ezatUqpk2b5ikzTZM9e/aQlJTEunXrvOrn5OQwYMAAn8dRq3v37vzHf/wHu3btYteuXfzwhz/kzjvvZO/evZ46aWlp9OrVi1dffbXN4ujI1A5b7z//8z/53e9+x9KlS9m/fz8LFy5k0aJFvPDCC5467dkOlVgEOIthes2xKCws93NEIiLS0XXt2tXziYmJwTCMemUjRozg4YcfJjMzk4SEBEaNGgXAxo0bGTp0KJ06dSI+Pp5x48Zx6NAhz7UvHIIyYsQIfvnLX/LYY48RFxdH165dmTt3botjzs7Oxmq1MmTIEE/ZgQMHKCkp4cknnyQ7O5uysjLPObvdzsCBA1v+j9NMGRkZjB07lmuvvZZrr72WefPmERkZyY4dO7zq3XHHHfXeYoub2mHrffLJJ9x555386Ec/olevXtx1112MHj2aXbt2edVrr3aoxCLAnTwOplm7j4WLoiKHnyMSEZHGmKZJaanTLx/T9P1y5C+//DJWq5W//vWvLF++HIDS0lIyMzPZuXMnW7ZswWKxMH78eK+hFw1dJyIigk8//ZSFCxfyzDPPsHnz5hbFsm3bNgYNGuRVZrfbCQ0NZdq0aURHR3uGIjkcDvbu3dvkm+L58+cTGRnZ5Gf79u3Nis3pdLJ27VpKS0u9HjgBbrrpJj777DMcjvb777dpmpS6/PNRO2zfdjh06FC2bNnCV199BcDf//53Pv74Y8aOHetVr73aobVNry6tVlQKhs29xKw1qpriYiUWIiKBqqzMRVTUNr/cu6RkOBERQT695tVXX83ChQu9yiZOnOh1vGrVKhITE9m3bx+pqakNXictLY3f/va3AFxzzTUsXbqULVu2eN4+N8fRo0dJTk72KsvJySEtLQ2bzcb48eN5++23mThxIp9//jlVVVVNvimeMWMGkyZNavKe3bp1a/L8F198wZAhQ6ioqCAyMpL169fTr1+/etdwOBycPHmSnj17XuRv6RtlJkTta5db1VPSDyIM315T7bDxdvjrX/+aoqIi+vbtS1BQEE6nk3nz5vHTn/603jXaox0qsQhwYcFAbY9FkElpqXbeFhGR9nHhm1mAQ4cO8dRTT7Fjxw7y8/M9b4jz8vKafKA7X1JSEqdPn25RLOXl5YSGhnqV2e12z9vgCRMmMGHCBBwOB3a7nbi4OK/JtReKi4sjLi6uRTFcqE+fPuzZs4ezZ8+ybt06HnjgAT766COv5CIsLAzAa3iMtIzaYePeeOMNXnnlFV577TWuv/569uzZw6xZs0hOTuaBBx7w1GuvdqjEIsDZgsHlqhuxZvj4LYCIiPhOeLiFkpLhfru3r0VERNQry8jIICUlhZUrV5KcnIzL5SI1NbXJSbXBwcFex4ZhNDlkpSEJCQkUFnqvjLh7927uvfdewD2G3mazsWnTJnJyckhPT2/yevPnz2f+/PlN1snOzmbYsGGNnrfZbFx99dWA++F3586dPP/8857hOgBnzpwBoHPnzk3ey5fCDXfPgT+Et8Fzitph4+3wV7/6FY8//jg/+clPAOjfvz/Hjh1jwYIFXolFe7VDJRYBLsQKrqq6ru0evWL9GI2IiDTFMAyfD0cKJAUFBezfv5/ly5d7HnQ+/vjjdrl3eno6r7zyiuf48OHDnD171vOm2Gq1kpGRwbp168jNzWXkyJFNXs8XQ6EuZJpmvTHsubm5dO/enYSEhBZdqzUMw/D5cKRAonZYp6ysDIvF+6VCUFBQvYSpvdqhEosAF2wFp7PuP1JVIb6fFCUiItIcsbGxxMfHs2LFCpKSksjLy+Pxxx9vl3vffvvtzJkzh8LCQmJjY7Hb7dhsNq9hLxMnTmTy5MmUlZXx2GOPNXm91g5BeeKJJxgzZgwpKSmUlJSwdu1atm7dysaNG73qbd++ndGjR1/yfaQ+tcM6GRkZzJs3jx49enD99deze/duFi9ezIMPPuhVr73aoVaFCnA2m3ePxfFS7WMhIiL+YbFYWLt2LXa7ndTUVB599FEWLVrU6uuuWbMG4yJjffv378+gQYN48803AfeE2dTUVGw2m6fOqFGjcDqdVFZWtuneAQCnTp1i8uTJ9OnTh9tuu41PP/2UjRs3ek0ErqioYP369UyfPr1NY7nSqB3WeeGFF7jrrrt46KGHuO6665g9ezY///nPvTYHbM92aJhtsS7YZaS4uJiYmBiKioqIjo5u9/s/+lsXS34MPW74EoDO03aza/W97R6HiIhIW5k7dy5bt25l69atTdbbsGEDs2fPJjc3t97wj0CUlZXFe++9xwcffODvUKQZ1A4b1pJnYQ2FCnBX9zagtC73y6+s9mM0IiIivrdp06YGd1m+0NixYzlw4ADHjx8nJSWlHSJrneDgYK8dkCWwqR22nnosLsLfPRbv/J/JxFCTbsMOEWStpvqfP+b4B+pSFREREZG215Jn4cDvv7nCWa0muMB0ucf8VQdf5BdERERERPxAiUUjsrKy6NevH4MHD/ZrHN+dAqxg1uxlUW29jNePExEREZEOS4lFI2bOnMm+ffvYuXOnX+M4VwFEgMVaM7fixk7+DEdEREREpEFKLAJcaCjgAsNwT4WxdA3xb0AiIiIiIg1QYhHgwsNwz7Ew3UOgjEgt5CUiIiIigUeJRYCLqOmxoCaxsMbYmqwvIiIiIuIPSiwCXHg44KzrsSAsqMn6IiIiIiL+oMQiwEWEAy5w1Sw3a4ZoVSgRERERCTxKLAJcbAw1cyxqvqowKxUVVX6NSURERETkQkosAlznBAMK6/axMEIsnDx5zs9RiYiIiIh4U2IR4MLDgHNQXhwBQNX+YiUWIiISMEaMGMGsWbNafZ2CggISExM5evRoq6/VHu666y4WL17s7zCkhtphYFBiEeCsVhOc4HK5J21bYoI5fbrUz1GJiEhHlpGRwciRIxs898knn2AYBjk5Oe0a04IFC8jIyKBXr16esuHDh2MYBq+//rpX3WXLlpGYmNhmsbz44oukpaURHR1NdHQ0Q4YMITs726vO008/zbx58yguLm6zOC53aodNq66u5sknn6R3796EhYXxve99j2eeeQaXy+WpE2jtUIlFR2AFl7M2sbDx3XdKLERE5NJNnTqVv/zlLxw7dqzeudWrV3PjjTcyYMCAdounvLycVatWMW3aNE+ZaZrs2bOHpKQk1q1b51U/JyenTePr3r07//Ef/8GuXbvYtWsXP/zhD7nzzjvZu3evp05aWhq9evXi1VdfbbM4Lndqh037z//8T373u9+xdOlS9u/fz8KFC1m0aBEvvPCCp06gtUMlFgHOZgM6gWFxAhDcN4r8/HK/xiQiIh3buHHjSExMZM2aNV7lZWVlvPHGG0ydOhWAjRs3MnToUDp16kR8fDzjxo3j0KFDPo8nOzsbq9XKkCFDPGUHDhygpKSEJ598kuzsbMrKyjzn7HY7AwcO9HkctTIyMhg7dizXXnst1157LfPmzSMyMpIdO3Z41bvjjjvqvcWW5lM7bNonn3zCnXfeyY9+9CN69erFXXfdxejRo9m1a5dXvUBqh0osAlxQkAUqz9t5OyqYgoKyi/yWiIj4U2mps9FPRYWz2XXLy5tXt6WsViv3338/a9aswTRNT/lbb71FZWUl9913X839SsnMzGTnzp1s2bIFi8XC+PHjvYZi+MK2bdsYNGiQV5ndbic0NJRp06YRHR3tGYrkcDjYu3dvk2+K58+fT2RkZJOf7du3Nys2p9PJ2rVrKS0t9XrgBLjpppv47LPPcDgcLfwbt49Sl9nop8JlNrtueTPrtpTaYdPtcOjQoWzZsoWvvvoKgL///e98/PHHjB071qteILVDq78DkGaoBmdVzVdlgcLCCv/GIyIiTYqK2tboubFj43n//TTPcZcuf6WsrOHk4JZbOvHhh+me4969PyE/v/6S4y7XrS2O8cEHH2TRokVs3bqVW291//7q1auZMGECsbGxAEycONHrd1atWkViYiL79u0jNTW1xfdszNGjR0lOTvYqy8nJIS0tDZvNxvjx43n77beZOHEin3/+OVVVVU2+KZ4xYwaTJk1q8p7dunVr8vwXX3zBkCFDqKioIDIykvXr19OvX79613A4HJw8eZKePXte5G/Z/qL2NX5ubBS8f17IXf4BZY08p98SAR/2rjvu/SXkN9BkXZfQJNQOG2+Hv/71rykqKqJv374EBQXhdDqZN28eP/3pT+tdI1DaoRKLjuD8xAJIvibGj8GIiMjloG/fvtx8882sXr2aW2+9lUOHDrF9+3Y++OADT51Dhw7x1FNPsWPHDvLz8z1viPPy8nz6QFdeXk5oaKhXmd1u97wNnjBhAhMmTMDhcGC324mLi/OaXHuhuLg44uLiWhVTnz592LNnD2fPnmXdunU88MADfPTRR17JRVhYGIDX8BhpGbXDxr3xxhu88sorvPbaa1x//fXs2bOHWbNmkZyczAMPPOCpF0jtUIlFR+AEZ3XdV1UaHeTHYERE5GJKSoY3ei7ogv8LP3XqB43WtVwwYPnIkSENV7xEU6dO5eGHHyYrK4uXXnqJnj17ctttt3nOZ2RkkJKSwsqVK0lOTsblcpGamkplZaVP40hISKCwsNCrbPfu3dx7772AeylRm83Gpk2byMnJIT09vaHLeMyfP5/58+c3WSc7O5thw4Y1et5ms3H11VcDMGjQIHbu3Mnzzz/P8uXLPXXOnDkDQOfOnZu8l7+U9Gv83IVPEqf6Nl73wnHzR/pcakQNUztsuB3+6le/4vHHH+cnP/kJAP379+fYsWMsWLDAK7EIpHaoxKIjqIbz/2edH+TbMYUiIuJbERHNfwHUVnWbY9KkSTzyyCO89tprvPzyy0yfPh3DcM/pKygoYP/+/Sxfvtzz4PPxxx/79P610tPTeeWVVzzHhw8f5uzZs543xVarlYyMDNatW0dubm6jS5TW8sVQqAuZpllvDHtubi7du3cnISGhRddqLxEWw+91m0PtsGFlZWVYLni7EBQUVG9uSSC1w8s+sfj666+ZPHkyp0+fxmq18tRTT3H33Xf7O6yWqfY+PHxOy82KiEjrRUZGcs899/DEE09QVFTElClTPOdiY2OJj49nxYoVJCUlkZeXx+OPP97k9ZYuXcr69evZsmVLi+K4/fbbmTNnDoWFhcTGxmK327HZbF7DXCZOnMjkyZMpKyvjsccea/J6rR2C8sQTTzBmzBhSUlIoKSlh7dq1bN26lY0bN3rV2759O6NHj77k+4ib2mHDMjIymDdvHj169OD6669n9+7dLF68mAcffNCrXiC1w8t+VSir1cqSJUvYt28ff/7zn3n00UcpLe1gD+buHi7PylDflPl/1r+IiFwepk6dSmFhISNHjqRHjx6ecovFwtq1a7Hb7aSmpvLoo4+yaNGiJq+Vn59fbxnQNWvWeN4+N6Z///4MGjSIN998E3BPmE1NTcVms3nqjBo1CqfTSWVlZZvvbXDq1CkmT55Mnz59uO222/j000/ZuHEjo0aN8tSpqKhg/fr1TJ8+vU1juVKoHdb3wgsvcNddd/HQQw9x3XXXMXv2bH7+85/z7LPPeuoEWjs0zPPX97oCpKWl8X//93+kpKQ0q35xcTExMTEUFRURHR3dxtE1zJjjgnuhS89jhESU4/p5Dl///l/8EouIiEhLzJ07l61bt7J169Ym623YsIHZs2eTm5tbb/hHIMrKyuK9997zmmQsgUvt8NK15FnY7/9i27ZtIyMjg+TkZAzD4N13361XZ9myZfTu3ZvQ0FAGDhzY7LWnL7Rr1y5cLlezk4qAUbOkW+3u21Vhfv/aREREmmXTpk0sXLjwovXGjh3Lz3/+c44fP94OUbVecHCw1w7IEtjUDtuH3+dYlJaWcsMNN/Czn/2s3jrF4F5qa9asWSxbtowf/OAHLF++nDFjxrBv3z5PV9nAgQMb3BTkgw8+8KxHXFBQwP3338/vf//7tv0LtSHT5U4onD6evCciItJWPvnkk2bXfeSRR9owEt/613/9V3+HIC2gdtg+AmoolGEYrF+/nh//+Meesu9///sMGDCAF1980VN23XXX8eMf/5gFCxY067oOh4NRo0Yxffp0Jk+efNG65ycpxcXFpKSk+Hco1G9dcBck9vqa0IhSKv50nFM/HnXxXxQRERERaYUONRSqKZWVldjt9noz3UePHs3f/va3Zl3DNE2mTJnCD3/4w4smFQALFiwgJibG8wmIYVNF7j8Mi3t5saCUcD8GIyIiIiJSX0AnFvn5+TidTrp06eJV3qVLF06ePNmsa/z1r3/ljTfe4N133+XGG2/kxhtv5Isvvmi0/pw5cygqKvJ8vv7661b9HXyipgPFdLq/LiPS7yPYRERERES8dIgn1AuXBzNN86JLhtUaOnRovY1EmhISEkJISEiL4mtzNYmFszaxCLdSWVmNzdYhvj4RERERuQIEdI9FQkICQUFB9XonTp8+Xa8X47JWk0O5nO5EwggLorCwwo8BiYiIiIh4C+jEwmazMXDgQDZv3uxVvnnzZm6++eY2vXdWVhb9+vVj8ODBbXqfZqldbrbavRqUERpEYWG5HwMSEREREfHm97E0586d4+DBg57jI0eOsGfPHuLi4ujRoweZmZlMnjyZQYMGMWTIEFasWEFeXh4zZsxo07hmzpzJzJkzPTPh/ap2KFRtYhFs4auvCujbt7MfgxIRERERqeP3xGLXrl3ceuutnuPMzEwAHnjgAdasWcM999xDQUEBzzzzDCdOnCA1NZUNGzbQs2dPf4Xc/ipNwKC6Mth9bDXYs+ckd9zR169hiYiIiIjU8ntiMWLECC62lcZDDz3EQw891E4RBZ5gF1QBlRUhUPNPdeK7Ur/GJCIiIiJyvoCeY+FPgTTHwuICzJrJ2zWJxclyTd4WERERkcChxKIRM2fOZN++fezcudPfoVDtoCahMHCVujOLfGe1P0MSERFp0IgRI5g1a1abXLugoIDExESOHj3aJtf3tbvuuovFixf7O4wrktphnfZsh0osOgAXRt03ZTHAgMLeAbbXhoiIdBiGYTT5mTJlyiVf+5133uHZZ5/1XbDnWbBgARkZGfTq1ctTNnz4cAzD4PXXX/equ2zZMhITE9skjobiMgyj3oPs008/zbx58yguLm6XODoatcPWKykpYdasWfTs2ZOwsDBuvvnmei/F27MdKrHoAIyiujkoRs2smLIkm5+iERGRju7EiROez5IlS4iOjvYqe/755+v9TmVlZbOuHRcXR1RUlK9Dpry8nFWrVjFt2jRPmWma7Nmzh6SkJNatW+dVPycnhwEDBvg8jgvt3LmTFStWkJaWVu9cWloavXr14tVXX23zODoitcPWmzZtGps3b+aPf/wjX3zxBaNHj2bkyJEcP37cU6c926ESi0YE1ByL8352Vbn/rIoN9kssIiLS8XXt2tXziYmJwTCMemUjRozg4YcfJjMzk4SEBEaNGgXAxo0bGTp0KJ06dSI+Pp5x48Zx6NAhz7UvHIIyYsQIfvnLX/LYY48RFxdH165dmTt3botjzs7Oxmq1MmTIEE/ZgQMHKCkp4cknnyQ7O5uysjLPObvdzsCBA1v+j9MC586d47777mPlypXExsY2WOeOO+6o9xZb3NQOW6e8vJx169axcOFChg8fztVXX83cuXPp3bs3L774olfd9mqHSiwaEUhzLCzgmbRt1uxpEZoc4a9wRESkEaZpUlrqn8/FVli8FC+//DJWq5W//vWvLF++HIDS0lIyMzPZuXMnW7ZswWKxMH78eFwuV5PXiYiI4NNPP2XhwoU888wz9Ta/vZht27YxaNAgrzK73U5oaCjTpk0jOjqa7OxsABwOB3v37m3yTfH8+fOJjIxs8rN9+/YmY5o5cyY/+tGPGDlyZKN1brrpJj777DMcDkcL/ratY5omZabLLx+1w/Zrh9XV1TidTkJDQ73Kw8LC+Pjjj73K2qsd+n25WWkGG+7EwgBnmQtrvAVXTJC/oxIRkQuUlUFUlO8frJqjpMQgwsfvnK6++moWLlzoVTZx4kSv41WrVpGYmMi+fftITU1t8DppaWn89re/BeCaa65h6dKlbNmyxfP2uTmOHj1KcnKyV1lOTg5paWnYbDbGjx/P22+/zcSJE/n888+pqqpq8k3xjBkzmDRpUpP37NatW6Pn1q5dS05OzkVfQHbr1g2Hw8HJkyfbbQ+uckyu58t2udeF9tKHcAyfXlPtsOF2GBUVxZAhQ3j22We57rrr6NKlC6+//jqffvop11xzTb1rtEc7VGLRARjn9Su5alaZrQ5XYiEiIm3rwjezAIcOHeKpp55ix44d5Ofne94Q5+XlNflAd76kpCROnz7doljKy8vrvZm12+2et8ETJkxgwoQJOBwO7HY7cXFxXpNrLxQXF0dcXFyLYqj19ddf88gjj/DBBx/Ui+lCYWFhAF7DY6Rl1A4b98c//pEHH3yQbt26ERQUxIABA7j33nvJycnxqtde7VCJRQcQEgSOmhdgrnL3WwCXEgsRkYATHu7uOfDXvX0tooEukIyMDFJSUli5ciXJycm4XC5SU1ObnFQbHOw9L9AwjCaHrDQkISGBwsJCr7Ldu3dz7733Au4x9DabjU2bNpGTk0N6enqT15s/fz7z589vsk52djbDhg2rV2632zl9+rTXm2in08m2bdtYunQpDoeDoCD3f6fPnDkDQOfOnS/+l/SRMAz20qfd7nfhvX1N7bDhdghw1VVX8dFHH1FaWkpxcTFJSUncc8899O7d26tee7VDJRYdQGw0FFcCYVBdbAFMjNAgSkocREVp2VkRkUBhGL4fjhRICgoK2L9/P8uXL/c86Fw4lrutpKen88orr3iODx8+zNmzZz1viq1WKxkZGaxbt47c3Nwm5z1A64ag3HbbbXzxxRdeZT/72c/o27cvv/71rz1JBUBubi7du3cnISGhyXv5kmEYPh+OFEjUDuuLiIggIiKCwsJCNm3aVG/oWHu1QyUWjcjKyiIrKwun0+nvUEiONTlWaUAYVByGmB+A80Q5x6rPkpraxd/hiYjIFSI2Npb4+HhWrFhBUlISeXl5PP744+1y79tvv505c+ZQWFhIbGwsdrsdm83mNexl4sSJTJ48mbKyMh577LEmr9eaIShRUVH1httEREQQHx9fr3z79u2MHj36ku4jDVM7rLNp0yZM06RPnz4cPHiQX/3qV/Tp04ef/exnXvXaqx1qVahGBNKqUCFBJtT01Lkc7rcgloQQjhw567+gRETkimOxWFi7di12u53U1FQeffRRFi1a1OrrrlmzBsNo+g17//79GTRoEG+++SbgnjCbmpqKzVa3r9OoUaNwOp1UVla2yx4WF1NRUcH69euZPn26v0O5rKgd1ikqKmLmzJn07duX+++/n6FDh/LBBx94Dftqz3ZomG2xLthlpLi4mJiYGIqKioiOjvZLDAMnVJHzaBB0Astfj9F9ejmYJpm/O8cjD3/fLzGJiIj4yty5c9m6dStbt25tst6GDRuYPXs2ubm5WCyB/240KyuL9957jw8++MDfoUgzqB02rCXPwhoK1QGU1QyDAnAlRIFRDobB3opS/wYmIiLiA5s2bWpwl+ULjR07lgMHDnD8+HFSUlLaIbLWCQ4O5oUXXvB3GNJMaoetpx6LiwiIHos7q8l5ygIhwMEietxxAgzo+8I3bHpE4zZFREREpG205Fk48PtvhIgQPHMsCLJApfvgu0i/hSQiIiIi4kWJRSOysrLo168fgwcP9ncoRIXj3nkbwGohyOFOLEKvifJbTCIiIiIi51Ni0YhAWhUqKtwCtaveVlUTUrNbXnknTZERERERkcCgxKIDiImmbiiUNYjgYneWURahr09EREREAoOeTDuATjGcl1hYML5zAOAIu3x31RQRERGRjkWJRQfwvZ4GOGoOKiHolPvAFRrkv6BERERERM6jxKIDuO4qoLzmoMog4YtzYILzdAVaLVhEREREAoESiw4gMhKv5WY71eyLF5QUxunT2iRPRERERPxPiUUHEBpyXq9EiIWIUneWYURa+fxgvp+iEhERERGpo8SiEYG0j0VpuQERNQfxVlwlTqh2gQF/LSnya2wiIiIiIqDEolGBtI+F1UrdPhYGVFY6Pef2mxV+iUlERARgxIgRzJo1q9XXKSgoIDExkaNHj7b6Wu3hrrvuYvHixf4OQ2qoHQYGJRYdQFgIXolFv36dodxdcCLY2ejviYiINCQjI4ORI0c2eO6TTz7BMAxycnLaNaYFCxaQkZFBr169PGXDhw/HMAxef/11r7rLli0jMTGx3eIyDKPeQ+vTTz/NvHnzKC4ubpc4Lkdqh00rKSlh1qxZ9OzZk7CwMG6++eZ6L7wDrR0qsegAIsKoSywsBhERwVjL3fMszO5hfotLREQ6pqlTp/KXv/yFY8eO1Tu3evVqbrzxRgYMGNBu8ZSXl7Nq1SqmTZvmKTNNkz179pCUlMS6deu86ufk5LRLfDt37mTFihWkpaXVO5eWlkavXr149dVX2zyOy5XaYdOmTZvG5s2b+eMf/8gXX3zB6NGjGTlyJMePH/fUCbR2qMSiAwgPBc5b/KmqykVkzQio0kh9hSIi0jLjxo0jMTGRNWvWeJWXlZXxxhtvMHXqVAA2btzI0KFD6dSpE/Hx8YwbN45Dhw75PJ7s7GysVitDhgzxlB04cICSkhKefPJJsrOzKSsr85yz2+0MHDjQ53Gc79y5c9x3332sXLmS2NjYBuvccccd9d5iS/OpHTauvLycdevWsXDhQoYPH87VV1/N3Llz6d27Ny+++KJX3UBqh3oq7QDCQ/EaCnXkSCExNftalGn3bRGRgFNaajb6qagwm123vLx5dVvKarVy//33s2bNGq/9kN566y0qKyu57777au5XSmZmJjt37mTLli1YLBbGjx+Py+Vq7NKXZNu2bQwaNMirzG63ExoayrRp04iOjiY7OxsAh8PB3r17m3xTPH/+fCIjI5v8bN++vcmYZs6cyY9+9KNGh+oA3HTTTXz22Wc4HI5G6/hTmelq9FNhunxet6XUDhtvh9XV1TidTkJDQ73Kw8LC+Pjjj73KAqkdWv0dgFxcSAhQXXNgwP793xFbnMwxwBGixEJEJNBERTX+sD92LLz/ft3/d3fpYnLeS1Avt9wCH35YV7d3b5P8BlYZd7la/t+CBx98kEWLFrF161ZuvfVWwD38ZMKECZ439BMnTvT6nVWrVpGYmMi+fftITU1t8T0bc/ToUZKTk73KcnJySEtLw2azMX78eN5++20mTpzI559/TlVVVZNvimfMmMGkSZOavGe3bt0aPbd27VpycnIuuoBLt27dcDgcnDx5kp49ezZZ1x+u58tGz91KJKtJ8RwP4ivKabjdfp9w1lL39xvGQc5Qf47nEa5rcYxqhw23w6ioKIYMGcKzzz7LddddR5cuXXj99df59NNPueaaa+pdI1DaoRKLDsBiMaCq5n/sTqiuNgn9xgE3heEKVqeTiIi0XN++fbn55ptZvXo1t956K4cOHWL79u188MEHnjqHDh3iqaeeYseOHeTn53veEOfl5fn0ga68vLzem1m73e55GzxhwgQmTJiAw+HAbrcTFxfnNbn2QnFxccTFxV1SLF9//TWPPPIIH3zwQb2YLhQW5p7nWNZYZigXpXbYuD/+8Y88+OCDdOvWjaCgIAYMGMC9995bb0J7ILVDJRYdRWXNny6oqnIyyBHCDhOwQLVpYjXUcyEiEihKShr//+SgIO/jU6car2u54N3RkSO+/f/6qVOn8vDDD5OVlcVLL71Ez549ue222zznMzIySElJYeXKlSQnJ+NyuUhNTaWysrKJq7ZcQkIChYWFXmW7d+/m3nvvBdxLidpsNjZt2kROTg7p6elNXm/+/PnMnz+/yTrZ2dkMGzasXrndbuf06dNeb6KdTifbtm1j6dKlOBwOgmq+xDNnzgDQuXPni/8l/WAvfRo9d+FryV1c2+y627n60oNqgNph/XYIcNVVV/HRRx9RWlpKcXExSUlJ3HPPPfTu3durXiC1QyUWHUVtj2OQe/L2gORYqC4Dq4VTVNENm1/DExGROhERzU8A2qpuc0yaNIlHHnmE1157jZdffpnp06dj1LyoKigoYP/+/Sxfvtzz4HPh2G5fSU9P55VXXvEcHz58mLNnz3reFFutVjIyMli3bh25ublNznuA1g1Bue222/jiiy+8yn72s5/Rt29ffv3rX3uSCoDc3Fy6d+9OQkJCk/fyl3Cj+aMa2qpuc6gdNi0iIoKIiAgKCwvZtGkTCxcu9DofSO1QiUUjsrKyyMrKwukMkH0iapNyA6qrXfTrm4Dz+JcE9Yxg35liusX7vzGJiEjHEhkZyT333MMTTzxBUVERU6ZM8ZyLjY0lPj6eFStWkJSURF5eHo8//niT11u6dCnr169ny5YtLYrj9ttvZ86cORQWFhIbG4vdbsdms3kNc5k4cSKTJ0+mrKyMxx57rMnrtWYISlRUVL3hNREREcTHx9cr3759O6NHj76k+0gdtcOGbdq0CdM06dOnDwcPHuRXv/oVffr04Wc/+5lXvUBqhxqg34hA2nkbgKC6P6urXXTtGoVpAgb8qeSMPyMTEZEObOrUqRQWFjJy5Eh69OjhKbdYLKxduxa73U5qaiqPPvooixYtavJa+fn59ZYBXbNmjeftc2P69+/PoEGDePPNNwH3hNnU1FRstrre+FGjRuF0OqmsrGzXvQ0aU1FRwfr165k+fbq/Q7ksqB3WV1RUxMyZM+nbty/3338/Q4cO5YMPPiA4ONhTJ9DaoWGev76X1FNcXExMTAxFRUVER0f7LQ7jWRf82P3z9yYt49D+h+l+dBdBPcLpc8zJB737+y02ERGRxsydO5etW7eydevWJutt2LCB2bNnk5ubi+XCySUBKCsri/fee89rkrEELrXDS9eSZ2ENheoozpvo/720rgCY3zmgRzj5wb5dx1lERMRXNm3axPPPP3/RemPHjuXAgQMcP36clJSUi9b3t+DgYF544QV/hyHNpHbYPtRjcREB02PxSxfU9HKNzcrm/373I/p8+DEVt8QRWeJib4zvllsTEREREYGWPQsHfh+PuBXU/VhhcU+4SHK4vz5tkiciIiIi/qbEoqM4r1/pRJF7iaiUmnXSq4OVWIiIiIiIfymx6Cgq6zKL44UVAHT5pspdYEC+WeWPqEREREREACUWHYdpQs0cbVdlNQDF/zgLprszI5cKv4UmIiIiIqLEoqOoqgJ3PoFZ4gCgV89OVO4pBBPUXyEiIiIi/qTEoqMoc3l6LKqD3asEX311HNWHSgH4WqmFiIiIiPiREouOohjPBG5nTDgA113Xmeqj5wA4WqWhUCIiIiLiP0osOgpHEIS4f3Re3x1w91hgs4ABH7hK/BiciIiIiFzplFh0FBWGp8fCjAwFICwsGIrdQ6AKgpz+ikxERERERIlFY7KysujXrx+DBw/2dyhuzrrlZm2xEZ6fzdxiAKqCQJuoi4iIiIi/KLFoxMyZM9m3bx87d+70dygAGLjqeizCbJ7yq4vqNsc7SmV7hyUiIiIiAiix6DAsRt0+FtUEecrTeyR4ejN2UOaP0ERERERElFh0FF49FrZQnE53ltGlSwSumnkWeyj3V3giIiIicoVTYtFBhIbi6bEgNJiCAnfvhNVqwXnCvdTsIQ2FEhERERE/UWLRQQRZXHjyBqfBd9+5E4v8/DKqDp7DBM6ilaFERERExD+UWHQQncNL8EyhqLKQn+8+6N27E6VrDoMJofo6RURERMRP9CTaQTirnHVDoYLrEotrromn6kv35nhHqdSSsyIiIiLiF0osOoiS4io8I51sVs6ccScW11+fSPXhUnCZlJouvtNwKBERERHxAyUWHYTLYoPomoMuFgoL3RO2e/fuBJUuXKXVmMCfKPJXiCIiIiJyBVNi0UEYFktdj4UFT2JhsVgICjKg3AmYWnJWRERERPxCiUUHYbW46hKLIEhKivScCw21Un3MPTRKS86KiIiIiD8oseggbEHnJRaGQWio1XMuLa0LVfvcQ6BOUOWH6ERERETkSqfEooOwBTnrlps1oLS0LoG44YauVH5WAECJZ+koEREREZH2o8SigwgNduHpjLDA4cOFnnNdu0ZSvuUU4O7UOG1Wt3+AIiIiInJFU2LRQVx3bXBdYmGA3f6t51xISBDVB0uhZguLv3Ku/QMUERERkSuaEosO4qpewVBRc+D0HgpVVOQAwHXWPXH7iOZZiIiIiEg7U2LRQSR0MqGk5qAaysvrkoerr44DoOytrzEAJ9p9W0RERETa12WfWJSUlDB48GBuvPFG+vfvz8qVK/0d0iWpKK8GR82BBSoq6uZRXHddAgCVe4vBhC89FUVERERE2of14lU6tvDwcD766CPCw8MpKysjNTWVCRMmEB8f7+/QWuTgwXK4ygVYwAIOh9Nz7vrrEwGo/PtZAPZpkzwRERERaWeXfY9FUFAQ4eHhAFRUVOB0OjHNjjdUKCzMAhGG+yAEyqsNz7mYmFAMA6oOn8MEvsXJCVPzLERERESk/fg9sdi2bRsZGRkkJydjGAbvvvtuvTrLli2jd+/ehIaGMnDgQLZv396ie5w9e5YbbriB7t2789hjj5GQkOCj6NtPaKgFHDXJhAFVpndnk80WhOt4OUZN0rTFMyFDRERERKTt+T2xKC0t5YYbbmDp0qUNnn/jjTeYNWsWv/nNb9i9ezfDhg1jzJgx5OXleeoMHDiQ1NTUep9vv3UvydqpUyf+/ve/c+TIEV577TVOnTrVLn83XwoLs0BFXU9LdHyU1/nanbiDy9wb5H2m4VAiIiIi0o78PsdizJgxjBkzptHzixcvZurUqUybNg2AJUuWsGnTJl588UUWLFgAgN1ub9a9unTpQlpaGtu2bePuu+9uffDtKDTUAiUuIAgAlzXU63z//l34+OM8OhW5OB0ZxD88a9OKiIiIiLS9FvVYLFy4kPLyujfh27Ztw+GoW4GopKSEhx56yGfBVVZWYrfbGT16tFf56NGj+dvf/tasa5w6dYri4mIAiouL2bZtG3369Gm0vsPhoLi42OsTCCIiguBsXY9FibWL1/m+fRMwDIg/4Z5b8S3afVtERERE2k+LEos5c+ZQUlI3dn/cuHEcP37cc1xWVsby5ct9Flx+fj5Op5MuXbwfort06cLJkyebdY1vvvmG4cOHc8MNNzB06FAefvhh0tLSGq2/YMECYmJiPJ+UlJRW/R18JSzMAqV1iYUjsqvXJPS4uDAAOuWWAnAOF1Wmq32DFBEREZErVouGQl24mlJ7ra5kGIbXsWma9coaM3DgQPbs2dPse82ZM4fMzEzPcXFxcUAkF9/7XhhsOe/fOyqS8vIqwsNtALhcLkwTvnvnGEzpDMAOyhhGpD/CFREREZErjN8nbzclISGBoKCger0Tp0+frteL4SshISFER0d7fQJBcnIIlNXsXWECcSF8912p5/ypU+6f9+46SWzN16qN8kRERESkvQR0YmGz2Rg4cCCbN2/2Kt+8eTM333xzm947KyuLfv36MXjw4Da9T3PZbAYcP+s+MIHYML77rsxzvksXd89EWVkV44jBAPJx1ruOiIiIiEhbaPGqUL///e+JjHQ/xFZXV7NmzRrPvhDnz79ornPnznHw4EHP8ZEjR9izZw9xcXH06NGDzMxMJk+ezKBBgxgyZAgrVqwgLy+PGTNmtPheLTFz5kxmzpxJcXExMTExbXqv5jBNwFkzZ8IAwmycPFm3bG63bu7lZysqnPQlBIB9WhlKRERERNpJixKLHj16sHLlSs9x165d+eMf/1ivTkvs2rWLW2+91XNcO7/hgQceYM2aNdxzzz0UFBTwzDPPcOLECVJTU9mwYQM9e/Zs0X06unPnnFBV0wNhAGFWvv66bsWq7t3dQ7aqq11cRygm8AXlLZqPIiIiIiJyqVqUWBw9etTnAYwYMeKik8Afeughny5j2xFFRQVBp/P2rrAFcfx4XWLRs2cnAFwuk14uK1igEBe5VNCfsHaOVkRERESuNAE9x8KfAm2ORUREELjO63mwmJw4UTf07Hvfi/X8XHGqHBvuupto+fA0EREREZGWalFi8emnn5Kdne1V9oc//IHevXuTmJjIv/7rv3ptmNeRzZw5k3379rFz505/hwJAdLQVKs/b9C7E8OxdAXj9fPhwIUk1nVGfUTfBW0RERESkrbQosZg7dy6ff/655/iLL75g6tSpjBw5kscff5z//d//ZcGCBT4PUiAiwgIO78TCag3yHBqGQaeaoVJBQRaux/3zISrbNU4RERERuTK1KLHYs2cPt912m+d47dq1fP/732flypVkZmbyP//zP7z55ps+D1LAarXUTd4GqISCAu/eiG7dojAMKC+vYjgRAJzBiUs7cIuIiIhIG2tRYlFYWOi1Md1HH33EP//zP3uOBw8ezNdff+276MRbxXk9FsHw1cEzXqdrh0OdOVPOP+NeftYEdmvZWRERERFpYy1KLLp06cKRI0cAqKysJCcnhyFDhnjOl5SUEBwc7NsI/STQJm8DGNXnJQhW2LPfe2K2xWJgmvD3v5+kk2ElVBO4RURERKSdtCix+Od//mcef/xxtm/fzpw5cwgPD2fYsGGe859//jlXXXWVz4P0h0CbvA0Q5Dhv6FMIlAeFe50/efIcADt2fAPgmWdxVjtwi4iIiEgba1Fi8dxzzxEUFMQtt9zCypUrWbFiBTabzXN+9erVjB492udBiltQdbl7bBOAFapsUV7nY2LciURhobtn4yd0wgCOUdWOUYqIiIjIlahFG+R17tyZ7du3U1RURGRkJEFBQV7n33rrLaKiohr5bWktC9XgAoIAC5hhnbzOh4e7h6GVl7vnYtxYszHeF5RTbZpYtQO3iIiIiLSRFiUWDz74YLPqrV69+pKCkaY5KoLqEguA8HjOni2nUyd3AmG1ujugXC53t8b3sBGOQSkmn1DKMCL9ELWIiIiIXAlalFisWbOGnj17kp6ejmmaF/8F8SnDoO4bCwEiOnH4cCEDBrgTi+Bgd2JRXe1eXjbIMLCaBmCyjiIlFiIiIiLSZlqUWMyYMYO1a9dy+PBhHnzwQf7lX/6FuLi4torNr7KyssjKysLpDJyJzxYLOGtHMxmAaXD06FkGDEgGIDjY3ZXhdNbtW3ENIeyinD2Ut3O0IiIiInIladHk7WXLlnHixAl+/etf87//+7+kpKQwadIkNm3adNn1YATiqlBeUyQMIDoci6WusHYolNNZ910Mwb1y1HFN4BYRERGRNtSixAIgJCSEn/70p2zevJl9+/Zx/fXX89BDD9GzZ0/OnTvXFjFKjaAg6laFsgCx4Z75FADXX98ZgKuuivWUTSQGgCrgoOlon0BFRERE5IrT4sTifIZhYBgGpmnicrku/gvSKiEh563CZQChIRQU1A1x6t49GsOATp1CPWW9jBBsNRvlraOovUIVERERkStMixMLh8PB66+/zqhRo+jTpw9ffPEFS5cuJS8vj8hITQ5uS149FgYQZWXv3tOe87VDoWonb9fqgXsZ2o8pbYcoRURERORK1KLJ2w899BBr166lR48e/OxnP2Pt2rXEx8e3VWxygeTkYApqDwwgxODD/zviOV9c7MA04fRp7wTi+4RzkEoOoaFQIiIiItI2WpRY/O53v6NHjx707t2bjz76iI8++qjBeu+8845PgvOnQFwVKiHBgCoTQgx3z0U0XkOhDh48A8CBA2e8fu+ndOJVzlKBSbHpJNrw3thQRERERKS1WpRY3H///RhXyO7NM2fOZObMmRQXFxMTE+PvcAAIDbXAd1XQ3QYOIALOltSt9tTQcrMAqUYYvU0bR6lkF2X8EO2OLiIiIiK+1eIN8sR/rFYr1C4lawBBUB5UN6/FZnPPsWho5d+bCOMolXxGuRILEREREfG5Vq0KJe3r2LFqcHknFq6wGM+KXLU9FucvQVurH6GYwHqtDCUiIiIibUCJRQcSHh4EXWw1B7iTi8hY8vLcyYLN1nhi0Rf3ErSnqOY7s7o9whURERGRK4gSiw4kNDQIauddW3AnFlVB5Oa6l5wNCXGPbGsosbiJMM+vvkFhm8cqIiIiIlcWJRYdiM1meO9jARAZj7Nm3kVtj4XZwCQLwzDoXrOfxV/QDukiIiIi4ltKLDqQkBBL/cSia2fKy90rQ/Xq1QmAhITwBn//n3CXf6n9LERERETEx5RYNCIrK4t+/foxePBgf4fi4U4sajKL2u01OnXi5El3D0TXrpEYBoSGNrzY1110AqAUk1NmVYN1REREREQuhRKLRsycOZN9+/axc+dOf4fiERpqgdotKmr/jI9gz56TAFit7q+zutpV/5eBQV7zLM62WZwiIiIicuVRYtGBXHVVWP0ei/Agtm49CkBlpRPThHPnKhv8fcMwSKmZZ7GL8gbriIiIiIhcCiUWHUifPuFQUdMbUbtibCc4e7YCgNOnSwEoLGw8abjPMxyq4V4NEREREZFLocSiA7HZDDhY6p7AXVZTGGV4eihCQ2tXhWr8GuOIwQB2U84Z7WchIiIiIj6ixKIDcbmAmqVlqagpDAanEUxFRRU2m3vSdlOJRZIRTB9CMIGPtOysiIiIiPiIEosO5ODB8rrEorbHIgjo1Jldu74lJCSosV/10gsbJvACBW0RpoiIiIhcgZRYdCDh4Ra4Kty9h0VsTaFXYtHwMrMX6k8IAEeppNrUXAsRERERaT0lFh1Ip05WsNV8ZecPd3KFsHfvd545Fhdzb01W4gKyKfFtkCIiIiJyRVJi0YHExwfXJRTn72+XnEJoqNWrx6K62kljYg0rnWt2tNB+FiIiIiLiC0osGhGIO2936WKr2xjv/G8uOYGiogqio0M8RVVVjScWAD8gAnCvDiUiIiIi0lpKLBoRiDtvd+4cDK6aLgsLUFRzIiKSI0fOEhlpwzDAMJpeGQrgwZrhUKWYHDArmq4sIiIiInIRSiw6EO8eCxPParHxoezbd5rg4Lo5FtXVTU/KTjPCCcUAYDWFbRCtiIiIiFxJlFh0IGFhQXVdERagtPaEhTNnKnA4qjBNd5WysqrGLuMxkDAA8qhsm4BFRERE5IqhxKKDsVTW9ERUufDkAzHuP3buPO6pl59fxsU8SmcMYC8OnBcbOyUiIiIi0gQlFh1M2Ffn3CtD/aOwboWocCA0nL/9rS6xqKiovui1biSMGIIowskeTeIWERERkVZQYtHBWC3ueRG4KuFUTWEQEN+N3btPeOo5HE2vCgVgNQyGEY4JrOKMz2MVERERkSuHEosOpqykpifCMOHbmkID6NqdAwfqkgOH4+I9FgA9sQGwiRJc2oVbRERERC6REosOxnVthDuR6BcF+eeduOoqvv22BKOmQ6M5PRYAU4kDwAm8R7FPYxURERGRK4cSiw7GCK9ZUjai5qur7WSIDaOoqG4/isrK5iUWsYaVrrh37H5Vu3CLiIiIyCVSYtHBWGonbBs1PzhqjjtH4HSaGDVdFs2ZvF1rNJEA/J1yTK0OJSIiIiKXQIlFB+PZAs+o6aqo3csiJhjDgMjIYAA6dQpt9jUfIgGAKuB9DYcSERERkUugxKKDqUssaiZTHK05drqPw8LcCUZLEouuRjBdaoZDvaTVoURERETkEiix6GCsNfkEQQZBFhfUrjAbCqbV5tlxu6qqeXMsao0jCoBcHBoOJSIiIiItpsSiEVlZWfTr14/Bgwf7OxQv4WE1X5kFgowqOF1zIhTokkJZWRWmiddE7uZ4iARCMKjE5O+07HdFRERERJRYNGLmzJns27ePnTt3+jsUL3ERNYOhnC6cjlIowb0DtwW45lqcTndvw96937XouvGGlduJwgA2aJ6FiIiIiLSQEosO5vqKKncisfcszpIvwWXUnby6p+fH5i43e76xNcOh3qdIm+WJiIiISIsosehgbLWTLCxBUFHgnsNdu7Jsl2hPvUtJLEYQSTAG3+LkNYpaH6yIiIiIXDGUWHQwxYU1WURQMFQXASaeKRHRIZ56LZ28DRBqWDyb5b1GYSsjFREREZEriRKLDuZMnA0MoE8kOMswTdzzLADC6oZFVVZe2lCm8cQA8A8cVGo4lIiIiIg0kxKLjia8ZvJ2lBUqC9w/n6w5ZwUs7q/0UoZCAUwjDgNwAX9Ur4WIiIiINJMSiw4mLKTmKzMAV6V7jsW3NSeDgIhOwKUNhQKIMoLohXv37tc524pIRURERORKosSig4kIrZ28bQAWgi3V8M15Fbp1AyAy0nbJ9/gJsQAcopISs/oitUVERERElFh0OJGhtT0WBmAjKrwayvCsDBV0bSoADsel9VgAPEgsFtyr2v4PBa0JV0RERESuEEosOpgQa93O22AjzHoOMKDUXezq1h2ArVuPXvI9gg0LNxEGQA7ll3wdEREREblyKLHoYGq3sXD3WBhYXWfcxzXbTpid3EvOHjzYup6GhSRjALsp5xuzqlXXEhEREZHLnxKLDsbmWVHWBOBU3kH3YVlNcaL7K62ocFJZeenzI3oYNoYQjgm8rUncIiIiInIRSiw6mB9E4M4pDpYBwZTn1yQW52oyjjAgNhGAzZsPt+pedxODCaziDE7taSEiIiIiTVBi0cFYa3+omWNBVRGhNhPyzivvdhUA69fvb9W9hhIBQAku/qA9LURERESkCUosOpgg4/wf4gGTLnGV8I1ZV6nP1QB88sk3F/56i3Q2gvke7mVrX1JiISIiIiJNUGLRwRxy4N4cr3sohuHeyK660uFebrZ2tFLPLgAcPtz6ZOBfiQMgjyq+MStbfT0RERERuTwpsehgztV2TERYPYlFVWUFYEBFzbkYd3lFRTX5+aWtut8kYrDh7ib5D0636loiIiIicvm6YhKLsrIyevbsyezZs/0dSqsE1/5ggMXinnFhqcp3l9UsOUtMMFZbEAC7d59s1f0shoURNXMt/sw5TNO8yG+IiIiIyJXoikks5s2bx/e//31/h9FqdftYgGm6vz5L5bfushM152yQ0DMZw4C//e3rVt9zDu6hVRWYvOvJXkRERERE6lwRicWBAwf4xz/+wdixY/0dSqt5eiwwqP36ukTW9FjsqzsVet0NgG8Si96GjW4161H9LyWtvp6IiIiIXH78nlhs27aNjIwMkpOTMQyDd999t16dZcuW0bt3b0JDQxk4cCDbt29v0T1mz57NggULfBSxf1lrvzEDXC73BtxHDhxzb8T9He4J3EFQnJiCacLmzYcoKXG0+r5P0xWAXZRRoT0tREREROQCfk8sSktLueGGG1i6dGmD59944w1mzZrFb37zG3bv3s2wYcMYM2YMeXl5njoDBw4kNTW13ufbb7/lvffe49prr+Xaa69tr79Smwo2cHdWGO6kAgyKiiqIDDPdG+fVjFQqiYrBMMA04bXXPm/1fUcRSQrBlOAiW70WIiIiInIB68WrtK0xY8YwZsyYRs8vXryYqVOnMm3aNACWLFnCpk2bePHFFz29EHa7vdHf37FjB2vXruWtt97i3LlzVFVVER0dzdNPP91gfYfDgcNR94a/uLj4Uv5abeb8L8w0ITo6jKKiMsJDyikpC4cyF8QaVHW3kdQ1khMnzvHuu1/y858PbtV9LYbBXWYM/x/5rKCA8cS07i8iIiIiIpcVv/dYNKWyshK73c7o0aO9ykePHs3f/va3Zl1jwYIFfP311xw9epT/+q//Yvr06Y0mFbX1Y2JiPJ+UlJRW/R18LS0UDAyMfPeeElZrCADJYV8BYDnrdFcMhwH/1BuAnTuP++Ted9YkE/tx8H9mYCVcIiIiIuJfAZ1Y5Ofn43Q66dKli1d5ly5dOHmydcuoNmbOnDkUFRV5Pl9/3frJz75UuyqUYTUwTejcORaAknz3PAvzYM1ysEGQNHwIAAUF5RQVlbf63r0MG0k1fSaLtKeFiIiIiJwnoBOLWoZheB2bplmvrDmmTJnCf/3XfzVZJyQkhOjoaK9PIAmq+Wu7av4MDe0MQMG3xwAwj9atG/W5tQsWi7viqlW7fXL/X5AAwFGq2G9WXKS2iIiIiFwpAjqxSEhIICgoqF7vxOnTp+v1Ylwpvqt2z9Em2p1AREVFAlBceJawEMAJVLvr7i836NnTPXxp/fp/+OT+P6UT4TU7cc+lbXqNRERERKTjCejEwmazMXDgQDZv3uxVvnnzZm6++eY2vXdWVhb9+vVj8ODWTXr2tcraja+D3Q/3ISHhADidJsHWmmVgC9x/lNrghz90z7M4duysT+5vGAaT6ATAZ5RTaFb75LoiIiIi0rH5PbE4d+4ce/bsYc+ePQAcOXKEPXv2eJaTzczM5Pe//z2rV69m//79PProo+Tl5TFjxow2jWvmzJns27ePnTt3tul9Wir4guPCQhNrzeYWESFl7sKv3QmGKxRm/+aHGAZ8800xJ0/6ZpnYx+hMEO6ek2c110JERERECIDEYteuXaSnp5Oeng64E4n09HTPyk333HMPS5Ys4ZlnnuHGG29k27ZtbNiwgZ49e/ozbL+xXfCNnT5dSdeu7uFQkUE1O3AfqOnWsMDeM5EMHJgMwAcfHPJJDOFGEMOIAGA753xyTRERERHp2PyeWIwYMQLTNOt91qxZ46nz0EMPcfToURwOB3a7neHDh/svYD+7sMfi7NlqZswYiGFAUlTNsrLfBkGV+8d/32xy++1XYZrw9tv7fBbH03QhCMjHqUncIiIiIuL/xCJQBeoci+ALFsMqK3N6eiROHvp73YmaEUr/KIXOnd29Cxs2HMDlcvkkju8ZIfwzUQC8TKFPrikiIiIiHZcSi0YE6hwL2wWJhWlCWpp7hayvvvyO8NCaDfKOuv+sioQf3Xk94J7g/b//+6XPYplCHADvcJbDpuMitUVERETkcqbEooPx9FgYYAS5N8kzjBBCQqyYJoTU9h58W7MhXhz85WgknTu7V49autR3idIgwuiClUrgCS09KyIiInJFU2LRwSQG1f5kkNTNBsDXXzuIjQ0FILz8U/fpY3XLwK78Am6//WoAPvnEdzuJG4bB7TXDoT6jjHOm02fXFhEREZGORYlFB2O1gIH7071HCKYJ+/adY8CAJACKTh12VzRiPBO4/15m8m//NgSA0tIqPv30G5/F8xidsQAu4DlO+ey6IiIiItKxKLFoRKBO3g467+dvT7kzh/feK+DOO/sAUFpUCFVnAAPjO3e9qgjo268rERHuNaWWLNnhs3gijCCG1iw9+w7FOE3fTA4XERERkY5FiUUjAnXytgv3xnQmEN89BIBvvnHwk5+kAu7J3DgrAbAdrPmlENiyH4YO7QHA5s2+2c+i1jy6AlCJyQu1236LiIiIyBVFiUUHc36PRWJP97yKU6cqiYoKJSbGnWjgcK81a+yvq7viC5NHH/0nwD0c6tw5363ilGLYSMMdy0uc8dl1RURERKTjUGLRwZy/3Gzvq90rPRUUuIdEXX99ovtEyRcAVJQCZe6iP5+C0aOv5ppr4nA4qnn//a98GtfTuJe8LcLFdlO7cYuIiIhcaZRYdDDW8xKL1HT3ikxlZS5cLhfjxl3rPlF6CPdgKQiqWQSqzISiMpg0yb2nxZtv7vVpXIOMcAYTBsDbFPn02iIiIiIS+JRYNCJQJ28bRl1mceNNUZ6fc3NL+X//bxAWS835Kvd+FmG5NRUi4cWtcPfd/TBNeO+9Lzl40LfzIX5LVwzg/yjmuFnl02uLiIiISGBTYtGIQJ28fT5bmBVrTRfGRx+dpVOnMPr3rx0O5d5hu/wbwAEEwe92maSldSU01IrLZfL00x/6NJ5UI5QhhOMEVpLv02uLiIiISGBTYtGBVQE9e7onbJ87596c7gc/SHGfPONeUtbpNLDUDIfKC3MnIbfd1hvA5/MsAO4gGhP4A2c5a1ZftL6IiIiIXB6UWHRgDhfcfns8hgHnzrn3j7BYar5SZwlRoeUAJNcOj4o12ZQLv/nNMABKSirZuvWIT2MaS5Rnw7x5nPbptUVEREQkcCmx6IDia761BCtcfbV7wvSBA+7lnyZPTvPU6xa+D8OAxGN1v/tvH8KQIT2IjXUvD/vssx/5NLZow8rwmg3z3qOISm2YJyIiInJFUGLRASVYwQDOuuCaa0IxTdi9273E6003dad2fvfZr/8OwOdfgFGzAuw+w71a1N139wNg+/Y8XC7fPvw/69kwD57XXAsRERGRK4ISiw4otmaXvEIndOoUDMDBg+WUlbnnNEREuMvOnDrBtb2guhrCvqj55VDYesTkmWduBaCqysWqVbt9Gl+KYSP9vA3znKbp0+uLiIiISOBRYtGIQF1uFqDU5d6l4uNS+P7365ac3bjRvcRsSko0AJWVTq5KcT/UO3NwT3wAHtlm0qVLFN/7XiwAmzcf8nmMC0gCoAyT3+HbZW1FREREJPAosWhEIC83WzNPmy8rITg4iJgYdxfGxo3uB/hBg7p56qZ1PwyAw2HAcXfZFzW7cS9ePBrDgI8/zsPp9O1wqL5GKNfhXrFqJQVUqtdCRERE5LKmxKIDiqr51grdK8zSu7d7AveuXSUApKTEeOp++uFfCQ+t+T33lAtMK3x63GTMmGuIjQ3j5MlzbN161Odx/jdJhGNwFhevUOjz64uIiIhI4FBi0QF1qpljUVyTWAwa5B4Odfiwe3nZvn3jPXVLSysZOcT9c9VRoMj988/eMrHZrJ6duOfO3erzOPsZYTxFFwzgBfI5Zzp9fg8RERERCQxKLDqg2snbxTWjl26/PQ6AoiInTqeLm27q7qlrt3/Lz++uAKCi0sA46i7fb4BpmkyceB3gHg61a9dxn8c6iU70xkYhTrI010JERETksqXEogOKr0ksymoSi7Fj4zznPvroLPHxYZ4lZ10uk6KTB+lUM8e70wHck7jDYfEOGDXqamJi3HMh/u3fPvB5rEGGwW1EAu65FhXa10JERETksqTEogNKtLr/LK95Rg8Pt5KS4k4ODh4sJzY2jNq50qYJ8+ZtY/Id7uOqfKDY/fMTe9x/TplyI+DutSgpqfB5vD/DnfhUA/+jfS1ERERELktKLBoRyMvNJtUkFpXnld19dyKG4d4oLyjI4umxANi79ztm/8xBbDSUlhvEfVfz+1aTj0+YzJv3QywWA5fL5De/+YvP4002gulXs0LUS5zBoV4LERERkcuOEotGBPJys0PC3X/GnPftDRvmXglq+3b37OywMPcmebUJxuqVn/Dze9w/9/zGgJp51He+ZxIREcLw4T0BePnlv2O2wdKwz9Tsxl2OyQrNtRARERG57Cix6IC6WsEAilx4koChQ2MwTdi7t5QDB8pISHBnH5GRNgBefz2X//cTCAqC3bvxTOI+EwRfnDH57/8eDUBxsYPXX//iwlu22iAjnKtxx7KMAirVayEiIiJyWVFi0QHVrgpVZbp34QZISLAREuLunli9+gS9enUCICzMPW7qwIECosMrSL3aXT9sH56duH/8jsmAAcn07Onu9Vi2rG16af6rZjfuckye5VSb3ENERERE/EOJRQcUYXH3WJjAQUdd+VVXuTfKy84uoF+/zgBUVFQTFGRgmvDss9t4dIq7btkBA/LcPx824XCRyf/3//0zALt2fcupU+d8HveNRjg34+5J+RPFOLUbt4iIiMhlQ4lFB2ScNzP7YFVd+R13JACQm1vKwIHu3oFz56oYPLgbAK+99gX332kQG+2u32k/nl6LSW+Z/PjHffmnf+pOZaWzzXot/odkorBQjIsNlLTJPURERESk/Smx6KBqFobi+HmJxezZKQA4nVBc3Alw72MxffoAAE6ePMexY2fJnOKuf/arul4LeyWcKoV/+zf3Nt3PP7+Do0cLfR53ghHMtJrlZ7PIx9WKXouSUhOXS70eIiIiIoFAiUUHZav55k5W15XFx9vo1s09Qfrtt88SEuKejNG7dyduuaUnhgF/+MPfmfOvEBUBOMF6FCgFguHWLJOMO68jJiaUoiIH06b9qU1in0IckVj4Bw7+i9OXdI3cAybRg6D3SB8HJyIiIiKXRIlFBxVWMxrqVLV3+Z13uodD7dpVwoAByRgG5OeX8+CD6QD88Y9/x2KB+bPc9asPGnDM/fM/4uDaNw1+8tNUAP7ylyMcO3bW57HHGEGMxr0V+O84w0mz6iK/Ud///MH9Z94JX0YmIiIiIpdKiUUHFV3zzeVd8ExeOxyqqsokKioRgC++OMWECdcRHh7MgQNn+OMf/87D/2KQnAgUg7UAOFBzvTKT7027HZstCNOEn/3s3TaJfw6JWHBP8XiMlmcHEeE+D0lEREREWkGJRQd1rXsjaw5Uepf37h3OP/2Te3a2zRaHacL//d8BIiND6NvX3Zvx1FMfAvCnZRAeBtVHDfjOgDL3NebnBDFjxiAAPvzwKIcOnfF5/AmGlYm4l7fdRimHTMf/z95dx1lVbQEc/+1b090zMOQQQ3eDCIKkoBIqgmCgooTdomAXBhigoohSUiKCgNLdMTDUMMF09839/jiXuTPSivn29/Pxce89fQbmnXX3XmtdZouqziWgGw2XXk9RFEVRFEX5a6jA4iKmT59ObGwsbdq0+btP5YLaO7+xz7Kdv2zcuCiEgD17tPbae/emUVJi5vHHOwGQlFTAnj1nadVIMGU8kI3Wids5JSpfQqPbelbkaNx119I/5RqmEIY72pyuB0i5qm3NzpEaVbFWURRFURTln0EFFhcxbtw44uLi2LXrzym7+kcN077sxyLB/JvKSIMHh+DjoyctzQ5o/SwWLYpj2LDG+PlpQx3jx/+k/TkCWsUCaUAu4HxgH7tPz+jxWiCyeXMS8fFZ1/wa3IWex5zndxwLc+SVj4yUOwc4VFEoRVEURVGUfwYVWPxL1TOBv07LUYj/zXQoLy89/fsHASBEfQCWLYsHYOxYbYrT1q0pHD2aicEgeHUSkAJIAUecOzHAdxHXVXTufvPNLX/KddwjgqiFEYCXyaRUOq5ou9wC7U/Hla2uKIqiKIqi/MlUYPEvJYSgibv2+lD5+csffzwaACl1QDi7d6cC8Mor1+PpqT3I33nnEgB6dRLcPww4CZQISND2UeANrcfcDcD33x8lN7f0T7mWr4hGD1iRLCD/irZp0fBPORVFURRFURTld1KBxb+Yrw4k8NUF+tg1b+5D/foegABqkpJSiMViw2DQ88wznQHYsyeNXbu03IYZL0I9P7SeFqkgigEJm3Rh1Ktfj8JCM6+9tvlPuY5oYeJ5QhHAR2RTLO2X3abyDCi7Xc2HUhRFURRF+bupwOJfzMv509t7gRELgHfeqet8ZUJKf7799hAATz/dpSLX4vXXtSlOQgjWzwZ9KoBAnkCbZ9UYEjsORUrBe+9tY8GCw3/KtdxBIDUxkYOdmeRcdv3KM6bKLnL9iqIoiqIoyl9HBRb/YiP9tT9z7JBsOf9b+379ggkPNznf1eXrrw8AoNPp+PzzmwBYseI4J09qD/IRoYLPHkGrEFUqMB7XtjS312EafT92u2Ts2BXIP6EUk1EIHiMYCXxADnvlpadd7Tniel1Sds1PR1EURVEURblKKrD4F+vrAyZnB+43si+8znPP1XC+8uTsWVdAcMstsfTpUxer1c7DD/9UESyMuUUQ66GtY80VtDMDAiwdQqDtDeTnl/PGG3/OlKg++OCDDgncz1kcl0jkLih2vVYjFoqiKIqiKH8/FVj8iwkhaO1M4F5WeOF1HnwwCm9vrR/F8eO+nDnjSsh4//0+GI06Vq06yZNPrqn4fM+HoHPGIAf3CTzP9coY0wGiajF16kas1svnQVwtndDxOhEAZGLjeTIuuq690uFLr663nqIoiqIoivInUIHFv9zYQO3PFBscLj9/ipIQghdeqOV858v77++vWBYTE8R112nL3n57K4cOpQPg7iZ4ro+2TpkDepUIbXqUDnh6BCUGdx588Mc/5Xr6CV86oXX/m0s+Oy4yJcpaqTGg+FPORFEURVEURbkaKrD4lxvhB17OJ+vbky+8zmOPVScmxgDo+eCDXCwW11P5woVDcHc3ICX07Pk1VucT+0vDBQHO0ZClB6HjcbRSTCYBkx9k1lf7OX36yhvaXY1ZVMfL+VdzDMlYLjAlqnJg4en+p5yGoiiKoiiKchVUYPEvp9MJpoRqr+PMcPAioxZffdUIkDgcAfTrt6lima+vO199NQiAzMxSBg6cV7Hs5yfOHQS2xQuM5xZ5ucG9Q+jVa861vyDAQ+iYTXUASnDwCpnnrWOrNBXKYv1TTkNRFEVRFEW5Ciqw+A+YFCIY6K1Vhx2UCFm284OLDh2CCAwsAmDtWgdlZa6v/IcObcwddzQBYNWqk0yatAqA1rUFPRpo60h/kNnADudGzepzqhC+/fbgn3JNbYQnHZ1TohZTgPU3lahslUYsylWOhaIoiqIoyt9OBRb/EV9WgzomOGOFNqdgT9n5wcWsWU2crwQ9euyssmzOnJtp1CgEgGnTtjNlynoAfnoMwn0AI9jCgI1AJlpiwx19GXXXUn74If5Puaa3icQPHcU4+Ow3vS1EpcSKuNN/yuEVRVEURVGUq6ACi4uYPn06sbGxtGnT5u8+lSsSaBCsqAGBOki0QttT8HCqxOFwBRiDB9fBwyMfgG3bylm/3lUhSgjBvn1jqVHDD4CpUzexeXMiRoPgg5HOB/lIAYHAMsAKxNbB1q4ZQ4cuYNGiSo0lrpFIYeQ5wgB4jyy2y5KKZW2auNZTIxaKoiiKoih/PxVYXMS4ceOIi4tj165df/epXLH6boKlNcBNaNOiPsqF8Hj4PNcVYLzzTnW0Ek/Qt+8BMjMtFdsbjQaOHBlH587RWK12Bgz4jgMH0rm1NdzQCO1vS32gHNgMCBB39KU8Iozbb/+e48cv0kzjD7gVPwbjhw0YQRIbpdbAwlopr0IFFoqiKIqiKH8/FVj8x3T2EmTVh+5e2vssO9yTCl5HYXiy5Oa7W+PmdhSAsjIHjRrtpLjYlbDg5WVi9eoRdO4cTUFBOT17fsVPP51gxkgw6ACdgCbAPhAFIA16eGQkVqORNm1mkpt76Y7ZV0sIwVTC8UGHDa1KVIl0VKkKpRrkKYqiKIqi/P1UYPEf5GMQ/FJL8GO0lncBUC5hfgHUPgHRcwdDpzLQC7KzrVx//f4qU6Y8PU0sX34bDRoEk51dxsCB37F/01FmjnauYBJQG+RPaCVo3U3wwv0UFllo1uyTKuVsrwVPoWMRNdABNuB1Mtgb51putlxsS0VRFEVRFOWvogKL/7C+voKT9QSnYmCwD4QZoEzCyfpRMKMP7O4KS9qwq44PI+46itns6hfh7+/BkiXDcHPTY7dLbr11AXm7ttPnXG5DqIA84Be04CLQDx4aTkpKIR07fo6U5yeP/xH1hTvtnVWiFlFAToHrXFVgoSiKoiiK8vdTgcX/gdpugsU1BGn1YXtteDhI4CUdoBdQxxOeieG7SfWp/k0uSSmueUX164dw+PCD+PtrHegeeWQ1A7z24eNsSCfqA/uAc3nbTWKgexv27Enj5pvnX/PreNmZyF2GxH6XK5+jTOVYKIqiKIqi/O1UYPF/RAhBW0/B+xGC7MZ6or/fBUnO7tkGQVbbQGok6XhjTnrFNnXrBpGQMIHAQA8Axj2wnOG1UwCQbgICgFVQUQ12+I0Q4MPSpcf4+ONrm/heV7jTDC2q0d2Wi6mZls/h63VND6MoiqIoiqL8Diqw+D/lrhfM6hQM/T+Cbm/jvy9VW+Bj4KmGwVRrv5fNm/MBbVpUXNw4fHxMSAmznvqCIE9tKpKhltB6WsxDKzYlBAEP3Q7AuHE/8uijq7Fa7ecd//eaSzQeaMcMeSsVkNSsds12ryiKoiiKovxOKrD4P3bDDXW47bbGkFdK/qhZ3Lz1uJYv4abj7KhounTZx7BhhykvtxMW5s2hQw/g5qZHOiTt8tbi5QZ2NyBQgBlYCUjIqxZG/RcfRALvvruNBg0+IiOj6Jqcs7fQ8wlRYAV9pA2vAYVVSs8qiqIoiqIofw8VWPyf++abm6lZU2uKt+SBebxdkI5BAp0CYVR1FizIIjBwM++/n8z+/TY++2wwAD/N28YdTQtBgHs9QC8QJwBnakV8ZDCtPngEYRCcPp1HgwbTycwsvibn3E34YJ6ldQkPeDqDdL3K3lYURVEURfm7qcDi/5xOp2Pr1rvx8DAgJTx1/SzGZGcgdMAjtWFIBGVlDiZOPMngwYd57rlCBgxoDkDa2p+JDtL65YlYkAhCysBnibbvPW7eBE59AjCQn19ObOz0a9bnwvxtIJZD7uh8HXzWLZFsqYYtFEVRFEVR/k4qsFCIiPBl8+YxGAw6bDYHn/X8lE7p2VozvBfqEbmiDc27+BEZ6UZyspkVK/yQsgU/LCmmkeksANILCIesPMF7YwTRzpSNnEA3ePBp4D5ycrTgoqDgj3e0axgtyHo0Cuxg87YznKQ/vE9FURRFURTl91OBhQJAy5aRHDz4AEFBHiBh86CZuOUWg4TUGl4cmtGCruvb4hdmRGtR4QPUYOWrx/F2mAGJriZggsfeho33CuoKoe28uYDXwsFnDBkZJdSqNY3jx7MvdipXxGoDe6qR/GnalKiTWHhCpv6hfSqKoiiKoii/nwoslAoNG4aQkfEYU6dej9Fix3zdO7BoL9gd2KXku3IdRWs7Uv2XdgT0DqrYrvj7veCQOKRE19BBQaFk5JNwZBT0re5cKQh4IwqqTSIvz5uWLT+ltPT350ZYnc29C78MwuOEVgp3AQW8KzN/9z4VRVEURVGU308FFkoVer2eZ5/tysmT47n3npbw8gro9hZsOA4OcEhIDnYn7+0mGL6Phd5uUFIOexIAcLgLZLhk4x7Jvc/a+PFGHR90dI5cGICnfCDqAUpKutGv30K2b0/+XeeZWGlwIvS16lTHCMCH5JAgVcc8RVEURVGUv5qQUpvYolxYYWEhfn5+FBQU4Ovr+3efzl/uk0928eabW0hIyAcfN3jwOujXBDzdwKjXVsovJdAMpSv0lBe6aSVr44BCSWDOdvJzLZiaBlL+YBNtfQnsAb5IBdvXTJzYgnffvRFxburUFTA1kRWjFp1bwQ9z7LThJFYktTHyi6h7ze6BoiiKoijK/6ureRZWgcVl/L8HFuekpRXy5ptbWbfuNPHxOVg8THBbWxjdETyMrhVTJWwScAY4DmQUQNJ+bVnTIHT9onFE+2pjZUeAL7KgeC633lqNhQuHXvH5GBpL7M6+e+2awvb5gq9kLi+SAcDHRNFH/P/+vBRFURRFUa4FFVhcQyqwuLDjx7NJSipg6D0/kDekDQxrA24G1wplwCFgGbBlFyIvByndtWUNAmBcU3ATUAp8ZoW4FNq3TyEmJoQPP4zBz894/kEr0TeSOLTm39zQEX7+XBvtGCET2Uwp1THyPTUJFYZL7EVRFEVRFEW5lKt5Fv6/yLEwGAw0b96c5s2bc8899/zdp/OfUK9eMD171uGeobHw9hoC+r/P3bpSPCzO+UkeQFtgKvBFG+Tteog8BRTCsQyYs1lbzxOYaITptdhevzNz5vgRGrqVBQsysdsvEfNWWtSgtuv1p1QnCgMpWLmBU6yX16Ypn6IoiqIoinJp/xcjFsHBwWRn/77ypmrE4tLS04uIinoHKeHMmYlER/uzpkjybAbsLgNJ1b9e7nYH3onZ5H+xFV2hJ5YB14GPybXCOgnzHUABcAZPz1wCAz3o3TuIgQND6dDBl5AQE7pYybm/ufcPg48nu/Izjkszj3CWw5jRAeupQ7SodAxFURRFURTliqgRC+UvEx7uQ7duNQGYNWsvADf4CHbWFZQ3AtNsAesFJAtAUG7Qk10nDNsrg5Ef9qZpHwNNT2zDq9A5stBDQDcdEAC0oLQ0kpQUK59/ns5NNx0kNHQLJtN6pEOiDVtI0tKtmM0OCgutSCmpJ9z4jhoYAQcwiiT+D+JnRVEURVGUv9XfHlhs3LiRAQMGEBkZiRCCpUuXnrfOjBkzqFWrFu7u7rRq1YpNmzZd1TEKCwtp1aoVnTt3ZsOGDdfozJVzHnigDQDTp+8kK6uk4nOTTrByNLAXWADMBb/TEOlMe7ACB+16Do7siLm3D8ZGQvsbOQxo54DaQGA9IAQ4NyIhsVod516ChGVrrHh4bMDPbzOenhsJCdlMgHEjGeMLQUoSpJWJdq1DeHGxDYdDCzLy88t45pm1nD1b8CfeHUVRFEVRlP8Pf3tgUVJSQrNmzfjoo48uuHz+/PlMnDiRZ599ln379tGlSxf69OlDUlJSxTqtWrWicePG5/2Xmqo1Ozhz5gx79uzhk08+YeTIkRQWFv4l1/b/YtCgBnh4GMnNLWfEiMVVlvVoLDjxOtQNAtKh4HtYUALJ9eDRIAhyVqy1AVZfMDUW4ClgjB6eFDDFAC1jMRo7odM1RBvJOE2VJItKZWrLyx1kZ1ux26Hoo1LK1lmQSJbqCgn9YCe+vpsICdlMs2Y7adRoLa+9lkKXLkto1GgHoaGb2bbt8kFGXp71j94yRVEURVGU/5x/VI6FEIIlS5YwaNCgis/atWtHy5Yt+fjjjys+a9iwIYMGDeK111676mP06dOHKVOm0Lp16wsuN5vNmM2uBmuFhYVUr15d5Vhcxp13fs833xwC4PHHO/Lmm72qLD+ZLol5SnvtlwX5P2rBgJSSDaVwwgxPZkC+HYwS3BIsFCUBbkZtaGOhhG2AGcLCj5LhF+vaua2IOsxl/PhObNumw+EQdO8eQE6OlWnvp2Da4oehjhbBFLxSTMEL50ZVKv/V185HCKhWzURsrDf163uyf38RPXoEsH17IZGRbmzcmM+JE2XUquXOkiWNadbM59reSEVRFEVRlH+Qf2252d8GFhaLBU9PTxYuXMjgwYMr1pswYQL79++/omlNeXl5eHp64ubmRkpKCp06dWLfvn0EBgZecP3Jkyfz0ksvnfe5CiwuzeFw0KTJx8TFZQGwYMEQhgxpVGWdqAmS1ALACr1j4L7+cHNr12jDSbNkZApsK9Pej7SX8fVOd9cO7MBcCVsE1Ku0Y3sx5MyER0fht/cgeYu6V2m2l1tSTpO0wxhqe4KEZ7YH8Pmks+zalYs2aKfDaNSh10N5uaw8AIKUoI/QYU9znHfN3t46XnutDrVquRMXV0Jiopk+fQLp1y/4991ERVEURVGUf5j/TGCRmppKVFQUW7ZsoWPHjhXrvfrqq3z11VfEx8dfdp9bt25l7Nix6HQ6hBBMnjy5yojIb6kRi9+vpMRMdPQ0cnPLMBh07N07liZNwiqWx6dJmj0BZuf0JwQsfBBubSPYckLi7wE1IyDmBKQ5q9beCizfbMWir9SP4i2p9cDoBJwF3YlyHM0PQo+2UG7mjbI9PPFE54rVly49ys0jv6da0kB0PgYa6Nz5iupEGl7F4ZAEBPiRmTmBoiI7n3+eSocOfmzfXkhOjpWl5QWUvOWO9bVSsl8uduZ3ZOLnF0blGXWV/xU1aeJFy5Y+FBba6NcviDFjIq6qq7iiKIqiKMo/xX8usNi6dSsdOnSoWO+VV15hzpw5HDt27E8/J1Vu9uqcPJlDbOx0rFYHHh4Gfv31Ltq1q1axfN9xSavxIP0BdwjyhneGw12fg0EHJZ+AWQd1jkOWXZugdLQu7Pw1kVGnw5EmE5RaIdcI1QAbeH0FMfcXs9/qDVKie2AqI0Y05ZNP+uPhYWTo0AUsXBiHoY43ERuvRx/hQYRdz97uP2PenI1OB2bz8xgM+vOuZ6xMZjXFdMKTOTKakJC3yM0tpVOnaPr0uZ5NmwrIzbUSF1eClFBaev7IRmSkifvui6RrV38++yyVmBgPXn659nnrKYqiKIqi/NP8Z8rNBgcHo9frSU9Pr/J5ZmYmYWFhF9lK+TvVrRvEDz/cjhBQVmajS5cvmDFjZ8XyFvUE8yei5V8DOcUw+nPttc0Bc7eDj14QFwPuQsuCGJsKd/apybzrnd/6ezqDCgADlDSGw9neWhQiBI4AX77++gBjx/6AlJJt21K0/Z8qJq3TOiKtelJ1NsJ+vR6ve2rjcMChQ5kXvJ5DlAOQiBWdTiCEFoe7uel59tmarFrVjJ07W1Nc3I3i4q5MnlyTBg08CQ42EhqqdQ9PTbXw0ktn6NFjP/PmZTJlSiJt2uzmppsOsmePKiSgKIqiKMp/wz86sDCZTLRq1Yo1a9ZU+XzNmjVVpkb9GaZPn05sbCxt2rT5U4/zX9S7d13mzbuV6Gg/bDYHEyas4ocf4iko0B7Sh9woeGgA4GxdUXnIbM8Z7c9gg+ABZxrMxlLIsEqGNnRjRFQ55BVDMlDq3KgZ2PycOxJw/UM9MBh0fPPNQQYO/JaUFNfDu+1MCbcvKcW90A46CHynOegEBw9mXPBacrADkI5WCaqsTPvTZrOft64QghdfrMXRo+3IyupMRkZn9u1rzSef1OPmm0MIDzcRHe0GwO7dRSxfnkObNnsICtpEw4Y7iI8vOW+fiqIoiqIo/xZ/e2BRXFzM/v372b9/PwAJCQns37+/opzsI488wqxZs/jiiy84evQokyZNIikpifvvv/9PPa9x48YRFxfHrl27/tTj/FcNHdqYM2cmMmJEU+x2BwMHfkdw8JusXHkcgA+fFzRzAAlAAXSI0Coy7Trj2sdrYWBEixce0CoHM6evJ9/UtcNC4FzufqX8biTU7tGEd9/tDcCKFScA8Pd3x8fZ4Ttu41n6LikCQHgbCPqqLfHxF+7MbnaGPc6UD0pLtVenT+df0X1o3tyHsWOjWLSoMampnUhIaM/w4aGEh5vw8NAhJeTm2jh2rJRWrfbw+OMnueWWw7z8ckJFU7/Vq3NISCi7ouMpiqIoiqL8Xf72HIv169fTvXv38z4fNWoUs2fPBrQGeW+++SZpaWk0btyY9957j65du/4l56dyLP6Y4mIzt932PStWaAGFwaBj//77adQoFJtN8uw0eOsLcPMCcxNXEvQrt8Az/QV3JEu+LYAaRjhdD3RCsHar5Ia7nQcYL8FQ9Zj19OXEj/Fk3rxD3HHHYnx8TBw+/CA9e35NfHwOXbvWoH79IJYN8sL9xggA/I6UMK9xY2KFR8V+LNJBPVwFAnYSQ5huKgB6vcBme/EP3ZuyMhvPPJNATo6VJUuyKS62I4TrHjz9dDQ9egRwww0HaN3ah507L1wiWVEURVEU5c/yr03e/idSgcW1sWvXWTp0mIXdLvHyMhIf/zBRUb5IKek5Bn7ZDt5toNiZP23Sw8anIb0MRumg0AHLo6G/r2DFesmAB5w7DgFucwYX5WijF/kOdl+fxc8/n2TQoPrUrRuE0ainX7+5rFx5AoNBh4eHgeIyKxH7emOI9dW6WAjBS4QxSgSyROZzGgsfklNxDTMKQugXoDVy1OkEdvsfCywqKy218/33WWzalM+vv+Zx8mQ5ej00aODJkSPanK+8vM74+xuv2TEVRVEURVEu5z+TvP13UjkW11abNlEsWjQUIaCkxEqNGu/RsuUnTJu2nVcnaOsU74NwZzqExQ7tp8Kgd+AmZ7DxrvMZv9xcacdZoJslifz5F+qedG6s19G6dTHPPLOOXr2+wWjUdnDzzQ0AsNkcFBVZqFndj9oPHaXkm0Qwa9WcXiWDxTKfSaRVCSoA9uS4unI7HFcWjw8a9B09esy+7HqennruvDOczz5rwNatLdHrwW6nIqgAWLjwwgnmiqIoiqIo/wQqsLgIlWNx7Q0a1JBZswYiBNjtkn370nnkkdVs37Cd0TcDNkiPA1FQdbuUdaAHfi2Bj3MkNSOrLhdmHWcX9mT1FD/tA29gfB0IuYGUlEJ27EgmK6uEu+9uxbJlw2nSJJS2bSNZv/4u6tcNJGfUDpKqLceYUoZZwmOkXfD8U41VS8mWlloueb2lpRaWLYvnl1/OsHv32Su+TyEhbjzxRPR5n8+de+EEc0VRFEVRlH8CFVgof6kxY1qSmfk4Tz7ZiRo1tEDgvfe2M/05G4+PAZ0O5HHQl4G7c9bP9gNQT8u7ZkoW2B2c1x0boJYPjD7XkbsRMKUDfPg07Ve7EXrXNsaN+5EePWpz8OCD7NhxH9HR/tStq5WekrkWznRei94mOb8ThSbLWLUSVGJiwUXW1OzZ4wpQjh7NutytqeKVV2oTFlZ12tPhw6pqlKIoiqIo/1wqsFD+csHBXrz++g3ExY0jOtqPpKQCJk9ezxuPwZa5gB3sB+CV68Coh1ILVDuibZtmg89+8+R/LrAQQvBFNx3ruzggFe1vt5sRIoJh0PXMOOtNu3YzOX7cVQFqzJgW+PlpJWBtSaXkvHIE6ZBIu6zaThvI1jmqBDRnzuRf8joPHnT1XzlXTepKCSHYsaMVw4aF8v77dQHIybFhsZxf5lZRFEVRFOWfQAUWyt/G09PE22/3AuDNN7fQtu1M2jaV1HY2v3vnU7iltTY6seYHMOUAEr7Qg6wLOudD/m/LD3RraOC7WBBfSFgvtcxvgL6dOVIg6N37GwoLy0lIyGPEiMUsX34bublPotMJCl6NI3f8XjL7b9QKzVbatyG5tMqxkpMvPWJx6lRuxevU1KtvhFejhgfz5jVi7NjIioCmb99DV70fRVEURVGUv4IKLC5CJW//NYYMacQjj3QAYPfuVK6//iveekJblpoJvSLgizHg5wGW7wA7WoftKeDo4NpPrlXS/ohkXrb25D98qI6fp+gIWi3gBZ22nU7AC/dzpkEjHnvsZ/r0+YY1a05zxx2LCQjw4P77W6OX0OqIFY+d+VpQISUtcUcAZ8sqZ41DYKAHl5KU5Ao8Dhxw5UfcJZNoKuPJkdYrukdubnruvlsri7tuXR6vvHIGgGnTkmnQYAfPP3+asjI1kqEoiqIoyt9LlZu9DFVu9q8xePA8li49BkDDhsE06TWWBasNhAfD4eXwzDL4bAMQDgzHFRKfAJ6HFt/APgPoHFDSBNydwxlHj0piz0gIBfY5t7HYYMpnkO6aEnX06DgaNAipeP/II6v4cMVhPLuH8e30ATykT0McKCChxSpAG0X56qvB3Hlnswtezylppmf5CUo3ZZHZewOdOlVj8+Z7AKgpjwJwNwE8L8Kv6P5IKWnQYAfHj2uN8u69N4Ivv0zDZjt3/4JZvLjJFe1LURRFURTlSqlys8q/zuLFw+jfPwaAo0ezWTHrHaLDzGTkSMa/CjPuhC51gNPAt0CRc8O6wGOw31mS1qGD8ZWKOnnXAaoBJmABROkBowGeuQfuGggDuoG3B5Mnr9e2d2jTpp5/vhvydAmFn51i15YUJGBv5EPwt+21ERMgN/fi3bA/JQfppsO9Zxje99UmKUmbCmWWrgSRqxljEEKwe3drAgO1boAzZ2pBhaen9k94586iS22uKIqiKIryp1OBhfKPIITghx/uYPLk6xACSkvKSdrxNdLh4NsVksffghevBw4C6cBnwFK0p/NWICslVc/OgyK7NhD3fSGuElIRcHY8+OQBbibo0FwLLF6fyOESA8OGLcBonMKsWXsICPDg0Uc7IgR8dO/P6O2AXuA5LJqIXb2QRh0rvEuYIbPJl+cnZifjmuYU8F5LSkq196m41s3k6hK6fXwMnDrVnjfeqM2wYaG8+WYdbn+uLjzbikxf96val6IoiqIoyrWmAgvlH+XFF6/j55/vxN/fHcpToeQMSJj2teSnzc6VzqUunAIWA2a0fIhj2p9W4C5n24h1xa596xoCxVD0JAxNtNLDt0SLOUxGjvTrz4KVCTgckkcf/RkpJS26dsc3dhQ5/jU4/XVdypK9ATC28Ce67FZOjI7gTbLozWnmrz9BSYmrr0VqpcBCuOuwNdeGDs9W+jznKgMLAH9/I088UYN58xrx+OPRLAoPhxreWO9vQnm5yrNQFEVRFOXvowKLi1DJ23+fnj3rkJf3FHv23EdN088gbUgJ73zpTAc6rv3nkQ0kA/OBLcAqYKe2yvpiSLdKDp7LtxYC34GCGG22FQteNXKXzYufbxRacKHXw6SRoNdRWGjGw2Mqtz2mo8BeA1OPnmDXk/VzNYrnJFFpcAQdkOGwcb9d0uGuNRWf51ae6CTBYdK2+jj9bEWlqbyrmgx1YZ5uzrPJLmPz5ktXqVIURVEURfkzqcDiIlTn7b9fy5aRbFx/Bz6la50VmtD+R0rIA598oAzIBnagTYvaDDWtkOeAnmcguVLhpXwHLNkAPj7a+5EjYesX8Ewz58N59TDE+09CiwaY3T0gAvADR5RPxT5abzfRdeIpcsftIb/DOt4tD0MKgVc7waHre1asZ0Q7TUeeNoohIj05dCiddafSkc7IovCirfiunNXhPHedYMOG/D+8P0VRFEVRlN9LBRbKP1r16n6s/K4ROJyJ0pUCjCZ1rVrORRJQqSl1ww0QZYAj5iptKADY5iZITBTcfbf2fvJkyZ4XJbUkIATSzQj33AyvTYDbgLvB5oaWsC0EQyd2p2vTSIo/OUXBzhzuiPgER7kevacNz4Yl5OWVUS4d5DmDhvK1WplZY20vli2LRx/pUXEd5dcgsCg+FzgZdZw+ffFkckVRFEVRlD+bCiyUf7zOnWtw103lVT+UsG7tKW1YIE3CYbRcC2DXUVgeCUHOqMJNQIizatTCAggIEMyapWPmTIHBAKt+goSx4Dld4qUHTAat5XdZ1eMhJa/vMHP33S0ZN66NlmTu7Y85S+vcHdw1g7vSTpLizKOQRVbsqWUgwNQjjK0pOeiD3Cp2GYrxD9+bivYVge7Ex5cya1YqqoK0oiiKoih/BxVYKP8Kn78RyLC+gvuH2yrKvaL3Aml1TZFytqXItsANz0DONGiXAcujoZ9zNtOaEkgwaw/ed98tWLMGzpVkLt0PPAO9faDJDmDm+edxskCycOERPvqoH4PGdoQb2pO3IxRp007qQAM9Q0hESrCnllV06ja1CSRuegOEj6FiX7nO5O0CiyS3/OqDAbvDuY0ADII9e4u59954qlXbSmpq+SW3VRRFURRFudZUYKH8K+h0gnnvCj6ebAIECPAMiEBYXU3uSJXg0HIwcksBBxxdJGnjsPJJpDZyIYFOCXDCGVx066YjM1Mwdaq2i5J0WD0cDn2BVl5qBejt0EI4E6Pd3bj9+Z1MXlfAqrY9oUNzbPluJH9dF3O6BxJXUrbwM2Ldn19xelVCBynJw47V4aDmPIj6DvLMVxdcJBdXfW+M1ErOpqZaGD487qr2pSiKoiiK8kepwOIiVFWofzpBmcXA+NH+2luJlry9E9h7lhtNexBICsugzoDtuOkELzkba6fZoOUJmLDcwWef7cZsNvPsszqmTnW1vKj4lxEPNRYK1t/pXzFSYn/sLl467UOZTTuwkA688gvIWBFN2ZoykBKJxJ5Wjnl7pcCn0rlLIbBL+C7dQr4Fyu3wzUlt6Z49qRw/fqHtqnJVl9UCrXm/tuW++yIA2Ly5gIIC60W3/TeSUjJ9+g4OHEj/u09FURRFUZQLUIHFRaiqUP98UsIT93k6E6txTZHKLWHVZyugQHs4zwuJJf50IfWSYUYE+OKgWEo+CISxq6F//28BePZZHQkJgkmTYMpbrv2dSZb07CLxk5WOAWB3wDPvIx96jZJ1ewHI+smP/PdO4sizUPBqHLYTlYYVBJRtLqTwUEDFR6sLLRiDynALK2F1CpSVWRg8eB4dO36O2XzpPhc55sqnIzhr1jFtWgx6vXZvHn/81NXf1H+wTz7ZzUMP/UTz5p/83aeiKIqiKMoFqMBC+VeLDHNFFUaDQOhA5+aDlCDjnE0tfAJpNNWLmz+CH2aVU3jLN5AP+AEvtmTTEwOZmSs5Y5HUqCF4910d/iHO/Qpw6GDXLiiYACPT4Jak0/DLTvhhJdT0IyrME4rt2mk0qk2Bb39S5sRQFtEZerZ3naxDkvW5ifydoeDQBlmyDBbC+ycR1i+ZfZ4FbN6cTHJyITk5ZXz11f5LXnvmb9IokkrAw0NPz55a4PLttxnX4A7/c/zwQ/zffQqKoiiKolyCCiyUf51PXgR3N3jvKe39e09BSADMeBGkFASGhlO/fhDE78ZYmgOA3SEAyao4I4Q1h++AI2jBQI1A7kuV1DoOd6ZIOpyS/OBM5UAnQAfiKeAG+PoF+H5qbZqnN4fX+8OXo9l6+hECo2pVPUkvD2heH4b2wpqr1avN2+4PnZprrTjs2j+9g+7FCL2WW2HokMbPu5MqdjFz5t4quzxZIHns50Kq1fmAadO2sSW9at5GirPk7rvval0AS0oczJ9/+eDi0e0Sjy8lpi8kbx/851aUys93RVIWy9V3LVcURVEU5c+lAgvlX2fscEHZfsHEUdpEoImjBJlbBe2bacuz83W8/tFD5OY+yfF3PLQpUVatqYUUOqjdBErROnX/CBRaEM7n6W/yYXsZ/NwAeB/4AnheIG8HpqCNcgD765oqzuetJEloZBTsBg4B32+GuNNQrtW/TV8RTfry6hTFafkP2O04tL55uEVWqmmrg4X9nSWq6lRnT3gdtsblATD1zS20m1PMO4nenO3UkaeeWsuurKpBQIZzVzEx7gQEaPfm/feT2bw58ZL3c3qclq9hdcC6s+cvj4/PJiEh75L7+CPKbZJfUyUW+6WDGrPZ1an8xImcP+18FEVRFEX5fQyXX0VR/h0a1YXgAMjOg7uehj3fu1MnWjDUtJIfl52gpFozaN/XtUFpERzzgSX7uLt9PhvH3chxC+gkWuu6cLQhgcYA2shF16XAFMnGHq7dfHESPC2eYAHMEOPuQfn3y0lLK8aGQDasjaVmBJxIQt+4DvYzaTh6x6D30qo4IaHslBsedc3IRh64T+1HeWgrrYLVFvBfmk5+oh+09tLW79wSs7cHh9ItIEzaOQoItpZyOtnBQ2OXk5dXDNRj+/YCunTZx6eftuC++1qfd8/yzBJzpT59O7K1MrZ6ncBstnHLLfP58ccTuLsbyMx8HB8ft/P28Ue9fQhe2APT2sP4xhdfr3p1X/buTQMgKamQRo3Crvm5KIqiKIry+6kRC+U/QwjB/He11wXFULc3jHpKMmfOEIqLnyV9w3UMikigYbiDrjVLGRZ9Wls5pgV7dmZyLAYyGkDsCqBEQq6EtKrH2BgMm94X0MiVLV4apgUz5+YlnTrVinfemai9sdnh0Al0P25iXI8QDkyuD7vjKFuQwLk24rLcRtaEEzjKdYAgaLy/64A6O/khodA6Vntvdg51tGhIHs6goqQUHLAwy5M6Kzz4qTwQJvSAxkakFEAdHn74yHnTh8x2yU/JznsH+Jsg3wy7nQWpXnzxV3788QQA5eU2Zs/ezxdf7CU3t5TCwnJSUwuv+md0IRvTtMs4mHvp9ZKTCxFCq9zl7q6+E1EURVGUfxohVZveSyosLMTPz4+CggJ8z3VSU/7RJr0meX8OFc3p6kbD2i+gRpSosp6UkvD7isi0euOdcoDx7XLZeMTMZv8bXSvZgKaCfj7wYxfXxwLX/kFCAXAQbTrUHhCHQMoDaO27C4Dd5Nmew1cHL01ez5QpG3DrHU7AlCYUL0ii6K14PMa1JOQDLT8i891yPCOy8b4tisKD/uTvCgeHA17+FL/Xr6fQURtpcXbuTkyFGpHn3wi7AyZ+C+ZqAPTvb2T58s6kphbx+KoC5ssohBDYpcTXIOkcrmNlCgyuAYtvEERFvUNqatF5u23ZMoK0tCKyskrZs+c+mjYNZ8eOFADatat2xT+nins5S7uRPkYoHCUuul5o6JtkZ5cCMHfuLdx2W5OrPpaiKIqiKFfnap6F1YjFRag+Fv9e7z0tOL0GmjfQ3p9MgqGPgMWiPcCWlEoysrXX93XT5gEVV2vGqwkd2GzsWHVnDuBLsOyyMNzDRl0T1DehfcWeDeQACPAT0AW4D2gJ0gjc3BSqtwN6wvU9CIqDPiskZ892Iz5+As93ieVUoza4fVkMBFE2fS/2tDJAEtjPgvdtUQjAr3E+PD8dnpxGzDv18L8Dqvc4WnGKhqRU1/lW/p5Ar4Ox7aFzMLjpWbHCSkS3X+nweS7fOaJwSGf3bgmFpzNYv/QgSMnKRAcFBeWkp2ulcmNiAqvckr1707RpXjYHK1eeYPHiODp0mEXHjp+TklLw+35oQNEl2m6cPVtIVlapVu1LUnFuVys/v4zXXttEVlbJ7zxLRVEURVEuRo1YXIYasfj3stslk16DD+dq79s3g5uuh+c+ALsdPNzh7SfgnR1lnC5w5TsAkFcCAV7a+51AUTz1vNZy6NADmPV62i83E7fTBHaBWyMwFwGdcGYtSa1Znx4tMHlawjgB1Z3vb4LO0dCqFWRnw3ffadN7Hn54H7OyDhD4VaUStc4v8FNCluLItVD37CCsEW4gJclN1uEQfnAyE92rj1DNIVh4cylvbS6iPDiYFSk6rWKuAFlo0a7F15V0XsXW/bBmO7x4PwD947aw4sNfce/eks8ea8bIGz+/4GZ+fm64uxvIyNAe1Hv3rsOJE7lMnnwdd97Z7LI/I7Nd4v6l61Id9wjePST54Aj82hdq+Wo3YOnSowwePL9iuw4dqrF16z2X3f9vde36BZs2JdG3b11+/HHEVW+vKIqiKP9vruZZWE1UVv6z9HrBB89B786SO5+CHQdh+wHX8rJyGPcyTBjpQe8xMOB9bfZQg3DwdJjYC67Ge/ZSjh/P4Z57ltOiRThxi4IgRpu2ZM7S9ueXAwU3oQUUeudBdMAboiLBGj2wAjYfhc3j0EY9nBISWpA1rynPHzzJiiZQJmRFnOP7ZAOsJ4uxhmmBgQT8J9Um995dENIDx0xIAto+5sXC2l4UWyWdl0vyLKATgjPn8jEAbA48cksJdSsh0U9LgB4QYWMvZZwtM4OHGyuswXBHX8o7t+QzCwQHe5JdZMWjTwfKft0LBcX4+JgoLDRTUGCuuIbVq7WmfOPH/0SjRiE0aBCMp+dFghngSN65qwGJQErJozu0ZfdthjXOXPtDhzKrbJeW9vtGLOLitB/WwYOZl1lTURRFUZSrpUYsLkONWPw3nDkreetzWLsNGsfAgO7w2JuQk68t/2U2BEfCjF/h5YFw0zjYZnT+0zgNeEogH4ryMeyZh63rXRDpLB8rtG/VBzaH5ceAWAlZe2DLSZhyE/hooyGhekmmQ+earlQKWEC/H+zjITwcNmwQeHvDsWwbHlElDMmMR1/fR1vfuZlJCiw6iSPXgqndBk4XNoOgrhiMAuuh83MUzHZtBOCLeCg7XkDiywfA4uDR9xvyrqcWWOSNBD+TYMBKKyvO6l0bC+1/Hknbyge6GGxhwUTkZ/EIJ9ngWY0VRFDr118ZHA3vvrutynH1eoHdLvHxMdG5czQtW0ZQo4Y/zZuHEx7uTUZGMSvyPHjpjH/FNmNSdvBFtXYgIMZXcHyodj0jRnzP3LmHKtYLDHQnJ+epivcLFx5mzZrTfPBBH9zdjRf8OyClxGB4GYdDu5G5uU8QEOB5wXUVRVEURdFczbOwCiwuQwUW/125+ZLq3aG0HDzcYM0XkJkDQyZpU6VoLZ1jeqJq7sKZfAgygc+5h1KtQ/eax+CGt9HWXTgNSgvBIDB1qoslxIddb3TlhnI/rFIrOlWZ30pJwTHgOjBlguVd8CmGhl+mkz5Yy1twFOow/6LHvOAg/t9qCSTXLcrn64d1ENAWnV5gP3Lx5GcAh0MSEbGFzEwrRqNgzOyWdG7jw4gYbbsdmZL2y8/f7taa8P0ZLbZx10P2CPD+CkDibRAUjgJf39coLrbQqFEIR45kXfQczgUc3Hsz1IzSuhues24HXK8FFmEegvQR2nm1aPEJ+/enYzTqsFoduLnpKS9/Xvs55pYSGvoWdrtkyJBYfHxMdO9eixEjqk7FSkzMp2bNaRXvn3iiE2+8ccMl75eiKIqi/L9TU6EU5QoE+gvmvysZ8CCUmeHRN8BocAYVAKcEhoZgc4De4nwY9gCq+7umOgEgEULQsZYNgV4bWAiNgjOF6CXYN58EuyT1znrkDfQH4NMcyUtZEKCDOAsU9hVwowShtcOgNxSdhp1fhhLiZcN22kDexBAI1cGD1fFJO4YhwsiBwYHoXizHIRwEvJbOXXYHX+qqI8SFAwydTrBnT2t69TrA0aOlfH3PPu7f2hLQRkXahQpi/SXxBXB7HThTBHENzvKrBHkmCtCa6b118NweBRIos8OiRUOYN+8w06b1Yc6GDM4cSaMsJYe9e9PYteusdv/Qcl9E+8bINhdoWtG1VUVeSa5Zsnr1KfLyyti/P107v3bV2Lw5CYvF1Szv4YdXVux74cI4AObPP8KQIY1wc3P9iluz5lSVQ/36a8IF75GiKIqiKL+PGrG4DDVi8d/3zXLJmGe1lhNQdXBi5WcQFAUNw2BXAvR4+8L/XHTWcpj3Fo5hj4PJHU4fhk2LAdc39LNn38SoUS3O27b9i1tIigiiR796JJULNpeDg6rHMVoh6pSdM94ConS46YoJjz1bcb72Ij16XzsCeF2EM1wEnHecyux2yU03HWLlyhxq1nTjxx+b0bCh1oDP4bwBOiGYllDOezW0B/CUb+sgy4389g4I4JvrwOKAeaegT3V4dDuEecLxIeBlFGQXWTmeYSbxcCrZyXn8XKsFK9KNUHlvF7q1D07VIju03hXbtt1NixafAhAV5cPGjaPp1+9bjh3LPm/TSZPas2HDGb755hZuXlTIqQNnsX7/S8VyLy8jRUXPXDQIUxRFURRFlZtVlKsyYqBg81yo5WzBEFzpmbxWFLStLfDxElzfWBDudy6bu+rDqMNi0ebu52jfrBNWvWKZXq/9M6uc5HzOsWNZ7Hh5DWkPzOPOo6fZECMoiIUpYYKQcw+8QmA1Cc401COqaZWezNKb0mJP7Hbtvd7X9Q3+21mpjDxjY3fpxb8z0OsFX3/dkOrV3UhIMNO27R6+/z6TV19NpEP7PXTtso+yMhsdo137NfhbeDi26n78nHnZj+yA0Rth9VmYuF0ripVaCh/HwezjkvAFBjqt92J0Xgz9RrXlSMm5PIhK9/Nc97tKt9ZY13Ufn3iiI40ahVS8P3u2iLp1PyA+PhsPDwOxsSHnbhcA7723nb1704m9YSHHwmth7d0ZTAYiIrwBKCmx8vXXlbL5FUVRFEX5Q1RgoShA26aCA0tg4xzYs0j7zGjQAovK1jwBpnPP6yUC4XytK9IRUbMOJGpTcfByRfQGw8UDiy++2Ke9iG7Ao2vCOZsr8dYLngsVZDYWJNUXLK0Ofb3B/WQGcsl+Ik5qTeuyEquTciyGlGN1yUqKoiTfBwlkBev40TuTrimlLLLn84BMwSod5x07MNDIzJn1ASgutnPrrUd49tnT7NxZxJYtBfTte4gCnaPi0f/16yy831Hwcksw6kAvYOH1EOoOGWUXvq9T9sOYjeCcqYTZDj1WQvFvelZ4VJpaFukpMOm1gz45czg//XQH06bdyAsvXIfRaGD8+LY0bRpGkyahAISHe7N06XA2bLiLp5/uzEcf9a268+gI1+s61enWrQbR0X4APPPMOnbtOkvv3nN49dWN2JzDVuXlrhOcO/cgMTEfsG1b8oUvEvjoox34+LzK6tUnLrqOoiiKovzXqalQl6GmQv1/Op4gEQJiap4/TSa/UDLyWbj9Rpi7HlYcAhKhcYyD5K3vUdB3Auj1sOwTmlYXnDmTT2GhmRo1/XlkxgP4+pgY0QEMekHz5h9z4EAG3PE0GI3c3EqwaBwMGPAtmzYlERf3IFFRfizZI7llxArksT0MubsFaycMpLRAYt4DdAf2ga6RjWotXXkEUgp0QsvbuJcAnhXhF7zWWbNSeeKJU+Tl2dDrISDASHa29mA96UAdFjfRelSMI4jHhfYwX2CRlFgh0ktwJFfSZYU2kynEHU4UQqSnVro3o1w7hpsOHo6Ftw9f+H439IOjzt56t9SEfTlwugieaw5TWlf9GRRbJRY7+BklGzacoWXLCPz9PSqW2+0OgoPfoLDQQnCwB5mdO8KNzsaHy9az8cnapKQUcvvt2lQ1g0GHzeZACGjePByr1cGRI5l07Fidp5/uzO23f09hoYWWLSPYtetedLrzv48RYjIA/v7u5OU9hc1mJz+/nOBgL7KySvDwMODt7Xbhi1cURVGUfzA1FeoaUJ23/7/VqyUuGFQA+PsKln8oGN5PsOQ1eKqX9nncKR1Jpx+maz0QQqAbdD/ut4zFEK7NsUo01WbCfCOjP5e0mwI5xZL4+ByoEQsGI0hYvAdmb3Lw448nKCw089RTa7HZJXd8KpHt+kFAKLpiCzmNIb0x6B8F+gGvgWOiAZEvKmYSCWcfDCnha1sxT2WbuTHRTt8zkhKH6/uEe+6JJCenMwkJ7ejcOZG77y6nZUttutBms6tD9cGsEurW3caCBZn4mQSRXtqRGgUKsu/UKkXtGgSTGsOGfnDgZhjXEJoHwi994a32gu6VBg/8TPBmW+hfHTpVinnuqKPlaQjA8ZuvPRxS0nopVJ8HD24VdOpWq0pQAdrUs/j4hzl1ajybN9+Nb4xz5wLuGtWULl1qMnx4E1q21E7GZnNQrZovXl5G9u1L5/DhTKSELVuS6d//OwoLLYDWcbxLly8pK6s63GKx2NDptHuRn1+OlJJbbllAaOhbzJlzgHr1PqRXrzkX/Lt0OTab/bJdwhcvjqNbty85cybvdx1DURRFUa4VFVhcxLhx44iLi2PXrl1/96ko/2AGg+DB27XXDgcsXmeijocBTxM4pGBngiC34x34dLsRGjm/NZew94yk0V0nKC+3QbMuzs+1b80/WuOathQfn0NCFlQ8y0Y3IDu7FCEE/v46xoxB6+YNkA2dZtRgvAii0/GqT+TleivfBZzmcMRp1losvPab/nBCCL78cgcbNpzhjTc28847dRAC0qPsFUnVaw8WcOpUOaNGHT3vPuiEQK8T+JkE77YX1PUThHkKPuok2HezoGO49uD9cx8YFK0FDbfVhsebCn7oLSit9KzePxpinF+IrEjW+nCccyAHjhdAqQ0+i4e7N1745xIa6k3NmgHExATRqGMdZ+KFICg6qOJ6d+26l59+uoOnn+7MgQP3s3LlHRgM2nkGBVUNVsLDtUBr69ZkoqPf47nn1tGz51c8+uhqFi2Kq+iNAbB27WnWrj2NlDB69FLy88vZti2FlBRtSMZisWG3nz817UKeeGIN4eFvX2Ya1k42bkxk1qy9V7RPRVEURfmzqKlQl6GmQilXwthYVlSVApg4Err3hts/g5KK1AqpPaQf2wn122gPuxlJEBatLT66E2Lbaq/nvwNlJfj7u/PN+ifpP825bfJxfHYtprDwGW21HZLhHzkgQUA2+AsHtT11zP7OwQT3YxzOLMejpVeVc7XbDGQlRhL0+T5Gxvrz4ohGeOgEXbt+waZNSZjaBPLanP582CcD+yE/dB7aw7Z5p4X0DrkAWK3dKnJHrpbNIfk1FdqFgq9J23d6qaTx99CnGszpLsgolTReDNnl2jSq2ABYcD28dgC+OO7al0kHJXeBQXfxyk53rpd8c1J7fVMNWHrDxdc9eDCdDRsSuffelsTH5zB16gZsNgezZw+umJ52ObVq+ZOQkH/e5/fe2xK9Xsdnn+1hwIB6LF1620X3sXNnCoGBHsTEfAhA//712LcvjagoX3bsuLfKugEBr5Gfb6ZBg2COHn3osuenKIqiKFdDNci7hlRgoVyJyK6StEo94UKDIGOzoLhM0vV12Od8HjXpJbsnZDNkthfxOc5vxQVg1srVcuezIHSw71c4uAmAWz58nu93Ox+GC7Jh6QyKip7G29uNxs9JjqQ4/wlvB/IlZAhq1YLTp3Xs2ZPKkCZ52J3fxIuEMmQtrbFffmYQhVlB6G12ai5di+XRauRO2kfAq03RB7sR/Z2dxNv02vlJKPm2nJyRBQgB27e3om1b17+H06dLsVgkDRpUDWL+iLknJSPWu94bnUWjLA4YGA3Lnff08Sbweltt1ORCuv8oWZ+mvY70hLO3/77yslJKPv10N088sYaiIgteXkZKS60V5YkDAtzJyyu/on2FhXlx9uyjFRXDKlu8OI5bbllQ5bPISG9SU4sBSE19lIgIre9Ibm4pQUFvAq78DkVRFEW5llSOhaL8xerWqPo+MwcOxUu8PQR7XxJMvRlCfeG1IYImTUI58LonvRprT8p+HoLqe74B9FDiLK9UvR7Ubgp3PsfyfZV27Kk9UO7alQpAfuXp996Ac0pRQgJ88YWDVq0iGW8MRSCwzk0i6Y1YLBlajVj/0ByiGx0nsslpSp5ogPA2EvRJG3QhbkgBibfrK6YQAehDdQQFGZESevU6QOPGO1i6NIsXXzxNnTo7iI3dyaFDRdfsnt5RV7C0Jwyrpf2iskotqAB4qhk0dZYFfusQ1FugjYRcSHKle5RaCuW23/ddihCC++9vQ2bm45w5M5Giomc4eXI8nTtHU7duIB980KdiXXd3A+7uF+8/mplZwsqVx9m3L+28Ze+/v+O8z84FFQDLlh2reL15s2sEpajo/KpjiqIoivJXUoGFolwDzeq7Xp/7Evru52HZWsmytZJnBwgy3hc80lt7SHczClY/JkifBjkfwqolg7jhlsFQ4vzGPyAM2vYGnQ6rvXJjB62y0D33LGfKlA3nesdpqkOvGzOpVUt7+8AD8PXXDhIfCeKGcfVY3rwr0upGxsvRSKtw9syWCJ3E5OF8KNVX/jbf9VonBE26+/Dqq7UBKCiwceRIKYMHH+bllxMBLUl8xAhX/sVXX6Uxblx8lfyDq2G1ScZ9AGe2ws6bwM/Z+sJNB+1DYW538HV+dqoInth5/j5sdklCYdXPdmZVfZ9YJIlZIHnrwJWdp7u7kRo1/BFCULt2IJs2jeH48YcZMaIZR448yNy5N7Nx42ieeUbLnbn++loV23p7mxgzpgVSwsCB82jZ8lPGjl1OWZmVc4PHNtul8y9++cXVMXznzrMVr+12SV5e6RVdg6IoiqL8GdRUqMtQU6GUK7HjgKT9cO31I3fBu7Ndy4SAw8shtu6lp+C0GCzZnyih6WUO9sNnkJ+pjV7cOsHVsdoBnYqS+ejF6rRuDXZ71c1qdoUztbVz8GheROSDqejLbZi9dM5duM6vpMAHLz/X6IMAjMCEGWaef76A8nLw8tKRk2MDIDhYK1FrMgmefbYGvXoF0rHjXqSEu+4K54svGjB+/AlKSuzMnNmA9HQzERFuFdWULuTbbZI7PtNe2z+HQis8tgP6VYfBtbTt7A5J1xWwNVOLiSI8oHGg1mejmifc1wBaLNX2YdJpIx4Px8IHHV3HbbtUssvZuFvec+26cEspOXgwg4YNg2nUaAYJCXmsWzcSm03Ss+fXVdYVAoKCPHn77V6MHr20YnqVTifOC8zq1QskPn48AIMHz2PpUtcIxrJlwxk4sME1uwZFURRFUTkW15AKLJQrtWydJCIU2jSGFoPhQLxr2ZAboXMLGNYXwoIv/PAa0lGSnQeiDsgQqEj2duY4VGEug7wMCK9Z5WOPAzmU7gth+XIHgwZpowheXmAwQEFttKBFaDsMssG3oySPdjxFkbsd+9ky9FEeSCDtVA30tjJC6mZiLvPA3bsMkCS5LcTT5MapxEewCSMmuxZM2O0Whg+PZ906rfKREFqVrHOv33uvLhMnahnUNWq4kZho5vrr/Vm3rsVF7+cHayQTvtVeZ0yDUL8L37f0Ukmt+VBud4VG525XDW9ILAadgI6hsDkDvA1QOEqb2gTgPVtSosVHnL2NijK611JZmZWiIjOhod7Y7Q4aNZpOTk4ZDockN/f87oKtW0eycOEQzGY7rVp9SkmJq2yWh4eB0tLnAFx9UJyefbYLU6f2uObnryiKovz/UjkWivI3uKmHoG0TgRCCLd/C8L7wxN3ag/Wi1TDhNWg/7OLb5zun7MhTMLw5tKstqBN6LsdBQFmlB143D1dQYaPiSbrMT5tKNXCgjrNnYeJsqPOIYM1WgZ+7c1upBSw5OTCwvyC5Vi3O1q1JrxX1QIA0g3V/Ph+lFJIx8hSZidUqDmuI8aa0tJzqj0qqPybJsRopKyunUaMZ7Nu3jrffrkFUlKkiqNDptG/uzwUVAImJ2rSrX3/Np7DwNy24K8mtlBuRmHPx+xbuKVjXF6a00srZTmsP9f2c2zlTEzz1MMNZ7bfYBm8d1F5nlbmCCqCietTVsDkkScWS0kvkbnh4GAkN1UrW6vU6jh59iKysJzhw4H4GD27APfe0xGRytR8fMiSWmjUDqF8/GB+fqo31yspsFBZqSeJpacVVlh069Js6woqiKIryF1KBhaL8Cbw8Bd+9I3jjMcHYoVRMbTmTCmu3nv8AWlxStVxtc0/Y/rxg8UNg0AFFwBkIstvhpy9xs1eaS28GLM7XoSYGTbORXyIpRPDhRsGhFFh4CNqf+yL7XB81NzCboSBTjy3BjTkTPPlF1mJpejA7aji4+4ZarJ3QDJzfqAsEIW1vBOGPTWgN/Xo+sJ82bT/D9lZjeKsR33zzM7Nn1yEiwkSTJm44HAecB5PoXc/N2icSnn76NBkZFi4ko8D12njxPGgAOoYJnmsh6BklGN9YcPgWqFfpS5VGAdAkSBDrr71/dje8uk9yx69V9/PNSbhuheTdQ5Indko2pjnzHhySb09KEou098fyJa2XStae1UZLaswD79nw0RFJ/QWS6O8kmWUXDzTOjZZUq+bH4sXDmTlzICkpj7Bs2XBWrRrBpEkdKtZ98MHWALRrF8W5wld+fq/z7bcHyc7W/h6c67thMqlf6YqiKMrfR02Fugw1FUr5oxwOSWEx1O8DmblQuxoc/RFMJtcIxE8bJH3vd20zrA/Me1dbPmicZNkv2udtmsCqT8r4dq8HD3/j/KebhxZYhLm2j/ErIbvQQR4+gECvg+sbwprDEo8TUF4PbabVHFwN9oAZM8DDA3JzYdIkbfTlhROlfFU7CYQk7/Mgir7xgMZeUAIc30voS0W499AOntZmDcZjxSxcOITbb/+eggIzEAQ05IYbgoiMdOf777MICjKSmKh96y4EdOvmz+OPR9O3b1DFuYybI5nhvO7Nz0CnmKubouSQki3pUGaHruHgbhCcLJC0WKKNWlSeYWbUgc1x/owzvYDU2+DNQ/DuIWjor3UUrzFPqzD1Wz5GKHIOwoS4Q8Iw8DL+salVDoeDZcvi6datBgMGfMvWrSkIoQUn5/IvJkxoxwcf7KBu3UCOHBmH0ai/zF4VRVEU5cqoqVCK8g+i0wn8fQXPP6C9P50Cni3Bp5Xkzick5eWSrfurbnMi0fU6qVJF0owcCAz05MHrwcPk/DATyP7N9gVe5Ekf55OyxO6ANUcAIfj0TYGvh0AKIEh7sA9zBiUPPgijR8Ojj8Kzz2oPrU/X8UDatV8V/qPzENPd4V7AH3zu9MG9R9i5yVp43BBGaamVfv2+dQYVADnAZlq2zGb27IYUFXVl5cqmGAyi4hv49evz6dfvIAMGHGTLlnwAwny1cxNI7h9/mmXLsq64YzVAwukyVkw7RfcwB+7OPh51/QQnh0KvKBhcE+r5afkXU1q5tnOv9Exul9BgEbxzSLuVcfnQ/ccLBxXgCioAssphyLorPt2L0ul0DB7ckMBATzZvvpuzZx9h7NjWFVWkunWrwZQp1xMS4sXJk7m8//52bM7hLyklXbt+QUzMB+Tnn5/LoSiKoijXkhqxuAw1YqFcK1JKhj8KC36q+nnt6lBaBumVgoOwIEjfrD0MR3WTpDqnzvt6QYGzWV5SjmT5Nhj/hEQioO0F/innZ+GjK6fIL7rio9WPwpAZUFgG9YMlo1tB6xDo0weslR6M9XqYOxcOH4bPKMb9Ja20qaXMjfTTNaBMEF3nFCJQS1IQwHVnBN82WIDF2XDi3ntbcuZMPmvWnMZg0NGtWw0OH85k/vwhuLsH4HCAh4eO667bR0GBay5YaKiR2sMas73IV3uiP3AG9ifSq1cAJ06UUVxs58SJdvidq0HrFB9fQr16ngghCA3dTFaWlVtvDWHhwsYX/Jk4pKTcrlWMunGVdqjve2gjDxO3w0dxrnWreUFKyQV3w3XhsD690r0TWlACcPhmaBR4/qjFwRzJVyfgzbagv0R1rAuet8PB4sVHqV07gJYtIwH44IPtTJiwCiG0nI7hwxsTFubFa69tBuDRRzvw9tu9r+o4iqIoiqKqQl1DKrBQrrXjZyRL1sKWvbBqM9hsrhwMP28oKNZyCkr3gcEg8GohKa3U0LlWNZhwJ0wYKVi1SdLnPueCYIlwh+pRqSQRCQ47zH9Hy6Ae/hjnaiYVzoB2U+BopZGQnyZB17rw1VeS4GBt1KKkhIoRBSnB/81MfB/VEjQcdj0Wswl3zzIEMFj4spRCYmxu1Bkfyoo1S2nc0MiPy4awb18abdrMpPJvGpNJT2xsCP3712Py5OuwWCSjRh3l559zXQFGp/pQN1x7nZgO6yuV2UIrY/vllw05fLgYHx89jzxyksWLs6ld2509e1oTEKA9UHt56Sgu7nbVPyerXVLtO23k4f4G8G57iFnoCi4iPSGtVAtGDg6GgWvgjDOX+uOO8PweyDZDuIfW0K/QAp8dg/GN4KFG4PsV2CRMbQXPtvjjlajKy600a/YJx49fONPdYNDxySf9GTOmRUWOh6IoiqJcjpoKdQ1Mnz6d2NhY2rRp83efivIfU6+m4Ml7BMtnCLK3wpuPOaf8CHj8bm0dqw26jwKLRVL2m4bKCSkw8TXt9b6jlRZkC0SqYOur/sQ4TvNuj2TcdTYoL4XUBGf0IvHxEDSIqLrPOz4Dd3ew1RWENBFs2SIYPBhatIDbboMJE2BMeigf2CKRpTp0ejvuntrUGoddcOCdEKSEeGHmG52Zs92Hc6DOUNbEQd2W4SxdOhy9s/meEGCx2Nm/P52pUzcyYsRiSkrKmT+/Efn52jSpli29oZor3wJTOXp91WlQ332Xwfr1eTRrtovatbezeLE25HP6dDlhYVsq1isrc+BwXPkUqnOMekHSbVB6F0zvpOVoJA2Hz7vAxEawsb82stEpTEsMv7WWczqYHu6qB2v6aqMcGWXa6McLeyGlFJ7YBaHfaEEFwJaMS53FlXN3NxIf/zBbt46he/eaFUGhENCnT13sdgf33rucmjWn8eabm8nKKmHLlqSKaVOKoiiK8kepEYvLUCMWyl/hbIZk92Hofx3c9yJ8uViLA1rGwt64C2+T9At8NBfe/BzcjGCxaSMd5oOub6NXrz7JrbcuoLjUBt2HoctKYto9vrTq3Zrr3xLUD5ccTNG+XxjUApbu0zqHn30Xwi7SN8LnYTuWCDMhj6agN9opyfchJyWSag1PoHM+/EurIG9BCAYj+A/NZJqIpG26jpMnHXz4YS6LF88lJsafkydzsNslHh5G3N0NNG8eTteuNRg8uAEt3wnALpxTnXLS8F6/huLiGnh66rBYJDabxGAQ2CqVedXrz28MqN2HZvTqFVjlM4dDViRBX8o8mcfrZDGTarQRnlWWZZdLPPRagvbmdK1Z3y21YGEPbZ8Wu+STo/DIDm1qlKcBSm1V9+9ngsw7wKS/tqMIp0/n8vTT6+jbN4Y77mjCe+9t5/nnf8FsrnqDOnaszurVIzCb7QQFeV5kb4qiKMr/KzUV6hpSgYXyd1i1STLsESgsvvg6zz0Amdnw2ULw83GtW76/asWp3NxSRo9exvLl2lQiIeCmmxqwdOkxGjUKIfaBB1i4u+pDbbf68N5t8PIyuLsr9G8uWHdEcucsSMvX1hEBdtzvLKZMr1We8g3Jxi84F6F3/Uqx5+sx+NupJYz8aKlNRCgUFsKwYfDss4KjR5OZOnXFhfsv3Pks6JyZ1IW5sOQjvvpqFF26hDJnTiaTJ58BoG1bH3btKsLhgOeeq8GpU2XMm5dZZerVu+/WYdIkLc/kxIlSOnfeS2amFTc3weuv12HixOokJJTh5aUnNNRU5TTayRNkYONGfPhEVONS4vIk1b3Ax1T1fm5MkxzIhXGx8HEcvHpAG9nIM0OuRWve91QzGFDjz52iFBeXyS23LODYsarZ/nq9wNPTSELCxL8suDCbbbzwwq/07RvD99/H8fXXB1i//i6aN4+4/MaKoijKX0YFFteQCiyUv8uRE5KBD2pVpHy8oOg3icOPjoaUdJj/E0SGQlqW9nn2Vgj0P/8Bde/eVObNO8zbb2+t8tA9aVIH8hv1YvYWCPeFtIKq2+l1kPwO3PAWHEmtukwIWPcGnLHAGGd/DI+MMoK7JCEMroMIIPSDUHZNCgC0TuA2G/j5wcKFUFBwlPff387p0/mkphZpG416nope2mVFsOA9AKKjfTl9eiJ5eTZSUsw0auTFoUPFbNpUwIQJ1TlzpozatbcDcNNNwSxblk2tWu54eelJTTUjJeTmVh02iIw0kZZmISjIyM6dLTl1qpzu3QPQ6wWNZTzF0kG9dAOzbNWJjnbnWun1k2SNlhOPDigbfe1HLi4kPj6LAwcyeP75Xzh+PLfi88mTr+OGG2rTrFk4X3+9nwUL4vjii5uoVSvgmp/DokVHGDp0Ia1aRbJ7t/YXq0OHamzdes81P5aiKIry+6kcC0X5D2gUI4j/CV54EH76DBrV1T6vE6090K/cCMnOSkQebue6XGsJ4RfSsmUkb7xxA0OGNEII8PLSphm99942PPf9xI7nHCS+DTWCqm5nd8B1b5wfVHi5acdLOwWjowQBZkBCWagHRXlVH0QlcHZALsbmpfhNzsJu0KZMFRTAHXfA4MGxbNp0N2fPPsp77/WmY6fq52rNav8ZXKMISUmFDB26kI8+2oKHRzmlpRbWrj1IcnIceXllREYaCQ09id47Ea9mgbh76UlIKOfQoRJycmwVQcULL9Skbl2tsVxamgUpITvbSu3aO7jhhgPExu5ASonZ2ejjUEIpt956mN9+F1NcbLtokz+A775LZ+vWfNaty6VZs50cOlRUseyppuDtbP7nAB7bCQ0XSlYm/bnf99SvH8LQoY3ZsGE0sbEheHhoJzF58no63bKMiOrTePDBlaxff4YGDT7i1lvns3dv1b8ADzywgvHjV/7uc/j551NICUeOuEarMjMvUnZLURRF+VdQIxaXoUYslH+KzBzJuu1wfTuo3QvKyl3VpJrEQF4hpGRATA04vuri33o7HA5OnMjF19dETMyHlJRoNWarVfPl229vplOnGhxNhZR82Hwcpv6gbSeEloeRUQjtasPMDVBshif6aM33bvwYuBlnoz5JtQZazkXRfj98mruGQQSgi3Mj8vUabFktIFty55M2vn7dDYC3ZSbzHQUceKE61lQ3dF52TCHllE9+m/r1gyqqHklZtWoVgNGoY+TIZnz++T7odivUjOXxXg5qFaRx9qyZ+fOzOXmyjFtuCWHRIq0E7dmz5SQmmikosNK376Eq96pZMy/y9/ogkWCDJLcMZsyoR/fu/jRo4IXN5qBNmz3Ex5fy3Xex3HRTSJXtt28voFOnvQgBDod2njExHhw/3r7KeuFzJRmV2kxEeULK7ef/DHNyLGRmWmjY0PuiP9/fw+Fw0KbNTPaWuMEjI2HzPpjzQ5V1GjQIZtmy4SxfHk9oqBejRi0FYOXK2+nTpx4A48ev5PDhTH76aQSffbaHVq0i6Ngx+reHAyA6+l2SkwurfBYR4U1q6mPX9NoURVGUP0ZNhbqGVGCh/BNt3CUZOxmOndbe3zdU68p97/Oudfy8od918M2brgTlmx6UxCfAt29Dy0aC5OQCunefzalT2jwmb28Tt9zSEDc3A++915uiIguf7/Rg2X4degHzH4DqQdq+qk2SnM0Hg157aHac+00SBoSD6GVHp3NgLzHQpv5pMjy1b/WdtaHIeL8a5qMehI9LxNjEgmmpL60Lvdk2UvtmvHiLD3kLQol64zTCXTIm148OeyM4cOAAp0+n8PXXBygtdTXeEIIqU7y4dSJ4+VLbv5yUj9/Bw8NARsbj2O0CT88Ld6Z+9tk4vvsuk4gIH7ZuLQQviC50dg90QJLRVcLpqaeiqVPHg3vv1XJX/P0N5OZ2rrjXFouDVq12cfhw1W56UVEmUlI6Vfls8BrJ0kpNEXWA9W7Q/Sax/FxvjrVrm9GjR9Vk9D/q1Klc7l5WwAafGpCWhe6lj5k5cyAzZ+4lLi6ToiIL7u4GysqqTiPr2bM2a9aMZMGCwwwbtgjQmvZt2KBd0L59Yy+YN+HhMZXy8qr7qlMngJMnJ1zT61IURVH+GBVYXEMqsFD+qaTUGucVFkOD2tpnAe2goKjqeiNvgq9eF8z4VjJuivaZELD4A2jREOwOO1/N2sTU95JwFCUCDoSA8HBv0tKKue66moSHe/PDD/Fs3jym4iFx6AzJwl2u4wicjb6dZr0N9yQCRtAJG2HVTiOsDhz5bphqm8EB5lPuuNVzNemQhTqErzb1yJZuQNp1GKO0gEQWCVKq1SHEU09qqiAxMY8HHviRVq0imDixPbm5ZTRv/omr6tFtj4PJA0oLYeE0AD74oA86neD11zfTqFEIS5YMx8PD1WSvUaPpxMVlMXlyN5KTI1h9Nh/dj74V15eor1ob1ttbR3Gxq5Rt9+7+fPBBDDExnrz++hleeimR3/6GFQKSkzsSFeVW8dniBMktv+nS3d+ST2CRma+e1Hp5bNtWQMeOewEYMCCI5cubcq0Ffi3JswBIjnbNo0E9bV7c4sVx3HrrgvOuBSAoyIMPP+zLyJFLsNnOL+sbFeVDcvIjVapvWa12TKYp5x8/0IOcnCev1eUoiqIo14AKLK4hFVgo/yZb90le/RSaN4QVv8KBeHAzwejB8N3KqkGHj5eWP+HlAT3aw7yVkhDvfAa33MJXX+2vWpbUFATe9enRIp21a0cCWmCz5gj8dBA8THBbO3hjJczdDn2awspJAo9xkvLmIFpJpAEQIISDwKgMvPxc02CEHWTlQQRJRd42AHZAB4WvB1K8yY+Rj9qZ0dWTuXMlN94oiIzUVj58OIMbb/yGjt1qsdA0SNuP3QbfvOo6VqWRjdBQLw4ffoCQEG+OH8+mfv2PAKhXL4iFC4ewvzq84JdXsa1Xp0LKMhxkZlooKdEeouvU8SA42MCOHb+J6JymT6/Hww8fx+HQmvWVlDiYOLEa994bSWysFwCH4kpousXDeYKV7oHZzsI6RdzaJ5BHHz3Ju+8mg7eRgL5RnPq6JgFu2spWh+T9w3BLTajl+/uSv6WU6D93BYeHbobGlTqGv/TSeuLiskhOLmDbthT8/NwIDPTgzJl85/aVdubtAY+O0qZUrdvBrFkDuPvuVhWLN248Q7dus6sc/1zckZPzJAEBHr/rGhRFUZRrTwUW15AKLJR/K6tVctM4VzK3lFo1po+ehftfuvh2M16EMNNRXn11E3v2pIHeG+pOAgRh+l2kHW570d4P5VbJ5xsczHl1IS0bePOjZz+ScgCThNZ2aO+KHty9SzAYbZhL3fEx2fCunoKUghsSgthWI48SgxbYWBLdKPwxiOAHUhE5emSw9rlhrycJXaKoW13H8eNV61BsPynp8Aqce0z+qvtB7rpracV9CAnxJCtLm6IUFubF3Lk3M3fuIb78cn+V/QQ9FIP3+y2c7wSLRQ1aCk/27y/innuO0bSpNw8/HILVamHGjHzmzMnA1YtPUquWOwsW1GDfPiupqRK7XTJlimvOU1iYkeuuC2D+/EzoWQ3q+RHZ2JfUc8nqEmrsSeXMp9Xo0XM/v2wthKntwMeIj8XGdL9c7hwRzn2bJDPjIcYXjg89/2cjpbxsv46DuZJmi13vv+gCo+ufv43NZue997bRv389CgrMzJixi4SEfKxWO/ff35rRo5fBg0OheQNtg/teJizMix9+uJ2ICG/uv38FP/544qLnsWrVCHr3rnvJc1UURVH+OiqwuIZUYKH8mzkckl+2w/JftSlTg3rAoJ6CZjdJDh6/8DYe7pC7HdzdBDM/3899r9YAo5+20JLNgJ6e9Ozixfg7XQ+du3adxeGQtGtXjQ8/3M748atwc9PzwqJneX6xwHEuAaM6uNdMo269SKzeEJ8HOPOdhXAgpaC/jyCpLI38+gUIqyBpYm2kVUeD6acoMzqqTLcqne9D9u2RZGZCSIgWXGRkSBYdhMeOFOHXL4fsjyPJetnE4xOXM2/eYd56qxf339+at97awpNPrr3k/fMcHk3wN+0rRhHeIYJbda6KV6dP59Ks2ScUF1t4//0beeCBtpw4UULr1j9TVmaiS5citmw5TmSkD0lJj7B5cwHduu274JSicyV46VsdBjnntkmgwEw9u5njXl7g/pvckKUJbHgykL6n/Cixad/6l90lcDNoJ3zmTBmD97qRXeSg5dKjfPl5fcxmidEoCA6u2q/jtf2SZ3a73k9oBNM6XP3oR//+c/mxbU+ICNHu270vVywzGnXYbI6K6z8vLwZ46KE2fPhhvyqfrVlzipISC4MGNbzq81EURVH+GFVuVlEUAHQ6Qc+Ogg+eFcx+TTCop/aguOQjaFgHnrrXtW5MDW3aVFk5vPABHDoueeXbZmDyc5V9NQXzw0ZPJrwqORafD8Dy5cdo334WXbt+SWZmMYsXHwPAbLZzW6MCbJ9D9Y3TYduP8O0S/J/7jkNdBHtjwTgPcFYYlXYdIFhRCAdLw8nPCCY1oRZ4GcGup1qJa3qMw6796vIcWoS+upV339U+P3PGQa22Vp6fbiN0/Fnc6pQT8mAqexLhs88GkJ//FA880AYhBE880ZnJk6/DaHT9GqxXLxD/hn6ErOyKsYkf+hpVqzzN+OEwR45kkpNTSn5+GQMGfEdxsZYD8vHHuzEadXz//R7Kyg4Be9i0SZsClZJSxKFDGXTp4k9RUVcKC7vw/feNqFlTy7OoU8ednJzODBsWCquTYWsafLYbCi3g58bxIN+qQUWxVQs6elSj/2tZlDhzoKWElvcnUrf9Ph56KJ5aPePYnwMpFh3LTX507ryPatW2EhW1lbw8a5Vr21I1fYQTv+lncqWWLh1ORM0g59wmQZ3Y0IplVqsDX19XbklsrOv+BgRo/UH278/AbnflaiQn59Or1xwGD57PoUO/OUlFURTlH0WNWFyGGrFQ/utGPSX5cQNsmgPHEuAWZ1EevQ5szjSLQT1h2TqJrJSbq8tZy+BueezenUpiovYU+vnnA3nkkdUUFJgBWLZsOAMHNiAg4HXy87Uk7YYNg4mLewiAkTMlc44CbUDEgRz6m5MTYDgGth+hYd9iSm5JwW4zkHaqJtXrnQQB0g4ywUQvPw82+RRR7l41gdiaZiTED4K8BJ8SRYyo2uDOarVz6FAGbm4G6tYNpG15PPk+Ap9kMyn7I/HrnwtC+zVZ8NIRCl4+AoCPj4miIgsmkx6LxY4Q8NVXgxk5cskF7/Mrr1zPM890rXhfVmalsNCM3W4kIsKEEIIDBzJo3nweWtRQRMzwoZxoEQ0BboRIGw+2MvLd6yc5/kMaPNYcor0r7lOFcjsYBPyYCDV8obmzMYkEZhyGA1q53iFDQliwQCu5m5hYRvsNJtItriCrcQAcuuXiIxaLEyQ2CUNrn7+O/9eSAmdrj6M32ShLycLLy0R8fDaxsaHEx2fzwgu/8sUXN3HvvT9QVmYlNNSLdesSAK0TuL+/u7OcbyRr12qf3357E+bOveWi56QoiqJce2oq1DWkAgvl/82UGZK3vtA6fXu4wWNj4OXxgjZDJLsPO39dSMCcAWc+rbJtjx61Kh4OAYYObcT8+UNwc3sZi0V74K9Vy5/Tpydqu5GSvYnw61EY0QEafAMFnQCDRJ+Yg71GECDgJBAEhjALdpse6dATFJyFd1iOa2rUbxO+z31GxZfnCCAKIyMJYBQBuImqg7ZSSmI4hk1ChMNAUqbAEG7VKl5JSf6TByl87ziGOp4EfdyakhknWfXIDXTtOts13QtwdzecV0rVzU1PUtIkPDyMDBjwLZs2JREc7MGuXfcRHe0PwPDhC5k//0jFNs2bh7Nnz1gkoNdpF3fkSAkvv3yGCc/UpN/PkO/nAQLcpAMzuvPvQaX7wOlCeHOf9l4HUREmdDpBSo4NOa2zdp5FZsw+bgS7wWNpybzySiJjx0Yy6NE6pBRLhtXVkVwsiZ6n7fLH3tC3etWDBnwtybcAUnJXWiq3j4li4Bp4qSU80ezCwcqaNScZOHDeefetsgtVjbLbHej1avBdURTlz6ICi2tIBRbK/6OycklCCtSrCQbnfP3npkle/Qw83aGkTAISkfwN0pyDu7GU8rLzHwh1OkFMTCDx8TkVn7m7GygtffaCycRSSrLs0Pq2JSR/fxDGdMY4sQfWyr+ldgNNAZPEzbMMh0PgG5SHm1sptiIj5Q5PfIPywArWdBNutcu1Z+3fHM4LwTOEcYcIwCEl75HFMcysodh5MmAv0qHzcSDsIPTAen8cS/2JHH2EtGaeuNsEx0wN6dr1CzZtSgLAYNCxdevdjBmzjMOHM9HrBXa76wLc3PRVKm717l2HlSvvIDGxgLp1P8DhkHh4aP0iPDwMlJY+d9Gfk0NKfk2Fo/kQGwA9V0okAoOQ2BxU1ACuveY0p3vVBgl1jqdzyssHQj1gznHYngFNAuHhJlrAseg0DKkNeWZ4crt2oFB3LWkcaPXrSWr1DGeRXRstaWgr59B9Huj12g22OySes8Fql1r+xKdHCH6oIdl2bSqXdQwYdBcOLqSUHDuWxXffHeb48RzWrj1Nbm6Zc5m2zqpVI+jVqw5CCB58cAWffrqH7t1rVjTb27dvLJ6epgvuX1EURbl6KrC4hlRgoSiagiLJe1/BwOuhVcVsFIkAGsfYObpjAza32uAeDsIAtmLI2QQF+87bV3LyJKpV8+PFF39l/fozLF9+G76+bgwbtpDc3DJ27DhbkbtwoOxFXjwFq7PhRgu0s8B0f0g+75/juV9lzqfpHIlb9TLCaiVTku/LMs8QVhjy2KAvJBVbxSYxdi/a4s5cQ855uzu3R32OEUeQlZKdPmR/GkW7DxNI99Kmex0kBnu+lW++OUBaWjEjRjQlNjaUHTtSGDjwO1555XomTlxV0eH8nC5dotm16yxms50hQ2JZseIEpaVW9O567jh4Kwse3kD56nRGjWrGu+/2JjDQE4CsrBIWLYpjyJBYgoO1crWrV5/gvgdW4vvknTSrF8BrbeCmNbAvR+viPSltK0/Ixjj8fao2GwH80opo4u1gi48fniey6JZfyMrWdbSFB3Pgq3h4ojmEa8fnQA546KGef8V98p22j1E9fXjggSg8q3lSa74zqJDAurO4tQ7C7Cwh+0knGNvwypLCd+xIoV+/uQwb1pgvv9xX0ZyvVasI3nmnN/36zT3vvj7wQGtmzOh/RftXFEVRLk8FFteQCiwU5Xx3PSVZuBrKzKDTaZ23z/tVcu5t/h7I+BFwVQFatGgovXvXITDwDaxWBw8+2IaHHmpLbOz0845lNj+HyWSo8tnRcsmEo7DmJHgeBdONkH8utzsf8JDgzBEWOgfSoc2FqucQzA2H1+cWs++BdGxurlGWKo+6ztikIrDINOEItWiZD7/449s9v6L0xRtEMEz4X/J+HTyYzqpVJzmit7B+dBCRJ81sbdOGWbP2MnbsD1UqI9029wa2Dg/EkV5GcrXlILWcg+7dazFiRFPefHMLcXFZBAS4M2NGPwwGHUOGLKzYPifnCQIDPZFSMnt9JmFGG/26zISurWCEs9qSlOilxK7XRhEMOEc4Zi9jSG3Jzz0HUXDueb1y50MBoRlFZHp5gJfzZyKBVUmwRJsCF9Y9lIzhDV3bppSAvwl8tEaE1b0EJ4aCm/7KgguHw4FOp+P997fzzDPrKrqtnxvwCghwJze3vMo206bdSP36QWzenMRnn+1h5swBTJ68gbAwL9544waaNdOaDmZmFmM06lXfDEVRlEtQgcU1pAILRbk4KSVnM+ChqbB1nxY0dGwB1cNh+tcloHd+y12wH5GxHJObAXO5g5de6kaLFuEMHPgdADVr+dOlT1/mzFoNlqojB0lJk6he3e+Cx3c4JDqdwOKQjFkLc4+BbwIUmoDhEgyABag8M8aOVonKFwwmC36hOXj5FWIu9QArmLzL8c13pziorOJ5Ou+96gROSEZWmsp/bnpVT7yZJapf9l5ZpKQtx8lHyzVZSU1ihQebNiXy/PO/UFRk4aab6iOerc/nunyQYLh5O6eWJVbZz4VKtFa2efMYOnWK5v33tzFx4uqqC2tHgZ8PpGbijoNOHz/AukyDttPiEnhhOoEDw1j69q3sSTcxaa/rxpl0YHWApwFKbNoJjKwr+PqkxFhkwfbcTmSpHe5tCG1CXTepzA5u+ko3DaIcVpa0tzL83WzqN/bm1dFBNA++eKBx+HAxFouDFi18WLToCK+/voXk5AIaNw5lzpybKS21YrXaadx4xiVL2Z5zxx1N6N+/HnffvZyQEE+OHn2oSgf23zKbbRw9moWnp5F69YIvut7l7NyZwtatyYwb1xajUX/5DRRFUf4BVGBxDanAQlF+nxmf7OeJj2MosXiAlET4ppKR74FD54/emkET3xXs35+mrezXDCJuAnMOJFQdtfj111Fcd12tKzpmfqnEzwNmboATZjBGQuhReDQYHAYJxcC5GMABZAE7QX+9FbuXAW0YQuLuVUJozRRtn/uDKVwcjJvDQugLZxAmLTA49xgcioHlogYbKeU6vHiYVATwubU6C78VDBgAQUGC5bKA8aRWnGsT3PlBnH9dzWV8RfBxvz2A6AWZfPDBDnbuPIuUEBMTyMSJ7Xn44Z8qEsaNRh3t21dj8+Ykatb0p3XrSBYujLvs/apTJ4AEqwOHTQ/Zhfg+GoP/1CY40sopbbqGtl8/wqo0A9FesHGwnc4/SVJy9BWJ8um3CyK+BYlEt24Hnjp3zNc1xSoEBiHQ4g/n0E9qKVjsUNNHO/ipQqjj/J0qYVZwPjPfPM3EidUZPjys4hy3bi2gc+e9SAG/7G5H9xaeF72eMWOW8s03B2nRIoL09GL8/d04dCizIsAwGnVYrY7zths0qAFLlgy/4D6llMTGTufYsWwAevWqw6pVI7DbHZw8mUuDBiEX3O63pkzZwIsv/grAd9/dyrBhja9oO0VRlL+bCix+IyEhgTFjxpCRkYFer2f79u14eXld0bYqsFCU36+wWDJ0Evy8Rfs1UzHvHsBhhuITUHgIqg2jYm5R8lwoPQVo3zrPmNGP229vgq+v+3n7v1IOhyQlC3o+JjkRCBiBAuDcdB8HMAwIFdoohwE83fOx4Yal3DlNRoK7dxGhNc8CYLca0Bu1qVQ6hwCdxFfoKHDW5K29yZ8No4OI/CmLjlEmMr0KSMBKOAbSnTkeK6iJD3qqY0QnBOXSTgNcnQvb4MFCUROAgoJy7HYHAQEeCCHYvfssgwfPo7TUxs8/j8DPz53GjWdgsdgrHqT1ekFgoLZ+//71+PLLfTRuHIrBoGPfvnTcOgUTuqob5g2ZZPbfROSJvhhqa0nZSfoF3DaiKbdNHUzXCElP40lyHHYSv62No9wIeYXs713OjXsCSHcYq6a4AJ3DBJsrtZ2orzOT+9we8h9ujjXY47z12ZMFn8YhBMya1YA+w8OZfdjOqwN3UpxhhseaQT1/5nYX3F73yqZRff11Gp98coqkpJ0880xnhg9vTO/e37B7d2rFFD7QigzMnDmAxo1D8fNzp3p1Xzw9TZSWWli0KI5Ro5ZW2e+YMS3Q6WDWrH0MGRJLnz4xlJfbqF8/iJdf3sDo0S0YNao5u3adZerUjZhMehYtcgV6zZuHs2/f/Vd0DYqiKH83FVj8Rrdu3Zg6dSpdunQhNzcXX19fDAbD5TdEBRaK8kdJKdm8B/YdBX8feOGdHBKzAi+9UVkyuEeArRByNqMvPsDmzWNo3/7yU44uJ7dAsu8s7N4reeZRcBSjTY8aqP1ZvxrEm4X24Dsa+M13EIGRqXj6FJOeUIPQGikYTNbzjqFduPNP4fojWOj5mdp05CTlSHzRUYSDPvgwnSh+ppixpLiOhZ69ot55u7ZIyXOk0RYPBtl9MRi0aTWHDmVw+HAmGzacYdWqk7z7bm8GD26I1WqnrMzG5Mnrue22xkRH+9Gky0w843oj9Fr+ySd7PXmwRj72IG1KUJJpIcIhGTIklpq312H+AC3Asn2ZzdkVEvbEQXIGdGgKowe5Tq64FNZtZ+rgSJ6Trk7ZL9Yv5dn27pwo1tF0sVbRyk0vCCoq46yHOzikFlzU9EUsT6Bmc18SW0TiSC+DvVnQvwYAbg4HO9qX0ayZzyV/zlJKdLr1ADzwQCQzZtSvWFZaasFo1FNaaiUo6I0qVbtACzSGDm3E4sVHsVi0Cl7VqvkSHOzJ/v3pFes4HLLKlKtzncUB+vevx08/nax4D1rFMJvNcdlqX4qiKP8kKrCo5MiRI0yYMIG1a9f+ru1VYKEo15bDIXnr0wKmzbaSWRyIw6E9xAt7AdLgd17VIgCKj9Mw5BCH99yK7iKlSisrKbHicEhSUwvp3n02Dz3UtkpzunN+/VUya5bk8ccF06dLZs0C9EA7oDaQD4YSsPUDagnwk7hlC8xxwE0S8iR+NXIwBFoozvMnIDyL8hIPfIPzLnhe7llhdLUFsN0ti6LAnKqJ0XDeeyHgJA3Q/6Y07zsykw/RclG+pjpdhfdl78lv3Zl/kk0+Fu0gAqYQxuTyNGxu2s8jrdpyrOlaUnTIss549I8EoPTbRLLv3FF1Z0F+0LguFBTDwePgkIwc1YyTNw/idBE0y0lk9aNf4+9tYuLEdpy9riuzTuh4vgWMqQc150tXHxKJlsyhF3Chn7UEU345DUw2HGV2wpPz6drEnVr+OuKPlpCVW8amXzdx112teWK5NzQNxONkHiWr6vHqfkgugffag4dBYLZL5s49yOOTVlWUta3s3G2XEn7+eQSdO9cgvO50CjOLtO6RJqMWLWfnaYEREB3tR1LS+W3LdTrBkiXDuOkmrQFIVtbjBAV5XrDs8jk//BBPRIQ3rVtHXfJnqSiK8mf6VwUWGzdu5K233mLPnj2kpaWxZMkSBg0aVGWdGTNm8NZbb5GWlkajRo2YNm0aXbp0uaL9L126lNmzZ+NwOEhJSeHWW2/lmWeeueLzU4GFovx5ys2SHQclm7YVMX60N+2H6zh6ygH2MvSWFOym6qB3Vey5sSvMeV3g7+vqr/FbNpsDt9hCHMKdOuJrTsVreQ1STr7kudhskptukqxceYGF0UBXIBE4iDa6oQPKAE/AS0A7CY2AZAiJLUSE52EzGynaG4CpoRW90UZhdmBF4FCtwQn0egcOqwFhrNoDxGo2YXSzIIA+woe7HAGESncOiGLO6qzMJpcstG/SBdAOT6YRSbi4eAJyZVJK6nGMymMtvfFmtSzm3Ane87ON9+74idzcMsJ39sTUKhABWPbm8ch6eOaZddhsjosmSHt6GqhdOxCdDo4cyaoyKnD3fa3oProTt7UNYNOmRJ5LDmRzuTcgCDBBnkVqzc4dEqnTAh+dQ+JIKIJazt/Dv/3xOyTYJRh0cCIP3S/7cYztXhGsdDeV8atNy8/oHAYftijnxvVuFFoFjzcFS1EZDUQxQUV5TJq0mpMnc5k0qT2+fu7sioghIzSSiY1g9AaJ7WwWfDAX08h+WGJj4OhpnnQ/Q0qBnRmvdeOVVzbx5ptbABg8uAFFRWbuvrslQ4c2wmh8GYcDnn66Mzt3nuXYsWzm/nwvt+zyYnht+KiLNvr0zjtbeeyxn/H3dyc5eRLe3m5X9LP9J5h7UjLvFHzSGaK8rmzamqIo/1z/qsDip59+YsuWLbRs2ZJbbrnlvMBi/vz53HnnncyYMYNOnTrx6aefMmvWLOLi4oiOjgagVatWmM3m8/b9888/s2XLFu6//372799PaGgoN954I8888ww33HDDFZ2fCiwU5a/VocMstm9P4cEH2zDj430QfhN41wJhAp0BHTYkegL9BV4egodHQJOoU2zZksTzz3dj0gtnmL7EmRSdswmytYTZY8ceon79S1f0kVISFwc7doCnJ2zcKJk9G8qcX2YLAd27gzUcNttB7gGCgBDgNNDGuSN3IBw4i5bHcW7EQ0pwB1EMboEWDN4lFOf7ExCahd5oQaeXGIxWss9G4Becg4dPScWX+NKqRxjtVZ6n/aSBImFDCmiJB68TwSclZZwyC77y96FUZycAPe6/6TC+TZZwG1pDv0a4cQQzoejJxNW4700iuMXhy5rdyTzQqkSriCUEgVLHXl194uOz0ekEq1efZPz4n3j66c68+upmQAv67Oca5OG6d15eRoqLXeViBw6sz/Ll8UgJkQ3Cub5jFFmpBSTXjsGjZhitis/ymaU6ZOXRIfMk3j4m1gQ1wCNPQvMoynwvUSb2tzkcuN7rAMeZVKgR6RqWcG7ULsDBoCAbvWIEjcNNpJRAw0VgqZLzLfEtK6HQ3TVPLspLkFYKX3aFkfUEM2fuIS4ui7feugG9XlcxMhFabRpZoeFw9DSYrSDA+MQorLW1/z9LvsVK2qls2rWbWXH/Zszoy/DhTXj11Y3UqRPIHXc0xcvLyK+/nqFZs7CKfiZSSo4ezSI62u+Cgcjp07m88cYWnnyyE7VrX3w64rkSv79X4NeSPAsMiIblvVRgoSj/dv+qwKIyIcR5gUW7du1o2bIlH3/8ccVnDRs2ZNCgQbz22muX3ee2bdt46aWXWLVqFQBvvfUWAI8//vgF1zebzVWClMLCQqpXr64CC0X5i5SWWjh2LJsWLSIYO/YHoqJ8sdsdTHkrHiIGgym06gYCKE8HcwYNYiPJPJtOrmyiLbNkQ8IMAB55pD3vvHPjVZ9Pfr5k3TpIS4Nu3aBJE+1Bae1aB717uxKAAQwhYGsMeADpaIng/2vvvuOjqtIGjv/unT6T3hNCIKF3KRYQVFARsCGW1VXX3nV113Vd1/5a17UvqGvXtaC4YkFRAem99x4I6b1Mr+f940waSQAXLOj5fj7RMPfMnTv33iTnmXPO8zQuM2icjO9AZqfKhpRjNGq3QdgBxMP4EyAlDpIr4HmjoFOfXRiMYdolYN/WXpgsfrK67W35MAB62IAwhIkXRh4LdGaa388TMTEkGzT+SDHf4sIudEb4E5ltqW46lSLaDzwRO+9rXXhH1PAQ5U37zcTIUq1Hq0Opr/exxWhhx9IC6jaXkZho5corP5PHE33irbcex//932juvnsWc+fuYe/eesLhjkc8oHlNQkcsvXOIPa4PVZod0hPlaIXJBlmJssGWGgaFalg/oJucViWAWh8kRhMBBENgbn+9XYwI4zUYiQiZ9appqlbLIifBEEYDhAzNI0VJFth1ISRaNb4vFtywWE6/GpMJF3eDa2d6CdqsUF4H9XUyuLE0p/VNeWcadcu3t3nfMTFmXO4gXDcJg8PKJbWbef+ddcTGWvjd7/px2ml53H//XHbsqKZz5zi2bLmFwsIGnn9+GZddNpATTsgmL+95ioqcdOkST37+7RQXO5k5cyeXXz6oKd3ulCnL+eMfv+GRR0a3O33wYCq8gvT35fe5MZB/sQosFOVo96sJLAKBAHa7nWnTpnHeeec1tbv99ttZt24d8+fPP+g+Q6EQxx57LN9//z3x8fGce+653HDDDZx1VvuVWR966CEefvjhNo+rwEJRfj7BYJhZs3azdVs1b01zsTk/FoyxYMsBY4vV1fuvWUDA9seACH37prJ58y0AVFT6SEo0YzTqCCHQNI0PP9yIxWJg0qS+AGzfXkVKip3k5I7Tm65bJ5g8WbBqFdhs8M9/apx7rqCmRm4/eTTM15GjFjXAYJqSX7WhIega4AAAXPtJREFUacSb4V+/h3u/gMIAaMdEMPf1EXBbiEmsh1QD9qQ6LHYvzpoEakszQIOU7GLscc6DnkdjRCdiaO7Me912astSyexW0HTqGvvOycLAo57uPODYRSVhriGJN6nBjMYWerVa9zHLKRhbADE61PaRy1RmztxJXl4iDQ1+Nmwo54orjmlVu2HGjO1ceeVnDByYTlqag+nTtxIItA0ihgzJpLTUSWmpC5AF8WprWxfE0zRITLTh8wXx+cL0O6EvG9dYMYRcRMLbESkpcqhpRxi21sKoTOiTBAtLZDAyIAm21cLo7OZ0uC1VeqHMAwOS0WvcRBKj99yc3VBZBpec2OJgoHc8+KoaKBMWfGYLzcMmgnbXENG8me+Xw6xlEGPntuuP4V8f75JvcE8xXHEO9I8Gdd8sgunfNz831gEDesj1HolxYDJiW7MRryeE2awTH2+lstLT1PyaawazcmUJmzZV8NJLE7jmmiEUFTXQs+e/CAYjaBqsXXsDgwZl4vUGefrpJUyc2JsBA9Jpz6YawYlfyvitLiAfM+vgv1oFFopytPvVBBYlJSV06tSJxYsXM2LEiKZ2jz/+OO+88w7bt28/pP3OnDmTv/71rwghGDt2LM8++2yHbdWIhaL88j3xxEJefXU1doeNrXXDwdENoZmRvXYNIl7Qo9NkQk6oXkQsO3jp3xfz6pvbWbhnBBatlt+fn8p/Poc3/s/PzX94Fr8/zJIl1/D993v4299mk5Rko6rqrwdcYLu/rVsFV14pWLcOFi8WnHPOVkpL+8jjsoF5KARKgFJgPBCLDDwaP/SO9vCNPtAEBO2Q7NCodsOIgfCP6wXnPxOkwmkCh8Y1k8CbJNgVrmVjvZFQoY284TV44urwe+xYHB40reUn7s3xV0VBNj63g859dsg2QCSsoxsiIMBZl0BcYh0Ab/q7caMlnyCCO515nG0z08Usdzhod5gNXpld6o0suDpJIywEnghsD0CCDt0tbc9hY1AHMnjcs6eWtDQHBoPOJ59s4fvv93D//SeRkxPP+vXlFOpB3h8KJ22JsOYf66iocHP55YMYMyaXzMxYIhGB2x0gEAjTpcvzeDxBNA3+9KfhDBiQxlVXfQtkAXEYDGHC4QTazJXq5JBfIQF7G+TajfqAPGGdHFDihlsHQoYNnlwDriBc1Q2EEar9cGbXVrvTwyHiTYJaoil5BVDjgyRr65eORGQZewFEwmA4eAE9g9uDwyBoKKmFTmlgMaN5fQhrdETm64UYZy8hlBAvs3XVu5qe25TNymyEgT2xFpXiK2uddOCKKwbx2GNjmDt3L5dfPh2jUWfMGd05/pRu3HvbECwWE8FgGJPJwCkzBPPL2h5j6e8hw64RCIRYvryY447rhMXS/ihRKBSmtNTVqiBmIBDC3MGo0qHy+0Ps21dPjx7Jh7UfRfmt+tUFFkuWLGH48OFN7R577DH+85//sG3bth/9mNQaC0X5ZQuH5aern366lauum4Oj03Cu+l0iT7+fSohY2XmLhIEIaCb5//2GDcx6A4Gtz4MxDqwZ4GquJfHZZxdz7rm9f/Bx+f2Cl19exp/+9B2ySIb8pPn55yOEw0Y++EBQVArOePDsAk4EukSfXAIsE+CBhC5w/TU6z+ySfdwci6DA39wjHZ4Lo/2Cx5c0Pz/GCq4MjasHQ9mxfooCYbq6dFbnleHzmfE6YwgGLPQvttC7M0zXXaR1kWlufS471pjmT7YBgj4Lpfm5ZHbLx2QJEA4ZyXElcrctllf1SjaZnCCgviqZTg0p3N+9gXtFKf6ACa/bjsnq5yZ/JmWJVZgb4vC4Yng5C4zRtR+1YcE6L5zsAF3TqBdhighiQqMH5qbg4wFRxrvUko6B5e2k4W2pqsrN/PkFhEIRLrywL7quM3PmTp75cA17Btj4+PRhfPjeFioq3JSVBZk9O0jfvhn87W/dWby4mNdeqyQc9gJyXY7ZLAgEWkUCjBljY+5cL6JlSfZUKyQZwG6TCzO27QThgTHdwRoHy13gDsKlPaG0HDIdcGwefLYbhsRD55S260JacroxWE2ETeb2t3e0tkQI2F0EPj/ExcLTb4PfD8f0gusvlIHN4nWQmQI9cmDeKti2B9ZtJynJRo0rCCcPg/EjwW5Fe+czuh7XnYr1BZyVHmDDeeex1am3CmARMHjDChydkikKmdn7f/8hOd7MCU9dSalmJbSzkE9v6ExudgzPPbeMJ55YSHW1lz8/Pp5H/nIcl1/8MTNm7OCxx8awZ08tffqkcuutx0ffjuCmm2ZQX+/nrbfOxWptnbig1i+4diGMy4av/jaVL77Yzr/+NYFbbjnuACdXUZT2/GoCiyMxFep/NWXKFKZMmUI4HGbHjh0qsFCUo8zTk3fx2Cs68Wk5FJRGO34tU5q2FAlAwevQ5VrQzVA5B2pkVp8HHzyZm246lrvu+o5zzunFBRf0o6ionnvvncNVVw3mlFNymTlzJ489toAnnzyNkSO7NO3297//hA8/3ARAamoalZVBTjstkVmz/tDUpr5e8I9/CGprISERdu6FAb2CPPTQMmBktJUm45LhNHfaGucsCQG1QGLbc5Bo0xiaB7OjtdnOHgL/uA6qw/DQnwRzXoO8HpD7jcaSBi82Vx1jy1LJP28v5ZrMVBUMmCjfm0M4ZCKr++6O63ZEBbxWDKZgu2tDWp56Ixp/DaexOiD40iUoq0zidIfGv7oEuJJ9lBFC02ACsUzWsgEYI3aRH81l9TW59NV+eNHEIWIHNYS5gHie1rKaHm85egJQWFjP448vIDU1i/Hju9Gzp52HH97Ceedloet+zGaN4cOzmTWrmnHjNiCEHGQIhX7gn1Rdg5wY2OuUJ8imQ/dEGJ4Gnnq0qkKE0QhdMqC4GuathHgHXHAWZKfIM2ozQkRgXLiSkNMH+SVw3XlgP8D5CUUgHAKzueNARgC19bBkPdQ0wKXj2x9J+fc0uGaS3Na4r3AEDDpU10FSgnysuFxO87rq3KanmmYuIGfDenbvqQOTCYb2gSvPpa89wJbLn2zzs3r11YO59tohrFtXxs03fwXApEl9eO21s/n22128+uoaPJ4g2ff8nk+roqOWf/onuLyMHt2V77+/EoCvvtrBE08s5L77TmLcuNZrhg7kv//dzMyZu7jiimMYNapLh+283mDTupUfavfuGhYuLCAvL5FRo7r8oBFTRfkx/GoCC5CLt4cOHcpLL73U9Fjfvn0599xzD2nx9uFSIxaKcnQTQvDdYjAaBNW1QSZ/aObS8U5uvM8n12eEfWBKhLALDNF6EFqEm8Zv4OUXviY7y47FYmD3bjlN5KKL+vHdd7upq/ORmGjlww8v4A9/mE5FhRvNYOTfL4/nD38YhMVi5OKLp/HRR5tbHY/VasTrPXBxtI8/3sTvfvdf4GYgiabeWg7QSz7k2AHugfu/WQ78abemcc4gKFopWPM54JYPX/MUvLFFdvstBtj9f1CfGWD55jCP32blgns1+g3TWI+bWfYK/HoIrx5u6vP5vVbyMFNsdcr5W0AkpKMbI23iOCH2S8QU5a6PRdMENocHzSDXWjQ2G+hLYHtQ4Iutb3os253I9450TBqH3PGqECGOYycAMehs0nod5BmHZtcuD7quUV8f5JZbdlJc7GfQIAe9etlZs8ZFXp6N9eudrFrlQggYPjzC0qV603mYMCGJb76pIdwqFpPF94YMsbN9+y5cLgF0Qo64NQAJTS11ayUffTSYs8bmcsstC3jzTQHdEuC0OIixYfaGiBmcTQ1GeQFaXBCTiJBUXEh5ZjYYDdHpWqK5hkh7PYQ2oyHR/1fVgtUCoZAMRLplN29vfE5kv31v3Q3/+hAevQ2SGlMJR7fPWwUffytrhuR1gp5dIb8IXB4MVbWEA9E0zbF2tHEnIpash+IKiLHBU3+W7wfglWmwZisADzxwMhaLgfvvn0skIjAYNJ5+eiwVERPza8w8eFo8Y0/pQn5+DZMnr6CuzseQIZkMGpRBdnYcvXrJNSipqXZeeGEc27dXc+21Q8jIiOHRRxewenUpQghmz85n1KguPPfcGYRCEaZO3cTy5cX06pXMX//anJVr165q1q0r45lnljJlygQaGvyMH/8+Pp8MrP/4x+N5/vnxbS7B9u1VFBU1MGpUzv88VWzHjipiYy1kZh642KSiHFWBhcvlYteuXQAMHjyYZ599ltGjR5OUlEROTk5TutlXXnmF4cOH8+qrr/Laa6+xefNmunTp+NOCI0UFFory67RuXRlFxU6+WhTLK9PT9ussNWb+CUH1YqjqeHS0aa66PQ+yfwcNG0nwzeLbby/n/PM/pqiooc1zNm++mW7dkti7t67dFLg33PAFr766BogjJ+c47rnnRKZPFyQkwEknabz8smDLFoHIg+TuGqeeoFFogFvGwOXPCUQMsBfoGt1hCTIt7v4ZSJcAATAMg3Bs4xsBWz589Qz8YRIU1QHjYMQAjU9vhz1bBSNHgt7bj2NwgPFnGDgmYOeaczXmWkJ8EXGRZA2S4UrkeLuguwXu89Qzz1qFuyGWQEkWfR0hijvtkWs52hH0manY15nM7nvQ9fbbhAImciNWSq1OetWnc65IpLcFOhnBqsNyD2wUfjRTgLttMVh1nfdFDfeKcpBXl/PKe/J8ZvMn8EIIzqeAEoJ8Qy4J2uHN7d9feXmAmpogffo4ePfdMgoKfAwc6OCcc1JYuLCO009fTzgsuPDCNGbMqMLlirQq0tcRq1Xj4ovTaWgIs3x5PcXFgcZ3ROONHRtn4L7Hu/Hkk4XUFntl+iqjBpV+zj07kTnLd+CyGsBfQlayhZzbJ3HqoESWfbaOOZUm+o/IpWDhNpK2bSPrijNZSjyUVEFiDNjkyIj5mwXErlxHdWUW9OgOtwyU60YqquXoSWyLRAtfLYTTh4PJCHuLoWun9oPij7+Drplw7IDW2wMh8PrAER2VMBigrgGq6uRUrkYCmL8KPvgajh8AZ4yAOie8/in4A5CXDVmpMH6UXPReU0efhlLKZyynZuM+eXyN2cPMJnC1LaQIkJhko9bigNKqVo+bzQaCwXCb1Ms9eyZzyy3H8re/zcFzygkwfCDalKlQXt2q7dChmaxYcR1bt1Zx113foWkafn+I77/fgxCQnGzjhhuG8fDDp2Aw6DQ0+Hn00fkUFTm56aZhnHhiDpWVbj78cBOdO8dxzjm9MJuNhMNhhg59lZ07a/jyy0s44YRs7HYzQghqary4XAG6dEkA5PqnwsJ6hICMjBheeWUVFRVuYmLMPPbYAp544lT+9KcRKL9eR1VgMW/ePEaPHt3m8SuuuIK3334bkAXynnrqKUpLS+nfvz/PPfccJ530w9Pg/S9UYKEov26hkOD1T2DTTuiTB6s3w1vTG7cKdC2MVr+GfgO6EKjbxbadLkDnxFG55CYXM+2DxQTjRmDNHIHHZwIEVM2DYA0EasFX0uY1L798IJWVHr79dhfTpl3E+ef3bdrm8wWJjX2iKd1oSoqNysq7Wz3/00+3c/75m+ncWbB373mtag7Mni/4fgmMGCg4527Q3JBnhF1VwGjkYvGW06ka/wII5Ifh0X62qRKCC4ERyJocyJEBsy7wL0UGKT2QBQIXwynZMHeuPA4hBNXVcMYZgpISmDAB7n0GqswauWaw6/Cyx8Pr9kKSQxaceogGQwgEhDx2ksuzuSpeZ7LXTbBTYav33rS4vIVwyEB9RSroYRxxLkxWPwgN3SCHAKzuWCbrGbxmqGSFua75A/biTK43xjMxDr5xQqnZybyEYtBgaCiG2PJsrk2EEXa5ltt8kKrv1SHBB/VwYRxkmH749JXiYj/hsCAnx0okIti61cPChXXMnFnDmjVOBg+OYfnyBioqgqSlmfj3v3vy4ovFzJtX17SPA/5F14BOVpK8IWqqQ203a3DDDRls3eplyZIGHA4DvXrZCIcF55+fxumnJzJ4cAz3/H0PT31Yg6nCw9sf9WD6Vh8F1fD4mfF0SrPQt+9KQIDFSM4xQbolVJEzqh9fd+pNZUhnQEyIATO+ZHYomYpTm/+WmyIhgpoR6959+HL3Cw4O5XTu387jiwY9ArbthW6dm9MLe/1yqpbZFD1pWuvnCqCsFjIT5fdOtwyM8gtlIBQfC5W1csrX0vVw7ikwrL8Mojbtltm9qusgNUkGL4VlcjQF5OuGI1gsBvwWK/zzz/Lk7yiAp98BoFu3RIqLG/D7w4wa1QWPJ8CqVaUdvvXx47uzYUM5JSXOVvfA/oHN6NFd+f3vBzB37l4++GBj03UHGDUqh4KCevbtq2fQoHQ++OACvN4gb721jilTVkTbakQibW+yJUuuYfjwzge9RMrR6agKLH7pVGChKL8t4bBg3grYvQ/u/5fsJ7T+1Lh5dazJCMkJEcqqZEakpm0tfqvaglvw5n8CgN1uwuNpvUYhNzeBp58ey6ZNFTQ0+CktdTX9wQfQdY1Q6IFW2ZMyM5+mulp+cvrxxxdy4YX92n0v+fmCuDhISdFYvVrw4IOC72ZDSn8460aNjSWwfoPAWwrsRM60GbTfTlp21tpbnwIyq1UhXHs6hIpAD8GbbyFHTMLAPrjySnjrrdaL5sNCYNA0fCLCdvx0wkTKfqMEReEQZUH43FTNAlzoZZnszSxoSrCkRTTQxQGzuAKEg0YMjRXOo+8pFDBRW5aOEJCSXdoUiDQq3NYdLWIkxQBVYTgzFiyGMHlGncvT/fwnUodF1xgajKWvsDOhAHYFINcEo7tUkK/5mWHOxrFfgcKOCCHfh36AqV1CCMJhgdHYHMR98kklq1c7iYszMGNGNWedlUxcnIEpU4q56KI0xoxJZPHiet6yWNg1Np0RkTB9J+9m82Y327Z5qK1tG2S0JynJSG6ujdWrO05t3DSC195jGpATy0Un2xnUy85NN3Xiyf9U8d4SL1mEuGlCHFq6jeOyjXwdtLG4UiMYgXSroG5GIbvDRlJPSiOo6yyr0pqLFgoY1lDImvhsImjEEcauwa1xTt7Z7mRn+sE7vKZggNSyYkqycw+85gQOHOQ0vs9QWAYvsS3SVVfVYfF6CMY4iFTWwfQ5MPo4OK5/c5s3psO67eAPMGRIJmvWlMoRmM4ZYDRCRjIsXIO2t5iYGBNOZwdrnrp1hkBQBjT7OZRRsMZ2h9pDNJsNnH12TxYsKEAIiERE05cQ8n796KML6dJFZvx67bU1vP76GvRosO7zhTCbDU339SefXESvXslomsa//72Kl15a2eK4tFbv4z//mcTgwfLTj3feWc+zzy5ttb1l+1dfPbspAJo2bTOPPbYA0Npt+8IL4xk9uisAM2bs4L77vm/TRotOxXziiVOZMEEmlJgzJ5+77prV6jy2fN4DD5zMeefJAkdLluzjj3+c2eF7u/POEfzudy3uj5+JCiyOALV4W1GUQEDw31mwYKWcOv6v9+QHlO3JTIXrL4KHp0CrAEODE7tvoKFgCXffPZLLLvu06Tmt/3BroBlByI5CVlYsJSWyA7dly8306ZOG1xvk8ss/5b//3dq0j6FDM3njjXMZODAdTdMQQuD3h9pkydm4sYyTT36bm246nocfPgWjsbl3VF4uePNNWLFSMPwyDaMR7nlVEEiRxxhbCQ1bgc7I4MMkDz4jRs4Mce2/YNkZfe9xQB2wFoiFW38HJwzSGD8GXnwFNA+cfBKccoo8lrJ6QWosGKKdjbo6wVNPCZKTNS69FDIy5OOlIsgWfMRioAsm7halzC8ShGKDWOJCJAatWHVBNyys1t049eaOc44vjlyLYL7mPGgwEvBZcdYkYDQFMFkDmC0BjOYAkZBBjppoAg0Ihw2U7OpKJCzPeVxKFQlpckpMqisBR1UGw2xQFIRlXvhTMhxnh15mSDZqeEWEmpDGmD0QFDAvF3LMGtUhQbwBjNFehj8iOGkPOCOwLA/iDD9sVKTPDsG2gLx8vn4ygNm40cUf/7iDK67IYMsWDy++WITfL+jSxYLbHaG2Vt6Pjes/Gjs8OTkWCgr87b6OpsGDD3bhH/8oxOtt/wdG08Bs1gmHRZsF75oGdrvOFVdkcM45KTz6aAGLFtUD0LmzBU2D3G42xo5NIndgLA0hjRvOSWTmag9ub5ibJ62nslIet67DyPMyOPmO7hSEjIxIjfDWTo3lVaALGOoIcFEPnYEhP4FqP+UZMbw+v5Zl1lQw6RAWYNQw+v30nzuHzNOPYRZphAzRALhFsG0Kh7gqvob8+HRml4j2g/BGAjmVy+ODlIQWjwv41wewabf8/XDluTB8v2g/GILJU2X1doCkeLjxQllo8dM5YDHBtZPktjenw7KNtCs1EdxeumVaqa/3U1UlP6zQ++QS6dkV5ixrmvplsxnp0yeFrVur6NUrhUhEsGFDeatrdii9yUMNag7aNsbWalraDwmCjtgx/I9tG4MRecyiVZHV/RmNGgaDjqZpZGXFsnv37Qc/kB+BCiyOIDVioShKo5IKwc69MsgoLofbHoNgECaNhaf+Iqd7n3a1XMN697Vw48MCt0fDZoXsdDh/LCSb8vnHS9V49DyCWgLBuu3QsBnSJ4BmgII36ZoVYOHCq8nNfYFQKEJCgpWbbz6WzZsr+PxzWb8nKclGTU3zH9bLLhvIzTcP4/rrZ7B9exWPPjqGm246lvff38COHdWsWVPK/PkFALz33iRqajxMmtSXUChCTk58mwXQtbWClRsgoTP0SIKrrpQVyOPS4fjrNc46AS4bASvzYcwTgkBHf0la/sXff6qKX37F6pDtgK0aGBqgazI8e7NGzQbBzTfJD35tdvj8U8jP1zjjDOjatXlHM9YJzn5Bfv/wBLj/Anh7ESTHwHHdIjy/rYEhgzWOM9rpqpkpF0GuoxCb0NkTCeMkjFEDpxbGjMZNgUxeN5fhIULj3/yOBmtCQSNGU4hIWCcUNCMiGha7t8V2EyU789D0CLoeIRwyNp0EiyY4M6+c1ZY6etWn811xIgDxukyIXBeRmWvfyYYzYzWmVAtujc6G+X08vJcN3+EkAyODtNaFHCtDgrluGGyF7mYZ1OQ0Z1FmUS6c6GgbmEQigrq6EImJxqZAtbo6yOefV5GYaCIYjOD3C84/P5W7795FZWWQLl2s9O7tYP78WjZudHPCCXFMmdKTkpIAjz66l4qKAGlpZhITjVitOgaDxkcfVbBpk1uuE9fpsHN1KJ21lBQT3brZWLGiocN2ZrNGXJyRfv3sJCWbyenr4MUnC7BbNIQAjyfS9HopKSYqgxpk2GFnPVc+0pOrJsSTqAvq60MMHBrHvAqNWj98sjnIV9VGRqdE2PXIBmp3ujj/glR25ySxqFOqvP1XlCMyHJAdIy99WJAsfNQYbbLSvQB21kMP+Wm+JgT9jW52FrvxZbRfkJBgiLwPplGpW0kfN4xdqR2MyhSUkLx8NdX7aiAhVgYhGcnQt5v8txBQ68O6cCm+pRshEGhe+F5WhenF9whVNyB0nYTMBC49rzsvTV7RdJ41A4gwJB6TS218EizbAP6gPJFGgwyCYh3wh7PQrGb01VsJL1gtt7W3ZiV6Plr+Omp1TXUNbr9ULuR/9RNY207ZgVi7HN2pbbu+rfEaHy1BSMu2WVmxFBXdefAn/AhUYHEEqcBCUZT/1edzBBNvld93/Iek9QMDunmY+pyFWqeRyy/9kD2FAjImQN1aqF4AQP/+acye/QfOPfdDtm2vw+W3EfZWsX/3NzbWHJ0qoaFpkXb/iJlMOhMn9uajjy5sE1zU1HgoKKinb9/UDouaAdTUCk45T2DLhcT+Giv3QL0HTukDGXHw+VKBqwE5gtGR9ubR+4FqID26rRzYB9ZqmPIPjePHQkY8nPMCLNmFPLlFkBOEfXnyXGSthNItcNll8O67HU9JCgrBDOrpg5XempUqEeI9apkr3BTgJ6KBPaLTS7MwP5pO6/pwKmVOB18m7G2d+QrQhIZJEwSBgCsGTAFMFrmoOug3U1eeisXhJS65pul5FQWd8LnbZuiJ0UBokGyAfdGZL5oeJqtrIUarrEL+RiCPPgYzQSGnbY3MB1/0oLKMUBpqfadpQIYRTrDDtM40VVJvnJ7W6MlKwYvV8HwmXBT/w9eNdEQIQX6+j5ISPwMHxrBvn49Fi+rZu9dHfr6HTZs8lJT4iUTguusyuf76LC68cBObNnkwmTSCwbajHCaThs2mEwwK/vCHDOx2A//9b0WbkZVD7ViazRqBaMTc8kfj7bd707evg6IiH1ddtZ06TwQt2M7PV6Ydh03HnR8tTJhuA7sRqnw8/FBXKk/oxKdL3JQsroIv98KYTmgDkxE9E9B0ENEfCLMm+H16AFMwwqpywVqDrcUxadHr2nYapkFEiOiNU+YO8mYFICIyKLBamn4WNQ3MRPA31mr56BtZD6W6Hi44TY6mFJVDVprs9Du94PHK5zts8O6XcPV5chSlUXk1JCfIfUydCQ0uOeR7wkDokilff94q2LVPDpXFx8LqLeDx0e8PJ7F51CkA6KEw4vn3EDUNch3Lcjkyk/vU9exNyCCltBj3l4vw1nvA5UGUVjNiRDarV5fg98tA8pzfH8Psb3fhMVrgzFGQlgTvfEGqOcJF5/bkzHF5bNlS2TQVK2/cMQwY05uetcUkpcdx4rAMbBa5MC0UirBw4T5AMGJETtO0Lp8vyO7dtfTtm4oQcO21X7B+fRkffHA+XbokMHXqJp56ahGBQIQZMy4hLy+J6moPI0e+idMZ4LbbjuOuu05E1zU6dfp5+qEqsDiCVGChKMrhWL5eUO+Sfzs/mAFfzpXTrw0GOW16b3Hb58Q5oMEN+wcd3VIKuOQMDy5DHy4er1HvhqvvheJygSFYRlhYIeLDXPExAU8doEHuzehmB4Ni/0t2poEvv9zR9gWBp58ey1df7eDSSwdSWFjPhx9uYudOmaEmJsbM44+PYcKEnnTrltT0HK83SFWVp1Wl5EYt60L4/YIPpkKBFVbvlaM9VgtsqQGXVxCO9ln0fXJ6SqhLix1p0WCp5akIgHUf+Hq0OUVSCGiMg+qAHUAEMkxgdYHTKTOiXn45/POfGvnV8OlquGoUdEo8eOd5u/BRRYgTNZmeeJXw8AbVrMZHA2GGCzuPaBl8QQP/pLLN4e9PExoRTaADafXJrKuOJTlooZcjxEKXjsESID65Bq/bAV4LQhc4UiuxOpo/7XXXxlNTmgkI4nSoj7T/PvYfeTEAT2fAjUlwQj5s9MkRjmE2sGjwVp1sd4xVBiDdLRruiMDRYiH7u6KG56jiNbIZtt/IyeFqeR+FQhGczjAJCUZKSgJMm1ZBRUWArCwLMTEGTj89iawsWTiweU1ShEce2cu775ZhtepMnJjC3r1+tm3zcNJJ8bz5Zil2u4FJk1JITDSxZEk9K1Y4GTjQwTXXZHLDDW1/Xjr8NL0Fq1WnUycL+flehJAfoIdaLGWxWHRMJg2Xq229F7rFkTI4kex4naK6MP71Nbh2u5rXqZzZBUZ3ghgTcW4/PosR45Ya9K01uI7NhLw4tAXFiK/2oY3tjOnYVMIWA2Fbiw8HBFDpg2SLfEO1shq8pkGcURCrQ5Ff63CoTtNaPHygm7tleuGmJ+/3nPY+VNiPobCU8LJNMKgn9OjSbns9GCSyagscP7DtawI4PbIuy0sfQ0099OgMZ58CvXNbtwtHf0HPWQYffSdf67wxMPwYiI+mJK+ogZQEDE4XyV/O4qKBDgKhCK9+tAMuPB1yMjE0OLFv2Yl71TYiI4eScEwu5+5awTtvr4OsVLQzRyGG9JXHsnk3hELE9MpmymXZzPvHF7z15jr53uMdTDy9CxPP7cVll+2/CO6noQKLI0CtsVAU5cfg9QlKK2Vmy4Q4+Ho+3PkP6JUHI4fAX5/u+LlmU3T2gKe9rc2/yvOyBTG+RWzY5IxOsYILx2lMHBPmmUenYTG4GTMmlzffXEvfvqlNqSs7fuFUCHvRhZvJkydw+ul5fPXVTh55ZD41NV6mTJnA0KFZOJ0BTj017wefk29WChZvgRvH+vjow/WszO/JxlACBWi4/JAWBw1OgS8CZiDQ0Y4KaK5e3tEpWovMaGUH4gFb9AuINcA5ubBlB3jXw4iz4K7rNHp31dizR+BwQHEx9OgBMTEHD0CEEMwq9bEr000sOnZ01uHlE+rxRq+XHY0Z5PL7aFHAxuM0aHLdO0J2/tvpfiJoXpQeCevUl6aT0KmMoN9MdXEmI+KCZATtzHcZKAvJ/dyaBC9EB0lidHBFZL9pgFWw0df8Kfn+NMChw+3J8EK1nKp1ZiwcZxNMSdpBEEFmxMyroTwGWKOdeiF4qRpyzbDdD9+54O5UOC167gpFgKV4GEssCVo7hfd+Ao1doJajdS2DmWXL6pk+vYqKigBGo5wXv3Gjm337fMTHGxk2LJZQSPD997WMGpXA6NEJvPZaCS+80JORI+P55psaCgp8dOtm44wz1uNw6AweHMvixfXR15JTwR5+OJcHHthDaqqJ2tpQ07qTDn8uDRoYdfCH246GWgzg3++OMekwLkdWht9ZD1trocqHnmIhkhh9LMVKapaFJBFi+54ATMqDY5LBagRPEJxB8IexdYvFJzSMvhBBTQOzQb54gQu6yhE3Q0OAcKEL+kU/iFhXBQtLMV/Rk0C8BUIRTMVurMlmwnFmeiborKuNXov23rfW/LgeDhPjrKMhIbmDi4oMDoyG9gOjUBiDUSfc8l7fv13jlKy6BoTNeuBCkjv3QUkFnDhYZgJLP8BxbdgO81fDicfA0L7tt6uqgy/mgj8Oaizw9xPB4yP+iVfYu/1mEhJsHRzIj0cFFkeQGrFQFOWntHqz4PM5EGOXRZZXboRH/gj/eF2ObmhaY4Vn2V7TZPbKULQf0TmjZSKYxl/vWtP0D4cN+veAC8fJ2mS3/D7C3Xe8z9y5MrgIhwXED8GghzhliJOkTj2Ytvw4rJ7l+CrWgjWbNNseKsrq2xy7w2HiqqsGM3Fib045pStr1pQSF2ehqKiBefP2Ul3tYcCAdK666pg2i8uXLi1k7Nj/4HIF0HWNoqI/k5ERw85CL/f+ZQYYDNz35ER6Z+n89W1YulkGaU6Dxj4PpPkEwwPgPUHj2y2QHSNwhaDOF+0NRMRBPxVtpRpZ+yMEJg8EDUAhEIEENxzbCXJyYNgwjXPPhczM6FSisCy6BnDTTRFeeQXOOgs++kjDbpePV4kQ91NGOgb+RBrxmoFdws848gm1ezDQFRNWdLbjb7qq8ejMjnTncvaxXfPRWIi9iQZmNAzIx8dG4tH1CLtrYnHF1hFvDiO8NuZU2EnKLkUIDa0omxKfiYT0CvxeK976eF7PMPBuPcxzt+2jme1uMro2pwS27elOL0eQYhHG4XWwwNP6pGvAQCtoKeXUxtUii8qb+Zs7l6XRtgvdMMgG58fJ6VxZRjmKomkaSzyC12vghiQ43n7gC/qtU2DToZsZMo0Hzrb1U1i8uI6sLAudOllYsaKB5GQTGza46NzZyogR8Xi9YaxWnYaGMMuWyWlhOTlWvvqqmqIiPxkZZjIzzUyYkMyiRfV8/HEFhYU+Jk5M5aKL0vB4wsycWc2cObXoukZcnIGiIn/TVLCUFCNCaNTWBunf38FJJyVw2WXpvPNOGS+/3JwWu72pYq2mn2mAUUMLRbOxdY2VQUeVD1OahaDVBMVuiAguuKEzXTKMvPjYXvl8sw59EmF3A7iCTa/XtauVvOMSmDOvXt5kIzPltDGzDJ6o8WPsn0gns+CavAjGeh9/nxeCLrGy8nxDAHbWwanZsKmGY/dVsC0+ltwLc8AfpjigU22Ro1lNN3EgArvriekZiyUcoWZxBcJmhOEZxGgCt9CamjYG+sZ6v/zdm2Rpva8fcGu1imEaR0faG8Vp+QTARIT6y8FmPbL1dQ6FCiyOIBVYKIrySxAOC75eIKcRnTESrrwHcjLhrmvkh2UX3wm3XQbXXQDHXihH6g+F1QL/d5sMRgb38rJn2w6e/qQ/Xr/Ot69pPDQFlq5rbB2d0xN2wa5nMRo1IhFa5bXXNBC6BWvO2YTqNhOq3drmNePjLbz77nkMGZJJUpKNQCBMauo/m2p3AFxySX/effc8HnxwLo8/vgiAO+44nueea1uFOBASmAyy4xkICT5Y6OPuP7xGUlo8v3/gMlx+nStOhAXb4Z3FsDy/8e+2kKly/ZAUAzWH+tfQA9QAW4E60EdAchK4K8DjhJ4DwZKlsW2rILgYKIc+feCxJzVqKhsXCMM557TujRSKALsIUEaQhbjpgYXt+HETZjLZxGsGqkSIP1LMBny8RjbDNQf1IsxTVDCdejIwkd/xmE5T/6fVW23xD02DXsLMtug+kjAwUnNwBjHM8ITYGRTU+czsqrNTHzKQ2rkQW6y73ddy1iRQW5aBI6EWsyVAbUUqCB3dECS71+5WbQPl6ZRVJ7Z7rGYNpncWHGPT+GMpfNIgR19Oj4F0I9h0qArJ6Vt3pcAKL7xZCx/VQ0N0RCZGl9m4bk2GgiB4InBSi8XrzrBgRwC6mGQygT+VwnIvvJsN/aIjMCEhcEUg4Qdm42q0wy9INULi//j8/1VNTRCbTcdmM0SzxkWwWptHiMJhwbJl9fToYefll4upqwtx9dWZfPhhObNn19K7t50nn+zGv/9dwvff1+D1RsjKsnDmmcmYTDpTphSxbp0Lo1Fj7txjqKsLs327h27dbJx9tkwZu3u3l2uu2cb8+XWAnBpmtRqastPV14d+lEXPuk40/S0yOogzN3fi3UEIRNoGUokWqPPLtokW8IboHg8Wm4HN610y4DkmBX17LZHsGOiXRFyGhRevTGRpnYEt6xtY+MBmSLMRMz4bl8Uk97egFG1oCp3HZpLg0DkjKcTKp7fRd0AM4YEpeCIQLqtnuTURpzNChUfI168PYM+20T3JwPpJP09wrAKLI0gFFoqiHG1KKgSX3QVzV0D3HJmN6pm34ck/w9SvYNXmjp9rMslMV9BcdLg1+SfjqrHbuevmLBYuLuO+v33O6NFdGTMmjzVrSnn72xwC1gFAGHY+C5H2qxU3pl3MzU1g9+7aVtvi4y1ccEFf3nxzbXMGGg2uu24op52Wx4kndiYrq/3fyRMnftiUPWvy5AnccstxANTVeUlIsOH0CraWQm4K+OpdlJb66TMgmVvegLiwXDP+6Q5I1WF7Q4uRDq1Ft7zpU0/k/KyObBcyAEkHukefXyNnViT11XDEwqSB8M1bgjOGwJlnauzbB8uWCWbOhH794K23NFJTW3coWk7X+e47wcaNcONNArtN4zFPJaVakNNsDj6hHhs6OuBAJx4DH1OHjoYZqInmvWoZcGjIjnuo8YGmC9b8bW8sdA/EsNhQT60e6jBrVt9gLFtMMm1yYsREWX5XGixuUjqXyA5f2IjBKG+yqqJMPA1x7P/xr8EUIDO3gFDQRNneHGhcSBxlNAVIzCzHZAmQ5LezZV8GAq318WgRGdREj3OwFa5KhF4WqNcCXF4Swe+PVhDXwB99cpIBCnuBXdf4Y4lgcg1MiJGL4eMNcmpYfkB+f3WizKIVBjb4YJNPLra3aFAYhMk1kGKAJXlyrQpAbViQaJDPW+eD9+sgxShHZNoLQIqCgn9VQ20YBlnh2kSwHKRw46GqDQvmuiDO0Dxd7VAFAhGCQYHDceApbfX1Iaqrg2RnWzCb5XX0eMLMmFFNXV2IvXu9lJQE6NrVSnl5gG3b3ITDMHp0IscfH8fChXWsXu2ktNRPOCyDosGDY5kwIZktW9zMnFlNfLyRk09OoLDQzzvvtK3jkZZmoqEhTGKikUmTUnnppWKEgN697eg6bNnSdq5p44++xdK4ILttGrPGuhYHSh8LcuTIaNQpLw8ccnYqXYcHHu3Gg/fkHLzxj0AFFkeQCiwURTkaCSHYvBM6pcu1HG4PxDhkB2b1ZthTBDsL4N7nm59js4LPL9Ph+1ok0tE1WP9ZdIbCpXIhusEgp2AFQ3DacHjt/6BLJw2PV5B4vCAQDU66p5Ux6YTNjBvXnbg4C2+8sYYPp26izp+B5uiKcO0Er1zBPmpUDq+9dja9e08BGj9x1HjssTH8/e/ftxkZmTChB7feehy5uYl065bIffd9z9q1pXz3XX5Tuy5d4nnllbO44YYZlJe7ePbZM8jPr8ViMTJ7dj4rVxYzbFgWCxZchdVqYt++OurqfAwcKAtuFdcK3H5IsMOcLfJcGAnx9TrB1NUmPMGDrMw+VNXAKqAMSABygCzAB/27QSBF45we0FsXdM/T6NYN1q6FTz6J8O67ABo33QQPPKDRv7+gvh7+/ndITdXIzoaTToKkJNk7ikT/7Ouaxmrh4S1quIgEkjDyKXVEgEtJ5HWqmVbvJOyIoBlo3d8XzXPeRQjuc2XwRFIZPbHwBp0ZTz4NtO1hxaETEgIvgksjyZwsYrjeUNAU0AzxJTLAYGKf18gWo4uIJqgxewkZQtE1JSbGVOfwSa0Jr5AHktUjH6OpuVBcXVkq50aS6WuRowRLE4rx2F3UVyZjtvowmoMEfFZqS9PRNEFWz91omqB0d1eC0eDCFuPE4vDSUJHCSJtOYRD2dFCLDmTwEK+DW0AwIt9MRymYn8kK47a5qK2P5eVqnR5mKAvJbF6NT9GBjztDqhH6WeD5avjaKRfXtzyM7ma4JxWGWOVUndIgzHLLqV/VYfBF4OJ4uZ+KEIxsMUqzxiswaTKI/LwBHq5sDqim58DEOI2wEEQAU4tpZIvcgpIQTIxtXY3eFxFYGqcMafK5pSHINmmEhMBA67UsPzYhBEuXNrB5s5vERCPHHBODw2EgI8Pc1PnXddiwwU2nTmZSUswIIfjuuxr+8Y999O/v4M47c4iPN7BihZO6uhBDh8ZSVubnjjt2UVjo4+KL0zAaNZ5/vqhpn1arzsiRcdTWhli1ykVCgoEXX+yJ1xvh3nvzqa6WV9Bo1NB1rSlD1f40DY49NpYVK2RgnpVlprj4xB/9vLVHBRZHkAosFEX5Ndu6W7CnCLpkyYyPb38G40fBLY/A3OWyzQVjYdoLskPw6MuC+19su5+0ZJk0pU8uPPl6623P3wM3/E4GLNv3wMRbYPte+afHaobbJ26kpqKcJx8bSVKSnTvv/JbXXluNzxdi8uQJXH/9MN58cw233TYTj0+DSPNUn8Z+itlswN9iweoPyVUPcPnlAznjjO5cffXnBINhzjuvNwsW7CM21sygQRkcf3wn/va3UQCMHv02ixbt46/3nET6gD7k5iSiaUYqnH7qfTrb1tXy+dtbqdU0At1zITUb6l0Y7TZCluY6Fm0OUCAXoMcAKR0c6E4Bu4AKIAnop0Urnws0v8ZFE+CjfOQoyjxkdqzjwJAA558ET1+ucd/dgl274N//1ujfv21Hr9YtSHRo1NYKkpMFxIbJvMDDXb83kYSBmaVevqv30LOHxuZvTfhm2Tm7h5X/fAI2NDRNY5Fwcy2F+BBY0MjBxM7o9CoNiEVnHt1I0ozMFA3cSjFh2sQubc8PEKvpnC3iyAnbmK7VsV33Nu238TkPaenEolNEkOeoapWNtfE1bAELkeoUfJnFTf82l3aiLLYWe5IcQastT8VVm4A1xo3ZFEQPG6mpj201aqLpYRLSKgn6LLjrEg8aZ2bk7sVs8+F1Oajcl83+IzQtaYBNA6s5QMDmwVUfR0JqFcGAGXddAgBpBqiM3vq5JsgPtt0HgFWDy+Jl8DPbJf8fLd/R5pgvj4c/p8hF95cXQVczJBjkepcvnLK9TZP1UGojUB6CT+plUOOJyIBHB7YHIN0osCdXo6HxiCmZqfUwxCaDKWcYRjlkINQQkf9f45VT1jRkwUi7DvVhmO+RRSX7Wts/X2u9gltL5LFenwQn2VsHMu6IYLFbvp7tEEZ5XqkRVITg3lRapWBuj88nL0BtbYj4eCN2uxy52bLFTWammcREuaYsFIqwZImsr3H88XEEgxHee6+c8nKZHMBk0khIMFFeHmDAAAeDB8dyzz27sdkM5ORYeOCBrj9pcNZIBRZHgMoKpSjKb1kkIli+Hsqq5JoOu615cfKjL8ObzQXE2Rct2tZy/nPvPMgvhEBQBhSBIPTrLlPSL17T+rW06H/uvhae+LPcyYKVgg++EhzbX2P9dpngZWCvCDc/DDaTD0ukFM25AZ+pN57iRfjqo4tPDXZsWSdy/5/T+eqT+SxeUojRksCQgXZWrChhf337prB9n41wyniSw4uoLtzS7vmIiTFz5ZXHYLEYeOaZpc3HroHJZMBiMeByBUhLc1Bevt+aA02XNQJ0nbv/eRFlLiM9eqXy3uQFbNsRQuuag7A5oGvPtielo1y1e5HBQ9Z+jzf2nH3At9Hvz0R+LA04QhHclTqYwOCDST3gpH4aWVnwxndOFtVZcNpMTOzVQJdyM88/b6Wj+VCaBsIu9627oLhYa6qODuATEd7bXcTA2BgGpSWwBi/xGHASIQsjnbXmOWS7hJ/ZuKggRDlBKgixhwDVhBHAMGyUEKQkurx9/7UivbHwDzKYSEGb9bT7nz47Gh4EZiAJY3M2rnZYhYZvvz0khs30FVaSvLFUNsRijatnfmwpApgYSUAPmZgfCKKZg2jGIKe7MgkETVwWY+DhBh9rUguajs1Xm0B1VRIiaGaIVWDrXIQnpFNWkUytz0xiYh0NCGISazGaQoQDJoxmGTkkFuayzikXERuASDvv1WL3YIt14axOJBwyRc+LwBrjwuuKaXU9DQjOiNH42tXxuWvPwdqabR4ycvcBUL67a9OUs/330fK6nRsLCz1Q0046tH4W+KYrdDJFP+yoEMxwwnpfc+0WDRlk3ZUqp645dDhlD2z2y3U0VyfKKWz5ARlonB4DJzuaR/QerYQHK+S+bkyCs2OhrwW6mpvP1xafIMUoR4W2B2CkXR7DroAMgI6NJhfY4JMByikOOYr1cIUM8u5NbT3i00gIwdt18ppeniCDoy0+QaIBMk1qjcVRT41YKIqidCwQECxcLb9/70tYuFrOMf7gn3Kawdhrod7ZdtHlWafIYOGzOc37slvBbgN/QHYyXO2vCQaimWSyYE8xJMQKbr3ES119mOlzHZRU6lx7ATx8S4C/PxPknS/tXHYOzJhVh8tn4eYL6+jf1clJJ6bQvXsyGSP8VNaZIeRE2/McZpMc/TAadcLhSKs1Ho3vwWDQZAatDtx553DKylxMm7aFv/xleNMC9P3300pWN0jOBMDosNM3xUePYb3YXBBk29I9MPh4mSEnxnFIWWhMOlh1gTN0gMabgSoAAb00yGixrRqoB5zItSKNS2USNBnQZAGd5FNZDv1iYcX85uxXc+fu4dRTP8ViGcvJJ/dmyhQj3bppVDYIImHQgpCWduA34hYRduGnL1ZCCAqjQcdH1FFHmCCCWHQeI5M0zci3ooHnqaKAAH2wUkuYeAzcRSr/pppxxHIBCdxIId9HCx0mY8BDBE+LrrGOHFWpb2c6VyM7Gr2wsh1fq+e2RwO6YKKYYKupTAjog5UHSGeW5uTtplUvkIAuJ6Z1sM5FA5IjRroFY3hMy2BtOMDnAS92U5g4v511jip2mWRxPkPIxKiqrjhj69htrqfOFCAhZCGlpAvBiE5snJPCpDKGazacRZ2Y2iBIjneR7LdR7DPhFKDrYSIRHTNwvE1jiVdO/8o0QZpR4ArDWp+GXYMG0XwekzsXYYt1oQFuZwxVhdntnCFBTGIdoOGtjW+dCrYdnY3gjJ4or2iewrW/OF22s2oy8OqoXbYRxsbIFMquCFyxX30hLbqvtd3kAKFdh+G7obhFTGrVZGAjgKFWmBQHFyfAHwphiVcWpDRpLYpcIl/v2kQ4JxbuLINtfnBHZFAFMNQGgywyYUEvC8zLPbTRliNNBRZHkAosFEVR/nelFYKl62BwX1i0Grx+GNADhg+WVY0vvQu27wWPD3bvO3jWF02TNa2+nHfwqU4piTLIqalvu61fd3B7ZVrfTTuhsfc2uFeAP14aYO+O3Wyr6sfZo2HG9wHmLDdxUs8NCFc+p5+ex6mn5vH22+vYsaOK777bTSAQoVevZBISrNx++wmcd14fAPz+EBaLkY8+2sSUKSvYu7eObt2SWLiwALPZQE5OPLt313DGGd3p0SOZV17bgk/LBM8eNBFoes+tFoSmdIK8/mCyoNWUIuzxkNoJ7HEQmwiuOjR3HSK9q2zvrocV2+CE4+T8lf9FLbBPQCXQleaF6PvRKgXjxC6uuCKDq2/Yhyc7HfzJEK+hdYa4OGjQNQgJMrZ7SXCVcuzxTpZUCHx6KnP+lY633sSiReD1ugiHawmFsrnpJo3ExOhrRG+SFSsEXq9cPwIwf/5eEhKsHHOMDM5CIcHZZwtqa2H2bK1V7ZGQEMzFxS78jMJBNSFep4bOmEjGyAk4aCDMXyilO2bGEcsAbLxONfNojngb9zgUKxvxt0gGLD9xtqMjkGtKWo4onIKD5Xia6pkcyghBKgYq26loYkVjAFbW4u1w7EUH+mNhY6sjlFPXdDTc0XAmBo0vyWVTMMRfTYVowK2ksFx4mY+LnLCVOF3jUj2Oi0igmgjPU8ki3JQR4maSGE0MOzxGfCGdk2w6l4aLKbLIYRCT0HjJ1421biNxBkg0wEJvmBX2Cipi5A/q8d5kvnFqaA1xJEbMOCMykcAoByz3QGVYoGsCEZ2O1vL9XJ8IPS3wUrWcEmYwBtHCBsyxLgzGEIa6ROqixSM1PYzZ6sPvsQMaFquXuNRqXLXxshil0NtNSnCoozk/pN0YB8w5wAcpIKd2Tc+BJKMKLI5qKrBQFEX58YXDghUbwGGXtTa8Ppkyd+VGyMmCecth9jKYfB+MGwU3PgTfL4PsDJi3ovW+ThwMlbVycTr8sLUWjS6eAB/NbP1cTYMHboY/XwE1DXLx+ohLYHAfGH6MYOl6DZ8frp4E/XpAbie5YL49tbVequsNOD0mjukjO8sV1YJ+Z0WoqtMwGuDsY3cw+7+f4nQG6NcvlSlTzuS++77H6fTz4IOn8Le/zeavfz2RDz/cyJw5e+jXPxVrWgYblu4k6PVBciZaSiaicCe6z0XXAXnkG/pC7R7wOqFTb8jsDqEICCP4vFC+B8I+GD6mRRasg2jZ+woh6304kfM+hh1gH/kCvBrUCRihyf34gT3Ij6GDyOlemwSENVKzPKSf42DzHjAkQ6ga2CpICNeSlLuD/HXr0NwVnHZaHg88cDJT3urM1DcBBN261xA0r+P8CUk889QQamrgtdcEJhOce65G9+4aW4pC3PNfndP6adwyBioqXEyZsoV33+3JgKFB/v1GKpkJsAEfmi9ECKi0CuIwcBx2qgixGi8OdLpiJhsTX38JM2YIHnlGsDzGxX+oJYzgHWR2n69o4BPq2U2AY7ByBUm4iPBPKiggyCk4CCGIx8DjZDKNOo7HziT2thr5aDzLJloXkOyMEQNaU2s7Gn8ilU+oZzstMjS00NG0qv0NxkYB/hZjLK2PBeDvpPEMla2mk2nA42QQATbhYzmetimSBYzVYniGLPYR5C5KKCZIZ8yUiCA1hOkizFjRyRZm/hTKaloDciWF2NDYGwmxXfO1uj2v0hLp35DO8mCAbxL20aCHSAhZGBSIZ6G9kkhjy6CJk71pmMwBFgYDGMwB3CYfoaAJX2UatQ0O+lg0CgMQErII5JaAXO9yXpzMrLXaC3PdMpbPNMLu6AXraoKGMNREYLAF1vnbnmubJkc3GqKn9uoEeCnryGUA+6FUYHEEqcBCURTllysUEvz7IzntKjlBZrYaP0r2iT+bAwUl0CcPLrgd+nSDf94Fn8+R60J65cLTb8ligzlZsK/tEow2jAY5XcsZ/XSxo7+gBoP8uvF3MtB59m15TBdPgNxsWLcVHn9VTvv66t8w4SSN6+4XvP5Ji33o8O2/vSTa6xg8OBNN09qtFB0OR/B4gsTGyvn2TqefNWur2LBDcPkFKUyfvpXs7DiOPTaLRx5ZwNtvr2XYsCwmTerLK6+sYv36MlJTHdx994nYbCbuvPNbrvrjqcxe7WRHjQXiU+mW4GO3MwZsMRDwgd8LFU4o2AR5XaDfCDBZZdqsI80LlCNT9h6o6PA2N2zcBWkJOAYm446PkWtNjMiemwUIg6miAG3lRgK1YwAb+giNM0+OMHtfBK9RFh+z1gWJ2/A2FXuGQcwxcJaG0QYz79So27aNSx4vRUQEo1LLOXvcEJ55Jo3U1DrOP7+Iq64aRHZ2PLt3++jbVxAImDnttH0EAvPo0yeFO+44gU2bKpg4sTdGo1z8UlBQx7vvruess3qSmmqnutZLSv8ksjC1utY+X5BFi/ZRlWfBlWtjYiSOOaVVuAwRjkmKo7PZytvUUkyQvli5kkQ+mbeLBxxVZIdNvHf8QDrrFupFmDui9VAiCNKEka5z61nSQ8eZbUZDY6hmZRW+ptc2IuNGA3IEJCRAtLjcHVWI14BczOjArpYBRGOWN01rZ9W+XCxk0+QalwN1VC1onISDBiKsxXOAKi4y0NLRyMLEsg4msDWmJG58T+2NAg3Bxh9JYSQOACoJ8mKkFqsGRk0+XyAoD8kaKqfpDjL8MVSFIM8eYrKopjoM2SaoCMk1GLrQSdZ04gI2rrM6iNVhhVew215HF4OBSVr8Ad7Zj0sFFkeQCiwURVGOfm6PwG5rm+7y45mCucvlSMTV98opW+u2wjeLYPRxsvq50QD33gBPvSnT9oKs9xGJyNGVBlfHr6tpYLPIqV4diYuBrp1ggyy9wbD+sGqT/N5sgkG94Y7LZRB0wiA4bgBs3g3vfi5HRS47Rx7jO5/Bv+6DYf01xl8n+GYR9OwqK7efMAg27pCB1rD+cOwAmgKVjZvr+XRuDKlJBm68GKpqw6QlG6h3CtauLmDr1kpy+gzh8r8KTIYAvzt+GTt319O1s5Wiwlqqqjx06ZJA5y6J7Ax0Z8UOP+W1TmLSEzlhaBo1XgN11S6y3LtYtqiBYGUS9E3FlBdH1zgfO/3pGMIhhF8QibH8z9f4kEWAWWFZWa/nfutKWlq+F7YlQGI8nB3t/IZAbwgSSYpWjs/fBgudoA2DnsAxApMuiKsKUF1olb1SJ7JXXrEMggVACdYxZ9C3Ry86m4N0SRT858OF1JaOgeRSCNZCiZvMzNWMHJlJcXED5eVuzjijO6+/voZAUHbfhwzOZMeOalwuBzCGgQM78eWXieTkaMyfv5dXXlnFokX7KC5uaAqAu3dPYunSa0hJkR3i/35XypItXgqXrmbax5tBA0OGFYvZwEeTz6HrmTksx0tpcQMp82uZE2ggw6mxdlclO3qaOS85hUnn9Kab3Y4OPFdZzKLdFZgybWTlxBKPAa8zyNWGZCz7vDzjLqO4t5VIIELZygoCa2oZPiSL0BlpXEA8Anhm117qNtZiO7cTGhAvdDSDhoeIDBoEGOqDhOOj10DreNpRJkZCoQg5mNhrDDaNrjS2swItfzQvI4G/kMbrVPMfalutsWkMrBp1wUQeZnQ06gixmo5/yLthpgcWIgicRFhK21oZLdsOw4YfQR1h5uEmBp0zieUf2v7ZGn4aKrA4AlRWKEVRlN+mUEiwLV9OZ9q5Vxaz69pJw+UWzFwIqUlw0jDZNhyWU6bqnDIQ2VcKf/ibLEz412vgkZdhbdvi44Dcb7ds2LZH/rtxROOtx+ChyfDEa63bH0oK3YmnwolD4L4X5GhIe89NTYIRg2Vn7NZL4bzbmkdgYuwyeEpLlp2vCSfJwGTstbA1Wiw7KR5qG2RQdd2F8MSfwWLWmPye4LbH5KDFog9g+DEycBFC1iMBueZk/uIqjCYTo0cmoWkapTVhHBYoLKzj75P3UmVMw2S3YXDE4PELGjauJZLSmVg9RLCklPKwiXSjn30BBw3J3QmZHJgCgohZQ2hgC4eIeMJ4/5cgJYD8yNqI/PjdDdij/26PF9gH5EXbHGjA5kshg5g0TS5672ifVcBSARYnVBXDuBxw+8BtAlECPXpAKAB798IOA9R2ly+cB/YBHmLjvRgq9lBS2CBHmFy1kJgGy74HEUHTEhkwwM6gU3L5oO5YwpoJ1tfDuhmg74ku6OkOnMXwEQVcf51gyltbWFWZAAXbwNPQ4mDtXHRRH668pj+2rE7c+Vw+a/47C+qr6ds3lUAgzO7dNQAkJFipq/O1ew9v334rPXum8P33+Zx66rsAWMdnIuqDhJZXc955fXjiyVNx5MXxzqtreOGhBVRZBIQFqSPSSRyYRGqslZMTEzjumExS+icTRuCaU8q4se+RnGznor8fx9q+Jno6dTZbg9TX+/ls5BDyc0zMw0UuZm4muenDB6+IsBYvRdHRn15Y+A4nj1DelEnsSGbPOljbFAys0nq21/xHpwKLI0iNWCiKoig/RCQimjrS4bBgwSpIT5bFBOevhKpaWTfkjJGQkSJHJypqYFAvWWSw8XkPT4FXP4byahkM/OFceP9LmQIY5FSrcDtzTxoHZTJToaSi4+M82EL5lu06amOzwJ+uhIWrZFBVEJ1OFhcj32Ndgzz2epc8BxeNg7/8E8IhGDFEjqhM+wb8QRg1BNJT4O/Xg8sDi9bIdTLF5ZCaCFNnysKN990I//dHOeLy9JuCvz4Lpx0vX2NgT3jpAXlu5m6Tx50cA94ADMqBJVt83Pm+gR21RjLiQvxhpIHdu4Ms2GnAoxu458RqvHXlPLuyK3UGe/T9azh8ApcLSG68yMggpG3m1CMriFw40ZF8EU1HhAyAOhp9AdiOTNe0HThTg8T9tkcgsdiHb5UHb0MipAITNPC6wGAHsy6r//n9oIdh+joIjwBDPlyYIyNlkDfl7p1gMkJiMqxeC0UrgADZPTtR6jYTxgBWh7wRqkswZHTG0a0HXShh4zdL5T2X0wfMVvBnAn1J6FpE1/gS1s1Y2PqGNBig73AZQFUU0n34IPLy4gnu2kxlhZtNmzr+IejaPY3cHAepQ4eSnqDh3LmT9HRHdKus3m7QwWYzcf/9JyOEwI/ggVkbWFFhwqcZcJgCZBjcaMgC7yZN46Lz+yKAGsIsW11MZbkbTYAmQBcCLRo6hI0ao8flYdcM2NBZuq6EomoXWAxYDTpWXcdl00jUjZzRvxMTiFV1LI52KrBQFEVRfi5CCMJhWaUXwOcXfDVfduAvmSA74C++BwXFcOV5ssBhMARjjoc/XwmzlsC/3pMZsI4bINeSrNwInTNkwPLFXDmN6qJxMsBZuQkG9pLfd0qXU7EaCyj+321wxxMyy1Zmqhy18PlbByi6vl8GqxYOtWhhapLcf+PUsP3ZLDC0v3ztNVvavt6IY+T2lAR44JbmTtizbwuKy6NT+qPTZ3Rdfh9jh3tvbG773NuC9QWy2FtZKXSKg+xM2FoPZS546VbokQrvLoSPlkAnC3SOgfJaqPLCLp+shxAEwgaNUEBQ7dOwaoK46gg+r05MJtSYZAZhTa5PJ8kkMOhQ59EI+jnwmpL/4dwCMiAy0fHoikCOmpiBjqb1h5FV4jNoqpHSoXKgLAJlhUy4NoOZRZb2j1UA27xQvIeTzjSzKZJHTVBv2y4iiPW5cWxYQpkLsATgxPGg73cgNTXgCcOurVBTKR+z+WDoSVBbIdM7xyaA1ws2G4TCMPMrCAYhNxcGDpQ3V9ke9FAIU24vwujE4cNTVIEvu2v0uAXs2AS1hVBZiO72ct7vx6JpMnxYtHgfpaUt5kv6StGCchRHGOxcdt056LosLLlgwV727K1rbusvRwtUk5rq4Nlnz+DSSwce5GT/OFRgcQSpwEJRFEX5rWgcbamuFcTFyLUhS9fB6OPldKfCUsHKjbIOSVUd3PAg7C2G6y+SAcfZp8Btj8GStc377NkVnr1brluZ/L4MHOJjYJesmYbVIqdXGQ0Q64Atu9vvJJuMsl15deuEVYlx7acUNpugf4/mQGLLro7XupiMsnK8psn+5fptMmjrqO2IwfIYXR6ZLtndQVuzCcaeKL8PAKvXQXVd+20NJrjhguYgYfpsKHUjgwtL9MsE1AEIkjLBHqPRNQE274VaJ81TuZKjBRW8gBUcQTmwUR8LIQM0pfLyIdeApLZ/TK0IDl4/5WAjLEdKBLngwXywhshaLCbkeTzQ8QugBHnOkmk7otNSmI4DKhFd1b6D6LWK7i+3xcGLxmhYA80Au5EpnYm+brfGfUXbev3ErN+IM3/EAQ7qx6MCiyNIBRaKoiiKcuj8AcG+EjnK4fXLaVGN0zcKigXpKbIa+/Y9sjr7CYMgKUFur6kTPDhZbu/XHXrnykCksEwGKAmxMHupnG1jMsm1LD26wOrN8rUn3to8VQxaByCHMuXraGrbsv2hthUacspUGNmR9kf/b0V2lP3R/8cgO+7B6Pcm5MhDUrS9EPI5tVqLzFvRFMHpGtiF7Py7NLAIuQ97dD+R6FdjEGKKfl8XfS0bMtgJR/drRAZLvuj2loMYAnBF29qRgUZkvzY/Flf09WM72O6nOU2WkQMHQX6aV4YbaDvFToDeECE8vaOFOT8uFVgcQSqwUBRFUZSjg8stWLZeZjIV+31FIs194jZfLR43GuSoBEAgKDN2Od0yYIkIOdridMuOelyMTFcc3O8Lmjv7+/8/GJJT09yeQ1vI+0Mc6R7dkdpfMBg9t0YoLZNpoQNBaGiQ0826pEF8AtTXwaq1gl3bYcQIWeG+oQGOPx527QJvEKr8UFQuKN0HugtEGALRkhzGBEiwglOAPxFiYsDVAHggywphHcp1ZDDjBbsf/DEy7WthLUTSkQFALXI6mAE5gmBGBj4umoOkvRBrAlciiDRkMPAjdhMtQP2/NSyWX/Yai58n9FEURVEURTnCYhwap/08s0WUI+ZQOs6t24TDAp8PHNGClJGIIBQCs1ljwwZBTAzk5clthYWCigpIS4POnZv3s2mT4LPPwOcTpKdr7Nwpq7ZnZMgRssJCSEyErl019u4VDL5E46KLYNkyeOklwTlnaDz1smBPOcTGQZeuMGSoxsJFgvxoRrXsbCgpkUGubmixPqijlFEaJCRAXR1YYuRyEMtPkJH5cKgRi4NQIxaKoiiKoijKwbRXwFIIwbZtUF4OJ54I+/Y1Jzp4/30YMwaGDAGPp3lkrfHLbofYWPjPf2Tyq8svV5W3j1qqjoWiKIqiKIryW6cCiyNIjVgoiqIoiqIov1U/pC/8U6ybVxRFURRFURTlV04FFoqiKIqiKIqiHDYVWCiKoiiKoiiKcthUYKEoiqIoiqIoymFTgYWiKIqiKIqiKIdNBRaKoiiKoiiKohw2FVgoiqIoiqIoinLYVGChKIqiKIqiKMphU4FFB6ZMmULfvn059thjf+5DURRFURRFUZRfPFV5+yBU5W1FURRFURTlt0pV3lYURVEURVEU5SelAgtFURRFURRFUQ6bCiwURVEURVEURTlsKrBQFEVRFEVRFOWwqcBCURRFURRFUZTDpgILRVEURVEURVEOmwosFEVRFEVRFEU5bCqwUBRFURRFURTlsKnAQlEURVEURVGUw6YCC0VRFEVRFEVRDpsKLBRFURRFURRFOWwqsFAURVEURVEU5bAZf+4D+KWaMmUKU6ZMIRQKAdDQ0PAzH5GiKIqiKIqi/LQa+8BCiIO21cShtPoNKyoqonPnzj/3YSiKoiiKoijKz6awsJDs7OwDtlGBxUFEIhFKSkqIjY1F07Sf/PUbGhro3LkzhYWFxMXF/eSvr/z81D2gqHvgt01df0XdA8rPeQ8IIXA6nWRlZaHrB15FoaZCHYSu6weNzn4KcXFx6pfJb5y6BxR1D/y2qeuvqHtA+bnugfj4+ENqpxZvK4qiKIqiKIpy2FRgoSiKoiiKoijKYVOBxS+cxWLhwQcfxGKx/NyHovxM1D2gqHvgt01df0XdA8rRcg+oxduKoiiKoiiKohw2NWKhKIqiKIqiKMphU4GFoiiKoiiKoiiHTQUWiqIoiqIoiqIcNhVY/IK99NJL5ObmYrVaGTp0KAsXLvy5D0k5QhYsWMDZZ59NVlYWmqbx2WeftdouhOChhx4iKysLm83GKaecwubNm1u18fv93HbbbaSkpOBwODjnnHMoKir6Cd+F8r964oknOPbYY4mNjSUtLY2JEyeyffv2Vm3UPfDr9vLLLzNw4MCmnPTDhw9n5syZTdvV9f/teeKJJ9A0jTvuuKPpMXUf/Lo99NBDaJrW6isjI6Np+9F4/VVg8Qv10Ucfcccdd3Dvvfeydu1aRo0axfjx49m3b9/PfWjKEeB2uxk0aBCTJ09ud/tTTz3Fs88+y+TJk1m5ciUZGRmcfvrpOJ3OpjZ33HEH06dPZ+rUqSxatAiXy8VZZ51FOBz+qd6G8j+aP38+t9xyC8uWLWPWrFmEQiHGjh2L2+1uaqPugV+37OxsnnzySVatWsWqVasYM2YM5557blOnQV3/35aVK1fy6quvMnDgwFaPq/vg169fv36UlpY2fW3cuLFp21F5/YXyi3TccceJG2+8sdVjvXv3Fn/7299+piNSfiyAmD59etO/I5GIyMjIEE8++WTTYz6fT8THx4tXXnlFCCFEXV2dMJlMYurUqU1tiouLha7r4ptvvvnJjl05MioqKgQg5s+fL4RQ98BvVWJionj99dfV9f+NcTqdokePHmLWrFni5JNPFrfffrsQQv0e+C148MEHxaBBg9rddrRefzVi8QsUCARYvXo1Y8eObfX42LFjWbJkyc90VMpPZc+ePZSVlbW6/haLhZNPPrnp+q9evZpgMNiqTVZWFv3791f3yFGovr4egKSkJEDdA7814XCYqVOn4na7GT58uLr+vzG33HILZ555Jqeddlqrx9V98Nuwc+dOsrKyyM3N5eKLLyY/Px84eq+/8Wd5VeWAqqqqCIfDpKent3o8PT2dsrKyn+molJ9K4zVu7/oXFBQ0tTGbzSQmJrZpo+6Ro4sQgj//+c+MHDmS/v37A+oe+K3YuHEjw4cPx+fzERMTw/Tp0+nbt29Th0Bd/1+/qVOnsmbNGlauXNlmm/o98Ot3/PHH8+6779KzZ0/Ky8t59NFHGTFiBJs3bz5qr78KLH7BNE1r9W8hRJvHlF+v/+X6q3vk6HPrrbeyYcMGFi1a1Gabugd+3Xr16sW6deuoq6vjv//9L1dccQXz589v2q6u/69bYWEht99+O9999x1Wq7XDduo++PUaP3580/cDBgxg+PDhdOvWjXfeeYcTTjgBOPquv5oK9QuUkpKCwWBoE21WVFS0iVyVX5/GjBAHuv4ZGRkEAgFqa2s7bKP88t1222188cUXzJ07l+zs7KbH1T3w22A2m+nevTvDhg3jiSeeYNCgQbzwwgvq+v9GrF69moqKCoYOHYrRaMRoNDJ//nxefPFFjEZj03VU98Fvh8PhYMCAAezcufOo/T2gAotfILPZzNChQ5k1a1arx2fNmsWIESN+pqNSfiq5ublkZGS0uv6BQID58+c3Xf+hQ4diMplatSktLWXTpk3qHjkKCCG49dZb+fTTT/n+++/Jzc1ttV3dA79NQgj8fr+6/r8Rp556Khs3bmTdunVNX8OGDePSSy9l3bp15OXlqfvgN8bv97N161YyMzOP3t8DP8eKceXgpk6dKkwmk3jjjTfEli1bxB133CEcDofYu3fvz31oyhHgdDrF2rVrxdq1awUgnn32WbF27VpRUFAghBDiySefFPHx8eLTTz8VGzduFJdcconIzMwUDQ0NTfu48cYbRXZ2tpg9e7ZYs2aNGDNmjBg0aJAIhUI/19tSDtFNN90k4uPjxbx580RpaWnTl8fjaWqj7oFft3vuuUcsWLBA7NmzR2zYsEH8/e9/F7qui++++04Ioa7/b1XLrFBCqPvg1+7OO+8U8+bNE/n5+WLZsmXirLPOErGxsU19vaPx+qvA4hdsypQpokuXLsJsNoshQ4Y0paJUjn5z584VQJuvK664Qggh08w9+OCDIiMjQ1gsFnHSSSeJjRs3ttqH1+sVt956q0hKShI2m02cddZZYt++fT/Du1F+qPauPSDeeuutpjbqHvh1u/rqq5t+v6empopTTz21KagQQl3/36r9Awt1H/y6/e53vxOZmZnCZDKJrKwsMWnSJLF58+am7Ufj9deEEOLnGStRFEVRFEVRFOXXQq2xUBRFURRFURTlsKnAQlEURVEURVGUw6YCC0VRFEVRFEVRDpsKLBRFURRFURRFOWwqsFAURVEURVEU5bCpwEJRFEVRFEVRlMOmAgtFURRFURRFUQ6bCiwURVEURVEURTlsKrBQFEVRfhU0TeOzzz77uQ9DURTlN0sFFoqiKMphu/LKK9E0rc3XuHHjfu5DUxRFUX4ixp/7ABRFUZRfh3HjxvHWW2+1esxisfxMR6MoiqL81NSIhaIoinJEWCwWMjIyWn0lJiYCcprSyy+/zPjx47HZbOTm5jJt2rRWz9+4cSNjxozBZrORnJzM9ddfj8vlatXmzTffpF+/flgsFjIzM7n11ltbba+qquK8887DbrfTo0cPvvjii6ZttbW1XHrppaSmpmKz2ejRo0ebQEhRFEX536nAQlEURflJ3H///Zx//vmsX7+eyy67jEsuuYStW7cC4PF4GDduHImJiaxcuZJp06Yxe/bsVoHDyy+/zC233ML111/Pxo0b+eKLL+jevXur13j44Ye56KKL2LBhAxMmTODSSy+lpqam6fW3bNnCzJkz2bp1Ky+//DIpKSk/3QlQFEX5ldOEEOLnPghFURTl6HbllVfy3nvvYbVaWz1+9913c//996NpGjfeeCMvv/xy07YTTjiBIUOG8NJLL/Haa69x9913U1hYiMPhAODrr7/m7LPPpqSkhPT0dDp16sRVV13Fo48+2u4xaJrGfffdxyOPPAKA2+0mNjaWr7/+mnHjxnHOOeeQkpLCm2+++SOdBUVRlN82tcZCURRFOSJGjx7dKnAASEpKavp++PDhrbYNHz6cdevWAbB161YGDRrUFFQAnHjiiUQiEbZv346maZSUlHDqqace8BgGDhzY9L3D4SA2NpaKigoAbrrpJs4//3zWrFnD2LFjmThxIiNGjPif3quiKIrSlgosFEVRlCPC4XC0mZp0MJqmASCEaPq+vTY2m+2Q9mcymdo8NxKJADB+/HgKCgr46quvmD17Nqeeeiq33HILTz/99A86ZkVRFKV9ao2FoiiK8pNYtmxZm3/37t0bgL59+7Ju3TrcbnfT9sWLF6PrOj179iQ2NpauXbsyZ86cwzqG1NTUpmlbzz//PK+++uph7U9RFEVppkYsFEVRlCPC7/dTVlbW6jGj0di0QHratGkMGzaMkSNH8v7777NixQreeOMNAC699FIefPBBrrjiCh566CEqKyu57bbbuPzyy0lPTwfgoYce4sYbbyQtLY3x48fjdDpZvHgxt9122yEd3wMPPMDQoUPp168ffr+fGTNm0KdPnyN4BhRFUX7bVGChKIqiHBHffPMNmZmZrR7r1asX27ZtA2TGpqlTp3LzzTeTkZHB+++/T9++fQGw2+18++233H777Rx77LHY7XbOP/98nn322aZ9XXHFFfh8Pp577jn+8pe/kJKSwgUXXHDIx2c2m7nnnnvYu3cvNpuNUaNGMXXq1CPwzhVFURRQWaEURVGUn4CmaUyfPp2JEyf+3IeiKIqi/EjUGgtFURRFURRFUQ6bCiwURVEURVEURTlsao2FoiiK8qNTs24VRVF+/dSIhaIoiqIoiqIoh00FFoqiKIqiKIqiHDYVWCiKoiiKoiiKcthUYKEoiqIoiqIoymFTgYWiKIqiKIqiKIdNBRaKoiiKoiiKohw2FVgoiqIoiqIoinLYVGChKIqiKIqiKMphU4GFoiiKoiiKoiiH7f8B38w/gqZ2jVgAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 800x650 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainloss = []\n",
    "valloss = []\n",
    "\n",
    "n_rep=10\n",
    "fig = plt.figure(figsize=(8,6.5))\n",
    "norm = matplotlib.colors.Normalize(vmin=2.0, vmax=20.0)\n",
    "cols = cm.jet(norm(np.arange(0,n_rep)),bytes=True)/256\n",
    "\n",
    "for j in range(0,n_rep):\n",
    "    epochs = 500\n",
    "    \n",
    "    fnloss = \"LatentDynamicsModels/VAELatentDynamics3var_CNN_n{}_{}epochs_Sigmoid_magnitude_expdynLin_nobias_updatedata_Li_dLdt2_c1e2_losses.npz\".format(j,epochs)\n",
    "    loss = np.load(fnloss)\n",
    "    trainloss.append(loss['trainl'])\n",
    "    valloss.append(loss['vall'])\n",
    "    \n",
    "    plt.plot(trainloss[j],label=r\"Train, ($N$ = \"+str(j)+\")\",c = tuple(cols[j]))\n",
    "    plt.plot(valloss[j],label=r\"Val., ($N$ = \"+str(j)+\")\", linestyle='dashed',c = tuple(cols[j]))\n",
    "\n",
    "plt.legend(loc='upper right',ncol=2,frameon=False)\n",
    "plt.yscale('log')\n",
    "plt.ylabel(\"MSE\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "#plt.show()\n",
    "plt.tight_layout()\n",
    "#plt.savefig(\"MSELoss_LatentDynamics_10reps.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "29c59388-0755-4799-9d0a-4756cb96e969",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import wasserstein_distance\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "aeec0576-c77a-459b-ad26-6855eb31ff29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def kl_divergence(p, q):\n",
    "    #q = q+1e-14\n",
    "    #p = p+1e-14\n",
    "    \n",
    "    q = q/(np.sum(q,keepdims=True)+1e-14)\n",
    "    p = p/(np.sum(p,keepdims=True)+1e-14)\n",
    "    \n",
    "    return np.sum(np.where(p != 0, p * np.log(p / q), 0))\n",
    "def mse(p, q):\n",
    "\n",
    "    return np.sum((p-q)**2)/len(p)\n",
    "\n",
    "def wasserstein(a,b):\n",
    "    a = a/(np.sum(a,keepdims=True)+1e-14)\n",
    "    b = b/(np.sum(b,keepdims=True)+1e-14)\n",
    "    \n",
    "    cdf_a = np.cumsum(a)\n",
    "    cdf_b = np.cumsum(b)\n",
    "\n",
    "    return wasserstein_distance(cdf_a,cdf_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e55966ea-3033-44ca-817f-0a105bca4a22",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcwasserstein(bina,binb):\n",
    "    bina = bina/(np.sum(bina,axis=1,keepdims=True)+1e-14)\n",
    "    binb = binb/(np.sum(binb,axis=1,keepdims=True)+1e-14)\n",
    "    \n",
    "    cdf_a = np.cumsum(bina,axis=1)\n",
    "    cdf_b = np.cumsum(binb,axis=1)\n",
    "    \n",
    "    dist = np.zeros(cdf_a.shape[0])\n",
    "    distkl = np.zeros(cdf_a.shape[0])\n",
    "    distmse = np.zeros(cdf_a.shape[0]) \n",
    "    for i in range(0,cdf_a.shape[0]):\n",
    "        dist[i]=wasserstein_distance(cdf_a[i,:],cdf_b[i,:])\n",
    "        distkl[i]=kl_divergence(bina[i,:],binb[i,:])\n",
    "        distmse[i]=mse(bina[i,:],binb[i,:])\n",
    "    return dist,distkl,distmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "fdfc16c6-f2d5-465f-aa01-0fbec50a3311",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model n =  0\n",
      "26214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_4479/2147665654.py:8: RuntimeWarning: divide by zero encountered in log\n",
      "  return np.sum(np.where(p != 0, p * np.log(p / q), 0))\n",
      "/tmp/ipykernel_4479/2147665654.py:8: RuntimeWarning: invalid value encountered in multiply\n",
      "  return np.sum(np.where(p != 0, p * np.log(p / q), 0))\n",
      "/tmp/ipykernel_4479/2147665654.py:8: RuntimeWarning: invalid value encountered in divide\n",
      "  return np.sum(np.where(p != 0, p * np.log(p / q), 0))\n",
      "/tmp/ipykernel_4479/3331754779.py:44: RuntimeWarning: divide by zero encountered in log\n",
      "  d = {r\"Wasserstein Dist. ($l_{1}$)\":np.log(wdistances[j,:,0]),'KL-Div.':np.log(kldistances[j,:,0]),\"MSE\": np.log(msedistances[j,:,0]),\"Realization\":realizations[j,:].astype(int)}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model n =  1\n",
      "26214\n",
      "Training model n =  2\n",
      "26214\n",
      "Training model n =  3\n",
      "26214\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_4479/2147665654.py:8: RuntimeWarning: divide by zero encountered in divide\n",
      "  return np.sum(np.where(p != 0, p * np.log(p / q), 0))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training model n =  4\n",
      "26214\n",
      "Training model n =  5\n",
      "26214\n",
      "Training model n =  6\n",
      "26214\n",
      "Training model n =  7\n",
      "26214\n",
      "Training model n =  8\n",
      "26214\n",
      "Training model n =  9\n",
      "26214\n",
      "MSE:  0.00025902686145247374 0.0005056912015350612\n",
      "KL:  0.4511654378224328 0.8742173685228962\n",
      "Wasserstein:  0.01205014139871765 0.01503374462935939\n"
     ]
    }
   ],
   "source": [
    "n_rep = 10\n",
    "n_test = len(testloader.dataset)\n",
    "\n",
    "wdistances = np.zeros((n_rep,n_test,2))\n",
    "kldistances = np.zeros((n_rep,n_test,2))\n",
    "msedistances = np.zeros((n_rep,n_test,2))\n",
    "\n",
    "realizations = np.ones((n_rep,n_test))\n",
    "\n",
    "wdistrep = np.zeros((n_rep,2))\n",
    "kldistrep = np.zeros((n_rep,2))\n",
    "msedistrep = np.zeros((n_rep,2))\n",
    "\n",
    "for j in range(0,n_rep):\n",
    "    print(\"Training model n = \",str(j))\n",
    "\n",
    "    nlatent = 3\n",
    "    sc = True\n",
    "    \n",
    "    model = VAElatentdynamics(n_bins=35,n_latent=3,n_hidden=20)\n",
    "\n",
    "    # Check if there is a gpu\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "    #print(device)\n",
    "    #print(model)\n",
    "    model = model.to(device)\n",
    "\n",
    "    mod_weights = \"LatentDynamicsModels/VAELatentDynamics3var_CNN_n{}_{}epochs_Sigmoid_magnitude_expdynLin_nobias_updatedata_Li_dLdt2_c1e2\".format(j,epochs)\n",
    "\n",
    "    model.load_state_dict(torch.load(mod_weights))\n",
    "    \n",
    "    testM,testdMdt,testrealbin0,testrealbin1,testpredbin0,testpredbin1,testpredL,testrealL,testrealL0=inference(model,testloader,device,nlatent,singlecat=sc)\n",
    "    wdistances[j,:,0],kldistances[j,:,0],msedistances[j,:,0]=calcwasserstein(testrealbin0[:,0,:],testpredbin0[:,0,:])\n",
    "    wdistances[j,:,1],kldistances[j,:,1],msedistances[j,:,1]=calcwasserstein(testrealbin0[:,1,:],testpredbin0[:,1,:])  \n",
    "    realizations[j,:]=np.ones(n_test)*j\n",
    "    \n",
    "    wdistrep[j,0] = np.mean(wdistances[j,:,0])\n",
    "    wdistrep[j,1] = np.std(wdistances[j,:,1])\n",
    "    kldistrep[j,0] = np.mean(kldistances[j,:,0])\n",
    "    kldistrep[j,1] = np.mean(kldistances[j,:,1])\n",
    "    msedistrep[j,0] = np.mean(msedistances[j,:,0])\n",
    "    msedistrep[j,1] = np.mean(msedistances[j,:,1])\n",
    "    \n",
    "    d = {r\"Wasserstein Dist. ($l_{1}$)\":np.log(wdistances[j,:,0]),'KL-Div.':np.log(kldistances[j,:,0]),\"MSE\": np.log(msedistances[j,:,0]),\"Realization\":realizations[j,:].astype(int)}\n",
    "    df = pd.DataFrame(data=d)\n",
    "    \n",
    "    if j==0:\n",
    "        latentdf = df\n",
    "    else:\n",
    "        latentdf = pd.concat([latentdf,df])\n",
    "    \n",
    "print(\"MSE: \", np.mean(msedistances[j,:,0].flatten()),np.std(msedistances[j,:,0].flatten()))\n",
    "print(\"KL: \", np.mean(kldistances[j,:,0].flatten()),np.std(kldistances[j,:,0].flatten()))\n",
    "print(\"Wasserstein: \", np.mean(wdistances[j,:,0].flatten()),np.std(wdistances[j,:,0].flatten()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c9a12868-7997-4f39-be67-d42a70990365",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(\"recmetrics/latentwasserstein\",wdistrep)\n",
    "np.save(\"recmetrics/latentkl\",kldistrep)\n",
    "np.save(\"recmetrics/latentmse\",msedistrep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d5d7695a-e5dd-4e35-aac5-da716ac0e98e",
   "metadata": {},
   "outputs": [],
   "source": [
    "latentdf.to_csv(\"recmetrics/latentdf.csv\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}