notebooks/image-classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "62ddd56a",
   "metadata": {},
   "source": [
    "# Classification on Fashion-MNIST\n",
    "In this notebook, we show how to use `SFR` for classification on the Fashion-MNIST data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5351551d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from collections import OrderedDict\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "from IPython.display import clear_output\n",
    "from netcal.metrics import ECE\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "from torchvision import transforms\n",
    "\n",
    "sys.path.append(\"..\")  # Adds higher directory to python modules path.\n",
    "\n",
    "import likelihoods\n",
    "import priors\n",
    "import sfr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "365a3a2e",
   "metadata": {},
   "source": [
    "Let's fix the random seed for reproducibility and use GPU if it's available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "61355867",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42)\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1e0db60",
   "metadata": {},
   "source": [
    "## Fashion-MNIST data set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92f880ec",
   "metadata": {},
   "source": [
    "The Fashion-MNIST data set is an image classification problem with $80,000$ inputs $\\mathbf{x}_i \\in \\mathbb{R}^{28 \\times 28}$ (i.e. single channel images) and outputs ${y}_i \\in \\{0, \\dots, 9\\}$. The original inputs are integers but we transform them into floating point numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5a9ef2",
   "metadata": {},
   "source": [
    "Let's load the Fashion-MNIST train/test data sets and normalize them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f4995a2d-5a7c-4d3f-91fb-ed1e97abbca3",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "train_val_split = 0.8\n",
    "in_channels = 1  # 1 for MNIST/Fashion-MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d6a057-969a-4b09-a11e-9b1b3c27c09e",
   "metadata": {},
   "source": [
    "Set debug to only use 500 data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1016d8dd-374f-4bad-98d3-d128e0064cda",
   "metadata": {},
   "outputs": [],
   "source": [
    "debug = False  # if debug=True only use 500 data points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "157f59cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(), transforms.Normalize((0.2860,), (0.3530,))]\n",
    ")\n",
    "ds_train = torchvision.datasets.FashionMNIST(\n",
    "    \"data\", download=True, train=True, transform=transform\n",
    ")\n",
    "ds_test = torchvision.datasets.FashionMNIST(\n",
    "    \"data\", download=True, train=False, transform=transform\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3539f5f-376e-4b3d-82a5-7cd9a2221cb9",
   "metadata": {},
   "source": [
    "Split the train data set into train/validation sets and create data loaders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9d60147b-26bb-4287-b737-40239742aaa2",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_dim = len(ds_train.classes)\n",
    "num_data = len(ds_train) if not debug else 500\n",
    "\n",
    "idxs = np.random.permutation(num_data)\n",
    "split_idx = int(train_val_split * num_data)\n",
    "\n",
    "train_loader = DataLoader(\n",
    "    Subset(ds_train, idxs[:split_idx]), batch_size=batch_size, shuffle=True\n",
    ")\n",
    "val_loader = DataLoader(\n",
    "    Subset(ds_train, idxs[split_idx + 1 :]), batch_size=1024, shuffle=True\n",
    ")\n",
    "if debug:\n",
    "    test_loader = DataLoader(\n",
    "        Subset(ds_train, idxs[split_idx + 1 :]),\n",
    "        batch_size=1024,\n",
    "        shuffle=True,\n",
    "        pin_memory=True,\n",
    "    )\n",
    "else:\n",
    "    test_loader = DataLoader(ds_test, batch_size=1024, shuffle=True, pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e1a8c07",
   "metadata": {},
   "source": [
    "## Neural network "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4e3ba14",
   "metadata": {},
   "source": [
    "Given the data set $\\mathcal{D} = \\{(\\mathbf{x}_{i} , \\mathbf{y}_{i})\\}_{i=1}^{N}$, we want to approximate the function $f$ with a neural network $f_\\mathbf{w}: \\mathbb{R} \\to \\mathbb{R}$ with weights $\\mathbf{w} \\in \\mathbb{R}^{P}$.\n",
    "It is common to traing the neural network weights $\\mathbf{w}$ to minimize the (regularized) empirical risk,\n",
    "\\begin{equation}\n",
    "  \\mathbf{w}^{*} = \n",
    "  \\arg \\min_{\\mathbf{w}} \\mathcal{L}(\\mathcal{D},\\mathbf{w}) =\n",
    "  \\arg \\min_{\\mathbf{w}} \\textstyle\\sum_{i=1}^{N} \\ell(f_\\mathbf{w}(\\mathbf{x}_{i}), y_i) + \\mathcal{R}(\\mathbf{w}).\n",
    "\\end{equation}\n",
    "where $l(f_\\mathbf{w}(\\mathbf{x}_{i}), y_i) = -\\log p(y \\mid f_\\mathbf{w}(\\mathbf{x}_{i}))$ and the regularizer $\\mathcal{R}(\\mathbf{w}) = \\frac{\\delta}{2}\\| \\mathbf{w}\\|^{2}_{2}$.\n",
    "We can view this as the maximum a~posteriori (MAP) solution to a Bayesian objective, where the first term $l(f_\\mathbf{w}(\\mathbf{x}_{i}), y_i)$ represents the log likelihood and the regularization weight takes the role of a prior precision parameter, $p(\\mathbf{w}) = \\mathcal{N}(\\mathbf{0}, \\delta^{-1} \\mathbf{I})$.\n",
    "\n",
    "Let's start by creating a neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e2b73daa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CIFAR10Net(nn.Module):\n",
    "    def __init__(self, in_channels: int = 3, n_out: int = 10, use_tanh: bool = False):\n",
    "        super().__init__()\n",
    "        self.output_size = n_out\n",
    "        activ = nn.Tanh if use_tanh else nn.ReLU\n",
    "\n",
    "        self.cnn_block = nn.Sequential(\n",
    "            OrderedDict(\n",
    "                [\n",
    "                    (\n",
    "                        \"conv1\",\n",
    "                        nn.Conv2d(\n",
    "                            in_channels=in_channels,\n",
    "                            out_channels=64,\n",
    "                            kernel_size=(5, 5),\n",
    "                            stride=(1, 1),\n",
    "                        ),\n",
    "                    ),\n",
    "                    (\"relu1\", nn.ReLU()),\n",
    "                    (\n",
    "                        \"maxpool1\",\n",
    "                        nn.Sequential(\n",
    "                            nn.ZeroPad2d((0, 1, 0, 1)),\n",
    "                            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "                        ),\n",
    "                    ),\n",
    "                    (\n",
    "                        \"conv2\",\n",
    "                        nn.Conv2d(\n",
    "                            in_channels=64,\n",
    "                            out_channels=96,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(1, 1),\n",
    "                        ),\n",
    "                    ),\n",
    "                    (\"relu2\", nn.ReLU()),\n",
    "                    (\n",
    "                        \"maxpool2\",\n",
    "                        nn.Sequential(\n",
    "                            nn.ZeroPad2d((0, 1, 0, 1)),\n",
    "                            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "                        ),\n",
    "                    ),\n",
    "                    (\n",
    "                        \"conv3\",\n",
    "                        nn.Conv2d(\n",
    "                            in_channels=96,\n",
    "                            out_channels=128,\n",
    "                            kernel_size=(3, 3),\n",
    "                            stride=(1, 1),\n",
    "                            padding=(1, 1),\n",
    "                        ),\n",
    "                    ),\n",
    "                    (\"relu3\", nn.ReLU()),\n",
    "                    (\n",
    "                        \"maxpool3\",\n",
    "                        nn.Sequential(\n",
    "                            nn.ZeroPad2d((1, 1, 1, 1)),\n",
    "                            nn.MaxPool2d(kernel_size=3, stride=2),\n",
    "                        ),\n",
    "                    ),\n",
    "                ]\n",
    "            )\n",
    "        )\n",
    "        self.lin_block = nn.Sequential(\n",
    "            OrderedDict(\n",
    "                [\n",
    "                    (\"flatten\", nn.Flatten()),\n",
    "                    (\"dense1\", nn.Linear(in_features=3 * 3 * 128, out_features=512)),\n",
    "                    (\"activ1\", activ()),\n",
    "                    (\"dense2\", nn.Linear(in_features=512, out_features=256)),\n",
    "                    (\"activ2\", activ()),\n",
    "                    (\n",
    "                        \"dense3\",\n",
    "                        nn.Linear(in_features=256, out_features=self.output_size),\n",
    "                    ),\n",
    "                ]\n",
    "            )\n",
    "        )\n",
    "        for module in self.modules():\n",
    "            if isinstance(module, nn.Conv2d):\n",
    "                nn.init.constant_(module.bias, 0.0)\n",
    "                nn.init.xavier_normal_(module.weight)\n",
    "\n",
    "            if isinstance(module, nn.Linear):\n",
    "                nn.init.constant_(module.bias, 0.0)\n",
    "                nn.init.xavier_uniform_(module.weight)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.cnn_block(x)\n",
    "        out = self.lin_block(x)\n",
    "        return out\n",
    "\n",
    "\n",
    "network = CIFAR10Net(in_channels=in_channels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fb9f982",
   "metadata": {},
   "source": [
    "Making predictions with `SFR` depends on the loss function as it encodes our likelihood and prior.\n",
    "As such, we instantiate `SFR` by passing it a prior and a likelihood.\n",
    "\n",
    "We use a Gaussian prior over the weights as it correspondes to a weight decay regulariser."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f9f74dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "prior_precision = 0.004\n",
    "\n",
    "prior = priors.Gaussian(params=network.parameters, prior_precision=prior_precision)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a7703ef",
   "metadata": {},
   "source": [
    "We use a Categorical likelihood, which corresponds to using the cross entropy loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3357c176",
   "metadata": {},
   "outputs": [],
   "source": [
    "likelihood = likelihoods.CategoricalLh(EPS=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7b75505a",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = sfr.SFR(\n",
    "    network=network,\n",
    "    prior=prior,\n",
    "    likelihood=likelihood,\n",
    "    output_dim=output_dim,\n",
    "    num_inducing=2048,\n",
    "    dual_batch_size=1024,  # this reduces the memory required for computing dual parameters\n",
    "    jitter=1e-4,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f02c6a8",
   "metadata": {},
   "source": [
    "We can now train the network using our loss function `SFR.loss()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "efa1951b",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 100\n",
    "learning_rate = 1e-4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cbc5767d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQsAAAKqCAYAAACdJAgGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACaZUlEQVR4nOz9fXxUhZ33/79nQpIBTEYCCzML3qSIShqRhpaSytqqYKMutW7ba4uy7lrbXmVtV23XWr3qYrSK1vayPi631LtWfxdFXdv1Jm2NBa3yE0OjRFxirNVsQC+dQEkg4S4hzMz3j3DCzGRuzjlz5v71fDx4bDM5c+bM5MSVt58bVzgcDgsAAAAAAABAyXPn+gIAAAAAAAAA5AfCQgAAAAAAAACSCAsBAAAAAAAAHEVYCAAAAAAAAEASYSEAAAAAAACAowgLAQAAAAAAAEgiLAQAAAAAAABwFGEhAAAAAAAAAEmEhQAAAAAAAACOIiwEAAAAAAAAIImwEAAAIOsefvhhuVwuvfbaa7m+lKzZv3+/Vq1apaamJtXU1Mjlcunhhx+2dI7169dr8eLFmjRpkqZMmaIvfvGL2r59+7jjTj75ZLlcrnF/vvGNb8Q974YNG3TuuefK6/WqqqpKCxYs0OOPP27jXQIAABS+Cbm+AAAAABS/3bt365ZbbtGJJ56oM888Uy+++KKl5//mN7/RxRdfrIaGBt1xxx0aHBzUPffco8WLF+v111/XX/3VX0UdP3/+fH3nO9+JeuzUU08dd95f/OIXuvLKK7V06VLdfvvtKisr09tvv63333/f8nsEAAAoBoSFAAAAyDi/369AICCfz6fXXntNn/jEJyw9//rrr9dHPvIRbdq0SRUVFZKkZcuWjYWHP/7xj6OOnzlzplasWJH0nNu3b9dVV12lb33rW7rnnnusvSEAAIAiRRsyAABAnnr99dd1wQUXqLq6Wscdd5zOO+88bd68OeqYkZERNTc3a86cOfJ4PJo6daoWL16s9evXjx3T29urK664QrNmzVJlZaX8fr8uvvjiuC28mVJZWSmfz2fruf39/erq6tIll1wyFhRK0plnnqm5c+fqsccei/u8w4cP68CBAwnP+7Of/UzBYFC33HKLpNFW6XA4bOsaAQAAigVhIQAAQB5688039Td/8zd644039N3vflc33XSTenp69JnPfEZ//OMfx467+eab1dzcrHPOOUf33nuv/tf/+l868cQT1dHRMXbMF77wBT355JO64oor9NOf/lT/8i//on379um9995Leg3Dw8PavXu3qT+ZNDw8LEmaOHHiuO9NmjRJH374oXp7e6Mef+GFFzRp0iQdd9xxOvnkk+NWDm7YsEGnn366fve732nWrFmqqqrS1KlTddNNNykUCmXmzQAAAOQ52pABAADy0Pe//32NjIzo5Zdf1kc+8hFJ0uWXX67TTjtN3/3ud/XSSy9Jkn7729/qwgsv1P333x/3PHv37tUrr7yiu+66S//6r/869vgNN9yQ8hoeffRRXXHFFaauN5MVeTNmzNDxxx+vTZs2RT3e19enrq4uSdIHH3wwVrk4b948LV68WKeddpr6+vr08MMP65prrtGHH36oO++8c+z577zzjsrKynTFFVfou9/9rs4880z953/+p37wgx/oyJEjWr16dcbeEwAAQL4iLAQAAMgzwWBQv//97/X5z39+LCiURuf+XXrppXrggQc0ODio6upqHX/88XrzzTf1zjvvaM6cOePONXHiRFVUVOjFF1/UlVdeqSlTppi+js9+9rNR7cy54na79T//5//UnXfeqRtuuEFf+cpXNDg4qO9+97s6fPiwJOnQoUNjxz/zzDNRz7/iiit0wQUX6H//7/+tb33rW5o1a5ak0bbjUCikO+64Q9dff72k0SrM/v5+3XPPPbrxxhtVVVWVpXcJAACQH2hDBgAAyDN/+ctfdPDgQZ122mnjvjd37lyFQqGxbb233HKL9u7dq1NPPVVnnHGGrrvuOv3Xf/3X2PGVlZW688479eyzz2rGjBk6++yz9cMf/nBc2248fr9fS5YsMfUn02655RZdeeWV+uEPf6hTTz1VH//4xzVhwgRdeeWVkqTjjjsu4XNdLpeuvfZaHTlyJGoLs9HWvHz58qjjly9frkOHDun11193/o0AAADkOcJCAACAAnb22Weru7tbP//5z1VfX68HH3xQDQ0NevDBB8eOueaaa/TnP/9Zq1evlsfj0U033aS5c+emDMMOHTqk3t5eU38yraKiQg8++KA+/PBDbdy4UW+//baee+45DQwMyO1265RTTkn6/BNOOEHS6LIUw1//9V9LGm1zjjR9+nRJ0p49e5x8CwAAAAWBsBAAACDP/NVf/ZUmTZqkt99+e9z3/vSnP8ntdo+FX5JUU1OjK664Qo8++qjef/99zZs3TzfffHPU82bPnq3vfOc7+v3vf6/Ozk4dPnxYP/7xj5Nex+OPPy6/32/qT7bMmDFDf/M3f6NTTz1VwWBQL774oj75yU8mrSyUpP/+7/+WNPrZGhYsWCBpdN5hpA8//HDcsQAAAKWCmYUAAAB5pqysTOeff76efvppbd++XSeffLIkaefOnVq3bp0WL16s6upqSaNLPqZOnTr23OOOO06nnHLKWJvywYMH5Xa75fF4xo6ZPXu2qqqqxrYMJ5KrmYWBQEADAwOaPXu2ysvLEx73ox/9SIFAQP/n//yfscf6+/vl9XpVVlY29tjIyIjuuOMOVVRU6Jxzzhl7/O///u/12GOP6aGHHtJtt90mSQqFQvrFL36hmpqasTARAACglBAWAgAA5MjPf/5ztba2jnv86quv1g9+8AOtX79eixcv1j//8z9rwoQJuu+++zQ8PKwf/vCHY8fW1dXpM5/5jBYsWKCamhq99tpr+tWvfqVvfvObkqQ///nPOu+88/Q//sf/UF1dnSZMmKAnn3xSO3fu1Je//OWk1+d01eC9996rvXv3jlXutbS06P/9v/8nSfrWt74lr9craXRT8yOPPKKenp6xoHTt2rX69a9/rbPPPlvHHXecNmzYoP/4j//QV7/6VX3hC18Ye41nnnlGP/jBD/TFL35RtbW16u/v17p169TZ2anbb799bGOyJF188cU677zztHr1au3evVtnnnmmnnrqKb388su67777VFlZ6dh7BwAAKBSucDgczvVFAAAAlJKHH35YV1xxRcLvv//++5o1a5Zef/113XDDDdq0aZNCoZA++clP6rbbblNjY+PYsbfddpueeeYZ/fnPf9bw8LBOOukk/cM//IOuu+46lZeXq6+vT6tWrdLzzz+v999/XxMmTNDpp5+u73znO/rSl76Ujbc75uSTT9aOHTvifi8yGPynf/qncWFhe3u7rrvuOm3btk2HDh3SaaedppUrV+rrX/+6XC7X2Hm2bNmi5uZmdXR06C9/+YsqKio0f/58/cu//Evc97t//359//vf1+OPP67+/n6ddtppuv7663XZZZc5/v4BAAAKAWEhAAAAAAAAAEksOAEAAAAAAABwFGEhAAAAAAAAAEmEhQAAAAAAAACOIiwEAAAAAAAAIImwEAAAAAAAAMBRhIUAAAAAAAAAJEkTcn0BZoRCIX344YeqqqqSy+XK9eUAAAAAAAAABSUcDmvfvn3667/+a7ndiesHCyIs/PDDD3XCCSfk+jIAAAAAAACAgvb+++9r1qxZCb9fEGFhVVWVpNE3U11dneOrcd7IyIh+//vf6/zzz1d5eXmuLwcwhfsWhYp7F4WI+xaFinsXhYj7FoWKexepDA4O6oQTThjL2RIpiLDQaD2urq4u2rBw0qRJqq6u5hcaBYP7FoWKexeFiPsWhYp7F4WI+xaFinsXZqUa8ceCEwAAAAAAAACSCAsBAAAAAAAAHEVYCAAAAAAAAEASYSEAAAAAAACAowgLAQAAAAAAAEgiLAQAAAAAAABwFGEhAAAAAAAAAEmEhQAAAAAAAACOIiwEAAAAAAAAIImwEAAAAAAAAMBRhIUAAAAAAAAAJBEWAgAAAAAAADiKsBAAAAAAAACAJMJCAAAAAAAAAEcRFgIAAAAAAACQRFgIAAAAAAAA4CjCQgAAAAAAAACSCAsBAAAAAAAAHEVYCAAAAAAAAEASYSEAAAAAAACAowgLcywYCqu9p1+S1N7Tr2AonOMrAgAAAAAAQKkiLMyh1s6AFt/5gr7yyKuSpK888qoW3/mCWjsDOb4yAAAAAAAAlCLCwhxp7Qxo5doOBQaGoh7vHRjSyrUdBIYAAAAAAADIOsLCHAiGwmpu6VK8hmPjseaWLlqSAQAAAAAAkFWEhTnQ3tM/rqIwUlhSYGBobJYhAAAAAAAAkA2EhTmwa1/ioDBS78ChDF8JAAAAAAAAcAxhYQ5Mr/KYOu7W377F7EIAAAAAAABkDWFhDiysrZHf65ErxXF7Dhxm2QkAAAAAAACyhrAwB8rcLq1aVpfyOJadAAAAAAAAIJsIC3Okqd6vNSsaVDO5POlxxrKThzf1EBgCAAAAAAAgowgLc6ip3q+b/vajpo699bdvafGdL9CSDAAAAAAAgIwhLMwxX7W5ZSeS1DswxAxDAAAAAAAAZAxhYY4trK0xHRgywxAAAAAAAACZRFiYY2Vul753wemSlHI7snRshmF7T39GrwsAAAAAAAClh7AwDyyZO0OSNMNCS/KufUOZuhwAAAAAAACUKMLCPPLcNWfrpovmmjp2epX5YBEAAAAAAAAwg7Awj5S5Xfqns2rl93oStiS7JPm9Hi2srcnmpQEAAAAAAKAEEBbmmTK3S6uW1UkaP8PQ+Nr4flt3n57e+oHauvtYeAIAAAAAAIC0Tcj1BWC8pnq/1qxoUHNLlwIDx2YT+ryesaBw8Z0vRH3Pf/R7TfX+rF8vAAAAAAAAigNhYZ5qqvdraZ1P7T392rVvSNOrRluP13f1auXaDsXWEfYODGnl2g6tWdFAYAgAAAAAAABbCAvzWJnbpcbZUyVJwVBYm7v79L1fbxsXFEpSWKNtys0tXVpa51OZO9HUQwAAAAAAACA+wsIC0NoZGNeSHE9YUmBgSO09/WMhIwAAAAAAAGAWYWGea+0MxG07TmbXvuShIgAAAAAAABAP25DzWDAUVnNLl6WgUJKmV3kycj0AAAAAAAAoboSFeay9pz9l63GsmsnlWnDSlAxdEQAAAAAAAIoZYWEes9NO3H9gRJ++6w9q7Qxk4IoAAAAAAABQzAgL85jdduLegSGtXNtBYAgAAAAAAABLCAvz2MLaGvm9HrksPi989M/3fr1Nm97drWDI6tRDAAAAAAAAlCLCwjxW5nZp1bI6SbIcGErS3kMjuuzBP2rxnS9QZQgAAAAAAICUCAvzXFO9X2tWNMjnjW5JPn5iuelz0JYMAAAAAAAAMybk+gKQWlO9X0vrfGrv6deufUOaXuVRKBzWZQ/+0dTzjSbkG5/cpnNPn6GKCWTEAAAAAAAAGI+wsECUuV1qnD117OtgKCy/16PegSGZnUjYf2BEi1Y/r9svqVdTvT8zFwoAAAAAAICCRYlZgbI7z7D/wGF9Y22Hbm15U23dfSw/AQAAAAAAwBjCwgKWaJ6hGQ9t2q7lD2xm+QkAAAAAAADGEBYWuKZ6v16+/lz98spPWlp6YmD5CQAAAAAAAAyEhUWgzO3SWXOm6Y4vnGGpJVk6tvykuaWLlmQAAAAAAIASR1hYRIy25JrJ1ioMw5ICA0Nq7+nPzIUBAAAAAACgIBAWFpmmer8237BENZMrLD93176hDFwRAAAAAAAACgVhYRGqmODW7ZfUyyVrm5KnV1lflAIAAAAAAIDiQVhYpKxsSnZJ8ns9Wlhbk/kLAwAAAAAAQN6akOsLQOY01fu1tM6n9p5+re/q1c83bZdLx5aaGMKSvvyJE3JwhQAAAAAAAMgnVBYWuTK3S42zp+rfln1UP0tSaXj3hne0+M4X1NoZkCQFQ2G1dffp6a0fqK27j03JAAAAAAAAJYDKwhJiVBre+8K7unvDn8d9v3dgSCvXdujrZ9fqmTcCCgwcW3ji93q0almdmur92bxkAAAAAAAAZBGVhSXosVffi/t4+Oif+zb2RAWF0rEg0ag8BAAAAAAAQPEhLCwx7T3944JAM4wm5OaWLlqSAQAAAAAAihRhYYnZtc96UGgISwoMDKm9p9+5CwIAAAAAAEDeICwsMdOr4i84sSKdwBEAAAAAAAD5i7CwxCysrZHf65ErjXM4ETgCAAAAAAAg/xAWlpgyt0urltVJkuXA0KXRrcgLa2scvy4AAAAAAADkHmFhCWqq92vNigb5vNYrBFctq1OZO526RAAAAAAAAOQrwsIS1VTv18vXn6tfXvlJHT+xPOXxfq9Ha1Y0qKnen4WrAwAAAAAAQC4QFpawMrdLZ82Zpju+cIZcStyWfO2SOXrpunPknVihp7d+oLbuPgVD4WxeKgAAAAAAALJgQq4vALlntCU3t3QpMHBs07Hf6xmbb/jpu/4Q93tUGgIAAAAAABQPwkJIGg0Ml9b51N7Tr137hjS9anSRyfquXq1c26HYOsLegSGtXNtBazIAAAAAAEARISzEmDK3S42zp459HQyF1dzSNS4olKSwRtuWm1u6tLTOx9ITAAAAAACAIsDMQiTU3tMf1XocKywpMDCk9p7+7F0UAAAAAAAAMoawEAnt2pc4KIzUO3Aow1cCAAAAAACAbCAsRELTqzymjrv1t2+ptTOQ4asBAAAAAABAphEWIqGFtTXyez1KNY1wz4HDWrm2g8AQAAAAAACgwBEWIqEyt0urltWlPM5YgNLc0qXDR0Jq6+7T01s/UFt3n4KheOtRAAAAAAAAkI/Yhoykmur9WrOiQTc+uU39B0YSHmcsO1nwg/XaN3Rk7HG/16NVy+rUVO/PwtUCAAAAAAAgHWlVFt5xxx1yuVy65pprEh7z8MMPy+VyRf3xeMzNwkN+aKr366a//aipYyODQknqHRiiRRkAAAAAAKBA2K4sfPXVV3Xfffdp3rx5KY+trq7W22+/Pfa1y5VqCh7yja/aXsAbluTSaIvy0jqfytz87AEAAAAAAPKVrcrC/fv367LLLtMDDzygKVOmpDze5XLJ5/ON/ZkxY4adl0UOmV12Eo/Rotze0+/0ZQEAAAAAAMBBtioLr7rqKl100UVasmSJfvCDH6Q8fv/+/TrppJMUCoXU0NCg22+/XR/9aOK21uHhYQ0PD499PTg4KEkaGRnRyEjiuXmFynhP+f7e/u2i03Tt41slHVtqYsWugQMaGal29JqQO4Vy3wKxuHdRiLhvUai4d1GIuG9RqLh3kYrZe8MVDoct5T6PPfaYbrvtNr366qvyeDz6zGc+o/nz5+snP/lJ3OPb2tr0zjvvaN68eRoYGNCPfvQjbdy4UW+++aZmzZoV9zk333yzmpubxz2+bt06TZo0ycrlAgAAAAAAACXv4MGDuvTSSzUwMKDq6sTFXJbCwvfff18f//jHtX79+rFZhanCwlgjIyOaO3euli9frltvvTXuMfEqC0844QTt3r076ZspVCMjI1q/fr2WLl2q8vLyXF9OSsFQWOv+uEN3Pvd26oM1OrNwRrVHz11zNjMLi0ih3beAgXsXhYj7FoWKexeFiPsWhYp7F6kMDg5q2rRpKcNCS23IW7Zs0a5du9TQ0DD2WDAY1MaNG3XvvfdqeHhYZWVlSc9RXl6uj33sY3r33XcTHlNZWanKysq4zy3mG75Q3l+5pH9cfIoe2PSeegeGkrYkG9HgDRd9VJ7KiixcHbKtUO5bIBb3LgoR9y0KFfcuChH3LQoV9y4SMXtfWFpwct5552nbtm3aunXr2J+Pf/zjuuyyy7R169aUQaE0Gi5u27ZNfr/fyksjz5S5XVq1rE6Ski498Xk9WrOiQU31/LwBAAAAAADynaXKwqqqKtXX10c9NnnyZE2dOnXs8csvv1wzZ87U6tWrJUm33HKLFi1apFNOOUV79+7VXXfdpR07duirX/2qQ28BudJU79eaFQ1qbulSYGBo7PGayeW6ZP5MLanzaWFtDa3HAAAAAAAABcLWNuRk3nvvPbndxwoW9+zZo6997Wvq7e3VlClTtGDBAr3yyiuqq6tz+qWRA031fi2t86m9p1+79g1pepUnKiAMhsJq6+5L+L1EzwMAAAAAAED2pR0Wvvjii0m/vvvuu3X33Xen+zLIY2VulxpnTx33eGtnYFzVod/rGWtfTvQ9WpYBAAAAAAByw/HKQkAaDQpXru0Yt/ykd2BI31jbEfc5vQNDWrm2gxmHAAAAAAAAOWJpwQlgRjAUVnNLV9wtyck2Jxvfa27pUjCU7EgAAAAAAABkAmEhHNfe0x/VXmxFWFJgYEjtPf3OXhQAAAAAAABSIiyE43btsxcUOn0OAAAAAAAAWENYCMdNr/LkxTkAAAAAAABgDWEhHLewtkZ+r0cuG891aXQr8sLaGqcvCwAAAAAAACkQFsJxZW6XVi2rk6RxgaErwf+O/HrVsjqVue1EjQAAAAAAAEgHYSEyoqnerzUrGuTzRrcTT5lcrivPOlnXLjlVM6qjv+fzerRmRYOa6v3ZvFQAAAAAAAAcNSHXF4Di1VTv19I6n9p7+rW+q1dPbf1Q/QcO66FN2yVJvupKXbtkjk6eNlnTq0Zbj6koBAAAAAAAyB0qC5FRZW6XBg4d1i82bVf/gcNR39s5OKyfbHhHlRPcapw9laAQAAAAAAAgxwgLkVHBUFjNLV0Kx/me8VhzS5eCoXhHAAAAAAAAIJsIC5FR7T39CgwMJfx+WFJgYEjtPf3ZuygAAAAAAADERViIjNq1L3FQaOc4AAAAAAAAZA5hITJqepUn9UEWjgMAAAAAAEDmEBYioxbW1sjv9SjR6hKXJL93dBMyAAAAAAAAcouwEBlV5nZp1bI6SRoXGBpfr1pWxyZkAAAAAACAPEBYiIxrqvdrzYoG+bzRrcY+r0drVjSoqd6foysDAAAAAABApAm5vgCUhqZ6v5bW+dTe069d+4Y0vWq09dioKAyGwgm/BwAAAAAAgOwgLETWlLldapw9ddzjrZ0BNbd0KTBwbCOyr7pSyxeeqJOnTSY8BAAAAAAAyBLCQuRUa2dAK9d2KBzzeO/gsO7e8M7Y136vR6uW1dGyDAAAAAAAkEHMLETOBENhNbd0jQsK4+kdGNLKtR1q7Qxk/LoAAAAAAABKFWEhcqa9pz+q9TgZI1BsbulSMGQmXgQAAAAAAIBVtCEjZ3btMxcUGsKSAgND2tzdJ7fbxTIUAAAAAAAAhxEWImemV3lsPe+qdR3ae2hk7GvmGQIAAAAAADiDNmTkzMLaGvm9HlmtCYwMCiXmGQIAAAAAADiFsBA5U+Z2adWyOkmyHBhGYp4hAAAAAACAMwgLkVNN9X6tWdEgn9deS7LBmGfY3tPvzIUBAAAAAACUIGYWIuea6v1aWudTe0+/du0b0vbdB7Xujzu0c9+w5XNZXZoCAAAAAACAYwgLkRfK3C41zp469vXHT56iyx78o+Xz2F2aAgAAAAAAAMJC5Knd+61VFbok+bweLaytycwFAQAAAAAAlABmFiIvWakQNJajrFpWpzJ3OqtSAAAAAAAAShthIfLSwtoa+b0eU1uSfV6P1qxoUFO9P+PXBQAAAAAAUMxoQ0ZeKnO7tGpZnVau7ZBLo9uOY1151slaUufTwtoaKgoBAAAAAAAcQGUh8lZTvV9rVjTI541uSfZ7PfrZigbdtOyjapw9laAQAAAAAADAIVQWIq811fu1tM6n9p5+7do3pOlVHioJAQAAAAAAMoSwEHmvzO1S4+ypub4MAAAAAACAokcbMgAAAAAAAABJhIUAAAAAAAAAjiIsBAAAAAAAACCJsBAAAAAAAADAUYSFAAAAAAAAACQRFgIAAAAAAAA4akKuLwBwUjAUVntPv3btG9L0Ko8W1taozO3K9WUBAAAAAAAUBMJCFI3WzoCaW7oUGBgae8zv9WjVsjo11ftzeGUAAAAAAACFgTZkFIXWzoBWru2ICgolqXdgSCvXdqi1M5CjKwMAAAAAACgchIUoeMFQWM0tXQrH+Z7xWHNLlw4fCamtu09Pb/1Abd19CobiPQMAAAAAAKB00YaMgtfe0z+uojBSWFJgYEiLVj+v/gOHxx6nRRkAAAAAACAalYUoeLv2JQ4KI0UGhRItygAAAAAAALEIC1Hwpld5bD0vfPTPjU9u0+EjIUevCQAAAAAAoBARFqLgLaytkd/rkcvm8/sPjGjR6uepMAQAAAAAACWPsBAFr8zt0qpldZKURmB4mJZkAAAAAABQ8ggLURSa6v1as6JBPm90S3LN5HJL52lu6WJLMgAAAAAAKFlsQ0bRaKr3a2mdT+09/dq1b0jTqzxacNIUffquP6h3YEipIkBja3J7T78aZ0/NxiUDAAAAAADkFcJCFJUyt2tc0LdqWZ1Wru0wfQ6z25UBAAAAAACKDW3IKFrBUFht3X0aPhLSNUtO1ZRJ5lqS7W5XBgAAAAAAKHRUFqIotXYG1NzSpcDAsSrBGVUVOq5ygvYPH4n7HJckn9ejhbU1WbpKAAAAAACA/EJYiKLT2hnQyrUd42YU7tp3eOwxlxT1fWOL8qpldSpz292pDAAAAAAAUNhoQ0ZRCYbCam7pirvMJKzRUPD4SeWaUR3dauzzerRmRYOa6v3ZuEwAAAAAAIC8RGUhikp7T39U63GssKS9B0f0yysb5Ha7xrYmL6ytoaIQAAAAAACUPMJCFBWzm4x3HxjWxfNnZvhqAAAAAAAACgthIYqK2U3GsccFQ2G19/RTaQgAAAAAAEoaYSGKysLaGvm9HvUODMWdWxhv43G8zcl+r0erltUxwxAAAAAAAJQUFpygqJS5XVq1rE7SsQ3Hhngbj43NybFzDnsHhrRybYdaOwMZvmIAAAAAAID8QViIotNU79eaFQ3yeZNvPE61OVmSmlu6FAzFOwIAAAAAAKD40IaMotRU79fSOl/SOYRmNicHBobU3tOvxtlTs3DVAAAAAAAAuUVYiKJV5nYlDfnMbk42exwAAAAAAEChow0ZJcvu5mQAAAAAAIBiRViIkmVsTo5dhGJwaXQrcuTmZAAAAAAAgGJGWIiSZXVzMgAAAAAAQLEjLERJM7s5GQAAAAAAoBSw4AQlz8zmZAAAAAAAgFJAWAgo9eZkAAAAAACAUkAbMgAAAAAAAABJhIUAAAAAAAAAjiIsBAAAAAAAACCJsBAAAAAAAADAUSw4ASwIhsJsTQYAAAAAAEWLsBAwqbUzoOaWLgUGhsYe83s9WrWsTk31/hxeGQAAAAAAgDNoQwZMaO0MaOXajqigUJJ6B4a0cm2HWjsDOboyAAAAAAAA5xAWAikEQ2E1t3QpHOd7xmPNLV0KhuIdAQAAAAAAUDhoQwZixM4lPBIMjasojBSWFBgYUntPvxpnT83ehQIAAAAAADiMsBCIEG8uodn1Jbv2JQ4UAQAAAAAACkFabch33HGHXC6XrrnmmqTHPfHEEzr99NPl8Xh0xhln6He/+106LwuMCYbCauvu09NbP1Bbd19arcCJ5hKaPeP0Ko/t1wYAAAAAAMgHtisLX331Vd13332aN29e0uNeeeUVLV++XKtXr9bf/u3fat26dfr85z+vjo4O1dfX2315wNHtxMnmEqbikuTzerSwtsbGswEAAAAAAPKHrcrC/fv367LLLtMDDzygKVOmJD32nnvuUVNTk6677jrNnTtXt956qxoaGnTvvffaumBAcn47cXtPf9K5hKmsWlanMrfZhmUAAAAAAID8ZKuy8KqrrtJFF12kJUuW6Ac/+EHSY9va2vTtb3876rHPfvazeuqppxI+Z3h4WMPDw2NfDw4OSpJGRkY0MjJi55LzmvGeivG9ZUIwFNbq376pirL4dYAuSat/+6Y+M2eq6QBv18ABVSY4XzLHTyzXzZ/7qM47bVrJ/fy4b1GouHdRiLhvUai4d1GIuG9RqLh3kYrZe8NyWPjYY4+po6NDr776qqnje3t7NWPGjKjHZsyYod7e3oTPWb16tZqbm8c9/vvf/16TJk2ydsEFZP369bm+hILx7dNTHXFAz7U+a+mcP1xo50qCOtyzRb/rsfPc4sB9i0LFvYtCxH2LQsW9i0LEfYtCxb2LRA4ePGjqOEth4fvvv6+rr75a69evl8eTuWUON9xwQ1Q14uDgoE444QSdf/75qq6uztjr5srIyIjWr1+vpUuXqry8PNeXk/d+ty2g7/76v1Ie98MvzNOFZ5ibXRgMhfXZn2zUzsEhU3MLXZJmVHv03DVnl2z7MfctChX3LgoR9y0KFfcuChH3LQoV9y5SMTp3U7EUFm7ZskW7du1SQ0PD2GPBYFAbN27Uvffeq+HhYZWVlUU9x+fzaefOnVGP7dy5Uz6fL+HrVFZWqrKyctzj5eXlRX3DF/v7c8p072QNB1MHdNO9k01/nuWSbrjoo1q5tkNS8g3IxivfcNFH5amsMHX+YsZ9i0LFvYtCxH2LQsW9i0LEfYtCxb2LRMzeF5YWnJx33nnatm2btm7dOvbn4x//uC677DJt3bp1XFAoSY2NjXr++eejHlu/fr0aGxutvDQwZmFtjfxejxLFhS6NbkW2up24qd6vNSsa5PNGV83GFg76vB6tWdFgeeMyAAAAAABAvrNUWVhVVaX6+vqoxyZPnqypU6eOPX755Zdr5syZWr16tSTp6quv1qc//Wn9+Mc/1kUXXaTHHntMr732mu6//36H3gJKTZnbpVXL6rRybYdciq4CNHI9u9uJm+r9WlrnU3tPv3btG9L0Ko8WnDRFW3bsGft6YW1NybYeAwAAAACA4mZrG3Iy7733ntzuYwWLn/rUp7Ru3Tp9//vf14033qg5c+boqaeeGhc6AlYYVYDNLV0KDAyNPe7zerRqWV1aVX9lbpcaZ0+Neiz2awAAAAAAgGKUdlj44osvJv1akr70pS/pS1/6UrovBUSJVwVI1R8AAAAAAIB9jlcWAtkUrwoQAAAAAAAA9lhacAIAAAAAAACgeBEWAgAAAAAAAJBEWAgAAAAAAADgKGYWAg4JhsIsWwEAAAAAAAWNsBBIgxEQru/q1VNbP1T/gcNj3/N7PVq1rE5N9f4cXiEAAAAAAIB5hIWATa2dATW3dCkwMBT3+70DQ1q5tkNrVjQQGAIAAAAAgILAzELAhtbOgFau7UgYFEpS+Oj/bW7pUjAUTngcAAAAAABAviAsBCwKhsJqbumSmfgvLCkwMKT2nv5MXxYAAAAAAEDaCAsBi9p7+pNWFMaz6d2/UF0IAAAAAADyHmEhYNGufdaCQkm69w/dWnznC2rtDGTgigAAAAAAAJxBWAhYNL3KY+t5xsITAkMAAAAAAJCvCAsBixbW1sjv9chl8XksPAEAAAAAAPmOsBCwqMzt0qpldZJkKzBk4QkAAAAAAMhXhIWADU31fq1Z0SCfN7oleXJlmann25l7CAAAAAAAkGkTcn0BQKFqqvdraZ1P7T392rVvSNOrPAqFw7rswT+mfK7duYcAAAAAAACZRFgIpKHM7VLj7KljXwdDYfm9HvUODCneVEKXJJ/Xo4W1NVm7RgAAAAAAALNoQwYclGyeofH1qmV1KnNbnXYIAAAAAACQeYSFgMMSzTP0eT1as6JBTfX+HF0ZAAAAAABAcrQhAxkQb57hwtoaKgoBAAAAAEBeIywEMiR2niEAAAAAAEC+ow0ZAAAAAAAAgCTCQgAAAAAAAABH0YYM5FgwFGa2IQAAAAAAyAuEhUAOtXYG1NzSpcDA0Nhjfq9Hq5bVsTUZAAAAAABkHW3IQI60dga0cm1HVFAoSb0DQ1q5tkOtnYEcXRkAAAAAAChVhIVADgRDYTW3dCkc53vGY80tXQqG4h0BAAAAAACQGYSFQA609/SPqyiMFJYUGBhSe09/9i4KAAAAAACUPMJCIAd27UscFEba9O5fqC4EAAAAAABZQ1gI5MD0Ko+p4+79Q7cW3/kC8wsBAAAAAEBWEBYCObCwtkZ+r0cuE8ey8AQAAAAAAGQLYSGQA2Vul1Ytq5OklIEhC08AAAAAAEC2EBYCOdJU79eaFQ3yeVO3JLPwBAAAAAAAZANhIZADwVBYbd19Gj4S0o++eKauOme2qeeZXYwCAAAAAABgx4RcXwBQalo7A2pu6VJg4FjwVzO53NRzzS5GAQAAAAAAsIOwEMii1s6AVq7tUOzkwf4DI0mf55Lk83q0sLYmY9cGAAAAAABAGzKQJcFQWM0tXeOCwlixC0+Mr1ctq1OZ28z+ZAAAAAAAAHsIC4Esae/pj2o9TmTK5Iqor31ej9asaFBTvT9TlwYAAAAAACCJNmQga8wuJ7npornyeSdq174hTa8abT2mohAAAAAAAGQDYSGQJWaXk/i8E9U4e2qGrwYAAAAAAGA82pCBLFlYWyO/1zNuJqHBJcnPEhMAAAAAAJBDhIVAlpS5XVq1rE4SS0wAAAAAAEB+IiwEsqip3q81Kxrk80a3JLPEBAAAAAAA5ANmFgJZ1lTv19I6n9p7+lliAgAAAAAA8gphIZADZW4XS0wAAAAAAEDeoQ0ZAAAAAAAAgCTCQgAAAAAAAABHERYCAAAAAAAAkERYCAAAAAAAAOAowkIAAAAAAAAAktiGDGRFMBRWe0+/du0b0vQqjxbW1qjM7Sqa1wMAAAAAAMWBsBDIsNbOgJpbuhQYGBp7zO/1aNWyOjXV+22fN1EgmKnXAwAAAAAAxY+wEMig1s6AVq7tUDjm8d6BIa1c26E1KxpsBXiJAsHPnenX/Rt7HH89AAAAAABQGphZCGRIMBRWc0vXuOBO0thjzS1dCobiHZGYEUBGBoWSFBgY0n1xgsJ0Xw8AAAAAAJQOwkIgQ9p7+scFepHCGg342nv6TZ8zWQCZip3XAwAAAAAApYWwEMiQXfsSB4V2jpNSB5BOvx4AAAAAACgthIVAhkyv8jh6nORM0Gfl9QAAAAAAQGkhLAQyZGFtjfxej1wJvu/S6FKShbU1ps+ZTtBn5/UAAAAAAEBpISwEMqTM7dKqZXWSNC4wNL5etaxOZe5EceJ4qQLIROy+HgAAAAAAKC2EhUAGNdX7tWZFg3ze6IpAn9ejNSsa1FTvt3S+ZAFkMnZfDwAAAAAAlJYJub4AoNg11fu1tM6n9p5+7do3pOlVo63Adiv8jACyuaXL9LKTH33xTJ01Z5qt1wMAAAAAAKWDsBDIgjK3S42zpzp2PiOAvHv9n3XvH95NefzuA8OOvTYAAAAAAChetCEDBarM7dJZp5irFmQDMgAAAAAAMIOwEChgmdi4DAAAAAAAShdhIVDAMrFxGQAAAAAAlC7CQqCABENhtXX36emtH6itu0/BUNjxjcsAAAAAAKB0seAEKBCtnYFxG5D9Xo9WLatzfOMyAAAAAAAoTYSFQAFo7Qxo5doOhWMe7x0Y0sq1HWMVhE5uXAYAAAAAAKWHNmQgzwVDYTW3dI0LCiWNPdbc0qVgKN4RAAAAAAAA5hEWAnmuvac/qvU4VlhSYGBI7T392bsoAAAAAABQlGhDBvLcrn2Jg0I7x8UKhsLMOgQAAAAAAJIIC4G8N73Kk/ogC8dFSrU0BQAAAAAAlBbakIE8t7C2Rn6vR4lq/VwaDfgW1tZYOq+xNCW2xdlYmtLaGbB3wQAAAAAAoGARFgJ5rszt0qpldZI0LjA0vl61rM5S6zBLUwAAAAAAQDyEhUABaKr3a82KBvm80a3GPq9Ha1Y0WG4ZZmkKAAAAAACIh5mFQIFoqvdraZ3PkWUkmV6aAgAAAAAAChNhIVBAytwuNc6emvZ5Mrk0BQAAAAAAFC7akIESlKmlKQAAAAAAoLARFgIlKBNLUzBeMBRWW3efnt76gdq6+1gYAwAAAADIe7QhAyXKWJrS3NIVtezE5/Vo1bI6y0tTEK21MzDus/Xz2QIAAAAA8hxhIVDCnFyagmNaOwNaubZDsXWEvQNDWrm2w9YGawAAAAAAsoGwEChxTi1NwahgKKzmlq5xQaEkhTXa5t3c0qWldT5CWQAAAABA3rE0s3DNmjWaN2+eqqurVV1drcbGRj377LMJj3/44Yflcrmi/ng8bFcFcok5epnV3tMf1XocKywpMDCk9p7+7F0UAAAAAAAmWaosnDVrlu644w7NmTNH4XBYjzzyiC6++GK9/vrr+uhHPxr3OdXV1Xr77bfHvna5qKQBcoU5epm3a1/ioNDOcQAAAAAAZJOlsHDZsmVRX992221as2aNNm/enDAsdLlc8vl89q8QgCOYo5cd06vMVU+bPQ4AAAAAgGyyPbMwGAzqiSee0IEDB9TY2JjwuP379+ukk05SKBRSQ0ODbr/99oTBomF4eFjDw8NjXw8ODkqSRkZGNDIyYveS85bxnorxvSE/BENhrf7tm6ooi99y7JK0+rdv6jNzppqeo8d9G9/HZlXppCmV2jk4FHduoUvSjGqPPjaris8uR7h3UYi4b1GouHdRiLhvUai4d5GK2XvDFQ6HLQ0s27ZtmxobGzU0NKTjjjtO69at04UXXhj32La2Nr3zzjuaN2+eBgYG9KMf/UgbN27Um2++qVmzZiV8jZtvvlnNzc3jHl+3bp0mTZpk5XIBAAAAAACAknfw4EFdeumlGhgYUHV1dcLjLIeFhw8f1nvvvaeBgQH96le/0oMPPqiXXnpJdXV1KZ87MjKiuXPnavny5br11lsTHhevsvCEE07Q7t27k76ZQjUyMqL169dr6dKlKi8vz/XloAj9bltA3/31f6U87odfmKcLzzDXisx9m9yGt3bqjmf/pN7BY7MJfdUefe+C07Vk7owcXhm4d1GIuG9RqLh3UYi4b1GouHeRyuDgoKZNm5YyLLTchlxRUaFTTjlFkrRgwQK9+uqruueee3TfffelfG55ebk+9rGP6d133016XGVlpSorK+M+v5hv+GJ/f8idadWTNBxM3V483TvZ8j0Ye98GQ2G19/Rr174hTa/yaGFtjenW5mJywbxZOr9+Jp9FHuOfuShE3LcoVNy7KETctyhU3LtIxOx9YXtmoSEUCkVVASYTDAa1bdu2hG3LAJzX2hnQzc+8mfQYlySfdzTMSve12LZ8TJnbpcbZU3N9GQAAAAAAmGYpLLzhhht0wQUX6MQTT9S+ffu0bt06vfjii3ruueckSZdffrlmzpyp1atXS5JuueUWLVq0SKeccor27t2ru+66Szt27NBXv/pV598JgHESbUCOZNS5rVpWl1bVG9uWAQAAAAAofJbCwl27dunyyy9XIBCQ1+vVvHnz9Nxzz2np0qWSpPfee09ut3vs+D179uhrX/uaent7NWXKFC1YsECvvPKKqfmGANITDIXV3NKVNCiURisKjco/uy3EyV4rrNFAsrmlS0vrfLThAgAAAACQxyyFhQ899FDS77/44otRX9999926++67LV8UgPS19/RHtQMn8qMvnqmz5kyL20JcM7lcl8yfqSV1vqTBYarXCksKDAypvaeftlwAAAAAAPJY2jMLAeSnXftSB4WStPvAcMIW4v4DI3po03Y9tGl70tmDZl/L7HGpsEQFAAAAAIDMICwEitT0Ko+p46ZNrtS//uqNlO3KyWYPmn0ts8clwxIVAAAAAAAyx536EACFaGFtjfxejxLV27k0GrLJJVPtykaY2NzSpWAoOlo0+1pObFteubZj3PUaQWZrZyCt8wMAAAAAUOoIC4EiVeZ2adWy0WVCsSFe5Abk3fuHTZ/TmD24ubtP7T39kjT2f828VjqtwqmWqEjxg0wAAAAAAGAeYSFQxJrq/VqzokE+b3T7r8/rGWsnttMafNW6Dn3lkVclSV955FUtvvMFSUr5WumwskQFAAAAAADYw8xCoMg11fu1tM6XcCGI0ULcOzCUcm6hYe+hEVWWHfs6cp7hy9efm5HlI9leogIAAAAAQCkiLARKQJnbpcbZUxN+b9WyOq1c22H7/GGNths3t3RpaZ0v4WulI5tLVAAAAAAAKFW0IQMYa1f2e+0HbZluA87WEhUAAAAAAEoZYSEASaOB4cvXn6tHv7ZIXznrZNVMroj6/vETy02dJ1NtwGYXtjjR8gwAAAAAQKmiDRnAGKNduXH2VP2vi+qiZg+GwmFd9uAfU54jk23ARgVkc0tX1LITn9ejVcvq0l6iAgAAAABAqSMsBPJYMBTOyLIQM2LnHAZD4aSLUFwaDe0y3QacamELAAAAAACwj7AQyFOtnYFxFXT+HFbQRS5CyXUbcLKFLQAAAAAAwD5mFgJ5qLUzoJVrO6KCQknqHRjSyrUdau0M5OS6jDZgX8wiFJ/XozUrGmgDBgAAAACgwFFZCOSZYCis5pauuK2+YY1W8TW3dGlpnS8nrbdGG/Dmd3dp91ub9fN//IQWnTKdNmAAAAAAAIoAlYVAnmnv6R9XURgpLCkwMKT2nv7sXVSMMrdrbDZhOvMCg6Gw2rr79PTWD9TW3adgKF5ECgAAAAAAsoXKQiDP7NqXOCi0c5xTYpetfGxWVVrny7eZjAAAAAAAgLAQyDvTqzypD7JwnBPiBXsnTanUt0+3f76VazvGtVobMxmZfwgAAAAAQG7QhgzkmYW1NfJ7PeM2DhtcGq3AM9qAMy3RspWdg6Nfb3hrp6XzpZrJKI3OZKQlGQAAAACA7CMsBPJMmdulVcvqJGlcYGh8vWpZXVYWipgJ9u549k86fCRkevZgIcxkBAAAAACgVNGGDOShpnq/1qxoGNf668vyTL9UwZ4k9Q4OadHq59V/4PDYY8lmD+brTEYAAAAAAEBYCOStpnq/ltb5opaKpLN52A6zgV1kUCglnz2YjzMZAQAAAADAKMJCII+VuV1qnD01Z69vN7ALa7RlurmlS0vrfFEBpzGTsXdgKG57s0ujFZTZmskIAAAAAACOYWYhgIRSLVtJJtHswXyayQgAAAAAAKIRFgJIKFmwZ1a8VmZjJqPPG1256PN64rYuAwAAAACA7KANGUBSiZatTJlULimY8vmJWpnzYSYjAAAAAACIRlgIIKV4wd68vz5OG37fmrDi0MzswVzPZAQAAAAAANEICwGYEhvsjYyMjP1vlxS1rITZgwAAAAAAFCZmFgJIy91/P5/ZgwAAAAAAFAkqCwGkZcncGTq/fiazBwEAAAAAKAKEhQDS5sTswWAoTOAIAAAAAECOERYCyLnWzsC4bct+r0erltXRygwAAAAAQBYxsxBATrV2BrRybUdUUChJvQNDWrm2Q62dgRxdGQAAAAAApYewEEDOBENhNbd0RW1SNhiPNbd0KRiKdwQAAAAAAHAaYSGAjAqGwmrr7tPTWz9QW3dfVPDX3tM/rqIwUlhSYGBI7T39WbhSAAAAAADAzEIAGZNqFuGufYmDwkhmjwMAAAAAAOmhshBARpiZRTi9ymPqXGaPAwAAAAAA6SEsBOA4s7MIF5w0RX6vR64E53FptBJxYW1NZi4UAAAAAABEISwE4Dizswi37NijVcvqJCluYBiWdGG9T+09/Sw5AQAAAAAgCwgLATjOyizCpnq/1qxokM8b3WrsPpoePrRpu5Y/sFmL73xBrZ0Bpy8VAAAAAABEICwE4DizMwanTa6UJDXV+/Xy9efq0a8t0lfOOlmSFFtIGDnrEAAAAAAAZAZhIQDHLaytSTqL0PCdJ94YC//K3C4trK3Rs529cY+NnHVISzIAAAAAAJlBWAjAcWVuV9JZhIadg9HVgmZnHbb39Dt4taOCobDauvv09NYP1NbdRyAJAAAAAChJE3J9AQCKkzGL8OZn3lTv4HDcY8IaDRObW7q0tM5nadahk1o7A2pu6YoKKv1ej1Ytq1NTvd/R1wIAAAAAIJ9RWQggY5rq/frx/5if9JjIakGzsw7NHmdGa2dAK9d2jKtoZEYiAAAAAKAUERYCyKjd++NXFcbatW8o5axDl0Yr/hbW1ti6lthW48NHQmpu6VK8hmNmJAIAAAAAShFtyAAyykq1oDHrcOXaDrmkqBDPCBBXLatTmTvV6pTx4rUa10wuV/+BkYTPiax6bJw91fJrAgAAAABQaKgsBJBRVqsFjVmHPm90yOjzerRmRYOtGYKJWo2TBYWRnJ6RCAAAAABAvqKyEEBG2akWbKr3a2mdT+09/dq1b0jTq0bDRDsVhcFQOGGrsVlOzkgEAAAAACCfERYCyDijWjC2DdiXZONwmduVdutvMBTWw5t6xlUUmuU6eo12ZyQCAAAAAFBoCAsBZIWT1YJmxJtRaEW6MxIBAAAAAChEhIUAssaJakEzjBmFVlqPayZXqP/A4bGvk1U9AgAAAABQrAgLARSVw0dCuvHJTtNBodFq/NJ152jLjj1ZqXoEAAAAACBfERYCKBqtnQHd+OQ201uOI1uNKya4s1L1CAAAAABAPiMsBFAU7LQe02oMAAAAAEA0wkIABS8YCqu5pctSUHjTRXP1T2fV0moMAAAAAEAEwkIABS0YCuvhTT2mtx4bMwoJCgEAAAAAGI+wEEDBau0MqLmly3RQaFi1rI6gEAAAAACAOAgLARQkOzMKp06u0G2X1DOjEAAAAACABAgLARQcOzMKayaXq+2G81QxwZ2x6wIAAAAAoNARFgIoOO09/ZZmFErS7ZecQVAIAAAAAEAKhIUACs6ufeZnFPq8Hq1aVkfrMQAAAAAAJhAWAig406s8po676aK5bD0GAAAAAMACevIAFJyFtTXyez1KFAG6JPm9HoJCAAAAAAAsIiwEkPeCobDauvv09NYP1NbdJ0lataxOksYFhsbXq5bVERQCAAAAAGARbcgA8lprZ0DNLV1RC038R+cQrlnRMO57ZmcUBkNhtff0a9e+IU2v8mhhbU3a4WImzgkAAAAAQDYRFgLIW62dAa1c26FwzOO9A0NaubZDa1Y06OXrz7Uc0CULIO0uQknnnISMAAAAAIB8QVgIIC8FQ2E1t3SNCwolKazRduPmli4trfOpcfZU0+c1E0BaDQzTOWcmgksAAAAAAOxiZiGAvNTe0x8VoMUKSwoMDKm9p9/0OVMFkNJoABkMxTvC+XMaIWPs+zRCxtbOgOnrAAAAAADACYSFAPLSrn2Jg0I7x0mZCSDtnjMTwWW2xS6eyedrBQAAAACYQxsygLw0vcrj6HFSZgJIu+e0EjJaabPOFtqnAQAAAKA4UVkIIC8trK2R3+tRojUfLo2GUwtra0yfMxMBpN1zZiK4zBbapwEAAACgeBEWAshLZW6XVi2rk6RxgaHx9apldZa2BmcigFxw0hTVTK5I+P1E58xEcJkNxdA+DQAAAABIjLAQQN5qqvdrzYoG+bzRgZnP67G1tdjpALK1M6BP3/UH9R84HPf7yc6ZieAyGzIx9xEAAAAAkD+YWQggrzXV+7W0zqf2nn7t2jek6VWjAZqVisLY861Z0TBu3p7P4rw9oxU3Wf1csnMaweXKtR1ySVHnsVs5mQ2F3D4NAAAAAEiNsBBA3itzuxxd8mE1gAyGwlHHLjhpSsJWXEPN5HK9dN05qpiQuIDbqeAymwq1fRoAAAAAYA5hIYCSZDaAjLf1t2ZyufoPjCR9Xv+BEW3ZsSflazhdOZlpRvt078BQ3LDUpdGwM9/apwEAAAAA5hAWAkACiVqNUwWFBrOtuE5XTmZSobZPAwAAAADMYcEJAMSRbOuvWcXaiuv04hkAAAAAQP6gshAA4ki19TeZUmjFLbT2aQAAAACAOYSFABCH3W2+pdSKW0jt0wAAAAAAcwgLASAOsy3ENZMr1H/g8NjX2dxkHLulmco+AAAAAEC6CAsBIA6zW39fuu4cbdmxJ+uBXbwtzf4sBpUAAAAAgOJkacHJmjVrNG/ePFVXV6u6ulqNjY169tlnkz7niSee0Omnny6Px6MzzjhDv/vd79K6YADIBmPrr3SstdgQ2WpcMcGtxtlTdfH8mWqcPdXxoDAYCqutu09Pb/1Abd19CobCY1uaY2cq9g4MaeXaDrV2Bhy9BgAAAABA6bBUWThr1izdcccdmjNnjsLhsB555BFdfPHFev311/XRj3503PGvvPKKli9frtWrV+tv//ZvtW7dOn3+859XR0eH6uvrHXsTAJAJxtbf2Ao+J1qNzbQQx6se9FVXauhIKG61Y1ijQWZzS5eW1vloSQYAAAAAWGYpLFy2bFnU17fddpvWrFmjzZs3xw0L77nnHjU1Nem6666TJN16661av3697r33Xv3sZz9L47IBIDsysfXXTAuxUT0YGwr2Dg4nPXdYUmBgSO09/SwfAQAAAABYZntmYTAY1BNPPKEDBw6osbEx7jFtbW369re/HfXYZz/7WT311FNJzz08PKzh4WN/IR4cHJQkjYyMaGRkxO4l5y3jPRXje0PxKrX79uMnVkuqliSFgkcUCto7z4a3durax7cqLKmy7Njje/Yf0jWPbtHdfz9f55w2Xat/+6YqyuLVD5qza+CARkaqbT+/mJXavYviwH2LQsW9i0LEfYtCxb2LVMzeG65wOGzpb6Pbtm1TY2OjhoaGdNxxx2ndunW68MIL4x5bUVGhRx55RMuXLx977Kc//amam5u1c+fOhK9x8803q7m5edzj69at06RJk6xcLgAAAAAAAFDyDh48qEsvvVQDAwOqrk5cXGK5svC0007T1q1bNTAwoF/96lf6x3/8R7300kuqq6tL64Ij3XDDDVEViYODgzrhhBN0/vnnJ30zhWpkZETr16/X0qVLVV5enuvLAUzhvrWuvadfX3nk1ZTH/c+/+Yju+///t63XcEmaUe3Rc9eczczCBLh3UYi4b1GouHdRiLhvUai4d5GK0bmbiuWwsKKiQqeccookacGCBXr11Vd1zz336L777ht3rM/nG1dBuHPnTvl8vqSvUVlZqcrKynGPl5eXF/UNX+zvD8WpGO9bM8tH7Nh98IiGg6nPE3K5TR0Xy3jGDRd9VJ7KCsvPLzXFcO9m6l5F/iqG+xaliXsXhYj7FoWKexeJmL0vbM8sNIRCoaj5gpEaGxv1/PPP65prrhl7bP369QlnHAJArplZPmLX9CqPqeMaPzJNv+74QL0DQ3G3HrskeSeVyzOhTL2Dzm5pRuHI5L0KAAAAoHRZCgtvuOEGXXDBBTrxxBO1b98+rVu3Ti+++KKee+45SdLll1+umTNnavXq1ZKkq6++Wp/+9Kf14x//WBdddJEee+wxvfbaa7r//vudfycAkKaEG4gHhrRybYfWrGiwHcIEQ2GFQmEdP7Fcew/FHyrr0mjgt2j2VK1aVqeVazvkkqKux6gZu+Pvzki6pZmKs+KWyXsVAAAAQGmzFBbu2rVLl19+uQKBgLxer+bNm6fnnntOS5culSS99957crvdY8d/6lOf0rp16/T9739fN954o+bMmaOnnnpK9fX1zr4LAEhTMBRWc0tX3Eq+sEZDuuaWLi2t81kO3eJVgMUyzrhqWZ3K3C411fu1ZkXDuOfFVg82zp5q6vWoOCsembxXAQAAAMBSWPjQQw8l/f6LL7447rEvfelL+tKXvmTpogAg29p7+pOGeWFJgYEhtff0xw3oEklUARYrXgtxU70/afWgldej4qx4ZOpeBQAAAADJgZmFAFAMdu1LHL7YOU5KXgFmOH5iuf79sgYt+sjUuCFgmdtlOvCh4sw5+dzGnYl7FQAAAAAMhIUAIPPLR6ZNrlRbd5+pEClVBZgk7T00IrfL5UgQRcWZM9Jp485GyGj2XjV7HAAAAABEIiwEAEkLa2vk93pSbiD+zhNvRG0gThYiZbsCjIqz9KXTxp2tWZFm7lWfdzSoBAAAAACr3KkPAYDiV+Z2adWyOknHlo0YjI3Eew+ORAWF0rEQqbUzMO6c2a4Ay2XFWTAUVlt3n57e+oHauvsUDKWa0ph/UrVxS6Nt3PHemxEyxlZ2Jrs/7Ep1r0rHFuUAAAAAgFWEhQBwlLGB2OeNDtNmVFfq+EnlcZ+TLEQyKsASRTYujVaeOVUBlu3XM7R2BrT4zhe0/IHNuvqxrVr+wGYtvvMFRwOybLDSxh0pnZDRrkT3qs/rYYkNAAAAgLTQhgwAEeJtIA6Fw7rswT8mfE6iWYBGBdjKtR1j1YkGuxVgyWbiJXs94zovrB99b07N0ium7ct227hzNSvSzrZsADArnxc9AQCAzCIsBIAYsRuIn976gannxQubjAqw2Fl2Phuz7MzMxEv0em6XFApLD23aroc2bXdkll6mty9n+y+qdtu4czkr0sq2bAAwK1szWAEAQH4iLASAFNKdBehEBZiVCr7I11vf1aufb9qu2A5YJyr/MllRl4u/qNpdHMJ2YgDFpJgqxgEAgD3MLASAFJyYBWhUgF08f6YaZ0+13HpsdSZemdulhbU1erazN+45Ez3PyqKSTFXUZXNZSCS7i0NyNSsSAJyWixmsAAAg/xAWAkAKud4+a3fxhtXnWV1UYrZSbtrkStMBZK7/ompncUiu7w8AcIrd/38DAACKC23IAGCCk7MHrbJbwWfleXbazsy07Xonles7T7yh3kFz7cRm/6L68KYe/dNZtRkJ4Oy0jefy/gAAp+RyBisAAMgfhIUAYFKuts/anYln9nk1Eyt09X9stbyoJNW257CkvQdHJI1EnTNZAGn2L6C3/vYtPfhyT8aCODuLQ9hODKDQMYMVAABItCEDgCXpzB60y+5MPDPPO35Suf7l8dfVf+BwwtdP1naWqG13RnWljp9UnvB8Uvx2Yit/Ac30DEM7cnF/AIBTmMEKAAAkwkIAyHt2Z+Klep5R+bfn4IjMSFT111Tv18vXn6tHv7ZI93x5vh792iL9+H/MP1pVGF+iADLVX1RjzyExbB8AnMIMVgAAIBEWAkBBsLN4I9nzklX+JZKs6i+2om73/mFT54wNIJP9RTWeyBmGZhaoAACSs/v/bwAAQPFgZiEAFAi7M/HiPS8UDuuyB/9o6nVdGv1LopW2s3TmXiVaFpLMrb99a+x/J1ugAgBIjRmsAACUNsJCACggdhZvxHve01s/sPR8q21nZjYlJwsgjb+oPrypJyoINCPZAhUAgDl2//8NAAAofLQhA0AJMlv5N3Vyha3QzYm5V2Vul/7prFrTMwwNzDIEAAAAAPsICwGgxARDYYVCYR0/MfnMwprJ5Wq74Tzb1XlOzL2yOsPQkGyDMwAAAAAgMdqQAaCEtHYGUs4CNEK52y85QxUTjv03pWAo7Mi8RKtzr+zMMDQk2uAMAAAAAIiPsBAASkRrZ0Ar13bEnSEYyRdnQUi8kNHsIhEn5l7Fho679w2bmmVott06HXZCVAAAAADIV4SFAFACgqGwmlu6kgaFx08s179f1qBFH5k6FnYFQ2Hd+8K7unvDn8cdn+1FIpGhYzAU1oMv9yRcoCKNvp9QOKxgKJyx8C6dEBUAAAAA8hEzCwGgBLT39Kds4d17aERul2ssWGvtDOisO56PGxRKuV0kYmaW4d5DI7rswT9q8Z0vqLUz4Pg1GJWasZ+rEaJm4jUBAAAAINMICwGgBJid3WccZwRhvYPDSY/P5SKRRAtUYmUivEtWqck2ZgAAAACFjLAQAEqA2dl906s8plqWY+VqkUhTvV8vX3+ufnnlJxNud85EeJeqUpNtzAAAAAAKFWEhAJSAhbU18ns9CVt2XRqdtbewtsZUy3KsbCwSSaTM7ZLb7dLeQyMJj3E6vLNaqQkAAAAAhYKwEABKQLIZf8bXq5bVqcztshRwRYaMuWQnvAuGwmrr7tPTWz9QW3efpapDK5WaAAAAAFBI2IYMACXCmPEXu73XF7O912rAZYSMuWQnvPvsTzZqx55jMxmtbDE2KjUTbWN2afRzzXWICgAAAABWERYCQAlpqvdraZ1P7T392rVvSNOrRgOtyLAvVRBmsBKuZZqV8O73nR9IknoHhxRZZ2ksQlmzoiHlezIqNVeu7ZBLinrN2EpNAAAAACgktCEDQIkpc7vUOHuqLp4/U42zp44LtJK1LBuuXTJHL19/btpBYTqtwJHMtllL0h3P/inuOawuQkm0jdnn9ZgKHAEAAAAgH1FZCAAYJ1HLspPVhK2dAUfPb6bNuq2772hFYXyRi1AaZ0819ZqpKjUBAAAAoJAQFgIA4konCAuGwkmf19oZ0Mq1HeNahq20Atu55kxsMTYqNQEAAACgGBAWAgASshOEpaoYDIbCam7pijtb0Hjse7/epipPuRZ9ZHybdDrXPO24SlPnYIsxAAAAgFLFzEIAgGOMisHIoFA6VjHY2hlQe0//uO/H2ntoRJc9+EctvvMFtXYGHLu27/zH1qTHuDQabLLFGAAAAECpIiwEADjCTMVgc0tX0pmBsSJDxnQYIWbv4HDCY9hiDAAAAACEhQAAh6SqGDSWh/TvTxzYxXuOZH5DcTzJQsxIbDEGAAAAAMJCAIBDzC4FqZlcIb/XI7O1e5Ebiu0w0/YsST/64pl5GRQGQ2G1dffp6a0fqK27z3ZoCgAAAABmsOAEAOAIs0tBfN6JWrWsTivXdsglpaz4M1jZUGznebsPmK94NCvVVuhUUi2LAQAAAACnERYCQJ5JN2DKlYW1NfJ7PeodGIobALo02uprvJ81KxrGBWHJ2N1QbPZ5Tm9ATjfoM+Ysxn6WxhxHWqYBAAAAZAJhIQDkkUKuJCtzuxJWDMZbHtJU79fSOp82d/fpqnUd2ntoJO55I0NGO6yEmE5JN+hLtSzGpdE5jkvrfAURJAMAAAAoHMwsBIA8YQRMsZV2Tm0Ezoamer/WrGiQzxtdpZdoeUiZ26Wz5kzTHV84Qy5p3BxDJzYUGyFm5PmcPH8ss1uhk80eNLssxu4cRwAAAABIhMpCAMgDxVRJZlQMWmmlNkLG2KpKn0NVlZHn799/yPHzR7IS9DXOnhr3GLNzFu3OcQQAAACARAgLASAPOBEw5ZMyt8vyddoJGe2cf/O7u7T7rc36+T9+QotOme54+OpE0JerOYulrlDmhRbKdQIAAKAwERYCQB6gkmyUnZDR6vkX1tbod28pYwGLE0FfLuYslrpCmRe64a2duuW3b+f9dQIAAKBwMbMQAPIAlWTFwwj6EsWQLo2GO8mCPifmLAZDYbV19+nprR+orbsv6YzEUldI80KvfXxrQVwnAAAAChdhIQDkAScCJuQHpxaqWF0WE6m1M6DFd76g5Q9s1tWPbdXyBzZr8Z0vECbF4cRCmmwwXj/frxMAAACFjzZkAMgDRsC0cm2HXIoOBDKxsReZ5dTCFjtzHI0qudjIyKg+SxU0lppCmRe6ZceepN/Pl+sEAIxiviyAQkZYCAB5ItMbgZGc0/9SHxv0TZtcKbmk3fuH1dbdZ/r8VuY4FtNW7XRY+VkWyrzQ3fuHTR2X6+sEABTOHFwASISwEADySKY3AiO+TP1LvRH0tXYG9K+/eiPjf2mwWyVXTNUPVn+WhTIvdNpxldpt4rhcXycAlDoq/AEUA8JCAMgzmd4IXAycDLcy/S/12fxLg50quWKqfrDzWRfK5ukFJ03Rc2+Nn4NpyJfrBIBSRoU/gGLBghMAQEGxsrwj1UZgO8strGwZzvbyDKtVcoW0BTgVu5+1UwtpMi3y9fP5OgGglFmp8AeAfEZlIQCgYFipHEtUMfdvF5029rXVtl2rVXjZXp5hpUrOTLh245PbdO7pM1QxIf5/W8yn9uV0PutCmhd699/P1y2/fTvvrxMASlGhzMEFgFQICwEABcFKa8/6rt6EoeK1j2/VnQtHv7byL/V2Wlyz/ZcGK1u127r7koZrktR/YESLVj+v2y+pH/fe8q19Od3PulDmhS6ZO0Pn18/M++sEgFJUKHNwASAV2pABAAXBbOXY5u6+lBVz0mj4aPZf1qdNrrTV4pqLvzQYVXI+b/Q5fV5PVKBpNlzrP3B4XEtyPrYvO/FZG/NCL54/U42zp+ZtAFco1wkApcao8E82X9bPfFkABYDKQgBAQTAbbrX99+6UoaIkbdmxR4tOmW6qbTcUDttqcc328gyjLXj4SEg/+uKZkkvavX84bvWZ1YDSqNo0/ne+DW8vlEUlAIDiZaXCHwDyGZWFAICCYD7cMvcv4Lv3D5tabvG5M/361qOvmzpnbKCZ7PzS6F8iLqwfbX01u+Qk0YKV2MUvlz30R/3rE2+ocoI7bvVZquqH2Os0wtB8Hd5eKItKAADFzWyFPwDkMyoLAQAFwWzlWOPsqbr3D++mPN+04yolJV9u8bkz/bp/Y0/c14snXqCZ6PxulxQKSw9t2q6HNm03Ne8v0ZzARNeZbJ5iZPWDWVZmK+ZieHshLSoBABSvQpmDCwCJEBYCAAqC2daeRR+ZmjJUlKQFJ00Zeyzev9QvOGmKPn3XH0wFhalaXCPPv76rVz/ftF2xhYTJgj0p8SbowMCQ7tvYE/d1U7UFG+HajU9uU/+BkZTv00rrcq6Gt/MXNABAPjDmywJAIaINGQBQMMy09phpR5U0LjyKXRqxZceelNuCI6VqcS1zu7SwtkbPdvbG/X7kopTDR0JRrcaHj4QSzglMJVVbcFO9X5tvWKKayRUJzxE5kL0QhrezAAQAAACwj8pCAEBBMVM5lqwd9d8uOk2He7akfB2zbbTHTyrXHX93hqkWV7Pz/hatfl79Bw6PPV4zudxU5V8yyd5PxQS3br+kfqwlOdVA9kQVnsZzv/yJE2xfp7GkhapAAAAAIDcICwEABcdMa0+iUDEUPKLfxe/ajWK2jfbflzforDnTTB1rNoCMDApHv04vKJRSvx8r8/4SHWu4e8M7euzV9y3PCUw0k5F5gwAAAED2EBYCAIpWvFAxFDT3XLMLVRZZmEeUizl+qeYpRrIy78849t4X3tXdG/487vvJZjDGqx5c39UbdyZjqlmOAAAAAJxFWAgAQBxmF6pYaZFNFUCmy4nrtDqQ/bFX34v7eKLlKvGqB33VlRo6Eor7maRa0gIAAADAWSw4AQBkVTAUjlreEYxdC5xHzCxUsSLZ8hW7XEf//M+zax27TrPMzmA0lqsYG51jn9M7OKy9BxO3Wqda0pIphXSvAgAAAE6hshAAkDWFOJPOSmuu2fMlm/eXSs3kiqiZhpEzBb/bNDery0HMzmDctW9IwVDY9kZnq6/nhEK8VwEAAAAnEBYCALLCqCorxJl0VltzU0k17y8eY/bgS9edoy079sQNBJ2+zlTMzmCcXuVJWYXo5Oulq5DvVQAAACBdtCEDADIuWVWZ8VhzS1fJtXkmmvcXK3L2YMUEtxpnT9XF82eqcfbUjM/wS9aKa8xgTHQFLo1W4y2srUmrKjDyPJnGvQoAAIBSR2UhACDjrMy2y2ZlXC5ZqbTz5aj9NVUrrpUlMHarAu0uk7GLexUAAACljspCAEDGWZltVyrMvtdvnjNbL19/bk6CwrjLSI624rZ2BiSZXwJjpgrx+Enl8lUnPk+yKkenlpFwrwIAAKDUUVkIAMg4K7PtSoXZ93rWKX/lSEVdMBQ2vfwkVSuuS6OtuEvrfCpzu0wtgTFThXjH350RdZ5pkysll7R7/7Du2fCOHm1/T72D46scdfR67Cwjif1cph1XmfR4QyndqwAAACgthIUAgIwzqsp6B4biBlDG8o5szKTLF9n8TKxu9rXTimtmuUqiTdCxbdaNs6eqtTOgf/3VG0mvo3dgSN9Y25Hwe6mWkcT7XHzVlTp+UrkGDo5wrwIAAKAkERYCADLOymy7UpGtz8TOZt9MtuKaqUJMdM2xkn0/XgVkpESvsXNweOwx7lUAAACUImYWAgCywuxsu1KS6c/E7mbfTLeNG1WI8TY6J7tmqyIrICOZabM+flK5ZsTMT5wyuVxfOetkeSdWsA0ZAAAARYvKQgBA1pipKis1mfxM7G72zWXbuJUt0WbFVkCa+Vz2HhzRL69skNvt0vquXj219UP1HzishzZt10Obtidt47YyHxIAAADIN4SFAFAkCiWgMDPbrtRk6jOx206cy7bxTGwZjq2ANPsauw8Mq3KCW7/YtN10G7fV+ZAAAABAviEsBIAiQECBeNJpJza7jCQRu+G1k1uGE1VAmn2NaZMr9a+/esP0Vmg78yEBAACAfENYCAAFjoACiaTbTmy3RdpKeB0bKi44aUrSa469fjvLSMx+LnLJdBv3wtqalHMQEy1byQeFUpkMAACAzCMsBIACZmZRQz4HFMisZO3EOvr1lz9xQspzGC3SZgIlK+F1olDxc2f6df/GnrjXHMmocpRkqQLSbJv17v3DSV79mF37hmzPh8wHVCYDAAAgEmEhABSwQg4okB2J2okNd294R4+9+n7KYMhMoGQlvF7f1ZswVLx/Y4++fnatnnkjEB0AVldq+cITdfK0yePCSrMVkEbgOXwkpGuWnKpH299T72D8kLGtuy/h5xFpepXH9BzE3oFDpo7LFiqTAQAAEIuwEAAKmN0FFigtRjvxvS+8q7s3/Hnc91MFQ2YDJbPh9ebuvpSh4jNvBPTSdedoy449cQPAeFWOqQLxeIGnr7pS1y6ZEzeAtNLG3d7Tn/S1Dbf+9i1NrChL2Y6djTZgJyqTaV8GAAAoPoSFAFDA0llggdLz2KvvxX08WTBkJVAyG0q3/fduU6Hilh174gaAdtpmEwWeOweH9ZMN72jNioZxr2VlK3SqYNGw58Bh0+3YmW4DTrcymfZlAACA4uTO9QUAAOwzAopEdTwujf7lPdECC5QOK8GQ3eeZD6XNVZ7FCx+N0C/2mowqx9bOwLjnpAo8pdHAMxgaf4TRxu3zRr83n9cTFfgZwWIqsa9n5/04JZ3K5FxeNwAAADLLUli4evVqfeITn1BVVZWmT5+uz3/+83r77beTPufhhx+Wy+WK+uPxUOECAE6IDChi45dk22BReuwGQ1aeZza8Njs/MzZ8tBv62Q1KDU31fr18/bl69GuLdM+X5+vRry3Sy9efO656zggWayaXJ31fZtuxE70fp9itTE4nfAUAAED+sxQWvvTSS7rqqqu0efNmrV+/XiMjIzr//PN14MCBpM+rrq5WIBAY+7Njx460LhoAcIzZyieUNrvBkJXnmQ2vF31kqq2KWLuhnxOzPY2t0BfPn6nG2VMTBvBN9X7d9LcfNfV6Ztuxzc5DtMpuZXK64SsAAADym6WZha2trVFfP/zww5o+fbq2bNmis88+O+HzXC6XfD6fvSsEAKRkLLBg0QASsbKsI53nJdq+7IuZZWd2FmAku6HftOMqTT3PqdmevupMtGNX276eRKzMZDQEQ2Ftene3qfOzWAkAAKAwpbXgZGBgQJJUU5N8Ftb+/ft10kknKRQKqaGhQbfffrs++tHE/9V9eHhYw8PDY18PDg5KkkZGRjQyMpLOJecl4z0V43tD8eK+zU8fP7FaRqgQCh5RKJjb68lHpXzv/ttFp+nax7dKih8M/dtFp8W9b6w+77zTpukzc/5GW3bs0e79w5p2XKUWnDRFZW7X2Od+3mnT9NNLz9Qdz/5JvYOR24k9+t4Fp+u806aN+xlNmzRBlWWpW1unTZow9twNb+3U6t+9lfR5Lkkzqj362KwqR+6Lj82q0klTKrVzMHHAOqPao0+e7NUDFt+P0/etlZ/Dhrd2jh1XWZb63JHXjdJVyv/MReHivkWh4t5FKmbvDVc4HLY1UCYUCulzn/uc9u7dq5dffjnhcW1tbXrnnXc0b948DQwM6Ec/+pE2btyoN998U7NmzYr7nJtvvlnNzc3jHl+3bp0mTZpk53IBAAAAAACAknXw4EFdeumlGhgYUHV14s4V22HhypUr9eyzz+rll19OGPrFMzIyorlz52r58uW69dZb4x4Tr7LwhBNO0O7du5O+mUI1MjKi9evXa+nSpSovTz4UHcgX3LcoVNy7o62k8ar+MvU8J214a2fSKse7/36+lsydoWAorM/+ZGNUtVw8RgXdkrkzMnKtiSr2jNcz+36cvG/NXFcks59lvOuOPEeu7x1kRqqfLf/MRSHivkWh4t5FKoODg5o2bVrKsNBWG/I3v/lN/eY3v9HGjRstBYWSVF5ero997GN69913Ex5TWVmpysrx84XKy8uL+oYv9veH4sR9i0JVyvduuaSzTrUejtl9npMumDdLLnfZuJmI/piZiK9192nHnmGlmgt4+9/N11lzpmXsWs+vn5l0lqjZ92OIvW+DoXDU+RecNEVbduxJ+HqtnQH987o3jgaTxx5/b8+w/nndG3GXIpn9LBNdd2tnwPT7Q2Gx8rMt5X/monBx36JQce8iEbP3haWwMBwO61vf+paefPJJvfjii6qtrbV8YcFgUNu2bdOFF15o+bkAAABmFvqYXa6x+8Bw6oPSYGxRTsbugqJ4QY3bJYUiShQjg5tgKKzmlq64cxTDGo0Cm1u6tLTOZ+uz/OY5s3Xt0tPGhZMr13aMe83egSGtXNvBxvYCxs8WAIDiZSksvOqqq7Ru3To9/fTTqqqqUm9vryTJ6/Vq4sSJkqTLL79cM2fO1OrVqyVJt9xyixYtWqRTTjlFe/fu1V133aUdO3boq1/9qsNvBQAAlIpUIZzZzcZObUBOl5lQMVKioCYU80BkcOOdWBEVLMYKSwoMDKm9pz/qWsx+Rmed8lfjNifbCSeR/6z8bAEAQOFxWzl4zZo1GhgY0Gc+8xn5/f6xP48//vjYMe+9954CgcDY13v27NHXvvY1zZ07VxdeeKEGBwf1yiuvqK6uzrl3AQAA8lYwFFZbd5+e3vqB2rr7FIxNtDJgYW2N/F5PwsZZl0ar7hbW1mT8WtJltBpLUntPvw4fCSUMamKFj/658cltCuw9ZOr1YisJ7X6W7T39psNJFBZ+tgAAFDfLbcipvPjii1Ff33333br77rstXRQAACgOuZpXV+Z2adWyOq1c2yGX4i8PWbWsLu8r2ozPr3//If1wofSVR17VZE+F+g+MWDpP/4ERrWp509SxsZWEdj9Ls+3LZo+Txs9oNNOunW+K4T1Y+9kW33JCAACKna0FJwAAAKnkeqZZU71fa1Y0jAsrfTlcrmElKIr8/CrLjj1uNSg07Bs6kvT7Lo1+NgtOmqK27r6oa7TzWTrdCl4Mi1KK4T1IhdfmDwAArCEsBAAAjsuXeXV2l4dkgpWgKNnn54REFYKfO9OvT9/1h4TXaOWzNNqXeweG4r4PI5w00wqeq+DZySrAXIfnTrLysw0Fk4fUAAAg/1iaWQgAAGBGPs00M5aHXDx/phpnT81ZULhybce4z8QIilo7A1GPp/r80jVlckXU1z6vR18/u1b3b+xJeo1WPkujfVnSuHmHke3LkpLOtEwVPEujwbPTszBbOwNafOcLWv7AZl392FYtf2CzFt/5wriflRm5eg+ZYvZnW2jt1QAAYBSVhQAAwHGZmFdXqOxUWWb6c7npornyeSeOVcwtOGmKPn3XHxyvBE3VvixJi+98IWm1pZXg2cpG6WScrgLMxXvItHxs8wcAAM4gLAQAAI5jptkxdoIis59LzeQK9R84PPZ1bHtxIj7vxKhQqq27L2NhVqL25fVdvSkDuaV1Pm16d7ep10kWsFppJ85EC32xhuf51OYPAACcQ1gIAAAc5+S8ukJnJygy+/m9dN052rJjz1hQM/+E43XWnS9EBYjxnhf7uWc6zDLalw2Hj4R045OdSQO57/3nNt38TJd6B829ZqKA1epSkUxUARZzeB77swUAAIWPmYUAAMBxzDQ7xm5Q9OVPnJgwKJRGP7+KCe6oGYITK8p0+yX1csna557NMKu1M6BFqzckDDSl0UBu78ERU0GhS6PhX7zg2eqsSCkzwakR/ia625O9BwAAgGwjLAQAABlhzDTzeaMDJp/XU1CbX9NlNSgyFmvcveHPcY9P9fnZ+dyzFWYZ4V3/gZG0zhN5XVL8ANTuUpFMBKelGp4b7d/SaMVmoSxwAQCg1NGGDAAAMoaZZseCopVrO8bNFIwNihIt1jBc9ZnZuuq801N+flY/dyvXaFey8M6uZMs07LYTZ6qFvtQWghjt3/37D+mHC6WvPPKqao6bWJTvFQCAYkNYCAAAMoqZZuaCIjNh2q87PtBV551u6jWtfu6ZDrNShXdWffOc2bp26WlxA8xgKGx7MUomg9NSCc8jQ+/KsmOP290mDQAAsouwEAAAwCIr23UNqYIiM2Fa76C9jcRmZTLMcnrT71mn/FXc64q30CSZeO3EmQxOiz08z8Q2aQAAkF2EhQAAABZY3a4bKVlQlOmNxGZlKswyO+OvZlK5QpIGDo5YbgNO1cZt9jxSflcB2gmrsyUT26QBAEB2ERYCAACYlCiMstNeGRv4TDuu0tTznNhInAupZgFKUs3kcm2+YYle+NNOy23AVmYimm0nzscqwHTC6mzIl9AbAADYR1gIAABggpPtlfECH191pY6fVJ6wom70mPQ3EueKmVmAt19yhiomuG21AVuZiVgIS0XiVQ+u7+p1LKzOhGAorN37hk0dW6ihNwAApYCwEAAAwASn2isTVSfuHBweeyxRmPa9C1JvQs5nVkJAq23AZivVki1GsSIyzJs2uVJySbv3DzvSFpwoTB46EsrbWYBmZ0Xa3SYNAACyh7AQAADABCfaK81UJ3onlcszoUy9g8fOM6PaI+mAlsydYema85GVENBKG7DZSrVEi1GsSBWMpdMWnLDVfTB5xV6isDob8w3NzopMd5s0AADIDsJCAAAAE8yGUcmOM1OduPfgiH55ZYPcbtdYwPOxWVV6rvVZq5ccJZ+WYmRiFmCqmYhOVbSZCcbstgVbmbuYSGRYnY35hlauuRDavwEAAGEhAACAKU6EUWarE3cfGNbF82eOfT0yMmLxaqPl+1IMJ5iZiZiqoi1VoGo2GLPbFmxl7mIiRljt5DKeZMxe8/WfPU3/uPgUKgoBACgA7lxfAAAAQCEwwijpWPhkMBtGOVGdaJURGsUGOkZo1NoZcOy1cs2YiejzRn9+Pq8nZTjW2hnQ4jtf0PIHNuvqx7Zq+QObtfjOF6I+HythXmRbsFnpbAh2aTQAXlhbk7LdXRoNMoOhdGoYR5m95qnHVRIUAgBQIKgsBAAAMMnOlt5I2WqVNTi5wblQWF2MIpmvwrMT5m169y8JXz+2knHacZWWzx/JCKvbuvssL+Ox26ZuNti28t7yqWUeAIBSRFgIAABggZ0wyuBEq6wVTm1wLjRWZiJaCVTtVHze+4du/brjg3FhcqKNx8dPKtfAwRFLcwuPn1SuO/7ujLHzW13Gk06bupkAXJIWnDTF1DWVQss8AAD5jjZkAAAAi4ww6uL5M9U4e6qlcC+dVlmrnNjgXOysBKpGMGY1yo1t+U7UGr5zcFh7jwaFVl7j35dH3zdW2t3TbVM3055vHJdKKbXMAwCQz6gsBAAAyLJ0qhOtyMWMxEJjJVBNVhmaTGSF4rmnz0hZyeidVC7PhDL1Dia/NqNtfVFMFaXZdvcFJ03Rp+/6Q9pt6sna8//totN0uGfLuOfEthovOGlKybXMAwCQrwgLAQAAcsBKq6xd2Z6R6IRsz6uzGqgmCsZSMSoU/2/b9pSVjHsPjuiXVzbI7XZpfVevfr5pu6W2dbPt7lt27HGsTT1RAB4KHtHveqKPjddqXDO5XP0HEm/9LtaWeQAA8hFhIQAAQJHK9ozEdOViXp2dQDU2GJs2uVKv/Pdu/fsfulO+3o7+g6aua/eB4bE294W1NaaX6hhh6/CRkK5ZcqoebX8vqkIx8nlPb/3A1LWYrb6MF4CHgtHHJFomkywotHMtAADAPsJCAACAIpbuBudsMbuR2Gl2A9XYYMztdpkKC0+qmWTquiIrHs22rSdamnLtkjk6edrkcc/Ldpt6smUyZuVry3wmKmLZCg0AyBXCQgAAgCKXrRmJdlnZSJyJa3YiUDVbofgPjSfrwZd7LLeGJ2tbD4bCuveFd3X3hj+P+97OwWH9ZMM7WrOiYdzzs92mnmqZTDL52DJvyERFLFuhAQC5RFgIAABQArIxI9EuKxuJ030Piaq10g1UzVYoVkxwO9oa3toZ0M3PvKneweG4308Wtma7Td1uC3E+tswbMlERm6sqWwAADISFAAAASFs6LZNWNhKn83qpqrXSDVQTVShOmVyuS+bPlHdihYKhsGOt4YlCpViJwtZgKCzvxApdcdbJemrrh+o/cNj2tZhhtoW4ZnJFxq/FCZmoiM11lS0AABJhIQAAANKUbsuk1dl5dl4vW9VakRWK67t6x0K4hzZt10ObtkddZzqVjHbm/0WGrYk2El8yf6aW1Pky0qZutu35pevO0ZYde/J+/l8mKmKzWWULAEAihIUAAACwzYkQzsrsPDuvl6paS5K+9+ttqvKUa9FHpqYdIpW5XRo4dFi/2LQ95XXGVvq1dfeZCrTszP+LDFvjfYZ7Dozo55u26xMZmmdppVXbySAsU/P/7FTEZuOcLEYBAKSLsBAAAAC2OBXCmQ2RJNlq0TQTrO09NKLLHvyjIyGSnVZSq4GWlQAqMmy1c22R4dO0yZWSS9q9f9hWEJXt7dyZrCjNxDbpdM/JYhQAgBMICwEAAGCLkyGcmRCprbvPVoumlWDNiRDJaiupnUDLSgAlHVsOYvUzjBc+RbITRFlpwU6nSi7dYDTV62Vim3Q652QxCgDAKYSFAAAAsMXpEC5ViGS3RdNKsObEEgkr12l3oUWqUMkQG+ZZuTYzC1TsBlGRy2QSBXTpVsnZCW2tvF4mtknbPSeLUQAATnLn+gIAAABQmKyGcNJoYBEMJY6fjBDp4vkz1Tg7unXZboumEayZjUgiQySDMU/w6a0fqK27L+l7sHKdVgKtSEaoJCnh+7p2yRy9fP25UUGX2WubNrnS1AIVsz/XRFo7A1p85wta/sBmXf3YVi1/YLMW3/mCVv+uSyvXdoz7bIxwsrUzkPLcdoJRq69nVMT6vNGfq8/rsV3Jl+icM6ordc2SORo+Ehp3D5q9jx7e1GPr5wQAKC1UFgIAAMAWs9VthnQ3udpt0UxWrZWMETZZrTizcp2/+a8PLV1LpESt205cm1wyvUDF7s81UeViYGBI923sSfhaZqvkrASj//qrN2xX5aW72Tqe2HNu331Qj7a/p7s3vDN2TOTP2Wwweutv39KDL/cwwxAAkBSVhQAAAGmwUnFWbMxUt8VjpX3Z7OulavtMVK2VzPQqj62KMyvXme5Ci6Z6v16+/lw9+rVFuufL8/Xo1xaNqya0c2279w+buq5IVn6uydpmU0lUbRkrVUWpS6OBW6pg1Hi9zd19CX/Xk1XE2mWcs3KCWz/Z8Gf1Dia+B61U+VqpzgQAlCbCQgAAAJsStVCW0l/C7YZwTr+embZPI1j75ZWf1PETyxMeZ4RIC06aknLbc6L2W7PXaTbQSrYkw2pQZeba7PyMrDzHzHKcVFKFk2aD0V37zAWjV63ryPrvupmN480tXVpw0hTTrfbpto4DAIofbcgAAAA2sHn0GKNlcnN3n65a16G9h0biHmdnO2yy17PT9lnmdumsOdN0xxfO0Mq1HZISL5HYsmOPre3LVq4zE0syzEh1bVZazO38XO1Wl0YyE06m2rItSbf+5k1Trxd7X9v9XbeycdnsLMItO/ZYarVPdyQAAKC4ERYCAABYVEqbR80GG1ZCOCdbNO1KFSI11fv19NYPTJ0rWfBl5jrNXEsmJLs2s3Me7f5c06kuNRNOxt63L113jrbs2BN1H6/v6k257TkZO7/rVudfWlnScvH8mXHvo1TPAwAgFmEhAACARVY22BZy1Y7VYEPKXfBlpVor8lqTVdelO0/QikwsyXDimlKFT3Z/rmYrF+1UWya7by+eP1NSejMTI1n5XbdTjWz1HjTuo4c39ejW375l+nkAAEQiLAQAALDISrVPoUqnzTrbwZedUNOQrLrO7vZlu9KtlsyE2J/ltMmVkkvavX84rZ+rmfbrr59dq2feCFgKnc3et2ZnJh5XWab9w8GUx6X6XbdbjWznHixzu/RPZ9XqwZd7snbvAgCKC2EhAACARdmsOMsFJ9qssxV8ZXJ2ZK7mCeabTP0szVShfrdprunQ+fCRkG58stPUfWs2yP/HxpP17y92pzwu1e+63Wpku/cg9y4AIB2EhQAAABZlu+Is2wqlzTobsyNz1VZdKlJVocYGlcFQWG3dfeOObe0M6MYnt6n/QPzlOlL0fWs2yP/U7Gn6z9c/SPt3PZ1qZLv3IPcuAMAuwkIAAACLir1qp1DarLMVaubjPMFiYrZyMVG7+efO9Ov+jT2m5w/u2jekv53316YC/0Wzpzryu55uNbLde5B7FwBgB2EhAACADcVctVMobdbZDDXzcZ5gKUnUbh4YGNJ9G3ssnWt6lcdS4O/E77oT1ch270HuXQCAVYSFAAAANhVr1U6htFkXSqiJ9Di1uTj2vrUSAqb7u17o1ch2to0DAAoXYSEAAEAairFqp1CCjUIJNZEes5uLzYi9b62EgOn+ricKJ6dMLtcl82fKO7FCwVA4579XBiMgXN/Vq6e2fqj+A4fHvmd227jdkJFwEgByi7AQAAAA4xRCm3WhhJr5olADGCfayKdOrtBtl9THvW+zGfhHhpORIdxDm7broU3bTYdwmRZvPmQkM9vGE82YTPX+7D4PAOAcwkIAAADEVQht1oUQauaDQg5g0m0jr5lcrrYbzlPFBLdDV5RasmC2zO3SwKHD+sWm7eMqYs2EcJmWaD5kpFTbxhOdI9X7s/s8AICzCAsBAACQUCG0WRdCqJlLhR7ApGo3NySqLr39kjOigsJMV1imCmaTzWBMFcJlmpX5kIm2jdt9f/n8uQBAqSEsBAAAQMErhFAzF4ohgDHTbv71s2v1zBuBlNWlVissrQaLZoJZ78SKpDMYE4VwyZi9zlTH2ZkPGdsmnuocid7f5v/uc/xzAQDYQ1gIAAAAFCm7wU2+MdNu/t2muUmDMKsVlnaCRTPB7HebTjf1nje9+xdTVY9mr9PMcXbmQ8a2iZs9R+RxrZ0Bfe/X20w9L9nnUqhzOTONzwWAVYSFAAAAQJGyE9zkq1Tt5smqS61WWJoJFmOvJRQOmwpm+/cPm3q/9/6hW7/u+CDpXEmzAajZ46zMh0y0bdzsOYzjzMxIjJTocynkuZyZxOcCwI7sTfkFAAAAkFVWg5t8ZwSCF8+fqcbZU01XR1mpsEwVLErS9/5zm8664wUtf2Czrn5sq5Y/sFlX/bLD1LXUTK6Q3+uRmSs3wrzWzsC475m5zuaWLh0+EjJ1XDAUHpsPmerakm0bT3UOl0bDqoW1NZZmJEaK/VyMwDH2Z5zs88sXwVBYbd19enrrB2rr7lMwZPXTSKyQPxcAuUVYCAAAABQpK8FNMbNSYWkmWNx7cES9g9HH7D00Yuo1fN6JWrWsTpJShnKxYV4kswHo/23bbjooNeZDprq2GdWVumbJHA0fCY0LuFKdIyzpwvrRqsxUcwqTXbNkPQzNN62dAS2+Mzp0XnznC46EeGbD5Hz8XADkHmEhAAAAUKSSBTfJqsOKjZUKy0y1ZEcGs8YMRp839XVFhnmRzF7njv6Dpo4zzpfo2moml+vKs07WtUtOleTS3RveiRtwBUNheSdW6IqzTtaUyRVR5zBus4c2bbdUjRmPnTDUjkxV/iWq+gsMDOkbazt0a8ubab2elWpaAIjFzEIAAACgiJlZDpJpwVBYr3X35WzBglFh2TswFLfSKnL+XibCk3jBrDGD8e71f9a9f3g35Tliw0GzAehJNZNMHRd5vkTzIdd39SadfRhvK3XN5HJ97ITj9fyf/qLY3MtsNWYyVsNQyfzCjw1v7dQtv33b8Xl/ZtqvH9q0XQ9t2m779bI5r5QFKkDxISwEAAAAilyq5SCZ9tmfbNSOPccWe2R7wYJRYblybYdcUlRIExvkpQoWzTh+YnlUEJYomC1zu3TWKdNMhYWx4aDZAPQfGk/Wgy/3JH0/x08sVygcVjAUTrgwxkxb630be8Z9r//AiJ7/019Svj+7rIahVhZ+XPv4Vg0Fo39HEm3PtiJV1Z8Tr5eteaUsUAGKE23IAAAAQAmwuxwkHRve2ilJ4+b75WLBQqL2Wp/XExXEmJ3bl8y/X9qgR7+2SPd8eb4e/doivXz9uQmDE7tzJc22mFdMcKd8P3sPjeiyB/+YdF6elYArG4zP5R8aT065lMUIQ3/3X+YWfhitv2aWx9hpUbZSzWf39bIxr5QFKpmXyQU4QDJUFgIAAABwXDAU1h3P/knfPn3898IaDSuaW7q0tM6XtQpHsxWWCVu3qys1dCSkgYMjSav5FlkIY61UPcZ7P2ZazBMdFytZFVumZjkaYqsx/V6PPnemX/cfrVZM9LkYYWi8z89ghKFuV+IAMPJ+3LJjT9JrNeb9LVr9vPoPHI66ZjMVdVar+ey8Xjr3lRmpKk1z8ftdbKjaRC4RFgIAAABwXHtP/7iKwkiRCxYi210zLba9NpFUc/ucDGDSmStpJQBdWufT5u4+XbWuI+68wGQhT7rtqqn8+6UNcrtd497Dx06c4lgYmqwoK/J+3L1/OPGBESKDO8l8y7DdVnerr5fJeaVWFqhk8/e7WBhVm4nmg6bTBg+YQVgIAAAAwHHZXLCQKfGCxUwFMOnMlTQbgJa5XXK7XUkXiyQKeZyY5RhPqmpMJ8NQM3btG9K04yq128ZzzVbUJav6c/r1MjWvtBh+v/MVVZvIB4SFAAAAAByXrQULuZCpAMZs6JcOuyFPZMBll91qzGSfS+wmXrnS27I8bXKlQsEjtp9vtqLObDWkE6+XifuqmH+/0+HEZmiqNpEPCAsBAAAAOG5hbY181R5JB+J+36goS2fBQi5lI9jLBLPhzbTJleMeMwKuG5/cpv4D5gI5Iyb5+tm1euaNgKPVmPFmuh0/sdzWuVySvJPK9Z0n3tCeA4f0w4W2TjPGTCgbGTqv7+rVzzdtt/16vQOHbD/XjNgQbMFJU0xt4y7U3287nJoxSNUm8gFhIQAAAADHlbld+t4Fp+twz5ak23ppo8sus+3E33niDd38ufEhR1O9X4dGQrr28a2mXi8yEPxu01zHqjETzXSzU1VoVDzuPTgiaUSVZYmPrZlcbiooNRvKGqFz4+ypWlhbo+/9eput93Drb9/SxIqyjMyxSxSCGQtoMrFApdA4OWOQqk3kA3euLwAAAABAcVoyd4YkaUZ19F9qfV4PA/rTEAyF1dbdp6e3fqC27j4Fk23uiGG0E0saF+JG2jk4GnK0dgbGfc9XbS6kuOmiuXr5+nPHfs5GMHbx/JlqtLAxOlaymW5mxL7sjOpKHT8peUXi8RPL9cuvflKbb1giv9eT8LNzaTRIs1NR11Tv179f1mD5eZK058DhhD8vu4KhsO7Z8I6+sbZjXFts78CQ7t/Yo6+fXSuft7R/v1PNGJRGZwya/T01Av1M3GOAWVQWAgAAAMio5645W6//v32OzvcrVU60OhrtxDc/86Z6B+Nv/k22SCFVdaLRgvpPZ9Vm5OecaqZbIsaV3Lv8Y5oyuXLsfgyFw7rswT8mfe7eQyNyu1yqmOBOuJwkUUWdlTl2iz4y1dYiGacXX7R2BkzdH8+8EdBL152jLTv2lOzvt9MzBpMtwCnFqk3kBmEhAAAAgIwq1Pl+TnBi4YHByVbHpnq/qjzlSUOyRCFHrsMMs7Pajp9YHtXSm2hG4tNbP7D0ulY2YlsNd9PZlOzU4otE91mi19uyY0/J/n5LmZkxmKmt64BZhIUAAAAAkAFOLTyQUrc62qkq270/ftVYrHghRy7DDLOz2v790ga53a6UQe2048Yvc0n1umY2YicK3QIDQ/rG2g5dedbJWlLnG/e8RJ+td+IEDRxKvak5ncUXdlq8N737l5KrJoyUqRmD6WxdD4bCeq27L2fVnk7+RxLkBmEhAAAAADjMySpAyflWRyn9kCOdMCMdZtugF5mYi2i02yaTaLNvsopZM6HbQ5u266FN2+MGyPE+WzPt0lJ6iy/stHjf+4du/brjg5KteDN7P9qZMZjqHov93TN89icbtWPPsf8YYPc/Utjh5H8kQe4QFgIAAACAgzJRBZiJVkcnQo5ctJjbaYOOF6ys7+pN2W5rt63aSuiWKECO/WyDoXDGQimD3apEuyG4E3JdxeZEW77V95AokPv8vOk6XVLv4JAiVxhl6+fj9H8kQe4QFgIAAACAg/KxCjCeXM8eTEe6cwN91ZUaOhJK2W4beT4rgY6V0M1sgJyNn5fdqkSnF6yYlesqNuOeGD4S0jVLTtWj7e8dDepGmWnLt/oekrW3//yVHfrhwvGvkY2fTyb+Iwlyh7AQAAAAAByUr1WA8RTyIoV05gYm2vIb60dfPFNnzZlmOdCxGrqZDZAz/fNKdZ8l49SCFbNyXcWWKIS+dskcnTxtsukKQSvvwc5MSUOmfz6Z+I8kyB3CQgAAAABwUKFVAeZq9qAT0p0bmMruA8O2Qim7oZuZADmTP690tjEb0lmwYlaqKjZJuvHJbTr39BmqmOB2/PUT3RM7B4f1kw3vaM2KhpSBmJ1KPDszJWNl6ueTif9Igtxx/rcGAAAAAEqYERQlim5cGq1Ks1sF6PNGh4w+ryftKiojdLt4/kw1mlgMUgicCFamTa5MGUo1t3QpGIo+wgjdJCW8D+IxGyBn8ueV6D6rmVxu6vnpLFgxy8zPtv/AiBatfl6tnQFHX9tMUBnvnohlpRLP4ETQlqmfT6a2QiM3qCwEAAAAAAdRBZgf0g1WfNUeySXbrZWJWobjcWI5iZPi3WcLTpqiT9/1h4wuWDHL7M+2/8Bhx1uSnWq3tVOJl07Qlujn49SCmExuhXbyOmEOYSEAAACAgpPvf3HM5Gy5XGwgLkR2gxXjLvreBadr935zsw0TBT+Rodv6rl79fNP2glkmE+8+y+SClcjf6WmTKyWXtHv/8FhQuWXHnrHf92nHVVo6t5OLNZxqt7VTiWe2vT32XSb6+Ti5ICaT/5Ek14tsShFhIQAAAICCUih/caQKMLfMVDp5J5XLM6EsaoPtjGqPpANaMneGXntv0NRrJQt+jNCtcfZULaytyfgyGbtBupnnpRuCJ3qNeL/TkdwuKbKr11ddqeMnlWvg4EjKuYpOL9Zwqt3WTiVeqkDO+GnNqPZox55jQXeiLeFOL4gxc39YvT9zvcimVBEWAgAAACgYhfYXR6oAc8dMpdMdf3fGuED3Y7Oq9Fzrs5LMBzoLTpqitu6+lAFIpgPkVEG6lbAuUQBv9z0keo3PnenX/Rt7koZ+seP/dg4OW16+ElvpZzdUdard1m4lXrJA7t8uOk2He7bouWvO1uv/b1/C92ZnuYpZye4Pq/+hJ5PXieQICwEAAAAUBP7iCKvMVsJFBrojIyNj/9tMoPO5M/369F1/MB2AZCpAThWkf/3sWj3zRsB0WJcsgLf6HhJdW2BgSPdt7DF9HoPx++6dVC6XpD0HR1I8I7rSL53qZCfbbe1WaiYK5ELBI/pdT+qfj1NzFxOJ9/p2/kNPpq8TiREWAgAAACgI/MURdqRbzZcs0LETtGWCmQ298UK5ZGGdEwF8MBTW5u4+fe/X2yxXAqYSlrT34Ij+7xULdfV/bFX/gcNxj4ut9HOiOtnJmaR27894gVwoaO41nZq7aJbd/9CT7evEMZbCwtWrV+s///M/9ac//UkTJ07Upz71Kd1555067bTTkj7viSee0E033aTt27drzpw5uvPOO3XhhRemdeEAAAAASgt/cYRd6VbzJdsOnA+VrqmCdLvSCeBTzSF0Sv+hw7r9knqtXNshKXmln5PVyU62lGd7XIFTcxfNsvsferJ9nTjGbeXgl156SVdddZU2b96s9evXa2RkROeff74OHDiQ8DmvvPKKli9friuvvFKvv/66Pv/5z+vzn/+8Ojs70754AAAAAKWDvzgiGAqrrbtPT2/9QG3dfQrGDrPLICPQuXj+TDXOnqotO/aYDkAyLdMBudXzG9V7mQ4KpdHfd6PSz+eN/t33eT1jlYLBUFgPb+ox9TPb3N1n6rVj74lCGX9gzF1MdLUujbZlp5q7aJbd/9CT7evEMZYqC1tbW6O+fvjhhzV9+nRt2bJFZ599dtzn3HPPPWpqatJ1110nSbr11lu1fv163XvvvfrZz35m87IBAAAAlBqnFgugMOXbFux8qnTNdEBu5fzJqvecFPv7bnWxRjJXrevQHV84w9H7yu5ClUxwcu6iGXb/Q0+2rxPHpDWzcGBgQJJUU5P4/xm3tbXp29/+dtRjn/3sZ/XUU08lfM7w8LCGh4+t+R4cHF1XPzIyEjVstlgY76kY3xuKF/ctChX3LgoR9y0KVSbu3X+76DRd+/hWSfH/4vhvF52mUPCI6dldKAwb3tqpax/fqrCkyrJjj+/Zf0jXPLpFd//9fC2ZO8OR1zJ7306bNEGVZakjsWmTJmT8n98fm1Wlk6ZUaudg/CDdLpekGdWjG6LNvof2nn717z8U9XNyWrLf94+fWC2pWpIUCh7R7zvj3zvJHDp82NH7asNbO3XHs39S72DEfMNqj753wemO3beStX/mnnfaNP300jMTXtd5p01z7L41c39OmVSueX993LjXzOZ1lgKzn5UrHA7b+mdJKBTS5z73Oe3du1cvv/xywuMqKir0yCOPaPny5WOP/fSnP1Vzc7N27twZ9zk333yzmpubxz2+bt06TZo0yc7lAgAAAAAAACXr4MGDuvTSSzUwMKDq6uqEx9muLLzqqqvU2dmZNCi064YbboiqRhwcHNQJJ5yg888/P+mbKVQjIyNav369li5dqvLy8lxfDmAK9y0KFfcuChH3LQpVJu/dYCisLTv2aPf+YU07rlILTppCK1qRau/p11ceeTXlcT//x0840oJu5b41Kh6l+JWuTlY8mpGogu3C+hn6xSs7xl1nMnYr38z+vBI53lOuu744Ty63S/0HDmvacZWaf8Lx2vr+Xsu/7+lei5TefRUMhfXZn2yM+nlEMio3n7vm7LH3k+yfban+uWfm3s3lPzvj3Z+R8u33xunKz3xgdO6mYiss/OY3v6nf/OY32rhxo2bNmpX0WJ/PN66CcOfOnfL5fAmfU1lZqcrKynGPl5eXF/W/IBf7+0Nx4r5FoeLeRSHivkWhysS9Wy7prFOL6y9xiG/3wSMaDqYOM3YfPOLofWbmvr1g3iy53GV5M0vxgnmzdH79zLiz8c48aZqluX23/918nTVnmuVrWHTKdNUcNzHhbNFEjJ9w8yXzdPbc8Z+bnd93s/dOqnPYua+CobD+f5t7tGPPsJRwRYe0Y8+wtrw3qLPmTEs6l1OS6fss0b2b67mfF8ybpfPq/lqLVj+v/gOH4x7jknTLb9/W+fUzsxJitnYG9M/r3jh6rx57vff2DOuf170xtiCnWJi9ly2FheFwWN/61rf05JNP6sUXX1RtbW3K5zQ2Nur555/XNddcM/bY+vXr1djYaOWlAQAAAAAlKN+3YCdbrJELxobeWMZ13r3+z7r3D++mPM/uA8Mpj0nky584UXdv+PO4x41P5Otn1+qZNwJRoZUvA6GVE/fEtMmVauvuG/vZLjhpirbs2JP0Z21nocrff2KW7t/YMy5g7R0Y0jfWdsR9Xu/AkFau7TAVaBkbquOd3+w5nLBlx56EQaEUvUU83n3spGTLeMIavV+bW7q0tM5XcpXrlsLCq666SuvWrdPTTz+tqqoq9fb2SpK8Xq8mTpwoSbr88ss1c+ZMrV69WpJ09dVX69Of/rR+/OMf66KLLtJjjz2m1157Tffff7/DbwUAAAAAUGwKYQt2ooAu35S5XTrrlGmmwkI7QVuqkCwyEPxu09yMB6yp7p1kXJK8k8r1nSfeiGpPdbukUMTJYivzEoVyyew9NKL7NvbE/V6y88QGWonkUyiWT1vE23v6kwa62Qwu843bysFr1qzRwMCAPvOZz8jv94/9efzxx8eOee+99xQIBMa+/tSnPqV169bp/vvv15lnnqlf/epXeuqpp1RfX+/cuwAAAAAAFKUyt2usDTM2xjC+XrWsruQqf+wyArREn5ZLowGY1fDVCMkShS/XLpmjl68/dyxUMwLWi+fPVOPsqRn5+Zm5dxJ9Lyxp78GRcfP1QjGJm1GZ19oZSBrKZUpkoJWI2VBsc3ef2rr79PTWD9TW3adg7Jt1QD5VCudTcJlvLLchp/Liiy+Oe+xLX/qSvvSlL1l5KQAAAAAAJI220K5Z0TCuai0TravFzgjQVq7tGAvFDHbD11QhmUvSY6++r2+eO8feRce8lpWKxFT3jjR+FuCM6koNHQlp78GRlNcTWZlX5Sk33XrstNFAK/5CWLNh11XrOrT30LH37Kuu1PKFJ+rkaZMdq/7Mp0rhaceN35URT65GHOSS7W3IAAAAAABkS77NBixkToev2WrntLugI9W9E/u9UDisyx78o+nrMt5fW3ef7feWrmSBltlQLDIolKTewWHdveGdsa+dWIaSibDajtbOgG5+5s2kx+TDiINcISwEAAAAABSEQpkNWAicDF+z0c6Z7oKOZPdO7Pee3vqBzavMZgPyqMhAKxQ8Mu77ZkIxs5xahpLrSmEzcyVLfcQBYSEAAAAAACXIqfA103Posr2gw+51Nn5kmn7d8YGthSqGeNV24STfk44FWqFg9LnsLFtJxsnPOleVwmbnSpb6iAPCQgAAAAAAYFum59Ble2ut1S3KxvtbNHtq0hbbVKHf18+u1TNvBEzPVowMtIxZjtLo5/WJj/yVqVDs+Inl49qPk4lchuJ2u7Rr35CmTa6UXNLu/cOWQr9cVAqnupcMP/rimTprzrQsXFF+IiwEAAAAAGSV1SUVyG+ZnkOXi621X/7Eibp7w59THhf7/uwsVIkM/b7bNNf0bEXje8Ysx/79h/TDhdJXHnlVkz0V6j+QOgS86pxTdNvv3rLwyRx9XswylEhOzDbM1D8jzN4juw8Mp/1ahYywEAAAAACQNXaXVCC/ZXIOXabbnCPFuz8juV1SKCINjff+rC5UifyeldmKxvUarcaVZcceNxMUStK04yosVVEaklUjpjvbMJP/jMjmvVTICAsBAAAAAFmR7pIK5LdMzaHLdJuzIdWMv2uXzNHKz5yiLTv2pHx/VkM/O8zO30vG552YsCrUrnRmG2b6nxHZupcKnTvXFwAAAAAAKH6pllRIo+FCMOTUOgbkghGEXTx/phpnT3WkddRoc5aOtf0anNpamyp4c0l67NX3M/L+7DI7fy8el0ar9RbW1oxVhfq8zlXTRc6RNOvwkZBufLIzo/+MyMa9VAwICwEAAAAAGWdlSQUQK1Gg5fN6HKlILcT70+6MxnihWFO9Xy9ff64e/doi3fPl+bp2yanyVUd/1sdPLM/YNbZ2BrRo9Qb1Hzic8BinfgaZvpeKAW3IAAAAAICMy8WSChSXTLU5S4V5f5qdq1czuSIqhEs0RzK2Pfqb554S9VmHwmFd9uAfHb/GVO3fsWJ/BnaWoWTyXioGhIUAAAAAgIxjsQCc4NS8v1iFeH+anb/30nXnmJqzGCv2sw6GwqaXoZid/Wdn7mLkz8DKMpR4oWIm7qViQFgIAAAAAMg4FgsgnxXi/WnM3zOWk0SKbDWumOB2JBSLfb1k8x2N104VSlqZuxj7M7CyDIUt7NYwsxAAAAAAkHEsFkA+K9T7M9vz98wsQ7Hy2lbbuo2fgZWFSUaoGBtKGqFia2fA0jWUAioLAQAAAABZYQQNsRU+iWaoAdlUqPenMX9v87u7tPutzfr5P35Ci06ZnrFgM3be37TJlZJL2r1/eFybc6p5gmbbuqdOrtBtl9SP/QzMLqR55Z3dSTcsuzQaKi6t8+VdEJxLhIUAAAAAgKxhsQDyWaHen2VulxbW1uh3bykr12tmdqSZ1t9U7d+SVDO5XG03nKeKCaPNscFQWJve3W3qOr/xyy06cDiY8PuRG5aZX3gMYSEAAAAAIKsytaQCiGRnS67E/ekEs/MEk81BNH5St19yxlhQGC+ATCZZUBgpn7Zc5wPCQgAAAAAAUFRYaJE7qeYJxrb+mm3/ThRAOiGftlznA8JCAAAAAABQNKxsyYXzzM4TjGz9TdX+nSyATEc+brnOB4SFAAAAAACgKFitaoPzzLb0xh6XrP07VQCZjnzccp1r7lxfAAAAAAAAgBOsVLUhM8y29Fpp/c3ETMGpkyuoMk2AykIAAAAAAFAU7Fa1wTmpNhzbaf11eqZg7IZlRONTAQAAAAAARSETVW2wxthwLB3baGwwvrba+msEkOk2C7uO/oncsIzx+GQAAAAAAEBRSBUquTS6FZmFFtYEQ2G1dffp6a0fqK27T8FQ8lUjxoZjnzc6lPV5PbZaf5MFkFbYff1SQxsyAAAAAAAFLBgKJ9wiW2qMUGnl2g65pKg2WLtVbaWutTOg5pauqFmQfq9Hq5bVJQ3dUm04tsoIIONdy+fO9Ov+jT2SFLf1+cqzTtaSOl9J/25YQVgIAAAAAECBshvkFLNEoZKvxD8XO1o7A1q5tmNcANc7MKSVaztSVukl23BsR7IA8mMnTuF3wSGEhQAAAAAAFKB0g5xi5nRVWykKhsJqbumKW6kX1milZnNLl5bW+bL6uSYKIPmZ/3/t3W1M1XUfx/HPQQE1PSBxcyCU8CYdcbOyZGcta8GFOOcse2DmtdnNdBpu3ZhL25LqCc62tmrOHrRlD5qWLXO5bJkIzkIMknlXTBhFJcjSAUcRRc73etDh7DrewXVNzp/jeb+2s8H5/c7Z768ffvv78c/53zqUhQAAAAAARJiRWuSMJLf6qrZoc7jlXMhVelczSW1dvTrccm7E/Dnzd35rcIMTAAAAAAAizP9S5AD/jw7fjfP1/8xD5KAsBAAAAAAgwlDkYLilThgz+KT/YR4iB2UhAAAAAAARhiIHw212dpLSE8boRr/E7tI/NxCZnZ0UzmUhDCgLAQAAAACIMBQ5GG6jYlwqX5AjSdfkbOD78gU5UfuZmLczykIAAAAAACIMRQ7CoTQ3XVv+fb88CaFXqHoSxkT13bZvd9wNGQAAAACACDRQ5Lz19cmQm514EsaofEEORQ5uidLcdP0rx6PDLefU4etV6oR/rliliL59URYCAAAAABChKHIQDqNiXPJOvdPpZSBMKAsBAAAAAIhgFDkAbiU+sxAAAAAAAACAJMpCAAAAAAAAAAGUhQAAAAAAAAAkURYCAAAAAAAACKAsBAAAAAAAACCJshAAAAAAAABAAGUhAAAAAAAAAEmUhQAAAAAAAAACKAsBAAAAAAAASKIsBAAAAAAAABBAWQgAAAAAAABAEmUhAAAAAAAAgADKQgAAAAAAAACSKAsBAAAAAAAABFAWAgAAAAAAAJBEWQgAAAAAAAAggLIQAAAAAAAAgCTKQgAAAAAAAAABlIUAAAAAAAAAJFEWAgAAAAAAAAgY7fQChsLMJEnd3d0Or2R49PX1qaenR93d3YqNjXV6OcCQkFtEKrKLSERuEanILiIRuUWkIrsYzECvNtCz3UhElIU+n0+SNGnSJIdXAgAAAAAAAEQun8+nhISEG467bLA6cQTw+/06ffq0JkyYIJfL5fRybrnu7m5NmjRJf/zxh9xut9PLAYaE3CJSkV1EInKLSEV2EYnILSIV2cVgzEw+n08ZGRmKibnxJxNGxJWFMTExyszMdHoZw87tdvMDjYhDbhGpyC4iEblFpCK7iETkFpGK7OJmbnZF4QBucAIAAAAAAABAEmUhAAAAAAAAgADKwhEgPj5e5eXlio+Pd3opwJCRW0QqsotIRG4RqcguIhG5RaQiu7hVIuIGJwAAAAAAAACGH1cWAgAAAAAAAJBEWQgAAAAAAAAggLIQAAAAAAAAgCTKQgAAAAAAAAABlIUO27x5s+6++26NGTNGhYWFOnz4sNNLAkK8+eabcrlcIY+ZM2cGx3t7e1VWVqY777xT48eP15NPPqkzZ844uGJEowMHDmjBggXKyMiQy+XSV199FTJuZtqwYYPS09M1duxYFRcX69SpUyFzzp07p6VLl8rtdisxMVHPP/+8zp8/H8ajQDQaLLvPPPPMNXtwaWlpyByyi3CrqKjQgw8+qAkTJig1NVWPP/64GhsbQ+YM5fygtbVV8+fP17hx45Samqq1a9fqypUr4TwURJGh5PbRRx+9Zs9duXJlyBxyi3DbsmWL8vPz5Xa75Xa75fV6tWfPnuA4+y2GA2Whgz777DO98sorKi8v188//6yCggLNnTtXHR0dTi8NCHHvvfeqra0t+Dh48GBw7OWXX9bXX3+tHTt2qLq6WqdPn9aiRYscXC2i0YULF1RQUKDNmzdfd3zTpk16//339eGHH6q2tlZ33HGH5s6dq97e3uCcpUuX6sSJE9q7d692796tAwcOaMWKFeE6BESpwbIrSaWlpSF78LZt20LGyS7Crbq6WmVlZTp06JD27t2rvr4+lZSU6MKFC8E5g50f9Pf3a/78+bp8+bJ+/PFHffLJJ9q6das2bNjgxCEhCgwlt5K0fPnykD1306ZNwTFyCydkZmZq48aNqq+vV11dnR577DEtXLhQJ06ckMR+i2FicMzs2bOtrKws+H1/f79lZGRYRUWFg6sCQpWXl1tBQcF1xzo7Oy02NtZ27NgRfO6XX34xSVZTUxOmFQKhJNnOnTuD3/v9fvN4PPbOO+8En+vs7LT4+Hjbtm2bmZmdPHnSJNlPP/0UnLNnzx5zuVz2119/hW3tiG5XZ9fMbNmyZbZw4cIbvobsYiTo6OgwSVZdXW1mQzs/+OabbywmJsba29uDc7Zs2WJut9suXboU3gNAVLo6t2ZmjzzyiL344os3fA25xUgxceJE++ijj9hvMWy4stAhly9fVn19vYqLi4PPxcTEqLi4WDU1NQ6uDLjWqVOnlJGRoSlTpmjp0qVqbW2VJNXX16uvry8kxzNnztTkyZPJMUaMlpYWtbe3h+Q0ISFBhYWFwZzW1NQoMTFRDzzwQHBOcXGxYmJiVFtbG/Y1A/+tqqpKqampmjFjhlatWqWzZ88Gx8guRoKuri5JUlJSkqShnR/U1NQoLy9PaWlpwTlz585Vd3d38GoZYDhdndsBn376qZKTk5Wbm6v169erp6cnOEZu4bT+/n5t375dFy5ckNfrZb/FsBnt9AKi1d9//63+/v6QH1hJSktL06+//urQqoBrFRYWauvWrZoxY4ba2tr01ltv6eGHH9bx48fV3t6uuLg4JSYmhrwmLS1N7e3tziwYuMpAFq+33w6Mtbe3KzU1NWR89OjRSkpKIstwVGlpqRYtWqTs7Gw1Nzfr9ddf17x581RTU6NRo0aRXTjO7/frpZde0kMPPaTc3FxJGtL5QXt7+3X35YExYDhdL7eS9PTTTysrK0sZGRk6evSoXnvtNTU2NurLL7+URG7hnGPHjsnr9aq3t1fjx4/Xzp07lZOTo4aGBvZbDAvKQgA3NW/evODX+fn5KiwsVFZWlj7//HONHTvWwZUBwO3vqaeeCn6dl5en/Px8TZ06VVVVVSoqKnJwZcA/ysrKdPz48ZDPMwZGuhvl9r8/7zUvL0/p6ekqKipSc3Ozpk6dGu5lAkEzZsxQQ0ODurq69MUXX2jZsmWqrq52elm4jfFryA5JTk7WqFGjrrlL0ZkzZ+TxeBxaFTC4xMRE3XPPPWpqapLH49Hly5fV2dkZMoccYyQZyOLN9luPx3PNzaWuXLmic+fOkWWMKFOmTFFycrKampokkV04a/Xq1dq9e7f279+vzMzM4PNDOT/weDzX3ZcHxoDhcqPcXk9hYaEkhey55BZOiIuL07Rp0zRr1ixVVFSooKBA7733Hvsthg1loUPi4uI0a9Ys7du3L/ic3+/Xvn375PV6HVwZcHPnz59Xc3Oz0tPTNWvWLMXGxobkuLGxUa2treQYI0Z2drY8Hk9ITru7u1VbWxvMqdfrVWdnp+rr64NzKisr5ff7g/9QAEaCP//8U2fPnlV6eroksgtnmJlWr16tnTt3qrKyUtnZ2SHjQzk/8Hq9OnbsWEjZvXfvXrndbuXk5ITnQBBVBsvt9TQ0NEhSyJ5LbjES+P1+Xbp0if0Ww8fpO6xEs+3bt1t8fLxt3brVTp48aStWrLDExMSQuxQBTluzZo1VVVVZS0uL/fDDD1ZcXGzJycnW0dFhZmYrV660yZMnW2VlpdXV1ZnX6zWv1+vwqhFtfD6fHTlyxI4cOWKS7N1337UjR47Y77//bmZmGzdutMTERNu1a5cdPXrUFi5caNnZ2Xbx4sXge5SWltp9991ntbW1dvDgQZs+fbotWbLEqUNClLhZdn0+n7366qtWU1NjLS0t9v3339v9999v06dPt97e3uB7kF2E26pVqywhIcGqqqqsra0t+Ojp6QnOGez84MqVK5abm2slJSXW0NBg3377raWkpNj69eudOCREgcFy29TUZG+//bbV1dVZS0uL7dq1y6ZMmWJz5swJvge5hRPWrVtn1dXV1tLSYkePHrV169aZy+Wy7777zszYbzE8KAsd9sEHH9jkyZMtLi7OZs+ebYcOHXJ6SUCIxYsXW3p6usXFxdldd91lixcvtqampuD4xYsX7YUXXrCJEyfauHHj7IknnrC2tjYHV4xotH//fpN0zWPZsmVmZub3++2NN96wtLQ0i4+Pt6KiImtsbAx5j7Nnz9qSJUts/Pjx5na77dlnnzWfz+fA0SCa3Cy7PT09VlJSYikpKRYbG2tZWVm2fPnya/5Tkewi3K6XWUn28ccfB+cM5fzgt99+s3nz5tnYsWMtOTnZ1qxZY319fWE+GkSLwXLb2tpqc+bMsaSkJIuPj7dp06bZ2rVrraurK+R9yC3C7bnnnrOsrCyLi4uzlJQUKyoqChaFZuy3GB4uM7PwXccIAAAAAAAAYKTiMwsBAAAAAAAASKIsBAAAAAAAABBAWQgAAAAAAABAEmUhAAAAAAAAgADKQgAAAAAAAACSKAsBAAAAAAAABFAWAgAAAAAAAJBEWQgAAAAAAAAggLIQAAAAAAAAgCTKQgAAAAAAAAABlIUAAAAAAAAAJFEWAgAAAAAAAAj4D3H0F+e+yve/AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1600x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def train(\n",
    "    model: sfr.SFR,\n",
    "    data_loader: DataLoader,\n",
    "    num_epochs: int = 1000,\n",
    "    batch_size: int = 16,\n",
    "    learning_rate: float = 1e-3,\n",
    ") -> dict:\n",
    "    model.train()\n",
    "    optimizer = torch.optim.Adam([{\"params\": model.parameters()}], lr=learning_rate)\n",
    "    loss_history = []\n",
    "    for epoch_idx in range(num_epochs):\n",
    "        for batch_idx, batch in enumerate(data_loader):\n",
    "            x, y = batch\n",
    "            loss = model.loss(x, y)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            loss_history.append(loss.detach().numpy())\n",
    "\n",
    "        if epoch_idx % 20 == 0:\n",
    "            clear_output(True)\n",
    "            plt.figure(figsize=[16, 8])\n",
    "            plt.subplot()\n",
    "            plt.title(\"Loss = %.3f\" % np.mean(loss_history[-32:]))\n",
    "            losses = np.array(loss_history)\n",
    "            losses_idx = np.arange(len(losses))\n",
    "            plt.scatter(losses_idx, losses)\n",
    "            plt.grid()\n",
    "            plt.show()\n",
    "\n",
    "    return {\"loss\": loss_history}\n",
    "\n",
    "\n",
    "metrics = train(\n",
    "    model=model,\n",
    "    data_loader=train_loader,\n",
    "    num_epochs=num_epochs,\n",
    "    batch_size=batch_size,\n",
    "    learning_rate=learning_rate,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fa1ce9b-3b58-4683-91d8-edc421ca1e37",
   "metadata": {},
   "source": [
    "Let's create a helper function which can calculate the NLPD/accuracy/ECE of the NN and SFR on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fc78a9fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "@torch.no_grad()\n",
    "def evaluate(model: sfr.SFR, data_loader: DataLoader, sfr_pred: bool = False):\n",
    "    model.eval()\n",
    "    probs, targets, val_losses = [], [], []\n",
    "    dtype = next(model.parameters()).dtype  # because change NN from float to double\n",
    "    for data, target in data_loader:\n",
    "        data = data.to(dtype).to(device)\n",
    "        target = target.to(device)\n",
    "        if sfr_pred:  # predict with SFR\n",
    "            probs.append(model(data.to(device))[0])\n",
    "        else:  # predict with NN\n",
    "            probs.append(torch.softmax(model.network(data), dim=-1))\n",
    "        targets.append(target)\n",
    "        val_losses.append(model.loss(data, target))\n",
    "\n",
    "    val_loss = torch.mean(torch.stack(val_losses, 0)).cpu().numpy().item()\n",
    "    targets = torch.cat(targets, dim=0).cpu().numpy()\n",
    "    probs = torch.cat(probs).cpu().numpy()\n",
    "    acc = (probs.argmax(-1) == targets).mean()\n",
    "    ece = ECE(bins=15).measure(probs, targets)\n",
    "    dist = torch.distributions.Categorical(torch.Tensor(probs))\n",
    "    nlpd = -dist.log_prob(torch.Tensor(targets)).mean().numpy()\n",
    "    metrics = {\"loss\": val_loss, \"acc\": acc, \"nlpd\": nlpd, \"ece\": ece}\n",
    "    model.train()\n",
    "    return metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adb5fd70-b4c7-4251-9c1f-8c38105258f4",
   "metadata": {},
   "source": [
    "Let's check the NLPD/accuracy/ECE of the NN (before fitting SFR) on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "46936c89-2987-4398-b394-c86bde4c87c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': 2.262396812438965,\n",
       " 'acc': 0.7575757575757576,\n",
       " 'nlpd': 0.7646384,\n",
       " 'ece': 0.07412855402387754}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model=model, data_loader=test_loader, sfr_pred=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bf28f064-6346-47bb-944b-0051f839b078",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': 0.12023645333980554,\n",
       " 'acc': 1.0,\n",
       " 'nlpd': 0.03060293131827908,\n",
       " 'ece': 0.02808798550955894}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model=model, data_loader=train_loader, sfr_pred=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9e666b2",
   "metadata": {},
   "source": [
    "## Inference"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec6ee22",
   "metadata": {},
   "source": [
    "Now that we have a trained neural network, we can use `sfr.SFR` to build our sparse GP model.\n",
    "That is, we perform inference by calculating the dual variables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed3f8b7a",
   "metadata": {},
   "source": [
    "To perform inference `sfr.SFR` first calculates the dual parameters at each data point.\n",
    "It then samples a set of inducing points from the inputs and projects the dual parameters onto them.\n",
    "This is done with `SFR.fit(train_loader)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "da5060da",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:sfr:Calculating dual params...\n",
      "INFO:sfr:Finished calculating dual params\n",
      "INFO:sfr:Project dual params onto inducing points...\n",
      "INFO:root:Computing covariance for output dim 1/10\n",
      "INFO:root:Computing covariance for output dim 2/10\n",
      "INFO:root:Computing covariance for output dim 3/10\n",
      "INFO:root:Computing covariance for output dim 4/10\n",
      "INFO:root:Computing covariance for output dim 5/10\n",
      "INFO:root:Computing covariance for output dim 6/10\n",
      "INFO:root:Computing covariance for output dim 7/10\n",
      "INFO:root:Computing covariance for output dim 8/10\n",
      "INFO:root:Computing covariance for output dim 9/10\n",
      "INFO:root:Computing covariance for output dim 10/10\n",
      "INFO:sfr:Finished projecting dual params onto inducing points\n"
     ]
    }
   ],
   "source": [
    "model.fit(train_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f508592",
   "metadata": {},
   "source": [
    "We can now evaluate SFR's NLPD/accuracy/ECE on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ec33ac7b-9a43-4839-b01f-2f2bd823b766",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': 2.2623964670182435,\n",
       " 'acc': 0.3838383838383838,\n",
       " 'nlpd': 2.0093064,\n",
       " 'ece': 0.21064715499849296}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model=model, data_loader=test_loader, sfr_pred=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dc371f26-0fb7-4034-889f-bfdbe449ec4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': 1.7657780173186906,\n",
       " 'acc': 0.31,\n",
       " 'nlpd': 1.9386634,\n",
       " 'ece': 0.09784363041190475}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evaluate(model=model, data_loader=train_loader, sfr_pred=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b108c33d-ec5b-4372-8cd6-957eb8316aea",
   "metadata": {},
   "source": [
    "## Out-of-distribution (OOD) Detection\n",
    "Train on Fashion-MNIST and test on CIFAR-10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "fceebc62-48cb-44a7-8945-45f48b06cc33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Calculated with ds_train.data.mean(axis=(0,1,2))/255\n",
    "# normalize_transform_cifar = transforms.Normalize((0.49139968, 0.48215841, 0.44653091), (0.24703223, 0.24348513, 0.26158784))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "30840e4c-4257-4032-a134-20ae72980126",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/CIFAR10/cifar-10-python.tar.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 170498071/170498071 [00:20<00:00, 8304871.88it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting data/CIFAR10/cifar-10-python.tar.gz to data/CIFAR10\n"
     ]
    }
   ],
   "source": [
    "# transform_cifar = transforms.Compose([transforms.ToTensor(), normalize_transform_cifar])\n",
    "# ds_ood = torchvision.datasets.CIFAR10(\"data/CIFAR10\", download=True, train=True, transform=transform_cifar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eea7890e-e0eb-47f3-869f-966cc4157381",
   "metadata": {},
   "outputs": [],
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}