From 65df9cb6b0f5e4c1f054a2e5e334dd30d9a770ba Mon Sep 17 00:00:00 2001 From: giktech Date: Fri, 2 Feb 2018 19:24:59 -0800 Subject: [PATCH 1/3] Rename firstname_lastname_p1.ipynb to Gaurav_Khanna_p1.ipynb Setting up to work on the first assignment --- Homework/{firstname_lastname_p1.ipynb => Gaurav_Khanna_p1.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Homework/{firstname_lastname_p1.ipynb => Gaurav_Khanna_p1.ipynb} (100%) diff --git a/Homework/firstname_lastname_p1.ipynb b/Homework/Gaurav_Khanna_p1.ipynb similarity index 100% rename from Homework/firstname_lastname_p1.ipynb rename to Homework/Gaurav_Khanna_p1.ipynb From 7651e7aee3eee7e57bcdd1118e133ef98ec2ed68 Mon Sep 17 00:00:00 2001 From: giktech Date: Fri, 9 Feb 2018 23:02:06 -0800 Subject: [PATCH 2/3] Gaurav_Khanna_p1 Commit for Project 1 Digit Classification with KNN and Naive Bayes --- Homework/Gaurav_Khanna_p1.ipynb | 1250 +++++++++++++++++++++++++++---- 1 file changed, 1123 insertions(+), 127 deletions(-) diff --git a/Homework/Gaurav_Khanna_p1.ipynb b/Homework/Gaurav_Khanna_p1.ipynb index c29cadb..05be80b 100644 --- a/Homework/Gaurav_Khanna_p1.ipynb +++ b/Homework/Gaurav_Khanna_p1.ipynb @@ -24,10 +24,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": false - }, + "execution_count": 199, + "metadata": {}, "outputs": [], "source": [ "# This tells matplotlib not to try opening a new window for each plot.\n", @@ -36,7 +34,9 @@ "# Import a bunch of libraries.\n", "import time\n", "import numpy as np\n", + "import math\n", "import matplotlib.pyplot as plt\n", + "import sklearn.preprocessing\n", "from matplotlib.ticker import MultipleLocator\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.datasets import fetch_mldata\n", @@ -46,7 +46,8 @@ "from sklearn.naive_bayes import BernoulliNB\n", "from sklearn.naive_bayes import MultinomialNB\n", "from sklearn.naive_bayes import GaussianNB\n", - "from sklearn.grid_search import GridSearchCV\n", + "#from sklearn.grid_search import GridSearchCV\n", + "from sklearn.model_selection import GridSearchCV\n", "from sklearn.metrics import classification_report\n", "\n", "# Set the randomizer seed so results are the same each time.\n", @@ -63,9 +64,7 @@ { "cell_type": "code", "execution_count": 2, - "metadata": { - "collapsed": false - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -91,8 +90,8 @@ "shuffle = np.random.permutation(np.arange(X.shape[0]))\n", "X, Y = X[shuffle], Y[shuffle]\n", "\n", - "print 'data shape: ', X.shape\n", - "print 'label shape:', Y.shape\n", + "print ('data shape: ', X.shape)\n", + "print ('label shape:', Y.shape)\n", "\n", "# Set some variables to hold test, dev, and training data.\n", "test_data, test_labels = X[61000:], Y[61000:]\n", @@ -115,20 +114,78 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#def P1(num_examples=10):\n", + "def P1(num_examples=10):\n", "\n", "### STUDENT START ###\n", - " \n", "\n", + "# Strategy: Walk through Y (mnist.target)\n", + "# exctract the digit, extract the corresponding feature list from X (mnist.data)\n", + "# put the extracted array of features into the 10*10 grid for display\n", + "\n", + "# This array keeps track of the number of instances of a digit we have found while walking the target array #\n", + " digCount = [0 for i in range(10)]\n", + " \n", + "# We'll need a function to find if we got 10 instances of all digits\n", + "# The Function returns False if we found 10 instances of all digits\n", + "\n", + " def isSpace(ar, instance = 10):\n", + " x = 0\n", + " for i in range(len(ar)):\n", + " x += ar[i]\n", + " if x < (instance)**2:\n", + " return True\n", + " else:\n", + " return False\n", + " \n", + "# We'll need a function to find if we got 10 instances of a digit\n", + "# The Function returns False if we found 10 instances of a digits\n", + "\n", + " def isSpaceDigit(ar, d = 0, instance = 10):\n", + " if ar[d] < instance:\n", + " return True\n", + " else: \n", + " return False\n", + " \n", + "# print(digClount)\n", + "\n", + "# Now we are walking the target array and creating plots of 10 instances of each digit\n", + " \n", + " for i in range(len(Y)):\n", + " Xp = X[i].reshape(28,28)\n", + " \n", + " # Is there space for an instance of the digit Y[i]? \n", + " if isSpaceDigit(digCount, int(Y[i]), num_examples):\n", + " # Yes, there is space, lets plot this digit\n", + " # We'll put this digit in the \"digit\" row and collumn digCount\n", + " plt.subplot(num_examples, num_examples, (Y[i] * num_examples) + 1 + digCount[int(Y[i])])\n", + " plt.axis(\"off\")\n", + " plt.imshow(Xp, aspect = \"auto\", cmap = plt.cm.gray_r, interpolation = \"nearest\")\n", + " digCount[int(Y[i])] +=1\n", + " else:\n", + " # Have we filled up all of the 10 * 10 array? \n", + " if not (isSpace(digCount, num_examples)):\n", + " break\n", + "plt.show()\n", + "\n", + " \n", "### STUDENT END ###\n", "\n", - "#P1(10)" + "P1(10)" ] }, { @@ -143,29 +200,97 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 175, "metadata": { - "collapsed": false + "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Mean Square Error for K = 1 on the dev data set is 2.119\n", + "The accuracy is 88.8 %\n", + "\n", + "Classification Report\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0.0 0.91 0.98 0.94 99\n", + " 1.0 0.89 1.00 0.94 105\n", + " 2.0 0.99 0.79 0.88 102\n", + " 3.0 0.77 0.87 0.82 86\n", + " 4.0 0.89 0.82 0.85 104\n", + " 5.0 0.93 0.84 0.88 91\n", + " 6.0 0.94 0.96 0.95 98\n", + " 7.0 0.89 0.92 0.90 113\n", + " 8.0 0.94 0.88 0.91 96\n", + " 9.0 0.78 0.82 0.80 106\n", + "\n", + "avg / total 0.89 0.89 0.89 1000\n", + "\n", + "\n", + "The Mean Square Error for K = 3 on the dev data set is 2.128\n", + "The accuracy is 87.8 %\n", + "\n", + "The Mean Square Error for K = 5 on the dev data set is 2.469\n", + "The accuracy is 86.9 %\n", + "\n", + "The Mean Square Error for K = 7 on the dev data set is 2.357\n", + "The accuracy is 86.5 %\n", + "\n", + "The Mean Square Error for K = 9 on the dev data set is 2.435\n", + "The accuracy is 86.3 %\n", + "\n" + ] + } + ], "source": [ - "#def P2(k_values):\n", + "def P2(k_values):\n", "\n", "### STUDENT START ###\n", "\n", - "\n", + "# Walk through the list of K_values\n", + " for i in k_values:\n", + " \n", + " # Create the knn model.\n", + " knnModel = KNeighborsClassifier(i)\n", + " \n", + " # Fit the model on mini training set\n", + " knnModel.fit(mini_train_data, mini_train_labels)\n", + "\n", + " # Try on the development set\n", + " predictions = knnModel.predict(dev_data)\n", + " \n", + " # 2 metrics to get an idea of accuracy: Mean Squared Error and model score\n", + " \n", + " # Mean Squared error of the predictions\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = knnModel.score(dev_data, dev_labels)\n", + " \n", + " # Print the MSE and accuracy for a value of K\n", + " print(\"The Mean Square Error for K = \", i, \" on the dev data set is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " # if K = 1, also print the precision, recall and F1 report\n", + " if i == 1:\n", + " print(\"Classification Report\")\n", + " print()\n", + " print(classification_report(dev_labels, predictions))\n", + " print()\n", " \n", "### STUDENT END ###\n", "\n", - "#k_values = [1, 3, 5, 7, 9]\n", - "#P2(k_values)" + "k_values = [1, 3, 5, 7, 9]\n", + "P2(k_values)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: \"3\" (precision of .77) seems to be the most difficult digit to predict" ] }, { @@ -179,22 +304,89 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 176, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The Dev set accuracy for training data size: 100 is 72.0 %\n", + "Time taken for the predictions is 0.12468504905700684\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 200 is 78.6 %\n", + "Time taken for the predictions is 0.23468804359436035\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 400 is 84.1 %\n", + "Time taken for the predictions is 0.4730370044708252\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 800 is 88.4 %\n", + "Time taken for the predictions is 0.951606035232544\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 1600 is 90.2 %\n", + "Time taken for the predictions is 1.9812893867492676\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 3200 is 92.6 %\n", + "Time taken for the predictions is 3.9774398803710938\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 6400 is 93.7 %\n", + "Time taken for the predictions is 7.833939790725708\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 12800 is 95.9 %\n", + "Time taken for the predictions is 15.428621053695679\n", + "\n", + "\n", + "The Dev set accuracy for training data size: 25000 is 97.0 %\n", + "Time taken for the predictions is 30.57994508743286\n", + "\n", + "\n", + "Accuracy Matrix\n", + "[0.71999999999999997, 0.78600000000000003, 0.84099999999999997, 0.88400000000000001, 0.90200000000000002, 0.92600000000000005, 0.93700000000000006, 0.95899999999999996, 0.96999999999999997]\n" + ] + } + ], "source": [ - "#def P3(train_sizes, accuracies):\n", + "def P3(train_sizes, accuracies):\n", "\n", "### STUDENT START ###\n", "\n", - "\n", + " for tr in train_sizes:\n", + " \n", + " # Fit the model\n", + " knnModel = KNeighborsClassifier(1)\n", + " knnModel.fit(train_data[:tr], train_labels[:tr])\n", + "\n", + " # Try on the development set and time the operation\n", + " sTime = time.time()\n", + " predictions = knnModel.predict(dev_data)\n", + " eTime = time.time()\n", + " \n", + " # Accuracy\n", + " sc = knnModel.score(dev_data, dev_labels)\n", + " accuracies.append(sc)\n", + " \n", + " # Print the MSE and accuracy for a value of K\n", + " print()\n", + " print(\"The Dev set accuracy for training data size:\", tr, \"is\", (sc*100), \"%\")\n", + " print(\"Time taken for the predictions is\", eTime - sTime)\n", + " print()\n", + " \n", "### STUDENT END ###\n", "\n", - "#train_sizes = [100, 200, 400, 800, 1600, 3200, 6400, 12800, 25000]\n", - "#accuracies = []\n", - "#P3(train_sizes, accuracies)" + "train_sizes = [100, 200, 400, 800, 1600, 3200, 6400, 12800, 25000]\n", + "accuracies = []\n", + "P3(train_sizes, accuracies)\n", + "print()\n", + "print(\"Accuracy Matrix\")\n", + "print(accuracies)" ] }, { @@ -208,27 +400,100 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 205, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Sizes Array \n", + "\n", + "[100, 200, 400, 800, 1600, 3200, 6400, 12800, 25000]\n", + "\n", + "Modified Train Sizes Array \n", + "\n", + "[[ 100]\n", + " [ 200]\n", + " [ 400]\n", + " [ 800]\n", + " [ 1600]\n", + " [ 3200]\n", + " [ 6400]\n", + " [12800]\n", + " [25000]]\n", + "\n", + "The Model predicting accuracy from Training data size \n", + "\n", + "y = 6.6652713854943685e-06 * x + 0.8431559772258371\n", + "\n", + "Accuracy with training data size of 60K \n", + " [ 124.30722604]\n", + "\n", + "Accuracy with training data size of 60K with normalized input \n", + " [ 100.]\n" + ] + } + ], "source": [ - "#def P4():\n", + "def P4():\n", "\n", "### STUDENT START ###\n", - " \n", "\n", + " # Starting a linear regression #\n", + " reg = LinearRegression()\n", + " \n", + " print(\"Train Sizes Array \\n\")\n", + " print(train_sizes)\n", + " print()\n", + " \n", + " # Reshaping train_sizes to a matrix #\n", + " train_sizes_re = np.array(train_sizes).reshape(-1,1)\n", + " print(\"Modified Train Sizes Array \\n\")\n", + " print(train_sizes_re)\n", + " print()\n", + " \n", + " # Fitting the model #\n", + " print(\"The Model predicting accuracy from Training data size \\n\")\n", + " reg.fit(train_sizes_re, accuracies)\n", + " print('y = {0} * x + {1}'.format(reg.coef_[0], reg.intercept_))\n", + " print()\n", + " \n", + " # Finding the prediction for training data size of 60000\n", + " print(\"Accuracy with training data size of 60K \\n\", reg.predict(60000) * 100)\n", + " \n", + " # Scaling accuracies to get more reasonable predictions\n", + " accuracies_re = np.copy(np.array(accuracies))\n", + " mx = np.max(accuracies_re)\n", + " mi = np.min(accuracies_re)\n", + " \n", + " # print(accuracies_re)\n", + " \n", + " for i in range(len(accuracies_re)):\n", + " accuracies_re[i] = (accuracies_re[i]-mi)/(mx-mi)\n", + " \n", + " # print(accuracies_re)\n", + " reg.fit(train_sizes_re, accuracies_re)\n", + " \n", + " pred = reg.predict(60000)\n", + " \n", + " # Normalizing the prediction like we did for accuracies\n", + " # print(pred)\n", + " print()\n", + " print(\"Accuracy with training data size of 60K with normalized input \\n\", (pred-mi)/(pred-mi) * 100)\n", + " \n", "### STUDENT END ###\n", "\n", - "#P4()" + "P4()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: The accuracy prediction (form the linear regression without any transforms) is 1.243 or 124. This is obviously not what we expected (We're expecting the accuracy to stay within the 100% bounds, i.e. the predictions to be in the range [0, 1])\n", + "\n", + "Can we do a transform to make the predictions more reasonable? Yes, I think we can normalize \"accuracies\" used for training to get more reasonable predicdtions. The predication before normalization is 124%. After its close to 100% as that's the max of the accuracies" ] }, { @@ -242,20 +507,97 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 207, "metadata": { - "collapsed": false + "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Confusion matrix:\n", + "\n", + "[[ 97 0 0 0 0 0 2 0 0 0]\n", + " [ 0 105 0 0 0 0 0 0 0 0]\n", + " [ 4 4 81 4 0 0 0 4 3 2]\n", + " [ 1 0 0 75 0 3 0 3 1 3]\n", + " [ 0 2 0 0 85 0 3 0 0 14]\n", + " [ 2 0 0 9 0 76 0 1 1 2]\n", + " [ 1 1 1 0 1 0 94 0 0 0]\n", + " [ 1 4 0 1 1 0 0 104 0 2]\n", + " [ 0 2 0 5 0 2 1 0 84 2]\n", + " [ 1 0 0 3 9 1 0 5 0 87]]\n", + "\n", + "\n", + "The most confused digits with the predicted digit as title\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#def P5():\n", + "def P5():\n", "\n", "### STUDENT START ###\n", "\n", + " # Starting a 1-NN model #\n", + " knnModel = KNeighborsClassifier(1)\n", + " \n", + " # Fitting with training data\n", + " knnModel.fit(mini_train_data, mini_train_labels)\n", + "\n", + " # Try on the development set and time the operation\n", + " predictions = knnModel.predict(dev_data)\n", + " \n", + " # Confusion matrix\n", + " dig = [i for i in range(10)]\n", + " sc = confusion_matrix(dev_labels, predictions, labels = dig)\n", + " # Printing the matrix natively\n", + " print(\"Confusion matrix:\\n\\n%s\" % sc)\n", + " print()\n", + " \n", + " # 4 & 9 seem to be the most confused digits #\n", + " \n", + " # printing 8 examples of 4 & 9 labeled as each other #\n", + " count = 0\n", + " print()\n", + " print(\"The most confused digits with the predicted digit as title\")\n", + " print()\n", + " \n", + " # We'll walk through the all the labeled in dev_data #\n", + " for i in range(len(dev_labels)):\n", + " # We only care about those where labels do not match predictions #\n", + " if dev_labels[i] != predictions[i] and (dev_labels[i] == 4 or dev_labels[i] == 9):\n", + " devp = dev_data[i].reshape(28,28)\n", + " count = count + 1\n", + " if count > 8:\n", + " break\n", + " # plot this as an example #\n", + " plt.subplot(4, 4, count)\n", + " plt.axis(\"off\")\n", + " plt.title(predictions[i])\n", + " plt.imshow(devp, aspect = \"auto\", cmap = plt.cm.gray_r, interpolation = \"nearest\")\n", " \n", "### STUDENT END ###\n", "\n", - "#P5()" + "P5()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ANSWER: 4 & 9 Seems to be the most confused digits in the dev_data. The images above show why. " ] }, { @@ -274,27 +616,142 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": false - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "#def P6():\n", + "def P6():\n", " \n", "### STUDENT START ###\n", "\n", + " # Function to recalculate the value of a pixel from its 8 neighbors #\n", + " # We'll take an image (One dimentional array) as the input and return one that's been blurred\n", + " def gBlur(image, debug = False):\n", + " \n", + " # basic validation of the image. Is the array empty? #\n", + " if (len(image) == 0):\n", + " print(\"Error: We've got an array of lenght 0\")\n", + " return image\n", + " \n", + " # Print the input image for debugging #\n", + " if debug:\n", + " plt.subplot(1, 2, 1)\n", + " plt.imshow(image)\n", + " \n", + " # Making an empty numpy array to hold the retun value\n", + " newImage = np.empty((28, 28))\n", + " \n", + " # Now lets start walking through each pixel #\n", + " for i in range(len(image)):\n", + " for j in range(len(image[i])):\n", + " \n", + " # Now we have the pixel. Lets assume there's 8 around it #\n", + " # For the edges the pixels will wrap around, i.e we'll have negative indices #\n", + " \n", + " # Extracting a sub array to do the sum\n", + " subArray = image[i-1:i+2, j-1:j+2]\n", + " bFactor = (np.sum(subArray))/9\n", + " \n", + " # Replace the pixel with the new value #\n", + " newImage[i][j] = bFactor\n", + " \n", + " # print the output image for debugging #\n", + " if debug:\n", + " plt.subplot(1, 2, 2)\n", + " plt.imshow(newImage)\n", + " \n", + " return newImage\n", + " \n", + " #gBlur(mini_train_data[0].reshape(28,28), debug = True)\n", + " \n", + " # Function to apply the blurring to an array of images\n", + " def gBlurArray(imageArray, debug = False):\n", + " \n", + " # basic validation of the image. Is the array empty? #\n", + " if (len(imageArray) == 0):\n", + " print(\"Error: We've got an array of lenght 0\")\n", + " return imageArray\n", + " \n", + " # Creating an empty array for returning\n", + " newArray = np.empty(imageArray.shape)\n", + " \n", + " # Walking through the input image array and applying blur on each image\n", + " for i in range(len(imageArray)):\n", + " newArray[i] = gBlur(imageArray[i].reshape(28,28), debug = False).reshape(28*28)\n", + " \n", + " if debug:\n", + " # Print the before an after for one image from the array\n", + " plt.subplot(1, 2, 1)\n", + " plt.imshow(imageArray[300].reshape(28,28))\n", + " \n", + " plt.subplot(1, 2, 2)\n", + " plt.imshow(newArray[300].reshape(28, 28))\n", + " \n", + " return newArray\n", + " \n", + " # gBlurArray(mini_train_data, True)\n", + " \n", + " # Function to run knn model with training and dev data\n", + " def modKnn(train, trainLabels, dev, devLabels):\n", + " \n", + " # Create the knn model.\n", + " knnModel = KNeighborsClassifier(1)\n", + " \n", + " # Fit the model on mini training set\n", + " knnModel.fit(train, trainLabels)\n", + "\n", + " # Try on the development set\n", + " predictions = knnModel.predict(dev)\n", + " \n", + " # 2 metrics to get an idea of accuracy: Mean Squared Error and model score\n", + " \n", + " # Mean Squared error and accuracy \n", + " meanse = (((predictions - devLabels) ** 2).sum()) / len(predictions)\n", + " sc = knnModel.score(dev, devLabels)\n", + " \n", + " # Print the MSE and accuracy for a value of K\n", + " print(\"The Mean Square Error for K = \", 1, \" on the dev data set is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " \n", + " # Knn model without any preprocessing on data\n", + " modKnn(mini_train_data, mini_train_labels, dev_data, dev_labels)\n", + " \n", + " # Lets do the model with preprocessing on the training data\n", + " modKnn(gBlurArray(mini_train_data), mini_train_labels, dev_data, dev_labels)\n", + " \n", + " # Trying the same with preprocessing on dev data\n", + " modKnn(mini_train_data, mini_train_labels, gBlurArray(dev_data), dev_labels)\n", + " \n", + " # Trying with preprocessing on both training and dev data\n", + " modKnn(gBlurArray(mini_train_data), mini_train_labels, gBlurArray(dev_data), dev_labels)\n", "\n", "### STUDENT END ###\n", "\n", - "#P6()" + "P6()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: There difference in Mean Square Error and accuracy with varying level of preprocessing\n", + "We get the most accuracy and smalles MSE by preprocessing the training data \n", + "\n", + "NO preprocessing\n", + "The Mean Square Error for K = 1 on the dev data set is 2.119\n", + "The accuracy is 88.8 %\n", + "\n", + "Preprocessing the training data\n", + "The Mean Square Error for K = 1 on the dev data set is 1.711\n", + "The accuracy is 90.9 %\n", + "\n", + "Preprocessing dev data only\n", + "The Mean Square Error for K = 1 on the dev data set is 2.504\n", + "The accuracy is 87.1 %\n", + "\n", + "Preprocessing both dev and training data\n", + "The Mean Square Error for K = 1 on the dev data set is 1.802\n", + "The accuracy is 90.3 %\n" ] }, { @@ -306,28 +763,125 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 208, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "The Mean Square Error on the dev data set with Bernoulli NB is 3.027\n", + "The accuracy is 81.5 %\n", + "\n", + "The Mean Square Error on the dev data set with Multinomial NB is 3.382\n", + "The accuracy is 79.4 %\n", + "\n", + "The Mean Square Error on the dev data set with Multinomial NB (features in a {0, 1, 2} set) is 3.255\n", + "The accuracy is 79.4 %\n" + ] + } + ], "source": [ - "#def P7():\n", + "def P7():\n", "\n", "### STUDENT START ###\n", "\n", - "\n", + " # Create the model\n", + " BNbModel = BernoulliNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " BNbModel.fit(mini_train_data, mini_train_labels)\n", + " BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = BNbModel.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = BNbModel.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print()\n", + " print(\"The Mean Square Error on the dev data set with Bernoulli NB is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " \n", + " # Doing the same with MultinomialNB without any transforms\n", + " \n", + " # Create the model\n", + " MNbModel = MultinomialNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " MNbModel.fit(mini_train_data, mini_train_labels)\n", + " MultinomialNB(alpha=1.0,class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = MNbModel.predict(dev_data)\n", " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = MNbModel.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set with Multinomial NB is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " # Function to transform pixel values\n", + " def tr(imageInput):\n", + " image = np.copy(imageInput)\n", + " for i in range(len(image)):\n", + " if image[i] == 0:\n", + " continue\n", + " if image[i] < .75:\n", + " image[i] = 1\n", + " continue\n", + " if image[i] > .75:\n", + " image[i] = 2\n", + " return image\n", + " \n", + " # Function to apply 0, 1, 2 transform to data array\n", + " def trArray(imageInputArray):\n", + " imageArray = np.copy(imageInputArray)\n", + " for i in range(len(imageArray)):\n", + " imageArray[i] = tr(imageInputArray[i])\n", + " return imageArray\n", + " \n", + " # Repeating the Multinomial model\n", + " # Create the model\n", + " MNbModel1 = MultinomialNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " MNbModel1.fit(trArray(mini_train_data), mini_train_labels)\n", + " MultinomialNB(alpha=1.0,class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = MNbModel1.predict(trArray(dev_data))\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = MNbModel1.score(trArray(dev_data), dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set with Multinomial NB (features in a {0, 1, 2} set) is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " \n", "### STUDENT END ###\n", "\n", - "#P7()" + "P7()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: The multinomial function improves the results by just a little bit\n", + "The accuracy with binary and multinomial function is about the same ~79%\n", + "The Mean Square Error with Multiclass reduces from 3.382 to 3.255\n", + "\n", + "The improvement is not dramatic due to he nature of the features. The binary transform already captures most of the difference among the features" ] }, { @@ -341,40 +895,139 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n", + " 'setting alpha = %.1e' % _ALPHA_MIN)\n", + "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n", + " 'setting alpha = %.1e' % _ALPHA_MIN)\n", + "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n", + " 'setting alpha = %.1e' % _ALPHA_MIN)\n", + "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n", + " 'setting alpha = %.1e' % _ALPHA_MIN)\n", + "/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/naive_bayes.py:472: UserWarning: alpha too small will result in numeric errors, setting alpha = 1.0e-10\n", + " 'setting alpha = %.1e' % _ALPHA_MIN)\n" + ] + } + ], "source": [ - "#def P8(alphas):\n", + "def P8(alphas):\n", "\n", "### STUDENT START ###\n", "\n", + " #GridSearchCV to perform a search over values of alpha \n", + " #(the Laplace smoothing parameter) in a Bernoulli NB model.\n", + " \n", + " # Create the model\n", + " BNbModel1 = BernoulliNB()\n", + " \n", + " # Setting the parameters under consideration\n", + " pTune = [alphas]\n", + " \n", + " # Some test code\n", + " # BNbModel1.fit(mini_train_data, mini_train_labels)\n", + " # BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n", + " \n", + " # Tuning alpha\n", + " GS = GridSearchCV(BernoulliNB(binarize=0.0), pTune, cv=5)\n", + " GS.fit(mini_train_data, mini_train_labels)\n", + " \n", + " # Some play and test code\n", + " # means = GS.cv_results_['mean_test_score']\n", + " # stds = GS.cv_results_['std_test_score']\n", + " \n", + " #for mean, std, params in zip(means, stds, GS.cv_results_['params']):\n", + " # print(\"%0.3f (+/-%0.03f) for %r\"\n", + " # % (mean, std * 2, params)) \n", "\n", - "\n", + " # actuals, predictions = dev_labels, GS.predict(dev_data)\n", + " # print(classification_report(dev_labels, dev_data))\n", + " # print()\n", + " \n", + " return GS\n", + " \n", "### STUDENT END ###\n", "\n", - "#alphas = {'alpha': [0.0, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0]}\n", - "#nb = P8(alphas)" + "alphas = {'alpha': [0.0, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0]}\n", + "# Replacing the array to remove some runtime warnings on processing of 0 and small values #\n", + "# Using the original though as the Q is about alpha = 0\n", + "# alphas = {'alpha': [0.00001, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0]}\n", + "nb = P8(alphas)" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For best score {'alpha': 0.0001}\n", + "\n", + "All scores\n", + "\n", + "0.810 (+/-0.034) for {'alpha': 0.0}\n", + "0.823 (+/-0.042) for {'alpha': 0.0001}\n", + "0.823 (+/-0.039) for {'alpha': 0.001}\n", + "0.819 (+/-0.044) for {'alpha': 0.01}\n", + "0.819 (+/-0.043) for {'alpha': 0.1}\n", + "0.817 (+/-0.045) for {'alpha': 0.5}\n", + "0.817 (+/-0.048) for {'alpha': 1.0}\n", + "0.812 (+/-0.047) for {'alpha': 2.0}\n", + "0.786 (+/-0.054) for {'alpha': 10.0}\n" + ] + } + ], "source": [ - "#print nb.best_params_" + "# Best parameter (alpha)\n", + "\n", + "print(\"For best score \", nb.best_params_)\n", + "print()\n", + "\n", + "# Finding scores for all values of alpha\n", + "means = nb.cv_results_['mean_test_score']\n", + "stds = nb.cv_results_['std_test_score']\n", + "\n", + "print (\"All scores\\n\")\n", + " \n", + "for mean, std, params in zip(means, stds, nb.cv_results_['params']):\n", + " print(\"%0.3f (+/-%0.03f) for %r\" % (mean, std * 2, params)) \n", + "\n", + " # actuals, predictions = dev_labels, GS.predict(dev_data)\n", + " # print(classification_report(dev_labels, dev_data))\n", + " # print()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER:\n", + "\n", + "What is the best value for alpha? .0001\n", + "\n", + "What is the accuracy when alpha=0? 81%\n", + "\n", + "Is this what you'd expect? Yes, we'll expect smoothing to increase the accuracy by a small % as is visible from the results below\n", + "\n", + "0.810 (+/-0.034) for {'alpha': 0.0}\n", + "0.823 (+/-0.042) for {'alpha': 0.0001}\n", + "0.823 (+/-0.039) for {'alpha': 0.001}\n", + "0.819 (+/-0.044) for {'alpha': 0.01}\n", + "0.819 (+/-0.043) for {'alpha': 0.1}\n", + "0.817 (+/-0.045) for {'alpha': 0.5}\n", + "0.817 (+/-0.048) for {'alpha': 1.0}\n", + "0.812 (+/-0.047) for {'alpha': 2.0}\n", + "0.786 (+/-0.054) for {'alpha': 10.0}\n", + "\n", + "\n" ] }, { @@ -388,27 +1041,115 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Mean Square Error on the dev data set is 6.441\n", + "The accuracy is 62.1 %\n", + "\n", + "Model parameters\n", + "{'priors': None}\n", + "\n", + "The Mean Square Error on the dev data set 5.374\n", + "The accuracy is 62.8 %\n", + "\n", + "\n", + "The Mean Square Error on the dev data set is 5.998\n", + "The accuracy is 63.6 %\n" + ] + } + ], "source": [ - "#def P9():\n", + "def P9():\n", "\n", - "### STUDENT END ###\n", + "### STUDENT START ###\n", "\n", + " # GaussianNB\n", + " # Create the model\n", + " GNbModel = GaussianNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " GNbModel.fit(mini_train_data, mini_train_labels)\n", + " GaussianNB(priors = None)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = GNbModel.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = GNbModel.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " \n", + " # The accuracy on dev. data is ~62%. Trying to figure out what's going on\n", + " \n", + " # Checking the parameters\n", + " print()\n", + " print(\"Model parameters\")\n", + " print(GNbModel.get_params(deep = True))\n", + " print()\n", + " \n", + " # Changing the feature values to increase accuracy\n", + " \n", + " # Binary feature values\n", + " # Copy the training data\n", + " miniTr1 = mini_train_data.copy()\n", + " \n", + " # Replace with 0 and 1\n", + " miniTr1[miniTr1 < .5] = 0\n", + " miniTr1[miniTr1 >= .5] = 1\n", + " \n", + " # Trying out the model\n", + " \n", + " GNbModel1 = GaussianNB()\n", + " GNbModel1.fit(miniTr1, mini_train_labels)\n", + " GaussianNB(priors = None)\n", + " predictions = GNbModel1.predict(dev_data)\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = GNbModel1.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " # Trying to make the prediction with modified dev_data\n", + " dev1 = dev_data.copy()\n", + " dev1[dev1 < .5] = 0\n", + " dev1[dev1 >= .5] = 1\n", + " predictions = GNbModel1.predict(dev1)\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = GNbModel1.score(dev1, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print()\n", + " print(\"The Mean Square Error on the dev data set is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", "\n", "### STUDENT END ###\n", "\n", - "#gnb = P9()" + "gnb = P9()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: \n", + "\n", + "The Mean Square Error on the dev data set is 6.441\n", + "The accuracy is 62.1 %\n", + "\n", + "The accuracy with Gaussian Naive Bayes is ~20% less than with Bernaulli \n", + "\n", + "The accuracy seems to increase by categorization (0,1) on both training and dev data, but not by much (~1% to 63.6%)\n", + "\n" ] }, { @@ -423,27 +1164,102 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Mean Square Error on the dev data set is 3.027\n", + "The accuracy is 81.5 %\n", + "\n", + "The shape of the probability estimates/class array\n", + "(10, 784)\n", + "\n", + "The generated digits\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD8CAYAAABjAo9vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzsvXd0VOXa8P3LZCa9V1rCAAk10hUp0kUfQJroEbGA6GMBFD3HCtZDVfFIkaIiNoogUqUICALSOyQkJCSB9N4nmcnM7PcPvLf37NnBc971ffqus3KtlZVJZu9rX+2+2l22h6IoNEIjNEIjNMJ/Dxj+agIaoREaoREa4f9baHTsjdAIjdAI/2XQ6NgboREaoRH+y6DRsTdCIzRCI/yXQaNjb4RGaIRG+C+DRsfeCI3QCI3wXwaNjr0RGqERGuG/DBodeyM0QiM0wn8ZNDr2RmiERmiE/zIw/pkPUxRF8fDwwOFw4OnpiaIoOJ1OPDw8EDtgxf/F3waDGns8BA55t6yHh4fAjcFgUO8Tfwv8v12n4hD3Op1OFY+iKC6/BW5AxqPiEPeL68S92vu1eH+jQ9FeK2iXnyvLQpKHGx8yLlkWMk6ZX4PB4MKHw+HQk5fL/RL9OJ1OPD09PX77rCiKgqenJ06nU9WZ0+lU75H/J/Mry1Pcq9WvwCF/L/MjeBEiEf8XcmhIPoJn2TYARdaZrF+tLLW7tvVsQ/CttWk9vcrycDqdinydFo9WnjLNv+FQxPfyveJvWUZaXoReBR+yLiV5ueAU41ZPJ3r3au1NfJb1L8tCyF37LFkmMl1a+5JxyN/ryVLH1lxsQ5a5DFofJNuPjEPGrX2mxhZcvvfQe2gD8Kdm7DLDDocDuOnIAd0BoCgKDodDvVbcKytHfNY6JYFPa4jiPqfT6WZU4K40Wfl6/5cVonVaTqcTh8PhFjRkOuRna41TlldDfIjnyjKT7xdyaChgaQOB1gnI/Mi0Cr3Jz9EarMFgwNPT00VGMo1aWkVgkG1AGxz05CODuFcbMOVnyg5CS5usC9kJavUh61XrpGU8sg2I64U9y7qRbVx8pw1G8sDXXqe1DVl/8mdtUBH8ybqSweFwuAVIwZOgXZah4FWmQ8Ytjyehc+0Y0OpWlrHMu17SodW3FuQxKGSitU3xveBdloUcKOWxpLWbWwVC+dky/+KzdtzKv/9d+FMdu2zAsgOor69XCbfb7S7XiB8BehmywFtTU6MK1G63u9wjgzAoWcni7/r6eiwWC3V1ddjtdhejkvFos0DxU1dXh8ViUWmQI7jsgIXyxbMFz3a7nZqaGjcHJe7VGqEcyOSAZrfb1QEoDxw9ByBA4BB8VFVVuQxUmRZtsJXxCeOvrq6msrJS/VuTIbs9Ww4GQh8eHh5UVVVRXV3toks5oGt50QYwDw8PbDYbVqtVlbueMxHXam1UURQsFgsGgwGLxYLVanXJGmUaZH60vAk6tI5VL+AKWrTJi81mo7Kykvr6egDq6+tdnMEfOTS73U5tba36t8CjFzS0zlIO+p6enqqdy/oUchEgbEW2d2FDdXV1wO+22pATEzYhjx3BuxgXcgdAq1OZF9lGxLhzOp3U1ta60Kfne4TjlWkUuqytrcVqtWK1Wl3GEeAyVvSCpNCDoEPoqSG7+HfgT23FaMuouro6SkpKWLt2LTU1NZhMJn7++We++eYbLly4wPDhw91wyA4AbgoqOzubX375hdjYWObPn8/777/PqlWrGDx4MCNGjHAJAIIO8T+RJRYUFHDw4EG8vLyIjo6mT58+fPXVV0RGRjJy5MgGyy8BlZWV+Pr6UlxczJUrVwDw9fXl22+/ZcKECfTu3RsvLy8X45Hpqaurw+FwcP36dXJycnjrrbf4+uuvKSsro1evXtTX12MymVyeqa0ErFYrdrud/Px8PvjgA9q0acP69es5ePAgFy9epHfv3m5ZmdbBlJSUcP36dc6cOYOfnx/FxcUoisJzzz1HcXExoaGh+Pn5uTllmSZPT08uXLhAUVERO3fu5LHHHuPQoUPcd999FBYWcvvttwOuWb+cAQpjLyoq4qeffuLAgQPk5eXRvn17hg0bhtlspkOHDm56lSsH4aCrq6upqanhwIED7N69m3bt2uF0OnnuuecIDQ1VnynTL/gRNOXk5HDy5ElOnjzJ2LFjefnll5kzZw4Gg4Hbb78dHx8fN9uQbdThcFBaWsrq1avx9fWlX79+tGjRgpUrVzJjxgwMBgPe3t5uvIjfYqw4HA62bdvGmTNnGDp0KF999RWtW7fm0UcfJTY2Fn9/fxfnKGejVqsVk8nE9u3bOX78OFFRUdTV1fHaa6/x448/MnjwYJUPrTyEHGpqagDYuHEjY8aMoV+/fixbtowBAwZw9uxZbrvtNpUP+X7ZTkpLS0lNTSUjIwMvLy/uvvtuVqxYQa9evejXr59L5qq1UTFWa2pqSEpKomvXrpw/f5633nqLoUOHcu3aNUaMGEG/fv0ICAhw0Yc2E66srKSkpIRNmzYRFxdHSEgIzZs3Z+XKlfTv35+hQ4fi7+/voketfkVL+auvvqJPnz4UFRXh4+ND586d+fnnn+nXrx9+fn66FZYAi8WCv78/8+bNIzs7m/vuu49Nmzbx8ccfk5iYSM+ePfH19W2QjobgT8/YBVM2mw0PDw9CQ0Np2bIlCxcupLS0lJiYGD755BNCQ0PdsjTxWQjHbrdz48YNwsPDKSoq4tdff2X06NHcdtttKIpCaGgoJSUlbtFbGI4w2uLiYpKSkvDy8qJ169asWrUKf39/Bg8ejNVqJS8vz40XbRlYUVFBUlISx48fZ+rUqXh5efHyyy9z+fJlunTpokZivYELUFxczLp166ioqCA9PZ1169YxdOhQfH19OXXqFOXl5erzZBpk3qqrqzly5AgZGRmqM3juueew2+20a9dOHRiyPLXG4uvrS4cOHQgPD6e0tJSrV6/yxhtvcODAAX799VdKSkrc6BB6ERlpcXEx0dHRBAUF8eyzz5KQkMDs2bNp0aIFFouFyspKt+pD6EUMPpEV/+1vf6Nt27Zs2LCBNWvWsGzZMlJSUsjKynK7X9syMhgMpKen8+qrr+Lj48P+/fvJzs5m8+bNaoakzcrktoXT6aS8vJzy8nJ27dqF3W6nU6dOJCUlceXKFbKysnRbMXJmWV9fT01NDZs3b8Zut7N3714qKir48ssv2bhxI99//72aQWsdqlzF5uTk4HQ6SUlJYfTo0ezbt48uXbowd+5c0tLSXAKaeLasY6fTSUVFBf/zP/9DcXExy5Yt48033yQvL4+amhqXLF4rTxHsKioqWLVqFePGjWPTpk2sXLmSjIwMampquHr1qm4Vpa2qhUzj4uJ4/vnn2b17N7m5ubRr146rV6+qdq5XechJUVxcHCdOnOD1118nIiICm83G008/jaIoqt/Q40X81NfX88svvzB9+nTq6uoYPHgwy5YtY+zYsbRp04bKyko3HLJM7XY71dXVrF27lokTJ/Luu+8yc+ZMli5dSmlpKbGxsfj5+elm3EIeolLZs2cPTz75JIWFhdx7773Mnz+f4cOHk5SU5JL8/Cfwl6yK8fDwwGKxsGvXLsaPH0+nTp1Yu3YtDoeDQ4cO4eXlxTvvvKMOPj0nIlo25eXlVFdXM2rUKC5cuECnTp349NNPuXbtGgD5+fluBisPRKvVSmhoKAaDgU8++YSMjAxOnTrFqFGjMJvNxMTEEBkZ6VK6Cx4EWCwWTCYTubm5zJkzB5vNRkJCAhs2bODVV19l27ZtLq0FrSwAKioqmDBhAmfPnmX+/PlMmzaNxYsX4+HhQUREBElJSQ3260TbKSkpiXvuuYeoqCh+/fVX1WDPnDnD119/TXFxsZsjg5sDsb6+nsrKSs6cOUN6ejo7duygd+/emM1mdu7cyZgxY1i4cCFNmjRxc2Ryq6WmpgYvLy/efvttnn/+eYKDg5kwYQKHDx+mffv27Ny5k8uXL7vRIGfqNpuN7OxsRo0axdixY5k6dSq9evXip59+Iicnh6FDhxIcHKxbQYlBW15ezrZt22jSpAl5eXk0b96cBx54gPbt25ORkUF+fj5Xr151C3TaVlleXp5a8bRs2ZKhQ4fy9NNPk5qaSvPmzXVbXELGdrsdo9HIvn37KC0tZezYsXz77bfY7XZefPFFKisrmTRpEtnZ2W6ZnHi+sHUfHx/effddNmzYwOXLl9m1axfFxcUsXLiQVq1akZiY6GLnAp/D4aCyspIDBw5QU1PDnXfeyeDBg3n44Yf57rvvKCsrY/PmzbpZoXDodrudwsJCFEWhf//+LF68GIvFQkpKCmfPnsXb25t169Zx8uRJl+RF4BDOSVTIgYGBlJWVsWnTJk6fPs24ceNITU1l1apVuo5Mbm3YbDY2btzIlStXePTRR4mPj6dZs2aEh4fz8MMPk5ycTGFh4S3br2VlZRw5coTr169z/fp1cnNzycrKYvz48YSFhfH111+r1bGejdlsNiwWC8HBwdxxxx2MHj2anTt38s9//pPQ0FBOnTrFP//5T86ePet2r9wGlMd+UFAQp06dYsWKFbz66qucPHmSQ4cOcf78+QbpuBX8qY5dGJvNZiMwMJDAwEBuv/12fv31Vz766CPuvfderl69ysWLF5k8eTIpKSmAe6ksjCUjI0MNBlOnTqVdu3acOnWK0tJSBg0axIkTJ1THrgVh9PX19axfv560tDTuvvtu9u7dS9u2bZk7dy7FxcWcPn2avLw81TD0+BGZclpaGqtXr+bjjz9m0aJFfPTRR1y6dIlevXqpgUbuZYpBe/nyZQICAli/fj0tWrQgMzOTZcuWYbFYyMnJYcWKFXTr1s3NoQqDNxqNFBYW0qRJEz777DOysrKYN28eycnJ/PTTTyQnJ9O3b18iIiJ0s0u51x8YGIi3tzfJyckkJCSo8vzmm2+oqKhg165dutmlyJSLioo4deoUjz76KJs3b8ZmsxEUFMSqVav48MMPiYqKIicnx6UsFjjk/jrA0aNHGT9+PHV1dSQkJNCxY0eSk5OZNGkSaWlpbjqVJztNJhOXL19m27ZtTJ48mZ9++gm73U5eXh49evRg586dxMXFufXI5b52eno6UVFRrFq1ihYtWhAbG8tzzz3HrFmzGD58ON999x0//vijW/UhPptMJvLy8iguLuZ///d/+fDDD9UWwYcffsiECRMYNmwYBQUFbg5RlmtmZibHjx+nT58+3HvvvQwbNoxz585RWFhIVVUV8HsFrO39AhQWFpKZmck777yjyiY9PZ3t27fTrl07xowZw549ewDXfrA8H+Hv789nn33Gm2++SX19Pd9//z07duwgLi6OjIwMXn31Vbp16+bS/pFtTFEUkpOTmTt3LrNnz2bXrl1qJfXdd98xbdo0Lly4QEVFhZt9ycHXarUyfvx4EhISaNasGXPmzGH79u2kpaWRmZlJ586dSU1N1e2xi/FeUVHB2bNnsVgsxMfHExISgslkIjk5mdGjR6uJnp5OAIxGIw6Hg++++47nn3+eF198kVdeeYWtW7fSrVs3unTpQkZGBgEBAbo6FfNWubm5nDhxgujoaNavX8/UqVMxm800bdqUESNGkJiYSI8ePdT7/hP4U3vscFPAJpOJLVu24HQ6WbFiBevXr2fz5s0oikJKSoqa5Z08edIts5MnFFJSUvj111/5+9//Tt++fcnKysJoNNK8eXMWLlzIuXPnmDFjBna73cUpy4P30qVLKi133nknL730kpr1HT58mF69eqklU0NlkY+PD6dPn2bPnj0YjUb8/Px45plnuHDhAkajkW3btnHffffptmI8PT2pqalhx44drF+/nm+++YaioiKsVitms5nk5GRycnKoqqoiJCREN1NWFIXU1FTy8/O5du0abdq0wcvLiy+//BJfX18+/vhjiouLsdlsLo5TlqfRaMRqtbJ8+XLOnTvHlClT8PHxYf78+WRnZ7Nq1Sq8vb2xWCzqpLBezy8iIoLjx4+zZMkSjh07xoEDB3jjjTfw8fHh3Llz7N69mzfeeMNllYZMi6IonDlzhh07dnDq1Cm2bdvG4cOHmTlzJna7nQkTJlBcXEyPHj2w2Wx4eXm56FXgPXr0KG3btuXbb7+lX79+dO3alb59+3L69GmKioowm82sW7eOiRMnuuCQdRQXF8eCBQtYs2YNK1asoGXLllgsFq5evUplZSXl5eXExMQ0GOjgZnvs4sWLnD17llWrVlFdXY3RaGTgwIG0aNGCI0eO0Lt3b+rr613oELQYjUacTiexsbEkJCQwZMgQsrOzuXDhAn/7298oLi6msLCQNm3auCQNggaTyURcXBwPP/wwc+fO5YUXXqBv377cdddd2Gw2jEYjI0aMYM6cOYwdO9bl+dp+fXh4ON27d6dz584MGDAAb29vzGYzH3/8Mdu3byc5Odkt65crGpvNRrt27XjxxRcpLCzk5Zdf5tq1a1RVVdG5c2eSk5MpKyvDbDa74BG/nU4nv/zyCwEBAZSWlrJ161b27NnDxo0bKSgoICkpidatW3PixAldxy5asNeuXWP48OGEhYXx5Zdf4u3tjdFo5I477uC+++5j2rRpfPLJJ/zjH/9wqThk+wgMDGTw4MG8/fbbtGzZkt69e3Ps2DGMRiPr1q0jJSWFjz/+mGXLlrnZuFyd7dy5k4cffhiAmTNnUlFRwZgxY1i2bBnjxo0jOztbtbH/Z3vsgqn6+nq6du1Kp06dVAP39/cnMDCQVq1a8dJLL3HmzBlWr16t3qcSLDHXv39/Bg8ezIQJE1AUhZiYGHVSbeTIkZhMJioqKtwcstzn79atG5WVldTW1jJhwgRqa2tp2bIlkZGRNG/enCNHjqjRXg/EPMHly5fx8vKisLCQsWPHYjQa6dq1K4qicPjwYZYvX+6yUkfw4nA4iI6O5vHHH+fTTz+lpqYGT09PAgICaN++PTU1NWRnZxMYGOiyqkYL2dnZFBUVkZubS3x8PC1btqS8vJz09HQyMjJYunQpVVVVun1puDloMjIy6NWrF0uXLqVfv36Ul5cTEBBAeHg4b775JnPmzNFdPSHA6XRis9m4fv063t7eFBUV0aNHD4xGI5GRkZSXl3P27FnS09N1M2Uh5wMHDpCSkkJycjLfffcdffr0oU2bNtjtdpYuXUqHDh3Yv3+/+kwtKIpCp06d1JbelClT6NGjB97e3sTFxfHWW2/RuXNnunTp4tZiE/fbbDbsdjvNmzcnICCAhx56iDZt2tCxY0c6duzIgQMHuPfee9WVIXo9dg8PDxITEyktLWXKlCksWLCAGzduYDabiY+P59NPP+XKlSv4+PioDly2DYErIiKCxMRETp48SUlJCQaDgS5dujB06FCaNWtGkyZN2L59u1sVJNoo6enpbNmyhSVLltC2bVscDgdRUVE0bdqUp556ipycHBwOh5t9yj3z1atXc/ToUd544w26d+9Oly5diI+PR1EUXnnlFQICApg1a5buOBGrebKzs1m8eDH3338/QUFB+Pj4EBsby+DBgyktLeXll1/WrebEskOr1YqiKPTt25dly5YBN31AeHg4QUFBTJkyhX/9618MHDjQbZzIQb9///5kZ2erPf+hQ4fi4eFBu3btGDBgAP3792fAgAFuTl0O2OvWreOHH35g+fLlNG/enPPnz9O9e3d69OhBy5Ytueuuu5gyZYpbG1iAzWYjMTGRDz74gE2bNnH//fer83A2m42nnnoKPz8/Kisr/+NsHf4Cxy4UdPnyZXJzc9XyQwi5oKCAuro6Lly4oGYVeoOmtraWNWvWMGPGDL755huys7Px8/PD29ubwsJCdQDl5uZitVrdMiqA8vJypk+fzpEjRxg2bBiVlZV07NgRg8FASkoKISEhdOnShcTERN0MQKzcmD59OmazmSeffJK7774bo9GoOuLLly/zxRdfcP/992MymdxKzNLSUsLCwrDZbDRr1kxdEhgWFobBYOCee+7BbrerrRytQ3U6nZSVlXHu3Dl++OEHJk2aRHl5OYGBgURGRtKyZUtmzZrF+++/z8aNGzEa9Yu0qqoqvL29OXjwIHv37qW0tFQNMGVlZRiNRhISEigsLFSfK9Mg+NqxYwcjRoxgxowZ5ObmEhYWRlRUFFevXiU+Pp7BgwczbNgw3aV5wjbuvPNOnn76ab755htiY2PVpWiHDx9m165d9OzZE39/f7VyECAvRSsrK2Py5Ml8++23XLp0iYCAAPz8/HA4HMycOZMnn3xSbWNo5y1E0Ll8+TJz584lKSmJpk2bYjKZ8PLyIjMzkzfeeIMOHTrQoUMH3TXoAGVlZSQnJ/PSSy/RtGlThg0bRps2bWjWrBlnzpyhbdu2TJs2Tc1mtXo1GAxUVVWxbds2SkpKaNasGQUFBbRo0QJFUaiqqiIlJYU9e/ZQVFTklimLNmFYWBj33XcfVquVZs2a0axZM+x2O6mpqUyfPp1z587x+OOPYzQadScLy8vLadasGdu2bSMlJYUWLVoQHh6uttX27t1Lhw4d8Pf313WoDoeDsrIyqqur2bp1K7t378bhcBAcHKwukhg2bBjjxo0jJSUFq9XqhkMkDVarlZUrV7Jw4ULS09Np0qQJwcHBREREUFlZyYkTJ/j+++8bTGBqamrYvXs3q1atYs2aNXTv3h1fX198fX05e/YsPj4+tGvXTm0J6eEoKCigR48eJCcnc+HCBQICArjjjjsICwsjOTmZcePGqYFaL9CJBGb79u1kZGTg7e1NXl4eBoMBLy8vTpw4wYcffoiPjw+1tbVu9/878JdMnirKzSWKixYtIjw8HIfDgbe3N15eXvj7+9OzZ08WLVpEbW2tW3kqhOvp6Ulubi4PPPAAxcXF9OzZk+DgYCwWCzabjbNnz2IwGEhMTGyQhsDAQKqqqoiNjSU7O1vtuYp+5ebNm5k/fz6JiYluRi/KU9Gba9++PQ899BC9e/fGx8cHHx8fKisr8ff3Jzw8nPPnz1NfX++2plVRbq6RXrNmDVevXuXOO+8kNDQUHx8fTCYTdrsdq9VK586d1Xu0ILLONm3acPXqVaKjowkICMDX15cjR47w+uuvk5GRwaOPPuq26ULQYDAYeOGFF1T+e/Xqha+vL15eXrRo0YJPP/0Up9PJuHHj1LXPWp3U1tZy+fJlfvzxRy5dukRCQgJ2ux0vLy/q6+uxWq1MmTIFb29v6urq3IIc3HQizZs3p76+npSUFO68805CQkLUjWqFhYW89957XLx4UTfICYiMjCQnJwd/f3+6detGQEAAJSUlFBQUMGHCBJ5//nny8/N1bcPD4+Z+hnnz5vHkk09SXFxM69at8fPzw263k5iYSFhYGKGhoSQmJroNXnli/vz58xw6dIgvvvgCs9msBrTevXurq6icTic+Pj66tBiNRsxms7q0r2nTpvj7+wPg7+/P2LFjmTx5Mq+//rraMhQ0OJ1OvL292bdvH5WVlURERBAREaGuZXc4HLRp04bFixerk+16CZDVasXPz49Zs2ZhMplc1tO3bt2ay5cvk5aWptq33jgJDg7m1KlTPPbYY2zZsoXWrVury3zF+Jg5cyZRUVH4+PjoLlRwOp2sXr2a5557jtLSUhISEtQFFEFBQQwcOJDFixczceJEt/aYCNilpaUsWrSIiRMncvvttxMZGYmXl5cqC1ExihVPehPrBoOBkydPsmvXLqZPn05lZSWenp5UVlaqznjQoEF89913DQYYRVHo2rUrI0aMID4+noSEBHVvQNeuXSkqKmL8+PGkp6djs9n+ozYM/AWTpwaDgdraWsaPH8+gQYP4+eefVeclsowRI0YwfPhwunXr5ha94aZwcnJymDRpEq+99hq33XabireoqIimTZtyzz33YLVaad++vdv6b/GcgoICJk6cSNeuXVmwYAF2u13N1mJjY5k6dSqtWrUiLi7ObXWOKLFKS0sZNWqUmo3n5+fjdDpJT08nPj6enTt3cu3aNfz9/V3WkAtnGhISwo8//siwYcPo2bOn2i6pqKjg+PHjJCcnc/vtt7Ny5Uq3DELI02g08s9//pPZs2dzxx13qBu+UlJS8Pf3Jysri6+++oq9e/fq8gFw48YNPv/8c7Zs2cLo0aPVwZuamspPP/3EqFGj+Pzzz9m7dy++vr66bZSsrCxsNhvbtm2jWbNm5OXlqa2AEydOkJyczPHjx9XJaK0D8PT0xMfHhylTptC7d28ee+wx1TZEkH/kkUeYPXs25eXlbsFWyKOgoIAVK1bQpUsXBg4ciJ+fn1od+fn5sWDBAt58803y8/PdKhhZP5s2bSIvL49Ro0Zx48YN4GYWXlJSwsSJE0lNTVWXf2pBZJheXl6UlpZy9913U1tbi9FoJD09nS+//JLa2lqGDBnC0aNH3dogAq5fv05+fj5vvfUWo0aNIjw8HJvNRnl5uaqjrVu3qtWH3Jc2GAxkZmayb98+vvnmG9LT0wkKCsLX1xer1UpMTAwvvPACHTp0oE+fPnh7e+s6surqanr27Mnjjz9OcnIyXl5e+Pj4EBgYyMGDB5k6dSpVVVU0b97c5T7Zzq9du8Yrr7xCZGQkzZo1o7y8XO3bnzx5kj59+rBz5041m9VbWVNXV8e//vUvDhw4oC5pBCgpKaGuro7jx48zf/589u3b12D7Ijg4mFdeeUVdDefl5YWiKOTn55Obm4vJZGL16tVq31vPNioqKjh06BCzZ88mOzub4uJiHA4HgYGBXLt2jX/84x9s2LCBcePG4eXlpZv5l5WVMXz4cHx9fWnZsqU6JiIjI7l06RLdu3enSZMmatDQazneCv70jF1RFHJzc8nJyaFt27YMGjSI+vp6iouLKS8v58svv6RJkyb84x//oF27dnh5eeluVggNDeXZZ59lz549fPDBB2RkZLB79242btzIl19+ydWrV3niiSeIiopy2w0nICYmhoyMDM6dO6c6w6NHj1JSUsLWrVs5duwYOTk5tGjRws0ByC2hqVOnsmDBAsrKytTVGB4eHsyfP1/dJBQfHw+4l/2ZmZlMnjxZLbuLi4tJS0vD39+fqqoq2rZty5QpU9RNPdpSWVEUampq+OGHH3jwwQc5evQotbW1nD17luPHj9O1HeJqAAAgAElEQVSjRw+GDx9O+/btGTNmjFuQEwMvOjqaw4cPc//991NZWUlubi7nzp0jKSmJPXv2EB0dTWlpKT179mxw/XhdXR1z587lgw8+QFEUfHx82LFjB7GxsaxcuZL09HTeeustmjVr5pahCrnYbDbef/99Dh06RF1dHfn5+WRkZLB//35qa2vp2rUrX3/9NR07dsRoNLrJE6C0tJTQ0FDmzZtHq1atqKurIycnh3379jFr1iyioqL45ptvGD9+vNtyR8GL1WplwIAB2Gw2QkJCiI6O5qeffiI9PZ2uXbtSXV1NdXU1AQEBuhuUPD091TaUqDorKir46aefKCgoYOTIkWRmZqorLLStKbm/ffHiRZ599lm2bdvG9evXKSgoICUlhb1797J27VpGjBihBg0tL0ajkbCwMAYPHkx0dDS+vr5s376dr776in379jFs2DCeeOIJl2MPBIhxFxERwSeffMKQIUMwGAyUlJRw7Ngxrl27hqenJy+++CLvvPMOgwYNcpOFyHojIiL47rvvqK6uZtCgQZhMJmpra/n++++ZNm0abdq0oaioiIEDB7rJUlQBfn5+XL9+ndtuu43CwkJSUlI4duwYcXFx7N27l9dff53AwECCg4Pd5k4EL1VVVdjtdsaPH09lZSVRUVH8/PPPGAwGtm7dyl133cXatWvJyMhw2yglkqK6ujrGjRvHK6+8QlZWFi1btmTHjh2sXLmS5ORkli5dygMPPOB27pVso7W1tUyZMoWdO3dy/fp1IiMj2bt3L1arldmzZxMfH8+4ceMYMmSI7lEPfwR/qmMXjqh9+/Y0bdqUU6dOUVdXR0pKCm+//ba6m09slvD19XVjSAzEoKAgXnvtNfbu3csDDzxAWVkZYWFhlJaWcujQIbp164aPjw9NmzbVzQ7hZvaVkJCAh4cHGzduZMeOHYSEhPDyyy9TUlJCWloaK1asICYmxo0X0fcTA+/06dNs2rSJjRs3kpSUxOLFi5kwYQI+Pj5Mnz6dLl26uAwckVG1adOGzMxMFixYQGpqKhaLhUOHDvHMM89w/vx5nnvuOfbt26e77Ek4ocDAQAICAsjOziY2NpbExEQOHz5MdHQ0S5YsoVmzZoSEhKi7SPWif3V1NWVlZdx555107txZzfI2bdrExIkT+fDDD2nTpg1BQUG6evXw8CAoKIjTp09z5MgR4uPjCQwMJD4+nlmzZvHFF18wcuRIysvL1fkUvZYQwKuvvqpWCJs3byY5OZmDBw+q5bdY4aLVq8DTsmVLMjIyKC4u5syZM1RXV6u94OrqalasWAH8vrRPmzh4eHjg7+/PwYMH6d69OxcuXOCrr76iqqqKuLg4XnjhBd59912uXbvGgAED3IKDwBMQEIDT6WTz5s2cPn2auro6kpKS6NKlC2+99RaRkZHqqhjtHgX588SJE4mOjqZ///5YLBaysrJIS0sjKSkJk8nETz/9RIsWLdzug5ttlPj4eJYuXcqOHTvYt28fp06dwul00r9/fyoqKoiJiSEhIcGtmhM8BQQE0L9/f+rr6xk1ahS5ubl06dKFjz/+mKZNmzJt2jR8fX2JiorStS+DwUBoaCiPPfYYMTEx7Nq1i+rqahYuXEhgYCAbNmzg7bffpn///gQEBLgtMxTjRgSvffv28cgjjxAUFERRURG7d+/mgw8+IDw8nOnTp3PHHXc06AgdDge+vr5cunQJg8HAunXrOHz4MJs3b8bb25srV66wbNkyoqKiVD3KOnU6nRiNRtauXcvcuXPJzMxkyZIldOzYkR07dnDw4EE+++wz/P39MZvNutm6aHd+8sknrFmzBqfTyY8//sjIkSM5ceIEP/zwA8nJyaSlpant4YYWTTQIYnD8ST+KoihKbW2tsn79emXcuHHKyy+/rLz33ntKfX29MmnSJOXnn39WSkpKFEVRFJvNpjidTsVutysCh9PpVJw3TxNUVq5cqWzfvl2ZNm2aMmvWLKVJkybKXXfdpXTq1Ek5e/askpubq9jtdsVutysOh0PFYbfbFafTqVgsFmXt2rVK//79FUDp27evEhgYqDRp0kTJzMxUFi1apD7f4XCI54pyURE/NptNycjIUPbv36+UlpYqt99+u3Lp0iWlvLxcWbhwoZKdna3U19dr6VAURVEqKiqUn3/+WZk2bZoSEhKimM1m5dKlS8qzzz6rvPfee0pqaqqSlpYm3+tCg6IoitVqVVJSUpS9e/cqmzZtUgYOHKh89tlnypw5c5ShQ4cqV65cUWn9TZZufFgsFmXNmjVKRUWF0qFDB2Xy5MnK/v37FUC54447lNTUVEXITQJVJ4qiKHl5ecqlS5eUkJAQZfLkycqSJUuUDz/8UAGUMWPGKKmpqcr169dlGtz0arFYlGnTpinZ2dlKSkqKEhsbq3h5eSl33nmnkpqaqpw6dUpJS0tTFEWR6XHBYbfblRs3biiA8sEHHyg5OTkKoCQlJSkzZsxQrl+/rpSWlqoEaG3DbrcrRUVFyvPPP680bdpUmTBhgrJo0SKlQ4cOisFgUL755htlyZIlSklJiUqDTIeiKCov+fn5ytGjR5V27dopQUFByp49e5Qvv/xS+fzzz5WPPvrIxb70dOt0OpV9+/YprVu3Vl577TVl3rx5yoMPPqg4HA6le/fuypYtW5Rr166p10o4VJ0nJycrx44dUw4fPqzccccdymOPPaYUFxcrBw8eVJYvX67ap9PpdJGFuD8vL0/ZsGGDMmDAAKWiokJJS0tTVqxYoeTm5iqTJk1Sli9fruTn5+uOE8FfbW2t8uqrryrvv/++0qlTJ6W6ulrZu3evsn37dqV79+7K/v37lezsbJUGecwLe8nLy1M+//xz5eTJk4rJZFIA5cSJE0piYqJy6dIl5ccff1QyMzMbHK9Op1OpqqpSqqurlV9++UXp1q2bcvjwYcVkMilms1mZPHmycujQISU1NVWx2WyyTF3sq7a2VtmyZYuSlpam/PLLL0rr1q2VSZMmKUlJScodd9yhnD59WrHb7YrVanWTqcBRUFCg1NTUKJGRkUr79u2VJk2aKEFBQUpERISyYsUKZdOmTUptba06VmQc/87PX3K6o9VqJTY2lubNm/P888+Tl5fH1q1bGTlyJP369SM4OFjdtdfQ+vGamhrMZjP33HMPRqORJUuW8Nlnn9GpUyf27NlDcHAwgYGBumWMfGBQdHQ0M2fOZMuWLdx999088cQT7Nmzh7KyMu6++27q6urcSjLBi8i6N23axHvvvcfSpUtRFAVfX1+eeeYZsrKyePTRRwkICFCv1eIxmUw0bdqU119/HbPZzPTp03n44YcZOXIkkZGR5OXl0aZNG5e1vALkHWxXrlzh3Llz3H///Xz55ZfqpPKOHTvUiSDBuxaHwWDA19cXb29vfHx86N27Nx9++CFbt24lKyuLFStWqCsS6uvrdbMHh8OhLhGdM2cOZ86c4dSpU6xdu5Y5c+bQuXNn8vPzCQ0NVTNcLR4PDw+8vLyYOXMmO3bs4JdffuGjjz7Cx8eH4cOHc+7cOaKiomjZsiWK4n7glJCP03nzMKVZs2axYcMGLl26xPvvv8+sWbN46qmnsNlseHt7q7zobZQKCAjgtddeY8aMGWRlZanLEgcOHIjZbKZfv36EhISotiDTIT77+Phw9uxZ9u/fz5UrV9Rt6suXL+fBBx9kwoQJ1NTUuO1tkHkBuP3229m6dSv33nsvRUVFdOnSBYAnn3ySHj16EBMT43LapGyfDodDnRTNz89nwYIF/PLLL9TU1HDu3DnGjx9PeHi4C//yZ1GJde7cmbfffps333yTuXPnqqtKRJswOjpafba2FSPmAoYNG0Z8fDyLFy9mzpw5LFy4EIfDwc6dO9V2oFzRyjaqKDfX5IsW5dmzZ9m3bx+9evUiLi5OnaMT9qWVp8Arjnj44Ycf6NatG35+frz66qtcvXqVYcOGERgY6EKH3gSsp6cnw4YN45NPPqFDhw6cP3+eNWvWcPHiRWbPnk1GRoY6B6C3rNfD4+Zu8pMnTzJ79mxefPFFQkND6dGjB5s3b6Zdu3b07t3b7RDB/wQ8/m9u+r8FRXE9j91ut1NQUKCeC+Lp6UlwcDC+vr4oiqJOjv0mGA8JjcvkZUhICNnZ2ZSUlBAcHExkZCTe3t54enqqvfHfnukh0/HbZ65du0ZNTY16QFRZWRnBwcEYjUZ8fHxcBq7ht3OmnU6nIis/JydH7fkWFhbSqVMnysvLVUOTHfNvOFwEX1hYiNFopLi4WF0p4O/vj7e3t7oSQXqeCx+CvsLCQkJDQ9Ulo2IZmOzUhew8frdYRabv8uXLREdHU1xcTElJCb1796asrMwlSEqDT1cWqampREVFUVBQQKtWrcjNzSUmJkZ1umKiWZKFqGBUvSYnJ9O2bVuSk5MpLy+nbdu26vJL+fTH3+5R6ZAdvsViIT8/n8jISHx9fbFYLOrgF7oXv2VeBB+KcnNJoditWFFRQXh4OBEREeoWfGFfMi/CRgUep9NJUlISZrOZsrIynE6n2jqRg5OWDok/srKyANS9Gf7+/jRv3lzdfCeve9falwiiJ0+exGw2ExQUpLbtAHUVinSevsqHuN/Dw4OamhrKysrUHZsVFRUYDAb1oCvNOem6tiHmTUT70Gaz4ePjoyYpIomTbfS3zFkdA2VlZVRVVXHjxg2io6PVtonJZHI5yEy2DZkXRbk50R8bG0tSUhIRERGUl5fTrl07dQWKnBBq6RBySklJoa6ujtjYWDw9PSkqKlLX1Au7UDNojUzFdwUFBdy4cYP4+HgsFgvh4eH4+PioPlEzt/dvN9r/dMcuG7w2U5GcZ0POEIfDoWj7kSJb0Wa18gSKXnAQdIjsXdAkDyiZjt/AwwWBhENcL/+tB78ZiiIfqatXEQhadFayuAUogUO+tqFMUG/gyQFC29OTv5P/1r5oQ5KzW69W3CPTKNOhEak6yBugXTfYioGn1aHMlx4e2Ta0QV8vCxXJicimJN5cgqVWjiKDlvnS2p82OOjRr9W5FpeHh4eHw+FQQDdwuMhTHjsSHhc+BO2Sk3KxM+1YlfmQ7Uu2US0tWjnpBX1Z/rI89HyYnlPW8z0yaMeOoFO2c0GzrEdtpSTzIa7jN/tyOByKPKmqpUW2K9k3aALuH8JfdrqjYExWkNyqEELRGoDWyQgHIIQhD6hbOVeBS9Ainq3nxATorQbROnPxf4FL62RkXCIrkDNhrQELWWhpkfFoeRY/eiWpzJvALQ9QWR7yPYALndpSWRuo5fXMWkNtaEDKNMsnUcpyFoNNb1CIZ2mdncAnP0fr+LUyF/RrdShfJ+PQOkxZruKznO1p5dXQ7mg9PrX2L+jROn+9M8xl/Qi56MlLvkd2xlqdyrpqyDa09qe1eXGPXHXo8Xsrm5MTBzlYauUp60Vco8en9lqtTPRWvGhtRS85ke1I5lfs0xBy0Y75W/kxPfhTM/ZGaIRGaIRG+P8fGl9m3QiN0AiN8F8GjY69ERqhERrhvwz+7FfjKdqekein6U0g6k186k2CyH1Gvd6pdoJMTIJo7xOg7W+Ka8TElMyLlg+ZbpkWDY/qqgV5AkzuI2onzoQctJNK2kkpmaaGJr5+A7cJoYZ0oJ2LkMBtpv8WE9cuspXo1l2BodWftseokbvbBKzWBuT7ZflI8nJbFaN9pnaSUsanpxet/WnnBmSdaGxDd1JblmVDcxW/3eMhZKHXI9barcyTLAshTD365XtkHiQa3VZdaXWvHauy7f92ne6Y19Ig3yPj+Xd0Ij435IOEWAUvWjlq56sEyLL67Vluiy7ka7XjVuvbNDL9Q/jTJ0/l32KiQjtbrjdrrsWjVYreIJAnrxqiQzuZIn7LxnMr5yBfL3jS4pfplO+RP+s5M4FDO0mkfa7sGGQ69HgT32n50K5yED96A1qLQ/tMvZUaQqfa4CuDFqeeDrQTVnr3y45IpkeLT+tIZHnLz5In1BqiXW9QN0SnnjPQCxYyHmFLgh49G9ZLUGTdaJMPPX3o0dBQEJDlIvOit8hAKw95kYS4RjxDjw5xrSwHPd5kP6KVhUyXrHvtd+JvLX96iwvkSV+tjPT8j3Ysa8e7wK2VwX8Kf3orRjYKwaSs3IYMVL6/IScntqrrDVgtaBUqDEEcxiSipdYBaz9ro634n9P5++v7tE5AloM2qxTPle/X0qzFIUCPd6fTqS6hEqDnhGSnIetDXt2il+3IeLQOXRiovMLkVg6vIScl8Moy0zoPPZlqnbh2RY0scy2eW9mYni4aokMrb/FZnMQoOyE9fFr6tA5eG6Qb0pHWkTUkDxlkurRBW+ZNzta1IAcheXWQdvyIz3q0a0HYs8FgcDk8TevQZZ5kB6yXoIlVKXry0l4r0y3rQBwiqCc/LY3aYCLGifBhcqbekL3fCv6SNyjJIA7fWrlyJYmJibRr147Q0FCGDh1KWFiYukFIzjT0nEpxcTGenp7s2rWL1q1bU1lZyV133aW+HaWhMkubhV69ehWj0Ujbtm05ePAgCQkJREZGuhm/dumeoKOqqoqPPvqIgoIC5syZQ2hoKBaLxeUwM9nwhMKEwgsLC1mzZg1DhgyhuLgYp9NJQkICYWFhbmfnaLMcgaeuro5du3axc+dOOnXqRGhoKI8++qi8AcUNh5ydC1oWLlyobrp66KGH1LNAtE5Az4BtNhs1NTUYDAYWLVpE9+7dsdvt9OzZkyZNmrgt75OfL3DZbDZMJhNz587F39+fGTNmcOnSJbp27fqHTknQ5XTefKG0xWJh0aJFtGjRgjvvvJPo6GiCg4PVzV+yPLTy9PC4uWvT09OTlJQUzp8/zxNPPEFNTY0uDpkHYSd2u52ysjI+++wzzGYzHTp0ICYmBrvdTnR0tNsOaS1fsq7ff/99Hn/8cYKCgkhPT6dVq1Z4eXm5HIomBx7xv/r6ekwmE5s3b6Znz54cOnSIqKgo+vTpo77sQ+sY5bYi/P5+3V27dpGQkIDVasVut9OmTRu8vb3dljfKOGR5WCwWMjMzqa2tpa6ujoCAADp06IDBYFA3TOk5V3kJYUVFBV5eXly6dImYmBiysrJo1aoVUVFRbnRr25JCHgUFBezbtw8fHx9GjRrFxo0bueeee/D393c7PljGI9tKWVkZP/zwA+3bt6d///5s3bqVgQMHqscr69mnXHUI26itrSU0NJTy8nIqKyuJjY3Fy8tLlet/An96K0bO0j08bu5Es9ls6qvBRo0aRXx8PP7+/qoj02Ye2mgvdosdO3aMIUOGsH37dnr37k1OTo5u9NZWCna7XcUhTu3LzMzEw+PmFne9fpqMR9BitVpxOBy8/fbbvPXWWxw5coTz58+rL63QtkqEoWvbNdOmTaNly5b06dNH/c7b21s3S5T5EhmDyWQiJiYGPz8/QkJCeOCBB7hx44Z6aL+27JR5EINOURSef/55Kisr1eOTCwsL1RefaMtaIQvxndglWl1dzYMPPki3bt0YPXq0+tIMLcgZpKDF29ub4uJiQkJC6NOnD3PmzCEzM5OMjAw3HWrtQ+arsrISPz8/srKy6NevHz4+PoSGhmI0Gt0ckZCp0Ln43mQy8f3339OxY0fsdjvFxcVUVVU1WI1p8RiNRiIiIqioqCAgIEA9AkLsutTDIfgQMhVOsE2bNlgsFioqKkhJSaGsrMzNCQq7kv8vjpBNSEhg1apVBAYG0rVrVwC3M/ZleQp6RDZZV1dHv379WLFiBadPnyYqKsrlcLeGZCIqYrGtf+vWrdy4cYNDhw6p71LQ7DZXaZcDpd1up6qqCl9fX/z8/Ni7dy/NmjXDbDarr5qU25CCD+0YNhgM6gtbTp8+zYkTJzCbzRQVFWEymdyCq1ydCzo8PG4eTnb//fdz9epVrFYrvXv3JigoSLcC09qboMtms7F//34+++wzDh06REhISIMJy78Df9mqGJHFiLOhR4wYQUhICOfPn3c5g0PbDpHBw8MDq9WqvqTDbDYzdepUWrduzdWrV4mLi9Mtv+TBIvCL42w/+eQTFEVh9+7d6uu7RInWULkKv1cegYGBjB8/nj179nD8+HG8vLzw8vJSS29tWSrjcDqd+Pn5sXLlSp599llWr17NgAED1GMJtI5dlo3TeXN7u3gnqdVqJSsri8jISPLz89VzYLR8aAODw+HAZDJRUlLCr7/+ypo1a9S/ZUchDzx5bgR+35VXW1vLunXrmDx5MvPmzWPv3r3ExcWp26S11ZI8+IUDCAkJoaCggM8//5wRI0a4vCyiIV0I2sTLiwMDA/n888+ZOXMmGzduVLfAC5r1bEPQIT47HA5u3LjB8uXLyc7OJi8vTz1jRVsqa1s59fX1OJ03z2cfPnw4p0+fpry8nL59+6rb6rUgBxUZf3V1NV5eXpw5c4Zjx44xZswYmjVr5pbAyAFS8FhbW0t9fT0bNmwgPT2dwsJCNZBrj3MWOhEgn8hpMBj4+eefSUhIUM8ij4qKUiuGhpIPwYe3tzd+fn707t2b9evXM3HiRC5evIjJZNLdbaxN5gD8/PzUbP3dd9+lvLwcHx8f9cgJbZtK1qvQidFoVM8Lio6OJjQ0lHbt2uHn5+eSqOjxIvBZrVYCAgJYtGgRa9euxeFwYDQaycnJUWWqtS/tXITD4cDPz48OHTpw9uxZysvLCQ4Odnmn73/aivlLHLsos0T5aTKZmDRpEi1btuTixYtYLBa1jNFru8iCMhqN2O12/Pz8CA4OJjs7myeeeEI9b0E8T1seygIWZ2IXFRXx7LPPMn78eFq0aEHTpk0xGAxqtqxnKOKzCC7l5eWMGDGCefPmqc4hPDzc7SAxvR6jqGDEa7emTJmiHkKmPadFlo1wAsJA8vLyWL16NR07dlRfuScyAL02itCHyGA9PT2x2WxcvHiRlJQU9d2n4vwcLcgDTw5YNTU1DB48mPnz59OpUyc6der0bxmoh8fvuyYNBgPFxcWMHj2a/fv3ExUVhb+/v9pe0w487YS8eJvVkSNHSEpK4qWXXsLPzw9FUVR+9Z4v24ndbicsLIyhQ4eSlpZGcHAwt912G4GBgQ1mdlp8Hh4eFBQUMHv2bA4ePKjat3h7mBaHcEzif+LcIn9/fz744AM2btxIhw4dSExMVN/4JT9btk9hG+IFKb/++iutW7dm0qRJXL9+nbCwsFvqVThkYYOVlZXqGUJDhw5VKwG96ljmXyRQdrsdk8nEkiVLaNeuHStXrqRXr17qSy+0Wa38P0W5uUtXHG42bNgwTpw4wYEDB9Qs2dvbW5cOuUIXlXh0dDSHDh3i4YcfJicnh8DAQJo3b65byclzCaIK8/b2JjQ0lK5du/KPf/yDCxcu4OPjQ0REhMszZdC2hTw8bh5RvmPHDu6//3414IogpcfLH8Ffch67yIDEAKyrq+Oee+4hPz+ftm3bYjabXQ5XkkEYmZgUFAflFBUVMWrUKMxmM6WlpWqPTNyjFzUFDvGdzWZj9erV7Nq1C7PZTFhYmNur+bS0CBodDgc2m43q6mpOnjxJamoqCQkJBAQE3NLoFUVRs30Pj5uv7ho5ciTXr19n7dq1lJeX6zoPca+QoSgLxSl3zz//PNu2beOuu+6iuroaX1/fW/Ig6BBZeVhYGJcuXeLNN9+kqqpKfZ+sXnCA30t/kUmLLO7zzz8nMTGRKVOmuODXZrlykBI4hEOaNGkSK1euxM/PzyWb0tIifxYDwm63k5OTQ9euXcnMzMTX15fa2lq3Iwb0QNDp6elJYWEhZ86coWPHjjzzzDMYjUaX4KNHh5wte3p6YjabGT16NHFxccTFxakVq97ztfzJeNq3b8/69etxOBw0bdpUPfhKr6+u5bGuro7t27fz9NNPU1FRQceOHVVZaFsgAo9wpuK74uJigoKCeOGFF9i3b5/2QDbdBEg8X65+27ZtS25uLnPmzFFfiaenS20yI+ipqKjg8ccf59ChQ8THx6sOW882BMhzOQ6Hg4sXL5KZmcnevXtp3749lZWVuk5d8CJn/EJeFouFpUuXcvHiRQoLC9WEQg9EEibPO3h5eVFYWEhOTg5Op5NBgwYRHBysBvyG6LkV/KmOXTYaYUxGo5ELFy7w0Ucf8c477zBixAgXR6cFufcpG31WVhbZ2dk0adJEdezQcKQTAhM9PU9PT5o3b05aWhodOnRQWwFyOaY1NmGwIssVR8GmpqbSu3dv7r33XjVyaweejEc4boPBoA705557jj59+tC8eXOVXz0ahFyFPMT7RKdPn47T6VR763rVglYeonQUbYPHHnuMVq1aERgYqGZBeu0xbfAV8rBYLGzbto2pU6dSW1tLeHi4i860NAmcshMpLS3lgQceoGXLlvTs2dOtcmnI4OUqJDMzky+++ILz58+rPft/Z6DIDqKgoECdfE1OTqayslLXEcoyEo7Y09NTfefrli1bCA0NxWw24+fnp17fkCOWcdntdi5fvszy5cuJjIwkKyuLwMBAl2pSbyJYPmwuOTmZOXPm0Lx5cxwOh8sbj7ROWa4axDUmk4nKykruu+8+YmJimDZtmotj18pE6/CNRqOqk++//x6DwcC+fftc5mnEs2U65JajGA9+fn7MnTuXV199lWvXrv2hnetVMy1atFDfUpacnKwecXyrxEEeK4qiqC/aKSoqokePHi5OW2/MC9uUk0qDwcCKFSto27YtrVu3VunQk+m/A3/qqhjZgOUI3rp1a/Ly8ujXrx+KotC0aVO3WXFZAPL9wimnpKTQrl075s6dS2FhoXo+tN5qGNmA5Um7zZs38+CDDwKoL5eVjVKb9cslpsjad+/eTatWrdSXV8t06AUr2fDr6upYtWoVgwYNIjQ01G2lhBaHbDCC1rq6OpYsWcKvv/7KoUOHaNGihbqaRStL8bc2I/D09GThwoVUVlbSv39/7rnnHpdz3PV4kB2ZqBwuXLjAk08+ydChQ9U39cg0NLRCRwR9T09PNp3ZkwIAACAASURBVG/ejKenJ2+//TbV1dU0adLETXZ6IOQhKphVq1apjkq0YvQCtp6NOp03j92Nj4+nffv2NGnSRD0OuaHEQZapuOazzz5T3zubkpKiykOWn9bORQsEfm87mkwmLl68SOvWrdWs7lYgZOFwOAgODubuu+/mkUceITo6WpVJQ45D+3+bzUZ0dDRNmjRhyJAhZGVlYTab/9C+ZZmIuYvMzEzeeecdwsLC3Noc2ixdxiV+z5w5k/vuu4+HHnqIgQMHqm+sakgn4j55QtzLy4ukpCRiY2OJiYlRj1PWrtK6lWxiYmJo2bKl+iYoYV8yvXp0iKTSbrezfv164uLi2LhxIytXrlQTKdAP/H8Ef3qPXZsFWCwWjh49SlVVFX379lVfPKxdCaPFIWexTqeTnTt30qNHD6ZMmUJAQADgOpveUN9T/iyCxIcffuhy361WxcifPT09OX78OBkZGURERLi8g1LuEQraZHzifh8fHxYvXszf//53WrRo4UKb3jNlmQp46623OHv2LAUFBepLA7TP0n6WMxRxTn5ycrKaJevJTE+Wso6+++47srKyePLJJ1VHKAfEhsptIZ/a2lri4uLIzMykrq5OXXYqvr/VCgzxHKPRyJo1a9iyZQu+vr4ugUHGpYdD4Bavo8vPz+fZZ59V21raDFf7fBlvfX09zzzzDL179yYjI4PmzZu7fH+rXqwAu91OTEwMGzduxGQyqb118XOrTFlRFKqrq/nhhx/YsGGD6jjkMaSVp3aST0y0zp8/n44dO5KQkEBgYKDLtXL1IP7W2r7dbmfBggVcuXIFp9PpUl3rtR20VaLA9be//Y09e/awbds2tSppyJnKdInvy8rKKCgoIC4ujkGDBhEbG+sS6LTy0EvuHA4H6enp2Gw24uLidGlvKPCK/1dUVNC+fXvWrFnDxIkT3dbD3yqBaQj+kp2ncnQWZX5QUBAzZ85UX8LQUAkiMyg+l5SUUFpayuLFi9Vst6FVCuI+eVCK54gX0n799ddqG0bQ29DAkZ1VcXExw4YNY+/evaxevZqwsDCX6/SCiUxTXV0dM2bM4KGHHkJRFJcljuL5eoNGps1qtTJkyBACAgKwWCxYrVYXOepNTAljFv/Pyclh+vTpeHt7q5NUMs16Dk0vK1m8eDGvvfYaw4cPd3PmDWUhcnZns9lYu3Ytt99+O7m5uWr/VB5gWoOXnYiQaZ8+fZg9ezYbN25U5SHrUHu/kIeQiaIoDBkyhKtXrzJy5Eh1Ga6eTmTeZGcn9lh069ZNXaYn06+HQ7TYBB3l5eW89NJLZGdnc/r0aQIDA93aFFo5yrr39/enqKiIPn36uGx+E7Tq6UPIWji7+vp6evbsybPPPovRaCQoKKhBm9bKWHxXVFREVVUVe/bsoby8XHfyV2+8yklOSUkJISEhjB07lp49e6otKfmZDTlDOSGaNWsWU6dOpW3btoSGhrrN/2iDr9av1NbWsmTJEvr27Uv37t0JDg5ukA9ZnrJ+LBYLISEhdOzYkTZt2qiBTjxTT65/BH/65Cn8rqiamhqKioq4du0aZrOZ2bNnu/TXZQUI0Itkfn5+PPLII1RUVJCTk+PixPQcgOwsRSmUmprKgAED+OqrrzCbzerkR0M9O3nQi8rj9OnTjB07lueee4558+a5KbehDFXIIigoiNTUVH7++Wd1EkabUWmDi2wolZWVnD59mgEDBjBw4ECXJWzyahG9wSdkVVNTQ3Z2Nl5eXly7do2FCxeqcwBCBg1lyrKzTkpK4vHHHycnJ4f333+/wUk5mT4ZR11dHX5+fnz88cdERERw5MgRt+fdKjDAzTaf1Wrl888/Z/DgwS7LAmXdaJ2ILPfq6mqsVivXr18nJyeH0aNHqysqBGiDpeBNzoJLSkro06cPw4YNc8EvP1ML8mIDMeHbpEkTfH19KS0tVVf1yM+Xf8vBpbq6msLCQtUhhoeH/6FOBG+yQy0tLQVg5syZjBgxwo3WhvQi44+MjMT8W/vm6NGjDS5/1YIcrH19fWnWrBl79uxhwIABf5g4yPNQcDMB8vDwoH379uzatYu0tDSX5a3a67V0AFRVVZGZmcmIESMIDAzklVdecdllrb1e0CHLqbq6Wn0TlHhbmt69/89n7PKMdFVVFTU1NfTv35+kpCTuvvtul7JPNmwB2vK2rq4Ok8nExIkT2b17N/fff/9NxjTGrlWyHNUrKipwOp20atUKm82GxWJR6ZUjv55D9PDwUCdBfH19GTNmDOHh4UyePNklSOkNPMGrzWZTV9WcOHGCMWPGsH//fl3D1MvKBI7g4GBqamp46qmn6NixIydPnlRX9ciDXG/QCHkC1NbWYrFY2Lp1Kz179nSRhXYAybR4eNxs4+Tl5REaGkp0dDTz5s0jOTlZXVEjP1/rDMWP1WqlrKyM3bt3s27dOsaPH8/w4cNdeGmIBzlgl5SUkJeXx1NPPcXKlSvVybVbZagyHtF6uHLlCqWlpRQUFJCdna3ScKt7ZXlYrVbOnj3LjBkzKC8vJzExUbfVqA324v9i52xoaCiPP/447du3d7FNEfBlm5fxi3bHsWPHmDRpEnl5eRw7dswtwblVr91ms5GdnU14eDidOnWiQ4cOXL582W236h+1HUpLS/8Pe+cdHlW1NfzfTNqk90ASUukECQQIHUTpKthQEEH0Iui96r0qlquAilgARfGiVBFFAQsqCAoBExNCCJhQQwkJSUivkzbJtGTm+yPu8545OdH7/vF57/M+rOfhCZnM2WfvtdZee+1VcXNzY+7cuZSWluLj49PJf6PErXxdVquVuro6amtreeWVV+jVqxcjR46U5iHHn/KgkCskNltHC8zvv/+elJQUVq1a5YBT+T/lGgS4ublx5coVDh06xKxZswgODu7kF5PTUfmZxWKhsbGRlpYWvLy8WLx4MRaLxaEns/yZ/w38R0wxAq5fv463tzfffPMNFy9epLKyEp1OR3Nzs4MdXu1aZrfbaWlpASA9PZ3jx4/j7OyMp6cnTk5OGAwGKUvy9047i8WCs7Mzffv2JS0tjfr6eubOnYvBYKClpaWTh1uAXJMxGAxkZ2fTu3dvZs2axYIFCzh48KAkpORXZbUbh9Do2tvbGTVqFNOnT+fuu++W5iCe/T3HkN1up7CwkJtuukly5CQkJGAymVQ1Svk6xPM2m43CwkJGjx7N22+/zYEDB+jXrx9GoxGj0YjFYvldu7aAsrIyoqKieOmll1i+fDn79+9Hr9c7NPiVv1s5jsFgIDc3V6KPr68vly9fprm5WcpcVROGYky7vcM+r9fr6dGjh+SsFCGG7e3tknam5A3ldT4/Px83NzeGDRtGZmYmYWFhNDQ0oNFoJHz8HhiNRum6/cwzz9Dc3ExUVFQn3vw9IaLVaqXMzOzsbOLj4xkyZAjNzc1Sg3ElPZVrMZlMTJgwgd27d5OXl4fBYJBuAvLoDDV8yG8xlZWVDB8+nClTpmAymWhpaaG1tdXBnKIEMWZLSwv+/v58//331NbWMm3aNGJjY7Hb7ZJyI6Ar7b2xsZHQ0FCuXLlCQkKCZCaz2Ww0Nzc70ETt9iEgPT2dHTt2EB0dzYQJE2hubqa+vl7ar2rKnFwhENmvw4cPl7KSm5qaJJwoBbMaPlxdXfH29sbT05OKigqSkpIkZVY+j98bqyv4052ngkk0Gg0jR47k448/5uGHH8bd3Z2GhgZaW1vx9vZ2aAbrMGGZQBWCMzAwkIKCAu6++25++OEHmpqacHZ2ljQ8NTu9EKhubm5UVVVx6NAhxo4dS1JSEgcOHMBsNqPT6ZRNbVXXY7d32MPLy8uZPXs2TU1N+Pv7O/gL1DaOWENraytRUVFUV1fT2NiIRtPRHFskPYnvdXXyC8KbzWYCAgIoKSkhPT2dm2++mYaGBofQKbXrtvi8vb2dnj17cvToUZYsWUL37t2JjY2VrvzymihdCUSbzUZCQgLffvstP//8M2PHjqVbt27odDqpAbTyJqR8XqfT0a1bN6qqqggICKChoYHg4GDp/WoONoEPsRbR0f6nn35i7ty5hISE4ObmhtFolLq/q9FUjs+2tjYSEhLIzs7GarVSX18v8ZbIXOyKrgJcXFxoaWnB1dUVs9nMggULOHv2rMS7cvx3pYCIqJzc3FwqKirw8fGRFAEnJyfJVKaGT2G6KC0t5euvv8bNzY2ZM2cyevRozGazQ1kFtVuYAKFgBAQEUFhYyDfffOOQXyE3TynnIfjUZDKRnZ2Nq6srOp2OgoICfHx8aG1tleqhKP09Srr4+vpKsfzXrl1j3rx5bN++naamJnx8fCQeUa5Hjl+TyURYWBh9+/Zlzpw5xMXFERsbi4eHh4NjXAnyORmNRry9vdm7dy9TpkwhJiZGMlMpE7aUYwj+qqurIz8/nytXrvD5559z5coV0tLSMBqNDrJHjTZ/BH92azypNrNIQqmpqaFbt27o9XosFguBgYFS8gc4aB1iZXbxmdAS6urqAKSMVaVQFQyjVWk2LFL9i4uLCQgIoLGxkaCgIDw8PByudzLEaqBzPXaxSdrb28nPz8ff31+K25YLADGGXQXxjY2NkjYoaovIHYYyhnVYh8CTxWLh+vXrREZGUl1dLSV9yB2KSlzYZPXY5QdEVVUVnp6eUsd1OZOJ72oVNablZqmSkhJCQkJwdXWlublZygpUaeTbiSbwP/V7hPBra2vDz8/PoXaPhEwFb9jtdimNX2g+Hh4e1NfXS1mWMjw40FWMobwllpeX4+7ujtVqJTg4WPWAU+NRoRVrtR2JLDU1NZKWKo/Jl0VPOeBD7BWRENPU1CQVlevRo4ck3JX8IaeJuDF4enpKJpWoqKhOzZhlPx3oKvDp5uZGc3Mzdrudmpoaaa+JQ1/OY2r7RNyShLLR0tJC3759pSgQpRlDjCGfh9gnZWVl6HQ63NzcJDzIcarkUSWfGwwGysrK6NatG83NzXh5eUk8Kl+LnEftdsf+B9BhZ9dqtQ6ZuyJpUq7EaBXNve12u+QDEj6D4uJiAgMDCQkJcWgy/ttzct74Q/iPCHZwNAHIGVu5oQQoESP/rtqzAuREVhJIPr4ggtK5IWdW+Rg2WbMOpSYt/0xNe/ltDAdmFYyvdkrLN60as3Z1oqsI839rDDmNlGvpCp/iMwUjdtJkuxrDptLwQ96xXcxHiTPlPOTrFQeNWrq8fD3KeSj5Sx5Kp6SzXHkAx+YSYs7iwJTbkpX+EgFaReMR+f4QY8jxrNT2BW3l+FRbtxKPAn77f6cDW/merj5XE4ZqPKjggU48LBdkYgylFiw31yr5W0bDTntePlf54SbGlNNHvhabrAmLfA5yJVQ5FyVOBVrl3xOHs3wMGQ7kpPu3BfufboqRbxCBZPnGFYRSYzoBcgKrHRTy7/274ygdqvKxleOKZ5VCT2xg5UGlZMiuQC6AlBtFoQ11WvPvXWHFTzGWfAwlk8o3kPxAk69ZDR/y+SrnrCI4Ogk1NcduV4JJPoZybKWJRYlTpVNeDV8qgrLTmpV2fuXflP/vKhdA+bsclHOQO37l/CWnj5ze4v1q/KzEpRqPyvenwJ18XmJs+edqY3RlCu1KqP/e72o8Lt6v9MspeUP+To1G4yDU/4j35TiVj60mkOXzVsO7UiYprRPy8ZS4/3fhz9bYb8ANuAE34Ab8f4b/WNneG3ADbsANuAH/f+CGYL8BN+AG3ID/Y3BDsN+AG3ADbsD/Mfize57a1TzGIllD1Cbpoh9mJ+92V1EKahEuIlpAOYbD5Owd5QXkPVKVCR9qkSBK55e8zowyIkOMIY84UIb5OTk5SbWl1Zx4yKIW5M+LNYn3K+ObFc6kTuFoSoet0gGsnK8SF3K62Gw2aR5yx598LspoASUdlfNQ8oX4rlrYpdypLo9bFx2i5M5oJV3lznyBD0Eb0RhDHgAgo0+nKA453axWq8PzfxQVoxbtpdFopHR4eblnGS4ANPKwOrEW4Ti22WxSwwuBU0WUzR9GTIln5XRV7MdOUUZKh6QyGkSGg07zkONSzh82W0dVVREWLKerMsRZzF/OzyLiSY4LOa7ldFWGOAt8C3qIvBk5TyjpKiJrlOsQ0VsizFGtPzH8+1Exf3rZXvmCLBYLDQ0N5OXlERgYyLVr1xg6dCitra1SrK+at14pCOvr62lsbCQnJweDwcDcuXOl2F9RQlNFQKPRaKT+i/X19QQGBlJcXExFRQURERGEhoZKvTuVIBd0QnDU1dVhtVrx8vLCarVy8eJFxo4dKyWzqM1B/F/0Ga2srKSsrAxnZ2epmXdYWJhq4X75hhIM0d7ezqlTp+jVqxc6nQ5fX19pM6v1+FQyqkajoaioCF9fXzw9PTlw4ADR0dEEBwcTGRnZSfjL1yN+2n5L7mlrayMjIwNfX18iIyOxWq1EREQ4CGw1nIjPysrKqK6uJiEhgcrKSinrUNm8RL4WOW+0tLRQV1fH1atX8fb2xmKxMGjQICwWi0MsunIc+Zyamppwd3cnLy+P5uZm8vLyuPfeex3i8+Uhb3JcyAVrXV0dZWVl2O12qWTDwIEDHTrtqEXdCFy6uLhQXFxMeHg41dXVBAYGkpubS1hYmNQERR5SKMaTx8GLHIfm5mauXLlCTEwM3bt3lwS9Ehdqh49er+fq1avcdNNNHD9+XCq17eLiIh1Yct5QhsyKPA+R6dmrVy8aGxvx9vaWYuuV/CVfi5w+lZWVuLq64u7uTkFBAe7u7vj5+am2gJQre4CUBX3p0iXCwsJwd3cnPz+fPn36SPhU8rjgOTmPNTc3c+HCBQc8arVawsLCuuQvsT6x7wsLC3F2diY4OJgrV65gs9mkEsJdRYb9EfzpJQWERmkymcjNzWX9+vV8/PHH9OvXj379+kkpynJCKsOAROxnW1sb+fn5fPbZZ3Tv3p3IyEgGDBjAt99+y6VLl2hoaFDV7OXhTaK40tWrV2lqagLg+PHjBAUFkZGR4dBbU8kodntHUlBVVRV1dXVs3LiRyspKxowZw969e/n888/54IMPaGhoUCWyOBRKS0ux2+3k5OSwa9culi1bRlFREUePHpXGVgMxB6vVSm1tLdevX8dqtfLxxx/T1NREeXk5I0eOZMWKFQ4dqZQCWQh+kQQTGhpKSkoKb7zxBqtWrUKn0xEVFSVtBiWzyRm+sbGR9PR07HY7SUlJDB48mPnz59Pa2sqpU6coLi5WDd8SNBYp4b/++iv19fW0tbXx3nvvYTabeemll9i8ebOUDq+ci/xwaWxs5Mcff+Srr77ixIkTVFZWMm3aNDZs2MCOHTukOu0CJ0oQeD116hQHDx5k6dKlHDlyhKysLHQ6HR999JFUoVEplAWYTCaqqqrYtWsXSUlJHD16lJkzZ7Jhwwa+/vpr6uvrHdagJlTb29tpaGigtraWM2fOcPvtt/P5559TVVVFRkYGmzdvdjgElDcJ0ft2//79hIWFcccdd1BUVMT48eO5/fbbqa2tpaysTJW/5HO6fv06drudN998k6effpoBAwYwf/58KioqOHLkSJeZ4vI51dXV0dLSwoULF1izZg25ubmcP3+emTNnUl5eLtXh6Sos02azkZ+fj9FoZM+ePVRWVvLaa68xcOBAnn/+eQCHvaa8BQhFrrW1ldzcXLRaLadOncJsNpOQkIC/vz/p6enU1tY63FaV69Fqtej1ei5evMi6devIyspi4cKFQEdt9gMHDjjwqBzk/FpTU0N6ejonTpwgIyODnJwcHnvsMdLS0mhubnZI5vvfRi/+6TZ2cYXUaDSEhIRw+fJlFi9ejKurK7Nnz2bJkiW4uLhIQlmpbQPS1SU/Px+NRsPs2bN55513CA8P58cff6Suro5ly5Z1WQNDLgBqa2vZuXMnWq2WtWvXsnbtWiIiInjhhRfIy8tzEHxqyBU11NPS0pg4cSJZWVlUVFQwefJkDh06hL+/v9ScWw7yK65IUa+rq2PAgAGkpqby3nvvMWrUKHbv3i3VIVd7vzgsdTodgYGBLFq0iO3bt+Pv78/mzZtxcnJiwYIFNDY2Su9VGwOgoKCAoqIitmzZQm1tLZGRkWzevJmoqCgOHDjQZQy7AIvFgsViYcyYMSxcuJC1a9dyzz330NLSwrJly9i7dy+enp7SQaAmlG02G2VlZQwYMICysjIqKyupr69n8ODBbNmyBb1e79CuUCkENJqOTM/i4mLuu+8+vL29qamp4V//+hePP/443377LYWFhZKZSO15wV96vZ6oqCjGjRvHhAkTyM3NZeXKlcydO5cBAwY4fF9NeXB1daWpqYkBAwbQ0NDAsWPH8PX1ZefOncybN4/m5maqqqocTCRqc6mvr6ewsJAPPviAoqIiCgoK6NGjBxaLhejoaAeTj/I2JgRrfX09q1evZtOmTej1eiZNmsTZs2fx9fV1KDUrn4P8wHZxceHIkSOsXbuWvn37Mnv2bNLS0li3bp10gKkJMjFGa2sr5eXlfPPNN8yaNYt7772X2NhY3nvvPXr16sWlS5ckHlfyhpiTyWTC1dWVjRs3Ultby9atW5kyZQq33nor7u7uJCUlSRq/mgIjfl6/fp1evXpRV1dHUlISpaWlFBYWcuLECbZt26ZKT/laTCYTFRUVxMTE8NxzzzF9+nSeffZZMjMzWbZsGaGhoQ6tKNUUU1EcLjQ0lLKyMkJCQlizZg3Lly/nzJkzUmMZNTPqvwP/kbK9AHl5eZSXl7N161aysrJIT09nypQpLFu2jCeffBI/Pz9JMCuZFToqq/n6+tLY2EhSUhI33XQTy5cv57bbbmPAgAG88MILUvd3tU0nQKfTERcXR2VlJVarlb59+1JRUcHf/vY36uvrOXPmDNBZIIrfhYbp5eXFt99+S0xMDF988QWBgYF8/PHHrFu3jtzcXEkbVm4cgNDQUDw9PZk+fTp2u52ffvqJ7OxsvvnmG+677z5qamqkAklKLQQ6DpeWlhb279/P+vXr2bNnD56ennh7exMfH88HH3yAj4+PqmYpPjOZTMTExHDixAnuvvtuRo4cyfDhw7l48SJeXl40NDSg1+tVGUx+za2pqeHTTz9lzJgxJCYmsmLFCv72t7+xefNmZs6cSVNTk5T+rQQhDBsbG6moqMBmsxEaGorRaOTw4cPU1dUxcuRI6ftqh77gjX79+nHw4EEKCgpwc3Pj/fffJzY2loMHD7Jw4UJpLUqTjtwG6+7uzsWLF6mtreXuu+8mPj6exx57jAkTJjBy5EjJ3KSkq9AOjUYjfn5+eHt7s3DhQhISEnjqqacwm834+flx5coVLly44KCAyNdmt9slW+vw4cOl94aHh+Pi4sKFCxf48ccfpaJ5SgEi9zkZjUZeeuklvvjiC2JiYti2bRufffYZn3zyCZWVlaqmLTFOe3s73t7eDBgwgJUrV/Luu+/y8ssvExsby/Lly8nOzpbK3qrRVPzUarU0Nzej1+sZP348J0+e5NZbb6V3795MnDhRUviUe17QRbSvfOqpp5g0aRIuLi4UFRURHBzMnXfeyeTJk8nLy5PmobYeFxcXevXqRWpqKuHh4dxxxx1otVq2bNlCWFgYu3fvpqysTBUfYk7C/JOcnMz27dtJSUkhNzeX+++/HxcXFwICAjh27JhEV+VNDP7H32KxWOjfvz9jxoxh9uzZpKam0tDQwKuvvupQFO2/WmOXZ8wFBQVJdTs8PDwoLS3l0UcfxWQyMWDAAOnq15WdC8DPz4+wsDCpjOmMGTPo2bMnWVlZuLq6SvZc6JyRKuzRYWFhjB07lp49ezJ+/HgeffRRtFot3333HZMnT2bw4MFdXsvEZ25ubowYMYLExESSkpIwmUwcOnSIf/zjH1gsFgoKCjo5UeUbMS8vj6amJq5evUrPnj3x9vYmJSWF+vp6Fi9eLNnwu9p8wtly5513otVqmTx5MgUFBXh7e7NhwwYef/xxioqKHBqIy+eh1Wpxc3NDp9MREhJCWFgY5eXlBAcHU15ezrp16xgxYgReXl4Ojabl7xcQEhLC9OnTefTRR4mJiSEvL4+5c+fyyy+/8NVXX0kdd7o6bNvb2/H396e4uBiLxcKZM2eYNWsWJ06cwGQyUVhYyK+//io9p8bw4vbj4+PD6tWrmTNnDnV1dTzyyCMsWbKE/fv3S1Ui1XAp+E5surNnzxITE4NOp+OVV17B2dmZOXPmUFxc7JANKp+T3W6XbhYxMTFUVlZiNBolW/tXX30llcBVqZHiIOBCQkJISkqid+/evPzyy9x6661kZWURFBREdnY2p06dUsWDVquVag7dc889ZGdn06dPH8lHMW/ePMlWL3hDqSmLebi6upKbm8uSJUswmUxkZWXx+eefs379eoKCgqQaMkraChy7u7vj6+vLyJEj8fLy4r333sPPzw9/f3/Onz+P3W7n8uXLqrco4TNwcXHh+vXrkk9uzJgxWCwW4uPjGT16NJcvX2bo0KGSzOjq9gIwevRoDAYD06dPp6KiAicnJ06fPo3dbsfHx0ficzVFTHSycnZ2xs3NDQ8PD+bPn4/JZCIgIIAhQ4YwceJEB15Sgk6nIzq6oyb9rFmz+PTTT4mJieHdd98lICCAp556Sirv3NW+/z34jxUBM5lMODk50dzcjNVqJSAggLa2NnQ6HRMmTCApKQlwqJTm4JkWV+WQkBCqq6uprq4mKiqKlpYWMjMzuf3228nJySHmt2bMIlpAzEMQv6WlRTKHaDQajh8/Tv/+/UlOTuaWW26hoKCAhIQEybmk9LLb7R0Forp3705lZSWBgYGYzWY8PT1JTEzkjTfeYODAgVKTBzEPewdImkh9fb1UZEmv13PhwgXCwsI4ePAgCxYsIDIyUirEL9Zh/414Go2GxsZGXF1dsVqteHt7S8Lt5ZdfpqSkRNLidTqdYHyHMaDDESQOqqKiIhoaGsjPz2fbtm1s2bIFk8lERESEVCxJGcFhs9mkokiurq5otVqys7NxCqOQngAAIABJREFUd3dn/fr1+Pr6smTJEsLDw3FzcxPONgeaCFt/Q0MD3bt3p7CwkKioKI4dO8a1a9dobGxk9OjR9O3bV+reIx9DGRklCiuVlZWRk5NDUVERPXr0YPjw4URGRsqjQhwiWoS2JTZ2ZWUl3t7euLu7s3nzZtavXy/d5tzd3YUQd5hHe3s7NTU1BAUFYbVaKS0tJSQkhKqqKpYvX47NZuPpp59mzJgx8ltPp2gSq9VKW1sbDQ0NUtnfL774ghEjRrBmzRrWrl2Lm5sbnp6eEn+IdWi1Wurr63F1dZUK3vn6+qLX67l8+TKjRo3CZDLR1taGl5eXEKIOUVeAVMJaBAfU1NSQkZHBlStXuOuuu/D398fX11cqOifnDSHcGhsbpQJZLi4uJCcn097ezqVLlzh69ChvvfUWN910kxS5pBbtJDp6aTQadDod9fX17N27l7CwMJKSknjooYeIi4uTBxs4RPgIR7K7uzuVlZWEhISQkZGBk5OT5K/btm0boaGhkjKmXIvgdRFJ4+rqitFo5IsvvuCBBx5gx44dDB8+nLi4OFxdXcU4DvMQdNXr9Xh6emIymfD09CQnJ4elS5eSnJyMwWCQ+rIqcPqH8KebYsQpZrVaJUHi6+vLuXPneOGFF1i1ahVz586loKDAobFCp4lrtYSEhGCxWCQn27Vr1ygqKiI6Oponn3ySQYMGSZtffvLKbwGurq60t7dTWlqKyWSisrKS5uZm7r33Xqm9nbyFmHwMIRODg4OlyJcLFy7g6+vLoUOHeOaZZ/Dw8JBMQkoQmrbJZMLNzY2KigqCgoIwmUwMGjSIgoIC+vTpQ+/evR0iHZTrsNls+Pj4YDabpTr0P//8M6WlpSQmJnLbbbdJAleYhNTm4uXlhbe3N3q9nuDgYOLj48nOzmbatGkcP36cXr16AXTqySjo6uTkhLu7O56enri6ulJfX09ZWRl9+vTh3LlzJCQkEB4ejk6nU6t4KR18Op0ODw8P8vLyqKur48svv2TMmDHs3r2byMhIoqOjVU1LymgpsVkqKirQaDT06dOHrKws3N3dHW5BSh4VuDabzTQ1NVFSUiIpDw888ACVlZUcO3YMq9WKr6+vQ1iqoItWq8XJyYmwsDAsFgtlZWVYrVb279/Pvn37GD16NEuXLiUsLAyDwdAptFZuJhJhgSEhIWg0Gsl8uWvXLkaOHMn169dVQ+0EfkTEislkws/PT/IDXb58mbfffpvCwkLp+2r4ECYhcehfvHgRg8FAQUEBgYGBvPPOO5LpVI23xNj+/v4Sf+Xm5lJVVSWtFSA+Pt6hj6scF2JcEQYsDt6LFy+SmJjI9OnTKSsr46abbsJsNnfac3KzpVarxWg04uPjw+nTp6WIOKPRKGn84hBTrkPwqGiIIaqHfv3115SWllJfX09WVhaDBg1Cp9N1wqc87FTQFMDLy4uUlBTS0tKoqqri6NGjVFdXq5pz/h34jzTaaG9vx2q1Stfhw4cPs23bNmbNmkVhYSFGo5Hw8HCpSYTDhH/7XXTqaWxsxNPTk3PnzrFx40Y2bdpEVFQUY8aMQa/XU1NT08mcIzdHNDY2Ul1dzddff01mZiZeXl6cPXtWatzRp08fh05I8jEAKWQzIyODwsJC/Pz8mDt3LjU1NZw+fZqGhgZiYmIwGo1dOnO0Wq0UXZCTk8OFCxcwmUyEhIQQFBREXl4eLi4unRxCQqgLO6+LiwsZGRnk5uaSkJBASUkJ9913H3q9nujoaFpbWzuFXYp1tbW10djYSGZmJunp6aSlpZGXl4der8fb21u6rooYeyVNBI6NRiOpqanU1tby7rvvEhISwuHDh3nuueek66/ValU9pMR8zGaz9Pddu3Zx8uRJ6uvr2bp1K+Hh4dTV1XUZSiaUBhHj7evri7+/Py+++CKHDx8mKSmJqqoqwsLCqK+vl7Q/AUKDF/gQaz579izbt28nIyOD5ORk9u/fT2lpKXV1dVIzDSV/tbe3S12cjh8/Tnt7O+PGjcNkMhEUFERtba3URUyUJ5bTRS7MysrK2Lt3L3369OHRRx9l+fLl1NbWEhgYKPVRVXYREjTR6XRkZ2fzySefsG/fPqDDFLBx40YmTZpEdHQ07u7unYSy/HCxWCxYrVby8vLYunUrJ06c4LbbbqO1tZV169ZRW1sLdM7bEPtMKBRGoxFPT0/69etHcnIyMTExzJgxg9mzZ0u80ZUz2mKxSLyXnp7O+vXraWlp4dixYxiNRqZOnSqZINVyHgQuRdTdxo0bqa+vZ/LkyezcuZPBgweTmJiIm5sbLS0tUsNvJV2F7Dpx4gRfffUVjz/+ODfffDPPPfccqamp/Otf/6KkpAS73e4QfSXwIQ6HpqYmTp48ycGDBwHYu3cvN998M3FxcQwZMgQPDw+pcdB/tWAXjGO1WikvL8fDw4O9e/fy/fffU11dTUVFBS+99BLTp0/n4sWLODs7S40R5CCYrbi4mMOHD7NixQo+/PBDTp8+zcmTJ9m9ezcVFRVUVFRITgo5yEOftFotoaGhxMfHc/z4cYYNG8bJkydZsmQJHh4ekmanFrUg1lNdXU1iYiLBwcGMHz+eY8eO4e7uTmhoKDqdjpMnT9La2tqpgbBg9La2Nurq6ujXrx87d+5k27ZtDBo0iOLiYgYMGED37t2lKCGlzU/YUbOysti7dy9ZWVmcPn2aa9euER8fz9y5c3F2dqa2tlYya6nRRfR99fX1ZeLEifz4449s2LCBMWPG8PXXXxMdHU1+fr50NezqkIIOZ3BpaSmxsbF89NFH+Pj44ObmJjG5aI6tpIt8Htu3b+fNN99k/PjxzJs3jxEjRjBt2jTCw8Ol67RSQxTC3tnZmStXrpCcnMyCBQsYOXIkY8aMITw8nOzsbCmUTJiU5DiVj2mzdXRe2r9/P0eOHGHHjh2kp6djMpm4evUqvr6+Ut13+WEptG8nJyeKi4vx9/fnnnvuwcfHh9zcXJKTk4mMjJQ2sRCqcg1RfohfvnyZH374gT179pCZmcmjjz5KXFwcAwYM4NixY+j1eunGqfQHmc1mTpw4gdVqJSEhgcjISNra2pg8eTInTpwgODgYjUZDVVWVFEKsnIPBYKC0tJQDBw5w9OhRZs2ahcFg4K677kKn07FhwwYA6f1q4bDQse/XrFnD+vXr+cc//sHJkydJSUnhu+++o1evXpw/f56mpiZV5UHgtaqqiqKiIsrLyzl//jzV1dWkpaVx9uxZ5syZQ9++faW9przNid+Li4txd3dn0aJF6HQ6kpOTWbZsGRaLhV69euHr64ufn59D9zOxDhFq7enpyZkzZ+jWrZskwCdOnMj169dJTU2lsbGR+vr6TgqMkD02m01qKDRjxgycnZ3p0aMH0KEsZmVlUV1djcVi6aQ4/DvwpztPAakZ72OPPUZ1dTUBAQFs2rSJPXv28MQTT3DixAl0Op3kfVa7HkJHsoSIgx03bhzQEce6bds2zGYz/fv3x9/fv9OpKZCk1Wq5evUqS5cu5bvvvmPUqFE8/vjjREVFsWHDBq5evcq1a9dwdXXtpNmJw6WxsZHs7GwuX77MxIkTmTp1KhEREdx7771ERUUxYcIEvL298fLy6tSBSBA5NTWVsrIySaj/8ssvtLW1sWfPHoqKitBqteTn59Pa2qp686ivr8fDw4MpU6bQrVs3rFYrWVlZHD9+nPDwcBoaGigsLKS8vFxVmEKHBqfX63F3d+eTTz4hNDSUiooK1q1bJ107e/bsSUFBgXTjUtK2srKSgwcPkpyczEMPPcTQoUO5cuUKRUVFUtednJwc6ZajLKkrzDmxsbGEhIRgMpl44YUXePHFFzl16hQnTpwgKCiIyMhIjEajZMKQ84Xw35jNZi5evEhFRQX79u2jW7duDB06lOeff55JkyZRX19PSUlJp4xDMZ7oh/nSSy9RXl5OSkoKO3fupL6+HpvNxgMPPMDZs2eprKyUkuCUPGqxWIiMjGTt2rV8++235OTksGLFCuk26eXlRUZGBpcuXeqkHYrNX1FRQW5uLn/961/561//SlxcHMuWLcNsNvPkk0/yxBNPUFFRgYeHBwaDoVOCT1tbG0ajkU2bNpGRkcGtt97KkSNHeOGFF7j33nux2+1cunSJkpISGhoaOs1BmByDgoIIDAxk4cKFnDt3jtzcXDIyMpg7dy5hYWF4eXlJNy21Fncmk4lvv/2WkpISUlNT6dWrF7fffjsbN27kzjvvBCAxMZH29naptZySR8XP5ORkqXerm5sbJ0+epKmpCQ8PD44fP051dbW0diVYLBb8/f05d+4cc+bMYcyYMVy6dIkRI0bw66+/kpWVRXl5OXl5eaoJdOJm7OTkxNy5c/H19WX37t0YjUYyMjJYvHixZFK1WCw0Nzd34gvBZykpKfz000/s27cPjUbDli1bWLNmDcHBweTn50ud4bpywP4e/Ok2dhF/7uzszKRJk/jhhx/Izc3l8uXLjB49moceeogffviBhIQEDh06JGnV8jGEJmE0Gvnpp58IDw9n3bp1vPLKKyxZsoS4uDjS0tL429/+JnWZV2YGiqtdSkoKJSUlUnPfPn364OTkxPPPP09rayvFxcWkpKSg1+tVN69Wq8XPz09qbzds2DDGjx/Pfffdx+TJk1m8eDFnzpzh2LFjUnsx+B9HkMViYfjw4ZjNZiZMmEBTUxP19fX885//ZOfOnURFRXH9+nWGDBkiNdmWg9ByS0pK2L17Nx988AG33HILP/74I7/88guTJ0/m73//Oz/++CN+fn6dNq8Yw2azERQURGhoKLm5uXh5edHc3MxLL73Eyy+/zL59+zh//jxXr16V/AnKtYSEhODn50fv3r1xcXFh7dq1LFmyRNJwiouLiYiIoKSkhICAgE6ajM1m4/LlyyxfvpypU6fi6urK1atXWbRoEXV1dUycOBGz2cyBAwc4ePCgqumgra2NyspKYmJiOHv2LCUlJcycOZMFCxZw5MgRZs6cydmzZ9m4cSP+/v5dRsZYrVbuuece7rjjDq5evUpNTQ0bNmzgvffeY/ny5dIh5+7uzrVr11RvQnl5eTg5OZGZmUlrayvTp0/nySef5K233iI+Pp6VK1fy1VdfUVJSQnFxseSgF3Ow2+14enoyevRofvrpJ4KDg5kyZQoWi4V//vOfLF++nOvXr5OcnCzxoxIX169fZ+DAgYwYMYKmpibc3NxYv3497e3tDBkyhKNHj3LlyhWKi4tpaWnpZErRaDSSc7hXr158+umnrF69milTpkix+HFxcWRkZJCfn095ebnDXhMKkNls5uTJk/zlL3/h3Xff5eeff+bw4cM89NBDPPjgg9jtdnbs2IHJZHI4oASIfa/X69mxYwcvvfQSU6dOJS0tjatXr+Lh4cGSJUsICAigW7du1NXVOeBTjFFXV0dRURFvvPEGYWFhWK1WYmNjKSgoYPbs2dx2220cPXqU8+fP09jYqBpNZzAYOHDgAJMmTcLLy4slS5bw/vvvYzKZSE5OJi0tjc8++4wjR450UsbEgV1TU4Ovry9/+ctfqKys5MSJE3h4ePCPf/wDvV7PI488gpeXF6dPn6a2tva/2xQjJmcwGBgyZAiXL1/m4MGDrFmzhtGjR/Pzzz8zY8YMzp8/z7vvvsuECRM6aYZCqysvLycnJ4fg4GAuXbrEL7/8QklJCdOnT8fb25ulS5cybNiwTowmoL29nby8PBYuXMg999yDxWJhyJAhrFmzhq1bt/Laa69JThp/f3/Cw8NVCWQwGBg/fjwjR44kMTGRJ598kvfff5+EhATee+899Ho9tbW1UmSEEkpLS3nrrbe4cuUKH3zwAaWlpbi5ufHyyy/j7u7Om2++SUREhNRHVQ2n1dXVZGZmctttt7F8+XLeeecdRo0axdixYzl8+DCVlZVMnz5d8mmoMWthYSEmk4kLFy7wxBNP8NxzzzFlyhRmzZqFt7c3W7ZsoaioiKioKKl9nxJaW1s5e/YsDz74INu3b2f16tWkpaUxfvx4UlNTuXjxIv7+/sTHx1NdXe3wrDisQ0ND6datG9u2bePAgQOYTCbpUFy6dCk7duzg3LlzkrBQCjNxjT979ix5eXmsWrWKWbNm8dxzz7FgwQLKysro3bs3fn5+ZGZm0tDQ0GkMEc3y3HPP8dlnn2G1WklLS8PNzY0+ffqQkpJC3759iYmJITY2lm7duqmuxcPDg1dffRWNRsODDz5IamoqmZmZZGdn09raSlpaGtOmTWPy5MmSWUiAcFheu3aNf/3rX+h0Ov7+97/j6upKUlIS69atw9fXlzVr1kiBCEraOjs74+PjIwmYoKAgBgwYwKFDh2hvb+exxx7j1KlTDB48mMjISIKCglQ15cbGRtavX8+5c+fYsmULixYtYu/evfTv3581a9bw9ddfU1VVhclkUj0sbTYbpaWlkoIwb948Dhw4wKZNm9iwYQMPPvgg+/fvlw4t5YEtFLHm5mYGDBiAh4cHJpOJp59+mgMHDrB161bWrFnDhx9+yNGjRzl48CAhISGdcgtEeRCLxcIvv/zCpUuXmDp1KsePH+fZZ58lPDycpUuXYjAY6N69Oz4+Pp14HKCiooL+/fszbNgw0tLSOHDgAIsXL6a6uhqdTsdTTz3FnDlzmD9/PpGRkao+rdbWVq5du8b777/Pl19+SXJyMlevXmXgwIG88MIL2O12srOzCQ4OlhLI/jfwp4Y7ihCs0tJSdDoda9euJSgoiPLycoKCgrh8+TLLli2TQssCAgKIiYnpFKooxjty5IjURT4oKIj8/HwWL17MxYsX8fPz4+TJkwwfPpyePXs6hKOJkCOLxUJ1dTWLFi2STDabNm3i8OHDPPDAA1I0hjjV5fMQY7S2tqLT6cjMzOSuu+7ivvvuo6WlhTfeeIPu3bvz3Xff0draSmJiIr169ZKPYbfbO3ov7tixgxMnTjB//nyCgoKIjY2lubmZQ4cOUVxcTFBQEHfccYc0BxHeJ0LiKioqaGlpYefOnbi6utLa2sqwYcPw8vKiW7dutLW14eHhgbe3t9SHVKxD0KShoYEPP/xQ0qbDwsKoqalBq9XywgsvcO3aNWpraxkwYIDUe1QZZqjX6/Hx8WH79u2SeaC8vJxVq1bR3t5OVlaW1FN2zJgxDiFc8jDWgoIC5s+fj6enJzU1Ndx8883MmzdPiuwYOHAgubm59O/fH09Pz05rqaioICcnhwkTJjBkyBBuv/12Ghsb0el0vP766xw/fpy4uDjsdjthYWHCoewQWif6io4bNw6DwcDatWvp1q0bN910EydOnGDQoEHs3r2badOm0aNHD4cwVMEb5eXlbNmyhT179lBTU8OkSZNYvHixZMd97bXXuOmmmyR7+W/x5dIY0CEISktLef755wkMDOTo0aP4+/uzb98+tm/fLsVM//LLL0ycOFFEG0n8Zbfb2bx5M9HR0cyYMYP169fz2GOPMW/ePFasWEFqaio9evSQsjeVNBG4EII5MTGR7OxsBg4cSH5+PgsXLqS4uJjp06dTWVlJfHy82J4OvFFdXc358+c5dOgQ999/PzExMXh4eFBSUsIvv/zC0KFDiYiI4OzZs0ybNo3f1u5Ak5qaGnbt2oW/vz/vv/8+zs7O9O7dmxUrVkjx8PHx8fj5+WGz2UTIo0PoZlNTE5s2bWL37t28//77ZGZmkpuby/bt29mwYQOJiYl0796d3NxcJkyYIJKmHMYwm828/fbbknkyNTWV1157jb1799K3b19Onz7N3LlzMZlMREVFyWkijWE0GnFxcWHFihVs3bqVpUuXMnz4cD7//HMefPBBPD09iY+Px2g0SrHyMpz+Ifzpgl2j0UjhfZmZmezcuZO+ffsyduxYyZMcGhoqFfPp3r27iON0YBQRNzpz5ky6d++OwWDgxx9/5J577kGj0fD9998TExMjZSH+dlI6ILetrY1Dhw5JKfCPPvooYWFhdOvWDScnJ6mOjJeXF15eXp0EorCxt7W1sWPHDnr06EFxcTEPP/wweXl5NDQ0SIkKZWVlhIWFSWsRm0ZEXhw+fJjTp08zZswYioqKGDt2rBTTK65/fn5+QlN2OOSamppwcXEhMzOT0aNHU1paSnZ2NvHx8bi4uGC1WvHx8SEoKEhyACk3b3t7O3v27CEwMJBTp05x1113SWFjIsNXhGdF/5bGrhzDbrezc+dO5s6dy/z581m/fj3BwcEUFBTQq1cvDh06xPDhwwkICJC3JXOIEW5qaiIvL48tW7ZgMBgYN24cI0aMYODAgZSWluLt7U1VVRXOzs707NlThK850MT+W27B4cOH2bdvH/Hx8cyYMYO4uDgyMzMBCAgIYODAgXJHsAN/CTvvvHnz6N27N6WlpSxYsIDevXtjNBrp06cPycnJ9O3blx49eojQNocDxmazkZmZybVr11iwYAGbN2/GZDIxePBgRo4cyeXLl4mNjaWyspI+ffqo0tZu76i5Iw4RgJkzZ3LkyBGGDRtGQEAAKSkpTJ06FavV2om/hPPuu+++o6GhgcTERHJzc0lMTMTLy4u0tDSmTJlCSUkJ0dHRneLxoSOG/ejRo4SFhfHOO+8wbtw4brnlFnr37s21a9cwGAyS4tCjR49O6xCKw+HDhwkPDycrK4vr16/z9ttvc+7cORITEzl79iylpaX07t2b3r17O/CXXSakTpw4wZdffsnQoUM5deoUM2bMwN/fn+DgYEJCQiRfhSyL1eGwtdls1NbW8tZbb7Fy5UqpuXdgYKAUFhsQECAlINlV8jUEXg8cOMCxY8cYN24cQ4cO5dq1awwePJgzZ85gs9m46aabpHIiSgXGYDDwzTffUFZWRnNzM2azmWXLluHp6YnZbKaurg4/Pz+8vLzkBcn+ewW77P/A/5RVFRtdxHdaLBYp1llOIHBs8ivK7Irym2rNi2XhU6oEAscYe3mkhPipglwpGUb+HjVHhzxGWYwhNh441uQQv4t1iKQSQF4jxYHhZeuT3iHs/zabrVMYnBwXQhiK78sbagMOzkUR9in+rtSohENYgDxLVZgWzGazMj+hk1AGHOgpQhfF3+Xz/e2ng0AV+BQRTeL98kxK4e9xdXV1GEPOG/L3yN8t5mY2m3F2dpb3M+0kiOTjyPlJlAqQ40QuRMQYcjqo8blw0kKHA1y2Foe9JqYk8CLiudvb2x1w0VUin3wOgj6CpuJzi8XSKZFPfvNQw4mgjViX4BfxNTGGoLUA8Zyc18V85PRT3m4FPuRzEiYs8Q7xdxFirJawBUhhtUq8CLzKEq0c1iJ4SbxP8JRaCWOr1Yqbm5uSR/8Q/vTMU+k/nQUNVqvVoT60XNjKGUXNUy2QKBAkkK6AToeDfA5yR63QbOVM89vnDkwvvqu2AeSCXy5wfpuHXSlohGCVM5YYSyG8HdYhZ2Q5o8vnL5+DfAz5ppEfcmIu4nARAl0xjgOzqh1yYkzB8OIz2d+7PGyVB5Z8bnL6KbUyNbqIDSv+Jj/slPwlnpX/FIkz4lnxtz8SIvLvCd4U8xAHpOKwUj2klDQRzkQxhnIe4nk1HpDTQ36Yytbc6dAX85ArX/bfHPfyfSZ7l6owVIZjyoWzUgHRKjI+5SDWpqwLI/at+I5SIVTiQvC2wIUa3yhpolQG5bJD0FXJg2q3D+V+UR488nX+Vwt2ObOCYxKG+P237ykFISjsqALkJ7n8efkGlxHjDzVdpZAWYyi1CLlGJRfgci1A/K6yeTRyXCg3oPxz5ab77f8OQkj+HmWIlvJgkuHDQaB29YyckeXM/htOOm1e5RrkIN8IsvEcNu/v4UI5XlcHjHzOyu92dRijIojktwIlfuU/BSgPByVOZd/r8mZHF/wlp4GcJ9X+ptVqNXKhrFSSxLjiGQkBjoqHwxzkzykVCbV9p8ajcpDvF+VekdGrE28ox+hq/8re8bs3bLmQVtBBlb9UlAr5flAVyvK1CLrIeV1NDimf/+1d/52C/QbcgBtwA27A/3+40fP0BtyAG3AD/o/BDcF+A27ADbgB/8fghmC/ATfgBtyA/2PwpzazljuV1KIw5PB7zj7ZeJ0cVEoHjMJBqRpKpuaYU85B6SEX85A7XcT3lI4plbE1YhpqDk/5+5WOMnn0hdzRp+YUUzqgu4oykjt4u3JQqTl01Wgif698DDmozUOOTzXHt9Ixplhbp4gWpTPq9xzVvz3TZeSDEq9K56maw1DNYanmXFNxrndyaquF5qr9LkDuPJXjvCt6Kr+njAKRv0tJQ7EO+XfUnKfKSDa1vSdfh5zP5dFOSpwpeVs8qxado1xzF/tCzcGu6oDtytGvdFjL6aqMQvs92ir/xv84gv8Q/lTBLieImGxbWxsWi0UqVm+32/Hy8pKQpMZQcuSLwvs6nY6mpia8vb0dCCQPKRMgFw7QgTh5nQzRlECEG4rYWJUNIK1LrEX0axUxsB4eHp3C/OQMKD5vb2/HbDZLdcR9fX3RarWqdTfkv6ttTIPBIIXWabVaCZ8C5DiVM5AYy2Aw4OXlJRX7cnNzk+pgd+Vsl+NUvkFFAxCBB/n71SIaBIg4YI2mI1tQ4MLT09OhlrsSn/IoBXlrRVEvSKPROMTpy3lR/ruc/4xGI1qtVip5bDKZOoX4Kdcjp48Yq7W1FQ8PD6nEhDz++fcOPwGi2qDBYMDX1xeDwYC3t7fDvlI7OMR4oipmW1sbvr6+mM1mNBqNPJmn036T41SMbzabpYYb8rwHpcImaC1CM+XjtLS00NbWJjVcASS6qikGys9EUT7Br87Ozri7uzuUt1ZGDKlFEVksFkwmkxSH7+vr2wnvclBGzIiCZxaLRQq/FLyhOLAdfoq5iHFE3o5er0en00k19OW88L8IivlzBbtgjJaWFpycnPj000+Ji4vj/fffZ8yYMZSWlrJixQquXLlCeHi41EZNTlT5pjOZTPz666+cPHkSJycn/Pz88PX15eDBg4wePZqFCxeG8Ii9AAAgAElEQVQ6PCcHjaaje5Kou9ze3s7evXupq6tj06ZNTJgwgVtvvZWRI0cSGxsrJcnInxdrEckdb7/9Ns899xyDBw+mX79+9O7dW2qZFxsb22kedntHqdaSkhKCg4MxmUx89dVXFBcXk5GRwcsvv4yzszPjx4+XEqTEu+XzEJvW1dWVt956i/LyclpaWli/fj27du2if//+jBw5Eo1G0yl5S4CgiU6n49KlS1I3niNHjnDy5Enuv/9+br/9dofYaQFiswjBs2/fPmJjY1m0aBF33nknkZGRxMTESHXp+/bt26l+j1ibzWajvLycjIwMxowZwzvvvMPUqVN56KGHWL58OYMGDSIhIUGkWKsKRIvFQmNjIxcvXiQlJYW5c+cyffp0Fi1axNChQ4mMjMTZ2Zl+/fqp8gV0dJMSySUajYZJkybx1FNPSRnTQ4YM4e6771Y9pOSHhmhIISpwfv755xw6dIjU1FSpcYY8OUWA4PPW1lYMBgPdunWjtbWVhIQE3nzzTc6cOYOPjw8hISHMmjWLwMBAh1hsuSCrqqrCxcUFo9FIc3MzOTk5dO/enT59+pCWlsasWbMcGnUoxxB15S0WC3v37mXGjBmsW7eOjRs3Ul1dTXNzM76+vp1q5sjBaDSi1+tpbm7GYDAQEBBAU1MTNTU1aDQdZRNuueUWwsPDu+RRq9VKfX09fn5+7Nq1i/T0dB588EEaGxuJi4ujvLycm2++WVUIin2i0XTURbpy5Qrbt28nJycHJycnEhMTiYyMJDAwkKlTp0rZr3KFTq6w2Gw28vPzSU5Opq6ujl27drF161by8/OJj4/H39+fiIiI3xXIJSUllJSU8NFHHzF69Gg2bdrEzJkzJVkxY8YMQkNDO9Hl34E/vWyvVtvRxef8+fMUFhby0Ucfcccdd7B06VKee+45Vq1ahV6vp7y8XGoUrbYgvV4v1ZkQxbweffRR0tPTefXVVzGZTOTn5zsIDPk8oCMBqKSkhB9//JHLly+zYcMGXnnlFT799FNWrlyJp6cnPXr0kLI/lRomdGgZTU1NHD16lJUrV5KSkkJCQgJ1dXWkpqYyYcIEqdu48iouP6mtVitXr17lpZde4tixY5w7d45evXrh7OxMaWmpVCVOiQu7vSPJ4tSpU7z//vtMmzaNgIAAQkJC8PDwICIigtjYWIcSpmq3F5PJhLu7Oy+//DL//Oc/ufvuuwkMDCQ6OpqePXvy66+/Ulxc7KDdy8Fm62iLV1ZWRlJSEs888wz+/v48++yzjB07ljfeeIP8/Hypop7yeYGb5uZmwsLCuHLlCqtWrUKj0TB//nzOnDlDYmIi48aNk5oNywWZwKcQlIGBgSQnJ/Pwww/T0NBAUVERSUlJrF69GoPBQO/evTuZMOQ4EU0dqqurGTVqlNRyUKvVUlxcTEhICGfOnJESXNRw2tjYSFVVFf369ePixYu8+OKLbNiwgXXr1rFhwwZaW1vJzs5WzTgUSpDNZsPf35/t27dz/fp1FixYwJtvvsm+fftYvnw5Go0GT09PKStYOYZWq+X69esUFhby+eefs2XLFlasWMGIESMoKytj2rRp5OXl/S5NWltbqaqq4uzZs1y8eJHMzEz8/PykIm979+6lpaVF0lrl48i1Z2dnZ3Q6HUFBQfTt25cFCxZw5coVfvjhB5qbm6WyFcp1yPnebDZz7do1oqKi0Ov1tLS08Nprr5GVlUW/fv2kFn5qPKrRaKivryciIgI3Nzc+++wz9Ho9qamp/PWvf6VPnz706NFDUg7Ubg7i5gWQkpLC0aNHqa2tZerUqeTk5JCWlsb58+cl3lQ7YAApoRI6So0//vjjaDQahg0bxrx587h27ZpD8xU1U+3vwZ/uPBWEHjJkCD4+PrS3t1NVVUVLSwtvvvkmTk5O9OnTp9MVU4BAto+PD9HRHZ1f3nnnHd544w0KCwtJT0/n119/lbRxcd1Rgt1up66ujvDwcMrLy+nbty/33nsvNTU1fPrpp7z66qv07NlTus4rESt+d3Jywt/fn9GjR/Prr78SExPD+PHjpRO4vb2d1tZWh2uXfA5msxlvb29SU1P57rvvWLt2Lbt27aJ79+6MGDGCwsJC6QRXO+A0Gg3l5eWYzWYefvhhevbsybx586ioqGDPnj2sXbuWTZs2kZWVJaWPq2mX3t7eXLp0iRkzZtC7d28OHjxIUFAQX331FXFxcSxatIjGxkbVdchNLEajkaioKJ599ll27txJXV0dOp2O3bt3s3fvXqnJhhpoNBq8vb05cuQIDzzwAGPGjMHV1ZWff/6Z4OBgPvroI9atWyc1Ohc4lPOW0JLT09Pp06cPERER9OjRgwMHDki8lZaWRkZGhpQWryZEvLy8qKqqonv37jzzzDN88skn2Gw2Bg0aRF5eHlevXqV79+6d6tsLPNjtdry9vYmJiWHr1q1MnTqVBx98kOvXr+Pj40NsbCxpaWlER0dLVT+74lObraPuyIEDBxg/fjz33HMPH330EWlpaYSGhnL69GlJkChvEEIIpaWlERYWxs0338yKFSu4dOkSTk5OJCUlSZUhuzIHiT0AHYJV1CGaPXs2P/30E6GhoVy6dEky1anxhtlsJicnh6ysLMrKyigsLGTZsmUsWrSIBQsWSLVr1PhLgNDk+/Tpg1ar5ZlnnuGnn36SukmZTCZSU1PlJR4c8CjGqK6uxmQysXbtWtauXcvq1avx8fGhpKSEH374gejoaOmGrEYTjUbD9evX8fDwYOXKlaxatYp7772X/fv3s337dqlNn/iu2hh6vR5/f38SExPx8/Pj6aefZtiwYRw8eJB58+axcOFCamtrVQ/Lfwf+9A5KQmO/fPkyixYt4sMPP2T8+PG8/vrruLq64uPjwxNPPIFer+9yDOhgWK1Wy8SJEyktLWX27NkUFxezZMkSfv75Z+Li4hy+LwdhOtDpdDg5OTF27FguXrzI7NmzaW5uJjIykhdffJGdO3dis9mkk1VNK2tpaZFs2qJIl5eXF7Nnz8ZkMlFRUcHAgQMBdSILO7ZOp2PAgAHMnz8fZ2dnLl26xMKFC0lPT5d6WiqfFb8HBgZKJYrLy8txd3dn0KBBPPjgg5L9UDQu6cpnYTKZCA4OJiwsjMWLF+Pl5cWyZcsYN24cUVFRUlVFIUDUtDubzUZMTAyTJ08mKCiI1NRUmpqaiIqK4u2332bJkiXy6pKqjmez2Sz1EZ08eTLh4eGcPHmSv//978yZMweDwcCAAQM64UA+D1dXV4KCgpg9ezbJycm0trZSX1/P3Xffzbp168jJyZH6yIr3qvGX0NqHDBlCXV0dTk5OREZG8sYbb2AwGKSuVGoHtjCznT9/njvuuAObzcaCBQswGo0cOXIEjUZD7969pZuUmmAVa3FxcSE3N5f7778fq9XKI488QmpqqtTIY/DgwZI9VnlIGQwGIiMjGTZsGBMnTsTDw4PJkyfz3nvv8cEHH9CvXz/i4uLUylZI+PHx8SE8PJxbbrmFhQsXMmzYMAoLC3n22WeJiIhg+vTphIaGqh5yYh42m42RI0fi4+NDdXU1+/fvx2AwcPjwYQIDA9m2bRu1tbWqvXAFfkTJkSNHjkiHySuvvMKdd97JpUuX+PLLL5k6dar0fTW/kslkwtvbG39/f0aNGsV9993HU089xerVq3n77bfx8vIiJydHeka+X8Sh7+rqil6vJzw8HIPBQFlZGZmZmbzwwgs89thj7Nu3j8DAQFXfi+CNgIAAySKxdetWnnzySe666y6Cg4PZs2cPx48flxqXKMf4d+A/Uo89ICBAqv8senSeO3eOqVOnMmrUKIYOHUp0dHSXGoBwStbV1REcHIzFYuGnn37iySef5KGHHqJv375S7WlRt0Hp0IEOLdXHxwc/Pz+GDh1Ke3s7H330Eb6+vnz11VesXr2a0tJSiTHlIJjG19dX0qoiIiI4fPgwH3/8McnJyZjNZtrb2ykpKVHtnwgdQlmn0zFo0CAmTZpEamoqH374IQMHDiQ0NJR7772XkJAQ1b6H4nfRZUqr1UqlcsPCwkhJSWH+/PlMnDiR6Ojo3z31RReg4OBghg4dyptvvsmiRYswGo2cP3+eoKAg6TqtBOEcCwwMpLW1lejoaAICAoiLi0Oj0RAWFoabmxupqakUFBR0OQe73Y6Hhwd9+/alrq6OkpISamtrycrK4qOPPqJfv34sXbqU8PBwVS1GHDh+fn6EhIRIh+aWLVuYMGECp06dIjU1lXvuucehI5aaWcnPz49u3brR1NRERESE1FVn+fLl3HrrrUybNo3+/ft3MgeJeWg0HY2fBw0aRFNTExqNhi+//JJly5aRlJSE0WgkKCgIf39/ySnblZZaWVnJrFmzqKmp4eDBg/j6+vL666/z+uuv09TURFNTU6fn5HstODiYwYMHU1dXR1hYGOfOnePUqVOsXLlSKnGrZgKR00U4JoUfZtq0aWRnZzNnzhxWr15NXFxcl4EKgjfc3d2Jj4+XWgF6eHjg4+PDZ599xtNPP01wcLAkkNUOfeHgnDhxIlVVVYwdO5YlS5awefNmRowYgbu7O4WFhZ1wIGiq0WikptUJCQnEx8fzwQcfMGrUKIqLi3nqqafo2bMnw4YNk55R8oXdbsfZ2ZmIiAgmTpxIbGwseXl5pKen4+7uzsaNG+nevTseHh4OBcmUa7HZbJLykJ2dTXp6OvX19URHR3P16lV69uwptc7732rr8B/ooCQQ4+PjQ2NjIz179iQiIoLIyEja29vZsWOHVDITuq6/ILQZUQZ17NixuLi48Je//IXExESGDx8u9QlVC6UUmrjJZKK1tZXKykri4uL45ptvpKiYt99+G39/fwdPuByEMPXx8cFms3H06FECAgJ45JFH2LhxI25ubri7uxMQENBJgxBM5+TkhK+vL7W1taSkpEjNjb///nuGDBnC1atXOzm05Ouw2zsif+SMdPHiRUaOHElRURH/j733jo+6Shf/35NkksxMekIqCQkkJJFQQ0cEQZqCyyK4iGVZRbDs2gt6dVUs69ph1RX1rhUpVhCpsmooSwmQENIb6T2ZlJnMJFN+f8A5+5lPPrh77+v19d7fffG8XnkRJvM5n3Oe5znPec5Td+zYQVZWlsfzWk5gHx8fTCYThYWF/P3vfycgIIBbb72V9PR04LwdUKlBqPEgfry9vamqqpLlaKdPn46XlxeTJ0+WjZPFd9WOZOV12cfHh4SEBKxWK9nZ2eTm5vL0009TVVUlm2NomcgEBAUFce7cOfLz82Vz9JEjRzJt2jSuueYaUfv8ooclnO8cL5qhl5SU8PDDD9PW1kZLSwthYWHS9/JzERR9fX1ERUVRXFyMl5cX77zzDi+//DImk4mSkhKJ/4vRRfBHeXk5nZ2dPPvss/zlL3/hrbfeIiwsjJMnT3rY49V0FopNf38/zc3N/OEPf6CmpoaIiAhZDdJoNMr3qYWh4FFvb2/0ej1jx44lLS2NZ599lpqaGm6++WZee+01j05BWrcocXAFBAQQFxfHgQMHmDNnDqdOnaKgoAC9Xk9MTMzPRkzpdDqGDBmC2+1m0qRJnD17lvfee48VK1awb98+rrzySo+oOC26enl5yVLWO3fuJCIigs2bN/PMM8+wdetWZsyYIQvxqWWP8v+BgYHU1tZit9sZP348jz76KM899xy33HILfn5+HpVptfa9j4+PlAuxsbHYbDZuuOEGJk+ezI033ojBYCAhIUHTR/jvwC/uPFUyXHh4uOx2fuWVVxIVFcXHH3/M3r17aWpq0nRaKj3VoaGhsutLcnIyX3zxBfPnz8dgMPD1118TGRl5Uc0OkHZQf39/enp62L9/Pzt27KClpYWNGzficDgIDAwcUEFOgBjXYDDQ29tLcnIyX375JaGhoTz66KMUFBTIpstqE4YyfMzpdDJixAi+++47urq6KC8v5+uvv+aVV16hqqrKw7atfr9yQ+r1el588UV+/PFHrrjiCl5++WXmz58vNW/lnNVrcLvdMqwxMDCQdevWsWLFCgYPHsyf//xncnNzpUC9mOkB/lnnvKGhgbvvvpunnnqKoKAgrrnmGrZs2UJ7e7u8sqvjlgWtAgICiIiI4J577uH+++/HbrcTHh7O1Vdfja+vL62trRfVhMS/er2epKQk4uLiaG9v56GHHgLgxhtv5IUXXqClpeVnTQfikHK5XHzzzTdYLBbS09Opr69nxowZtLS00NbWpvm8EicGg4G2tjY+//xzysrKePrpp+WNZt++fRQXF/+svwDOl+PNyMjg7NmzdHR0EBsbS3l5Ob/97W8JDw+X79Jy9AEylLiuro7f/va3PPvss+zYsYNHHnmEV155hbq6Ok0nsNhrbvf5Pp8dHR289957fPvtt5jNZvbs2UN7ezvr16+XIbVa81DyR3t7O9988w3ff/89PT09TJkyhaioKJKSkqStX4seys9LSkrw9vbmxIkTvPzyy0yZMoXDhw/T1NSE1Wod0ORcTZOAgAD6+/sJDQ3ljjvuYNGiRRw4cICtW7fyyiuvkJ+fr+l/Ucoig8FAZGQkYWFhPPbYY/Jge//99ykuLqajo8OjcqRyDmJN3t7etLa2kpOTw/79+1m1ahULFixg/Pjx7Nu3j87Ozv9/mGLgn8LdZrNRWlpKbGwsTz31lAxHe/rpp3nvvfc4d+6ch9NGgDqOvampia1bt+Jyne8jGBERwW9/+1v6+vo4d+7cRQksxhXlfQ8ePEhNTQ0+Pj4UFhaycOFCAgMDOXbsmIfGIUB5Gvf19REdHc0PP/zAPffcQ1FREQaDgcTERLq6uoiOjtbsNC7GFLa2NWvWMHnyZG6++WaOHz9OcXExt912GzExMR5CSzkH8a/NZsNoNLJs2TIuu+wyrr32WkaNGkVWVhbZ2dnSlKLlBFYedElJSdTX13PPPfdQVVXFzp07mTx5Mrt27aK3t1d66tWajDCR9fT00NTURGFhIQ888AA33XQT+fn5rFy5koSEBJkvoJ6L0Di9vM53pTIYDFx11VU89NBDJCQkcPvtt3P55Zdz++23ezx3MU1G1DkXZhmj0ciwYcOwWCwsWbKE8vJyTcGuFKhOp5OhQ4cSGhpKQ0MDd911F2+//Ta7du1i6NCh5ObmyjEuZhbq7e3F4XDwwQcfcPPNN+N0OomKimLmzJlUVVXR2tqq6exT8phozj1jxgzq6uooLS2ltraW/fv3c/ToUZqbmz2iT5T4dLvdMl5+8eLFZGRkEB8fT3t7OxMnTuSGG26QuQFae0Wsw2KxEBAQwNChQ5k4cSK7du3CbDZLs2NHR8cAQSjmob5xrly5kk8//ZQPPviArVu3snTpUo4fP87x48dldI6W30N87uvrS3FxMfPmzWP27NlcfvnlXHXVVWzfvp3ExMSL3qLEmCI8eOzYsTzxxBOsWbOGyy+/nPvuu4+2tjZlt7QBZmAxB7vdTlVVFSUlJdxzzz3s2bMHnU7H3//+d0pLSy/azk5JFyE30tLSuOuuuxg/fjwvvPAC7733nvTniGin/yr84oK9v79fNkMWp/Tw4cMxGo088sgjXHnllfJUVSaYCFAusr+/n7i4OEJDQxkyZAgnTpygu7ubN998k1mzZlFSUkJPT89Fx1Ai94orriA1NZXu7m6ef/55Fi5cyKpVq+T3tEAQyeFw0N7ezpIlS/D29iYsLAxfX19SUlK48soryc7OHsDgIplB/Pj6+hIWFobVaqW1tZXFixeTlpbG6tWrsdlsdHV1Ddg44neR6OHv7096ejqPPfYY9913H+PHj+eRRx4hIiJCdmnRsieLG4lgori4OG688UbZju3xxx/n1VdflV76n8OFEBKTJk0iJCSErVu38o9//IMnn3ySmpoa7HY73d3dmqGfwmTgcDjo7Oxk1apVPP7441x77bX86U9/4r777uO9995Dr9dfdC0Cv06nk+7ubsLDw7nvvvuYM2cOCxYsYNiwYbz00ktERERIrexiNzFhgoiLi+P6669n0aJFAGRnZ+Pt7S1jsLWedzqdkrYZGRns3r2b0NBQVqxYwUsvvURHRwehoaG0trZqhrKK3+12O3q9nu7ubiIjI2loaOCBBx4gJSWF1157jejoaMaPH09PT8+A2604bEXf3oKCAhwOB0899RRhYWGsXr3aI2pL+V7xu06nk9FUTU1NzJ49Gx8fH/Ly8rj++uvZsGEDq1evpqmpycMkp16H+DwiIgK9Xi8F2p///Gdqamo4d+6c7KOgdcsWfCpkQ2VlpXQMx8fHM3PmTF566SVKSkokj6rpojSdud3nG4Xff//9PPnkk9TW1nLbbbcxbdo0zp49O6AJtZLHRbBDamoqTqeTxMREhg8fzuWXX86xY8d4/vnnyc7OHsBPSpyIJjDt7e2kpqZSV1dHeno60dHRLF++nPvvv5/Tp09f1Lz1r+AXj4oRSR/19fXYbDYmTpzIwoULaWlpYcyYMXR3d/PVV18xatQobDbbAM1Op9PJRIW2tjaqqqpISUmhu7ubm266iaFDh7Jt2zZ2797NyJEj1d16PMZxuc736Tx79iwhISEkJyeTnJxMa2srb775Jnl5efT390stVakdCuYwm80UFRXhcrmIiopi8uTJZGZmyhCmDz/8kPb2dik8lQTq6+ujvr6egIAACgsLiYyMJCEhgUmTJhEfH8/48eN5/vnnZStBrXU4HA6sVivNzc3U19cTHBxMV1cXvr6+LF++nJEjR7Jnzx7q6uowGAwD5iDw2dDQQG1tLRUVFYwePZrRo0fT1NTEmDFjeP311/nNb37DhAkTPOydShC4tFgstLW10d3dzaxZs5gyZQq+vr4kJSWRk5NDcnKyRzKMEkS4pPiprq4mKSmJhQsXEhwczPr164mKiqK6ulrTTi9o2tDQgMPhICoqigkTJmAwGAgODqakpESaDdLT05UdqTzmoNOdb3lYXl5ObW0tI0eOZNy4cbjdbkJDQ/nyyy/Jzc3l2muvleGEag3T29sbs9ksr/1TpkwhODiYjIwMJkyYwOeff84LL7zA2LFjB5grxBhCiDQ3N1NbW0tERASLFy8mMDBQOhDPnDnDM888I4W6UrsV2bsWi4WGhgaGDBlCRkYGgwcPpra2lqVLl1JbW8u5c+d+NuSyvr6exsZGwsLCaGtrY+zYsfLgzMjI4NSpU3R3d3tE+Cj5wm63YzabsVqt5OXlYbFYmDhxIunp6fzwww9y/508eVLOQX04CAfzmTNnaGhoYM6cOcydOxer1cr8+fPljwhY0PLNuVwuGhsbZTs8cYvV6XQsXryYESNGkJWVhclkkoEbWgphS0sLRUVFtLe3k5mZicPhYPny5fz617+mpqaGbdu2sWDBAs0DSvhd+vv7qaiokLb8ZcuWkZaWRltbG6tXr2bu3LmyNaWW8vGv4BcX7E6nk66uLhl/W1xcjJ+fH6GhofT29jJx4kRmzZrFqVOnZLSHFgQGBtLV1cWoUaOk5l9TUyPNBf7+/hw8eNDDTqgEm81Ge3s7BQUFpKSkEBcXR1VVFT4+PnR0dHDZZZfx1FNPERISIgmkFiJu9/kIjFGjRknhbzQaqaur44orruAvf/kL48ePx263YzKZPMKnhCblcDj46aefqK2tpa+vj+rqarq7u5k6dSrbt2/nzTff5Pvvv8fPz0/zcBJhmzk5OXR1dWEymeju7iYkJIS2tjbKy8ulKUekkKvNMb6+vjQ3N6PT6QgJCSE/Px+LxUJISAgJCQn09PSQnJzMBx98cNGswN7eXhkB5Ha7qaqqIiIiAqvVSmlpKSdPnuSxxx6jqKhIChE1OBwO6urqyM7O5tixY+h0OsrLy/nxxx8xGo08/fTTPPvss9TW1l60vEF/fz89PT10d3dL+kZFRTFixAj0ej2///3vmTdvHgUFBRc19TkcDkwmEzabjWPHjklnY2VlJefOnSMsLIxPPvmExsZGj9hrJV0sFgs1NTUcOXKEL7/8Umq91dXV5Obm8tBDD3H27FmZ5i+eU46h051Phunv78dqtXL27FkqKio4ffo0AGvWrMFkMrFgwQLCwsI8aCv+ra2tJTc3l/z8fIxGI2azmYaGBk6cOMGYMWOYM2cOQUFBmvvM7XbLG0NSUhIGg0FqxB0dHRQVFWGz2cjJySElJUWapdQRaDrd+bBLk8lEYmIiQUFB5OXlERAQwJQpUygqKiIrK4vMzEyPd6t54+zZs9jtdlpaWjh8+DA1NTUEBAQwatQo+vr6mDlzpiyzoKUle3t7y9yDxsZGysrK6OrqorGxkZqaGt544w3Cw8NlX1stEMpcT08PBw8epLS0FL1ez9mzZ2lubua2227j4MGDnDp1SloL1OB0OmX48YEDB2hsbESv1xMXF0dsbCwpKSnMnj2bkJAQj3IP/xX4RUsKiNPKZrOxY8cOjh8/ztGjR9m1axeLFi3iL3/5CytXriQ6OpqRI0fKtHGl1i60mNzcXPz8/Lj22mt599132b9/P++88w579+7l8ccfZ926dTz88MOaGWBiPHE4HDhwgKNHj0rh94c//IHPP/8cnU4nGxWLzau0vel0Og4ePEh8fDwRERHMmTOHb775hoyMDP76179K+6G4wisdJyKqx+12M3LkSHJycti3bx/l5eVER0ezc+dOXnjhBTZt2sSUKVM0087FfBwOB0lJSdTV1VFfX09JSQmlpaUya3bVqlWyno7QppSRPg6HA39/f/bs2cPVV19NVVUVcXFxPPzwwwwfPpxdu3aRk5NDT0+P1PqV4HK5pJNwyJAhnDx5koqKCpxOJwaDgf3793PllVcybdo0SkpKZBy6WssVccqJiYnk5eWRm5tLVlYWycnJzJ8/n3vuuQcfHx+uvvpqZTNsOYbYvOHh4Zw8eZKenh6am5tpaWlhz549zJgxg/DwcGw224BeqsoxRIvF0NBQvvjiC/r6+tiwYQNut5vnn38ef39/1itYbNgAACAASURBVK1bJ5NYtKKuRMmCzz77jN7eXjo6OmhtbaW4uJgDBw5w5MgRkpKSuOuuuzCZTJqHdk9Pj6yPk5WVxT333MPJkydpaWkhLy+P3bt389vf/lbuEzX09vbS1NTEkCFDZKLLnXfeyejRo3nkkUcoKCjgww8/ZOHChReNx9fpzocIVlRUcOedd3LllVcybNgwiouLZfLWu+++i8FgkI3BlftV0LWmpoYTJ04wdOhQLrvsMp544gm8vLxoaGjgscceo6SkhMGDBxMQECB5SjmXvr4+Bg0aRFBQEOvWrWPYsGGEhoaSmprK448/zoMPPojRaCQzM1PzVimUytbWVs6dO0dVVRVdXV2EhoZSXl5OUFAQU6dOZezYsfT398swZrUfSNRzGT16NHV1dXz44YdMnTqVs2fPcvvtt+N0Onn++ecJDQ1V9tP1GMPlcpGTk8PIkSNJTEzkySefZMaMGcyZM4fJkydL3hWZzv8d+B8xxTgcDhYtWkRTUxPvvvsuEydOJDY2lhUrVuB0Opk6dSoOh0NqOR4T9jpfjEmk/trtdl566SWCgoI4fPgw48ePp7a2lquuukpmbIp3K8dwuVzYbDYSEhJ4/fXXueKKK/jkk08wm82kpKRQUFDA0KFDNWOEBYgIkuDgYJYuXYq/vz8Gg4GAgAD+/Oc/8+abbzJ06FCPuGvlPHx9ffH398dkMvHKK6/w0UcfceDAAdxuN+PGjeOVV17h8ccf9+gFqxW1UFlZSWtrKwcPHuTRRx8lICCABx54gAULFsjDTtwwtMLAfHx8pO27qamJdevWcfDgQd555x3++te/kpqayubNm2X8sZamLOKbDx8+zI4dO3j66adlskhzczMmk4nw8HBmzJgh497VG8/Hxwer1UpOTg4xMTHMnDmTzz//nNraWqZNm8Ynn3yCv78/7e3tHo4wJYjMwuDgYGJiYli9ejWrVq1i3rx5ZGZmcvnll7NgwQISEhIuqqW6XC4KCwsxm82sXbsWgJUrV1JbW8u8efP4zW9+Q2FhoSyypoUPceAuX76cMWPGcPLkSfr7+7nnnnuoqanhrrvuYvbs2R6x22owGo00NzdTUVHBjBkz+N3vfsfLL79MYWEhgwcPZty4caxfv16OoRzH7XZLE1hERATvvvsuGzZs4NChQ0ycOBGX63ytkwcffJBBgwZpXvfF2s6ePYter2fRokUyEWjhwoXcddddfP3110yfPl3yhRaPmUwmxowZQ2hoKN9++y1Hjhzh3nvvxWw2M2zYMCZPnsyECRNITEyUdnC1MDQajXR1dfHuu+9SXV3Ntm3b8PX1lWGPYkzxrNZavLy8ZO2esrIy9u7dy6xZs1i4cCE33ngj0dHRjBs3Toa4avGH8Mlt2rSJOXPm8N5777Fnzx6SkpJYvHgxBoOBgwcPYjAYPIqaKSEgIICEhATa2tqYNm0a06dPZ+XKlRw9epQbbriBU6dOMXfuXAYNGgT8M0/kvwK/aGs814USnqIuidlsJicnh08++YQ//vGPdHR04OPjw8iRIwd4wnUXsOy6UPZSZAVu376d+Ph4/P39iY+PR6/Xk5+fT0ZGBqGhoXIMQI7hPg+43W4aGhr4/vvviYyMJDQ0lNOnT3P77bdz9OhRJk+e7FH86wLTynnodDoZ7VJeXi4FbV5eHmazmczMTFJTUz3MOWIeYg463fmiRIGBgbS2tpKQkEBBQQHFxcWEhIQwd+5cD3ufEhcXloLA6ddff01qaiqlpaWMGjWK/Px8rrrqKvR6/QBNSIlPcVOprq6mubmZ9vZ2ioqKyMzMpKCggKlTpzJ8+PABmqVyHi6Xi97eXsxmM+3t7ezevZvp06fT1NSE2Wxm2bJleHl5ycNBMY7HWmw2myyREBsby4kTJzh69Ch33HEHLpeLiIgIj1vThY3ssRan00lHRwf5+fmUlpaSmZnJ8ePH8fPzIz09nUmTJsnnBU68VM3SnU4n9fX11NbWEhsbS0BAAFlZWfT09PCrX/0KLy/PqplK3nC7z5fMtdlsdHR0yBo6XV1dWCwWRo0ahbe3N0OHDpVav3otAh9WqxUfHx+++eYbUlNTSUxMpLa2lr179zJlyhRGjhzpYXq4sCYdnC+DLEwpn332GdOnT+evf/0rsbGxpKenk5GRgY+PDxEREWoh5oELQVs/Pz8KCwv59ttvSUhIYNmyZZSWlpKWlubRvF0xB8Q8bDYbnZ2dlJSUcPToUe6++27+9re/kZ6ezpQpU/Dz8xsQoaXcr4JOPT09+Pr6snPnTk6cOEFaWhqLFy+mqamJlJSUAc29tXjD6XSSl5fHt99+S0xMDCkpKdjtdsaMGSNDpJWKmJeq3LfVaqW6upqYmBiMRiOHDh2iubmZgIAAwsLCGD16NCaTSZPPxRh2ux2r1cqRI0coLy/nyiuvJDk5mT179mAymZgzZ45UQBUO6H/bHvM/0swa/um0E5tZlKns6+vD39/fc5IajKJ0Dol4Y6vVSkhIyACzhZZgF58LDQ3Oa52iRKwoJ6rcdFoCEZDxquJk9ff3l+8Uc1Ge3DqdTudS1WUWNnphMhFMrk711hJC4ror5uLt7Y2Pj4+89QhfhUrb9xDKSnr09/djMBik6UUZ7ql09HmpmjfrdOdDN3U6nYxgsNvtBAQEyHWoO7ijYnixBiG8+/r66Ovrk3ZgZbiretO4FLW/BW/4+vrS1dVFUFCQdMb7+voOKIesnIdYo9AexY1GaKMGg0HTNKaeh8CpwJswh4hbq9p5q8SpoIvgDR8fH8kbNptN+lJEiVflTcpLUY9defBYrVbJ7/7+/jidTplxrDJfeChASrw7nU56e3vx9vaWJWqVpSrEOy+21wDpAxNCWqfTeZREUGj9A8ZQ4lH4rkSknclk0sp7GcBfLtf5TFtRCkQkFAkQv6vlhpK/BB69vb1lTSrh7xK3TyVdteYh+FzgU8g/YYNXKoNKfPw78Es3s1auSxJQ7dEXDKYMwVIjRsFAA7R7ARqCYMDhoP6uUngp36PcNODZoEJpt9aKFb/wfeXnOvU6lPNX00Q5J/Uhp9544l2KU37APJTrUOJCQ/h7PKceS31zUGxINc4GCGStw1a5DiVPKN+rRWMUAlVJEzUdVBql2t+guZaL8YEALc2OC0JZ+XflGKpDWlMrU24U5XNatNXgAR0q3tDiVfGsiqYeuNCipfIgUI+htdd+jreUvK+ck5quPycn1HPQ4i8xhha+1HNQjq91I1TTUckvWvj9VzjV+r5aFqnG+JfwSwv2S3AJLsEluAT/j+FSz9NLcAkuwSX4PwaXBPsluASX4BL8H4NLgv0SXIJLcAn+j8EvmqCEhkPn33A6aEaCiM+VDhT1cyKzUPGeAVELSoeSeL/aSaMErXkonUlqp4pybYr1yXA04V0Xf1M71pTjinl5qbrIazjgZBagt7e3jOBQzXGAM1q8V4kH5fzdF6Ja1BFCYh7K5wSoHXxKx9SFfz0cUxdzjKkdf8qsUYEPp9PpVnzmEcmhjtpQ00sd+aB2zms55dXrVYc7qh2oauecciylY/3Cv26t96txq6a7gs8lTS7m1FY+p+LRiwYZCNDat6puYwMiWtR0U9JW+R3FfD1oolqjx/MXc1BrzUMJ6nh5Ldwox1Dyzs85UsWzF5uHVqCAFo5V8/y3nae/qMauLuqlZA4RUue6kNItwuW0CCHCCtWbRE1kZdU8JQGV4XvKTaWxQQYIF/U8lOtQElK8s7+/X/OgEIJaCEvl35Vlbd1utwwhVIN4h5LRxNjKeF5lgoMan2qhIcZUMp1Ymzq6RTmG+nc1LnS6f4ZAKvGqXIvAqwCRoKaktxhHI9TQoxmJUkgoN6DAu1KQqTeQ+hDQEopqAaWct1pQqnlH66BS87r4m3rTa/HZxQS48hmxZiWexbMiXFdJBzGGMjJNuT71Aaqkj/rw0drDYp4iyUvw18UOMDXPqAW5Fi6UcDF+U+Jd4E9JS+U8xHfEnMX+VM9LS3aox1Dzp3IOysNDSaf/CvyiGrvQGsWkRSEhwRRtbW0kJSWxZcsWrr/+eioqKggLC5OJRkoQQlOnO1+wSafT0dXVRUJCAidPnqSqqor58+dTWVlJSkqKRwcjtcbU29uLv78/bW1tGI1Gzp07JxMuent7GTt27ID3KwnicrnkXPR6PXV1dZhMJpmNabFYqK2tZciQIbJmjBhDENdqtcoYWLPZLIse1dXVYTQaqa6uZvTo0TLRCAaWMNbpdLJOSnR0NB0dHbhc52vStLS0EBAQQGJi4gA8KoWIOFj7+vpkq7Kuri7i4uKorq4mOjqa4ODgAaUFxDxEbLPT6ZS1aQSd6+vrSUw830/S5XIRGBjoQQcheJS1wUVThKKiIsLCwmQMeUREhEwJV9JESVtRv0bEClssFuLi4vjxxx9JS0uju7ubqKgojzHUAqq3t5eenh78/f2x2+2y8mRUVBT+/v5YrVb8/PwG0FV9MxDVF61WK5GRkZw6dYpz584xduxYoqOj8fLy8ohrVx4qYh4iflvcmkTJX5FvERgYiNFoHBDmKRSFvr4+OQ+9Xk9nZyf9/f3U1tYyduxYmcKupcy43W5ZzCs8PJy2tjbCwsKora2lpaWFtLQ0AgMDZfKhEp/iIBDzEDgTt8kzZ84AMHr0aCwWCzrd+Qbd6r0meKO/v5/e3l7ZstJkMlFdXU1ERASHDx8mISGB9PR0TaVFjCca7Lhc57s75efnA9Da2orT6WT27NkD8Kg80EQMu81mk415ioqKiI6OpqqqirFjx2KxWGRJCPVaBF1cLpesdipKH9tsNgoKCmTT70GDBmkqMj8Hv7iNXanx5OfnU19fj7e3N3l5ebS3t7Njxw6mTJkiS3IKLU+AUpjp9XoaGxvx8fGR2YaihnZGRgYu1/kysna7XVODEogtKyujp6eHvr4+Ghoa5GEh6p6Icqdap6aoaCdKqwoB1tnZSWVlJf/5n/8pG1Yri5rpdDpZplTZN7Gzs5P6+nqqq6vx8/OjubmZrq4uWWVSrTmJ9YgaPKWlpTQ1NZGVlUV+fr4suiW6wItqhEoQ+HQ6nbS3t8tm4N7e3litVuLi4ti9ezeDBw8mMjLSIxtXPC+0l/7+fvr6+sjNzcXlcnH69GkqKytlzfD8/HzOnDmjWQtduR7BH263Wx7YXl5evPHGGzQ3N8uEFPXz4kckuvn5+VFaWkpFRQWxsbGyZPT27duJi4uT3a+UaxFz6O3tpbKyUv7o9XoqKipoa2vD4XCQm5sr6+xoaYhCOFdXV8tDWmTvhoSEEBAQgMViITs7e0CRNzGeSL5xOBwYjUYMBoPMEu7q6kKv13Pq1CmCgoI8EvuUYzmdTsxmM11dXVRXV1NVVUVRURHe3t4yWzs4OFgmySnHEPMQWcWinVtTUxM5OTkMHjwYt9vNd999x4kTJ362lZvD4aCjowO73c6ZM2coLi6W+6qhoYFdu3ZRWVmJ0WgcoCmL58VedrlcFBUVSb7u7u6WylhcXNyAIl5Kuvb19ck+wp2dnbS3tzNkyBDa2tpk16+CggLN0tAC7HY7FRUV+Pv7U1JSwuHDh7HZbISFhREVFcWZM2cGZNOq8drX10djY6MsOFdXV4dOpyMpKYnIyEjq6+tpa2vDYrH8lzX2X7xWjFhUd3c3AEOHDuWll14CYPz48XR3d7N27VqOHz8u052VIDQpUVgoJiaGjRs3UltbS319Pbt37wbgxRdfJDAwkPDw8AHFdJQmipaWFkpKSmSnIp3ufOGvrKwsjh49yvjx40lOTr7o6a3T6Whra6O1tZWGhgb2799PZmYmYWFh2O12qSG3t7drMr1er8doNBIWFibX7HK5SE5OZt26dYwaNYqPP/4Yf39/jwa5Ap9iHaJsr5hLf3+/1KKMRiNWq5XU1FSZaagFFouFvLw8wsPD2bt3r6zqCPD555+Tn59PdXW1vE0IUGplPj4+dHd3c/jwYXp7exk8eDBGo5Fvv/0Wf39/kpKSSE5OHnALU5onRIek0aNHs3btWtxuNwcOHOD06dM8+eSTHDlyhJ6eHvR6/QB8CJw0NDSQl5dHWVkZQUFBtLe34+3tTXFxMcnJyaSlpdHY2Djg6q1ck3L9qamplJWVkZSUBMC6desoLS2VionWgQvQ09NDdHQ0x44dY+vWrbIM66ZNm6iqqiIyMpKgoKCLHgw+Pj7U19dLodrV1UVeXh59fX309vayefNmEhMTKS0t9WgErTbrtbe3k5ubS2lpKaNHj2bo0KHs2LGD119/XQpJrWJkAjfd3d0UFRXR09NDY2MjNpsNb29vysrK+Omnn6ivr9fszSv2uyi6VlVVxfvvv4/JZMJoNPLDDz9QXV3N0aNHmT17trzFqfer0gSSl5fHli1bSEhIwMfHh6NHj3Ls2DFZ7lncYpTzEIqHwIvBYODjjz+msbGRvLw8XC4Xp06dkvWKBg8eLG8E6jEEz3V0dFBWVia7JSUmJlJfX8/f/vY3OY6fn98AJUYop97e3tTX1/PRRx/x1ltvYbfbaWho4Pjx40yfPp3p06cTHx//3yoG9j/SzNrb25u+vj6sVit/+tOfuOqqq4iJicFmszF58mRuuOEGhg0bRmNjI6DtvPH19ZXmhgkTJjBixAgCAwOZMGECRqOR4cOHs3nzZnp6ejSfV9oqr7rqKg4ePEhkZCRDhw7l7NmzzJw5k0GDBpGTk0NHR4em3dTtdst086KiIvLz8zl58iTZ2dkEBgbyzjvv8OGHH3LgwAFSUlLke5Vr0unOl6bdvn07dXV17N27F5fLJTfvZ599RmJiIomJiZr2Vi+vf/ZwLC0tZebMmVRXV2MwGPD392fQoEEsW7aM5ORkWTJALZTFj8Viobi4mK1bt+Lj44O/vz/Z2dns3LmTDz74gAkTJhAeHq6JSzGWqAl//fXXk5WVRVxcHG63mxUrVlBUVER5eTk2m+2idBUmtVOnTsmmBc3NzYwZMwY/Pz+uu+46brvtNpker3Z+iTGGDBlCU1MTX3/9Nb6+vowaNYoffviBwMBA7HY7l19+uTxc1NqhwEdoaCjff/89hYWF6PV6Bg8ezKBBg6ivr+fs2bNERUURHx8v36kEIcyCgoLYvHkze/fu5YEHHqC9vZ2TJ0/y61//msLCQkpKShg1apQmLsRnSUlJfPbZZzz44IO8+uqrJCQkEBsbC0BcXBwnT54kPj5+gL1YzKmjo4Pe3l4mTZpEWVkZDQ0Nkj8yMjKIioqSAlU9D4ELp9PJ8OHD+eqrr9i2bRsmkwmz2cyBAweIi4uT9VG0fEECP01NTQQEBLBmzRrMZrM0VzY2NrJixQrZI1htUhP7VJikhEnw448/pqysjLi4OHJycmhubqapqUmzAqlyHD8/P3bu3El9fT0ZGRlkZGRgNpvp7OzE7Xbz2WefyQNKS9t2Op34+PgQFxeHw+GgublZNjJ5//33GTFihMcho4UTh8NBfX09NTU15OTkABAVFcWYMWPQ6XSYzWa+++47rFbrf1mow/+Axu5yueR1KiwsTJY1DQ0N5R//+Af+/v5s2bJFFt8Xz6nBbreTl5cny/y+9957BAcH4+fnx+TJk9HpdFx//fVS49caQ6/Xc+TIEc6dO8fSpUvZtm0bDQ0NdHZ2UldXx3PPPcfQoUMJCgoC8LBziY1js9kICAjAaDQyb9481q1bx5AhQ6itreXNN9/k/vvv59prr5XXdaUTU/xusVh47bXXePjhh+np6SEuLg6r1cqhQ4c4ffo0GRkZ+Pv7D2ASpX0/NzeXyy67jFOnTjF+/HgyMzMJDAwkLy+PtLQ0QkJCPOqtCFDa++Li4ujo6OA//uM/8PX1xc/PD7PZzObNm2VNca0SsUptqKamhpaWFg4ePCjtwklJSbzyyit0dXUxbdo0EhISBhxS4vm+vj5CQkKIiYnh8ccfZ8uWLbIrVXl5OTfffDMtLS3SNKME4WwSm23z5s1ce+217Nu3Dx8fHyZOnIi/vz9ffvklZ8+e1dSUxf9dLhe7du1i6tSpbNiwge3btxMVFUVZWRk+Pj688cYbmEwmD9u6mjdEvZ4bb7yRnp4eqqurGTZsGCkpKXz55Zfs37+fmJgYurq6BjjIlP4XOF9DKCoqisWLFxMVFSXrAVVVVXHdddd5+JAELgSdhY/i+uuvJzMzk6ioKEpKSrj55pv55ptvqKurkyYVtaYsxsnPz+fFF19k4sSJPPbYY4wYMQKj0cjXX3/NuXPn0Ol0cp9o4bO/v5+cnBxeeuklzpw5g8ViweFwEBQUxOzZs0lKSsLLy+uiLeUETYxGI2PHjuXgwYNcf/31TJw4kfr6esaNG0dnZ6e0raujs5Q8tnPnTnx8fHjggQcIDAzEz8+PxsZGgoODeeONN1i9erU086lNjkIhrKysZNWqVVxzzTWEhIQQGhrKFVdcwZQpU7Db7SQkJBATEzPAuapUbsvKypg2bRp/+MMfmDdvHvHx8ZSWlvLZZ5/hcrnIyMggJCTEQ1b8u/CL29jFwo4cOUJzczPh4eHSOdXW1saNN95IZGQkU6ZM8ej0LUBtb+/q6qKzs5NrrrkGm81GWVkZa9asYcqUKZw6dUoWqleCGMNqtTJ37lwqKirIzMxkwoQJREREMH36dEpLS+nv75fOPrVAVHr1dTodra2tfPrppzQ0NGCz2fDx8eHNN98kISFB9lJVM4lOd76Rgl6vZ9WqVbz66qssWrSI06dPM2TIEObMmcPzzz9PWFiYLHCkvNYJpunv7ycgIACz2UxpaSmFhYUUFBSwfv16WbEyODhYM6xK6ZhqbW0lNTWVHTt2yCJJnZ2dNDc3M2TIEMrLyz2KeKlxIZjRy8uLAwcOSHo3NDTQ3d1NSkqKtEuraSlANB948MEH+eGHH5g7dy5tbW2YzWaKi4sZO3astH2qNTsBDoeDI0eOMHToUGJiYvD396ewsJDXXnuNDRs2UF9fL23tF5uHn58f/f39VFVVkZycTHh4OMXFxVitVnJzcxkzZoy04Yt1KvlSwKFDh+R6goKCOHPmDG+//bbsbp+QkCAPy4tp7RaLheTkZO644w6Ki4vp7u5mw4YNlJaWEhERQWFhoZyHWjB7e3tTXl5OcHAwZrOZxMRE3G432dnZVFRUMG3aNCkM1SAif0Qby9bWVjZv3ozFYpF+g4KCAkaPHs2MGTM0eUOpJc+cOZNHHnmEf/zjH7Li6MmTJ/nhhx/49a9/TU5OjmZ5aoFTvV5PaWkpOTk5ZGZm0tfXx4kTJ/Dy8iIjI4OkpCSmTp0qD0n17VasZe7cuezZs4esrCz+8z//E4PBQHh4OIcPH2bBggUUFhZqatnKaKq///3vzJ8/n127dpGcnExfXx9vv/02lZWV7Nq1S65BPQ8BNpuN4OBgbDYbQUFBUok1GAxUV1dz4sQJUlJS/tuNNn5xU4yX1/ni+llZWXz44YesX7+eZcuWsXXrVt566y1GjhxJRUUFLS0tA2xcyjHcbjeffvopDoeDcePGSe/80aNHSU9PZ+PGjQQHB0tPs3oMYUNdv349vb29LF26FF9fX7Kysli/fj3vvfceGzZskFq5mkDKUMT8/Hzuvfdevv/+e+677z62bt1KUVERjz76KOXl5dKpKuYuQGi4O3bs4K9//SuvvPIK48aNk5Eat956K8eOHaO6ulq+Tx226Xa7aWlpITAwkFdffZWenh4mTZrE66+/zvDhwyktLSUmJoaSkhLNzusCHw6Hg56eHkaOHEl4eDjvvPMOjY2NbNq0Cb1eT3NzMxaLBbPZrKld6nQ6Ojo6OHPmDD/++CMul0s62B5//HE+/fRTcnNziYyMlM9q2VErKytJTk7m1ltvZfny5dxwww189dVXlJeX09HRQUhICMXFxR72dOUYcH5zpKamcv3111NcXCzX8vvf/55nnnlG3oBEH9mL3cSampqIiori3Xff5dVXX6Wzs5PHHnuMzMxMXnzxRSwWC729vQO0KTFeU1MTqampFBQUsGTJEjZv3kxubi6PPvooR48eZe3atRw4cECzj6zQOO12O8899xwbN27E29tbmiFmzJjBjTfeyPfff09mZqbs0akOT+zr62P06NGEhobyzDPPsHbtWioqKujs7GTXrl10dHRIE4Tga/U+EYI5MzOTmpoaGhsbcTqdssHF7t27pX9KrQCJ5/v6+jh27Bi+vr5s2LCBP/7xj/zud78jLy+PtWvXSr+HlmYqPuvu7sZkMnHvvfcyd+5cHnjgAQ4ePAhAXl4ebW1t9Pf3S2ej1o2wsrKS9evX8+OPP/LTTz8xYsQInn76aU6dOsW4ceNobGyUHZkudtB6e3sTExPD8uXL0ev1vPzyy2zatImjR4+SlJQkgxzUNFFCZ2cnERERMmjikUcewd/fn1/96lcsXbqU/fv3U1hYKBvd/692nooF6vV6brnlFs6cOcNDDz3EG2+8wYIFC4iMjKS5uZmrr76a6OhoGcGhvuoK58OaNWvw8fFhw4YNBAUFERYWxnXXXcf9999PYGAgMTExAB5xuuB5VX7ooYdk78GVK1fyzjvvcO+991JcXExfXx92u12GuWld2xsbG+np6eHYsWN8+umnrF69muHDh3PNNdfwwQcf8N1330kPvJYN1M/Pjzlz5jB79mw++eQTsrKymDNnDitXruShhx6iuLiYMWPGyG4satDpdCQkJJCQkMBll11GREQEq1evJjMzk/fff58JEybw7rvvUl5eDvyzjLB6Ha2trWzfvh2r1cpHH31EWVkZmzZtYu3atXzyySd88cUXMiRTaNzqMby8vEhNTWXLli0sXbqUmTNnMnHiRLKzsykqKmLJkiWUlJTIcD01eHl5SbOWaER+66238uabb5KcnIzZbOa1115jxowZtLW1aTo+3e7zoaOC/vv27aO2tpbU1FS++OILxowZQ1dXl2ZLO+UYvr6+zJkzB39/f6qqqjh27BjpCZnNGgAAIABJREFU6elMnjyZJ554gpMnT9LY2CidY2phBhASEiKbwixZsoSlS5dy+vRpfHx8eP3119m4cSNms1nTwSbm1dXVhcFgYOzYsWzdulWGaaalpdHZ2cmiRYtobGykv7/fYwwxB19fX8rKytDpdFxxxRXMmTOHqVOnEhkZSUxMDFdddRURERGavTUFbmtqavjqq6/Q6/XExsYydepUzpw5w+uvv05ISAgvvviidCKraaKMc9+xYwcffPABN910E1deeSWzZs3C4XDw2WefUVNTI9tDqnlDaNt6vZ6vvvqKH3/8kbfffhuj0SgjsB5++GFaWlo4ffq0dDaqxxERJ+np6cyaNYu3336btrY2Ro4cydixY/nNb37DfffdR3Nz88/ePmpqamhtbeWWW24hMjKSuXPnctVVV7Fp0yZuueUW/va3v9He3i4VQi2TYWBgII2NjTIQ4N577+Wll17iD3/4A7fddhu33XYbo0aNkrLrf73G7nK5ZIH62NhY3n77bUpKSmhoaGDbtm1ER0fj7+8v66qr+2MKZFssFqndGQwGTpw4QUxMDDfddBN+fn5SW4aB2ZAC0UFBQXz77bfs3buXhQsXMn/+fB5++GEiIiI4efIkhw4dYtCgQRcN4fLy8iIpKYnx48fLMLCGhgbS09NZuXIlt99+O1VVVSxYsMCjE7xYh9vtJjIykpqaGrZv305DQwN33nknWVlZzJw5kzNnzuBwOMjLy6Ojo2MAswlt6Ny5c2RnZ0s/xapVq1izZg2dnZ2kpaWRk5NDamqqpglEbJrQ0FCCg4O57777GDx4MK+++iqvvfYaqampWK1WxowZw/jx46U3X0tjd7lchISEsGLFCpKTk1mxYgV33nkneXl5zJ8/n+eff57p06fT3d2tuXHc7vOx0gcOHGDJkiW8/PLLTJs2DavVSnp6uozRrqio0AyJE/gQAlfYUUeNGsX8+fP54IMP+NOf/iQ79yhbuamhqamJffv2sXTpUsxmM1988QWrV6/mueee48knn2TLli3ExcVJR5rWAdPa2sr+/ft58cUXufHGG6WTb9OmTfz0008sWrSIxYsXS9OdlskxICCAWbNmMW/ePJqbmxk6dCjBwcGUlZWxceNGIiMjycnJGRBlpBRCOTk57N+/n7feeovFixdz6NAhHnroIWpqavjxxx+prKwcYNNXjgNw880343A4iI6OZujQoYSEhLBp0yYyMjLYuHEjHR0dMtxY/byXlxctLS1MnTqVq6++msrKSs6cOcNPP/3Ed999xz/+8Q9effVVGhoaBvRiUPJXb28vN9xwA9u2bePmm2/mhRde4IEHHsBgMPD73/+evXv3evCV+nYsbnhhYWHExsYya9YsMjMzeeCBB3jnnXd49tlnCQsL80hsVNvHvby8ZD38devWsWHDBhobG/nuu+945plnWL9+PX/5y1/w9/eXNFXfgtzu8x2hwsPDmTp1Klu3bqW4uFg2T1++fDlffPEFBQUFF238/q/gf6zRhhCEbW1tnDp1is7OTm699VZuu+02nnrqKSIiIjwcU7oLGHY6nW4vLy+sVismk0k2o42MjGTjxo0kJycTHByMyWTisssuw2QyyRBCL1U5ANEYd9CgQdTV1REQEEB5eTl33HEHDz74IFFRUcycOdOjaL63t7dH2rjFYsHpdMpkD6PRyF133cVLL73ECy+8wJo1axg5cqRsRnCBWXROp9MtGKijo0M2DLDb7fj6+vL3v/+d2tpapk6dSkZGhozAuYCGAWnSdXV1BAcH09bWRlVVFX19fezZsweXy8X9999PcHAwRqNR2YdxQJp0e3u77LXY29vLtm3bGDRoELNmzaK6upqJEydKu+2FzeYxhsvloq+vj66uLnp7e/Hy8pJNCEwmE/Hx8fT19cnkFOUYLkXTkN7eXqxWKxaLhZycHHbu3Iler+faa68FYN68eTgcDkkX5TzgvP1S4FEkruzcuZNt27YxevRonnjiCXp7ez261Ov+uYNlN6ju7m66uroIDw/n4MGDbNu2jeDgYOLj47nuuuuIioqSkR1aY/T399PZ2Ul4eDjl5eUkJCQwc+ZM1q1bx/jx4ykvLyczM1OGAqrpIiIw3G63jOGur6/n6NGjVFVVsWjRIkJCQkhMTPRI/vO60GhD7LP+/n5CQkLo7e1l586dZGZm8txzz7FixQrGjBmDl5cXYWFhXKCDxz7R6XQSlx0dHYSHh9PR0cGrr77KZ599xqZNm4iJiSHxQlivQuuX61BGXfn6+lJeXk59fT3x8fE899xzGAwG3nzzTY9oFiVvCNI6HA7JGz4+PgQEBPD+++9TUVHBuHHjmD17thTMAh9eqjIigMwbSUhI4MyZMxQWFrJhwwZuvvlmFi1aRFxcnIxBB8+SFaKxht1uJzg4GIvFwp49e1iyZAlFRUXS1Dx79mzpx1HPw8vrfAc4EfLd3t6O3W4nOTmZo0ePsm3bNm699VbZaUsRC/9vq+2/eKMN+OfpY7fbsdlsBAYGsn//frKysmSrK51Oh9FoVJoNPIisdEw0NjZSUFAgtY4jR46wePFiUlJSpFamQoxshKAUSPn5+VRVVWEwGMjJyeGWW24hLCxMnr5aTC+cly6XS7Z16+rqYtSoUXh5eckNLa7+WoJddPtpaWnB5XLxyiuvMHjwYH7/+9/LDDcvLy9lFyKPdQgbuThoKisreeKJJ7Barbz11lvExMTg6+srtdwLDCvHEAgW6+jo6CArK4vm5mYmTJiAj48PiYmJGI1GD2ehUigLTUQ43JxOJ99++y3Dhg1j586dPPHEE3R1dcmDVuBeLQzB84Z14MABTpw4wW233cbnn3/OqlWrsNvtGI3GAZuGf8p2KQx1Oh25ubmEhYWRm5tLYGAg0dHRDB8+3KMnpVqgCt4SfHbmzBlycnIYOnQo48aNw+0+n+mpLG+gPGCUfgiHwyEPu0ceeYTW1lbmzp3L/PnzueyyyzxSywVdlIJI4KO5uVkm9X366ad88MEHNDQ0kJaWhq+vr/rgdyv4DUAmqH300UfyZjhlyhSMRiN6vV4TnxfmIjew0+nkiy++YN++fRgMBmbMmMGSJUukFqvGp5I3BJ+KBLGgoCBaWlo4d+4cy5cvJzIy0iPc0UvVkk5ov+Jmd/ToUaZOnYper5eOV9HuT41PNX/B+SzTgIAA9uzZw+7du/njH/9IdHQ0FotF8peWEiRw4u3tTW9vr1QkDh8+TG5uLmvWrCEoKIiAgABN2SP4U2RFi72SkpLCo48+ylNPPSWVKMFf/1XB/ovb2AVhnE6nbIm3fft2Jk6cSGNjI/PmzSMoKEgKM60xBAiHndPppLy8nFGjRvHuu++SlpYmY0yVG105hkC4OIHLy8uxWCwy3Oruu+9m8ODBUiPTsteJDSNO4IqKChk/LWJU09PTPTI1xTOCScWPIKDb7WbQoEGkpKTId+j1+gHZnvDP5BO32y3/7nQ6CQwMZNmyZTz//PP89NNP0uEp3qvGhXJtImNv7ty53HHHHRw4cABvb2/0er1M59eii5irEC5Op5M5c+Zw/PhxrrjiCtn7VGigWmYUMa7ItNTpdEycOJGEhAT27dvH3XffLSOotBzramHscDgoKCigqqqKgIAAJkyY4JHCr2W/VNLJfcE53tzczIgRIxg2bBjR0dFs3ryZgIAA6SRT41TJc+IGIvw4Y8aMITw8nCVLlpCcnIzNZpP2bbWJTEB/fz8dHR20t7czevRopkyZgslkIjs7m3HjxkmhrsaFWIfD4cBsNtPY2EhhYSGxsbG43W5SUlJkPLs4nLTMF2KNYr+63W4eeeQR4uPj+dWvfiW/qxV1JQ4tgW/XhWQoq9UqszzvvPNOYmJiMBgMqIWvmq6CV1paWigoKGDt2rXs3r0bu91OaGioZktM9Xz6+/tpb2+X4ZpeXl7cfvvt8tAUckHgTw3is9bWVqxWKx9//DHPPPMMw4YNY9WqVYSHh3uEN6v9LwJP3t7edHd3Y7VaZSLSmjVrPMym6ryXfxd+cRu7sFN5e3sTEhKC3W4nMjISu93ONddcQ35+Pi0tLbJZtZaDS4yj7HmamZnJn/70J6Kjo2WCAGhXgFRvxt7eXtLT05k2bRrHjh3jiiuuwOl00traCiDrwKhBuXlMJhOhoaH8+OOPHD9+nJqaGhwOBzabzeNZLcYVCVtms1mWBdi3bx++vr7YbDYpwLUcUwKfAkJCQmhoaGDJkiUMHjyYtLQ0DAaDTOhRaDIDcCEEuEiUeuyxxzAajbS2tsroIqHFXEwIwfmrpfKwGzduHP39/cTHx3tEkWiNIQ4HX19fcnNzJR0mTpzIpk2bCAwM9IhYUK9FjCUOS51OR3h4OK+//jqnT5+moaFBOsTF99XzEJtP9ExtaGiQ2uCWLVtYvHgxzc3NUpiqBZpyHsJP1NvbS319PXfffTdr166V5RpcLpe0o6r5ROk0FN/x8fHh+++/53e/+x1paWkyBl7Zd1c5D0FXk8lEamoq9fX1jBgxgkOHDlFcXIyvr688bNXPK/nD5XLh5+fHDz/8wPjx42lqauI3v/mNTKRTNtRW8oPa5i6cwX19faSnp1NSUsK+ffvkftYCcTgIQel2u/Hz8yMyMpJp06YRHx/PpEmTiI6O1oxgU9PY29ub0NBQfHx8WL58OdnZ2SQnJzNlyhSCg4M9lC71GEpZoqxbJMx9P/zwA729vdjtdo/qsur1CP40mUyUl5fT2tpKVFQUCxcuJDc3l7a2Nnp6ev5byUnwC5tixPVSbHqLxYKfnx/+/v4UFxdz5MgRrrvuOpmkoopB17wOAVRXV2O1Whk2bBj79+8nLCyM1NRUTCaT1GbU9lwxqLg5mM1mecWLiIigurqaqKgoAgICpE1Yy44qEG+z2WTdiurqaioqKpg0aRIhISFERERIp5DSBqq8ojY1NdHS0kJGRgZlZWW0trYybtw4enp6ZOEvIUi0rqiiOJUotLV3715iY2MxmUwkJSXhcp0vuqXY7ANMSkJAVVZW4nA4OHToEP39/dx0000ezai1bP0CLUIgtrW14e/vz6FDhzCbzQwfPpzRo0fjcrmkLVV5zUVhOnC73bKGh16vJy4ujlOnThEZGUlYWBhut9ujGJrajALI8M3a2lpiYmIIDQ1l48aNMgrEx8dHCiMt84Oglah909HRQVVVFeXl5dx0001SQAl7rnoeQkt1uVyy3seQIUPYsmULkydPxmAwoNfrZSy8mkeV8wCkGSsrK4sxY8ZQWloqE5WMRiOBgYEephS1qVCn01FSUkJwcDCxsbEcPnyY+Ph4goODZeKa4CVBV7W5UBSrys7OJjExke7ubgwGA7GxsXh5eXnYpdV7TQhnUQMoMjKS6upq6urqiIiIYNKkSTIfQ4s3xGc6nU4e7E1NTfJ2HB4eLs1aAhcXQNP8arFYMBgMFBYWMmrUKOrr69Hr9YSGhkq6aZli5KAX9ouoW9TX10d0dDQVFRWEhobKhC/FYTBgDOF3cDgchIaGsmnTJsxmM7feeitGo1HSXHHr+d9rYxfCULxXFK+yWq2EhYVJZCo7r6vtuQLxypOws7MTvV5PW1ubTLcWz16MyGqBJtKAReErcRvQIjIqwS7A6XTKtGZ/f395qivnqiXYAWk66u7uRq/Xy+qQQkj8HJOI73R2dkrmVpp3hFBWwICNJxjfYrHg7+9Pa2srvb29xMbG4uPjIzvTq52WSnyKuYg1Nzc34+XlhclkIiAgwGMuap+Fch46nU5Gz4iQQIPBIA9qUUVSy++h1OYFLi0WC6GhobL6oPrWpsSpUigLR72SF/R6vQfdtfChODCA84JZaPDCkS40coWjT9JFax52u1063YKCgvD19fWgqeKmoFMqQMrrvMVikfMV5iwxvlooq1hMmpWEYBVKkDCbatmDlYetwIngj46ODgCMRqO0z2vRRKmIKfessG0L35EIDFCW1dXynYhxenp6MBqN1NfXExcXJ/lO8K7aAYvicBB4FbHqoipkVFSUvJGoyoZ70FW5DuHjMxgMnDt3jqioKGl+VSbSKejyL+EXj4oBT/OIUmgphYP6mqw+vdW13ZXMqxQOSkIqGVbdhEP9u5qhFfPSPBzE97Su9crvKJjNA/Hq9ynXosTHBRgQ0aL8nnLNysNHdRANcObIP2iYBC4yrwE3B/VzAnda/7+AI4/NK/6unrP6EBX/vyBwPcZQH9hK+ojflYJauRa1s0+JWzHni13ztW4fyu8r13Lh+x60UmvsWnygXIeygYoYQ81fyr+p56vFH1q3UjE3cSALP4v64FHNT/M2J9at5iv1XNS4UCuEWvO/yN8GjKG1J5RKpFrwXsyJezE+0/I1/Bw+1Pym5BulTPnfrLFfgktwCS7BJfh/DJd6nl6CS3AJLsH/Mbgk2C/BJbgEl+D/GFwS7JfgElyCS/B/DH7Rnqdut9vDCaJ0fqg/F38TPgDhIBMlBZROQ6UTRwkajjM5hnDQ/SsniCqCA1ShYCL2VhGRgNrhpHZoCueWcu3KNSgdYsp4ZrVzS0QIifUp56HGp9Ipo3YIKd+pduKKNSpxoOX4VDqL1E4klQNbHcsvx1DPVe0UFk479ZhKmigdbGq+UuJY7aQFNB11WnNXOdY0HbDKeShxr8SLcP4q/6YOElA7x7XoquHE1CkjSdR4VQYraNFdSVe1w1LgQunAVdNKHUki5q2gucfeUu9lBT40I6YUTvMBOFU7lf+VA/ZiNBHPX8CRB4+KuSjpqy6sp5yfcr+p5QbgsbfUQSQqB/u/7Tz9xROU1AgQxBAbVh3dog4n1Io0cLv/mZ6rFAQilEi9eZSxucrvKp9RRw6oI2UEwpW1HJQbTUl0pfdbzE+ZTuzl5eXRsUUtXJXFu9S0Vc5XfZiI9yrnpI5gUEegaL1fhDlqbDw5hnrdWvRyu92yqJtYuxIE/ZQNRdRCXl16WL1BlHhXH2Zi/Uqciu9eDJS0Ff8HZAKKWpkQ31HiQ8xf4Ffwn4gvVx+8AgRt1bhSHzgiUU/5PSVd1ZEzynmJLF/xXfV+01qfeIc4GMQctKJBlHtT+X/xLvGcoInW+5QCW61AiXmI9WhVHlXOWY0HAYJmQiCL76vDSbWUTq01izEEv6rfI/hcGeqqxKHyoNPC67+C/5EEJQGi001WVhZNTU3MmjWLxMREjh07RmxsLIWFhfz6178WG35AjLAYo7KyEh8fH3bt2oXVamXGjBk0NjaSlpZGcXExCxcuFATSDIsTjXqPHDlCamqqbLxss9mIj48nLS0Nt9stYss9NABBRJFw1dzcTEpKCh999BFJSUkMGzaMjz76iNmzZ5OZmSmIqROaspiH0+mkuLhYFuDv6ekhJCQEPz8/PvzwQ1avXi0LNalDBAUjOBwO6urqcDgcBAcHExAQQGdnJ6WlpZw5c4bExETmz58v4mI9tG3BPA6Hg5KSEgAaGxsZN24czz77LPHx8Sxbtozs7GwWLFgwABfqg6WsrAyTyURJSQkmk4l9+/axcuVKjhw5wrJly+jv7xfZlAPC+4TAqaysJCoqSpa1tdlsnDhxgqysLH73u9/JrjteqlhlsTkdDgdNTU1kZ2cTHx/Pli1b+OMf/8hrr71Gd3c3Tz75pCwZoZwH/5wQbrcbs9mM0WikrKyMiooK/j/23jw6yiJ7+P9k7ewL2RNCQgIBQgIhbFGQnUG2EVEEN1AHB3AEBfkiIy6AOiM6igKiIirIKrIYFhNAkD2BgElYQgLZk87aSWftpJPuzu8PrJqnO52Z77zn/Jz3vMd7Tk7o0E89Vbdu3br7HTlyJOfOnSMvL4/hw4czYsQIM81BLER5YAWcPHmSiIgIdDodra2tXLp0iZdeeknJiK1KujY2NrLfqcj5OHfuHEFBQXTv3p0RI0ZgMBiUODWT+AVODhw4wLhx4ygpKUGv1xMdHU1mZqZsH/hrjH0nzVYwKb1ez08//US3bt0kfaWmpuLg4MC8efNk03ZLXCgvL5PpXmLO3bt3cXBwIDQ0lP3792MymZg1a5asJ2RNqxSXRGtrK9euXePu3buyBEdaWhrDhg3D2dmZgIAAszEEPpShmnV1dWRkZODo6EhLSwslJSXU19fz0EMP4ejoiJ+fn6iN1OnMC9zm5eURGRmJvb09L7zwAkajkZ49exIfH09VVRWPPvqoSE7slJ+gLK8h+g3X1NQwdOhQSV+zZ8+WfYMV8/i38F9ptCEYamNjIydOnCA+Pp65c+eybNkyli5dSm1tLUajkSFDhsgC/gKUko2trS0NDQ1cuXIFtVrN2LFj0Wq1XLx4kUOHDvH+++/j6upKcXGx2U2ulOzFRp0/f56GhgZOnjxJfn4+X3/9Nb1792bdunXk5eV16kSv3GAxZmFhoaw1P3HiREJDQ3Fzc8PLy4tTp05RXV1tJokq8dLU1CRroO/YsYOqqio++ugjtm7dSm5uLlVVVdTW1v5L6RIgNDSUy5cv8/zzz6PVann22WfR6/XodDqKi4s7NXUQ+yHmpNPpyMvLY9++feh0OlatWsWTTz7JrFmzeOaZZ3BxcemkAVlqCHq9Hjs7O3766Sd69Oghe9dqtVq+++476uvraWhosCqdCdzq9XqZbj127Fg++eQT5s2bx9WrV8nJyeGzzz6joaGhE30ppRuDwUB6ejqTJ0/m/fffp0ePHqSkpHDs2DHGjRvHjz/+SHV1tVlpaHHQhPSk0Whwd3ensrKSXbt2MWbMGL7//nt5GI8fP05RUZHVWuiCgTQ0NLBt2zbmz58v6S48PJxFixbx2GOPsWbNGmprazvhQynZtre3c+bMGUJCQtDr9ezevZunnnqKsLAwmTltiUOBE8EIs7KymDp1Ki+//DLh4eFERERw7Ngxzpw5w507d6iqqjLbV0ttwsHBAa1Wy/Dhwzl+/DgrVqwgJyeH8+fP07t3b/7xj3/g6OhoRmOWdK7RaDh//jwuLi5s27aN7OxsHB0dmT17Nnl5ebJ3gbVOYco5ibIT+fn5jBs3jn/84x8UFhbi7e3NkSNHzLQQ5b4Keq+vryc5OZmCggJyc3O577770Ol0xMbG0t7ezuXLl2UfBiWI9YjEObVazXPPPcfMmTO5//77WbVqFSdPnmTbtm1MmDCBkpISs7Uoz5qdnR21tbXs27ePnTt3yqbr7733HtOmTeP06dM4OjqiVqvR6/X8J/CbM3axSNGROyMjA1dXV3bv3k1iYiKFhYUMHz5cdi/XaDSdmAj8syxBfX09gwYN4uzZs9TU1ODg4MDTTz9Nz549WbJkCcOHD6ehocGsSJKSKRsMBpqbm3nwwQcZPXo0M2bMYMCAAZSWlvLmm2/i7u7OL7/80qlug1Ita2lpITMzk379+vH+++8zY8YMRo0axRtvvMGkSZNkfXJRQ0U8r/x969YtoqOjeeKJJ/jrX//K0qVLWbFiBbt27eLvf/87V69excvLy2qmoYC2tjba29sJDAzk2rVrLFq0iM2bNzN06FCCg4Px8PAgPz/fjIEo1X0hSRw9epTDhw+zatUqli5dSnh4OJ9++ikBAQEkJCSQk5PTaU8EQ9Xr9RQWFlJaWoqDgwPr1q1j27ZtLF++nA0bNhAZGUlGRgYqlcqq2UYwVa1WS3p6Orm5ucTExLBy5Upef/11fHx8OHDgANOmTaOxsbGT2UjQhl6vp6KigsTERP7whz/g6urKihUr2L17Nx9//DFnz57F1dUVLy+vTuYHpfCRm5uLWq2mvr4eo9HI559/TkNDA1FRUfzpT39i7dq1+Pn5dWKISjOYoI2IiAjUajURERFs2rSJQYMGcfPmTdasWUNpaWmXJq7W1lbu3LnDqFGj8PPzk1Uac3Jy2LlzJ01NTRw4cEAWWVM+azLdK0FcU1ODSqXi448/xtPTk/Pnz7N3714SExOZNGkS06dPt9pMRuChtbWVK1eu4OnpyYQJE5g9ezZ79uzh+++/x93dnb59+zJkyBAqKirMzppScBA1ZQoKChg5ciQtLS2cOHGCsrIynJ2defzxx4mJiaGkpMSsyJvS/KHX66mrq+P06dN88803JCcn8/LLL9Pe3s7MmTM5f/68LAmipHMlQ21tbUWtVlNcXExmZiYvv/wybm5uXL16FRsbGzZt2kRcXBz19fWd7PhCKGxubsbDw4MhQ4bw5ptvMnr0aJ566ilu375NeXk5CxcuBLBqGhJnraWlhaqqKq5evcqbb75JQkICDQ0NTJ8+neLiYl5//XXu3r2Lp6dnpyJv/w5+a+eptI05OjoSEBBAbGwsPXr0ICoqitOnTzN48GDOnDnDhAkTqKioICAgoJOUrlSnxC07efJk3Nzc0Gg0rF69mo0bN5KYmEhcXJw0YShBbJJQX7/++mvWrVvH+fPnuXz5Mnv27MHDw0OaNtra2jo1chYMob29XdaTmTFjBuHh4Tz33HN0dHTwwgsv0NTURP/+/QkMDJTPKrUXg8FAaGgomzZtory8nB07drB27Vq++eYbzp49i5eXl+wlqnTKKPEiTDEXLlzAZDLx2WefERoayvnz5xk4cCBubm5ER0fTo0cPq/Y6Yf74+eef2bx5MyNGjJB1vN3c3BgzZgxtbW388ssvDB06tJMUpXQ+FRcXM2rUKMaNG0dkZCSPP/44Dg4OLFu2DDs7O0JDQ2ltbTVjqEr7s6hvf+vWLcLCwnBzc+PSpUt4eXnx7LPPkp6eTmBgYKfibEpbuCiK5eHhgbe3Nw8//DAbNmyguLiYoqIili9fTlVVFaWlpURGRpqNIdbW1tZGdXU1r7zyCs3Nzdja2nL//ffLMrk3b97E0dHRahNnpR9Hp9Px7rvv8sILL3Dy5Ek++OADbt68SU5ODp6enqSkpDBs2DBps1aeF4ETOzs7PD09OXToEBEREUycOJG0tDTGjx/PiBEjuHPnjlnNF7EWQJomlixZwsCBA5k9ezY9e/bkwIEDLF68mPz8fCJoHPNOAAAgAElEQVQiImQDZ8vnhXSpUqlYtGgRKSkprFmzhn/84x+MGzeOOXPmEBwcTENDA76+vp0uSnFeHRwcSEpK4siRI9y5c4e33nqL2tpaevbsKWsQZWdn069fPzNfkBAIhV365s2bxMXF8dprrxEbG8v06dNJS0vDZDIxcuRIDAaDrGCpxKUYS6VSUVZWxpAhQ/Dy8qKpqYkTJ06wdu1aAgICpNCZkJBgFZ8Arq6unD59msbGRj799FNZH2rlypXyoigqKsLd3d1qxzKBl8bGRkaMGMGDDz7IF198weXLl6mvr8fe3p4HHnhAav2WOP138JsydqX9s66ujtLSUlasWMHUqVPRaDT88Y9/JCYmBmdnZ4KCgoiJienkOFAylKamJg4ePMju3bv56KOPuHTpEs888wyRkZG0tbXx0EMPYTQaCQ0N7UQoYgx7e3vOnj3L4cOHqaioIDk5mcrKShwdHSkpKaF37940NTXh6enZSWIXUF1dzbFjxwgLC2PNmjUcOXKEgQMHotFo8Pf3JyQkhKCgoE6qocCHKGRUU1PDnDlz0Ov1nDlzRrYOU6lUxMfHA53LFovL0mAwsH37dvr06UNmZibTpk2juroaFxcXoqOjGThwIDqdzqyeBpg7Mevr6xk4cCBr167F3t6e+fPn4+HhQUNDAyNGjAAw6wyjBLG2uro6CgsLyczMJDY2lrfffpv6+npZdMnDw0M2B7e8mMQF0dLSQlJSEgsXLmTmzJn06dOH4cOHU15ezs2bNxk8eDBNTU2y3aASp+KzkMpKS0sJCQnh7NmzuLu7U1VVRXh4OM7OznTv3t1q5yKBH7GmjRs3EhsbS3Z2tmxp1tbWxvjx42V1RUvaEOupqqqSTWDGjRtHcnIya9eu5cyZM8TExODo6NiJgYh9FtES1dXVpKWlkZaWxvTp0ykvL8fG5l6/giFDhuDi4sKgQYOsXrYdHR2UlpZSW1tLUFAQX331FY888ghHjx4lICCA+Ph44uLiMBgMskOVNXy2tLQQExODl5cXe/bsYdiwYdTW1hIVFUVzczN2dnZERERITUzMQ1m6Q6PRkJ+fz0MPPcRHH33E2rVrmTt3LpWVlej1eiIiIrCzs6O9vd1MYlf6bwD8/f0pKCjg8OHD1NTUSJNZVFSU1ECt8Q2xNmHPXrhwIW5ubpw9e5ZDhw5RVFTEU089xR/+8Aeamposo+HMzk1dXR0RERGkpKSQnZ3N888/z9WrV0lJSWHGjBmyvr3ow2AZ1QRQVVUF3CsR7uvrS1xcHIGBgQQFBXH//fcTGBgoi7z9p/Cb12MXXmCtVktsbCwDBgzgxRdfZNq0aZw6dcqsl6VlBAeYM/bm5mYiIyNZvHgxTk5OpKamkpSURFJSkqxBbRlaBJ0jA5qbm9mwYQPz588nLi6OsWPHcv36dVmBTxC8kqkKx4coLxwWFsbZs2dJTU3lmWeewdvbGzc3N5ycnMyiAiw9+aLsZ2trK/Pnz0ej0ZCZmcnq1avRaDQYDAbZOUZ50JS4aG9vR6fTsXjxYlatWkV6ejrvvvsu165do6WlBa1WK7s7CelLuQ6hNQgHcWpqKrdv30av17N//342bdokzVzt7e2S+Snn0dFxL+LF09NT1qAfMWIEZWVl/PLLL7J0rNC0RBla5Z6IMY1GIx4eHhw4cIDJkyezevVqXnzxRfmuxsZG3N3dO9Vkt2REwr+RmZnJH//4R3Jzc/H29pZV89zd3WXjECWNigu3qqqK+vp6EhMTSU5OZs6cORw+fBiNRkNNTQ2NjY04OTl16kerNB20trbSr18/xo8fz7Rp06iqquL9999nxIgReHl54eLiIvdWyYjEhWswGGhvb2fo0KEUFRXRs2dP1q1bx1dffYW9vT1lZWWYTCbZHcvyohTziYyM5O2330av1/OXv/yFnj17cv36dezt7XFwcMDV1VU2ubBcB4CnpyfvvfceLS0tkrazs7MZNWoUNTU1ODo6yiJvXZlARJcgLy8vEhIS+Oijj2hra+PSpUuyx7HQDCwlZXH+KisrAVCpVHTv3h2tVktWVhbe3t4UFhai0+lwdnY2MwGJMYRWW1tbS2hoKCqVii+++IJjx44xZswYunXrhrOzM42NjXItSv6jdHhWVlaSkpJCXl4eu3fvpqmpid27d+Pt7S27sSkL+ClB+G/s7e0JCgri1q1bJCQksH37dmJjYwkODsbHxwcbGxtZo76rksZdwW+eoCQOTnt7O1evXqWpqYn77ruPXr168corr6BWq7lx44ZsrWbJzOCfZgMPDw/i4uJkI4nk5GR++OEH0tLSyMzMRKvV0traahbuJUAQSltbG3fv3mXJkiUEBQXRu3dvzp07x927d2loaJA12S3nIQjHwcEBX19fXFxcUKvVzJ8/n6ioKBlBoGxkLcYRzwsGJ5oOHD16lIMHD7Jnzx4aGxuZMGECTU1N3Lhxw8wZZjkHYedfv349R44cwWg0EhERQXp6OkajkYsXL0r7q2UcrzLMtLW1lTVr1nDjxg2ysrLQarVERUVx584dDh48KFt/WYahKuchoiYA5syZQ3JyMocPH6a8vBydTkdtbW2XzbDFGLa2tmRkZJCamsqyZct4/fXXefLJJ9FoNJSXl1NdXS3HsNZYwdbWVkrWY8eOZdKkSXz77bdcvnyZ06dPM3ToUDIyMqSDTcmIlKGWer2eAQMGsGDBAhYvXoy/vz979+5l3759aDQaCgsLrdo+xcEV+G5paWHBggU8+OCDvPrqq5w6dYrPPvsMnU5HYWGhlMgsfR+Cvry9vWW9/pUrV2IymVi5cqW89MXFbc3EJi6XCxcu8OyzzzJ69GhaWlq4e/cupaWl2NraUldXJ0MNrWkv4pKbM2cOmZmZjB07lsDAQD744AOp3ba1tcmL1nJPBENsbGzk9u3b5Ofns3DhQtatW4darWbGjBns37/fTEq2XIP4EZePCJbw8fGhtrYWR0dHrly5IqOhLM+7OL/Cxh4VFUViYiLTp08nNzeXo0ePolarOXPmjOQZlrShXFtYWBhGo5Hr168TFBTE5MmTpV/J3t4etVot32c5hrj0g4KCqKuro7y8nOeff56srCwSExNlJdnW1lYzuv5P4Dc1xQgQC3Vzc+Oxxx7j888/p6mpSZYDHTduHO7u7rJkpTWCFRLf3bt3pYT19ddfy80eOnSodBhZIlbp2Rb276VLl7J161YqKytZs2YNp06dIjMzk8jIyE7xx2IMMS8vLy+GDRvGjz/+yKZNm6isrOTYsWMsWrRItptrb283k4iENiLGrq+vx2QycfDgQZYvXy5t29nZ2XTv3t3M7KKcQ0fHveYX3bp1Izw8nA0bNjB48GDGjh3L1q1beeihh7h27ZpZHK/lGGIegYGBvPHGGwwYMICPP/6YsrIyJk2axLx587CzsyM2NtYstlZp6xeagEajkTX1N2/ezNy5cykqKuLIkSP4+fkxcuRIKVlakw6FU+n111/ns88+49atW8TExNC/f39eeukltm7dSnZ2tnxO6XNQSpitra2MHj2ab7/9lldffRVbW1u2bduGo6MjGo3GLHTOkjbEXnt4eNDe3k5SUhLr1q2TXZRycnLo6Ohg0KBBnTrdiH+LfTEajfz444/ExcUxatQocnJyiI2NZdCgQdKXILQmyzGUa/Tx8eGpp56isbGRoKAg0tPT6d69Ow4ODrIuu6U5SOBGCEJLlizhzJkzsimESqXizJkzDBo0SDJlS/OYuMSbmprIzMxk1apV2Nndawk3ceJEmpubZS8BX1/fTk1DlCbP0NBQPDw8MJlMREdHs2PHDql19O/fHy8vL9ra2sw0DyUuxCWak5ODh4cHkyZN4tKlS9x///0MGjSI9PR0ysrKiIiIMDtjynWJeVRVVZGcnExpaSmurq4MHjyY+Ph4YmJiqKmp6TR/5Rgmk4n8/HymTJkiI9UyMzOJiYlh9erVxMbG8sQTT0iBzlK7hXslk1taWujRowcODg4sWrQIb29vXnzxRbp16yaFUn9/f6uC6b+D/1q4Y8+ePaUa+vzzz/Pss8/i6OjI3Llz2bZtG6WlpbL5hWXokwCNRkNgYCBVVVX06tWLqVOn8uCDD+Lu7s4333yDi4sLer2+k1qmjFgwGAz079+fI0eOSOdTUlISo0ePZuzYsVKCsHbzCqisrMRoNNLQ0EB+fj7bt28nPz+fo0ePSpu9UmIA84wylUrFH//4RxISEvjggw+IjIykpKSERx99lLS0NMBcClLiQsyrtbWVBx54gPDwcP7whz9gNBqJiopi79695OTkoNVq0el0Vp0wyhjhnJwcJk2aRFRUFLNnz+bkyZOsW7eOW7duodFoZMimtQghISl7e3tjY2PDCy+8wJdffklwcDAZGRnS5CRCtywZuxIfHh4e0nkUHR3N8ePHUalUfPfdd3h5ecnwPmsJNUIqa2pqYt68eezZs4dt27YxduxYPDw88PX1pVevXlZpQ0lvGo2G3r17M3fuXLRaLadOnaKgoICoqCj8/f2prq622lFKMETxt0GDBgGwd+9eunXrxnfffYezszNXr16VtbsFDpTrED/t7e00NDSg1+tpampiwIABREREcOXKFZqbm6XN3/LwC5rp0aOHjKjx9/dn1qxZeHt7M2nSJOrr61Gr1dTW1pqZwyxp1MXFhdDQUNrb22Vjm5s3b/LLL79IjaG5ubmTSclyXyZNmsT48eMZPnw4EydOZPr06ahUKiorK81MpJbai9iT1tZWBgwYQENDA7NmzZLNZVasWMHAgQPx9fWVvRy68ok1NDRIS0FsbCzbt2/nySefJCkpiaysLFpbW2UnJiUo5+Xi4kJWVhY9e/bE2dlZNhmvq6vjsccew9HRkaampk64EOeko6NDnqeKigqWL1/OI488QkVFBS+99BIRERHSlNMVTv8V/KaMXSBG3HA6nU4mZ+zbt49z587x97//XfZgFA5La0xNqDLe3t5MnTqVkJAQyUxHjRqFSqUyawqgBEFARqOR4uJi/P39eeSRR5g5cyY//PAD+/btY8mSJTKJw7JsgHIt7e3tnD59GmdnZxYvXgzAsGHDeO+99+jfvz8BAQEyDtny4AqGKELVhgwZwooVK/Dw8CAvLw87OzvGjh2Lvb291XXAP2Pys7OzKS4uZtasWTg5Oclkk4ULF8pGwUr7vhIXcC+yx9XVlYiICLy8vHjuuee4ffs21dXVBAQE8Kc//UkmTVlTlYVUWFlZSXl5OU5OTmRlZeHr68uJEyf46KOP6NevHyEhIWbPWIJwOLq7uxMfH49KpaJXr16MGzdOhn26u7tbjURRmoj8/PzIyMggOzubmJgY2traCA0NJTc3l82bN8vEFMtLCv7JEC9evMjPP/9MRkYG06dPl4lFS5Ys4aOPPkKtVptljypBMBaRhxEQEMDo0aOxsbHhyy+/JCUlhb59+6LT6Whvb+9kglCupaqqirq6OoYOHUpsbCyJiYmUlpZy8OBBUlJSZNMNpeAgzpnBYCAlJYVffvkFNzc3Ro8eTVtbGxqNhosXL+Ln54dOp7NqUxZjGQwGKioqGDBgAMOGDSM4OJi0tDT8/Py4fPky9vb2MvqoK6YufF7p6el4eXnh4eHBxIkTCQsL44033pBmR2tMWeyJ0WiUWvy0adMICwvD19eX0aNHo1arKSkpkd25LDVCJV5EYET37t0ZOXIk3333HcnJyYSFhVFYWIhWq5Udz6zRp5ifn58fvr6+lJSUMHToUPR6PTNnzuT06dOoVCpcXV07lT5QaunNzc306NGDXr16ERsbS69evXjiiSdwcHBg5cqVxMbG/h9J6/BfkthtbW1pbGzE39+foqIiVCoVDz74IDExMSQmJjJq1CgZDmdNShaI+eabb1Cr1eTm5vLNN99w+vRp1q9fj1arJScnh4qKCqliWqp24sfV1VVKG+fPn2fUqFH069ePwMBA2Vle2TldCeLSUalU5Obmcvv2bVQqFQ888ADPPPMMd+7c4bvvvqOhoQEPDw+z9GJBuEajkWnTpnH48GEcHR356aefSEtLY9KkScycOZOTJ09iZ2cnVVxrZiXRT9Tb2xtPT0/S0tKkQ85oNHLt2jVcXFxwcnKyakeFe6rh999/T0FBAc7Ozhw+fJi//OUvdHR0sHjxYl577TWrTmBLaGpqoqamhu7du9O/f38cHR2Jjo5m1apVfPHFF1RXV3faD+Vng8HAsWPH2L9/P83NzRiNRrKzs8nIyODRRx8lLi4OtVrdaf5KujAajXz33Xf07dsXJycnYmNjiY+P54svvpD278DAQKvSoVhfW1sblZWV3L59WyaiBAQEcPToUcLCwpg6dSp+fn7SNm3p3BLjRkdHy73p6OhgyJAhJCYmUlBQwPr164mMjJTmCeVaxHhGo5GMjAxu3rzJ7du3pZ3Zz8+P5557jqefftqsz6fl3jo6OjJmzBjpGD9+/Lhsr2dnZ0dGRgahoaFWGZmSiTk4OHDo0CFUKhXNzc3MmDFDOobT09Plvlr6cMR8HBwcqK6uxt3dnczMTHbs2IG3tzfr169n9erVnDx5UmoNludeqUnY29uTmprKsWPHaGtrY+TIkeTk5PDcc8/h7u6OVqs1c14r91WMe/PmTcaOHUtDQwPp6ekyuiU3N5eKigp8fHxkuKw1sLOzk3HwaWlp2NnZERYWRkBAAFlZWcTFxeHk5NSp37GgUTGP4OBgUlNT+f7776mrq8PBwYHVq1czd+5campq0Ol00vz0nzL33zyO3cbmXpZlVVUVhw4dolevXpK5Xrp0CU9PT4qKihg5cmSXEp2w+U2dOpVr164REBCAj48PPj4+VFRUUF9fz5gxYxg4cKBVNUbpRKmoqODLL7/EYDAQHx/PsWPHmDRpEpGRkcTExMh3WrMJC3uwSOu+c+cOH330kZRs77vvPhoaGqSUqyRYYf6ws7Pjiy++YOjQoWRnZ+Pg4MDSpUtxdXVlwIABvPrqq5hMJjMbqHIO4veNGzcYO3YsGzdupH///iQmJhIeHk52djbh4eEYDAbZEs4aTkQM8nvvvUd0dDTx8fG4urpy7NgxamtrefHFF/Hz85MSiDUTiMFgoF+/fhQVFbFhwwb+/Oc/M378eJKSkggODmbOnDn4+vp2CokTz8M9htq7d29UKhUODg7MnDmTKVOmsHv3bq5cuSJDDrsyTQl7df/+/Zk/fz5ubm7SIX716lXmzJnDe++9Jy9Ka/MQjuQePXpw6dIlJk6cyObNm6mtrWXnzp18/fXXsn+rtXkocezs7MzOnTt5/PHHefDBBxkwYACPPvooEyZMoLKyUjpGLZ2wiiJWjBo1irfeegt7e3tycnJ4/vnnaWlpkdnRvXr16tTVSAnvvPMOtbW19O3bl/T0dG7duoXBYOCJJ56Q9nmBC0vzhTK8r6Wlhddee42XXnoJnU7HokWLUKvVmEwmunfvLtsmWjOB2NjYyB6p69at44knnuDbb79l586dBAYGMm7cOIKCgro8a+LCbmpqoqysjLi4OJ566ikKCwt5+OGHeeCBB3B3d6e1tVXa6S19YsLvIebQt29fQkNDcXBwYMqUKWzbto033ngDe3t7Mw1bjKM0ywonaVtbG3l5ebzzzjt4eXmxcuVK/Pz8pH/FksbEWgwGA25ubjg4OHDhwgX8/PxkYMEPP/zA999/b3Y5/afmmN9cYhehWb1792bp0qVs2bKFN954g2HDhhEXF0dUVBQRERG4uLh0GT0hEFtWVsaFCxfIyMjg4MGDbN++Xaaz9+nTR9roLaUypXMoKiqKyZMn09zczC+//EJKSgqbN2/GZDLh4+NjRvjW7Momk4lBgwaRlJTE9OnTqaysxMPDg8DAQFavXi2bJwtPvRhDWQiqT58+pKSksGXLFry8vBg9ejSrV6/m+eef54knnrAqaSvnIJhtXl4eCxYsQKVSydhkX19f/P39LZt6d8KpnZ0d0dHRbNiwgYaGBt566y1++uknjh49SnR0tGTcljZpJV6cnJxwdXXl4sWLnD9/nuvXr3P79m0SEhIYOHCg1FqshbGKcWxtbaUjuFu3bhgMBsrKykhISODcuXOoVCr8/PwkLpVzEY7ClpYWevfujbu7O/v37yc3N5f169dLVdfV1RUPDw/ZLN1yPUajEVdXV/n+wsJCamtr2b9/P0OHDpVhnAKvXdn5DQYDp0+fZsqUKcyfP5/hw4dTXV3NtGnTKCkpITw8XNKyNSeu0MYyMjJYtmwZgwYNYvPmzSxfvpyNGzfy8MMPExISQnNzs6QHZa6GeD48PJxx48YRGxvL6tWrGT16NIGBgTz++OMMGzYMV1dXM1OF5Tp0Oh2DBg1i/PjxvPbaawwePJjY2FicnZ0pKiqSNZAsms/LMYQP6P7776ekpIQnnniCwYMHc+3aNd5++22Ki4vp2bOnbGRtKZ2KeYgyE/fddx8ff/wxY8aMYcWKFfz1r3+lurqakpISGfZpTbO1tb3XozQsLIywsDCuXbvG0aNH6dWrFwcPHqRXr140NjbKTPWuGGl7ezvx8fHU19ezdOlStFot4eHhFBcXc+nSJRkB5OTkZFWDERFzTU1NdHR00K9fP6ZMmcKxY8fYu3cvTk5OMhNZnIn/VGL/zZtZwz0kNzc3k5qaSkNDA2q1mv79++Pj40OfPn2wsbGRIVQiqsVWUcxHmDSMRiMHDhzA39+fmJgYsrKy8PLyko5ZUTxKIcnI4kaCsZaVldHe3k57ezvXrl0jKChI2naFpGw0Gjs1Tu7ouFdwSjC71tZWWfemW7duVFVV0a1bN0loSqZoc49iOuCfDaz1ej1/+9vf8PDwYNasWVy/fp0ZM2ag1Wrx9PSU0savjLnTHNRqNb/88gv29vbcuHGDHj16EBYWRs+ePfH29sbV1VVKVMox+LWwkdFopKKigoKCAk6dOkVDQ4MsnhYVFYW7uzuurq5muQi2Vkqztra2kp+fT3h4OB9++CGvvfYajY2N2Nvb4+TkZGYaU87DpCgRq9Pp2L17NzU1NfTp04fIyEgqKiro1auXNDcppWXLtZhMJioqKrh+/TpFRUU8+OCD1NfXk5OTQ0JCAj4+PjI+WHFpm81D2HKF6SUiIoLU1FQAevfujY+PTydGZLkvRqOR2tpaUlJSSEtLY/bs2SQlJcmor+DgYDOc/gqSRm1tbWVI46lTpzAYDPTq1YurV68yYMAAYmNjaWlpMfM3/HrJy2bp7e3taLVafH19qampISkpCUdHR/r27Uvfvn3R6/XywhWXgq1FwT2DwUB1dTUnTpzAy8uLK1eu8PDDDxMVFUVdXZ2Ma7e4JDud16amJpKTk7Gzs5O2/ba2NkaMGCGFAosoFjP6MhqNaDQaTpw4IZtIz5w5k9TUVBISEnB2du6SzgU+xGV3/PhxJkyYQFFREXfu3JEZq6KxtsCH4rzKPWlvb0etVuPn54ejo6MMz/b09MTBwQF/f38zTezXcTrRRmFhIc3NzZJG4uLicHZ2pl+/fjg6OuLp6Wlmo7f9v7jnqWTsra2tmEwm6urqZEaiuFWVkphCujNDrpDCDQYDNTU1BAUF0dbWJqVbMFeJf/1sRmw2NvfSxltbW+Wm2tjYyKQNQQSAUhoxYwBifnq9Hq1Wi7e3t7ztlXZPJbHZ2traiMtFzFWEewIy+Uas07KsqnId4h1iPa2trdIZZm9v36lEseXhVV5ywqan0Wiwt7fH19dXlksQkraF9tIJFyJrUDjClP4BgU+LWHizMeBecpEoJ9va2kpgYKBM6FAeOMXeyjHEvsO9TNq6ujpsbW3p0aOH3ANAJlopnHWd8KHX62lubpaSomCgQnsSNCjmZafoGaDEtcFgwMHBgZKSEoKCguQcBP0KycyyyqTSZ2BjYyPjtQUTFWsV9KWIwbfp+PVgi+fhnkZTU1ODm5ubdBwrNbGuLn2xtyK3RK/X4+zsLOlL0LDSMahkhmJ9ojSHSqUys2ELoUmpfSppo+MemGkhJpOJxsZGvL29Je6U31HQgRnfEHtvb29PcXExwcHBnQQvIegIyd/Wou+A0CBE2KdOp8PX15e2tjYzs41YixKnAh9KjV+E37q7u0veYWNzLydEeYYVtPFv4Tdl7MpNBvOwQ/gnI1ZmiyrSes0OryAi8X2lqcIS+eIdyltTuW4lQYjfSsnB1tZWyVDMiF45b6V90JLAlBKRUmJXOt0ss2QtD6/iAHVi7Eo8KudtzSYvPoqvWsvMFThWzluMJf4uGJkSmcp3CKYgGGAXeQCd1qJknMr5Ky9S5f9Zlg9WRhwp36ekBytgJh2K+Vuauyxt2cr3WWowSrwqTSRibOXcxP9ZaqbKtHbLtSvpQvxd4NRkUY5ZiU/lWMr3K/DT6cK2FJLEfC3PjmJvzS45y+8o/U3KsyI+W9KGwJklTSr31tKcZU0QU8zPbB+Uc1DyJ0vhQ4lv5W9r9ZusWQusnRUlfpVzUa7JAh//Fn5rif13+B1+h9/hd/j/GX7vefo7/A6/w+/w/xj8zth/h9/hd/gd/h+D3xn77/A7/A6/w/9j8FsXAetQOjlFxEdzczPl5eWYTCZcXV1xcnLC2dlZhvlBZ4eh0qkpomycnZ25fPkyERERVFdXExQUhI+PD2DufFCGPsE/k4VE2nN7ezu+vr4yJl5k5XXl7FM68mpra6mursbBwQFnZ2fq6+uJjIyUUTXCkSKcKErHlfCCl5SUoNPpCAwMRK/X4+joiL+/v/ye0glshtxfQ0Dt7e25e/cuQUFBEseOjo4y6ufXtZitQ4AIr7O3tycrK4uQkBA0Gg1hYWE0NDQQEBDQyYmrxKcYS9TbKC4uBv5ZwCkmJsbSUWbmIFPiQ4ShVlVVodPpCA4Opri4uFOqtSU+xN8FLkQd+rq6OunwsrW1lSnwXUU7CRCRQdnZ2bi6uhIaGirbDXp6esrvKWnU0uHY2tqKk5MT1dXVstFDeM72cf8AACAASURBVHg4gAy9tIZTy30VdJKZmYmTkxNOTk50795dhk2KMUSAgNLZqtfrcXJyoqWlReZb6HQ6goKCLDtzdenoa29vl1E6mZmZDBo0iKKiIry9vWWEimV4sliDwIeIEiooKKCpqQknJydcXFzw8fGReQGWdG7p7DT+2mXLw8OD9PR0Bg4cSF1dHR4eHrJhiOWZt+bwrqurQ6fT0djYiI2NDf7+/jJL25qDX8xBGWTR2NhIUVERzs7O1NbWytwRi8YlncJ6xZr0ej0mk4nc3FxsbGzo1q0b/v7+1NbWWj33/xv4zWvFKGJDZehUfX09N27coKSkhGvXrpGTk6MMNTLzdisiEKTX2d7enoqKCt59911ZZCogIEDW4bDEh5IJ2dj8M7tOq9Vy6NAhPv30U9LS0mQ7vK6iTpSRKsrQJU9PT1lqwMvLi5qaGrOGA+L7Yh3iHSKWvLGxkR07dlBeXs6dO3dkOJZlVILlXOCeRz8nJwedTofJZJIdoJycnLp8VvkjQs/a2tpkv9KsrCwaGxtl7fmuxhHvt7W1xdHREa1WS58+fXB2dubKlSsA5ObmWq0tLeLPLdcjkmf0ej3e3t7U1NSgVqvNyjNYzkGJC4Dy8nJ++OEHunXrxoULF3B1de0UMy1AGVaqDKsU+7J//34uXbrErl27zOZpGYGj/Lug+4KCAmpqati8eTOJiYmcOXPGanKR+GyZVCdCc1NSUoiOjua7776jpKREMiolrVrSrMjJEJfE6dOnOXHiBD///DONjY1mc7WkDWWUh52dHbm5uezbt4+8vDxaW1spLS2loaGhU1SJeK/lPtn+mihUU1PDkSNHyM/P5/Tp02at/SyjZJRCgwidbGxsxGAw0NDQQHV1Nf7+/jLpR/l95Z4oBUvR7Fyn03Hp0iWam5vlJazsg6tci5iPGEu0tzt37hz5+fkcOXIEJycn2traOkX9WduXjo57+Sl5eXnk5ORw5MgR2ddBq9VaHeN/A/+VzFMxSRE7npaWhre3N3fv3sXHxwd7e3szQrF28JSHuLa2lp9//pmIiAgWLFjAunXryMnJITQ0tBOxgvnlIJJqNBoNW7dupW/fvtjZ2bF7925cXV3R6/XyMFgjNvG7vb1dMr4FCxaQnZ1NeXk5lZWVsl2YJZErCdBkMqHT6WSNk6amJurq6ggPD5dZo11l4ipxUlFRQW5uLsnJySxdupRdu3aRlZVFS0uLfL8lE1Iys46Oe53XP/30U7788kvefPNN4uPjSU1NxdfX91/OQ+yv6AoVERHBjRs3aG9vp6SkhNbWVsLDw62OoWRK8E+JrKqqihUrVnDmzBmys7Pp378/3bt37xTiaolTsabS0lJMJhN79+5l586dlJeX4+LiQkNDg4zNV+6J8rPYV5PJxK1btygtLeXGjRvExsYSFxeHjY2NrBWjBCVtiO9oNBp+/vln3nrrLR555BFmzZrFxIkTzapDWo5jTXO4ffs2NjY2nDhxgjVr1lBfX29WDlrJOJShciaTiYKCAj788EP+9Kc/4e7uTmxsLMOGDZNrtKQNSzoxGAxUVVWRk5PDY489hru7Ox0dHQwdOpTw8HBsbGw6MURL6dRkMlFaWopOpyM5OZlHH32U0NBQgoKCzJLfLN+t3CORA3P79m3Gjx8vm5JnZWWZNfuw5BtKhmwwGCgtLaWwsJBXX32VtrY2EhMTqa+vx8vLy6wkgCV9iTFMJhN5eXlkZWVRWlpKYmIiDzzwABkZGWY1+f/VWkRF1R9//JFu3bqRkJAgC+WFh4djNBr/4yYb8F+Q2AUIqbC4uJioqChsbGykui2yAy2JVTwnwM7OTiYXhYeH8/7773Pjxg1ee+01IiMjZfNoy0Oj3BhbW1tUKhUajYaEhAQOHz6Mj48PL774Io2NjfI5ZQMGy/WIS8LJyYkdO3bwxhtvMHz4cE6dOmUmiSkldqU0JL6jUqlQq9WcPXsWDw8PMjIyZO0LkYCiBEspT+Dz9OnT6HQ62SUoOjrarJuLJcGLvwuCb29vp1evXkRHR0vVtOevfSkFLizBUtL19/fngw8+IDMzk8LCQkaOHCmTt4Rm0BUI6VQw9okTJzJhwgQuXLggC7YBcizLOQj8ioSpjRs38v777zN27FiGDx8upX/BSJT7ahkL7ejoSGVlJfv37+f48eMEBgZy+/ZtPD09JQOwTD9XxjeLy6e2tpbw8HAmTpxISkoK+fn5UlpTam7KMZTSmjCPXbhwAW9vb8aOHcuuXbsYPHiwWRy7NRDP19bW0tzczJtvvklsbCxqtZo+ffrg4eHRKc5ePKcUjOzs7GSVyitXrqBWq9m5cyeVlZWyZK9lzRtLQQbutZLctWsXzs7OVFVVkZeXx/jx462m4FvShfgxGo04OzszduxYoqOjZW0lsaeW9YwEo1eOXVxcTFxcHP3796e6ulqWRhaSclf0pbz4g4ODMRgMTJo0ifz8fDIzM2WLQGXCk+UalBde3759KSwsZN68eXzwwQeys5XIrlXyjf8t/KZx7EqbXUfHvQJaO3bsICkpidmzZ1NdXc2YMWOIiIjA2dnZqt0PRQKJgG+//Zbz58+zZs0a9u/fz9SpUwkKCpJFr8T7rI1hMplkQ44pU6bg5eXFvHnzGD58OP7+/tK+rpAEO9n9ANRqNd7e3mzfvl2aMURddHd3d7EG5Tw6lBtua2vL0aNH2bRpE/X19Xz55ZcEBATIRtwWzKdTRp5Yx82bNxk+fDgzZszgyJEjsjmwKLylkOSsJn/U1dVx9OhRJk+ezAsvvMCyZcsk8alUKmWJBzmG0i4tpNzy8nLGjh3LyZMnKS4u5r777jO7wCzHEOQh1tPW1sbly5fp0aMH1dXV+Pn5ERYWRnNzs0zlt7avyjVqNBqys7Npamri3LlzLFu2DKPRKE1kYt2/HpxOdnpbW1tZZW/fvn08+uijFBYW4ubmRv/+/S2zAs3mobB3o9Pp2LZtG83NzUyePBmTySTT+pXZsMq1KM+K0WikvLwcvV7PihUrsLOzY/369TQ2NhIREYGtra2y5AX8mnmqpI36+nq8vb3ZuHEj6enpbNq0Sfp0hORtaR9XzkEIYk5OToSHh/P555+j1Wrp1asXQ4YMsTxnch3KhELRWOT8+fPU1dXJqpmvvvoqHh4eyszsLu30QgL++uuv8fPzY8SIEXz99dc88MADDBgwAAcHB0nryj2xtG0XFRXx/fffo9FoqKio4LnnniM4OFj2S7YoVNcJH8JPcPPmTWJiYqitrSU1NZUxY8bIS8GijpBV/4utrS2ff/45999/P01NTZSWljJ48GACAgJwcHAwy0C3sfnfc/ff3BQjX2xrS25uLiEhIXTr1o2amho8PT3p0aOHlDC6AqU0U1FRwbRp0xg3bhw3btzAz88PGxsbGhoapPOtq+fFPrW3t5Obm8uxY8fo1q0bsbGxMv1Z2OwspWMxjgAXFxdqamoA6NmzJ9OmTaOsrIy2tjb0en0n+57Ah7jV9Xo9I0eOZPfu3XTv3p2UlBQcHR2pqakxc1j9K5za2dnRrVs36uvrOXHiBOXl5fTv318yW4FTa5e5kILKy8vp168fK1euZPHixbi6ujJo0CB5+Lt6VvwWKvKuXbuIiYmhZ8+eeHl5oVKppHprmWknQODZaDSiVqvJzs7m8ccf58CBA1y9epWSkhLs7e3R6/VyXy3HUJrYxFharZaZM2fKC8LT05OGhgbpL7CUUgWIkgbHjh3Dw8ODbdu2kZCQwIABA2TPAGu1+pV0IcaYPXu2HDs4OBgPDw/q6+vR6/VdmnPEbzs7OxobG+nVqxfffPMNe/bs4fz587I/p1JVt5QOxTvd3NzYsmULjz/+OMuWLaOiokJebsIPpTTfWK7JxsaG4uJiXn31Ve7cucP3339Pv379iI+PlzZpa6YxpSZiZ2dHZWUl9fX1nDx5kmnTpjFy5Ejc3d1pbm6WY1gDcV7t7OzIzMxk0qRJbNu2jc2bNxMXF8fw4cNlT14xX8v5izEMBoM0gahUKj799FPy8vLk95UXgxKUGowILmhqamLZsmW8+uqrjBw5kpKSEhwdHeV5VfIq5RjKuY0ePZoXXnhBVprs0aMHRqNRaurW/BT/Dv4r4Y4dHfeaWUdERLBnzx5WrlzJ0KFDuf/++6mpqaGoqKhTKrTyWUEs1dXVaLVavvzyS2pqahg+fDjDhw+noKCA0tJSSkpKzBweApSOMWGj/Pvf/46NjQ2bN2/mzp07lJWVSUISXmtLEHNrbm7m2rVrnDx5ksOHDzN06FDUarXcYGUxMgFKNbulpYWsrCx++eUXAHbv3s3o0aMxGAyoVCocHR2lrd9a2rRgZkajkZMnT7J69WouX77MrVu3yM3Npby8XEp81i4ngV+TyURTUxPdunVj5syZtLe3k5+fLyNTLCOalHsioLGxkerqai5dusTKlSv58ssv6d69u5l92BpDVYJer0ej0TB58mTee+89Zs2axYMPPoharaaoqEhW7fx3UF1dzapVqwgNDZXNgY1GI5cvX8bNzc3qpa80STQ2NmJnZ0d8fDw//vgjsbGx3Llzh/Lycq5evYrRaKSlpaXTOpTqc2trK9euXcPOzo49e/ZgZ2fH+fPnzcw0zc3NnfZFeYm2trbSs2dPVq5cybp169i5cyd9+/aVzVGU0T7KOYjfJpOJa9euMWLECN566y1Z+riqqkqaHURXK8s5KP8dFBTE3LlzmT59Op999hltbW1cvXqVixcv0tTUZPWMKP0HOp2OgoICbt++zWOPPUZISAihoaEYjUbS09Ol+cSSzpXjNjQ0EBYWxq5du9i2bRtPPvmkfF4wVWEWsra34sz6+flRWlrKuXPnMJlM9O7dG61WS3NzMy0tLZJGrZlwxZ7Y29vLmvgzZ84kMzMTPz8/7ty5YxkRYxWvzc3NXL16lXHjxlFcXExSUhIGg4GLFy9SX18v/WL/J6aY35yxixvL0dERR0dHLl68SFRUFMHBwbIPocFg4Pbt21Zt7JZ2ejc3NxISEjh+/DiXLl2irq6OM2fOUFhYyO3bt2loaJDftTaG6LTU1NREUlIS5eXlNDQ0yH6SqampXV4wYl4tLS1otVoGDx7M1q1bOXPmDA4ODqSlpREQEMC1a9fQ6XRm81AevPr6ei5cuCAvvJMnT3Lz5k1Onz5Na2srycnJZiqqADGnjo4O2aatT58+aLVagoKCKC4uJiIiQhKbmLc1u6FgZHfv3qVnz56EhITg4+NDWVkZ+/btIzk5mdraWrN3K0EcYFFyNzw8nIiICJ566ilZFKx3794UFxfLg97VZalSqdDpdDz00EMkJibi4eHBlStX6NevH2VlZXI8S2Ym1iYuS41Gg4uLC5988gl2dnZUV1dTUFAgG6ZbizhQSmWurq6kpqYyYMAAnJ2dCQwMxMbGRpb0/emnnyRDtCZxi+92dHRw4cIFVq1aJSNyQkJCOHTokCwkZU2bE/Noa2tj7969LFiwgIqKCp5++mkKCgo4efKkLFdrrYGJWEtzczN1dXW4uLjw4YcfEhQURFVVFVeuXJGF0oQ9tytc6HQ6NBoNffr0Ye3atVy4cIHhw4ej0WhwdnZGp9NZdXwqzI90dNyLbhIO9UOHDtHU1CQdmZcuXepSYhfCmL29PQUFBaSlpXH58mUp0JWUlJCUlMT169fNpGVr0NbWxk8//URzczMODg4cOHCAfv36YTQaOXXqFFeuXOky6kopEF6+fJlx48Zx6tQpWlpacHNzY+fOnZSWllJQUEBFRUWnPRGfTSYTTk5OssfByZMnaWtro6WlBS8vL9LT02lqapIRS//XS+ziIFZXV6PX6/H09GTNmjXMnTtXNj9+++23uXz5sgwZskYo4tYVZUP9/PxQqVRcuXIFLy8vDh48KO2zyvcqQYzz+eefs3nzZtnPc/v27axbt4729nb69esnvfDW5gH3HGzTp0/nq6++IjU1FbVaTXp6Oj/++COffPKJ3HRrUq6QZNzd3ZkwYQIbNmwgLi6OBx54gClTpvD+++/LeGNLRqYErVZLXl4eq1evxs/Pj+TkZNlLUqh1guCthY92dHTg7OxMeXk5ERERBAcH8+GHH7JgwQJiY2Px8fHh0qVL5OfnS3OKck8FI6qoqECj0XDt2jW+/vprHn30UZKTk3nggQfYtGkTISEhtLS0SBwqQcyjoqKCwsJCzp49i52dHd988w2ffvopSUlJsvlFdXV1l2YhoUV9/fXXhISESPPQM888w6xZs9i4cSMpKSkUFxd3qeba2t5r5pKfn8+KFSvYvHkzxcXFVFZW8uGHHxIcHMz48eNlM+OuNCFxkQBERUUxd+5cli9fTnx8PKNGjaK5uVkyxK6ia1paWoiIiOChhx7iscce49ixY/zwww+MHDmSH3/8UVY0tQztFQzE0dGRyMhILl26REtLC+vXryclJYWffvqJAQMGkJycjFarlSG1lu+3tbWltraW2tpa5syZQ1paGh4eHixZsoRhw4bh5eXF3r17JW1Yo3Mxr4cffpgtW7bwj3/8g2nTpvHqq68ya9YspkyZQnl5OfX19WbPKccR+KmvrycvLw9nZ2eeeeYZ6uvrWb9+Penp6bLdZVeFwmxsbKRGmZ+fz+HDhwkJCWH37t08/fTTnDp1Cnd3d8rLy61GbokxxGW2f/9+XnjhBY4dO0ZUVBT19fWMHDlStvW0ZnIUZ6W2tpa6ujp++ukn3nvvPc6dO8fOnTtxdHRErVbLbk7/qbQOvzFjV4ZUCbVu2bJl9O3bl7/85S+kpaWxcOFCZs6cacaALIlNIKumpoavvvqKHTt2sHjxYrZu3Sq7ERUUFMimyJbSoVJaVqvVPP/88/z5z39m3rx51NbWsmrVKtasWYOrqyubNm2Sbea62qD29na2bdtGbm4uH3zwAadPn8bHx4eXXnqJzMxMdu/e3clOrlQ5bW1tKSsrY9y4cbi6upKQkEBzczNTpkzh6aeflt2kupIixDx27tzJlStXWL9+PXPmzOGbb77hwoULaLVakpOT5fOWTFmMI5pYFBQUMHXqVAICAlCr1SxfvhwvLy8SEhJoaGjoFNFiqb0MGzYMJycnVCoVL730El9++SV79uxBp9Nx8OBBysvLO9GGch0qlYoTJ06waNEiXnnlFXr06MHdu3fZvHkzzz33HMePH5eXS1f7ajKZePfdd5k6dSqNjY38/e9/591338XG5l4SyuTJk3F3d+90aJT4FY2i//CHP8hLqaSkhOLiYm7fvs3SpUutmumUqrOvry8jR46kvb2dZ555hnfeeYcdO3bw3HPPsXnzZhl6aSnpCnoTDm2hrd1///3s378ftVpNYmIivr6+fPvtt1KbsLaOpqYmzp8/T0lJCUuXLiUrK4sPP/yQwMBA9uzZg6enp0xe60oDcnZ25vTp0zz11FNs3ryZFStWcOLECWxsbGQPUtEM3lIjFHPXaDSsXLkSZ2dnvv/+e/bv38+MGTMIDg6WcdzKd1rb17y8PO7cuUNUVBSJiYmUlZUxfvx4Bg4cyJUrV/jkk08IDg62qhGKMVUqFXPmzEGtVpOTk0NERAQBAQHs3r2bCRMmUFVVJR2f1jQgIWBFREQQHx/Pyy+/zPHjx7l+/TqHDx9mw4YN/Pzzz7I1Xle+uZqaGhlq+eSTT9Le3s6qVas4ePAgAwYMkMLFv2rT1xX8V2zsJpOJ8vJyAgMDcXV1JTs7m+XLl5OSksKyZcuIj49nzpw55ObmAp0dU0LKbGhoIDIyknfeeYe1a9fy/vvv09raSmVlJRs3buTEiRMynM2SYAXY2dmxYMECXnjhBdllZu3atezbt4/Q0FCZEWspzSjHaWlpkWFger2eLVu2EBYWxuHDhxkyZAgvv/wydXV1ZqF1SinPaDTS0NBAQUEBu3btIjg4mClTpjB37lwOHDjA4cOHpR3VEhfighDJIzqdjoSEBB5++GEWLlyIn58fX3zxBd7e3lIqs4ZPwUBu3rwpHb8ZGRm8+OKLjB8/nnPnzpGSkkJQUFCnXo5KacjBwYH09HSKi4uJiYlh6NChcm7p6emkpqbKWuBdSWUuLi7Y2tpSVVXFypUriY6OZtmyZWzfvp0NGzYwYMAAgoODO4UqKhlCR0cHGzdu5MMPPyQkJIQ33niDQ4cO8eOPP7JkyRKZJdiVbbqjowMXFxfs7e1ZtWqVZL5NTU38z//8D9nZ2Tg7OxMRESHxqMSpGKO+vp533nmHvXv3snDhQoKCgkhNTeW+++4jODiYd955x8yma+2siNaLtbW1bN26lRkzZuDg4EBdXR0fffQR3t7elJaWWjWj2NjY4O3tjUql4uGHH+arr77i1q1brF27lqFDh7JhwwZyc3NxdnbupIkpz017eztz587Fz8+PMWPGoFKp2L59O3v27OHixYsyUcfSHqw8r97e3gQHB1NYWCgzcM+dO8e8efN48skncXFxkYKYJV2IMQMDA0lJSWHw4MG8+OKL5OTk4O7uTp8+faipqWH8+PG4uLgAnTueiQvGaDTy+eefM3nyZOk/mjhxIsnJySxYsICysjIZV9+VWSk/Px+1Wo1Go2HRokVMnjyZDRs2MHjwYJ599llu3ryJh4eH9I1ZrqWj414/2vnz5+Pl5cWsWbOoq6vjr3/9K8uWLZPNyQWN/qfwmzJ2Zayzr68v69evp3fv3hw7dkyqvFeuXOHjjz/m8OHDMjvQmtoP9xpD9OzZEycnJz777DO2b9/OggULSEpKYujQodTU1ODh4dFJpVIylaCgILZs2UJGRgZr165l1qxZfP7554SHh/P000+zePFimSBk7faGexExonn2yJEjJbNduHChNMlYm4MYx9bWFjc3N5YtW8bw4cPZsmULn376KZMmTSI7O5vx48cTFRXVKcZXaUcUcdVLlixh3rx5/OUvf2H37t2MHDmSwYMH88wzz8jmCJYg8KFSqXjllVe4fv0648aNY9q0acybN4+IiAj+53/+h7KyMimBWZOoTCYT3t7ehIWFsXr1arRaLVqtFi8vLxYtWsSWLVuYO3cuISEhVqN8xGdhe1y1ahW2tveaZHh6ejJjxgx2795N//79ZURHVzh1d3dn+fLlfPvtt6Snp3Pt2jVMJhMLFizg0UcfZd++ffTr169LqV/Yg0eNGsW3335LVlaWZMrPPvssGzZs4LHHHpPNFZRrUWpjoknHhAkTiI2NxdbWlkmTJlFaWkpISAizZ88mMjKy00WnlFINBgPJyck8/fTTNDY2Eh0dTVBQEMeOHWP9+vVMnjxZNqqxpI2OjnsBAHV1dWzZsoUbN25Ic93rr7+Oj48PixYtwtXVtVNrO8s5rFq1iu3bt/PII4/g6urKsGHD0Gq1FBcX4+npKe3U1tYhzGMiCzsxMZGdO3dSX1/PzJkzSUhIICAgQEZvWTJlsZb6+noef/xxBg8ezPHjx7G1teVvf/sbn3zyCR0dHQQEBNDa2irfaQm2traEhITwxRdfMGvWLObPn098fDx/+9vfcHJykhmowkxneWGLc9+/f38ef/xxjhw5wuHDh3nyySdZtGgRb731Fn/605945ZVXzGhB+X7xu2fPnmg0GqZMmcLW/4+9N4+Oskoa/z+dpDtbZ+8sJJCNsCTsYd9ElMUVBUYHHBccxGVGQccZR2dcEdAvDoriMiCoCAMIOI4oyCZBliAJhIAsIQkhG9n3rZN0Ov37I947t588jc45v9d5z3uoczghnX7uU7duVd26VXWr1q5l1apV9O/fnx07dlBTU8PJkye1JVF+NvziF5TUwNk777zDDTfcwFtvvYXD4SAzMxObzcbf//53Ro4cKWvFaC0AIQQxMTGkpqbS0tLCBx98wLhx41i+fDkFBQU89dRTjBgxgrq6Ot2gkPi9qqqKCxcusHjxYgICAggJCZFH2z179hAWFqZ7zVmFgIAA/P39mTdvHv369WPmzJmkpaUxY8YMlixZwsKFC2UtGtWiFD/j4uJ48sknWbt2LXPmzOHJJ5/k3LlzhIWFsXz5cnx8fKSAakFYSB4eHowePZoXX3yR3r17k5OTw44dO8jPz+fy5ctERER0E37xvMCjoaGBQ4cO0aNHD6xWq6zXM27cOI4ePcptt90mfbZ6JyA3Nzd8fHz45JNP6NOnD/X19VRXV/P2229z5MgR1qxZw4ULF2SpBlf0rKioYO7cubJDzscff8wbb7zB/PnzaWhooKCggPLy8m5HZYGLOM2dOnWKu+66i+bmZv7+97/j7++PyWRi1apV9OnTR3bK0otbiM/69evHmDFjqKmpwWw2k5CQwF//+ldGjhwpOxqpdAScLL3g4GAeffRRamtrGTduHDExMSxYsICsrCymTZvGhQsXqK+vl9f9tTQFZDrgd999J5X7b37zGzZs2EBzc7M8totbrOocBO8vWLCA3bt3U1FRwbRp0/j+++/ZsmULf/nLXzh69KhT7EqLg8PhwGKx8NRTT/H666/zwQcfMHDgQGJjY3n55Zd57rnnSElJ6XYqVfnTza2rzMRjjz3GE088QUdHB7m5ubz22muUl5fTq1cv+vTpI9NI9TZbNzc3vL29uXLlCv7+/uTn5/PQQw/Rq1cvJkyYQGFhIVeuXJHNzrX8JcasqKggIyOD2bNnYzKZSE1NJSYmhnXr1vHYY48xffp0mUeu5QmxyRgMBnJycli9ejUxMTE0NTXJJuOfffaZPJVe7WKjzWYjNDQUPz8/9uzZw+7duzl//jylpaUMGzaM++67D3d3924XpX4O/Nda49XX11NTU8OOHTtISEiQGS2xsbHMnTsXi8UiiyNpL8MAUnirqqpoaGjg22+/5fnnn2fNmjWkpKQwb948oqKiiI2NVXNpXV54OHnyJMnJycyePZugoCAqKip46KGHuOWWW+RNNuhepKmzs6texOnTpzl58iQ333wzTz/9NBs3bmT+/Pl88MEHtLS0YFOSEQAAIABJREFUEBUVpVpATkXAhFDt3buXyMhIVq5cSVFREbNmzeKOO+6go6NDFmr6UVC6XaYR/uB9+/YxZ84c2tvbSU1NxWw2Y7fbSUxMJDY2Vl0Lp0s9YpzKykrq6upYvnw5a9euZfDgwfztb39j6NChMmahHLe7XdayWq0YjUaWLFnCHXfcweHDh1m0aBFlZWWkpqYyYsQI6UbRw0PQori4mICAAE6ePEnPnj3Ztm0b9fX1LFq0iICAALy9vXUv1IjnGxoaqKmp4emnn+bYsWOcPn2a+vp6wsLCSElJYfz48U6BKcO/pc+pUF1ubi7l5eUsXbqU0aNHk5CQwLRp02SGiKo8tesCXX76M2fOUFhYyK5du5gzZw7nz59n1KhR1NXVMXToUHr27Kl7KUcMIwrBbd++neuuu45Zs2bx7rvvkpeXh4+PD7fccoteGzaHIjs0NTXxxBNPkJmZSXp6OnfeeSdhYWE8+OCDDBo0SLb905MTsa7FxcXEx8fz/vvvs3LlSjZs2IDdbsdmszF48GBZI0nv4tmPsou7uzsHDx6kqKiIkJAQVq5cyX333cfQoUNJTEyUPK7SU4wh+OPIkSNs2LCB5cuXs2vXLvz9/eXvwiLXXgzq/LH7kcPRlcd+5MgRzp07xzPPPIO3t7e80Xv69Gmuu+462dZRlXl1LvX19bi5ufHkk09SUVGBn58fdrud5ORkevTowcyZM53cStpLhYKmVquVXbt2MXPmTEaNGoW3tzcrVqygtbWVPn36EBcXp25sP9ts/0UVe6dyC00IX11dHa2trVy5coWwsDDy8/OZNGmSTIdUdjunG2TCim5ra6OhoQFvb28yMzM5ceIEs2fPxsvLi6CgIK1F5URcMU5jYyMtLS00NTVx6dIlhg0bhpeXF/7+/rKyn2AsrRL58f+0t7eTnp5Obm4uEydO5Ouvv+bxxx+noqKCsLAwJx/fj2M4tdarr68nLy+P/Px8CgsL6ejoYOLEicTFxclLV2Kt9BSIqCnx/fffExISwrfffsvChQuprq6WMQC1nyI6ShmQNVTq6uqIjo7m7bffJjk5md69e9OrVy/5PVXwtOva2dnJsWPHqKysJDIykpEjR3L48GH69esn6+ZoFaq6UYpN283NjStXrnDs2DFuuukmQkNDZbEnMQ91Luqm39HRgdVqJT09nYyMDJKTk4mN7eokn5CQ4LTRqnigbPoOR1fV0LNnz+Ln50daWhr9+/fHYrHQo0cPPD09naxJLY8KqKurIzc3l2PHjjFq1ChiY2OdbhTr3TxV8TAYDNTW1srKo6mpqcydO5fq6mqMRqMsbSDo56ZUD1UhLy+P48eP09jYyEMPPcTp06cZNGiQU49elRbqugreEJUUm5ubycvLY/z48ZSXlxMeHu50MUy7roAs2OXt7Y2npyd79uzh1KlTPPnkkzQ3NxMaGqrN23ZSymJ+LS0tsvLh9u3baWxsZNy4cfTs2ZOgoCB1PXR5Q7hUMjIyKC0txd3dnZKSEm666SYCAgLw9fV1St3Urgn8W95SUlIYNWoU69atw2QyERsby5AhQ4iIiNC9AavVPc3NzRw6dAgfHx9ycnL4zW9+w/79+xk4cCA9e/aU+kuzWf4k/FcUu8pEQhkoRHQKCmoVO4olohAN7Wfqe5R3OQme9hkVJ1XpioXQWoficz13kTovleF/HNOgRwv1d4W5nax6LcO78ruL51UaibHUDUorvNrvq1afTrplNyWk4iD+78pdoo6hWlQq7loaqO/RCp52k1LppuKlrr1WEWnpoc7Zlay4mot2bbU8r8VRq0S0+KtzcEUfhT8cGp7rtn4qn2hkrtsJSLxDy++ueB8Nj6o4a8fQyrtWGYJz2QstTfVopG5yrtZVy5tiLC2PiLmo9FDlWgWt3OvJrLomKi46vCD//uPYP1ux/1eCp8J61TKnlgkFgVTiqQTTe1a7QYj3qguvp4y1z7lSIgK0fxf/1wq/VqmroLH2nOgj5i3ooDe++n31GfV3PSFUhVtxUzkxlvZdgpYqPurf1DkKgVDHVddTj3aq0KvvU7+nBrPEd/XoqkcvgYOWxlrh1qOdujFoNz49cKW4Vfy0tHA1Fz289NZdy+N6G5I2lnA1GdTSUZ2Xup7q31WFqOLt6ndXmUSujAF1DL2fKg218qqOo75L/VzlET3FrZ2L+rmQK61hopUjLS+o79cGjFW6XI039OC/VlJAT2gEaJlLO2GtoLlSQlqG08NBSzgts2rfqYIrBaqdhyulruKtZ3WoP11tDqryF4ytZUAtftq/6SlrdRMQ9FNxcmUh6W282s1ETzj0FJaKh/bd6ju04+jRUFVyWsWqpYcrwdTjWVcC5+okqK6Rqli1uF9NMWl/1ypnV6BurupnYi5aI0q1XvWUqPqcSkt1rfUMIj2e0FqsrnBUZdvVhqK3mao4q3iovC/WR48vVNAagFqe0Bofeni4kn/13cLdrDfGT8EvHTy9BtfgGlyDa/A/DNd6nl6Da3ANrsH/Mbim2K/BNbgG1+D/GFxT7NfgGlyDa/B/DLrfL/+fBYc2CKgXHNSLpBt+/KOaLqQGurQphtp3/PiZUyqZE2KaIIYrXPTy2AX+eoEXbSDpxzENKg6ugixa0M5Di4Ne4FDFQ5PGJcdQn9VmpWjpeLU8Y71x9ILQmiCbEx4q3tqAqyYFTY6vt64qPtqsDuU5dX4u+UvFXQ3yarOuVB4VecrikovAW9uYQydA6TQXbXBUG5xTb2lq70lo5cBVcFZLH+089BIc9NKBNWvtxKNaedbOXcVD+dwptVgbYL2azGjXVR1DK596yRXqmqlr4oovtYFQlcZaWbnae6/GYwoePwn/tZ6nqgCrjK2NzGvTwLTMqGU2LfNq3yt+d5XZId6p/a42A0I7thphv1oal/Z5kR2g9x7tTy2Id7lKDdQ+e7XUS733aBWhXhqoeE6Lux6jq3S62vvV9VH5Q5sRoSfU6rqKcQQP6WWFXG0uejnfKh7alE7tHFWlLkBtJqEqKC3oZSqp31czOLTZHCo+2vlq10qdp6v3qTQVeOnxqd77xGdqSq9W1rTrpQVXOLviMZWGemNoZUMr74LvXKWQir9rdY02y8lVRoyKk0pT9TsqnbVz+Tnwi1rsKmF/avKqZSc+A2eF6MqyAucLCHoKQB1H3SVVpaGXU621NtSf2vloF0X7ufpu9XcVR+13tUpSj6H1xlCtPxX0cNEqG62ydmVlqGNphV27wbjCR8X/p9LmXFlaWlANB1eplnoblvoeMY6WFnrKWSh1lQdVvldLVLhaG/GMtoa+ukba04DeGFqaqu9SN0wVR60sqfNztbZXs5y18qW+R8XL1elAz0DTzlmLhyveAmfFqYevXp673lz0cNEbX4//1fG0eOoZaj+Hz53m+B99+/8nUJnd4XA49WwE53xbrcUOzu4Cke+p3QjEe9T36b1f/UzLJOIdV1M+qvUAdKtup25MqoBqBVrgrhYKU3FwxWxaemlpqc5Hfbfes+q81WqUqrWqWizqO7RjOxwOORf1M731Uf+mZWSh2NQN0JWVJuikztlmszm9V7Uc9eip5QPxrLqJ6ClR7by0Y4g+m6rrRB3bFe+qRaTEmujdCdAqSjG+Onft3/UUrBZUuuttbFpDy5WsqN9Vm2AI3tHKgyvjRG8D1s5JlSkVtDQWZYpd8ZWKszq2UNxa/aPVQdrTiaChKs/qhq++W33uP1Xq8Atb7IIx2tvb8fDwwM3NjTNnztDY2IjVamXy5MmcOHGCsLAwzGaztkiT08+Ojg7ZCLitrY2CggLZ+V0U5TEYDJjNZln3Qd0Q3NzcZMNq6Kq0VlJSQk1NDYmJiQQHB3Pw4EHGjRsnayPrMYqoSdLY2EhTUxMJCQns2bOHuLg4zGaz7PIUEhLidHQWIJrVurm5yToaPj4+dHR0cOLECYYPH05LSwtms1m35K4qmFeuXKGoqIhRo0bJGjHp6elMnToVk8mE0WjUHUNAW1sb3t7enD9/HovFQm5uLv379yc4OJiioiL8/f3x8fHpVvVOMKfARRStqqiowM3NjaqqKgoLCxk0aBB+fn6y4JSedSk2Jzc3N06ePEnfvn1paGiQFSVDQkJoamrSLUGsbpAtLS20t7djNBppbW3FarXi7u5OVFQU2dnZhIaGEhISomvBGwxdvUrtdjteXl6cOXMGk8lEREQEFouFgwcP4uHhQXx8PGFhYd2MDyH4oum2aIh+5swZhg8fzsWLF/H396e9vZ0RI0boKitBS7vdTkdHh+wZm5SUJDeKoqIiEhISgK5Sx3r8KcatqKigsrKS4OBgLBaLlBlBB1EZUk+JGAwGrFYr7e3t5Ofn06tXL6xWK5cvXyYxMZG2tjYsFousa6KCaol3dnZSV1dHTk4Obm5usq7LlStX6N27t1NxOD2jS9DUYDBw/vx52tvbGTJkCJ6engBkZmYSHx+vLb7lRFPxe319PZWVlYSEhBAUFER9fT3FxcU0NjYybNgwWQdIb8NzOLpqQ9XX12Mymaivryc2Npbs7GzOnj3L0KFDiY2NpaOjo1u7QHUu0FWcrb6+ntbWVsxmM7W1tbJBeVJSEgEBAU4nqp8Lv3hJgdbWVjo6OigsLGTv3r0cOnSIV199lVWrVnHq1Cnq6+s5cOAAbW1tNDY2dhMalalzcnI4duwYX375JY8//jjPP/88ZWVlvPTSS7zxxhsUFxfLAkda14JQ6g6Hg6NHjxIYGMi8efM4evQo//rXv0hPT+eTTz5h3bp1sgm0nvC6ubnJBsUZGRnMmDGDoqIiPvjgA+666y6uv/56WaZWHUMwqbu7O0ajkezsbI4cOYLZbJYF0ERXGNGfU4/JRAeff/zjH6xfv57AwECMRiO9e/cmMTGRhIQEJk+ezJdffklzc7OkoUqLtrY2mpqaKC8v59FHHyUiIoItW7Zw33338c477/Dee+/Rs2dPvvrqK5eujI6ODmpra9m0aRP19fW88sorWK1W1q5dy6uvvkpVVRW7d++WPW1dKZCCggJ27txJenq63FD37dsnq2+2trZSUlIin9HiY7fbaWpqoqKiguLiYh555BEOHDjAt99+K1sxBgcHO1lfWiUi2hDabDb27t2L0WhkxYoVsjjagAEDeOuttyQ/a8cQOGVnZ3P69Gk6OjrYuXMn06dPZ82aNWzbto333nuPgoICjh49KlvaaWnS2dlJXl4eJpOJI0eOEBISwnvvvcfXX3/Np59+yuuvv05SUhLFxcXdapALHs/JycHhcHDx4kXmzp3LjTfeyFtvvcWSJUtko44TJ0649OG2trZSVFREW1sb69evZ8uWLdhsNqZMmcLBgwf57LPPOHDgAAUFBTQ3N+tuLs3NzRQXF5OZmckbb7zBzJkziYqKYunSpUybNo1nn32WW2+9lQ0bNrg8OQjrOi0tjY0bN/LAAw+wfv167r33XkJCQigqKiIjI4NNmzbJAnJaeoqmGrW1tXz55Zfs3r2bXbt2sXXrVg4fPkxKSgrBwcE0NDTIk54WH7vdTklJCadOnaKsrIwzZ87Qu3dvPv/8cyoqKggKCiI8PFw2LlfXRPxf9Mm9ePEihYWFfP755/z5z3/myJEjvPDCC6SlpbFhwwZMJpM8sf4nSh3+C64YYUUB/Otf/yIwMFCW29y1axcmk4nAwECKiorw8vLS9RvabDY6Oztlo+jbb7+d3NxcwsLCAHjxxReJjY2lpaVFdizX+q0aGxvJysqitraW1atXk5ycTFxcHH369OGGG27ggQce4O9//zv333+/buF+sWufP3+eS5cuMWLECD788EOOHDnC999/z5133ilPDtnZ2bpHLk9PT1JTUzl+/LhskpGcnMzMmTNZtWoVd955Jy+++CJDhgxx2Wy4qamJY8eOERYWRnp6Ok888YTsofraa69xww03UF1dzeTJk/H29u62HoJ5a2trSUlJwdfXlytXrrBlyxYOHTrE/PnzKSws5O2332bo0KHSvaLdHAyGrh6Ovr6+nDx5kqFDh7J582YGDRpEZWUlfn5+nD59msjISEwmUzdFYjAYaGpqIjIykoSEBDw8PKTyu3TpEi+88ALjx49n5MiRtLW10dLSoqsE6urqZJ30vXv3MnXqVBITE8nIyOCtt95i+fLlZGdnExAQILsiacHb25vq6mrq6+v54IMP2LRpE0888QTXXXcdu3bt4q9//SsrV67ku+++06UHdJVkNRgMREVFcc899/DBBx8wffp0FixYgMVi4cMPPyQ5OZnz5893qz8OXYZDdXU1JpOJFStWYDAYWLJkCTExMVx//fVs3LiRw4cP88Ybb5CdnS0tbq37rqGhgdLSUqqrq7HZbGzevJm2tjZ27NjBU089xaFDh+jfvz8tLS268S53d3fCwsL4/vvvOX36NKtXryYnJ4fq6moOHz5MXFwcy5Yto0ePHnh7e3eTV4ejqyl4Z2cn8fHxfPfdd5SUlNDa2kpubi7Lli1j+/bt3H///QQEBHTrOCSgpqYGg8HA2LFjufvuuzlx4gTjx49n1KhRfPTRRwQEBHD33XczYsQI/Pz8dJMKxOnn3Llz9OvXjxEjRvDmm2+SkZFBRUUFH374IbNnzyYtLc2lte7m5kZ4eDiXLl2iqqqKqqoqxo4dy7p16/Dz82P8+PH4+vpSXl6u23VNeCzS09NpbW2lpaWFoUOHEhYWxv79+3nxxReprq6mtraWtWvXdnMl/lz4xas7ChdIS0sLRqORxYsX86tf/Yrg4GB8fHyIjY2lsrKSEydOMHbsWFn60vAjtzgcDkd9fT2enp6cPXuW6Oho9u3bR9++fWVZ2enTpzN37lwmTJjA6NGj1c4wMuWorq4OPz8/jhw5wsiRI/nb3/7G888/L9tdTZw4kUOHDsm2Wz++uxseolB/eno6o0aNIjExkZqaGs6fP4+fnx/ffPMNzz//PMHBwepx1wA4RLliUbO7oaEBi8WCxWKhtbWVfv36UVtbS0xMDIGBgS7rsWdnZ2M0GikoKCArK4sbbriBnj17snXrVi5dusTevXvZvn07kZGRqvtC0qKhoUG2KRszZgwff/wxCQkJTJ06lYsXLzJ9+nRWr16N2Wxm4sSJqitGpoGJI7LJZOLw4cN89dVX/OY3v8Hd3Z2kpCQsFgvZ2dmYTCbZGUtdE0GP/Px8ysrKCA8P56uvvpK9KQsKCti7dy+TJ09mypQp2tK9kh5tbW1UVVVhsVjIyckhMzOTxMREhgwZwpkzZ1i+fDkRERHcdNNN3HDDDWqjDUkPm80mLdW6ujoOHjzIggUL8PLy4uTJk/zhD3/gnnvu4ZlnnnHylap4VFZWEhgYiJubG9u3b6elpYUbbrgBDw8Ptm/fzu7du/H19eXTTz/Fw8NDPVnKMaqrq6moqKCgoICTJ08SFRXF6NGjCQsL49ixY3R2dvLpp5+yceNG2ZABulJyxbpWVVVRU1MjXZy33347ly9fpqCggD/+8Y/MmzePhQsX0tnZqStr4uQiSha/8847PPjgg1y5coWxY8fyww8/sGbNGpYuXSq7/Sg8jsPhcNTV1eHr64vD4eDDDz+kqKiI559/nszMTOx2Ox999BHPPvssERER+Pj4yObcbkoddNE+8syZMxw/fpykpCSGDx9OeHg4nZ2drFixAjc3N2644QaGDx/eTV6FzBuNRsrKymhsbKSsrIzm5mYmTpxIa2sr2dnZvPrqq3z11VfSlatJM3TY7XaKi4sxm82cOHGCUaNGUV5ejsPR1b2psrKSiIgIdu/eza9//Wu56bspVSZFY5X6+no2b97M+PHj5QkrPz+f7OxssrOzeemll6SR8yOP/Wyz/RdX7Ha7nfb2dhobG9m/fz9DhgwhNjYWT09PvvjiC0JCQti8eTMvvfQSvXr1Und/SZjOzk7a29vx9vbm4MGDsvmzn58fR48eZf/+/dx1113S3wZ0U+w2mw2TycTly5c5evQo99xzD7W1tVgsFnbv3s25c+eYM2cOHR0dxMTEqH4up0W22+1kZ2dLn1x9fT0BAQGUlJSwdu1ann/+eby9vYmKigL+nY/a2dnpEMGw/Px8LBYL6enpTJo0iYqKCtmaq7i4mDvvvNPJh6riIGIEDQ0N/PDDD1IwzGYz0dHRfPTRR0yePJno6Gi8vLzU5ZBjOBwOaWGWlpbS3t4uLVo/Pz8eeeQRbrvtNh555BEny8FN04DAbreTlZVFU1MTpaWlTJs2jcbGRoqLi8nKymLSpEn4+Pg4+bbVMdTsgurqavLz80lMTMTHx4cDBw4wZcoUbrjhBjZt2kRwcLDsOqQKr91ul0q5o6ODuro6IiMjiY+Pp62tjc8//5zVq1eTkpJy1TroAFlZWbS2thIUFITdbic4OJjGxkaio6Npbm6WG5xW8MTatrW1UVFRwXfffUfPnj3p27cvnp6esp/myJEj2bRpE3379pV4qPQQBlBlZSVFRUWUlJQwfPhw/Pz8CA4OpqCggH/+85/Mnz+foKAgJ3qo/CUawfj6+pKYmEh7ezt2u53Y2FimTp3K66+/Tnx8vOq+kPMQCicrK4s+ffqQmppKVFSU7G62c+dO9uzZw9atW6WcqUpZrImbmxv5+fk0NDQQFhZGa2urnMPw4cPZvn07t956qzae5TSGmMuVK1fw8PCgubkZf39/zp07x6lTp/D09OTRRx+VvWrVMRwOh1yT4uJiGbMR8Zqmpia2bNnC2bNnWbp0KUlJSVpDTI7R2trKpUuXSExMdOKDyspKBg4cyK233sobb7xBVFSUbrMO4V4pKysjPz9fxhaioqKwWq1UVlayfPlyHnnkEQYPHqzHGz8Jv7iP3Wg0SsUjCtK7ublx+PBh7rzzTgoLC3nkkUcIDAyUWQAaZYKbW1ebrcrKSmmlG41GDh06xKpVqxg5ciR+fn7SXaKNhkNXp3K73U54eDj33nsvdrudgIAAvv76awYOHAhASkoKPXr00I3UQxcTG41GevbsSZ8+fQgNDWXw4MFEREQQFhZG3759ycrKIiAgQO7+YgwxB4PBIAMkws2QnZ3Nli1b+Prrr7n55pu7ZSMI6OzslAzc2NjImDFj6Nu3L9HR0bi5ubFjxw5KSkr47LPPpE9fzy0l3ELNzc3Ex8cTExNDREQEJpOJXbt28fnnn3P77bdL14WePxi6ju3R0dEkJiYyadIk3NzcuHjxImazmRdffJHXXnvNKZikHUMNjPv5+cl5pKWl8Y9//IO3336bgQMH4unpqSqxbuvh5+eHn58fiYmJREdHk5CQwN69ezl+/DgASUlJ1NbWyvlr3VvCDxoWFkZkZCTR0dGEhYVx4sQJCgoKKC0t5cSJE9TV1cn3auMvHh4estl1bGwsiYmJhISE4OfnR3V1NcuWLeO5554jKChI8qiWHh4eHjJoO378eMaNG0dYWBh5eXksX76cCxcuUFlZicPhkO3T1CCdOKm2tLQwaNAgBg0aJJMEjh49SlNTE8uXL5dNP7TvV5MN4uLiyMnJYeTIkfTt25f09HT+8Ic/MGHCBAYPHiz969rkACHzHR0d+Pj4YDAYiIyMpFevXmRkZPDBBx/w0ksv0adPH5qammTcSwti8xSBRoPBwMCBAzl//jxDhgxh3rx51NfX4+/v75SlooLRaMRsNhMYGEhTU5Pk1+joaEJCQpgyZQo333wz0dHRunNxOLpSTE0mE0lJSbS3t+Pv74/RaOTo0aOkp6fz/fffExoaSkxMTLdUVUFLEZ8zGo34+/sTEhIijYa//OUv+Pv7c88995CUlNTtQtvPhV/cxy6IZbfbpYuhra2Nfv36yUa5Z8+epbGxUTeyLX53d3cnMDBQ7vDCOgsODmbWrFn07t3b6e/a4KnwdwtLtbCwkMbGRiZNmsR1111Hjx49OHXqFCaTCavVKp/TzgO64gYXL16ksbERh8PBxo0bOX78OC+88IIUOhHkFCB8gB4eHgQFBeHl5UVtbS0BAQF4eHiwcuVKHn74YdavX3/VTBYB3t7elJSU0NTURFBQECdPnmTJkiXs27ePQYMGUV9fr+2g5EQLMZfa2lqZHbR+/Xrmzp1LeHg4x44dc0rp0oLI4Ghvb6e5uRlvb2/c3d05ceIERUVFlJaWMmPGDKe4iVahip8eHh4S387OTkaNGkV8fDwpKSnMmjULQGZH6EFHR4dsbWaxWGhqaiIxMZH33nuPP/7xj0ydOlXyjJ5PWN0gbDYbBQUFtLW1UVdXx6lTp6irq6O0tBRPT0+5NtrNUghvaWkpo0ePpqWlhZaWFlasWEFISAiXLl1izJgxGAxdfTG1abJiAzYajTQ1NdHZ2Ymvry82m40ffviBy5cvOzUEFwFYLRiNRiIiIvD19aWsrEy67FJSUsjOzubw4cPSDaCnDB2OribnbW1teHp6YjKZqK2tZcyYMTJ2IWRJ4KA1osQ8wsPDSUxMpLS0FLvdjq+vLxkZGfj5+WEymbTuDyfeMhi6Ok15eXnRq1cvevbsiYeHB9HR0TzwwAPceOON/Pa3v5UbjF6atOCNsLAw2YZPnF42btzI9ddfz/XXX09zc7NTiz4VDzc3Nzw9Pamrq5PWP8DYsWM5d+4cTz75JDfeeCNWq/WqaazCoIuOjpaJHPn5+Rw+fJgbb7xRrrWg6f96xS6E393dHX9/fxkUOXz4MKGhodx2223cfffdWCyWq44hFGPPnj1lmqDofxgYGEhOTg4tLS26Vr8ADw8PzGYzJSUl0lXR0dHB4sWLCQkJYdmyZXR0dEgXhitF5OXlRXBwMGazGYfDQUlJCadPnyY5OZkRI0bI9E6tVSeUi91ux2q14uvrS15eHjt37mTkyJE888wz3HbbbdKC1LNQ7Xa7bMrs7u6Oj48Pra2trFmzhmeffVb6l4UvWU9w4d+pjk1NTYSFhVFaWoqXlxdffPEFFy9exG63S8HTs/pFkMdgMEir6ezZs4wYMYJ0wJtCAAAgAElEQVSOjg5uu+02IiIinPLjVVBPJI2NjVKIbDYb69evZ9++fbz66qty81PbjmnpYbfbCQ0NlUG6K1euYDAYGDlyJJcvX6Zv375YLBaXuIixjEYjYWFhhISEyBZ5q1at4siRI8TFxclTg97m0NHRIZVRWVkZgYGBeHt7k5KSQltbG1lZWQCy8bKe8IoNwt3dXW7YBoNBZoHV19fz9NNPy3aDegFpQKblibTAXr16UVtby6OPPsqECRPkKdoVb4gTVExMDNDFu19++SXHjh3jqaee4q677gK6N1wRnwl+qa2tlamfBQUF1NbWEhcXR3p6Oj4+Pi4vDgl6dnR0EBoaisVikemGn3/+OS+++CLfffcdVVVVdHR04Onp6TJ4KoKXJSUleHt709rayqFDh3j77bfZt28fZ8+eld4C7VwE2Gw2/P39sVqtREdHc/78eZ566inCwsJ47rnnCA8Px8fHx2UwWdxnEJukyK46c+YM7733Hr/73e+Ij4+XKb16G+5PwS+ax64eGYUC6ujokEE1gNtuu42ysjLi4+OB7jVDVGvPy8uL+vp6rFYr/v7+TJgwgWXLlnHy5EkMBoMkLOjfYhQWc48ePcjLy+PcuXOsXLmS6dOnk52dzbhx4/D19ZXPaI+YAj+xAEVFRURERPDVV1+xcuVKrr/+ejo6OvD395dMqyowVaC9vLzw8PDgwIEDXLhwgd///ve4ubkRFxfXLRdWnYfRaKSzs1P6WEXmw4IFC3jggQc4ceIEZrNZpvhpQXwm7hX06NGDmpoaHA4HgwcPZuXKlaSlpfHss886zVvLrELJCaGorKykubmZf/3rX5SXl7Nu3ToAzGZzt3er4Obmhr+/PyJAvm/fPlatWsULL7zAwIEDSUhIkLRwNR/hZouIiKCoqIj09HTsdjv79u2jtraWF154AUAG6bTPi/HFkd9kMrFlyxYeeOABEhMTKS8vl5ulHm+IcTo7O/H39ycoKIgLFy6QmZnJd999R3h4OO+++y4NDQ306NFDPqPldWFJBwUFSYu/urqakydPMm/ePCZOnMiUKVO6pdGK34WS9Pb2pqWlhaCgIPbu3YvJZGL06NGEhobSu3dvp/sVWmUmNieRolpYWIi3tzdr167lww8/pLOzk4CAAMxmsxPt1OfF+CEhIdTX19PU1MTZs2c5cuQIjz/+OBkZGYSFhTmVW1D5Q4zR+eNloIaGBgIDA8nNzaW2tpbk5GSeeOIJXn75ZQIDA7vxhBhDbPyin7G/vz9bt25l9+7d7Nixg4sXL/LrX/9aN5deXSPokpfw8HCys7MZMGAAq1atIi0tjba2NhlDEfysxcPd3V3muEdGRsrkibi4OLKyssjKypIxQyH7rvBxBf+VWjHCevT09KS4uJjhw4fj4eHBvn37ZBAB9NuFaX3Vfn5+dHR08Nlnn7F+/XouXLhAbm6utG5UBayOofrQmpubiY6OpqGhgTFjxnDHHXfw/PPPSxzEM1pXinhezMfDw4Njx44xf/58rFYrWVlZMnirBfF+sXv7+vrS2tpKVFQUJSUlzJ49m1mzZjkJi541IwRRxB4qKioYMGAAEyZM4Pvvv+fgwYPSly/wdzUPkZ1ht9v57LPPeOmllygpKeGll17C19dX4qIVXpXGwspuamrCYrFw7733yks56hV4V8d+kcrq6elJbm4u2dnZ3H777fJzJcPJiafE/8X7hXvDarXi4+PDd999R11dHc899xze3t5yDO0pRlUAnp6etLa20traSt++fdm8ebP0SWvprp2HUFJGoxGr1UpiYiKDBg0iJSWF4uJiLl++TO/evZ0EV6vUBf+L77S0tPDRRx8xceJE+vTpw4QJE5xOtq6MDxEoFPndK1as4IEHHmDRokXYbDYnftQaQCpura2teHt7k5OTg7+/PxaLBbPZTGRkpBPeWloIhSzGDwgIYOLEiezevZsHHnhA3r0Q39cbQ52Tr68vTU1N7N+/nwMHDpCSksJrr71GRESEE39q6alufiaTiTNnztCnTx9mz57NkiVLpC5xNRft2rS3t1NXV0dGRga7d+/m8uXLAMTHxzu935W1Lb5TV1dHRUUFixYt4qabbuJ3v/sd4eHhV8Xhp+AXD56qzFJZWYnRaJQ3vsrKypg7d66ur1H7uyBaYWEhOTk5TJo0iffff5+33nqLuLg4J/eJnt8OkO4Ro9FIeno6Hh4eMp3KZrPh6+vrdEX/ahZvc3MzNTU1DBw4kLa2Ns6fP88999wjj796iyveDVBeXs7hw4cpKChg48aNrFy5Uvr/r/Z+dV7CX1hcXMz8+fOpqanh+uuv73ZM1wq/+GcwdF0Qys3N5e677yYxMZGhQ4fi7+8v56GugwD1CO5wOCguLqazs5PDhw9jNpv51a9+JS1t9f3aMYR1aDB0XZqKj49n0aJFlJSUEBQU5OTPVV1hKn3UU6HD4cDPz4++ffvyxhtvsGDBAjw8PLBarZKPtIpETV8Uf6uvr+fYsWO0t7ezdOlShg8fLk+D4p+eX1nwXXV1NZ9++ilxcXF4enpy1113MXLkSLkJqQpHS1+h1E0mEx0dHcycOROz2UxycjJRUVFObkl1DIGXOBXW19fT2NjIddddx/bt2ykrK5OnRJV+WgNINWyEfzomJoa3335b3pBW36t1gQjeEu/x8PAgPT2dgwcPsnnzZlauXMm4ceOwWq1O5SP0DAfBG01NTXh5eTFw4ECWLFlCfX29VKpantKjJ3TpjYKCAnlafvbZZ5kwYUK35/RiJ2LTLioqIjY2lu3bt5Ofn8/QoUMJCgpyuaYqXwk88vPzKS4uZsqUKXz00UeUl5dLWqgxlP/VPnZ1kjabjY6ODoKDgzly5Ajjxo2T19XVY6HWaleP4e3t7bi5uVFTU8Pu3btZt26dTB3q7OyUfk4tqNZvW1sb9fX1VFVV8c9//pOoqCjmzJlDXl6eU9lV8Zz6f7FIbW1thISE4O/vz8GDB2loaACQV+oF3upctJtXQEAAEyZMYMyYMWRkZDB06FC5qQjh1eKgWps2m01a3AcPHiQ2NpZNmzYRHx+Pn5+f/L7W6lcVnAiQtbW10dDQQHNzM7feeit1dXXSbynG0QMRFAfkFe3du3eTmpoqLw25stYFPQ2Grgto1dXVeHt78/rrr2OxWPj0009lwEz7TnUu6pza29s5fPgwQUFBvPLKKyQlJdHY2ChPWHrzUAVJnDwOHTpEQ0MDU6ZMISsrC29v758V1BJjhIWFMWvWLDZu3Mjy5csxGAzExcXJm8c/xaMOh4PCwkK2bdvGyy+/THt7O4MGDaJ3795yExO85criFjGSs2fPSn6trq6WpxPxXa2VK2hptVppa2tj3bp1LFu2jIqKCnbv3i3jWHqnDgFC2be1tVFaWiozT9zcukpEiPiRK8tWzSSBrhO/3W4nMzMTs9nMl19+ia+vb7ebnnpzEf/v3bu3vLiXlJREQkICbW1tMtag55ZS5Uf4+/Py8pg8eTLZ2dlcvnxZegoEHloeUXFoa2vDbDbTp08fLly4QGNjoyyjIU6nApf/1T52FRyOroT+EydOMH36dIKCgujXrx8+Pj5SAaiLIUD9rLOzE4vFwpAhQ2hra2Po0KFkZGQQFxfndCXY1dHO4XDQ3NwsrZeEhARmzpyJp6cnoaGhkrDqe/UWyc3NjW+++YZTp04BUFRUxEsvvQQgmVZbN1tdfJvNRnp6OkFBQRw6dIi7775b+szF5vRTCqSqqorLly9TVlbGW2+9xYkTJzh+/Dju7u6ydouer04du7q6mubmZoYPH05DQwNJSUmUlJQ4MagrpS4UUXNzM6GhofTt25eqqir8/f1pbW2VefiuXCCqYjEajcTGxpKenk5SUhJjx47l0qVLuLu709ra2u30oIeL3W7n/PnzTJgwgcuXL7N06VJOnjwpL0ep/HW1I3dxcTFlZWWMHj2a0tJSfH19nVxbemsj1lq4TwICAti2bZt0IbzzzjuEhobi7e3tVBBLBRWvK1eu0N7eTu/evfnTn/5EWloaubm53HzzzdJ6VJWQipMwgDw9PcnMzGTXrl0sWbKEzZs3M3fuXDo6OqQl7CpYaDAYZCZQWVkZffr04eDBg9hsNm6//Xan+WpBKGWHwyFvWp4+fZotW7bw9NNPyyAhILOg9N4vPq+oqKCiooKePXvyyCOPsHr1au677z6GDBkiZcXVmqpG0IULFxgyZAivvPIKISEhDB48mISEBJnYoRc3UefS3t4uZXTs2LFs27aN6upqmeYoXIaqq1M7H5FUsW3bNkJCQigoKGDq1Km0trbi4+Pj5Jn4X22xC6IIJDMzM+nbty/79+8nLS2NwYMH4+Pj063kqZ4fFaClpYWzZ88SFRVFWloa7e3tXHfddU6XBlwd2QU+RqOR4OBgevToQUREBOXl5Rw5cgRABs+0z6u/GwxdOeT9+vVj5MiR9O7dm4kTJ7J3715aWlrw9vbWTXdSj++1tbW4u7tz5MgRHn74YVJSUti0aRNlZWVXVTzq37y8vIiKiiIiIoIPPviAc+fOERwcTFNTk1REYs56R1SHoyugXVZWRmdnJ//85z954oknuP322wHno7arzVIwbHV1tXQziGO43iatB52dnVRWVlJRUUFoaCj9+/dn06ZNMnfdVQaJFkQpiV27dsmU2sDAQHmRTOty0a6PeIefnx+//e1vGThwIP369WPIkCFOAqs3L8Gjbm5uWK1WqqursVgs3H///dxxxx0yQ0YtEqUHAhc/Pz+Ki4uZMGECe/fu5f7772fatGlOJxw9C1OM29zcjNVqxc/Pj0GDBvHtt98yZMgQWRjNlQGkjmGxWIiPj2f+/Pn07dsXk8nE448/LvFU10Uv5mAwGORlr5ycHJ555hk8PDzYsmULZWVlTu/S2/RVPhdptHv37mXBggX4+flRVlbmdLrWy4oRayLq/bi7u9O3b1/mzZtHYWFhN3eNipOYpxizvb2dU6dO0adPH44dO8Y777zDrFmzZBquyl+ufP2tra1cvHiRIUOGYLfbmTt3LmfOnJHp1aqO+E8t9l/05ik/3lBU/U9i9xMV+IKCgqQyVN0x4NzFRIA4/lutVlpbW2WUXmTZaHZweYPsx58qYrS3t8taNg7Hv2tcqOO4aTooqcJts9mw2+2YTCZKS0sJDQ2VLgzVJWMwdN0MVJWIYESHw4G4+iwuNqk4/vh9pxuf6neEz9PDw4OGhgbMZrMrQdMdQ8zXZrNRV1eH3W4nJCTEKb1QeZ/TGFoQFkl1dbUMkGmPxNo1UWkqqiN2dnbVPImKiupmWapjdP7YnUbwhXoKEAWgQkJCusVfflwfORctbwAyCCuMBpFFpAEnHlU3ceHmEvVf1CqZGl6X9FBPSsK1aDKZaGhowMfHR66z1nhxc3MzCP4UoMpMTU2NdIO6OMl1W1d1LCGv0OUWERa3q3VVXRsi6CjGsVqtmM1mp5iFQtdueKindXHiDggIkIFd9Xs/0s6JN1S+ECmUTU1NMqtH8IbgQ1XmUW4lCxyEm1TceBYeB61RKvBQ10VV2uI02traKjN7dDKUfrbZ/ksr9mtwDa7BNbgG/8PwX2m0cQ2uwTW4Btfgfw6uKfZrcA2uwTX4Pwa/aFaM3W538iur/jQRKBCBUzXQ+mPaoUvfturLdBXd1/rHVX+g+l41uKH6xpW/OfnbtGmIauBEBcWX6+RjV+egDRirOGrm082XK2ipPgfde7Bq4w16vn4dP3i3v//4uxxD9aGq2T9a/712PFz4x8WaiZ8an7oc78fvd/NfqqA3Fz2/tEqPq/GWOpYa8NPORU2PU33lepkOenEgbeBOHUf1R2uD8yp/aWVMbw6u1lX1j2viEU451loctTEx7Xqp31ef0/jXncYQf9eTfe1aaeS4W2xOj7+En1vLK9q4hyv5VscVoOLsiqbaGJmWr1T6/Cc+9l88K0b8VIMg8O/osVY5aCcuntEqZvF/Mb5WGbqKTAPdNhNVGPUyWvTw1jKY+OfqvXr519rfxcI7HP/uZaqX0aIN1Kg0UMdQBcIVLfTmoLdRaNdE4KcqOvU57eainYtKR3UNhBCoitFVxTs92mizCkTOtqvsHu3mqPKaiouKtzq++rlIZVTXWi0PIfDQ4qy+S708puUl7fu0G7KrzV6MpeUL7Vq7Wj9X2TfqpqX+TV1HlR7atdZ+Xwta2qtj/NSaaHWE+n+DwbkQmzofve+r+KvyoyZAuMrqc4Wznmy6msvPgf/KBSW1nKUeEV0pUwHaHVcwm1gU7aagZRRXjKNn3Wg3GRUvrdJUF0u7qHq4qaBt8KsKsioM2g1Bq0BVGrqwgpxAyzhaxaB9XsxReyNXi7ve+Ooc9NZVq2S031Mtrp/KdxaboSazyimVzVX+uFa5uOIflUZ6CkerwFSB185FSzcxX1eKz5Xho+U/VaGpvKHddLTpgdrxAN2bkA7Hv8sn6Mma9r1avtczwq5m6Khj6m3C6onTlZLUGiEqLtp3avlPa1Rqlbu6oeq9Q0sTddPW01euTgc/Bb/4BSWVkfPz83Fzc+PSpUtMmjSJlStXMn/+fFlZzdPTE09PTydhVMFg6Lo4UV9fT2dnJ2vWrCE5OZmPPvqISZMm8eyzz9Lc3CzrQAtQCWgwGGRjiC+++IKsrCxWr17NpUuXOHfuHBMmTMBgMMhm1CqoQiVuKR4/fpxx48bx0UcfMWvWLD755BP69evHjTfeKDvqANL9I2hSUVFBe3s733zzDcnJyVRVVfH666+TmJjIX/7yFwAiIyOvqqRLSkoIDw+nurqapqYmFi9ezL333ssXX3whO8yIPG69OUBXaQPRYGPVqlVkZmby7rvvsmHDBp555hnZN1RPmYh5lZSUUFdXR21tLWVlZWzevJkRI0bg7+9PfHw8w4YNw2KxdLvOLgSis7Or3K27uzvl5eUcOHCA+fPn89RTTzF27FgGDBjAkCFD8Pb27mbFak8M1dXV7Nixg8mTJ/PKK69w//33U11dTXJyMiaTSZemqltOXA6KjY3l008/xdvbG5PJRFpaGrNnzyYxMVHbwETSVVVIdXV12Gw2ioqKWLx4MbfccgsPPfQQGRkZThVA9axywaPNzc1kZmbKG59NTU3Mnz+fsLAwoqOj5Q1jodBV5WK328nLy8NsNlNTU4PRaKS8vJwTJ04wceJEYmJiuvG4dnNva2ujsLCQ8PBwPvnkExoaGrBarYwfP57w8HB69uwpS/Cq/KDOpba2Vhbw+vvf/46XlxeRkZHce++9lJaW0rdvX5cWrRhHNDf/4osvKC0tJT8/n+nTp9O/f39KSkro378/ISEhunpDzKWmpgar1UpFRQVxcXGcOHGC9evXM23aNG655RY6OjoIDw/vhoeqgEU68bvvvkt1dbVsJiMuPIWEhMjKm1oQ/NXa2kp5ebm8rLlq1SoGDRpEVFQUv/3tb6moqCA4ONilDnQFv7grRux4DQ0N8gLNm2++yYsvvsiMGTMIDw8nJSWF0tJSMjMzdccRi1NfX097eztFRUUsX76cHj168MYbbzBv3jxZqbGsrEzmzQrQ7q4Oh4M+ffoQFBTElStXOHv2LAsXLqSjo4P09HQuX76sa7UJENf5MzMzOXbsGH/961+x2+1s2LCBhQsXcubMGdnaTosDdF0gaW9v5+zZswwcOJB//OMf3HTTTWRlZfHaa6+xefNmqRjU96r0bG1tpUePHlRWVvL1118zc+ZMVqxYQWNjIyNGjOCzzz6jqqqqW114FWpqarDZbPTs2ZOmpiZ8fHzYtWsXQ4cOpaamRtaycLUmDse/yxDn5eUBkJyczNixY9m4cSNDhw6ltLSU8vJyp1u92jFEbnN5eTlPPvkkqampfPbZZzz00EPYbDZSU1OpqqqSBaxUmgqaNDc309jYyLFjxxg+fDiLFy+W/Whnz57NuXPnKC4u7taXUlUgdXV1WK1W9u7dS2trK42NjeTn57Ns2TL69++P1Wqlrq6u2xFaPWlYrVZKSkqorq5m7dq1BAcHM2DAAO677z7uuusuOjs7qaqq0j1ZiTFFFdQrV65gNBpZuXIlycnJLFmyhMbGRvz9/btZmKoBBV2bvoeHB76+vnh4eMiWjF999RUBAQGyT6gKWjdRYWEhbW1tPPTQQ/z1r3+loqKCpqYmrrvuOnbu3CmLjelZwg6HQ/Let99+S3l5OX369OGee+5hzpw5nD9/nsTERIqKinRjZOJ3UfVQlP8ePXo0+/fvZ/369SxcuJCcnBx5D0bv5CBkxdPTk6amJuLj49m4cSNTp05l//797Nq1Cw8PDy5dutSt/6p6SrFarbi5uZGRkcGtt97KF198wTvvvMPEiRP58ssvZeVZbeMQ1YCx2Ww0NjZy4MABtm3bxqBBg6iqqmLAgAGy7LjZbNZ1cf0U/FeqO4rLIr6+vtx7772cPn0aq9XKwoULmTVrFnfccQc7d+4kLi6u2xhigcRlgJCQEBISEoiJiaGmpoZVq1YxbNgw7HY7/fv3p6qqqtsxUyV0UVERaWlpbNq0iRkzZrB7925yc3PZunUrNTU19OjRg9jYWKdbqCoegOzzOXnyZGbOnMmMGTOIiIhg7969bNmyhZdeeonOzq4blerzgLxUVVtby4oVKwgICOAvf/kLq1ev5rHHHuNPf/oT/fr1w8PDQ9ayFqAe4cXmUFZWxunTp7nxxhv55JNPWL9+PYsXL5Yt80SFP3UMcflFdFj/5ptv8PDwYNGiRdx6661ERUWxb98+goODCQsLc3LDiDHEuhqNRhoaGti/fz/ff/89sbFdTcXHjBmD0WjkzJkz5OTkyDo/AsSYNpuNqqoqGhoa2LJlC59++inPPfccNpuNlStXyq41DodD9wq6mIunpycpKSlMnjyZDRs20NzczJ49e7BYLPTv35/6+npZv0bLX2JMd3d3AgICGD58ONu2bSM1NZX4+HgmTJhAamoq77//PhUVFbKomJamwviorKwkNzeXOXPm8M033/DnP/+ZP/3pT7z22msMHz4cNze3bnMRtBHNFry9vSksLMTDw4M1a9Zw7733kpqaSlNTk7yRqxfQFA1CLl26xP79+7FYLERERGA2mxkwYABlZWX4+/tz8uRJ2VVKgDBEbDYbNTU15Ofn8//+3//j/vvvJyUlBZvNxhNPPMGbb77JqVOnZNkHFcQGY7PZZPP3CRMm8I9//IN9+/bx8ccfk52dTWlpKbm5uVy8ePGqTVR8fX05d+4cXl5e7Ny5k9WrV8s+vCEhIdxxxx0cP35c3jxW11XMSXRheuWVV3jqqae4/vrreeWVV1i6dKmTwaHe2AZnvVFTU0NWVpZsa/jZZ5+xa9cuioqK5G3v0tLSbvMQxkt7ezsmk0n2tP3666958sknWblyJQ0NDVy8eJGMjAzKysqcLpH9XPjF0x0NBoO8xr9582ZmzZrFgAED6OjoYPv27VgsFt58802ioqLk8U+riKDranF1dTUHDhwgODhYXoGPjIzE09OTmJgYRo4cKctf6u14ra2tREdH09nZSU1NDe+++y5PPvkkERERLF++nJycHPLz87l48aLTu8U8oGuhsrKyGDBgAB999BF//OMf8fPzY8yYMUydOpX777+f2bNnA8gr5OJ54ecsKiqipqaGwMBAkpKSKCsrY8GCBfj6+rJmzRpGjBghXQZ68zAYDPj6+lJfX0/Pnj15+eWXZYu+Tz75hHvuuYfRo0dLf6hedoK7uzu5ubl4enpy+vRp3nzzTex2O5MmTeLkyZOy5vwPP/zQzaISwuvp6UlZWRlJSUkUFxczduxYMjMzGTJkCFOmTKG2tpZhw4Y51RfR0tPd3Z26ujpCQ0N58MEH2bZtG2lpabJwl+g0VVZWJq/Sq7xhMHTVT//hhx+orq7Gx8eHjIwMevfuzZ49e6ipqWHMmDEcOHCA4cOHU1xcrGuxi7VpaWnhvffeY9y4caxZs4aWlha8vLzIzMxk6NChsvOWlh6AbJ5y6dIljhw5wrJly5g9ezY//PADb7/9Njt27CA3N5f29nbZcEadi1jv4uJi0tLSSE1N5fe//z1ms5kvvviCX/3qV8yYMYP9+/djNBqdlJIaHPbz88NoNPKb3/yGgoICAgMDKSws5PHHH2fw4MHs2LEDi8XSTZGJdens7KprUl5eTnl5Oc8++ywHDx7klltuweFwyHIHvr6+1NTUOD2vujJEA/l169aRmprK3XffzWOPPca6devIy8vju+++o3///t3KLAjjxWazkZeXR1VVFX/4wx8YPHgwo0aNYs6cOTz//PMsXLiQr776Sjan1uIh/pWWlnL+/HnMZjOvv/46Z86cYerUqfj5+bF69Wp27dpFTExMt41O5TEvLy+SkpKoq6uTJUB8fX1JTU1l8uTJWK1WIiMjaWlp6YaH4PPa2lrsdjsXLlwgODiYjz/+WJbsXrRoEevXrycvL6/byeHnwC+q2FWmESVxp0+fTmhoKH/+85/Zt28fDz74IHPmzJE9SLUKQD3WiSvenZ2d3HvvvWzdupXs7GxefPFFHn74YY4dOyY7lOi5H7y8vLhy5QoFBQVUVFRQXFzM8uXLCQwMZOnSpSxatIjBgwfTr1+/btaQGoDp0aMH27dvp0ePHixatIiioiJiYmIYNWoUAwcO5NlnnyU9PV32NoV/M4iwQEeNGsWiRYv49ttv2blzp/StHTp0iODgYGmBqNayUCCtra3k5uZSUFDA008/TWNjI2fOnKGyspKcnBz+9Kc/cfr0aanE9DJ1DAaDLGDU2NhI//79efXVV3E4HEyYMIE1a9Zw6623MmHCBF0/PSArZb7//vssWLCA/fv3s2fPHgYOHMjKlSsZM2YMvr6+nD59upsyFPOx2+14e3tz9OhR9u7dS2RkJCaTiZEjR3LnnXcydOhQHn30Ufr27dvNNaWuTUJCAuPHj2fGjBkkJSWxcOFCBg4cSHOfH4YAACAASURBVEVFBV5eXixatIiKigoiIiK64WAwGGSrxbNnz/LJJ5/Iz2+++WaOHj3K3XffjdlsJigoSNaq1xvHy8uLYcOGUV5ezqRJkzhy5AinTp2itraWo0ePEhERgcVikc2h1XURlp1oATdixAh69erF+PHjGTFiBJs3b+buu+9m3Lhx0gevPi/4/vz58/j4+PDCCy+wa9cu3n//fcrKyrBYLPj6+jJo0CBqamq6yZoaqA0LC6NXr17069eP4OBgZsyYwcSJEzl27BgHDx7Ey8uL6OhogoODXQYMW1pa5NX7hIQEkpOTqampITExkUceeYQRI0ZQX1/fzXhRcTKZTHh7e/Pwww8zduxYamtrMZlMbN26lYcffpj+/fuTl5dHeHi4brzC4XAQHBwsN4cVK1YwatQoGhoamDp1Kvfcc4/kC1G2QQvt7e00NDSwdetWysvLiYyM5JVXXmHcuHEMGDBA9pWwWCzdOn2Jzdpms1FbW0tmZiYPPvgg06ZNw263c/HiRWbPnk1NTQ1Lly4lOjpa9yT2U/BfccV0dHRQVFTEpEmTWLZsGaGhoTz88MNMmjSJN954g88//5ykpCTy8vJkPQ0tiEDTgAED2L9/P/n5+Rw9epTs7Gzc3d0pKysjMjISi8XS7Xio+tr8/Py4/fbbmTdvHtOmTePBBx/khRdeYMCAAdTU1BAUFITD4ei2QGJMYV2Eh4fzyiuv8NVXX1FWVsYdd9zB3LlzSU5Oxm63ExUV5dR+TChYb29vQkNDOXPmDMuXL2fBggXceuuttLa28vbbbzNs2DA8PT0JCgrCbDZ3K3QkTkADBw5k8ODBxMTE8MwzzxAWFkZtbS179uzBYDAwYsQIQkJCZPs+AapPVPiMf//737Nr1y5+//vfc/z4cf72t7+RlpbGuXPnuHDhgq7vUTCs0WjkoYceIjU1lW+++Qa73U5+fj6BgYG89tprtLS0EBwc7LLTjc1mk3XGd+7cyY033siePXvYsGGD3Bj8/PwoLS3txhtigxLNoc+ePcvNN99MTEwMa9eulbEDMe/AwMBu/kvVDWO322VD8oqKCr744gvmzJnD5MmTOXv2LOPGjWPs2LHd6var2RkiSD5p0iT+9re/cfr0aWbOnElzczP9+/fHza2rqbl2LkKpenp6EhUVRVRUFGVlZYwfP56DBw/y/vvvExMTw8MPP8zJkycJDAzsxl8Cj5CQEIYNG8bLL7/MsmXLmDJlCrt37yYkJIS1a9cyevRoWalQb4Py8PCgqqqKpKQkFi9ezKhRo/j444/ZunWr5PFx48bR3t7erd2gOp7RaMRkMjF37lzeffddcnNzqaioYObMmRw4cECehlxlCHV2dso2lPn5+QwaNEiWI37sscd455138PPzIzY2lra2tm68JXzj/v7+9OrVi/fff59ly5bx/fffc+DAAb7++mumTp3K6NGjZTxDOxfB5+7u7owdOxYPDw9SU1PZs2cP58+fJzAwkB07dhASEuJUOVPFQZymjEYjw4YNY+LEiWRmZpKTk8Ps2bPx8PBg7969pKWlkZCQIGvx/CfwX7HYPT096dWrF7GxsSxevJjDhw+zc+dO1q5dy8mTJ2XnbtFhxpX7wWAwSGU0aNAg2X3EbDaTmZnJoEGD6Nmzp0sXhqenJzabjdOnT/9/7Z13dJXF1v8/56T3TkJIQgohtAChKSJYQDqIiGJXEATsBUWN3gtYUBABaSIWkHJtvCpIV6R3CAikQDpJSO/tJCc5vz/ijHOePPHe+6716m+xznctFifJc+aZ2bNnz5699+wNwJIlS2jfvj3btm1j586dUpsKCAhoFfkgdtGmpiZcXV3x9/dn3LhxdOzYkaSkJF5++WU++OAD1q9fz8CBAwkPD7eKelD/d3R0pKGhgW+++YagoCCmTJnC1q1bGTBgALt37yY7O1vWSGzLbmgymcjMzCQvL4/GxkZGjx7NW2+9Rbt27Vi7di1Go5HQ0NBWi1eNWmhoaMDZ2ZlPPvmEefPmYTKZ+Oijj1izZg033XQT/v7+dO/evdUmJ4SQnZ0dISEhXLx4keDgYMaNG0dGRgaJiYmsXLmSwYMHM27cOKKjo9uMhXZxcZE265deeonnnnuOI0eOsGDBAiZMmMCZM2coLCwkKipK1wba3NxSHcdkMtG5c2fuv/9+kpKSmDBhAuHh4RQWFhIfH0/79u3laaAt05S3tzdubm4sXLiQgwcP0rt3bxwdHdm8eTMPPPAA3t7ecux6tlQnJydqa2vx9/fH19eX6OhoGhoaeP755wkLCyMqKgovLy+r6kJqH9TNMj8/n9jYWL777jvWr1+Po6MjpaWltGvXjptuukn3+4BMSlVcXMzhw4e58cYbSU5OJjU1lSFDhvDZZ59RU1Mji4BoeUOMIyAgAHd3d3766ScOHjzInXfeyU8//cSjjz7KBx98IAtd6xVeF/4QPz8/uZG+9tprzJs3j6amJplZNSwsjM6dO+sqcwZDS8lDf39/HBwc2LVrFykpKSxdulTaysvLy6XJUm9eAXm6qq2tZd68eWzcuJH4+HjeeOMNTpw4If1joaGhbZqlHBwcZJW3M2fO0KNHD7744gtSUlIoLCzk+PHjuLm54evra5WkTUCYFF1dXYmOjuann37i0KFDPP/884SGhtKuXTtpZhLP/3+tsYvOCS0mIyODJUuWsHHjRi5cuEC7du345ZdfiIiIICwsTNoMVW1ILCIxeR07dsTT05MhQ4Zw+PBhkpOTeffdd6VW1JaHXfzO29ubkJAQVqxYwWOPPcZtt93G6dOnJdO1VXldHHPFxtO3b1/y8vJkX5988kns7OxkIWUxbvVIqF6IsFgsPPbYY9x1113k5ubyySefEBUVRa9evQgNDW0V9SA+i+xyRmNL1jwRnldUVMSWLVu44YYbuO2222SBaa1ZSo0jDggIICMjgxkzZnD48GGOHj3K1atX8ff3p7KyUlaH0TKqGolhZ2dHeHg4Bw4coKysDD8/P5577jnS0tIYO3YsjY2NrVKbqvQ0Go34+/vL/NjPPfccAwcOxMnJifDwcMaNG2fF6NrTh+iPh4cH1dXVvPXWWyxdupRHHnkEX19f5s2bJ8P9xGmlrRBDNzc3TCYTtbW1PPHEE4wePZpRo0axZcsWgoKCZIk9PcVBtC20y6NHj/LII4+QmprKlClT2LBhA6NHj6agoMAqp7oKMTZ7e3saGxu57bbbpP+jqKiIpqYmzGazbo1NNQrEx8cHLy8v9u7dS1JSEqNGjSI8PBwHBwcee+yxVimutWMQSElJoXPnzvTp0wd7e3vuuOMO+vXrR2NjI506ddINU1R53tPTE3d3dw4ePMjVq1d555138PPzkymmRZZGbUSLdr47dOjAkCFDiI+P57PPPuPNN9/kxRdfpHPnzjg5OVnFhmtp2dTUhLu7O2FhYbK+8fHjx+nYsSMdO3YkMTGRsLAwKxqqbagRUDU1NVJRCA8P5+zZs9x2220yp7s2Gk+0Kdrx9vbm2rVrjBs3junTp3Pp0iXpgO7fv79UBLURef8J/nJTjFhI9vb2dOjQgcmTJzN37lzy8/MZO3YsdXV13HTTTRQUFFgJcW0bqlnn4sWLzJs3D39/f+6//36am1uKVNfW1ra524lJa2pqIiQkhGnTphEWFsa5c+e49dZb+fjjj8nLy6O2ttZKcKlQL73k5OTwyiuvMHPmTDZv3syyZcsYNGgQdnZ2uiFcQisU7QQEBPDhhx8SFBTEa6+9xqJFizCZTLRr105uINoJFpuIECyBgYH84x//ICYmhocffpjc3Fyio6MJDQ2VUQnafogjrggfCwgI4N133yUmJkYeaZubm4mOjpbphNuaV9GG0WjE1dWVLl26sHTpUoKCgjh//jxZWVlWpxa9DaK5uZn6+noCAgJYuXIlFy9eJDc3lzVr1vD000+Tl5cno0C0QkS9+GYymbjxxhsJDg6WJpSioiJSUlIIDAzEw8NDLjLtZSsxHhEyefPNNxMTE0OfPn1YsmSJNP2JiBo9jV+MRZzo7r33Xtzc3LjzzjsZP368jHZpqwi0Sh+LpaVgx8aNG6mrq6OgoID27duTlZVFXFwcVVVVUlPWo6nFYiE/P58BAwYQFxfHL7/8wtChQ+nevTsXLlyw4qO23m+xWIiIiKCqqooFCxZQXl5Ou3btSE5O5vLly/JUqaWHKhzr6uqIioris88+Y8eOHbKwRXh4ONXV1RQVFcn5045D3YCLiorYv38/Xbt25fnnnycrKwsHBweuXbtGTU2NFf21YxFrXhTnPn36NLfeequshNSnTx8qKyvbFKSCniaTCQ8PD0wmEzt37uTgwYOyKLXB0FKKUM+kpLZRU1NDaGgoubm5TJo0ic8//5yMjAyeeeYZnJycqKiosCqz99/gL72gpA5ULJoTJ06QlpbGzTffzOXLl1m3bh3Dhw+nT58+uotXQDB7RkYG48ePZ/To0dJBlJeXR1JSkvROOzs7t8m0paWl1NbWsn79en788UcmTJhAeno6H3/8MZMmTSI3N1fatvXiSUVtwoyMDNasWUNWVhaffvopv/zyC7t27WLYsGG0b9/eakNSNxuDoSVe2tPTk7i4ODw9PdmwYQMNDQ1ERkZiNpupra2VjhwtPQQDFxYWcuTIEV588UVCQkJ44YUX+OWXXyTT9u7dm4CAAF2TlKoVeHh4MG3aNLZs2UJISAjHjx8nLi6OkydPEhUVJasxafsg/jk7O/Ptt99y0003MXnyZGpqakhNTaVr166cPn2a4cOHy++1denCycmJvLw8vvvuOx566CGmT5/OrbfeKp3p9fX12NnZyQs56jjEojEajaxcuZKwsDBmzZrF+vXryczMpH379mRnZ+Pq6ioLjbelYYqc5XV1dXz++ee4urrSvXt3Tp48SWhoKCaTCU9PTzkH6oYlTFMidPPEiROcO3eOmTNn8swzz3DrrbcCLaaBqqoqGUeu8oVop76+Hnd3dwIDAzl//jxubm688MIL1NfXc+HCBW644QYaGhpk/LZ2vYjIjE2bNhEYGEi/fv2oqqqiuroaPz8/wLp6kZZHDIaWyzinTp3C3d2dAQMGsGjRImJjYwkICMDNzQ0fHx+pUOmtNWFSWrlyJVevXuXVV1/F0dGRiIgIXF1dqaiosKrhqgcRNvnll19y44030qNHDzp37izpMHLkSBobG6mtrZUbtxZGo1HO6/jx46mpqeHgwYMUFBSQk5ODm5sbXl5eso6BVrEUbZhMJsLCwvD392fy5MlMnTqVSZMmkZGRQd++fcnMzCQsLMxKwxe0EKivr2fXrl3cfffdHDx4kH379jFr1iwKCwvp3bs3KSkpVmvzvxHwf4vG3tzcUmXHz8+P4OBgoqKiSE9PJyIigoiICGpraykpKZGmg7YG5OnpydGjR0lKSsLHxwc7OzuWLVtGfn4+N954I1lZWa3shmC9eJ2dnTl69CgPPvgg33//PTfffDNlZWVERkZy6NAhaQbRO2IKhk1KSqK2tpb6+nq2bNnCqFGj5Ali1KhRcmP4sx38nXfewc3NjQ8++IDs7GwWL17M4MGDZWif+H5bpofS0lJZR/Pbb79l2LBhREZG0tTUxMCBA62KEOjFSwvNNT4+nurqagYPHkxkZKTsf48ePfD399dldNGO8HlcuXKFOXPm8PPPP+Pt7c2zzz5LUVERvr6+8lmtRqQKlZSUFBwcHOjduzc1NTXccccdLFy4EEdHR44cOUJNTY3sg9ZMJ+YlIyODlJQUdu3axbJly+jZsycRERFs2bKFrKwsysvLJe20x23Vsb127Vq++eYb3Nzc2LRpE3PnziUhIQFnZ2cphLRtqOOrqanhq6++4uTJkxQUFHD8+HHc3d3x8vLC1dWV+vp6XTus6Bu0RGEsXryYuXPnyoLpW7dulfcs8vLyrArLCHqKKKPa2lreffddPvvsM7p3787s2bOlQxRaNti2+FP0y8vLi379+vH666/z7LPPypOkqBRWWVkpL4xpNWWx8V25ckVGeLm4uDB8+HDc3Nxwd3fH0dFR3kbWrnlV275y5Qpjx47l5MmTuLm54ezszG+//caAAQM4deoUTk5O0omst1YslpZKYW+88Qb79u0jJCSEU6dOkZCQQEJCAsXFxZSXl0vzmN4mZbFYKC0tZd68eWzatIkffviB4cOH4+7uTkpKChaLRfqA9CDaECfokSNH8q9//YvKykq+//57XFxcKCwspFOnTro8+p/gb0nbazQacXNzY/ny5Rw6dIgXXngBb29vjhw5QkpKCkFBQTg7O8tFqreDi2PuU089xRdffMGRI0fw8vKS13PT09MJCAiwOk6q74c/YuqdnZ356quv8PX1ZfPmzXz00UcEBgZyww03kJeXp0tUVdDGxMQQGxvLxo0b8fHx4b333qNnz56MHDmSPXv24OnpaRUloaKxsZHTp0/j6OjI1KlTOXXqFEuXLuX555/nvffe49q1azg6OraKyxX9B2TR7ezsbCIiInjggQdwcXHh6aefpmvXrlgsFukA1tbYVBNqOTg4kJWVxezZs8nIyCAwMJAvv/xSOucMBoN04GoXrzDpHD58mMGDB7NixQo++eQTHB0d+fjjj0lLS6NPnz6yzqd2kxKns8bGRgIDA1m5ciVz5szhrrvuYt68eTzxxBPU1dURGRmJg4NDq8pUWnpERkby4IMPMmHCBG6//XZ5Y7S2tlbaegVNtUJZ2LvT0tJ48sknqaurk3H5AwcOJC8vD1dXVwICAqRQVseiznVVVZV0iNfX15Obm8uRI0dYs2YNRUVFZGVlWRVQ1sJoNFJdXc2YMWPo3r07Z86cYc+ePezatQtPT08qKiqkA1Ydi6Bvc3MzmZmZrF69mvLychnSJ8ondujQgcLCQunv0fKX2KT27NnDxo0bCQoK4osvvsDLyws/Pz+mTZsmI2rEs3p+IIPBQLdu3ejSpQu9evXiySefpKamhuTkZPbt20e/fv1IT09vZV8X/CXoGh4ezvbt23FwcOCnn37i/vvvZ/bs2YSFhdGnTx+ry4h6mrbB0JImYurUqTg5OZGTk8Ovv/6K0Whk9OjRhIaGEhwcrMujYjwGQ4sjt2vXrtxwww288847XLt2jQkTJpCUlCT5RUQIaekh+tWhQwcyMzPlRpuenk5qaiqXL1+WUWOqsvLf4C8X7CqzxcbGsn//fk6cOMFnn33GK6+8gq+vL76+vjJPTFu2R3FENRqNVFVVMXToUGbPns25c+dwdnbG29tbHqf0tG2xMaSkpJCcnMwXX3zBmTNnWLJkCcuWLWP37t0UFBQQHh4uNRGtfVu04+TkRHFxMcnJycTFxTF79mzefvttUlNTrWKU9ULrHBwciIyMJD4+nlGjRvHQQw+xePFicnNzqa2tpWfPnoSFhcndXyuUBaN5enpyxx13kJubS58+fVi0aBErVqzg66+/pqioiKtXr0o6aGPhVUEUHBzM8uXLMRqN8kJMz549yc7OxtfXV9r89BxTFouFsLAwsrOzueWWW+jWrRsODg6cPHmSIUOG4OLiIq+2a+dEtCFue06ZMoW4uDjs7e158MEH6dixI3v37pXOVz2bsvjs4OAgL7KcPHmS5cuX4+zszKFDh5g7dy6Ojo5SK2vLzCfokp2dTbt27ejSpQtBQUFkZmbi4OBA+/btpXNfz7kl6Ong4MCMGTM4duwYpaWlHDt2jJ9//pn6+nrKysoIDAyUTja9zcFsNuPv78+wYcOYNWsWQUFBJCQkyBwkorydiAIRQk3QV5i79u/fzyeffMKAAQPYunUrtbW1pKWlkZycjKura6vMhmIMFktLmohOnToxYsQIEhMT+eWXX1izZg1+fn5s3ryZ8vLyNiNARDuAvNS1aNEiBgwYwIkTJxg+fDiNjY0kJyfj4uIio7a0wlD8f+7cOUaOHMk777wj49F/+OEHGejg5eWl68MRtDGbzfJi26uvvkpcXBxvvfUWubm5XLhwAfgjRYhKTy2fX7t2jTFjxtCnTx8KCwvx9/dn06ZN3HvvvdTX1+Pp6akbIST6Ai0XtqZNm0b//v0JCAigtraWO+64gyNHjlBSUoLFYtGlx3+Cv7zmqWDYuro69u7dy7Fjx7jhhhuoqqoiMDCQqKgoGWYmakv+LhANahti8hobG+VROycnB0dHR6KioujXr5+V0/N34sg2AKkh7tq1S17VHjx4MOPHjycqKoqysjJ8fX1lPCpg1YYQrKI6urgENHbsWBISEgj/PcRRbDDKEdNgUQjf3NxMbm4uy5YtA2DBggWsXLmSUaNG4erqSnBwsBRCernpxc3A5ORkTCYTPXv25PXXX+cf//iHjLG2s7OzcnyKcTQrucPFcytWrKBr166EhYWxa9cuBg8eLIW02WzGwcGh1ZyIdsUCq6ioYN++feTk5NC9e3eGDRtGY2Mjbm5ucszaORHCqKamBmdnZ5YtW8YjjzzC7NmzmTZtGjfeeKP0R6hCy6jJpS78L+JoHRcXh7u7OydPnsTT05OuXbvi4+Mjhffv9vBWNIUWh9/cuXOJj4+XuUC6detGu3btACQ9BFm1NK2ursbe3h4HBweOHDnCDz/8wO23346Xlxddu3bF3d1dauyCN7T0EA7l/Px8Xn31VZ566in69etHSUmJblje721YxOmsrq4Oe3t7Fi9ezP79+9mxYwdJSUmYzWZ561utA2vUqVtgsVg4cOAAFouFXbt24erqylNPPYWbm5ucB1UR086roJXBYCA+Pp7p06dz9epVoqOjqaqqkqG44kSotiEaELQQ91u+//57OnfuLNe+8DVozDmt+tHQ0MCePXvo27cv7733Hvfffz8DBgyQEVDu7u7SQa/Oq7pmReTLl19+KesLjxgxguDgYKqqqvD19ZVRYup6Q5E9BoOBwsJCcnNzKS0t5dy5c4SEhBAdHS3v4CjyTx3Lv8XfItiFUK6pqcHOzk5GCIhQJbU4rlioeoxiMBhkIh1HR0cZHSA0ZCcnJ9nO789bbQ6ibXHhpqmpCZPJJO3R4siv2l3BukCFiFgRWqTF0hKBYG9vj7+/P4DcFNQJampqsmgrxJvNZq5du4azs7P8p4Y8aQW7GAe0CJGSkhIZXhcUFCQTJgmzhXjud7RaNEIg2tnZUVJSIvvt7e0taSmEvyrYLRomqq6uxsXFhatXr+Li4oKfnx9NTU1ysWhOLq2ECEBlZaW8+u7m5iYdnapDS8vwog0xloqKCqvIo5qaGmnPFZuT4A+9Qi5izi0WC6mpqbIPAQEBNDY2WjmRVR5t/r3wiEBTUxNlZWVy0woKCpKnLTVxlipUBVkFTWprazGZTLLYsdHYEgstimQLXhQCUd2gDIaWKA0XFxcZhldXV4evr6+6vlr1QeVRQEZp1NTU4ObmZlW4WfC+eJ92c1D5y9HRkZycHDp27Ai03FgWAQ5iTlV6agW7mBeRMsJobMlaKvKvqFFkba35uro6amtrJY/7+PhQW1srUzPwxyS0kj3i/XV1ddK04+joKB2v6g1e8T5V+VBDW4XloaCggMjISCmHfudJqzBYhTf+Lf5SwS4GpRHYus48dRLU3VtdNOpxvq3jsOazlVAW79Zz5qmMLvqlClV1gjT9tOqP2kfRrrrwxGJQx64+q+1fW0yiPqvST3mn7kYp+qHSU32X2oY6HpWeYvGqWr92TrTHYz2tTPRfS0NlccixaehlpSkLiMUBrXOJq7RXBZGq9avPq+8U/VQXr552qCogKl3F70S/VNoY26gGpccH2jZVeqhrTfzTzovenPzejq7ioDqKtWtW+zctPdVNRqWLMm6refv97602ffVdKi11+KrNU6U6f9q51somLZ+r/VPHrzcvbQhlizqX2nnQjlOlk0Ed9L/BX62x22CDDTbY8H+MvyUqxgYbbLDBhv872AS7DTbYYMN1hr+6NJ50pGhD/zQ25FY/o+OZ1j6vtd+ptjSNV9kCbV99FlDti1rHkurQ0b5Ta9NWx/f7cwbt97XPa8eooVkrR59oS/sdMQ6tHRRaRwtox6NnY9fQtlUkidZ3oXmnbFdrYxf9aKsvWppq7Nu6dml17OrPej4RlaZaXtLwUJv01dJU/bs6prZ4Q8tfWr+CandV6aOuFzG3Wt+J8jcrOrThP9ANVNDSVKVTW7bttuakLX7XzHmrNnTszto5aJPP9fouoCeXlGda2elV+7jKs1p51BZvaGmqbVflE60M/E/wl988VQdrsbS+fCSIqreI1TbEM+rgtZMl2tIuCOFZF88Kh53ajtapobYn3q1+1gpo9Z/6nJ6gEu9Q6aGNR9Ybhwp1EWuFiravKrQLRaWzOhdtOc7Es1rBp35HfU7vf/U7WgeyXkyylgfU72tp3tb7VHrp8aDeRi+eV/lSpZN2LOo71Ta1/KEKaPU9eoEEWhprNzmVb/Q2aLVt7ToS/dTSTW8s2vbVNaRHD/X7Kp31hLv6TvFZpZVWRmg3ybbmTksjlU56ckmPl+CP+dAqoNp+q2PUvk/9rL5Pb7MX7/xv8LfkY9dqCQLqYhE/aydeT9tRd0mVcKItPaKojKwlvLZdPYGhfa6t/monXF2sesyjCnu9v7clRNoSWipdxHPaiAYtM6nv0S5W8VlPwPwZk+ttyFqoG4RWY1b7o/ZDjxZ6m676Xe3vtO2oi0xVDtQ2tfOsx2Nq/1WBq4Xe39paC3pKjh49tTRoS+C3JXTUn1V6qP3RCmZVQOpBb/NQx61HG+33tbzVFo+ptNNCq1SqPK6NJtNCG52k5SWtgqdtR6VbW+tEOx7tevtP8JcKdi0jCCYQcZwFBQWYzWarq7h6IYBaQoncMiLGVr1dJt6r1eS12qSoQCPar6qqanUjsC0tXW2juLiYhoYGKioqgLYZTIxNqy3l5ORQUFBAZmamLBih3nLV05ZVRhLFmaurqykoKKC+vl5XuxLQ9k98rqmpobGxbn1HggAAIABJREFUkZycHBoaGqwKR7e1YNTfi3ksKiqioKAAg8EgU/62tcBVDVR8rq6uprCwkKKiIsrLy2UaAL3Ti56AEDHboi/Nzc1UV1fLyzJ/tumLtsxms5zbxsZGSkpKrGpq6m3m2tC+uro6rl27RnV1NSaTicrKSjlXYuFq+Uvbl8bGRurq6qiuriYrK4uCggJZLLktWqh8bjKZ5BpRx6ZuEHpzq85TVVUVZrNZFtUoKiqSGUDb0ti1G0RDQwMlJSUUFBTI+RCJyrTrUqWvqqiIuH7Rf1FaUMyr3jwKiHc0NTWRm5tLc3MzdXV1QMt9AVWhU6FnxhG3uAsLCykrK6OiokKuU3WT0fZDnfPm5mYqKyut5I6Wv//dpqfFXyrYVQ3UaDTKTGz79+/HbDazbds2zp49S1lZmRUz6E20+i81NZWtW7fyzTffMH/+fBISEuQtOVVQqFA1IIPBgIuLC2azmU8//ZScnBxefvllLly40Epz00IsiJqaGi5fvsyRI0dwcHBg3bp1nD59Wm5SegJU7ZdgEJPJxN69e3n77bd59tlnSUlJkSlGxfvUNsTvBBPU1dVx9epV9u/fLzPcFRQUyMWsPaGopxEhfJOTk8nIyODbb79l69atGI1GTp061apKkNoPlUbinefOnWPdunV8+umn7N27l9TU1D/VzlSBXl9fz6VLl9i6dSseHh5cuXKFb7/9lqqqKqvFoeUL9X+xIZaUlLB69WpcXV3JycmhurpaVwtV6SHaMZlMXL58mYsXL3LhwgXOnTsnb3DqpQIQEHQ2Gv8o93f69GnOnz/P3r17qamp4dq1a1Iwa4WzatoyGluyCYq8Rrm5ucyfP5/4+Hh27Ngh+UPlJz2TVkVFBVu3bmXOnDkUFRWxefNmMjIyrDZtrQKktaVnZ2fz8ccfs2/fPnbs2IG9vT1lZWVSMLd1AhW0MJlMlJWV8cUXXxAYGMj8+fMxGAwcP35cpsjW0kI7J83NLakBHB0dOXnyJNOmTePrr78mLy9PCtU/O4kL2hQVFdHY2Mjhw4dZsGABVVVVFBUV6eZlUtsRbZnNZgoKCmTa4lmzZrF48WJ5kezfaeSAVBSuXLnCd999x6lTp/if//kfEhISdDeX/xR/tfMUo9EoU9FeunRJVjsPCwvDbDazcOFC3n//fc6cOcPIkSOB1g4wi8UiL5zU1NSwdOlSmVfZ09OTs2fPytusI0aM0G1DMEttbS25ubl88MEH7Ny5k9raWgIDA6muruaVV17h7bffZuDAgfK9WpuvuGCSkpLC1q1bCQ0NZfv27cTExLBnzx5++uknxo4dS//+/eX31MVnMploamrC0dGRkSNHsmvXLo4fP87hw4cZMWIEHh4eHD16lNtvv132W6Ul/KEd79+/nytXruDh4cF9993HK6+8Qvfu3QkODmbEiBG6jCYgtJbc3Fyqq6t5/fXXKSkpISgoiJ9//pm4uDi6dOkia1qqtBRCRdweTktLY+fOnezatYv09HRZLDguLo4RI0ZYpe7V8oaYtytXrrBo0SKmTJlCeHi4LAhx6tQpYmJiiIqKajWn6mI2mUwkJyfLgi2HDx9m/vz5jBs3Dg8PDyZOnMgtt9xiNZcqb4j89ceOHePTTz9l0aJFrFu3jp07dxIe3lLw49q1a3Ts2FH3FCnmuaGhgfT0dBYsWCBz7cfGxjJw4EDuuusu+vbtS6dOnVoJIpXP7e3tKS0t5dVXX8XPz49x48Yxb948XFxcmDlzJuPGjbMSvqrGKnLr7Nu3j71795KYmMj69ev5/PPP2b59OzfddBP5+flWxSVUnhBasNFoJDU1lcTERAYMGMBDDz2En58fM2fO5OjRo0yZMkVW/NGbV6Hhu7q6kpeXx969e/n222+ZMmUK7777Ln379m1TiGk3ioyMDL7//nsaGxspKirC2dmZ1atXSz7XZrpU2xF9OXToED///DMPPvgge/fuZdmyZQQEBODv78/gwYPp0KGD7olStGOxWKSykZSUxOXLl9m+fTsvvPAClZWVVFVV0alTJyulSW3DbDZjMpk4dOgQV69eZezYsQQGBhIQEMCgQYP46KOPqK2txc3NTVcx/Xf4W0wxQosR5bAGDRpEWFgYv/76KwEBATQ1NREQEGBlbxVQbfPCDLNo0SIee+wxli5dSn5+PhMmTKBLly7yea2NSt1xjcaWq8GPPPIIM2fOJC8vT+ZI/uSTT3B1ddU9Yqq2TbPZTNeuXdm9e7dMuHXmzBkuXLhAeno6/fr1a5XpTbQlEjiVlJTwwgsvcPXqVc6ePUuPHj0YOnSo1Pq1WRnF2MTiFwmQYmJieP/991m/fj2hoaGsX7+evXv3cuLEiT/NWActuT4CAwNxcXFh0aJFDBkyhICAAMaNG8eVK1eoqKhoU5sxGFquxxcVFfH999+Tl5fHlClT+Omnnzh79ixvvfUWd9xxB127dpV01/ajublZXvHu2bMngYGBvPbaa8THxzNu3DjuvvtubrjhBlxcXKivr281FtUc4OjoyLVr10hNTWX27Nm8//77ZGZmMn36dEaMGMGgQYN0K9yIRSiuiOfl5TFu3Dhyc3NJSkpi+/btPPjgg4SFhVFUVCSP/nr9EGYggKCgIDw8PKisrCQlJYXQ0FDGjBnD5cuXdetzCvqYzWby8/PJy8vj8uXL9O7dm+TkZM6fP8/gwYN57rnnyM7ObrW5iLHY2dlRVVXFlStXCA8PJzc3l8WLFzNo0CDuu+8+Fi5cSPv27eXzfxbBU1BQQGpqKqtWrWLt2rV89NFHWCwW5s6dS2FhoRUvqX0Q3xcmlzNnzrBo0SImTpwoN4otW7Zw5swZK1Obtg1hskhMTKRXr16MHTsWe3t7Bg4cyAMPPEBcXBzHjx/X5U8hL0SOl9jYWHbv3s2qVat47bXXeOutt4iLi8PBwUEqL9rTh0oTAH9/f1avXk1qaipHjx5lwYIFjB49mk2bNhESEtJqo1XHAi3yp6qqijvvvJOePXvi4+PD5s2b2bNnDxcvXuSXX36R1cb+vxbsKsOLdKMHDhzA3d2d/Px87rnnHvbv34+7uzvdunVrVTUd/iCssJtu2bKFBQsW0KNHD44fP05MTAzHjh3jq6++IiIiQibR0TODAFy7dg0/Pz9OnDjBnDlzMBqN3HPPPbzzzjsMHDiQ6upq6urqdG26wj/Q3NzMU089xfDhw3n55ZeZNGkSoaGhxMfHk52dzaVLl3S1MbFwMzMzOXz4MDNmzKC4uJiHHnqIiRMnkpOTw6uvvqqbGhb+YH5R71QcT7/99ltuu+02xo8fz4oVK/j111/x8vKyoqHaD3Hyyc3N5bfffmP+/PmcPXuWKVOm8OGHH9KhQwfi4uJkrhG9sYg26urqcHBwkFXvKysr2bNnD/feey9z587F39/fyqSjtgF/aDLZ2dl4eXmxYsUKevTogZeXF0uWLOG+++6Tme+0zK46xbKyslixYgUlJSW8++67VFdXU1VVRVlZGRs3bpSmA71+NDe3pNsVxT5EycMnnniC4uJizGYzI0aMoHfv3rpzI0xjjo6OVFdXc+DAAaKjo3n00Ufx8fGhoaGBe+65h9zcXMLDw2XeGr3FK7TPDRs2UF5ezsMPP8zdd9+NnZ0de/fu5cYbb8RkMsl8R1q7rtlsxs/Pjz59+jBp0iT279/P3XffLTemu+66SyoObZ08mpqayMrK4tVXX8XX15ePP/4Ys9lM//796datG9nZ2bKwtN68CJOWSBxWXFxMYmIio0ePpkePHnz88cd88MEHNDY2ynKDer4PcTJNTExk6dKl5OTk8Nxzz+Hh4cHChQtZuXKlzBmj8pSgh9jwGxsbSUxMxGKxMG3aNHJzc7n33nspKCjAaDRSVlamOxZBD1EneevWrVy+fJm1a9dy4cIFpk6dys6dO/Hz8+PKlSu69SQEj9bV1XH58mUKCgqYOXMmycnJXLp0iV69ekkaq3mE/lv8LReUHB0dcXFx4dFHH+W+++4jPz8fs9nM7t27Wbp0KT4+PlapXfVsVE1NTZw5c4a7776bwsJC6urqOHr0KE8++SQTJ04kKSkJX19fmdpXhbAH19TUcPXqVRYvXszRo0cpKipi+/bt7N69mxdeeIFLly4RHBzc6jil9sNoNFJaWsqhQ4fo27cvFy5c4NKlS3z99dds3LiRhQsX0rFjxza15crKStLT03nllVfYunUrly5dIiIigg4dOrBx40aWLl3KoEGDdPNlq159Ozs7IiIi+Prrr/Hy8qJjx44cOXIEZ2dn7rnnHgwGg0wzq0LQxt3dnebmZvr27UtUVBQDBw6UGut9991H//79pQao52+wWFoKFiclJTFp0iQ6deqEh4cHsbGx5ObmsmXLFiZPnmxVCUr7faHVicRr586dw9vbm5tvvpkFCxZw+vRpmVNeLH7thi3asbOz4+GHH8ZkMhEcHExKSgqzZs3illtuITk5WTrZ9ehhNLaUbszIyODtt9+md+/eODk54enpSUNDA3fddRdjxoyRi1xPmEGLM72srIwRI0bg5+eHq6srP/74IxMnTmTgwIEcPHiQrl27Wjn6tXMLLY45g8HAqFGjOHDgAGfPnuWll16ic+fO9O/fH29v71baoWqmO3jwIOHh4SQmJnLs2DHatWuHl5cXv/32G9999x1paWlWc6BFU1MT3t7erF69msrKSo4ePYqrqyuJiYnEx8fz9ddfExgYaPVeAbF+nZycuHjxIjNmzMDLy4sxY8aQnZ1NWFgY+/fvJz8/H19fX90yfWJO6uvrcXR0xNfXl6lTpzJgwAD8/Pzo0aMHaWlp3HHHHfTv31+Xz0VfGhsbMZvNODk5sXTpUqKjo9m9ezdnzpxhyJAhVFVVyVS5bVkL6urq8Pf3Z926dTKLa0REBLGxsbz55pvExsbSrVu3Vu9Xx2OxtFQrmz9/PjfffDM7duzghhtu4P333ycxMZG4uDh69OjxvzLDwF9sY1dtsZ6ennh4eBAWFsZLL73EhQsXKC0txd3dHbPZzNChQ6UQ0WM4Ly8vSktLZY3UdevWcfbsWZKSkoiNjWXcuHH4+fn96Y5nZ2dHdXU1P/74I7t376ayspLly5fzyCOP8PTTT1NcXIyfn58uYUWfnJ2dqaqq4uTJkzz11FN06NCBM2fO8OSTT1JaWkrnzp2luUVPq/Pw8GDIkCHMmDGD7OxspkyZwj//+U/pGBNVb4KDg3XHYDAYcHV1pbm5GR8fH2JjY1m+fDkzZsygurqacePGsXbtWmJiYnSdsGqEgLe3N/PmzeP8+fPs27ePzMxMnn/+eR5//HFiY2Ol+UOvD9CyYbdr1461a9fKCjevvPIKkydPJi0tjaysLJnmVuvUFvPk5ubG0aNHOXnyJE8++aQsir1mzRoslpZMeCJlblsmJXt7e3Jychg6dKh0pO/YsYP4+HjWrl3LggULaN++vVVkjHbTNhqNxMbGkpGRIWu33njjjaSkpODv78+kSZPkBqJHDzGWvLw8CgsLGT9+PO+99x5PP/0006dP57333pM2WJEyV6vZNTc3U1tbS0xMDNeuXeOTTz5h8eLFnDlzhieeeIJ58+axe/duaYfXOjpF//z9/dm2bRsREREcOHCAmTNn4uLiwuHDhzl58iQhISGt3q+OxWAwcPHiRRoaGpg5cyalpaX0798fV1dXKisr+fzzz3F2drayQevxV11dHU8++SSDBw/G0dGRdevW8a9//Ys9e/Zw6dIl7r77bnli0tvo7OzsOHfuHO7u7mRnZ7Njxw769OnDhg0b2Lp1K8ePH6e0tFTmqlchaNPU1ER9fT3x8fHEx8czY8YMjMaW9Lre3t4cOHCAhx9+2MoZreUNFxcXysrK2LNnD7m5uTzwwAMcO3aMoKAg8vPzefHFF+nTp49VoXl1HEZjS03g/Px8fvjhB8LDwzl8+DDff/89zs7ObN68mSFDhuDn52eVxvi/wV+usQtCJSUl8cgjj7BlyxbWrVuHv78/K1euxNPTE2dnZ1nX8s+OId27d2f79u107dqV22+/nenTp7Nr1y7y8/MJDw+X9k0tUcRiFkUuZsyYwZo1a1i5ciXh4eFUVFQwaNAgkpKSZBk2PSEiGMVisXDy5EkmTZrE9u3bCQsL45133mHGjBlW1cr1hIfJZKKhoYFz586RnJxMRESELF8mHLeiLqUWol8iheyGDRtk+uCysjJOnz5NaWkpXl5emEymVuGVog1o2eQuXLjA2LFjZSm+nj17cuXKFQoLC8nPz8fDw0O3JqX4WdQADQ8PJzY2lsbGRrp3705SUhIPP/wwb7zxhhy7VpiKnx0dHenSpQs+Pj6kpaWxZMkSamtrOX78OPfccw8AxcXFukdlobE3NjbKVLnDhg0jIiKC1NRU8vPz+fHHH8nKypJ91nPMi9ONl5cXXbp0Yfjw4Tz11FP885//ZMKECUybNo2UlBSrQgp6NnaTyUT37t2JjY1l/PjxhIeHs27dOuLi4tizZw/u7u5WETra04eYq0OHDrFp0ybKy8u5cOECqampzJ07l3PnzvHrr7/i7+/fKhZeNWeYTCaKioqYPXs2KSkpJCQkcP78eZydnfH09NSNuFLbcnNzo3///gwaNAhHR0d27tzJPffcQ0pKCpcvXyYzM1OagvTMF0Jjj4yM5KWXXiIhIYG0tDSCg4N55ZVXmDt3LiNHjrQSpFpaALi4uNC/f38aGxuJjIwkICCAnTt3sn79ejZt2kRiYqJcK1o+F7RwdnYmLy+PO++8k7lz5/LMM89IH5KDgwOvvvpqq/4LqOsnJCSEBx98kIaGBiZMmMBdd93Ftm3bmDx5Mp6enlRVVUmtX+902tzcTEhICKtWrcJgMHD27FkiIiLYuHEjmZmZREdHS7PU/0Zj/9suKIWGhnL16lXKy8sxm8189NFH7Nq1izvvvFN66AXasnOFhYXx8ssv8+6773LLLbcwatQoysvLSU1NZcyYMTJfst6RXRzvvL29qays5O677yY0NJT6+npuvvlmtmzZgq+vL56enq0cp2obdnZ2dOzYkY4dO+Li4kLv3r1ZvXo177//Pt7e3uzbt0/Go2u/39zcLCtFzZ8/n6amJqZPn84DDzwgzULXrl2Tmra2DTEuo7GlUHC3bt149NFHcXBwYPny5QwePJhjx47JnOx6piCBpqYmbrnlFqKjo/nxxx95//33efzxx5k+fTolJSV4eXlJDbAt27aTkxMuLi64ubkxZ84ctm/fzqhRo1i9ejV5eXkUFBRIk01btkchsB999FHKysrYsWMHq1atYsGCBTzxxBP4+PhYCSM9Z5/RaKRPnz6YTCY++OADMjIycHNzo6ysjIKCAqZPn05xcbFu4WVVg8/Ozmb//v288cYbfPPNN3z55Zekp6fzxRdfEBISQllZme68iDadnZ3x9/fnypUrrF27FqPRyIQJE1ixYoWMjnFzc2szlFVo/SEhIcyfP5/Kykri4+NZuHChFATCGa1XrUfQIyIign79+vHhhx/y6aefMmzYMDp37szChQuprKyUef/1/Dji59TUVGpra9m5cyenTp3C2dmZgoICTp06Jf1hKl+rfRD/i/j31atXExYWRnh4OHfeeSczZszg1KlTUpnT0kKdl6amJtq1a0fv3r05ffo006ZN4/Tp03z33Xf4+vrK+q1a5UPQWJhmH3jgAaZOnUpZWRmHDh1i9OjRrF+/ntzcXCk32lLoxL2Gr7/+mrfeeovevXtz8eJFZs2aRVpaGs8884w0W2rHIuZEmIt69+7NkSNHGDRoEI8++ii5ubn8+uuvFBUVyZq0Wpr+J/jbKiiJIPyioiIuXbrEBx98ICvjLF++XEbFaCuQNCvVaUwmE/n5+Vy9epWQkBDc3d259957GTRoEFOnTiUsLEwS+PevGwAsyqDr6+upqKiguroab29vFi5cyPDhw/n888/59NNPMZlMsv6g2g/RjLAJlpaW4unpSV5eHuvWreOf//ynrOEYFBQkx/a7RmMQ4xDHVKPRyMWLFwkLC2PixIkMGTKEp556SpbnEzbw3xlDjkMMxWQyUVNTQ3FxsQzXnD17NqtWraKiokIm8Vc2qVa0EJdFXF1dOXz4MN9++y0xMTFkZ2fz5ptv4ubmhr29vdU4VFoImM1m7OzsyMnJ4e2336a2tpZevXoxbNgw4uLidIt1qG2YzWaKi4vJycnBw8OD7du3k5WVxbBhwxg7dmwrpjLq5NwGKCgowN3dncbGRn744QeKi4spKCggPj7eqsC42g/RCbGQamtryczMpKKignPnznH//fdTUVGBk5MT3t7e0meg5Y3f25Lhho2NjTg7O7Nz505WrlzJkCFDGD9+PJ07d5ZVpdQ2LJY/8gCJQhSnTp3CYDCwevVqVq1axYABA1i7di29evXSlpE0iD6Izb+6upq0tDTCw8OZNm0aN910Ez4+PkyYMEEWh1BOCVZzIiK6RLnGLl26MHLkSHx9fXnooYcIDQ0lPDxcblIqfzX/no8dkOGJwcHBNDc3s3jxYhITEykuLmbFihV06NBB8pd2TlQTk9ls5uzZs7LAzRtvvMHw4cMZM2YM0dHRODo6tpIbYl7FJpiXl0dZWRnl5eVs3ryZc+fOERQUxL/+9S/MZrNVmKG2DTGvDg4OJCQkYDAYePvtt1m3bh0ffvghr7/+utxgxPNtya+8vDzq6upwd3eXBbXHjBlDUFAQISEhcq2o8us/wV9uihG2KzFwNzc3goKCaN++PZs3b2bYsGE4OjpSU1OjW0NRvTTh5OREUFAQPXv2JCgoiMcff5yffvqJsrIyPDw8sLOzsxJEKsTPQquKjIzEy8tLMt6yZctITEwEWh/rBMSubmdnJ+35QUFB3HLLLezdu5eff/6Zjh076u642nh4o9FIREQEBw8exM3NjdzcXDZt2iSjTMTi0o5B9EGMIyoqCoPBwPPPP09xcTGpqan4+vpSWVkpN6G2aCE0RBEOJir1TJ48mbKyMqqrq62eVb8v+iIEidlsxtPTE0dHR9asWcOMGTMwGAyyqpGeCUTAzs6OwMBAevToQX5+PhEREeTk5BAdHa171BdQT2bNzc34+/vLSz1jx46lZ8+e3HvvvVRWVlqZYvQ0KnE6cXd3Jzw8nPDwcFl6cMOGDVRXV2NnZ9eqiLQYi2jf3t4eDw8PnJ2dSU9Pp7KyksceewxXV1c6d+6Mu7u75E/tvAgN1cnJCZPJRL9+/eRYunTpwsSJE4mOjpbmMbUN9aKOwWDAw8ODXr16cfr0abZs2SLjpktLS+XlNb1Tpcr7oaGhxMTEkJaWRpcuXTh79qwspC3KP7Z1mhMVtAICAqirq6OpqYnnnnuOffv2sXTpUhoaGqQ5R3xPnRP1VGNvb0+3bt3o0KEDaWlpbNiwgccee4x27dpZnVz0xiP+3qFDByIjI2lubuaWW27hvvvuY86cOVy+fFlWYdKORzUTiY00OjqayMhIZs2axZIlSxg7diypqakypFvbD3XdOzk5ERERQceOHSkpKcHR0ZHAwEBZcUzPqf6f4i83xahx5eKzk5MTwcHBrF+/nqqqKlmPUhRO1i5edVE6OTlhZ2dHeno6ixYt4siRIzz77LOyPJ642adn3xawt7envLycd999l9tuuw0fHx+Sk5OJiYmRoWh6JxttOw4ODuzdu5ddu3YRExNDUFAQ6enpVmW/VKimg+bmZlxdXXFwcODixYt06tSJkSNH0q5dO706joB1qgTxv9Fo5Oeff6Zr167079+fxMREGabY1jFXtCM2wvr6elmHMSEhAT8/PymcxHj1nFPif8HUV69eJS4ujhkzZrBp0ya6d+8unUFtXf5Q6eLg4EBhYSGHDx/Gy8uLsLAwLl++bLVg9IS8mG87OzsZbXXkyBG++uorMjMzKSsrw97eXp4atXOq8pfQzmpra+nfvz/Tpk1j1qxZ0o6v5S29uRXPnDp1ivLycoYOHYqfnx95eXkyvFN710LQUggiQVMhTN58800cHR1JS0vD2dnZyjEu3q+dk/r6emnvP3XqFKGhoTg6OkrhrDcGsUYF75hMJqKioujVqxdxcXEEBARIR+Gf2YKFkiZ4bdeuXdx6663MnDmThoYG6b9pSwnT+g7MZjPHjh2joaGB5557jqCgIJlKRDynZ6dXhXNjYyNZWVn8+OOPuLq60r17d3nKF3JGb92L9WqxWHB1deXo0aOEhobi5+fH4cOHcXd3l5uZtg2tH6GpqQlnZ2fCw8PZtm0bP/zwAxaLhfDwcFk29H+Dv815Kj6Xl5dz8uRJXnzxRW666SYGDhwo60PqTbRgWJU4GRkZVFVVsW/fPqKjo9m2bRuVlZVWDkO1DW2kTWNjIx4eHvTt25dr166xevVqunTpIu2PIqStLU1XmJbq6+uprKzk/vvvlxuW8GxrhYh6tDQYDPJqcefOnfnqq69wc3Ojrq6OwMBA+Vnd1KB18qi6ujpKSkoICwvDw8MDe3t7HnnkESu6a+2GqjAUtHB2dqa8vByLxUJERASVlZWyPVWr0tJCMLGdnR1Xr16VsdIvv/yydGqpgrMtM6DB0OJ4zMrKoqamhpqaGnr16oWbmxvBwcFWJ7m27LlivtLT0+nduzerVq1i6dKldO3alYiIiDZPL4JGgm+EwPz+++9pbm5myZIluLi4yHq4emGo2j6IOPOKigqmTp2Kp6cnzc3NuLi4yNu6Wv5S6Sk+5+XlcezYMRISEpg8eTJ9+vQhNjZWCjqVp7WnAOGkP3HiBIsXL5YhuoK+4p3aPqgbRENDA8XFxXz33XckJCSwadMmampqJF+KyzR6NBVCvaGhgYKCAsaPH8/gwYOlGaKkpETSs615EWMzm80UFhbSt29fUlNTmTNnDomJiQQFBUlt+9/BZDLh5uaGj48PCxcuBODs2bNUVVXJkMg/O6kL+XTt2jXatWvHunXruPnmm/H29pa+F2HV7tEuAAAGhklEQVRC0VPG1D6mp6fj5OTEP/7xD4YOHcqePXu4cOGClXWirbXSFv62QhsGQ0s+kODgYCZMmMCyZctobGwkODhYVlVvK1RRMJIoZB0aGsq2bduYNGkSvr6+3HrrrdLco2fOUX9ubGykurqaX375hcDAQJ555hm6detGaWkpeXl5ADLsUiuYxc/CTHL69GnOnTtHaWkpP//8Mx4eHgQGBsq4We27RRvCBtrY2Mhvv/1G9+7dGTt2LJcuXaK4uNhKKOtpmILJLJaW2O/w36NSBg0aRFZWFllZWTIXjqC9Hj3EokpJSSEpKYn33nuPiIgIAgICuHz5sjwGa01LqgCwWCwyodFrr71GREQEYWFhREZGcunSJVxcXHQ1IdXEI3wOdXV19O7dm+XLlzNr1iwOHjyIs7OzlRlHexJTF015eTldunTh119/5Y477iA3N5euXbuSn59vtWj0+iHaMBqNJCcn4+/vT05ODhcuXCAhIcHq5KmFdrMUeWG6devG8uXL2bx5M48//rgUZHrarrq5iP6cPHmS2267DYOhJcR16NCh8tapWgBeOxahyVZUVMiwPHFpSWzYWrOLOg71vkRDQ4O8nbllyxYKCgqoq6vD2dlZXqbSaqjqZ3Hzc9u2bTz88MPMmTOH5uZmvLy8MJvNuhFC2hN7fX09ERER/Pjjj3Tp0oWOHTvi7u5OcXGx1fxpx6Ku1+rqapmGpKSkhF69ehEeHi6d/yIEta3Tg5Ab5eXlfPrpp4wdO5aSkhJ69OhB+/btZa6Ytk4xqrmvrq5Ohl536tSJBx54gPDwcGm+0tss/x3+UueppQVSQ62oqODMmTMcP36cYcOGERwcTHZ2NoMHD7ayRanOGBTHlMFgoLi4mPPnz9OjRw8yMjLo1KmTrF4unDRK1XErp5B65Dp//jxFRUUMGjRI3pgUVdyFGUN1YDQrRXpFxrzKykoSEhIYPnw4RUVF8uKIh4eHFaMZDNZV5OEPZlu1ahXdunVj9OjRHDhwgFtvvVXSQvgLtOMA5Cbn4eFBXl4eGRkZdOjQgYqKCqKiouQC/v39VuNQ7aDV1dW4u7tz/PhxebmnoaHB6rKEIgis+iF+LC0tpaKigg4dOpCTk0NRUREDBgyQG5DqqBP9EAMRc2IwGMjJySEoKIiKigpppsrJySE4ONjqVp7WASvoKk4PmzdvJi4uTt5+jI6OttLGtc5ksZDETcfz589jNpvx8vKie/fupKamEhISIgWZjnNL9kM4knfv3s3Vq1eJiYmhsbGRAQMGUFRUJH0wWpqqTjbL7ybFhIQEXFxciIyMJDMzk5CQEGnCs7e3V80d0nkq6FlZWcmlS5fw9/cnJiaG06dPExkZicFgwNfXV+vzaMXjzc3N0mkscpwMHDgQf39/ioqK8Pf3R/RX6/hU56O+vh6TycQ333zDxIkTuXz5Mr169ZLz4OLiop6ErZynwhxlMpk4c+YMjo6OREVFyYtgXbp0wc7OTs6LOhbBX2Jzqqmp4fTp0zKdQkREBHV1dZhMJvz8/KRA/X1MreSGGrxx4sQJXF1d6dSpE05OTjg7O9OuXTutpt6qHyaTSSqfGzZs4Pbbb5cx+kIpVO8HKPz1b/GXR8XIDzpHPq25RH1OZXj1aKfu7qrd3uqlf0xGq+gJVRBov6/dcdWFZ1E6q5pUlP62GrzStlVUjBiL+m7xWU97UQWqZsNoZcNrYwxWbWjnQP2u6Jf6N+Vzm/Rsqz1VUGj7oUc79XcqTTTPWdFDpaGWxuL32t9p2xBQzXZ/Nrdaoaxq7ap/Re2/ysPKz62Eqvb92nWiw7tWFbr0zFV6P6vf/2NYredP+z2VV7S0UDdsPb5UTwU6bbcShur4/2zdade82GDUvqj90PCClqa6PKo+o4V2rHptiL6oa0w7Lr2x/Cf4qwW7DTbYYIMN/8f422zsNthggw02/N/AJthtsMEGG64z2AS7DTbYYMN1Bptgt8EGG2y4zmAT7DbYYIMN1xlsgt0GG2yw4TqDTbDbYIMNNlxnsAl2G2ywwYbrDDbBboMNNthwncEm2G2wwQYbrjPYBLsNNthgw3UGm2C3wQYbbLjOYBPsNthggw3XGWyC3QYbbLDhOoNNsNtggw02XGewCXYbbLDBhusMNsFugw022HCdwSbYbbDBBhuuM9gEuw022GDDdQabYLfBBhtsuM5gE+w22GCDDdcZbILdBhtssOE6g02w22CDDTZcZ/h/QO6HTFKAHYgAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "#def P10(num_examples):\n", + "def P10(num_examples):\n", "\n", "### STUDENT START ###\n", + " # Training the NB Model and testing for accuracy\n", + " \n", + " # Create the model\n", + " BNbModel = BernoulliNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " BNbModel.fit(mini_train_data, mini_train_labels)\n", + " BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = BNbModel.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = BNbModel.score(dev_data, dev_labels)\n", "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " \n", + " # Reasonable accuracy, moving on to generating\n", + " \n", + " # Finding out the probability estimates for each class (digit)\n", + " print()\n", + " print(\"The shape of the probability estimates/class array\")\n", + " print(BNbModel.feature_log_prob_.shape)\n", + " print()\n", + " \n", + " # We have a 10 (digits) * 784 matrix that's the probability of each pixel\n", + " # print(np.exp(BNbModel.feature_log_prob_ ))\n", + " \n", + " # Making a 10*num_examples array. Each example is a 28*28 array\n", + " print(\"The generated digits\")\n", + " print()\n", + " digArray = np.empty((10,20,28,28))\n", + " count = 0\n", + " for i in range(len(digArray)):\n", + " for j in range(len(digArray[i])):\n", + " \n", + " # generating just random values corresponding to a digit\n", + " digArray[i][j] = np.random.rand(28,28)\n", + " \n", + " # Now we get the feature probability matrix corresponding to this digit\n", + " # The product of the random array and feature probability is the digit\n", + " digArray[i][j] = digArray[i][j] * (np.exp(BNbModel.feature_log_prob_ ))[i].reshape(28,28)\n", + " \n", + " # Plotting the digit\n", + " count = count + 1\n", + " plt.subplot(10, num_examples, count)\n", + " plt.axis(\"off\")\n", + " plt.imshow(digArray[i][j], aspect = \"auto\", cmap = plt.cm.gray_r, interpolation = \"nearest\")\n", + " \n", + " # TODO Not urgent, but got to figure out how to make bigger matrix plots\n", "\n", "### STUDENT END ###\n", "\n", - "#P10(20)" + "P10(20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: The generated images can be recognized as such(digigs) but are blurry, especially at the edges. It the same kind of impact you get by blurring." ] }, { @@ -459,37 +1275,97 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Mean Square Error on the dev data set is 3.027\n", + "The accuracy is 81.5 %\n", + "\n", + "The shape of probability array for dev_data\n", + "(1000, 10)\n", + "\n", + "The probability accuracy matrix\n", + "p(pred) <= 0.9000000000000 total = 28 accuracy = 0.536\n", + "p(pred) <= 0.9990000000000 total = 70 accuracy = 0.429\n", + "p(pred) <= 0.9999900000000 total = 59 accuracy = 0.508\n", + "p(pred) <= 0.9999999000000 total = 63 accuracy = 0.571\n", + "p(pred) <= 0.9999999990000 total = 57 accuracy = 0.632\n", + "p(pred) <= 0.9999999999900 total = 66 accuracy = 0.712\n", + "p(pred) <= 0.9999999999999 total = 56 accuracy = 0.857\n", + "p(pred) <= 1.0000000000000 total = 601 accuracy = 0.953\n" + ] + } + ], "source": [ - "#def P11(buckets, correct, total):\n", + "def P11(buckets, correct, total):\n", " \n", "### STUDENT START ###\n", "\n", + " # Training a bernaulliNB model\n", + " # Create the model\n", + " BNbModel = BernoulliNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " BNbModel.fit(mini_train_data, mini_train_labels)\n", + " BernoulliNB(alpha=1.0, binarize=0.0, class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = BNbModel.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = BNbModel.score(dev_data, dev_labels)\n", "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set is \", meanse)\n", + " print(\"The accuracy is\", (sc*100), \"%\")\n", + " \n", + " # Finding the probabilties for a class for each of the dev_data\n", + " prob = BNbModel.predict_proba(dev_data)\n", + " print()\n", + " print(\"The shape of probability array for dev_data\")\n", + " print(prob.shape)\n", + " print()\n", + "\n", + " for i in range(len(predictions)):\n", + " for j in range(len(buckets)):\n", + " if (buckets[j-1] < np.max(prob[i]) <= buckets[j]):\n", + " total[j] = total[j] + 1\n", + " if predictions[i] == dev_labels[i]:\n", + " correct[j] = correct[j] + 1\n", " \n", "### STUDENT END ###\n", "\n", - "#buckets = [0.5, 0.9, 0.999, 0.99999, 0.9999999, 0.999999999, 0.99999999999, 0.9999999999999, 1.0]\n", - "#correct = [0 for i in buckets]\n", - "#total = [0 for i in buckets]\n", + "buckets = [0.5, 0.9, 0.999, 0.99999, 0.9999999, 0.999999999, 0.99999999999, 0.9999999999999, 1.0]\n", + "correct = [0 for i in buckets]\n", + "total = [0 for i in buckets]\n", "\n", - "#P11(buckets, correct, total)\n", + "P11(buckets, correct, total)\n", "\n", - "#for i in range(len(buckets)):\n", - "# accuracy = 0.0\n", - "# if (total[i] > 0): accuracy = correct[i] / total[i]\n", - "# print 'p(pred) <= %.13f total = %3d accuracy = %.3f' %(buckets[i], total[i], accuracy)" + "print(\"The probability accuracy matrix\")\n", + "for i in range(len(buckets)):\n", + " accuracy = 0.0\n", + " if (total[i] > 0): \n", + " accuracy = correct[i] / total[i]\n", + " print (\"p(pred) <= %.13f total = %3d accuracy = %.3f\" %(buckets[i], total[i], accuracy))\n", + " " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "ANSWER:" + "ANSWER: Above analysis of BernaulliNB shows the following:\n", + "\n", + "1. At prediction probability of .9 the classifier is ~50% accurate\n", + "2. Except in the lowest 3 buckets, the accuracy is increasing with prediction probability\n", + "3. The accuracy is ~95% when the digit is almost an exact match\n", + "\n", + "In the current form, our classifier is weakly calibrated. There is definately a positive correlation among probability and accuracy so we cannot conclude that the classifier is poorly calibrated" ] }, { @@ -507,42 +1383,162 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": false - }, - "outputs": [], + "execution_count": 209, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Mean Square Error on the dev data set of the base model is 3.027\n", + "The accuracy of base model is 81.5 %\n", + "\n", + "The Mean Square Error on the dev data set of the base model with full training set is 2.717\n", + "The accuracy of base model with full training set is 82.6 %\n", + "\n", + "The Mean Square Error on the dev data set with a Multinomial model is 2.719\n", + "The accuracy with multinomial model is 82.6 %\n", + "\n", + "The Mean Square Error on the dev data set with a Multinomial model that accentuates information is 2.683\n", + "The accuracy with multinomial model that accentuates information is 82.7 %\n", + "\n" + ] + } + ], "source": [ - "#def P12():\n", + "def P12():\n", "\n", "### STUDENT START ###\n", "\n", + "# Training a BernoulliNB model\n", + "\n", + " # Create the model\n", + " BNbModel = BernoulliNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " BNbModel.fit(mini_train_data, mini_train_labels)\n", + " BernoulliNB(alpha=.0001, binarize=0.0, class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = BNbModel.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = BNbModel.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set of the base model is \", meanse)\n", + " print(\"The accuracy of base model is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " #########################################################\n", + " \n", + " # Does the accuracy increase by training with more data #\n", + " \n", + " # Fitting the model on the mini training set\n", + " BNbModel.fit(train_data, train_labels)\n", + " BernoulliNB(alpha=.0001, binarize=0.0, class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = BNbModel.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = BNbModel.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set of the base model with full training set is \", meanse)\n", + " print(\"The accuracy of base model with full training set is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " #########################################################\n", + " \n", + " # Trying the multinomial model #\n", + " \n", + " # Create the model\n", + " MNbModel1 = MultinomialNB()\n", + " \n", + " # Fitting the model on the mini training set\n", + " MNbModel1.fit(train_data, train_labels)\n", + " MultinomialNB(alpha=.0001,class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = MNbModel1.predict(dev_data)\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = MNbModel1.score(dev_data, dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set with a Multinomial model is \", meanse)\n", + " print(\"The accuracy with multinomial model is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " #########################################################\n", + " \n", + " # Lets try to accentuate the features of the digit #\n", + " # We'll highlight everything that has a little more information than 0#\n", + " \n", + " # Creating a new training set with middle of the image highlighted\n", + " def tHighlight(data):\n", + " hTrain = np.copy(data)\n", + " hTrain[hTrain > .001] = hTrain[hTrain > .001] * 255\n", + " return hTrain\n", + " \n", + " \n", + " # Fitting the model on the mini training set\n", + " MNbModel1.fit(tHighlight(train_data), train_labels)\n", + " MultinomialNB(alpha=.0001,class_prior=None, fit_prior=True)\n", + " \n", + " # Predictions on Dev data\n", + " predictions = MNbModel1.predict(tHighlight(dev_data))\n", + " \n", + " # Mean Squared error and accuracy\n", + " meanse = (((predictions - dev_labels) ** 2).sum()) / len(predictions)\n", + " sc = MNbModel1.score(tHighlight(dev_data), dev_labels)\n", + "\n", + " # Print the MSE and accuracy\n", + " print(\"The Mean Square Error on the dev data set with a Multinomial model that accentuates information is \", meanse)\n", + " print(\"The accuracy with multinomial model that accentuates information is\", (sc*100), \"%\")\n", + " print()\n", + " \n", + " \n", + " #########################################################\n", + " \n", + " \n", "\n", "### STUDENT END ###\n", "\n", - "#P12()" + "P12()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 2", + "display_name": "Python 3", "language": "python", - "name": "python2" + "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", - "version": 2 + "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.6" + "pygments_lexer": "ipython3", + "version": "3.6.4" } }, "nbformat": 4, - "nbformat_minor": 0 + "nbformat_minor": 1 } From 6f03729199ea4b816824ef52f79d747d984cdc3e Mon Sep 17 00:00:00 2001 From: giktech Date: Fri, 9 Feb 2018 23:03:39 -0800 Subject: [PATCH 3/3] Gaurav_Khanna_p1 Project/Homework 1 Digit Classification with KNN and Naive Bayes