{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Programming Set 2" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#imports\n", "\n", "%matplotlib inline\n", "\n", "import matplotlib.lines as mlines\n", "import time\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.patches as mpatches\n", "import pandas as pd\n", "import scipy.spatial" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Code from Task 1" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# computes the alpha minimizing the LLS function given by the points X_in and the labels Y_in.\n", "\n", "def linear_least_square(X_in, Y_in):\n", " _X = np.matrix(X_in)\n", " _y = np.matrix(Y_in)\n", " alpha = np.linalg.solve(np.dot(_X.T, _X), np.dot(_X.T,_y.T))\n", " return alpha" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# creates the linear function resulting from the vector alpha, which minimizes the LLS.\n", "\n", "def make_minimal_linear_function(X_in, Y_in):\n", " X_hat = np.ones((np.size(Y_in),np.size(X_in[0][:])+1))\n", " X_hat[:,1:] = X_in[:,:]\n", " _alpha = linear_least_square(X_hat, Y_in)\n", " def minimal_linear_function(_x):\n", " return _alpha[0] + np.dot(_alpha[1:,:].T, _x.T)\n", " return minimal_linear_function" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# for a given characterization function, this creates the function, which returns interger labels, by rounding the result.\n", "\n", "def make_label_function(function):\n", " def label_function(_x):\n", " return_val = np.array(np.int_(function(_x).flat))\n", " for i in range(np.size(return_val)):\n", " if return_val[i] < 0:\n", " return_val[i] = -1\n", " if return_val[i] > 0:\n", " return_val[i] = 1\n", " return return_val\n", " return label_function" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def confusion_matrix(points, labels, classifier_function):\n", " CM = np.zeros((2,2))\n", " our_labels = classifier_function(points[:,:])\n", " for k in range(np.size(labels)):\n", " label = int(labels[k])\n", " our_label = our_labels[k]\n", " if(label == -1):\n", " label = 0\n", " if(our_label == -1):\n", " our_label = 0\n", " CM[our_label][label] = CM[our_label][label] +1\n", " return CM\n", "\n", "def accuracyC(C):\n", " return np.trace(C)/np.sum(C)\n", "\n", "def accuracy(points, labels, classifier_function):\n", " C = confusion_matrix(points,labels,classifier_function)\n", " return accuracyC(C) " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# plots the contour line for a given function.\n", "\n", "def PlotContourLine(func, value=0, minx = -5, maxx = 5, miny = -5, maxy = 5):\n", " #This plots the contourline func(x) = value\n", " \n", " samplenum = 1000\n", "\n", " xrange = np.arange(minx, maxx, (maxx-minx)/samplenum)\n", " yrange = np.arange(miny, maxy, (maxy-miny)/samplenum)\n", " \n", " #This generates a two-dimensional mesh\n", " X, Y = np.meshgrid(xrange,yrange)\n", " \n", " argsForf = np.array([X.flatten(),Y.flatten()]).T\n", " Z = func(argsForf)\n", " Z = np.reshape(Z,X.shape)\n", " \n", " plt.xlim(minx, maxx)\n", " plt.ylim(miny, maxy)\n", " plt.xlabel(r'$x_1$')\n", " plt.ylabel(r'$x_2$')\n", "\n", " Z = np.where(Z > value, -1, 1)\n", " plt.contourf(X, Y, Z)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.1 & Task 2.3 & Task 2.5 (parts)\n", "\n", "Somehow it seemed to make sense to implement a class for the SMO algorithm, so that we can operate on the class objects. But for that I had to put these two tasks in one block." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# the standart scalar product of x1 and x2\n", "def scalarProduct(x1, x2):\n", " return np.dot((x1),(x2).T)\n", " \n", "\n", "class SequentialMinimalOptimizer:\n", " def __init__(self, dataPoints, labels, regularizationConstant, kernalFunction = scalarProduct):\n", " self.n = np.size(labels) #number of points\n", " self.x = np.matrix(dataPoints) #training data points\n", " self.y = np.matrix(labels) #training data labels\n", " self.beta = np.matrix(np.zeros(self.n)) #this will be modified during the alg.\n", " self.b = 0 #y-intersect calculated function\n", " self.C = regularizationConstant #the regularization constant for the SMO\n", " self.iteri = 0 #iterator for the first KKT variable\n", " self.kernalFunction = kernalFunction #the kernal function we want to run SMO with\n", " \n", " #scalar product on points with indices i,j induced by the kernal function.\n", " def scalarProductX(self, i, j):\n", " return self.kernalFunction(self.x[i,:], self.x[j,:])\n", " \n", " #function evaluation on index i\n", " def fx(self, i):\n", " return np.dot(np.multiply(self.beta, self.y), self.scalarProductX(i,range(self.n)).T) + self.b\n", " \n", " #one step rountine modifying beta and b\n", " def performOneStep(self, i, j):\n", " delta = np.asscalar(self.y[:,i]*((self.fx(j)-self.y[:,j])-(self.fx(i)-self.y[:,i])))\n", " s = np.asscalar(self.y[:,i]*self.y[:,j])\n", " chi = np.asscalar(self.scalarProductX(i, i) + self.scalarProductX(j, j) - 2*self.scalarProductX(i, j))\n", " gamma = np.asscalar(s*self.beta[:,i] + self.beta[:,j])\n", " if np.int(s)==np.int(1):\n", " L = max(gamma-self.C,0)\n", " H = min(gamma, self.C)\n", " else:\n", " L = max(-gamma,0)\n", " H = min(self.C - gamma, self.C)\n", " if chi>0:\n", " self.beta[:,i] = min(max(self.beta[:,i]+delta/chi, L), H)\n", " elif delta>0:\n", " self.beta[:,i] = L\n", " else:\n", " self.beta[:,i] = H\n", " self.beta[:,j] = gamma - s*self.beta[:,i]\n", " self.b = self.b - 1/2 * (self.fx(i) - self.y[:,i] + self.fx(j) - self.y[:,j])\n", "\n", " #generates two random disjoint indices\n", " def getRandomDisjointIndices(self):\n", " while True:\n", " i,j = np.random.randint(self.n, size=2)\n", " if i != j:\n", " return i, j\n", " \n", " #evaluates the KKT function on xi\n", " def KKT(self, i):\n", " yifi1 = np.asscalar(self.y[:,i]*self.fx(i)) -1\n", " betai = self.beta[:,i]\n", " return (self.C - betai)*max(0, -yifi1) + betai*max(0,yifi1)\n", " \n", " #generates two disjoint indices with the KKT heuristic\n", " def getKKTDisjonintIndices(self):\n", " margins = self.marginIndices()\n", " i = self.iteri + 1\n", " while i != self.iteri:\n", " if(i==self.n):\n", " i=0\n", " if(not (self.KKT(i)>0)):\n", " i = i+1\n", " continue\n", " self.iteri = i\n", " if i in margins:\n", " margins.remove(i)\n", " if(np.size(margins)>0):\n", " j = np.asscalar(np.random.choice(margins, 1))\n", " return i, j\n", " else:\n", " while True:\n", " j = np.random.randint(self.n, size=1)\n", " if i != j:\n", " return i, j\n", " return -1, -1\n", " \n", " #returns the support indices (i.e. beta_i>0)\n", " def supportIndices(self):\n", " full = np.nonzero(self.beta)\n", " if(np.size(full)>0):\n", " return full[1].tolist()\n", " else:\n", " return []\n", " \n", " #returns the margin indices (i.e. beta_i 0),(self.beta < self.C)))\n", " if(np.size(full)>0):\n", " return full[:,1].tolist()\n", " else:\n", " return []\n", " \n", " #readjusts b in the end of the algorithm\n", " def readjustb(self):\n", " nonzeros = self.supportIndices()\n", " self.b = self.b - np.median(np.asarray(self.fx(nonzeros) - self.y[:,nonzeros]))\n", " \n", " #runs the SMO with the KKT heuristic\n", " def runKKT(self, iterations):\n", " start = time.time()\n", " for iteration in range(iterations):\n", " i, j = self.getKKTDisjonintIndices()\n", " if(i==-1):\n", " break\n", " self.performOneStep(i, j)\n", " self.readjustb()\n", " return time.time() - start\n", " \n", " #runs the SMO with randomly generated index pairs\n", " def runSMO(self, iterations):\n", " start = time.time()\n", " for iteration in range(iterations):\n", " i, j = self.getRandomDisjointIndices()\n", " self.performOneStep(i, j)\n", " self.readjustb()\n", " return time.time() - start\n", "\n", " #returns the calculated function\n", " def outputf(self):\n", " def f(x):\n", " return np.dot(np.multiply(self.beta, self.y), self.kernalFunction(x, self.x).T) + self.b\n", " return f" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.2" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "#generates exponentially random distibuted points\n", "def generate_exp_x_y(n):\n", " x = np.zeros((2*n,2))\n", " x[:n,:] = np.random.exponential(1/4, (n,2))\n", " x[n:,:] = np.random.exponential(2, (n,2))\n", " y = np.ones(2*n)\n", " y[:n] = -1\n", " return x, y" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "small_x, small_y = generate_exp_x_y(20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.3" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [], "source": [ "#helper function, which creates plots for a solution of an optimizer.\n", "def plotResult(points, labels, optimizer, f, runtime, minx=-1, maxx=1, miny=-1, maxy=1):\n", " n = np.int_(np.size(labels)/2)\n", " plt.figure(figsize=(10,10))\n", " PlotContourLine(func=f,value=.0, minx=minx, maxx=maxx, miny=miny, maxy=maxy)\n", " plt.scatter(points[:n,0],points[:n,1],marker='o',c='orange')\n", " plt.scatter(points[n:,0],points[n:,1],marker='o',c='blue')\n", " supporter = optimizer.supportIndices()\n", " plt.scatter(points[supporter,0],points[supporter,1],marker='+',c='black')\n", " marginer = optimizer.marginIndices()\n", " plt.scatter(points[marginer,0],points[marginer,1],marker='d',c='black')\n", " label_p1 = mlines.Line2D([], [], color='blue', marker='o', linestyle='None',\n", " markersize=10, label='label = 1')\n", " label_m1 = mlines.Line2D([], [], color='orange', marker='o', linestyle='None',\n", " markersize=10, label='label = -1')\n", " label_sup = mlines.Line2D([], [], color='black', marker='+', linestyle='None',\n", " markersize=10, label='Support')\n", " label_marg = mlines.Line2D([], [], color='black', marker='d', linestyle='None',\n", " markersize=10, label='Margin')\n", " \n", " plt.legend(handles=[label_m1, label_p1, label_sup, label_marg])\n", " plt.show()\n", " print(\"C = \" + str(optimizer.C) + \n", " \"; #support = \" + str(np.size(supporter)) + \n", " \"; #margin = \" + str(np.size(marginer)) + \n", " \"; runtime = \" + (\"%.2f\" % runtime) + \"s\")\n", "\n", "#Helper function, which runs the optimization for different C and plots the results.\n", "#The results are calculated using the optimizaion mode defined by optmode.\n", "def plot23(points, labels, optmode):\n", " function_storage = []\n", " for C in [0.01, 1, 100]:\n", " optimizer = SequentialMinimalOptimizer(points, labels, C)\n", " runtime = optmode(optimizer)\n", " f = optimizer.outputf()\n", " plotResult(points, labels, optimizer, f, runtime, minx=-1, maxx=6, miny=-1, maxy=6)\n", " function_storage = function_storage + [[C, f]]\n", " return function_storage" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 0.01; #support = 33; #margin = 1; runtime = 3.85s\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 1; #support = 9; #margin = 3; runtime = 4.01s\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 100; #support = 3; #margin = 3; runtime = 4.06s\n" ] } ], "source": [ "#defines the opmode, which runs the normal SMO alg.\n", "def smoopt(optimizer):\n", " return optimizer.runSMO(10000)\n", "small_functions = plot23(small_x, small_y, smoopt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We observe, that with increasing C the number of support vectors decreases and the number of margin vectors increases. The seperating hyperplane tends to seperate the points better. It moves closer to dense points and is, by the margin vectors, aligned to the boundary." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#calculate a hyperplane with LLS\n", "small_lin_f = make_minimal_linear_function(small_x, small_y)\n", "\n", "PlotContourLine(func=small_lin_f,value=.0, minx=-1, maxx=6, miny=-1, maxy=6)\n", "plt.scatter(small_x[:20,0],small_x[:20,1],marker='+',c='orange')\n", "plt.scatter(small_x[20:,0],small_x[20:,1],marker='+',c='blue')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The result, we get with the SMO seem to ba a lot better, than the result we get with the LLS. This can be seen in the plots and the accuracys in task 2.4." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we evaluate the calculated functions from the previous task on a bigger test vector set computed by the same distribution." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "test_x, test_y = generate_exp_x_y(1000)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SVM: accuracy = 0.556; C = 0.01\n", "SVM: accuracy = 0.8335; C = 1\n", "SVM: accuracy = 0.8705; C = 100\n", "LLS: accuracy = 0.5805\n" ] } ], "source": [ "for pair in small_functions:\n", " print(\"SVM: accuracy = \" + str(accuracy(test_x, test_y, make_label_function(pair[1]))) + \"; C = \" + str(pair[0]))\n", "print(\"LLS: accuracy = \" + str(accuracy(test_x, test_y, make_label_function(small_lin_f))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.5" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 0.01; #support = 32; #margin = 0; runtime = 0.26s\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 1; #support = 9; #margin = 3; runtime = 0.13s\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 100; #support = 3; #margin = 3; runtime = 0.50s\n" ] } ], "source": [ "#defines the opmode, which runs the KKT SMO alg.\n", "def kktopt(optimizer):\n", " return optimizer.runKKT(10000)\n", "small_functions_kkt = plot23(small_x, small_y, kktopt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Again we test our results on the test data." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SVM KKT: accuracy = 0.5585; C = 0.01\n", "SVM KKT: accuracy = 0.8335; C = 1\n", "SVM KKT: accuracy = 0.871; C = 100\n", "LLS: accuracy = 0.5805\n" ] } ], "source": [ "for pair in small_functions_kkt:\n", " print(\"SVM KKT: accuracy = \" + str(accuracy(test_x, test_y, make_label_function(pair[1]))) + \"; C = \" + str(pair[0]))\n", "print(\"LLS: accuracy = \" + str(accuracy(test_x, test_y, make_label_function(small_lin_f))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When C is not too big KKT aktually extreamley speeds up the convergence. But it seems, that finding two indices with KKT takes way longer than just taking two random indices. Probably this can be speeded up a lot, but as I think the task is to get an idea of the matter and not to implement some high performance code, this should be sufficient." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.6" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "#generates points and label in a circle and the band surrounding it.\n", "def generateTwoCircles_x_y(n):\n", " def inCircle(x,r):\n", " return (np.linalg.norm(x)<=r)\n", " def inBand(x,r1,r2):\n", " return (inCircle(x,r2) and (not inCircle(x,r1)))\n", " def getRand(r):\n", " return np.random.uniform(-r,r,2)\n", " \n", " x_vec = np.empty((2*n,2))\n", " n1 = 0\n", " while(n1" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 10; #support = 99; #margin = 16; runtime = 4.21s\n" ] } ], "source": [ "circle_optimizer = SequentialMinimalOptimizer(circle_x, circle_y, 10)\n", "circle_runtime = smoopt(circle_optimizer)\n", "circle_f = circle_optimizer.outputf()\n", "plotResult(circle_x, circle_y, circle_optimizer, circle_f, circle_runtime, minx=-2, maxx=2, miny=-2, maxy=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This does not look too good. Lets see, whether we can do better in (b)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (b)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "#defines the transformation from 2D -> 3D where the third coordinate is the squared norm of the vector.\n", "def circleTransform(x_in):\n", " x1 = np.matrix(x_in[:,0])\n", " x2 = np.matrix(x_in[:,1])\n", " n = np.size(x1)\n", " x = np.empty((n,3))\n", " x[:,0] = x1\n", " x[:,1] = x2\n", " x[:,2] = np.multiply(x1,x1) + np.multiply(x2,x2)\n", " return x\n", "\n", "#defines a 2D function for a given 3D function by precomposing the circle trafo.\n", "def generate2DfunctionFrom3D(f):\n", " def func(x):\n", " return f(circleTransform(x));\n", " return func" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "circle_transform_x = circleTransform(circle_x)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 10; #support = 13; #margin = 9; runtime = 3.98s\n" ] } ], "source": [ "circle_transform_optimizer = SequentialMinimalOptimizer(circle_transform_x, circle_y, 10)\n", "circle_transform_runtime = smoopt(circle_transform_optimizer)\n", "circle_transform_f = generate2DfunctionFrom3D(circle_transform_optimizer.outputf())\n", "plotResult(circle_x, circle_y, circle_transform_optimizer, circle_transform_f, circle_transform_runtime, minx=-2, maxx=2, miny=-2, maxy=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The featur map transforms the data to 3D, where each x3 coordinate is the norm of the point. As we constructed the points such that they circles of different radii, the two labels have different norms (label -1 : > 1 and label 1 : <=1). Thus the two sets are seperabele in 3D with a hyperplane parralel two the x1-x2-plane at hight x3=1. And it seems, that we are prtty good in finding it :D" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.7" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "#generates a Gaussian kernal for a given sigma\n", "def generateGaussianKernal(sigma):\n", " def gaussianKernal(x1, x2):\n", " n1 = np.size(x1,0)\n", " n2 = np.size(x2,0)\n", " norms = np.empty((n1,n2))\n", " for j in range(n2):\n", " norms[:,j] = np.linalg.norm(np.subtract(x1[:,:],x2[j,:]),axis=1)\n", " return np.exp(-norms / (2*sigma**2))\n", " return gaussianKernal" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we try the above, but we replace the Euclidean scalar product by a Gaussian kernal function." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAJSCAYAAACoQEOdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xl4VOXZP/DvM0lmkgkTIJAQgwLFEqRvtARDQOtCFcWlRSmbphZ5W5cWakULFeuCgvW1r9alQlq1tRYVRUAUfyhWa1OlFmIAK6gYlhcQspKEZJLJPs/vj0kgyySZ5Zx5zjnz/VwXl5lnJmduIpO551nuW0gpQURERETmZFMdABERERGFjskcERERkYkxmSMiIiIyMSZzRERERCbGZI6IiIjIxJjMEREREZmY8mROCHGGEOIfQogvhBCfCyFu9/MYIYT4vRBivxDiMyHEBBWxEhERERlNrOoAALQC+KWUcqcQwgVghxDiPSnlF50ecyWAMe1/JgH4Q/t/iYiIiKKa8pk5KWWJlHJn+9duAF8CGN7tYdcAWC19tgEYJIQ4LcKhEhERERmOEWbmThJCjAKQBWB7t7uGA/i60+2j7WMl3b7/FgC3AIDTKc79xpmG+usRERER+fX57pbjUsqUUL7XMNmOEGIAgA0AFkkpa0O5hpTyWQDPAkDmOXa5YfNQDSMkIiIi0sdZI0oOh/q9ypdZAUAIEQdfIveylPJ1Pw85BuCMTrdPbx8jIiIiimrKkzkhhADwZwBfSikf7+VhmwDMaz/VOhlAjZSypJfHEhEREUUNIyyzfgfAjwDsFkJ82j72awAjAEBK+UcAbwO4CsB+AB4A/60gTiIiIiLDUZ7MSSm3AhD9PEYCWBiZiIiIiKgzr3cgWuvvgGwbCQMs6pmYFyLmMGITn4DNVqPZVZUnc0RERGRsrfV3YGjyBAwaHAvf7igKhZQS1dVDUFl1B+yuBzS7LtNrIiIi6pNsG8lETgNCCAweHNs+w6kdJnNERETUDxsTOY34fo7apl9cZiUiIiLNiLqvEVO0GjFH3gZaPUCsE20jrkJbxjzIAWf0fwEKGmfmiIiISBO2kq2wvzcbMf+3EaK1HgISorUeMf+3Efb3ZsNWsjWk6w5NPq/P+w8fOoZzs2YGdc2bb7oPr7/+Xkjx9GbrRztw3qTrMMB5rubX7guTOSIiIgqbqPsacdsWQ7Q1QsjWrvfJVoi2Rt/9dV/3cgXzO+OMNDz7p+WYe92VEX1eJnNEREQUtpii1YC3te8HeVsRs++lkJ+jrs6DK6fdgvMmXYfsCbPw1qZ/nLyvtbUN82+8G+PPmYHrr1sMj6cBALBz5xe4bOpPcP7k6/H9q3+GkpKKkJ+/PyNHDcfZZ2fAZovs/kImc0RERBS2mCNv95iR607IVsQc/n8hP0d8vB1r1z2Of29/FVv+9hyW3vU4fKVogaKiQ7jl1jn49LONSEpKxDN/fA0tLS24845HsOaVR/Hxtlcwb/61eGDZyj6f4/HfvYBJE+f0+HPnHb8NOW698QAEERERha/Vo+3j/JBS4v77nsa/tu6EzSZQXFyOsrJKAMDpZ6Th/POzAADXX381Vq1ag8unfQdffH4A37vqpwCAtjYv0tKG9vkcd/5yPu785fyQY1SByRwRERGFL9YJtNYH9rgQvfrK2zh+vBofb1uDuLg4jM24Ek2NTQDQo3SKEAJSSoz71pn454erA36Ox3/3Ata++naP8e9ccC4ef+KuLmPL7n8aW975CACw/ZPXgv3raIbJHBFRFHKVe5ByyI3YJi9aHTZUjHLBnRr6myxR24irfKdY+1hqlSIWbSO/F/Jz1NTUISUlGXFxcfhn/ic4crjk5H1fHynBtm3/weTJ38bate/g/POzkJExCscrqk+Ot7S0YN++w/jWt77Z63MEMzP34PLb8ODy20L++2iFe+aIiKKMq9yDtH01iGvyQgCIa/IibV8NXOWhL38RtWXMA2z9zBHZYtE25oaQn+O666/Czp1fIHvCLLz88lsYO/YbJ+/LyBiFZ/64FuPPmYHq6lrccuts2O1xWPPqo7j3nqeQkz0HkybOxbZ//yfk5+9PYeEenDn6cry+4T3ctvAhTBj/A92eqzPRsXHQajLPscsNm/teFyciikajC8oQ1+TtMd7isOFgzjAFEZHRNZ34KzLGpvb7OFvJVsRtWwx4W7vM0EkRC9hi0TL5MXhPu0DPUE2h6KtyOAbd2GXsrBElO6SU2aFcjzNzRERRJtZPItfXOFGgvKddgObL1qFt9EzI2ERICMjYRLSNnonmy9YxkdMJ98wREUWZVofN78xcq4Of7yl8csAZaM26G61Zd6sOJWrwlUtEFGUqRrng7fbb32vzjROR+XBmjogoynScWuVpViJrYDJHRBSF3KlOJm9EFsFlViIiItLMwQN23P6L4Ugdmgln/DlIHZqJ238xHAcP2FWHZllM5oiIiEgT725xYWJ2Bv7yfDLc7hhIKeB2x+AvzydjYnYG3t0S2r7Mocnn9Xn/4UPHcG7WzKCuefNN9+H1198LKZ7Opn9vAdJSL8APrlVXPJjJHBEREYXt4AE7cq8fCY8nBi0tXdOLlhYbPJ4Y5F4/0nIzdHfceSP+/PxvlMbAZI6IiIjC9tRTKWhpEX0+pqVF4Pe/Twn5OerqPLhy2i04b9J1yJ4wC29t+sfJ+1pb2zD/xrsx/pwZuP66xfB4GgAAO3d+gcum/gTnT74e37/6ZygpqQj5+f357iWT4HKp3X/KZI6IiIjC9sqawT1m5LprabHhlTWDQ36O+Hg71q57HP/e/iq2/O05LL3rcXR0sioqOoRbbp2DTz/biKSkRDzzx9fQ0tKCO+94BGteeRQfb3sF8+ZfiweWrezzOR7/3QuYNHFOjz933vHbkOPWG0+zEhERUdjq6gKbH3IH+Dh/pJS4/76n8a+tO2GzCRQXl6OsrBIAcPoZaTj//CwAwPXXX41Vq9bg8mnfwRefH8D3rvopAKCtzYu0tL5bfd75y/m485fzQ45RBSZzREREFLYBA7xwu2P6fZxrQOht41595W0cP16Nj7etQVxcHMZmXImmxiYAgBBdl3iFEJBSYty3zsQ/P1wd8HM8/rsXsPbVt3uMf+eCc/H4E3eFHLuemMwRERFR2K7PrcZfnk/uc6k1Ls6L63OrQ36Ompo6pKQkIy4uDv/M/wRHDpecvO/rIyXYtu0/mDz521i79h2cf34WMjJG4XhF9cnxlpYW7Nt3GN/61jd7fQ4zzsxxzxwRERGF7fbbKxAXJ/t8TFycxC9+EfoBhOuuvwo7d36B7Amz8PLLb2Hs2G+cvC8jYxSe+eNajD9nBqqra3HLrbNht8dhzauP4t57nkJO9hxMmjgX2/79n5Cf359LL/lv/DD3V/jHPwpw5ujL8d7fPtb0+oEQHRsHrSbzHLvcsLnvdXEiIiLqX9OJvyJjbGq/j3t3iwu5149ES4voMkMXF+dFXJzEmlcOY9oVbj1DNYWir8rhGHRjl7GzRpTskFJmh3I9zswRmYSr3IPRBWXI+KgEowvK4Cr3qA6JiKiLaVe48UlhEX78kyokJbVB2CSSktrw459U4ZPCIiZyOuGeOSITcJV7kLavBrb2fcNxTV6k7asBAOX9NctK2zAsrf9Nz0QUHUaf2YwnnzqGJ586pjqUqMGZOSITSDnkPpnIdbB5feMqFW5vxpRJ5dhR0Kw0DiKiaMZkjsgEYpv8H+XvbTwSEorrcVNuJaQE7ltYiYTiemWxEBFFMyZzRCbQ6vD/Uu1tXG+ucg/Wr6pFc6vvdtkJYENeLffxEREpwGSOyAQqRrng7fZq9dp84yrMzK3BkpcAb/th+PomYPGLgPfTWiXxEJExPbTiD6pDiApM5ohMwJ3qROmYgWhx2CABtDhsKB0zUNnhh4oTQPeiRhLAunxrljoiotD85qFnNLvWbx95DhPG/wATz52NSRPnoKBgt2bXDsbTv38JHk+DkufuDU+zEpmEO9Wp/ORqh/yHBc5aKFHfdGrMaQdmTxHgzjki0tq2bf/B229/hH9vfxUOhx3Hj1ejubkl4nG0tbVh5cqXcX3u1XA6EyL+/L3hzBwRBc02PgnL5wC29laIiQ5gxVzfOBGR1kpLj2PokEFwOOwAgKFDByM9PRVjM67E8eO+9mA7dnyOyy/7CQDf8u6P//seXHzRPGR+6/t4/s8bAAAf/vMTTL30x5hxzc9xTuY1uG3hQ/B6fQfJ1q59B9kTZuHcrJm459dPnnzuocnn4a5f/Q452XPw20f+hJLiClxx+c2YdvlNkfwR9InJHBEFzZ3qxKyFSRjVXhB+2CBg5oIkw8wcEpG1TJ16Ho4eLcXZ/zUdt9/2G3z0YWG/37Nn9z5sefdZ5H+4Gg8//CyKi8sBAIWf7MHjTyzFrv+8joMHv8Ybb/wdxcXluPeep/DOu89i+ydrsWPH59j05gcAgPr6BkzMyURB4Wv49T234rT0FGz523N4929/0vXvHAwmc0QUkob0RCxfOQRCACtWDUFDeqLqkIhIoYdW/AEJjvFd/gDoMRbKoYgBA5z4eNsrWJV3H4amDMaPbrgLL65+s8/v+d73pyAhIR5Dhw7GxRdPROEnewAA2RMz8Y3RpyMmJgZz5l6Jj/+1CzsKP8dFF2UjJSUZsbGxuO66q7B1604AQExMDGbMmBp0zJHEPXNEFLLsSXbkb09lBwgiwr33/Qz33vezLmMJjvFoaPpUk+vHxMTgoosn4qKLJ+K/Msfg5RffQmxMLLztx+obG7sWLxcC3W6LLv/tPt6b+Hg7YmKM/TuOM3NEFBYmckSkt6KvDmH/vsMnb3/2n69wxojTMHJkOnbt/AIA8MbG97t8z/97Kx+NjU2orDyBDz8sxLnZ/wXAt8x66P+Owev1Yv26d3H+d7KQPTETH320A8ePV6OtrQ2vrd2CCy88128srgGJqHMbq6YmZ+aIiIjI0OrqPbjzjkdQc6IOsbExGH3mGViVdx/27v0//OzWB7D8wTxceFF2l+/JPDsD0y6/GZXHq3H33TcjPT0V+/cdxrnZ/4U7Fv0PDhz4GhdfPBHXXHMJbDYbVjz0C1xx+c2QUuKKKy/E96d/128sP/7JTEz//gKclp5imH1zQkpr1oXKPMcuN2weqjoMIiIi02s68VdkjE0N+vu0XGYNxkMr/oDERCfuuPPGLuMf/vMTPPnEarz+xtMRj6mzoq/K4RjUNbazRpTskFJm9/ItfeIyKxEREeninntvVR1CVODMHBEREfUp1Jk58o8zc0RERER0EpM5IiIi0tyRIyW46IIf4ciREtWhWB5PsxIRUdRzlXuQcsiN2CYvWh02VIxyKeloYpQ4tPDLO3+LHTs+xy/v/C3WrX+y/2+gkHFmjoiIopqr3IO0fTWIa/JCAIhr8iJtXw1c5ZGtJWaUOLTw739/ir+/vw1erxd/f38b/v3vyJ9ojSZM5oiITKCstE11CJaVcsgNm7frmM3rG4/GOMLl9Xqx4KfL0dDQCABoaGjEwp8tP9nQPlQJjvH47/m/Pnm7tbUVZwz/Ln5w7W1hXbezn/30QXz55QHNrhcpTOaIFOObNPWncHszpkwqx46C5v4fTEGLbfKfZPQ2bvU4wvXKms34+uuu++SOHCnBq6+8HdZ1ExMT8MXn+08miX9/fxvS01OCukZra2uf9//hj8swbtyZIceoCpM5IoX4Jk39SSiux025lZASuG9hJRKK61WHZDmtDv9vhb2NWz2OcNTVebBk8aOor2/oMl5f34DFfsaDNe2KC/DOOx8BAF57bQtmz73y5H2ffLIbF180D5Nz5mLKxfNQ9NUhAMCLq9/ErB/cjium3Ywrr7gVXq8Xt9/2G3z77Gtx9ZW34trpC/H66+8BAC6/7CfYseNzAMDQ5POw7P6nkZM9Bxdd+COUlVWGFbuezPMvhMhi+CZN/XGVe7B+VS2a2ycTyk4AG/JqTbmHysgqRrng7fZu6LX5xqMxjnD89pHnejS879DY0ITfPvJcWNefPecKrHvtXTQ2NmHP7iLkTMw8ed/Ysd/A3z94HtsK1uL++xfg/vtPdXnY9emXWPPKY3jv/T/jjTf+jsOHi7HrP6/jz3/5DbZv/8zvc9XXNyAn5xwUFL6GCy6YgL88/3pYseuJyRyRAnyTpkDMzK3BkpcAb3tt9/omYPGLgPfTWrWBWYw71YnSMQPR4rBBAmhx2FA6ZmDET5EaJY5wPPfc+pPLoN01NDTi2WfXhXX9s8/OwJHDxXht7TuYdsUFXe6rqalD7vVLcG7WTPxqyWP48otTe98uvXQykpMHAgA+/tcu/GDmZbDZbEhLG4qLLp7o97ns9jhcdfVFAICsCd/C4cPFYcWuJ5YmIVJgZm4NCvb1fJOefVEtcLl5fnGTvipOAN179EgA6/IlrrpcRUTW5U51GiJpMkocobr55llYtfIVvwldgjMet9wyJ+znuPp7F+PupU/g3ff+hKrKEyfHlz+4ChdfPBGvrXsChw8dw+WX33TyPqczIejniYuLhRACABATY+t3v51KnJkjUqCvN2miDvkPCzjtXcecdmD2FKEmIKJ+3LX0ZsTH2/3eFx/vwF1Lb/J7XzDm3Xgtfn3PrcjMHNNlvKamDunDfS3HXnxxU6/ff9754/HGxr/D6/WirKwSH31YGHZMqjGZI1KAb9IUCNv4JCyfA9ja/1kkOoAVc33jREY0YIATjz62BImJXWfCEhMT8Jif8VCcfvowLPx5bo/xO385H/ff+3tMzpmL1tbeqwTMmDEVw4cPQ9a3f4Afz/81xo8fh4FJA8KOSyUhpTVnAjLPscsNm4eqDoPIL1e5B68+dWo/VMeb9NxfmGt/DOkvobge372mFgfLgNHDgH+8mYSG9ETVYVGUaTrxV2SMTQ3osV6vF+dmzcLevQdPjo0bNxqFO9fDZjPGHFJdnQcDBjhRWXkCF37nBnyQ/wLS0iKXMxR9VQ7HoBu7jJ01omSHlDI7lOsZ46dKFGXcqU7MWpiEUe2/G4cNAmYuSGIiRz00pCdi+cohEAJYsWoIEzkyPJvNhrw/3o+EhHgAQEJCPPL+uMwwiRwA/GDGbZg0cQ6mXvJj3P3rmyOayOlB+QEIIcTzAL4HoFxKmenn/ikA3gTwf+1Dr0spl0cuQiJ9+N6k4/CjOZXtb9L+95kQZU+yI397KoalxagOhSgg5503HpdOnYy3N3+IS6dOxuTJ31YdUhd/e+/PqkPQlPJkDsALAFYCWN3HYz6SUn4vMuEQRQ7fpClQ/DdCankhpTx5ujMQv3v8LpSVVuJ3j9+lY1zm49vepm1XD+XJnJTyQyHEKNVxEKnCN2miyHKVe5ByyI3YJi9aHTZUjHJxi0M/RMxhVFcPweDBsQEndCNGnIYPt76oc2TmIqVEdXUrRMxhTa+rPJkL0HlCiP8AKAawWEr5ub8HCSFuAXALAKQP5xskERF15Sr3IG1fzcmG9nFNXqTtqwEAJnR9iE18ApVVd+B4xUhwu304vBAxhxGb+ISmVzVDMrcTwEgpZZ0Q4ioAbwAY4++BUspnATwL+E6zRi5EIiIyg5RD7pOJXAeb1zfOZK53NlsN7K4HVIdBvTB8ei2lrJVS1rV//TaAOCGEuY+dEBGRErFN/vcq9TZOZAaGn5kTQqQBKJNSSiFEDnwJaKXisIiIyCQ675HrTavD8HMbRL1SnswJIV4BMAXAUCHEUQDLAMQBgJTyjwBmAfiZEKIVQAOA66RVKx0TEZGmuu+RA3yt8zpv4ffagIpRrkiHRqQZ5cmclPL6fu5fCV/pEiIioqD42yMncKo3Mk+zkhUoT+aIiIj00tfSatGFp0UwEiL9MJmjoLFGExGZRavDhjg/CR33yJGV8F8zBaVj/0lckxcCp2o0uco9qkMjIuqhYpQL3m7vdNwjR1bDZI6C0leNJiIio3GnOlE6ZiBaHDZIAC0OG0rHDORqAlkKl1kpKKzRRERm4051MnkjS+PMHAWlt30m3H9CRESkBt+BKSjcf0JERGQsXGaloHQsVfA0KxERkTEwmaOgcf8JERGRcXCZlYiIiMjEODNHRESGw+LkRIFjMkdERIbSUZy8o6ZlR3FyAEzoiPzgMisRERkKi5MTBYfJHBERGQqLkxMFh8kcEREZCouTEwWHrwwiIjIUFicnCg4PQBARkaGwOLm58OSxekzmiIjIcFic3Bx48tgYuMxKRGRRZaVtqkMgi+PJY2NgMkdEZEGF25sxZVI5dhQ0qw6FLIwnj42ByRwRkcUkFNfjptxKSAnct7ASCcX1qkMii+LJY2PgT5uIyEJc5R6sX1WL5lbf7bITwIa8WrjKPWoDI0viyWNjYDJHRGQhM3NrsOQlwCt9t+ubgMUvAt5Pa9UGRpbkTnWidMxAtDhskABaHDaUjhnIww8RxtOsREQWUnECkN3GJIB1+RJXXa4iIrI6njxWjzNzREQWkv+wgNPedcxpB2ZPEWoCIiLdMZkjIrIQ2/gkLJ8D2Npzt0QHsGKub5yIrInJHBGRhbhTnZi1MAmjUn23hw0CZi5I4jIYkYUxmSMispiG9EQsXzkEQgArVg1BQ3qi6pCISEc8AEFEZEHZk+zI356KYWkxqkMhIp1xZo6IyKKYyBFFByZzRERERCbGZI6IiIjIxJjMEREREZkYkzkiIiIiE2MyR0RERGRiTOaIIqSstE11CEREZEFM5ogioHB7M6ZMKseOgmbVoRARkcUwmSPSWUJxPW7KrYSUwH0LK5FQXK86JCIishB2gCDSkavcg1dX1aK51Xe77ASwIa8Wc38hoqpX5q1FuX3en3BDQ6/3NbyU0Of3PpOxJqSYiIisQkgpVcegi8xz7HLD5qGqw6AoN39qCQr2Ad5OLzObAA4/J1B/eZq6wHSwvnbCya+3Th2pLI4L3j988utZSTuVxUFEFIyzRpTskFJmh/K9nJkj0lHFCaD7xyUJYF2+xFWXq4hIW4tyZqgOoYfOieRWnPq64aUEzuIRkSUxmSPSUf7DAmctlKhvOjXmtAOzpwiYcefcgnm3AQDse48qjiR4CTc0YBF8yWfzWacDAC5Z+S/O3hGR6TGZI9KRbXwSls+pwZKXfEutiQ5gxVzfuBn88MHFSNl84ORtO8yXxPnTkYxunTry5OxdxdVnAgBeXvaYsriIiELBPXNEOksorsd3r6nFwTJg9DDgH28moSE9UXVYfq2vnYDVr1+K0Xn7VYei3MEF30TTiGa8e8lTqkMhoigQzp45JnPkl6vcg5RDbsQ2edHqsKFilCuqTl9qrXB7M340pxIvrRuCc3PsqsPp4dai3D5PlEa75rNOR9u9lbgsbS+XZYn6UVbahmFpMarDMB0mc34wmQudq9yDtH01sHlPjXltQOmYgUzowmC0X3Draydg4xOXdFlGpcB8+cgI3Jz9ERM7om6M/sHVyJjM+cFkLnSjC8oQ1+TtMd7isOFgzjAFEZGW1tdOUFo6xIqeLNioOgQi5RKK6zH2wlo0thh/S4kRsTQJaSrWTyLX1ziZw7QPbse4pUdUh2FJi3JmnFyKZfkTikYskK4WkznqodVh8zsz1+pg9zcz6jiROg5M5PRk33sUuAFYhBmouPpMnoqlqDIzt6ZLgfT6JmDxi8Dsi2qBy5nM6Y3vztRDxSgXvN3+ZXhtvnEyj+kvLMGinBncE6dAyuYDWJQzA4tyZmD6C0tUh0Oku74KpJP+uGeO/OJpVvPicqpxffnICJY6IUtK/FtpjwLpiQ5g7yrrtS7UC/fMkebcqU4mbybTcbCBy6nGNW7pESyCb39d3uqnVYdDpBmzF0g3Oy6zElnAtA9u5wlVE7HvPXpyGZbICtypTsxamIRRqb7bwwYBMxckcVIgQjgzR2RiPNxgfh0J3cEF38Sm+Y8qjoYodA3piVi+Mg4/mlOJFauGoCGddeYihXvmiExqwbzbTNnwnvrGk7BkdkYrkG4W4eyZ4zIrkQktypnBRM6iOk7C8hQsmRUTucjjMiuRiXCPVfQYnbcfi/Jm8AQsEfWLyRyRCdxalIuEGxpUh0EKdJyA5Z46IuoNl1mJDI6JHAHtM3U5M7Bg3m2qQyEigzFEMieEeF4IUS6E2NPL/UII8XshxH4hxGdCiAmRjpFIhWkf3M5EjrroKGuip7LSNl2vT0TaMkQyB+AFAFf0cf+VAMa0/7kFwB8iEBORUotyZrCTA/Wqo07drUW5ml63cHszpkwqx46CZk2vS0T6MUQyJ6X8EEBVHw+5BsBq6bMNwCAhxGmRiY4o8njQgQKVcEMDfvjgYm2uVVyPm3IrISVw38JKJBTXa3JdItKXIZK5AAwH8HWn20fbx7oQQtwihCgUQhRWV3kjFhyRlpjIUbA6ypmEw1XuwfpVtWhu9d0uOwFsyKuFq9yjQYREpCezJHMBkVI+K6XMllJmD0621F+NogQTOQrHopwZIc/Szcw91VcTAOqbgMUvAt5PazWMkIj0YJaM5xiAMzrdPr19jMgymMiRFlI2Hwgpoas4AXTvByQBrMu3ZpcgIisxSzK3CcC89lOtkwHUSClLVAdFpBUmchSKxrY6v+OhJHT5Dws4u7XSdNqB2VNEqOERUYQYIpkTQrwC4N8AxgohjgohfiKE+KkQ4qftD3kbwEEA+wE8B2CBolCJNMdEjkJR1VyM/IrVqG72/7k22H10tvFJWD4HsLXnbokOYMVc37hZuco9GF1QhoyPSjC6oIz7/8iyhJTWnELPPMcuN2weqjoMoj4xkaNQHKvPwm73zwE0QWAUMl33YHjirl4f/2TBxoCum1Bcj+9eU4uDZcDoYcA/3kxCQ3qiRlFHlqvcg7R9NbB1OgvntQGlYwbCnepUFxhRL84aUbJDSpkdyvcaYmaOKBoxkaNQFHuysdtdDaAFACBRgd3uEyj29P4eEOi/tYb0RCxfOQRCACtWDTFtIgcAKYfcXRI5ALB5feNEVsNkjkgBJnIUqs9q8wAsBdCRqdQDuAtfuSf3+X2BFhjOnmRH/vZUnJtj7/exRhbb5L88VW/jRGbGZI4ogtbXTmAiR2Gqhr9zp01yS7/fmXBDQ0D//oalxYQWmoG0Ovy/vfU2TmRm/FdNFCHraydg69Rs5eGSAAAgAElEQVSRqsMgk3OItwB03/PlhEP01RGxq2j4QFExygVvt3c4r803TmQ1TOaIIoSJHGlhrGsbgGU49es7EcAD7eOBW5QzA9M+uF3j6IzDnepE6ZiBaHHYIAG0OGw8/ECWFas6AKJoEA0zIRQZ6c5CSJmFPe4RkDgEgRRkugYh3VkY9LXGLT2CRZgR8GlXs3GnOpm8UVTgzByRzpjIkdaGJ+7CxOTxAICc5Kw+y5IEYlHODCyYd5sWoRGRAkzmiHQUap9MspbeOjWEI9mejikp8zDYfpom17PvPWr5pVciq2IyR6ST9bUTkLL5gOowSLH+OjWEIz5mgObXHLf0SMBlTIjIGJjMEemEBx7oWH0WCqreAQAUVO3CsfosxREFLtAyJkSkHpM5Ih3wTZBC6dRgRItyZvDfM5HBMZkj0hjf+AgIvVODUfGQBJFxMZkj0tD62gmqQyDDCL1Tg1F1HJKY/sIS1aEQUSdM5og0cmtRLvfJ0UladGowqtF5+3nylchAmMwRaSThhgbVIehKj/IaelzTKLTq1GBkPPlKZAxM5og0YPV9cnqU19CzZIcRpDsLcbZrMARGAAAEUnB2iJ0ajC7hhgbWVCRSiMkcUZisvk9Oj/IaZi7ZEQytOzUYWcrmA5b/UENkVEzmiMJk5X1yepTXsErJjkBp3anB6FjKhCjymMwRhcHqb1p6lNewWsmOQOjRqcHoFuXMsPysNZFRMJkjwygrbVMdQlCi441Kj/Ia1ivZQf5tnTqShyOIIoDJHBlC4fZmTJlUjh0FzapDCZiVl1c76FFew8olO6gnK7UFM9sHTooeTOZIuYTietyUWwkpgfsWViKhuF51SP2KlpN7epTXiIaSHdST2RM6M37gpOjBZI6UcpV7sH5VLZpbfbfLTgAb8mrhKveoDawfKZsPqA4hIvQorxFNJTuoK7MmdGb8wEnRhckcKTUztwZLXgK87Vuo6puAxS8C3k9r1QbWB7O+IYVKj/IaZinZYeWixqqY7fVj1g+cFF2YzJFSFSf8bYUH1uV3HzUGs70RaUWP8hpGL9lh9aLGKpnpdWTGD5wUfZjMkVL5Dws47V3HnHZg9hShJiDqlR7lNYxasiNaihqrZJaEzmwfOCk6MZkjpWzjk7B8DmBrz90SHcCKub5xo1kw7zbVIVAERFtRY5XMkNDxAyeZAZM5Usqd6sSshUkYleq7PWwQMHNBEtyp3UtXqDX9hSWw7z2qOgyKgGgsaqyS0RM6M33gpOjFZI6Ua0hPxPKVQyAEsGLVEDSkJ6oOqYfReftVh0ARw6LGkWbkhM4sHzgpujGZI0PInmRH/vZUnJtj7//BEcbl1ejCosZ90+uEr5FfZ2b4wEnRjckcGcawtBjVIfjF5dXowqLGvdPzhK9979GAEzoVnRiM/IGTiMkcUR+MvPxD+mBRY/8iccI3kIROZScGo37gJGIyR9SL9bUTVIdAipilqHGkRPKEb18z4W+sn44bZtdBSmDe3AF4Y/10zZ+fyIyYzBH1YuvUkapDIIWMXtQ4kiJ9wtffjPhbG6/FPb8ajY6Esq3tOO791Zl4a+O1usRAZCZM5oj8mP7CEtUhkAEYtahx5FXhVCLXQd8Tvt2XW3+9eDvaWu9G54SytXUpHvufm3SLgbTjKvdgdEEZMj4qweiCMrZD0xiTOSI/WIqEyMe3lHqjn3v0PeHbff9cS0sN/JWMKSv9p24xkDZc5R6k7atBXJMXAkBckxdp+2qY0GmIyRxRNz98cLHqEIgMw7fE+qCfe+7S/YRv5/1zw9Jeg7+SMcPSLtY1BgpfyiE3bN0mdm1e3zhpg8kcUSfTX1iClM0HVIdBZCD+iigDQEJETvh2fLhafPefEBN7PzqXjImNXYbFd/9J9xgoPLFN3Zfo+x6n4DGZI+qEy6tEXfkvohwPh7g6Is/f8eHq+zPewG/+9yBiYs4AAMTEDMVD/3sA35/xRkTioNC1OvynGr2NU/D4kyRqN+2D21WHQGQ4PYsoJwBYEdEiyh1lgq6dtQl/fbUOQgCr19bh2lmbIhYDha5ilAvebtmG1+YbJ20wmSNqN27pEdUhEBlOzyLKwyJeRPm5wgtPfs1ODObjTnWidMxAtDhskABaHDaUjhnI/rYailUdAJERsNMDUe+GJ+5CQtx4FFQdQk5yFgbbI1tEedzSI0DBqdvsxGA+7lQnkzcdcWaOot6tRbmqQyAylMa2uh5jqoso83VK1DsmcxT1Em5oUB0CkWFUNRcjv2I1qptLetynsojyoaMpyp6byOiYzFFUY/9VolOO1WehoOodAEBB1S4cq89SHNEp3NNK1Dsmc2QKZaVtulyX/VeJfIo92djtrkZH71OJCux2n2jvAEFERsZkjgyvcHszpkwqx46CZk2v2733I1E083V6WIrOvU+Bu/CVe7K6oIgoIEzmyNASiutxU24lpATuW1iJhOJ6Ta67vnZCl1ZBROSv04NEk9yiIhi/2GqPyD8mc2RYrnIP1q+qRXOr73bZCWBDXq0mzZm5vErUlf9OD044xBUqwiGiIDCZI8OamVuDJS8B3vbJgvomYPGLgPfT2rCuyxIHRD317PSQCOCBiHZ66A/7JhP5x2SODKvihL9FH2Bdvr+m34FjKRKinnp2ekiJeKcHIgoNkzkyrPyHBZzdOvY47cDsKSLka5qt00OxJxv55cuxpXQl8suX82Qh6Wp44i5MTB4PAMhJzsLwxMh2eggEDy4R9cRkjgzLNj4Jy+cAtvbcLdEBrJjrG48GxZ5s7KnNRaN3CACBRu8Q7KnNZUJHulLd6YGIgsdkjgzLnerErIVJGJXquz1sEDBzQVLI/f3MNitXVDcdXji6jHnhQFHddEURkRX5a92lstNDf3gKnagnJnNkaA3piVi+cgiEAFasGoKG9MSQrmO2RA4AGr3JQY0TBauv1l1EZB5M5sjwsifZkb89Fefm2Pt/sB9mbdkVb6sKapwoGEZu3dUfM344I9JTrOoAiAIxLC0m5O81a025jAGbsKc2t8tSqw1NyBiwSWFU0a3Yk42iuulo9CYj3laFjAGbTHna09e66zi6t+4SItuUfx+9lJW2hfW7hyhSODNHlmbmk2/pzkJkJq1BvK0SgES8rRKZSWv4ZquIlQ6kWKF1l971IvVqI0ikB87MkWVNf2EJRu/drzqMsKQ7C5m8GURfB1LM9//I+K27+lPy8XAgQ59r+9oI1p5sI/iPN5NC3q9LFAmGmJkTQlwhhPhKCLFfCLHUz/3zhRAVQohP2//cpCJOMpfReeZO5MhYrHQgxQqtu/R6fevZRpBIL8qTOSFEDIBVAK4E8C0A1wshvuXnoWullOPb//wpokGS6XCDNGnNSgdSzNC6SxW92ggS6Ul5MgcgB8B+KeVBKWUzgFcBXKM4JjIxM++TI+PKGLAJNjR1GTPrgRSrtO6a9sHtml9TrzaCRHoyQjI3HMDXnW4fbR/rbqYQ4jMhxHohxBn+LiSEuEUIUSiEKKyu8vp7CFncgnm3sago6cJqB1LM0LqrP+OWHtH8mnq0ESTSm1kOQLwF4BUpZZMQ4lYAfwVwSfcHSSmfBfAsAGSeY+fHqChza1EuEpjIkY6sdiClo3WXkTs+RJqvjeCppdZoayNI5mSEmbljADrPtJ3ePnaSlLJSStmxvvEnAOdGKDYykYQbGlSHQGQ6Zk/kfvjgYk2vp3UbQaJIMEIy9wmAMUKIbwgh7ACuA9BlE4oQonPH5+kAvoxgfGQCPPBAFJ1SNh/Q/JpatREkihTly6xSylYhxM8BvAsgBsDzUsrPhRDLARRKKTcB+IUQYjqAVgBVAOYrC5gMZ8G822AHl1eJSDsdbQTZAYLMQEhpza1lmefY5YbNQ1WHQTrjgQciAoAnCzaqDoEoLGeNKNkhpQyppYzymTmiUC3KmcEZOSIiinpG2DNHFDTukSMiIvLhzBwRkR/FnmwU1U1HozcZ8bYqZAzYZKmyJFazKGeG8qXWstI27rEjJTgzF4Ky0jbVIUQ1zsqR3oo92dhTm4tG7xAAAo3eIdhTm4tiT0jbWShCbi3KVfbchdubMWVSOXYUNCuLgaIXk7kg8QWrFhM5ioSiuunwwtFlzAsHiuqmK4qIAqGq1mRCcT1uyq2ElMB9CyuRUFyvJA6KXkzmgsAXrFpM5ChSGr3JQY1T9HKVe7B+VS2aW323y04AG/Jq4Sr3qA2MogqTuQDxBasWEzmKpHhbVVDjFL7GtjpNrjP9hSWaXCdQM3NPtf4CgPomYPGLgPfT2ojGQdGNyVyA+IJVh4kcRVrGgE2woanLmA1NyBiwqZfvoHBUNRcjv2I1qptLwr7W6Lz9GkQUuIoTQPdqrRLAunxr1nAlY2IyFyC+YNXQuu8iUSDSnYXITFqDeFslAIl4WyUyk9bwNKsOjtVnoaDqHQBAQdUuHKvPCvuakfy9kf+wgNPedcxpB2ZPERGLgYilSQKU/7DAWQsl6jt9WO94wXLnnD7W107Qpe8iUSDSnYVM3nRW7MnGbvdxAC0AAIkK7HafgBDZYf3sUzYfAJZpFGQ/bOOTsHzOqZWbRAewYq5vnChSODMXIN8LFrC1f9jiC1Zf62snYOvUkarDICIdfVabB2ApAG/7SD2Au/CVe7K6oILkTnVi1sIkjEr13R42CJi5IAnuVKfawCiqMJkLEF+wkcVEjigaVMPfBpYmuSXsK0dyr21DeiKWrxwCIYAVq4agIT0xYs9NBHCZNSi+F2wcfjSnsv0Fa+//myhoPPBgLUbvpGD0+KzMId5Ck5wIdNms4oRDXAFgZdjXX187AbOSdoZ9nUBkT7Ijf3sqO0CQEpyZC1LHC/bcHCZyemAiZy1G76Rg9PisbqxrG3yb2zreihIBPNA+Hr5Iz/AzkSNVmMyFgC9YfayvnaA6BNKY0TspGD0+q0t3FuJs12AIjAAACKTgbNcgTWdGVbb4IooUJnNkCDzwYE1G76Rg9PiiwfDEXZiYPB4AkJOcheGJuzS9vqoWX0SRxGSODIGJnDUZvZOC0eOLFsn2dExJmYfB9tN0uT7rVZLVMZkj5ay4T66jNZFWLYrMyuidFIweXzSJjxmg27VZr5KsjskcKWXFfXIdrYkO1+/WrEWRWRm9k4LR4yPtLJh3m+oQiHQjpLRmO6rMc+xyw+ahqsOgflhtVu5YfRZ2u38OoAmAACAhMAqZrns03wtERMGpuPpMvLzsMdVhEPl11oiSHVLKkI7Sc2aOlLFaIudrTVSNjtZEHcVQO1oUsdwFkVpcbiWrYjJHpJGerYk6mK9FEZFVWe1DJBHAZI4UseYvVH+tiTpo06KIiMI3/YUlqkMg0hSTOYo4ayZyvtZEQG+9ejtaFBFpI9pPSodjdN5+1SEQaYrJHEWUFU+vdujZmqiDti2KiDpOTEfzSelwWfVDJUUnJnMUUVYuDty9NREQC0CfFkUUvY7VZ6Gg6h0AQEHVLhyrz1IckXmxXAlZBZM5ipho+CTcuTXRONd5APRpUUTRqfuJaZ6UDo9971Hun4tirnIPRheUIeOjEowuKIOr3KM6pJAxmSPSWEdropGJZ+vaooiiT88T0zwpHa7Refstvf2D/HOVe5C2rwZxTV4IAHFNXqTtqzFtQherOgCKDgvm3QY7jqoOI2I6WhMF26Ko2JONorrpaPQmI95WhYwBm7g8S534OzHNk9Lh2jp1JGYV7FQdBkVQyiE3bN2qSNm8vnF3am8H2YyLM3MUEfa90ZPIharYk409tblo9A4BINDoHYI9tblcQqOT/J+Y5klpLUTDNhA6Jbapez3QvseNjskc6Y6bjANTVDcdXji6jHnhQFHddEURkdH0PDHNk9JaYkIXPVod/tOf3saNzpxRk2n88MHFnJULUKM3Oahxij7dT0zzpLT2+OEzOlSMcsHbLQPy2nzjZsRkjnTFXoiBi7dVBTVO0anziWmelNaefe9R/PDBxRF7vrLStog9F53iTnWidMxAtDhskABaHDaUjhloyv1yAJM50hGP/AcnY8Am2NDUZcyGJmQM2KQoIjKqjhPTPCmtj5TNBwJK6MJNxAq3N2PKpHLsKGgO6zoUGneqEwdzhqHowtNwMGeYaRM5gMkc6Ygtc4KT7ixEZtIaxNsqAUjE2yqRmbSGS2jkV7AnpSk4/SV04SZiCcX1uCm3ElIC9y2sREJxfaihEjGZI31M++B21SGYUrqzEFNS78cVaT/HlNT7mcgRKZSy+YDfPXRvrJ+OG2bXQUpg3twBeGN9cIeUXOUerF9Vi+ZW3+2yE8CGvFrT1jgj9ZjMkS7GLT2iOgQiorDZ9x7tktC9tfFa3POr0ejowtHWdhz3/upMvLXx2oCvOTO3BkteArztJQPrm4DFLwLeT2u1DJ2iCJM50hxn5YjISux7j54sW/LrxdvR1no3OnfhaG1disf+56aAr1dxwl/pZ2BdfvdRosAwmSPNcVaOiKxoUc4MtLTUwF8qVlb6z4Cvk/+wgNPedcxpB2ZPEWHHSNGJyRxp6taiXNUhEBHpprcuHMPSLg74GrbxSVg+B7C1526JDmDFXN84USiYzJGmYh4aojoEIiLdjHVtQ0zs/ejchSM2dhkW3/2ngK/hTnVi1sIkjEr13R42CJi5IMnUpTFILSZzpCl2eyAiK0t3FiLjm99ETMwZAICYmKF46H8P4Psz3gjqOg3piVi+cgiEAFasGoKG9EQ9wqUoEas6ALIO9jUkomgw8sTf4RqYhU+qD2P12jqcmxNaYe/sSXbkb0/FsLQYjSOkaMNkjoiIKEjJ9nRNEjEmcqQFJnOkifW1E1SHQBoo9mSjqG46Gr3JiLdVIWPAJhYuJurFR86JmIWdqsMg4p450sbGJy5RHQKFqdiTjT21uWj0DgEg0Ogdgj21uSj2ZKsOjciQtk4dqToEIgBM5kgjKZsPqA6BwlRUNx1eOLqMeeFAUV1wrYqIognLMZERMJmjsLHjgzU0epODGiciIOGGBtUhEDGZIyKfeFtVUONE5DP9hSWqQ6Aox2SOwsb2XdaQMWATbGjqMmZDEzIGhFZ2gShajM7brzoEinJM5igs3C9iHenOQmQmrUG8rRKARLytEplJa3ialSgA3G5CKrE0CYWl7pV0JICHH6wi3VnI5I0oBOOWHgEKVEdB0YozcxQWnmIlIiJSizNzRBphwV2i6LYoZwaeLNioOgyKQpyZo5AtmHeb6hAMgwV3iQhgNxxSg8kckQZYcJeIAHaFIDWYzFHI7HuPqg7BMFhwl4iIVOGeOSINxNuq2pdYe44TBYv7L81t2ge3491LnlIdBkURzswRaYAFd0kr3H9pfiykTpEWcDInhLhMCPGcEGJ8++1btApCCHGFEOIrIcR+IcRSP/c7hBBr2+/fLoQYpdVzU2gW5cxQHYKhsOAuaYX7L62BLb4okoJZZv0xgJ8BuFcIkQxgvBYBCCFiAKwCcBmAowA+EUJsklJ+0elhPwFQLaX8phDiOgC/BTBXi+cn0goL7pIWuP/SGlyHpeoQKIoEs8zqllKekFIuBnA5gIkaxZADYL+U8qCUshnAqwCu6faYawD8tf3r9QAuFUIIjZ6fiMgwettnyf2X5sKC6hRJwSRzmzu+kFIuBbBaoxiGA/i60+2j7WN+HyOlbAVQA6DHbnMhxC1CiEIhRGF1lVej8IiIIof7L62DS60UKf0mc0KIp4QQQkr5ZudxKeXT+oUVGinls1LKbCll9uBknu3QC4tiEumH+y+t4/QPGlWHQFEikD1zbgCbhBBzpZQeIcQ0APdLKb+jUQzHAJzR6fbp7WP+HnNUCBELYCCASo2en4L0XulZSECD6jCILIv7L62BtTgpUvqdvpJS3gvgFQD/FEL8C8CdAHqcOA3DJwDGCCG+IYSwA7gOQPf1hE0Abmz/ehaAD6SU3F2qSMnH3VfBiYjIn1uLclWHEFVc5R6MLihDxkclGF1QBle5R3VIEdHvzJwQ4lIANwOoB3AagB9LKb/SKgApZasQ4ucA3gUQA+B5KeXnQojlAAqllJsA/BnAi0KI/QCq4Ev4SJHReftVh0BEZAoJNzQABaqjiA6ucg/S9tXA1r5lPq7Ji7R9NQAAd6pTYWT6C2SZ9R4A90kptwohzgawVghxp5TyA62CkFK+DeDtbmP3d/q6EcBsrZ6PiIgoUtbXTsCspJ2qw7C8lEPuk4lcB5vXNx71yZyU8pJOX+8WQlwJYAOA8/UMjIiIiChQsU3+q1j0Nm4lQR/5lFKWALhUh1iIiIiUamyr0/yaH/xcq/OC1JdWh/+UprdxKwnpbyil5FFGIiKylKrmYuRXrEZ1c4mm1+Wp1sioGOWCt1tW47X5xq3O+ukqERFRP47VZ6Gg6h0AQEHVLhyrz1IcEQXLnepE6ZiBaHHYIAG0OGwoHTPQ8vvlACZzFKRpH9yuOgQiIk0Ve7Kx210NoAUAIFGB3e4TKPZka/Yc/N0ZGe5UJw7mDEPRhafhYM6wqEjkACZzREQU5T6rzYOvfGrHRvl6AHfhK/dkdUERBYHJHBERRblqAN3r0Es0yS0qgiEKWiB15oiIyKSKPdkoqpuORm8y4m1VyBiwia3CunGIt9AkJ8I3I9fBCYe4AsBKTZ5j3NIjLB5MuuHMHBGRRRV7srGnNheN3iEABBq9Q7CnNlfTvWBWMNa1DcAynHpLTATwQPs4kfExmSMisqiiuunwwtFlzAsHiuqmK4rImNKdhTjbNRgCIwAAAik42zWIM5hkGkzmiIgsqtGbHNR4NBueuAsTk8cDAHKSszA8cZfiiIgCx2SOiMii4m1VQY1Hu2R7OqakzMNg+2m6XH/6C0t0uS4RkzkiIovKGLAJNjR1GbOhCRkDNimKyPjiYwaoDoEoaDzNSkRkUR17vnialcjamMxRUN695CkswgzVYRBRgNKdhUzeiCyOy6xEREREJsZkjoiIiMjEmMwRERERmRiTOSIi0l1jW53qEIgsi8kcERHpqqq5GPkVq1HdXKI6FCJL4mlWClrDSwlIuKFBdRhEbCJvAsfqs7Db/WcAQEHVLmS6rmJ3BSKNcWaOgnZZ2l7VIRgSl5Eii03kja/Yk43d7moALQAAiQrsdp/g/yMijTGZI9IAl5Eij03kje+z2jwASwF420fqAdyFr9yT1QWl0Kb5j6oOgSyKyRwFbVbSTtUhGMqx+iwUVL0DwLeMdKw+S3FE0YFN5M2gGoDsNibRJLeoCIbIsrhnjigMvmWk4+i+jCRENvdu6SzeVtW+xNpz3OrMslfQId5Ck5wI34xcBycc4goAKxVFRWQ9nJmjkFRcfabqEAyBy0jqRGsTeSPsFSz2ZCO/fDm2lK5EfvnyXp97rGsbgGU49VaTCOCB9nEi0gqTOQrJy8seUx2CQXAZSZV0ZyEyk9Yg3lYJQCLeVonMpDWGnKHSkuq9gsEkk+nOQpztGgyBEQAAgRSc7Rpk+f9HRJHGZVaiMHAZSS2VTeRVLXWq3ivYVzLp7+8/PHEXEuLGo6DqEHKSszDYHp1lSb58ZITqEMjCmMwRhWGsaxs+q12GU0utXEaKBh2zUx1JTcfsFADdEzrVewVDSSaT7emYkjIP8TED+r2+WfYDdtbYVhfQ341IL1xmpZA1n3W66hCU4zJSdFK51Kl6r2BvSWN/yWSgiZzq/YDBYlkiMgImcxSyvNVPqw7BEIYn7sLE5PEAgJzkLFa3jwIqlzpV7xXUM5lUvR8wWMGUJXr3kqciFRZFIS6zEmkgmGUkMj/VS51a7BUMdTmz4zF6LIWq3g8YDJYlIiNhMkdhqbj6TKRsPqA6DENgIhc9MgZs6rJnDjBXWZRw9/zpdfBEdZIcDF9Zop3oWZZoD5M5ijgus1JY3COF6hCIIk71Ume4jLqcqXo/YHACL0t0wfuHIxIRRS/OzFFYNs1/FIvyZqgOgyjiVJZFCZdRlzP1XMLVGssSkZEwmaOwRetSK8sRkFkZeTnTLElyMGWJ2M+a9MZlVgrb8QtbVIcQcSxHQGZmruVMY2JZIjISJnMUtmg7ch9MOQIiIzL7nj+jCKQs0ZMFGyMdFkUhLrOSJi54/zC2Th2pOgzdsRwBWYVZljONjmWJyAg4M0eaiJY9Ib5yBB17ZIBT5QgmqwuKiJTqLZFjlxyKFCZzREEJvBwBEUU3dsmhSGEyR5qJhr0hDvEWAGe30Y5yBNSbYk828suXY0vpSuSXLzd0r00iIrNhMkcUBF/ZgWU49dLpvRwB+ZixeTpRuA4u+KbqECiKMJkjTTW8lKA6BF2xHEHwjNptgEhPm+Y/qjoEiiI8zUqaeiZjDRbB2h0hhifuQkLceBRUHUJOchYG23uWI6BTjNptgEJT7Mk2RYcGomjCmTnS3JePjFAdgu46yhEMtp+mOhTD662rgBG6DVBwuGQemGj4HUjGwmSONBctRYRZVyow7DZgHVwyD8yo0ytUh0BRhsuspIsvHxmBcUuPqA6DDMBMzdPNLBLLn1wyD8wzGWtUh0BRhskc6eLdS57C9AVLMDpvv+pQyADYbUBfHcufHbNmHcufADT9ucfbqtqXWHuOk88F7x9WHQJFIS6zkm54mosoMiK1/Mkl8/5FSzccMhYmc6SriqvPVB0CkeVFavkz3VmIzKQ1iLdVApCIt1UiM2mNklnXxra6iD8nkVFxmZV09fKyx7DgwG2w7z2qOhQiy4rk8qcRlsyrmotRUPUGJiXPMNSJ8mjogkPGxJk50h37ExLpK5qWP4/VZ6Gg6h0AQEHVLhyrz1IckU/zWadH5HnKStsi8jxW4yr3YHRBGTI+KsHogjK4yj2qQ9IUkzmKCC63EunHSMufeir2ZGO3uxpACwBAogK73ScMUeeu5kxH/w8KU+H2ZkyZVI4dBc26P5eVuMo9SNtXg7gmLwSAuCYv0vbVWCqhE1JK1THoIvMcu9yweajqMKiTRTnW7gxBRPraUloAYCcAb6dRGxxiDwZT8q0AACAASURBVL47bKWiqHz0XmJNKK7H2Atr0dgCjB4G/OPNJDSkJ+r6nFYxuqAMcU3eHuMtDhsO5gxTEJF/Z40o2SGlDOmTCWfmKGK4n4SIwlMNoPsEhEST3KIimJMOLvimrtd3lXuwflUtmlt9t8tOABvyai01s6SnWD+JXF/jZsRkjiKKNZiIKFQO8RYAZ7dRJxziChXhnKR3GaaZuTVY8hLgbc9j65uAxS8C3k9rdX1eq2h1+E91ehs3I+v8TcgUZiXt5P45IgrJWNc2AMtw6q0rEcAD7ePWVXHC33wksC7fmtuktFYxygVvt2zHa/ONWwWTOYq4l5c9FrGTX0RkHenOQpztGgwBXyN7gRSc7Rqk9KBHw0sJuj9H/sMCTnvXMacdmD1F6P7cVuBOdaJ0zEC0OGyQ8O2VKx0zEO7U7rO85qW0zpwQIhnAWgCjABwCMEdKWe3ncW0AdrffPCKlZFdnk8tb/TQPRCgQif6dRsefQeAa2+oQHzNAdRhdDE/chYS48SioOoSc5CwMtu9SGk8k+rDaxidh+ZxTS62JDmDFXN84Bcad6rRU8tad6pm5pQD+LqUcA+Dv7bf9aZBSjm//w0TOInggIrI6+nf6isuKk/07jVDWIVL4MwhcVXMx8itWo7q5RHUoPSTb0zElZZ7ygsGR2gPsTnVi1sIkjEr13R42CJi5IMnSyQkFR3Uydw2Av7Z//VcA1yqMhRTg/rnIiVT/TiPjzyAwRi3M25kRZgwj2Ye1IT0Ry1cOgRDAilVDWJaEulCdzA2TUnZ87CsF0FvBl3ghRKEQYpsQoteETwhxS/vjCqurtD9ybPUK0iq8vOwxJnQREqn+nUbGn0H/jFyY10i+fGRExJ8ze5Id+dtTcW6Ovf8HU1TRPZkTQrwvhNjj5881nR8nfdWLezuaM7K9kF4ugCeFEH7f/aWUz0ops6WU2YOTtf2rRUMFaVWY0EVGb3069ejfaVT8GfTvs9o8+Ha8dHwgrgdwF75yT1YXVB8a2+qUPO+7lzyl5HmHpcUoeV4yNt2TOSnlVCllpp8/bwIoE0KcBgDt/y3v5RrH2v97EEA+gIjP+acccsPWbbLP5vWNU/heXvaY7oU3o1009e/sDX8GgTBmYV5/VO3r4+8qMhrVy6ybANzY/vWNAN7s/gAhxGAhhKP966EAvgPgi4hF2C4aKkirtmn+o/wlqaNo6d/ZF/4M+mfUwrzdqdzXp3eRYKJgKS1NAuARAK8JIX4C4DCAOQAghMgG8FMp5U0AxgF4RgjhhS/5fERKGfFkrtVh89vbzUoVpI1g0/xHsSiPJUv0ku4sjPrEhT+Dvo11bcNntctwaqnVeIV5ffv6jqP7vj4hsnX/f6tirxxRf5RmIlLKSinlpVLKMe3LsVXt44XtiRyklB9LKc+WUn67/b9/VhFrNFSQNgqWLCFSx4iFebtTua9P1V45or5wWilA0VBB2kiY0BGpMzxxFyYmjwcA5CRnYXii2sK8PanZ1xeJbg9EoWAyFwR3qhMHc4ah6MLTcDBnGBM5nT1ZsJF76IgUMUphXn9U7esLpNtDWWmbrjEQ+cNkjgxt0/xH+WmYSBEjFOb1x7d/bxlOvYUZY19f4fZmTJlUjh0FzUrjoOjDZI4M75mMNUzoiOgkFfv6+tv6kVBcj5tyKyElcN/CSiQU1+sWC1F3TObIFJ7JWBOxPohERlXsyUZ++XJsKV2J/PLlUd2VwUj7+lzlHqxfVYvmVt/tshPAhrxaFpWniGEyR6YxK2knEzqKWsWebOypzUWjdwgAgUbvEOypzY3qhC5S+/r6m5WbmVuDJS8B3vYzGfVNwOIXAe+ntbrGRdSByRyZyqyknTzpSlGpqG46vHB0GfPCgaK66YoiMgYj7OurOOHvbC2wLr+3DpVE2mIyR6b0ZMFGNJ91uuowiCKm0Zsc1DhpI5D9uvkPCzjtXcecdmD2FKFTVERdMZkj08pb/TQqrj5TdRhEERFvqwpqnLQRSDkS2/gkLJ8D2Npzt0QHsGKub5woEpjMkam9vOwxLrtSVMgYsAk2NHUZs6EJGQM2KYrI+gJt3eVOdWLWwiSMSvXdHjYImLkgibVIKWKYzJElsMAwWV26sxCZSWsQb6sEIBFvq0Rm0hpDtdmymmBadzWkJ2L5yiEQAlixagga0hN1jIyoq1jVARBpZdP8RzFtxO0Yt/SI6lCIdJHuLGTyFiGh1LbMnmRH/vZUDEuL0SEiot5xZo4s5d1LnuKyKxGFLZC9cv4wkSMVmMyRJXHZlYhCxQ+EZDZM5siyNs1/lL+UiSgoPCFPZsRkjiyPNemIKFAvL3tMdQhEQWMyR1Ehb/XTnKUjoj7xdwSZFZM5iircS0dE/gRaU47IiJjMUdThXjoi6qzi6jODqilHZDRM5ihqPVmwERe8f1h1GESk0MEF3+Q+OTI9JnMU1WYl7eQsHVEU2zT/UdUhEIWNyRwRfLN0PPVKFF34QY6sgskcUSd5q59mnSmiKMBEjqyEyRxRNy8ve4y/6IksjK9vshomc0S9eLJgY0jNtonImBpeSmAiR5bEZI6oD89krMGTBRtZg4rI5BpeSsAzGWtUh0GkCyZzRAF495KneECCyKSYyJHVxaoOgMhM8lY/DQBYMO822PceVRwNEfWl4uozWUOOogKTOaIQ5K1+GtNfWPL/27v/4KjrO4/jr3eApEm6UUECRqWU+oN62FOPQtuzN9haa+mNngW1pa1lWsd2wLt25vTqjeNxxau1p3NDT2GqtZ2rgm1PLJWetv5o5dr+IWlEFCwqyuBVAwmCkJjEBNjP/bEb3CSbX7v7/X6+n93nYybD7jdfdt98suy+8vl+fmjWmpd9lwIgD8bGoZIQ5oACbVx6m7RU+upLS1T7hR7f5QAQIQ6ViTFzQJHuOuN+tgUDPDv/iVcJcqhY9MwBJbC4YYsWN2+RJH1j3mWeqwEqx/lPvKrFDVt8lwF4RZgDSmxV8wbG0wERYmIDMBBhDohA/3g6Qh1QOjtunaFHP/Y932UAiUOYAyLUH+pYygQoTN/sU44tCQQgP8IcEIM1996h9R3n6Q8Xvsd3KYn09tG39K4J7/ZdBhJi17LTMr8IARgTwhwQk/5JEoS6gQ70tar5wC80f/JlOqH6JN/lwJP+GeFMZgDGjzAHxKw/1H3+W9dp6sOv+C5nTKLqOXu961xt6/yhJKn5wDOak1qok+ufKfnzIHl23DpDM0/ZxzZbQAkQ5gBP1q24XVqR/EkSUfWctXbP1bbONyQdliQ57dO2zoMym6umupaSPQ+SY9ey03TVZ35D7xtQYuac811DJOZ8oNo9+PCJvssAxiyJ69Nles6uldQr00zNSd1Ysp6zX+9tlrRFUjrnaJVqbLsumHZnSZ4D/rGMCDA2s2fsedo5N7eQv0vPHJAQq5o3JGo8XfQ9Z29KGvzLpFOv+3UJHhs+MQMViBdhDkiQJO0k8VzHGg3sOeuS9E292Lm9JGGuxn6pXvfB7OP2q1ONXSyJnrkQsZ0W4Ad7swIJtap5g+c9X6PtOTsz9ZSkFXrnbahe0r9mj6MQbx99y8vzsi8q4BdhDkiwxQ1btKp5g3rW1sb+3DX2S0l1g47295wVr6muRWenTpBphiTJNFVnp45n8kOBDvS1atO+e/Vm357YnrNnba1WNW9gQgPgGZdZgQDcdcb9UnPmdlyXX89MPaXnOlZIukGZS62l7zk7uf4Z1U46R80Hdmve5HN1QjXLkhQi7iVe2FYLSBbCHBCY/stZUa9T11TXIufO1fbOGXLaLdNUzYmg52xydZMWTL2KHSAKFOcSL0xsAJKJpUmAwEW97ys7NCRbXEu8MCYOiBZLkwAVrL+nJKrLr/ScJV30S7wQ5IBkYwIEUCZWNW+IbAYsQS65opyosuPWGQQ5IACEOaDM9M+AXdW8QTtuneG7HEQsqiVeetbWMskBCASXWYEy9ujHvic1K1E7S6C0opioUoreuLa9RzVt+oSiHwfA6OiZAypAbm/drmWnad+n3+e7JJTQyfXP6IOTz5EkzZt8bsHLkuxadlpJglzL5j4tmN+up5v7in4sAKNjNitQ4T7/ret03Cu9kc6Ixfi8ffStgsYpFvr3pNJNcqht7dKZH+3Q24elWdOkJx9qUE9TfUkeGyhnzGYFULB1K24fcP+rLy1R7Rd6PFWDYpaC8R3kUu3d+unqDvUdydxvOyg9uKZDV/6DqbNx8CQNAKVCzxyAMYlr54lKltnJ4VpJvTLN1JzUjZHu5CCVdtmRpRfuUfNOKZ3zsVJl0qs/MHVdNL1kzwOUI3rmAERu8If++o7zjt0up8kVxVyqLEacOzlI0r5Pv29Ir2zRj3kw34p30gObnBZeVNKnApCDMAegILmbqy9ufuf2J3/79WO333/D/8VaU7F87nbxXMcaDdzJoUvSN/Vi5/aSh7ldy07TxqW3Hbtfqpmnm24xzV7u1NX7zrG6aunyBaauoh8dwHAIcwgWSx8k04C1yZozf1zyX9dLkmatedlDRWMT92b1Q0W/k0O/3CDXsrlPX7xiv9Y+MEV/Na+6qMetOqdBK684pOvXZi611tdIN1+ZOQ4gOixNgiAVuvRB296jEVWEkWxceps2Lr3t2A4VSVsaJXOJ800NvsTZ2l3Q8JWCRLmTQ67cy+W1rV26esl+OSfdtHy/aluL6z/rbKzT4uUNmtmYuT/teGnRsgYmPwAR8xrmzOxyM3vezNJmNuy7ppldbGYvmtnLZnZDnDUieQr9AGLtq2RY3LBF61bcfmzduyTIXOK8QUMvcX4othqi2skhV257p9q7tT7PzNNUe3dRz9HTVK+Vd06RmXTz6iksSxKQVHu3ZjW36Yzf79Gs5raiXwuIj++eue2SPiPpd8OdYGYTJK2W9ClJZ0n6nJmdFU95SJpCP4BK3QOB0olyT9mxi+8S53Ca6lp0duoEmTJbsJmm6uwid3LINXhrt0VL3rkcKkldvdJ190nprR1FP9fc+dXatLmx6Mu2iE+qvVvTdx7SpN60TNKk3rSm7zxEoAuE1zDnnNvhnHtxlNPmSXrZObfLOdcn6aeSLo2+OiRRIR9AUfVAoLT6d6nwEeriusQ5mlLt5DDYrmWnDdlndaSZp6XAeNawTN3dqar0wGNV6cxxJJ/vnrmxOFnSn3Puv5Y9NoSZXWNmLWbW8uaBdL5TELhCPoCi7IFA6fWHup61tbE9ZxyXOMdqcnWTFky9qqSzaXMnPPTbdIupblDHWf/MU1Seib35PzOHO45kiTzMmdkTZrY9z1fJe9ecc3c75+Y65+aeMDmEnBq+uMdYFPIBFHUPBKJx1xn3H9tLNmpRX+Icr1KuczfcuMTMzNPMor4SM08r3ZGa/J+Zwx1HskT+U3LOXeicm5Pn66ExPsTrkk7NuX9K9hg88zHGopAPIHogwtY/CzbqGbBRXeL0aaQJJsw8Ra59M1NKD0oE6arMcSRfCJH7j5JON7P3mlm1pM9K2ui5JsjPGItCPoDogSgP61bcHvl4uigucfoylh5NZp6iX2djnfaefpwO11TJSTpcU6W9px9HuA+E171ZzewySXdImirpoKStzrlPmlmTpHuccwuz5y2UtErSBEk/cs59e7THZm/W6J3x+z3K17flJL300Wg/DMe70Glta5cuuLRDu9qkWdOkJx9q4IMrcOwVO7zBOzyMhgW4Af+K2ZvVa5iLEmEuerOa2zQpz+DYwzVV2jVvWuTPP94PoFKudI9k+Py3rtPUh1/xXUai7Lh1xpCZqwCSjzCXB2Euev1j5nIvtaarlOiueXog4hVXe9NLl0GQA8JVTJgLYcwcEirEMRYEufjEueNG3EuZJBFBDqhc9MwBKLna1i6d+dEOvX04/jGKlXjptWdtre46437fZQAoAj1zABLD944b/fu+9s0+JZbn840gh3LC/rCFoWcOQEktvXCPmne+s+OGlFkW5tUfmLoumh57PeU8no4gh3IS4jjsUqJnDsFp23vUdwmISNJ23PC132vUVjVvIMihrLA/bOEIc4hdnAPjEb8k7rjhY7/XqKxq3jDizg5AqNgftnCEOcSqtrVLVy/ZL+ekm5bvV21rl++SUGJJ3nGjf7/XEMfU7bh1BiEOZY39YQtHCyE2vgfGIx6h7Pm55t47tKp5w5i2vfJp17LTtKp5A8uOoOyxP2zhmACB2CRtYDyiFeKOG8uu+ntVv/Ca7zIkSec/8aoWN2zxXQYQq1R7t6bu7tTE3rSO1FRp38xU4n4RjEoxEyAmlroYYDgjDYxfeJGPihClufOrtWlzY1ALNa+5945jt32sV7fv0+/TuhW3x/qcQJJ0NtZVTHgrJXrmEJv6x/Zq9nKnrt6cYzXSC6vpmUMYoljmhHFwACR65hCIzMD4Q7p+beZSa5IGxgNjkRu81necl/ecx/fOVu0XetSztlafmP7CkO9z6RRAqdEzh1jVtnbpgks7tKst/m2eAABIKhYNRjB6muq18s4pMpNuXj2FIAcAQJG4zIrYhTgwHgCApKJnDl4Q5ADkYos/oHCEOQCAV2zxBxSHMAcA8IYt/oDiEeYAAF6wxR9QGoQ5AIAXi5a8s+6kJHX1StfdJ6W3dvgtDAgMYQ4A4MVIW/wBGDvCHADAi023mOqqBx6rq5YuX2B+CgICRZhDcFLt3ZrV3KYzfr9Hs5rbGF8DBCqzxZ9Ulc1ubPEHFIYwh6Ck2rs1fechTepNyyRN6k1r+s5DBDogQJ2NdVq8vEEzGzP3px0vLVrWoM7GOr+FAYEhzCEoU3d3qio98FhVOnMcQHjY4g8oHtt5ISgTe9PjOg4g+djiDygOPXMIypGa/C/Z4Y4DCANBDigcn4AIyr6ZKaUHvWrTVZnjAABUIi6zIij9A6On7u7UxN60jtRUad/MFAOmAQAVizCH4HQ21hHeAADI4jIrAABAwAhzAAAAASPMAQAABIwwBwAAEDDCHAAAQMAIcwAAAAEjzAHIq23vUd8lAADGgDAHYIiWzX1aML9dTzf3+S4FADAKFg0GMEBta5euXtIh56Sblu/Xkw81qKep3ndZFSPV3s0OJwDGhZ45AMek2ru1fnWH+o5k7rcdlB5c06FUe7ffwipEqr1b03ce0qTetEzSpN60pu88RPsDGBFhDsAxi5Yc0vVrpbTL3O/qla67T0pv7fBbWIWYurtTVemBx6rSmeMAMBzCHIBj9h2U3KBjTtIDmwYfRRQm9qbHdRwAJMIcgBybbjHVVQ88VlctXb7A/BRUYY7U5H9LHu44AEiEOQA5qs5p0MorpKpsdquvkW6+MnMc0ds3M6X0oHfldFXmOAAMhzAH4JjOxjotXt6gmY2Z+9OOlxYta2A2ZUw6G+u09/TjdLimSk7S4Zoq7T39ONofwIhYmgTAAD1N9Vp55yR98Yr9unn1FPU0VY/+l1AynY11FRXekrgUSxJrAkZCmAMwxNz51dq0uVHTpk/wXQrKWP9SLP0zePuXYpHkLTwlsSZgNIQ5AHkR5BC1kZZi8RWcklhTMehlrAyEOVQc3tyAZEjiUixJrKlQ9DJWDiZAoKKwwj6QHElciiWJNRWKRagrR3ivTqAIvLkByZHEpViSWFOhyqmXESPjMisqCm9uQHL0X+pL0rCHJNZUqCM1VZqU570txF5GjIwwh4rCmxuQLElciiWJNRVi38zUgDFzUri9jBgZn2CoKOV0CQUARsIi1JWDnjlUlHK6hAIAoymXXkaMjDCHisObGwCgnHCZFQAAIGCEOQAAgIB5DXNmdrmZPW9maTObO8J5u81sm5ltNbOWOGsEAABIMt9j5rZL+oyku8Zw7gXOuTcirgcAACAoXsOcc26HJJmZzzIAAACCFcqYOSfpMTN72syuGe4kM7vGzFrMrOXNA6zoDwAAyl/kPXNm9oSk6Xm+daNz7qExPsz5zrnXzaxR0uNm9oJz7neDT3LO3S3pbkma84FqV3DRAAAAgYg8zDnnLizBY7ye/bPdzDZImidpSJgDAACoNIm/zGpm9WaW6r8t6SJlJk4AAABUPN9Lk1xmZq9J+rCkh83s0ezxJjN7JHvaNEl/MLNnJTVLetg592s/FQMAACSL79msGyRtyHO8VdLC7O1dkv4y5tIAAACCkPjLrAAAABgeYQ4AACBghDkAiEDb3qO+SwBQIQhzAFBiLZv7tGB+u55u7vNdCoAKQJgDgBKqbe3S1Uv2yznppuX7Vdva5bskAGWOMAcAJZJq79b61R3qO5K533ZQenBNh1Lt3X4LA1DWCHMAUCKLlhzS9WuldHYzwa5e6br7pPTWDr+FAShrhDkAKJF9B6XBm0I7SQ9sYqtoANEhzAFAiWy6xVRXPfBYXbV0+QLzUxCAikCYA4ASqTqnQSuvkKqy2a2+Rrr5ysxxAIgKYQ4ASqSzsU6LlzdoZmPm/rTjpUXLGtTZWOe3MABljTAHACXU01SvlXdOkZl08+op6mmq910SgDI30XcBAFBu5s6v1qbNjZo2fYLvUgBUAHrmACACBDkAcSHMAQAABIwwBwAAEDDCHAAAQMAIcwAAAAEjzAEAAASMMAcAABAwwhwAAEDACHMAAAABI8wBAAAEjDAHAAAQMMIcAABAwAhzAAAAASPMAQAABIwwBwAAEDDCHAAAQMAIcwAAAAEjzAEAAASMMAcAABAwwhwAAEDACHMAAAABI8wBAAAEjDAHAAAQMMIcAABAwAhzAAAAASPMAQAABIwwBwAAEDDCHAAAQMAIcwAAAAEjzAEAAASMMAcAABAwwhwAAEDACHMAAAABI8wBAAAEjDAHAAAQMMIcAABAwAhzAAAAASPMAQAABIwwBwAAEDDCHAAAQMAIcwAAAAEjzAEAAASMMAcAABAwwhwAAEDACHMAAAABI8wBAAAEzGuYM7PbzOwFM3vOzDaY2fHDnHexmb1oZi+b2Q1x1wkAAJBUvnvmHpc0xzn3AUkvSfrnwSeY2QRJqyV9StJZkj5nZmfFWiUAAEBCeQ1zzrnHnHNHsnefknRKntPmSXrZObfLOdcn6aeSLo2rRgAAgCSb6LuAHF+W9LM8x0+W9Oec+69Jmp/vAczsGknXZO/2zp6xZ3tJKywPJ0p6w3cRCUS75Ee7DEWb5Ee75Ee75Ee7DHVmoX8x8jBnZk9Imp7nWzc65x7KnnOjpCOS1hXzXM65uyXdnX3MFufc3GIerxzRLvnRLvnRLkPRJvnRLvnRLvnRLkOZWUuhfzfyMOecu3Ck75vZUkl/K+njzjmX55TXJZ2ac/+U7DEAAICK53s268WS/knSJc657mFO+6Ok083svWZWLemzkjbGVSMAAECS+Z7NeqeklKTHzWyrmX1fksysycwekaTsBIlrJT0qaYek/3bOPT+Gx747oppDR7vkR7vkR7sMRZvkR7vkR7vkR7sMVXCbWP4rmwAAAAiB7545AAAAFIEwBwAAELCyCXNsDZafmV1uZs+bWdrMhp0Gbma7zWxbduxiwdOjQzGOdqm018tkM3vczHZm/zxhmPOOZl8rW82sLCckjfazN7MaM/tZ9vubzWxm/FXGbwztstTM9uW8Pq72UWeczOxHZtZuZnnXNrWM/8y22XNmdl7cNfowhnZZYGaHcl4r/xJ3jXEzs1PN7Ekz+1P2M+jrec4Z/+vFOVcWX5IukjQxe/u7kr6b55wJkl6RNEtStaRnJZ3lu/aI2+X9yixEuEnS3BHO2y3pRN/1JqldKvT18u+SbsjeviHf/6Ps997yXWvE7TDqz17SMknfz97+rKSf+a47Ie2yVNKdvmuNuV3+RtJ5krYP8/2Fkn4lySR9SNJm3zUnpF0WSPof33XG3CYnSTovezulzFamg/8Pjfv1UjY9c46twfJyzu1wzr3ou46kGWO7VNzrRZl/34+zt38s6e881uLTWH72uW21XtLHzcxirNGHSvw/MSrn3O8kHRjhlEsl3esynpJ0vJmdFE91/oyhXSqOc26Pc25L9nanMqt0nDzotHG/XsomzA3yZWVS7WD5tgYb3IiVykl6zMyezm6Lhsp8vUxzzu3J3t4radow573LzFrM7CkzK8fAN5af/bFzsr9IHpI0JZbq/Bnr/4lF2ctD683s1DzfrzSV+F4yVh82s2fN7Fdm9he+i4lTdmjGuZI2D/rWuF8vSdqbdVRxbg0WkrG0yxic75x73cwalVn374Xsb1XBKlG7lJ2R2iX3jnPOmdlwaxe9J/t6mSXpt2a2zTn3SqlrRZB+KeknzrleM/uqMr2XH/NcE5JpizLvJW+Z2UJJv5B0uueaYmFm75b0oKRvOOc6in28oMKcY2uwvEZrlzE+xuvZP9vNbIMyl1OCDnMlaJeKe72YWZuZneSc25Pt1m8f5jH6Xy+7zGyTMr9dllOYG8vPvv+c18xsoqTjJO2PpzxvRm0X51xuG9yjzDjMSleW7yXFyg0xzrlHzGyNmZ3onHvDZ11RM7NJygS5dc65n+c5Zdyvl7K5zGpsDVYwM6s3s1T/bWUmk+SdfVRhKvH1slHSl7K3vyRpSA+mmZ1gZjXZ2ydK+mtJf4qtwniM5Wef21aLJf12mF8iy8mo7TJobM8lyowJqnQbJV2VnaX4IUmHcoYzVCwzm94/ztTM5imTScr6F6Lsv/eHknY45/5jmNPG/3rxPbOjVF+SXlbmGvPW7Ff/LLMmSY8MmiXykjK9CDf6rjuGdrlMmevtvZLaJD06uF2UmZn2bPbredqlol8vUyT9RtJOSU9Impw9PlfSPdnbH5G0Lft62SbpK77rjqgthvzsJa1U5hdGSXqXpAey7z3Nkmb5rjkh7fKd7PvIs5KelDTbd80xtMlPJO2RdDj7vvIVSV+T9LXs903S6mybbdMIKwuU09cY2uXanNfKU5I+4rvmGNrkfGXGqD+Xk1cWFvt6YTsvAACAgJXNZVYAAIBKRJgDAAAIGGEOAAAgYIQ5AACAgBHmAAAAAkaYZkVlWwAAAPdJREFUAwAACBhhDgAAIGCEOQAYgZk9aWafyN7+NzO7w3dNAJArqL1ZAcCDFZJWmlmjMnvQXuK5HgAYgB0gAGAUZva/kt4taYFzrtPMZkm6UdJxzrnFfqsDUOm4zAoAIzCzsyWdJKnPOdcpSc65Xc65r/itDAAyCHMAMAwzO0nSOkmXSnrLzC72XBIADEGYA4A8zKxO0s8l/aNzboekm5UZPwcAicKYOQAYJzObIunbkj4h6R7n3Hc8lwSgghHmAAAAAsZlVgAAgIAR5gAAAAJGmAMAAAgYYQ4AACBghDkAAICAEeYAAAACRpgDAAAIGGEOAAAgYP8PZ+t2HMMHZDUAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "C = 10; #support = 53; #margin = 53; runtime = 5.40s\n" ] } ], "source": [ "circle_gaussian_optimizer = SequentialMinimalOptimizer(circle_x, circle_y, 10, kernalFunction=generateGaussianKernal(1))\n", "circle_gaussian_runtime = circle_gaussian_optimizer.runSMO(500)\n", "circle_gaussian_f = circle_gaussian_optimizer.outputf()\n", "plotResult(circle_x, circle_y, circle_gaussian_optimizer, circle_gaussian_f, circle_gaussian_runtime, minx=-2, maxx=2, miny=-2, maxy=2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The runtime is not particularly good, but the result looks quite convincing." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2.8" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "#Load MNIST Data\n", "\n", "import os\n", "import gzip\n", "from urllib.request import urlretrieve\n", "\n", "def download(filename , source=\"http://yann.lecun.com/exdb/mnist/\"):\n", " print(\"Downloading %s\" % filename)\n", " urlretrieve(source + filename , filename)\n", "\n", "def load_mnist_images(filename):\n", " if not os.path.exists(filename):\n", " download(filename)\n", " with gzip.open(filename, \"rb\") as f:\n", " data = np.frombuffer(f.read(), np.uint8, offset=16)\n", " data = data.reshape(-1, 28, 28)\n", " return data / np.float32(256)\n", "def load_mnist_labels(filename):\n", " if not os.path.exists(filename):\n", " download(filename)\n", " with gzip.open(filename, \"rb\") as f:\n", " data = np.frombuffer(f.read(), np.uint8, offset=8)\n", " return data \n", "X_train = load_mnist_images(\"train-images-idx3-ubyte.gz\")\n", "y_train = load_mnist_labels(\"train-labels-idx1-ubyte.gz\")\n", "X_test = load_mnist_images(\"t10k-images-idx3-ubyte.gz\")\n", "y_test = load_mnist_labels(\"t10k-labels-idx1-ubyte.gz\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (a)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "#creating a random sample of size n from the given data\n", "def generatePartialTrainingSet(n, X_t, y_t):\n", " indices = np.random.choice(np.size(X_t,0), n, replace=False)\n", " X_temp = X_t[indices,:]\n", " y = y_t[indices]\n", " X = np.empty((n, 28*28))\n", " for i in range(n):\n", " X[i,:] = (X_temp[i,:,:]).flatten()\n", " return X , y" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "from sklearn.svm import SVC\n", "from sklearn.model_selection import KFold\n", "\n", "#performs the cross validation for one pair of paramters C, gamma\n", "def crossValidationFor(C, gamma, points, labels, n_splits = 5):\n", " kfold = KFold(n_splits = n_splits)\n", " acc = 0\n", " for train, test in kfold.split(points):\n", " clf = SVC(C=C, gamma=gamma)\n", " clf.fit(points[train], labels[train])\n", " acc = acc + clf.score(points[test], labels[test])\n", " \n", " return acc/n_splits\n", "\n", "#performs the cross validation for all pairs in the given parameters to find the optimal pair of paramters C, gamma\n", "def kFoldCrossValidationSceme(C_values, gamma_values, points, labels, n_splits = 5):\n", " n_C = np.size(C_values)\n", " n_gamma = np.size(gamma_values)\n", " \n", " A = np.empty((n_C,n_gamma))\n", " \n", " for i in range(n_C):\n", " for j in range(n_gamma):\n", " A[i,j] = crossValidationFor(C_values[i], gamma_values[j], points, labels, n_splits=n_splits)\n", " \n", " ind = np.unravel_index(np.argmax(A, axis= None), A.shape)\n", " \n", " return C_values[ind[0]], gamma_values[ind[1]], A[ind]" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "#creating a random sample of size 500 from the MNIST training data \n", "training_x_mnist, training_y_mnist = generatePartialTrainingSet(500, X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "optimal accuracy: 0.874\n", "otpimal C: 10\n", "optimal gamma: 0.01\n" ] } ], "source": [ "#finding our optimal parameters C and Gamma\n", "C_mnist_opt, gamma_mnist_opt, acc_mnist_opt = kFoldCrossValidationSceme([1,10,100],[.1,.01,.001],training_x_mnist, training_y_mnist)\n", "\n", "print(\"optimal accuracy:\", acc_mnist_opt)\n", "print(\"otpimal C:\", C_mnist_opt)\n", "print(\"optimal gamma:\", gamma_mnist_opt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (b)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "#creating a random sample of size 2000 from the MNIST training data \n", "training_x_mnist_big, training_y_mnist_big = generatePartialTrainingSet(2000, X_train, y_train)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "#using the optimal parameters computed above to learn SCV\n", "clf_mnist = SVC(C=C_mnist_opt, gamma=gamma_mnist_opt)\n", "_ = clf_mnist.fit(training_x_mnist_big, training_y_mnist_big)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "#Flatten test data \n", "test_x_mnist = np.empty((len(X_test), 28*28))\n", "for i in range(len(X_test)):\n", " test_x_mnist[i,:] = (X_test[i,:,:]).flatten()" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "from sklearn.metrics import confusion_matrix as skl_confusion_matrix" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy: 0.9385\n", "confusion matrix:\n", " [[ 962 0 0 0 1 7 6 1 2 1]\n", " [ 0 1122 3 2 0 1 4 0 3 0]\n", " [ 10 2 962 6 15 2 11 13 11 0]\n", " [ 1 3 25 938 1 15 2 8 11 6]\n", " [ 0 4 3 0 939 2 10 3 2 19]\n", " [ 9 2 10 34 1 812 9 3 10 2]\n", " [ 13 4 5 1 7 7 920 1 0 0]\n", " [ 1 12 27 2 7 0 0 956 3 20]\n", " [ 7 4 11 25 6 19 13 9 875 5]\n", " [ 8 7 2 17 53 3 0 16 4 899]]\n" ] } ], "source": [ "#Accuracy\n", "print(\"accuracy:\", clf_mnist.score(test_x_mnist, y_test))\n", "\n", "#Confustionmatrix\n", "print(\"confusion matrix:\\n\", skl_confusion_matrix(y_test, clf_mnist.predict(test_x_mnist)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We are dealing with 784 dimensional data and we take only 500 training points to tune our parameters with. We think in general one has to be quite careful, when training a system with little points comparded to the dimension. As far as we had a look at the data a lot of the dimensions are zero (white background) for each data sample. So we think in our case this might work out.\n", "\n", "In gerneral it is pobably a valid aproach, as long as we make sure that both training sets we use are representative for the data we want to learn our system for." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.5.2" } }, "nbformat": 4, "nbformat_minor": 2 }