dos-bs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from math import ceil, sqrt\n",
    "import copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Black & Scholes model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class MultiDimensionalBS:\n",
    "    def __init__(self, initial_prices, interest_rate, dividends, volatilities, correlation_matrix):\n",
    "        self.initial_prices = initial_prices\n",
    "        self.interest_rate = interest_rate\n",
    "        self.dividends = dividends\n",
    "        self.volatilities = volatilities\n",
    "        self.correlation_matrix = correlation_matrix\n",
    "        self.dimension = len(initial_prices)\n",
    "        self.var_cov = np.linalg.cholesky(np.matmul(np.diag(self.volatilities), np.matmul(self.correlation_matrix, np.diag(self.volatilities))))\n",
    "        \n",
    "        assert self.dimension == len(self.dividends) and self.dimension == len(self.volatilities) and self.dimension == len(self.var_cov[0]) and self.dimension == len(self.var_cov), \"Arrays should have same lenght as the problem dimension !\"\n",
    "    \n",
    "    def Simulate(self, expiry, nb_time_discr, number_paths):\n",
    "        \"\"\" Simulate stock prices under BS model until expiry and with constant timestep \"\"\"\n",
    "        diffusion_list = np.linspace(0, expiry, nb_time_discr + 1)\n",
    "        last_index = len(diffusion_list) - 1\n",
    "        delta_time = expiry / last_index\n",
    "        dW = np.sqrt(delta_time) * np.random.randn(number_paths, last_index, self.dimension)\n",
    "        dW = np.append(np.zeros((number_paths, 1, self.dimension)), dW, axis=1)\n",
    "        cst = self.interest_rate - self.dividends - 0.5 * (self.volatilities ** 2)\n",
    "        W = np.cumsum(np.matmul(dW, self.var_cov), axis = 1)\n",
    "        S = self.initial_prices * np.exp(cst * diffusion_list[np.newaxis, :, np.newaxis] + W)\n",
    "                    \n",
    "        return S\n",
    "    \n",
    "    def Simulate_Next_State(self, current_price, current_time, diffusion_times, nb_paths):\n",
    "        \"\"\" Simulate conditionnal stock prices under BS model until expiry and with constant timestep \"\"\"\n",
    "        delta_time = diffusion_times[0] - current_time\n",
    "        dW = np.sqrt(delta_time) * np.random.randn(nb_paths, len(diffusion_times), self.dimension)\n",
    "        cst = self.interest_rate - self.dividends - 0.5 * (self.volatilities ** 2)\n",
    "        W = np.cumsum(np.matmul(dW, self.var_cov), axis = 1)\n",
    "        S = current_price[:, np.newaxis, np.newaxis, :] * np.exp(cst * (diffusion_times[np.newaxis, :, np.newaxis] - current_time) + W)\n",
    "                    \n",
    "        return S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Payoffs Management"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Payoff:\n",
    "    def __init__(self, strike, option_type):\n",
    "        self.strike = strike\n",
    "        self.option_type = option_type\n",
    "        \n",
    "    def value(self, asset_prices, interest_rate, dates, k=0):\n",
    "        if (self.option_type == 0):\n",
    "            # max call\n",
    "            return np.exp(-interest_rate * dates[np.newaxis, k:]) * np.maximum(asset_prices.max(axis = 2) - self.strike, 0)\n",
    "        \n",
    "        elif (self.option_type == 1):\n",
    "            # max put\n",
    "            return np.exp(-interest_rate * dates[np.newaxis, k:]) * np.maximum(self.strike - asset_prices.min(axis = 2), 0)\n",
    "        \n",
    "        elif (self.option_type == 2):\n",
    "            d = len(asset_prices[0][0])\n",
    "            # geometric call\n",
    "            np.exp(-interest_rate * dates[np.newaxis, k:]) * np.maximum(asset_prices.prod(axis = 2)**(1/d) - self.strike, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Net Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Build_Neural_Network(nn_structure):\n",
    "    \n",
    "    nb_hidden_layers = len(nn_structure) - 2\n",
    "    assert nb_hidden_layers >= 2, \" A neural network has a least two layers : input and output \"\n",
    "    \n",
    "    layers = []\n",
    "        \n",
    "    for i in range(0, nb_hidden_layers):\n",
    "        layers += [nn.Linear(nn_structure[i], nn_structure[i + 1]), nn.BatchNorm1d(nn_structure[i + 1]), nn.ReLU()]\n",
    "      \n",
    "    layers += [torch.nn.Linear(nn_structure[nb_hidden_layers], nn_structure[nb_hidden_layers + 1]), torch.nn.Sigmoid()]\n",
    "    \n",
    "    return nn.Sequential(*layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def model_train(nn_structure, nn_hyper_params, model_params, nb_epoch_before_display, re_use_nn_params = False):\n",
    "    \n",
    "    # nn_structure : list containing specification of hidden layer : \n",
    "    # nn_hyper_params : dict containing nn hyperparameters\n",
    "    # model_params : dict containing BS model parameters\n",
    "    # re_use_nn_params : if True : we previously trained nn to initialize current nn weights\n",
    "\n",
    "    #################################################################################################################\n",
    "    ####################################################                  MODELS INIT\n",
    "    \n",
    "    N = len(model_params['diffusion_times']) - 1\n",
    "    nb_batches = ceil(nn_hyper_params['inputs_size'] / nn_hyper_params['batch_size'])\n",
    "    \n",
    "    nn_base = Build_Neural_Network(nn_structure)\n",
    "    f = [copy.deepcopy(nn_base).to(device) for i in range(N - 1)]\n",
    "    optimizers = [torch.optim.Adam(f[i].parameters(), lr = nn_hyper_params['lr']) for i in range(N - 1)]\n",
    "    BS = MultiDimensionalBS(model_params['initial_prices'], model_params['interest_rate'], model_params['dividends'], model_params['volatilities'], model_params['correlation_matrix'])\n",
    "    losses = np.array([[0.0] * (N - 1)] * (nn_hyper_params['nb_epochs'] // nb_epoch_before_display))\n",
    "    \n",
    "    comp = 0\n",
    "    \n",
    "    #################################################################################################################\n",
    "    ####################################################                  TRAINING\n",
    "\n",
    "    for epoch in range(nn_hyper_params['nb_epochs']):\n",
    "        S_train = BS.Simulate(model_params['diffusion_times'][-1], N, nn_hyper_params['inputs_size'])\n",
    "        x = torch.from_numpy(S_train).float()\n",
    "        y = torch.unsqueeze(torch.from_numpy(my_payoff.value(S_train, model_params['interest_rate'], model_params['diffusion_times'])), dim=2).float()\n",
    "        payoff_tau = [y[i * nn_hyper_params['batch_size'] : min((i + 1) * nn_hyper_params['batch_size'], nn_hyper_params['inputs_size']) , N].to(device) for i in range(nb_batches)]\n",
    "        this_epoch_loss = np.full(N - 1, 0.0)\n",
    "        \n",
    "        # bakward induction\n",
    "        \n",
    "        for n in range(N - 1, 0, -1):\n",
    "            inputs = torch.cat((x[:,n], y[:,n]), 1)\n",
    "            \n",
    "            if n < N - 2 and re_use_nn_params:\n",
    "                f[n].parameters = f[n + 1].parameters\n",
    "            \n",
    "            for batch in range(nb_batches):\n",
    "                batch_range = [i for i in range(batch * nn_hyper_params['batch_size'], min((batch + 1) * nn_hyper_params['batch_size'], nn_hyper_params['inputs_size']))]\n",
    "                this_batch_inputs = inputs[batch_range, :].to(device)\n",
    "                optimizers[n - 1].zero_grad()\n",
    "                F_n = f[n - 1](this_batch_inputs)\n",
    "                f_n = (F_n >= 0.5).detach().float()\n",
    "                payoffs_batch = y[batch_range , n].to(device)\n",
    "                payoff_tau[batch] = payoffs_batch * f_n + payoff_tau[batch] * (1 - f_n)\n",
    "                z = torch.mean(torch.mul(torch.subtract(payoff_tau[batch], payoffs_batch), F_n))\n",
    "                this_epoch_loss[n - 1] += z.item() / float(nb_batches)\n",
    "                z.backward()\n",
    "                optimizers[n - 1].step()\n",
    "                \n",
    "        if(epoch % nb_epoch_before_display == 0):\n",
    "            losses[comp] = this_epoch_loss \n",
    "            print('epoch {}, losses : {}'.format(epoch, losses[comp]))\n",
    "            print('\\n')\n",
    "            comp += 1\n",
    "                \n",
    "    return f, losses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "##### BS parameters\n",
    "nb_assets = 2\n",
    "expiry = 3\n",
    "nb_ex_dates = 9\n",
    "strike = 100\n",
    "my_payoff = Payoff(strike, 0)\n",
    "\n",
    "# NN parameters\n",
    "nb_hidden_layers = 3\n",
    "nn_units = [nb_assets + 1] + [nb_assets + 40 for i in range(nb_hidden_layers - 1)] + [1]\n",
    "nb_epoch_before_display = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "_kg_hide-output": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 0, losses : [0.79989797 0.6440044  0.54361796 0.44865102 0.36296296 0.28914708\n",
      " 0.21355854 0.12937084]\n",
      "\n",
      "\n",
      "epoch 100, losses : [ 6.56650782e-01  4.64382559e-01  3.08521718e-01  2.14288652e-01\n",
      "  1.34374425e-01  9.88520235e-02  5.43644577e-02 -5.45443734e-04]\n",
      "\n",
      "\n",
      "epoch 200, losses : [0.11817421 0.08339562 0.08056502 0.04711644 0.02684899 0.03413507\n",
      " 0.01498811 0.00183711]\n",
      "\n",
      "\n",
      "epoch 300, losses : [0.05090082 0.03025005 0.03355752 0.00729988 0.0133896  0.00442184\n",
      " 0.01566438 0.00122915]\n",
      "\n",
      "\n",
      "epoch 400, losses : [ 0.01822976  0.00822224  0.0084055   0.01728267  0.00358075 -0.00458146\n",
      " -0.01450301 -0.00118253]\n",
      "\n",
      "\n",
      "epoch 500, losses : [ 0.02325164  0.01785731  0.01163417  0.00816861 -0.00477006  0.01563264\n",
      " -0.01734555 -0.00736392]\n",
      "\n",
      "\n",
      "epoch 600, losses : [-0.00981892  0.03604876  0.01698104 -0.0037787   0.00239931 -0.00565946\n",
      " -0.00750741  0.0047931 ]\n",
      "\n",
      "\n",
      "epoch 700, losses : [ 0.01096731 -0.00826875  0.00466156  0.00025154 -0.00347374 -0.00481658\n",
      "  0.01079756 -0.00403058]\n",
      "\n",
      "\n",
      "epoch 800, losses : [-2.27486482e-03  8.21906980e-03  7.53011741e-03 -8.73813406e-06\n",
      "  1.09743150e-02  7.51915760e-03  7.45334709e-03 -6.24015182e-03]\n",
      "\n",
      "\n",
      "epoch 900, losses : [ 0.00611851  0.01593205 -0.00435022  0.00140942 -0.00791195  0.00313502\n",
      "  0.00664282 -0.00272046]\n",
      "\n",
      "\n",
      "epoch 1000, losses : [-0.00624624  0.0064074  -0.01292936 -0.02475173  0.00108351 -0.00551934\n",
      "  0.00251492 -0.01374435]\n",
      "\n",
      "\n",
      "epoch 1100, losses : [-0.00253772  0.01126819 -0.02138419 -0.0187145  -0.01111621  0.00445619\n",
      " -0.00632604  0.00402173]\n",
      "\n",
      "\n",
      "epoch 1200, losses : [ 0.00090307  0.0013208  -0.00130109 -0.00999771 -0.0092003  -0.01259724\n",
      " -0.00233514 -0.00395744]\n",
      "\n",
      "\n",
      "epoch 1300, losses : [ 0.00898373 -0.0088463  -0.00439062 -0.00165686 -0.00704653 -0.01690715\n",
      " -0.00937876  0.00182831]\n",
      "\n",
      "\n",
      "epoch 1400, losses : [ 2.47756252e-05  7.80080166e-03 -3.07466416e-03  1.45435752e-02\n",
      "  3.55729926e-03  7.52063049e-03 -7.84790237e-03 -2.20268616e-03]\n",
      "\n",
      "\n",
      "epoch 1500, losses : [-0.00377139  0.0099699  -0.01066977 -0.0012707   0.01023556 -0.00273564\n",
      "  0.00532232 -0.00545669]\n",
      "\n",
      "\n",
      "epoch 1600, losses : [ 0.00931424 -0.00901154 -0.0053093   0.00305145  0.01577197  0.00375279\n",
      " -0.0004809   0.00504673]\n",
      "\n",
      "\n",
      "epoch 1700, losses : [-0.01460005 -0.01307887 -0.00502267 -0.00208144 -0.00703776 -0.00896593\n",
      "  0.00353056  0.00223729]\n",
      "\n",
      "\n",
      "epoch 1800, losses : [ 0.00424957  0.00649904 -0.00687896  0.00250394  0.00740517  0.0142949\n",
      " -0.00309702 -0.0041988 ]\n",
      "\n",
      "\n",
      "epoch 1900, losses : [ 0.00766247 -0.00766999  0.00943178  0.02094917  0.00029016 -0.00761409\n",
      " -0.0049743  -0.001327  ]\n",
      "\n",
      "\n",
      "epoch 2000, losses : [-0.00474802  0.00016637 -0.01037588  0.00566525 -0.01339329  0.01182735\n",
      " -0.00639618  0.00603007]\n",
      "\n",
      "\n",
      "epoch 2100, losses : [-0.00026669  0.0048111   0.0018343  -0.01058253  0.00967856  0.01039377\n",
      " -0.0019287   0.00420837]\n",
      "\n",
      "\n",
      "epoch 2200, losses : [-0.00280967 -0.00615306 -0.00018575 -0.01027704  0.01319872 -0.01836545\n",
      " -0.00958928 -0.00027551]\n",
      "\n",
      "\n",
      "epoch 2300, losses : [-3.06497607e-03  2.09579710e-04 -3.92284011e-03  2.28978251e-03\n",
      " -4.32142755e-03  6.52300660e-05 -3.83552862e-03 -9.35835997e-04]\n",
      "\n",
      "\n",
      "epoch 2400, losses : [-0.00977144 -0.00132888  0.01080889 -0.00061013 -0.00447072  0.01397989\n",
      "  0.00680971  0.00094926]\n",
      "\n",
      "\n",
      "epoch 2500, losses : [ 0.01074606  0.00715918 -0.00181735  0.00723761 -0.00173044 -0.00622811\n",
      "  0.0038984  -0.00167692]\n",
      "\n",
      "\n",
      "epoch 2600, losses : [ 0.01141072  0.00625766  0.00604709 -0.00343816  0.01525056 -0.00185596\n",
      " -0.00149912  0.00367372]\n",
      "\n",
      "\n",
      "epoch 2700, losses : [-0.00990854  0.00734834 -0.00681855  0.00413797 -0.00535451 -0.0023699\n",
      "  0.00176554  0.00131397]\n",
      "\n",
      "\n",
      "epoch 2800, losses : [ 0.0028245   0.00302693  0.00442656  0.00632209  0.00693797 -0.01570372\n",
      "  0.00305188 -0.0016352 ]\n",
      "\n",
      "\n",
      "epoch 2900, losses : [ 0.00169538  0.00684573  0.0015334   0.00227494 -0.00400828 -0.00444211\n",
      " -0.00323779 -0.00451606]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "nn_hp = {'lr' : 0.001, 'nb_epochs' : 3000, 'batch_size' : 8192, 'inputs_size' : 8192*1}\n",
    "\n",
    "BS_params = {'initial_prices' : np.full(nb_assets, 100),\n",
    "             'interest_rate' : 0.05,\n",
    "            'dividends' : np.full(nb_assets, 0.1),\n",
    "            'volatilities' : np.full(nb_assets, 0.2),\n",
    "            'diffusion_times' : np.linspace(0, expiry, nb_ex_dates + 1),\n",
    "            'correlation_matrix' : np.eye(nb_assets)}\n",
    "\n",
    "my_models, losses = model_train(nn_units, nn_hp, BS_params, nb_epoch_before_display)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'loss')"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3gAAAHgCAYAAAD3xM9JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAACto0lEQVR4nOzdd3hc133n//e50ys6hgArCLA3NNGWrWZLFiXFseN1LNuxnTg9vySbZJ1kEyebbJKNd9Oz3l0nGyfZeO1448h23GU1W7IsyZLYwN4JkgAJopcBps+9vz8GrGhDCiAI8PN6HjwDzJy594AiRX5wvud8jeM4iIiIiIiIyMJnzfcEREREREREZHYo4ImIiIiIiCwSCngiIiIiIiKLhAKeiIiIiIjIIqGAJyIiIiIiskgo4ImIiIiIiCwS7vmewI2qrKx0Vq1aNd/TEBERERERmRe7d+/ucxynarLXFlzAW7VqFbt27ZrvaYiIiIiIiMwLY8zZqV5TiaaIiIiIiMgioYAnIiIiIiKySCjgiYiIiIiILBIKeCIiIiIiIouEAp6IiIiIiMgioYAnIiIiIiKySCjgiYiIiIiILBIKeCIiIiIiIouEAp6IiIiIiMgioYAnIiIiIiKySCjgiYiIiIiILBIKeCIiIiIiIouEAp6IiIiIiMgioYAnIiIiIiKySMxpwDPGPGKMOWaMOWmM+e1JXl9hjHneGLPXGLPfGPPYXM5HRERERERkMZuzgGeMcQGfAh4FNgIfNMZsvG7YfwKecBynCfgA8DdzNR8REREREZHFbi5X8LYDJx3HOe04Tgb4AvDu68Y4QHT88xLgwhzOZ87YtsOFoeR8T0NERERERO5wcxnwlgIdV33dOf7c1f4A+LAxphN4Evj3czifOfPvv7CXD/3DaziOM99TERERERGRO9h8H7LyQeAzjuMsAx4DPmeMmTAnY8zPGWN2GWN29fb23vJJzuSBtVW0942x6+zgfE9FRERERETuYHMZ8M4Dy6/6etn4c1f7aeAJAMdxfgD4gcrrL+Q4zqcdx2l1HKe1qqpqjqZ78x7bUkPI6+KJnR0zDxYREREREZkjcxnwdgJrjDF1xhgvhUNUvn7dmHPAgwDGmA0UAt7tt0Q3g5DPzTu31vKtA12MpXPzPR0REREREblDzVnAcxwnB/wy8DRwhMJpmYeMMX9kjHnX+LBfB37WGLMP+Bfgo84C3cj2+F3LSGTyfOtA13xPRURERERE7lDuuby44zhPUjg85ernfv+qzw8Db53LOdwqzSvKWF0V4ou7Oni8dfnMbxAREREREZll833IyqJhjOF9LcvZeWaQ072j8z0dERERERG5AyngzaL3Ni/FZRm+uLtzvqciIiIiIiJ3IAW8WVQd9fPA2ir+bU8nubw939MREREREZE7jALeLHtf63K6R9J8/0TffE9FRERERETuMAp4s+zt66upCHl5Ypd64omIiIiIyK2lgDfLvG6LH2laynNHuukfTc/3dERERERE5A6igDcHHm9dTjbv8NW2C/M9FRERERERuYMo4M2BdUsibFtWwhd3dbBA+7aLiIiIiMgCpIA3R97XupyjF+McPD8y31MREREREZE7hALeHPnhbbX43JYOWxERERERkVtGAW+OlAQ8PLJ5CV9rO08qm5/v6YiIiIiIyB1AAW8OPd66nJFUjqcPXZzvqYiIiIiIyB1AAW8O3b26gqWlAb60u3O+pyIiIiIiIncABbw5ZFmG97Uu46WTfXQOJuZ7OiIiIiIissgp4M2xH21ZBsCXd5+f55mIiIiIiMhip4A3x5aVBXlLfQVf3N2BbasnnoiIiIiIzB0FvFvg8dbldA4mefV0/3xPRUREREREFjEFvFtgx6YlRPxuvqjDVkREREREZA4p4N0Cfo+LdzfW8uSBLkZS2fmejoiIiIiILFIKeLfI463LSedsvrHvwnxPRUREREREFikFvFtky9IS1sUiPLFLZZoiIiIiIjI3FPBuEWMKPfH2dQxxvDs+39MREREREZFFSAHvFnpP01LcluGLuzrmeyoiIiIiIrIIKeDdQhVhHw9tiPFve86TzdvzPR0REREREVlkFPBuscfvWkb/WIbvHu2Z76mIiIiIiMgio4B3i923porqiE9lmiIiIiIiMusU8G4xt8vi3zUv4/ljvfTEU/M9HRERERERWUQU8ObB+1qXkbcdvrLn/HxPRUREREREFhEFvHlQXxWmdWUZT+zqwHGc+Z6OiIiIiIgsEgp48+Tx1uWc6h1jz7mh+Z6KiIiIiIgsEgp48+SxrTUEPC4dtiIiIiIiIrNGAW+ehH1ufmhrDd/Yd4FEJjff0xERERERkUVAAW8ePd66nLFMnm8fuDjfUxERERERkUVAAW8e3bWqjFUVQZ5QmaaIiIiIiMwCBbx5ZIzhfa3Lea19gDN9Y/M9HRERERERWeAU8ObZe5uXYRn40u7O+Z6KiIiIiIgscAp482xJiZ/71lbxpd2d5G31xBMRERERkZungHcbeLx1ORdHUrx0sm++pyIiIiIiIguYAt5t4MEN1ZQFPTpsRURERERE3hAFvNuAz+3iR5qW8uyhbgbHMvM9HRERERERWaAU8G4T72tZTiZv87W28/M9FRERERERWaAU8G4TG2ujbF4a5YldOk1TRERERERujgLebeTx1uUc7hrh4Pnh+Z6KiIiIiIgsQAp4t5F3bavF67bUE09ERERERG6KAt5tpDToZcemJXxl73lS2fx8T0dERERERBYYBbzbzPtaljGczPLcke75noqIiIiIiCwwCni3mbc2VFJb4tdhKyIiIiIicsMU8G4zLsvwoy3L+P6JXi4MJed7OiIiIiIisoAo4N2GfrRlOY4D/7ZHq3giIiIiIlI8Bbzb0IqKIHevruCJXZ3YtjPf0xERERERkQVCAe829fhdyzg3kOD1MwPzPRUREREREVkgFPBuU49sqiHic/PEro75noqIiIiIiCwQCni3qYDXxTu31fLkgS7iqex8T0dERERERBYABbzb2OOty0hlbb61v2u+pyIiIiIiIguAAt5trHF5KWuqwyrTFBERERGRoijg3caMMTzeupw954Y42ROf7+mIiIiIiMhtTgHvNvcjTUtxWYYv7lJPPBERERERmZ4C3m2uKuLj7eur+fKe82Tz9nxPR0REREREbmMKeAvA463L6RtN871jvfM9FRERERERuY0p4C0AD6yrojLs02ErIiIiIiIyLQW8BcDjsnhv81K+e7SH3nh6vqcjIiIiIiK3KQW8BeJ9rcvI2Q5f3Xt+vqciIiIiIiK3KQW8BaKhOkLTilKe2NWB4zjzPR0REREREbkNKeAtIO/eVsuJnlHODyXneyoiIiIiInIbUsBbQFZVhgDoHknN80xEREREROR2pIC3gMSifgC6R3TQioiIiIiITKSAt4BcCXhawRMRERERkYkU8BaQsqAHj8toBU9ERERERCalgDcbeo7CsW/P+W2MMVRH/PRoBU9ERERERCahgDcbvv8X8LVfAjs/57eKRX10xxXwRERERERkIgW82bDuUUj0Q+fOOb9VLOpXiaaIiIiIiExKAW82NDwElhuOPTnntyoEPK3giYiIiIjIRAp4s8FfAqvuuSX78KqjPuKpHIlMbs7vJSIiIiIiC4sC3mxZ9xj0HYe+k3N6m1ik0CqhR2WaIiIiIiJyHQW82bL2kcLj8bldxVMvPBERERERmYoC3mwpWwmxzXNephmL+gDojmsFT0RERERErqWAN5vWPQrnfgCJgTm7RXX0UommVvBERERERORaCnizad2j4Nhw4pk5u0XU78bvsVSiKSIiIiIiEyjgzaaaJggvmdN2CcYY9cITEREREZFJKeDNJsuCdY/Aye9Abu4CWCyiXngiIiIiIjKRAt5sW/cYZEbhzPfn7BbVUR89OmRFRERERESuo4A32+ruA09wTk/TLJRopnAcZ87uISIiIiIiC48C3mzzBKD+7YWAN0cBLBb1kcjkGU3n5uT6IiIiIiKyMCngzYV1j8LIebi4f04uf6XZuco0RURERETkCgW8ubBmB2DmrEyzOqJeeCIiIiIiMpEC3lwIV8Hy7XPWLiEW9QFwUQFPRERERESuooA3V9Y9Cl37YPj8rF+6WiWaIiIiIiIyiTkNeMaYR4wxx4wxJ40xvz3FmMeNMYeNMYeMMf9vLudzS617rPB4fPbLNMM+N2GfW73wRERERETkGnMW8IwxLuBTwKPARuCDxpiN141ZA3wceKvjOJuAX5ur+dxylWuhfPXc7cOL+uiJK+CJiIiIiMgVc7mCtx046TjOacdxMsAXgHdfN+ZngU85jjMI4DhOzxzO59YyprCK1/4ipOOzfvlYxK8STRERERERucZcBrylQMdVX3eOP3e1tcBaY8zLxphXjTGPzOF8br11j0I+A6e+O+uXjkV9KtEUEREREZFrzPchK25gDfAA8EHg740xpdcPMsb8nDFmlzFmV29v762d4Rux/M3gL52TMs1Y1E/PSBpnjpqpi4iIiIjIwjOXAe88sPyqr5eNP3e1TuDrjuNkHcdpB45TCHzXcBzn047jtDqO01pVVTVnE551Ljes3QHHn4Z8blYvXR31k8nbDCWys3pdERERERFZuOYy4O0E1hhj6owxXuADwNevG/NVCqt3GGMqKZRsnp7DOd166x6F5AB0vj6rl73UC69bB62IiIiIiMi4OQt4juPkgF8GngaOAE84jnPIGPNHxph3jQ97Gug3xhwGngd+03Gc/rma07yofxAsz6w3PY+pF56IiIiIiFzHPZcXdxznSeDJ6577/as+d4CPjX8sTv4o1N1b2If38B/P2mVjkUsBTyt4IiIiIiJSMN+HrNwZ1j0G/Seh78SsXbJ6vESzRwFPRERERETGKeDdCuseLTzOYpmm3+OiJOBRiaaIiIiIiFymgHcrlCyDJVtnvV2CeuGJiIiIiMjVFPBulXWPQcdrMNY3a5eMRf10x7WCJyIiIiIiBQp4t8q6R8Gx4cQzs3bJ6ohfe/BEREREROQyBbxbpWYbRGpndR9eLOqjJ57Gtp1Zu6aIiIiIiCxcCni3ijGFVbyT34Xs7Ky6xaJ+8rZD/1hmVq4nIiIiIiILmwLerbTuMciOwZnvz8rlYuOtEnTQioiIiIiIgALerVV3L3jDs1amWR0tNDvviSvgiYiIiIiIAt6t5fZB/dsL7RKcN75vLjYe8NQLT0REREREQAHv1lv3GMS7oKvtDV+qOqISTRERERERuUIB71Zb8zAYa1aanntcFpVhr1bwREREREQEUMC79UIVsPzNs7cPT73wRERERERknALefFj3KFw8AEMdb/hSsaiPbh2yIiIiIiIiKODNj3WPFR6PP/WGLxWL+lWiKSIiIiIigALe/KhsgIo1s1KmWR310zeaJpe3Z2FiIiIiIiKykCngzZd1j0L79yE18oYuE4v6cBzoG83M0sRERERERGShUsCbL+seAzsLp77zhi4Ti1zqhad9eCIiIiIidzoFvPmyfDsEyt9wu4Qrzc4V8ERERERE7nQKePPFcsHaR+D405DP3fRlYtHxZudxHbQiIiIiInKnU8CbBQOpAQ71HbrxN657FFJD0PHqTd+7IuzDMqgXnoiIiIiIKODNhk+8+gk+9sLHbvyN9W8Hl/cNlWm6LENVxKcSTRERERERUcCbDU3VTVwYu8DFsYs39kZfGOruh6PfAse56furF56IiIiIiIAC3qxoijUBsLdn742/ed2jMNgOfcdv+v7VEb9W8ERERERERAFvNqwrW0fAHbi5gLf2kcLjG2h6Hov66NEhKyIiIiIidzwFvFngttxsrdp6cwGvZCnUNL6hfXixqJ+BsQzpXP6mryEiIiIiIgufAt4saa5u5vjgcUYzozf+5nWPQcfrMNp7U/e+1CqhV6t4IiIiIiJ3NAW8WdJY3Yjt2Ozv3X/jb173KODAiadv6t7Vl5udK+CJiIiIiNzJFPBmybaqbVjGYk/Pnht/85ItEF1202WasUgh4KkXnoiIiIjInU0Bb5aEPCHWla2jraftxt9sTGEV79R3IZu84bdfKtHUSZoiIiIiInc2BbxZ1FTdxP6+/WTt7I2/ed2jkE1A+4s3/NayoBePy9CtPXgiIiIiInc0BbxZ1BRrIplLcnzgJnrarboHvJGbapdgWUa98ERERERERAFvNjVVFRqe39Q+PLcPGh6EY0+Bbd/w26ujPnp0yIqIiIiIyB1NAW8WxUIxloaX3lw/PCi0Sxi9CF03/v6YVvBERERERO54CnizrKm6ib09e3Ec58bfvOYdYFw3dZpmLOpTwBMRERERucMp4M2ypuom+pJ9dMY7b/zNwXJYcfdNBbzqqJ+RVI5kJn/j9xURERERkUVBAW+WNVUX9uHt7b3ZMs1HofsgDJ69obfFxpud98S1iiciIiIicqdSwJtl9aX1RLwR9nTfxEErUAh4AMefuqG3XemFp4NWRERERETuVAp4s8wyFo1VjTd/0EpFPVSuu+F2CZdW8LQPT0RERETkzqWANweaY82cHj7NUGro5i6w7lE48xKkhot+SyyigCciIiIicqdTwJsDjVWNALT1tt3cBdY9BnYOTj5X9FuiATc+t0VPXCWaIiIiIiJ3KgW8ObC5cjNuy33zZZrLWiFYeUOnaRpjiEXVC09ERERE5E6mgDcH/G4/Gys23nzAs1yw9hE48Qzks0W/LRb1cXFYAU9ERERE5E6lgDdHmqubOdh3kHT+Jksm1z1a2IN37gdFv6U66leJpoiIiIjIHUwBb440VTeRtbMc7j98cxeofxu4fDdUphmLFEo0Hce5uXuKiIiIiMiCpoA3RxqrGwFuvh+eNwSrH4Cj34IiA1ss6iORyTOazt3cPUVEREREZEFTwJsj5f5yVkVX0dbTdvMXWfcoDJ2F3qNFDb/SC09lmiIiIiIidyIFvDnUVN3E3t692I59cxdY+0jhscim59VRHwA9OklTREREROSOpIA3h5qqmxhOD9M+3H5zF4jWQG1z0fvwLq/gxRXwRERERETuRAp4c6g51gxw8+0SoND0vHMXxLtnHKoSTRERERGRO5sC3hxaEVlBub/8DQa8RwEHTjw949Cwz03I61KzcxERERGRO5QC3hwyxhT24b2RgBfbBCUrbqhMs0creCIiIiIidyQFvDnWVN1ER7yD3kTvzV3AmMIq3qnnIZOYcXh11KcVPBERERGRO5QC3hxrqm4C3ug+vEchl4T27804NBb165AVEREREZE7lALeHNtQvgG/y//GAt7Kt4IvWlS7hFjUT/dIGqfI5ugiIiIiIrJ4KODNMY/Lw+bKzW8s4Lm90PAQHHsK7Ol76lVHfGRyNsPJ7M3fT0REREREFiQFvFugqbqJowNHSWRn3kM3pXWPwVgPXNgz7TC1ShARERERuXMp4N0CTdVN5J08B/oO3PxF1jwExjVjmeaSkksBT/vwRERERETuNAp4t8C26m0YDHt6pl99m1agDFa+ZcZ2CbGIAp6IiIiIyJ1KAe8WiHqjrClbQ1tP2xu70NpHoOcwjHRNOaQ66gOgJ64STRERERGRO40C3i3SVN3Evt595O38zV9kyebCY/+JKYf4PS5KAh6t4ImIiIiI3IEU8G6RpuomxrJjnBiaOpzNqHx14bH/1LTDYmp2LiIiIiJyR1LAu0UuNTzf0/0G9uFFl4HLBwMzBTy/TtEUEREREbkDKeDdIjWhGmLB2Bvrh2dZUF4H/aenHVYd8dOjFTwRERERkTuOAt4tYoyhubqZPT17cBzn5i9UXg8D0we8WNRHTzyNbb+B+4iIiIiIyIKjgHcLNVY30pPooWts6lMwZ1ReB4PtYNtTDolF/eRsh4FE5ubvIyIiIiIiC44C3iwY+Nw/0/UHfzDjuOZYM8Ab64dXUQ+5FIycn3JIbLxVgg5aERERERG5syjgzYJsZyfDX/kqdmb6FbM1pWsIeUJvrB9eeX3hcZqDVqqjhWbnPTpoRURERETkjqKANwsCLc046TSpQ4emHeeyXGyr2vbGV/Bg2n14sfGApxU8EREREZE7iwLeLAg2F0ovk3tmPiGzqbqJk4MnGcmM3NzNIrXg9k/bC68qfKlEUyt4IiIiIiJ3EgW8WeCurMSzcgWJPTOvzDVVN+HgsK9n383dzLKgrG7aFTyv26Ii5KU7rhU8EREREZE7iQLeLAk2t5DcvXvGFghbKrfgMq431g+von7aFTwo7MNTLzwRERERkTuLAt4sCbY0kx8aItPePv04T5D15evfWMArXz3eKiE/5ZBY1KcSTRERERGRO4wC3iwJNLcAkCyyTPNA3wGy+ezN3ayiHvKZ6VslRPw6ZEVERERE5A6jgDdLvHWrcJWVkdg9c8BrjjWTzqc5MnDk5m5WvrrwOE2ZZizqo280TS4/dUN0ERERERFZXBTwZokxhkBzM4k9u2cc21TdBHDzZZpF9sKzHegfm743n4iIiIiILB4KeLMo2NxM9uw5cr29046rDFSyPLKcPd032Q8vUgPuAPSrF56IiIiIiFyhgDeLgi2FfniJIvvhtfW2zXjq5qQsq1CmOW2zc/XCExERERG50yjgzSL/xo0Yn6/og1YGUgOcHTl7czerWD1tiaZW8ERERERE7jwKeLPIeL0EtmwpquF5c3Vhte/m9+GthsEzU7ZKqAh5sQzqhSciIiIicgdRwJtlgZYWUocPYycS045bVbKKEl/JGztoJZ+B4Y5JX3a7LCrD6oUnIiIiInInUcCbZcGWZsjnSe7fP+04y1g0VTXdfMCrGD9Jc9pWCX6641rBExERERG5UyjgzbJAYyMYQ2L3zO0SGqsbOTNyhoHUwI3f6HKrhOkPWtEKnoiIiIjInUMBb5a5olF8a9eSLOIkzebYG9iHF1kCnuC0Aa866tcePBERERGRO4gC3hwINDeR3LsXJ5ebdtymik14LS9tPW03fhNjCgetTFeiGfHTP5Yhk7Nv/PoiIiIiIrLgKODNgWBzC3YiQfr48WnHeV1eNlVuYk/PTTY8L5+pVUKhF17vqMo0RURERETuBAp4c+Byw/PdxfXDO9x/mFTuJkopK+ph8CzkJ18pVC88EREREZE7y5wGPGPMI8aYY8aYk8aY355m3HuNMY4xpnUu53OreGprcdfUkNxbXMDL2TkO9h288RuV14OdnbJVQvX4Cp724YmIiIiI3BnmLOAZY1zAp4BHgY3AB40xGycZFwF+FXhtruYyH4LNzSR27cZxnGnHNVY1Ajd50Er56sLjFGWaV1bwVKIpIiIiInInKCrgGWN+1RgTNQX/aIzZY4x5eIa3bQdOOo5z2nGcDPAF4N2TjPsvwJ8Ci2qZKdDcRK6nh+z5C9OOK/WXUl9Sf3MB73IvvMlP0iwPenFbRiWaIiIiIiJ3iGJX8H7KcZwR4GGgDPgI8CczvGcpcHXtYOf4c5cZY5qB5Y7jfGu6Cxljfs4Ys8sYs6u3t7fIKc+vYEsLAMk9xfXDa+tpw3Zu8LTLcAy84SlX8CzLUB1RLzwRERERkTtFsQHPjD8+BnzOcZxDVz13U4wxFvBXwK/PNNZxnE87jtPqOE5rVVXVG7ntLeNbswYrHC7qoJXmWDPxbJyTQydv7CbGQHndzL3w4lrBExERERG5ExQb8HYbY56hEPCeHt83N9Ny03lg+VVfLxt/7pIIsBl4wRhzBngz8PXFctCKcbkINDWR3FPEQStVTQA31w9vpl54UZ9KNEVERERE7hDFBryfBn4buMtxnATgAX5yhvfsBNYYY+qMMV7gA8DXL73oOM6w4ziVjuOschxnFfAq8C7HcXbd6Ddxuwo2N5E+cYL88PC045ZFllEZqLy5fnjl9TA0fasElWiKiIiIiNwZig14dwPHHMcZMsZ8GPhPwLSpxXGcHPDLwNPAEeAJx3EOGWP+yBjzrjcy6YUi0FzYh5fYO/0BKsYYmqqbbm4Fr6Ie7Fwh5E0iFvUznMySyuZv/NoiIiIiIrKgFBvw/hZIGGO2Udgzdwr47ExvchznScdx1jqOU+84zifGn/t9x3G+PsnYBxbT6h1AYOsWcLtJFtnw/PzoeS6OXbyxm5SPn6Q50D7py9WRS73wtIonIiIiIrLYFRvwck6hodu7gf/lOM6nKOyhk2lYgQD+TRtJFLEPr7m6GbiJfXhF9sK7qH14IiIiIiKLXrEBL26M+TiF9gjfGj8B0zN301o8gs0tpA4cwM5kph23tnwtAXfgxvvhhasLrRKmOGjlSrNzBTwRERERkcWu2ID3fiBNoR/eRQonYv75nM1qEQk0N+FkMqQOHpp2nMfysLVy640HPGMKq3hTruAVSjQV8EREREREFr+iAt54qPs8UGKMeSeQchxnxj14AsHmQullMQ3Pm2JNHBs8xlh27MZuUlE/5QpeScCD123RE9cePBERERGRxa6ogGeMeRx4HXgf8DjwmjHmR+dyYouFu6IC76pVRTU8b6pqwnZs9vXuu7GblNfD0DnIZye8ZIxRLzwRERERkTtEsSWav0uhB95POI7z48B24PfmblqLS6ClmeTevTj29L3ht1ZtxTLWjZdplq8GJ18IeZOIRfwKeCIiIiIid4BiA57lOE7PVV/338B773jB5hbyQ0Nk2idvZXBJ2BtmbdnaGw94FeOtEqY5aEVtEkREREREFr9iQ9pTxpinjTEfNcZ8FPgW8OTcTWtxCTQ3AZDYXcQ+vOom9vfuJ2fnir/B5V54Uwc8reCJiIiIiCx+xR6y8pvAp4Gt4x+fdhznt+ZyYouJd9UqXOXlRTU8b65uJplLcmzwWPE3CFWCLwoDpyd9ORb1MZbJM5q+gdAoIiIiIiILjrvYgY7jfBn48hzOZdEyxhBsaS6q4XljdSMAe7v3sqliU7E3gPK6onrhhavCxV1TREREREQWnGlX8IwxcWPMyCQfcWPMyK2a5GIQaG4h29FBtqdn2nFLQkuoDdWyp2fmMHiN8vopSzSr1QtPREREROSOMG3Acxwn4jhOdJKPiOM40Vs1ydvd0Ve7ePWrk4erS4Itl/rhzXyASmN1I209bTiOU/wkKsZbJeQyE166tIKng1ZERERERBY3nYQ5C3rOxNn33Q7y+anbIPg3bMD4/SSKaHjeXN1Mb7KXztHO4idRXg+ODUNnJ7x0dYmmiIiIiIgsXgp4s6CmoYRcxqb3XHzKMcbjIbB1a1EHrTTFCqdutvW0FT+JS60SJjloJexzE/K66NYKnoiIiIjIoqaANwtq15QC0HVieNpxgZZmUkePYo+NTTuuobSBiCdyY/vwylcXHqc5aKU7rhU8EREREZHFTAFvFoRKfJRUBbhwcmjaccHmFsjnSe7fP+04y1hsq97G3u4baHgerABfybQHrfSoRFNEREREZFFTwJslNWtK6To1hGNPfTBKoHEbGEOimDLN6iZODZ9iOD39quBlxkDF6ulX8FSiKSIiIiKyqCngzZLahhLSYzkGuqYuv3RFIvjWrSNZxEErTdU3sQ+vvH6aZud+ukdSN3Yyp4iIiIiILCgKeLPk8j68Gcs0m0m07cPJ5aYdt7lyM27Lzd6eGyjTLF8Nwx2TtkqojvhI52xGktPfV0REREREFi4FvFkSrQwQLPFy4eTMB604iQSpY8emH+cOsLF8440FvIrxVgmDZya8dLlVgg5aERERERFZtBTwZokxhtqGUi6cGJq2DDLY0gJQXLuE6iYO9h0kk5+4Ijep8kutEibuw1MvPBERERGRxU8BbxbVrillbChNvH/qEOVZsgR3bQ2JPcUFvIyd4XD/4eImcKkX3iQHrcSiPgAdtCIiIiIisogp4M2imoZSgKLaJSR3757xwJPG6kaA4vvhBcvBXzrpQSvVEa3giYiIiIgsdgp4s6iiNoQv6KbrxNC044ItzeR6e8l2dk5/vUAFq6KrbvyglUlKNANeF1G/W73wREREREQWMQW8WWQsQ019ycwHrTSP78MrokyzsbqRtp42bMcubhIV9dA/XasElWiKiIiIiCxWCnizrKahlKHuBImRqQ9G8a1pwIpEimp43lzdzFB6iDPDZ4qbQHl9oVVCduJKXSzq1ymaIiIiIiKLmALeLCumH56xLAJNjSSKaHh+aR9e0WWaFfWAA0NnJ7xUHfXRoxU8EREREZFFSwFvllWtiOD2WFyYaR9ecwuZk6fIDQ5OO25VdBVlvrLiD1opX114nPQkTT898RS2Pf3hLiIiIiIisjAp4M0yl9sitjo680maLc0AJPe2TTvOGHN5H15RLgW8yXrhRXxk8w6DiSL76omIiIiIyIKigDcHahpK6e8cJZPMTTnGv2ULeDwk9xa3D+9c/Bx9yb6Zbx4sh0DZlCt4oF54IiIiIiKLlQLeHKhtKMVxoOv01KdpWn4/gY0bizpopSnWBNzAPrzy+klX8KovBTwdtCIiIiIisigp4M2BJatLsCwz4z68QEsLqQMHsNPTr6htLN+Iz+W7sYNWBtonPB2L+gDUC09EREREZJFSwJsDHp+LyhWRaU/ShMI+PCebJXXw4PTXc3nYXLmZvd3FruCthuHOCa0SqiKFgKcSTRERERGRxUkBb47UNpTQfWaEXDY/5ZhAU6H0MlFEw/Om6iaODhwlkU3MfPPy8VYJg9eu4vncLspDXrq1giciIiIisigp4M2R2jWl2DmHnjMjU45xl5fjXb2aZDH78KqbyDk5DvZNv9oHQMXUrRKqIz6t4ImIiIiILFIKeHOkpr4UgAsnpj5oBSDQ3ERi714c25523LaqbRhMcf3wLrdKOD3hpUu98EREREREZPFRwJsj/rCH8trQzPvwmluwh4fJnJq42na1El8J9aX1xfXDC5RBoHzyXnhRn0o0RUREREQWKQW8OVTTUErX6WHs/NSrc5canhfTLqG5upm23jby9tT7+i6rqJ+yF15vPE3edma+hoiIiIiILCgKeHOodk0J2VSevs7RKcd4VqzAVVlZVMPzplgTY9kxjg8en/nm5fWTlmhWR/3YDvSPah+eiIiIiMhio4A3h2obSgHoOjn1PjxjDMHm5qJW8FqqWwCK24dXUQ8j5yFz7ambMbVKEBERERFZtBTw5lC4zE+kws+FGfbhBZqbyHZ2ku3unnZcTbiGmlANu7t3z3zzSwetDJ655ulY1A+gfXgiIiIiIouQAt4cq11TStfJIRxn6j1vwZbCylyyiH54LbEWdnfvnvZ6wFUnaV67D+9ywNNJmiIiIiIii44C3hyrbSglGc8y1D11g3L/+vWYQKC4g1ZizQykBjg7cnb6gRX1hcfrDlqpDHsxRiWaIiIiIiKLkQLeHKtpKAHgwomhKccYj4fAtm1Fr+ABM5dp+ksgWDlhBc/tsqgM++hRiaaIiIiIyKKjgDfHSmNBAhHPjPvwgs3NpI4eJT86Nu24umgd5f7y4g9aGWif8LR64YmIiIiILE4KeHPMGENtQyldJ6Y+SRMg0NwMtk1yX9uM12uubi7+oJXJeuFF/CrRFBERERFZhBTwZkEyPsLFk1P3pqtpKCU+kCI+MPWqWaBxG1gWySL34Z0fPc/FsYvTDyyvh/iFCa0SqqN+enTIioiIiIjIoqOANwue/fT/4mt/9V+nPNmydk0pAF3TlGm6wmF869eRKKLh+aV9eHu6ZxhbcekkzWsbnseiPvpGM2Tz9oz3EhERERGRhUMBbxasamxhtL+P/o7JT7asWBbG43dNe9AKQLC5heS+/TjZ7LTj1pWtI+QJzVymWT5+kuYUrRJ64yrTFBERERFZTBTwZkFdU2FF7fTeXZO+blmGmvoSLpycfh9esLkJJ5EgdfTYtONclovG6saZD1opn3oFD9TsXERERERksVHAmwWR8kqqVtbR3jZ5wIPCPrzBrjGSo5kpxwSamwFI7pn5AJWW6hZODp1kKDU09SB/FEJVEw5aqY6MNzvXQSsiIiIiIouKAt4sqWts4cKxI6QTk7c5uLIPb+pVPM+SJXiWLi2q4fnlfXgzruLVT7KCVwh4OmhFRERERGRxUcCbJXVNrdj5PGcPtE36emxlFJfbmrEfXqClmcTePVMe2HLJ5srNeC3vzPvwKuonrOBVhLy4LaMSTRERERGRRUYBb5bUrt2ALxiife/kgcvlsaheFaGriINW8r19ZDs6ph3ndXnZXLl55pM0y1fD6EXIXFlZtCxDdcTHxWGVaIqIiIiILCYKeLPEcrlYubWJ9rZdU7dLaCilt2OUTCo35XUCzU0ARZdpHhk4QiKbmHrQFAetqBeeiIiIiMjio4A3i+qaWhkbHKD3bPukr9euKcWxHbpPj0x5DV9DA1Y0WtxBK7EW8k6ett62qQdVjLdK6L++VYJPJZoiIiIiIouMAt4sqmssHHzSPkW7hCWrSzCGaffhGcsi2NRU1ApeY3UjlrGmL9O8vII3sReeTtEUEREREVlcFPBmUai0jOq6+inbJXgDbiqXR+ia8aCVFjKnT5MbHJz+fp4Q68vXT3/Qii8C4Rj0TzxJcziZJZXNT3sPERERERFZOBTwZtnqplYuHDtKanR00tdrG0q52D5CPmtPeY1gy3g/vL17Z7xfS6yFA30HyOSn7q9H+eqJe/AihWbnPVrFExERERFZNBTwZtmqxlYcx+bsgcnDWc2aEvJZm55z8Smv4d+8GePxkNhdXMPzdD7Nof5DUw8qr5+0RBOgWwetiIiIiIgsGgp4s6xmzVr84ciU+/Bq6ksBpi3TtHw+/Js3kyxiH15TrHDq5rRlmhWrYbQb0ldC5eWAp4NWREREREQWDQW8WWZZLlZta6a9bTeOPbEMMxj1UrYkOGPD82BLM8lDh7BT0wewcn85q0tWTx/wysdP0ryqTDMWLZRo6qAVEREREZHFQwFvDtQ1tpAYHqLnzOlJX69pKKXr5DC2PXm/PIBAcwtks6QOHpzxfi2xFtp62sjbUxyYUjEx4JUEPHjdFj1awRMRERERWTQU8ObAqm3NYAyn9+6c9PXahhIyyRwDFyY/iAUg0NQIFNfwvDnWzGh2lOODxycfUFZXeLyqF54xRr3wREREREQWGQW8ORAsKWXJ6gba2yYvm6xpKAXgwonhKa/hLivDW19PooiG562xVgD29EwRBn1hCC+ZcJJmLKJeeCIiIiIii4kC3hypa2ql68QxEiMTQ1ykwk+4zMeFE0PTXiPY3Exyb9uke/mutiS0hNpQ7QwHrdRfs4IH483OdYqmiIiIiMiioYA3R+qaWsFxOLt/YrsEY8z4PrwhHGeafXgtzdgjI6RPnpzxfs2xZnZ37576euWrJ7RKqI761AdPRERERGQRUcCbI0tWryEQiU5Zplm7ppTESIbh3uSU1wi2tACQ3DPzPryWWAsDqQHOjJyZfED5ahjrhdTI5adiUT+j6Ryj6dyM1xcRERERkdufAt4cMZbFqsYWzrTtxp7kdMva8X140/XD8yxbhquqsuiDVgD2dE8xdpKTNC+1StBJmiIiIiIii4MC3hyqa2olGR+h+9TEEsuymiD+kGfafXjGGILNLSR3z3zQSl20jnJ/+dQHrVzuhXelTDMWudTsXGWaIiIiIiKLgQLeHFq1tQljLNrbdk14rbAPr4QLJ6c+SRMKDc+zFy6QvXhx2nHGGJqrm6c+aKV8deGx/8oKXnW0EPB6dNCKiIiIiMiioIA3hwKRKEvWrKV978SAB4V2CSO9ScaGpl5BCzTf2D6886PnuTg2SRj0BiFSO2mJpnrhiYiIiIgsDgp4c6yusYWLp0+SGB6a8FrtmlIALkyzD8+/fh0mGLyhfXjTruJdVaIZ9rkJel0q0RQRERERWSQU8ObY6qa7wHE4s29iQKtaHsbtc9E13T48t5vAtq0kiljBW1e2jpAnNM1BK6uv6YVnjCn0wtMKnoiIiIjIoqCAN8eqV60mWFLK6UnKNC2XxZK66Mz78JpbSB87Rn50dNpxLstFY3XjNCt49ZDog9SV+1VH1AtPRERERGSxUMCbY8ayqGts4ey+PZO3S1hTSv+FUVJj2SmvEWxpBtsm2bZvxvu1xlo5NXyKwdTgxBcvtUq4ahUvFvXTrUNWREREREQWBQW8W6CuqZXU2ChdJ45PeK22oRQcuHhq6lU8/9Zt4HKR3DNzu4Tm6vF+eJO1S7h0kuZ1B610j6RwHGfGa4uIiIiIyO1NAe8WWLmlCWNZk56mGauLYrnMtAetuMIh/OvWFXXQyubKzXgt7+T78MrqCo/XBDw/qazNSCo347VFREREROT2poB3C/jDYWrXrp+0H57b66J6ZZSuaQIeQKClheS+fTjZqUs5AbwuL1uqtky+D88bhOjSa0o0L/fC00ErIiIiIiILngLeLVLX2EpP+ynGhibujatdU0LPmTjZzMQ9epcEW5pxUilSR47MeK/m6maODhxlLDs28cXrWiXEIpd64emgFRERERGRhU4B7xapa2oFoL1t4spaTUMptu3Q3T4y5fsDTYW9dcW0S2iNtZJ38uzrmeRQlor6CSWaoGbnIiIiIiKLgQLeLVK1so5QWfmk+/Bq6kvAMG2ZpidWjWf5cpJF7MPbVr0Ny1js7pmkTLN8NST6IVm4V3V0fAVPJ2mKiIiIiCx4CnizxE5PXV4JhabidY2tnN2/Fzt/7Vhf0EPF0jAXpml4DhBsbiKxZ8+MJ16GPCE2lG+Y/KCV8vFWCeNlmkGvm4jfrV54IiIiIiKLgALeLBj40nF6//fMPerqmlpIJ8a4cHziPrrahlIunh4mn7enfH+gtZV8fz/p4ydmvFdzrJn9vfvJ5DPXvnC5F961ZZoq0RQRERERWfgU8GaBpyZEtmuMbE9i2nErtzRiuVyTl2k2lJDL2PSdG53y/ZEHHgBjiD/77Ixzaom1kLEzHOo/dO0LZXWAufaglfFeeCIiIiIisrAp4M2C4JYqMJDY1zvtOF8wxNJ1GycNeLVrSgGm7Yfnrqoi2NJC/OmnZ5zTpYbnE9olePyFVglXH7QS8esUTRERERGRRUABbxa4ol58dSUk9/fOuD9uVWMLvefOEB/ou+b5UImPkqrAjPvwIg8/TPrECdKn26cdV+Yvo76kfvJ+eBWrJ/TC64mnZpy7iIiIiIjc3uY04BljHjHGHDPGnDTG/PYkr3/MGHPYGLPfGPMdY8zKuZzPXApsqyLXmyTbNUnvuausvtQuYe8k7RLWlNJ1agjHnjpoRR5+BwDxZ56ZcU7NsWbaetrI29cdAFNeP6FEM5t3GExM30RdRERERERub3MW8IwxLuBTwKPARuCDxpiN1w3bC7Q6jrMV+BLwZ3M1n7kW2FwJliE5Q5lmxfKVhCsqJy/TbCglPZZj4OLUIdGzZAmBxkZGnpm5TLMl1sJodpTjg8evm0Q9JAchMQCoF56IiIiIyGIxlyt424GTjuOcdhwnA3wBePfVAxzHed5xnEsnk7wKLJvD+cwpV8iDf00piX3Tl2kaY1jd2Mq5g23kc9eumNWuKQGga6YyzR07SB8+QubcuWnHtcRagEn24V1ulVAo84xd6oWngCciIiIisqDNZcBbCnRc9XXn+HNT+Wng25O9YIz5OWPMLmPMrt7e6VfI5lNgaxX5oTSZjvi04+qaWskkk5w/em27hGhlgGCJlwsnh6d9f7TIMs0loSUsDS9lT891/fDKVxcex8s0qyOFFTz1whMRERERWdhui0NWjDEfBlqBP5/sdcdxPu04TqvjOK1VVVW3dnI3ILCpAtwzl2mu2LwVy+Wmve3aMk1jDLUNpXSdHJp2FdCzdCn+zZsZebqIfXjVzezu3n3t9cpWAebyQSvVWsETEREREVkU5jLgnQeWX/X1svHnrmGMeQj4XeBdjuMs6CUky+/Gv66cxP6+aQ9K8QaCLNuwacp2CaODaeL904etyI6HSR04QPb8hF/SazTHmhlIDXBm5MyVJz1+KFl+eQXP53ZRFvTQHVfAExERERFZyOYy4O0E1hhj6owxXuADwNevHmCMaQL+jkK465nDudwywW1V2PEM6fbpyyzrmlrp7zzHSN+133ZNQykwfT88gOjDDwMwMkPT8yn34V3XKiEWVS88EREREZGFbs4CnuM4OeCXgaeBI8ATjuMcMsb8kTHmXePD/hwIA180xrQZY74+xeUWDP/6cozXmrFMs65x8nYJFbUhfEH3jAeteFeuxLdhA/EZyjRXRVdR7i9nT/ck+/CuanZeHfXToxJNEREREZEFbU734DmO86TjOGsdx6l3HOcT48/9vuM4Xx///CHHcWKO4zSOf7xr+ive/iyvC/+GCpIH+3Dy9pTjypcuI1oVm7gPzzLU1JfMeNAKQHTHwyT37iXb3T3lGGMMLbGWSQ5aqYfU0JVWCRGfVvBERERERBa42+KQlcUmuK0KO5EjNU2ZpTGGusYWzh3YRy57bbuEmoZShroTJEYy094nMl6mGX9m+jLN5upmzo+e5+LYxStPVoy3Shgv04xF/fSOpslPs3dQRERERERubwp4c8C/tgzjd81cptnUSjad4vyRQ9c8X7umFICuGfbh+VavxremgfjT0zc9n3Qf3uVeeJcCno+87dA/plU8EREREZGFSgFvDhi3RWBTJclD/TjZqcs0V2zaisvjob1t5zXPV62I4PZYMx60AhB5eAeJ3bvJ9fVNOWZt2VrCnvC1Aa9sJRjr8j686qh64YmIiIiILHQKeHMkuK0KJ50ndWxgyjEev59lGzZPOGjF5baIrY7SVcQ+vMiOh8FxiD/33JRjXJaLxurGaw9acfugZNnlEs0l4wFPvfBERERERBYuBbw54qsvxQq5SeyfvkxzdVMrAxc6Geq+eM3zNQ2l9HXEySRz099nzRq8dXWMFFGmeWr4FIOpwStPltdfVaJ5KeBpBU9EREREZKFSwJsjxmUIbKkidWQAO52fclxd03i7hOtO06xtKMVxoOv09Kt4xhgiDz9M4vWd5AamXi28tA/vmtM0K+qh/zQ4DpVhL8ZoBU9EREREZCFTwJtDwa1VOFmb1JH+KceU1SylNFbDmbZryzSXrC7BssyM/fCg0C6BfJ74d74z5ZhNFZvwWt6JB62khyHRj9tlURn20RNXwBMRERERWagU8OaQd1UUK+olUcRpmucO7iebuVIe6fG5qFwRKeqgFd+GDXiWL5+2XYLX5WVr1dZr9+GVry48jh+0EouqF56IiIiIyEKmgDeHjGUIbq0idXwQO5GdclxdYwu5TJrOwweveb62oYTuMyPkslOXeEKhTDO642HGfvAD8sNTl3Q2x5o5MnCEsexY4Ynre+FF/CrRFBERERFZwBTw5lhwWxXkHZKHpy7TXLZpC26Pd+I+vDWl2DmHnjPxGe8T2bEDcjni331+yjEt1S3Yjs2+nn2FJ0ovtUooBLzqqF8reCIiIiIiC5gC3hzzLAvjKvdPW6bp8fpYvnkr7XuvDXg19aUARZVp+jdvxl1bM23T823V23AZF7t7xvfhub1QuuLKCl7UR/9Ymmx+6t59IiIiIiJy+1LAm2PGFMo006eGyI9mphxX19jC0MUuBrvOX37OH/ZQXhsq6qAVYwzRdzzM2Msvkx8dnXRMyBNiffn66w5aWX3VHjw/jgO9ca3iiYiIiIgsRAp4t0CwsQpsSB7sm3JMXdNdALRfd5pmTUMpXaeHsW1nxvtEduzAyWYZff6FKce0xFo40HuATH48bJbXFwKe4xCL+gC1ShARERERWagU8G4BdyyIuzo4bZlmaWwJZbXLJpRp1q4pIZvK0985+arc1QKN23BXVxN/ZuoyzeZYMxk7w8G+8QNdKuohPQJjfVRH1OxcRERERGQhU8C7BYwxBLdVkTkzQm546vBU19hCx+EDZNNXVtBqG0oBuFBMmaZlEXn4YUZf/D722NikY5qrm4GrGp6Xj5+kOXCKWLQQ8NQLT0RERERkYVLAu0UCWyvBgeT+6co0W8lns3QcOnD5uXCZn0iFv6iDVgAiD78DJ51m9MUXJ329zF9GfUk9u7rHVwqvapVQEfLisoxKNEVEREREFigFvFvEUxXEszRMYv/UZZrLNmzG7fNxekKZZildJ4dwnJn34QVbWnBVVDDy9DNTjmmJtdDW00bezhdO0TQuGDiNZRmqI2p2LiIiIiKyUCng3ULBrVVkO+Lk+pOTvu72eFixeRvte3ddE+ZqG0pJxrMMdSdmvIdxuYi84yFGX3wROzn5fZpjzYxlxzg2eAxcnkLIu6YXnlbwREREREQWIgW8WyiwtRKAxDRlmqubWhnp7WbgQufl52oaSoDi9uEBRHfswEkkGH3ppUlfb4m1ALCne3wfXkX9lV54ER89WsETEREREVmQFPBuIXeZH+/KKMlpTtOsa2wFuOY0zdJYkEDEQ9fJ4aLuE7zrLlylpcSnKNNcElrC0vDSK/3wrmmV4Kdbh6yIiIiIiCxICni3WHBrJdmLY2S7Jz/lMlpVTcWyFdf0wzPGUNtQWvRBK8btJvzQg4w+/zx2evLVuObqZvb07CmUgpavhswojPUSi/oYSmRJZfM3/L2JiIiIiMj8UsC7xQJbq8BMX6ZZ19TK+SMHyaSu7KGraSgl3p8iPlDc6lp0xw7ssTHGXn5l0tdbYi0MpAZoH2m/5iTN6vFWCb1xlWmKiIiIiCw0Cni3mCvixbe6hOS+3ilPxaxrbCGfy3Hu4P7Lz9WuKQWgq8hVvNCb3oQVjRJ/evKm582x8X543XsKK3hwTS88HbQiIiIiIrLwKODNg8C2KnJ9SbIXJi/TXLp+Ix5/gPa9Oy8/V7EsjMfv4kKR+/CM10vk7W8n/vzzOJnMhNdXRVdR7i8vBLzSlWC5of8UsagPQK0SREREREQWIAW8eRDYVAmWmbInnsvtYeWWbbTv3X15lc+yDDX1JUWfpAkQ2fEw9sgIY6+9NuE1YwwtsZbCQSsudyHkDZwiFtEKnoiIiIjIQqWANw9cIQ/+NaXTl2k2tRLv76W/89zl52rXlDLYNVb0PrzQW9+KFQoxMkWZZkushQtjF+ga7SqUaQ6cpjToweuydJKmiIiIiMgCpIA3TwLbqsgPpcmci0/6+mTtEta0xrBchj1Pny3qHpbXS/htb2P02edwstkJrzdXF/bh7e7ZPd4L7zQGqI6qF56IiIiIyEKkgDcL2traeO65527oPYGNFeA2U/bEi1RUUrli1TUBL1oZYMNbazn80oWiV/EiOx4mPzxMYufOCa+tLVtL2BMeP2ilHrJjMNpd6IWnEk0RERERkQVHAW8WdHd388orrzAyMlL0eyy/m8C6chIHenHsqcs0zx87TDqRuPxcyyMrwcCuJ88UdZ/wvfdigkFGnpnY9NxluWisbizsw6sYP0lz/KAVBTwRERERkYVHAW8W3HXXXdi2ze7du2cefJXAtirseJZ0++QnY65ubMXO5zl3oO3yc5FyP5vuWcrRV7oY7k1O+r6rWX4/4fvvI/7sczj5ic3LW2ItnB4+zUCoovDEwGmqI36VaIqIiIiILEAKeLOgvLycNWvWsHv3bnK5XNHv868vx3itKcs0a9auxxsI0t6265rnWx5ZiXEZdn37TFH3iT78MPn+fhKTBNCWWAsAe1O9hVYJ473w4ukcY+nivxcREREREZl/CnizZPv27YyOjnLkyJGi32N5Xfg3VpA82IeTtye87nK7WbW1ifa9u645bTNU6mPzfUs59upFhroTE953vfB992F8PuJPTyzT3FSxCZ/Lx+6+NihbdU0vvJ64VvFERERERBYSBbxZUl9fT1lZGa+//voNvS+4tQo7kSN1cmjS11c1tTA6OEDv2fZrnm/esRKXy7DzyfZJ33c1KxQifN+9xJ95Bse+Nkh6XV62VG4p7MMrr4eB08Si6oUnIiIiIrIQKeDNEsuy2L59Ox0dHXR1dRX9Pv/aMozfPWWZZt22Qglle9u15ZXBqJctDyzjxOvdDHSNzXifyMM7yPX2kmzbN+G15lgzRweOMla2EgZOs7w0AMBTBy8W/X2IiIiIiMj8U8CbRY2NjXg8nhtaxTNui8DmCpKH+nGyE8s0w+UVVK+qv6ZdwiVNO1bg9rrY9a2ZV/HCb3sA4/EQn6TpeUusBduxafP7IJtghXeEj75lFZ955Qxf3t1Z9PciIiIiIiLzSwFvFgUCAbZu3cqBAwdIJGbeG3dJcFsVTjpP6tjApK/XNbVw4fgRUmOj194v7GXr25ZxYncP/edHJ33vJa5wmNA99zDyzDPX7OcDaKxqxGVc7HbG5zxwit/9oQ28pb6Cj3/lAG0dQ0V/LyIiIiIiMn8U8GbZXXfdRS6Xo62trej3+FaXYoU8JPZPUabZ2Ipj25zdP/Gaje9YgdfnYuc3Z17Fizz8MLmuLlIHDlzzfNATZEP5BvYkLxSe6D+Fx2XxqR9rJhb18XOf3aX9eCIiIiIiC4AC3ixbsmQJK1asYOfOndj2xJLLyRiXIbClktSRAez0xF51NWvW4Q+FJy3T9Ic8bHtwOaf29tLbEZ/2PpG3vw3cbkYmKdNsjjVzYPAEGcsDA6cAKAt5+fsfb2U0nePnP7ebVHbi3ERERERE5PahgDcHtm/fzuDgICdPniz6PcFtVThZm9SR/gmvWS4XK7c2cWbf7gmnYAJse3A5vqCb178x/Sqeq6SE0N13E396YplmS6yFjJ3hYOUKGDh9+fn1S6L81ePbaOsY4j999eCE94mIiIiIyO1DAW8ObNiwgXA4fEOHrXhXRnFFvSSmOk2zqZWxoUF6zpye8Jov6KHxoeWc2d9Hz9mRae8T3fEw2c5O0tf162uubgZgd6QU+q+9xyOba/jVB9fwpd2d/NPLZ4r+nkRERERE5NZSwJsDLpeL1tZWTp48SX//xBW5yRjLENhaRer4IHYiO+H1VdsKAWyyMk2ArW9bji808ype+MEHweVi5Lqm56X+UhpKG9jtprCCd91K4a8+uIYdm2J84skjvHSir6jvSUREREREbi0FvDnS0tKCZVns3Lmz6PcEt1VB3iF5eGIoDJWWEVu9ZkI/vEu8ATfND6/k7MF+Lp4envIe7rIygtvvIv7UUxPKLZurm2nLDZPPJSF+bS8/yzL85eONNFSF+aX/t4ez/TP33hMRERERkVtLAW+ORCIRNm7cyN69e8lkMkW9x7MsjKvcP22ZZteJY/R1nJ309c33LyUQ8fD6NyaWcV4tumMHmbNnSR8/cc3zLbEWxuwMx7xXDlq5Wtjn5u9/vBVj4Gc/u4vRdK6o70tERERERG4NBbw5tH37dtLpNPv37y9qvDGG4LYq0qeGyI9ODIVbH9pBsKSEr/zpH5EYHprwutfvpunhlXQcGeTCiYmvXxJ56CEwZkLT8+bY+D48v/+ag1autqIiyKd+rJlTvWN87F/bsG0duiIiIiIicrtQwJtDy5cvZ8mSJbz++utFnz4Z3FYFNiQPTtznFimv5N2/+Z9IDA3ytb/4BLlJVgY337+UYNQ77Sqeu7KSYGsr8Wev3Ye3JLSEpeGl7AkEoH/iCt4lb22o5Hcf28Azh7v55HdOTDlORERERERuLQW8OWSMYfv27fT09HD27ORllddzx4K4q4NTlmnWNKzjkV/6GBeOH+Hp//3JCcHR43XR/MhKzh8fovPY4JT3iezYQfrESdKnrg1yLbEW9vj9ONMEPICffOsq3teyjE9+5wRPHeyadqyIiIiIiNwaCnhzbPPmzfj9/qJbJlwq08ycGSE3nJ50zLq77+Gt7/8IR1/+Hq/+2xcmvL7p3lpCpT5e/8bpKVcOI+94CID4M9eu4jVXNzNgQfvg9D38jDH88Xs207SilI89sY+jF6dvzyAiIiIiInNPAW+Oeb1empubOXLkCCMjxYWgwNZKcCC5f/JVPIA3vedxNt77Nl554vMcfeXFa15ze1y0PrqSrpPDdB6ZfBXPE4sRaGqa0C6hJdYCwJ5094RWCdfzuV383YdbiPjd/Mz/3cXAWHGHyYiIiIiIyNxQwLsFWltbcRyHXbsm72F3PU9VEM/S8JRlmlBYQXvHz/8KS9dv5Km/+WsuHD96zesb3lJLuNzHa9Ot4u14mPTRo2SuKh9dGV1JuSvIbq8L4hdmnGt11M/ffaSVnniaX/r8HrL56UOhiIiIiIjMHQW8W6C8vJy1a9eye/ducrniWgsEt1aR7Rwl15+ccozb4+Fdv/67hMsr+Npf/DEjvT2XX3N5LFofXUV3+whnD07ebD368MMAjFxVpmmMoaVsLXt8Pug9VtRcG5eX8t/es4UfnO7nE986UtR7RERERERk9ing3SLbt29nbGyMI0eKC0CBrZUAJKYp0wQIRkt4z3/8z+SzWb7yp39IOpG4/Nr6t9QQrfTz+jfaJ13F89TW4t+6lfj1ZZrL7uWCx03Xt34NBs8UNd/3tizjZ+6p4zOvnOGJnR1FvUdERERERGaXAt4tsnr1asrLy4s+bMVd5se7MkpymjLNSyqWLeed/+G36T/fwbf+x59h5/MAuFwWrY/V0XsuTvu+iW0XAKIPv4PUwYNkOs9ffu6uFQ8A8Ge+LKl/emzalglX++1H13Pvmkp+96sH2H12oKj3iIiIiIjI7FHAu0Usy+Kuu+6io6ODCxdm3tsGENxaSfZigmz32IxjV21t4sGf+gXa9+7ie5/7x8vPr3tTjJKqAK9/sx1nkqbkkfEyzatP01xbtpbfaP0NvhPw8tMR6P/Mo9BzdMJ7r+d2WfzPDzZRWxrg5z+3h67hqctLRURERERk9ing3UKNjY14PB527txZ1PjA1iowTHvYytW2veMxmh97N3u+/XXannkSAMtlcdc76+jvHOV028TreFeswLdxA/Gnn77m+Z/Y9BP89QN/zXF/gA+VeTj9uXfCxYMzzqE06OUffryVZCbHz39uN6lsvqi5i4iIiIjIG6eAdwsFAgG2bt3KgQMHSFy1V24qrogX3+oSkvv7pjwJ83r3f+SnWN18F9/9p//NmX17AFhzV4yyJUFe/2Y79iSreNGHd5Dct4/sxYvXPP/gygf5p0f/L6lgOR8u9/Pav7wbLrTNOIc1sQj//QNN7O8c5uP/dqDouYuIiIiIyBujgHeLbd++nVwux969e4saH9hWRa4vSfbCzGWaAJbl4od+5TepXLaCb/z1n9DfeQ7LMtz1zjoGLoxxanfPhPdEdlwq03x2wmubKzfz/975r8RKVvILZUG+8sR7oXPmdg/v2Bjj19+xlq/sPc8/fL+9qLmLiIiIiMgbo4B3i8ViMVauXMnOnTuxZ2gkDhDYVAmWKbpME8AbCPIjv/X7uL1evvKnf0hiZJiG5mrKa0OTruL56urwrVnDyDNPT3q92nAtn33nF7iruonfLwvyP77yAewzL884j19+ewOPbVnCf/v2Eb53vPj5i4iIiIjIzVHAmwfbt29naGiIEydOzDjWFfLgX1NKcn/vpIekTCVaWc2P/MffY2xwkK/9xSfI53Ns/+E6hroTnNjZPWF8ZMcOkrv3kO2ZuMIHEPFG+NQj/8h7Vz7C30cD/Pa3f5L0qe9MOwdjDH/xvm2sjUX49/9vD+19xa1CioiIiIjIzVHAmwfr168nEokU3TIhsK2K/FCaTEf8hu5T07COR37pP3Dh2GGe+bv/Qd3WSiqXh9n5zXbs/LWrh9EdD4PjEH/uuSmv57E8/Of7/4z/sPln+XbQx8985xcZOPLVaecQ9Lr5+x9vxWUZfub/7iSeyt7Q9yAiIiIiIsVTwJsHLpeL1tZWTp06RV/f5P3prhbYWAFuU1RPvOutu/te3vr4hzny/ed5/atPsP2ddQz3Jjn22rUHqngbGvCuXj2h6fn1jDH8VMuv8Jdv/gOOeL18+OWP09722Wnfs7w8yN98qIUz/Ql+7Qttkx70IiIiIiIib5wC3jxpbm7GsqyiWiZYfjeBdeUkbrBM85I3/bv3s+Het/HyE/9MeuwI1Ssj7PzWGfJXreIZY4jseJjEzp3kBmZuUv7wuvfyjw/+DWNuDx/e86fsfPWT046/u76C//zDG/nO0R7+6tnjN/w9iIiIiIjIzBTw5kkkEmHTpk20tbWRTqdnHB/YVoU9miV9eviG72WM4eGf/xVq123k6b/579Q3O8T7Uxx9peuacdGHHwbbnrZM82rblt/L59/5r1RYHn7u6N/zjRd+b9rxH3nzSj64fTn/6/mTfHN/cc3eRURERESkeAp482j79u2k02n2798/41j/+nKM1yK5/+ZOo3R7PLz7N36XUFkZr335f1Cx1GbXk2fIZ6+s4vnWr8ezYsWMZZpXW1a5gc+991u04Od3zn6VTz31C1P2vTPG8Ifv2kzryjJ+44v7OHThxsOqiIiIiIhMTQFvHi1btoyamhpef/31GZuBW14X/o0VJA70kY9nbup+wWgJ7/mt/0wuk2G098vEB+IcfvnKSpoxhuiOhxl79VVyg4NFX7ckspS/ff93eA8R/nf3y3z8a+8nk598jl63xd9+uIWyoJef++xu+kdnXr0UEREREZHiKODNI2MM27dvp7e3l7Nnz844Pnx3LU7WpvuTe0genXmf3GQqlq3gh//DbzPSex7LeYZdT54ml8lffj3y8A7I5xn97vM3dF1PoIQ//OB3+FVTybeGj/CzX34ng6nJQ2JVxMenP9JK32ia/+/ze8jmZ+4HKCIiIiIiM1PAm2ebN28mEAgU1TLBtzJK7N834gp76P/MIYa+cQone+PhaNW2Zt7+k79Acvg4wxef49D3r6zi+TdvwlNbS/yZ4ss0LzHeAD/zY0/x567lHBy7wIf/7Z2cHZk8uG5ZVsKf/ehWXm8f4Cf/aad65ImIiIiIzAIFvHnm8XhoamriyJEjDA/PvCfNEwtR/UtNhN9Sy+jLF+j5VBvZ7hsPR40PP0bzo+8in97DK1/6KtnxVTxjDJGHH2b0lVfIx2+s7x4Abh+PfPBr/KN/HfHUIB/62nvZ3b170qHvblzKJ96zmX0dQ+z46xf586ePksjkbvyeIiIiIiICKODdFu666y4cx2H37smD0PWMx6L0XfVUfHQT+XiG7v/ZxuirXTPu47ve/T/+09Su3UZi4Ble/Px3Lj8fffQRyGa58Jv/8Yb24l3m8tD4+L/y+UgLZalRfvapn+Kbp7456dAPvWkl3/mN+3nn1ho+9fwpHvrL7/HkgRv/XkRERERERAHvtlBWVsbatWvZvXs3uVzxK1iB9eXEfq0ZX12Uoa+epP9zR8iPZYt+v2W5eO/v/C7eYDVtT/8dF0+3F667bRux3/kdxl5+mfYfeQ9jr81cPjqBy83y936Gf668j8Zkgo+/9HH+tu1vJw1u1RE/f/X+Rr74C3dTEvTyi5/fw0f+8XVO9oze+H1FRERERO5gCni3ie3btzM2Nsbhw4dv6H2uiJfKn9xMyQ/VkTo2QPcn95A6OVT0+72BII/+8scBF1/+r39IYqRQJlr+4x9h1b9+ASsQ4NxHP0rPJz+JcwPhEwDLRcm7/zd/t/SHeFd8lL/Z9zf87ku/M+UJm3etKucbv/xW/vBdm9jXOcQj//1F/tuTRxhNq2xTRERERKQYCni3idWrV1NRUVHUYSvXM5Yhcu8yqn+xEcvnou8fDzD8VDtOkadTNrQ0sGLrj5OKD/LVP/9jctnCKqB/40bqvvwlSt7zHvr/9n9z9iM/Tvb8+RubnGXheedf88erH+eXB4f4xulv8vPP/jzD6cn3G7pdFj/xllU8/xsP8J6mpfzdi6d58C9f4Ov7LqhsU0RERERkBgp4twnLsrjrrrvo7OzkwoULM79hEt6lYar/fROhu5YQf6GTnr/dR64vWdR77//QfXhCj9B1/AjPfvp/Xg5TVihE7X/9BLV/8Rekjx/n9I+8h5GnnrqxiRmDefRP+PlNP8Wf9PSxr3s3H37yQ3SMdEz5lsqwjz9/3za+/P+9haqIj1/5l7382N+/xvHumzj4RURERETkDqGAdxtpbGzE4/Hc1CreJZbXRdm/W0P5hzaQ60/R/T/2Mra7e8bVr+qVURrueiu+yD0cfvG7vP7VL17zesk7f4i6r34Fb10d53/tP9D1e7+PnSwuPAJgDDz0B/xQ67/nHy5cZGjkPB968sfY27N32re1rCzja790D3/8I5s53DXCo5/8Pv/lm4eJp4rfa7io2DacexW+/dvwD++Aw1+f7xmJiIiIyG1EAe824vf72bZtGwcOHCCRSLyhawW3VBL71WY8S0MMfvE4A184hp2afi/b9h+uA9ddVK1q5aUvfJbnP/Ppy3vyALzLl7Pq8/9Mxc/+LENf+hLtP/o+UseOFT8pY+Btv0PzW/8j/9xxjmgmyc88/TN85uBnGMtO3erBZRk+/OaVPP8bD/B46zL+z8vtvP0vv8dX9nbeGWWbl0Pdb8Ffb4L/swN2/SOMXoQnPgLf/URhjIiIiIjc8cxC+wdya2urs2vXrvmexpzp7u7mb//2b3nooYe455573vD1HNsh/kIHI8+dxVXio/wD6/GtjE45/qlPH+DsoR5WrDvEkRefw+P3s/3dP0rzY+/C4/NfHjf2yiuc/63fwh4eofq3/iNlP/ZjGGOKn9gr/4uh536P3161npedUSLeCO9f934+tOFDVAYqp33rvo4hfv9rB9nXOcz2VeX84bs3saFm6u9pQbJt6HgNDn+1sEoXvwAuHzQ8BJt+BNY+Ai4vfOtj0PZ5WPcYvOfvwL/Ifh1EREREZAJjzG7HcVonfU0B7/bzmc98hsHBQX71V38Vy5qdRdb0uREGvnCM/FCK6NtXEHnbCoxrYiDrPz/KF/74dZp3rGRtq4fv/8v/5dSu1wiXlXP3+z7E5gcewnK5AMgNDHDh4x9n7HsvEn7wQWr++L/gLisrflKv/z08+Rvsr1jBZ5as5LnEOdyWm3fVv4uf2PQT1JXUTflW23Z4YlcHf/rUUUZSOT7y5pX8h3espSTgueFfm9uGbUPHq3Doq3Dk6xDvKoS6Ne+AjT8Ca3dMDHCOA6/9HTz9O1DRAB/8F6ion4/Zi4iIiMgtooC3wBw+fJgnnniCD3zgA6xfv37Wrmuncgx99SSJtl68q6KUf2Ad7lL/hHHP/MNB2g/089jPb2FJQwndp4/y4uf/ia7jRylfupx7f+yj1LdsxxiD4zgMfvazdP/FX+IuL6f2z/+M0PbtxU/q+DPwg/8J7S9y1uvjsys28jVnhIyd423L38ZPbv5JGqsbp3z7UCLDXzxzjM+/do6KkJffemQ9721ehmXdwGrifLLzhfLLSyt1oxdnDnWTOf09+OJPgGPDj/6fwkqfiIiIiCxKCngLTD6f55Of/CRVVVV85CMfmfXrj+3tYeirJ8FA2b9bQ3Br1TWvD14c40t/sotMKo/lMsRWRVnSUIKxT3H4xS8zdPECS9dv5L4P/SS1azcAkDx0iAu//htkzp6l8v/7BSp/8Rcxbnfxk+o7Cbv/Cdr+H/3pIf4ltpwvBL0M22maqpv4yU0/yf3L78cyk69oHjw/zO997SB7zw3RvKKUP3r3ZjYvLbnpX6M5dSnUHfpKYaVutBvc/vHyy/cUQp0vcuPXHTwDX/gQ9ByGh/4A3vIrhX2PIiIiIrKoKOAtQC+++CLf/e53+eVf/mUqK6ffk3Yzcv1J+r9wjGxHnGBrjNIfrsfyuS6/nk7m6Do5xIUThY+es3Ec2wFjEwidYLT3RbKpOKtb3sz9H/4o5bXLsMfGuPjHn2D4K18h0NTE0r/4czxLl97YxLIpOPIN2P1PJM69wleiUT5bUcUFJ0NdSR0f3fRR3rn6nXhd3glvtW2HL+3p5E+/fZTBRIYPvWklv/7wWkqDE8e+EZmcTd9o+vJHbzxN32iG3nia3tE0bsvwy29rYE3sqpBm5+HcD66UX14KdVev1N1MqJswuTH46i8WVgS3vA/e9T/BE3jj1xURERGR24YC3gI0OjrKX/3VX3HXXXfx6KOPzsk9nLzNyHPniL/QgbsiQPkH1uFdNnnIyKRyXDw9zIXjhcB3sb2P7NhucqmdQI7q1XfT8kOPs7ppJenvPs3FP/gDcLmo+aM/IvrIjpubYO8x2P0Zcm3/j2ddGf6popIjLqj0l/OhjR/h8XWPE/VOLF8cTmb562eP89kfnKE06OU/7ljH463Lpy3bzOZtBsauhLRCaLs6vKUuh7jh5OQtGiJ+N1VhH72jaZKZPD9zzwp+taGPwIlvFELraDe4A4VQt+lHYM0O8IVv7tdmOo4D3/9L+O4fQ81WeP/noXT57N9HRGQRcLJZxn7wA0ZfegnvypWE770X74oV8z0tEZFpKeAtUF/+8pc5fvw4H/vYx/D5fHN2n9SpIQb/9Rj5sSwlO1YRvmcpZoY9bNlMnu7Tw7Qf6ODoi19npGcn4MLlb6G67n5qlwXxPv9FQvu/Q/V7HiP28d/GCtzkSlI2CYe/hrPr//BqbxufKS3llYCPoMvH+9a9nw9v/AhLQksmvO3whRH+89cPsvPMINuWlfDB7SsYSmavC2+FADcwlpn01mGfm8qwl6qIj8qwb4pHL5VhH36PC7Iphk+8zKHnPsua/uepMsPkXX6sdTswG38E1jw8N6FuMseegi//DLh98P7Pwcq33Jr7iojc5pxcjrFXX2PkqW8Tf/Y57OFhjMeDky38AM+zYgXhe+4hdM89hN60HSsUmucZi4hcSwFvgero6OAf//Ef+aEf+iHuuuuuOb2Xncgy+OUTJA/142sopfzxdbiixZc29nV08t3P/B86Dr6OyxPC5X8zxrUZY1yExrood3qo/9EHWPnWdQQjXrCdQsmnA1bIM2OgvKz7MOz+DEcPPcFnghZPhUIYY/HYynfwE9t+jrVlawHIj46SPn6c1JGjHH15D337D2FlM5yLxLhQWsNwbBnppauwli6lsiRAZfja4FY9/hjwuiafh23D0JnCfHoOQ/dB6D6M038K23FwefwMLnuAv+3dyuf619G6Zhl/9O7N1FXe2D8SEtkEvcleehO99CX7Cp8ne+lL9DGSGaG+tJ5tVdvYVrWNikDFxAv0HocvfLCwP+/RP4O7fvqG7r/o2HkY7oR0vHDaqMpXZRGx8zaJkSz+kBv3VP/vuoM5uRyJnTsZ+fZTxJ95hvzQEFYoRPjBtxN99FFCb30rua4uRl96ibGXXmbstddwEgnweAg2NxO6562E770X37p1N9YWSERkDijgLVCO4/DpT3+aXC7HL/7iL875XyiO4zC28yLD3zgNbgt3ZQBsp/DhjAcyuzCOCZ87ODY4+Tz5bBZsMMaa8lCUq7ljQUoeq8O/tqz47zGTgENf4fyuv+ffLp7h8FiQml5oHopQN+DD6uq9PNQqKcG7di0Zlwdztp18V9fl14zXi3f1anwNDfga6vE1NOCtr8e7YgVmvB0EY33QfWg8yI0/9hyFq5qzx4P1HEmt5vAFw+BwmvqWu9jy0GMs3bSVz7/eyV89c5x0zubn7lvNLz5QT5axK4HtqvDWlxh/TPbRk+ghkZvY8N5tuakMVBL2hDkzcoacXWhgvzyynMaqRhqrG9lWtY2G0gZclguSQ4WVvJPPQstH4dE/B/fs7ku8reRzMHwOBk7DQHvhsf9U4XHwDNjjJbbGgvLVUL2x8BEbfyxfDZb+cbzY2YkEY6++SurgIQLbthLcvv3mqwzmmG07JOMZEsMZxobSjA2nxx8z13yejGfAAV/Qzfq7a9h831JKY8H5nv4bMtxzkfPHjrBqaxPBktIbfr+Tz5PYtZuRbz9J/JlnyQ8MYAWDhN/+dqKPPkLonnuwpqiQsTMZknv2MvbS9xl96WXSR48C4KqqJPzW8dW9t77lxtoDyW0vn8vRe+Y04fIKwuWT/OB0AUmNZjlzsI/2tj6GexPUNVax/s01lFTdnv+vkxujgLeA7d27l6997Wv8xE/8BHV1U/eFm03ZngQjz57FTucLhzBaBozBWOOfW6YQxCwDhsLqm2UKj+Pjh3sv0nH4AGPDQ4TKS1m2diOZvUcZGUiTrlhBwl1CNutgGVjtdxE0kIx6oWUJZZsqKFsSxOW+NhzmR8dIHz9O+thRUseOkT56jPTx49iJQghyjMPFMsPpmCFdG2bLW97D9rf9OL6a2muCY350jMzpU6RPnCR96hTpkydInzxJ7sJVwc9t4S334Asn8YVG8Zbk8EWzeKtLMUs2QmwT2bK1nOw2HNp/knOHDuI4NpUN9QRrq7mwu43cWBITDZDdUMH5VYY9oxcZTPdjeeJgchN+3QPuAJWBSqoCVYXHYNXlr6sCVVQGC5+X+EouB+dULsXh/sPs691HW08bbb1tDKQGAAh5Qmyp3MK2qm00Vm5l65GniL7yKVj+5kLJZrh6dn/j3Eq5DAydg4Hx4Hb1x9A5sK/69fUEC6GtvG78cTV4w9B3fDywHym8j/H/F7r9ULXuSvC7FP4iNTqVdIHLdJ5n9HsvMPrC90i89hpO5kpptvH5CL5pO+H77id8/314l8/9vlXHdkiNZcdD2rVhbWwoTWL860Q8W/gB29UMBCJeQiVeQqU+QlEvwVIfwYiXrpNDnNrTi207LN9Yzpb7l7JyS+WCaR/jOA7nDuxj79Pf4NTu18FxsFxuGrbfzbaHHmH5xi2YaXrEOrZNcvduRr79FCPPPEO+rw8TCBB52wNEHnmE8H33YfkntgiaSba7h7GXX2bspZcYe+UV8kNDYAz+zZsJ31sIfIGtW2c8QXrgQieJoSFcHk/hw+3G5b7qc4+n8LXbPe33ORfyOZt0Ikc6kS08JgufZxI5UokcmUuvJXPj4wpjcBxWbKxgdVMVtWtLcblu7bzfCDufp7v9JB2HDtBxaD/njx4mm05hjMWKLdvYdN/badh+Nx7fjf+emQ8jfUlOt/Vyel8fF08N4dgQLPESrQxw8fQwOFC7ppT1d9dQ31yF138DJ57LbUUBbwHLZrP81V/9FatWreL973//fE/nhth2nsMvPs/LT/wzo/191DW1sjVUTvbT/4CrohL/b32CQe8y+s6N4DkzzLJUDg/QkXU4ms7jCzlEzQjheAf+84cJtLfhzQwXMmQ0in/tWnzr1+Nfvw7funX4lteQPfE1vr7v7/m/DHHW42G58fMTa36Ud7f+Cv5L5Xh2vrCSM74aZ188SKL3MPG+DuIjLpIjHnIjXhgN4h4E79CVsJBzW5xbGqWjLMwYXnAMKV+e48vinFg2RjxUGGvZsLw7yJrOMEt7/YBhrNbL0JpyXiNE72iATdVL+Zm7G9m0ZBlVgSpCntAbXqV1HIfO0U7aetrY17uPfb37OD54HNuxAaj3V9HYd45t+Nj2jj9l1ZrHplxlHRpIsvPZ0+SODRIwhlDUR2lZgIqKAO6gG8vvxgq4MX43lt+F5XdjAoXnjdcq6nuxbYfec3E6jw7QeXQQyzLUt1SzurEKv3f8v9P1AW7gNAx3FHr+XeKNQMXqKwHu6o9wbOZglklA37ErJbc9hwufj168MsZfOh74Noyv9m0qfB4onfH7vCm2DckBGO2BsR4Y7YWx3qs+7yl8PdoLiX6IxCC2ufCxZPyxdCXc4n8g3k6cXI7kvn2MvvACoy+8QPrESQC8q1YRvv9+wm97AP/mzST3tjH64ouMfu97ZM+dK4ypqyN8332E77+PQGsrlneaVW/bhlyysF84m4BsEjs9RmIwSbw/SXwwQ3zYZowYYyl/IcgNp0kMZ7DzE/8O9oc9hEp8hEq9hEp8BEu841/7Lj8fiHon/Ue0bTsYA4mRDIdfusCh719gbChNuNzH5vuWsvGttQQit+cKfiaZ4NCL36XtqW8ycKGTQLSErQ8+Ql1jC8dfe5nD3/sOqbFRSpfUsPXBR9h0/4OXV/Uc2ybZ1lYov3zqKXK9vRi/n/D99xN9dDzUBadfzUxkEwTcgaL+3+Xk86QOHSqUc37/JZL79oFtY0UihO6+m9C99xC+5x48NTUAxPv7OPry9zjy0gv0nm0v+tfEcrmmDH+XP5/iNXDh9lWwfOO95HIWmatD2XhIuxLcCoEul7WnnY/LbeELui9/eAMefEE3uUyejiMD5DI2vqCbuq2VrG6qYvmG8tuuXNi28/Seaafj0H46Dh+g88ghMsnCD4ojNUvILYtwLjpMaAQiJ8bID43hDQRY++Z72Hjf21m2ftMbDt6O43Dw/Ahf3tPJsYtx8o5D3i582JN8bjuQs21sm8JrjoM9/pjPO1RkYEXKsDpjUZUvzK3XsjnhyXPSk6fb5eD1WLyzvpp7PAESx4YZ7k3i9rloaK5iw1tqqGkoVenxAqOAt8A9++yzvPLKK/zar/0aJSW3aW+3aWQzafZ++xu8/tUvkk4mWL+1mRUvvob7XAeVv/ALhO+7l9TRY4wdOUWqtwJveB0A54d7OZaxGPNdKX/xeqGiJkjl6nIql4WpWBqmvDaE57q/QPLn9/DCq3/B/xnYy36vmzLH8GZvJYnUEPFcgrhxGLUsRo3FqGXhTPP/NH/aYV2Xj7Xno4RH/DiOC8u2qR0aZelAnPKxFLbHRbq2nOzKGli9gsC2bZQ33kVV1UoyQyMcfP45Dr7wLPG+XvzhCHZ9C18YrqHPU84vPtDAz9+/unBIyxwYy45xsO/g5RW+/d17GckVyktLXAG2Lmm9XNa5IbCeU6/0MrK3hxXxHB4MfZbDkAWenE0YQxiDjxn+ErAoBL0J4c9Fxob4SIbBgRR9PUlSmTxZB1yBQbKpNMlsCca4Weo9yCr/q6zw7sFrJcAfxpSthPKVUFGHqVhd2EdXvhqCFXOzupYYGA98R66s9vUchvTIlTHRpYWgd/VqX+U68Ezy0958djyU9RRKf8d6xj/vvfJ46fNE37Uh9vKvrQdCVRCqLKzChqohWF7YW9h9CPpPcnk10huG2Kbxj/HQF9s4Oy05ZslIKsuZvjHa+8Y43Vt4bO8bYyydY3VVmDWxMGuqw6ypjlBfHSLonf6nzfnhYUa//xKjL7zA2Pe/T354GNxugq2thB+4n/D99+Mbr4Zw4j0M7XuWiN/B7aQgmyTTeZHRfe2MHuwkcbIPJ+9gPBahuiDhVV7Cyx08/gz5TIbRpI94Kkw8U0o8X0XcriKeryaer2I0X4GN55q5+UyckC9JqCxEqLaWYFVpIbCNr8IFS7yEoj5cnuL/8ZjM5NnbMcjO9kF2nhlgz7lBKsM+PvqWVbyvdRkhj4v2/X0ceOE8548NYrkNDc3VbHlgGbG66G3xD7qBC+dpe+abHHrhO2SSCZbUr6HpkR9m7d334nK5SYxk8Ec8OPkcx197mf3PPcX5o4ewXG5Wr93AqoxD4JXXyF+8iPF6Cd9/H5FHHiHywAPTHo6Sy+fZffEg3z33Aq92fZ/T8WMsD6/k3Q0/zDvr38nScPFtfvLDw4z94FVGX/o+Yy+9TO7iRbIui941dXRVlNA9OgzAkoa1bLjnASqWrSCfy5LPZsnncuOPV31+/dc38FomlSGdSJNNZ8BJggnh9r8Jl28LxnLhC1wKaB68ATf+oBtv0D3+vOeq8ObGHyqMufSce5q/p7KZPB2HBzjd1suZ/X2kEzncPhcrN1VQ31TFys0VeAO3frXIsW36Os/RcXAf5w4d4PyRg6TGRgGIxmKYleWcLxvjVfcxOp0eoLDlIZFN0J/sJzbgY0NXGSu6/FhZB195KVvuf5CtD+ygbEntDc2lJ57ia3sv8KXdnRzrjuN3OWyrCWM8hR/YWMbgsgwuY7DGH12u8UfLjL8OLsA/lCPYk8HXk8aVsnGAfIUXp8aPvTSIK+LBZXH5Op2DSb7Wdp6RVI7lZQHeX1dNXRzOH+gnm8oTrfSz/u4a1r15CdGKIks4bbuw7SGfhXymUD1j58FfAt6FXR6+EMxbwDPGPAJ8ksLvxX9wHOdPrnvdB3wWaAH6gfc7jnNmumveiQFvcHCQT37yk9x77708+OCD8z2dm5aMj/DaV79I21PfAGNYGyxh2Us78diFf8Ra4XBhJW7NVghuIz8QxAq6Cdy7jERNiIGLCfrOj9LfOUr/hTFy6XzhwgZKqgJULg1TMR76KpaGiVb4IRNn72uf5J9OfYWTpIm4/IQ9EcKBMiKhGOFILRF/ORFvhLAnTNgbJuKJEPaG8eYs+vce4cwrr3LxxDEwhpVbGi+Xa1jZfKHU8+Qp0idPkj55gszJU2QvXBifl8HX0ECgcRuBbdvwbdnCxeQoB194jpOv/wA7nyNVtoyXXfWklm/l997TxNvWzX3ZpO3YnLm4l31PfYy2sXMci6xiyVA998abaR7dgAc33a5RTlSmWPameu5+0yZcLhc9IylePzPAq6d72HOmi4u9g4StHKUum7WlHlZGPdT4PJS6DK6sDSkbk3ZwJV34Ej78aS++vBcvBs8s/KPSMVwuITYuA5Z1uYz4mrLh8Y+c45C2HdJ5mywQiHoprQjii3ixgh6skLvwGHRjhTyFzwPuiQcAOQ6MnL92ta/ncKGtR3685M9YUF4PFQ2FA10urbYlByf/ZjzB8dBWNR7arvv86ucCZdOH2UwCeo/AxYOFwNd9sPCRGr4ypmzVdat9m6B01Zyt9qWyec72J2jvG6W979JjIcj1jV5VJmlgWVmAusowIa+LU72FcdmrVrmWlQVYUx2mYTz0NVSHWDnaAz94qVB6uXcv5PO4yssLK3APPEDorW/BFYkU/tv1nSB76BscefE5dp9IM5AJYmFT7ktS7R+lyjdGdSBFadhNlhp6+2P091cwHC8hYZWR8peTClaQdpdc99/BIRTME4nYRKIQKbWIlHmIlPuIVAQIeSw8F1/EHHkC070fMLDqHtjyo7DhXYWQXoThRJZdZwd4/cwAO9sHOHB+mGy+sGq3fkmU1hWlHOkaYde5IcI+N4+3Luejb1nFioogA11jHPzeeY6+2kU2ladyeZgt9y9jzfbYhB+SzTXHtmlv283ep77BmX17sFxu1t19D02P/DDB0hWFVf2DF+k82k8q7cYYh3CJi2h1lKArRf7cHvrPvEK/GSbnMgSNi1jDVnzv+FHGQuWMJLOMpHLjj1lGkjlGUlmGU2MM2odIeg5g+w9jeeI4jiGfXEE+sRpX4AzuUGGFbVlgI4/VvZMPb34XZYHifriay2Q4ted1Dj/9JGeOHMR2bELpLEuGxyh1XLg3byWzdg2uVXX4Y9W43W48Hg9ut/vyx3Rfu1yuSUN5Pmdzuq2XAy900nVyGLfHYu2bllBSOcihF75MT/tRIpXVvPV9H2LDfQ9gzfE+43ze5sKxIU619XK6rZfkSAbLbVi+oZzVjVXUbaskEJ6blWTHcRg431lYoRtfpUvGCz+Ui1ZV46tbQndlht2+UxxKF1b1qz1VPBp8kDeZJuqStXj6HJycTdadZ4Q4ffYg3ZlukiODBOI2gVGbnJ0hU+qidN0qNr3pXqqrl2L5XFh+F8bnwoyvsKfSGb7//TaOPf881qkDrBi7yNLUMKF4Anuk8O8YX2kWf3kef7mNvxJ85QbL5wHLPf7hIuOEODu2ifb4Js7G15LJ+3FbWZaXnKWu4jSrKjoI+PKFPeSWG8e46DcO50yWs06aMcdmPQHKRuBiX5yh0QQe8lQF/eTtDXQOb+b8yEoAloZPs6F0F6sjbXicRCHAXQpydu7K15P9EPIST7Dww9dg+fhj5fjj+HOhShxfGY4rjG2FsPHjpDPYqRR2MomTSmEnU9jJBE4qRS6RYmjQpnfITd+Yj8F0CI+VpzySo6LcUFXrp3xZFE95Ga7SUlylpVih4MQ/L7Zd+CFtcnDiR2qocG7B9c9XroH3//Os/j6dDfMS8IwxLuA48A6gE9gJfNBxnMNXjflFYKvjOL9gjPkA8B7HcaatQ7wTAx7Av/zLv9DR0cHHPvYx3DPU99/uRnp7ePlfP8fhl17A5/WxalUDVes2UL1pMxXLVhCpqMQYQ+b8KMNPniZ9ahh3hZ/oI3UENldgjMGxHUb6k/R3jhVC33jwG+5LXl688PhcVCwNXQ585bUhSmNBglHvlD+1tvN5zuzbw6EXv8upXa+Sz2apWLaCjfe9nQ33PkCkfOam8/nhYZL7D5Dct6/wsX8/9nDhH9dWOIx/y2bMxg10eCxOnDlBf9d5cpaHY8F6Ilvfwm/++CMsK5v4k69sNktXVxednZ10dHTQ09NDJBKhqqqKqqoqKisrqaqqIhwOz/hTeTuVY7jtIiPPvoRrrBrw0GNS7Cm9wIEl+3jV9TKJfKFkpcJfQdATZCw7xlh2jHQ+Pe21vTk/NSMNLB9ez7KRdZQmqnHsFFnOknGfwGQ7cY0m8ODDa/nx+byEKkqI1q4k7w8xONLHaHwYJ50jlAkSzPrx5d0YJ4/BxmCwjIWhUAZqYWGMhcvlweP1Ybl9OJYb23jIOS4yjotM3pDHBabw4TYuwsZFKYYSLKb8E2XAClwV/K5+DF353BVyY/ktrPR5rPhRTP/4it/gGfBFIVxVWGkLVV35PFxdWIULVd9w6wzHthnq7qL3bDtnThznbOd5wiWlNGzZSsOmLZSUlmJdHdYc58oKX/eBwuPFg4U9jJf+gn6Dq325vM35oSSn+8Zo7x3jTP+VVbkLw0mu/qumKuKjrjLE6soQdZUhVo1/vrw8OGElO5u3OTeQ4ET3KCd74pzoGeX0hUGCh/fTdOEQ2y8epiZR2Hd6sXoFA1vuwvWWe1n65mYalpRQ5reg4zU49iSJA0/T1p6mbbCGZN5LRVmYZRvuZmQkw2DvRUYHu8hlrlqdNREsdxXGVYXLHSNcEiNkufANXcB94ST+RC9BK0X55tVU3tdKyf334K6qwnEccn1JMu0jpM8Mk24fJj9Y+HNjvBaukMFl+nElT+DKnMFlDeKqWYpr/Ztwbbkfq6Ls8g8WukdSvN4+wM4zA7zePsCx7jiOAx6XYevSKC0xD3XBFN5EP33dF+kbGCCXz+P2eEnbFsMZyGIRDQVZWRWlpjyC2+VhtC9L37kEqSEbj9fD8rVVrGmsoXxJFK/Xi8/nw+v14vV6L/9ecvIOdjKLnchhJ7LggKvEh6vEV/ghSxFSY6MceuE52p7+FkPdXYTKytl038OU1m6nryNP59EBRvoLv1Yhq59l3v1EvRfIjPoZHKthOB8j6akk4ysZ/62dxc6cIJvZD7kLOFiM+OrpCG2iw19LNujCjsYhepSc7xBjrqM45HATYJm/ibWR7WwpfxNLwpX4PRbHLsZ55cwJ9g09TyawE5evFxwXJc42Wisf4t1rH6R1ZRUR/5XVWdvOc+7gfva/+DwnD+wjYzu4o6WEapZhgiHGEknio6NF/foUw+Px4Ha5cLsMLgpbkjNJC8d24bYcSnxjlHr68TmjeC2HYKSUlCnhTHsfI719lFVWcve7/h0b33IfLtfcB3vbdug+PVwIe3t7ifenMKawD2x1UxWrG6sIl938/jbHcRi6eIGOQwc4d2g/nYcPMDZU+GFapKKSSMMKBqocDgQ7eD2xH0/WxbpMHfd53sSW3HqWxMtw9ecv/9vBCrrx1IYxXhdOKoedyeOk8tjpHHY6D5npy1gvz8vO4uSSkE3hZFOFz3MpnFwKy0rh8uZxhd04Jk+29yKZzk7yw/046REgjy8Wxlm2hL7yLXS51tKVrMV2XPg9SerKz1BXdoql0dOMmiTn7DRnyXDWyXDO5Mc/HLKOF3/ejz/vx2N7yJs8FnlWOjnW2g6r0nmWjOXx5BxclotgYAlDmVZO9W9iJBXF48rQsKSTDcvPsaR8BOP2FKpIXO7xRw923pAdSpHpHSPbFyfbFyc/OoqTGMNOjQe1VAY7k8PJ5LGzDk7eYOcMjj1Nf2J3iOHoKoZLVjMcrSMeXUXeVTgQyZcZJpzsIIeP0dAy8u7CiqNlZwmPnicSP1f4SHQQtLtx+2zcPhuPO4fHk8btzePyOri8Ni6ffeXRZ+MKBTChssIPUwOlhcfYZnjgt2769+hcma+AdzfwB47j7Bj/+uMAjuP8t6vGPD0+5gfGGDdwEahyppnUnRrwTp06xec+9zne8573sG3btpu6huM45HI5stksmUxmwuP1zxljLn9YljXp4xt5bejiBQ489xQ9Z06RHhnG2DbYeXyBABVLV1C+bDkVS1dQ6arFd9hg92fwroxS8lgdvpUTG5wDZNN5Bi6M0X9+9Mpq3/lR0okr++i8fhelsSClS4KUxYKUxkLY+V46D73MsR+8SGJ4CH8kyoa33s/G+95ObHXDGypjchyHzJkzVwLfvn2kjx2HfB4HGK1bSWdNBWcSozhOniFPKRUt9/Hef7eD4Xicjo4Ozp3roLv7Ivb4aqffHcJvouRMmlQuTu7SyZCAz+enqqpyQvCL+sOkDg/Q9XoXnnNxXA50YzPgPcs95m9wlyTwfOgLENtI3s5zcugkbT1t7O/bT87OEfaECXlCBD3By5+HPCECJoh90cfwKYeLx1Kku7OQHyCbu0DS7sSbO4c1XhJqcKgKJKmtKaN2cwu197yH6Ir1k/76DqQGONB7gP19+9nffYD+k0mWXtzAqv51eHMOWWuYRGkfqUCWsayL5HCSfCJOMJ8kkE8SsFP47TRuZ+KBNgDucAm5SCW9rlI6M2ESrnIcdxmV4RK2VoRYWxJgZcBHpcuFSeUK/6gdu/KPW2eavSrG58IKFspSPdXByx/u6iDuCv/ln+wWI51I0Huund6z7fSdPUPP2XYudl8k7QuRi5Rh+yeW0lhANBIhVltDZWUV5eXlVFRUUFFRce0PAG5wtc+JbaI/vJYTmQra+5PXrMSdG0hcs9IW8bsvB7i6yjB1VSHqKkKsqgxe849jKPwZSSaTjIyMMDIyQjweJ5PJEAgECAQCBINBPMkkzp49ZF56ieQrPygcX+/zkdzSwrm1Teyu2cC+tI+TPaNYmTj3Wgd4yLWbB11t5FI2r/Sv5WQ8iuM4BErWYHlayOVqLv9auDwWkXI/gWgel9WPne0hPdbF6MB5Rvou4Iz/2fMGglStrKOydhnRTI7g2Q7cr+3GZLy4KtbirWvBKlkFduF7tEIefHVRvCujYEN+JE1+JEN+ePxxJA3X/VZysEm7c5x3XFzMZhnNJcnlhvF4h7FdI6StJGNWnqTLjXMpyNs2VjqBK5XA5PM4loXHcuF2ecm7PCQcFzmXG8vjwu2xsG0bh+L+/vfgwoMbj+0qfO4UvvY5HsL4CTt+osEw0ZISSstL8VeEcZX6cJf5xx999Hd1sPfpb3L4+8+TS6epWL6GsqV3kxhZykBXIdB5TJpY7iDV6YNEE+30xG0GU2EqxkapHu3Htgz52hCVy4coXzJMwlVFj1lLl7+VYc86hhNuRi/uIzV0AJwUxirF5duCy7uJlNcmHYwTrvCxrDbGmhUrKasKE6n0Eyn3TzjUy3EczvaP8c1jO3n23JOcSb2MY0YJpirwxzey1FlHveUlmOwnmxol73JPOH03EolQXl5OWVnZNR/hVJr0a68y8tJLxPe2kc/nsSNhvJvX412/Cs+KCmyTIpeIk0uOkEuNkk0nyKVT5DIpstkMw/lKenMriduV2MbB7xok6BrA7cqStbykjJckFjnbwrav/fN21TeJx2MRikQIhsKEQ2HC4cJjMBgkFApd8xgMBt/wD5gdx6GvY5TTbb2c2tvLYFfh74bqVVHqx8Pe9Se/2pkMqUOHSO7ZS+rwYXBZJL0eenJpuhNxLg4PkEglAQgGQ1SsWEa62suJSB/70+2UZMqoTy2nyd5EQ3oFkdErYdKKePEuDeOpDY0/hrFKvNi2jWVZ1/ygzLFtct3dpE+dInNoH5n206Q7u+kbSdHvjjASKcVy+/E7bkoz4LMMxufF8ocIBEqJhCuxfFEc/DhZBzuVh9zkf4/kyZPM2yRsFykHcukxPPFOvLlOUpE+2iszHCkb5bh/jBTgzxVCXCAfIOpECdgBXBkXRf4RL3x/OOQw5BwXLreXsNeLN+8iM2ZD3sLrcVMSNJRYCbxjI1jDo1jDcazRJG7Hhce4cePB4wni8/jwunx43X68Li/G48O4vRi3F1yewv93jTVeBGEAQ952kXO85GwPtuPGwV0owAGMsTHGwcLg5sqfs6zJMuAaZNiMksjnyOZc5DMB8rlS0rbn/2/vzoMkye7Dvn9f3nVX9X1OHzM7Ozsze83u4j5IggQB8JKoJQXRpBgKWqRsMsKKsB2mHLZFU1aEpQjZDocZpsggIkDxAggTAggQFCEudgEQwB7A3rM7d0/fZ1XXXXk+/1HVPT3nzl4zuz2/z0RGZr3Mqc6qfJWZv3wX7QRCHWKGS7jteXKNeUqVeQYrKzjx9a/hvmvTyXj4mRRhJkN0cJZP/Lv/5+a/zFvkdgV4jwKf0Fr/l73XvwS8V2v9G3u2eam3zWLv9bneNpvXe987NcBLkoTf+Z3fwbIs3ve+9103KLtRwBYEAe+GNpcKMNDoOIYohCRBJQkZM0vJHsDVDnhgj3nkh/vJlUo4Tvdps23bu0+dd5Zt2yZoahpbAdtrbbbXWmyvtSgvbVDbeJ44OImONwADJ3OI/slHGDtyP/2j+d0gMFN039K2Kkmr1b1g9QK+6ouvMG9lmB8fplzKEGRSaLtXfUUrrCCHHeZ3p0wmQ6bo4jcjGtUOkfaJrRax1SLqzWO7TaIuVX8ztUFRZ0glaSraIxkZ5JH3HuQDE0U4+13iL/0mcaNDfPQfE6eniLe3u1O1CmHUrY6mFFoZ1FSBDT3Mph5kM8kRRpvoaBkzvkgUrRH3gioniRiIWxSTgCR0qEZ5NnWJtOcwkPcYzKcYyntkXatblTLR6CBAhyFRx6fZaNFqdfBbPn7HJ/IbxFFAJzdDs3gftcK9aNPB8SsMrf+AkfVnyNXnL2shGCtFYBkElklgmgSWSce28MdHaQ0NUK1X8VuXhrxITIeaW2JVFag4RepuHwMTkxy9e4aHZgc5caDEUN5DhzFxKyJpBDRWW9RXmrTWW/jlDmEtIGlF2FqTswxSe3fIVFj9KeyhFNZlgZ9LtbLBxsULbFyc680vUNtYQwOJl0b3DRMXSgR0bzrGhoc4ft/9HDt+HL/V5ORT3+P8Ky+ztrpKbFpoN03iuJdd423HIV8oks4VcbMFDC9L4mbxjTSN2KTeDjHqSxRqpxlonWa0c56p8DwTehmz9051neIVfYDTTLGROUyn7yjO+DEmh/p3g7q+TLekPIoi6vU69Xp9N3i71jyO45v78WiNqxSpVIpMqUQ6k+kGgkZMujmPu/UqyeYqvl9gtdPPat0nbi13f0fOMfAeZMspse2C0eeQH8mQG/DIF11KGYdCyqGQsimme1PKwdQh5cUF1ufOs3HxPBsX5ohWWpSMIQa9SQa8cRyje9MYRDX8jVOo9VOYnRVSDx8h95GPkPnQBzFcl6hcIa5UiLcrhFtlluZWWJlbo1lu4gU+WdMGN0sjnaXh2dQdqFo+VdVGq+7372iL/iRHKUlRiCzyIeS0xnI0TsYkiEKatRZ+AIlysA0Px0zhKQ/X8LCtFCiDmISAiFDFhMSEveW2DvGJie0I7WliVxHbEBq97XVEkES0/TaNVvOqQNHTNhndDfyy2iWjPdxYYUYhRmQSJyU6ZGnHEUZtgdTmSQqbL5FrzGP0SpQD0ybMFfAG+ylMjpP7kR8m+7GPdYck0Lrb2dKFJ+DCN+HCN2m0y3wn5fFEaYjvmBb9i1nuXsjTVwMMg+zQUQr97yEMRmhU/Ms6t1EKMiWXfL9H3wGPzIjCyobU6lUqlQqVSoVypUytWrvsc5IkqNCnEytqVgl3ZIrpiVHuOzjOw4cnyaZ6wy/49cuHaylfgPoyNDdItrdonq/SWLRoLHtEHRPQpPpDsmMdstM27kQJlR0k9EY4s30/LywcZms7g+smHLnX5PD7csxnqjxZPsezGy/wavlFqmH50ufTCjd2cRIHN3bxIpexco6JrTw2Dq2UoplRGIaDEzu4iYu6TjvrxEzQjkY5CsMxMF0Ty7NwXAfP9kjZqd0pbadJO2nSdhrLtK75sLdVDVg9X2P1XI3ttTZoRaHPZSjv018/jXPmWcK5BXQUsZ1y2SplqKQ82raNVgZWAtkgJBPEZHBwvBJJuo8kXSRJ5Yltl5iYmIQwaRMnbSIdEKuI2EiITUVsGMTKIFKKGIj23CdZWmMlEVYQYvkBZhhhRyFWFGFFEa4KcK0YyzVpWQ6LiUMj1rh+GyOOaWcSzg6UuThSo5PSHOo/xAPDD/Dg0IM8OPQgA24/USNk/ZUyF59fYmNui9jvoM2A2OkQmm1CHRCR0FYhLeXTIbhmvwEuJhnLI5vJkcsXyOVz5Ep58gNF8qUCnucRRRGBH+C3OjRqNRY2F1jdXqFc3cKvN/ACAy+0sBMHQ5soDLRSRIZBZECkku5EvHs+uhl2LwB0sHCU1QsGLSxtYsYmKjYwExNTW5gYJGaMr9r4douO3SBWBjp2ILJxY4t+w2LUA1elUHEWK0zhRA6pyMS4Iu92SGjpBD9SdLqtR2jomHWrxpq5xroxR0fPYYSL5IIOuU5ArhOT62iybci1NevFHL/yxadu+vPeKu/6AE8p9avArwIcOHDgoYsXL74t+/xO9/TTT/PVr371qvS9gcy1gptrzV9rnWV1T8ZJkqC1vu78rVgXhuF1g9N2q0WrXqPdbNLpdAiDsFukr0wiYpLXcYIxTZNcLoejIKhu09pYRYU+xUI/IweOURy4j6DuUl1vU1lrXWrjB1iuSXEo1Svx2yn9y1AYSt1UF8NJomlu+9Q221Q3WqyvbLG8ssxWdY26v0Vg1KH3WYzIxfYd7MYGujmP8us42mQ0PcKRY/dz4EMPk3vg+O6YXTrRtGo+9eUK9eUKjeUaeqWDW9NYUULdaLFOg2XdpGw06ZgtEnNPNUsNTmCQaiVkmj65Wp3CdoX+Rpmck+DmXNpeP5v2BJv2OJt2gSDeIolXIFwgTi7dSOSCgL5Oi1KnTV8Qk1U2ykqBYXePdRQThDFhlBDGMTrRKDSmAttQKMPAVyYdTDoYhIZFZJiEhoXhOriei5f2SGVTZDMeTibNcpxnyR+mEY0DJhEbNNX3advPUygqRotTjJemGCpMk3ILBEoRLixgfO7zqOVl3GNHSf/SLxIcmqW8vER5eYHy0iIbiwu0ypdORQmKulWgYxWx3EEKqUEy5gBGJ49OLrUlSRcc+kYzlEYzZIsuW8sNNs5V0RWfnAE5y6AvbZBVCU6kdm+ktNY0o21q4Ra1sEyUjmgNuNSyJhutFs12G6UU0zMzTB08zMDEDD4OtXZItTfttjdqtIkWT+EsniS3cRqbiMhJUckMU0/1kTgeGSMkq3z2NjH0tUkDD99IY9gZPDtL3s2TtUHp80TBPC3q1O0yLXODWG+SjhSZKEUqTuGoPkyjD0WeJEkTBQahf3XgZlkWuVyOfD5PLpcj6zikfR+vVsPd2MBeXCJ++SU69Tq+58GRI6hjx9EHDxJkM7TbbdqtFs3KGvVyhVYnxNeK+AYPYQxl4LgepusRKpNWoqiGUAk0jcChnVgE2iSkV623Nw+xSBkWj7guJ5TN0UQx7YPdO/XU7IiKuc2Wv8ha+WVq24u7fzNlWuQbLXK1Brl2QGwYtB2Ltm3RdixajkU7lSJKZ4ndNImXJvbSaOfSuGx22CEfbNMfNxgtDTM58zCDU+9FRXa3NLAa7JYKJr1x8HYo20ClLRIrwY/atFoVqrUNWn4VP+50pygiTcSo9ulrbJGsrbJmjLE4/hG2S3ejkpCh9WeZWP4mRb2JPTCANTCANTiAcj3CcplavU693aYWhTQtm3o2S7lvkE46RWSbJFe0YzW0Iqu9bhBINwj0YptY29ipDMNjQxw4NIzTl8IsdauAGraBsk2w1O7DtoXaAk8sPsHj84/z/OpzECuKicvD7Zj7WyF3+Zq2PctcMMxKJSKMNU4uT2F0HCdbwvcjOm0fP/AJw4AoDki4PL86lkc+m8M1Ytqbq7RWl1CBT2o4z/xog8czJ/GdmKKaobA9zeiGx11JhVlznaPuBgf0CtmofNl7kh2Bwni3ynZ6oFdVexCd7qez2qHx3AXqT76A/8opABqjh5k78lNsGNPo2MDPwoXhFV4q/IA258lQpZikKcRZcp0Rcv4YeX+YQtiHTlyWVcii0WFZ+SyZTVpGAEZIn97iPdtnmVqrY0ZglOo4B5bx0wFtPKqqn4Yq0VE5YtIo7WElCjs2sGITJ7KwYwsndjB4B/bWq8HSCZaOMeMQKwkx4xgzjjHiGDPqTkaYYEQxZpTsrjeTuBvY2BZJyiD2LJJ0iiiVJvLShE6KtrZoBglxHO0+/Lqp3dI7P1MDQ5sYiYU2QrRxdW0TjUa5CiflkEtn6UsV6XdLZCITt9LBqfh4tQinpTBVGsMrosyrS2xjYmIVYmgTE+u6AfyOJAmJYp8gaRPQoaN9Oioitgws06PTTmgHAaER45QsvAELM2sQmZrYhEz/AF5fH5GO8X2f+naT7c0G9WqTVqONHwRoFaONiMSI0MQ310+aUriuS8rzdquRu667Ozm2061lkJhYocIODMyOxmorzGaCqiXYHXDoBpI7OommoyH2TMy8iz3oYY266BFFPRVA1uTBsbtvYgdvLamiuU8kSUK5XMY0zd2AzLbtd0QvaLdaa22byl+dITrVxDdClpwLnCo/S626hVZGt8MN2yZd6idV6sfLF2g1m2yurRIpA1yPxLSvOiVblkWhUCCfz5P2sjhGChU5JG2LoGrQ2tI099TVB8gUXYrD6d3gL513qJc71Dbb1LY6bG80qNQ2CcwaoVMjsmskZrdkTWGS8/oYLA0zNjrOzMEpRiYHSOVsOm2fP/3jr3P2P3+NoXCZ2OpWwxxotJmsNJgcGMYIo24pW9PHGr4Xa/xhrKFjKNMmaVcIl7+Pv/R9Ov4GRt8gSf8Yfm6AVqpA1U1RtQwaKqGtAgIVEJkBu+d9DUZsYUYWKgohbvYmH3SCpaDoJfSzwaBVYSgVkDlwHHvmA9iHPopdGN59aHCtdh5Jojmz3uCpC1s8eaHbvqgVxBwczDA7mGV2oDs/OJThQCmFjgI6nc7u1G63L3vdrLfYXN2mslmj0/HRKiI2A7SKrnsxy9km/curFBcXGfJS3PUPf57Sp36C+nZEeaXJ5nyZ1fMX2VpcoFFeIQ630HEFnVTYW68uMDNEmQHSI2NMHJzh+LG7ODA7Q7bUR3V9jY2LF1g+c5alU2cpL13Eb24BYCiTnD1MITVDMTNONt1PxwhZY4N5Y4OWCjC0Ykj3k0oGqCYlzieKORLmSNi+xk2FZxvkPZt8yibvmgy6JuPNDQY3F8huLuL6Ia6RIl0cJdc3gZXN4hPS6NSpBnWqUYOqbtKgw96vzdM2BZ1GoWjh01Q+sbq6ikuiYgIzoGk1qVl1WlaLjtUhoEWm2aa/2mKsHHOgYjJWhqHNiHT70k11bBm0Rwo0pwbZuH+S1XvHaGVMwk4CGzZqKcbacrGrAzidEVTvIh0YFTr6KYzmeZTWtHMOKxMJ20WNSgzMyMSKLOzE3i2lcBLn5m5OdfeGwMFCYREoiwYGG4lBNTEIMAl7QaGOE9Jhg2xYo+Bv0x+UybfLKB2jbZfYSxN6OZJ0Fu15l3VsU8jlGBkdZXxigtHRUUZHR7ul22e/Di9+AU7/NUQdyE/A8Z/tdtAyct9uZy861gS1FmESQqobDCUkuzU3Ep2Q6IT6xgZrZ05z7sWTLJx8Fau62Tt2Bu7IGNP33MXA6AiOzrH6qsnivEMcm+SsKhPxqwxVnsPc2gQ/wCgVMfv6CIvjLBglLm6vUGucA2IMa5Js/0NMHTtCyTuNV3mM9vZFqjrPnJpmJRkkUjaGCq/6yl1t75YAprRDpBJCIgJiQhXhq6hb4kh8zXx4LUprTN0dxsbQ4Dou2XyBbL6we4OYzeQwQ49OJWH91TNUll8kCuZIdIjp9TM6fZxjx0Y5NLCGUzvLWvkMf9Ve4C+dhDOOg6U1H2q1+dGOyVR7gDP+IBfiYS7oEdr5KYYOHOHemXEyrkW5GbDVDCg3duYdOo2QuBli+wn3+yEPhFCwsrgK8kGFTFQnSpngZXGNXLdGy7WyrKFQaQsF6Mbl32/kmvhZi2bGouaZVMyI8sLzNE//LYFfxRoeZXxUcZDzzARnKOltAGKtOKsneFHP8EIyw0vJDCf1FB0cLEIMs41htrGMJiVjk4JVJmNs45lNbKOJYQQY2qdY0fRvKoa2DEY2FKlQoZWi6SoWhgxWSikMa5BSkMdTKRwzg2P3YVlZsExKuKSwsTBRGpqGpuNYGJkcRs7Fy7s4toFBgtIx6Bh0t3dHpeNeT4/RZcskEURBtwZJb0q8AnF+jMjqIyBF6GsazYCNcptqPUCHCe5Or9I66QYsO5NxaTnRVeJkmSRZQ6sIbdgYbh84OWLLJDIjzALkRjyG+geZGJhgojCGZ5qoMMRv1GnXa7RqNdr1Gu1atTuv12j1ljv1OrpX+m0bLikzi2dmSVlZ0ipNxsjgKJco6RAmPlHiEyYBISGRCglVTKQiQhUSqpBEdR/Ex0lMGIVEcYTWMWiN0t0r6s78ur8308LLThAnI2g9jmGNEdua1dwFVjLnWM1dYDu/jmON0qqNUq8MY/ijZClybDjN0eEUs/0uE3kbI4nwfX93CoLu/UAQBJel7cxvhmEYOKbdLU1MTKzYxIoN3MTsne97VdO1iWPY/Oi/eucNVXa7AjyLbicrHwOW6Hay8gta65f3bPPrwL17Oln5Wa31z9/ofe/kAE9cLVxrUv3aHJ1Xy5gFl/SPjNHqb1FeWmBraYGtxXm2Fueprq9hOQ6H3/MBjn7kY0wevxdQNBqN3XY/1Wr1qnmj0biqWqvjOGTTOVw7jYWHChyipoW/rUja3SdjoV1Hp5vEbp2Oru5WYcpl8oyPjTN9cIrJyUlGRkZes5H7/FaL3/rLl3n6xXP8cPgqh2uv4rcbpJTLeOYuxjJ3M5SaxlQWrajOQvMU881TbPmLrzWYwVU0isRxSdwUieuROB6Jm0IbZnfwXqVIrjNu3o0YhrH7QGJn2vuQYmfSWl8zeHutE7ZhGHieRyqVwvM8bMshailalZj2doKhLcysotm3xdnMiyyHC5Q6JQY7wxSDAra2dr4AzDiFFeawwixWmKOU72dgtEBpNEPfaJq+0Sz5AYd2bZMzp8/xyqlzrF68SHtjBbe5iZtc2leNQvWOvQYaboktp58Vq48tux/MAUpkmTIaFO0yuGW0EYI2sMISKYYYsIcYtB2GEujvJNh77mVj1yDu8zAHUjimgenH0I5I2t12gkkrgmuMs7YjTHyCuENsRlj5FKmBIo1cyKn2GZ5vvMR20sC1M0zmpijZ/fidgCROyDppMkaKjHZIBTapjolXN/HqClPvabOiY5KwQtLYQNc20K0tkuYmSWuTltqiku+wOeSxNphhpT/NcsFkzUvwgwjPzzLQmmSoOclAc5xc51IHRx27SiO7TLOwReRVyKyvkp9rYMSazmSa9gMD6KkitulgGRaO6WAb9qXJtHGMblqsYyprm+j5DtkNh8F6kf6gSEBEW/ks25tseTXaXgye0a3imNgYsUESJvid7s3Fa11LNZfiZcMwGBwcZGRkZDeQGx4exrvB4NtBHLBZnWPj1FfYPPs3bGy8zLqp2EyX2MgPs+l4bAQ1Kn5ld9zLm+WEBoMVh+GKx1DFZWDbwUq6x7GWDtkoRhjWGCPt91MM7yaw2rw69CTr2YuMVWeZXPNw6+fR8TIai2ZhiMUpWB6dJzHXcYMWrk7Q2qUSF9jSg+SzfUz1FZjuK5IyHZzIwfItlK9QbYVuapJ6RNgK8f0ATUKcxCg0hlJkzDR5O0veypE2vG4VMG3iJBZWYnTbC0YGVqywo+7TfFMbr1ly8VpirUmARINSEYYRY1oxtqvwbSjrDuvxNq2kjTY1fZkBcu4QQZRhvRWyVO9QC2M8FEUUJRT9hkERRS5RXO9q0FE+HZpYoY9Tr6LqZbTfwCimcA8dIH3/Ebyjd2HmHIyM3e3FsRf4J0FMtNUh3moTbXWIttq9qUNc9S97YBkbMbXOJvWwQnqij8n33U92QGH5pzEqP4DV52D5OVSzO5yAViadwiFauSns9gZuawWnvY7q5cGoY9DacGhUcrS2PMKKg+EWUV4RhsbRozNEfZMEZgbLT/BCC8+4uufDiIQWMUFkUI9hO9bUYqjF+somrG8pw1TYrklsKupRTCWICJQmnbYZH8owO5Ilk3GwPRPHM7Fdqzc3sb1Ly45nYdqwfPplTj7xt5x+6jtEvk9xeJSRQ4fp7AZx3YAt8q/dmZkyDFK5fHfK50nnCqTyO68Ll83T+QKuaRFduEDn5Emi1VXs8XHsyUmcqSnskZHudf11+M6FOf7gmcd4auUHxM55THcJJ7Y5uPUA95U/RHF7FHRIEq2QRIuEyRwq3EIBidJUiwblYoEL1ggX9GE68SgD2RSPTJd4aKrEI9N9HB3LY7+OdupXSpJktybYlUHhjV63Gg2a9RrtdpswCIm13m3jnAkN/vt//b+84X16u9zOYRI+BfxfdIdJ+IzW+l8rpX4beEZr/WWllAf8B+BBoAx8Wmt9/kbvKQGeuJbOuW2qf3WBcKmBPZah8KkZvEOXxs8L/Q4ohb2n6tPNiON4t43QlQHgznKz2bzm/7Usi7GxMSYnJ5mYmGBiYoJc7o2NPxbXA558cpEnvj3PYDvmIVvRH5kYGDS1zwv+Ms/7qzRSbe4eKXDXaIGU62CYBoZhogwDwzS7k9Gdq966venKNC/9n7UXMb75bzBIKBVc0s05APTog4SHPkE48yOEfYd3q9jurWZ75XSz6UopPM+7LFjbO12ZthvQ3aAku17ucPaZdc48s8bGfB2AbJ9LY/tS5xax4dPMrhGyihc3iRxN4HYvfBqNyihyAznGxsa4e/pujk4fxXOvvhlv+iHPnJzn+ZdPM3/uArXNdfx0H0lpFGtgjEI2TSFlk3cUbnuTcGuBxvo8cRhg2Q4HDswwWpzC9fvYnGuyfrFO3OvMJVN0GZnJMTaeZSDvkNUQb7UJ11tEG20w1GU9fZq7PX5epxfQlEWjWubcM0/ywncfY+PUaUg0bSdmdTRk5IF7+fiHPs39AyeII00UxERhQhwmBPUW7YUVOkurdFY38NfL+FtVwmoDQ6WwvAK2l8P2sripHK7t4Zo2zhUPByKtaSWaVsIVc42fdJtl5s1N+s0lSukaxbFBCofuxpk4xtb8Eue//zRbcxexLIfR2SNMHjlOOpNHx90uznWUQNRbjhN0b5neOh1rklZ4WQ+XzlSeeMJmY6DO+cwS8+0FFmoLLNQXmK/PUwsub4c1lB5iMjvJgfQBxrwxhtwh+q1+imYRIzLwfZ9Op4Pv+xSLRUZHRxkcHMS2u9WoWmGLzfYmG+0NNlob3Xl7g81WN21nXdWvciUDRb82GAjaDMYxg06egcFjZPoOoew0ysmi7BTKMDF63/2lXmgvdaK1809reGWlzrdPbdBY2GCi1eSI7lCoVNHtTvdveh5WaozEH4MkJgpegKSJkc5h3z8Dh9sE1Vdol88S6piq8jhPH8sUsTNpCmlIuQlhEuDH/qUp8omu0yESQJ/Xx4fHP8xHJz/K+0ffT9Z5nT3Pat1t4xsm6GYNffEHhOef5OILL3N2RVEJipjKwlQmrgFj6TZjqRaFbArSw+jUENrtI7b7aHZyNJs2rWpI0AhRuptXUztjyrkmIW3qnRqdoIOVGLg4pFUaBxsVgbYNjIxF4IZsm3XW/W1a2wqn3k8Um6ylVtk6sETpWIrDB45w39j9DKQGdj9LcO4cjccfp/7447R/8CwkCWZ//+VDg2Rf+zvSYUJU6ewGfNFWG3+1RmuxjBXYu/kGur8Pqy+F1e9h5iIstYoVnMFqPIPZeJXIm6HTHKNTzhKULcIa6NhFeSWMdAmVKqGMq6sPBkmHVlSjk7SwSynyUyP0HZ7C6ctg5h3MfHcom6uGrOmJE81qtc1ipc3Sdovlcm+52ma50mZpu0MQJZeF9oWUzXjRY6yQYryYYqyYYqzgMVZMMV70yHk2p9Yb/MXzS3zp+WW2WyHDeZefPTHBPzgxwaGh15f/rvrMnTZnnvwOJ7/5GNX11WsGaDtB2m5aPo+XzrzpQdbfCu0g5msvrfAnT5/l2bUXsNIXGRxcxvarjJSnaaQqqEEwzBGaWwPEF2Co2ma8s8pIsN5ra6soTk4xc/w+Jo8eZ/zIMdL5WzPWc6O8xeq5M6ydP8PquTOsnj9LpzeUhmlZDE7PMjx7F8Ozh+g/ME1+eIRs9p0zfuwOGehc3BF0omk/v0H1P80Rb/t4d5cofHIGe+T6A92+FaIouizgC8OQ0dHRmyqdu5IOE8L1FuFqk3Cl2Z2vNkn2VLFpOQYvBgFniPkOEctpk585Mc7PPTzBkZFr9y76hpUvwFf/WzBtuPuTcNePQ370rf0bt9D2Woszz6yxtdSkOJyibzTTHT5jKI3lmERJxGJ9kaUn/prwT75CvN5ibXiAs1N9tNIFvKTX7hGN7/lYRYvSUIkDEwc4OnWUg/0H8axrl8L4vs+ZM2d45ZVXOH36NGEY4nkeR44c4Z577mF2dnb3pn9HHCdsLTZYPV/tdkRwvkp9q3ejbSkGJ3OMzBYYnsnjeBZRGBMF3SBsZ7kblF1ajsKYOEhodTqs1zcpNyuEfoQVa1J+GaOzQNyZAx0ANoY9g2kfxLBnUMbNdGWusSyF5ZjYKbs7dwwsx8SxFClDkULjJuDGCY4fdDsv8MHQb9GNiwJlGWAZKEuhTAPVW+6m9SZToVwTZzKHO13odo3+Gt39V/0qC/VewFeb311eqC+w0d64bNuiW+RA7gATuQnGs+N04s5VgVszvPoBkW3YDKQGGEwNdufpQQZTgwymB3fTB9ODlNwSpmFCbQVe/iK89AVY+v7VX4ZX6I47leq7xrx0zfSXNkI+83cX+Mvnl4nihE9OWny8v4VXWWD51EkqK0sATN13ghPvPcZM+BzJi1/AbK3TJM1fRu/hS8kHUVMf5CcfmOQTx0foy9x43LMoiQjigE7cwY8uBX9KKQ4WDnY/69uhVWbzqS9z5slvMzg8wPQDD2ENH4a+2dccJiQMYlbPV1k+vc3S6QprF2oksUYZiqGpHEMHs6wVL/CN8Kv83ca3SHTCPX334Jour2y8yvjW3Rxf/TBjtbtIzBjviM/xj47z8LHj2NdoS3Ut8fY2jW99m8bjj9P41rdIajWwbTKPPIx3/N7uRloDutsbrKY7FpjW3Wp9urc+SS7bpu77nC7XqAYGBbuPycwofW4/igyQ7g47cwNaxxh20u1JdaSIWfBo+hWWF08zd+ZZytvLhEbI9IkT3P2BDzPzwEPY13hw9mYliWaz6bNU2QkC273lFkvb3bRWcHnbS8826IQJjmXw48dGePShCT50aADzOkHmnez8RoPPP7PIF76/yGajRTZTo9HKgrZxTIN7Jwo8PF3ikak+HpoqkbU1q2dOsXDyJZZefYnl06eIgu5Dtv6JA0zcc5yJe44xcc9xsn39b3r/2vUaa+d2ArkzrJ07Q6PSbRerDIOBiQMMHzzMyMG7GDl4FwMHpjCtm/vt3W4S4Ik7ig4TGt9ZpvaNebQfk3l4hPyPTWHm355BVd8IrTVxNbg8kFtpEm22LjXtsgzskTT2SKY7jXbnZsbm/EaDzz2zwIkDJX747iEc6/Y/0duP2s89x+bv/T6Nxx6DdIrqT/8Ir56YZrG2TXOriaornKibrxIS6nYdP+uTKqUYHBlkengar+pRXaiycGGBKIrIZDIcOXKEo0ePMj09/bofAjSrPmu9YG/1fLVbynedrrZ3GKbCsg1M2yA0AppJnVpSJTJCPMdh2C0wqFLYnQ6qsU1S3aJZnaOhN2jYTSKj2+60oLIUsv2kSyUyg0NkJ8YpzM6SGxok21fEy6YwLeMNtQvWWqPbEVG5Q7S+TVJvozJ5lGUQhgFzL/+AM898l2atQnagnyMf+Sizj7wHO+VdHryZxk2PyfZWa4UtFhuLl5X4zdfnWawvstJcwTXdq4K2neXdwC01SMEtvPG21ZU52DwL7TK0yteZV7rz4AZjs1kepPoIvSIrQZrTVYu1KIOR6eOe2WmmR0cwaiukz38Jq3yGEIvH4gf4YvwhyuM/xCfun+Yn7htlOP/W37C/k4V+N+BbOl1h+fQ2a3OXAr7SZIrGwBrPm98lWxtgYv44quWQ6bO5/4enuOcDo3iZN3djqaOI9rPP0njiCerfeJxgbg56JbU7PSFjGNdMU7C7rpvWLdmtORavZh1WPQsn0RxuRUwHYLoFDLcP5ZVQqSL2cBH34ASp+w/jHp7CzNqgNcunX+XU977Fme/9HY1KGct2mDnxMHe//8PMPvgI9g2qJt8KWmu2W+FusLdYabG83WF2MMNP3T9GIfXuuNm/3cI44bFX13nslXWmBzI8PF3i3vHCVWObXimOQlbPnWXxlZdYfOUllk+dJGh3h70ojoz2Ar7ulB8cuuG5MWi3WDt/drdUbu3caarra7vrS2MT3UBu9hDDBw8zND3ztjxUuFUkwBN3pLgZUn9snsb3VlCGInV8oDs2mWtiuL25Z6Ics7e8s677Wtlv7Eb1SkkQ75bEXQrmWujOpepIZsm9LIizRzNY/anrVkkRt1bn1Cm2fu/3qX3tayjLovjoP6D/V34Fa2yMjcoGL557kfML59lY3cCv+Kjw8uPWMlts5DYwR0yGx4eZKc4wU5hhJj/DZG7ypp/UX0scJZSXm8RRguUYWLaJaRu7AZ1pG7yw9TxfefWLvPj9v6a42uRwLcOJ9iCjmwlqYQW9p72H2d+POzuLc3AWd/Yg9uwMFRPmLpzl3NPfo7yyBNe5bliue3XVoj3tRS4td9d52RzmDdqAbK+u8P2/+hIvPf51It/nwPH7efgn/z7T9594R1RTej3iJO5WjXwndYoV+dCuvHYg2CqTtLYI6lvYwTbmnlZPTyVH+GL8Qc4N/Cg//ODd/OR9o0z2pW/wR+8s1wv4AA4c6+PeH5rgwLF+jHfBuX759Kt8+8/+kIWXXyDXP8j7f+4fcewjH8O44iGV1pqVM6c4/b1vcep7f0djaxPTtpl54CEOv//DHDzxCE5K8oi4tiSOWZ873wv4XmbplZfoNLsPo3L9g0wc7Zbwjd99DL/VYPVcN5BbPXfmsutTfnCIkdm7GD54FyMHDzM8exA3/fbW6LrVJMATd7Roq031by4SXKiS+DE6uLwXzOtS7An4rN3AbzcAvEZQaLgmOoFobU+pXLmz+/eUY/aCuPSlYG4kg3ETQy2I2y+Ym2PrD/6A7f/4JdCawk/+JP2/+k9xZ2d3t9FaU61WWVpe4uLqRXRRU/EqzNXmuFC9wFx1jvX2+u72pjKZyE0wk59hujDNTGGG6Xx3XvJK19qNG4qrVfzz51k9+Qxnnn2cxplX6FtrM1Tt9hwIdNujTkzgzM7gzh7EPTiLM3sQd3YGs1i84fsnSYzfbO52BtDt1a22Z3lPem9d0G5d9/3cTOaKQLAb/G2vLnP2mScxDJN7PvRRTnzqZxianr3u+4hbQycxT5+a5z9+50Uu1hIePn6Un7p/lEND77z2Ke9EoR+zNlcj2+t9+d1Ga838i8/z7T/7LKvnzlAam+CDP/+LHH7vB1g7f5ZT3/s2p777LeqbG5iWxdT9J7j7/R/m4EPvxU2/+z6vuP10krC5ON8N+E52S/la1e3LtskUS91AbrZbzXL44F23rD3f7SQBnhB76J2G9n5M4ke9ebxn3kvrXJ52+TaX5iTX+A0puoNZ7wni7NEMZtGVUrl9IFxdZeszn2H783+O9n1yH/84/b/6T0kdO3ZT/78RNLhYu8j56vlLgV9tjovViwR7euEsuIXLAr+Z/AxTzgjDTRPWtwhX14jWVglXVgkuXKBz7izJ1qUxtwITqsNpvIOHmDj2XjJ33Y178CDO9DTGLawWFUfh5UHgnqCwdWVA2AsSbdfj/h/7JA98/CfeknYYQoi3jtaas09/l7/73B+xtTiPk0oTtFsYpsnUfQ92g7qH34uXeXOdkQhxJa01lZVllk+dxM1mGZm9i2xf/zurdsQtIgGeEG8TrTVEyaWgr9NtqG0NpjCct6lDAPGOEZXLlP/wD6n80R+TNBpkPvxhBv7Zr5F+6KE39H5hvc7y3AusnH+J8vwZmsvzRKtrWJvb5LYD+uuQ7VxjP3IpygMur+TqzPdrkskRjj/8CT72vl9gND/+Jj/lrbdzXboTL9hCvJskScwr33qcued/wNS9D3Dokffj3UTvnUKIN08CPCGEeBvF9TqVP/lTyp/9LHG5TOrhhxj4tX9G5kMf3A1S4kaDaHW1W+q2unKp9G3P66Rev+q9zf5+7OFhGOqn1ZemnFOsZALm3DqnzE1eMlZomRElt8QnZz7JTx/8aY72H5XgSAghhNjHJMATQohbIGm32f7zL7D1mc8Qra7izM6CoYhWVkmuHC9RKcyBfuzhEayRYeyRUeyRYazhke58ZARreBjDee2u5ddaawylht5UZy1CCCGEePeQAE8IIW4hHQRUv/xlql/5KmYuhzUygj2yE8iNdIO4oUHUawRvQgghhBDXcqMAT7ruE0KIt5hyHIqPPkrx0Udv964IIYQQ4g7z7hpISAghhBBCCCHEdUmAJ4QQQgghhBD7hAR4QgghhBBCCLFPSIAnhBBCCCGEEPuEBHhCCCGEEEIIsU9IgCeEEEIIIYQQ+4QEeEIIIYQQQgixT0iAJ4QQQgghhBD7hAR4QgghhBBCCLFPSIAnhBBCCCGEEPuEBHhCCCGEEEIIsU9IgCeEEEIIIYQQ+4QEeEIIIYQQQgixT0iAJ4QQQgghhBD7hAR4QgghhBBCCLFPSIAnhBBCCCGEEPuEBHhCCCGEEEIIsU9IgCeEEEIIIYQQ+4TSWt/ufXhdlFIbwMXbvR/XMABs3u6dEO8IkhfEXpIfxA7JC2KH5AWxQ/KC2PF688KU1nrwWivedQHeO5VS6hmt9cO3ez/E7Sd5Qewl+UHskLwgdkheEDskL4gdb2VekCqaQgghhBBCCLFPSIAnhBBCCCGEEPuEBHhvnd+73Tsg3jEkL4i9JD+IHZIXxA7JC2KH5AWx4y3LC9IGTwghhBBCCCH2CSnBE0IIIYQQQoh9QgK8t4BS6hNKqVNKqbNKqd+83fsj3n5KqTml1ItKqeeUUs/00vqUUl9XSp3pzUu9dKWU+r97+eMFpdSJ27v34s1QSn1GKbWulHppT9rrPvZKqV/ubX9GKfXLt+OziDfnOnnht5RSS71zw3NKqU/tWfcvennhlFLqx/ekyzXkXU4pNamU+oZS6qRS6mWl1H/TS5dzwx3mBnlBzg13IKWUp5R6Sin1fC8//K+99Bml1JO9Y/s5pZTTS3d7r8/21k/vea9r5pNr0lrL9CYmwATOAbOAAzwPHL3d+yXT237c54CBK9L+LfCbveXfBP5Nb/lTwNcABbwPePJ2779Mb+rYfwQ4Abz0Ro890Aec781LveXS7f5sMr0leeG3gP/uGtse7V0fXGCmd90w5RqyPyZgFDjRW84Bp3vHXM4Nd9h0g7wg54Y7cOr9xrO9ZRt4sveb/zzw6V767wL/VW/5vwZ+t7f8aeBzN8on1/u7UoL35r0HOKu1Pq+1DoA/A37mNu+TuD1+Bvhsb/mzwN/bk/6Huut7QFEpNXob9k+8BbTW3wTKVyS/3mP/48DXtdZlrXUF+Drwibd958Vb6jp54Xp+BvgzrbWvtb4AnKV7/ZBryD6gtV7RWv+gt1wHXgHGkXPDHecGeeF65Nywj/V+443eS7s3aeBHgC/00q88N+ycM74AfEwppbh+PrkmCfDevHFgYc/rRW78Qxb7gwb+Rin1faXUr/bShrXWK73lVWC4tyx5ZP97vcde8sT+9hu9anef2amSh+SFO0avStWDdJ/Uy7nhDnZFXgA5N9yRlFKmUuo5YJ3uQ5tzwLbWOuptsvfY7h733voq0M/rzA8S4AnxxnxIa30C+CTw60qpj+xdqbvl6dJF7R1Ijv0d7/8FDgIPACvAv7uteyNuKaVUFvj/gH+uta7tXSfnhjvLNfKCnBvuUFrrWGv9ADBBt9TtyNv9NyXAe/OWgMk9ryd6aWIf01ov9ebrwBfp/mDXdqpe9ubrvc0lj+x/r/fYS57Yp7TWa72LeQL8Ppeq0Ehe2OeUUjbdG/o/1lr/RS9Zzg13oGvlBTk3CK31NvAN4P10q2VbvVV7j+3uce+tLwBbvM78IAHem/c0cFevNxyHboPIL9/mfRJvI6VURimV21kGPg68RPe47/R49svAl3rLXwb+ca/XtPcB1T1VdsT+8HqP/X8CPq6UKvWq6Xy8lybe5a5oX/v36Z4boJsXPt3rIW0GuAt4CrmG7Au9NjJ/ALyitf4/9qySc8Md5np5Qc4Ndyal1KBSqthbTgE/Rrdd5jeAR3ubXXlu2DlnPAo81iv9v14+uSbreivEzdFaR0qp36B7AjaBz2itX77NuyXeXsPAF7vncCzgT7TWf62Uehr4vFLqV4CLwM/3tv8ruj2mnQVawD+59bss3ipKqT8FfggYUEotAv8S+N95Hcdea11WSv0ruhdwgN/WWt9sZx3iHeI6eeGHlFIP0K2KNwf8GoDW+mWl1OeBk0AE/LrWOu69j1xD3v0+CPwS8GKvrQ3A/4icG+5E18sL/0jODXekUeCzSimTbsHa57XWX1FKnQT+TCn1vwHP0n0oQG/+H5RSZ+l24vVpuHE+uRbV63pTCCGEEEIIIcS7nFTRFEIIIYQQQoh9QgI8IYQQQgghhNgnJMATQgghhBBCiH1CAjwhhBBCCCGE2CckwBNCCCGEEEKIfUICPCGEEOItppT6IaXUV273fgghhLjzSIAnhBBCCCGEEPuEBHhCCCHuWEqpX1RKPaWUek4p9e+VUqZSqqGU+j+VUi8rpf5WKTXY2/YBpdT3lFIvKKW+qJQq9dIPKaX+s1LqeaXUD5RSB3tvn1VKfUEp9apS6o+VUuq2fVAhhBB3DAnwhBBC3JGUUvcA/xD4oNb6ASAG/gsgAzyjtT4GPAH8y95/+UPgf9Ba3we8uCf9j4Hf0VrfD3wAWOmlPwj8c+AoMAt88G3+SEIIIQTW7d4BIYQQ4jb5GPAQ8HSvcC0FrAMJ8LneNn8E/IVSqgAUtdZP9NI/C/y5UioHjGutvwigte4A9N7vKa31Yu/1c8A08O23/VMJIYS4o0mAJ4QQ4k6lgM9qrf/FZYlK/c9XbKff4Pv7e5Zj5JorhBDiFpAqmkIIIe5Ufws8qpQaAlBK9SmlpuheGx/tbfMLwLe11lWgopT6cC/9l4AntNZ1YFEp9fd67+EqpdK38kMIIYQQe8nTRCGEEHckrfVJpdT/BPyNUsoAQuDXgSbwnt66dbrt9AB+GfjdXgB3HvgnvfRfAv69Uuq3e+/xc7fwYwghhBCXUVq/0ZonQgghxP6jlGporbO3ez+EEEKIN0KqaAohhBBCCCHEPiEleEIIIYQQQgixT0gJnhBCCCGEEELsExLgCSGEEEIIIcQ+IQGeEEIIIYQQQuwTEuAJIYQQQgghxD4hAZ4QQgghhBBC7BMS4AkhhBBCCCHEPvH/A8QZ9e4+pDQjAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "epoch = np.array([i * nb_epoch_before_display for i in range(nn_hp['nb_epochs'] // nb_epoch_before_display)])\n",
    "plt.figure(figsize=(15,8))\n",
    "for i in range(len(losses[0])):\n",
    "    plt.plot(epoch, losses[:,i])\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.ylabel(\"loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# # Lower Bound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "K_L = 1096000\n",
    "BS_lower = MultiDimensionalBS(BS_params['initial_prices'], BS_params['interest_rate'], BS_params['dividends'], BS_params['volatilities'], BS_params['correlation_matrix'])\n",
    "S_lower = BS_lower.Simulate(expiry, nb_ex_dates, K_L)\n",
    "x = torch.from_numpy(S_lower).float()\n",
    "y = torch.unsqueeze(torch.from_numpy(my_payoff.value(S_lower, BS_params['interest_rate'], BS_params['diffusion_times'])), dim=2).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 reward : tensor(11.8513, device='cuda:0')\n",
      "7 reward : tensor(12.3899, device='cuda:0')\n",
      "6 reward : tensor(12.8573, device='cuda:0')\n",
      "5 reward : tensor(13.2481, device='cuda:0')\n",
      "4 reward : tensor(13.5555, device='cuda:0')\n",
      "3 reward : tensor(13.7726, device='cuda:0')\n",
      "2 reward : tensor(13.8747, device='cuda:0')\n",
      "1 reward : tensor(13.8922, device='cuda:0')\n",
      "0 reward : tensor(13.8922, device='cuda:0')\n"
     ]
    }
   ],
   "source": [
    "# init\n",
    "tau = y[:,nb_ex_dates].new_full(y[:,nb_ex_dates].shape, nb_ex_dates).to(device)\n",
    "payoff_tau = y[:,nb_ex_dates].to(device)\n",
    "\n",
    "# backward induction\n",
    "for n in range(nb_ex_dates - 1, 0, -1):\n",
    "    inputs = torch.cat((x[:,n], y[:,n]), 1)\n",
    "    f_n = (my_models[n - 1](inputs.to(device)) >= 0.5).detach().float()\n",
    "    tau = n * f_n + tau * (1 - f_n)\n",
    "    payoffs = y[:, n].to(device)\n",
    "    payoff_tau = payoffs * f_n + payoff_tau * (1 - f_n)\n",
    "    print(n, 'reward :', payoff_tau.mean())\n",
    "    \n",
    "# initial date\n",
    "payoffs = y[:,0].to(device)\n",
    "f_n = (payoffs >= (payoff_tau).mean()).detach().float()\n",
    "tau *= (1 - f_n)\n",
    "payoff_tau = payoffs * f_n + payoff_tau * (1 - f_n)\n",
    "\n",
    "lower = payoff_tau\n",
    "lower_bound = lower.mean().item()\n",
    "print(0, 'reward :', payoff_tau.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tau : 6.967 lower bound : 13.892\n"
     ]
    }
   ],
   "source": [
    "print('tau :', round(tau.mean().item(), 3), 'lower bound :', round(lower_bound, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-12-07T14:02:52.157472Z",
     "iopub.status.busy": "2021-12-07T14:02:52.157099Z",
     "iopub.status.idle": "2021-12-07T14:02:52.162066Z",
     "shell.execute_reply": "2021-12-07T14:02:52.1612Z",
     "shell.execute_reply.started": "2021-12-07T14:02:52.157439Z"
    }
   },
   "source": [
    "# # Upper Bound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "J = 16384\n",
    "K_U = 1024\n",
    "BS_upper = MultiDimensionalBS(initial_prices, interest_rate, dividends, volatilities, correlation_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S_upper = BS_upper.Simulate(expiry, nb_ex_dates, K_U)\n",
    "x = torch.from_numpy(S_upper).float()\n",
    "y = torch.unsqueeze(torch.from_numpy(my_payoff.value(S_upper, interest_rate, diffusion_times)), dim=2).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S_cond = BS_upper.Simulate_Next_State(S_upper[:, nb_ex_dates - 1, :], diffusion_times[nb_ex_dates - 1], diffusion_times[nb_ex_dates:], J)\n",
    "y_cond = [my_payoff.value(S_cond[k], interest_rate, diffusion_times[nb_ex_dates:]) for k in range(K_U)]\n",
    "C_n_1 = torch.from_numpy(np.mean(np.squeeze([y_cond[k] for k in range(K_U)], axis = 2), axis = 1)).to(device)\n",
    "mg_increments = torch.from_numpy(np.array([[0.0] * K_U] * (nb_ex_dates + 1)))\n",
    "mg_increments[nb_ex_dates] = y[:, nb_ex_dates, 0].to(device) - C_n_1\n",
    "f_n = [[torch.from_numpy(np.array([[1.0] * 1] * J)).to(device)] * 1] * K_U\n",
    "\n",
    "for n in range(nb_ex_dates - 1, 0, -1):\n",
    "    S_cond = BS_upper.Simulate_Next_State(S_upper[:, n - 1, :], diffusion_times[n - 1], diffusion_times[n:], J)\n",
    "    y_cond = [torch.unsqueeze(torch.from_numpy(my_payoff.value(S_cond[k], interest_rate, diffusion_times[n:])), dim = 2).float() for k in range(K_U)]\n",
    "    S_cond = torch.from_numpy(S_cond).float()\n",
    "    \n",
    "    inputs = [[torch.cat((S_cond[k][:, m], y_cond[k][:, m]), 1) for m in range(0, nb_ex_dates - n)] for k in range(K_U)]\n",
    "    payoff_tau = [y_cond[k][:, nb_ex_dates - n].to(device) for k in range(K_U)]\n",
    "        \n",
    "    if (not (n == nb_ex_dates - 1)):\n",
    "        f_n = [[(my_models[n + m - 1](inputs[k][m].to(device)) >= 0.5).detach().float() for m in range(0, N - n)] for k in range(K_U)]\n",
    "        \n",
    "        for m in range(nb_ex_dates - n - 1, -1, -1):\n",
    "            payoff_tau = [y_cond[k][:, m, :].to(device) * f_n[k][m] + (1 - f_n[k][m]) * payoff_tau[k] for k in range(K_U)]\n",
    "    \n",
    "    C_n = C_n_1\n",
    "    C_n_1 = [torch.mean(torch.squeeze(payoff_tau[k], dim = 1)).item() for k in range(K_U)]\n",
    "    C_n_1 = torch.from_numpy(np.array(C_n_1)).to(device)\n",
    "        \n",
    "    inputs = torch.cat((x[:,n], y[:,n]), 1)\n",
    "    f_n = (my_models[n - 1](inputs.to(device)) >= 0.5).detach().float()\n",
    "    mg_increments[n] = (y[:, n, 0].to(device) - C_n) * torch.squeeze(f_n, dim = 1) + C_n - C_n_1\n",
    "    \n",
    "mg_doob = torch.cumsum(torch.transpose(mg_increments, 0, 1), dim = 1)\n",
    "\n",
    "upper = (y[:,:,0].to(device) - mg_doob.to(device)).max(dim = 1).values\n",
    "upper_bound = upper.mean().item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('upper bound :', round(upper_bound, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "IC_inf = round(lower_bound - 1.96 * torch.std(lower).item() / sqrt(K_L), 3)\n",
    "IC_sup = round(upper_bound + 1.96 * torch.std(upper).item() / sqrt(K_U), 3)\n",
    "\n",
    "print('- lower bound :', round(lower_bound, 3))\n",
    "print('- upper bound :', round(upper_bound, 3))\n",
    "print('- point estimator :', round((lower_bound + upper_bound) / 2.0, 3))\n",
    "print('')\n",
    "print('IC 90% :', (IC_inf, IC_sup))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to do : qq tests et graphes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}