SSVAE_CRNN_m_II_with_Pyro_H_alpha_better_scale.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "SSVAE_CRNN_m.II_with_Pyro_H_alpha_better_scale.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMb8myDghKQBK7l67rIV8W9",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/TheMrGhostman/Semi-supervised-Learning-with-VAE/blob/master/SSVAE_CRNN_m_II_with_Pyro_H_alpha_better_scale.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1_HC7lL8d--C",
        "colab_type": "code",
        "outputId": "81a80ef9-42e4-4c31-cee9-c7e3aebe6d0f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        }
      },
      "source": [
        "!pip install pyro-ppl"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting pyro-ppl\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/c0/77/4db4946f6b5bf0601869c7b7594def42a7197729167484e1779fff5ca0d6/pyro_ppl-1.3.1-py3-none-any.whl (520kB)\n",
            "\u001b[K     |████████████████████████████████| 522kB 4.5MB/s \n",
            "\u001b[?25hRequirement already satisfied: tqdm>=4.36 in /usr/local/lib/python3.6/dist-packages (from pyro-ppl) (4.41.1)\n",
            "Requirement already satisfied: torch>=1.4.0 in /usr/local/lib/python3.6/dist-packages (from pyro-ppl) (1.5.0+cu101)\n",
            "Requirement already satisfied: numpy>=1.7 in /usr/local/lib/python3.6/dist-packages (from pyro-ppl) (1.18.5)\n",
            "Collecting pyro-api>=0.1.1\n",
            "  Downloading https://files.pythonhosted.org/packages/fc/81/957ae78e6398460a7230b0eb9b8f1cb954c5e913e868e48d89324c68cec7/pyro_api-0.1.2-py3-none-any.whl\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.6/dist-packages (from pyro-ppl) (3.2.1)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch>=1.4.0->pyro-ppl) (0.16.0)\n",
            "Installing collected packages: pyro-api, pyro-ppl\n",
            "Successfully installed pyro-api-0.1.2 pyro-ppl-1.3.1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gloUNUFqedAt",
        "colab_type": "code",
        "outputId": "622ecfc2-d285-44b2-f989-6b60d9eae400",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        }
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Fri Jun 12 12:33:30 2020       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 450.36.06    Driver Version: 418.67       CUDA Version: 10.1     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   64C    P0    42W / 250W |      0MiB / 16280MiB |      0%      Default |\n",
            "|                               |                      |                 ERR! |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ESS55soUeGST",
        "colab_type": "code",
        "outputId": "c8578e45-a751-49ec-84af-4f127ea48455",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        }
      },
      "source": [
        "!git clone https://github.com/TheMrGhostman/Semi-supervised-Learning-with-VAE.git"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'Semi-supervised-Learning-with-VAE'...\n",
            "remote: Enumerating objects: 105, done.\u001b[K\n",
            "remote: Counting objects: 100% (105/105), done.\u001b[K\n",
            "remote: Compressing objects: 100% (72/72), done.\u001b[K\n",
            "remote: Total 783 (delta 50), reused 76 (delta 33), pack-reused 678\u001b[K\n",
            "Receiving objects: 100% (783/783), 321.05 MiB | 31.85 MiB/s, done.\n",
            "Resolving deltas: 100% (281/281), done.\n",
            "Checking out files: 100% (496/496), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3yHtmorsZMLa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "os.chdir(\"Semi-supervised-Learning-with-VAE\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IsRdYWjMeGXD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import time\n",
        "\n",
        "import numpy as np\n",
        "import torch\n",
        "\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "import pyro\n",
        "import pyro.distributions as dist\n",
        "import pyro.contrib.examples.util  # patches torchvision\n",
        "\n",
        "from pyro.infer import SVI, JitTrace_ELBO, JitTraceEnum_ELBO, Trace_ELBO, TraceEnum_ELBO, config_enumerate\n",
        "from pyro.optim import Adam\n",
        "\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3T5yj7HneGZi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from utils.inception import Inception, InceptionBlock, correct_sizes\n",
        "from utils import layers"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9AMXRpfVeGb_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from utils.datasets import SupervisedDataset\n",
        "from utils.utils import One_Hot"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ujF47fbFeGed",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import RobustScaler, StandardScaler\n",
        "from sklearn.metrics import confusion_matrix, accuracy_score, f1_score\n",
        "\n",
        "from utils.layers import Reshape, Flatten\n",
        "import utils.datasets as d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b8VTb33neGhJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class VariationalLayer(nn.Module):\n",
        "    \"\"\"\n",
        "    Variational Layer with reparametrization trick. \n",
        "    It's used as bottleneck of Variational AutoEncoder ie. output of encoder.\n",
        "\n",
        "    \"Linear layer for variational inference with reparametrization trick\"\n",
        "    \"\"\"\n",
        "    def __init__(self, in_features, out_features, bias=True):\n",
        "        \"\"\"\t\n",
        "        : param in_features: \t\tNumber of input features (number of neurons on input)\n",
        "        : param out_features:\t\tNumber of output features (number of neurons on output)\n",
        "        : param bias:\t\t\t\tInclude bias - True/False\n",
        "        \"\"\"\n",
        "        super(VariationalLayer, self).__init__()\n",
        "        self.mu = nn.Linear(in_features=in_features, out_features=out_features, bias=bias)\n",
        "        self.rho = nn.Linear(in_features=in_features, out_features=out_features, bias=bias)\n",
        "        self.softplus = nn.Softplus()\n",
        "\n",
        "    def forward(self, x_in):\n",
        "        mu = self.mu(x_in)\n",
        "        sigma = self.softplus(self.rho(x_in))\n",
        "        return mu, sigma"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "00FwQrFfeGje",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ConvTransposeDecoderOutput(nn.Module):\n",
        "    def __init__(self, in_channels, in_features, out_features, kernel_size, stride=1, padding=0, bias=True):\n",
        "        super(ConvTransposeDecoderOutput, self).__init__()\n",
        "        self.mu = nn.ConvTranspose1d(\n",
        "                in_channels=in_channels, \n",
        "                out_channels=1, \n",
        "                kernel_size=kernel_size, \n",
        "                stride=stride, \n",
        "                padding=padding\n",
        "            )\n",
        "        self.rho = nn.Linear(in_features=in_features, out_features=1, bias=bias)\n",
        "        self.flatten = Flatten(out_features=in_features)\n",
        "        self.flatten_mu = Flatten(out_features=out_features)\n",
        "        self.softplus = nn.Softplus()\n",
        "\n",
        "    def forward(self, x_in):\n",
        "        \"\"\"\n",
        "        x must be shape ... (-1, in_channels, size)\n",
        "        \"\"\"\n",
        "        mu = self.mu(x_in)\n",
        "        x = self.flatten(x_in)\n",
        "        sigma = self.softplus(self.rho(x))\n",
        "        return self.flatten_mu(mu), sigma"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdFs2oTygccn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Encoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Encoder, self).__init__()\n",
        "        self.first_part =  nn.Sequential(\n",
        "                Reshape(out_shape=(1, 160)),\n",
        "                nn.Conv1d(in_channels=1, out_channels=16, kernel_size=6, stride=2, padding=0, bias=False), # n*1*160 -> n*16*78\n",
        "                nn.PReLU(),\n",
        "                nn.Conv1d(in_channels=16, out_channels=32, kernel_size=4, stride=2, bias=False),#n*16*78->n*32*38\n",
        "                nn.BatchNorm1d(num_features=32),\n",
        "                nn.PReLU(),\n",
        "                nn.Conv1d(in_channels=32, out_channels=64, kernel_size=4, stride=2, bias=False),#n*32*38->n*64*18\n",
        "                nn.BatchNorm1d(num_features=64),\n",
        "                nn.PReLU(),\n",
        "                Flatten(out_features=64*18))\n",
        "        self.fc = nn.Linear(in_features=64*18+4, out_features=256)\n",
        "        self.act = nn.PReLU()\n",
        "        self.out = VariationalLayer(in_features=256, out_features=15)\n",
        "        \n",
        "    def forward(self, x,y):\n",
        "        z = self.first_part(x)\n",
        "        z = torch.cat([z,y], axis=1)\n",
        "        z = self.act(self.fc(z))\n",
        "        return self.out(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s-yqEMpSgcfR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "decoder = nn.Sequential(\n",
        "    nn.Linear(in_features=15+4, out_features=256),\n",
        "    nn.PReLU(),\n",
        "    nn.Linear(in_features=256, out_features=64*18),\n",
        "    Reshape(out_shape=(64,18)),\n",
        "    nn.BatchNorm1d(num_features=64),\n",
        "    nn.PReLU(),\n",
        "    nn.ConvTranspose1d(in_channels=64, out_channels=32, kernel_size=4, stride=2, padding=0),\n",
        "    nn.BatchNorm1d(num_features=32),\n",
        "    nn.PReLU(),\n",
        "    nn.ConvTranspose1d(in_channels=32, out_channels=16, kernel_size=4, stride=2, padding=0),\n",
        "    #nn.BatchNorm1d(num_features=16),\n",
        "    nn.PReLU(),\n",
        "    ConvTransposeDecoderOutput(\n",
        "        in_channels=16,\n",
        "        in_features=16*78,\n",
        "        out_features=160, \n",
        "        kernel_size=6, \n",
        "        stride=2\n",
        "        )\n",
        "    )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jakI5d4vLEoP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class LinAct(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(LinAct, self).__init__()\n",
        "\n",
        "    def forward(self, x):\n",
        "        return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4aoMVZNSgclj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class CRNN_mII(nn.Module):\n",
        "    def __init__(self, n_filters, kernel_sizes, rnn_out, bottleneck=1, sequence_len=160, bidirectional=True, activation=nn.Sigmoid()):\n",
        "        super(CRNN_mII, self).__init__()\n",
        "        self.sequence_len = sequence_len\n",
        "        # conv wants (batch, channel, length)\n",
        "        self.reshape_to_inception = layers.Reshape(out_shape=(1, self.sequence_len))\n",
        "        #self.reshape_from_lstm = layers.Reshape(out_shape=(rnn_out*(2**bidirectional)*sequence_len))\n",
        "        self.inception = Inception(\n",
        "                in_channels=1, \n",
        "                n_filters=32, \n",
        "                kernel_sizes=[5, 11, 23],\n",
        "                bottleneck_channels=32,\n",
        "                activation=nn.ReLU()\n",
        "            )\n",
        "        # RNN wants #(batch, seq, feature)\n",
        "        self.rnn1 = nn.LSTM(\n",
        "            input_size=n_filters*4,\n",
        "            hidden_size=rnn_out,\n",
        "            num_layers=1,\n",
        "            batch_first=True,\n",
        "            bidirectional=bidirectional\n",
        "        )\n",
        "        self.rnn2 = nn.LSTM(\n",
        "            input_size=rnn_out*(2**bidirectional),\n",
        "            hidden_size=rnn_out,\n",
        "            num_layers=1,\n",
        "            batch_first=True,\n",
        "            bidirectional=bidirectional\n",
        "        )\n",
        "        #self.pool = nn.AdaptiveAvgPool1d(output_size=1)\n",
        "        self.fc_on_rnn = nn.Linear(in_features=rnn_out*(2**bidirectional), out_features=bottleneck)\n",
        "        #self.fc_on_rnn = nn.Linear(in_features=rnn_out*(2**bidirectional)*sequence_len, out_features=128)\n",
        "        self.flatten = layers.Flatten(out_features=self.sequence_len*bottleneck)\n",
        "        self.fc = nn.Linear(in_features=self.sequence_len*bottleneck, out_features=4)\n",
        "        self.activation = activation\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "\n",
        "    def forward(self, x_in):\n",
        "        x = self.reshape_to_inception(x_in)\n",
        "        x = self.inception(x)\n",
        "        #print(x.shape)\n",
        "        x = x.permute(0,2,1)\n",
        "        #print(x.shape)\n",
        "        x, (h, c) = self.rnn1(x)\n",
        "        x, (h, c) = self.rnn2(x)\n",
        "        #print(x.shape)\n",
        "        #x = self.pool(x)\n",
        "        x = self.fc_on_rnn(x)\n",
        "        #print(x.shape)\n",
        "        x = self.flatten(x)\n",
        "        x = self.activation(x)\n",
        "        #print(x.shape)\n",
        "        return self.softmax(self.fc(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DA7YkHHhgcof",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "clf = CRNN_mII(n_filters=32, kernel_sizes=[5,11,23], rnn_out=100, activation=LinAct())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Md_xb2geg0h8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class SSVAE(nn.Module):\n",
        "    \"\"\"\n",
        "    This class encapsulates the parameters (neural networks) and models & guides needed to train a\n",
        "    semi-supervised variational auto-encoder on the MNIST image dataset\n",
        "    :param output_size: size of the tensor representing the class label (10 for MNIST since\n",
        "                        we represent the class labels as a one-hot vector with 10 components)\n",
        "    :param input_size: size of the tensor representing the image (28*28 = 784 for our MNIST dataset\n",
        "                       since we flatten the images and scale the pixels to be in [0,1])\n",
        "    :param z_dim: size of the tensor representing the latent random variable z\n",
        "                  (handwriting style for our MNIST dataset)\n",
        "    :param hidden_layers: a tuple (or list) of MLP layers to be used in the neural networks\n",
        "                          representing the parameters of the distributions in our model\n",
        "    :param use_cuda: use GPUs for faster training\n",
        "    :param aux_loss_multiplier: the multiplier to use with the auxiliary loss\n",
        "    \"\"\"\n",
        "    def __init__(self, config_enum=None, use_cuda=False, aux_loss_multiplier=None):\n",
        "\n",
        "        super().__init__()\n",
        "\n",
        "        # initialize the class with all arguments provided to the constructor\n",
        "        self.output_size = 4\n",
        "        self.z_dim = 15\n",
        "        self.allow_broadcast = config_enum == 'parallel'\n",
        "        self.use_cuda = use_cuda\n",
        "        self.aux_loss_multiplier = aux_loss_multiplier\n",
        "\n",
        "        # define and instantiate the neural networks representing\n",
        "        # the paramters of various distributions in the model\n",
        "        self.setup_networks()\n",
        "\n",
        "    def setup_networks(self):\n",
        "\n",
        "        self.encoder_y = clf\n",
        "\n",
        "        self.encoder_z = Encoder()\n",
        "\n",
        "        self.decoder = decoder\n",
        "\n",
        "        if self.use_cuda:\n",
        "            self.cuda()\n",
        "\n",
        "    def model(self, xs, ys=None):\n",
        "        \"\"\"\n",
        "        The model corresponds to the following generative process:\n",
        "        p(z) = normal(0,I)              # handwriting style (latent)\n",
        "        p(y|x) = categorical(I/10.)     # which digit (semi-supervised)\n",
        "        p(x|y,z) = bernoulli(loc(y,z))   # an image\n",
        "        loc is given by a neural network  `decoder`\n",
        "        :param xs: a batch of scaled vectors of pixels from an image\n",
        "        :param ys: (optional) a batch of the class labels i.e.\n",
        "                   the digit corresponding to the image(s)\n",
        "        :return: None\n",
        "        \"\"\"\n",
        "        # register this pytorch module and all of its sub-modules with pyro\n",
        "        pyro.module(\"ss_vae\", self)\n",
        "\n",
        "        batch_size = xs.size(0)\n",
        "        options = dict(dtype=xs.dtype, device=xs.device)\n",
        "        with pyro.plate(\"data\"):\n",
        "\n",
        "            # sample the handwriting style from the constant prior distribution\n",
        "            prior_loc = torch.zeros(batch_size, self.z_dim, **options)\n",
        "            prior_scale = torch.ones(batch_size, self.z_dim, **options)\n",
        "            zs = pyro.sample(\"z\", dist.Normal(prior_loc, prior_scale).to_event(1))\n",
        "\n",
        "            # if the label y (which digit to write) is supervised, sample from the\n",
        "            # constant prior, otherwise, observe the value (i.e. score it against the constant prior)\n",
        "            alpha_prior = torch.ones(batch_size, self.output_size, **options) / (1.0 * self.output_size)\n",
        "            ys = pyro.sample(\"y\", dist.OneHotCategorical(alpha_prior), obs=ys)\n",
        "\n",
        "            # finally, score the image (x) using the handwriting style (z) and\n",
        "            # the class label y (which digit to write) against the\n",
        "            # parametrized distribution p(x|y,z) = bernoulli(decoder(y,z))\n",
        "            # where `decoder` is a neural network\n",
        "            mu, sigma = self.decoder(torch.cat([zs, ys], axis=1))\n",
        "            #mu = self.decoder(torch.cat([zs, ys], axis=1))\n",
        "            #pyro.sample(\"x\", dist.Normal(mu,torch.ones((mu.shape[0],1)).cuda()).to_event(1), obs=xs)\n",
        "            pyro.sample(\"x\", dist.Normal(mu,sigma).to_event(1), obs=xs)\n",
        "            # return the loc so we can visualize it later\n",
        "            return mu\n",
        "\n",
        "    def guide(self, xs, ys=None):\n",
        "        \"\"\"\n",
        "        The guide corresponds to the following:\n",
        "        q(y|x) = categorical(alpha(x))              # infer digit from an image\n",
        "        q(z|x,y) = normal(loc(x,y),scale(x,y))       # infer handwriting style from an image and the digit\n",
        "        loc, scale are given by a neural network `encoder_z`\n",
        "        alpha is given by a neural network `encoder_y`\n",
        "        :param xs: a batch of scaled vectors of pixels from an image\n",
        "        :param ys: (optional) a batch of the class labels i.e.\n",
        "                   the digit corresponding to the image(s)\n",
        "        :return: None\n",
        "        \"\"\"\n",
        "        # inform Pyro that the variables in the batch of xs, ys are conditionally independent\n",
        "        with pyro.plate(\"data\"):\n",
        "\n",
        "            # if the class label (the digit) is not supervised, sample\n",
        "            # (and score) the digit with the variational distribution\n",
        "            # q(y|x) = categorical(alpha(x))\n",
        "            if ys is None:\n",
        "                alpha = self.encoder_y(xs)\n",
        "                ys = pyro.sample(\"y\", dist.OneHotCategorical(alpha))\n",
        "\n",
        "            # sample (and score) the latent handwriting-style with the variational\n",
        "            # distribution q(z|x,y) = normal(loc(x,y),scale(x,y))\n",
        "            loc, scale = self.encoder_z(xs, ys)\n",
        "            pyro.sample(\"z\", dist.Normal(loc, scale).to_event(1))\n",
        "\n",
        "    def classifier(self, xs):\n",
        "        \"\"\"\n",
        "        classify an image (or a batch of images)\n",
        "        :param xs: a batch of scaled vectors of pixels from an image\n",
        "        :return: a batch of the corresponding class labels (as one-hots)\n",
        "        \"\"\"\n",
        "        # use the trained model q(y|x) = categorical(alpha(x))\n",
        "        # compute all class probabilities for the image(s)\n",
        "        alpha = self.encoder_y(xs)\n",
        "\n",
        "        # get the index (digit) that corresponds to\n",
        "        # the maximum predicted class probability\n",
        "        res, ind = torch.topk(alpha, 1)\n",
        "\n",
        "        # convert the digit(s) to one-hot tensor(s)\n",
        "        ys = torch.zeros_like(alpha).scatter_(1, ind, 1.0)\n",
        "        return ys\n",
        "\n",
        "    def model_classify(self, xs, ys=None):\n",
        "        \"\"\"\n",
        "        this model is used to add an auxiliary (supervised) loss as described in the\n",
        "        Kingma et al., \"Semi-Supervised Learning with Deep Generative Models\".\n",
        "        \"\"\"\n",
        "        # register all pytorch (sub)modules with pyro\n",
        "        pyro.module(\"ss_vae\", self)\n",
        "\n",
        "        # inform Pyro that the variables in the batch of xs, ys are conditionally independent\n",
        "        with pyro.plate(\"data\"):\n",
        "            # this here is the extra term to yield an auxiliary loss that we do gradient descent on\n",
        "            if ys is not None:\n",
        "                alpha = self.encoder_y.forward(xs)\n",
        "                with pyro.poutine.scale(scale=self.aux_loss_multiplier):\n",
        "                    pyro.sample(\"y_aux\", dist.OneHotCategorical(alpha), obs=ys)\n",
        "\n",
        "    def guide_classify(self, xs, ys=None):\n",
        "        \"\"\"\n",
        "        dummy guide function to accompany model_classify in inference\n",
        "        \"\"\"\n",
        "        pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VDptyP9Bg0lc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_accuracy(data_loader, clf):\n",
        "    \"\"\"\n",
        "        clf ... ssvae.classifier()\n",
        "    \"\"\"\n",
        "    dataloader_len = len(data_loader)\n",
        "    acc = 0\n",
        "    with torch.no_grad():\n",
        "        for (xs, ys) in data_loader:\n",
        "            xs = xs.cuda()\n",
        "            pred = clf(xs)\n",
        "            acc += accuracy_score(np.argmax(pred.cpu().detach().numpy(), axis=1) , np.argmax(ys.numpy(),axis=1))\n",
        "    return acc/dataloader_len"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hF7digEHg0p-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def run_inference_for_epoch(data_loaders, losses):\n",
        "    \"\"\"\n",
        "        thanks to random sampler supervised and unsupervised datasets have the same length\n",
        "\n",
        "        two losses -> [ ELBO , -E(q(y|x)) ]\n",
        "    \"\"\"\n",
        "    num_losses = len(losses) \n",
        "\n",
        "    epoch_losses_sup = [0.] * num_losses\n",
        "    epoch_losses_unsup = [0.] * num_losses\n",
        "\n",
        "    sup_iter = iter(data_loaders[\"sup\"])\n",
        "    unsup_iter = iter(data_loaders[\"unsup\"])\n",
        "    \n",
        "    #model.train()\n",
        "    for batch_idx  in range(len(data_loaders[\"unsup\"])):\n",
        "        \n",
        "        # supervised flow\n",
        "        (xs, ys) = next(sup_iter)\n",
        "        for loss_id in range(num_losses):\n",
        "            # evaluating (tracing) losses and optimizer step \n",
        "            new_loss = losses[loss_id].step(xs.cuda(), ys.cuda())\n",
        "            # saving losses \n",
        "            epoch_losses_sup[loss_id] += new_loss\n",
        "        \n",
        "\n",
        "        # unsupervised flow\n",
        "        xs = next(unsup_iter)\n",
        "        for loss_id in range(num_losses):\n",
        "            # evaluating (tracing) losses and optimizer step \n",
        "            new_loss = losses[loss_id].step(xs.cuda())\n",
        "            # saving losses\n",
        "            epoch_losses_unsup[loss_id] += new_loss\n",
        "\n",
        "            \n",
        "    return epoch_losses_sup, epoch_losses_unsup"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1kFNmztgg_z1",
        "colab_type": "text"
      },
      "source": [
        "# Get Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VtyeYXSXg0tV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_s = np.vstack((np.load(\"data/sequenced_data_for_VAE_length-160_stride-10_pt1.npy\"),\n",
        "               np.load(\"data/sequenced_data_for_VAE_length-160_stride-10_pt2.npy\")))\n",
        "y_s = np.load(\"data/sequenced_data_for_VAE_length-160_stride-10_targets.npy\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VNy00mx6g8VZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_u = np.vstack((np.load(\"data/unlabeled_sequences_part_1.npy\"), np.load(\"data/unlabeled_sequences_part_2.npy\")))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xqelRgwg8YV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_train, X_test, y_train, y_test = train_test_split(np.array(X_s), np.array(y_s), test_size=0.2, random_state=666)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WDgjmE_rg8a0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "scaler = RobustScaler()\n",
        "scaler.fit(np.vstack((np.array(X_s),np.array(X_u))))\n",
        "\n",
        "X_sup= scaler.transform(X_train)\n",
        "X_unsup = scaler.transform(np.array(X_u))\n",
        "X_test = scaler.transform(X_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0TKCWKZnhJPO",
        "colab_type": "text"
      },
      "source": [
        "# Defining model and inference\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XtcZ1Ci8g8dn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ss_vae = SSVAE(config_enum=\"parallel\", use_cuda=True, aux_loss_multiplier=0.1*66944)# pyro exaples suggests 46 for MNIST"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0mV094SQg0wF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "adam_params = {\"lr\": 0.0001}\n",
        "optimizer = Adam(adam_params)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uDixtKiAg028",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "guide = config_enumerate(ss_vae.guide, \"sequential\", expand=True) #config_enumerate(ss_vae.guide, \"parallel\", expand=True)\n",
        "elbo = TraceEnum_ELBO(max_plate_nesting=1) #JitTraceEnum_ELBO\n",
        "loss_basic = SVI(ss_vae.model, guide, optimizer, loss=elbo)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_ADokxJfiHpO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "losses = [loss_basic]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ONP6SIeMiHsa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "elbo = Trace_ELBO()\n",
        "loss_aux = SVI(ss_vae.model_classify, ss_vae.guide_classify, optimizer, loss=elbo)\n",
        "losses.append(loss_aux)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O4h7qaLCiOno",
        "colab_type": "text"
      },
      "source": [
        "# Training\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JXgkx91jiH0N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sup_num = X_unsup.shape[0]\n",
        "unsup_num = X_unsup.shape[0]\n",
        "best_valid_acc, corresponding_test_acc = 0.0, 0.0"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XTlsXCpXiH4l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "batch_size = 512"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6_bgBUqKiH_k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sup = d.SupervisedDataset(X_sup, One_Hot(4)(y_train))\n",
        "test = d.SupervisedDataset(X_test, One_Hot(4)(y_test))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_mPdwjOLiH9b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data_loaders = {}\n",
        "data_loaders[\"sup\"] = torch.utils.data.DataLoader(\n",
        "                            dataset=sup,\n",
        "                            batch_size=batch_size, \n",
        "                            shuffle=False, \n",
        "                            sampler=torch.utils.data.RandomSampler(\n",
        "                                sup, \n",
        "                                replacement=True,\n",
        "                                num_samples=X_unsup.shape[0]\n",
        "                                )\n",
        "                            )\n",
        "data_loaders[\"unsup\"] = torch.utils.data.DataLoader(\n",
        "                            dataset=torch.tensor(X_unsup).float(), \n",
        "                            batch_size=batch_size, \n",
        "                            shuffle=False, \n",
        "                            sampler=torch.utils.data.RandomSampler(\n",
        "                                X_unsup, \n",
        "                                replacement=False\n",
        "                                )\n",
        ")\n",
        "#data_loaders[\"valid\"] = torch.utils.data.DataLoader(SupervisedDataset(X_train[-5000:].view(-1, 1,28,28), y_train[-5000:]), \n",
        "#                                                  batch_size=batch_size)\n",
        "data_loaders[\"test\"] = torch.utils.data.DataLoader(test, batch_size=batch_size)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KSnoCnpriH8F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sup_loss, unsup_loss, clf_loss, test_acc = [],[],[],[]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cgrQ1AWSiH26",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_epochs = 75"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bvz84dVqiHyQ",
        "colab_type": "code",
        "outputId": "8e927354-179b-4393-c3c6-b479fdc9bbc5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "for i in range(0,n_epochs): # 10 epochs for start\n",
        "    start = time.time()\n",
        "    epoch_sup_loss, epoch_unsup_loss = run_inference_for_epoch(data_loaders, losses)\n",
        "\n",
        "    sup_loss.append(epoch_sup_loss[0]/sup_num)\n",
        "    clf_loss.append(epoch_sup_loss[1]/sup_num)\n",
        "    unsup_loss.append(epoch_unsup_loss[0]/unsup_num)\n",
        "\n",
        "    test_accuracy = get_accuracy(data_loaders[\"test\"], ss_vae.encoder_y)\n",
        "    test_acc.append(test_accuracy)\n",
        "\n",
        "    \n",
        "    print(\"Epoch [{}/{}], time {:.2f}s, sup_loss:{:.4f}, sup_clf_loss:{:.4f}, unsup_loss:{:.4f}, test_accuracy:{:.4f}\"\\\n",
        "          .format(i+1, n_epochs, time.time()-start, sup_loss[-1], clf_loss[-1], unsup_loss[-1], test_accuracy))"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch [1/75], time 173.33s, sup_loss:-10.4653, sup_clf_loss:5267.0400, unsup_loss:-36.3771, test_accuracy:0.7718\n",
            "Epoch [2/75], time 173.04s, sup_loss:-91.5568, sup_clf_loss:3522.2026, unsup_loss:-119.0980, test_accuracy:0.8074\n",
            "Epoch [3/75], time 174.13s, sup_loss:-122.2815, sup_clf_loss:2892.4831, unsup_loss:-146.6298, test_accuracy:0.8623\n",
            "Epoch [4/75], time 173.78s, sup_loss:-140.7324, sup_clf_loss:2532.4265, unsup_loss:-165.9537, test_accuracy:0.8735\n",
            "Epoch [5/75], time 173.81s, sup_loss:-152.5745, sup_clf_loss:2607.8311, unsup_loss:-173.5812, test_accuracy:0.8768\n",
            "Epoch [6/75], time 174.13s, sup_loss:-158.9701, sup_clf_loss:2241.2897, unsup_loss:-182.8030, test_accuracy:0.8592\n",
            "Epoch [7/75], time 173.90s, sup_loss:-166.0893, sup_clf_loss:2132.4863, unsup_loss:-185.3186, test_accuracy:0.8928\n",
            "Epoch [8/75], time 174.01s, sup_loss:-166.5232, sup_clf_loss:2021.3520, unsup_loss:-192.5074, test_accuracy:0.8999\n",
            "Epoch [9/75], time 173.92s, sup_loss:-170.8028, sup_clf_loss:1959.1025, unsup_loss:-196.2364, test_accuracy:0.8950\n",
            "Epoch [10/75], time 174.11s, sup_loss:-177.1329, sup_clf_loss:1949.1525, unsup_loss:-199.1720, test_accuracy:0.8722\n",
            "Epoch [11/75], time 173.96s, sup_loss:-173.3857, sup_clf_loss:1902.1326, unsup_loss:-199.3788, test_accuracy:0.9047\n",
            "Epoch [12/75], time 174.25s, sup_loss:-177.6640, sup_clf_loss:1863.9324, unsup_loss:-201.4460, test_accuracy:0.8916\n",
            "Epoch [13/75], time 173.68s, sup_loss:-183.8194, sup_clf_loss:1781.0269, unsup_loss:-208.0482, test_accuracy:0.9050\n",
            "Epoch [14/75], time 174.10s, sup_loss:-183.7179, sup_clf_loss:1785.1572, unsup_loss:-205.9434, test_accuracy:0.8911\n",
            "Epoch [15/75], time 173.65s, sup_loss:-186.6805, sup_clf_loss:1787.9344, unsup_loss:-209.4595, test_accuracy:0.9028\n",
            "Epoch [16/75], time 173.74s, sup_loss:-186.1543, sup_clf_loss:1734.1507, unsup_loss:-210.1938, test_accuracy:0.9061\n",
            "Epoch [17/75], time 173.48s, sup_loss:-190.4092, sup_clf_loss:1730.3937, unsup_loss:-210.4173, test_accuracy:0.9080\n",
            "Epoch [18/75], time 173.54s, sup_loss:-185.6733, sup_clf_loss:1702.2520, unsup_loss:-211.3781, test_accuracy:0.9099\n",
            "Epoch [19/75], time 173.62s, sup_loss:-187.9521, sup_clf_loss:1718.2282, unsup_loss:-210.1881, test_accuracy:0.9016\n",
            "Epoch [20/75], time 174.12s, sup_loss:-193.2948, sup_clf_loss:1635.5821, unsup_loss:-215.4637, test_accuracy:0.9143\n",
            "Epoch [21/75], time 173.82s, sup_loss:-190.9698, sup_clf_loss:1601.8767, unsup_loss:-214.9828, test_accuracy:0.9112\n",
            "Epoch [22/75], time 173.69s, sup_loss:-196.0321, sup_clf_loss:1598.9757, unsup_loss:-215.9341, test_accuracy:0.9055\n",
            "Epoch [23/75], time 173.71s, sup_loss:-193.5394, sup_clf_loss:1595.3031, unsup_loss:-215.8341, test_accuracy:0.8955\n",
            "Epoch [24/75], time 173.90s, sup_loss:-194.3398, sup_clf_loss:1590.0791, unsup_loss:-219.7132, test_accuracy:0.9145\n",
            "Epoch [25/75], time 173.78s, sup_loss:-198.1270, sup_clf_loss:1566.6977, unsup_loss:-221.4580, test_accuracy:0.9073\n",
            "Epoch [26/75], time 173.70s, sup_loss:-199.1607, sup_clf_loss:1514.4537, unsup_loss:-221.4475, test_accuracy:0.9150\n",
            "Epoch [27/75], time 173.68s, sup_loss:-200.3336, sup_clf_loss:1508.2308, unsup_loss:-226.6826, test_accuracy:0.9076\n",
            "Epoch [28/75], time 173.72s, sup_loss:-204.0705, sup_clf_loss:1507.4686, unsup_loss:-225.4376, test_accuracy:0.9177\n",
            "Epoch [29/75], time 173.74s, sup_loss:-201.8797, sup_clf_loss:1489.8996, unsup_loss:-224.9607, test_accuracy:0.9031\n",
            "Epoch [30/75], time 174.08s, sup_loss:-201.9341, sup_clf_loss:1497.0818, unsup_loss:-225.8298, test_accuracy:0.9064\n",
            "Epoch [31/75], time 174.36s, sup_loss:-205.1614, sup_clf_loss:1463.3568, unsup_loss:-229.2571, test_accuracy:0.9161\n",
            "Epoch [32/75], time 174.00s, sup_loss:-203.5166, sup_clf_loss:1452.3577, unsup_loss:-226.5479, test_accuracy:0.9160\n",
            "Epoch [33/75], time 174.14s, sup_loss:-204.5867, sup_clf_loss:1460.4363, unsup_loss:-226.5762, test_accuracy:0.9131\n",
            "Epoch [34/75], time 174.04s, sup_loss:-202.8451, sup_clf_loss:1402.7690, unsup_loss:-228.6769, test_accuracy:0.9182\n",
            "Epoch [35/75], time 173.75s, sup_loss:-204.2692, sup_clf_loss:1416.8861, unsup_loss:-228.1468, test_accuracy:0.9181\n",
            "Epoch [36/75], time 174.09s, sup_loss:-207.2403, sup_clf_loss:1388.5196, unsup_loss:-230.5959, test_accuracy:0.9023\n",
            "Epoch [37/75], time 173.87s, sup_loss:-203.7041, sup_clf_loss:1382.6408, unsup_loss:-228.4548, test_accuracy:0.9221\n",
            "Epoch [38/75], time 173.78s, sup_loss:-209.3387, sup_clf_loss:1371.2386, unsup_loss:-231.7237, test_accuracy:0.9052\n",
            "Epoch [39/75], time 173.96s, sup_loss:-207.4203, sup_clf_loss:1365.4989, unsup_loss:-230.3723, test_accuracy:0.9243\n",
            "Epoch [40/75], time 174.27s, sup_loss:-206.9578, sup_clf_loss:1351.3943, unsup_loss:-228.5123, test_accuracy:0.9103\n",
            "Epoch [41/75], time 173.99s, sup_loss:-209.7403, sup_clf_loss:1323.2164, unsup_loss:-234.1536, test_accuracy:0.8880\n",
            "Epoch [42/75], time 174.29s, sup_loss:-204.5374, sup_clf_loss:1326.0555, unsup_loss:-233.8285, test_accuracy:0.9191\n",
            "Epoch [43/75], time 174.56s, sup_loss:-210.7847, sup_clf_loss:1340.5620, unsup_loss:-230.9896, test_accuracy:0.9247\n",
            "Epoch [44/75], time 174.37s, sup_loss:-207.9887, sup_clf_loss:1303.5359, unsup_loss:-232.5099, test_accuracy:0.9141\n",
            "Epoch [45/75], time 174.41s, sup_loss:-208.8632, sup_clf_loss:1303.5593, unsup_loss:-234.5029, test_accuracy:0.9115\n",
            "Epoch [46/75], time 174.14s, sup_loss:-210.1814, sup_clf_loss:1243.0008, unsup_loss:-232.3654, test_accuracy:0.9206\n",
            "Epoch [47/75], time 174.21s, sup_loss:-211.2443, sup_clf_loss:1319.8308, unsup_loss:-233.9370, test_accuracy:0.9209\n",
            "Epoch [48/75], time 174.15s, sup_loss:-211.0066, sup_clf_loss:1254.3593, unsup_loss:-235.0848, test_accuracy:0.9236\n",
            "Epoch [49/75], time 174.37s, sup_loss:-208.9752, sup_clf_loss:1326.4621, unsup_loss:-233.6512, test_accuracy:0.9200\n",
            "Epoch [50/75], time 174.34s, sup_loss:-211.1300, sup_clf_loss:1250.5332, unsup_loss:-233.1025, test_accuracy:0.9283\n",
            "Epoch [51/75], time 174.27s, sup_loss:-210.7061, sup_clf_loss:1233.1301, unsup_loss:-235.7090, test_accuracy:0.9302\n",
            "Epoch [52/75], time 174.96s, sup_loss:-212.4863, sup_clf_loss:1202.0065, unsup_loss:-235.1961, test_accuracy:0.9258\n",
            "Epoch [53/75], time 175.29s, sup_loss:-210.0218, sup_clf_loss:1305.0296, unsup_loss:-237.5744, test_accuracy:0.9247\n",
            "Epoch [54/75], time 175.14s, sup_loss:-214.0673, sup_clf_loss:1181.8512, unsup_loss:-236.3629, test_accuracy:0.9267\n",
            "Epoch [55/75], time 175.17s, sup_loss:-211.3563, sup_clf_loss:1156.7537, unsup_loss:-236.1241, test_accuracy:0.9265\n",
            "Epoch [56/75], time 175.08s, sup_loss:-212.8385, sup_clf_loss:1164.3397, unsup_loss:-238.1729, test_accuracy:0.9272\n",
            "Epoch [57/75], time 175.08s, sup_loss:-212.9369, sup_clf_loss:1128.1485, unsup_loss:-234.6997, test_accuracy:0.9300\n",
            "Epoch [58/75], time 175.13s, sup_loss:-214.4266, sup_clf_loss:1164.2763, unsup_loss:-238.0688, test_accuracy:0.9150\n",
            "Epoch [59/75], time 175.37s, sup_loss:-211.4237, sup_clf_loss:1146.3717, unsup_loss:-234.5273, test_accuracy:0.9298\n",
            "Epoch [60/75], time 175.44s, sup_loss:-213.7988, sup_clf_loss:1112.5647, unsup_loss:-234.1198, test_accuracy:0.9315\n",
            "Epoch [61/75], time 175.32s, sup_loss:-213.8170, sup_clf_loss:1111.1312, unsup_loss:-236.8592, test_accuracy:0.9287\n",
            "Epoch [62/75], time 175.57s, sup_loss:-216.7236, sup_clf_loss:1159.2092, unsup_loss:-238.4715, test_accuracy:0.9270\n",
            "Epoch [63/75], time 175.39s, sup_loss:-215.5874, sup_clf_loss:1075.1746, unsup_loss:-239.4888, test_accuracy:0.9304\n",
            "Epoch [64/75], time 175.32s, sup_loss:-219.0404, sup_clf_loss:1080.3094, unsup_loss:-240.1950, test_accuracy:0.9252\n",
            "Epoch [65/75], time 175.44s, sup_loss:-217.0422, sup_clf_loss:1089.5007, unsup_loss:-238.8551, test_accuracy:0.9359\n",
            "Epoch [66/75], time 175.43s, sup_loss:-215.4172, sup_clf_loss:1076.8872, unsup_loss:-238.6084, test_accuracy:0.9289\n",
            "Epoch [67/75], time 175.03s, sup_loss:-214.1159, sup_clf_loss:1010.0533, unsup_loss:-240.5988, test_accuracy:0.9306\n",
            "Epoch [68/75], time 174.49s, sup_loss:-218.2493, sup_clf_loss:1043.8841, unsup_loss:-239.0957, test_accuracy:0.9310\n",
            "Epoch [69/75], time 174.42s, sup_loss:-218.2556, sup_clf_loss:1035.5544, unsup_loss:-239.4343, test_accuracy:0.9320\n",
            "Epoch [70/75], time 174.34s, sup_loss:-217.1156, sup_clf_loss:1008.4582, unsup_loss:-239.4784, test_accuracy:0.9357\n",
            "Epoch [71/75], time 174.47s, sup_loss:-218.9809, sup_clf_loss:1004.3167, unsup_loss:-239.4413, test_accuracy:0.9331\n",
            "Epoch [72/75], time 174.17s, sup_loss:-220.1746, sup_clf_loss:992.2570, unsup_loss:-241.4518, test_accuracy:0.9318\n",
            "Epoch [73/75], time 174.02s, sup_loss:-217.8470, sup_clf_loss:1010.8162, unsup_loss:-242.3669, test_accuracy:0.9187\n",
            "Epoch [74/75], time 174.26s, sup_loss:-216.9268, sup_clf_loss:968.3526, unsup_loss:-239.4629, test_accuracy:0.9303\n",
            "Epoch [75/75], time 174.30s, sup_loss:-218.7021, sup_clf_loss:948.0990, unsup_loss:-242.4362, test_accuracy:0.9338\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ClRCnBrJiHww",
        "colab_type": "code",
        "outputId": "05843456-a34e-4cb9-e4a0-9f839e051ae6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "alpha = 0.1*66944\n",
        "fig, axes = plt.subplots(4,1, figsize=(15,20))\n",
        "fig.tight_layout()\n",
        "axes[0].plot(np.array(sup_loss), label=\"supervised loss\")\n",
        "axes[0].plot(np.array(unsup_loss), label=\"unsupervised loss\")\n",
        "axes[0].legend()\n",
        "\n",
        "axes[1].plot(np.array(clf_loss), label=\"classification loss\")\n",
        "axes[1].legend()\n",
        "\n",
        "axes[2].plot(np.array(test_acc), label=\"accuracy\")\n",
        "axes[2].grid(True)\n",
        "axes[2].legend()\n",
        "\n",
        "axes[3].plot(np.array(sup_loss) + np.array(unsup_loss)  + alpha * np.array(clf_loss), label=r\"$\\mathcal{J}^{\\alpha}$\")\n",
        "axes[3].legend()\n",
        "plt.show()"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABDUAAAWXCAYAAABX00+wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXSV1b3/8ffOPAAnYZYkTAqCIDIEBHHAEVGr1daqdagd7Fzba2+rHWzt79Z7tXpbr72t1rYOta1TrbUVK4iKUCcERQZB5iFhHpJAQhKSPL8/TuSCIgRIzkng/VrrrJPzDPv5nrAWa+Wz9t7fEEURkiRJkiRJbU1KsguQJEmSJEk6GIYakiRJkiSpTTLUkCRJkiRJbZKhhiRJkiRJapMMNSRJkiRJUptkqCFJkiRJktqkpIYaIYRzQwjvhRCWhBBuSmYtkiRJkiSpbQlRFCXnwSGkAouAs4ES4E3giiiK3k1KQZIkSZIkqU1JS+KzRwFLoihaBhBCeBS4CPjIUKNz585R7969E1OdJEmSJElKulmzZm2KoqjL3s4lM9QoAFbv9rkEOHFfN/Tu3ZuZM2e2aFGSJEmSJKn1CCGs/KhzrX6j0BDCF0MIM0MIMzdu3JjsciRJkiRJUiuRzFCjFCja7XNh47E9RFF0XxRFxVEUFXfpstfZJpIkSZIk6QiUzFDjTaBfCKFPCCEDuBz4exLrkSRJkiRJbUjS9tSIoqguhPB1YBKQCtwfRdH8ZNUjSZIkSWpddu7cSUlJCdXV1ckuRQmQlZVFYWEh6enpTb4nmRuFEkXRs8CzyaxBkiRJktQ6lZSU0L59e3r37k0IIdnlqAVFUcTmzZspKSmhT58+Tb6v1W8UKkmSJEk6MlVXV9OpUycDjSNACIFOnTod8KwcQw1JkiRJUqtloHHkOJh/a0MNSZIkSZLUJhlqSJIkSZLUyp100kmHPMbUqVO54IILmny8LTDUkCRJkiQpyaIooqGh4SPPv/rqqwmspu0w1JAkSZIkaS8qKys5//zzOeGEExg8eDCPPfYYAL1792bTpk0AzJw5k3HjxgFwyy23cPXVVzNmzBj69evHb3/7211j3XHHHYwcOZIhQ4bw4x//GIAVK1Zw7LHHcs011zB48GD+4z/+g+985zu77nnwwQf5+te/DkC7du0AWLt2LaeeeipDhw5l8ODBTJ8+HYDJkyczZswYhg8fzqWXXsr27dsBeO655xgwYADDhw/nr3/9636/85YtW/j4xz/OkCFDGD16NHPmzAHg5ZdfZujQoQwdOpRhw4axbdu2j6wlkZLa0lWSJEmSpKb4yT/m8+6aimYd87geHfjxxwZ95PnnnnuOHj16MHHiRADKy8v3O+acOXN4/fXXqaysZNiwYZx//vnMmzePxYsXM2PGDKIo4sILL2TatGn07NmTxYsX89BDDzF69Gg2btzImDFjuOOOOwB47LHH+MEPfrDH+H/+858ZP348P/jBD6ivr6eqqopNmzbx05/+lClTppCbm8vtt9/Oz3/+c7773e9y3XXX8eKLL3LMMcdw2WWX7bf+H//4xwwbNoy//e1vvPjii1xzzTXMnj2bO++8k1/96leMHTuW7du3k5WVxX333fehWhLNmRotbNXmKv7fP95l+abKZJciSZIkSToAxx9/PM8//zw33ngj06dPJxaL7feeiy66iOzsbDp37szpp5/OjBkzmDx5MpMnT2bYsGEMHz6chQsXsnjxYgB69erF6NGjAejSpQt9+/bl9ddfZ/PmzSxcuJCxY8fuMf7IkSN54IEHuOWWW5g7dy7t27fn9ddf591332Xs2LEMHTqUhx56iJUrV7Jw4UL69OlDv379CCFw1VVX7bf+f/3rX1x99dUAnHHGGWzevJmKigrGjh3LDTfcwN13301ZWRlpaWl7rSXRnKnRwrbV7OT+V5ZT3DufPp1zk12OJEmSJLVJ+5pR0VL69+/PW2+9xbPPPssPf/hDzjzzTH70ox+Rlpa2a/+L6urqPe75YFvSEAJRFPG9732PL33pS3ucW7FiBbm5e/6dePnll/P4448zYMAALr744g+Nd+qppzJt2jQmTpzItddeyw033EB+fj5nn302jzzyyB7Xzp49+5C+/+5uuukmzj//fJ599lnGjh3LpEmT9lrLNddc02zPbApnarSwwrwcAEq37khyJZIkSZKkA7FmzRpycnK46qqr+M53vsNbb70FxPfUmDVrFgBPPvnkHvc8/fTTVFdXs3nzZqZOncrIkSMZP348999//659LkpLS9mwYcNen3nxxRfz9NNP88gjj3D55Zd/6PzKlSvp1q0b1113HV/4whd46623GD16NK+88gpLliwB4nuBLFq0iAEDBrBixQqWLl0K8KHQY29OOeUU/vSnPwHxriidO3emQ4cOLF26lOOPP54bb7yRkSNHsnDhwr3WkmjO1GhhHbLTaJ+ZRmmZoYYkSZIktSVz587lO9/5DikpKaSnp3PPPfcA8X0nPv/5z3PzzTfv2iT0fUOGDOH0009n06ZN3HzzzfTo0YMePXqwYMECxowZA8Q3/fzjH/9Iamrqh56Zn5/PwIEDeffddxk1atSHzk+dOpU77riD9PR02rVrxx/+8Ae6dOnCgw8+yBVXXEFNTQ0AP/3pT+nfvz/33Xcf559/Pjk5OZxyyils27Ztn9/5lltu4XOf+xxDhgwhJyeHhx56CIC77rqLl156iZSUFAYNGsSECRN49NFHP1RLooUoihL+0INVXFwczZw5M9llHLBz75pGYX4Ov/tMcbJLkSRJkqQ2Y8GCBQwcODDZZTTZLbfcQrt27fj3f//3ZJfSZu3t3zyEMCuKor3+Qe3ykwQoyMt2poYkSZIkSc3M5ScJUJCfzYwVW5JdhiRJkiSpBd1yyy3JLuGI40yNBCjIy2ZbdR0V1TuTXYokSZIkSYcNQ40EKMy3A4okSZIkSc3NUCMBCvKzAUMNSZIkSZKak6FGAhTkxUONkq1VSa5EkiRJkqTDh6FGAnRul0FmWoodUCRJkiRJCTFz5kyuv/76Qx7nlltu4c4772zy8USz+0kChBAoyLetqyRJkiSp+dTV1ZGWtvc/64uLiykuLk5wRYnnTI0EKcjLdk8NSZIkSWpDVqxYweDBg3d9vvPOO3e1bR03bhw33ngjo0aNon///kyfPh2A+fPnM2rUKIYOHcqQIUNYvHjxfsf55je/ydChQxk8eDAzZswAoLKyks997nOMGjWKYcOG8fTTTwPw4IMPcuGFF3LGGWdw5plncvnllzNx4sRdY1977bX85S9/YerUqVxwwQUAvPzyywwdOpShQ4cybNgwtm3bBsAdd9zByJEjGTJkCD/+8Y93jXHrrbfSv39/Tj75ZN577739/p5mz57N6NGjGTJkCBdffDFbt24F4O677+a4445jyJAhXH755fus5WA5UyNBCvOzmbymItllSJIkSVLb9M+bYN3c5h2z+/Ew4baDvr2uro4ZM2bw7LPP8pOf/IQpU6Zw77338s1vfpMrr7yS2tpa6uvrWb9+/T7HqaqqYvbs2UybNo3Pfe5zzJs3j1tvvZUzzjiD+++/n7KyMkaNGsVZZ50FwFtvvcWcOXPo2LEjTz31FI8//jjnn38+tbW1vPDCC9xzzz288cYbu8a/8847+dWvfsXYsWPZvn07WVlZTJ48mcWLFzNjxgyiKOLCCy9k2rRp5Obm8uijjzJ79mzq6uoYPnw4I0aM2Gf911xzDb/85S857bTT+NGPfsRPfvIT7rrrLm677TaWL19OZmYmZWVlH1nLoXCmRoIU5GWzubKWHbX1yS5FkiRJktQMLrnkEgBGjBjBihUrABgzZgz/+Z//ye23387KlSvJzs7e7zhXXHEFAKeeeioVFRWUlZUxefJkbrvtNoYOHcq4ceOorq5m1apVAJx99tl07NgRgAkTJvDSSy9RU1PDP//5T0499dQPPXPs2LHccMMN3H333ZSVlZGWlsbkyZOZPHkyw4YNY/jw4SxcuJDFixczffp0Lr74YnJycujQoQMXXnjhPmsvLy+nrKyM0047DYDPfOYzTJs2DYAhQ4Zw5ZVX8sc//nHXMpm91XIonKmRIIX5OQCUlu3gmK7tklyNJEmSJLUxhzCj4mClpaXR0NCw63N1dfUe5zMzMwFITU2lrq4OgE9/+tOceOKJTJw4kfPOO4/f/OY39O/ff5/jhBA+9DmKIp588kmOPfbYPc698cYb5Obm7vqclZXFuHHjmDRpEo899tiuZR67u+mmmzj//PN59tlnGTt2LJMmTSKKIr73ve/xpS99aY9r77rrrv3+Xppq4sSJTJs2jX/84x/ceuutzJ07d6+1DBgw4KCf4UyNBCnIjydlbhYqSZIkSW1Dt27d2LBhA5s3b6ampoZnnnlmv/csW7aMvn37cv3113PRRRcxZ86c/Y7z2GOPAfCvf/2LWCxGLBZj/Pjx/PKXvySKIgDefvvtj3zmZZddxgMPPMD06dM599xzP3R+6dKlHH/88dx4442MHDmShQsXMn78eO6//362b98OQGlpKRs2bODUU0/lb3/7Gzt27GDbtm384x//2Of3jcVi5Ofn79pT5OGHH+a0006joaGB1atXc/rpp3P77bdTXl7O9u3b91rLoXCmRoIU5MVDjZKtVUmuRJIkSZLUFOnp6fzoRz9i1KhRFBQUNGlGweOPP87DDz9Meno63bt35/vf//5+x8nKymLYsGHs3LmT+++/H4Cbb76Zb33rWwwZMoSGhgb69OnzkaHKOeecw9VXX81FF11ERkbGh87fddddvPTSS6SkpDBo0CAmTJhAZmYmCxYsYMyYMQC0a9eOP/7xjwwfPpzLLruME044ga5duzJy5Mj9fueHHnqIL3/5y1RVVdG3b18eeOAB6uvrueqqqygvLyeKIq6//nry8vK4+eabP1TLoQjvpz5tQXFxcTRz5sxkl3FQ6hsijv3hP/niqX357rkHP7VGkiRJko4UCxYsYODAgckuo0WNGzeOO++884hov9oUe/s3DyHMiqJor78gl58kSGpK4Ki8LJefSJIkSZLUTFx+kkAFedmUbjXUkCRJkiTFTZ06NdkltGnO1EiggrwcSgw1JEmSJKnJ2tKWCTo0B/NvbaiRQAX52azfVk1tXcP+L5YkSZKkI1xWVhabN2822DgCRFHE5s2bycrKOqD7XH6SQIX52UQRrCuvpmennGSXI0mSJEmtWmFhISUlJWzcuDHZpSgBsrKyKCwsPKB7DDUSqPD9tq5lVYYakiRJkrQf6enp9OnTJ9llqBVz+UkCFeQ3hhruqyFJkiRJ0iEz1Eigo2LZhIAdUCRJkiRJagaGGgmUkZZCt/ZZlJYZakiSJEmSdKgMNRKsID/bmRqSJEmSJDUDQ40EK8jLpqSsKtllSJIkSZLU5hlqJFhBfjZry6qpb7DPsiRJkiRJh8JQI8EK87Opa4jYsK062aVIkiRJktSmGWq0tLJV8OKtsHUFEF9+AnZAkSRJkiTpUBlqtLSqLTDtZ7BuLhCfqQFQYqghSZIkSdIhMdRoaXk94+9lqwHo8f5MDdu6SpIkSZJ0SAw1Wlp2PqTnQHkJADkZaXTMzXCmhiRJkiRJh8hQo6WFALEiKF+161BhfrYzNSRJkiRJOkSGGokQK9y1/ATim4WWbK1KYkGSJEmSJLV9hhqJkFe0a/kJxEONNWU7iKIoiUVJkiRJktS2GWokQqwIqjZBbXx2RkF+NtU7G9hcWZvkwiRJkiRJarsMNRIhVhR/rygFoDA/B4BSNwuVJEmSJOmgGWokQl5jqFEW3yy0oLGtqx1QJEmSJEk6eIYaifD+TI3y+GahBfnxUKO0zM1CJUmSJEk6WIYaidD+KAipuzYLjWWn0z4zzeUnkiRJkiQdAkONREhNgw499mzrmp9NaZmhhiRJkiRJB8tQI1FiRbuWnwAU5me7p4YkSZIkSYfAUCNRYoV7hBoFedkuP5EkSZIk6RC0aKgRQrglhFAaQpjd+Dpvt3PfCyEsCSG8F0IY35J1tAp5RVCxBhrqgfjyk201dZTv2JnkwiRJkiRJapvSEvCMX0RRdOfuB0IIxwGXA4OAHsCUEEL/KIrqE1BPcsQKoaEOtq2DWAGF+TkAlG7dQSw7PcnFSZIkSZLU9iRr+clFwKNRFNVEUbQcWAKMSlItiRHrGX9/v61r3vttXV2CIkmSJEnSwUhEqPH1EMKcEML9IYT8xmMFwOrdrilpPHb4yiuKvzd2QCnIj4caJVurklWRJEmSJElt2iGHGiGEKSGEeXt5XQTcAxwNDAXWAv99EON/MYQwM4Qwc+PGjYdabvLECuPvjTM1OuVmkJWe4mahkiRJkiQdpEPeUyOKorOacl0I4bfAM40fS4Gi3U4XNh7b2/j3AfcBFBcXRwdfaZJl5EJ2x12hRggh3gHF5SeSJEmSJB2Ulu5+ctRuHy8G5jX+/Hfg8hBCZgihD9APmNGStbQKeUW7lp8AFOTnGGpIkiRJknSQWrr7yc9CCEOBCFgBfAkgiqL5IYTHgXeBOuBrh3Xnk/fFimDz0l0fC/KymVdansSCJEmSJElqu1o01Iii6Op9nLsVuLUln9/qxIpg2VSIIgiBwvxstlTWUlVbR05GIrrrSpIkSZJ0+EhWS9cjU6wQardDdRkAhY0dUNa4BEWSJEmSpANmqJFIH2zrmvd+W1dDDUmSJEmSDpShRiLFGkONxg4oBfmGGpIkSZIkHSxDjUTaFWqUANC1fRZpKcEOKJIkSZIkHQRDjUTK7Qxp2VC2CoDUlECPvGxKnakhSZIkSdIBM9RIpBDim4U2Lj+B+L4aztSQJEmSJOnAGWokWqxw1/ITiO+rUbK1KokFSZIkSZLUNhlqJFpe0a7uJxCfqbFhWw21dQ1JLEqSJEmSpLbHUCPRYkVQuQF2VgPxmRpRBGvLXYIiSZIkSdKBMNRItPc7oFSUAlDY2NbVzUIlSZIkSTowhhqJltcYajR2QCnMywGgxFBDkiRJkqQDYqiRaLHC+HvjZqHdY1mEACV2QJEkSZIk6YAYaiRahwIIKbvaumakpdCtfZbLTyRJkiRJOkCGGomWmg7tj9qjA0phfjalZbZ1lSRJkiTpQBhqJEOscNdMDYh3QHFPDUmSJEmSDoyhRjLEivYMNfKyWVdeTX1DlMSiJEmSJElqWww1kiGvCMpLoaEBiM/UqGuIWF9RneTCJEmSJElqOww1kiFWCA07Yft6AArz421dS+2AIkmSJElSkxlqJEOsZ/y9cQlKQV42ACVb3SxUkiRJkqSmMtRIhlhh/P0DoYZtXSVJkiRJajpDjWTIK4q/N7Z1zc5IpVNuhstPJEmSJEk6AIYayZDZHrLy9uiAUmhbV0mSJEmSDoihRrLEiqC8ZNfHgvxsl59IkiRJknQADDWSJa9o1/ITiO+rUVq2gyiKkliUJEmSJElth6FGssSK9lh+UpCXTU1dA5u21yaxKEmSJEmS2g5DjWSJFUJNBVSXA1CYnwPgZqGSJEmSJDWRoUayfKADSkG+bV0lSZIkSToQhhrJEmsMNRo3C30/1CjZWpWsiiRJkiRJalMMNZJlV6gRn6nRISud9llpLj+RJEmSJKmJDDWSJbcLpGZC2apdhwrzc1x+IkmSJElSExlqJEtKCsQKdi0/gf9r6ypJkiRJkvbPUCOZPtDWtTA/m5KtO4iiKIlFSZIkSZLUNhhqJFNe0a7uJxCfqbG9po6KHXVJLEqSJEmSpLbBUCOZYkWwfR3U1QDxmRoAJWV2QJEkSZIkaX8MNZLp/Q4oFaXA/7V1dbNQSZIkSZL2z1AjmfLeb+sa3yy0IK9xpoahhiRJkiRJ+2WokUyxwvh7474aHXMzyEpPsQOKJEmSJElNYKiRTB0KgLCrA0oIgcL8HJefSJIkSZLUBIYayZSWCe267dHWtSAv25kakiRJkiQ1gaFGsn2wrWt+NiVb7X4iSZIkSdL+GGokW6zoQzM1tlbtpKq2LolFSZIkSZLU+hlqJFusEMpLoaEBgELbukqSJEmS1CSGGsmW1xPqa6ByI/B/oUaJ+2pIkiRJkrRPhhrJFiuKv5eXAFCQlwNAiTM1JEmSJEnaJ0ONZIsVxt/LVwHQtX0m6anB5SeSJEmSJO2HoUay5TXO1GjsgJKSEjgqZltXSZIkSZL2x1Aj2bJikNlh1/ITiO+rUWpbV0mSJEmS9slQozX4QFvXwvxslm+qpKEhSmJRkiRJkiS1boYarUFe0a7lJwAnHd2ZrVU7eXt1WRKLkiRJkiSpdTPUaA1ihXvM1DhjYFfSUwPPzVubxKIkSZIkSWrdDDVag1gRVJdBzTYAOmSlM/aYzjw3fx1R5BIUSZIkSZL2xlCjNXi/A8pum4VOGNyd1Vt28O7aiiQVJUmSJElS62ao0RrE9mzrCnDWwG6kBHhu3rokFSVJkiRJUutmqNEavB9qlK/adahTu0xO7NPJUEOSJEmSpI9gqNEatOsGKel7LD8BOHdwdxZv2M6SDduTVJgkSZIkSa1Xs4QaIYRLQwjzQwgNIYTiD5z7XghhSQjhvRDC+N2On9t4bEkI4abmqKPNSkmBWMEey08Axg/qDsCk+c7WkCRJkiTpg5prpsY84BJg2u4HQwjHAZcDg4BzgV+HEFJDCKnAr4AJwHHAFY3XHrliRXu0dQXoHstiWM88/mlrV0mSJEmSPqRZQo0oihZEUfTeXk5dBDwaRVFNFEXLgSXAqMbXkiiKlkVRVAs82njtkStW9KHlJwDnDurOvNIKVm+pSkJRkiRJkiS1Xi29p0YBsPv0g5LGYx91/ENCCF8MIcwMIczcuHFjixWadHlFsG0t1O/c4/C5g12CIkmSJEnS3jQ51AghTAkhzNvLq0VnWERRdF8URcVRFBV36dKlJR+VXLEiiBqgYs0eh3t1ymXgUR3sgiJJkiRJ0gekNfXCKIrOOojxS4Gi3T4XNh5jH8ePTLHC+Hv5asjvtcepCYO784spi9hQUU3XDllJKE6SJEmSpNanpZef/B24PISQGULoA/QDZgBvAv1CCH1CCBnENxP9ewvX0rrl9Yy/f6ADCsSXoEQRTHp3fYKLkiRJkiSp9Wqulq4XhxBKgDHAxBDCJIAoiuYDjwPvAs8BX4uiqD6Kojrg68AkYAHweOO1R64OjVuK7GWz0H5d29G3Sy6TXIIiSZIkSdIuTV5+si9RFD0FPPUR524Fbt3L8WeBZ5vj+YeF9CzI7Qrlqz50KoTAuYO685tpy9haWUt+bkYSCpQkSZIkqXVp6eUnOhB5RXtdfgLxJSj1DRFTFrgERZIkSZIkMNRoXWKFe11+AnB8QYyCvGy7oEiSJEmS1MhQozWJFcVDjSj60KkQAuMHdWf64k1sr6lLQnGSJEmSJLUuhhqtSV5PqNsBVZv3enrC8d2prW/gpYUbElyYJEmSJEmtj6FGaxIrjL+XfXizUIDhPfPp3C7TJSiSJEmSJGGo0brEiuLv5XvfLDQ1JTB+UDdeem8D1TvrE1iYJEmSJEmtj6FGa5L3fqix981CId4Fpaq2nmmLNiaoKEmSJEmSWidDjdYkKw8y2n1kW1eA0X07EctO57n5LkGRJEmSJB3ZDDVakxAaO6B8dKiRnprCWQO7MeXd9dTWNSSwOEmSJEmSWhdDjdYmVrjPUAPiS1Aqqut4fdneu6RIkiRJknQkMNRobfKK9rn8BOCUfp3JyUjln3ZBkSRJkiQdwQw1WptYEezYArWVH3lJVnoqpw/oyvPvrqO+IUpgcZIkSZIktR6GGq1NbP8dUAAmDO7Opu21zFq5NQFFSZIkSZLU+hhqtDbvt3XdzxKUccd2JSMthX/OW5uAoiRJkiRJan0MNVqbXTM19h1qtMtM49R+nZk0bx1R5BIUSZIkSdKRx1CjtWnfHVLS9htqAJw7+CjWlFczp6Q8AYVJkiRJktS6GGq0Nimp0KHHfpefAJw1sCtpKYHn5tsFRZIkSZJ05DHUaI1iPfe7UShAXk4GY47uxHMuQZEkSZIkHYEMNVqjWCFsWQZNCCrGD+rO8k2VLFq/PQGFSZIkSZLUehhqtEZ9ToHt66B01n4vPWdQN0LALiiSJEmSpCOOoUZrNPBjkJYFcx7b76Vd22dR3Cuf5+a5r4YkSZIk6chiqNEaZcXg2Akw70mo37nfy8cP6s7CddtYsakyAcVJkiRJktQ6GGq0VkMug6rNsPTF/V567uDuAPzjnTUtXZUkSZIkSa2GoUZrdfSZkN2xSUtQCvNzGHdsF373r+WU79j/zA5JkiRJkg4HhhqtVVoGDL4EFk6E6or9Xv6d8cdSvmMn9768NAHFSZIkSZKUfIYardmQy6CuGhY+s99LB/WI8fGhPXjgleWsr6hOQHGSJEmSJCWXoUZrVjgS8ns3aQkKwLfPOZb6hoi7pixu2bokSZIkSWoFDDVasxDiszWWvQwVa/d7eVHHHK48sRePz1zN0o3bE1CgJEmSJEnJY6jR2h3/KSCCeX9p0uVfP+MYstJSuHPSey1blyRJkiRJSWao0dp1PgYKRjR5CUrndplcd2pf/jlvHW+v2trCxUmSJEmSlDyGGm3BkMtg3VxY/26TLv/CKX3plJvB7c8tJIqiFi5OkiRJkqTkMNRoCwZdAiEV5j7epMvbZaZx/Zn9eH3ZFl5etLGFi5MkSZIkKTkMNdqCdl3gmDNhzhPQ0NCkW64Y1ZOeHXO4/bn3aGhwtoYkSZIk6fBjqNFWDLkMKkpg1atNujwjLYVvn9OfBWsr+Ps7a1q4OEmSJEmSEs9Qo6049jzIaNfkDUMBPjakB8cd1YH/fv49auuaNsNDkiRJkqS2wlCjrcjIgYEfg/lPw87qJt2SkhK4ccIAVm/ZwZ/fWNnCBUqSJEmSlFiGGm3JkE9BTTksntTkW07t15kxfTvxyxeXsL2mrgWLkyRJkiQpsQw12pI+p0G7bjCnaV1QAEII3DRhAJsra/nttGUtWJwkSZIkSYllqNGWpKTC8ZfCoklQtaXJt51QlMd5x3fnd9OXsXFbTQsWKEmSJElS4hhqtDVDPgUNO+Hdvx3Qbf9+zrFU1zXwvy8ubqHCJEmSJElKLEONtqb7EOgy4B8zcDoAACAASURBVICWoAD07dKOy0YW8ecZq1i1uaqFipMkSZIkKXEMNdqaEOKzNVa9BltXHNCt3zyzH6kpgf9+/r2WqU2SJEmSpAQy1GiLjr80/j73iQO6rVuHLD43tg9Pz17DvNLyFihMkiRJkqTEMdRoi/J6Qq+x8M5jEEUHdOuXTjuavJx0fjbJ2RqSJEmSpLbNUKOtGvIp2LwY1rx9QLfFstP52rhjmLZoI68u2dRCxUmSJEmS1PIMNdqq4y6C1IwD3jAU4OoxvegRy+L25xYSHeBMD0mSJEmSWgtDjbYqOx/6j4d5f4H6ugO6NSs9lRvOOZZ3Ssq5+4UlLVSgJEmSJEkty1CjLRtyGVRuhGVTD/jWTwwv4JLhBfxiyiKembOm+WuTJEmSJKmFGWq0Zf3OgawYzHnsgG8NIfBflxxPca98vv34O7yzuqwFCpQkSZIkqeUYarRlaZkw6GJY+AzUbD/g2zPTUrn36hF0bpfJdX+Yybry6hYoUpIkSZKklmGo0dYNuQx2VsHCiQd1e+d2mfz+2mIqa+r4wh/eZEdtfTMXKEmSJElSyzDUaOuKRkOs50EtQXnfgO4duPuKYcxfU8G3n5hNQ4MdUSRJkiRJrZ+hRluXkgJDLoVlL8G29Qc9zJkDu/H9CQN5du467pqyqBkLlCRJkiSpZRhqHA6O/xREDYc0WwPgC6f04dIRhdz94hKenl3aTMVJkiRJktQyDDUOB10HQK+T4bX/hdqqgx4mhMBPLx7MqN4d+c5f5vD2qq3NWKQkSZIkSc2rWUKNEMKlIYT5IYSGEELxbsd7hxB2hBBmN77u3e3ciBDC3BDCkhDC3SGE0By1HLFO/z5sXw8zf39Iw2SmpXLPVcPp1iGTLz48izVlO5qpQEmSJEmSmldzzdSYB1wCTNvLuaVRFA1tfH15t+P3ANcB/Rpf5zZTLUem3mOh7zj41y8Oqr3r7jq1y+T3nxnJjtp6vvDQTKpq65qlREmSJEmSmlOzhBpRFC2Ioui9pl4fQjgK6BBF0etRFEXAH4CPN0ctR7TTfwhVm2HGbw55qP7d2vPLTw9j4boK/u0xO6JIkiRJklqfROyp0SeE8HYI4eUQwimNxwqAkt2uKWk89iEhhC+GEGaGEGZu3LixpWtt24pGQr9z4JW7obr8kIc7/diu/OD845g0fz3//XyTMytJkiRJkhKiyaFGCGFKCGHeXl4X7eO2tUDPKIqGATcAfw4hdDiQAqMoui+KouIoioq7dOlyILcemU7/PlSXwev3NMtwnxvbmytGFfGrl5by1Nsl+79BkiRJkqQESWvqhVEUnXWgg0dRVAPUNP48K4SwFOgPlAKFu11a2HhMh6rHMBhwAbz2Kxj1RcjpeEjDhRD4yYWDWb6pkhv/MpeeHXMY0evQxpQkSZIkqTm06PKTEEKXEEJq4899iW8IuiyKorVARQhhdGPXk2uAp1uyliPK6d+Hmm3xFq/NICMthXuuHMFReVlc8ds3+PXUJeysb2iWsSVJkiRJOljN1dL14hBCCTAGmBhCmNR46lRgTghhNvAX4MtRFG1pPPdV4HfAEmAp8M/mqEVAt0Ew6GJ4/V6o3NQsQ+bnZvDEl8dw5oCu/Oy597jof19hXumh79shSZIkSdLBCvHmI21DcXFxNHPmzGSX0TZsXAS/PhFGfxXG39qsQz83by03Pz2fLZW1XHdKX751Vj+y0lOb9RmSJEmSJAGEEGZFUVS8t3OJ6H6iZOjSH47/FLz5O9i2rlmHPnfwUUz5t9P4xPAC7n15KRP+ZzpvLNvcrM+QJEmSJGl/DDUOZ6d9F+p3wvSfN/vQsZx0fvbJE/jj50+krqGBy+57nR88NZdt1Tub/VmSJEmSJO2NocbhrNPRMPTTMOsBKG+Zdqwn9+vMpG+dyhdO7sMjM1Zx9s+nMeXd9S3yLEmSJEmSdmeocbg77bsQRTDtzhZ7RE5GGj+84Dj++tWxxLLT+cIfZvL1P7/Fpu01LfZMSZIkSZIMNQ53eT1hxGfg7Ydh64oWfdTQojz+8Y2TueHs/kyav46zfv4yf32rhLa0Ga0kSZIkqe0w1DgSnPJtCKnw8h0t/qiMtBSuP7Mfz15/Cn0753LD4+/wpYdnsbWytsWfLUmSJEk6shhqHAk69ICRn4d3HoHNSxPyyH7d2vPEl0/iB+cN5KX3NjDhf6bz6tJNCXm2JEmSJOnIYKhxpDj53yAtE6belrBHpqYErju1L099dSw5Galc+bs3+NlzC9lZ35CwGiRJkiRJhy9DjSNFu64w6jqY+wRsWJjQRw8uiPHM9SdzWXERv566lE/e8yorNlUmtAZJkiRJ0uHHUONIctI3ISMXpv5Xwh+dk5HGbZ8Ywq+vHM7yTZWcf/d0npzlJqKSJEmSpINnqHEkye0Eo78C7/4N1s1NSgnnHX8Uz33rVAYVxPj2E+/wzUdnU1G9Mym1SJIkSZLaNkONI82Yr0FmDF76z6SV0CMvm0euG823z+7PxLlrOe9/pjNr5dak1SNJkiRJapsMNY402flw0jfgvWehdFbSykhNCXzjzH48/qUxAHzqN69x9wuLqW9wOYokSZIkqWkMNY5Eo78M2R2TOlvjfSN65fPsN0/hgiFH8fPnF3HFfa+zekuVe21IkiRJkvYrtKU/HouLi6OZM2cmu4zDwyv/A8//CE78Cpz9/yAtI9kV8dTbJfzwqXlU1taTmhLISU8lOyOV3Mw0stNTycmIf87JSCU3I23Xz9kZaQwryuO0/l1ISQnJ/hqSJEmSpGYUQpgVRVHx3s6lJboYtRKjvwoVa+GNe+LLUC59EGIFSS3p4mGFjOjZkWfmrqGypo6q2np21NZTWVvPjtr4523VdWyoqKGyto4dtfXxa3bWA9C7Uw6fOak3nxxRSPus9KR+F0mSJElSy3OmxpFu3l/h79+AtCz45O+h77hkV3TAausaeG7+Oh54ZTlvryqjXWYalxYX8pkxvendOTfZ5UmSJEmSDsG+ZmoYagg2LoLHr4ZNi+D078PJ34aUtrndyuzVZTz4ynImzl1LXUPEGcd25bNj+zD2mE6E4NIUSZIkSWprDDW0fzXb4ZlvwdwnoN94uPheyOmY7KoO2oaKav74+kr+9MYqNlfW0q9rO64d25tLhhWSnZGa7PIkSZIkSU1kqKGmiSJ483fw3Pegw1HwqT9Aj2HJruqQVO+s55k5a3ngleXMX1NBLDudy0cVcc2Y3hTkZSe7PEmSJEnSfhhq6MCUzITHPwOVG2DCz2DEtdDGl25EUcTMlVt54JXlPDdvHSEEPn9yH/7trP7O3JAkSZKkVsxQQweucjP89Quw9EU44Qo4/+eQkZPsqppFadkOfvnCYh59czU9O+bwnxcfz8n9Oie7LEmSJEnSXuwr1Gibu0Gq5eV2giv/AqfdBO88Cr87CzYvTXZVzaIgL5vbPjGER784mtSUwFW/f4NvP/4OWytrk12aJEmSJOkAOFND+7d4SnzWRn0dXPIbGHB+sitqNtU76/nli4v5zcvLiGWn8+MLB/GxIUcdUqeUnfUNvPzeRp6du5Y+nXP59Ik96dQusxmrliRJkqQjh8tPdOjKVsX32Vg7Gz72PzD8mmRX1KwWrK3gpifn8E5JOWcM6Mp/fHzwAW8kumj9Np6YuZqn3l7Dpu01tM9KY1t1HRlpKVx4Qg8+O7Y3g3rEWugbSJIkSdLhyVBDzaO2Eh6/BpZMgXN+Cid9I9kVNav6hogHX13BnZPeIyXAd8Yfy9VjepOa8tGzNsqrdvL3OWv4y8zVvFNSTlpK4IwBXbm0uIhxx3Zh5eZKHnx1BU/OKmXHznpG9enIZ0/qzdnHdSMt1dVfkiRJkrQ/hhpqPnW18NQXYf5TcMq34Yyb23xnlA9avaWKH/xtHtMWbWRYzzxu/8QQ+ndrv+t8fUPEK0s28cSsEibNX0dtXQMDurfnkyMK+fiwAjrvZalJedVOHp+5modeW0HJ1h0U5GVz9ZheXD6yiLycjAR+O0mSJElqWww11Lwa6mHiDTDrQSj+PJx3J6QcXrMOoiji6dlr+Mk/5rO9po6vnHY0F5zQg6dnl/LXt0pZW15NLDudi4b24NIRRQwu6NCkfTjqGyKef3c9D766nNeXbSErPYVLhhfy2ZN602+34ESSJEmSFGeooeYXRTDlFnjlLhj8Sbj4XkhNT3ZVzW7z9hp+OnEBT71dCkBKgFP6deHS4kLOGtiNrPTUgx773TUVPPTqCp6aXUptXQMnH9OZz5/ch3HHdjmkjUolSZIk6XBiqKGW869fxMONfuPh0gchIyfZFbWIV5ZsYtH6bUwYfBTdY1nNOvaWyloembGKh19bybqKak7t34WfXjSYnp0Oz9+lJEmSJB0IQw21rJkPwDP/Bj3HwKcfhSw7fByMnfUN/On1ldw5eRE76xu4/sx+XHdKXzLSDq+lPZIkSZJ0IPYVavjXkg5d8Wfhk7+HkjfhwQtg+8ZkV9QmpaemcO3YPky54TTOGNCVOya9x/l3T+fNFVuSXZokSZIktUqGGmoegz8BVzwKmxbDA+dC2epkV9RmdY9lcc9VI7j/2mKqauu59N7XuPEvcyirqk12aZIkSZLUqhhqqPn0Owuufio+U+P+c+MBhw7aGQO68fwNp/Kl0/ryl7dKOOO/X+bJWSW0pSVjkiRJktSSDDXUvHqNgWufgfqaeLCxZnayK2rTcjLS+N6EgTzzjZPp1SmHbz/xDlf+7g2Wbtye7NIkSZIkKencKFQtY9MSePjjUF0OIz8PvU+BnqMhIzfZlbVZDQ0Rj7y5itv+uZCanQ18ZdzRfGXc0YfUVlaSJEmSWju7nyg5ykvhb1+Bla9AQx2kpEPBCOhzSjzkKBoF6dnJrrLN2bCtmp8+s4C/v7OGPp1zufLEnoQQaGiIaIgi6qOIKIL6hoj6hoio8VhDFA9GCHBCYR6n9OtM+6z0ZH8dSZIkSdonQw0lV812WP06LJ8OK6bDmrchaoDUzHiw0fuUeNBRMALSMpNdbZsxbdFGbn56His3V+3zuhAgJQRSQyAEiCKorW8gPTUwum8nzhjQlbMGdqOoY06CKpckSZKkpjPUUOtSXQGrXoPl0+Ihx9o5QARp2dDzROh/Loz8AqQ6i2B/6hsiynfsJDUEUlIaw4uUQEoIpARITQmEEPa4p66+gVkrt/Liwg1MWbCepRsrAejXtR1nDuzGWQO7MqxnPqkpYW+PbDWixtknrb1OSZIkSYfGUEOt246tsPLVeMixfDpsmA8FxfDJ30N+72RXd9hbsamSFxZu4IUF65mxfAt1DRH5OemcfmxXzhzYjVP6d6bDB5apNDREVO2sp7Kmjm3VdVTW1LF9t58ra+s4tlt7RvXp+KFQ5VDV1TfwzJy1/HrqElZsrmJIQYwRvfMp7tWREb3y6Zib0azPkyRJkpRchhpqW+b9Ff7xLSCCC34Bx38y2RUdMSqqdzJt0UZeWLCBl97bQFnVTtJSAsd2b09NXQPb3w8wautoyn8dA7q357Nje3PR0IJD3tC0pq6eJ2eVcu/LS1m1pYr+3dpx0tGdeaekjHml5eysjxfUt0suxb0aQ47e+fTtnNvswYokSZKkxDHUUNuzdSU8+QUomQFDr4IJt0Nmu2RXdUSpb4h4a9VWXliwgYXrKsjNSCM3M5V2mem0y0qj3V5+zs1MpX1mOlkZKUxduJH7X1nOwnXbyMtJ54pRPbl6dC965B3Y5rBVtXX8+Y1V/Hb6MtZX1HBCYYyvnX4MZw3sRkrj0pPqnfXMKSln5sotzFqxlVmrtlJWtROAjrkZDO+ZT3HvfIp75TO0KI+0VLtZS5IkSW2FoYbapvo6ePk2mHYndDoaPvF76DE02VXpAERRxBvLt/DgKyuY/O46QgiMH9SNa0/qw8je+fucQVG+Yyd/eHUF97+ynK1VOxndtyNfP70fY4/ptN+ZFw0NEcs2bWfmiq3MXLmVWSu3snxTfO+Qvl1y+e74AYwf1M0ZHJIkSVIbYKihtm35dPjrF6FyI5z9Exj91XhLD7UpJVurePj1lTw6YzXlO3Zy3FEduHZsby48occeS1M2ba/h9/9azsOvrWR7TR1nDOjK104/mhG9Oh7S8zdtr+GVJZu4+4XFLN1YyfCeedw0YSCj+hzauJIkSZJalqGG2r6qLfD01+G9iXDM2fDxe6Bdl2RXpYOwo7aev80u5cFXVvDe+m10zM3g06N6cs6gbvz1rVIembGK2voGzjv+KL467mgG9Yg16/Pr6ht4YlYJv3h+ERu21XDWwK5899wB9O/WvlmfI0mSJKl5GGro8BBF8ObvYNIPICsGl/wGjj4j2VXpIEVRxGvLNvPAKyuYsmA9UQRpKYGLhxXw5XFHc3SXlt1DZUdtPfe/spx7py6lsraOTwwv5N/O7n/Ae37srq6+gYXrttEhK52enXKasVpJkiTpyGWoocPLunnw5Odh40IY+004/YeQZhvPtmz1lipeXrSRccd2oTA/sWHA1spafvXSEv7w2kpCgGvH9uarpx1DLCd9v/dW1tQxe3UZb67YwswVW3lr1VaqautJCfDxoQV886x+9OqUm4BvIUmSJB2+DDV0+Kmtgknfh1kPQI/hcOEvofvgZFelNqxkaxU/n7yIp2aX0j4zja+dfgyfOan3Hvt9bNxWw8wVW3hzxVZmrtzC/DUV1DdEhAADundgZO98RvTKZ15pOX94bSV1DRGfHF7IN848JuFhjSRJknS4MNTQ4evdp+Hv34Dq8ni4MfTTcPwnITs/2ZWpjXp3TQU/m7SQqe9tpEcsiytH92LFpkpm7tZBJTMthaFFeYzs3ZHi3vkM75VPh6w9Z3ZsqKjm11OX8uc3VhERcdnIIr5+ej+6x7Kapc4oiuzeIkmSpCOCoYYOb5WbYM5j8PafYMN8SM2EAefB0Kvg6NMhJXX/Y0gf8OrSTdz+z4W8U1JOXk46xb06MrJ3PiP7dGRwjxgZaSlNGmdN2Q7+96UlPP7malJSAlee2JOvjDuaru0PLNxYX1HN68s2N762sGJzJXnZ6eTnZtApN4OOe7wy6ZibTsfcTDrlZuy6ZvdZJ5IkSVJbYaihI0MUwdp3YPafYO4TsGMrtD8KTrgchl4Jnfslu0K1MVEUsb6ihq7tM0lJObRZEau3VHH3C4v569ulpKcGPjOmN1867Wg65u59P5gN26p5fdmWeIixdDPLGmeJtM9K48Q+HTm2e3sqdtSxpbKWzZU1bKmsZUvlTrZW1VLfsPf/1wd0b8+niov4+LCCj3yuJEmS1NoYaujIU1cDi56Lz95Y8jxEDVA4CoZdCYMujndPkZJg+aZK7n5hMX+bXUpOeiqfHduH607pS219A28sj8/EeG3pZpZujIcY7TLTGNWnI2P6dmJ0304c16MDqfsIWBoaIiqqdzaGHLVsbnzfuK2GKQvWM6eknPTUwNnHdePS4iJO7ddln+NJkiRJyWaooSPbtnX/tzxl03uQlg0DL4CBH4O+p0NWh2RXqCPQkg3b+MWUxUycs5aMtBRq6xqAeIgxsnc+oxtDjEE9OpCW2rSlLk2xcF0FT8ws4am3S9lSWUv3Dll8YkQBl44oondnO7VIkiSp9THUkCC+PKX0rfjylHlPQnUZpKRD77HQ/1zoPx469k12lTrCLFhbwSMzVnFULJsxR3dicDOHGB+ltq6BFxeu5/GZJUx9bwMNEYzq05FPFRdx3vHdyclIa/EaJEmSpKZo8VAjhHAH8DGgFlgKfDaKorLGc98DPg/UA9dHUTSp8fi5wP8AqcDvoii6bX/PMdRQs6mvg9VvxJeoLJoUn8EB0Ll/PNzofy4UnQip6fseRzoMrK+o5sm3SnhiZgnLN1WSm5HKx07owSXDC+nfrR2x7HQ7rUiSJClpEhFqnAO8GEVRXQjhdoAoim4MIRwHPAKMAnoAU4D+jbctAs4GSoA3gSuiKHp3X88x1FCL2bIMFk2GxZNgxb+gvja+78YxZ0G/8dDvbMjpmOwqpRYVRREzV27l8TdXM3HuWqpq64F4C9tuHbLo3iGLbrEsunfIpFuHrPixWPx4l/aZdleRJElSi0jo8pMQwsXAJ6MourJxlgZRFP1X47lJwC2Nl94SRdH4xuN7XPdRDDWUEDXbYNnUxlkck6FyA4QU6HQMpGXGl6ykpkNqBqSkxd9T0/f+c8e+UDACjhoC6dnJ/mZSk1XW1DF98UZKy6pZX1HNuvJq1lVUs6Ei/l69s+FD9+TnpNM9lk1BXhYFedn0aHwV5GdTkJdNl3aH3kVGkiRJR559hRotsWj6c8BjjT8XAK/vdq6k8RjA6g8cP7EFapEOXGb7+CaiAz8GDQ2w9u34EpUNC6ChDup3xmdyNNRBbSXUb/3w8fqdULcDqsvjY4ZU6HYc9BgOBcPjQUeXgZDqvgVqnXIz0zh38FF7PRdFERU76li/7f/CjvXl1azfVs3asmpKtu5gxvItVFTX7XFfemrgqFg2PfKy6JGXTWFj6DH2mM4UdcxJxNeSJEnSYabJf1GFEKYA3fdy6gdRFD3deM0PgDrgT81THoQQvgh8EaBnz57NNazUNCkp8QCiYMTB3b9tXXxz0jVvQeksePdpeOuh+Lm0bDjqhP8LOXoMi8/scO8CtXIhBGI56cRy0unfrf1HXreteidryqopLauitKyaNWU7KN26gzVlO3ht6WbWV1TT0DhZ8MQ+HbnUTUr1/9m78/C4rjrP/++jrUpbaZdKq2XHuy3bsZ04IWR1CEmABJLAj+7QEKa76Sb8gH5mOuwDNB0aMt0D08zQTUNDhyXNQAIkrCF7AgkJieN9kyzZkrXvS2lX1Zk/ztVix3YsuaTS8nk9z33urVvbKV1bSX18zvcrIiIiMk1RW35ijLkL+Ctgp7V2wDun5SciU1nr6nc07nYhR8Or0LTXzeoASCuAG74IFXco3JBFbzQc4WTnAL/e38RDu+o50TFAalI8N1cU8s7tpVxSnnXBBUq7+kfYc7KbttAwBogzBmPcX68477WNMcQZMBjvPMTHxbG1LJOcNF8UPqmIiIiIXIi5KBR6I/AV4GprbduU8xuA/2SyUOiTwCrA4AqF7gQacIVC/9Rae/Bc76NQQxal8Bi0HXYhx+4fQP3LsPat8JavQHpBrEcnMiestbx8oouHdp3kV/ua6B8JsywnhTu2lnD7thKKMl+/Js1YOEJlS4hX67p4ta6LPXXd1LT3z3hMcQZ2LM/h5oogb94QJD/gn/FrxUrf0CgDI2Hy033qYCMiIiIL1lyEGscAH9DhnXrRWvvX3n2fxtXZGAP+xlr7G+/8zcD/wrV0/Y619ouv9z4KNWTRi4ThD1+Hp+6FpBS46R81a0OWnP7hMX5zoJmHdp3kxZpOjIE3rszljm0lvHlDcKLLSkdomN113ew+2cWrtd3sre+e6NiSk5rExWVZbF2WycWlWZRkuVDEWrBYItYFKW75i8Va3DnveGBkjGeOtvHr/U1Ut/VjDGxflsWNGwu5cWOQ4vMIWc6lq3+EqtYQxuC6ygT8JCXEzfj1RsYi1LSHONrcx5HmPo56W0O3mwWWnBjPspwUluemsiwnleW5KZTnpLI8N5W8GAQe1lqFLCIiInLe5rT7yWxSqCFLRlslPHK3Zm3IklfXMcBDr9bzk131NHQPku5PYMfyHI619nGiYwCA+DjD+sIAW8syXZBRlkVpdnLUvjRXtfTxmwPN/Hp/E0ea+wDYXJrJTRuD3LQxyLKc1LM+tyM0TFVriKqWPqpaQ1S29HGsNUR7aOQ1j81N8xHM8BEMJFOYMdkud+I4w09yYjyNPUMcbe6dCC+ONPVR0x5iNOz+e54QZ7goL401wXTWBNMJ+BM40THAifZ+jnf0c7JzYOKxAKlJ8SzLSaXcCzrKc1O5tDyb8tyzf66ZsNayt76Hh3c38Mt9jQT8iXziprW8aX2BAg4RERE5J4UaIgtRJAx/+D/w1BfdrI2b/wk23q5ZG7IkRSKWF2s6eHBXPbtqu1gbTGfrMhdgVBRnkJwUPyfjON7ez28ONPHogWb21bvuRusLA9xcEWRTSSa1Hf1UtoSoau2jqiVER/9keJHmS2BVQRqr8tNYXZDORflpxBlDc88gTT2udW5Tz2RHme6B0de8f1J8HCPhyXa6xZnJE+HFWm+/IjftnLM+xsIRGruHON7RT21HP8fb+znR3s+JjgFOdg4w5lVvvSgvlZ3rCti5Np9ty7JIiJ/ZTJIT7f08vKeBR/Y0cry9n6SEOK5bk8+xthDHWkNcviKH//7W9awvCszo9ReSl2o6+MrjlfQNjfGZt6zjDStzYz0kERGRBUGhhshC1lYJD38QGl658Fkb4THoOgFZyyA+MarDFFlqTnYO8OiBZn5zoIlX67onzqf7ElhZkMbq/HQXYhSks7ogjWDAP60ZCYMj4cmgo3eQ5p5hugZGKM1OYW0wndUF6WQkR/fv8Wg4Ql3nAL+rbOPJI628WNPBaNiSmZLINavz2LmugKtW573u+7aHhvnl3kYe3tPInpPdGAOXLc/hHRcXc2NFkIA/kbFwhP/8Yx1febySnsFR3n1JKf/1TWvIS198xVkPNPTwj789yrOVbeSn+/AnxlPXOcDtW0v49FvWkZ2aFOshioiIzGsKNUQWupnM2rAWek5C/Step5Vd0LjHdVpJzoYN74BN74LSHZr9IXKBmnoGqWnrZ0Ve6rTDi/msb2iU31W188ThFp452kZn/wgJcYZLyrPZuS6f69cVTCxTGRgZ4/FDLfxsdwO/q2onHLGsKwzw9i1F3LKliMKMM9ch6RkY5WtPVfHdF07gT4znQ9eu5P1XlE/UTlnIqttCfOWxSn61v4nMlETuvuYi3nt5OQD/+6kq/u3ZGgLJifz3t67j7VuKF82fGxERkWhTqCGyWLQdhYfvPvOsjcEu1yK24VV3f8Mu6PeaEcX7oHATQDJxFgAAIABJREFUFG+HvDVw4ndw5Ncu4Mgsg4p3QsW7IH9t7D6biMxr4Yhlz8kunjjcypOHW6hsCQFumcrK/DR+V9XOwEiYogw/t15czNu3FLMmmH7er1/TFuIffn2YJw63UpqdzCdvWsdNG4Mz+qI/MhahqrWP2o4B+ofHGBgJ0z8yxsDwafuR8Cn3D46EKc1K4eo1eVy9Oo/1hQHi4qb//g3dg/zzE5U8tKsef2I8f/HG5fzFVSsI+E+d4XKkuZdP/nQ/u+u6uXJVLve+feM5a7SIiIgsVQo1RBaTSBhe+N/w9D+4WRsX7YSmPdBxbPIxuatdgFG8FUq2Q/4GSDhtevNwHxz+Jez/MdQ8AzYCwQoXblTcAYGiOf1YIrKw1HUM8OSRFp483Mqx1hDXrs3j7VuKuaQ8e0ZBwLjfV7Xz9788xNGWPi4tz+azb1vPxuKMsz5+cCTM4eZeDjb2crChhwONPVQ2h06pPTIuzkBqUgIpvviJfUpSAqlJ8aT4EvAnxHO0pZcDDb2AK9561apcrl6Tx5Wr8l53mUh7aJivP32MB16sAwN/dtkyPnjNReSmnX1JTSRieeClWu579Cij4Qh/c/1q/uLK5STOsIZJa+8Qz1a2caipl4zkRHLTfN6W5PbpPlKT4jUrREREFhSFGiKLUdtR+MXfQGeNCy+Kt3nbVvCf/QvAGYVa4cBPXcDRsAswUP5GN4Nj/a2QnDkrH0FE5EzGwhF+9MpJ/udjlXQNjHDH1hLuefMafInxHGrs5WBjDwcbeznQ0EN1W8hrzQuZKYlsLMpgQ1GADcUZrMxLI92fQEpSPKm+BHwJcef1Zb6tb5jfVbXxbGUbz1W20TUwijGwqTiDq1fncfWaPDaXZE4UT+0dGuVbz9Xw7d8fZ3gswju3lfCRnasomkbr3+aeIT7/84M8erCZtcF0vnRbBReXZb3u80bDEXbVdvFsZRvPHG3jcJMLZPyJcQyNvjbYAfAlxJ0adKT5yElLojDDT2l2CmXZKZRkpVxQm+FYiEQstZ2u08/K/DRKsqLXBUlERGJLoYaInL+Oatj/IOz7MXRWQ3wSLLsC0oOQkgPJWZCS7epynL5P9Md69CKyiPQOjfL1p47xneePA5zSirYg4DslwNhQFKA4M/pfYsMRy4GGHp6tdCHH7rouIhYC/gSuXJXHspwU/vOPdXQPjPKWTYX81zet5qK8tBm/32MHm/nsIwdp6RvifZeX87dvXkOaL+GUxzR0D/Ls0TaerWzl+WMdhIbHSIgzbFuWxTVr8rl6dR7rCtMZDVs6+0doDw3THhqmI3TqcduUcx39I4Qjkz9fY6AoI5nS7GTKvKBjPPAoy04hOzUppoGBtZbGniH2nexmX0MP++q72VffQ9/Q2MRjctOS2FKaxcVlmVxcmsmm0szX/CxFRGRhUKghItNnLTS+CvsehNrnXc2OgU4Y7T/7cxJTvJAjC5LSIC7BhSLxSa7bysQ+cfL8+GMS/JCaA2lBVyckLQhp+TPr0jIy4Iqk9pyE7in7viYovxIuvxt857/WX0Ri60R7P9/7Qy05aUkuxCjKiFmXlJ6BUX5/rJ1nK1t5trKNlt5hrlmTx9/esOacy2Smo29olP/5WCXf/cMJggE/n3vbBtJ8CTxz1L1nVaurZ1KcmTxR/+MNF+WQ7p95N5xIxNIWGqauc4C6jgHqOl2L37rOAWo7B2jrGz7l8Wm+BEqykinKTCaY4ScY8E/sCzP8FGT4SfclRC34aO0bYn99D3vre9jvBRjjLZMT4w1rgwEqSjLYXJJBeU4qla0h9tR1s/tkFzVt7r9bxsCagnS2lGa6oKMsi5V5aee9XMpay/BYhMGRMENjYXJSfVGdzWKtpaa9nxdrOnixppM/Hu8g4E/kTy4t4/atJWSkqGuZiCxdCjVEJHpGh1zAMdjpQo7X7MfDjwEIj0J4xG2RscnjifNTztnwmd8v5bSg4/TAYyK0qIOeenc80HHqa5h4CBS7ZTTN+yAlF67+GGy7CxIWX/tIEZkb1lq6B0bJmqWWrLvruvjkT/dzpLkPgKT4OHasyObq1XlcsyaPi/LS5my2xOBImJNdk4HHeOjR1DNES+/QRMAwVUpS/GsCj6yUJEYjEUbHLKPhCKPhCCPefnTMMjJ+e2zyvpq2fpp6hgBXF2VVfjqbSjK8LZO1hen4Es7eLad7YIQ9J7vZc7Kb3XVu3zM4CrhwZnNpBqVZKQyOhhkYCTM4EmbAKyR7+rkpk1lIjDdclJfGusIAa4PprC0MsC6YTl6677yui7WW6rbxEMMFGe0hFx7lp/vYsSKH+q4Bdtd140+M422binjPZcvYXBq9JaEnOweo7xpkWU4KwYD/gurhxJK1lrrOAbJTky4o3BOR+UuhhojMf+FR162lrxlCLa/dh1qgz9tHRk99bmIKZJRCRglklrrjzDJ3O6MU0gsh3ptyXP8KPPF51wEmswyu/YwrjBq38NtHisjiMxqO8Mt9jWQmJ7FjRTYpSfNz+cTwWJjW3mGaeoZo6hmkpXdoIvBo6hmipWeIlr7hU5a4xBlISogjMT6OpHi3T0wwE8fj95VkJbOpJJNNJW6Z0YX+DCIRy/GO/omZHLvrumntGyYlKZ7kxHhSklwB2eSk+Ilz48cpSQkkJ8bjS4yjvmuQI029HGnumwhdALJTk1zIEQywtjCddcEAqwrS8CXEUd0W4g81nbxY08FLU0KMgoCPy1fksGNFDpetyKE8J2UiGDnQ0MMDL9XxyJ4GBkbCVBRncOeOMm7ZUjTtn0VoeIwXqzv4XVUbz1W1c7x9cvZlcmI85bmprMhNZXluKivyvH1u2rycJTIyFuHlE508fqiFJw63UN81SJyB9UUBLinPZsfybLaXZ5+zUK+ILBwKNURk8YhE3GyQULMLQjJKXU2P6fxrpbVQ/SQ88Xdu5kb+Brj+c7Dqhum9joiInLdwxNI/MjYRWsQv0FkBZ9I9MMKR5r6JkONwcx9Hm3snirXGGTcrpNer+REM+LlsRTaXeSHGsikhxtn0DY3y8O4GfvBiHUdb+kj3JXDb1mLuvGwZqwvOvKRyvCbMeIjxam0XYxFLcmI8l63I5spVeazMT6Ouc4Dj7f3UtIU43t7Pya7BUwKonNQklk+EHWlkJCcSZyAuzhBnDPFxEGfGj427b8rtpIQ4SrNSKM5KvqDr3jMwyjOVrTx+qIVnj7bRNzyGLyGOK1flcvXqPNpDI/zxeCe7T3ZN/OxX5KWyY3k2l5Rnc+nybEqyUmb8/iISOwo1RETOJBKBgz+Fp+6FruNQdjlc/3kouyzWIxMRkQUuHHFLIo409XK4uY+2viG2lGZy2YocyrJfP8Q4G2stu2q7+MGLtfx6fzMj4QiXLs/mzh1l3LgxSEdoZCLEeP5YO90DbnbjxuIAV67K48pVuWxblnXOJTsjY5GJoON4e4iatn5q2vs53t7/mvoq05GUEEd5TspEOLI8N5WL8lJZnpt21pbJJ9r7eeKwm43x8okuwhFLbpqP69fls3NdAW9cmUty0qmfZWQswv6GHl4+0ckfj3fy8onOiSKyRRl+Ll2ezSXLs9lUnEligrsOBm/vXZbxqzN5mdxBMMOvgrMiMaBQQ0TkXMKj8Op34dn/4Za3rL4Jdn4WCtbHemQiIiJn1REa5qFd9TzwUh11nQMkJ8YzOOpqVOWn+7hyVR5Xrc7lipW5UVuG0Tc0ysBImHDEEo5YrIWwtUSsJRKxRKwLdCLj56yryVLX6YKRmjYXjtR29J/S0SgzJXFiucuKvFT6hsZ44nALx7zCuGuD6excl8/16wrYXJI5rfof4YjlaHPfRMjxxxOdMw5nEuMNl5Rnc93afK5bm8+KC+h2tFhYa2nrG3Z1dzoHqOsY5GTXAE09g2wry+JPdpRRmHH+La5FzkShhojI+Rjphxf/FZ7/Zxjug83vhiv/m6vZMRJy23DIPW6kH0b63H7Yu2+k3+3jEl0h03SvoGlacPJYXVdERCTKIhHL74+185sDzazITeWq1XmsLpi7QrIzMRaOUN81yPH2fqq9ZS9uRkiIlt5hEuIMO1Zkc/26Aq5fV0BpdvSWjVhrOdExwNHmPqy12Inz3t47M3l78nmHmnp5+kgrlS0ubCnPSeFaL+C4dHn2OWfALGSDI2FqO/up6xjgZNfgRHekk50DnOwamFjuM64g4CMn1cfh5l7ijOFN6wp47+XLuPyinHn951LmL4UaIiLTMdAJv/8qvPRvED7Pf8lJTHFtbJNS3cyPMxU0BUhM9Tq4TN3yXaFSG3FLYmzYO/b2E7cjk7f9mVDxTshbHd3PLiIiEmOhYbdUZD4v8zjZOcDTR1t56kgrf6juYHgsQmpSPG9clct1a/O5dk0++QH/GZ87MhahuWeIxp5BmnoGaeweorF7kMbuwYmiszdtLOSWLUUsz02dy49FaHiM6tYQVa0hqlr7ONbijk92DTD1a2OaL4HS7BRKs5Ipy06hLCeF0qwUSrNTKMlKxp/owp26jgEeeKmWH71yku6BUVbmp/Fnly3jtq3F6lQj06JQQ0RkJnoa4OivIT7JhRVJaeDzgoukdLf3pblA4/TuKZEIDHV73VuaIdTqHbe62+OdXEItMNx75vc3ca4drYlzrz9+Oy4OhnpduFH2Btj6Xlh/KySp+JmIiMhcGxwJ80J1O08daeXpI600esHExuIAb1yZx8hYxIUXPS68aA8Nc/pXsKyURAozkinKTKZ3aJSXT3RiLWwqyeCWzUW8dVMRwYwzhyQz0Ts0SlVLiGOtfVR5wcWx1hAN3YMTj0mKj2NFXior89NYlZ/OirxUF2Bkp5CZkjitGRdDo2F+sbeR779Yy776HlKT4nnH1mLee3n5WQvdytn1D4/RHhomzhhKspKXxOwXhRoiIvPZ6JCbgREXPyXEiDv3c/paYO8P4dXvQWc1+DJg0ztdwFG4eW7GLSIiIqew1nK0pY8nD7uA49W6LnwJ8RRl+inKTKYww+2LvACjMNNPUUbya4qdNvcM8ct9jTyyp5H9DT0YA5eWZ3PrlmJu2hgk6yyFVc+kZ3CUgw097G/oYV9DD/vre6jrHJi435cQ5wUXaawqSJ84LstOISH+df5/ZAb2nOzm+3+o5Rf7GhkZi7BjeTbvvbycGzYUkBiF9xseC9PcM0RD9yBN47NgvECpqWeQ9tAIpVnJrC8KsL4wwPqiDNYG00mN8cygkbEI7aFh2vq8zTs+07mBkfDE89J9CawJprO20LWSXleYzuqC9EU3E0ahhojIYmUt1D7vwo1Dj8DYEBRuceFGxTvBH4j1CEVERJaskbEIifHmgv4lvaYtxC/2NvHI3gZq2vpJiDNctTqPW7cUcf26glO+jPcNjXKwsZf99S7AONDQw/H2/on7S7KSqSjOYGNxBmsK0llVkEZJVkpMWix39o/w41dO8oMXa6nvGiQ/3cctm4vOGi6c7UfYMzjqwgtvKU976LVLh3NSkyZCpZy0JGo7BjjY2EvP4OjEay/PSWVdUYANE2FHgPz06M2OOV1zzxAvn+jklROdvHyiiyPNvUTO8NU8MyWR3DQfeWk+8tInt9w0H8NjYY4293GkqY/Dzb0TXX7AXevxkGNtMMDawnTKc1IXbDtthRoiIkvBYBfse9B1cmk54JbFbHiHCzhKd5z9/wZERERk3rPWcrCxl1/sbeTnextp6hnCnxjHznUFJMYZ9nkBxvjXu6IMPxUlGWwqyWRjcQYVxRlnbZ0bS+GI5ZmjrXz/xVqeq2w74xf7c0lJinezXzKTKcqYnBFTnJlMoXc8XuNjKmstjT1DHGrs5VBjLwcbezjU1Et91+QSnNw0HxuKAqwJplOcmey2LLcFpjETIhKxVLeFePlEFy+fcG2Gx98nJSmerWVZXFyWSVFm8inhRU5a0nkXnx3/PEeaejnS3Mdhb1/TFpr4mfoT4/jEjWu564rl5z32+UKhhojIUmItNL7qZm/sf8h1ZMldA2tuhPwNrlVt7mpIiE57PxEREZlbkYjlldoufr63gd/sbyYxPo6KEhdcjO+j1cZ3Pjjbd1Zr3b/ZRLOmRM/gKIebejnohR2Hmnqpbg0xEj61w0u6P4HizGRKslzYUTQeeHjH9V2DEzMxXqntonvAzQrJTUvikvJstpdnc0l5FusKA1FZdnM2Q6NhjrWGONLcx5GmXq5bl88bLsqdtfebLQo1RESWquEQHHoYdv8AGnZBeMSdj0uAnJWQv96FHPkboGADZJZpRoeIiIjIFJGIpb1/mIauQRq6B8+47xseO+NzV+Smsr08ywsxsinPSVkShT2jTaGGiIi4VrMd1dB6EFoOQeshaDkI3bWTj0lKh/x13myONZAwZZrq+fz3InMZrHqTghERERFZUnoGRydCjqaeQfLSfGwvzyYvffHMmIklhRoiInJ2w33QetgFHK2HvMDjoKvRMRNFW2HnZ+Gia6M7ThERERFZks4VasS2b42IiMSeLx1KL3XbOGthoBNs+LQHnzYDY+qMDGuh6jF45kvw/bfD8qtg5+ehZNtsjVxEREREljjN1BARkegaG4ZXvgPP/RMMtMPat8J1/x3y18Z6ZCIiIiKyAJ1rpsbslVkVEZGlKcEHl30QProHrvkU1DwL/3o5PHw3dNfFenQiIiIisohopoaIiMyu/g74/Vfgj98CLGz/L3Dl30Ja3vm/RiQCoRYXivQ2uDa1wyEY6XfHI1OOJ873w0if28clQmqee8/U07a0fEjNhVRvr1a3IiIiIvOKCoWKiEjs9dTDs/e59rIJyXD5h+AN/z/4M1w9jvHQorvOdWTproMub99zcrId7enikyApzW2+NEhK9TbvXFIqREYh1Ab9bdDf6o7HBs/8ev4MSCuAFdfAxjug5BKI08RGERERkVhRqCEiIvNHexU8dS8cehiSsyAl14UWY0OnPi4lFzLLJresZa5lbKAIfAEXYCSmntp2djqGQ17I4W2hVuhvd6FHdx1UPw3hYcgohY23uYAjWHFh7WqHQ1D7PFQ/BTXPuPcD7zXNqccT7zPlOD4RCjZC8VYo3g5FF4M/MPPxiIiIiCwACjVERGT+adwNz/8zRMKTgcXUECMpNbbjG+qFo7+G/Q9BzdMQGYPc1bDxdhdw5K58/deIRKB5rwsxqp+GuhfdrJGEZFj2BsgqB6ybqQJTjr3bpxwDowPQtBc6q73HGzemku1e0LHNhR7xiVH8QYiIiIjElkINERGRC9HfAYcfgQM/hRO/BywEN0HFHbDhNsgsnXxsT4MLQcZnYwx0uPPBCrjoOreVXgaJ/pmPZ6DThUINu9xW/4rrNAMQ74PCzS7gKN7mAqKRPjdLZLjPbSMhGO71bk8979Ugyb4Iyq+AZW+Eoi3RC0kiYWg97MaclAqrbpgfM03CY9BRBS0HXSikTj0iIiLzikINERGRaOlthIM/gwM/cV/OwYUUwQoXeLQddufSCiZDjBXXuIKks8Vat2RmPORo2AWNe85eNwTcbBFfulvG40t3S3qS0lzY0nII2o+6xyWmQtkOWHYFlF/plryc75KfvmYXuNS/7I1ptwtUxsUnwUU7YcPbYfWNkJw585/B+RoOufCieR8073db66HJ5U8mDrbdBdd+2hWOFRERkZhTqCEiIjIbOmtcuHHgp9BR7ZaUjAcZBRsurP7GhQqPuS/rodbTwot0SEqH+IRzPz/U6up/nHj+1LAmIRlKL3UBR/kVbjZIgg9GB93SmPqXXZDRsMvVSgGIS3ChT/F2V3i1ZLurJ3LoYTj0iOtoE5fofm7rb4W1N7t6KxdivPhs8/5TA4yOaiaW9CRnuRk3wQq3z1sNe/+v69STlApX3QM7/kodcURERGJMoYaIiMhssza2IcZs62+H2hdcwFH7PLQccOcT/K42SMcxV3cEIKPMBRcl212QUbgJEpPP/LqRiAtAxgOOnpMu4FhxjRdwvAVSss/y3LDrqtN1HDqPT9mfcNtw7+Rjs8onw4tghdsCxWe+Zm1H4bHPQNVjkLUcbrjXjSMW1zcSdjNLklJd3ZnXC6NEREQWIYUaIiIiEl0DnS7kqH3eBRoFGydDjPSCmb2mtdDwqhdwPOyW1MQlwPKrYM3Nrq3v1PCiu84VXh0Xl+iKzmYth+zlrjZIsAKCG12r3umqegJ++ym3FKf8SrjxS+71Zlt/h6vJUvUYVD85WZclLhGyV0DuKrflrHKFYnNXXvjMFhERkXlMoYaIiIgsLNZC0x446AUcXSfceV/AzbrIXj4ZXozvA8UQFx/dcYTHYNd/wNNfhMFu2PpeuO4z0a2REom4z1r1OBx73C3fwUJKDqy83i3LiYy5dsjtVa6oaWfN5MwYcC2QxwOOnFWQt8YVjE0PRm+c4wa73eyaloPu55DrhSu+9Oi/l4iICAo1REREZCGz1s3O8GW4pSixWAYy2AXP/g/44zddXZGr/hYu++DM620MdLrZGMeecFt/G2Bca95VN8DKN7mirHFxZ35+eAy6a6G9cjLoGA89xjvhAKQXQuEW91pFF7tuNtMJZMKjLrxoeAXqd7maKR1VZ35soNgLONa4+iS5q91xWn7slmaNjXjdfXqndPzpm3Kuz7Vv9qW7GUGFW7TER0RkHlKoISIiIhIN7VWu3kblo67GxXWfccHB2LDroDJ1Gx0/HnadaMaGXUHV9koXDtgIJGfDyp0uxFi5MzodVwa7oPWIm/3RuNt1wmmvZKJAaqB4StCxxR2n5bnwqLfhtI41U7ropOZ5xV63uYKvwU2u1kr7UVeHpL3KHbdXndrlxp8xGXDkXOTaDGeUuHGkF848RBgPdjpr3BKojmrorHbLkga7XWARHn791zHxYMPu2JcB5W90NV1WXO3GvZhr5SwV4VEYHYCRAbcfHXB/F028q/kTrbbVIjJrFGqIiIiIRFP1U/Dopya7wpyTcQVVE/1uHyhyy0pWvsnNzIj2kpkzGe6Dpn2nBh1TZ1wEStxyllCzux2f5JavlFziOtyUbHchzvl8wR8PR9oroa1yMuhoOwr9rac+1sRBehFkFE8GHRml7jij2I1rpM8LLGomg4uOahdoTF2C4wu4miPZy12NkfFuP76At6Wfes7vnUvwu3DmxHNQ8wzUPOteG1zosvzqyZAjUHQBF2EJstaFZHV/cN2SirZGPyQaGYCjv3bL1EKtpwUXXpAxtfbO6ZK8WTorr3MtprOXR3d8IhIVCjVEREREoi085r6sYd0X4wSfW5qS4HPdXhJ87nx80vz81/6hXtfudjzkMHGTXWsKKiAhKfrvOdwHPQ2ua03PSRd+9NRPbr0NriDs2SSmuuAiZwXkrHTFYHMucvvU3Oj9nDuPw/FnXcBx/NnJYq25q13Isfwq1yZ5OOQ+08hp++HQlOO+yZkrxdtc6+eyN7hxz8c/F9HQehj2Pwj7H5oMiMDVw9nwDthwmyu6O9PPHx5z12Xfj+HwL2C034VjuasgMQWSUtz+9OPEZNdJaPz2SMgFWdVPuhk+4Gr0rNzpAo7lV6pWjMg8oVBDREREROa/SMTVF+kdDzoa3JfQ8eAiPTj3QUAkAq0HJ2dx1D7vZgCcSVyiCzt86W4GgC8Nkrzb4RE4+dJkQJKaD8sudwHHsjdAwYaZzdoZG3Y/q+46FwqNDrr3Co+4ZRdjw5PHU8+PHyf43ayc4q1uP9Mv8d11cOAnLshoOeBCshXXQsU7XThQ8ywc/ClUP+2W++SsdOHGxtsgf93rv761LoAbD0v6W91yoQ23QsW7YNkVZ69Bcz6v3VHtwo1jT8KJ37lrHJcIpTsmZ3EEN838PUTkgijUEBERERGJhrERaNrrlr5MhBYBd/x6hWOtdUtxap93s3xqX3AzVsB9QS/bAWWXuy/oRRe72TLDIfeY7pPQU+f23XWT58aXDJ2VceOK97naEfFJU/ZJrmDq+BgwrnNO0VYXchRtdS2Rz/a5+tvh4M9cmFH3B3eu5FIXZGx4+5mL0vZ3wOGfu4DjxO9dbZm8dbDxdhdw5Fx06uM7j7sQY9+P3JKp+CRXTHfT/+f2if7X+fwzMDYMdS+6ZWbVT0Lzfnc+JRfKLnM/o9w13n61mw0iIrNKoYaIiIiIyHzUXQe1f4C6F1zI0V7pzif43RKJwc5THx+X6GqOZJZ6RVfL3D6z1NUk8aWfGlqcz+yPUJu3DOlVaHjV7fvbJt+vYMNkyFG4eXJ5SfVTbtZF3loXZGy8fXo1KfpaXMBx4Kfu84ObDbHxNhcW7X/QzW4BF/Rsehesv9XVTJlLfS1Q87SbxdG019V1majnYtzPPm+tCzny1k52APJnzO04RRYxhRoiIiIiIgtBqM3Neqj7g1tKkll6anCRFpz9JRDWuiUt4yFHwy73ZX64d/IxGaVQcQdsvMOFHhe6LKinwRX7PPBT10IY3AyOTe9y75NZdmGvH03hUVe4tu2IK4A7vrVXntpxJ73IhRsZJa7obHrQ23tbWv7cFAqeylpXULWn3nVnCg9PLkcaGz5tmZK3jXl7f8CFWoWb5z5YkiVPoYaIiIiIiMxcJOJmKDTtdTNCSnfMXrjSVesCnbw1C6uYaiTsCqO2HfUCD6/7T28ThFomWwePM3GQVnDmsCMl2wUHE1v2+S+1GRtxS4o6j0PXceg6cerx2WrCnMvU1sfgCqqOt4UuutgFHdOZmTIy4P48tVe5lsztVW55UV+zm2l0StFl/5Tiy8leJ6kp98cleH9OzJR93LnPYV3Ac6Y9vPZcUpprfx3c6N4z1kb64bhX++Wia5dEyKRQQ0REREREJFYiYbekp6/JhRx9U7fmyXOnLzeaKiHZfXmdCDwyJ0OPwS4vvDjhCu3ayKnPyyp3W/ZyF0hklrrlTePLlBKSJo/PdC4uHgY6vbbQXmvopj2TXWPAFfMt2uK+/Bdd7DrcDPe+NrjoqJ5Sx8WTUeqKx2YUu+42Y0NuGx2ccjwEY4MYk0snAAAgAElEQVTeftgdn6tb0mww8ZC/fjLMKbrYzVR6vXo60dB1Aiofg6rfukBjfFaQiXfFhle/GVbfBLkrZ38sMaBQQ0REREREZL4bHXLhx2CXt3VOOfa2ga7XnvMHvOBi+anhRVb57HYN6u/wgo7dk4HH6YHFuKR094U7Z5Vrv5uz0u2zL5p5sdVI2NU3OdOsCxs5w7nx2Rhm8mfymhkd5tT7Me46TA1zGl6dDKDG686MhxxFF7uOPvGJM/tM48KjrqZM5aMuzGg/6s5nXwSrb4TVN7hgqvJROPqo69IE7ue6+kZYcxOUXgbxCRc2jnlCoYaIiIiIiIjMvv52FwC07HdLUsZDjLSChbWc6FysdeFN4+5Tt6Eed3+8z9WBScv3tgJIzXP7tILJ86l5p4Yf/e1Q9bibjXHsKRjucaFJ+RWw6s1uNsbpHYLGddVC5W+h8jduJkdkFPyZsOpNLuRYeb2b3bNAKdQQERERERERmS3Wurol4wFHT70ryhpqcQWAh3vO/LyUHEjNdzMqmg8A1hUEXvUmF2KsuMZ1NZqO4T7Xnejooy4gGehwtUfKLoc3fNi97gJzrlBjccxFEREREREREYkVYyB7hds23v7a+0cHXcjR3+YFHV7YMX480g/XfgpW3eBaG19IIV5fumt/vP5Wt0Sn/hU3g+Poo642yiKjmRoiIiIiIiIiS4G1C3IZ0Llmasxyk2sRERERERERmRcWYKDxehRqiIiIiIiIiMiCpFBDRERERERERBYkhRoiIiIiIiIisiBFJdQwxvyjMeaIMWafMeZnxphM73y5MWbQGLPH274x5TnbjDH7jTHHjDFfM2YRLu4RERERERERkVkTrZkajwMbrbWbgErgk1Puq7bWbvG2v55y/l+BvwRWeduNURqLiIiIiIiIiCwBUQk1rLWPWWvHvJsvAiXnerwxphAIWGtftK6n7PeAt0djLCIiIiIiIiKyNMxGTY3/Avxmyu3lxpjdxphnjTFXeueKgfopj6n3zomIiIiIiIiInJeE832gMeYJIHiGuz5trX3Ee8yngTHgAe++JqDMWtthjNkGPGyM2TCdARpjPgB8AKCsrGw6TxURERERERGRRey8Qw1r7fXnut8YcxfwVmCnt6QEa+0wMOwd7zLGVAOrgQZOXaJS4p070/t+E/gmwPbt2+35jldEREREREREFrdodT+5EfgYcIu1dmDK+TxjTLx3vAJXELTGWtsE9BpjLvO6nrwXeCQaYxERERERERGRpeG8Z2q8jv8D+IDHvc6sL3qdTq4CvmCMGQUiwF9bazu959wN3A8k42pw/Ob0FxUREREREREROZuohBrW2pVnOf8T4Cdnue8VYGM03l9ERERERERElh7jlb9YEIwxbUBtrMcxQ7lAe6wHIXNO131p0nVfmnTdlyZd96VL135p0nVfmnTdY2+ZtTbvTHcsqFBjITPGvGKt3R7rccjc0nVfmnTdlyZd96VJ133p0rVfmnTdlyZd9/ktKoVCRURERERERETmmkINEREREREREVmQFGrMnW/GegASE7ruS5Ou+9Kk67406bovXbr2S5Ou+9Kk6z6PqaaGiIiIiIiIiCxImqkhIiIiIiIiIguSQo1ZZoy50Rhz1BhzzBjziViPR2aPMeY7xphWY8yBKeeyjTGPG2OqvH1WLMco0WWMKTXGPG2MOWSMOWiM+ah3Xtd9kTPG+I0xfzTG7PWu/d9555cbY17yfuf/yBiTFOuxSvQZY+KNMbuNMb/0buu6L3LGmBPGmP3GmD3GmFe8c/pdv8gZYzKNMQ8ZY44YYw4bYy7XdV/8jDFrvL/r41uvMeZvdO3nL4Uas8gYEw98HbgJWA/8iTFmfWxHJbPofuDG0859AnjSWrsKeNK7LYvHGPDfrLXrgcuAD3l/x3XdF79h4Dpr7WZgC3CjMeYy4D7gq9balUAX8OcxHKPMno8Ch6fc1nVfGq611m6Z0tZRv+sXv38GHrXWrgU24/7e67ovctbao97f9S3ANmAA+Bm69vOWQo3ZdSlwzFpbY60dAf4vcGuMxySzxFr7HNB52ulbge96x98F3j6ng5JZZa1tsta+6h334f5npxhd90XPOiHvZqK3WeA64CHvvK79ImSMKQHeAvy7d9ug675U6Xf9ImaMyQCuAr4NYK0dsdZ2o+u+1OwEqq21tejaz1sKNWZXMXByyu1675wsHQXW2ibvuBkoiOVgZPYYY8qBi4GX0HVfErwlCHuAVuBxoBrottaOeQ/R7/zF6X8BHwMi3u0cdN2XAgs8ZozZZYz5gHdOv+sXt+VAG/Af3nKzfzfGpKLrvtS8G/ihd6xrP08p1BCZI9a1GlK7oUXIGJMG/AT4G2tt79T7dN0XL2tt2JuaWoKbmbc2xkOSWWaMeSvQaq3dFeuxyJx7o7V2K25J8YeMMVdNvVO/6xelBGAr8K/W2ouBfk5bbqDrvrh59ZFuAR48/T5d+/lFocbsagBKp9wu8c7J0tFijCkE8PatMR6PRJkxJhEXaDxgrf2pd1rXfQnxpiM/DVwOZBpjEry79Dt/8bkCuMUYcwK3pPQ63Jp7XfdFzlrb4O1bcWvrL0W/6xe7eqDeWvuSd/shXMih67503AS8aq1t8W7r2s9TCjVm18vAKq8qehJu+tLPYzwmmVs/B97nHb8PeCSGY5Eo89bSfxs4bK39ypS7dN0XOWNMnjEm0ztOBt6Eq6nyNHCH9zBd+0XGWvtJa22JtbYc99/0p6y1d6LrvqgZY1KNMenjx8ANwAH0u35Rs9Y2AyeNMWu8UzuBQ+i6LyV/wuTSE9C1n7eMmzkjs8UYczNu/W088B1r7RdjPCSZJcaYHwLXALlAC/A54GHgx0AZUAu8y1p7ejFRWaCMMW8EfgfsZ3J9/adwdTV03RcxY8wmXJGweNw/EPzYWvsFY8wK3L/gZwO7gfdYa4djN1KZLcaYa4C/tda+Vdd9cfOu78+8mwnAf1prv2iMyUG/6xc1Y8wWXFHgJKAGeD/e73x03Rc1L8CsA1ZYa3u8c/o7P08p1BARERERERGRBUnLT0RERERERERkQVKoISIiIiIiIiILkkINEREREREREVmQFGqIiIiIiIiIyIKkUENEREREREREFiSFGiIiIiIiIiKyICnUEBEREREREZEFSaGGiIiIiIiIiCxICjVEREREREREZEFSqCEiIiIiIiIiC5JCDRERERERERFZkBRqiIiIiIiIiMiCpFBDRERERERERBYkhRoiIiIiIiIisiAp1BARERERERGRBUmhhoiIiIiIiIgsSAmxHsB05Obm2vLy8lgPQ0RERERERETmyK5du9qttXlnum9BhRrl5eW88sorsR6GiIiIiIiIiMwRY0zt2e7T8hMRERERERERWZAUaoiIiIiIiIjIgqRQQ0REREREREQWpAVVU0NERERERESWntHRUerr6xkaGor1UGQW+f1+SkpKSExMPO/nKNQQERERERGRea2+vp709HTKy8sxxsR6ODILrLV0dHRQX1/P8uXLz/t5Wn4iIiIiIiIi89rQ0BA5OTkKNBYxYww5OTnTno2jUENERERERETmPQUai99MrrFCDREREREREZEZ+PznP88//dM/Re313vCGN0wc33PPPWzYsIF77rmHb3zjG3zve9+b9ut1d3fzL//yLxO3GxsbueOOO6Iy1muuuYZXXnklKq91IVRTQ0RERERERGQeeOGFFyaOv/nNb9LZ2Ul8fPyMX2881Lj77rsBKCoq4qGHHrrgcc4nmqkhIiIiIiIi8jq+973vsWnTJjZv3syf/dmfveb+b33rW1xyySVs3ryZ22+/nYGBAQAefPBBNm7cyObNm7nqqqsAOHjwIJdeeilbtmxh06ZNVFVVAZCWlgbALbfcQigUYtu2bfzoRz86ZUbIsWPHuP7669m8eTNbt26lurqaUCjEzp072bp1KxUVFTzyyCMAfOITn6C6upotW7Zwzz33cOLECTZu3Ai4OiXvf//7qaio4OKLL+bpp58G4P777+e2227jxhtvZNWqVXzsYx973Z/ND3/4QyoqKti4cSMf//jHAQiHw9x1111s3LiRiooKvvrVrwLwta99jfXr17Np0ybe/e53z+xiTKGZGiIiIiIiIrJg/N0vDnKosTeqr7m+KMDn3rbhrPcfPHiQe++9lxdeeIHc3Fw6Oztf85jbbruNv/zLvwTgM5/5DN/+9rf58Ic/zBe+8AV++9vfUlxcTHd3NwDf+MY3+OhHP8qdd97JyMgI4XD4lNf6+c9/TlpaGnv27AHcMpdxd955J5/4xCd4xzvewdDQEJFIhKSkJH72s58RCARob2/nsssu45ZbbuHLX/4yBw4cmHidEydOTLzO17/+dYwx7N+/nyNHjnDDDTdQWVkJwJ49e9i9ezc+n481a9bw4Q9/mNLS0jP+bBobG/n4xz/Orl27yMrK4oYbbuDhhx+mtLSUhoYGDhw4ADDx2b/85S9z/PhxfD7fxLkLoZkas6xvaJQXjrXTPTAS66GIiIiIiIjIDDz11FO8853vJDc3F4Ds7OzXPObAgQNceeWVVFRU8MADD3Dw4EEArrjiCu666y6+9a1vTYQXl19+Of/wD//AfffdR21tLcnJyec1jr6+PhoaGnjHO94BgN/vJyUlBWstn/rUp9i0aRPXX389DQ0NtLS0nPO1fv/73/Oe97wHgLVr17Js2bKJUGPnzp1kZGTg9/tZv349tbW1Z32dl19+mWuuuYa8vDwSEhK48847ee6551ixYgU1NTV8+MMf5tFHHyUQCACwadMm7rzzTn7wgx+QkHDh8yw0U2OWVbb08af//hL/8f5LuHZNfqyHIyIiIiIisqCda0ZFLN111108/PDDbN68mfvvv59nnnkGcLMyXnrpJX71q1+xbds2du3axZ/+6Z+yY8cOfvWrX3HzzTfzb//2b1x33XUzfu8HHniAtrY2du3aRWJiIuXl5dNujTqVz+ebOI6Pj2dsbGzar5GVlcXevXv57W9/yze+8Q1+/OMf853vfIdf/epXPPfcc/ziF7/gi1/8Ivv377+gcEMzNWZZQcAPQEvPzP9AiYiIiIiISOxcd911PPjgg3R0dACccflJX18fhYWFjI6O8sADD0ycr66uZseOHXzhC18gLy+PkydPUlNTw4oVK/jIRz7Crbfeyr59+85rHOnp6ZSUlPDwww8DMDw8zMDAAD09PeTn55OYmMjTTz89MbMiPT2dvr6+M77WlVdeOTHOyspK6urqWLNmzfn/UDyXXnopzz77LO3t7YTDYX74wx9y9dVX097eTiQS4fbbb+fee+/l1VdfJRKJcPLkSa699lruu+8+enp6CIVC037PqTRTY5blp7tQo7lXoYaIiIiIiMhCtGHDBj796U9z9dVXEx8fz8UXX8z9999/ymP+/u//nh07dpCXl8eOHTsmwoR77rmHqqoqrLXs3LmTzZs3c9999/H973+fxMREgsEgn/rUp857LN///vf5q7/6Kz772c+SmJjIgw8+yJ133snb3vY2Kioq2L59O2vXrgUgJyeHK664go0bN3LTTTfxoQ99aOJ17r77bj74wQ9SUVFBQkIC999//ykzNM5XYWEhX/7yl7n22mux1vKWt7yFW2+9lb179/L+97+fSCQCwJe+9CXC4TDvec976OnpwVrLRz7yETIzM6f9nlMZa+0FvcBc2r59u50PfXCna/u9j/Om9QV86bZNsR6KiIiIiIjIgnP48GHWrVsX62HIHDjTtTbG7LLWbj/T47X8ZA4UBPw0afmJiIiIiIiISFQp1JgDwYCfZoUaIiIiIiIiIlGlUGMOFGT4aVFNDREREREREZGoUqgxB4IBP10DowyNhmM9FBERERERkQVpIdWDlJmZyTVWqDEHgl5b19be4RiPREREREREZOHx+/10dHQo2FjErLV0dHTg9/un9Ty1dJ0DBRmTbV3LclJiPBoREREREZGFpaSkhPr6etra2mI9FJlFfr+fkpKSaT1HocYcKJwSaoiIiIiIiMj0JCYmsnz58lgPQ+YhLT+ZAwXe8pMWdUARERERERERiRqFGnMg4E8gOTFeMzVEREREREREokihxhwwxhDM8CvUEBEREREREYkihRpzpCDg0/ITERERERERkSiaUahhjDlhjNlvjNljjHnFO5dtjHncGFPl7bO888YY8zVjzDFjzD5jzNYpr/M+7/FVxpj3RecjzU/BgGZqiIiIiIiIiETThczUuNZau8Vau927/QngSWvtKuBJ7zbATcAqb/sA8K/gQhDgc8AO4FLgc+NByGJUkOGntXdYfZVFREREREREoiSay09uBb7rHX8XePuU89+zzotApjGmEHgz8Li1ttNa2wU8DtwYxfHMK8GAn5FwhM7+kVgPRURERERERGRRmGmoYYHHjDG7jDEf8M4VWGubvONmoMA7LgZOTnluvXfubOcXpaDX1lVLUERERERERESiI2GGz3ujtbbBGJMPPG6MOTL1TmutNcZEZZ2FF5p8AKCsrCwaLxkTBRku1GjpHWJDUUaMRyMiIiIiIiKy8M1opoa1tsHbtwI/w9XEaPGWleDtW72HNwClU55e4p072/nT3+ub1trt1trteXl5MxnuvDAxU6NnOMYjEREREREREVkcph1qGGNSjTHp48fADcAB4OfAeAeT9wGPeMc/B97rdUG5DOjxlqn8FrjBGJPlFQi9wTu3KOWl+zBGy09EREREREREomUmy08KgJ8ZY8af/5/W2keNMS8DPzbG/DlQC7zLe/yvgZuBY8AA8H4Aa22nMebvgZe9x33BWts5408yzyXGx5Gb5qOlR6GGiIiIiIiISDRMO9Sw1tYAm89wvgPYeYbzFvjQWV7rO8B3pjuGhSoY8GumhoiIiIiIiEiURLOlq7yOgoCfFoUaIiIiIiIiIlGhUGMOBTN8mqkhIiIiIiIiEiUKNeZQMOCne2CUodFwrIciIiIiIiIisuAp1JhDBV5bVy1BEREREREREblwCjXmUDDDhRrN6oAiIiIiIiIicsEUasyhoDdTQ3U1RERERERERC6cQo05VJCh5SciIiIiIiIi0aJQYw6l+xJISYqnuWc41kMRERERERERWfAUaswhYwzBgF8zNURERERERESiQKHGHCsI+FVTQ0RERERERCQKFGrMsWCGX91PRERERERERKJAocYcK/CWn0QiNtZDEREREREREVnQFGrMsWDAx1jE0tE/EuuhiIiIiIiIiCxoCjXmWFBtXUVERERERESiQqHGHCsIuFBDdTVERERERERELoxCjTlWmJEMoA4oIiIiIiIiIhdIocYcy01LIs5o+YmIiIiIiIjIhVKoMccS4uPIS/dp+YmIiIiIiIjIBVKoEQPBgF/LT0REREREREQukEKNGCgI+LX8REREREREROQCKdSIgWCGX8tPRERERERERC6QQo0YKAj46R0aY3AkHOuhiIiIiIiIiCxYCjViIBjwA2rrKiIiIiIiInIhFGrEQDDDCzW0BEVERERERERkxhRqxECBN1NDxUJFREREREREZk6hRgxMzNRQqCEiIiIiIiIyYwo1YiDNl0CaL0HLT0REREREREQugEKNGCkI+LT8REREREREROQCKNSIkWCGX8tPRERERERERC6AQo0YKQj4adHyExEREREREZEZU6gRI8GAn9a+YSIRG+uhiIiIiIiIiCxICjViJJjhZyxiae8fjvVQRERERERERBYkhRoxUhBwbV1behRqiIiIiIiIiMyEQo0YCXqhhoqFioiIiIiIiMyMQo0YCWYo1BARERERERG5EAo1YiQ3zUd8nFEHFBEREREREZEZUqgRI/Fxhrw0n2ZqiIiIiIiIiMyQQo0YKsjw06JQQ0RERERERGRGFGrEUDDgo1nLT0RERERERERmRKFGDAUDfi0/EREREREREZkhhRoxVJDhp29ojP7hsVgPRURERERERGTBUagRQ8GA2rqKiIiIiIiIzJRCjRgaDzXU1lVERERERERk+hRqxFBBhmZqiIiIiIiIiMyUQo0Y0vITERERERERkZlTqBFDqb4E0v0JWn4iIiIiIiIiMgMKNWJMbV1FREREREREZkahRowFM/w09w7HehgiIiIiIiIiC45CjRgrCPi1/ERERERERERkBhRqxFgw4KctNEw4YmM9FBEREREREZEFRaFGjBVk+AlHLO0hLUERERERERERmQ6FGjE20dZVS1BEREREREREpkWhRoxNhBrqgCIiIiIiIiIyLQo1YqwgwwdAi0INERERERERkWlRqBFjuak+EuKMlp+IiIiIiIiITJNCjRiLizPkp/u0/ERERERERERkmhRqzAMFGX4tPxERERERERGZJoUa80Aw4NfyExEREREREZFpUqgxDxQE/LT0Dsd6GCIiIiIiIiILikKNeSCY4Sc0PEZoeCzWQxERERERERFZMGYUahhj4o0xu40xv/RuLzfGvGSMOWaM+ZExJsk77/NuH/PuL5/yGp/0zh81xrw5Gh9moQoG/ABagiIiIiIiIiIyDTOdqfFR4PCU2/cBX7XWrgS6gD/3zv850OWd/6r3OIwx64F3AxuAG4F/McbEz3AsC16BF2qoWKiIiIiIiIjI+Zt2qGGMKQHeAvy7d9sA1/0/9u48Ou67vvf/6zO7RtJo32Vblm15X5I4+2qHhJAEErjQ0gJNAoVyChRKgQK35/S2ve2v7S2XhG4HQ8JNgZKGQEigEIjjOM6e2Ikd75ts2ZJt7dY+++f3x3wly8SxLVvSzGiej3PmfL/fz3xn5j3+xEr0ymeR9Jhzy8OS7nbO73Ku5Tx/s3P/XZIesdZGrLWHJB2QdMWFfolsV13ESA0AAAAAACbqQkZq3C/pK5KSznWZpJPW2tEFIVol1TnndZKOSpLzfJ9z/1j7GV5zGmPMp4wxm40xmzs7Oy+g3Mw3Nv2EkRoAAAAAAJy3CYUaxpg7JXVYa7dMUT1vY61dZ61dba1dXVFRMV0fO63yfG6FAh6mnwAAAAAAMAGeCd5/raT3GWNulxSQFJL0gKRiY4zHGY1RL6nNub9N0ixJrcYYj6QiSd3j2keNf01Oqi4KMP0EAAAAAIAJmNBIDWvt16y19dbaBqUW+txgrf2IpGclfdC57R5JTzjnTzrXcp7fYK21TvuHnd1R5kpaIOm1i/omWa4qFGCkBgAAAAAAE3Chu5/8tj+X9EVjzAGl1sx40Gl/UFKZ0/5FSV+VJGvtTkmPStol6SlJn7HWJiaplqxUHQqwpgYAAAAAABMw0eknY6y1GyVtdM6bdYbdS6y1YUkfeofX/62kv73Qz59pqosC6hyIKJ5IyuOerKwJAAAAAICZi9+eM0RVKKCklboGo+kuBQAAAACArECokSHY1hUAAAAAgIkh1MgQ1UVOqNE3kuZKAAAAAADIDoQaGaJqdKQG27oCAAAAAHBeCDUyRFm+T1630Yn+SLpLAQAAAAAgKxBqZAiXy6iyMKB21tQAAAAAAOC8EGpkkOqiANNPAAAAAAA4T4QaGaQ6xEgNAAAAAADOF6FGBqkKBXSiPyxrbbpLAQAAAAAg4xFqZJDqIr+GowkNROLpLgUAAAAAgIxHqJFBRrd1bWddDQAAAAAAzolQI4NUO6HGCdbVAAAAAADgnAg1Mkh1kRNqMFIDAAAAAIBzItTIIGPTTxipAQAAAADAORFqZJCA163ioJfpJwAAAAAAnAdCjQxTHQroRF8k3WUAAAAAAJDxCDUyTFUowPQTAAAAAADOA6FGhqkOBZh+AgAAAADAeSDUyDBVRQF1DUYUSyTTXQoAAAAAABmNUCPDVIcCslbqHGBdDQAAAAAAzoZQI8NUF/kliSkoAAAAAACcA6FGhqkKBSRJ7X2EGgAAAAAAnA2hRoapdkINRmoAAAAAAHB2hBoZpjTfJ5/bRagBAAAAAMA5EGpkGGOMKkN+pp8AAAAAAHAOhBoZqDoUYKQGAAAAAADnQKiRgaqKAjrBSA0AAAAAAM6KUCMDNVUWqqVnWN2DkXSXAgAAAABAxiLUyEBrFlXIWum5fZ3pLgUAAAAAgIxFqJGBltUWqbzArw17OtJdCgAAAAAAGYtQIwO5XEZrFlZo075OxRPJdJcDAAAAAEBGItTIUGsXVao/HNeWlt50lwIAAAAAQEYi1MhQ1y0ol9dttGEvU1AAAAAAADgTQo0MVRjw6vKGUj3LuhoAAAAAAJwRoUYGW7uoUvvaB9XaO5zuUgAAAAAAyDiEGhlszaJKSWK0BgAAAAAAZ0CokcEay/M1pyyoZ/d2prsUAAAAAAAyDqFGBjPGaM3CSr10sEvhWCLd5QAAAAAAkFEINTLc2kWVCseSevlgd7pLAQAAAAAgoxBqZLgr5pYqz+vWBtbVAAAAAADgNIQaGS7gdeva+eXasKdD1tp0lwMAAAAAQMYg1MgCaxdVqu3kiPZ3DKa7FAAAAAAAMgahRhZYs6hCkpiCAgAAAADAOIQaWaCmKE+La0KEGgAAAAAAjEOokSXWLqrQlpZe9Q3H0l0KAAAAAAAZgVAjS6xdVKlE0mrT/s50lwIAAAAAQEYg1MgSq2aVqCTo1bNMQQEAAAAAQBKhRtZwu4xubKrQxn2dSiTZ2hUAAAAAAEKNLLJmUaV6hqJ6q/VkuksBAAAAACDtCDWyyI1NFXIZMQUFAAAAAAARamSV4qBPl84u0Ya9hBoAAAAAABBqZJk1iyq1o61fHf3hdJcCAAAAAEBaEWpkmbWLKiVJzzJaAwAAAACQ4wg1ssyi6kLVFAW0gXU1AAAAAAA5jlAjyxhjtGZRpV7Y36VIPJHucgAAAAAASBtCjSy0dmGlhqIJvX6oN92lAAAAAACQNoQaWeia+WXyeVxMQQEAAAAA5DRCjSwU9Hl0dWMZi4UCAAAAAHIaoUaWWruoUoe6hnSoayjdpQAAAAAAkBYTDjGE4nYAACAASURBVDWMMQFjzGvGmG3GmJ3GmL9y2ucaY141xhwwxvyXMcbntPud6wPO8w3j3utrTvteY8y7J+tL5YKxrV2ZggIAAAAAyFEXMlIjImmttXalpFWSbjPGXCXpHyR901o7X1KvpE84939CUq/T/k3nPhljlkj6sKSlkm6T9G/GGPfFfJlcMqs0qPmVBUxBAQAAAADkrAmHGjZl0Ln0Og8raa2kx5z2hyXd7Zzf5VzLef5mY4xx2h+x1kastYckHZB0xQV9ixy1ZmGFXm3u0VAknu5SAAAAAACYdhe0poYxxm2M2SqpQ9LTkg5KOmmtHf3tulVSnXNeJ+moJDnP90kqG99+htfgPKxZVKloIqkXDnSluxQAAAAAAKbdBYUa1tqEtXaVpHqlRlcsmtSqxjHGfMoYs9kYs7mzs3OqPiYrXd5QqkK/h3U1AAAAAAA56aJ2P7HWnpT0rKSrJRUbYzzOU/WS2pzzNkmzJMl5vkhS9/j2M7xm/Gess9auttaurqiouJhyZxyv26Xrm8r17N4OWWvTXQ4AAAAAANPqQnY/qTDGFDvneZJukbRbqXDjg85t90h6wjl/0rmW8/wGm/oN/ElJH3Z2R5kraYGk1y70i+SqNQsr1d4f0c5j/ekuBQAAAACAaeU59y1vUyPpYWenEpekR621vzDG7JL0iDHmf0t6U9KDzv0PSvq+MeaApB6ldjyRtXanMeZRSbskxSV9xlqbuLivk3tuWnhqa9dldUVprgYAAAAAgOljsmnawurVq+3mzZvTXUbGuetfXpDLZfT4H1+b7lIAAAAAAJhUxpgt1trVZ3ruotbUQGZYs6hSW4+eVPdgJN2lAAAAAAAwbQg1ZoC1iyplrfTcPnaHAQAAAADkDkKNGWBZbZHqivP08Mst7IICAAAAAMgZhBozgMtl9Nm187Xt6Elt2NOR7nIAAAAAAJgWhBozxAcvq9fs0qD+79P7GK0BAAAAAMgJhBozhNft0p/cvEA7j/Xr1ztPpLscAAAAAACmHKHGDHL3qlo1VuTrm0/vVzLJaA0AAAAAwMxGqDGDeNwufeFdTdrbPqBfbD+e7nIAAAAAAJhShBozzJ3La7SwqlD3r9+neCKZ7nIAAAAAAJgyhBozjMtl9Ke3LFBz55Ce2Hos3eUAAAAAADBlCDVmoHcvrdbS2pAeeGa/YozWAAAAAADMUIQaM5AxRl+8pUlHeob1ky2t6S4HAAAAAIApQagxQ61dVKlVs4r1zxsOKBJPpLscAAAAAAAmHaHGDDU6WqPt5Igeff1oussBAAAAAGDSEWrMYNcvKNflDSX6l2cPKBxjtAYAAAAAYGYh1JjBUqM1Fqq9P6Ifvnok3eUAAAAAADCpCDVmuKvnlemaeWX6940HNByNp7scAAAAAAAmDaFGDvizW5vUNRjVf7zcku5SAAAAAACYNIQaOeCyOaW6salC337uoAYjjNYAAAAAAMwMhBo54ou3NKl3OKbvvXAo3aUAAAAAADApCDVyxMpZxXrX4ip95/lm9Y3ELug9rLWy1k5yZQAAAAAAXBhCjRzyxVua1B+O68Hnmyf0uhN9YX3z6X266v97Rh/57qsEGwAAAACAjOBJdwGYPktqQ7p9ebUeevGw7rt2rkryfe94bzJp9cKBLv3w1Rat392hpLVqqizUSwe7tWl/l25sqpjGygEAAAAAeDtGauSYL7yrSUPRuL696cyjNXqHolq36aDWfmOj/uCh1/T64V598vpGPfelNfr5565TXXGe7l+/j9EaAAAAAIC0Y6RGjmmqKtT7Vtbq4ZcO6xPXzVVFoV/WWr1xpFc/eOWI/nv7cUXjSV3eUKI/vaVJty2rlt/jHnv9Z9bM19cf367n9nXqpoWVafwmAAAAAIBcR6iRgz5/8wL9fNsx3b9+nxbVhPTDV1q058SACvweffjyWfr9K2drUXXojK/94GX1+tdnD+ib6/frxqYKGWOmuXoAAAAAAFIINXJQY0WBPnBpvX746hFJ0pKakP7u/ct116pa5fvP/o+Ez+PSZ9fO19d+ul0b93VqDaM1AAAAAABpQqiRo75y20JVFPp1y5IqXTKreEIjLkZHa9z/9D7dxGgNAAAAAECasFBojqosDOjPb1ukS2eXTDiU8Lpd+tza+drW2qdn93ZMUYUAAAAAAJwdoQYuyAcurdes0jzdv34/O6EAAAAAANKCUAMXxOt26XNrFuit1j5t2MNoDQAAAADA9CPUwAV7/6V1ml0aZLQGAAAAACAtCDVwwbzu1E4o29v69MxuRmsAAAAAAKYXoQYuygcuqdOcsqDuf2YfozUAAAAAANOKUAMXxeN26XNrF2hHW7+e3tWe7nIAAAAAADmEUAMX7e5VtWooY20NAAAAAMD0ItTARRsdrbHreL9+w2gNAAAAAMA0IdTApLhrVa3mlufr/vX7lUwyWgMAAAAAMPUINTApUqM15ms3ozUAAAAAANOEUAOT5n0ra9VYnq/71+9jtAYAAAAAYMoRamDSeNwu/cnNC7TnxIB+vfNEussBAAAAAMxwhBqYVO9dWavGinw98AxrawAAAAAAphahBiaV22X0eWe0xlOM1gAAAAAATCFCDUy6O1fUal5Fvh5gJxQAAAAAwBQi1MCkc7uM/uTmBdrbPqBf7WC0BgAAAABgahBqYErcuaJW8ysL9MAz7IQCAAAAAJgahBqYEqNra+xrH9T//NkO9Y3E0l0SAAAAAGCGIdTAlLljeY3uvaZB//X6Ea35p4165LUjjNoAAAAAAEwaQg1MGZfL6H+9b6l+/rnrNK8iX1/96Xa9/99e1NajJ9NdGgAAAABgBiDUwJRbWlukR//oat3/u6t0vC+su//1RX35x9vUORBJd2kAAAAAgCxGqIFpYYzR3ZfUacOXbtIf3dion21t09p/2qiHXjikWCKZ7vIAAAAAAFmIUAPTqsDv0dfes1hPfeEGXTKnRH/9i12641vP66WDXekuDQAAAACQZQg1kBbzKgr08H2Xa93HLtNILKHf/86r+swP31DbyZF0lwYAAAAAyBKEGkgbY4xuXVqtp//0Rn3xliat392um7+xUf/8zH6FY4l0lwcAAAAAyHCEGki7gNetP7l5gZ75sxu1ZmGlvvH0Pt12/yY9t68z3aUBAAAAADIYoQYyRn1JUP/+0cv0Hx+/Qi5jdM9Dr+nT39/ClBQAAAAAwBkRaiDj3NBUoV994Xp9+d0LtXFfh971jef0bxsPKBpnlxQAAAAAwCmEGshIfo9bn1kzX+u/eKNuaCrXPz61V7c9sEkv7GeXFAAAAABACqEGMlp9SVDf/thqfe++y5VIWn30wVf1mf98Q8f7mJICAAAAALmOUANZYc3CSv36CzekdknZ1a6bv/Gc1m06qFiCKSkAAAAAkKsmFGoYY2YZY541xuwyxuw0xnzeaS81xjxtjNnvHEucdmOM+ZYx5oAx5i1jzKXj3use5/79xph7JvdrYSYa3SXl6T+9UdfMK9Pf/XKPbn/geb18sDvdpQEAAAAA0sBYa8//ZmNqJNVYa98wxhRK2iLpbkn3Suqx1v69MearkkqstX9ujLld0uck3S7pSkkPWGuvNMaUStosabUk67zPZdba3rN9/urVq+3mzZsn/CUxM63f1a7/9fOdau0d0fULyvXeFbV699JqFQW96S4NAAAAADBJjDFbrLWrz/jcREKNM7zxE5L+xXncZK097gQfG621C40x33bOf+Tcv1fSTaMPa+0fOe2n3fdOCDXw28KxhL6zqVmPbjmqoz0j8rqNrptfrjtX1OqWpVUKBQg4AAAAACCbnS3U8FzEmzZIukTSq5KqrLXHnadOSKpyzuskHR33slan7Z3az/Q5n5L0KUmaPXv2hZaLGSrgdetzNy/QZ9fO1/a2Pv3ireP677eO689+vE2+n7p0Q1OF7lxRo3ctqVKB/4L/cQcAAAAAZKAL+i3PGFMg6SeSvmCt7TfGjD1nrbXGmAsf/vFbrLXrJK2TUiM1Jut9MbMYY7Sivlgr6ov1tfcs0tajJ8cCjvW72+XzuLRmYYXuXFGrmxdXKugj4AAAAACAbDfh3+yMMV6lAo0fWmt/6jS3G2Nqxk0/6XDa2yTNGvfyeqetTakpKOPbN060FuBMjDG6ZHaJLpldov95+2K9caQ3FXBsP65f72xXwOvSjU0Vqi3OU6Hfo4KAR/l+jwr8HhUGPCrwe1XgXBcEUkefh42CAAAAACDTTHShUCPpYaUWBf3CuPb/I6l73EKhpdbarxhj7pD0WZ1aKPRb1tornIVCt0ga3Q3lDaUWCu052+ezpgYuRiJptflwj37x1nFt3Nehk0MxDUbjOp+/Aj6PS9WhgK6cW6pr5pfp6sZyVRcFpr5oAAAAAMhxk7ZQqDHmOknPS9ouKek0f12pdTUelTRbUouk37HW9jghyL9Iuk3SsKT7rLWbnff6uPNaSfpba+33zvX5hBqYbMmk1UgsocFIXAPhuAYjcQ2NOx8MxzQUTWggHFdz56BePdSjvpGYJGlueb6unlemqxvLdFVjmSoK/Wn+NgAAAAAw80zZ7ifTjVAD6ZZIWu0+3q9Xmrv10sFuvXaoR4ORuCSpqapAVzeW6ep55bqqsVTFQV+aqwUAAACA7EeoAUyReCKpHcf69dLBLr18sFubD/dqJJaQMdLi6pBWN5RoRX2xVtYXqbGiQG6XOfebAgAAAADGEGoA0yQaT2pb60m9fLBbrzR3a9vRkxqKJiRJ+T63ltUVaeWsYq2oL9LK+mLVl+Rp/O5BAAAAAIDTEWoAaZJIWjV3Dmpba5/eaj2pba192n2sX9FEakma0nyfltcVaWV9kVbUF2vV7GKVF7A2BwAAAACMOluoMeEtXQGcP7fLaEFVoRZUFeqDl9VLSo3m2HtiQNtaT6aCjqN9en5/p5JWchnp3Uur9YfXN+qyOSVprh4AAAAAMhuhBjDNfB6XltcXaXl9kaQ5kqThaFw72vq1YU+H/vPVFv1qxwldOrtYn7qhUbcsqWYtDgAAAAA4A6afABlmKBLXjzcf1YMvHtLRnhHNKQvq49fO1YdW1yvoI4cEAAAAkFtYUwPIQomk1a93ntB3nm/Wm0dOqijPq49cOVv3XtOgylAg3eUBAAAAwLQg1ACy3JaWHn1n0yH9etcJeVxGd62q0x9eP1eLqkPpLg0AAAAAphQLhQJZ7rI5pbrsY6Vq6R7SQy8c0qObW/XYllZdv6BcaxZWKpG0iiaSiiWSiiesYomkor91HktYxUfvSVolklbxROqYsNZpS55qS9qx+/L9bl07v1xrF1Xqirml8nvc6f4jAQAAAABGagDZ6ORwVD989Yj+30uH1TkQOe05t8vI6zbyulzyelzyuo08Lpd84869biOXy8jjMnK7Um3ucdfusXYjt8ulzsGIXmnuVjSeVNDn1nXzy7VmUaXWLKxUdRFTYQAAAABMHaafADNUPJFUfzgun8clj8vI63ZN2U4pw9G4Xj7YrQ17OvTsng4d6wtLkpbUhLRmUYXWLqrUqlkl7NQCAAAAYFIRagCYVNZa7WsfHAs4thzpVSJpVRL06samCq1ZVKl5FQXyul3yOKNGPO5U6OJ1G3ncUx/CAAAAAJgZCDUATKm+4Zg27e/Us3s6tHFfp3qGouf9WpeRPG6XAh6XZpUG1VhRoMbyfDVW5GteRYHmlucr33/xy//EE0n1jcRUEvTJRZACAAAAZA1CDQDTJpG02t7Wp47+sOLJ1EKlY4uUJq1i8aTiydE25/lkUiPRhFq6h9XcNajW3hGN/9FUUxRQY0W+GssLUkcn+CgOetUzFFXXYERdg1F1D0bVPRhJXQ+lzrsHU8/3DsckSY3l+fr4dXP1Py6tV56PBU8BAACATEeoASCrhGOpgONg56CaOwfV3Dmkg11Dau4c1EA4fs7XhwIelRf4VV7gV1mBL/XI96vA79Ev3jqmba19Kgl69bGr5uhjVzeootA/Dd8KAAAAwIUg1AAwI1hr1TUYTQUdXUMaCMdUlp8KLkZDjNJ8n3we11nf4/XDvfrO881av7tdXrdL719Vp09cP1dNVYXT+G0AAAAAnA9CDQA4g+bOQT304iE9tqVV4VhSNzZV6JPXN+ra+WUyhnU3AAAAgExAqAEAZ9EzFNUPX2nRwy+3qGswosU1If3hdXP13pW1Zx31AQAAAGDqEWoAwHkIxxJ6cusxffeFZu1rH1RloV8fuXKOLm8o0aKakErzfekuEQAAAMg5hBoAMAHWWm3a36XvPt+s5/d3jbVXhfxaXBMaeyypKVRDWb48bkZzAAAAAFPlbKGGZ7qLAYBMZ4zRjU0VurGpQt2DEe0+PqDdx/u1+3i/dh3v14sHuhRLpAJhv8elpqpCLa4pHAs7aovy5HYbeVxGbtf4o2vs2uVizQ4AAADgYjFSAwAmKBpP6mDn4FjQMRp6dA9Fz/s9jNHbwg6v2yWv28jjNvK6XPK4U8953annPKNH516fJ/Xwe9zyO+c+t+vUufPc6HlZvk+zSoKqKQ7Iy+gSAAAAZAlGagDAJPJ5XGOjMkZZa9XpjOroHIgombSKJ60SyaRztKeOidPbY851NGEVT6TaY4mk4gmr+Pj2hNVgPK54IvV8NJ5UJJ5UNJFUJJZQ1GlLniOrdhmppihPdSV5mlUSVH1JnmaVnjpWhwJyM5IEAAAAWYBQAwAmgTFGlYUBVRYG0l2K4gkn7HACj1T4kVDHQEStvSNq7RlWa++IjvYO66WDXTrRH9b4QXsel1FtcZ5mlwZ1VWOpblpYqSU1IabMAAAAIOMw/QQAclwkntDxk2Ed7XXCDif0ONAxqF3H+yVJ5QV+3dBUrpsWVur6+eUqYScYAAAATBOmnwAA3pHf41ZDeb4ayvPf9lznQESb9nXquX2d2rCnQz99o00uI62cVaybmip148IKragrYhQHAAAA0oKRGgCA85JIWm1rPann9nZq475OvdV6UtZKpfk+Xb+gXDctrNDK+mIFfR4FvKcWMCXwAAAAwMU420gNQg0AwAXpGYrq+f2d2ri3U5v2db7j7i8+t0t+r0sBbyrkCHjdY6FHwOuSyxgZY2SU2hUmdTx1LZlx7ZLH7VJFgV8Vhacelc6xLN/PIqcAAAAzDNNPAACTrjTfp7tW1emuVXVKJq12HOvTgY5BhWOphUnDsaTCsYQi8dFjQpFYUuFxx3AsqUTSykqSTR2tlaxs6mjltKUCeGulaCKprsGIBsLxt9XkMlJZgV8VBX5Vhk4d/R63RmIJjUQTCscSY+cjsdOvw7GkRmIJReNJzSoNanFNoRZXh5zdbgpVVuCfzj9iAAAAnAOhBgDgorlcRivqi7WivnjaPnMkmlDXYEQdAxF1DoTVOTB6fuq4+3i/ugajSiStfG6XAl6X8nxu5XndCnjdY+ehgFcB5zzP65bbZXS4e0gvHujST99oG/vMykL/2Ha+i2sKtbgmpMbyfHncrmn73gAAADiFUAMAkJXyfG7NKg1qVmnwrPclk1ZJay84eOgejGjPiQHtPt6vXcf7tfv4gF462KxYIjV6xOdxqamqQPMqClSU51VhwKNQwKvCQOq8MOBRKM+rUMCjwoA3FaB4XTLm1DSZRNJqOBrXcDThPOIaGXc+2p60VlfOLVNTVcFprwcAAMhVhBoAgBnN5TJy6cIDgLICv66d79e188vH2qLxpJq7BrXbCTl2H+/XG0d61T8S10A4puQ5lqvyuIwKAx5ZScPR1HSXiZhTFtStS6p069JqXTq7hHVEAABAzmKhUAAAJpG1VsPRhPrDMQ2EUyFHfziu/pHR69G2mFzGKM/nVtDrUdDnVtDvVtDnVt7otc+toO/UeSxptXFvh36zs10vHexSLGFVXuDTuxZX6dalVbpmXrkCXne6/wgAAAAmFbufAAAwwwyEY9q4t1O/2dWuZ/d0aDASV9Dn1k0LK3TrkmqtWVSpojzvO74+mbQaCMfVOxxVz3BUvUNR9Q7HdHI4qrICnxrLC9RYka/CwDu/BwAAwHQg1AAAYAaLxBN6pblHv9l5Qk/valfHQEQel9HV88q0pCakvpGYeoaiOjkcGwswTo7ElDjXPBmlFkdtrMjXvIoCNVakgo75FQWqLc5j2gsAAJgWhBoAAOSIZNJqa+tJ/WZnu36z64Rae0ZUHPSqNN83diwJOo98n0rzvSoO+lTqtBXledU5GNbBziEd7BxU87hj30hs7HN8Hpcay/PVWJGv2aX5Cvrc8ntc8ntcCnjd8ntd8ntG29wKjF57U/cEfR6F8jzye5guAwAAzo5QAwAAXBRrrbqHomruHFJz5+BpgUdr74ji5zHq40z8HldqV5i81K4xozvFhMbtJDPaFvCeCklGw5Gx4OS0EMXF7jAAAMwgZws12P0EAACckzFG5QV+lRf4dcXc0rc9H08kFYmnHuFYwjlPKBJLnnYejicUjiU1Eo2PLaDaH46pfySu/nBMfSMxtfYMj52Pbp07UT6PS0Gf2xmV4h0bmVIS9KZGqAR9qREq49qK87wXvPUvAABID0INAABw0Txulzxul/L9k/ee1lpF4smx0OO0sCSeVCSWVDSRVGSs/fQgZTgaV+9wTL1DUZ3oD2v38X71DEcVjr3zFrrVoYAaK1LTakYXS52XhjVERhdy7RmO6uRwVHXFeaoMBabt8wEAyBaEGgAAICMZYxTwuhXwulVZOHnvOxJNpHZ9+a3FU3uGojraO6zmziE9ufWY+sPxsdf4PS7NLT897GisKNCc0qBcLqNE0iqeTKaOCetc29PbnevhaGLs83qGoqd9fqqumHqHo29byLWy0K8V9UVaVlek5XVFWl5fpMpCgo7xIvGE9p0Y1KKaQnkZdQMAOYFQAwAA5JQ8n1t5vjzVFue94z3WWnUNRtXcOajmrtQ6Is2dQ9p9fEC/3tl+XjvHnA+X0bhFW1Nb6V42J7WAa4kzPaYoz6sjPcPa3tqn7W19emZPh0aXRKsK+bW8rtgJOUJaXlesisJJHC4zSfa3D+gHr7SouWtIty6p0h0ralWa75vU93/k9aP66Rut6h2OqbLQr9+7YrZ+74rZqi4i+AGAmYyFQgEAACYgGk/qSM/w2CKpkuRxGbld5tTRbeR2ud7e7nIp4HWp1AkxQgGvXBOc1jIUiWvnsX5tb+vT9taT2t7Wp+auobGgozoU0IKqAvkmOFJhVmlQ71lWrdUNpZMy1SaWSGr9rnb9x8sterm5Wz63S3UleTrUNSSPy+iGpgrdtapWty6pVp5v4rvgDEfj+sVbx/Vfrx/VlpZeeVxGty6t0g0LKvTUzhN6bl+nXMbolsVV+uhVc3Tt/LKsWUC27eSIvvn0PgV9bn353QtVGPCmuyQASCt2PwEAAJjBBiNx7WxLjeTY3tanQ11DSk7gv/GslQ50DCoST6q8wK/bllXp9uU1uqKhdMKLp3b0h/Wj147qP19rUXt/RHXFefrIVbP1u6tnqTTfp93HB/TE1jY9ue2YjveFFfS59e6l1bprVa2um19+1s+z1mp7W58eef2ontx6TIORuBor8vXhy2fpA5fWq7zg1CiVI93D+uFrLfrx5lb1DEXVWJ6vj1w1Rx+8tF5FwcwMCQbCMf3bxoN68IVDMkoFQ9WhgP7hgyt0/YKKdJcHAGlDqAEAAICzGorE9ezeDv1q+wlt2NOhkVhCZfk+3bq0Wrcvr9ZVjWXvuE6FtVavHerR919p0VM7TiietLqhqUJ/cNUcrVlUecaRH8mk1auHevTE1jb9cvtx9YfjKi/w6c4VtbprVa1WzSoeG1nRNxzTz7a26ZHXj2r38X4FvC7dsbxWH75illbPKTnrCIxwLKFf7TiuH7xyRFtaehXwuvS+lbX66FVztKK+eHL+8C5SPJHUI68f1Tef3qfuoag+cEmdvvTuhTrRH9aXf7xNBzuH9HtXzNbXb1/EqA0AOYlQAwAAAOdtJJrQc/s69N/bT2jD7nYNRRMqDnp165IqvWd5ja6dVy6fx6WhSFyPv9mmH7zSoj0nBhQKePSh1bP00avmaG55/nl/XiSe0LN7OvXE1jY9s6dD0XhSDWVBvXdlrVp7R/TL7ccViSe1rC6k3718tt63slZFeRP/5X7XsX794NUW/ezNNg1HE1pZX6SPXDVHdyyvUb5/+peas9Zq495O/d0vd2t/x6CunFuqv7hjiZbXF43dE44l9M2n9+k7zzerpihP//A/Vui6BeXTXisApBOhBgAAAC5IOJbQpn2d+tWOE1q/q10DkbgKAx5dObdUrzT3aDAS19LakP7g6jl638q6C1ofY7z+cExPbT+hJ7a16aWD3SrweXTXJbX68OWztayu6NxvcJ6f8bM32/T9l1u0v2NQklQY8Kii0K+KAn/qWOhXZWFg7Hy0vTTfNylrjuw61q+/++VuvXCgS3PL8/W19yzSLUuq3nHUyZaWXn35x9vU3DWk379ytr5++2IVpCGIAYB0INQAAADARYvEE3rxQJd+uf2EXj7YrcsbSvSxqxt06eziKVmEs3coqjxfalvfqTA6bWZzS686ByLqHIyos985DkQ0GIm/7TVul1FZvk8NZflqqi5QU1WhFlQWqqmqQGUF5955pr0/rG/8Zq9+vKVVRXleff7mBfrIlXPk85x77ZJwLKFv/GavvvvCIdUW5ekfP7hC185n1AaAmY9QAwAAAJig4WhcXQNRdQyET4UeAxG194fV3Dmkve0DGgifCj7KC3xjAceCqkItrC5UU2WhioJeDUfjWrepWd9+rlnxZFL3XtOgz65ZcEGLlm5p6dGXf/yWmruG9JErZ+trjNoAMMMRagAAAACTzFqr9v6I9rUPaF/7gPa3D2pv+4AOdAyeNsqjstCvpLXqGozqjuU1+vPbFml2WfCiPjscS+iffr1XD76YGrXxfz64QtcwagPADEWoAQAAAEwTa62O9YWdoGNA+9oHNRCO9EM3aAAAIABJREFU6ZPXN2p1Q+mkftbmwz368mNv6ZAzauPOFbWaUxZUdSgg1ySs/QEAmYBQAwAAAJihRqIJ/dNv9uqhFw9p9D/tfR6XZpXkaXZpUHPK8p1j6lFfEjzvdUqstYomkgpHkxqOxTUSTai80K/QFG4t2zcS00A4popCv/yeqVlPBUB2IdQAAAAAZrjjfSM60DGolu5hHekZ1pHuYbX0DOtI95CGoomx+4yRqkMBzSoNqqLAr3AsoZFYQsPRhMLOcSSW0IhzTCTf/vtCQ1lQy+qKUo/aIi2rC6k46JtwzT1DUe1o69OOY33a2dav7W19OtIzPPZ8UZ5XlYV+VYZSu9FUFp6+O02q3a8Cv2dKFqu9EIORuF471K0XD3RrR1ufbmiq0EevnHNB66cASCHUAAAAAHKUtVbdQ1En7BjSke4RtfQM6Uj3sHqGogp43Qr63MrzuZXnTR2Dzq4zQZ9bQZ9n7NzvcenYyRFtb+vTjrZ+tZ0cGfuc+pI8Last0vL6Ii2tDWlZXZHKx+0I09Ef1o5jqdftaOvTjrY+HesLjz0/qzTPCUiKVJbvU+dARB0DkbGFWjucRzSefNt3DPrcaqzI1+LqkBbXjD4KLyhomahIPKE3Wk7qpYNdeulgt7YdPal40srncWluWb72tg8o6HPrw5fP1seva1B9ycWtpwLkIkINAAAAAJOudyiqncdSIyxSoy36dLj71EiL6lBADeVBNXcOqWMgIik1UmRuef7YCI9ltUVaWlt0XiMZrLXqH4mrYyCsjoGIE3aEdaIvov0dA9p9vF9dg9Gx+2uKAmMBx2jY0VCWL/dFrDeSSFrtPNanFw9066WDXXr9cI/CsaRcRlpeX6xr55Xp2vnlumxOiQJet3Yd69d3nm/Wz7cdk5V0x/IafeqGRi2rK7rgGoBcQ6gBAAAAYFr0h2Pa2davncdSozEOdw+rsSJ/bBTGktrQlG5B2zEQ1u7jqYBj9HGwc2hsGk2e162m6kLNq8iXz+2SMUYuI7mcY+raaXMZGec5I+lAx6Beae5Wv7OVb1NVga6ZV65r55frysbSs641cuzkiL734iH96LWjGozEde38Mn3y+kbd2FSRMVNngExFqAEAAAAgZ4VjCR3oGNSucUHHke5hJaxV0qZGgCStlLRWyaSVHT13jqPX1UUBXTuvXNfML9PV88pUWRiYcC394Zj+89Uj+t6Lh9TeH9Gi6kJ98vpGvXdlrXwe1xR8+9NZaxVPWnndU/9ZwGQh1AAAAACADBKNJ/XktmP6zqZm7W0fUHUooI9f16C7L6mTkVE0kVQ0nnpE4olT56e1p47D0biGowkNReIajMQ1FIlryLk+1ZbQUDR1nbSS3+NSUZ5XxUGvivK8KsrznXZ9qj31mFOWr9L8qV+jBDgTQg0AAAAAyEDWWj23r1PrNjXrpYPdF/Vefo9LBX6Pgn638n0eFfg9yvd7lO9c5/tTbX6PS4ORuPpGYjo5HEsdR2LqH4np5HD0tN1yRrldRjcsKNf7L63XLYurlOdju11MH0INAAAAAMhwO9r69OqhHvncRj6PK/Vwp3ad8Y1/uF2ntQW9qSBjsqaUxBJJ9Y3ExoUeUb1+uFdPvNmmY31hFfg9um1ZtT5wSZ2uaiyT6yIWXgXOx6SGGsaYhyTdKanDWrvMaSuV9F+SGiQdlvQ71tpek1rx5gFJt0salnSvtfYN5zX3SPoL523/t7X24XN9NqEGAAAAAKRHMmn16qEePf5mq365/YQGI3HVFAV016o6feDSOjVVFZ73ew1H49pzYvyCrgNq7R12tg/2ONsJp0aYBH1uBf2ntwd9qREoFQWpHXZqi/IIV2awyQ41bpA0KOk/xoUa/yipx1r798aYr0oqsdb+uTHmdkmfUyrUuFLSA9baK50QZLOk1ZKspC2SLrPW9p7tswk1AAAAACD9wrGEnt7VrsffbNNz+zqVSFotrQ3p/ZfU6X2rascWUbXW6lhfWLuPOeHFiVSAcbh7SKO/ihYGPFpcHdKcsqCiiaSGo4mxdUKGnbVARqKpYziWPGM9fo9Lc8qCmluer7nlBZpbHtTc8gI1lAdVUeBnh5ksN+nTT4wxDZJ+MS7U2CvpJmvtcWNMjaSN1tqFxphvO+c/Gn/f6MNa+0dO+2n3vRNCDQAAAADILF2DEf182zE9/mab3mrtk8tI18wrVyyR1J4TA+obiY3dO6csqMXVIS2uCWlxTaEW14RUX5J33qFDImk1Ekto2FkM9URfWIe7h3Soa0jNnUM63D2klu4hxRKnfs8t8Hs0tzxfDeX5aigLKujzyOtM8fG6Rx/mtHOf2yWPcx7wuhVyFkzN97kvKiAZjMTV3h9WR39EHQNhtfeH1d4f0UA4piU1Ia1uKNWi6kJ52J3mNGcLNSZrg+gqa+1x5/yEpCrnvE7S0XH3tTpt79QOAAAAAMgi5QV+3XftXN137Vwd6BjUz95s01M7T6gw4NEdK2q0uCakJTWFWlgdUoH/4n4FdbuMCpwFTyVpbnm+rp5Xdto98URSx06Gdah7SIc6B3Woa0iHuoe19WivfvHWMV3MspJul1Eo4BnbFSbkPIryvAoFRts8GokmxgKL9v6wOgdSxzMtwhrwuhT0efTo5lZJUr7PrVWzi3XZnFKtnlOiS2YXqzDgvfCiZ7jJCjXGWGutMWbSVh81xnxK0qckafbs2ZP1tgAAAACASTa/skBfevdCfendC9NWg8ft0uyyoGaXBXVjU8Vpz8UTScUSVtFEcuw8lkg612c+D0cT6g/HxhZP7RuJqX8kPnbe1jsydh5PnvpV2O9xqSoUUFXIr8W1Id24sGLsuqowoMqQX5WhgAr9Hhlj1HZyRJsP92hLS682H+7Vv2zYr6SVXEZaWB3S6jklWt1QosvmlKiu+PxHt8x0kxVqtBtjasZNP+lw2tskzRp3X73T1qbUFJTx7RvP9MbW2nWS1kmp6SeTVC8AAAAAIMd43C553FKeJn9LWmtTU2P6RmIK+jwKBTwTCh7qivNUt6pOd61KTWIYCMe09ehJbT7cqy0tvfrpG636/istkqTqUEDL6kKqKcpTdVFANUUB55inmqKAAt7c2XJ3skKNJyXdI+nvneMT49o/a4x5RKmFQvuc4OPXkv7OGFPi3HerpK9NUi0AAAAAAEwrY4yzQ8vk/JpdGPDq+gUVun5BarRJ3FmjZEtLrza39Gp/+4A2t/Tq5HDsba8tCXpV7QQc1UUB1YRSx0vnlGheRcGk1JcpJvynbYz5kVKjLMqNMa2S/lKpMONRY8wnJLVI+h3n9l8qtfPJAaW2dL1Pkqy1PcaYv5H0unPfX1trey7iewAAAAAAMGN53C4tqyvSsroi3XNNw1j7SDShE/1hHe8b0Ym+sI73nX6+7ehJdQ9FJUl/ccfiGRdqXNDuJ+nC7icAAAAAAExMOJZQR39E+X63ygr86S5nwqZj9xMAAAAAAJCBAl63ZpcF013GlGDzWwAAAAAAkJUINQAAAAAAQFYi1AAAAAAAAFmJUAMAAAAAAGQlQg0AAAAAAJCVCDUAAAAAAEBWItQAAAAAAABZiVADAAAAAABkJUINAAAAAACQlQg1AAAAAABAViLUAAAAAAAAWYlQAwAAAAAAZCVjrU13DefNGNMpqSXddVygckld6S4C045+z030e26i33MT/Z676PvcRL/nJvo9/eZYayvO9ERWhRrZzBiz2Vq7Ot11YHrR77mJfs9N9Htuot9zF32fm+j33ES/ZzamnwAAAAAAgKxEqAEAAAAAALISocb0WZfuApAW9Htuot9zE/2em+j33EXf5yb6PTfR7xmMNTUAAAAAAEBWYqQGAAAAAADISoQaAAAAAAAgKxFqTDFjzG3GmL3GmAPGmK+mux5MHWPMQ8aYDmPMjnFtpcaYp40x+51jSTprxOQyxswyxjxrjNlljNlpjPm8006/z3DGmIAx5jVjzDan7//KaZ9rjHnV+Zn/X8YYX7prxeQzxriNMW8aY37hXNPvM5wx5rAxZrsxZqsxZrPTxs/6Gc4YU2yMecwYs8cYs9sYczX9PvMZYxY6f9dHH/3GmC/Q95mLUGMKGWPckv5V0nskLZH0e8aYJemtClPo/0m67bfavirpGWvtAknPONeYOeKS/sxau0TSVZI+4/wdp99nvoiktdbalZJWSbrNGHOVpH+Q9E1r7XxJvZI+kcYaMXU+L2n3uGv6PTessdaustaudq75WT/zPSDpKWvtIkkrlfp7T7/PcNbavc7f9VWSLpM0LOlx0fcZi1Bjal0h6YC1ttlaG5X0iKS70lwTpoi1dpOknt9qvkvSw875w5LuntaiMKWstcettW845wNK/cdOnej3Gc+mDDqXXudhJa2V9JjTTt/PQMaYekl3SPquc21Ev+cqftbPYMaYIkk3SHpQkqy1UWvtSdHvueZmSQettS2i7zMWocbUqpN0dNx1q9OG3FFlrT3unJ+QVJXOYjB1jDENki6R9Kro95zgTEHYKqlD0tOSDko6aa2NO7fwM39mul/SVyQlnesy0e+5wEr6jTFmizHmU04bP+tntrmSOiV9z5lu9l1jTL7o91zzYUk/cs7p+wxFqAFME5vaP5k9lGcgY0yBpJ9I+oK1tn/8c/T7zGWtTThDU+uVGpm3KM0lYYoZY+6U1GGt3ZLuWjDtrrPWXqrUlOLPGGNuGP8kP+tnJI+kSyX9u7X2EklD+q3pBvT7zOasj/Q+ST/+7efo+8xCqDG12iTNGndd77Qhd7QbY2okyTl2pLkeTDJjjFepQOOH1tqfOs30ew5xhiM/K+lqScXGGI/zFD/zZ55rJb3PGHNYqSmla5Wac0+/z3DW2jbn2KHU3PorxM/6ma5VUqu19lXn+jGlQg76PXe8R9Ib1tp255q+z1CEGlPrdUkLnFXRfUoNX3oyzTVhej0p6R7n/B5JT6SxFkwyZy79g5J2W2v/77in6PcZzhhTYYwpds7zJN2i1Joqz0r6oHMbfT/DWGu/Zq2tt9Y2KPXv9A3W2o+Ifp/RjDH5xpjC0XNJt0raIX7Wz2jW2hOSjhpjFjpNN0vaJfo9l/yeTk09kej7jGVSI2cwVYwxtys1/9Yt6SFr7d+muSRMEWPMjyTdJKlcUrukv5T0M0mPSpotqUXS71hrf3sxUWQpY8x1kp6XtF2n5td/Xal1Nej3GcwYs0KpRcLcSv0PgkettX9tjGlU6v/gl0p6U9JHrbWR9FWKqWKMuUnSl6y1d9LvM5vTv487lx5J/2mt/VtjTJn4WT+jGWNWKbUosE9Ss6T75PzMF/0+ozkB5hFJjdbaPqeNv/MZilADAAAAAABkJaafAAAAAACArESoAQAAAAAAshKhBgAAAAAAyEqEGgAAAAAAICsRagAAAAAAgKxEqAEAAAAAALISoQYAAAAAAMhKhBoAAAAAACArEWoAAAAAAICsRKgBAAAAAACyEqEGAAAAAADISoQaAAAAAAAgKxFqAAAAAACArESoAQAAAAAAshKhBgAAAAAAyEqedBcwEeXl5bahoSHdZVyQoaEh5efnp7sMTDP6PTfR77mJfs9N9Hvuou9zE/2em+j39NuyZUuXtbbiTM9lVajR0NCgzZs3p7uMC7Jx40bddNNN6S4D04x+z030e26i33MT/Z676PvcRL/nJvo9/YwxLe/0HNNPAAAAAABAViLUAAAAAAAAWYlQAwAAAAAAZKWsWlPjTGKxmFpbWxUOh9NdylkVFRVp9+7d6S7jbQKBgOrr6+X1etNdCgAAAAAAE5L1oUZra6sKCwvV0NAgY0y6y3lHAwMDKiwsTHcZp7HWqru7W62trZo7d266ywEAAAAAYEKyfvpJOBxWWVlZRgcamcoYo7Kysowf5QIAAAAAwJlkfaghiUDjIvBnBwAAAADIVjMi1AAAAAAAALmHUCNLxOPxdJcAAAAAAEBGIdSYBHfffbcuu+wyLV26VOvWrZMkPfXUU7r00ku1cuVK3XzzzZKkwcFB3XfffVq+fLlWrFihn/zkJ5KkgoKCsfd67LHHdO+990qS7r33Xn3605/WlVdeqa985St67bXXdPXVV+uSSy7RNddco71790qSEomEvvSlL2nZsmVasWKF/vmf/1kbNmzQ3XffPfa+Tz/9tN7//vdPxx8HAAAAAADTIut3P8kEDz30kEpLSzUyMqLLL79cd911lz75yU9q06ZNmjt3rnp6eiRJf/M3f6OioiJt375dktTb23vO925tbdVLL70kt9ut/v5+Pf/88/J4PFq/fr2+/vWv6yc/+YnWrVunw4cPa+vWrfJ4POrp6VFJSYn++I//WJ2dnaqoqND3vvc9ffzjH5/SPwcAAAAAAKbTjAo1/urnO7XrWP+kvueS2pD+8r1Lz3rPt771LT3++OOSpKNHj2rdunW64YYbxrZJLS0t1cDAgNavX69HHnlk7HUlJSXn/PwPfehDcrvdkqS+vj7dc8892r9/v4wxisVikqT169fr05/+tDwez9jnSdLHPvax/5+9+w6L4tweOP6dpUpVekeQIiACimIXNXajRhMTo6ka04wpNzflpt3kl5tubpoxsUWNSdTEFmMSO6IoFhAVlY4gvXcW2N35/QF6bShlafp+nocH2Jl9510HVubMec9h3bp1PPbYYxw5coS1a9c289ULgiAIgiAIgiAIQucllp+0UlhYGHv27OHIkSOcOnWKoKAgAgMDmzXGlR1Irm2vamxsfPnrt956i1GjRhEbG8v27dtv2Yr1scceY926dfzyyy/cd999l4MegiAIgiAIgiDcmY6lFjFmcRiHEgs6eirt7lxWGe9tP8eWkxlU1YqahbeL2+oq91YZFW2htLSUHj16YGRkRFxcHJGRkSiVSsLDw0lNTb28/ERPT4+xY8eyZMkSvvjiC6B++UmPHj2wtbXl/PnzeHt7s2XLFkxNTRs9lqOjIwCrV6++/PjYsWP5/vvvGTVq1OXlJxYWFjg4OODg4MD777/Pnj172vzfQhAEQRAEQRCEzquqVsXLv54ivaiKeWuOs/KRAQzztOroabW5lPwK/rsnke2nslBIoJHBWD+Wif72zOjnyCA3SxQK6dYDCZ2SyNRopQkTJqBSqfDx8eG1115j0KBBWFtbs2zZMmbMmEFAQAD3338/AG+++SbFxcX06dOHgIAA9u/fD8BHH33ElClTGDJkCPb29o0e65VXXuH1118nKCjoqm4o8+fPx8XFhb59+xIQEMDPP/98educOXNwdnbGx8enjf4FBEEQBEEQBEHoChbvSiC9qIpv5/TDzcqYeWuO39YZG1kl1by26TRj/xvOnnO5LBzlQfRbY9mwYBBT+jrwd2wODy4/yvBP9vPZzniS8ys6espCC9xWmRodwcDAgL/++uuG2yZOnHj56/LyckxMTFizZs11+917773ce++91z1+ZTYGwODBg0lISLj8/fvvvw+Arq4un3/+OZ9//vl1Yxw6dIgnnniiSa9FEARBEARBEITbU1RaMasiUpk7yIVJ/vYMcrfkweWRt2XGRkFFDUv2J/FTZDoADw925ZlQD6xNDQAIcbckxN2Sf0/1Y9e5HDZHZ/JtWBLf7E8i0Lk7M/s5cneAA92N9DvyZWjduawyHLob3navSwQ1bmP9+/fH2NiYxYsXd/RUBEEQBEEQBEHoIMo6Na/8dgoH8268NrE+g9vCWJ+fnxh0WwU2SqvrWB6ewqqIVGpUGu7t58Siuzxx7N7thvt309dhWqAj0wIdyStTsi0mi03RGby17Szv/XGOMb1tmdHPEYVGbudXol3ns8v4ck8if5/N4fkxnrw41qujp6RVIqhxG4uKiuroKQiCIAiCIAiC0MG+2ptIcn4lax4fiInB/y4Bb5fARlWtitWHL/BdWDJlShVT+trz4lgvelmbNHkMGzNDnhjhzvzhbpzLLmNzdCbbYjL5+2wOBjrgFxeBr4MZPvZm+Nqb4W1nipF+576cjsupD2b8FZuDqYEui8Z48vgwt46eltZ17rMgCIIgCIIgCIIgtFhsZinfh6dwX38nRnpZX7e9Kwc2alRqfjmazjf7kymoqGFMbxteGueFn4N5i8eUJAk/B3P8HMx5fWJvwhPz+WlfDOUKBdtOZrGuYUmLJIGbpTE+DvVBDl/7+oCHrZnBVd0tO0J8Tjlf7U1kx5lsTAx0WTTag3nD3DE30uvQebWV2yKoIctyh//gdFWy3LVTqQRBEARBEAShuWpVGkqqa7ExNezoqbSpWpWGl389haWxPm9O9m10v84e2CipqiU5v5KU/ApSCho+51eSVlhFrVpDiJsF3z/Uj/6uFlo9rq6OgtG9bVHkGBAaOhhZlskoruZcdhnns8s4l1XG6YwSdpzOvvwcC2N9fOxNeX6MFwPdtDufW0nILefLvYn8eSYbY31dnhvtwbxhbrddDY1rdfmghqGhIYWFhVhaWorARjPJskxhYSGGhrf3m7kgCIIgCIJwZ6tRqTmdUcrRlEIiU4qISiumuk7NQDcL5oS4MKGPHQa6Oh09Ta377kAycTnlLH84+JZ36TsysKFSa6ioUVFYWUtK/v+CFikF9Z8LK2sv76urkHCxNMLdyoTRPjaM8LRmSK/2uRaUJAlnCyOcLYwY72d3+fEyZR1x2eWcyyrlfHY5YQl5vLghhn0vj2yXn6vEhmDGjjPZGOnp8ExoL+YPc6eH8e0dzLikywc1nJycyMjIID8/v6OnclNKpbJTBg8MDQ1xcnLq6GkIgiAIgiAIgtbUqNSculhKZEohkSmFRKcXo6zTANDbzpT7BzhjYazPpugMnl8fg4WxPvf1d2L2QBd6Whl32LyVdWrKlHVaySCJzynn632JTA1wYKyvbZOeo43AhizLpBVWcSKtmIKKGiqUKsqVdZTXqKhQqqioafhQqiivqd926dxcycpEH3crE8b62uJubYy7lQnu1sY4Wxihp6No1pzampmhHgPdLC5nZhxMzOehlcf4KTK9TWtYJOWV89XeJLafzsJIT4enR/biieF3TjDjki4f1NDT08PNrfMXOwkLCyMoKKijpyEIgiAIgiC0gEqt4VRGCQcSCohOK8ZBUcvQ4ZpOd3HV2ZRU1XIms5RhHlZteiddWacm5mIJR1OKLgcxalQaJAl625kxe6ALIW6WhLhZXHXBt3CUBxHJBfwUmc6KQ6l8H57CcE8r5oS4MMbHtt3Or7JOzS/H0vnuQDLFlXW8NcWHuYNcW/xvplJreOW3U5ga6vHO3Y0vO7mR5gY2ZFkmKa+CyNQijqUWcSy1kNyymsvbFRKYGOhiaqiHqaEuJga6WBjr42JhhKlh/eMmBvWPdzfSo6eVMb2sTLp0/YfhntYM9bDkm/1J3BfshKmh9l/Lkv1JfLYrnm56OjzVEMywuMOCGZd0+aCGIAiCIAiCILSFzJJqwhPyCU/IJyKpgDKlCoUErpbGHCqo4/TXh/hoZl8Cnbt39FQ7FVmWiUwpYsPxdP6MzaFWpeHLBwKZFujYJscrra5j4hfhZJUqkSTwtTdjTogrg9zr75zfrJ6AQiEx3NOa4Z7W5JYp2Xj8Ir8cS+epddFYmxrwwABnHhjo0mhL0NZS1qn56Wh9MCO/vIaBbhZ42+nw1razRKYU8eFMf8xacEG88lAqpzJK+Xp2EJYmBs1+/s0CGxqNzPmcMo6lFnE0pYhjF4ooalgeYmtmQIibJQPdLAhxs8CxRze66enckWUCXhnfm2lLIlh+MJWXtNxC9Xx2GZ/vTmCcry0f3OPfonN8OxFBDUEQBEEQBEEAqmvVRKYWXg5kJOdXAmBnZsiEPnaM8LJmmIcV3Y30WbxhD78m13HPtxE8MrgnL4/3vqpV5p0or1zJpqhMNhxP50JhFaaGutwf7ExEUgHfHUhhaoBDm1zcrotMI6tUyeezAhjT27bFd/htzQx5bownz4zyICw+j5+OpvPN/iSW7E8i1NuGOSEuSFoqsl9dq+ano2l8dyCFgooaBrlb8NUDQQzuZYlGI7PsYAqf7ownNquUJQ/2o49j07t5JOdXsLjhgndKX/sWz/HawMYTw905n13G8QtFlClVADj16MYobxtC3CwIcbfAxcLojgxg3EiAc3cm+dux4mAKDw1yxdpUO4EHjUbmra2xmHfT46MZfe+4pSY3cme/8wqCIAiCIAh3tPzyGraezCQ8MZ+jqUXUqjQY6CoY6GbB7IEujPCyxtPG5LoLtf62uiyYNpTPdsaz5sgFdp7N4b1pfZpcu+B2odbIhCfks/54OnvP56HSyAzsacGiMZ5M7GNPN30dNp64yCu/neZAQj6h3jZaPX51rZpVh1IJ9bZmRj/t1InTUUiM8bFljI8tGcVVbDh+kfXHLzJvzQmMdGFI+gkGuVsQ4maJr4MZOoqmX8RX1ar4KTKd78OTKaioZUgvS5Y8GESIu+XlfRQKiadG9iLYtQcLfz7JjG8P89bdvswNcbllwECjkXn1t9MY6ip4f3qfVgcYrgxsfLM/CXcrYyb52xPibsFAN8s2y2C5Xbw8zpudZ3P5Zl8i707ro5UxN0VncCKtmE9mioDGJSKoIQiCIAiCINyRiitrue+7w1worMLTxoSHBrkywsuaEDcLDPVu3bHA1FCPd6f1YVqQI//afIYn1p5ggp8d/57qh5155ysQr00ZxVVsPJHBrycukl2qxNJYn3nD3Jg1wJle1iZX7Ts90JHPdyXw3YFkrQc1fo26SGFlLc+Eemh13Eucehjxj3HeLBrjyd7zefwcdoqkvHL2nM8FwNRQlwE9LS4HOfwczNC9QR2OqloVPx5JY1l4CoWVtQzzsOL5uzwZ0LPxlp/BPS348/nhvLQxhre2xhKZUshHM/xvWp9h7ZELnEgr5rP7ArAx087PoIWxPjsWDae0uu6OrdnQUu7WJswKdubnY+nMG+aOi6VRq8Yrqarlw7/i6O/ag3v7i2YPl4ighiAVWU/NAAAgAElEQVQIgiAIgnDHqVVpePqnKLJKlGxYMOiqO+XN1c+lB9ufG8bygyl8uSeRQ58X8OoEb+aEuKJoxl38zqqyRkV2qZKcUiUZxVX8GZvDwcT6zoPDPa15e4ovY3xs0de9cVFNfV0F84e78f6O88RcLNFaDZI6tYbvD6TQ37UHA3r20MqYjdHTUTChjx2GBXGEhoaSU6rkaGp9e9ijKYXsi8sD6gtiBvfsUV+U1N2CXtYm/HIsneUNwYzhnlY8P8aT4JsEM65kYazPqkcG8H14Cp/tiudsZinfNLIc5WJRFR//Hc9IL2tm9tNu/RIdhSQCGi30wl2ebDmZweLd8Xz5QOsaR3y6M56Sqlr+b1rIbfHeoi0iqCEIgiAIgiDcUWRZ5p3fY4lMKeK/9we0KqBxiZ6OgmdCPZjsb88bW2J5a9tZtpzM5MMZffG2M9XCrG8ur1zJ8dRiVJr65TP6ugr0dXQw0FOgr9PwvW7915e36ypQaWRyS5VklyrJLq2+HLz43+fqy/UTLrE3N+S50Z7MCnbCqUfT7jw/MNCFr/Ym8l1YMt891F8rr3n7qSwyS6p5b5pfu9dxsDM3ZFqg4+Xip3llSo6m1ndeOZpaRFh83FX7j/Cy5vkxnvR3bX7wRaGQeDq0F8E9e/DczyeZsfQwb0/xra/x0fC6ZVnmtc2n0VFIfDDDX9S16ERszQx5bKgbS8OSWTDCHT+HptdHudKpiyX8fCydx4a44etgpuVZdm1NCmpIkjQB+BLQAVbIsvzRNdtdgVWANVAEzJVlOUOSpEBgKWAGqIH/yLK8oeE5q4GRQGnDMI/KshzT6lckCIIgCIIgCDex8lAqvxy7yLOjenFPkHZTuF0tjflx3kC2xmTyf3+cZ/JXB3lypDvPjfZs0pKWplKpNcRcLCEsPp+whDxiM8u0NraViQEO3Q1xtTRikLsFdubdsDc3xM7cEHtzQ5x6GDWrjgTUZzA8PLgnS8KSSM6vuG6JSnNpNDLfHUjG29aU0b21u6SlJWzMDLk7wIG7AxyA+lotx1KLOJddyl0+tgS5tD6TZEBPC3YsGsZLG0/xZsNylA8blqNsOH6RiKRC/nNPH1HnohN6amQvfj6azid/x7Pm8YHNfr5aI/Pm1lisTQx4caxnG8ywa7tlUEOSJB1gCTAWyACOS5L0uyzL567Y7TNgrSzLayRJGg18CDwEVAEPy7KcKEmSAxAlSdJOWZZLGp73T1mWf9PmCxIEQRAEQRCExuyLy+U/f55nYh87/jHWu02OIUkS9wQ5MdLLhg/+PM+S/clsisqkn2t3PG1M8bQ1wdPGFDcr40aXbNxIfnkNBxLyCYvP42BiAaXVdSik+uUv/xzvzTAPK4wNdKhRaai99KG++utrtykk/he0MDPE1sywWXNqjkeH9mT5wRSWHUjh43v7tmqsvXF5JORW8MX9gZ0yK8Ha1IDJfe2Z3IruIzdiaWLAD48O4LvwZBbvSiA2s5S37/blPzvOM9jdktkDXLR6PEE7zLvp8UxoLz78K44jyYUM7tW87LCfj6ZxJrOUr2YH3bSmyp2qKZkaA4EkWZZTACRJWg9MA64MavgCLzV8vR/YCiDLcsKlHWRZzpIkKY/6bI4SBEEQBEEQBKEdxeWU8dzPJ/FzMGPxrIA2X5NuYazPZ/cFMCPIkdWHL3Auq4y/Y3PQNHQF1VFI9LQ0wtPGFC9bEzxsTfG0McHd2hgDXR3UGpmYi8X12Rjx+ZzJrE9wtjY1YKyvLaHe1gz3sG5xC9P2ZmViwH3BTmw8nsFL47ywbWEhS1mW+TYsCWeLbq1qWdpVKRQSz4R6EOxqwXO/RPP46hMY6in4aKa/qLPQiT0ypCerD1/go7/j2PrMkCYH4/LLa/hkZzxDelly9x34894UknyLXsuSJN0LTJBleX7D9w8BIbIsL7xin5+Bo7IsfylJ0gxgE2Aly3LhFfsMBNYAfrIsaxqWnwwGaoC9wGuyLNfc4PgLgAUAtra2/devX9+a19thKioqMDFpXZqd0PWI835nEuf9ziTOe+eikWWqVWCs17Z/4Lf1eS9WatgQX8swRz36WGlv6cKdqKxG5t0j1ahleGewIT0MW5eN0NJzX6uWyanUkFkhk1WhIatSQ2a5htwqmUt/lUuArZFEeZ1MZV399x7dFfhb69DXSgcXMwWKTpid0BR5VRpeDa9mgpse93u3rPBkXJGaj44pedhXn9Eu7RvQ6Wzv9WW1MhviauljpcNgB1Eusa1o67wfyKjjh9haFgYaEGzXtPO1/HQNkdkq/m9oNxxM2iaLqisYNWpUlCzLwTfapq2f/JeBbyRJehQIBzKpr6EBgCRJ9sCPwCOyLGsaHn4dyAH0gWXAq8B71w4sy/Kyhu0EBwfLoaGhWppy+woLC6Orzl1oOXHe70zivN+ZxHnvXP67O4FVEansfzkUKxODNjtOW573ExeK+OdP0eSXq0ks02H3S8NF94EWUtapeXB5JJVqJb8+OQR/p5YV6ruSts99jUpNSn4liXkVJOWWk5hXgbGBbpfLxmiKg6Un2R+Xx0cPD8W8W/Nf16pVx7Ay0fCv2aO1WqekKTrje/3UcR09g9ufts77MLWG8C/C+TMTXrhvxA3b/17paEohEX9H8kxoLx6c0LvVx79dNSXUkwk4X/G9U8Njl8mynCXL8gxZloOANxoeKwGQJMkM2AG8Icty5BXPyZbr1QA/UL/MRRAEQRAEoVU0GpmNJy5SrlSx/GBKR0+n2WRZ5scjF3hgWSTG+jp8PTuIMmUd7/x+tqOn1m6KK2tZcTCFKV8f5Ol1USTklrd4LFmWeX3zGaLTS/h8VqBWAhptwUBXBx97M6YGOPDSOG+Wzu3PZ/cFMKWvw20V0AB4coQ7FTUq1kWmNfu5sZmlhCfk8/gwt3YPaAhCa+nqKPjn+N6k5FfyW1TGTfetU2t4a1ssjt278dxoURz0ZpoS1DgOeEqS5CZJkj7wAPD7lTtIkmQlSdKlsV6nvhMKDftvob6I6G/XPMe+4bMETAdiW/NCBEEQBEEQACJTCskuVeJgbsjaw2kUVly3urXTUtapeeW307y17SzDPa3YtnAYdwc4sGi0J9tPZfF3bHZHT7HNyLLM0ZRCXlh/kpAP9/L+jvNISBxKLGD8F+G8tDGGi0VVzR7327BktpzM5B9jvZjkL9ajdwZ9HM0Z7mnFDxEXUNapb/2EKywNS8bUQJe5g1zbaHaC0LbG+9kS5NKdL/Yk3vTn/4eIVBJyK3jnbl+66YsA3s3cMqghy7IKWAjsBM4DG2VZPitJ0nuSJE1t2C0UiJckKQGwBf7T8PgsYATwqCRJMQ0fgQ3bfpIk6QxwBrAC3tfWixIEQRAEofOqrlVTXdu8C5nm2BSdiamBLssfCUapUrP8YGqbHUubskqqmfX9EX6NymDRGE9WPjLgcmr+U6G98HMw482tsRRX1nbwTLWrqCErY8znB7h/WSR74/KYPcCZv54fzvbnhhH+yiieGO7OjtPZjF4cxjvbYskvb1qg6q8z2Xy6M57pgQ4sHO3Rxq9EaI6nQ3tRUFHDpuib362+UmpBJX/GZjN3sCtmogOE0EVJksSrE3qTU6Zk9eELN9wnu7SaL/YkMqa3DWN9bdt3gl1Qk2pqyLL8J/DnNY+9fcXXvwHXtWaVZXkdsK6RMUc3a6aCIAiCINwW5q05jkaWWb9gsNbHrqpV8VdsNlMDHPBzMOfuvg6sPXKBJ4a7YdmGtTVa60hyIQt/jqZGpWHZQ/0Z52d31XY9HQWf3RfA3V8f4p3fz/LV7KAOmql2yLJMZEoRvxxL5+/YHGrVGvq79uCz+zyY7G9/1V3JHsb6/GuSD48PdePLvYmsO5rOxhMZPD6sJwtG9Gq0JsOZjFJe3BhDP5fufDSzb6ds+3knG+xuSYCTOcvCU3hggAs6Teja8f2BZPR1FDw+1K0dZigIbWeQuyWh3tZ8uz+J2QNcrlti9n9/nEOtkfn3VD/x3tUEd275VEEQBEEQ2t3FoioOJxcSmVLE2axSrY+/82wOVbVqZvRzAmDRGA+q6zpvtoYsy6w8lMrclUfpbqTH1meHXhfQuMTH3oznRnvy+6ks/o7NaeeZakdRZS3Lw1MYs/gAs5dHsj8+jwdDXPj7heFsenoI9/Z3ajTN2s7ckA9n+LPnpZHc5WvLkv3JjPhkP0vDkq/L/MkpVTJ/7XEsjQ34/qFgUXuhE5IkiadG9iKtsIq/mrCsKqdUyaboDGYFO2Nt2nkDlILQVK+M7015jYrvwpOvevxAQj5/nslh4SgPnC2MOmh2XYvo+yMIgiAIQrv5/VQWAPq6CtZFpvPhDH+tjr85OhNni24Eu/YAwMPGlCkN2RoLRrh3qu4h1bVqXtt8mm0xWYzztWXxrABMb5FS/8yoXuw8m8ObW2MJcbOgRwe9HlmWOZCQT2ZJ9eXlRFV16stfV9epqapVU12nqt/W8FhWSTV1aplg1x48O8qDSddkZTSFm5UxX88O4qmR7ny2M56P/47jh4hUnhvjyf3Bzqg1Mk+sPUGFUsWmZ4aIC+BObJyfHW5Wxnx3IJnJ/vY3vSO98lAKGhkWjHBvxxkKQtvxdTBjWoADP0Sk8uiQntiaGaKsU/POtljcrIxZMFL8rDeVCGoIgiAIgtAuZFlm68lMBvTsgZuVMVtPZvL6pN5aWxufU6okIqmAhaM8UFyRyr5otAd/nM5i+cEUXu0kLfEuFlXx5I9RnM8p4+VxXjwTevWcG3NpGcrUbw7x7vazfPFAxyxDWXP4Av/efu6auUkY6ulgpK+Dkb7u5a+NDXSxNDHASF+HCX52zOjnhLedaavn4Odgzg+PDeRYahGf7ozjra2xLA9PwaG7IbFZpax4OJjedmatPo7QdnQUEk+OcOe1zWeISCpkmKfVDfcrqarlp6Pp3N3XXty5Fm4r/xjnzY4z2XyxJ5EPZ/izLDyFC4VVrH18IAa6IsOsqURQQxAEQRCEdhGXU05iXgXvT+9DoHN3Np7IYHNUBo9qaX38tphMNDLc07D05BJP24ZsjcMXeGJ4x2drhCfks2j9STQamVWPDmCUt02znu/rYMbC0R58sSeRSf72jS5XaStRacW8v+M8d/nY8J97/C8HL/R0OmZV80A3CzY+OZiw+Hw+2RlPZEoRb0zyYYyPKK7XFdzTz5HPdyfw3YHkRoMaaw6nUVWr5qnQXu08O0FoW84WRswJceXHyDTG+9myZH8Sk/3tGeFl3dFT61JETQ1BEARBENrF1phMdBUSk/zt6eNoTqBzd36MTEOW5VaPLcsym6Iz6OfSHTcr4+u2LxrtQVWdmhUHU1p9rNbYejKTR384hq2pIb8vHNbsgMYlz4R64GNvxhtbYympar9uKAUVNTz7UzQO3buxeFYgtmaGmHfT67CAxiWSJDGqtw07nhvGvn+M5AmxRKHLMNDV4fFhbhxKKuBMxvV1dqpqVaw+nMqY3jYi80a4LS0c7YGhroJ5a06gq5B4a4pvR0+pyxFBDUEQBEG4TWk0MrllSgoqaiitqqOyRkWNSo1G0/ogQkvmsj0mixFe1pczJR4a5EpyfiVHUgpbPf7ZrDIScisuFwi9lqetKZP97Vlz+EKHtkT9MTINDxsTNj8zhJ43CL40lb6ugs/u60txZS3vXrMMpK2oNTKLfjlJcVUtS+f2a7TrSEdSKCTcrU06ehpCMz0Y4oKpgS7fHUi+btv6YxcprqrjmVEiS0O4PVmZGDB/uDtqjcwLd3lhZ27Y0VPqcsTyE0EQBKFLqahRYWIg/vu6leT8Cp77+STnsstuuF0hga6OAj2FhJ6uAl2FAj0dCX1dBa9P9GFCH+0uaTiRVkxWqZJXJ/6vpsXkvvb8345zrItMY0ivG6edN9WWk5no6yiY0te+0X0WjfFkx5lsVhxK4Z/j27+2Ro1KzZnMUh4Z7IqxFn6G/RzMeXaUB1/urV+GMta3bZdbfL47nsPJhXxyb1/8HMzb9FjCncXMUI+5g135/kAyFwoqLwf8alUalh9MYaCbBf1dLTp4loLQdp4d5UGAszkjPMWyk5YQfxUKgiAIXcbSsGS+2JPAtoVDRRpyI+qXYWTy9rZYDHQVvDHJBwM9BXVqGZVag0ojU6fWoFLXf65Ty6g0msvbDycXsnhXPOP9bG/aiaC5tsZk0k1P56oLb0M9He4PdmbFoVRySpUtvjulUmvYFpPJ6N42dDdqvF6Gl60pk/ztWR1xgfnD3Nu9c8jZrDJqVRr6N3Rm0YZnR3mw82wO/9pyhgE9e9z09bfGnnO5LNmfzAMDnJkV7NwmxxDubI8N7cnKQ6ksO5jCB/fUd0XaFpNJdqmSD7TcJUkQOht9XQWje4s6QC0lghqCIAhCl3Amo5TFu+JRaWSW7E/m69kd0/WhM6uoUfHW1li2nMwkxM2CLx8IanagYHN0Bi9tPEV4YgEjtVSorFal4c8z2Yzzs8VI/+o/PR4McWHZwRR+OZbOi2O9WjT+wcQCCipqmdHP8Zb7LhrtyY7T2aw8lMrL471bdLyWik4rBqCfi/aCGvXLUAKYviSC9/44x+ezArU29iXphVW8uDGGPo5m/Huqn9bHFwQAG1NDZvZz4reoDF64yxMrYwO+O5CMr70ZoaJooiAINyGCGoIgCEKnV12r5oUNJ7EyMWC0jw3rj6Xz0livGxaE7AhlyjoOZ6koPpmBjkKBrkJCRyFd8VlR/1nn6sfdrIyvu8hvqTMZpTz3SzTpRVW8eJcXC0d7oNOEFqHXmtLXgY/+imPFwRStBTUOJuZTUlXHtECH67a5Whoz0suaX46ls3C0R4sKTm6KzqCHkR6hTSi66W1XX1tj9eELzB/u1maZDTcSnV6MU49u2Jhpd710H0dznhnlwVd7E5nsb6/Vrh/KOjVP/xSFBCyd0x9DPdFiUGg7C0a4s/54Oj9EXCDAyZzk/Eq+nh2k1awxQRBuPyKoIQiCIHR6H/8dR3J+JevmheBtZ8qmqAyWhiXxyb0BHT011BqZ+WtOcCy1Bk6fatZzTQ11ua+/Mw8Ndm1xgEaWZVYeSuXjv+OwMjFg/YLBDHRr+dpzfV0FDw925bNdCcTnlONtZ9risS7ZFpNFDyM9hjeyVvihQa7MW3OC3edymeTfeE2MGylT1rH7XC73D3BGX7dpAZFLtTVWHkrlH+PaJ1tDlmWi0ooZ5G7ZJuMvHOXBrrM5vL75DLtftMDcSDtFPN/ZdpazWWWsejQYZwsjrYwpCI1xszJmYh871h1JI8zCCFdLIyZqub6PIAi3HxHUEARBELSiuLKWoqpaemm580B4Qj6rD1/gsaE9GeZZX0xy9kAX1kWmsWiMJ049OvZC69v9SRxLLeJhX30emzQEtaa+boVKLaPWyKg0lz5r/ve9WkapUrPrbC5rj1xgVUQqI7yseWSwK6HeNk3OsCisqOGfv51mX1weY31t+WRmX63UiXgwxJVv9iex6lAqH9/bt1VjVdao2H0ul5n9HRvNwgj1tsGxezd+PJLW7KDGX2eyqVFpGu16ciPedqZM8rfjh4gLzBvWPtkamSXV5JbVaHXpyZUuLUOZ1rAMZfGs1gf8NhxPZ8OJiywc5SHWegvt5qmRvfjzTA7ns8v44B5/dDu4XbAgCJ2feJcQBEG4icoaVUdPQSui04tJya9os/Hzy2uY/m0EE788SERSgdbGLa6s5eVfT+FpY8KrE/7XrWLBCHckCZaFp2jtWC0RlVbMF3sTmR7owGgXPdysjPGwMaW3nRl9HM0JcO5Of9ceDHSzYEgvK4Z7WjPK24a7fG2Z0teBr2YHcfi10bx4lxdx2WXMW3OC0M/2syw8mZKqm7cdPZxcwMQvD3IosYD3pvmx7KH+Wit8aWGsz4x+TmyJyaSgoqZVY+0+l0t1nZppgY3Xu9BRSMwZ5MKRlEKS8sqbNf6m6EzcrY0JcGpeN45FYzypqFGx8lBqs57XUtHpJQBaLRJ6rT6O5jwT2otN0Rnsi8tt1VixmaW8te0sQz0sW1zrRBBaoq9Td4Z7WmFnZsjM/reukyMIgiCCGoIgCI3YeOIiff69k/lrjnMkuRBZljt6Si1SVavioRVHmb4kgtjMUq2PX66s49EfjpFbpsSpRzfmrznBiQtFrR5XlmXe3BpLcVUt/70/8Kq1/A7duzGznxPrj18kr1zZ6mO1RJmyjufXn8ShuyH/N71Pi8exMTPk+bs8iXhtNN88GIS9eTc++DOOkA/28upvp687Zyq1hs93xTNnxVFMDHXZ8uwQHh7cU+trzh8f6katSsNPkemtGmdbTCaO3bvR/xYZCvcHO6Ovo2BdM453saiKY6lFzOzn1OzX39vOjIl97FgdceGWASRtiE4rppueDr21sJznZhaO9sDb1pRXfjvDj0da9tpKq+p4+qcoLI31+eqBoBbVZhGE1lgypx+/LxyKga6o4SIIwq2JoIYgCMINVNSo+OTveFwtjIhOL2H28kju/uYQW09mUqfWdPT0mmXn2Rwqa9UAPLTyKAm5zbsTfjM1KjVPrYsiLqecpXP6s2HBYOzMDXnsh+OtDqBsjclkx5lsXhzrRR/H6+/CPzWyFyq1hpUH2+dO+5VkWeaNLbFklyr58oEgTA1bX79AT0fBlL4ObHxyMH89P5wZ/Zz4/VQWU74+xL1LD/P7qSzSCiuZvTySr/YlMbOfE9sXDsPPoXkZCk3lYWPCKG9rfoy8gLJO3aIxCitqCE8sYGqgA4pbXBhbmhgwua89m6IympwhteVkJsANC5A2xaIxnpTXqFjVDtkaUWnFBDibt3kqvYGuDl/ODsTa1IC3tp1l4H/28uzP0YTF56HW3Dowq9HIvLQxhpxSJUvm9MPSxKBN5ysIN2JmqKf1grqCINy+RFBDEAThBpaHp1BQUcN/7w/k8Guj+XCGf0MHjhiGf7yf7w4kU1pd19HTbJJNUZk4W3Rj28Jh6OkoeHD5Ua0sRdFoZP6x8RQRSYV8MrMvo3rbYG1qwE/zQzDrpteqAEpmSTVvbz1LsGsPnhzR64b79LQy5u4AB36MTKO4su3vtF9pU3Qm209l8dJYrzapkeBjb8aHM/yJfH0Mb072Ib+ihkW/nGTkp2Gcyyrji/sD+ey+AIwN2rY01rxh7hRU1PL7qawWPf/PM9moNXKTgw5zB7lSXqNiW8ytjyfLMltOZjLI3aLFdVV87M2Y4FdfW6O0qu1+n6tqVZzLLmvTpSdX6m1nxl/PD+eP54bxYIgLh5MKePSH4wz5aG9D0d3Gf/+XHkhmb1web072bbP6H4IgCIKgTSKoIQiCcI28MiXLwlOY7G9PkEsPDPV0mD3Qhd0vjuSHRwfgbm3MR3/FMeTDvby7/SwXi6o6esqNyi6tJiK5gHuCnHCzMubnJ0KQZZk5K462at6yLPPeH+f443Q2r0/szcz+/yvS6NC9Gz/ND0FPR8HcFUe5UFDZrLHrgyUxaGSZ/94feNPU92dHeVBVq+aHwxda+lKaLbWgkre3xTLI3YKnRt444KIt5kZ6zB/uzv5/hLL6sQE8OdKdHYuGMz2ofdaZD/WwpLedKasOpbZo+dW2mCy8betrjDRFP5fu+NqbsfbIhVse7+TFElILKptVIPRGLmVrrIxou2yN0xmlqDVyuwU1LunjaM6/p/oR+a8xLJ3Tjz4O5iwLT2HM4gPM+DaCX46lU6b8XzAnIqmAxbvimRrgwMODXdt1roIgCILQUiKoIQiCcI3/7klApdHwyoSrWz0qFBKjetvw8xOD2LFoGOP97PjxSBojP93PMz9FEZVW3EEzbtzWk1nIMsxouAj2sDFl3fwQquvUzF4eSVZJdYvG/TYsmdWHLzB/mBsLRrhft72nlTE/zQ+hTq1hzoqjZDbjOCsPpRKZUsQ7U/1u2ULSy9aU8X62rI5IpVzZ9pkztSoNz68/ib6u4pYBF21SKCRCvW14faIPPVvY+rUlJEni8WFuxOWUE5FU2KznXiyq4kRaMVObsTREkiQeGuxKXE450ek3/33aHJ2BoZ6i1e0efR3MGO9nyw8RqW2WfXXpvSHIuWMyHwx0dZjob8/KRwdw5LXR/GtSb8qVKl7ffIaB/9nDC+tP8ueZbBb9chJ3axM+nOGv9RotgiAIgtBWRFBDEAThCom55Ww4fpG5g1xxtWz84tHPwZzP7w/k0KujeXJkLw4lFjBz6WFmfBtBbEHL6g9omyzLbI7OINi1x1UXwj72Zvz4eAilVXU8uDySvLLmFdrccDydT3fGMz3QgX9N8mn04sfT1pQf54VQVl3H3BVHm1TQ83x2GZ/ujGecry339W/aHfiFozwpU6qaVWCypRbvjud0RikfzeiLvXm3Nj9eZzAt0AErEwNWHGpep5ntp+uXkEwNaF69i2mBDpga6PLjkbRG96lRqdl+KptxvnZaqWeyaIwn5cq2q61xMr0Yd2tjrXWnaQ0bM0MWjOjFrhdHsO3Zodzb34l9cXk881M0yjo1383t3+bLmgRBEARBm0RQQxAE4Qof/RWHsb4uz432bNL+duaGvDqhN0deH8O7U/3Ir6hh8QklS/YndXi3lDOZpSTmVdwwPd/fyZzVjw8gr7yGOSuOUtjEtp27z+Xy+uYzDPe04pN7A25Z/LGPY/1xckqVPLTi2E1rX9So1Ly4IQazbnrNulPs72TOCC9rVh5Kobq27QJKhxIL+P5ACg+GuDChldkBXYmBrg4PDXIlLD6/We1Wt53MIti1xy2zba5lpK/LzP5O/Hkmp9F2svvj8iitrmNGP+0sw/FzMGe8ny2r2iBbQ5ZlotKKb9n9pb1JkkSAc3fen+7PsTfu4ts5/fhxfggeNiYdPTVBEARBaBYR1BAEoUtS1qmpaGKHhKY6klzI3rg8nhnlgUUz76gaG+jyyJCe7H5xJCH2Ony6M57nfjnZphfZt7I5OhN9XQWT/e1vuL2/qwWrHh3AxeIq5p4uRhYAACAASURBVK48dsvWjycuFLHw52j8Hc35bm5/9HWb9l9If1cLVjwSTGphJY/8cKzRZSKLdyUQl1POJ/f6N7vjwsJRHhRU1LL+eNtkaxRW1PDSxhg8bUx4a7JvmxyjM5szyAV9XQWrIi40af+4nDLic8tb3JVk7iBXatUaNp64eMPtm6MzsTY1YJiHVYvGv5FL2RprtVyfJbWgkuKqOvq1cz2N5jDU02GSv70oDCoIgiB0SSKoIQhClyDLMvE55aw4mMJDK48S8O4uQj8NI6NYO0U6NRqZD/48j4O5IY8N7dnicQz1dHiyrwGvTujNjjPZ3Pf94RbXrWiNWpWG309lMdbHFnOjxtPzB7lbsuyhYJLzKnhk1bGrigZeKSG3nMdXH8ehezdWPTqg2enpQz2sWDqnH+eyypi3+sR1wZ4jyYUsP5jCnBAXRve2bdbYAAPdLBjoZsGy8BRqVdptuSvLMq9uOk1JdR1fzQ6im76OVsfvCqxMDJgR5MimqAyKmtBpZltMFjoKiUmNBNRuxcPGhCG9LPkpMv26NqRFlbXsj89jeqCDVtuj+jmYM9jdkm0t7PTSmOj0EoB2LxIqCIIgCHcKEdQQBKHTKq6sbyX5z19PMfjDfYz/Ipz3d5wnu1TJAwOcqVGpmbf6hFYKRG4/ncWZzFJeHu+NoV7rLlolSeLp0F6seDiYCwVVTP0mgqi0olbPsTnC4vMoqqxlZv9bp+eP8LLm2zn9OJtVxuM/HKfymgyYrJJqHll1DEM9HdY+PrDZWRSXjPGx5b/3B3IirYgFP56gRlUf2ChT1vHyr6foaWnMG5N9WjQ21GdrZJcq2Ryd0eIxbmTtkTT2nM/j9Ym98bFvWheP29Hjw9yoUWn4+WjjtS6gPkD4e0wWIzytWvyzAvDQIFcyS6oJi8+76vE/TmdRp5a5J6h1XU9uZLyfLUl5FTdtedpcUWnFmBrq4mEtlnUIgiAIQlsQQQ1BEDqNOrWGY6lFfLYznmnfHKLf+7tZ9MtJdp3Lpb9rDz6e6c/h10az56WRvDutD0vn9Ccpv4Ln18dcdze3OWpUaj7dGY+vvRnTA7XXKnOMjy1bnhmCiYEODyyLZOPxG6fSt4XN0ZlYmegz3NO6Sfvf5WvLV7ODiE4vZv6aEyjr6gMOxZW1PLzqGBVKFWseH9js+gjXujvAgY9m9uVgYgELfz5JnVrDv7edJadMyeezAjDSb3mBwuGeVvR1MmfpgWRUau1ka5zPLuM/f55nlLc1jw7pqZUxuyovW1NGeFmz5kja5YDUjUSlF5NZUs20Vv4u3eVri62ZAWuvKRi6KTqT3nam+DpoP8A01q++Vsqus7laGzM6rZgglx63rD8jCIIgCELLiKCGIAgdRpZlkvLKWXP4Ak+sPUHQe7uZ9f0Rlh5IRldHwQtjvNjyzBCi3xrLkjn9uH+ACw7d/9dxYpinFe9O9WNfXB4f/Hm+xfNYeziNjOJq/jXJR+sXHp62pmx9dighbpa8suk0724/q7UL7saUVNWyNy6XqQGO6DUjPX+Svz2fzwokMrWQBT9GUVpVx+NrjpNeVMXyR4K1lqUwK9iZd6f6sftcLvd+d4TNJzNZOMqDoFau55ckiWdHeZBWWMUfp7NbPU9lnZpFv5zEzFCPT+8LEC0ugXnD3Mgvr+GPU43/+26LycRQT8FY3+YvI7qSno6C2QNdOJCQT1phJQDJ+RWculjCzBsUv9UGx+7d8Hc0Z9e5HK2MV6asIyGvvNMVCRUEQRCE24no2SUIQrvKLq0mIqmQw0kFRCQXkFtW393AqUc37g5wYKSXFYN7WWHerWltGucOciU5v4KVh1JxtzZmTohrs+ZTUlXL1/sSGellzTBP7RUdvFJ3I31WPzaAD/6MY1VEKom5FXzzYBDdjdqmveP209nUqeUWdYaYHuRIjUrNq5vOMPyTfVTUqPh2Tj8GuVtqdY6PDOlJZa2KT/6OJ8DJnIWjPbQy7lgfW7xsTViyP4mpAQ6tClK9v+MciXkVrH18IFatWEZxOxnhaYWnjQkrD6Uyo5/jdYGeOrWGHaezGetrp5W2oLMHuvDNviR+OprOvyb5sCU6E4VEiwuQNsV4P1s+25VAbpkSWzPDVo0Vk16CLIt6GoIgCILQlkRQQxCENlVaVceRlAIikgqJSC4gJb/+jquFsT6De1kytJcVwzyscLFs+bKGNyf7klpQydvbztLT0pihzeiIsGR/EuU1Kl6b2LvFx28KXR0Fb9/tS287U97YeobpSyJY8UgwHjamWj/WpqgMetuZ4tfC9Pz7B7hQo9Lw3vZz/N/0Pkzo07Jij7fyTKgHve1M8Xfs3qyMkptRKOqzNZ5fH8Ouc7ktbr2682wO6yLTWTDCnRFeTVvCcyeQJIl5w9x4bfMZjqQUMqTX1b9rhxILKK6qY7qWgg62ZoaM97Nj44mLvHiXF1tOZjLM0xqbVgYbbmacnx2f7Upg17lcHhrUvCDptaLTi5EkCHA219LsBEEQBEG4lghqCIKgdVFpxew5n0tEUgGxmaVoZDDS12GgmwWzB7gw1MOK3namWlvqoaOQ+Hp2EDOXHubpdVFseXYovZpQlO9iURVrDqdxbz+ndisAOWuAM71sjHnyx2imLznMlw8EMsandWn6V0rOryDmYgn/mtS7VcslHh7ck1nBzq0umnorLel0citT+jrw390JLNmfxHg/22b9O1TXqtlwPJ3PdyfQx9GMl8d5a31+Xd30IEc+2RnPqkOp1wU1tsZk0t1Ir8m1XJpi7iBXdpzJ5q1tsWSWVPPKhLY9J542JrhZGbPrbE6rgxpRacV425piati0zDNBEARBEJpP1NQQBEErZFnmQEI+s747wsylh1kenoKBroLnRnuy8cnBxLw9jtWPDeSJEe74OphpvXaFqaEeKx8ZgJ6Ognmrj1PchLaTn+6MR6GAl8Z5aXUut9Lf1YLfFw6lp5UR89eeYGlYMrLc8kKnV/pfen7rC562dUCjrego6rvPnMksJTyxoEnPKa2q4+u9iQz9eB//3n4OL1tTvn2wP/q64r/Jaxnq6TB3kCt7zueRckWXkKpaFbvO5jLJ316r/26D3C3wsDHht6gMjPV1GOfbsuybppIkiXG+thxJLqS0uuWdlTQamZj0ErH0RBAEQRDamPhrTRC6sPzyGvLKlB06B41GZufZHKYtieCRVce4WFzFO3f7EvPOOH59aggvjvVioJtFu1wcOlsYsezh/mSVKnlqXRS1qsYLcp7OKOH3U1nMG+aGvXm3RvdrKw7du/Hrk0OY0teBj/+OY+mB5FaPqdHIl9PzW1sLoKu7J8gJB3NDvtmXeNP9csuU/GfHOYZ8tJfFuxMIdO7Or08N5renh7RqSdTt7qFBrujrKPgh4sLlx3afy6W6Ts20AO3Wu5Ak6XLGxCR/e7rpt32wbZyfHSqNfF072eZIzKugvEZFP1EkVBAEQRDalFh+IghtZMn+JLqVqglto/HVGpkHl0dSp9aw56WR6GqpJkFTqdQadpzJZsn+JBJyK3CxMOKjGf7c088RA92Ou8Pf39WCT2b25YUNMby59Qwfz+x73fIDWZb54M/zWBrr89TIXh00U+imr8NXDwSi0ch8viuBEZ7W9HFs+dr7yNTCdknP7wr0dRUsGOHOv7ef42hKISHXFDpNya9gWXgKm6MzUcsyd/e158mRvdptGVJXZ21qwNRAB36LyuAf47zobqTPtpgsHMwNGdDTQuvHm9HPkYikAuYNd9P62DcS5Nwda1OD+oBtC7OeotKKAVEkVBAEQRDamghqCEIbyC+v4dOd8TiYSDwyVUZHy0stALaezCQxrz71e8vJTO4Ldtb6MW6kVqVhc3QGSw8kk1ZYhaeNCV/cH8iUvvbtHlhpzPQgR1LyK/hqXxIeNiYsGHF14GJfXB6RKUW8N82vw9e6S5LEf+7pQ1RaMc+vP8kfzw1v8Z3ozdGZmBjotnl6flfxwEAXvtmfxDf7ky4HNc5klLL0QBJ/xeagr6Pg/gHOLBjhjrOFyMpornnD3PgtKoOfj6XzwAAXwhPymTfcTetLy6B+edmyh4O1Pm5jFAqJsb62bD2ZibJO3aKlWFFpxVga6+MqMn4EQRAEoU2JoIYgtIGYiyUAZFXIbIrOYJaWAw61Kg1f7K0vZAjw9b4kpgc5aq2DxI0o69SsP5bOsvAUskqV+Dua893c/ozztW2Ti5jWeuEuL5ILKvnwrzjcrEwY61tfkFKl1jQ8ZszsgS4dPMt63Y30WTwrgDkrjvLhX+d5b1qfZo9RVavirzPZTO7bPun5XYGhng7zh7vz0V9xrD1ygV1nczmUVICpoS7PhPbi0SFuWJuKVq0t5WNvxlAPS9YcvkA3PR1UGplpAa2v5dJZjPO15eej6UQkFbSomO/J9GKCXHq0qmCvIAiCIAi31jluqwrCbSbmYjE6CglXMwVf7E5AWafW6vgbTlzkYlE1/xjnzQtjvEgvqmLLyUytHuMSZZ2apWHJDGsooOjYoxurHxvA7wuHMqGPXacMaED9ndbF9wXQ19Gc59ef5GxWKQC/RmWQlFfBqxO82zQI1FxDPayYP8yNtUfS2B/X/HX8u87mUlmrZmY/pzaYXdc1d5Ar5t30eHvbWeJzy3ltYm8Ovzaaf47vLQIaWjB/mDu5ZTV8tjMeL1sTfOy136K4owzpZYWpgS67zuY2+7lFlbWkFFSKpSeCIAiC0A46z1/0gnAbiblYgo+9Kfd765NVquTHI2laG1tZp+brvYkM6NmDUC9rxvjY4O9oztf7EqlTN14Ys6Xe3hbLx3/H4WNvxoYFg/j1qSGEett0ibuPhno6LH84GPNuesxfc4ILBZV8vjuBYNcejPfrfEs0Xh7vTW87U/7522kKK2qa9dxN0Rk49ejWJvUMujITA12+eTCIT+7ty8FXRvHUyF4dvuTodjLSyxp3a2Mqa9VMC3TsEu8LTaWvqyC0tw17zuei1jSvO1G0qKchCIIgCO1GBDUEQcvUGplTF0sJdO6Or6UOwz2tWBKWRJmy5a0Br7T2yAXyymt4eZw3kiQhSRIv3OXJxaJqtkRrN1sjKq2YjScyeHKEOz/OC7mu2GJXYGNmyIpHgimtrmPyVwfJL6/h9Uk+nfLiy1BPhy8eCKSsuo7XNp9pcpvXnFIlh5IKmBHk2GkzZzrScE9rZgU7d9kWtZ2ZQiHx9MheGOgqmKrlriedwXg/Wworay8X/Wyq6PRidBUSfZ1aXvhXEARBEISmaVJQQ5KkCZIkxUuSlCRJ0ms32O4qSdJeSZJOS5IUJkmS0xXbHpEkKbHh45ErHu8vSdKZhjG/kjrjFYYgtEByfgUVNSoCnevv0L06oTclVXV8r4WWneXKOpaGJTPCy/qqAMPo3jb0dTLn6/3ay9ZQa2Te+T0WOzNDFo3x1MqYHcXPwZwvHwiiqk7NxD52nfruaW87M16Z4M3uc7lsOH6xSc/ZGpOJLMM9YumJ0AHuC3bmxJt33ZbFVkd6WaOvo2Dn2ZxmPS8qrRg/BzMRSBMEQRCEdnDLoIYkSTrAEmAi4AvMliTJ95rdPgPWyrLcF3gP+LDhuRbAO0AIMBB4R5KkS1cTS4EnAM+GjwmtfjWC0AnEpNcXCQ107g5AH0dz7g5wYOWhVPLKlK0ae+WhVIqr6nh5nNdVj1+ZrbE5OqNVx7jkl2PpxGaW8cZkH4wNun5N4bG+tux4bjiLZwV09FRu6fGhbgzpZcm728+RWlB5031lWWZTVAb9XXvgZmXcTjMUhKvdrkt6TA31GOphya5zOU3OnKpTaziVUUK/Thw8FQRBEITbSVMyNQYCSbIsp8iyXAusB6Zds48vsK/h6/1XbB8P7JZluUiW5WJgNzBBkiR7wEyW5Ui5/q+EtcD0Vr4W4Q6laeZa57Z28mIJZoa6uF9xgfmPsV6o1DJf7k1s8bjFlbWsOJjKBD87+jp1v277KG8bApzM+XpfErWq1mVrFFXW8unOeAa7WzKlr32rxupMfB3MMNLv/AEahUJi8awA9HQkXtwQg+om2TexmWUk5lUwo9/t03VCEDqTcX52XCyq5nx2eZP2j8suR1mnoZ+LCGoIgiAIQntoyl/3jsCVOdAZ1GdeXOkUMAP4ErgHMJUkybKR5zo2fGTc4PHrSJK0AFgAYGtrS1hYWBOm3PlUVFR02bl3ZiVKDZ+cUGKkKzHf3wA7444vE3PofDUuxhLh4QeuOu8jnHT45Vg6/vr5LZrnhvhaKmtUDO9e2ujP0mhbFf+NquHDX/Yy0rnld05/iK2hQqliin0VBw4caPE4dypt/b7P9dbh21MlvPzDHqZ76N9wn5/O16ArQfeyFMLCUlt9TKHlxPv87cmoRkYClv0ZecPfw2vP++60+vpJtVlxhBUntNMshY4gfufvTOK835nEee/ctHXL8mXgG0mSHgXCgUxAKz0sZVleBiwDCA4OlkNDQ7UxbLsLCwujq869s8ovr+GBZUcorVVQoZJ4N7KWf032YW6IS4cVgaysUZG5cyf3jPIgNNT7qvPu21/JyE/COFjanSWT+zVr3NwyJfv37ueeIEfm3B3Y6H4jZZl9eYfZlVnD67NHoK/b/ODJqYslhO+MYN5QN+ZMuXalmdAU2vp9DwVyFDFsO5XFw+MGXHfnt06t4aWDexnXx47JY/u3+nhC64j3+dvXjymHia9UExo6/Lpt1573Tb+cxN68iJkTR7fjDIWOIH7n70zivN+ZxHnv3JpyxZMJOF/xvVPDY5fJspwly/IMWZaDgDcaHiu5yXMzG75udExBuJmCihoeXB5JdqmS1Y8PZNeLIwnu2YO3tsby6A/HyW1l7YqWOpNZikaGQJfrl4fYmBoyf7gbO05ncyajtFnjfrMvCZVa5oW7vG6636XaGpkl1WxqQW0NjUbm7W2xWJkY8PxdXbs46O3i39P8sDMz5MUNMVTWqK7aFhafT1FlLTNFgVBBaFPj/ew4n13GxaKqW+4bnVYslp4IgiAIQjtqSlDjOOApSZKbJEn6wAPA71fuIEmSlSRJl8Z6HVj1/+zdeZyU5bnn/+/Ve0Mv7N1AN4KySIMCilsWgyiEmKiJJ8fAxCxnzHEyJyY5HicZT04mi0l+M5ksnpOM5oxJzHoiMWaMxhjRqCRmUQFpdlFE7Kpmpzea3ruv3x9VTdq2oYvuqnpq+bxfr35R9dTzPHUVN7T01/u+7ujjdZJWmtn4aIPQlZLWufsBSS1mdml015MPSnooDp8HWaDhRJdu/N5zCjW26d4PX6SLZk5QZXmRfvyfL9Yd1y3Qc68e09v/9Q96ZOv+pNdWG+pvEjr0P2hvvvxsjR+Tr68+9mLM9ww1tGnthjq976JqzZg4/O4Cy+ZO1uLqcfo/I+it8fONIW0JN+tfrp6fsY3/0k1ZUb6+ecMi1TW06UuP7Hzda//vhbAmji3Q5XMnB1QdkB1WLqiQpGF3QTnY3KH6pnaahAIAkETDhhru3iPpFkUCil2S7nf3HWZ2h5ldGz1tmaTdZvaSpApJX4le2yDpS4oEIxsk3RE9Jkn/IOl7kvZIekXSb+P1oZC5mtoigcarR0/o+x+6SJcO2NbUzPTBy2bqN594q86aOFa3/GyzPnHfZjW3dSetvtq6Jp01cYwmjB26/0FpUb5uWT5Hf9xzVH98+WhM9/zX372sHDN9fHlsMycGztZ4YFPsszWa2rr0vx97URfPmqDrFk+L+Tok3iVnT9RH33aO1m4InfyhqqmtS0/uOqxrF09Tfm7wvWSATHbWxLE6t7JUj+84dNrzXqhrlKSU3jYaAIBME9O/hN39UXef6+7nuHt/YPE5d384+vgBd58TPecj7t454Np73X129OsHA45vdPeF0Xve4rHulYas1dzWrRu//5z2HGnVdz+4VG+ePWnI886ZXKJffvQy3XrVXP1m2wG9/V//EHOAMFqbQ40nt3I9lRsvnaHp44r11cdeHHbnlj2Hj+vBzWF98LKzVFleFHMdb4vO1rjr6dhna3xt3W61dPTojusWBNaTBKd261VztWBamW7/5VYdbunQI1sPqKu3j6UnQJKsrKnQxtcadLS185TnvPBaowrzclQztSyJlQEAkN3433tICy0d3frgvc/ppYOt+r83XjjsdPu83Bx98qo5evAf3qSxhbm68fvP6QsP71B7V1z61w7pQHO7DrV0DhtqFObl6p9WzNW2+mY9uv3Aac/95hMvqTg/V/912ewzqsXMdOuKuapvatcvNoWGPX97fbN+9nydPnjZWTq3kn+Mp6KCvBz92+rFauvq1ace2KpfvhDWvIpSLZjGeAHJsHJBpfpcenLXqWdrbKpr1PlV5SNq0gwAAEaG/+oi5R3v6NaH7n1eOw+06O73X6Arzp0S87XnV43Tbz7xVn34TTP1wz/v0zu//Yy2RPtexFttXeS+S2JoEPfuJdM1r6JUX1+3W929Q8+k2F7frEe3HdRNbz37lMtZTufyOZO0ZMY43fXUHnX2nDrM6etz/Y+Htmvi2ALduuL0jUgRrNlTSvUv75yv3790RJvrmnT9BdOZVQMkyYJpZZo+rviUS1A6unu1vb6ZfhoAACQZoQZS2onOHv3dDzZoW7hZ315zga6qqTjjexTl5+oL1y7QT2+6RO1dvbr+O3/WnU+8NOzSjzNVG2pSQW6O5k8tHfbc3BzTp1fN075jbfr5hqFnUnz98d0qL87XR946a0T1mJluvWqu9jd36BcbT91b44EXwtpc16Tb3zFfZTQHTXkfuPQsvW3uZOXmmN69ZHrQ5QBZw8y0ckGFntlzVK2DdiKSpB37m9Xd6+x8AgBAkhFqIGW1dfXo7364QZtDTfrWmiVatbByVPd7y5xJeuwfL9e7zp+qf3vyZT2+8/Rd7M/U5rom1UwrU2FebkznLz93ii6aOV7/9uTLaut6/T+QN+xr0PrdR/Rfl50zqqDhrXMm6YIZkd4aQ83WaG7r1ld/+6IuPGu8rucH5LRgZrr7/RfooY+9WRVlsfdZATB6K2sq1dXTpz+8dOQNr216LdIklFADAIDkItRASmrv6tVNP9yojfsadOf7Fuvq86bG5b7lxfn6xt8u0rgx+Vo3TBf7M9HT26dt9c3D9tMYyMx0+zvO1ZHjnfrBn/adPO7u+tpjuzW5tFAfumzmqOqK7IQyVweaO3T/ELM1vvnEbjW2demO6xYoJ4dlDOlibGGeFk4vD7oMIOtcNHO8xo/JH3Jr102vNeqsiWM0ubQwgMoAAMhehBpIOR3dvbr5Jxv17KvH9I0bFunaRfHdXjQvN0fLz52ip148rJ5T9LM4U7sPHVd7d6+WzIg91JCkC8+aoKvmV+jf17+ixhNdkqQ/vHxUz+9r0MeXz1ZxQWyzPk7nrXMm6cKzxuvuQbM1duxv1k+efU03XnqWFkzjB2QAGE5ebo6unF+hp148/LqdpdxdL9Q1MUsDAIAAEGogpXT29Oq//GST/rjnqL723kV6z5LEbFe5Yn6Fmtu7tWFfY1zuVxttPrqk+sz/QfvpVfN0oqtHd6/fI3fX19ft1vRxxVp90Yy41BaZrTEnMlsj2r/D3fX5h3Zo/JgC3bZiXlzeBwCywdsXVOp4R4+e3Xvs5LFwY7uOHO+kSSgAAAEg1EBK+dGf9+n3Lx3R/7r+PL33wsQEGpJ0+dzJKsjN0e9OszXfmdhc16QJYwtUPaH4jK+dW1Gq6y+o0o/+8pp+8Kd92lbfrH+8ak5ctwR8y+xJWnrWeN319Cvq7OnVg5vrtfG1Rv33VeeqfAzNQQEgVm+dM0nF+bmv68vU30/jQmZqAACQdIQaSCkb9jXq7Mlj9b44zVI4lbGFeXrT7Il6YuchuY9+F5TaUJMWV48b8faa/Vup3vHITp09eazeE+emnf29NQ62dOh7z7yq/+/RF7W4elxCgyMAyERF+bl629zJenzHoZO7aL1Q16ixBbmaVzn87lcAACC+CDWQUraEmrSo6sz6UozUipoK1TW06aVDraO6T0tHt1450qolZ9AkdLDp44r1wUvPkiTdtmKe8nLj/1fzzbMn6qKZ4/W1dbt17ESnvnTdQpqDAsAIvH1hhQ4f79SWcGTp4abXGrV4xjjl8j0VAICkI9RAyjjY3KHDxzu1qCo5TSuvml8hSaNegrI11Cx3afEZNgkd7LaV8/TvN16oq88b3da1p9I/W0OS1lw8Q+cl6fcZADLN8nkVyssxrdtxSB09rl0HWlh6AgBAQAg1kDL6m22eP4oZD2eioqxIi6rK9fjO0YUam+sia6nPH+UMk+KCXK1aWDniJSyxePPsSXrwH96kz19Tk7D3AIBMVz4mX5eePVGP7zyoV5v71OfSEpqEAgAQCEINpIyt4Sbl5ZhqppYl7T1X1FRoS6hJh1s6RnyP2lCTzpk8VuXF6dFwc8mM8SrMG/1WsQCQzVYuqNDeIyf0h3C3JOmCEex+BQAARo9QAylja7hZ504tVVF+8n7gvqqmfwnK4RFd7+6qDTVpCdOOASCrrIj+9+MvB3o1Z0oJO0kBABAQQg2khL4+15Zw8pqE9ptXUarqCcUj7qsRbmzXsRNdWpykJTMAgNQwtbz4ZA+oCwi2AQAIDKEGUsK+Yyd0vKMn6aGGmemq+RX6456jOtHZc8bXvxDtp0GoAQDZZ+WCSGPnC+mnAQBAYAg1kBL6t8VbFEA4sKKmQl09fXrm5aNnfG1tqElF+Tk6t7I0AZUBAFLZ31xQpSVTcrV8/pSgSwEAIGsRaiAlbAk1a0xBrmZPKUn6e180c4LKi/P1xAh2QakNNen86eOUl8tfJQDINpXlRfrkBUWaVFIYdCkAAGQtfhJDStgSbtLCaeXKzUncdqankp+boyvmTdZTLx5ST29fzNd19vRqx/4WLZ7B0hMAAAAACAKhBgLX3dunHftbtKi6PLAaVtRUqrGtWy/UNcV8za4Dx9XV00c/DQAAAAAIbmDwDwAAIABJREFUCKEGArf7YCQcOD/JTUIHunzuJOXnmp7YeTDma2ppEgoAAAAAgSLUQOD6m4QGGQ6UFuXrsnMm6Ymdh+TuMV1TG2pSRVmhppYXJbg6AAAAAMBQCDUQuC2hJo0fk6+q8cWB1rFi/hTtO9amV460xnR+bahJi6vHySz5fUAAAAAAAIQaSAFbw81alALhwFU1FZKkJ3YeHvbchhNd2nesTYurxye6LAAAAADAKRBqIFBtXT166dDxQPtp9JtaXqzzppfH1FdjSyj4JTMAAAAAkO0INRCo7fUt6nNpcYA7nwx01fwKbQ416cjxztOetznUpByTzq9KjboBAAAAIBsRaiBQW6NNQlNhpoYkraipkLv01IuHTntebahJcytKNbYwL0mVAQAAAAAGI9RAoGpDTZo+rliTSgqDLkWSNH9qqaaPK9YTO08davT1uWrrGrVkRmoEMQAAAACQrQg1EKhIk9DUWcJhZlpRU6FnXj6q9q7eIc959dgJtXT00E8DAAAAAAJGqIHANJzoUl1DW8osPel31fwKdfb06ZmXjwz5em1df5NQdj4BAAAAgCARaiAw/f00FqVYqHHJ2RNUWpSn3+0aeglKbahJJYV5mj2lJMmVAQAAAAAGItRAYLaEmmUmnZdiO4jk5+boinlT9OSuw+rt8ze8vjnUqPOrypWbYwFUBwAAAADoR6iBwGwNN2n25BKVpOAOIlfVVOjYiS7Vhhpfd7yju1cvHjhOPw0AAAAASAGEGgiEu2tLuCnl+mn0WzZvsvJyTI8P2gVle32zevqcUAMAAAAAUgChBgKxv7lDR1u7tDiFdj4ZqKwoX5eePfENW7vWhqJNQtnOFQAAAAACR6iBmPT1uZ7YeUgb9zXE5X5bo+FAqs7UkKQVNRXae+SEXjnSevLY5romTR9XrCmlRQFWBgAAAACQYgw1zGyVme02sz1mdvsQr88ws6fNbLOZbTWzq6PH329mtQO++sxscfS19dF79r82Jb4fDfHQ3dunX24Ka8Wdv9ff/3ijPvrTTerq6Rv1fWvDTSrIzdG5U0vjUGViXDk/8kfydwNma9SGmpilAQAAAAApYthQw8xyJd0l6R2SaiStMbOaQad9VtL97r5E0mpJd0uSu/+Huy9298WSPiDpVXevHXDd+/tfd/fDcfg8iJOO7l799NnXdMXX1+u2X2xRfm6Obr78bB1t7TrlVqdnYmuoWfOnlqowLzcO1SZG1fgxqpladvLzHj7eofqmdi2hnwYAAAAApIRYtp24WNIed98rSWa2VtJ1knYOOMcllUUfl0vaP8R91khaO/JSkQxtXT362XN1uucPe3X4eKcWV4/TF65ZoCvnT1GfS7/ZekD3PV+nq8+bOuL36Otzbatv1nuWTI9j5YlxVU2F/s9TL+tYa6dq6yJLZpYwUwMAAAAAUkIsocZ0SaEBz8OSLhl0zhckPW5mH5c0VtJVQ9znfYqEIQP9wMx6Jf1S0pfd3WMpGvHX3N6tH/15n37wp1fV2NatN50zUXe+b7HedM5EmZkkKdekG5ZW687fvaS6Y22aMXHMiN5r79FWtXb2aFEazHhYWVOhbz35sp568bD2Hj2hvBzTgmmp2dwUAAAAALKNDZcjmNl7Ja1y949En39A0iXufsuAc/4peq9vmNllkr4vaaG790Vfv0TS99z9vAHXTHf3ejMrVSTU+Km7/3iI979Z0s2SVFFRceHatek52aO1tVUlJSVBl/EGLZ2udfu69WRdtzp6pUWTc3XNOfmaPW7oZSENHX26bX273nl2vt47t2BE7/nH+m59b1uXvvKWYk0vSe1ete6u237frpllOWrvcbX3SF94U3HM16fquCOxGPfsxLhnJ8Y9ezH22Ylxz06Me/CuuOKKTe6+dKjXYpmpUS+pesDzquixgW6StEqS3P0vZlYkaZKk/j4ZqyXdN/ACd6+P/nrczH6myDKXN4Qa7n6PpHskaenSpb5s2bIYSk4969evVyrVfqKzR19bt1trN9Sps6dPV583VR9bNls108qGvfbRQxv0XLhZd950ufJzzzyUeOqh7SoprNfqq69Qbo6NpPykemfzdj2wKawcM11/QZWWLVsY87WpNu5IDsY9OzHu2Ylxz16MfXZi3LMT457aYvmJdIOkOWY2y8wKFAkoHh50Tp2kKyXJzOZLKpJ0JPo8R9INGtBPw8zyzGxS9HG+pHdJ2j66j4Iz8eXf7NKP/7JP15w/TU/+09t013+6IKZAQ5JWXzRDR4536sldI+vtuiXUpIXTy9Ii0JAiW7u2d/fqRFcv/TQAAAAAIIUMG2q4e4+kWyStk7RLkV1OdpjZHWZ2bfS02yT9vZltUWRGxocH9Me4XFKov9FoVKGkdWa2VVKtIjM/vhuXT4RhbdzXoPuer9NNb5mlr/3tIp09+cymUi2bN1mVZUW67/m6M37vrp4+7TpwPC36afS75OwJKimMTGpanEZ1AwAAAECmi2X5idz9UUmPDjr2uQGPd0p68ymuXS/p0kHHTki68AxrRRx09fTpMw9u0/Rxxbp1xdwR3SMvN0c3XFStbz/1skINbaqeEHvD0BcPtqirt0+LqtInHCjMy9Xyc6foz68c1axJY4MuBwAAAAAQldpdGhF3331mr1461Ko7rlugMQUxZVpDet9FkTYrv9gYGubM19sSimyLmk4zNSTpi9cu0P3/5bKTO8EAAAAAAIJHqJFFXjt2Qt968mVdfV6lrpxfMap7TR9XrGVzJ+vnG0Pq6e2L+bot4WZNKinQtPKiUb1/so0fW3DGy3QAAAAAAIlFqJEl3F2f/dV25efm6PPXLIjLPVdfPEOHWjr19O4jMV+zJdSkRVXjmPEAAAAAABg1Qo0s8fCW/Xrm5aP69Kp5qiiLzyyJ5edO0ZTSwpgbhrZ29mjPkVadn0b9NAAAAAAAqYtQIws0tXXpS4/s1KLqcXr/JWfF7b75uTm6YWm11u8+rP1N7cOevy3cLHfp/OryuNUAAAAAAMhehBpZ4KuPvajGtm79z/ecp9yc+C77eN9F1XJJ98fQMHRrONoklJkaAAAAAIA4INTIcM+/2qD7ng/pI2+ZpZppZXG/f/WEMXrL7En6+YaQevv8tOduCTepekKxJowtiHsdAAAAAIDsQ6iRwbp6+vSZB7dp+rhiffKqOQl7n/908QwdaO7Q7186fNrztoSamaUBAAAAAIgbQo0Mds8fXtGew6368rsXakxBXsLe56qaCk0qKdR9z596CcrR1k7VN7UTagAAAAAA4oZQI0PtO3pC33pqj9553lRdce6UhL5Xfm6O/nZplZ568bAONncMec7JfhrVhBoAAAAAgPgg1MhA7q7P/mq7CnNz9LlrapLynqsvqlZvn+sXp2gYuiXUrByTFk6Pf18PAAAAAEB2ItTIQL+qrdcf9xzVp1fNU0VZUVLe86yJY/Xm2RO1dkNIfUM0DN0SbtLcitKELoMBAAAAAGQXQo0M03iiS196ZJcWV4/T+y85K6nvvebiGapvatcze46+7ri7a2u4WedXlSe1HgAAAABAZiPUyDD/67cvqrm9W//z+vOUk2NJfe+VNZWaOLZA9z1X97rj4cZ2NZzo0vk0CQUAAAAAxBGhRgZ5bu8x/XxjSB956yzNn5r83hUFeTl674VV+t2uQzrc8teGoVuiTUIX0yQUAAAAABBHhBoZorOnV595cJuqxhfrk1fOCayO911UrZ4+1y82hU8e2xJqUkFejuZVlgZWFwAAAAAg8xBqZIh7fr9Xrxw5oS+9e2GgzTjPnlyiS8+eoLUb6k42DN0SbtaCaWXKz+WPGwAAAAAgfvgpMwP09bm+8/tXtGpBpa6YNyXocrTm4hkKNbTrz68cU2+fa3t9sxbRTwMAAAAAEGfsr5kBDh/vVFtXr94yZ1LQpUiS3r6gUuPH5Ou+5+s0ubRQbV29WlTNzicAAAAAgPhipkYGCDe2SZKqxhcHXElEUX6urr+gSut2HNSTLx6SJHY+AQAAAADEHaFGBghFQ43qCWMCruSv1lwcaRh611N7VFqUp1kTxwZdEgAAAAAgwxBqZIBQQ7skafq41JipIUmzp5Tq4pkTdKKrV+dXlSsnx4IuCQAAAACQYQg1MkC4sU1TSgtVlJ8bdCmvs+aSakmiSSgAAAAAICFoFJoBQg3tKbX0pN87Fk7VMy8f1XWLpwddCgAAAAAgAxFqZIBwU5sumDE+6DLeoCg/V9+8YXHQZQAAAAAAMhTLT9JcT2+f9jd1qHp86s3UAAAAAAAgkQg10tyB5g719rmqJ6ROk1AAAAAAAJKBUCPNhRsjO59UMVMDAAAAAJBlCDXSXKixTZJYfgIAAAAAyDqEGmku3NCmHJOmjisKuhQAAAAAAJKKUCPNhRvbNbW8WPm5DCUAAAAAILvwk3CaCzW2qWo8TUIBAAAAANmHUCPNhRvbaRIKAAAAAMhKhBpprLOnVwdbOtjOFQAAAACQlQg10tj+pg65s50rAAAAACA7EWqksfDJ7VyZqQEAAAAAyD4xhRpmtsrMdpvZHjO7fYjXZ5jZ02a22cy2mtnV0eMzzazdzGqjX/8+4JoLzWxb9J7fMjOL38fKDqGGdklS9QRmagAAAAAAss+woYaZ5Uq6S9I7JNVIWmNmNYNO+6yk+919iaTVku4e8Nor7r44+vXRAce/I+nvJc2Jfq0a+cfITuHGNuXnmirKioIuBQAAAACApItlpsbFkva4+15375K0VtJ1g85xSWXRx+WS9p/uhmY2VVKZuz/r7i7px5LefUaVQ6HGdk0bV6zcHCa5AAAAAACyTyyhxnRJoQHPw9FjA31B0o1mFpb0qKSPD3htVnRZyu/N7K0D7hke5p4YRqihTdU0CQUAAAAAZKm8ON1njaQfuvs3zOwyST8xs4WSDkia4e7HzOxCSb8yswVncmMzu1nSzZJUUVGh9evXx6nk5GptbY177XsPtWnxlNy0/T3JBokYd6Q+xj07Me7ZiXHPXox9dmLcsxPjntpiCTXqJVUPeF4VPTbQTYr2xHD3v5hZkaRJ7n5YUmf0+CYze0XS3Oj1VcPcU9Hr7pF0jyQtXbrUly1bFkPJqWf9+vWKZ+3tXb1qeewxXbLgHC1bNjtu90V8xXvckR4Y9+zEuGcnxj17MfbZiXHPTox7aotl+ckGSXPMbJaZFSjSCPThQefUSbpSksxsvqQiSUfMbHK00ajM7GxFGoLudfcDklrM7NLoricflPRQXD5RlujfzrWK7VwBAAAAAFlq2Jka7t5jZrdIWicpV9K97r7DzO6QtNHdH5Z0m6TvmtmtijQN/bC7u5ldLukOM+uW1Cfpo+7eEL31P0j6oaRiSb+NfiFG4cbIdq5V9NQAAAAAAGSpmHpquPujijQAHXjscwMe75T05iGu+6WkX57inhslLTyTYvFXoehMjeoJzNQAAAAAAGSnWJafIAWFG9tVmJejySWFQZcCAAAAAEAgCDXSVKihTVXjixVpSQIAAAAAQPYh1EhTocY2+mkAAAAAALIaoUaaCje2008DAAAAAJDVCDXS0PGObjW1dauamRoAAAAAgCxGqJGG2M4VAAAAAABCjbQUamA7VwAAAAAACDXSUIiZGgAAAAAAEGqko3Bjm8YW5Gr8mPygSwEAAAAAIDCEGmko1NCu6gljZGZBlwIAAAAAQGAINdJQuLFNVePppwEAAAAAyG6EGmnG3RVubKefBgAAAAAg6xFqpJmmtm61dvaoegKhBgAAAAAguxFqpJnwyZ1PWH4CAAAAAMhuhBppJtTYJkmqZvkJAAAAACDLEWqkmVBDJNSomsBMDQAAAABAdiPUSDPhxnaVF+errCg/6FIAAAAAAAgUoUaaCTW2qZpZGgAAAAAAEGqkm1BDm6rG0U8DAAAAAABCjTTi7go3tjNTAwAAAAAAEWqklSOtners6VMVO58AAAAAAECokU7Cje2SxEwNAAAAAABEqJFW+rdzrWamBgAAAAAAhBrppH+mxvTxzNQAAAAAAIBQI42EG9s0qaRAYwrygi4FAAAAAIDAEWqkkVBDO01CAQAAAACIItRII+HGNlWx9AQAAAAAAEmEGmmjt89V39Su6gnM1AAAAAAAQCLUSBuHWjrU3evM1AAAAAAAIIpQI03073zCdq4AAAAAAEQQaqSJUEObJLH8BAAAAACAKEKNNBFqbJOZNG1cUdClAAAAAACQEgg10kS4sV0VpUUqzMsNuhQAAAAAAFICoUaaCDWwnSsAAAAAAAMRaqSJcCPbuQIAAAAAMBChRhro7u3TgeZ2VTNTAwAAAACAk2IKNcxslZntNrM9Znb7EK/PMLOnzWyzmW01s6ujx1eY2SYz2xb9dfmAa9ZH71kb/ZoSv4+VWQ40dajPpSq2cwUAAAAA4KS84U4ws1xJd0laISksaYOZPezuOwec9llJ97v7d8ysRtKjkmZKOirpGnffb2YLJa2TNH3Ade93943x+SiZK9wY2c61agIzNQAAAAAA6BfLTI2LJe1x973u3iVpraTrBp3jksqij8sl7Zckd9/s7vujx3dIKjazwtGXnV1C0VCjmpkaAAAAAACcFEuoMV1SaMDzsF4/20KSviDpRjMLKzJL4+ND3OdvJL3g7p0Djv0guvTkf5iZxV52dgk3tis3xzS1vCjoUgAAAAAASBnm7qc/wey9kla5+0eizz8g6RJ3v2XAOf8Uvdc3zOwySd+XtNDd+6KvL5D0sKSV7v5K9Nh0d683s1JJv5T0U3f/8RDvf7OkmyWpoqLiwrVr1476QwehtbVVJSUlI7r2/27p0MtNffr625ipkW5GM+5IX4x7dmLcsxPjnr0Y++zEuGcnxj14V1xxxSZ3XzrUa8P21JBUL6l6wPOq6LGBbpK0SpLc/S9mViRpkqTDZlYl6UFJH+wPNKLn1Ud/PW5mP1NkmcsbQg13v0fSPZK0dOlSX7ZsWQwlp57169drpLV/e9efNXuqadmyy+JbFBJuNOOO9MW4ZyfGPTsx7tmLsc9OjHt2YtxTWyzLTzZImmNms8ysQNJqRWZdDFQn6UpJMrP5kookHTGzcZJ+I+l2d/9T/8lmlmdmk6KP8yW9S9L20X6YTBVubKOfBgAAAAAAgwwbarh7j6RbFNm5ZJciu5zsMLM7zOza6Gm3Sfp7M9si6T5JH/bIupZbJM2W9LlBW7cWSlpnZlsl1Soy8+O78f5wmaCju1eHWjpVPYFQAwAAAACAgWJZfiJ3f1SRBqADj31uwOOdkt48xHVflvTlU9z2wtjLzF71Te2SpKrxbOcKAAAAAMBAsSw/QYDCjZFQg5kaAAAAAAC8HqFGigs1tElipgYAAAAAAIMRaqS4cGO7CnJzVFFaFHQpAAAAAACkFEKNFBdqbNP08cXKybGgSwEAAAAAIKUQaqS4cEMbS08AAAAAABgCoUaKCze2q2o8TUIBAAAAABiMUCOFnejs0bETXczUAAAAAABgCIQaKay+ie1cAQAAAAA4FUKNFNa/nWs1MzUAAAAAAHgDQo0U1h9q0FMDAAAAAIA3ItRIYeHGdhXn52pSSUHQpQAAAAAAkHIINVJYqDGynauZBV0KAAAAAAAph1AjhYUa2tn5BAAAAACAUyDUSGHhxjZ2PgEAAAAA4BQINVJUc3u3Wjp6mKkBAAAAAMApEGqkqHBj/3auzNQAAAAAAGAohBopKtTQLkksPwEAAAAA4BQINVJU/0wNlp8AAAAAADA0Qo0UFW5sV2lhnsqL84MuBQAAAACAlESokaJCDW2aPr5YZhZ0KQAAAAAApCRCjRQVYjtXAAAAAABOi1AjBbm7wo3t7HwCAAAAAMBpEGqkoIYTXWrr6qVJKAAAAAAAp0GokYLCjWznCgAAAADAcAg1UlCI7VwBAAAAABgWoUYKCjUwUwMAAAAAgOEQaqSguoYTGj8mXyWFeUGXAgAAAABAyiLUSEE797do/tSyoMsAAAAAACClEWqkmO7ePu06eFwLp5cHXQoAAAAAACmNUCPFvHyoVV09fVowjZkaAAAAAACcDqFGitm+v1mSdB4zNQAAAAAAOC1CjRSzvb5ZJYV5mjlxbNClAAAAAACQ0gg1Usz2+mbVTCtTTo4FXQoAAAAAACmNUCOF9PT2aeeBFi2cxtITAAAAAACGQ6iRQvYePaGO7j4tnE6TUAAAAAAAhkOokUK219MkFAAAAACAWMUUapjZKjPbbWZ7zOz2IV6fYWZPm9lmM9tqZlcPeO2fo9ftNrO3x3rPbLStvlnF+bk6e3JJ0KUAAAAAAJDyhg01zCxX0l2S3iGpRtIaM6sZdNpnJd3v7kskrZZ0d/TamujzBZJWSbrbzHJjvGfW2VHfopppZcqlSSgAAAAAAMOKZabGxZL2uPted++StFbSdYPOcUn9jSDKJe2PPr5O0lp373T3VyXtid4vlntmlb4+1479zVo4jX4aAAAAAADEIpZQY7qk0IDn4eixgb4g6UYzC0t6VNLHh7k2lntmlVePndCJrl4toJ8GAAAAAAAxyYvTfdZI+qG7f8PMLpP0EzNbGI8bm9nNkm6WpIqKCq1fvz4et0261tbW09b+7P4eSVLngZe1fv0rSaoKiTbcuCMzMe7ZiXHPTox79mLssxPjnp0Y99QWS6hRL6l6wPOq6LGBblKkZ4bc/S9mViRp0jDXDndPRe93j6R7JGnp0qW+bNmyGEpOPevXr9fpav/Tb3aqIO81rb56mfJz2ZQmUww37shMjHt2YtyzE+OevRj77MS4ZyfGPbXF8tPzBklzzGyWmRUo0vjz4UHn1Em6UpLMbL6kIklHouetNrNCM5slaY6k52O8Z1bZXt+i+VPLCDQAAAAAAIjRsDM13L3HzG6RtE5SrqR73X2Hmd0haaO7PyzpNknfNbNbFWka+mF3d0k7zOx+STsl9Uj6mLv3StJQ90zA50sL7q7t+5t17aJpQZcCAAAAAEDaiKmnhrs/qkgD0IHHPjfg8U5Jbz7FtV+R9JVY7pmt6hradLyjRwtpEgoAAAAAQMxY65ACtte3SJLOI9QAAAAAACBmhBopYFt9s/JzTXMqSoIuBQAAAACAtEGokQJ27G/WvMpSFeblBl0KAAAAAABpg1AjYO6ubfXNWjiNpScAAAAAAJwJQo2A1Te1q6mtWwvopwEAAAAAwBkh1AgYTUIBAAAAABgZQo2Aba9vVm6O6dzK0qBLAQAAAAAgrRBqBGz7/mbNmVKionyahAIAAAAAcCYINQLk7tpe36yFLD0BAAAAAOCMEWoE6FBLp462dmnhtLKgSwEAAAAAIO0QagRoe32zJOm8KmZqAAAAAABwpgg1ArStvlk5Js2fykwNAAAAAADOFKFGgHbsb9Y5k0s0piAv6FIAAAAAAEg7hBoB2kaTUAAAAAAARoxQIyCHj3foUEunFtAkFAAAAACAESHUCMiO+hZJ0nnM1AAAAAAAYEQINQLSv/NJDTM1AAAAAAAYEUKNgGzf36yzJ41VaVF+0KUAAAAAAJCWCDUCsr2+RQtYegIAAAAAwIgRagSg4USX6pvatZClJwAAAAAAjBihRgD6+2nQJBQAAAAAgJEj1AjA9v2RUGPBNEINAAAAAABGilAjADvqW1Q9oVjlY2gSCgAAAADASBFqBGBbfTNLTwAAAAAAGCVCjSRrbutWXUMbS08AAAAAABglQo0k27GfJqEAAAAAAMQDoUaS/bVJKNu5AgAAAAAwGoQaSba9vkXTyos0saQw6FIAAAAAAEhrhBpJtr2+WQtZegIAAAAAwKgRaiTR8Y5u7T16glADAAAAAIA4INRIop37WyTRJBQAAAAAgHgg1Eii7dFQY8F0moQCAAAAADBahBpJtKO+WVNKCzWltCjoUgAAAAAASHuEGkm0rb6ZpScAAAAAAMQJoUaSdPa4XjnSqgWEGgAAAAAAxAWhRpLUHe9Tn9MkFAAAAACAeIkp1DCzVWa228z2mNntQ7x+p5nVRr9eMrOm6PErBhyvNbMOM3t39LUfmtmrA15bHN+Pllpea+mTJC2kSSgAAAAAAHGRN9wJZpYr6S5JKySFJW0ws4fdfWf/Oe5+64DzPy5pSfT405IWR49PkLRH0uMDbv8pd38gDp8j5b3W0qeJYwtUWUaTUAAAAAAA4iGWmRoXS9rj7nvdvUvSWknXneb8NZLuG+L4eyX91t3bzrzM9LevpU8Lp5fLzIIuBQAAAACAjBBLqDFdUmjA83D02BuY2VmSZkl6aoiXV+uNYcdXzGxrdPlKYQy1pKWO7l7Vt/ax9AQAAAAAgDgydz/9CWbvlbTK3T8Sff4BSZe4+y1DnPvfJVW5+8cHHZ8qaaukae7ePeDYQUkFku6R9Iq73zHEPW+WdLMkVVRUXLh27doz/pBB29vUqzue7dAtiwu1tHLYFT/IIK2trSopKQm6DCQZ456dGPfsxLhnL8Y+OzHu2YlxD94VV1yxyd2XDvVaLD9h10uqHvC8KnpsKKslfWyI4zdIerA/0JAkdz8QfdhpZj+Q9N+GuqG736NI6KGlS5f6smXLYig5tYSffU3Sdr1v5ZtUPWFM0OUgidavX690/DOL0WHcsxPjnp0Y9+zF2Gcnxj07Me6pLZblJxskzTGzWWZWoEhw8fDgk8zsXEnjJf1liHu8oc9GdKaGLNJk4t2Stp9Z6eljx/5mjc2XqsYXB10KAAAAAAAZY9iZGu7eY2a3SFonKVfSve6+w8zukLTR3fsDjtWS1vqg9SxmNlORmR6/H3Tr/zCzyZJMUq2kj47mg6SybfXNmlmWQ5NQAAAAAADiKKYGD+7+qKRHBx373KDnXzjFtfs0RGNRd18ea5HprKunT7sPHteKGfTSAAAAAAAgnmJZfoJReOnQcXX3umaW8VsNAAAAAEA88ZN2gk0sKdDt7zhXc8bzWw0AAAAAQDzxk3aCTS0v1kffdo7GF/FbDQAAAABAPPGTNgAAAAC77CexAAAgAElEQVQASEuEGgAAAAAAIC0RagAAAAAAgLREqAEAAAAAANISoQYAAAAAAEhLhBoAAAAAACAtEWoAAAAAAIC0RKgBAAAAAADSEqEGAAAAAABIS4QaAAAAAAAgLRFqAAAAAACAtESoAQAAAAAA0hKhBgAAAAAASEvm7kHXEDMzOyLptaDrGKFJko4GXQSSjnHPTox7dmLcsxPjnr0Y++zEuGcnxj14Z7n75KFeSKtQI52Z2UZ3Xxp0HUguxj07Me7ZiXHPTox79mLssxPjnp0Y99TG8hMAAAAAAJCWCDUAAAAAAEBaItRInnuCLgCBYNyzE+OenRj37MS4Zy/GPjsx7tmJcU9h9NQAAAAAAABpiZkaAAAAAAAgLRFqJJiZrTKz3Wa2x8xuD7oeJI6Z3Wtmh81s+4BjE8zsCTN7Ofrr+CBrRHyZWbWZPW1mO81sh5l9Mnqccc9wZlZkZs+b2Zbo2H8xenyWmT0X/Z7/czMrCLpWxJ+Z5ZrZZjN7JPqccc9wZrbPzLaZWa2ZbYwe43t9hjOzcWb2gJm9aGa7zOwyxj3zmdm86N/1/q8WM/tHxj51EWokkJnlSrpL0jsk1UhaY2Y1wVaFBPqhpFWDjt0u6Ul3nyPpyehzZI4eSbe5e42kSyV9LPp3nHHPfJ2Slrv7IkmLJa0ys0slfVXSne4+W1KjpJsCrBGJ80lJuwY8Z9yzwxXuvnjAto58r898/ybpMXc/V9IiRf7eM+4Zzt13R/+uL5Z0oaQ2SQ+KsU9ZhBqJdbGkPe6+1927JK2VdF3ANSFB3P0PkhoGHb5O0o+ij38k6d1JLQoJ5e4H3P2F6OPjivxjZ7oY94znEa3Rp/nRL5e0XNID0eOMfQYysypJ75T0vehzE+Oerfhen8HMrFzS5ZK+L0nu3uXuTWLcs82Vkl5x99fE2KcsQo3Emi4pNOB5OHoM2aPC3Q9EHx+UVBFkMUgcM5spaYmk58S4Z4XoEoRaSYclPSHpFUlN7t4TPYXv+ZnpXyV9WlJf9PlEMe7ZwCU9bmabzOzm6DG+12e2WZKOSPpBdLnZ98xsrBj3bLNa0n3Rx4x9iiLUAJLEI1sNsd1QBjKzEkm/lPSP7t4y8DXGPXO5e290amqVIjPzzg24JCSYmb1L0mF33xR0LUi6t7j7BYosKf6YmV0+8EW+12ekPEkXSPqOuy+RdEKDlhsw7pkt2h/pWkm/GPwaY59aCDUSq15S9YDnVdFjyB6HzGyqJEV/PRxwPYgzM8tXJND4D3f/f9HDjHsWiU5HflrSZZLGmVle9CW+52eeN0u61sz2KbKkdLkia+4Z9wzn7vXRXw8rsrb+YvG9PtOFJYXd/bno8wcUCTkY9+zxDkkvuPuh6HPGPkURaiTWBklzol3RCxSZvvRwwDUhuR6W9KHo4w9JeijAWhBn0bX035e0y92/OeAlxj3DmdlkMxsXfVwsaYUiPVWelvTe6GmMfYZx93929yp3n6nIf9Ofcvf3i3HPaGY21sxK+x9LWilpu/hen9Hc/aCkkJnNix66UtJOMe7ZZI3+uvREYuxTlkVmziBRzOxqRdbf5kq6192/EnBJSBAzu0/SMkmTJB2S9HlJv5J0v6QZkl6TdIO7D24mijRlZm+R9Iykbfrr+vrPKNJXg3HPYGZ2viJNwnIV+R8E97v7HWZ2tiL/B3+CpM2SbnT3zuAqRaKY2TJJ/83d38W4Z7bo+D4YfZon6Wfu/hUzmyi+12c0M1usSFPgAkl7Jf2dot/zxbhntGiAWSfpbHdvjh7j73yKItQAAAAAAABpieUnAAAAAAAgLRFqAAAAAACAtESoAQAAAAAA0hKhBgAAAAAASEuEGgAAAAAAIC2lXahhZvea2WEz2x7DuXeaWW306yUza0pGjQAAAAAAIPHSbktXM7tcUqukH7v7wjO47uOSlrj7f05YcQAAAAAAIGnSbqaGu/9BUsPAY2Z2jpk9ZmabzOwZMzt3iEvXSLovKUUCAAAAAICEywu6gDi5R9JH3f1lM7tE0t2Slve/aGZnSZol6amA6gMAAAAAAHGW9qGGmZVIepOkX5hZ/+HCQaetlvSAu/cmszYAAAAAAJA4aR9qKLKEpsndF5/mnNWSPpakegAAAAAAQBKkXU+Nwdy9RdKrZva3kmQRi/pfj/bXGC/pLwGVCAAAAAAAEiDtQg0zu0+RgGKemYXN7CZJ75d0k5ltkbRD0nUDLlktaa2n2zYvAAAAAADgtNJuS1cAAAAAAAApDWdqAAAAAAAASGnWKHTSpEk+c+bMoMsAAAAAAABJsmnTpqPuPnmo19Iq1Jg5c6Y2btwYdBkAAAAAACBJzOy1U73G8hMAAAAAAJCWCDUAAAAAAEBaItQAAAAAAABpKa16agAAAAAAgKF1d3crHA6ro6Mj6FJGpKioSFVVVcrPz4/5GkINAAAAAAAyQDgcVmlpqWbOnCkzC7qcM+LuOnbsmMLhsGbNmhXzdSw/AQAAAAAgA3R0dGjixIlpF2hIkplp4sSJZzzLhFADAAAAAIAMkY6BRr+R1E6oAQAAAAAA0hKhBgAAAAAASEs0CgUAAAAAAAnV1tamz3/+82ppadGYMWN0zTXXaPny5aO+LzM1AAAAAABA3D3yyCO6/vrrddlll2nixIkaN26cPvWpT6m2tjYugYZEqAEAAAAAAOJs3bp1amxs1AMPPKCqqiq95z3v0ac//Wlt3rxZN9xwQ9zeJyGhhpkVmdnzZrbFzHaY2ReHOOfDZnbEzGqjXx9JRC1B23O4VR/72QvaffB40KUAAAAAAJAUxcXF+sAHPiBJeuaZZ3TppZfqM5/5jJ5//nk988wzcXufRPXU6JS03N1bzSxf0h/N7Lfu/uyg837u7rckqIaU0NXTp99sPaB3njdV8ypLgy4HAAAAAJAFvvjrHdq5vyWu96yZVqbPX7MgpnMvv/xySdKzzz6rsWPH6hOf+ERca+mXkFDD3V1Sa/RpfvTLE/Feqa6yvEiSdLC5I+BKAAAAAABIroceekjXXHNNwu6fsN1PzCxX0iZJsyXd5e7PDXHa35jZ5ZJeknSru4cSVU9Qxo/JV0Fejg61EGoAAAAAAJIj1hkV8bZ//351dnZq1qxZkiKhxt13352w90tYo1B373X3xZKqJF1sZgsHnfJrSTPd/XxJT0j60VD3MbObzWyjmW08cuRIospNGDNTRVmhDhJqAAAAAAAy3L/8y7/o4YcfliT99re/VV9fn5YtW5aw90vYTI1+7t5kZk9LWiVp+4Djxwac9j1J//sU198j6R5JWrp0aVouYaksK2L5CQAAAAAg461Zs0bf/va3tXnzZh09elS//vWvlZOTuI1XExJqmNlkSd3RQKNY0gpJXx10zlR3PxB9eq2kXYmoJRVUlBVpe31z0GUAAAAAAJBQK1eu1MqVK5P2fomaqTFV0o+ifTVyJN3v7o+Y2R2SNrr7w5I+YWbXSuqR1CDpwwmqJXCVZUX63a5DcneZWdDlAAAAAACQERK1+8lWSUuGOP65AY//WdI/J+L9U01leZE6uvvU0t6j8jH5QZcDAAAAAEBGSNzCFpxUURbZ1vVAS3vAlQAAAAAAkDkINZKgsjwSatAsFAAAAACA+CHUSILK6EyNQ2zrCgAAAABIIPe03DRU0shqJ9RIgillhZKkg82dAVcCAAAAAMhURUVFOnbsWFoGG+6uY8eOqaio6IyuS9TuJxigMC9XE8YW6CAzNQAAAAAACVJVVaVwOKwjR44EXcqIFBUVqaqq6oyuIdRIkoqyIpafAAAAAAASJj8/X7NmzQq6jKRi+UmSVJYV0igUAAAAAIA4ItRIkspyZmoAAAAAABBPhBpJUllWrGMnutTZ0xt0KQAAAAAAZARCjSSpLI/sgHK4hR1QAAAAAACIB0KNJKkoi2xLwxIUAAAAAADig1AjSSrLI6EG27oCAAAAABAfhBpJUhmdqcEOKAAAAAAAxAehRpKUF+erMC+H5ScAAAAAAMQJoUaSmJkqy4t0kEahAAAAAADEBaFGElWUFekQy08AAAAAAIgLQo0kqiwrolEoAAAAAABxQqiRRJHlJx1y96BLAQAAAAAg7RFqJFFFWZG6evrU1NYddCkAAAAAAKQ9Qo0kOrmtK0tQAAAAAAAYNUKNJKosL5REqAEAAAAAQDwQaiRRRXSmBjugAAAAAAAweoQaSTSllOUnAAAAAADEC6FGEhXk5WhSSYEOEWoAAAAAADBqhBpJVlFWpIMsPwEAAAAAYNQINZKssqxIB1s6gy4DAAAAAIC0R6iRZBXlRSw/AQAAAAAgDgg1kqyyrEgNJ7rU2dMbdCkAAAAAAKQ1Qo0kq4xu63qYJSgAAAAAAIwKoUaSVZSzrSsAAAAAAPFAqJFk/TM12AEFAAAAAIDRIdRIMkINAAAAAADig1AjycqK81SUn8PyEwAAAAAARolQI8nMTJVlRYQaAAAAAACMEqFGACrKinSI5ScAAAAAAIwKoUYAKsuZqQEAAAAAwGgRagSgsqxIh1s65e5BlwIAAAAAQNoi1AhAZXmRunr71HCiK+hSAAAAAABIW4QaATi5rStLUAAAAAAAGDFCjQBUlEdCjUOEGgAAAAAAjBihRgBOztRo7gy4EgAAAAAA0hehRgAmlxbKjOUnAAAAAACMRkJCDTMrMrPnzWyLme0wsy8OcU6hmf3czPaY2XNmNjMRtaSi/NwcTSop1KFmQg0AAAAAAEYqUTM1OiUtd/dFkhZLWmVmlw465yZJje4+W9Kdkr6aoFpSUmVZETM1AAAAAAAYhYSEGh7RGn2aH/3yQaddJ+lH0ccPSLrSzCwR9aSiirIiGoUCAAAAADAKCeupYWa5ZlYr6bCkJ/7/9u47Ou7zvvP955kODGaGKINCkAR7LypU75TsqFlSvI5X8brH0TqxY2njnNyUPd57HefsvbteJ06cxJElW+69ybJi2bIoiWq0KFEixU6CBQRBNKLOYPpz/5ghCFIUxYLBbzDzfp0z5/n9fvObmS/0HI7AD59ird14yi2tkjokyVqbkTQkqb5Y9ZSa5oifkRoAAAAAAFyAooUa1tqstfYiSbMkXW6MWXk+72OMuc8Ys8kYs6m3t3dyi3RQczigwXhaiXTW6VIAAAAAAJiWir77ibV2UNJ6Sbee8lSnpNmSZIzxSIpI6j/N6x+01q611q6NRqPFLnfKNBW2dWUKCgAAAAAA56dYu59EjTEzCsdVkt4haecptz0q6UOF4/dIespae+q6G2WrOZIPNY6yAwoAAAAAAOfFU6T3bZH0dWOMW/ng5AfW2seMMZ+VtMla+6ikhyV90xizV9IxSfcWqZaS1FwYqcG6GgAAAAAAnJ+ihBrW2i2SLj7N9c9MOE5I+oNifP500BRh+gkAAAAAABei6Gtq4PRCfo+qfW4dHUo6XQoAAAAAANMSoYZDjDFqDgcYqQEAAAAAwHki1HBQUzjAmhoAAAAAAJwnQg0HNUcC7H4CAAAAAMB5ItRwUFM4oJ6RhHK5itnJFgAAAACASUOo4aDmsF/prNWxeMrpUgAAAAAAmHYINRzUXNjWlSkoAAAAAACcO0INBzWF86EGO6AAAAAAAHDuCDUcND5Sg1ADAAAAAIBzRqjhoGiNXy4jdTP9BAAAAACAc0ao4SCP26WGGj8jNQAAAAAAOA+EGg5rjgTUxUgNAAAAAADOGaGGw5rCARYKBQAAAADgPBBqOKw5HGBLVwAAAAAAzgOhhsOaIwENJzIaS2WdLgUAAAAAgGmFUMNhzWG2dQUAAAAA4HwQajisOVIINZiCAgAAAADAOSHUcFhTYaQGi4UCAAAAAHBuCDUcNj5Sg1ADAAAAAIBzQqjhsBq/RzV+D9NPAAAAAAA4R4QaJaAp7Gf6CQAAAAAA54hQowQ0RwJMPwEAAAAA4BwRapSApnBA3Uw/AQAAAADgnBBqlIDmcEA9I0nlctbpUgAAAAAAmDYINUpAcySgTM6qL5Z0uhQAAAAAAKYNQo0S0BTOb+vaPUSoAQAAAADA2SLUKAHNhVCDxUIBAAAAADh7hBoloDlCqAEAAAAAwLki1CgBDTV+uV2GHVAAAAAAADgHhBolwO0yitb4GakBAAAAAMA5INQoEU2RgLoJNQAAAAAAOGuEGiWiOezXUaafAAAAAABw1gg1SkRzOMD0EwAAAAAAzgGhRoloigQ0ksgonso4XQoAAAAAANMCoUaJaA4XtnVlCgoAAAAAAGeFUKNEjIcaTEEBAAAAAOCsEGqUiKZIPtRgBxQAAAAAAM4OoUaJODH9JOlwJQAAAAAATA+EGiUi6Pco5PcwUgMAAAAAgLNEqFFCmiIBFgoFAAAAAOAsEWqUkOZwgIVCAQAAAAA4S4QaJaQpHGD6CQAAAAAAZ6kooYYxZrYxZr0xZrsxZpsx5v7T3HOjMWbIGPNa4fGZYtQynTRH/OoZSSqbs06XAgAAAABAyfMU6X0zkj5trX3VGBOS9Iox5jfW2u2n3LfBWntnkWqYdpojVcrmrPpGk2oq7IYCAAAAAABOrygjNay1XdbaVwvHI5J2SGotxmeVkxPbujIFBQAAAACAt1P0NTWMMXMlXSxp42mevsoY87ox5j+MMSuKXUupGw81WFcDAAAAAIC3VazpJ5IkY0yNpB9LesBaO3zK069KarPWjhpjbpf0M0mLTvMe90m6T5LmzJlTzHId1xTxSxKLhQIAAAAAcBaKNlLDGONVPtD4trX2J6c+b60dttaOFo4fl+Q1xjSc5r4HrbVrrbVro9FoscotCQ1Bvzwuw/QTAAAAAADOQrF2PzGSHpa0w1r7hbe4p7lwn4wxlxdq6S9GPdOFy2XUGPIz/QQAAAAAgLNQrOkn10j6gKStxpjXCtf+RtIcSbLWflnSeyT9iTEmI2lM0r3W2orfy7QpEmD6CQAAAAAAZ6EooYa19jlJ5m3u+ZKkLxXj86ez5nBAu7tHnC4DAAAAAICSV/TdT3BumsIBdQ8nnS4DAAAAAICSR6hRYpojAY0mMxpNZpwuBQAAAACAkkaoUWKawwFJYgcUAAAAAADeBqFGiWkqhBosFgoAAAAAwJkRapSY5ggjNQAAAAAAOBuEGiVmfPoJIzUAAAAAADgjQo0SU+VzKxzwMP0EAAAAAIC3QahRgpojAaafAAAAAADwNgg1SlBTOMBIDQAAAAAA3gahRgmaGalSx8CYrLVOlwIAAAAAQMki1ChBa+fW6lgspe1dw06XAgAAAABAySLUKEE3LmmUJK3f2eNwJQAAAAAAlC5CjRIUDfm1elZETxFqAAAAAADwlgg1StRNSxq1uWNQx2Ipp0sBAAAAAKAkEWqUqHVLG2Wt9MxuRmsAAAAAAHA6hBolalVrRA01fj21s9fpUgAAAAAAKEmEGiXK5TK6cUlUz+zqUSabc7ocAAAAAABKDqFGCVu3tFHDiYxePTTodCkAAAAAAJQcQo0Sdu2iBnlcRut3sa4GAAAAAACnItQoYeGAV5fNrdN6tnYFAAAAAOBNCDVK3Lqljdp5dESdg2NOlwIAAAAAQEkh1ChxNy1tlCRGawAAAAAAcApCjRK3IBrUnLpqQg0AAAAAAE5BqFHijDG6aUlUz+/rUyKddbocAAAAAABKBqHGNHDT0kYl0jm92N7vdCkAAAAAAJQMQo1p4Mr59aryupmCAgAAAADABIQa00DA69Y1C+v11M4eWWudLgcAAAAAgJJAqDFN3LS0UYcHxrS3Z9TpUgAAAAAAKAmEGtPETUvyW7s+xRQUAAAAAAAkEWpMGzNnVGlpc0jrdxFqAAAAAAAgEWpMK+uWNmrTgQENJ9JOlwIAAAAAgOMINaaRdUsblclZbdjd53QpAAAAAAA4jlBjGrl4Tq1mVHtZVwMAAAAAABFqTCtul9ENi6N6ZnePcjm2dgUAAAAAVDZCjWnmpiWN6htNaUvnkNOlAAAAAADgKEKNaeaGxVG5DFu7AgAAAABAqDHN1AZ9unhOrdYTagAAAAAAKhyhxjS0bmmjtnYOqWc44XQpAAAAAAA4hlBjGrppSaMk6eldvQ5XAgAAAACAcwg1pqFlLSG1RAKsqwEAAAAAqGiEGtOQMUY3LmnUc3v7lMrknC4HAAAAAABHEGpMU+uWNmo0mdGmA8ecLgUAAAAAAEcQakxT1yysl8/jYgoKAAAAAKBiFSXUMMbMNsasN8ZsN8ZsM8bcf5p7jDHmn4wxe40xW4wxlxSjlnJV7fPoyvn1emoXoQYAAAAAoDIVa6RGRtKnrbXLJV0p6RPGmOWn3HObpEWFx32S/q1ItZStdUuiau+N6WB/zOlSAAAAAACYckUJNay1XdbaVwvHI5J2SGo95ba7JX3D5r0kaYYxpqUY9ZSrdUubJIkpKAAAAACAilT0NTWMMXMlXSxp4ylPtUrqmHB+WG8OPmSMuc8Ys8kYs6m3t7dYZU5Lc+qrNT8aJNQAAAAAAFSkooYaxpgaST+W9IC1dvh83sNa+6C1dq21dm00Gp3cAsvAuiWN2th+TLFkxulSAAAAAACYUkULNYwxXuUDjW9ba39ymls6Jc2ecD6rcA3nYN3SRqWyOT2/t8/pUgAAAAAAmFLF2v3ESHpY0g5r7Rfe4rZHJX2wsAvKlZKGrLVdxainnK2dW6cav0fr2QUFAAAAAFBhPEV632skfUDSVmPMa4VrfyNpjiRZa78s6XFJt0vaKyku6SNFqqWs+TwuXbeoQet39spaq3yeBAAAAABA+StKqGGtfU7SGf92ba21kj5RjM+vNDctbdR/vHFUO7pGtHxm2OlyAAAAAACYEkXf/QTFd+OS/AKqv9p21OFKAAAAAACYOoQaZaAxFNDNSxv19RcOaDiRdrocAAAAAACmBKFGmfhv71isobG0Ht6w3+lSAAAAAACYEoQaZWJla0S3rmjWV5/br8F4yulyAAAAAAAoOkKNMvLf3rFYo6mMHny23elSAAAAAAAoOkKNMrKkOaQ7V8/UIy8cUP9o0ulyAAAAAAAoKkKNMvPALYuUSGf15Wf2OV0KAAAAAABFRahRZhZEa3TPxa36xosH1TOccLocAAAAAACKhlCjDN1/8yJlclb/+jSjNQAAAAAA5YtQowy11Qf1B5fO0nc2HtKRwTGnywEAAAAAoCgINcrUJ9ctlJXVl9bvdboUAAAAAACKglCjTM2qrda9l83RD17uUMexuNPlAAAAAAAw6Qg1ytgnblool8von367x+lSAAAAAACYdIQaZaw5EtD7r2jTTzZ3an9fzOlyAAAAAACYVIQaZe5Pblwgn9ulLz652+lSAAAAAACYVIQaZS4a8uuDV7fp568f0Z7uEafLAQAAAABg0hBqVID/ev0CVXvd+scnWVsDAAAAAFA+CDUqQF3Qp49eO0+/3Nql7UeGnS4HAAAAAIBJQahRIT527XyFAh79A2trAAAAAADKBKFGhYhUe/XH183Xb7Z3a8vhwXN+fSab0293dOvVQwNFqA4AAAAAgHNHqFFBPnLNXM2o9uoLvzn70Rrdwwl98ck9uu5/rdcffX2TPvrIyxpNZopYJQAAAAAAZ4dQo4KEAl791+sX6OldvXrl4FuPuMjlrJ7b06c/+dYruvr/fUr/8ORuLWys0X+/Y5kG42l9/YUDU1c0AAAAAABvweN0AZhaH7q6TQ8/164v/GaXvv2xK096bjCe0o9eOaxvbzyk/X0x1VZ79UfXztP7Lp+juQ1BSdKL+/r14LPt+uBVbQoFvE78CAAAAAAASCLUqDjVPo8+fsMCfe6XO/RSe7+umFenzR2D+vZLh/TYliNKZnK6tK1Wn7p5oW5b2aKA133S6++/ZZHu+tLz+voLB/TJdYsc+ikAAAAAACDUqEjvv7JNX9nQrs/8/A15XC5t7xpW0OfWH6ydpf9yRZuWtYTf8rWrZ83QLcsa9ZUN+/XBq+cqzGgNAAAAAIBDWFOjAgW8bn3q5kXa3T2qnLX63D0rtfFvb9Hn7ll1xkDjuAduWayhsbQeef5A8YsFAAAAAOAtMFKjQr3v8jm6flFUs2qrZIw5p9eubI3olmVNemhDuz58DaM1AAAAAADOYKRGhTLGaHZd9TkHGsc9cMsiDScy+tpzBya3MAAAAAAAzhKhBs7LytaI3rm8SQ89166hsbTT5QAAAAAAKhChBs7b/bcs0kgio689v9/pUgAAAAAAFYhQA+dtxcyIfm9Fkx5+bj+jNQAAAAAAU45QAxfk/psXaySR0cPPMVoDAAAAADC1CDVwQZbPDOvWFc362nP7NRRntAYAAAAAYOoQauCC3X/LIo0kM3r4uXanSwEAAAAAVBBCDVywZS1h3b6qWV99/oAG4ymnywEAAAAAVAhCDUyK+29erNEka2sAAAAAAKYOoQYmxZLmkO5Y1aKvMVoDAAAAADBFCDUwae6/ZZFiqYy+soG1NQAAAAAAxUeogUmzuCk/WuOR5w9oIMZoDQAAAABAcRFqYFLdf/MixdNZRmsAAAAAAIqOUAOTalFTSHeunqmvv3BAxxitAQAAAAAoIkINTLr7b16oeDqrB59ltAYAAAAAoHiKEmoYY75qjOkxxrzxFs/faIwZMsa8Vnh8phh1wBkLG0N61+qZ+saLB9Q/mnS6HAAAAABAmSrWSI1HJN36NvdssNZeVHh8tkh1wCGfunmREumsHmRtDQAAAABAkRQl1LDWPivpWDHeG9PDwsYa3bVmpr7xwkH1jCScLgcAAAAAUIacXFPjKmPM68aY/zDGrHirm4wx9xljNhljNvX29k5lfbhAf3bzImVzVrd/cYN+sKlDuZx1uiQAAAAAQBlxKtR4VVKbtXaNpH+W9LO3utFa+6C1dq21dm00Gp2yAnHhFkRr9JM/vVpt9UH95Y+26N3/9oJe7xh0uiwAAAAAQJlwJNSw1g5ba0cLx49L8hpjGpyoBcW1sjWiH338Kn3hvWvUOTime/71ef1fP9rCAqIAAAAAgI8VZu8AACAASURBVAvmSKhhjGk2xpjC8eWFOvqdqAXFZ4zRuy+Zpac+fYP++Lr5+vGrh3XT55/WI8/vVyabc7o8AAAAAMA0VawtXb8r6UVJS4wxh40xf2SM+bgx5uOFW94j6Q1jzOuS/knSvdZaFlwoc6GAV39z+zL96oHrtWb2DP3fv9iuO//5Ob3UTp4FAAAAADh3ZjplCWvXrrWbNm1yugxMAmutntjWrc/9crsOD4zpztUt+ts7lqklUuV0aQAAAACAEmKMecVau/Z0zzm5+wkqmDFGt65s1pN/foMeuGWRfrO9W+s+/4z+Zf1eJTNZp8sDAAAAAEwDhBpwVMDr1gO3LNaTf36Dblgc1f9+Ypd+7x+e1dO7epwuDQAAAABQ4gg1UBJm11Xryx+4VN/8o8vlchl9+Gsv6+PffEWdg2NOlwYAAAAAKFGEGigp1y2K6lf3X6+/vHWJntndq5v/z9P6l/V7lcqwSwoAAAAA4GSEGig5Po9Lf3rjQj356Rt04+JG/e8ndunWLz6r5/b0OV0aAAAAAKCEEGqgZLXOqNKXP3CpHvnIZcrmrN7/8EZ94tuvqmuIKSkAAAAAAEINTAM3LmnUEw9cr0+/Y7Ge3NGtm//PM/r3Z/YxJQUAAAAAKhyhBqaFgNetP7t5kZ788xt09YIG/c//2Knb/2mDXtjHlBQAAAAAqFSEGphWZtdV66EPrdXDH1qrZCar931loz713c061B93ujQAAAAAwBTzOF0AcD5uXtakaxY26F+f3qcvP7NPj75+RGtmz9C7Vrfo9lUtmjmjyukSAQAAAABFZqy1Ttdw1tauXWs3bdrkdBkoMZ2DY3r0tSN6bMsRbTsyLEm6tK1Wd6xq0R2rW9QUDjhcIQAAAADgfBljXrHWrj3tc4QaKCf7+2L65ZYjemxLl3YeHZEx0mVtdbpzTYtuXdmsxhABBwAAAABMJ4QaqEh7e0b1yy1demzLEe3pGZXLSFfMq9cdq1t028pm1df4nS4RAAAAAPA2CDVQ8XZ3j+ixQsDR3huTJPk9LoUCHtX4PQr68+3x85pA/lrIf/zcq5ZIQJfMqVWVz+3wTwMAAAAAlYNQAyiw1mrn0RE9vatXg/GURpIZxZIZjSYyGim0o8nCI5FRKps76fVet9HFs2t15YJ6Xb2gXhfPmSG/h5ADAAAAAIqFUAM4T8lMVrFkVqOJjPb1jeqlff16sb1fb3QOKWfzoz0ubavV1QvqddWCeq2eNUNeNzslAwAAAMBkOVOowZauwBn4PW75PW7VBX2aU1+tm5Y0SpKGxtL63f5jerEQcnz+17slSdU+ty6bW6erFtTrqvn1WjEzLA8hBwAAAAAUBSM1gElwLJbSxvZ8wPHivn7t6RmVJAW8Lq2YGdHqWRGtmTVDq2dFNLc+KJfLOFwxAAAAAEwPTD8BpljPSEIb24/ptY5Bvd4xqDeODCmRzq/PEQp4tHpWRKtnzdCaQtsSCcgYgg4AAAAAOBWhBuCwTDanPT2j2nJ4UK8fHtKWw4Pa2TWiTC7/56+hxq81syK6pK1Wf3DpLDWGAw5XDAAAAAClgVADKEGJdFbbu4a1pWNQWw4P6fXDg9rXG5PP7dJdF83UH183X0uaQ06XCQAAAACOYqFQoAQFvG5dMqdWl8ypHb92oC+mrz6/Xz/cdFg/euWwrl8c1R9fN0/XLmxgegoAAAAAnIKRGkAJGoyn9O2Nh/TICwfUO5LU0uaQPnbdfN21ZqZ8HnZTAQAAAFA5mH4CTFPJTFY/f+2IHt6wX7u6R9QY8utDV8/V+69oU6Ta63R5AAAAAFB0hBrANGet1bN7+vTQhnZt2NOnap9b7107Wx+9Zp7m1Fef8bW5nFU6l1M6a5XJ5pTK5pTNWWWyNt/mrHJ24nlu/PrxNuhza83sGfK6GSUCAAAAYGoRagBlZPuRYT30XLt+8foRZXNWC6I1yuasUtmc0tmcMtmTj4/vsHKhQn6Prl3UoJuWNurGJVE1htihBQAAAEDxEWoAZah7OKFvvnhQe3pG5PO45XUbeV0ueT1GXrdLPrdLXrdLHvfEcyNPoXUZI4/byO1yyeMycrvMeOseP3fJ7TLqHUnq6V09Wr+rR93DSUnS6lkR3bikUeuWNmp1a0QuFwuZAgAAAJh8hBoAJoW1Vtu7hrV+Z4/W7+rV5kMDylmpocanGxbnA45rFzUoUsV6HwAAAAAmB6EGgKIYiKX0zO5erd/Vo2d292ownpbHZXRpW60WNtbkR4q4TowOGR854sq3HrdLPnd+RIjf69Ls2mrNjwYVChCKAAAAAMgj1ABQdJlsTq91DGr9rh49vatX3cMJpbN2fG2PdC6ns/26iYb8mt8Q1ILGmnwbrdH8aFCzaqvlPotpLtZajSQz6h9NqW80qf7RpPpGUxqMp3RJW62uml8vY5guAwAAAEwHhBoASkI2lw85JgYdx3dliaeyOtgfV3vfqNp7Y2rvHVV7X0yD8fT4631ul9rq86M55kdrNKPKq2OxlPqOhxexpPpHU+ofTSmVzb1lHStmhvWx6+bpztUz2dEFAAAAKHGEGgCmrWOxVD7g6I1p34TA42B/XJmclc/jUkPQp4aQX/VBn+pr/Kqv8akh6FdDyKf6YOG8xq+g36PHXj+ih57br709o2oOB/Tha+bqDy+fwzogAAAAQIki1ABQdjLZnMbSWdX4Pec8lSSXs3pmd6++sqFdL+zrV9Dn1nsvm62PXjNPs+uqi1QxAAAAgPNBqAEAb2HbkSE9vGG/Hn39iHLW6taVzfrYdfN1yZxap0sDAAAAIEINAHhbR4cSeuSFA/rOxoMaTmR0aVut/vi6eXrH8uazWpwUAAAAQHEQagDAWYolM/rBpg599fn96jg2ppmRgC5uq9Wy5pCWtYS1rCWslkiA3VMAAACAKUKoAQDnKJuz+vW2o/rZa53a3jWsjmNj489Fqrxa1lIIOZrzQceiphoFvG4HKwYAAADK05lCDc9UFwMA04HbZXTbqhbdtqpFkjScSGvX0RHt6BouPEb0vd91aCydHb9/fkMwP5JjRkAel5Hb5Sq0Rh6Xkcd98rnbZeRxn7jP63bJ4zbyugqt28hTOPa5XeOv97pd8rqNfB5X/uF2MXIEAAAAFYlQAwDOQjjg1WVz63TZ3Lrxa9mc1cH+mHZ05cOOnUeH9crBAfVuSyqbs8rmpm4knM/jkt/tOhF0eFzyTwg9fB6X6mv8ml1brVm1VZpdl29bZ1QxwgQAAADTFqEGAJwnt8tofrRG86M1umN1y5uetzYfbGRyp7a5fJs9cZ4pnKeyOWWyVplsTulcoc0W7slapbP5e9PZnFKZnJKFRypz/DybP87mlEzn2+PXt3UO6dfbjiqdPTlsaQz5x0OO46HHrNpqtdXnjxkFAgAAgFJFqAEARWJMfnqJp4QGQuRyVt0jCR0eGFPHsfhJ7SsHB/TYlq6TRpi0zqjS9YujunFJVFcvqFco4HWwegAAAOBkhBoAUEFcLqOWSJVaIlUnTaU5LpPNqWsoH3rs7R3Vht29evS1Tn33d4fkcRmtnVurG5c06obFUS1tDjGKAwAAAI4qyu4nxpivSrpTUo+1duVpnjeSvijpdklxSR+21r76du/L7icAMPVSmZxeOTigp3f36Jldvdp5dESS1BT264bFUd24pFHXLGxQpIpRHAAAAJh8U76lqzHmekmjkr7xFqHG7ZL+TPlQ4wpJX7TWXvF270uoAQDOOzqU0LO7e/X07h5t2NOnkURGbpfRJXNmaM2sGar2ueX3uuX3uBTwugsPl/yefBuY+JzHLZcrP1XHSDJGMjKFVtIp58en9IT8HkaJAAAAVIgp39LVWvusMWbuGW65W/nAw0p6yRgzwxjTYq3tKkY9AIDJ0xwJ6L2XzdZ7L5utTDanzR2DemZXPuT41saDSqRzRa/B53EpWuNXY9g/oQ0oGvKrMeTPt2G/6oN++Tyuk16by1klMlmNpbIaS2eVSGc1lsppLJ0/H0tllMzkNKeuWkuaQ6r2MVMTAACgVDn1m1qrpI4J54cL1wg1AGAa8bhd41vd/sXvLZGU3/Xl+K4syXRWiXROiUxWyUKbSE88zimXs7KyslayUqE9cS5rT1y3+R1i+kdT6h1JqmckqYP9cW06OKBjsdRpa6wL+uT3uAqBRVbJzNmHLsZI8+qDWtYS1tLmkJa1hLVsZlgzIwFGigAAAJSAkv/nJ2PMfZLuk6Q5c+Y4XA0A4O0YY8annWgK19lIZXLqjyXVM5xU70hSvaP5456RhFKZnKp9bgV8blV5Cw9fvsbTnXvcRvv7YtrRNawdXcPa2jmkX249kbtHqrzjIcfylrCWtYS1oDGoKq+bsAMAAGAKORVqdEqaPeF8VuHam1hrH5T0oJRfU6P4pQEApiOfxzW+s8tkWNwU0u+taB4/H0mktevoiHZ0DWt7V779/ssdGktnx+/xuo1CAa9CAY/ChTb/OPna8dZKiqfyU17iqaxiE47HUtnCtcz4cc5aXTm/Xu9c3qTL5tXJ63adpnIAAIDK4VSo8aikTxpjvqf8QqFDrKcBAChloYBXa+fWae2ErXBzOauDx+La0TWsA/0xjSQyGkmkC21Gw2NpHeiLaySR1nAio9Fk5m0/J+B1KejzqMrnVrXPrSqfR0GfWzOqvUplrb77u0N65IUDilR5dfPSRr1zRZOuXxxl7Q8AAFCRivIbkDHmu5JulNRgjDks6X9I8kqStfbLkh5XfueTvcpv6fqRYtQBAEAxuVxG8xqCmtcQPKv7szmr0WQ+7BhJZGSMCsGFOx9keN1yuc48fSWeymjDnj79elu3fruzWz/Z3Cm/x6XrFjXoncubdfOyRtXX+CfjxwMAACh5RdnStVjY0hUAgBMy2ZxePjCgJ7Yd1W+2d6tzcEwuI62dW6d3Lm/SO5c3a059tTLZnAbH0hqMp3QsltaxWCp/HE9pMJ4/H4ilNBBPaXAsrfqgTwuiNZofDRbaGs2urZKH6S4AAMABZ9rSlVADAIAyYK3VtiPD+vX2bv1621HtPDoiSQr5PRo5w7QXv8eluqBPtdU+1Qa9ilR51TuSVHtvTP0TdpTxuo3a6oOa3xDUgsaa8XZBQ40i1VO3ICwAAKg8hBoAAFSYg/0x/WZ7tzqOxTWj2qe6oE8zqr0TAgyf6qp9qvK53/I9BuMp7euNqb13dLxt74vpYH9M6eyJ3x8iVV5V+9zye1zye9wKePOt3+sav+Y/fs3jkr+wbkg44FG4yqtQwDt+HK7KHwd9nredigMAACoDoQYAAJg0mWxOHQNj2tczqva+UR0eGFMinVUyk1MynVMyk1Wi0CYzucIjq2Q6p0Q6q0Qmp1Qmd8bPcBmpxl8IOgq7xVRNCE6OhyPjx4XgxOc+cb26sMBqXSHAmVHtk8/DFBoAAKabM4UaLJUOAADOicftmrBAatN5vUcmm8vvEJNIa3gs345MOB4ey+8YM94m0hqIpU6EJOmTA5OJI0fOpMbvUW3Qmx+tUu1TbbV3fNTKjKBPrTMCWhCt0azaarkZKQIAQMkj1AAAAFPO43apNpifBjMZsjmrVGbC6JB0TrFURgPxlAZi6UKb0kC8cFw4b+8b1WAs/aZ1R3xul9rqqzU/GtT8aM2JhVOLsIZILmc1nCgs2FpYzHUgllL/8cVb4ym1RKq0qjWi1bMiagwHJvXzAQCYzgg1AADAtOd2GVUVtsc9H6lMToPxlDoG4trXG9O+3lG198a0t2dUv93Ro0zuxEiQ+qAvH3Y01GhOfX5ERzZnlclaZXM5ZXI2fz7e5iY8bxVPZXWsEKocDzJybzHQxO9x5RdvHU3q+IzhxpBfq2dFtLIQcqxsjagxVPpBx1gqq77RpGbXVRfl/RPprH69vVsv7uvXjUuiunlpIzv2AEAFYE0NAACAMzh1DZH23pjaC8HHxB1ijvO6jdwuI4/LVWjNidZtFPC48+t8BE8s2Fob9Kn+pPP8WiBVXreMMYolM9reNayth4e0tTP/2Nc7Oh50NIcD4yHHqtaIFjXVyHeOf6Ev1poj+/ti+uaLB/WjVzo0nMhoWUtY91w0U3ddNFMtkaoLfv9dR0f0/Zc79JPNhzUYT8vndimVzaklEtC9l83RH14+e1qObhmMp+RyGYUD7C4EACwUCgAAUARjqawkjYcWU7ljy2gyo+1HhvMhx+FBbe0cUntfTOf7q12N36OblzXq9lUtumFxVAHv+Y16kfLTgZ7a2aNvvHhAG/b0yeMyum1Vi1a1hvX41qN6rWNQxkhXzKvTPRe16rZVLYpUnf1f3mPJjB7bckTfe7lDmw8Nyus2eueKZt172WxdMa9e63f16FsvHRz/7HeuaNL7r2zTVfPrZUxpr5UylsrqKxva9eVn9snvcenv7lmpO1fPdLosAHAUoQYAAEAFGE1mtK0QbuTO4Xc8a6Wth4f0xPajGoynVe1za93SfMBx45Koqn1nN2O5fzSp773coe9sPKTOwTE1hwN63xVzdO/ls0+aInOgL6afv3ZEP3+tU+19MfncLt20NKp7LmrVTUsbTxuoWGv1+uEhff/lQ3r0tSOKpbJa2Fijey+brd+/uFX1Nf43vWZ/X0zf2XhQP9h0WENjaS2IBvX+K9v07ktmnVOIMhVyOaufbO7U55/YpaPDCf3eiiZ1DSW05fCQbl/VrM/evVINp/kZAaASEGoAAADgbaWzOW1sP6bH3+jSE28cVX8spYDXpZuWNOq2VS1at7RRNf6TAw5rrV49NKhvvXRQv9zSpVQ2p6sX1OuDV7XplmVNZ1zXwlqrrZ1D+tnmI/rFliPqHUkqFPDotpXNuueiVl0xv14jibR+urlT33+5QzuPjqjK69adq1t07+Wzdcmc2rMaeZFIZ/XYli5986WDer1jUFVet+6+aKbef2WbVrZGLvi/24V6YV+f/v6XO7TtyLDWzIrob+9Yrsvn1SmTzenfn23XF5/co5qAR39390rdsbrF6XIBYMoRagAAAOCcZLI5vXxgQI9v7dKvth1V70hSfo9LNyyO6vZVLbp6Yb3W7+zRN148qG1HhlXj9+g/XdKqD1zVpoWNoXP+vGzO6oV9ffrZ5iN6YttRjSYziob8GhpLK5XJac2siP7zZXP0rjUtCl3AOhNbDw/pWy8d1M9f71QindNFs2fojlUtao4EFA35xx8hv6foU1X29Y7qfz6+U0/u6FbrjCr95a1L9K7VM980jWnX0RH9xQ9f19bOId2xqkWfvXvFaUemAEC5ItQAAADAecvmrF45WAg43jiqo8OJ8eeWNIX0gava9PsXtyron5yN9RLprH67o0ePv9GlhqBP//myOVo+Mzwp733c0FhaP37lsL618aDae2Nvej7gdeUDjpoTQUe05kTwMa+hWm31QXnPY4eVY7GUvvjkbn174yEFvG796U0L9NFr5p1xHZPjozb+8cndCge8+rt7Vur2VYzaAFAZCDUAAAAwKXI5q80dg3pxX58um1uny+fVlfzim2dirdVAPK2+0aR6RyY8RpPqGU6od8L1gXj6pNf63C7Njwa1qCmkxY01Wtwc0uKmkObU5bf6PVUyk9Ujzx/Ql9bvVTyV1R9ePlsP3LL4nNbKmDhq487VLfrs3StVF/Rd8H8HAChlhBoAAADABUplcuqPJdU9nFR776h2dY9oT/eodneP6PDA2Ph9fo9LC6I1WtIc0qKmGi1uDCmWyujzv96ljmNjWre0UX9921Itajr3aTpSfu2TLz+9T//01B5Fqrz63D0rdetKRm0AKF+EGgAAAEARxZIZ7enJBxx7uke0q3tUe7pH1DV0YqrO0uaQ/vsdy3XtooZJ+cwdXcP6ix++rm1HhvWuNTP12btWqJZRGwDKEKEGAAAA4IDhRFp7ukc1mszo2oUNp52WciHS2Zz+7el9+uen9igc8OqahQ1qq6/WnLr8mh9z6qrVGPK/afFRAJhOCDUAAACAMraja1iff2KXdnWP6MjgmHITfsX3e1yFkKNac+qC+ba+Wm111aqv8SuZzmosnVU8lW/HUvlHPJ1VIpVVPJXRWDqnsVRGY+msGkMBrWgNa8XMiCJV578TzamG4mm9cWRIb3QOaWgsrWjIr8ZQQI1hvxoLx1W+t15MtdRksjkdOhZXW31w0sMsoNKcKdSYnCWqAQAAADhmWUtYD3/4Mkn5tT86B8d06Fhch/pjOtgf18FjcR3qj+v5vf0aS2fP6zOMyQckiXRu/FpbfbVWzoxoZWtEK1vDWjkzclZTYPpHk3rjyLDe6MyHGG8cGVLHsRPrkrhdRtncm//xNeT3KBrO70rTGA4Uwg6/msIBzY8GtbgpdMZdZIrJWqvd3aN6YV+fnt/br43t/RpJZtRWX62PXTtP77l09rQKZYDpgpEaAAAAQIWw1qp3JKlDx+I62B/XQDylgNetap9bVV63qgpttc+TP/a5VV247ve4ZIw5KZDYdmRIWztPDiRaZ1SNBxwrWyOa2xBUe++o3ugc1tbCayauNTK3vlorWiOF+/Ovi1R5NRBPqWckmX8MJ9RT2IWmZyRRaJPqGU6eFNK4jDQ/WqNlLWEtawlpWUtYy1vCagz5i7JLT8ex+HiI8cK+fvWNJiXlw56rFzRoaXNIP3utU5sPDaq22qsPXDVXH7qqTfXnsOMNAKafAAAAACiioXh6POB448iwtnUOqb0vdtI9xkjzG4Ja1ZoPO1bMjGj5zPAFTWGx1mo0mVH3cEJ7uke1o2tY27tGtKNrWJ2DJ4KWuqAvH3I0hwuBR1gLGoPyuV3nFHb0jiT1Ynu/Xtjbp+f39Y2HOdGQX9csqNfVCxp09cJ6zaqtPqnGTQcH9O/PtOvJHd3ye1x6z6Wz9LHr5mteQ/C8f3agkhBqAAAAAJhSI4m0th8Z1sH+uOZHg1rWElbQP3Wz34fG0trZNawdXcPa0TWiHUeHtevoiJKZ3JvuNUZyGSOXkUyhzZ+b8eeMkQbjaUlSKODRlfPrdc2Cel2zsEELG2vOKhzZ1zuqhza068evdiqdzemdy5t03/ULdGlb7aT//EA5IdQAAAAAUPEy2ZwO9Me0vWtEh/pjyuaknLWy1ipn88c5q8L5hGu5/HHLjICuWdCgla2RC1r8s3ckqa+/cEDffOmghsbSurStVvddP1/vWNZ0wTvVWGs1ls5qNJlRPJlvY8mMYqmMYsmsYsmMkpmcavweRaq8mlHtVaTKq0ih9XtY9wOlh1ADAAAAAEpMLJnRDzd16KHn9uvwwJjmNQR190UzZWSUymaVyuSUyuSUPN5mc+PX8tezSmVziqeyihcCi1gqo9OssXrWqrzuE0FH4TGj2qsF0Rq9a81MzZxRNXn/AYCzRKgBAAAAACUqk83pP944qgefbdfWziFJ+R1gfG6XfB6X/J586/O45HO/+bza51HQ71bQ71GN36Nqn0c1hfOg36Ng4fmawrnf49JoMqPBeFpDY2kNjuXboXgqfz7xejytwbGUuoeTMka6Yl6d3n3xLN22qlmhwORt6QucCaEGAAAAAEwDiXRWXrfrgqa3FMOh/rh+urlTP918WAf64/J7XHrH8ia9+5JWXbcoKq/bdd7vnc7m1N4b0+GB+PhuPNU+j6p9+WCmesLuO6hMhBoAAAAAgAtmrdVrHYP66eZO/eL1IxqIp1Uf9Olda2bq9y9u1epZkTOGD4PxlLYfX7y1sJDrnu5RpbJvXsB1IpfReNBxPPQI+t2KhvyaWx/UvIag5keDmlsfVF3QRwBSZgg1AAAAAACTKpXJ6Zndvfrp5sN6ckePUpmc5keDevfFrbprTavSudx4cHE8xOgaSoy/vqHGN77F7rKWkNrqg0plchpLZRVLZQprhWQUS2XHr+Xb49cz6h5OquNYXJkJC4mEAx7Ni9ZoXn215jXUaF40qHn1Qc1tqC7JKTPWWmVy9oJGu5Q7Qg0AAAAAQNEMjaX1+NYu/fTVTv3uwLGTnnO7jBZGa7SsJTQhxAgrGvJPymenszkdHhjTgb6Y2vti2t83qgN9ce3vi+nI0Jgm/pW3ocanap9HXreR1+0qPPLHPo9LHlfhusclb+E44HUrXOU5afHUcMCrcNWJnWNqfJ7T7lwTS2bUPZxQz0gy3w7n2+6RpHomXB9LZ7W4MaRL59ZqbVut1rbVaXZdFSNOCgg1AAAAAABTouNYXL/e3q1wwKNlLWEtaqpxbKvYRDqrg/35gGN/X0yHjsWUSOeUyuaUzuSUyVmlC7vKpLM5pbO20J44HktnNZLIKHuGbWVcRgoFCoFHlUfxVFY9w0mNJjNvujfgdakpHFBTKKDGsF9N4YCqvG5t7RzSq4cGNJLIvyYa8mttW60ubavV2rl1WjEzXLGjOQg1AAAAAAA4T9ZajSYzGhpLa3gs3w6NpTWcSGv4+O4xYyeOq30eNYb9agwF1FQILprCfjWGAwr5PW85AiObs9rTM6JNBwb0ysEBvXzgmA4PjEnKhyGrZ83Ij+SYW6uVMyNqqPGfdoRIuSHUAAAAAABgGuoeTmjTgQFtOnhMrxwc0LYjw+OjRjwuo6ZwQC2RgJoj+bYlUjXhvErRkL/kdtM5V4QaAAAAAACUgXgqo9c6BrW3Z1RdQwkdHUqoa2is0CaUzJy8k4zbZdQY8qs5EtBHrpmnu9bMdKjy83emUMMz1cUAAAAAAIDzU+3z6OoFDbp6QcObnrPWajCe1pEJIcd4OzymaT5g47QINQAAAAAAKAPGGNUGfaoN+rRiZsTpcqZEZS6dCgAAAAAApj1CDQAAAAAAMC0RagAAAAAAgGmJUAMAAAAAAExLhBoAAAAAAGBaItQAAAAAAADTEqEGAAAAAACYlgg1AAAAAADAtFS0UMMYc6sxZpcxZq8x5q9O8/yHjTG9xpjXCo+PFasWAAAAAABQfjzFeFNjjFvSv0h6h6TDkl42xjxqrd1+yq3ft9Z+shg1AAAAAACA8lasw79e3QAABh9JREFUkRqXS9prrW231qYkfU/S3UX6LAAAAAAAUIGKFWq0SuqYcH64cO1U/8kYs8UY8yNjzOwi1QIAAAAAAMqQkwuF/kLSXGvtakm/kfT1091kjLnPGLPJGLOpt7d3SgsEAAAAAAClqyhrakjqlDRx5MWswrVx1tr+CacPSfpfp3sja+2Dkh6UpMLCogcnt9Qp0yCpz+kiMOXo98pEv1cm+r0y0e+Vi76vTPR7ZaLfndf2Vk8UK9R4WdIiY8w85cOMeyW9b+INxpgWa21X4fQuSTve7k2ttdHJLnSqGGM2WWvXOl0Hphb9Xpno98pEv1cm+r1y0feViX6vTPR7aStKqGGtzRhjPinpCUluSV+11m4zxnxW0iZr7aOSPmWMuUtSRtIxSR8uRi0AAAAAAKA8FWukhqy1j0t6/JRrn5lw/NeS/rpYnw8AAAAAAMqbkwuFVpoHnS4AjqDfKxP9Xpno98pEv1cu+r4y0e+ViX4vYcZa63QNAAAAAAAA54yRGgAAAAAAYFoi1CgyY8ytxphdxpi9xpi/croeFI8x5qvGmB5jzBsTrtUZY35jjNlTaGudrBGTyxgz2xiz3hiz3RizzRhzf+E6/V7mjDEBY8zvjDGvF/r+/ylcn2eM2Vj4zv++McbndK2YfMYYtzFmszHmscI5/V7mjDEHjDFbjTGvGWM2Fa7xXV/mjDEzjDE/MsbsNMbsMMZcRb+XP2PMksKf9eOPYWPMA/R96SLUKCJjjFvSv0i6TdJySX9ojFnubFUookck3XrKtb+S9Ftr7SJJvy2co3xkJH3aWrtc0pWSPlH4M06/l7+kpHXW2jWSLpJ0qzHmSkn/n6R/sNYulDQg6Y8crBHFc79O3oqefq8MN1lrL5qwrSPf9eXvi5J+Za1dKmmN8n/u6fcyZ63dVfizfpGkSyXFJf1U9H3JItQorssl7bXWtltrU5K+J+luh2tCkVhrn1V+e+KJ7pb09cLx1yXdM6VFoaistV3W2lcLxyPK/7LTKvq97Nm80cKpt/CwktZJ+lHhOn1fhowxsyTdIemhwrkR/V6p+K4vY8aYiKTrJT0sSdbalLV2UPR7pblZ0j5r7UHR9yWLUKO4WiV1TDg/XLiGytFkre0qHB+V1ORkMSgeY8xcSRdL2ij6vSIUpiC8JqlH0m8k7ZM0aK3NFG7hO788/aOkv5SUK5zXi36vBFbSr40xrxhj7itc47u+vM2T1Cvpa4XpZg8ZY4Ki3yvNvZK+Wzim70sUoQYwRWx+qyG2GypDxpgaST+W9IC1dnjic/R7+bLWZgtDU2cpPzJvqcMlociMMXdK6rHWvuJ0LZhy11prL1F+SvEnjDHXT3yS7/qy5JF0iaR/s9ZeLCmmU6Yb0O/lrbA+0l2Sfnjqc/R9aSHUKK5OSbMnnM8qXEPl6DbGtEhSoe1xuB5MMmOMV/lA49vW2p8ULtPvFaQwHHm9pKskzTDGeApP8Z1ffq6RdJcx5oDyU0rXKT/nnn4vc9bazkLbo/zc+svFd325OyzpsLV2Y+H8R8qHHPR75bhN0qvW2u7COX1fogg1iutlSYsKq6L7lB++9KjDNWFqPSrpQ4XjD0n6uYO1YJIV5tI/LGmHtfYLE56i38ucMSZqjJlROK6S9A7l11RZL+k9hdvo+zJjrf1ra+0sa+1c5f+f/pS19r+Ifi9rxpigMSZ0/FjSOyW9Ib7ry5q19qikDmPMksKlmyVtF/1eSf5QJ6aeSPR9yTL5kTMoFmPM7crPv3VL+qq19u8dLglFYoz5rqQbJTVI6pb0PyT9TNIPJM2RdFDSe621py4mimnKGHOtpA2SturE/Pq/UX5dDfq9jBljViu/SJhb+X8g+IG19rPGmPnK/wt+naTNkt5vrU06VymKxRhzo6S/sNbeSb+Xt0L//rRw6pH0HWvt3xtj6sV3fVkzxlyk/KLAPkntkj6iwne+6PeyVggwD0mab60dKlzjz3yJItQAAAAAAADTEtNPAAAAAADAtESoAQAAAAAApiVCDQAAAAAAMC0RagAAAAAAgGmJUAMAAAAAAExLhBoAAAAAAGBaItQAAAAAAADTEqEGAAAAAACYlv5/ArcApAnLyUgAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 1080x1440 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ynSJeoZnF6Nu",
        "colab_type": "code",
        "outputId": "661c6c84-3620-4b50-b401-7494a6052ab9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        }
      },
      "source": [
        "\n",
        "torch.save(ss_vae, \"data_pro_stazeni/SSVAE_CRNN_mII_proper_scale_lr-1e-4_75ep.pt\")\n",
        "torch.save(ss_vae.state_dict(), \"data_pro_stazeni/SSVAE_CRNN_mII_proper_scale_lr-1e-4_state_dict_75ep.pt\")\n",
        "torch.save(ss_vae.encoder_y, \"data_pro_stazeni/SSVAE_CRNN_proper_mII_scale_classifier_lr-1e-4_75ep.pt\")\n",
        "torch.save(ss_vae.encoder_y.state_dict(), \"data_pro_stazeni/SSVAE_CRNN_mII_proper_scale_classifier_lr-1e-4_state_dict_75ep.pt\")"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type SSVAE. It won't be checked for correctness upon loading.\n",
            "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
            "/usr/local/lib/python3.6/dist-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type CRNN_mII. It won't be checked for correctness upon loading.\n",
            "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
            "/usr/local/lib/python3.6/dist-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type LinAct. It won't be checked for correctness upon loading.\n",
            "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
            "/usr/local/lib/python3.6/dist-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type Encoder. It won't be checked for correctness upon loading.\n",
            "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
            "/usr/local/lib/python3.6/dist-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type VariationalLayer. It won't be checked for correctness upon loading.\n",
            "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
            "/usr/local/lib/python3.6/dist-packages/torch/serialization.py:402: UserWarning: Couldn't retrieve source code for container of type ConvTransposeDecoderOutput. It won't be checked for correctness upon loading.\n",
            "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DjWvNm5CH66Q",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "0413ad5f-37d2-48c4-cef2-8d3c3b181326"
      },
      "source": [
        "import pandas as pd\n",
        "\n",
        "df = pd.DataFrame({\"supervised_loss\":sup_loss, \"unsupervised_loss\":unsup_loss, \"classification_loss\":clf_loss,  \"test_accuracy\":test_acc})\n",
        "df.head()"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>supervised_loss</th>\n",
              "      <th>unsupervised_loss</th>\n",
              "      <th>classification_loss</th>\n",
              "      <th>test_accuracy</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>-10.465277</td>\n",
              "      <td>-36.377075</td>\n",
              "      <td>5267.040044</td>\n",
              "      <td>0.771818</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>-91.556763</td>\n",
              "      <td>-119.097994</td>\n",
              "      <td>3522.202620</td>\n",
              "      <td>0.807367</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>-122.281513</td>\n",
              "      <td>-146.629754</td>\n",
              "      <td>2892.483110</td>\n",
              "      <td>0.862297</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>-140.732433</td>\n",
              "      <td>-165.953661</td>\n",
              "      <td>2532.426473</td>\n",
              "      <td>0.873483</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>-152.574523</td>\n",
              "      <td>-173.581228</td>\n",
              "      <td>2607.831133</td>\n",
              "      <td>0.876840</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   supervised_loss  unsupervised_loss  classification_loss  test_accuracy\n",
              "0       -10.465277         -36.377075          5267.040044       0.771818\n",
              "1       -91.556763        -119.097994          3522.202620       0.807367\n",
              "2      -122.281513        -146.629754          2892.483110       0.862297\n",
              "3      -140.732433        -165.953661          2532.426473       0.873483\n",
              "4      -152.574523        -173.581228          2607.831133       0.876840"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aCK_O-WxH690",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "df.to_csv(\"data_pro_stazeni/SSVAE_CRNN_proper_scale_lr-1e-4_75ep_losses.csv\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qoh1qfPsIESS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#pred = ss_vae.encoder_y(torch.tensor(X_test).float().cuda())\n",
        "preds = []\n",
        "ss_vae.encoder_y.eval()\n",
        "with torch.no_grad():\n",
        "    for (xs, ys) in data_loaders[\"test\"]:\n",
        "        xs = xs.cuda()\n",
        "        pred = ss_vae.encoder_y(xs)\n",
        "        preds.append(np.argmax(pred.cpu().detach().numpy(), axis=1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r4DwquQQIEVN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "preds = np.hstack(preds)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rpL630VeIEew",
        "colab_type": "code",
        "outputId": "fa2029a5-6e6b-47d9-c377-8ca9146135b6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "f1_score(y_true=y_test, y_pred=preds,average=\"macro\")"
      ],
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9027716276074625"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oPvMmWXwIEdd",
        "colab_type": "code",
        "outputId": "6795929d-970e-477c-b4fd-67e3dc1c12b7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "accuracy_score(y_true=y_test, y_pred=preds)"
      ],
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9370219885277247"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wU67Kc7_IEZW",
        "colab_type": "code",
        "outputId": "6cb25ddf-8056-47a8-ace9-ffbfbe67952b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "cf1 = confusion_matrix(y_true=y_test, y_pred=preds) # x_axis = predicted, y_axis = ground_truth\n",
        "cf1"
      ],
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3988,  120,   27,  100],\n",
              "       [ 395, 9974,    6,   70],\n",
              "       [  17,    7,  434,   21],\n",
              "       [ 248,   26,   17, 1286]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BGSJcw48hgXo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}