MAGIC_02_CNNs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MAGIC AI Workshop 02 Convolutional neural networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "In this exercise, we'll build a convolutional neural network (CNN) for image classification. This is one of the original and more straightforward uses of CNNs. More complex uses include:\n",
    "\n",
    "- Semantic image segmentation\n",
    "- Image denoising or reconstruction\n",
    "- Working with video streams\n",
    "\n",
    "But all methods are based around two basic operations: \n",
    "\n",
    "- Convolution: in this step, the network learns a series of kernels or filters that transform the original image in some way. These are similar to filters that are used in standard image processing (e.g. low-pass filters), but filters are chosen by how well the transformed image maps to the outcome variable. To put this another way, these filters identify shapes or features that are important in differentiating between different outcomes\n",
    "- Max-pooling: in this step, the image resolution is transformed. In general, the resolution is halved, by aggregating groups of four pixels in a two by two window. \n",
    "\n",
    "In general, these steps are repeated several times. As this progresses, the small shapes identified in the first set of convolutions are progressively combined into larger structures. For example, a series of small curves or lines could be aggregated into a cat's eye.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Image classification\n",
    "\n",
    "The basic idea behind image classification is to link *features* of an image to a single label or class. For example, we might have a photograph of a cat, with the label `Cat` and one of a dog with the label `Dog`. The goal of the model is to identify what shapes and colors, and combination of these can help differentiate between these two classes. \n",
    "\n",
    "### Data\n",
    "\n",
    "We'll use a dataset from Kaggle (https://www.kaggle.com/moltean/fruits) containing over 90,000 images of fruits and vegetables. We'll just be using a subset of these data, and you'll need to download the zip file *fruits.zip* from the Google drive folder. I'd suggest making a new folder for this lab - move the zip file to this once it is downloaded. \n",
    "\n",
    "https://drive.google.com/drive/folders/1GMEY1fYEj1YMI__u3hU4y6agnrz3ekna?usp=drive_link\n",
    "\n",
    "Once you have unzipped the data, take a look in the *fruits* folder. This is already set up in the standard way for image classification. There are two high level folders `Training` and `Testing`, each of which contains a subset of the images. Not too surprisingly, the first will be used to train the model, and the second to test the model. Within each of these, there will be a set of folders, one per class of fruit. The name of the folders is used as the *label* for each image, and is what Tensorflow will use. \n",
    "\n",
    "- fruits\n",
    "  - Training\n",
    "    - Apple\n",
    "    - Banana\n",
    "    - ...\n",
    "  - Testing\n",
    "    - Apple\n",
    "    - Banana\n",
    "    - ...\n",
    "\n",
    "Note that this is a specific format for image classification. There are other options, for example, if you are working with continuous outcomes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup environment\n",
    "\n",
    "I'd suggest making a new virtual environment or Conda environment for this exercise:\n",
    "\n",
    "```\n",
    "conda create -name tf\n",
    "conda activate tf\n",
    "```\n",
    "\n",
    "You will need to make sure you have the following Python packages installed. Please ask if you have any issues installing these:\n",
    "\n",
    "- `numpy`\n",
    "- `pandas`\n",
    "- `matplotlib`\n",
    "- `seaborn`\n",
    "- `tensorflow`\n",
    "- `PIL` \n",
    "- `scikit-learn`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image classification\n",
    "\n",
    "### Data processing\n",
    "Let's start, as usual, by loading the libraries we'll need for the lab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/ql/nw995vq50pq3dlrxhk7mm4_40000gq/T/ipykernel_44009/1425430157.py:3: DeprecationWarning: \n",
      "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n",
      "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n",
      "but was not found to be installed on your system.\n",
      "If this would cause problems for you,\n",
      "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n",
      "        \n",
      "  import pandas as pd\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sn\n",
    "from PIL import Image               # to load images\n",
    "from IPython.display import display # to display inline images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now set the path to the folder containing the training images you downloaded. If you have any questions about setting this path, please ask. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# path to image folders\n",
    "path = \"../datafiles/fruits/\"\n",
    "train_image_files_path = path + \"Training\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can visualize any of the images using the Python image library (you'll need to install this) by joining the folder path to one of the image names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "im_file = os.path.join(train_image_files_path, \"Banana\", \"0_100.jpg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "image/png": "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",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=100x100>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "im = Image.open(im_file)\n",
    "#show image\n",
    "display(im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can try other images by changing the folder name and filename. Note that these are somewhat idealized images, with a blank white background. \n",
    "\n",
    "Next, we'll define the classes that we are going to process. There are 16 different types of fruit in the dataset, making this a multi-class classification problem. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fruits categories\n",
    "fruit_list = [\"Kiwi\", \"Banana\", \"Apricot\", \"Avocado\", \"Cocos\", \"Clementine\", \"Mandarine\", \"Orange\",\n",
    "                \"Limes\", \"Lemon\", \"Peach\", \"Plum\", \"Raspberry\", \"Strawberry\", \"Pineapple\", \"Pomegranate\"]\n",
    "# number of output classes (i.e. fruits)\n",
    "output_n = len(fruit_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The original images are 100x100 pixels. Ideally we'd use these at their full resolution, but as this is an example, we'll reduce the resolution to 20x20 to make this a bit faster to run, so we set the target size here. We'll use these values (stored in `target_size` to define the input tensor shape in the network. (A good follow-up test would be to increase this and see how much it impacts the predictions.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_width = 20\n",
    "img_height = 20\n",
    "target_size = (img_width, img_height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other dimension we need for image processing is the image depth. These are RGB images with three color channels. The input tensors then will be rank 4, with shape ($n$, 20, 20, 3), where $n$ is the number of images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "channels = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last parameter we'll set here is the batch size. This is the same parameter that we have used before to control the rate at which the network weights are updated. We'll also use this to control the number of images that are loaded into memory at any step. This is very useful if you're working on a computer with limited memory (like my old laptop)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keras has several functions to facilitate working with images. We'll start by creating an image *generator*. This acts a bit like a pipeline and will carry various pre-processing steps. These include data augmentation: simple transformations of the images to supplement the original image. We're not going to use that here, but some example code is given in the appendix to illustrate how you might use this.\n",
    "\n",
    "We'll create a generator for the training images. This will rescale each channel to a 0-1 range (the RGB channels have values between 0 and 255), and it will hold aside 30% of the training images for validation. We'll use this to check for overfitting during the training process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "# training images\n",
    "train_data_gen = ImageDataGenerator(\n",
    "    rescale = 1./255,\n",
    "    validation_split = 0.3\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next function we'll use is a *flow* function. This function controls how Keras will read in the images for any training step (i.e. any update of the network weights). There are several arguments here:\n",
    "\n",
    "- `train_image_files_path`: The path to the top-level folder containing the training images\n",
    "- `train_data_gen`: The image data generator\n",
    "- `subset`: The subset of images to use from the generator for training. As we set the `validation_size` to 0.3, this will be 1 - 0.3 = 0.7, or 70% of the images\n",
    "- `target_size`: The size for rescaling each image\n",
    "- `class_mode`: The type of label used (this will one-hot encode the labels of the images)\n",
    "- `classes`: The set of categories to use. This is the list we defined earlier and needs to match the subfolder names. If this is not included, this will use all subfolders, and create a list of labels\n",
    "- `batch_size`: The number of images to import for any update step\n",
    "- `seed`: a value to initialize the random number generator (this is only there to ensure consistent results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 5401 images belonging to 16 classes.\n"
     ]
    }
   ],
   "source": [
    "# training images\n",
    "train_image_array_gen = train_data_gen.flow_from_directory(train_image_files_path,                                                            \n",
    "                                                           target_size = target_size,\n",
    "                                                           subset = 'training',\n",
    "                                                           classes = fruit_list, \n",
    "                                                           class_mode = 'categorical',\n",
    "                                                           seed = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function will tell you how many images (and classes) it found in the folder you defined. If this is 0, go back and check the folder path you defined earlier. We'll also create a flow for the validation images. The only difference here is in the definition of the subset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2308 images belonging to 16 classes.\n"
     ]
    }
   ],
   "source": [
    "# validation images\n",
    "valid_image_array_gen = train_data_gen.flow_from_directory(train_image_files_path, \n",
    "                                                           target_size = target_size,\n",
    "                                                           subset = 'validation',\n",
    "                                                           classes = fruit_list,\n",
    "                                                           class_mode = 'categorical',\n",
    "                                                           seed = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that these flow generators contain various useful bits of information. For example, to check the number of images (we'll also use this number when training the model):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training: 5401; Valid: 2308\n"
     ]
    }
   ],
   "source": [
    "train_samples = train_image_array_gen.n\n",
    "valid_samples = valid_image_array_gen.n\n",
    "print(\"Training: %d; Valid:\" % train_samples, valid_samples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can get the number of images per class (type of fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2     345\n",
       "9     345\n",
       "10    345\n",
       "13    345\n",
       "15    345\n",
       "1     343\n",
       "4     343\n",
       "5     343\n",
       "6     343\n",
       "8     343\n",
       "12    343\n",
       "14    343\n",
       "7     336\n",
       "0     327\n",
       "11    313\n",
       "3     299\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.Series(train_image_array_gen.classes).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which suggest this is a relatively well-balanced dataset. This generator also contains various information about the files, resolution, channels, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model definition\n",
    "\n",
    "Let's now set up the model. As this is quite a complex model, we'll do this as a series of steps rather than in one go. First, import all the modules from Keras that we'll need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import (Conv2D,\n",
    "                          Dense,\n",
    "                          ReLU,LeakyReLU,\n",
    "                          BatchNormalization, \n",
    "                          MaxPooling2D, \n",
    "                          Dropout,\n",
    "                          Flatten)\n",
    "from tensorflow.keras.optimizers import RMSprop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, create a template sequential model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we add the first hidden layer. This is a convolutional layer, where we'll create 16 filters (or convolutions) based on the original images, with a 3x3 kernel. We'll pad the output of this layer so that it has the same size as the input (`same`). Note that we also need to define the size of the input tensors (width, height and channels). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(Conv2D(filters = 16, kernel_size = (3,3), padding = 'same', \n",
    "           input_shape = (img_width, img_height, channels)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll then take the output of this layer and pass it through a ReLU activation function (this could have been included directly in the convolutional layer, but this allows a little more control on the process):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(ReLU())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we add a max-pooling layer. As a reminder, this reduces the resolution of the output from the previous layer by a simple filter, forcing the next layer of the network to focus on larger image features. We'll also add a dropout layer. This is a form of regularization. It randomly sets some connection weights to 0 (i.e. having no contribution to the model), which can reduce overfitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(MaxPooling2D(pool_size = (2,2)))\n",
    "model.add(Dropout(.25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add another convolutional layer, this time with 32 filters, and pass this through a different activation function (a leaky ReLU)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(Conv2D(filters = 32, kernel_size = (3,3), padding = 'same', \n",
    "           input_shape = (img_width, img_height, channels)))\n",
    "model.add(LeakyReLU(0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll take the output of this function and normalize the weights. This is a simple method that adjusts the mean weight to close to zero and reduces the amount variation. This helps avoid gradient problems with very small or very large weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(BatchNormalization())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we'll run the output of this through a max-pooling function with dropout:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(MaxPooling2D(pool_size = (2,2)))\n",
    "model.add(Dropout(.25))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll add layers to connect the output of this last max-pooling step to the output (the fruit classes). The first thing we need to do is to flatten the output. The output of the max-pooling is a tensor of shape (5, 5, 32). The size of 5 is a result of the two max-pooling operations and the 32 is the number of filters from the second convolution. The `Flatten()` function will flatten this into a rank 1 tensor of shape (800). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(Flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we'll pass this flattened layer through a dense layer, with a ReLU activation and a dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(Dense(units = 100))\n",
    "model.add(ReLU())\n",
    "model.add(Dropout(.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we need to output predictions. As this is a multiclass task, the final layer needs to have the same number of nodes as classes (16). This is passed through a softmax activation function. This transforms the predictions for all classes into probabilities (i.e. they have to sum to 1). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.add(Dense(units = output_n, activation = 'softmax'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More practically, we'll create a function that will build the model in one go. This will allow us to easily create new versions for testing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model():\n",
    "    model = Sequential([   \n",
    "        Conv2D(filters = 16, kernel_size = (3,3), padding = 'same', \n",
    "            input_shape = (img_width, img_height, channels), activation = 'relu'),\n",
    "        ReLU(),\n",
    "        MaxPooling2D(pool_size = (2,2)),\n",
    "        Conv2D(filters = 32, kernel_size = (3,3), padding = 'same'),\n",
    "        LeakyReLU(.5),\n",
    "        BatchNormalization(),\n",
    "        MaxPooling2D(pool_size = (2,2)),\n",
    "        Dropout(.25),\n",
    "        Flatten(),\n",
    "        Dense(units = 100),\n",
    "        ReLU(),\n",
    "        Dropout(.5),\n",
    "        Dense(units = output_n, activation = 'softmax')\n",
    "    ])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the whole thing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_2 (Conv2D)           (None, 20, 20, 16)        448       \n",
      "                                                                 \n",
      " re_lu_2 (ReLU)              (None, 20, 20, 16)        0         \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPoolin  (None, 10, 10, 16)        0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 10, 10, 32)        4640      \n",
      "                                                                 \n",
      " leaky_re_lu_1 (LeakyReLU)   (None, 10, 10, 32)        0         \n",
      "                                                                 \n",
      " batch_normalization_1 (Bat  (None, 10, 10, 32)        128       \n",
      " chNormalization)                                                \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPoolin  (None, 5, 5, 32)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 5, 5, 32)          0         \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 800)               0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 100)               80100     \n",
      "                                                                 \n",
      " re_lu_3 (ReLU)              (None, 100)               0         \n",
      "                                                                 \n",
      " dropout_4 (Dropout)         (None, 100)               0         \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 16)                1616      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 86932 (339.58 KB)\n",
      "Trainable params: 86868 (339.33 KB)\n",
      "Non-trainable params: 64 (256.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = create_model()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model has a little under 87,000 parameters or weights to train (hence the need for a lot of images). Note that there are small set of non-trainable parameter from the normalization layer. \n",
    "\n",
    "We can also generate a simple visualization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.keras.utils import plot_model\n",
    "plot_model(model, show_shapes=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to compile the model. This asss an optimization function, a loss function and performance metric. A good option for the loss function is `categorical_crossentropy`, which tries to maximize the difference between the distribution of multiple categories, and we'll use a backpropagation optimizer. The metric is the error between the predicted class and observed class aggregated across all samples. Accuracy is sthe simplest of these for classification exercises and gives the proportion of all images that are correctly classified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.RMSprop` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.RMSprop`.\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss = 'categorical_crossentropy', \n",
    "              metrics = ['accuracy'], \n",
    "              optimizer = RMSprop())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the model\n",
    "\n",
    "We'll now train the model for 20 epochs. As we are using a data generator function to supply the images and data to the model, we use the `fit()` method. We specify:\n",
    "\n",
    "- `train_image_array_gen`: The generator of the training samples\n",
    "- `steps_per_epoch`: The number of update steps in each epoch (usually just number of samples / batch size)\n",
    "- `epochs`: number of full training iterations\n",
    "- `validation_data`: the generator of the validation samples\n",
    "- `validation_steps`: the number of validation steps per epoch\n",
    "\n",
    "This takes a few minutes to train (on my laptop). It's worth remembering what is going on here: the algorithm is reading in batches of 32 images, rescaling them, updating model weights through back propagation and then repeating the whole thing 20 times. As we previously defined a separate validation set (and image generator), this routine will calculate two losses:\n",
    "- The training loss. This is how accurately the model can predict the images that are being used to update the weights\n",
    "- The validation loss. This is how accurately the model can predict a set of training images that are not used in updating the weights\n",
    "\n",
    "As the model continues to train, you should see the loss (the crossentropy) decrease for both of these, but will likely stabilize at a certain point. The accuracy should (hopefully) increase over time. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "168/168 [==============================] - 4s 20ms/step - loss: 1.0198 - accuracy: 0.6735 - val_loss: 1.3011 - val_accuracy: 0.9358\n",
      "Epoch 2/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.1767 - accuracy: 0.9404 - val_loss: 0.3825 - val_accuracy: 0.9753\n",
      "Epoch 3/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0875 - accuracy: 0.9724 - val_loss: 0.0237 - val_accuracy: 0.9983\n",
      "Epoch 4/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0599 - accuracy: 0.9788 - val_loss: 0.0082 - val_accuracy: 1.0000\n",
      "Epoch 5/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.0404 - accuracy: 0.9871 - val_loss: 0.0027 - val_accuracy: 1.0000\n",
      "Epoch 6/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0370 - accuracy: 0.9879 - val_loss: 0.1719 - val_accuracy: 0.9488\n",
      "Epoch 7/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0234 - accuracy: 0.9924 - val_loss: 0.0017 - val_accuracy: 1.0000\n",
      "Epoch 8/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0235 - accuracy: 0.9911 - val_loss: 0.0138 - val_accuracy: 0.9948\n",
      "Epoch 9/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0178 - accuracy: 0.9939 - val_loss: 0.0055 - val_accuracy: 0.9996\n",
      "Epoch 10/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0144 - accuracy: 0.9946 - val_loss: 0.4734 - val_accuracy: 0.8672\n",
      "Epoch 11/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0185 - accuracy: 0.9939 - val_loss: 0.0015 - val_accuracy: 1.0000\n",
      "Epoch 12/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0096 - accuracy: 0.9968 - val_loss: 0.0467 - val_accuracy: 0.9900\n",
      "Epoch 13/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.0184 - accuracy: 0.9937 - val_loss: 0.0050 - val_accuracy: 0.9978\n",
      "Epoch 14/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0098 - accuracy: 0.9970 - val_loss: 0.1145 - val_accuracy: 0.9835\n",
      "Epoch 15/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.0115 - accuracy: 0.9963 - val_loss: 0.0197 - val_accuracy: 0.9935\n",
      "Epoch 16/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0117 - accuracy: 0.9966 - val_loss: 3.8962e-04 - val_accuracy: 1.0000\n",
      "Epoch 17/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0089 - accuracy: 0.9970 - val_loss: 9.0967e-04 - val_accuracy: 1.0000\n",
      "Epoch 18/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0072 - accuracy: 0.9978 - val_loss: 1.9157e-04 - val_accuracy: 1.0000\n",
      "Epoch 19/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0082 - accuracy: 0.9970 - val_loss: 4.4807e-04 - val_accuracy: 1.0000\n",
      "Epoch 20/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0069 - accuracy: 0.9976 - val_loss: 0.0108 - val_accuracy: 0.9948\n"
     ]
    }
   ],
   "source": [
    "epochs = 20\n",
    "hist = model.fit(\n",
    "  # training data\n",
    "  train_image_array_gen,\n",
    "\n",
    "  # epochs\n",
    "  steps_per_epoch = train_samples // batch_size, \n",
    "  epochs = epochs, \n",
    "\n",
    "  # validation data\n",
    "  validation_data = valid_image_array_gen,\n",
    "  validation_steps = valid_samples // batch_size,\n",
    "\n",
    "  # print progress\n",
    "  verbose = 1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now plot the evolution of the loss function and performance metric:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_loss(hist_obs):\n",
    "    plt.plot(hist_obs.history['loss'], label='train')\n",
    "    plt.plot(hist_obs.history['val_loss'], label='valid')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "plot_loss(hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot shows a steep decline in both loss values, but no real improvement beyond epoch 3. It's quite likely that this model has overfit - become too tuned to the training data to allow prediction. There are a variety of ways we can avoid this, but a simple one is to slow the rate at which the model learns. We'll refit the model, but will add a `learning_rate` parameter to the compilation step. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.RMSprop` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.RMSprop`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "168/168 [==============================] - 2s 12ms/step - loss: 2.5932 - accuracy: 0.2121 - val_loss: 2.4861 - val_accuracy: 0.3533\n",
      "Epoch 2/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 1.6930 - accuracy: 0.4433 - val_loss: 1.6954 - val_accuracy: 0.8906\n",
      "Epoch 3/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 1.1443 - accuracy: 0.6167 - val_loss: 0.7223 - val_accuracy: 0.9336\n",
      "Epoch 4/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.8314 - accuracy: 0.7256 - val_loss: 0.3446 - val_accuracy: 0.9392\n",
      "Epoch 5/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.5949 - accuracy: 0.8059 - val_loss: 0.1861 - val_accuracy: 0.9627\n",
      "Epoch 6/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.4312 - accuracy: 0.8586 - val_loss: 0.1230 - val_accuracy: 0.9753\n",
      "Epoch 7/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.3327 - accuracy: 0.8922 - val_loss: 0.0815 - val_accuracy: 0.9787\n",
      "Epoch 8/20\n",
      "168/168 [==============================] - 2s 12ms/step - loss: 0.2437 - accuracy: 0.9216 - val_loss: 0.0560 - val_accuracy: 0.9848\n",
      "Epoch 9/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.1943 - accuracy: 0.9402 - val_loss: 0.0528 - val_accuracy: 0.9900\n",
      "Epoch 10/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.1553 - accuracy: 0.9549 - val_loss: 0.0421 - val_accuracy: 0.9835\n",
      "Epoch 11/20\n",
      "168/168 [==============================] - 2s 12ms/step - loss: 0.1420 - accuracy: 0.9559 - val_loss: 0.0323 - val_accuracy: 0.9913\n",
      "Epoch 12/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.1083 - accuracy: 0.9704 - val_loss: 0.0237 - val_accuracy: 0.9983\n",
      "Epoch 13/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0943 - accuracy: 0.9700 - val_loss: 0.0252 - val_accuracy: 0.9905\n",
      "Epoch 14/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0832 - accuracy: 0.9739 - val_loss: 0.0160 - val_accuracy: 1.0000\n",
      "Epoch 15/20\n",
      "168/168 [==============================] - 2s 10ms/step - loss: 0.0683 - accuracy: 0.9832 - val_loss: 0.0151 - val_accuracy: 0.9987\n",
      "Epoch 16/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0574 - accuracy: 0.9831 - val_loss: 0.0145 - val_accuracy: 0.9983\n",
      "Epoch 17/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.0617 - accuracy: 0.9817 - val_loss: 0.0095 - val_accuracy: 1.0000\n",
      "Epoch 18/20\n",
      "168/168 [==============================] - 2s 11ms/step - loss: 0.0508 - accuracy: 0.9836 - val_loss: 0.0072 - val_accuracy: 1.0000\n",
      "Epoch 19/20\n",
      "168/168 [==============================] - 2s 9ms/step - loss: 0.0421 - accuracy: 0.9853 - val_loss: 0.0095 - val_accuracy: 0.9991\n",
      "Epoch 20/20\n",
      "168/168 [==============================] - 2s 15ms/step - loss: 0.0425 - accuracy: 0.9883 - val_loss: 0.0105 - val_accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "model = create_model()\n",
    "\n",
    "model.compile(loss = 'categorical_crossentropy', \n",
    "              metrics = ['accuracy'], \n",
    "              optimizer = RMSprop(learning_rate=1e-4))\n",
    "hist = model.fit(\n",
    "  # training data\n",
    "  train_image_array_gen,\n",
    "\n",
    "  # epochs\n",
    "  steps_per_epoch = train_samples // batch_size, \n",
    "  epochs = epochs, \n",
    "\n",
    "  # validation data\n",
    "  validation_data = valid_image_array_gen,\n",
    "  validation_steps = valid_samples // batch_size,\n",
    "\n",
    "  # print progress\n",
    "  verbose = 1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss(hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot now shows a good evolution of both the loss and performance metrics. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model evaluation\n",
    "\n",
    "We'll now evaluate this model on the set of test images. Normally, we'd retrain the model using the full training set (including the validation set), but to save time, we'll just proceed with the existing model. In order to do this, we first need to create a new image generator for the test images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2592 images belonging to 16 classes.\n"
     ]
    }
   ],
   "source": [
    "test_image_files_path = path + \"Test\"\n",
    "# test images\n",
    "test_data_gen = ImageDataGenerator(\n",
    "    rescale = 1./255\n",
    ")\n",
    "test_image_array_gen = test_data_gen.flow_from_directory(test_image_files_path, \n",
    "                                                         target_size = target_size,\n",
    "                                                         classes = fruit_list,\n",
    "                                                         class_mode = 'categorical',\n",
    "                                                         shuffle = False,\n",
    "                                                         seed = 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The only differences here from the previous code is that we use the test image folder, and we no longer specify a validation parameter. Now we can use this to evaluate the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81/81 [==============================] - 1s 9ms/step - loss: 0.0084 - accuracy: 0.9996\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = model.evaluate(test_image_array_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-entropy loss: 0.0084\n",
      "Accuracy: 0.9996\n"
     ]
    }
   ],
   "source": [
    "print('Cross-entropy loss: %.4f'\n",
    "      % test_loss)\n",
    "print('Accuracy: %.4f'\n",
    "      % test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Which gives us an accuracy of close to 1, which is a very good classifier. It is worth noting that this is partly because the images have all been cleaned and prepared; achieving this level of accuracy with images take 'in the wild' would require much more work in setting up and training the model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicting classes\n",
    "\n",
    "We'll finish by obtaining predictions for the set of test images, and building a confusion matrix based on these. Predictions for new samples can be obtained using the `predict()` function. Note that if you were predicting for completely new images, you would need to make a new generator for these. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81/81 [==============================] - 1s 10ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(2592, 16)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_pred = model.predict(test_image_array_gen)\n",
    "test_pred.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each image, there is the predicted probability of each class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9.9778688e-01, 7.8940531e-07, 3.7481252e-07, 1.2876804e-06,\n",
       "       5.7829893e-04, 1.1953901e-07, 9.7590491e-06, 4.3785747e-08,\n",
       "       4.5130513e-05, 1.5211769e-03, 4.1794861e-05, 2.1177412e-07,\n",
       "       1.2214842e-07, 2.7495994e-06, 7.5978114e-06, 3.6886208e-06],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_pred[0,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.imshow(train_images[0], cmap=plt.cm.binary)\n",
    "plt.colorbar()\n",
    "plt.grid(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the predicted labels, we simply need to find the column with the highest probability. We can use Numpy's `argmax()` function for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_pred = np.argmax(test_pred, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The test generator stores the observed labels for the test set, so let's extract that and store it as `obs_class`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_obs = test_image_array_gen.classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now make a confusion matrix between the observed and predicted classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[156,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0, 166,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0, 164,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0, 143,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0, 166,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0, 166,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0, 166,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0, 160,   0,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0, 166,   0,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0, 164,   0,   0,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 163,   0,   0,\n",
       "          0,   0,   1],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 151,   0,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 166,\n",
       "          0,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "        164,   0,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0, 166,   0],\n",
       "       [  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,\n",
       "          0,   0, 164]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "confusion_matrix(test_obs, test_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the row and column indices are integer values due to the numeric representaiton of the classes in the model. We can simply replace these with the fruit labels and make a DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "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>Kiwi</th>\n",
       "      <th>Banana</th>\n",
       "      <th>Apricot</th>\n",
       "      <th>Avocado</th>\n",
       "      <th>Cocos</th>\n",
       "      <th>Clementine</th>\n",
       "      <th>Mandarine</th>\n",
       "      <th>Orange</th>\n",
       "      <th>Limes</th>\n",
       "      <th>Lemon</th>\n",
       "      <th>Peach</th>\n",
       "      <th>Plum</th>\n",
       "      <th>Raspberry</th>\n",
       "      <th>Strawberry</th>\n",
       "      <th>Pineapple</th>\n",
       "      <th>Pomegranate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Kiwi</th>\n",
       "      <td>156</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Banana</th>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Apricot</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>164</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Avocado</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>143</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cocos</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Clementine</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Mandarine</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Orange</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>160</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Limes</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lemon</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>164</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Peach</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>163</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Plum</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>151</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Raspberry</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Strawberry</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>164</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Pineapple</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>166</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Pomegranate</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>164</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Kiwi  Banana  Apricot  Avocado  Cocos  Clementine  Mandarine  \\\n",
       "Kiwi          156       0        0        0      0           0          0   \n",
       "Banana          0     166        0        0      0           0          0   \n",
       "Apricot         0       0      164        0      0           0          0   \n",
       "Avocado         0       0        0      143      0           0          0   \n",
       "Cocos           0       0        0        0    166           0          0   \n",
       "Clementine      0       0        0        0      0         166          0   \n",
       "Mandarine       0       0        0        0      0           0        166   \n",
       "Orange          0       0        0        0      0           0          0   \n",
       "Limes           0       0        0        0      0           0          0   \n",
       "Lemon           0       0        0        0      0           0          0   \n",
       "Peach           0       0        0        0      0           0          0   \n",
       "Plum            0       0        0        0      0           0          0   \n",
       "Raspberry       0       0        0        0      0           0          0   \n",
       "Strawberry      0       0        0        0      0           0          0   \n",
       "Pineapple       0       0        0        0      0           0          0   \n",
       "Pomegranate     0       0        0        0      0           0          0   \n",
       "\n",
       "             Orange  Limes  Lemon  Peach  Plum  Raspberry  Strawberry  \\\n",
       "Kiwi              0      0      0      0     0          0           0   \n",
       "Banana            0      0      0      0     0          0           0   \n",
       "Apricot           0      0      0      0     0          0           0   \n",
       "Avocado           0      0      0      0     0          0           0   \n",
       "Cocos             0      0      0      0     0          0           0   \n",
       "Clementine        0      0      0      0     0          0           0   \n",
       "Mandarine         0      0      0      0     0          0           0   \n",
       "Orange          160      0      0      0     0          0           0   \n",
       "Limes             0    166      0      0     0          0           0   \n",
       "Lemon             0      0    164      0     0          0           0   \n",
       "Peach             0      0      0    163     0          0           0   \n",
       "Plum              0      0      0      0   151          0           0   \n",
       "Raspberry         0      0      0      0     0        166           0   \n",
       "Strawberry        0      0      0      0     0          0         164   \n",
       "Pineapple         0      0      0      0     0          0           0   \n",
       "Pomegranate       0      0      0      0     0          0           0   \n",
       "\n",
       "             Pineapple  Pomegranate  \n",
       "Kiwi                 0            0  \n",
       "Banana               0            0  \n",
       "Apricot              0            0  \n",
       "Avocado              0            0  \n",
       "Cocos                0            0  \n",
       "Clementine           0            0  \n",
       "Mandarine            0            0  \n",
       "Orange               0            0  \n",
       "Limes                0            0  \n",
       "Lemon                0            0  \n",
       "Peach                0            1  \n",
       "Plum                 0            0  \n",
       "Raspberry            0            0  \n",
       "Strawberry           0            0  \n",
       "Pineapple          166            0  \n",
       "Pomegranate          0          164  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm = confusion_matrix(test_obs, test_pred)\n",
    "\n",
    "df_cm = pd.DataFrame(cm, index = [i for i in fruit_list],\n",
    "                  columns = [i for i in fruit_list])\n",
    "df_cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows why we got such a high accuracy - nearly all the images are correctly classified. Let's finish by plotting this result using Seaborn's `heatmap()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAAKVCAYAAAD822vkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeZxO5f/H8dc9+z5mMauxZUuWrCUlQvYlZSlE+YoKWcMPochStsiSMCpbCUmlUJQsWbImpEWYxZixzBiz3r8/5OZu3GPmpplj5v18PM6jmeuc+zrvc59mzHV/rnOOyWw2mxEREREREZEsHPI7gIiIiIiIiFFpwCQiIiIiImKDBkwiIiIiIiI2aMAkIiIiIiJigwZMIiIiIiIiNmjAJCIiIiIiYoMGTCIiIiIiIjZowCQiIiIiImKDU34HkNuXcnhTfkewybPas/kdQURERCTfpaeezu8INqXF/Z5n+3IOLJ1n+7pTVGESERERERGxQRUmEREREZHCLDMjvxMYmipMIiIiIiIiNqjCJCIiIiJSmJkz8zuBoanCJCIiIiIiYoMqTCIiIiIihVmmKkzZUYVJRERERETEBg2YREREREREbNCUPBERERGRQsysmz5kSxUmERERERERGzRgusO6d+9O27Zt7XptZGQkRYoUuaN5RERERESylZmZd8tdSAOmXLrZgGjlypW4ubkxefJkZsyYQWRkpF19d+zYkWPHjlm17dq1i969e/Pwww9Tvnx5Nm7ceMt+UtPSeGfJZzR5YSQ1OvSj+YuvsXrTNrsy5dSxv07z3Mip1Or0Co3+N5y5H3+J2Wy2rPf0cCQ0xI2SxT0pVcKT8FB33N0dc9R3717dOH50O4kXT7Bzx1c8XLf2f3UYuaZs9jFqNqPmAmWzl1GzGTUXKJu9jJrNqLlA2eTuoQHTbXr//ffp3Lkzs2bN4tVXX8XX19fuKpG7uztBQUFWbZcvX6Z8+fK89tprOe5n8NsL2HngKGNf7sLaWaOZNPB5SoUH25UJ4HTsOaq0e8nm+sTLyfQaO5Oi/kVYOmkow/7XgcWfbeSDtZss27i5OZKcnEFUdDKnTl8m+UoGocFuuLhk/79g+/atmTplDBMmvkPN2k3YuvUn1n3+ERERYXYfz52ibAUrm1FzKVvBy2bUXMpW8LIZNZeyGZA5M++Wu5DJfGMZQG6pe/funD9/njVr1jB58mRee+01lixZwpNPPpll/eeff07Xrl2Jj4/HwcGBffv2Ua1aNQYPHsxbb70FQK9evbh48SLLli0jMjKS/v37c/78+Zvuu3z58rz77rs0atTIqj3l8PWByda9hxk6dSFfznkdX29Pm8exZtN2Fq35htOx5wgLCuCZ5vXp1OzRm257OvYczXqP4sCq2Tddv2L997zz0Wd8t2giLs7OACxY9TXLvtzM9j2nbWaICHcnMSmdhPNpNrfZtvVz9v58iD59h1vaDh7YzNq16xkxcqLN1+UFZbOPUbMZNRcom72Mms2ouUDZ7GXUbEbNBYUzW3qq7b+J8lvq3/vzbF8uEVXzbF93iipMdho2bBhvvPEG69atswyW/q1evXpcunSJn3/+GYAtW7YQGBjIli1bLNts3ryZRx+9+UDFHpt3HaBimeIsWrOBRv8bTquXx/B25KdcSUm1bLNyw1ZmLl1L386tWfPOa/Tr3Jp3l63js+922LXP/Ud/p8Z9ZS2DJYCH7q9IbPwFnJxMNl9ncjCRkWG7X2dnZ6pXr8KGjVus2jds2EKdB2valfVOUTb7GDWbUXOBstnLqNmMmguUzV5GzWbUXKBshpSZkXfLXUgDJjt89dVXTJo0ic8++yxLtedGvr6+3H///WzevBm4OjgaMGAA+/fv59KlS0RHR3Ps2DHq16+f432npaVx8eJFqyUl9fpg6FTMOX4+coLfTp5h2tBevPr8U2zc/jNvzl9h2ea9T75iUPd2NHqwGsWCA2n0YDW6tnqMld/8kOv3AuDc+YsEFPG2arv2vaPjzQdMRXydcTCZSEpKt9lvYKA/Tk5OxMbEWbXHxsYRHBJk41V5Q9nsY9RsRs0FymYvo2Yzai5QNnsZNZtRc4GySc59//33tGrVirCwMEwmE2vWrMmyzZEjR2jdujW+vr54e3vz4IMPcvLkScv6lJQU+vbtS2BgIJ6enrRu3ZpTp07lKoeew2SHKlWqEBcXx2uvvUatWrXw9va2uW39+vXZvHkzAwcO5IcffmDcuHF8+umnbN26lfPnzxMcHEyFChVyvO9PP/2U5s2bW7WNeLEro17uBly9j77JZGJC/+fw9nQHYPBzTzLorff5v54duXwlhei4BMa8+xFj5yy19JGRkYGXh7vl+ydeeYMzZ+P/6fPqrM0HnhlgWR9W1J/VM0ZZvjdhPTDKbqKnl6cTfkVciI65QkbmrWeE/nvWqMlkytKWX5TNPkbNZtRcoGz2Mmo2o+YCZbOXUbMZNRcom6EY9NqipKQkqlatynPPPXfTGV0nTpzg4YcfpkePHowdOxZfX1+OHDmCm5ubZZv+/fvz+eefs3z5cgICAhg0aBAtW7Zkz549ODrm7AZkGjDZITw8nE8//ZQGDRrQtGlT1q9fb3PQVL9+fRYsWMD+/ftxcHCgYsWKPProo2zZsoWEhIRcT8d78sknmTp1qnXjiR8tXwb6+RLkX8QyWAIoXSwEs9lMzLnzeHlc/R9o9IudqVyupFU3Dg7XC47vjniJ9H/my8XGn+f5UdP5ZMr1ubxON/wPFlDEh7jzF636ir9wCYCMDOtfLp6eThQNdCUm9grJV7Ivy8bFxZOenk5wSFGr9qJFA4iNOZvta/9rymYfo2Yzai5QNnsZNZtRc4Gy2cuo2YyaC5RNcq5Zs2Y0a9bM5voRI0bQvHlzJk+ebGkrXbq05esLFy6wYMECPvzwQ8ussI8++oiIiAg2btxIkyZNcpRDU/LsVLx4cbZs2UJsbCyPP/44Fy9evOl2165jmj59Oo8++igmk4lHH32UzZs323X9krOzMz4+PlaLq4uLZX21CvdwNv48l5OvWNr+OhOLg4OJ4IAiBBTxIci/CKdi4igeGmS1FAsOtLwmLCjA0h5aNODqMd+wbVhQgGXbquVLs+eX46SlXZ9et33fEYL8fUlPvz5g8vJ0IijQlZizV7icfOs5rGlpaezde4BGDetZtTdqVI/tO3bn4l2785TNPkbNZtRcoGz2Mmo2o+YCZbOXUbMZNRcomyHl4XOYUlJSsl5ekpJiR+RMvvjiC8qVK0eTJk0ICgrigQcesJq2t2fPHtLS0nj88cctbWFhYVSqVIlt23L+yB0NmG5DsWLF2Lx5M+fOnePxxx/nwoULWba5dh3TRx99ZLlWqV69euzduzdH1y8lJSVx5MgRjhw5AsCpU6c4cuQIZ86cAWDKlCn834xIy/bNH6mJr7cno2Z9yIm/o9h9+DhTF6+m7WMP4eZ6dWD1YscWLFj1NR+t+5Y/z8Rw7K/TrNm03eo24LnR/JFauDg7M3LWBxz/6wybduzj/VXr6dqqoWUbL08ngoq6ci4+hZSUTBwdTTg6mnCwfU8IAKbNmE+P55+me7eOVKhQhilvjaF4RDjz3vvQrqx3krIVrGxGzaVsBS+bUXMpW8HLZtRcyla4TZgwAV9fX6tlwoQJue4nNjaWxMREJk6cSNOmTfnmm2944oknaNeuneUGa9HR0bi4uODn52f12uDgYKKjo3O8L03Ju03h4eFs2bKFBg0a0LhxY8LCst6jv0GDBuzdu9cyOPLz86NixYqcOXOGe++9N9v+Dx06xLPPPmv5/tr/UE888QQTJ07k7NmzRMclWNZ7uLvx3uh+THj/Y54eMhFfb0+aPFSDPs+0smzzZOO6uLm6sPizDUz7YA3ubi6ULR5Gl5aP2fUeeHu6M290X96cv4KnX52Ij6cHXVs15NnWDXlpzAcA+Hg7YzKZKBroxo1F7ouX0jgbZ/tThU8+WUuAvx8jRwwgNDSIQ4eP0qp1V06ezP9bcypbwcpm1FzKVvCyGTWXshW8bEbNpWzGY87Da5iGDx/OwIEDrdpcXV1z3U9m5tXMbdq0YcCAq9fZ33///Wzbto25c+dmO4vLbDZjMt3iU/sb6DlMBcCNz2EyGs9qz956IxEREZECzsjPYUo5Yd+jZezhes+Ddr3OZDKxevVq2rZtC0Bqaiqenp6MHj2akSNHWrYbOnQoW7du5ccff+Tbb7+lYcOGxMfHW1WZqlatStu2bRk7dmyO9q0peSIiIiIihVkeXsN0p7i4uFCrVi2OHj1q1X7s2DFKlCgBQI0aNXB2dmbDhg2W9VFRURw6dIiHHnoox/vSlDwRERERETGcxMREfvvtN8v3f/zxB/v27cPf35/ixYszZMgQOnbsSL169WjQoAHr16/n888/tzwD1dfXlx49ejBo0CACAgLw9/dn8ODBVK5cOdtnqf6bBkwiIiIiIoWZQZ/DtHv3bho0aGD5/tq1T926dSMyMpInnniCuXPnMmHCBPr160f58uX59NNPefjhhy2vmTZtGk5OTnTo0IHk5GQaNmxIZGRkjp/BBLqGqUDQNUwiIiIixmboa5iObc2zfbmWe/jWGxmMrmESERERERGxQVPyREREREQKs8yM/E5gaKowiYiIiIiI2KAKk4iIiIhIYWbQmz4YhSpMIiIiIiIiNqjCJCIiIiJSmN3BB8oWRKowiYiIiIiI2KAKUwFg5GcdJZ/5Ib8j3JR72CP5HUFERETEGHQNU7ZUYRIREREREbFBFSYRERERkcJM1zBlSxUmERERERERG1RhEhEREREpxMzmjPyOYGiqMImIiIiIiNigCpOIiIiISGGmu+RlSxUmERERERERG1RhEhEREREpzHSXvGypwiQiIiIiImKDKkwiIiIiIoWZrmHKlipMIiIiIiIiNhS4AVP37t0xmUyWJSAggKZNm3LgwIH8jmZ4vXt14/jR7SRePMHOHV/xcN3aNrd1c3MgJNiNEhEe3FPKCw8Px2z7HjFuCpXqNsuytOnc604fhpVjJ/6g+8tDqNGgDY+16cKchUswm82W9Z4ejoSGuFGyuCelSngSHuqOu3v2x3Kj3LxneU3Zcs+ouUDZ7GXUbEbNBcpmL6NmM2ouUDZDyczIu+UuVOAGTABNmzYlKiqKqKgoNm3ahJOTEy1btszvWIbWvn1rpk4Zw4SJ71CzdhO2bv2JdZ9/RERE2E23dzCZSE3NJO5cSo76H9a/N5vXLrEsG1d/gK+PN48/9ojdmU9HxVCpbjOb6xOTkujZfwRFAwNYvmAGwwe8SOSyT1m8fJVlGzc3R5KTM4iKTubU6cskX8kgNNgNF5db/2jk9j3LS8pWcHIpW8HLZtRcylbwshk1l7LJ3cZkvvHj9gKge/funD9/njVr1ljafvjhB+rVq0dsbCxFixZl6NChrF69mlOnThESEkLnzp157bXXcHZ2BmDMmDGsWbOGQYMGMWrUKBISEmjWrBnz58/H29sbgPXr1zNu3DgOHTqEo6MjderUYcaMGdxzzz0A/Pnnn5QqVYpPP/2UmTNnsnPnTsqWLcvcuXOpU6cOAOfOnaNPnz788MMPxMfHc8899/B///d/PP3007k6ZieX8Nt+37Zt/Zy9Px+iT9/hlraDBzazdu16RoycmO1r7ynlRVRMMpcvZ/3UIPnMDzd9zabvt9H//8bx9cpFhIUEW9pXf/ENC5es5HRUNOEhwXRu34ZO7W4+2D0dFUOTp7pz6Mevbrp++ep1zJgbyZbPl+Li4gLA+x9+zNKVa9m+6y+bxxMR7k5iUjoJ59NsbgO3957915St4OQCZbOXUbMZNRcom72Mms2ouaBwZktPPX0n4v0nruz6NM/25VbryTzb151SICtMN0pMTGTJkiWUKVOGgIAAALy9vYmMjOSXX35hxowZzJ8/n2nTplm97sSJE6xZs4Z169axbt06tmzZwsSJ139IkpKSGDhwILt27WLTpk04ODjwxBNPkPmv2zKOGDGCwYMHs2/fPsqVK8fTTz9Neno6AFeuXKFGjRqsW7eOQ4cO8cILL9C1a1d27tz5H78r1pydnalevQobNm6xat+wYQt1Hqz5n+xz1bqvebDm/VaDpZVrv+KdeYvp90I31i55j369ujNz/gd89uUGu/ax/9Cv1Ly/smWwBFD3gerExp3Dyclk83UmBxMZt6gY58d7llPKlntGzQXKZi+jZjNqLlA2exk1m1FzgbIZkjkz75a7UIG8S966devw8vICrg5sQkNDWbduHQ4OV8eHI0eOtGxbsmRJBg0axIoVK3j11Vct7ZmZmURGRloqSl27dmXTpk2MHz8egCeftB4dL1iwgKCgIH755RcqVapkaR88eDAtWrQAYOzYsdx333389ttvVKhQgfDwcAYPHmzZtm/fvqxfv55PPvmEBx544KbHlpKSQkqK9TQ4s9mMyWR7AHArgYH+ODk5ERsTZ9UeGxtHcEiQ3f3acjYunq07djNp9FCr9rmRyxjStyeN69cFoFhYCL//eZKPP/uKNs0b53o/cefiCQ8NtmoL8PMDwNHRRHp61uJqEV9nHEwmkpLSs+07r9+z3FC23DNqLlA2exk1m1FzgbLZy6jZjJoLlE3uPgVywNSgQQPmzJkDQHx8PLNnz6ZZs2b89NNPlChRgpUrVzJ9+nR+++03EhMTSU9Px8fHx6qPkiVLWgZLAKGhocTGxlq+P3HiBKNGjWLHjh3ExcVZKksnT560GjBVqVLFqg+A2NhYKlSoQEZGBhMnTmTFihWcPn3aMhjy9PS0eWwTJkxg7NixVm0mBy9Mjj42XpFz/56daTKZsrTdCWu+3IC3lxcN69WxtMUnnCc65iyvTZjO6EkzLO0ZGRl43fB+tOncizMxsdcCA1Cr0ROW9WHBQXy2ZJ7VMdzIjO3j8fJ0wq+IC9ExV8jIzNlx59V7Zg9lyz2j5gJls5dRsxk1FyibvYyazai5QNkMRQ+uzVaBHDB5enpSpkwZy/c1atTA19eX+fPn07JlSzp16sTYsWNp0qQJvr6+LF++nClTplj1ce16pmtMJpPVdLtWrVoRERHB/PnzCQsLIzMzk0qVKpGammqzn2t/vF/rZ8qUKUybNo3p06dTuXJlPD096d+/f5Y+bjR8+HAGDhxo1eYXUCEnb4tNcXHxpKenExxS1Kq9aNEAYmPO3lbf/2Y2m1n9xTe0avKY1XuT+c8voTFD+1HlPuvjuVYZBJgz5XXS06/Ol4s5G8dzfYbyaeS7lvVOTtfvcBcY4E/cuQSrvuITzgOQkWH9S8/T04miga7ExF4h+cqt7+CSl+9Zbilb7hk1FyibvYyazai5QNnsZdRsRs0FyiZ3nwJ/DRNcHag4ODiQnJzMjz/+SIkSJRgxYgQ1a9akbNmy/PWX7RsA3My5c+c4cuQII0eOpGHDhtx7770kJCTc+oX/8sMPP9CmTRu6dOlC1apVKV26NMePH8/2Na6urvj4+FgttzMdDyAtLY29ew/QqGE9q/ZGjeqxfcfu2+r733b9fJCTp87QrlUTq/ZAfz+CiwZw6kw0xYuFWS3FwkIs24WFBFvar13/dOO2N14TVbVSBfbsP0Ra2vWbN2z7aS9BgQFW0/G8PJ0ICnQl5uwVLifn7HaXefme5Zay5Z5Rc4Gy2cuo2YyaC5TNXkbNZtRcoGyGpGuYslUgK0wpKSlER0cDkJCQwKxZs0hMTKRVq1ZcuHCBkydPsnz5cmrVqsUXX3zB6tWrc9W/n58fAQEBvPfee4SGhnLy5EmGDRuW65xlypTh008/Zdu2bfj5+TF16lSio6O59957c93X7Zo2Yz6LF81gz5797Ni5h549ulA8Ipx573140+1NJnB2vj7ednZywMXFTGaGmfQMM/5+Ljg5Zh3IrVr3NVUqlqds6ZJZ1r34fBcmTp+Lp6cHjzxYk9S0NA7/epyLlxLp1qldro+pReMGzFm4lBHjp9Lz2Y789fdp5n+wgt7PPcP2XdOBfwZLRV2JO5dCSkomjv9kNmeaudWsvNy+Z3lJ2QpOLmUreNmMmkvZCl42o+ZSNrnbFMgB0/r16y3XC3l7e1OhQgU++eQT6tevD8CAAQPo06cPKSkptGjRglGjRjFmzJgc9+/g4MDy5cvp168flSpVonz58rzzzjuW/nNq1KhR/PHHHzRp0gQPDw9eeOEF2rZty4ULF3LVz53wySdrCfD3Y+SIAYSGBnHo8FFate7KyZM3vwWmq6sj4aHulu8DA1wBuHgpjbNxKTg6mnBysi5gXkpMYuPmHxnW/+YPq32qdVPc3VxZtHQlU2cvwN3NjXL3lKRLh7Z2HZO3lyfzp49n/JTZdOzRDx9vL57t1I5undrx4qDpAPh4O2MymSga6MaNxfdrx5Gd3L5neUnZCk4uZSt42YyaS9kKXjaj5lI2A9I1TNkqcM9hKozuxHOY/iu2nsOU39zD7H9groiIiEhuGfo5TD8uybN9udXtnGf7ulMKZIVJRERERERySBWmbBWKmz6IiIiIiIjYQxUmEREREZFCzGzO2V2CCytVmERERERERGxQhUlEREREpDDTNUzZUoVJRERERETEBlWYREREREQKM7MqTNlRhUlERERERMQGVZhERERERAozXcOULVWYREREREREbNCASURERERExAZNyZP/lHvYI/kd4aaS/9qY3xFsci/RKL8jiIiISGGimz5kSxUmERERERERG1RhEhEREREpzHTTh2ypwiQiIiIiImKDKkwiIiIiIoWZrmHKlipMIiIiIiIiNqjCJCIiIiJSmOkapmypwiQiIiIiImKDKkwiIiIiIoWZKkzZUoVJRERERETEBlWY7NS9e3fOnz/PmjVr8juKiIiIiIj9dJe8bBWKCtO2bdtwdHSkadOmd6zPGTNmEBkZecf66969O23btr1j/dmjd69uHD+6ncSLJ9i54yserls7X/Nck9tcbm4OhAS7USLCg3tKeeHh4XjLfaSmpjHj/Y9o3LEn1Ro/RdNnerHqy4136hBu6tjvf9L9lRHUeLwDjz31PHMWr8BsNlvWe3o4EhriRsninpQq4Ul4qDvu7rc+lmuMej7BuNmMmguUzV5GzWbUXKBs9jJqNqPmAmWTu0ehGDAtXLiQvn37snXrVk6ePHlbfWVkZJCZmYmvry9FihS5MwENoH371kydMoYJE9+hZu0mbN36E+s+/4iIiLC7LpeDyURqaiZx51JyvJ9BY99i554DvD6kD+s+eJe3Rg2iVPFiduc+HRVDpfptba5PTLpMz0FjKBrgz/K5bzG8X08iV6xh8cefWbZxc3MkOTmDqOhkTp2+TPKVDEKD3XBxufWPrVHPp5GzGTWXshW8bEbNpWwFL5tRcymbAWVm5t1yFyrwA6akpCQ+/vhjXnzxRVq2bGlVFdq8eTMmk4kvvviCqlWr4ubmxgMPPMDBgwct20RGRlKkSBHWrVtHxYoVcXV15a+//spSEcrMzGTSpEmUKVMGV1dXihcvzvjx4y3rDx48yGOPPYa7uzsBAQG88MILJCYmAjBmzBgWL17MZ599hslkwmQysXnz5v/6rbEy4JWeLFy0nIWLlvHrr78xaPBo/j51ht69ns3THHci1+XkDOITUkm6nJGjfWzduZfd+w4xZ9Io6tSsSnhoMJXvLUe1ShWstlv91SZaPduH6o3b06rryyxf86Xdx7Vu4xZSU1MZP6wfZUuXoHG9OvTs/BQffLLWss25+FTOX0gjJTWTtHQz8QmppKVl4pmDiplRz6eRsxk1l7IVvGxGzaVsBS+bUXMpm+TU999/T6tWrQgLC8NkMmV7KUyvXr0wmUxMnz7dqj0lJYW+ffsSGBiIp6cnrVu35tSpU7nKUeAHTCtWrKB8+fKUL1+eLl26sGjRIqtpTwBDhgzh7bffZteuXQQFBdG6dWvS0tIs6y9fvsyECRN4//33OXz4MEFBQVn2M3z4cCZNmsSoUaP45ZdfWLp0KcHBwZbXN23aFD8/P3bt2sUnn3zCxo0b6dOnDwCDBw+mQ4cONG3alKioKKKionjooYf+w3fFmrOzM9WrV2HDxi1W7Rs2bKHOgzXzLMe/5VWu77b9xH3ly7Bw2Woee+p5WnR5ibdmL+JKyvUK1cp13/DO+x/R73+dWfvBLPr17MLMhcv4bP23du1z/+Gj1Ly/Ei4uzpa2urWrERsXj5OTyebrTA4mMm4xDjTq+QTjZjNqLlA2exk1m1FzgbLZy6jZjJoLlM2QzJl5t+RCUlISVatWZdasWdlut2bNGnbu3ElYWNYqYP/+/Vm9ejXLly9n69atJCYm0rJlSzJu9QfVDQr8TR8WLFhAly5dAGjatCmJiYls2rSJRo0aWbYZPXo0jRs3BmDx4sUUK1aM1atX06FDBwDS0tKYPXs2VatWvek+Ll26xIwZM5g1axbdunUD4J577uHhhx8GYMmSJSQnJ/PBBx/g6ekJwKxZs2jVqhWTJk0iODgYd3d3UlJSCAkJyfZ4UlJSSEmxnmpmNpsxmWz/kX0rgYH+ODk5ERsTZ9UeGxtHcEjWwWFeyatcp87EsPfgEVxcXJjxxjASLlxk3LR5XLiUyLihfQGY+8HHDHnpORrXqwNAsdBgfv/zbz7+/GvaNH0s1/uMi08g/F/HEOBXBABHRxPp6eYsryni64yDyURSUnq2fRv1fIJxsxk1FyibvYyazai5QNnsZdRsRs0FyiY516xZM5o1a5btNqdPn6ZPnz58/fXXtGjRwmrdhQsXWLBgAR9++KHlb/+PPvqIiIgINm7cSJMmTXKUo0APmI4ePcpPP/3EqlWrAHBycqJjx44sXLjQasBUp04dy9f+/v6UL1+eI0eOWNpcXFyoUqWKzf0cOXKElJQUGjZsaHN91apVLYMlgLp165KZmcnRo0ctlaicmDBhAmPHjrVqMzl4YXL0yXEftvy78mYymbK05Yf/OlemOROTycSkkQPw9rp6joa8nMbA0ZMZ2f8FLidfITo2jtcmz2L0W7Mtr8vIyMDLy8PyfZvufTkTffZaagBqNe1kWR8WUpTPImdaHceNsjsmL08n/Iq4EB1zhYzMnB27Uc8nGDebUXOBstnLqNmMmguUzV5GzWbUXKBshpKH1xbd7MN/V1dXXF1dc91XZmYmXbt2ZciQIdx3331Z1u/Zs4e0tDQef/xxS1tYWBiVKlVi27ZtGjDB1epSeno64eHhljaz2YyzszMJCQnZvvbGP2bd3d2zreC4u7tn21d2FaDcVoaGDx/OwIEDrdr8AirY2Dpn4uLiSU9PJzikqFV70aIBxMactfGq/15e5Soa4E9QoL9lsARQukQxzGYzMWfP4elxdVA0ZvDLVLm3nNVrHRyvz2qdM3EU6elXy7sxced4rv9IPn1/mmW9k9P1a48C/f2Iiz9v1Vf8+QsAZGRY/0L29HSiaKArMbFXSL5y6/KxUc8nGDebUXOBstnLqNmMmguUzV5GzWbUXKBshd3NPvwfPXo0Y8aMyXVfkyZNwsnJiX79+t10fXR0NC4uLvj5+Vm1BwcHEx0dneP9FNhrmNLT0/nggw+YMmUK+/btsyz79++nRIkSLFmyxLLtjh07LF8nJCRw7NgxKlTI+SCkbNmyuLu7s2nTppuur1ixIvv27SMpKcnS9uOPP+Lg4EC5clf/AHdxccnRXEpXV1d8fHysltuZjgdXpxzu3XuARg3rWbU3alSP7Tt231bftyOvclWrVIGz5+K5fDnZ0vbX32dwcHAguGgAgf5FCA4M4FRUNMWLhVotxUKvVwfDQoIs7WHBV3/R3rht2A2l/Kr3lWfP/sNW18pt27WPoEB/q+l4Xp5OBAW6EnP2CpeTczbX1qjnE4ybzai5QNnsZdRsRs0FymYvo2Yzai5QNkPKw2uYhg8fzoULF6yW4cOH5zrynj17LI/5ye3fwrm9nKXAVpjWrVtHQkICPXr0wNfX12rdU089xYIFC5g27eqn/6+//joBAQEEBwczYsQIAgMDc/VMJDc3N4YOHcqrr76Ki4sLdevW5ezZsxw+fJgePXrQuXNnRo8eTbdu3RgzZgxnz56lb9++dO3a1TIdr2TJknz99dccPXqUgIAAfH19cXZ2vsWe75xpM+azeNEM9uzZz46de+jZowvFI8KZ996HeZbhTuUymcDZ+fpnAc5ODri4mMnMMJOeYcbfz4Xhb05nwv/1B6BFw3rM/eBjRk6aycvPPU3ChYtMmbuYJ5o1xO2f8vCL3TsxceZ8PD08eOSB6qSmpXH46AkuXkqkW4c2uT6uFg3rMSdyBSMmvkPPzk/x1+ko5i9ZSe9nO7B919ULG708nQgq6krcuRRSUjJxdLz6g23ONHOrWXlGPZ9GzmbUXMpW8LIZNZeyFbxsRs2lbIWbvdPv/u2HH34gNjaW4sWLW9oyMjIYNGgQ06dP588//yQkJITU1FQSEhKsqkyxsbG5usFagR0wLViwgEaNGmUZLAE8+eSTvPnmm+zduxeAiRMn8sorr3D8+HGqVq3K2rVrcXFxydX+Ro0ahZOTE6+99hpnzpwhNDSU3r17A+Dh4cHXX3/NK6+8Qq1atfDw8ODJJ59k6tSpltf37NmTzZs3U7NmTRITE/nuu++oX7++/W9ALn3yyVoC/P0YOWIAoaFBHDp8lFatu3Ly5Ok8y3Cncrm6OhIeen2aZGDA1R/Ki5fSOBuXgqOjiagbyuoeHu7Mf3ssb74zn469BuHr403TBnXp26OzZZunWjbG3c2FRcvXMHXeYtzd3ChXugRdnmpl13F5e3kyf8oYxk9/j469BuPj7cWz7VvTrUMbXnz16oDJx9sZk8lE0UA3bpwYcO04smPU82nkbEbNpWwFL5tRcylbwctm1FzKJndC165dre5JANCkSRO6du3Kc889B0CNGjVwdnZmw4YNlpu5RUVFcejQISZPnpzjfZnMBfoKtuxt3ryZBg0akJCQcFc/hNbJJfzWG4mV5L825ncEm9xLNLr1RiIiInJXSU817oAreeW4PNuX+1Mjc7xtYmIiv/32GwDVqlVj6tSpNGjQAH9/f6vK0jUlS5akf//+9O/f39L24osvsm7dOiIjI/H392fw4MGcO3eOPXv24Oh462dbQgGuMImIiIiIyN1r9+7dNGjQwPL9tRufdevWjcjIyBz1MW3aNJycnOjQoQPJyck0bNiQyMjIHA+WQAMmEREREZHCLQ9vK54b9evXz9Xt3P/8888sbW5ubsycOZOZM2dmfUEOFeoBU25PgoiIiIiIFC6FesAkIiIiIlLoqYCQrQL7HCYREREREZHbpQqTiIiIiEhhZtBrmIxCFSYREREREREbVGESERERESnMVGHKlipMIiIiIiIiNqjCJCIiIiJSmJlVYcqOKkwiIiIiIiI2qMIkhZJ7iUb5HcGmS58Nze8INnm3mZTfEURERORO0zVM2VKFSURERERExAZVmERERERECjOzOb8TGJoqTCIiIiIiIjaowiQiIiIiUpjpGqZsqcIkIiIiIiJigwZMIiIiIiIiNmhKnoiIiIhIYaYpedlShUlERERERMQGVZhERERERAozsypM2VGFSURERERExAYNmPLIn3/+iclkYt++ffkdRURERETEwpxpzrPlbnRXD5i2bduGo6MjTZs2ze8oBULvXt04fnQ7iRdPsHPHVzxct3Z+RwKMmwtyn83NzYGQYDdKRHhwTykvPDwcc7yvn3+PosbA2XSYvPx2Y9/S8TPn6DFzNQ8MmUvj0ZHMW78L8w1PAff0cCQ0xI2SxT0pVcKT8FB33N1zfixGPadGzQXKZi+jZjNqLlA2exk1m1FzgbLJ3eOuHjAtXLiQvn37snXrVk6ePJnfce5q7du3ZuqUMUyY+A41azdh69afWPf5R0REhCnXHczmYDKRmppJ3LmUXO3rUnIKo5ZspHbZYrcbm9PnLnJ//3dtrk+8kkrvOZ9R1MeTJQPbM6zdI3zw3c98uHmfZRs3N0eSkzOIik7m1OnLJF/JIDTYDReXW/9KMeo5NWouZSt42YyaS9kKXjaj5lI2A8rMzLvlLnTXDpiSkpL4+OOPefHFF2nZsiWRkZEA1KlTh2HDhllte/bsWZydnfnuu+8ASEhI4Nlnn8XPzw8PDw+aNWvG8ePHrV7z448/8uijj+Lh4YGfnx9NmjQhISEBgPXr1/Pwww9TpEgRAgICaNmyJSdOnLB6/U8//US1atVwc3OjZs2a/Pzzz1mOYcuWLdSuXRtXV1dCQ0MZNmwY6enpd+otypUBr/Rk4aLlLFy0jF9//Y1Bg0fz96kz9O71bL7kMXoue7NdTs4gPiGVpMsZudrXuI8306xGOaqUDLnp+jU7j/DEm0upPXgubd9cwoqtB3PV/42+3H2MlLQMXu/ckDKhATSseg89Gtfgw837Lduci0/l/IU0UlIzSUs3E5+QSlpaJp45qJgZ9ZwaNZeyFbxsRs2lbAUvm1FzKZvcbe7aAdOKFSsoX7485cuXp0uXLixatAiz2Uznzp1ZtmyZ1fShFStWEBwczKOPPgpA9+7d2b17N2vXrmX79u2YzWaaN29OWloaAPv27aNhw4bcd999bN++na1bt9KqVSsyMq7+kZuUlMTAgQPZtWsXmzZtwsHBgSeeeILMf0bNSUlJtGzZkvLly7Nnzx7GjBnD4MGDrfKfPn2a5s2bU6tWLfbv38+cOXNYsGAB48aNy4u3z4qzszPVq1dhw8YtVu0bNmyhzoM18zzPNUbNBXmbbc3OI/wdd5FeTWrddP2n2w/z7hc76NPiAVYPf4a+LR5k9pc7WfvTr3bt78Cf0dQsE4aL0/XBz0MVinP2QhJOTiabrzM5mMi4xTjQqOfUqLlA2exl1GxGzQXKZi+jZjNqLlA2QzJn5t1yF7prbyu+YMECunTpAkDTpk1JTExk06ZNdOzYkQEDBrB161YeeeQRAJYuXcozzzyDg4MDx48fZ+3atfz444889NBDACxZsoSIiAjWrFlD+/btmTx5MjVr1mT27NmW/d13332Wr5988sksWYKCgvjll1+oVKkSS5YsISMjg4ULF+Lh4cF9993HqVOnePHFFy2vmT17NhEREcyaNQuTyUSFChU4c+YMQ4cO5bXXXsPB4eZj2ZSUFFJSrKdzmc1mTCbbf8jeSmCgP05OTsTGxFm1x8bGERwSZHe/t8uouSDvsv119jzvfL6dRf3a4eR48/8n5n+9m4Ft6tKw6j0AhAf48HtMAiu3HaZ17Qq53mfcpcuE+Xtbtfl7ewDg6GgiPT3rBZtFfJ1xMJlISsq+QmrUc2rUXKBs9jJqNqPmAmWzl1GzGTUXKJvcfe7KAdPRo0f56aefWLVqFQBOTk507NiRhQsXsnTpUho3bsySJUt45JFH+OOPP9i+fTtz5swB4MiRIzg5OfHAAw9Y+gsICKB8+fIcOXIEuFphat++vc39nzhxglGjRrFjxw7i4uIslaWTJ09SqVIljhw5QtWqVfHw8LC8pk6dOlZ9HDlyhDp16lgNdOrWrUtiYiKnTp2iePHiN933hAkTGDt2rFWbycELk6PPLd+3W7mxKgdgMpmytOUHo+aC/zZbRmYmwz/YwIvNalMiqMhNt4lPTCb6fCJjl3/H6yu+u+G1ZrzcXCzft5u4lKj4S1cz/9NW59V5lvWh/t6sGvbM9eP4136yOyYvTyf8irgQHXOFjBze/cao59SouUDZ7GXUbEbNBcpmL6NmM2ouUDZDuUvvXpdX7soB04IFC0hPTyc8PNzSZjabcXZ2JiEhgc6dO/PKK68wc+ZMli5dyn333UfVqlUt293MjVUad3f3bPffqlUrIiIimD9/PmFhYWRmZlKpUiVSU1Oz3Yet/d3YBmRbLRo+fDgDBw60avMLyH0V4UZxcfGkp6cTHFLUqr1o0QBiY87eVt+3w6i5IG+yJV1J45e/Yzl6+iwTP/0egEyzGbMZagyczZzerbkn1B+AUR3rU7lEsNXrHW+oUs56oSXpGVcH9rEXkvjfrDWsGNLRsv7G6lWgtwfnLl226ishMRmAjAzr/7c9PZ0oGuhKTOwVkq/c+roso55To+YCZbOXUbMZNRcom72Mms2ouUDZ5O5z113DlJ6ezgcffMCUKVPYt2+fZdm/fz8lSpRgyZIltG3blitXrrB+/XqWLl1qmboHULFiRdLT09m5c6el7dy5cxw7dox7770XgCpVqrBp06ab7v/cuXMcOXKEkSNH0rBhQ+69917LzSBu3Mf+/ftJTk62tO3YsSPLNtu2bbMaXG3btg1vb2+rgeC/ubq64uPjY7XcznQ8gLS0NPbuPUCjhvWs2hs1qsf2Hbtvq+/bYdRckDfZvNxcWDm0EyuGdLQsTz1UiZJBRVgxpCOVSwQT4O1BkK8np89dpHjRIlZLeMD1qmOYv4+lPdTv6nS7G7cN87++bZWSIew5EUVa+vUB0PZf/6aor6fVdDwvTyeCAl2JOXuFy8k5u4mFUc+pUXOBstnLqNmMmguUzV5GzWbUXKBshqS75GXrrqswrVu3joSEBHr06IGvr6/VuqeeeooFCxbQp08f2rRpw6hRozhy5AjPPHN9qlHZsmVp06YNPXv2ZN68eXh7ezNs2DDCw8Np06YNcLWKU7lyZV566SV69+6Ni4sL3333He3bt8ff35+AgADee+89QkNDOXnyZJa78j3zzDOMGDGCHj16MHLkSP7880/efvttq21eeuklpk+fTt++fenTpw9Hjx5l9OjRDBw40Ob1S/+laTPms3jRDPbs2c+OnXvo2aMLxSPCmffeh3me5W7IZW82kwmcna+fX2cnB1xczGRmmEnPMOPv58LIjzYyrksjHBxMlAkNsHq9v5c7Lk6OVu29m9Zm8qof8HRz4eF7S5CansHhv2O5dDmFrg3uz/VxNatRlnlf/8SopZv4X+ManDx7gQUb9/BCk5rs2PcN8M9gqagrcedSSEnJxNHx6qDdnGm+ZVXfqOfUqLmUreBlM2ouZSt42YyaS9nkbnPXDZgWLFhAo0aNsgyW4OrNGN5880327t1L586dadGiBfXq1ctyPdCiRYt45ZVXaNmyJampqdSrV48vv/wSZ2dnAMqVK8c333zD//3f/1G7dm3c3d154IEHePrpp3FwcGD58uX069ePSpUqUb58ed555x3q169v6d/Ly4vPP/+c3r17U61aNSpWrMikSZOsbhYRHh7Ol19+yZAhQ6hatSr+/v6WAVZ++OSTtQT4+zFyxABCQ4M4dPgorVp35eTJ0/mSx+i57M3m6upIeOj1KZ+BAa4AXLyUxtm4FBwdTUQlXMpVjnZ1KuLm4sTib39m+tptuLs6UzY0gM6PVrXruLzdXZn7YhsmrNzCM1M+wcfDlS71q9K1/v28PP3qgMnH2xmTyUTRQDdunLRw7TiyY9RzatRcylbwshk1l7IVvGxGzaVsBnSXVn7yislcoK9gKxycXGxP4ZO7z6XPhuZ3BJu820zK7wgiIiJ3pfRU4w64Ls/onWf78nhlbp7t60656ypMIiIiIiJyB6l+kq277qYPIiIiIiIieUUVJhERERGRwkzXMGVLFSYREREREREbNGASERERERGxQVPyREREREQKs1s9RLGQU4VJRERERETEBlWYREREREQKM7Nu+pAdVZhERERERERsUIVJRERERKQw0zVM2VKFSURERERExAZVmEQMxrvNpPyOYFPymR/yO4JN7mGP5HcEERGRu5JZD67NlipMIiIiIiIiNqjCJCIiIiJSmOkapmypwiQiIiIiImKDKkwiIiIiIoWZnsOULVWYREREREREbFCFSURERESkMNM1TNlShUlERERERMQGVZhERERERAozPYcpW6owiYiIiIiI2KAKk4iIiIhIYaZrmLKlCpOIiIiIiBjO999/T6tWrQgLC8NkMrFmzRrLurS0NIYOHUrlypXx9PQkLCyMZ599ljNnzlj1kZKSQt++fQkMDMTT05PWrVtz6tSpXOUo9AOm6Oho+vbtS+nSpXF1dSUiIoJWrVqxadOm/I6W53r36sbxo9tJvHiCnTu+4uG6tfM7EmDcXFCwsrm5ORAS7EaJCA/uKeWFh4djttuPGDeFSnWbZVnadO51Jw8ji2Mn/qD7y0Oo0aANj7XpwpyFSzCbr38y5unhSGiIGyWLe1KqhCfhoe64u2d/LNcUpPOZl5Qt94yaC5TNXkbNZtRcoGxya0lJSVStWpVZs2ZlWXf58mX27t3LqFGj2Lt3L6tWreLYsWO0bt3aarv+/fuzevVqli9fztatW0lMTKRly5ZkZGTkOEehHjD9+eef1KhRg2+//ZbJkydz8OBB1q9fT4MGDXj55ZfzO16eat++NVOnjGHCxHeoWbsJW7f+xLrPPyIiIky5Ckk2B5OJ1NRM4s6l5Ggfw/r3ZvPaJZZl4+oP8PXx5vHHHrE79+moGCrVbWZzfWJSEj37j6BoYADLF8xg+IAXiVz2KYuXr7Js4+bmSHJyBlHRyZw6fZnkKxmEBrvh4pL9r7uCdj6VzbjZjJpL2QpeNqPmUjYDMmfm3ZILzZo1Y9y4cbRr1y7LOl9fXzZs2ECHDh0oX748Dz74IDNnzmTPnj2cPHkSgAsXLrBgwQKmTJlCo0aNqFatGh999BEHDx5k48aNOc5hMt/40Wwh07x5cw4cOMDRo0fx9PS0Wnf+/HmKFCnCyZMn6du3L5s2bcLBwYGmTZsyc+ZMgoODLduuXbuW119/nUOHDuHl5UW9evVYterqH3AJCQm88sorfP7556SkpPDoo4/yzjvvULZsWQD++usv+vTpw9atW0lNTaVkyZK89dZbNG/ePMfH4eQSftvvxbatn7P350P06Tvc0nbwwGbWrl3PiJETb7v/gpYLCna2e0p5ERWTzOXL1p++JJ/5weZrNn2/jf7/N46vVy4iLOT6z8fqL75h4ZKVnI6KJjwkmM7t29CpXcub9nE6KoYmT3Xn0I9f3XT98tXrmDE3ki2fL8XFxQWA9z/8mKUr17J91182s0WEu5OYlE7C+TSb2xTk8/lfUraCkwuUzV5GzWbUXFA4s6Wnnr4T8f4TSaM65Nm+nEZ+SEqK9Yezrq6uuLq6Zvs6k8nE6tWradu2rc1tNm7cyOOPP8758+fx8fHh22+/pWHDhsTHx+Pn52fZrmrVqrRt25axY8fmKHOhrTDFx8ezfv16Xn755SyDJYAiRYpgNptp27Yt8fHxbNmyhQ0bNnDixAk6duxo2e6LL76gXbt2tGjRgp9//plNmzZRs2ZNy/ru3buze/du1q5dy/bt2zGbzTRv3py0tKt/uL388sukpKTw/fffc/DgQSZNmoSXl9d//wbcwNnZmerVq7Bh4xar9g0btlDnwZo2XvXfM2ouULabWbXuax6seb/VYGnl2q94Z95i+r3QjbVL3qNfr+7MnP8Bn325wa597D/0KzXvr2wZLAHUfaA6sXHncHIy2XydycFEdpV3nU/7KFvuGTUXKJu9jJrNqLlA2Qwp05xny4QJE/D19bVaJkyYcNuHcOXKFYYNG8YzzzyDj48PcPXSGxcXF6vBEkBwcDDR0dE57rvQ3iXvt99+w2w2U6FCBZvbbNy4kQMHDvDHH38QEREBwIcffsh9993Hrl27qFWrFuPHj6dTp05WI9SqVasCcPz4cdauXcuPP/7IQw89BMCSJUuIiIhgzZo1tG/fnpMnT/Lkk09SuXJlAEqXLp1t7pSUlCyjcrPZjMlk+4/FWwkM9MfJyYnYmDir9tjYOIJDguzu93YZNRco27+djYtn647dTBo91Kp9buQyhvTtSeP6dQEoFhbC73+e5OPPvqJN88a53k/cuXjCQ4Ot2gL++SXo6GgiPT1rwbyIrzMOJhNJSek2+9X5tI+y5Z5Rc4Gy2cuo2YyaC5StsBs+fDgDBw60artVdelW0tLS6NSpE5mZmcyePfuW2+f2b+dCO2C6NhMxuzfryJEjREREWAZLABUrVqRIkSIcOXKEWrVqsW/fPnr27Gnz9U5OTjzwwAOWtoCAAMqXL8+RI0cA6NevHy+++CLffPMNjRo14sknn6RKlSo2M02YMCFL+dDk4IXJ0efWB30L/56daTKZsrTlB6PmAmW7Zs2XG/D28qJhvTqWtviE80THnOW1CdMZPWmGpT0jIwOvG6q6bTr34kxM7LXQANRq9IRlfVhwEJ8tmWd1HDcyY/uYvDyd8CviQnTMFTJycMtUnU/7KFvuGTUXKJu9jJrNqLlA2YzEnIcPrs3J9LvcSEtLo0OHDvzxxx98++23luoSQEhICKmpqSQkJFhVmWJjYy3FjJwotAOmsmXLYjKZOHLkiM25kLZGnze2u7u729yHrR+sG1//v//9jyZNmvDFF1/wzTffMGHCBKZMmULfvn1v+tqbjcr9AmxXyXIiLi6e9PR0gkOKWrUXLRpAbMzZ2+r7dhg1FyjbjcxmM6u/+IZWTR7D2dnZ0p75z///Y4b2o8p91v+POjhcnw08Z8rrpKdfnS8XczaO5/oM5dPIdy3rnZyu3+EuMMCfuHMJVn3FJ5wHICPD+ufN09OJooGuxMReIflK9nfC0fm0j7LlnlFzgbLZy6jZjJoLlE3unGuDpePHj/Pdd98REBBgtb5GjRo4Oztbbg4BEBUVxaFDh5g8eXKO91Nor2Hy9/enSZMmvPvuuyQlJWVZf/78eSpWrMjJkyf5+++/Le2//PILFy5c4N577wWgSpUqNm9BXrFiRdLT09m5c6el7dy5cxw7dszyeoCIiAh69+7NqlWrGDRoEPPnz7eZ29XVFR8fH6vldqbjwdX/2fbuPUCjhvWs2hs1qsf2Hbtvq+/bYdRcoGw32vXzQU6eOkO7Vk2s2gP9/QguGsCpM9EULxZmtRQLC7FsFxYSbGm/dv3TjdveeE1U1UoV2LP/kOUaQIBtP+0lKDDAajqel6cTQYGuxJy9wuXkW982VOfTPsqWe0bNBcpmL6NmM2ouUDZDysNrmHIjMTGRffv2sW/fPgD++OMP9u3bx8mTJ0lPT+epp55i9+7dLFmyhIyMDKKjo4mOjiY1NRW4eie9Hj16MGjQIDZt2sTPP/9Mly5dqFy5Mo0aNcpxjkJbYQKYPXs2Dz30ELVr1+b111+nSpUqpKens2HDBubMmcMvv/xClSpV6Ny5M9OnTyc9PZ2XXnqJRx991HJjh9GjR9OwYUPuueceOnXqRHp6Ol999RWvvvoqZcuWpU2bNvTs2ZN58+bh7e3NsGHDCA8Pp02bNsDVe8M3a9aMcuXKkZCQwLfffms1mMor02bMZ/GiGezZs58dO/fQs0cXikeEM++9D/M8y92QqyBmM5nA2fn6ZyjOTg64uJjJzDCTnmHG38+F4W+8zYRRg61et2rd11SpWJ6ypUtm6fPF57swcfpcPD09eOTBmqSmpXH41+NcvJRIt05ZbxF6Ky0aN2DOwqWMGD+Vns925K+/TzP/gxX0fu4Ztu+aDvwzWCrqSty5FFJSMnF0vPqBgjnTnO3v6YJ2PpXNuNmMmkvZCl42o+ZSNsmp3bt306BBA8v312ZZdevWjTFjxrB27VoA7r//fqvXfffdd9SvXx+AadOm4eTkRIcOHUhOTqZhw4ZERkbi6JizZzRCIR8wlSpVir179zJ+/HgGDRpEVFQURYsWpUaNGsyZM8fyROG+fftSr149q9uKX1O/fn0++eQT3njjDSZOnIiPjw/16l3/VGLRokW88sortGzZktTUVOrVq8eXX35pmbqUkZHByy+/zKlTp/Dx8aFp06ZMmzYtz9+LTz5ZS4C/HyNHDCA0NIhDh4/SqnVXTp7M31tgGjVXQczm6upIeOj1KaaBAVfnF1+8lMbZuBQcHU1EXbvW6B+XEpPYuPlHhvW/+cNqn2rdFHc3VxYtXcnU2Qtwd3Oj3D0l6dKhrV3H5e3lyfzp4xk/ZTYde/TDx9uLZzu1o1undrw4aDoAPt7OmEwmiga6ceOEimvHYUtBO5/KZtxsRs2lbAUvm1FzKZsB5bLyk1fq16+f7bVjObmuzM3NjZkzZ1r9/Z5bhfo5TAXFnXgOk0hOZPccpvzmHmb/A3NFRET+a0Z+DlPikCduvdEd4vXW6jzb151SqCtMIiIiIiKFnjnv7pJ3Nyq0N30QERERERG5FVWYREREREQKM4New2QUqjCJiIiIiIjYoAqTiIiIiEghZlaFKVuqMImIiIiIiNigCpOIiIiISGGmClO2VGESERERERGxQRUmEREREZHCLFPPYcqOKkwiIiIiIiI2aMAkIiIiIiJig6bkiUiOuYc9kt8RbEo+80N+R7gpI79nIiIigG76cAuqMImIiIiIiNigCpOIiIiISGGmClO2VGESERERERGxQRUmEREREZFCzGxWhSk7qjCJiIiIiIjYoAqTiIiIiEhhpmuYsqUKk4iIiIiIiA2qMImIiIiIFGaqMGVLFSYREREREREbDDNgMplMrFmzJr9j2C0yMpIiRYrkdwwRERERkVwxZ5rzbLkb5dmAKTo6mr59+1K6dGlcXV2JiIigVatWbNq0Ka8i3DElS5Zk+vTpVm0dO3bk2LFj+RPoDundqxvHj24n8eIJdu74iofr1s7vSIBxc4Gy2Ss32dzcHAgJdqNEhAf3lPLCw8Mx275HjJtCpbrNsixtOve604dh5diJP+j+8hBqNGjDY226MGfhEqvbtHp6OBIa4kbJ4p6UKuFJeKg77u7ZH8uNCsr5zGtGzWbUXKBs9jJqNqPmAmWTu0eeDJj+/PNPatSowbfffsvkyZM5ePAg69evp0GDBrz88st5EeE/5+7uTlBQUH7HsFv79q2ZOmUMEya+Q83aTdi69SfWff4RERFhyqVs+ZrNwWQiNTWTuHMpOep/WP/ebF67xLJsXP0Bvj7ePP7YI3ZnPh0VQ6W6zWyuT0xKomf/ERQNDGD5ghkMH/Aikcs+ZfHyVZZt3NwcSU7OICo6mVOnL5N8JYPQYDdcXG79a7ggnU9lM24uZSt42YyaS9kMKNOcd8tdyGTOgydVNW/enAMHDnD06FE8PT2t1p0/f54iRYpgMplYvXo1bdu2BeD06dMMHDiQb775BgcHBx5++GFmzJhByZIlAejevTvnz5+ndu3azJgxg5SUFAYMGMCIESMYPnw4CxYswMPDg9dff53nn3/esr+c9vvwww8zZcoUUlNT6dSpE9OnT8fZ2Zn69euzZcsWq2Mwm81ERkbSv39/zp8/D8CYMWNYs2YNgwYNYtSoUSQkJNCsWTPmz5+Pt7e35XVvvfUWc+fOJSoqinLlyjFq1CieeuqpXL2/Ti7hudr+ZrZt/Zy9Px+iT9/hlraDBzazdu16RoyceNv9F7RcoGz2up1s95TyIiommcuXM7KsSz7zw01fs+n7bfT/v3F8vXIRYSHBlvbVX3zDwiUrOR0VTXhIMJ3bt6FTu5Y37eN0VAxNnurOoR+/uun65avXMWNuJFs+X4qLiwsA73/4MUtXrmX7rr9sHk9EuDuJSekknE+zuQ0U3PP5XzNqNqPmAmWzl1GzGTUXFM5s6amn70S8/8SFbg3zbF++i+++2WX/eYUpPj6e9evX8/LLL2cZLAE3ve7n8uXLNGjQAC8vL77//nu2bt2Kl5cXTZs2JTU11bLdt99+y5kzZ/j++++ZOnUqY8aMoWXLlvj5+bFz50569+5N7969+fvvv3PV73fffceJEyf47rvvWLx4MZGRkURGRgKwatUqihUrxuuvv05UVBRRUVE2j/3EiROsWbOGdevWsW7dOrZs2cLEidd/0EaOHMmiRYuYM2cOhw8fZsCAAXTp0iXLgOy/5uzsTPXqVdiw0Xq/GzZsoc6DNfM0y42MmguUzV75kW3Vuq95sOb9VoOllWu/4p15i+n3QjfWLnmPfr26M3P+B3z25Qa79rH/0K/UvL+yZbAEUPeB6sTGncPJyWTzdSYHExlZx35WdD7tY9RsRs0FymYvo2Yzai5QNkPKzMPlLvSf31b8t99+w2w2U6FChRy/Zvny5Tg4OPD+++9jMl39Y2PRokUUKVKEzZs38/jjjwPg7+/PO++8g4ODA+XLl2fy5MlcvnyZ//u//wNg+PDhTJw4kR9//JFOnTrluF8/Pz9mzZqFo6MjFSpUoEWLFmzatImePXvi7++Po6Mj3t7ehISEZHscmZmZREZGWipKXbt2ZdOmTYwfP56kpCSmTp3Kt99+S506dQAoXbo0W7duZd68eTz66KM37TMlJYWUFOupSWaz2XI89ggM9MfJyYnYmDir9tjYOIJD8m+aoVFzgbLZK6+znY2LZ+uO3UwaPdSqfW7kMob07Unj+nUBKBYWwu9/nuTjz76iTfPGud5P3Ll4wkODrdoC/PwAcHQ0kZ6etZBfxNcZB5OJpKT0bPvW+bSPUbMZNRcom72Mms2ouUDZ5O7znw+Yrs34y80f9Hv27OG3336zDDSuuXLlCidOnLB8f9999+HgcL1IFhwcTKVKlSzfOzo6EhAQQGxsbK77dXS8fjF2aGgoBw8ezHH+a0qWLGm1r9DQUEuWX375hStXrtC4sfUfZ6mpqVSrVs1mnxMmTGDs2LFWbSYHL0yOPrnO92//np1pMpmytOUHo+YCZbNXXmVb8+UGvL28aFivjqUtPuE80TFneW3CdEZPmmFpz8jIwOuGKnibzr04ExN7LTAAtRo9YVkfFhzEZ0vmWR3DjczYPh4vTyf8irgQHXOFjBzO59b5tI9Rsxk1FyibvYyazai5QNmM5G69e11e+c8HTGXLlsVkMnHkyBHL9Um3kpmZSY0aNViyZEmWdUWLFrV87ezsbLXOZDLdtC0zM/O2+73WR27cKgvAF198QXi49TVIrq6uNvscPnw4AwcOtGrzC8h59e5m4uLiSU9PJzikqFV70aIBxMacva2+b4dRc4Gy2Ssvs5nNZlZ/8Q2tmjxm9bOY+c8/eGOG9qPKfdY/Ozd+ADNnyuukp1+dLxdzNo7n+gzl08h3LeudnK5/qBIY4E/cuQSrvuITzgOQkWH9j5CnpxNFA12Jib1C8pVbzMdD59NeRs1m1FygbPYyajaj5gJlk7vPf34Nk7+/P02aNOHdd98lKSkpy/prN0m4UfXq1Tl+/DhBQUGUKVPGavH19bU7y53q18XFhYxbXXhwCxUrVsTV1ZWTJ09myRIREWHzda6urvj4+FgttzMdDyAtLY29ew/QqGE9q/ZGjeqxfcfu2+r7dhg1FyibvfIy266fD3Ly1BnatWpi1R7o70dw0QBOnYmmeLEwq6VY2PVptmEhwZb2a9c/3bjtjddEVa1UgT37D5GWdv3mDdt+2ktQYIDVdDwvTyeCAl2JOXuFy8k5+x2i82kfo2Yzai5QNnsZNZtRc4Gyyd3nP68wAcyePZuHHnqI2rVr8/rrr1OlShXS09PZsGEDc+bM4ciRI1bbd+7cmbfeeos2bdrw+uuvU6xYMU6ePMmqVasYMmQIxYoVsyvHneq3ZMmSfP/993Tq1AlXV1cCAwNzncXb25vBgwczYMAAMjMzefjhh7l48SLbtm3Dy8uLbt265brP2zFtxnwWL5rBnj372bFzDz17dKF4RDjz3vswT3PcLbmULe+ymUzg7Hz9sx1nJwdcXMxkZphJzzDj7+eCk2PWDw1WrfuaKhXLU7Z0ySzrXny+CxOnz8XT04NHHqxJaloah389zsVLiXTr1C7Xx9SicQPmLFzKiPFT6flsR/76+zTzP1hB7+eeYfuu6cA/g6WirsSdSyElJRPHfzKbM823vMtqQTqfymbcXMpW8LIZNZeyGZCm5GUrTwZMpUqVYu/evYwfP55BgwYRFRVF0aJFqVGjBnPmzMmyvYeHB99//z1Dhw6lXbt2XLp0ifDwcBo2bIiPj/3X6typfl9//XV69erFPffcQ0pKit1zWt944w2CgoKYMGECv//+O0WKFKF69eqWm1bkpU8+WUuAvx8jRwwgNDSIQ4eP0qp1V06ezN9bYBo1l7LlXTZXV0fCQ90t3wcGXJ2yevFSGmfjUnB0NOHkZF0sv5SYxMbNPzKs/80fVvtU66a4u7myaOlKps5egLubG+XuKUmXDm3tOiZvL0/mTx/P+Cmz6dijHz7eXjzbqR3dOrXjxUHTAfDxdsZkMlE00I0bJ3pcO47sFKTzqWzGzaVsBS+bUXMpm9xt8uQ5TPLfuhPPYRK529l6DlN+cw+z/4G5IiJScBj5OUznOzbIs30VWfFdnu3rTvnPr2ESERERERG5W+XJlDwRERERETEm3VY8e6owiYiIiIiI2KAKk4iIiIhIYZb7x40WKqowiYiIiIiI2KAKk4iIiIhIIaZrmLKnCpOIiIiIiIgNqjCJiIiIiBRmuoYpW6owiYiIiIiI2KAKk4iIiIhIIWZWhSlbqjCJiIiIiIjYoAqTiBQI7mGP5HeEm0o+80N+R7DJqO+ZiIjkMVWYsqUKk4iIiIiIiA2qMImIiIiIFGK6hil7qjCJiIiIiIjYoAqTiIiIiEhhpgpTtlRhEhERERERsUEDJhERERERERs0JU9EREREpBDTTR+ypwqTiIiIiIiIDRowiYiIiIgUYubMvFty4/vvv6dVq1aEhYVhMplYs2aNdW6zmTFjxhAWFoa7uzv169fn8OHDVtukpKTQt29fAgMD8fT0pHXr1pw6dSpXOTRgEhERERERw0lKSqJq1arMmjXrpusnT57M1KlTmTVrFrt27SIkJITGjRtz6dIlyzb9+/dn9erVLF++nK1bt5KYmEjLli3JyMjIcY5CP2CKjIykSJEit93Pn3/+iclkYt++fbfdl4iIiIhIXsnLClNKSgoXL160WlJSUm6aq1mzZowbN4527dplzWw2M336dEaMGEG7du2oVKkSixcv5vLlyyxduhSACxcusGDBAqZMmUKjRo2oVq0aH330EQcPHmTjxo05fn/ydcDUvXt3TCYTvXv3zrLupZdewmQy0b1797wPZoeIiAiioqKoVKlSfkexW+9e3Th+dDuJF0+wc8dXPFy3dn5HAoybC5TNXkbNlttcbm4OhAS7USLCg3tKeeHh4Zjt9iPGTaFS3WZZljade93Jw8ji2Ik/6P7yEGo0aMNjbbowZ+ESzGazZb2nhyOhIW6ULO5JqRKehIe64+6e/bHcyKjnE4ybzai5QNnsZdRsRs0FylZYTZgwAV9fX6tlwoQJue7njz/+IDo6mscff9zS5urqyqOPPsq2bdsA2LNnD2lpaVbbhIWFUalSJcs2OZHvFaaIiAiWL19OcnKype3KlSssW7aM4sWL52OynEtNTcXR0ZGQkBCcnO7OGw+2b9+aqVPGMGHiO9Ss3YStW39i3ecfERERplzKViiy2ZPLwWQiNTWTuHM3/2Ts34b1783mtUssy8bVH+Dr483jjz1id+7TUTFUqtvM5vrEpCR69h9B0cAAli+YwfABLxK57FMWL19l2cbNzZHk5AyiopM5dfoyyVcyCA12w8Xl1v9EGPV8GjmbUXMpW8HLZtRcymZAZlOeLcOHD+fChQtWy/Dhw3MdOTo6GoDg4GCr9uDgYMu66OhoXFxc8PPzs7lNTuT7gKl69eoUL16cVauu/+O9atUqIiIiqFatmqVt/fr1PPzwwxQpUoSAgABatmzJiRMnLOuvTYlbtWoVDRo0wMPDg6pVq7J9+3ar/UVGRlK8eHE8PDx44oknOHfunNX6EydO0KZNG4KDg/Hy8qJWrVpZSnYlS5Zk3LhxdO/eHV9fX3r27JllSt7mzZsxmUxs2rSJmjVr4uHhwUMPPcTRo0et+vr888+pUaMGbm5ulC5dmrFjx5Kenn5b76k9BrzSk4WLlrNw0TJ+/fU3Bg0ezd+nztC717N5nuVuyKVsBS+bPbkuJ2cQn5BK0uWczYP29vIkMMDfshz+9TgXLyXyRIvGVtut/uIbWj3zAtUbtKbV0z1Zvmqd3ce17pvvSE1NZfyIgZQtXZLG9evS89lOfLB8tWWbc/GpnL+QRkpqJmnpZuITUklLy8TzFhUzMO75NHI2o+ZStoKXzai5lK1wc3V1xcfHx2pxdXW1uz+TyWT1vdlsztL2bznZ5kb5PmACeO6551i0aJHl+4ULF/L8889bbZOUlMTAgQPZtWsXmzZtwsHBgSeeeILMTOvbbYwYMYLBgwezb98+ypUrx9NPP20ZgOzcuZPnn3+el156iX379tGgQQPGjRtn9frExESaN2/Oxo0b+fnnn2nSpAmtWrXi5MmTVtu99dZbVKpUiT179jBq1CibxzZixAimTJnC7t27cXJysjqur7/+mi5dutCvXz9++eUX5s2bR2RkJOPHj8/dG3ibnJ2dqV69Chs2brFq37BhC3UerJmnWW5k1FygbPYyarb8yrVq3dc8WPN+wkKufzq2cu1XvDNvMf1e6MbaJe/Rr1d3Zs7/gM++3GDXPvYf+pWa91fGxcXF0lb3gerExp3Dycn2PxYmBxO3uh7WqOcTjJvNqLlA2exl1GxGzQXKZkRGvUtedkJCQgCyVIpiY2MtVaeQkBBSU1NJSEiwuU1OGGLA1LVrV7Zu3cqff/7JX3/9xY8//kiXLl2stnnyySdp164dZcuW5f7772fBggUcPHiQX375xWq7wYMH06JFC8qVK8fYsWP566+/+O233wCYMWMGTZo0YdiwYZQrV45+/frRpEkTq9dXrVqVXr16UblyZcqWLcu4ceMoXbo0a9eutdruscceY/DgwZQpU4YyZcrYPLbx48fz6KOPUrFiRYYNG8a2bdu4cuWKZd2wYcPo1q0bpUuXpnHjxrzxxhvMmzfPZn83u1DuxmsR7BEY6I+TkxOxMXFW7bGxcQSHBN1W37fDqLlA2exl1Gz5ketsXDxbd+zmyVZNrdrnRi5jSN+eNK5fl2JhITSuX5dnOz7Bx599Zdd+4s7FE+BfxKot4J+pCY6ONx8wFfF1xsFkIikp+2q3Uc8nGDebUXOBstnLqNmMmguUTe6MUqVKERISwoYN1z9QTE1NZcuWLTz00EMA1KhRA2dnZ6ttoqKiOHTokGWbnDDEBTeBgYG0aNGCxYsXYzabadGiBYGBgVbbnDhxglGjRrFjxw7i4uIslaWTJ09a3WihSpUqlq9DQ0OBq6PIChUqcOTIEZ544gmrfuvUqcP69est3yclJTF27FjWrVvHmTNnSE9PJzk5OUuFqWbNnH3KYCtP8eLF2bNnD7t27bKqKGVkZHDlyhUuX76Mh4dHlv4mTJjA2LFjrdpMDl6YHH1ylCc7/x54mUym2x6M3QlGzQXKZi+jZsvLXGu+3IC3lxcN69WxtMUnnCc65iyvTZjO6EkzLO0ZGRl4eXpavm/TuRdnYmKvhQagVqPrv9vCgoP4bMn1D16yTFfA9jF5eTrhV8SF6JgrZGTm7NiNej7BuNmMmguUzV5GzWbUXKBsRmLOzPn0tLyUmJhoKXzA1Rs97Nu3D39/f4oXL07//v158803KVu2LGXLluXNN9/Ew8ODZ555BgBfX1969OjBoEGDCAgIwN/fn8GDB1O5cmUaNWqU4xyGGDABPP/88/Tp0weAd999N8v6Vq1aERERwfz58wkLCyMzM5NKlSqRmppqtZ2zs7Pl62t/JFwbXOXkf/QhQ4bw9ddf8/bbb1OmTBnc3d156qmnsuzH84Y/XrKTXZ7MzEzGjh1701slurm53bS/4cOHM3DgQKs2v4AKOcpiS1xcPOnp6QSHFLVqL1o0gNiYs7fV9+0wai5QNnsZNVte5zKbzVevU2rymNXviMx/fkeNGdqPKvdZ/1w7OFyfEDBnyuukp1+dLxdzNo7n+gzl08jrvzednK5fexQY4E/cOeupCPEJ5wHIyLD+nejp6UTRQFdiYq+QfOXW12UZ9XyCcbMZNRcom72Mms2ouUDZJOd2795NgwYNLN9f+xu4W7duREZG8uqrr5KcnMxLL71EQkICDzzwAN988w3e3t6W10ybNg0nJyc6dOhAcnIyDRs2JDIyEkfHnN8N1hBT8gCaNm1KamoqqampWabJnTt3jiNHjjBy5EgaNmzIvffem2UuYk5UrFiRHTt2WLX9+/sffviB7t2788QTT1C5cmVCQkL4888/c72vnKhevTpHjx61TOu7cbnxj6Mb3exCudxctHYzaWlp7N17gEYN61m1N2pUj+07dt9W37fDqLlA2exl1Gx5nWvXzwc5eeoM7VpZ/64L9PcjuGgAp85EU7xYmNVSLCzEsl1YSLCl/dr1Tzdue+M1UVUrVWDP/kOkpaVZ2rb9tJegwADS068PmLw8nQgKdCXm7BUuJ+fsJhZGPZ9g3GxGzQXKZi+jZjNqLlA2IzLqNUz169fHbDZnWSIjI4GrxYgxY8YQFRXFlStX2LJlS5ZH/Li5uTFz5kzOnTvH5cuX+fzzz4mIiMhVDsNUmBwdHTly5Ijl6xv5+fkREBDAe++9R2hoKCdPnmTYsGG53ke/fv146KGHmDx5Mm3btuWbb76xmo4HUKZMGVatWkWrVq0wmUyMGjUqy40l7pTXXnuNli1bEhERQfv27XFwcODAgQMcPHgwy80o/mvTZsxn8aIZ7Nmznx0799CzRxeKR4Qz770P8zTH3ZJL2QpeNntymUzg7Hz9ww1nJwdcXMxkZphJzzDj7+fC8DfeZsKowVavW7Xua6pULE/Z0iWz9Pni812YOH0unp4ePPJgTVLT0ix30+vWKWs1+lZaNG7AnIVLGTF+Kj2f7chff59m/gcr6P3cM2zfNR34Z7BU1JW4cymkpGRarm0yZ5q51aw8o55PI2czai5lK3jZjJpL2eRuY5gBE4CPz82vw3FwcGD58uX069ePSpUqUb58ed555x3q16+fq/4ffPBB3n//fUaPHs2YMWNo1KgRI0eO5I033rBsM23aNJ5//nkeeughAgMDGTp0KBcvXrydw7KpSZMmrFu3jtdff53Jkyfj7OxMhQoV+N///vef7C87n3yylgB/P0aOGEBoaBCHDh+lVeuunDx5Os+z3A25lK3gZbMnl6urI+Gh7pbvAwOu3hb14qU0zsal4OhoIuratUb/uJSYxMbNPzKs/80fVvtU66a4u7myaOlKps5egLubG+XuKUmXDm3tOi5vL0/mTx/P+Cmz6dijHz7eXjzbqR3dOrXjxUHTAfDxdsZkMlE00I0bJ6FcO47sGPV8GjmbUXMpW8HLZtRcymY8ZrMxr2EyCpO5IF/BVkg4uYTndwQRsSH5zA/5HcEm9zD7H5grIiK5k55q3AHX6TqP5dm+wrd/m2f7ulMMVWESEREREZG8dSefj1QQGeamDyIiIiIiIkajAZOIiIiIiIgNmpInIiIiIlKIGfXBtUahCpOIiIiIiIgNqjCJiIiIiBRiumd29lRhEhERERERsUEVJhERERGRQkzXMGVPFSYREREREREbVGESERERESnEVGHKnipMIiIiIiIiNqjCJCLyH3IPeyS/I9h0+dfV+R3BJo8KT+R3BBGRQkN3ycueKkwiIiIiIiI2qMIkIiIiIlKI6Rqm7KnCJCIiIiIiYoMqTCIiIiIihZjZrApTdlRhEhERERERsUEVJhERERGRQsycmd8JjE0VJhERERERERtUYRIRERERKcQydQ1TtlRhEhERERERsUEVJhERERGRQkx3ycueKkwiIiIiIiI2FNgB099//02PHj0ICwvDxcWFEiVK8Morr3Du3Ln8jmZYvXt14/jR7SRePMHOHV/xcN3a+R0JMG4uUDZ7GTWbUXNB7rO5uTkQEuxGiQgP7inlhYeH4y33kZqaxjuRn/B4t/5Ub/UczZ4bxOqvt9ypQ7ipY3/8Tfch46jZ5nkadunHnCWrMZvNlvWeHo6EhrhRsrgnpUp4Eh7qjrv7rY/lGqOeU6PmAmWzl1GzGTUXKJvcPQrkgOn333+nZs2aHDt2jGXLlvHbb78xd+5cNm3aRJ06dYiPj7/p61JTU/M4qXG0b9+aqVPGMGHiO9Ss3YStW39i3ecfERERplzKViiyGTWXvdkcTCZSUzOJO5eS4/0MmjCLnfsOM7b///j8/clMHvYSpSJC7c59OuYslZt1tbk+MSmZF0ZMIijAj2UzxjL8xa4s/vRLPlj1lWUbNzdHkpMziIpO5tTpyyRfySA02A0Xl1v/82XUc2rUXMpW8LIZNZeyGY8505Rny93IZL7xo7wColmzZhw6dIhjx47h7u5uaY+Ojuaee+7h2WefZc6cOZQsWZL//e9//Pbbb6xevZq2bduyePFihg4dyurVqzl16hQhISF07tyZ1157DWdnZwDGjBnDmjVrGDRoEKNGjSIhIYFmzZoxf/58vL29Abh06RK9e/dmzZo1+Pj48Oqrr/LZZ59x//33M336dODqAG3kyJEsWbKE8+fPU6lSJSZNmkT9+vVzdbxOLuG3/Z5t2/o5e38+RJ++wy1tBw9sZu3a9YwYOfG2+y9ouUDZ7GXUbEbNBbef7Z5SXkTFJHP5coZV++VfV1u+3rr7AK9OfJevFk3B19vLZl+rv/meRSu/4HT0WcKCA+nc5nE6tWx0021Px5ylafeBHPzqw5uuX7FuIzMiP2Hz0lm4uFz9/fr+x5+zbO0Gtu/+22aGiHB3EpPSSTifZnMbMO45NWouUDZ7GTWbUXNB4cyWnnr6TsT7T/xarnme7avCsS/zbF93SoGrMMXHx/P111/z0ksvWQ2WAMvgZ8WKFZYpH2+99RaVKlViz549jBo1CgBvb28iIyP55ZdfmDFjBvPnz2fatGlWfZ04cYI1a9awbt061q1bx5YtW5g48foP0cCBA/nxxx9Zu3YtGzZs4IcffmDv3r1WfTz33HP8+OOPLF++nAMHDtC+fXuaNm3K8ePH/4u3xiZnZ2eqV6/Cho3WU282bNhCnQdr5mmWGxk1FyibvYyazai5IO+ybd6xl4plS7Hwky9o2KUfLf83hLfnL+VKyvXK+8qvvmPm4k/o1+0pPntvIq90b8+sDz7lsw0/2LXP/b/+Ro3KFSyDJYC61SsTey4BJyfbn0KaHExkZNhcDRj3nBo1FyibvYyazai5QNmMyGzOu+VuVODuknf8+HHMZjP33nvvTdffe++9JCQkcPbsWQAee+wxBg8ebLXNyJEjLV+XLFmSQYMGsWLFCl599VVLe2ZmJpGRkZaKUteuXdm0aRPjx4/n0qVLLF68mKVLl9KwYUMAFi1aRFjY9VLuiRMnWLZsGadOnbK0Dx48mPXr17No0SLefPPNm+ZPSUkhJcV6io3ZbMZksr/EGRjoj5OTE7ExcVbtsbFxBIcE2d3v7TJqLlA2exk1m1FzQd5lOxUdy8+Hj+Hq4sz0Ua+QcOES499dzIVLSbwxsCcA85Z9xuCez9Cobi0AioUEceLkaT756lvaNH4k1/uMi79AWHCgVVuAny8Ajo4m0tOz/staxNcZB5OJpKT0bPs26jk1ai5QNnsZNZtRc4Gyyd2nwA2YbuVaZenaAKNmzayfFqxcuZLp06fz22+/kZiYSHp6Oj4+PlbblCxZ0jJYAggNDSU2Nha4eg1VWloatWtfv0DQ19eX8uXLW77fu3cvZrOZcuXKWfWbkpJCQECAzfwTJkxg7NixVm0mBy9Mjj42XpFz/56daTKZsrTlB6PmAmWzl1GzGTUX/PfZMjPNmEww8dUX8fb0ACA1LY2B42cy4uVuXE6+QvTZc4ye/j5jZiywvC4jIxMvz+vV/La9hnEmNu5aaABqP/E/y/qwoEDWzLtejf/3hz3ZHZOXpxN+RVyIjrlCRmbOjt2o59SouUDZ7GXUbEbNBcpmJHfrtUV5pcANmMqUKYPJZOKXX36hbdu2Wdb/+uuv+Pn5ERh49VNNT09Pq/U7duygU6dOjB07liZNmuDr68vy5cuZMmWK1XbXrme6xmQykZmZCWQdlF1z4w9aZmYmjo6O7NmzB0dH6zs+eXnZvn5g+PDhDBw40KrNL6CCze1zIi4unvT0dIJDilq1Fy0aQGzM2dvq+3YYNRcom72Mms2ouSDvshX1L0JQgJ9lsARQOiIMs9lMTFw8nh5XB0Wj+z1PlQplrF7r4HD9d93s1weT/s98uZi4eJ4f+iYr3x1vWe90w++7QH9f4hIuWPUVf/4iABkZ1n+YeHo6UTTQlZjYKyRfucV8PIx7To2aC5TNXkbNZtRcoGxy9ylw1zAFBATQuHFjZs+eTXJystW66OholixZQseOHW1OYfvxxx8pUaIEI0aMoGbNmpQtW5a//vorVxnuuecenJ2d+emnnyxtFy9etLo2qVq1amRkZBAbG0uZMmWslpCQEJt9u7q64uPjY7XcznQ8gLS0NPbuPUCjhvWs2hs1qsf2Hbtvq+/bYdRcoGz2Mmo2o+aCvMt2f8WynI0/z+XkK5a2P09H4+BgIjjQn0A/X4IC/DgVfZbiYcFWS7EbpqmEBQda2q9Nt7tx2xun4FWtUIY9h34lLe369Lptew8RFOBnNR3Py9OJoEBXYs5e4XLyrQdLYNxzatRcoGz2Mmo2o+YCZTOiTLMpz5a7UYGrMAHMmjWLhx56iCZNmjBu3DhKlSrF4cOHGTJkCOHh4YwfP97ma8uUKcPJkydZvnw5tWrV4osvvmD16tU2t78Zb29vunXrxpAhQ/D39ycoKIjRo0fj4OBgGdyUK1eOzp078+yzzzJlyhSqVatGXFwc3377LZUrV6Z587y7WwnAtBnzWbxoBnv27GfHzj307NGF4hHhzHvv5ne3Kuy5lK3gZTNqLnuzmUzg7Hz9MzFnJwdcXMxkZphJzzDj7+fC/709lzcH9wagRYOHmLfsM0ZOfY+XuzxJwsVLTF2wnCcefxQ3VxcAXurSjolzP8TLw52Ha1YhNS2dw8f/4GJiEt3aNcv1cTVv8BBzlq5hxNT36NmxFSdPx/D+irX0fqYt23fPB/4ZLBV1Je5cCikpmTg6Xv0das40c6tZeUY9p0bNpWwFL5tRcymb3G0K5ICpbNmy7N69mzFjxtCxY0fOnTtHSEgIbdu2ZfTo0fj7+9t8bZs2bRgwYAB9+vQhJSWFFi1aMGrUKMaMGZOrDFOnTqV37960bNnSclvxv//+Gzc3N8s2ixYtYty4cQwaNIjTp08TEBBAnTp18nywBPDJJ2sJ8Pdj5IgBhIYGcejwUVq17srJk/l7C0yj5lK2gpfNqLnszebq6kh46PVriwIDXAG4eCmNs3EpODqaiIq9/iBvD3c33ntzKBPmfECnV17D19uLJvUeoO+zT1m2ebJpfdxcXYhc+SVTFyzH3c2VsiWL0bVtU7uOy9vTg/fGD2X87MV06jcaHy8Pnm3XlGfbNePFEVcHTD7ezphMJooGunHjBJlrx5Edo55To+ZStoKXzai5lM14zHdp5SevFMjnMBlRUlIS4eHhTJkyhR49etzRvu/Ec5hEpPC58TlMRuNR4Yn8jiAickcZ+TlMB0u1yrN9Vf7j8zzb151SICtMRvDzzz/z66+/Urt2bS5cuMDrr78OXK1giYiIiIgYhcon2dOA6T/09ttvc/ToUVxcXKhRowY//PCD5e58IiIiIiJifBow/UeqVavGnj178juGiIiIiEi27ta71+WVAndbcRERERERkTtFFSYRERERkUJMd8nLnipMIiIiIiIiNqjCJCIiIiJSiOkuedlThUlERERERMQGDZhERERERERs0JQ8EREREZFCTLcVz54qTCIiIiIiIjaowiQiUkh5VHgivyPYlHzmh/yOYJN72CP5HUFE5I7SbcWzpwqTiIiIiIiIDaowiYiIiIgUYrqGKXuqMImIiIiIiNigCpOIiIiISCGm59ZmTxUmERERERERGzRgEhEREREpxDLNpjxbcio9PZ2RI0dSqlQp3N3dKV26NK+//jqZmZmWbcxmM2PGjCEsLAx3d3fq16/P4cOH7/j7owGTiIiIiIgYyqRJk5g7dy6zZs3iyJEjTJ48mbfeeouZM2datpk8eTJTp05l1qxZ7Nq1i5CQEBo3bsylS5fuaBZdwyQiIiIiUojl5XOYUlJSSElJsWpzdXXF1dXVqm379u20adOGFi1aAFCyZEmWLVvG7t27gavVpenTpzNixAjatWsHwOLFiwkODmbp0qX06tXrjmVWhUlERERERPLEhAkT8PX1tVomTJiQZbuHH36YTZs2cezYMQD279/P1q1bad68OQB//PEH0dHRPP7445bXuLq68uijj7Jt27Y7mlkVpmyYTCZWr15N27Zt8zuKiIiIiMh/IvPWm9wxw4cPZ+DAgVZt/64uAQwdOpQLFy5QoUIFHB0dycjIYPz48Tz99NMAREdHAxAcHGz1uuDgYP766687mrnQV5i6d+9uc0AUFRVFs2bN8jZQPurdqxvHj24n8eIJdu74iofr1s7vSIBxc4Gy2cuo2YyaCwpWNjc3B0KC3SgR4cE9pbzw8HDMdvsR46ZQqW6zLEubznduusXNHDvxB91fHkKNBm14rE0X5ixcgtl8/ea7nh6OhIa4UbK4J6VKeBIe6o67e/bHck1BOp95Sdlyz6i5QNkKK1dXV3x8fKyWmw2YVqxYwUcffcTSpUvZu3cvixcv5u2332bx4sVW25lM1tMJzWZzlrbbVegHTNkJCQm56QksiNq3b83UKWOYMPEdatZuwtatP7Hu84+IiAhTLmUrFNmMmqsgZnMwmUhNzSTuXIrNbW40rH9vNq9dYlk2rv4AXx9vHn/sEbtzn46KoVJd2x+IJSYl0bP/CIoGBrB8wQyGD3iRyGWfsnj5Kss2bm6OJCdnEBWdzKnTl0m+kkFosBsuLtn/01rQzqeyGTebUXMpm/GYMeXZklNDhgxh2LBhdOrUicqVK9O1a1cGDBhgmb4XEhICXK80XRMbG5ul6nS7NGDKhslkYs2aNQD8+eefmEwmPv74Yx555BHc3d2pVasWx44dY9euXdSsWRMvLy+aNm3K2bNnrfpZtGgR9957L25ublSoUIHZs2db1qWmptKnTx9CQ0Nxc3OjZMmSN53H+V8b8EpPFi5azsJFy/j1198YNHg0f586Q+9ez+Z5lrshl7IVvGxGzVUQs11OziA+IZWkyxk52oe3lyeBAf6W5fCvx7l4KZEnWjS22m71F9/Q6pkXqN6gNa2e7snyVevsPq5133xHamoq40cMpGzpkjSuX5eez3big+WrLduci0/l/IU0UlIzSUs3E5+QSlpaJp63qJgVtPOpbMbNZtRcyiY5cfnyZRwcrIcqjo6OltuKlypVipCQEDZs2GBZn5qaypYtW3jooYfuaBYNmHJp9OjRjBw5kr179+Lk5MTTTz/Nq6++yowZM/jhhx84ceIEr732mmX7+fPnM2LECMaPH8+RI0d48803GTVqlKWc+M4777B27Vo+/vhjjh49ykcffUTJkiXz9JicnZ2pXr0KGzZusWrfsGELdR6smadZbmTUXKBs9jJqNqPmAmW7mVXrvubBmvcTFnL9E8SVa7/inXmL6fdCN9YueY9+vbozc/4HfPblhmx6sm3/oV+peX9lXFxcLG11H6hObNw5nJxsf0JqcjCRkc04UOfTPsqWe0bNBcpmRJnmvFtyqlWrVowfP54vvviCP//8k9WrVzN16lSeeOIJ4Gpho3///rz55pusXr2aQ4cO0b17dzw8PHjmmWfu6Pujmz7k0uDBg2nSpAkAr7zyCk8//TSbNm2ibt26APTo0YPIyEjL9m+88QZTpkyx3O6wVKlS/PLLL8ybN49u3bpx8uRJypYty8MPP4zJZKJEiRLZ7v9mt2K83bmagYH+ODk5ERsTZ9UeGxtHcEiQ3f3eLqPmAmWzl1GzGTUXKNu/nY2LZ+uO3UwaPdSqfW7kMob07Unj+ld/FxcLC+H3P0/y8Wdf0aZ545t1la24c/GEh1pP6Qjw8wPA0dFEenrWf/WL+DrjYDKRlJRus1+dT/soW+4ZNRcom+TMzJkzGTVqFC+99BKxsbGEhYXRq1cvq8LEq6++SnJyMi+99BIJCQk88MADfPPNN3h7e9/RLBow5VKVKlUsX1+bH1m5cmWrttjYWADOnj3L33//TY8ePejZs6dlm/T0dHx9fYGrN51o3Lgx5cuXp2nTprRs2dLq9oj/NmHCBMaOHWvVZnLwwuToc9vHduPFzHB15P7vtvxg1FygbPYyajaj5gJlu2bNlxvw9vKiYb06lrb4hPNEx5zltQnTGT1phqU9IyMDL09Py/dtOvfiTEzstdAA1Gr0hGV9WHAQny2ZZ3UcNzJj+5i8PJ3wK+JCdMwVMnLwEarOp32ULfeMmguUzUgyc3FtUV7x9vZm+vTpTJ8+3eY2JpOJMWPGMGbMmP80iwZMueTs7Gz5+to/pv9uuza38tp/58+fzwMPPGDVj6Pj1Tnu1atX548//uCrr75i48aNdOjQgUaNGrFy5cqb7v9mt2L0C6hwW8cUFxdPeno6wSFFrdqLFg0gNuasjVf994yaC5TNXkbNZtRcoGw3MpvNV69TavKY1e/dzH/+iBkztB9V7rP+fXjj/Pc5U14nPf3qfLmYs3E812con0a+a1nv5HT92qPAAH/iziVY9RWfcB6AjAzrP5o8PZ0oGuhKTOwVkq9kf12Wzqd9lC33jJoLlE3uPrqG6T8UHBxMeHg4v//+O2XKlLFaSpUqZdnOx8eHjh07Mn/+fFasWMGnn35KfHz8Tfu82a0Yb/fWiWlpaezde4BGDetZtTdqVI/tO3bfVt+3w6i5QNnsZdRsRs0FynajXT8f5OSpM7Rr1cSqPdDfj+CiAZw6E03xYmFWS7GwEMt2YSHBlvZr1z/duO2N10RVrVSBPfsPkZaWZmnb9tNeggIDrKbjeXk6ERToSszZK1xOvvVNLHQ+7aNsuWfUXKBscvdRhQm4cOEC+/bts2rz9/e/I32PGTOGfv364ePjQ7NmzUhJSWH37t0kJCQwcOBApk2bRmhoKPfffz8ODg588sknhISEUKRIkTuy/5yaNmM+ixfNYM+e/ezYuYeePbpQPCKcee99mKc57pZcylbwshk1V0HMZjKBs/P1z+ucnRxwcTGTmWEmPcOMv58Lw994mwmjBlu9btW6r6lSsTxlS5fM0ueLz3dh4vS5eHp68MiDNUlNS7PcTa9bp3a5Pq4WjRswZ+FSRoyfSs9nO/LX36eZ/8EKej/3DNt3TQf+GSwVdSXuXAopKZk4Ol798Mqcac72wuaCdj6VzbjZjJpL2YwnN7f7Low0YAI2b95MtWrVrNq6det2R/r+3//+h4eHB2+99Ravvvoqnp6eVK5cmf79+wPg5eXFpEmTOH78OI6OjtSqVYsvv/wyy20U/2uffLKWAH8/Ro4YQGhoEIcOH6VV666cPHk6T3PcLbmUreBlM2qugpjN1dWR8FB3y/eBAVefd3fxUhpn41JwdDQRde1ao39cSkxi4+YfGdb/5g+rfap1U9zdXFm0dCVTZy/A3c2NcveUpEuHtnYdl7eXJ/Onj2f8lNl07NEPH28vnu3Ujm6d2vHioOkA+Hg7YzKZKBroxo2Td64dhy0F7Xwqm3GzGTWXssndxmQuyFewFRJOLuH5HUFE5I5KPvNDfkewyT3M/gfmikjhlZ5q3AHXhuCOebavxjEr8mxfd4quYRIREREREbFBU/JERERERAoxXcOUPVWYREREREREbFCFSURERESkEMvM7wAGpwqTiIiIiIiIDaowiYiIiIgUYqowZU8VJhERERERERtUYRIRERERKcR0l7zsqcIkIiIiIiJigypMIiIiIiKFWKYKTNlShUlERERERMQGVZhERMRw3MMeye8INiX/tTG/I9yUe4lG+R1BRO5SmbqGKVuqMImIiIiIiNigCpOIiIiISCFmzu8ABqcKk4iIiIiIiA0aMImIiIiIiNigKXkiIiIiIoVYZn4HMDhVmERERERERGxQhUlEREREpBDLNOm24tlRhUlERERERMQGVZhERERERAox3VY8e6owiYiIiIiI2KAKk4iIiIhIIaa75GWv0FSYunfvTtu2bfM7hqH17tWN40e3k3jxBDt3fMXDdWvndyTAuLlA2exl1GxGzQXKZq/cZHNzcyAk2I0SER7cU8oLDw/HW/afmprGjPc/onHHnlRr/BRNn+nFqi833slDyOLY73/S/ZUR1Hi8A4899TxzFq/AbL4+ocbTw5HQEDdKFvekVAlPwkPdcXe/9bFcU1DOZ14zajaj5gJlk7tHoRkwSfbat2/N1CljmDDxHWrWbsLWrT+x7vOPiIgIUy5lKxTZjJpL2fIum4PJRGpqJnHnUnK8j0Fj32LnngO8PqQP6z54l7dGDaJU8WJ2Zz4dFUOl+m1trk9MukzPQWMoGuDP8rlvMbxfTyJXrGHxx59ZtnFzcyQ5OYOo6GROnb5M8pUMQoPdcHG59T/5Bel8Kptxcymb8WSa8m65G5nMN34sVYB1796d8+fPs2bNmizrfvnlFwYPHsz333+Pp6cnjz/+ONOmTSMwMBCA+vXrU7lyZRwdHVm8eDEuLi688cYbdO7cmT59+rBy5UqCgoKYNWsWzZo1s/S7ZcsWhgwZwv79+/H396dbt26MGzcOJycnS79VqlTBzc2N999/HxcXF3r37s2YMWNydWxOLuF2vy/XbNv6OXt/PkSfvsMtbQcPbGbt2vWMGDnxtvsvaLlA2exl1GxGzQXKZq/byXZPKS+iYpK5fDkjy7rkv65WkLbu3MuQ199m/bJ5+Pp42+xr9VebWLhsNaejYggPCaLzky3o1Lb5Tbc9HRVDk6d7cWjzmpuuX/7ZV8x470O2rF6Mi4szAO8v+ZSlq79g+66TNjNEhLuTmJROwvk0m9tAwT2f/zWjZjNqLiic2dJTT9+JeP+JZWGd82xfT59Zkmf7ulMKfYUpKiqKRx99lPvvv5/du3ezfv16YmJi6NChg9V2ixcvJjAwkJ9++om+ffvy4osv0r59ex566CH27t1LkyZN6Nq1K5cvXwbg9OnTNG/enFq1arF//37mzJnDggULGDduXJZ+PT092blzJ5MnT+b1119nw4YNeXb8AM7OzlSvXoUNG7dYtW/YsIU6D9bM0yw3MmouUDZ7GTWbUXOBstkrL7J9t+0n7itfhoXLVvPYU8/TostLvDV7EVdSrleoVq77hnfe/4h+/+vM2g9m0a9nF2YuXMZn67+1a5/7Dx+l5v2VLIMlgLq1qxEbF4+Tk+2Pbk0OJjKyjv2sFPbzaS+jZjNqLlA2I8rElGfL3ajQ3/Rhzpw5VK9enTfffNPStnDhQiIiIjh27BjlypUDoGrVqowcORKA4cOHM3HiRAIDA+nZsycAr732GnPmzOHAgQM8+OCDzJ49m4iICGbNmoXJZKJChQqcOXOGoUOH8tprr+HgcHWsWqVKFUaPHg1A2bJlmTVrFps2baJx48Y3zZuSkkJKivV0EbPZjOk2HjgWGOiPk5MTsTFxVu2xsXEEhwTZ3e/tMmouUDZ7GTWbUXOBstkrL7KdOhPD3oNHcHFxYcYbw0i4cJFx0+Zx4VIi44b2BWDuBx8z5KXnaFyvDgDFQoP5/c+/+fjzr2nT9LFc7zMuPoHwf+UP8CsCgKOjifT0rJNGivg642AykZSUnm3fhf182suo2YyaC5RN7j6FfsC0Z88evvvuO7y8vLKsO3HihGXAVKVKFUu7o6MjAQEBVK5c2dIWHBwMQGxsLABHjhyhTp06VgOZunXrkpiYyKlTpyhevHiWfgFCQ0MtfdzMhAkTGDt2rFWbycELk6NPjo43O/+enWkymbK05Qej5gJls5dRsxk1Fyibvf7LbJnmTEwmE5NGDsDbyxOAIS+nMXD0ZEb2f4HLyVeIjo3jtcmzGP3WbMvrMjIy8PLysHzfpntfzkSfvZYYgFpNO1nWh4UU5bPImVbHkN0x3sjL0wm/Ii5Ex1whIzNnx11Yz+ftMmo2o+YCZTOSgntkd0ahHzBlZmbSqlUrJk2alGVdaGio5WtnZ2erdSaTyart2j9gmZlXb8x4s6rPtR+0G9tv1u+1Pm5m+PDhDBw40KrNL6CCze1zIi4unvT0dIJDilq1Fy0aQGzMWRuv+u8ZNRcom72Mms2ouUDZ7JUX2YoG+BMU6G8ZLAGULlEMs9lMzNlzeHpcHRSNGfwyVe4tZ/VaB8frM+LnTBxFevrV+XIxced4rv9IPn1/mmW9k9P1O9wF+vsRF3/eqq/48xcAyMiw/pPH09OJooGuxMReIfnKLebjofNpL6NmM2ouUDa5+xT6a5iqV6/O4cOHKVmyJGXKlLFaPD09b92BDRUrVmTbtm1Wn0Zs27YNb29vwsPtv0mDq6srPj4+VsvtTMcDSEtLY+/eAzRqWM+qvVGjemzfsfu2+r4dRs0FymYvo2Yzai5QNnvlRbZqlSpw9lw8ly8nW9r++vsMDg4OBBcNINC/CMGBAZyKiqZ4sVCrpVhosOU1YSFBlvaw4Kt/pN24bdgN04Cq3leePfsPk5Z2/eYN23btIyjQ32o6npenE0GBrsScvcLl5FsPlkDn015GzWbUXKBsRqS75GWvUFWYLly4wL59+6zaevXqxfz583n66acZMmQIgYGB/Pbbbyxfvpz58+fj6JjzZ1fc6KWXXmL69On07duXPn36cPToUUaPHs3AgQMt1y8ZybQZ81m8aAZ79uxnx8499OzRheIR4cx770PlUrZCkc2ouZQt77KZTODsfP33s7OTAy4uZjIzzKRnmPH3c8HJ8fq/9i0a1mPuBx8zctJMXn7uaRIuXGTK3MU80awhbq6uALzYvRMTZ87H08ODRx6oTmpaGoePnuDipUS6dWiT62Nq0bAecyJXMGLiO/Ts/BR/nY5i/pKV9H62A9t3zQL+GSwVdSXuXAopKZk4/pPZnGnmVrPyCtL5VDbj5lI2udsUqgHT5s2bqVatmlVbt27d+PHHHxk6dChNmjQhJSWFEiVK0LRp09sa2ISHh/Pll18yZMgQqlatir+/Pz169LDcOMJoPvlkLQH+fowcMYDQ0CAOHT5Kq9ZdOXkyf2+BadRcylbwshk1l7LlXTZXV0fCQ90t3wcGXB30XLyUxtm4FBwdTTg5Xf93wcPDnflvj+XNd+bTsdcgfH28adqgLn17XL8971MtG+Pu5sKi5WuYOm8x7m5ulCtdgi5PtbLrmLy9PJk/ZQzjp79Hx16D8fH24tn2renWoQ0vvnp1wOTj7YzJZKJooBs3Tiq6dhzZKUjnU9mMm0vZjMf2xSACheg5TAXZnXgOk4iI5My15zAZjXuJRvkdQUSyYeTnMEWGd8mzfXU//VGe7etOMd7cMBEREREREYMoVFPyRERERETEmqabZU8VJhERERERERtUYRIRERERKcTu1tt95xVVmERERERERGxQhUlEREREpBDTbcWzpwqTiIiIiIiIDaowiYiIiIgUYqowZU8VJhERERERERtUYRIRERERKcTMuktetlRhEhERERERsUEVJhERkVxwL9EovyPc1OU/v8nvCDZ5lHw8vyNIIaFCiX10DVP2VGESERERERGxQRUmEREREZFCTBWm7KnCJCIiIiIiYoMGTCIiIiIihZg5D5fcOH36NF26dCEgIAAPDw/uv/9+9uzZcz232cyYMWMICwvD3d2d+vXrc/jwYXvegmxpwCQiIiIiIoaSkJBA3bp1cXZ25quvvuKXX35hypQpFClSxLLN5MmTmTp1KrNmzWLXrl2EhITQuHFjLl26dEez6BomEREREZFCLDMPby+YkpJCSkqKVZurqyuurq5WbZMmTSIiIoJFixZZ2kqWLGn52mw2M336dEaMGEG7du0AWLx4McHBwSxdupRevXrdscyqMImIiIiISJ6YMGECvr6+VsuECROybLd27Vpq1qxJ+/btCQoKolq1asyfP9+y/o8//iA6OprHH7/+2AJXV1ceffRRtm3bdkcza8AkIiIiIlKIZebhMnz4cC5cuGC1DB8+PEum33//nTlz5lC2bFm+/vprevfuTb9+/fjggw8AiI6OBiA4ONjqdcHBwZZ1d4qm5ImIiIiISJ642fS7m8nMzKRmzZq8+eabAFSrVo3Dhw8zZ84cnn32Wct2JpP1fEKz2Zyl7XapwiQiIiIiIoYSGhpKxYoVrdruvfdeTp48CUBISAhAlmpSbGxslqrT7dKAKR+ZTCbWrFmT3zFEREREpBDLyyl5OVW3bl2OHj1q1Xbs2DFKlCgBQKlSpQgJCWHDhg2W9ampqWzZsoWHHnooF3u6tUI9YOrevTsmkwmTyYSzszOlS5dm8ODBJCUl5Xe0fNG7VzeOH91O4sUT7NzxFQ/XrZ3fkQDj5gJls5dRsxk1FyibvYyaLbe53NwcCAl2o0SEB/eU8sLDw/GW+0hNTeOd95fweKcXqP54B5p1fpHVX266U4dwU8d+/4vur4ykZpNONGz/P+Ys/hiz+fqTVzw9HAkNcaNkcU9KlfAkPNQdd/dbH8s1Rj2fYNxsRs0Fxs328MMPsHp1JH/9uYe01NO0bt0kvyMVSgMGDGDHjh28+eab/PbbbyxdupT33nuPl19+GbhaeOjfvz9vvvkmq1ev5tChQ3Tv3h0PDw+eeeaZO5qlUA+YAJo2bUpUVBS///4748aNY/bs2QwePDi/Y+W59u1bM3XKGCZMfIeatZuwdetPrPv8IyIiwpRL2QpFNqPmUraCl82eXA4mE6mpmcSdS7G5zb8NGvs2O/ceYOyQl/n8g1lMHjmQUsXD7c59OjqWyg3a2VyfmHSZFwaPJSjQn2VzJzG87/9Y/PFnfPDJWss2bm6OJCdnEBWdzKnTl0m+kkFosBsuLrf+c8So59PI2Yyay+jZPD09OHDgF17pPzK/o+QZIz64tlatWqxevZply5ZRqVIl3njjDaZPn07nzp0t27z66qv079+fl156iZo1a3L69Gm++eYbvL297X0rbspkvvGjn0Kme/funD9/3mpaXM+ePVm3bh1nzpzhrbfeYu7cuURFRVGuXDlGjRrFU089BUBGRgYvvPAC3377LdHR0RQvXpyXXnqJV155xWofCxcuZMqUKfz222/4+/vz5JNPMmvWLODqyHj+/Pl88cUXfP3114SHhzNlyhRat26dq+NwcrH/H8Brtm39nL0/H6JP3+t3KTl4YDNr165nxMiJt91/QcsFymYvo2Yzai5QNnsZNdvt5rqnlBdRMclcvpxh1X75z28sX2/9aS+vvj6Vr5bOwdfH9h8Oq7/axKLlazgdFUtYSBCd2zWnU9tmN932dHQsTZ/uzcHvVt10/YrP1jNj/kdsXrUIFxdnAN5fuoplq79k+66TNjNEhLuTmJROwvk0m9uAcc8nGDebUXPBf5ftTj9OKC31NE8+9Txr1359R/oyqreLd8mzfQ0++VGe7etOKfQVpn9zd3cnLS2NkSNHsmjRIubMmcPhw4cZMGAAXbp0YcuWLcDVO3cUK1aMjz/+mF9++YXXXnuN//u//+Pjjz+29DVnzhxefvllXnjhBQ4ePMjatWspU6aM1f7Gjh1Lhw4dOHDgAM2bN6dz587Ex8fn6TE7OztTvXoVNmzcYtW+YcMW6jxYM0+z3MiouUDZ7GXUbEbNBcpmL6Nmy6tcm3/cRcXyZVi4fA0N2/+Pll1f5u05kVy54WGRK9dtYOaCpfTr0ZnPFr/DK//rzKxFy/hs/Xd27XP/4aPUqHqfZbAEULfW/cTGxePkZPvPWJODiYwMm6sB455PMG42o+YCY2crrDJNebfcjXRb8Rv89NNPLF26lAYNGjB16lS+/fZb6tSpA0Dp0qXZunUr8+bN49FHH8XZ2ZmxY8daXluqVCm2bdvGxx9/TIcOHQAYN24cgwYNsqo61apVy2qf3bt35+mnnwbgzTffZObMmfz00080bdr0phlv9nTk2719YmCgP05OTsTGxFm1x8bGERwSZHe/t8uouUDZ7GXUbEbNBcpmL6Nmy6tcp6Ji+PngEVxdnJn++lASLlxk/PT3uHAxkTeG9gFg3oefMPjF7jSq9yAAxUKDOfHX33yy7hvaNG2Q633GJZwnLNj6GAL8igDg6GgiPT3rhJYivs44mEwkJaVn27dRzycYN5tRc4Gxs4ncTKEfMK1btw4vLy/S09NJS0ujTZs2DB48mJUrV9K4cWOrbVNTU6lWrZrl+7lz5/L+++/z119/kZycTGpqKvfffz9w9ZaGZ86coWHDhtnuv0qVKpavPT098fb2JjY21ub2EyZMsBqoAZgcvDA5+vw/e/cdX9P9x3H8dbMn2SJBJGLHVrtI7T3aUjstau/R2ntUa6s9ghZFUaU2ScWu2FvsGYktQ8b5/ZGfy5WB4J6Dz/P3uI9f7/eee8773CvJ+Z7vet1TTtXLvTN1Ol2yMjVoNRdItvTSajat5gLJll5azfa+cyX+/0ba2AHdsbezBeBpx2/pOfRnBnRvS1R0DLfCIxjy868M/WWG/n0JCQnY2dnon9cP6MaN23eepQagRI3ng6k9MrmyJnDyC+dhmCOtc7KzNcPRwYJbt2NISHy9c9fq9wnazabVXKDtbJ+aN5m97lP0yVeY/P39mTFjBubm5nh4eGBubs6+ffsAWL9+PZ6ehuODni20tXz5cnr06MH48eMpXbo09vb2/Pzzz/r3Wltbv9bxzc3NDZ7rdDoSE1P/Z9uvXz969uxpUObonOe1jpWaiIi7xMfHk8nd1aDc1dWZcP0fSuPTai6QbOml1WxazQWSLb20ms1YuVydHHFzcdJXlgB8vLKgKAq370Ria5NUKRrSqwMF8+UyeK+JyfPe+tPHDiD+//3lbt+5y3c9BrFy7nj962amz2e4c3F0IOLufYN93b3/AICEBMOLYFtbM1xdLLkdHkN0zCv646Hd7xO0m02ruUDb2YRIySc/hsnW1hZfX1+8vLz0lZd8+fJhaWnJlStX8PX1NXhkzZoVgJ07d1KmTBk6duxIkSJF8PX1JSwsTL9fe3t7smfPzrZt73YKV0tLSzJkyGDweNvVjOPi4ggNPUrlSuUNyitXLs+evf+91b7fhlZzgWRLL61m02oukGzppdVsxspV2C8PdyLvEhUdrS+7dPUGJiYmZHJ1xsXJATcXJ67dvE02z8wGjyyZny/46OHupi/3+P/F7YvberzQfapQ/twcPHqSuLjnkzfs/u8wbi5OBt3x7GzNcHOx5PadGKKiX11ZAu1+n6DdbFrNBdrO9qnS4ix5WvLJtzClxN7ent69e9OjRw8SExMpV64cDx8+ZPfu3djZ2dGqVSt8fX1ZtGgRmzZtwtvbm8WLF3PgwAG8vb31+xk6dCjt27fHzc2NGjVq8OjRI3bt2kWXLl1UPLuUTZw8h4ULJnPw4BH27jtI29bNyZbVk1mzF0suyfZJZNNqLsn28WVLTy6dDszNn9/jNDczwcJCITFBIT5BwcnRgv6jJzO6f9KY2VqVP2fW4hUM/GkanQK+4d6Dh0yYtZAGNb7A6v89JToGNGbs1HnY2dhQrmRRnsbFceLMeR4+ekKrRm82WytAzUqfM2PhcgaMnUbb5g25cu0mc39fRfuWX7PnwK/A/ytLrpZERMYSG5uIqWnSDT8lUeFVvfK0+n1qOZtWc2k9m62tDb6+z6/nvLNno1Ch/Ny9e4+rV2+omEyoRSpMqRgxYgRubm6MGTOGCxcu4ODgQNGiRenfvz8A7du35/DhwzRu3BidTkeTJk3o2LEjGzZs0O+jVatWxMTEMHHiRHr37o2Li4t+WnKtWbFiLc5Ojgwc0IPMmd04fuIMdeq24MoVdafA1GouyfbxZdNqLsn28WVLTy5LS1M8Mz/v6u3inFTpefgojjsRsZia6rgZ/nwAvY21NbN/GcKYKXP5pn0fMmawp1rFMnRp/Xz80Ze1qmBlaUngH38xYfYirK2syOmdjRZf1U7Xednb2TL7lyGMmjyHb9r1JYO9LS2/rkPLr+vSoW9ShSmDvTk6nQ5XFyte7Iz17DzSotXvU8vZtJpL69mKFSvEtq0r9c9/+WUoAIsWLad1mx4qpXq/Ej/Yth/j+KTXYfpYvIt1mIQQQnzYXlyHSWtssldVO4L4RGh51motr8M0yqvZqzd6RwZc/t1ox3pXpIVJCCGEEEKIT5jMkpe2T37SByGEEEIIIYRIjbQwCSGEEEII8QmT8TlpkxYmIYQQQgghhEiFtDAJIYQQQgjxCZMxTGmTFiYhhBBCCCGESIVUmIQQQgghhBAiFdIlTwghhBBCiE9YopYXsNIAaWESQgghhBBCiFRIC5MQQgghhBCfsESZWDxN0sIkhBBCCCGEEKmQFiYhhBDiI2CTvaraEVL1OGSS2hFSZVeuu9oRxDsk7STpI59b2qSFSQghhBBCCCFSIS1MQgghhBBCfMJk4dq0SQuTEEIIIYQQQqRCWpiEEEIIIYT4hMkseWmTFiYhhBBCCCGESIW0MAkhhBBCCPEJk/altEkLkxBCCCGEEEKkQlqYhBBCCCGE+ITJLHlpkxYmIYQQQgghhEiFVJjSISgoCJ1Ox/3799WOIoQQQgghxFtJRDHa40MkFaZUBAQEoNPp0Ol0mJub4+PjQ+/evXny5Ina0d6b9u1ace7MHh4/DGPf3g2UK1tC7UiAdnOBZEsvrWbTai6QbOml1WxazQVvns3KygT3TFZ4ZbUhh7cdNjamaW5/4NQFCrUYmOxx8cadd3kayZy7eovvRs6lxHdDqdz1J2au3o6iPL94s7UxJbO7Fdmz2eLtZYtnZmusrdM+lxdp9TvVai6QbOLDIRWmNFSvXp2bN29y4cIFRo4cyfTp0+ndu7fasd6Lr7+uy4TxQxkzdgrFS1QjJGQ/6/7+jaxZPSSXZPsksmk1l2T7+LJpNVd6s5nodDx9mkhEZOwbHeuvcd3ZNvUH/SObu3O6c1+/c49CLQam+vrj6Bja/RSIq6M9vw/rwI8tarPon10s2rBLv42VlSnR0QncvBXNtetRRMckkDmTFRYWr75U0up3qtVckk17FCM+PkQ65cXbK0IvICCA+/fvs2bNGn1Z27ZtWbduHUuXLsXf35979+7h4ODA0KFDWbNmDYcPH9ZvO2nSJCZNmsSlS5cM9leiRAkmT55MbGwsPXr0YMCAAfTr14958+ZhY2PD8OHD+e67794oq5mF51uf7+6Qvwk9dJzOXfrpy44dDWLt2o0MGDj2rff/seUCyZZeWs2m1Vwg2dJLq9m0mgvePlsObztu3o4mKirBoPxxyCT9fx84dYE2o+ezc+YAMthap7qvNf8eJHB9CNfv3MPDxYGmVUvTuHLJFLe9fuceNXuO58jikSm+vnzrPqas2ML2aT9iYZ4039W8v4NZumUve0Nvppohq6c1j5/Ec+9+XKrbgHa/U63mgk8zW/zT6+8i3nvRI/s3RjvWxEvLjHasd0VamN6AtbU1cXFp/9JMy/bt27lx4wb//vsvEyZMYOjQodSuXRtHR0f27dtH+/btad++PVevXn2HqV/N3NycokULsmVrsEH5li3BlC5V3KhZXqTVXCDZ0kur2bSaCyRbemk1m1ZzgfGzNR74K5U6j6XtmPnsP3nB4LU/dxxg2oqtdP6qMqvHdqXL11X49c+trN0Zmq5jHTl/lWJ5susrSwBlCuTkzr1HmJnpUn2fzkRHQkKqLwPa/U61mgskmxYlGvHxIZIK02vav38/S5YsoVKlSuneh5OTE1OmTCF37tx899135M6dm6ioKPr370/OnDnp168fFhYW7Nq169U7e4dcXJwwMzMj/HaEQXl4eASZ3N2MmuVFWs0Fki29tJpNq7lAsqWXVrNpNRcYL5urgz2Dv6vHhG5NmdCtKdkzu/D92AUcPH1Rv83sv4Lo1bQ6lT/LTxY3Jyp/lp/m1cqwcvuBdB0z4sEjnDPYGZQ5Z0x6bmqacoXJIaM5JjodT57Ep7lvrX6nWs0Fkk18eGQdpjSsW7cOOzs74uPjiYuLo169ekydOpWTJ0+ma3/58+fHxOR5HTVTpkz4+fnpn5uamuLs7Ex4eHiq+4iNjSU21rCfuKIo6HSp3yF7XS/3ztTpdMnK1KDVXCDZ0kur2bSaCyRbemk1m1ZzwfvPlj2zK9kzu+qfF8qZjVuRD1j4zy6K5fHm7sMn3Ip8wNC5axg27y/9dgmJidhZW+qfN/hxCjcj7htkLtVmuP71zC4OrB7b9YUTMcyR1inZ2Zrh6GDBrdsxJCS+3rlr9TvVai6QbOLDIRWmNPj7+zNjxgzMzc3x8PDA3NwcIFmFycTEJNkPUUpd9569/5lnM/C9XJaYmHqD5ZgxYxg2bJjhe0zs0JlmePUJpSIi4i7x8fFkcnc1KHd1dSb89vudtSgtWs0Fki29tJpNq7lAsqWXVrNpNReom62gb1bW7z4CPL9QHfxdPQr4ZjXYzuSFm4O/9m5BfELS38vwuw9pPXoey0d10r9uZvr8BqVLRnsiHzw22Nfdh0nPExIM/37b2prh6mLJ7fAYomNe0R8P7X6nWs0Fkk2LlA92OgbjkC55abC1tcXX1xcvL69kFZsXubq6cuvWLYNK04sTQLxL/fr148GDBwYPnYn9W+0zLi6O0NCjVK5U3qC8cuXy7Nn731vt+21oNRdItvTSajat5gLJll5azabVXKButtOXb+Ly/y5yzhntcHPMwLU798iWydngkcXNSf8eDxdHfXlmFwcAg209XBz12xbyzcrB05eIi3/evW7P8fO4OtoTH//8b7edrRluLpbcvhNDVPSrK0ug3e9Uq7lAsokPj7QwvQMVK1bkzp07jBs3jq+++oqNGzeyYcMGMmRIf6tPaiwtLbG0tDQoexfd8SZOnsPCBZM5ePAIe/cdpG3r5mTL6sms2Yvfet8fYy7J9vFl02ouyfbxZdNqrvRm0+nA3Pz5/VdzMxMsLBQSExTiExScHC0YMHMlo9p/BcBvG3fj4eJAjixuxMUnsH7XEbYeOMH4rk30++jQ8At+WrweO2tLyhbMRVx8PCcuXufhkxha1ij7xudVo0whZq7ZwaDZq2hdpwJXbkcyb20w39f3Z2/oSuD/lSVXSyIiY4mNTdSPbVISFV7VK0+r36lWc0k27flQJ2MwFqkwvQN58+Zl+vTpjB49mhEjRvDll1/Su3dvZs+erXa017ZixVqcnRwZOKAHmTO7cfzEGerUbcGVK+pOganVXJLt48um1VyS7ePLptVc6c1maWmKZ+bn04O7OCfd1Hv4KI47EbGYmuq4FXlf/3pcfAITlm4k/N5DLC3MyeHpxrReLfi8cG79Ng0rFsfKwpzAf0KYuGwT1pYW5MySiWbVy6TrvOxtrJj1QwCjF/5N0yEzyGBjRYvqZWlZoyydRidVmDLYm6PT6XB1seLFzljPziMtWv1OtZpLsokPjazD9BF4F+swCSGEEO/Li+swaY1due5qRxCfCC2vw9QxeyOjHWv6peVGO9a7ImOYhBBCCCGEECIV0iVPCCGEEEKIT5h0N0ubtDAJIYQQQgghRCqkhUkIIYQQQohPWKK0MaVJWpiEEEIIIYQQIhXSwiSEEEIIIcQnTNZhSpu0MAkhhBBCCCFEKqSFSQghhBBCiE+YImOY0iQtTEIIIYQQQgiRCmlhEkIIIYQQ4hMmY5jSJi1MQgghhBBCCJEKaWESQgghxHtlV6672hFSFX1jp9oRUmXt8bnaEcQnQsYwpU1amIQQQgghhBAiFVJhEkIIIYQQQmjamDFj0Ol0dO/eXV+mKApDhw7Fw8MDa2trKlasyIkTJ975saXCJIQQQgghxCcs0YiP9Dhw4ACzZ8+mYMGCBuXjxo1jwoQJTJs2jQMHDuDu7k6VKlV49OhROo+UMqkwCSGEEEIIIYwiNjaWhw8fGjxiY2NT3f7x48c0a9aMOXPm4OjoqC9XFIVJkyYxYMAAGjZsiJ+fHwsXLiQqKoolS5a808xSYRJCCCGEEOITlqgoRnuMGTOGjBkzGjzGjBmTarZOnTpRq1YtKleubFB+8eJFbt26RdWqVfVllpaWVKhQgd27d7/Tz0dmyRNCCCGEEEIYRb9+/ejZs6dBmaWlZYrbLlu2jNDQUA4cOJDstVu3bgGQKVMmg/JMmTJx+fLld5Q2iVSYhBBCCCGE+IQZc1JxS0vLVCtIL7p69SrdunVj8+bNWFlZpbqdTqczeK4oSrKytyVd8oQQQgghhBCacvDgQcLDwylWrBhmZmaYmZkRHBzMlClTMDMz07csPWtpeiY8PDxZq9PbkgqTEEIIIYQQn7BEFKM9XlelSpU4duwYhw8f1j+KFy9Os2bNOHz4MD4+Pri7u7Nlyxb9e54+fUpwcDBlypR5p5+PdMkTQgghhBBCaIq9vT1+fn4GZba2tjg7O+vLu3fvzujRo8mZMyc5c+Zk9OjR2NjY0LRp03eaRSpMLwgICOD+/fusWbNG7ShCCCGEEEIYhWLUUUzvTt++fYmOjqZjx47cu3ePkiVLsnnzZuzt7d/pcTTTJS8gIACdTodOp8PMzIxs2bLRoUMH7t27p3a0T0b7dq04d2YPjx+GsW/vBsqVLaF2JEC7uUCypZdWs2k1F0i29NJqNq3mgo8rm5WVCe6ZrPDKakMObztsbEzT3H7AyPH4la2R7FGvWbt3eRrJnA27SECnPhTzr8cX9ZozY/7vKMrzC1hbG1Myu1uRPZst3l62eGa2xto67XN55mP6Po1Jy9k+ZUFBQUyaNEn/XKfTMXToUG7evElMTAzBwcHJWqXeBc1UmACqV6/OzZs3uXTpEnPnzuXvv/+mY8eOasd6K4qiEB8fn6z86dOnKqRJ3ddf12XC+KGMGTuF4iWqERKyn3V//0bWrB6SS7J9Etm0mkuyfXzZtJrrY8xmotPx9GkiEZGpL4r5oh+7tydo7e/6x9bVi8iYwZ6qX3ye7tzXb97Gr2yNVF9//OQJbbsPwNXFmWXzJtOvRwcCl/7JwmWr9NtYWZkSHZ3AzVvRXLseRXRMApkzWWFhkfZl3Mf2fUq29yfRiI8PkaYqTJaWlri7u5MlSxaqVq1K48aN2bx5MwAJCQm0bt0ab29vrK2tyZ07N5MnTzZ4f1BQECVKlMDW1hYHBwfKli2rn4d96NChFC5cmFmzZpE1a1ZsbGz4+uuvuX//frIcw4YNw83NjQwZMtCuXTuDyo2iKIwbNw4fHx+sra0pVKgQK1euNMig0+nYtGkTxYsXx9LSkp07d1KxYkU6d+5Mz549cXFxoUqVKnz33XfUrl3b4Njx8fG4u7szf/78d/WxvpYe3doyf8Ey5i9YyunT5+nVewhXr92gfbuWRs3xoeSSbB9fNq3mkmwfXzat5voYs0VFJ3D33lOeRCW81jHs7WxxcXbSP06cPsfDR49pUKuKwXar12+mTtPvKepflzpN2rJs1bp0n9e6zTt4+vQpowb0JKdPdqpULEvblt+waNlq/TaRd59y/0EcsU8TiYtXuHvvKXFxidi+osXsY/s+JZtQi6YqTC+6cOECGzduxNzcHIDExESyZMnC8uXLOXnyJIMHD6Z///4sX74cSKpo1K9fnwoVKnD06FH27NnD999/bzAP+/nz51m+fDl///03Gzdu5PDhw3Tq1MnguNu2bePUqVPs2LGDpUuXsnr1aoYNG6Z/feDAgSxYsIAZM2Zw4sQJevToQfPmzQkODjbYT9++fRkzZgynTp2iYMGCACxcuBAzMzN27drFrFmzaNOmDRs3buTmzZv69/3zzz88fvyYRo0avdsPNA3m5uYULVqQLVsNz2HLlmBKlyputBwv02oukGzppdVsWs0Fki29tJpNq7lAsqVk1bpNlCpeGA/351MUr1y7gSmzFtL1+1as/X02XdsFMHXOIv76Z0sae0rdkeOnKV64ABYWFvqysiWLEh4RiZlZ6mvJ6Ex0JKRRD5TvM320nO190uIseVqiqUkf1q1bh52dHQkJCcTExAAwYcIEIOkf8IsVF29vb3bv3s3y5ctp1KgRDx8+5MGDB9SuXZscOXIAkDdvXoP9x8TEsHDhQrJkyQLA1KlTqVWrFuPHj8fd3R0ACwsL5s+fj42NDfnz52f48OH06dOHESNGEB0dzYQJE9i+fTulS5cGwMfHh5CQEGbNmkWFChX0xxo+fDhVqhjekfL19WXcuHEGZblz52bx4sX07dsXgAULFvD1119jZ2eX4mcUGxtLbKxh14K3XaDLxcUJMzMzwm9HGJSHh0eQyd0t3ft9W1rNBZItvbSaTau5QLKll1azaTUXSLaX3Ym4S8je//hpyA8G5TMDl9KnS1uqVCwLQBYPdy5cusLyvzZQr2aVlHaVpojIu3hmNlwzxtnREQBTUx3x8ckvMB0ymmOi0/HkSfIu/8/I95k+Ws4m1KOpCpO/vz8zZswgKiqKuXPncvbsWbp06aJ/febMmcydO5fLly8THR3N06dPKVy4MABOTk4EBARQrVo1qlSpQuXKlWnUqBGZM2fWvz9btmz6yhJA6dKlSUxM5MyZM/oKU6FChbCxsTHY5vHjx1y9epXw8HBiYmKSVYSePn1KkSJFDMqKF09+FyKlsjZt2jB79mz69u1LeHg469evZ9u2bal+RmPGjDGoOALoTOzQmWZI9T2v68UBppA0kO7lMjVoNRdItvTSajat5gLJll5azabVXCDZnlnzzxbs7eyoVL60vuzuvfvcun2HwWMmMeSn58MCEhISsLO11T+v16wdN26HPwsNwGeVG+hf98jkxl+/zzI4jxelNWOZna0Zjg4W3LodQ0Liq89dvs/00XK29+FDnSXPWDRVYbK1tcXX1xeAKVOm4O/vz7BhwxgxYgTLly+nR48ejB8/ntKlS2Nvb8/PP//Mvn379O9fsGABXbt2ZePGjfzxxx8MHDiQLVu2UKpUqRSP9+wX1Ou0zuh0OhITk4aqrV+/Hk9PT4PXLS0tk51LSuf3spYtW/Ljjz+yZ88e9uzZQ/bs2fn889QHl/br14+ePXsalDk653ll/rRERNwlPj6eTO6uBuWurs6E377zVvt+G1rNBZItvbSaTau5QLKll1azaTUXSLYXKYqSNE6p2hf6oQEAif+/YB76Q1cK5jf822ti8nyUw4zxw4mPT+ovd/tOBN92/oE/A3/Vv25m9nzskYuzExGRhjMC3713H4CEBMOLWFtbM1xdLLkdHkN0TNrjsuT7TB8tZxPq0ewYJoAhQ4bwyy+/cOPGDXbu3EmZMmXo2LEjRYoUwdfXl7CwsGTvKVKkCP369WP37t34+fmxZMkS/WtXrlzhxo0b+ud79uzBxMSEXLly6cuOHDlCdHS0/vnevXuxs7MjS5Ys5MuXD0tLS65cuYKvr6/BI2vWrOk6R2dnZ+rXr8+CBQtYsGAB3377bZrbW1pakiFDBoPH23THA4iLiyM09CiVK5U3KK9cuTx79v73Vvt+G1rNBZItvbSaTau5QLKll1azaTUXSLYXHTh0jCvXbtCwTjWDchcnRzK5OnPtxi2yZfEweGTxcNdv5+GeSV/+bPzTi9u+OCaqkF8eDh45TlxcnL5s9/5Q3FycDbrj2dma4eZiye07MURFv3oSC/k+00fL2d4nmSUvbZpqYXpZxYoVyZ8/v34F30WLFrFp0ya8vb1ZvHgxBw4cwNvbG4CLFy8ye/Zs6tati4eHB2fOnOHs2bO0bPl8RhMrKytatWrFL7/8wsOHD+natSuNGjXSd8eDpO51rVu3ZuDAgVy+fJkhQ4bQuXNnTExMsLe3p3fv3vTo0YPExETKlSvHw4cP2b17N3Z2drRq1Spd59mmTRtq165NQkJCuvfxtiZOnsPCBZM5ePAIe/cdpG3r5mTL6sms2YtVyaP1XJLt48um1VyS7ePLptVcH2M2nQ7MzZ/fGzY3M8HCQiExQSE+QcHJ0YJ+I35hzKDeBu9btW4TBfPlJqdP9mT77PBdc8ZOmomtrQ2flyrO07g4/Wx6rb5p+MbnVauKPzPmL2HAqAm0bdmYy1evM2fRH7T/til7DkwC/l9ZcrUkIjKW2NhETE2TbpQqiQpp9cr72L5PySbUoukKE0DPnj359ttvOXv2LIcPH6Zx48bodDqaNGlCx44d2bBhAwA2NjacPn2ahQsXEhkZSebMmencuTPt2j1fbM7X15eGDRtSs2ZN7t69S82aNZk+fbrB8SpVqkTOnDkpX748sbGxfPPNNwwdOlT/+ogRI3Bzc2PMmDFcuHABBwcHihYtSv/+/dN9jpUrVyZz5szkz58fDw915vhfsWItzk6ODBzQg8yZ3Th+4gx16rbgypXrquTRei7J9vFl02ouyfbxZdNqro8xm6WlKZ6ZrfXPXZyTus8/fBTHnYhYTE113Hw21uj/Hj1+wtagXfzYPeXFar+qWx1rK0sWLFnJhOnzsLayIleO7DRvVD9d52VvZ8ucSaMYNX46jVt3JYO9HS2/aUirbxrSodckADLYm6PT6XB1seLFjmLPziM1H9v3Kdnen495fNa7oFM+kU9o6NChrFmzhsOHD6sdJZmoqCg8PDyYP38+DRu++d0pMwvPV28khBBCiGSib+xUO0KqrD3Sv2Cu0J74p9qtcDXIVsdox1p95W+jHetd0XwL08csMTGRW7duMX78eDJmzEjdunXVjiSEEEIIIYR4gVSYVHTlyhW8vb3JkiULgYGBmJnJ1yGEEEIIIYzrQ11Q1lg+mS55HzPpkieEEEKkj3TJE8ai5S559bLVNtqx/rqyzmjHelekSUMIIYQQQohP2Ic63bexaHodJiGEEEIIIYRQk7QwCSGEEEII8QlTZAxTmqSFSQghhBBCCCFSIS1MQgghhBBCfMJklry0SQuTEEIIIYQQQqRCWpiEEEIIIYT4hMkqQ2mTFiYhhBBCCCGESIW0MAkhhBDik6XlxWGjL29VO0KKrL0qqx1BvGOyDlPapIVJCCGEEEIIIVIhLUxCCCGEEEJ8wmQdprRJC5MQQgghhBBCpEJamIQQQgghhPiEyTpMaZMWJiGEEEIIIYRIhbQwCSGEEEII8QmTdZjSJi1MQgghhBBCCJEKqTAJIYQQQgghRCqkS54QQgghhBCfMJn0IW3SwiSEEEIIIYQQqZAK0wsqVqxI9+7d1Y4hhBBCCCGE0ShG/N+HyOgVpvDwcNq1a0e2bNmwtLTE3d2datWqsWfPHgB0Oh1r1qwxdiwBtG/XinNn9vD4YRj79m6gXNkSakcCtJsLJFt6aTWbVnOBZEsvrWbTai6QbOn1JtmsrExwz2SFV1YbcnjbYWNj+sr9P30ax+S5v1GlcVuKVPmK6k3bseqfre/yFJI5e+ESAd0GUKxqI7746jtmLPzDYDY1WxtTMrtbkT2bLd5etnhmtsba+tXn8szH8n2Kj5/RK0xffvklR44cYeHChZw9e5a1a9dSsWJF7t69+9r7iIuLe48J362EhAQSExOTlT99+lSFNKn7+uu6TBg/lDFjp1C8RDVCQvaz7u/fyJrVQ3JJtk8im1ZzSbaPL5tWc0k242Uz0el4+jSRiMjY1z5Gr2E/s+/gUYb36cy6Rb/y86BeeGfLku7M12/exq9i/VRff/wkira9huLq7MSymT/Tr2tbAv9Yw8Llf+m3sbIyJTo6gZu3orl2PYromAQyZ7LCwuLVl5cf0/f5MUhUFKM9PkQ6xYgTr9+/fx9HR0eCgoKoUKFCstezZ8/O5cuX9c+9vLy4dOkSQ4cOZc2aNXTt2pWRI0dy6dIlEhIS2LRpEyNHjuT48eOYmppSunRpJk+eTI4cOYCkypmHhwdTp04FoHv37kyePJnjx4+TP39+4uPjcXR0ZOXKlVSrVo2KFSvi5+cHwG+//YapqSkdOnRgxIgR6HQ6IKmiM3DgQH7//Xfu37+Pn58fP/30ExUrVgQgMDCQ7t2789tvv9G3b1/Onj3LuXPn8Pf3p02bNpw/f57Vq1dTv359rl69Sr58+Zg2bZr+nCMjI/Hw8GDDhg188cUXr/W5mll4vvmX8ZLdIX8Teug4nbv005cdOxrE2rUbGTBw7Fvv/2PLBZItvbSaTau5QLKll1azaTUXSLb0eptsObztuHk7mqiohGSvRV9OakEK2RdKn+G/sHHpLDJmsE91X6s3bGP+0tVcv3kbT3c3mn1Zi2/q10xx2+s3b1OtSTuOB61J8fVlf21g8uzFBK9eiIWFOQBzf/+TJavXs+fAlVQzZPW05vGTeO7dT/vm9sf6faYl/un1dxHvvSjvWclox/r3+jajHetdMWoLk52dHXZ2dqxZs4bY2OR3VQ4cOADAggULuHnzpv45wPnz51m+fDl//vknhw8fBuDJkyf07NmTAwcOsG3bNkxMTGjQoIG+RadixYoEBQXp9xEcHIyLiwvBwcH648XExFC2bFn9NgsXLsTMzIx9+/YxZcoUJk6cyNy5c/Wvf/vtt+zatYtly5Zx9OhRvv76a6pXr865c+f020RFRTFmzBjmzp3LiRMncHNzA+Dnn3/Gz8+PgwcPMmjQINq0acOSJUsMPovff/8dDw8P/P390/sxvzFzc3OKFi3Ilq3BBuVbtgRTulRxo+V4mVZzgWRLL61m02oukGzppdVsWs0Fki29jJFtx+795M/ty/ylq/niq++o1bwjP09fQMwL1w8r121mytzf6NqmGWsXTaNr2+ZMnb+UvzZuT9cxj5w4Q/HCfvrKEkDZEkUIj7iLmZku1ffpTHQkJK/7GfjUv08tUoz4+BAZdVpxMzMzAgMDadu2LTNnzqRo0aJUqFCBb775hoIFC+Lq6gqAg4MD7u7uBu99+vQpixcv1m8DSS1IL5o3bx5ubm6cPHkSPz8/KlasSLdu3YiIiMDU1JQTJ04wZMgQgoKC6NixI0FBQRQrVgw7Ozv9PrJmzcrEiRPR6XTkzp2bY8eOMXHiRNq2bUtYWBhLly7l2rVreHgkNcv27t2bjRs3smDBAkaPHg0kdRmcPn06hQoVMsj3xRdf0Lt3b4NjdenShb/++otGjRoBSZXFgIAAfYvWy2JjY5NVNhVFSXX71+Hi4oSZmRnhtyMMysPDI8jk7pbu/b4treYCyZZeWs2m1Vwg2dJLq9m0mgskW3oZI9u1G7cJPXYKCwsLJo/4kXsPHjJy4iwePHrMyB+6ADBz0XL6dPyWKuVLA5AlcyYuXLrK8r83Ua/66/VYeVHE3Xt4vpTf2dEBAFNTHfHxyS99HTKaY6LT8eRJfJr7/tS/T/HhMfo6TF9++SW1atVi586d7Nmzh40bNzJu3Djmzp1LQEBAqu/z8vIyqCwBhIWFMWjQIPbu3UtERIS+ZenKlSv4+fnh5+eHs7MzwcHBmJubU6hQIerWrcuUKVMAUuwaWKpUKYPKR+nSpRk/fjwJCQmEhoaiKAq5cuUyeE9sbCzOzs765xYWFhQsWDDZORQvbnhnwtLSkubNmzN//nwaNWrE4cOHOXLkSJqTXowZM4Zhw4YZlOlM7NCZZkj1Pa/r5d6ZOp0uWZkatJoLJFt6aTWbVnOBZEsvrWbTai6QbOn1PrMlKonodDp+GtgDeztbAPp0iqPnkHEM7P49UdEx3AqPYPC4aQz5ebr+fQkJCdjZ2eif1wvowo1bd54lBuCz6t/oX/dwd+WvwKkG55DWOb7IztYMRwcLbt2OISHx9c77U/0+tUjWYUqbKgvXWllZUaVKFapUqcLgwYNp06YNQ4YMSbPCZGtrm6ysTp06ZM2alTlz5uDh4UFiYiJ+fn76CRV0Oh3ly5cnKCgICwsL/RilhIQEjh07xu7du99oGvHExERMTU05ePAgpqaGs8C82EplbW2dYotPSufQpk0bChcuzLVr15g/fz6VKlXCy8sr1Qz9+vWjZ8+eBmWOznle+xxSEhFxl/j4eDK5G1ZIXV2dCb99J5V3vX9azQWSLb20mk2ruUCypZdWs2k1F0i29DJGNldnJ9xcnPSVJQAfrywoisLtO5HY2iRViob27kTBvIY3dU1Mn4++mDF2EPHxSf3lbkdE8m33gfw5d6L+dTOz59c2Lk6ORNy9b7Cvu/cfAJCQYHhxbWtrhquLJbfDY4iOeUV/POT7FB8eTazDlC9fPp48eQIk9R1NeFXnV5ImRzh16hQDBw6kUqVK5M2bl3v37iXb7tk4pqCgICpWrIhOp+Pzzz/nl19+ITo62mD8EsDevXuTPc+ZMyempqYUKVKEhIQEwsPD8fX1NXi83IXwdRUoUIDixYszZ84clixZwnfffZfm9paWlmTIkMHg8Tbd8SCpC2Fo6FEqVypvUF65cnn27P3vrfb9NrSaCyRbemk1m1ZzgWRLL61m02oukGzpZYxsRfzycCfyLlFR0fqyy1dvYGJiQiZXZ1ycHMjk4sy1m7fIliWzwSNL5kz693i4u+nLPTIlVQhe3NbjhS5nhfLn5uCREwYzE+8+cBg3FyeD7nh2tma4uVhy+04MUdGvvn4D+T61KBHFaI8PkVFbmCIjI/n666/57rvvKFiwIPb29vz333+MGzeOevXqAUkz5W3bto2yZctiaWmJo6NjivtydHTE2dmZ2bNnkzlzZq5cucKPP/6YbLtn45jMzMz4/PPP9WW9evWiaNGiZMhg2JXt6tWr9OzZk3bt2hEaGsrUqVMZP348ALly5aJZs2a0bNmS8ePHU6RIESIiIti+fTsFChSgZs2UZ6J5lTZt2tC5c2dsbGxo0KBBuvbxtiZOnsPCBZM5ePAIe/cdpG3r5mTL6sms2YtVyaP1XJLt48um1VyS7ePLptVcks142XQ6MDd/fs/a3MwECwuFxASF+AQFJ0cLzEyf3wytVak8MxctZ+BPU+n0bRPuPXjI+JkLaVCjElaWlgB0CPiGsVPnYGtjw+cli/I0Lo4TZ8J4+OgxrRrVe+NzqlWpPDMC/2DA2Cm0bfYVl6/fZM7vK2nfshF7DiTN7mtna4abqyURkbHExiZi+v/MSqLCq3rlfUzfp/j4GbXCZGdnR8mSJZk4cSJhYWHExcWRNWtW2rZtS//+/QEYP348PXv2ZM6cOXh6enLp0qUU92ViYsKyZcvo2rUrfn5+5M6dmylTpuin937Gz88PFxcXvLy89JWjChUqkJCQkOLU5i1btiQ6OpoSJUpgampKly5d+P777/WvL1iwgJEjR9KrVy+uX7+Os7MzpUuXTndlCaBJkyZ0796dpk2bYmVlle79vI0VK9bi7OTIwAE9yJzZjeMnzlCnbguuXFF3Ckyt5pJsH182reaSbB9fNq3mkmzGy2ZpaYpnZmv9cxfnpErPw0dx3ImIxdRUh5nZ8wqVjY01c34Zxugpc2jcrhcZM9hT3b8sXVo302/zVe0qWFtZsGDZGibMWoi1lRW5fLxo/lWddJ2TvZ0tc8YPZdSk2TRu15sM9na0/LourRrVo0PfpApTBntzdDodri5WvNiB7dl5pOVj+j4/Bh/z+Kx3wajrMImUXb16lezZs3PgwAGKFi36xu9/F+swCSGEEEJbnq3DpDXWXpXVjvBB0vI6TKU8KhrtWHtvBBntWO+KKpM+iCRxcXHcvHmTH3/8kVKlSqWrsiSEEEIIIcTb+FDHFhmLJiZ9+FTt2rULLy8vDh48yMyZM9WOI4QQQgghhHiJtDCpqGLFitJnVAghhBBCqEqRFqY0SQuTEEIIIYQQQqRCWpiEEEIIIYT4hEmPp7RJC5MQQgghhBBCpEIqTEIIIYQQQgiRCumSJ4QQQgghxCdMphVPm7QwCSGEEEIIIUQqpIVJCCGEEEKIT5hM+pA2aWESQgghhBBCaMqYMWP47LPPsLe3x83Njfr163PmzBmDbRRFYejQoXh4eGBtbU3FihU5ceLEO88iLUxCCCGEEBpk7VVZ7Qgpir6xU+0IqbL2+FztCB8kLY5hCg4OplOnTnz22WfEx8czYMAAqlatysmTJ7G1tQVg3LhxTJgwgcDAQHLlysXIkSOpUqUKZ86cwd7e/p1l0SnSBvfBM7PwVDuCEEIIIT4RUmFKn/in19WOkKpC7mWMdqz9l3cQGxtrUGZpaYmlpWWa77tz5w5ubm4EBwdTvnx5FEXBw8OD7t2788MPPwAQGxtLpkyZ+Omnn2jXrt07yyxd8oQQQgghhPiEKUb835gxY8iYMaPBY8yYMa/M+ODBAwCcnJwAuHjxIrdu3aJq1ar6bSwtLalQoQK7d+9+p5+PdMkTQgghhBBCGEW/fv3o2bOnQdmrWpcURaFnz56UK1cOPz8/AG7dugVApkyZDLbNlCkTly9ffoeJpcIkhBBCCCHEJy3RiCN0Xqf73cs6d+7M0aNHCQkJSfaaTqczeK4oSrKytyVd8oQQQgghhBCa1KVLF9auXcuOHTvIkiWLvtzd3R143tL0THh4eLJWp7clFSYhhBBCCCE+YcYcw/TamRSFzp07s2rVKrZv3463t7fB697e3ri7u7NlyxZ92dOnTwkODqZMmXc7iYV0yRNCCCGEEEJoSqdOnViyZAl//fUX9vb2+pakjBkzYm1tjU6no3v37owePZqcOXOSM2dORo8ejY2NDU2bNn2nWaTCJIQQQgghxCfMmGOYXteMGTMAqFixokH5ggULCAgIAKBv375ER0fTsWNH7t27R8mSJdm8efM7XYMJZB2mj4KswySEEEIIY5F1mNJHy+sw5XUrYbRjnQrfb7RjvSsf1BimoUOHUrhwYbVjpJtOp2PNmjVqxxBCCCGEEEJPi2OYtERzFaaAgAB0Oh06nQ5zc3N8fHzo3bs3T548oXfv3mzbtk3tiB+t9u1ace7MHh4/DGPf3g2UK2u8uw1p0WoukGzppdVsWs0Fki29tJpNq7lAsqWXVrO9aS4rKxPcM1nhldWGHN522NiYprn9gJHj8StbI9mjXrN27/I0kjkbdpGATn0o5l+PL+o1Z8b833mx05StjSmZ3a3Ins0Wby9bPDNbY22d9rm8SKvfp1CH5ipMANWrV+fmzZtcuHCBkSNHMn36dHr37o2dnR3Ozs5qx/soff11XSaMH8qYsVMoXqIaISH7Wff3b2TN6iG5JNsnkU2ruSTbx5dNq7kk28eXLT25THQ6nj5NJCIy9rWO8WP39gSt/V3/2Lp6ERkz2FP1i/R3jbt+8zZ+ZWuk+vrjJ09o230Ari7OLJs3mX49OhC49E8WLlul38bKypTo6ARu3orm2vUoomMSyJzJCguLV1/6avX7fJ8SFcVojw+R5sYwBQQEcP/+fYOua23btmXdunW0a9eONWvWcPjwYYNty5Urx/jx43n69CnffPMNkyZNwtzcHEiaXnDgwIH8/vvv3L9/Hz8/P3766Sf9ALLIyEg6d+7Mzp07uXv3Ljly5KB///40adJEf/yKFSvqVxX+7bffMDU1pUOHDowYMUK/MFb27Nlp3bo1p06dYu3atWTIkIF+/frRpUsX/X50Oh2rV6+mfv36AFy/fp2ePXuyefNmTExMKFeuHJMnTyZ79uxv9Jm9izFMu0P+JvTQcTp36acvO3Y0iLVrNzJg4Ni33v/HlgskW3ppNZtWc4FkSy+tZtNqLpBs6aXVbG+bK4e3HTdvRxMVlWBQntYYpm3/7qZ7/5FsWrkAD/fna+GsXr+Z+b+v5PrNW3i6Z6LZ1/X4pmHtFPdx/eZtqn0VwPFdG1J8fdnqdUyeGUjw30uwsLAAYO7i5SxZuZY9By6nmi2rpzWPn8Rz735cqtvA+/s+tTyGKZdrcaMd6+yd/4x2rHdFky1ML7O2tiYuLuV/3Dt27CAsLIwdO3awcOFCAgMDCQwM1L/+7bffsmvXLpYtW8bRo0f5+uuvqV69OufOnQMgJiaGYsWKsW7dOo4fP873339PixYt2Ldvn8FxFi5ciJmZGfv27WPKlClMnDiRuXPnGmzz888/U7BgQUJDQ+nXrx89evQwmBv+RVFRUfj7+2NnZ8e///5LSEgIdnZ2VK9enadPn77Fp/XmzM3NKVq0IFu2BhuUb9kSTOlSxvsBeplWc4FkSy+tZtNqLpBs6aXVbFrNBZItvbSaTa1cq9ZtolTxwgaVpZVrNzBl1kK6ft+Ktb/Ppmu7AKbOWcRf/6R8jfQqR46fpnjhAvrKEkDZkkUJj4jEzEyX6vt0JjoSElJ9GdDu9ynUpflpxffv38+SJUuoVKlSiq87Ojoybdo0TE1NyZMnD7Vq1WLbtm20bduWsLAwli5dyrVr1/DwSGpG7d27Nxs3bmTBggWMHj0aT09Pevfurd9fly5d2LhxIytWrKBkyZL68qxZszJx4kR0Oh25c+fm2LFjTJw4kbZt2+q3KVu2LD/++CMAuXLlYteuXUycOJEqVaoky71s2TJMTEyYO3euvpVqwYIFODg4EBQURNWqVd/+w3tNLi5OmJmZEX47wqA8PDyCTO5uRsvxMq3mAsmWXlrNptVcINnSS6vZtJoLJFt6aTWbGrnuRNwlZO9//DTkB4PymYFL6dOlLVUqlgUgi4c7Fy5dYflfG6hXM/k10qtERN7FM3MmgzJnR0cATE11xMcn7zzlkNEcE52OJ0/i09y3Vr/P9+1DnYzBWDRZYVq3bh12dnbEx8cTFxdHvXr1mDp1KtOnT0+2bf78+TE1fT6IL3PmzBw7dgyA0NBQFEUhV65cBu+JjY3Vj4VKSEhg7Nix/PHHH1y/fp3Y2FhiY2OxtbU1eE+pUqX0FRuA0qVLM378eBISEvTHL126tMF7SpcuzaRJk1I8x4MHD3L+/Plk88THxMQQFhaW6mfzLN+LFEUxyJZeL/fO1Ol0ycrUoNVcINnSS6vZtJoLJFt6aTWbVnOBZEsvrWYzZq41/2zB3s6OSuWfXw/dvXefW7fvMHjMJIb8NFlfnpCQgN0L11r1mrXjxu3wZ6EB+KxyA/3rHpnc+Ov3WQbn8aK0LvjtbM1wdLDg1u0YEhJf79y1+n0KdWiywuTv78+MGTMwNzfHw8NDPx4pJS+/ptPpSExMBCAxMRFTU1MOHjxoUKkCsLOzA2D8+PFMnDiRSZMmUaBAAWxtbenevfs76xaXWkUmMTGRYsWK8fvvvyd7zdXVNdX9jRkzhmHDhhkew8QOnWmGdGeMiLhLfHw8mdwNj+vq6kz47Tvp3u/b0moukGzppdVsWs0Fki29tJpNq7lAsqWXVrMZO5eiKKxev5k61b4wuDZ7Nsh/6A9dKZg/j8F7TEyejwyZMX448fFJ/eVu34ng284/8Gfgr/rXzcyeX8e5ODsREXnPYF93790HICHBsFJja2uGq4slt8NjiI55RX88tPt9vm8f6mQMxqLJMUy2trb4+vri5eWVZmXpVYoUKUJCQgLh4eH4+voaPNzd3QHYuXMn9erVo3nz5hQqVAgfHx/9+KYX7d27N9nznDlzGlTEUtomTx7DXw7PFC1alHPnzuHm5pYsW8aMGVM9p379+vHgwQODh87k7VYzjouLIzT0KJUrlTcor1y5PHv2qjcwT6u5QLKll1azaTUXSLb00mo2reYCyZZeWs1m7FwHDh3jyrUbNKxTzaDcxcmRTK7OXLtxi2xZPAweWTzc9dt5uGfSlz8b//Titi+OiSrkl4eDR44bjG/fvT8UNxdng+54drZmuLlYcvtODFHRr64sgXa/T6EuTbYwvSu5cuWiWbNmtGzZkvHjx1OkSBEiIiLYvn07BQoUoGbNmvj6+vLnn3+ye/duHB0dmTBhArdu3SJv3rwG+7p69So9e/akXbt2hIaGMnXqVMaPH2+wza5duxg3bhz169dny5YtrFixgvXr16eYrVmzZvz888/Uq1eP4cOHkyVLFq5cucKqVavo06cPWbJkSfF9lpaWWFpaGpS9i+54EyfPYeGCyRw8eIS9+w7StnVzsmX1ZNbsxW+9748xl2T7+LJpNZdk+/iyaTWXZPv4sqUnl04H5ubP76ebm5lgYaGQmKAQn6Dg5GhBvxG/MGZQb4P3rVq3iYL5cpPTJ3uyfXb4rjljJ83E1taGz0sV52lcHCdOn+Pho8e0+qbhG59XrSr+zJi/hAGjJtC2ZWMuX73OnEV/0P7bpuw5MAn4f2XJ1ZKIyFhiYxMxNU26VlISFV7VK0+r3+f7JGOY0vZRV5ggaSKFkSNH0qtXL65fv46zszOlS5emZs2aAAwaNIiLFy9SrVo1bGxs+P7776lfvz4PHjww2E/Lli2Jjo6mRIkSmJqa0qVLF77//nuDbXr16sXBgwcZNmwY9vb2jB8/nmrVDO+0PGNjY8O///7LDz/8QMOGDXn06BGenp5UqlSJDBnS370uvVasWIuzkyMDB/Qgc2Y3jp84Q526LbhyRd0pMLWaS7J9fNm0mkuyfXzZtJpLsn182dKTy9LSFM/M1vrnLs5JN2kfPorjTkQspqY6bj4ba/R/jx4/YWvQLn7snvJitV/VrY61lSULlqxkwvR5WFtZkStHdpo3qp+u87K3s2XOpFGMGj+dxq27ksHejpbfNKTVNw3p0GsSABnszdHpdLi6WPFi57pn55EWrX6fQj2aW4dJiypWrEjhwoVTncABktZh6t69O927dzdarmfexTpMQgghhBCvI611mNRm7ZH+BXPfNy2vw+TtXMhox7oYecRox3pXNDmGSQghhBBCCCG04KPvkieEEEIIIYRIXaKMYUqTVJheQ1BQ0Cu3uXTp0nvPIYQQQgghhDAuqTAJIYQQQgjxCZMpDdImY5iEEEIIIYQQIhXSwiSEEEIIIcQnTMYwpU1amIQQQgghhBAiFdLCJIQQQgghxCdMxjClTVqYhBBCCCGEECIV0sIkhBBCCCHEJyxRWpjSJC1MQgghhBBCCJEKaWESQgghhBCvzdrjc7UjpCr68la1I3yQFJklL03SwiSEEEIIIYQQqZAKkxBCCCGEEEKkQrrkCSGEEEII8QmTacXTJi1MQgghhBBCCJEKaWESQgghhBDiE5Yokz6kSVqYhBBCCCGEECIV0sIkhBBCCCHEJ0zGMKVNWpiEEEIIIYQQIhXSwiSEEEIIIcQnLFFamNIkLUxCCCGEEEIIkQppYRJCCCGEEOITJmOY0vZGLUwBAQHodDp0Oh3m5ub4+PjQu3dvnjx58r7yfRQCAgKoX7++2jFeqX27Vpw7s4fHD8PYt3cD5cqWUDsSoN1cINnSS6vZtJoLJFt6aTWbVnOBZEsvrWbTai5482xWVia4Z7LCK6sNObztsLExfeUxnj6NY/Lc36jSuC1FqnxF9abtWPXP1nd1Cik6e+ESAd0GUKxqI7746jtmLPzDoEKyefNmvv32W0qVKkXRokVp3LgxO3fufK+ZxNt54y551atX5+bNm1y4cIGRI0cyffp0evfu/T6yvTcJCQkkJiaqHUNTvv66LhPGD2XM2CkUL1GNkJD9rPv7N7Jm9ZBcku2TyKbVXJLt48um1VyS7ePLptVc6c1motPx9GkiEZGxr32cXsN+Zt/Bowzv05l1i37l50G98M6WJd25r9+8jV/F+qm+/vhJFG17DcXV2YllM3+mX9e2BP6xhoXL/9Jvc+DAAcqUKcPs2bNZtWoVJUuWpEOHDpw8eTLdud5WIorRHh+iN64wWVpa4u7uTtasWWnatCnNmjVjzZo1xMbG0rVrV9zc3LCysqJcuXIcOHBA/76goCB0Oh2bNm2iSJEiWFtb88UXXxAeHs6GDRvImzcvGTJkoEmTJkRFRenfpygK48aNw8fHB2trawoVKsTKlSsNMq1du5acOXNibW2Nv78/CxcuRKfTcf/+fQACAwNxcHBg3bp15MuXD0tLSy5fvsyBAweoUqUKLi4uZMyYkQoVKhAaGmqwb51Ox9y5c2nQoAE2NjbkzJmTtWvX6l9PSEigdevWeHt7Y21tTe7cuZk8ebL+9aFDh7Jw4UL++usvfetcUFAQANevX6dx48Y4Ojri7OxMvXr1uHTp0pt+Je9Ej25tmb9gGfMXLOX06fP06j2Eq9du0L5dS1XyaD2XZPv4smk1l2T7+LJpNZdk+/iyaTVXerNFRSdw995TnkQlvNYxQvaF8t/h48z4aRClixfCM3MmCuTNRRG/PAbbrd6wjTotO1O0ytfUadGJZWv+Sfd5rdsazNOnTxn1Y1dy+nhRpXxp2jb7ikUr1upbmQYMGEDbtm0pWLAg2bNnp2fPnnh5ebF9+/Z0H1e8X2896YO1tTVxcXH07duXP//8k4ULFxIaGoqvry/VqlXj7t27BtsPHTqUadOmsXv3bq5evUqjRo2YNGkSS5YsYf369WzZsoWpU6fqtx84cCALFixgxowZnDhxgh49etC8eXOCg4MBuHTpEl999RX169fn8OHDtGvXjgEDBiTLGRUVxZgxY5g7dy4nTpzAzc2NR48e0apVK3bu3MnevXvJmTMnNWvW5NGjRwbvHTZsGI0aNeLo0aPUrFmTZs2a6c8rMTGRLFmysHz5ck6ePMngwYPp378/y5cvB6B37940atRI3zJ38+ZNypQpQ1RUFP7+/tjZ2fHvv/8SEhKCnZ0d1atX5+nTp2/7tbwRc3NzihYtyJatwQblW7YEU7pUcaNmeZFWc4FkSy+tZtNqLpBs6aXVbFrNBZItvbSaTau5wHjZduzeT/7cvsxfupovvvqOWs078vP0BcTEPm+hWrluM1Pm/kbXNs1Yu2gaXds2Z+r8pfy1MX2VlyMnzlC8sB8WFub6srIlihAecZdr166l+J7ExESePHmCg4NDuo75LiiKYrTHh+itJn3Yv38/S5Yswd/fnxkzZhAYGEiNGjUAmDNnDlu2bGHevHn06dNH/56RI0dStmxZAFq3bk2/fv0ICwvDx8cHgK+++oodO3bwww8/8OTJEyZMmMD27dspXbo0AD4+PoSEhDBr1iwqVKjAzJkzyZ07Nz///DMAuXPn5vjx44waNcoga1xcHNOnT6dQoUL6si+++MJgm1mzZuHo6EhwcDC1a9fWlwcEBNCkSRMARo8ezdSpU9m/fz/Vq1fH3NycYcOG6bf19vZm9+7dLF++nEaNGmFnZ4e1tTWxsbG4u7vrt/vtt98wMTFh7ty56HQ6ABYsWICDgwNBQUFUrVo1xc88NjaW2FjDpmhFUfT7SA8XFyfMzMwIvx1hUB4eHkEmd7d07/dtaTUXSLb00mo2reYCyZZeWs2m1Vwg2dJLq9m0mguMl+3ajduEHjuFhYUFk0f8yL0HDxk5cRYPHj1m5A9dAJi5aDl9On5LlfJJ15lZMmfiwqWrLP97E/Wqf5HW7lMUcfceni+dg7OjQ9JrERFkzZo12Xvmz59PdHS0/hpaaM8bV5jWrVuHnZ0d8fHxxMXFUa9ePbp06cLKlSv1FSFIuntQokQJTp06ZfD+ggUL6v87U6ZM2NjY6CtLz8r2798PwMmTJ4mJiaFKlSoG+3j69ClFihQB4MyZM3z22WcGr5cokXzQoIWFhcGxAcLDwxk8eDDbt2/n9u3bJCQkEBUVxZUrV1LNbGtri729PeHh4fqymTNnMnfuXC5fvkx0dDRPnz6lcOHCyT+8Fxw8eJDz589jb29vUB4TE0NYWFiq7xszZoxBBQ1AZ2KHzjRDmsd7HS/X+nU6nSbuBGg1F0i29NJqNq3mAsmWXlrNptVcINnSS6vZtJoL3n+2RCURnU7HTwN7YG9nC0CfTnH0HDKOgd2/Jyo6hlvhEQweN40hP0/Xvy8hIQE7Oxv983oBXbhx686z1AB8Vv0b/ese7q78Ffi8d9TLN7GfnVNKN7fXrVvHtGnTmD59Os7Ozm93wm9B1mFK2xtXmJ61Jpmbm+Ph4YG5uTlHjhwBUv4H8nKZufnzJspns+29SKfT6SdkePb/69evx9PT02A7S0vLVI+R0g+btbV1su0CAgK4c+cOkyZNwsvLC0tLS0qXLp2sS1xaGZcvX06PHj0YP348pUuXxt7enp9//pl9+/Yly/CixMREihUrxu+//57sNVdX11Tf169fP3r27GlQ5uicJ5WtX09ExF3i4+PJ5G54XFdXZ8Jv30nlXe+fVnOBZEsvrWbTai6QbOml1WxazQWSLb20mk2rucB42VydnXBzcdJXlgB8vLKgKAq370Ria5NUKRrauxMF8+YyeK+J6fNRKzPGDiI+Pmnc1O2ISL7tPpA/507Uv25m9ny2PhcnRyLu3jfY1937DwCSVYj++ecfBgwYwOTJkylTpsxbnKl43954DJOtrS2+vr54eXnpKxK+vr5YWFgQEhKi3y4uLo7//vuPvHnzpjvcswkarly5gq+vr8HjWZNmnjx5DCaXAPjvv/9ea/87d+6ka9eu1KxZk/z582NpaUlERMSr3/jSPsqUKUPHjh0pUqQIvr6+yVqILCwsSEgwHKBYtGhRzp07h5ubW7Jzy5gxY6rHs7S0JEOGDAaPt+mOB0nfVWjoUSpXKm9QXrlyefbsfb3P8n3Qai6QbOml1WxazQWSLb20mk2ruUCypZdWs2k1FxgvWxG/PNyJvEtUVLS+7PLVG5iYmJDJ1RkXJwcyuThz7eYtsmXJbPDIkjmT/j0e7m76co9MSZW8F7f1eKELXqH8uTl45ARxcXH6st0HDuPm4kSWLM9n51u3bh0//vgj48ePp2LFiu/snNNLMeL/PkTvZOFaW1tbOnToQJ8+fXByciJbtmyMGzeOqKgoWrdune792tvb07t3b3r06EFiYiLlypXj4cOH7N69Gzs7O1q1akW7du2YMGECP/zwA61bt+bw4cMEBgYCKTd9vsjX15fFixdTvHhxHj58SJ8+fbC2tn6jjL6+vixatIhNmzbh7e3N4sWLOXDgAN7e3vptsmfPzqZNmzhz5gzOzs5kzJiRZs2a8fPPP1OvXj2GDx9OlixZuHLlCqtWraJPnz4GP1TGMHHyHBYumMzBg0fYu+8gbVs3J1tWT2bNXmzUHB9KLsn28WXTai7J9vFl02ouyfbxZdNqrvRm0+nA3Pz5vX5zMxMsLBQSExTiExScHC3oN3oSY/p3B6BWpfLMXLScgT9NpdO3Tbj34CHjZy6kQY1KWP2/p1KHgG8YO3UOtjY2fF6yKE/j4jhxJoyHjx7TqlG9Nz6vWpXKMyPwDwaMnULbZl9x+fpN5vy+kvYtG+mvS9etW8cPP/xA//79KVSoEHfuJLWqWVlZJRuqIbThnVSYAMaOHUtiYiItWrTg0aNHFC9enE2bNuHo6PhW+x0xYgRubm6MGTOGCxcu4ODgQNGiRenfvz+QNMnCypUr6dWrF5MnT6Z06dIMGDCADh066LvtpWb+/Pl8//33FClShGzZsjF69Og3XlOqffv2HD58mMaNG6PT6WjSpAkdO3Zkw4YN+m3atm1LUFAQxYsX5/Hjx+zYsYOKFSvy77//8sMPP9CwYUMePXqEp6cnlSpVIkOGtx+P9KZWrFiLs5MjAwf0IHNmN46fOEOdui24cuW60bN8CLkk28eXTau5JNvHl02ruSTbx5dNq7nSm83S0hTPzM9vbLs4J13nPXwUx52IWExNddx8oUufjY01c34Zxugpc2jcrhcZM9hT3b8sXVo302/zVe0qWFtZsGDZGibMWoi1lRW5fLxo/lWddJ2XvZ0tc8YPZdSk2TRu15sM9na0/LquQeXrjz/+ID4+nuHDhzN8+HB9eYMGDRg7dmy6jiveL52ilZF/79CoUaOYOXMmV69eVTuKUZhZeL56IyGEEEKIj1z05a1qR0iVeeb0D1N536ytvYx2rOjoy0Y71rvyzlqY1DR9+nQ+++wznJ2d2bVrFz///DOdO3dWO5YQQgghhBDiA/dRVJjOnTvHyJEjuXv3LtmyZaNXr17069dP7VhCCCGEEEJo3kfY4eyd+ii75H1qpEueEEIIIYR0yUsvK6tsRjtWTMyVV2+kMR9FC5MQQgghhBAifT7U6b6N5Y3XYRJCCCGEEEKIT4W0MAkhhBBCCPEJkxE6aZMWJiGEEEIIIYRIhVSYhBBCCCGE+IQpimK0x5uaPn063t7eWFlZUaxYMXbu3PkePoG0SYVJCCGEEEIIoTl//PEH3bt3Z8CAARw6dIjPP/+cGjVqcOWKcWfak2nFPwIyrbgQQgghhEwrnl7GvJaMf3r9tbctWbIkRYsWZcaMGfqyvHnzUr9+fcaMGfM+4qVIWpiEEEIIIYQQRhEbG8vDhw8NHrGxscm2e/r0KQcPHqRq1aoG5VWrVmX37t3GiptEEeL/YmJilCFDhigxMTFqR0lGsr05reZSFMmWXlrNptVciiLZ0kur2bSaS1EkW3ppNZtWc30MhgwZogAGjyFDhiTb7vr16wqg7Nq1y6B81KhRSq5cuYyUNol0yRN6Dx8+JGPGjDx48IAMGTKoHceAZHtzWs0Fki29tJpNq7lAsqWXVrNpNRdItvTSajat5voYxMbGJmtRsrS0xNLS0qDsxo0beHp6snv3bkqXLq0vHzVqFIsXL+b06dNGyQuyDpMQQgghhBDCSFKqHKXExcUFU1NTbt26ZVAeHh5OpkyZ3le8FMkYJiGEEEIIIYSmWFhYUKxYMbZs2WJQvmXLFsqUKWPULNLCJIQQQgghhNCcnj170qJFC4oXL07p0qWZPXs2V65coX379kbNIRUmoWdpacmQIUNeq5nU2CTbm9NqLpBs6aXVbFrNBZItvbSaTau5QLKll1azaTXXp6Zx48ZERkYyfPhwbt68iZ+fH//88w9eXl5GzSGTPgghhBBCCCFEKmQMkxBCCCGEEEKkQipMQgghhBBCCJEKqTAJIYQQQgghRCqkwiSEEEIIIYQQqZAKkxBCCCGEEEKkQipMQryhf//9l/j4+GTl8fHx/PvvvyokEkIIIYQQ74tUmIR4Q/7+/ty9ezdZ+YMHD/D391chUcquXbvG9evX1Y6ht3HjRkJCQvTPf/31VwoXLkzTpk25d++eismS7Ny5k+bNm1O6dGn957Z48WKDzGqLiYlRO4KBsLAwBg4cSJMmTQgPDweSvucTJ06onCxl9+/fVzuCEEYTFBSkdgQhPhpSYRLiDSmKgk6nS1YeGRmJra2tComeS0xMZPjw4WTMmBEvLy+yZcuGg4MDI0aMIDExUdVsffr04eHDhwAcO3aMXr16UbNmTS5cuEDPnj1Vzfbnn39SrVo1rK2tOXToELGxsQA8evSI0aNHq5otMTGRESNG4OnpiZ2dHRcuXABg0KBBzJs3T7VcwcHBFChQgH379rFq1SoeP34MwNGjRxkyZIhquZ756aef+OOPP/TPGzVqhLOzM56enhw5ckTFZLBt2zb69+9PmzZt+O677wweart//z6bN2/mt99+Y9GiRQYPtV2/fp3ly5czbdo0pkyZYvBQU2BgIFFRUapmSEn16tXJkSMHI0eO5OrVq2rHSSY+Pp6tW7cya9YsHj16BMCNGzf0v0vUpOVsQiWK+CQ5Ojoqd+7cURRFURwcHBRHR8dUH2rav3+/0qdPH6Vx48ZKgwYNDB7G9uy4JiYmSs2aNQ2y1K1bV8mePbtSrVo1o+d60Y8//qi4uroq06dPV44cOaIcPnxY+fXXXxVXV1elf//+qmaztbVVLl68qCiKogwZMkT58ssvFUVRlIMHDyqZMmVSMZmiFC5cWFm4cKGiKIpiZ2enhIWFKYqiKIcOHVI927BhwxQfHx/lt99+U6ytrfXZ/vjjD6VUqVKq5SpVqpQyfvx4RVEMP7P9+/crHh4equV6xtvbW9m1a5eiKIqyefNmxcHBQdm0aZPSunVrpUqVKqrlGjp0qGJiYqKUKFFCqVevnlK/fn2Dh5rWrl2r2NvbKyYmJkrGjBkVBwcH/UPtvwXz589XLCwsFDs7O8XLy0vJnj27/uHt7a1qNnd3d8Xe3l757rvv9P/mtCAyMlKZPHmyUqRIEcXU1FSpWrWq8scffyixsbFqR1MuXbqk5MmTR7GxsVFMTU31vz+6deumtGvXTrIJzTFTu8Im1DFx4kTs7e31/51Si4nali1bRsuWLalatSpbtmyhatWqnDt3jlu3btGgQQOj58mYMSOQ1MJkb2+PtbW1/jULCwtKlSpF27ZtjZ7rRQsXLmTu3LnUrVtXX1aoUCE8PT3p2LEjo0aNUi2bhYWF/i7s1q1badmyJQBOTk76lie1nDlzhvLlyycrz5Ahg+rduBYtWsTs2bOpVKkS7du315cXLFiQ06dPq5br2LFjLFmyJFm5q6srkZGRKiQydPPmTbJmzQrAunXraNSoEVWrViV79uyULFlStVwzZ84kMDCQFi1aqJYhNb169eK7775j9OjR2NjYqB3HwODBgxk8eDD9+vXDxERbnWOuXbvG+vXrCQwMxN/fH29vb7799ltatWqFu7u7armcnJzo2rUrXbt25fDhw8yfP59OnTrRoUMHmjVrRuvWrSlUqJAq2bp160bx4sU5cuQIzs7O+vIGDRrQpk0bVTI9o+VsQkVq19iESE2BAgWUadOmKYry/A52YmKi0rZtW2Xw4MGq5Ro6dKjy+PFj1Y6fFktLS+XMmTPJyk+fPq1YWVmpkOi5OnXqKNWqVVOGDx+umJubK9euXVMURVE2bdqk5MyZU9VsPj4+ypYtWxRFMWwtWbhwoZI3b141oylWVlbKpUuXFEUxzHbixAnF1tZWtVyenp76u+kv5lq1apXi4+OjWq5nMmfOrM+XK1cuZfny5YqiJP0s2Nvbq5bLyclJOX/+vGrHT4uNjY3+e9QaLX9uL7p9+7Yyfvx4pUCBAoq5ublSp04dZc2aNUpCQoLa0ZTr168rQ4YMUSwtLRVbW1vF1NRUKVeunHL8+HGjZ3F2dlZOnz6tKIrh74+LFy8q1tbWRs/zIi1nE+rR1m0aoYpmzZoxZ84czp49q3YUA2FhYdSqVQsAS0tLnjx5gk6no0ePHsyePVu1XEOGDMHW1pY7d+4QEhLCrl27uHPnjmp5XlSoUCGmTZuWrHzatGmq3Ul8MYOZmRkrV65kxowZeHp6ArBhwwaqV6+uarZ27drRrVs39u3bh06n48aNG/z+++/07t2bjh07qpotf/787Ny5M1n5ihUrKFKkiAqJkjRt2pQffviBW7duodPpSExMZNeuXfTu3Vvfeqimhg0b0rRpU6pUqUJkZCQ1atQA4PDhw/j6+qqWq02bNim2zGlBtWrV+O+//9SOkaLWrVuzYsUKtWO8kpubG2XLlqV06dKYmJhw7NgxAgICyJEjhyqTMMTFxbFy5Upq1qyJl5cXmzZtYtq0ady+fZuLFy+SNWtWvv76a6PnSkxMJCEhIVn5tWvX9L1f1KLlbEI90iVPYGdnx/jx42nXrh3u7u5UqFCBChUqULFiRfLkyaNaLicnJ/1gS09PT44fP06BAgW4f/++qgNso6Ki6Ny5M4sWLdJPpGBqakrLli2ZOnWqql1Zxo0bR61atdi6dSulS5dGp9Oxe/durl69yj///KNaLoBs2bKxbt26ZOUTJ05UIY2hvn376mc5jImJoXz58lhaWtK7d286d+6sarYhQ4bQokULrl+/TmJiIqtWreLMmTMsWrQoxc/TWEaNGkVAQACenp4oikK+fPlISEigadOmDBw4ULVcz0ycOJHs2bNz9epVxo0bh52dHZDUVU/NSnBMTAyzZ89m69atFCxYEHNzc4PXJ0yYYNQ8a9eu1f93rVq16NOnDydPnqRAgQLJsr3Y1dfYxowZQ+3atdm4cWOK2Yz9ub3s9u3bLF68mAULFnDhwgXq16/PunXrqFy5MtHR0QwcOJBWrVpx+fJlo2Xq0qULS5cuBaB58+aMGzcOPz8//eu2traMHTuW7NmzGy3TM1WqVGHSpEn6m586nY7Hjx8zZMgQatasafQ8H0o2oR6doiiK2iGENty6dYugoCCCgoIIDg7m7NmzuLm5cfPmTVXyNG3alOLFi9OzZ09GjRrF5MmTqVevHlu2bKFo0aKsWrVKlVzt2rVj69atTJs2jbJlywIQEhJC165dqVKlCjNmzFAl1zM3btzg119/5fTp0/oL2Y4dO+Lh4aFqLoCEhATWrFnDqVOn0Ol05M2bl3r16mFqaqp2NCCpMnzy5EkSExPJly+f/iJbbZs2bWL06NEcPHiQxMREihYtyuDBg6latara0QgLC+PQoUMkJiZSpEgRcubMqXYkTUtr6QGdTsf27duNmIbXHg+k0+lSvOtuLCNGjGDIkCHkzp2bTJkyGYy7VeNze1GdOnXYtGkTuXLlok2bNrRs2RInJyeDbW7cuEGWLFmMOltppUqVaNOmDV9++SUWFhYpbhMfH8+uXbuoUKGC0XJB0ufh7++Pqakp586do3jx4pw7dw4XFxf+/fdf3NzcjJrnQ8km1CMVJqH35MkTQkJC9JWm0NBQ8uXLx6FDh1TJc/fuXWJiYvDw8CAxMZFffvmFkJAQfH19GTRoEI6OjqrkcnFxYeXKlVSsWNGgfMeOHTRq1Egz3fO05vz589SsWZPr16+TO3duFEXh7NmzZM2alfXr15MjRw61I4qPzOLFi5k1axYXLlxgz549eHl5MWnSJLy9valXr57a8cQbcHR0ZOLEiQQEBKgdJZnWrVvTpk0bSpcuneo2iqJw5coVvLy8jJIpLi6O77//nkGDBuHj42OUY76p6Oholi5dSmhoqP5GULNmzQwmVFIz27JlywxuUmklm1CHVJgEP/zwA8HBwRw5cgQ/Pz/Kly9PhQoVKF++PA4ODmrH0xwbGxsOHjxI3rx5DcpPnDhBiRIlePLkiVHzHD169LW3LViw4HtMkraaNWuiKAq///67/u5rZGQkzZs3x8TEhPXr16uW7cmTJ4wdO5Zt27YRHh6e7C7ws7WP1PT06dMUs2XLlk2VPKmtnaXT6bCyssLX15d69eolu9NuLDNmzGDw4MF0796dUaNGcfz4cXx8fAgMDGThwoXs2LFDlVwvunbtGjqdTj+eT6TO3d2dnTt3aq4FMy4ujqpVqzJr1ixy5cqldhwDDg4OhIaGarbCpFX//vsvZcqUwczMcNRKfHw8u3fvTnFGVfHxkwqTwMTEBFdXV3r06EG9evWSVQTUlJiYyPnz51O8UFTrl1alSpVwdnZm0aJFWFlZAUl3o1q1asXdu3fZunWrUfOYmJig0+mSLaj77Ef7xTI1u9TY2tqyd+9eChQoYFB+5MgRypYtq+qCgE2aNCE4OJgWLVqQOXPmZNPsd+vWTaVkcO7cOb777jt2795tUP7s+1brO/X39yc0NJSEhAR9i+G5c+cwNTUlT548nDlzBp1OR0hICPny5TN6vnz58jF69Gjq16+Pvb09R44cwcfHh+PHj1OxYkUiIiKMngmSfqeNHDmS8ePH6//N29vb06tXLwYMGKDqlNldu3bF19eXrl27GpRPmzaN8+fPM2nSJHWCkTSG6ebNm6ovUpsSV1dXdu/erbnK3LfffkuBAgVUXxj8mRfHy72KmuPlTE1NuXnzZrKud5GRkbi5uan6d1SoRyZ9EBw6dIjg4GCCgoIYP348pqam+kkfKlasqFoFau/evTRt2pTLly/zcr1ezQvFyZMnU716dbJkyUKhQoXQ6XQcPnwYKysrNm3aZPQ8Fy9e1P/3oUOH6N27N3369NF3D9mzZw/jx49n3LhxRs/2IktLS/0kHi96/Phxqv3rjWXDhg2sX79ePyZNSwICAjAzM2PdunUpVubU8qz1aMGCBWTIkAGAhw8f0rp1a8qVK0fbtm1p2rQpPXr0UO3nIqVZBJ/NuKmWAQMGMG/ePMaOHUvZsmVRFIVdu3YxdOhQYmJiVF0r7c8//0zxorZMmTKMHTtW1QrT/v372b59O+vWrSN//vzJJn1Qa0wrQMuWLfXfqZb4+voyYsQIdu/eTbFixbC1tTV4/eWK8ftWv37919pO7fFyL998fCYyMjLZZyg+HdLCJJI5cuQIkyZN4rfffkt1ek1jKFy4MLly5WLYsGEpXig+W0hWDdHR0fz2228GEytooX9ziRIlGDp0aLKZfP755x8GDRrEwYMHVUqWdFERGhrKvHnzKFGiBAD79u2jbdu2FCtWjMDAQNWyeXt7888//2iqdfUZW1tbDh48qOqMlSnx9PRky5YtyVqPTpw4QdWqVbl+/TqhoaFUrVpVldacfPnyMWbMGOrVq2fQwjRlyhQWLlyo2s+Ch4cHM2fOTHYH/a+//qJjx45cv35dlVwAVlZWHD9+PNm06+fPn8fPz4+YmBiVkiW1lqRlwYIFRkqSXJcuXVi0aBG+vr4UL1482UW1WjP4eXt7p/qaTqfTRFdjLWnYsCGQ9LNYvXp1LC0t9a8lJCRw9OhRcufOzcaNG9WKKFQkLUwCSGqZeDbZw86dO3n48CGFCxdOc0an9+3cuXOsXLlS1TVTUmNtbU3btm3VjpHMsWPHUvwj6e3tzcmTJ1VI9NyUKVNo1aoVpUuX1t8djo+Pp27dukyePFnVbCNGjGDw4MEsXLhQ1WnhU5IvXz7Vuo+l5cGDB4SHhyerMN25c4eHDx8CSWMonj59qkY8+vTpQ6dOnYiJiUFRFPbv38/SpUsZM2YMc+fOVSUTJE1mk1LlN0+ePNy9e1eFRM/5+vqycePGZFPpb9iwQfVxMGpWiF7l+PHjFC1aFCDZeoZqtQgrisKOHTtwc3PT3O80rXp2E1ZRFOzt7Q1ugFpYWFCqVClN/t0XRmKsFXKFdjk4OChmZmZKsWLFlF69eil///238uDBA7VjKf7+/sqGDRvUjpHM6NGjlXnz5iUrnzdvnjJ27FgVEj1XpEgRpWnTpkp0dLS+LCYmRmnatKlSpEgRFZM9d+7cOWXt2rXKX3/9pZw7d07tOIqiKErhwoUVe3t7xc7OTvHz81OKFCli8FDTtm3blNKlSys7duxQIiIilAcPHhg81NK0aVPF29tbWbVqlXL16lXl2rVryqpVqxQfHx+lefPmiqIoytKlS5VixYqplnH27NlKtmzZFJ1Op+h0OiVLlizK3LlzVcujKIpSokQJpUuXLsnKO3furJQsWVKFRM/NmzdPsba2VgYPHqwEBQUpQUFByqBBgxQbGxtl9uzZqmbTqvj4eCUoKEiJjIxUO4qBhIQExdzcXDl79qzaUVK1detWpVatWoqPj4+SI0cOpVatWsqWLVvUjqUMHTpUefz4sdoxhMZIlzzBunXrKF++vH4cglasXr2agQMH0qdPnxQXKlRrxrfs2bOzZMkSypQpY1C+b98+vvnmG4MxRca2f/9+6tSpQ2JiIoUKFQKSuljqdDrWrVun7wonDA0bNizN14cMGWKkJMk9mwTg5TvVisqTPjx+/JgePXqwaNEi4uPjATAzM6NVq1ZMnDgRW1tbDh8+DCR1r1VTREQEiYmJmlg/JTg4mFq1apEtW7YUF5f+/PPPVc03Y8YMRo0axY0bN4Ck33dDhw6lZcuWquby9vZOs7VGze5lVlZWnDp1Ks0ucGrInz8/8+bNo1SpUmpHSWbatGn06NGDr776Sj/edu/evaxcuZIJEyaovmC4EC+TCpPQrJRmi3pxNji1LhRT++N44cIF8uXLp2o/f0hafPXl8VVNmzZVfbDqV199RfHixfnxxx8Nyn/++Wf279/PihUrVEqmbcHBwWm+buwFJ1/2+PFjLly4gKIo5MiRQzOL/WqZlheXfubOnTtYW1tr5vt8udtuXFwchw4dYuPGjfTp0yfZ7xVj+uyzzxg7diyVKlVSLUNK1q9fz9ixY5kxYwZ+fn5qxzHg6elJv379klWMfv31V4MKu1pWrlzJ8uXLuXLlSrJuxaGhoSqlEmqSCtMnqmHDhgQGBpIhQwb9QMfUqDX70OXLl9N83VgLAL4sZ86cDBkyhObNmxuUL168mCFDhshA2lS4urqyffv2ZNOKHzt2jMqVK3P79m2VkomPUWRkJIMHD2bHjh0pLkug9ngh8W78+uuv/Pfff6qOcdq8eTM//PADI0aMSHE2OrV6bzg6OhIVFUV8fDwWFhbJJiVS82fA3t6eQ4cOJRujfO7cOYoUKaLqMhNTpkxhwIABtGrVijlz5vDtt98SFhbGgQMH6NSpk6ozWQr1yKQPn6iMGTPquzekNdvcgwcPjBUpGbUqRK/Spk0bunfvTlxcHF988QUA27Zto2/fvvTq1UvldElOnjyZ4p0xNde2SG36cHNzc/0kAcbk5OTE2bNncXFxwdHRMc3uPsa+sDh69Ch+fn6YmJi8cmFitbqman2x3+bNmxMWFkbr1q3JlCmTZqZjB4iJieHo0aMpfm5q/ozCh3dnvUaNGvTr10/VClP16tWBpO/u5bXw1OwNoeY08K9St25dVq9eTZ8+fQzK//rrL+rUqaNSqiTTp09n9uzZNGnShIULF9K3b198fHwYPHiw3Gj5hEmF6RO1YMECfvnlF3r37p3qH5qHDx9StWpVIydLTmsX/3379uXu3bt07NhRn8nKyooffviBfv36qZLpmQsXLtCgQQOOHTum774Iz8e/qLm2hZ+fH3/88QeDBw82KF+2bJkqC5tOnDgRe3t7/X9r6YK6cOHC3Lp1Czc3NwoXLmzwXb5IzYuxNm3apLnYr9pCQkIICQnRj+XTio0bN9KyZcsUZz5Ue/2ZF++s//XXX8nurGvRypUrcXJyUjXDjh07VD1+alq1aqV2hFTlzZuXUaNGERQUZDCGadeuXfTq1ctggWJjrxd15coV/Rhla2tr/fqBLVq0oFSpUkybNs2oeYQ2SJe8T5i1tTXTp09PcX2Lx48fU7VqVe7fv6/adNRavviHpM/o1KlTWFtbkzNnToM1G9RSp04dTE1NmTNnDj4+Puzfv5/IyEh69erFL7/8ouqA8rVr1/Lll1/StGlTg5a5pUuXsmLFitde1PBTcPnyZbJly4ZOp9Ns11QHBwfNLvYLSeNKpk6dqrkB776+vlSrVo3BgweTKVMmteMYyJMnD0OGDKFJkyYGa1c9u7Ou5oVikSJFkrXe3Lp1izt37jB9+nS+//571bJpWVhYGAsWLCAsLIzJkyfj5ubGxo0byZo1K/nz51ct1+tOkKHGelE+Pj6sXLmSokWL8tlnn9GmTRvatWvH5s2b+eabb6SV6VNl7Gn5hHasWLFCsbKyUlavXm1Q/ujRI6V06dJKrly5lJs3b6oTTlGU2rVrK/Xq1VPCw8MVOzs75eTJk8rOnTuVEiVKKP/++69qubTM2dlZOXLkiKIoipIhQwbl9OnTiqIkTU1duHBhNaMpiqIo69atU8qUKaPY2Ngozs7Oir+/vxIUFKR2LMXExES5fft2svKIiAjFxMREhURJnj59qgQEBChhYWGqZUhN9uzZlZMnT6odI1X79+9XvvjiCyUoKEhT07Hb29sr58+fV+34abG2tlYuXbqkKIqiuLq6KocPH1YURVHOnj2rODk5qRlNGTp0qMFj+PDhyowZM5RTp06pmuuZf//9V2nWrJlSunRp5dq1a4qiKMqiRYuUnTt3qpYpKChIsba2VipXrqxYWFjof4/89NNPypdffqlaLq1r3bq1MnToUEVRFGXGjBn6z9DBwUH57rvvVE4n1CJd8j5hX331Fffv36dp06asX78ef39/Hj9+TPXq1YmIiCA4OBh3d3fV8u3Zs4ft27fj6uqKiYkJJiYmlCtXjjFjxtC1a1cOHTpktCwfwiQZkNTq9mxWKxcXF27cuEHu3Lnx8vLizJkzquV6platWtSqVUvtGMkoqTS0x8bGpjjuyljMzc1ZvXo1gwYNUi1DarS82C8ktYA9ePBA35r5jKLyuJKvvvqKoKAgcuTIocrx0+Lu7k5kZCReXl54eXmxd+9eChUqxMWLF1P9GTEWNaf2f5U///yTFi1a0KxZM0JDQ4mNjQXg0aNHjB49mn/++UeVXD/++CMjR46kZ8+e+u7HAP7+/qovFv4i5aXeI2qbPXu2fmxh+/btcXJyIiQkhDp16tC+fXuV0wm1SIXpE9emTRvu3r1L/fr1+euvvxg0aBC3bt0iODiYzJkzq5pNSxf/rztJhtr8/Pw4evQoPj4+lCxZknHjxmFhYcHs2bPx8fFROx4ABw8e5NSpU+h0OvLly0eRIkVUy/Ksn7xOp2Pu3LkGUygnJCTw77//kidPHrXiAdCgQQPWrFlDz549Vc3xsvHjxxMWFkamTJnInj17snXS1J4goFmzZlhYWLBkyRJNTfowbdo0vv76a3bu3Jni+nLGHq/xoi+++IK///6bokWL0rp1a3r06MHKlSv577//Xnmj6H14k8lg1FxHcOTIkcycOZOWLVuybNkyfXmZMmUYPny4armOHTvGkiVLkpW7uroSGRmpQiJD8+bNY+LEiZw7dw5ImoG2e/futGnTRtVcz27QPtOoUSMaNWqkYiKhBVJhEvTt25d79+5RqVIlsmfPTnBwMJ6enmrH0tTF/7OJMRRFYejQobi6umryrvrAgQN58uQJkPRHvHbt2nz++ec4Ozvzxx9/qJotPDycb775hqCgIBwcHFAUhQcPHuDv78+yZctwdXU1eqaJEycCSd/rzJkzMTU11b9mYWFB9uzZmTlzptFzvcjX15cRI0awe/fuFKcsVusCW+tjzo4fP86hQ4fInTu32lEMLFmyhE2bNmFtbU1QUJBBRU6n06laYdLanXUHB4dXVnTVbjEEOHPmDOXLl09WniFDBu7fv2/8QP/n4ODAzZs3k40XOnTokOp/4wcNGsTEiRPp0qWLftKHPXv20KNHDy5dusTIkSNVzXf//n3279+f4kyWai/iLNQhkz58wl6+Y/jPP/9QqFChZL9I1epitmnTJp48eULDhg25cOECtWvX5vTp0/qL/5e72hhDYmIiVlZWnDhxgpw5cxr9+Olx9+7dV06bbQyNGzcmLCyMxYsXkzdvXiBpBsRWrVrh6+vL0qVLVcvm7+/PqlWrcHR0VC1DatIaHK3GgOgPRfny5Rk8eDCVK1dWO4oBd3d3unbtyo8//pji4tziuVct2vwiNRdwzpEjB7NmzaJy5coGk2UsWrSIsWPHqjZxUt++fdmzZw8rVqwgV65chIaGcvv2bVq2bEnLli1V7ebo4uLC1KlTadKkiUH50qVL6dKlS4qzSBrL33//TbNmzXjy5An29vbJbmrIpA+fJqkwfcJSmh0vJWqub/EyLVz858+fn3nz5mlu9i1IWjcrISEh2TS7d+/exczMTNVuKxkzZmTr1q189tlnBuX79+/Xz8goxLuyYsUKhg4dSp8+fVLs+qbW+lVOTk4cOHBAk2OYAHbu3MmsWbMICwtj5cqVeHp6snjxYry9vSlXrpzR80RFRdGnTx/WrFlDXFwclStXZsqUKbi4uBg9S2rGjRvHwoULmT9/PlWqVOGff/7h8uXL9OjRg8GDB9O5c2dVcsXFxREQEMCyZctQFAUzMzMSEhJo2rQpgYGBBi3qxubo6Mj+/fuT3Xg8e/YsJUqUUPXvQa5cuahZsyajR4/WZE8SoQ6pMAnxhtavX8/YsWOZMWMGfn5+ascxUKNGDerUqUPHjh0NymfOnMnatWtVG3wMSSu779y5k8KFCxuUHzp0iAoVKqiyeO0zCQkJBAYGproI6/bt21VKpl0JCQlMnDgx1UVO1b4Lm1LrzbPlCdTswtWjRw9cXV3p37+/KsdPy4uTFyxevJiTJ0/i4+PD9OnTWbdunSq/P/r06cP06dNp1qwZ1tbWLFmyhIoVK7JixQqjZ0nLgAEDmDhxIjExMQBYWlrSu3dvRowYoXKypKnFDx06RGJiIkWKFNFE74guXbpgbm7OhAkTDMp79+5NdHQ0v/76q0rJwNbWlmPHjmlm3K/QBqkwCc168uQJY8eOTfUiVq2uSI6OjkRFRREfH4+FhQXW1tYGr6t5oejk5MSuXbv0Xd6eOX36NGXLllV1oG+9evW4f/8+S5cuxcPDA4Dr16/TrFkzHB0dWb16tWrZOnfuTGBgILVq1UpxEdZnY53Ucu3aNdauXZtixeTlCw5jGTx4MHPnzqVnz54MGjSIAQMGcOnSJdasWcPgwYNVHYsDaHb9qq5du7Jo0SIKFSpEwYIFk7V8qfV9QtJaRz169KBly5YGXcsOHz5M9erVuXXrltEz5ciRg1GjRvHNN98ASS3SZcuWJSYmRtUWkpRERUVx8uRJEhMTyZcvn8EkMmrT2kx0Xbp0YdGiRWTNmlXfW2Pv3r1cvXqVli1bGvxcGPtnomHDhnzzzTcy0YMwIJM+CM1q06YNwcHBtGjRIsWLWLVMmjRJ7Qipio2NJT4+Pll5XFwc0dHRKiR6btq0adSrV4/s2bOTNWtWdDodV65coUCBAvz222+qZlu2bBnLly+nZs2aquZIybZt26hbty7e3t6cOXMGPz8/Ll26hKIoFC1aVLVcv//+O3PmzKFWrVoMGzaMJk2akCNHDgoWLMjevXtVrzCpVSF6lWPHjulnhjx+/LjBa2r/jtPi5AVXr141WHC7RIkSmJmZcePGDbJmzapKptTY2NjoZ2TUSmVJqzPRHT9+XP/7KywsDEiavc/V1dXg50KNn4latWrRp08fTp48mWJ33rp16xo9k1CfVJiEZm3YsIH169dTtmxZtaMYaNWqldoRUvXZZ58xe/Zspk6dalA+c+ZMihUrplKqJFmzZiU0NJQtW7Zw+vRpFEUhX758mhiUb2Fhga+vr9oxUtSvXz969erF8OHDsbe3588//8TNzY1mzZpRvXp11XLdunWLAgUKAGBnZ8eDBw8AqF27tmrrRq1du5YaNWpgbm7O2rVr09xWrYueHTt2qHLc15E5c2bOnz9P9uzZDcpDQkJU656UkJCQbC00MzOzFG8MqSU+Pp5hw4YxZcoUHj9+DCT9THTp0oUhQ4Yku+A2Fi3PRKfln4O2bdsCpDglvNozMgr1SIVJaJajo2OyyQu0IiEhgdWrV+vXE8qbNy/16tXDzEzdH6lRo0ZRuXJljhw5QqVKlYCkFooDBw6wefNmVTJt376dzp07s3fvXjJkyECVKlWoUqUKkDRJRf78+Zk5c6bBXWRj69WrF5MnT2batGmq3+V/2alTp/QzCJqZmREdHY2dnR3Dhw+nXr16dOjQQZVcWbJk4ebNm2TLlg1fX182b95M0aJFOXDgAJaWlqpkql+/Prdu3cLNzS3Nac+1cNFz/vx5wsLCKF++PNbW1vqxVWpq164d3bp1Y/78+eh0Om7cuMGePXvo3bs3gwcPViWToigEBAQY/JuKiYmhffv2BlPsq7lgeOfOnVm9ejXjxo0zqJgMHTqUiIgI1ZYmmDFjBnPmzDGYia5u3boULFiQLl26qD51t1a93P1fCJAKk9CwESNGMHjwYBYuXKipmWqOHz9OvXr1uHXrln6Nl7Nnz+Lq6sratWv1d93VULZsWfbs2cO4ceNYvnw51tbWFCxYkHnz5qk20HfSpEm0bds2xRn6MmbMSLt27ZgwYYKqFaaQkBB27NjBhg0byJ8/f7I7wmpejNna2hIbGwuAh4cHYWFh5M+fH0DVqXcbNGjAtm3bKFmyJN26daNJkybMmzePK1eu0KNHD1UyvXihk9pFz5UrV1SdTjkyMpJGjRqxY8cOdDod586dw8fHhzZt2uDg4MD48eNVy9a3b18ePnyIv78/MTExlC9fXj95gVozvaXUot+8eXMVkqRu6dKlLFu2jBo1aujLChYsSLZs2fjmm29UqzAlJCRQvHjxZOXFihXTRAvdgQMHWLFiRYpjM9X8nStESmTSB6FZRYoUISwsDEVRyJ49e7KL2NDQUFVylSpVCjc3NxYuXKhft+fevXsEBAQQHh7Onj17VMmlVV5eXmzcuDHZRBTPnD59mqpVq3LlyhUjJ3vuVVPsqzm1fv369alVqxZt27alb9++rF69moCAAP26UVu3blUt24v27dvHrl278PX11XQf/yNHjlC0aFHVWphatmxJeHg4c+fOJW/evPqJFTZv3kyPHj04ceKE0TO9PHW3v78/vXr1AtDc5AValClTJoKCgpL9jjt16hTly5fnzp07quTS8kx0y5Yto2XLllStWpUtW7ZQtWpVzp07x61bt2jQoIHqy5k8efKE4ODgFCtzao/PFOqQFiahWWl1qVHTkSNH+O+//wwWOXV0dGTUqFHJ1hhSQ0JCAmvWrNF3F8yXLx9169ZVbUap27dvp9mH38zMTLULimfU/uOclgkTJujHRQwdOpTHjx/zxx9/4Ovrq9rsfXFxcXz//fcMGjRIP7alZMmSlCxZUpU8H5LNmzezadMmsmTJYlCeM2fOV87s974MGTKEwMBAg6m7ExMTNTd1t1Z16tSJESNGsGDBAn3XwdjYWEaNGmX0lrmePXvq/1un0zF37lw2b96c4kx0aho9ejQTJ06kU6dO2NvbM3nyZLy9vWnXrh2ZM2dWNduhQ4eoWbMmUVFRPHnyBCcnJyIiIrCxscHNzU0qTJ8oqTAJzVKz20xacufOze3bt/Xdop4JDw9XfeKA8+fPU6tWLa5du0bu3LlRFIWzZ8+SNWtW1q9fr8pimZ6enhw7dizVz+bo0aOq/4GEpIHbQUFBhIWF0bRpU+zt7blx4wYZMmRQ9Q77i4PtbWxsmD59umpZnjE3N2f16tWqTe7wIXvy5EmKXYwjIiJUG/u1atUq5s2bp5+6u1mzZpQtW5aEhATNTd2tFQ0bNjR4vnXrVrJkyUKhQoWApBtrT58+1Y8lNZZDhw4ZPH822c/LM9Gp0ZL5orCwMGrVqgUkrVn15MkTdDodPXr04IsvvmDYsGGqZevRowd16tRhxowZODg4sHfvXszNzWnevDndunVTLZdQl1SYhHhDo0ePpmvXrgwdOtTgrt3w4cP56aefDBZgTWnczvvUtWtXfHx82LNnj37CjMjISJo3b07Xrl1Zv369UfMA1KxZk8GDB1OjRg2srKwMXouOjmbIkCHUrl3b6LledPnyZapXr86VK1eIjY2lSpUq2NvbM27cOGJiYlQbg6BlDRo0YM2aNQZ3tMWrlS9fnkWLFukXNNXpdCQmJvLzzz9TsWJFVTJ9SFN3a0XGjBkNnn/55ZcGz9X63LQ8+9yLnJycePToEZB0U+348eMUKFCA+/fvExUVpWq2w4cPM2vWLExNTTE1NSU2NhYfHx/GjRtHq1atklWWxadBKkxCsxISEpg4cSLLly9PsR+xWgvEPru4b9SokX5Wq2dDAevUqaN/rsZMXMHBwezdu9dgdkFnZ2fGjh2r2vTsAwcOZNWqVeTKlYvOnTuTO3dudDodp06d4tdffyUhIYEBAwaoku2Zbt26Ubx4cY4cOYKzs7O+vEGDBqqsV+Lo6PjaM6ap9XPg6+vLiBEj2LVrF8WLFzeYsQzU6+f/qosZtdYTeuZZxei///7j6dOn9O3blxMnTnD37l127dqlSqYPYepurdFyN95ntmzZQrly5ZItrq4Fn3/+OVu2bKFAgQI0atSIbt26sX37drZs2WL0VrmXmZub63//ZsqUiStXrpA3b14yZsyo6lhboS6pMAnNGjZsGHPnzqVnz54MGjSIAQMGcOnSJdasWaPaFLeQ9h280NBQVRcTtbS01N+1e9Hjx4+TXRAZS6ZMmdi9ezcdOnSgX79+BivOV6tWjenTp5MpUyZVsj0TEhLCrl27kn1GXl5eXL9+3eh5XlwcOTIykpEjR1KtWjWDKYs3bdqkape4uXPn4uDgQGhoaLIJWHQ6nWoVppfv/Kf0uprjN/Lly8fRo0eZMWMGpqamPHnyhIYNG9KuXTuGDBnC/PnzjZ7pQ5i6+0MQHh7OmTNn0Ol05MqVCzc3N1XzfPnll8TGxlKsWDEqVKhAxYoVKVu2rCYm8Zg2bRoxMTFA0lpz5ubmhISE0LBhQ9W7+hYpUoT//vuPXLly4e/vz+DBg4mIiGDx4sWqzoIr1CWz5AnNypEjB1OmTKFWrVrY29tz+PBhfdnevXtZsmSJ2hGBpLWEfv/9d+bOncuRI0dUXd+lZcuWhIaGMm/eyzQtBwAAGWBJREFUPEqUKAEkzV7Wtm1bihUrRmBgoGrZIGk2wfPnz6MoCjlz5jSYOENNTk5OhISEkC9fPuzt7fUzl4WEhPDll19y+/Zt1bJ9+eWX+Pv7Jxs8Pm3aNLZu3cqaNWvUCfZ/ERER6HQ6g5Y58ebUnL3vVbNEPvMhtKqo4eHDh3Tq1Illy5bpvz9TU1MaN27Mr7/++spK/PuSkJDA/v37CQ4OJigoiN27dxMTE0PRokWpWLEiY8eOVSWX1v333388evQIf39/7ty5Q6tWrQgJCcHX15cFCxbox6mJT4wihEbZ2Ngoly9fVhRFUdzd3ZWDBw8qiqIoYWFhSoYMGdSMpiiKomzbtk1p1qyZYm1treTJk0cZMGCAEhoaqmqme/fuKXXr1lV0Op1iYWGhWFhYKCYmJkr9+vWV+/fvq5pNyxo1aqS0bdtWURRFsbOzUy5cuKA8evRI+eKLL5SAgABVs9na2irnzp1LVn727FnF1tZWhURJ/846duyoODs7KyYmJoqJiYni7OysdOrUSf6dpdPhw4cVExMTtWOIdPj666+VnDlzKhs3blQePHigPHz4UNm4caOSO3du5euvv1Y7nt6xY8eUVq1aKWZmZpr4t3b+/HllwIAByjfffKPcvn1bURRF2bBhg3L8+HHVMiUmJiqXLl1SoqKiVMsgtEm65AnNypIlCzdv3iRbtmz4+vqyefNmihYtyoEDB1SbTeratWsEBgYyf/58njx5QqNGjYiLi+PPP/8kX758qmR6kYODA3/99Rfnzp3j9OnTKIpCvnz5VJ+9T+smTpyIv78/+fLlIyYmhqZNm3Lu3DlcXFxYunSpqtmcnZ1ZvXo1ffr0MShfs2aNKq06d+/epXTp0ly/fp1mzZqRN29eFEXh1KlTBAYGsm3bNnbv3q2Z1kMh3rf169ezadMmypUrpy+rVq0ac+bMoXr16qrlOnXqlL51KTg4mISEBMqVK8f48eOpUKGCarkgabxtjRo1KFu2LP/++y+jRo3Czc2No0ePMnfuXFauXKlKLuX/vR9OnDih2mLvQpukwiQ0q0GDBmzbto2SJUvSrVs3mjRpwrx587hy5Qo9evQwep6aNWsSEhJC7dq1mTp1KtWrV8fU1FRTM6gFBwdToUIFcubMKb/s34CHhweHDx9m6dKlhIaGkpiYSOvWrfXr0qhp2LBhtG7dmqCgIP0Ypr1797Jx40bmzp1r9DzDhw/HwsKCsLCwZGPPhg8fTtWqVRk+fLhqa0QJYWzOzs4pdrvLmDGjqjcO8ufPj6urK927d2fQoEHJlsJQ048//sjIkSPp2bMn9vb2+nJ/f38mT56sWi4TExNy5sxJZGSk/A0VBmQMk/hg7Nu3j127duHr60vdunWNfnwzMzO6du1Khw4dDH6Rmpubc+TIEU20MFlYWODu7k7Tpk1p3rw5fn5+akcS78C+ffuYMmUKp06d0rcadu3aVZWFYrNnz86sWbOoVq1aiq9v3LiR9u3bc+nSJeMG07jXmb3vWSuA+LDMnj2bFStWsGjRIv2acrdu3dJPQd2uXTtVcnXv3p1///2XEydOULhwYSpWrEjFihX5/PPPVZ/4wc7OjmPHjuHt7W0wbvTSpUvkyZNHPyGEGtavX8/YsWOZMWOG/A0VetLCJDQrMjJS3+Xo6tWrrF+/nujoaIoXL65Knp07dzJ//nyKFy9Onjx5aNGiBY0bN1YlS2pu3LjBsmXLWLp0KePGjcPPz4/mzZvTtGlTsmTJonY8Tbt+/Tq7du0iPDycxMREg9fUXtm9ZMmS/P7776pmeObmzZtp3qn28/Pj1q1bRkz0YdD67H0i/WbMmMH58+fx8vIiW7ZsAFy5cgVLS0vu3LnDrFmz9Nu+PKPk+/Rsts379++zc+dOgoODGTx4MMeOHaNw4cLs3bvXaFle5uDgwM2bN/H29jYoP3ToEJ6eniqlStK8eXOioqIoVKgQFhYWyXoZqLWUg1CXVJiE5hw7dow6depw9epVcubMybJly6hevTpPnjzBxMSEiRMnsnLlSurXr2/UXKVLl6Z06dJMnjyZZcuWMX/+fHr27EliYiJbtmwha9asBl0L1ODi4kLnzp3p3LkzFy9eZMmSJSxatIj+/ftTvnx5tm/frmo+rVqwYAHt27fHwsICZ2dngzWQ1Jwi+5nExETOnz+fYmWufPnyRs3i4uLCpUuXUq2AX7x4UWbMS4HMMPfxMvbfojeVmJhIfHw8T58+JTY2lri4ONVbgJs2bcoPP/zAihUr9Is379q1i969e6t+4+DFZR2EeEa65AnNqVGjBmZmZvzwww/89ttvrFu3jqpVq+rHa3Tp0oWDBw+qenfsmTNnzjBv3jwWL17M/fv3qVKlCmvXrlU7ll5CQgIbNmxg0KBBHD16VLr7pCJr1qy0b9+efv36YWJionYcA3v37qVp06ZcvnyZl39dq7E4cuvWrTl//jxbtmxJtm5VbGws1apVI0eOHMybN8+ouYQQhrp160ZQUBAnTpzAycmJ8uXL67vlqd3VLC4ujoCAAJYtW4aiKJiZmZGQkEDTpk0JDAzE1NRU1XxCvEwqTEJzXFxc2L59OwULFuTx48dkyJCB/fv367vinT59mlKlSnH//n11g74gISGBv//+m/nz52uiwrRr1y5+//13Vq5cSUxMDHXr1qVZs2bUqFFD7Wia5OzszP79+8mRI4faUZIpXLgwuXLlYtiwYWTOnNmg9Qte3dXrXbt27RrFixfH0tKSTp06kSdPHgBOnjzJ9OnTiY2N5b///iNr1qxGzSWEWq5evYpOp9O3uu7fv58lS5aQL18+vv/+e9VyffXVV5qpIKUmLCyMQ4cOkZiYSJEiRTQx0cLDhw9TLNfpdFhaWqq2CLxQl1SYhOaYmJhw69Yt/SrpLw4IBbh9+zYeHh7SWpKC/v37s3TpUq5fv06VKlVo1qwZ9evXx8bGhsOHD1O4cGG1I2pS3759cXJy4scff1Q7SjK2trYcOXJEU1PDX7x4kY4dO7J582Z9q5dOp6NKlSpMmzZNU1mFeN8+//xzvv/+e1q0aMGtW7fIlSsXfn5+nD17lq5duzJ48GC1I4o3YGJikuzG1IuyZMlCQEAAQ4YM0VyPBPH+yBgmoUkv/7JK65eXeC4oKIjevXvTuHFjXFxcePDgAYGBgcybN4/Dhw9LJTMVY8aMoXbt2mzcuJECBQpgbm5u8PqECRNUSpY04cP58+c1VQnx9vZmw4YN3Lt3j3PnzgHg6+uLk5OTysmEML7jx49TokQJAJYvX06BAgXYtWsXmzdvpn379qpXmE6ePMmVK1d4+vSpQbkas80+k5CQoF+3LaWxmWqOtw0MDGTAgAEEBARQokQJFEXhwIEDLFy4kIEDB3Lnzh1++eUXLC0t6d+/v2o5hXFJhUloUkBAgH5x2piYGNq3b4+trS2QNE5CpGz37t1A0h+b+fPns2rVKry8vPjyyy9VWbPnQzF69Gg2bdpE7ty5AZJN+qCmLl260KtXL27dupViZa5gwYIqJQNHR0f9haIQn6q4uDj936utW7fqKyJ58uTh5s2bquW6cOECDRo04NixY+h0OoPWYEDVG2jdunUjMDCQWrVq4efnp/rv2RctXLiQ8ePH06hRI31Z3bp1KVCgALNmzWLbtm1ky5aNUaNGSYXpEyJd8oTmfPvtt6+1ncw6ZejatWsEBgayYMECHj9+TKNGjZg5c6Zm1ojSMkdHRyZOnEhAQIDaUZJJqcvHs4sfNSZ9EEIYKlmyJP7+/tSqVYuqVauyd+9eChUqxN69e/nqq6+4du2aKrnq1KmDqakpc+bMwcfHh/379xMZGUmvXr345Zdf+Pzzz1XJBUljlRctWkTNmjVVy5AaGxsbjhw5kmw81blz5yhUqBBRUVFcvHiR/PnzExUVpVJKYWzSwiQ0RypCb65mzZqEhIRQq1YtpkyZQvXq1TE1NWXmzJlqR/sgWFpaUrZsWbVjpOjixYtqRxBCpOGnn36iQYMG/Pzzz7Rq1YpChQoBsHbtWlVbYPfs2cP27dtxdXXFxMQEExMTypUrx5gxY+jatSuHDh1SLZuFhYWmuhm/KEuWLMybN4+xY8calM+bN08/mU1kZCSOjo5qxBMqkQqTEB+BzZs307VrVzp06KCJWYY+NN26dWPq1KlMmTJF7SjJeHl5qR1BCJGGihUrEhERwcOHDw0uor///ntsbGxUy5WQkICdnR2Q1KJz48YNcufOjZeXF2fOnFEtF0CvXr2YPHky06ZN01R3PIBffvmFr7/+mg0bNvDZZ5+h0+k4cOAAp0+fZuXKlQAcOHBAcwvXi/dLKkxCfAR27tzJ/PnzKV68OHny5KFFixbyy/wN7N+/n+3bt7Nu3Try58+fbJzQqlWrVEr2nBYHbgshkpiamiZrcciePbs6Yf7Pz8+Po0eP4uPjQ8mSJRk3bhwWFhbMnj1bP+usWkJCQtixYwcbNmzQ3O/cunXrcubMGWbOnMnZs2dRFIUaNWqwZs0a/XfaoUMH1fIJdcgYJiE+IlFRUSxbtoz58+ezf/9+EhISmDBhAt999x329vZqx9OsV42bU7ObqJYHbgshkqxcuZLly5eneFMjNDRUlUybNm3iyZMnNGzYkAsXLlC7dm1Onz6Ns7Mzf/zxB1988YUquUDbv3OFSIlUmIT4SJ05c4Z58+axePFi7t+/T5UqVTSxqK54M1oeuC2EgClTpjBgwABatWrFnDlz+PbbbwkLC+PAgQN06tSJUaNGqR1R7+7duzg6OmquG5zW7Ny5k1mzZnHhwgVWrFiBp6cnixcvxtvbm3LlyqkdT6hAVtwS4iOVO3duxo0bx7Vr11i6dKnacTQvPj6erVu3MmvWLB49egTAjRs3ePz4saq59uzZw/Dhw1MduC2EUNf06dOZPXs206ZNw8LCgr59+7Jlyxa6du3KgwcPVMkUHx+PmZkZx48fNyh3cnKSytIr/Pnnn1SrVg1ra2tCQ0P1S5k8evSI0aNHq5xOqEXGMAnxkTM1NaV+/frUr19f7SiadfnyZapXr86VK1eIjY2lSpUq2NvbM27cOGJiYlSdbVDLA7eFEHDlyhXKlCkDgLW1tf6GS4sWLShVqhTTpk0zeiYzMzO8vLw01WW3aNGibNu2DUdHR4oUKZJmxU2tbowAI0eOZObMmbRs2ZJly5bpy8uUKcPw4cNVyyXUJRUmIcQnr1u3bhQvXpwjR47g7OysL2/QoAFt2rRRMZm2B24LIcDd3Z3IyEi8vLzw8vLSr8N08eJF1Bz1MHDgQPr168dvv/2Gk5OTajmeqVevnn6B3/r16xuMydSSM2fOUL58+WTlGTJk4P79+8YPJDRBKkxCiE9eSEgIu3btwsLCwqDcy8uL69evq5QqycCBA3ny5AmQdOezdu3afP755zg7Oxvc/RRCqOOLL77g77//pmjRorRu3ZoePXqwcuVK/vvvPxo2bKharilTpnD+/Hk8PDzw8vLC1tbW4HVjt+IMGTKEqKgoOnXqxJo1a4iLi6NSpUpMnToVFxcXo2ZJS+bMmTl//nyyWQ5DQkLkJtUnTCpMQohPXmJiYopdV65du6b67ILVqlXT/7ePjw8nT56UgdtCaMjs2bNJTEwEoH379jg5ORESEkKdOnVo0KCBarnq1aunud8RQ4YMITAwkGbNmmFtbc2SJUvo0KEDK1asUDuaXrt27ejWrRvz589Hp9Nx48YN9uzZQ+/evRk8eLDa8YRKZJY8IcQnr3HjxmTMmJHZs2djb2/P0aNHcXV1pV69emTLlk2VKW6/++6719pu/vz57zmJ+F97dxYS9bvHcfwzM44xtkhQioltGoUFoVg3EmKEWkl0EZUlbXZhJkEbGUFTlC2QFG03VlgXLQgWSNFCixZFC0YKChmKWaFFtpEzUTrnouOUx4z+53Dm+cXv/QIvfs8T9Lka/f7meb5f4J9qa2tTcXGxjh07Jp/PZzqOZcTHx6u4uFgLFy6U9H0GXmpqqvx+v1wul+F0P2zZskX79++X3++XJA0YMEAbNmzQjh07DCeDKRRMAGzv1atXSk9Pl8vlUmNjo1JSUtTY2Khhw4apurpaUVFRIc/kdDo1atQoJSUl/fac//nz50OYCkCP9+/fa/Xq1bp69arcbreKiopUWFiobdu2qaSkRImJiVq3bp1ycnKM5Bs7dqwePnzY615mT+7k5GQ1NTWFPFN4eLiam5sVGxsbXPN4PHr69Kni4uJCnud3Ojs7VV9fr+7ubiUmJgab78CeKJgAQJLP59OZM2dUU1Oj7u5uJScnB4+NmFBQUKCzZ89q5MiRWrFihXJzcy1xcRvAdwUFBaqsrNSCBQt0+fJlNTQ0KDMzU36/X16vV2lpaUbzOZ1OtbW19Xnh097erri4uD4DdkPB5XKpra1Nw4cPD671fKs/ZsyYkOcB/hQFEwBY1JcvX1RRUaETJ07o7t27mj17tvLy8pSRkWG5uwmA3YwaNUrHjx/XjBkz1NTUpISEBK1Zs0YHDhwwmqtnQPncuXN18uRJRUZGBve6urp0/fp1Xbt2zchYAqfTqZkzZwa75UlSZWWlpk+f3qspRUVFRciz9fD7/Tp06JBu3ryp169fB++n9TDZ8hzmUDABsKWePyr+xJw5c/6PSf5MS0uLysrKdOrUKX39+lX19fUcEQEMcrvdamlp0YgRIyRJERERevDggSZNmmQ0l9PplKRftu12u90aPXq0SkpKlJ2dHfJsy5cv/6N/Z+LeaI9Fixbp2rVrmjdvnqKjo/u8nPJ6vYaSwSS65AGwpT8d5OtwOCwx/NHhcAT/APrPN54AQq+7u1tutzv47HK5+rTuNqHn82HMmDF6+PChpVp2myyE/tTFixd16dIlpaammo4CC6FgAmBLf0PR8fORvDt37ig7O1uHDx9WVlZW8C0yADMCgYCWLVsWPF7m9/uVn5/fp2gK9fGy+/fvq6OjQ83NzcG1U6dOyev16vPnz5o7d64OHTrU61gcfoiNjTU+TgLWw29cALZ148YNJSYm6uPHj332Pnz4oIkTJ+r27dsGkn2/UB4TE6O9e/cqOztbL168UHl5uWbNmkWxBFjA0qVLFRUVpcjISEVGRio3N1cjRowIPvf8hJrX61VtbW3wua6uTnl5eZoxY4aKiopUWVmp3bt3hzzX36KkpESbNm1SS0uL6SiwEO4wAbCtOXPmKD09XWvXrv3l/sGDB3Xz5k0jrbudTqdGjhyppKSk3zZ4MHk5GoD1xMTEqLKyUikpKZK+zxSqqqrSnTt3JEnl5eXyer2qr683GdOy3rx5o/nz56u6uloRERG9jl1KUkdHh6FkMIkjeQBs68mTJ9q7d2+/+xkZGdq3b18IE/2wZMkSOuEB+MfevXun6Ojo4HNVVZWysrKCz1OmTFFra6uJaH+FnJwcvXz5Urt27fpl0wfYEwUTANtqb2/v8/bwZ2FhYXrz5k0IE/1QVlZm5P8F8HeLjo5Wc3NzcNZSTU2Ntm/fHtz/9OnTbz/37O7u3bu6d++eJk+ebDoKLISD8ABsKzY2VnV1df3u19bWKiYmJoSJAOB/k5WVpaKiIt2+fVubN29WRESEpk2bFtyvra1VfHy8wYTWNmHCBPl8PtMxYDEUTABsa9asWdq6dav8fn+fPZ/PJ6/Xa2RWCQD8t3bu3CmXy6W0tDSVlpaqtLRU4eHhwf0TJ04oIyPDYEJr27Nnj9avX69bt27p7du3+vjxY68f2BNNHwDYVnt7u5KTk+VyuVRYWKjx48fL4XCooaFBR44cUVdXl2pqanrdBwCAv8GHDx80aNAguVyuXusdHR0aNGhQryIKP/w8+PdngUDAMnP5EHoUTABsraWlRatWrdKVK1fU83HocDiUmZmpo0ePavTo0WYDAgBCpqqq6rf7aWlpIUoCK6FgAgB97yz17NkzBQIBjRs3TkOHDjUdCQAAWAAFEwAAAPBv79+/1/Hjx9XQ0CCHw6HExEStWLHCyCBiWAMFEwAAACDp0aNHyszMlMfj0dSpUxUIBPTo0SP5fD5dvXpVycnJpiPCAAomAAAAQNK0adOUkJCg0tJShYV9H1f67ds3rVy5Uk1NTaqurjacECZQMAEAAACSPB6PHj9+rAkTJvRar6+vV0pKijo7Ow0lg0nMYQIAAAAkDRkyRM+fP++z3traqsGDBxtIBCugYAIAAAAkLViwQHl5eTp37pxaW1v14sULnT17VitXrlROTo7peDAkzHQAAAAAwAr27dsnp9OpJUuW6Nu3b5Ikt9utVatWac+ePYbTwRTuMAEAAMDWOjs7tXHjRl24cEFfv35Venq6CgsLFRkZqYSEBEVERJiOCIP4hgkAAAC25vV6VVZWpsWLF8vj8ej06dPq7u5WeXm56WiwAL5hAgAAgK3Fx8eruLhYCxculCQ9ePBAqamp8vv9crlchtPBNAomAAAA2Fp4eLiam5sVGxsbXPN4PHr69Kni4uIMJoMV0CUPAAAAttbV1aXw8PBea2FhYcHGD7A37jABAADA1gKBgJYtW6YBAwYE1/x+v/Lz8zVw4MDgWkVFhYl4MIyCCQAAALa2dOnSPmu5ubkGksCKuMMEAAAAAP3gDhMAAAAA9IOCCQAAAAD6QcEEAAAAAP2gYAIAAACAflAwAQAAAEA/KJgAAAAAoB8UTAAAAADQj38BUXYmiiUsFlQAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x700 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (10,7))\n",
    "sn.heatmap(df_cm, annot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default confusion matrix shows the number of correctly/incorrectly classified images. You can also generate the proportion of correct/incorrect predictions by normalizing the confusion matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(test_obs, test_pred, normalize='true')\n",
    "\n",
    "df_cm = pd.DataFrame(cm, index = [i for i in fruit_list],\n",
    "                  columns = [i for i in fruit_list])\n",
    "plt.figure(figsize = (10,7))\n",
    "sn.heatmap(df_cm, annot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix\n",
    "\n",
    "This is an example of an image generator that will perform data augmentation. In each epoch, each image is transformed according to a set of random modifications. The parameters here set limits on the amount of transformation that any method will carry out. For example, images will be randomly rotated by an amount between + and - 40 degrees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_gen = ImageDataGenerator(\n",
    "    rescale = 1./255, ## Rescale channel values\n",
    "    rotation_range=40, ## Random rotation (+/- 40 degrees)\n",
    "    width_shift_range=0.2, ## Random horizontal shift (+/- proportion of image size)\n",
    "    height_shift_range=0.2, ## Random vertical shift (+/- proportion of image size)\n",
    "    shear_range=0.2, ## Shear angle in counter-clockwise direction in degrees\n",
    "    zoom_range=0.2, ## Zoom range. Zooms by 1 +/- 0.2 from original\n",
    "    horizontal_flip=True, ## Randomly flips 50% of images\n",
    "    fill_mode='nearest', ## How to fill newly created pixels (nearest neighbor)\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}