homography.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from PIL import Image\n",
    "from scipy.stats import truncnorm\n",
    "\n",
    "import cv2\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "import tqdm\n",
    "import time\n",
    "import pdb\n",
    "import argparse\n",
    "import sys\n",
    "from shapes_loader import *\n",
    "from base_model import *\n",
    "import tf_homo\n",
    "\n",
    "from homography import warp_point, homo_adapt_helper, homography_adaptation, sample_homography, invert_homography, flat2mat\n",
    "from descriptor_training import warp_pseudo_gt_pts\n",
    "\n",
    "np.set_printoptions(threshold=np.nan)\n",
    "DEVICE = 'cuda'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "shape = torch.tensor([300.,400.])\n",
    "homographies,_ = sample_homography(shape)\n",
    "\n",
    "p_hw = torch.stack(torch.meshgrid((torch.arange(37), torch.arange(50))), dim=-1).float()\n",
    "p_hw = p_hw * 8 + 8 // 2\n",
    "\n",
    "warped_p_hw, bound, mask = warp_point(invert_homography(homographies), p_hw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f7ebca74f98>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVgAAAD8CAYAAAAylrwMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAADt1JREFUeJzt3WGs1Xd9x/H3Z5TiZrusXR1BICtN2AO6bGgImmhMt0Zbu2XUJw1NZnjQBB90RjOXhWoyuwckbpm6R5rg2kg2lZGpKTHNTItNjE9sacUWqFi0NAUpzOlitwfY0u8e3D/rWb2Xe7n3fjnnwvuV3Jz///f//8//wy+nH8753/+hqSokSYvv18YdQJIuVxasJDWxYCWpiQUrSU0sWElqYsFKUpO2gk1ye5KjSY4l2dF1HkmaVOm4DzbJMuCHwHuBE8ATwN1VdWTRTyZJE6rrHexm4FhV/biqfgnsAbY0nUuSJtJVTc+7GnhxZP0E8I6Zdr46K+pNvLkpiiRdvJf5+U+r6i0LeY6ugp1Vku3AdoA38Ru8I7eOK4ok/YpH699eWOhzdF0iOAmsHVlfM4z9n6raVVWbqmrTclY0xZCk8ekq2CeA9UnWJbka2ArsazqXJE2klksEVfVqkr8AvgksAx6sqsMd55KkSdV2DbaqHgYe7np+SZp0fpNL0mXpmz85OO4I47uLQNJ4TUIBXe4sWGlCWHiXHwtWmoZlp8VgwWreLCHpwizYy4iFJ00WC7aRhSdd2S6LgrXIJE0i74OVpCYWrCQ1sWAlqYkFK0lNLFhJamLBSlITC1aSmliwktTEgpWkJhasJDWxYCWpiQUrSU0sWElqYsFKUhMLVpKaWLCS1MSClaQmFqwkNbFgJamJBStJTRb0Pz1Mchx4GTgHvFpVm5JcD/wrcCNwHLirqn6+sJiStPQsxjvYP6qqjVW1aVjfAeyvqvXA/mFdkq44HZcItgC7h+XdwJ0N55CkibfQgi3g0SRPJtk+jK2sqlPD8kvAyukOTLI9yYEkB17h7AJjSNLkWdA1WODdVXUyye8AjyT5wejGqqokNd2BVbUL2AXwm7l+2n0kaSlb0DvYqjo5PJ4Bvg5sBk4nWQUwPJ5ZaEhJWormXbBJ3pzk2vPLwPuAQ8A+YNuw2zbgoYWGlKSlaCGXCFYCX09y/nm+XFX/nuQJYG+Se4AXgLsWHlOSlp55F2xV/Rj4w2nG/xO4dSGhJOly4De5JKmJBStJTSxYSWpiwUpSEwtWkppYsJLUxIKVpCYWrCQ1sWAlqYkFK0lNLFhJamLBSlITC1aSmliwktTEgpWkJhasJDWxYCWpiQUrSU0sWElqYsFKUhMLVpKaWLCS1MSClaQmFqwkNbFgJamJBStJTSxYSWpiwUpSk1kLNsmDSc4kOTQydn2SR5I8NzxeN7LtviTHkhxNcltXcEmadHN5B/tF4PY3jO0A9lfVemD/sE6SDcBW4ObhmM8lWbZoaSVpCZm1YKvq28DP3jC8Bdg9LO8G7hwZ31NVZ6vqeeAYsHmRskrSkjLfa7Arq+rUsPwSsHJYXg28OLLfiWHsVyTZnuRAkgOvcHaeMSRpci34l1xVVUDN47hdVbWpqjYtZ8VCY0jSxJlvwZ5OsgpgeDwzjJ8E1o7st2YYk6QrznwLdh+wbVjeBjw0Mr41yYok64D1wOMLiyhJS9NVs+2Q5CvALcANSU4AnwQ+BexNcg/wAnAXQFUdTrIXOAK8CtxbVeeaskvSRJu1YKvq7hk23TrD/juBnQsJJUmXA7/JJUlNLFhJamLBSlITC1aSmliwktTEgpWkJhasJDWxYCWpiQUrSU0sWElqYsFKUhMLVpKaWLCS1MSClaQmFqwkNbFgJamJBStJTSxYSWpiwUpSEwtWkppYsJLUxIKVpCYWrCQ1sWAlqYkFK0lNLFhJamLBSlKTWQs2yYNJziQ5NDJ2f5KTSQ4OP3eMbLsvybEkR5Pc1hVckibdXN7BfhG4fZrxz1bVxuHnYYAkG4CtwM3DMZ9LsmyxwkrSUjJrwVbVt4GfzfH5tgB7qupsVT0PHAM2LyCfJC1ZC7kG++EkTw+XEK4bxlYDL47sc2IYk6QrznwL9vPATcBG4BTw6Yt9giTbkxxIcuAVzs4zhiRNrnkVbFWdrqpzVfUa8AVevwxwElg7suuaYWy659hVVZuqatNyVswnhiRNtHkVbJJVI6sfAM7fYbAP2JpkRZJ1wHrg8YVFlKSl6arZdkjyFeAW4IYkJ4BPArck2QgUcBz4EEBVHU6yFzgCvArcW1XneqJL0mSbtWCr6u5phh+4wP47gZ0LCSVJlwO/ySVJTSxYSWpiwUpSEwtWkppYsJLUxIKVpCYWrCQ1sWAlqYkFK0lNLFhJamLBSlITC1aSmliwktTEgpWkJhasJDWxYCWpiQUrSU0sWElqYsFKUhMLVpKaWLCS1MSClaQmFqwkNbFgJamJBStJTSxYSWpiwUpSEwtWkprMWrBJ1iZ5LMmRJIeTfGQYvz7JI0meGx6vGznmviTHkhxNclvnH0CSJtVc3sG+CnysqjYA7wTuTbIB2AHsr6r1wP5hnWHbVuBm4Hbgc0mWdYSXpEk2a8FW1amqempYfhl4FlgNbAF2D7vtBu4clrcAe6rqbFU9DxwDNi92cEmadBd1DTbJjcDbgO8CK6vq1LDpJWDlsLwaeHHksBPDmCRdUeZcsEmuAb4KfLSqfjG6raoKqIs5cZLtSQ4kOfAKZy/mUElaEuZUsEmWM1WuX6qqrw3Dp5OsGravAs4M4yeBtSOHrxnG/p+q2lVVm6pq03JWzDe/JE2sudxFEOAB4Nmq+szIpn3AtmF5G/DQyPjWJCuSrAPWA48vXmRJWhqumsM+7wI+CDyT5OAw9nHgU8DeJPcALwB3AVTV4SR7gSNM3YFwb1WdW/TkkjThZi3YqvoOkBk23zrDMTuBnQvIJUlLnt/kkqQmFqwkNbFgJamJBStJTSxYSWpiwUpSEwtWkppYsJLUxIKVpCYWrCQ1sWAlqYkFK0lNLFhJamLBSlITC1aSmliwktTEgpWkJhasJDWxYCWpiQUrSU0sWElqYsFKUhMLVpKaWLCS1MSClaQmFqwkNbFgJamJBStJTWYt2CRrkzyW5EiSw0k+Mozfn+RkkoPDzx0jx9yX5FiSo0lu6/wDSNKkumoO+7wKfKyqnkpyLfBkkkeGbZ+tqn8Y3TnJBmArcDPwVuDRJL9XVecWM7gkTbpZ38FW1amqempYfhl4Flh9gUO2AHuq6mxVPQ8cAzYvRlhJWkou6hpskhuBtwHfHYY+nOTpJA8muW4YWw28OHLYCaYp5CTbkxxIcuAVzl50cEmadHMu2CTXAF8FPlpVvwA+D9wEbAROAZ++mBNX1a6q2lRVm5az4mIOlaQlYU4Fm2Q5U+X6par6GkBVna6qc1X1GvAFXr8McBJYO3L4mmFMkq4oc7mLIMADwLNV9ZmR8VUju30AODQs7wO2JlmRZB2wHnh88SJL0tIwl7sI3gV8EHgmycFh7OPA3Uk2AgUcBz4EUFWHk+wFjjB1B8K93kEg6Uo0a8FW1XeATLPp4QscsxPYuYBckrTk+U0uSWpiwUpSEwtWkppYsJLUxIKVpCYWrCQ1sWAlqYkFK0lNLFhJamLBSlITC1aSmliwktRkLv+a1sS77a0b53XcN39ycPadJGmeLouCna/5FvNS4l8i0vhc0QV7JRjHXyKWujTFgtWiuxI+GYB/kWh2Fqw0T3460GwsWGkJsdSXFgtW0gVdKZd8OngfrCQ1sWAlqYkFK0lNLFhJamLBSlITC1aSmliwktTEgpWkJhasJDVJVY07A0n+A/gf4KfjzjLiBiYrD5hpriYt06TlATPNxe8Cn6iqXfN9gokoWIAkB6pq07hznDdpecBMczVpmSYtD5hprhaayUsEktTEgpWkJpNUsPO+ztFk0vKAmeZq0jJNWh4w01wtKNPEXIOVpMvNJL2DlaTLytgLNsntSY4mOZZkxxhzHE/yTJKDSQ4MY9cneSTJc8Pjdc0ZHkxyJsmhkbEZMyS5b5i3o0luu0R57k9ycping0nuuFR5hnOsTfJYkiNJDif5yDA+znmaKdNY5irJm5I8nuT7Q56/HcbHOUczZRr362lZku8l+cawvrhzVFVj+wGWAT8CbgKuBr4PbBhTluPADW8Y+3tgx7C8A/i75gzvAd4OHJotA7BhmK8VwLphHpddgjz3A381zb7teYbzrALePixfC/xwOPc452mmTGOZKyDANcPycuC7wDvHPEczZRr36+kvgS8D3xjWF3WOxv0OdjNwrKp+XFW/BPYAW8acadQWYPewvBu4s/NkVfVt4GdzzLAF2FNVZ6vqeeAYU/PZnWcm7XmGTKeq6qlh+WXgWWA1452nmTLNpDVTTfnvYXX58FOMd45myjST9kxJ1gB/AvzTG867aHM07oJdDbw4sn6CC78wOxXwaJInk2wfxlZW1alh+SVg5RhyzZRhnHP34SRPD5cQzn+EuuR5ktwIvI2pd0MTMU9vyARjmqvho+9B4AzwSFWNfY5myATjez39I/DXwGsjY4s6R+Mu2Eny7qraCLwfuDfJe0Y31tTnhLHecjEJGYDPM3VJZyNwCvj0OEIkuQb4KvDRqvrF6LZxzdM0mcY2V1V1bng9rwE2J/n9N2y/5HM0Q6axzFGSPwXOVNWTF8i74Dkad8GeBNaOrK8Zxi65qjo5PJ4Bvs7U2//TSVYBDI9nxhBtpgxjmbuqOj38h/Ia8AVe/5h0yfIkWc5UkX2pqr42DI91nqbLNAlzVVX/BTwG3M6EvJZGM41xjt4F/FmS40xdmvzjJP/CIs/RuAv2CWB9knVJrga2AvsudYgkb05y7fll4H3AoSHLtmG3bcBDlzrbBTLsA7YmWZFkHbAeeLw7zPkX3+ADTM3TJcuTJMADwLNV9ZmRTWObp5kyjWuukrwlyW8Ny78OvBf4AeOdo2kzjWuOquq+qlpTVTcy1Tvfqqo/Z7HnaLF/KzeP3+LdwdRvXX/E1L9cM44MNzH1G8LvA4fP5wB+G9gPPAc8ClzfnOMrTH1MeoWpazz3XCgD8Ilh3o4C779Eef4ZeAZ4enjRrbpUeYZzvJupj21PAweHnzvGPE8zZRrLXAF/AHxvOO8h4G9mez1fgjmaKdNYX0/DeW7h9bsIFnWO/CaXJDUZ9yUCSbpsWbCS1MSClaQmFqwkNbFgJamJBStJTSxYSWpiwUpSk/8F9sWTxLiFYjoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7ed84e1d30>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.imshow(mask[0])\n",
    "#print(warped_p_hw)\n",
    "#plt.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test warp_point method\n",
    "# I use 300 400 to check the bound and mask is working, (matrix value is not meaningful though)\n",
    "# I use 3 3 to check the returned value is the correctly warped. (values are meaningful)\n",
    "shape = [300, 400]\n",
    "# shape = [3, 3]\n",
    "a = torch.zeros([1,shape[0],shape[1],2])\n",
    "a[0,0,1,1] = 1\n",
    "a[0,0,2,1] = 2\n",
    "a[0,1,0,0] = 1\n",
    "a[0,1,1,0] = 1\n",
    "a[0,1,1,1] = 1\n",
    "a[0,1,2,0] = 1\n",
    "a[0,1,2,1] = 2\n",
    "a[0,2,0,0] = 2\n",
    "a[0,2,1,0] = 2\n",
    "a[0,2,1,1] = 1\n",
    "a[0,2,2,0] = 2\n",
    "a[0,2,2,1] = 2\n",
    "\n",
    "# sample homography\n",
    "H,patch = sample_homography(torch.Tensor(shape))\n",
    "# its inverse\n",
    "invH = invert_homography(H)\n",
    "# warp points\n",
    "warped_a, bound, mask = warp_point(invH,a) # this warp will warp points in patch to an HxW image\n",
    "print('warped_a sz:', warped_a.shape)\n",
    "print('bound sz:',bound.shape)\n",
    "print('mask sz:',mask.shape)\n",
    "# look at patch to see which is becoming new image\n",
    "print('patch corners',patch)\n",
    "plt.imshow(mask)\n",
    "# warp back\n",
    "# dewarped_a, _ = warp_point(invH, warped_a)\n",
    "print('bound nonzero',bound.nonzero())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def warp_point(homo, pts, need_mask=True):\n",
    "    \"\"\"\n",
    "    Warp batch of pts with a homography matrix H.\n",
    "    \n",
    "    INPUT: H: [[H_11,H_12,H_13,H_21,H_22,H_23,H_31,H_32,1]] as generated by sample homography\n",
    "           #patch: size of([4,2]) generated by sample homography, used for generating mask\n",
    "           pts: [B, H, W, 2] torch tensor\n",
    "           need_mask: whether a mask should be calculated\n",
    "    OUTPUT: warped_pts: [B, H, W, 2]\n",
    "            bound: [B, H, W] boolean matrix. 1 indicate this point is valid.\n",
    "            mask: [H, W] torch tensor 1-filled or 0-unfilled\n",
    "    \"\"\"\n",
    "    B = pts.shape[0] # batch_sz\n",
    "    H = pts.shape[1] # height\n",
    "    W = pts.shape[2] # width\n",
    "    pts = pts.view(B,-1,2) # B x P x 2\n",
    "    P = pts.shape[1] # pt_num\n",
    "    \n",
    "    pts = torch.cat((pts,torch.ones(B,P,1)),dim=-1)\n",
    "    pts = torch.transpose(pts,1,2) # B x 3 x P\n",
    "    matHomo = flat2mat(homo).repeat(B,1,1) # B x 3 x 3\n",
    "    \n",
    "    res = torch.bmm(matHomo,pts) # B x 3 x P\n",
    "    res = res/res[:,2,:].unsqueeze(1) # normalize by z\n",
    "\n",
    "    # check out of bound value\n",
    "    bound_1 = (res>H) + (res<0) # look at dim1\n",
    "    bound_2 = (res>W) + (res<0) # look at dim2 \n",
    "    bound_1[:,1,:] = 0 # dim2 not your business\n",
    "    bound_2[:,0,:] = 0 # dim1 not your business\n",
    "    bound = bound_1+bound_2 # combine\n",
    "    bound = 1-(bound.sum(dim=1)>=1) # invert: now 1 in bound means a point is valid\n",
    "    \n",
    "    # mask work\n",
    "    mask = None\n",
    "    if need_mask:\n",
    "        # apply homo to shape\n",
    "        mask = Image.new(\"L\", (W, H), \"white\")\n",
    "        mask = mask.transform(size=(W, H), \n",
    "                        method=Image.PERSPECTIVE, \n",
    "                        data=homo[0].numpy(), #invert_homography(homo)[0].numpy()\n",
    "                        resample=Image.NEAREST)\n",
    "    return torch.transpose(res,1,2)[:,:,:-1].view(B,H,W,2), bound.view(B,H,W), np.array(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(120, 160)\n"
     ]
    }
   ],
   "source": [
    "# parameter \n",
    "threshold = 0.2\n",
    "config = dict()\n",
    "config['threshold'] = 0.3\n",
    "config['aggregation'] = 'mean' # 'mean'\n",
    "config['num'] = 10 # how many homography adaptation to perform per image\n",
    "config['patch_ratio'] = 0.8\n",
    "\n",
    "# load in model\n",
    "magic_leap_model = SuperPointNet().to(DEVICE)\n",
    "model = torch.load('./Fri Nov  9 15:54:21 2018/e_405_a_10.9042.model').to(DEVICE)\n",
    "magic_leap_model.load_state_dict(torch.load('superpoint_v1.pth'))\n",
    "criterion = nn.Softmax(dim=1) #reduction='elementwise_sum')\n",
    "\n",
    "# load in images\n",
    "img_dir = '../test_coco/'\n",
    "imgsList = os.listdir(img_dir)\n",
    "clr_imgs = [Image.open(img_dir+img).resize((400,300),Image.ANTIALIAS) for img in imgsList]\n",
    "\n",
    "\n",
    "\n",
    "shape = torch.ones([2])\n",
    "shape[0] = 120#height \n",
    "shape[1] = 160# width\n",
    "\n",
    "#clr_plant = Image.open('../plant_data/train/high_res/vc_left_001_1501595808.23.jpg').resize((shape[1],shape[0]),Image.ANTIALIAS)\n",
    "clr_plant = Image.open('../test_coco/COCO_test2014_000000000182.jpg').resize((shape[1],shape[0]),Image.ANTIALIAS)\n",
    "# net = model.eval()\n",
    "\n",
    "# a = {}\n",
    "# with torch.no_grad():\n",
    "#     a = homography_adaptation(clr_imgs[5].convert('L'), net, config)\n",
    "#     a['prob_orig'], _ = net(torch.from_numpy(np.array(clr_imgs[0].convert('L'))).unsqueeze(0).unsqueeze(1).float().to(DEVICE))\n",
    "#     a['num'] = config['num']\n",
    "    \n",
    "# print('prob shape:',a['prob'].shape)\n",
    "# print('images shape:',a['images'].shape)\n",
    "# print('counts shape:',a['counts'].shape)\n",
    "# print('patches shape:',len(a['patches']))\n",
    "\n",
    "# show_results(a,1)\n",
    "\n",
    "#clr_img_array = np.array(clr_imgs[5].convert('L'))\n",
    "clr_img_array = np.array(clr_plant.convert('L'))\n",
    "print(clr_img_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[9.1177e-01, 1.6175e-07, 1.3909e+01],\n",
      "         [8.8879e-03, 9.1090e-01, 3.3629e+00],\n",
      "         [1.5320e-04, 2.0183e-10, 1.0000e+00]]])\n"
     ]
    }
   ],
   "source": [
    "H,pts = sample_homography(shape)\n",
    "invH = invert_homography(H)\n",
    "invH_np = invH[0].numpy()\n",
    "H_np = H.numpy()\n",
    "\n",
    "mat_homo = flat2mat(H)\n",
    "print(mat_homo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "homo_adapt_helper pts size: (101, 2)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f5f45faf588>]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAACVCAYAAABWxTFzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzsvXeU3cd15/mp+v1e6pwDgEZoAA00ACYwSGIQCZKyJVseWcEE6R3PHPvsSg7jM7MzkhzOmd3ZtTxjSx571vbasufsrhxFcizJCmNlAiIpUhRIiAFAIzS6gc7x5fgLVfvHL74GSImQKJGavjxgv/cLFW9977du3aontNZsyqZsyqZsyo+vyB91ATZlUzZlUzbltZVNoN+UTdmUTfkxl02g35RN2ZRN+TGXTaDflE3ZlE35MZdNoN+UTdmUTfkxl02g35RN2ZRN+TGX1wzohRBvF0KcE0JMCiF+87XKZ1M25Ycpm3q9KW9EEa9FHL0QwgDOA28D5oATwENa6zM/8Mw2ZVN+SLKp15vyRpXXitHfBkxqrae01hbwMPCu1yivTdmUH5Zs6vWmvCHltQL6rcBs7Pucf21TNuWNLJt6vSlvSDF/VBkLId4PvB8g3dJ688ju/bF73+1lQHt/v5dHmz7oq918hedeIYP4o9+1zN+rXK1M/yPI1fpFX/32K1+8+uWJ7zy3prXuv6ayvUqJ6zZw8w8jz035H1e01t8VKl4roJ8HRmLft/nXQtFa/yXwlwBj19+i/+wLJxDSm2IIAcovuhACtPb+So2BRgkQMRiUgBZgoAP8D5FXokEI731AoLzv/jNCaj8fjdiAECJ8T4HwAEQKgfYNjQyKIPy0QuOgg0oi/bxcAZLoRbERjqSfgdZoAULrlzUe4nu0KkH3R8XRQQKekYwVQQgRu49fFtCSEDmFiEBUa+33QZSIFAKhhV8HgdB+X+nIGAafvTb02z7oS629S35GwXMaQGkCfdaa6LngQaJr2n9ACIFSCoDD7ebl76nRXlm+q177bRPqthAbtWpTNuWHL68V0J8A9gohduENhAeBn3+5hwVgBgNaRNdCxm7Eaa5A4oG7whvMQkfA6WFuaCX8NJoT9S8jfMNwZYEiM6K1Rsjgsm8s4iAD6MAYxQBLCBHmr4MqCI1GI9Fo/9mwrFqFZQzrLvxaxRbM4xAfgHMz3Mbu6yANHT4fysvAjxDCa1d8v54Pql6JI9QP6qrx6y79Z3RQf69dAuPrGS+BiKF+UATl10GGbeqXOTRIvvEjMkZBvYRvda+YVf3AplhN8qr0+lrlS9MOoZ4KkNJrfe0prUeGQv0hUGYA7h3ajJjelCvlNQF6rbUjhPhXwJcBA/h/tdanX/EdERBJ7/9SeNc8Ro4PpADCY8ZCYXiZNaUTMfeAIeODZvN9hGoCg4B3CR/kg/KImMWJQ0cTePrAJvAYaXy24aHtxms+QIvIQGkdPScB5ZfN8GsT1jKwC0GbBAZBKS8PEVY5BN3IcvipKB9Q/XL4JYhDd8x7ItBCh0w9uCEDFi00QoqIoRsCoUAFbRRkFbRaQMDD/gz6yuusYDajhUZqjUKgQuYftYEImXzcWAd95xmr0OD+gORa9Pr7ESHwSUZETsCbGQb6GddtgOPLrveMEN7YCdLxLvr6qqK2F8J/X4dpBekGtjZS/uZZZmBkmq+J8GXdNCsN5n+66f3gXzCLC/MOsr1KVODV+jQgiRujCINnQ4LQNA6jl0OyFKShr3ysOWHvj/QHnCLCpyYCqCI9H08YV0vphyKvmY9ea/1PwD+9qpf8ARyoRMhcAraL554JCXpc+/0EhM/yQ7eA9EFho1L6CiniYBRSfR1TuGbFkNrDSSkiLQnKHBkGP0m5wfDEkhNBPn7VtF8e6ddLBqDoJxoMWiVjZdCiCVClD/EqlpXH0IOSBnlFwy4k0QH7FxojcNv4b8krmyEaQP5NqQNUCAxWMAi8PELPlP9Pbhi/2hsTfr6BuffqY4RmIjKsgUELJhlSxwa570YLZwH84OSa9PpVivT1UIoNKhgnJsKfcUX+wiZCIa9S65DM0Pw3rpPhNR39jRuCqBiiqY+ahmHMMIuAaIXljoxGdD3oTN1cqFjV0LH3ryq6mfPF343VP3Dz6lARXya5K18HAnWLFSjIO/Y5rOsGo3PajnBMB25KDdofx2EFfIsTECLtu0IDcnS4/dXD9o9sMfZqEra7DCy9jjk5fNmoJLEG8G4LfyqgEEJ6aWiQnh8jDhkEsCMQCCkI2HeYDYGPPhohGt9Pj1c+IPQdByDtSBWVpal2QfcFDDlmCGKDWvvg6j2ywUCEAxqQ2ndhxQdAAG0ihgu6CVyVD8qhjvsMOGwVgc8ktb+u4BsFP5+4+po6yjdIQAX2MmjpwG8eNwBew4XpCIKZg1efgLV6Ri3IQ4Vus3AeErjtwn6SoR6pHzDI/7DE8Fl2yNqJfQ7diJGehEDMFZDr90OkC5Fe6+h6HMDjWLshHR17P3y+icjo5j7dMDumaQyK5oRj+ufXuCn37z4xi2oeGaAoGRkoX2wGrgGhfBQIGzqWyIaihAYufCECeBmvSlOp/CRiKho+E5816Gisx7iMTwCv3ievRl4fQC8ixocQaKFCMAiAIXSl+NPx0HWifABpmj8GPnIIWGvgM/d1DS0CMPTTkv6AQACRW0cG/uGgwX0AFBBbaPWMig588AGjJFAA7YMxTcAZ+qDxfPhRx0YsSfgMd+MwDsZ2BKpR/WXziInYbVCn8F5sDUCE38IMRFhWLy8dGAcdpRsXHatWeCtwU/mfw/JIH9GJFm4NvwQm4GodMtaw7f2pigoGHN5sKsAWKaVXFW9V1nf9vPHO+RBxQBRELg7/ewgJItDZeN81w3G0BhTT4fDlkK5HrwZliB70y7MhPTY8G3s5co9670k/L+2XM9BuT9VVWDEZ5KkjAI2Nlg3SjMgbS7WxnBG1i01rQiNAOJOMWjR4L/a8wHPFaMIZuJdM00gJ3ZiBPZCx8aLDwnqBIFpFeYX9u7EfNtT4WuT1AfT41l/6bFf48Sna9//iNZYQGiGlD/5Ro8U7NfL7xZZnhd/ggJA+OPiKJtG+NfeNABoto2VHIUDG0Q0IjEeQvDfVjtiMVNLPT/msXGNshBsZjbGm8ofTNh21S8AiYkAaVD6uCGF0zQYlF0Jg6oi1xI2Fjl+JG4g4iwkaWkdtggpcB/FW8URpn4nLZiMU3hee28lP0p+9CG/Mh3UM/OwgVSx9ITDwB2Bg6CIERBBb7Ba+S+mNJjH6HQFI5JKMs/NwDQuimVMsmeD9wFWIoEl3EVd8jH0JAL65POEzeO0tRBRxFs4n42lvRDCBR9h0pH+Bm1Zv1GvhERPVTPCblp4CtRUxHQ+fU1HOOmqC6B3/UQ+cm+PI4hgTKKaQsXEAIanYmEdYh6ZINr+2MVYf6TtNEhA4T8ejUl2rOr8ugN7rMB2yeI03n5KB1dQxhu7PgTxlirWO0MimeMfId46fKuD7u3yjAWgZjx8JwF/45QFEswukCbj8QSPRKE0ExkL5i4p+HXwrIxSRZoVsSQTF39AoG3o+qH5cE6OqAzHXzFXaOAxTjD0XtlRsACvtKUVQfqVjRQ5SD8I/hNdXzdFI3ixICBlbf4gPgIhhx9vS86/5H4N2DioiAleY9P96jiZvhhH0hQ4HYNB2zUPwDSpBU/tItgHHos8BqMdcKWG/eVELMcCPt0k024qvZTWl36wAVwF7f5YoQIVljIc0xwiC1n6UXKB7Ihx3TdX26xOLGwglJHixcoSTk0DPA9T178sYOAd1DcrjkQ1xRf3EFdeicS+JDEucwsXiFcJnQ9e78AyDF78Wxy6vwGE4hNAYSjTVMwgd3tBM37O8LoAefB+6zw5C/2zoM/dQ1ECiPJ4XWwz1JJotxoAn7FDhD5bA5+99jze2ED4Si+bwy2bfpg7BnZC7eN9NfB9zYITwF9N815DUwl+4JJ5gE3OOW+vmGPdm8PbHfJwkNGmXjF+LsYdgzT9IKyhOYKS08BQiXLQiWtTzQiN95h0zoM3GluiaipjYVSPJ4wM3aE+/MhHbEU3fPa87IeNvom8qxg21Jlib8VxH1zo8fjQS8JXQnsYAPgLRKDoqhO0Yyw3XliKbfIUhCJXIb9RI1/0wWCBwd0Z9G5XTEOAG1/x/G1U8ctU0g6VXJhFzWW6oS3gthugxdhy6dkOCFTHoYJYYtmFztp7+BhnJeNn89ic0f97MMy4i2uMDcSLpj/nwlg6vBaQpaMDIhSNAq5irM071gyXfYLYUGZlrkdcH0Isgzjyy+lJEnEQYXvN5LhARdr7wXSMC4btPVKh0QoAM5m3xtHy3UKxHCKJcQkUVCiXAiLGEsKg+kMdDIAMQDFU5GKia0L8ZZxdo0Mqf8gYLuqq5I5v6MwDeDUmFhNd/5iru04gREOp1LCLD+2v4mCmD3VH+yI5PXXXgY9UghaTZi8qVc0q/XqGx85lMOOhjFYkYjwipXxwkAnd+YGR0AD5Sg5bRLE9rPGMgw35oDvF7Y4gMN/HFQCTQY18JZLwBhe/6CCyE0JFxELH+9o1GYACCxVJkzM+vg/cDwqP9sMygJLHwW3/cKqLNhpFWBGsr/liNo33MoIT1898OSVyMkcefCtk6sRlsvCkIXHt+3V9mMqc1/nPNyuF9Uz6Zioxl0xBWAQWKjJCOJRCDAm+i6utquFkQf9arCdOI7+nRXiN4OBGMm41M8FXK6wPowVMagugM4S9oBv7zwDoKz+8tA3ANaIDvphFxpfDSCZQ58ksGiOgDEYFSRq4bLTyD0uRjgHC2EXhggnBG8DtUxjRTR9E5QXmaxmasToC34ehqoBQfQBvogYzl7f0NBlcwYCNwDxMRMcYY09I4sAohw/h6Ebsf1C0eTBbG0zcN1StFExv8vl9Tb0CHIHIhFjcEeL5+8AaYF1AVb1Xt93+w71gTHzSRAXjjiBBBG+iwrwLQDTemhawouh+HraA/PRIUEI549E0zKQmvhkaGcDxF4yqmCLFyha6+mL5H/ei5ZJtms0Fafnl1uIlmo6PVT2sD4G/szStCdfF1XG94NlY46VdF+vockBgv+it4OKi433ax90PQjoZarMBxHY7aLBi6kSGIm5nw6bAvwzEQw8BrldcF0HugKXz24Vs4X8OuiCDBZ98y1imxyIwmUNqQBxALVxKAQopwkhdaVhHfjQIEG28Ewpuq+nGtoVpumP5F+BUxnSCLUOTVShkNwCvAKWQVcWOwYdU+iAjy20yFxmWDsbuCKcWy8UZe6Bq7ohwhKIsr3yNgQfGqBgYtytNjZTElD98lHETNeQaRDmAEi7j+ZqqArYZMKQQXT9yr1vL1LSGoh58DwI2AuplBeq0agEowUwxUOHSBhmnJSL1j1wN3Qei6iQGTiHcgIS7THKMCNH3XYYcH/R5EYIX5XwXEQ3LySnq6ob2a3J5E4Hu1AFtNrH1izUDYBn6LxtxX0bs6lkqsXrFSNemvT1hVCP1e/yiIEVliRi7CnKtV6FpJy+sC6CFazAkZeNRTIQP0om685wNFlFrErKcIX4wPEC0jTQjadePGh8iN0mxZPIWMwEvGvgcfdbMTJbofMOwrTH6YbaxfX7kDZagmzZPN8Frk6IvqE2lgrD4ve/BD8/2wzTcM4ysMkIoBTQREKuYcDTeGhM1zJctuXjSNGkwQGX/vlShKSqrYWTq+cfKOUxCxAdQMPW8ECfQ2CDmWIn74RMyo4gFZ0y7uwEhsAO8AkuMAH3z23o3Gh/Qd3xoQMgh7jOcdFSBwb4RlCtZG/IQDdhp7K0rH79NQI8WGhc3wLc3VU4lmyZHhCYhErDGbLEZADoLUYiC+QU3iGtlEIDfkJ/CWiMKZRPwZv7JSR5F+6Ob1sqDu4bQC0ZyxliEBu1Z5XQB9ZOE9Bi/DuvpQ7GuR9LVZBD2pva3yAoGhfeWMNX6QeDCFDTbkhANACoS/61bELWrI+nUz0IXMntC6ep6mZg1pArFwbhcgVZPdjumjCNMMwC06+CtgCs3K6YGb3pBSc7teKZH7pClvfLYS1CcWChaX6Ngh70bgxtIE/RX1VbCm4OLVP7J/zUM4ipgIjobw2l7pyGAHzeB3czjQ8Ps1vu8iWGrw1nRizOwNIkLE3FiROjYDbnAPCFgoIggIiJ4JEmxyYUY2GIhtiost8Da/H2O2MfS70gDEDE4A3lew8nAAev/FXZbxYRO8FAtj8ZK9GmuKZUSkz0FdruaHj1yNND27UQQemdQbL4Z/RDjLjs8uA6wO0gzX9Pz6BAYgwrLYw4HHINjfEhur17rg9LoAevB2A2qtwu3fnt5qf/FPBxcgeCboKKGDZREf1KOGCFhitOARLX5KIUIDGZ5QiYimxwE4E3/Gk8APHI/uCe9dYXVFaPKvun07fl0H6u+zAx1T0lB7fEgNlS0yEHF5+RlCtIp/RWkCwI2xidCx5RvEkB8Ggz00Tprs7MdIt99Ka/eRsMjV3HFqpW/Tvf3DIWUKTZOv+OHhbD4gqeAsBHRzxMxGyqVjsc6BwSaGBWEjvrGA3giYXzQUYv/3jWTIWALw9v3xQcX9GZ5HGnT4XNi94SyheV2o2dd/JUDGkd7TveZd4HH1uSokvQwp2jjTDMbzhmEYzuriGXhVjZer+Z2XA/CN5d0oYVvG8cV/WG98MwbUTfnFHgti7kNzEPZPMIveEBod4pCXm9owa3818vrZNBiCT8DihM/04hrvxeypQBmF8AdFAD7C34jhK6/0x7qfvghW04kp49XAGh0uHgXg44liQ6xLCFLe4qW/WOgPuMj4+M9dVeMiptU8EBVaKBDKn0p7n8MNVH69NbGpcjxZHQ3o8FpgHIPyhv9ccjO/Rz3/dYR2w3+N3NfJzX4UQygMKTGlxBTeP0P6/4RESokhDVo63sTSxINU898AIajlj7M08QDp9ltAeW0XbGgSWvmzKYV2XQ+olYt2HbyVEJfi7Eex8seQ0jMoUiiswtdZOfVTXlml9vpDK2qFxyjOf9QfjCoE9yuO0HgDSHDGjcCL/DK0B9ZSqFBXpBDRP4KB7E13JMFeBh3OggM9hIClQrQW4xOXkAT4T8XIRDTGdJjv1VDnCpqjo7qIDf81vaev7KeYLUNckVazxgfpv4x5eUXZWC4Dz7USHFcSRTF5M+igvYMxHg8/vSJtvfFWNGM3RCye3geAZkMZ1fSq0XivQl43jF74/prIp+exEhFn+gRK6SuuH/fugXnwbkw1fDoQdw1AAN5XcXUEoB7XruBPU9oRwDfJhk4VfhmkbxwiMxOlG5vN+X+Vf4iX95zSwXkmIsjC29avQccNl9b+DoPIny+UDsMPDBGeihMe3RCVxKC1400snHmALQceJdN9hHLuGEsTD9Gz+5Pky4qGXcdAYzVqOI5LMpHASAiU7aBkAq00pryeRO8fM/fS+2gf+gCVlf9K776/x+w4ghLe8QSuApTASARMHAzD83HajvfZqXv1MFK3sXT6KO0jnyDTeYR66TilmX9J+7bfYnXiIXr2Pkrb4BHq2WNkzz/EwPijmIZEmB6HdR1vI5shXz985nsRI2B46DBkMvKh6yZdhsgfH+zxaO7bOArFFwQ3xuZ7uhc8FY4l0cz4ozR18OR3r9AGIAz0NciriYk3fdOhVyN89xWyuyqP2vAtfsx1lJNuLlNs3Pv2kNzMR0m130Jr971hG1Zyx6iXTtC1/cNEvXH1vOM+9qvZhfhO/OZE4ufpaK6+KeW7y+sC6IUA5TpI0wwgKpyOApGyx5Q0UDPvug+YIUZHXmep/TC+wGJuWKEMOzUcITq8GHaGiD8fMXgvi0hx4n0Qdo7QZGc+RqbtVjLdR8JdorXsMRqlE3Tv+BD4z6Tbb6VeOkGm7RZauo9Qyx2jVjpBpv0W6qVn6Rn5YBSdFIJ1UIEo2DModzD/cADL9grlui7VSgXLaWAAxVyW3NIlGtUiduk9WPWfoVB5K52tj3Nx6u3kjj+CkJ+iYVcRVgW7XsOybTLJFCnTxHLqGEbSA2zpYjVq7NzfxYj6TyxMH+Dksb9hcPtvY9s7qBS34Nh1tDZo6VqitX2d9cJ9pNt7wa7SqJeRiRak8A6MsOw6Lel3MFL/OVZXrqdv4EXWSr9KorKXpPjX2Kf/GfMTP0OSf6Jm/h/UptpI6g+ijHHq9nUk0204ykW6z9LXx+D3qo8/etHNehzX0ZBN+Bom4x+jcRIHkuZ1qyiyZmO6V7gWw5DMOIzF+Gbs8Y26F00MRHj3aoy9mUB56QcupTCfjWlulGAoxjjaxnugyc/+Pqm2W8h0HQkNTC1/jEbpOXq3fyhG7JrJmAYy7beyOPEgw+OP0NJ9hGruGEsTRxkafzgKUIiTv2ZqHrKa/OzHSLXfSqbr3jCP7IUPoLWmb+9fEISjVgtfxy4/S/vWD0X1v1Y6z+sE6F3HQpT/CNe8Fdl6txdZIzR2+ThO9QQtgx8KgThc7KO5QaOBEQ2E8uJHSbbeRrrr7pA1N/KPYVe8BiwtfIxk2y1howsB9cIxrNKzdI58+Kqs/wrRsQ0esYuB8RFAuv1WFs8cZXj8UVp67vHZ8lGGDzzqFVVp0m03s3zmKN3bf4OliQfp3f6brM/8Hj3bf4vFiYfYcuBRDGniAFJBw3JwHBetNLZVw7EtGpZFrZjHqpdxrDL5tSWcegXHcakVV2hU8hjKxanmse0qjtWgVi2g/fdNrbEPtzB6/ReZOzXM6ovT2Pqit9AtBQjJrgOrFLNtlNe6PP7nOmR6C3QN1Fk+v4WO7ixD22dYmNhG/+h5itMO65Ow747PcvFbe3DXu0j1ZNlx4xSTT41SWPhHclrh2DaWo7xjpQVYXhwraTOJuqGF3YefYfK5XqZe+iLoL+FqzeiNSfYd/iQTz/Vx4dRf05r+B/q2Vhm/9Y85/c39rK310juY5aY3T1CrUf3+tPSHJ0Jqf81CRjooIrxoZuxxsqL9dQ8RPg/xvzpGaCKCdEX+wTpVeC/yUV+dN8evBuMzeC9Y22l+yosois1K/Jl6UL/46a0RXgY72/FjHKJZQRxgo3mGiI56RtDSfhuLE0cZGn+Etu4jlHPHWZp4iP59D1NtuDiOi9Aax26glMY0DaT0vI5a3kbHjk8wf/oBMr2/SD37Cfr3/T3Jznu8TdlCeN5JLTzvhI76S7k+mXUgkbmF1TMP0r37b0l33kO9cJzKyiMgBLW+B0l1HqFRPEb23EP07XsYQ4ownkPrKOjg1co1A70QYgT4a2DQr89faq3/LyHEfwD+F2DVf/S3/TO8X1aWFy/x3HOL7B16gLadn8SpPosUCaorv0fnrkcQAuzyY9jlZ2kb/nBQgChEUgRKHCiu1+nJtlvJXXiAnr2PkO68h0bhGNkLD9I39ihCQKrtVtbOHSXT+27a+h8EAasTRxkYf4RG/jHqpRN0b/9wE4ZfGd/exJ1i+YvwPIx66QRdW3+DhdM/R+fw+yku/1d6Rn6DRvEZ2rvvxpAGqZ77MQ48yvzpB0h1/SQrFz9EqvMoK1MfQaU/wosnK7iNT1Evr6Er61j5RQw0dqNCrZRDKYVhGqh6iYShsWwLx7a9xWzTQAgDIaBStzCkpCVp4jguna0ZqoZB3XQZ2FpmZCzH7JntDO9dpLjWw/xsOyJh4rgujqvIrndw6PZznH5yD9nlbjp6Cxy8a4qLzx6ie6jK6G3TTD0zTnG5jdW5Fg7cNcX5bx/g8vOHGX3zSS6e6WF0PMtzx3dQXGoFaZA0DBwEjnIxDROFwtWahJS09hXZNp5n6vlBth9co7DWw9pCht6hCjvHC0x+Z4DdB9fJL7ZRWXPJXoSXilu58cgZLp3pYceBLM99ZZhKZa70o9Dta5Hq0u+S7ngLsuVeDzAk2OVjONVnaRn80JUgHmOi4ezWv+6RnVtJdR4JX7CKj2EFZGf+YyTbbyHt3xdCeGSnfILO7b8RwezV8MVH5QhYo3NWAfIzHyXVcSutnUdAgBaaWvaYNzvd/iFyM79P2p+tpttvprX7Xmq5x6iXno3NYj/kpSyCSKTQqhFBuPfdW9kBx1/yCWavjmuRXbhMJV9H27+G9fy7qFhHaE0eZzX7Lzh16nGUcwxHOWBXses1HNelJZXGkL6rVJgYUtPTP8Kg+wfk1u5gauJJuvr/EMUebHsM13EAg1TLFMnkArbxEFJoLKuOYaYQ2sA7avtXsCd+jmr9HlrSx7GS/yepdIblM+/DNX4W0/1HzN4/JrfwdYr5HDL1JjTS+xGe+lM8+CA8/PCr06nvh9E7wL/TWp8UQrQDzwkhvurf+yOt9R98rwnZtsv//cf/wK/98oOMyYcw295BLfe3tG75KIm2u7FKj1GYfoh057tplB4j3XFvOPVslB7DrpygYzhg4F7nF30F79nzMNkLR2kb/AClxT+hpf8o6a57EAIyXfcysP8Rls+8m+rq3wEmwwc/g4tiZeIhBscfaXKoBQoVLHRGu1v9+yJiGKFzD02m7WYWJx4i2Xofubn/ROfgL5Cb/X369z5CqVijmF9n/tIFCovnyRgH6HP+jkpxGHiYmbM7WZx4GKEclOugtUvCNGhJpuloSZOQkEKTrVZZLlRIJdNIKRBCkTJTFBoWCSW9c2eERsqk585pKAwjgVO3UK6irXuN0VumeP74TsrZftaW2zn4lnPUnD3kVjtIZtpIoVmetah9fRu33jfJ0tQWhkcXuPTcdSxMJ9h1aIGzT4xSXMnQaNhUsm3UrF0MbC2wOrMF50wv44eXmXhugMJ8O2gXW9k0tAxNY6Ha8MovBZ2DBW68f56nvjjM8mya6akkd7x9iolnuzhwa57vfG2E9YUW1uZbOHzfLM9+xWV+JsVK0aS1r5v9t61y9kQv56ZbfmS6fS1y8jsLHBz5OTp2/jec2rMIaVJb/n06dj3sk55jOJVnaR36UOgaaQb8iH8k224lP3mU7j0xsjP5ID17H0EAyfZbWD/3IJned9Pa55GdtbNH6R9/hHr+MSzfB/1yEkWmBHlH+yns2kVyM/+RoQOfJtNxN/XScRZPv5e2/qMINJn2m1maeJDukd/w1oNGfpPszO/ROfxBFs48SP/oX1Epl/yFeo1l2ShX4dgNHLuBZTvUSnnsRpnqC+CrAAAgAElEQVR6tUAlv45jNahXCzTKWYRjh7PXcm4Jx6rj2Dbjh9OM3vh5Lr00yMLpb+EoHa4DbjuwQrnRTm6li4qUaK1o683R0lejlm+je/w8M6e3MrznGVbO5FmY1+x9y9eYemmc6no36Z519rzpHJPPjJNf/S+4rotlO/4xLgJXgyEFuw52svPQ55l6aSvzU/+ENJKMjPWxfewTXDq/l7nZLzE4WGTXvj/i4oWfpFDcRkfnArv3fomzZ1+9Tokf1PZwIcRngT8F7gDKr2YwtHa06JvuHKc1IfjlX9lJd/pTtPb/AtXcF2nt/xUqq39Ox85PIgQUph+ie/Rh0h1HsErfIHvxAU+JO3xG4hWGevHrZC88yMC+R7FKx8jO/A5CtjAw/llauu7zd7YCQlOY+d/JXvbud279d5SW/pwtBx4l0XkPwaKw0kGop5e+QMRi2L2cdRBJokEaRvjLSJaGtUt/SO7yB3H1ASRnqNQfYOXSbiqFZSr5ZexKntauZQ7dMY1VS9LaVSU/P0T7wDqzJw95LLyrRGVujEwmhdCuF/KoFFJCtV7FHJymlGsnv5RBCYkpBcmeHG3dZV76dg+O1iSEwJCCar1BqaHpbUmQlJrdN2WxSp0szrViNWyK5Rqdw2VGdrhceK4bDEkqncR1NGnTZPSGOfYeXubyqS0sn9+L62qUckG7SOExFykNlHIpNRz6hiscuus8s2f7Gdm/ysmv7mTyrIESkK1a3HZHkUahg+JSK7ajsZTmlnsXUBomv72TSq2OVpDpyTF+W4HJ53tYnU3Rmk5hCMHASI3egSqXTg3Ru7XCDUcuMT3Rw87xLF/7/CB/8OcLz2mtb/lh67a4hh8Hv+89b+a2w+287c4TZLrfST37d7Rs+Sitg/8rVukYxUse6Un3HCXVcYTAX94oHcOunKB9+MMIASWf7GggN3mU1sEPUF78E1r6jtKz+y8IjkVo5B9jZeI9ePbNZODgZwDN6tkHGRh/2HNtXs3FQ8Cw/YXjmBtVANXcMRZOvxe0prX/lymvfhwhBMMH/oFMx924jkNh5UvkLv/PiNSdqNrncTiCVCfI5n+JankEq5pH2RWkYyOsCkI7WNUSjUYDV2uw6xiGwnFslONF5Ulpeu1hORhSkDINlDCoNhza+/KM336ehckBtuxZYerEIZZm016QgBC09+e44a4LnH5yjNxyOx39Ba5/6yTz57azbf8sF7+1n9JqJ629a+x5yyQXnhknkUix8/DzTJ3pYdf4Os9/YyeF5U5MaaAcm0bDxjBNlFYoDX3DZW66f4a5s72M7F/nxW/sRCnFjUdmuDzRy/bxdU4+NkJlrZueoRKH7p72ru9f5zvHRvitj11q6gf9PZza9wMBeiHETuBx4BDwb4FfBArAs3jMKPdK76db0/q62/Zx3YEq7/npaWaXb2PfrjNkut5BI/8w6b4PMrTvY7g2WJVjrJ57gNaBX6ay8nF69jxKS8eRKP5UBuFlCqv2OAunfhatGv6CUoItBz9LsuueMOypkvs6K+ce5MTpIW4aO48hbYrOz7F9/D/TOzyM0F44pykNkoAN2MrxFkNF4MDzQz2lEXKbatUiv7rI3LkTVFe/RN/A35Ff6aVv6zyrl3rpGipw7qlRark+pDToHK6w46aXWLmwk6GxKYLfC5w7O8LW/TMgJEsv3oRZ24pl13FdB0cplK1ImAY1u0GmN8/I4bOce3onlWwf7YNV9t5yholv7aGw3k1bJoV2NY7lYNk2ju/DbEtlcGybRCZN0khgWQ2vnnUL27KR0sRIS+rVGqY06B0sse+OCyyc7WV4/xqnju3EKg+RSiSwbIuUmUBpTaNh4boOLQNlDr11krNP7ia/3EnnYIHxOy+yONXB/HQfy9MphndWOXzfJS6e7CGRSlDOtXHgrinOPj5KbjGDRoHwXFCu463rWC60tyZxLQthCmzHoX+4wYF7L/HCYzuYv5Sgf3uDm++d5X0PuOfLZb3vh63b1wL0t91/A5m0yc+/z2RsxzOku3+eRukrtPT9MtW1jzeRnq6A9BSPk5s6SpdPegR4vt7Jo/TseRi7fJzC3Ed8svM5z1UTC+3Nz/xv5GY+4pOdf0tx6eMMjT9CuutI6I6J1geijWwRwigf5P17fq1L+cdYOPUutKqCSNM68HEc9wDVYo5yYZXs0iwtqU8xuOVZquUOWtqKzJ/bwfLZ7bT15mjrKrE2vZ2kaZBOJEia3jlMyaELLM4nKK/14oUgC9r6i2R6ysxMbMXVOtyPoFyXpCFp7c1x8K6LTH57nNlpk94tNa6/a5KTx0fJr7ZjmilMwyDdscBNd19i/sIg28ZWuPjMAdKdBYprGUrL7YCgbinaBor0b6mzPL2X3p2n2Xd4iXPPDTB9chhHubgKdt+4RmElw/yMN9Pu31rhLe+YZfZ8Oyce66d/pM5dPzUPQnDiS1vJLbXTt6XCTffPceLLwyzMprnuTVnGb8sycaKXbz/dyyc+c75JX74XoP++F2OFEG3Ap4B/o7UuCiH+HPgdXy9+B/jPwC9d5b33A+8HMBImW/rXeO9PL/PJz23nzPkcd94iefc7HmZ6aYzt7sd5IbuV7uF34rrDJNr/OaWFj9C57d+Tars73LAj/a16Ai8O/vLlSYRdwTRcnju1m3xhF/eJ9zI4/igt7fdgV59g+exRPv31g7iVAtft0mjDIKU+wz/+dZ5b7/pNDt9+N1IIioU8l6bPMrpjjKHuHuqAg8aQHm93gXy+zNKFk+RnzpKfeYn80iRWZZ0t+5eZX+1ny/5F5k5vY3DPEvNnt9HeZ1HNSRrKIdORZ/HFGzBbs5z/1gGUctl3xzm6h/IIISkuDmEVesnVcxSKFSxXYaCp2xaZVIZqpYK7pFktbOPGu6dZnqoyvHuF5x/bRn7FJJO2KFp1pCFJmyaJBLQYJqYJrt1AaIdGxcI2k7jaxTQStKRMLNNAGwlaUwlU3aZ9oMTYHRc48+QYtbUO8qtdHDpykRce0+SzA0gpqFRzGGYCIU1cNN1DdU59cw+L8xmsaoGqlYGn99G/bZlb7pvizJOjzE4aTJzo4vq7Vlma7mH7oWWe/eoW8osJbKeOEJpEwsQwTRISpBS0taQoloogBE7FBiHY1lPgO8d3sDLfihY2K4vtPP3VETKZS6/af/OD0O1rkVKxwe4dZbb2X+bkxEGu3/d5ku1vo7L0EdL9H6Kj7160K0jtfYTVC0dxAtKz++FwZquBdOcRevc8zNqF96JVA0QajYl23TCSRgCV9a+Sn/8zCuoo7frT5Gc/Ql3+AnV7P2nthru0TSGRgKM18bOKPHCXIDSuq6lXq9jVEuXCKsXVk0jX8Rcjbc4+/g8Ultux6xUcq0Zb9wrbbjlNfqmDzsEixZVuBnYugJ1gcOwyuTO30NPe6e2gVS6O8n59zi53cuCuU1z8dpLsUoaOwQp733SeM0/vxXbs8IdEtFJUGxaZRILhnjITT+6hmu+gJa3JLRg885URuvoLrMykcaSDNAWVcgfz5wYYvXGBqeeHWFvIYC53ACANB0MamAmNLvcy/ZJN99ACuw6sMfX8MLsOrpJKOUxOtDF1MYWcNviJd8/Q+VwfWkCmwwJgcbqXhJkgO5dg8kwrjoK56QwCm9npNOorI/QNVUkmkuy+rsD5k/2MHsoyPZ26Jp36vhi9ECIBfAH4stb6D69yfyfwBa31oVdKJ9Oa1r/y653kK108+4LB/t1V/sX75vjaN3swpaBQHuJnf+IMnz9+E1I7/LP7zzA1fx3jo5OMXP9pzMw9SFNgWzbgbat2XYsnv3Abw91nefHsLg6NXeLrT97M2P6buf2OrXRs/02q8x/j6efXOfZPj/Lgu+b4xtM3g9nCobECg70TpNo/ypatNRrmQX73Dz/Di099mbfefT8/884b6GpbYtvYfyC7dJns9GkKq3OsXTxJZfkC2rFBSsxUEkOmSPess/2ml7jw9D4q61109BcZfdNZLp8Yp7TaheM4JJImEoFpetswbOUyOHaJwX2XmZ8YYe70NuqWA2haW9tQro2jNPWGhSG92UTCNEBoRg7MsWX/DItntzL9whZcx8U0JI4G5ViYCZNEIkkiYVKv18nny1QdB8fVtKSSZFIJtOud4GNrjWmYpEyDVMJkaGyB/FoGpzSM5dokE0lautZp6cwze34HjmNjCnCUSzKdoVar4toaR2kyLRlMQ4BWKFdhCujoL3DgrkmWJwcZ2rNMdqmTwZ3rXHpxmOnnh0gmkzRc19tPoEEpjdIuygVXu96vWSUNktrAcW0sW2FrjVYuUghsPEP6iU+df1Wumx+Ubl8Lo3/He7bwq7+4zKNf2MG56QxvObzMu35ijcvL+9naP0c1+RF6ht+JrVyM8p+gi39K+9bfpnPr74RnUkg/dKVReIzFMz+NFBYvnBunXN3D7Tc9wcD+h2ntug+rfJz50w9w/Lm3Ui8XuffNT2BIjdKSl87/LDe+5d8yfsOtuFqRz2exG3WG+oYwk0nvgD80roZyLk927jzFxSnyi5PUCitI8yxb930DDSxNDjO0ewHQnPvmfsrrXbQPFNj7pvOsTe2ib3Sa7FwfA6OLFFe66BjIs3Z+jPzMDhoNG9uxvRms6yCFge3YtPblGb/zMnPnexjZl2XiqT2sLbZgGpJEwkAI70gVx1UkTROttKdHholpJnAcB43AdVxcJUikTOrVKp0DRQ7cOcni+X6Gx1Y5dXwnxdUuUqkUWnsESyNwHJfWwRIH77zAqSdGWZ9vpXdLhevumQQteParO1mfb2H3dcvsf8sKS1M99G4tcOr4TnILrWhchDSQwkC5GuU6KASGKUE5dA6WuOG+eV44toPFmRS9W2vcfP8sv/XbLs8/H+nLa8rohUcJ/h9gIj4QhBDDWutF/+u7gVPfLa3OTIL6/B60gr29Fru3rvPpz+1kZraXkmWj0KyuD3PL9ec5fKjGp794kImLJrfdcD0/I95L69a/oF44wcjoO2jpPoIBfOfkX7G19zzPPt/CsSc7OXfxAO99x0myjbeylH8rPdscWrd8kOP/5f3s2CZ55DO7yVY6qFWqLCwfpK8rw4GxTzK0/bdYu/DPGVF9jN44RqvxbZLlv2f65F1c+tqv0yisUCvnsF0bw0iSSqZoSIN0IoXjWlj1Ot0deS6d2I9d6sdIKPIr7Uw/s5+2vjKltU4yKQPTkKBcbMdBJkw6+nP07Jxn+sUhto4tsL6QQRT7MGQCaXhAmZAS3ZLxwsH8GU33QJGBXYvMnNrC0O4lLl8wyC22YiYNeru7Ua6J6zq4gHYUjhLsublIbq3FMzqWheNotu5ySLblmHiui0x7BqvRoFiqsPpcOz2t7Th2CW1KDDTFtQ6Ky620JgUymcZFUG80sCtlTGGAcnGVJmNKEkkTx3FQAlzHJrfSzuKFQXZcN8/SZDc92wrMnNrClrEVcisd5JdMzw+sQEhvp6eUJkp6RxNrx/U2g0mBrSTpliQ0LCp1BxtwhIP5KsnMD1K3r0XG9zj8/ae3M7vcwfbhLPffmeOzXxnANLI8XtzBe97+Qf7ms39DvVbmwZ+Z4sLMDRxw/xgtbiQhp0i130qi5S5wBeW1h3FdxexSJ3u3T/KlY2lebHsXdw4+RVvv/dQL3+L03APMTR/nvT91kc99ZR+trT2M78lyaO/nEeUaTuHfcDk3wp/96e/iVHK8650H2THi0D34r8jNnKOwMsf69AtUVqZxGlU0Dkoptl8/CWjOP7WP4konpZUO9r7lLAM71qnnemnrKnPpxDhtPWXmTh6gtNqFkXDp277C2swANavBaq4I0kAKgesqbEd5a2GAs9rN4sUao9cvMD+xlfJKO1LZSMBWGq0dkmYC0zSxGnUqdQtXC8+Vk0ximhKpve2MSkiErekdKjJ2+ySnnthDPddLab2b6+45z0uPj1JY7fE6SFkgDYSUtPWUeeEbo6yvdKK1TXalk9OPj9G/Y42b77/M3Nketu5bZ2Gqm627s1x8foC1hRZcpf1fc9NIqRBCo4RAGBLLcXBtly09VZ792lZWlzIorViab+XJL29l//6ZJqD/XuT7cd3cAfwC8JIQIsj2t4GHhBA34s0eLwEf+G4JGQYM9ySRhoFUGZz8QXYkJaNjBsWqRaFiUW5k0LVZ/vuXt7E0nyEFPP+ig5m4ic6ujzC/1MK77vszzs/9T4wf/gC17KMktebE853MLxfIVzOUi33s2vXXTF1IU617eV9//Vt4/L/PMb6znwNbMqRTBrWVaZJOF/mXqnxr+VNk2m/m7e94guqipGXoEtnTN1JfEVjWeZQw0UYS0zC9H/BQymMRjouWBg3XYubMMLajEFRJJRI4SpFdamNtrgUMmwYuwhCgNIaUZDrW2XrTJJPP7CO/1k6t2Mv4nee4/J0UyzMZ8uUKWmkyiQRGMonULqaUGO1Ztt88xZmn9rI4k2Ru2uCWt80z8dRuKtkuGpaNkTCp1mxqlby3r1YACyZvets0E0/tZf6ySc9wmX23z3H6iV0M9HZjSoP1WgVXCrrbWtHKwXEaCCVQwkXIBIY0SEuwHButwRSaZCpJe0uSQq2G64KyGySTEoGN5R9A1zNQYHjvMktTvQzuXmfi6UFmJnpZmM9w+O6LvHB8J6W1LlA2FcvBMEyEVijtoqXE0S7SsjBNA0NrrEYFpTRGUqC0wLFcLNf5ken2tYhY30uPgky3YnS3wxe+sJOFhV6qjqLhuPxVcSs3HZrihgNlPve1w0xOpTizYy/ve+cvYbR/ADH7XgZ2/xXSMKll/xuugi8/1kE6s4X3vfMUkws3sJC9gz67jtH1qzz19L9mdLDBI5/dzeJyN0IKLs3tZ+tQJ4evm8IUR8k2fp22tbPs3llnIPUlJh+/C1H8MNXiGrZr+wvwXjiaIcCyXeqlFNPfPkg920EqZVDJ9jD59H7ae6tICfmpEUzTIJ/txEHTPpCjcyDrk5s1Vqb3YiaSGEJ4fngkwkhhu168e/9whS17Vlg8t52BXQssXk5Smm/BNiRtba2gvagZpWFwbInVpRTZpXaQJrZl09lfo3ugzrmT3UjDxLUs+nbkOXlsO41sB0LY5FY6OPfMProHSzQK3pmTWmewHBvlukx9pxdbQVtbgkQmjeu6FFY6yS+1Y9XnGb1xgaWLPfRvLXL5pS2M7F+htNpFbrkD19/1rpT305gY4KLRUpJqTTE1sQWlNJZt4yqNIzTl2RQPf/oadOr18KMMQ/2t+l++7xCuUqAkhukpTUIIhJYYUoAhkEJSr3v+N9cFJUxs16Fcc3CEZKh/jXt+cpqzEwOMH1jlq1/cwdR0O46jQGhSSQMhbK674Q4SUlOamWDvvjGs7BLSFAjl0HBdQHrb9E2JcBoo5dI7Ns3A3hmWzo0wd3o7yYSJIQQNy/KiYKSB1BpXKVwFdUdhB2e4hItUnhGouw6uY6Olpu4qWtNJktLEbthorRnav0Qt10a10IfwmUN79xrpjjxL50coVGtordl7/RqNYgerMyk0gh3Xr2KKBImkweWJQWzLpaO/gNmeY+qFPmzHxVG2d3yCEpiGgatcjIRkeIfFzffOsXRxgOHdq5x6YgdLlxII0yRtpjDTSZRjkU74UdNaY7sOhpRYjrcgrUXCO5fGMEFBJVdEC2jp6sQ0TQq5PGDTlklju5ruLTUvzv6pPaS7SriOZud1K7z0jVHW59N0DRXpGbSYfKEHy/bAumo3EBKSCYNMIo2tHBq2hWEmqbt1GpbCbijSaRPDTOJYFiD5/z49dc1RN9+PXIvr5t//2u3+vgcviFtpkFJi2Ypy3aHqaMYOzLKW62RmrgPHBcuBvWM2A0NV5pdb+el7X6JcGaC7c5WHPzfGiRNVDNNg32iZ7dsbaPEgN73lbbh2g6nzZ5mZOMnIYC+4NVrTCZzSGgYOStXZNioZGHuSysJ2Wocvs3b6RsqrnVQbjv/rVN75Rcr1dF8YElcrLMvyjK2rkIBpGt4Yd71ICCGU9zvPWtM5UGL3mye58O295Nc66R0sMXrLOc49tYf5ywl2HFyhtNZCOduDFNAzWGL/XZOsXOri4sk9pDtXuOGeWU4/sYtKrhspDQzToFKt0ajX6RqqcPN9c5x+YpTiWhfpzlUO3zvLqSd2UVjuIGEmqdVqlBsWbe0Zkghsy8JMSBJmEikNMgkTpTS2BsdxMAFXOTQcjWmatGTS2I6F7bq09xU4cOcU2fkOBkeznH1mmLlzg3QNlbnh7kucenyU7GIrjnK9ftYKpT3yo7TCNAyPLGpF3XFpKI3larTr8refnW7Slx/KYuwPQrTWVBsW2vWUet/YCuV8K9nlDqQwcZTL4HCJrt4qpiEprLeRX+tC4CCTgv2767R2lVme3kV2zuGmw5eYPbeDkfRuRg9J7+wQfxEnYRo49WkMAVu3dFJduQRGAsdSmFKSEgnPWmuHRs1FCUFb7zrd2xeYO+O5Q4prXVTXu0E7ICBbLnv+cyXpaMugXc+NkpQG9bqNo2ws1yGZMJFS0NA2wtAoV5KQYGqBslwypoFCsXJ+kISRJJkQ5CtVKnWL3LqJQR+IKm2pDAJNo9DJ2O0XUPZu1hZbKCyluO7ILGe/OYrUAseyWJ1NUan1sOv6ZXJraRrZLtqSCfLVBkMjDboG68xPbEGXJSsXLbYfXOTSiwPkF1vRpoM0JMpwqVtVEkLQqDu4rgtS42IgXY2tXG8zpnSRQpI2FS4S0ZLCdbypqVY2wlC4LtQdFwdIdeR56fgI2eUk1uVuEsKgnEvR0VdidT7F+nI7uVVwtOWF0hmCRDpJoWFRtRyqTpFSQ2Bpl5akRggDEikwHSxbkXZcABLGG+usm1KjgcBbj9h7YJlCro3CaicSSVtasGOoSGebQWGmndFOf/elFqhsksVVE6UFF093c+DGy5x+YQtiNcHhkS5vU12tjeykZtv2ZWafegRrfZ6hwX76++tIFtDSRdVdXMPjKDKZIHfZwkgMMjB2gaWz21i4lEDIOtp1SaYS3u5VDUiJ0hrLdtGu680YtXfWkBQa5brYro3SLpZWpBImKZHAsV2SHQVeenwHjVI3QkqySx3Un9xJZ1+FxEI/hbUWbjoyw8STJrnFVnq2eXvWigtDtGUy1EqDTHwzRUt3gVRnkfWlFPNzSe+8Jy1otWwWp9s4dNcUc+d62LYvx8RTu8kupHCcOkppUukUiZRBOuHtDkgaCTQKrR0cx6bsemGbQpooV1Gu1jAzKVKZNJVSBduqkkwkaB8ocfDOS5x7eg+ZrhLnn93C7huXKedbWJ9v4YXjO+jsK7J42cRVCks5SAkJ08AQJhpv5tZwLCzbW4cyzAQGLuqNfNYNgBQSYXpnkGfXMtx+ZJrvPDlKfqWLgS0Vrr/jIi9+cw8JQ3Dd7ec4/fQY+ZV2OvqL7L75Aue/tY+W9hUGts+zeHYHw7sWsNZ6qKz3YmvvB0sEUPHjb73fYK2DliQTikTCwHZcXK0oN2pIDclkgnT3OjtvPs/5Z/ZRW++hvN7D7tsmmHxmH/OXTO/kRsOkNZkiYZokEwZFq4ZwwbFraENi49LWksYU0vOPa4OkNMm0JkglTMrVBmW7QcPW1B0XoTSJhEvaTdOaSNKaMP04fu8n2UwJritYm0thPrOXA3dPsjY1SO/oMmef3E0t10m1XEIgSCcEpkzhFDu44+2zXPxWO4WlDNtGyxy4c4bL395NZ8Yg3VdgcPcqF5/vY2TfOvOXk9TWujABaWuUUlRxEco/v1MYGHihazXbRguJbdURSpPJpJCpFFJIjFSC1UIebI0wJelEyltcVS4XTvWSNhLezkMAqVlcSDA7Y6KFhUDRqNuARBoGpglmIkFaO5Qsl47WFhaKeRytSCQFQrvkyy6WI+lpS2C7kJCShvOqXTc/UlGu67WxgpWVNLcfuchzT4ySW+mkZ6DIoTdf5Pkn97Bj/xzlXDv51S7vYQEj24oMjKzTu2WduXM7GNu/QKo2TD3bC3iLp1JIlLOGdKC91aSeW/VcF8I7m0kgUI6DqxxwNJnePN07PD/4wOgSxfVuyqud2MqlUrZwXY0pTVJJDwCFENiu4+1O1TZKaxI+iXHwyEBKGiSQuJZLUgoWzw2hlEYYNuW6hdCaSrGV1dkWEgmBnevj3JNJLyz3fB/9O0qcemwn5fUWpFFFa1ifS1OfMmjvL/Cmty/w4rER6uudJLvz3HT/Cuef2s2qLjF6wwKXTw2yPpfyzq0yBEoqLNXABKy6hVIOWoJSEq28ndpCmkhpkDIVDgI3YWJKr6O0cGg4HjHs7yrxwvFtFFaS2Jd7MISgnE3R2VdlbaGF9aUWVheSXhtJgTIEZdvGcB1M2aBuA4Z3+LoyEuC6JF3v5Nekabyc2ryivG6AXjkWDVeD1KyttHDi2A5uveciF8/0svvAOt/5xm7KK+3euRLWHg6+9Txz5/rZtm+VM0/sJmHA2O1nmXpmnNJqJ8WVTkbfdIrJZ/ZTXOvGqTteFIJjk5Em6UQCI+FVX2mHfLUOUnq/Sauh6ri0bLtIa6fL2af2Ul5rR+J4CjXTRaoti+v2YyYNEgkDy7axXJtCRaFsh1rDIpVKgqMxDYGJwHYVwjBJCOHFsTds0GksZWO7mrpjYznQkvQ2Gmm7Qb5aIykNuttbqdSrpJJJipaNZSlakiarcylSE13sunGeyy8OkltKY1kV/n/q3jTYrus8z3zWWns44z13xB0wjwRBAuAADqIggqRIidQcy4M8JLHsjjsdl+MkbiWu6qr86aruji13Bru7bMV2bHfsduy2FcWySIkkCIAQOIAkZhAzcHHn+cxn772m/rGvHf/oapdopyStX/cU6p57D+631177+973eYXzBHGIUhLrHL36AFdOSu45fJ27l/vZuq/BheObWZuWDI7Psu2RGd57ZTNzkxHzd4s88twsZ18LWJyNidfnD0IbjPNI8kfNljForfv8DagAACAASURBVLFSUYpCAKSCTmpAZ1RLpdz9qjVxXCSUoAKz7m40JBbSNAWlEMLmngXp8YFFyYAsMxg8BJ6O6RIZhesByiMDwVrq6B+K0C7DGodyCte1yNBigZ5M0F2I3Ae7OL5bS/i8Bq33LM6XeOv4Vh47cpM7V4bZtneFMyd20FysIr3j4EeucfnkblYXq/SPNtn3+HXAc/3N+2gtDdBZqLHjsfPcensfzaV+wGO8Q3gIleIvspIlGYiclupZ7wtbS2W4wfaHb3H11C7aK4M0l/rZ9dj7XD+1i/pskSAIiYLc7WmsIU2zXN1CTt50OCpxIR+euhyQFipFMQrJtKGVZHSdJVtXYRVjSTFQKCXwziOkRAmPdZaVuSLz14fZemCe2csTZI1hEHl7NEsyAiWpFEJMfYjrpyo88MxN5q8njO5e5vYbO1DCs2HHIlMXRhnftczcnYiluTJhECBN3mLtefMXloCcPeEcmdFYD9qkCOsoFGNkFKFUQJr0cM0WQkniMCI1lmvnBlBKocR/RZfPzQZMTVVApFhtsM4jpCIIZP7zvaVjLJUwpNNLUFLgnKGZegKlqAQhISJHen+A9T2x0Xs82nkCBVIqhJcsL5a4c32YfQ8vcOXsKNNTBSQp5ThgfrZE9eoIOw/OcffSRtqrg0zsnuH86zuoDqygsoyluQGSb++kMrBKrDMGB9rMXd1EX6WCUgqf9dA+Pzlp6+lmKWlqCGQu/zNO0KnXuOfgJM3ZDWRZwsBYm12P3uHam/fQWeunVvP0soy1VgerHYU4QFtNIAMq5VIewyYd2ktWewnza20kglIsSXoa6ywDpRiDI7GOKIopFgOM1kghWGq0aHcNURQShJI4iBAEyFhRDi1Yh+xbZuPeNW6f38DGPcsszZVIZ8t0tCaWEm0yMu8JZczqLUk81M+eh1a4/t4wN2+Azrr0727x1jfHaa/ViEqe1eWQN18ZZ2CsjVoqob2hm+U3MI9CmxSkQImAOIqRUUgIlKII7R0oRaot2pr89w0DjE5RAlo9TWIMVil2P9BgeSlkdq5IoCwFJMMjKaW+Hlfe68tvjKEkVIo084hA0esY2iajUAxI05RACorFkG4nAwS1gSKpSchSg7GOtCOIy99frRuNw633saWULM+VuH1liL0PLHDlzAbmpksEaFbnqpw7voODR64zfW0Dm/Yssnh3kOXJYSpDDbLMsDTXjz61m/LgGlGWUh3qMHdjM2EQ5LkDUuDwZCYfWhtr14lhno33zBOVEi4c30pvrQpkWGtZmR6gNNhGzJfR1pAYi5ICa23ethS5vlM6h5CSzFjaSYaUEu8t1hhKUYjD080sdh3M4yW0my2s8wxUioAjDEOcVHSyjKENbcZ2L3H77Agb9y4wPxXTXaxidH4Ak0E+fBWhZHEmonR1gB0H57l9bpS1VocHn5vj3Vc3szpX4e6tiEMfm+XM0Y2szJfzPGLAm/wwgxd4b0mNwXoIw4hASpCeRBuEMxTjApnJCIKQUAqEyPBYUuMwOltv83hUAFZ6vMzfVzuLl4Ku6xEahe3l/xaEisQ6wrIgyyxYiU8NvmjooMkST2i/30/0uBwpKySBDxkcb7F1zzJXLo6xfe8Sywtl2msDaOOojdfZdM8iN86PsWXPAssLZW5dHkEphVSC+w7f4Nrbe2msDIDw3Hf4Jpfe3IELLHOtZeppxkixhAK0sUgPgZTU4oggCGlnGcIaVuf6+MbXtvCJz95k6towm/cscfbEFpZnPY418BK8RyqHiKDd6xKHEZnRdHVKJANaWUYgFYmxlCNFIEM8MNxfzDnsOPqCEO9BW0sQKEwYgPPURgpYfK73FZ5u1iVQMak1qCCgNtLk0NPznD66mTuTkuFbkiMfn+TESyP05qsYa0lMLjcrWsHI5pSte+tceLefXftWuXVX0lytcfvaMMI6FjpzqCAiFoq2jlibi8hMD2cFUShwQmC0oWsNWguiOO/jlJyHIMAJiRSSjk4xWuOEwNkerigIioqVRKOFJyhEVGXE7HSX5z+9yssvDjM1HTOypc0TTzV49RsjzK9Z4orAZxmNeYEIHSpM6S/VGK7khKtaHLDa0Cyv9KhWCiglSbMUCIg9JD1NL1H0939/bfTeOux6mqjziuHxLtv2rvD+hVF23LvM8mKF5ko/Ds/cQpG+q4Pcc3CWmxfGuX1xAu88Bsv9h6/z/qldrK7UsMJy7+EbvP/mDlqmS72bMRgXcgOUsX8RFEUoJcX1G3ZzpcSBfUvcuDpE4KE8VGfPh25z8eQ21hYqWKtB5CkI3TT3ajh8TlIQ5K0M50lN3nYIVECgJFGg6Om81gtxiHWeMFQYa6kUIxBgvMU6h14fRvaNNjn49AzvvLaJtYUKU9MRj350krdfnWBpppCrfhKLcZZQKsY2dtm4Z5XL7w2w494lbFTh9LGNzEwrMtdhZT6m9+oEIxu6dKdDTGaJ1wUW1nq6xqCNI44UURSghMcpTxSGOFR+iPAGrTxd30VYQZYZvID9B9osLITMzxXJUosQltGRjLExwxtvlYgiQaIdSEkxztvIoVL/VX2DQBiPihR9MsQZj0kc3bpjeOiD1fL3xEbvIQ+ykCFJkjE00eCJIzO8c3Ib8zNFmvMVHj1ym9MnQEnFg4fv8taxzSSrQ6wtVjl4+BaX3thJfbmflcUil9/ayb7HrnD3xhCbdy3zzrGt9A3VCasJ3bki1niSNGF4tM3GkYzbF4dxNscY1Dtt0kRTK0WstDLeOq25b/cAux+a5/p7wyxNl9DeIQLYdf8S9cUCK/MllFDEcUB1qM7gcMrUtY2kRlMpl9DOUS0IjLWEkcR7iReOZreHUCp/TBeQ2Iw0MXgCRGZIdUrPObLEUAwUpTgkKsJir0OxHDE20uS148PMTgt6OsPNlTn1ykbGNqU0ViVOGLD55lobqvPQkRWOvthPd3mApcmYIy8s8+YrZdZWRij3F1GDISKIKEhJzwhIexS6U6ggoN3roYUgrkoKMqDgJZlzSCNJrKGVpjjjieMAH0kqpSLSajSSduYJVAQNqFUEScfTDTS2W+ONEwWe+8Qsly+U2Htfh5e+XmN+OqRUgCxJyKxiy2iBZiuj0dXIsqDT8Vgcdj1xKyoG4D2h8iTWIzKICyVajSZR2VErV77bJf4dLScEURDivWNwuMmHnprl9MktLM2WacxXeOTIHd45Ac2lfoYnOmy7Z4Vr50bZds8SawsVmss16iv9XHhjG/s/fIO714bYvHuZd49tpjZUp9jfY2G6SNf3EMDIWI+BoR53Lm7AAM0kIUk1vV6REy9t4vFnbzF3fZgte3MGy/J8zI79c9SXiqzMl5Ai7ydXhpoMbci4cXED1hlkEIL3FEKDAMIgzF22zmBwBCJnHWUYummGc4KVtEWqLUpApCRRIabrLMP9TY4f3cDivAKXMDcZ0PvmKKNjCXOzRZxwOO8w1jI02uLhp5c4/s1B1uarzNwJefKFFRbujhIVqlgPUkU0G5LGGoRBm1AkWGfpWYdUHq8cMhJofP5ZALzAeo2WjoDcqdt2lmI5ImlpZCgRXrG6XOS55xc59soIk5MhIxu6vPCpBi/92RDeCXqZRXiFyRzL3ZShWhWXGdw6yCVL87oOMFjjCQjpdR3WQxB8sC37e2KjF0KgvcNoi1SSew+ssLxYQNv80enO3Yj44gj3PjiH1gHvndpOu9FHoARry1XOnNpBeaBOtlBECMnSYpXJ6wPs3r/AtYsbmF2ukEnL409No49u4tKkYsfmHo88NcvC3RobJnqszFewxqDwbNycMrBhjTsn+9m3L2PzvStcON3P7vtXmZsr0Fiq4YVnYSniiWemOXN8G+3lKtXhOg88OctbRzdS77URUhAisM5TUbncS68zaqzOXaXNVNN2ac5qyRztjiDNUkphrkXuZvkQSCmFtp4amtB6uo0OZ98s0kw0QrZRUqCVZeqWZGGmjFUWJUIqfUN0rWF8k+eNNx5AB1sZ2NqHiiLOX5hi/J41/OyHUGFILMFbsNZRMCl4h14r0py/hAsgisELkcv9AEmIMRldpwkLMRUVUIgkUgiKIqTX9QQeKt7TWk4pFMr0TAdnHC6VNLsZdxcyvIp45tk2Z073sTxfzQ1kgSdrR5QrASsmozJQYbBk6OiUoVqJdq9HIQrJtCaWEVhH4gyEknIUE8eSckGyYaiI19l3u8S/oyVDRWYMwnmGNqRM36kysWmNNDNM3q2QndjM1q114n3LDI+2OP36TuqLfTRW+jh4+DanT26mudTH8kKVqRsj7No/x9ULG5hZKqNxPH5khsbLo2QrVTaOpzzyzCQ3zo7m6BCfG5JGJzoMbOhx8mQ/nKry7McWufhOP3enQ6LAsbZa5NAz07x3fCutpSqDww0eOjLLG69M0DUpgfAI4bB4ykrm+GBnsdbmijHradsOIoAsc3S6OVZYZxrtoBQowhj6wgxnHO+8UYDA43w3b60AMzOKhakSYWTxQhKomDAQDE0knDi+h1Y2Qf94FScUZ881Gd3RIAsfpCoE3gu8dTkuIWmQrd5GmwaEINal3NJLjIE00zgpiJUiiCBWATEKnWnKLkS3LaEr4kyK0Y7JGzEvdQf52GcWuXi+zP4DXb71jUGW5ktEgSW1giCWRMUYmYRo74hEQGZ1LhoJ/iJM3CGUIpYhXTy1sqLw/TyMdc6jtcFbhxNw+fwgT350huHRuxx9dYIQxd79C0gheOf1iXWnmMYECusMzWmJmBpGBRaHZniszebdq1w8N8jue1ZYnanQXhni/MmAx5++Q+lChQP727x1dCNCCh49MsmZE5tZmqsyONbhwaemOPfGZgY3tvjYC0ucPrmJubmYVr3GYx+d5tTxgMZiidm5mLeOT/DYkTvcfr/G9nsbvHdiCysrRYLAEEqFFnlsXldatPYYa0mtJvQeTG7t95mn3bKkXXDGo4p57F+trAgDT6UKQlisLxBKxcjEIFFcpNN1pE3HQF+FTSOjdI3GaoeQMSKKEF6ACJDOsViP0VpD4Og6gdSKrLuHetPQa6+gCjFW53JRGSictZhUE1XGqWw0NObPYHWMlRoVR0RKEQcCWyxQNAXiYkTgDd1ehteODikaQXvFMzJcRsWChkmwiUenAhNoSpWQnaMJjz+R8fab/dx/oMnkXIH6aj9KQ1FY4jCkTIR3KVFRUfMVIiUQcURfWIAgZ69YY+mZjDhS4ASZ7qC8ohRIgvD7axibJSY3hHnP+bP9TGzs8ZGPTrNpe5PXX91ENzOMb6+jpOf9c2MszBZBGKbnY7onJhgY7LA4X2ZotM6mnYtcOjfErntWaCxUqS8OcPJVz3PPzXDzSsLuvQ0uvTfC3gNLrCxFrC32MTDW4cGnpjlzajMDG1t86IkW758fYvf9deqrfczNVZhfKPPmsXEef2ryL2v/neObWVkuEAYeRN6Dl8r/Ze1ra7DWECOwjrxF0rYknXwPCAuCckGhQk8YehwKJQPickRlsAAiZK1tKciYieHh3F2dOURQQAQBAoVDMLcc4ByEZY+RChUErKwNsLTm86hKowEQMnfbelUhGNhCtnIZXIrGoqIwRynEgjCSyCAgVqAzjTWGNpYk9YQyAi/oeYvpenSWPw3cuhNz5t0yH/5Im7dO9TG7VCYuRUTKoFy+gUvhiaMQ6RVRJIhMns0gydHtmdOEYYAkn19WiyHRB4zF/J7Y6JUQhIHAyfwuurJU4eRrmzn89BTPfWwGyA0+b7y2henpkEgKolJMkrZyFECYM14QjtGRDoc+PM07JzezOl+htdTPQ0cmOX9SMLdQJLzcx6OPrnHuvX4WFksIIXjrxGYePzLFjas1dt7T4NTxCZrLRUY3tfij/3ucrUOjlGNNfTXi+CujlGt1lluC1Cb0rgVUB8o8+OgqF84McmNGkaQ9TJZfrEpZkixD9zRRoIjjIqXydiqRIyBDFBRRqOjNdtkwJIlKRVxgqRaqpEYwUCzR39cHIsY5lQ+0gkI+fOr2qA2BChVaBLmVOvLgDG6dNaOkoNvtYUySa7PXEQu9doem80ipMFpju136+wewzoKFIAjzwbh0DGx6kGJJMT11hlKpRmoN0ystYlWgEIYUo4j2coJRGuck1guqlfzCuDvdooxkrtmmECsKfQF9qoK0ltGNbZ58ts5rL40xv1Cgvlzm+efmOPlaIe/ZF0toYygXo/XN3BMFAQhBOQiR3iMjh80kRkmiUOK1I4glVSOYzVoYo8jSD6ZU+G6tYijJvMevtxOXFyu8/upmnnx2mqc+NgWAc4Jj39rE4lwF7wUq8Ag0y/Nl1parjI53ePjD07x5fIL6Yh/1xSqHPnKHd17fzJ3JAtff7+fAQ6tcPjfEjStDtOolHnlmitvXumzfs8ap4xOE0vHCJxf4oz8cZ6yygfpSH488eZdXXhpmdqbIakPQN5jX/vn3+rlyB9K0A95j8BQiiXMOm1kKUUyhOECtMkJRGqzI5bbLSwmjg4KgGCMCEKpMqVIhCApYq/L69B4VFjDaUOzXKCVzDIbzyEJe70JAFMUYo9E6Pxlbk8Pbes0mxvmcwxSGlIolnHcoL1FBgPeeUm0blWrM3NQ7hFGRnjHM17vEQYFiGOEzT5MM6/IUinJJkqUGTUqrlyIUFEohtXIR4R0jEx0eOtTlvdP9HHywSX2lwuJiERXlwe1hoPDCYq0jUlGewRCuh5JLTyoDjA0QgBKeps1yRErywaTC3xMbvcfnwwjvcHiM8dSXaty62mPvgUUAzp8ZYH62RDGGuws96rcSHtgT4KWiIGOiSKKCkP6hFY59awPNtRAhDVOzMenJTQwMtSllPfbua3LxvUHu2degtzrA/FKZtaUSd2+MsO/gPO+fG6K50o+QjjffqrG87KjJNWSQD2CydoHl+ZhaKcYS0z/U4N79bc6fqbF77xqXr6Zcu+noK9UYH51gzz0HGRseZ2LLZcq1R6kWnyQu9FOqlrH+LJ3Ou2zY8I9QyNxBLiStdotEZ6wtzTEzN8XqygqLywvUGyvIUOKyLs4YvHdkxuK6BqUUmTYYk2fvZmmGNZZqXx+Z1nhrCYIAqVQOFAsjilFMEIYIcrldkmUEocJmGU6rdQWGY8XMUenbyci4pr06SaMlcFZh0bhA4TFYkaBkRKkY0M5arDUssSwSRCHOaqphkSD0xEoRKY0ThonxjHMnN9OrRxQCS2epwluvjjM00mLmbkgYK1xmcT7v4UobYG2KsxYB1HWXarlI6BSZ0RAIwljS6aWsNQ1ZICjGHu2+v4axDkdAjsf23qOEor1a49aVHnsP5EahS2eGWJorY51hej6hXFCMDwcor4hEwNBwxlvHN3HnlqJQNMzOFXnj9U3097eY0AX23Nvg0tlBdu2ts7RQZmGuxM0rQ+x7YJHLZ4doLPWx674lvvafR7h1I6K8q02jHdBNRxmf6NFaqdI30mPv/jbnzwywZ1+T6Zk+lpdG2TA8zobhMQaGRhnfeJ5q+UFqA89QLAwQFysY9y5Jeo6RkZ8lUAFiHTzWTbpM3rnO0tI8i0uLLC7N0U1zqWGn3c5r3jmctUgpct+LzcFgWuscQxKGeQtWSITKbzRhHNNXLOZu7izX9atA5ioyJ7DOYs0apfIwg2P301y+TqstsEZghcEFEodBCEmpFNBOW9Sb4HREtQAFFSICTyFUxNIyNt7l8DMLvH1sI9PTEe2lCk89O8vxVxxL8xWCHKVGYjQYRWbT9UGso2d1Dji0III8pW6tndIynr5QoIK/1gT7/7m+JzZ6AK8tCFDkH258Y5sde5cxJv9ge++rszpfZW4mIEt6NJvQ6pUAR2o1IgvBtZlb7qOXGYw2FIqeOFA05it47Tj89Aynj21kdr7I4mKRJ47c5fWjo+A9E9uXOHt6lHv3L1Gf72N6PqCbphRUEcKYZtJDhRIXKDAGmaU88MQC23d1+dbXR+k0thHIGj/4Q8f5wo8cZuumX6a/f4za4BBZmtJJT3P54g8xvuVh+vofZnXlKLeu/TS7d/wWYRhT6htEAb12g0rfKGFQgF17wSUkvTa9JOP6lUsce/0VJudmSHsJgZLrhi2JdSCFolQIkUrRV6rkTtKokAdMeI/JLNaZXM6qNVnaQ0ny5B7n0GlKWIgpl6o47zE25+475+i22xDtIPWrDFbWGA+r2MzS6CQkNiUUkmoc4oxFZgFpHCMJWct6eCsolgWpSynEJaTNte7vn+8jzRzTjVWElMRestqKCSdrrDRa9CoBKhSkWW5CLoYB880O2mYoBCaw0E1z2p93pG2LDCOKcUBmoK8iUXFEM/n+OtH/RX69Wo/Lk8DIaJsde1fy68HD7n2rTE2FzNyNc08CjkyDVQ7rHJfO1DDeoaTBG48IPAszBYzWHH5mjuOvjjE/V+DWnZBnPz7N2XdqbNvT4NuvD/HwoTqLM0UuvVfl5kxCFCh8oGj3Epp3AybvVjny1BKbd7S5cv5JAnkI00v4xKd/m0rpEDu2/1viQoUwClldfY0bN7/I4PBBhkcOUW8c5861f8iOrb+OImc7hVGByDsara9wz95HOPTwZ0mzjLmZKc6d/12W177Nxcu780AfsZ6eJWTeWlFBDhcrlZBB3qbJn1wdZh2PbKzFGp3D9JzDZBoVKuKokJsnXe6cb7caePpJTImhSp1Qlun1DL1eghCCcilEaEfNROhY0TF5Jm5cFKQuI44ChDUMDnc59q1hLl3LSG3C3IqknYwwPNLj/fc9cSn33gibzyIWmh2szdumTjpCawkCSdZxBFGI8YoogiAO6brvY2dsbt4I11sdkr7hJg8fnkIA7xzficNx6PAdPvTMXV59cQOr9QqC/GIPghCJpOAFIgxJhSdSClHMT0NCSbrGsHG4w2snNrC4HNNJUlZvKxYbNfbtXWPX7pRf/bUysRmgsaB49JlJOi+PENyJ0KEgjDymZ1lba0Enpa9SY3TzDjaMlYjiW/y9L/5LNm35AdLOt7k59RYbNuxkYvu9GK3p9DrgBXH4MDu2/ybvX/kxxsZ+hvn5r7Bz21coFQ7RWZ6nPvk+xeEJBkY3o5MOd6f+F4rFB6n1Pwuyj1KfYvveq/SPVPl3/04zNj6OzRK0NTjjiAuFXI7W69LtacIwJJCCtNcjLOQOwEAEOGO5Z+/7tNqjLCwM4/HEpQJ91Um2bj7D5cu7mJ0byp24QjBYm2RwaI233x7BZZpSpCnGGmUV3Z5DJDGNpEdcEAijUYEnViUKkaPnMxKbUhvso9W1qCwgsQbhPd1GRqeTgvAYK7GZIS6HOAVG54PeduIphyClR8YSKwyDA0XSdoiQnkwZvFFY4cApysUS3UzT7XiyBPr6PdPLbdaa+rtd4t/R8uuoYePzw8/YaI9HjkwDcOrVLWTG8OSzszzz8QWOf3OCej1C4Cmum9YiqdDrg89YCjSOjrakzrFlsMdL3xxm8jaEKqV1N+Tdtyo89sQaf/D7A1y5XKK5GPP0J2Y59s1h/FRMoh1rTYt2isHaEFvHtzM6epMousbzn/5pRjc8T6t5nNt3f49StZ9idQDv83lUtfoRdu38bW7c/CLtzhdZXPoP7Nzxm1SKjzM9829QdgtB+DD9o9soFh/i8uUfplb7HGMTv0RUusPo+Feo9n2e6akKxmaAp782w+DgKnenHsakKak2WOvyNpHNUd7eCbZvPUujOczcwjDtTgetDY8eeg/vLS+/sgutLc45du1sMDHR5J3Tw6AN5YLDKAdK4qzE6wALZMKhJERhTBha2t2MYjUm0w6bBvS0wRrLiW/H+TwOgTMeEXmm5wrMTBUQMjeHicAhA0EmMmp9MSbNHeJ+HRNivCMKYpJEk3ZzJtByq0er8/3cuhGQ+txZah1sGekwfbuPyck+Zqdy5kT3lTG27WizZROszhVwvkspioliSLUniEIanW5+ChcKEULqPElmSYxl6c3csm11B2EM5UJIt95H0nYcfbHAnbsBmwcNi7MFXnt5lKGRLomNqDcyzl61hCpg5459PPnE0+zb+wQTW++hVK5Qb53k1u2fYrV+l/n5f8/2bb/NwPDHcgWRDFAyxK2jUwcGnmFD54tMT/+vbJz4Ev39T+GRtPRXUHITcxcnqcwusPPAI3inuHH9Rxgb+01UcIjVlZfodv8lYfwxHnt0iFNvzFGt9BEoSd/QLAODKywtH0YUCiRpmm/Ucj3V1llSndHKumRJjyvXPR996htcu7qbG7djRoZX+bEvTPPiS2Wef/4kv/qrJU6fhkOHPD/4zxKOH5sgkstUKiGVSkgnK2Cko1ALoewo2RLeRISxxaUOGWqIHVnToYSk2TO5fjqU6J4jSS0ygqjfEbqQUqBQXmIyh1YWEQeMDJXo9jLa3S46FRA6ej4HvJWKET0HlUKJViPBpA4hod3t0uqkFGJFs5tSGakhrWdkuPBdrvDvbHVtlgf0uVxuVxtoM3mzwu2bFZbmQoSMeP2VCbZsbzI82sPLALzACY9xllQbtM5DOiIhyCKHto521/PmqQphACEO5TzlUkBUEPz51we4O6mwznPnTsRLXx9kcKSL9hFLK102je3i6SNPsf/gQcbHtlDtGyLRZ7k79d/j3BdZWv5tduz4PWq1p3DOIpC5A9po4vBRBgf+LrNzX2Zo6B9j7UFW1poY7mWx/vOY7s+i7h5ibFsXaw0rK3/MjWvT1AbeYnnl42wY+Rp77vkxLpy3DA3N8fDDxzn1xhN0Ol2M1nS7XYzJNfRGa9I0I8sy1lbb/MDnL3Du90a5dk1x376MbVsX8UBjdYULFxX79lk+9lzK8aPjFFSDKBCU4pDU5dF/UVEQFxTWKCIlwHiU8jlx1sGu3cusrBSYmyvgTW6I2r5LMzyU8c57fUgh6fU0HaMpxyHFgqLbM/S6uUQ7ETlcUCmFk4IoDCDNsyacNrmBy1iiYkgUK4YK38fDWOsc3SxDeYewcO69PiQ+Jf0ptAAAIABJREFUB/LjSYxhabHC8kIFYw1t3clP6lqTKkcv1dS7nfzuKQVWODJjIJYUJOiOoL7aY6ASEZdjhI9wRhOHcOl6P71uQiAs3czRsYabFy3ahAgJy0sNdk/czz/4mf+Bw08/hwyDvO2RpTS7TYR4kFrtJ5iZ+VeMjf1zKtUj4D0260BcJu12MEZjtaXTPcX8wm9RLf8Ms3O/Sb2xE9x99MwYNvsSnfRnufDtm2j/Hmutf8Xy0nMkyU9x49pWtu+8xdFv3o8Vt/jUp1/inr3PcudWxvCGZR56+BhHjx1iZvoG3bRHp9UiTTW9XkKmM7qdhDTRGJNhbN62eftNz//4C+/zjW/Apz8t+OaLI7z57ZQzpz2/+D91ePFFxSc/4fjWn2+gvhJTDj1SGNKuI1SCrJNBKFBBng2bCkfR5uUUigKdbgdpJX2VgPvuWaZerzC7WKBaCemrRIxMtKlVM06/GdJLMqJAsdzIUMrQX4jRgaadGTAi1ycTkMq8x9/sZQgZkAUZopRQMiFOQn+txpA2+WduSUb6AgQBve8zeWWw3rLx5Mzyi+cGUVKSaovEEYeKtcUq8/NFOklG5i3SSnqZRgaQWoO2DqUkWnrSxCGVII5AGCgVQ5COrGMwzvLOu1WkgTiyNBD0jGBhoUR9qQ/lUx576BE++6lPsPWe+wmiAs1U0FpqEkf3UCr/CPMLX6ZW+QdEwcOkaYKzuSs5SzO63R7t9gk63d/B8xMsLf0HLl8SLM3203UxQfhJ7tv7v3P1+i60usWxY48yPLrIgweO8ta7e3n9tGLjyH380Gd/C6PHGR+f4w9+fxNXr8ywZesVJjb1eOOVAtpYtM6dvSbLMdbWea5dk3zpS7McOxbxwgua997p59pVy8//kybfeknxyU9bblwtMTcZ5DkP3tPt5dhw5xxBnmCJk7njW3qHIEBYgUTQVzU88MAiR4+OsrxQZMtYxpGn17h+rYjXDgtoQ+629x6hXJ5QpUKQYEX+dwJP3oHUiNBSlSGFSpFeliHJiGJBpSTX6bofoKb+FuvzAy8pBMUwxBoL5BjQIFLgJd0kJVY50iIKFK2kR8+DQNFJUspBQBQFdJMMIxxBEJAKhyKi1UgJlCAuKYaGJMI4iuUI7TWmGdDNNIn2hLpAsZTQTQTaB4xvKFOLily40eDHPv95fvQLP0hYG+adS5dIkwQZVAglxJFCivP0er9HX+0fsTD/6yi/j8GxT6J7Ka7dpdXq0Wx36HZP4Nz/TDv5F9yZGiHrZGzZ9k9449hBZur3Ua08wEef+mWm10bYtLzKn311OzfuLHDkmY088dhV3jr3ABeXD2CcZ+33e/z4j/4Xmk3BwQOGf/0rMRfPnWHX3oyduzwnXlF4HNb6XJ0jJM7mHBoL4CXnzkhefBF+9Ectx1+rsnWrxaaS/+ePCrz8kuYLX7DculFmYjxhYTaPBVQ+zxQSoUQEOTFRGIkOch6Niw1OG4w3xMWQlWYP5QS1QcFDjyzw2mvjLMxGjI+nPPmRRW5cK6GtoxgqjDYMVCNClRMNpRIMVBSxyJ2Sztm85wyoskIKSdpJiaOIUEiiKEICqfLITBDFCp1lSCUQ8oMNsL5rS+RmHO0tmcl7slLlnBghBF1t0J0EofIglyiyZD1H12h05sBbrBWIzBCHCtsFF3oq5YgokoBAKUVUkkRxgNWOSCjiSLNSNxgTUKmEpNrQXxtmy30HODe9zLvTr9NLMhARpShg8/gsuzb/Xxj9efB/iJx/giB8hF6vR7PdotVLaXe+zYbav+b0O89y5f2UUrSJT3/21/iTUyNcuV7GecfzH4/41CcvcvLNPdRNgcN7bvHO5cc4cP955tv3c/3mfi5dmeTg/VOcOBHw4p/Pct99jh//CcOXvxwwv9AF8lrP//vEX74+dw5efFHyhS9kXLxY4OCDDaamBnj5mwE/9COGLIOZ2QpBLJESjHbr1E2HCBQiVuAtaZYTObUxeaiQcXQzx63JCjt29Xjmo4tce7+fPXvX8rCCO1UG+io446lVPIUwxmWWIJJIlcs6lQAvPFmq8crjrUM4iQ1ACElPZ/Qyk6PPvSAzOfvng6y/0UYvhLgDtMj3D+O9PySEGAT+E7CNPJzhh/+6AGUAaw3aa7QROXfD5YFdQSBzJYrOSFuaarVILXLMqBQvJI2sRy/xhNJhnYIkoRApvJCEmaSrM/rDgHIYEMWKLHFUCiGFiqJQiLDGEJqA1a5mruPxJqY06Jivdxka2Uhp01Z+42sv40RAt9vFiwJKBvQVBRvH5jm074+4OvlTVAsPsKEYMCv+KY2uBh6i2W4xvbTC0uoqleAb3Lp2gPPnv8nq3BTLK0vsujdky9azfP3r7+dFloX8nc/N8cqJnUz1PsSOBxZ58IFzvHflCQ7sPcNKex8Lazs48+4Cj15b5cmPzHH0VXj3Xct9+xz/7Bcsv/IrIdbndiap8uxyIfNwF49HrdMn9x9wvPCC5Q/+QPLpT7c4e6bKp36gTaIVH3ve8vqJgMMf6bC4NEC1VsSTkSTkkzCncVISliKKBUvaMHTTXCrWTQ2VWhllM1abhlJfxK27JXbu7PD00/PcuDrErj0reCG4M1VleLiPSlggzSwy8JTjEr1WFxUISnFMT+cxcqW4iBeeVivBZg7tDKUgRGNJrCHLcq6PNp52PUVGitQoAg8i+M4vjr/N2v5OV6/bRYYSi0cISeY8aWoJgjyb1TmQzhGECucMnTRD2IBW26JCT7UU47WnvxxjnUMVJaEKSZ3DZnkf2WbggoCSjxDC00oTrPNI6Wl2HH3dEJOBDfu4eHOSpF0naTdwFlAh2zev8cTBi3z1zx6mrQfYd+8P8/C9/5iFtX/K3bkx+ot/zM1bgji4xR+eL3PmzOvcu1ezc6fj3/yffezY1uHx0TyQ5skn23z1z/p4/tmbqOAWV27v5vV3D3F3biMvfPjPGao9wq6dq5w9N8zhw8sYAw8/DF/+suLChZxvw/pNMF/rvHvn2b8fXnjB8dWvRjz/fMaFy/185nOrgCdN81wLLwQizq8TqRTeCpABDovBYQwk2qNDCxKkd2TWofHcnJSYbwzxiU8uc//BVYwWvPqtcdorNYbLcR6BaHNZsAsEzjv8+lO1VBJigZSSZF0p5FX+JNLRuaqu1dT0upZaEOJ7EmvcB6qpv40T/dPe++W/8voXgVe99/+bEOIX11//i/+/N3DOkZkUg0cqiXSC1Fp62lAsKLwXeXEDRlgW6x0EAd3Ek3YMpZKiWipjEsPgQBXjLE4LVClkc9CHlopOL0GnDmMsVoMLQgpKoQhY7naIowDtMpbrEbIoyboSGxZ558L7mF6TTnMFl2pEUMALj7dQOTzN7//hJuYWL1IdXGRofBf37/4iG0eOc2tOsDC/QFX9DpcuaU6+vkavl6BCxcEDigeegK+/1MelW4rP/EAL4+CjH23z1a/38exTd9i4uY+dmy7wtaPPMz2/kRuTw3zqyJ/y0slP8OEnSmzeusSFCyM89fQSQlkeetCtF34eVe59fpIVQvyVC8HjhWf/fsE//5Lll3855O3TjmZrkJ/8yTVu3S7yE3+/w8nXFQ88aDj1Zj8PP9hgrRmyslJB+vVHgjjC2QxjMpotQTcVaOcQ0qGKIdaa3EGLQMWOq9dBt4f41GeW2bd/CaMFr720kbWFErVSiVIQIGwXo0G7lCiWpF7TbBuMt2Rpho4DfAFkJOmlBiklbZHhNWgrSLUhUJ52V1NvaGSsKZeK9BKP7n3gcJ2/cW1/kCXDEG1ABR6n8mzSSOaZwr0kQ4aeTDh6ixlxrIiEoKeh04LhAYVKFTqDrs5De0QkSZ3ABwKtBEKGBJFACUEj0TipMaEnA1QoaLcMCysJfYMFVFRhbXGS9soCxUIBgcJLwdjIHOfOxszfucrdyWkWZvYxv/wce7b8CbrjePlYnZ/8+/P82v/RR721hUOP1fmpvzvDr/77DVy6WeTSDXjho3V+/IfX+I9/PMA3X6mxY7vjwH1tVhs1vLPcnRvj9KWH+dDBU/zpKy9w+bxBZ9/mmWeaHHtNcOmSREj4O59z3LguuHRJrYsIJAfut3z4sOWxxzy/9EsBk5MxMhjmhY/PoVRunPqTPwmZvlvkZ/7hEi+93Mf8YpkoVLlSJ8vTsjBinTLpKQYBWSbwRuK9pxBG+UAXy1+tMAn0shRtUvYeWKO+UmR+Icb5PBJzfLzD1v6EKxcG6FqHSxxeiJx2KV2eVZSFZFlK2vVYbTGJxCpIuh+sdfPfQmD8WeB317/+XeBzf903CCnIbLCeLhVgRJ6YU40ipFfr/BdNqjTz8z0KQhEpaDQh6XgqQQgdiUsC2muCrKlwRuK1ot31GOsRSpCsOyqDSkxUVDQSzVrWxhQ8PpJECpbrKYurDXxJERQrJPVZlu9eReoOobCEPiHwCbgWx14pMVxbpKrOcvvd17h19ijH3044dS7D9n6Ds2+/xMkTs/zEj07y1NPDbN29hwcOVfj5n+twa6qCD2KcUFgHP/6Da/znb9T40z8b4U//S4G9285w9fZe7s5NIIRken6CF09+nN3brvKpJ1/iP37tUV5+5SG+/e2Ip59ynDkjuXw5fyyUSiBlLs8Twq9TNCVKSMJAsme35Zd+KeDipRzKdu1qwNunN9JXNbz5huLJI5ZXvhXz3rt9vHy0RrnSppMYnDS4wJClPZz2ZF0NLiAKBYVIUgsiAh0gTIjzEIYh/XGFTOf0zb+8GAQI6XDCMLO2xmxjibHds1RH69Rtk+W0Q7OnqYw12L1/CVzehmq2DSuNLmmWu0d15nBaoBNFqAtkDYHtKoz2xMqTth06hV7vb01e+R3X9gdZjY6mm5j81JhaYgGxFCgtiHRAmEXENmagL6KvUCAKagRhlSAs41REJnLwcJJoEmdph4alrMlq1sUqh4xyFRNBSKlUoaAG2L+3zshwB+ssUnqcE2zdBA/ed5PVmSmcc8zMzDE1dYfG2jJHj1Z5970yX/zvGtx7IKK1tkqWttk6fp13T9c5d6XK7/ynPfzcz7X5zGc6/PTfm+Xf/voI718t5huozzfb3/+jAT73iQaf/8wa27d2uT2zlYG+OkIInHEEyvPG+ccZ27DMzl099u3r8vrrEY9/yLN/fy7PvHlT8qUvWQ4cyPvdB/Y7fuEXDBLBl78ccPGixBjL9KRicSnGe/jzr8c891xOpvzq16qMjhqEh15HgxN56H0hhw1KCR5FGJUolWKiQkSlUMJZz/BgixdeWMJ7wdnz/VgvOPLsHLUNdXo45uZDPnxknqCwRrOR0D/U5PDTS0xOwsJim8W5DnMzXZaWOtSXM9prmkZbkzQyeh1LIQqoFuP8ydwrisX4A9XU3/RE74FXhBAW+A3v/VeA0b8SoDwPjP51b2Ksp93RlPoEJs05MLU4wjogkQSJQlpJIPz/S917Btl1nWe6z1o77xM6B+RIIjCCESTFTIKkzCCSkigrWbJlShpJFE1ZnrFvGNo3jO9YgUHBEi1dWemKNilmMBNgppiQu9GNRjfQADqnE3de6/7YsGp86065xFHZ1vpzurrPOVWn+tvf2etb7/u8lDywvFYqdoTvujnD3jZJspxC2WwESFvQUnJpiIx6o0FaSSkWfSyDPBrMNWkEMZbjYFBiemGSOM7jBqXUKC0xjRJpqpkePUyh5DE9PUezVqVUKuIWC0gpsT2fQ4dtPv2ZGf7xgZX07Z1j/emDXH72Kzzw6Ab2vbuD7lUb+eFPprn106O89EYH5589w7fu66FvwAWtEYCUgp/9Y17wxQJccVGTR59Zy6IlXeg0BSfXBo8eXcSizhkef+Vq5oIuFnW9yRlnKJ5/Hi64QLFtW97sM6W56aaMkRHYtUsgZH4HcupJijUnKB78pUmW5bJFQ0qCMGZuqkg9cLlwc5WHH/a4YkvIAw9UOHLMZfSogyU1jXpK0XOwLIuCI5ldUEiRp2mFiYnluHhGfndTcD3GoxoJIV1tFbZc3UBrwa7dLaxfV+WiKyd4cmsrc8dcXNNncsLiiisneOiREjMTBVauiLno0jle2tbBxEwTw5A0lSZpaISjsQ0T28+jG5NQYqOIshRpwaLOImEckqCwhEOx+J7K/LdS2+9lGdLImegh2Jj5fN7IP7fvmhimgdLkqqQg5dhUDZXZeK5FPbTwPIuy42I7gCvwpMD2MoI0AgSJzlioJpx/2uWoKGR2aoqiMLnh2ncImh307zVZ3Nvg6isnuP/BNQiVMjG+QKXaxLIMbNuj4PqMDHn8/Ke9fOwTh3n73Yizz9rNA49vYnCkgr9sNYerBnv6Grxv8zBPPNvFvgEf05QIrdEoHns65+P7BcXN11V46PFWhHs6W973NIMjRxgdX8zUbDdbLniSN/edxQeveYNfPnIGb74yw3PPjfKVr6R8/euCvn0Gd90luOOOhGeegS1Xptx1l0V/n0mS5uY6pRWFco32tpiHHuvglRcE+/piPv/5Gj/4YSuHD7bS3Q2FoiSKFEokuEULUxqoTJCqjLlGHWkYuI4kzRSJiNi4oYkGntzazsSEw5EjFluumGH1qoBjYx5D+yVjR30+9skKu3YmbDqjycMPlBkcyIFvpilJ0QglWYgSisIiSzXIhGLBQSud5y1kGs8xCOL3Jiz4H23079NaHxNCdAPPCiH2/7d/1Frr/15mphDiVuBWAM8zUArShkZkUJRFjAxMS5MaCqdoY9smSapZqDQYGJ4lDCzC1MSxShwekxQLNm2+R6GkMQoCHIWfZnQXDOaaVRKd4VgGcRoyNdvk0rM/QNJoMjE+ybmXV3m9f5apYxauZVCdb7BhQ0C5tJfRfs3UxAzjkwtYlqQR1lhbKCG0JKhVODhj87Mfd/LxPzjE22t6OOvMF3n+jd/jzTeHcDt6MDt6SDKDPfvh6ssO8cCjLfQfKAIKQQ6QevyfCt5X3HzdPA8/0cqDj2i++MWM1cumODS+OMenas3UbDc9bRMY0mTLOft4+qlN/MM/9PHSS+Hxwpfs2ycYGZHcfnvC33xNsmuH4owzDG7/Ssbdd9lICSqXaGOYgjBKUHKBS95X4wf3ldi5y2Fw0OHzn6/wk59YGKqM5acUyh7NZobWCUari5sZ+YgmycNNpmtVpGHiupJAJ0RECMfglBNDtNY8/XQnExMOR8ccrrh0ipWrmgyNFoiSkKH9JuPHCnz0k1V27sw444wmj/yyyOghST3UmGYewJCQUTQcKo0mXY5HFGdEYQy+QbHoIFJBJhMk+W6m4JrUwuDfrLbfy5KA55ukqcI0BbHKqYyaPG4uDFJsMzcLyQI4dsTcfEAY5jRKQxqMH9/FoQW+7yJFntlq2ga242CZPkMj07i2pNZIiA4voZnafOiDr/PG0hLnnFPh4UeX07freIjL8WAPAMPMceCu7zI23cqbb8ZceukxXnp1KQcP2LSUXBwrZEnPNKefMsGLry3iws2TvLvLYP8B/7/5lJqN6wKuvKTGLx9r4YpLqmx9OebRbZdz/SXPsWNgA2es7+fJ166hq32KJ165mpEJSXuXZKB/irvuilmzJmN/n0H/PsG2F1w++MGQZ5/tZu/eKrYpUDKXnWoNS5dkbN/ew+ysSaEUsa/P5J57fVavChiqFxGmRaxSLM8kVQlBnICQ1MOIMFDYriCNUpo1SZZoapWUyXHJ7l0lJo4J4iSkOieYHivRuzilOpXQrKcMjwreedfl4osabHvOYf8+ie1KpCnAzGgpmKRJhlU0yKIc22A6InfjOhKRCLJYk2The+7Y/0ONXmt97PjjlBDiIeAcYFIIsUhrPS6EWARM/Xde+33g+wDtrY5e1llkoRnmzk4J80mIlQhSoTG0Sa0W4zkG5VKBciOkXk2ZnZ9DHHcQSmmijwc1CHI1QqFQwJQaw3CwbAPXM7HdNlzLIAw9PN/DKgQ0G6u46YYR5mbKTI8LFi9OuGbLAX7y40UoIahUmzi2kRuwBPhFlyzNkKaHLEgm5ix+9UbCZZeP8cL2HkYGJSrTrFvTQSMNOXFDzKkbj/Lo0+1suXSBgaECfQMuAokWoLX6/xR8jd27JUPDK7np6ud54NkLGZ1azpqlE1x1wfM8/srVLOme4IFnL2PsYMbqVavZsWMvd9/tsmZNyv4+k4E+g7vuyvizr8LB4VNZvWoP3/ymxdCAiSmznBsuBAiNyqC3N+WZ59s5OpbLXff2Sb75TZd165ssVNqRhiZWKX7ZIlMptTDAdVzqQUCtkZEmGqNkEAYx9ZrAMgRJkjJ5RNNdlvyiv8T4MUGaRjRrgoWpEi2tKbWZiMyC2ZmESqRZ967HxRfV2fa8zd4dBqYZ4/gOQmowM8qegY4UhU6TeiPBdQ0Knp2bpsgQBQtSjUglURiTOE0wfvMZ/W+rtt9LOLiyIVAZiPzAT0gDnRn5OYshMHSajxec/BCvXDYJAoVSoPOYqOMkSk2WKWbnm3lmspD5GE/kjurh4WMYRs4OMqSB5zpUojJXXjnHs88WGRzwiKMq/JOKRea7wzRTxEmCZVisXlHjnHPmef6FTjafO8HBQyXeekezpnuI37/hGN/8Thd7+hw2ru/m9s9Ncc/3e+gb9BFCs/HEkNtunebuv+2mb8Cjf9Dj9s8/z5OvXsPugY1ccPq7vL7rDMaml3FsejnSMJDuNGZSolwus3r1JAcO5CPBDRs1l10eM3p0HRdffIBXXpEMDdi54kpolNK8/XYLy5cW8OyMcllw5GiN/n6T4WGLDRs1cZyRJJDplDiO8QomoIiaOVlX61wtYymTWiUljjRvvFoELTGMjFpdkdmS+TmT/n6LlrLEK5iceFLK2WeGvPSSyznnRYxNukyP22QqQZoWxaJLM6ijpSSUijTK/29ZqpBaYhgGpmWhzRxy+F7We270QogCILXWteM/bwH+CngU+APgr48/PvIvvZcSmslmHUtI5mWAa7koZRIkGUIYeLaJqVKINMpVOK4gVSm2LcjS4zwLqTCkQIrcHRcEIfV6JQ+y1mBKk1RnWIaNaZjs3DGAZTm5ZVqanDe6kU9+Yg/vvA1nnlXhoYdWsr8vT79RWueSKynQCGr1Jlma4dguYaPBqZsE526u8tL2Ls49e5apmSFGix7HRiusXD3GZZvH+Zt7Oukb9Nmz1+FLt05w9/d76N+fH+xuXBfw5c9Oc/f3uunf79E/6HP7Fyf54c+O8Nxb13PTFQ+ze/9JnLZ+H4+/tIXxueVMV1aTZZqFaBdLu7sZHHJYvSblwECuPBBS8u7bisOjvZx+2m6efKqdHe/OUyocByhJDUIjhCbLMoYPLkKlivbWmLGxGtLQ7NwJ8wslTtkUk8aCWEmCQBFEMX5REoqYOMzRxipVBAFkSYalTMIm1BZiLOGx7QWPcsFF6IS5SkrgSqYnDOYbBkU3w+/w8AuajadnnH1WgxdfdDlnc8TB4YS52QK2MMlI0IakrbVMo1pB2yZ1pUjiPH8WmV8YKoopdzgkkcCybJRpYzq/mZvwt1nb72VZlgkZ2IYNUhAnKZYliRBUkgipM2wJHnlmaUfJJK6nmAYUWixqzST3lCBpBpootomT9NeCBk3ezISWpGmEUnncxZIls2zeXOPJrQUuvKjB8EiVmYks5yEJgSFzdb/KNFKY9C6e55ZbJnn4iVaefc5hZHgJn/zkACuXFWltjfnWfT0cHCly2skNVq5I+fYPFrN2dcjAQYnQsGZlzL3f72XggIcQmv7BIj99oJsLzx9i1bJh3txzFqet28t8fS1j08vRaC4+9wBHD5mkwTIGD0zyp19JeP31jIsvVjz+WJlrrx3h6ac6uOOOae65Wx4/oAWpIAggSjWZEEgDQGFaFpalULEmVhlxlBKZYMQZmTJJUDQbKr9e0pwuG2YZUZjiOha+K0mPyx7bWhwsA2xb5V+4hmDVipSrrq3x2CNlho9YjE3Y3HhTlWeedDgwDLZpEaUZqeK44UrjeoIkFQhbIQCUxHJyxY3I/vVZNz3AQ8clTSbwc631U0KIt4B/EEL8EXAY+PC/9EZSShzPJUtTRKpQhsYSBpa0SGxNLBWpTLCki1Ipvd0upJKxsYD2DpMo0SSRymVjQpCmCnQ+a8+OG0eUzB22SmtiHWEKgyiKyIImSmm2PpPhei7XXjvDc88V2L+/QBzP4Hn5tldJgTyux3YcF2GlFEsFli7L+NCHhnjmuS62vlDkwHCRT3x8L2tW97Cvfx7Lcfnad9oxDbju6gqPPd3KPd/vZe2qiAPDJQSKtatS7v1+L/sHPDSKvX0u9/14GWuXz3FotIvBzk2ct+kNXt+5ieGj3fh+HmppWBK3tZtTTn0LZAv790/zp3+q+MY3wDbhyi1w0sYJjo6u4X0XDPPqK4LhIY1G/jogXQpBEoPGIjMTTDvfnlumjTQSunscmlVFEuSwuVhqVBCjQgezkKBCWJiPcQogmpCmCkNqJiebWLZNwTOxTEEYKixHUiy6mEj8gkKTUSzZJCpiw0kZ136gxqMPljl8zOLoUZuPfqzGM8+6jI8WaYYhBbeI0KAdINMkaYbv5VpkhYk6rp1u1BRZqnEKZi5tU9a/WW2/l5UkKTYSJSSWJQnrEUhNgkHQjPA9gzRLkFbuiE2VzvlGJUlnp0XLcaY8yiAJDaIUTt9U5+hRi6EhlyTWpInBypURixaHbH3S58QTYj57a41vfcvn8KEi9epqPv6xPu6rFjgwUsg56ccha5V6jTCK2Hhag5884POh6xY4OJjR39/Fjl0dXHLhNP/4yw7m55Zw7pl1PvqhCb7zg8XsP+DRt99F6RQ0PPFU66+9AYaUKK2oVRZYuXSKo5PrqDRW8fqOlVxxzuO89tZVOSe/PM+ZV4+wp/V8vv2jVp54os5HPhKxe7fkqqtq/PD/XsSv3ox46x2TdScq+vpMhIAP3JCyZu00Y5OtTEz6JEnCxg0pm88PmZkS7H7XAE8ihMJlxoL+AAAgAElEQVSzHHSqkSonpiYxGIbAkQYlz6IRJrS3OEgBri2wW23QGVobmIZAyBTXlRjSZfmygG3PdjI+Iag3E0aO2DzxZCs9XQHxkIdKk5xtRJ5iZRmCVOUa6FxuLPF8jzDVBJWA9D0G3b/nRq+1HgZO+//5/Sxw+W/6flmUUXJc3LJLIw6phTX8liKVRkalUse3JJYMKFs2RgiepXGlZuNKgXQdxmYbOFIisKnVUsI4Q2uHczfPMTQsGdhn56JyBOtOCFmxMuPJpzy0yilJp5wEF18c8PSTJc5/X50DQ3NUpnPpJwIMya8BYPVqgOvaDB0aZ+myGX72C5ubbpzmV+9UONC/hHfebWHzueMMDJbZ/tISTj854pMfHeE7P1xGseBy6LDLwZEMdIrKNFufasklXAb5l5PW7O6z2bEz5ZJL3mDDmj7GppZxxsZ9TC2sJIgXEUURi7oOcfqqI4yN9vLHnz3MX/1viu/9bZE/+2ody0qwLNj6eBfN+iYGDk7w1a82uPeejP6+XEKWHwZLrv29mFNPHmV0vMzshIFKYzaeITj15Jg4nmVgVwuOaZBGAdI1cAxJAUnUlMwvhJjCRGaKONJIJalGCbYlcS1JFAS0t/gEZoTWEstzkIam5CkW99okCaTYrFlT4fkn25iatUjMjOl5jyeeEizujTgyGhMhkFlKI0hII4FUkrYWE1MK6mEEqcL1jm91pQVWLieszTXIfkMd/W+7tn/T5dk2vm0TRymNRpizyy1IswTnuEU/izVK5Ya/IIVaoAhjQTVUFIouji3IdIxpSnxfUalb3HzTHE881cbElMPSxTFXXzHHM8/2cMopRTZvStjxyno6ykWmvUGyYA2PPaq47MoBsmcFY5Mqz2QFTlwXsnZNwBNvnoCjUuozFW774ixvvG5y8sYqjz+1jGu2HMMvjHDxBfO8tcPP8cGRcTwoDzauD1izMubxZ9pyauvxQ6Oli2v8/MENrF6xmIvOfoy33trC3PgnOXP9O3ilfUyM3Ex15BTOet8T/EXHShavmuOlFwUXX6J4+GGb7dsX8tHjHoO9u8Gy85ScoYOCD34o4gwxxZNPdNPbpnj/dQ2EgLvv9mkGGs+StJQculrLBE6DRpjQ5tuU7ASQ9HSXSbMmnZkHSGpBQjMJKfoOOktIhCCKElAGRelgWw47dpTAFURxQKOaEseawdhisN9AuCZaZWgDbM9AJJJ6NWF2PsYyDXzHwDENLFPSaEZokeF5v9PBIwrbVMw1GrQZmkTHzMw1SaUiiiRWU+G2GOhY5+nwZkYtBK9YIBUWrpD09poorUFBS4tN3FQYvkArl89+ZpqtT3UxMuLS2xNw4wdq3P+LLlpaTJqNmPXrNJ/+wznuuddn/EiJlvKlfPITT/C9qs/wqMzDOAyO400Fw0eP5ltYLbh/q0/m+gwfmuWrt0e88soUp57S5Lnta7nh2hFWLm+w6bSj3PfjlQwcsEjSGK30r2l1EokQedCI1uJ4gLIiiUJO2ZBxy/U7eOGtD1PwBZ1tD3LNBU/w5lsZmZOwedM2XnvpLJJRweyB9/Pnf/4o216IMU2wbXj9NYef/zxAmC9Qa8R8/RsW605Q9PVbCJHHuyEUB4cFH/xQjfXr68zPtHLqaYLP3TqH1vB397lU6gmWjLE9k7JXIEqbxCojMzJsy8y5Mhi0l23KhTw5Cn0cC6tMpFD0LG1DZwFxrPAcl6mZCotafYSd0u13sOftDO2bGEbA9OGYRptE4XLkiEWcRKRKECT5jsNwbUyhCJsZzShXVTiGQRxqfEvT02uj8ZmuNmjxnN85BMJCo4LWPmhJKjNircgiRZYl6EyQkR13SSrOOKPJkVGLiWMOQaqpNpqsb0tYvUrx0stlTFPj+5r56VZqCzY33zhBX38LJ59U4403TmdhskTUqPLM1pg/vPlKzj17KT/82U8YPXKIqbmAY0d9/vizVearJn0DktNPFfzJbSk/+vEiVngGaZiwb5/Bc8/bfOCGOZ7f1skbb/Sgsio3XDvDLx9roW/A5bbPTnH333bRN+CycV3IbZ+d5lv39YIUeJZBd3sn0rTY8U47i3q6MHpPYGzQ59yzH0M0zsVq7aOY3saSFevJspSmoVh36i+JG+dw3nm7eGlbK5ddNsWbb6UMDJgIIRGGyKW8CHbvFtz3/SK3frbBdTfkRytJAt/8ZoGBQZOT1hboaXVIs5ggSXALNp3dbRgISDMs26CZZYQV6GkrkGWCZjRPLEykJZFIkArp50Y3aRq5018KDCVIMjBtE4lEJwKVZSDyL+44ABXGZAlEscIUgmLBpVgwMQ2DykLCQrWJbWiy9+jy/nfR6A0paW1ppexr5itVGllM7+IusCIyEYI08HybJFRUoghbSubrKVlgsLtP4XgWbeUSjiNIVRPLAccxybTi2IzNk8+3cc3VU+zZV+DUkxtse7kDy7c4+0yfhCInr00YG7qAxb0ZQ/tfIFno5eGH17FsxTAr1lTYsSuhb9DKxxxaceppmhPWaLa+3IvV0Ysf1gkrPm+/U+H9759i2/Zutr/YgpCLuOLiXGnz5g4FKuTaqxY4eMihf8A/3mhhw7oGq1fGPP5MO2kSo9G4js2JJwZ841tlbHeBk9Yu5o3aZWze/BznnzUIxhEmRj/GhSedAsvmaWSSxvQYN9zwFmEI998veP/7Y9aeqNm3L8OSJvt2a/bsUthOXoBK5QHUfX023/2uwRe+EPH7tyyglCbL4Otfdxk7ZtFelpRaHFp9k96OVsKSxfRMjXJLiZ6yJmkamE6BpUvbmK3M0FbOc0RDBaNH54lMTacWRHGu+lho1BGGRRx6lCxBFCsaKsMRknoTDAHzUymmsnHNBlkmcdoKiCQmzRReUSOVxdx8hdl5sG2BNDNKjk3qGbSnBknYoDFfR8qMUvl3C2o2M5OQlSOUUGghkVJhSSh6LlgSHWlUGqOEwcykzfU3zDE928LgYJG1q0M+/akFfvKTTqIwZaLSQGcK27YYP+bS01Viy5Z5Xn9tCa+9YhEFCwRBSJIqBsemuWnzufQu7uXNsbeJ04yBfoN77/X46leaPPWs5v1XZfz4R13s3p0xu3AQpTUnn5Jx6aUJDz3icuXl88Sxy/suqPPgoyWuvLRG34DLPd/r4sufm+b5l1q4/KIKd32njd27E7rbSyxbuRLXKyCzlFKv4LTVS1nZU2bF8lOwfcWc8yBm/UrK/ql0nXAaiXmAgYMv0lm6kRkeZmnHVzjtUx+l/50f8pf/6308ev8Kfrl1kqlqFd+RmNJEKxg+aLN/r8Wms3Mz80svFNmzB2xHYBcNCu0mOpFkjkIlJrO1JmXXpNUrog2NmyWYLT6JypiqhizUIxzXpRYmeKaDEDGeaRLqBMPOm3kSxpS6iyxfVMK2Gji+QDUVk9OK5kJCuWDlWApT4lkOni0oLnIwDU2aKjzHpF4JSaOMRpbhxL/DULMkS5lamME1bGIzQ9qS+aiKrql8npdIHD8hijSuIznrlComgoG+FjI0c7MVers1a9dkbH+xBcOQOJbENBOkYbAwvZT2YsYllyzwzjvtJNWT8e0SjdmQ+VrANx7fzZtbv0xn5x52vfMmb7z7JiNH5sl0kZWrA776lYSv3SXYv9/mvLNsvvgf6vzDL1axvrOFLKsTqYiuJXOcdeYCDzxgcs01s9RqmvPOmuehJ9rYcmmFgQMefQMew4cdvvy5ae75Xhf9Ay4nb0j5wmemuPfvevEdyZLuJXiFEpXZWd75VSu2ZbNkcZEVPUso6w7mRsfpXbsTL7mOS0/5APWpMfSiblJ7hJmkD4WDZULBPIkf/uAYd9wxyX/5axgZ8Uh1HtAspEakAp3Pb4jjjHq1g3ffDjjvgvwieOghl75+m9ZWwaaNPcTNiCANmajW8F3ByhOW0uK5TE/N07O0k0inzNYaNJsZS7oL2NJmeGISzxTEtotwJLaSIBJae3xC3QBiLNOjWg+wLQsry8dWhmdSdgVCgy0c6mlEVGviWpIsFjSCFKFiTMemvaRIgO72In7JwBKSoJIy34ipNyJaCzZB8N7mmv9Wa3lPAWlaBInCEhLXhESlpEHOSvELJraXEcaCkZEC999v8ak/mODZ5wKuuDziW98uMDws8DxNkii01lgo1qxtcP75NZ5+qsj5F4zxymsVpmfbcV0fYRs88/I29gzuo1Kr0VkqMy+aNOp1Bodcnnwq4iO3pDz8kM0z2xfIMo1fsNm4PuWOLyd8826X3fskOitx441HeWzrYn75kKB/sMRtn53gW3+3iOe2F7npunl++XCBqLGWT3/sfHoXL2ZovApxFac5zke3XMzSFatpW7aKQA7Rt38bPV23My3/niqXMbN7N5H/bdrs/wxigmVL/zPjE/dQtFaysfNMFgKbz9w8yIfP/AgvHzjE1lffZvfgQUBw4jrNSadVyFIJQnPBRQ1ee9Olf0AiUpuwkpFkKcuLnTgFTT2IGRmbJ+1I6HALCG0xcGiCllZJhsL3DJYu6iKOQ2bqVWxbEycCaRoIYTI/HzFXjTDaNElmUGg18W2b+UaDKEkxhMF8JcF2JR2tDjgar2DQ3e4TNTMKlgkio16NWWgqgjDDd9/b7lRo/d7kOr/N1d5m62uuXkYjiVGpTdFVGEiaaQgRmJ6J7xiEKiJuSLq7Dd5//SjfvMtn6IDLunUhX/pSk/vua2V0tMDMTA3TFIRRhudYnH56ymc+U+f114ucd16db3/HY2jIoVQs4roFQFIwDVasXsnO3XtY3dvB4ak5ZmbmUYakd1GV//RnCS9v97jwkoC//hvJnj0mlpPHAG5cn/Int4Xcc6/HGzsUH/+g5JZbAp58ejE/+mnGaZsMvnTrBN/+wRL6BhxWL53iji/VeGF7gauuiBgY/DCK09l/dB7SgGz6AGuWdHPm2lWsXr2a9kVLaVm8jJoaoK/vY5RbPsn8/I9w6reiopMwikNEzj2Uy9ewaNFHsAxJ38AfsFL+B5qVJqE4RGnhPA5OVnh16DDPvPEuO/sHCZMU37UwMPjQB1v58C1T+Ygqy0MsvnmXy/4Bj499YCNHR45hOCYrejtwnFyauXtwCmlmrFvRhggsUgm7h8dobzNRpiJpKpSWLFu0iChqMtOoYVsa0xJgm2ilWdTRw863RohVTPdKhyTOPRWOaVGwLfp3jTMfCWxpECcKwxZ0lCwKrT6ldptl7a2EjYgwhYJhYjoZcRPeHRhnaj5AZZqCZ7Fzx8I7Wuuz/rVr+73IKy+4pJMMTRbnh3IZCi3AcXKJcL2W0FI0cVwT2zQYGws454wKN9+c8tijLk8/1UKaKhIlckNZlLBuXcTtt0f5NXK4xLp1EZ/45DTf+36JQwd9TCs3ZqF1jiSJFY5fIogjzjnb58M3H+DFl1u56II5vvXddvbsFURRwPXXRgwNSdauURw4CKefYiOlTbPZYHy8wNLlCdXKIi6/3GDVymMY5k2o7CHS5E9Z2ns1bQWbdHKAcHqM0qoNSCmQpklT93N4+n9i7fJvULROptp4m5Gp/5nW0hZazAsp2qdTr8yyMDVGvfkWypvAiK9HeEUckVL0DYTbxt6d7zI21+TExeOw+OcADL5xGnGSsW7zTjKl+frXXcKglfVrfNJA0tbm0eL7mMIiijMMUxCT0FoqM7Uwy7t7xjHJCOOMnl6HufkIgUVLh4/lGmidIjOoVEPSVLN8RQuthQJHjs1hG5L56ZiJSkiiMurNDMuTlHybom/Q3eVimxaVqHlcomzSCGPCMEUKKHgmzz4x/s/qRWv9L85z/l3c0SOhEkeEoUkSNvBtj0YaEye57Mn3BbHKEJkm1Bm7dkUcHStyx5cbvPiS4KKLAu75Vom9ezWCOqAxDRvfN1m7pskf/VHAfX/XyuCgze5d8PnPVbn3Xnjr7YDe7phyyWOiGjE+O06SZhybFJRaW5mv1SlaJvt2K556WnLLhwJ+8Y8Gg/ttLAsQgjhNWbEi4WvfsNizVyC1QaZinnpmMVkaYVs2g8Nl7v1+xpLuad6Ytal1nkb/UIUbr9/NzMzldHVcRmtHF9dft4Ge7laysMnQr56n5DsUij6YkoVkF/v3f4pVvf+FztbzqLZs4sCRr7BiyT0szFcxK/+R2oFWZncNYrZ0kDav5Wj5V2xY97/gtLQTjh1knXuI5Z1FPnTJuQyNTfPA1hd44Z09dC2pcPMHJxFCsveVEzg63uDS647wJ7eH/Neva6ozVXraWwjiJpZr00gS5uamMcy8COfmMwq+RSMM8EomtTQhacQ05jPcskczDGlUI6pBRKmjQFwLidMEp1hk585jHBquU+5xWCpaiFSTSrPJmsVtLBxZYK6W4foeSqXEiUYrkDqhoQLau00m56qYBmRpTtSMF0IGRqapLBgoZYLUNOPfrTt6nUkMqXOli5m7Yw0LDCkwlcmKHh9hxQhlkCSCst/giitSfnG/4JqrQ/bt0eztt5BC4vsWprDYsD7mO9/2GdgPhtFg105JEJRZu1YxOe7xvgtnOXTI5NAhHxA4rs3yJbOcfU7EOeeMsv2VVby1cwnjEzN86QsH2PbKMtIQnn5+GUmS4BcW+LOvzPLDv+/k4EiR666ucfPNCzz5+Gl84PqL6en9Ea3lz2EaiqL/bUaPfYFkdJKZYAWiOYMpoDlm0LHpGqTtMzf5HKuXfxff2UQ4dwxHnsKK9v+T+ZlXiesGc2oHKkuwoyY9hTPxOzqRhRZSo0CjmRAGAZWhA0wO9PPawFEu/NOlBOn5hLPrkEHGI8++jvO2zzlnxZy4Dgb2WtSjFCkKBLGgvSwwDEXBNfE8m2aQoWWEgaBccomiPFXNxMYRCRkZC/WQHqdInGYkGThFi1bLJE1ixqZiYmHgWSYrlji0tlpM1APaU5OUhHKLh9YJITGZzkgTRbOZ4hSg0GbhJoIkybDN9wY1M+68887fapG+l/W//x9/dWe50yQMIpJIUWkEzFZCmmEGliDRmtHROiKTlIoOXlkwuD9FZSkfuDFk2wtF9uxqxTIlwsghaEmUkqQZZ50Z8dRTFv37HTzXJQjKjB3zWLUq4fCog0SDkLiuiZQSyzSpNGMsr0SYpXQtXsmppxl88MYFntjqcdWVCUMHBBPjCk3eePbvN5meltx4Q4ZpwbYXIIuW8NYOxckbQjaeOMmL2yS+t4mPf+KzfPSWE1m55FGOHDuP3p53WLX2A5y68WLMhWFm33ke03VZduIGHFuSVGcwbYPZuSfoEJfR2X05SVDDNJfT0n4ezca7LCp+lK7uDTiOiRQJ0cwhdNOhtrCGsalZ5qsBaWOa8tJFeGtPp+/QYWYizeUXXcwfbjmHFSdMYMgSR/etoGys48BgyBPbFxACpKFohEUsJyaOJI4jMbWkxWvFNWw6WlpxHUFgKHpbuxBmyujhBkYCUaCpNiMMM+LwRA0yi5LngmkRaUXJMYnDBGHm6p/u7iIre7qoTDRQOiWrKWYqeU6A0pogyjAsEMJCCE1Pq4tODYIoZj5okqmEIBCEWmBauUqkVDTp6PQ5dLA2fuedd37/X7u2//Iv//LO3/Q1m05rQ0qBZxt4JQvblHjSwHdzzokQx7/0EsGi3pCPf6LG175m8fwLktFDBrfdnjA0LDh8KCaNM5pRysGDNjOzOfQLcijfzIykvw+iIERIxR/fWmH4oGR+1mTjqQaf+tQU42MG+/d3ceEFYxw5bLO/zyAMU96/ZZztL3aQpJ0UikUaYStHj7r84R+MU2rxOH9zzquZOLKSU9ZlmGIjQfL/4MvrMZJViHobsTpAwT8VsghhFzDK3US1Ks3pY9iNLppHFlgY6WN6/y6a02NEMwnxKCTN/IwnqlYwDINUWkwM9tOYm8ZxXMoFj/aeRZQLBeYbIY1UsH7JpRTkORTMRfR0L2bp4qUcGm2w/Y0mE5MuPT02qaEoFX16W1tIsoRqGNHMMuo6IhIplVqTJIuRKExTooA40yRZSqYVXR1FHENTiwKSVOUYbwRxljC/ENGMEqQG01AkKmO+GdHb69Nbdim6LtLQOVocQX0+ysNb/sn8oKBWyYPWDw//c6f3nXfe+Zf/Uk39uxjdFAqm3nRWO2GcYaJIUonpSISZYQgoWB7lkovhhpR8n9d+NUvJq/EXf5Hy5FOSa65WfO/bDvv6HRzXye3jmchxoFFMoxlhiPwuxTANHDeHbjmujec4bD5vkpERgwMHXchyR+HiRQusW28yV+nkox85wsBwL/sGFoES3Ph7O/jZgxupzEyxfEmDhx7JSXMb1wV89asp/9d/lUi9lkLbNHfctsCrr6ygs+c2Tlh7Ap0dRwmCP6Ot5TpWrf4OY/t/wET9Tvy5W7BmPGwpoVCk85QLEE4Zp30Zhu2SJQmOXyLNEpK5I7idKwjnpwmnj6Jqx9BaodKEqFHDMAp0rFlNoXcFC1OTTFdiZiZmiBYmSarTpJVZfvr8G1x5/Q3cdNGZNKfGaKQmP334AR5+4S3qMiWNFc1GQrFY4IyTixRbM2amLApFxYYVnbSVSoSNgJZyKypKqDQDepZ2c+DAJNvfHca08ki0opfRVXKZmmmCIWkIwYolXaS6iaUFSabRVoaLieOAZdjUQ0mcRaxpbePY0Xlmo5i5IKRW0aRWxrLFZXSU0rnIQcX5c7UBYRDgFosgDUypqVaa2LbAMQwe/sXY78zo5oZre0kyyFKBknk9CqURCCzTINMp0pRkkea88xscHJa8+rqispBgGnDGJsnqtZJHH3PRWUYYp2RpitLk9npDYNu5E1arDCkN0lSxZk3A7XdE9O1ZwkmnjvGzBzfyq9dC2tp9Tjgh4GMfOsg773Rz5plT3Pe9Vt59N8axbDzfB0OiM8WNH4y5/LJJnt/Ww96dKbd+tkpQOYdC25vMj3+czu6rUPUp3HIHrl9GJHWyhUkM22fh0AGy+WOoLMNybFzbpLHQIFYaLQwM28UQCs/36Fy+GksoavUGU9PzREGDJStPYNGKNTjFYv5c0wLDYmZugercDNX5Obo7Oyh4PkLD0KHD/OL5J+if7Ke7y0QnAt/3KPkG9WaMYzoUPY/5Wh2toOjaxHFE38AkhbKP6xnEMQgUUira2nykzJiuNNBKkCa5NNt2LZoLeSi555h4lkEjSBifC2hptzlxWTsFPKpBk1RkSAzG5+YRWuE4NhgGYSCYnGpSLArefHXun9XL78zoxrIkjmdimoJiWf563io1GLZDM4ox7IwkkQRNzbJFIZ//fMrXv2Gyc7fg4IDBbX8S8427NDvfblAsOnlggzRoLXh09bQRNEOSJMlPr6tNkALLMigUXUZHLD796Rl+/rMeBvbbbDjF4Pdvifj5TztYsrTC/fevJMsyPnLL23znOyV+8INuzjn3KCfftMADj5zMaZtXoZDUazV+8cAR/uLPB9mxT3H6xiovv7iI9100hojHOHX9FqYr99NsKIzkbBYO76S2awIjex8sn8DrPB8dhdhtXWTSptC9Bikt4qCGzGJmJw9jJFUqh4ZoXTHO/MA71KbmwHYRpo1KI2wdY7V1cuj1Y8TpC3Sfdh7Llq1n2eLFyFIXh9/azoM/+3sOTla44OhhJo8todTaSzo/w/mnbWZs3uTpt7fjFWyEISj6Bo5lMlOPWL1qCZ1+EUOEjM/MI6VHM6nTWjZYyCY5emACyxBccHYX01MLzMynxBriTGI4OVmz1XGxSQjikCCDJBWYqYXtSaIk5ejEHM3MoqPsMlWt0NHr4IcaXVGcsLJMUG2gXBvZatBMm2Bqim4Lk8eqBKGBTkNix6StZGJZNrVmRmb9bskrwzBDCZEHgQuRkz51BokEJUDq3PCmJa+8VCBIUkwrwbZNTCE4dNBlfMyntcVAZQktAppBRBilRHFMnGREUUqjGeM7uaLNtCVDB0ze/lWRSy4/wjPPdtC/N6OlrQ1paoaGMl5/vcyVV46z7YUuDgyaKBWSxhFeeytOwWP50gU2b57l5ddXcu7Zo7z7ZoFXX/a54qpXeWlbN4dGK2Txz7BEQuviVRRae3BMA5GFENbQU8N0L1mBECm26VAqtTE7tofGwhxK5ZF7QivQisLwKG1tJSZmKwRxRqmrmw4t0KZFnKR4JuTMSehpa6FsCSZQHDlyhEVdXZiGgW+ZbNl0LnJ3xsGZEUwvI0sbzM8llJx2PGFgSEXBtonSANOC6VqDYqmEV3KIZERHWxvChmq9QlUFeRxmBmmUkKUmhmGhdQxK4NgOoIgSje+b9AifJIW5egQlgVkArTS+YVIbSUh0xtJeD89ySJsZUuYTjfey/l00eimg6Ei0MrClCa6iMRvjGgJ0jExSKnMpSoLpGZyxyeC7f+syuF+g05SBQYvvfsfgxBMUu3fl3I8oVigSatUQ0xCYloHn2riuSaGUZznWag2mpyu8MJ4xO+/x5dsnePVlj4suifnhz1fyxvZJTjj1VITtY2QZj2xt4Qtf3MsLz6dsXN/kW3f77O8fwfcnkYaB45fZP6d4860uLrt0iBdfW8WTj2uIzuSK3/sub726Hb9rL23mf6K1+xomdzxD25lXIdMLSeMGzbm9GKaH33siw69tx06fJENh2S6WSAjm5whiAMXk8CCpyvAtTanUTql3CY2xUez2JahCD1N73qQ+MYZb7mBuaD/dy1djlzpYtXIlt97xH1m67VU2nLCasflpmBth9cqlnHR6J6dv2sT5207k24/+FGlJ1p/oYBYTqGnmGvN4dkqapkRJgnQUtbGASc+j4HbimookaTJ0ZArH9ym3mozNNKhliiBWZFpxQk8rBdtguppiehZZkOB5FvUgIiEhzSRkEY1KhlNwCKKAqdmM8YUqtidY0lPEUSXmm/MEDR/XNSgZLkeTWcotJkJpCDO0ZxA2EhqzKdnvlrqSJBPYnolSudchTlSO2lY5c6VYlDQaecMzsXCkg2k0KPgmhgKdKhr1GuW2VjIE9UZIlmQIpSDLiVwDmH4AACAASURBVKlaSpTShFGKlAqv4LLx5IQzz6mzdWuBCy+co69PMDgwS0tbOytX1Tn//CovvbKYc86don9/Jy9v1yhTUCgWWLsx4QPXjfPgIxs4NNrG3h0BX7xtCoFg65MlLrl4jrHpAxw8aqMQ2E2NW5xHak0UNjGlwLEcnJE5TMPGdsGdnSOtC5JaiusVKRcLiDQhqVWwwhrZ+CRTcw2sgstiaeAfGyVJUzzPo62jm2K5DSGO+1LCENeycSybvqEhFrW3MD0xRa3eYMvp51NhMwfH9zMXVdg7OMhco0p7q0NXt0Wr51OdTYmyKsqCnsUOs9WMIFVMiyZmZFCpRHS1F4gaDYgEZII0hkamsHNBDeJ4Mp5hKDzHwnc1hikxTYmhJVgmtnLIMoUUPr6t8P1CHofqxpy4uMj4ROM91dS/i0avVJ64kmjB/FSIMBS+YxIIRX0+ptziY6BwHZNarUH/3hLVeoQ0Ahw3Z00PHSgwOlqkuwuyNMLxLBrNmLARkCSKKM1YqIaIBYVpVSkVfTzHpH1JFyDZu2ea8UMbuOb3+tj6VCvzjZMpL+lmenIar+AxOzJMsrCCt7pbue76abY+Xvp/qXvTaMmu6s7zd865U8xvnnIelFJqSA1IAgECCSEwIMRgsKEwUNgGDJgul3Ev0/2hv1R3L0w1GFtMkgBhZGZJIIEwk4SYJKUkpJzfkPnyZeab55jveM7pDzdNu7y6XEZQC3t/ifVurLgvbsS+O87eZ+/fn9NTHkkWQbtLtVYlDuvs2trgmqtDHvnxCNdeO8+TP/M5Or6Niw5cytYdB1mavY724LU886VPURsepag2KARlRGxQ5T14tQGO3vP3JHMnKQ8NkqUJaRhR6O2nb6BGa32dVgrKj3CkYMNqCvU2Y8KlUCwxe/IkMxMPkjqKHRdezsCOiyiUKhgBVmc0WpuUKz285daXEycxWbaFp558kqefPsxVBy4j0/A7L7yeSqHIh+79DKGTYTouBV3E9R3W4gabzRBPFdlT6sMp+kydXqRWCKjVfLphwsy5Ln7ZsmV7iXLJw1pFz3AvrmOJhEA4Gq3y8X2lHDY2O0hHUCoV0WkERpEFklaicVNFbCK08Tg71yXwAsZKBp16DFRDpHGJ4pBC0SFqxxSLAYNlj/paiokLbGyuMzLs/bZd/FcygUJrgQokMjOYNJeWU56D6zr0lB1KBcH6RsjqWkwUxmQ2pRz4KAUmy4iSlLjbIY5Tut0Uc15HQ1hwBWTkUpBa5909+w7E/Ml7Y+78dIHxScX4ZIV3v3ODuz5XpVyLeOPvzvOFu4dZXh5g5nSBt7/9DGtrDsePWlaWVrjuhfDVr29jekZhbR1bzqfQj53o4TvfKdJo7eI1t5zggW/s4Mz8IJgMm4boNMQREik80iQhTpL/D7hnBOHmPGG9QWlwGKeR4Lg+nt8LjuTAlU/TfGqTiUmfnqUGj4+f4+LLYNeujO4T1zAyMsTAwCB+sUwatrFGo6OIldmzTE5E7BnqZ21lhfV6nec97zquu+hy+kZ3UI8inj5xhIPP/JTZjWO02msEQYlGu0Hg+2yG+f4PHUmqI9pRfq3NlTZRrAkcgdDQVygxu9rAphnGEzhKYiwk+jx9VECcpfRWiuhQoxIQSNpRythwBWFiNtbaFN0Az3XpqXoMVft47Bdr/7ID/f/51L+FGn2t6trnXddPklgc5aJciJMIg8HJPJQAlCa1Asd4dMIuoRGszEUo18UFquUiThCQWYU1KTrNKFVKdNodQi2IOu1cojDR6NSgTUbRyzcX/aLHhXtj3v+fDEeP7WD//mk+//l+5ld24xUKpHETaWIu2NXl935/loMH+7j66lVu+1jAiXEHV1hGR0c5cE3Ara8e5xsPXsLC2k6Ge2Z4/S3H+P73irzsd0IOHuzj+c+vc+99F3D8ySZb915E0DNEqTaI7/lYHWI6m5TCVUrVKr2jO/CDMiLt4heKFEs9rBx9jMbCPK7KWcMCSxqnFKWlt7/GUj3EOB6lvn5GRse46MDl9A0MEXdD+gZGkK4Ccj59GoVgNcWgwOT0NCpLEVKysbaJ4zhMnZvhKz//Pl3bpjxgkRjiKGOouoWSlFSrFrQijjSp06Hi1ZheWiDrFKj1lFhK1glkwEj/MKmKWFvfwNqYJDUQSbI0IelmSFXGcRwQbWyscL0CBd/S6sRUix5ewdDuGOJY4FclvTWXWrFIO4rp8QPW1htMnq4T6ozh/iIX7BxmabFJnDosrDbZvq3Ed789+++mRn/L72wlM5okNpQKEpNpEg19wyUGyi6ZtviOQimfb/3wLHNzHYb7i9QKLtYYMpORZAY0dLIMKVWuO6ptLptn7Xn95fQ81tjyhtcb5uZczp4tIB2F8ors2dNl184MPygwN19galzgBkUKpSpbR1dR5jQPPOCglGJosJdiTw3huOgs5bpr51larnDmXI36Wp2de3exbes6A33rPH5wDMf18QslOq0WSjpUyiV0lmGBNIkJijW0LCJthrUpCIWNWlghEY5P2m2yZesGt946wSf+JuDkVMD+izXvfl+Lz366h7mzZQYqJcZGRxgeHICwSRTH9BbLFDyHgyemGOrpYahWod6NuPLqa7ni8stRxQJ7Lr0Kt9pH3GozN3eah390D0+d+Bnr3SbLyytkoUdff0BmXFrNGMeBQlFRr3fpqTjITNNuZXi+j+e6NFpdgqJDloHE4jiGQsnHCmg1NL4HJVfQ21NGYcmMwK86NDdCWu2MeielVFCMDFfprxb4208f+m/85V9To/83EegrFdfecNMY3W6IiyTODHF8viXOADj01hxarQxhFLVClXqWMH16heH+frr1FghBrFMGhwcwmaXeaGMsxEmKoxzCMMqdn/MakeQo14IHz7nW5Z3vbPO5zwYcfMJw5XMKvOdPWtzx6YC19VG0kOzZ2eWtf7DCV7++nbnlAXr9ad7+jnX++qMup6Y89l6wm+tf2mL2dMb4yRr9o9uor65w3VUnufl3Wnzyk33E5jJ2bq/z6lce4557dnB2cRhV7CUolLBpQhh2cRwXPygilELovLbseWW8wMX3HOiuY5t1RraOYeI2DoLu8iJF36Vb32R1o4MMXAYGetm3exeDA0NUan34nsvA0CjFcs8v5QWllGRJShh28LyAnx58jJ3DA2yurnN2bo59e/biDw6x2m1xeOoxQmF5+tgxOvWM3lqJcm/Cnu0jmHbGmaUVSlWXyBpqXsDquqGehbhujjIIPMXmZp0twzXqmy1s16BU/sMRpT6JhqCg8S24jkOpWKDRaTPcX0BJiRQGx5VIKXCkTyYzhFZIBcsbTVaXLVZkDI+WGOursbG6RqwNRRkwc67BwUPr/24C/ctuHMZklsxY3ILCZJowTHE8w94dA6w3DUknZt/2CtK4PHp0ndmFDn1lD5tpwKCFZbOVkFkoOIoos7hK4iqJ0YY4TUEJksQglaLogSMFge/gFX2kX0LInDtfLZVxiwWSKMJxPBzPJ4lC1mZn6XRjMp0xMDyIVyzhug7dbpuwE+EHBazJ0KlmeMsocdglS2Mcx6FYquRaqXFCGKYErqBc8OnGGikE5UoNg8Lmi2VA4ZABucq91YbFs2cZHl7mj9/X5pGHPG64KeHOT1eZHHfzjACB5xcoeC5lR1OrVCgV8gnr1WaTbpSwf8sQURIztm0n/+Et/5H+wWGM0mwuL7Feb+AVyzQ6hp8d/glPHfkes+fqWAt9PQWU54BJqFWC/H2ZnIoZtmPaHY3jeICl5Pu0ohA3EBR9iaugXCmgcWl1NSLVJGEXt+hQLEh6yz5LmxmeIxCOIUotnTCmFDhII7n/G7P/jb/8u9mMFUIQdXK9USUyglaud4pycFwH31X0lBx6KpLDxzY5N7tOlMVUii5Sa4Ig/+IjDd1WhyRJCaMUQZ6aYvOVjCsVUuarI5MDLtGJYdtYzGduL3FqyqVUhpkzHn93l8sFF0S0ogrddpvhoSb33reTU5OSUs2ysjHKJ27rsOeCjGPHNXNn53jo+1twvBz9W19bJks6KM/lS1/ZzdTJkO27LQvzvdx/zyg7d6bMLlh8aXBsgtUdqoGDcBzQCSaN0RYcp0CnvUIYutgMuvV5hHSZjxawaUyxdwjlDWOlQ0LGvqunOTWtmJrs8tTJBXpqPezfn7JjV0rn6WsYGhqgv3+AYqWGzlKSsI3vB0TdDpsLc8ycOs3+rSP4Ah7+6U957rXXctXlV3LNnosZ3LaHjXabo6cmeOIXjzK9dIiTs3MURYFqfx8r68tUSmVW6hrpCUqUWNlYp1qy1BsWJRWN5SadKKPgKITWoCVbe2ocO7uANALtQlkKsiwhzRIaoaDmBhirCdOUvmqRLMpylSIpqIcRvX6AM6TwZMriehOZethYUCwH1IoeV+7fwcFD679tN/9XWzc1oAXCzbO1qJ0SKEHRDVha6RJ2BVuHe9FZL/t2bsPxWnyve4gs7uToaWMJI02sLb4SxJlGCUnRcXjVqxNOTksOHVKgHPAz9l+Usm8f/OjhEo7voLwgl30UIsd+mIy41aFTb4LJqPXWQElqQ/30KUnUaWMdH200yigkEs/3cDyPLErBGBzXx+gUYzXKcZBSIbBIkaOPkySliyFNM3zX5aorp+npTZmcGGF2oR+BZnh4ib1756lvevzkhzXqGxtsrDs88pDPq18X8a37fI4fAUhxlAIpSeMuSQx1a+gKHyfUhM06UgmiJOXseh1PSVheZOLEYfbt3svGwllOnpzgoaeOsBJnlId3kVmDTgpkegMlHVxXMNBfxJVuHtyboAVkWUaYWcrlHG3QaWdEWYp0oVh26Cm7mCRDi5Qk0xSLEgfJapjvYcWJIYkL6NRBC4tF/xKT3uykkP72xMF/bctxn4bmeoZbUpRKCtvSGFeyZXuZHk8SJQbfkXhFh+MTqwz0l/AdFx2nOaTfZjhA1ArpZBlIhSKXy0vTNBfLViJvk/IVjTBBCEGC4N6vw+BIgFSGku+h3CJTp1POzJapVKFUrXLwcY10FYVKBScooZIux49ajhxSKGFpdSOCtVUq/X0Ix0FKgbGWn/58GKTC6BCJwUrJ1JkKJ8+5SJWShU0UJZqNOo5yqVbL6Exj0gTpuBgdk4UhlZ5hEsel1r8dKwVEbTKhsVFIiiVpbWKEZGJK8u73tfj0xw0npwIqI5s8/1Ut7rq9l/lzP2egXGJ0ZIjR0TG8NELrhCRN6Xa77BgcYPzUSVZWV9g9MoQ1hsePHmPnvv0UhODs/Ckuuvxadj3nam655Q2srq9x4uhPufebt7ORNgiKVeaXlkm6PoMDLsqpUnQDorbKOSAFl9XVLv09PsqkKCtpNCPKlQ47R2ts1FuUCz5xbMnOf2dZlNIUCq0z2g2Tj4yjGRsZROgEVymkKxnqUdTXYvoLRc4sbBI4hl4JxWqRvt7/GdLI//Ms7mrKRR8csFgiKYkySyU19JR9SkWP1RVYIeTJY4eJw5A4yXJd3jijk2pSa6iep3ZGJu+dF9Zwelrynvd3+cztFZ464rJ/V8SffyDjIx9xcjF3zwOR/18lJIVCQJJlOYPJGDB5y3JQLpIaS1AqE/g+qYUkSsi0xhjzS0ET11XoKGJ9eZE0SQCLlJLmZi5o4gUeQrhoA+1uQuAqLIqFhTLXXDvOvn1LPHD/pWAybnnNOAB33d7P6vI6ILhof8oNN8U8+I2AG14aMzXuMHHCAZtPeOfXAlhod9pgNFmmc+Sy1tSjhL5ymTDJmD0zTXdjlVMnJ5icW2Bifp3YK1LS01QCSaEk2LW1hpWW3pqP7xqsFthMEKUJtd4qpBntpiVNDI4w9NcKhDpDC0WpqDBCoB15XtM3wfUlxgq6SYZjU1Kh8IgY3dJHmiRkiUOznVDAoxuHNJvPSi3t30agt9aSdjUYS2IMOpWkmaXTjUhPd9m/e4TFtYSoFfGqa4fZ1l/iocfnsTbIf/WMQUqB5wk2WwmpsSij8V2HyOQ1r2rBxVqDzgRxkhB4edoKDo4H3UZIqezmyFQESnlYKcFYglKR3EFd/CAgs4B12LZ3O43ldbphSpzm7BUjJIp8srHb7RD4ZbQOcV1FphPaG01MakiyDpVyCVyPJGxiraHVbpPEHarFACHzwZQkjnAdD6sTyCIyY7HCwZMK3wtAaoRwcCs1Fs6cpr7ucefHy7znT9v86IcJN96c8tlP9zB+QoGMqHciztW7lM4s4YsMB0s5cCiXKnS7i0TacPjMPI7IU/mzM6c5PjXFG974B7SjiI3GGt0zU4SdkGpfHwcuuJzw5X/Odx//IkeOP0pr00XrjFbDw8g6WhdxZJP+3hraxuwareQkwDYkHY1GEMV5L/LYYC/1dgfHs+QayC7lgqKnt0qUgOtrTJxi4y5nVtYZGvQZHi7RaqY0Ogbpu9Qqhr29LmGc0Y0SOkmb5mL7t+rfv6oZYSgXFFooojQDmw//bXZTRvqLOL7HvY9PIs6X3wq+Q09PgYqSJNrkQzyZJdW5BnLRUaQGpO9w8pzLpz4J73lfi30/LXP9C1P++iMuR49KatUcImxtHoyFIO8KMRLHd5AiwJUSz8sZ715QRMicm+97eXDNujEAN7xog7nFMrPniggV02012b03YueOjB/8oESnHYGAoeFh3EDgeR5JlGKRCOlwdrbCN++9iNf+7jivfd3R82pZ8Nnb+zlxBLQ27Nuf8s4/bXPHbUWmxl0mTyje9f4ud9xWZHJCkf+4nUeNS4HReReTFJClGWOjYwwODdFtN3EqFc6ub/Dk4aNsdCOiVCOERNqM4dExhvtrxOEK/dUS9fY6xnHoxglJqImjPCupN9v0BkUGKgWQ5DqvnocnQ7QjkcKh00xJUo3rSnQs0KkgCCyu6yJMhlIy36uIu3nFIU4p+2U6NqNYELme7LOwX0dh6kLgq//k0G7g/wB6gHcCq+eP/+/W2u/8S+cyFroxZNLgKcnySgdfaALXoeQXmZltEnYE28d62LP1Ui65sIfVzYdZXVqiWJAYAS7Q6mq6maGgBBboZrmye+Aqyp7HTS/vcHJa8tRT/yisoblwX8LevZaf/aSM8jykW8Bag5AKYS3aZnQ7XTrNFp1mm77eCoVqlVTHSOUxsHUErKXbrCP8AplOseS1TikkjuehuzEYQ6FUQ0pJmgh0GFIsFPM02eRUxjhOSeKYSFlcmU8KZzojKAuuuHySWi1mamKUcwsDICUDA4vsu2iFVt3nZ4/0s7ayCkIwMe7w44d9bn19xAPf8Dl6xCLOp7NCKXQc0kgisvOoZBfYdsEQp87M4HiKRhwxu9nEdxXCcZmYGmd6ZoqeQpHO6UXOTU/xvZ8fZHpxnmBwG327nsPKIjhU2Gys4CpFXDSMbC1TVjUQBo3GhB6tTkRqUrqRxS0KdhRqSNcyN9vG1KpYCY7nMjwSoNsRUrnEukNiXIoFQ7k3YH0xRrkucZxhYhfdTjm73KCnr4B2QjzPIbGWbhqy0jao9Lfn28/GRnoDXFeQRJZmM6HVzZBIUmOYW+3SU4Ny2aUcuPT2eviupFzxWV+PCLMcYaxcRWRyiceKL6mUFLLoYV2P6dOGH/9Ic8utLb7xTZ/j4xKtNVGsKWmLNAbH93jxi9bZWM+YnHQRKmen79jdYdcujdGapdUaS6sjCESuybqtwVB/g4cerjI7V+Ctb5nlq18b4/Azlu3b2rzznV3u/EwPiPz+RBs2NxsUShmu65AlCalyiKIU1emyuaQZHunnxpvyj/vBb3gc+kWWi6dLwc49mjs+XmLqhIsVMDHhccfHYcduzcREHuTz+n4uSGOyLG8xtSBcH6dQZLVeJ4pDEiHYqK+iw4SxkS0M9fYxfvo047MLlIcvxu8ZoDnzPZphSCdStDoJ7W6T/p4SpbJP1O7gSRAywTiaouvkJSovI440WZpitMaYHCaoNfTVSmToHBDnKxqtNlIIEJKkmxGnGUIKapUC5ZLFRilHVurPyqd+HeGRSeAKACGEAuaBbwDvAP7aWvv//GvPZYz9pY6l64LrCdJYYlPo1xa36FMqKEgrfP3hGZJulyRMcAIXlEZElqbO0Fh63VzcQAlB67zOY+AAScr0tOA97+/w2TuqPPaU4KJ9edr64Q9LpF/A8RTaGgwCRzoUil6etsYdkjAhjWJadYFyHNwgX4GkWlPr6aVQCIiyHCCltSaMkpwtL8B1BGk3Zn15AZ1lgCXLUur1OsI2QEmM1UjrkCFptmOUyEUjAtdFa1haKHP1NWfZt2+ZBx+8HB13ueW1kwB8/jMDzJ9bRMr82i+4MOLFL8nT2Rtvipk84TB5wgGZ1xBzrdh8b0TrnP64vrJIO06QqUAbOLOyRn+xgHIU09OnOPWLR6n29jN5+BcsrKxwaGqW05ttqrqGnv4GfsFncKDI1tEC2rr0VqCoNIEXg3TwpM9Cs8nwaD8mjVjb3EAmkuGqQTiW/fsGWa23EcJSrRhwFCLwiGyKKySZjiiWA7IsZqPdRktLfyEgLFsGtoxS3mLptpo4boVGN4Esoxb4RK0oF3n+Lfn2s7FCySFQikxAtGrRWhAELoGn6CYaP9FcuX+QShmKZY96PcQAmTWEqaFcCBga85lf7FJfj2lmloLv4hZ8jHDYv7/Fi2+IeeCBgJteElMqCn7yE8nkZN6v7yjB3j0hfb0JL7nhHF/+ygjjEy57dnV485vWueuzPVhr+ON3neGb33KZna0yNrzK6187w91fHuPGF28yN1/kC38/xtv+YJ4d2ypc9/wOjz2qePJgiuNajHTJrCXqRLSabRyZ31dhYtBaYxFccZnm2udFpHEer298WcITh2Bq3EMpyTfvz9HhjuQ82gGOnXA5cjTfi/OE4mWvijg9LTk54WE1OMUql17psXt3yg+/36DbaiGlJey22TE4yOUXbKMRJ0wunOXM8gJh2GZ+Zhw5NkTYWWF5Oc6pqNUynY7FUyGFfiiWXAYKBYzKyKzBdSRSGVppiDEWshw7IaSD1RlGCbpJgjQJSjqEYUwcCkySkRlDEqYoYfDKRaoFgcSwWI9JtX5WPvWbKt3cBExba8+el1/7lUwbS0/JpWskjhG5hmOcEiUp9Q5cNlxm3RS4+2u/AGNwPQWZZPeeGkJDrE0+Jp1ZtLEIZXGFoOoKNpJcaJeKz7GTik9/Av7kT1vsvaTC9c9P+dhHXY4fF+zYofjHj1CSM9FdR2K1QCqLKHlUe8cQOsP1XZTjo3rK6DgGRyJxqZZ80iShWe9gbb6KeNELVllccBk/WqTTrNPYbLD/EsPePfD9H1ZoN9pIRzEyOoJwDApBkuVvQGjQmabke5yZrXL/fft5zetO8OpXP3M+lRV84a5hjj6Voo1BCsFFFyb80fu73PmJElPnRcL/5Hw6e3LSyaXbDGRG5zVUpXLNyvNpLQZsliILVcZ272FzbY3tu3exWK8zPjHFzOI8xxeWWNloUq72oEyLbSMu/TWPZpIwsLUfK2J6+quk3RSjEuorCVhDnAo6saY/KDNWUqy3WzQ7GW5H4lQ11XKBzGZUSi5hGONKBdYBHdBq1AnDNrWSD05AoFJakaZQ30QpSB2NCAQmlUTtNoISjnYwOqLVfHY3x2/Ct5+N+a6Li2TncEDBlTRDTdFxKRdcLrp8iXZbMHfOpxtHtLohQ1tCtoylnPqawGhLrdehOihZXM5XzmGk2Wym9HqGnbsb/OE76nz0Iy6HjlieeMLhgx9MecELDB/6K8HikmH//oy3v7XO578wyDNPubzjjxZ59LEa1z2vwV2f7+f4MU0Sae68o8I733WSxw/WuObqTT7/d0PML1UxqeZtb1vk7r8f40cPB7z61gZxDAcfdXGlpFoIGKiV2D/Wz7atQwzuuBBhNK21ZdbDlFazgePP8NLfncYYuPf/lAy7iuf9Rcpf/mXK3/y1w9HDeWkqTFIs4EqJUhLPlThK5lgHAWfOuvzJ+1vc8XGYOdvD828a4rWveoavfHEL9eVlkkzj+QVqtSo6g8Pn5jkxP4sxGhMblMmYOvQonbUCo8OSof4eVCry51NFN0pptqDWW0CVBS4OPY7FdX0sGbMzXQaHfLqxRbiCWsGl0TIo6VDyy+hOnfWWxliJ71tcXLIoA99FyoSk0WHRrCEDj0LZ5abn7eOZZw7+yj71mwr0bwK+/E/+fr8Q4m3AU8AHrLWb//wFQoh3Ae8C8H2JIaPi+8RpQhhlRJHBcRxWu5ql9YhK1SEoODhCUvRhy1gN5Xo0ljdIsGTaEmX5o0wtXccy5DuM+ZA5AqfkUxU+xyY0jzxsePVrmtz3TZ+pKQdjM9I0xVc+WZYSlCoYq3n+dSvMzgbMLfRh2i06nTZXXSkZGa1jtWZhqcbC0gACSZKEbNnaYGysy3e/W85bAYVgdi7grW+e5bOtXo4fhWuuK/IHb1nlrs/1orOUKDWU3FzA2FMuxVKAaHaQQqCcfPPYcV2MMZyZqXL4ma0897pzAPzDAwFPPx7n7ZJAZgzbdqfc8bdFpiby/YZTkx53fkKwY7dmctJi9XkqIpYsy/L9DSWwWYKSgrDb5eKLL+PSSw7w9NFfEGWallD85OhRTk1OI4o9DPeOUnarTM6dY9vQKDuvvgkbtpD1CbYPWmYXZ1lbC4nDlNSGJB0PazIKnmZtfR1V7aFY0JTLJYrFIquNLoO9JbrpBtoXCKOImuehUmlKTzXBw89pjTqj7Lu0woz+oo+SCh1GuJ4iVYrG2hqDvWMY67O8sc5gfz8Fv8Xxo88u5f11ffvZWFAsIowkji1b+mtsdRXCEYRJRLtZ5oU3zvPtb/cRN2v0V9Z40xub3HtfP0JF58+gSWKJTvMpWGOh3UlBtnje80I++hGXo0cEmbYcOgz/1/+tuP56y198IOWhh+rcfHPKXXcNcPpcCRvBzx7xePmrNvnhQ32cOVfFL8WkSYNfHIy48MKAV7xyg/vucTg15eKVDJNTHl+4dkcvRgAAIABJREFUe5h3vH0eKQ1JIjA6L6EOlXwuGyiyZ6jGaEkwWIa9F2+h0egS1iQ9Mld2alV+TswABx91mJgZx989gpreihqc4T+/ucLmtRey3mjR1JLJs0s8MTnDSr1FklraYUzgu/RWSiytjfJ3n9/gXX+6zI8fzrjhpkU++bESx49uIBw3L60ay/zSEgsbJZ6/fw8wT//wFtAJm4uLuMZSFJKC4+F7CZddNsy5pRXSRKIcn04cYzdcTNJCOALfNZRERhgq4rZi1UtwFaAjAi9geHAAT3roVPDTqTnKvTW8kqaED6mhGxr8okPcigg7KYlu0dUuI0NVPPVbkhIUQnjArcD/dv7Qp4D/Qr7Z/V+AjwB/+M9fZ629A7gDoK/Xt721gMXNjLmFJt3YYC0EuJg45fRSm1IrolbxuPEFo6ysRIwNu5xb1axterQ321jrMDzo02gltDuGbmJYd2F7f4G8HqSIUsNVByw3vCTmO/9Q5qU3daiUMx55WLC4pPEKiizpsOsSydYtXebnarzxd8/yxS8nTDcCLtgb8frXrXHPvdtIo4Q3v+UMX7tXs7q+lb0XJNx6yzT3PbCH1GboJKfbTZ8q8pWvjPCHf7TI978rufllmttvrzB92kV5Al/F6CTj7Nk5SqUyjiPJtEZaCDwXayxidR2lHC7Y1eayy9dJ4/zmffFNIceOOpw+HSBNTr373ndLSJ0LZlsBBsOJEy4njjnkpU3xyy4ER0qMzcXCszhFJylepZdmkvKtH3wHIwWDvb1MnD6FE7XYvm0HF+7cxdjQMKcWlzh2+hRhJqhtvY7FiYOsrMzSDiFNFWFoWV5tUCgZto6UKboBG2ubDFVKVIua+c2IiudBu0F/X4EOdTqpJgsTrI2R0sMrOygjENZlbLRElMYkiaJadmiHMYm2FBC04gwvs6RphAE83+A6PpViD6ateXR64bfm28+mjx5rCRwPx8/H5f3AJUwShGvZqFf54SMZr3zVEscmM/Zf0OTzXyixsGrxAolUEm0sYdPkcoM5LgdtLa12xDfuEWgryDTnLwOOHJEcPSJoNDLe/KaEr39dMT7u4RQsl13u8IIXxfzgBzWuu67O1IRiaipACMlVz3G4/kVdfvjDHm5+eYONumH6rETbXLlMKYvnwc8e3crxJ5q860+bfOlTELVrtMa2oIMCycg+GquCNHap1vaQLJ8gbUh6ht9Oj4Bqcj9LhRl29/XRZ/dS7FyLCGrsvczSrK9TGx0hTiOefOow3/75IcYXVtDSY3G1zmq9ATrjTNrDoz+vcstrG9x/n8+hIwLfd0lTTacT5rCxIKC35HJueZbh0RG6YUZjbRVh8wWnFBAmGqRlKVwiMym9vZJAeWw281bJdldjhcCRhg4paSYIPBdpLJ1OQrns0NWGmifo2pjNdkStv0hQsGRa53A0B3p7HITJaIeG2ORZSqWoSLOElc3oX/Kc/679Jlb0rwCettYu5z6aPwIIIe4Evv0/OoGxFh0nHLi4nyTVLK9HCG0Z6w/w/F6uumaJsFVi77YxhJexJGL8Updrd8RMTGiyzHLBrl76tyrGJ5qYRhfXlTQ7GateytBwCet6XHZhhzf/fovb/tbjxDg8/QufP/uziOdfB7fdFjG/VObCiyxve8sSd93Vz/Kyy9fv28Zb3jzLo4+WuO66Dp/8W5/xExt522bWx1vffo5nDic854oVvvaVrZw55+A7ljRLecmNdeZmU8ZPuDz5RA+vf8MGj/xIMjjY4eBjCU4QIAplkkQjSGhsbKCAoOATa1hNLWmSkpmMA5fBO95tMBZO/JXiqUTy+x9Mee+ftfivH06ZmMjrlUpKPCfHmxrywG6MwWiTYySEAgS/8+qEs9OKk5NeXgYykqtv3sWuHV2+950mwmpEHNPciAkTyQsvvYgDQ31Mra7xrdNTnJ1fwPNd5k6dYPzxe/H1Kka3mJt1qDfbbBsdxnc9Vlfb1AptnJ6USsVjMCggXE2t7KGwlMtloqxNK41RVuIiSTOJ8gI6cYjRAlEwrG12kDbGdz02WvnmvI1joixDIQiUwBOWSAo8KemvWDrtmNl6DM9uEfQb8e1nY9VymZVGk5J0MJkh7uabiMbJg/ipaUO5GHDDi+vc/6DHk4csxVLCS18SM35Ccmo6oxXGZJnlwAHDvn1w733O+eaC/OPwlD0PnMvr35ddpnnlKwxf+7ri5S/TzJzr4AeaN79plbvvHuTo0wkTx8u844/X+cztZbIxwx+9u83nP9fL6dleJo8L/uMfL3Pn51JWlixXXJGgjeBnT+ziysvPcur4MA/c388Fz+nw1LEtHF5OSbMu5fVTOJyh6EDJd+lP5xndsYdK/UnM7Ak+/5NjbN8+yq0vOMDQrl1oWaDZ6JJmOUbjzOQpok6TXlfyezdcxT8cmmK21cX1HGbOLdEKY/ZeuMx1L+hy3z0uL31ZzDNHBIePJGDAcSSlwMd3IElC+kd3cGbyFNoafFcihML1PaQEoQ3C8bGJpoDC93ykJ8nSEp04RQiDNCC1yIfdlKJUDegkEWlsMY5mfSUhLjfwiwJZsgRG4StwcIg7mjBJCXyBjQELcapptlIG+10wCaH5FTsLzttvItC/mX+S2gohRq21/yiB8jrg2P/oBK6SIDzcWPDcC3vYSDM6XUGv5+H7gKnxsluXePiHmqcOa0a2ZLzuDQ2++MUe4jjGUQ5uOcP6Gpud7521eXvgej3BcbpUBxzKpXU+/FeKE8ctSZZw8CB86EMu11+vee97u/z8sU1e+PwWd39pjNNnXNLOOlNZD49v7eFlL9vghw/3M7vgobyQuJvx04ebbN/m86pXL/Dww33cc+8sw4M1tl+wA9POmJsNePvblrj/fo+rr4742Y8lL3qx4ctf9OmtVhjuKzNUKXDdvi1s3THGyL6rcIRgeW4G2i2aVtKxkvriHJWxI0yfqPP1B0KeN2mpVyt85k7Bc65sc9FFlqkTeVtdN07IrMWTKoe5OXnrm6NyibOU/Ni5GcW73t/hzk9KThy1XHV1if/wxmN89Yuj1BfrRKlGSgfplBjq62Vto8GDi0ucmD+HEmAzgady4uQjD36VSy8u09Oj2L6lRpFcfEWiiDuKRjvGUZZKrYAtW5RQ9CqFSSylngKiGzJ9rs2OHWU6DUOKYKjPxa7GJEoQCJdiqUzW2mB9M0MLF9dNcEWBLExwPRfpKaST4McZc6eW0FsN9Sihf6jAzTsv5NAzj/9WfPvZWFMbWnFKUCmgVYxNDRW/ysL6JitrTXaPCa65JuaBBz1ufFHCM0ctU6dcjk9K/uz9ER//RMDs2RJbL2nylx/QfOhDCmvONxk4AgcoBYooMWSx5eKLNR/8oOajH3GYGFeMH5f85z+vc+hIib/74ghnzvgUqwnHj3X4xG0eO3dFWGP51G0Byytl3JLD3NkCX/1aie3bmsSh5cClHb78tb3MLg1xckry+285wwPfvYRHn6gh3RRhJFmU0soW8IMKbSHRSchi4HPy+Bwl9xyOG2D8AL08x9RTivr0FFsuuYKtl1+D6DZRbR9R7idob7K5OEPoVij09WPrLXpqZarlgJ17Qt79vowPf9jl+DHFoSOCv/hAxG1/U2TqpIcSgizL6KZQKlcolyrUBnpxHEvSCYk7IY7voYTGw+C4hqJXJAyTvKMvKJBGmkY3ohoEyAyKjoPC4riSxFjCLENxfvjJxLQ6Bm19KmUXbEqYGjqJQKQi77QRAmklxcDBKgeBgkTjFSTafXYh+9cK9EKIEnAz8O5/cvjDQogryPPCM//suf/OiSTVoT7OrXforwRsKVbJ+gTCgeXNOs3FMt//fi833bRKoVrg6iu7PPjgCOeWLIg22BzIHzYk5zsG+ce01Fqot0Jirfnm/RJSlXecnOd8HzoMzxxy2NzMeNObmnzrWwGTEy7SUXi+z2jfItc9N+Ghh/p43nM3mZ4e48gzAXG3wYErBde/OOQ73y7yohvqXPscxcqyJE1SktQwMenwo0cGePOblzl6tMaVz2lxz5cDbn1NjNOCgU2focEafd0GlXbAWEnTaMb0uJbS1hG2hym9BZfhF12BcF+TK+rUf8b3l3/E//KHr6RW9GmHEXq3w83vjVhvNOngMDO/zuPj00wvroCQhLEmTlLKJZ+econawCDzKwmfvX2Fd763wY8f8nnxTfN84mMlThytIxwHv1AEo+mGIUsraxR6BnnJJXs4tbxE39AYvu+wPDNDRWSUhKKoPIqui+PEXH7lGAsrK8wlGVuHSkiZ0YpijHYxSRvpSjAZvX2SsLNJoyNIOw4r9RjfgTTTdJMmu4cGIFOU/AJJbPnRibNUe/uwfsLgWBXTTqg3BNrkpEsbJTQbCYUCnDq7TDN22LfbxXd+dYWp35hvPwtbWF4DJO2wS5IldNOMNdFkc63NtuGM339Dk7u/1MePfx5z7ITDn78v5GOfUBw74fBf/8blf/1PET94SHPzS1L+6sMuR47xy8WP0TnVrBsbtM0xIPv2WT78YYfJCYVSgvFxh4/9teTCS+DwEUMxMAgr8IoBMzOSE+MpcZzQUy7SP1JEC4l1fGbOFukcd3nBdSt84YtjrKwPEGddTk6XeOA7+xkc3ORIt4zrK5TK0ElCGlmysIN0XHSW4XnDJPi0dAbtDn6phF8qcywrIE4t0btxkCvcfpzGEmkmSQYvZXNlleT0LONnFpnvpDQabVIr8JTDpfsln7ytyNwZj0rRMjsDn/q4y94LMiYmNUmWt1IXSwG+69BpN/AdxfLyKibTuBKyNCWxkCJwE00sEpC54EjJsVR7AvySwvM8POPgiAyjNWES040iJJahok/saApB3nZp0MSZRdiUqJNLd2otcAUoa4itxUcSOBJXynx4SoAT/BYCvbW2A/T/s2NvfRbnQYQZu3cMs7qxTtDjsNaJ0d0YP8gHMpbWe3jmmZAbru/w4Hd8Dp+IMRKqVZ/GRoq2hrAFcWYQEvJwb1GOIE4tphXiKEFqQWf5UNQ/cn4OXGZ4xSsMX/mK5JWviDg3GzE5XeDAAYc3/V7E3V8YYuZMiRPHLe/4wwXCdo2wY3nv+yPuurPKzFwPC0uGP/vAHF/+IizXA9qtLtqCFBnHTgxy+eWrPPzdEj/+vmLhrOTARR1W422I7bvZjBNGRi9hc0WSRIpiYStm2wWYmaeoL5wlrFUp7rycchoyXCgwV+ul6CkKrku1dxu4BTyVUl9fo2/bVoQjOH70GN9/9CgPPnkEzw9IcZhbWss3YLOUUqVMR1/Ek09Oc8vrVvn2NwOOHM1RzlobGq02aZZikPTUagxUXCbOTrFt53biRLA0O4fVKUIofFfmk4dJRsFkLEYLtE1CsaIpVosgFBv1mBCN6BqMACUMcSLwdEwrkZR8H2mgWU8oF3zaOkOVXPyupGkj1te7VHuLFEuaODVk3S4FKRke9hEIhMhohoaOdSh4ilLRQ8SCOE5ZjePfmm8/GytKRWTJ8cJa47ne+cWDZnQ04/a7K/z8sRCs5ci45GOfdNm5I+MXz1gOHxX8w/ckb3pjype/Kjl6VAKWN7xeM3VSMDmeb/ynmeXiSzR798A996m8GwuDi8RRcPgwnJhS+F7Ey29qMXNacuZcAdf38Isldu1oceONdX7yiGVmtobJUjSCPbs6gGVyMqBvKGfIWwPTp30mJhTahpCECM9DZwlJosmUAhHldMeki/IkQlqM1fi1YYRyaUiBwKGeGpZ+/CjZ+gJi5ACtp7+Lbc9SIGJucZNYi7wDD1BK8Q8PBnlHmUgwxpJk8OTT8OTTEs+HUqmIo/JJ4Hajgauh0W7juQqv4BJ1Y5Iwgp4CmQNWK4Rv8TKBlQKdJAz1VInSDkW/hhSW+kaTZjekFcakaa4alVlIMqgWXBxHguuhpKKeGBr1FtYBYzTaKsJI47uSdqJRSCqBRQOeJwm8wrPyqX8Tk7Gu47CSdjANQ2RjZjbqrG426CsEdBJAW4rVNa64ossD3/G54fqYkzOSyWkXxxG88fcM8wshxybs+RW94NJLNfv2We67z8Gex55mFjws0rHERpBowWWXGT74lxkf/ajLkWOS8QnDX3xghbvuHmZ0LOWLXxriyNMxSiXMZkXu+hxs3xZhjOBjH/WYnsroHUgYP1XhrjurXHzAMvtozOrSKrW+Cktrfdz4kjP86JFhnvvCVRZXdnFuxuHgRAG/f4zpyTW0zag1TyM1lBxLKfAojZ9Gzj/DwNgIW5fauCuPk04+xh0/meQ9r7mZ/VdfSZxCFAkW/1/q3jzazqs88/ztvb/pzHeUZEuyLdmSZ0MllRQpxk6cgAWEQBhDQiaqq5pKuhIItlyr1+rVfzTIE2QlXUlBQgYCMQQIU2JTzFMggLGte68mW7JsjVe605m/YU/9xz6STSqVbpwKw15LOvd8d93vnHPv3u9+9/s87/OcOEmz1aD0niP7D1KM+lTOcMszdnDl5ibv+9pBZrfMYa3mzPkNsrhCiCH1+Ag/9uM9PvGxjBf8ZMGDC/DgwwXOeBCQJgnTrQYRFcNBj7ltW3ns0DFGRUWWxaQiUNriLME5i9cCn9QZjwvSRFBL6jTjGCcURd5ARgLrSqSIwHiKMnhrCqWYmq5RmApbamRkGa9EHK+GTLVjjCqo2hWtJCFVkoaU2Eoz6GvakcLhETlUY01eGdY3LB0vabYz+sM+Qjy9uub3a7QTSSIlI+Moc0NqPbUJOeET9zu6vRIpJEkagbAsLkU88JDFWc+N1zlu+RnHBz6o2PMiy+KCZWFRcvSYZO9tmrvugsceVVx3k+O33mzZd8dTQ4BEm9DRCeDGBcIlHD7s+M3fHPGudzkeftByw42CX39jzv1/m/Krb+zx3r/IWNxvuGLHiDf8cp8/+MMGxhqss0RxjDUCrQ3GOKQI+FGlAyXYmArhI6QK69RbjdMjhBShhIEF66jGOXrUQ8QZeeXIS4c5dwLRf5wt823KwtKvNJGM0dqQVzrY+Ymw9sWkS1ZKSa2R0ahnxHGEsxXFeAzO4YxjoCTN6Q66LBmsd4OcchRM1gGsF3jjQVrMWCMy2BiOGJUjpqdSpC4YliUb4wpdQl4YcuNII8gyR7c/olmv02gL+oOcs+fzSS+LJIkTbOkDZllJilLTqEVkWRPjPBvrXYZPE2/6gQj01nuGRUWr1aA21WYjP89Up0Gr3uHUiRPMTQ94xQtHfOwTm/jbzw749kLMW96U81/eA9/8luDwMbjtt0ve8542n/9KeTF477sjwjmHEAHESlOFso5WPWJUWGwFu3Z53r5PcfyoJFGCgwckv/d7CdffVPD5L29CeUNrOmXQHbG60mNlRfCwjKkqgxLx5DwsiZTizBMZ3X4HYyu0cVy5I+e1rzzPRz55HceORpw7N83LX3WMj318B8cfl5iiQHooRhUDf4o06zBC4nsD9GCZLElpnFMsnP57phoJMplCZw02HvwWX9o4Q2tqlqt/5qVcMj2PH27QmJqm1VnD5W1Wl88gtu5g22XXsvnYWbR37Ny5nXFR0B+V7Liq5NfeqPm/365YWrR8/ZuKvbcV/O47Mo4cSWnUU6S1lNWYobY05jdz1c6rOXPyLFdsn6eRRpw9foaskZE06iR2QIYgrcNsc4be+ohaFCMdqFrEdL3GiZUem7c0cFoTJxGZkuS6Yq7VwKiIsjsm15q680ipOHluhe4wotlqsGm6ydlhD+UhlwK0YKg1Zmhpy4RRVdFuZWhp6A40aQWbkNSaCZX54dK62fAjfCGwzpMoT004lIjACHRliSKBmgDuxgbKrHdw4/WevW823PEOxcL+iP2Lgr23Gu68K2ZhQbDvDsXe2wyf/rTnZ37GcvfdigMHFXEUgipB8DHoxHiPMZ5xrvnWtzzvfGfCb//WiM9+NuLmmzXvfGfM0cOSc+fa/MqvLfPFrSkv+F9K3vOnszzyqCBNPdZqhFQ89yeWOXOmxtGjNYSMsNZw1eV9tm7N+cKXZpFSgg/GqMIbvPUgYoTzlKM1LBG6KMBZoqpAW89oNCYzfa65vMXczBQnTq0zykvyMkcqiYoEtVYwGhFKkiZ1VBSRxArvHXlZUOYlUlpqUdjgZC3FWcnpk+eR0lPLotDL4izWGZxWZK2U6VYLgWR+524ee+xL9CpHMXb0u11amcNaQTEOMipZvcEVM7M8fuIYSZxS6ZJROcYMDMKmbJlpsdLtUWnoDTWb52rURJPVQUWnlaKrgm5eEskEaSLWR9/96RR+QGSKp6dT/2+esw2ZWqSzaClopjU2BiPOrwz5qWc7Ti4rvvTVilhIhHRcu9ty+XbLRz8RYb3npmsst77ZcP9/U9zywpCpLC7JC6V6EFBPZNC7NoH+5a3AiiDepJSjliU4FxTkGp0mSnrq9Tq6yKk1U6IoIkszxqOK3voGVVWinGd6uo2o14mloFavoZ1gvH6e592cM9ZXcvCwQuJpN+ts37bO9NQan//iDM1GE3Dk4wKHBMSE/uhp1sMxWWUzyKiOiDzVcCN05TY6RHpEvrpMp1njksuvpTj4NcSVz8bN7eLE0hfZ2i44vXCAw8t9oiSicuF4HkkBzvLTt4x54omER47EOOOweHbtLrnscs2H/1qgopgoipmbrpMmCUMruGbHTg4dOMTpM2eZmZ2CqqTeahAJz8wWSSOVNBoqKAc6jxOS2EE6nbJpeoqyyMFnxDJB2SGjosIYy3p3QO4sSgiaJKy7glq7QeoNNosZjytqzZSqP2DY91gkuTHM1FKcKfDEFE7TkAllGfTTI+cpdIGsh8z3E59c/qGRKX7xq7dSjzOEd1jjyMeaqhKcOTeizD2F9pS5RbtAmfE2lMNe8bJQnllaCibgArjxesfuq+CjH4sAz+teo3ndaxz33it5/1+GPE8AQgmiSAWNGy/wuCD8JYI8gree17624rWvsdz7Aclfvl8hgykSv/ALnlf8vOGTn8i471MdrBOIKKbR6RAL2L275LU//xh/+ufzHDmScOnmNd70H0e8/e2SpcWAC2S1hOmpBvVWDeEsmZpYBs5cQpTUMGVFpQuKoqDIxwz7G2y/7lk852d/m7NPHObg1z/K8Pxxas0mlTYMeyPW1weINCaOFUJAnGZk9eADq2xJ2e+ivSRrtRmPC8ajAqMrytKz47IGqRIcPNallkou3Vpj5846DZlgywqtOjz/WS/lK197P43pFsJ6jhxbYfv2OZQQaOMROKZbs0RKsXzqFE44fOpxwiJ8ijYGUxrarRRdCUoPSRTTzhRT9QZVOSYSEUhHs9Ugjur40vJ/vevL3zFffmhkimMp2TLdoIo9K+fXiaiTRp66lSQi5pOfdmys50gkqgW+EDy4X/DAQwqvHR5YWIi4/1Oe177G8oEPKBYXQ1B/1c9bHjkqWdgf1CSbqWDH9Z4rdjg+8pEIvMd6h3UCYzRpIsEL8sGIRrNGXpR449jzvB6HD2oOHkiY3TTD3FybK3aMeP7z+3zhi55TZxI2VtcYdLvc9GMNNv+rMZ/4RMyuG2eoNzS60pRVxZFHMspqDolB64okifFAVeSkSYKTQS88ioI5iKmGRN5AkROpCOIMqw3ognh6lg2fcP7QYYqBJ16zLH/1XUzXHVE1z2O9MXPzW6iqAmFC52tRGvKy4v0ftAhZgi8QEy2Qv/um4IEHY9qtjE6njTQFlTWcWx2BNhzsDjCR5JprLiMSsLE+oMpzvJLU6tP4uAgCa6kk0oJYSAZ5QS1Oybyg9CWdRps0lSyfCaJ1K4MBzgqckYxt4B8PC81UbcIYihKa002kF6yUgrWNDWTq8MJyfqSp0LSyEKyWyxJTweZIY7SnimNaDUkrbgHL388p/l2NYb9k6DXOObyR2CJk22UF670ymHxLSRQptHF4IZDAxz4e4T0oGZyKnHUsLkkWlgRShqC/50UTLGqPY/+CY3Ex6NRgPc56VBQC7wWqrsMjIsV1N2hueZENJaFbLEuLkoX9kt3XG37qZsdffVDywhcVPPSw5fChiKzZwhqNkIJDhxR/9r5L+OVfOsMXv1Tjec8d8fa3qZCICYHD0x8EZcZLtkyRpZK006DR6qDHAywCJRVKKSQGJRzeRzx2aJFtl92HHq5RdU9SFJq1jfOMRjlCCTZfOk+WRHjnUEmGQOCsZtTtUqvVmLrkCjZWz7Ny9hx5bii1C74WxtHsdOg04KZ0E/NTU+TjPtUYLIap2ct55tXP5gtf+QZGWop+FzM2IEOShrM4Z5luNfF+hDGSRtZipb+BtRYQxEno5I9lApUjiwVSSup1hRKgI0+apIyHY4qiYOhKonjIbK3ztObUD0Sgr5yhP1gPynvGgB9Qno9p1xJWhaa73sc6cBKqEoQJNmPOhItCem68KUzEez8o2XOLZWEpAFGPHhXc9lbNvn2KQ4cirrrO8r//pubuuyQWUBONHSTgPaUm+K1ph+uPEcJTr9c4dlzxH39zxD33WB555Dw3XO/4pTdUfOq+jF/91XXe+96YfNzg8u3rvOH1Z3n3n0zjhUFX4SgpZGhPd06gZIRXgkobtNVYH+py2hiSOME7h65K4jhFCYs1OWpiYqDMAF1V9NbOY7WmObuFKIpxccxw+SEumTJsu3SeJE1YMI589RxpmtEbjMmrKvCoY4VKM0RAi8EHvfK5qQ6NRjD60FVOLy+wpaGVSkZOoloJU51pRoMxK2fPozDUUhUkaquKTDqMBJNbROIwRcl46EjKiLKsGBZjCobE3TG5MfQrzaiEhITecEjpgi5Roxmx0ushhWSTSIlrhrNrQ86ey4mFY6hFkEuoLIqY1Q1HIw2yCTKOUKR05lps9IacPdVlPf5nSSB8z4c1gqowDHMDPsJoRVFWOOEmAR6M80iVgA1CMFKI0Fw3kWnwkzo7UiAR3Hi95bY3a/bdHbG4pNi/ZLl9r2HfXVFIimzY7I0OtX4pBcZKlJTceJPnzb9Vcs87Mvbvh6VFya23aj6EIoAmAAAgAElEQVT8EcUrf95xx50xS4uC/QueW2/V3HWX49hjBfWmxgoQ3nPogOKrf9fkpS/pc+9fChaX5MVykfcCpQIb7rnP2+D4Y5LlcyCTjHwwYOeWDXZcCV/5fANtDdZ7vJR0Nzb4/Cf/krnZNkkkGY5yNBGtqRapAhklrK/3KYuSrFknigIQmqYpSa3N8vI6K+dWqSqD9+KiLlW7ltHPDaWWbJ5pMDOV0I1iphodLtl2Nc1snk/9t8+x/5El/s2PzqOoWB8WQII2Yad12mMqRS1TrHd7FCWMrEEiECiyusR5yXBQEfkAgKe1NtoKSgxEhrxylGXJoCoQVQWRYmi+fzz6f/YQUuIiSRLFbG0lRFqwdWqaJzYGrB2vaLcTrDWkScTKeoH0AkuQaAXHDde7wBe+Kw4ZzAHH3rdq7ro7Zf9+xb59nr17Lffd79lzi+PuuyMWDyrSRCCFxCMQ0hP0qwJKXlVgXBCz7g9yvv51RVnUectbxnzmM/DTN1vuuVvx6CHPmTMNfu2NZ/ncpyNufqHlj98zzbFjNYTI8YC1hjiKQMU4VyFFRGksSMgmWVPabIASeCsmNVKHlH7iIK9wDqS1DAdr5JVHqohaPUL3VhgWFfloxNRcg+uummd+dprRsEAgWOmNQZUkcUSjVSOrJ6RRGrT5EcRxSprWgiyCtwxGI4pejog8nUaKFZ5CRKHWPXYcOX2cSBF8fAXo8ThsYs7gNNTbGfNT02ysn+MFL3ojX/3830Bxjr7JqcZwstelmVpazTr9tRFEWbCSm9rEtbNzPHrsMLW0yXA8Ik1hfbhBZjISkbJ9U8pat0dpobeuuWbnFL0VS+RKjBDMTGcU+Zj14RCXZJRakPiYjWH1fZ7h390oxjAaeYyVaFlRqyc00gQnHKasMM6TJYJ6SxHnGcP+GAhwkQjK2gRKwsSeyTt2XenY946IxUMhqVk8FLHvHti9GxYPBnvBCx3TbqJG6bVFe8vllznuvCvm0CFFFEmOPBJxzzskP/tSzV33pBw8pBDSsbDkuePOmF1XWR495oM88CTQX7lzyHOePeTDH4rY82LDwqJjcTGEPU9g3uHhkUcke/ca3vHOPiurEc+8EV7/ixu8732bqazHe4kXnkhKmrWMRrMWqJnekaQx050ZUBEbKysMVtaJ0oT6dCesPy+wVUm/8KysnWTcH2KtC14VQiAEGONQCk48NqTdqdPM6pxzgp07n8Hlm7fy+BMr/PVXP8Lp1RWm2hnOGbBgfFgD1njqcUwcwaA3xJk6wji6wxGNVoKz4JwKDBtrkBK0cEgt2ZzVGZWWwnrKosAbWFsr6VYV7UYCscDLp1ej/4EI9M57ZqY7JLEkzwtEWnHo/ArHlwc4b9nSbJE7S2+9nFgLeoT3OBVQ9F1XWfbdE7NwMFjNLR1Q3HEX7Nrt2L8oOXgw4v5Pwetea7n3XsmDDwcdGeHBY5GRRIhQsoHQwixSBT5QMI21lLnhG38vueoqyWtebfnwhySHDioE8PACfPlLGS9/ZcF99zU4eiQhSkOG5Uyws3JSoYTgWT9+mtOnazz6aIwdDHhiZYPrniHYdU3MV7++CSnDootVRq+3gXWWOIqJFURJRlLvMCi7tJIU7yyjURftHM4VtDddz9y//Q8MNzbYyB8gUvupZQlTM03SZossVZjxiPGopKwsKlLImkN70GXFcDRCxdCamiLv9ih1SdaZYqo1y2h1hfXBKtu2z5NmNYp+n0pXeOdReGqpYrYlyOoK5SLOnVnBWMtrXvErfPy+30coi6o3OXj8DPVmA01ENjXPaDhAU/KsZ/4Yxx57jHozIfMJshZD4oNXsPE0kpResU5ci2jlUIkKpGB6VjIrmigEJDG985KxGbFj6yx1BI+dWKaG5SBPW+vmez6mWgJ8ghUKIwtMZbDGUWt48szjjEQpeNmLco4+HvP3D8R4C147brzOcPWuQJn0XuGFwHnHRz4ZavTIMO/xnqUDisWDIpxgkyB2F9aXwE80foWDD39kou2OCVaOkWTpQMzSUqh9R0oEez8Phw+H+9ZqYU2VVcl1V5f8u1/f4F3/tclXvpzzwLcVt99u2XeHmJSOnoQxFhYlb9+nuH1vyRe/3OXmn6z46Meu5PETgC9wzmG9QEUJU9MZUZxgjUXKsNH1NvpYPHGWMt2sIxCMR2PGoxHeO5yFsjLoUl9UvPSAkIIki3DOsHvn5Zw6e4Z+z9Jpb+Gmq3ciheRzX3mIBxYeojKa2Zk6W+eboHToLhYx4GjUUoqywBtLvd6kmSWYrAWqTm5Ksjo0soy8qjhfGFrNGlKPKL0jzwe0axmmrFCqRq8qGFWeftczLgvqDUWr0Xxac+oHItCDZ3W9D0LjjQIv2VgvuHrbJXy7e5InzvXJq+DmIiOJNzYEmDhkwx/+uAogrZiArD5MmP0HJTKGG6+zob44qU0uLCoWFgJdSgAYS1aTF6SrcRA4vUJijEWhkEJyw/WGF70wAFl79jgeesixeEBw9bYRz3ue42Mfjfmpnxpz8JDi8cfbxElEXlVEPmTvlXM8dhR+5ZdP8O4/nuLLBwZcfY3lf32T421vqzi89DhpLabVzBBSYL3HaoMtKkTkqAY9GrOXMtvuoHVBUZX4JMHmOeOiorQpXrTIdZ/HTq8ghGfHlVsRUpDnJevLfbrdYQCokgivLWM9RsqctN5gfusWpCko+xt4q6nPb0IgWDtzOjSzpBErZzfYemnBjksyvvztdSLlqAkoSofcVEOWmsHgJLk1DPrrRHNXMCwLOrMz+MognSVL6ggs050a9Tg4eo0G62yaa2HGGQhNvZ6g5QjhI4SqkeshTsDmuRp67NCb2yQyoVkPzVDtepPRuM8lO+ZxVYcs00zV2szPXsO4N+Bznz/x/ZnaT2N4b0hboBKFdRHlwGG8RRcR052MsirojzRHjgr+t1/tU5QNHtov+JFnwm//B8173jdDe8YzHIWs0BsRekvcJM8XHoTHu3DdPyncHqLlBQaDePIyDjwO50XABXygRQshgh2gICRGQiClQCkx+SHPtm057/mTOZYWi4trc98dgl27PAsLk5PIRTjRs7Qoue8+z+tel/OZz07x2ON1ajWHcJbhMDhEaW1IRIJ1Nri5GQt4kiyhMTWF9I5Rv09ehAy4LCpMZbHO4RxhcxNPvracvO80FUTK84wbrgQUV23bwhOPn+CBpSVOn19BKcHsphrbL63TiVNkEtHvFehR4MqPRwOazTqdRpN61kQhaWRT9GoFZ3traK+JE4/VgrlmE4ljbWgplUSOCqwMekVUnnZc47zpE6HQhaYUDqqnxyD7gQj01njWN0ZUDpS3mDxFOsmjj5+n0BHDcYFSApXIwPFVAiEkyoesOTBxQKFwF/SaI8A7brjO8da3aPbdE7P4oGRx0bH3Ns3b90Uhm0CA9ZSlJVIOqSQSkJOVkUQKax3X3qD5nTdr7rwrYWlJcOCA49bbNB/6K8mrXu24866Ig4uCB74tuPXWPr/7u2MOH0pozwV9ajse4xEsHYj4s/du4o2/tszmecFLXuLZty/i4CGFSjxFaRjnA9bWx8zNtUkiyFJJvd6m0Whh8gGiMYOMExJbUeZBGc/7mGMH9nP5js8hTM747CJKxayv9ukPRozGBVGi2HLpHPUsRVxY6HFKoiTGerqrq9SylE2X7WLc77F67izDXFMWhtKEFZGXlms7bWY2e268egovG+y+dJrjp09RjCP6wz5jLfjFN/wfxLnj19/6Ozzn2Q3OrK6iKouQgtJVzKc1NsZr1BtNmrWI8fhcEJaqT7Mx6qFLw6DQNOoZxlZYbehkTSLjSLKYkRvTasckNsIpRVSLmE4alJWhMDnjQU6lw99zrjHzfZzd3/3QeNqNiBIHBto1RSUUpVd47RmXgjKHk6eavOf9Eb/5632+8JWMn3xewbveW+foUUVWMxgnKPoBhpETdTPng9CZ9z7gUjwZZL0MAT7sAxey+slwTMob4iIFs6o0QkqUEkRq8j0vcNYFVVQBKoq4/9NNFJ6yMrjJfRYWBQuLF15/ckM8URRx442OPXscH/ig5CUv7nPmTI8nHp9ksgKiKLCKjPNIG8gYpqrIajWyRpNxf8RgNCROYqIkohgVFGMdPvOF98+Trx02O8torNk032DL5hmedc3VHDr6GPd/7gucW1/HOEsUe666pkWa1BC+Yn5Lk+7KGCWhKHogIUrqICyD0ZjRKKc91UaMLUWZo4QhLzRrJkinx5FkvdunV4XPVU9jityRppapVotKW+Y7M6hoDWQN6aGZfJ/UK/9nDCEEzghGQ01RWVr1Bue7I/CWKIUkVqhMhHZlJ4NRSSy5MA/lZAI76y7eDymRHnZfabnznoiFpSCpsHBIsu+uiKuv9iwdCqUXZ8E7T2UtSgXMQFuLkgqpgqn11bsr7rknYWkpWKwdOBhx1z2Cn/tZw513JSwsSASOhYWYO+907L7a8+0HSpwxaGMC1msdcSJ55NGEv/1bwetf77n3XsnSUvjj+UlDRxQFDvW5lW7wyY0FqJjZJKPfHxD7GKkLsBVm4nLupGRjdYX7/uqPmZluMDPVwtiKU2dH1Fs1Ws2UTqtGrdWhv7bBYKOHExAlEUmaIZVkutWgM72JXi/n5OOnGI8LrJ2AexJqqaLeSHGx4PQqTM0l3LR7G9WwZCOXyNyy6ZLd/NyLXse3v7HI7733Xag0pdRTCDHmfK8EFZOpjEJoVgeWTmWY72wiVkO6/RypMs50R9RaMdInjMaW6dk6upCsdXMakWN+SmB9hIgcPTSucowxTLUbaD1mw+fI0rNeVCRpRG5+uGr0kYB8bIlTiZSO0hmiOKIeQ7fvabVSysrhtaPXneGr3zC8bM+Iv/lsjcfPxAgZQLwkVZTShFYP7y/KWeNBoMJmj7/YxBTSW/DuQuAlRH0vmLh4czH3v7A5OIdxIjQqyslccSGg6lKDBDG5h3N+Yngz+dnJ5xVPueGNN1re+juau+5OOHBQceIJxZve9ATvf/8mjj6ahI1FQORjirzEyQgvgqFOf5jzkuesc/yJmJPnLyFCcO70aa7eXbFrl+OvPxKFzzH5FBfeb1FUzMxN87xn/WuuuWwrJx9/gj/64Cc41+ujosBAqrVidl6T0mnEjIew3i2Zag65Yr7F2rDihktneeTMMhGefrei0c7IIsWgqtgoS5JYMtWeoqbGZFlGtztgvRwyKCtGJSAkcthHC8VU1GE4WiXPPTIyzDZTsiwjkgq+z8Yj/6zhLKxtGNIoYTQeUZsaMjUbo0gxGMphhfNBz7o+k7J6ZoBSHpODlAIvPYFSLPHeBHB38gv56CdC56QUAq8CmLN4KGLxoIMogE7Cu8mJdQJfeXAmGCxfqEl+9KMxUkrSNIBb2liWlhRLiwqEQEWBPeCc4+EFycKCwHk9OVIG38qqLKllMZdsWmXPHn+xBLS4YFk8EFQlAxjsEAhe/UrPI484Ht4ParWPUJLrrnVsv+w8X/h8I/hrEnoBIiBTEVktIcnqOKGoKsfcbIvtu6+iKg1njx9ntXcSbS1Zq0EtzchqKVma4DUM8xHrw1MM1tapigofENqwLhwUhSFJBU8c7ZPUJbU4IpIbOFvSbM/z3B95DjsvfyZ/9Cd/zv1f+xpzcw2EixGmovRB28N5w9n1LpfNT7N1Zp7Mak4urzDXaNLvDuiNu3RmU4S19MaKmUaCdyWDcYWQjjTLGA3HzG6Z48ypMa3pBCVL2nGdlTN9Mu/o9jVxTSANjJ1l/P1vFfmuRi2NKa1DeUllDGXlSIymWY/pzCRkUYz0Ifu9dkfF8/9tzic/VeP5zy545Kjk2LGYJMootEEmElX5cPoN8lgYF7Jg4TxeCLz1OOcnpUsRZqGcZP0Xst/JoxAecSHiexmCOqFhK3wdhq4Mw+GIKAmCasiQoF1Iqr+zf0dM5JQlO3dq9t2hWFj04C37F1Pe/e4Wl23vcaCcRlsXtGI86KqkHBck9SAn4IXl9EqH3/6tdd71RwO+/PkNrrvesHevCx3A6kJwF0gPpTZk9RovfcFz+Ykbr+bx4yd434c/xpm1DZqNlFqqAsU18sxvqZFGDbrDEeiKovScXR3wI9vbXHnZNvr9MUnrMmxl2Ugi5jbPUGjDsZPLwQhF5NhGh1rapDIVWoBE0G436dRjRAyDUc5ooMEMqHU6GDRWeYSMSBJFImBkfojB2EhBpxUDdeYankQa+lVJ4mPqHcsg9WgUUnpedkto1T/yaIx1gbN6w/WWq3fBhz4cZEURAqHCudQ6j/SB3yqUBEOYtC40KHkcxBJhwve993gJwgf6ggcqbZAiBNUojlASVJwE2VdrQkYyObYiZWjl9h6rFVIpRqMRiZIkWcaVVw74lTcMeNvbwyaxsOjYu9dwx52C/fu/8/fyyCOCvXsNb9snefRRy/bLBvziLw143/s3Y6wHa5GxwmpFrdEgazZI0xqm0pg0QsYxdZWxduo851ZWQEJnqs3cpjnwjtFGj6o/ZH2S8RrjKYY52lgQMgQCH+qeHh/wChFz/nyOEPCqn9vD2sp5ZmeneNUrX8UTjx7l37/lrWzkfaamWkjvuOyKFnk1QCYNRGRxlWO+2Q5OYLagNywpKsFQxUzV66wNNmjIOnESjFNQgqLSpAlUVjFyObayzCKYn6ljhWOkS8qN8zSzBhvLI544PWJ2vs50LcIUgjRy37O5/D9jKO+xhUYLj3YO6ySj0lErJVEikM5w2dYptm8veeELT/GxT2zhGw/Do8dy3viGLr//R54z5xpUWlKrCUbaIeVkLUhBHEuMnlCTcUFrCjmZx4DwF53ILjBivPKBsOCCLowQwRQHEer+/sknAeeynlE/J4oVUSxJItD6gg7Vfz8ulIQ+8pFJaWKyGRSF5sgjDY4cickyTyIjEIqyKLDaIpTE6uAyVa9nnDjR5p2/O+Y//cY5tm4W7HmxZ98+xa5djuc91/F3X1M8/HBwcbv5p2d42S0Z/Y2T/OG793NmZZWsljDXrmO9Q3sLEaSZoizHnDo5ptkI7EBdGoaDCKcaAMzNzTDlDLGKOLc+YGOsKcuS7bNT6DLnfDlmZAxxYonjmFZTMioCuWSqU8dagxOCPC9QUrK8PqAxXScixmiHihOGw5ye/iEO9OCJ6pooMrQaCb01y1Sm0GVFMUyYm6tTVWP6Y8sTxxN+501D3vmHim8vOJ71r2N+498V/Nm9szSnLXleBlCoNPhJ0wfWIZCBliksF90Y5JPxGRMm8IX/xVPPmBMBNOsdOI/WIROK1aSJQ4Ka/KxzAkTwihVS4Z1FeE+lNe20xmXbcu65J2L/foFSnsUDin13CnZd5di/P7AbJi/JwpJk350R/3mv4f5PlezZk/PnfzHP+sZmGvUho8GYsrI459GVIcsyjLUTx3sL3nL67HmSRsb0lllmZ6ZII8Xq8iqrK+vIJA7NMS40cQx6BReYGXiPl+GXY62j2UmpqpKbn/PjHHviER548Am+feAw//71L2f39m2898/+lI9+/ss0OxmNtEl7Kuay+Q6Xzdc5OSzAaKRLca6i2U7Y2BiANahMcsXWbdSkZeQSbqzPcna9h4wqdm+vI5OMlbU+JwddNk+3UOMB6ymsDDfYuXmOY+vnMSVcMjfLymhI3zlaSYPTpwpG8yVZGjHTueR7P6X/GSMvHOMhOGEQyuO9QjvP+dWcbfOSTqeGUgk7Lx/zrS/tZmMlYtNmy+nlmP/yHs0Vl1WcPKNJ4uCdmo8hiUOmXrng9pTEitJbhA+EBTfpqfA+0A2RYiIW57+Tny8mGb/jO8QDw4TnydqOCB3o2npUBUUkQo4l5Xdk/hdojeEe4XmUZdiqwnlLVWiK0tCsh2awoqxABFMflcQIQvnRFCXDbp/uWo/Hjzh27ZS87hccH/iAYmEx4G2vfrXl+c/3/NUHr6JWq/Oyly3ivOdP3utZ6yc0mxkABo9IBFY7nBOkQqBkQpJIEBXChwqBVHBubHGmwpseKk7YND9HlmYklcHoUGVQaULdN/BGcXLlHFmSgInIrcE6j449Y6Mx0tBqN8iEYCw0mYoYFyb4yFYWg8OZ/88m2H90/EAEeudhfiomx5FX0GoqYiXoIdEyIXaeUSEYDRyPnoi56/dj3vobYz7zpYSbn9/n3X/R5PixlFa7wvgSMxKTQA2xFKAU3vogyxpLvLV4GUBXd+EoGonwRpQMnGLlEU7gBKDDxFRSTiaxAAfaGrQwSBX4xbECJoCWRKBwIJmwZzSDYZ+PfTxifa16CqjlWVgQLC5EIbO6SH4I91ncL7jvPsnrXhdYQ4891qYzBUmaoivNqJ8jhUAbizSWWIBQYCuN97Bt+2amNm0mSupsLC9z/PQZiCNac1NE1jAYFPSHBdb6Cc00rNYL6p5KSqIowhhLo+Y5dOQIN1x7Jbt2XcHzn/kTHD1ylLvf+QesjHt0pptIIejMR+ze0cIMDVJGzDanWVnuk/ctlRMsn16mM9Nm8/Q0tVgRJTFWS65oTtHt5WipONvVDLylUY0R1nLF/AzOVqzkFSMkQjlWC009rZEA5bDg0maHlfEGSRKRCoGrBMaBL3+4ajd5ZTFWBgxFWMDhrafeTJAqQglFnEY8evBSdFGh0DTSCKZjTp+ss7AkqGWWqVbEsAiZepQKkjgoY5aVpxxblA9ECC/C39q7UDIMNEuHl0G7XkmFkBLrAtvNT+gqcnJ6nTjcAN+RG4X15D3OgTP+YlD3/Pd/D+/hFa+wHHtM8fiJhJEzaG254SbLddf3+exn63jn0caiohipwmlZCIkuDdpYitKCh2c807PnxY4PfjDillsM+/fD8tk5Pv03m3npKw7x+l88FnSCDLx9n+TRY2koBVuHUII4hTRVoUnTBRXMVj0lTRTjXOMsqEgiE3DCMdKamhKkESyvnKee1WhnIEREXjoGRYn0EZqJBIt3GGvwSjKscuJigNWWsbaMJ1IexmhcF7wBYxUbvSHaW5z97iW34SLu/j8eQog/EUKcF0IsPeXajBDiM0KIRyeP00/53u1CiKNCiCNCiBf+/3kTQkC3V2FzRz21QUxLGJrthLmmJy/KAIgkEVvmW5zfmOWzX0p4xUtK/u7bGUdPKsZVTmVGtBoxOE+Uhm7UgPQHhN7iEdYjkYQp6oLOjRB46cK2Z12YuBPNGTkBscSEQ+ZD8nvxmvceawxVpclLi7YebTylcYxLTQw0Gg2iWhaOmdaEpGdyjwsJkPfhWP2kAbUnjiN+9Mci9rzY8VcfirjlFsf2S9fAWqyuqMqSrJZSqyVkjSzYAk5OEGWRY42nNdWmv9rl8IP7OXn6NFOXzDM732HcG3L21Dr9/hi8QKknp8JFypmSCAXa5Gx0h6RZi3910zXc/K+eyfakwz1/8Ee84/0foqCkU2+ilOHGH22w84oZ1nsjmjMp1167jdGGJanVKScKho3OJpSEjeGAE2dXOXn6JIUvWdvo0hv2cE6TeEe/W3BuI2doDNpXrHR79IykLDy6kgz7Y5T1zGQ1ZjodpBTs3HIZDs2OyzNatRqdNKGZ/uNMhe/F3H46YzBwZIlkuq1oZzE1pZju1JmqJ6HmrWIsAkFofqrXoJF6ptsNZmZqbJ5rYm0wujC+YrqTIoSkVpNsmomIIxGCGlxUiWQiC/UdHbWTOWoDmhuwK/yEggl4h5cTD2IVMvzQq/XkPUJ5NKyV8O8pdf9/MB55BN76loorrxjinePGmxx7b7ccPgK9fkm3XzIcGfrdHF3pUO4wBmcNRgdtnpueEUqhd78j5c//AvbdGXP77Y6X3zLP6WM1PvOphDh2pCncd5/i0OEYYx2V91gJcaJIlSBJZAjmUWjpKosS7zztJKGa0EvLylKXiqwu0MqzUQ1ZXlvlXG/A2npBfz1HmwIZJaRxhogUsYrQxqCdIUlSokjRHY2obNDGL4xlpDUREdoLROLxyuJchLQJuH851s2fAf8P8N6nXNsLfM57v08IsXfy/DYhxHUEM+XrgUuBzwohdnvv/0moWAiBSiIyEYHVGCUZrI65tK0QLcX85jbNesLRw6vESJ7zI56bX1DxoY8nvPAnC84sZxxYyDizWqESD6knSSQ2d8RJHLQ/JpPQGouQIdBbHFIIjLYTIadJvTEKExsZugQvDu+Rk8zfXahj+kkXoQNjLda4CZMhNKaMxgXGVDjvUFF6cY1cqIcK95TnPHlEVpHihpssb/6tijvuiDlwMOLAgYi3vLnL+94X8/jxDK+iwJjwNrg56TGRTPDWIYQnLzVHDjzGy1+hObPc5Fz/auwo5+Tx41x3rWH3CwV//ddRSFuknCRlHiFDXXU0yNHOc931V7HnBc9jS7vJ4sIS/+fv/THLvQG1esym2Sa6MjQ3J+y+vkmCohhZhiPNE6bPdZd3uerSNut5xTO2znHw5GkyZelvaETqmJuewemcXllixo4oFsy0Z/GVo9VuIZGcXV6lX4wYFBXDwqNNYFBlHU/qZ+h0OiyvnqEsoTSeLdMpiVTMT9VCnVn/D2v0/+Jz++mMTj1I9konqMUp9SRIZjRqklaryWCs8c4wNdNGG8357gCPw+BoNBRSpVR+DIllthkzWLU0m4IsDSeEWEqEV2hjAEmkJChCJ/ZECgEVpoW4wL3HTfIfibiQk0cCrMUrdYEdCfiLVRwgbBAynIylCG1X/gIWcHHDCA9LSxF33Cm47daC+++X3HJLAFGXFgMpwBMAX+9BlxolYrQN5Z3KeGr1lGuvLbnr7oiTJztcugn6aykfulcwNX2clbLiV39SU5bhpffssTy8JFiYiB9GUpLWFLp01GNPlIArgvWindhxQjitF7lFudBEVpSWUT6iO66QBlTN0kkStNEIqdmSJYxtjfWVcwwLy7DQ1CIVSCCFQsmU3BkKY9gy3UZgUSZoAOWFoV1P6SSKcpwz/Jfi0XvvvyyEuOIfXH4Z8ILJ138OfBG4baVPBZsAACAASURBVHL9A977EjguhDgK/Djw9X/qNZQUJDic9JQjGJYlIo1ZWS/YMb+JyluEM1y6vcXurSUv/NkV/vQDszz0oOLU2YJff32X9RWHjDqsbuSYSOCFRnhPEgV9bSViEBanJqUJE45pprJYQLoJ8q8mR1nhL1Ju/YT+FR6C7LGMglSClHISWCeJzKTO6F2oOQ4GQ6I4wjuLpJro3VxgHjxZonkykw9MIikFO68w7NunWFgS4A3f/Bb83u/XuXLHBkfKTcE305WktTrG64BpjAriLKHdCUfd5tw0vXHEf/qNs/zBfz3Nlx5a58ZneG6/3bHvjji8tgpghZiIY1XaMCoKbrrhel5+83OYa9T42jcf4r3f+CbdUU6zkTI33Qiql9YiM9h+WQuhY7rlAGkrvI9YXumzNhizZdZz3exOzp9f49pd24lRFOOcrZs305mfZmVlg0PHT9Nq1IhEjjNjGq058mqE8p4xjghBp9OgmUZEzYhBd8igW0DSpVd0ubQ5TVWVVNEIaxVEiiwWZEoyrP5xeuX3Ym4/nRElgrJylKWnLgVxIim8xomY7miIzjWzm+dYXllhkI9BRowLS2lK2p2YJHLMzCUUQ0OzluAamqwek3mQrqTZ8FirOL/qsM7jCFpLUjIpSwYQPgCvAi+ZNCQKCh16IfD+ota7FyHb956JZtQkkttQCmWS9UMI1E+eWZmUK5+c+wsLkvvul7zutY57PzAxTvGTc+9TNpBKO4wpJ5RNSaNVY26uw+GljDyvmGl5vLWUZcVX/86wbUfF3tuCTszb9iVo6/nPt2puv9Xwtjsjlg6Ehkmjw4YGkKUx5ajE+MAqMqWh1JZhGVypWknKynKXXlESJ4rBuCIiIksN3dQzrCp658eM9RrtVo1mI6F0EXGSEktP6gQ+NsQNTzH2bJptU4tTRkUX60IjYjLdoZOmlOMh9TSjVnt6ZcinW6Pf/BTvzGVg8+TrrcBTzTlPTa79k8Naz3BdY4VBxopYpRSlw3pYPq9p1xRCWbbNdth66Rqf/tvtnDrpyBLLoSMZv/9uwxWX5xw7EdQoOx3FxoZGCImXnlhKxlVFo54gvaQqLagIhwElUE4gYi4CkBIRqGMT5N9PxKSwIogfyZBBCzGhi8kJQCU83oeNAMLWMOrlqEgRx5LIG/LCINVEMfAfBPkLGLGQYE1Q17yQ/CAFwnoefAieON6i2fIoJLUoQzsfwCvrUJHCe0s1GgOC+dkOhw4b7rhT8jtvXmH7pZI9L3bs2xexsAjeW175Ss8ll3i++EV44FuO6c3T/MbrdvOjz+hx8PDfcPtdy5TG0mxlzHcaWBfopSICJwJjqtvdYHns6LQUWZIyHpckZCwdXeHan9iFEI4rLt+GtiWS4Aw2rhzr62OsLrl62xaqYsS5QrNSFMxMRbi8TrsWIaOYU+dWEYQsPcIxvXULx0+cRKcahopj68tEzRq1NKU0JWKqxv/L3ptG23VVd76/1ez2tPfcVp1l2bLcy4ZKKB4hpACDm1AYgyFUZYzkQ40iVYM0BEgg+VL13hup0JmEkZDkpSEv9aqSYIzBISSmT4AQKoEYJMuyJMu2et3+tLtde633YR8ZJw8KUJEniaH/GHfcc/c9zbx3zz33WnP+538GnmZ1fUgivyse/ffUt88HRV7hxQKUgNCj1W6gJikb4wmLCw1QkpmoYkxMXuV0WiF4LRJbMZhsooXGlRLRMLS1JF4MsVaSTAzZ0DLX89ES0rGlPzHgHMqBQmKmK+aGr0hLWwvfAVGgqWw9rNo+w7cHnk3BnUIgUEJSSfusjtd/QqmcFnVx58gPgKNulrqzDvJ33WnZt89Op2Txjz6jqupB5wjwPEkYajAVg/6ISZKRlSXOVVhncQiu2wNf+pLiS19WHHhMkxUlv3qfxwufX3HN1Y79B0BpQaMh2dgwlJkgiiWJr6hMPURd2hxTCkwJzchnx0LEIBdcObeV4WiDHTvmkdrDOctmMsRJQ9yOCEVAIAWqEpDkeIGmpQKkkwydI09LJpnDuAS/I6lKyHJHs+HjiYKsdLQ7XTzryLlAPHrnnDsfzW0hxBuANwCEoaSoPJyUlMOUuB2AcJQWzixvMrdzhoV2i7xypOvXMVzts2ULzC9JDh06zoFDHvseU8zPW8JQI4Wh3Q0Z93OcgG5bIcaCSoDJLWGgmWQlwim0VwdVZN2kBFPGgRMg63y9pM73n2s2UULVLAVdc7XPkQjcdM8qzhW3JJgKjK0oTUVRSgoHSom60GvtP1rNPLNecQ7r6itJag8dhRSTCUJMt6xejFKKNCvI8xSpFEiF8moWghf4OGcwpuLsiVMko5wTlrqo+2/rItW+/fUKXinJkcOG173W8q9+RPLxj/8ArcDnRbd9maqyPPw5COOYWNYrPWMdToOpamlnOc3vVoUk8BVCOZS0KAFmWlw+PlQseBlnywGVg+uuuZpobBhmKZPhmFgLlCeQnqZBE1/EPPbkE3TnW4yWoUCTVnXtwbU0a/0x1Thh5/Yd5MkIGUpEHjK/2KI0BdU4J+tPkItLVEwwyfkxFb4Xvn0+CIIAZx2hrm/0G8MRyaRA+xKFotdsMx6XbJmJca5DKwzo9ELGpmQ2DcnTjJOr64S+zzgxBF7AeJzR7xdgLa1xzcmPI0lpNGiLrSSB1lgEk7QgUrXgX2XrOO4piZYwmaqwiinTRpzbBUxzN+d2wUpLbOXQgrog/gxX85+ci3NNXMDemyve9jbDO97lsX+/YN++eoDQO99VD06ZvuAZVs85Iba8LBkNEzSCSZ6TF+V0/12nUJWSfOQhKKraR92UJPHo45JHH60ZPHLaN6CkprIFeW4RtnxmJzLODMYJGqFmqRfSbUq6HY9rd+xAZwolDWo6parZjKlEilMepSkxQJ5UIHxazRalLTGlpe236EYpy1mCNZZBktNAID2Fyw3rlWO+KTCuoNQ5SgniIDwvnzrf0TvLQogt9XkSW4CV6fFTwI5nPW/79Nj/B86533XO/YBz7geUrqvLZSXxPY+aiOsQleXqHfOU2ictHH7sc2JtjUk6IKgkRT5g984uDV2f1Mmwoh0IqkpR5RZrLdpXCM/RbAsW5xTNrgJR4Xl1ILeirm9YMy1vGRCmwoo6XeAJRaA9lKjZONLVfGScQ8na0c85Q70aP0etPHcR1G58Locvz6V2nD33f5i+9hsbWufg3lcbbt5riWKPTqfWvtl7k+XV9xiyNGc8TBhsDkmzlDzLMaZE+xod+BR5RVEaisoxHORYJ55hItz/QY877jDcstchlWQ8ydn3WMAX/ur5aKV45Su/yo+87EtUleXd7/V5+skIXFUXkLBUviVs1FrovpQIC2EYsrgwx1yvjTGOIncgFCpyhA0JvuT0sCCdJGgBTx0/ibGWG67aytZZS2O2gRQSLw7R+OACnNM8fXqZQelY30ipvIpUlGRZRhBKKg8mRUIchTgjcDYn2ZgwXE4YpAZfKsbjAVbkCP1dBfrvqW9/Nx/8zOuBSVEyTFNWN+v5o1Y7UmNYWctY26g12s+sDQgcVM4y7CeI3GHGBenEEAgPjwhl/bpBSoCzFWVuGWcO4SrihmZ2JqTTVXh+TaNtxD7NOMJaaHqaIBC86hUlN91g69nA1C6990bHva+qapkDKRGqlvtWUtXsLQm+kvWwjWkh6tzO95lcvqJe2cs6b797j6tlk/fVzJz9j0re+S7NNdecK2RNNxA4kPVCSkrBbG8G7WmKKq8XR9OqgqBebBRVRWHrYeiWmmSAqrvpXf0Q39OEUUhRlEgh0Mojzd205C3YOtfkqi1L3LprG0tzHg1fYUzJ5uYGT22coYhyREMRNRXGjWl5HmFmGawOOPD4MlVh0U4QRAFYhdYeuShpdBXtUNFpenS7McZJtPK4dc8VLHQ6dDst2lGIpyRxGBJr/3xc6rwD/Z8BPzl9/JPAQ886/nohRCCE2AVcA/zdt3uzqoIwVCz2YGE2ILaadqzZumUWbauaA+z75JXD0x4zM018b8xsq0OrGTMzG7J9qYOpKkprMC7HUbJlIcbXiqJwzM1pZtsetqobN+pcunxG68LiwDicrLWuax8UGGfrvOJUM94KEPYcc6BO1VgBCFcHFDmlrJxLK0656DXzQNZshmnO8pvRzKBuFT98RPJLb7dct6dgPBhxy801A+HwE5LRqODMypgktwz7OZtro1rCoSgxpQEqqtIipEAqwd5bqlr69b0B/89/E7zjnZpf/EXDNddkvPB5e/k/3vhvkJtbuf9DJb7vCEN4+GHNgf2CwlYUrmaYKiVoBBKt5TR1BXiqZj7kQ2xZ0lC1KFMUeRRFiSdjxv0hUWhpL8zQbXuMJpus9Tc5dvwYFCCNw8iKp5eX60JXldOMAtqtmHbXxwUGX0WMi5yNbJPReMDKmT5PnFjn5PqQWCnGacnqOKcqBVHYYbVfsLIxZHNU6+JfKN8+H4wmBa6qV8faB+0BwpDkJZPEsLExZPnsgLXNjCzNmAyGrK1vcvbMOqdWNnn69AarmxPSSYkSmqq0NY0SgTEwzhy2Elw5G6GVo9WQBH49nFpKi5IWrTStSBIgWVyw/Mf/MOKG6yukEOy92fHLbzUsLTqccNzzipKbbzDTRU89qerGGw2vutvgBz6ep+vg6+rrQsh6Fygk4J27BhwPflSx/4BESImgXjDt3y/58IfVlODwjUvr3ObX4pgkCUi4866M628w3H13yfU3Vwgfrr+x4pWvNDznZsdr76meqT9oWXPvmBaHpQRfVIxHFuXVKZxO08fXimaosMYy09JoDRqJDiR+FFFgCBqKjqeRwlLYgvFkxOkzGzxxapX+OKfjRayvFhRG40lBM1J4lDgm9EcJtpQkaYatwFMRppR4UrF9roGgIslrvSnnFIU9v+a/74Re+SfUBadrhRAnhRD/DngH8DIhxBHgtunPOOcOAPcDjwEPA2/8TlgJnqrHA+ZJhawk7UaDuUabKBJ0ex5zMx0meckoSYgCj9ODjNNrEyajAWfXVlhabNFoKBodDUHF3IJHdy4gS0vaLUfU0PiinkfpSQ1O1oODp2kZJRU68ECLOlh7AivrO76cMg6Mrdko5/Lo7hxDxRMIUdXLAllPiXHO1aV6eW7VUrNgKtwz2043faNzaZ5zcNYhZF2Eesc7NW9+c8br7s35hV8oecc76vGIpXFYV6ecSlPTOcssx9e1do8rSsajYsoGslyzB/7Lf5E8ejAgrwz7D/p84A/m+bf37Oa6rXP8zn99kE/ue5BXvQryHLIM7rzTcN31FaWt+wA8XxHFfp1SCAV+XBeiQ0/gqorBxOL5Ae0oYjgqyJKC0ijWh8tcMTeL11Qs9zc4sLrMiTMrnBmnlIQ8dTJlbbmPLVN2LG0jDtt4YYgTUKaC02fXMBaCIKzfe5zjPB8v8Ajimo2SY2h6ta69igXG6xN5Cs9v05QhkuCC+fb5QGiNpzStqF45hlojrYcrJaFWBCpkNKkYJIbl4YS1fsraesrp5SGDQUZlLZ6nSJOSNCsZJQVJUlGW01mzKHIrecELJly3pyJNLWFYc7y3b0m447Yx2q+IYsFMqPmHR+pV5BveMOQnXm/45beUCODzX6w7ZZ94SvK2NxluuqFmnN14veEtP5Nz5KhEI3j1K6a/E66WZAgVNz/H8Zp7qnpUrLAIxbSQO93lyrpoa6cZn3tfbbnl1lqxtl5QSfbudbz2tSA9SVYWHD4iedPP5VRS8NafN9x1l+Ftb6mF1N788yVHjtZMFqnqdbpkOklLKULPp9nSzPR8WmGIP01jNZqK2VmPdktRYeqxilLU+veeoj8Z0R8NObU+YjQwLK9O6I9LRoUgswFZBp2oSRSFSGlpRB7NRoTyfUpbYaoKoRSuVPhSEQeSymSc2Finn07IC4P0NJ6nAUGSpefnUxfDzNh223O3PKeFNZJQSLbNdtjIcoRvaTUCSisp04K5pXnWl9fJK4kf+zx9fJXerEejFZCNChJRko8tcUsx057lycPLNGcUWJ9ZWZLpgpW+YDK2rG2aOienFZWzaOUwpt7yVZUDWzNQnATlwFeKpDBTlUxBNT1BVkwZPGLKDnhWDtJhkaYu4MqpI4spOc0aar6+c88wD4Q4t+L5BvPsx3/cfGNO5x/XLBlXWYSncNU30j9xUHfoGmPrhpi8YmnrDEHDZ31lSBSFbF2YodeI0EIhlOTYybMcPHGa5/9Lj1/+xZqR8KvvqlNnb/+FWtrhV96lOfCYwvc1na7HeJQzO69Ic0F/oyTyFe2mptPRBNrHs4ZSwMnllP4Qrrsp5EV7dpNWE/IiZ2NUEklFBjzvuhs5e+xJZNCgEiNafkguOjx+8hiFsZzuT/CUoO1pUJZsrNAaHIazgzHPuWYH/fEmnlZQaEqhMGlB4RzXb52jSEfkacG4FDz0mROXzMzYV/3YLkxREapaLMwL64a1slD4WqOKuht0mE0IIx+EoEgN48xgrUF5kJQpkecx1+pwanODdGjJMov0YW6mSaMpuGJ7zit+dJ3/+08jnj7uc9U2w4//2Ig/+ECLEyc0gbJ0fY+NzLBjp+Pfv6GP70OWw//+q5p9jyqUBO0prrvW8LY3FXzy05qX32b4vd/v8Mh+gbSO3dfl/Pwbc379tyMe+Zpj717Hm9+Y897fDNn/KHWfSzVl+UxlR+69x/DEkXpcoZOCW/dafvltJV/8W8lv/Jbm5hsr3v7Wine8x+PAozXnXUjYu9fy5p8t+IevCV70Q5a//oLguc9x3PfrPl/bX/cGBIGmqiDStSCa9hWzrYAocuggYDiaMDPbrBcOoiAIoNdtgKn7cHJTEIUeVpacPjvBDzTzrXlCv+5sXxv1Cb2Ahm7QH1nSZIwIHN1OhNT1zS9NSwpTUhWGUgh8p2hEDUajIUHg1V2wVhB6EPsaD4kS9ejI939w3z/yl0tmZqy1Dj8QFHGFFiFlLNm5NMfJ06uc7Y+4YluHkYDZRsWKcyz2fKQfEF+7lVxa1jZO0/Tb4DTEY3qBYkYqql0xlbEEcYOVk+swsly1o8mJMwXpxDHKDLaySFcLq1nn0EoQeJKstDUH29YiU1rW1DJnHVbYZ9T8qOrI7KR7hhPvhAMDUqmasaPFlF1Qb3XFVBaEaSMJ/2g3NpUPFoIbbzL1eMQ/red07ttXsW+/RKl6Hui57kNhIcnsMzsDrSU7d/UojOPWa3ZidljWByPGozFHVtcZJymTvMDzFPMzDa7bU/Dlv9X89d8ovra/Zh/8yrvgRT9k2bPb8ehjtf3JpJzKKzgaccRwrcJUjgJHVUJlK5LMMswMFsnW2Yig8jh5bJWVLKPVCBlnhvXccMVSjydOnKRSPv21DYb9jKRaodMK2bLQ5exwxFKvi5IOLRxBJdk0JUEbRv2S3dt6CAtSWawGVzoikWPbTXa1Z3AmJS8tjTAmjC4trZtW5FPoEl94JKnBlA7Pt8S+h+9pxus5s3GDSTmGyqJwxD5UQgAR1uQUApqtAO1DiE9ic+LIRylHmRk2TUl/ItHeLD/5Y6t8/euO59ya8sf391heDei0KsLK4kvHzoWQdvsbI+ykgIVeG9/PCUOPsiw5eEjzmb9yvPbVJR/+s4DVMw16DYOj5PBhxXveH/DWn075xKc1t7/U8L7finn8kCTSFomknxag6250pODIk4K3v9Xwzvs0jz6uQNcr+xf+b5aNTcNdL7e8872axx5X0xV+nRJ6/HGPz3zWcc/dBQceF7z4RxwfenD6POrBIxaoXEWSO+ZnmvRmAsLQ0ogl7SimE1nmt/cIPcl4PMZUJVGkGK2NKCVQCCpdIRvgqQBfKJLEEGpBEGo6zRiFh5KC7XNtzg4LnHT4nk9RGkZZzuYwpdcMEcYQNyNCHWItzHU7zLUbLI8G2KqiGYa19IpzFJXFa3rn5VMXRaCXUiCsR1sLwiDESsvJM2sMJwWtjk+o63FgG+sTlrbOYUaGvVdvZXkyIqkq5lsRZZZw9PQq7ViSGoPpj9ChR5qlDNbXWdms6EQW18+YbftMNg15IdCBqFUe201Org8JtWax6bE8KXDT+bGBJ5BSI2WJqRzPxOlz1LBpLkecy+erWixNIShlrRhoqRuwhOWZ0WWOZ9HSnvVeArjpppqB8M5314yDffsEb3+bqRtIprLG51gMTj6TEarTQk6QpAlz7TZfeeQQo3FSp6pkrXmilKTZCpGubur6+Me8Wv1UCXAFTkoOPFZ/AVimY9pmFGfPZGQTj7kGxE1FWTjy1FLGAuMyKisRThBozfalgLmeT1FGPG/bDs6uneXqKxdBaQKtWRv3yfKUKBZor8WMbOAJkJVEjS0T12eu3cFHghFgJdmkojSK0+tj2ltjysLR30xphw06cYjyDXmZIHBs2bodmySk50lJu1AohobcVfTTDIDA83GeYjyeMDdTEnVisjQlKCCKQ5yumU5pmYBwyMCjNzOPrQTLmwOECgkiaMYNhM0RImdUSvKk4Gv7QhbmIl74QxP+5kstTpyMUCFkRYm0Fi0tW7c67njNBtYKHv5EwIt+OOen/v0GkyzkxPGIyoPdOwtue3HJRz8WcPtLSkyiOPKEz2R9QBF7HD4q+eRnKl57T8n9H9YcPKSJlMRVJVEgmRhFhUVoiXWWfY8p3vFewdvfYnj403DHywzvfm/AjTdU/JvXmvo9Duq6Y77pY4oKB1x3neGlLy756y8qfvgFFZ/7vOT22wwHH9d89RFQoUJJSbcVIah36q6CvAS/cihtWZxvUqQpm2mFtIaqKBj2LaUsqFAMNjOC1KPtQuY7EU54FGVF3GxQFZCOcnJXz1CQcoT0Hb6UhIGHyC1R1MUUFcl4wGzcxlUKpyXjLKPXjFkbDOg0QtbHA0ZpDsaQZTlSWXzbPi+fuigCvXOOQZojsoowLrETQaepcFHJyqhiOJJgV1jqNFhA4wLB1x47ymy7RZqUPHV2jbKatnXLJr0wYFJmJHmOkj5GpMjKMNh0+J5jrlMyvxDS6saIKGf5bM4wGXPL9Ts5eXKDvCjZ2goYFgXGCALfpx0pNsbplHMscFqghJjKtlILmLl6DKCtIAgDSlERV4oc80wDlVSqDurG1vRjVefrhf1Gvt4C11xrnwnyOMe+A1Md/T2O/fvru4P0JK6o+W9OneuyFczNzZCkKWvDPqGnEUoSqFrGFVdzpXF1Ya1ytQZQZaHhafBqcQipa7kHTwu0F+D5mjwrcEiE0Jw6nqDD+m/RSjI300C5WbbtCplUA0Qp8XRO4Ql292LOjNYIFn1QDk9AEDmaVrFnaSvLy2uczDZ5cnnM9TsXEK5ifts8Xn/CeJyz0G1jkVy53XK2v4ZnFUIGDIYDOs0OV852CQLB4WN9ts93IR8TRiHJpE/T82jL82MqXCgcPrbCYq9DWSlGoxwtDTMtRSkFTx8v6DQTtvS6aKHJqowrZ7oEcYhcg6TMqSY5xaRu8lkIIjpNzdhISlNSGNCqwdZGm2FSEccnee5zMr78d22ec+uY08c9Th0LWB6WbCQV61Lw4j0THPDJh2c5vRzjrOUlLznFXXfAp/7aZ8u2lNfckfLQny1y+nRAlk545StP8ZEPtzlBRCQcM7MpL3+p4f6PeNz+spITJxybKxGxCji9kbN1PsRZyeoop7L1tfXYYcmnPiP4sdeUPPBRD09L7nhZwQMPetzxspIDhyWD9S5FUbA5gOv3WN70szl/8Zchd92Z8V//xOM1rzT8xV+2eOvPJXz8o9s4eVKSpbCWWLZvV8z7bVQgWVzq4IqCx584xUZSUmQpge9TGk02Kek2BZvDeu7CloUQowxHnxyx54ouXqOkLWG8MQYl0UozTMekmWNls4+w0I41ZxojAl8xGwY0Y8Xc1qsYDxIIag0i34IQFU45ZpRPKQNGeUaoPeZ6XZSQDCfZefnURRHoTQXKKHqzAYUpkJ7AlhpXCiajgjDQaK1Z3igR0tD2FKaseKJ/Fk8ESK0YjhIaocbmOcf6eU1JrASb40nd5OAECsn6hqEdR+yZi/ny4QGd0DHXCxhJwSTZIE0TOu2IRuAoSp9CVwhnecmLc1r7HH+3T073fhXX3+TYs9vx4McUytV5eykFaEklHL5SCCWIpaY0FaYwtV7IuRZCr6ZpSjUt2hrA1R27D350SjPVDmlqTf39+xUH9tW5/7opBUoxFZk6R8HH0R8M0Z4i8CArS5SqewQq6fAUFHnNFAqkQluHUm6q3+HwpJjOGa2LzJUThLJCVY6NfoXwHWHkaMcx/VFGsxkibUaRwzXbI3wJhZF4scCIiEboMTRjOrMN5mJFZh1R4LO+fhZbwKEz64zKnH5W4hnN8aeGXLF9C5UxNFo+flliyxFWe/QTECagYILyLVneROcS5WfM6VnUFmjO+Jw9U1JkMDPboRPFaHVpBfqygpNnRwS+x3wrQAKTzFAJy6gwZJlAVZsIrVGeZpjniLSkSHIqCvK0IgorgqiBdBVCC0Ip8L0Ar3R42uGJnB+8WXDL8wY88JEOo/Ei62sZr7j7BA892OHoaUtSWmZaIWvrJQ884LO8KhG25PFDgs3+LL3ZhGQIs9cbPvrxNqNxhIwynjwODz88y5U7S46fyNi5s+I1d494/wdi/v4RxZEnfd70H8Y88IBi/YRmsedRolkfZHXOX9WLpBuuy3nZbSUfeSjgzpfn3Pnykvf8esiBxzQHDyne8tM59/+x5euP1dLLu67Kef/vRNx8g+RP/niWg0cibFqydWvG3372RuaWTnLiTIutO7vctWsbx1ePI51jlI45uzymGDk2RzmFrghyyWCSobwAU1jGaynD3BGHIRsbGcIzGKOY5BAJGAwnNLpNJsOENM8JQ023HbLY6fLU0U2ywjLbaxIqj0B7mCqH0hBFEZUt8HVAq+PTT1L6acam8nDao8oKTF7ilAZZNxqfDy6KQO/7isqTxKFCpB6dmZBkDJXSxKpgfrZLSL3eIgAAFy5JREFUmhgmZcrKYJM1KagmmqihOLbWJ/QEccsjjCTjjZLI99EenOxPsKWgyGsKYLOpcNIjE2CFYKYbc2Ztk9leyOZmiRpBt6NxOidshsxax3phMaVlZrbkrT+f8Z9+VfH4Qc3em+CX3mL4wpckwgruucdw6Ajsf1QihaOSlr3XO67aWfHwJyKUExTG1f9xBUGoKWxV8+ntNK8vXM0+mOopODtV0HTT47auZwhRSyRoX1FNU0lOCpy1eFNGSpqnkEruubvi0JOCAwcl99xpOfp0Lb+6e7fjoT9X7L3JctXVhgc/qpFKUpl6GLqcUuCUVASeT29W4JTAVZpG6JNMcpyEVkvh4VGUCaMsIJCSSmqyfMTc7AJa1/MA8izl1Kggcm2Op2dpdDR2nHBkzVDakm5Tc/Vil9VBxqSo2NaLWZ2sErYjSDOKasJ45FBWs7GSkVSWW6+apz9OOY1Fxym9mZjl1Q02JyCdoShXqWbmSKq1C+vg3yUWZmKW13OSsmRtBO2WJsPiW8X2XkSWplgHcUOCruWMnecQocRzIVU8baLTJU5KMgtFblCypghXDmxqmOtaHv6LJc6e8vGClMOHLcVklt7cmKKUOGoW2Wc+G+EH0J4FoTR5bjh7usXnvmBYWrB86fNttmzv4OkSXylK7Th51uP0iYA4tFy5Y8CHPtphMIm55eaA0Bd87tMZV++aUKz7NAJHFfjoyCM9NSBqBGzfOuKN/y7nvt+MOPVURLttef7zpo1QAvbtE/zhH85y9a6KU2c7bJ+Fxx6xpMbgyoBeO+L5eyJEZdk85TA5lCzSa1pwBfufegodatZHA7ABo/UJSVniaY+gqskaUegjbAhU5ALaTclkMmZmJsLTMSKG8cgAHpmrKPpjsrykLBzkjnY3oj3b4F/c1OLsqE+v3SCSHtrzGAwrNvsjtPYpnaQbhRQmoywNVVFRANl4gqwMWmgEAiE1lSu/jfd8c1wUgV5rwZ5rumghMVVBWQS0ZyxhXrJldpa0LJgVAVdtm6NfJARRwGg8oZiUdOdnCKXBScvqZp+5XoOldhcZCtIiJR85NkcZnXYI2nL11hnQBVfcvE5vR5cvPhJisezaGjK3VHDD7pLPfzGkSEpm2wEycwwnmsOHNbfcmvOf3lbx538Jr7izQgj4/BcVOMGTRxVv+7mMd79fcfxIyJYdI97805b3/WaMFpJKOV73Ojh+0uMrX62wwhFGmuv3GHbvqupJWNLVzVh1huVc3xhOO6SoaZfneMj33mt58pjhK4/UvH5hHTfd7NhzTcZHPmLwPEVlHYeekLzl5zJ+7wNtjjxlePubc5yDX32Px43XG978ppL3vM/HVJZYCpwUdKOA0lQMjaQbNYlDR2kMvZmY8SSnKAuE5zHfjJnpFbSCFjMzbbCS2CmGRR9fN7FZSho5hisTUlPRjNv0GhXCUwxHBcsrm9x4/Q2cPnaGE8vrBIuOuBkR+yUijFgK5rBWs1wuMzEefqiQWtPNKtpUZHlGaca0ZJtjp86wEvl0wpBuO0BLzWyrgac87OT8pF0vFLLyG5PNnIDBuCQ1ltCTtJzA8wRKKzJjkU5R+VXNz25HKOGToCmKDD/yUb5HNjZM8hTlDJHvE/ohRpUcOOBTFI6rt4WcHWwyGJbsO+AYj3zSvMCUjoku6xuKpzAVtBoBXuihnOXGa3ssdnsMJxuMS1sPiHcQeSHCORQVjTDk0a97NGJFbyalFTk6wiPpd1g95VOUKZQGpRRLMzFJltCeUdx6i+CP7p9l/+GM2SZ84L/HfPmrFTuvKth/UFI6yIezbJ5uc+OOgPFwA0dC1jd04kUmkwGBGxJ4XaokR2uPZjdmVGQ8dXqNMO7iygE2z2sSQVXTGFvNBqO1VYaTCu2BVBVCaHYszXBmbUClNGkJntUY4Qh9ibSy3h0rj9w40jQnqSyZTeh12jS7ATtaHYJK4ozADzRV5HHfH+779s7wPcJFQa+cm4vcj9y2SMuLUJ7m2IkNFuYbGMbEskUchaycHrGjN8PTgz5UhqZWVL5kJSnp+k3GSZ/M5vRmWkTao8SSbhrOrk7IrKXXjMnKFE/4GJ2x+xrLj9874sGHOjx1XLP7CnjFv17jQ/fPcvqUIiwcWlmips9aIvECR7c75id+ckAQ1Hzz//OdAY8d8ggCjSkN115b8gs/m/OFLwX88Aty3v9/tTj+RID2LZvjnF3XGH7xZwru+82A/Y9Knnur4md/asyv/VbIkYMSnKwV8KaCks44lJI4Bff8aMHRJ+ohCkLXXbK/9JaCz/+N5P2/q9h7o+Ntbza8+9d9vv41gfIkUtbF3efeYvmZN+Y8/CnFXbcbBPAXn6hpcO99n8+jBxWmcPhRPe5NVZJ2IyIILXE3ZFsrAGnx4xZr62tcce0WYi8iGWySpAkyCFmaC+mfGZAJgys95roRhgkTU3HqRMr8bIvt7W2UIqMd+SxP1lndGLNn+wKiaJDT5OljR7DasDDbJbMVwhmaKmCQlPhKYNKMVEIkJVvntnLoyBGuvPIKymzMpHJkhUO4kl4nRBtb3y0dVE7w2/fvv2Tolc//V0tUxlKVFXHsk6QFVVXvrtpNj0DX5zAKFcZJGqGg6fvowEN7EcP1MaujTf7y4UtrJ3MZ54dLh15pLMoqjh5foxH5VFWJsJpEBQxWNtm2Paaz0GYyTJn32iS+odXwGE6G+JUDYWg0wqmCoePk2jpz3S5Oe0gvoxe1aMUx/sSgA8dmpnn88YI/+VCH19/b56uPRDz3ORkffHCOo6dCXJ5MW58rbCbodhRplhGc09sGEPWFFoeCOPApGnBqWfGpz1Xce3fOQx+PsMWVzC0OyTY2aEQeTxxT/Nr74S1vzPjEZ3xe/tKE3/idBk8crCVLY1+SlJrSlggt8Xxdt2m7isNHBb/05pJ33qfZf+Qbp+1FP2QZDgR33F7x7vs8Hj0gCZs+rjRYHEEUsO+A4TOftbzu1QX3P6jBOl53r+HBhwIOH/WhKrDOobRPkRSkpqRByNb5RZSXs5IMWZyPaSuHN9vAt5JIG1zDx1KhfYMSgjQrUM0Ql1oG6wnRdo9G5tFrSWSlOLq8zLbZBqWv8FXA7i0dRhPwZEZXaxYWm1jhaEUxIsnQKuTsygbDpOTKxTamMsw0IlpBg7XNda7etYMtnRbHVjKaHgSqoNeaJStKRFhPTTK2Ioy+ecPUxYov/9XZC23CZXyf4aII9KaqG4smRclgUjLTielvDoi7MYkCM7J4rRS/16baLFn0wY89BlWAbwKKfEC3FbO5OiQ34HseLTROlGzZ0sDmObmrubDGFHjOMdua4/RTlkf2lfzwD435+y+3SUZt2nrCMNVkrsI5iZUZM1GLa/doXvjiIc4JPvWZBi98wZif/5mEX7kvYJQLts55zAYlt7+04sMP+bz8JRlnTp+CtMlIzVAOJqT9ikOHfB7+dB10P/iA5vTJDu2mIE9HBLHGL0qoAjotzSQtKMp6ytNjBzTvfJ/kbW8t+ctPOu58ecV9vx6y51rD619reOCjHgcP+ygN7Y5PnkgqY8nTnBtuMLz0JSUffsjnR2+vlRzv/7DizpeXHDoS8MhXJSiLtI5rt82jBKS5ZWVtHS/wiRoxZWIxs5ZeN2YwGnF2PaXVCHDjIWN8kkEJbUNuMlZXJ2jpMRe28ArHwkwDQ0BY5nRmI2TpMzq7yppLKShxqeW4PyCIBJ6EXq+DP3Iop7hyy06OnTlKf3OdhWYPk4MLNVk+IehoDp86hQ4iuqHPapmyOckweY6HoD8ZE4WK8jwpaZdxGd8vuCgCfVlZBsOULb1Z1tfHJEOH8yoCnSIqj+NrFd18yNaeYtkYFn2fKxdmGZYFnk3IrU8xTvCCAKUtgZYM85QdXY+VXOL7IRtJjhKKIGqxtKXH6iCj1z3Oc/YmfPl/NNl784ijTwnEsMVqOkBXkpGzbO36nF0f8IIX1EWQv/7iNlZP9/jwR09w76v7vOZuwee+1GBpy5BX3ZbwoQfmOHmsi8iH/MSPr/LBD+akkwVmOj7WwdxSyu23lXzoIx53vLzkzKmErD9Hmlg2hil+pNgaN1kfZhgDUtfN2qWC/Y/Bpz8b8Pp7cx78iI9SkrteXvGhB31uv63gsYOKY6diGoElzwy+9rn+2oI3/WzJ+94fwJSeBnDkaMTTf+Dx0z814Nd+w6fLbrIk4dTymCKuRQMaDcvcljbPuWYrG2tnWR3WQ74Ll5CZCflqSjbJmFlsM0lTqpFlVCQ0u236/THjUUpLBcTNiKpMcIHCLxVZVuB7IWmWsD4e4REzGIzwtaITa7LqLFKkbG9vI9IVuxcXIKgHL4Q6IIoC2kXIbDNkfVxLWG2bWWLQX8fZkrl2zImTm8zO9uh6go3xpZWjv4zL+F7jogj0AKdWJ1ibsG2xRVhZCuGx0s8QHmxMCrJMoapNnNIUUnNqtU+ykWJlgXElZlwRtyv8qIkwJSoQVEIw09Qkaclir0syKWg3FULl/OAtJc97/oQPf6zDxuYC68sTXvWqM3zoTx2TE1DkBZ1WSGod0lrW+vDVB1r0x6Btn9XNiIc/o+g0E9K+x/wNlgf+PGY8bNLbXnH4TE7+UIurroTPndggakXcskvyY69Oec9vxPzDPsfBQ5o3//SA//4nFeFyg/VEsTUOyMqSSlQ0Gj5FUVHaCu0JbrjWcdtLCj70kMddtxfcfnvBe98X8bX9kscPS37ujRkf/GDMowccxtR/w+7d8Ht/2OXUMc2LXzbiXe/zaUiPG/doPvxxx4MPLPGvXxLzyc+MMVqg55vs3unYGS8wyUpmFmIaLYXJmhw7vckg36DMMkJPEzbbDDdhsjphpuVzcnPCqPCIFmFxKebM6QmbKHq9jFxaosqxNt4ELQkCH12kNJshZgRJloDnUQiFEQY8kOUa7dgDK5hvLJIUBYUoaboQmY85PdBEnmR+JiCf9Gn4ERuTMSMES/MtWr6HQyHdd6VHfxmX8X2HiyLQ+/VUbax2HDszZNdiC6NKCgkd53HVYkwy7e5szNZ6E5MqwYQFJgekovAyfEIUKV4gaccdUjeBrMRgiaRkUqXoQqEyya7nav7iY4t89X9k7LrSsLLc5rOfLJlbHGKMQvgeYeBTWIufSL7wZUlHdxmmGdamIFocPbSDxw8+zvy2jAcfEGzfEbI0J3DCkOWC42d9RisNmsGQ4bhgz7Vjfv+/NXjiqZCwkbHab/DpT8xwzVUj9q0a9mzzSazPyZUR7VgzzAwOS7fRZccVfd7yxpJ3/0bI00+GzHYm/MsfLDHW4SnJ448Jfu/3Z9h7neXgQUk79tiwOQ99TNFsWbbPB+z/SkzhJMpXHPi6oOGvoMw1HHtUcHbwdX5w71W89urtHDl1FC0LjCg4u7bOcNBksJoxTA3WWqJCM0wLxsmQZtOjv5wS5BWDCbQbERvrKevDjNALOXlyzA17OhQpjIcT2nNt0nHB5nBA6Ic0GxLhxSzOtDnw2DKbBnZ0Y7SrZSc8AhKX0taKqtVEiJI0zdk2N8damjMqCljv09QBMmrgISgmCZEM6tGOZUIcn9+czcu4jO8XXBSsm1bLc1fsbBDEmryqaBFQyJJxVrNlti1EpMmQTsMni2Cp28WXDuMcymshSkvSH+FLgfEVE1vhWYGWPoNkSJYmzEQxAojbDUaTER0vYLN0zMx2Ob28ymQjwSE4u54yTCqEFczOhGArhHQs7fBwwkeJgKyfsLQ4z8bY8fWDT3H1tg5KCrbt2sJwcpq5dpMzq5tAgFdVaOXhVEGWa0auYmG2i68ksa6ww4r+eELb9yiLEt0M6BcB6xt9jp9OabY8gjjiB29d4fARxf6DCl+AQnPNNTlXX2X4s4/7VKVh+9ICEkWnJ2h5Dlt6HF0d0m0GzM15dOOQthfhbIXyJGvDEb3GPIPBWVQjRIcWiSNqRpzZWMbzOuSTgv6ZIUUAvvBQzrC+muP7ksBvIoQkLVKo6lb08WBIbzZGKEUj1GwOM5TnM9MNGI4HaKmockNSVXR1QOhJZhYWCQKPcmR5cm2Z3nyLHc0u6+MRW2cXePypIzSUptOboT9KuP6qq6DMOPjUUwzLHE/7bJmbQeQVZwZDfFPRDQNmZtpIGbCyvsZvPfT4JcO6uYzL+G5wybBunBC05yMmg4y5XkxVWSbDilYjwGDqmYxa0s8MuvJYMQNmAg+tPIgnaCKSrORkOmD7lgV2L85y8vQ6woEWMZPxiG4oKVE0lSIOGzTbAXFq0EaQxgEryxO0q3CFYDwxCCvwZEG359HqBAyTjLnQY2Zbj1WZU8ohi52Au158Nb3GHGsbJzm2toxwmuPjBF8p2s0WJGOiIGCQK3Yt+hwbD8mrdeaDHiItkc2Y0uQMhinSGISBhcUGeeLTbZcsLHj4Dcm+wz3SRGPFJkiJ8gSPHvX5yn5HIxCkuWDnUpO5mQbNqMl4c5ncQbhpyEpY7O7g1PJxVLtP4M+QDTLavmQ0OMNCr4OJFV87fIxmq4db3cAZQ5FsouKQDVvQ8To0GhH9lWU2RoaZTkDgV6SloxE2uGr7PAeOnsZoj3Hh6PkBm6s5nYUuNskRlSJWGk/7JFKRnplglWGSGbbaDfZcsUR7MaQxt0SEJp8U7JibRUjDUq9N6EVsbozwgiajtXUSDC0/qIdWWIOwlvFoQNuDuflZBhtjkJI0HaMvMdbNZVzG9xoXxYpeCLEKTIBLlfg7x6VrO1za9n+ntu90zs3/cxvzTyGEGAGH/v/+3O8hLmXfgEvb/u/E9u/Iry+KQA8ghPjKhdhafy9wKdsOl7b9F7vtF7t93w6X7b9w+F7afr6jBC/jMi7jMi7jEsHlQH8Zl3EZl/F9josp0P/uhTbgfwGXsu1wadt/sdt+sdv37XDZ/guH75ntF02O/jIu4zIu4zL+eXAxregv4zIu4zIu458BFzzQCyHuEEIcEkI8IYR4+4W25zuBEOJpIcR+IcTXhBBfmR7rCSE+JYQ4Mv0+c6HtBBBCfEAIsSKEePRZx76lrUKIX5qei0NCiNsvjNXfwLew/z8LIU5N//9fE0Lc9azfXTT2X2q+fSn5NVz27e/qw5xzF+wLUMBR4CrAB74O3HAhbfoO7X4amPsnx94FvH36+O3AOy+0nVNbXgQ8F3j029kK3DA9BwGwa3pu1EVo/38G3vpNnnvR2H8p+val5Nf/E9+47Nvf5OtCr+ifBzzhnHvSOVcAfwrcfYFtOl/cDfzR9PEfAa+6gLY8A+fc54GNf3L4W9l6N/CnzrncOfcU8AT1Obpg+Bb2fytcTPZ/v/j2RenXcNm3+S7sv9CBfhtw4lk/n5weu9jhgE8LIb4qhHjD9Niic+7M9PFZYPHCmPYd4VvZeimdj58RQuybbn/Pbc8vJvsvJlu+U1zqfg2Xffub4kIH+ksVL3TO3QrcCbxRCPGiZ//S1XutS4LOdCnZ+iz8NnVK5FbgDHDfhTXn+wbfN34Nl569U/yz+PaFDvSngB3P+nn79NhFDefcqen3FeAj1FuoZSHEFoDp95ULZ+G3xbey9ZI4H865Zedc5ZyzwO/xjS3sxWT/xWTLd4TvA7+Gy779TXGhA/3fA9cIIXYJIXzg9cCfXWCb/qcQQjSEEP9v+3aL2zAQRVH4DCoqSVBhKmUrkRJWVmaQZXg5AcUNTjYQlv6ApkspCZgxc6yQauyn80mWDAyu7DtPskd+7M6BFfBFzt2UyxrgvU7Cu9zKugdeU0oPKaUFsAROFfIN6hZy8UK+/zCu/JPqdpBeg93uN4Kd8w1wIe8it7Xz3JH3mbz7fQa+u8zAHDgCv8ABmNXOWnK9kV8B/8jf9bZDWYG2PIsfYD3S/DvgE/goC+BpjPmn1O2p9XqgG3a75/DPWEkKrvanG0nSP3PQS1JwDnpJCs5BL0nBOeglKTgHvSQF56CXpOAc9JIU3BVFRsqI7AFTFQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5f45d137f0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "config = dict()\n",
    "config['threashold_aggrated'] = 0.1\n",
    "config['threshold'] = 0.2 # the threshold to select points in every warped image (only used in 'pts')\n",
    "config['aggregation'] = 'max' # 'pts', 'max' not implemented\n",
    "config['num'] = 25 #50 # how many homography adaptation to perform per image\n",
    "config['patch_ratio'] = 0.8\n",
    "# example usage of homo_adapt_helper\n",
    "pts = homo_adapt_helper(clr_img_array,model,config)\n",
    "\n",
    "print(\"homo_adapt_helper pts size:\",pts.shape)\n",
    "\n",
    "# show selected points\n",
    "fig=plt.figure()\n",
    "fig.add_subplot(1,2,1)\n",
    "plt.imshow(clr_plant)\n",
    "plt.plot(pts[:,0],pts[:,1],'xy')\n",
    "\n",
    "test_warped = clr_plant.transform(size=clr_plant.size, \n",
    "                     method=Image.PERSPECTIVE, \n",
    "                     data=invH_np,# test_H, # test_inv_H, \n",
    "                     resample=Image.BILINEAR)\n",
    "# warped\n",
    "fig.add_subplot(1,2,2)\n",
    "plt.imshow(test_warped)\n",
    "\n",
    "res = warp_pseudo_gt_pts(invert_homography(invH),np.expand_dims(pts,axis=0))\n",
    "res = res[0].numpy()\n",
    "\n",
    "\n",
    "# pts = torch.cat((torch.from_numpy(pts).float(),torch.ones(len(pts),1)),dim=-1).transpose(0,1)\n",
    "# res = torch.matmul(mat_homo[0],pts)\n",
    "# res = res/res[2,:]#.unsqueeze(0)\n",
    "# res = torch.transpose(res,0,1).numpy()\n",
    "\n",
    "plt.plot(res[:,0],res[:,1],'xy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def homo_adapt_helper(image, net):\n",
    "    \"\"\"\n",
    "    INPUT: image should be a numpy array of size [height, width].. \n",
    "            net is the base detector\n",
    "    OUTPUT: pts of size (pt_sz, 2), [x,y] \n",
    "    \"\"\"\n",
    "    # hyper paramter\n",
    "    threshold = 0.9 # threshold to select final aggregation. Here it can only be int (1,2,3,...). \n",
    "                    # 1 means that one warped image indicates this pixel as feature points\n",
    "                    # 2 means that two warped image indicates this pixel as feature points\n",
    "                    # now 0.9 is used, which means that as long as one warped image says this is \n",
    "                    # a feature point, the function outputs it.\n",
    "    config = dict()\n",
    "    config['threshold'] = 0.2 # the threshold to select points in every warped image\n",
    "    config['aggregation'] = 'pts' # 'mean'\n",
    "    config['num'] = 2 # how many homography adaptation to perform per image\n",
    "    config['patch_ratio'] = 0.8\n",
    "    # run homography adaptation\n",
    "    net.eval()\n",
    "    with torch.no_grad():\n",
    "        a = homography_adaptation(Image.fromarray(image).convert('L'), net, config)\n",
    "    prob = a['prob']\n",
    "    width = prob.shape[3]*8\n",
    "    prob = prob.squeeze().view(64, prob.shape[2]*prob.shape[3])\n",
    "    prob_list = []\n",
    "    for col in range(prob.shape[1]):\n",
    "        prob_list.append(prob[:,col].view(8,8))\n",
    "    prob = torch.cat(torch.cat(prob_list, dim=1).split(width,1))\n",
    "    \n",
    "    px = []\n",
    "    py = []\n",
    "    for x in range(prob.shape[0]):\n",
    "        for y in range(prob.shape[1]):\n",
    "            if prob[x][y] > threshold:\n",
    "                px.append(x)\n",
    "                py.append(y)\n",
    "    return np.transpose(np.array([px,py]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_results(results, num_to_show):\n",
    "    \"\"\"\n",
    "    show results from homography adaptation\n",
    "    INPUT: output of homography adaptation\n",
    "    \"\"\"\n",
    "    prob = results['prob']\n",
    "    ori_prob = results['prob_orig']\n",
    "    patches = results['patches']\n",
    "    images = results['images']\n",
    "    counts = results['counts'].squeeze(0).squeeze(0)\n",
    "\n",
    "    # show aggregated results\n",
    "    fig=plt.figure()\n",
    "    # show original image\n",
    "    fig.add_subplot(1, 3, 2, title='Original Image')\n",
    "    plt.imshow(images[:,:,0])\n",
    "    # show without aggregation\n",
    "    fig.add_subplot(1, 3, 1, title='Without aggregation')\n",
    "    plt.imshow(images[:,:,0]) \n",
    "    # inference\n",
    "    ipt_sm_1 = criterion(ori_prob)\n",
    "    ipt_sm_1 = ipt_sm_1[:,:-1,:,:]\n",
    "    #find the max entry and confidence\n",
    "    idx_conf_1, idx_locs_1 = ipt_sm_1.max(dim=1)\n",
    "    idx_mask_1 = idx_conf_1 > 0.4\n",
    "    px = []\n",
    "    py = []\n",
    "    for x in range(prob.shape[2]):\n",
    "        for y in range(prob.shape[3]):\n",
    "            if idx_mask_1[0,x,y] == 1:\n",
    "                #location in the image\n",
    "                x_ = x*8 +(idx_locs_1[0,x,y]/8)\n",
    "                y_ = y*8 + (idx_locs_1[0,x,y]%8)\n",
    "                px.append(x_.item())\n",
    "                py.append(y_.item())\n",
    "    plt.plot(py,px,'.r',markersize=4)\n",
    "    # show with aggregation\n",
    "    fig.add_subplot(1, 3, 3, title='Aggregated')\n",
    "    #plt.figure()\n",
    "    plt.imshow(images[:,:,0])\n",
    "    # inference\n",
    "#     ipt_sm_1 = criterion(prob)\n",
    "#     ipt_sm_1 = ipt_sm_1[:,:-1,:,:]\n",
    "#     #find the max entry and confidence\n",
    "#     idx_conf_1, idx_locs_1 = ipt_sm_1.max(dim=1)\n",
    "#     idx_mask_1 = idx_conf_1 > threshold\n",
    "    px = []\n",
    "    py = []\n",
    "    \n",
    "    prob = prob.squeeze().view(64, 37*50)\n",
    "    prob_list = []\n",
    "    for col in range(prob.shape[1]):\n",
    "        prob_list.append(prob[:,col].view(8,8))\n",
    "    prob = torch.cat(torch.cat(prob_list, dim=1).split(400,1))\n",
    "    \n",
    "    for x in range(prob.shape[0]):\n",
    "        for y in range(prob.shape[1]):\n",
    "            if prob[x][y] > threshold:\n",
    "                px.append(x)\n",
    "                py.append(y)\n",
    "    \n",
    "#     for x in range(prob.shape[2]): # 37\n",
    "#         for y in range(prob.shape[3]): # 50\n",
    "            \n",
    "#             #location in the .shapeimage\n",
    "#             x_ = x*8 +(idx_locs_1[0,x,y]/8)\n",
    "#             y_ = y*8 + (idx_locs_1[0,x,y]%8)\n",
    "#             px.append(x_.item())\n",
    "#             py.append(y_.item())\n",
    "    plt.plot(py,px,'.r',markersize=4)\n",
    "    # show homography adaptation\n",
    "    plt.title('with aggregation')\n",
    "    fig=plt.figure()\n",
    "    for j in range(0,min(num_to_show, results['num'])):\n",
    "        i = int(torch.randint(low=0,high=images.shape[2]-1,size=(1,1)).item())\n",
    "        # get px py\n",
    "        px = patches[i][:,0].numpy()\n",
    "        py = patches[i][:,1].numpy()\n",
    "        # show gray\n",
    "        fig.add_subplot(num_to_show, 3, j*3+1, title='Idx_'+str(i))\n",
    "        plt.imshow(images[:,:,0]) \n",
    "        plt.plot(px,py,'xr',markersize=4)\n",
    "        # show warped gray\n",
    "        fig.add_subplot(num_to_show, 3, j*3+2)\n",
    "        plt.imshow(images[:,:,i+1])\n",
    "        # show counts\n",
    "        fig.add_subplot(num_to_show, 3, j*3+3)\n",
    "        plt.imshow(counts[:,:,i+1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def homography_adaptation(image, net, config):\n",
    "    \"\"\"\n",
    "    INPUT: image is a PIL image, grayscale, testing is of size (400,300)\n",
    "           net is a torch model\n",
    "           condif is a dict() with parameters\n",
    "    OUTPUT: aggregated patches, probs, images, counts\n",
    "            note that patches is a python list.\n",
    "    \"\"\"\n",
    "    # remember the original image\n",
    "    test = image\n",
    "    # convert image to torch tensor\n",
    "    image = torch.from_numpy(np.array(test))\n",
    "    # get the shapeust have same number of dimensions: got 4 and \n",
    "    shape = torch.Tensor([image.shape[0], image.shape[1]]).type(torch.FloatTensor)\n",
    "    # inference on original image\n",
    "    probs, _ = net(image.float().unsqueeze(0).unsqueeze(1).to(DEVICE))\n",
    "    # get the dust_bin out first, later cat in\n",
    "    dust_bin = probs[:,-1,:,:].unsqueeze(0).cpu() # 1x1x37x50\n",
    "    #\n",
    "    small_height = probs.shape[2] # 37\n",
    "    small_width = probs.shape[3] # 50\n",
    "    #\n",
    "    # global variable for aggregation, will be concat at last dimension\n",
    "    probs_to_cat = probs[:,:-1,:,:].squeeze().view(64, small_height*small_width)\n",
    "    prob_list = []\n",
    "    for col in range(probs_to_cat.shape[1]):\n",
    "        prob_list.append(probs_to_cat[:,col].view(8,8))\n",
    "    probs_to_cat = torch.cat(torch.cat(prob_list, dim=1).split(small_width*8,1)).unsqueeze(0).unsqueeze(0).unsqueeze(-1).cpu()\n",
    "        \n",
    "#     probs_to_cat = probs[:,:-1,:,:].view(1, 1, probs.shape[2]*8, probs.shape[3]*8).unsqueeze(-1).cpu()\n",
    "    #print(\"original probs:\", probs_to_cat.numpy())\n",
    "    counts = torch.ones(probs_to_cat.shape)\n",
    "    images = image.unsqueeze(-1).cpu()\n",
    "    patches = []\n",
    "    # sample homography\n",
    "    for i in range(config['num']):\n",
    "        H, patch = sample_homography(shape) # H*[w;h;1] = [_;_;_] is a coner of the patch \n",
    "        inv_H = invert_homography(H)\n",
    "        # get in numpy\n",
    "        test_H = H[0].numpy()\n",
    "        test_inv_H = inv_H[0].numpy()\n",
    "        # apply homography on color scale and grayscale\n",
    "        test_warped = test.transform(size=test.size, \n",
    "                             method=Image.PERSPECTIVE, \n",
    "                             data=test_H,# test_H, # test_inv_H, \n",
    "                             resample=Image.BILINEAR)\n",
    "        image_warped = torch.from_numpy(np.array(test_warped))\n",
    "        # inference on the warped image\n",
    "        ipt_patch, _ = net(image_warped.unsqueeze(0).unsqueeze(1).float().to(DEVICE))\n",
    "        # aggregate the probablities:\n",
    "        # Get rid of dust bin: 1 x 65 x 37 x 50 -> 1 x 64 x 37 x50 -> 1 x 1 x 296 x 400\n",
    "        # apply warp to the patch and concatenate\n",
    "#         prob = ipt_patch[:,:-1,:,:].view(1, 1, ipt_patch.shape[2]*8, ipt_patch.shape[3]*8).cpu()\n",
    "        \n",
    "        # 1,64,37,50 -> 296,400\n",
    "        this_dust_bin = ipt_patch[:,-1,:,:].unsqueeze(1).cpu() # 1 x 1 x 37 x 50\n",
    "        prob = ipt_patch[:,:-1,:,:].squeeze().view(64, small_width*small_height)\n",
    "        prob_list = []\n",
    "        for col in range(prob.shape[1]):\n",
    "            prob_list.append(prob[:,col].view(8,8))\n",
    "        prob = torch.cat(torch.cat(prob_list, dim=1).split(small_width*8,1)).cpu() # 296 * 400\n",
    "        \n",
    "        #print(\"warped probs:\", prob.numpy())\n",
    "        prob_img = Image.fromarray(prob.numpy())\n",
    "        prob_img = prob_img.transform(size=(ipt_patch.shape[3]*8, ipt_patch.shape[2]*8), \n",
    "                    method=Image.PERSPECTIVE,\n",
    "                    data=test_inv_H, #test_inv_H, # test_H,\n",
    "                    resample=Image.BILINEAR)\n",
    "        # print(\"unwarped probs:\",np.array(prob_img))\n",
    "        prob_proj = torch.from_numpy(np.array(prob_img)).unsqueeze(0).unsqueeze(0).unsqueeze(-1)\n",
    "        # warp the mask to correct\n",
    "        count = Image.new(\"L\", (ipt_patch.shape[3]*8, ipt_patch.shape[2]*8), \"white\")\n",
    "        count = count.transform(size=(ipt_patch.shape[3]*8, ipt_patch.shape[2]*8), \n",
    "                        method=Image.PERSPECTIVE, \n",
    "                        data=test_inv_H, #test_inv_H,# test_H, \n",
    "                        resample=Image.NEAREST)\n",
    "        # aggregate prob\n",
    "        dust_bin = torch.cat((dust_bin,this_dust_bin),dim=0)\n",
    "        # aggregate prob\n",
    "        probs_to_cat = torch.cat((probs_to_cat,prob_proj.cpu()),dim=-1)\n",
    "        # aggregate counts\n",
    "        counts = torch.cat((counts,\n",
    "                            torch.from_numpy(np.array(count)).type(torch.FloatTensor).unsqueeze(0).unsqueeze(0).unsqueeze(-1)),\n",
    "                           dim=-1)\n",
    "        # aggregate image\n",
    "        images = torch.cat((images,image_warped.unsqueeze(-1).cpu()),dim=-1)\n",
    "        # aggregate patch\n",
    "        patches += [patch.cpu()]\n",
    "    #\n",
    "#     print('probs_to_cat shape',probs_to_cat.shape)\n",
    "    # aggregation done \n",
    "    counts_sum = torch.sum(counts, dim=-1)\n",
    "    max_prob,_ = torch.max(probs_to_cat, dim=-1)\n",
    "    mean_prob = torch.sum(probs_to_cat, dim=-1) / counts_sum\n",
    "    # check aggregation method\n",
    "    if config['aggregation'] == 'max':\n",
    "        probs = max_prob\n",
    "    elif config['aggregation'] == 'mean':\n",
    "        probs = mean_prob\n",
    "    elif config['aggregation'] == 'pts':\n",
    "        prob_sum = torch.zeros(1,64,small_height,small_width)\n",
    "        for h in range(probs_to_cat.shape[-1]):\n",
    "            prob_to_cat = probs_to_cat[:,:,:,:,h]\n",
    "            prob_split = prob_to_cat.squeeze(0).split(8,2)\n",
    "            prob_stack = [st.reshape(1, small_height, 1, 8*8) for st in prob_split]\n",
    "            prob_to_cat = torch.cat(prob_stack,2).permute(0,3,1,2)\n",
    "            prob_to_cat = torch.cat((prob_to_cat, dust_bin[h].unsqueeze(1)),dim=1)\n",
    "            prob_to_cat = F.softmax(prob_to_cat, dim=1)\n",
    "#             print (torch.sum(prob_to_cat,dim=1))\n",
    "            prob_to_cat = prob_to_cat[:,:-1,:,:]\n",
    "            mask = prob_to_cat > config['threshold']\n",
    "            prob_to_cat[mask] = 1\n",
    "            prob_to_cat[1-mask] = 0\n",
    "            prob_sum += prob_to_cat\n",
    "        probs = prob_sum\n",
    "    else:\n",
    "        raise ValueError('Unkown aggregation method: {}'.format(config['aggregation']))\n",
    "    # cat back the dust bin\n",
    "    if config['aggregation'] != 'pts':\n",
    "        # 1, 1, 296, 400\n",
    "        probs_split = probs.squeeze(0).split(8,2)\n",
    "        probs_stack = [st.reshape(1, small_height, 1, 8*8) for st in probs_split]\n",
    "        probs = torch.cat(probs_stack,2).permute(0,3,1,2) # 1, 64, 37, 50\n",
    "        probs = torch.cat((probs,dust_bin),dim=1)\n",
    "    \n",
    "    return {'prob':probs, 'patches':patches, 'images':images, 'counts':counts}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_homography(\n",
    "        shape, perspective=True, scaling=True, rotation=True, translation=True,\n",
    "        n_scales=8, n_angles=25, scaling_amplitude=0.5, perspective_amplitude_x=0.2,\n",
    "        perspective_amplitude_y=0.2, patch_ratio=0.9, max_angle=1.57,\n",
    "        allow_artifacts=False, translation_overflow=0.):\n",
    "    \"\"\"Sample a random valid homography.\n",
    "\n",
    "    Computes the homography transformation between a random patch in the original image\n",
    "    and a warped projection with the same image size.\n",
    "    \n",
    "    The returned homography will transform orginal image corners to patch corners.\n",
    "\n",
    "    The original patch is initialized with a patch_ratio centered crop. It is\n",
    "    iteratively projected, scaled, rotated and translated.\n",
    "\n",
    "    Arguments:\n",
    "        shape: A rank-2 `Tensor` specifying the height and width of the original image.\n",
    "        perspective: A boolean that enables the perspective and affine transformations.\n",
    "        scaling: A boolean that enables the random scaling of the patch.\n",
    "        rotation: A boolean that enables the random rotation of the patch.\n",
    "        translation: A boolean that enables the random translation of the patch.\n",
    "        n_scales: The number of tentative scales that are sampled when scaling.\n",
    "        n_angles: The number of tentatives angles that are sampled when rotating.\n",
    "        scaling_amplitude: Controls the amount of scale.\n",
    "        perspective_amplitude_x: Controls the perspective effect in x direction.\n",
    "        perspective_amplitude_y: Controls the perspective effect in y direction.\n",
    "        patch_ratio: Controls the size of the patches used to create the homography.\n",
    "        max_angle: Maximum angle used in rotations.\n",
    "        allow_artifacts: A boolean that enables artifacts when applying the homography.\n",
    "        translation_overflow: Amount of border artifacts caused by translation.\n",
    "\n",
    "    Returns:\n",
    "        A `Tensor` of shape [[1, 8]] corresponding to the flattened homography transform. \n",
    "        Note that it is 2D\n",
    "    \"\"\"\n",
    "\n",
    "    # Corners of the output image\n",
    "    pts1 = torch.Tensor([[0., 0.], [0., 1.], [1., 1.], [1., 0.]])\n",
    "    # Corners of the input patch\n",
    "    margin = (1 - patch_ratio) / 2\n",
    "    pts2 = margin + torch.Tensor([[0, 0], [0, patch_ratio],\n",
    "                                 [patch_ratio, patch_ratio], [patch_ratio, 0]])\n",
    "#     print('pts2 initially...:', pts2)\n",
    "    \n",
    "    # Random perspective and affine perturbations\n",
    "    if perspective:\n",
    "        if not allow_artifacts:\n",
    "            perspective_amplitude_x = min(perspective_amplitude_x, margin)\n",
    "            perspective_amplitude_y = min(perspective_amplitude_y, margin)\n",
    "\n",
    "        # create truncated normal distribution\n",
    "        perspective_displacement = truncated_normal(-perspective_amplitude_y, perspective_amplitude_y, perspective_amplitude_y/2)[0]\n",
    "        h_displacement_left = truncated_normal(-perspective_amplitude_x, perspective_amplitude_x, perspective_amplitude_x/2)[0]\n",
    "        h_displacement_right = truncated_normal(-perspective_amplitude_x, perspective_amplitude_x, perspective_amplitude_x/2)[0]\n",
    "        pts2 += torch.Tensor([[h_displacement_left, perspective_displacement], [h_displacement_left, -perspective_displacement],\n",
    "                              [h_displacement_right, perspective_displacement], [h_displacement_right, -perspective_displacement]])\n",
    "#     print('pts2 after perspective...:', pts2)\n",
    "    \n",
    "    # Random scaling\n",
    "    # sample several scales, check collision with borders, randomly pick a valid one\n",
    "    if scaling:\n",
    "        scales = torch.ones([1+n_scales])\n",
    "        scales[:-1] = torch.from_numpy(truncated_normal(1-scaling_amplitude, 1+scaling_amplitude, scaling_amplitude/2, my_mean=1, sz=n_scales))\n",
    "        center = torch.mean(pts2, dim=0, keepdim=True)\n",
    "        scales = scales.unsqueeze(1).unsqueeze(1)\n",
    "        scaled = (pts2-center).unsqueeze(0) * scales + center\n",
    "    #     temp = (pts2-center).unsqueeze(0)\n",
    "    #     print('center',center.shape)\n",
    "    #     print('temp',temp.shape)\n",
    "    #     print('scales', scales.shape)\n",
    "    #     print('scaled', scaled)\n",
    "\n",
    "        if allow_artifacts:\n",
    "            valid = torch.arange(n_scales) # all scales are valid except scale=1\n",
    "        else:\n",
    "            scaled_boolean = ( (scaled >= 0.) & (scaled < 1.) )\n",
    "            valid = ( (scaled_boolean).sum(dim=(1,2)) == 8 ).nonzero().squeeze(1) # get the index of valid\n",
    "        # get the index\n",
    "        idx = valid[torch.randint(low=0, high=valid.shape[0], size=(1,),dtype=torch.int32)[0]]\n",
    "        pts2 = scaled[idx]\n",
    "        \n",
    "#     print('scale is:', scales[idx], 'center is:', center)\n",
    "#     print(\"pts2 after scaling: \", pts2)\n",
    "\n",
    "    # Random translation\n",
    "    if translation:\n",
    "        t_min, t_max = torch.min(pts2, dim=0), torch.min(1-pts2, dim=0)\n",
    "        t_min = t_min[0]\n",
    "        t_max = t_max[0]\n",
    "\n",
    "        if allow_artifacts:\n",
    "            t_min += translation_overflow\n",
    "            t_max += translation_overflow\n",
    "\n",
    "#         print(torch.randn(1) * (t_max[0]+t_min[0]) - t_min[0])\n",
    "#         print('t min',t_min)\n",
    "#         print('t max',t_max)\n",
    "#         print( torch.rand(1) * (t_max[1]+t_min[1]) - t_min[1] )\n",
    "        temp = torch.Tensor([[torch.rand(1) * (t_max[0]+t_min[0]) - t_min[0],\n",
    "                              torch.rand(1) * (t_max[1]+t_min[1]) - t_min[1]]])\n",
    "        pts2 += temp\n",
    "#     print(\"pts2 after translation: \",pts2)\n",
    "#     print(\"The translation is: \", temp)\n",
    "\n",
    "    # Random rotation\n",
    "    # sample several rotations, check collision with borders, randomly pick a valid one\n",
    "    if rotation:\n",
    "        # sample angles\n",
    "        angles = torch.linspace(-max_angle, max_angle, n_angles)\n",
    "        angles = torch.cat((angles, torch.zeros(1)))\n",
    "        # get rotation matrix\n",
    "        rot_mat = torch.t(torch.cat([torch.from_numpy(np.cos(angles.numpy())), \n",
    "                                     torch.from_numpy(-np.sin(angles.numpy())),\n",
    "                                     torch.from_numpy(np.sin(angles.numpy())),\n",
    "                                     torch.from_numpy(np.cos(angles.numpy()))]).view(4,-1)).view(-1,2,2)\n",
    "        # get center of rotation\n",
    "        center = torch.mean(pts2, dim=0, keepdim=True)\n",
    "        # apply rotation\n",
    "        rotated = torch.matmul((pts2-center).unsqueeze(0).repeat(n_angles+1,1,1), rot_mat) + center\n",
    "\n",
    "        if allow_artifacts:\n",
    "            valid = torch.arange(n_angles)  # all angles are valid, except angle=0\n",
    "        else:\n",
    "            rotated_boolean = ( (rotated >= 0.) & (rotated < 1.) )\n",
    "            valid = ( rotated_boolean.sum(dim=(1,2)) == 8 ).nonzero()#.squeeze(1) # get the index of valid\n",
    "        # get the index\n",
    "        idx = valid[torch.randint(low=0, high=valid.shape[0], size=(1,), dtype=torch.int32)[0]]\n",
    "        pts2 = rotated[idx].squeeze(0)\n",
    "#     print('pts2 after rotation:',pts2)\n",
    "#     print('The rotation angle is:',angles[idx])\n",
    "#     print('The rotation matrix is:',rot_mat[idx])\n",
    "\n",
    "    # Rescale to actual size\n",
    "    pts1 = pts1 * torch.from_numpy(np.flip(shape.numpy(),0).copy()) # different convention [y, x]\n",
    "    pts2 = pts2 * torch.from_numpy(np.flip(shape.numpy(),0).copy()) # different convention [y, x]\n",
    "#     print('unsq pts1', pts1)\n",
    "#     print('unsq pts2', pts2)\n",
    "    \n",
    "    # cv2 to estimate\n",
    "    [h, _] = cv2.findHomography(pts1.numpy(), pts2.numpy())\n",
    "    homography = torch.from_numpy(h.flatten()[0:-1]).unsqueeze(0).type(torch.FloatTensor)\n",
    "\n",
    "#     # LS to estimate a H from 4 point pairs: AH = p\n",
    "#     def ax(p, q): return [p[0], p[1], 1, 0, 0, 0, -p[0] * q[0], -p[1] * q[0]]\n",
    "#     def ay(p, q): return [0, 0, 0, p[0], p[1], 1, -p[0] * q[1], -p[1] * q[1]]\n",
    "\n",
    "#     a_mat = torch.FloatTensor([f(pts1[i], pts2[i]) for i in range(4) for f in (ax, ay)])\n",
    "#     p_mat = torch.t(torch.FloatTensor([[pts2[i][j] for i in range(4) for j in range(2)]]))\n",
    "#     homography = torch.t(torch.from_numpy(np.linalg.lstsq(a_mat, p_mat)[0]))\n",
    "    return homography, pts2\n",
    "\n",
    "# # test homography sampling\n",
    "# homography = sample_homography(shape)\n",
    "\n",
    "# homo = flat2mat(homography)\n",
    "# invHomo = flat2mat(invert_homography(homography))\n",
    "\n",
    "# res = torch.matmul(homo, torch.Tensor([0.,300.,1])).squeeze(0)\n",
    "# res = res/res[2]\n",
    "# print(res)\n",
    "# res = torch.matmul(invHomo, res).squeeze(0)\n",
    "# res = res/res[2]\n",
    "# print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def truncated_normal(myclip_a, myclip_b, my_std, my_mean=0., sz=1):\n",
    "    \"\"\"\n",
    "    Generate random numbers from a truncated normal distribution\n",
    "    \"\"\"\n",
    "    a, b = (myclip_a - my_mean) / my_std, (myclip_b - my_mean) / my_std\n",
    "    return truncnorm.rvs(a, b, my_mean, my_std, size=sz)\n",
    "\n",
    "def invert_homography(H):\n",
    "    \"\"\"\n",
    "    Computes the inverse transformation for a flattened homography transformation.\n",
    "    \"\"\"\n",
    "    matH = flat2mat(H)\n",
    "    invH = torch.cat([torch.inverse(matH[i,:,:]) for i in range(matH.shape[0])]).view(matH.shape[0],3,3)\n",
    "    return mat2flat(invH)\n",
    "\n",
    "def flat2mat(H):\n",
    "    \"\"\"\n",
    "    Converts a flattened homography with shape '[N, 8]' to its\n",
    "    corresponding homography matrix with shape '[N, 3, 3]'.\n",
    "    \"\"\"\n",
    "    return torch.reshape(torch.cat((H, torch.ones(H.shape[0],1)), dim=1), [-1,3,3])\n",
    "\n",
    "def mat2flat(H):\n",
    "    \"\"\"\n",
    "    Converts homography matrix with shape '[N, 3, 3]' to its\n",
    "    flattened homography with shape '[N, 8]'.\n",
    "    \"\"\"\n",
    "    H = torch.reshape(H, [-1, 9])\n",
    "    return (H / H[:, 8:9])[:, :8]\n",
    "\n",
    "# # unit test\n",
    "# H = torch.ones([10,8])*64\n",
    "# matH = flat2mat(H)\n",
    "# flatH = mat2flat(matH)\n",
    "# print(H)\n",
    "# print(flatH)\n",
    "\n",
    "# H = torch.ones([2,8])\n",
    "# temp = torch.Tensor([1, 0, 3, 2, 1, -1, 4, 2, 4])/4\n",
    "# H[0,:] = temp[:8]\n",
    "# H[1,:] = temp[:8]\n",
    "\n",
    "# print(H)\n",
    "# print(invert_homography(H))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}