{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Practice Lab: Decision Trees\n", "\n", "In this exercise, you will implement a decision tree from scratch and apply it to the task of classifying whether a mushroom is edible or poisonous.\n", "\n", "# Outline\n", "- [ 1 - Packages ](#1)\n", "- [ 2 - Problem Statement](#2)\n", "- [ 3 - Dataset](#3)\n", " - [ 3.1 One hot encoded dataset](#3.1)\n", "- [ 4 - Decision Tree Refresher](#4)\n", " - [ 4.1 Calculate entropy](#4.1)\n", " - [ Exercise 1](#ex01)\n", " - [ 4.2 Split dataset](#4.2)\n", " - [ Exercise 2](#ex02)\n", " - [ 4.3 Calculate information gain](#4.3)\n", " - [ Exercise 3](#ex03)\n", " - [ 4.4 Get best split](#4.4)\n", " - [ Exercise 4](#ex04)\n", "- [ 5 - Building the tree](#5)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "_**NOTE:** To prevent errors from the autograder, you are not allowed to edit or delete non-graded cells in this notebook . Please also refrain from adding any new cells. \n", "**Once you have passed this assignment** and want to experiment with any of the non-graded code, you may follow the instructions at the bottom of this notebook._" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 1 - Packages \n", "\n", "First, let's run the cell below to import all the packages that you will need during this assignment.\n", "- [numpy](https://www.numpy.org) is the fundamental package for working with matrices in Python.\n", "- [matplotlib](https://matplotlib.org) is a famous library to plot graphs in Python.\n", "- ``utils.py`` contains helper functions for this assignment. You do not need to modify code in this file.\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "deletable": false, "editable": false }, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from public_tests import *\n", "from utils import *\n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 2 - Problem Statement\n", "\n", "Suppose you are starting a company that grows and sells wild mushrooms. \n", "- Since not all mushrooms are edible, you'd like to be able to tell whether a given mushroom is edible or poisonous based on it's physical attributes\n", "- You have some existing data that you can use for this task. \n", "\n", "Can you use the data to help you identify which mushrooms can be sold safely? \n", "\n", "Note: The dataset used is for illustrative purposes only. It is not meant to be a guide on identifying edible mushrooms.\n", "\n", "\n", "\n", "\n", "## 3 - Dataset\n", "\n", "You will start by loading the dataset for this task. The dataset you have collected is as follows:\n", "\n", "| | Cap Color | Stalk Shape | Solitary | Edible |\n", "|:---------------------------------------------------:|:---------:|:-----------:|:--------:|:------:|\n", "| \"drawing\" | Brown | Tapering | Yes | 1 |\n", "| \"drawing\" | Brown | Enlarging | Yes | 1 |\n", "| \"drawing\" | Brown | Enlarging | No | 0 |\n", "| \"drawing\" | Brown | Enlarging | No | 0 |\n", "| \"drawing\" | Brown | Tapering | Yes | 1 |\n", "| \"drawing\" | Red | Tapering | Yes | 0 |\n", "| \"drawing\" | Red | Enlarging | No | 0 |\n", "| \"drawing\" | Brown | Enlarging | Yes | 1 |\n", "| \"drawing\" | Red | Tapering | No | 1 |\n", "| \"drawing\" | Brown | Enlarging | No | 0 |\n", "\n", "\n", "- You have 10 examples of mushrooms. For each example, you have\n", " - Three features\n", " - Cap Color (`Brown` or `Red`),\n", " - Stalk Shape (`Tapering (as in \\/)` or `Enlarging (as in /\\)`), and\n", " - Solitary (`Yes` or `No`)\n", " - Label\n", " - Edible (`1` indicating yes or `0` indicating poisonous)\n", "\n", "\n", "### 3.1 One hot encoded dataset\n", "For ease of implementation, we have one-hot encoded the features (turned them into 0 or 1 valued features)\n", "\n", "| | Brown Cap | Tapering Stalk Shape | Solitary | Edible |\n", "|:--------------------------------------------------:|:---------:|:--------------------:|:--------:|:------:|\n", "| \"drawing\" | 1 | 1 | 1 | 1 |\n", "| \"drawing\" | 1 | 0 | 1 | 1 |\n", "| \"drawing\" | 1 | 0 | 0 | 0 |\n", "| \"drawing\" | 1 | 0 | 0 | 0 |\n", "| \"drawing\" | 1 | 1 | 1 | 1 |\n", "| \"drawing\" | 0 | 1 | 1 | 0 |\n", "| \"drawing\" | 0 | 0 | 0 | 0 |\n", "| \"drawing\" | 1 | 0 | 1 | 1 |\n", "| \"drawing\" | 0 | 1 | 0 | 1 |\n", "| \"drawing\" | 1 | 0 | 0 | 0 |\n", "\n", "\n", "Therefore,\n", "- `X_train` contains three features for each example \n", " - Brown Color (A value of `1` indicates \"Brown\" cap color and `0` indicates \"Red\" cap color)\n", " - Tapering Shape (A value of `1` indicates \"Tapering Stalk Shape\" and `0` indicates \"Enlarging\" stalk shape)\n", " - Solitary (A value of `1` indicates \"Yes\" and `0` indicates \"No\")\n", "\n", "- `y_train` is whether the mushroom is edible \n", " - `y = 1` indicates edible\n", " - `y = 0` indicates poisonous" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "deletable": false, "editable": false }, "outputs": [], "source": [ "X_train = np.array([[1,1,1],[1,0,1],[1,0,0],[1,0,0],[1,1,1],[0,1,1],[0,0,0],[1,0,1],[0,1,0],[1,0,0]])\n", "y_train = np.array([1,1,0,0,1,0,0,1,1,0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### View the variables\n", "Let's get more familiar with your dataset. \n", "- A good place to start is to just print out each variable and see what it contains.\n", "\n", "The code below prints the first few elements of `X_train` and the type of the variable." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "First few elements of X_train:\n", " [[1 1 1]\n", " [1 0 1]\n", " [1 0 0]\n", " [1 0 0]\n", " [1 1 1]]\n", "Type of X_train: \n" ] } ], "source": [ "print(\"First few elements of X_train:\\n\", X_train[:5])\n", "print(\"Type of X_train:\",type(X_train))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, let's do the same for `y_train`" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "First few elements of y_train: [1 1 0 0 1]\n", "Type of y_train: \n" ] } ], "source": [ "print(\"First few elements of y_train:\", y_train[:5])\n", "print(\"Type of y_train:\",type(y_train))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Check the dimensions of your variables\n", "\n", "Another useful way to get familiar with your data is to view its dimensions.\n", "\n", "Please print the shape of `X_train` and `y_train` and see how many training examples you have in your dataset." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The shape of X_train is: (10, 3)\n", "The shape of y_train is: (10,)\n", "Number of training examples (m): 10\n" ] } ], "source": [ "print ('The shape of X_train is:', X_train.shape)\n", "print ('The shape of y_train is: ', y_train.shape)\n", "print ('Number of training examples (m):', len(X_train))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 4 - Decision Tree Refresher\n", "\n", "In this practice lab, you will build a decision tree based on the dataset provided.\n", "\n", "- Recall that the steps for building a decision tree are as follows:\n", " - Start with all examples at the root node\n", " - Calculate information gain for splitting on all possible features, and pick the one with the highest information gain\n", " - Split dataset according to the selected feature, and create left and right branches of the tree\n", " - Keep repeating splitting process until stopping criteria is met\n", " \n", " \n", "- In this lab, you'll implement the following functions, which will let you split a node into left and right branches using the feature with the highest information gain\n", " - Calculate the entropy at a node \n", " - Split the dataset at a node into left and right branches based on a given feature\n", " - Calculate the information gain from splitting on a given feature\n", " - Choose the feature that maximizes information gain\n", " \n", "- We'll then use the helper functions you've implemented to build a decision tree by repeating the splitting process until the stopping criteria is met \n", " - For this lab, the stopping criteria we've chosen is setting a maximum depth of 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 4.1 Calculate entropy\n", "\n", "First, you'll write a helper function called `compute_entropy` that computes the entropy (measure of impurity) at a node. \n", "- The function takes in a numpy array (`y`) that indicates whether the examples in that node are edible (`1`) or poisonous(`0`) \n", "\n", "Complete the `compute_entropy()` function below to:\n", "* Compute $p_1$, which is the fraction of examples that are edible (i.e. have value = `1` in `y`)\n", "* The entropy is then calculated as \n", "\n", "$$H(p_1) = -p_1 \\text{log}_2(p_1) - (1- p_1) \\text{log}_2(1- p_1)$$\n", "* Note \n", " * The log is calculated with base $2$\n", " * For implementation purposes, $0\\text{log}_2(0) = 0$. That is, if `p_1 = 0` or `p_1 = 1`, set the entropy to `0`\n", " * Make sure to check that the data at a node is not empty (i.e. `len(y) != 0`). Return `0` if it is\n", " \n", "\n", "### Exercise 1\n", "\n", "Please complete the `compute_entropy()` function using the previous instructions.\n", " \n", "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "deletable": false }, "outputs": [], "source": [ "# UNQ_C1\n", "# GRADED FUNCTION: compute_entropy\n", "\n", "def compute_entropy(y):\n", " \"\"\"\n", " Computes the entropy for \n", " \n", " Args:\n", " y (ndarray): Numpy array indicating whether each example at a node is\n", " edible (`1`) or poisonous (`0`)\n", " \n", " Returns:\n", " entropy (float): Entropy at that node\n", " \n", " \"\"\"\n", " # You need to return the following variables correctly\n", " if (len(y) == 0):\n", " return 0.\n", " entropy = 0.\n", " m = y.shape[0]\n", " ### START CODE HERE ###\n", " p_1 = sum(y[i] for i in range(m))/ m\n", " entropy = -p_1*np.log2(p_1) - (1-p_1)*np.log2(1-p_1)\n", " if (p_1 == 1 or p_1 == 0):\n", " return 0\n", " \n", " \n", " \n", " \n", " \n", " ### END CODE HERE ### \n", " \n", " return entropy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Click for hints\n", " \n", " \n", " * To calculate `p1`\n", " * You can get the subset of examples in `y` that have the value `1` as `y[y == 1]`\n", " * You can use `len(y)` to get the number of examples in `y`\n", " * To calculate `entropy`\n", " * np.log2 let's you calculate the logarithm to base 2 for a numpy array\n", " * If the value of `p1` is 0 or 1, make sure to set the entropy to `0` \n", " \n", "
\n", " Click for more hints\n", " \n", " * Here's how you can structure the overall implementation for this function\n", " ```python \n", " def compute_entropy(y):\n", " \n", " # You need to return the following variables correctly\n", " entropy = 0.\n", "\n", " ### START CODE HERE ###\n", " if len(y) != 0:\n", " # Your code here to calculate the fraction of edible examples (i.e with value = 1 in y)\n", " p1 =\n", "\n", " # For p1 = 0 and 1, set the entropy to 0 (to handle 0log0)\n", " if p1 != 0 and p1 != 1:\n", " # Your code here to calculate the entropy using the formula provided above\n", " entropy = \n", " else:\n", " entropy = 0. \n", " ### END CODE HERE ### \n", "\n", " return entropy\n", " ```\n", " \n", " If you're still stuck, you can check the hints presented below to figure out how to calculate `p1` and `entropy`.\n", " \n", "
\n", " Hint to calculate p1\n", "     You can compute p1 as p1 = len(y[y == 1]) / len(y) \n", "
\n", "\n", "
\n", " Hint to calculate entropy\n", "     You can compute entropy as entropy = -p1 * np.log2(p1) - (1 - p1) * np.log2(1 - p1)\n", "
\n", " \n", "
\n", "\n", "
\n", "\n", " \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can check if your implementation was correct by running the following test code:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Entropy at root node: 1.0\n", "\u001b[92m All tests passed. \n" ] } ], "source": [ "# Compute entropy at the root node (i.e. with all examples)\n", "# Since we have 5 edible and 5 non-edible mushrooms, the entropy should be 1\"\n", "\n", "print(\"Entropy at root node: \", compute_entropy(y_train)) \n", "\n", "# UNIT TESTS\n", "compute_entropy_test(compute_entropy)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Expected Output**:\n", "\n", " \n", " \n", " \n", "
Entropy at root node: 1.0
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 4.2 Split dataset\n", "\n", "Next, you'll write a helper function called `split_dataset` that takes in the data at a node and a feature to split on and splits it into left and right branches. Later in the lab, you'll implement code to calculate how good the split is.\n", "\n", "- The function takes in the training data, the list of indices of data points at that node, along with the feature to split on. \n", "- It splits the data and returns the subset of indices at the left and the right branch.\n", "- For example, say we're starting at the root node (so `node_indices = [0,1,2,3,4,5,6,7,8,9]`), and we chose to split on feature `0`, which is whether or not the example has a brown cap. \n", " - The output of the function is then, `left_indices = [0,1,2,3,4,7,9]` (data points with brown cap) and `right_indices = [5,6,8]` (data points without a brown cap)\n", " \n", " \n", "| | | Brown Cap | Tapering Stalk Shape | Solitary | Edible |\n", "|-------|:--------------------------------------------------:|:---------:|:--------------------:|:--------:|:------:|\n", "| 0 | \"drawing\" | 1 | 1 | 1 | 1 |\n", "| 1 | \"drawing\" | 1 | 0 | 1 | 1 |\n", "| 2 | \"drawing\" | 1 | 0 | 0 | 0 |\n", "| 3 | \"drawing\" | 1 | 0 | 0 | 0 |\n", "| 4 | \"drawing\" | 1 | 1 | 1 | 1 |\n", "| 5 | \"drawing\" | 0 | 1 | 1 | 0 |\n", "| 6 | \"drawing\" | 0 | 0 | 0 | 0 |\n", "| 7 | \"drawing\" | 1 | 0 | 1 | 1 |\n", "| 8 | \"drawing\" | 0 | 1 | 0 | 1 |\n", "| 9 | \"drawing\" | 1 | 0 | 0 | 0 |\n", " \n", "\n", "### Exercise 2\n", "\n", "Please complete the `split_dataset()` function shown below\n", "\n", "- For each index in `node_indices`\n", " - If the value of `X` at that index for that feature is `1`, add the index to `left_indices`\n", " - If the value of `X` at that index for that feature is `0`, add the index to `right_indices`\n", "\n", "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation." ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "deletable": false }, "outputs": [], "source": [ "# UNQ_C2\n", "# GRADED FUNCTION: split_dataset\n", "\n", "def split_dataset(X, node_indices, feature):\n", " \"\"\"\n", " Splits the data at the given node into\n", " left and right branches\n", " \n", " Args:\n", " X (ndarray): Data matrix of shape(n_samples, n_features)\n", " node_indices (list): List containing the active indices. I.e, the samples being considered at this step.\n", " feature (int): Index of feature to split on\n", " \n", " Returns:\n", " left_indices (list): Indices with feature value == 1\n", " right_indices (list): Indices with feature value == 0\n", " \"\"\"\n", " \n", " # You need to return the following variables correctly\n", " left_indices = []\n", " right_indices = []\n", " \n", " ### START CODE HERE ###\n", " for i in node_indices:\n", " if (X[i,feature] == 1):\n", " left_indices.append(i)\n", " elif (X[i,feature] == 0):\n", " right_indices.append(i)\n", " \n", " \n", " \n", " ### END CODE HERE ###\n", " \n", " return left_indices, right_indices" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Click for hints\n", " \n", " \n", " * Here's how you can structure the overall implementation for this function\n", " ```python \n", " def split_dataset(X, node_indices, feature):\n", " \n", " # You need to return the following variables correctly\n", " left_indices = []\n", " right_indices = []\n", "\n", " ### START CODE HERE ###\n", " # Go through the indices of examples at that node\n", " for i in node_indices: \n", " if # Your code here to check if the value of X at that index for the feature is 1\n", " left_indices.append(i)\n", " else:\n", " right_indices.append(i)\n", " ### END CODE HERE ###\n", " \n", " return left_indices, right_indices\n", " ```\n", "
\n", " Click for more hints\n", " \n", " The condition is if X[i][feature] == 1:.\n", " \n", "
\n", "\n", "
\n", "\n", " \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, let's check your implementation using the code blocks below. Let's try splitting the dataset at the root node, which contains all examples at feature 0 (Brown Cap) as we'd discussed above. We've also provided a helper function to visualize the output of the split." ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "deletable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CASE 1:\n", "Left indices: [0, 1, 2, 3, 4, 7, 9]\n", "Right indices: [5, 6, 8]\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjAAAAD+CAYAAAAkjD+CAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAACQMElEQVR4nOz9d5wcx3WvjT9VHSbubE7IOZEEwRxEikE5S1aWHCSna1vXvr72+9rX6dpykF9bvv45X0fZkmzJki3JkmjJShRJMYiZBANAEHmBzXlyh6rfH92zAVgAC2B3ZxeoZz/92Qk9Pad7uqtPfc+pU0JrjcFgMBgMBsNKQtbbAIPBYDAYDIbzxTgwBoPBYDAYVhzGgTEYDAaDwbDiMA6MwWAwGAyGFYdxYAwGg8FgMKw4jANjMBgMBoNhxWEcGIPBMAshxH1CiB+PH39QCPHN8/z8rwoh/n5xrDMYDIYI48AYDJcgQojbhBAPCyEmhBCjQoiHhBA3nO92tNb/orV+7YztaiHElhnP7xRCnDjlMx/TWv/4xe3B4hLbrYQQhXg5KYT4aL3tmgshxI1CiK8JIcbj3/IxIcSH622XwVBvjANjMFxiCCFywD3AnwMtwGrgo0C1nnYtQ3q11lmtdRa4DfgxIcTb51pRCGEvqWXT33sLcC9wP7AFaAV+GnhDPewxGJYTxoExGC49tgForT+rtQ611mWt9Te11nsBhBAfihWZv4gVmv1CiFfNtaF43Qfjxw/ELz8bqxY/AnwdWDVDyVglhPgtIcQ/x5/ZEKs2PyKEOC6EGBZC/NqM7aeEEJ8UQowJIfYJIX7pVEXnFHtuFUI8Htv9uBDi1hnv3SeE+J143/JCiG8KIdrmc8C01keAh4FdM7anhRAfEUK8DLwcv/YTQoiDsRLyFSHEqvj1jwoh/jx+7AghikKIj8/Yx4oQouVcx2MOPg58Umv9B1rrYR3xpNb6PfG2m4UQ9wghhuJjeI8QYs0px+T3Y9VmUgjxZSFEy3yOicGw3DEOjMFw6XEACGPH4A1CiOY51rkJOAS0Ab8JfPFcNzat9Svjh1fHysUniZSAKSVDa917ho/fBmwHXgX8byHEzvj13wQ2AJuA1wA/eKbvj+37T+DPiJSIPwb+UwjROmO1DwAfBjoAF/h/zrZPM7a9FXgF8P1T3no70bHaJYS4G/h94D1AN3AM+Nd4vfuBO+PHNwD9QO143QK8pLUenbHdMx2PmTal48/++1lMl8A/AuuBdUAZ+ItT1vlh4EdjmwOi42cwrHiMA2MwXGJorSeJbpAa+DtgKFYLOmesNgj8idba11p/DngJeNMimvXRWAl6FngWuDp+/T3Ax7TWY1rrE5z95vom4GWt9ae11oHW+rPAfuAtM9b5R631Aa11Gfg8sOcs21sV55VMEjl9jwIPnrLO72utR+PtfRD4hNb6Ka11FfgV4BYhxAbgEWBr7Ey9EvgHYLUQIgvcQeTgzOd4zKSZqI3uO9MOaK1HtNZf0FqXtNZ54Pfi75vJp7XWz2uti8BvAO8RQlhnOS4Gw4rAODAGwyWI1nqf1vpDWus1wJXAKuBPZqxyUs+eyfVYvM5i0T/jcQnIxo9XAT0z3pv5+FRWEdk5k2NEOT7n+p656NVaN2mtc0ATkXrxyVPWmWnPrO/XWheAEWB17OA8QeQ8vJLIYXmYSNWZy4GZj51jgCJSTuZECJEWQvyNEOJY7Ig9ADSd4qDM3IdjgEOkvBkMKxrjwBgMlzha6/3APxE5MjVWCyHEjOfrgDOFf866+YswDSJ1Yc2M52vPsm4vUahkJuuAkxdpA1rrCeAzzFZzYPb+zfp+IUSGKJRV+/77gbuBa4DH4+evA24kcizO16YSkbLzzrOs9otEoaibYkesFraa+dvOPKbrAB8YPl97DIblhnFgDIZLDCHEDiHEL9aSOYUQa4H3Mzu/owP4uTjh9N3ATuBr89j8AFG+ysznrUKIxgs09/PAr8TJqKuB/36Wdb8GbBNCfEAIYQsh3kuUdHvPBX73FHGo533AC2dZ7bPAh4UQe4QQCeBjwKNa66Px+/cT5Zu8qLX2gPuAHweOaK2HLtC0XwI+JIT4f2u5PkKIq4UQtdybBiLlaDzOEfrNObbxg0KIXXFOzW8D/661Di/QHoNh2WAcGIPh0iNPlHj6qBCiSOS4PE/UW6/xKLCVqCf+e8C7tNYj89j2bwGfjHNH3hOrO58FDsevnW8Y6reBE8AR4NtECatzDveO7XtzvB8jRDf3N2utL1RNmBo9RRRaaSHKc5kTrfW3iXJIvkCkHG0mcnpqPAykmFZbXgQqXID6MuM7HyZSde4mOsajwN8y7Wz+Sfydw0S/83/NsZlPEylw/UAS+LkLtcdgWE6I2WFwg8FwqSOE+BDw41rr2+pty6kIIX4aeJ/W+tREVMMFIIS4D/hnrbWpjGy45DAKjMFgqBtCiG4hxCuEEFIIsZ1IXflSve0yGAzLn7pUlzQYDIYYF/gbYCMwTlRX5a/qaZDBYFgZmBCSwWAwGAyGFYcJIRkMBoPBYFhxmBDSPBFCnFOqEgLSCYvGBouWnE0urWnIuLi2wrE0tmVjWQ7IJBqXQNkUSx7Fimay5DM+WWEiX6ZY9vD94KILbBgufdasbubNr93Otk3NpJM2IJjM+zzxbB/fvO8A4xOlept4VoQQuI5NImHhOjZSSqpVjyDUVKo+YajqbaJhheLYFk2NKdqa0nS1N5JKCJpyDdi2xfhkiZ7+SQ4eGyJfKNfb1BVPU87hdbdm2LZeIwX0j0gefNpj3+ESSl38nUxrLeZ63YSQ5snZHJjmnMNVmxNcudFidRtkU+BYGiFBChvbTuK6KVwnjetOL4n4v2UnAIkfaAolj6HxMkd7x3nu4CDP7DvJkZMjVL1gCffWMBMpBQIIF+BCXEjWr23hQx/YQ0dLEtuS2JaFJSWWJZFCcOT4JH/xj9+nf3Cy3qbOQgjobMtw4+5V3Hj1Wras76Q5l8J1JEIIfD+kVFWMjBXp6Ztk/+EhnjvQz5GeEYql5T+hthCCHZvXMDZRoH9orN7mXHakkw533bSWu27oZtPaJpoaMiSTKVw3gW05U+v5geZ4f57Pfu15vvqd56l6fh2tPjtt2Qyv3rGNzR2d7D3ZxzdffJGqvzzszWUdfvJdWTavDqmVxtQaPF/wlQcU9z6a52LdDOPAXCRzOTC2JXjlNRlec51NU1Yxq64pEttO4DhpEm4K103juGkSs5yYVKTIRNuf+uTM36RcDdh3ZJB/+9YLfPexw1Q9U39qKWhudNi9LcnmNZKmBoEQMDapOXBM8dzLFSby9W08UimXn/yR69m0PodjWVMOjG1JbBk9llKyd98wf/hX91GpLo/Grinn8ra7u3nNrWvo7mgjm20h4WZmnf8ziS4Fjecrevrz3PfoUe757j6Onhihnm2XJSUp26Yx4dCeTNKcSnDHq29GFUpM7D/CHXu20F8ose/FoygpmMylYaxIECqa1rQzXvF44mAPw+UKJc+n6psOykKQSbv83Ad28oo9bSQTSRwnhesmsZ0Uju0CnHau+YHic/+1jz/91PfwlmFHcVd3B3/8ltdyVdda3ESWQEv+6YnH+a17vkI1qK+9QsDb727ktTdr5rqESxXBn33W4+jJi1O5jANzkczlwLz6hgbefpvAtk5d18J2UrhOTXVJ4ThpXDeJ66RwnFTs3CQQYnYaktYarRVKhYShh+9X8PwK5UqJ/3rkBH/zhQP4gZHVz4SUgoQjcRyLSjXA88//WO3ZkeFdr3ZobYw+O7NXoYGRccnXHgp5bG+hbqrMLTdu4J1v2YbrWDhTzsv044Tj4toOQaj4479/mPsfebkuds5kTVeSn3hnOzs3NZPJtEwtjp08owNzKlprxvMeX/jGPj71pSeYyC++/G/bNqu62ti2eR1yYIiNG7p4RaHKVgTNSZegs5FKa5bsZJERVaG3qmiXLmuKVZrzVQ50NTDQ1cyO8RKpyTJu2WNkVTN6tIBXqLC/PcfeSpX+AMY8RaXq8czeAwyPjqPU0l/rArAsC1tKkq5LynURKkQC6VQCKQRhGFIqlwkAJQSFcpVAa4IgrFvo25KCD755M++8u4uEm8JxIwcm+p+M1BcBgtPPNT9Q/PGnHuOzX32yro7xqbRkUvzju17PtavX4yabkfG14oUhP/ulL/CFJ5+oq33NOZdf+nB6jg58hNbwvWckn/3a+EWpMGdyYEwOzAUiBezeJLBOTYMWEstO4thJbDuBZTtI6SClBARKa8Iw6g0rFUw13Frr2GnxCUKfIKgSBFV8v4IfVPD9Cns2e3S1uvQMVJZkH4WIlig0IeLn0552rSHQiPjmLtBKE4SKUCnQoJaoMXAdye7tKW680qWrVZNwBPmS5vBJzYNPVTneN79jtnFNkg++0SabOv2CFCJq3NuaFB94vSSXzfKthwsLEuM9HxzH4ro9XcgZ9gmmJ7+RQuBYNkknibIVd92ymQcfO1TXfJKWRocffVuK9V21HrCY+n8+CCFoziX40Xdeze4dnfzmn36L3oGJRbEZYOO6bn7hp97Lps5mtpwcIDzeg5KS7oP9aCk49qpr8Lo7SLx0iPGWHCOuJgyhHEBpcJz0iRHk6lZSuRTjDRlGmxsJDx+mokPcK9eTKlVZ25CipaMFO5kk295FJT/JeLHKdx59kX/8569S9QOCRexpJ12XVU1NbOvsYkdnF1va21nd2EhLKkWD65KwBTKoQFhFEKDCKqFfoeqV8MIq1aDKRDHPWNWnN1/i0HiJA2MVDo6VGS5WCZbovLtpdzuvv7kRiDqB0RKiVYgKA5S0kEg0+jRHxrYEP/qOq3n02eMcOja4JPbOh/fs3soVrY3xBT5tryMl/+3WV/D155+jVK1fWHXzOpfGzNzOC0Qmb14DrmMtSvTAODAXiNJw37MBfujQ3CBJOGHc83fQSKQUSAlSaoSIGh+lFEHgI6WcobxotFKEKkSpgDD0CEKPIPCmnJgg8AhDj6MDmrFFCF04tiCbtmnJWbQ3O7Q3OTQ3CFoaU6QTkE27JF0X15bYdhSmkNJGShtLWiBsEA4aC43E8xVVT+OFkmI5YKLgUSiFDI3lGZmoMDRWYHS8yGSxuiCJmgnX4v1vaOCGXQopp+OwjVlY3Q57tiX51D2S51+endAqpcCyJGGoUEojheBVNyXndF5mIgQ4tuaNr5D0D6V49qWlTZTtaG+gqzMd9XRjB1EzPeugRqNiJU+j2bC2kVxDirHx4pLaWUNKeNMr06xqj37nWg+3Fh66sG0Kbriyi9/+H6/lF3//ngVXYq7atZnrt3Tz9o3dbPLL9I1C+YkXWJsvIzQox2b82m00jRWxDz1D/7Y1pIVDS36cNgEdFUXzgT5EqOg8NIC3vpVcIkvY1Epu4iCVMKCQqOI3ZVl1fIhKWxecHKX63MuMr+0g4Vd492uu55pVTQyFkr/59D0cOXbRc1ZOYVsWO7q7ePMVV3DX1h1sbmujwXWR8U19ZscKNCpMEgZlQr+MCgWBgISEMJSEAbTaijCocFVOoLpsQt3AZAD7J3zuPVHgwZ4JRoqLd6PdvLaBH3xDC44VRh1BFSACP25nxZSybVkOUloIIdE1UV1H10xTg8WH3nE1v/2X9+L79Q/VN6YSvHVLF+gQrQJU6CFldH8B2NXeytWrV/HI4SN1s3HzGotzjW/JZSCVlMaBWW48tb/E0y+BY0ssCQnXxrbBlppU0iXhOtiWIJtOsGFtB0JoUskEWmtsSxKGIVIoQDM0PEIYBmilUDpEqbj3oDVaQ6kKLx4pUygtzEnQkLbZtNpl53qbjd2S1kZBOiFx7GiklGXZSGlhSTt+7MQXf+159N+SNtJyZqw3/T9arFPyeyAINeVqwEShSv9IkcMnRtl/dJj9hwfp6R+nWJ5/QyeF4PWvyHDjFQo5R1EAIaAhrXjH3S6HT3h4nmL9qgS7t7ms7xakUjaFYsChHsVzBwM2rhJndV5m4tqaN97m4ocSKWB0wmd0IqBSXdzGb92aJhxbgtaR46JroUcdK3kaP/Qp+9GOJBOC1uZ03RyYrrYE1+yA6Z7xzB7yhTuvQgiuu7KTD7z1Wv7vvzy0ILZKKXjtTbv44Vdfwxo/ZPOLvYhD/TSt6iAZKAbWt1NozrDq8ABqYoLkRImgtZH133sOu+pj330DVqVKw+HDCKUQQG6sxBVjkZOb9wLS40VykyVyVc3w9q3YveN0f/E7+NkUpfXdZI4OEXa1kXjsBYKuHN2W4uO/8qN8/M8/y0snBhifyF/4MQN2dnfwkVuv5+7Nm2hMNmDZSaTlwCnOS219HWsVAhE7BFEHbOaCiJwCISVCSSxCmh24uc3hptZmTm5v5PMH83z15WFKC5xnkk07vP+1jTQkfYJQznK+psPxPkHgIeN2TcaODYBGRe2uCrn5iix33LCObz9cP6egxlWdjaxOCVToEQZVpCxFv4PlgtbIsMIdm9fVzYGRUtDVKhHi7O2dJUMki6MgGgfmIomyraNGuFz1ZrwzrZRs27qZP/r5X8KvjFP1ioRh5JiEQYCUFhXP5id+7mOMTyz+aJH2Zofbr05y7TaLlmx80xfEaoqDjJ2SKYfEqr3unOLM1NZxZjguMx2c6cSgWQ2iAFcKXMelMeuyrquBG3Z1AlDxQvpHijy1r5/vPHaIZ/afpFT2Tt2FWWzfmOKuGwRSnrkXIAR0NGuu2Znlqi2wa6PGsXXcc/DQGnZthFv3JKkGNlqH83JihIDVHZp33J1hdVsFP7AYnhA8uU/x4FMlJguLc9GuXtWAELHqomtqi556HCqFHwRT+ROakMZcalFsmQ+7Njmk3Oj3iZzzIFYb/chpd6LkovnmwcxECsFb7trGv97zDGMTF+egWZbk/dfu5Geu34Fua6et6FO4YxWMT9D8xH5KCZujuzfSNDCGXQ3ob2sgkXHpPtRPMeXQnC/T8Z3HEVojgulGvbZXGmh4+mVCS6KBxPAEq//1m4QSfMdC+z5u3xBWewvWgR5SxweovukV+Pk8qckh/ugn38YjQwV+/Q8/gXcBI2aEgDfu3Miv3X4NnZkcFj6BX0SrAGm7SOkipB2HKmpOgIp6/8pDhR5K+WgdxJ0rBVrFUppmLkGtFvlYk5L8/JWN3NCZ4g8e62OosDBhcCHg7hsyrOvwiKJskdNiTynakeMy3amSCBF1qoQQMxz/yIFRKuBH3rSKsYkST704WNd8mJu6GxBhhTAoI+L2VCkfKe24o+Kzp6MJ25JLFqabiZSCTOrc36sR6NgVXmiMA7MElEolbNsl2ZAj4dlRTFYFBIGHkBKKYtEvFCng5iszvOUVNk0ZjRC1BFULKd1px2XG/ynVZYazMq28xE7MLKcleq12I5rvDam2Xiphs3FVIxu6c7z1jq0cOD7Gp+95lu98/wB+cLqXb1uC197iknDOfhFpDSOTLm++PaQpG8yZ2wLQmgsYHLepeBapxPxUFEtqLDuSURMurG7XrGqD3Vuz/ON/lBkYWVjZXEpBa0vkjMx0XtSU81ILJoVTDozSkEw4Z97oIrOue1pmnu28+IShh1IBlrww+7TWtLck2byumSeeuzgH5qYdG/nlbWtJNzQxuWo16fsex54sMnrbNUxMFkge6WPLkwdpGi0gHJvNzxzB9kNsLyRostAJBxmP9vJdCyeWzLUQFDZ2kznah1CaydYMjSNFrFCBUlHYJlAIrbGDEqWWJspdrST6R8jtfRm7WMZrSLF6rIHbd23i3W++k899+V6C8PyUvhvWdfBrN22iSfoEXgGlPCxZRVkuMnAQ0o6WWGWJUGgVhzCUHy2hjwqrsVMTvaZVEC01x+YUBGAJuL3dxb15Fb/2YA/5ysWHwztaEty2G5Sq4gchSodYKiS0fKzAi9svK3JehBUpRELG13zc7mqN0ipul0MSVsBPvaOFf3IVDz09dNE2XgiOJdnVZM1yXrQKUUE1fq5RYcDqFDQmE4wUl76WjRQC25bA2c9Dz7cIQgtYeCfLODBLQLFYpuop0o1ZpGWjVEjgl1EqKlZXqUSF6xaT63dleN/ddqw8xC8KK0owPsV5kTOcERmrMbVwkBWHlaYaBWnNWORUz+ZiECIa2bVrYwu//dN3cNXWDv70nx/CO+UYZTMuqzvOHPKp+YSTJUnVg87m052X2d8LjRmPfMkl6c5PhQFiOXr2dtZ3Kd792hR/++/+BY2EOuN3SUEqGTdoTDsxSmlCoWakJQpUvANKgVenmL4QkElNN3JKBbNyvHy/iuNUka593iqMnurRBXS1N1y0rc2+YjhwyB0fwQv30+9LApJYTx4myJfQ2iY5mEdJELZNamw6lOOMF6dPOJh2XgAtwC5VqKUKNA/mp94DEEpjKY0S4ImAhpeOT20nOTBGtS2Hky+THBynu3+AX7p+J31DY9z7vfmPQLEtyQ/taCOtiwReEDktoUsoXaR0EJaNFDYizg+ZHnrHjHBfEOdizFBkQg+lqqjAix2cgLP1tIWAG1sdfmB7G598tm/e9p+Ja3ckaIhVgNr3h6EXt00OlozaKSElcirkNUNh4lQHRkUONQFvvlWy94BDvrj0JQgaEjbdSQj8KPSotYpCSZaLELEDowLSVOnI1MeBCULF4Kiiq2V6wMepaA2Do5pSxYSQViylconJfJmujlZsO4nWIZWyxPNKaBVS9QP8YPEuEtuW3HmNg2PPSE4VMr6wo55JLS48+0K3Zse5kWhkPOpIoIl69+ioEa71smtq0nndjE5RoCJJV4EOedsr1/Poc8d54InZsd5iyadvGBrS0cWjNSgtqFQl5aqg4kmKZXj4WZ+7bjh7Yu7UsbI033/OY/dWizUdCinmrm8Q2Qhlz0Kp0387IWDHBs32jUmeO7BwSb62bZOYoaZMOS5CIJQipObYTDuSYaiZmKxP/ovWUK7qGc9VnJgejazzvDK2Hd1EHTvKD5v3eaMjh8jzygty/Xzt5aP0prK85U2vZ9OmDaRSSRCSVMIFrVC+j+VVEROTMDxMolREl0pYXoDIpAiVwnEciJOopYiukainaqHXRQ5oGCoCpfCkHf1esWoZqpBQV2kYL+GGIXZ+EkKP1qECad/DUSFupUL7S8f4ofVdfO9hC3+eKkzalmxIBfheASmrSMtByNoISXuG+mKdcpOPQyxxnkjkxIToGWqMrqkyKmA+vWwp4I3rsnxhv0PhIuoTCQHrOuWUmqw1hAp8T6N1GIXqEVh25MgIAZYIo0KPUkShPqFim/WUehQpSApLytNKZCwVbSmHrCPQajrMp6zq1G9Us1eEPt1Zl311GDillOaf7ymydX2Cdd0W3W02q9oljptgdLxCoVilVHV4/PkqYbg4EQbjwCwBvh8wODzGrp1bsVQiurgCHyksFCFhKC66UuFZ0ZogiC7ufAkCZaFx8AON0lEYSWlBtVolCD2kFTlZQVimVCwhhI1lJyKnRYMK9XQD52ZYu7YbpRSuLcnn89goEokogVnogEwmTSLhYtsSW2hsW5BKJeMCbGBb4Ng2UmosoSJHKO7x1UYUZFOnn6p+oPj3b5e56aoEQghGxkO62xw6mzxs6ePYmsaEIJdyGRwNWd8Vfe5MPQWAIBQ8va/CZN7m2h0umbSkqUGRToZYUs9af3TS4kh/B6vbbKp+HwlntsJjSc21Ox2ef5kF+3210rNGbWliJwaFQKJRWES1OUQ8VLRUDRifrN9Qy+de9tm5wSadjA5CEET1jWy7jGW5UzlTkfLmntOJqTm7SoVUvRKFYoFjJy++4q3WmqeffY4X9r3EqlXdbNq4gc7ODoJQYVuSrq4utFLYto3j2AyOFqlUquTzebQe4eZrNtHZ3owXaizLxXGTBCFk0mlyDRmU1pQrVYaGx+kfGgcEDbkGMqkUbsIhlUiAgIKMEvy9qocU4GiNLJVITIzTMDRI0+AguycnWdfYwKHR8XntmwKGqoqc4+NaAVZYicPHNdUlXqQFQkZpuzMLIE0lYIezHBmlov/nGx7oSFl05tIUhi58CLzW0D+qyZdtxiZsxsck5QKEvkYKSTWEzVf4NNgBfhgSBAFBqBEyassq1QqVqmRswCKbsnFcaGmGlsYQL5B863HFeJ0KVnZkXNza4VcBgQoRYXXKwYz2Pxoi3pG8OMX7YiiUAp7eF/D0Pti1JccvfXg9lp3ms18/wtBoQNqtEmqL1iaXyUKw4DXMjAOzBCil6O3rjxoKaYG2kFaULCeEYGKysKgFq4JQ88UHyty2O0PvsMJXFpYAgcS1Jcov4kgbKUD5HpYo4dg2AoUKfCwhsC0Z3xAjyTW6yUAx1c1113VEUq1l0zNwgKH9T+BYUWglVApiSVojIolWayzbAWERqkhpcZMphJQEYUAinUJaglQ6xY6NWcIw4KGne+bct56+Cj0zarxcvTXB5lcqLGnhWGlcJ8vGVRb//t1ejvZGPYWuVklDxkWIKLxSrnj0DQv6h31ODHiMjPv8wB2trG0VBKFFqegymZf0j5U5MZBHaegfrjI+6fPuuydI2LspVVZT8V6gMZOfrpMjYH2XwHUkVW9hfl/PDzjZm6e1JSooJkRcayc+f6zYyay9BzA0XGaijnMiPfZckaMnXTaudljbZdHREtLWXKG12aGxwSIXSkIlUEqTSKRx4qk1YO4K1ZqolpLvlalUC+w7PMzREwtXC8bzPI4ePcbRo8emXhNCxLWcpglPUT+S8pW8+y03USyM4ZXKhJUoDOt5NmOF6ZyxQ/sP8snPfxcpJdlslpaWZpqbm8jlcjQ3N5PJpGltacGJ54YKgqgOjO+HFGSSARL0jxQYLM8/EbZQDfj57x6jLe3S3ZBgXS7B6oxNV8qiM+3SlLDIWIKkbWGL6PyJi6UwlZ0bKzHESa/zTcqsfdzXMBloeoohTw5VGS5efCLvNx4p8MLBLE1OSDbpIHQAWiO0wk4luD6nyCRPHQgQhTO0Bi+QDB23mZio4CvBSy/DuHI5NlCgf6iyuB3Ls9CRdk6pkKSjHKM5RvO0peskE1G7PjUgaMo1srp7I0dOFnjbnZKWhiSurdAIqp5gYEzw9L6Q7+8tkS8uTEjJODBLxPGeXiD6wTViKjFLIBgeWfyKm0d7qxzrq2JbgqRr4ziaTCqBY2mSCYtUMoElNa4tSCZcfMtGCoVMuuAmEJYTFU7TIQKNUgopLdKJlqixi9u6jvYWhvqbaWx0kVYCiFNKVXQ5+oEmyseNJv2SopbLoGOHQlOulAk8wVBhkr0HB9h3eIh88eyjkWoc6Qvxgxy5XIaEk8GxU2xdYxMG/dz7aB4BvPNVXVy3PY0lHWzLwUlY/MODh+kfinITOlqyXLFxC9lkLRcgcgruf/IA33t6uqf/hles4soNm8ik0wxPSsbK1zI8+RItDQNToadcFjJpm6o3P/vPhdaaL371Rfa+0MamDU10tGdoyLpkM0lsK4xGlWmN1oIwhMl8he8/2VvXubS0hoERj4ERj+/vrRVHnCSRGCHpStas6uDOW67BtUtYVhnfK5FOJUilU4yMjiKFwpLR/GLR6IsoCbhcDZgsVHng8RNUqou7f1rr0xyWU3n0qZd406v2xCNvojpQthXVGrJsgWVF6sYDjzzP2Fh0Ho2MjHDs2LSjZMVTQKTTaVzXnRopU6lU8H0fz/MuuK2YrPhMVnwOjxapDTqXUpByHBqSLo1Jm/ZskgZbkHMlWRuakjYZAtqbGmhvcHG1JJlwkVpRLZdj9SU+RsJCISh7PgUvoILDYKHMiAc9eY+eyQp9+SoTFR9/gUbNVKohB8/gvK7p8nizlWJmtfOZCcbReag4MFzi4LEK1UBR9cNlMedZU0LOu8Zji7v0DkxLU4KrtyXZvlGScjzGCi7Y7RS9LBPjT7CqtTRDjdbYKc2mFGzshmt3Zvmnr5QZGL54Vdg4MEtEz4ne06TxKBFe0tu3NJnuWkcORC1fYHRiZqN/5toSQsQ1K2PTo8kCJVLC+966Yda669d189mvlhgYPDZzC1M9mTjpP84NmGXd1Puh0tGIggtoSArFkJHJRtZ3NkXVkC2XTMpl99ZOvvf0MYQUbOhexZr25kg1EhZ+KEjY04mT67ubaW9qi6ssR0aOTFZ54fDo1DpdbQ285dZdNDU0YUmHNa2QLdmMFK9monCUTOoQrh2QcDRNDTaj4wvjwABUqz4v7OvjhX19CCFYvaqT3/qVH0eFZSrVkD/6888wNDyGUlH4cqkrBZ+LmedhoQjZHNx522sojI3hVeMbtNAIx+EvPvk3nOwbqLfJ86K3b5jDPaPs2tqGZdvR5IFOAstycBMp0pkmBkarHDh85oJ0YRjlbkxMLJyiNBeN6Qy3bNnC7Zs3s7WlkWZHkrBCpA4oVwrkq2X6Jic5NjHJ3pFJhiar/MRPvQ6nIYfd1EGl7PGLv/xx+vuHp7YpZOTwe35AEIZoIesyFUKNzes62LXjalLJhsg2DeXKJBMTvYyNn8D3y1EbZAnG5tlBWioanTmKWp2BhqQzlQO42FiW5LZrG3jdLZLmhhAIEcJC65BSIDjR10smWThj3qAQsKFb8Y67U/zdF7yLzo0xDswS0dvXj+8HJBIutSLWkSQu6B8cqbN1Z0fr2TUelIpOXMuy2LplPclUAmlZNDY309zWxo7tmzl4pLcutiqtOdIbcuuVORzLnRpB9aZbN/PU/n6qnk9HcwvZVFPsmAlcBQ3pxNQ2tqxpw40nfqtxuHeY8XwUhkknXX74DVezuq11xpBMaEpbhMon5W6h4rcwUXyOhFPifMvlnw9aaxzHZcumtRAWkFaSNau7KRaLtLVlSSYcfD9kYqLM2ESZctmra22LufB9H9t1cVwXpRS2I7FtjZ1IkMs1rBgHJghDHnv2OK+6+2ZCv4ztRA6MYyexnWhCwe89fj/FYv3CeelkktdfeRUfue12drV3YAuBRuP7ZSpekVIlT8q1aAiTtOeSXNmV4/VBmX43TbIhQSabIJfL4CZTeFgUzqbsXUSRwoWguamNttYNszqN6XQzrS3rqVYL9Pa9wNDwYSy5vJwXgGzKnXerkSRcpCorp3PT7izvehXY1umjNJUKKZcnyZ6jIoIQsGm1oCHtMJ6/uGNvHJglYmh4hGKpHDswTE2soxX09den1sDFks2k2XXlNhoyGiktbNvFsi1uvWk3X/vmg3Xr+b/ck0eQxLHdqdFVW9c0c8d1G3ngqaM0ZbOz6o5YFuQaMkCkNq3vbDwtiXQ8X0YpjeNY/PCbruXWK9fEQ8aj95WCkyMFvvPEUR7f18f67ha8MEX/8Bgn+hd37irHtrBth4qnePLpvVy3p4nX3XUjiUQ0msSxomNQLoccP5Hn0adO8ML+vrqGlWZSLJWxEwla2tuolstIW6F1GWk7OM7KaqKeeOo5RkZfT1Oudn6JWWNMDx05XhcHsiGV4tU7d/Chm27l6u5uCoHHvolB8rrERDVPgIeSUa2XUAVYjk1AQCgUOAlKTootKog7M5H9Xbk0x8/xvfWkUvXi7Ixpatd1IpFlw/obSKdbcOzH62Lf2XDOo8/jyqku8aLZA9F8Rrdfa2Nb04MVIkVdcGLIouQLbrthO0eOgQpGERRxrGgwhZR66ncQArwAggW4P6ys1mEFMzmZZ2x8gpbmRoC4Uq3A8wKGhy9+BEU9aG1tpqmpARUUZt3wr75yKy3NTQyP1Ge/eofy9AxV2bU+M2tI6Ntu28aBYyMknVOnN4hqRQLYtkVHc/q0ba7tbMJ1bN5+xxW87oYNU0myUZG8Cl/63gHue/Iwk4WoHsPxvuHTtrFYWJaFZdk88exLFAqHWdPtTCcSA5YlSDgWuUyCtV0NvPLGdex7eYx/+NfHOdlX/3PP93y0tGjv6iDwPIKgQKk0BAikXDz1ajEYn5jk+IkBmnatmeNdfUEVdC8Gx7Z41fbN/OSN19DR0sKAKvONwacRtocUIUKHWI6FCgMc245CPkGIV6kQBFFdFCEEVrZ5SlHR8RQJP3JlO8eP9dCfX5rJZc+XSrXKaR5MTHT9S9rbNpHNHgZGT19piUknEiRsm2K1ii3mr16lEm40p9scxT4XEikFSXe63VNKUKgkCGnm4efKtOQ8tqxtZdOaWylXAp7eP0DPiQM0NfgcOl7m5aNjZDOCXDbJsV6PYunirwXjwCwRlUqVgYEhNm9cF78SxTgLpcqSTCGwGKxd3UUykaAUFGa93tqcY/eV27j3/kfrYpfnBzzwTC9XbGifKqwnEHS3pHnnq3aTcGef9gJoa0yxrjtJayOU/BJ+mMOZMdV4R3OaV920jXfdtX1qZm6toW+0xO9/6kGO9tYvDGhZknyhytDwUTraZhf2m9p/IZBCYElJNpXi9uuaaGlK8Tt/+h1GRgtn3vgSUPU88sUyW3I50JpKWeL7o3hBSLlSv+HfF0IQhIyOTgCnODBxleSO9lZc18VboKTus5FJuvz8rVdyy+Y19NsVhoJjJGxw3Wi6iSAIQWvKVY9QKaqhR+hmCEolgtIkKozq2jiuQyadRqk4VKEVIMknsiTqVShlHpzrhh4lWltYdv2m2QBIuy4fvOEa3n/9zbRmGnjm5AnGTj44789fbOHQ+VL1Ap4/GJJJSg6fFDzxYsibXtnALdes58Y9XTy6N4okWFKQSdl0t2Vpb2jBscr0D8H9T9RGkl74XF6nYhyYJSIMQ06cnFl5MurxD49MUDqP4ZDLiU0b187ZQ5aW5I7bruO7DzxWt3yL5w4OUKyG5FLTITsBrG3PYFszbdZUfcWurQF33ZTAdTSV6l4O9il2rF495Qzk0i5vumVrrN7UiuZp/v2+fXV1XgCy2QZ6+4fJZsK4yNU0Ue5SlDVdm7EmDAM8IVnTneY1d2zlX7/0dD3MniIMQ8YnJrDim6H0ohEY1WrA+PjKcu5Xrepm05arqIYZPCUQnsayQyxb47qCD77/3aTSWf74T/+aanVxnbP3XrGKHWtznEh6JBywiBLkVRjNleUHAZ4XUKl6hGGI1bqaa195E+NjeZ5/4EES0sdNODiOQzobOTAIEU98qNl7coy+Zaq+AORy2XMWr4zqKC2JOXOSdGz+96tv4n1XX0sm2xnVeVm1hoeGXM5Von+p0RruuT/PvY9KJgrR4IANazp5w12rSSYybFgzOyRdKFfpbm5AhUk62hNIeXDBk7qNA7OEHO85edoNfWBwnCBYHrkI50tNTRJwWvj1+mt20tzUyOjY+FKbBcDQeIHjAwWu3NA6qxFTujb6adrggfFxOlsGScYTDqYSASOVHqpBF4l4NIBj1yYkq2X7a4YmSjz+woml2aGzIC1JqVxiznSRqXmSono7QSgoe1UqfjTaZ/vmlrpNBjdtomZwaGRqyHBtiu2JyRL5Qn0qCF8I6XSaX/1/f47bX3ErwNREgTOn1xBC8KEPvpvGXI7PfO6LHD5ylMIi7KMUgg2NDvmsS9oVhCqq3RKGiiAMCfwQzw+oej6+H8Y1qSSOY9HekaNj02ac0ZPYlsTDJpF00Ko6NemhbSV4cbCAt8hhi4uhqSFxznW0hnyhfknVr96ymrdtXoU9o8aQEBBy7jmGaixlH7HqhVS9abseemqQn3yfIJUU2LaDH4Q4tkW5GpJM2GTSjSgdks0sTo7O/MdqGS6aaCh17VnUoJ3oHVp2o0Lmg23brF+/mjONsGlva2b3VduW1qgZBEHI84dnJkdHeTCOm4hqz8yYwdlXPpacXR9CiiLlqjfjJlRLXYyKeYUq4MWjQ0wUln4OklNxHIf29g5GxgTlcjT8fOZw9VBpgvjG5QfR1BVV36cahFFC5jJIMxkYnH0daGBoZJxqdfmNEDkTr3nVHdx0wzVUqx7lcmUqfwTiasmholL1yBcK7Nyxhde++k62btmyKLYorfnaoVHGx0r4oZ7VyRAIpCVxHJt0OklLcwNtrY1kZUixWAGt6VzTjpPK4jo2wkli23HoSEcVYKUF3V2ti2L7QiCl4IptnZzr5NZKM1knB0ZKwes2tWOJ6aq6GrCEwsNC6XPf8pWGZ4ZL855SYqHpH5rkmw8dQWuNa8PgcB/F0hh9Q+O0N2dIphpJp5rJpk7PK1wIjAKzhPT29hOGIbYdzWUBgp6TK2OI6KlkMmm6OtrP2D5YlsWdt9/I/d97vG4O2guHBwnv3I5tzSxkpVFoxAyb2hpyHOjtpqWxn4SrCENJNcjiWHKq8JXWmiDwCbUbTbMQeDx3cGBZOJ9SSrZv2YgI7+JEbz/jE5OUKgXKpQlSKXDskFRSkXIViYTGtmTsxMHBI2MEC1ze+0IYHJoRhosSLTjZO3zO4nHLif/65r08s/d5cg0N3H7jZm64ZjuJZBYprXieHc3n/uNBHn/6RSYmJhZ9OPWjx0YYLD/P7i2r2bK2ha6mBGlXYllxUT3HQaOxrCip3Q8Ceo/3s3XHOjIZhwNVyehAiSApuWNHSKg1SoWoMAQVsm3Ler7+zfnnaiwlWzd0cuue1ecMIYUqmj6kHiQdm3UNUXuiQp8gKCGVT5oq6XQX3xg+QZvtsSYlaHEFzimzOxRC+OaJEn/37EDdKgZrrfniN57nLXdupbHB5eVDJ/EqgoHxHKs7spEDLwT5spnMccUzNDxCpVIlm428UaU0J5dwtMpC0trSTFNjA6jazLozrqD44Q3XXkFTYwNjdcpjOHJyhOGJCl0ts71/pYIpFQYgnRC059bz0vExcukcwmpjc1czjq2m5h3SgG0LfN9DaY98qcDBE8unfo+UFp3tTbS3NuAmMoxN+IxOeOQyAWOjw/QNjvMnf/tvuI7EdQQN2RSWZbHvQH+9TQdgYGAQpfSsnKrjJ1aWc1+tVjl2LEpUzCY8rt3Vih9OYFkOlu2QTOU4crSH3t6Ln4V5Pmjg8OA4RwbHSSZcmnIZ2hoztDdlaW1Ik7FAVctIx0U4LgNDo4TJPn5ybQcJS+I7Nn/71Ud5w2tujsrYTzkwAaEK2LRxFZZlLTsn03Esfvw9N9DU4J5zXT8I6qfAABYKFfqEQQXhFaIctqDM3auaKDT6PDMwwOeqDXQlXGS5SFJHUzl4lstXHnuZl/vHCevciTrSM8yXvr2fD77lSvIlDeExSt5aisUMjpOM5hh74fiilNUwDswSMjGZZzJfmHJgqp5icKj+w/cuhM6OdpLJBJXSmUewdHW0csWubTz48BNLaNk0+VKFp18e4PU3bphKvA18D8/XcZXd2ky7Gkf6ZBM+GzpyjJUypByNH9SSLKMLr1IpU0w4hGGBk0NDDI3VL3Y+G4GQMk7gjW4mI6MTbNy4GcJhGrOddHZ2EQSSnhPLs+bQ2PgEQRjgxvV5lNb0nKzDFLsLRE/fGG4yR2NjDtdNkc21Yrs5iuWlH1WlgXLVozzk0Tc0PWx+ZlZCLf/IkpLrbr6S267fxLZNbXR1ttDV0UgQ+NE1pELC0McKAro7W0ilkouSw3Mx3LxnI6+8Ye28RudUPEW5Up8cxFBDyfNQYZUwiEPRQhAGFQK/gAxLtDiKNatXsX1rB55fxY4nCU2mcnzuqZ66Oy8QdQT//vOP0ZjVrOrIMDqiCdQgvb3jOE6KYlnxwGOLkytoHJglpFyOhkyv6u4ABJP5ChMTCzekbClZtaozkqFhRhhp9sVkWxZ3vOKGujkwWsO9Tx7mrmvWkXCimZpTLozkizSma3kwChXPfB2EkiCskEvZDE3kycWjK/V08gD50iSVaj9H+/OUF3n+nfkSBgECGZVLDyKnrFDyyDWkGB8JAEkmnaSrs23ZFk0cHR2jWvFwnciB8bxgyabYWAxGx0vgNNLetRbHiSrxVqsK318e5wzMvlpramSoFN+672luvnYjmZTLnbfupLMth1IBQliEgR8ttk+uIUlTY8OycmBSSZcPvfNaEs65h3drrckXq5TK9cmzqvoBJwtldjRXCPxiXOEcwqBM4OUJ/BK2DmhpX82GLZuZnBjEtpPkmtqQdhZ/GSVQF4oV/vDvvs9dN7XRnEsQKo+ElUdr+NajimMnF+c+ZxyYJcT3fUbi4m5CwMDw5Iqrc1GjuzNywk5jKvEsuu3fcN2VpNMpSqX6JLsePD7EIy+e5ParughCn5RbpWewADrAEkE8Oieau8UPBX5QoaPF4uWTPpKJGXuiKZQlJYbQKs9Lx+SymWNoeGSUIAyRworLwvu4bgqBRutoaLXj2Gxcv5qnn91Xb3PnpFAsUSyVaGjIoJViMl9iZGxx5wNaTCqVKif7hqMpHmKmhrQvc57fd4SjPSOs68pw4561OIkGtMojpIrCR4FP4FdxXIu2tiZOnFweYUiAW65dz+5trZyxgl1MzWEbm6xEo7DqgNKa54cL3NndgBASaUWDBlRYIfAKqNDDkYLQD2lsaUdaIa6bwk1kGRmrLCsHBqBc8fna/X1YMsp7+foDEoFgouAv2mlvHJglRGvNxGTkiQphcaxnsK6TnV0MiWTyLAly02frqu5OVnV3cvDQ0aUw6zSCUPEv//UsHU2SzmZFuTqBa4+xv0fTkfOwLC+K62uN0kmCsIIgxHVcxgu91KqngGZk3KU5W2RgzGLvweUzOmZwaJh8voQVD8WczJdoaWklDD200khbIoRk84yb6XKjUqmQzxfp6myPhlUPj0cjYlYoSilOnJxDQVoGI77ORblc5Zv37+Un3n8bqVQKx3UJygqtBUHoI7xyVNROSLo6Wupt7hSOY/HWuzcBPlpHlXZhdqE3Pd3DIlQBJ/tHCcL6qWJP9ecpb28mBYjQBq0IwyphUEGj6Um0kWxq46m9R3BkCddNUKoME2qXn/zRH+YP/s+fL7syHNFs3pqJ/OLf24wDs0TYtk1XZ+uUw6K0ZGKyxM/+9If5zOe/zMjIysmFkVLOqCh89hY5lUywZ/fOujkwAAMjef7PZ57gjmub6GotI/CQQnGoP8X4pE+16jNWtClXSoS7LYrVSQ71DuFIDz+AhoxgsijYd9QnnbDYe9CnWF4+vZ/JyUlO9PazcU1mqn7K+o2bCcMqmlodEsmmDWuikuN1rPlyJjzPZ2x8PH6m6Tk5vOwa5vNl/8s96BkqXe13WAk8+MjzvPHu3SRdgRTRPiit8P0qYRhgWVWklHR3Lh8HZtPaZnZsTOP7lSifx3KiKVtm9f7jukihTxBWOXZytK6i2MsjRY7ly2xpCBFSRmFtFQCaQIPadh1vf+sbKFcqjI9PEoYhjY05stkMpVKZe+/7Ho88Wp8Q/XLAODBLQDKZ5Oc/8mGu272Gr337CY4cOUKlUqGjvZl3veNNPP7k3hXlwDQ0ZNm1Y2aNl9lOzKyaEwJuuO5qvvAf/1XXIcdDYyX+/TslHMdCCrCtaHhxvujHPYZoXo4XD1eRchSlVCTnao1jS0KlL3rq98XC83z2Pr+PTetuQgN+oHBdhzCoqX3RfFCrV3WRTCbrOhvymVBKTY1W01pz9PjKGoE0FwcP9VAqV3ETUTKVbVlkMvUtWz9fxify/NtXHubdb76eVCqJtCy0UgSeB+ipm21LY2q6AGGduXF3G5bw8DwZF9tzkJY9PR+ajpwwrUJC5eP7HkdPjNfV5kLV577eIpu2SsQph1BoKB97icceeYx1mzfS0JDF93183+e+Bx7m81/4Ki8dOFgfw5cJxoFZAnZs38p73/UmSpM9fPCdr0DIBOlMjkymkeMn+ti3/+V6m3hedHV20NbaDPhzCDCzr0KtNdu2bCCZTFBeBlMm1OLdUebR6SpKEKqoOMQMPH/5KRan8r2HHuOtr78RAEuCV61gC3/GXEiS5qZGGnMNy9KB0VpPOfFKKY4eXz55FRfK4NAovf0jNDU1AdFEoY25XH2NOg+eeOYgt9+0jfb2NrSTIPA9wsCPaiOFAq0LZNLL4xbi2BZXbE7j++W4WnBAaDlYMxyYqLhj/F4YUCxXOHqy/nlW3zo6wbs3NZA75VBaEq6vHOOTn/prNt15F75XRoU+tuPyn996lIcff6E+Bi8jVoaeucI5ebKX/oEoHm7bFqmkixPP+9I/MEyxtPxuKGcjl2vAdhzOHj6KRviMDAySsCXZTGapzLsseeqZ5zl4OBqqmEo5jI2PoUIfgQAR5cCk0yma49nQlyO1EXmVasDJ3pU7AqlGuVJh30vHpp5LKWPHf2VQKFbY93IvQlok3BS2HdWzsZ0EMh6BmMum4sKc9SWbcWhrUvheGd8r43klPK9EtVo84zIwlKd/qL4TmQIcGy/xvf7KVChLA1UFL1ck94pWwlVr2XPtDdz2imu5+sr13HD9Lsre8glh1xPjwCwBQ8MjfOozX4xmf51BsVTmP7/x3RUX6x8aGqZYKOJVq4R+GIVb4gnewjCkWvWYHJvg+MHD9J84CUKs2GTllUKhUOSTn/kKnhfQnEtzsvckYejHc9xEiyUtbKv+N5sz4flRGG90vMjI6Hh9jVkgnn3h4FQeTBTG66yzRfNHa82h42NIK4GbTJNIpkmmMiSSaVw3iW07ZDJpGrL175ykEmCLCp5fxvNLeF4Zr1qiWi3hxQ6LVy3E/yPn5sVDoxRK9U/GD5Xm3w6MMhFAT0nxpZ4K/2mvYvCq69j+qtu46uqd5ItVGhpbaGxpIVDQ378yC6AuNMtD/7sM+OKXv4EKK9x8/Q6am5o5fnKEe/7rezzx1PP1Nu286TnRy7996T954903MjrYy8T4IGGokMKKkhS1RFo26UyWjtWr+dq9jzI2Xn+p9lLnO/c9Bjrk3W+/i/0vnaAxHbJmdUf0mwhJqVKtW1XksyGE4KYbr8ayJPteOsQze/eza+cWnn1uP57n19u8i+Kll49Rrng4cR7Mpo3rlk3OyLlIp1O8/c2vJtQOmUQUiglDH7QmCDzCMKA51cT/+vn38Wd/++W6DqeWEoKggu9HISLL8pHSQUo5K3G6NhmlHwQ88szymYdu/1CB//5AL/35CgUv4ANrdvP6W+6kf6CPAIvB4TG2bmxDAMPD44yv0PphC41xYJaIatXjc1/4Fl/48r3Ytk01nihwJRKGIX/8Z3/DI99/jOv2bKOxwYkbNYWQNpZlU6n6DI8d5Jm9L/HM3n1GgVkCwjDkm/c+xv0PPUMYhNyzrosPfeCNbN+2mWSyzLfvf5yTvcsvt+SqK7bxe//7ZwiVolAc5ro9G7njtl/ky/fcz5/8xT/j+yvXiRkYHGFwZJxcYxS627p5Pel0alnmIZ3K5o1ruGHPBgZHJmhraUZaNmHgAxo78NFaMzBaYcPqHNfs3lZXB6ZYVuRLVWxbYakQK/SR0j6jA9PT77H3pfG62XsqSmsODE07JYeO9TNZcujs3kmhdJAjx/uwrCsQQtLTO0hlBU1yupgYB2aJCYLwtFDSSsTzPO5/8FHuf/DROUt2r1Tn7FKgNoPzoSMn+c3f/wcSCRcpBOVKdVk6kpZtcbJviFXdbTQ3RRPAeVWPHds20JDNMDo2Xm8TL5jGXI7JfHlqVvPVqzr5tV/+nzy79wW+9o1vk8/XPwfjTLS35rBEQGFimEp7K+lUFh2GgCZUivGJEoXJXtau3kGxVN8E/cmCz7HeCpmkH809FQ+hlkJGYVREPG2IIggUX/tenkJp+TrGLc1NfONb97FlQxc7tnax/0ARhIWQNsd7+k37GmMcGMNFYy6m5YtSalmM/jobTz/zIv/tZ3+HhoY0jh0peFWvSrFQprAClIozsWb1Kv7sj3+PpsYsQ6NVpKVw3SSvedXt3HzjtfT29fPgw48u2+un6vkIKehqz3H45f3YbppUJgtaMzkxil8ZY9OmjYxNVnnuhfoO5w1Dzf1PemxZa+PogDD0kHLGEGqYGkb9xD7FQ8+M19Xec/GfX/8WQghuvfkGPv57v0w2e5hS2UNaNr19y2cS2XpjkngNBkPdKZcrDA6OcrJ3kOM9vQwMjKxo56WttZU//NhvsLq7k1TSwbEqBJV+yoXjKL/Aqu42fvs3fpYd2zbV29Qz8vyLh3nosZdIpnNs3bqeNV05Mk4FGYzQnNVs3bqNUtXmL//+ywwN17+O1fMHyxw4Fg0YUMonCMr4fmlqKVdLPPp8lX+5ZxRvBYzi0Vrz8Pcf53f+4K9IJDMMDo1hWy7hMlRR64VRYAwGg2GB6exs5+ord+K6DuXSOJZ2sDQoHWDJKoGXJ5sSrO5uZd9Lh+pt7pxMTBb4vT/6NBvXr+LqKzezbctqOtqa8APoGxhj7wtP8tSzLzEyMl5vUwHwfcXXH6qycbVLKhHPyKY1Y3nB0T548oWAvQdKK6KuUw2tNf/1zXvZ+9yLfPxjv0ZjNsWOrWv52jcfqbdpywKxXOXL5YYQp9ZJNBgMhrnp7urkd3/151i3qhPLlpRLY4RBAWnB+OgkXjWkp3eIP/mHrzC2QkaUCCGwLAuto3IJyxEh4PW35Xj9LQIh4OG98I2HSozng2UbqpsvTU2NNOYyTEzkL7tRSDqa3Oo0jAMzT4wDYzAYzodt67q4fnMXzbkMlm2zYetGCvlJ+np6yVcC7nvmECcGx+pt5iWHJQWru5IkXcGhnvKynQLEMH+MA3ORGAfGYDCcLy25DFtXtdLemCaTzTA+UaB/dJKDfaMUy9V6m2cwrAiMA3ORGAfGYDBcKFJG1ZCV0is+lGEwLDVncmBMEq/BYDAsMkppTp3o1GAwXBxmGLXBYDAYDIYVhwkhGQyGFYUQ4p3A/wJu1AvcgAkh7gG+prX+q4XcrsFgWHiMA2MwGFYMIprY5hngV7TW/7kI278B+CKwRWttsmwNhmWMCSEZDIaVxDuAKvC1xdi41vpx4FngxxZj+waDYeEwCozBYFgRLLb6MuN7jApjMKwAjAJjMBhWCouqvtQwKozBsDIwCozBYFj2LJX6MuP7jApjMCxzjAJjMBhWAkuivtQwKozBsPwxCozBYFjWLLX6MuN7jQpjMCxjjAJjMBiWO0uqvtQwKozBsLwxCozBYFi21Et9mfH9RoUxGJYpRoExGAzLmbqoLzWMCmMwLF+MAmMwGJYl9VZfZthhVBiDYRliFBiDwbBcqav6UsOoMAbD8sQoMAaDYdmxXNSXGkaFMRiWH0aBMRgMy5Flob7UMCqMwbD8MAqMwWBYViw39aWGUWEMhuWFUWAMBsNyY1mpLzWMCmMwLC+MAmMwGJYNy1V9qWFUGINh+WAUGIPBsJxYlupLDaPCGAzLB6PAGAyGZcFyV19qGBXGYFgeGAXGYDAsF5a1+lLDqDAGw/LAKDAGg6HurBT1pYZRYQyG+mMUGIPBsBxYEepLDaPCGAz1xygwBoOhrqw09aWGUWEMhvpiFBiDwVBvVpT6UsOoMAZDfTEKjMFgqBsrVX2pYVQYg6F+GAXGYDDUkxWpvtQwKozBUD+MAmMwGOrCSldfahgVxmCoD0aBMRgM9WJFqy81jApjMNQHo8AYDIYl51JRX2oYFcZgWHqMAmMwGOrBJaG+1DAqjMGw9BgFxmAwLCmXmvpSw6gwBsPSYhQYg8Gw1FxS6ksNo8IYDEuLUWAMBsOScamqLzWMCmMwLB1GgTEYDEvJJam+1DAqjMGwdBgFxmAwLAmXuvpSw6gwBsPSYBQYg8GwVFzS6ksNo8IYDEuDUWAMBsOic7moLzWMCmMwLD5GgTEYDEvBZaG+1DAqjMGw+BgFxmAwLCqXm/pSw6gwBsPiYhQYg8Gw2FxW6ksNo8IYDIuLUWAMBsOicbmqLzWMCmMwLB5GgTEYDIvJZam+1DAqjMGweBgFxmAwLAqXu/pSw6gwBsPiYBQYg8GwWFzW6ksNo8IYDIuDUWAMBsOCY9SX2RgVxmBYeIwCYzAYFgOjvszAqDAGw8JjFBiDwbCgGPVlbowKYzAsLEaBMRgMC41RX+bAqDAGw8JiFBiDwbBgGPXl7BgVxmBYOIwCYzAYFhKjvpwFo8IYDAuHUWAMBsOCYNSX+WFUGINhYTAKjMFgWCiM+jIPjApjMCwMRoExGAwXjVFfzg+jwhgMF49RYAwGw0Jg1JfzwKgwBsPFYxQYg8FwURj15cIwKozBcHEYBcZgMFwsRn25AIwKYzBcHEaBMRgMF4xRXy4Oo8IYDBeOUWAMBsPFYNSXi8CoMAbDhWMUGIPBcEEY9WVhMCqMwXBhGAXGYDBcKEZ9WQCMCmMwXBhGgTEYDOeNUV8WFqPCGAznj1FgDAbDhWDUlwXEqDAGw/ljFBiDwXBeGPVlcTAqjMFwfhgFxmAwnC9GfVkEjApjMJwfRoExGAzzxqgvi4tRYQyG+WMUGIPBcD4Y9WURMSqMwTB/jAJjMBjmxQz15Ve11vfU2ZxLFqPCGAzzwygwBoNhvtTUFxM6WkSMCmMwzA+jwBgMhnNicl+WFqPCGAznxigwBoNhPpjclyXEqDAGw7kxCozBYDgrRn2pD0aFMRjOjlFgDAbDuTDqSx0wKozBcHaMAmMwGM6IUV/qi1FhDIYzYxQYg8FwNoz6UkeMCmMwnBmjwBgMhjkx6svywKgwBsPcGAXGYDCcCaO+LAOMCmMwzI1RYAwGw2kY9WV5YVQYg+F0jAJjMBjmwqgvywijwhgMp2MUGIPBMAujvixPjApjMMzGKDAGg+FUjPqyDDEqjMEwG6PAGAyGKYz6srwxKozBMI1RYAwGw0yM+rKMMSqMwTCNUWAMBgNg1JeVglFhDIYIo8AYDIYaRn1ZARgVxmCIMAqMwWAw6ssKw6gwBoNRYAwGQ4RRX1YQRoUxGIwCYzBc9hj1ZWViVBjD5Y5RYAwGg1FfViBGhTFc7hgFxmC4jDHqy8rGqDCGyxmjwBgMlzdGfVnBGBXGcDljFBiD4TLFqC+XBkaFMVyuGAXGYLh8MerLJYBRYQyXK0aBMRguQ4z6cmlhVBjD5YhRYAyGyxOjvlxCGBXGcDliFBiD4TLDqC+XJkaFMVxuGAXGYLj8MOrLJYhRYQyXG0aBMRguI4z6cmljVBjD5YRRYAyGywujvlzCGBXGcDlhFBiD4TLBqC+XB0aFMVwuGAXGYLh8MOrLZYBRYQyXC0aBMRguA4z6cnlhVBjD5YBRYAyGywOjvlxGGBXGcDlgFBiD4RLHqC+XJ0aFMVzqGAXGYLj0MerLZYhRYQyXOkaBMRguYYz6cnljVBjDpYxRYAyGSxujvlzGGBXGcCljFBiD4RIlVl+eBf6XUV8uX2aoMFu11pV622MwLBRGgTEYLl1+AKhg1JfLGqPCGC5VjAJjMFyCGPXFMJNYhfkSUS6MUWEMlwRGgTEYLk2M+mKYIlZhnsGoMIZLCKPAGAyXGEZ9McyFUWEMlxpGgTEYLj2M+mI4DaPCGC41jAJjMFxCGPXFcDaMCmO4lDAKjMFwaWHUF8MZMSqM4VLCKDAGwyWCUV8M88GoMIZLBaPAGAyXDkZ9MZwTo8IYLhWMAmMwXAIY9cVwPhgVxnApYBQYg+HSwKgvhnljVBjDpYBRYAyGFY5RXwwXglFhDCsdo8AYDCsfo74YzpsLUWGEEH8thPiNea77T0KI371A8wyGc2IcGINhBROrL78J/JY2cqrh/Pko8CtCiCSAEOKoEKIshCgIIfpjJyRbW1lr/VNa699ZiC8WQmghxJbzWP9DQogwtq0ghDgshPjphbBloRFCvE4I8YAQIi+EGBJC3C+EeGu97ZqJEOJ/xr/xpBDiE0KIRL1tOl+MA2MAQAjxDiFET9wwXFNvewzzxqgvhgvmDCrMW7TWWWAPcA3wK0tv2Rl5RGudje17J/CHZ2qvhBD20po29b3vAv4N+BSwBugE/jfwlnrYMxdCiNcB/wt4FbAe2ETkzK4ojANziRH3oF59AR/9I+C/xw3DWNw7mncDIIT4LSGEP6N3tE8I8c4LsGPREUJ8QAjxRGxnnxDi60KI2+ptVw0hxF1CiO8KISaEEEfPsp5RXwwLwSwVpobWuh/4BpEjA5weFhJC/FJ8DfUKIX58DlWlWQjxn7ES8agQYnP8uQfi95+Nr8P3nq/RWuungX3AznibG+Lv/zEhxHHgXiGEFEL8uhDimBBiUAjxKSFEY7z+J4UQvxg/Xh1/9iPx881CiNH483cKIU4IIX4x3kafEOLDc9kkhBDAHwO/o7X+e631hNZaaa3v11r/xIxt3yuEGBFCDAsh/kUI0TRjG0eFEL8ihHhRCDEmhPjHU3+bBeBHgH/QWr+gtR4Dfgf40AJ/x6JjHBhDjfXACxe5jc/N6B39PPDPQojOuVasY+/oF4A/AT5G1DNaB/wV8LZ62HMGisAngP/3HOsZ9cVw0ZwpF0YIsQZ4A3Bwrs8JIV4P/ALwamALcOccq72PyEFqjrfze/F3vjJ+/+q4zfhcvM3x+XYmRJSEvA144pS37iByal5HdFP+EHAXkcqQBf4iXu/+GTbfARwGXjnj+fe01ip+3gU0AquJjtNfCiGa5zBrO7AW+PezmQ78PrAqtnMt8FunrPPB2P7N8T7++pwbEuK2+JidaTnTsbyCKPG/xrNApxCi9Sx2Lz+01ma5hBbgKPDqOV6XRJLhIWAE+DzQAiSAAqCJbpyHgOPx80K83DKP7/0t4J9PeW0QuDV+fCdwAvhloB/4dPzdfwL0xsufAIl4/fuBd8aPXxHb86b4+auAZ+LHHwIeJFKQxoAjwBvOYGNjvD/vPst+3Ag8AowDfUSNnTvjfQ38HFFjNwx8HJCL9Fu+Gjh6hvck8FztmJjFLBezADfE1+ex+BrJx+f6d4CmGev9E/C78eNPAL8/470t8We2zFj372e8/0Zg/4znU+vO08YPAUF8bdbs+3OmR9NuiF/bNOMz3wF+Zsbz7YAP2ETOwVh8Lf018N+AE/F6nwR+IX58J1AG7BnbGQRunsPGWluVPI/9ejvw9IznR4GfOuW4HVrg3/sQ8PoZz53Y7g31PhfPZzEKzOXDzxJdKHcQef5jwF9qras6Ukwg6g1tZroX0qSj3tEjQoh1sUe/7lxfJCLeBLjAizPe6iJymtYDPwn8GnAzkUR9NZHzUOtpnKt3dP+M7d4EvAS0AX8I/EMs5Z7KLUCSaOjomQiB/xlv6xYiZ+lnTlnnHcD1wLVEys2PzrWhOFR1tt7ROY/lWTDqi2HB0NMqTBZ4u9a6gej620F0LczFKqBnxvOeOdbpn/G4FG//Yvi+1roptq+LSEn42CnrzLRjFZFTVuMYkfPSqbU+RNRp2wPcDtwD9AohtnN6GzOitQ7msS8j8f/uM+2AEKJTCPGvQoiTQohJ4J85/RjP3Idj8X4sJAUgN+N57XF+gb9nUTEOzOXDTwG/prU+obWuEikm75pvKEdrfTxuOI6fZbX3CCHGiS6OrwAf01qPz3hfAb8ZO01lIpn0t7XWg1rrISKp+Yfide8nakQgclx+f8bzUxuXY1rrv9Nah0Q9p26i8NCptALDpzREp+7nk1rr72utA631UeBvZnxvjT/QWo/Gx+JPgPefYVufiY/ZmZazHcszYnJfDIvER4lUSgdAa30/kYryR2dYv48oSbXG2sU07lS01gPAFzg9OXbmNdFL1GGqsY5IxRmIn98PvItIZT0ZP/8RopDXMxdg1ktEzsfZ8v8+Ftt4ldY6B/wgUVhpJjOP5bp4P05DCHH7jLzDuZbbz2DDC0SdxhpXAwNa65EzrL8sMQ7M5cN64Eu13j9R8lvI3Df6C+Xz8Y05QyTP/rAQ4r/NeH9Izy6YNVfvqNbTeATYFufQ7CHK6F8rhGgjUmoemPG5qV6e1roUPzxT76jtbE6bEGKbEOIeEQ8vJGpslrp3dC6M+mJYcGIVxiPKe6nxJ8BrhBBXz/GRzwMfFkLsFEKkgXnVh5nBAFFeygUR52u8g7Pn7n0W+J9CiI0iGg7+MaJcvVon5n7gvzPdntwXP38w7hCdF3GH4heA3xBCfFgIkYsTgW8TQvxtvFoDUSdvQgixmrlz3T4ihFgjhGghUqo/d4bv+16skp9p+d4ZTP0U8GNCiF1xAvGvEzmrKwrjwFw+9BDlhsxUAJJxr+NULrpXH6sXX2d27+jU7c7VO+qNP18CngT+B/C81toDHiZqHA5prYcvwKxHgCpRKO1M/F9gP7A17h39KhfeO/rgOXpH5x1CMuqLYZEZB95fG/USK6OfIhoGPAut9deBPwO+S5Sg+/34reo8v+u3gE/Gnar3AJxDNQC4pXb9EHXChojC42fiE0T5dg8Q5cdVTln/fiKHoubAPAikmd1BOi+01v8OvJcotNxL5Kj9LvDleJWPEoWfJ4D/BL44x2Y+A3yTKHR+KP78gqG1/i+icPt3iXIejxG1KyuLeifhmGVhF6IEsDcQ5XrUFpsor+M+YH28Xjvwthmfm5l8lyZSZ7adx/f+FjOSeImk5eeIwi0QJ/Ge8pnfJXJK2olUjgeJEwTj9z8GTAK/ET//SPz8L2es8yGi3hJz7cscdv4iUYPy9ng/nfh4/WH8/mNEjbUgiv+/NHP7TCc2NhM5MvuBn1yg324nUaNX+93eQNSwJIkTiYnk7seJExfNYpaFXohyQT5ylvdtorDpDae8vjNuN+zFtO9SXzjDQAyznL4YBebS5GtEWfO15beAPyXKS/mmECJP1Fu6aa4P60j9+D3gobh3dHOcxHsu1eC9M3pHjwMPcfbiSL9LNARyL5Gz8xSzexqn9o5OfX7eaK3/D5GK8+tEvbceIsn4P+JV/h/gA0TJbH/H3NLtl4nUoWeIelD/cKH2nMJrgL8lcrDKRL/juvjxN436Ylgi5qwLI4SwhRA/SHSD/TTwThEVwEzEQ4r/APiqPkuOmcGwkJjJHA2G80AIoYnCS3PWxrjIbf8ckaybIBodUSHKK/iE1roqogqfvwzcaBwYw2IihLgH+LrW+i/jnLH3Af8fUZJvLb/sD4jy024hUl7uJxqy3Lf0Fl86iKh45Y9rrb9db1uWO3UpJmYwGM5JJl4+DvyOEOJ/Ew3n/mXjvBiWgI8SJf2XiKq0znRcptBav36pDbvU0VpvqLcNKwXjwBgMy5uaI/N/iK7XdUKIhI6GwhsMC06suGwnKjvwf4kUQYNh2WFCSAbDMuGUENKZOC20tBS2GS4N4hCowXBBaK3nKhBaN0wSr8GwssgQ9Yw/DpwUQvy0EML0kA0GwywsKZm7IPmlw1kVmPl465YUZFIWjVmL1kabXFqTy7o4tsK1FLblYFkOQibRIkGgbErlgFJVM1kMGJ0oMZEvky9VqVR9lDIdBMPZcV2bV96yidtvWUtbcwrbkgSBpnegyHceOMwTzxwnCNW5N1RHbNsinXRJuJJEwiUMQzw/pOqFVKo+QXDeNbTqghSCbCZBR2uG9pYsrU0pMukEDZk0vh8yNFbk4LERjp4cxvOW1+CUztYEr3tFik2rNQLoHRF87ymf/YdLC9IOLbfeKiyOAmPbFlJIwjBgy/pVpJIuL7x8HBUqEFC7xQgp0BqUWt7X5konm0zwqm1buH79eiYqHl96di+HBwcvvrgXy++cviAHRgBtzQ67Nye4YqNFdytkkmBbGiFAChvbSeI6KVw3jeukcd00CTf677ppLDuBEBZBqClVfEYnK/T0T7LvyBBP7+tl/5FB8sXKXF9vWGQEIC2BlBIVKsJl5FTatsXb3ngFt9+8ioRjYVsWlpTYUiItgQrh6989zL99de+ycwISrsX2jS3ceu0art65hjXdrWSSNo5joZTC9zXFis/wWIljJ8fZd2iI5w/0c/TEKOWKV2/zZyEEbF3fwpvvWM+eHa10tDSQSadw3SSOk0AKCQi01pSqAc/sH+JvP/84e/f3sByi1u0tCX7q3WlWtYVMN3OCiif48n2K+x7PX7Sdy62xh4t3YFzbpiWZoN11aHUdGlMJ9ly7k662ZnqfeIE9G7oJHMFL+3vwlKLQlEFNlhFlj1RnM1UBzx3t40SpzEjVZ7xUxl9m1+lKpj2b4bdfdwdv3LmLVLIRabm8MDjIRz7/OZ4/eeKit7/czunzdmAcW3L39RnuvkaSS+tZFz9CYluJ2GGZ4bwkpp0Y101hWU5t+6dsXaM1eH7I0d4xvvrAfr5y30tMFkyYfylIJiyu3JJi12ab9iZFImFTroScHIRnX/I4dKJKENS393TDtet479t3kExEzottWdhSYlvRYkkLpeDvPvsM335gf11trSEE7NrcyHtev4Y9O7tobmohnW7GttyzSrxaa8rVkCMnxvnWw4f5r/v30zc4sYSWn5lb9nTzkfdupr05g+NGnRXHSeI4SaS0TtsvrWFkosJH/+o+HnhswUegnxdSCn7oLY3cfKXi9MOvKZQt/uwzFY73XVwHark19nB+Dkwul6WtuZFr9+zAHRmlLZfiOgU78hWymQSqNUd+dQtNE0UmqNLjh6S0zYZqQNdoicHGFM+tbWFnNSQ1USIzUWKsqwm/7GEPTXCstYEXXZu+QFNxU0zmS7yw/wiHj55gMl9czMNwGo5lkXJdUq5LwrJIui4Jx0aqEEcIUqkEAo3neZQqZQLA15pSpUolUJSDkGoQ1rWzl7AtfunOm/jx6/bgplqw3SxCRGGkr7z4Aj/zr5+h7F1cR2i5ndPnPQrp7uszvPVWgSUVUV892h8hbGwnheskY8clheOkpv47TiIKJYnptJua8xRV1QtRKiQIPHy/QltDhQ+8poOtq+Hjn95HoeQvyA5fikgpSCUkqZSD54WUKuF5OxodLS4feGOaretU/NtqojnPNNvXC27b4/LcoQT/cW+JodH6qAHptMsdr1iHbUfnXfQXOcJSCCxpkXQTWNLiXW+4gsefOc7EZOlcm11UpBTcfVMj735tK23NKRKuhRBWrFCcHSEE6aTNFVva2LW5lfe+4Qo+9R/P8qVv7qVcqd/1sK47x4ffuobmBhshRHRNCzG9zIEQ0NaU5Fd/8pWcHJjk0LHBJbZ6mq62BFdvJe58nWqvIJNS3HJ1kp7+yrJQi5Yay5J0tjbx337oLVxz1Va2DI6Q2XeQsi1o7RnBdmz6r9hI/tqdpA4do5DLMJaQiMDHDgSqb5QgXyFszdLYmGJSupR3bGKgv4/y2Ahi7SrS6ztotiR71nRyneuSbW2jWixRKN/Mc0cG+L9//0VG84VFcWQE4Ng2zdksu7pXsbOzi63t7axpbqI900DOdcm4DrZUiKAKQQXwCYMqgV/G90p4YZWKXyFfLjJeqTBQLHMsX+HlsSr7RsucnChTDcIlPX92r2rnbdtOmU9TazRw56bN3LhhI/cfeGnpDFoCzsuBkRJ2rhNYsvarxA2AkNh2AsdOYNsuluUgpT3lrGilCEIfrTVh6E2/rhVKhYShTxD6BIFHEFTx/QpBUMHzK6xrr7BxlctzBxe/wRYiSnySkqhHb0usuE2WQk81zgKBBjQyiulqCEOF74coDUpplFLoWFFaLKQUbN+Y4rY9Luu6IZ0U+IFmcBSeeDHk0b0lqt655dlkwuKDb0qzbd3MHqmY9d91FNduF3Q0p/m7L8LgyNI7MVs3tdHelpy2Ssy8bwosKXEtB9d2WdsNV+1cxYOP1re3f9NVad5+p0U6SXyzF1PqxPkk2Akh6G7P8Is/ejNXbO3gD/7mPiYL5cUy+4zksgk+9NbVtDfK6ZLeSqFV7VoOELHCWrN7Jl2tKX7m/Tfzq3/8dapefZywnZtcUolaB+x0BJrNawSObeH5l1d4Y+vGNbz+1iu5uTXLdeUipdEx+l46xJ4jA2QFCA1j12zFyiRZff9TDHc1kck24IyMUsmlaQ1Cmk+MYheqdB4exA8CsnYC1dBCetRD9JXJqzEmt62l88XjhFYKpUL8h5+luKELS2pesWsjW37xfYyHgk9/9UG+9/BThAuU09bWkOX2LZt4485d3Lh+Ex3ZBhxpzb2yVijbJvAlKigTaoXUIRYKJ4CkUOSskK4EbM3CrW02akOGkoIDEwH39xZ4oGeS3onyguSfnA0h4I1bumm0QesAFVbRKgHSRWhN1rF53Y6tPHTwZYJLKAfpvBwYpeAbj/mMFx1acxZJNySVsHAcm6QjSKroZq60IlQBjoIgDLECDynkDPVFo7UiVCEq9AmVTxDEHm7g4YdVwsAjCH1ODGlODC5sCEkISDiSpgabtiabzhabtkablpxNU4NLOilJJ22SrotjW9h2FKqQ0saSNtKykMIG4YCwAYtQgedrfGVR9RT5okexqhkZKzA6WaV/eJLh8RIj4yUmC2XKFZ/wIk4kKQR339TAW14pSDg1xUQAmqYsbFkj2Li6gc9+bRLPn/4eyxIkXBulNJ4XorRm1+YkW9aqM/RIp44aQsCaDsV7Xpvm774QUPWW7kIQQnDFzg6krDmPOupdRP/QaJSOllBHjtgV2zrq6sC0NTm85Q4Hx46NZMb/eB/EGY/33NiW5I2v3IwfKD72V9/B85cuMdZxLN73uk52rrdQKiAM/SmJOiJyZpQdRNfJVCgpOi81UWfm5t1t3HnTJr7xvaXvDQoh2LRaIkTI2c71XFaTTAjq5GMtOVIKbt21kR989W52trSw7qVeEvkSueFJ1pQ9hte00L+pi67D/ThDIzBhowPofPEYickyk7s2Um1waHzhMFYp6tw4XsjGg0MIpagUPWS5ijtWIlUJcbq7kMkkuQeeRrs2hS1r2HBkiMrmNTR88zHEjtVkkha/+uG38Olsksde7uGlg8fOsRdnJuU6vGbbRn7ihj3s7Ogkk8xgWS6CqfmHps9jPX19TqdYRD0lMWuRgIxfj3K+pNBkLbiuxebq5iZ+YGMDXzhc4OuHRphYRNW0JZ3kxo40YVhFBhWkdEFILCsR3fCUz42r2kgnXCbLl05u6XmHkPYdLbPvaBnLklhC4zgWloxCSq7r4Do2lhRkM0l279oEeCSTLkppHEsQhCECjRRw7PhJqtUqmrgHpxVaqynZq+IJjvRWmChcfCMtBDQ1OGxb67Jzvc26TkFzAyRdC9u2saSDtGwsaWFJe0pFkpYTP7cjB8aqOTGnvy5lbYkabhF/cXST1QSholQNGJ+scmJwkoM9Y7x4aJD9RwcZGJ6keh6jNHZvT/Pm2wUJZ8YFNuO/lJobdmmeeznFM/tLrOlMcM0Oly3rBLmsTRhqBkcVj78QsGODgyUDztygzzyOmp0bFHfd1EixFJAvKgZGAobHfXx/8RyaRMJm9arsjIm8mHJktNYopQlVSNWvEqiQMAzp7sxgWXLBem/ny41XJWluiHr6kY3ROV77L8/mL54FKQVvumMLDz15jG89uHR5PrftaeSmnRIVVglmtPXRvoUoFWBZHtKPrgdxWqeltl7ID75pAy+83MeJ/sklsx/AtgTtzec+6JYIEVwe6ouUkruu2sJHd28muWYtiVSG4OocxWyKhidfRE4WOLltM7YX0Dicp39DO/nWHOufO0oxk8DVisa9B6MRR7VhR0JM9am0FCSPD1BNOoS2hV2u0n7vE4SWxEs6SK2xegfxN64hfXKYzNE+ujpbaQ19HDXGL7zqOp5+9U388u9/gqHhsfPev5Rj81M37uLH9mwn7SYRqoJf1YS2h5QJpOUgpiIGsbOtFVr5qNCLFuWjVIBSYfRebSFuW06RWDRgCVifsfj5qxrZ1ZLgT5/sY6S0OMr1tpY0rW5IEJQR0gYESgeE0on2SQV0JzVrmhp48XJ2YGqEoSIEvGDmTXf6gt+wvpmP/OzPQVigWi0ShgHo6CYjhESR4sd/9mOc7B2+CPPnR1ery53XJNmzRZLLqKlwkJTODMfFPsUhqb3uzHptap1ZDkxtnWkpcqZ0XgtxuNLCdSyasgk2rMpx2541KKUplH2O9E7w0DPH+c6jhzh6YuSs6kxLo8M77nZIumfvRVpSc/X2JDs3OVy/U5N0NUIowAc0q9rgys0WJ4ddqr4m4ZxtezO2a8HNV9k0ZTWuI6h6NicGU9z3hM+z+0sE4cILpo25JLlsFJqYvmlqlGRaeQkVVe0h4nBlJu3gODZhuPThLseWXLnFQoiowVM6iBvASLlQKgDLveDtu47kB163i/u+//KSjOLoakvw+psEWlfwfRUdf62wVRCpqIGDb1WnFEohLISUs84mpVQcNg5oTof87Pu38mefOcDJgfyi21/DtsVZw0c1NNPK0aVOV1MDv7J7M1u8kKGmZjLH+sg9/iLFnRupru4g3TPI1qcPk8qXCdqaWHNoAH2wH8sPSYVAwoViFaE1oSOxgviYSchvW0u6ZxC7WCFwbaT2seJbhlSaRNlDaHAqAT69VDpbCV0bt2+IhFIoS9CSL3PD1rX83A+/lT/+xJcYG5+/0ysEvHXnGn5weysyKOBpH2l5hFYFGbhxh9NByOicnf7NNVqFKB2g43NchT5hWEWFHmHooZSHjq9lpUNg7jZbAq9blUTpbv6/R09QWeCwpBCwtcnFUhVCz4r2QIeo0IscM0DpECv02NKc5cW+oQX9/nqyaFMJlEollJakUxmkjLxBHYYEQRQOqgZi0Ye5SgE3X5Xlra+waEzrKdlYCAspnVlOSNTwzlRi5nJc4tfmUGFqPc3zLRwkpSCXcbl6azu7t7TxwTdexb2PHeUTX3qCnv65exs37U7R0XyuRlhTKDus65J0tfgzwkOzlRrbUnS3VBmeTNDdUj5TDuZp286kNH7okHSrpBKKrWthQ7fNd7pyfPW+ScIFdmIacykcp5Y7peNQZaxqCBFn/0c3VqGiMJO0JJasT63GdMqitan2TBOGAaEKCAM/yvkKPBw7CVxYsSmtNVvWNdKUSzE0WlhAy09HCMFd16XIpX2CIHbCVIAd+oSWE6kuU6FVK74ZyFiFFLXg0ZQKpWO1Zl17wP94Xxd/9jnFif6lGXUipURKCWdVVzTlqo0XSM50U7qUqFQ9HhwsE2zZiH1oBGllCHZfi+U6OFWP0fWbyBQKVLSD7SmSSIQK0VKiKz5agLCjzpvWmtCqXXMCq3+UwA9Rto1T8lFAxXFACGoDdpTQlFxN02iezMgkAkicHESnkohQIcIQ3dfP+6/YztHXvYJ/+rdvzDv8nnYc3rI+gxUU8HU1VlxchKzVJ7MRwp51zsY7Eiu98fmq/UiFCX107LyENXUm9NDq7Oq5EPDqVUkeWNPIvUdGz/9HOguOlGxudCGsRsMutIqcLauCqHWqtUIpn7VZ65JyyxfPgSmXKZY8mnJNSMtBqxDfKxGqAK1Cqp5Ptbq4PeOrtqR5711WnCMS37yFhTjFeZkO/djTeS5ydkiotgg53UhLIadyexaq4mEu7fD2O7dy9dZ2/teffosDx2Z7y1II1nU5COEx24GZDiVpDcWKxbF+m50bqufMbXFshVIiVn7nF9fQWpyW8OvYirtvkBzvy/DUiwt7U02nbabblqj3r7SIVBhRa8wEWkw7adXqxeUZXQyOLXAspmyJVAqPIIyT1P0KgZPAsVOR03Ue54/WGo3GddSSODCNWZvdW2rnBijlxUpS3BGQUX6YFBZS1q6HUx3HGQ5MPOJQqZDmTMCd1yb4l68Vl6RRrVYDjvVrchkxVbdqdnMenT8nB/W8EuAvBUaLZf7wwce5ORDccsuNrF+3hmQyGY3WcWxs24YgwAp8wsk8FApQKaPKFaTroAQk3FrnblqFtmRUpDFqWMD3A8pVn4qKs78cGylryeA+brGKEwYwMUFYLdNcKJErFmnwiySKPul9R3iPY3NPKsFAcX4J7Gkb2m0P39Nx++1EiotlE0gHOeW8WDDVjtfCSICOzletw0iJUUEUWlL+lPqi9fzOE1fCXWsbeKhnguoCdt4dKVidcUArwqASOVyhh7AcpKg5lgqtA7qSGseSeMu80Od8WTQHplKpMjZeYNOGNdhhAh2HjjyvRKhCwlDj+YuX1CSE4OYr3BnOC0RJVrEzIuRUYyuFjOTu+CTWSDSCUAlUPOIoVJHkKZXGkgoZKqQMcWyJTYglrbgxFPNUMaaHkcfPZuUIrGpz+OCbruCjf33/rKqgSmteOOSxe6tEyugiC0JBuWpTLGn80KZSVZzoDyhUAq7YeG6HRAhN31CVvQcEt+62yWUCpJx2iE6xmlAJRiYs1nac2ogIXFtz1w02z78sZyUPXyyp5HS1fA1TjkutGbCInCoppo//ZKGCv4RJrjOpeoqqD+lkdPxD5eMHFXy/gm1XqHplLNtFikjZm29Cb+2cCYIqlUpxSUby5DIWmWSt5AH4oaRaFQTKRmuo+FUSCTXl5KN8HEtj2w7RrxUiRYCUAilCBHGuGyoarB+KJesRBqHmU1/Js7rDpbvdYl23w7b1CSw7ydGTBSYmSxQrDs++VL6sqoKXikW+e+99PPi9h2hubqKzo4NUKkWpXKa9rQ3HjcK3iUSCfD5PPl+gUqngeR43XrOF17xyN8VigSBUWE4STeT4NKZdhLTw/ICRYoknnzsMwqKpuYnW5mYaGjJks2ksy0I2y6n8R0tKxqRAKg3lEvbYGMm+Xty+XroasvN2YEoh3DdQZWtO0ZayaHQCklYVR0qEtFBIiNt9auUA4itxeqBALeclhNj5jh7Pr32bcokEtGWSJB1rYR0YS9CSkFNDA6IOho8I4n2KX0crWhIa1zYOzDkJw5D+wWEsO4lludGoo9BHCosQ8AO9qA2E1pqxvMIPBX0jmopvoXEIgih/x7IkSoHvV6lWC9hOGrQkDDWVShmtwHaS0VkHUVlsAAFV7bLjip1IEY3qyeeLTIwMkUm52JZEKZ9UMkEylcKxLSwJUoRkMxlc18G2BLZUJJMJHDtKgHZsgS01UiokCqVDql5lTq3vseeKVL006aSgWNa4rsUtuzxc28e2NE0JiW5Ncd+zPuWqRSqhztDTjG5IoZKcGFQ891KZjZ1J+m2XbFqQy4QkXYVl6TiOCuN5ycs9SVqbNjJRHKQxM4xtzQ5nre3UdLS6nOhfuGSxU2/USus4bBSFjiBKFlRi2g3oHyrWLYG3WA559DnFrVdbZFIKKTVBUMH3y1iWG4UtrUi2TriZaSfmHIXtQOMHHtVqkZP944yMLX7oZSwf0jNoYwub8TFBOQ+hp5BxaMhqsrjqyio19c/3A6raxgsUvh8QhIqeXhtdsLFsQSoN7e0B2UzI4V7Btx5dXAXpVCrVkEM9ZQ71wC172njb3atROsmXvvMyQSDJJCus6bRJpySDIwH5YnBKZ+PSROuoUNvAwCADA3PX6RFCnHYsQq/Ia2/fQUPSo1zOI5UVKdzaJiyNY9sOKdth4ORRvvQf9xCGCsdxSCQSpFIpspkMTbEz097RTsJNYDs2gR9QKhbxfJ+JyTzDw8OMDgwyODI+730qVn3++LGTpBxJxrZoTDm0p1060xbdGZeOtEOTI2hK2mRsSdISJCyJI6PcFUtE6oWYMXpQirm1b4haIq0h0FANNaVQM1LVHM17vDjm8fRAgfwCj0ZKuw4N7lyKZ+RwzaTBBndhggXLgkVzYLTW9JzoQ1oWWksEOqrAGye0Tk4WCILF7R1/7ZESo5NpAmWhkdiWxhKShBPFC4WQ2JaN8jVhMInrRNUWA99DhwrXCaMbf63WRRjZW5I52tuaSSddpGXTPzTBC088RdYOsKzpQ6rFtJOglAJpTY1KCsIQaTkgLfwgRFgWwraxEgk629JsX5fm0/e8iJqj4fR8xePPTzf6mZTFDdsccmmBY6VxnSzpZJrh0V7+f/9SYdMal1Vtgs3rstiWRGuB53mcHNIcOFZkdEJzvK/Krbvb2NiVJVIMbKpVm96xkHufGqTqeRTLIcNjAa+/WdCxtoq0rmI0309D6mWSrj+lfCQczdouixP9C/dbnjg5Sf9ghY62JFJGKst0eCjOeYnDWiK+kb58eGFjzeeDUpqvfDfP/U/arGq36Wqz6WjxaW8u0N5q0ZxTNDdCNhOSzQQkkxlcx8WyZFSgb45GRqkQP6jgeWVK5TzffqSHYnnxFZh80eev/n2SloxDLuXgWtGoBrRGoLmyOUvKnXEtJyBKFK/Zpgl8mwO90RxPJR8eek4zWPQZGCkt6ui1UxFCkExYSBHiB5Lmphba2jay96WTvPe1imxKIuO5MUNlM1lM8MIh+M6jZfqHTUXwuRy5k33D7H/5BDu3tE3lPUkhpvKNLMtC2kkeeeogxWJUWLJSqZDPn568PbV+HFqKcq4u7vyoxlVyx/E5ma/gWBbZZJL2nCTnCnKpBA1JiQ59tA7xAh8V+Fg6ZMOaTq7Z1kXKcUkn0pSLRV7efxDfn05/0JZLoDUThRIFX1FSkpFSlYlqyFglZLTiU/KC6UmhFpik1CTm6ZRkXRvHtoiKlK58Fs2BAeg5cXIqvh/9rw1TEwyPThKGixtjLpQCvv345NTcPpaMYrWOBY4jSCZcbAtcW5NKJrEsH0tqHFuSSKapWjaWJZCE2FYUbnJsie2nSbjOlOfd3NhAsr2D9mZQ2p4qeOeHAq0FgdJ4vp4aXWhb0RjgKGwQbaXq+ZTKZQqlKoeeHeWzX58gX5xfg1ksh/QM5ljXkcV1Mrh2GstKsH1dhe88foyevgo7NjRw/dYMtuVEE2w2OLx4aIzvPxv1tKSUXLt9HR3NzdT6F0IInnhphCdfeGlKydi0ppHbd2+jo7kTpR16x1ZRrDTg+S+QyxQQIvq9u9oW9tQaHJrkb/7xCdasaqS7q4GW5iTdXS00ZBJIERIEQZzzIiiVfQYGizzz/MkFteF8UVozNuEzNuHzQlyORogJLGsIx5Lcdsv13HjVWrRWVL1xfK9MOpUiUIr9Bw9iS7At4lChjgvFhVS8kPHJCs/uW7pqtsWyP6ezJATsvi6BbSemRuEppQjD6tSQdyFAWB7feqlKseQRKj2nY76YOLbF1g0pbrzSYUM3OHbAWN4Gp53+EQXBARozs/PKbEvTklPctkewc2OKT3xZcrhn6YsHLncqVY8nn+vhlpuuIvBy2I6L46awLRfHTZLKNDI0WubAwXPPxaOUWrTJHtOJBLdv287bdu/m2lWraUs6ONqDsIIKKvheiYpfYrJcYKCQ5/DYJH25Fjpuu5GGxjayje0cOtrHX3/xcUZHx2dtW1OrKL/0CbK5dAJ7nmMVEpbANgrM/Dhxoo8wDKMksBkNgxCC/oGhJZNlNRCGmjAEz5+ZODzTQTi3jC3i/Iq7b70GS8qpvIWWlkYCu5G//49HTvveuDjCVHwyfuV0G+NRNRfK4V7Ba65vx3US2FYC23K4fc9aHnr2JBUvoLu9je7WTXHuTxS6aMpM35AyKZctazpJJ1NTrykNT+w/MOW8JFybd921k+621djSBQGbOmxOjklCbmE0/zxN2X4sqWhvduaUmy+GUqnKgYODHDgY3bh/5ic+wC03XEGoFI88vp+/+sS/xkmic/cUlwNaQxAogkDR1NTKjddez/jIKCoIEVJg2YLhyRJ/9o/34K2AKmqOY3PTtTdx1a7uaFQHkVJULk8wOtbDyOhRfL9MMmHjh2X8OoT0GjIu73xNlmt3hLhWGJWTBVpyARUdMjB0gpTjM/eVGV3zrY2Kt9yR4C//tf7zgS1HnnruIGXfpr21HSkdHCeBHc+N5bhpju89ytBwfRTRhlSK6zZs5MduvoXbNmwkadtUVUg58Bj3Q4qBT7FcwCNEWZIgmUQ5FmtyaRqbWuMwjI47nzaaqFO6XEhaFlLMb2yRo2uh30uDRXVgBgaHKFeqNGTjr6kdZCE5uQLHotc87Cuu3EZzWxMqDMk25mhsbuG2W67h69/+/hy9h6U5WXoGKgQqTc5NTY2i2rkuzY1XruOBpw7T0pAmnWycKq4nELQ25qacjLamLK0NmVlz9JSqPgeORXV6bEvytjt2cfOutdjSjkKBRDliq5ptXugp0NZ4LUOTR4BDjE4Ei77vjY0NtDQ3oLVm25b1rF7VTHdnhpaWDFIISsUqQyMl+gYmGRsv1S0f5kyUymXS2SzlQpHQDnETEmmFNFlZXMddEQ6MQNCQbSGZyM563XXT5HJddHVu58TJvYwXTlCPIclCCN70yjQ3XRGcUkogOjdDpQhDj6RTW3/u5HUhNN1tkkzKZiK/vGYGXw4MD4/w3IuHeNXtu4D46OrpmnZDI6OLnjJwKumEy+2bN/H+665lz9oNlAl4rnCCscoEyg7wVRVNgGWBTEAQBFFGnaUIUYRSIzJJVBjEo5EUWVdy09omvjY6tmySvG2h5l0P07YkrmMDl8Y5vKgOzNj4BJOTeRqymfiVqPHQWtC3Ah0YANu22bFjEx2r2tBaRSNJLMmVV2ymtaXxgipFLgTj+Qq9wyGdzcmpUVZCSH7gzu08+3I/7c2NWNJiZvOcTiWmHJhV7Q24zuzh4FpBqKKQ0Gtu3sZ77tqBbdVGW0VTS/QM5fnW40d4+LnjhKGmrbmB4fEiheLiT4SXSLgIITlw6Bj7DzzLj/3QbhKuJJq7SuA6No5l4XvQ05vnwUeP8+TeHrzzqHi8mEzmi+RampFCEAQeCA+lSngyQMiVofMqrc+oSAghSCZzbNxwE8VqA4LvL7F1kfqye+vMqQM0WgsqnsOT+wVtrYI33HENh463USyNUCyOYIkSqYTGkiGW1FgyugYmCppK9fIYWn2+aK05dPgEd9+267T8LQFYZ5pvaJG4YlU7P3njbnau7mJEhjxRfBElvOi3dHScvhBVDQ4DgRcqwsCnUvWiavFCIKRNg2NPqblaKRSCO9c18egBh6FifZwA17a4avUatnd1M1EuY/vDzLezaEmBYy/qbX9JWdQ9KRVLDA6NsHpVF0AUugCCIGSwTnLixZJOp1jV1c6pJ0xbcyO7r9zOd+5b+kYaopFV339hgOu2d8VDuiNncUNnjtfdvJWGVFRlcmbbYsvpzPru1lwsQ06TTtqsam9k0+pWfuT1V5FwpitVjhc9vvTAAb792MFZkwqOTizdiBLXdRkeLfDC/qfo6mBW7REpBJYQ2JYk3WDTcWUnN1+9lsef7edv/uURxsaXpnDa2ZjI50llG0hnMlHjWRmhVPRwfH0hMwzUBRUqKpUzjzYTQmBZDm1tG7Gsx5lO7F0aotFq0WOtYbJk4wUZGnNtlP0qpbKiqy1LZ+sOlIKn9w8yMnKQhFvmkb0FHn56iHRKkk0nGBj2LpvaMOeLEAKNxA+IRi0KhRCKQAdU/QobNmzgtlfczMOPPLZoOS419qxu4xdv20nYmOCYPY5tKyytEUoT+CFBGKJChecHBEGIn8zRvHYDE/0DlIaPI4k6R05C4qaT8ZQBsQMjNEc9i1KdwogtmRT/4/abePc1N9KSbaESBHzusW8CA/PcwkppWebHojownu/T2zfANVdfMfWaBkplj9HRicX86kWjva2Z5qYcKphtv7QEd7ziWr57/6NLnqBY4+mX+hjNX0FHkzM1GgABb7x5M/nK6RdcYzbJ7u051nf5dLWPc2JkgtUtuSkVxpKSG69Yx827OskkazU9NBUv5C++8CSPPX900VWWMyGEwLFdXjxwmPbWOSogC6hNviaFwJIWDakUd960gUAF/NnfP7ikEyHOxcTEJArINjSgVYimSKUiKJbKVL0VIvEK4sq2Z1lFCIRw4lLtS0ux5PHwsyHb1tvsPaB46WiV//6BLnZv38j1V7fz7EvDUzZaFiQTkm3rcoBL63HB0ZMn4h54acltX0ns3LGNH/7BH6K5tZEwDFBhiJASx0mSSCS48fo1bNqwgV//6Md56JHv43n+ojgySVvyti1NFBsc3CzYhKhQx4nlCi8I8P1IaalUooTylu6N7Lp6K+Pru3j2gTKZsEzCsVBOikTCQetguh6MUtx3oI9idenbDseSfOTmK/nhq7aRTqWQQpCwbJKJxNRUvpcbi+rAaK053nP6SJDRsUkKhfr3gC+ENau6SSYTlGpCg57+f+2eHbS0NDE8Up8w0kShwr5jY3Q1xyG7uCaKY0sS9szGQqMUFL0hfvStUahF6zGGJ56jIXkDjRm39nGu2NROS0OSuKwTaM0TL/XzxIvH6+a8QKSwpFJphkf20do0x6UbDQuIq/ZGc3CVvApozdU729iysZ0XD/Qtud0zKRRLlCsVGnMNKKGn8oqGRyfrVoDvfLEti3Q6dc71glDFdXuWFq3hGw9N8s2HmZre4vEX///tnXlwnOd93z/vuRf2AoiDBEiQ4C2aFEWVVuVDMaO60yjOWIk7TurWnmQ6cSdpUtdppp0200xnPPE0VTPJ2G6bpI6T1J6Jkzi2rNS25NqRI0uiLIsSzUM8QBDEfSx2sfe+5/P0j3cBQhTFQwF2F8z7mcGQuIiHmGef9/f8ju9X8P5HejF0k3QyvtqnETT6+ySzKYQfo6dbX/dG9HuRgYF+/stv/DoH9+8BrvcKskbXSAG2be3nd/7rb/Ktbz/LN57+Li+e/MG6BzFCwoLtM2CqaKrE85tZOCnxxIqHV1ANiEajgcheIxC8TMRN+oeHUXOTaAo09Di6sfL/CaYAY/EY1TYl4XZvSfNTI/1Nr6PmQIgiV/2O7gRHCJwWeKe1ig0vhk1Ozlw/AJq/5YVcaUNVeDeSXbu2N/113rxl+rZkuf/wAb77vZNv/sYWIKXk9OV53nd0aE05KEjtmrrG2rJX3XFRtRlMY8UfCtJdZZYqRVKJXlZCelNTcD2BaqiAxPN9njs90f6G2MAhEylu/mJcObSEEPhC4Db1JCQgFcHQtmTbAxjLsihXqgz097JqDIPC7NzShqfZ14uIqZNummzeioZl47bpNX9js+ULp+ZYLLgM9Qc9YI5rYegmxapLJhUl3iwbJBPB9EnIrTEMg5Mvv8LcwiIRA3bvGiQWS6CqGr4fKNfOzC1x4fI4V8cnOP2jcyws5jZkjzu+4CtnZ6lqUfbu7qc3FcHQQFMUFF1FUxX0pm+TpgZeabZiUyhU6M7GyfSmWFyKYAiPBgaq4gevTSkQwicRjzG4tZdr124/Er7eHO5L0aWzatSoaiYIH0PTOVNWGIqKplDdzXWkaj78xViFmfK9IwWw4QHM9MwcvhBveOjPbKID+kb2jOzgpruDwDzwxCPHefa59b9Z3CmXJ5eoWT7J2NrRdQXd0NbcJJty9L7e9DQK3tcUQcNpXP86KTENFdcXmEYwHluoNLg8ufEO4rdDARKJOIPb9jExeYZIxCMaUTANBVUN5l18X+ApCig+UgYqx0jwpaTRhhTwjdi2c11PYs2empq503p2+9k30kdfT/y2X9ewvPYHvU1y+TLf+N4oH//wUSIGzM5Pkk7Gmc0pjOzoI2oGg6YRs/L3Mi1/t0xNTfO7n/kDFEXh0P5BfuXnT6Ab0ab5rYZpmHz5yZM89fSLLVnPUs3myy9dpu/iLNv6MuwcyDKQidOTCmT8DQUQPoqmoqo6heVllrjKQ+8+RCyqcz5n8+zzZzlx4kGG9wYqzEFZzMOMwO6RIV44+VpL/i9ryUa0ZvDi4rt1gky6y4nBXi7OW1wszDNWrrE9GycjHTKmiiYFLgpXSw7/b7zIi9Ole8ZGAFoQwCws5rBth3ismWZWFKZmWifAtZ4YhsHw9qFbHmoPHr2P7my6bWWk3HKV6cUKB4e7Vz+2UvoRUqy8R9SAbHw/43OvsyVdA1QadpL+VBohrt88NdXHciVRU8X3Hcbn8pQqHRDBK6BpGu9+6Bh7dvZQKtuUKg2ujE8RiYBjl1DwEKKOoQu64hFMI+jAr9QcLo22fwpOCJ+l/JpmdhnYa0xOb44AJhox+NjjDzSbu29NwxZ0yNQpEvj6d87xwUf3k03FOHdxjkbdp1jtR1PS+CLIKM0tVTpmzZsBKSWzC0XqDY/+LgNdN4nEu8j2DOLJUy1di+f7zOZLzOZLvHppCk1TiRg6yVgUQxH4joNmmEhVpVxrkExfYee+IXozEQaHMszlS2RScXzPRVH1pohk4Ea9a3hbW0qLrpBI38H3LTy3hi9cpHBRvTp7umBA0RlTuul6z4MsLi0x6wWtAslUimefO8P3JsZbut5WsOEBTGG5SLVaDwKY5gE9vUkDmFgsGqT7V7jJ/u3rzXL0yEG+82xrbhs34rger16e58CO7BsaW33fCxynVwzKkPSloozNGNTUDL4yyEh/mmRMw/OvN5AqiqBhOcRNBcuucmFiAa9jIngFVdOIxyKkU2nMSAJFS3L82AGWlybwfPiLJ5/jS1/+JpquomsK0WgE1/UpltrfgyWEZG7+ja8F2/FYWMi3aUV3x4mH9/KuBwbvyLw0v1zZcOXtu2F2ocgffeUUn/joP8B2IywVxnClTqEQNJ76QvDSa+Nh/8tdYlkeNkmGdh3AMKKYkQSGGadhtc+GYUXd13U9qvW1E3PX/15uLPHiy5d4/J8cZc/OHu47MEwmHcXzPXRFRfiBvYDnumzt7yYWjVJvtPYil6s18HwbzW2goKKoNkI4uE4Vz6kifJuomWFo+zDJhIGiqMQTKXr7h/jh6+0tl28UGx7A1OsNisUS/b3doCi4rmR+cXMc0DeSzaTJZFJA47pb6Q1RjKZp/Nh738nf/O3JtgkdvXRuisffu5dENHAL1hRBsV4nZujNkcCV5laBaRgkY3W64lEqDZtIU2d6RTnY9wS1hkdEsynXcoxNtT9zcR0FtdnAJpHYtotpRlEViaYpRKIR9u7egef7qxNHlWpn+dnkcm8sx5WrDQrFcptWc+dk0wl+4UPHMO5Qw7xUbX/Jbi1SwlefOQvS4j3HUuTyETR1kdm5eTTNZGoBXj6zOTJhnYTtuExO53nkXSa6bqI2tadEx1x6bo6Uku+/dI4ff89BoqbBT5w4TE8mjhC1phGxh++7uK5NNh0nlUq0PIC5WmxQdyw0tYZEoCgawnfw3CqeW0MVHlFdZ2jnAdKZ2KoOUySeptborHNvvdjwAMZ1XZbyBfbvG0EBylWb5eKbTbw2A93d2eAGb924ceX1PyQ8ePQQqVSSYpseRFMLy7xyaYFHjmwLghTdp9xwSEQaKASKkqJpD69IievZJKKSpZxPzGg0e2IC/wPXD8zQCuUZlqtlZnKd8SASQmJZFkrTIBMpKRTL9PZuwfeCDJKiqOwYGsA0TCy7M1/Ai7l84BdEcIgu5pap1zugRHcbHjtxkL07Mnf0tVJK5haLG7qet4Pn+Xzl6Uu8cjbBlqwJCB7YL3E8i++8ZFMOFXfvGt/3mZ1fuiFztTmyWFevzXH2wjTvvH+Qoa1pYjET16oGPTCei+sE4pxR0ySbSTG/0NpewKlSnelKnX26hpAeCgpCOPhuA+E7WKi4Zpwr4zPEDQvT1KlbFQoTeQYHh0jE49Tq95YcwIYHML7vk181vlJYXKrQaLy18FUn053NoGlaIMX1lmlzyUB/D/v3jvCDH55u2drW4vuCv3r2PAeHUyRjCo7bIG7WGJur0Zf2gkYw4SGkh5ASx/PxhUsm0cVSaZKI0eyBkRLHg+WyRSpW5OqsznK5UwIYwdT0LA8f38+KG3WhWOW+Q3vxvevaHn293WQySeYXOjWAWcL3fVRVQUqf6dmllkuu3y3ZdJzH/9EeFGXFoPTmLwbZDIJ94bOYb53A4d0ghOTqVJWrU8H7PzwLgVr45njodiKT0ws4rodprnxE2RTK0rbt8O1nX+PYO4aC7FFwq0D4Pq5j4/seuutgRNNkM8mWr6/ueLy8UGEkoaGoTiAkLDyE76IgmDF6eP8/+3l002Rhfp5CpUEsFmHHjmF+9fCDlEoV/vKvnrqn9nZLNIVXNF8UVWNyepFEPE65Utl0v8hEIr5q6Ljy0LwZhq5z5B0H2hbAAIzP5PmDJ1/jw49uw9TL2HYBx7G5PG2S6bLQFA9fQK4YIdor8TybqJlmplHGcVcyZJLlagSQzOZ1/uaU1xYtj7di9Mo4Co8GD1ApaNiCrkSUUt5tCvmpdHUFfUutvi3dKaVSBdf1moJZkvGJ+bbq69wJDz8wxNYtOq5no2sm0CwjKYHW80rgAiCER8OymFvs/LIYsKpfEvL2mZicY3m5SrIreMirikIkEmnzqu6MsxfGOfnKJfbu6sc0IihqML3pOBYoCppqg6KRSd1+8m698YXk+ekKHxiKEddXJAmu79WqUOl2XYa2DzK8fXD147VandfOnKdeb6Cqyqoe0r3AhgYwWwf6eNdDh6lUK8zNL1IqlVnMFfnjP3yCTz/xv3jl1OmN/PHrzv2HDzX1Vd7qNnF9Yzx0/H7++Itfaett+uXzM4zP5hkZ0umKK+iqRywKJ8+r5PIOrqdRrlXZMWCyZ8cCC/lpTMOiWpMk4hqGrnB5wkYCpapPw+qcJkyAC5dGcTwfRVHxhUA3IijN0UJFCXydDMNg5/Agp89caPdyb8ry8jKWZROJGPi+3/ETSIau8b539uF7Fq4SZMI0TQ9sQqSCbJbzhBQIEfQNFMu1js3AhKw/5XKVsYk5hndsAwKl5t6ebJtXdWdYlsM3v/MqH//Y+8lmkkjfCPpfPDfohWl6zGXSsbZMIp1drHKp3M2xboM3FukUDoslXvrCf+fpoSOM7BzCdW1A4fKVa/z5V79NuVLddEmD27FhAcyWnh5+77/9Jlt7NV546TRPPfUk8XiMR3/sQXYND6JugpTiWiKmydEj9938k2tubSvbY+/unXRnMyzm2nvzzy1b5NZMdCuKtWYTB411F681uHjtWsvX9nfl2sQU8wtLJKMqSL9ZE3bxV8zYFBVVVRnZtaPdS31LLNuhblmk011YtsvMXGc3uA/0Jti1TcdxGkgp0DUPfyWAUdRmO5JsTn54eJ7L/GKRUmVzlo1D7h5fCM6eH+N97z7GSotaNptu97LumKuTOabnltk+2Idpxpp7XaKgIkXQO5hKxtsSwNQcj29OVDmSzaI1H6ESsHzJjG+QM2JkM2n27+4jN3+NSCTGzKxBtVa754IX2MAAprs7w8iu7bjWPA8f349pxjEjXZiRBOOTs7z++uWN+tEbQjLZxcBAP7cqHUGQmxFCENFVBrcNtD2AuZF7aROXyxWeP3mKn3z0HSgKuI7VvCn5KKrRfKCq7BjahqqqHSmeaFkW1UoV+npYLtY63iNsZCiBoTm4jooUPr7uXc/ANM00pZTB50Rwcx2dLGB3iAN4yMYjpeTi6AR1yyFlRIEgG79ZsG2Hy1dzvOfhI2hqcGbohokUEs9zUFWNVCqBrms4TuvPlBemS1waSXIgrbNoScY8g1pvP9FtA+zfOsjMksLWoV3EYgqapjP/zGsdIyK53mxYAHNtYornT77CQ0eH3vS5hVx+01oJ3K4+7joO+cV5VNUglepq0Zr+fiKl5Ktff4b3vnM3sagKeNTrQZpUaRo5KopCdzbVsQGM7wvqzRHHmfkCjVs4O3cCg/06ntcABEL6aMJFVZsBDCsj+BIpxGoAc/ZS/p4KnENuz/TMIvlCiVQyhZSSocF+IpEIdodOA64lkUiwe/deFDWKoavBuLLwQApcR0dRVXbv2s4//eAJvvbXf9tyjZulms3nzuTpieq8tlBlcNcOPvXRDwA2haJFubIEaCiqhuu5jE/MtnR9reTORBzeBo7j8D//8Etcm5pHiGBawXU9Xv3RRX73s3+Es1ncdpsUS2XOnH2dUmGZwuISpeUylVKVcrFCsVBkcS7H5JVrjJ6/SKlQwIjHyOU6uxxwL3B5dJw//bOnqTdstmTjjF29BgQj1DQzMIHwXmc+QE3TWPVoGh2bbpt20J0Sj/i4bgPXaeA49dU3265hO803u47t1HCcOsVKjXOjhdv/wyH3FPlCkcnpheZ0nWRrfy+9W7pv/40dwANH9vHIwwfxfIjEuojEuohGu4hEk0RjXUTjKZAOP/3YcXZs39qWNb4yU+SZsSUWqxbjk/OMTdVA30q2ZxcNy8LzJZpmUKtZzMxuTuHYO2FDm3hHr4zzyf/4GQ7sG6anO8vk9AIXLl2lVtt8s+ie5/Hbv/M5fv0Tv8iuoQy25WBbDYQIxNQ0zcAwI8TTaequ5H98/stcGr3a7mXf8wgh+MuvfZfzF66yb+8w07OL/NIvfIA9u3egKCpSKrz8ylm8DnRg3bd3J5/41/+csfErzM5Os3Wgm3/7Kx/lT770dZaXO7OUVG/YOG4DIZrZF01HVXRUVeX6fUis9sCcG60zu9B+1eOQ1rOQKwY5OQlburN85Gd/hpM/eJXTZ85RqXSmFpiiKAxt68FUHWZyRXp6RtB0A+EH0hJC+BTLFq5dpys59JYSAq0knU4RjcW4MjZOf0+MqO5QrTaIGRHyhRLLpc78Xa8HLfBCyrOwSZV3b+TaxBSf/A+fYqC/h55sCt3Q8DxB4Oas4LoelUqNpfwytU0gRnav4AvB2dfHOPv6GABjV6f5h8cPk81msGyPb337uTav8M2oqspHPvwYx48dBGjqqQSf60rE+fQT/7ujpPdXmFpwcZwGQvfRfA9V01AVbXXqC5o9MFJguz7PvLDUQdYTIa3ANE1+7RO/xIlHHiJXdFBViaoZfOjxD/AzH3yMTz/xWf76G890bFlRSohETaKGx4ULo6TSaSKRKEIISsUCtfISu0d2MjVTYL4DbD8mp2b4N7/2GwzvGOSJ3/pPHDp0iJm5HAf3dLOQK+K6927/WUt0YO4lXNdlanqeqen5di8l5C1Yyhf5v09/v93LuCVCCL7wf55kYmqOvi0ZYrEonudh2Q7Pv3i6I/t1AC5ctciXNLIpD001UH0dtVmqWxvACCk4ecbl7Ojm0H8JWR8ikQj/6l9+jJ/4xycwdJV6fZlGfQlVAU3pIZ3p5Zd/8eeYm5vhh6fOtnu5b0JKyWtnrnBt+gGGtg7gey6NRgO7WsK26hgqjIwMU2nAn/zZtyiV25/dkFJi2zajV8b51G9/jl/++MdYmJnn0P4BbNtdETe6J1FuFQUrgaZ8SEjIBtOOkcy3y0+9L81j75YoCquTXsEE0vUAZnQSPv/VMsvlzdXrtp5IKdtfX7iBjT7Te7q7+fMv/j67dw1jWRUatUWqlRy+75JMDRDv2oLnNvjs73+Rz//p1zp2zw/09XD/4T0cPjTCzu19pFMJGg2LhVyZM+ev8oNTF5ic6jyDREVRGBrcxkd+9qf5uQ/9OOfOnuJX//1nKK5TGanT9nQYwISEhNwV6aTBJ/9FgoEen7WijkJCraHy6kXJN79fp1TZrJOG60OnHfaw8Wd6KpXkt/7zv+PIwb04doNoTGM5P0UsblLMl5BSJ18o8pkvPMWF0YmNXMq6oOsamqYRMU08z8P1PDzP79jAa4VsJsPePcM06lVev3Rt3crRnbanwwAmJCTkrjn+ji4++pMapiEQQuHypMqLP3IZn3HJL7uIDj/gW0GnHfbQmjN912Af77pvmN5MkmgsSqYnRTQeYfzSOA3H5ZXLM5y+NBXukU1Ip+3pMIAJCQm5azRV4eGjCY4dNBid9Hn25RqW3XlNx+2k0w57aN2Znk3G2Tu4hf50nHQ6Sa1ukVuuMDZfYKFQCYOXTUqn7ekwgAkJCXnbaJqK8EWHquy0l0477KG1Z7qiKGiqsioiKYQMA5dNTqft6VsGMCEhISEh9w7hpTTk70KnBTAbpsQbEhISEhISErJRhBmYkJCQkJCQkE1HmIEJCQkJCQkJ2XSEAUxISEhISEjIpiMMYEJCQkJCQkI2HWEAExISEhISErLpCAOYkJCQkJCQkE1HGMCEhISEhISEbDr+PzxwK2j1hI7rAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "CASE 2:\n", "Left indices: [0, 2, 4]\n", "Right indices: [6, 8]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[92m All tests passed.\n" ] } ], "source": [ "# Case 1\n", "\n", "root_indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "\n", "# Feel free to play around with these variables\n", "# The dataset only has three features, so this value can be 0 (Brown Cap), 1 (Tapering Stalk Shape) or 2 (Solitary)\n", "feature = 0\n", "\n", "left_indices, right_indices = split_dataset(X_train, root_indices, feature)\n", "\n", "print(\"CASE 1:\")\n", "print(\"Left indices: \", left_indices)\n", "print(\"Right indices: \", right_indices)\n", "\n", "# Visualize the split \n", "generate_split_viz(root_indices, left_indices, right_indices, feature)\n", "\n", "print()\n", "\n", "# Case 2\n", "\n", "root_indices_subset = [0, 2, 4, 6, 8]\n", "left_indices, right_indices = split_dataset(X_train, root_indices_subset, feature)\n", "\n", "print(\"CASE 2:\")\n", "print(\"Left indices: \", left_indices)\n", "print(\"Right indices: \", right_indices)\n", "\n", "# Visualize the split \n", "generate_split_viz(root_indices_subset, left_indices, right_indices, feature)\n", "\n", "# UNIT TESTS \n", "split_dataset_test(split_dataset)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Expected Output**:\n", "```\n", "CASE 1:\n", "Left indices: [0, 1, 2, 3, 4, 7, 9]\n", "Right indices: [5, 6, 8]\n", "\n", "CASE 2:\n", "Left indices: [0, 2, 4]\n", "Right indices: [6, 8]\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 4.3 Calculate information gain\n", "\n", "Next, you'll write a function called `information_gain` that takes in the training data, the indices at a node and a feature to split on and returns the information gain from the split.\n", "\n", "\n", "### Exercise 3\n", "\n", "Please complete the `compute_information_gain()` function shown below to compute\n", "\n", "$$\\text{Information Gain} = H(p_1^\\text{node})- (w^{\\text{left}}H(p_1^\\text{left}) + w^{\\text{right}}H(p_1^\\text{right}))$$\n", "\n", "where \n", "- $H(p_1^\\text{node})$ is entropy at the node \n", "- $H(p_1^\\text{left})$ and $H(p_1^\\text{right})$ are the entropies at the left and the right branches resulting from the split\n", "- $w^{\\text{left}}$ and $w^{\\text{right}}$ are the proportion of examples at the left and right branch, respectively\n", "\n", "Note:\n", "- You can use the `compute_entropy()` function that you implemented above to calculate the entropy\n", "- We've provided some starter code that uses the `split_dataset()` function you implemented above to split the dataset \n", "\n", "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation." ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "deletable": false }, "outputs": [], "source": [ "# UNQ_C3\n", "# GRADED FUNCTION: compute_information_gain\n", "\n", "def compute_information_gain(X, y, node_indices, feature):\n", " \n", " \"\"\"\n", " Compute the information of splitting the node on a given feature\n", " \n", " Args:\n", " X (ndarray): Data matrix of shape(n_samples, n_features)\n", " y (array like): list or ndarray with n_samples containing the target variable\n", " node_indices (ndarray): List containing the active indices. I.e, the samples being considered in this step.\n", " feature (int): Index of feature to split on\n", " \n", " Returns:\n", " cost (float): Cost computed\n", " \n", " \"\"\" \n", " # Split dataset\n", " left_indices, right_indices = split_dataset(X, node_indices, feature)\n", " \n", " # Some useful variables\n", " X_node, y_node = X[node_indices], y[node_indices]\n", " X_left, y_left = X[left_indices], y[left_indices]\n", " X_right, y_right = X[right_indices], y[right_indices]\n", " \n", " # You need to return the following variables correctly\n", " information_gain = 0\n", " \n", " ### START CODE HERE ###\n", " w_left = len(X_left) / len(X_node)\n", " w_right = len(X_right) / len(X_node)\n", " information_gain = compute_entropy(y_node) - w_left*compute_entropy(y_left) - w_right*compute_entropy(y_right)\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " ### END CODE HERE ### \n", " \n", " return information_gain" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Click for hints\n", " \n", " \n", " * Here's how you can structure the overall implementation for this function\n", " ```python \n", " def compute_information_gain(X, y, node_indices, feature):\n", " # Split dataset\n", " left_indices, right_indices = split_dataset(X, node_indices, feature)\n", "\n", " # Some useful variables\n", " X_node, y_node = X[node_indices], y[node_indices]\n", " X_left, y_left = X[left_indices], y[left_indices]\n", " X_right, y_right = X[right_indices], y[right_indices]\n", "\n", " # You need to return the following variables correctly\n", " information_gain = 0\n", "\n", " ### START CODE HERE ###\n", " # Your code here to compute the entropy at the node using compute_entropy()\n", " node_entropy = \n", " # Your code here to compute the entropy at the left branch\n", " left_entropy = \n", " # Your code here to compute the entropy at the right branch\n", " right_entropy = \n", "\n", " # Your code here to compute the proportion of examples at the left branch\n", " w_left = \n", " \n", " # Your code here to compute the proportion of examples at the right branch\n", " w_right = \n", "\n", " # Your code here to compute weighted entropy from the split using \n", " # w_left, w_right, left_entropy and right_entropy\n", " weighted_entropy = \n", "\n", " # Your code here to compute the information gain as the entropy at the node\n", " # minus the weighted entropy\n", " information_gain = \n", " ### END CODE HERE ### \n", "\n", " return information_gain\n", " ```\n", " If you're still stuck, check out the hints below.\n", " \n", "
\n", " Hint to calculate the entropies\n", " \n", " node_entropy = compute_entropy(y_node)
\n", " left_entropy = compute_entropy(y_left)
\n", " right_entropy = compute_entropy(y_right)\n", " \n", "
\n", " \n", "
\n", " Hint to calculate w_left and w_right\n", " w_left = len(X_left) / len(X_node)
\n", " w_right = len(X_right) / len(X_node)\n", "
\n", " \n", "
\n", " Hint to calculate weighted_entropy\n", " weighted_entropy = w_left * left_entropy + w_right * right_entropy\n", "
\n", " \n", "
\n", " Hint to calculate information_gain\n", " information_gain = node_entropy - weighted_entropy\n", "
\n", "\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can now check your implementation using the cell below and calculate what the information gain would be from splitting on each of the featues" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Information Gain from splitting the root on brown cap: 0.03485155455967709\n", "Information Gain from splitting the root on tapering stalk shape: 0.12451124978365324\n", "Information Gain from splitting the root on solitary: 0.2780719051126377\n", "\u001b[92m All tests passed.\n" ] } ], "source": [ "info_gain0 = compute_information_gain(X_train, y_train, root_indices, feature=0)\n", "print(\"Information Gain from splitting the root on brown cap: \", info_gain0)\n", "\n", "info_gain1 = compute_information_gain(X_train, y_train, root_indices, feature=1)\n", "print(\"Information Gain from splitting the root on tapering stalk shape: \", info_gain1)\n", "\n", "info_gain2 = compute_information_gain(X_train, y_train, root_indices, feature=2)\n", "print(\"Information Gain from splitting the root on solitary: \", info_gain2)\n", "\n", "# UNIT TESTS\n", "compute_information_gain_test(compute_information_gain)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Expected Output**:\n", "```\n", "Information Gain from splitting the root on brown cap: 0.034851554559677034\n", "Information Gain from splitting the root on tapering stalk shape: 0.12451124978365313\n", "Information Gain from splitting the root on solitary: 0.2780719051126377\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Splitting on \"Solitary\" (feature = 2) at the root node gives the maximum information gain. Therefore, it's the best feature to split on at the root node." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 4.4 Get best split\n", "Now let's write a function to get the best feature to split on by computing the information gain from each feature as we did above and returning the feature that gives the maximum information gain\n", "\n", "\n", "### Exercise 4\n", "Please complete the `get_best_split()` function shown below.\n", "- The function takes in the training data, along with the indices of datapoint at that node\n", "- The output of the function is the feature that gives the maximum information gain \n", " - You can use the `compute_information_gain()` function to iterate through the features and calculate the information for each feature\n", "If you get stuck, you can check out the hints presented after the cell below to help you with the implementation." ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "deletable": false }, "outputs": [], "source": [ "# UNQ_C4\n", "# GRADED FUNCTION: get_best_split\n", "\n", "def get_best_split(X, y, node_indices): \n", " \"\"\"\n", " Returns the optimal feature and threshold value\n", " to split the node data \n", " \n", " Args:\n", " X (ndarray): Data matrix of shape(n_samples, n_features)\n", " y (array like): list or ndarray with n_samples containing the target variable\n", " node_indices (ndarray): List containing the active indices. I.e, the samples being considered in this step.\n", "\n", " Returns:\n", " best_feature (int): The index of the best feature to split\n", " \"\"\" \n", " \n", " # Some useful variables\n", " num_features = X.shape[1]\n", " \n", " # You need to return the following variables correctly\n", " best_feature = -1\n", " \n", " ### START CODE HERE ###\n", " highest_gain = 0\n", " for i in range(num_features):\n", " curr_gain = compute_information_gain(X,y,node_indices,i)\n", " if (curr_gain > highest_gain):\n", " best_feature = i\n", " highest_gain = curr_gain\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " ### END CODE HERE ## \n", " \n", " return best_feature" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Click for hints\n", " \n", " \n", " * Here's how you can structure the overall implementation for this function\n", " \n", " ```python \n", " def get_best_split(X, y, node_indices): \n", "\n", " # Some useful variables\n", " num_features = X.shape[1]\n", "\n", " # You need to return the following variables correctly\n", " best_feature = -1\n", "\n", " ### START CODE HERE ###\n", " max_info_gain = 0\n", "\n", " # Iterate through all features\n", " for feature in range(num_features): \n", " \n", " # Your code here to compute the information gain from splitting on this feature\n", " info_gain = \n", " \n", " # If the information gain is larger than the max seen so far\n", " if info_gain > max_info_gain: \n", " # Your code here to set the max_info_gain and best_feature\n", " max_info_gain = \n", " best_feature = \n", " ### END CODE HERE ## \n", " \n", " return best_feature\n", " ```\n", " If you're still stuck, check out the hints below.\n", " \n", "
\n", " Hint to calculate info_gain\n", " \n", " info_gain = compute_information_gain(X, y, node_indices, feature)\n", "
\n", " \n", "
\n", " Hint to update the max_info_gain and best_feature\n", " max_info_gain = info_gain
\n", " best_feature = feature\n", "
\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, let's check the implementation of your function using the cell below." ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best feature to split on: 2\n", "\u001b[92m All tests passed.\n" ] } ], "source": [ "best_feature = get_best_split(X_train, y_train, root_indices)\n", "print(\"Best feature to split on: %d\" % best_feature)\n", "\n", "# UNIT TESTS\n", "get_best_split_test(get_best_split)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we saw above, the function returns that the best feature to split on at the root node is feature 2 (\"Solitary\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 5 - Building the tree\n", "\n", "In this section, we use the functions you implemented above to generate a decision tree by successively picking the best feature to split on until we reach the stopping criteria (maximum depth is 2).\n", "\n", "You do not need to implement anything for this part." ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "deletable": false, "editable": false }, "outputs": [], "source": [ "# Not graded\n", "tree = []\n", "\n", "def build_tree_recursive(X, y, node_indices, branch_name, max_depth, current_depth):\n", " \"\"\"\n", " Build a tree using the recursive algorithm that split the dataset into 2 subgroups at each node.\n", " This function just prints the tree.\n", " \n", " Args:\n", " X (ndarray): Data matrix of shape(n_samples, n_features)\n", " y (array like): list or ndarray with n_samples containing the target variable\n", " node_indices (ndarray): List containing the active indices. I.e, the samples being considered in this step.\n", " branch_name (string): Name of the branch. ['Root', 'Left', 'Right']\n", " max_depth (int): Max depth of the resulting tree. \n", " current_depth (int): Current depth. Parameter used during recursive call.\n", " \n", " \"\"\" \n", "\n", " # Maximum depth reached - stop splitting\n", " if current_depth == max_depth:\n", " formatting = \" \"*current_depth + \"-\"*current_depth\n", " print(formatting, \"%s leaf node with indices\" % branch_name, node_indices)\n", " return\n", " \n", " # Otherwise, get best split and split the data\n", " # Get the best feature and threshold at this node\n", " best_feature = get_best_split(X, y, node_indices) \n", " \n", " formatting = \"-\"*current_depth\n", " print(\"%s Depth %d, %s: Split on feature: %d\" % (formatting, current_depth, branch_name, best_feature))\n", " \n", " # Split the dataset at the best feature\n", " left_indices, right_indices = split_dataset(X, node_indices, best_feature)\n", " tree.append((left_indices, right_indices, best_feature))\n", " \n", " # continue splitting the left and the right child. Increment current depth\n", " build_tree_recursive(X, y, left_indices, \"Left\", max_depth, current_depth+1)\n", " build_tree_recursive(X, y, right_indices, \"Right\", max_depth, current_depth+1)" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "deletable": false, "editable": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Depth 0, Root: Split on feature: 2\n", "- Depth 1, Left: Split on feature: 0\n", " -- Left leaf node with indices [0, 1, 4, 7]\n", " -- Right leaf node with indices [5]\n", "- Depth 1, Right: Split on feature: 1\n", " -- Left leaf node with indices [8]\n", " -- Right leaf node with indices [2, 3, 6, 9]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "build_tree_recursive(X_train, y_train, root_indices, \"Root\", max_depth=2, current_depth=0)\n", "generate_tree_viz(root_indices, y_train, tree)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Please click here if you want to experiment with any of the non-graded code.\n", "

Important Note: Please only do this when you've already passed the assignment to avoid problems with the autograder.\n", "

    \n", "
  1. On the notebook’s menu, click “View” > “Cell Toolbar” > “Edit Metadata”
    2. \n", "
  2. Hit the “Edit Metadata” button next to the code cell which you want to lock/unlock
    3. \n", "
  3. Set the attribute value for “editable” to:\n", "
      \n", "
    • “true” if you want to unlock it
      • \n", "
    • “false” if you want to lock it
      • \n", "
    \n", "
    4. \n", "
  4. On the notebook’s menu, click “View” > “Cell Toolbar” > “None”
    5. \n", "
\n", "

Here's a short demo of how to do the steps above: \n", "
\n", " \"unlock_cells.gif\"\n", "

" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.6" } }, "nbformat": 4, "nbformat_minor": 5 }