diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..662c1b39 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,28 @@ +############################################################## +# to build: +# docker build -f Dockerfile -t coursera . +# to run: +# docker run -it -p 8888:8888 -v /home/ishivvers/codes/ml-coursera-python-assignments/:/workdir/ coursera:latest bash +# from inside container: +# jupyter notebook --ip 0.0.0.0 --no-browser --allow-root +############################################################## +FROM ubuntu:18.04 + +############################################ +# system installs: +RUN apt-get update \ + && apt-get install -y python3 \ + python3-pip + + +############################################ +# make python3 the default +RUN ln -sf /usr/bin/python3 /usr/local/bin/python \ + && ln -sf /usr/bin/pip3 /usr/local/bin/pip +# and update pip +RUN pip install -U pip + +COPY requirements.txt requirements.txt +RUN pip install -r requirements.txt + +WORKDIR /workdir diff --git a/Exercise1/exercise1.ipynb b/Exercise1/exercise1.ipynb index 0d245b5c..63cf1bec 100755 --- a/Exercise1/exercise1.ipynb +++ b/Exercise1/exercise1.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -108,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -126,7 +126,7 @@ " Return the 5x5 identity matrix.\n", " \"\"\" \n", " # ======== YOUR CODE HERE ======\n", - " A = [] # modify this line\n", + " A = np.eye(5) # modify this line\n", " \n", " # ==============================\n", " return A" @@ -149,9 +149,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1., 0., 0., 0., 0.],\n", + " [ 0., 1., 0., 0., 0.],\n", + " [ 0., 0., 1., 0., 0.],\n", + " [ 0., 0., 0., 1., 0.],\n", + " [ 0., 0., 0., 0., 1.]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "warmUpExercise()" ] @@ -173,9 +188,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 0 / 40 | \n", + " Gradient Descent (for one variable) | 0 / 50 | \n", + " Feature Normalization | 0 / 0 | \n", + " Computing Cost (for multiple variables) | 0 / 0 | \n", + " Gradient Descent (for multiple variables) | 0 / 0 | \n", + " Normal Equations | 0 / 0 | \n", + " --------------------------------\n", + " | 10 / 100 | \n", + "\n" + ] + } + ], "source": [ "# appends the implemented function in part 1 to the grader object\n", "grader[1] = warmUpExercise\n", @@ -199,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -236,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -270,7 +308,9 @@ " fig = pyplot.figure() # open a new figure\n", " \n", " # ====================== YOUR CODE HERE ======================= \n", - " \n", + " pyplot.plot(x, y, 'ro', ms=10, mec='k')\n", + " pyplot.ylabel('Profit in $10,000')\n", + " pyplot.xlabel('Population of City in 10,000s')\n", "\n", " # =============================================================\n" ] @@ -288,9 +328,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)" ] @@ -306,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -352,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -377,10 +428,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ + "def _hypothesis(X, theta):\n", + " return np.sum(X*theta, axis=1)\n", + "\n", "def computeCost(X, y, theta):\n", " \"\"\"\n", " Compute cost for linear regression. Computes the cost of using theta as the\n", @@ -419,7 +473,8 @@ " J = 0\n", " \n", " # ====================== YOUR CODE HERE =====================\n", - "\n", + " y_pred = _hypothesis(X, theta)\n", + " J = (2 * y.size)**-1 * np.sum((y - y_pred)**2)\n", " \n", " # ===========================================================\n", " return J" @@ -434,9 +489,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "With theta = [0, 0] \n", + "Cost computed = 32.07\n", + "Expected cost value (approximately) 32.07\n", + "\n", + "With theta = [-1, 2]\n", + "Cost computed = 54.24\n", + "Expected cost value (approximately) 54.24\n" + ] + } + ], "source": [ "J = computeCost(X, y, theta=np.array([0.0, 0.0]))\n", "print('With theta = [0, 0] \\nCost computed = %.2f' % J)\n", @@ -457,9 +526,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 40 / 40 | Nice work!\n", + " Gradient Descent (for one variable) | 0 / 50 | \n", + " Feature Normalization | 0 / 0 | \n", + " Computing Cost (for multiple variables) | 0 / 0 | \n", + " Gradient Descent (for multiple variables) | 0 / 0 | \n", + " Normal Equations | 0 / 0 | \n", + " --------------------------------\n", + " | 50 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[2] = computeCost\n", "grader.grade()" @@ -494,10 +586,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ + "def _gradient(X, y, theta):\n", + " assert theta.size == X.shape[1]\n", + " y_pred = _hypothesis(X, theta)\n", + " gradient = np.empty(theta.size)\n", + " for i in range(theta.size):\n", + " gradient[i] = np.sum((y_pred - y) * X[:, i])\n", + " return gradient\n", + "\n", "def gradientDescent(X, y, theta, alpha, num_iters):\n", " \"\"\"\n", " Performs gradient descent to learn `theta`. Updates theta by taking `num_iters`\n", @@ -508,7 +608,7 @@ " X : array_like\n", " The input dataset of shape (m x n+1).\n", " \n", - " y : arra_like\n", + " y : array_like\n", " Value at given features. A vector of shape (m, ).\n", " \n", " theta : array_like\n", @@ -547,13 +647,12 @@ " \n", " for i in range(num_iters):\n", " # ==================== YOUR CODE HERE =================================\n", - " \n", - "\n", + " updates = alpha * y.size**-1 * _gradient(X, y, theta)\n", + " theta -= updates\n", " # =====================================================================\n", - " \n", " # save the cost J in every iteration\n", " J_history.append(computeCost(X, y, theta))\n", - " \n", + "\n", " return theta, J_history" ] }, @@ -566,9 +665,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Theta found by gradient descent: -3.6303, 1.1664\n", + "Expected theta values (approximately): [-3.6303, 1.1664]\n" + ] + } + ], "source": [ "# initialize fitting parameters\n", "theta = np.zeros(2)\n", @@ -593,9 +701,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# plot the linear fit\n", "plotData(X[:, 1], y)\n", @@ -603,6 +722,37 @@ "pyplot.legend(['Training data', 'Linear regression']);" ] }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.figure()\n", + "pyplot.semilogy(J_history)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -614,15 +764,26 @@ "\n", "\n", "
\n", - "Note that the first argument to the `numpy` function `dot` is a python list. `numpy` can internally converts **valid** python lists to numpy arrays when explicitly provided as arguments to `numpy` functions.\n", + "Note that the first argument to the `numpy` function `dot` is a python list. `numpy` can internally convert **valid** python lists to numpy arrays when explicitly provided as arguments to `numpy` functions.\n", "
\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For population = 35,000, we predict a profit of 4519.77\n", + "\n", + "For population = 70,000, we predict a profit of 45342.45\n", + "\n" + ] + } + ], "source": [ "# Predict values for population sizes of 35,000 and 70,000\n", "predict1 = np.dot([1, 3.5], theta)\n", @@ -641,9 +802,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 40 / 40 | Nice work!\n", + " Gradient Descent (for one variable) | 50 / 50 | Nice work!\n", + " Feature Normalization | 0 / 0 | \n", + " Computing Cost (for multiple variables) | 0 / 0 | \n", + " Gradient Descent (for multiple variables) | 0 / 0 | \n", + " Normal Equations | 0 / 0 | \n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[3] = gradientDescent\n", "grader.grade()" @@ -666,9 +850,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# grid over which we will calculate J\n", "theta0_vals = np.linspace(-10, 10, 100)\n", @@ -730,9 +925,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " X[:,0] X[:, 1] y\n", + "--------------------------\n", + " 2104 3 399900\n", + " 1600 3 329900\n", + " 2400 3 369000\n", + " 1416 2 232000\n", + " 3000 4 539900\n", + " 1985 4 299900\n", + " 1534 3 314900\n", + " 1427 3 198999\n", + " 1380 3 212000\n", + " 1494 3 242500\n" + ] + } + ], "source": [ "# Load data\n", "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n", @@ -773,7 +987,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -793,6 +1007,8 @@ " -------\n", " X_norm : array_like\n", " The normalized dataset of shape (m x n).\n", + " mu, sigma: float\n", + " The mean and standard deviation of X\n", " \n", " Instructions\n", " ------------\n", @@ -803,20 +1019,16 @@ " in sigma. \n", " \n", " Note that X is a matrix where each column is a feature and each row is\n", - " an example. You needto perform the normalization separately for each feature. \n", + " an example. You need to perform the normalization separately for each feature. \n", " \n", " Hint\n", " ----\n", " You might find the 'np.mean' and 'np.std' functions useful.\n", " \"\"\"\n", - " # You need to set these values correctly\n", - " X_norm = X.copy()\n", - " mu = np.zeros(X.shape[1])\n", - " sigma = np.zeros(X.shape[1])\n", - "\n", " # =========================== YOUR CODE HERE =====================\n", - "\n", - " \n", + " mu = np.mean(X, axis=0)\n", + " sigma = np.std(X, axis=0)\n", + " X_norm = (X.copy() - mu) / sigma\n", " # ================================================================\n", " return X_norm, mu, sigma" ] @@ -830,9 +1042,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computed mean: [ 2000.68085106 3.17021277]\n", + "Computed standard deviation: [ 7.86202619e+02 7.52842809e-01]\n" + ] + } + ], "source": [ "# call featureNormalize on the loaded data\n", "X_norm, mu, sigma = featureNormalize(X)\n", @@ -850,9 +1071,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 40 / 40 | Nice work!\n", + " Gradient Descent (for one variable) | 50 / 50 | Nice work!\n", + " Feature Normalization | 0 / 0 | Nice work!\n", + " Computing Cost (for multiple variables) | 0 / 0 | \n", + " Gradient Descent (for multiple variables) | 0 / 0 | \n", + " Normal Equations | 0 / 0 | \n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[4] = featureNormalize\n", "grader.grade()" @@ -867,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -912,7 +1156,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -941,17 +1185,7 @@ " ------------\n", " Compute the cost of a particular choice of theta. You should set J to the cost.\n", " \"\"\"\n", - " # Initialize some useful values\n", - " m = y.shape[0] # number of training examples\n", - " \n", - " # You need to return the following variable correctly\n", - " J = 0\n", - " \n", - " # ======================= YOUR CODE HERE ===========================\n", - "\n", - " \n", - " # ==================================================================\n", - " return J\n" + " return computeCost(X, y, theta=theta)\n" ] }, { @@ -963,9 +1197,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 40 / 40 | Nice work!\n", + " Gradient Descent (for one variable) | 50 / 50 | Nice work!\n", + " Feature Normalization | 0 / 0 | Nice work!\n", + " Computing Cost (for multiple variables) | 0 / 0 | Nice work!\n", + " Gradient Descent (for multiple variables) | 0 / 0 | \n", + " Normal Equations | 0 / 0 | \n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[5] = computeCostMulti\n", "grader.grade()" @@ -980,7 +1237,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -1021,24 +1278,7 @@ " While debugging, it can be useful to print out the values of \n", " the cost function (computeCost) and gradient here.\n", " \"\"\"\n", - " # Initialize some useful values\n", - " m = y.shape[0] # number of training examples\n", - " \n", - " # make a copy of theta, which will be updated by gradient descent\n", - " theta = theta.copy()\n", - " \n", - " J_history = []\n", - " \n", - " for i in range(num_iters):\n", - " # ======================= YOUR CODE HERE ==========================\n", - "\n", - " \n", - " # =================================================================\n", - " \n", - " # save the cost J in every iteration\n", - " J_history.append(computeCostMulti(X, y, theta))\n", - " \n", - " return theta, J_history" + " return gradientDescent(X, y, theta, alpha, num_iters)" ] }, { @@ -1050,9 +1290,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 40 / 40 | Nice work!\n", + " Gradient Descent (for one variable) | 50 / 50 | Nice work!\n", + " Feature Normalization | 0 / 0 | Nice work!\n", + " Computing Cost (for multiple variables) | 0 / 0 | Nice work!\n", + " Gradient Descent (for multiple variables) | 0 / 0 | Nice work!\n", + " Normal Equations | 0 / 0 | \n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[6] = gradientDescentMulti\n", "grader.grade()" @@ -1094,9 +1357,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta computed from gradient descent: [ 334302.06399328 99411.44947359 3267.01285407]\n", + "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $289222\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "\"\"\"\n", "Instructions\n", @@ -1119,7 +1401,7 @@ "At prediction, make sure you do the same feature normalization.\n", "\"\"\"\n", "# Choose some alpha value - change this\n", - "alpha = 0.1\n", + "alpha = 0.01\n", "num_iters = 400\n", "\n", "# init theta and run gradient descent\n", @@ -1138,8 +1420,10 @@ "# ======================= YOUR CODE HERE ===========================\n", "# Recall that the first column of X is all-ones. \n", "# Thus, it does not need to be normalized.\n", - "\n", - "price = 0 # You should change this\n", + "x = np.array([1650, 3])\n", + "x = (x - mu) / sigma\n", + "x = np.concatenate(([1, ], x))\n", + "price = np.dot(theta.T, x)\n", "\n", "# ===================================================================\n", "\n", @@ -1171,7 +1455,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -1194,7 +1478,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -1224,11 +1508,11 @@ " ----\n", " Look up the function `np.linalg.pinv` for computing matrix inverse.\n", " \"\"\"\n", - " theta = np.zeros(X.shape[1])\n", - " \n", " # ===================== YOUR CODE HERE ============================\n", - "\n", - " \n", + " theta = np.dot(\n", + " np.dot(np.linalg.pinv(np.dot(X.T, X)), X.T),\n", + " y\n", + " )\n", " # =================================================================\n", " return theta" ] @@ -1242,9 +1526,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Warm up exercise | 10 / 10 | Nice work!\n", + " Computing Cost (for one variable) | 40 / 40 | Nice work!\n", + " Gradient Descent (for one variable) | 50 / 50 | Nice work!\n", + " Feature Normalization | 0 / 0 | Nice work!\n", + " Computing Cost (for multiple variables) | 0 / 0 | Nice work!\n", + " Gradient Descent (for multiple variables) | 0 / 0 | Nice work!\n", + " Normal Equations | 0 / 0 | Nice work!\n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[7] = normalEqn\n", "grader.grade()" @@ -1262,9 +1569,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Theta computed from the normal equations: [ 89597.90954355 139.21067402 -8738.01911255]\n", + "Predicted price of a 1650 sq-ft, 3 br house (using normal equations): $293081\n" + ] + } + ], "source": [ "# Calculate the parameters from the normal equation\n", "theta = normalEqn(X, y);\n", @@ -1274,8 +1590,8 @@ "\n", "# Estimate the price of a 1650 sq-ft, 3 br house\n", "# ====================== YOUR CODE HERE ======================\n", - "\n", - "price = 0 # You should change this\n", + "x = np.array([1, 1650, 3])\n", + "price = np.dot(theta.T, x)\n", "\n", "# ============================================================\n", "\n", @@ -1299,7 +1615,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.9" } }, "nbformat": 4, diff --git a/Exercise2/exercise2.ipynb b/Exercise2/exercise2.ipynb index 39983d90..4debb9cf 100755 --- a/Exercise2/exercise2.ipynb +++ b/Exercise2/exercise2.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -151,7 +151,13 @@ " fig = pyplot.figure()\n", "\n", " # ====================== YOUR CODE HERE ======================\n", + " # Find Indices of Positive and Negative Examples\n", + " pos = y == 1\n", + " neg = y == 0\n", "\n", + " # Plot Examples\n", + " pyplot.plot(X[pos, 0], X[pos, 1], 'k*', lw=2, ms=10)\n", + " pyplot.plot(X[neg, 0], X[neg, 1], 'ko', mfc='y', ms=8, mec='k', mew=1)\n", " \n", " # ============================================================" ] @@ -165,9 +171,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)\n", "# add axes labels\n", @@ -202,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -228,14 +245,8 @@ " \"\"\"\n", " # convert input to a numpy array\n", " z = np.array(z)\n", - " \n", - " # You need to return the following variables correctly \n", - " g = np.zeros(z.shape)\n", - "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - " \n", - "\n", + " g = (1.0 + np.exp(-z))**-1\n", " # =============================================================\n", " return g" ] @@ -249,9 +260,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g( 0 ) = 0.5\n" + ] + } + ], "source": [ "# Test the implementation of sigmoid function here\n", "z = 0\n", @@ -260,6 +279,41 @@ "print('g(', z, ') = ', g)" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'Y')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pyplot.figure()\n", + "xray = np.linspace(-10, 10, 1000)\n", + "yray = sigmoid(xray)\n", + "pyplot.plot(xray, yray)\n", + "pyplot.xlabel('X')\n", + "pyplot.ylabel('Y')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -275,9 +329,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Login (email address): ishivvers@gmail.com\n", + "Token: HGkc3clbLHvkgHYA\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 0 / 30 | \n", + " Logistic Regression Gradient | 0 / 30 | \n", + " Predict | 0 / 5 | \n", + " Regularized Logistic Regression Cost | 0 / 15 | \n", + " Regularized Logistic Regression Gradient | 0 / 15 | \n", + " --------------------------------\n", + " | 5 / 100 | \n", + "\n" + ] + } + ], "source": [ "# appends the implemented function in part 1 to the grader object\n", "grader[1] = sigmoid\n", @@ -298,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -328,10 +405,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ + "def _hypothesis(theta, X):\n", + " return sigmoid(np.sum(X*theta, axis=1))\n", + "\n", + "def _J(theta, X, y):\n", + " h = _hypothesis(theta, X)\n", + " vector = (-y * np.log(h)) - ((1 - y) * np.log(1 - h))\n", + " J = (1 / y.size) * np.sum(vector)\n", + " return J\n", + "\n", + "def _dJ(theta, X, y):\n", + " assert theta.size == X.shape[1]\n", + " h = _hypothesis(theta, X)\n", + " gradient = np.empty(theta.size)\n", + " for i in range(theta.size):\n", + " gradient[i] = np.sum((h - y) * X[:, i])\n", + " gradient = (1 / y.size) * gradient\n", + " return gradient\n", + "\n", "def costFunction(theta, X, y):\n", " \"\"\"\n", " Compute cost and gradient for logistic regression. \n", @@ -347,7 +442,7 @@ " of data points and n is the number of features. We assume the \n", " intercept has already been added to the input.\n", " \n", - " y : arra_like\n", + " y : array_like\n", " Labels for the input. This is a vector of shape (m, ).\n", " \n", " Returns\n", @@ -368,14 +463,10 @@ " # Initialize some useful values\n", " m = y.size # number of training examples\n", "\n", - " # You need to return the following variables correctly \n", - " J = 0\n", - " grad = np.zeros(theta.shape)\n", - "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - " \n", - " \n", + " # You need to return the following variables correctly \n", + " J = _J(theta, X, y)\n", + " grad = _dJ(theta, X, y)\n", " # =============================================================\n", " return J, grad" ] @@ -389,9 +480,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at initial theta (zeros): 0.693\n", + "Expected cost (approx): 0.693\n", + "\n", + "Gradient at initial theta (zeros):\n", + "\t[-0.1000, -12.0092, -11.2628]\n", + "Expected gradients (approx):\n", + "\t[-0.1000, -12.0092, -11.2628]\n", + "\n", + "Cost at test theta: 0.218\n", + "Expected cost (approx): 0.218\n", + "\n", + "Gradient at test theta:\n", + "\t[0.043, 2.566, 2.647]\n", + "Expected gradients (approx):\n", + "\t[0.043, 2.566, 2.647]\n" + ] + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(n+1)\n", @@ -426,9 +539,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 30 / 30 | Nice work!\n", + " Logistic Regression Gradient | 30 / 30 | Nice work!\n", + " Predict | 0 / 5 | \n", + " Regularized Logistic Regression Cost | 0 / 15 | \n", + " Regularized Logistic Regression Gradient | 0 / 15 | \n", + " --------------------------------\n", + " | 65 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[2] = costFunction\n", "grader[3] = costFunction\n", @@ -459,9 +594,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at theta found by optimize.minimize: 0.203\n", + "Expected cost (approx): 0.203\n", + "\n", + "theta:\n", + "\t[-25.161, 0.206, 0.201]\n", + "Expected theta (approx):\n", + "\t[-25.161, 0.206, 0.201]\n" + ] + } + ], "source": [ "# set options for optimize.minimize\n", "options= {'maxiter': 400}\n", @@ -508,9 +657,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot Boundary\n", "utils.plotDecisionBoundary(plotData, theta, X, y)" @@ -530,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "metadata": {}, "outputs": [], "source": [ @@ -566,9 +726,8 @@ " p = np.zeros(m)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - " \n", - " \n", + " values = sigmoid(np.sum(theta*X, axis=1))\n", + " p[values > 0.5] = 1 \n", " # ============================================================\n", " return p" ] @@ -582,9 +741,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 78, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For a student with scores 45 and 85,we predict an admission probability of 0.776\n", + "Expected value: 0.775 +/- 0.002\n", + "\n", + "Train Accuracy: 89.00 %\n", + "Expected accuracy (approx): 89.00 %\n" + ] + } + ], "source": [ "# Predict probability for a student with score 45 on exam 1 \n", "# and score 85 on exam 2 \n", @@ -608,9 +779,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 79, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 30 / 30 | Nice work!\n", + " Logistic Regression Gradient | 30 / 30 | Nice work!\n", + " Predict | 5 / 5 | Nice work!\n", + " Regularized Logistic Regression Cost | 0 / 15 | \n", + " Regularized Logistic Regression Gradient | 0 / 15 | \n", + " --------------------------------\n", + " | 70 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[4] = predict\n", "grader.grade()" @@ -630,7 +823,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 80, "metadata": {}, "outputs": [], "source": [ @@ -654,9 +847,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 81, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)\n", "# Labels and Legend\n", @@ -686,7 +890,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ @@ -718,10 +922,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "metadata": {}, "outputs": [], "source": [ + "def _Jreg(theta, X, y, lamb):\n", + " reg = (lamb / (2 * y.size)) * np.sum(theta[1:]**2)\n", + " return _J(theta, X, y) + reg\n", + "\n", + "def _dJreg(theta, X, y, lamb):\n", + " reg = np.zeros_like(theta)\n", + " reg[1:] = (lamb / y.size) * theta[1:]\n", + " return _dJ(theta, X, y) + reg\n", + "\n", "def costFunctionReg(theta, X, y, lambda_):\n", " \"\"\"\n", " Compute cost and gradient for logistic regression with regularization.\n", @@ -762,14 +975,10 @@ " # Initialize some useful values\n", " m = y.size # number of training examples\n", "\n", - " # You need to return the following variables correctly \n", - " J = 0\n", - " grad = np.zeros(theta.shape)\n", - "\n", " # ===================== YOUR CODE HERE ======================\n", - "\n", - " \n", - " \n", + " # You need to return the following variables correctly \n", + " J = _Jreg(theta, X, y, lambda_)\n", + " grad = _dJreg(theta, X, y, lambda_)\n", " # =============================================================\n", " return J, grad" ] @@ -783,9 +992,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 87, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at initial theta (zeros): 0.693\n", + "Expected cost (approx) : 0.693\n", + "\n", + "Gradient at initial theta (zeros) - first five values only:\n", + "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n", + "Expected gradients (approx) - first five values only:\n", + "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n", + "\n", + "------------------------------\n", + "\n", + "Cost at test theta : 3.16\n", + "Expected cost (approx): 3.16\n", + "\n", + "Gradient at initial theta (zeros) - first five values only:\n", + "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n", + "Expected gradients (approx) - first five values only:\n", + "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n" + ] + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(X.shape[1])\n", @@ -832,9 +1065,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 30 / 30 | Nice work!\n", + " Logistic Regression Gradient | 30 / 30 | Nice work!\n", + " Predict | 5 / 5 | Nice work!\n", + " Regularized Logistic Regression Cost | 15 / 15 | Nice work!\n", + " Regularized Logistic Regression Gradient | 15 / 15 | Nice work!\n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[5] = costFunctionReg\n", "grader[6] = costFunctionReg\n", @@ -892,9 +1147,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 93, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 83.1 %\n", + "Expected accuracy (with lambda = 1): 83.1 % (approx)\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(X.shape[1])\n", @@ -957,7 +1232,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.9" } }, "nbformat": 4, diff --git a/Exercise3/exercise3.ipynb b/Exercise3/exercise3.ipynb index e37be91f..0f471eff 100755 --- a/Exercise3/exercise3.ipynb +++ b/Exercise3/exercise3.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 96, "metadata": {}, "outputs": [], "source": [ @@ -132,9 +132,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAJDCAYAAAAiieE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzsnWecFFW39Rf3kWAOmBOKCRXFnCMo5pwTIibMGTFHRAQT5pzQxywq5pzAjIiiYgIVszwgKsl77/vhvWv3KqfKYWaqu7rH9f/C/m2mu+vUOXWqascW//u//wtjjDHGGNM0/qvoAzDGGGOMaQ74ocoYY4wxJgf8UGWMMcYYkwN+qDLGGGOMyQE/VBljjDHG5IAfqowxxhhjcsAPVcYYY4wxOeCHKmOMMcaYHPBDlTHGGGNMDvihyhhjjDEmB2Yq6oenTp3aLPvjtG7dugXQ/Mc3bdq0Zjm+Vq1atQCA6dOnN8vxtWzZsgUATJkypVmOr02bNv+I9dnc58/7Z23yT9k//w5bqowxxhhjcqAwS1W5aNGiReLfrP//n//5n9C5qXT1kDZ/aXNZq/NX3/rkWGppTGnUN386vlofq2k+1Hd96r5jKs9//VddO1C17SW2VBljjDHG5ECzsFTp0yufVKdMmRK66dOn15FnnXXW0LVq1arO503l0LdCnv9JkyaFburUqSHPNNP/X7Jzzjnn336+aHRN/utf/wp52rRpAIDJkyeHTt9+27RpAyC5Jmvp7Zhz8eeff4Zu/PjxIXN+dP44Zv3/WiJtrrMsHeS///u/U+Vah9enzn81ovOj1yfnQvcfZZZZZqnz+Wonbayq0/2l2tfiH3/8ASB5nLpXzjzzzACS+0ilx2RLlTHGGGNMDvihyhhjjDEmB2rW/acm959++inkO+64AwAwdOjQ0H366achf//99wCAAw88MHTnnXdene+tJjdEQ0zN1XTcM0raXG699dahGz58eMjzzjsvAODKK68M3c4771zuQ5whdJ4mTpwYsh7/M888AwB48sknU/+2a9euAIDzzz8/dPPMM0/I1egK1HHTvTlgwIDQ3XDDDSHT/b7pppuG7rrrrguZ7pVqX8c65t9++y3kd999FwDwyy+/pP4tWXXVVUNefPHFQ672caeh4RXDhg0DAKy00kqhm2222Sp+TFlwr9HrSO8PTz/9NIDkmlT4/wsssEDoqtFlpi5NDYX54IMPAJTug0ByrhZeeGEA6QHhlUSvGV1fhx12GIDSdQYkr6Udd9wRALDOOuuEjmMCKrN/2lJljDHGGJMDfqgyxhhjjMmBmnL/ZZkEzzjjjJCHDBkCIOkS2mmnnUK+5pprAAAjRowIXbWY3NVk29jaG/odpBrN04qaZGeffXYAJTMvUDJZA8ATTzwBADj88MNDp66WHj16AMg+l+VEf/OTTz4J+eCDDw6ZY1X3s2Y3XnzxxQCAZZddNnTHHXdc/gfbRPRaVPcCXemXX3556C677LKQ1113XQAlMz0APProoyHvtddeAKp/zer4n3/++ZD33XdfAKUsOACYe+65Q/7qq68AACeffHLo+vTpE3ItjZv8/vvvIffu3RsAcO2114ZuhRVWCLmIvVavS+4V/fv3D92gQYNCZtZfx44dQ6eZuoMHDwaQvKaLIKsOHK/FMWPGhE6vxUceeQQAMGHChNAtuuiiIV999dUAgC5duoSuiJADHdPbb78dMsMn5p9//tC9+uqrId9///0AgI033jh0t912W8jzzTcfgPKuQ1uqjDHGGGNyoKYsVYo+yX777bchn3XWWQCSlgzWtgBKb8WbbbZZ6Fq2bBlyEW+KHMuPP/4YOn06V6sa0SftOeaYI+QNNtgAQDI4j8Hdf/1ctaDH1Lp1awBA9+7dU/+WVke1Pr788sshd+vWDUDSUlCpMWttntVWWy3k9957r87fMiAbSAY6M9D3wQcfDN0xxxyT63HmgV5/Y8eODXngwIEAgAMOOCB0OpesKdO2bdvQvf766yHvscceuR9rudGaRlwDN998c+jUUsIEhV122SV01XRN0ipBiwaQ3ItooVlqqaVC98ILL4T8/vvvA0iu6SLqyGmg9bhx40Lm/vDWW2+Fbvvttw+ZVuFOnTqF7tZbbw351FNPBQDst99+oSuizpruNc8991zIZ555JgDghx9+CN2GG24YMgPw9Z5wwQUXhHzaaacBANZee+3QaU3HSo1P14zuD2uttRaA5Jzo/ZteDfUE0DsFAKeffjqA9NqWeWFLlTHGGGNMDvihyhhjjDEmB2rK/admOjX5qavv9ttvBwDss88+oXvggQdCHj16NIBkHZ2igydpslSXiQY6q0tyrrnmAlBykwHJQGfKyy+/fOjUVLr00ksDqN42EnQ/ZLV5odtBaze99NJLIbP+Svv27et8ZyXR41dXH1Hzts4laxYxoLmhFOFq0bW0yCKLACiZ2YHk+Omq/fzzz0OnLj8efzW5xNLQ49NAbbo3uc8AyVCDSy65BEDSPV107TFdq3T1HXvssaHTvSQtvIDBwQCwzDLLAAA6dOgQuiLGp3vmCSecEPLIkSMBJGunaVIT7yt6TrSlUpFzpWvm2WefDVnd69tssw2AZHLIGmusETJdlTo+JlcAwKGHHgogWftR3X/lJK3eHQA8/PDDIXNf0fAB3X9Yn2rXXXcN3c8//xxyJfYVW6qMMcYYY3LAD1XGGGOMMTlQU+4/Rc2wnTt3Dpl1qtQk+s4774TMmlaLLbZY6neVA5o19Xe0TQlr1nz33XehoxkWSGZvMKtM3V9qqmX2hmaPaZ2Sfv36AUhmrBTtflD3HmV1aWpWJM2/X3/9dejU1MuslqLHpKSZnNX8rm1q6H6hm+Wvf5uWnVrOTJYZQd17nD+tXaVmfbb5UHbYYYcyHl150DW7yiqrhEwXja5fzY676667AAAHHXRQ6LQmUtGusjvvvBNA0qWimYwLLbQQgGR4gu41rAlUhMtMrwPNSNXsuI022ggAsO2224Zu5plnDpnnQsendRDp3kyrB1hu9Dr65ptvQtbsdtYE0+xjuqSB0v7wn//8J3Q33XRTyMyE1NpVRewpumZ0fphVqu7BtJY6mhGvNbs4v+WcP1uqjDHGGGNywA9VxhhjjDE5ULPuPzVJqiuLmR7qElRX32677QYgvd1CuVEz+3333RcyC7Vpu471118/9Tto9vzss89Cp4XseF7U/H7LLbeETFNw3759Q1epli5ZmWmaCcZCrprdMnTo0JBfeeUVAMmMsQsvvDBkuqKqPXtMz8WHH34YMjNBNWOpvs9r8UnNhGQmUDnOhZrn9fpipo5mh3355Zch01Wk1+eSSy6Z+r3VCF0Nei1rcUJeS5deemnoDjnkkJDTspeKzk5lRhxQKg7Zq1ev0Olcci3de++9odOWIauvvnr+BzuD6DrXY2JGGFAKDzn++OND17Nnz5C5/2hrKHXl3n333QCSLrVKzZ+uua222ipkdd+xTZBmpDIkBCiN5fzzzw+dhp1cf/31AJLZ9ZUan86f3pO4JoHSWkxz+QGl4sl6/Wn4C+8P2uYub2ypMsYYY4zJgRZFvdFPnTq1ST+c1VCSFiCW6weSgaBLLLEEgOTbCWs3KY1tV9O6desWQHJ8fKoeP358/N3KK68cMt/0tTWEBvpqoCtbnqilS+uXMJBUgxf1TYTzrVYxfZOrb9wc37Rp0xo8f1mWqnPPPTdkbXRK9K2FQc1qnVJLCY+/seu6VatWLQBg+vTpTVqfesxpa/XXX38Nnb518g1Tm/Sq1ZHj0u/UmmsMNAaA4cOHA0i+abZs2bIFAEyZMqUsF36aJUeDsmmp4hslkGy429S34jZt2jR6fWahc8maN9raQy3BPH6tOad/yzflxu4vXJ9NnT/dH2i9B4CPP/4YQDL4XK1PtDpq8ox+nmsxK3mivvnl/OV5f9A2ZrTk6Pi04TWvP21ofuONN4a84oor1vn+huw1Tdk/sxg1alTIbJ+jyT0cM1DycGiilI6PgfxNXZ9N3T8VXUtpdQx1fpmgxnqFQDJRgQ2VG7vPcP/82+Nt1DcbY4wxxpgEfqgyxhhjjMmBmg1UV/OfduRmTZGrrroqdFpH5rzzzgOQbE2gHa133313ACU3GtB4U+hfUTedunQ++ugjAEmXoLr/1FTJ+iPaJV3dK3Rvamf2LbfcMmTWN9F6Qez8DZS3zYl+n/6OBsUyEF/dXxrIzblkOxQgOT9FuLM5Fl2T6urVmjIMFNXWQRoo/NBDDwFIuiS0ZlBagoXW5NEA1UolY+jvMACU9YqAUnAvUAqa1TYm1ZhUkOVeYPuWxx9/PHQaXkC3rrZ50TYfRbaHUjemBpprIsgVV1wBINnaRNcU91d1X2tSzS+//AIg2WZpwoQJqX+rwdB5o2uKeyJQammm7i91lTEAXYOb9f7B+aumNav3DQZ1d+vWLXSnnnpqyLzvaJsedeXmda9rDHrNZbmPuWZ0zvT+nebepMsPqEzQvS1VxhhjjDE54IcqY4wxxpgcqCn3n7oZ1Ix+5ZVXhkxTvGa0zT777CEzu0wz7TQ759///jeApPl37bXXDrkx5lGaHPU49PeZMaP1hjbeeOOQ1VVIV562qUlzKaj7kq0HAODqq68GANxzzz2h0y7lSy211N9+b1PIytjUNifMBDzqqKNCR5csUDJvb7HFFqFT90ulzPJpHdXVzTVo0KCQmYUHlNx/em7V1cfsKq2Nk1YTR8ep2YOzzTZbyJU6F+pWeuaZZwAARx99dOg22WSTkI855hgA6Rk91YQe0yWXXBIy3QpHHHFE6FgPDChdX1onqejxca3qOrz22mtDVvcI3X7q8mRrHaDk9tQ5V1fSOeecAyA5v1qHTEMNuK7LsU71+DQTjK4wPaZVV101ZGbPvvrqq6Fbd911Q64mtx/RexLDQ9Slp6EGzI7bfPPNQ1f0mLg+dc1pSITWSaP774EHHgidtqG77LLLAJTaCQGVH58tVcYYY4wxOVCzlioGRALJN6kTTzwRQNK6o80XGSyuTXj1TZ9v0kceeWToHnvssZD1DbShVit9YtbaWLSKZTWRTPsOHVMaGhSvNbs+/fRTAMlAW615xfMHlM53U5/0+daqx6RvJTpXrVu3BpC0tC2++OIhv/vuuwCSTTJXWmmlJh3fjKLrT+f+4osvBpCsUp91zmhJYj0YIGmhZHNtWkyBUnIFUKoZpOdSrXabbbZZyOW0kOjvs7YRULJQrbfeeqHTN2Va5fT8VYvVSgOnNZFDj58WKlpkgPTq4np+irAE6Dl94oknACQru2tDXbXq7LLLLgCSwd2s8g+UzpHW4dL1x89pcL52vNB9Le/zotcn64kBQI8ePUJmApDWc9NAfc61JpoUbclJIyuhaODAgQCSe7rOr85L2ueLgL+vjbsvuuiikOeaa646n9Em9Ew+AIA999wz8/srhS1VxhhjjDE54IcqY4wxxpgcqCn3n5q0tYmwBjpvu+22ALJdc2m1e7ShL2v+aB2krJoZTUGPjyZ1PTZ1gzTmN/XzGiDPRq4aKK11jvS41IXRUHQskydPBpB0o2odLXVL8Fyre1ePj8eU1VCznKgZffTo0SFfc801AJK1xdSlqa4+usc22GCD0On8suGrtp7p2rVryGzIqw1fdZ7KsVbTvlvrxJx00kkhsz6RmuQ16J6B+Hps6pJgAkYlTfZcq+pS17WqLqtDDz0UQMlNDZRaRwGlOkz6/0XWpgJKLWk0ODtrfTIoe9FFFw0dxwyUgrrPOuus0Kl7j/OWNX/lmFfOnzbJ1TWpzauZTPLFF1+ETsey4IILAki6DKsR3aeZHAKUErE0uUeTotLui+WsTTgjcF9p37596HjPAJLzynulXpPqyu3SpQuA5J6p90LXqTLGGGOMqRH8UGWMMcYYkwM15f5TM+Xbb78dspoH6QpUM19al3ntLK8tbVinhVkUQNJ8XA7zYX0m87y+Hygdv54TrR2jGVBNOR79fprcNTvuqaeeClndt3SV3HTTTaHT7CNSqRYsiprONSORrT3oZgGSrS0WW2yxkOl2yXJPs31S586dQ6frk1ln+nnN2NTzXk7U5K7uB7qCNOOU7lGg5N5Tl6C6FZm9o3XKyj0m/j5bXADJOjjaBoQ1c954443QjRgxImQed9EZVbpP7bjjjgCS9cJ0rS6wwAIhMzu1X79+oVNXzAknnAAgWTutyNYmQGkveP3110PHLGEAGDx4cMgPPvggAOCUU04J3W+//RYyr2XNzi56LoleB2+++WbIhx12WMh0u++xxx6hY+srID2ko1rGp1mk6n7VTHGOVV3ZPXv2rPO5vffeO3RaM49hPWn3xLywpcoYY4wxJgdqylKlT5SspwIk61TxTX/TTTcNHYMPgZIF5LvvvgudvhWzPpVWpi460DRPeA71nGjQtFoN8hp3mlVJA5m1phGrH/ONEki+FXN+1lxzzdBVqraRvt1ocC4tAUpW7aX6zinf+rXK+vHHHx8yrQra5FatDnPMMUfq8TYFzp8eu1p11FLBYG9tmKyWNAZCa6Dw9ddfHzKrc2uVf634Xc63ag1+1do4qmf9ot69e4dOrQKs01RNewbnT7swqPVdoSVfA/W32267kFmxu2jrRloT7z59+oRO6xhp0PaoUaMAJOdMG/LSU6HjK3qs3Eu0iTUD0oFkTT9aZdTSqkkJ++yzD4CkR6JoSyP3R12f7EwAJM9/WqISk3uAUscN9Yrcf//9IdNCqfWssmpCNhZbqowxxhhjcsAPVcYYY4wxOVCz7r/ll18+ZA06ZyCbmoLVvMc2E926dQvdsssuGzLNitVkvs8TmsrVJKym1LxMwfo9PNedOnUKnbpPtCUB57hdu3ah69WrV8g0XxcdKFufe6CpLkldf1rz6OCDD67ztzr+crpCdZ3o+dc6aGyIvdNOO4VOG6LyXGkbFLpcgJL7V10B5Xa/8PvnnXfe0NHNBSQD8ffaay8AyUBmdSUU7Ur5O7LWrM4rg7a1zYsmTRRRHy6NtOPXkABNJNBr4sILLwSQvI70/sD5K9rlp9DV+cMPP4Tu5ZdfDlkTfRi0rW3I2EQZKLX0qsZ1mrUmFc5lVh1G1u9jvTggGX7AmmsaPqHN0fOo81cdV4gxxhhjTI3jhypjjDHGmBxoUZSZc+rUqU36Yc3+UHnSpEkAki1D1KTHrJ6s7Iemno/WrVu3AJo+vjzRsTKT7J577gmdtgfQlgbMJFNTK8c3bdq0GR4f50fnSTPWVCbqXtJMTM5ludxcrVq1agEA06dPr5r5y5OWLVu2AIApU6Y0aXw6Z1pzim67hriUdV3wc411T7Rp06bB6/Ovvw0k2ygNGjQo5E8++QRA0mU9//zzh1zusAGuz6bOXxbc/+jGBZJ1rLQmUDng/DVm/9Rzr5lyWpuJe1pRrVmasn/qdUY3JpCsQ8W9fLfddgsdW7cBJVdZucZc9P7Jc5Xm0gZKbj91+WqbrPrg/vl32FJljDHGGJMDfqgyxhhjjMmBmnX/KWmuwKw2JnQblWvc1ej+03NBs7iW/ldXDrNDgJLbUM9VY8zXaceRJZOsTKVyr9eizdflJi/3X9b8VaoQaxZNcf8p6j6ob31Wcszldv+RrP2z3NdfU9x/9e0pQPlbgtVHU/ZPpSFZmP/0/TPtWm7s9Wv3nzHGGGNMhaipOlVZVFNLgWpEzwkDNbUNh6JP7XmfS89T86G5z2XRFreiqcU5be5rUvmnr8+GUOlzZUuVMcYYY0wO+KHKGGOMMSYHCgtUN8YYY4xpTthSZYwxxhiTA4UFqldTymWeMOWymkoq5AlTgv/8889mOb6ZZpopl5TnaqUaU57zhNdfcx9fc1+fzX185S6JURRNKYlRC/D+93fYUmWMMcYYkwPNoqRCfdRXFM7pqbVDWnFXz191U1/xzFqkqOKYxjSUtPvfP6n8hMJCoOUcvy1VxhhjjDE50GwtVf/6179C1jYsZ555JgBgscUWC93RRx8dcjVaPbTMPuWsN2WS9fTN8VXjOLPQsU6fPh0AMGXKlNBpl/H6zoupDDoP06ZNC5nrslWrVhU/pjzgvvLnn3+m/v9MM/3/LfW///u/K3ZMxvyVrOtv/PjxAIDZZpstdCrXotWqvj1fr9WJEycCSN4zeM3mhS1VxhhjjDE54IcqY4wxxpgcaHbuP5rnf/zxx9Cdc845Id922211dNXoMtJjoskSAL799lsAwIQJE0I3efLkkFu2bAkg27y78MILAwBmmWWW0FW7yVePb9CgQQCA22+/PXRPPPFEyG3atKnzGVN56KYFgBNOOCHkdu3aAQCOO+640KmrvlrmTa8/deV99913AIA777wzdBpe0K1bNwDAkksuGbpqGVMWjdn/qn1M9aFjrm8s+rd0FelndH0UfV4YHqLhEWeccUbIr732GgCgQ4cOoRs4cGDIdIsVPY760D1j6tSpIfO4eR8EgJ9++inkrbfeGgBw1FFHhe6ggw4KOQ+3vS1VxhhjjDE54IcqY4wxxpgcaBbuPzUF0u2n5r37778/5I4dOwIAdt1119BVo6lTTc5XX311yP379weQzN7T7AaeC82ummOOOUJed911AQC33nprnc8A1XMudPxq3n3ppZcAAOPGjQtdLWUyNgbN/qyv5lPR54LHOnz48NDdfPPNIe+3334Aksep669I9NyqS/38888PeeTIkQCAN954I3Tq/nv00UcT/wIllztQzPxwXFnrSLPDeHxpGcdA+lzpmKpl/1B0rDoWknb96N/pWuD+O/vss4fuiCOOCFndTpU6FzonY8eOBQBcdtllodt8881D7t27NwDg+uuvD93nn38e8iqrrAKgurJXdS44P08//XTo9P7IuVp55ZVDd/jhh4fMOdHwmbzDf2ypMsYYY4zJgZq1VOnT+W+//RYy3xoeeeSR0G2xxRYh9+vXDwCw+OKLh67ot/s09Ol5++23D3nAgAEAShYbIBl0SKvV119/HTp9U+ZTvz79V/vbpVriONdzzjln6KrF0tFY0qwCOie///57HVnPidZc0fNSxNsm5+2rr74KnY5l7rnnTvxdNaHH2bp165DXXHPNkDt16gQgaX375JNPQt5ll10AAEOGDAndwQcfnP/B1kPa+f3ll19CZsILAJx++ukhv/XWWwCS+6OOf6211gIAdOnSJXQLLrhgnd8tek/JCkT/5ptvAJQsjgCw0korhbzIIovU+czzzz8fMq0i66yzTugOPfTQkNVDUM5zkFa7DwAuv/xyAMASSywROgZn6+d0n0irI1c0Oj61BF988cWJf4GkJ4aWqqWWWip0Tz75ZMgM4Nc5y3uftKXKGGOMMSYH/FBljDHGGJMDNeX+UzeJ1p7o06dPyHT7qUvsxhtvDHmhhRYCUJ0uP0XNsGpep6lTTZ5ac4puIR1/mkm3Wsy8Waj5V10Vw4YNAwCce+65oWNtKqD65zWtzZCu5XfffRdAqR4SkAzKZCDqpEmTQkeXBQD07NkzZLqNK3lOOC4dk7pn11hjDQBJN0k1BcUSnZ+dd975b/9fg5PpSrriiitCt9dee4XMmnHluP6ygs/vvvtuAKUafQAwatSokH/99deQuVZ222230C277LIhv//++wCAa6+9NnTqimEiTBG1m3T8uuZefPHFkE8++WQAwIcffhi6K6+8MuQePXoASAYyX3LJJSHTfbTccsuFTusAZrUvyhsd688//xwy3c7PPPNM6uc4L6uttlrotGXbRx99BKA0zwCw++67h1zEXJ5yyikh33LLLQCA0047LXQ77LBDyKxZyDADoJRcAJTcojPPPHPo3FDZGGOMMaYK8UOVMcYYY0wO1IT7j6ZAdWNom5KrrroqZLaHuOOOO0Kn7hGaP7UzdVqmjP5WkVlUQMnlA5TcJmq+THPvVLsbrD70+NlaASiZ33fccceKH1NDyHJFMOtIzeuanfLZZ58BANZff/3QLbPMMiEzk2yFFVYIna5PzVorwsXL36SbFkjWGWvbti2ApCu/Gt1/Strx6Zyq++zjjz8GAKy++uqhU/dgOdFjYhYfUGoJpC7j+eefP+Q99tgj5O7duwMA1ltvvdDpmmKm2b777hs6uswA4PHHHweQzD4r9/ym3R/oxgKSNQuZFa21x3T8/A69JtVVyrnUe0rRaPY714DOmcLrk25aoJQRCQDnnXceAGCeeeYJnbq/9b5Zqf1l6NChIS+wwAJ1jkn3Qo570003DZ2GGjB7U6+VvO+VtlQZY4wxxuSAH6qMMcYYY3KgJtx/dBVoQcu77rorZHW1MNOG7WiApJmS5mu6WYBkphJp165dyGrqLcKt9sILL4TMTBy6UYCkSZbusbR2DED1Z/0RPU7NZGGmn465GtHjV/cBXRFakFYz9pgdl5XRmDZ/WYUOK7VWda0xa/GDDz4I3aKLLlpHrlX3NM+1utJuuummkLmXqEtMXfXlcIXxmDTjT1tzkV69eoW80047hayuSs5lVvgD3V977rln6AYPHhwyC4lqcdRyuIzSWs9oSAjdWEAyI++GG24AkAwfUPfQDz/8UOfzOn5en1rQVc9V1rWYN/rdWqh17bXXBgAMHDgwdDoW8t5774Ws7lEWNVX3aNFtzLTlDtfttttuG7qTTjop5GeffRZAsmDoddddF3L79u0BlHf/saXKGGOMMSYHqvt1///g0zGfQoFknRFtGcCgTH1jeOWVV0LmW6UGP7MJs/4W2zEAyZosWv6+nE+7+nbEOjNAKSjxnHPOCZ0Gyn755ZcAgL333jt0GohZLW0ksuBbkTbkZfArUHqr0tow1TIWfSPXN8EDDzwwZFpy1FI1evTokPmmrOuv6Ia89aHXGten1vnRQHuOpRrHMSPQKsLrDEjWMWLz2k022SR05R4rz78mBOj6o3VQG+vqnqltTuqzpPFaU+ujBuKzJhTX8V//thyWqtdffx0A0Ldv39BpHb8zzzwzZFo41PpC6z5QSnr6/vvvQ5cW1Kxj1nOW5SHIm6yWSrRK6Z6jlv7//Oc/AErt2oCkpWqfffYBUExjaEWvGU2aYAKaNrFWmS27Bg0aFLquXbuGXImx2FJljDHGGJMDfqgyxhhjjMmBmnL/aZd1NQ9qGxeaYjU4T+vJDI4iAAAgAElEQVRY8Ts0eHSjjTYKmQHCajI97LDDQn7ooYdCpqkxL/O+mpk//fTTkLWjOsvvv/rqq3WOWY9Fg58///zzkHv37l3nt6rFfaZonbG55porZNbR0eDSSrWGyILn8vfffw+dtu5QVwwTKN5+++3Qacd4mufPOuus0Om56NSpE4Dqre1E94e6QdQVk1YTrlrIqi2msI3QQQcdFLpVV101ZAZLa52ftJYt+lsqN2UvUfez1omiK33ixImpv1Pf9a/Hx7EMGDAg9W+5J+qelBc6J5pcxNYz6nJUl7O6/9iybJVVVgmd3lfY5kTXr54fhp1omxRtE3PssceGzJZF5Xb/6vpi0LoeB9tVAaWWLo8++mjo0tyz1XRP0HnnOdU9RY+V90etw1Xpmni2VBljjDHG5IAfqowxxhhjcqAm3H8037EGBwDMPvvsITP7AwC23nprAEn3mWYynHvuuQCAzTbbLHQrrrhiyJ988gkA4KWXXgqd1rSqlKtJTcr7779/yMcffzyAUjseIL1mi9bOOeaYY0Jmx3Htsl60K0nNu99++y2AZG0uNeXT1Vv0Mes5p1tF3S/a+V2zknj+1WU9yyyzhEy3rnZeV1cvu8sXPf4s0twG6oqi27Zo90KaS0Cz4NQ9q1nHrP80ZsyY0Gl2ETOJNftR9yq6erWmlP4t23AA2S7Iv0L3krrcNKPrueeeqzMmrdNU3+/ouWIowZtvvpn6t3Q/qcs+r7nW76GbEShlNWqYg2Zn6rXK7Ns33ngjdDp+ymkuJ6CU3Xr99deHTkMR9L6y8sor1z+oHND5eeeddwAAzz//fOgYMqF/q22K9LwWfV0SHZO6ehmKo9mZWlOL9SvpxgWSmfCVwJYqY4wxxpgcqAlLFVGLkgYa6luTBmMSbb54yCGHAEhaBzQQmJVoNbjwlFNOCbmc9ZHU+qB1iljFFyhZ3bKCH/mErw1PtY4OLUCszF4N6Jsk36o1OF+r5+edHNAQ1BKlddIYFKpvqR06dAhZg5aJVhy/5557QqYlRGsKaZ2xooPy64PXhM6PWo1podFEkUq9HesxqXXoiiuuAJAM3qVFA0gGQPMNf7755gsdazMBpXlT67juNRy3HotamB577LGQae2Z0bWuf6fB87ymLr300tBpw1la94FS0o6OT/dUWsBUV6mkER2frh8GqqtFQr0Xeqy0Hum50PnjWNQSteGGG4bM9avrR+daz1tZq3aLJUfrFF5++eUAgCOPPDJ0et9kgoWub+0eUqSlKi0hAkgmXXGu7r333tBpzTXWNNSEMnoHgMrUEbOlyhhjjDEmB/xQZYwxxhiTAzXh/qNJUt0vWYGQaXVwHn744ZAZwKemWQ0KJ2eccUbIGiieVb8kb7Jq5tQXoMxx6We0tc5bb70FINkQtFJNQBX9TT3/t956K4BkIL26woo0T+ua0UB0tiTRdaYtQ5Q095g27KYrQ11+WseqGtu76JzQPa7X57hx40JmoK+6xMo9p7xmx48fHzp1GbA5srpR1KWj7gO6IrShubaxGjZsGIBkILUG1TIYXl36KjfFLZq1D/JaomsISLbuUpcjGyJrULvOFd1b2uT2oosuClnrB5UTvQ6417FZ7l9lPRd022lrGnVZss2ZtpFK2/PTXPp/Pa5KNVTWQG26fbW1y9ixY0PmWi9HHbHGwvnRc3f11VeHPGTIkJBZf3LLLbcMHWv7ASX3bFYduEpgS5UxxhhjTA74ocoYY4wxJgdqwv1H86vWq9DsDjW1r7DCCnU+ry6zr776CkAyY0XreOy2224Aku6BIjp2qym0IRkLdJGqq2Po0KEhM5OxCJefomPSmlSU6QYESq0HgGLrM+mcaBZor169ACRdqlrzKM38nFVzJ819Uo0uPyWtZZRmP6pblPWdFlpoodTPlwOeaz232maEGUXzzjtv6LQm3jbbbBMy50rXr7ZsoStCQxXU1UTUfaQuv7Tjbgz6WV4zuo916dIlZM0EZKacumx1/dLtqeu/X79+ITPTrBJZVoRj1b0hy+Vzww03AABefvnl0GmdMd4LKt3aZEbQY+J9DEjeC5n1pvNPlztQWmtFZN9mkXZ/1zqLWtNvv/32A5AMb3n//fdD/uKLLwAkXd16LbpNjTHGGGNMjVATliqiT6dakVhrMvXv3x9AdsDgN998AyBZ5ViDTvnUXESVWX2i1jcprfPTo0ePOp/T88LmoEcccUTo9K2YQfdFvInp26Na0jQokVYpNg6uVtIsiVqjpiHo+qp2q1R9cC1q8L1eq08++SSAUmV4/QxQnmstLdFFrdN8+52RhsqcH50ntXrTAldf8kylApqVrN/R4+P1p3ti2t9qcLCOhQHuaYHklUTHpJYMWkA0+J7B6UBp3NVYD07HxM4TQHIsrVu3BpC0ZPXu3TtkduJQ63i1oA3ptY6W3r9Yc00r5mvz+l122QVA8v5R6T3VlipjjDHGmBzwQ5UxxhhjTA7UhPuP7ikNWHvwwQdD1pYrNDVnBUqyfkmWKbxI94sek4511113DZkBotqGYsSIESGzjseoUaNCN3jw4JDZZqOI4Et1A+jxaZshBgVrw+hqd4mlBcr+U6Hb5KSTTgodm5QDpUa26hLMCtQuJ3qtpe0VDVlzaUHh1U7W/pdWR03huVKXpzYO5nVdxPyqe0zdd3369AmZAfjqEtOWYNU8fzones6POeaYkC+44AIAwAMPPBC61VdfPWQ2JK5UvcUZgb+viSJsJwckWwrx+DXUQoPSd9ppJwDFJJcRW6qMMcYYY3LAD1XGGGOMMTnQoijT3/Tp0xv8w2rezao9UbSrqGXLli0AYOrUqU06sWqe1TowrN+0wAILhI61f4BSduCBBx4YOq0JxHPY2Hlv3bp1CwD4888/mzQ+reOk7UGYyVLJNibKTDPN1AIApk2bVqxNvEy0atWqBdC4668h6Pr9448/QuZclsslxOuv3OMrCo6vqPXJ/UPn95ZbbgmZbl+2wwKAJZZYIuT69meuz8aMT+8Pur9ssMEGIQ8fPhxAMiOwY8eOqZ8rBxzflClTmjR/WXW4mJWpbbK0zh+vu3K5Odu0aZPL/U+Pj7XTgNK41b2nbbzqc183Fd7//g5bqowxxhhjcsAPVcYYY4wxOVBT7r9aIC/3n5KWnZRVXDDNvZdnIdO83H9ZXcR5fEWtS7v/8qe+Nj15YvdfZdBM3p9//jnkrbbaCkAy+3OPPfYIub6imnm5/9T9M2TIkJBZFLNbt26hU/dRucNH8nL/ZVHfvaLc+2pe7r+s+0MalQz5sfvPGGOMMaZC2FKVM+WwVFUTeVmqqhVbqmobW6oqj1qtxo4dCyBZx0qTauq73zTFUpWFBjXT6qEWs0paOsptqSqavCxV1YotVcYYY4wxFcIPVcYYY4wxOVCY+88YY4wxpjlRWO+/5h6T09x9ytUU05EnjHlo7vPn66824fw19/E19/2luY+vuceM/R12/xljjDHG5EBhlqpqIq0mRtHtboxpzmg9nUrW0THGmHJiS5UxxhhjTA78Yy1Vap3S5o2///47AGC22WZL/dtqQY9J3/q1ZkwatARonZZqtw5o8+z6KgZzLm1prG7Y+BUAWrduHXKbNm2KOJwZhtdXfdeZouuT1121X3PGVDN6/9NrcUbv1XrPz/teYUuVMcYYY0wO+KHKGGOMMSYH7P4D8OSTT4Z82mmnAQDefPPN0GnLhaLN9nR/qfvuiy++CHn48OEAki4zNW/OMsssAIDOnTuHTts4FD0+zou6+TgmABg9ejSA5HHOPvvsIa+55poAgLZt24auUmPKcsmmuSwVPT7OVXNyX+r4OX8bb7xx6Pr06RNyjx49ABQ//iz3wtdffw0AeOONN0KXNr+zzjpryPPMM0/IK620EoCky1NdEbWC7i96/EXvHzNK1rVKfVqTd6A01rTPAPU3jG7KsdbKuS0nXHcaPqD3PzbM/uOPP0Kn65P3itVXXz10Cy+8cK7HaEuVMcYYY0wO+KHKGGOMMSYH/nHuP5ptacYHgGOOOabO/xed8ZflMhozZgwA4NZbbw3dfffdF/Knn34KINt8TfNp3759Q9ezZ8+Qi3B1qntl0qRJAIAHHnggdKeffnrIdFUutthiofvpp59CXnHFFQEAt99+e+g0o6wcY+Lxq+n/pZdeClnnivOqx7HkkkuG3L17dwDAEkssETp1hRXtFptRdP1NmTIl5MsvvxwAMHny5NAtv/zyqZ8rEl2TQ4YMCfmMM84AAIwcOTJ0aces7j11BR5++OEAknvOnHPOGXKlXIFZ7q/6fn/atGkAgIsuuih0un9wLNXkqkobK/cZIOnKZajBu+++G7qVV145ZI71ueeeC51e6+rKZgZ5Y85FWu3ErCy3tP2hms5/Y9DxTZ8+PeSbbroJADBo0KDQ0eUHlM75fPPNFzq63AHg5ZdfBpCc0+uuuy5kvW4bew5tqTLGGGOMyYF/nKWKT8A33nhj6Gj9AUpvIvpWUESgswbaaaD2YYcdBgAYO3Zs6PRNc6655vrb3+Cb5p133hm63XffPWQN2ivnW7Oe32+//Tbko48+GgDw6quvhu7ss88OuVu3bgCAmWeeOXQffPBByHvssQeAUr0xoDy1j/Sc//rrrwCA888/P3TPPPNMyKuuumrI6667LoDk26WOdbvttgNQsugApeB7oJRoUO1vonp+NKj06aefBpC0xHXq1CnkIi1xuib17ffUU08N+bPPPgOQrGPHawooXTOqU/r16wcgaQlRS+bcc88dct5Bz7q/TJ06NWRatwGgQ4cOALKtItyXHnroodBtu+22IfP4iw6+z6pDSEuFWpTeeuutkLkueU0DwMMPPxwyr0u1vuqeedZZZ9U5hhm9VrP2xKeeegoAsNRSS4VOE3HS5KxEpVpBz9mFF14YMq3Ge+65Z+jWX3/9kGmBUo+LroWBAwcCSFq6vv/++5DVa9DYNWxLlTHGGGNMDvihyhhjjDEmB/4R7j81q9LVpybdjh07hnz88cfX+Uy5zac0T6q5sX///iFfeumldf42qyEtzfoanLf44ouHPHjwYABJ83ARAek//PBDyHRpAsDzzz8PIBlovuOOO4bMY9XxzzHHHCHTPfbJJ5+EboMNNgi5KW6JrHo0DF6+++67Q/fggw+m/n7ad7E2EwBce+21AICdd945dHRpAsCAAQMAJIOfq928r+eKAepbbLFF6NSVW6RbMys4Xd1jTJRQN8Fmm20WMt0P6h5SV/ALL7xQR3fCCSeEfNVVV4XMoNm85lfH99prr4V83HHHhfz6668DyG4N9fnnnwMAfvvtt1yOqVzoObvmmmtCpntuyy23DJ26gli/6JZbbgndBRdcEPLEiRMBACussELo9LrXmmR5zRv3khEjRoROrxl1/9EVpnuqrtVq3it0T9TwDXU1M2lJ3X8ayM7x6XepK56uVK1tOO+889b5fFOwpcoYY4wxJgf8UGWMMcYYkwP/CPefwpY0H374YeiOPfbYkNu1awegsm4Imtc1C+Wuu+4KWU2S/NsjjzwydFpzg6bo/fffP3Qff/xxyOr2rBQ0xaqZVrNvHnvssZAvvvhiAOkuv7/KRE3FP/74I4Cke2XDDTds9LEr6j7R2jb3338/gJLrDgDWW2+9kOtr46Ftguj2u+KKK0J3xx13hLzbbrsBALp06dLwARSEXmucn1VWWSV0WTXVKgV/X90Emn2l7stNNtkEQHKuF1lkkZDpstPPqKuW2Wc6548++mjIzA4E8sta5brVem7nnXdeyBwTUHIrZc3DL7/8AiB5/AsssEDI1ZK9+fbbb4esGXl0i6lOXWnjx48HADzyyCOh0zEx6/OGG24I3dJLL536tw1F94kFF1ww5HvuuQdAcv9UeE0Bpfsbs6QB4Prrrw+ZNeGq0Q2oa45hHACw9tprh8zrbtNNNw1dmvtO18K4ceNCZksbdbnrb+Wx/9hSZYwxxhiTA36oMsYYY4zJgWbr/kvrLA8AN998MwBg/vnnD91+++0XMs3a5S5epy4PZtJoxoYWJFtooYVCZnuIrl27hk7N1zvssAOAZLl9dU9cffXVAMrTTT0LuiyHDRsWOi0+etppp4VMt2Z9Lj/NSPrmm29CpvleMzqbatLlXKnJfOjQoSGzUKB2Ps9qI5GGHh//Niu7k64iddkU7T5TeCy6vjSTisen56poeMxacJdFPoHkOaWrQfcPzZTj+rvyyitDp65cZgXqZ7S4YTmyx7iX6TXHLD4gmWnMc6AuSz1WutUmTJiQ+ltpbZiKcDWpS0f3Ql6rafsvUHK/asiEFpJkIdhyF6zV88f9Xfd5RQvGcl1qmIfeSzRrsZrR/U9DXXbZZRcAydZl5557bsh0ReuYWVAaKN0X1D2a9/5pS5UxxhhjTA40O0sVn3C1DYM2/2R7CK0DxCa8QOXaK6gljbWZ1KKmT8+HHHJIyLvuuiuAZFCtvinxrUzH8cQTT4TMQFNtrVAO0hpianCv/r6+SXD+GmLd0TYonHd9e2sq/C2dMw205hvke++9FzqtDdaQmmecP3271s9/9NFHAJKWIA0aLhrOu7beYfAsAOy0004ASu1QgOqxrmmTZ62jphYC1rnR5BZt3kpLjiad6F7E9a3XtFrKG2Lh/DvSakuxxhmQ3B/0TZ8WqkUXXTR0aqlhAoiuOR0fLXV6/pZZZpmQy9kwW8e07LLLhqyWQDa0Voug1kxjUogmv+y7774hc970/JbbElff96sl8eeffwaQTLTQY60VdMzqdWDNqpNOOil0mpTF+mNqqdN7Ja21mgSS9/zV3tk2xhhjjKlC/FBljDHGGJMDzcL9l9ZF/fzzzw+dBsoygPGAAw4InZpPy+n+yyqdz9YQGjCpLgGarPVzWS6TNL0GnaorqZyoyZk1nbT2iwYaqquuPldQWlCx1rmaa665AJTqjc3Id84oaibWzugbb7wxgGSiwciRI0Pu3r17yAyk1POjc0K3qLoPWVsFKLlXtGZN0e4/Xdd0BWlrD20JwUBgDSSulMs9C86ruvHUJaSuPJ73f//736FLW196TtT9xUDnbbfdNnS6/+Tl8qObHyitP22dc9ttt4WsNdW4B+n6ffPNN0P+6quv6vzuQQcdFDLd0hrIf/nll4es57icbjM9F3vvvXfInCu2lgJKyTtAaX/VNiisnQeU1m3RdZ50felc33vvvXV02sarFtHri2EX6j7ffffdQ/7ggw8AAKecckro9F5aifmzpcoYY4wxJgf8UGWMMcYYkwM16/7LyiKhq2/gwIGhU/fX8ccfDyBZ5r5Splw1SX/33XchMzuPrisA2GuvvULW7KMZzYpTl5C2fGHHds3YKQc6P6+88gqApEuA9UaApPurvvpZ/F51ZWjNKNbpWmKJJUJXDvefZo+w5YdmpJx99tkha5d1tlzQ2mN6rDwXY8aMCZ2eS7pPinb5KTp/w4cPB5CcE3V1MausaPeJwvPLzCkg2eZEr1vKWRlV/C51iWmdnbSs23KcC72+2abp0ksvDV1WnTC6itT9vM4664TM7L+xY8eGTtc626vontW2bduQKzXves1rJi3dulpHbMSIESGvscYaAJIZ45opWLSrmuj60+xN3vd0L1pppZVC5nnJun82JDuzUu5bvScMGTIEQNIlqzXDJk6cCCC55thaCKjM/NlSZYwxxhiTAzVrqdK3YzYpBYC+ffsCSD6RnnnmmSEzmLiIKtT6OxpozeBIDehdbLHFQm5qTRRWEQZKgbbahFKtHk05F2kBy0ApUJ1vgUByfPW9Pej3ct61obFWVN9mm20AJMdUjrcT/U42KdWK1aNGjQpZA81pyXnggQdCp+eK49M6OTp+NlIu2lKlx6RWw0GDBgFIvl2eeOKJIbPmUdFv/Gn1oLSyuNbWUksHr1UNLk+zZKl1WK0+vP7Ksefo3qBNjs855xwAyXHUZxHW+dG/pV4t/WrJ4nktuqK6zonuf0yg0Ir5WnOuffv2AIA555wzdNVkVSV6fnv27Bky74Vau08badPqlmVp5fxqIpXKWsuNVue8OlboPV3nTJOamOyklmAdP/9WLZFsQl8pbKkyxhhjjMkBP1QZY4wxxuRATbn/sgK9GXwOlEydLFcPJMvYz2gblHKjDR8nTZoEIJ/S+TShasNUdb+wztH2228fOg0gz8stoy4DBg9qcLaaetOCI1Wnx/TSSy8BAA4++ODQrbbaaiFvsMEGTTnsRsGxqvtWXSIqs2aO1iRT9xndShrorTVzGPTdkOD+cqDXorbnYSKE1gZS90rR110aXF/qktXzq4kuRx11FIBkyAFbXwElV8mLL74YOiYnAJULNdDrh2uqsetEv4vzTjf0X/+/SLduVpNk3f/YkFzdQ2uuuWbIDBVRl5fuy9WCXkfakofusRtvvDF0vXr1CplrQd3Xet7oNtQ6ZRoIvvXWW4fM+2pj1rTuH5wrrQenddQ0UYA1CbUxtLokGVajrecqjS1VxhhjjDE54IcqY4wxxpgcqAn3X1oX+bPOOivk999/P+RFFlkEQDJjQN0y1WKeXnrppUNmpg5dc0DS/JxmylfUFMw2EkcccUTo1FXBOjmsXQPk55LQ71GTOd0fN9xwQ+hU3meffULmWNVVoX/LWjua0UKXDFCq41TEPDfEtaVtWtS9RLM4MwqB5LngWleTf6VIawcFJNuQ8FrT2kyVagPVENS9R7cf3dRAcqyaNZdW00rh/6vLr2gac33r+CdMmBDy119/DSDZeqdSLs0seKy6tnRN3nHHHXX0GhKidao41obUayoaHTf3d73/6fzRVc8s5L/Ca1Uz5jWTVNsMNXTe1eWn4S8nnHACAOCFF14Inbpsjz322JCZPawZ01qTctiwYQCAxx9/vEHHlie2VBljjDHG5EBNWKrIzTffHLK+fWiV4gcffBAAsOqqq4auWt6Os6BVR2uLqPXm5JNPDnmppZaq83lWLAeA6667DkCyoabWzGGl3ZVXXjl05Qge1jc9volo8KhWAdbqxbQKaMPiTTbZJOTOnTsDSAZya1B0raBveWlvfNpkWuecVsedd945dOWuuZZmCdAmtHfffXfIXF+aPFCNwen61syOBkwYAZKWRL0utSo5UUsiLcAa/Fy0JaepfPnllyEzqWK55ZYr6nDqwPWp+6DuL9ronI14tQ5c7969Q2Z3g2oMTp8ReI3qnqCB3tw/dU9V+Dm9PrJqjjV0Xat1WL1LDD7XzhObb755yOq1+fDDDwEkG2JrUhZrBeqeWen9x5YqY4wxxpgc8EOVMcYYY0wO1JT7T+v5qMzWNECpJk41uvzUDKltYjbaaCMAwDvvvBM6bW3SvXv3kNNMrmltMjR4m20qgJJbo9y1jXSsdGX169cvdBooqoGUdP9pE1BtyUJXk7YmYHICUJ3z3hA4v+p+0qQCBpiy3QlQCt4sF3QJ6G++/vrrIbdr1y5kJkjonFWj+0+vI7aRUZerJg/88MMPIafVuVP3CgOE9fPVOP760Lm+4oorQmatuaLbJCm85lmjCUiuSQ1/YKPsa6+9NnSjR48OmY169ZqqxfnT9Z22J2YF4vNz5b4/6D1LrxXy3HPPhXzvvfeGzPpZXbt2Dd0ll1wSMu8FRc6ZLVXGGGOMMTnghypjjDHGmBxoUVRmyp9//tngH05rfQIkzfbMMChqXDPNNFMLAJg6derfHkBazQ5mpgDJjCPNmiB6LrR2CF2FW2yxRejyaH9DWrdu3QIApk2b1uATrCbn+trU6HGqK2LAgAEAkm12tGVBU8fXqlWrGZq/cqO1ndTVts022wBImr/VlaE12dLOBeevMdefXlOaPaXw96v9+tM1x/p3P/74Y+i0tpu2NGFWrtaZ0zYezEQuV0Ym569c65PHrRlXuqa4R1122WWh02u5qWNtyv6itZU0o1jdsxyfupzUfcR9pVzuI+4vjRlfLcDxTZkypc74smqf9e/fH0Cydlbbtm1D3njjjUNmm5yslmflDv9o06ZNvQXMbKkyxhhjjMkBP1QZY4wxxuRATbn/1HyYZV4vutDejLofFI4lz9YI5TonTTHP5wHdpuUaX7W4/3QtqCuGhSrVfL7nnnuGrC1V0s5LU9x/irqvlaIzpRpz/XEseVx/HH+59qFyu/+IziMz4oBSUUYtrlz0/sL5GzduXOhuvPHGOv8PAB06dAAAdOnSJXTqHiz3+v0nu/+UtHt51jqqLzykktj9Z4wxxhhTIWrKUlULNOZNuZYo2lJVbqrFUqXU11Bbkxbqu57zslRVK/+U66+S49OaTQwELldAcFP2F7VIpV0nQMnCocdfyXugLVW1jS1VxhhjjDEVwg9VxhhjjDE5UJj7zxhjjDGmOWFLlTHGGGNMDhTWULm5B+o19/FNnz69WY6vZcuWDnSuYTi+5r4+m/v+Mnny5GY5vplnnvkfcf019/X5d9hSZYwxxhiTA4VZqkx50fRiTckvd3FCM2NkFZpM06fNVTXN34wes6lN0go1Zq3fWtlf6iv0Wu3Hb6oXW6qMMcYYY3LAlqpmBjt2P/jgg6F76aWXQr7wwgsBAG3atAld0a1FmiNqKdQu6nwD1nOu8qRJk+p8RgsZaiHGamHy5Mkh0wKg6yvtrV/Pj9df9cD50/U3ffr0kH/99VcAyYKzavWZc845ASTXbDVZfbjutPgnxwSUrq9ZZpkldHr89bVUqUZ0fjj++jwZOr/NEV3fWXtxY9tW2VJljDHGGJMDfqgyxhhjjMmBf6z7L8u0V0tmXaKmzN9++w0AcNNNN4VOx1orZl095jT3Wbl6jzWGtLU0fvz4kMeMGRPy77//DgD45JNPQvfLL7+EfM899wAA5plnntAtvvjiIe+7774AgE033TR0RaxZdR/wmAHghRdeAABcc801oZt11llDpivpjTfeCN3qq68eclbPtkrTWNN/GtW+p+hc0pU7cuTI0A0ePDjkW265BeENfkUAACAASURBVAAwYcKE1M/36dMHAHDMMceETs9lEedCf//TTz8FAFx//fWhe+aZZ0JeeeWVAQCnnHJK6JZffvmQuX+mBe9XA2mJBCr/+OOPAJJ70pdffhnyGmusAQBo37596HTOqn0t1wfPha7vBRdcMOS2bduG3Nix2lJljDHGGJMDfqgyxhhjjMmB6rC1zyCNNbnq39JtpG4wNfNVi/uhPtQlRpcSABx//PEAgHHjxoXugQceCHm22WYDUL0ZV5wrdZ+dffbZIXfs2BEA0KNHj9DpuSgCHvPLL78cupNOOinksWPHhjxt2jQAwNSpU1O/i9lH6hJ8//33Qx42bBgA4M033wwd5xQoxjy/9tprh3zooYcCAA455JDQbbTRRiHz+jvhhBNCd9hhh4XcrVu3xN9VkrR9AkjPCFKXVxq6JtMyjYq+/nSsmt130UUXAQAuvfTS0Om56NSpEwDg66+/Dt3PP/8cMt1Kur8Wsafq+PRaO+200wCU3GAAcN1114U899xzA0i6gfTz5557LoCkS3C//fYLueh1y3XJMBAAuPnmm0O+4447AAD/+c9/Qqd7xqKLLgoAeOyxx0Kn7vui3X8ca9b1U99zwVNPPQUAOPXUU0PHcwIA8803X8iNnUtbqowxxhhjcqAmzDJ8+tQnxz/++KPO/yv6djFq1KiQn3/+eQDAXXfdFTr93iOOOAIAcOyxxzb1sMsC33rVOsVjBoAhQ4YAAJ588snQLb300iFXY6C6vsm+/fbbAIBdd901dN9++23ItITonFVLTZxFFlkk5JVWWinkhRdeOOQFFlgAALDaaquF7ptvvgl5xIgRAIADDzwwdOecc07IHHd9lpJKom/FROdHr09a4NQSVy3WYT0OXkdA0iq6zDLLAEjOr1p6uP7WW2+90HXu3DlkroWZZ545dEVYrXT9DBgwIOS+ffsCADbffPPQ9erVK2RaJVnvTj8DlCzkuv8WPb+6/mgJXnbZZUPH4HQAmGOOOQAk99cbbrgh5MsvvxwAMHDgwPIc7AySVlsKKFliLrjggtB99tlnIe+zzz4AkvcM9QrsvPPOAIDjjjsudFdddVXIee21aWs+a09TPefljDPOCN0OO+wQ8sYbb1zn85oUc8ABBwBIJlJ06NAh5DwsjdWzMxtjjDHG1DB+qDLGGGOMyYHqsLunoOZNtu4477zzQvfFF1+E3LJly5BpvtNAxNGjR4e8/fbbAwC22mqr0N15550hs74T3UxAdsuCcpIVlP/TTz8BAE4//fTQPfHEEyE//PDDAJK1f6qpphNRk666j66++moAwFdffRW6QYMGhbzjjjsCSLoxi27dQlO21na58cYbQ1b3EI9Vzega9PvQQw8BSNYZ05oyl1xyCYBi1mQWH374Ycisr7XQQguFTtcvXbnq/lprrbVCLnIsep3o9bPqqquG/OqrrwJIzslyyy0XMveau+++O3QMfgaAbbfdFkByL6NLGCjGFaiuTtY/u/XWW0M3//zzh8y51Dpr+v8M5J599tlDV8T+o+uodevWITOBRMMLunfvHjJdof/+979D169fv5DpCt17771DV6k5ywrCvu+++0JmgoiGF/CeAJSutSlTpoTu8MMPD5luWz0n5SCt9c+M/O1tt90GIOmSPeigg+p8l95T9F7JQHRNjtF7UR77jy1VxhhjjDE54IcqY4wxxpgcqFr3n0KXyQ8//BA6zW5j7R8AaNeuHQBgr732Cp1mt7AM/7333hs6tl4ASqb+ol1KapKkyw8oZSW+8soroXvuuedCZh2nrG7baRkWlTLPq2lVM96OPPLIkN966y0AJTcYUHKZAKX6OVoTSttoFFn/J8t0rJlEEydOBJDMjtLsqtdeew1AMmPz0UcfDVlrQhWJrpnHH388ZK6/NJcRUMpupEsfANq0aVO242wIunY0Y1NdYQw7YL0mIHlN0S2t4Qds3QKUagYxCwtItskoGmYtZrkkmV2ma1IzyZhVV3QdLkWPhZl+6vLUTLdNNtkEQLJekdb523DDDQHk7zKaEfQ60nuhZgczE07rjOlc8lgZRgAk91KGkmhtubTs1qaSVltQv1tDet55552Q6crbfffdQ6fZe0Rrj+n4br/9dgDAXHPNFbq873+2VBljjDHG5IAfqowxxhhjcqBq3X9p2RtXXnll6DR7TzPFaP5Uk6CaalmeX4u3qauPbkM1P1bKlK3H+euvv4Z84oknhvzxxx8DSLYRoMsFKB2rnj91tXD8Oj4tWlkOV2Ba8dazzjorZHVfslCbjklbsrAQHYv0VRNq0tbO77vsskvILHqprWXUFUq04OQ666wTMrMGiyjiquvzu+++C5kuS6DUZkbN63r90BWq42fGIFB8JiPJcgXyWsk6Tp4jHZ9mnzETUL+z6DHPOeecIdNtosVNdS5ZlHbdddcNnRZS5PqsxoxjRc//UkstFTKLQ2vx0y5duoTM666IOdP9RfdMLd5JV6xm3+pcjBw5EkAyO1nDD+j+zWrjVk50f5kwYULIBx98cMirrLIKAODiiy8Ond7LuO+qe1P33+222w5AecdkS5UxxhhjTA5UraVK4VOl1j7Zd999Q05rhKpvmhrIzoah7777bup3aUuJSsHj13FoILoGbd9///0AkoGy+lbBtxlt4ssmy0Ap6G/JJZcMndbpynrDyZusRAC2gdBATA1U/P777wEAa665ZuiKftMnehzahHSzzTYL+b333gOQrFOllsKPPvoIQHLOnnnmmZCPOuooAMk6NEVYUj/44IOQNZCV9Z30b/X4Jk+eDCA5/mppM5RFfedXr1sevzZp1aQYzp9aR4oes1rtd9ttNwDJhthaE41WEfUa6PrVtVAtpM2PWjq0jdk222xTR6dWE7VAVhpdJ+qJ0fGxPprWWdOWUKy/qNZHrkmgdP8oItFAx6frS+9lrLmlDa81Eah///4AkvcPTXTi/JXT0m9LlTHGGGNMDvihyhhjjDEmB2rC/UfUPFifmVmD+rSNC9ugqPn07LPPDpmm7koGWtJ8qwHlV1xxRcja8Z5duNV8qa4Wusd69+4dOjVf0+2nwdF0yeix5AnnTd08GhypdYpYP0YD9dU9S1fu0KFDQ/fHH3+EzPmrpEuFa03Pnda50Y7xPK40lzVQquN0zTXXhE7dvwykveeee0Kn66McZm0eq7rRNVFCW86kuf/UPK8tbYheq0UG4jeErNpvL774IoDk+qZLDShdl1nu0XKSdW3rtcLzr9eftvzg/2twezXVpEpDzzXbz7DeFlAKqQCAu+66CwBw4YUXho4ueaBUJ66IQHz9TQ3/0EQmhrfovUTrHNItpnUeNVGkiHFxfnRP5zgAYJlllgmZoRA6f9wzgdK9Xmtz6V5cCWypMsYYY4zJAT9UGWOMMcbkQE25/2YEmrjV5aCZBHQraOfqRRddNORKmT/TTPHqUnn11VdDVrMoXS1qsv/8889DZp0gtusBkqbUM888EwBw3nnnhU4zAcvpdtFj1t/UTJyTTz4ZQNL9oC1b2J389ddfD526Dyvl9lNXJrMTNctGXXKaPZV2fOqeoHtBs3fYGgMATj31VAClLEmg1HoJSLrS8j4Xem2w3hmQdKUze/Szzz4Lna5PZrWqy1DbgNBsv/7664euHC7ppqJz9v7774fMrLnFF188dOpKYlZoJd0sPFZtjUQ3GJCsGUdXkdb2UeiKvummm0J32mmn5XewOaHz8+mnn4Z87rnnAijtMwDQvn37kHnNTJkyJXTjxo0Luci1qNezjk/b7DATU93PmgnH/UPHXLT7lvcc1iAEkvdvvb5YZ0uzF3UvYhsiDZ+gTn+rnNhSZYwxxhiTA83OUsU39bfffjt0WvOJb5KsvA4U/6TO39fK4Rpcp4GEfILXv6V1Cii9VWlNL60uy0rd22+/feiKqJOTdc7ZXFYrHuvbBWuW6Fu3Hn853yT17ZCV7QGge/fuAJJNdNXqqJak+t6U+P/6W/vvv3/ITz/9NIDk+h4zZkzIbGg7I781o/CcakIDEyKAUhV8oFQ/S5MjdE74Hfr/rJ0DlOo3ZQXSFl3TidWbWW8MSF5LrIOjiQRaU6cIS3habSa1Tu23334h04Kvtaf0WqUFTi0B2ryeFuiiK6rr72v18LXWWgsAsOuuu4ZOrxPuKxrorFbjou8VaWhFcVbs1zGpVYf3QrWqzzvvvCEXcX1xrWqT5OWXXz5ktfRvscUWAJKJXHqtsZG0dqEoR0Pov8OWKmOMMcaYHPBDlTHGGGNMDjQL958G5zLAWc2Daj7cZ599ACSbnBbdWoGung022CB0t912W8jqPmLQnbbZUVcKzdv6XdpyYv755weQNI8X7VJRaF5XM7u6wlZccUUAwOOPPx46DSplIHCeY0pzKervs44NTdMAsNhii4XcEJdB2m/p+uRY1bxf7uBLnkttvdO1a9eQtQ4OA9W1toy6v26//XYAwAorrBA6bcjLBAutg1SkSwJI7i8MwFeXmbYuYSC3jr9oVxjrTKmbRBsGayA950+PWZMy6KrVQHd11fbs2RNAuvux3Ohv/vzzzyGztQlQctWrS0wD0Tl/2tpEkw6qxf2ne+IXX3wRMs+/3jM0PISB6uq+ZfJSUXDe2OwYALbaaquQdayDBw8GkNx/NemJ94ciGkITW6qMMcYYY3LAD1XGGGOMMTlQs+4/NQmqe4SZbmqSPvzww0Om+6zoNhhpJkk1f2qdKnX1sc4K29UAyTY7zJrTjCml6HE3BjXrU55jjjlCp5mOlXK16G/SvXz00UeHTjNqFHWlkLRj1nlSVzDb1GjGmdacKcf4uVbVDXbEEUeErG2EWDNM5+frr78OmTXjDjjggNCpK5HjLsLNkrbOgGSmLTPd1OWsLTOYfVlN1xnXnK5Z3T90r+BeqvuT1gxiS5fx48eHTs8F9+Wix58V3kC3oGbM9u3bN2RmtTJLuprQNannXFuS0UWvNZ90z+G5SGsXVTQ6T5rRqDULWX9LQ17uvvvukOmKL9JNa0uVMcYYY0wO1KylSp9Etbo034Q7duwYOgbvAaUn4KKDR5U0SwAD7oBkRXE2bGVAKZCs6cG3Ej0/1RSI3hj0rXf48OEAkg1DdaycVz2XTSVtftZdd92QWVNMq4irJUDXGv9G62wNGzYsZFoFnn322dBpTaouXboASFbEb9WqVciVekPTRA+t6UP0XKlVg02ZV1llldDp/BZtoSKvvfZayDvuuGPIrKOmTdq1Nlg17SuE1kOtzafWGe4pQGnfYT04INl8nd0DllhiidDp+amWvUYtxZo08OCDDwIoNW4HknsJz4tW4a6WMek6VUuN1kxjIoHOmXpqaFU/44wzQleN41O0zhiTCtQ7o90XuH8UOSZbqowxxhhjcsAPVcYYY4wxOdCiKDPZtGnTGvzDGnCnrWf22GOPOn+jwWtqyk1rSJwnrVq1agE0bnxZaFA+m2NqIPuWW24ZMs275R7f9OnTK7ZwdPw333wzAOCcc84JnbbJYND2gQceGLqGtK5p2bJlCwCYOnVqnfHp96ibqn///gCSLjutnaJBl4MGDcL/fX/odF3ze9VVo/NLWd2/DXE5tW7dOnN8eaLuP21oO2DAAACldhJAvg2xOb6GrE8eq7bb0UQAdS9cdtllALJrF5V7P+X6bMj+wvFpPabOnTuHrHWO0q4Vtj4BgIMOOghAsuGyunKbOn7uL5MnT27SF+meoYkedHvpNXXwwQeHzJY05aqzNfPMMzf6+tNratSoUSFrTS3e37SJcqdOnUK+7rrrACRDSvJcv7z+GnP/03Oute9WXXXVkFnfjvXEgGSduHKHD3B9/h22VBljjDHG5IAfqowxxhhjcqAm3H80C6ppj/UqgGRLGroCr7322tBpm5pyj7cc7j+FJmA1BVeyC3cR7j8dK7OPtA2PZo8xq0drHzXEJPx37j9FTdX8fXXpaUZRWsuTLJck509rCtGkr//fWDN3pdx/ih4rs/80e7Ah7tn6mFH3n64pZpSqS2ujjTYKeeDAgSGzvUlRra0a4/7j+VU3MVvXAMmx8G91H1H3NOuPqUs7z5pUebn/FB03ax7p9VXJ7NmmuP/Upan7y2GHHRby6NGjASRrHh511FEh05VbLpd1Xu6/X375JWStGcZMUw3vqGTGrd1/xhhjjDEVwg9VxhhjjDE5UBPuP5o9J06cGLrddtst5BEjRoTMlhGakVLJgoLldv8VTRHuP4Wm3ltuuSV0OterrbYagKSpvCHMqPtPodk6q82JXmMz6urSz2TJjaEI95+S5l7Kkxl1/6lLixl9bMECAI8++mjImv1WdPuVxrj/SNb6bIj7tdzFFcvh/ksba57XVENoivtP0THVt9eljbXc11+5st/Lffz1YfefMcYYY0yFqAlLFdFj1ZorGiDMOkV5Br82BFuqKoMGyqa1qWnC9xZqySk3RVuqys2MWqp0f2CTXQ3Y1jpg1dLGA2iapaoWKIelqprIy1JVrZTDUlVN2FJljDHGGFMh/FBljDHGGJMDhbn/jDHGGGOaEzPV/yfloeiYnHLBmAePrzb5p4yvucc8NPf5mzJlSrMcX5s2bf4R67O5j6+5r8+/w+4/Y4wxxpgcKMxSVW6ysv/SWt40R+qrQ5Pl9q12d3BaTahamsu040+jqDo6xjQHqrWOk2n+2FJljDHGGJMDzc5SxUrJWrtKZTLbbLOF3JysAnwr03H8/vvvIbOhrTaZ1rc6rTRdLejx8fi1HlVaw+Gi0bdjtaT98ccfiX+BZJVuNnedddZZQ6fjq2TzUGNqCb3mJk+eHHKfPn1CvvvuuwEAa665ZugOP/zwkNdbb70631Ute4qpDWypMsYYY4zJAT9UGWOMMcbkQPX5ehqBmmdffvllAMADDzwQurfeeitkulqOPfbY0O20004ht27dGkBtBT//61//Cplupbvuuit0NHkDwJgxYwAAW2+9dejUVH7xxReHPPvsswMo/lyoS/L2228HAHz11VehO+OMM0Iu0lSvbspvv/025EGDBoX8xRdfAAA++OCD1L9le5RFF100dKecckrIHTt2BND4htHlQMeta5E0pgnxjAQaV4srNC0pJCtRhNdSua+ptPPX1CbKKleTS4zj++2330Kn18ywYcNC3nzzzQEAY8eODd12220X8uOPPw4A2GCDDUJXdBPtfzppe0qWezYt0aDS96/q2ZmNMcYYY2oYP1QZY4wxxuRAYW1qmlrxWM1/t912W8jHH388gGTGm46Rn2vZsmXo9t9//5D79u0LIJkd2BDzYbkrcqe5F0aPHh3ygAEDACRdftOnTw+ZZm09Jy+++GLI3333Xcjzzz8/gKSbpVIVx3V8an7v0aMHgKR77MILLwy5qS6hpoxP1+S7774b8mOPPRbyPvvsAwBo06ZN6NLG+s4774Tu1ltvDfnqq68GACyyyCKha8iY86qonpXdSFfnuHHjQterV686n8vad/j/OufvvfdeyBMmTAh5k002AZB0D1RqfepvMiMVAEaNGgUg6d79+eefQ95ll10AlK4toGEZt39XUV3X0S+//BIy3V9vvPFG6H766afUz6Wx6aabhtylSxcAQNu2bUOX5z2kMRXVefwaxsB5AJJ7xXzzzVfnbw899NCQR44cCQB46qmnQkeXPNB0V1I5KqrrWuReoNdP2v2vIRnfDRlzUyqqp2V5A8m5+PHHHwEkry/Njl5xxRUBACuttFLoVl555ZCbulZdUd0YY4wxpkLUbKC6PtXqUystVPomuMcee4S88MILAwBWWGGF0B100EEh860k7e26KNICTF944YXQHXjggSHzDVSfyHX8tMr17NkzdPompm8tRQaj6jmfNGlSyMOHDweQTC6oFvSNrlOnTiGvssoqIacFXSoc94ILLhi6gQMHhsz5VUtVpdB1qNbPm2++OeTzzjsPAHD66aeHrr7rR8/JlClTAABDhw4N3dFHHx3y2muvHbJaUCoFx6KJEmeddVbI999/P4Dk+VGZljy1PvLtGmiaJUTnZ8iQISEfc8wxdb5bLQH1ce+994a81lprAUgmX5TLajWj8DfVYsHj/Osx8RzMMcccoTvnnHNC7ty5MwBg8ODBodM6VkXA48+6jj7//POQ77jjDgDADTfcEDoN4Of9T+t07bnnniFvtNFGid8Ekue1IQkODUX3AbXu6/0treakHhM9UO3atQudzuWSSy4JoLzB67ZUGWOMMcbkgB+qjDHGGGNyoKbcf1mBbN9//33INP/RDQEA3bt3DznNPM3aJEDJFai1SzTorVI1L9TUq4HIrD917rnnhk6DTum+09pNaj6lKVgDflmP6q+/WyQ61+pqoZ4Bs0B11cwhWWbytKDytL+95pprQl5qqaVCXnbZZQEUUztMXcOvvfZayL179w55zjnnBABsttlmoUtby2rq10DuM888E0AyeULdZ9tvv32d4yl3vSo91o8//hgAsOuuu9bRAaUEl3XWWSd06j5heIIGT+e1fvV71l9//ZA5F+pS7tq1a8g6Pp5TbaNElyYAPPHEEwCSrV+0tl2R6Pjrqy2l14+GP9Bt//bbb6d+bxHw+tE5YcIKAPTr1y9kzp+69DQUhqEUn376aej23nvvkLlW9PzovVRd1Xlfd3qe27dvH7KGelDfoUOH1M8xVELrkI0fPz71e8tFddxBjTHGGGNqHD9UGWOMMcbkQE25/9RMrW1YtCXNlltuCQDYeeedQ1dfyXrNzqJZn/WeAOD6668PuVWrVqnfmwdZtX9eeumlkJkJpXVWNNOMbqPVVlstdHreaApVV462SVG3ajkzPbLgb2aNn65KnYdqp742LureYqbVnXfeGbqHHnooZLqSKun+4zGzRgyQzHhTtwTrMGl2Ytp1oudBa3oxq0y/84QTTghZ3VblPAc6Z5o9xUwxdflpHRxmPWpIwtdffx0y65Opy70c7r9lllkmZJ5TPefqklQ9s6s0pOCmm24Kmedc60DVInqutGYc163W9GJGKlBqY1ZJlyDP+fnnnx86ze476qijQj7ssMMAAHPPPXfo6ss4fvbZZ0Omq01dolqzsZyoO1GvKQ2FYHiP1pnUe+EjjzwCIOnerG/8eWNLlTHGGGNMDvihyhhjjDEmB2rC/Ue32A8//BA6NUnTJAuUsoeYhQTUnwmiZke6F26//fbQacsNzcTKK/uB41Mz5lVXXRWytmHh32oXdc0EWX755QFktyl48803ASTdK1oIr9Km0iz0+LXQIDMxq6VIaRZZmao8/1988UXo3nrrrZDZXkiLu2qmWH1rOS/SWudokU/NjlpuueVCZlbqLLPMEjq9Tri+Pvnkk9BppirPlRb2PPHEE0PW7y3nudDxqyvs6aefBpB0GTEjEyi1hNGCrVpc+JRTTsn/YFNQ16geK9Eiirqv9u/fH0DS5az70oYbbggAuOSSS0KX1ialltDwBxbS1Ixvvb8UsdfwnN53332h0+zSI444IuQFFlgAQHabL2afqkta3X90q+21116hY8FQPZZKUt/5V1c73baava/XZyXCJmypMsYYY4zJgZqwVPGpW4NDX3nllZDZhgFIt9TUR1p9DDbe/Ov/54W+SfD7tR6M1gbRtwNaqK699trQsfQ+kAx6TvstvomppUqf6medddY6x1VJeKwaHMzWNACwxRZbAGhYE9oi0HOulgBaQnWe1PrCAHxaPIDkW3Ol0ONngPpll10WOn3j05phtKrp/2tQKdedtgbRhsm0BOv61jo7lbLU6drX32f9J61t9/DDD4fMa1U/T+sBUApQ1/8v93XGc6YJN9qwW4N6aUHMSprh8WvDeq0jx0DvrM8Xga5lHpcen3oiaOnQ/Vf3Gp7LSu6N/P1u3bqFTmuDbbXVViGz/Zpat9Uqzmv5yy+/DJ1arbbZZhsAydpzaoks0lIHlPZNXbNXXHFFyGwkruOvNLZUGWOMMcbkgB+qjDHGGGNyoLp9KP8HzcfqJlAzpLqvGJTZ2IA6moXHjBkTOjVva9BbU4L21KTMoHgNYlX3kAYlsj7XPPPME7o087qabL/55puQn3nmGQBJl5MGJWpQaxFBiTTVq8tM66SwjoqOr1IuoYaQ1eX9ggsuAJB0mWnyw0cffQQAOPTQQ0O39NJLh9y5c2cA5XepqMuELhFtJ6Pnn7W1gFKgObvdA8mkihEjRgAAnnzyydDNNddcITMBRcdcxPxmzR/rUOkxacse6rWdx+GHH17ne8vtRlH3FteU1jmaOHFiyFrzTeciDbqld9xxx9BpqMS+++4LAOjRo0foNBGmUq7AtPAKABg5ciSApHs9LShfg9d1L5p33nnr/Fa555JjUZccwyCApFtXkyqIzm9a0peGFzABQffcIu4D+ptah4tudz3nmnTB+6omeml4zAEHHAAgPUwmL2ypMsYYY4zJAT9UGWOMMcbkQE24/2gK1CwwdV9pdk5jTLHqyvjggw8AJF0deZl39Xe0tgbrME2YMCF06v7Qmjdt27YFkG2SpXlXzd/PPfdcyEOHDgWQbM2jLW2KhsfNek1A0nzL7M6iM4rqQ9eMugzYckWPX/927bXXBgCstdZaodM6XawTVO46XWnHpK0x9FrUTDj+zY033hi6xRZbLGTWnJk0aVLojj322JDXWGMNANVV70jPBV3xvXr1Ct0OO+wQMt0KbJcFlK5ZoHLrVn+HGc377bdf6LR2ml7/vL7qW1P6/ZqJzbWqIQeaSafhBeV0m+n+p64+1nRaYoklQqdrmXvNo48+Gjptk7X77rsDAI488sjQaXZrOa9FveZ5Tf5VpvtZz7POFduvaZ051nYESmulyNAPIOle/+yzz0L+9ddfASRd8vq3nB8NaenQoUPIlRiXLVXGGGOMMTlQE5YqorWLNJBOK77OKGo1UgtRv379ACSDL9u1axdyY940+QSub4d9+/YNWd/0yLbbbhsya4/o7+tTvcoMXtwRdwAAIABJREFU2tOGvGeffXbIfIPRJrVq6SvCAqRBtWz4rMefVhG6muAbpJ67LEtUfUHX/JzWWdG3/kqhx8/rq3v37qHbe++9Qz711FNDZv0jVo4HkhX/v/vuOwDJhI+ePXuGzLf+arJUpVXH10B7rTjesWNHAKXGttUArYNqMdIxpQUyNwS1qrKhtiYnrL766iGrBSFvq47u6bqnakX7tEDszTffPOSTTjoJAHDggQeGrk+fPiGz+r82HC7nmLLI2qc5f3r9aJ2qSy+9FECyYbHWuSqyO4X+tlZRZ3IWUEog0Jp5Q4YMCXn//fcHAGy88cah0/uuK6obY4wxxtQIfqgyxhhjjMmBmnD/0aTJIEogaX5X993cc88NIGlKVJM29Rq8ffnll4f8xBNPAEi6NNT91xi3BE3t2hqGv6P/r2ZYmqGB9JYsOj4N+mVzXv28uifowtHaXlnfWyl0flhnRevE6LHSVVFNTZRZe2nBBRcMnbqP6zM56/inTJkCIOk+06Bouscq6aZNW/PqatGxbr311gCSiRDaiJlrVVtLaSJCtdQcy6pzxAB8baOj/8/6YroWqiWpQt18SpbbekbR/YltrnQe/x97ZxkuVfWF8dfn+RMmNraCgYWgWISFiomJhWKB2NjdighiYzcmBrZiB4piYGGC2NiiqCjhh/+nd8174AyXe+85c+Ze398X1rO4M7P32fvsmbPyt99+q/V71gbePwwdAJI1ndRVvd566wEo1SsCkoHMPXr0AJBMLmBIiKJtYjQpgd8/QLHrrp993XXXhczz9e677w5d0bUJa0LbPHF/aT0uPWsYKlNpl59iS5UxxhhjTAb4R5UxxhhjTAY0KPcfW3QAwODBg0NWUy9NtZrdwc7rQKlNi2YksbM1AGyxxRYAktk7at7OKvtPM7roStHaKVp6f8KECSHTLcTWE0DS/UlTrman7LDDDiGzFY7W+agW94Si2R8dO3acRZ9nm4E5Qd1DzKqaMmVK6G6//faQ01yBes3VbaFuBaLZVdWyVurySnO1jx49OnQ6P7bnoZsFqJ45KerefPvtt0PmWmsmsrZk0XlVG1m4zLm+umaaXcZWOHov0GWTFxyTnuMffvhhyKx9BpTqS7EeIQDcf//9ITPUQ89qdc+zTZHWvvrkk09C7ty5c8hF7GvuW61DpW1s6J6uxjOlHHr9+f03cuTI0GlWcosWLQAUOydbqowxxhhjMqBBWKr4hKVPAdp8+Nxzzw2ZT8j66/ann34KmYHAWttqyJAhIfNXr1pK6vurl+NX61m3bt1CZp0NNpMFknWa0oLS1VKjzVv5BPL000+HTq1WtLBU69MJ56qWIK34XC3j1vGddtppAJJNkjU4Nq0+0AMPPBA6faqkVUurl2vF5mqZv6L3Gvfn8OHDQ6eJEm3atAGQtF5US9JBWsIEkKxZxLOkU6dOoTvnnHNCZqPzalyn2qCWOt3r7DSh+1MTfWhh79u3b+jYBB3IZ615rTW4XJvQX3PNNSHz3FXrlFqy0tZNdfPPPz8AYNNNNw2d3r9a3ZzXrVINl4GShTDN4g2UrKoanF4tySFzAq2RaknU7780S2qlsaXKGGOMMSYD/KPKGGOMMSYDGpT7TwPGtc4Ng9OAkqlXA0m1DQHrx7CxJpCsU0LzYZYmW76X1okZMGBAyDQ/a+2sUaNGhayvY9A5G0fq64FSyxl9TX3r0OSNXmu6SLXNgLovq8VVpNexXbt2AJK1xzSRQl1FTEbQNhG6F7faaisAyUSCaqwdo6jb7KuvvgKQ3L96f7KOlbo0i3Y/0H2i42A7E6BUhwwotVy59dZbQ1eNNalqQsMH0tzLY8eODZ3uazZkf+GFF0KndfxYH2+33XYLne7lPN1/WiNKG3qPHz8+ZNap0lCMutxfdPkDSVdUufpmeaKu2hdffBFAMrxAGya3bdsWQPH3XE2ktYYCSkkj+v223HLLhVwN3w+2VBljjDHGZIB/VBljjDHGZMBcRZnLZsyYUa8PVpeDmtzp9lOTrmby0YWouizdK02aNJkLqHl+6sqkKVazpLSljZpCabaeZ555QqdryGuR17rO6fxqg86P41eTbyVratVnfmqG17X8448/Qua66/qlzS/v9Zs+fXpmH6B7mW6jjTbaKHTq/mRWYJbZtUrTpk1rvX7cf1obbu+99w5Z69zde++9AErtMIDKuvy4flOnTq31/PSeOuuss0L+/vvvQ2Z235gxY0KnrsJll10WQMmNCwAHHXRQyFprj9RmLzdv3jyT/an3on5X8Kyv75rpmZV2fpWD+7O+89PP1H27yy67AEjW6Xr33XdDXnDBBQHkd75wfrXZn7XhiiuuAAAMHDgwdJrpzrCKvO5J7s/ZYUuVMcYYY0wG+EeVMcYYY0wGNFj3XznU1EvS5lhN7jGacsuZlBWOu6gsozzcf0ratSjXEiUPsppfTWtZyTkpebj/0opmavFazU7t0qULgPz2b13cf0Tn8dJLL4Ws2X3MFC4qI7Mu7j+i+0zbfLzyyish05Wr7jNmzAElt2fLli1TP6O+65qV+69aycr9p3tV3dMsVHvppZeGTtcv7++NPNx/OtfJkycDSGbkahsz3bd5YPefMcYYY0yFaHSWqqLJ25JTNJ5fwyYPS5XCp8pyTcjzro9TH0uVouPXM7LommH1sVQp+kSvctr3QVqdu7y+N2ypqj2///57yEyQ0dp+lSTvQHVa/XXPVrLmli1VxhhjjDEVwj+qjDHGGGMyoDD3nzHGGGNMY8KWKmOMMcaYDCisoXJjD0T8999/G+X8/ve//80FANOmTWuU82vWrFmugZZpaMkFBkhrcHCWwdEMtGzsgfjenw2T/8r+9PwaJpzf7LClyhhjjDEmAwqzVJn6kVbkFCiuKGjWlCt+Sn25WMCGEiOo66d9HtlbrkOHDqFr27ZtyI1lfY0xpjFiS5UxxhhjTAbYUtUASLPasFw/kLReLLDAAmVf0xBgUTct6KZd2Fncbt555w1dWkySWoKqyXqVti5vvvlmyKeeeioA4JRTTgkdO6+b6qFccdM0S2La/lR0r1fTXq0P5dqFFFE8Va8p10LPB10z/m1N56e+p76Xvo5zbahnsakbtlQZY4wxxmSAf1QZY4wxxmRAo3X/qclVzbNpAd5qyqUpuJoCgqdPnx7y/fffDwA4/fTTU///ggsuAADstddeocu7c3dd0PXR8X355ZcAgBtuuCF0H3/8cchvvPEGAKBr166ha9asWcht2rQBABx66KGp/1803Gu6D1ddddWQF198cQDAPPPMU9mB1YM83BvV6gbjuN55553QtWrVKuT5558fQNLNR5c1ALz22msAku77zp07z/J6/ayGyNixY0OeMWNGyOrKztMtVs49x7H89ttvoVtkkUVS/3Z276t/99dff4U8adKkkJdddtnaDrvqSXOlmiS2VBljjDHGZIB/VBljjDHGZEBhvf+yrKieZobU2j/PPPNMyE8++SSApBlzvvnmC7lnz54AgHXWWSd0tblGWVVUV/PyhAkTQt5qq60AALvttlvoRo4cGTIz5V544YXQqUuhvm7NrCqqf/fddyE/9thjIV977bUAgI8++ih0c889d8hNmzYFkLw+6v6knusMAOutt17INc0/74rVaXv1pJNOCpnu3VdeeSV0Sy+9dMj1zZ7Ko2J1WqZlTXXUymXM0RWs16k291/eFdUfeeQRAMAhhxwSujXWWCNkurfoxgWS9y/rkC222GKh0726yiqrhJy21nnsT73WPD/0s/X+q+n1f/75JwBgyy23DN3aa68d8pAhQ0JOC0vIu6L6Sy+9BCB55jBkAkjPzkxzJapL8+STTw55/PjxIT/66KMAkvs774rjadmLaddZ1zft/tIxl8tuTKM+8ysXplLT/V/TmNIyMuv6u8cV1Y0xxhhjKkSDDVTXX89ax4hWqYEDB4buk08+CZlBhTM9PYQ8fPhwAMlA6c033zyrYc8xOj4NeGRNIw2IVEvcUkstBSD5q78aA15vvPHGkC+//PKQl1tuOQDJQHO1BCy66KIAgHbt2oWud+/eIX/44YcAgClTpoSu6IBK/XzKb731VujuvPPOkI877jgAwBJLLBG6akqaILq/fvrpp5CvueYaAMCmm24auqlTp4bMAOYxY8aE7tNPPw35jDPOAADsuOOOoaur1ao+6Gfq+LlWev5ozTTOTwOheU8CQJ8+fQAARx11VOj0/i6ijpNaegcNGgQAeP/990N3yy23hKxW/bTXc/14HwLJ+zOPpJm0PUGLNgC8/PLLIe+5554AkokuNQWnp50fDz74YMjXX399yJdeeukcjDg/OFatffbee++FzL08evTo0P38888hM6mCFlkAuO2220LeaKONQtbPqA9cPyYpAcn1U5lWU/VEqdUwbWy6P5dcckkAQPPmzes56vLYUmWMMcYYkwH+UWWMMcYYkwENyv2npuM//vgj5P79+4c8dOhQAEkzuposGbTMekZAqXYMUHKlaeuQTTbZJGR1FVbKFaHBkzRlH3300aFT8y1N7TUFlxbNgQceGPI222wTMs2zGpyt5l+aetVl9sUXX8zy/jr/ot2f6l6gW4huPiDpiujbty+A5JrXFEhaqfnp/afuZ3VlMRD74osvDp3WaVp++eUBJO+pzz77LOR3330XQNL9VzR6fXnunHDCCaE7/PDDQ2YoAgO2gWQdJJ4f5dqkVApdS9Z+A0queD0/NWli2223BZB0iWkdObqNVl999dB179495KzmXVPrmQ8++CDk/fbbL2S6hfT8SQuV0PfXM3/UqFEAgIMOOih0q622WsiaQJTnfVmuXhTHqiEhPXr0CJn3or6mZcuWIa+//voASm5SIBmKkMecuA9OO+200L3++ushq6uO4SGa6KT32kILLQQg6RL8/PPPQ+Z9q5+VNbZUGWOMMcZkgH9UGWOMMcZkQINw/9Gsqxk1an6/5557QqYpc5999gndkUceGTLNg2oq/vXXX0Omq+nYY48NXU2umEqy8MILAwB23XXX0GmmznXXXQcAWHDBBUOnptxqgWZcAFhhhRVm+X81T2umB91LJ554Yurf0u2kdcaKcK+k1UYBSpk0mvF28803h9yiRQsAydYXEydODJlzWWmllVI/K6v9mZaxqC53rc1z3333hUz3B91EALDhhhuGzPpMuiYjRozIZMxZklZ7CSi5f9S9qdl/PD/KtZuhXHRGp2ZfHnHEESEzU2q77bYLHV1Cil6Tww47LGS6lwYPHhy6rDJZy7m8eJZzbQCgV69eIev3Bs9HzehOu2f0+0HDK0499VQAydZXV199dcj8fgHyzeTU+es1ZfbtueeeG7q2bduGvPvuuwNIut9bt24dMvevhlzotdCsuqyyqul+ZY1CIFnbTbOLCc9JILl+nIu6tDWUgJm2ebrfbakyxhhjjMkA/6gyxhhjjMmABuH+o8mRplcg6XLQlhCXXXYZAGD77bcPnZop+V7qMjzzzDNDXnHFFQEkXX5FFB8sBzvaa0bj77//HvI555wDABgwYEDotGUEM5GKnkc5kyuLdmqbGi0+yKw/Lah45ZVXhsyik2mtUyqJfv5XX30V8iWXXAIgmf2n2TecK92cQLJQH83y2tpEC6Hm4XLg9dPrfNNNN4V89tlnh3z88ccDAOaZZ55ZXg+UroteEy3UusACC2Q06uxQVy3dY7p/J0+eHDIzlarpzOA1/+abb0Kn2Ws6P7rqtHWL3muctxZUVlcLz90uXbrM8vlAdvtTM/ZY3FJDPn744YeQNbyAbi99fdqYdM103zP7WsND1L2WlpWbR/FhvaZ6L/L+Y5FkALjwwgtD5lmh7rO0Mae5rIF8CylrYVk902q6l/T/eX/qNdHscro/88SWKmOMMcaYDKhaS5U+STzxxBMAkq0BNDiUv86BUoCs/qLVQHQGmA4bNix0aU/S5X6pFw3Hok9XGhxJC8hTTz0VOq35wSfJItphKPqk9fjjj4fMOjlqqdIAaQZoa50qrYlT34aZ9SHNIgoA5513XsgMpDz44INDd9VVV4XMANOOHTuG7phjjgmZ1+qdd94JXfv27es99jlh3XXXDfmiiy4KWes0sU5OuYBWrotaUjXot1u3bgCKr+OkY1ZLDOufaaKMJlIwwFstkVrnqIi5MHhc241obTetA8RzV9ut6FlLXn311ZDVKjlu3DgAyUSGTp06hbzxxhuHrOfWnKDeA03O2WWXXQAAP/74Y+jU4qmJHqxjqOuj78t9p9ZhTSRhoLMmP+n103N1Tq06c9qEvNz76VrwvXRPak1DzlVrd2kbIe7VSlmnlLreG3p/PfzwwwBKjbMB4MUXXwyZeznP7z9bqowxxhhjMsA/qowxxhhjMqBq3X9qfqT7SttdqBlZa46wvczzzz8furvvvjtklrdXk6+aHemWqabaVDWh46dZU4N/NahUA/irBXVFjB8/HkCyzo+asukKVPO81mxSt3GlUfO9zknbfLBOjrrvGLwOlEz1mjyhpmq2cdE2PnnszzTzv95nW2yxxSz/D6S7KlTm+DXRZP/99w+ZLT+KaMOj66eBzprUwrFwHkDSLXr77bcDSLbJ0Jpq6qrIE70Phg8fDiDp0iuXiMOaTpwHkH799f11rb799lsAyUBhdZ+pW5Au1Dl1+5SrXcezQhOZevbsGbIGKg8aNAhAsvbR1ltvHTKTnjSkRN2HdNUvs8wyodPx18VVxtfo95u+j7rHia6JJh0w/EXXV8Mn+L3IhKaZ/7ZPnz6zfH41ovvv+++/D5kJBHvttVfo1lprrZArEfZiS5UxxhhjTAb4R5UxxhhjTAZUrftPadWqFYCkGVQzcpj9AQBff/31LK/X7Ay+h2YnaR0TujXyqK1SjvrWM9Gx0n2maE2rakFN5mqqVVM90TYQdCUMHDgwdGq+X3LJJWd5/7zhuuk+ufXWW0PW7CjWmerXr1/otI0CXUXq/tTsHro6dU3znmtN+zPt88tlQrKNhprv9VrQFVF0dqq6YrRlELMy1T273nrrhcxzSWsmaajCZpttBiB5TbKinPuZGc/qktTrn+beK9emhGutbsytttoqZLqf1D2mcy3nNpsTdPzaOoeZXnrP6Py0phRdjkOGDAmdni/M7iyXvco6SFnC99d6WFobbO+9957lNXrtNLsy7R5VHd9LXdra0oZrqW3Eim6plIaOiRnjqtfszkqH79hSZYwxxhiTAVVrqdJfovx1rcGxY8eODfnjjz8OmUFpa665Zug0qLRv374Akk8c2vw1reFrHujT31tvvQUg2QRZg69rMxYG2GpF3TZt2tTpvSoFq7wDpXFr8KTWQWLSgT4pFx1UybXUxqvPPfdcyKxtAwCPPfbYLH971llnhcynba2YrjWt+KSt1tdKremcPPFxLdKC0wHg2WefBZAMJK6Wp2K9J3VM+lTPjgta/VlZe+21ASQtPWpp1GD/rClXxX/SpEkASs3YgWQXCrX0suYbz0EgmehDmZ0dgGQjXM67pppLM8u1Rfci7xnVqaWJwdcAsMEGGwAArr/++tDp+vJ1eq1OOumkkNOsRvWF94oG359yyikhc6107+j5p3OtqTk0P4vfOUCyplelEinqCsev1uM77rgjZCb60LsFVP5MsaXKGGOMMSYD/KPKGGOMMSYDqtb9p9CkrCZ5ldkaAiiZB9UMqjVXpk2bBiBp3u7Vq1fIRQTKsnT+jTfeGDptbZJWM0tNutpQme1bNHhR3Yq5lucv01qE+nJm2LQ6L1wnAHjmmWdCpr4mk3cl4edrQLoGmmryBF2Buqba8oU1ZR599NHQ7brrriHvvPPOic+cWa4W1L2ugaQ026tLRSliLrwntJ3TOuusE7I2d+Ve1ftIg6JZp0ndE9rmJc/56T3BxsEAMGrUKADAL7/8EjoNL9AAb95/GlKhbT44Vw3F0AQiXpc8XC7l3Pxp17Rcm5UOHToASNahYh0voLRuWk/rsMMOC5nXuNz86hKKwPc67bTTQqfhK0yKoOscAA488MCQV1lllZB5rug4dK+yjYvWDuvfv3/IRST61AbOT4P61WXJ9jtFhoTYUmWMMcYYkwH+UWWMMcYYkwENwv1HU+6cmM7pavrss89Cd8MNN8zyd8wCAZJ1qirl9tO58PO1s/YjjzwSsrp/aH7XTBFtz8BMI63jlLdLhSZxzRLSjvGs2dOyZcvU1+v4WB9IM3K0JhDXV90bLVq0SH2vSsHP1IywfffdN1Vmduavv/4aOq2Ts8QSSwBImue1DhBN3dVqnuf+pMsJSLoy6UrRjM8i5pJWR0szrrSNjrp1016ve50uHM2u69GjR8iVOl/0mrKlUbkaUWmuzGHDhoVOW7ow63TDDTcMXTW6nxVdK7r3Bg8eHDq25gGAnXbaCQCwxx57hC4t1CBL9xLfU93Iu++++yzj03pSd911V8h6PjCTU9dEs2+5rjo/PZ+q8VzRsBKu3wMPPBA6nQuzx4usc2dLlTHGGGNMBjQIS1Vd0IrWGsjNoFF9Ki3XXDlP9EmCgZ5aA0WrTOuTIoNmNVBPaxpxXmxMO/NnZYU+PbDh6BVXXBG6jz76KOShQ4cCSFYB19frkyCDhceNGxe6lVdeOeTTTz8dQOmJEkgGKhZpqdKnI3161DpTbP6pe27VVVcN+YADDgCQtHRkVdsnL/SpnYkEWrtI6+AwwFbrOOVRXbw20ELAIHOgVA8MSDZEZv0ibYh91FFHhcz6YwMGDAidNr8u4gm6Jku/rh+D2bW2liYd0OqsFc2rfU8qtKDef//9odOaRueffz4AYKGFFgpd3muWllyl90Tv3r0BAN27dw+dfr+pVZgeCh2zzuWCCy4AkOziUETNu7pCD8ann34aOtb+A9KvZaWxpcoYY4wxJgP8o8oYY4wxJgMahftPXUl0Gz311FOhU1Mw3S6sx1ENcHxsoQMkXQYaiM75tW3bNnQa1MyGxGm1rbJEzcQMgNVxqCuQdaa0Xli5OipsqaPB22xCC5RM9fr51RIoq+NQl6QGxaa5JdLce3pNqmV+5dC99uGHHwIAnn/++dDttttuIbdu3RpA8Q2T9Zpy/Fonju0uAKBr164h05Xy3XffhU7rwLFhtAanV7tLRQOk6VYZM2ZM6HT8rGmlr6lG9D7TpB4Ge2twutZpoitemzeXq3mVNTW9tyb6aB0tdc8yEUbHrIkWaW3Y9F4suuUXKdfE+umnnwaQbD2kLdmq4V6zpcoYY4wxJgP8o8oYY4wxJgMarPsvrc4MUMo60tocWj+oZ8+eACrXOmJO4Oery0iz27Q7+dSpUwEAc889d+h0fjO/ZyWg+0Tbeaj7bsqUKQDmzOXDTEitPaUU7TaaU/T6qyuhsZCW8QeU6udMmjQpdN26dQuZe6XojL80Nt1005Cfe+65kDVTjG0+OnbsGLrjjjsu5DXWWANA9bcRUnR8dO9pHT/WTgOAddddF0Ay5KLaUVclsxe1NRl1QOlerZTLrzaU21Pqfmf7Nh2z/m2ae6xa5qek1RYDgBEjRgAAHn/88dDp92Y1nCsN584wxhhjjKli/KPKGGOMMSYD5irKND19+vRcPvitt94CUMoSAJJtaNjyRQueZXkNmjZtOhcA/Pvvv5m9aU2m9kpmPPzvf/+bCwCmTZs22/mp+bY+ndsrTbNmzeYCgKlTp1a3z6aONG/efC4AmDFjRr3mpy4VdfUxO5NuIqDkMgNKmUh5nTtNmjSZo/1ZE3V1b+W9byu1P8vNvzYtw+pCVvuznPsubV5pmcR5ucS4P+s7v2olq/npOmkmKsN3Ro4cGTp1T+cdHsL5zQ5bqowxxhhjMqDBBqqXgwGWnTp1Cl1a+f9qDx5VqqH2Rm1pSIG6pvbontRECbYZ0tYYaQ2Jq52GeM9lSUOffzlLU03zqsag7f86epawVY8mMlXbXrWlyhhjjDEmA/yjyhhjjDEmAwoLVDfGGGOMaUwUFlOVV/Zf0TD7r7FndzT29ZsyZUqjnN+88877n1i/xn7/eX4NE84vy+zwaoLZ4Y19/WaH3X/GGGOMMRnQ6LL/TONDa5akZefU1IbB5EtNdYDSMkEbatgB51quDUhDndd/mTnds8bMCbZUGWOMMcZkgC1VpirRp8fffvst5AEDBgAApk+fHrqzzz47ZNY0aUwWK61eTgtJ0Y1D1VKja9G/f38AwFNPPRW63r17h7zffvsBSHY0qPa10oa1bB49efLk0Glzds7rv27d0P2h10/3bZHXSMfHhu9AaXxaW61p06Yhc6/+19e3aPRM1O+KaqhDaUuVMcYYY0wG+EeVMcYYY0wG2P1nqgqa5bVJ78477xzyZ599BqDkhplZvuyyywBUv3upXMNpytoY9Isvvgj566+/BpBsw1TX5r/1QT/z2WefDfniiy8GALRr1y50F1xwQcgtW7YEAOy4446hKxf0XSQ6Dr3+l19+OQDgpptuCt0WW2wR8qWXXgqg1FgaAGbMmJHbOLNArz/dKnrP1Ob+4Xv9/fffoXvzzTdD7tChQ8hsb1TJNU9zn/fp0yfkN954AwCwyy67hO6II44IeamllgIANGnSJHTVeL40VnjufPfdd6H78ssvQ2Yjd3U5V/pMsaXKGGOMMSYD/KPKGGOMMSYDGqz7r5z7hKa+2nQbT6uzoyZDdcVUi3uiscLr//7774du0UUXDXnYsGGJfwHgzDPPDLlnz54AgE022STXcdYVugrUZTBx4sSQP/74YwDAAw88EDp1n+y5554AgC5duuQ6zjQ040ZN7qeeemrIyy23HADghhtuCN35558f8llnnQUA2GijjUK3yCKLhFzk/aXzGz9+fMh77713yGPHjgUANGvWLHSPPPJIyMw+ZZYqUHJ5AsmzpEj0zPvjjz9C5n2lLs0VV1wx5JpcXXzfu+66K3TMCAWA119/PeT5558fQGXXnGt8xx13hO7JJ58MmaEsU0GRAAAgAElEQVQEdPMCwEMPPRTy1ltvDSA5pwUWWCDkavl+0HGkfVeW+35MW1+9L9LcwrX5rq0LGmrwzz//AABOOOGE0On6jRo1CgCw2mqrha7SmdK2VBljjDHGZEBVWarKWZ/4S1l1Gvw5derUkFlThL9ogeSvdgYY6hOjvv77778HkKw9s/TSS88ylpnf12QD15gWAQDYfvvtQ+b1v/3220One+G+++4DAHTu3Dl0+qRTxJrpvn355ZcBJK1rtE4BwCqrrAIAWGmllUKnQdHt27ef5T2LmJPWadLP32GHHQAAq666aui6d+8e8vDhwwEkrSNqiSwC7o8ff/wxdIcddljIH330UcjnnnsugOT1v/HGG0O+9957ASRrH6mlrnXr1gCKD27We2LcuHEhH3744QCAESNGhE73Yk3vNXr0aABJ6+VFF10U8hJLLBFypa6Bfs4LL7wAIJk8oWu1/PLLA0gGqj/44IMhX3PNNQCAxRdfPHSnnHJKyEV/P6R5anR9OFeuEwD88ssvIb/33nsAkrW5tttuu5DXXHPNkNVaW2m0Np7Kv//+O4D8rWezw5YqY4wxxpgM8I8qY4wxxpgMqAr3H011asZT992YMWMAAN9++23ofvjhh5A1qJTmdXWpqHuPrjxtfaI1LxhIOffcc4fu0UcfDbljx44h17b+TDmTZG3MxDUFGtb0uRyzuj+15krR8FqsvvrqoRs6dGjITzzxBIBkGwk11U+YMCHxPtWAmt+XXHJJAMnaWnQpAEDXrl0BAAsuuGDo0gJFi5if7pm2bduG/Pjjj4fMdVH3wQorrBByXRJJKoXW23rppZdC1jppdAtqHbSddtop5JNOOglAyQ0NlGqLAcDNN98MIOkerVTwul5zdYk9/fTTIa+//voAgDXWWCN0aXtN97S6chnAre53vX6Votxcr7vuOgClencAcPrpp4fMRJCVV145dFrHap999gEA3H333aE74IADQl522WVDrtS6pgWlq27kyJEhs46cJr8w5AAo7WtNHhk4cGDIG2ywQcgMFs/7LNL3Z/0pTQ7QvVhEzb6ZKX4ExhhjjDGNAP+oMsYYY4zJgKpw/9FkN3jw4NDRTAuUXIHl3FSavUHUfZeGuifUlM+xqMvwzz//DLkubgu6b9Rl+cwzz4S8++67Ayg/Py25Txepts44/vjjQ2Z9JnVTvvLKKyGzpo66zI499tiQK13ToxysYQMA99xzT8ismaMZOS+++GLIzC4rGnXZ/fXXXyGz/s0ee+wROrocFF2HojPF0lCTPGtTqV7/X68F7zt1fxZBmktcM6LU/azZa3Rv6vzUfcI2SRoaoPc63YN33nln6DTTOI+1TgsZYBYckJwfs+LUjZUW5qDvRZc8UGrzcu2114ZOXdmVOl/UDfTcc8+FTFd1t27dQqfnJ88dHae6ao877jgAwMEHHxy6r776KmRmDwL5uv/K1aHivLW2lo6VLjv9flVX2szvAyT3pN63lQpB0PnxtwDDPIC6t1TKC1uqjDHGGGMywD+qjDHGGGMyoCrcfzQjaud6zc6jeV0zD9Q8qaZAuu00O0nNsDQlqktNiyteccUVAIBDDz00dJtuumnIc5rxpyZLuie1tQHbHQDpbj/NfnznnXdCZlYRs4iAZEf4zz//HEDymvz8888h05VJlyNQPa0zgJL5VtsMXHjhhSHvtddeAJKtP7TlRJFZf7rm6jKmywcoZTLq9Ve3N+fHLEGgujIZ00jbP+ryU/cW3SuPPfZY6NS9Uil0rT744AMAwC233BI6LV6pxX/T3Jt6JtAV2qtXr9Cp++/5558HkHSPqfs9D3hWahiAjm+33XYLmdltuqZ61nJdNaORrYeA0rmmBXsrhY5T2yj17ds3ZK77oEGDQjfffPOFnHa+67VYa621ACTP7CJcTuUKZb/66qsAgKOPPjp0mp1KV2CLFi1CV5vzX8NqKtWmRuFn6TXXTEUWEi7yzLSlyhhjjDEmA6rCUsVfnVoCn/U0gJprM7Vr124WXbm/5dMMn06BZFAff4mr1UyfSuY00FItYQxKZQ0tIFn6n/PXz9EnebaOAIBtt90WAHD99deHrk2bNiFroCTRpxYG0i6zzDKhyzt4NK12iD5JpMn69HjMMcfM8nq1BPHpHwA23njjWT6ziIBKtX5qUP0hhxwCINma5cMPPwx53333BQAMGTIkdGrJqYZATKD8kzKvu+reeuutkH/99VcAyafLItDxseWOPoXrmaJ7qaaneq6PWsrVKslG2dpweNdddw1Za3rVZ611frzmeo6oJVhbtjBpR63f2qaHiTK6P7/55puQack644wzQqfXUq1iPCPre39yfdS7cdRRR4WsiSK0emsdqprWNO1apnk/KonuSa25tf/++wNIJo9omySur1rkaqqDV25+Rcyb49Lrr2cpkyKKPCdtqTLGGGOMyQD/qDLGGGOMyYCqcP+lkeYSKmcmTjNDlquTw1pRNJMCwMSJE0OmXtss1CWQW11qNP9ra5W0uehrNt9885DVVUlTp85JZZp1NdC+U6dOIW+00UYA8g9OTwvaVp2693T8HJdeH70u/FutPaPXh243db9WqjaOjnnvvfcOWd0/DLAv555k0O+AAQNCp0kJRbZhKGfuV7cLW5ao+X3EiBEh0/3AemrVQNq8dE/WBs5ba1epq571r1ivDADOPPPMkG+44YaQWdNrTt1jOg+9vxl0/8knn6T+/4knnhgy60xpSzC9l7j/tF6RJhAtvvjis/z/SiutFLJe16zd8tqORfechkfQ1ap1CtNcRXottX0a70V1j2blairnckvbi1rzUOvcMUFJ3Xv6XcL7U4PXTznllJD5/VKNbaSA0rh0/X788ceQ6epVl2ClsaXKGGOMMSYD/KPKGGOMMSYDqsr9V1dzcNrrypkv2X1eMyb0b9mFXmvrzGltqnJjYhuAchlvabqFF154tu+rf6vmaboVdPy9e/cOOa2LeVaoa0rN43Q/6DXXNjpbbrllyOuttx6A8i17ONfbbrstdGrKZtZLEdkfek3LZbfxb3R8at7v3r07AKBPnz6h+/3332d530rWYeGeUZfRyy+/HLJ2sf/4448BAM2aNQud7gXuEZ1/miu0iPXT2nDaekXdJ1yrmq6//r/uZWbiMosXKGUfAklXhraKqS16/ej+XmqppUKn54u699i+SjOxWVsNKLWE0iw+rbPGs07nrOdrHuvKffnoo4+mfo7Oe7HFFgNQPiQgLXv1ySefDJnZm3p/q1yf+1I/U92nb7/9NoBSiy4g6XKnyxUo7S89UzXTm9mL/fr1C91PP/0UMt3PmglbdJ08/XyG0Kyxxhqh05qMaS3rKo0tVcYYY4wxGVBVlqos4K99ffrVOjkMytSnZw3UZE2gLAO56/JLvzav0eBWBpreeOONoatU9V+95tqw9e677waQfDrW5rVak4yNTnVNNNCVQb+vvfZa6PRJmoHQ1fR0VZu/paVNA/knTZoUcpEVg7XeltY80v3FtdKnR33qpqVHa6epJZVP2NpQW+/FrOat70NLhn6m1j77/vvvQ2YduNokP6RZrViZG0jWrNL7lhXe53TO5ZJzWJtOx6zWKQ36pUyLBpBsuNyqVSsAydpHailJSzTJY6+mWXX0nNeK4WeffXbIaVXA095Lm7SzdhxQWj9NHtGaX/VJitE10z13+umnA0jWA1NLv1rqaVXVjhNqvWHNsV9++SV0WhuttskRlUDHwvF16NAhdNdcc03IDz/8MIBkbT9d30rMy5YqY4wxxpgM8I8qY4wxxpgMaHTuP6LB5VdddVXIbASqDT+14S3Ni9XSDmRmaLZ//PHHQ3fPPfeEfOuttwIo7z7JEzWtfvHFFyHTFKuNZceNGxeyBgWzzpQGB2vQJIOJNThfGy7TLLzQQguljqsI0gJ1y7kfuD/V/VL0+IkGUWug7GmnnRZyz549AQB77LFH6HSt6TbUoHA2eQWArl27AkjW6dKA7azqHOn9zQBgbU2lzZWPPPLIkK+88koAyeDfmpJO0moO0U0PlG9+W59aQeVqwtX0t6zzc8QRR4ROXUX3338/gGTwd6XqwCk6ZtbfUvcYA+aBZNA9r7+Gf+j+PO+88wAkzySdK9efYQpAdq5OPafVJcfzXVuXPf300yGfe+65Iffv33+W99K9zkbt2sZHazby+6XoNjzl4LjYjgxIuq+nTp0KYM7a7OSFLVXGGGOMMRngH1XGGGOMMRnQ6Nx/NO/ee++9oRs+fHjIbBOhGWfaPqYa3X7q8hg/fjyAZGf5QYMGhUyzcaVcfoqaWdV8/eWXXwJIujy0jYe20WEmn7oU9H25Vpo9dcwxx4ScVhOsCHTMn3/+echsL9GlS5fU17EODuvpAEDr1q1DLmJ/ci46Zh2T3muUv/vuu9AdeOCBITMTS032WlOH9XNYLwlI1iRr27ZtyFmtMbNW1Y2pNdW0TtHOO+8MIOme1OvCe1Wz6zT7kTWp9PzhmQSU3E9AdvOrqQ2Lfg7d7w899FDo9Kxp165dpmPLAp51abW5gORasn7fpZdeGjqtb8WaTVqHSzMd6fbNO7tR4Vmg95G2plG3PN2a6grVrGuey9rGRbO2eS2ryeWXhq61niWjRo0CkLznamoPlzW2VBljjDHGZMBcRT1xTJ8+PbMPVksOq09rIDqrPAPAkCFDAAB77bVX6LJ86mjatOlcADBjxox6vZE+PbAhMQD06tULQLJOkAZN5m2hatKkyVxA+vrpmBnwCpSCXu+8887QlQs4Zh0gfSrTQGaiwetavTvtPWsD12/KlCmZrd8BBxwQMoOhdf+9+eabIe+www4AktYZNsEG6r++8847b9n1K0faU6vWBLrjjjtC5v2nT/pbbLFFyKwjVg4mOOj9y+BTIGl1bt++PYBZnlrrfP/pnmTCAFAK/gVKe1j33Nprrx3yEkssASCZKKEN21mfTe8PtVoddNBBIad1T+D9V9/zRef66quvhszrrtbjYcOGhcyn/ry+N+Z0fnp/8XzX4GVNVNK5MsFF9xS7OACl68+ECyC5Z+t7/3F+//77b70uoN6TaU3WywVqp3UsyDKo+3//+18m+7McnCs9NgCw/vrrh0yr3Ouvvx46tcrV19LP9ZvtGOv1CcYYY4wxBoB/VBljjDHGZEKDDVQvV+fngw8+AJB0+fXt2zdk1s+pZKBhfXn22WdDpqlT6zhVS3C9jkNr49C90aNHj9Cp+V3bnLBRpgZCpzXcVap9/bThKttbaJ0nbU2yzz77AAA6d+4cuqLXN+36qsld3Sd0u6h7rFzNHKL3L9ugaE2eMWPGhKztN7Jedx0n2wUBwBVXXBEyEyTUla0tl2paK+4FdSnSpT8zWc9Pr7M26daxMNRg6aWXDp26v6rlXtPrzNZI2k7n+OOPD1nbyLRp0wZAcv9qUkRaw/Iikn5qIsvxVXtQehr6/aI1yehq1+QgTfqpBLZUGWOMMcZkgH9UGWOMMcZkQIPN/lOXkNakOPTQQwEk3X8jRowImVk5eZl0s8r+U7RlCeusaPZbJddwdtl/5eBaae2ectCsr+tTyflllf1XztVCV5/W7FL3A7PmsmrHMjN1yf6rDZx3fces81dZ6w+ludryuP/Ssqe0zYm23Jnda4CSq1vbSOn8anIf1if7Tz8nrXUQUHL7HXLIIaFT927e1GV+aXtO7zmtY0RZdbpWlcqerm/2X7WSd/ZfGq+99lrIzGQ97LDDQpdlnSpn/xljjDHGVAj/qDLGGGOMyYAG6/5TU/a7774bMltGsB0GkMwEoXk9r3nn7X4gRa1bXdx/DYms3H9KuUzVNNIKPmZJ3u6/osnj/lO4fvXNmKpr9nFWxT+VtOKRSiWzT7OaX7k55X1/1YTdf9lQ7kylXK64aX2x+88YY4wxpkI02DpVijaPpKWqUrVfKkFDHLMp0ZBqopnZU7SlIw+KroOWB41xTqZENZ+ptlQZY4wxxmSAf1QZY4wxxmRAYYHqxhhjjDGNCVuqjDHGGGMyoLBA9alTp1bMRKbptXkHMDZv3nwuoLLzqyScn1PyGyZMCfb+bJj8V/ZnYy85MG3atELmR8+UliHQThdpHS1qUz6kWbNm/4n9OTtsqTLGGGOMyYBGUVIhDf2l/f7774e85pprAqi54J0pFl2fOS2YqbJjBU0RVFMhTZMNNRWXbEhwf+r349ChQ0Pu0KEDAGC11VYLnc/S2uFfFsYYY4wxGdDoLFV8kvjhhx9S/78hWqjSOt7XZL2pqYy/Pn3k3Zm9LkycODHk22+/PeRnnnkGQLLz+HnnnRfyWmutBSD9mjUGOBfdxxoT8e+//4bMp+n6tlSpL3r9ORYdv7acImoJ0DkVPZc0dEzvvfcegOSe3G677ULeZ599ACTXrDHtz8aCrumMGTNC/vvvvwEkzx9dy2pE5/LPP/8AAC644ILQPfXUUyHff//9s7zG+7N2NLxfGMYYY4wxVYh/VBljjDHGZEB12y3rAE2Vr776aujUFbj22msDqE6Xl6ImV3WF0Cw7bdq02f7/n3/+Gbpff/015OnTpwMAmjVrFrpVV1019XMrhbqC/vjjDwDAvvvuGzpdS45bx7nVVluFTLdLnz598hlswfBa/fXXX6F7+eWXQ+7YsWPICy64IIDizffqHqErZfz48aHTRJLff/8dANCuXbvQrbfeeiEXPReic3rhhRdC3nHHHQEAzZs3D92nn34acvfu3QEAiy66aOiqZU5Zou4jvb/LnWvVho7/lltuCfmGG24AADz55JOhW2SRRUKulrXU8U+ePDnkgQMHAgBuuumm0B177LEhL7HEEgCqZx61hfNOCykAkqEEeWFLlTHGGGNMBvhHlTHGGGNMBjQK95+al7/99lsAwJVXXhm6wYMHh1zNZk2dB7MwAGD48OEh062gLj1mdCjqHpwyZUrIXbt2BQD07NkzgxFng5qqx44dCwD44osvQjf//PPP8rd6raZOnRrymWeeCQBo37596DbYYIOQq93tm4aasjnXo446KnTDhg0LmdlnALDQQgsByGfP65qluXH0/++9996QmcnJdZ55fFtuuSUAYPXVV099r6LvX7r9Ro8eHboePXqEvOeeewIATj/99NDp9eGaVJPrK81Vp+OrzTXn6/X8eeONN0Ju1apVyEsvvXSt3z9vOH516Wqm3E477QSgtI5AMeNPy6gF0q//EUccETK/V0499dTQHXfccSE3adIEQHpISbWi5yPDRy666KLQ6XcF5zrvvPOGLuv1s6XKGGOMMSYDGoWlSq0P1157LYBkoDarqAPV9YRI+CSgQXQTJkwI+fPPPw+ZVhsGnAOl4EKgFDS57bbbhq5t27YhL7XUUgBKTyRA8U+KuiasM/Xggw+Gjk8fQOkaLbzwwqHTv7388ssBAHfddVfoWCUYKB80W23o0+HPP/8c8hlnnAEAuO+++0JH6xwALL/88iFnvdf12n300Uch9+/fP+ROnToBAH777bfQ6ZP+AQccAAC4+OKLQ7fCCiuEnBZgWtc+ZFmh82aCgNahWmeddUKmVbxFixahq8aacHodf/zxx5DHjRsHIGndbdq0achp90ya1fKJJ54I3VlnnRXypptuGvIVV1xR9j2LgnN59tlnQzdp0qSQaeHXRIUi1rRcIgDXr1evXqFTqz/v1SOPPDJ0ur6cS0OyTr355pshM+ie9cSA5PlJT83GG28cuqzXz5YqY4wxxpgM8I8qY4wxxpgMaHTuP5qytbaNthRIM2sWbX7m56tJs1+/fiEvtthiIXNeyy23XOh0fgxkV9dPWtBp0XNWdCzzzTcfgGSdorQ1U50GNdNtqoGm6t5gcCxQPa4YhXtATdYHH3xwyA8//DAA4JJLLgndoYceGrK6JbJqU8PXqxtE3Qs0qQOl2liXXXZZ6LRhK4O6awp0T/v8otD9eeuttwJI1ikaM2ZMyAsssACAytTDqQ961rz00ksh77333rPounTpEnJN7iEGQmtwtJ5VWhOpGuFe1IQPDR9ZeeWVAVT2/ExrTab3udbx22+//QAka2c9/fTTIeu5OvP7A6V9kdakvhrg+EaNGhW6Qw45JGQmiKy77rqh06Qsnk95nim2VBljjDHGZIB/VBljjDHGZECDdf+p+Y6tLYCSWf7SSy8NnWZHMCtAs+fmnnvukDUrrkg0+2TAgAEhs00C2+0AyS7qKjdE5tQ9qWuqrhaur9bu0pot1YjO5ZNPPgEAHHjggaF75513Qj755JMBAIcddljo1JWTR30Zvr+2lvnggw9Cfu6552bRn3322aHbY489QuZaVXsdHF0TbfPBOjda50fdQ9XoUiY6Jz0zH3jggZDZPkfdR0papvKdd94Z8tFHHw0gGbLAMwtI1qmqlmulrjS2fHr99ddDd91114VM91Els8jT7o9XXnkl5L322itkulpZDw4AVlxxxZD5/aBnhmbKsaahtjHTmk5KmlsyD3Tfcl7MggaSZ+EWW2wBIJmdrOEfDGHQ2o0610zGm+m7GWOMMcb8R/GPKmOMMcaYDGgU7r+333475J9++glA0mSp/3/aaacBSHaOZ0FCADjllFMAJE2OecPP+uWXX0Kn2V1qambxTzWdV1N2Rt5w3XX9tdAgs5a23nrr0DEjC6iea6Xmd133ww8/HADw1ltvhe6EE04ImWbvcsUH8zDFc/8ts8wyoVOX18477xxyx44dAZTazQDJNkIsNFiNRXgVvY5ff/11yNw/bEcDJNeiGrP+uNe0IDL3GVDKKAVK5yOz3IDkWvG9HnroodAdc8wxITMTWYvTanHUark+5VyhLFS7+eabh07PkiLgNVeXpBZ31kKzt9xyCwCgdevWodNrzn2t54u66pk1rS7Dgw46KOQ+ffqErEVDs0bXZ8SIESEze1SLB+u5RFegrqkWnOX4H3vssdC1adMm5CzOJVuqjDHGGGMyoMFaqhQNtOMvXA301kBaNiJmPRYgWeeDlg6tvZO3dYNjnjhxYui09P5NN90UsgaoNzT06b+cRSUtUD2tJYMGTWsbFKK1nTTotmgLCcf/3XffhU6tBi+++CIAoHfv3qE76aSTQmZQZSVbt/Cz2OIISN5fr732WsiPPvoogGSgPVsPAaWnYt3HRa9JGjqm888/P+RtttkGALDSSiuFTp+q0yzcuj6VCs7Wz6SlQu8TbdiulkbWl1IrhF4LnlFDhgwJnVrq2HqmGq1Tip4vHDNQOv81EFy9HkUE19PSyxZcQHKfaaIBLVS6ZnrW0MKjyQVq1WL7Ja3TpW2Gdtlll5B5HmR1/6r1/rPPPgtZz0ImQmhwvp713NdqUdM6XUya0fs383Zemb6bMcYYY8x/FP+oMsYYY4zJgEbh/lNTN83WDNgDkubpq666CkCydo62NGFNEu1irWbJPKApmi1aAGDhhRcOmWMGSkGJ66+/fuhYOwUoXYtqCcgGSqZqrRdVbnwcP9vtqA4ouWrVvaRd2Nl9nQHTs/usSqH7hwkS2uYlrQ4VEyaAZBuiIrrIp+0p3XPbbbddyAzq1UBRto4AgE6dOgEAhg8fHjoNui3SFagule+//z5kumQBoH///gCSddC0Js67774LIBmSoPNbdtllASTXL6v9Wa71z8CBAwEka/etsMIKIWvQL93LGsisoQhXXnklAODjjz8OHVujAED37t1n+fxqgveiuswGDRoUMte3bdu2oSvC5ad7kS4tTShQV6C2ZOEeUPedhrow6ULvSa3zxPqNmryl97rWccz6XNUai+pe1u9iJu2oe1oD9RdffHEAwD333BM6DeVhIka52n5ZYEuVMcYYY0wG+EeVMcYYY0wGNAr3n9bMoavkr7/+Cp3W2WCmi5rK1XzIOldptVnygp+l3dzPPPPMkDX7YqeddgKQdP/tvvvuIdMtVnTGil6zsWPHAkhm2ej1VZlm3XLZYddeey2A0joBJZcfUDJrq5m6Uq6ItG7vQDKrk6Z2dZ9oy4UTTzwRQLJ1QjW2dNG5pu2vhRZaKGS6jABggw02AJC8J7VmDNe9CPeRrtnIkSND1pYWzA7TjNyWLVuGzLOIWcZAsuYcsx81eykrdPx0QwIlV4r+v87p+OOPD5m1rHT+6pbhfaVn7qGHHhoy3fbV0oIGSM6b7i+t/abua2aaqfutUntR720NleCeW2KJJUKntZc0vOWHH34AkFxTPSt5fvbs2TN048aNC5nnE9tlAcBtt90WsoalZOX+4/polqJmp2qdKn4m2wkByTp4v/32G4Dk/tTwmbQ6j1ljS5UxxhhjTAY0WEuV/kpmcBpQqp6tliqtDktLlj4JaB0LPpVUsqI656JPHBooqNWpr776agDArbfeGjoGNwOluVx44YWh04qxM39mluj49emHQdn69MMnBgBYfvnlQ/7qq68AJAMNtc4NnzDUEqJPbUTXX4PedV2zugZ8H30i1kDtfffdN2RWRdZAdH1qpiWgknWo8qCcdY1BzVoz6e677w65Q4cOs7y+Uuh+0OQHfRJmzS21HmtFZ1oYdZ/dcccdIdMSstFGG4WOweszj6E+49f7a7XVVgMATJgwIXRaXV3r+PH87NKlS+g0aJ3nploftSZVtViodM/p+nHddJxqQWeyUNH7T88SWl90Hmpp1KQKNvrW6uta526NNdYAkLSUqiWI56o2kd5ss81CTuvkUd/zie+j3hVNpNDvN36+JoJoRwqun35/aH09Wl3zPFNtqTLGGGOMyQD/qDLGGGOMyYAG6/5T1L1Ds7Wa3LWhMusEqStKa5bQbaaurErVOSrXmkXdY3SbaENXdV/SLL/JJpuE7txzzw2Zrii9ZvWdH8eqpmGtqfLBBx8AALbffvvQHXXUUSF/++23IQ8ePBhAyQ0IJIPyGSipgcDqSqJ7QmubaB0dmr+zhK4e1ngBku5XDapkoLK6/NTUX0Qdqvqirlaa32uqw8TGqABw++23h5ELEsgAACAASURBVDxp0iQAyeSRSt1/6vLR/bXkkkuGTFeKjqk242OwcR7NaPX+0zYcvBe1MbSef/q3rVq1ApAMVFdXERNh9J7Mo+ZWfVH3q7rChg4dmvgXSCYaVIv7Us+Efv36AUjOQ9uwTJ48OWSepbpntQ4ja5Zp0Hvfvn1DZtKPurTLXZOszijed1oPS+tUDRs2LOTVV18dALDYYouF7rjjjgv5mmuuAZAM+UlrKJ0ntlQZY4wxxmSAf1QZY4wxxmRAg3X/qZlZTek0ZbKdCZA0Hz7xxBMAkiZNbRnCNhrVRFomCrOkAKB9+/Yh0yyvdYC0ZgnNp+oeq6/JmyZVzU7R1itzzz03AODnn38OnWZ83XfffbO8p2Y8qiuNZl/9LK2jw6wYfiaQbPNSzsVaH/g+3FsAcNlll4Wsri7K5dokNCS3H6HJHSi5NctdZ8p6f2p9Nq5VEW4kHae6vHSv0pWtdXD0/qH7+c477wzdeeedF/KNN94IIOlyymOuuqeYCaitV9q1a5f6+Xyd7uVFFlkkZLqHtI6auleKRNfvjz/+CPmcc84JmXPRjLBqcVkqOqbOnTsDSGZ8H3744SFr9h/3orp61T1It6G+XjPt6DattMsMSO5ZzSjV7zqe9TvssEPoNJOWdRwLbXdV2CcbY4wxxjQiGqylStFf9bTUaBPURx55JGQG7XXr1i102lyZFoRqfHpR9ElCrR5bbbUVgGSgvgats35SlvNLey99kuXThQZasso6AGyzzTYhH3HEEQCSgbBpQb1ah6c248vqCUYDYd9//30AyYBJTSTQmka8Lg29DpXy+OOPh8ykALU+qSWR1aG1joxWJ2cChb6mUtdH10Stv1pnbLfddgOQtGR9+eWXIX/22WcAks3RH3300ZBpIapkQDT3v36myrqXWZF79OjRodO9zADgagnoVnQeTz75ZMijRo0KedVVVwWQPJ+q8axPs/RqvShNvtLq+ayYrt8J2nyenphyFeMpF3Em6WeW219sJK37U70iTDAr8ny1pcoYY4wxJgP8o8oYY4wxJgPmKsr0OXXq1Fw/WE1+auqkrCbPLE3ZzZs3nwvIf346Zq05M378+Fl0Gqj50EMPAQC23Xbb1PeqCc5v+vTps8xPrzNbKwCloGSt46SBuhqUyABzXZ9K7tGmTZvOBQAzZsyY7Yfq+JgcoQ1B77rrrpC1CWmRAZQA0KRJk0z2p95f2nKH9Y3ohgZKtaeAkqtP6+ywdg5Q//pNs9uftUHnp672N954A0CyIbaOmcHgdDMByUSJ+p41c7o/a4PW5GPYgNYu0qSCvN2X3J///vvvHM+Pa6Xni+4vbZlFtzPrcQGVdWX+73//mwsApk2bltn66bmrbj+i88v7/GnWrFkm+1PnpOfquuuuCyD5naZrnfd3Bffn7LClyhhjjDEmA/yjyhhjjDEmAxqt+68oKuX+U55//vmQ2V184sSJodtxxx1DpllfWwLUZg/MqXtFzbfqXkj7THWvFJ2JM6fuFR0zW5doO5y111479W+LzvTLyv2naKbeqaeeCiDp/tTab927dwcA9OzZU8cUcn2zj7Jy/yk6FrpXdH8rHL+6XLLc03m7/+i+1ZpIV199dchcq7zu07q4/4i6trR1ku4vZmUWlb2Yh/uvmsjK/af33KGHHhryhAkTACTboKl7PW/3pt1/xhhjjDEVwj+qjDHGGGMywO6/jCnC/ZfWBqQcXO+6rnse7pVqoi7ulbRrXrQbsxx5uP+Ucm6xmcnLTO/9WT/S1kUzyiqVXVUX959Sk3u2KOz+mzPUPXv99deHzEzxjh07hq6Sa2r3nzHGGGNMhWgUbWr+6+jTY7VaSBozvuYlirYEmPqRZuFpiPvb+7Bho9bRfv36hcx1rabkn5mxpcoYY4wxJgP8o8oYY4wxJgMKC1Q3xhhjjGlMFBZT1diz//7+++9GOb955pmn4tmNleS/kj3W2OfX2PdnY88ea+z7s7HPL6/s1KJx9p8xxhhjTIVw9p8xxhgjaBakZpcxXMbZhcWi61Nt2e+2VBljjDHGZIAtVaZwtCaJynOKVt8tqlGqMbVBrR/a0Fj3r60hlYcWkH/++Sd0U6ZMCXn++ecHADRt2jR01WAdmVM4P91/abXJqqnJvcJx//3336Fr3rx5UcNJxZYqY4wxxpgM8I8qY4wxxpgMaLTuv9qUrq8m82YaaQ2TazLfKtXuUvjmm29CHj16NIDy68fxq5uwbdu2Ibdu3RpA+UDGPCm3JjW1/tA1qW/D62qhrq0jqnHeafdfXYNj+frp06eHbuTIkSGvvPLKIS+55JK1fv/6krZuaXtZ92za/m1IqPv1p59+AgAceeSRoXvwwQdDPvjggwEAF198cerriz5fuT66ZurK+/HHHwEAkydPDt1HH30UcrNmzQAAm2222Sw6oJj1Tbv/dtxxx9Bts802IR933HEAig0DsaXKGGOMMSYD/KPKGGOMMSYDGp37j24hNf/NmDFjlr9Tk626kqrF/VLOffXtt98CAF588cXQvfDCCyHT/KwZEYccckjIdJWl1V7JG73Ob7/9dsiHHnpoyO+99x6ApMlZ5WWXXRZA6ToAwHzzzRfybbfdBgDo3Llz6PJwT6S5+qZNmxY6Nak/9thjITNrpX379qHr2rVryIsuuugs71+0S6Em0jI21b2Vds3LZXxSLrdmRbhydV2feeYZAEDHjh1Dt8gii4Rc0/i4Vz744IPQqSvjoosuCvmggw4CkL8rI829ohlvaWfNPvvsEzrdy6To87McnJ+ery+99FLIAwYMAAA8//zzoZt77rlDHjp0KABg4YUXDt2xxx4bMrMDgcrdt/o5X331FYDSOQoAjzzySMg8l3799dfQafgF77+jjz46dGeccUbI1eIK/PLLL0P38MMPh3z88cdXekizYEuVMcYYY0wGNApLlT51/PDDDwCAQYMGhY7WCwBYY401Ev8CwB577BEyn0CbNGkSukr9Itd56NPxjTfeGPLAgQMBJAMNdXx8ktA6K2PHjg15+PDhAICWLVumvj5P1CLx7LPPhvzOO++EfMkllwAA+vTpEzq9LnyP7777LnRdunQJmXNVS4IGatalDlZN8KlPg1tHjBgRsloyuK9uuOGG0C2wwAIh0zpxxBFHhE6ffqulDpdeR92Lr7zyCgDg/PPPD933338fMp80N9lkk9BtuOGGIXfq1AlAKeEASD4d1zUAvrbonmNwLwAcfvjhAIBLL700dLvuumvIafeSjpl78eqrrw6dzk8trHnel+WSKkaNGgUA2G+//UKn98/iiy8OIBm8ffPNN4es60qKtlqlWeU//fTT0O25554hM1BddRq03b9/fwClcwoAunXrFnI5C3nW6Jq99tprIW+//fYAknNefvnlQ1599dUBAO3atQvdhx9+GDItWfqdod8l6gGp1Lrq53BeTBgAgM8++2yW/y8SW6qMMcYYYzLAP6qMMcYYYzKgwbr/1Pw5adKkkHfffXcAwIILLhi6e++9N2QGOr/77ruh00C8Bx54AACw2GKLha5SgaIaUK/mZZqcAWC55ZYDAJx88smh69ChQ8iffPIJAODss88OnZpHf//9dwDAEksskcXQa4VeR5qpAWDIkCEhM0C0R48eoWO9HqB0je66667QqSl72223BVCqdwUAzz33XMgnnHBCyGw1MadmbHV5aaA8XUJ0fQHASSedFPJuu+0WMhMkJk6cGLpbb7015HPPPRdAcs3U1URXYCWD19NM6l988UXIGhxKt6e28UhzNd13332hu/vuu0OmK0zX/7zzzgt5qaWWCjnr+1LHqW0w7r///lk+X2uj1fReOk4GfT/00EOh454FgFatWoWcp3tF97Kehfvvvz8AYOONNw4da/8ApflfeeWVobvuuutCXnfddQEA8847b+iKdv/pXOne0pCP3377LeSddtoJADB48ODQadIF92/fvn1Dp4Hg66+//ix/m8f89T1XWGGFkFk/a6GFFgrdBhtsEDLPfbp5geT3C8+VAw44IHQalF8t4Qf6nV9tiTy2VBljjDHGZIB/VBljjDHGZECDdf8pmklDU+hVV10VOjWF0lSotVf23nvvkJmpVYR7RU2a6nJQ9xfdBm3atAmdZmTQvacmbZ0fM0GKMMmr6Xi11VYLmRmNQCn7Tc3rmr3J7Dmdv2YKcv3UJK+1fw477LCQ6Wqqi/vvrbfeCpm1Yd54443QqUlea6IRdfPQZQKU3ErqPtT/Z02vvOuM6ftz/BMmTAgd1wlI3kt0u2vGou5PZlfRzQQk64w9/vjjAIA777wzdOpKUrcM90JW8y9XR03dj3QP6fqmfb6u+fjx40Nm/R/9f82002uV9Rmk8/vll19C7t27d8jMZNTwgXnmmSdk7gvNrh02bFjIf/75J4DkmhaBzvXnn38OmRm6Wkduhx12CPmaa64BkMzY1XOLoRa6Tvr/RWTEqUuc56b+v34XMJP8nHPOCZ3uRZ6VW2+9deiqxeUHpNep0nOpGlyBtlQZY4wxxmSAf1QZY4wxxmRAg3L/pRX5BJKuHhai04wFLaTJ4pdnnnlm6DQTiWZjLXiXNzRpasaRthFo0aJFyCwUqeZtzcRiJp3On9lpQKnlQtEmXTVP77XXXiFzXlpI87TTTguZ2S0777xz6vty3dS9oe6j+hSH02umGTV0yapLSM3QNe0lzZQ78MADAQA33XRT6NS8zTHkUeSu3Huy5YVec91/mv231lprAQBWXXXV0D3xxBMhT506FUDy/tP50xWlrXvoEgSSbgu6GuvrcuG5om66U089NWRdV+5LLdip+4Lv9fnnn4fu9NNPD5ntX9S9qXPN05Wre/Laa68NWc8KZkKXK/JIt4u+fpVVVgmZbt8iwgv0+0Hb7PTr1y/kl19+GUApixoArrjiipA16zvtveiWZxFUINlmS/dynt8h5Yq3siiy3jNaPJp7XFsjaUsaFsUuojVUOdIyaTW7e6WVVkr926KwpcoYY4wxJgMarKVK6/xoGwnWCmLANpBsuHjLLbcASD5prL322iEXYcHhk4AGHGqgIJt4AiVrAS0aQLKlABuest4RUGpNAFRHIB+Q3noAKNWP0XVQqxWD9jWQW62WbP+iiQq77LJLyPWpn6Nj0jpfHH9t9k5a6x2gFMitT8ds3QKUnoS1dk5W6Djef//9kLfbbjsASeuM1tZSqx3fQy2teq/16tULQLINlO5JPnWqdVItCVm1GdLr/9dffwFIBt+/+eabIWudMAZoa005HRP3wFlnnRU6PX9o1dhyyy1Dl0fDb4Vz1UQYNoYGkjWJaBXXMele5Lmic7rjjjtCZoB6EYk+eu000UcbmvNvdc6aCMRx6/5QSyvPV62zl2ftNEXH9Mcff4SsiQK33347gGTDboVB6WrdUasyr2HR1qlycFxaJ1DvRf5/3ok8s8OWKmOMMcaYDPCPKmOMMcaYDGhQ7j81rbZv3z5kdYUxgFLrIKl5nnVU7rnnntBpTZUi3H80OWuQ44ABA0JWlxVdger+UrMwAzB79uwZOjWFVov7T0lzBe67776hU1cS2/OwNhSQ7NLOQExtDaOupHIBxrWlputYLpCUsprvdX50G6lLYptttpnlc7M0b6e5LzXQla50dRmpy0+vBd9D7zltCcIA6HLXj6/T1ktaJ0mvZW3R106ePDlktlxhQP7Mn6l1fhheoC4fTTB5+umnAZTaLc38t3pWkUq5J3R9NXln5ZVXDpmBzkwoAJJ13uhe0nl069Yt5CLcR1xXDQO57LLLQv7nn39CZiKFunp1r3Lc2ibqmGOOCZmB+OqS1jMlj/OV9+fXX38dOk0+YvA9UEoaOOSQQ0KnLdtYf00TYdZZZ52QN99886yGnQu8Fky4AoDvv/8+5GpwW9pSZYwxxhiTAf5RZYwxxhiTAQ3K/aemPTXln3LKKSGzTL+2GaDLCCh1Ee/cuXPq+xaJjkNrx6j5nW4XrX2jZm+6arRlSrmaTpVGXVblZLrCXn/99dCpe4/cddddIav74cILLwSQNGOrW7VS2TnqPlHz9KeffgogmTGla8VMxk033TR06opgnbJlllkmdOq+qEsmGa+/uoQ++eSTkDfaaCMASTdBTZ+jbWqUOXWPqEtF24xo1qO6xecE3Wfq0uNa6HvrntE2NbwX9f7UekS8//S9evToETLdM5U8c3jNtV3XJptsErKeDy1btgRQyogEkufLiiuuCCCZXVzuWlQKrqu61DXTUa91u3btACRdYmnhERp+oe/Lmmxaz6pSa6nniLqntc0X609pxq2eD7wuemYeddRRIdN9veyyy4au6JqGaej9qedWNWBLlTHGGGNMBjQoS5WiTwda84ZP8FrR+NFHHw2ZAeoa6FaNv8T1iV4bXvIJRINjtY7Rxx9/DCBZeVr/n6+vZMA6LTj6me+8807I2iRXLVREnwr51D9y5MjQadApn9T06SXvufJJUKu469OfWtqYKMF/gaRVhg2VFQ0KpiWEFgMgWcdrq622CpnXvaYn6bTaLiqnVZmuido8vacF3etTudZJUktIbasn6z5QSx+tEnqfae26UaNGhcxAdV3TtEBZbfitzYm51pW8/zgmtaRqRXvWIQNK3RlYLw1I1nxina5yDYcrha497zutTafWTV3XcePGAUjef3pW0ALOzhszs9lmmwFIfufkPX+unyZvaJ04PT94FpVr8kzrrr5GmxPzXquGyuRpcC5qaa5P8koeVNdojDHGGGMaKP5RZYwxxhiTAQ3W/VcOlqxX86jWtGL9qmoJTi+Hml/V5UH3gwZPsgmq/v+gQYNC9+GHH4bM9ip5ux90/AyOVDffddddF7IGNbO+lLq8tM0O5/fiiy+GTgOWea0qub6cK4PQgWQdNA2qJLonteYMg4a1oa22ZKIrirWVAGDPPfcMWQPg6Qqti3tCTepa56e+8FqVczWy/YQ2qdUAa72WtV3jcokuNSVyaJ0tXmttg0WXGFDay7q/W7VqFXKRoQY6fw1/YCKCyjpObUnD+1PXQduEVApdP7r0WEMLSAZnax3CXXfdFUCy5pPWdGJYgq6ZJkK1bt0aQP7nZ9re1jmXa3hd0/7id4GeKTvssEPIdItXY0gMUDortE2Yhl1UA7ZUGWOMMcZkgH9UGWOMMcZkQKNw/6lZlFl/WseItUWAkim4CJN1XdH5Lb/88gCS5l/tMs46T5qdopmClULHfPXVVwMALr/88tAdfPDBIR999NEhr7DCCgCS4x87dmzIrEPGvwNKrSeAYszWNL+ry2D33XcPWdeqS5cuAJJd7tOy69SkzzXXz1h33XVDR5cGANx8880h0/1XEzSp6z3BLDCg5NbU1i6a/VVT9o3OhbK6rzW7jOPfeOONQ8fWPUDSlZOVi7c2rhzOdcSIEaHTmk5DhgwBAKy33nqhq0ZXSrk5c36aEab7gvWLim53pZ/Pe0Fbc6n7tUWLFiGzvZW2nnn//fdD5r2qra169+4dMsMLspw/7z91Keue5/l2wAEHhC6ttY6+l6ItvY499lgAyYxI/X5kKEXR66vo/DhurTP5xBNPVHxMs8OWKmOMMcaYDGiwlir9Ra7Vi1n9eMsttwzd/vvvH3IRFX/rgv4616eSNddcE0Cyoq4GaLLOiF4TfX2eqMVC64g89dRTAICuXbuGTp/ENNCcgcpah0or4tNqc80114ROA5mLsArwMzV48rbbbkv9W65FuSbXadYXnRP/lpW5gWTz3rrU5+Jnau0aXavRo0cDSD4p6/2liQSsyM3K7wDwzTffhPzSSy8BAB566KHQsYo8UKqzRevmzOMqV38nT/SpfsyYMQCSDc0PO+ywkGkdrKYn/ZpISxpQS7+uL5tDFz0/XXsGzWsT9ltuuSVkrVl1/fXXA0iej4suumjIrBTfq1ev0KmlLo89x2uuyTd6vvHM13qD2nBdx8SkEq3NqM2f+f2gljxd36LXtSY4Pk2+qjavky1VxhhjjDEZ4B9VxhhjjDEZ0GDdf+rSeuyxx0KmKVBrN2nQc7WbN9PQMTNQWduUaENNutJWWmml0Gl7g0rNX10mDP786KOPQqetVdSl8+qrrwJIBv9qQ1o2kl5uueVCV40u3XLB2zTV13Ud+Hq9Zuq+UGrr/tM10zY7bM1BNyCQbOitiRBLL730LK+nSxAoNYfW1+tepqxjqab1pdtIG2ZrQ2GuezWNuSbU/ce1fPnll0O39dZbh8yztJpcLrwXNGGFIQdA0v1F/bbbbhs6rUPF99D7t1I1qbQJvLbcoayJJ5oUo7D5tSaaaFB3//79ASTbMDWk70TuVV1r16kyxhhjjGmE+EeVMcYYY0wGzFVUu5apU6fW+oPV5ac1PTQT54QTTgCQdH9VMiOsefPmcwHA33//ncuFpVn68ccfD51mvXA9Nfuse/fuIdf3WswzzzxzAbVbP2Z3DR06NHSasaYtL5j9tcsuu4ROs+roFsrLZM31mz59enX3MaojTZs2naP5qfuD11xdPprRp3V+WL+K7aCAZJ0gus80ezWtzUZdzyXOry7nSzn0WvDc0ewqralFt3Re5yr357Rp0zL7AD1XWedO66hpnaaDDjoIQH7uzWbNmtX5/lM3prqPmfEGlMIKtN6ZtuzhuZLX+s3u/isXMsCabprR+MADD4SsmYzMCu7Xr1/o9F5keEhe34mc34wZM3K5gFxjbZ2lGc8LLrgggPzWr0mTJrMWApsJW6qMMcYYYzLAP6qMMcYYYzKgQbj/aBbVjBvN6Nhuu+1CZqG0olpD5O3+o/lT3V+PPPJIyDTvaiaJmpXru951cf/x89U8X5txpLU5yQu7/8qj61dTa5qa3LN5u1eydP8pvAbl9nKl9meW7j9dS7pVnnnmmdBtsMEGITOTMy/3e33cf+XQ+XHddJ0qmf1Wl/uvpnutJiq5P/N2/5Fy1yTvtbT7zxhjjDGmQjQISxWfLjQgTdugaB2ctCeRSpK3pYrok3JaG5q82nnUxVLVkLClqmGTt6WqaPKwVCk8VzTQO61NUl7kYamqJv4r91/elqqisKXKGGOMMaZC+EeVMcYYY0wGFOb+M8YYY4xpTNhSZYwxxhiTAYU1VHagXjEwFVWD2zX4tKZSFAzUyytQtmgYKNvY59fY77/GHqje2NevWs/P+sLzs7HPr7Hvz9lhS5UxxhhjTAYUZqkqipoKqTHGrKHHmmnJBbU+fffddwCAESNGhG7ttdcOuUOHDiE39GvQEEkrLplWaLKSBQuNqS26Z8vh8yU/yp0fpDGdH7qP5rQ475zsz7piS5UxxhhjTAb8JyxV+qucHb9nzJgROv0lu8ACCwAAmjVrlvr/1Q5jpf7888/QnXXWWSE/9thjAIDJkyeHTlv+rLvuuiEXOe9yLVHSnkRqExNWNGnjV9iKacqUKaHT+c0zzzyJf4Fi1knXRAtFpqHj51irfZ3M7Knp/tQ116LNGstZ3/Yr/2X0+uv99++//wJItnT766+/Qm7SpAkAoEWLFqFrSN9vRMec1obt77//Dp1+l1diz3lXG2OMMcZkgH9UGWOMMcZkQKN1/9HMCQATJkwIeZNNNgEA/PLLL6FTk2CvXr0AABdeeGHo5p133pCr0VSq4//1118BAFdeeWXobr311pB32203AMAhhxwSutVXXz3koudH94Cab7/66quQJ02aBAD44YcfQte6deuQORdd/6LnpOtDt7O6Z1988cWQH3jgAQDAM888Ezo15W+88cYAgLvuuit08803X8h5zlXnwXUAgFdffTVkunrUJbHKKquETPf6Ukstlfq+dBsVvWY1US4QmHLanFSu9vkpaa4+DZ9g8gsAfP755wCAN998M3Svv/56yBpecMIJJwBoXEHTeaJ7Ss/HDz/8MOSxY8cCAJ5++unQaVLSwgsvDAC44447Qte5c+eQq30teN/otdBQguHDhwMA7rzzztANHTo05AUXXDDxPnlgS5UxxhhjTAb4R5UxxhhjTAY0Ovcf3UejRo0K3aBBg0Km++S3334Lnbov6H454IADQrfeeuuFXC1me82iocsPAI477jgASffQNttsEzKvBc3AQPlMyCIYOXIkAOCCCy4I3UcffRTyP//8AwBYbrnlQnf55ZeHzOui5mFmxADA9OnTQ27atCmAfGqWpLlkgZLLQ12a77zzTsg0Zbds2TJ0Cy20UMhvvPEGAODrr78O3RprrBFyHuvH66NZXAMGDAhZrz/drro/l1122Vn+f7vttgvdXnvtFTJdhc2bNw9dNWUKcl7qJhk/fnzIb7/9duJfAFh//fVD5r2oLludX9H3X5r7kvccUHLr3XzzzaFT995PP/0EIBky0bVr15AXXXTRjEdcDOWyH9Myket7vvD1ug76nXb11VeHzPNNz/T5558/ZH7v9enTJ3S33HJLyBtssAGA4vdhOdKu5bXXXhvyqaeeCiB5puj8KzEvW6qMMcYYYzKg0VmqXnnlFQDAgQceGDq1VDCATwOF99xzz5AZdHn//feHTp80i4ZPRRoofMQRR4TMoMQjjzwydMcee2zIrE+iTzJFoE93aonacccdAQCrrrpq6M4///yQN9xwQwDAMsssEzqt2cQntQ8++CB099xzT8j6On1ayxq1PgwcODBkBohq8PbRRx8d8mKLLQYA2H777UNH6yNQCkpdYYUVQpf30xefDvU++vbbb0NWS9Wmm24KIL02HAA88cQTAIDXXnstdLfffnvIW2+9NQBg8ODBoWNw6czvmyflLBG87y655JLQ3XDDDSFzrloHSBNF+vbtCyC5pgzen/lzK2UtSOu+8Nxzz4VOk15o1dcuDHvssUfIm2++OQBgrbXWCp1a5crVlyuSNOuHrnmaJUqtRnoW33vvvSGPGzcOAHDGGWeETs+fOYXW0S+//DJ0aqlSaJXR779u3bqFzLP0rbfeCp3WKeReVktj0euk9wETYL74ZdQLYwAAESxJREFU4ovQqVeD66KdQTRpiWeYK6obY4wxxlQ5/lFljDHGGJMBDdb9Vy4QmK4wrZ2iNXFoSlxnnXVCx9pUAHDeeecBSAaaak2rRRZZJORKmUU16JftZdSl98gjj4TM+lMaSMyAbKB4U24amlTAsarLRAOxOX51X2pNnLvvvhtA0lSurtCOHTuGTBNwVm4W3ZO6Z7ROzD777AMAOPnkk0O32mqrzfIedJMByZozp59+OgBg7rnnDl3ebiK+v9aeOuqoo0Ju3759yHTFpjU5BYBOnToBSLrf9V47+OCDASRdouqeUFdZ1nu5nEtA64jRlaN7bqWVVgr5xBNPBJCs/aPuwcsuuwxA0v3Zr1+/kNXtm/X+VMq1OeG4dt9999BtueWWIbN+Wps2bUKne5GUW5uiA6DT2pToXmR7qB9//DF0GkrApIRPP/00dD///HPI6t5jqIIGStcFumTLJefod12XLl0AlOoxAsn14fqOHj06dGkNh4umXBsa1ufq379/6JgcoX+r7udyZ1Fe2FJljDHGGJMB/lFljDHGGJMBDcr9p6Y7df+ce+65IdPto246df8svvjis7yv1k6h+ZDtFgDgm2++CZnZWUC+rjSdq7YpGTZsGADgoYceCl27du1C5ly1zo9mbVUjmim38sorAwCWXnrp0On8J06cCCDZRujhhx8Oma7cG2+8MXTlsseyNnXr+2nGiWay0Sxfrk4R3Qrq/lp++eVDZqaquoTzruPEeakbWd2oOu85HYu6RLSOEbOaNCO3R48eITM7FMjX/ae16/bbb7+Q6erZYYcdQqeZWHQFanak1rHiNXz55ZdDp5l0Wr8ra1dFuffTOmnMiO3du3fo1NVC966eKdVSR6ycy0hltre6/vrrQ/f888+HzPtW30vdbnTv7b333qHT7HA9a9Leqy7w9ZrlzCxSIHkfqCuXaPYtvx/1muhZUgn32JxQLguWmcIa8rLmmmuGzO8HDfmpNLZUGWOMMcZkgH9UGWOMMcZkQINy/6kZUDNy2FoGKBX/uvjii0OnhdD4HuXcQDRra0ZPq1atQq5U9pyOSYtHMhNKs29uu+22kFkUstpdfsqKK64Y8ieffAIgmTE3ZsyYkLmuzKwB0gu1phU0zBtdM3VvaZugNFfAhAkTQmZ7Bc1I0mtB90MRLpdyWTRprsiaXB56H6krQouaEmZk5QU//6+//gqdZldpdhfd6+ecc07otFAi3Sv7779/6N5///2Qed3YLgsoZewCyWuZ1VnDz/x/e+cSclX1hvHHgX7OGlbgKAwksCgIwUCEIqUIKukyalQDUwpUohvVIKlBRNCNEBpUFBXRoAtlhShFpAMHYk2i6AKJ0MWRfjr5j551nv13b893jmuffazfb7RYfp6z195rrbP2+7yXnDOZcDX3l0ceeUTSKEpVasq+87yvtEWJSdL7779f2pb9Nm3aVPrSVcAlofKZ5vjHyWN9RtJ1fV6O28843Q+chFQaRRV3ye+WGIeOEs/7nKXFHImZLj8ZyXjppZdKarrpzDqiEUsVAAAAQAUuCEuV395cokNqvt3lG6ZLJmSelcSn1nHlEtISks6HfVoI8o0jC+5++OGHpe03kCxzYeduaXSqH1dmYZ7Ie20L3H333df6ty6YmY7cWRzab9Lzkm9Fanegzdw36XRqS4cDEiRp7dq1pT2kpSDnUeaW2rdvX2k7UCADQtrGn325fl0cNcv4pFN8H/PX15QWqXRUT0dk57FLS4adY6VRnq0sA5LWJ69fF9aWmuu3j+frvS6t+9u2bTvrmiTpn3/+kTQq9yU1C3pfccUVkppjarOuDbH+cm5kbrMsE+Pfja1bt5Y+Wzek9v1jHvM4JW1lXH788cfSl4EytuBlkfO02vWZG20S2sYkjSzEGYh14MCB0naAWls+slmBpQoAAACgAhyqAAAAACpwQch/NuumSTpT82ca/nvuuUdSs0p85rSyeTNzd6QjsMtgbN68ufT1bQr1NS0uLpa+dLRPR8Pbb79dUjN3Sjpqf/bZZ5KazvVZ+sI5PYY276b8mo68zgmWjqYvv/xyaVsWbAsumCdyfNn+6quvJDVzp2XplbfffltS03l0XvIAJfl8XnvttdJ2/iWPQ2pKZZYlcs7m/7f5/vXXXy99maerj3vh/SWdW2+44YbSTtnMTrEpiVkSlJqyoUl5ry3Qou/n6/GlJJSSau4Vn3/+uaRmmaQsueTyLd6HpJHkKY3kwa48Q32Skk+W1slrcSDMjTfeWPpeffXV0l63bl2fl9g7f//9t6TmnMychs7f5IAESbr44otLe17cQ7qCYuzqkfvPxx9/XNrOGbewsFD6Zj0mLFUAAAAAFeBQBQAAAFCBZUPJQKdPnz7nF6fJz/JOloY4cuRIaW/fvr2077//fknNPBxtkQQZsZRlMBy1ZBlNakZKjDMlrlixYpkknTlzZsk31tEzGUV00003lXZKnSkVmayo7s9KSSHlE0st1113XembxDy6fPnyZZK0uLg48cRJ83yO6ZZbbjmrP6/pscceK+0HH3xQUn+SycLCwtTj64oo3bt3b2lb9ktJLMvsOGdXVx41t6ddtx7fuPU3jszdk5GAfpa33nprfmdpf/LJJ2d9Vq4/R2dlmYlJnrXX36lTp87r+f3xxx+lndFjX375paSmVJ95dHytKe+9+OKLpe2oxmkjylauXDn188vrTMk8y59YVsl7njnTvv32W0nNPF5ZhseRyuvXry99k+wv0+yfpktyz+hE3wPL8FJTCnPOw8yXVnOv8f45zfiSrpxcjur86KOPSl/eC8tjWYaoZukuj+9895cuPO78/c/fSkudKeOm+0/b/jlJaR7Pz3Ne45I/DQAAAAA6mVtH9Tw9vvvuu5Kab8Rr1qwp7bRU2ULVdRL1W1dmYc+TrDMhZ0Hfvh3d/PmZOdz5iqTmm6THlVm6s3i0cb4ZqZnn6qmnnpIkffDBB6Wvy6pXm3wOeU3pQOtCmZnHKR1J77jjDknTWzL6wOPKt/90Dn344YfP+j9ZhDcLev/555+SuovDuhBzH5m3x5HXkVnODx48WNpeX3v27Cl9WQTZDuh2aJaa89uW5KEzxuf8Skd6W7DTOTvntas3PP7446UvHeCHDKpIi2Hm+clxZ6Fvk3n6bMFJS8A111xT2nYaTktd33j+Hz9+vPTlmso8R57DGYiQOa2876bz/ryQ6y+LzGd2ce87uX6yoojbXXmc2iqODEHX/udnmcEjOT/9t5m7KvPPOYAhg9tq/+ZhqQIAAACoAIcqAAAAgArMlfyXZvR0BLVJ86+//ip9loGkpvnPWEaRpB9++KG0neY+88mkA7zLF/Rd2iXH6mvdsWNH6UuTdUoGl1xyiaSm+T1N3TZlOh9L9knS999/L0k6duxY6Uvn9z7kP481TdbfffddaXtM0qgkSBaMTqnM8ks6Wg6N75lLrEjNPDH5rC11pfN9zus283vKs573mecq5d8+52rOqXTeTtnF5vU0v7/00kulbSmsyzl2aCm3jbwmF+fNPHcPPPBAaT/xxBOSmvLaEJJfm9P2UnJHtfXnXmhXiZwLJ06cKG2v21mWxvLn55xMyT33Et+Dw4cPl74MSnBQ0tB5/BJL/bl/Pvnkk6XtItHS6Hcj7//PP/9c2pZn856kK4F/C7L0V9/4Xuc1Z+mkLGPlZ+WACalZkN75JbO0VK5P358+ny+WKgAAAIAKcKgCAAAAqMBcyX9dJktLVpnbx+UUpGaeJn9Glj7x/5ek33//XVIz4ijz5Dj6pW+TdZofPa4XXnih9GWekczt4/wcGdGRn2VTbkb6ZE6qhx56SFIzD0vfY22LjsvoxLwWR2WkfHL99deXtp9lRmzmvJmV2b5Nqk6Zq0v+OHnypCTpqquuKn2rV68+62/TJJ9r4bnnnpPUzGmW0UtdUV2TkuPzvXYOKalZ2iIjHR3JuX///tKXZZYsVQ8dXTSOfH5vvvlmaXusuX/cfffdpe35O4Tkl9ecEU/e89KlIstcpdRi2Sf/NvOouQxRPt+77rqrtO1KMUnun/PFayV/HxwxLkm7du0qbeenskwrjUpfSaOcfkPL0Hn/vNazdFmWcUpXEa/5vP7MyeXntmrVqtbvctS7ZW6pGRHax/7q55dR4M8880xpp3uE78XRo0dLX/6+WfbN6NN0n/C6nDZP1VLAUgUAAABQgbmyVOWJMbPEup1vYpmnwm9P+Rl5Ek2rhvPj5NvJzTffXNpDOCjaqpTXkQU/0ynbbyh5nfnW7zfQLCialiA7hdfMojsOf35m4c435bTK+a0636Ty/zkj8jw5kprMfZKWAuc+k6QtW7ZIkq699trSl5YCj6utooA0cqTNt7pcK33kX/H3Z564dMRPp1ZbOPLttu833VqkdfDXX38t7eeff760/Vyuvvrq0ucs6dKwFo68/rTOu8h8zrNcU2mVsgOzC/NKzbnseZsFs9euXVvavj+zvA/+XfA4JenRRx8t7W+++aa0L7roIknNLPcZ9DNLC9u5yGdp62jm60urXJtVNPPAJZ4XP/30U+u/2xE850Rb7rKa+J7nPvbWW2+VdgaibdiwQVJzfWZOvMsuu0xSc/7l739b0EZtsFQBAAAAVIBDFQAAAEAF5kr+S2kgHWEtL7jYsSRt3LixtN95553Sdv6YlJeyuKtNxF0m+yHliZTk0vybUtG48g9teY6GzgPUJv/de++9pf3ee++VtqXOK6+8svR9+umnpW0pJp0zh3B6zntq+TblhzfeeKO00ynWOaXSZN8259qKgEvSzp07JTWfYzpi1roX+f1+bilDP/vss6WdxU2d/y0lwcsvv7z1c+cFSwEpE2TQSJaMapOaMihkSAf8nFOZp+eLL76Q1B3c8dtvv5W25Z+UkXMtunxLBkTM0pWgDX9nSrIpHzk4RBqVH8q9aGin9Dbymvz7lZL/K6+8Utq33XZbad95552SmpJm4vV56NCh0vfLL7+UtoNmZlW6TBqNNSXLr7/+urQzAMj5xZxPUhoFF0jtUuisJV0sVQAAAAAV4FAFAAAAUIFlQ5njT58+fc4vzuty5fs0Wad52v8ujUyJad7NSAnLan2Ne8WKFcsk6cyZM/Onc1Rg+fLlyyRpcXGx2vhS/rOs5Ci37JNG0Ukpj9Z8lgsLCxOPz+ZlRyb+fztzGp2vKbotemUSycnjG7f+Eq+7LBexe/fu0s6ccY5azTI6llyk/qUEr79Tp05NPL6MPnr66adL++DBg6XtPD4pSfQhv3axcuXKJT2/nB+5Vs4X76/zvn/mb0Xei6GlPu+fk4zPzy8j8jLPX86/3GvORe5PKZnZ1aAt99VS8Pgm2V/aIp5zzua6tJSbEYl5rX3j+XkusFQBAAAAVIBDFQAAAEAF5lb+S9KUayZJM59/Oyv5Aflv6bQ93y78/Pp6jtPIfybn4bTyXN9MI/+ZrvGNY5bjn0b+ayPlh5Q9nRQz5elZSkpLlf8uVP4r++c04+taf9P8vk3ymzkJ08h/42gbd1fy674j/ZD/AAAAAGbEXOWp6mLcm+485r6BpTNPlpzzYZYW0SH4t48vSetTOv866GVoh2f471Fz/V1I63fcuOeltJDBUgUAAABQAQ5VAAAAABUYzFEdAAAA4N8ElioAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACnCoAgAAAKgAhyoAAACACvwPSNGXHo7ptjEAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Randomly select 100 data points to display\n", "rand_indices = np.random.choice(m, 100, replace=False)\n", @@ -158,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -267,10 +278,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ + "def _hypothesis(theta, X):\n", + " return utils.sigmoid(np.sum(X*theta, axis=1))\n", + "\n", + "def _J(theta, X, y):\n", + " h = _hypothesis(theta, X)\n", + " vector = (-y * np.log(h)) - ((1 - y) * np.log(1 - h))\n", + " J = (1 / y.size) * np.sum(vector)\n", + " return J\n", + "\n", + "def _dJ(theta, X, y):\n", + " h = _hypothesis(theta, X)\n", + " gradient = (1 / y.size) * np.sum(X.T * (h - y), axis=1)\n", + " return gradient\n", + "\n", + "def _Jreg(theta, X, y, lamb):\n", + " reg = (lamb / (2 * y.size)) * np.sum(theta[1:]**2)\n", + " return _J(theta, X, y) + reg\n", + "\n", + "def _dJreg(theta, X, y, lamb):\n", + " reg = np.zeros_like(theta)\n", + " reg[1:] = (lamb / y.size) * theta[1:]\n", + " return _dJ(theta, X, y) + reg\n", + "\n", "def lrCostFunction(theta, X, y, lambda_):\n", " \"\"\"\n", " Computes the cost of using theta as the parameter for regularized\n", @@ -336,21 +370,13 @@ " do the following: `utils.sigmoid(z)`.\n", " \n", " \"\"\"\n", - " #Initialize some useful values\n", - " m = y.size\n", - " \n", " # convert labels to ints if their type is bool\n", " if y.dtype == bool:\n", " y = y.astype(int)\n", - " \n", - " # You need to return the following variables correctly\n", - " J = 0\n", - " grad = np.zeros(theta.shape)\n", - " \n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - "\n", - " \n", + " # You need to return the following variables correctly\n", + " J = _Jreg(theta, X, y, lambda_)\n", + " grad = _dJreg(theta, X, y, lambda_)\n", " # =============================================================\n", " return J, grad" ] @@ -389,9 +415,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost : 2.534819\n", + "Expected cost: 2.534819\n", + "-----------------------\n", + "Gradients:\n", + " [0.146561, -0.548558, 0.724722, 1.398003]\n", + "Expected gradients:\n", + " [0.146561, -0.548558, 0.724722, 1.398003]\n" + ] + } + ], "source": [ "J, grad = lrCostFunction(theta_t, X_t, y_t, lambda_t)\n", "\n", @@ -417,9 +457,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Login (email address): ishivvers@gmail.com\n", + "Token: DAfOVWiJVJD91aKH\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 0 / 20 | \n", + " One-vs-All Classifier Prediction | 0 / 20 | \n", + " Neural Network Prediction Function | 0 / 30 | \n", + " --------------------------------\n", + " | 30 / 100 | \n", + "\n" + ] + } + ], "source": [ "# appends the implemented function in part 1 to the grader object\n", "grader[1] = lrCostFunction\n", @@ -448,7 +509,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -518,6 +579,7 @@ " \"\"\"\n", " # Some useful variables\n", " m, n = X.shape\n", + " initial_theta = np.zeros(n + 1)\n", " \n", " # You need to return the following variables correctly \n", " all_theta = np.zeros((num_labels, n + 1))\n", @@ -526,9 +588,15 @@ " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - " \n", - "\n", - "\n", + " for label in range(num_labels):\n", + " this_y = (y == label).astype(int)\n", + " res = optimize.minimize(lrCostFunction,\n", + " initial_theta,\n", + " (X, this_y, lambda_),\n", + " jac=True,\n", + " method='TNC',\n", + " options={'maxiter': 50})\n", + " all_theta[label, :] = res.x\n", " # ============================================================\n", " return all_theta" ] @@ -542,7 +610,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ @@ -559,9 +627,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 20 / 20 | Nice work!\n", + " One-vs-All Classifier Prediction | 0 / 20 | \n", + " Neural Network Prediction Function | 0 / 30 | \n", + " --------------------------------\n", + " | 50 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[2] = oneVsAll\n", "grader.grade()" @@ -580,7 +668,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "metadata": {}, "outputs": [], "source": [ @@ -624,7 +712,7 @@ " are in rows, then, you can use np.argmax(A, axis=1) to obtain the index \n", " of the max for each row.\n", " \"\"\"\n", - " m = X.shape[0];\n", + " m = X.shape[0]\n", " num_labels = all_theta.shape[0]\n", "\n", " # You need to return the following variables correctly \n", @@ -634,9 +722,11 @@ " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - "\n", - " \n", + " all_predictions = []\n", + " for idx_predictor in range(num_labels):\n", + " all_predictions.append(_hypothesis(all_theta[idx_predictor, :], X))\n", + " all_predictions = np.array(all_predictions)\n", + " p = np.argmax(all_predictions, axis=0)\n", " # ============================================================\n", " return p" ] @@ -650,9 +740,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 97, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 95.24%\n" + ] + } + ], "source": [ "pred = predictOneVsAll(all_theta, X)\n", "print('Training Set Accuracy: {:.2f}%'.format(np.mean(pred == y) * 100))" @@ -667,9 +765,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 98, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 20 / 20 | Nice work!\n", + " One-vs-All Classifier Prediction | 20 / 20 | Nice work!\n", + " Neural Network Prediction Function | 0 / 30 | \n", + " --------------------------------\n", + " | 70 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[3] = predictOneVsAll\n", "grader.grade()" @@ -690,9 +808,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 130, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# training data stored in arrays X, y\n", "data = loadmat(os.path.join('Data', 'ex3data1.mat'))\n", @@ -735,7 +864,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 131, "metadata": {}, "outputs": [], "source": [ @@ -774,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 152, "metadata": {}, "outputs": [], "source": [ @@ -830,12 +959,15 @@ " num_labels = Theta2.shape[0]\n", "\n", " # You need to return the following variables correctly \n", - " p = np.zeros(X.shape[0])\n", + " p = np.zeros(m)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - "\n", - "\n", + " a1 = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + " z2 = np.dot(Theta1, a1.T).T\n", + " a2 = np.concatenate([np.ones((m, 1)), utils.sigmoid(z2)], axis=1)\n", + " z3 = np.dot(Theta2, a2.T).T\n", + " h = utils.sigmoid(z3)\n", + " p = np.argmax(h, axis=1)\n", " # =============================================================\n", " return p" ] @@ -849,9 +981,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 153, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 97.5%\n" + ] + } + ], "source": [ "pred = predict(Theta1, Theta2, X)\n", "print('Training Set Accuracy: {:.1f}%'.format(np.mean(pred == y) * 100))" @@ -868,9 +1008,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 157, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neural Network Prediction: 3\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "if indices.size > 0:\n", " i, indices = indices[0], indices[1:]\n", @@ -890,9 +1048,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 158, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Use token from last successful submission (ishivvers@gmail.com)? (Y/n): \n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 20 / 20 | Nice work!\n", + " One-vs-All Classifier Prediction | 20 / 20 | Nice work!\n", + " Neural Network Prediction Function | 30 / 30 | Nice work!\n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[4] = predict\n", "grader.grade()" @@ -915,7 +1093,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.9" } }, "nbformat": 4, diff --git a/requirements.txt b/requirements.txt index 2890a287..fd82043f 100755 --- a/requirements.txt +++ b/requirements.txt @@ -29,8 +29,8 @@ jupyter-core==4.4.0 MarkupSafe==1.0 matplotlib==2.1.2 mistune==0.8.3 -mkl-fft==1.0.4 -mkl-random==1.0.1 +mkl-fft +mkl-random nbconvert==5.3.1 nbformat==4.4.0 notebook==5.7.8