main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random processes\n",
    "import torch\n",
    "import math\n",
    "\n",
    "class RandomProcess:\n",
    "    \n",
    "    def sample():\n",
    "        raise NotImplementedError\n",
    "\n",
    "class AnnealedGaussianProcess(RandomProcess):\n",
    "\n",
    "    def __init__(self, sigma_max, sigma_min=None, n_steps_annealing=1):\n",
    "        if sigma_min is None: sigma_min = torch.zeros_like(sigma_max)\n",
    "        self._sigma_max = sigma_max\n",
    "        self._sigma_min = sigma_min\n",
    "        self._m = -(sigma_max - sigma_min) / float(n_steps_annealing)\n",
    "        self._n_steps = 0\n",
    "\n",
    "    def sample(self):\n",
    "        self._n_steps += 1\n",
    "        return self._sigma * torch.randn_like(self._sigma_max)\n",
    "\n",
    "    @property\n",
    "    def _sigma(self):\n",
    "        result = torch.max(self._sigma_min, self._m * float(self._n_steps) + self._sigma_max)\n",
    "        return result\n",
    "\n",
    "class OrnsteinUhlenbeckProcess(RandomProcess):\n",
    "\n",
    "    def __init__(self, theta, sigma_max, n_steps_annealing, dt=1., x0=None, sigma_min=None):\n",
    "        self._gaussian = AnnealedGaussianProcess(sigma_max=sigma_max, sigma_min=sigma_min, n_steps_annealing=n_steps_annealing)\n",
    "        self._theta = theta\n",
    "        self._dt = dt\n",
    "        if x0 is None: x0 = torch.zeros_like(sigma_max)\n",
    "        self._x_prev = x0\n",
    "        self._sqdt = math.sqrt(self._dt)\n",
    "\n",
    "    def sample(self):\n",
    "        x = self._x_prev * (1. - self._theta * self._dt) + self._gaussian.sample() * self._sqdt\n",
    "        self._x_prev = x\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import copy\n",
    "\n",
    "class ActorCritic(torch.nn.Module):\n",
    "#this object encapsulates an actor network and a critic network, and is capable of calculating outputs (actions, values) when provided with an input, as well as optimizing the actor and the critic networks when provided with a necessary input and target values\n",
    "    \n",
    "    def __init__(self, actor, critic):\n",
    "        super(ActorCritic, self).__init__()\n",
    "        self._actor = actor\n",
    "        self._critic = critic\n",
    "        self._nb_states = actor._nb_states\n",
    "        self._nb_actions = actor._nb_actions\n",
    "    \n",
    "    def calc_actions(self, s):\n",
    "        return self._actor(s)\n",
    "        \n",
    "    def calc_qvalues(self, s, a):\n",
    "        return self._critic(s, a)\n",
    "    \n",
    "    def calc_values(self, s):\n",
    "        return self.calc_qvalues(s, self.calc_actions(s))\n",
    "    \n",
    "    def optimize_actor(self, s):\n",
    "        q = self.calc_values(s)\n",
    "        loss = -q.mean();\n",
    "        loss.backward()\n",
    "        self._actor.optimize()\n",
    "        self.zero_grad()\n",
    "    \n",
    "    def optimize_critic(self, s, a, target):\n",
    "        loss = torch.nn.functional.mse_loss(self.calc_qvalues(s, a), target, reduction='mean')\n",
    "        loss.backward()\n",
    "        self._critic.optimize()\n",
    "        self._critic.zero_grad()\n",
    "        \n",
    "class L4Actor(torch.nn.Module):\n",
    "\n",
    "    def __init__(self, nb_states, nb_actions, hidden1=128, hidden2=64, init_w=3e-3, optim=torch.optim.Adam,\n",
    "                 lr=1e-4, l2=0):\n",
    "        super(L4Actor, self).__init__()\n",
    "        self._fc1 = torch.nn.Linear(nb_states, hidden1).cuda()\n",
    "        self._fc2 = torch.nn.Linear(hidden1, hidden2).cuda()\n",
    "        self._fc3 = torch.nn.Linear(hidden2, nb_actions).cuda()\n",
    "        self._fc3.weight.data.uniform_(-init_w, init_w)\n",
    "        self._nb_states=nb_states\n",
    "        self._nb_actions=nb_actions\n",
    "        self._optim = optim(self.parameters(), lr=lr, weight_decay=l2)\n",
    "    \n",
    "    def forward(self, s):\n",
    "        a = self._fc1(s)\n",
    "        a = torch.nn.functional.relu(a)\n",
    "        a = self._fc2(a)\n",
    "        a = torch.nn.functional.relu(a)\n",
    "        a = self._fc3(a)\n",
    "        a = a.tanh()\n",
    "        return a\n",
    "    \n",
    "    def optimize(self):\n",
    "        self._optim.step()\n",
    "\n",
    "class L4Critic(torch.nn.Module):\n",
    "\n",
    "    def __init__(self, nb_states, nb_actions, hidden1=128, hidden2=64, init_w=3e-3, optim=torch.optim.Adam,\n",
    "                 lr=1e-3, l2=1e-3):\n",
    "        super(L4Critic, self).__init__()\n",
    "        self._fc1 = torch.nn.Linear(nb_states, hidden1).cuda()\n",
    "        self._fc2 = torch.nn.Linear(hidden1+nb_actions, hidden2).cuda()\n",
    "        self._fc3 = torch.nn.Linear(hidden2, 1).cuda()\n",
    "        self._fc3.weight.data.uniform_(-init_w, init_w)\n",
    "        self._nb_states=nb_states\n",
    "        self._nb_actions=nb_actions\n",
    "        self._optim = optim(self.parameters(), lr=lr, weight_decay=l2)\n",
    "    \n",
    "    def forward(self, s, a):\n",
    "        s = self._fc1(s)\n",
    "        s = torch.nn.functional.relu(s)\n",
    "        q = self._fc2(torch.cat((s, a), 1))\n",
    "        q = torch.nn.functional.relu(q)\n",
    "        q = self._fc3(q)\n",
    "        return q\n",
    "    \n",
    "    def optimize(self):\n",
    "        self._optim.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import torch\n",
    "\n",
    "class DDPG:\n",
    "#this object manages an actor-critic by providing it with inputs for calculating actions and for optimization\n",
    "\n",
    "    def __init__(self, gamma, random_process, actor_critic, tau):\n",
    "        self._network = actor_critic\n",
    "        self._target_network = copy.deepcopy(actor_critic)\n",
    "        self._nb_states = actor_critic._nb_states\n",
    "        self._nb_actions = actor_critic._nb_actions\n",
    "        for target_param in self._target_network.parameters(): target_param.requires_grad_(False)\n",
    "        self._target_network.eval()\n",
    "        self._random_process = random_process\n",
    "        self._gamma = gamma\n",
    "        self._tau = tau\n",
    "        self._preprocessor = torch.nn.BatchNorm1d(nb_states, affine=False, momentum=None).cuda()\n",
    "        self._preprocessor.eval()\n",
    "        self._preprocessor_samples = int(0)\n",
    "        self._preprocessor_lock = False\n",
    "\n",
    "    def _preprocess(self, s):\n",
    "        return self._preprocessor(s)\n",
    "        \n",
    "    def update_preprocessor(self, s):\n",
    "        if self._preprocessor_lock: return\n",
    "#default BatchNorm training is not appropriate for the task; we will update the layer parameters manually\n",
    "        n = self._preprocessor_samples\n",
    "        if n == 0:\n",
    "            mu = s\n",
    "            var = torch.zeros_like(s)\n",
    "        else:\n",
    "            mu = self._preprocessor.running_mean\n",
    "            var = self._preprocessor.running_var\n",
    "            var = (n / (n + 1)) * (var + (s - mu) ** 2 / (n + 1))\n",
    "            mu = (n * mu + s) / (n + 1) \n",
    "        self._preprocessor.running_mean = mu\n",
    "        self._preprocessor.running_var = var\n",
    "        self._preprocessor_samples += 1\n",
    "\n",
    "    def lock_preprocessor(self):\n",
    "#once the BatchNorm parameters are good enough, we keep them constant to facilitate learning\n",
    "        self._preprocessor_lock = True\n",
    "\n",
    "    def target_policy(self, s):\n",
    "        training = self._network.training\n",
    "        self._network.eval()\n",
    "        with torch.no_grad():\n",
    "            s = self._preprocess(s[None,:])\n",
    "            result = self._network.calc_actions(s)[0]\n",
    "        if training: self._network.train()\n",
    "        return result\n",
    "    \n",
    "    def behavior_policy(self, s):\n",
    "        return torch.clamp(self._random_process.sample() + self.target_policy(s), -1, 1)\n",
    "    \n",
    "    def step(self, s, explore=True):\n",
    "        self.update_preprocessor(s)\n",
    "        if explore: return self.behavior_policy(s)\n",
    "        return self.target_policy(s)\n",
    "    \n",
    "    def update_actor(self, sarst):\n",
    "        s = sarst[:,:self._nb_states]\n",
    "        s = self._preprocess(s)\n",
    "        self._network.optimize_actor(s)\n",
    "            \n",
    "    def update_critic(self, sarst):\n",
    "        s1 = sarst[:,:self._nb_states]\n",
    "        s1 = self._preprocess(s1)\n",
    "        a = sarst[:,self._nb_states:self._nb_states+self._nb_actions]\n",
    "        r = sarst[:,self._nb_states+self._nb_actions:self._nb_states+self._nb_actions+1]\n",
    "        s2 = sarst[:,self._nb_states+self._nb_actions+1:2*self._nb_states+self._nb_actions+1]\n",
    "        s2 = self._preprocess(s2)\n",
    "        t = sarst[:,-1:]\n",
    "        target = r + self._gamma * (1 - t) * self._target_network.calc_values(s2)\n",
    "        self._network.optimize_critic(s1, a, target)\n",
    "        for target_param, param in zip(self._target_network.parameters(), self._network.parameters()):\n",
    "            target_param.data.copy_(target_param.data * (1.0 - self._tau) + param.data * self._tau)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "class RingBuffer:\n",
    "\n",
    "    def __init__(self, maxlen):\n",
    "        self._maxlen = maxlen\n",
    "        self._pivot = int(0)\n",
    "        self._data = []\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self._data[idx]\n",
    "\n",
    "    def append(self, v):\n",
    "        if len(self._data) < self._maxlen:\n",
    "            self._data.append(v)\n",
    "        else:\n",
    "            self._data[self._pivot] = v\n",
    "            self._pivot = int((self._pivot + 1) % self._maxlen)\n",
    "    \n",
    "    def draw(self, batch_size):\n",
    "        return random.sample(self._data, k=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch, numpy\n",
    "\n",
    "class EnvWrapper:\n",
    "#wrapper around a Gym environment. normalizes action space to a unit block, wraps observations to PyTorch tensors. Also adds information about current time step.\n",
    "    \n",
    "    def __init__(self, env):\n",
    "        self._env = env\n",
    "        self._a_min = env.action_space.low\n",
    "        self._a_max = env.action_space.high\n",
    "        self._tmax = env._max_episode_steps\n",
    "    \n",
    "    def reset(self):\n",
    "        return torch.from_numpy(self._env.reset()).float().to(torch.device('cuda'))\n",
    "\n",
    "    def step(self, a):\n",
    "        a = (self._a_max + self._a_min) * 0.5 + a.cpu().numpy() * (self._a_max - self._a_min) * 0.5\n",
    "        s, r, t, _ = self._env.step(a)\n",
    "        return torch.from_numpy(s).float().to(torch.device('cuda')),\\\n",
    "           torch.tensor([r], dtype=torch.float, device=torch.device('cuda')),\\\n",
    "           torch.tensor([t], dtype=torch.float, device=torch.device('cuda')), t, r\n",
    "    \n",
    "    def render(self):\n",
    "        self._env.render()\n",
    "    \n",
    "    def close(self):\n",
    "        self._env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initialize everything. all parameters are in this cell\n",
    "ENV = 'LunarLanderContinuous-v2'\n",
    "gamma = 0.98\n",
    "\n",
    "mem_size = 1e5\n",
    "pre_explore_episodes = 10\n",
    "batch_size = 64\n",
    "\n",
    "ou_theta = 0.15\n",
    "ou_sigma = 0.3\n",
    "ou_sigma_min = 0.05\n",
    "ou_dt = 1.\n",
    "n_steps_annealing = 1e5\n",
    "\n",
    "hidden1a = 128\n",
    "hidden2a = 64\n",
    "init_wa = 3e-3\n",
    "\n",
    "hidden1c = 128\n",
    "hidden2c = 64\n",
    "init_wc = 3e-3\n",
    "\n",
    "ratea = 1e-4\n",
    "ratec = 1e-3\n",
    "tau = 1e-3\n",
    "\n",
    "import gym\n",
    "import torch\n",
    "import torch.utils.data\n",
    "import hiddenlayer\n",
    "\n",
    "env = gym.make(ENV)\n",
    "nb_states = env.observation_space.shape[0]\n",
    "nb_actions = env.action_space.shape[0]\n",
    "env = EnvWrapper(env)\n",
    "ou_theta = ou_theta * torch.ones(nb_actions, device=torch.device('cuda'))\n",
    "ou_sigma = ou_sigma * torch.ones(nb_actions, device=torch.device('cuda'))\n",
    "ou_sigma_min = ou_sigma_min * torch.ones(nb_actions, device=torch.device('cuda'))\n",
    "\n",
    "memory = RingBuffer(mem_size)\n",
    "\n",
    "random_process = OrnsteinUhlenbeckProcess(theta=ou_theta, sigma_max=ou_sigma, sigma_min=ou_sigma_min, dt=ou_dt,\n",
    "                                          n_steps_annealing=n_steps_annealing)\n",
    "actor = L4Actor(nb_states=nb_states, nb_actions=nb_actions, hidden1=hidden1a, hidden2=hidden2a, init_w=init_wa,\n",
    "                lr=ratea)\n",
    "critic = L4Critic(nb_states=nb_states, nb_actions=nb_actions, hidden1=hidden1c, hidden2=hidden2c, init_w=init_wc,\n",
    "                 lr=ratec)\n",
    "actor_critic = ActorCritic(actor=actor, critic=critic)\n",
    "model = DDPG(gamma=gamma, random_process=random_process, actor_critic=actor_critic, tau=tau)\n",
    "\n",
    "s1 = env.reset()\n",
    "e = 0\n",
    "R = 0.\n",
    "history = hiddenlayer.History()\n",
    "historyt = hiddenlayer.History()\n",
    "historyrt = hiddenlayer.History()\n",
    "canvas = hiddenlayer.Canvas()\n",
    "\n",
    "RT = RingBuffer(100)\n",
    "\n",
    "def avg(buffer):\n",
    "    return sum(buffer._data) / len(buffer._data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAI4CAYAAAB3HEhGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsnXmYXEW5/z/V++xrJnsy2cgCJBCI7BAimyCCoLhd4Yp4F72CP7kg7op6BVG8oigqq9cAsgSQRRCzQcISsu97JplJZt+n99Ndvz/q1OnTPT2TARJCsL7Pc550d51TVadOncn7re/7viWklBgYGBgYGBgYGBgYGBi8e3iOdAcMDAwMDAwMDAwMDAw+KDAEy8DAwMDAwMDAwMDA4BDBECwDAwMDAwMDAwMDA4NDBEOwDAwMDAwMDAwMDAwMDhEMwTIwMDAwMDAwMDAwMDhEMATLwMDAwMDAwMDAwMDgEMEQLAMDAwMDAwMDAwMDg0MEQ7AMDAzedxBC1AkhokKIPiFEkxDiQSFE8du4/udCiB1CiF4hxFYhxNU55fOEEKuFED1CiN1CiH9zlQkhxLeFEPvs8keFEKUHae8GIcQeIURYCLFFCHHMUOoSQlQKIf4ihGgXQrQJIebnlC8WQrTa164TQlyW0+4wIcTDQohuIUSnEGK+q2yTPX76sIQQz7rKLxVCbLTLXhNCzHCVHSeEeMnuU7/NEoUQtUKIF+w2m4QQvxFC+IY4vnOFEOmcvl3jKv8vIcRKIURcCPHgYON+qGDPr4Tdlw4hxMtCiGmHoZ1rhBCr7HFpEEL8LGfcKoUQT9nzaK8Q4rOusnOFEBuEEF32fHlKCDF6kLZq7fkTsd+B895GP/pyjpQQ4td22Qz7+XTaxz9y5s7/s595jxDigBDilzl1DzqnXefdL4SQQojJrt+WCCFirn5ty7lmsPdhtBDiGfv5Nggh/sNVVi2EWG6Pa5cQ4nUhxBmu8k8LIbbZ9bYIIR4S2e/pn4UQjfY9bRdCXDfQczEwMPgngZTSHOYwhzneVwdQB5xnfx4BrAN+8jau/yEwDbWIdArQCZxul/mBbuDfAQHMAfqAWXb5NcBWYCxQDDwDPDRIW9cB64EZdn2TgMqh1AX8Fvg7UAqUAf8A7nSVzwR89udTgF5gpKv8VeBO+1o/cOIAfRTAHuBq+/sUoAc4E/AB3wR2utqaCnwRuEz9N9GvvheAB4GQ/Xw2ANcPcXznAg2DjOcVwOXA74AHD+McG+76/CDwY/tzgf19uau8BCg4BG3+J3AWEABGA6uAW1zljwB/sefKmfY4Hqv7C4yyPweBnwF/HaSt1+25UQBcCXQBw4bSj5x6iu3nd7b9vRyotZ+tF7geWO86fxJQbn+uBBYBXx/qnLZ/PxNYCkhgsuv3JcB1g9zzgO8DsBj4X/v3WUAHcK5dFrLnvMe+r8vtct3PsUC1azzmA3e56j4WCNqfpwFNwEmHa+6awxzmeP8fRsEyMDB4X0NK2QS8BJzwNq75vpRyq5QyLaV8E2V4nWYXV6IIzf9JhbeALSiCBHApcJ+Usl5K2QfcDnxKCFGY244QwgN8H/h/UsrNdn27pJQdQ6xrAvC0lLJHStkNPIUy1vR9rJdSWvoryjgca7d9gf35Jillt5QyKaVcM8CQnA1UA0/a3y8EXpVSLrPrvx1laJ9jt7tNSnkfsGmA+iYAj0kpY/bzedHV74ON76CQUi6QUj4NtA/l/LcDIYRfCPFxIcRfUYQyX/tR4DGy59txwAEhxO+FEKe+0/allL+TUr4qpUxIKfejDPUz7L4VoYjQd6WUfVLKZcBfgc/b1zZLKQ+4qksBk8kDoRTU2cD3pZRRKeWTKBJ85cH6kQdXAi2odwgpZZeUsk5KKVFkJKsf9vzv0l0B0jnlA85pu+8+4NfAVwfoT14M9j4IpX7PRS3SJKWU64AngGvtPsXsOZ923VMFai5jv79truZy73mTlDLuuieJIpoGBgb/pDAEy8DA4H0NIcQY4CO4DGIhxGeFEOuHeH0BSkXZBMpQRSkFXxBCeIUQpwHjgWXuy3I+B1GqTy7G2MdxQoh6odwEf2gTr6HUdTfwUSFEhRCiAmXM/i2n/88JIWLAm6gV/JV20anANuAh27XpLSHEOQMMwzXAk1LK8CD9EigiMRT8L/BpIUSh7ab2ERTJGur41gghmu3x+qVNLg4bhBDHCyHuBPYDNwPP4zLqc84tAj6Da75JKV9HEZZG4GGh3EBvFkKMzLl2nO1iNm6IXTubDIk9BrCklNtd5etwEW5dPxAF/hulYuXDscBuKWXvQHUN0o9cXAP8ySZUDux+xFBk6H9yyj4rhOgB2lBq0e9zygea0wD/D3hFSjnQ+/1ToVxXlwsh5rp+H+x9EDn/6s9Z893+mxJDEdt7pZQtrrIzhRDdKMXtStQ74L72t0KICEqxbkSpvAYGBv+sONISmjnMYQ5z5B4oF8E+lDEjgYXYbkfvoK6HUMa/cP12KdAMWPbxJVfZdcB2lBtUGcrYksBpeeo+3S57nozr1HZd38HqAkah3ALT9vEyEMjTjh9FYtyuVn+w6/qiXf5plBtYdc61hSh3wLmu36YBYdSqfgD4rt3+N3OunUx+F8HpKLcyy+7Dg29jfEeg1CwPSgl7Bfh9njZ+zLt0EQTmoYz3ehQJOGaA8x5EGdZd9jjsAWYOcK5AKX33o1xPnwPGvYO+XQs0kHE9OwtoyjnnS8CSPNdWAt8ATh2g7s8Db+T89pN845nbj5yy8Si1ZsIA7RQBXwYuGaB8CvAjYMQQ5/RYFLEts7/nugiegnLXDKKIXy8waSjvA4rg/xrlDjgb5QK4LU+/QiiCfc0A9zQa+EG+uYRymTwT+A7gfzdz1xzmMMfRfRgFy8DA4P2Ky6WUJSgSMA3l4va2IIS4A7VKfZWUUtq/TQMeBa5GkYtjgZuFEJfYl92PUmCWoFb1F9u/N+RpImr/+zNpu06hVusvHmJdj6EIWAnKrW4X8OfcRqRya/obcIEQ4mOutuuklPfZ5Y+iiESuq9cVKGNyqau+rSgD9Teo1fZqYPMA95gFW517EViAMrCrUe5Ut9vlg46vlLJJKnfKtJRyD0pRuvJg7b5D1KBI4kaUgrNvkHN/LqXUJDmKisnpB3sebbbra0Dd39tS4IQQlwM/BT4iM65nfag54EYpikTk9qEDtXDwjDuBhAtDqmuAfrjxeWCZ/Zz6QSpF9B7gT0KImjzlO1Dz/rd5yvLN6f8FbpXKXTZfe29KKXullHEp5UPAcjLv2sHeh8+hCH09Kr7vz+SZ71K5Cz4C3CKEmJWnfD9q/j+apywllWvnGFScm4GBwT8pDMEyMDB4X0NKuRSlMPz87VwnhPghaoX8Aillj6voOGC7lPIl28jfhlKgPmK3l5YqhqtWSjkGZSDut49cbAMSqJVzp8uuvh+srhNQ6k1Yqhite8gYjPngIxPbsT6nXfJ8hwFcvKSUT0gpj5NSVqHiyGqBtwZpW6MSGAf8xjZ024EHXP0edHzzQHKY/i+yjewRwP+hlI0DQog/CiHOHOSafcANwK9s91IAhBBBIcQnhMrEuAM4CZXgYaKUcstQ+ySEuAj4I3CplHKDq2g74BNCuF1RZzGw654PRSDzZbjcBEwUQpQMVNcg/XDjahSRGwwelEo6UEZD95w9WPmHgTuEykzZZP/2unBlU8yBjgODg7wPUsq9UsqPSimHSSlPQS0MrBikX35g4hD6/E7KDQwMPug40hKaOcxhDnPkHriyCNrfh6Fc2mYN8fpvoozgfK5Jk1Ar/PPIZP3bCfybXV5p/yZQrmwbddkAbf0J5SZWglq53gp8cSh1oRStX6MyvRWgVvpfs8umoUhJAcrY+xcUmZvtqrsTRaC8wCdQSlW1q/4xKBe9SXn6fZJ93TCUkvawq0ygXKVmoIzUEHaWNLt8N3ALypAsRyXneHiI43suyvVMoFzCFgMPuOr22e39FEWMQtjZ3A7BvBoLfNueG7tcvz+InUXQ9dtK4Ab780x7bF9FEbWSd9j+PFTyjrMHKH8UpXgWoZQXdxbBK8hkutPPbPUgbb2BWpQIAR8nO4vgoP2wzzkd9c6V5Px+PnCiPXdKgbuAA0DILr8OqLE/z0CRujuHOKdrUIRYHxIVW1Vgz7ML9XxAKVJhbFc9DvI+oNxaS1Cq6r+g4sP0eJyKcu0L2G19A6X26ayNn8N2A7Xn7lJggavPn0ZlF/TafQwDHztUfw/NYQ5zHH3HEe+AOcxhDnPkHuQQLPu336ESNWiDZ9Mg10sgjjL09fEtV/lVKLLTi3ITuh3w2GXHoJSpCLAXV4yIXX4PcI/reynKMO5FuR99DzseaQh1TQCeRRm7HSjXoyl22XRUEoBelHH8FvDxnOvPQmWH60MRgrNyyr+JyhaYb4yW2XV3oNwai1xltWSyoemjzlV+AsrtsdM2VB8jO+35YOP7dZSCF7HH6y5cRjwqviW37R8chjl2puvzg/QnWJ+y+xlEGfuTh1DnOPtZ5I3JQpFJK2de/s1VXgk8jTLQ9wGfdZV9FRUbFkalAX8UGD/IvKy1n1HUnoPnDbUf9jm/R2WCzL2HT6IWEfqAVpQ6OdNV/gAq/i6Meo/vIEO+Djqn87zHk+3Pw+zz9bVvAOcP9X0Avmb3N4ya+ye7ys5BuXzq92EpLvKJil9rsK9tQMV7Vbn6tdTuU4/d/pcGuidzmMMc/xyHNgIMDAwMDAwMDAwMDAwM3iVMDJaBgYGBgYGBgYGBgcEhgiFYBgYGBgYGBgYGBgYGhwiGYBkYGBgYGBgYGBgYGBwiGIJlYGBgYGBgYGBgYGBwiJBvg8KjCtXV1bK2tvZId8PAwMDAwMDAwMDA4AOMVatWtUkphx3svKOeYNXW1rJy5coj3Q0DAwMDAwMDAwMDgw8whBB7h3KecRE0MDAwMDAwMDAwMDA4RDAEy8DAwMDAwMDAwMDA4BDBECwDAwMDAwMDAwMDA4NDhKM+BisfkskkDQ0NxGKxI92Vw4pQKMSYMWPw+/1HuisGBgYGBgYGBgYGBnxACVZDQwMlJSXU1tYihDjS3TkskFLS3t5OQ0MDEyZMONLdMTAwMDAwMDAwMDDgA+oiGIvFqKqq+sCSKwAhBFVVVR94lc7AwMDAwMDAwMDgaMIHkmABH2hypfHPcI8GBgYGBgYGBgYGRxM+sATLwMDAwMDAwOBoRyyZOtJdMDAweJswBOswwev1csIJJ3Dcccdx6aWX0tXVdaS7ZGBgYGBgYHAUobknxrTvvsj/vTGkvU0NDA4puqNJvrlgA3PvWEx3NHmku3NUwRCsw4SCggLWrl3Lxo0bqays5O677z7SXTIwMDAwOEpgpdK09saPdDfeE6zZ10lXJHGku3FQSCnpi1vvaZsdYTUu9yzZ9Z62+26QSkt++Owmdrf2Hemu/NMhlkxxxm2LDgkhb+6J8YnfvcYjK/ZR1x5hQ0P3kK9NpyVPrmrgQFf0XfXhmws28MKGxndVx5GCIVjvAU477TT2799/pLthYGBgYHCU4Kk1+znnjsWED5NBn0ylufmJdexo7n3XdV374Fv86LnN7+ja7kiSj//2Nf778XXvuh+HG0u2tXLSj16moTPynrUppfp3/7s0VN9LbDrQzQPL67jpifWHpf57X93NW3Udh6Xuow1tfXHiVsaFtDOSYH9XlO8+vdEh54OhtTeOlJJIwqI3lq1QfXn+ag50Rbn7s7MB2NLYA8A9S3dx9+KdA9aZsNJ8ef5qbnx8Hd97ZtPbvqeeWJL1DV0s29HGIyv2vafv26HEBzJNuxs/fHYTmw/0HNI6Z4wq5fuXHjukc1OpFAsXLuSLX/ziIe2DgYGBgcEHFy29cSKJFI3dUSbXlBzy+uvawjy2soEZI0uZMvyd198bS7JkWwsHut5ZHW/saQegte/9r2DtbOkjbqVZtLWFq0+rfU/aTKbSg5Y/v76RYSVBjhtdyuq9XZwxeegZlJOpNH5v/3X2bU29TKkpxuN5Z4m02u1nWRjwvqPrD4YfP78FgE0/vJCi4KE1Y+9ftoeSkI9Pnjz2kNQXSVjctXAnnztlHGMrC+mOJllb38U5xwx713Wn05KL/vcVPjVnLDddOA2ApCWd8t8t2cm3L5lBwkrzx1d386+n12aN1/bmXi7+1av8z8eP528bGwknUjz276cBcKAryqq9nXzjomlcMnMkP3w2yJbGHpp7Ytz59+0EfB7+7eyJeefPn9/Yy4ubmpg5poyFW5vZ1x5hXFVh3nvoDCe48+Xt3HzRVEpCfhZva+H6h9fQG7cI+T2MqSh4z961Qw2jYB0mRKNRTjjhBEaMGEFzczPnn3/+ke6SgYGBgcH7HHErhZVKk7CUYd3UfXjcBBs6o3Z7gxvwg0FKyep9XaQl7G4LYx2EDOTDazvbAJgxsj9Be3xlPWvr+8cvP7aynkVbm99+h98l2m1FYOm21sPfVl+cTQe6sdKZMc11GU2lJbcsWM89S3fx0Gt7+Zf73uT5IbpT1XdEmPG9Fx1V4vGV9Xzxwbdo6Ixw4f++wo+eH1iRjCVT9MQGjsfR41RVFMjq+yV3vcqetvCQ+jcU/CaPitLYHX1Xi+q3Prf5HStv6+q7SKczBCeZUkrOPUt38fQa5cV042PruOb+FTR1v/stdlp647T1JVjimo9J13zZsF+59L2+u507XtrWb248sHwPVlryq4U7WLytlY37u5G2ZLpwawsA58+oAWD6yFI2N/bwwPI6Eqk0fXGLlXWd9MSSfOgn/+Cyu5ezsq6D3liS3yzeyRmTq/jj1SfjFYI/vV434D3csmA9//fGXl7dof4OPLmqgaDfw9fOm4JHCL5zyQxC/sND1A83PvAK1lCVpkMNHYMViUS48MILufvuu7n++uuPSF8MDAwMDI4OfOr3b3D6pCq0mdbUc3j2Oqy33W4S75Bg7W7tY94vljJzTJlTT31nlAnVRW+rntd2KQVLyv5lt7+4lXnTajhhbLnzW08syXef3sjxo8uYN234gPWm0/IdKzC5aOiMEPB6aO+LO32OWymCvsNn+H34zqV0RZI88qVTnd+2NPYwrCSjfGxr6qU3ZtHWF3fcu37x9+1cdOwIfHmUBTf2d0VJpiSN3VGmjyxlbX0Xr+9udzIWPvzmvrz209LtrVxz/wqmjSjhxa+dnbduPU6VRUHnt1V7O9h0oIc3d7e/7TmSCyHUfFm6rZVvXDQtq+xnL25j6fZWXrzhLK5/dA23XTGTWru9hK0+Xnjs8He0zY2UklRa5h3bxdta+MIDb/Hjy4/jX04dDyiysGRbKwGfh61NyhW3sVstbLT0xhhRFnrbfXBjb7siq5sbe+iKJCgvDDiKZ1HAS11bJOu8VXWdXGUrc53hBE+t2c+wkqDjfhpJpGjqiTGyrICFW5oZX1XIpGHFgPLcWr6zjfqOCOdOHcaynW0s2d5CNGnR0hunN2bxo+e38NHjR9IRTnDzhdMYXhpi9rgK1ttEL5WWPPRaHZefOJrKogBSSl7apBZKPPbzaOyOMaWmhK+ddwzXz5tyyN7hIwGjYB1mFBYWctddd/GLX/wCy3pvg2MNDAwMDI4u7O+K0tAZdYhP8+EiWB3K+BqKgiWl5IlVDTz85j5a7P7sblVG2/qGboptt6ODxXPVd0SyVK6Wnhg7WvoG7Ec8qZS8dFrFiAC8sL6RuJVmR0ufs9qu8eDyPdy9eCeLtjYz8VsvsLNF9aehM8L6hoEz+catFFffv4JFW5u546WtfP2xtVmueV97dC3feXoj7eEEQkA0mWJlXeeg9wrQF7f4+l/WOkb120FXRBEmdz+2NPY4Rj7Am7Z7ZVtvnC47w9uetjCv2qrgYNDzK5lSdcWtNMlUOut7dzRJW1+2avbNJ5W6owlDPjT3qGuC/oyJudtWrura1bzrjSXZfKDHuZehIpWWDhnvjiZp7I5y3UNvOSShviNCRzjBbS9u5Y3dHfx9c5Nz7eJtLfzHn1exvbmPWDI1qOKaO7cAHl6xj9NvW+SM3bIdbY4CuHqvmg8tLpXxiVUNTK4pZu4xw9jSpM6rtFW99gHio/6xublfWv5UWvLv/7eSv+UoUHvtd1hKeHOPiknTLoKTh5fQ1BMjmkg5RGvl3kzc2rKdbcSSaX551QkUB32MKFVkb3drmFgyxWu72vnwtAwRnT6yFCstkcCtlx3HnNpKFm9tYcWeTvxewXVnTWBdfRcPvlbHrLHlzLIXRUoL/PTG1Lv7+q52bn1uM8+vPwDAij2Z/uj3u6k7xkibeB7N5AoMwXpPcOKJJzJz5kweeeSRI90VAwMDg38q7G0Ps+sIZjN7Zu1+Z0V/KNDugdqwPlwEK+MiqIy5t+o6+Ooja/KSpNX7uvjvx9fxrac2cGueZBaXnTAKwCFL+dAXtzjrZ4v58J1LnTYfX9UAKEXCHaivEU+liVtpFqzZzxm3LSKZSvOEfY0y/rON1Plv7uOB5Xu4b9keAOraIrT0xjjz9sV87DfLae6JUXvL87yxu52Wnhg3P7GOr/9lLS09cV7Z3sq1D67k7sW7WLB6P9//ayY4vyuapK49THtfnNoqpYYMxcVr2Y42FqzZz9NrDgx4TlN3jJ2DjJubYL1V18mPn9/CpG+9QDotHQO1rS9BW28cn22Q9sUOvpirSYImOIpgySxFc9YP/868ny9xvjf3xDjQHUMIKAkN7ACl56ybwOyxCfne9jDLd7Yx7xdLufiuVznjtkWDJmO4b9kenlm7n2gixcItzVnj0RNN8sbudv6xpYWP370cKSWN9nNZsFq55LldTPW4tPXFufJ3r3Hny9sHbHfTgR5uenxd1nisq++ipTfOtqZeookU/3Lfm1zx29eATBKSUTY52NMWZuXeTq6cPYbpI0upawsTTaSoKFQEqy1PhtANDd1c96eV/G1jNpHqi1m8tKmZ/5y/mtdtxVePpdcjCPk93Pa3raq/9vhMqVHK096OsKNg7WoN02mPdTSh3rfa6kKe/srpPPCFOYAiwusbuklYaU6fVOW0NXtcOX6v4PuXzmBsZSEXHjuC7c19PLGqgeNHl3HZCaOdcfi4/fcAoDTkc9TVF+z70q6u2i0QIJxIkUpLpaCVvztl7/0CQ7AOE/r6sv9gPvvss3z+858/Qr0xMDAw+OfED5/dzLcWbBiwvDua5Jr7V7AuT6wPwPef2ejETySsNL9euGPIG792R5Pc8Ohanloz9CyyyZQkkRWDld+Qz7fC/nbO0y6CcStNW1+cL89fzbPrDnDxXa+yam+2OrNoazNej+CiY0ewZFsrcSvlGLpfnjuJG86bwqiy0KBEQWdD3Nse4ecvbSOZSvN/r+/lzMnVHDuqlHgyW02QUhn7cStNQ2eEzkiS3pjFyr2djsvgjpYMGYxbKfa0hWnrS7B8pzJCC4Nebnky8+y12vCzF7fylYdX89jKBhas2Y/lUlE+cdIY/vX02iy1Lm6l2N8Zpa0vwSjb+BuK8remXo3j67tVf+o7Ijy4fA/bm3udWJ2fvLCFL89flXWdm3Dodj5UW8myna0OeUyk0qzY04FHqM+728KMKi8ADp4YQ18POPcet+d0JJE9t3tcZE2TlZPHVwzahiZYWg2DjIK1tz3Cd5/ZSFHAy/UfnkJTTyxLXdzXHuF/XtjC75bsIpZM8eiKfTyz9gB/29jIFx9a6SwMFAd99MYtum2lr6U3zvMbGmnpzX5f1uzL1K3HsiuSZGdLH9sGUeEeeq2Ox1c1ZC3O1Heottc2dLHQjgHUpFanI9eqywsbGhECPn7iaKaPLCUtVVKJikK/019QiVO0mrzCzoyYG2uXcI31H1/d7Xze2x5hTEUBc4+pYU9bmCdWNzjP5ZjhimDVtYWpaw8zrES5a+p3Wy9oBH1eJteUMG1ECYUBL7tb+5xzZo+vcNoaU1HIhh9cyKfmjAPUe1JW4KetL86cCZVMrilmck0xXo/go7MyBKs45KMvbpFKS/6+SamJrfaC0562MDV2vyJx5eqaSktGlBUM+FyOJhiCZWBgYGDwgUVvLEl0EEK0py3M0u2tXHb38rx7tjy7vpFXdqgg8jX7OvnFy9sHTBH9//6ylmfWZshUPqM1mUpz58vbnZXkXGhyNZiLYHckyZyf/IN7lg68N1IqLfnmgg3M+clCwnGLZCqdpShoQzVhpblr4Q66I0nmX3cKFYUBbn9xaxYxW7ilhZPHV3DVnDH0xS1e39XuGH1XnjSGmpIQk4eXZBGeXLgN8n9saeHvm5pp6onxhTNqCXg9/QiLrl+TLMiQtJNtw89N6Pa0hbOIkmpTst1W5IqDPifj2ep9Xay0jUiPyCgtv/7Mifz8k7P4yHEjAKVigHJVDNvxKaNs4y+f4paLNXuVcf/Wng4SVpr5b+7jB89u5oJfvsIJt/6dFXs6ONAV5UBX9jN27x+l586Fx40g5iKhXZEk7eEE00aUOvevXatyyU9XJMEZty3izd0Z9UP3X9977hhrjC4voDeW5EfPbWbJthZ8HsGsMeVZ5CkXOm7QTQx0coudrX3sbg3zqTnj+MLpteo313N8fFU9f3hlN7e/uJXV+zqJ2++C7pdOrlFVrJQg7Sbn9Qhe3txMMiUpt0nMx2aNorE75ixS6Htu7I4St9KOoZ8PmhS7yY5elFhf3+Wokifac1ErZ3rsG7ujVBQGGFEWYrqdwGVrU49DwPR7/Y0n1ztq6Srbha8jnJ1AJN84giJY4yoLuftzs7l+3mSkxFn8mWJnHt3VGqa+I8olx48k6PPwjy3N9lioOgM+9U4IIZhQXcTu1jCr93UysbrIcWfUcCebKAr6uPo0FWv2odpKAP77gqncdOFUqoszsXclIR+9MYtVezsdxVmP6Z62MNNHliKEUrAO5KiARzsMwTIwMDAwOGqRsNKc9tOFjutYLuJWGmsQY9AdA/KXt+r7lUcSlkN23EZ/Llp74zy1Zj9/XZtxB9NGjFvxWt/QxV0Ld/Dl+aud39r74nzn6Q1ZGQTjjotgfyOwrl0pNbf9bauzKqzbmfjN53lm7X5+u3gnj6zYR1tfnI5wggt++QpTv/siP3l+M72xpBPjE7fSNHbHmDisiDMmV/Nf8yazYk+HowId6IqytamyJBouAAAgAElEQVSXedNqOH1SNYUBr2PIAgRs0jK6PDSo25w+/9hRpexpC3Pvst3UlAQ5d2oNQZ+XhJVmW1Mvj6+szxrjuJVy1C1NNsZUFFAS9GUZ5tub+6tnVirz7GPJlOMWBSpu5cPTakjLzHPye5XxO2OUIi2bDqjgfP3cU2npqET6mufWH+DL81f1UwqTqTTr93cxrrKQaDLFuoYu4laKwoCX2644np6Yxcq9HbT3xemLW04MCpClmujfz55SnZX2XC8aaEXN3bdEznx/YlUD+7uiPOqa33p8HQXLJh9hu70PT6txDOWVdZ3ct2wPj6yoZ/rIUkpCflJpmZUxLzOukhZ7ziYdxShBRzjB6PICp92TayuoKApQXRxgR7NbJcrseRRLppzFBuddsp+h7ltdW5jioI+pw0ucOXvjBVP53kdn8K9n1AKwtl6rNqoOTVJa8rxbGnoBQitNVirtkKhXdrSydLvKsqfHQJMDPd96Y5YTmzi2opDCgJctjb1OuW47HLc40BVFSunE9eUuvuhxHFkWyopj3NsepraqCK9HUBBQbel3pLzQT3VxwFkMmTqihCtmj2HBmv323lmqjqAvQwMmDitmd1sfq/d2cuK4Cg6Gfz9nEt/96AzOtlPOX3TcCP7jnElZ5+i5stl+lyYNK3L23trTFmbSsGIK/V4iccv5+zHSKFgGBgYGBgZHFvs6IjR2x3hxY/701PFkmvQg7nRugpWrdKXTklgyoyZp4ygfwdLuU5sbMymiMwTLfb4y4l/f3e4Y5a/vbufPb+xja2OvbfCnHKOq1XabccPtQvby5ky68n0dEdIS7lq4w3HJ0v3Y1xEhlZas3NvpGI+qLEUsmXJWpz81ZyxCZBIoaOJ63ozhhPxe5tRWsmZfl7NSr1WhgNczqKqhjcIzp1QDynXrouNG4PEIgn4PcSvFIyv28Z2nNwKZMVbGtVYClfHv93mYVFOcZZhvb+rF6xGMd+23o5I2ZIhE2EViKosCnDhOuRpqAuzzqHspCfkZX1WYpWBpOC6CyTR1bWH+6+E1vLChiVyusbWxl1gyzb+dPRFQAf1WShL0efj0h8ZREvTR0hN39oxq6808012tmWcXjqu+FQV9fMzleqXJojsTnaNg5czPl2wSPmNkqfNbvhgsyBjoN5w3hfOm12Cl00gyNzdrbBl+nx3rlbC46fF1WSprRzjhEFI99nounjtNGeIBr4fjR6vsk5NrirOUz/rOqKNA6WcfT6WdOvU7qtWVuvYI5YV+JtUUOwk5ThhTzrVnTuDYUaUEfB7esomLfo46QUtbX7wfScxNLqjVlsbumCKxZSGae+IU+L3UVhWSTKWJJCxn7ut77otZTpyaxyOoKg7QE01mYit7Mypfa2+chs6oQ+Y6IjkES8dVDS/BSkv2d0XpiiToiVnOfNdKlFb6/F4PtVVFvGErceOrCrnurAkkrDR/en2v8/zdBGvaiBLqO6K0hxOcNP7gBKs46OOLZ07IuxeW+xyAfbZ75dQRJbT2xmnuiRNNpphQXUhh0KcULIdgGQXLwMDAwMDgiKLONt5W7OnIm5EsbqX6uY654d5nKJc4xWzD3lGucv7d2dLnKEhr9ikjrrE75qxA6/piLncyt5veE6saaO2NO8ayNm7jVjpLNcnN5Ka/l4Z8WWRLB85XFQez3IpiyVTGkE6mnax2Qqjv8WSakJ3xLejzEvB6SKTSdEUS/PGV3VwwY7iTrrk46MuKwdKqj9/rGTQuRxugM0eXO4bnRbYrXtCnXAQjCctWHDP3H7fSDkHV4+P3ephSU8xOl9KzrbmXCdVFzHatvOt4No3uaMb16qwp1Y5Rqo12nzdjXR87qpRNB1TWPrc74LCSIH6vIG6lspIkuOfRga4o33lmIx4BH55eQ8jvoSuSwEqnnRTfw0qD1HdE6LUNYu2u9td1B1hk70Gk7jljMN925Ux+esXxWX12r/aPzBOD1RVJOATDvUdSPEfB0mPsNtD9NmlO2JnpZows5YrZY/DbRHRbUy+Pr2pwMthB9rYCSbtuneDi3KlqT6XjRpc6hH5KTUlWRsj6jgiT7bmm3QPdLrP6vqttF8H6jgiVRQEmDcukfh9eptStoM/LnNoKltnJFPR7qBUsKy2d7IsauWRBEyytrF150hhAZdIbU6EI1j6X6pbMo2DpehOuLI2OypdK0x5OOG7HlUWBfgqWnsPH2Ikr6toj3LNUxWJptTVgz139jgR8Hs6dVuM839qqIiYNK2bmmDJW71WulwGvJytd/bVnTOD6eZOZPa6cedNqOBTQ73p9Z4SAz8PYykJa++LsblPv7oTqYooCXiIJi6buKCG/xyHYRzsOK8ESQowVQiwWQmwWQmwSQtxg/14phHhZCLHD/rfC/l0IIe4SQuwUQqwXQsw+nP0zMDAwMDi6oY2lnpjF1qb+G4zGkulBU0G7y3IJgiY+mZTW2S6C9yzdxTfstNWr93U6ZEMnU9CGkdtF0K3y3PTEem56Yh0xRz2wnOvcZK+pO4aVytyHTvE8ZXgJHZGEMtL64o5xW10cyLrevSlsIpV2jLCSoI9EKk3MSmXFVwR8HidmqC9h8fULjskqc2eb04TB7xucYGkCEvR5OG1iFdXFASd2I+jzErfSRB0jPzWAgqUJlmDK8GJae+N02av925t7mTq8hCtnj3FW37WCpcljpx3bcuP5x/DVeZMdxSrqIm4ax44qY1+HSq7hnj5VRUGnv+6ECu55dPfinWxt7OE3n53NyLIC/B41ZsmUxG/H4NSUBJ15AsqQ740luf6RNdR3RBhtk6U+h/Co63RSBT2nakqCjuoyKk8MljudvE7hDa4kFw6RzR1jDz6vIOnKaHnXZ05g9rgKpy+ajLkVM7fbpv69PazIxEnjKyjwezllYiY73ZThxfTGLJp74sSSKVp64w6ZjyfTNsnKzIdojouglZaUFwaca3weQbVr/62zpwxjW3MvTd0xR8Fyk8DcpBi5qds18dXxV1edPJblt8zj8hNH4/cKrLR00qBDZux74xYloQxRCNgLELpcu8npZ+IklhhXnkfBUuccM1zFVT30Wh33LN3F504Zx+mTlCKsFwv6XAT5K+dO5rF/P43brzzecR8tDvoc10u3egVQEPDy9QumsuDLZ7zrPbo0Su0xqO+IUFHop6YkRDIlHcW/trqQwoCPcFwpWCPLCt7RHmXvRxxuBcsCbpRSzgBOBb4ihJgB3AIslFJOARba3wE+Akyxj38DfneY+2dgYGBgcBRjT3vYMS7e2N0/+UTcSmUZv1uberIIjzs+qx/BSmYUJfe52jht7I4SSyrFZX1DNxceqxQZ7SboxBG5XMy0inD7lcczc0wZneFEv2QYesVeG0CdkQRfnr+abz+lMuJ1hBOE/B5GlxfQEU7w5zf2MvfnSxw1r7Iom2D1ujLBuWOaSkJ+4sk00USKkGvT3KBNsBq7o1QWBpxECqAMxYSVWYnXMVha7Rgoa6E+3+cV/Pjjx/GXfz/NIWdBn4e4K0aqzxX3FnfF37jVnMn2ar426Ft744woC3HmlGru+syJzvOyUtIxdDttw/WaM2qZXFPiEAVHwXLtu6MTE+Tun1VVHLAVt5RDCIEslbQ3ZjGqvICLjx+p+uvzYKXVPNH3PLw05LhEgTLk99p7RP3yUydw80VT1T3Hs8mf/lePVdDvpdJO/a2NYncMVjSL3PdXa93KJmRIU8DrUaQgnSbXHdRvz0s9X3W5lJL7l9cxrrKQGSNLnd+1m2NpyM+zXz2Dr86b7PRDJ2PY0dLrpDrXzzaSsLDS2Vk19btb5UrAUFnodwjW8NJQ1v5JOj7olR2teROTuJNYpNMyi0xXFwdptQlYfUcUr0cwsizkkF+f/S60ukiaQ7BiSUpdqez1ooWzSJNK0xVJOgsPq/Z2MqwkyIiyUH8FS8dglYcoCnhZtLWF0eUFWRtB62ej3xE9lz80odLJ/AfqXYtZKeJWyvm7eThRHNIughEqCgNONsO39nQQ8HkYVVZAUVArWLH87oFDzJj6fsNhHV0pZaOUcrX9uRfYAowGLgMesk97CLjc/nwZ8Cep8AZQLoQYeTj7eKQwd+5cpk6dyqxZs5gzZw5r16490l0yMDAwOOpQ1xZmxshSxlQUsHpf/81f41ZG+QnHLS799TIn7TpkG8a5MUS5ClZukovG7hiJVJr6ziiRRIqzjxnG8NIgmw9kE6wsBcv+7dhRZYwqKyCaTDnl2jjSm75qF6NkSlLfGXVip9r64lQVBaksCtARTrCjpY/emMUrtiuUV4gsY9q9L5JWBUBtAhq3UsSsFAWuBAqaRMWT6X5GmN8nSLgyEmqSol2UBnLH1P0JeD3UlIQcgxiwY7DSzjiE45bTRzfB0s/D5/E4hrkmWMlUpq9aJYqn0lhp6bgpaRdBTSZ9OWTF51KwqmwVJHevLaVgeWzXysxzTeUQdb/L3dDnEYrspaXjhqjTU2u09mYI1viqQoe4hl2kUvXRdgWz2/Z7hKPmDCsOOkqJhptoJ/O4w1o5MVi6vYAv4yLYj2B5s9US/V68sbuDdfVdfOnsiRQEvM77FElYFAa8eDyCyTUlFAYyxGNspSIr+zujjhvepBrl7qcXBhIul1lN6qpcmerKCwNMqC5CiP7xO9NGlDCsJMiyHW15U+u7E124x8fnEcweV55xEeyMMLIslDVHAl4PVlpm1ZvlIhjKdhHUKqZGc2/MeQ7bm3sZW1FAZWGArmgyr7Ie8HoYb+/D9tlTxmW9m/qZaDI7EHkK+b3OBt65CtbhgH73IokU5YV+htnPbcWeDiZWF+ERMNrTSTweo6prI+fL1+Gp/4Af1cAPyuEHZfDStw57Pw8HBt4p7hBDCFELnAi8CQyXUuqI5CZguP15NOBO49Rg/5YVvSyE+DeUwsW4ceM4WpBIJEgmkxQVqRdk/vz5nHzyyTzwwAPcdNNNvPzyywB0dnZSUXHwAEMDAwODf3bUtYU5ZWIVkmylRsNNsCKJFMmUpDOScZlLuY3OARSsXBfBZCqtNjXtUoHvmsCUhnwcM7zEyQKXSKnr3TFY2sDyez2E/B5iybQr/iXTXtxKUxT00R5OOK5Fuv2OcIKq4gBVRQF6Y5ZDvNbZakvCduErDqo9aPRGnyp+KkNkSkM+uqNJYq4YLFAKhR6LXEMt4PU6bmNCqPTY+n702Lhd7bSiZTkKVn+jTmcR1OPdF7ecRWuluGUrfAGfYHR5ASG/x4nfSaZkHpVHPRetYHVFEng9op+7nW7XTYq0y6R2QRQCCvxeCgJegn5v1jhCf6Ku3Q91f5K2mqbjl2pKMkRACEWw9DMYX1VEo5263e0Wqfqszom5SGF1SYDtLUq59NtufRruOZ3lIuiosjkugvFMez6vIOUiEJnxzXYR1HW9uqMVr0fwyZPG8Pz6A07b4UQqi1S5UWCPc9xSCxUAk4cp8tzrqj83BqvA76Uw4CWSSFFZFKAg4GVCdZFDQDJjK5g8rJgDXVEnRg1w3r0Faxr428Ymfv/5k5w5OnfqME6ZUEVzT8xJErGrtY8J1dl1+7zCfi/VdV6PcP429MWtrM2Y/V61MOF1qWttvQnn2rSEsZWFVBQFkFItBuhEHnoc/T4PE6qL2NHSy1Unj83qS8CXrWANlHgi5PfaClb/xZN3hd5m6NkPVgySEUjGwIoxvLubiz11tMhyPmLFmLn0ZzwaaMSSHkbLYvhNB//bvoM0Ag8SDgAtIZj1aSiuAeGBMR86dP18D/GeECwhRDHwJPA1KWWP279SSimFEG9L/5NS/gH4A8DJJ5/8vtcOt2zZwr333suCBQtYsGABJ554Ylb5aaedxh133OF8v/zyyykrK+O6667j4osvxud7z3iwgYGBwVGDWFL57ddWFSl3vZxNUnXckjZ+tTuOe1Vfl/k8ol/2NcdlTxMrV1xQT9RyjD1NYII+L6Uhv5OyWbtdudOD6z74vYKCgDdLwXITukRKESzIxBLpvrb3JaguDlBhG2BbbZdETUq0K1KGYGmi4aMrknQM5pKQn9ZeFfsS9PVXsNQ99VewVFY3RWj0/+cOwbIkuLbPufW5zTywvI4HvjBHjbO3f3xFwE5yoccpHLccIpGlYLmy/Xk8gknDitnR0ueMi1bRfA4ByBBJgM5IkpAv0+dAjqubmxRpw7/HVr3+9fRaptuukhkXQZeClZY89lY9c6cNUyTTNW4+r1AugumMgV1TmlFgxlcWOhntqouDFAd9WTE1fq9wjXOOW6NXKViVhQF8Xk+/WLiBPvfbaDhHwfLbCpZ7fNwJTdy/a5IQTaYo9HsJ+b34vR5H4YrELYqCmfnlRtAe54SlNrwO+DyMrijIGvssgpXI3HdZgZ9IIuVs3vunaz9EUR4iVxjw0tidzCLEo8oKaO6JOande2NJhJ3h86wpw/jimRO4e/FOemIWfXGL7U19fMFO+67h93qwXApfYcCLlVILBam0zI7B8nnpiSbxe4WTRMadLAZUOndNqjrCCeez/rsT8Hr4r3mTuXTWKMfVzqnfUTz7Lxa4oYmlUrDyP5NB0bEH2ndBpA2SUUiEYf2j0JR/M/cK4Lf670ELpMprEYQIiiTDg0koHsNffRfQ2tLEhvhw5px6Np87/1QoOPpFhsNuuQsh/ChyNV9KucD+uVkIMVJK2Wi7AOqUOfsBNy0fY//2zvG3WwZ88O8YI46Hj9w26CnhcJjHHnuM++67D4AvfOEL/OAHP6CkpKTfuS+++CKXX365833JkiUsXbqU+++/nxtvvJFPfvKTXHvttUyePLnftQYGBgb/rKhrVzFHtdWFrKn3ZmXUg4zRqFWqTAxVtmEMyqAeKAYr150qYaU50J1Jdd7jECyPIk05xMydpj3hUgNCfi+xRMpRuMLx7CQXOs5EG5habWjvi3PM8BKnvKU3O8tgMqVISXHIBz0ZJaA05Ke5J5alYMUtnUUwO8mFWonvr2AFbfKVsLOQaWhCkasCPrC8Lvu+PfkULI+dfMNyxkHv65NwKUW5q/NTaop5q67TeW6+XAXLvs7tIui+T0cNSmaUMY1QQJXpLHMnj6/kkpkjnf7q7IZaRemMJLj5yfV855LpWOm046ao2hG2IS4dw1cbyEUBr8qs1hunJ5p00m67Y2rcaoQv5978Hg//cc4kLtHxXl5PVgyWHvfc+e2OwZIyk7TEcTGzY7BAESR3nzLuaHaSC9c814TJ7ao4mIKl24hbKRq6oowuL8DrEQR9HmdhIG5l9oXLqI0eygr8NHbHKLdj0MZUFOZpAWchw+3KV1EUQJJJkhNOpAjZc1grm9qd7c3dai+p6a4096oPwnlXPUKpQ4lURtF2ZxEMaLXL8lAY9JKIqHfUrXyOrSygwr6XTleiCyfe0efhmOEl/fqhy6D/s8pF0OclnnwbMVjpFHTWQeNaWPkA1L3a/5xRJ8L5t0LVFPAXZA5fASlvkEvveI4q0cN5J03n6o9/jM9/7yVGlxew6D/PASFY9cxGHtq7F4A5w2d8IMgVHGaCJdSSy33AFinlna6ivwLXALfZ/z7j+v2/hBCPAqcA3S5XwqMKI0eOZObMmdx7771MmzYt7zmf+9znSCQS9PX1ZcVgCSGYO3cuc+fOpaenh9tvv51p06bxl7/8hSuvvPK9ugUDAwODftje3MvmAz1cfuLoI90VZw+h4aUhQj5v1go1uAmWVrD672OlSVfIFTOioRWxeE669ngqnbWpbo9tUAX9HmVw5yTHGMhFsMCvFazs+JJUWhJLplwKlnRckaSUtIezFaxcaAVLr6C7Fay0VEZ7wOshZKdHTqTSjmIDGUUJyCJRugyUoeteJdfq0UCZBJ1Mfb7+K+t6JV3HSPXFU3hdRMxRQnJW56cML+HptQccl89cAqAJWUkw4yLoNvS10hUdRMHSfXIrecpIVcRPqyjuhChJS2YZuDqFvTtN+/BS5SJYXRJkWHGQ3a1h0lJy2iSVYS9jMKeykm9o4uZWcqaPLHWM7oDXk5UJTz/HoqAva35n3F6zY4jcMV9OvFdOlkWHeOXEKMaTKcfN0e/1OC6JkYRFUSC/WqLUOdXPvpjlqI1Bn8dZuLDS0nETzTwrpWBBZk+sgVBoL3q4Y+YqCv14PcIhWJG4hc+j6tP3PcxWGZdubwXIQ7DUWGu3WL/tItjjet/c5yZTaZLpNEUBpSRHchT3MRWFzj25F4tyY+DyITcGa0CC5fcQsxVyZ06nU7D1OWhc50ooISFtwea/QpciP5SPh/N+AONOh6Jq8IVApqF8bJ6WFLzAvsBkNsctzh42HeHx8LFZozhpfIWjyha6iKhO2PJBwOFWsM4APg9sEEJoBvEtFLF6TAjxRWAvcJVd9gJwMbATiABfeNc9OIjSdLjwxBNPcN9993HFFVfw6U9/mmuuuYbx48dnnTN//nxOOukkbrrpJr761a+yYMECpywajfLUU09x//3309XVxa9+9SvOP//89/o2DAwMDLLw8Jv7eHJVw3tOsFSgfPZ/WW43Nr1K7YYmRg7ByklS4S4r8Hv7qS/ufakgE8OStGS2ghXNuAgWBnxOHEu+LIJZLoJ+L5YrhksrAqBIhdtFMGEpAz2cUCvxlUWBrExqtVWF1NlJEpL2PlJ6BV0TFG3w9cYsgj6lUGhj0B2DpV0E8ylYbvUiS1nxZGKw8iGfG56GNvQ0mQnHrSzCp8c3N526JilN9rPQJM/rEXhEpk23guUmpfnc7TQyMVj2s3WNT9Cv1JW4HefWYrtZ6vtPpNKUBjLuYe5YHU2WdJKLqiKVWU1n0KutKgIpKYy1MIJ2+uJB9QykhHgvxX17GCuaiSUnUkYfJb27oK0T2rbDroXcYu2lpetsSEyBQKEzB4uC2QqWVoRS6XTW/IzEU3js2DqHqObEqOUmuXAULFe6f33P6nmmKC3Iv7eREMJRBONWxlU16Pc6cxMyiwQR51ll9ks62L5JhQGfs8eaRkVhgNqqIlbYe3hFEplEL1pl1QrWoq0tBHweJg7LicGy0+8nUkrN9fsU4dIuw6UuF0F3whDtLul+30G5CHrtMXZnEsyo3gOnL3c2Gk5YzvNz0NsEr/8Gdi/hSz1hLvOkKGlME8CCXwjl5hfvVvFOwoPeDF1lDZkFZ90I1VNg7KmQ5/09GLSrsn5OP//krKxyN/k+GFk+mnBYCZaUchnOk+qHD+c5XwJfOZx9eq9wwQUXcMEFF9De3s6f//xnLrvsMqqrq7n33nupra11zhNC8KMf/YhJkyaxdetWpk2bxs0338zjjz/OJZdcwh133NEvZsvAwMDgSCFuZbvaaGxo6ObJ1Q18/9IZh3wfk4ff3Me3ntrAsm+cm+UGpAlU0Od1Yguy+prMdu1LOi6C/WOwhuYiqLMJprIULG38BX1KwdJZ9vJlEXSMJZsUQsYdKOI6L5ZMUxxwx2CpJAntfZnNhN3GyAXHjuAPr+zG51FuS0lLOgRLG3xa0eqJJQn6PQT9Hodg5roI9sUt0hLKA9nGq2PI5RAs7SLoHkN3yvaMe18eBcsmL9pbKjdBQG8/BcuT1Zfc3/VnTXR1Nre0JIu4OftgJfNf7/MIl4KVHaOm1RVNgh0SbitV2S6CKtuclUo7iwTFQR+l/jSjCiWThxVRQQ9neTZybud6+PXjTO/YxRsh2J4YS6FIwE96wIoyE3g1CAc2HMPNwR14n3KprsFS5lopSva/DP/zPRg9mxM9p3Ktv49TE/to6TgRohOgoDzL7dWdvjzsckl0uwi648AyMW7ZWQTdyVJ0nJF6Plb+9Nu623aSk1gy7Tz3gNdDr2sTYE3mYi4Vc6gKlttFsDTkoydmUVkU4JsXT+fD04fzmT++QThhUZbKVrCmDC9mXGUh+zoiHDe6NDM/ehph9Z+4tH4zIl1OIHY5Fd4Yo+hmeLiFRKcPHxal3gT0tUDnXqYktrE9WYLlq6DQnoNaLQTwCJWGXSvq7kQ8TsKZgRSsdIpQvI0SIkTihZzq3Q7LtsOuRdBVD+FWsOIw/nR6rGr29/YQFEH8wQKGTx6llKjaM2D6x8DzDuKyDoKSkI+mHhz3x1y4F84MwTIYMqqqqrjhhhu44YYbWLFiBV5v/8lbUFDAjTfeyB133MF9993H3LlzufXWWwmFDs1GbwYGBgaHCnHbvURKmUWkFm5t5sHX6vjGRdOyUn4fCty1cAegNopNpyOUFfopK/Bn3Nh8HoKDuAimbUM/lRPQr35Tn5WLYDbB0vXp+3WnaT/QlY9gqcxmoMjSYBsN+z2efipJJGdF2228a/civclwVVGA8sIAQihx47ITRvGJk8bw3ac3Okkyil2KFWSUnJ6oRdDnzSIN+RSsdB4Fy71S7i7T6lHCVvnO+tki5k2tccodBWuALIJuhONWlsqoeVqui2DApabl1u33ehzC6k42kBWD5c3etNftigeKjDmp3WUU9q+CaBenxNfTHSlnrKeRz8S2EPF34O34NhPFAQLRMk6JLuOU1B54cQGkLf6zbz8t8VE0yGEcG6uD334NkU6xxrsTb10KudfLJ0ISQRo2AsOPp+2sH3H/oo2c4t1CwlfOmDkzoXg49YkSHvvHMq4KbeAPqY/y0QsuZGxZAArKYdI8Pv3r5Zwf2szXpnbB1ueZ23w3c73QZxVR3LoYbr8TKify2cR0zvVFqWg6DrlvHhPFAfpkAZFEwBnXomQbI2gnnBieRT4DMsEU0UB5X5jZYj8ioTa7jSUshnn6IN5LuezGcsV15Y3BinTA/tWc7NlOcdjCm/Qw27MHXvorX0k3siQ6i7QoolWWUxgN8zHPOqLxuepZISkLeRlGF9XbHgGvVxGFpvXQsTujxnh8XN4SYa63jnFd7UiPl4ZAGSN3VMAjVUxNh/ixr4uxrz8Psz5FNd0UWN0gRxNMx7hnHvz3gr2cVTURXvo2rHsEomo7iKneUk70dsGmB/kGQNg+6mFnCJifudWvAv+Jh76F75IAACAASURBVO5EGVWyk75giL0bz6XDW8kZFV2M9bThf/pp/B4f3w90E2i8EOREYBAXwXgfvPFbeOs+pvU1sTropTFcwzhfI/wDGDYdRs8GXwGc9XWomsSSZXu49bnNjCgIMWtEGadddnL/53KIof/uVBTlVxrdCVAMwTJ4R/jQhzKpJpcsWZJVduONNzqfL7744veqSwYGBgZvC5ogJFMyKymAVgGS6TQFHFqC1dSjyIxEcvX9bzJv2nC+d+kMhyhpF8FcgqW/OwpWniyC+n4K/B46w9nXa4NeSjsOysrce0uvm2Bl3Mi0IRmJZzb0jWXFfGXcfbSxrxWscE5MhjY8dDB80pJO3FlVcQCvR1Be4KczkmREaYiq4qCjPiWt9OAKls+TFVeUq2ApgiUHcRHMjsFyp2kHtTHrQ6/v7TeWfk8eBSunjXDc6ueuCRBNZgfw6/kXjmcTL/1Zp2l3b/iaSyTBFdcj0rDhCTiwBrrrWSoW09xXTTwgOG5+A6SUeujsExOAeCRI0iMofukjLAoCdjBEMuqHNQUgPJweT1ES7QUgjQeqz4ZgCd5pF0OoHBHvBa8fplwAxcOhZCTRrhi/fXkxv01dxqSyIs6/cC4AfY09/PqlGnaP+wrPr2/kvKlnw/BM8iyfz8fa4Mlw7ofg3G/xkydeZ+mmOgqqxvIhzza+PbMH9rzKybtfIemVVO5fBE/cxaIgpKVgjXUMCRGC+3/JR+pXcFEwzeb9J/IJTxCefBKEh5nb/87LwQ61yU4QUhu80HMqdzTXMTq1H34K3wOuZTj87eNcGIfp4eGwfpuK84l2qkx0+1dC2uI+gG2uB90e4ioryWd5EoJgSQ9EBb5AimTjPVhBDwX3JpjmCXBLQRrvC66FCW8Aqo9RL61MQdpiZCRGhBBvpaczvMSP6G2kxBODrr2URLq4yNtD+Z4kvp3zWRlCBau8oKqbAbwQALbb9R97hXKXm/UZ/rja4uWFL3LN2BZaOrtJBcsRBeWcUZNk0dodXDd3KuWlpVA+jj+/WU9892uM9HQjS0bS27afj3cs5Tv+CIlYMYFhk6D+TUin+IynhdC25+F/bgFvgFMrz+XrPknx4iXgD0BhFcR7Ye186GuGyefTMeq/eGzRG8zx7uQhz6V896ZvQmFlv3co5IotfEdZBN8BikPalXNwBUuIgc85GmEIloGBgYHBkJGwMrEmbuNbu+7kpjp/t+h2ucokU2m6oklabTc5dwxWyOe13egyiQQ0AZMS0mmZySKYJwarMODL2nQUyIrpSrj2oUpYadr7Ev3SoGsXQcBOHpGJAdOB8O79owpyFKxoDsEK+b14PRmiYKXTTjySju+oKArQF7cc9xudvS2eShP0Kze3vlj+GKxBCZad4j6Ys2oedClYbnc7N8HKF4c12P48uQSrL57KekYamkj5HAUrM9b63jV8Xo8rBsulYGmj8sAaat+4l4f9q+lom8Y5vj5K7vlv6D2glJCCSlZ4Z1OY7AAp6T3u85RNnweFVfz6lXrqt7xJiyxn2HHnsWz9dv4wczsPbkwytzbEq+1FpCZ8mF98+iQAvnzfm3jDLYQS7ZRWjeZnVx88nto9Jtmui7bqNoAiqOeYRg9FdPuHUer1sMl3LJx5Kpz5/7jmt8tZva+LL84KcfX4Ln7x3ComiCbO8a6j2BMFiqib8q/8fXMLF6Y2MpU4NDRCKkl0+Gy+s+MYRlQUs6szxadHNnFeYhOdoozllZdw1Ulj+fuWZgobXmXMqof4noyqaPu9gDeoEiSUjobTvwqT5nHLYyuZXhqnp72JiuFj+ZcvXM/n7nmV8gOvUEicSZ4DBD1pFlkzuaJkCx3hOFedPo0KXxKQMOuzECpVey+VDIdgdrbm52wXY4DPnTCO71wyQxFtIWjrjnLaTxfx8wsnclrfQn6/dDufnTOGaaVJRdZq7CRl0S4YNg3GznHNsZ1slBN5qeg09kT7KCvwUxjwUTBiGL9JbeFLZ14Athtj3Y7NPLJzHKVBP6eOrOKppv2smfk9Xli9mx9eOYcr5tQ69V7wPy9yfdUKPjEuAuFWJm9+num+KHJ9iSKNyQggYPKH4Zw/w9gPEe+OctvfJyJSKnbsu3nIFWQWGKLJIWYRPATQf3cGSmChF5LKC/zZsWNHOQzBMjAwMDAYMrThm7DSFLm2YnEUrJxMfENFc0+M3liSyTXZxtHKvR2utiVJK91vg9OAz+MYDjErTbEr9bNGSkpXDFX+GKx+Gw27CI9OMqHqzWSQ64tbrjTtLhfBRDZJiCVTTgptv0ftxVQQyE5t7o7JAEUY/F5BXzwzttp41sZRVVGAeDKNx7Xhr84iGPB6CLjSXetEAz3RJGMqCwcmWF4PSVs167/RcCa7XUlOEL++l1wlEfqTo6w68yhY+eL89PPQfXA2vM0TgxWwCZaHNJP2Psat/lfYkJ7AKWE/3PN1aFpPpTdIqRjJyeFnsbweGH4OXPILOOYi8Hi485dL2d6sNo1efu48yuyNattKinkspWIBP1dQRCNVrJlwHU+u34S3cgyvtLVxtmv/yoDXQxPlRClhRrB/iu18yI0H08iNG8t1a3Rn7wP1PAL2nlb59sHq9FbRNno2f02rkIRfpa5kTEUBy66dx54tzdy2fiVPF5fQE03y2g0qdL65pY9n7lzKOFnIvnSEYNVIzvvsbK7/xRKmV5dy1RmzWdW9hYf2nsmGb53LOd/7C/9xxiiuPmUMVE4CX7ahvT70/9l77zA5qjN7+FTsNDlIMxrNKCckhIQCQYBARIFtHFiDAePs/RzXi72OG7ze39per+21FwfsdWDN2jgAhgVschRBQiihnKUJmtHknpkOFb8/bt1bt6qrunukERLeOs+jZ1rd1dXV1dUz77nnvOcV0JdMYHPfIK5paCKPK0k8ZjmuH+5S6JJX4IiRwbXnX4bauuBYdj+SnGU5JkseC3NScQJQrDh65t+CXz39Ei5bsALzOXtrGJgCqpO+NXqOR4Ji2p1FC910RyKM6gJGkISses+HoMTwfNVbccNa0n//gyf24vtP7cWhf7qOyDxaBrB0IF7NnkOvEdsunjbIf8/9CxunClVxGYKA0KATqmD9JdkDgb9gguXvD/hLBN9AHCFChAhvBCiByhsWvvv4Htx6wTRMqowjq7tN/gBwtD+DuCJiUlV5vaT//tgebG0fwhO3r/bcv+noILttWBZ0LnWP78GiRVNON1lhw6ejmaEKltODFRRy4SNYtL9Ic4aJNlSQ9DdaUKkyZxEsIFgWKuPEIkiJAV/sAGChDBS0MKYKjcGpQ7SIunhOoyfSWZUJsbBtUgDGZJE1zFOrnGsR5HqweMXEKQYNyy4cNMz1PakcWaJ2Pd20C8JGgEJ7H4+CHizNCFSwMrq318o/+0eWBGI92/NnfMTcBlvTcYH6Kua82o42UcFt0hNAL4DJZwPXfhsHJq/FW368FXMnV2BvzygO3XItKWAdJHykkx0vdz/tc8uz658Qee/sKmcOlu/+YlA8ChYXmOFLPvTvT5FFZLlwCDqvTJFFZLImDJP01rGQC9P2xJcD7nlln7VmeI7H3/tGVeu8bjGFkKbmZUwJXWiAVjMLmDQz8L3GFJGF5/ApgkEICjQpBZ5Q8WmQ/GNZzWC/H4JmtQWBH2jNf1dH8ySWnldj6PkgnwcZNjzGlFdvraoGkGF+qDfUQmKphlwvfvDf5zdKwTpnag0O92VC1alURLDePIjH4+jv70d9ff1fLMmybRv9/f1REEaECBHeUNDC7EDvKP7z6f2YWpfEu5e3FgzX/cRvNmF6Qwp3vKe8FNTBMc2TnEXhnwejmxZLFGMKliSywo5XT3gVxLBsjwLF3w8Q64zhU9+yvvQ/WvTohoWsZrIUs3ROhyIJxPbnsQh6FSz6HmixmlAKiQUP1YlSp+qPbtlsiCwtjj59+RzPcxRJZIWvKoueIqqCm6sV8z3mV7DyBrEIFgu5CFJZjBAFy41pD08RpBgNVbC8cdWKKKAewxjN6VBgYPa27wK7fgZYOt7vPGczZuPgJd/DTeuakMx24tol0/H5d18OCALEXqJOZXUTkigU1At8ke+JaefPqUqDSNzrXzP8BEuEblkwuJj2UlADzi1/m5+D5X2e4CnO886xqJIAw7TwjT/vxvbOYc+gYf+5dhVCV630xNvT3jfNnyLonYNlWjbr/0vFwstNd3Cz+/wwdSUX8r6LwatgFV7PiiRgTDNZf2S5++bnrVXFFSiSAMN5z7y6S18HoPPjyHePfk/9ZJH2QFLoRmliHna9+OFVsN6YHqybVrbhppVtoY8nHYtgRLDeBJg6dSo6OjrQ29t7ug/llCIej2Pq1Kmn+zAiRIjwfwh0fg4tnGgxRwtMSlJ60jmPRaYUxjSDKTU8RjlVJ6eT2UxuYUcKY1kSWQHsJVicRdCy3Zh2Xw+WKLgWHh78INC8YXoshjndYnNdSE8TKRJoP0FG88bZu4mENrN5+dMW/T1YtBALUrDCIptJ4WZ6nk/BW3RIiqD7WMJXhGohBIsWb5YdXPjrPoJVGZcxkjOYOhe0is0fR2Vc9qQIxqChWegHAPRq5O+dkjkO7H0Rs176CV6Lb4S2OY5PxyTU7BgDltwCXPolrL3rEPYfT0O3BPzv3FWQ17+Gw5lm5FNTmEpFlYqsZgUSn0SInYq/TYkDVe2otdITuCE6CpZpB6YoBsEzxJl7PXqc9Bz71Ra/FVB3BsqSmU0W2gcyONg3xsJGDMvyfE/oPvhjyGgmJlUVftY5n2pNCJKjYDkkjKYwJoski6qyhIGxvKOYOgpWCMHKhrzvYuBf268ak8dlZPIGdIsOAS+XYLkKVn0qxuy5/jEDgPt9pdeA/3vq2db3u8jf7xp8LOUSrODr+HQiUrDeRFAUBTNmzDjdhxEhQoQIf3GgdiBqi6P/p+RAdyLNh7I6RvKFilQYMpqJjGbCsmzWTwQQGxJd4aYrvvRnXrdYkUALJ96elvcRKRpoofkULFkUC2w5ZF9eNYxaBLMaiWCv5nqaKHmhPR2FBItasixmCfIrWFRNo6C2I9pjZNmuFS2sCFQlwZ2b4yhgFCkuKpvOwaKI83OenPNN9uc9Rq8VqfC2xlkEf3jzuahLqWzOkMrbnCi0DOqO/BlrxZ0wIGG12o75I7shHpyK96sb0Sa6C6VbrZkwVRGx/zwAwIaSasK39b/CuZOA4729WLn2vZi56gZyPPIR6JYzt4mLxOcLTD6mPagoDbUIcueK2VG58BcaaOK+DhlAa1pW2cW7IAhslpR/X0DwcGTAtaJRaIbTgyWT+3MGGYRLjztIwfIPFM7qpsfG5j9XtOcrZ3jnYAEuwUoFxbQ7iHF9gq6CFUzI6HdEGoeCVarvKKVKyPAKVrkWQdFVsBTZ24NV4SNYHsIsCVAkgS2cBH2G/GeimXZJBUsSiYJu+si9HzHf9/xMQKRgRYgQIUKE//OgxTu16dGChw3lddQdzbBYr1Q5oKQpq5seO9FojiTkdadz7DVGuQGntEhIKAEWQd2vYBWGXJiWDUkUCgpTAB5FjU8RpKEW1QmVnQNauNFiIevrI8oZhRbBoNV0HjTkgp+PldENlkIY+BxfrwyvCPhtbjx5CoovBwrte94eDqHgObphsc+pOqGwQj6rmW4haWjAwWeBHfcDux9Bcz6NHzu1laWJ2ItWTE2/hFft6fidfhmO2XWoE0ZwrbQeOmQIqz8PzL8OPbFZ+MG3nsPl1ZPw1LHjeHj6Rex4PIEXshuJH5R8mNGMwAZ8quqpspcY8ueEFtKUVGrOUGjvTC4ButMDWG7xTp+nmYXx80C4RZCqKBSaSUiPIgnQDAt53UROtyDADU7J636C5bUIFt72vib9bpiW7enBAtwU0GQs/FqPyaI7b0xxz3kxlGu1BLyDbIOIW4ISLOd3WdkWQWaXNRlpMiwbY3mjgFAqvoUJMk7BG9riHqNLOAGwwJqSxyNRgvXmUrAqVBlvWdyM1XNLB4u8mRARrAgRIkSIUDYoyaDkiZIVliJoWBjKkr6pkXEQLGrHG9MML8HKG6hNEYJFt8npFgzTQl53Cw9amGVDerDCQi50k9jDaM8IJVxkXxaLYud7sGhUerXHcucQLKcoHwtIESSv5/bhlCJYMWdVPM2FFmTyprfh3QcvsXAtgmpALLuHcPHEIyDQIGj/ntss5MK1CMYV0bnfRl3+KN4uvgj84XfAwWfILKRYNbDgrRic+y7ccvduiLBw1oJFuH93Fm9Z3IyHtx3zqHo/M6+DKovYe9lacmwjJFafhQUEWOnocdLCMu4hWGQbyw5WLcL6gYIsglTByrCkQy6YQiQKlm5Z4+odUmQR0EwPWaPHSQmd3yqnyt4eLM2wUBWXoUoiDMtiM9no94QoWGEhF8Gqlb+A1wz3M6fXFH2fQ2UpWBK7xum5LVX8jyfkolgPFkA+wzEu5KJcEkxtlkwldNI3s7qF+grvd9uvQqqSiH5NC3wvBSEXRnnKpyqJyOnF+7V4gnmmECxRFPCDm8893Ycx4YgIVoQIESJEKBuUNIyyBDHHHqS5Q33pXKeR/PgVrEzeBLik9tG8gam1Cecxd39jjk0vxgpnb+EJ+MMsLGYR9BMvWRI8BEESXTWMRrHnDYsVYPR90R4swC1c6Ao+TRFMKBKyjmpA908LIL9F0A93pZtTsDSz6Gq238KncgWrv7jy9GCF2OHCQi7o/v23eYJVPbIPk1/5ObbEHkaNPgYLAtDZBsy+Elj0TmDWGkCOQczo2GmTwc3LqhthWEcwkiN9LP7gE8+xMQUqIKbdd5yUWPFE0q8y+cGe41M9vBZBdxg04CZBekiRkyI4npAL/v2pAcepmRZEAR47LXlc9JBSWvzLkuCoVV4yRXqwyLHTazVQwQohrwD9zN00Tv65zCJYTMFSRNBDdj+n8Gu8mIIbhGIpggAhYETBOrGQC3qbhJnYyOlmwXfbO9dMcBIHi/Rg+RaByiGUjBgXIU6nI+Ti/yoighUhQoQIEcoG/cNPSYbuU7A002IESzNIA32pP+S2bbM+I3+S3ljeYESGD52gQQiqj6zwFkH+tmUBOg2p4FbsDcuGJLq9SvycmoxmoD5Fotg1w2JqHZ2QUREj811s2y3cRFEgBVuepAhWJWSHYBUOaKbJg6av94rCjX52j5fM3AkvAP0kw1UEJA/p4P8vCuGhCuUSLDV9FNeIGzCpZwBth3fid+rTmHPfblhyAveZK7Ads7ApcSEe+sy7C46ZL3obKshwtYGMhsq4UkCw5IDjpOScL/wLFSxKgIOJQlBRnWAEq7SCRT/fTEAcvSK5sfflhlzw++A/G0Fwr5mgfcmi6Bn2TWy0ElNX/P1WhmmzY6+Iyw7BcnqwPEqm9xhofxjgUy2d7zr9PtHfBckiCpa3v614DxYwvoALAEiWIBVJVcbxkRyzCI83ph0AS2rUTZIw6idY/uvBT7h4BIVclEWw6PVShHx6rMBniIL1l4qIYEWIECFChLKh+SyClLTwFkF+lXw0ZyBWUZxg0UhwwEuiAKJg1SRJg86Yj2DlDRMqVY5KWAQNy1WgPD1YjqrgKjAu2clqJmoaCbnjLYIUCYUk8eW4sA3AWRHXTeQNE1VxBT3pPCtASagGKYAEQUBCkTwKFQ8aIc0rEhktOJCBwl+40f/7LYK8ohVXJI/lUJULC15+nxQp5ID2V4Gt96By069wp6oDWwALInahFcMXfBH5Je/H3/3HJgDAVDkR/D6599NQSQjW4JhWkMRGXr+wMKVpbOHqmsAKS17N8GwTUFSHEixnX4LgbuNXsLwWQYE9Xqz49SPGiLj39WWHYAUpmYoseK5vughBCVGhgkVCLgTBtdIpAYV6wTE4/WGA08dleC2CroJFbHBFLYJ82IrvnActQIzHZkm2d99/kC2OLIiMP6bdr/TKDom17cKEUD/BCrtW6X69fXSFaZ5BUEKuFx5nokXwLxURwYoQIUKECGUjyCJoWTZngXNn3wCkD6veUSXC4FemKHSTrLjXOgpWllO3qG2PrXg7RVreQ7C8IReUqPhTBCUPwXIfy+omU8800yyYk5VQJdb3wBcuSVUmSYOGxcITaO+Lf0ZSvBjBksSCYqkUwQrrwfJbAmOK+39/L1hgJLllAofXobLjdXxZfglnC4dw3rbdwDYLkGKwz7kZ73hlFt67ogla40J86ZEj2LjqCshCeJFOIYpEETFtmylYx0fyWBQwpFrxqE4iRMFVPcNDGdw5aXxaIpl9RRTIoKI6LHCBt4NSFYkGRYyxZDhvz03Q7VIIsuoBDmFD8DH7+3fyXH+QYdnsOqSgKYIxLnHSPwcr6BjI/032GoUWQacHy1Gw/ISDR1DRT39WxmW2D/79jxcJVYKWtQL7HlOqjIxmspj2cgkW/1nS76pu2dBNs+B1/MOiw+yX9P/+OVjlhFywz60IcVIkAaJA+g4jBevUIiJYESJEiBChLNi2XahgmVaBUjTEhTKEkQceY74eI//9tY6C5X3MZP0lAG8R5IpL7rZp22yF2rJJXLosiTCd4AHW22K4tifdtFmQRZCCRYIiJCBnFChY1MJY5agwec4iyId4JFTyPFkkShXtgwEKY9bJOTCKrjz7UwRZ0ewk4dH+Dn4OVjE7Uxw5YPt9wBNfBYaPIgHgvZKKw3YT1k95Ly5YtQaYuRpCvAZbXv4TLqmYjZQls/1atktKixXG9FjqK9zPOq5IHuUhb1iFxainl6UwbY9uQ3uvCgpfsTAKnb13tbBviz/WuCK6c6kMN4CFviaFGnJcpcAHlPCQHXITFMagSKSfiYa1aAZJuJOdhDn/rDnDIn1ZvGVUCSjUgwkWgTfYRPI8dyijk+uwyDXrJf7ecx5EsMYTcEGRVCUMZ/XA705ClZyQi+DgkDD4rzfVSWoECr9TBd/LYhZBqdAiWKwnzd1PoaXUD0EgiZoZrbR1O8LJISJYESJEiBChLJiWzfqP+B4s3panGZanIErnSs/CClOwaAphVUKBIHi3owoWtZGVtAiatrf53yFYVMGiBQ8/NJW+Nt2XfxBxwiEAgNfmlFAJSdIMd1ZWkEUQcBUVGugQU4gCYTgWsJNVsGK+npiYRAkWp27RY7dtYPcjWPniT/BtBWgVjuO8e3eTx5oWA1d9DUbrKiz4+gYAAj49fTYuWDgPACCAFoY2JE7N4ElpMfUmphAC2MipnarTq6KZJM0xb2iBgQD5XCkFS2AFb1zxEwVidQs6NmYR9D1Gz2lCkVjYQmHUuVdpY7fHob7Qffif486pKtwXr8RKosRGGfiHA1MYzgIJiXL3Ejr+dflIfsBLGj0hF5QU0h6srF40oh0IVkzpzyBr4XgtgoCroAURlVSMzsEaZ0x7QMiF+3qFtj8KWRK8wSWi//oqjNr3z9UKAiPIJQgiJViRgnVqERGsCBEiRIhQFniCMeoMEdZN20NqdNNmyWEAypqFxQdb8Pui91fGZEep4FIEHYWI71ORRME3HDh4DhZAiGBSdVIEA3qw6JyhYgpWQnWjzvnVYGo50kwLyZjsHFewRZAWfjTQQRYJ8TGcAshfBGXyJhoqwwvW0BRBxf05kvf2YFVJBrDnz8CL/wkcfQkVyWZcKQ5jBEl0nvNptMxfCcy7FhAlyABEQYBlB6kapMlfEEhBKYkCBAQrOX7EZEJWGitj3H0iO96KuIz+Ma2AbKghpIoWu4okOKv2wXZIqgYF9UYxguUryuk5jStSgYIVeCxiMNkqhXCLoEOAAgmWmzIYVySm8gZZzASBtwhKBdZA73sotLFRBCpYtAcroxXtvwK8CqG/ByuhSs51xSuhJ6Zgkf0Gh1yYlh1oNS0G/2KG93vtHzTsvU496mBAkIzmDGwXBKHgd0YYXItgcYJYbhR+hJNDRLAiRIgQIUJZ4FdVRziLYFbjCZaF4azGrGjlzMKiwQCAG1hAbpPnpmIyFFHwKl0aDbng7GxO4ASFJ47dtj3N8vS90BRBfw9W2jlu2hPEx7RTeBQsPvJcldA3mif9L5KIuCy6ISCm1+ZGC8qqBPlzrEoCDFlkK8yFCpYBRSrsTaLgSYxnDhY7TgkiLEwZ2gjl4W/g1+oWnDt8ALgnByTrgbd+H1uq1+I9P9sAGwIeWH4RWlprPK+hSCF2PZnMezIt25OqSO2PRRUs573GFYnNHuOJAS3Sw1INRV90t8rUHy+xCuuNCe7BCi5E3b6/cAXLn2IYdH8phFsEHQUrgGgwJdYJjrFsQJWkwPeXVCQn5MIk51+m6YHkpyS6iYVBfWAU/CKLvwerb0zDzIZU0ffJK4T+c05trrppcscyfgUrqcie/Xoec8gXXRgq9zPypwjyx1U8RVDwvOcgi6Btk99NdNGirB6sMkIugPKHOUc4OURnN0KECBEihOJ4OocrvvscjvSPeRUsjmDldC/BGsrobHZVWT1YGt+DVWgRTMVkKLI3rnwkZzi9OW4hk1AlHOwbxdce2klW5vkeLMv2rIJT8mWYZIgnv/IPuOlnVFGhMe188ZWgPVjwFm5JxyJIwwPiiuSxCCpiYSFWGSNKmSy54ROEIHmLL35OURA8vR4i0GD2YK7QjrWjDwB3vwP35D+BLbGPYNW690PY/TBSQh4vJtYAt94H3L4bWPZ+qKoKGyIAIbAgDSvkFMcimDe8Tf50u2KFqyqLrOepwenDUp3eKT7hrtAuF6Ly+PpR4r55aWw7MbwodVMEfT1Y3L7o8/3x5565USF2wVJQfe+B7Zuez6IWQZstIgQRdYCoLIZj74vxFsEAQuhXRfz7o9/VuC9FUDMs1kMZBs/Aa9l7zmOK2xuWotfACfRgMYtgwPVMyTslWOXO2PLPZPMoWEV6sBTftn6iTK8dtx+0zBRB53ooRcYiBeuNQaRgRYgQIUKEUOw4lsb+46PY2zOKBc3uBGDaz1RIsGyHYCVxsHfMkygYBr7vaixAzaqMU4tg+BwsfNOeGQAAIABJREFUgBRlz+7pxbN7enHDsqnIGyZTT8ig10J1i/Vg0cLUoASLHHdtUnX6dIhFMKlKTN2KqyJbieZtTklV9oRwEIJlsf0HFWK0l0yRBIfcBKcI6mZwPDd5UyNo7nwM14u7sFg8hCm//Bw+NtqFj8UA9AMQ5uGgPAsdWRVLL3krFl52E2771+exYlIdrpi9gu2m2KBhcp5FjKDQ8kcT7AzT8hSYiiQgq5eKjxaRcArthooYDvdnWLR8jCMIQT1YQff7+4maqxNIKBKzfFLITOkKULDU4imC3h4sn0VQDC6gTyTkIkw9Cgu5AMj3kidYQddMUiXEn86qCzrHqqNW+p/vPyf0e+63CAJAXaoEwfIout7in+8VrIjJSOeME0oRTIYElgAu+UpnDWYpLQf+mWxei6DvfPksgnyfm39YND+Tj/4s57ph+yyxbSxSsN4QRAQrQoQIESKEonckD4D0M2m+VXqAzGjJ6n6LoI6zplRBlUUWhlEMdL6VJAoeBYv2eVGLIJ9OOOaEXKgBxRlACtmc7hIiy/aFXDjvhfVgsZALsg0lWNUJhRSZOrEI1iZJkScKVGEpXA0mr6mz+5OqxN6LZtoedYPvwSLH7X0PQaSEFVvZIaB9PXD0ZeDoeqBrExYYOXxfBfK2DHPy5VjXfBv+uCONSQsvwZdvWYv/+ME6bB0Zxj2zzgeUBGKKVGCb8yeeFb5+GKkhdqa8bvkGmkoAjKKF383ntbHXpbZManGMyVLojJ+w5DQ3CII8ft3ZzbhgVj07z/7nFw25CLEI8j1YBQqWL5ab3R5H/1C56lzQ62qmhbzpplEG9eXQtMu87o1pL4gQzxchsBLpF2IKluy1CAJgow7C4I1p9/a98TbXZIwuQpy4ghUPIBUpJ4QjndNP6POht/nPucCKyp1/RRKKkiH6GJ9oWs57Drte/Igz8hqlCJ5KRAQrQoQIESIAIEl3H/7vjfjsVXOxtK0WgEuwSMiDXfAcI6AHayijoSahoDIml9mDRfudVM8w4VFHwapwLII8kRt1FCJ/7xNF3rCQN0yknFVvw7JhWN5kLsBVsGihTFeNaRJiTUIhSXWGCcOyWcR6whnOG9SDlVIlj3rQWpdE+0DWeT3LYxH092ApkgjR2a8guARLggkbAhLI49KxR4G7vwkceg6wDECUgeZzgOUfxJ66S/HxPx5Bj12LV979DuzbcBQPvL4LtySnOsfpLWCbquJoqvb2dHlVwfFZBHXTQs5nEVR9ZCcIN65oY7cbKlX2OsRiKbJzVtCvUpJ4kZ+iKDDi5t0uPJHPH7hAwce0i84sLX/CpNciGGwXLIVS5DGIFAYpWDFJDCQOSVVinxdRiQvPBbMIhqhoyZgELWMxK7B/0DBQvoIlCu5ru1ZBrg/P+e6dSIpgUiVqY9A5SzoWwXRWH9/n41Mmi1oE/SEXRcgQvaYpac+XG3IR9WCdUTjjCJYgCNcA+D4ACcDPbNv+5mk+pAgRIkQYF/YfH8W3Ht2N7920hP3xDsPW9iF894m9+PGt55bcdqLQN5rH2+5Yh5/ethxzJlfAtskf3f3HR7Fufx+WTastIFh5wwpUsPwx7RnNxJhmojqhoDIul5kiSJ5fn4oxsgVwIRcqUQpoRDw/Z8obcuEWNZoTP02tQablDangFSxVce1Rbg8WIVhVCQUxWfIEbgCFsc/8cTTXJNhtVRIxrT6J9Qf7Ydt2gUUwrpBhubQPRJFIsEC1rAGv/gzv3nM/ViuDWCQegggLNgRU9OUAczpwwSeA2VcCLcsANQkA0DuHccA22Gvz/Vz8T3r//3z4vAICwb+XoFXusIGmiiRCM2xkNV8PFiv8yiteKRGi9jDevuYvkMPIG7P+lXhNlsgXQEASIYWoLJGERPoeZVEoWHzwWgRPbg5WuEWwSA+WYUOTgnuw6Kw1mp6X0y0nra/wWg4jeW5fFJlTlc7pEAQUXG8ASvZgudekxOx5Me4+1bkGaQ9WuXOqeEytTaK5Ojgchu/BGleMPqdKqbLo6d3yD1b2EG6xMHyGB33vGmcRLIcM+QdFhyEsvCXCxOKMIliCIEgAfgjgSgAdAF4VBOF/bdveeXqPLEKECBHKxzO7j+PxnT149fAgVs9tLLrtn7Yfw3N7e/Hcnl6sPbuZ3Z/TTTy0tQtvPWdKgd3kZLGnewRdwzm8dKAP339qH46nc7j/46twoHcUANA+kGHb9o66CpZmmgX70kzb04NFiUkqJqMiLpfVg5XJG0iqEirisifwYjRvkCABXy9SbVJFOqfDsGwPAeDPk2YQgkVXz00LniJY8/dgOcUGJWFDGR2VTsS6KotMTaNFHlsFltxCkIJPTVNlCdPrUxjTTPSNatB9FsGV0+vQMZBBjTWAZvTjbbnn0KofxrnCy8AjadQmpmFAiOF/zQuhQ4IKHT2z342/fd97SM62DzFPcSwUhgb47EH+niRyzGLgbXe/tJDzKSsyVbAsz37dkIvyCjreIkgHIlOi5C8eQwlAmcVmsRTBsJALcp/IrgEpiGBxxbd3Dlb5RW04eQxXKuj70S0LmumcM19YSkOlivaBLBIqSRHM6SbiITbMsCRDuk1FjKo/ZAA2JUie72uqPItgPDDsgrMIqieuYH34ohm49fxpgY/RGVODGa3AQloM/GepSqKnl6qYgqXKbnhM8GfotwgW6bsMeF7JHiw5WJmNMLE4owgWgJUA9tu2fRAABEH4LYDrAUQEK0KECGc8frHuEKoTCg73jwEANh0pTbB2dqUBAI/t6PYQrD+81oF/eGA7/vBaB375/hVMOZkI9KRzAIB9PaPYeHgAgxkd973Wgc4hYmNrH+QIlqcHq9AiqBuuRVAQiM0GICu4lTEFo3kDhmnhO0/sxUcvnonaALvQmEasfClVQv+Yxu4fzRuocNL1+AKvJklmRvnv5wlW3rCQ101W6JiWBdNjETTZ/d45WE5Me1ZHddJ9bapg0SLPX3zzxcrMxgp2W5VFTKkhK+eH+8egWxZiMIB9TwA7HsDawUNYO3QUONSOD8cBpIEhsQ7bhTm46IPfxO8O1OGbj+7xnK8bK1oDyRXg7Y0RBKFQuSpj9TqowOYRassTaQ+WiUSVd2AwUH5hTJMbVUnEW89pRu9IHruPjTiveWIWwTAwshKkYDnKadCQ12sWNuGCmfVkH6IIwB/THmwLPJGY9qBeN/6n5zlMwbKgcfY+fh+NFTG0D2SRVCWmYMWUwjlY/PGGHQPtXxrJ6b7kSPfYyk0R9PRicddpjJE5l9COF7IkoiLkWqDvIadbqEuOx8LpjWmXihAs/0yxYsSeD7kwLTswJj8I5VsERfb7IcKpw5lGsFoAtHP/7wBw3mk6lggRIkQYF36+7hBqkgorKDa3DxXd3rZtRrCe2n3cY3l7cV8fKmIyNhwawL2vdeB9F04P3c+j24/h7leO4L9uW45NR4YwrT6J1rokjo/k8G9/3oMDvaP40tr5OM8pCLsdgvXSgX5nuK2Abz++Bytm1AEAjnIKVt8Ir2AVWgQNy0LWScgjKV8OwVKIItU+kMGenhH8+NkDmN9UieuXtBTsI6MZSKkSkjHZ89pjeYMVVXxhWpdSscspuMNCLqiCRYmpaQF60BwskyhYhTHtOlNhVElkyho9noQvYY5FTRsaGvJHsUTYjxphBCu23Y9JVi9+pqRR99RMfFs+jus2bgVeSQOxaqBpETBlCV6edBMe29kDve0i9MRnYk/PCF5oXQn1yKGC81VskKhbZAme//uVK//wXB50WzoHKfw1CkkNtYwGWgTHqWDFZBHvWEp6xz5/71YAhRbB8CCIcBLi2U4sUujKIu756PmYO7my4LHv3riE3Q48R3zPjYdsla8auJY97/7dQcMB6gcX1iJxfYA84aPnN6nKroKliByZ8hIH/qf/fdDv10jO8Fh0T6QHyxOMwvU20mv1ZEIuiqGCW7waz+cjCO6MN0UmVl+KuM8i6JkpxvWVBSlTfMgFXfApNTwY8C6uFENSlYt+/yNMDM40glUWBEH4KICPAkBbW1uJrSNEiBBh/DjQO4qZDamyV/k0w8Kx4Sx6R/Jsjs/mo4OwLBsDGQ2mZWNylbcHoCedR/+YhovnNOCFfX149fAAVs1ugGnZePlgP9YuasJTu49j17F06Ov++fVj+NivNwEA2geyuPXn6wEA+/51LT75683Y2jEE07Lx6I5uRrCOpwlpoorVredPw10vHcZTu3rYceWcIrl0D5abIlgZk5HO0nk4EirjJOSCWgj9w1gpxvIGkipRsPgo9tGcwdQDvqhqqorjhX19APwRz7yCZXp6sAzLYjOvdNNmDeR0ddgfjTyU1Vn6WUwRmTJHi7y4LAG2jZSgoR7DmNnxILD3FeDA0xC0UTzgCDh6VyWkxrloFgYwqfso1oh5HKlfjXlrbgNmXQbIZMN9Lx/GXa/vwJWJyaiKyWwulr/PyX8uwh4rHDDs/X8x22kpe12Q0kGPNZM1meXM3T54llIYqOJXFWAzDI9pD5sVVcoiWHzVf8X0upLHG6RKeYfQBicKlkKxtEb/fv3P0U2LFfyq5LUITm9IQZVEtoAwphmIK5Jne7a/kPPrHwA9ktd9KZ6cRbCUgiUXWjFZwAinrLE5WCegYBVDwnnvlj1++6EiiTAs01GEvPss3NYhWKLA+sqKhVzwi1rjGjRc4nt2y3ltOHdabcn9RTg5nGkEqxNAK/f/qc59Hti2/VMAPwWA5cuXF3pWIkSIEOEk8PiObnz07tfwo1vOxdzJlRAFYvvqGsric3/Yir+7eh4LgaDoGsrCsokC0jWcQ0tNAp1DWdz10mH84Jn9MC0bv/3o+VjQXIWedA6NFTHsPDYMAPjAqul4YV8fNh8dxKrZDdjRNYzhrI6L5jSgfZAoQGF4ctdxdpuPOP/FukPYcHgA37txCX6+7hD29Yyyx6hFkOLDF8/A3a8cQU63UOvY7zoGs2ipSbCYdX41VRDAAic0w2Ir4CSW3bUIplQZGc1gM6ByRmEPF0DmXaViEpKqjGPDOfzjg9vxkYtnYiCjceEPboHBN6vzCtal8xrRPZzDuv19nKWPWgSJ1SapyhjO6gU9WG44gKtgTa6qALQMGjGMsZyGhUInrup7FjXSEC5JHwe+vRNfHDuOL8YBvAagshk4+wag9Xx86bFOHBk28dfvvhmrz2rFx//9GcxoSOHZPb34+0ULMG/eTM854HuJ/u6aeez4KTmJySIjhcWKLb+65A/hKMciKDqpimGr3GGkRpUE6IbFQhP8763c/qPm6gTu+9gFWNRSXbCPsEI/jISUKkyLzcEqF0EKlscSFqJmlUJ4yEX4+eSVWFrwk5AL9xhvXtmGG1e04rEd3QDIdzkuS7Bhe16XHG9Y7xu1CLo9WPz3kldsgmzBQe+TJ2gJVcJX33oWLl8wGds7hz2hIhOtYAmCgJQqYyRvjDtAQ5YEQPeqjLzlmIciicjplmPZDF90YCmCpsV+H5VlEWTXcvFt50yuxJwAVTbCxOJMI1ivApgjCMIMEGJ1E4CbT+8hRYhw+pE3TAgQAvsh/i8ip5tI53RMqgxOhTpR7D8+iu7hHH77KnEqD4xpuOK7zwEAdn7tanzsf17D1o5h/GzdIfzwZi/B4vuWAOBdy6bijqf34WsP78S0+iQ0w8L7frEBf/qbi7H635/Bpy+fA9NpjF85ox7T65N4vZMQLqrOXDirAZuPDuEPG9thWXbBQEpyjHl2O80l9v3gmf1YMb0Wb1/aguf39WLdvj4MZ3QMZ3V0p3OIK+SPfUtNAlNrk1g+rRbrDw3gkrmNeHBLF9oHMh7LC69gpVSZxTLrTkx7wkniG3QUr4QiIaGStDLao5XTgwlWRjNQk1QZGfrVy0fw/N5eHO7P4LNXzgXgFnSiADRySiBPFN6yeAqWttVi1TefZvHwSUUCQMiVbtqoVUzo2Rz+69ndeGl/HyxTx5Kxdah49E78QDmE2dubgZEpeO9IF5ZhAPjWBvzUcAhpDEAncKkCDOYbgLPW4MV0I57dP4hr33Yjlq5czXqjOjdtwEuDvfgASHE5rT7FSG6x4AhFEtFcnSi4PxWTkTc0z31BYOpTiILlV7JC9yMHD6clrx/Wl+NaBGOeOVjB5KgYlk3zKkdhrxlOsMp7zXKVrmIIImfeWO4TU7DUkPdQLCGRV2LpozGZRP9TVMRlNFTEPMcdV0Q2J84/38l/H///Cq4HazoX7kKPWxIEpjyFgV2bPtXn/atmkPfkXIuuNXLie4dSMUKwxrvvoOsvSL3ybCvzg4YDFCwu5IKGp0xkD1aENwZnFMGybdsQBOGTAB4DiWn/hW3bO07zYUWIcNrxt7/bAkEQ8MObzz3dh3JG4J8f2oF7NrRjyz9eiZoS9pPx4LtP7METO3vYHzVeHn/nj17C7u4RLJxShSd39jgBDO6vUL53CAAumdOAdy5twbHhHBa1VOGZPb349D2b8etXjiKnW/jVS0dQlZAxv6kSFTEZi1qqsfnoEGzbxn2bOrB8Wi0aK2OYO7kSY5qJzqEsWuuSBcc8MKYx1al/1CVbIzkDf7WMGALmTq7E/Zs68cl7NmFP9whkUcCK6XV4YV8fFjRXAQDWzJ+E9YcGsNohWJ/53RaWCAj4CFZMYgTLsIhFkBKsEa4HK6FIyOkW61/KhVkENRMttaThHiAhB4f7M5jZkMJHVxOlhy/0GrgVcUawevcCx3ei+tg+/Iv8CqYcWoqPS0fx4V0v40uxLuSeacUCoxrztO1Q4gYwCgztrsQoUpja0Q27vw7zhTia+g/C7s/hPVYWmfwkYOmt+J+DCRzoHsIoEjh7zc34xhMHcfU5M/C9d52Lbc8ewH/t2Y2rJi/2BE8sba3B83t72XuaWpvA83t7Pe+FR1jBRbdNKMH9LWH7Cfu5pLUWl8wdLWl9VSQxdEEnzN6kSGTorGZYgf04J0VipODimioAfislPY+lis1idrtyIQU8N2y48ETEtLPvQqCC5RIsfj+e/iAWLy967tMC1BJmEQxJEaQKlmWTmXH+bRJxqeS15if/ftCB3nKZCs2JgAZdjPcaZemWsshUfX//FYX7HReKLnTQ7XTTdQ2Us7ga1rMX4fTgjCJYAGDb9p8A/Ol0H0eECGcStnUMB8Yp/yXh+b29+M36o7jzvctKbrv5KAmPuPvlI/jU5XPY/S8f6MfP1x3Cj289F4okon0gg5gilq10Hewd88Qtj+aI7eXYcA67u0fw8UtnYc38SbjhzpfxsxcO4sJZDYjJIs5prUH7QBaqJGJGQwp7ekbQVp/EpMo4W9VdMZ0oXne/chgACZroTgN33kre7+Kp1Xh42zE8vrMHB3vH8LEbZgEA5jURK8ee7pFAgtU/pqG1LonBzDD6R90EvoQi4drFJJVw7mSSakeVMQC4fmkL0jkDa+ZPAgD81fJW9I9puPbsZnzp/tc95ApwUgRNN8yiB4TM6YYTaqBKUCQBNEcioYrMJkb3FaZg0blJtOfmzluXYWv7EC6a08D6Mvho8IakCAUGpgh9mL3vF8BLTwJdpA+tAsA7pDgqDj6JyxWgRzkLd41ejWtTY6gaOIQ/xa/D9pEUFBhYoHSjRejDc60fx3tu+ziu+PvH8TcXz8EHVk3Hkq89gS9cNh8fu3QWNv52Mx7o7AIALKmoQxZdSDiFZVhx+Kk1szGjIYWrzpoMAB5SGKx40EItuJcoyVvuihRQkihAFNzCjS4C0PTD6xY347rFzaHPZ8cjFyFYIYWcIols7hlvEQxTmcaDsAZ+VaKzkfzpgsHEy49idrtyEWzVC1GwxvE6oQETRYI5WMiFYcO2XUspz3Hotco/P66IsG1qEXTvV0MIqN8iCLi9c/zxlwq4IMfhnSvmx6KWavSPaaGK3kSAfk/811Ep8J8RPX9hCha/LbsdZBHkFCz6O7ec91xMFYvwxuOMI1gRIkTwwjAtHBvOhaUy/8Xgg3e9CsOykc7pqCoxi6SxMobd3SO466XD+MglM9kf5uf39eLJXT3YfHQILbUJvOWOdThvRh1+etvykq9v2zaO9GfQUpNAOqdjJGdgLE/+nd1SjUvmNuD2K+dBAHBWcxW+9+Q+fO/JfRAF4OUvXY72gQxaahNY2FKFzqEsGitinv03VycwpTqOruEc5jdVIqebmFKTwNULSQFO+02+9tBOVMRkVgRTcrTrWBpXOMU6j/5RDedMrcG2jmH0OXbBtYuacNm8SaxomDOp0G/fVBXHg59Yxf5fl1Lx5WsXAACuWtiElpoE7nzuAAASXqFxChav3GmmhZzmzNHhCsG4o2ABRGUDiIL16uEB6KaFC2c1sG1poMaHLpqBKxZMxrymSixrrQKyg8C+9cChZ/GprlewVhGxStiJ2rtHsI/WclsBNC8Brv46MGM1cslmLPr6y/jA2XHc9/oA/vbKFfjGQzuRWLoQD27pgiIJeGVoAAAQE0RUxGSsrWuCKCuQRQE/fGY/vv/UPgBgIRd8OAl972wOli+dj0KWRLx9qZuY2FDJxZaXsAjyoMVuMoCwhIEnR7MnVeBHt5yLy+ZNKvqcgn1IYuD8J/6Ygo6VpkjGA2Zpjbd45UGfW6DwhRwLU7BKvGa5A4mLIbgHi7cFikW3DUOYLbLoHCzR7cGybG+SJH19+jzJYxGUAi2C9DyGzR/jfxc0VSV82wglAy4oYrIYqmC978LpeN+F0/HLF0mi5qmwCNIwnRMJuQDI+bFKEiyy+MHP3SsVcqGPI+Si3NEEEd4YRAQrQoQzHN3pHEzLZulsf6mor1DRk87j2FAOVU3FCVb/qAZVFtE/pmHdvj5GPGji3dO7j2PDoX4MZ3Xs7x0ttisAQDqnI5M3kdVN/PXqmbjlvGlY8rXHMZo3MJo3sHpuIz539Ty2/f0fvxA7utLY1zOCL97/Op7f24ujAxm01iVx+5Vz8e7lrYG2mGXT69C1tQvLp9fic1fNg8oN5qQEq2s4i69cu4ApDpVxBQuaq/AfT+6FZlr47FXucWQ1csxTa0lh0zdCiMw7lrbgqoVNbLuWmgSSKiE8oiigdyRfkGjI4473LAUA3HbBNDy1qwe/Xn+UWARNahF0/3TopoWMRkIq+OKX9mABwFh6ELdKT+CtB7tg7Egja6eA85cBsSqgpg2r9ddw/bEuxP+nC/PGeoFMHyFXzgo8JBWVyjQsEQfxqrAYl6y6BHc8cwBpJHHDTR/COWcvZq+rWjYAAZ1mDdLIs5AMw7RhmBYqYm7BlzcsqLLlsZNlOZWNqsb8uUr55mDRn/ESscf1KZdgFRsuGmYRjJVpEaSP020EQcC1Z5dWrPyIlaFgBfdgOUWmJ+SCkpiTULBCEtLojKQwC1vJcxVCIMYDvyIpi4Ln+88/Pp7id9m0Wlw2r5F9v919hAdz8BZBnmDR4p8nMbKPYOWLWQRDCBb/u6DZp2CpslhyyDC/bamB6uMNSxkPgsJ0ygFPguk5DrMIepSrItcnI1imFWjbDAOzHUYWwTMCEcGKEIj2gQyOj+QKGo0jvPFoHyBR2iM53RN0sP5gP5qq45hW720sPp7OQRIF1PsUlDMdjZUxQrCGs8wWF4b+sTyuXdSEx3f24Nm9xxnBOu4QrF+sOwTNtDCrMYX2gSxMJykuCBnNwOKvPo5zWmsAANPrU5BEARUxGb2jeVg2CgaNxhUJy6bV4ty2Gnznib14bm8v2gczWDy1GlNrk5haW2jlA4BlbTV4aGsXzm2rLegdq4or+Na7FqO1LokLZtV7HvvvD67AF+7dhp8+fxCfWjOH/QHudxQrWoDR/1NyRiGKAt517lRMqUlge+cwHnn9GCZXlb4+ptQk8N4LpuPeTZ1kNdUoJFiWTWKe6ftRYODt0jpUP/QbXNexFZfHhpDcbiKhZDA80oBBuwIzrTTw3JNsH98VAb03BkxdCjTOBZIXAqlGINUA1M8G2i7ADx4+gHs2HEVLTQLrLr8MP3n6zzAsGzfUeEd10AQ8FnIRc1MEddMusNpkNJNdG4okgHdGUoLVxKWjpWIyVElk6tYVZ03G165fiLYA+yaP+oriFsEwyxAjWE4SnG7aJfsxYkUCKsqFyg14DXqMPzb/sQLwDZ09eWsXPWdhSkrhAOIyLYITqGCpTg9aQZ8YrwiN43VmNlbglx9YWXB/eXOwLJgWR7AcdYr/XPw9WFQtSQaQ47B4fD7Agk8RBIAvr12A5hovOQzDyul1OGdqddFtJqJfLgxUiRtvmiRT+GQRhjPIPBGy2EK+w+72QPB7CZ6DFSlYbzZEBCtCIO54eh+e3HUcr/39FdG07yKwLBvbu4axeGpN2c95+UA/lk+vLfuXYIeTTkcL2UrHPnf777dixfRafO+mpZ7tV379KSiSgH3/em3Zx3QmgA6/PDacK7qdbdsYGNPQVJ3AhbMa8OyeXti2DUEQmIKlmRZWTq/D9Uun4Ct/3I7uNIlND8JghlTUW52hwNMdwloRk9HtHAtvg+EhCAIumdOIB7Z0wrRsLC5RIFyzqBkvHejHpSF2rXevaA28f1JlHDeuaMMze3qxrWMIy53ZPLTnqrk6AVFw/58IWEH9l7cvAgD8Zv1RPLqjO5QEBiEmiawHSxDcAkyVRWiGheGMhsuUXVg+8hS+HnsVU4U+2N1TMVJ3Np4ezmNKSsV3Bi9C65wLsad7BDndwoufvxTIDUEfOIK3/PAVXH/ZRfj4VWeHHgM/OFcQBKZ4BkWJ83HxdGXatEmSoH/127RsT6M6D/q58wpWUpVw78cuwMxGYt2sTii47YLpJc9hA0ewgoolRghCFCzFSVHTTbM8BeskE0dVbsBr0P6BcLIDuN9n/v6TiULnAwKC7veftzBrmx8TmSKYUCVoWSvA0scpWBOgvhSfg0XuI0qi01MliTCFAAWL78GSRZy3YDLuvHWZZ9GOKXwFw44Le7D8BGvtOJTTcmzcxYjlyYK+D2mcnw8/J0wUyG3iwZBKAAAgAElEQVT/AhfbVnLj2Yv1JbIeLNOCZlDbZunvztkt1Th/Zl1BmmOE04OIYEUIRP+ohoEx8u/NpoS8kXhuXy8+8MtX8eznLsX0hhR2d6eRzhpYOSNY+WsfyOA9//UKfnjzuWU1mgNAx2CW3U7nXII1phnoGvKSEdpkywc1nEps6xjCtPrUhARwUK/+saFs0e1G8gZ000ZDhYqW2kY8uasHB/vGMKuxAr0jeayaXY/+UQ3/fP1C1vtzpG+MEayXDvShYyCLZdNrMauxgs0bAkjRQBu1UxzBqoyH/6q8ZG4D7tvUgSsWTGKpfWFoqo6XVUgEgV5T6w8NMIJF319dhYqkKrMUwWSRWOQbV7TivJl1aKws/3tdIRtAdghSFlgjb8OVgy9gunQcl8uvQxQ1NGbSmJwZwJhYiY3WDPwTPoKff+YLOHigH1/etx5nxaqw006jUbeYrRGiCCTrkJeqsMfughwvTvj8RXp9iiieYSlcI76wBdOyoVuF6gK/Tzrk+DNXzMHkqjgjzLyCpUgizppSVfa5o+AtgkHHHLb6zKeNUYWtVLFVLGK9XHx6zZxQy1bYQFOVOy6aTgm47+FkSB+zcYZZAUOUv9Ix7ZTYnryClVAkDGf1QmVPDCY1Jwo5RFXiX4sfCq5KIgyhUMHy92DFFQnXLHKtxUB4j1uQRbCpujy16kTByMwEDxoG3PcxXnVMEd3zIwilQy4oOSzag8WFXLx2hPSLlhPU1FqXxG8/esG4jj/CqUNEsCIEgqZ+HegdK0qwHtl2DC21CSxpLV/BOROx4dAA2uqSnkKqHAw4igE9X99/ch8O9I7i8b9dHbj9YMa7vR+fvmcz5k6uwCfXuMl4/HwlEoFN/ohlNRPdvoGx/WMaJgLrD/YDAM6bWR+6jWZYuOHOl/E3l8/BJy6bfdKvSckhr2ANjmkYzRue9Dyq0tSlVKycUQdBAH79ylF85boFGBjLY1lbK253+pTanej0w/0ZtNQSkvXBu15FTrewoLkKf/6bi1ncOED+QNE/gBUxGTu6htntMFyzqAl/f90C3LiiNXBO1UShLqVi7uQKrD80gE9cRu6jn3d9SkVCldDnnJtUyAoqQIqqWY76UgDLAoaOAD3bge7t5GfPdvxi8LDzgiADNHoAKMAOcS6OmbXYY7ZCmnYenktciT++3k/sc4LAehHodZ/TTWS4uVj0PgBl91/Qn9RyF2SXUyWXYHl7sOxAFYWuWlOCNb+pEtcschdAJlXyasyJfcbVCYUNXg1MEQxIdiOv5xKLMOXIj0mVMUwqwwJaDEGBKhTzmyoxv6myIASDHl9DhepJjysWK14uXCIUbFUrJADl9X258e8nT/7owkbY3Cr/7ZN9vaB9UYss6cFylBVRgOJs6u3BCrZ08gidgyW7vycpiv2enAiwoJNToGBVnGBMO/+dFARCaostTKi+73AQwaKfYd9oHg9u6cIVCyZh9qSQ39kRzlhEBCtCIFyCNRqqxgDAPzy4HQunVOHuD533Rh3aKcGH7noVN61sxVeuO2tcz6MN8bT5fzRvYCzvjaL+67s3ork6ga++bSEr4LIhcdXP7jnO5ghRdAxmIQrEIkiDLmzbRt6w0J3OMXscABzuGxvX8QfBtm3c/vutqEkqeOTTF4du15POEXtYVsfgmIaekRzmTa7EEzt7cNGchlCbxD8+uB2/Xn8UB77utTBS1Y0nWP/yyE68uL8PL35hDfvDRwfr1lfEMLU2iZtWtOFXLx/G5QsmwbK9Q2in1CSgSAL+48m9+PsH8rjrAyuR0y1Mr09id3caw1ndo2BNq3eJXEVMZsdUrHCIyRI+fPHM0McnEufNqMf9mzqgmxa+eN/rnnORVCVmkQyyCHqQHwUGDwPZAaBvn0OkdpB/Gg0FEYD6WUDzEjwkXIqDmThm1al4ujuOSYsux282HMWUpibs7h4BAHykeQYEh/D5AyD6xziClSdWQ8O0IEuiS7BCEusoWIEt0yKeEIigpDtVFjHoLD4kVLK9advsNf3wEx5/HH7Q4NXxQhQF1KVU9I7kA5WccNudawcrplzw+Nn7VpySPhWKaxY1ewgoBT23fgLv2vBOIkUwRKnyF6wF25cMuTj5vh6qBNHCulhv2oRaBEP2lVAkZDQTOd1kvZGCQIr2mKcHi1ewittB/e9pSnUccUX0LD6cakzEdRSG1AnGtMsSOa+iKEABOT76O8cPomB57chh150qi/j1+qOwbeD2K+cFbhPhzEZEsCIEghKsg0US2DKagYExDds6hj1F/qmAblr4hwe24/2rpmN+0/jtOcWQ0QyMOGlx4wUtDvPOANW8bnlm/bQPZPDYjh40VKj4p7eehQwbuFpIsEbzBtI58o9H52AWsxorsO/4KNLO50LTnjTDwmBGZ6vFh/uJYlPOUMIwbO0YRudQFsNZvejnStWzrGbi9t9vwTN7evHjW87Fx369Cd9459l4z8q2wOf96uUj7Hk8EaDNvMeGXYvggd4x9KTzeOXgAC6aQ2K9qUpT77znv7t6Hh7e2oV/fWQXAHji0SVRQGttEgcd4vm7je0AgBtXtOHfHt2NLe1DyDqfyccvnYXLF7i9Ubz1xR9ycbqwckYd7n7lCB7c0oX7NnUAIJ91SpU8tpQCi+BwB7Dxl0DHBqBvPzDS5X08Xg1MXgQsuQWYvBBoWgQ0LgBUQjSe+u1mbDo6hPPr6vBSXx/eFq9GGinM485LUpVdW55zLPQ4qF1pLO/O0sroJqokkQ0fDuv3oeDnYAHu5x+oYMluml1MlhzlyIJh2U5/4lo8u6cXH/nVRgCF0dlB88bYcZzEd6uhIobekRBbY0jxyBOvMJucH6d7Zp5/tZ2SopNKEQxJkHP3HawaqSWKcTlkv+MBfa2EGkawyOOigAlRucOGLlPUV6joH9OQ1Uz2PaHHxStY/IDkcAUrmICumT8JG75yRcmRGhMJuQSxPBnQ3/fjJW8qlwwoigIkUQi1CNanVPQ7n0epBQBVFpHRTDRUxE7Ikhzh9OPMqBoinHHgLYJh6HR6g4azOo70Z05pY+WmI4P47avtqE4q+NLaKliWjaGsSyx++Mx+CALw8UvHb1WjljNKksYDanXSTPIzZ5gedeqBzZ0ACCk40DvK1K0ggkV7j9KcfTBvmDg2nMXbzplCCFaucGBr93COnYcj/eTz8s9gGg/+/PoxAITwFevBo0pTVjeZQvH5+7YBKK6kUZvUob4xzx8Ol2C5qlynY4/83pN78e+P78G3b1jM+o6oRawupeKCWfV4fGcPABT0FrXVuwTriR09EATghmVT8e+P7cZrRwZZ+tuNK1o9zd3UMgIAlbEzY8jzeY6a/KNn9rP76lMqBEFgZEaAhcRoO3BkH9C3F2h/Bdj9JwA2mRc14xKgYTZQN4uk9NXOAKqnotigtZgssTlYvM2FJ6FJ1Z2DFfcpWBQDGdfCmtVMVMWVsi2CfvVm9qQKVMXlwGKGJzAxhQwxNSwbhpMmqUiiR5X0K1jFisaT6f+gQRdBRVzYOeMtcKcyRW0icHSAfM/8BIvZoU7i3IWpd2zQcMH95SlYE5kiGGYRFARSeEsTtAgpl7DK1VfE0DeSR94wPemViiT4UgT5kIvxWQQFQXhDyRUQvggxEWApguNcBJAlwbPI8/4Lp2PN/GB77ZevW4C8QX7fFevB4u9vqzu1fW0RTh0ighWhADndZArJgSIKVgcXRrC1Y+iUEqwX9vUBAHZ0pgEA927qwD8+uB0vfmEN6iti+MPGdhwbzuGWldNQnRzfL/0+Jxggb4yfYOUMr4KV0wnBogThj1s6Ma0+iSP9Gbx8cICtpmY1E//90mGkszo+dTnpt+pyCEuaswi2D2Rg2cDiqTV4YEsXI188ietOZ1GTVPD5e7dhJO9aCE8Uj+7oRkqVMKaZONyfCSVY3Y7SlNVNTKtPYVvHMFMwjg5kAp8DAG11SRzqG8OB3lEfwSLHnNFMpLMGVFlE36gGSRSw8cggAOAXLx5GixNCwfd4rJhexwiW37Jy4ax6DGZIxP3rncNoq0uisTKGBc1V2HRkkK3wpnw2QF61OlMUrElVccysT6Cnrw81soS55gG8XdwP3PUf+EXfdgyoMTQLAxDv4HrxKiYDF34SWPFhoCZYVSwFVXZTBFWuF8hPsGjhQwtNv1VxkOsRpNZMWnCUIlhucUV+/tXyVqw9uzlQweJX6WOyBFkUYFk2dNOdecVbosY3/PXEV8/rfavXPBorY/jJe5dh1ewGz/2eFMEye7BOF6gt2J+qWqqYLAfMClgQZhFMvKh1tJSaT9WQiYiQp9dwkBomO+rGREApQVgbKlQc6huDZlg4u7bG87zQHqwQW1t9RQyVMbnoefzCNfOLthJMFCaiXy4MFSdoEeRnWwHAP7wlvM2AKMukPnHDa0Isgs4+/WNYIrx5cGZUDRHOKFD1qqFCRftABnnDDOxzoOl2ogBsaR/C9UtaTuj1fvXyYWw4NIBVsxtCbWUv7HcIVhexI244NICcbmHjkUFcsWAyOoey0E0b927qwIcumjGu12cKlhHcF1UMWc2x6jnqCyFXhKzZNnCwdwyfu2oufr3+KNYf7Me5bbVsu0e3d2NgTMOnLp+DrqEsp2C5FsGDjoJ4TitJM6P2wRyntnUP5/H07v1Y55wj/ngofvbCQSxqqcb5RUIryH5NHOnP4O1LpuCBLV04OjCGZdNqA7ftHibENKeZTPwQBaClNoEj/eEEq6UmwQgWD/6YO4eyrJD62OpZ6B/Lo39Uw0Nbu/CWxc2ojMmea3LZdPcY/QrWRy+ZhY9eMgv/+OB2vN45jLmTyYytc9tqcf+mDjZzyt9nxZOHVKx48T+h0LPAwCHgyIvA/qdIn1QuDeTTQC6Np7URgLaZyYCVFYD8YmxPnYehoSG8JK3ArW+5AmiYBzTOA5InX/jEnDh2zbChSO4A2kruHCVUmRUFlFj5SZNhucSf9iPSazleqhD2WQQlUQi1wqkegiVCEoiCZVruHKyglfxffXAlxBCVYfHUamzrGD6p1XO6WBFGkK5e2FRwn9t7JrDjPFPn3Hz2qrlYNbu+4HfGRPTOMKUpJOTCf06rkwq+dcNirJkfPBLBPbbg/Y4H/BwsWRRCe+wmKgPHVd3CSdHGw4PQTKvAIui57p39CEL4NXnj8lZcsWBS0WvuY5fOGvd7OBG418Cp68EaL3lTZS9pLft5kojqhBKa5kovx2J25QhnNiKCdZrwncf3wLaBz1195jUvUoK1cEo1ntvbi+PpfOCXvHMwC0UScM7UGmxyFIYwUEVnYExD3jDR7MS5WpaN7zy+FzndxMPbyPDTKTUJWBYwZ3IFFEnEcEbH6x1DaKqKozudQ9dwDts7SbrbxsMDWNRSDd20IQjAb9YfwQdXTR9XPxgdzlqugvWBX27AjStacc2iZqYkuQqWq2TRYrIqoWDljDpsODSA+c4A3ZxuIaORvq9NRwfxzh+9hNVzGwEQ8kWtWIf7qeWmEklVYgEYvEXw9c4h3LepE5OrSGy1/73Yto1vPbYHF86qL0mwepy+qhUz6vDg1q6iRKk77SpYggAsm1aLH9y8FHc+ewD3b+oM7d+iPQgHffZTw7QwpTpOPt+uYWZzvGx+I5ZNI+fv8Z09+O2r7Z4wCgBYNKWaDFeVxVAl5OwWQlLnTib2pba6JMY0Ez3OYGb/H0lKHlRJDFxgOCGYOpDuBIaOuv96dwM9O4HR44AAIDfsbl83C6huIWET8WogVoVdg8Afdwxh7cJJmDpnCay2CzF5chP+8NvNeLC3C1MrErh12ZqJOV4HMUVE3rA4BYt8hqUsgtTWFjQ2wCVYJ2YRLIYCgiURBcswbZYY6C00yX2XON/BINz1gZV49fAAG5NwIqB2rfEQJL4Hi5GJk5xxdaqQVOVAe9REDEBtqopDFFCQ9FrMNvbu5cXHJpDnTQD541L9FEkMVEFkaeIsgqVUt4aUioGMBtuGh2CdO60GZ7e4rgEWziFLoX8zVVlkf69PN9hnfQoIVsUJ9mB9cNUMXHVW4cJIKYiigKc+uzp0kYgGFpUaYB7hzEVEsE4T7nia9FDMnlSBty89MeXnVIESLFrEDmd1NJkWZFHw/BLuHMpiSk0CV5w1Gd/8825s7xzGwilVnm0sy8ZPnj+IHz2zH99812L89IWDGMnpeOr21RAEAYf6xzCc1fEvb1+Eu18+jA/990ZQd9tHLp6BT66Zg8/8bjMsG/joJTPxtYd3YtORQew7TtSPjUcG2R/0a89uxiPbjmHnsTQWTgke+Jo3TPy/h3dhfnMlbjlvGgA3NCGoL8qPjGbgmT29mD2pAtcsanZDLkyXWAGEdOjOgMCUKmNKTQJ9o3mMcj1YGc1EOqezXrbn9vay1xnJ6aiviOFQ3xjqUyqqEwqq4gpTt/hj/f3GDti2jf/50Hn43pP7cHQgg709I+zxdNaAZljYeHgwNEWNgs59mlaXQnNVHEc5gvXEzh601CSYrY/vwQLIH6jm6gTa6lMYyRue8A0eukP+9h8fxQv7erFyRh1isgTdtDG3qRKjeQObjw7hrGZCRulA3BXTa3HJ3EY8v7e3IKlRlUUsbathamQQlk2rhSAA5zgjBWocK2n7QAYptbDAoOThhO2BuTRw+AVHjXoJ6N5GyJXNEXlBBGqmkVCJWWsA2ECqEaibSUInJs0v2G1LTkc6tgttV8/z2DepPavYDKwThSpJMCwbOd1EjLMZpTwKlkuw+D6ihCJBNwsDZMY0rxpbbshFOUU6JcQxZyix7PRg6ZbFitJESC9KGOpSaqDCNB5cMLMeK2fUoTZVPklTJRHT6pOY2ZjCi45KfaYqWGEIGxI8HsyZXIkt/3RVQd/PydoPwyyG4wElKqS/TwjclyyKmKiPLUzNo2iojLG/o3VcD9aPblnm2U4JsMueyRjPIst4QV0K4w3QWNRSjUUtxQfMh6GhSK80/b0YEaw3LyKCdZrQUpNA51AW//bo7jOOYA1lCMGiX+zhrI7FX30cV5w1GXe8ZynbrmMwg5aaBN6zsg0/eHo/Pn3PZvSO5PGT25bhwlmkj+D+zZ34t0d3I6VK+Py9WzHmrFrv6RnB/KYqbDk6BIA07y+fVosfP3sAF81pwP2bOvDQ1mMYyRl4YV8f/uX6hbhhWSv+3yM7cd+mDpiWjRkNKWzvHMa+405M9MUz8ej2bvzp9WOMYHUOZZHJG5gzuRJH+zP4/H1b8cpBMvOKEizXIlhawepnZMxLqPI+JSurmWybVExCVVyBbtosVjvrECySHFg4EyudM1BfEcPB3jHMcHrbKuMyF3LhHqtp2bj1/DbMmVyJH95yLr77+B5s73KTHY+PECI0mjew81gaU2uT+Oafd+Fvr5xbsDJJkwGbqmNoq08yBW0oo+ETv96Eqxc1sWuAkjEa9EEVJ3rdHB3IBBMsh4zuPJbGe3++AXfeei6uWdQM3bSgSiKWtNVi89FBVMWJ5YzuVxAE/Px9y/Gdx/diam3hiur/e/siRmCDMLOxAs997jK0Ok3D9Ng6BrOBMeyMYBWb7ZIZALo2AZlBYuXLDLDZURjuBCzns61uA9ouAGqnkz4o+q+qBZALz1ExVMUVfPNdiwvud/ueJv7XOiU/ozkDtSmFFTh8EEhKlVmim4dgqVJBMibgXjesB6vcmPZyFCxnG0oERYHMBbJtnHQP1slgaVstfv/X4xsEKooCnvu7ywAA92wgKZhnag9WGFRmczy54w4KVSh3NlgYmPp0MgEc1LopEpUx2CIohNpPx/16pVIEuaHW/G0//PHyZzqaqxOYPakC8xwnyETiRBWsU42IYL15ERGs0wRaZKZDBs6eTlAFi36xj4/kkNVNPLS1C1+5dgGzaHQOZrF6biOqEwpuOb8NP3nuIFRZxDf+tBs3rmhFY2UMj2zrwtTaBL75zsW49efr0VgZQ99oHo9u78b8pipsbh9EZUzG7MYKiKKA/3SKd1US8ZnfbcHvNrbjphVteO8F0wEAS1pr8OweovTcdsE0/PNDO/Hgli5IooCFU6pwwcx6/O/WLtQkVCxtq8EnfrMJmbyJf75+Ib54/+uQRYGpIO0DGbTWJV2LYBkpgjTBLsspVQDpHzIt29OLRQvIpCozGwBVfXK6iTHNgG0DPdzcp6RK5pc8tqMb92/qQE86j6ucgZ9VCQVdwznc/coRTHE+g5aaBNJZHZ+5Yi7bhyqLsG0SGqHKAo47VgMAWH9wANtjafx+Ywde70zj3v/vAo8KQUlTU3UC0+tTeHIXCY54cEsXNNNCvxMIYlo2229ON2HD7bvhCVbQAGrd1x9G1SjdtKDIIhY0V+GOp/dhclUcLbUJT6yxIon44tpCVQcgNspSaOOshbUcwQoibJVBBGvgILDrIWLna98AdG70KlIAIVEty4CF7wRmXwE0zid9UKdwjAHgEqzUKVGwSEE3MKahpTbBVIMKLl0xqUps9ZcPt6BkSxAAPnuFhlywHqyyBw2XPo/0+GIsdEBgCyhyUA/WGVZUhYHvx3ozobUuCVUS0VQ1vkHu5SBsQHO5mAhVhClYb5hFsHiaZAOnWvEpgkHHBLx5CFZ1QsGTt68+JfuuiMlorIwxx8SZgjdyzliEiUVEsE4T/ANqzyQwguUUo4f7XJvYnc8dwFffthB5w8TxkTxanML0s1fOw1vOnoJd3Wl8/t5teL1zGElVgmHaeN+F03DRnAZ8es1sLGmrwY+fPYBHt3fjM1fMxZb2ISxurS6YDXL5gklQJRGaaeEDq6az+791wzm4/gfrIIkC/mp5K7716B68dmQQU2sTUCQRbz2nGV+473X865/ITCRVFiEAuP33WzF3cgV+9cHzkM7puGpvL14+2E8IVpGQi0e3H8PkqjiWOuEUA2NeOyFbhffNv8pqJlPrUjEZVQnyVeNtdbQHpXPIJVhz/n/27jxO0rq69/jn1FNrb9Pds68ww8wAg8g27MgqCKKgxgU1EZeEGDHRq9FoNJdEr1FzvUGNmoQoNy7XABKjuAuIKyKL7AyEYZthFmZfeqv1d/94lnqq9+mumq7u+b5fr3lN9VNVXU/309PzO3XO75z57Ty4cQ+3r3uB/37BL4MMuzN2ZJPc8cR2Hty4hz89ewUAH3/VMSyclaspNQgXHOF+mWj4bMrjrqd30pFLkU0lWLdlHzff9zxXnlH9/m7ZO0BbJklbJsnS7hZ29BQYKJa58Z6NNV//jp485YojYf7XUnHVBX4UYAXln49t3hc1kvDPy3HO6rm88ZRlvPMb90X/BoplR9pLcOJhXVQc/Gb9jprn1VtXMICzv1ge0kEQoDWdYLlt4fXlX8APvgNbH/FbngMkszDvaDj7g7D8JX6nvly3v0/Km5pfq2FQ04gSwTCDtW3/ALNb57JmUQdHLWjn8FjA6pcIDl2whRm1jmwq+t0Cw+3Bql+JYBRgBX97nkWvE2YbauYBNWCuTiNEc7CmWQbrmEWzWPfxixuSKZzfkaU17U2429rCWTmSCRs1EBlLvPnC4K5yoVQiUbf3WJJj/FuIlw4PV0UQ8ob5t3CoSnoJ7vzQ+Q3Z3zUZ9ZibJlNDAdYUCbMlxbKjUnFN9Y8oXASF7+SEs5UA7t/gN7N4JGiXvirIGqSTCY5dMoujF7Zz9zO7WNKV44t3rKdYdlz8In/fwvsu8ht6bNzVzzW3PMpN927k8S37eec5QzsQtWdTvObExezPl6Kub+DvWbv+rSezvSdPWybJRcfM57sPbI4W9a89yZ9lNK89w/W/eYbTV8xhZ2+ef/3F0/zbW9ayYFaW+R0Z5rSl+e1TO3n92qWjtml/5zd+D8Czn7oUIJr3NLhEsFAeFGAVy9E79K0Zr5rBCjoF7h8oRcNXN+/pJ5vy/1M+bUU3D27cw+Nb9kfv+IeNMeJBwO5gntDyOW1RCWEozDYUShXIEJUIvvK4hXzn/s105FKcu3oeP350a1QOGnph3wDzO/z/nMN3m+/fsIfHtuwj5Vn09YfNL5Z2t7C7199MHc3xSXvMbc+wYVcfX73zWT53+5M8/LcXRXuEiuUKbZlk1NY3/D4Ug31+JyzrpD2bxDm4cM3w80TqobuluvBozXjQuxOe+QVs+C08fw/HbnucOzL9sA94uNOfFXXBNfDiN/iNJ5pMS6pxJYLhz1TF+Qu2oxZ08OP3ns26Lfuqr5/2otKo2j1Y/rGulhECrHG2aT+gEsHBAZbFM1j+MTMjm/IHHTfbomok9dgvNFUaVYbZ3Zrm0Y9dPOHnn7K8m3s/+lI6WyYeYIVfWzKRYNW8NlbMHRrsJetaIjjGHqxYsDhnlBLB1DANXw5lzfTv6pZ3nxn9jpTpSQHWFCiV/W5cYTlYoVwhm2ieX3D7+ou0Z5O0Bu9IPxMspue1Z6IF0q+e3I4ZnLmyNsOQ9BJ85nXHAVAqO37y6FZOWFrbsvcNJy/lul8+zQdvfoi2TJI3njp8a/bh9pkAnBrrhPfqExbXBFhewqJOef/rVcdGj/uj0w6LmhiYGWccMYc7ntjGnr5CLGiq/WU2uJQNiPZQhdmuMNAqlCoMxAK0/kIswEonyWf9+8KsVnwe0Oa9/cxrz/Lj976EPX1F/vUXT7M/X+K4pZ18+g+OZXUQxD74/J7oOWFWarh3/cOyqDBw2bYvTy7l8fazlnPLvU9xTt/PeWf/Zl6d3krquVNg77vY4c3h+w9uZvOefn9f1t5NrM4/wim2jqcfTTCfXSydv5AHtuZxznHnUzsw82dM3Xzf8zUZLPCzWBt29VEs+62xt+/Pc9jsaoCV8qpd+8LvZVgi2JFNcd9HLyTl2QF1gxw352D7E7RvW8cV3m9op5cz9vXCtT+FUj+kWmHJSfS/+I/42O8cbUeew9+85ZX1P486i5pcNGCxlIl9zu5BbZ+j108lq00uYjN1wsxaZ0saYk1T+gY3uRhnm/bxlMdV92D5r+0lLHpTK15Wlcw4vIUAACAASURBVE15DBQrB20P1mSFC+rptger2U0muILaLoJfeevJwz4m5dUvg7WkM0fKMxZ1Dl9yOSuXit40CKsnhuNFGWf9PDWbwbPkZPpRgDUFwoV4Zy5FX6FMvlhpqneQ9vQV6GxJRZPawwzW4bNbWR/MLvrVkzt48ZLOUf9jev9Fq3n/RauHLJKzKY8PXnwk77nhAT566dEs7px4C9izVs7hrJVzOPfIkdsrA0PO4U/PWcEPH97C397yaFT2Fs9g5UvlKIiJGxyMRW3aS+UhGay+WIlgfP4PVDNQAFv2DLB6QRst6WTNHpXFnVmOWlBtqXv1uSv50LcfBmB7T7Xsb7CaDBawbX+eeR0ZjrKN3Nb6NywpP09p12zSiTSHbbwbrv0iyfQCXpnv4aVk6EwW4dq9HAvclAF+D2/OArsgn0rhPtPF6wZS/EFLgpb1Kd7qFXAYcx7KwtNZMPjsXr9jYmpbgjeljfbvrYZjzoOjL6NYqtTMUqpmsFxsmOgk/sOvVKBvp9+xb/8W2LcZel6A/j3+fqmnfga7niIBfCrYQlTe58Gxr4FT/hQWHQ9eCpcvceOdP+HN7RMbznuw5UYY7lsP8QV9PMCKH8+lveocrJoMlv/fTFfQtdHMvz/ce5cvlqNuf6OJyuPGUc6XifZgBRmshEWZsngw5TfWKE6fDFbUMW96nO+hoprBGvm6JD2/XL0eVs1v5/GPXzLiGwNmfsmjc0P/76s5p8TQpjQiUh8KsKZAuG8nbFrgv4M/8dkq9ba3vxiVtM3KpXh6RxBgzWnh9xt2s7e/yAMb9/CuMYYLjvaL/fLjF3PK8u5Jz9dIegm+8cenHvDzjlk0i3edt5LP3/4k4P8HEwZYj2zay6u/9Bs+EcuAhXYN6iIY7aUrVaLr6t/vdwiE4ffExOOtQrlCe9AsoCXt4SWMcsWxaND35opTlnHRMQs48eO3smO/fx7DBebpQZmhHft6eXnq9/CVa5mbyvKZ7r/nf7zzz3jDp+/gNYf188HFj7DtsQe4e3OBnBVYOXsOx514KvnOlbzta79nXnKAbHkfV7yojbsefYrXLW7l/nXPsmpeK8UEPL1/HwbkWlqZ09kCzlHM72dLbw9pZ3guT+6Fe+HZ78OP/oqbKrNp/W9IftbjV5kie9edAovfwqLyFg7r3wvPD/jzoDB/NV4pQ6EXin3+3+Htgb3QuwN6t/l/F3r8IGr/FigPbtdukO2AcgmWngKnXw1LT+WKr6/j4Z3Ga049ko+/uvZ6t6Q8Esak5h4dTFGTiwYMRY63UO+KBVjVBgFGOpkYdtN8TQYL/99aWyZJf7E6cmA8bzCFg6cnVCKYSFQzWLEALXzn/kCHi06VVMIwO3hdD2V8kuMIsMJrVy9j/QzMbs1QcUPnz8WF59tMb/CKzBQKsKZAmOkIg5jxDrg9WOIBVkdsCN5hs1spVRy/fnIH5YqLWrFP1FQPL3zPBavYvKefm+97npXz2nh4015K5QrP7uylWHb84OEtQO2gxsFNLgaiVtOVmiYZ/YUyfYVSNMB2rP8MwzIOP2uYZHdfkUXDZPbCxXPY+XC4sqpwcVnZvQEe/Q7/suVLdNAD844h8+Zv8ZfB/qGWtMfGxGI49xXc6tbzvzc8AcDHT3wRx512GBngsazjzr4i89ozXHLScXzqwbvZ0bGcLxef4VuvPJ3Ht+zjb777KACfPPlYDjvFz/bcf9/zvP9bD0Kw5eZjL1nDW47oh4du5IHf3MuS9g66DuvmkfvWc96uX8B//IAfJYB1wZ/xynX5c6Na50L7Qpiz2m993rGo+qd9IbTOG7b5RLl9H707d9M6TBCVSBjXvuH4ISWuzara5KIBbdrjGayWoSWC4Tvg1RLB6oItLFkM5461pJO0pP0M1gv7BhgoVsZVojSZEsFkwqKSxOSgEsHw/ukgHGTbkNJZmbDqHKyRf47PO2rewTqd4PXmMlYPraT2YIk0jAKsKdDsAda+gRLzgwYH4Tm2Z5JRoBEOsY23vJ6OvITxmdcdx1Vnr+D2ddt4eNNe8qUKfUHp0l1P7wRqhwFGJYKlQW3aS5Wa2VT9xQq9+TItwQDblGe0pr1oD9Zg8SxJRy41YoCVSXqkkwkKpcrQsqpKGdbdwmk/u5ZHMk/QdoPf3OIedzK7VlzG6974DkhXN19nU16sC2I5+lqPW1IdmrigI8ueviJLunLR9f/ZE9tIecbxSzt5dke1AUo8U3fYoJ+NHT0FmL8GLvw7PvDLH/NHKw/j+JcfzYce+CmvPXYeHz1mB3/5f2/lrOOO5NUnLA76eTv/74Tnn3eqBdJtkG7xP063gTe57FKYVWkbIetz+fHN18xiJGFg1Yhyn3gGa7gSwfC1hy0RDH4uwq6NLWmPlnSSXz65ne99cjPHLp41rgXegew/GpzBSiQs+vdZUyKY8oYca2ZJL1ET7EpziDJYo5RuXn3eyoN1OgB84GXDj7OI0x4skcZRgDUF+ocEWM3VKaa/UI4WReE5dramomzWM8GievYo7V+nk9Xz26NgKl7aFwa+8cXlrlgXwWK5Eu2typeG7yIYn6HUkUvRWyhHAVJcfIBmeHukvWkd2SQ7egrVRWmpAPd/He78J9j9DOn2w/lm+TxWrFjJNU+uYIObzweWHVkTXIG/8I0GJQcB270ffWnNYxbOyvL41v0s6WqJFtZPb+/lqAXtpLxETaYivkgePBwx3DMG1SYX4C+E+yoepRXn85+VPMvnrobVq4b9uhshzMYM16Z9umlpYJv2tDdCk4sgmxS+Zphliv8shLe7WqplsK0ZL+pg+fjW/SwfR4vtCZUIDjMHK/78qERwmgRYRy1o5+nFHWM/UA4qrw7DiqdCdWSBMlgi9dawty3M7H+b2eNm9pCZ/ZeZdcbu+7CZrTezJ8zsZbHjFwfH1pvZhxp1blMtfCc1LJkZvNiean2FUrRgCgOs7pZ0dPuZHb20pr0ZVVZQ7WhXibr/hYrlah17vEQwHlAVSpUocA7v7yuUaxa74fdvzjCBaXs2Hoj5t0fqEBUGbbmUB3274GuXww/e5w+zff3Xeew1t/Hx0h9xQ+pVbHB+m/PhpsHnUl6sSUdl2HLDBUEZ55KuXM3C+sigdXw8UxH/Wue2Z6LF68JZ2ahhSKXiKFVctMjNJBPkS+WoY+PBbpPb2epfk5kQYC3rbuGiNfOj9vf1FL7JkEkmaq5zctBg4ROWdfLWMw7nhGXVDlgtg/ZgtaS9mlbyhVKl5k2MkcQ7tY0lDLCy0R4si7K0yWmcwXrL6Ydzw1WnT/VpyCBR2/Rpll3UHiyRxmnkb4NbgRc5514M/DfwYQAzWwNcARwDXAx8ycw8M/OALwKXAGuANwaPnXGGZrCaK8DqL5ajkp8og9WSjjIrz+zorRlkOBOE7+DlSxV6CoMDrEpwn5/dMvPnmMUDKr+L4KA27YVSzcI9/P4N972L73XryKbIJBMjDohsC4Kxld4W+PIFsOk+eM2X4Y9vhzWXkU75z9sdZAi++cencumxC4d8nmzKqxn2Otx/sgtn+UHekq4WsimP1mCxHM4mq+0WV71tZizrbqE9k2TlvLYowCpWagOpMJtXLPlB7MFeoHRHJYLTP8DKpjyue8taVsxtq/vnDsvyulvTNWWpYSay2mAjyd9edkzNPrBclMEKA6xk9HMUnfs43kHvbkvTlkkO+2bBSOcbdRGsmYM1uIvgyPOERMZjPF0Em5GXMBZ35lgxZ2JDmkVkZA1bVTjnfhr78C7gtcHty4EbnHN54BkzWw+cEty33jn3NICZ3RA89rFGneNUCfe9NGOAVam4YNP5oAxWazrKrPTkS6ycV/9F3FSKz2QamsHyr0+YvZrfnmXrvoForxaEe7Cq75CHJYKt6doSQagtsZrTlmZHT4GOWAbr1OXdfkvfETayz0o7PpC8gXf0/xisHa78HiyrdlIM370Pz/e0FbOHHWQ9pERwmCxCNcDyM1ndbWl6d/VzZBBgZWML5cHtwdcs7KAzl2Zee5antvnt/cNsYLwJQb7kz4Xzjx/cBUrXDCoRbKTwZ2Nw0B/uLxytsUY2ymBVSwQHP348GayObIqHrrloXJ3YqnuwggDKs+hnLB5MhT+z0yWDJc0pGTW5mF4/R2bGbz50/lSfhsiMdLDetns78KPg9mJgY+y+54NjIx0fwsyuMrN7zeze7du3N+B0GyvcczUrWNw1U4lg2LxhcIlgZ0squg21k+JngnCBlw+aU8T/oywFQcGWvX7TiMVBsLEnGLoMtXuwOlvSQYBVrmmZHQao8b1rYTOReJOLt565nH964wlDT7Jcgmd+xd/s/huuTt7CXZkz4aqf1wRXUA0Wd/cWaE17wwZX4Hd3i5pclMrD1uGffsRszlk9l+OW+iVf3a1+9m34EsHaRfPfv+ZYvvzWtcxtz7C9xx9QXIz2wVT3YBVKFUqVqSkRnNvufz3xn20ZKp7BGizlJUbd93XGEbO5/PhFrJjrv0vuB1iDMljjLFFKJMY3fDozpE179Tm1XQTHX3YoMpLw50vzyUQkNKm3bc3sNmDBMHd9xDn33eAxHwFKwP+bzGvFOeeuA64DWLt27eiDHprQ0AxW8zS5CEvGwgVQR2wPVjwIGKl8bboKS4XCJhdHzG3lvCPn8cDGPdEcsDvX7wDgzCNmc99zu9kdZIha0x6FUiXKRHa1pBgI2rTHg47wes8OgtNkwqLvYxh8jWjPBvjW22DTvRxhad5beBdbF13GuZ1Dh+CG797v7ivUdEAcLJeu7sEaqVX2kq4Wvvr2U6KPZ7emaU17UQOOkUoEoRpwzWlLUyw79vYXq3utYgvgfKk8ZSWCL1k1h8+/8YSazokyVNgsYrh/98mEjTrc+Ii5bXzuihNwzpEwaMkkaQneeDhmUQePbt5X9z0ggzNYXiwoi2ew4m3cRSYqOY427SJyaJlUgOWce+lo95vZW4FXABc4F0282wQsjT1sSXCMUY7PKEP2YBWbJ4MVBn+DSwQ7W9N4CaM9k2R/vjTz9mCFGaxShb6C3/3vwy8/mmu++whPBG3p73hiO8ctmRVlsHb3+QHWrFyKfDBo2MwPSvuLZXry5VH3YOXSXtTcomOkYbalAvzun+HnnwZLwOVf4h+eWcl37t7BuSMsSqM5WG70vUXZmiYXw2ewBnv1CYs5YWlnlBXLjVIiGAqzRDt68tHPVbzJRW++FJVvHex3gJNegsuOW3RQX3M6CjNYXS1DA6yl3S3j6gJoZizoyLKwI8tL18ynuyXNEy/s9wOsYRqsTO58/Z+zaA/WiBks7cGSyZuuXQRFpHEatvHAzC4GPgic45zri911C/BNM/tHYBGwCrgbMGCVmS3HD6yuAN7UqPObSlEXwSB4KYw1DfAgChfcYQZrQbAHZ3HQ0a4jl/IDrBmWwappcpEvR3uikl6CUtmxu7fA/Rt28+fnr4oWZWGb6Y5cih09BQaKZXIpv/ypJ1+ir1Cq2cw/a9AerNZ0kvZMMNA5HmBVKrD5flh/Kzz8Ldi5HlZfApd8CroOJ73tcWDHiI0B0rHF6mh7i3IpP/NWrjjyxeG7CA72ykHBSHaUDFZobhBQbtufj4ZLhwv2tJdgV6kSZbbGM+NIDr6UZ7xocUdNd8DQLe8+i/EuK2/587NoyyTJpjyOXtjBp370OFD/LmbxrodQG1TFf3eFP7OeSrtkEsYzB0tEDi2N3Nn9BSAD3BrUzN/lnHunc+5RM7sJv3lFCbjaOVcGMLN3Az8BPOB659yjDTy/KRMGMWH2Il9svhLBcOGxfE4rP/iLszh6gT97pSOXYtOe/qjMbaYY3ORiURBYprwEhXKF3zy1g4qDc4+cywv7/I54e2IZrM17+hko+Z34simPbfvyfpv2WICzqDNLwmBJUF7XkvGijoAdbh88/EN48qew/nbo2wEYLFkLb7wRjrw4+jxtQVA20nDITE2ANfLCNZf2H9dfLDNQKtd0MhyvXKpaYpUeIUDrCha0e/qKzA72cFXnFAV7sIJ9bgd7D5aMj5nx/T9/ybD3HcjG/sElq/OC7Ga9B53Gm6gAJGIlgvPaq+MPptscLGlO07WLoIg0TiO7CI44ttw59wngE8Mc/yHww0adUzPoL5SDltiJ6F3bpspghQFWLPNyzKLq/pQwsxMulGeKKINV9OdghZmftGcUyxW2Bg0uVsxtY2/Q3CJsg97ZkgqaXFTIJhPkUh47Y/uzQhetWcCt7zsnuu6t6STLMz38Y+Y6Zn3xV+DK0DIbjrgAVl0ER5wPrbOHnGsYlI30rn88CzRaiWAYHPUXyuPOYA2W8gxvjD04YcZuV2+BZd2D2rR7iZougnoH+NAyryMMsBq1B6s2gGrPJmt+VruC0mfNAZLJiOZgqdRURALqTXwQ5EtlntrWy/W/eYab73uekw/vIpvyqlmTZtqDVfRblI/Udnm4VuMzQfhO9kAw6yoMTJJeAueIOgRmktXAOL4Hq1D252Jl014QYPlZrniJXiJhHDG3LWqfvsTbxZseuwZLbsLW/gkc+zpYdAIkRl/stWdGD7DMjHSQeRutRDB8/kCxPOKg4bGYGbmUN2J5IFTbc+/pKwzZa5VJ+mWKKhE8NIXZpHoHOIuC2T5ht8twj0yYMQtdfvwi1izsUBdJmZQwg6VSUxEJKcA6CK757qPccE+1A/2DG/cyuy1N0kuQsOaagzW4RHCwcCEyWne66SgTdREMM1i1zRh6gplXaa8aYIWZrFm5FM5Bz0CJbNIjl/YIW7oMKdEr9NJ29xf4fOoOXrb9fhKp1JA5VmNpHyODBUH78zECrDCI7i+WRxw0PB7Z1OhtujNJf0Dxrt5i1KY9HRs0nC+Vh3QXlENDGPBMJLgfzaxcip/95bnRx2HcHo5FCGWSHi9arA6SMjlJlQiKyCBazRwE2/fnWdbdwg1XnQb4JYFhAJNJek1ZIjjSgjlsxtDVOrPe8Q03xe/tL1Jx1cxTmGnpyRdJewkSCYuuXTyDFT43XvoJsUzgrmfgvq/C9S8j9YtPclLiv/l9+7nwJz87oOAKqmV/o+1bCUukRi0RDPdgFSaewfLPwyM3yqBZ8EuxdvcVokHD8Tbt2oN16FrclePSYxdy2oqhpbD1NFIGS6Qeql0E9ftLRHzKYB0EhXKFOW1pTlsxm/Zskv0DpWiuTDqZaKomF2EDjpH21Fz64oVkU4lxtfSeTsKMSjjbqi0KsIIM1kApCkDCwGZ3b5GcFThy/+/4C+8OZu9NstJ7gaXr9nFWaoAWy7PmNg9+2gd7gwxmrht7002c/7Uyly9bxOlzVx/wuY61BwuqGYHWUQKf8Pn9xbLfpn2CGSy/RHD0hUVXSxhgDdqDlRy0B0vvAB9SUl6CL775xIa/zkgZLJF6UBdBERlMAVYd3fPZN+DM45T3fLPmuN9AIGh73pFl/0BPtCDNBAvMZtE/RongSYd1cdJhXQfzlA6KRMLft7Qrak6RBOdoL+4kS56efNnPcpUKtO16lCu8n3Fu30OcnXmQlvvzXJgCCrDHm00xexg5KzB/zhyy8+ZAug3mHQ1HvQK6V0AiweLOn7Okq2VC5xq2dh9tdlCYwRq1i2BwjfsKpahBx0S0ZJKjliJCkMHqHX4PVqnioj1uI3UiFJmM3qDEd64yWNIAK+e1cdSCdg4fxzw4ETk0KMCqo3T/dloqPUOO50tlOoMBnQtmZXlyW0+UIQrbVDeLsfZgzSgDe2Hb47D1IXjml3wltRFvYwcvT/Xzkl/thx9v4DXFXi7NJNm5YT658n74RA+zXYVPpeAF18nt6fPpOvFVXPXzFGUvw0tXLuQLbz6RdH+JWS0jl1F+991nTjgLuLAzy8XHLODUUcqqwozc6CWC/uvv6/cbm0w0g/XXlxw1ZmDU1ZLi2R29Q5pZhM8Lf+5UIiiNsKPHbzqjDJY0wtLuFn783rOn+jREpIkowKqj/uQs5vVvGnI8vr8l/A8+HBIbtqluFv3FMpmkv9doRnEOdj0NG37r/3nut7Drqer9s5bSTZr2wjbmW4VSy2o48lwe6u/mrt8/wJrMXnZaG5ef8WIKs4/kwhv2ssHN44IVC3nVokX0cT+UIZP2MLNRgyuA9uzE97ClvAT/8kcnjfqYagZr7Dbt4Tyvie7BGi3QC3W1+BmswSWC4Wv25kvB8Rn2cydNYWeP/zOuAEtERA4GBVh11J/qpL13/5DjhVIlyg4sCAOsdLXJRb7URHuwCuVRO8JNG5UybH0YNtwFG+70/+55wb8v1wVLT4Pj3wTzj/HL9zoP46pP38FAsczOQoFvX3wG3cu62PjQFv7+7mNYkW4lnUxw+flnk3KODTf8EAcs6crVtBZvlu6KmXE1uQibdfjdECeawRqP7tY0+/OlqFQrDADDv/cPhAGWMlhSf+HYBDW5EBGRg0EBVh3lU5200QvlIngp9vYV6cglyZcq0SJ8/qzaDFYmNb4M1hfvWM/dz+ziq28/pXFfAH6p1kgzsJrevi2w/jZ48qfw9M8hv88/PmsZrDgXlp0Gy86AOathmG5PmVSCTXv6gXiTCz+jsj9fYlHWv3ZmRiaZYKBYYUlXriYwWTWvrWFf3oE4kAxW2G6+3q2y47qCjN72/f5Cd+QMlgIsqb+wUWs42FhERKSRpulKujkVMp3+jf7d7PW6OPWTt/G5K07wSwSDphZhBiuXTkBxgLnsZU9p7KYRdz61gwc37m3YuYf8eUjTZJFbLsGme/2A6smf+hkrgI7FcMyrYfnZflA1a8m4Pl18T1TUpj0WAMT3GWVTXhBgtdRksFbPb5/sV1UX6eBrGa3JRXZQiWC9h73GdQWDqbftH/DPb9AerN6CSgSlcb7xx6fw8ye2T983j0REZFrR/zZ1VEoHgVLfTnYlWhkoVti8p598qVzNYAXvoOZSHvzgfXxh2038c/u7wZ0GNvLicsOuPnryJb+ddh1bpN/x+Db2DRS5/PjF/qkXSs29CKmU4dlfw8M3wbrvw8AeMM8PpF76t7DqIpi3ZtTv5UjigWVb8D1IJapNGOLfdz8DWWRJV65mjtnKZslgjaPJRcpLkPKsWiLY0AyWH2C9sC/IYCXDLoK1g5yVwZJGOGpBB0ct6Jjq0xARkUNEE6+kp59y1g+wXN9OBjJ+wDJQrAR7sGozWN1uDzz8LUqW5j37r4X/exe8/mvQNm/I5y2WK2ze47/zv7u3yIJZ9Quw/v3OZ9m+Px8LsMojzsCaMs752amHb4KHb4b9W/zW50e9Ao68GFacB7nOSb9MPMBoCTI/8YxK/P7we7S0q4WNu/ui42O1Kz9Ywp+3sc4nm/Im3eRiPKoBlv9zXC0R9L+PKhEUERGRmaI5VoMzRCXXDUCpZycDCf8d+f5CyS8RDBaOc9oynL5iNhflfwzlAv942L/QtvVu3rvhX+G+r8I5HxjyebfsGaBccYC/WXvBrPp1wsqXylSciz4eKFZbyk+5fZvhoRvhwRth+zpIJGHlhfCyT8DqSyA9sTlSIzl6YQfP7OjlDScvixb6qVjQkYlluDLJBO3ZJLNaUmzvab6gIDOODBb4mdQ9wR6sxpYI+nuwtgV7sMLBnOkog1UiYeDNtO6VIiIicshRgFVHLue3qy7u38FAzi8b25+vnTGUSBj/8SenwueuguVnsyt3BD9OdPHeRb+D9bcOG2A9t6s3ur27tzji6+8fKNKWSWIHUB6XL1UoVaoBVl+hzKLOKcxglQrw+PfggW/CUz8DV4Glp8Kl/wfWvBpax24JPlHXvPIYrnnlMTXHUol4UBUrEUx50aDgRPD9bpYOguAHLl7CxsxKtaS9aLjywchg7ejJk/YS0c9ovMmFslciIiIyEyjAqiNr8TNY5d6dDASt14ft0LblQdjzHJz9l2SeDboIrrwQfvUZ6N/ttxGP2bCrWoK2szdPb740pPRr/0CRU//+dj77huO56JgF4z7nfLESZccgKBGciiHDPdvg3v8L937Fb6fesQRe8n447o0w+4iDfz6BcK8QUNPM4tUnLCZMtswJWj9/+JKjDuq5jWZWS4o5bekxg+1ZLWme3en/fNVzb99g2ZRHRzbJvoFSTdllPIOlAEtERERmAgVYdZTOtdDv0lR6dpAv+gHWviDAinegY90tfmOGIy8l8/xW/7ErXwq//Ae461/ghD+EzqXRw+MB1oMb9/KX33qQb/7JaZx8eHd0fN9Aib5COdrjMl75UplSpdqkYaB4kPdgbX4Afvev8MjNUC7434dTvwhHXDBsK/WDLb7oj5cIXnnG4dHtjmyKZz916cE8rTG965yVvO6kpWM+bklXjgc37gFoePfIeR1Z9g301JZdxvZgqYOgiIiIzARTv4KdQXIpj1204/p2MVD0g5YhGax9W+CR/4TDz4LW2WSSCb8L3eKToHUe/OJTFD9/Ejx4Q/R5N+7q4/DZLZjBL5/cTrHseHxr7UDjUtDJLp6NGo98qUIsvgrmYDU4wCqX4NHvwPUXw3XnwGPfhRPfAlffA3/4n7DqwqYIrqA2a9XIErp6m9WSGldHw6Vd1X1sjRw0DNUhr/GgVRksERERmWm0oqmjbMpjj2uD/t0MFGtLBNPJhN8J7/MnwN7n4dQ/jY7nSxVcwoN3/pq/m3st6zgCvvMuGPAH5W7Y1cdhs1vpakmzflsPAC/src1UFct+YFUeI74qlivc+dSO6GN/D5YfYTnn6C82sESwVIDffw2+sBa+daXfxOJlfw/ve8zfYzV3dWNedxKSNV0Em6y7Yh0s6cpFtxsdQIYB1nBB60CxogBLREREZgStaOoom/LY5dpJDOwcEmBlkh7c8UlIpuHd98BRlwbHEzgXBEjt83kseTT/XLkcXBm2PgT4jS1mt6Xpbq129xtcChgGSeV4OmoY33twM2/6t9/xzA6/cUa+WI6yXmHWLVvvDFapAPd8Bf7pRLjlzyHbAa//OvzF/XD61XVpsd4ow2VbZpKlyojMUAAAIABJREFU3dUMViO7CIJfIgi138f4bZUIioiIyEww81aMUyiX8thDG97AHgZKtSWC3fsehyd+AKddDd0roueEWZEzPnU7j2zaS7Fc4e6BZf6dmx8AoLdQoi2TrA2wgnbXoVKYwRo9vooyYJv39AO1XQQLwTnXLVPjnF8K+KVT4Qfvg/YF8KZvwVW/gDWXQaL5M0KpaVoiOF5LpyCDNdJsMWWwREREZCZQk4s6yqX9DFZqYF2UwQqzQoc/9Q1/OG5QGhgK38Hf0VPg1+t3UKo4djKLcvtivM33A0RdA7tj86mGlgj6rxOfaTWc54KOcdv2D+Cco1CukC7751AMsl91ySQ891u49W/g+Xtg7tHwpptg1UVwAC3km8FIwcBMsbgrhxkY1dlUjTJ3lD1Yg4+LiIiITFcKsOool/LY4maTLu6l0r8vOt5GH3M3/ABe/Poh5XD7B6pzrWblUlEWqbf7RXRseYB8qUyx7PwMVpsfYHkJ44X9tQFWWOZXGmMT1rM7/dLAbfvyFMsO54gyWOFzJ7XQ3f0c/OSv4fHvQ9sCuOyf4Lg3gTc9f9Rquwg2f8btQGWSHvPbs+wbKB7Q/LSJmNfulwjWBFix26kZGMCKiIjIoafhq14zez/wGWCuc26H+au4zwEvB/qAtzrnfh889krgo8FT/5dz7quNPr96yqQSPOUWAdDe8wzg72+5zPstXqkfTrxyyHNOXFadeVUsV6JM1M6Oo+l47if07vNbaC8oPs8RPffS6j3FeW3Psb63hfymhWQWHxs8N2xyMXKA5Zzj2WDv1Qv78uSDWV3hc8LXnlAmo1SAOz8Pv/yMn6U676Nw+rsg3Xrgn6uJxL8XMzGDBbC0O8f6beWGv868jqFNLuJB3eGzW4Y8R0RERGS6aWiAZWZLgYuADbHDlwCrgj+nAv8MnGpm3cA1wFrAAfeZ2S3Oud2NPMd6yqW8KMCa0/M4X07dzmdLf8ArE78l37WazOIThzznjJVzeOB/XsjxH7uVYtlF2aSNbS9mOZD94V/w0WSZV911G16lyMUp2MMijvN2kvrqJfC6f4eVF0RNLiqjtGnf0VOgt+AvpLftH/AHHFPNfoUB1gFnsLY+DP/1TnjhETj6Mrj4kzBryYF9jiZlZqQ8o1h2M7LJBcCKOW1sH7SnrxGiPVjJ2gD+qrNX0JL2+NOzp26gtIiIiEi9NDqDdS3wQeC7sWOXA19zzjngLjPrNLOFwLnArc65XQBmditwMfAfDT7HusmmPDa4eZQtyck7vssS70nypFibeIKe5e8kM0IJVthUoliuUAyCnsezx3H2hR8jd+s1XOkl2Lr45bRe+CF+9myB2QuW8lfX/4g7Oj9L7v/9ARxxPuWTvgiMnsF6LigPNINt+/M1AZZz1eBu3AGWc/Cbz8HP/hfkuuCNN8CRl4zvudNIyktQLJdnZJt2gA9efCS7+4pjP3CS2jJJcilvyM/XX7/86Ia/toiIiMjB0rAAy8wuBzY55x4ctLdjMbAx9vHzwbGRjk8bKS+BeSl2Z5ewpP9JAC717gagdPh5ozzP//4USxWKQZCzs7cIL38PD3VewJu/vo4vvuRczlk2l9csgye27mcrs7nj7G/x8r7vwO0fY0H7N1hmcyiXDx/xdZ4NGlysWdjB9v158sVqWVi54qL9X8nxNLkY2Afff68/NHnN5fCKz0JL99jPm4b8gKA8Y0sEZ7dlmN2WafjrmBnzOzI1JYIiIiIiM82kAiwzuw1YMMxdHwH+Gr88sO7M7CrgKoBly5Y14iUmLJv02J45jDn9z9Lv0uSsQK/L4JadOuJzvIRhVrsHa3uPX7K1OzmPHp6jLVPNniwI5glt7jM4633w7K856oFP8MsM/GTre4G/G/Z1ntvZi5cwTlzWxbd//3yUwQK/0UU1gzVGgPXMr/xByPuehwv+p38O06w74IEIMy4zNcA6mK657Bg6c6mpPg0RERGRhpnUitE591Ln3IsG/wGeBpYDD5rZs8AS4PdmtgDYBCyNfZolwbGRjg/3utc559Y659bOnTt3Ml9C3WXTHltTftD3tfKF9LoMd1ZeRCaTG/E5/j6fBIWyi0oEd/YUAOjN+1mm1kw1Fu7IJUknE34QZgYv/wybFl/M+soi1m67GUYYNvz87n4WdGRZ1Jmjt1Bmd28huq/iHKWx9mC98Cjc/Hb46iv8roBv+zG85P0zOriCasA5U/dgHUznHTmPE2KNXURERERmmoasGJ1zDzvn5jnnDnfOHY5f7neic24rcAvwFvOdBux1zm0BfgJcZGZdZtaFn/36SSPOr5FyKY9NQYB1R+UE/qjwYf6u9JYxsx9pL+FnsKISQT+D1ZsvAdCargZYZkZ7JknPgH8fs4/gdyf9H/6p9Cpm55+Hx/4LykP31Gza08/izlzUbGDj7r7ovlLFn4kFkEwMc64P3wz/dj48eSuc+R54569hlKzcTFLNYM3MPVgiIiIiUj9TMZzoh/gt2tfjt2l/G4BzbpeZfRy4J3jcx8KGF9NJNpXgruxL2ND6V9w1cDT+CFfG3Hfid6qLtWkPMlg9QYDVlqm9VG3ZZHQf+DOsflQ5lY8nb6Tj5rfDohPgHbeCVy3H2rK3n5OWdUXtsjfu6o/uK5ddbA5WLCNVLsEvPgW//N+w7Ax4w9ehdc6BfEumvfD7kUkpgyUiIiIiozsoAVaQxQpvO+DqER53PXD9wTinRsmlPHrKHrfZGZj14pwfXCXGmC2V8hIMFMuETQB39hRwztFXCDJYgwKs1nQyym4BFCsVCqT4wsp/46+XPAS3/S3cfR2c7n+ryxXH1r0DLOzMRQNfB2ewwlbvUYngjif9ksCtD8EJfwiXXgvJ9IS/N9OV9mCJiIiIyHhpxVhn2ZRHf6HMQLHMrGAz/3j27qS8RDSjqiXtUShXKFccPfkyaS8x5HO0ZZPsH6jNYAHs9ubAme+FVRfBHZ+EXU8DsKMnT7HsWNSZo6vVP68X9g0AjgSVoIug/zmSnsH2/4Z/vxT2bfZnbV32hUMyuAKVCIqIiIjI+E1FieCMlkt77O4tMFCq0JlLsaevOK7MRzqZoD8IsLIpj75CmbJz9OZLtGaGLuzbMkm27R+IPg5LC8sVFzW+4F/PhhvfAqf9Gb37E7zWu5+XPn4Tc3/9Ox7I7OPhbcfyD+mn2Esr5fzpUQYrm98FN/6BP+fqbT+EuUfW41szbanJhYiIiIiMl1aMdZZNevQX/QxWZ4uf8RlfBsuicsBs8PhyJQywhsbBbfEmFxC1WC87R6XiKM9aBq/5N9jx3/Ddd7HiZ+/kM6l/Zd7mn2HLz+JWdzJrSuvYRyvH2HN03vo+SqUSXexjyY/eCr3b4U03HvLBFUBSJYIiIiIiMk7KYNVZLh0PsPxSvPEszFNegr5YBgsISgRLQxpcgL8nqydfOyg4/Pvvf7iOx7fu5xt/fBHF9z/JeR//NrPopZcs3/3Am5nVmuPT627lA0EjjXd6t/ChJ2/gjF2b+V7mGVI7e+D1/w6LT5zU92KmSCvAEhEREZFx0oqxzrIpj/0DJSqOaKDqeDJYyViAlYkFWL2FEi3poSWC7dkkPflqK/Z4ieDzu/ujBhYFr5Xn3TwedcvZnlpCR4vf4KIjW+0u+C/ly9h+5t/StedRNrk57H7tzXDkJRP58meklGekkwlshs/7EhEREZHJU4BVZ7mUx54+P/AJSwTH0xwh7Rl9QVfAXKpaItiTLw9bItiaTjJQrETDgcMmF+WK8zsCBh+HgRfAos5cFCS051I1n2/Hi97Bf1xwJ28o/E9Yesr4v+BDQMpLkBmjzb6IiIiICKhEsO7mBkN8gQMuEewdpkSwN19i0azskMe3Zf1L98L+PP2FEsWgQUXFOb8jYBBYFUrVAOuIuW3R7Y5s7aX3nxN2EVQwEZfyEpqBJSIiIiLjogCrzlbPrwYxXQfU5KK2iyAQ6yI4XJML/zH/56dPcPu6bbz2pCX+c6IMlh9Y5YMA68OXHMUVJy+Lnt8xKIMVPs8/F5XCxaU8U4t2ERERERkXBVh1tnp+e3T7QDNYYdYpG2RLSuWRm1y0ZfzP/djmfeztL0algGF5YHFQieCCWVlmtVSDqvgerOrzBg0aFgDedOphnLVq7lSfhoiIiIhMAwqw6mxxZy66nUt5ww4JHk46Wc0aZZO1JYLDzcEKjz2zoxcgapARlgiGgVVhhKBpuBLBMChLJpTBijtleTenLO+e6tMQERERkWlAqYo6S8SCk2zKI5NKjKu8LB4AhV0Eewt+N8LhSgTbgwApLAEMZ2j5pX6VaoAV3J8eHGDlBmew/OckE6ZueSIiIiIiE6QAqwEWdPhNKbIpj/ZMctgM1GDxACssEYz2ZA0ToIUlgqFwJla54mewKi5oXBEGWMmxM1ililN5oIiIiIjIJKhEsAGWdbewdd8A+VKZz15xQhRwjaY2wPIDqjA7lRym6cTgoK03H89gVfdfjVgiOCSD5ZcVDvdaIiIiIiIyPkpXNMD7LlpNwuCoBR2csrybZbNbxnxO2hu6ByvMPnnD7IlqH5TBigKsIHMFftA0cgardghyJQiwlMESEREREZk4ZbAa4LQVs3n6k5ce0HOGKxHMl/yyv+GaTgzJYAV7sCqxBhfFUiUKsAZ3MuzI+Ze+Ne1RKFWi7oNq0S4iIiIiMnFKVzSJVCwAyqVrSwS9xNDLlPQSUSAG0BfswSoFe7AAipVK1BlwcAarPchgtaT9QCvsIpgc5rVERERERGR8tJpuEjUZrOSgPVgjtE2Pz8fqyVczWNU9WI5CuTzk80O1RDDMhJWiEkFlsEREREREJkoBVpOI78HKBJmp0fZgQW2AFQZjZVfNYJXKlZH3YAUlgrkog1WhVNEeLBERERGRydBqukmM2kVwhABruPlYQ7oIjjAHK5fySCaM1qAcsVQOSgQVYImIiIiITJhW001iuABrrAzWsu4WVsxtrTlWju/BKjsKI+zBMjMOm93Ckq4cABWnEkERERERkclSgNUkUjVt2gd1ERwh6Ln2DcfzpTefWHOsXHGUwi6Co2SwAL5z9Zn8xQWrAGJdBPUjISIiIiIyUWrT3iTigU1mSAZr+KAnm/KYNWhgcMUNymCNsAcL/E6C4f3lcNDwCNkyEREREREZm9IVTSIMsLyERdmssfZgAWSStfOwShVHMbYHq1iu4CVsxDLDsC27vwdLTS5ERERERCajoatpM/tzM3vczB41s3+IHf+wma03syfM7GWx4xcHx9ab2YcaeW7NJpyDlUxYFPSMtQcLhmamKpV4F0FHYYx9VWFyLGyOoT1YIiIiIiIT17ASQTM7D7gcOM45lzezecHxNcAVwDHAIuA2M1sdPO2LwIXA88A9ZnaLc+6xRp1jMwnbtKe9BGESKdqDNWoGqzbAqhk0HOzBGm7/VSgM5spOXQRFRERERCarkXuw/gz4lHMuD+Cc2xYcvxy4ITj+jJmtB04J7lvvnHsawMxuCB57SARYYWle0rNoz9V4MljJhJEwCGKq6DngB1j5UoX0oDLCuPBzlzVoWERERERk0hqZrlgNvMTMfmdmvzCzk4Pji4GNscc9Hxwb6fgQZnaVmd1rZvdu3769Aad+8IUBVspL4NngPVgjXyYzqykTLJTjAZYfNA3OcsWF2bFS2e8+qD1YIiIiIiITN6kMlpndBiwY5q6PBJ+7GzgNOBm4ycxWTOb1Qs6564DrANauXevq8TmnWk2AFWSRxpPBAr/RxUCx2g0wVKr4JYKj78EyzKBcqfglgqMEcyIiIiIiMrpJBVjOuZeOdJ+Z/RnwbeecA+42swowB9gELI09dElwjFGOz3jppB8EpTwbmsEao2xvpAxVoRTswRolgwXgmfndB1UiKCIiIiIyKY1MV3wHOA8gaGKRBnYAtwBXmFnGzJYDq4C7gXuAVWa23MzS+I0wbmng+TWVmgxW4gAzWKnhL2MYNI0ZYCUs1kVQGSwRERERkYlqZJOL64HrzewRoABcGWSzHjWzm/CbV5SAq51zZQAzezfwE8ADrnfOPdrA82sq1SYX1QArXx57DhYwYpfAYrkStGkfPWhKBgFWsVwZM1smIiIiIiIja1iA5ZwrAH84wn2fAD4xzPEfAj9s1Dk1szAISnvVocD5ot+mfTx7sMAPlEqxPVjFsvO7CI4RYHmJeImgMlgiIiIiIhOl1XSTSA9XIlgeu4sgVEsEB+/FiuZgjVEimPQSfolgWYOGRUREREQmQwFWk0gFTS6SnkUlgfnieLsI+pcxm6qdd1UqV8Zs0x5+/lKlQqmiLoIiIiIiIpOh1XSTiDe5SNjgDNYYe7CCEsHBgVSh7II27WN3EQyDOWWwREREREQmTgFWk0glqgFWcvAerHG2aR9cClgKmlyMp4vgQKkcvb6IiIiIiEyMVtNNIhWbg5UYsgdrfAFW2OwiVCxXKI6jyUXSs2hQcVIBloiIiIjIhGk13STiJYLgB1X5cc7BSkd7sAY3uXDjz2AVwwyWSgRFRERERCZKAVaTCLNUYYCVSBjOhfeN0UUw2oM1NIOVH8cerGTC6C+qRFBEREREZLK0mm4SZkbaS0QZpHhZ4BgJrGqJYGrwHiy/ycXYXQQT1RLBsV5MRERERERGpACriaQ8i/ZAeVYNtMzG2IM1yhys4rhKBKsNNZTBEhERERGZOK2mm8iSrhaWdOWAaufAsfZfAWS84ZtcDJTKVNzYQZOfwVKAJSIiIiIyWcmpPgGp+t6fnxWV6MUzWGPJpIafg9Wb94OmsTJYyYQxUAq7CKpEUERERERkohRgNZF4IBRmrsaVwRphD1ZfoeR/3jEzWOoiKCIiIiJSD6oHa1JhYDWeuVTDzcHKphIHlMFSF0ERERERkcnTarpJHUgGKz1MBiub8ug9gAzWeFvCi4iIiIjIyLSablJRBmtcJYJD52DlUt64M1jxIG7wsGIRERERERk/raab1IFksLJBk4tcyqs5Fu3BGkeJYKi7NX3A5yoiIiIiIj41uWhSB9JF8JzVc7nmlWs4Ym5bdMwPsMa3ryoexHUpwBIRERERmTBlsJrUgWSwcmmPt525vCYYy8VK/Qa3bx8s3HeVTBjtGcXcIiIiIiITpQCrSVX3YI3/EiXiAVa6Wi44ryMzrtfqak1jpjbtIiIiIiITpQCrSSUPIIM1+DkA2VjDi4WzcqM+L3yN2SoPFBERERGZFAVYTSoRzcEaf4AVz2BlgwxWa9qjIzt62V+UwWpRgCUiIiIiMhkKsJrURDJYng3NYC3szI1Z9he+ljoIioiIiIhMTsMCLDM73szuMrMHzOxeMzslOG5m9nkzW29mD5nZibHnXGlmTwZ/rmzUuU0HiQPoIhjyavZg+Zd24azsuJ/X1Zo6kFMUEREREZFBGtky7h+Av3PO/cjMXh58fC5wCbAq+HMq8M/AqWbWDVwDrAUccJ+Z3eKc293Ac2xaYWngAWWwhtmDtWiM/VcAYYKrWyWCIiIiIiKT0sgSQQd0BLdnAZuD25cDX3O+u4BOM1sIvAy41Tm3KwiqbgUubuD5NbVqBmv8l2i41u4LO8fOYPXm/XlZKhEUEREREZmcRmaw3gv8xMw+gx/InREcXwxsjD3u+eDYSMcPSRPZgxUvK9zVWwDGVyK4t78IaMiwiIiIiMhkTSrAMrPbgAXD3PUR4ALgfzjn/tPMXg98BXjpZF4v9rpXAVcBLFu2rB6fsulU52AdeIlgMmFs78kDMK997ABrXxBgKYMlIiIiIjI5kwqwnHMjBkxm9jXgPcGH3wK+HNzeBCyNPXRJcGwT/h6t+PGfj/C61wHXAaxdu9Yd+Jk3v+HK/cYSz3pt3+8HWHPaRh8yDLEMlvZgiYiIiIhMSiP3YG0Gzglunw88Gdy+BXhL0E3wNGCvc24L8BPgIjPrMrMu4KLg2CHJm8QcrKSX4HVr/Rj28DktYz5v34AyWCIiIiIi9dDIPVh/AnzOzJLAAEFJH/BD4OXAeqAPeBuAc26XmX0cuCd43Mecc7saeH5NzQuaW3gH0uTCqhmsd5y1nLefefiYM7AAls9p5YV9eTpb1KZdRERERGQyGhZgOed+DZw0zHEHXD3Cc64Hrm/UOU0nYeJqonuwgHEFVwD/8ocn8fjW/bSkGxlvi4iIiIjMfI0sEZRJqGawJhBgHUBZIUBnS5rTVsw+oOeIiIiIiMhQCrCalBdcmQPKYE1gdpaIiIiIiNSPVuJNaiIZrDCuOpDniIiIiIhI/SjAalITyWCFmasDeY6IiIiIiNSPAqwmlZxAF0FlsEREREREppYCrCaVsANvWFHdg6UAS0RERERkKijAalJhYDWRLoLKYImIiIiITA0FWE0qMYFslJmRMEh6uqwiIiIiIlNBK/EmlZxgNspLmEoERURERESmiAKsJpVITGw/VcJMJYIiIiIiIlNEAVaTqmawDuwSJZXBEhERERGZMgqwmpQ30QxWwg44KBMRERERkfrQSrxJTbQjoPZgiYiIiIhMHQVYTcqbwBys8HneAT5HRERERETqQwFWk5pMBiulDJaIiIiIyJRQgNWkJroHK6k9WCIiIiIiUyY51Scgw/Mm2EXwry45imXdLY04JRERERERGYMCrCY10QzW5ccvbsTpiIiIiIjIOKiWrElNdA+WiIiIiIhMHQVYTSrqIqgAS0RERERk2lCA1aTC9uzKYImIiIiITB8KsJpUtAdLM61ERERERKYNBVhNKiwRVMt1EREREZHpY1KrdzN7nZk9amYVM1s76L4Pm9l6M3vCzF4WO35xcGy9mX0odny5mf0uOH6jmaUnc27T3US7CIqIiIiIyNSZbHrkEeA1wC/jB81sDXAFcAxwMfAlM/PMzAO+CFwCrAHeGDwW4NPAtc65lcBu4B2TPLdpTV0ERURERESmn0kFWM65dc65J4a563LgBudc3jn3DLAeOCX4s94597RzrgDcAFxuZgacD9wcPP+rwKsmc27TnQIsEREREZHpp1EbfBYDG2MfPx8cG+n4bGCPc6406PiwzOwqM7vXzO7dvn17XU+8WZywrIsrTl7KMYs6pvpURERERERknJJjPcDMbgMWDHPXR5xz363/KY3NOXcdcB3A2rVr3VScQ6PNyqX41B+8eKpPQ0REREREDsCYAZZz7qUT+LybgKWxj5cExxjh+E6g08ySQRYr/ngREREREZFpoVElgrcAV5hZxsyWA6uAu4F7gFVBx8A0fiOMW5xzDrgDeG3w/CuBKcmOiYiIiIiITNRk27S/2syeB04HfmBmPwFwzj0K3AQ8BvwYuNo5Vw6yU+8GfgKsA24KHgvwV8D7zGw9/p6sr0zm3ERERERERA4285NH09fatWvdvffeO9WnISIiIiIiM5iZ3eecWzvW4xpVIigiIiIiInLIUYAlIiIiIiJSJwqwRERERERE6kQBloiIiIiISJ1M+yYXZrYdeG6qzyNmDrBjqk9CGk7X+dCg6zzz6RofGnSdDw26zoeGqbzOhznn5o71oGkfYDUbM7t3PN1FZHrTdT406DrPfLrGhwZd50ODrvOhYTpcZ5UIioiIiIiI1IkCLBERERERkTpRgFV/1031CchBoet8aNB1nvl0jQ8Nus6HBl3nQ0PTX2ftwRIREREREakTZbBERERERETqRAGWiIiIiIhInSjAqhMzu9jMnjCz9Wb2oak+H5k4M7vezLaZ2SOxY91mdquZPRn83RUcNzP7fHDdHzKzE6fuzOVAmNlSM7vDzB4zs0fN7D3BcV3rGcTMsmZ2t5k9GFznvwuOLzez3wXX80YzSwfHM8HH64P7D5/K85fxMzPPzO43s+8HH+sazzBm9qyZPWxmD5jZvcEx/c6WpqMAqw7MzAO+CFwCrAHeaGZrpvasZBL+Hbh40LEPAbc751YBtwcfg3/NVwV/rgL++SCdo0xeCXi/c24NcBpwdfDvVtd6ZskD5zvnjgOOBy42s9OATwPXOudWAruBdwSPfwewOzh+bfA4mR7eA6yLfaxrPDOd55w7PjYHSb+zpekowKqPU4D1zrmnnXMF4Abg8ik+J5kg59wvgV2DDl8OfDW4/VXgVbHjX3O+u4BOM1t4cM5UJsM5t8U59/vg9n78hdlidK1nlOB69QQfpoI/DjgfuDk4Pvg6h9f/ZuACM7ODdLoyQWa2BLgU+HLwsaFrfKjQ72xpOgqw6mMxsDH28fPBMZk55jvntgS3twLzg9u69jNAUCJ0AvA7dK1nnKB07AFgG3Ar8BSwxzlXCh4Sv5bRdQ7u3wvMPrhnLBPwWeCDQCX4eDa6xjORA35qZveZ2VXBMf3OlqaTnOoTEJlunHPOzDTfYIYwszbgP4H3Ouf2xd/I1rWeGZxzZeB4M+sE/gs4aopPSerIzF4BbHPO3Wdm5071+UhDneWc22Rm84Bbzezx+J36nS3NQhms+tgELI19vCQ4JjPHC2FpQfD3tuC4rv00ZmYp/ODq/znnvh0c1rWeoZxze4A7gNPxy4XCNxnj1zK6zsH9s4CdB/lU5cCcCVxmZs/il+ifD3wOXeMZxzm3Kfh7G/6bJaeg39nShBRg1cc9wKqgY1EauAK4ZYrPSerrFuDK4PaVwHdjx98SdCs6DdgbK1WQJhbsufgKsM4594+xu3StZxAzmxtkrjCzHHAh/n67O4DXBg8bfJ3D6/9a4GfOOb0j3sSccx92zi1xzh2O///vz5xzb0bXeEYxs1Yzaw9vAxcBj6Df2dKETL9T6sPMXo5fA+4B1zvnPjHFpyQTZGb/AZwLzAFeAK4BvgPcBCwDngNe75zbFSzSv4DfdbAPeJtz7t6pOG85MGZ2FvAr4GGq+zb+Gn8flq71DGFmL8bf+O7hv6l4k3PuY2a2Aj/b0Q3cD/yhcy5vZlng6/h78nYBVzjnnp6as5cDFZQI/qVz7hW6xjNLcD3/K/gwCXzTOfcJM5uNfmdLk1GAJSIiIiIiUicqERQRERGDS13TAAAgAElEQVQREakTBVgiIiIiIiJ1ogBLRERERESkThRgiYiIiIiI1IkCLBERERERkTpRgCUiItOemX3EzB41s4fM7AEzO9XM3mtmLVN9biIicmhRm3YREZnWzOx04B+Bc4M5R3OANHAnsNY5t2NKT1BERA4pymCJiMh0txDY4ZzLAwQB1WuBRcAdZnYHgJldZGa/NbPfm9m3zKwtOP6smf2DmT1sZneb2crg+OvM7BEze9DMfjk1X5qIiEw3ymCJiMi0FgRKvwZagNuAG51zvzCzZwkyWEFW69vAJc65XjP7KyDjnPtY8Lh/c859wszeArzeOfcKM3sYuNg5t8nMOp1ze6bkCxQRkWlFGSwREZnWnHM9wEnAVcB24EYze+ugh50GrAF+Y2YPAFcCh8Xu/4/Y36cHt38D/LuZ/QngNebsRURkpklO9QmIiIhMlnOuDPwc+HmQebpy0EMMuNU598aRPsXg2865d5rZqcClwH1mdpJzbmd9z1xERGYaZbBERGRaM7MjzWxV7NDxwHPAfqA9OHYXcGZsf1Wrma2OPecNsb9/Gzzm/7P35tG2XWWd6G+uvfc5597c3PSEQICETjoLlIA0NkBQ1FLRp2XzfMrjYTHqFeJ7ImOICgVqlYWjykJUbBjKsytTokhjh0KIIEpPQlpIAiHk5ibk5ib35jbnnL33mvP9sdY35zfnmnN1uzlnn/v9xjhj77PauVc7f/P3fb/vccaYTxhj/hMKZexRC/wZAoFAINgjEAVLIBAIBKuOAwB+Uyl1LoApgNtRhAv+CID3K6UOG2NeWIYNXqWUWi/Xez2AW8vv5ymlrgewXa4HAP+tJG4KwNUAPreUXyMQCASClYaYXAgEAoHgjAY3w9jptggEAoFg9SEhggKBQCAQCAQCgUAwJ4iCJRAIBAKBQCAQCARzgihYAoFAIBAIBAKBQDAnCMESCAQCgUAgEAgEgjlBCJZAIBAIBAKBQCAQzAlCsAQCgUAgEAgEAoFgThCCJRAIBAKBQCAQCARzghAsgUAgEAgEAoFAIJgThGAJBAKBQCAQCAQCwZwgBEsgEAgEAoFAIBAI5gQhWAKBQCAQCAQCgUAwJwjBEggEAoFAIBAIBII5QQiWQCAQCAQCgUAgEMwJQrAEAoFAsBJQSp1kf1optcn+/9EW679OKXWTUuqEUupLSqnXBPMvV0p9WCl1Wil1i1LqhYntfFgpZeb1uwQCgUCwtzDc6QYIBAKBQNAGxpgD9F0p9WUAP2GM+WDHzfwfAK4H8EQA/6iU+oox5i/Lee8EcA2AlwD4HgB/pZR6vDHmKNvvywCo/r9CIBAIBHsdomAJBAKB4IyAMebNxphrjTG5MeYWAH8N4PkAoJR6CoCnAfhFY8yWMeadAD4P4PtofaXUeQB+AcDrlt96gUAgEKwKhGAJBAKBYE9AKfUtSqn7Wy6bAfhGADeVk54K4HZjzCm22OfK6YQ3A/hNAPfNobkCgUAg2KMQgiUQCASCPQFjzIeNMRe2XPyXAUwB/HH5/wEAx4NljgM4GwCUUt8A4FkAfnsOTRUIBALBHobkYAkEAoHgjIJS6v8B8MMAvskYMy4nnwRwMFj0IIATpdr12wBebYzJlZIULIFAIBCkIQqWQCAQCM4YKKVeCeBnAFxpjDnMZt0E4PFKqf1s2tPL6ecDeAaAdyml7gXwsXJb9yqlnreclgsEAoFgVSAKlkAgEAjOCJQOgL8I4AXGmC/zecaYm5VSNwH4T0qpNwH4LgBPBvBuAA8AeCRb/DIUJOsZ5TyBQCAQCCxEwRIIBALBnoBS6gVKqWM1i/xnABcA+Ayrn/VbbP4PAXgugAdR5Gh9vzHmqClwL/0BuB8Ayv/H4U4EAoFAcGZDGSO1EgUCgUAgEAgEAoFgHhAFSyAQCAQCgUAgEAjmBCFYAoFAIBAIBAKBQDAnCMESCAQCgUAgEAgEgjlBCJZAIBAIBAKBQCAQzAkrb9N+4YUXmssuu2ynmyEQCAQCgUAgEAj2MD7zmc/cb4y5qGm5lSdYl112GT796U/vdDMEAoFAIBAIBALBHoZS6s42y0mIoEAgEAgEAoFAIBDMCUKwBAKBQCAQCAQCgWBOEIIlEAgEAoFAIBAIBHPCyudgCQQCgUAgEAgEgtXAZDLBoUOHsLW1tdNNSWJjYwOXXnopRqNRr/WFYAkEAoFAIBAIBIKl4NChQzj77LNx2WWXQSm1082pwBiDo0eP4tChQ7j88st7bWMuIYJKqXcope5TSt3Ipp2vlPqAUuq28vO8crpSSv2GUup2pdT1SqmvZ+u8rFz+NqXUy+bRNoFAIBAIBAKBQLA7sLW1hQsuuGBXkisAUErhggsumElhm1cO1h8C+PZg2usAXG2MeQKAq8v/AeA7ADyh/HslgN8BCkIG4I0AvgHAswG8kUiZQCAQCAQCgUAg2BvYreSKMGv75hIiaIz5iFLqsmDySwG8oPz+RwD+CcDPltP/2BhjAHxcKXWuUuqSctkPGGMeAACl1AdQkLar5tFGgUCwWBzfnOAdH70DBsDLn3cZzjtrDfc9tIVP3PEAvvvpj7DLfeHeE3jPdXfDGGBtoPCKb3wsztlfxDif2p7i9//5Dky1xo895zF42MEN3HdiC3/ysTsxyQ0yBfzwsx6Nidb4y88cgjHFNpUCvvcZj8TZG0P82Se+gqk2lfZdeGANr/jGy/G+zx3GLfecAAA89qKz8INXPAp/8rEv4+5j/kjVvtEAr/imy3H9oWP4yK33z+UYPfbCs/CDz3oU/uTjd+LuBzc7r//sy8/Di550MQDgb6+/B898zHk4uT3Buz57tz0Wi8D+tQF+4psux82HH8LaMMPjH3YA773uMH74WY+CUgo33n0cp7an+IbHXgAAeN/nDuM5jz0fD21OcejB0/iWJ16Eqz55F77v6x6JL3z1BHKt8czHnF+7z7+/4R48/VHn4hHn7uvd7g/e/FU84eIDeMwFZ3nT/+X2+3HBgTU86eEHven/+sX77bk+d/8I//6bHotBpnDz4YdwbHOM5z3uwt5tEbSDfY4Yg//z+Zfj8LFNnNye4orHnIerPnUXfuRZj8Jw0G5s+N3XHsK3PPFhOP+sNTx4aoxrvnAf/revv9RbZnOc493X3o0fefajoh2qv7n+MJ512fm4+ODGXH7fPDDJNf78U3fhR579aAyyapv/4aZ78ZRLDuJR5+/3pv/zbUfw8IMbOP+sNfzzbffje7/ukQCAT335AawPM/ybS8/t3abr7jrW6r5O4Zov3IdHn78fj7voQO827CXccOg4Nic5nn15v+O5m3Dn0VO49asn8a1PuXinm7JULDIH62JjzD3l93sB0JF9JIC72HKHymmp6RUopV6JQv3Cox/96Dk2WSAQ9MVHbj2Ct159GwDgMefvx/c/81K867N341ff/3l861MuxsZoAAD4w3+9A1d98i6sDTOMpxprwww/+aInAAA+ccdRvOWDtwIADm6M8O+/+bF4/4334jc/dDvWBhnGuUamFE6Pc7zjX+7A2rDoaI2nGsdOT/CYC/bjt64plgXrd2htMNUG3/G1l+AN77kRJ7enUErBGIOXPPXheMN7b8IgU7azYozBJDd48iVn4/c+8iV89isPYtSyU5dCrg20MXjJ0x6ON7znRm9/bTDJNa6+5QBe9KSLkWuDn7zqs3jNi5+Io6fG+MN//bI9FvMGHYt/c+k5+I2rb8PBfSP8wDMvxc/91Q149uXn43EXHcBbr74N9xzfxN+8+puwOc7xU1ddi5//zifhy0dP40O33Ic//Yln4+fffQPO2z/Cn33yK9ia5PiL//C82v2++qpr8R9f+Hi85luf2LvtP/MXn8MPPPNSvOG7nuJNf8N7b8TTLz0Xb/mhZ3jTf/0Dt+FTdz6AgVKYaoMXPelheOLFZ+Nt19yOLx45iff/v9/cuy2Cdvjobffb58ijzt+Pq2+5D1954DTe9D1PxRvecyOe8LADeE5J5Otw/PQEP/3nn8Mvfs9T8bLnXYa/veEevP49N+IFX1MQLsKHbz2Cn3/3DbjisvPwxIvP9raxPc3x6quuxWu/7Wvwqhc+fr4/dAZ86o4H8Pr33IgnX3J2lND89J9fhx977mPwc9/xZG/6L7z7Rjz78vPx1EccxC/+9c140ZMfhoMbI/zK392Cc/aN8Icvf3bvNv3aP36h1X2dwuvedT2ufPLF+JXv+9rebdhLeOvVt+LIyTHe+6rn73RTZsaffvxO/K9P3YUb3vSSnW6KxdGjR3HllVcCAO69914MBgNcdNFFAIBPfvKTWFtbq1u9FZZicmGMMUqpuY2vGmPeDuDtAHDFFVcscNxWIBC0Rc5UI/o+nmoAwNYktwRre6Jx6Xn78NGffRH+3e/+K95z3WG86oWPh1IK2xNtt3Hk5DYAYJoX2/rUL7wYz//VD+H0OMfmZIqLzl7Hp37hxQCA5/7XqzHNNSbl/m76pZd4hOhdnzmEn/mLzyHPDXJt8H89/3KcvTHCWz54KyZ5sc4bv/sp+PHnXgYA+OKRk7jy1z6MzUmO0+McVz7pYvz+y66Y6fj85tW34dc+4Pb3+n/7ZLz8+e2TZ1991bW48e7jAIrjawww0QaTXOOCs9bwmTd860ztS+H6Q8fwPb/1L8h1QbQmufbOK1CcZ5pGn5PcYDzVmOQa2+W0qTaY5sV26mBMQYhzrWuXa8J4qr3rkjAtf0dlutb4xsdfiB/9hkfjP/zpZ+21N851VBUVzB9Tds5zbTDVxTmclucrdj7rtkPnjdafBteUXS5yTU7y4j5ru89lYZzTvRZv1zQ33rOUQPcu3aN5+Zu3JhoH1mf7jdPcRO+Rt11zO244dBy/+2PPbFw/1uYzFdtTba/ZVcekfO/uJlxwwQW47rrrAABvetObcODAAbz2ta+d6z4WWQfrq2XoH8rP+8rpdwN4FFvu0nJaarpAIFgBaBajRt/z8pM62EBBCoj8vPQZj8Tt9520IXsT9hA+cmLb25bKgI3RAJuTHJvjHPtKwgYAmVLIjbH7GwShPlnm2qUNkGUKJB5Rx4qHB9G2N8c5tiY59q0NMCto8/Si6RrdnSl3LOjTlL9nkbHsWbntXJuyo+s6UkSUplrb48g7rLkuzgn1aYvjb2Aa4hlp9qzv5NzEX+xFG6rL07Gk4+kf593VQdir4IdZG/oz9lpoex5oeWPvmer2+fTYdmnAZredexP8thC5MZaEcWhTEFa6f+l3TXI982/k54jj8/eewE33HG9cPy/bJiiQOp6riDP1+blIBet9AF4G4M3l53vZ9J9USv0vFIYWx40x9yil/gHArzBji28D8HMLbJ9AIJgjwo4RAKtA8JHJaa4xLNnNd37tJXjj+27C+2+6F095xEE7Ynf+WWu4v1SwaLuZUtgYZdie5NiaaGyM3PjQIFPQ2kCXO86C0LuMdZi1MVDKLUNKxiBCsLYmJcEazT4WRZ32aaKNTciUqhCsvPzNM0YvNu6X9mn/AoWSky76JHJDJAsozqUxjninEP7OvtA6/mI3BjCIE69Mud/splc75oLFgJ8vuoY066C17XSa4BpKXVOGXZsh6Nmw2zq64QBWbP5kWiUruS7v1dw/ltNcY1ZuYwzscyFsS0wdrCyn46rymYoiSmGXXXg9QQMlKfziX9+Emw8/NNd9PuURB/HG737qXLfZFXMhWEqpq1CYVFyolDqEwg3wzQDeqZR6BYA7AfxgufjfAfhOALcDOA3g5QBgjHlAKfXLAD5VLvdLZHghEAh2P6IKVvm+3Jrmdt4kNzZJ/fyz1vDwgxs49OBpAE5NevjBDatgUUc4UwXx2Zzk2Jz4CtYgU8jLjnssr8kpEkVHIFPKdqIt4WGrUTjj5kRjk4U3zgKrBEUUszZQCkwJcp8FKVicgkXHM9cUssUVLB76p71puiRWOQv1o45yUz+KrqRZ+xdTHR8F1kxVC6cX14b7nz73Smdnt4OfLxr5NqY76aalQuUqvB7qtmtVoF127t0AVmzwoAwfjtxkJrgf6Zqe5LMrDJwE+ztFq/Daos276zjvJCgMfC/gTH1+zstF8EcSs66MLGsAvCqxnXcAeMc82iQQCJYLE3SMANdp8RQsrTEaOEJw4YE13H9yDACYlC/+R5y7gWu/cqzcRrFcoWANrKq07oUIFmpZrqvhgTSf2uVUirI9ZUeEk5T10jBi0ypY8yBY5f609v5viwFTsKhjpcuwyMUSLNh9kXpF7Rjz3Crtt22qjc15yxkxbPOytZ3eGaQDWje2L95h99cpzouyBKv4zBNETTB/eAM12pGrprC41HZiYbXectpfniNUenYL+P0fgibFyEoRImhYiCAtq2fuzKdC2nQiTDe2nChYDrneO2F1TQrWTitNi8Iic7AEAsEZBB5y5UJPSoLFFKxpbmyIIABccGAd95/wDS0uOWcfHjg9LkJX2EuGFKyQ9AwyZV9IWeSpljEFi1SKgQ0RrIbsZZnC+jAryZz2yFxf8Fwm/n+X9cNOInVAY795XlBeiKAzqgDcCH+unZnEJHedv9wqVsbbRlOHK6U2dAGFT6VysFKdwXgO1u7Lw9mzYIeZ51850t1uMynlKjyN9hxHtuFCBHfXuTf22q7Os4MfkZlkGrKYHKw4+W1LnLSJG42cqcj30DPnTM3BEoIlEAjmAu11jAIFi5tc5NqrY1MoWNt2HgBccu4GjAEeODX2crDWRxm2JjqSg5XZ/IJaBaukgbwTnVKU9q0NcOx0oazNQ8FSVsEigtVt/SyrhgZRCN5CFazA5IKPrPIcLBcuGJhcsOVNqV41vWznkYPlSF1s+2lli+dgcSX2DOwf7AjCUGP3V51fux06/wGZqOZg0Wd1u+Ndm4NFn9WG0cBCPETQz8HigyKzdoBT97VpMaACpI05zlTQ4NlewJn6/FyKTbtAINj78DtGxSe9WMnOGygIBidHFx5Yx9FTY1urCgAecU5RXPa+E9vOuKLMwTpyYhtb01DBcp2xuhwsimvPFEBRiqS4hOvtGw3w4OlJ+X32sahQweqeg6WijmjaxEnlvOBysBxhiuVg2dBArmBpX7GiUJGm/pb7fbMTLGMMbj78ED70+a/aemvGxCwuqjlYhl3HZ+II7E7Az8FyeZPdTS787YX3jttferv0bNht+SNEomIhtNTUcczkwoQ5WMX0QsGarU2p+7qtMmWM2TO25PPAVMefUasIfg8u0vG2L970pjctZLuiYAkEgrkgTE4HnFrDFazCRdAnWLk2OLY5sc5Xl5yzAaCohUWb5TlYm2PfeGKglO38xwiWDRHU7n8KCaSXevjg3xg5BWs+JhfFZ98QwSIHq/juuQgag0W+s+g4mVL14dbnExsiaKzFvnMTdGGDY2Z3nUyGZ+jamY7BdkKNwd/feA/++z/e6ilS0RwsY0oLfxdSCkiI4DIRKljO6KIb2anmYFW3702PXGz0bGja4+Y4x1s+cGuU1CwCNkQwcQ0DcQVLm+I+pXuVLzsriUzdU0VNu3YhgmJy4ZByQF1FzON5vooQgiUQCOaDoGMEuE7LduAi6JlcnL0OALj/5LZ98V9SKlhHTmzbbSkFbNgQQZ9gZZmyOT9xglV88nDA0EUwVIE2uII1hzpYltD1DRFU1eR2csOL/eZ5wRJDYzzrdYAXFdZMwSLShQoRo1HuxhysGuOBtqBrj+cycFUj1oRC3VS2RpnvIti7KYIO4B393Lj8K83OXavtBNtLmlzUdP5siGDDTj/55Qfw1qtvww13N9d7mgdCsxt/XvE5jplc6DJfMqIyz0PBit0jppzXdAzF5MJHniCsqwj33N0bv6cthGAJBIK5wM/BKj5phHWr4iLo52ABwP0ntm2NrIsY6aJtKaWYyYWOKlg6kY8UC8+jafRSDznKxiizCtb6cB45WLOZXKidchH0crDgEyyWy0F1W2wCvXb1r6ijSjlYTe9ZCo6ZScHix6i8/HKPMFU3XhxLVEwuchM3xRDMH9UQQWPrpxXzuypYiH66faSVsUlLF8Ewz2vRyGsGIOygRkRN08YvFF6oRvMx8kjlYNG0Oqv2Omv5MxVFXcedbsV8kM5/3N0P1VnbJwRLIBDMBWFoD+Be9tuTwEWQEayLDhRk6sjJbUy1wXCgsG9tgAPrQxw5sQ1TdnqBQlU6PZ5inPsmF1lWHyIIq2A5NYyaMI24CAJBDtY8FKwgRLArJ8qUYgn5xafWKI/PAhUsGyLoHAGrCpbrRE3Z94qzoPZdBVOYSw4W6ziHKgZMvEOZysEqRud3d2dgryC0adfadxFsexZSylV4GuuUscm0HfkIFftFo85R0dW2ShAs7UL2vAGRmRWs+H1tB9tqdkCz2tTLOlOQJwaBVhE81JqwsbGBo0eP7trfaIzB0aNHsbGx0XsbYnIhEAjmgnDkGWAEi42mjnONESMzFx4gtWqMSa4xKvOzzjtrhAdPjbF/bWAJxMZoYDvr+wIFa5LrpJoTs0ivughWCRYtP586WLMpWGTkAVSVlUXatMdcBEOnMkqaz1nnjXe4XA4WvM5yCnN1EdTVDmkq5E/rgvjyvLPic++E6+x2hEo4kdtUiF/TdsLcq2oOVvpamzDltc2+YjlRi0B9DlbxGRIsY5zhjKdgTdv9xiYkQwTpWaE19iH+HLW5YEvKYVsFTPO9ZHJRvccuvfRSHDp0CEeOHNmpZjViY2MDl156ae/1hWAJBIK5gL+gXf5L8emFCOaFSkU4Z98Iw0zh/pPb3rxhltmXNidYhI2gDtbWtBjtrs/BMvb/gQ0RNOU2/HX8fc3DRZDaECd0zesrZ8/uhb8t1kXQEkPjEtl1QJy4q2BcwdoBkwt2DYYhVSmSR2ognSsv122v9HZ2ObznCLte+oYIhu6BSZv2yDYmut116BwrWzVtZtjfElWMfNWYQG2bBjlYiw4RtINtNQYWts1yk1m0eU6uCmIOnqPRCJdffvkOtWg5EIIlEAjmAv4uCDsAXqFh7dfByjKFCw6s4f4T2xgOlJ2nFOvYlh1ebpceFhoucn7ihg9OPXLkhlQfIjwxF8HYvvqimoPVfX0esga4kLtFWt/ScaJwramO2LSzXCyrYEVCCY1x1tt16NqZjoHUKt7x4zlYsTZoQ+clyMHSs3dABe3ADzOpLpwQty40XCHVcRJUq2DRddugJVRCUBcMPngQgtoQ1pSyhbe9HCzTmkQ2wSQGLdrlYBWfkoPlkOs9pGDNwbRoFSE5WAKBYC6I5WDFbNonufFCBIEiTPD+k9uY5AZrJcGinKMwB4uw7hUaVqVSoRN1sIpPIgK+yUWpYFUIVsa+zy9E0OWBdVWwqp1B6ngu0kWQtk2GGr7JhQsNBOCRL8+mPVCwmnOwZlcEcnaMbP6NJV3xkKhUDpYxpn3yj2Am+M8RR5BTClQKoVFKirR75zgAd7+sb3Px2aag7jxgCV1MwSqv8dAynqtELgerfZ5ZE1KDFlw5q1sXaFcv60xByohnFaGD5++ZAiFYAoFgLuCvgrAD4BUazn0FCwDO27+GY5uTcl7Ru1VwHXIiJ9xsgqtKRfgckuFy1fwnRnjI5CKSg0VYTB2sbusPMlUhWLkpnKYWyK9YiKApbZ4jJhfaKVlOzUIlV4sIYVNnbh4KVui0SL+BpsU2XeSzOfLtOul7J1xnt8PPwXLhgV1Jd3gNNRYajnT+2udgzT4g0AV1xhw6uOcINlSP3b+F6YVfdHiWNqUGLYB68kS/I1TdzmRM9d4JS+46OLJXIARLIBDMBeHIM+A6tJ6Cpf0cLABYH2YYTzUmucGwZAtZaUtehG2pcrlUDhaFpFXdAGlbvD2ZUlaZsTlRC8/BCutg9bFpL4v9atdpXLRNuyvSzFwEWSdOa+ONUnv5VhWTi4KktamJU3z2b7frRFZf8CnCRGppWJg630Odnd0Ofl54HayuYXgh6Ul18uo6f2PrftluX8tSsMJczFhbQoLF69RNmf38eNrtuKbQrGCltx/W0BPAlr3YC1h2CO1ugRAsgUAwF/BnZ9jh4ARrypwCCWuWYLkaWUUOVrFd4g+egrXm52BRYcbQrAKIq0c0bZJSsNbmq2Ap2wbt/d8WPGyNj0Yv2qadiCgpUrk2NmF9PNVex2mam2i4IFcCTKIjxjFXBUs7okefBunR/8Jh0t8/V1AEiwV1xoaZssfdDxFst50YqS62Hy6XJvPTlgYQ87heu6Aub4wmTXK/g87DtrnT5/xMLhLtAb0L0uSJq4vLIqm7HVSeYC9gHgNmqwghWAKBYC6gzqtSLlyQXpYUIkgvjVDBWhtmGOfa1sECXA6WNoY8LrAxZHlRQz9EkEwVYiGCocEEz8GiTlSYx0SkajRQXmHkvmgKSWy7Ps9hog7JInOwLDktQ7VywxUs4+VWTDVLmo+EEpKa1GRnHYZ19UFMrSIF0Jj4tnMdEiy3LeFXywEd86w0rjHGhZYW8/spWO7TX7++0DCZXLTb17I6kHyAJdUWwHcSpNuUD3wYw01pZmtTKreSJtUpWHyWGF0UyM3eCUu2eZBnWCKrECyBQDAX0KNzyHKFQgWLcnVCwrI2yLA9KRSsYaluZZlTPCjsz1ewfJOLaRnCFg8RLD55eF41ZM9fh8ICOZGbBWEeWFfRyZlN8LyRgrAuUMAqyagjosa470SKCbk2dp5vcuGTnbZ1hWbp9PE8Ex6yGoaMcZBaanOwODE7wzoHOwW6tovniFNpbSetZaczDEtKkaA6ZYxft/VtRqvl5oUwp9Cbx34IJyv8mcwHaChEcPY6WKm8xlI5a2HTHrZ5VXH42CYOH9ucaRtFEfk5NWiHsewcxd0CIVgCgWAuoIfoIFOVEdbtUsGil+wwSyhYucGIKVhhDpbnIjgMQgRrFKyYyQURFnqhp0wuNtbmQ7BUhOT1Wd9XZCgscoEMC0VbeceHktHHU+11nCa5ZqF5KZOL5jCgrmpFDLyYKg8RtC/7CGFyLvi34eYAACAASURBVIJkclFAcrDmiz/9+J14w3tujM6j40ymLvQMSJlUpBAS6dQ1VXetTdigQh3mcb12QV2HNaUGWVKmjVOUvXDBWdtUH7JYr2C5eXvBSfDn330DXp+4vttiqvWeUbCWHUK7WyB1sAQCwUx4zZ9fh4P7Rji4bwSgsDuvFBqmgrREsEIFq8zBmmqnYJGpQ9HpLZbbSJlclGQs13EFKyQ3SlWt20PCQ9ufh8FFsf3iM+9JsHiIoFNkHClYJLJMeeFG1j0w116IYK6NXa5wHTTe8t1zsPq32Vf5qmpWTB0ryLw7VzxU8UzrHCwSn7zjAVx317HoPGMMlKKBGucgaEly6xBBtz3+f8rkIrbVthbmXcnfrKgLEeRKFLdq15Hp2mCOOVhp4xig3sCC34t7QcE6uTWNvofagp6Re+WRIzlYAoFA0ANfPHISXzxy0naMspIYAU45IAWLlI+1WA4WuQhaBasMO4HLodpgYYEVk4uyIx2qY8W2SgUrd0WFrYKl4zlYpGDNo8gw7RPob9PuOv1uG4WjYHey1hWDQMGikM/xVHudvCIskEIEqyYXnvpW87aty4tpi1iIYFMuT9Xkwn0aM3sYlaAAmaXEwFVEOl/GFIMJxfx2+6iaW8RVn7prjaug9fsqP5fUg7QDWDU5T4Bve85/3jYjjs5FcMY2mfg22uVguXmTPdALbxMGXb++285eQJtn/l6EECyBQDATXOcTtnPKHasAN2JKakeoYK0PBxjnRQ5WrNCwNbng1unM8CIrw4mmOh4uFwvPC00nQo6yMWeCVc3BmkXBch0sXoh5UShysBIKFps+zZ2Cxd37whBB+h0pzKODoVnnOPeOVzE/tmljimuJzg11kvJE51zQD3WKoGEqIk/0tw6QrRWsQLnS/vTqctXtjnOnvLbb13IukLxmfymTC07GrOmQ4XWwZmt7ilQ4F8GWBGu6+gpWimy2hRtAm1ODdhhOTd7ZdiwbQrAEAsFMIOWI3P6yMrSH5gHuhZ7KwVovydLmOK8oWJopNPuYsx8naQNVKlg6Hi5XX2g45SJYbH99bgSr+EyZajSvz+pRsc7iUnKwsngO1vY0YnIRUbD4iLklh7UEa/ZRdUeKjKdSUIcvnYPlk1laj/8vmA1UsDo6zxSDD0opL5zUqUntzkGY95HKW6oLGZ3Y0Nb6fdmQ3WUpWDX7azK5ADjBml+IYMpWnI5rXegf3/V0VjvDXQBeq7AP8o7X+m7Hmfr8FIIlEAhmAk9E56E9NA9gLoJ52kUQAE6Np5Y4KeWS3Ik/jAYZBpmqOPtZk4sE2YgV+bV1sBI5URSCOH8Fiwobd1Wwik8vzE07a/FFYpApL3THV7D8ItK2I6xNxeSClE76nsI8TS54OFpu/HDB2H75tWGCZc+s7sHiUGdB7Yo9o3RS86+FriGC4TnsY3LRNgdrWf3Hupwv3gYvB4vxFj7gMcm7Hdd0m+oVtbYKFoUsrjKKqI4ZCNYeIyR7LeSxLYRgCQSCmWDKcAgDysGqvlS3p07VAOJ1sADg9HaOUcYVLDeiTdg3GlSc/TJFLoLxfKTQYIKS6AGnYFVMLobzNbmohil2W58IWegiSGFti8RAKY9IOYJlAgXLhQx6Nu3MtaxNh6sNCWuCcw70VYpUh5rUEl4jLVQKzrQOwqJQN8Lv52CZ3ucgVLDSOViITgfAyEf9PrsacMyKumPhhwjGFSxeB2tuCpZJ15cr2pLefpjHuerg120f2BDBObVnpyEmFwKBQNADFHtvDOVgqUqniEJS6GVOToEEIlhcwcrKECEDA774xiirkJ5B5lzrYjWBVUTBqk7z11mcgkUkb/YcLG0KlWjROViqxqbdD0lydbC0cb+Vj5K3UafCzjHHj7/jk/iDj97R2GbeCeUqiNH+PsJ98mPZFF4m6Ad+bcTmcSWclnOkoO0+/E5d6rqrI0c8d7B+X8VnUwHteaEuRDCVgxUlY7p9GGTbNoVNaqdgue97wUWQP+d6rc+u9b1grONysFb/t3SB2LQLBIKZQKN1WjsFKzQHmOqi403qxihUsEpWpA2COlhl8Ve45TdGgwrpGWSZrbsUDxEs2xoJEWyyad83pzpYsTDFPutr7cJ9lmXTPshc0VXADxH0au3oqnMg/+45+tX0o+pI2E13H8clBzca28xJke8omOhoG3ZtZL7JRR3hE3RHXV0xyuVUyjfDoNDatk5k4TlLE4D4dICHtjYoWEseoQ9zXP22uO8pm3Y+rWtuWwr8vhqw57XLoavLwYqTwlWFMQYa/Z/JnKgbs9hC8svAsssY7BaIgiUQCGYCxd77I8/lA5W9U8esZlKsDhbB1cFyHWLOmTZGA89NEPAVrFqTC9uJZiGCCZt2a3IxnK/Jxew27cYzcOAmIItCKkSwqmA5Es07d9yNrU3Cc12HtS5/x1vOMwKhaazQcKKjzetgpTrpgtmga0IEqUNJhYaN7aCX563DPort+ddbtxysdqqZCzNcloKVbnM6RDC2HXdvzkqwUoMQrg7WmaRgmdYDATHwe2MvDOrMI6d2FSEKlkAgmAlkHOBysFyIIB+13Jpo22EZBezCI1iBgkXEjbAvRrCUM7morYPFwvNo2iRh0742yLA2yHBgfT6PyWodrP4hgnwEOySgi0CWqahNe0Ga3fRcG1tXbBwhZHQ+gSYXweIz1mHNc9MqFIuuPc/qm+0/1dGWHKzFw5j0+demKBbO62ABxXmn+W0QKqUpEmRVysg22pKPNmFw8wQfPKi0hbVhHKjLIYwx9r6etempgQsT3EN16wL1RGxVoA2gZsig4sdq9Y8GPNfbMwlCsAQCwUyo5mDxDoczq9ie5s6mvUbBGtkcLBcixLnItzzxokoOVmYNK0zU8MEaTNhwwGabdqUU3v7jz8STLznY/mDUIGa00Wl9G7bGO1jF9hZu066U11nbzhnB4nWwtFMmPAUrYtNen4NVr2C1eU/zDp9vClLfERxkvNCwv+wZ1j9YGKh+WwwU8qqCOlhti/7y7cQ+U8plrD1tc7Dymut1EeDP1+o89z1lcsGXbRsG2bZNqYGLSU2IYMpaflVBYa59sVcVrD3wUzpBCJZAIJgJ5MxGRIgKBAPF9P1rQ5zcnmJ7ou1LNnQRXB9wglXMI5t2GN8Q4rUv+ZpKGwbl/HGu7XcOZcmNttsm44y6nKgXfM3DGn9/W2RBSGJ3Bav45GFuVHumq2FGVwzCOlgsMX57mtvp09xEQwR5Dpa9NmpzsGCXDzHVPUIE6bt21a/SOVgu5y8MLzvTkrQXhaYQwcw+R6ougm3PQUjSU2Ge/F4KMW2pmrlrejnXh6lps5/PFLdpt9OMYSrdbG1K5bLRv21cQ4G9kYOVClVvvT47IHvhkXOmDlBJDpZAIJgJlAdECha3aZ/mGvtLk4gtpmCNAhfB9VE1B6tQsGhEu74NRF7GU92yDpYjZdQJWXQeUzUHaz4ugtrEnRPniUylQ3dOjx3ByrXLs5t6o9LVEKq+OVhatyviyd3hSGHITUuTC1ZzjNZLtUfQHcV9HSdLNGAQ1sHqW2g4RbT4/vgnB6/fVoel27Sz6zk1DwAm0/r7TXshgv3bzs9jUsGqzcFy8/aGTftsjpLTls/JVcGZmoMlBEsgEMwEypMgIuQXGgbOKnOYtifOca5SB2vgcqp8BcuFDNWBSNUk19EQwTAHy7NpZ2GDi8Ss+1Os068DwrCcQsPxjs8mI1gTpmBx0Ch5mK+VQtg55pjqdiGClhSxTjp17Pk+CPTzeA4WmXJwRVYwO+oIq/GeI1zB6qa0hIQqba6S7vxZc5aGTJg6krYIuPyyOEEljBtCBI0Ji4D3+wF8nyZ4TFjH0xrixNvGle/dgrd/5Iv4zJ0PtF6eD4L1gfYIVnX+JNe47asnem9/2RCCJRAIBD1AYV808uznYBlrqb41ye3LfFTnIljJwWoOgeNqVCxE0Fqys/wnS8rKacvIYwL652ANMtfpp36TMcX2Fq++qWRuxOaEK1jGHk8O6jR5yds179pUZ5g6Hm0ULK548M62Uxv85XmIIDe54E040zoIi0KdKYTLwfJNLroqWKEK2kSsY5u1oa0Nff5ldyDrnDhTZCW1LFeW+jafbzul3Exr7lk+q265ncJbP3gb3nfd4dbLG9N8zdTBt2n3j8ck17jy1z6Mb33LR3Ds9Lj/TpYIE9yDZwqEYAkEgplAo3XGFIm9lDsBlASrDBHkhgiVOlieTTt3ETR2RLsOTsGKGz7EHPxcHSztLbMoVElevxBBHuaWa2cuskhkSnnhRhw8RLAwuUj3LDwFqzZEsPwMNtWlk+2FCGr/eAHVjgsPEaQM9XAkWvjVfFCXY6fL63mQucEbgOdgtd2Hqf1MLcdB13xzDhappcu5QOz1nFAACW1s2puMMNqgbhDChYvX3e/xNu8GGGOwOck7hfxxM50+8EOp/Xm/+09fxFceOA3Af/buZpypOaxCsAQCwUygUWbq6GdKsUK4xuZgTVrWwXIugqzQcEuCReuFCMlNxsLA6MW/NAWLd+Q7rV98FoWGffKw6BysQaYquRFEhDfHUzttmuvaXIs85x2H5g5XuEwXu3S3bBgimOpoF59hHayw6KdgdtQpkdwshxNyS65bkhhHpGm7/qfbX3x6sc+WOVhLHqGvDRFkt2lYBLy6HdNIwtq1J31fhwpkdP1IvuZuwTjX5Tuu/TpcNe8Dfg5DUvLlo6ft92WVBZgVbe6Pu49t7srw0FmwcIKllPpppdRNSqkblVJXKaU2lFKXK6U+oZS6XSn150qptXLZ9fL/28v5ly26fQKBYDa4EMFCaQpDBKlm1XhaUwdrUK2D5RcaricjPO8qRjZceB4ZWrh1JmzaImGdDHvnYHGTi2Ja4SK4hBDBTFU6PhT6GSpY05oRaC95uzZkKK5WdDGbCJ0WgaDQcLA8dWT8OlimdnRe0A88hzAEDaiooLh13rFeU0ikU2F1deF2vLxAm33NYmzQBXUhlrwN44YBDV4HK7VMG/DVwk3Q/3XPBf4zdpuCtTWmMNEuCtasJhdp0ssJ16o8jppCaCe5xrf9jw/jLz5z1zKbtXAslGAppR4J4KcAXGGMeRqAAYAfBvCrAN5ijHk8gAcBvKJc5RUAHiynv6VcTiAQ7GJQJ9/lYJW5E+WbgTri21NtX7K1ClbmFCxjXG5XHXje1SCrPtZihYYHgYK1jDA7oN4Wvg7UXl+FKd0bF66+VTs+G6UyeXrCCZauHVXNazoOHE51CBSsiBthCjyckCtftGbYYaJ/BxkzuQjaIARrPqg3aTA2hDeqYLU8B+E1ZNerKFjp7U1aOuy5/K7lXB82bDJBmgj8no01TRvfCKNv8+sVrLKtNfcsb3MdEdsJbJVlKLrc+2SO0xd1x5Of82UR+lmRep4TxlONU+Mcx05PltiqxWMZIYJDAPuUUkMA+wHcA+BFAP6ynP9HAL63/P7S8n+U869Ui06MEAgEM4FIkLGhPeXIaECwxlNtp1XqYHGCNaQcLK5g1beB87WYgqXKafTu5mFg9EJfNMGq1uLqtj7xRi8HyxQW5ItW3wYRkwtrXhIoWHUhPq1dBBPObnnYWa4BDxHknexUoWFucsELDbc15hC0R32IoAvhzb3rpVtB3IrJhfan8/3xNnFYh72GffGc02WgriaYpwZN60ME80Bx7juA4BMCf15osx9f330f77IQQXJJ7cL7uoYUhsi9EMHqtt333XWsUkhFJITzVyXksS0WSrCMMXcD+O8AvoKCWB0H8BkAx4wxFLh/CMAjy++PBHBXue60XP6CcLtKqVcqpT6tlPr0kSNHFvkTBAJBA6zJBVgOFiMB3ORikqiD5YUIZjwHq52JA58fdxEMQgQzxUIEizYtKwerr4LlhQiyDpY2Jvqb54m2IYJ5bmrr2LSug5VwdpvqdiFbxTYcqeKd7ZTBAv1PTpi0/1Xs0Ox21IcIuoGauIJV/P+Oj96BH/uDTyT3YQWrgJRXc7Di0/kgUVO/L7WNRaHJhZHQZGBhjD8g0p9gse8VZbgkWLUhgrtXwSKX1C7HJjTHCTHJNd52ze3YmsRNKvxBnfjxBLqFLe4kmkIEnZX/avyetlh0iOB5KFSpywE8AsBZAL591u0aY95ujLnCGHPFRRddNOvmBALBDKAwNVKaCuXJPSwpB2vihQj6hCDLlHUW9Opg6ULNaKIPnslFtA5W8ckLDTuTi+XkYM2r0LAxxrqHUU2oRQv9MQK3URaHphDB0aAwJagbqW5bQDNpRKH9zzq4OljxHKxKR9uqmywHS/uhPsKv5gOXH1edRwMqSqkgpNS/Jm796gncfPih5n1YouVP5/uLTffty+Mn/oZDx/HpLz+wgyGC1Xm+GtRk097sNNiuPel7hP6tey54xZH3AsHSppb8XH/oGP7bP3wBn/pyvLZWnYtgU42s3Ygmkws6/3vNZXDRIYIvBnCHMeaIMWYC4K8APB/AuWXIIABcCuDu8vvdAB4FAOX8cwAcXXAbBQLBDKCQNT8HKxIimGurFg0jbIZULKdglQqNbiYjnGDFyICCn4MF+DlYlFS/SKiKgtVt/YFVsFhI0rIcECNvCiLO5CK4MRxgqnWtHXNdx4Ej9UImBatN7gGvd8U751YdCwK/eIign4NVXUYwGyzhjXb63UANv5Z4yCdQlgSoJelue4A73ylFIFZviC+zNcnxwCm/7tBbPngr/vPf3rL0ECd7LGIKFps2ZqUVYmQ2dBGcR6Hh6qAIKVjpbft5Y7vrHtuyIYLt2xUq3yHoN6ZIJ7+uU0p71zbtJExwj33v2/4Fb7vmdjt/2SYxy8KiCdZXADxHKbW/zKW6EsDNAK4B8APlMi8D8N7y+/vK/1HO/5DZa5RWINhjoDA1PwfLvVjJpn1cKljDTEXJDBldkLpFNu1k21yHJgWL1ufkhvKyJlovPP+q2GfVaKPb+rDr0zaW5YAYOz4U+kkhguujDNPc1L70W+dgJRSsutyT1L54SGUYLsjhCJarkRbmYK1If2bXgzs8xuYVdbDCHCz/3GttPNv/5D4Cst42RNAjWBp42zW34wd+918ry0y1Xnoh1TYhgiowpomTWQQhgrO1J7Yf+rfept19320KFplcdOmJNoUINj3HfJUqfAYiOW+3IlSR73rgNL7C7OZdTuayW7ZYLDoH6xMozCo+C+CGcn9vB/CzAF6jlLodRY7VH5Sr/AGAC8rprwHwukW2TyAQzA7Ka6HQHsqdohftehlKRiYXYXgggQiWrYPFCo02Kliei2BdDpbrRHMFa9E5TMU+i8++ClbMpt06IC6YYcWOKSmTFEKzNshKk4u6HKx2o+XhC9mtH+8MR/dlR01Z51pXc3PCfXI1k6uFTW0WtEc9QXBW+XUugk0KFs2p5mDFz3s43XPXA3D01LiiYBUEvDnHZN6oVwCLz/Vh1qhOGRPWweqrYKXvEfqvrgC5n4O1u+6xzdKmvYtaxFXzGJwCWT8fiNnep8nXbkV4f5A5E2GvhggOmxeZDcaYNwJ4YzD5SwCeHVl2C8C/W3SbBALB/EDqlQvtUd7I/yBTWBtm2M41xlNdMbggWAUrYzlY5YsqrJsVImsIEawtNKwN1ofLVLD6uRby4re8k9lnW10RO6ZWwdrOMRooDAdZ4UqmDYaZio5Yx0K+Yki6CNqRzuYXcUy1yo1h2w72afxjqShElS0nCtZ8wAuRhzCG6un5zpUhuc5NvVqaMrdIdVgr4ahBDpbW1f1R0e/lE6x0h5TmbYwGjflV1RDBfu0xNfcItWdSc674rN2mYNEAUpfwNTJ9SiFnz6O6+UC6FmCxn9ZN2lHo8N4NctT49L2EZdi0CwSCPQpjjFUItDFQUGWBYPewHCiF9UGGybRwmEsqWJSDNfBzsAxcDlUK7RUsZ5GeedbuiydYNkyxZ90taiMPebPzlpQ/xnFwYwQAOL45wSBTGGZFh3iaa892n6N7DlZAsDqMdOasE++7LiK6DZpOxzlUYmPtEfRDfYggbKgxv16mQU2qPK8Pw7KdOutIWa9ghV3iUNmJ3Xd2euJ6XRTqFED6nRvDgWd5nlIL+UBI/xys9D3Cz1eb9euI2Lxx30NbuPPoqcr0B0+Ncft9JwA4gtXl2NCgYwp0LFLL1Lmt8sOzKoTEBPeHMQFR7BCZsEoQgiUQCHqDPziN7RipwumO1JVMYTTMMM5zTHNjQwBDrA0LRWQ08Du4XXOwYmQpRm44wdmRHKyOT1/F1g9HPhfd/NgpO2dfQbA2JzlGWYbhQFkFa70MHwzR1qa9SVVoZXIReZn74Vzx5enyCXMJaVuC2VGX1E45WGGIYO6YkF23roMZkh5+PcTaEk4P1Z/i2vGXoWvLsOtrGXAqXnUetWF9lHl1sOIugiZYZrb2ANWwN9ptXfkGL29sujwF681//3n81FXXVqb/9j/djpe941MA+plc8AHGGPLEM8jOryNYcyDEy0aouNJ7gsALwe8lCMESCAS9EVphZ0qVuVPuoTnMFNYGGcbTog5WmmD5OVgKzsWtsQ5Wo8lFoaw50uerPksQsKJ5YN3WLz5JMeRYtAIX2/7+tYElw4OBwiDLMMkNprlJKlhdbdpTjm9tbNp5h46/wFM5Va6T54eo+uFPe6sDsFOw6mJtDlagYAU10OiZkzQKCIhT10LD5MA3Gih73YSEkAaWQpVs0eBGHyHo940GmXcPxK5dY4rCvkOmjvdBnSmDI1jNZHgtaPOicWJ7ihPb08r0k9tTnCrdUbesTXv77XJVMzq/IdTZVwTT81ZFwXKDHcUnjyooptcfj1WFECyBQNAbvBPjXASV1xmhHKzC5CIdIrg+IILF62AZm5NRBy9EMEFcMqU8csMXW7RJRLHP4pOOS9dd2tpMkVClRStwse0PMoUD60Ua77AMEcx1cY7bhAjWqg+2M+xPD40O6sDVBM9R0CNM7jtt0uZgAZVOtfCr+cARhPg8ysGa1uRgNRUBDsOSUsplSi0lBWt9OABMtVMIOBUtN+2vy3mgLheRfs8wcGGM2rTrImybBrf6tt9E7iO7jxadZ2rz+jDzwhrnhcPHNnHP8c3K9FheHeA7tXatg0Vh8/Q9hqbnmN8mk5y3KnykqiKH7qyiYAkEAoEH3omh0B5rTsHIzNowwzgvaiTFamAB3OQis+sVao3pVgcr8VTLlE9uaJQcWHwOE8DqYM2cg1V9ES2aICYJ1gYRrCJEcJIXBGZ9GA8RnOp2CfVJx7cOBIt3hm3+TiW5ukr4XIigC1GNLS/oj7oQQWOcy6evYIVEqb7jbutese3y9cK2hNPpWl0bZpaYx9QvXrx6eSGC6fvAqkHDzAshTC07mboBkb6Xd909Qv/VmVfQOuujgUeq54XnvflDeO5//VBleirMdMqeE90JlvueIkCpsFTbrhoSZYyfj7sKcPde8cnvmeJ/mr8av6cthGAJBILe4KPCBlSk1R/5dyGChWNVKkRwvVIHi9Sa5hwjrw5WYmHFOmxEdpxj3PIULJ5v0AW0fCwHa9ECXCxEsFCwRvb7MFM2nIas+UO0VbBcWFfY6W0eDbfbZ8eIOne5iatWgDsvmeLX32raIu921OVcWDfSLF43zYacMdOLY6fHSdOS2Oi5t1wivI/qQxUhgvGQRFOGDjYpFvNG+Nv8ee6523TtamMw0cYOiPQOEeSd5QSBrc1JKs/B2iBbqotgKleKP2PpmdY2fK3NgEyTG2pdDlZuZg/pXDb4vUdGQ7HfKCGCAoFAUIK/6F3uRNEh4TWarIKlu9TBUpa4NRGgQQtHQAVmMFFO453pRYPbwhdt6JqDVSzPO3ThvEUhtv1MKZxdhgiOBgrDLLNFOWfNwbLqQ7BI2MmuQ6pILXeLi+U60E91Cioqy+wUyC581ZEi0EBxTlSphNfVwaIO8L3Ht/Cs//JBfOyLRyvb8faVUA2SpieaiAopWNXldDmQtOwQp7ocnpy1uymcTJti0MuFCPZsjzdo4W+E/p20cBFcH2W1y/XBdvlMiu5Xm2huWGEjXnzfLE0u2qaG8c2lCENjiCB/LgX71cblMa8KIeH3hx0giTyfV+TntIYQLIFA0BvxHCx4HZKBIgUrxyTXNgQwRLUOFj2Qm3OwOAFIESzuSmaJVVa/zjxRNbnotz4PvyQsOsQxJjoOWYjgIFMYDhS2JixvJQJu1VxvchFfxo78tujIxsLLcu2TU/+7f23Q9VeXD7Fs/N5HvoTv+s2P7mgb5oG6EWttSAlXUZLMTS4A4P6T25jkBvcc3/K2kyJWsZArvpzdX/n/aOBClcPltPbdBZdVIzdFCgH3e8jVk5AKhTPG5b32z8GKEzk+vU0O1iIUrHuD64KD51pVplsFyzdXaQJfLrWKKxtRPz+2X80GKVdEwHLPc41ovmJ4T+8VCMESCAS9YVjstDFkHqG8EADP5CI39mUeoloHq28OVopgVR38ws9FgmzZKcegew5W8Umj5t62F9z8qILlmVxkGPAQwVYKVnp/qQ5kFzvfuAV4OoSH9jWwBF+BCmi3afMycNcDp3HXg6d3thFzQF2hVWPIpt2fTvcNnQO6lsalrXfYMQ/z9ZJ5fQ3X2nCQlUTbn07r8mtkaQoWEbqEAgi4dhNi4Yt0TEkR6V8Hi31P3ONtXASLHKz5HsO7j1XNLQh1OVihyUXbQsN8sSaFKllouOFY0SDlKihYXkgt4uGRdSGvqwwhWAKBoDf4aJTNnaAcrIBgTfKy0HCDgjUKc7BMM4HwFKwaF0HqUNAig0DJWiQqdbA652C5UebwPbRoBS5mosEVrCGFCJKCNWMOVpOC1SZcJxV+FoZ4hd9diCDKnJv6bS4TVUVtNcFHtGPzwjp1gB/mWSxXfG7nCYIV7IP+r4SwRb7x7Re5TG69sAPN62At6/pIFU0uphWfa4GC5aa7e9Plmc0aIhgnVXx6nXmFDRFcgE374WOFgrV/raqqp1wEXZFqw0wu/6LMEwAAIABJREFU2u2vSw5Wan5dKHWuzcyK4zIRXg9WMWan2UUmLLFhS4AQLIFA0Bt89JdyJ8h9zSNYrA5WUw4WdxEk4tacg1VfBwtAUAfLhYHRvhYNatZUF6GUXY01uE172ClYdPtjpHWQuRwssmnftgqW68ysMTWrqS4PIdaZLdbvoGAlOk7eqD6fF4QIZkrBILQTbtztQpEKaVo12IKjUYJA94c/PbRlJ6WDCtNuBwVqXR5fqGBV9wdUyR7xgWFZByumOpBSn6qxtSjw+oMhHDHMvPuHrht+P06sgjVbhz2llMX2H12/nDcaqlqlqw8OlwrWw85er+7XmCihsyHFxrg6WC3b1Ubxbso5qtuGNu4duhoEy7826NqNvQt2egBr3hCCJRAIeiPMR1AgYsQt0Z3JRZ2LYKhgUaghTDOB4NbvSQUr4zlY5bLll2XYtHMFqw8hsi6EuvpiXbRNe9pFkBSswqY9ZnLBR8xTo9shUnbsXUKxorkVJig0zPpWNJk7S4YhhctyiUsh16sRFtQEp0TGFRhV2rRH1wmuAVJhQnMEp4IWn3bkvHJNxadzs4jiOvCn0zrG8DYlfvCcQX3TKEGlga2BCshgmmBRWHZf8chX9fh398+kZuNcXZt3iCARrNgzLDf1RiG5Nj1cBNn3xDp1138xn2+v+gwcZbMpjstESBZjalWX0O9VwnCnGyAQCFYX3gilMVjLsoo5wHDgcrDWBlkyB+tZjzkfdzzlFLNQd9ttNLlolYPlFxrmn0vgV3YfU53OQ6uDV2g4JFgLbn/s+AxUYHKRKdvJ9QjWMAO2q+vXdebo14W/05lVNLc5mYOV6LxU62DBWgrz9XcSxYi7KQ1llnDRLgh1OURkalMJEQxIDK07zosOcBgiWFWu4iQoVWiYli9MLpx7Y6jQFDV9ynWWdIE4k5DYvOJzFBYaZr8HKAalprk/bR4KVsrkIW/hIjhaQIgg5WClFO2UiyC1q0+hYbv9niGCdUYZ2rhSJqsw2BKG1MbCaetMb1YZQrAEAkFveDH22mBj5MwpOJkZDbIyhGeKs9bjj50XP+VivPgpF9v/ra153sLkgs1PqTmZYhbpyl92GS6C3Ja9T+eY2qqNqZCThbsI8uNb5iZ5ClamMGCJbOsjFyKYIpN1SeOh+mCnRzq5KaQ6VHxqPAeLuQjqMEl7pxUsRwZ6cPRdAc9ZLnIejSlzsLLqdL4+HYvJtCRa0zAHyydO1k0wkWsVXlO+gmWinUBym6vLiVoE6pRcz+QiloPFymFM2G8E+rvShZ1oO50d6502uUgRKWOK5wJ/b3AFa3Pc1UUw/t3bb4Piya+xat02g7XRbHXLlomkgsWvTSk0LBAIBD74CyLXGgqqatOeKawPC/vdE1sTm7fTBKtgadNYMcpzEawpNOy27atky8zBCr93XZ+HXxIWrWbw40shnoNM4ewNFyLIiVRFwYqgjiSFxVwJPDeiCanOZyoHy4UI0qefS1is37jbhSKPdPJXDX7HKn6OspocRUt0ys8mk4tQoaooAonOnSMqync/C0i57yIYbfLckQprBFy5jAGFWJeg9tP9Oxoo5iK4GAWL77+OYHGb9nnnYN1TmlzU5auFzxNS0bR2hYbbNqtNSDE30Yihzm1Vm9U1ueA5WN5AxZLvn2VBCJZAIOgN/oLINco6WEXHlEYih6WL4PY0x8ntKc7eGLXaNnWwClOIegLBRx9TjoA+wfFzr5ZDsKoEr8/6sRDBZboIEmEaZMqqkYWClSBYiZy7ujC/VCcttx2ffgpWmIMV6xj6JhfpnJKdAIVZrTLB8s5nIoxTRWza7fzyuglNLsYVguWrPCmnvybzi0GmCuUzQtAqIYJLVrBS1/igVADzSGd/bVCUVBhkyuVg2ZyevgSLfU+E4LZxEVwbqtrl+oDyQmPELXUcSUTLeYhg2xysFgMyTWY9tXWwzOw5c8uEn6ft7qNYfuAqP9diEIIlEAh6w89h0a4OlvY7rGuDwsJbG9i8nSZwQtHEH7hqlbKBz4IwN8CRuGXYtKsIweuCukLDi45w5NtfYwoWDxHk5iXcRTBlalJrcpEgNbmuzk8hnt8TjqhW9+nqYPk5A8XyO0ywyv3PO09lmYjlvXGkcrDC9emTiFUYIkjyZBhuWs3BqraraFvxSW58sZH3YrCjPmRvEahTQLRxNvexzv76sCBYmXI5k86Vrl97+H1xYnuC//GPX8Ak154qXKdM0bGet4Lldehrcq3CfdJAzvY071TcHGgeQKB2hct6+08MAlGbydSpbZt2EsYj3HGDj5Sp0apDCJZAIOiNMATEr4NVTKc6WIQDPUIEmwgJJ0iJ/rwXZkj5UMt0EVRKWZLVZ3fORdBUXswLdxFkDY6HCAYK1oiTrT4EK97BsApWixdxqkOVDmcqvnPrft6xBnZ+xJg6Iqs80ps6/nxarA4WIewwT1KFhgPSkyJBTuEK2mFD6ly5CL5fvm4sr2SRoN3U2dwPMt9FkIcIDjNVuqrOv9Dwv9x+FL/xodtx8+GH7PZGDcRJt1yuK/jvjytY5XLBPFJHT21PK21sQqjY1LWrjYIVpn0aY2Y+X8tEeL/HCOtedREUgiUQCHojHI12dbDcAzQkWGd3VLBybRoVJt+EoTkHS2W0bHXeIhG6F/ZZV7M49nDeosAJHI12D5TCgfUi3HOYZV59s3P2jdjyCYJVm5MR/96lIxvLlSfFwf3P91P8w50lw+V3+vXvFKydbkl/+CGf8fkZG4yozvevgbHNwQqJU/FpFSpNRCpBsIKzS8d6OMg81dhE2k8d8uXlYJEKUJ1nEgoW5WZZgqV4oeHZFCz+HiCim7N7Z22Y1d6zNnyxXG5exKEp3y/1PKHfc3I7Z+u322edAyDBhgj2yMHKjWEugu3atJMIj0d8oAKVaXsBQrAEAkFvmIBgZapQk4qRquLpT4WGCW0JlrM110CDzQUPC0zatLOnnSU6S3QRLPbrf3Zb13WCwg7IslwEKXcDKIgWhXtSoWEAuPDAGp5+6bmV5UPUmYWl8qSmkU5uCtHwKZ0O+aPFOQnm4V9hW3YCTfVzVgFNI/xWgWlpcpEKEazmYNF0f3uOgPnTreKTKY9ox/KaSAlalqKQCmsEimNKIZZhuFqmFIYDheEgQ6ZcvpPN6emtYEUIFrvX1gb1xIkTMWB+Awi8w16XgxWG3NKyp0sFa1BeA23ghx3XK1TJEMGmHKwZc+aWiTDcO0amlm0SsywIwRIIBL3hj0abMgyuVLAoRFApjLwQwW4mF0Tc6hAjT5VlIjlYoZvgoqFmUbDK32iMqYz0LTwHi4VSEmHKlML+0cCGI9Fo+Eue+nB7vgeRgrGEsLN1yz0P4SO3HgEQvpT5d79zXYeoTXtAmGLqmFM1izbuphws1yFc3Z6IZ4wTOZ7GlCYXiYua1iDDj3HC5CIkISmlqil0cJAFLoKRjuE0Mm+RqMsLyk1hOT7IqioB3b9hDtaIlYDoA77aeOqOBe2eQtpS160zuSiXm5NVOx0fIniV/SbOG/1PBhcbDQqct80WAzIul7T+eMSW0Xq1XATDQazYfbQXBo5iEIIlEAh6I1QXeA4WPSwHA4X1HgpWlxwsz6a9ptBw+H2ZLoLFforPXnWwPBfBYN6iXQSZGQgds2GWIcsUDqwNMRxkuP7QMQDAtz/t4VHFK0TYYfm9D38Rb3zfTQDSHYwm96267dN6qRFml4PFXATZQEGxTONuF4pl5/osAuGgTHU+2bTXr28VrMYcLEQ/w+1VQrHKCcNB5lmxx1TPyQ6FCBpTJf02RDDIwSJlcJgpjLIiBHMSKFh9++v+PeqcPm0O1rA4mSniRO+KNUvE5hP7xvPoYttMlT2w+X1kYz/MOuRg8e8pglWfS+rXwQq3b5iL4O5/Dvgh1rykQfXZuwqmHV0ghYYFAkFvhKNQRR2s0qadCJbqa3LhQuIaFSzVTLB4hy00m1geweqvmLmctGqnatHtJ37sKVjltP/9Gx6NKy47H+ftfyT+6GN34rmPvQAPnp6U66UJVtg32J5q21n2XsqsX0SqBXUs64hqXnbUUyEqlf2U3y0Jtss3j0gvCynXs1XC7CYXfqfYKljTuIIVFgFO5mAF03PWOefKZ8zhjULtlqVwhiSV5z8SQR2ELoLlQNUwyzAYKCgoex2NZg4RdN+JlEy10wpHHnEaIAQ94+lZMTcFq2zY+miAU+O88swgTp4iWNvlNdXF3dC/vhPtSqimsW1UcgO1sYrjnGsyLwTtcrCWO0CxLAjBEggEvRGGWGWZi/2nl0iWoafJhfvepPjwTny7EMHARXBpOVj9FTNahTsxEVLOifMCb3d4zH7uO59sl7visvO9ebzTFCLsXExybX9XKgcrDzovg5rDWITSZLaTVEwLX/jV/fg5WGHdrPT+loE9oWBFQoM4ihDB9CBE2EGb5O0ULBsyGLq5G3/5cP1hlnnEnK9Pq3QpgD0PhPfEMJhH92nY2SfDodEgg9YmUmh49vYQ0c3Z4IRVplIKlqH8sMXkYNH+Y2Q0tr+pvbYcAd2eTtEGqWdXrF2pn8mPU+x6pWfqTocst0GYcxkbJLIhkyv8XItBQgQFAkFvxFwErfsaV7AG3RUsz/WvgY/4dbBSBIt/94nOkgSsmWza+Us1fA8t2gWRm4LQ8U0dZwDMCCNLksmwcz3OnTtiKoyvLvm7sn1jKkWOq4WGUfnO62CFIYI73aGxBVBXuCPSFCJoQ9xSJhekOlCIIJlcJFwEw9yrFJGqhggWn6NBESoaq9UTkrxl2fjXOdVpU9ynlAvLFT+lgP/7BY/DL33P0/w6WDOaJvD7gs4DLydBpRpCEhy2mZ4p8woRtDlYCfOMmJpCbQccWVzrGyKY+BlNOUe1dbBYiOAqPAf8Z7k7JrFiyqvwe7pAFCyBQNAb/Hk41RoKLneFXmbDLLMvuH2jQdK2O0RMcUou2zkHy19vFRQsr9Bw8NJduIsgO05Z1vwbuBFG6nRXFKypjnZiUx3yXBuMqtFGFtPcH62m7fphgdWXPA8bDY/1Tg8Y0/HZK4WGY8fT5WCllU9eQJZMFaohgo6s80GJag5WPfGyltg1oU196/hsTXIMgiLdbVCnApKL4IA9LwZlXuwgU3jyJQcBIMjBmk0R4Zcj1SWbshys9fJG3Q6LQZeg4tKWYM05RJDePxWyQvdTsL+pJViFycVaqfi1wVxMLrxrrLr9WRXHZSI8HtFQ2573z26HKFgCgaA3fPmfRp59BSvLXAz+gZbhgUCoODUvTy/nlOGDr4j5uVDLN7nov25YLLeYt2AFixEmp2ClXx/OCMOFFI5CshP0Dia5ZiYWbnpYCsBNr28zTwbn+0yRt7AOVpZRx7y9arZo7IUQQY8kR46nDXFL5mD5640bQgRpnXQOllsm1s5B5oe3xQjiJDKvDX7o7R/HWz5wa6d1iv2wdkaIIR/Y4I6D4aAV3W9r1jShc1PsPgm+yUUxjRSs0OnR/gbtLOSLbcyZYCVCD1Mde6dMFp+joWpNZvgxbDa5SLQ78fyj7a+qTbsxLkqBH6emnLRVhRAsgUDQGyZ4sbr6K+5BygsNt82/AropWIBvJR7fnv/Jl12+yUWfHCw3ylyxaV/wk3zACCknIMnlmeJFHdRwlD7sXEy0I+WpML6mzjkHTwbn2/LDAqv7sWGjoPpH6dHkZWMvhNKYxPkkaFPatNfkYPH1JkkXQbYf4zr74R6t0pWwbw/D1mKEe9rQYU7h3uObuPf4VreVyv1Su8KBCm2ciyBvI00nZErZYzec0fabN4FICc/B2igVrFBlDNs8tGR2TiGCgYKVB0pVqnB3WMR6NMha59e1M7nw91Ntt/v94RKegrUCz4HweFhr/MhxWoGf0wlCsAQCQW+EFtaZUoAqvrsRYGVHMM9umX8FhK5/zYRk0NDxd/lPVeK2/DpY/dYvEterL6KFK1jK7Z86Y7UKFnMaJOEqzNkKOyyTqY7asPuj4+3VJG2MV3/N7jMRohbWwSIHwjYj0stCVwXLGIOtspbPbkGY9B6CwsVSSnRIsFKFhlNErhoKSG0J9sOeX3wbeeR6yFneURfkup9aU6izfrv4PMUGQrhy5xsHuWPnCg13bordNsGaXEQUrHQOVtHm0ZwVLGuykcrBsi6CfrtCh8pRhxBBP+covk5sICncP52reA6WH7a6mxGGYdNh5IWnrZK4xxiWECyBQNAblReIohws1wniNu3dQgR5SF/z8oNGBatKbogjLC8Hy29Ln/Up/NJT4hZdB4uFCLZRsDJLqjK7blXBCghWrlmoSHy5ps45R5Gj5e8zNAiJOQoSCVaqKDCbch3cCaRG3FO45gv34Zm//AGc2JosslmdwDuF8RDB4n5P3SJhiGDKRTAVWto2Bys3xhbkBao12Pi1NGmoa5QCV/q7rcet1f15xpTKsQqJYV2I4Iw5WJ6C5QgWHY/1Yb2CRflhYTjmrKDft57IwbIKZCUHyy9evTboYnLR/LxoUjxzHSe9plRiB9lshHiZ8J+38XuxrnD2KkMIlkAg6I1YLhCN/HMFi2Lgz14ftd4278C34Q9cZYmBd5x5e/nnojGra6FSyobe8PyiRfNDXji4TQ6WKm2iebJ9xXAikoMVMwvgl9i0pqMcYqpNVTULcrBM8PIHfAWLOjSx5XcCXRWsu49t4dQ4x0Nb7SymlwFvRDsaIlhfB0sb44V6pepgtVU+nZrg7yfXxbVLzQhVKu+67FloONemErbWBlSCoNhnQAxLImVDBK2hQlDOInPX0XDGDjtvg0+wimkbozIHqylE0CpYcw4RTORgWeOSgBTRYr6LYDsC6g0gJF0Eq8ty8BDQWLj0gN6zK8CwQsIZc+FMDXKsOoRgCQSC3gifhzwHi7uBzapgtSFALiytfQ7Wsm3a56FgFSP48PKLFm3THqtr1eRcWJCxLBlSWMnByp3qmQqz4Z3RJpLBO6F8n03qWFgHK5YrsFPoSrCs6+CcclrmgTA3qjKfCEIyBytuchEaKHj70X4nj4P+jakbRV2/4n9SqWIJ+dOO58XuQ5veIYJh6CKfp5QLzbWdV2285xx/Bs2eg8UJFj8+xXfKwdpOmVyYwEVwXiGC5e5iOVh88CR0JyVMbA4WkZ3mfbapg5UyXOFtiBFo+j7I3PNptyMMsY79HneNLrVpC4cQLIFA0BsxBUsxm3bnIFcSrE45WN0IhK291GDT7hG3Jdu0q0gbumCgVOnO5StYi7Zpt9blzBVwUFflt2xTxkKsQhfBah0s7j4WJzXhSHMdcmOizoWpDpBVsFgdrLAw8U53aHTHjjx1VOfVYZ0H/M5sdb4BvByiENyhFHAqw6RSB4sTIL/YdLi/cHlq54ApaWFx2Ngh7Rpil5uqI2gbaOMXz/Xb4JtccEI4SAzKpNSwtuCr0X081dU6WHUhgoqZXKRytbqCzrvLwXLb5cdtmvjOc7CAdiFsqQEcv131hKIgWFVSR21W5fldhZC68BkbO+5W0dtFz6l5QAiWQCDojfB5WHSMiu/TXNvOCb3gDva0aW9DH5rC/WLq0bJt2p3RRr/1qTYTfwHT9EWCq1ZdFKxBhgrJJoSd0WmkYwYEChbvnDd0LrSO5315ISuR9jgrfQWDdN2snUDXHCxK3t9NHZcmwkoEITWoQoM3BG6qkLLxrze58IkTX4cK9gJMmYmEsdp1uhKsHgoW7T+lOlHkgDW5YMQw9uwD3H3S9/KOhQjykgiUg5U0udBFe1LGHX1hTS4iBNIL5cvj1wcPEWzbLp24BmPLpK6XXJto2CYtTuHXK8CvKiHWEiI4RyilzlVK/aVS6vNKqVuUUs9VSp2vlPqAUuq28vO8clmllPoNpdTtSqnrlVJfv+j2CQSC/ghjwBUb8Z3kLo58/9oADzt7HY972IHW2+4aIjhsUKNcDpabtko27UCpqpQ5AmE+xSLBc7AyVX+c7Tpl0jotH9akqrgIstCiVKJ4nVlBiELBCvdZTRp32yOC5cIhtfGv8Z3mKW6kt90IPy0/L9OAeSBFfAhEEFICacpFEPA78Nx2nf/+cI+pcC1SfMLLvK6ocK8crI5xUaF9fJQYsoEQnme0uBBB952H3dH35hysQi2cf6Hh4jPmIsh/alLBYiYX4ToptFGwmgpTk8FKuExun1HFM3k3DZykEA6oeC6cVskTgtUXbwXwfmPMkwA8HcAtAF4H4GpjzBMAXF3+DwDfAeAJ5d8rAfzOEtonEAh6ohoiyBQsrT0HuU/+wovx0mc8svW2/VypFsu3roNVDZNZlk27bUPPJ2+WFXH3xhgvp2nRBJEbhDQRWULhZMYVrCBcL3iXxkKLwuU8glXTuSAXy9BYIzStiO2Hk+DdVmjYup6tsIKVynchWJOLljbtE9Zp52TLK2Rak4NFs8KWUIhg2IqU4hXbdhNyU61p1wRafJQIESSlKnQRNCWJIfDvozmaXBCmnoLVbHKhlLK/ae6FholgJXI4U+6kfUIEUwNCsXbVKVzU5tQg0MrkYAWDZTHCGHOP3QtYKMFSSp0D4JsB/AEAGGPGxphjAF4K4I/Kxf4IwPeW318K4I9NgY8DOFcpdcki2ygQCPqjEiIIF1Izzc1MuU2e21+L7TSbXFTJFAkcy7Npn0MOVtkp44Rl0e13hYO5ZXvzOsMsY66D1XwogjHGcx9L5UnVhXp52w46oXz9VGeKpvMwTl1RvJK7XAq6mlwQ35jsUPb4R249gmu+cJ83rYmwUmc7FSKoTdzkAvDJVtpF0N+ercUTC7XLqkSvLpypC1kist+dYJUKVkJ1MqY057AudK5tqdIXsypYMWKpDVewSpv2mjpYGQsnXlih4USIcUrBciYX7XPU2jwvLLFInHvugOoNAmlGsDK1Ii6C/nfeZqvkdXyurQoWrWBdDuAIgP9PKXWtUur3lVJnAbjYGHNPucy9AC4uvz8SwF1s/UPlNA9KqVcqpT6tlPr0kSNHFth8gUBQh7iC5UIEZzFf4Gu22QzPD4ohanLBlJllwHXe+4YIUqFh3+Ri0c23RLRUsAZZugNs11HK6+jx9g4zVSFO9K/WgcrE+lptbdrpRV1VzXzyxjfBOy/0GS6/0yPG3QnWzipYv/J3t+DXP3ibNy2lSBJsoeHE5WWMb3LBzS08BSulfCYUrJCDWgVLhddQ2Y4IB+hymKlNnXOwbIhgSsHyXRi5OQcni/w56HKw+hKs6rRco0qwphp/f8M9OHxsM9rmeRcaJiKzHlGg/I5+3PyCrqfRUFXWSaGN4t0UIsif7zHFnUJXV4GPhM/PPHjuF9PL+avwgzpg0QRrCODrAfyOMebrAJyCCwcEAJji6Hc6qsaYtxtjrjDGXHHRRRfNrbECgaAbwheyYi/2Sa5nUla80dYWNhcZK64ZQ4zcZEyZWQZiKlq39Sl53FeEFu0i6IoLK6+IaR0GwbKh4sYHqXknmYcWAekOSx1poOUqJhc6nSPhQgSLT3LDTBkn7AS6dsqtKcYO5GBtT3Pcft9JnN72a3C1UbDq62Clf/9kys9V/FoJV00pUrlGjxys9sfZhkX1DhH0QwD5fKWqOVhhcXIepjyyClanplTa5E+rhghuTzVe9Wefxf/8xJ2V9Yu8sarb3yygY7teErzUdZAKHaQQwfVEOGZ0n5FnSoimEEEeoRC7X6hcxmq4CPrfYwMfsdIHewGL7lYcAnDIGPOJ8v+/REG4vkqhf+UnxRDcDeBRbP1Ly2kCgWAXInyB8I7RVM9IsDoWGibFJIWYycVOFRruXwfL1Rjj5GHR7eftJuLUBGtyEXERHA0yrwPsKw+hc5/77iepp1/GtJyfp+Z3+sJtx0wujEk7Gr79I1/EOz/NAy4Wj6bQohBd6jN99aEt/MnHvty3aRXc9tWTmGqDUyHBioQIefON8dxIQ1B+XQzhdRTbj6dgsjC28HKisLXw3qLtpmp4tQVxiL4KVsr5rzCMiLkI+iHbnslF1j4Erq5NHNOcEazS5OKhzQm0AR7arJJuXgcrtNzvCzq2ttBwixwsX8Hyj3WbUxV7poRoNLnQ7lzFCnOTu+VOu5q2QSUHK3Lcm1wVVxULJVjGmHsB3KWU+ppy0pUAbgbwPgAvK6e9DMB7y+/vA/DjpZvgcwAcZ6GEAoFglyF8QSjlCMwkNzN1/D2lqcV2mhQsZ3Lhpg3stOWGCPblnYPM2bRzA4c2OWqzwLNpbwjF5OsMlFPXONkJR195zsVU1+VgsVCempdxLERwmGVl3SG3XFTBsjlmLhwzXAYA3n3tYfzN9ct9PXXNVaDl2+Rg/fXnDuMN770JD54a928gw82HHwIAnBrnfpu8Eezqesa0yMFKESyWg8WX8OpgNRBs/n9Wa3IRV9/aoitZtvugwYOE8QK127nQubalagvOqmDFOvq5cT6OWRlafHxzAgA4sTWprJ8pNXeb9vA5kFJPG+tgDbvkYFUJUWqZ1O/kA2ihAgQ4E5NVKMxbdRGskllHtJbbtkWjfVGa/ng1gP+plFoD8CUAL0dB7N6plHoFgDsB/GC57N8B+E4AtwM4XS4rEAh2KcIXhJ+DpSsubl2QSshOYdigrNTlYC1bweqfg0V5RM75q9juXJqXhAsRBF7y1IfjnH2jxnVIwaJrgJOd0UB5HQc+Ys3r5wDp0eW6l7G2HSuW91XuM1XEmHJ/CKrct2fGAb+dWwF5WDR6K1gtFIHtsjO5nXB664qb7ykJ1vbUFpIF6kMEeS2y1GBJmMfBMWmRg5UiVdUQQb/QsJte3Y6d1yVEsCNZdu0sPkdZnIwUNaViOVhBiCD7PmsOVjREkA2UZEphbZgxghWqmkTCSGmaU4igVdCKEMFppHNf9308Le7vviYXqVNrCw3XzHeFhlnbyu+D8vyuguJjguMRe57T6d5rIYILJ1jGmOsAXBGZdWVkWQPgVYtuk0AgmA/C5yF/sU9nNLnwOwMtFaxaglXd1tJzsMr99D31xIg2AAAgAElEQVQqmSqco0IFa3kuggrPe/yFeN7jL2xc57z9I5y3fxStgzUIHLB4xzjXLW3a6xQsQ6P8XMFSFQONUCkLLfzDnAE/XFFjc7I8gsXD2dqGldExbrP8dvlbYlbam+Mc+9YGLVtagBSsqTYY59oWm63Lo+Mj9KlwX2PSyoBXByuhUKQUyXiIoKoM7tTV7OlCUPoTLP/ajilviocIMsVtEBlc8rbVUzlK27S7fa0NMzy0FSdYVKNr3iYXYYhgyswiFTpIAz+dCg3XkHY73eZgpefHCg3Tekq5kh27HeHxiNm014XdrjKW1K0QCAR7EdUQQWdrPMn1TKFrXRUsXnMphngOVnVfi8TsOVhuFHC41Bys7vv57R99Jl7/XU+x5HWUcbKTedfOOAwRZNtJmxWkX8Y66FgBxSh0fQ5WqG5W67aERYe3lkiw/FH2diP8XXKwSLka5/5v+viXjuLpv/SPOHJiu21TAQC33nfC3o+ntt02PcIcIQeAr4SH0MYkO+DjhE17ytygj4LlCEusbdFmRdHbRTAMEQzWN8blSvL5oU17TMHqy2vix8INCChV3IukYD2UCBF0Nu3z6Wjb50CkDlZKyeThpHQ9rVkC2rzPNq6jYf2n2Px6kwtlB9t2O8JBDC5OhiGCxvRXUXcjhGAJBILeCJ/vRQ6WG4UMax91QcyMog6F41c3Baupdta8YQsbz1hoWBvjEZaFEyyWl9QWF529jnP2OQUrDNfzR4pDk4t4h7ipSC3BmlxwBavcZ10HO7zmjAmX4ftYroLlhze1W4fa3saVLRUieNcDpzGeahw91Y1gnR7nOG9/EUrKjS48klpRsGiEvi4HyyQ7lqlCwylzFE/NDLaVa5R1sILpNl+k2oYualRTHk56veKT7v+wHbkpDBLonuWEkP8WfnyHWbUz3wXRHCwW6luoU45gnaw4SxbP4kUVGo6F+KXqYPHrZlF1sIjopX6m1mAmF9Vtk9HQCvCrWgWLjnWdy+cqQwiWQCDojfCFw+vXTHI9U8c/Ndpat3y7HCw3TUWmLRKzKmau0++Th0W3n0KL+oQi2kLDYbgeu3S4vfY0rzG58EZ20/sMO1bFPrPKCGkYfuOHj7oOwSDSAdUa2JosLys7ZfZRB+rItVEErIIVECya3lVVmOYaB8tcvVNjRrBqQgRpFg81DqFNjU17nrhuPJMLRJeJhdoNsmqJiLoQweI3tDtOs4cIxlWnVIggqUQET8Eaxh0Ju7aJgxOsTCmsDzMcP53IwTLGWo8Dcyw0XO6fXAzb5GCFChZvV5sQtjaDQPycpLYRJYUsRFCtTA6WP6ARUwvrngmrDCFYAoGgN8IXBLdpH091pdBrF4T5ME1oVrCqKowlDiticpGp4gVU5GD5OU2LxKCHghWuG9q085fqJHB54/zhs195EL/34S8CKDr5bUaTQyvr4rsqXQTjakYRIui2oUBqobs+TNA52KkQwa51sNqFCOblp9+5HdvQwfadXqrVdi4RrESIYIwcANUQQX5ejKmaXFAIWNJFMEG8YqPpBFdoOGxjvO3h/BA33n0cN9593Ns+MLtNezXM0rnMFftx+0vbtM+mYNFP4BELuTb2JCgU5+hEqVydLI1P+PqqdBoE5q9gxepYeR39RA7Wdq4xzDL7vG5DntvkYDWR6ykjWHwJ2j/VF1yFcDp+X4UugjH3wFXIK2sLIVgCgaA3wj6XgusMjafaIwFd0dXkoqk+E20iloPVl/B0Rcwqvtv68RDBRbdfzdBuClXyCiMHCdoT1jHmI98A8N5rD+MtH7zVzrMEq6YTRi9xvs+hzcFyy4VqRpj3Z8AVAb+zk+vl5mDxTkjbUd4unfhxg4I16eAuSIT5nH3VEEF+bqqqUfEZKljc4l+b6rnfV7rEpUwu0jlYiC5fzCtMLqougvUKVurc/Mrf3YL/8re3eNsvlu+m1tDio4QxBblh0iFz7Y2XvuADU/1zsFzHn8BLImRZYXJBhyzXBqeZAycVQaYCybMUGr7n+KY1WLFKdiQHK5XTGBYazjJ4ZFVrg2s+f1+S3Hhhp4nj2XQNaWOipJfINA1kroLaE+a8+iHf5WcLUrqKEIIlEAh6I2ZyQS/x7ameMQfL7+w2oX2IIA8D6x/61gcq0oYusLWZmIK1jLYPZjhOZDRBYTpA0bmOuXUBvvsYUCgr21NtlYs2CflhGBXtM7SAD8NXeC6eDccsQweJ3BJyrTHVxuvULxJ5gjDUwZlctM/BqhKs3NtWq/2W55MI1mkWImjsual2EHnODr//+XUXM7kggjVO2LSnc7DixAtoNrmoqvf+/BCbkxwntp25w8whglnc5IIGCgbK76BTGB6BftaAOSX2z8Fy27Lt8EIEfcMZwM/D4oMbw0zNZHLx6x+4Da++6rN2uwCwPqyqfal8rPB4DrPMGvXk2uDjXzqKl//hp3DdXcei+2+lYNlzEv8N01xHwzbpNs5KM6kV4FeVQaxYofGm4uOrimXUwRIIBHsUdSGCs9fBin9PobkOlmujm7ZTOVg918/I2c6NYC+j7dRZ62MG8pKnPRyZUtiauhHrQaa8jkNocsGvq/FUw5ii85xr4xy9ajqD1p556Iclnh7n0aRx2l54zdkQwUxhqsPR1+KfzUnuhSIuCm0NPjg62bQnQgFT0+sQEqyTkRDBMEwUAEy5C6X8ouF8oMaY6u8nC/k2LoJ1558j16Rg+b/NKU/+9GGWYZzr5HU5zQ02uWrTIXwztn9blLfSbr9kBSdYMZt2TiJ718HSVQXLdwNVlXvkxNYEFx/csG2jZ8tokM0UInhie2JDUqc1NuspE5Rw3wUBdceSwhxTrpp1IbCEGLHgKMoaVJV6P4S2XsXfLQjzaWMkN2UktOoQBUsgEPRG+DDkJhfjMn69L7rmYGWZqs2litm0L9tFcPYcLJdHRMd2GRbzVunrsa+DGyN8/zMvZb+9OO5eKA63ac99m3aatz0tCBaN7NYSLOpYBbXCcp020KiGCLpwTFJUYp32ZYUJ+snh3RSsViYXrA7WtV950BoSjGcJEdy/BsBXsKiDNRpkSQWLh7gVoWPB9gN2Q53RVKHhdB2sdMeOCEm471RRVEdoEMUk1x7Bou30z8GKkyIKEaRnDC/m6ocIunbPHiJYfHIiXFGwhv674KGtqbc+b88sJhfjqa6YJ6xF3Ak91SqPT6f2cDWQrrFjp32refdb0tuy0xtCBMdTjY0R1Y2rbtu5CM6XjXzmzgfwM+/83Fxzu/i1oYPBEauweyrd3mFYQrAEAkFr3HLPQ/jobffb/6shgq7DP0+TizYk4see8xj8xxc+Ljnf5WBVQw+XXwer3/qu+K0rNLwUgjUHpY8riCFZqbNpJwVla5J7OVh1I/8pkwtS/wjGW6d6bWjNQwR99YM6T1vjJYUILljBIiK7OcnxQ2//OP70E3cC6BciSO1zClYkRDCrhgjSf3SN0Pcwjy8kjKRgpXOwml0Ew04lmUKEgyGxUXcgXfiXMNUGpxkZjzmotYHrsNJ9EM73a0rxkEYuIvF7uim8sblNVQUrZ0o0FRrm4E6C3OFwNFAzKVjbU21Djun6sgpWUNCc4BGv4NoqLO+L79q4AYdjm+Po/lMhqBw8Ly42TxtgoyzMzYebaD26P+ZULszio7cdxbs+e6hidDML+LVhguiE09tT3H7fiahKtxcgIYICgaA13nbN7bj58EP40GtfAKD6glBsxHc8nU3B4v2aNv36b37iRbXzYyRh2S6CsxK6geIhgkvMwZohRJDALfEHyk9kD5PPtSlzMbRx9Zkm2iNYde9h6jCFNu11LoI08k/go/o0yh/LFeChj4tEH4LVKQertJw/vjnBeKptzSKa3iXXjJY9e32ITAGnt6uhcXGTCx4CxQgWM2SYalMxQbA5WNxFkJNhm7sSr4OVMtzgA0Z2ujbeugRrSpA4N9NcB8YO5fQZFay2LoIxhRYo8hQVu9b7wBhTOVZTHRQarhAsPx9tfcjO8QzMYZJre/2FocKeUpJQMsPzMWQKX66Nvcb+f/beO96y5CoP/ar23ifc2DlN6BlNnpEGgUYaCQlJHkkgGL0Hxgj4CcvgHxgMT2R4NthYzzYYjAwm2OaBCRY8hJAJBguhhCQURmg0aNCgyTl2DjefsMP7o2pVrapd+8Tbt/t27/VHn9vn7FA71V5rfd/61plKBIv9XXFCq4J0gDU3Nkh9eduKrbH5TXlpnuhlFkGb1niApRAs+9t77n4Gdz95Gq+5do8dw0UUYNUIVm211VZpeV7grsctYrXWTR1K1KAarDQvpqzBYgjWJsxUg2qwtii+2iSRCy3TLrdu7HT+pwlEOT1S9Ziyv/W8zLLKtlskFFBICq/BGhRk2D5YdrxxROifXc6n/PnS4ISmkcPP92hqsHpbH2CN6pTT8Y1Wg6WOY1kHVnRcdG188YtBRg5yHAnMNmMHwaJLncTVFEEhbO2TYAgL3fM9zwEnimDPk2On5clxjKUMOtaRFKVGw7m+B/2cQlbhHFf1pSLrZ8o5N5Q9gyyNR4syKowVappG9VLa/9N6PEESGQqmTXxMXINFQV2JImj30fRFLjyKoDDXeLoarF6a20a+ejvNSAULDpJZ8Tz515UfV+FQBMMI1ij1RLS/YQGWEOUaJjUmnBMVwb7e3jh04GFGwydKIw+gTq720E3dhu1TCEhecFYHWLXVVlulffqxk3jbf/8cHj22AkA1Vu1VSN0C5f410xT/ywCdZRoLIVihoOtcGncaJ1tfMOd162qwplERJOMCH75z0PcCrLwoSvvq9HNPRXCUAMvrveXXYDn9V/x7w/bBImSW061o+BtbVIPlKp1tfqNhCqQIuaLjIgRrLBVBCmgiidlG7NRgcQTLHxYdIk/UcLqg34iWbv1ISjQiWarBMsvnbhbd3x8pTHKrVhG0v3Mb1kuKzgmdCweRHCOw4WMOjSPPC7euiiFuoeQSD7SmoQj6cz9vtyCEfRaJNlpFEYyj6WTae1luagDpvBIaNEoNVgnBilwEixD16hos/nf5fCqanP49cJj0HDaisnKpERMRpCK4uQEWPVf9TeQeuoi1GzBu6GeBJ20vJopgHWDVVlttlUaZZ1JO2uhn6KXhpqGAm20G3KLncU0wYuBm9HmyIhccGZs+cBjHQlLx45gQzFkUWzf2acU5+DbIeeYvWp4xTXPVaNg/rm6aIRux0bBfewHYDGq1yEFRrsEqqAZL0VRpce7UbpnIxQQIFjmRIyFY/YoASz/v41EEdYArBWabkdNomK47BbzceIbe0mkZghW5YhYkXhBLgSQSHkWwKAUhPhXQrQ9xj4EQH/+WpzH7p9TUPFVSBDXiqc9rlcrhMPPrC0PURo66mGbThS/TrucP9lxOCojwJARZximCsDVYu+caEMKlCPJgeByZ9keOreA3P/WE8x2pjma5kgQXgtXHcaSqQkXQT17wIDsrCnNvn6lAsKpEdOz2B/9uAqxYahSdreshvJuN9tCxbWbrCRp/JKVqtcEOiCizvObrYpJprwOs2mqrrdJ8FbJOP3OyWyE6BXdSN6/R8MSbKW0jVGezRfFVcAzjGNWgqL9d5/Ncmp/tnsR4/VkkhZNB9u+pAkUpOO/2Vd+pJFCb4FtqHGpX5MKnCPJNFIUb1AlBohhFKWOcnocAa5I+WFZBbvQ+WEseRbCqP9Yg4yjrbDPGWi9AEQyqCKpPXkPk12AB9n4hpz2SAnEkHfU5Lv1N10tK4Vx0gwYFJOOtiqB7H1pqn7v8sP5s5LTSeZ2E8sm3Xx1gufVQXLHOlWlXn1FkqcaTogemuTFHsAomciHttZptxJhrxp6KoA3+FEVwtHvtz//uBfz0XzzoPING9TJT80XE7qUqBMsNdt19cJpoUTCRiyoEywmgyr8PoiMCNtmkKIJu4M/pdudCRZDulXFaMgwzv+aSn3ebxAm3V9juVgdYtdVWW6WRY0aOy0Y/cyZf38ngtRMAplIRdNCEkWQuBlsIPdpqmfbNqMGiayE1DWhLKYKbUoOFUvbVkWnPqfeU+3rqpooiOEoNFjk5jZgF+5IogmAOk+vs+EF9UdjsPKfrcCeg079wVQRpuZFUBLWTU6rBSsenCPYNRVBgthFjrRugCEYBYYmcMvT2mZTSPv2+imCTBVhJJL0arDKNrgrBCqE3pCLoTw32HnC/9xEj3+j8UdZ+0uaqtgaLjs39naiAtm5Ij7sk015GsCb1bUlAg58rEquhbVOA1U4iLLQShyKY5RY9jqPRESwKWk+vWTSJ36+ZDrKpn1kVejQQwZIMDcwL9DJ1/SalCA6r0aK5MIlkqS7OqghqmrW3/SdPruHOX/lUZX3YMKPAdjMRLBp/JAXy3BWHoTnGpQhu2q7Pu9UBVm211VZphjKgZ72NnhIaqJKZFXCDh+n6YIX/nnZ7rpJW+btzabYGawqKYGadwi0LsIR1dic1nyLoODjcMdZ1Uj6C5cu0D+yDFajBIodebTus0OXXqBiRC0miF+72ga2rweJ+3/gI1uDli6IwVMAyRXD8PlgGwRpEEZRlBMtQypizruiCLoJFjiBX0kwit3+SEkqRznj8Giz6u0pFkJIYzvcMEeI2XEXQDbAmQSTpuIBqFcEsJzTJ3baqa7TLmfNLgawYT2yDGz07/FwREg2o9wLROVuNCHPNGKtdG6DwpEc8RqNhujedACuz92ue23mEo/+AH+C6CR5ukbRtAnJGEaySaXdVSsu/ZxVjMOMnBCuSEKhICEiaQ911HzqyjPtfWMYzp9eDYxtm5n2fbl6UY56xSKBAEURua4pgbbXVdsmZyYAzBAuwGa4yRdAVp9isPlibW4Nlv9tqmfZpKYlSCIMOKNra1tRgCU9xbBLzRS6q+mBR5rskcpG6AdagbDtXjSNLmEy73yOI/uaHRw4Mp4pZNIAFWFukIpgOcAKrjJ7fYUXrhBoCtgFsZ4oarJSd/zJFUAcIcTkD79ZgsYBcX0Zylk2NV8Qpgq4DXTgIVm7WH6cGKxJlQRoje+5dA0KUqu5Lem7DFMHRz60NCqtVBLnIBVc9DM2pm1ODRc247XdpZu8p4SBYEnMtV1mSj021ZxjtfNA9eXK1a74zFMHcUgQBQlAKpFmOH33fF/HY8VVnrGYs/nXlgiGFlWnv9PMgPZhf/1AANU0NFi1OaKG//f6Iz3uV0Xv+XFAErUx7eWzdAcrE29nqAKu22ka0oijwJ194bqxahO1uqTdhd7ystj/Bq6LwMgVvEvMls6e1EEVwq2Xap91fJK36HtVZbMXYN0NQgzvM/DiA0VQEN3ouajFYpl19KgUw+zfVYPn0KfV3UQogSUXQNhrWCQdeg7VFfbAmEUUYtQaLZ5ArEawxvO/UBEACM43YQbB4gODPH/Q/joYIEarBcnsFRUIgkb6KYMEQL+3kRX5Ni0baAnRFErkI3RP8OMgILQtRBLngA51XF8korVJpfguCcP8u1mjY3AMVFEFp56TJa7AqECwWMBOC1U4itJPIodbyerlxRC6CFEHqgZUpkQu7XYWMHVnq4I+/8Bw+/ZhqP+LPRX7vrEi6PcX4sxKiCTrIZMW9YI+7fEwcwfITUbRuJMI1WKk59sl8FPu+33yRi1iWGw2TOQhWHWDVVtulZ/c9t4Qfed8X8clHTpzvoWyZUef7fpYjzXITaNFLoEQR9F6y04hc+GjCtEabcLYrpw8cJhnD5DVYLt0pEmJLxm5q1TYBwSK1Mf4edfpgFbbRMDeSt6a6qsEUwdyMm8ZMqnXc8fbrG0rBd8Gy8xA4tdbDP/ntu3FsuWOW62xZHyz+92hOCJ2HYYhXL0DR8WuwxqIIMpn2uWYUrMFKomoEi+r0AIt4Aha1STM32I4iVYPly7THXr1euQ+W+qzsgyXK1Z9VTWKTACpKxscVkmkfB8EyQaEMJxpIcMKvCSsqKIK8DnVS9CAocpEXDuXTIFiNCK1EOsgvBWgASkjkIKP3UbAGK1M1WLGZu9SYDC2tbwOZEF2zydBROixFEbTXKqQkOKzGqkpcwx4TF7nwEDH2fAhR7oNl2jJMCEWm50BF0NZgSYVgDQuwaopgbbVdekaTOKe7XOxmVATzHB02CVZRBAVctCmZwvnn9T6bgdKEarBC351Lm1buXAhhzj2hV1sx9s1QEeT0yLKKoEd/CyBYRCkaR6adSywTPYxTxx45toqf+JP7DC3RDeo1gpXbAv4Hjyzjk4+cwP3PL5vlOluEaE8ickGLDVu+G0DhfARrLJELVoO10Eqw0c/MPrjMuB9XWMTD74Olfqc5gdA0jmD54ghBBKuCIhiqwTIiF959WBVghYJ2Mqdmr+eeB9rXqEaLhno70Xb5+aOffYqgn1yaVqZdUTndAItTPmm8rSRCK4kc5LekIjiig98zFEH1bk6z3BxDP8+d5sqqtis3cw3dj0kkgs+Wg2AxNLA3BMEKIaTcRq7BimUp6OWiLJEo01r7IyZUquxciFzQMRoVwXxwQvMiArDqAKu22kY1os50L1GKIM849tIcT59aK72QfZrI5sm0Tx9EhOh5W60iyLPyk65vlKT0i38rhr4ZgahkdVylGqy0MBSivKIGi8QBhslhAyzAkrZ+J4psTRVd708+egJ/cPezOLbcKVEEpWQ1WJr66jtnwNbVYLmqZ6PNQaMiWN2AEqKhA+vPceoyUlYjtWe+CQA4pZ1gW/Q+WKadB+Q8SAYUmiYEHAGDOJIOjbEowKhd1slza2Sg15coioCqZOD5otPgO4KWuho6HxzBykrLTdIHixQU/WCEkFgat6UI+jVY6pOf50kpgtRDjp8rQqJpH5wi2EoiB/nNSjVYo42jZ0QuVA2Wo0aaFaZZNEBUQLBn2AYyPDD3BXJiKVnNplqfzl1Irc+Vaa8OsBQlU3233ksNKk7HlEQSAmUhHjoWKcMCJ+rYJ/NRLENl86IcPuZcP2ONAX5BjWDVVtslaDSZdrdINexCMDthF05B74NHlvG6d30Cf/v0aWd5VZxu/795IhcTb4Zto0xzE8y52AqbttFwJDmCVQ5oz5VFUmCxnWDXbGPibQjPYeYxQj/P0Uws5SkvCkPvIlvzEKzBNVjaoY4YRZBRqrijTtv2gzrl3BCypRwacn54kmWrVAR5Zn1kBEsPc5jDFQqe+pmiQ02kIshk2vfOqQDrxIpygg2CJQeLXFBgzB13jkjx/kaRFEhkSEWQlreor+uwUiBO6/DfXLEN830eRrDiipoowBUdMDVYEyJYtF6iKWR+TTDR7bi0OP+ezA9axdQIlk8RdM9FwmTa20nkIL9KQl79PY1Me89jWXC0JJYCWZ6X6okbXqDvI1g8yM60yMWuGTUPngkgWLzmKPTY0TOZsN5r/+3jj+Mf/dpd6hgckYtwDZaZQ717zTYKvoAQLIYSU6Nhf24H4Jzji8XqAKu22ka0sxrB2qq+NxeC0USb5rnjSD5/dgOAdZrISgjWFJHLZtdghdCjrVYRnDag47x7an67JSqCQuAjP/JafNvthyfehita4Dpf/axAO4kAcBVB9/VEmf+GUWuz6z9ybMVBklJ+jlhtB/1G35Ezs9pNHZoSjbMooCmCavwUbPBkw7BGwyQ7P62R49EMID9VRg7TUIpgxZy23s0YTXj0YzAqf9IiWKT0RgEK1cRxI+eT13IqiXw3GOhlue5vpJY3KoJ+Hyy/BityKVf0ZyTLtFNCP6pELvxz6vfc4sYRx/Vequ5xpwZr9HNralpEufcXjU8FqG7Al1XUYHGZ9ulqsPw+WLlRLZGSIVjBGiyLNBGVbxSj99MpCrAyN8DiNFEpFDJGQTi9xxtxuAaLkoOOimBeoJflOLDYghTAkaWN0phcZcrqeyFhtNRTa128cHbDoSA2IlkKeksy7aUaLPu+nsTGqcF67sw6/vLvjwxdrmD3ADUaDiFYxHapVQRrq+0Ssvd9/ln81P/6kuFbh+oVLlbjMs/8hUhSziVFRQGnKHw6imA52zqNhVUE1edmyMCPNobp9qdk2gvzdyjDfq5s33zLZHUnMevQlZW7+mmOFgVYRbgPVhWCtdLp4y2/8mn8/ueeNstyJ4dOD62Xsgwq3b+rGsES3r1RwIpiSCGCCNagAKubZrjtZz6KD37p6NDzM8xs8+TRAyzyk4ZSBPWc5l9fokUD41EESbUwigT2zKlsvwmwDEUw1HuKZ+jVdySRDzAEK8sRs+SCbTTsqwi6fbD8rD/PrvOxATAKdP7TZWXP3e9DypRkPPD7ky88j2t+8gN44oSVCR+LIqgPUQqBpifsQeOS0qJ7vGYsNKe6Mu2TUwT9ucivwWqyGqy2rsEq2LmchCJI/ZqIfsrfR2muBC0MgqVrrege6bB73m00XDh1V249mwqAZpsxDu+edaTeyYpCieKEVP5oG4BC9Gi3vVQlldZ6aUmmHSjfr4RQ+qfJJEMmRrBGD7Dee/ez+P4/uHfock6dY66eqyTgFzQGUGy3q9UBVm21DbFPP3YS/+vvnjfOxqWEYNkJ20WwlulceAGWX+h8IVEEQ8HNVqsITksRlMJmKcmJmkZ4YivNFS1wnYN+lqPlUQR9VNHUYMVuDdYTJ9bQy3IcXbLKfrbRrTQiCbT/NMvN9SZnZq2bGiU0Pl5Vg6WVDxFujDloPljrZji91pu48Sc3Xhsyeh+sEREsfTwLrdj5njdTHYciaBEsgT1VFMEAEmey3Syo4siIQSEzF10iNIdn7vOijCrFsoIi6AUjgEZ8QgiWodx5CNYA8RXusB7R9+kTJ9fsviagCAqhnoVygFU497vt2+XOffQ3ndNpRS78Gix6dgClwNlgFMFmEqEo7PNHzbwBErkYbSDdIRTBnAVYlNShbRNqq+5DNzDzxXE43bKX5WjGEtfsnQsGWBQsVp1Puh6cIkjXcLmTmufMyLSzy2tqBvWc5t83lnEyYYBl+mANX3+jr9DtYfeuW4OlAskkLr//BtAd4EcAACAASURBVFFst6ttk1dzbbWdP+ulOVY6qaEDXEoIVsombJ6pX+5oNK+fOUgDzzwDbqPXcc2la028GbaNMj1PBr47l2aFHiZbP2IvbcoYb5UC4rRGw5Q6KOQv0l7GEKxcKf35QS/dc63YdWTJyeH1EFYIxEq1UyCa8hos7UisdrNAhp9qsCg7b8fC6zAH1WClUzo83CZDsEbLSJNjOt9KnO+5Sto4x0DHHUcSrSTCfCs2Sm90HCEH1JVpF6W/ObUzilwEy++f5NZgWUSzSqZdrWPHQkiG/3jROv7YTTAXpIWVv5tpRAN/rzIrey2QRKLEIjAqgtL+nz6DFEF2nqcTufBrsAoUsAgWl2knOnCnl7P1OYI1IkWQIdCdfjZQ5CLWAVbfQ7CSSCKkPmnurcgmDYtCPSuNSOK6/XN46tRaMMCl+SJ0PjlF0H8+lzf65hioxs4P+gH7TPhB/maJXIySTDHtG4bsy63BUseQBPyCqsbZ29nqAKu22oYYTXiPHFOO3KWIYPVSt2v9ClEEGRoAuJlnAMFi1lEt1BRzGguhR+RwbJWKoAnyJtyf38SZ93m60I07cpFHR+pnOVoxr8EqF0ITQrVbIyK0/uOaasUVvTLzUpcm6OcIls3uq+XWuiny3LvPdA2WVWWzvxHiI0VZRXC1mxq0uz9igDOKmRqsCQKsUWXa5z0Ei1MExzkGmjfoGu6da+IEowiqezfQw0l/ctTKQbAMRTAgclHqg1WUVQQHNBqmdfj6oUbDGQtYuJGDGKohCZ07joKOE9jYBEuZFkm/83NDx15JEWRUuEnBAxLQ8AMsg2AJgX3zTUgBHNrRNsmUjpHutwHfJCIXgEKxXIpgruotvRosCiLoWP2ERZoVLv1UuCIX/SxHEklcu3cO/azA06dcdNqieeUaKYCJXMTSjIHGvbzRN+OzjYbtujy4jkRZJMYESBMGKaMmZPiYhy3r9sGyzZ/9VyDV1tYiF7XVdgmZlYJVDtywovaLyUxGLA9TBPuZWyvjZzFDXOtRLYQ0TWO8Bsjf7lYFKZamON36ahuihBheyOZTBJ0arKxAEqvjqUKwyEHfrWt66L1uAqyNMoJF8urc+SNkgttqN0Wms/B2vHZbPlWMnOPZRuz08wGAn/yTvze1CZRJ3gzp4UlUBMlZGV6DRQiWTxFkNVgTUQTVw7ZnvulQBKVQSYbBjYbd+wWwYhR9ndjhFN8kEo56WgEubJKb9V0pdpj1aR0yc929KaxSRTBQx0UWChi4sMg4NTNcSa4RyZJiHJ1fKy2uahp5nROtrz4tij9tDRY/V+o5ttfz8O5Z3POv34SXXrHD0IF5TzCONI3eaDg3aJgfYKm6JovaxZEKeHx0rFkSucidwDqWbrDaS3M0Yolr980BQIkmaJsuh+8FowLJKIIUJC93UvMsJpFuyA4+NvVJCGWpBosQ80kRrDFUBHtmX6NRBGOpmnnTtfbnYEuxHXPQF7DVAVZttQ0xP0N4KfXBopd3mhXY6NnjJpELwJO29nj409Q2hZyBaYw2x8vW/ULvc23T12AxBEtsnYrgZph16Ehhy/6W6qwwNSDOAyIXtPzeEoKlalnOMASLXvrUJ4yjIJwiSGZrsMr3BtGfHIqgDqrmWrHTzwdQ6londTAxrWwyN167NHoN1qgIlnq255qx87nEz+lEFEGLYJHIRabpYFEgw+80GpYW8fQRrD4JETAUJo7cBrW8/oa+rqrBssERoRuFEYvwZS4qGw17ioXO+QhQ3jjVfJI+WFKquiZO5yoKlZwQOigVglQs1e/O/S1tAEG/TVODxZMY9Bz7+6U2D20fwcoZRVBfx4eOLg9VlOtnBXbMKFrrhk8R1I2GKSiPpNQIlnst/FrArPAQLGkD/KJQCFgjlrhGB1iPn3ADLEIKq0QuqN6LKIvqOBhFUFMQKTFUBO5XUtYsqQgaiuBkF5LWG6UGa1yKYBTZRsN+IhZgKPJFFGHVAVZttQ0xP3N7aSFYNIkWDoK10rGZba4UKL2JcxqRC4+tNbXRS9JFKWz2dits2v1xaiGd661SEZzWfNEC7tT0ssIGWHm40TAZUQQLTdd5SosF8HqhzDjqMNlSXqjubzvUB4v+7GcBiqBGH2abcUnoZbWbsga/02WUudEmfATrV//qUfzihx+uWGc0h8uKXChndees+qRzKsV4FEGiKJHzvne+aYLOorDXhK7T6bWeltWG3p9PEdTOrhG5UDTPiElpJ5EY0Gg4N9sKqQgaBIsEIQjZEmUqExeN4JZ4QZpzPvT5n2V1VzxRNw4tigctPkXQD2ikppFl5jjtdnyKoJgSweJOM/WW4iqC3IgiSAgWUQwB5Wiv9TK8+Zc+hbsePzVwv900N6hrt5+7FEFTg6X+b2uw3GNMPEpiFgje+dzRTVUyaK4Z4+BiKxBgWeXLQSIXDUYRpDEtd/roZ7ntweVdE64iGFJ93CyRi1GeddMfb1SRCx0sUo2bn+TifQovFqsDrNpqG2J+gHWxIVhpllcGjbYHjrvMMqMOORRBuEXh04lcuMjYtHYh1GD5Yxl/Pfa3dgK2Cn2b1iw9UpieKGT9TGVtIyGMYxYKsGKpGh4DylF55vQ60rzAocUWzq73TPYzy5WMN8/k0z1E9DJuK7oPlhvUuwEZ/40y7+0kKhWEr3ZS47CZzzGcho88cAwPvLBc+p6OrRlbtbzTaz38wkcewa987LHS8oTCqP0PnrNItINELqiRKtVgzTbjsSiCJKNO53DPXAPLHSVEwPuKFYUa55t+8a/xu599mglgsOc10Aern+WII3vvSyG0+pxXg0U1Wyzgc2uwoL93hVMsxdSde2J235YQLFOkHzofatmFthUR4fMpV7Gjc1RlPGhRtMhyoEa3t3qeOPWynEDgNUrT9sGizVMSwNRgeSigqcHSiYqssAqe/H3i1zf61s9yc892+lmg0TBTERRKPMMPHhpxVKrBUvRT9X9CwQEVLPTSzEjOz7dirHfdMdpgM1yPZ/tsBVQEN1JDQQTKzZ/pvjAJCu8+mVbkwsi0jyJyQcHYkGVdyiRre1GiCFYnKLar1QFWbbUNMZ8ieLEhWN/w3z6DV//cx4K/pYzixF92K11LESyrCDKHZJMQrE2twQo40VtXg0XZ4kkDLJfCJgRKNSIXqnH0jmdfs7zA2fUemolUdTmmBqt8YDtnG8zZKYzwxS2XLSIvrPiKU9yuHXSehfavNyFYodYAaV5WSCMEq5WURQZWOmmplmGcxp/v/LMv4bc+/WTpe3J+FDqgvvuDu5+p3I7jNI5KEdRowE5N5aIarPlmPFaQmOWuSAlJtZ9a62ln2l6Pbprj1FoPx5c7jiiCMM+rMM31bB8st44jjkjkgmf7y42GiaZkl3ERLD948ovxee8u3w9MBjiIdD8sMJXGroe20Dhf8x8/jvfd82xpG2S2BksjWAGxDH7v5wGqHv87Yud5wv60RiDGIFixdBpsC+9RphosepeSoIg/xmHWz3JDZ+2muUcRLHRzZYtE5XkZzW1EXg1W4akIsmAgZxRB9Vu5KXJRwNRwhdAY3jKA9mtELjqKIkj3ko8qZuw6ClG+B6cVuRinD1ZPJ5mGzW1G1VIQRVBThH0Ea0Cbg+1q2+TVXFtt58/8ycanBG1ne+joMr70/DJOrfWCv/OM2EY/M04PnwN5JsqXDZ9O5KKcbZ3GggiWoYFMv/3RxuB+Tro+/b0dVQQV2qAK2YuiwEceOIaTqz189c37DY3HbzRML+NdMw1T55cXtnXAocUWANu3KWd1VuTMlyl/dmxr3SzYBwvQRe/e8uQct5LIzA8nV7vI8wKrvbSEXI1TE9HxHEUyXhxPiMf/1I44HT83v3nqIDMy7dpZ3UkI1rpFsPx58IkTq3jJOz+Ep0+twTclfmMfKqJ1nlrtGgeUrildw26asxos937x0Q1SL+XL+GgOV83jCFZIpt0XqDABmT+fSUvP9Gl9fpDGzSJYVkQkpCK42klxcrWL585slLZBZoIlqsEaQBGkOjeOyJH5wiGbQxFU/2/oOsFQYAcoqXaAB1h2mb979qxZbpjz3s9ykxTopplHEXT7YMVRFYLl1WDpuYNTKHmftF5mA6AkKgtyuAFFecx03xBFsChs82OlIsgpgsJRXjHPh0RQRXBaSjKdm3FqsHrpcIogUdnznEQuynXPNkExycgvTKsDrNpqG2J80l5sJ04PnO1uvxqgFnGztSTKmSUHjBunT0nhBgE+z3occ9AETL4dsw1Bnyxwk+XvzqVNkqUNrU9/+7VBF7Lxe2SxnaAoFAXtdz7zJC7b0cabbj7ARC7ceijKUlNtEGVDyUndrwMM6oWVetQg7rBneeHQzgBVNxXqg8W3xe8REihoxhHyQknIv/I//BU+8KUjKAoubmFrGEe1XpoHaTeGIphYkQvqLRVK+vi0p0HW1YX1hCyQcAAFrLPNuDSmR46tYqWb4smT5QArzXMHwZppWEqYUZzT55NqO3u8BssJnni9kK3TIKl3QM0zsefsFig3GlbCA3ac1mEVzv95rYtDeWYy775Ahi+U4ZwPfR+8/oZ9eMVVuwC4Ihc0bur1NghB4BTBhleD5dc8UQ0WPx4yQyOUdll+br7r3Z/H7/3N05XjcMfkIljNRDr79WcoaslA154nN776lgNmuUGOPglOzHMEi6sIZoVCslkQHqrBakTCCUgI/Y7YdaVt9HVdVyOKzG/+s5XlVlExRBGk55iSj2q+sAhWV9Ol1Zg9BIuhlz7NGpiMkhxafywVwREQLE6ZzHMXFSSL6xqs8U0IEQkh7hVCvF///2ohxOeEEI8JIf5QCNHQ3zf1/x/Tv191rsdWW22jGJ+0Dyy0LqoarAePqFqPKkEBPuFu9LNSI1LAfbFSzQvZZsm0b0YMERKY+Iord+JbX34FbjqwMP0ORjAT5E24vk/xefsrD+NbXn7F9APbAuP3yL4FFRA9cGQZn3vyNN52+5WGlpNlZRVBCrBIhUxRCW0G/KAJsFRAwGsviN7H0QwBNzClPlih3mvGYQogWJSJP7rcQZoX+PvnlvQ+XAnjcSiCvbScZadxAFZAgJYFwrTlLOCYVVlX15VQ5ny+GaMRSVODNd+KS7SjJR18rQfqZHwEi1PCiKJJUwNRj7s6+ALcRA2/drxBNKcZSqlqsLg0uGo0rHbCESz6TX3C+Z4OkS6X3wcrZufeoF8ktEEUp8ClpnP3Nbfsx6++7cv1uWC1U/p33l8wZA8fXcG9z5w15yWJJPoMQeAiITT+PC/s8YQogoxOyAOCzz5+Cvc+cyY4Dt+KQiUt6PlpRJoi6O2LrN1wa7A4gvX2Vx7GJ37s9QAG1/fQOSKRi04/c56bNMudeYRQc//Z4tcUsOh3xM4h3cr0nNFzEnu91+hYTB+sULDt3YtZUZhruLyRoq9FNACUtmEEIyT12XK3bSjJE6oIjtMHi2jSw/tg2Wc4L2AowiWRC6+B/MVgW4Fg/SCAB9n//yOA/1wUxbUAzgD4Tv39dwI4o7//z3q52mo770ayqQBwaEfrokKwOPc/NFFyTnann6HdiMy5IBOOM+QhWBdUo+HytnbMNPBz/+hW88I/18Ydn8nWt3/vaCf45pdfga97ycHNGNo5N2ky5cC+eUUZI2fx+v3zACztJS/cczTnUdcoG0oO2n4dsJ1lARanCLo1WLkKdNm5XDMIlv2O7r80K0qJA1ODpZ2C9Z5yjKnpqB9YjZpRJrpQyMEmx4MoTZxaFEr6ZMzJGhbg9dIczcQGWK1GhFYiDSI42yhTBElhcI3VY5r9MRoVoJA+QAs4FG7gQtewl+XMuRIO2kunPjIBlkLIeOBF+yOEIi84gpXr9S1qoJYpnO2aukD6XrjJHV6vY5oUGxnw4QhWLKUZkytyQQGWOqdVgiI//8GH8IeaFiqFQMIognle4LRGNHl/MBfBstvy50PuzOd5gbVehtVO+dqGzNLi1P+ptxTva8bNR7AoiUHWTGy/syqj6zzXVEm/bpq7dW2aGslrqbK8cNAqKdQ7iicjFGItrWy8c6+q8dK9FurZZUUdqlQENYLFAgqOYPWy3IhoqN/B/rbn00e3aOzqc0KK4AR9sIah8yRqQxTUPC+rsgKDVTi3q53TAEsIcTmAOwH8pv6/AHAHgD/Si7wbwDfov79e/x/69zeI7aI/XNtFbb0sxze//HL89nfchst2ti+qGiz+sgk6aayGZKOXoZ1Exgkji5jz6U+c06gIqu3pz02YqXjh9/kyOp5JZzZ+bimo2C7GHTkKsL6o6y0IgaKMe1EUELDni+osCMEitUGLYLUBAGfWlIPKHSty/OjUpYEarBBFkP4KIVhGRVAH5mtaSeyZ0yrA8qmBo9ZE0PIhB5urj2W5Da7aSRRMkGTMGRtF5KIRSUN9aicR2o3IjGO2GZey4iSAEUKwUk/kwiBYus5KChv8bPQ1apNmDPHgiGcZbTEy7cx5pqy/CTiKgsm6u6iBFbOA8z3tn1MKfdGeggUhgOts820754P2HwnjWPvBAGARrCoHl4sLSaH2TffBhx84hte+6+PmN/Up8MjRVbz5lz9pjoeMBxD0fzofFPisBoJnbmfXe3jDL3wCDx5ZcYQLqL6IzpE/3zUZommbEduF/GsZMkK35rhMO1ueVARNEB4J/dzY60Ny4T6CFUlLnYykNGgWJQOaDMGqqsESIiy/bxIljCLY4wFW6tZgOY2xWW0gb3NAZhOi4wcpJC4EDK+rUsuMFow5NViFVfcsNxqmZMjYQ79g7Vy7Gr8E4P8GQKdsN4CzRVHQU/scgMv035cBeBYA9O9LevmSCSG+WwhxjxDinhMnTpyrsddWm8kS75pp4I4b96MVRxeViiCn/YSOizJh/Vz1wQoFWNxZ5c4QMF0fLNo2/5zGbB+s85e3mfZ4bFZfSV9vJ+NOH1EE79OUukM7VIBEGWFeKA4oBx9gFEH9siYnde98E0JYpz/NC+MUCQGnpiLN3RogQDmSfn+sgTVYRkVQBSSEYFGA5YtbjErZsVnhapELJdNu689IOMFPkJDT2Iylg2aFrKudOnIcW0lkmsECioblo2oGweqVnfB+lpu+NmoMFsEip7ehvzO0OEfkwu+Dpf7mFEFfiIAoemlWmIa7ftBjUSZ43xO9r3C+9ymCXBqbTint11AEA6eakIEkkua88CDaIFjdwQgWZ09IIdCMrYrgC2c3nN/UJ/Dg0WUcW+5i/0LTIMXOMhRgseMmVHJYgPXUqXU8fmINR5c7zjNF7why9P35rhlLCAHc/8ISvvHX7gLgBn/mHA24b+kZaSUSSSQckQshbB8sctypBstFsIRpQExGCJZTw+mhjnR8iRSl5AkFFJEIy96XKIIsObK8kapnhyiC0hWU4hRQIWybA7NtQxEcP0rpe8HpMKNzPWxu82uwssKdj8ksxbZGsIaaEOItAI4XRfG3m73toih+oyiK24qiuG3v3r2bvfnaajNGSkg04TUTeVHVYPWzvCSZyy1lGfiNfo5WIyoFTTyo4vLKgNuEeBIz251qK7Qt9/N8mGCOzyRG6+2Za059brfaeKPnuWaMmUaEo8sdNGOJnVpUQeqsbAEXxZj3Aiyim9A9O5NEWGwnhiKY5xa9IBTC1mDlzv8B5bhs9DLn3pXGAcqNciEZCRRQgLXqOaRE4eMJilHMZoXLy1OQRM4dHTvvA+Qsz2q2hiJY/QwtljxpJ5E5NgCYbUYlp4t64fl9gGjfLoIVmf2QA0rBHAVY3TR3aoVsAFBGsPp57jhpkWAUwTwvqdfR8fs0PkPz0+vSeq6KoD0uRRGEuy6r8QGA7/v9L+AXP/KIcz44ghaiTdP+Vg2CFb5evNm7lCRNr+vwUh58wRwvIYz/83u+Ere/aHd5GTYn0fGv6XWGUQTXHESN9cGiYJc1eOYmhEArjvDxh06wmjL7exJTID28BiuJJJpxZEQuYjoveW7qfYBwDRYpBHK0jZoTc+SLxkfslcQE1WWRC950OcTUM8gnowjSc7/S6ZtkB503V6bdBv5W2dBuexqRC47ijRNgVdULkqn6PFuTZvvgucs1Ins+LhY7l2/oVwP4P4UQTwF4LxQ18JcB7BBCkBTZ5QCe138/D+AKANC/LwIY3Ma7ttrOsdEkYmoT4jAdZ7tamhUOh730O8vEd3oZ2qxOg8xxhoRbO5NMGc3Qe3kzUCdSItwMRcJJLVQHNt76ar3tRg8Eyugd0QQP7Wg7dKUsUy9hHqzPNpWDTjVYSg2uQCfN0IhU/6ydMw1HRZDoqUQlc0QuvEQAoBx9hyJIy2flmgHyRSg5EQoy+plVLMtGrIkYRLvhMu2AFYdYaA1BsJJoaE1GJ83RZAFWK4lwgEm/N+MIReE6YaQwGEawqkQuciOIQDQxjmDxGhPBnhWfzkboFKcI0v7SzNb++CqCfH2gLArhNxqWUjjZHYci6AVnPHB66IjbKJquZxzZGixutL/lISIXToAl4PT+4qIZnLJN26ZrYNd3g1YpBEiWggKnlSEI1qpHWTQqghqdJIc/NNu1G5FzPCGK4CAkhp6VpkZeqdFwI5ZIpEA/9WuwFLWWJzuksAFvygKsmCNY7JOeOUfkItQHS88voWCBJz7oHOWFQonzQjUPp9/8RsNcbZE+nYbtY9Z8cuOB4kgiFyMKalBCRQpFwc00u4Ce19mGVWQEwrTK7WrnLMAqiuIniqK4vCiKqwB8K4CPFUXxbQA+DuCb9GLfDuDP9N9/rv8P/fvHiknbitdW2yYZTTTc8QDCwch2tH6WOypMvhlVoTxHJ1UUQV8ZUKlH6b+9jG+VOuGoFlL+m3xb7uf5MI70TWK03v6F5qaNaavMr6fbN68c+IPMkZdCI1jmpaxWoiQApwhmeYFuPzeO+lwzNo4hL5qn+iv6v9p22elb6abOvUF/pl5Gm1vbQ7C4cTrSqDURtrdMQOSC1WABtvZpsT0YwSJK4SDr9pWK4P6FFoRQYj7/5i03m99DNTFEEeTB5XovxUcfOIY0d0UuaN7s9DODKpATaYQduEw7u/YcPeTNp3nQrGqwLOpBR+vXYFU1FC7XZnEEyx4HKRWqZfS5kdL5pGPhlpprp4JFW/fk/s6DzZDxIIpUBI3QCbv+fnAAqECbmxDushxxMRTBIQjWOguu+XXyKYKh6a4VSNSR2X5ngyiC9nloxopZQvQ6VRuVOwEW1VpxZUIp7PFnLMDiva8idh8Sck33rl+/BVANlqUx++YH++RLUDPuk6tdg24JlGXafWpnqB3DRBRBFigO64NVMNRteA0WiVxoRUtCtPT4qYZuEMV2u1q5qc25t38B4L1CiJ8GcC+A39Lf/xaA3xNCPAbgNFRQVltt59V6HiWAF+fOBXpCbTdL88IcRyho5LKvG72wiqAUFhMS8F6UU1ME7T6mtWmDm82waYM8etnvnd/+CNZeHSSSQAVgC9Gtk6K+f+PN+7BjJsFNB5WcvuoBo6h65LwrJ8uqklGGlCSTXXTKOihcCYwvQ3+TUxN0Er0aLG79PDfZ8lEdnl5me0L5lunicAokKMCqogimLMAiClSVemUnzbHYTnD1nln87b9+kwlk//h7X4UHXlg2c0Mvy80xh2qw/uK+I/jxP7oP1+ydNYEfoObPSAp0UkURjIQwDn+wBovTAllwy1EihUyqv32Ri6EIlt4GOXN+bVaVyEUSCXT6YQSLBzN+gMRVBGmdNC/QiKSmRlKANbgPVqfn1mA1dA1Wweiy6jf3uIDhCBZHXOiabvQzpFleOY+vdt19+jVYqVbsDM25LU+51Ulu6AB8sIogowgmiiKYRMIIbPQ1Es7l1tO8cJINkRSmR9taL0W7odDeRhw7SoyAumeNiiAhWFIGKII6QSArECxCoj2q74GFFp48uYZOP0eT9cHya7D8Xor892lELhwEa0gCuT8G2pUXdg4uChtw0S2l6mu7aFCj4YsowtoSEn9RFJ8oiuIt+u8niqJ4RVEU1xZF8daiKLr6+47+/7X69ye2Ymy11TbIugGKIBBGe7ab5bmiUFCANRDB0n2wWknkSMgCevI0L2nXEb2wRC7cbZ4PE1MeD1G99s5vPwTLp3taiqANFkkdkBwJOk975pr4gTdcx7LtVqadCzNQht9pNKyz0a6Ahd02NdXlY6N9qG3lJZl2MotghesXs8yOZxQj9a5wHywXUTEUwQqRCyvrHg0dAyFYgEUJAeBlh3fh7a+6ilG27DaWAiqCFCydWuuVnPJWLE2vKyGsEhuhf4oiqJYtiVywQIqM9yqKpEv1Kkzg5PbBMmIWXg0WbbfUaFi6iHwspaUXmqDNBk1kfoBl0RahP9U6lKx68Mgyfvr9D1iKYIWD69ZgwTilqhF8mSJonzmUE2OmbYKdk0wNFruf1wL3tv3Nr8Fyj6+fFZWEbHqXkvlshyQSI/XBSiJVz9ftZ0YNM9HNg/k8oNCmvFSDRYkAShhkBVwEi80jRkVQH18SiUAfLHV/R2JwHyw6R/TcXrlrhh07UxGE3QZvJUGX05GYH7H5b8j4OsOCJletcTjapRKvavw+Qkj+B80XF1Oj4e2fgq+ttnNoNJGQM0AI1sVAESRKAJe59Y0HWB0dYPkUQZ5h5llMYHqZdu4gTGubSTc8X2M4udoFsD0DLP/Y6Rg4giV1bVWuX8p03f26FS7TzhEsqgvK8twJxoSwzy6NhTa52E5wkvoHsd3Yuhy6r8vHZGqwAggWOXjq7xEDrAGUwlzXLsUGwVL7rESwMotgAYMdl26aO6IWvsWMfkefvrAHYAOApY1+KbnSTCKFYGlEMChyYVQEbbKGB7f8PogYzYjXYIURLKqB0oGUnuqq1AXJf+QtKGj9rChwfLljlrEy7fb+8t8Pqb4f/QCkEUugC3zw/qNY72W4fv+cc5659dn9BKhaUo7auSIXFnUBVDDjJwikd06ltPcdD5xWun0szpQbzPvL8WeKri3J6YfMzB5AFwAAIABJREFUR9T88fEeXyGj4KvBEKxGqhIu/Ty3aqTsHvHrp6WwARYlDGju8BEsIVBGsKKqPlhWltw3Q/U1FEG1zSt32wDLEbnI3XWtKAndsyzAGnO+4TZODRZPAAwL5owirGYdGPq3Pv7ZBgVY5ePZ7lYHWLXVNsBMDRZRBC8iBIsmVEsRDBTq68mz08/Rz4qhMu2+rPHUCJZXqzDdttxtng+jXU9KUzyxogOsue0cYBGCpWuwGIIVS6XKVcBFRv2gnpwXFRgwhU+dJKAsNC0rhXACCDUE9fuhHW08fmLNGZtdRo8rEkFHkbYZarbbz63IxagZ5UE1WFQcTsdFwcxCKyxSQ44KObv9PEcb4SCKI1gho/NP4yJnFHCDS5oXlQhFGcHqaAQrksLMpUSL4wEWXRuaW3w6G6CoRRQcREKgYZTnihL1r0pFkC6LX4NlKYLufZBEEseWOvjKn/sYbr180dnmYIpg4QSH9DfNpYQC0n0YSuDRuf3Ka3ZjvhUjiViAlQ6mCPrBDMDQdF6DZSiCoyFYPLgWwu7PBFh5URlg+c3d/WlZ1ZdVO9uUjKD2Ah19DzdiCaS2DxZXeUzzwgkkeIBFqpg9jYLRlBOz60vPnK3BkmWZ9pyJOgwQubAUQbX+vvmmoXzSfcFpmwAcVUQTYAXU/6ZBsBqxHIpK8fub/n7ixCrmW0kp+UcJKjoWOgY6r0TRrFUEa6vtEjO/Bqt1ESFYfoDVCSFYmVsbEBS5YFleogIAKPUOmsQ2kyJoa7Cm3tTUY5j0eE5opGV7Ilju58sO78TNBxfwkssW2TIkcuH2qvKlrY2KYD8zVCOSagZUFtpk5rXjx/s68aSAI7LBvDx+7zbjqALBchsNc0uznPWlGZUiWC19nOkaKjouW4NFCHRFDZYe46BeWB0WqIbMym6rbRCdSgpX5GKDOeZ+ckVRODNkuTq3ZRXBcoBA9wD9nwcpM43I1tFFXEUwLyFTXHYdCIhZGIognO8pOCeLpcBKN0WaFzi23NX7tnQxMv/69bPCmTe5zDefCjhjwDdy7r/2JQfx62+/DUKwpsVZVhLA4J/NuBxY+0EYR1x4wmC12/dXNbbWdUUu6JmxIhd5ZY8NnyLoz4mhHlPcnBosLXLRMyIXotRomIIXfm04RXCJB1ixdGq3aHx0jo2KoCwjWEbEoYIiyBuGA25vLZqL6Dch3BqrwqnBov3Z38ftu8eNgqqZRjRUet1FsNR63/Xue/CuDz1UWlZRJm0NFlEECcW255KQ9rGHfsFaHWDVVtsA82XaLyYEy6cIhhsNq8mTMpWtRhnBEsJFZkJ0nkmNtrA5NVibF6xNPgboMUy2/kEtz37ZjvaQJS888xs9X71nFh/4wa8y6lkAF7nwHWs/qLd9sMhRbyXS3MNp5lKDpICDYPHgrZ1EpmmzSxG0f6vGqOWLRkFblVQ5iVz4Us5VRiIX/SwvZb+5YwLYAGuhHUawuIogMLwGy3d4ufkUwSVNxdy/0HKOfZ3NIf41a+oaOQqeDUWwy1UEiSLI0EcueMG2OdeMHboUjfHhYyv43bue0mNwESy6J+hU0CkerCJojyFhc183zU2tjRqbXbAc7OZOksAIY7BMPrcQgkDoLE8UNFmtE5+/KVig0xUKnn2VPI648Gu6MkBJcK0kcqHHZSiCReVcRyIXNx6Y18fg3r+DKIJ/cPcz+LtnVZNy3gern2mZ9kiaRsN0XdpJhDQvnCSAlGA1WOqepgCLi+Co4xPmutoAuUrkQieLAs8cMUXaniJxI5I4oOf3yj5YOa/BcpMHgEWhRu27x422M5OUe975RvMUoKiaRVHgubMbhmrNTQWFds4mimAklSBJzJINwMWFYNUUwdpqG2ClPliEYAXQnu1mZYpg+ZjIMaH5upoiaF/S9ALwka5JbNrGvNx8BOV82LQI1s+/9Vb841cednoUbRcb5fyTU8KlfYFQgT7VYOWmNxZHsPLCIgZJpByuKgQrjpQ8+cnVnnNd+N/NWAYT8SGKINV6pLlFsAahR9xovqFML3fKs6IwTVT5PofJtNPzOqgGS/XBGp8ieGhHG48cXbHbYc6rjzq2EqXySP2rLEXQ1mCRX8fnEy6c4yJYMRMwkEgidXx/+Plncd9zS852yn2wvEBKHx/5dpUqgl4QFQkrwMHnuxCCxQNOW/dE23evjU/B+pd/fB/uvPWgOY9mPESLTHPTBBewtZqmBitQXye8wJDLirsIVnWAtVqqwXIRLGrqHTIK6F982SIeOrqCU2uuc857fPn279//AKNZKjS0m2bopZFprN3PC/PMAJaSuNyxiFwkhElQLG3Y+7DJECxLAbXNnCmATCIR6INFNUdhyfFOP3cSDB0WtBGC1WQBFt8E0WsBe/14IsbWYE0g067XaTUihwIcMu4r9PMCK90UvTQPyvqbGiwdLFKQSHMAIb+GIngRiVzUCFZttQ0w3i0e4H2wLgIESx/boD5Y/kTdTqxMOzUI5Blm/pL1HaxJzPgzmxJgnX8EyyJ9k62/0Erwmuv2bN6AttBGOf8UnBSF21fHv5eIblIl087Vw37sq2/AT955k+OYOkhrJEzmmAd/fJjNJCqNWzAnab2X6ZoYgZ1aECDNrCT0qBnlnlNo7mXGNd2JjoNqRuzzWxZWADiCFXa6Uk2lGoRgVVEEDy4qBIucPK5y5ydYWrGmCBZhiqCS1lZjtEivK7HPKZyzzYh9b4OWM+vWUVc0ZTdgAsoy7VUIlpQuhY8rI3bT3EsuCec3bmnm9gWjc1ONYNn1nzm9jj+593l89MHjAFwEi4tccNTMiLZQTVQgwPKREEIYAEX7pPEO6oW1Vmo07I+rWkWw3VDLvPiQar1wUteX8mOroqr10twoLjaiCK04QrefO42G0yxX9VCm1kc9J8sbbMw6YTHXjMsUQYaAq+MT5pmkADKSwrRAIMsYvTlUg0XCPLRduleSWOKAFvyhc+/XYBHdjo/LVRGcQuSCEKxGNFYNVj/LzbXjwasdsy0jyAvbbsJQBEsI1thDv2CtRrBqq22A8W7x/DNUr3Q+TNU0FLqXxHhGL3FS8QnWYHmzXbthJ8T5VoK1XqYnT/W7EFydavr8zebWYKnP89oHS27e8Ww3G+VaxlI4TnZlDZawCFbTiFxYChqnBr1Y13jxBIIQ1olPpMR+nTl2ZdpdBMu/nSNWA7PWTdGIJL7tlYfR7Wd492efRj+zktAj98HykAsuBEDH1NbPKzmEVuTCTZBQPMXpWiEj5GMQguVTBCnAumxHm4mNRE6A5ctutxKJk6spWolHEWROGV0j/pxEwuZXYifAis35iqVEoU/V0rrdnqFqldQCwzVYVuRCH4MQECxE4PvvZRrpMEEMQ7BKKoIuGmkCLClK58lfn875iZUOgHCA1U2VyusbbtwHIQS+/45rzfiBclNfdW7coJXXYK12U+ybb+H5sxsDESwuhsGTFk3TGqAawbr54CJuO7wTl+9U6nknVt0AqxGQQAdUMMPprglDsLo6OOqmQic4cnMOZgIIFo1tsZ2Y56mraYYllUVRvn4mkMxzNKXaPu/7FESwdFKINsebFx/QvQHpHetvI89dSiftj2wakQtadyaJ0dMU5ap3pVODleUmoA/RSUm2nrZE/fhiqQIsei7iQMC43a1GsGqrbYBxpSLgwkOwfuYvHsR3/M7dE61ri+AlYimCx+Rn3luMIki1W34W1zium4hgbU5AIti/58do35sQe247E/qYB11KKdymv3TdE++EUWa3m2bGmSOHveeph5GpOirajxu87deKhtwx8REs39ngTX/XehmSWOInv+4mvPHm/XpbxdgZZSfA8pxLUt8iR/GsCbCGIViD+2AR8jFIpp0jJbRvIVQNFmCRjEEiF02NYOWFUkNsMJSDjI5BetcpjGDxZrB2jMvcyWMoqBBc5EIFrD510Mq0E4LljcW7p/jYFlox/uYn3oDve/016KZ5ibrF72FyKqkWhdtiO3GuPd0TJKrB0SguJtHp59gz18RvfvttOKRrNGlsoWtreosxh53GvN7LjJDO4BosH8ES3riKyuf9bbdfiT/63q/EK6/ZjRv2z+OH33i983tS0WjYfy6MyEVfCVg0NCVY1fTZ4JmSFbxvGx37QjvB0kYPRVGgl6pGv74cOp+CuMgF4D7fVGPoo09knX6OFgvgrHCGMAgW9a4TwqUAEjrGx8XRM0MRnKIGi87ToG34fbCIkhoKxg1lUtgkTSSUuMjO2Ybt+aVrZWuKYG21XSJmarCMTPuFhWAdWdrAM6fXJ1qXXl6xlKZJ6/vve8EJtEoIFlMRnDcBlkt9C0kqT2rnpgbr/IVYF4LQxvmykRCsyCqHkZMScmxJRbDbZzLtsc3mcwSLTAhhaHC8BiuJJA4sKmfy5Iqll5UQrECARfNClheOdDNAfYsoozxqgMWKx0vyz4WjhkhF+e2GohuVECxPpr2qBqvjofQhSwyCpbaxtN7DQisxc8BnHj+Fx46vOihhSaY9kebaEGXI36dBsFhARUIXapsswGpEQZELbryOjyd/8rzAD7z3Xrzzz+8HUN1omDd2JrEUf/tckOPAYssEwDxwTLPcuR8p2FIIlv0bAHbPNZxrT87sseUygsWDVIWM+LWK6nOQTDtHaOi4V7sp5lsxZhvRYASrog+WqcHK8qGMgblmjA/98GvxZVfscL5PIol+Wr5nwwGWqr9c7aSYa8ZIImmod3ReZxrl80bzymJbUQQ5BZArVAI2GOPrE2WUB1hOzVHgmSOKoA2wyjVYSVS+JmbbHqLGm2bTM07j+f/+5mn82/99f2kMIaN16P4aJHRRogiyAMunRSrZevv+pRqsf3XnTfgvb/tyhy5bpby4Xa0OsGqrbYAZKVgPwbpQVAQ7/XxghnGQpeZlouo6vvjcWbzjPffiY5rr71OtABfBoganPDsl4Dqu0xo5CJtB6+OF8+fLLsXAiowjAdXL2DoHotmE7iOiznR4DRahy/3cqcHiRo6m8BxnQmI4TYmvrgIsd1uRdMdmaUM2qz12H6zMdVy4UW8vg2BpKlwzjkyPKW5+o+GqMYyFYKUWwdoxkxhq8g+9916860MPOehAWeSCECyLDvqCOTSvWqRROEGS3wfL9iqSJZSTr6/+5sIAwAMvLJvlyo2GLXWQxiKEcJxswGbdaV/8mPwsP6/fMgiWtDVYVIt0eNcM8sLSSumckxPLaaMcWdzoZaVraPtghWqwXFSQ09HWeylmGzHmWvHAGixf5CLcB6ty9YEWBwQkgDL9sqERrF6W4/RaD7vmGg4jg6sIks00I/2b+j9RBLtGxCJiIhduMMaRa6tSacdEfbBUEqh8XIrWHJl9mxqsSOKGA/N48y0HcNtVu9Q+hSvTTnWY/LiyAGpFc8dfP3ICH77/WHkQATMUQUoQBIJbsqoarCwvnDkAcBsN0zilFNg918TBxbYTTEopaopgbbVdKlaFYF0ofbA6/QzrvWwq1aBYqgzgsxoJO6MdN5qwOX9fiVyoCZGy11zliwtebIZMu80OT72pC6rR8KUYaI1ag0XOCjnH4QALusbJijO0DLqcabSnvB45WVLA8DVjKYwq43Fd5wKU+2D5o/YDLJobTFabqQj2syJY8O5bqPaGLMuV+hgV6xNFMIkEmklUiWBZNKECweqPgmC5QdrZ9T52tBPjjOWFmjcGilzoAKtgSmh+fyaaV11V0nAfrNlGjFsv34FXvmgX9i00jaIeNx9hsnUrhWnazbdL14icPELQiF4YoghykQjAvivcXkGuyIWRpmY1WC+/ahc++eP/AK+4ejcAi4B1M1LGpPPIg3qhz5uqP/LFLAxFcGAfLOjzY++ZtW6G2WaMuWZciWClWa6FPvQXLIDlFMFJ57pGBUXQ/64RS1P/luYFdmvaGSn9+hRBQEmRAxaV2tFuYGmj76gG03nxqYJ75hqOQA7tl4xqjqQIUwS7GmmkbXDp91YS4f99+8tw9Z5ZAG5d3KPHVrDRz5iKIO1PffLnm8az1k2dGsdBRuvQeRrUC4v/lmaF6c8IlGmCVJNG403zwklUcIpgVIH6bVerA6zaahtgXTbhAurF2IilQ404n0aysYNoHFVGL/A4UkXClL2nImCfk01/GwSrySmCZRpOvBkI1iZS6mwfpqk3NbFdCEqG58s4ElBlUloEi+6rIPVLClPvw0UuAPXMpoEaLMD23nHqu1j/mePL1unma7eSMkUwZpls2g59D7h9sIDBMulkXEUw1NdKiVyoY1ha76Oh+3MFESzTB2tIDRZl7QciWMIZ39mNPhZnGo64zvJG36MIuuermUh0Urf5axVFkNZsJRHaDUunchGsCDcdXMB7v/tVaCVRUFSHI5V8nlrtps6cScE4nSJy8sgRFN76ZJy+ao4pUKebZu792GC0Mzqm2WaMK3fPWASMmk5790E7UINFLAafCmgRrAEiF+yT4oG1XorZZoS5VoKVincL9cDaNdvUx2iDLUITFUUwuPpQq6QIsvMhhTpGHkDumm0gjoSlCOoBUGICAGaaNjkIAIszCc6u952aa45Y8e3wJu8JowOTUZ8nHhxxo+bodN67Ayi6VBe33ktx569+Gh+6/5g5n74wC0f7KLGzpu/zUZI7JsAagSLI/aIeowgCKAV0ftN4aphOZgVfKCgdOtRtY3WAVVttA8xMuCxYOLDQwpGlTtUq58R+97NP4Xc/+1Tpe8rSTUITpGw0cdhpDqYJ0iBY7IXuUgRDIhc2W7UZIheWKjT1pi6I4GYzj2e72SgUzUhY5TAK1kOOsxTCUFEIubLocuY48dxsDZYdRxwJ00vqe19/TWm8attlkQtyokwfF9MbxyJGHFkepQ7LRbDc5bNcBQLkAPWy3DSaJXTIXZ6e33IN1kNHl3H7f/goji51xkKwKNu+vKEQrFnmtK50Ukfkwk+wtOIIPR1g0an0lQv9Gqxff/vL8H2vv4ah4nZ5Xzk1NN9IIZxm5bRfjlSq7XoIlifrTnOcTzt16NEDEKx+lrsUQUM7s/ue1bS1hglmwwFWK1CDZQKsuALBCvbB8sbiIFgpZhox5psxVisQkFXdjJiadHf6OV60dw43Hpg35ynNq5XohllVo2F+Pui+5PfRrtkGYinNvWpl2hmC1SCKoA6w2gm6qaXbN5jIBSV46DD2eo3RAffZUnVSNjjyraPrRi1F0G1ezE1A1SRxdM1H1Oiapax+zCBYPUXJ3RihpCH1KYIj1GDNNWOkWuSCzo/vi9iaNPudq8jInjEZbs68Xa0OsGqrbYBRBo3XChza0cKRpY0tHcf77nkWf3rv86XvCcGaKMAiBEsKJ8NJfUKoOSp/ObeTCF9+5U68+trdJpPH6xQo9yxFuL/LuLaZQdEoNUDn2jhd6VKz0UUuqAYLugarvHwkhHEa6P609ZFhFUHAorEc2UikQoGe+rk78UNMyYzHdc2kXINF2/drryxtKA/SdgbZIIqgajKq5iLbZFWazxDixZfhdSIPHVnBseUuvvT8kplDBtVg7dMqi5RYOrvew2I7MUEBoIIuhyLonTDaPqc5+RTBDS/AuuXQIvYttEpZe6AcYIUQc4FyTy3AKvKR+TVYpg+WcJ0//9ZVdVlwlvURKECrCDoUQYuOSBNgxe76hl7qKlvyQDjxA6wKimC4DxaNwf4/1yp6/azAXDPCFbvaePjoCtZ75fcLsTj26ICjm2b4ppddjg/+0GvN+ewzVGtcSyIRpKnx7yx13x7f7tkmGrEw9zWd9nYowNLngJoNE22U98Hy0dM9LMCyxxkWuQgFCyRyQe8ASnAEEwRS3ZO+mAj/tMIWajutWJp5h9YbxT8wIhc6aTJKgKV6ZikE6zKtXFkOsMroL39UDUVQJzBGQdu2i9UBVm21DbBelpV6lRxabOOFs1uLYJ1c6TnZYbKOQbBG41lz402UeeaTtkWUAwq+qLj35Vftwu9/1ytNJl0IPunDfG4ORXDqTbBtnX8Ey9SBXXrxlb03BtwWUtgarEEiF0JY54E3GgaUo5fmBaKAw2JFLpiKWgXS6tZglSmCshRg6U9DG3IpgqPUSfYypiIYogjqMZCzyNtHVCFY5HxyZ4+e8WdOrxsUfBCC1W5EOLjYwlOn1pDnKqO+YyZxaFcr3dSh95QQLH3u13XvvNA+aT4T3lBk4FrNeEFDlYNq+zzZ7Rz1GAhVfbCsyI6mo41CEQzU6aZZ7qBv3Kk0CJY+l76gCA/UWh6SmhiKoLqeZYognDG5Y3fHLYRAntvnaqYR4xteehnWehk++KWjzrqff+o0fu0TjwOwCBY/XtpvlhdOH7FxrKoGy0GwPPQagBa5kCboifRgHJELfa7pkhCCTcgmf95jdv8AHkXQq00EWB8sGVbEI2Gekopg4BoJoQKO1a59tu39pv5Pu+CME3p3jxNg0ToUfPYGiVxkFsHq5wVOrvRM3VgIweI90tTYebLB+hdS1CIXtdV2yVgvzR16IAAc2tHG0eXOlkHZRVHg1FoXa4EsIk3O0yBYSSQdigX1kTEUI+2gtb1eQNxJsIGDfVlvTh+szQuKaBPntdHwBRDknS8T7N6ostirwRIiHABFvAarRBHMkbEGo9ysyIV1+6oSAT5F0PQNkq7jRc+BrdPUCFaWO0GVT/kLGXceuwEEy6c7Ndixd9PcqSsqIVhs//SMP3tm3VCUBiFYAHB49wyePrVuAqnFtpJpbyVWXhoAds4oZ7Xch8z2IaKfmiZAtAIlQLjWCXARLF9wolpFkKFQehWfIljZgJitG2oKTE6hGo/6rhEIsPqZh2Cx+h5fRtzvOcYRG47CqGXVussmwBpHRdBdhihtdA/NNiO84upduHLXDH7jk0/gFz/yiLk+v/mpJwyjggKOLqsBpHOiRC5Kux7JkkgGhVn4M+KLTwHAbl2DRUbXMImkOV9tVosJsABruYxg0Se9Y3mARdfxyNkO/sdnnkSeF07NUShWMBRBvW9Tz1ShlloUcJQc/evmS7O3G4run+WFaQQ9So22qblObJPoKuMI1pJGrinAWu36NVguJZuOi6wR2ftPoX5Dh7ptrA6waqttgPXSvBQoHNzRQpYXpZf0OPb82Y2RhTKWOyn6WRFEsOil5k+gf3rvc3jHe74wcLs0gcaRWyS8vOHWYNHLyH9J2wArVDAdrp0Z1za3D9bmbWtSE54zdqmZ/6It/c4daEKwqmqwPIogOfDdfrgPFmCpUgp5UN/5VDYy/q0KALRzRtswAZb6tL1xtHPJGg0DI4pccKd8AIJFGfgmQ7A+/9RpfNm//TDuf2FJLe/1wUodBEsHWCMiWABw1e5ZPH1qDUtaZXTHTAOtJMIHf/C1eMcd15rliEJVlmlX29/gCJY+l3NN5eBSTy7/koyiTMol08m4ciDVhwJlBMvWYKn/G4ogQy/8LDyNy6+JCVMEPQRLL8NFLuY8imA3iGC516gZqfNXJXJB4w2JXBAlca5pa2nzwgZrC60EQgi87fYr8dDRFfzKXz2Kzz5xCgDw6PFVsx1OESTjveAmrsHSzYJ944kKUo6k+2imEaHFejUCLh2Nnl2jIqjPPdUTn9a95UIiF6e1Uh6nCNJ+fumjj+D/+d8P4MMPHNOUOOHUtHHr9FVzdLoveR8s32gbvhw+//RFLugY13qpmXMGSe2T9TP3fe+jh5y619Pqka0kMhLtV+ycATCoBosFvQGRCzpnNUWwttouEetlhemqTnZIc41fODt5HdZbf+0uQ7EYZqTQs9Z1A6w8L8wLyKcI3v3kaXzsoeMDt0sTaiJdBIsmSMq+k+Pqv6RjVpzqK/QJbBaCRZ8XFho2+RjU56VYgwWg9KL1jaNOFARVqQgaClzioiAkchGswWIIlqWdjYhg6f9SQFeFYHEFNa7sNaimwS5TBP8GXPUtOg6OYFHW+pOPnDTL8/Hy/S8ziuAoNVgAcHj3LE6u9vDcGdXOYYfO+l+1Zxa7Z63TaQMsnyJoa7B8Ot2CdnC7FQhWqA9WyPx98qCKi1wcW+46iAGdV0sRDCBYotwHS4hqiqAvZc3vYwrqJUewKMAagGC1fAQrdtEVX+SCxhuSab/p4AL+6J+/Cq+4WvdckjCCCoBS1gOA7/6qF+EvfuA1ANQ7r5fmePqUbW6/2wRYDMHiFMGJESwRpggyGi09exR47pxRdEX+7PN2DZSYmGVBpfreKnMC6hoakQtCsLplBIuuHdVwvf++F3RAgUq6m2qObtkg3TQPoqOASunkhddvjN07QFnkgoJNOhagjCqFjN73dCzc33jP557B1T/xAbPNXpajEUskkcTpNRV4UquL5ZFELuzfnCIYyVrkorbaLhnrpXkps3tokQKsyRCsoihwdLmDU2vd4QsDOKUzZxu6vw8Zf6H5k9p6LzM9Z6qMJtQSglVSESxz2AHrCPAsMb1MNwvB8hW6pjHhjfF82IUQ5J1PGxpgMSeUarBCARB/QVMCYNxGw8NqsJx9MJn2dsNmXAGLYCUegqVUBMcTueimuXnOPvLAUbz5lz5pkAEXwSLFOYtgkd3z1GmzPADs0w6hK6VMCNaGyaAPQ7Cu3qMy1H/33FkAwA7tgAM2QAKsA1oWueABDZx9ksNLIhf+LUKbGjan+PuUztzERS46eNHeWbNcbJxV9X9fRVBo5NW/Ffn2Le2RalhYcJ3nDkJhnEpha7Dmmm7QHJJp9wMlK3KhA4MxKIIAcNtVuxzqbl5YBgPR5qQUuPHAAiIp8MLZDTx1ag1ZXuDHv+YGvOMfXIsb9s8D8GuwNIqb5RPPdUkkg7TaIEVQH99uXQ9WhWDRc9P2VARnEnX/nSEEK7KNgH0qqkMR9FQEP/7QcXT6mVHS9Vl2mU6KKhVBCrCyymSkFAIFCk/kwv2ke7bPRC4AmEAZGFHkQm9o96w6h8ssafuTf/r3AIATq8rnodKJJLJiQ4vtRPVNC4hcEAJsjoGd0wZL1NY1WLXVdglgXi4BAAAgAElEQVQZZWq4HdqhMjWTIlgbfSWdOmqz4lPMMeIqXbyo3acIbmh51kHNAvtc5CKAYPmc7DL/fxBFUARFBsa1zUR8LgT0yH85XmqmXrTVv3OEgF7KjVANFluO7l0ucpEX4QCLNxqmX0MURLV/jmBZFUFycmMvsDI1WESPynMnAz+ayEVugo17nj6Dh46umEROVlgUpCxyYY/hnqfPIM8LG2AttJBEwkkIkUO+0c/w/JkNvY3hCBYAfPHZQIDVtn+TAxqSaSezaA9RBNUxV9dgjYZg+UIB7txkn7tTaz2jesa3X3g1WBydoqbD/vZtEKY+G+w+JPP7YDkqgh7t09ZgqTHwgMKfg2mbpPzqswysTPtwV4/oWUtegEXjPLDQwvNnNvCYpge+7vq9+LGvuQEzTUpslHugTaciKJGx+5iMerHNN2MHwQWURLtalznzzlyhxjrr1WDReT1LCFYizXPszw8hkQsKgNZ6GR4/sWbQTp7g/Bd/dB/efddTZhyWIpgH6YGAFR4JUQRpDjQ1WB6l/6yDYI1CEVT3GZ1Dug/4+V/vZfivH38Mn338FBqxS8Wcb8WYb8UVfbBcBU4+f9uWBaqW+yKKr+oAq7baBlkvkF2ab6ni7kl7YVGGx+9vUmUn12yXdC500WEvcH9So0Cs0xsUYJHIhTAZwPlmjNWu4m7ThFtZg0V1BLKMYAlRXdsyjnF0bDO2BVwgNVg1ghU07oQSOlDVQJasrCI4oNGwo3yp9zkCgtWIpNln25N49vtfOQgWo0iNJtOeGSSDEKcjOpHDe3tZkQs3E79/oYmljT4ePb5q9pdEAvsXWjjKWkusdFIzrkePr+rzPPiePLxbIVhffFbVeC22G+a3hVY5wPLnTY6u2Bosdc7miCKo50R/JBbBGjzG8r3ii1zY9fctWEfZ1rOo/1MsHLE5g4QunHFJvn31XbgPVuEEnOS0R9I20iYVQbqfaP7lQbrPIhBCoBFLpiLoy7Qj+H3ISKY9FGABwGU7lHruY8dXIQRwzd45Z0wdThFk53PyPlg2SONG5/WV1+zGLYcWAZQDrFDPMYAjWEQRdL+nY29EEm+8aT9+6i0344pdNhAH1DvSblttwG/GrPpguY2GP/ClI/jIA8cAKJTJyrRnQYELGl/h1WBRLbYw55horW4NFkewRqnBIjon0SwpaL9PI9aACtTe9aGH8fCxFTRj6Zzn+ZZCsIIy7dJ95/G/nXpEUVMEa6vtkrF+VpQQLEDRBJ+fEMEiOt+oCBYVkQJwhC46TLXJn9RoOR6E+WZFLqShFVypnajVTlqq4fBf7hRAcbqVVdQKU7vGNSE2Lxi5EOh5m0l53I52560HTc1HyFyRC+ANN+7DHTfuKy3H0RO/D9ZGL1PKVQMCLKVuRghU+GJwx5DTy2gb5GybZqcGwaIAS4ltGFUuRnf63BOn8NDR5RKFt5daBIue7xeWOiiKAk+fWjfouanB0vt+TqNQb3vFYQDA3z59xjy/UggcXFTN0T//1Gl87olTWOn08SKt+vXo8VWnJqTKZhoxLt+pFFQB1wGfZxTBK3fNlH5X583OB6Z/lx4/rV+FYI1ag+VfS8kQU/434DaMJR/cNBo2CJbdfyTLNVi+SiFgg0Zf5KKqDxbVCBESRMtRLaFDEQwgUY1IVvbBshTBURAsFRAsbfQRSWFQRbLLdqp33qPHV3HZjrZJNJjG1wGKIDD5XOfXopHR///d19+Cn/3GlwBgFMHZUA2WXZfG7DcapmMg1KcRSyzOJPjO11xdei74/yl4W+umzj6VTDsToMhUE+Nj+tlpJRGjCFYjWHRNOEVwRddTGeXLnM6LyzhxAqyREKwCiVRsliQSWNroY2mjj9/69JNmmdMs2SuE+7wtaATL31c3zRBLt48gn5vJ94ijamn77Wp1gFVbbQMsJNMOADtnE6eIdByjCaiX5nj46Ar+68cfG7g8r9XihaddB8Eq12ABCCoPktGEHEuLYF2laUDLnb7TVwMIBFgxpwiq76wzs3ky7ZsXYLmf58MkOz+Xov2nt34ZvuaWA5W/R15Q8447rsM/e+2LSsu97fYrzd88sJECRpp4EIKlVLDIya3OHnOjoZUDLPdT6LqavkaB6bkhwYtHj63gW37jb/DmX/oU/q/3fMGhDnKKINmRsxt4+tQ6ljb6+LLLdwCwGXg69idPrgEA3nCTCkZPr3VNgBVLgYOLbRxZ6uDf/Nn9+JkPPIiVToqbdfb/xEp3aP0V2VtuPWT+5oknHmBdv38ef/mDX4XXXrfXWZc3g33jTfvVd4RgeUFluQZLfVGFNpL5v/P5Q3hzyX4mLU/fk7or1bpyBCtEb+V1WUZFkBAsX+Siog9WJGAEA/j6v/xXj+HOX/kUelluAoIQEpVEwiAovsogObJ+Q+eQNROJjV6GM+t9LLaTUmBxaEcLR5c7uP+FJVy3b85879MWAU9Of1IEi3pM6ffU0aUOfvYvHzRBOH8vtwyC1SyNie9/xgsKuWBEO4lwdsOqCPrGKaVkdL+tdTNHXZCEnyhYoNquoyzAolPU7WcGrfNNCK0iyN7v9LetwaoQueA1WCMEWGmWI47UuBfbCZY7fbzjPV/A++87YpJcXH3zuTMbDn1SMXsSh02T5QUeP76GF+2dde4n/pi+7PBO/Mw/fDFuO7zToKgXi9UBVm21DbBeRXapnUROPdQ4tmoQrAzvv+8FvOtDDw8MhEjkAgA2+owiyBAsnwJAL6FBY3T6YHkI1nKnb343IheVNVjlLO4333YF7rhxf+W+RzU/6zzdtqyjdb7sQkDRLmSLKmonfPuKK3eavy3tT6AZR1jXNNpQ4MSVBmnzVbSzUL0NALRZ422g3GgYUI5XpmXaWx6CdUz32vnaFx/AB/7+KH7+Qw+b9fppUUIOXljq4IuapnOrDrDIUaTn9rt1EHr9/nnEUhWec6GGg4stHF3q4LHjKziy1MFKJ8WeuYYRwBiFQgYA3/Syy4Pfx5E0dS3tRoSbDi6UEESOolAgaARKYskC1PK5p/+Geptx8+dqKeFsl99TBxZ4gKU+f/ovHsS3//bdBiXh9VVcUt2uxwM49Z2pwepziqCLYCUGwVL3Kb/mtP6DR5bx5Mk1dNMcO2cakKKc5PKPuYRgeajrINs/30Ivy/HMqfUS+ggo9dwsL/DEiTW8+to95vtQcO4gWEP3HDa/H9hHHzyGX//rJ4xEPA+Cds818c7/42b8wy+/DADw9S+9DD/ypuvxVdftwUsuXzTLzTAaZhK5iORMIzLv1NAxfezHXoeH/v2bvTGq9Ve7KWYakUk0SKHOPbHdCPmhxGeLieZ0KpK4gG40DBeBomQqPV+Etvoy7RQsJpEYiSLIhYEWWgmWNvp48Mgyvvm2yw1SeHzFFeaiwDCWAq1EYq4VO4JbT55cw0Y/w80HF1yKoFOPKPFttx9GHEmHIrjaTfFd774HT+nk0Xa0OsCqrTbPnjixijt+4RM4utRBNyByAagXVmfSAEtD/L00NzTBZa+G6vRaD++9+xnkeYFTqz0zAXMEi/Y/14xL6xsEa8AYqQA5ksK8eK4mBGsjNRTCVhzOntLLhReS07T5L7/2Rrzp5ukDLFJj2gzj6Nr5Mk5Xqq1svkz7IPvgD30Vvv+Oa41jDyjHhZ6RkM9Cz1E3zc21qKbn+P9XX9CzQs4IbZPPE4mU6Gc50jw3gQU9T+T4/PCbrsfrb9jrtFPgaAXZkaUNfPHZJbQSiev3z+kxuCIX/+RVV+Gpn7sTjViq5E8v1zVb6hk6uKic535W4ORqF6vdFPOtxND5Rg2wrmXIhW/zug4rFATw3193/d4SrbIRSxNshZ5Pg/xK69CFjDLq1OxYCIF/9/UvxttfeRjf87prnGu6f6FVEqgAlEjI/7jrKWd/NMfR2OieU1QwN2liVAB1YHBipYtumnsNalkNlhTONef3YzfN0e0rJdv9Cy1TY+Qc86AAawyK4H4dcD58bMURLSE7xBAcjkLTuXvJZTaQcZ/jySY7QofoPNI7ztRJee/lf/rqq41U+Fwzxg+84Tr83nfejoOLdty8xUISSScQ5AnE0Du/GUel88tRyWYSGeoy1Y+eXuvhjl/4BB49tupuK4nMealK4qrt2BosukdSRv0FLK3VT4iSGuS++dZIFMGUKV0utBOcXe/h9FoPBxZaZt/l/nG2hlIIgT2zDUeU64EjywCAWw4tuhTBinsiiYXxie556jQ++uAx3PX4qaFjv1AtHr5IbbVdWvb5p07jiRNr+PxTp9EPyLQDyokYVN80yCgD1ctyo7y0vNE3LzgA+LVPPIb//qknMd9KcHK1i8t3tfHEiTUTOAE2wNo73yzXYJHIxaAAK89NndTXveQAYilw86EFPca+5dgbeop7Hmgy5kHQZgcvPHibflvWWTpftne+CSls75jaXBunduPGAwu48cCC890wBMtIuTOKYBXtrKr2omUQLBe58hGsNCvQzwrz/JADRHUeO9oJrt8/j7seP4Vc97hSbSEi3QNILX/krEKcXnxo0Tyvvoogt3YjwkY/dZTQDjAnkxg4C60YV+6awT1PnxmZIggAd/+rNwQFehbaMY4uVwdYi+0E7//+1+CGA/PmOxNgRZE6lm74+aRzT+f4W19xRXAfcaQy6TONGGfW+5BC4NXX7jGIy12PnzTLHlhs4eM/+no8cGTZmWNuvXwR9z23hEgKEzyTiiAFU4vtBGu9TCFQ3rzCg3hAIVEAcPNBe6/a5JTAS6/cgYV2GcEiW+700Yglfvs7Xo6dgQCLzmESlRE2n9Y6yA4sqjnpxErXGSsZUeRuOriAK3RgTvaxH31dsD8UH8O4Zmuw1A1L7zii5lepfw4yChQSTcnkY+NBbhWi5Bs/TiW9nuBZbDgo7BMn1pz7DlBJSz780HMMuDVYl+1oOw2erYog9KeHYOnzdGCxNRqCxZQuF9oJHj++irwA9sw3jQALURx/+VtfildcvQu/85mnAFiK8J65JpY7Kbqpaqb8wAvLSCKBa/fN4ZFjK8Hzxm3PXNMwdh46qpY/vjKZmNiFYHWAVVttnj1zWjVRfOz4alCmHVCO2sYAhb5BRi+Kbj83lAQfgSJH4rc/8ySOLXfw8qt36QDLTpT0At8z18DDR1ec9Y3IxRCKIAlV7Jhp4JtffgWe0Q0klzupGYORaS8hWNUUwc2yza3BOv/0vFsOLeILP/Um7JgpO0q1udScSa5TM5EDa7C4wpsRuRixBstXZKO4jGoR+djjSCLNc6SsBosQLMrAL7QVgtRLcxxb6eDgYhvdVM03jUiirxuqPndmHWle4NtuP2y2P+OJXHBrNyJs9DLMtwrjxB1k9UZk860Yl2tH2e+fNMj2zZe3BVglwUHB2osZysH3S8cMhCm8r7pmN77xyy/DfDPGF9/51SUaJZmiKsZmDP6W+D21a6aBPXMCV+6ecWhI7/6nr8DJ1S5OrvbMtSZEgpzahXaCF5Y65nu+bVL263kB1k0saOHNVf/5665xxuijGWfXVYB11Z5ZhOzGg/N44uRasGcUjXeUAJon+EIUwct2tNGMJe58SbmG8kV7XWSTo0ETqwh6FEFCZM5u9JBEIihiM8xMgCXLFEGqa+SKoaOOEVDnmLbvy5Lf/8Kysx6nCPrb4SaFrsHqprhi14wTYNHqVkjDrZle2ugjiQR2zTbw7Ol1DLN+VlgEqxXjBa06umeuCalRVhLpuGbvHA4uts0cO99U9wsF2Y8eW8V/+vDDeObUOq7bN49G7AazVce7d66Jh44oX4aeG5+WuJ2spgjWVptnz55WE8vDR1dwdKkTpGW0Eun0/RjHjMhFlhuhCpJE9Zf526fPIM0LvPVlKmO7VoFgrXZTRhXIDa1iUBCoilrdKYAyUSuOyIUbaJHxOgIjcrHJM4r/oppuW+rzfJc/1cFVtV3OMuOTOGbNWGK969YoOL+bGixLEayWaR+MBlgEy0VXAKWw2c8K9HNbg0UO0NJGH61EopVERvr86VPrWjEuU/VILGhb62XopjnuvNU6tjOepDc3qg/NciuscFCrD7rKf5YiOA6CVWUL7UQ5jmM4vhx9oWMJrf4VV+7EL37LSyGlKsCvyoA3IoHZZmwCt6p+WoCvWGn/3jnbwHX75/Gqa3Y76/J2FHQehRD4isM78cab9jvzSjOSZm5/6OgKDiy0HPSJHNNQEsG/FiqgqL4+P/G1N1X+NqzRMDceOIcCrNlmjA//8GvxPV5AGDK359nQxYNGzxUFqpSYPLveHxlh8o0CvyQSeNPN+x1F05mkGhWuMj53tJLINmcWcIJ2Chr4sm6AVY2i57kKsPZ7iQ3aFyVXDaWfSc7PNGLTeoXbSqePp0+5tU1pnpv7ZbGdGKSbgqaZRmwogpTgoPuS/AZa9qMPHsMnHj6BJ06uGVYMHe/OmQRvuilcPrB3vomTq13keWHO2fHlOsCqrbaLxgjB+utHTmC1m+K2w2VZ6alELpiKICFYXPEHAM6s97FjJsE3vPQQfv+7bsfrb1CKXBscweoTgtVUNAIjzW6DqkFj7LGMFRlNlMsbqaEcGBVBrzakEUCwNjt28QvTp7HFmQSxFI7aU20Xlr2IZeknccxaSTRYRTC2TVEpgKumCLr/N01JTYClvg/VYMWRRJopBIueHyrePrveww7dQ+rwLnW87/v8s7jlnR/UyLEwz+V1uubqyy5fdIQ9hlEE13uZqcECgD2zTbQS6Ujez2uKIDB6DdYgm2/FlfTAKmuyQLIZ2/lkUoulQhEoKVSFQvo2bJdSuvVWttYGeP0N+/Cb336b25g6cRGsGw/OO9uj6xYKFP05eWlIQHHFrhn88re+FN9/x7Wl39qNCO0kGhig8TGRzHkowAJUs+lRtkWIBzCFimBMtYvqueE1WH5D6VGNgqg4kvjZb7wVb73NUk194ZiRxsjQ71bMAyzx/7d333FyluXCx3/39J3tPVvSNlnSSEggJEASCAQI1agvIhZE7L72rhwUj++rB48eOBaOHo94LAc9+FoAPYogRGkhIQlppJC6STZts9lep9zvH0+ZZ2Znts5sy/X9fPLJ7tRn55l55rnu67qv217GJehzx3WUhPgugpA6o6MUaIy51zmB+Kzt1KIg184r48fPH6KlK9SnTXtzZ4gcv4ecJK3TH3j6ddY99KLdLROM19k6Fjrn4Fnflzl+t101Y22LFRha8yutAGubuRj5LYsqeJtZzruqtoR7bprLC1+4hvxg8vdXWa6fcFRzuq2bgw1Gtq5BSgSFmDysdLoVnCydUdjnNgGvm3BUJ80CDaTNsQ6WncFKKBFs7uxlZkk2/3rHEgD7QBjX5MK8r1Xa0dplHFCdZYT9lwhG+4ycWd3AWrpiGazibD/leX5mJUxw9zhKejK1gG46M1hluQE23rMmaUZSjA/OVsjDKhH0uGjpMkY8k5282h3ewtHYaHbKEsHkc7CsExjPAHOweiNRojp2e6vUqdkcPAGj9bXHpfj9tnp7xNhZLrd4agG76lt576qauBP42Mlg34Amy2zAE4nGFrd1uRSPvG8504uzeXLXKbpCEXIDXsrNxXbTkcG6dl45xdlDG7ywtt/ncdknoSP5uNeW59DWHeakWd6UWDRnvYaJJYbWsa4kJ/mxwSoFnFmSTXG2zw5MU71HfW6X2cQowoEz7VydsJab9d5JNghgrI0V66bW1hMeMKuybnFV0svfdfkMViW0y+9PeV6Axo7euHXmhitoBvojn4MVn8Fq6w7b3S+Hyh6YSPKdHfSnzgqn4o7LYLnswEQpxXfftoSNh87x+1fr7YDDeVtnl0lrjlMil9lVr7M30mf5BjAa5dz83Rf49KPbuHh6of3YYJwPTMkPkOP30N5tVLhY7/+tR5tp7gxxuLHDXjA6HInax8L8uADL+Ew4nz8xg5XnmIMFsP1YM1634rt3LHEMSvj4wJX9Zz9LzSzdSwcaCUc1uX6PlAgKMVl09IRp7OilptQYWa7MD1BdGOxzu2Sr1ydyjg45WetEODNYrX0yWL32iuoQW6fDmZGygifry8aa1NrtKAvsN8ByjFg55WcZLVqtSfk5AQ8b77mWq+fEnyTEdxE0t3McN7kAo7nEWLZpF/1zDlYMJ4Pl97hjXQT7Kb8aXJOL+N/tOVjWyHxCm/bELoLWZztxoeHmrpB9AuNxu6guzMK59IvP7bY/WytmlfDUp67k1kUVcduS1U85k3WcCEd13GfnkulFlOT47flYeQEP5bkBfG5XWjJYt15UyVdunT+k+1glmz6Pyy6Beufl0/u7S7++tu5CHnzrYjtwS2zGYe3DxBP0ivwAU4uyeOD2xUkf11ivSnHpjCK2fPk6u0lNqrbxVsC4/3Q74aiOm38FsfdcqnJK58CX1kM76XcqyvZxyfS+A4SpWF34knURHCqrjHXEc7DCfb8jh/t6ZPcTRA2rRNCx//yODFZvOMrcKXncdcUMe9Co0Lk4uscdNwBUnDKwj3UEzvG7+e2HL+fpT11pX7+gMp/7bp3Pc/sb+Ja53IOVpW/rCZNtZrDCUW2fO4QiUXt+0676FvuxmjtD9mLX1nzKgDe2hEC2P5a1stceTCgRtP6Ops4QlQVZQ54nZ2XAnt/fAMCK2SU0tPWkPJca7yTAEsLhWJORvbKCiaUz+pYHQmyUKNX6VYca2qm550/8dffpPtdZ6fqecMSRwYpP4Td1hPqMIgZ97rgV3a0RMOtL0Wr/3OlYK6v/hYajSUfv84O+uAxWypbIyUoE0xy7OCeRi/ODdUIynBOzgNdlZ3CTBU7WiUFvOGK/r1JPMLcCqPjsbCyDZV5vrgXjczyfx63sz15im/aWzvjP9jRzaQTrz/V5XPZJXm7A6DSY+FoMpkQwGtVJW9Vbx4vcgBeXS7F6TikLq/p2jRsNzi6C/3L7Rfz101f1O6doqI/bk9Dp1donJQkBVsDr5vnPX8OVFyTP9iSWKsc6qCZ/fp/HyFC8fMhoMX1pQhWEPX81VbvqhB033DlHQ2VVQ6QqERyKWIng8O5vvUb3P7mXX2w4ElflMdzX4+o5ZXz5lvlxCyVb+stupd5GR4mg12W/bs7Fdq0BjZmO8ueA1x333knVVdb5nsvxe7lkehG15fHlpnevmMnblsUWXneW8mf73VxoLij++LYTABxsaLcHHqzmG+FIlJ31LSwym9BYf0eJY0DSWpogx++xL/MllAj6PbFW9ckWZh5ILMA6S8Dr4tKZRYSj2l6oeaKRAEsIB6uL3pp5ZcZkzBRrOVmTqFNliPaYEzQ/9ettfa6zWqaGIpquFBms5oQMFkDQ7+bAmXY+8shWWrpCdIcjuB1ziqz2tc6gaqCFhpOdhBZkeWnp6rXnYKUa4Y8FWNjdytIdYDnLD8X5wWr8oIcxaGm0abfWwer7vrGCi3csnx6bg5XiDDAxAIstNBw/tyTVHCzrs2dlvKwBi+au2BwsgJnFQZSCd5pdAps6Y00NnO27nazsgD/FIujdvRE6esP27ZK9Btao84/etXTA0p1McZYITi0K9rvO1lAE7ONzfAaryTxGJuuq2B8F8W21E4LuRH6PMe/mpYON1JRkx63FBLESwVQj/Iklm8PN2AyVVTKazgBruEdv6zOw43gLf9h+Mm4pkpFksN67cmbS1z1xbbnBcLtiJezOJhfObbXWD5tenG3f1u+J7yKYqjTV+eJl+1NnmRdPLbB/dmajs30eVtWWsGRaAd97Zj894Qi76o2gqiDotTNYe0+10dkbscsMreOOc76ylcFyzgVLzGCB0QkQoLpw+AFWY0cvc8pz7c/pRC0TlABLCAerwcXcKXls/fJ13HpRZdLbZQ0QYHX0xurFdxyPr7+OX5U9fvFEMMoLOnojcSUFAEGvh42Hz/E/O0/yxx0n6A5FCXhc9ohRc1ffACvxBMMpFEm+wGF+lpfmztik2VQdu9wuxcfX1HL9gikZnIMli/Keb6x21FZL4KFwnpgmyw7kBrwcuf9m3rNypn3ukur9bY/SWi2/E9bB8iSUCCZ2EbSODX1KBBMyWO9bVcMP33mJPZjT7AywAslPdKsLs1hUnc+CJJmnoM9NZyhCW3fYnhvhNL8ij4r8QFrKAkdqQWUeb18+rU+GZ6SsfZR4fF4zr4y3L5/GfbcuGNLjJS4XYQfdKc6gfB4jk7rp8Lk+3Qid9x9vGSzrhDY9c7CM996wm1w4/ubjTZ1xa0BmIuAcTpMLiB0H/B5HBqsn9n1eaXbwLMnxkRfw4vMYnTbjSgRTzF10vna5ST7LlkXVsQDL2WjGWgD4U9dewImWbp7cdYpd9S0EfW7Wzp/Cayda0Vqz9WgTgF1Oav0dzrXNrFLBHH/svWHtI2fQZQVlVQV9p1YMJNtsygLGOZhVyisBVhJKqalKqfVKqd1KqdeUUp8wLy9SSj2tlNpv/l9oXq6UUt9VSh1QSu1QSl2cye0TIlFdYye5fg+FQW+/mZNUI6SWZkdK+9m9Z+Kuc45uWZkrZ/mDdd/Edt5BxwjWn3aepDsUMVaPN0fDrTlYzqxVfxmskGMSvFNB0JiDFbFLBFMfJj593QVcWJWf0XWwVNp7E4rxbIk5GjusOViOk4tUgZPFpRQeV+oMaaxEML4czM5g9RNgedzK/uw5m1x0h4yW684uWlOLgqxdMIWVs0u479b5fG7tXPuEOtVcmGy/hyc+upIFlfl9rguY62C1dofs0h2nu1fM5NnPrE76uKMt4HXzjTctTPvSBVaQnpiJsZ5vqI1uXCr+hNhZHp2Mz+1ia10z7T1hrphV0ud65xIXSe/vccU/n2d0joE3XFjBPTfN5YKy3IFvPIARdxF0VE6caIkfbMlEwJnVz9IH/bG+H/0DZLAKs30UBL0EPPHHE+h/DpbFGdgkcnZfdZYIXmWWvK6cXUJJjp+nXjvN5rpzzKvIY9HUfFq6Qhxv6mJLXRPleX67rM8a2HFmsKyAOWvf0WIAACAASURBVNfR7CKxiyDEgrKqYWSwlFKUmVnUeRW59tIBZ4Yx2DYeZLqLYBj4jNZ6q1IqF9iilHoaeDfwjNb6fqXUF4EvAl8AbgRqzX/LgR+Y/wsxKg6f7aCmNHvAsjR7DlaKAKapM4THpcjyue3Ax9LWbVwXjmrazGyWcx0sq4ylT4mg48C54WAjfo+bgMdFwGvM2bDnYCVZKysZo2tQkiYXQS/NXSG7e1OqEkEne42pAW85NC6XZLDON7ddUk1uwMO1KdZK6U9RduyLfqD3rcvV/22sa3wJJ9NWyV8sgxWf6TIucznmYMVKBK1MdbISLJdLcfeKmXGP1d+odSpZXqOdcktXKGkpnNs8Lk1mH7xyFjUl2axd0HdR3OFQKn5OoNUmPGWJoNdocuFScFlN33m8zu6OyXjdLiryAxxvMroh+tyjs7/ys7xpKxe1v6+GPQcrdaAzmFbxQxUrERzaa+1xKwilLhGcUZJNbsDD3Cm5FGR57ePCYEoErdu4XapPq/+42zneR87jkPX+d7mMdb9+vfkYkajma+sWUGsG0Qca2tl6tImLpxXa73FrYKfUsV055gCv85iUuA4WxAKs4ZQIGs/pp66xk3kVeXawJRmsJLTWJ7XWW82f24A9QBWwDviZebOfAW80f14H/FwbXgYKlFIVCDFKDp/tiJuMmspAJYLNnb0UBH0UZfviJmhqc1V2a9FJa56JM4Nl3b5PiaA5grRsRhFRbWTGjMmyioIsr50Ns4K+bJ97gAArdRfB3nDU7saWao6KU6aaXMgcrPOPUoobLqwY8vIHEKv/h4FHzpVSKVu0A0TND6d1wrKgMo9LZxTao7tWhsFnN2pwZLBcfTNYf9/XwL88ZXT6cs7BSsbrNtYRGs6JpHWi2NDaQ24/o96TmdtlvIfSdewwugjGfvc5OqgmY2U1rrqgNGkDA+uYmrILoRlgWY8/WnOw0slqez7cAbL+/uZMlggONTtmfUbjSgQd3+d5AS877ruea+aWkx/0xRYqd+z7VCWC1vv3our8lOXClpsWGsGUNWhanO2LKwO+fkE5kaimJMfH7UunMsvslLzjWAvHznVxYVUsG14Y9PK+lTO5cWHs9DvZHCxfklJmO4M1jCYXzvvPnZJHwOsmN+ChYYIGWKO2DpZSagawBNgIlGutT5pXnQKsocoq4JjjbsfNy046LkMp9QHgAwDTpk1DiHToDkWob+7i9pKpA942MECA1dQRojDoJZiQweoKRYhq4+DnPGg452ClKhG0uvisW1LJ7pOttPeE7ZKogqA3ViJojpAV5fgGKBGMkuPtewiwTv4aO1KvJ5TIGOEdfkveVFxKpZznIESisrxYxqa/0lYwBtb7y2BZcxCtDNWq2lJW1Zba6+S5E0oEE5tcWMcGqxX5hkONbDhkXD/QHBev2zXgCVUqVkDX1hNO2SRDDE1Rts8eFIOBSwQ3150D4LZLkn+X2HOwUhxb37SkipyAhz0n22gfxDpY41HQO9ISwb5/s7U+WGYCLLNxzBAf29qHRjBgroOVkLazvhcXV+fbJXbO1yVVUxFr0HTlINYy++4dS/jn26Jk+9zcc9Nc3nBR/NpoV8wqZlpRkPesmEHA67YDwj/vMk6v5zkyZEop7r0lfskFO8BylAheMbuYz62dw0XVseDsjYur8JnLTwzHxdMKaWzvtcuof/OhK+Lmgk0ko3L0VUrlAL8FPqm1bnWehGmttVJqSP2itNY/An4EsHTp0onZIF+MO0caOwCYWTpwBssKsKwAZld9C/c+tos3Lq7k3Stm2utYBXxuu/kExDoIJtZct3aF6AlH8LldsRLB7PiDrlUjPndKHvMqcnnlSJNdqmg1pnBuU2HQN3Cb9hRzsAAa241Ar79RfkviJPB0UfT9shIiFecX8aDmYPUzWm2VyCaezCWeHFsnZAFHaZHXrewAzegYBs6lXAbq0jatKNjv4Eh/nKPWww3SRLzvv31J0jlYqQaUakqy2Xq0mWvnlyW93jNAF8L3X1kDwANPv24EWIMo0x5vgkkWxh0Kb5K/uTTHz6nW7ozMwRpukwuvHWAZ8+buvXle0sYmAJ++fo79s3I8TapSUavN/4oUj+fkcbvIMV+XZGWefo+b5z5/dez5laKmNJtXjxpNuOZM6X+pBquLoTODFfR5+MjVs+NuNyU/wHtWzhxwe1N5/5U19vvf2K6RzwccKxkfFlFKeTGCq0e01r8zLz5tlf6Z/1tdAOoB55BPtXmZEBl3uMEIsGoGUSJoBTY9oShnWru57Ycvse1YM0+Z615ZncIKg964hhdWsOUsZSrO9hHVMO/LT/LbrfWOEsHkGaw5U3KZby5caX3R52f57Me25mDlZ3kHLhFMNgfLPPk7295jrP8yqBLB9M+/AnjDRZW8awQLj4rzS9mQAiySzkG0WMHaTQvjq9Stx7X+v25+Ofe/eSFTi2Ijts7smcfl6pNNGyjA+oeb5/Gzu5f1e5tUnK3ZhzOHS/RVEPTFTeRPbN2f6OG7LuXvn1ttt6FPZAUIA80THE7r8PHC2vaecOpOtv2x/uYl0wrsz1q5OacwE69Hf2vL9cdjlwga93/fqpqkzWcSDWZA8qPXzKYg6GXJtPR22bTUlBjLIuQGPFQOsHRBdpImF6J/GX2llDG88zCwR2v9gOOqJ4C7gPvN/x93XP5RpdR/YzS3aHGUEgqRUYfOGgHWjEEFWLEM1jN7z9AdirKoOp/XT7cDxjyqxVMLCHhdcSWC9eakZedzlOb6aezoJaph/d4zVBVmEfC6+rRRfuulU6kpzSHH77EP4FZ3nYKgl90njDUtukMRsrxusn0e9p1q47JvPMN337aEZTPjJ1v316Yd4GTL4EcKM5XBujbFOmRCJDOUDNbsspw+C3w7lecF2P6V6/uU2SUuEpsb8HLHsvhSdU/CosO9ZjbsA1fWkJ/lHbB8xph72O9NUsryxT6zqboQipHxDdDkojChpDDRQBksi1XuOVpt2tPJGhDsb5CvP36Pm//3ocuZOyWXtQ8+x4mWbqbk+dlOZl6P4Qaz1r60Bl0HK9X8O6dbFlVyy6LkS8WkQ41ZrTMnyWLmiXKSlAiK/mX6lVoB3AnsVEpZK67egxFY/Vop9V6gDrjdvO5PwE3AAaATuDvD2yeE7fDZDspy/YM6gDibXDy//yxVBVncsqiCb/xpL00dvUYGK9uL3+Omtdtoee52KY43GfM3ZpXGFtTMdjzfK0fOoSlMOum1tjzXXsV9fqWRwTpiLoxckOV1ZLDCZPncZPncdvedjYcaWTaziB3Hm3li2wn+4eZ5hKMpFho2SwSPnutkQWX/ZQOWkZwQCpEuzuzNQM1ZPnpN7YCPl59krpRngPkzEF9W6xzEWDajKOODBs6BmWRt2sXI+QbxHuhPeW6AD6+exeo5/c+tsbIq3gmYwbJK2odb6gpw6QxjUHBKfoATLd122+5MtK0PmvORhxq8eRxzsIZiPHxfWo0u+utQaAnaTS7kmDJYGQ2wtNYvkLpyaE2S22vgI5ncJiFSOdHcxdSiwS2OZx1Mm7tCvHjgLLcvrbaDn+3Hm+mNRCkM+vB7XGhtzLEqzPZxvKkLn8cVt0bEFbOKOdjQztr5U3h08zGeeu00dyzrv9HG7LKcuN8Lgl46eyP0hCN09UbJ8rrjRtSs7NxvtxznZxvqeMdl0wlHdL8ZLGDQAZZLjY8vDCEswz35HYgnoUQw6W2cGSzH7aYVD33xzaFyBpnJFhoWI2ed4A/3mOdyKb5ww9wBbzfcznbjgZ3B6mce8GBV5GeR42+35/9kom39sEsErXWwhni/TFR8DJU9YFsxcEnjjOIgM0uy7ekJYmBy9E2jHz9/CJdSI5rgJ8ZOc2fIXnV9IG6Xwud28fz+BrpCEa6eW2YfrDYdNjpIFQa99sG62RFgVRdkxR2M51Xkse0r17PvVBuPbj5GOKpTdp+yBLxu3rF8ml32l2/O12rpCtEVMjJYzhE1K8A60GCUMG6pa6I3Ek06kTjH77G7NQ32YJqpEkEhhitTAZbf4+JNS6pYPrPv+kYW58CF83M4tTDzAVaWZLAybqAugumSZWVVJmQGK74R1EjctLCC0ly/3ZkwE6+H1cRhqI/tdQ8vg2UNvHx8zcCZ9EyZVZrDT+++lMtqBm6iURD0sf6zqzO/UZOIBFhp9OzeM/SGoxJgTVAtXSHmDWF0xu918fopI2CZX5FHaa6fbJ+bV44YAVZB0GePPBqNLrI51tRJVWFW3ORnK9iqLcshL+ChPC8Q1/Y0la+/aaH9c4GZdWrtCtHVGyHoc8edaB1uaEdrzYEzsQArHIkmbWVtravV2NHL/EFM1gUjgyUBlhhPBrN+23AopXjwrYsH9dy5AY9dzguMygK/zs+9tGnPDN8ATS7SZbid7cYDq/S9OzS8JhdONy+q4OZFFTz8wmGAjHRVzPK6+fiaWm68cGhLr1olw4EhLlDscimO3H/zkO6TCavnJO90KUZOjr5pVBD02k0OxMRjLA48+BHfgNdNW3cYt0tRnONHKcXscqN9OhhdAK3RLavRxfEmY0E/5xemFWy5XIpvv+UiinN8Q15Pytruv+45w9n2XmMOluNEq7U7TF1jJ6dbjTlZW+uaUi40DEaZYGNHb9zaGP2ROVhivCjO9tHY0Tuo7peZYn0W1swtG9ZiwSPhDOKkyUVmjFYGywqwRvs9lA5Z3vRlsCyZ7KqolOLT110w5PvZyzUMscmFmPwkwEqj/CxfXMc4MXGEIlE6eiMDtk92sr5AynP99kF2xaxith8z1pUoDHrt0a3mrl46esKc6+ilujAr7gvCOVfq+gVThrX9c8pzqSrI4v4/7wXghgVT7BOtC6vy2FXfytNmC/mLqvPZUd+C1qm/uPODXqYXBwddYvSWpdXMncDrVYjJo8gMsHqH2R46Hay1Zdaan+eSHN+oredife6VghyffMVngjVwlukgfrjzgsaD7Ax0mxuPbevtEsEhZrDE5CdH3zQqCHpp6epFaz3kDIQYWy1mB76hZbCMg3y5Y/2I/331bP7tbwfNx/LZpUJNHSGOmR0EqwuDSTNYI1GWF+D5z1/Nq8eaae0KcWFVPk++dgqANXPL4wKsO5ZNY/vvdgLJF3MEePcVM+yFUgdjQWX+oNb+ECLT3r58Gv/4h90U9dMmO9NW1pawua6JKy8wusRtvvc6jB5OmWcN/OT4PWOaxZvMvJ7RLRGciE0ughkohx2PbevtJheSwRIJJMBKo4IsL6GIprM3kpHRG5E5VuZxKBksa1LrlLxYgJXj9/DL9y/n0VeOUZztQ2OMJH/tj7vtLFd/GayRcLkUl0yPLUhofRldeUEJ//a3A7xSdw6fx8WbL67i23/ZR2NHb9I5WADrFlelZZuEGG3vvmIGty+dOqbH4I9fU8v7V9XEbcNoDbq5XQqfx0WeNLjIGN+olQga75+J2KY9EwHWeHw9rEHKiThPTmSWvCPSyMp+WOsRWRraejhqrlc0FGNZ4nK+iWWwBj/qbQdYCSugXzGrhO/csQSXS+F2KayB65kl2SybWcSc8ty4Ebh0ZLCSWT2nlI9cPYuLqgv4+DW1uJVi3pRc/B43ay80Spe6w+mrjxdiPFBKjfkAl8s1ttuQ5XWTKy3aM8Yqrc500BwYhxmbwQpmoDw16B9/r4fH5cLvcUnVkuhj/LxLJ4H8LOPk3OgYF/PVP7zGXf+5Kel9dp9o5bYfvERHTzju8l31LSy470kONUjTjNHQ0mXss5FmsPrzw3dewq8/eDnZfg8et8vOaKUrg5WoJMfP59bOxeN28bE1tTz3+av59zuXAnCruTr8iebujDy3EGLsZHndksHKILdLmZ1TM/s8E7mLYCaWScg2gzb/EFuiZ5LbrYbcol2cH2SIK40KrQxWQqOLI2c7OHy2g1Mt3X2yHc/tb2BzXRNHGjvi5rDsPtFKKKLZd6qNmtL4RWVF+ln7rGBITS6ML73EfZroxgun0N4T7rM4sM/toisayVgGK1FlQWxx48tqirjv1vlcN798VJ5bCDF6gj7JYGWaz+PK2FprlrlTcqnID1A2yEG8ya62LIcv3TiX1XNKx3pTbF6XmpABsMg8OQKnkVVelhhgnWjuAuCVI+e49aLKuOuOnutMep+TLd1x/4vMGl6TC7OL4ABffj945yVJJ7j7vS66QpExmRyrlOLuFbJemxCT0UevmU1prn+sN2NS83vcGQ+wlkwrZMOX1mT0OSYSl0vxwatmjfVmxFkxu2RIlS/i/CEBVhrF5mDFSgQ7e8M0mcFT0gDLnJvVlFBWeLLFCMpOtUqANRqsAHewbckh1pa1YoAMFiSv1bfqyGX0SwiRTm++uHqsN2HSe+D2i5gl1SX9+sV7l1GWO7mzb29ZOpW3LJ061pshxiEJsNLIGsVwZqOs7JVLYS9A65Qqg3XCzFydkgzWqGjpCpEX8AxpRNJao2SgDFYqPo8Ln0yOFUKICWfNPCmvHsiq2vFTyifEaJMAK40CXjcBr8suNwOoN5sIXDGrhBcPnqWxvYfiHKN0IxSJUm8GYImNMU6al0uANTpaukJD6iAIsHxmEQ1tPcOe4Or3uAhI9koIIYQQYlKRs7s0K8jy0dzZy95Trdzxow38eedJAO5eMQOt4X/M3wFONncTiRpzc5pSzcFq7RqlLT+/NXf2DrmO+saFFTz0jouH/Zw+j3tcdUMSQgghhBAjJxmsNCsIetlc18Sfd56irSfMy4fO4VJw1QWlzCnP5fFtJ3jX5TMAqDvXYd/POQertTtEe08Yv8fF6ZYeolGNK9P9YM9zzV2hITW4SAefx5WxFu1CCCGEEGJsyNldmuVneTnU0EFPOMqq2hLAWCfJ43bxhsWVbKlr4pg578qaf1WU7Yubg3XSLCtcWJVPbyTKuYTywdHQ2h3ieNPQF0eeqFq6QqPeCcjvcY1ai3YhhBBCCDE6JMBKM2vtkWvmlvGO5dMAqCo01h+63lxz6OVDjYDRQdDndjGnPDduDtYJs4PgxdMLgaHNw/rvTUfZdPjcCP8K+McndnPHj14e0WOcae1m85HBb8uu+hbufHgjnb3hgW+cRl29ERraesYkwJIMlhBCCCHE5CJnd2m2+0QrAG9cUsmVF5Ti97ioMhd4rSnNIdvnZld9CwA7jrdQW55DUU7yDNbF0wqAwQdYXb0RvvL4a/zouYP27z/8+8EhByxaa57b38Dxpi7aukMD3yGFf3nqde58eJM9zyyZncdb6Ogxtu+ve07z/P6zbK1r5rdbjvP66bZhP7fl2LlOPviLzVz3wN/pDkX6XK+15ou/20F7T5gbL6wY8fMNxQeurOFj19SO6nMKIYQQQojMkgArzW5aaJykr55TRtDn4T/etZSPrTFOot0uxYKqfHbUtxCORNl+vJml0wspDHpp6uzlofUHePlQI8ebOvG4FIuqjQDLWhOrP9GoZktdE72RKHtPGYHJzzcc4f4/7+XJXacGvP/Jli62HWtGa83BhnYa2noAONQQmyf26tGmIWXHthxtoisUSVlqeLypk3UPvcDPNhwB4MCZdgCe2Xuaz/5mO//0pz2Dfq5UPvnoNp7efZr9Z9rZfqy5z/U7jrfw+LYTfGJNLSvNks7Rsqq2lLULpozqcwohhBBCiMySACvN7rlpHru/ttZu3X3lBaVxixEuqspn94lWdp1opbM3wsXTCykM+mjuCvHtp/bxi5frONTQwfTiIFPyAmR53Rx0BDndoQjffHIvpx0LEG86fI6FX/0LD79wCIDjTV2c6+jlxy8cBmBbksAC4JGNdbx6tIlfbTrK5f/0LG986EUe21bPSwcb7dscbGi3f/7K46/xzoc3suN48sdzaukK2QHTtmPN3PWTTXz/2f109caySH/eeYqojmX9rNv/atNRtIbn9htt7YfrwJl2ttQ18aGrZqEUbEwSHD73egMAd142fdjPI4QQQgghhEW6CKaZy6UI+lK/rAur8+kJR3n0laMAXDK9kIa2HrRZRfe6mX2aVZqDy6WoLc+xAw+AJ3ed4gd/O8irR5t45H2X4XYp/rzrJB29Edbva8DjUoSjmm/9ZR8NbT0UZft49WjfgOhsew/3PraL6+aV43ErKvIDFOf4+Oaf9zGtyAjuGtp77AxWKBJl36k2eiNRPvxfW1n/2dX4kqzhFIlqbvneC0wvCtqXPfLyUTYdOcffX2+gvrmL2y6ZyiMb69hz0vhbD5xpJxLVHDprPFd3KIrf46InHOUdP95Ils/Nbz50BW6XojsUweNSeNypxwa6QxG+9LudnGrpxu1SvPuKGazf18DGw42AkU3UWtMTjvL8gbMsqMyz1yYTQgghhBBiJCSDNcqssr/fv1pPeZ6fqoIsCh0L3B4+28GRxg5mlRlZr9qy3Li5SP+z8yQ+t4uXD51j6f99mq88vosX9p8l6DMyZjeaJYq/3nyMmpJs3nrpVPacbLXnH2kzkvvr7tNoDVvqmth+rIVLphdy360LONXazaYj53j78mlMKwqyo76Fex/byYsHztIbifLGxZXUN3fx9O7THG3sJJowv2rPyVb2nGzlyddOoRTkBTxsOnIOn9vFusWVPL7tBF994jV+t7WePSdbyfV7ONTQweGzHfSGoyyearw+N1w4hblTctl7qo1Xjzaz95TxN9z4nee597FdcX9Lor/ta+D3r9az4VAjV11QSllegOUzi4wSynCUaFTzwV9sYeU31/Pq0aZRLw0UQgghhBCTl2SwRtn0oiDXzitnw8GzrF0wBaUUhdmx7nVhM2Cxygpry3P47dbjtHSGcLng76838Pbl05hRHOSp3af5+YY6AD5/wxwA1i2u4undp+gORVm3uIr5lXmEo5pXjpzjV5uOcqihgz98bCVP7T4NQGOH0b3w7hUzuHRGEb98/3Iq8rOYWZLN9mPNPLP3DADP7z8LwIdXz+aVI038nz/u5lRrNx+8soYv3TTP3n6ra6BLweyyHEpy/Lx0sJHFUwu487LpPL7tBDvrW7h9aTXNnSGWTCvkm0/u5dm9xva8ffk0th9v5vr5U/js9XM4dLaDu36yiY2HzvGX105z+GwHp1u7WVidz/eeOcAv37+cU63dzK/Io8AMVJ/afYr8LC//fucl1JRmA3BZTTE/fekIV31rPaW5fnYcbyHL6yYU0ayaXZru3SyEEEIIIc5TEmCNMpdL8eO7lqK1Rilj8WArMFg2o4hNZoAyywwMLig3Aq39Z9rYf6ad3nCUWxZVsHRGEW+6uJpV33yW1u4wV11QyoLKfPM+uew43sK6xZVk+41d/K6fbLLLEB95uY4XDpxl5ewSXjhgBE4XmZmjK2bFsjk1pdk8s9f4ua6xk4DXxeyyHN62bCrffup1cvweHn7hMG9ZWs2BM+186y/7KM8LUFWQxSfW1JIb8LDhUCMvHWxkeU0Rl0wvpKYkmzNtPXz5lvnkBrz2fK4/7TQacaxdMIXLa4qpLsxCKcXUoiBTi7J4fFs9e061Mac8l32n2/jyY7uIanjLDzfQ2NHL1XNK+dzaubxy5BzP7DnDmnllXFZTbP8t18wt496b57GzvoXXT7fzkatnsW5xFX/cfoLlNUVp3MNCCCGEEOJ8JgHWGLGCK4Dqgiy8bsVdV8xg69EmwlEdVyIIRoOGh184zMXTCrh4mrE+Vn6Wl8+tncNj204wb0qe/XjXzy9namGQGSVGkHb/mxdypLGTK2YV85XHd/HVP+zG53HxDzfP4/YfbqCjN8yCytj9LYuqC/C5XdyxbCo/31DHnCl5uF2K96ycSUHQx+o5pdz0nee574nXaGzv5WBDBwcbOli3uJLbL50KQIPZpGL5zGKUUnz79oto6w6TGzCydrPNv3PbsWamFQXJz/L2WY9q+cxifrPlOEGfm/+8+1L+1w9e4mRLN+9dOZOfvHiYeRV55hyrc3SaTTQSu/P5PC7et6qmz9/46evnDGp/CSGEEEIIMRgSYI0DZXkBNt1zLYXZPh786+u0doXIMwOQqoIssrxuHnz6dQC+8eaFuFyx4OzOy2dw5+Uz4h7vowlrK92xbJr983tX1fDlx3bxT29ayLyKPJbXFNPQ3pO0McfNCytYObuEiNb818t1dhAW9Hl4p9l17zPXz+G+J14DYHpxkLrGTi6dEcsI3bqokpbOkJ0lsoJDS9DnYVpRkLPtPfzrHYuTvj6X1RgB1sfX1FJZkMUnr61lz8k2vnzLfD569WyCfjdrH3yO7lCUB26/iH2n2rl6TlmKV1sIIYQQQojMUakaBUwUS5cu1Zs3bx7rzUibh9YfoLU7xJdujM1ruvexnRw+28F7VsxkzbzyET2+1pr65i6qC40ufy2dIcLR6IBd9P7+egO1ZTlUmosmW8KRKLd+/0VOt3bzp4+v4qH1B/jUdRdQlO1L8Uh9bTp8jqDPzYVV+Umv7wlH+OP2k7xhcSXeFN0Dmzp6cblUn+yXEEIIIYQQ6aCU2qK1Xjrg7STAEiN1pq2btu5w3HpfQgghhBBCTCaDDbCkRFCMWFluAHOqmBBCCCGEEOc1WQdLCCGEEEIIIdJEAiwhhBBCCCGESBMJsIQQQgghhBAiTSTAEkIIIYQQQog0kQBLCCGEEEIIIdJEAiwhhBBCCCGESBMJsIQQQgghhBAiTSTAEkIIIYQQQog0UVrrsd6GEVFKNQB1Y70dDiXA2bHeCJFxsp/PD7KfJz/Zx+cH2c/nB9nP54ex3M/TtdalA91owgdY441SarPWeulYb4fILNnP5wfZz5Of7OPzg+zn84Ps5/PDRNjPUiIohBBCCCGEEGkiAZYQQgghhBBCpIkEWOn3o7HeADEqZD+fH2Q/T36yj88Psp/PD7Kfzw/jfj/LHCwhhBBCCCGESBPJYAkhhBBCCCFEmkiAJYQQQgghhBBpIgFWmiilblBK7VNKHVBKfXGst0cMn1LqJ0qpM0qpXY7LipRSyJKRLAAABjZJREFUTyul9pv/F5qXK6XUd839vkMpdfHYbbkYCqXUVKXUeqXUbqXUa0qpT5iXy76eRJRSAaXUJqXUdnM//6N5+Uyl1EZzfz6qlPKZl/vN3w+Y188Yy+0Xg6eUciulXlVK/dH8XfbxJKOUOqKU2qmU2qaU2mxeJsdsMe5IgJUGSik38BBwIzAfeJtSav7YbpUYgZ8CNyRc9kXgGa11LfCM+TsY+7zW/PcB4AejtI1i5MLAZ7TW84HLgI+Yn1vZ15NLD3CN1voiYDFwg1LqMuCbwINa69lAE/Be8/bvBZrMyx80bycmhk8Aexy/yz6enK7WWi92rIMkx2wx7kiAlR7LgANa60Na617gv4F1Y7xNYpi01s8B5xIuXgf8zPz5Z8AbHZf/XBteBgqUUhWjs6ViJLTWJ7XWW82f2zBOzKqQfT2pmPur3fzVa/7TwDXAb8zLE/eztf9/A6xRSqlR2lwxTEqpauBm4Mfm7wrZx+cLOWaLcUcCrPSoAo45fj9uXiYmj3Kt9Unz51NAufmz7PtJwCwRWgJsRPb1pGOWjm0DzgBPAweBZq112LyJc1/a+9m8vgUoHt0tFsPwr8Dngaj5ezGyjycjDTyllNqilPqAeZkcs8W44xnrDRBiotFaa6WUrG8wSSilcoDfAp/UWrc6B7JlX08OWusIsFgpVQD8Hpg7xpsk0kgpdQtwRmu9RSm1eqy3R2TUSq11vVKqDHhaKbXXeaUcs8V4IRms9KgHpjp+rzYvE5PHaau0wPz/jHm57PsJTCnlxQiuHtFa/868WPb1JKW1bgbWA5djlAtZg4zOfWnvZ/P6fKBxlDdVDM0K4A1KqSMYJfrXAN9B9vGko7WuN/8/gzFYsgw5ZotxSAKs9HgFqDU7FvmAO4AnxnibRHo9Adxl/nwX8Ljj8neZ3YouA1ocpQpiHDPnXDwM7NFaP+C4Svb1JKKUKjUzVyilsoDrMObbrQduM2+WuJ+t/X8b8KzWWkbExzGt9Ze01tVa6xkY37/Paq3fgezjSUUpla2UyrV+Bq4HdiHHbDEOKTmmpIdS6iaMGnA38BOt9dfHeJPEMCmlfgWsBkqA08B9wGPAr4FpQB1wu9b6nHmS/n2MroOdwN1a681jsd1iaJRSK4HngZ3E5m3cgzEPS/b1JKGUWoQx8d2NMaj4a63115RSNRjZjiLgVeCdWusepVQA+AXGnLxzwB1a60Njs/ViqMwSwc9qrW+RfTy5mPvz9+avHuCXWuuvK6WKkWO2GGckwBJCCCGEEEKINJESQSGEEEIIIYRIEwmwhBBCCCGEECJNJMASQgghhBBCiDSRAEsIIYQQQggh0kQCLCGEEEIIIYRIEwmwhBBCTHhKqX9QSr2mlNqhlNqmlFqulPqkUio41tsmhBDi/CJt2oUQQkxoSqnLgQeA1eY6RyWAD3gJWKq1PjumGyiEEOK8IhksIYQQE10FcFZr3QNgBlS3AZXAeqXUegCl1PVKqQ1Kqa1Kqf+nlMoxLz+ilPpnpdROpdQmpdRs8/K3KKV2KaW2K6WeG5s/TQghxEQjGSwhhBATmhkovQAEgb8Cj2qt/66UOoKZwTKzWr8DbtRadyilvgD4tdZfM2/3H1rrryul3gXcrrW+RSm1E7hBa12vlCrQWjePyR8ohBBiQpEMlhBCiAlNa90OXAJ8AGgAHlVKvTvhZpcB84EXlVLbgLuA6Y7rf+X4/3Lz5xeBnyql3g+4M7P1QgghJhvPWG+AEEIIMVJa6wjwN+BvZubproSbKOBprfXbUj1E4s9a6w8ppZYDNwNblFKXaK0b07vlQgghJhvJYAkhhJjQlFJzlFK1josWA3VAG5BrXvYysMIxvypbKXWB4z5vdfy/wbzNLK31Rq31VzAyY1Mz+GcIIYSYJCSDJYQQYqLLAb6nlCoAwsABjHLBtwFPKqVOaK2vNssGf6WU8pv3uxd43fy5UCm1A+gx7wfwLTNwU8AzwPZR+WuEEEJMaNLkQgghxHnN2QxjrLdFCCHExCclgkIIIYQQQgiRJpLBEkIIIYQQQog0kQyWEEIIIYQQQqSJBFhCCCGEEEIIkSYSYAkhhBBCCCFEmkiAJYQQQgghhBBpIgGWEEIIIYQQQqTJ/wd8QH2UrrnsBQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-0ab45c53bba0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     24\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmemory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch_size\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_actor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_critic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-3-7f3a05e993b3>\u001b[0m in \u001b[0;36mupdate_critic\u001b[0;34m(self, sarst)\u001b[0m\n\u001b[1;32m     74\u001b[0m         \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msarst\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m         \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mr\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_gamma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_target_network\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalc_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 76\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_network\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize_critic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     77\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mtarget_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparam\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_target_network\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_network\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     78\u001b[0m             \u001b[0mtarget_param\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtarget_param\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tau\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mparam\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tau\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-b0a0c3cbda7c>\u001b[0m in \u001b[0;36moptimize_critic\u001b[0;34m(self, s, a, target)\u001b[0m\n\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0moptimize_critic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmse_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalc_qvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduction\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'mean'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     33\u001b[0m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_critic\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-b0a0c3cbda7c>\u001b[0m in \u001b[0;36mcalc_qvalues\u001b[0;34m(self, s, a)\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcalc_qvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_critic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mcalc_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    487\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    488\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 489\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    490\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    491\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-b0a0c3cbda7c>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, s, a)\u001b[0m\n\u001b[1;32m     75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     76\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 77\u001b[0;31m         \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fc1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     78\u001b[0m         \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctional\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     79\u001b[0m         \u001b[0mq\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fc2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m    487\u001b[0m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    488\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 489\u001b[0;31m             \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    490\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    491\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.6/site-packages/torch/nn/modules/linear.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mweak_script_method\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mextra_repr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.6/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mlinear\u001b[0;34m(input, weight, bias)\u001b[0m\n\u001b[1;32m   1350\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mbias\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1351\u001b[0m         \u001b[0;31m# fused op is marginally faster\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1352\u001b[0;31m         \u001b[0mret\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maddmm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_unwrap_optional\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbias\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1353\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1354\u001b[0m         \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#this is where all learning takes place\n",
    "while True:\n",
    "    a = model.step(s1)\n",
    "    s2, r, t, term, r_ = env.step(a)\n",
    "    sarst = torch.cat((s1, a, r, s2, t))\n",
    "    R += r_\n",
    "    memory.append(sarst)\n",
    "    s1 = s2\n",
    "    if term or env._env._elapsed_steps == env._env._max_episode_steps - 1:\n",
    "        history.log(e, loss=max(R, -1000))\n",
    "        historyt.log(e, loss=env._env._elapsed_steps)\n",
    "        RT.append(R)\n",
    "        historyrt.log(e, loss=avg(RT))\n",
    "        with canvas:\n",
    "            canvas.draw_plot([history[\"loss\"], historyrt[\"loss\"]], labels=[\"R\", \"<R>\"])\n",
    "            canvas.draw_plot([historyt[\"loss\"]], labels=[\"T\"])\n",
    "        s1 = env.reset()\n",
    "        R = 0\n",
    "        e += 1\n",
    "    if e == pre_explore_episodes:\n",
    "        model.lock_preprocessor\n",
    "    elif e > pre_explore_episodes:\n",
    "        x = torch.stack(memory.draw(batch_size))\n",
    "        model.update_actor(x)\n",
    "        model.update_critic(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#halt calculations in previous cell and run this one to see how the agent performs with current target policy\n",
    "import time\n",
    "env = gym.make(ENV)\n",
    "env=EnvWrapper(env)\n",
    "s = env.reset()\n",
    "term = False\n",
    "R=0\n",
    "while not term:\n",
    "    env.render()\n",
    "    #time.sleep(0.02)\n",
    "    a = model.target_policy(s)\n",
    "    s, r, _, term, _ = env.step(a)\n",
    "    R+=r\n",
    "\n",
    "env.close()\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#record video\n",
    "import time\n",
    "import gym.wrappers\n",
    "\n",
    "env = gym.make(ENV)\n",
    "rec =gym.wrappers.Monitor(env, '.', force = True)\n",
    "env=EnvWrapper(env)\n",
    "\n",
    "s = env.reset()\n",
    "term = False\n",
    "\n",
    "while not term:\n",
    "    env.render()\n",
    "    #time.sleep(0.02)\n",
    "    a = model.target_policy(s)\n",
    "    s, _, _, term, _ = env.step(a)\n",
    "\n",
    "rec.close()\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/stepan/.local/lib/python3.6/site-packages/torch/serialization.py:251: UserWarning: Couldn't retrieve source code for container of type ActorCritic. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/stepan/.local/lib/python3.6/site-packages/torch/serialization.py:251: UserWarning: Couldn't retrieve source code for container of type L4Actor. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/home/stepan/.local/lib/python3.6/site-packages/torch/serialization.py:251: UserWarning: Couldn't retrieve source code for container of type L4Critic. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "#save model\n",
    "torch.save(model, \"model.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}