From 4532da9925d392c5c470dd10bb977e5d16fb1c77 Mon Sep 17 00:00:00 2001 From: GregHilston Date: Sun, 24 Nov 2019 11:30:23 -0700 Subject: [PATCH 1/4] Added my solutions to exercise 1, need to run the optional exercises to verify understanding --- Exercise1/exercise1.ipynb | 611 +++++++++++++++++++++++++++++++++++--- 1 file changed, 562 insertions(+), 49 deletions(-) diff --git a/Exercise1/exercise1.ipynb b/Exercise1/exercise1.ipynb index 0d245b5c..4dfc9d7e 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.identity(5)\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,44 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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 +249,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -236,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -271,7 +321,10 @@ " \n", " # ====================== YOUR CODE HERE ======================= \n", " \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 +341,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)" ] @@ -306,9 +372,290 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mSignature:\u001b[0m \u001b[0mpyplot\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscalex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscaley\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m\n", + "Plot y versus x as lines and/or markers.\n", + "\n", + "Call signatures::\n", + "\n", + " plot([x], y, [fmt], *, data=None, **kwargs)\n", + " plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)\n", + "\n", + "The coordinates of the points or line nodes are given by *x*, *y*.\n", + "\n", + "The optional parameter *fmt* is a convenient way for defining basic\n", + "formatting like color, marker and linestyle. It's a shortcut string\n", + "notation described in the *Notes* section below.\n", + "\n", + ">>> plot(x, y) # plot x and y using default line style and color\n", + ">>> plot(x, y, 'bo') # plot x and y using blue circle markers\n", + ">>> plot(y) # plot y using x as index array 0..N-1\n", + ">>> plot(y, 'r+') # ditto, but with red plusses\n", + "\n", + "You can use `.Line2D` properties as keyword arguments for more\n", + "control on the appearance. Line properties and *fmt* can be mixed.\n", + "The following two calls yield identical results:\n", + "\n", + ">>> plot(x, y, 'go--', linewidth=2, markersize=12)\n", + ">>> plot(x, y, color='green', marker='o', linestyle='dashed',\n", + "... linewidth=2, markersize=12)\n", + "\n", + "When conflicting with *fmt*, keyword arguments take precedence.\n", + "\n", + "\n", + "**Plotting labelled data**\n", + "\n", + "There's a convenient way for plotting objects with labelled data (i.e.\n", + "data that can be accessed by index ``obj['y']``). Instead of giving\n", + "the data in *x* and *y*, you can provide the object in the *data*\n", + "parameter and just give the labels for *x* and *y*::\n", + "\n", + ">>> plot('xlabel', 'ylabel', data=obj)\n", + "\n", + "All indexable objects are supported. This could e.g. be a `dict`, a\n", + "`pandas.DataFame` or a structured numpy array.\n", + "\n", + "\n", + "**Plotting multiple sets of data**\n", + "\n", + "There are various ways to plot multiple sets of data.\n", + "\n", + "- The most straight forward way is just to call `plot` multiple times.\n", + " Example:\n", + "\n", + " >>> plot(x1, y1, 'bo')\n", + " >>> plot(x2, y2, 'go')\n", + "\n", + "- Alternatively, if your data is already a 2d array, you can pass it\n", + " directly to *x*, *y*. A separate data set will be drawn for every\n", + " column.\n", + "\n", + " Example: an array ``a`` where the first column represents the *x*\n", + " values and the other columns are the *y* columns::\n", + "\n", + " >>> plot(a[0], a[1:])\n", + "\n", + "- The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*\n", + " groups::\n", + "\n", + " >>> plot(x1, y1, 'g^', x2, y2, 'g-')\n", + "\n", + " In this case, any additional keyword argument applies to all\n", + " datasets. Also this syntax cannot be combined with the *data*\n", + " parameter.\n", + "\n", + "By default, each line is assigned a different style specified by a\n", + "'style cycle'. The *fmt* and line property parameters are only\n", + "necessary if you want explicit deviations from these defaults.\n", + "Alternatively, you can also change the style cycle using the\n", + "'axes.prop_cycle' rcParam.\n", + "\n", + "\n", + "Parameters\n", + "----------\n", + "x, y : array-like or scalar\n", + " The horizontal / vertical coordinates of the data points.\n", + " *x* values are optional and default to `range(len(y))`.\n", + "\n", + " Commonly, these parameters are 1D arrays.\n", + "\n", + " They can also be scalars, or two-dimensional (in that case, the\n", + " columns represent separate data sets).\n", + "\n", + " These arguments cannot be passed as keywords.\n", + "\n", + "fmt : str, optional\n", + " A format string, e.g. 'ro' for red circles. See the *Notes*\n", + " section for a full description of the format strings.\n", + "\n", + " Format strings are just an abbreviation for quickly setting\n", + " basic line properties. All of these and more can also be\n", + " controlled by keyword arguments.\n", + "\n", + " This argument cannot be passed as keyword.\n", + "\n", + "data : indexable object, optional\n", + " An object with labelled data. If given, provide the label names to\n", + " plot in *x* and *y*.\n", + "\n", + " .. note::\n", + " Technically there's a slight ambiguity in calls where the\n", + " second label is a valid *fmt*. `plot('n', 'o', data=obj)`\n", + " could be `plt(x, y)` or `plt(y, fmt)`. In such cases,\n", + " the former interpretation is chosen, but a warning is issued.\n", + " You may suppress the warning by adding an empty format string\n", + " `plot('n', 'o', '', data=obj)`.\n", + "\n", + "Other Parameters\n", + "----------------\n", + "scalex, scaley : bool, optional, default: True\n", + " These parameters determined if the view limits are adapted to\n", + " the data limits. The values are passed on to `autoscale_view`.\n", + "\n", + "**kwargs : `.Line2D` properties, optional\n", + " *kwargs* are used to specify properties like a line label (for\n", + " auto legends), linewidth, antialiasing, marker face color.\n", + " Example::\n", + "\n", + " >>> plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)\n", + " >>> plot([1,2,3], [1,4,9], 'rs', label='line 2')\n", + "\n", + " If you make multiple lines with one plot command, the kwargs\n", + " apply to all those lines.\n", + "\n", + " Here is a list of available `.Line2D` properties:\n", + "\n", + " agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n", + " alpha: float\n", + " animated: bool\n", + " antialiased or aa: bool\n", + " clip_box: `.Bbox`\n", + " clip_on: bool\n", + " clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]\n", + " color or c: color\n", + " contains: callable\n", + " dash_capstyle: {'butt', 'round', 'projecting'}\n", + " dash_joinstyle: {'miter', 'round', 'bevel'}\n", + " dashes: sequence of floats (on/off ink in points) or (None, None)\n", + " drawstyle or ds: {'default', 'steps', 'steps-pre', 'steps-mid', 'steps-post'}, default: 'default'\n", + " figure: `.Figure`\n", + " fillstyle: {'full', 'left', 'right', 'bottom', 'top', 'none'}\n", + " gid: str\n", + " in_layout: bool\n", + " label: object\n", + " linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n", + " linewidth or lw: float\n", + " marker: marker style\n", + " markeredgecolor or mec: color\n", + " markeredgewidth or mew: float\n", + " markerfacecolor or mfc: color\n", + " markerfacecoloralt or mfcalt: color\n", + " markersize or ms: float\n", + " markevery: None or int or (int, int) or slice or List[int] or float or (float, float)\n", + " path_effects: `.AbstractPathEffect`\n", + " picker: float or callable[[Artist, Event], Tuple[bool, dict]]\n", + " pickradius: float\n", + " rasterized: bool or None\n", + " sketch_params: (scale: float, length: float, randomness: float)\n", + " snap: bool or None\n", + " solid_capstyle: {'butt', 'round', 'projecting'}\n", + " solid_joinstyle: {'miter', 'round', 'bevel'}\n", + " transform: `matplotlib.transforms.Transform`\n", + " url: str\n", + " visible: bool\n", + " xdata: 1D array\n", + " ydata: 1D array\n", + " zorder: float\n", + "\n", + "Returns\n", + "-------\n", + "lines\n", + " A list of `.Line2D` objects representing the plotted data.\n", + "\n", + "See Also\n", + "--------\n", + "scatter : XY scatter plot with markers of varying size and/or color (\n", + " sometimes also called bubble chart).\n", + "\n", + "Notes\n", + "-----\n", + "**Format Strings**\n", + "\n", + "A format string consists of a part for color, marker and line::\n", + "\n", + " fmt = '[marker][line][color]'\n", + "\n", + "Each of them is optional. If not provided, the value from the style\n", + "cycle is used. Exception: If ``line`` is given, but no ``marker``,\n", + "the data will be a line without markers.\n", + "\n", + "Other combinations such as ``[color][marker][line]`` are also\n", + "supported, but note that their parsing may be ambiguous.\n", + "\n", + "**Markers**\n", + "\n", + "============= ===============================\n", + "character description\n", + "============= ===============================\n", + "``'.'`` point marker\n", + "``','`` pixel marker\n", + "``'o'`` circle marker\n", + "``'v'`` triangle_down marker\n", + "``'^'`` triangle_up marker\n", + "``'<'`` triangle_left marker\n", + "``'>'`` triangle_right marker\n", + "``'1'`` tri_down marker\n", + "``'2'`` tri_up marker\n", + "``'3'`` tri_left marker\n", + "``'4'`` tri_right marker\n", + "``'s'`` square marker\n", + "``'p'`` pentagon marker\n", + "``'*'`` star marker\n", + "``'h'`` hexagon1 marker\n", + "``'H'`` hexagon2 marker\n", + "``'+'`` plus marker\n", + "``'x'`` x marker\n", + "``'D'`` diamond marker\n", + "``'d'`` thin_diamond marker\n", + "``'|'`` vline marker\n", + "``'_'`` hline marker\n", + "============= ===============================\n", + "\n", + "**Line Styles**\n", + "\n", + "============= ===============================\n", + "character description\n", + "============= ===============================\n", + "``'-'`` solid line style\n", + "``'--'`` dashed line style\n", + "``'-.'`` dash-dot line style\n", + "``':'`` dotted line style\n", + "============= ===============================\n", + "\n", + "Example format strings::\n", + "\n", + " 'b' # blue markers with default shape\n", + " 'or' # red circles\n", + " '-g' # green solid line\n", + " '--' # dashed line with default color\n", + " '^k:' # black triangle_up markers connected by a dotted line\n", + "\n", + "**Colors**\n", + "\n", + "The supported color abbreviations are the single letter codes\n", + "\n", + "============= ===============================\n", + "character color\n", + "============= ===============================\n", + "``'b'`` blue\n", + "``'g'`` green\n", + "``'r'`` red\n", + "``'c'`` cyan\n", + "``'m'`` magenta\n", + "``'y'`` yellow\n", + "``'k'`` black\n", + "``'w'`` white\n", + "============= ===============================\n", + "\n", + "and the ``'CN'`` colors that index into the default property cycle.\n", + "\n", + "If the color is the only part of the format string, you can\n", + "additionally use any `matplotlib.colors` spec, e.g. full names\n", + "(``'green'``) or hex strings (``'#008000'``).\n", + "\u001b[0;31mFile:\u001b[0m /mnt/m/Code/ml-coursera-python-assignments/venv/lib/python3.6/site-packages/matplotlib/pyplot.py\n", + "\u001b[0;31mType:\u001b[0m function\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "?pyplot.plot" ] @@ -352,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -375,9 +722,18 @@ "" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're coding the following function:\n", + "\n", + "$\\text{cost function } J(\\theta) = \\frac{1}{2m} \\sum_{i=1}^m (h_\\theta(x^{(i)}) - y^{(i)}) ^2$" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -419,7 +775,11 @@ " J = 0\n", " \n", " # ====================== YOUR CODE HERE =====================\n", - "\n", + " \n", + " predictions = X.dot(theta)\n", + " differences = predictions - y\n", + " square_err = differences ** 2\n", + " J = 1/(2*m) * np.sum(square_err)\n", " \n", " # ===========================================================\n", " return J" @@ -434,9 +794,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "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 +831,44 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -548,7 +957,11 @@ " for i in range(num_iters):\n", " # ==================== YOUR CODE HERE =================================\n", " \n", - "\n", + " Hypothesis = X.dot(theta)\n", + " Loss = Hypothesis - y\n", + " Gradient = X.T.dot(Loss) / m\n", + " theta -= alpha * Gradient\n", + " \n", " # =====================================================================\n", " \n", " # save the cost J in every iteration\n", @@ -566,9 +979,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 48, + "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 +1015,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEHCAYAAACncpHfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO2deXxU1fXAvzfJKBnDiBKkVoRo6lJ2AS0YbW1xAVm0Gjd2BaNsakQlqG21VYEq0lZQlICyuuGGktT+xKVawAoooICS0aAoLqCyCA0Tcn5/vDdhklmTzJbJ+X4+75OZ++5798zMyzl3OedcIyIoiqIoTY+0RAugKIqiJAY1AIqiKE0UNQCKoihNFDUAiqIoTRQ1AIqiKE0UNQCKoihNlIxY3dgYczwwH2gNCPCYiPzdGHMXcC3wnV31dhEpCXWv7OxsycnJiZWoiqIoKcmaNWt2iEirYOdjZgCASmCCiKw1xjQH1hhj/s8+N11EHoj0Rjk5OaxevTomQiqKoqQqxpitoc7HzACIyHZgu/16jzFmE3BcrNpTFEVR6kZc1gCMMTnAacC7dtE4Y8x6Y8xcY8xR8ZBBURRFqUnMDYAxJgt4DrhJRHYDjwC5QFesEcK0INcVGGNWG2NWf/fdd4GqKIqiKA0glmsAGGMcWMp/kYg8DyAi3/icnw28EuhaEXkMeAygR48efgmLPB4P27Zt43//+18sRFeShGbNmtGmTRscDkeiRVGUuOF2u5kxbRqLFy5kx969ZGdlMWjIEMZNmEBubm7U2omlF5AB5gCbRORBn/Jj7fUBgN8DH9bn/tu2baN58+bk5ORgNaWkGiLCzp072bZtGyeccEKixVGUuFBaWsqw/Hyu9XhY4fHQDti6Zw9ziovpOW8e85csoW/fvlFpK5YjgDxgKLDBGPOBXXY7cJUxpiuWa2g5cF19bv6///1PlX+KY4yhZcuW6BSg0lRwu90My89n6b599PIpzwXu83gY4PEwMD+fVevXR2UkEEsvoHeAQNo5pM9/XVDln/rob6w0JWZMm8a1Hk8N5e9LL2CUx8PM6dN5cMaMBrfXJCKB3W43hWPG0NrlIj0tjdYuF4VjxuB2uxMtmqIoSjWLFy5kpMcTss4oj4fFCxZEpb2UNwClpaX07NyZzOJiVuzZQ4UIK/bsIbO4mJ6dO1NaWlqv++7cuZOuXbvStWtXfvazn3HcccdVvz9w4EBE97j66qv5+OOPQ9aZOXMmixYtqpeMoXjttde4+OKLQ9ZZu3Yt//znP6PetqIogdmxdy/twtRpa9eLBjH1Ako0sZxPa9myJR98YC1t3HXXXWRlZXHLLbfUqCMiiAhpaYHt7OOPPx62nbFjx9ZJrmiydu1aPvzwQ/r06ZMwGRSlKZGdlcXWPXsIpY0+t+tFg5QeAdRlPi1alJWV0b59ewYPHkyHDh3Yvn07BQUF9OjRgw4dOvDnP/+5uu5ZZ53FBx98QGVlJS1atKCoqIguXbrQq1cvvv32WwDuvPNO/va3v1XXLyoq4owzzuCUU05hxYoVAPz0009ceumltG/fnvz8fHr06FFtnHxZtmwZp5xyCt26deOll16qLl+1ahW9evXitNNOIy8vjy1btrB//37+/Oc/s2jRIrp27cqSJUsC1lMUJXoMGjKEOWFcnosdDgYNHRqdBr291GQ+unfvLrXZuHGjX1ltjmneXMpAJMRRBtLa5Qp7r1D86U9/kvvvv19ERLZs2SLGGHnvvfeqz+/cuVNERDwej5x11lny0UcfiYhIXl6evP/+++LxeASQkpISEREpLCyUyZMni4jIHXfcIdOnT6+uf9ttt4mIyEsvvSQXXHCBiIhMnjxZxowZIyIiH3zwgaSlpcn7779fQ8affvpJjjvuOCkrK5Oqqiq55JJL5KKLLhIRkR9//FE8Ho+IiJSWlsrll18uIiKzZ8+WG2+8sfoewerFmkh+a0VJBcrKyiTb6ZQVQfTVCpBsp1PKysoiuh+wWkLo1pSeAor3fJqX3NxcevToUf3+ySefZM6cOVRWVvLVV1+xceNG2rdvX+OazMzMat/e7t278/bbbwe89yWXXFJdp7y8HIB33nmHiRMnAtClSxc6dOjgd93GjRs5+eSTq6e6Bg8ezPz58wH48ccfGTZsWNhF8UjrKYpSP3Jzc5m/ZAkD8/MZ5fEwyuOhLda0T7HDQbHDwfwlS6IWDJbSU0DZWVmETIVHdOfTvBxxxBHVr7ds2cLf//53Xn/9ddavX0+fPn0CRi8fdthh1a/T09OprKwMeO/DDz88bJ26cscdd3DBBRfw4Ycf8uKLLwaNro60nqIo9adv376sWr+eioIC8lwuMtPSyHO5qCgoYNX69VELAoMUNwBxn08LwO7du2nevDkul4vt27fz6quvRr2NvLw8nnnmGQA2bNjAxo0b/eq0b9+eLVu28NlnnyEiPPnkk9Xndu3axXHHWYlan3jiiery5s2bs2fPnrD1FCVeNBWX7tzcXB6cMYOvd+2i8uBBvt61iwdnzIhqGghIcQMwbsIEZjscrAxyfiWWARhbWBgzGbp160b79u059dRTGTZsGHl5eVFvY/z48Xz55Ze0b9+eu+++m/bt23PkkUfWqON0Opk1axZ9+/alR48eHHvssdXnJk6cyK233kq3bt2wpg0tfve737Fu3TpOO+00lixZErSeosSDWLl0N2lCLRAky1HfRWARkZKSEsl2OqXI4ZAykAP2wm+RwyHZTmf1wmtjxuPxyP79+0VE5JNPPpGcnJzqxdpUQBeBlWgvjjYVCLMInNIjAIjvfFqi2Lt3L3l5eXTp0oVLL72URx99lIyMlF7fV5oYiXDpbgoYaQRD+R49ekjtLSE3bdrEL3/5ywRJpMQT/a2V1i4XK8IESLmBPJeLr3ftipdYSY8xZo2I9Ah2PuVHAIqiNH4S5dKd6qgBUBQl6UmUS3eqowZAUZSkJx4u3cnmYjrzjTKGznmXnyqiE+8TCDUAiqIkPbF26U4WF1MRYUrpZnKKlnH/qx/z9pYdagCSlawAw81Zs2ZVp1hoyixdupQpU6YkWgwlRahOkeB0MsnhwA14sBZ+JzkcDHQ6650iwTdr8H0eD7lYaZK9WYOX7tvHsPz8mI4EqqqE21/YwAmTSpj1ltVOu5ZO3v/DeRzjahazdtVXMMpcf/31Mb1/tf9ukBTTBw8eJD09vd73r6ysjIoL6cCBAxk4cGCD76MoXrwu3TOnTydvwYJDm6UPHcqqwsJ6R8nGexcuXyoPVnHzM+tYuu6r6rJOxx3J4mt/RfNmoae8ooGOAKLMXXfdxQMPPADAOeecw8SJEznjjDM4+eSTqxO8HTx4kFtvvZXTTz+dzp078+ijjwKWP3/v3r3p1q0bnTp1qk7ZXF5ezimnnMKwYcPo2LEjX3zxRY02c3JymDhxIt26dePZZ5/F7XbTp08funfvztlnn83mzZsBq6fTs2dPOnXqxJ133lk9gnnzzTc5++yzGThwYHWSuoULF3LGGWfQtWtXrrvuOg4ePMjBgwcZMWIEHTt2pFOnTky3fa7/8Y9/0L59ezp37syVV14JWKkixo0bVy3/7373Ozp37kzv3r35/PPPARgxYgQ33HADZ555JieeeCJLliyJzY+ipAyxSJEQ7124ACoqDzLi8f/yiztKq5X/mbkt2fyXPrw8/qy4KH9IkRHA3S9/xMavdkf1nu1/7uJPA/yzataVyspK/vvf/1JSUsLdd9/Na6+9xpw5czjyyCN57733qKioIC8vj/PPP5/jjz+eF154AZfLxY4dO+jZs2d1L3rLli3MmzePnj17BmynZcuWrF27FoDevXsza9YsTjrpJN59913GjBnD66+/zo033siNN97IVVddxaxZs2pc79385YQTTmDTpk08/fTT/Oc//8HhcDBmzBgWLVpEhw4d+PLLL/nwww8BKzsowJQpU/jss884/PDDq8t8GT9+PMOHD2f48OHMnTuXG264gRdffBGA7du3884777B582YGDhxIfn5+g79zRakLtV1M3cAMYDGwA8gGrgS+88mLVV/2HahkSPG7rP380P/JBR1a89BV3TgsI/798ZQwAMlMoPTN//rXv1i/fn11j3fXrl1s2bKFNm3acPvtt/Pvf/+btLQ0vvzyS7755hsA2rVrF1T5A1xxxRWANYpYsWIFl112WfW5iooKAFauXFmteAcNGlRjB7MzzjiDE044AYDly5ezZs0aTj/9dAD279/PMcccw4ABA/j0008ZP348/fr14/zzzwegc+fODB48mIsvvjjgNpMrV67k+eefB2Do0KHcdttt1ecuvvhi0tLSaN++ffVnVZR44rsLVykwDLgWWAG0A7YCxUAzEUpLS+uVPWDXfg+XPrKCsm8PxSnkd2/D1Es7k55movEx6kVKGIBo9NRjRaD0zSLCQw89xAUXXFCj7hNPPMF3333HmjVrcDgc5OTkVKdc9k0xHQjv+aqqKlq0aBFwR7BIrvfKN3z4cCZPnuxXb926dbz66qvMmjWLZ555hrlz57Js2TL+/e9/8/LLL3PvvfeyYcOGiNv1fj/edhUl3gwaMoQ5xcWM9HgYBiwFvy1kJwMDoc5byO7YW0H/f7zD17sPpU6/Oi+HP/ZvjzGJU/xedA0gAVxwwQU88sgjeOx5x08++YSffvqJXbt2ccwxx+BwOHjjjTfYujVc6Is/LpeLE044gWeffRawlOq6desA6NmzJ8899xwATz31VNB79O7dmyVLllRvS/n999+zdetWduzYQVVVFZdeein33HMPa9eupaqqii+++ILf/va3TJ06lV27drG3VjTmmWeeWd3eokWLOPvss+v8uRQlVnhdTO/E6vlHI9/Qmq0/kFO0jB73vFat/G/sfRKfTb6QPw3okBTKH1JkBJAo9u3bR5s2barf33zzzRFdN2rUKMrLy6vTKrdq1YoXX3yRwYMHM2DAADp16kSPHj049dRT6yXXokWLGD16NPfccw8ej4crr7ySLl268Le//Y0hQ4Zw77330qdPH7+U0V7at2/PPffcw/nnn09VVRUOh4OZM2eSmZnJ1VdfTVVVFQCTJ0/m4MGDDBkyhF27diEi3HDDDbRo0aLG/R566CGuvvpq7r//flq1asXjjz9er8+lKLHA62J66YUXEm7sOsrjIW/BgqDeQG9+/C0jHn+vRtmd/X7JqLNPjJK00UWTwTUh9u3bR2ZmJsYYnnrqKZ588skam8MnK/pbK/EgPS2NijD75HqAzLQ0Kg8erFH+0gdfcuNTNaddT2vbghfGRH//j7oQLhmcjgCaEGvWrGHcuHGICC1atGDu3LmJFklRkgbfxeBg1M439Ph/PuPul2vuwNe34894ZEj32AgZZdQANCHOPvvs6vUARVFq4l0Mvi9ETIA339ADr37MjDfKapwb3qsdd1/UMdZiRpVGbQBEJGkWU5TY0BimKJXUYNyECfScN48BQaKCVwLzLxiHI6s3+Cj/m887mRt6nxQ3OaNJzAyAMeZ4YD7QGhDgMRH5uzHmaOBpIAcoBy4XkR/qev9mzZqxc+dOWrZsqUYgRRERdu7cSbNmscuFoiheqvMN5eczyuNhlMdDW6xpn6GX3cVXJ/bANz73nos7MqRnuF0KkpuYLQIbY44FjhWRtcaY5sAa4GJgBPC9iEwxxhQBR4nIxFD3CrQI7PF42LZtW7WfvJKaNGvWjDZt2uAIkwpYUaKF2+1m5vTpLF6wgLRL7uGw1jU9eGYO6ka/zscmSLq6kbBFYBHZDmy3X+8xxmwCjgMuAs6xq80D3gRCGoBAOByO6shVRVGUaJGbm8vzWX1pNrpmxO+iUb8i7xfZCZIqNsRlDcAYkwOcBrwLtLaNA8DXWFNEiqIoCUVEOGFSiV/5S2Pz6HJ8iwBXNH5ibgCMMVnAc8BNIrLbd75eRMQYE3AOyhhTABQAtG3bNtZiKorSRPEcrOKkO/w3fFlyfS965BydAIniR0wNgDHGgaX8F4nI83bxN8aYY0Vku71O8G2ga0XkMeAxsNYAYimnoihNj70VlXT806t+5c+NPpPu7Y5KgETxJ5ZeQAaYA2wSkQd9Ti0FhgNT7L/JH4qqKErK8O3u/3HGfcv9yl+f8BtObNW0NpWP5QggDxgKbDDGeGOkb8dS/M8YY0ZiZVq9PIYyKIqiAFD27V7OffAtv/L37jiXVs0PD3BF6hNLL6B3gGAO+r1j1a6iKIov75V/z2Wz/LeT/+juCzji8EYdC9tgmvanVxQlZSndsJ3Ri9b6lZfd25eMdM2ED2oAFEVJMQIlaAP4bPKFmjWgFmoAFEVJCe5dtpHZb3/mV14+pV8CpGkcqAFQFKVRUzB/Nf/a6L+ftCr+8KgBUBSlUXLeg2+x5du9fuWq+CNHV0IURWlU5BQtI6domZ/yL5/SLymUv9vtpnDMGFq7XKSnpdHa5aJwzBjcbneiRfNDRwCKojQKcoqWBSxPBqXvpbS0lGH5+Vzr8bDC46EdsHXPHuYUF9Nz3jzmL1lC3759w94nXjTaPYEVRWkaNAbFD1bPv2fnzizdty/ohjIDnU5WrV9Pbm6ojSejR7h00DoFFIbGNJxTlFTCO9VTm2SZ6qnNjGnTuDbIbmIAvYBRHg8zp0+Pp1gh0RFACHyHcyO9wzlgjsPBbIcj6YZzipIKBFL6p7RuzquFv06ANJHT2uViRZhN5d1AnsvF17t2xUWmcCMANQBBSMbhnKKkKsFy8V/U9ef8/crTEiBR3UlPS6NCJOTCqgfITEuj8uDBuMiUsB3BGjt1Gc49OGNGPEVTlJThQGUVJ9/pn4t/wnknM76RbbSenZXF1jAjgM/tesmCrgEEYfHChYz0eELWGeXxsHjBgjhJpCipw659HnKKlvkp/79f2ZXyKf2CKv9kXpMbNGQIc8LsXV3scDBo6NA4SRQenQIKQjIO5xSlsfP5zn38+v43/Mqfvb4Xp4fZfSvZ1+SScdpYp4DqSWMczilKsrL28x+45OEVfuVv3HIOJ2QfEfZ6t9vNsPx8P+WaC9zn8TDA42Fgfn5C1+Ryc3OZv2QJA/PzGeXxMMrjoS2Wnih2OCi2jVQyrRnqFFAQGuNwTlGSjWXrt5NTtMxP+b//h/Mon9IvIuUPjcfFsm/fvqxav56KggLyXC4y09LIc7moKChg1fr1Sec1qFNAQUjG4ZyiNBZmveVmSulmv/LNf+lDM0d6ne+XjC6WjQGdAqonjXE4pyiJ5tZn1/Hsmm1+5Q3Nxb9j717ahanT1q6nRI4agBB4h3Mzp08nb8ECduzdS3ZWFoOGDmVVYaEqf0WxGTjjHdZv8+95RytiV9fkYoNOASmKUm/ilaencMwYMouLuS+Ea/Ykh4OKggKNy/FBp4AURYk68U7QNm7CBHrOm8eAIAvBK7GmZlcVFsak/VRFDYCiKBGTqMycuiYXG9QAKIoSlmRIyaxrctEn7BqAsZbuzwCOs4u+BP4rcVw80DUApTHidruZMW0aixcuPKSshgxh3IQJjUZZJYPiV+pPg9YAjDHnAw8DW7AUP0Ab4BfGmDEi8q+oSaooKURj2xmqNqr4mwYhRwDGmE1AXxEpr1V+AlAiIr+MrXgWOgJQGhONOYgwkOLPaenkzVt/mwBplIbSUC+gDMA/qsMaDYTOk6AoTZTGlko8WC7+Czv9jIcHd0+AREq8CDcCmARcDjwFfGEXHw9cCTwjIpNjLiE6AlAaF40lbYHnYBUn3eGfi/+G3idx83knJ0AiJdo0aAQgIpONMS8BA6G6Q/MlMFhENoZpeC7QH/hWRDraZXcB1wLf2dVuFxH/roeiNGKSPW3B7v956HyX//LdA5d1Ib97mwRIpCSKsG6gtqLfaIw52n7/fYT3fgKYAcyvVT5dRB6oi5CKEm8a4sGTrGkLtv2wj7Om+ufif/LanvTKbRlXWZTkIGQ6aGNMW2PMU8aYb4F3gf8aY761y3JCXSsi/wYiNRaKkjSUlpbSs3NnMouLWbFnDxUirNizh8ziYnp27kxpqf+0iS/Jlkp83Rc/klO0zE/5v3bzrymf0k+VfxMm3BrASuBvwBIROWiXpQOXATeJSM+QN7eMxCu1poBGALuB1cAEEfkhnJC6BqDEi2h48CSLF9CrH33NdQvW+JWvvvNcsrMOj1m7SvIQbg0g3IYw2SLytFf5A4jIQRF5CqhPt+ERrE18ugLbgWnBKhpjCowxq40xq7/77rtg1RQlqkRj45HqtAVOJ5McDtxY24e6sRKWDXQ6Y5q2oPjtT8kpWuan/Df/pQ/lU/qp8leqCTcCeAprGmceNb2AhmMZh8tD3rzWCCDSc7XREYASL6LpweN2u5k5fTqLa6UtGBujtAW3v7CBxe9+7lf+6X0XkpZW/1z8SuMl3AggnAE4DBgJXETNVBBLgTkiUhGm8RxqTgEdKyLb7deFwK9E5MpwH0INgBIv0tPSqBAJ6R3hATLT0qg8eDBErfiR/8gKVm/1n0nVqF2loW6gB7CmbR6pR8NPAucA2caYbcCfgHOMMV0BAcqB6+p6X0WJJcnqwROIU/9Qyv88VX7lqviVSAmXCygDawRwMTVHAC9hjQCC7s4gIlcFKJ5TTzmVCEiF5GOJZtCQIcwJs/FIPD14AqF5epRoEW4K6EngR6w1AG9KiDZYawBHi8gVMZcQnQKKBN/kYyO9yceAOQ4Hs+1c6cmcfCxZSBYPnkCo4lfqSkPXAD4RkYAx4aHORRs1AKFJZqWVzAQbMXXq0YOJ48eH3HgknsZUFb9SXxrqBvq9MeYyY0x1PWNMmjHmCiCs/74SH6LhutjUCBXsNXH8eKY+9BAVBQXkuVxkpqWR53JRUVDAqvXr46b8c4qWBVT+5VP6qfJXokK4EUAOMBX4HYcUfgvgDaBIRD6LsXyAjgDC0ViSjyULyT5i0h6/Ei0a6gVUDlxh36ilXbYzmgIqDSfZk48lG8marjmQ4v/5kc1YMal33GRQmhZht4QMeJExPYCvROSr6Ivkj44AQqMjgLqRTN9XsFz8Q3u24y8Xh42RVJSQNHRDmGCMBzrbC8Fx8QRSgtMYXBeTiWQYMVUerOIXAXLx39nvl4w6+8SYtasovtTLAIjIcABjTPPoiqPUh3ETJtBz3jwGBJnWWIllAFYVFsZbtKQkkcFe+w5U0v6Pr/qVPzK4G307HRv19hQlFGENgDHmSKAPNQPBXhWRH0VkTyyFUyKjOvlYfn5I10V1AbVIxIjp2z3/44x7l/uVPzf6TLq3Oypq7ShKXQi3H8AwYC1WSgenffwWWGOfU5KEvn37smr9+oS7LjYGxk2YwGyHg5VBzntHTGOjMGL68Mtd5BQt81P+b9xyDuVT+qnyVxJKODfQj7EStv1Yq/wo4F0NBFMaK97I6VgFey3f9A0j5/k/s2v/cB5HH3FY/QVXlDrQ0EAwg5W4rTZV9jmlkeN2uykcM4bWLhfpaWm0drkoHDMGt9udaNFiSqxGTPNWlJNTtMxP+W/88wWUT+kXVvk31d9DSQzhRgDDgT8C/+LQfgBtgfOAv4jIE7EWEHQEUBfqkhBO8wdFj7uWfsQTK8r9yt33XUh6hLn49fdQok2DcgHZNzgKuAD/ReC4pYJozAYgHhk6vW08/sQTePbvZwxwPYRUIMkeDdtYuOqxVaz81D82sq5Ru/p7KLEgnAFARJL+6N69uzRGSkpKJNvplEkOh5SBeEDKQCY5HJLtdEpJSUnU2rg+I0NagqwAkQDHCpBsp1PKyspEROSm0aNlksMRsK73KHI4pHDs2AbLmIp0+tM/pd3EV/yO+qK/hxILgNUSQrfWKxLYtiwbRKRTPQ1TnWiMI4B49Oh823gGyATuC1F/ksNBRUEBD86YkVTRsI2JWOXp0d9DiQUNTQd9SbBTwCwRadVA+SKiMRqAwjFjyAzja+6rkBvaRmtgBUSsQBrj1oeJJNYJ2vT3UGJBQw2AB1hEYE+gfBGJSyRwYzQA8ejR+baRDlQQOrLPV4FojzMy4pWZU38PJRY0NBfQeuABEfkwwI3PbahwqUw88s34tpGNteAbaXoDzR8UmninZNbfQ0kE4eIAbgJ2Bzn3+yjLklJkZ2WxNUydhuab8W1jEOE3XPZVIPGMhm1MJGoTFv09lEQQ0gCIyNsi8nmQc41rTibODBoyhDkOR8g6De3R+bYxDpgNESuQ6vxBTieTHA7cWFNEbqy1iYFOZ5PKH5To3bf091ASQigXIXt94BjgCPt1JnAHMAU4Nty10ToaoxtoWVmZZDudEbtlRqONEpBskCLb3fSA/XdiRkZQt9OysjIpHDtWWrtckp6WJq1dLikcO7ZBcjUmArly/vb+NxImT1P/PZToQkPdQI0xrwMjRORzY8xfgVbAZqCPiPw2dqbpEI1xERhin28mUBse4H7gOWAPcJTTybCrr2ZsYaH2Hm2C5eLv3/lYZgzqlgCJFCU2NGgR2E4FkQucY4wxWNtD/hXYC7SzM4J+ICLroyhzyuDNNzNz+nTyFiw4FAk8dCiroqSQg7VxzdChqvRrsWu/hy53/8uvfNRZJ3Bn//YJkEhREks4N9B2QCnWGmNLYDKQjxUH8Kz9epeIxNQvrbGOAJTk4POd+/j1/W/4lf/10s5cfvrxCZBIUeJDQzeF32qMeQh4FSsD6LX2VFBbYKcEWSBWlGTgv599z+WP+i+LP1XQk54ntkyARIqSXIRzA0VEHsGaBsoVkVfs4p3AVbEUTFHqy5I128gpWuan/N+0N2HxVf6afllpykS0J7CI7K31/qfYiKMo9WdyySYe/fenfuXr/ng+Rzr9XXJ90y+v8KZf3rOHOcXF9Jw3T9MvKylPvZPBhb2xMXOB/sC3ItLRLjsaeBrIAcqByyWCtNK6BqCEYkjxu7xTtsOvfMu9fXGkBx7kavplpSnQ0B3BGsITWJvJ+1IELBeRk4Dl9ntFqRe//MM/ySla5qf8P5t8IeVT+gVV/gAzpk3jWo8noPIH6AWM8niYOX169ARWlCQjZiMAAGNMDvCKzwjgY+AcEdlujDkWeFNETgl3Hx0BKL5EI0+PJl9TmgINTQbnvcklwFSsqGBjHyIirjrK01pEttuvvwZah2izACgAaNu2bR2bUVKRaDN9CDUAACAASURBVCZoi0eyPkVJdiIyAFjBXwNEZFO0GhYRMcYEHX6IyGPAY2CNAKLVrtL4iEVmzuysLLaGGQE0NFmfoiQ7ka4BfBMl5f+NPfWD/ffbKNyzXqj7X/ITywRtdUnWp8+KkqpEagBWG2OeNsZcZYy5xHvUo72lwHD79XDgpXrco8GUlpbSs3NnMouLWbFnDxUirNizh8ziYnp27kxpqX+eGCV+xCMzZ6Tplzt266bPipKyRLQIbIx5PECxiMg1Ia55EjgHa6+Sb4A/AS8Cz2BNr27FcgP9Plz70VwEVve/5CXem7CES9Y39aGHmDh+vD4rSqMlKm6gInJ1gCOo8revuUpEjhURh4i0EZE5IrJTRHqLyEkicm4kyj/aqPtf8pGoXPzeRHoVBQXkuVxkpqWR53JRUVDAqvXr2bB6tT4rSkoTLhncbSLyVzsfkF9FEbkhlsJ5ieYIQN3/kod49/jrij4rSmOnoW6g3oXflHHCV/e/xBIsF/9hGWl8ck9ypV3QZ0VJdcJlA33Z/jsvPuLEHnX/Swy7/+eh813+ufgHdPk5D111WgIkCo8+K0qqE8tUEElJPPbqVQ6xdedP5BQt81P+k/qeSvmUfkmr/EGfFSX1aXIGIFL3P+/m6Ur9WOneSU7RMn5z/5s1yucM70H5lH5c95u6e83E2x9fnxUl1YnIABhj8iIpawzk5uYyf8kSBjqdTHI4cAMerMW8SQ4HA51O5i9Zom599WTeinJyipZx1exVNcr/edPZlE/pR+9fBs3+EZJExG7os6KkOpHGAawVkW7hymJFLJLBud1uZk6fzuJae/XqPrp1x+12M+jht/jG4a/c19x5Li2zDm/w/RMZu6HPitJYCecFFM4NtBdwJnAT4Ovs7AJ+LyJdoiVoKDQbaPJy0u3L8FT5l1/x98uYm2aisqlK4ZgxZBYXc5/HE7TOJIeDioICHpwxo0FtKUoq0VAD8BusaN7rgVk+p/YAL4vIlijJGRI1AInF7XYzY9o0Fi9cWN0DzhzzZMC6n03tj7FfR6tnrv74ilI/Grop/FvAW8aYJ0Rka9SlU5Ke2tsm9p74SsB65VP7+5X5Rso2pGeu/viKEhtCLgIbY/5mv5xhjFla+4iDfHGnMWZ+jJXMbrebYfn5LN23j8U3vxBQ+e+d2p/lAZS/l1EeD4sXLGiQHNlZWYTrfag/vqLUnXBeQPPtvw8A0wIcKUVjzBIaS5lnTJvGEeOf4aoAir98an/Kp/ZnFDAzxD2C9czrYrTUH19RYoSIBD2w9u8FmBqqXqyP7t27S6wpKyuTbKdTVoBIgGMFSLbTKWVlZTGXJVJiKXO7ia8EPGq3UQbSOkj71eddrhr3LikpkWynUyY5HFIG4rHrTXI4JNvplJKSkrh9TkVJZYDVEkK3hhsBHGuMORMYaIw5zRjTzfeIsW2KK4nOElqfaZyGyhyozaCZOe0ef23aAjuwFmELsfb4TLf/FgL3Z2TU6Jn7Tivd5/GQi7UQlQvc5/GwdN8+huXn1/jc6o+vKDEilHUA8oFSLK+fN2odr4e6NppHPEYAxzRvLmUherLBerPRIFiPuCgjQ1wZGXJkZqakGSPHNG8uN40eXd3TbYjMtdsM1uOP5P5ZIE6QCfZ7r/wT7fI5c+ZUt3vT6NEyyeEIec8ih0MKx471k7msrEwKx46V1i6XpKelSWuXSwrHjtWev6IEgTAjgIgUMPCHSOrF6oiHAUgzRjxhlN0BkHRjqq8pKyuTm0aPlmOaNw+ooCMhkumNliCba02TzJkzRw4HOQYkzf57k13HT+a0tKBtBlP82U6njBg0KKyyvhnkCFvOSKZnEmloFaWpEc4ARLohzF+MMQONMQ/YR3C3j0ZKVkZGRJ4mWfZiZLQWXyOZxrkWeJSa0yTjR45kKLACqLD/ZgI9sYZsvjLX9o6JaHHX4yHNmLC5cGYDQ205g8nvOw2lLp2KkjxEmgpiMnAGsMguugp4T0Ruj6Fs1cQjEKzFYYcx2uNhcog6RcAsh4M1mzZFLTVBxEFOwNc+ZROx5sEfDNQ2sArLYPhGyAbLxQ/+fvzewKrHn3oq4LaJs4xhtv3srLHbCim/HaSlQV2KEj+isiUk0A84T0TmishcoA+QUqOA3R4PxRCytzsH2FNZGdUF44h7xLXKCoDFwdrGcs30ZqscfP14coqWBVT+IRd39+4Num3i7IwMnsdaHKpLj15dOhUleYh0BLAeOEfsPXyNMUcDb4pI5xjLB8RnBNDa5WLynj1MxFKgo+DQJuH2MRW43eVC7Okeby/WDczAUsg7gGwsi7k0K4sde/aEbbc+IwAP1pRPZZD63YHDczqSecUUv/NV333GG3PHN6gXnp6WRoUIx2FNP0V6r0QndlOUpkS0RgCTgfeNMU8YY+ZhjfrvjYaAycKgIUMoczhYhTWnnoelYPPs96uALXbP1LfXXoo1755Jzfn41sD+vXvDrgVE1CMGBtUq+xzL0ATi7a59aTHxFT/lf/1vcimf0o9LD9/Y4F64Nzp3ENbIKNJ7qUunoiQRoVaI7dGBAY4HjsWaXh4I/CzcddE86uoFVB/vnLoEG3k9WcpAsuvgAVPvdgN49xSBXG17/ng9gdpc+seAHj2lG76q92cNhteds77fgbp0KkrsIUpuoBsiqReroy4GoK5RpoGuLbKvPWBfW1TrWq/yuwlkUhiXxmA+7ZG0e5utXEsCKFWX7R46KYQr58df727wZw2GrxEpseUssu/hvdcEkJaZmWHvpShKbIiWAZgHnB5J3VgckRqAaPRsI+mZLl++XFzp6ZJJaB98r097q6yssCOS2u22dDrFlZ4u12Vk1FCqEzMypBnIkSEU/2uHOaVlZmbY3nSgz3rN4MEyYtCgiEZPvkZkOciNIK3s78QJckn//lHv0Ucj9kJRmgrRMgCbgYNYU7XrgQ3A+kiujcYRqQFoSJRppJSUlEjLzEy5xRgpwwrQutpWyAbk6FrG4ICtEOszIglmjIIp/oOYBn3O+oye4jmV05DRnaI0RaJlANoFOiK5NhpHpAYg1lGmZWVl0uKww6pHGN6pj0nUTIFQ5DN1450jr++IxJdIE7T5fs5Ie8zJnnAt2eVTlGQknAEItx9AM2PMTcCtWL7/X4rIVu8RnWXo6BGxT30Y18xgjB01ipEHDtALayg0DFgK3Ac1kppNtsuHAVOwImUDUTteIFhCuLomaPP9nJFGKyc6GV44kl0+RWmMhNsS8mksL723gb7AVhG5MU6yVRNpHECkPvWdgfVlZXVyNXS73XT6xS/YgKXkC7FcP+8Lcc1E4BHgfQgaM3A04HE4eHDWLCaOH8+1Hg8jPR7aAb8IsvvW/oevivhzvkbgNA21/e2TPUI32eVTlGSkoXEA7UVkiIg8ipUZ9OwoCVVujNlgjPnAGBO1CK9BQ4bwqDEh6xQDnY2pc09xxrRpVHAo6nUxMDLMNQXAYRxS/oFiBlZh9VzHjxzJJDtFcu+JrwRU/suvPZXyKf0iih2YZQydjUmZHD3JLp+iNEpCzQ8Ba0O9r+8BlAPZkdavixeQkzA+6SDLfdYBIp0jP6Z58xr++Gn2nH+o9YYDIOk+c/Lh/OVDzfH7LupGMh/utD9npOshyZ6lM9nlU5RkhAZmA+1ijNltH3uAzt7XxpjdMbRL9SI3N5f9WJFqk6BmlKldPh9rGLPDjtKNdI58x969NaJesyGi7KHN7dczsLJ6BuqR50x8JWRmTrB664/OnEl6WhpnnnYaeeecw4DMzKDRtPuBX4eRrzHl6El2+RSlURLKOsTqAD4D1mKllCgIUqcAWA2sbtu2bcQW75jmzWU5SCHWVoXp9t9Cn957GUjLrKw6eZV47+vtxUcSBDYxI0Nc6emyAitWoHYPti5ePd7RhK/r41HNmskl/fsHdMGsa4852b1skl0+RUlGiIYbaLQP4Dj77zHAOuDXoerXJRI4kliAiRkZctxRR8ktYRSk77TLTaNHS1FGRrXr53VYkbjhFNKcOXMk2+msMWUUTPFvgqCbvATae7e20qsxnYUVmxAsQK325xNpeHRwrEl2+RQl2UhKA1BDALgLuCVUnboYgEjnx10hFGO4HnIZ1oiiBTW3QgymkMrKyuTIww4P2eMvsQ3KLdSMKZhkG5zLODSK8c3/cyTI6R07Vhua2kFSEwmeTqIx5uhJdvkUJZlIOgMAHAE093m9AugT6pq6JoML1lOcmJEhTpBp1GER12c7Re99J/qkZ1gOcgZIJtZ2kV6FtHz5crlp9GhpfWy7oIrfq8iNbUjCGa3JBA48GxXB9S1BNoUwUJpeQVFSj3AGINJ00NGkNfCOMWYd8F9gmYj8M5oN9O3bl6dffpnXTj6ZzsDhWD7xC5s3Z2h6OjcT+SKu73aK3s1RDlx3XfXmKINcLvLGjmVDWRmVVVV8vWsX5/Xrx6Dxd/GCqx/Nhs30u+8jU/vz09T+1e6g4+0jlMvmWA4FmNUOPMuK4PoRQFcsP/mKggJWrV9P3759o7a1paIojY+INoRJNHXdEKa0tJRh+fk1gqq2Ym2S4t2+MJJALt/tFGvjdruZMW0aixcuZMfevWRnZTFoyBB+aD+QN7cd9KvfvOIn/vq3K7gKEOCfHFLYLbEsYbggpx7ADwHOtaZum7L4fgbdnEVRUpdwgWAZ8RQmHrjdbobl5/sptVxqbl84DisoawDBI2WLHQ5WFRb6nfM1MCtsA9Nx1OO8cFgzqKX8h615hT+/Nqv6/SVYCt/bphtLqbcjNG1t+QOxI8LrawdJ1SW9QiAjqChK4yblDEAwpVaKNRW0FcsY5GJt8dgHyz9/NIe2gHwYmB9kZ6raBiYnSLqGuc/exe8+9R+1LMPqrVfLC7h85ApGqB3AvNNZYa/3mc4CWLxwISs8nhBXWQYgb8ECNQCKkoKknAEIpNS8idsuwgrkug/LIEzE2tLwB6ytH3dgzad7gDNPP52TTz7Z7/5eAxMocAvgq4eHs2/PzqBf7HfAP4Cn7PaaAVf4yBWMh7H2GQ6EN0At1PWBgqQ0vYKiNG1SzgAEUmreKNyRWNM+pwFjsBZUg03/nPvWW3Q9+WT+Pns211xzTfWc/wuufnCzvyp2/3Ug6VJFa4L3xkux1h2cWKOAdlijkonAWYSejpqF/77AXuo7nZWdlcXWMAnWAo0cFEVJDRLhBRRTvJuV++JN3JaLlQpiFHA14b1uOlRVMX7kSAoLC+k9e7Ol/Gvx09T+PDK1P+lSBVhKujjAPb2jkNewvHm8XjzZ9t/5BE9hMQDIaNaMF51OVga4d65d71ygKCMj4o3WNb2CojRtUs4AeJWaG8vTpzXWtMuZ9vuTAQdwXZj7XAd8CrSa+AovHH6u33lvnh5v3n+3XT4OmA1+ijpYLiDv9E1frMygFVjTUZn23wogPyODkSNHMn/JEgY6nQHz/0x2OnlozpwaLqq1XT5rM27CBGY7HAGNChwaOYwNsBCuKErjJ+XcQN1uN906dCCjooLrsHr+XjfQOVjKeSdwgNDzX8EWdwNtwDIJS1E/aL+/PD2dV41hjDGM8nhoC/wcS8HXnm5xY03fhJqO8nXFdLvdzJw+ncULFhxyPx06lLGFhfVy1fR6NI3yeKpl/RxL8Rc7HMxfsiSg8VAUJfkJ5waakgbg9A4dWFZREXx+H3gZ+F2A83VR/NVtYvXWv+aQwn765Zd55fnnqxV1VVVVUKNTijWKGIk1Soi3Eo62UVEUJTlocgagcMwYMouLuS+Ee+MErEVY36mPYIr/86n9qxV37d28srGmcK4DOgK3hlDY4Xa0cmN58TwFVKSlqRJWFKXBNHRHsEbH4oULGRnGt30MsB7LAORMfCWg8l8+tT/5drqG+QTezWuF/f4sLAMRar493IJrLnCMw8F1Y8dSefAgX+/axYMzZqjyVxQlZqTcCCA9LY0KkZDz+x7gpAinelYC52O5a75M8Hn6PhkZrN28OajC1rQLiqLEmyY3AgjkBupLzsRXAip/3923fOkF/BK4htBuo6Mh5D7Dubm5Ib14grlqKoqixIqUMwCBplqE4FM9O6f2Z3mIBV6wti8L5zZ6bWUlixcsCFnHm020oqAgYldNRVGUWJFyU0But5tfderEy/v38ysMJ0582a/Oyd+V88jcccwyhodF+BuwEVgIfI+VnuEg1mYFw7BSN1QQ2m3UA2SmpVF50D8TqKIoSiJoclNAubm5nPXb39IXOCv/jzXO3fl6MeVT+/OvuePIBe4X4TXgJmAfhwKx1mMFjRngKw4lkQuFpkxQFKWxkXK5gABWvv02zwNPvl7MV7mnc37xaB7b+UXAur2wonc9HArSysVK1zDQPn4HPAI8EKJNTZmgKEpjI+WmgKCmJ1DEm6VgBXLVZhLwLfAclitoMA+eAZmZvLthgy7iKoqSNDS5KSCo6QkU8WYpQc6NwgrO2gP0Bs4AXueQB08RVh4fT1UVn3zySQMlVxRFiR8paQB8PYEi3vs3yLm2WOsCFcAG4Bys7JzNsEYNB7C2mfxnRQXD8vNxu90B7+N2uykcM4bWLhfpaWm0drkoHDMmaH1FUZRYk5IGwDfLpTfbZiiKCZ5r/3PgMOA4rDQQ12GldD4a+A9WArhcam6fWBvdeF1RlGQkJQ2Ab9DVXuAx/NMze1mJZQDGBjk/GyjgUNqHnsCPWFNDM2vVHeXx+MUC+G4heZ/HU70PQC5wn8fD0n37Qo4cFEVRYkVKGgA4FHRVNXgwe7EygN5Czc1WiuzySQReJF6JNXoYb5+/Dytt81BgC/AokI610Fxo37chG68riqLEk5Q1AF5cLhfNMjOpAt4GugLNgc7A/Vg+/ncD1+O/E9dArERwvsahFzAC+BIrXqB2Urjmhx9eo/1IktMFGjkoiqLEmpQ1AL7z7mv27+cDoBKowuqte5X3e1jZQZ/EMgqHYyn5CqzAsEDJGUZjpYeoMZ2DlSyuyuOpMZ2jG68ripKspKQBCDTv/iWwGf89eb1BX//E2ioSrOhf7+JuIIK5jfbCygl05UUXVRuBcMnpQKOIFUVJDClpAHzn3b17A1+E1XMPNRd/LZBFw9xGRwNlH31U7d0Ty43X1bVUUZSGkJIGwDvv7ruJSzMs5RyK67GmiW4PUy+U22hbrKAxr3fPgPz8mGy8rq6liqI0GBGJ+wH0AT4GyoCicPW7d+8udSHNGNkMkg2yAkRA0kA89utgxwGQdBAnyDNB6qyw71sW5HwZSGv7dZHDIYVjx0pJSYlkO51S5HBImd1OmX0+2+mUkpKSOn2+srIyyXY6qz9bQBmdTikrK6vTfRVFSS2A1RJCt8Z9BGCMScdyoe8LtAeuMsa0j2Yb2VlZTMWa0vFO+dQlIngclp//JGp6Bt1qDH3x9wzyxXd04PXuifY+AOpaqihKVAhlHWJxYOmnV33eTwImhbqmriOAm0aPliNr9dJvApkUZgRQBFJoX9fKft3aZ1RwzeDBclSzZqF73j7tHgBJT0urk+yRcEzz5kFHIDVGIi5X1NtWFKXxQLKNALCyKvjmZt5ml0WNcRMmsJuaSeDGYUX1RhIR3BZrY5gHsTKE3mpv1j5n4UIWPf88A51Ov6CyQHEDsfLuUddSRVGiQdIuAhtjCowxq40xq7/77rs6XZubm8tRmZk1pnxysZTzuVgRwKGUt6+XT+1FWu90zlsdOtADa4E5j8BxA7HaI0BdSxVFiQaJMABfAsf7vG9jl9VARB4TkR4i0qNVq1Z1bmTYiBEUZ9Tc76YvcDnwFpbSDqa8ZwP9CL5Ze25uLk+99BIZTidvY40SascN1Ne7JxJi6VqqKEoTItT8UCwOrPirT4ETsBJtrgM6hLqmrmsAIpanzFGHH+43X19Wyzso0Dy+E6RlVpYUjh0b0pMm2t49dfls6gWkKEo4SLY1ABGpxJqSfxXYBDwjIh/Foq2DQH9qevMA/BZrKmgCtaaC7B7/kpISduzZw4MzZoTc4Sva3j2R4pvtdJLDEfAz1B61KIqi1CYlt4QEKBwzhsziYkZ6PMwEFmOlb8jGctPsD9xuDJsdDvZWVpKdlcWgoUMZW1jYaBSn2+1m5vTpLF6wgB179zbKz6AoSuwItyVkyhqA1i4XK/bsCbsX8K+cTnb89FOD5FMURUlGmuSewBC5q+QP+/bVOXeO5uBRFCUVSFkDEKmrZHOoU8Ss5uBRFCVVSFkDMGjIEGaFqVMMXAoRb8ai2zsqipJKpKwBGDdhAg8TPvL3ViKPmNUcPIqipBIpawByc3NxZGYyAP+kbr6Rvw4ij5jV7R0VRUklUtYAAFw9YgSXZWRQQfDI37pEzGoOHkVRUomUNgDjJkxgyWGHcRlWuoZKaqZtqGu6Bs3BoyhKKpHSBiDaEbOag0dRlFQipQ0ARDddw7gJE2KyvaOiKEoiSEkDUDtQ68zTTkOqqvjP2rVUHjzI17t2hc3zEwjNwaMoSiqRcgYg1oFaiUoApyiKEm1SKheQ2+2mZ+fOLN23L6Cv/kpgoNPJqvXrtZeuKErK06RyAWmglqIoSuSklAHQQC1FUZTISSkDoIFaiqIokZNSBkADtRRFUSInpQyABmopiqJETkoZAA3UUhRFiZyUMgAaqKUoihI5KWUAQAO1FEVRIiWlAsEURVGUQzSpQDBFURQlctQAKIqiNFHUACiKojRRGsUagDHmOwgb4xWMbGBHFMWJNSpv7GlsMqu8saWxyQuRy9xORFoFO9koDEBDMMasDrUIkmyovLGnscms8saWxiYvRE9mnQJSFEVpoqgBUBRFaaI0BQPwWKIFqCMqb+xpbDKrvLGlsckLUZI55dcAFEVRlMA0hRGAoiiKEoCUMQDGmHJjzAZjzAfGGL+8EcbiH8aYMmPMemNMt0TIactyii2n99htjLmpVp1zjDG7fOr8Mc4yzjXGfGuM+dCn7GhjzP8ZY7bYf48Kcu1wu84WY8zwBMt8vzFms/2bv2CMaRHk2pDPTxzlvcsY86XP735hkGv7GGM+tp/nogTK+7SPrOXGmA+CXJuI7/d4Y8wbxpiNxpiPjDE32uVJ+RyHkDd2z7CIpMQBlAPZIc5fCJQCBugJvJtomW250oGvsfx1fcvPAV5JoFy/BroBH/qU/RUosl8XAVMDXHc08Kn99yj79VEJlPl8IMN+PTWQzJE8P3GU9y7glgieGTdwInAYsA5onwh5a52fBvwxib7fY4Fu9uvmwCdA+2R9jkPIG7NnOGVGABFwETBfLFYBLYwxxyZaKKA34BaR+ga6xQQR+Tfwfa3ii4B59ut5wMUBLr0A+D8R+V5EfgD+D+gTM0F9CCSziPxLRCrtt6uANvGQJRKCfMeRcAZQJiKfisgB4Cms3yamhJLXGGOAy4EnYy1HpIjIdhFZa7/eA2wCjiNJn+Ng8sbyGU4lAyDAv4wxa4wxBQHOHwd84fN+m12WaK4k+D9NL2PMOmNMqTGmQzyFCkJrEdluv/4aaB2gTrJ+zwDXYI0CAxHu+Ykn4+zh/twg0xPJ+B2fDXwjIluCnE/o92uMyQFOA96lETzHteT1JarPcEZ9BUxCzhKRL40xxwD/Z4zZbPdYkhZjzGHAQGBSgNNrsaaF9trzwC8CJ8VTvlCIiBhjGo0LmTHmDqASWBSkSrI8P48Af8H6Z/4L1rTKNQmQo65cRejef8K+X2NMFvAccJOI7LYGKxbJ+BzXltenPOrPcMqMAETkS/vvt8ALWMNkX74Ejvd538YuSyR9gbUi8k3tEyKyW0T22q9LAIcxJjveAtbiG++0mf332wB1ku57NsaMAPoDg8WeLK1NBM9PXBCRb0TkoIhUAbODyJFU37ExJgO4BHg6WJ1Efb/GGAeWMl0kIs/bxUn7HAeRN2bPcEoYAGPMEcaY5t7XWIsmH9aqthQYZix6Art8hoGJImivyRjzM3teFWPMGVi/1c44yhaIpYDXG2I48FKAOq8C5xtjjrKnL863yxKCMaYPcBswUET2BakTyfMTF2qtS/0+iBzvAScZY06wR5FXYv02ieJcYLOIbAt0MlHfr/3/MwfYJCIP+pxKyuc4mLwxfYZjuaodrwPLG2KdfXwE3GGXXw9cb782wEws74kNQI8Ey3wElkI/0qfMV95x9mdZh7Xwc2ac5XsS2I61rfI2YCTQElgObAFeA4626/YAin2uvQYos4+rEyxzGdZc7gf2Mcuu+3OgJNTzkyB5F9jP53osRXVsbXnt9xdieYm4EymvXf6E97n1qZsM3+9ZWFNp631+/wuT9TkOIW/MnmGNBFYURWmipMQUkKIoilJ31AAoiqI0UdQAKIqiNFHUACiKojRR1AAoiqI0UdQAKBFhjDloZxn80BjzrDHGGeX7jzDGzAhT5xxjzJk+7683xgyLphwB2rzfzsx4f4BzfY0xq+3sje8bY6bVlsv+XD+vY5vFxpj2dah/qjFmpTGmwhhzS61zYbOGmiDZMe2YmYAZdE2CMr4qUSYe/rh6NP4D2OvzehFwc5TvPwKYEabOXYTJlBmDz70LSA9Q3hHLB/9U+306MDpAvTeJccwJcAxwOnCv7/dDhFlDCZIdkyAZdElgxlc9onvoCECpD28DvwAwxtxsjwo+NPaeBsaYHGPlL19kjNlkjFniHTEYK2d5tv26hzHmzdo3N8YMMMa8a/eqXzPGtDZWcqzrgUJ7JHK2sXLn32Jf09UYs8ocypnu7cW+aYyZaoz5rzHmE2PM2QHaM3ZP/0Nj5VO/wi5fCmQBa7xlPtwG3CsimwHESt/wiH3dXcaYW4wx+VjBRYtsmfsZY170afc8Y8wLAeR50xjTw3691xhzr7GSAq4yxvglLhORb0XkPawALV8izRoaLDtmsAy6ATNlGmPSjTFP+HyPhQHaUpIINQBKnTBW3pe+wAZjTHfgauBXWD3Ea40xp9lVTwEeFpFfAruBMXVo5h2gp4ichqW0bhORcmAWMF1EuorI27WuznZosAAAAyBJREFUmQ9MFJHOWJG0f/I5lyEiZwA31Sr3cgnQFeiCldbgfmPMsSIyENhvt1c7z01HYE2oDyEiS4DVWPlbugIlwKnGmFZ2lauBuaHugRUxvkpEugD/Bq4NU9+XSDNaBsuOGez6YOVdsdIXdxSRTsDjdZBVSQBqAJRIyTTWbk+rgc+xcpacBbwgIj+Jlbjueay0wABfiMh/7NcL7bqR0gZ41RizAbgVCJkK2xhzJNBCRN6yi+ZhbV7ixZtUaw2QE+AWZwFP2r34b4C3sKZUooqICFaqhyHG2tWpF8FT+3o5ALxivw4mf9SwZaxveoBPgRONMQ8ZK3/N7nAXKIlFDYASKd6ecFcRGW9PKYSithLxvq/k0HPXLMi1D2GtB3QCrgtRL1Iq7L8HiV4K9I+A7vW47nFgCFYiwGfl0EYfwfDYShnqLn+kGS2DZccMdn3Acns6qAvWusf1QHEdZFUSgBoApSG8DVxsjHEaKwPh7+0ygLbGmF7260FY0zpgbVvnVZyXBrnvkRxSVL4eJnuwtsqrgYjsAn7wmd8fitWLr8vnuMKew26FNXr4b5hr7gduN8acDGCMSTPGXB+gXg2ZReQr4CvgTmI/RRI0a6gxZrIx5vd2vWDZMYNl0A2YKdNe20kTkefsz5ewfbeVyEilDWGUOCMia40xT3BIWRaLyPv2gu3HwFhjzFxgI9ZGJwB3A3OMMX/B6ikG4i7gWWPMD8DrwAl2+cvAEmPMRcD4WtcMB2bZi82fYs2vR8oLWNMx67BGKreJyNehLhCR9fai95N2m8KhqRpfnrDl2g/0EpH9WF5UrURkUx1kDIox5mdYU3MuoMqWq71Ym5+Mw1LY6cBcEfnIvqwTh1JITwGeMcaMBLZibe0I1pqFNxvlPuzvVES+t3+/9+x6f7bLugCPG2O8HctAGx0pSYRmA1Wijm0AXhGRjgkWJSkxVrzD+yIyJ4EyvCoiFySqfSU50BGAosQRY8wa4CdgQiLlUOWvgI4AFEVRmiy6CKwoitJEUQOgKIrSRFEDoCiK0kRRA6AoitJEUQOgKIrSRFEDoCiK0kT5f4PxFaBIRVLsAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# plot the linear fit\n", "plotData(X[:, 1], y)\n", @@ -620,9 +1055,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 50, + "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 +1087,44 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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 +1147,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# grid over which we will calculate J\n", "theta0_vals = np.linspace(-10, 10, 100)\n", @@ -730,9 +1224,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 53, + "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", @@ -1299,9 +1812,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From cfe3397a2cf4016fd5fa002b96b74fb1c5c41e95 Mon Sep 17 00:00:00 2001 From: GregHilston Date: Sun, 24 Nov 2019 15:07:08 -0700 Subject: [PATCH 2/4] Stopping work on exercise 1 --- Exercise1/exercise1.ipynb | 94 +++++++++++++++++++++++++++++---------- 1 file changed, 71 insertions(+), 23 deletions(-) diff --git a/Exercise1/exercise1.ipynb b/Exercise1/exercise1.ipynb index 4dfc9d7e..43693129 100755 --- a/Exercise1/exercise1.ipynb +++ b/Exercise1/exercise1.ipynb @@ -188,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -249,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -286,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -341,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -372,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -699,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -733,7 +733,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -794,7 +794,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -831,7 +831,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -903,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -979,7 +979,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -1015,7 +1015,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1055,7 +1055,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1087,7 +1087,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -1147,7 +1147,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -1224,7 +1224,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1286,7 +1286,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -1326,9 +1326,13 @@ " X_norm = X.copy()\n", " mu = np.zeros(X.shape[1])\n", " sigma = np.zeros(X.shape[1])\n", - "\n", + " \n", " # =========================== YOUR CODE HERE =====================\n", "\n", + " mu = np.mean(X)\n", + " sigma = np.std(X)\n", + " \n", + " X_norm = np.divide(np.subtract(X, mu), sigma)\n", " \n", " # ================================================================\n", " return X_norm, mu, sigma" @@ -1343,9 +1347,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computed mean: 1001.9255319148937\n", + "Computed standard deviation: 1143.0528202028345\n" + ] + } + ], "source": [ "# call featureNormalize on the loaded data\n", "X_norm, mu, sigma = featureNormalize(X)\n", @@ -1363,9 +1376,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise linear-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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[4] = featureNormalize\n", "grader.grade()" @@ -1380,7 +1428,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ From e7dca3a79c5af34d995c31b4c373f774086d4f1d Mon Sep 17 00:00:00 2001 From: GregHilston Date: Sun, 22 Dec 2019 15:12:32 -0700 Subject: [PATCH 3/4] Completed exercise 2 --- Exercise2/exercise2.ipynb | 342 +++++++++++++++++++++++++++++++++----- 1 file changed, 304 insertions(+), 38 deletions(-) diff --git a/Exercise2/exercise2.ipynb b/Exercise2/exercise2.ipynb index 39983d90..925e4f11 100755 --- a/Exercise2/exercise2.ipynb +++ b/Exercise2/exercise2.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "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,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)\n", "# add axes labels\n", @@ -202,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -234,7 +253,7 @@ "\n", " # ====================== YOUR CODE HERE ======================\n", "\n", - " \n", + " g = 1 / (1 + np.exp(-z))\n", "\n", " # =============================================================\n", " return g" @@ -249,9 +268,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "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", @@ -275,9 +302,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Login (email address): Gregory.Hilston@gmail.com\n", + "Token: HhQKuZGmcEDkp2wc\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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 +360,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -328,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -373,9 +435,10 @@ " grad = np.zeros(theta.shape)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - " \n", - " \n", + " eps = 1e-15\n", + " hThetaX = sigmoid(np.dot(X, theta))\n", + " J = - (np.dot(y, np.log(hThetaX)) + np.dot((1 - y), np.log(1 - hThetaX + eps))) / m\n", + " grad = np.dot(X.T, (hThetaX - y)) / m \n", " # =============================================================\n", " return J, grad" ] @@ -389,9 +452,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "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 +511,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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 +578,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "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 +641,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Plot Boundary\n", "utils.plotDecisionBoundary(plotData, theta, X, y)" @@ -530,7 +676,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -567,7 +713,16 @@ "\n", " # ====================== YOUR CODE HERE ======================\n", "\n", + " hThetaX = sigmoid(np.dot(X, theta))\n", " \n", + " arr = []\n", + " for h in hThetaX:\n", + " if (h > 0.5):\n", + " arr.append(1)\n", + " else:\n", + " arr.append(0)\n", + " \n", + " return np.array(arr)\n", " \n", " # ============================================================\n", " return p" @@ -582,9 +737,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "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 +775,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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 +831,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -654,9 +855,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)\n", "# Labels and Legend\n", @@ -686,7 +900,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -695,6 +909,35 @@ "X = utils.mapFeature(X[:, 0], X[:, 1])" ] }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plotData(X, y)\n", + "# Labels and Legend\n", + "pyplot.xlabel('Microchip Test 1')\n", + "pyplot.ylabel('Microchip Test 2')\n", + "\n", + "# Specified in plot order\n", + "pyplot.legend(['y = 1', 'y = 0'], loc='upper right')\n", + "pass" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -718,7 +961,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -768,7 +1011,17 @@ "\n", " # ===================== YOUR CODE HERE ======================\n", "\n", + " eps = 1e-15\n", + " \n", + " hThetaX = sigmoid(np.dot(X, theta))\n", + " \n", + " J = - (np.dot(y, np.log(hThetaX)) + np.dot((1 - y), np.log(1 - hThetaX + eps)) - \n", + " 1/2 * lam * np.sum(np.square(theta[1:]))) / m\n", " \n", + " # We're not regularizing the parameter θ0, replacing it with 0 \n", + " thetaNoZeroReg = np.insert(theta[1:], 0, 0)\n", + " \n", + " grad = (np.dot(X.T, (hThetaX - y)) + lambda_ * thetaNoZeroReg) / m \n", " \n", " # =============================================================\n", " return J, grad" @@ -783,9 +1036,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'lam' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;31m# Compute and display initial cost and gradient for regularized logistic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m# regression\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mcost\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcostFunctionReg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minitial_theta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlambda_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Cost at initial theta (zeros): {:.3f}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcost\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mcostFunctionReg\u001b[0;34m(theta, X, y, lambda_)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 51\u001b[0m J = - (np.dot(y, np.log(hThetaX)) + np.dot((1 - y), np.log(1 - hThetaX + eps)) - \n\u001b[0;32m---> 52\u001b[0;31m 1/2 * lam * np.sum(np.square(theta[1:]))) / m\n\u001b[0m\u001b[1;32m 53\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;31m# We're not regularizing the parameter θ0, replacing it with 0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'lam' is not defined" + ] + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(X.shape[1])\n", @@ -957,9 +1223,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From a42b44a443888151cdee03e6a913284ed8ea941b Mon Sep 17 00:00:00 2001 From: GregHilston Date: Sun, 22 Dec 2019 16:10:11 -0700 Subject: [PATCH 4/4] Finished exercise 3, not passing --- Exercise3/exercise3.ipynb | 315 +++++++++++++++++++++++++++++++++----- 1 file changed, 276 insertions(+), 39 deletions(-) diff --git a/Exercise3/exercise3.ipynb b/Exercise3/exercise3.ipynb index e37be91f..2d5ce99d 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": 2, "metadata": {}, "outputs": [], "source": [ @@ -132,9 +132,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAItCAYAAAAwm9DjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOyddbxU1bv/P97vJezuFkywRUVFRVTsDkzEAlssTGwxUMHuLkQsxO5C/VrYgthioNgS3vu7vz/u/Tzz2Z49Z87EnpkzfN7/8Lwezpmz1l5rr9n7yRn+53/+B8YYY4wxjch/1HoAxhhjjDFZ4QcdY4wxxjQsftAxxhhjTMPiBx1jjDHGNCx+0DHGGGNMw/Kfzf3n1KlTGzIlq127djMAwN9//92Q82vTps0MQOOvX6PPb9q0aQ05v7Zt23p+rRjOr9HPT69f64Trp9iiY4wxxpiGpVmLjjEmPzPMMEOqTP7f//t/1RyOaYa0tfL6GDN9YIuOMcYYYxqWqll09I3qP/7jPxL/AoBWaP7v//7vJjpTW/7zP3NbhW/C0+sb8b/+9S8AwJQpU0L3xx9/hMzrMtdcc4UuzeKTBfn+jt5r/BnVKRw/70Ogdd6Lei3+67/+K+SpU6cCAGacccbUnzXGNBa26BhjjDGmYfGDjjHGGGMalkxdV2oa//vvv0OeMGECAGDMmDGhW3LJJUNeYoklAACzzjpr6NS0rCb1ekHHR9dGPugGqMd5KLpmzz77bMhLL700AGDhhRcOna51a3dppbl2dE4ffPABAOD8888P3RNPPBHyRhttBAC44YYbmnxmVvDz1cWkY544cWLIP/zwAwDgiy++CF27du1CXmyxxQAk70l1XbYWN5au3+jRo0O+5557AAAXXnhh6Frj/JRGDA3IF+yfdr7qXue86v0c0vXROdHNWu/r05qwRccYY4wxDYsfdIwxxhjTsFTcdaUmuJdeeinkSy65JOSPPvoIQM4FACTN5B07dgQALLjggqHr3bt3yF27dgWQP2ukWuhcf/rpp5BHjBjR5Gc166NLly4AgNVXXz10aW6SWpsudX4ffvhhyKeddhqApOuqf//+IXN+Sq3nUgid67Rp0wAk5/zwww+HfP311wMAvv7669Cpm3WbbbZp8plZzF/N+dwzV199dehefvnlkHWsX375JYDkntX9N9988wEADjjggNAdeeSRIXNe9b6mOr6PP/44ZK5va8204rh1/H/99VfI7733HgDg5ptvDh3PTADYaaedACTdlbVey7S9/Oeff4ZOwxxuvfVWAMmsx7XWWivkzTffHEAuBAKor/lR/uSTT0Knbu4jjjgCALDQQguFLs0Np7q061cr0r6XixkT10o/p5AbttC9bIuOMcYYYxqWGZp70i23l9C1114b8uGHHx7ybLPNBgDYbbfdQrfHHnuE/OOPPwLIBQ0CwKOPPhryAw88AABYc801Q1fME2M5va70LV0DPA888MCQR44cCSD/W8Scc84JADjhhBNCt/XWW4dMi1apT+lZ97ri+owaNSp0V111VchbbLEFAOD4448PXdu2bUMu9+2qUr2u9PqqxWPIkCEAktYRrYnTuXNnAMm98Pbbb4fcoUMHAMkA5WKCXVva6yotQH/77bcPnd4z+nbbq1cvAMm3fCYIAMDQoUMBAL/++mvoeM8BOUukWimLIeteUGmVj7fddtuQd9xxRwDAfvvtF7pS55JGS+en61doT6QFG7/xxhuho5UGAOaee+4mv68WrWeeeQZA0vJazPyz6JWk8+e5f9xxx4VOEyPmn39+AMC8884bOr3/OP8XX3wxdHr/FrrWlep1lc8iwXH17ds3dLSyAsCuu+4KIPmdye8MAPj+++8BJNd/mWWWCXndddcNOc36Ws766eek7Ukdn+rS9mQ++Htqpfzmm29CnmOOOZr9XPe6MsYYY8x0hR90jDHGGNOwZFpHZ9999w15qaWWCpl1PNRdo6Y5mq40GPn2228P+fPPPweQdF1lDU2A6q7q169fyE8++WTI++yzD4BksPHkyZNDpslRXSN0lwC5wE81rau5rtb1d2gy1vGtt956IdM1QBMzkLxWtQ4MJGp6veCCC0KmG26HHXYI3dFHHx1yp06dACTXVF1GM888c5PPzxr+LQ3aX2eddULu2bNnyGnB4gzQBYB33nkHQC7oEwC++uqrkNdYY40KjDh7NJhV70/u21okM6QFUgI512Y+14DqH3vsMQDAYYcdFrq99947ZN5r6lrVwHK2wKg1Or4777wz5NNPP73Jz952220hr7jiigByIRBAcn15fj744IOh69OnT8hZnj+6Zj///HPI9913X8gMEqeLBwAWWGCBkLm+jz/+eOhmmmmmkHmvfvvtt6HbfffdQ1aXdKGabsWSVu8HSLq2Bw4cCAA45ZRTQkd3HFD4+rO+Fz8HAB566KGQNUxk0KBBAAqHdtiiY4wxxpiGxQ86xhhjjGlYMnVdqZlr0003DZkmWzUdqxn3s88+AwCceuqpoVt11VVD7tatW+UHm4KOjxko6q556qmnQr7ppptCZoaHZhqpaY2mYzX9aYuFY489FgBw//33h46ZMACwyiqrhFwLNxD/po5/2WWXDfnyyy8HkMy60wyDekGvndYB4hrTRQUkO11zr6o5mrVLAODcc88FkH0dnTQ3h7rbFN3LXDcd37vvvhvyvffeCyBXTwdIup5rXaejELwW48ePD12tx8zrz4xFIJf9BORcn/n2jLoRBwwYACBZ20gzlHjufPrpp6H797//HbLWz6k2ug+1Ns6JJ54YMven1pbZeOONQ+Z1UTcR25YAOTe/urM0q7dNmzZNPqtc0mobsd4WkHTDsD7OeeedFzq9b+lyfeutt0JHd7J+rmYc6e/n+94pB66b1v4ZPHhwyMOGDQuZbsKtttoqdOrm//333wEAr776aug0Q5SuO3WX6zx0fi0ef9G/YYwxxhjTSvCDjjHGGGMalkxdV/m6z9IMpt2TNUL+uuuuAwC0b98+dHSHALkI9SzM0TpOzUQ566yzACQj4WlCBpJZNzQ/qztOP5emY50f2wYAwEorrQQgmcmkUeta2n+eeeYBUHvTfFpxQy3RXo+o2VpbkNDMqlkRWrCMGQDqWmXZeSCXAVFMQbhKkS/TK83Npfv7iiuuCJmm8/333z90K6ywQsi13muF4Px0/+Xr6l4t+De1cB2zExV17WgLkmOOOSZkhgFoQTl1efHc0f35yy+/hKznTrXgvCZNmhQ6db3pWcmsx4022ij1//lZr732WuiOOuqokOnm0Xu6Fmuubkp1F7KQqmaC6X1L19uiiy4aOt2/XEt1DfXo0SP1Z4tFfzctdGPnnXcO3fvvvx+yZo2xOKmGLjz//PMhv/LKKwCS56u6o5iBqNdk/fXXD/nQQw9NHW9z2KJjjDHGmIal4hYdfQrTpoEamMVgYw3A1RL8RJ9S9emcfyOLt2R9imW9HyDX1kGDovWNSkv8p9W5SRtrvrdMBtZdeeWVodM6CQzWAoA999wz31QyR+fJRq0AcPbZZwNIjrkW1o1C6JjUYsPaDMOHDw+dvjEzSE4DAPk7ADDLLLMAqM1bZL46LDp+zlXfuLQORlpNF70+fDutl3X8J5z366+/Hjq9P/nGXI/j1zXTYGo9lw466CAAyToyuj5s9/DCCy+ETu/VSra7aCmclwZF6/jYyBLIWUfztcChdYD1yoDkWc39qedPWjJBJUnbS3vttVfI2qKDdYDynf9ca63Do8ku/H+1IlcqwFqvue4TBk5r0oWeKXr9WXNM/1+tiLRUaYLKd999F/I111wDIFknjzog2fqjpWesLTrGGGOMaVj8oGOMMcaYhqVqrqs77rgjZJpctTaCBhsxiPD8888PHc21QM7kPvvss4euUm4CHb8G8P32228Acp2pgaQ5NAszuAbjaQl/dQNm6brSa6GBnXRNaTCgBlnSdLnJJpuErtYBrIXcneoaoJtUA+/UXMpgeTXNsjYGUBvXAEnraA4A48aNC5ntVDgPILk+vK/0/xn0DgCHHHJIk79VT24gjkWTHRZZZJGQl156aQC135Np6JhWW221kPWsYZ0tbbGj3a/ZYkDdCWeeeWbInTt3BlDdVjK8J5544onQ6ZpoHR3uqz/++CN02i6H3wva4oPuYiDnGtLabdVaa70PtA5XmhuuUCdwrZ2m12277bYDkL9mVjmoi3f06NEhX3zxxQCSNdx4nYHkdzFDL9Zee+3QaehJ2vmiNXn4vcF9DCRrepWylrboGGOMMaZh8YOOMcYYYxqWiruu1KzUsWPHkFlWHsi5ObQjt7oOKGtHczXT0iSrv18p8rlr/vrrr2Z/tpRO1fl+ny4R7TKsWWl6XbJEx6RmYpqO1YWmGQ40f9a6y7ruKa6l1mvIZzpmfYt8LUroBlLTrprZ6WaohTtH3WmPPPJIyJrhQDesZkKom+7ggw8GkHQXaDl+1n9ZeOGFQ1dPa02Xs5aYX2uttUJecMEFAdSn60r3jLpLtaM3XfeXXnpp6DRDh+ejnr+1vj85L2bcAsmaOqeddlrIzCZS1/hll10WMutc0QUHAGeccUbIzIzV2jW1uBcL7S+9V/V85fqq60ZDJngva6ZVpfayXid1V7OOm+5DrfOjc0n7LtQWEHRTaaaqhrFwrct1Vym26BhjjDGmYalaZWR9u+BToz6lpVUR1sqt+sRLfSlWlELomPSJdZlllgGQbH7ICo9AsopxoaZjnL8+Pev8WFOAQZ9AsqaGWseyfFPRa6FWpJNOOglA0mKwyy67hKxv19VG3yzefPPNkBnAqRWoDzzwwJD17S/t7UHrlNB6o2/ctX57TLsXNBh11llnDXnLLbcEABxwwAGh08DCmWaaqclnapVXWjezuP9KRffcxIkTAQDffPNN6DbYYIOQuVa1DBrPh+4d3ctak4X3mr4l9+7dO2RWb1eLXL1Y39Zdd92Q9Z7ROk48d7VyLhtBAsD8888PALjkkktCp4GvvH/ryWKXFmysyS5aE4jr16VLl9BpYg6tk1nMT/eGfmdzL+U7JwvtKe1swIrd2pxb9yqrLFdyn9qiY4wxxpiGxQ86xhhjjGlYMnVdKYXMUGqmpelZg12Zmw/k8vCzcBHoOGkiBXKBf1q3Rht57r333iGvvPLKAJLuADUzs0S76u6+++6Q2SxNaxawkSQArLHGGiFXy02i68NmfBrAeu6554Y8cODAqoxJoWlY12/UqFEhM5hbXWz53E38LHWHqLuQMuvRAIVbgGQNx69/W/eqrhWDGHX+Ote3334bQLLRLl23QH22UFDXAM8PDXZVN3RrIV+wPIPddf89+eSTIfMs0hL6tYbj11YP+VqMsP6auu71Z9ngVOen+75e9mW+ZBO2y7ngggtCp4kNDPxlI2mgeq7HfHuO4Rjqrsr3s5T1O+24444LmYHHt956a+g08DiL+dmiY4wxxpiGxQ86xhhjjGlYKu66ypfJkJaJpOZyNTMzQ+add94J3V133RUy62Bk7SJQMx3NpFqKW+scaNQ4XW6MHgeSGWTMYNH/VzcYTZrLL7986DTrqRaukbQWAdpRVjvpMpq+e/fuoauFOVndSXS9acdndcfp+LiH1V2lplfOq0ePHqGrlwyPfFk7M888c+rPEM0AYadi1W222WYh03VV6zmruVxrTt1zzz0AknWwNNun1uNuKfm6z7MDuLZN0HYr55xzDoDkmVvrOadl6KlO9yddHup61vmxE3i+7ua1RL/TdEysjQPkwiC++uqr0PXr1y9kuuY0q7NaZ36+TMq0TOF8rrn77rsPQDKrdZ111gmZGVjVnJ8tOsYYY4xpWGZo7k176tSpRb+GDxkyJGQG1QLAhRdeGDKDIbURHRtBArlgyBtvvDF0+kZZ7tNfu3btZgCAv//+u+j56ZuVPrFrnRFab/JdWz79aiM6rXPCv6G/X8wbS5s2bWYASlu/YtBg1uHDh4d8+OGHA0jWHKpkA1auX9r89I1KA/xYGbZr166hYwVgILmn2IBW9x/fIoFc/Q6tHFrJN0rOb9q0ac2uX9obv+6ZQg1MNQBUm+qxaavWJtGmvHwTK/U+bNu2bYvmVwhda1Z7BoDVV18dQLLy8xtvvBEyz5+srIxZzE9rAm2xxRYAkrW3XnjhhZDZYDart2TOr5TzU9H5TZgwIWTea99++23oHn744ZBp6c7KisPzs5j1457SCvb6nXb//feHzMSaQw89NHRq0Um7lytJKevHsRSy4gC5YPhll102dFonic1cs14/xRYdY4wxxjQsftAxxhhjTMNSsWBkmrFWW2210Kkba4899giZdSC0aZu6bu68804AwPrrrx+6WjcNJPnGoYFVLSWfm6Fe5poPmpzHjBkTumHDhoXMcvvqOqhWMLKaQ9X1wgBHBmoCyWDitGZ2DIoHgP79+4dcruumHNRcrH+f7S40aF1dowrrlGiAvzaIZP0orfOhdS7qsXWCukF4vmiAvAam10udlTR0HuoO15oyH3zwAQDglltuCR0TNID6Pz+IrsPLL78cMt2MuifVDVIvgcc6fn6XaT0xTVzR+l0MNu7UqVPBz60X0oKUn3vuuZDV9cZz97rrrgsd3VVAbdbPFh1jjDHGNCx+0DHGGGNMw1LxrCs1cX3yySch0x0F5LJxtM7DGWecEXKHDh0AZGfiKifrqjWQRdaVmtRfffVVAMlMOq2TwE7KrLcCVNYc21zWVT6YycDO20CuC3m+n9WaO+r6yNr02lzWla6D1ok5+eSTASRrc9CF80/YekQzXZipAwDHH388gKQbOl/p91KoVFaSomNip2tmwgD5r0UWlDM/3WdaR2bbbbcNmS0CLrvsstBVMquxEOVkXen+ZSscIFlzZemllwaQ7NitLtmsXTvNZV3p+LWjOsfPGk5A7j4CgJNOOilk7sVK3lPFUE7W1SOPPBK6Pn36hKztktg6ht/jQHXdqc66MsYYY8x0hR90jDHGGNOwVNx1paiZrxiq5Rqw66o88hWPSisXXklKcV2RfGNOoyXF97KgpQUDFd5rxYyzmPWr5PyzcF0paedONTM9ypmfFiQdO3ZsyGz7AOQyePK1MMmaSrmuxo8fH7J2X6dLRF2P1ZxfSwsG6lzGjRsHIFkYsFevXiEvvvjiIdc6a7GU9WOLlREjRoTu119/DVnb/aywwgoAapcdZ9eVMcYYY6YrMrXo1Cu26LRuyrHotAZKsei0JrK26NSaSs1PLTZqPaBFoFb1VrJoAaFz1dYktaCUFhAcv85DLTf1UvsHaPn6pTXw1GD5fDW9KBeymGeFLTrGGGOMma7wg44xxhhjGpZmXVfGGGOMMa0ZW3SMMcYY07A029Sz0YN1HQzZOvH8Wjec35QpUxpyfu3bt58ukh0afX862aF1wvVTbNExxhhjTMPSrEXHGNO6yFcEsJjiiPWUCmtaRtpaex2N+V9s0THGGGNMw2KLjimZQtaDQv9frwW1Wgt6TVnIi6XagWR35ULdg2eeeeaQ2V25Vi0wTMvQ9dd1nzZtGgBglllmqfqYKgELCWpxOp8VrQfuy3wFL4meKXo+ZbG+tugYY4wxpmHxg44xxhhjGpaKu67SuiCX8xnlflYtKOS6aU7XEtS0V0szrv7tn3/+OWT2qlHXyYQJE5r87Lrrrhu6eeedN+R6WetS1yfL8euY9Pq/8sorAIBhw4aFbvjw4SHrWqSZkddbb72Qzz77bABA586dQ1fI9VWP6DxVTgvWbU3zS9uXQ4YMCZmdwB988MHQzTTTTCHXo+tH3Rw//PADAGD06NGh22CDDUKeddZZqzcw0yLSerG99957oRs7dmyTn11ooYVC16FDh5DnnntuAJU9R23RMcYYY0zD4gcdY4wxxjQsFXddqVlUzZHFuG6YNaCkmdvrCTWzffvttwCS7pyvvvoq5ClTpgBImvOoA9Kvi5rWN95445Dpcqimu4fr+vzzz4futNNOC5kZPJ988knovvvuu5DpRqGJHQDmn3/+kGvhRtBrzr2Wz7VBvf5OWoZBFllL+ndeeOGFkHfaaScAQM+ePUPXpUuXkN98880m49M998wzz4S85557Aki6vjp27BhyPbo+0tD76/bbbw/5ww8/BAAccsghoVPXXakuy2qje1L3wmyzzQag/uehZ/rkyZNDvuyyywAA55xzTug233zzkC+66CIAwLLLLhs6usurSdr1LeZ7qtCZoP+fFhJSCxd/vj2l5/uFF14IALjrrrtS/5/MNddcIXfq1CnkSy65BEDSdV7umVPfTw/GGGOMMWVQlkVHn14//fRTAMA111wTOn0iY4ARALRv3x4AsNhii6V+1qmnngog+ZY/ePDgkOslcFDfrvWNuHfv3gCAv/76K3SsTQIA7dq1AwC0adMmdHPOOWfIqidaJ0Ofqrt16wYg+6d7netPP/0EADjxxBNDt/3224fMwLI///wzdOPGjQv54osvBgAsuuiioav124nuv++//x4AcOedd4buqaeeCpmBv7qmO++8c8j9+vUDkAywKzdIn7+v1s4xY8aEfM899wBIWib0LUj/Ji057777buhOPvnkkN944w0ASYvd0ksvXfSYq4nuz5dffhkAsNtuu4UuLfB9wIABodPA3fnmmw9A67FcAcmzhmdJPVp0dExqhenbt2/Ir7/+OoDk+fLII4+EfOaZZzb5f7XuZLlu+e5jyl9//XXo9BzXMfHc0PMjzROif0utr7TY6ZmV9XdiWgD/5ZdfHjKtbAAwadKkxO8AyblSr99pPFMB4IQTTgAA3H///aHTuZZyftqiY4wxxpiGxQ86xhhjjGlYKhaMzNoG77//fugYVAQkTe40Q80zzzyhUzPXr7/+CiDnAqhX1DUzaNCgkBdccEEAwMCBA0OnNQPouqILD0jWhtDS50TNdVquv1pmWjWN3nLLLQCStTn233//kGk6V9Pk3nvvHTLnusACC4SuFq4rNYfqvt1vv/0A5EzoANC9e/eQGayr7sYLLrggZP6eBlura6UUeH10zEcccUST/29JMgD3n7pz6K7Rn613141ei19++SXkQw89FEDSncjaQEDuvqOLGUhPgKh3NIBX61TpWVNv6JrRRQoAjz/+eMh9+vQBkExwUDc3973u6ZtvvrniY1U4bq1Hdf7554fM76zHHnssdNqCQ8/ChRdeOPEvkFxLulbV9aWJHRtttBEAYNtttw2dhoFkAc+SL7/8MnQ6f7qrgNz5oufPlltuGTL36muvvdbkd1TPawokz9pSsEXHGGOMMQ2LH3SMMcYY07CU5bpS0zbNbXfccUfoNHdea8rw99SMqVk5xx9/PIBk2e9aw7EyIwcADjjggJDVzLbrrrsCSI5/9tlnDzktQr4Y1021ukqraZiZVkDOzXHvvfeGTt1pHNOtt94aOs2aYJsC/Z1qZdKpW1BLzHPNgJxr48UXXwzdyiuvHHLbtm0BAEOHDg2drgPNtOW6qwqhHZ3T0Lmmdbc+/fTTQ/foo4+GTNfiaqutFrp6acuRD83K5LyZvQEksz7oftD9pzU96n2uvC//+OOP0P34448h0+VRT1lXvBcmTpwYujPOOCNkDQOgm0LvH9YmA3L3XzVr5/Ba6pmnmUYcq7pgdE30u46uG800SssA1TNRs66YAcpMSyD5vaturEqdq/wcdYtqOML1118fMvelzll/jxmc6rpM62Sutb822WSTJv9fDLboGGOMMaZh8YOOMcYYYxqWimVd0R2l2UMsbJQPNW0tv/zyId94440Aku6eWkPT4meffRY6dcdohgCLX6lpXM2s9W4aJ+qaVNP+7rvv3uRn1czMQnRHHXVU6NiiAAB69OjR5POzJs2M/8QTT4SspvOHHnoIALDSSiul/v7HH38MALj00ktDxzkBwMEHH9zkd7KeK/+W7i3tHqzFvVjckl2i/wnXTVtI1EuRznxo8cTtttsOQDKrT7Oq7r77bgDJs6reu3unoa5LlVk8T7N2an3mcH9qYcPx48eHzNAHIJdVpO4abeFRC9cc94S2oshX0K5c0rIe1TX0wAMPAEiGUWjWVhbXhftH3eEs7AsAvXr1CpkhAXrmXHnllSGzeLB+ln4/8izWcIly52SLjjHGGGMalkybehaD1sH45ptvACRbQNQazmuFFVYI3eGHHx7yVVddFTJrQmy22Wah22effULmvNQKom9c9f5GmVazRVskHHnkkQCANdZYI3Qs2w7knuRrYSXQNwe1aKj1cIkllgCQfEvTN1E2G9Q9e9JJJ4XM+hnVXEfuJbU46v777bffQmYwp85P3/65lloHRIO155hjDgDJ9au1xUDrbIwcORJAbp5A8rrw/7U5bmuCa816VkDSIsn6ZHq+1OOZouNTmYHjt912W+g08DrN4pH1/uPna70pbaBbSXgt9J7VdjS03vE+BJIWySyvhX623l+rrrpqyAw2HjVqVOi0DhBr7uhn6VnD79IddtghdOV+V9iiY4wxxpiGxQ86xhhjjGlYKu66KgY1XT388MMh08ylLRJqDceqAYznnntuyBqMxZoGGuyqJcpZep9Bq0AyGJtmyHoyN6tpmZ3qtaw+AzyB3Pw0WFfrKBSq/5IFXD910TDoEcgFwAPAscceCwDYY489QqedvFm/Yscddwyd1pzhulXTncO/pfeMtljRmh6ss6Huui+++CLkp59+GgDw0ksvhU7rh7DdhQZr13JNdUwAcO211wJIBrtqTScGJi+++OJZD7FipLVjYVA8kAzs5L2Wr9N2LUmrlwKku4G1do66jnkPs0s9AAwfPjxkTXxI+7vloGdyJc9ndSMzCLt///6hY+0xAOjQoQOA5Jml7SSqFRKg+0vXj99rzz77bOjUzUX0+mniAM9lrUlU7vlii44xxhhjGhY/6BhjjDGmYakb11VaBH09uW6IjlndOVpzZK211gKQ7HSr5axpWtfus9ouglk9alqvxbVQc6pmdbDOitYROvDAA0NmawHWSwBq49pIQ826W2+9dcjaaZ5deW+66abQ6bVgtoO2GFDXQS2yybg/tB6JZuXQ3Qjk6qxopoO2a2HWoNbB0HYZdNlp2Xnd/9Vaa70XNRtmwIABAJLmdHW9MatOXYxaG/gAACAASURBVMf1jroJeK6oa0fXna6renFXAen7Uztaq2vxhRdeAJC859SNTDfsgw8+GLrXX389ZGbrVLK2TRbo94dmgLImm2Zaafd2uqw6d+4culp8P+jf1HYevNf0+uv4eT6qu1zh+VHJ/VvfO8EYY4wxpgxqatFR9C2QwVZaJ6Ce3k7SSAtS08rI66+/fshrr702AODrr78O3W677RbyWWedBSBZTbJabydpzeUA4MknnwyZlYMPPfTQ0NEKBeSsG1rZtF6qtOrf1vlp4F/v3r0BJC02ah3p168fgFy9CKD21kfOS+ekwcKrrLJKyGnB0toIkIHVW221VejUusM3TX3LHjFiRMgrrrhiyNWy7qRZhNUKqXvxmGOOAZC0AtWLxTEfel+ygbCeH127dg2Z617rPalwLFrvRWtrabAqg8jXWWed0B122GEhDxkyBEDSoqMWc1ryNBi/nip783zURtdq3XrnnXcAJK+VWpyZ7KF7tlpnqp7jrNAMJOvI8Qzad999Q6f153Tdq4UtOsYYY4xpWPygY4wxxpiGpW5cV2p6o8kxLfe+NaGmY3UpsNaJBrBqTZOxY8cCqK6Lh6ZxNfFqAKq2u+D4aWIFkk1NGWS2yCKLhI7uOCBXH6HW7kj9+2qSpctUG0EuuOCCIe+8884AksGEtXZ9cP3efvvt0GkJdtYGAnImcV1rlflZ6u7SmlFcX3Vnaon3lVdeucRZVAbuLw1Q1WDIDTfcEEDt918xqOuKDUy/+uqr0GkyAM9NbXdSL+iZqK6Z8847r9nf03stTac1hXh+quuqFuRrRMl2JOru1wa8PDcHDx4cum222SbkLIJ1C5HWlFUD/KdOnRryIYccAgAYNGhQ6E488cSQ6XpNW9OssEXHGGOMMQ2LH3SMMcYY07DUjetKzXw0j9U6ayAtUl9dUPlMkxy3jp8d2YFcnZLLLrssdFrH5JJLLgGQdG1lbabkXFjDAgD22muvkLUmEHnrrbdC1nLdzEbSOibqBtKfrRd0XZnBoVkde+65Z8jLLLMMgNpncuj+41678MILQ3fXXXeF/MEHH4S8+uqrAwDWXHPN0HXs2DFk1j/S+WnNC8rq7qumGToNXb+ffvoJQPL+2m677UJmHZ1ar18hdH3VNcrWHHo+0J0K1P+8SL52EIV+dpdddgGQbDHw6quvhnz99dcDSHbU1jOnFi5LnR/Pd23hoBmcbBektamq2ak9Dd7fmumnrnGtj7T33nsDyHWhB5LXP+17M+s9a4uOMcYYYxqWurHo6BvZ+++/DwCYNGlS6GabbbaqjEPfkvQtgcG2Sy21VOi0cvFvv/0WMt+eNVhX58KKtPrEfsMNN4TMN+5qWXGA3BO1BshpI0itcswqzscdd1zotHYKPzdfMHa9BIHq/LXOCiv+qpXioIMOCpn6Wr85p9UE0qBxBj0Cyaar999/P4BknSp94+Jn6eerRY57mfsUSNY8qXVgNu+liRMnho7VvIHaW4pbiu7PCRMmhMyK3Qz6BJJNHevl/qokuma0yGkA83rrrRcy63zpntx///1DrsX+1CrrrEOlyTYauEtLq54vtV5TXv+55pordNrI+KmnngqZZ5Be/++//z5kWnq0jpB+F84555wAXBnZGGOMMaZF+EHHGGOMMQ1LTV1X6s7Qmis0WdU6aEyD2Y4++mgAyQAyNdextgwAdOrUCUCyRP6SSy4Z8hprrAEgGQCq7SKq5RJR0zhNi+PGjQudtgVggB+Quy465jTU9VNr02sauv/UjEo3j5pT2QgTqE/XB68v24sAwH333RcyA1iBXBD5sGHDQqcNInkvqmuL7mQA2GyzzQAky9JrzZJquQZ0f7322mshs10Fm7MCOXM4UJ/rl0Za7Rwg56bStiW6l2vtUs0arp+eTz179gyZzYY1XKBapCUIAMkGnQyW79WrV+i03QrXr57OTM5FzwRt+6BNPYcPHw4gGfqh9yqvkTa1Pvnkk0Pmd2kl71NbdIwxxhjTsPhBxxhjjDENywzNmcf+/vvvTG1nmuGkpnFGc2vtD812Ktc026ZNmxkAYNq0ac3OL62T9+TJk0OnmSj6s6wvonVGdK5p7RYqaaZs27Zti+an5kTWzzn99NNDp5kAa621Vsgcd61cAC2dXyF0/tdee23IzLDSjuW77757yGndvytJFvNT1wbLtf/xxx+h03YBzAbR39d9z6xBdV0W467i/KZMmVL0/NLqbQHARhttFDKzPdR1Vc2aVO3bt58BKP/81LlqiX1ea22hUE1aen5mje5prUM2YMAAAED37t1Dp520C+1V7s+pU6eWtT/1fNQMpPnmmw8AcN1114Vu/vnnT/29LGjXrl3FzxfNWmW2p2aaaTshuqz69u0bOp4pQPnf71w/xRYdY4wxxjQsftAxxhhjTMNSU9eVmh61xQA7tWpU93LLLRdytVxXaahpMl8LiFpmjQGluT44l3yF/eopU6Uc146umc5P2yHQ5aglzrVgYtZZLZVyXeWD1yDfXk7bt2n/X+qeqJTritkrADBixIiQ2SKgVplWlXJdKWlrVat7sl5cV0paa55Sz69Kua7UnbPJJpuEfMoppwBIZlqpazJrKuW6UtLCPAqR1feLXVfGGGOMma6oqUUnMRB5ImRND83Z1wZh5VpK6vGNpJJkbRGoNZWy6OhbxPjx40OeffbZAVQ3QFCZXtavFIuOomupwcYMNq2VRTULi049Mb2cn5UMRj7ssMNCZmD/FVdcETr9fmstwcj1ii06xhhjjJmu8IOOMcYYYxqWZl1XxhhjjDGtmWZ7XZXrQ69X6EMvxQfbGqAPttFjBCZPntyQ85txxhmni/Vr9Pk1egyEvx9aJ47RMcYYY4xpIGravdwYY0xxpNVB0hCERgxHKFSbJS3bqTVdh7Q6SdPTmlayTlfq36rYJxljjDHG1BlVs+hoAzCVW4pWo826Mq0xjYa+PfH+0+aGpbwx6n2sb2TFNPg0/0ualUbRt1vWYdE1YyNWIFfZu56qmRdD2jX4888/m8j5atawIrZek3q8Fjp+bar722+/AUg2bdU6O6S1WnnSGmTr+s4666wAkutX7lxt0THGGGNMw+IHHWOMMcY0LFVzXX311Vchv/LKKwAKm2nVNL7iiiuGvNRSSwHI34CyWuRripgWOJfWwKy1mh7N/1LNYLpS0DH9/PPPIY8ZMwZAspFpKS1W3nvvvZDV9LzqqquGXIqbulLkuyfT7k9dq2q5xtMaQN54442hW2+99UL+5ptvQr7uuusAAD/88EPoVlhhhZCPPvpoAMCyyy4bunp396etyWOPPRbyBRdcEPLo0aOb/I66fvr37w8AOP3000NHdx5Q+3OX6/7XX3+F7tRTTw35hhtuAAB07do1dMcdd1zI3Bf5vj/rEW3Rwn2rbTHuu+++kPv27QsAuPDCC1N/v5Rz1RYdY4wxxjQsftAxxhhjTMPSbAuIUipfqqn6zTffDPmggw4Kmabzdu3ahU7lRRddFADw9ddfh26WWWYJ+ZZbbgEArLvuuqFTc1Yh02QplS9pJsznLps0aVLId999NwBg2rRpoVPTcrdu3QAk51xJN0drqYycz7WQ5kbQn2Xly2pWRta/P3XqVADAsGHDQvfOO++EvPHGGwMANtlkk9TfL2RyrlRlZDXn6/3HsT7yyCOhm3feeUMutBc5/mOOOSZ0P/74Y8jXXnttyHQZ6L2SdWVknkF//PFH6NQN8uyzzwLIZbcAwFZbbRXy9ttvD6B013hLKyOrOf68884DAJx44omhO+SQQ0Lea6+9Qub81F14yimnhEw316hRo0K39NJLh1yuG6tSlZHT3BkAcPbZZwMA7r333tD99NNPIXP/5XNHMetPr98ZZ5wRciE3VhaVkfWe5/fCRRddFDquPwDMPvvsAJL7V7//nnzySQDAMsssE7pi1jTryshp35XPP/98yOeccw4A4Omnnw5dWlYZXZAAcNRRR4XMrCwg/axyZWRjjDHGTFdUPBhZLTp88gSAt956K2Q+ye6///6hS6vzMWHChNBpYN67774LIBmspbU7sgiA5FPq999/H7qrr746ZH2759tHPovPdtttByAXVAgAs802W8i1DmIthTQrRb4AUM5P6yikWcQAYOzYsQCSb6yLLLJIBUZcGJ2Tvj0ziI77EAA22GCDkLmuTzzxROjUurf22muHvMceewCoXIBkmuUJSL5Rde/eHUByzxX6+/q5DKLk2gDApptuGnItAj91fEx80LfAhx56KGSeFXpOPPDAAyEvscQSAIAuXbqErlLBvHofaID4iBEjACSDTjWYVq0f/Ayd8/333x8yrXebb7556B5//PGQl1xySQC1OWd0zL/88kvIGpjKtdBr1b59+5DXWmstAMnvDw2MHzJkCADg9ttvD12vXr1C1mD5agVp61y+/fZbAMBNN90UutVXXz1k6idOnBi63XbbLWRaTM8999wshloSackYH3/8cej0+tN6pzqeSQBw1llnAUhavPR8yefJaQ5bdIwxxhjTsPhBxxhjjDENS8VdV2oK1AC/Sy+9NGQGIe20006hW3DBBUNmEOUdd9wRupVXXjnkLbbYAkCuHg8APPXUUyEfe+yxIbOMdCkmdDU30rWy4447hu61114Lmbn/KqtZ7eabbw758ssvB5A0TWudiLSmbvVEWs2L33//PWS6edTNp6blcePGAUiaNtVMq64punk0AK0WaIAtgz3V3cHaTgAwcuRIAMA222wTOrpDgKRLodLo2nz22Wch617aeeedASQDAAu1bUhz87z66quhGzhwYOrPZtkOQueqe23vvfcGkDwf6O4AgLnmmgsA8MILL4ROa5o888wzAIDVVlutwiNOXpsPPvgg5M8//xxA8hzJVzskzVzPAFYAGDp0KIDcdQCSwcysWTLffPOFLmsXDuf966+/hk7nqq5Fuj7Vxdu7d++Q6fpX1+vWW28dMsMkNNhe13qllVYKuVpnrbp2eO5psg3vSSB3luj6aODx+++/DyC5Dwo1Pc2atH296667hk7dtFw//c5T1z7ncuCBB4buwQcfDFnrf/FnC62fLTrGGGOMaVj8oGOMMcaYhiVT19Xyyy8fskaIH3DAAQCSpinWxgFypkstYa4R9nPPPTeApDlr8ODBIR988MEhs1ZNud2Zr7zySgBJ0+vLL78c8iqrrBIy3WVqTpx//vlDpkmVLg4geX3UZF1t9Drly5r67rvvAADXXHNN6LQmQlrtlMUWWyxkuqaYcQQkzZFzzDFHs5+VNTQzf/HFF6G79dZbQ6YbUl1sd955Z8gnnHACgKTpnfsHADp16hRypVw7XB/NDmM9EiDpGmbWQiF3hZrbNUOO9526g/Rez9INomPSOiN6z7/++usAku7y3XffPWTe1yeddFLo9Gc1W63S6Pi//PLLkOka171fzJ7Xa06Xx2233RY6daMeeeSRAJLudD3rssgA5FppPSd1V6kbhq4bPV+YKaY/q+4OrUnWo0cPAMk6QtpCQ+dXrTYKuj4fffRRk//X7w+OT/eHut7oJs5izYpB/76GHjCDTl2zuv94FvJ7HEheH2agaaad/n9JYShF/4YxxhhjTCvBDzrGGGOMaVgy9ZGoiUkLHtHkpUWi1IzMrqUsxf5PaO7XsvMzzzxzyJUyR+r4mdWg5tDFF188ZDW9cnzq7lEz3TrrrAMAeO655yo+5nLRMWsmyvDhw0OmSblnz56h0+KHc845J4DkmtCdBxSeq173Wnalf+ONN0Knrje2S9Cy8ppBwEJYgwYNCp2uf5aZSOrOVdeAZkCoSbg51DStGVZ0U1588cWh0wyYLOeXr8WMZl3SjbbhhhuGTu9PZmh16NAhdLrvWag0CxeHfuY888wTMkv8V6KIH6+/fv4VV1wRMrP+tGDdfvvtV/bf/Sfqgmeml+5P/X/dP3TN6D1XyHWh141ZdbXORMrHDjvsACDX6ghI7lW65LQgrbaAYNaxzq8WhQ/VTX744YeHTDebrt8ll1wSsrabSfusAQMGAEhmnanLU79LWnrW1OdOMMYYY4ypAFWz6OgbEd8u9SlUrTsMnOSTHZALgAVyNU1YjwbIPSUDSUtCORYBHR8Dp/VpMh8MvNMS5xqAxtYAOjadHy1F+d5isrRy6JuRPoVrC4Z+/foBSD5la7Arn7Lzjble6wMR7lWto6I1j1j/SVuU6F7k/6vlJIty+2nBwvrmrtaPe+65J+QVV1wRQPKeSxurBvvq2yUDZrUeULXeKHXO48ePT/37LLHPpAcged8yyFObeiodO3YEUHpTz+bQz9EEBb7lVvLe0LddrR3DxA0GJf/z/zWIvljrXFrtMSAZWJz22doOgLXKijkz1DrEZA/VabBvFutaCP07tOSoR0DHRIuItrBQiwkbtFazhUdavSE9U9R6zJ/t06dP6PT7gePWOT/88MMhs46V1uFbaKGFQi7lrLFFxxhjjDENix90jDHGGNOwVK1gS5obS0uUs+M3ABx//PEAknVMRo8eHTJbCGjZbA1m1poK5ZjUdcz8TP08NZ2rmZH1K9QdpSZ3Bpvp5++zzz4hs6aOmpPzucwqbXpVc+Imm2wSso6fbjjtKKt1YrS+SmtB3TwMVtU6JJ988knIrEPz7LPPhk4D77gm1Swr/+STTwIA3nnnndBp2xR1k9ANp/tT70W269DaQdr9nPVX8tXBqBb57gm2I9Ezg21lgJxrO82dAOTOlSyCPfVvMmhWx6QB8Hr/lfv301qAPPbYY6HTZBFtbcM1bqmbRP+OuiPY9kD/X11k6hpP+6w08tUk4rnMpAgg564FqteiREkLjNZrqrWbbrjhBgDJtjrrr79+yKwtVq2xA7nxa6sVdokHknW2+L2lruO0mj96pvbv3z9ktvvR0An9Ti/FZWeLjjHGGGMaFj/oGGOMMaZhqbjrSs2J+WS6qbQ2h5qZiXYvVzfJ+eefDyBX6htImrErZWbWMdNMqF2stcS+ut623HJLAEnT/pgxY0KmaU4zAbSmDk3WWkfokEMOCZklsnWMWUTgr7HGGiGrO4quN61dcuihh4Z87733Akh27K6FayMNNSHrNdP6HnQdandhbUfCTtA6v2qakdP+5rBhwwAAyy23XOjuuuuukLWmCu8fzRS76KKLQmYGll4fvf9Y86MW2XM6Zx0T7zkgl7Wh50O3bt1C5rw1K4jXBMi5sbLYs3pN1Z3IFge8d4Dk+MtF14quD3UXaU0sbWei93VzpJ1DeuaxdY66k4444oiQtU5MobOM97Cuj9axYvdyvb7VylDS7ww9a3744YcmY1HX5YgRI0KmS/yYY44JnX5X1OIs5bw0U1HvH91fdJlrOxO9Lpz/OeecEzr9XM5b6+2Ue9bYomOMMcaYhqViFh0+veqTM5+sgeQTt1pyiD69sQ6JBkBqYNO2224LIBnAlfUT+5QpUwAk34I0WEyfTnv37g0gWQdIgwzZzPLMM88MnVZ5Pu200wAk36zuvvvukE888cSQ+VaktYNKgddP3zzUCqA1KbjWG2+8ceg0cOzzzz8HkGzEV2v4RvHhhx+G7rzzzguZVgAgF6ypjSIZIA8AM800U2bjLAZ9SzrrrLMAJMemlUX1jYj7Z7vttgudvlHSEqQNbPv27Rsy90UtrFg6D50fAziBXINB3b9aBZhB2LxPAWDrrbcOOcuzRMevVuiFF14YQC4QHEg2rdSfLfftlvNjvSAgd6YCyfO5pRadNNKaE9OaDQArrLBCyIWq3eqc+f+aLKAyzydWsweS90WWlkhdM21UPXTo0CbjU4u/NsBkYLie83p9amGd4veTWoG1kaeu9dixYwEkvx/1u5qeGj1zlO7duwPIWR6B8q1YtugYY4wxpmHxg44xxhhjGpayXFdq2mJgkrqotGy8mizpGth3331Dp2bMF198EUCyTom6ZtJaDFQLNRuq6VzrcNCNpaZLDZZkM0htZKfXh2Z4tloAkkGKWrOHgcvl1q7hvNQ1p+4aDcbluqtrkmX3gdy1qHWrB92fI0eOBJB0R+k1e/TRR0Pu3LkzgGQdENZuAnKBgdUswZ6Gzk8Do0m+8bGmxaqrrho6rVPBfbv77ruHbqONNgq5XgLLdRwzzjhjyHSZah0uDbamS+uoo44Kndb5qNb89O+wxD/N9kCyaSlrNwHluwzpOlE3iyZTaGuPlsJ7Xa+j3l886xgCAAAvv/xyyDon1jzSYF51g7DBsJ6v2q6E7SQ0mFfddFmsL+/FBx54IHTHHXdcsz+rtX/UtaM1n0gtzlK9/nRHaW0tXWsNJmcLD52ffpfxe0NDG0444YSQl1pqKQCVPV9t0THGGGNMw+IHHWOMMcY0LDM0ZxKbMmVKs/YyNV0xg0izjzRTQzvl0syuUdXvvvtuyKwfo5lYahJkNH2p5rz27dvPAABTp05t9gPScv81u0jnqmZgmmnVdMpMKyAZbU/SWmRoJLuaMzUzitdIzYxt27ad4f9+p8UXiH9fS3Gra07nwvo5AwcODJ1mxVHW61dJ2rRpMwMATJ48ucn89Dqou2mLLbYAAHzzzTeh0xL0WmeFZnB2mQeSc91hhx3KGH1hZpxxxqLXrxi4Lmou1xYkLM2u7lJtcVGuSZnrV8n56V7jvA466KDQaVYOz6JBgwaFLq1EfalwftOmTWvx+ULXzTbbbJP6/1oTSeuTpMHxq4tGP4vnh2Ydqpv2pZdeCjmtBQTPl7TvB72Oeq9xXmwfo58NJL8L0tDz75dffmkyJr0mzKDUmlJ6Pheipd8PCq/5gQceGDrNKtKsKc5F3cXqxqGbSPesuhPLvf/atWtX9P7kXlJ3r4am6HcFs6bV9aqZfFzryy67LHT77bdfyLwXSp0n96dii44xxhhjGpaiLTr6xswnayBXh0JrF+gTqQYT841C6+Ro4Oviiy8OALjqqqtC16lTp5DLDSYr5Yk9rfKnBuNqHRxaCgpVhizmzTFfxc20z+ITezFvzPx8rfejdRz0TY1rzABKIBl4mJUlhzRn0dG/rQ3oWHk6rR4HkNxTlJdffvnQVbNRabUsOlqNW+vIsOK3rm8lAwOzsOjoPfHQQw8ByFWwBnJ1agBg1KhRALKr3N1Si47C+4vNL4Fk02Kd39FHHw0AWGSRRUKn+5r1Td5+++3QqUWEFYsZdA8kLe6aWJF2RjVn0VF0zP/+978BAH369Andp59+GrJaN9JIC9BVK6M2FaZ1Vs+CYs7aciw6muxw4403hqznJ8etlfU32GCDkLlv//rrr9A98sgjIbMmUKmWx5ZadBR6F7ThqwbO6/pwrmpF05pWTMZRK06pa5WGLTrGGGOMma7wg44xxhhjGpay6uhosCwbAWop68MOOyxkNQ2zfoLWPmAAEwCcfPLJAJKmyVqUm1doTlNzbJcuXZr9WTXBlWv618/Kog4EP19rq6jrcfLkySEvtNBCALJppFouep20qd+uu+5a1ufWumZOuajpnC066AIBkoHJ6n6uZ9TcraZzusS19oo2AKXLp172LJAbyzLLLBO6xx57LGRtYUGXiM5PzyUG4S6wwAKh0zoyTBbo0KFD6HR/VGqv6+esueaaAJJtbU499dSQn3766ZDT1kXrCHEtmWAAJEMbalFnjddf3f0aDK3B1nT5aO04hXptdJ3muqsmXJOVVlopdLo/NUmHel0frZPDz8jXYDkLbNExxhhjTMPiBx1jjDHGNCxl1dFR2BH45ptvDp2aI9XN0bNnTwDJeiRqZqVLLCtzVilR9a2JUrKu0lDTYlpNhVrRXNZVI5BF1pW6JpgBo66rPffcM2SW0NdMyUpSqawr3Z9sQQMAPXr0AABMmDAhdFrTgxlYWZ0vpWRdpZGvLQXdjDp+vT/pJtHro2EG/Fn9zGLcPC3NukpDx6TucA1jSEP3IsMksmrbUc73g65DvuzTtOuv/PnnnwCSa6LzLzertZSsq7S/rXuKYwZya6ltIbRFSylZx8XgrCtjjDHGTFf4QccYY4wxDUvFXFc0SZZa+Ed/NutoebuuWjd2XZUH79F8JvC0rMFKkkXBQHXj0GWumSqbbbZZyNUqaFmu60pJG3Oh9SukK5VyXFdKS9w8aWS9P2v9/ZB2f1bSzVqO6yofaWEOlcw6Lga7rowxxhgzXVFWHR2ltdcZMWZ6Ies34lqgb5RqvSG1rsNVLllbaWpBNa34rYnWeH/W+/e/LTrGGGOMaVj8oGOMMcaYhqXZYGRjjDHGmNaMLTrGGGOMaViaDUZu9PTkRp9fJdMH6wmmDzZ6enmjlz9o9PVr9PvP+zMbmJ6tlYfV81JuYH3W5StqDb//FFt0jDHGGNOwVCy9vBRKLRhV76lsprEpt+Cc4+JqS9YF2WpBvr50pFbF20zL0DWbOHEiAOCOO+4I3bzzzhvy9ttvDyDZP8pnSvPYomOMMcaYhiVTi44+peobB9GOp7///nuTn9WnVHasBZJdUVsz2n1XqXV38FJI62qb7425tRRvy2dxTCtxPm3atJC5frrn27ZtG7LqW/PbdUssW/XypqnXnGul3bNnn332kFtLwbZ8ncDHjBkDADj99NNDt95664U8YMAAAMnzp1pz1T2jf1/nwrHoOdia75OWoNfipZdeAgAcf/zxodtxxx1T5Xom7TtfqWbBSFt0jDHGGNOw+EHHGGOMMQ1LxV1XaoL666+/Qv7tt99CfvfddwEAo0aNCt1DDz0U8jfffNPks5ZZZpmQL7jgAgBAz549KzXsqkKT3vjx40PXpk2bkBdddFEA9W+uVTO0dooePXo0gNw6AsDSSy8dcufOnQEUNm3WijTXqa4VTcvqbv3ggw9C/vHHHwEAs846a+hWW221kLfccsuQF1tssSZ/q9akuaRKXSvOqxZ7Weeh63f22WcDyAV9AsDll18e8kILLQSgNq6dfKSFAfzyyy+hO+KII0J+4oknACT3p7r7f/jhBwDAggsuqWTsDQAAIABJREFUmM1gU+D41cX7ySefhDxu3LiQ55prLgC5cwIA5pxzzpBrvRaVQtPHf/rpp5CvvPJKAMD8888fun333bfJ79XTdUhzSfIcBJLPAkTdxXPMMUfIaWdGuedHfX7TGGOMMcZUAD/oGGOMMaZhabbXVTGVE2m60oya8847L2Q1TR555JEAkpkomlX15ZdfAgBOPfXU0L366qshH3zwwQCAwYMHN/n7LaEWlZHV9E+T3lZbbRW6gw46KGSaKdUdVAzVqoyse+e2224L+bjjjgMATJo0KXTqunrqqacA5FwEQHGZZllURlY3Bd1Q11xzTeieeeaZkOkG0T2npnW6Wb/++uvQ6fy22WabkLmH1TSbdWVkjjufa4b38JQpU0I3duzYkHkvP/3006FTN4l+Fl0qXbt2Dd2//vWvTCvPcn5Tp04N3WabbRYy56e6n3/+OeRBgwYBSLqTi3ETlFMZuVCmH5BznZ5zzjmhe/7550Nu165dkzHrXHbddVcAyfOzGDddSysj65h//fVXALmMLwB45JFHQqY7DcjVh1lxxRVDR3cjAHTr1g1Adu7QrCsj87vg448/Dt1VV10V8o033ggAOPnkk0On163U7wVSqcrIur561l988cUAgFdeeSV0en/x99R1uvjii4c888wzAwD23HPP0C277LIhq8svDVdGNsYYY8x0RcWCkdPeohh0DAA9evQIeY011gCQ/y2eb8RffPFF6JZccsmQBw4cCCC99kK9om9Mt956KwDg9ddfDx0D8FoDvO7vvfde6LgmQG4tllhiidDp0znf2Gq9ZvpGonvx3nvvBZALCgRye1b1HTp0CF3Hjh1DZmBdS6xUWQbp5qtZwntU78/PP/88ZL5pjxw5MnSaTEB07Pp2ttZaa4W88MILN/nZfPWjKgX3p95ftBIDuSSIYcOGhU6tV7UMktfrpPuHAf4A0KdPHwDJt+RNN9005Pnmmw9AMsBV79UHH3wQQM5yBWSzJvqZtI6q5VfH3Lt375C//fZbAMDQoUNDpxZvjl/vv9ZUe4z35d133x06WnEAoEuXLgCAvn37hq5eao/pvaFW3F69eoX8wgsvAEhaERXO/6OPPgqdBqnzHtBgZrV46bnW0u8QW3SMMcYY07D4QccYY4wxDUvFXFc0IWlQsbpj7rrrrpAPOOAAAPkDiGlaV9MYfwcA5p57bgD1Y87Lh5r5Pvvss5DpEtAAVjXD1nv9HK61BkBqCXoGy2kA4U477RQy173W89T1obkVyLmmtM5D//79Q959990BJIMC00znhYLmgMq77/LVNtLAQLrmrr/++tCp6Zj318Ybbxw6dUOuuuqqAJKNBln7Cci5ToBcYGzWa502bw0m17mwpsxNN90Uug033DBkjjVrF5vCv/X999+HTpMxGMAP5NyIRx11VOhUpstA11QDl3ld1J215pprhlwpN5CuOWtH6X4/9NBDQ9aaU7wW6vo49thjQ2aQvyY41LvrSvcnz5rbb789dHrPMICfQblA7d38RM+U4cOHh/z222+HrM8AaXCt9PtPQ1O++uorAMk6eyNGjAh5l112KXbYtugYY4wxpnHxg44xxhhjGpaKu67UXK8mJkbKA8D9998PIGma1HLfN9xwA4BkVL7W4ah3l1Uazz33XMh0I2idiEUWWSTkWrt00khzDai7R83km2++OQBg6623Dl29dOzWcdBECiRN+8zA0Tlrtgg/Q90daSXMqwnHpKXWTzjhhJB1/H/88QcAYIsttgjdmWeeGTLbUtDtBCTva963+brTV7J0e0vRsdD9o7W71I3KOh/qJtK9mi9bpNLomHmmnXvuuaG74447Qta14LoefvjhodOaZNx/zG4EkrWb+Lnvv/9+6DRTrlLo2i+//PIAgOWWWy50ei+mnemawcs9qXI9npOKrq+69q+99loAyRY5zKQDcnsxnzsurUVN1mcO3Yl6Zp511lkha9YiXVd0cQPJvcbu6/369QudusZZx0zdzepm1r3c0gxeW3SMMcYY07D4QccYY4wxDUvFu5erObF79+4hb7TRRiHT5KVmWjVjMQJfzamtqTggTZZqrtTu1rPNNhsAYLfddmuiA+rTJKsZKGPGjAGQbMuhWQM0rc8000yhq3VWBNdEzcks3AgkWzzQ9KqmfzW9svihdiG/9NJLQ2bX4WquI+8PNYdrVoTeM0cffTSAXKsOIJkhmTbutBYR9YSuK7OS1JzOPQsA99xzD4CcCR1ImsNJ1ueMjpktEDg2IOmO0vOTLit1saXdX3pmavdy3svagkCzabI8a/N9tp4vLBio7grN0KGbuLV8DwC5th0A8OijjwJIzkm7z/P+y+canjBhAoCkO1kzILO4Lvz7DDsBgIkTJ4ase5UZcj179gydFidlcUEdv86VGViavfXhhx+GrC5NfsfYdWWMMcaY6ZaKW3TyBWBpHR2W9lYrhpbYp3WgNVlx0tC3FK0TwLlo2ezWBJ+o9clan775dF9Mo9Ws4TXXfaTBxHyLBHItSNZdd93QaZ0PNtvTAHsNsjzllFMAJN9Yst6//Hy9Z/Tva7AfLTqslwMkLQL1aFEshF5fNoudZ555Qsc1AXL1VzQAXa0j1Zq/rhWtoxrUr/+/3377hcz7qxgrqV4f/p4mE2i7CFoki/0bxY4jn/6hhx4CkLTC7b///iGn1Waql2QHRc8/DSyn9UxrHy211FJNfu/PP/8M3RlnnBHys88+CyAZrKt7uVJrpuNnOwa1sun/a4Nm1mTSRpyabJRWRy2tHY9ajrUBr1ra3QLCGGOMMdM9ftAxxhhjTMOSqevqzjvvDJnmciDXzmHllVcOnXYapslSTXda56LWga0tRU1vV199dcinn346gGTH59YyJ6CwSyrNTVQvqLl07bXXDlkD3zk/NYerzBYQWpb/scceC/nggw8GACywwAKhq5brSoPCtaz/E088EfIee+wBIFmHpUePHiFXq21DueTbh2wRoHVy9F7cd999ASTdBRqMmyW6j7Q78+OPPw4guU/0zOvWrVvI5e4luum0LY3K1TqX0twVQC6YnJ3vgWSywAorrAAglxQAJLubc/y1rGcFJIO9tV0Oawpp7Rz9PQbR63emBqnTvZl2ZlUS/czvvvsOQO7e+id6fvz8888Akq7ztDAUXR/9WXY115pgGuZSSmsWW3SMMcYY07D4QccYY4wxDUvFXFdpkeJqztcMD+bZq05rktx4440Akjn7WkeCXV3r1d1D05pm5agZji0SWhNqxqQZMl+dh7TfqUfUdJo2Vt1f+rN0eamJX90QzDas5vw5Pq2Xot2vNQPy5ZdfBpBzYQHJ7vIDBw4EkCy7X4/3ml7fL7/8MmS6prSOx5AhQ0K+4oorACQzRfT8oesuC9eHmt1pogdyrgldP3XHaE2qUuoY6bVK25e1cPPo31TXBl06mmmj+4/ZYoMHDw6dtti55ZZbACQzXau1f3VO119/fci//vpryOeffz6AZO0bPT9vvvlmAMnvD20B0qFDBwDJOmyVcjPnW5M33ngDQDLTVusAaSd6nhu619P2l36+PjewvplmQuq9XEqGpC06xhhjjGlYMrXo6FOoBv6xsqU+8WlTxAMPPBAAcPvtt4dOn9759JivDkgt0KdTNk1kc1Ig95YJ5Gqa1HrMxaD1PWgR0Kd7DRarF9KCifXNQt8GinmjpXUkXzXZWliyeC/pOFZbbbWQ1TrKKqVae0MTB7744osmOr3X6qUpK+8zIBcADgDrrLMOgOT81FLCwNa99947dHp9+PaYdQXotADNLl26hE6b/qbVHMm3Z9P2ggZmM9i1Fs1X86Fz4XeBVutWWJNF62BpYDIrXj/55JNNPvOff6tScE0YSA0An3/+echq/eC6au0xrRl01VVXAUiuie5FJhnoXqnU+ume0fPtxRdfBJD8HtA6VZp4kVbnKe1MVB1rJwHAsGHDACRrf2mdvVKwRccYY4wxDYsfdIwxxhjTsFS8jo7mw0+aNCnk0aNHh3ziiScCyAU9AknXB83MWmegb9++IbMB32233Ra6xRdfPORa129hMJwGoKlpvdZm4paipkU1Y7LBpTZN7NSpU8iLLroogNq45tT0qk3nxo4dCyAZgKrBtsUEuDFYni4eANh0001Dnn322QFkvw91rjR9s+EfkCyVrq4njk8DkN95552QGeypjWjXX3/9Sg27JNLKxvM++yds96CNBnUvptXhUNdCtc6PNNep7tlx48aFzNoxQM6NoaEBCs9dbUTLAGwg5/JT15Cev7U+P3ld8t2H3At65uhe2H777QEkg3n32WefkLM4l9IaOau7UOfy6aefAkiu9THHHBMy29Goa0sD0ykXCvYtBT3zNZno6aefBpDcc+rGSrum+QLgKevn9+/fP2Tet/qdr67HUr4/bdExxhhjTMPiBx1jjDHGNCwVc13RnKTm0BNOOCFkzca69957AQArrbRS6LScNUt/qzth1113DZk1L7QjOt1hQPbZEiRfBsi1114LABgwYEDoNOujNWVbpcF56zwWWWSRkGlmVNNmtVBz7ksvvRQya8ZoJL+2gNA6Ddx/7GIO5PYskMtGUnO/tlOgGyRrF6XOdfjw4QCAoUOHhk7NxerG4n2lruW07tY0VwP147pScz/vMwDYa6+9Qmb3bd1/7733XshcS63Tom6QLNdN7xm2AgBy+2/UqFGh69WrV8h6/ekynnXWWUOna812Dm+99Vbofvnll5C5/r179w4da7MAtXetp9XpKlTzSt3IrFmm7o6s4fh0TfSsefvtt0Nmawd1bem+YPiHZhqz7Uza36wEaVnTdHEDuXNFMxXVTX7dddeFfNhhhwFInk8//fRTyKwZdfbZZ4dOM3h5ffr16xe6fN3pW5rhaouOMcYYYxqWigcj69MW61kAycAwvmloU0R9I9bAO8K3NCBXk2fVVVcNXS0C6PRpkgGqQG782223Xehq/ZZUSdLmUmpNmkqjb0ZaR4aB7awhAwAPPPBAyLSIALmAOw1m1cByvukccsghoevatWvI1Zq/Wi4ZgMuGuUDSoqVNEfnGq29caQ0WK9lIslJogKZaIbQyMoOpWY8DSFrkttpqKwDAWWedFTq1eGV5r+pnq/Wbwahsnggkg4mvueaakNNqQqVVtNWmmNoglHVo0gJA/znGaqH7j00h+S+QtC5w32qdmpNPPjlk3r8bb7xx6LKeU1plcv1O0/3F+0vvPx0fm13vsssuzf6tSsLP1PtLzzRaR3feeefQ3XHHHSGfe+65IbPOml4LTXZgkD07HADAaaedFjKDkNPqTAGl1SmzRccYY4wxDYsfdIwxxhjTsMzQnBns77//rpiNTM1NNNmpuVkDj1jrRM2pNOcBOZfVKqusEjo1cxWiTZs2MwClzU/noQFU6qZiYPQGG2wQumoGIHN+06ZNK2v9dK7qJmGzyIsuuih02uLi6quvBpCsvVNJ2rZtOwMATJ48udn56Z7g9degTHVj0d0BAB9//DGA5Py1QeAWW2wBIFmCPZ+ZtRRmnHHGGQBg6tSpLf4gjrVQ88ZiyNcuo1zatWvXovVLQ6/z+PHjQz7iiCNC5hrr+aBuAJrkS2kO2BK4fsXcf2nB1jq/H374IeS0OkAK56K1xTp27BgyXQqlupt5/xWzPwuh9dfYQFLXVOG6qTtE67tcfPHFAJJ1ooqZXzn7U0n7zmsJHGtW3xncn8V8//G+0wBqBh0DwKOPPhoyz/18rlW2i9Cmp/pdyb1Q6jnK77/E+Ev6JGOMMcaYVoAfdIwxxhjTsFTNdZWGmk7VDaQmZaJuLJrRSq2XU47rSk2s6u5gx1kglyGhEezVzFqplOtKUTMszesnnXRS6LTOQ/fu3QFkl+nQUteVUsi1o3uJGQb6/7onuQeyyjQrxXVViFLcWFnt2SxcA8wkA3Im/5lmmil0ae0gsppfKa4roi4OddOVsn75upOXe19m4bpS0tphvPLKKyGPHDkSQC77FkiGDrA+Ub46PIWo1P6sV0pxXaWh39mvv/56yMyq0v2rNa1Yv0zr6KW5yUt1vdt1ZYwxxpjpCj/oGGOMMaZhqanrKjGQAmaqSpqZy3Fd5SMt66ZWRdaycF0paW6gfBH2WVCK66oQxZhJs55fFq6reiIL11Wavpp7UinHddUayNp1RYrJpFXKdc3ZddUyys3wzCq0wa4rY4wxxkxXVLwFRKnUS4n5UmmkFg+FqLXFKgsaaS7TC/nWzGvZGExPZ2prpFYW01KwRccYY4wxDYsfdIwxxhjTsDQbjGyMMcYY05ppNkan0bM+Gj0rYsqUKQ05v/bt21c8a66eYNbAX3/91ZDzm2mmmeri/tOsHi0EytgQ7TVUSi+oWs8vKzy/1s30Mj/FritjjDHGNCx1k3U1PcE3yUJ1aOxWNK2RUkvvF/vZSjF/h20W/vjjj9DdcsstIbOFwPrrr5/6d31f1pa0Ol5KPZ6faWMtZi/Xy1xKbctQ6/HbomOMMcaYhsUWnQzJVzmSb5LaiFAbEM4yyyxNPqvWT8TTE3zj1xiNUtA11xgQbSBaz+uarzJt2ludNu2bMmVKyGymmdaotxBpfydfbZW0yuT5/p/334knnhi6K664IuSDDjoIQNKiU4/onLQZKMlnheK+bk11anR+bCapVrgRI0aEfN111wEAFllkkdCVey+XQr71+fvvvwEkm2LqWrRr1w5AetwYUL0zo9B9nq+ODmVtpKv3P/+/mvvPFh1jjDHGNCx+0DHGGGNMw2LXVQbQZEkTJQA888wzIQ8cOBAAMGbMmNCtvPLKIR922GEAgF133TV0avrM0nRZarBZMdSju0bdSR999BEAYKmllgodzclA4fHzGmqw6yuvvBJy165dQ5555plb9JnVhOP//PPPQ6d7+aeffgIAvPXWW6H79NNPQ55zzjlD5h7u0KFDRcb222+/hayugdlnnz1kXkv9f13f888/HwBw8803h26NNdYIuVevXgCqcy+UAs+Cn3/+OXQffPBByFyriRMnhk7d4euttx6A3N4D6mv/EV0/3V+nnXYaAODpp58Ond6f3CO1WD8ds7qm9Px//fXXAeTOGSB5/VdffXUAwJZbbhm6ZZZZJuS0prWVQq/Z5MmTQ77nnnsAAM8++2zo1EWtYRh0SS233HKh23TTTUPu1KkTAGDBBRcMXdbtJGzRMcYYY0zD4gcdY4wxxjQsFXddqdmpUNZGWiYAkDN96e+rSY36ejK36lhp0jv33HNDd9VVV4XMyPVZZ501dGrGPOSQQwAkTdPMBPnn36rUNShUm0Lh+uTLKmsptV4/zWrQ69+7d28AwMiRI0OnZtZCGRy8FnfffXfojjjiiJDff//9kOlSqPW10D313XffAQAOPPDA0On6MpuF9WYAYPvttw9Z3VRzzTUXgMplWKi7JV9WUdpefuKJJ0K+4YYbACTn3KdPn5C7desGoL6y49R1/fXXXwMAjjnmmNA99thjIXOs6jrVa3HTTTcBAHbfffcmv1MPcK7vvfde6LbeeuuQO3fuDCDpRmnfvn3I3HPVzLTimL///vvQMUQBSJ4FafeCnkXcq1wnABgwYEDIO++8M4BkVlOl7i+9J+iiBoAHH3wQADDbbLOFbt999w1ZXad//vknAOCNN94I3aGHHhoyM4z1fNl7772b/H8ls7Js0THGGGNMw9JsU89ye11pACMDsIBcMNKrr74aultvvTVkPh2ussoqqZ/Lp78NNtggdMW8kVSq15U+/Wp9gRNOOAFArp7D//3NkA8++GAAyWBXfXq+9tprAeSejAHg3nvvDVkDJ9PeWlra6yqtzssXX3wRuscffzxkrfPz7rvvAki+XS+55JIh65swWWeddULmG3+pAWjl9LrSv/Ptt9+GvN1224W8xBJLAEgGq+r8C42Va6LB5Pp2cuedd4bMN1H9zGr1utL118DJIUOGAAC6d+8eOr0Xue/1LTSfRS/traycXlfFWA4fffTRkPfff/+Qaek488wzQ3fAAQeEPOOMMwIo/Y2yUr2E9HxR68bRRx8NAHjxxRdDp+dLWuV1vScZLP7UU0+FTq1wafevkkWvJJ3rO++8AyBpJdQA/ssvvxxAMuhd7x+uW6lWqpbOT68v73mODQBOOeWUkLmngNz34rLLLhs6PV+YpKJnu1r0aAlRi1ExyRItnV/aNS3UH05/T39fLV1XX301AOCRRx4J3TzzzBPypZdeCiC5J4u5F93ryhhjjDHTFX7QMcYYY0zDUvFgZDVtaVluDZyjGXzcuHGhmzBhQm5Q/2cS09oJagZ78sknAeQCpPQzgWxLS6u5Ut1VF154YcjXX389gGSA3EknnRQyzega2KVjpplPP/O1114LWV1XxdZUyBfAyZoUGkCtwX66rpTzXee0YFAdM4Ps6CL652dlUkfh/8b866+/hu7YY48N+ZNPPgl56NChAJKuuUJ7Sq/PSy+9BCC/60RNvrVETeN0lwLAhhtuCABYe+21Q1fINF2tYNa0oON/8vDDDwNIBoDrNedZlOauAuqnNYKOQ10idFmpu6MQOv9JkyYByNUTAoBBgwaFPMccc6SOodKkBVgDwDbbbAMAWGuttUJHd4aOr5CLLWv0nuea0C0DJN1J6tpnyMJ+++0XuhVXXDFk1tziOQTk3HlALpheXcs9e/YMuVLXRe8vrlWhBACV0xIYAODss88GAOy0006h69GjR8i8P++6667QaeB1KWeNLTrGGGOMaVj8oGOMMcaYhqViNnSaqbQU9KhRo0KmuRTIuUnURKoR6AsssACApLlOy1GzxLfWI1l11VXLm0ABOD815Wr33IsuuihkmonVtElzLJCrnaKuLzXjbrvttgCSWVv//ve/Q07rDt1SdEzffPNNyMcddxyAXEYVkMxq22yzzZqMVa9FmhlaTY/aAmH8+PEAkubcrOH6aT0Vda1qhhQzxAqZ7fNltdx+++1NdJpBoibtWpjfOW7NqtMMP7pc1Z2gdYTqBd3Lo0ePDpktVDSTcc011wyZNanUNVlrNwjROWkdLb1/2An6H5l6IdNNoOEAmlXHv6Guf3Wj6LWqtOtK56cZnnq+rLDCCgCStcdYGweoTSdyks9dypoxOidm1wJA3759Q1500UUBJM9MXb8ddtgBQDJrmeczkPv+00xcdTNrfbZKr5/uOT0zfvzxxybj03XSFhifffYZgJyLH0i2cOH+q2TbI1t0jDHGGNOw+EHHGGOMMQ1LxVxXNEmqufv5558PWU2P7A7MUtZAsjsrzX804QFJMxgj1PNlhWQB56eZSKeeemrIOj/qtUiiyoVcNjSj53MNlYN+jma1ffzxxwBynXOBZCbO4osvHnKaGVFN0sxguv/++0OXFpWfdaaO/k0WibvjjjtCp1krWoI8rcWIrgU/V+esLjH+jR133DF0mnVWi6weHStdGlrQjO5iINdOYPPNNw+dms5rmZWka6qm/UsuuSRkuny0RcXFF18c8nzzzQegftxViq6TtiXRTuSFCgJq1/k0GAagoQPqOsgCjlXd7lqwUfXMXCrkrsrnRsryXNG/qWEadMPoOFdbbbWQtZM316pQCyTNStIwA2bwvvzyy6H74YcfQta1rNS9ynlrkb8zzjgjZHWT/v777wCSWcXzzz9/yLwvtQWJhnYwK82uK2OMMcaYFlAxiw6fHOeee+7QnXXWWSF36dIl5I4dOwJIBgNqfZPBgwcDSAbj6RsLnwT5OUA2AWr6dsWaP4cffnjoNBhLg5F32203AMkAVH1jSXvK1jcFBh7qG4PWWSim3Pc/P18DoN9+++2Q+Xasf0dLcOv4C1FoLRisXUoj0GLQz7/nnnsAJIPitOlhv379QqYlY5999gmd1mniXtS3GG26x2usjeyyDBBsCbpPhg8fDiC5v7XO08ILLwwgVw8KqH1tmTQrmjZKZG0tIBegr3V0Vl555ZC5frWwCBRCrzNb5QDAvPPOGzKDOQtZefU+1LOWTYO1dgnX/J+/Vym4bhw7kAyG13YrtHjrma/rzvFpgorCYHqtHZTPOlsOep0Y7K1WssUWWyz1b6bVoVKo1/25/vrrh0zriAbba4uFpZdeOuRKWc85V7XSjx07NuS02mBqWVpppZVC5vei1gFigo5SydpqtugYY4wxpmHxg44xxhhjGpaKu660o2xagCeQM0Opa+ayyy4LmcGQahrs1q1byAzSyrJVAJB0bbAjuZrr9tprr5DVTcVroWXl00rMq2lSzbBvvvkmgGRH1/XWWy91jC0NqOTf0noaGszGa6nmwkqasLVOBGue6JyyQMfPYGFdU3VNaWD2NddcAwC49dZbQ7f11luHzPVRc7G6Xhl4qK6HLPaqfmaaG0P/X12WDIzed999Q6euEQazFtNiIGu4f/U+4TkBJNeVrkdds0KtI9J0WbclSUPHobWzNNhU7/80OFbdE6effnrIffr0afI5Wc+V5xTDEoCk60xrdrFT+3PPPZc6Pn5vaG2ht956K2TWwdLaQJpkoW68Yl3/es00MYVnqQbIa1C4fn+1FJ2zJuvQja51kLR+Tyl/qxDcS7p+7KIOJNs5MYj+u+++C50GU9OlrNdKQ0JYU0kTYNT1X8r3ki06xhhjjGlY/KBjjDHGmIal4i0glHx1AqhnJgwAXHDBBU1+Vmt7aM0FmtmzyATReWg7BLpbWJ4cyLmzgGQmVEtNa2pa1gyeMWPGAEjW28nX6bul8JqrC0lrO3DMWdUW0ev67bffJsb0z//P4m/2798fQNLdqFH/6vqgSVxbcIwcOTJkXn91A2qnZZau1zoSWbtZae7Xv6nuKDUTM8NGXQNcEyBXzn6jjTZK/Vu1yMDiWmom5ocffhiy7muaubWFDNvOAOl1TLQFDbu3a9uLfF2bKwWvr66DdhfXDE+i66Dzp17N/eq64blTzTpCvGZ6zmnbHrZNAYArr7wSQHL/qpvbp0RjAAAgAElEQVSbLQK0Y7e2A2KtF20roTXb6JoGcud2KWuqYRoMTdAzoZLnm7b64d/Sz89iT6bted1TWhtMs6qJnjmsrQPkMu/YCggA7rvvvpBZv61z586hGzJkSMjaCb2lZ5EtOsYYY4xpWCpm0SmEvhGy2eNRRx0VOrWC8I3j6KOPDp0+MWZpydEnYw1wYzDgnnvuGTqt41PMmDi/fHV4+KSrlXW1PkMpT+9pAYrHHntsyKx/pG9J5QYj5wuGZRVMHUvWVgK+fehbis5Pq7BuueWWAICNN944dGr9YDC8WveGDRsWMpv2Zd18MO2e0srPrAAMJK8vgzF1/2r9K9bnUItXLWvL5EPHpG+8tN5oZXatOZJWp0STBbgX1KKilVsrZQlJq2ystX802FbvFZ5B3GdA0iLOffHLL7+E7tVXXw056wbIzcEaN0CyaadWAb7tttsAJGv7qMU8zTqidZL4WdpUk7WDgGRgN2vdFNrfackammzA+mPaqFKbPuu9xHnlsxKmBT6/+OKLIXNfa+XvfI1Yi71v9efVOsX7S8dc6MzWPavWL541ahHS+4uB1WqFYyNeIHnWplm30rBFxxhjjDENix90jDHGGNOwZOq6UtObBgYysFhrYmjg0gEHHAAgWQehWqZzdbHomFniWoOx0sqSK2rm05+dNGkSgGRTUC2BvtVWWwFINlKsVDCo/q6a69muoJKl0tMaeQLpTQmzppAbKW1/aYDnww8/HDLbYWhNCS33Xq0gTx0zA8s1mFVdV1ozh3U4tPbPiBEjQj7yyCMBJINBa90CgmgNFHVtsCktkFtrPVPSSswruma8PzWAMmu4ll9++WXq/6vrhvVndH10L3L+6i7o2rVrk79VTXivayCpXl9t8KitZ4juv7S9qOcj153NhYFkU1RNPCgWvXYaTsAWMtqIlfW2gOT8rrjiCgDJAPg01F2uLWboktTEilLDKAjXR2vbsd4SkAszYY0ioPB3Rb5g6bSf1f3NkAB1Vx122GEh6/qx1pddV8YYY4yZbvGDjjHGGGMalkxdV2o6HjRoUMhf/X/2zjrqiqpt4xfrk7I7sbATGxVb5MVuUBFbUUSxxcDuwlYs7MZOsPVFRVQs7MYEVCzKb63vn++6zzU+c3jqzJnzDNfvH+5185xzZs/es2fmzm+/BZB0XbDjNwAMHDgQQNJ1UC1zq0aKawsGmtvUBaLHr91b+bdqotNy4HRZ3XXXXaFT0yazPbLueJ23O6IWM3mAkhlcs+60pk7Pnj0BJMvWZ51hlYbOHzP09Jgff/zxkNUMztL16iJQNynrN+W9PhQei9YJ0hYzWlOHbor6XIhqLlc3BM8lXchA9vPLvUTdGeoGobsUKNWE0kzBtLlKq12WF7ymTjvttNDp8Wk7AWYQaYsW7X5NdH7VZTt48GAAyUwlzUrT7t7NyUpSttpqKwDJFkGatadz2adPHwBAx44dQ6cuWbqPNIOL7lSgdA3stNNOoWtMNtT00PuYuoaZtbb99tuHrlevXiFrzTeeI3Un1hemoOv7mWeeAVCqpwSU2roASTd0Q+fPFh1jjDHGFJZW03simjJlSqNfA9Qi8vzzz4e82267hcwg5HXXXTd0rJ0AlIIos3qLatu2bSsAmDp1ap3x6fE//PDDIe+9994AkkGn55xzTsj6RMsgNH2j0Lfr8ePHA0hacS6//PKQ+cTa1PG3adOmFQBMnjy5aq9xet7Y4E3fiDXIkudCK+82pvZDu3btWgHAtGnTKja+tGau2qh15MiRIQ8bNgxAMsCzkgHIrVu3bgUAf//9d4PHxzcmPY/aVE/fCFlxXC0C1axpNPPMM5e9/uqj3JuhjpV7iTYaTBuf1knSyrs8P019S+b115jxcf3pPqHBpmmJD3qdqPWblnStraKVh5tbWb4p4yM6Dxr4euONN4bMKuRjx44NnVoaiJ4TraPD+0qPHj1Cp3Wi6ttrmjI+jksTbLROnDYI1rkiacHUmhijDS5p6dhoo41SP1/f/tnQ8en38PhpLQOSyQy61ngO9Jg1MSIt8FkrI7NysjYn1ftjfV0COD7FFh1jjDHGFBY/6BhjjDGmsFTcdaWmJG0xoOW+6Zp56KGHQqem46wD/6bnulIToJZQZ9l1bQ6o5czVtErXh5ppNcgwrUS5Blk213VQK64rtlIASmW9gVJNGnUdNCZwMgvXlf4m2ygwaBBItiChe0EDCCsZ7NkU11Ua9QUA5hWg2hzXlVKuTpOuxelRrrZH2nlpzLlqjmtHTfhnnHFGyFoTJs2No8c3xxxzAACefvrp0Gm7gubur80Zn1KuzhgDU9UdqTV3OFccJwAsvPDCenyJvwOqN386Dj1+rZNG15w2IlU4VwyXAJJhHtrskmQ9Pl5TWo9IA6xHjRoVMl1vbDQMJJvx8rt0HWoDXYY0dOvWLXTqZq9v/dp1ZYwxxpgZCj/oGGOMMaawVKyODk12P/30U+i0+66am+gGKtdxNU/0ONQ0yu7QGlVfjjSXgdbsoMujUm0dag2OS8fETBagVJo+79oeis4F50q76w4ZMiTkhnbMzZtaP77m0pgS8y0FrVPCjtgAcNVVV4VM14BmemodGbZz0TotedR5qg+dMz0+up40uyZtTy0353mOVY9D3TEaxsGaNFo7RmFIhNZR0/GnZd1lDX9Ta8tpVlSXLl3qfEazxhrT6Zzzn/b7TcUWHWOMMcYUFj/oGGOMMaawVCzriqYnjSRXc5ZG/V933XV1dFpwLeuu1tPLuipHcztup5nZszI95pF1pedlypQpAJJl19UM279//zqfb8y5yCLrSuFYys111q6RSmVd1SqVyrqqVZqTtVMuk0zlhl4rWa3TSmVd1SpZjC9tLsvtL2n3h0reK6o1f5W4VzYFZ10ZY4wxZoai4nV01DKjtVM0sHeBBRao87dZW3GUplh0WhJ5WHQUWr9o2fn/YwmZa6Gpb5xZW3Tyxhadlo0tHi0bj69lY4uOMcYYY2Yo/KBjjDHGmMIyXdeVMcYYY0xLxhYdY4wxxhSW6VZGLnqwZ1OCrVsCDLbOKxg5axiMXPRguqJff0Vfn5MmTSrk+Nq3bz9D7J9Fv/6KPn+KLTrGGGOMKSwV63VljDHGNJT6SooUPX5U++ulFYRsyT3bag1bdIwxxhhTWGzRMU1GO87qG4kWgjTGGKL7xN9//52qb9u2LQBgpplKtye1brR0Sw/H9eCDD4bu6KOPDnnfffcFABx//PGh0722pY8/D2zRMcYYY0xh8YOOMcYYYwpL1VxXapqkGa5cR16aKR2MVZtw3t57773Q/fTTTyFvsskmib+bEdDAwvo63ad1JW5J7r60cdWSOZ3HV861yn3lf//3f6t7YAatW7cO+eKLLw75v//9b8jrrbceAGDbbbcN3YorrhgyXVstCd0fvvjiCwDAwIEDQzdhwoSQl156aQAz1v6ZNbboGGOMMaaw+EHHGGOMMYWl4q4rNWGr6fiPP/4I+dprrwUAvPnmm6FbcMEFQ+7ZsycAYJ111gmdmv5qyUzeFOoz/fP/dcxKHhkIesyTJ08GkMwU2HnnnUOm66qlkjY/6ubg/6u76auvvgr57rvvBgB88803odO57NSpU8hLLrkkgKSZPmvSXGtprmPVTZs2LeQpU6YkvgcA2rVrF7K6J7J0P+vx67F89913AIDLLrssdDoXO+20U+Lff39XHvD3G3Ic9V3ztbw/6rHNPffcIT///PMh04118803h26NNdYI+cILLwRQcvEAtemG1DXJPRMATjzxRACldQoAjzzySMhdunSp8121PKdNpT7Xfrn9qb6/TcMWHWOMMcYUlopbdPQpdty4cSHvvvvuIfPtqnPnzqH78ccfQ951110BAP379w/dUUcdFXLeb1/1UV8wJN+O9Vzp39JSMHbs2DqfAYAOHTrU+VzWT/x6fHfeeScA4M8//wzdfvvtF3Ktz08aaW9f+pY1bNiwkGebbTYAwKhRo0L30Ucf1fl8OfRN9eSTTwYAbL/99k046oaj6+Pnn38GAPz++++hY4AkALz11lsAgC+//DJ0r776asi8fvU7N91005DPOuuskFdaaaU6f9scdG3p+rv33ntDPu644+r8rVqMX3/9dQDAp59+GrpTTjkl5KlTp1bkWOsjraZMudoyev7SgnH1+pxlllnq/H+tJHao5aV79+4hq/WNiQ3LLrts6GadddaQf/nlFwC1v8/onF1wwQUh33fffQCSa3bjjTcOmeeopVpx0qwsaR4Zvc70bynrWmnTpk3qdzV0XduiY4wxxpjC4gcdY4wxxhSWTIORr7rqqpC1zsrjjz8OAFhuueVCp66ZRx99FEDSnKyuL7pu8jbHljPNcSyvvfZa6DTYjqbXJZZYInQagPbEE08ASLo4ttpqq5AvuuiiZh5549H5eeONNwAAJ5xwQug0ALUWAwPT0Dl75ZVXQr7hhhsAAE8++WTo1E1CN8Ecc8wRurXWWitkBt6rO0sDlxdZZJGQt9tuOwDJc6ZuiOag61OTAfbff38AwIgRI0KnwcTt27cHAGy44YahW3fddUPecsstAQALLLBA6PT49XvpuqoUur9cfvnlIZ955pkh0/V9wAEHhG6ppZYKmS67G2+8MXR6rTGwXs9JpdwIOrdvv/12yHRh/vrrr6Er57qad95563yvtktYffXVASQTBDRwl3+bh2tEr7mPP/445IkTJ9b5m/Hjx4funnvuCXnmmWcGUJu1p3TO1N3LAGqgdN9jvSAgvbZWue+lnPf9T0lLptFjpjscAB566CEAyQQBXb+8RjQEgOECALD++uuHzOeC+tayLTrGGGOMKSx+0DHGGGNMYamY64rmRs2euv/++0Pu27dvyDTdqelRTbrM4JhrrrlC99tvv4W86KKLVuqwG0xaJhXriQDJDKlzzz0XAPDUU0+FjpkuQMnkqOY6HRPrK2h2lZrh9XNZmp/VzPz111+HPHr0aADA6aef3uDjaEhNhGqgY1LXEjsGA6Xzr9krrO0EAHvssQeApAtKzfCDBg0CkHTnbLTRRiGrm4U1dSrlutJzq+5EzTB68cUXASQzQfbcc88631Gu1D7PYX1Zhf8+nubA39JxqDugW7duIdMlpcevx8EMDq19pHsV60Dp9VepcZSrIzPffPMBSGbfdOzYMWQ9v59//jmA5HmeZ555Qub80gULJMMA9tprLwD5dMTW31F3RNpa+uGHH+rogJJLsZZc5Lwm1EWs1/mkSZNCZjZxOdcvKbdnMjNPXau1lIHGudT7H9ccAOyyyy4AkuEY+izAc6FrQtf68ssv3+hjskXHGGOMMYXFDzrGGGOMKSwVd11pF9ZPPvkkZJa6B9LNpKqj6UpNl8OHDw955ZVXrsAR10+aOV6LyD399NMhswgUkDRTEjVTM8NKzdTvvPNOne/VIlrVGnM5zj777JBXW201AEnTa1oGgOrU9chspUplFzUVzaTSuWZWh7q5VllllZBpZj3iiCNCp5lGdJnstttuoVMztroZKp05ocdMFwcA9OnTJ2TOG7OrgGQnembozD777KnHyWu1XKZIFvPK79frRF1Teq1Qr+4APS/ffvstAOD9998PHTO1gJIbKQt3jp5HdVcPGTKk0d+la1YLqvH6euCBB0KnxR/zRM/pwgsvHLK6ibVoItHQABYPrKVMT84FM2qB5FpdbLHFQmamZTnXVFqLmWuuuSZkZi3p/GoGaB6hAXrNM5tKQxsGDBgQMsNYdP9pzD6Y1q7GLSCMMcYYM8OSaR0dfUrTwM/NN98cQPItRGGQrwb7ah4+8+vLBRtWCn0LZG0fBqICyaBgrW3BIKu11147dJr7z2AqfUvRYEi2u9AS6Xk08lS0DhCDyXT+tOYBn+5feOGF0OkbN4NF1bJRrTHpeaRlCgCee+65kM8//3wAwC233BK6c845p8536frceuutQ+b8adBcOetIpdE3Gw0GHDNmTMg878cee2zo9PwzyFqbtmqwch7wnI0cOTJ0G2ywQchqHeB1q9evBony7VJbYPTq1StkvmlmXaelvtop5eAcq+WDjTAB4IorrgCQDJY/7LDDQua+VUt1WBSed20RoMGsvG6POeaY0GlNtloKzCVaZ4sW1XLnn/unWmS1BRL/n61MgOS9olrWLT3PuhcOHDgQQLJFjt4LeS/Xc5IWGN+QeWzoXNuiY4wxxpjC4gcdY4wxxhSWirmuaIbToFutHaJ1HN58800AJRcWkDQjDx06FEAyGFkDl/IwTS600EIAgH79+oWONVCAZDlvtnZQ15a6eRistc8++4ROg10PPPBAAE03bWeBuuwYDKe1fTTYnPVJtG3H/PPPH7KelzzRYMY555yzjr5csCDrO6k5WU3rDJYs58bNEv0ddTfp+qLpnEHXQLJOBVsraLD14osvHjKD6KsZAErTtq5DdQefeuqpIffu3RtA0px+9dVXh0w3sboul1lmmZBrpbVAWndzoOSa0hYzL7/8cp2/1Tpk6gbhHq3XYR7rU4Oxr7vuupDpWtQA+e+//z5kBpM//PDDodNrkS5Zvb7z3j812J0uVT0X6mYdN24cAOCggw4KnXZv51jYigcotWXJCz2/bB2z5pprhk5dzqxZpuPTvSaL+7stOsYYY4wpLH7QMcYYY0xhqbjrasEFFwyddpzVOjPM/9fu5qxdAQCdO3cGkMwU0ayKapUA1++nmVzN5WpuTMuKSjNHAsCRRx4JIFniXbN6aKbMuzaEjondlYFSTRx1Ta244oohs36E1s5R1wFrZuRd70Gz3g4//PCQmWFWLiuQXdu1bYSS57zpOVXXFGs3/ftviK5V1r946aWXQnfbbbeFvM466wDIPutR4VpUF9PgwYND1vpWdJmrazwtK1BrQ2k7gryvuzR0fv766y8ASdeUXqsct3af16xHutbVDa/7a7Xatej1xbY/QCl04d133009Prr+tTYU3XlAKZtH24LkgbpANQOSdXS0hYPOL/9Ws5a6du0aMl16GhqSRYsSXQc8vnLhFDqXDGnQz+u+y6xWrUPHthj//lylsEXHGGOMMYUl06hQtdIcfPDBIe+9994Akk+EGhjHYDqtLaPBknmQVoGxXNAin1755gUkx8/xsZ4MkKzDU4tvlDo/F110EYBkFWwNHOcTPd9cAGDnnXcOOY/6HZw3tRKeddZZIT/22GMhs/6IBoDq+BmErm8peQSw6jrh+MoFmNZ3zvX/WWVVA8x1fjnWck0/s4B7hSYlaLC1ri/Om9Yu0iq1rL+j1cbzDlZNQ49JzzXXra5frcZOS8cOO+wQOq0CfvvttwMo7cNAqZEpkDyvtP5kcX7KfSerCPO3gaTFg/Oq1ZS1mfSJJ54IANhss81Cl3UVdo5F15xaYbQmFxskq5VN54cWVb0mtY7Z6quvDgBYY401QlepPVXPE4O+gVICilZ71/u7zk8aWseK4y9nMc8CW3SMMcYYU1j8oGOMMcaYwpKp66qcOU2DJImavmh6VjeRuklYGlzN9NUyPZf7nbTj1xLlajpn4KQ2xayV2h3lSGvaqIHnWieHgcl5N+3UOaHpV2sX6fGxbDlQct1ogPi6664bMl06ebjgdM1rsOKTTz4JoFSDCSjVfgKS5yItWF5rzjAI+ZVXXgkda9MAJfdRHu6ecsGQGtjJ49P5Tdtzav2aU3QvnDhxIoBk2wd1EzOwV8en52f//fcHkHRt6VrOY19V6JItd0xsUKruHnWDMMmgmmPib2k9rptvvjlkrdl07rnnAkgmCCgMnNdj3n777UM+44wzACRr62SxF+n+MHr0aADAM888Ezp1DWqLB1532sJj0KBBIXMv1kbIaftTJbFFxxhjjDGFxQ86xhhjjCksudTiTzNNpZne1JylLSKYgZV3K4Fy9SZY0+GJJ54I3V133RUya4G0JNN5GuU6qtcXgV8t1HXBTBMtJX/SSSeFrHV0WE7+l19+CZ22+GC2QR6ZgHqe1Ux+xx13AADuvPPO0GkdFT1+1m9Sd6qakekG0zotWjOJ110tZQemubR0fWp3+rxdqs2Frm+20gGSew1rAtU3P5rpWY48QgJ43Lq/ak0nun60NpKOldlkeYc2aAsK1k4DSm4obeGgLZKY4UgXFQAceuihITMDLwt3lZ5HrV3EOmjqzr7yyitDvvTSS+t8h+6PmkHHDC7tOJ/1/NTGHckYY4wxJgNqo7sikk90fCNhUCiQtH7USs0LtVxoYOgNN9wAINloUN+oa+X4K4m+vTDI7sUXXwxd3mPm+kmr9gkAF154Ycj33nsvgGSA3U477RRynpYM/e2ll146ZAYJagXqBx98MGQNjGTgptak0SrdrJirlWe1qWctWXKmhx6nWnTytgQ3FF2rWmWcTS979uwZOtZWARo+P3lfkzo+DVw97rjjAAAvvPBC6H7++eeQWZNFLQashqyfV8tdHokD5erErbDCCgCSFo1PP/005JtuuglAsmaNXqvV8gSkVT7WauNs7gsAv/76a8hp60/rCzExoJxHwJWRjTHGGGMagR90jDHGGFNYatKGSzeImua/+uqrkFmnRkuAV8sMq+ZQbdSpLR66d+8OAOjVq1fqd+RtMs4CNUOyjgdNsEA+Y9ZjYoM/BsIBwCWXXBKyurFoOj366KNDp+0Q8jCD1wfL5jNQE0g2bVQ3Ik3HHTp0CJ02y6TLWE3ItTjm+tA51ZpCNK3XStB8Q9A6QGyAqG6EajXirCTlmkLut99+AJJNd7/44ouQOW69JrXODOe6ltasjjXNja71r3r06AEgnzpr5dxGaS2Q9PqpL7Bdx8/vytpdpbScK90YY4wxppH4QccYY4wxhaUmXVdEWwyMHDkyZEbbZ23uUmim047WJ598csgaFc/us2qOrSUzahbo+OgS2WabbUKn3WuZVZc1Gv3PDJXPPvssdFpzRsvJsw7HlltuGbpadwekrS91TWlH6rTrJq3Tea2PuT50nJpVxv3jgAMOCJ26Mfm3eV+z5Vw7rPNU7m9bOp06dQJQqg0FJK9PhixopqeGFLSUc6HHueiii4ZMN3Qt1Vmr717blHNe1ft31X7JGGOMMabK+EHHGGOMMYWl1fRMTtOmTcvFBkiTlpb9HjNmTMg0w2v31saYzlq3bt0KAKZMmTLdD6VlMpx//vmh06yiYcOGhUzTd16F1dq2bdsKACZPnpyrDTerTJB27dq1AoCpU6c2+ks1U4Cl1v8ts1z53HPPHbpqujHatGnTCsjv+ssaXn9Zr09df9pC5tZbbwWQLAi5yiqrhKxu6KbA9Tlp0qRCzl/79u0btH82F52/+vaSSu4v3D+Lfv1lPX95wflTbNExxhhjTGGpSYsOj0nLZuubOIO09C27MYFNTbHoTJkyBUAyqFPrrKS1eMgrKK5WLDpZ0RyLjpJWOwfIPxjXFp3Ko/PLfUX3j0paX23RadnYotOysUXHGGOMMTMUftAxxhhjTGGZruvKGGOMMaYlM92Cgc2NgahVGAPxzz//FHJ8M8000wzhg/3rr78KOb5ZZpllhogRKPr+4vlrmcwo81f08Sl2XRljjDGmsOTSAoIZEJr1oi60vLOWKkW5OhB5l5bPmrQMuBlp/MZUgnL7Rxpp+6dp2ej9UWnp+yfHVc1x2KJjjDHGmMJSNYtO2hv9xIkTQ9e2bduQWZm0pb+ZsHkgkGxKx4rOWieoJaJzqm8frDnEf/8Nm/KZlkNaHRptOliL16quSb3WuP9o7ZxaOX49Zt0/tCku0WPW/ZPXl35XXlXamwLXWrn9hbKOP20ua2VOG0La/fGKK64I3SuvvBLylVdeCQCYb7756nymVtHj++233wAk7wPaoDULbNExxhhjTGHxg44xxhhjCkumvpNywXTPPvssAGC//fYL3WabbRYyTXOzzz576GrdNKf8z//8DwBg6NChoTvhhBNCfvLJJwEAyy67bOhq3bSs88fxqWvqzTffDPn2228HAIwePTp0kyZNCpnnhc0zgZY1vzMK6i7466+/Qn7rrbcAAGuuuWbotBFm3i4Drs9ff/01dM8//3zIXHcrrrhi6Nq0aRNyHsfP6+v7778PnTYQ1uuL7WZ0TtSNyPFpu5rFF1885Frca9Kadk6YMCF03333XchffPEFAGC22WYL3eqrrx7yHHPMAaC0DvQ7awkds87f9ddfDwA4/vjjQ7fFFluE3K5duyocXfPR8d17770hv/DCCwCA8847L3TaQDkL16MtOsYYY4wpLH7QMcYYY0xhqZrrSs2sAwYMAJA0TaqbZ9VVVwUAHHXUUanfVYtmSIXH+umnn9bRAeXrI9Qaesxjx44N+a677gJQcmEAwEsvvRQy51rHqa6rO++8E0DSnVdLpNUs0QyYtPWnZvKWMr/1oefh4YcfDrlPnz4AgHfffTd0Sy65ZMh5XJ96/pnVoab/m266KeQFFlgAAHDttdeGbuutt876EKcL3Uk33nhj6Dp37hzycccdF7K6bIhmsN59990AgN69e6d+fsstt6zAETcfXV/qBr/wwgsBlFwcAPDll1+GTDfWzDPPHLpOnTqFfPnll9fR1ZK7juOeOnVq6G644YaQTz75ZADAQgstFLrTTjstZM5/rbr7OT69v+v6O/TQQwEA48ePD51ev5wrddE1111XjB3ZGGOMMSaFTC06+manT9+XXHIJAODcc88N3csvvxwy6wPoU16tPr1Oj3J1cmrdIkX0jUsDi2+55RYAwFJLLRW6Qw45JOQuXboASAaDqkVg2LBhAIADDzwwdPPOO2/IeQaDAqU3rUceeSR0gwYNCvmnn36q8/n1118/ZAbZLbLIIqFrSeuXFilaRgDg5ptvDnm55ZYDAMw///yhy2PO1HKmx0pL8P333x86DXb8+++/ASTXLBMgAGCnnXYCUN06Qfz+3XffPXQarK/B0mlriQG4QOntWQNY+/fvX+d7V1555dDlYfHQa04tNvEDYbEAACAASURBVBdccAGA5Fu81gnq0KEDAGDy5MmhGzlyZMivvfYagJJnoFbhfRAAzj777JAXXnhhAMAdd9wROg22rvW9hNelXn86l59//jkA4OCDDw7djz/+GDLv+2eddVbodthhh5CbslZt0THGGGNMYfGDjjHGGGMKS9VcVxp4xfob6ppabLHFQu7atet0v8tUBzWRduvWLeTVVlsNQLIEuZrWiQYYvvHGGyEzyFBdQPpd1ZprNZ1rsPQ555wDoFTPAkgGI88zzzwAkuN76qmnQu7bty+Akom9JaDngmM9/fTTQ6d1aK6++moAyRLu1TKn63Gq6+LEE08MmTU7tKy87j9EA3g5JqDk2qmm64N7obqD9TpQN1pDUXeHBiA/9NBDAJJ1hKpF2joDkmEMdN2o62KFFVYImUkQuj71XkKXXH2NUKuJHt/7778PABgyZEjoNMyBa3nttdcOXa27q9L2Ug2w1r108803B5C8fjXMgdftnHPOGbrmulZt0THGGGNMYfGDjjHGGGMKS6auK82KYKYNUOrKOmrUqNDRXQCUTJe1bq4rOmqO1Ky5jh07AkiaE9UMPWbMGACl7Akg6do56aSTAADLL7986PKYa/3N++67L2S6MZhdBJRqcwClOiy77LJL6NS1QJdV3u7WtEwyAPj5558BlK4zIHmt8lxoJlKvXr1C7tGjR+UPtoHomL766quQ2VYFAOaaay4AQPfu3UOnx/zoo48CAB5//PHQvfrqqyEffvjhAIDhw4eHTt1gWc5rVt+tLTp43vJen3rNaIsLutTUXa57zcUXXwygtI4BYP/99w+ZLru87x/lXOOXXnopgGSm2a677hoy12re89MY1PX2zDPPAEi67jfYYIOQOZd6TXFPVSo5f7boGGOMMaaw+EHHGGOMMYUlU9eVot3JWShJi0D17NkzZJrRa6lsd1NQ02O5Tu61jBZhY5EnoDSub7/9NnQs0gWUStBr2w91/bAoWh5tPdRFQxcbAJxxxhkhL7jgggCSRfKYaQaU3BxqOtfigOUKRVYbPaea9cFCf2o6VtfBscceCyCZ9cGy/EApG6Ka1yfnTTM1tOCarsV+/foBKLk4gOSccC/S4nzaLoEuBV3zmvWTx1rVa4Um/XLHwb/VrEANE9h2223rfH8ebh79fb1+mJWp3ddZ5BEojWXnnXcOHdsmACU3e973D50zbZHDrDeGAADA0UcfHTKzGfM+/vrQ8WkGI+dCMyH1Xp+2frNef7boGGOMMaaw5PLqyTd9fUq/5pprQmbTz5beAqJciXo2pVt66aWrfkz1oU/patHQOhd8Y1KLjb49MshQGz1qYCHnNe83Fp2ftGBTtroASgGsAPDOO+8ASM6pBruyzk4tBRPqWFnzSJvO7r333iHz7UsbTGqwYFNqujQXrstx48aFTmszaaPLrbbaCkDSiqPHzO9ad911Q3fRRReFzKalfPMGsq85k2aF0bY4WqdqrbXWApCsY5T2XWyeCwA//PBDyHotVhu9JvQtX5tWbr/99gCSAeIKLYoDBw4Mna5PTYzIE11zt956a8h//PEHgNJ9DgDWWGONkPPeFxuK7ilah4qJD9oWh2MGgG+++QZAKWkASLaT4fqt5P5pi44xxhhjCosfdIwxxhhTWDJ1XZWr4/HJJ58AAM4888zU/7/tttsAJGt3qGuhpbix1LQ3YcKEkNkJfKONNqr6MTUGBi0CydL0LJGvtSHUjfXAAw8ASNYp0U62Bx10EIB8grJ17Sy77LIha2Ar6/988MEHodPxcf60RYB2YqeboZbWqa7F33//HUCpyzcAfPTRRyHTZaUBuLViTv/zzz9D1o7H6jrccMMNAZQ/ZprE9ZxsuummIXOts1S/fgaoXhA9g3IB4Pzzzw+Z86ItEv7zn/+EzDpI6m6+/fbbQ6bLoFbmFEi6Lujy0Y7Xei0x5EFbQFx22WUhc3x5X3/6+x9//HHIrF+lHbl1LXJeVJcWOK5rL48A+c8++yxkDTwmnTt3DlkDr3mv1zpYO+64Y8hct1r7qbnjs0XHGGOMMYXFDzrGGGOMKSxVy7pS0xNNUlpbhx1ngZIZkqWyAeDII48MmVk7tZTV0hhqpc5KfeZQdVcts8wyIaeddzXnb7HFFgCA7bbbLnTaToBZFVo7I28zurYLWHPNNQEAs88+e+jUDbfPPvsAAPbYY4/QqRss77EQnRM9JrZb0TH1798/ZLa2yMM0Xg6ORbM3xo8fH/J+++0XMveX+uZB17+W42c2mprbs4bnVzORTjnllJDVTUo3q7pLNWuHrp977rkndFoHKs/1qZm0DGEAkm5UZi2qa0pDF3h/GDp0aOj0XsK1kLfrSkmraaXXp65FoudH60Rxr1HXjmYwZQGPVTPJBg0aFHJaTSB1p7I2GVAaq45J3XjvvfceAGC99dYLXXMzPW3RMcYYY0xhycWiw6dzbRSpT+yHHnoogFKFVqDUKAwoPSnmUVm3qagVh0GuGoCdddPAtDod+sbH2hoLLbRQ6PSNKO0tsNwbCYPMNMBVawax/ketzhnPwdixY0OnwcqrrLIKgFK9FqC23h6Jvj1r5WpaSjUYXt+e+aZYi2PS2jH6FqvXUhq6VnmtaTA9EyCA0lo+4ogjQlct65Z+t9bO0crx22yzDQDg119/DZ1af1g9Wi2ytVKNXY9DK08zwB8o1VRTi7DCit3aCPO5554LmedKLR55V37WOkwPP/wwAGDfffcNHRM8lLfffjtkrcLOa0DrQA0ePLjO/wOVW6v8Hp0/TSbSYPlZZ521zuf1/PM7FltssdCpxYZyJdesLTrGGGOMKSx+0DHGGGNMYama60rN6FqunaiJjfUT1NynefosgT7ffPOFrlYCQMuhrqnXX38dQNKNpGbqLF1Xaq5nvRigFOzIGg8N+S4952o6PvXUUwEkTcdq5mSQby26RoBSCXltgaGmdQZDLr744qGrlfWn5nIt+7/XXnuFzOtGWzxo4HUeLR7qg9cEy/8DSTdrWs0RvY7UtcW51Noyzz//fMiHH344gGQAb9bwmkpr3gkkx0KXv7oIrrvuupDZQPeQQw4J3fXXXx8y99e8Xcd6T9BgVrpUyzV9pBtcA1g1sJ4B6xoakQe653fq1CnkRx55BEByT9F2JkTPj+4vDMLX2k/Vck3qdTb33HOHXF+Yg8IwjhdffDF02g6KrYMqeX+wRccYY4wxhcUPOsYYY4wpLJm6rtT0NMccc4Tcu3dvAMmy2JqVw6yBESNGhC6tO3ato6ZHJa1mQrVQE6e2NaAZUU2s5cyhdANobZwzzjgjZGZFaPdvzQCpRZeVzhVL71911VWhW2eddUJmhlrepn+Fa0pdkyeffHLIbPsAlMz8munRUq4p7UytY7333ntDpktL3bAjR44Mmdk8uidpTZC07t6Vmmu99jVrit3Tte1NuY7pvH7URaBZncwW03FoJ/MDDjigzufzQPeXX375JWS6dLp06RI6vT5Z84itZoBkzZVaaQGh9yxdfzzvG2+8ceh0rtMynFjbCyjtperuUzddlqEPOk86vg4dOtT5/XJ1vBi6sfvuu4fu7LPPDpn11Sq5Pm3RMcYYY0xhydSik1YNEihVlr3iiitC99hjj4X8008/ASgFbQHAnnvuGTLfxGrpjVrhm8TOO+8cutNOOy1kfRKuFjwmDWDUOkWsraIVYldaaaWQtYHiU089BQD47rvvQqeVq4855hgAyaDzvN8e09A3jnHjxoU8cOBAAMkA1uOPPz5kWkJqaUy8FtQKpY1UhwwZEjItbnm/8TYGjm+BBRYInVZe1fFx3+jatWvodK6Z2KC1aTSwkm/HWe8vaYHjWjumX79+IWsVZF5XOiZawYFSxVm9ZjUwvRbnXatcs+I4r0MgGYRO6xcr6ALJvZbB1mr9qxZ6n9OmwE8++WTItLRpMoBaF9PmR7+X814uWDsL+Pta20eTNbSLAYPBtWmnVrFmTS+t/bP11luHnMW+aouOMcYYYwqLH3SMMcYYU1haTc88O3Xq1ExstzSDqbtAzbR0jbA5JACce+65IbPBZLk6E/XRpk2bVgDwzz//ZDI+mhb//PPP0Gk5eZrGL7zwwtBpM7/mmsxnmmmmVgAwZcqUOl9Urk4HXYcDBgwInZZo18BAlh7fcccdQ6dNBbNuutq2bdtWAPDXX3816wfUdfDEE0+ETNO5msM18FrnKgtmmWWWVgAwbdq06Y5Pj5+B/RtssEHo+vbtGzJrGwHppu9q0rp161ZA0/YXNeHr+tSmjuuvvz6AUnNBAFhuueVC5vWn56+SLR64v9Q3f3ot0k2qtVWuvfbakDWYnEGsbH4JAMOHDw+ZzSC1zkyfPn1CZs2kpo6zUvOnrh02kgVKLnG9ztQNRdeGzrnW6WKLlqa6cxo6f/WhwfIvvfRSyAwJyKsOF+evMePjtTJhwoTQaSNdrQPE866tKHQvZWiDuqErOX6OT7FFxxhjjDGFxQ86xhhjjCksubiuiJox1czHctBaGyDNXdBU02vWrqs00rora9uHSjI915WS5sbS2jqayaFmSGY1aO2OproRm0KlXFd6zNoiga7T++67L3SawZO1mbmhrqu0rLH+/fuH7rDDDgtZXY95Z4s1x/Wh6PjPO++8kF9++WUAQPfu3UNHdzcAbLLJJgBK6xio7JptiuuDY1F3mmZnalZS2t+qa4f7pmYq6d82N0OnUvOn51xdImyxoi0CtJ0MW0TsvffeodNO2M0dX3NcVzomPee6V/L60+uwmt3lm+K6Inqc2rZB6+vwXq33b5V5389qH7LryhhjjDEzFH7QMcYYY0xhydV1paiZLy0rJIusiGq6rtJMk1m5eBrqukqjXHuKSp7/5lIp15WOQ9slMBvkjjvuCJ0WP8y6OFdDXVdKmjujmu7ExlAp14eStm7LjTnrc1GprB3dM5ri2shqnWbhemzKWLMqmFep+atVmuO6Uuqbs7zuGXZdGWOMMWaGItMWEI2hFsuSV5JaeqOeHkWfB0WtAGwLAAATJ04EkGyXUevnhesr70DjvKj1+WkKtWRFzYKij6/otKT5s0XHGGOMMYXFDzrGGGOMKSzTDUY2xhhjjGnJ2KJjjDHGmMIy3WDkaqaXVxOmDzYl/bolwPTros9f3uNr3bp1yGoZ/eeff5r1vbUyvqzw9deymVHW5+TJkws5vnbt2rUCgEmTJhVyfO3bt3d6uTHGGGNmHGomvdyYWiatONatt94aOu0r9J///AdA+eKLxhhjqod3YmOMMcYUFlt0KoS+8fNNPq2tRTm00BuLnzkjLl+047B26n3wwQcBAIccckjoBgwYEPKWW25ZhaOrLOwo/G95euj6TFu/ecHjb+g4gPQYq5Z6/XGv0fHr/LTUcZkkOr9ZtcMoCrboGGOMMaaw+EHHGGOMMYWlWa4rdc1QrqRZtBa7L6e5qICkafjnn38GAHz55Zeh+/777+t8V5s2bUJeaaWVQu7QoUOd76+V8c8I8Lx//vnnoTvzzDNDfvHFFwEAZ599dugOOOCAkLlGanXOOD41fY8dOzbk0aNHAwAmT54cOl33XOva0b1Lly4hzzLLLCFnaUbXY9KxfPvttwCA119/PXRpgeF6nHPPPXfIq6yyCgCgbdu2oWtJPcSmTp0KAHjnnXdCt8wyy4TMwPlaXZ+k3F6b9v8K56rWx9dUOO6PP/44dDrWZZddNlXfUqivE3pTsEXHGGOMMYXFDzrGGGOMKSyNdl2pifiDDz4I+dFHHwWQrCeiJqj6TNj6/zS9rbfeeqGrljm8HDSdatXbMWPGhHzDDTeE/MYbbwAAPvnkk9BNnDgxZJrh9FyqufHUU08FAOy4444VOXalPnOwntumnue0761FE6qeCz2+p556CgBw6KGHhk7dGHfeeScAoHPnzqmfr5WxljPtf/jhhwBK4wCA5557LuS3334bADBt2rTU7+L4NCtNM9DOO++8kFk9OotzotfPY489FvLAgQMBAO+9917o0s6FzqnuL3379gUA9O/fP3RzzDFHyLXixip3LXNfHjx4cOguv/zy6h1YM+G4NNPxpZdeCpmhAV9//XWdzwDAPvvsAwBYZJFFsjzMRlFur2nK5//44w8AQPfu3UOna3X55ZcPuRbXKmVds2n3nXKu6aaEtNiiY4wxxpjC0qxg5Hbt2oXMt6effvopdHzyBIB55503ZD7Jaa8g/f877rgDQPLJTd9OGCyY9ZtzWoDjueeeGzrWUwGACRMmhLzgggsCADbbbLPQbbjhhiHTKqQWoQceeCDk888/HwCw7bbbhk7fnpszbg0w1WNmsPSzzz4bOo65Ib+p/7/++usDAHbffffQVer4s+KSSy4J+eKLLwYAbLHFFqE766yzQl588cUB1M7bUjn0jUjfflm5efz48aHTsfD6VCuHwrnU6/Paa68N+YQTTgh5/vnnr/P9zUGvyW+++SbkE088MeTPPvsMADDrrLOGjgG6eiyqU3j9vfXWW6G7+eabQ55rrrlCbm5fs6bAeR0xYkTo1l133ZCff/55AMBHH30UOj0Xtb5un3nmGQDAEUccETq1jvO+w7UFJIPp//rrLwDAOeeck+lxNgbdd5mEUl9tNUX3zCuvvBIAsMQSS4Ruv/32C7lW6uikWXGA0n2HljkgGVg9cuRIAMDss88eOu5ZALDiiiuGzHNZ3z3FFh1jjDHGFBY/6BhjjDGmsDTadaVmzyWXXDJkmnbVHEwTIpCsuUEzlpqztKbMr7/+CgDo1q1b6C688MKQGfirn6mUO0QDpPT4Tz75ZADAPffcE7pNN9005J49e4a81lprAQCWXnrp0LVv3z5kjltNyw899FDIWZgeOS418TOAHAB++eUXAMlg8lVXXTXkhRZaKGS6HNWN8O6774Z8yy23AEiuD3Xd5eG64jnXc3vfffeFfMYZZ4TMYEa6MABg5plnDrnWTf9Ex6oBwjQdzzfffKHbbrvtQmZNmQUWWCB0GqysMtHA3uYGXk6PcgHIn376achcn7r+unbtGjLXtboThg8fHjJdP6o7+uijQ77qqqtC5rizdhfovvTnn38CSNZxuu6660LmvqXBvLWIrhMNfGfg8QYbbBC64447LmTWBNIA5VNOOSVkhkFkuQ7LofOkoQmDBg0K+bTTTgMALLzwwqFLOz79rmHDhoV82WWXAUiGO6ibJ+/9Ke3+/sILL4TMvei1114LnR6z3tfJFVdcEbLew5gwYteVMcYYY2ZY/KBjjDHGmMLSrKwrNRfRpKwuGjX369+m5dFPmjQpZGYzaVbFQQcdFHKW5mI9Js1A4jExowgArrnmmpA7duwYMseq5jjNzuD41fSoZnSaIRsTld9QpkyZEvKuu+4acr9+/RK/DSQzpVTmXGvUvJqWSR4ZKeXgvOqaOumkk0Lu0aNHyMys07Wctzm4Kej60awbugkuuOCC0O2yyy4h81xpppFmIPH/dS1pCwytOVMplwHHoq5xbauia22TTTYBkMwE05oq3D/0M5phRpeIZoWqm1ddmpp5WmnK1Rmh6+zHH38MnboZmY2jY6rF9Zt2/wCAAQMGAEief72XcK9kdiQAdOrUKeRevXoBqK7rinOl9dK0tpTu77w+yh0Tj5suSiAZurHvvvsCSNaZy3t+9Vz/9ttvAEr1rIDkvY73+rS2K0Bp3FqnT91Zq622WqOPzxYdY4wxxhQWP+gYY4wxprA0y3WlpJnhVKdmWJrOX3311dAxkhwAHnnkEQDJgnt77LFHpQ51uugxq+uCx7///vuHTt1VmjWQhrp+WBxJMyX0/4855pg6uua66fj5q6++ulnfA5QKsh111FGhe/LJJ0Omm1EzrdQ0zXNczewr/tYrr7wSOi0ypgUB6ebJ2xzcXPT8MqsOKJmZ1fWhWVN0SWl20bhx4+r8rZ4fZhoCSTNzpc5hWlsArkMgOVZm3WhBOb2WeC5YeA1IZnXQzaCf0aw1NblX2n2u14m6BvVY6bLRTB7dqzh+dc39/vvvIdfnOskDdX3QTZXW9gAoZS1p9p+24GE2YR77y+OPPx660aNHh8y2MkBpfym3dqg//fTTQ6drgS73cq7NaqHXhxYKZhiEZsUpdE1qEUBm0gGla5GtlICkm1Kz8Ro6blt0jDHGGFNYKmbRSUOfqLWmAN+ONMBPn1gZRPfOO++EjnVsgFLNEw2wrNTTuz4hbrTRRiHz6VJbVdQXbFuuJg+DQDWYcrfddgt54403buxhN5jGPPnr8T/88MMhH3bYYQCAH374IfVzDFLWt1ANct5yyy0BJOtIZG094frQdaaktaiorwGqrrm0Fgrl/rZaqHVA23GwfpAG07OtBVB6E1OLV5qlQUuxazBoFmPlXGjSgr5FqkXj6aefBpBsIaA1g0aNGgUg+cao64LzpwkQvXv3rnMsQPPepNP2D60HpI0477rrrpCPP/54AMk51XPOudQAXt1/WCurliw6aejxDRkyJGS+8atFWRsgc36qOT6un0svvTR06oVYe+21Q05bM7r/0NNx++23h04b8LImXTWtOGm1cbQOzplnnhnyyy+/DCBp0dfEBzawVsuvegTodeB9AkgmzrippzHGGGOM4AcdY4wxxhSWiruu1Gyvpm8G2AKlgEIN8NPuu/yOzz//PHTq2mEQMIOeKomawrSOA81tajYrZzpMq3+jwY50HXTp0iV0ae0GaqULLZDsZM7AMa1noGZIBonq/KtMM/xtt90WOnZ8B7Idd7naROqaoRlZ3SRaf4ctSrTj7uuvvx7ySiutBCBZm0YDWLM0qZcbn7bzSKuDpN2P6VJJCxAFgG233RZAsgVB1uPjmlAXlAYzqhuKiQHq7kk7Jh2fBkOyxPw222wTuuYmBnBP07Yv+v1ca+piUlmvD64vvabUDcy50ABk/d1FF120yeOoJhrAq2X/6bLTcIY8AnP1Nxl4rHV06GIEkveSNDe91ofiumU9ICDZwiSPJAnuGepa1etPk3EYbKy11bTeFK+78ePHh06fD7huTzjhhNTPN6U+my06xhhjjCksftAxxhhjTGGpuOtKzYba8Vqj5hk1riXK02ruLLXUUqGj6wgo1f/IOqpev78x5jIeP6PPgWRNEroBtDaA1vyoFZOyHseBBx4YMt0c6u7Rct0ffvghAGCrrbYK3RdffBEyXY5qetaaQlnAOVEXDtchUDpmoJRNpsek3YOZYaTd6Vn2HADOOeccAEnTrJZDr1RrjLSsMJ2z//73vyFrO4e0Fiz6ObppunfvHjrt3k03j2bSNSUTojGkmbuZPQUkx0I5LftNv0vbVqgbXN1ApFLXpH6PZq0xm5NuKSCZSfb++++HzGwyrS3Ts2fPkFlOX90heq3WIjpXdLP1798/dJoBy5prtdSihW0LtNWDZqWyLQdQGqvOyZtvvhkys61uuumm0LEFEVBynatrq9xabw66v/D8alsV3cfYlgIorU8NZ9DvovtLM7E0TIV1kjQ0ornza4uOMcYYYwpLpnV09ClOm86lNb1MQ98MVaYlqJpN2+pDn6j5dq8BxlqFlm8qK6+8cup38Y1ax5T1G3N96NM5x/rVV1+FTgMHOT61mGj9oUsuuQRAKagVSL4R6NtbfRWnGwrPn57zPffcM2Rt6snzq7UbtMHrXHPNBSAZYKhrkTUl1Mqlb3r6ucbOZbk1z7ckrb3CoHcgGSTJwD5dU3otsk7VwQcfHDoNRubfZm15TKtXo80Ndc1pZWdaMjSAOM3is8MOO4RuscUWC5lrrpLXGY9/ueWWC93dd98dMt/uy70Fq3WG1gOtLH/rrbeGzAaKeu2oRTXLOl2NQedErVPcP3ROaSUFSpbEvJsG6/rv3LkzgGRQu9b20WB9Wu0YFA4kKyrzXOj9Qy1CrGOWVm2+kuj6Gz58OIBk7a3NN988ZL0uWXlb97wRI0aETEuO1s5Ri7fWvyLNHZ8tOsYYY4wpLH7QMcYYY0xhydR1pTTGzE2TmQZzabn3bt26AUiaPvMIRtPf15orNL1p0zkN7GTpcq0NoGY+tstQd4HWD1F9tdxY+jucn3vvvTd0b7/9dsg0rWuwqpreibpTtE5NuVowzYHHr64BrQOjbrjHHnsMQNK0rGZ0uk71nGjNkvfeew9Asimtfr4pa5XnRK+jW265JWTWnNCml+q60bWWZvrXueD/l6tdkYfrlOds6NChoVPTvSY20LSvTQXfeuutkLkWX3jhhdDR9QBUr86RBtOm/Xa5ml50g2gdHt1f7r//fgDJYF5t5sskAU0Wqdb+Wc4dpzXV6JLjOIBSgDWQv8sqDa4/PWa6e4BkMDmvS93zdP/h/UNry8wzzzwhZ9niQu9p3333XchMHNH7kNYJUzcq938NMNYWEVz3ffv2DZ0mu3CtV9I1bouOMcYYYwqLH3SMMcYYU1gq5rpKczfUZ1rTz6gZmhlKffr0CZ12MmX9iVqpNwMAgwcPDvmRRx4BkKwDpFHpND1r1LmWq6fLSzOBTjnllJDzzjbjb3bo0CF0p556asg0WW666aahY+0HoJTBpLWR1ltvvZCzNKOnZe8BpdocQMl8q3UeNENm9dVXB5Cchy+//DJkZhjutNNOoWvuWuVvab0eNW1zXOoiU/T3ea2V675ON49mpakbrFronkCXlbrY9PzruNNq7ij8f3VX5UFjrt1yLi2i54p75UUXXRQ6dQ3Q/ZB37ZmHHnooZM3moZtDs3pqaa+fHsw4ApK1jbSFEedKx6/tZOgmUte/zlW1XKvqBud1p7/N7FkgefycK3XNqpuVddi0u3lzW6zUhy06xhhjjCksFXtNmzJlCoBkgNmss84asj4p8ulN/1aDBQ899FAASYuB1gfJs+mlvjlpbQB9uuVTrwb7aRXgkSNHAkhaObRpH5vBaaNFDUbM++2GbxcajKZjufPOOwEk31gUWjwuvfTS0C255JJ1vj9r9He0jsodd9wBAHjtmHTV7wAAIABJREFUtddCpzVpGHisbyxqcWPlZF3/lXoL0+tIA6sZDJ9WLfnfcK7K1ShiELVaSfIIANXjp/VT661oUL6uv0GDBtX5Lj1+vkmuvfbaocu7Dldz0T0hrfK8Wpc5r2kJAlmR1hSSSRkAsPXWW4fM/V/nv6XMT0Oq6fO6u/HGG0OnFjdacvKwuOk60j1xn332AZBMBlBo5QaANdZYA0ByTrUpaX114rLAFh1jjDHGFBY/6BhjjDGmsFTMdcWmlRrgt8kmm4SsQYSsX/HEE0+ETgNz6bLROhDaTiBv1w0ZO3ZsyFpHh9BFBaTXodGmglpTgGbm+gIQ80bdeDQ3A6Ug1nHjxqV+jgF72hYi78BIXVM07WswtQZGppEWLFjJOeN3aYCimrtZs0PrcdCdDKS3cNA6P3qtctx5X2d6/mhGZ/sNIOma0TpbaQ1OtQQ/3cj6+bzHWkm4v2jTWW2hsMgiiwBItqPIen/hmqNbGEiuZa2jQ9dGEecEACZMmAAg2RZIk23yHLeuA3WNs05X7969Q6d7nt4LGJpQLtwij/HZomOMMcaYwuIHHWOMMcYUloq5rti2QOvBaCaN1hmhyWv77bcP3bBhw0Lu2LEjgGTUfa2YMfU4tPuxlvP+8MMPASQj0bWEN917mlWmZsK83ThNQY+ZJmmtKaHQPForc/pveHw6prznhMekJuKTTjop5AEDBgBIdqn+5ZdfQmbHZKB0XWnWmLZ7SGs3kQeatXLssccCAPbee+/QaYuHK6+8MuRevXoBSLpumAkHAAsvvDCA5Phq0TXcXNSdfOSRR4ZMl0I1W+jwXGsrhBVWWCFkbS1QxLlIa32hazKPtj71kVZni25PoHw9t7T9M29s0THGGGNMYfGDjjHGGGMKS6vpmcmmTp06XRuamq6+/fZbAMCDDz4YOi3BTnMxUHJZqeummlHZbdq0aQUAU6ZMaZaNUMdfTp4eWZnO27Zt2wqof/5aKpy/GX18TVlz5ahmhl9Trj+6WSrR2Z7XXVbjrJXrr9z6aG5WYHOuP+1yrS0GNAOwEnPcHDi+yZMnZzp/ebXyadeuXSsAmDRpUiH3z/bt29dZQLboGGOMMaawNMuio/CNS4Mlyz2xMkgpr2DHSll0apVaeaPMClt0Wja+/lo2zVmf5ZrD5tFipBzVsujkhS06xhhjjDEFwg86xhhjjCks03VdGWOMMca0ZKZbMNA+5pbJjOJjnjZtWiHH17p1a4+vBcPxFf36K3qMR9HvD7U0Po3dam7BQY5PsevKGGOMMYWlYi0gjGnJaIaglsZvKGl1aOwWrjxNrbFS3+eqWUfIGJNk+PDhIbPmnrYIaW6Gti06xhhjjCksFbfolHsz1rck6su9Odf39Mb/17/Lq8pkGmlvj1pfiFSzGrSpi87T5MmTQ2bF1vfeey90bFqraKPMNddcM+RZZpmlzvfnvSbT0GPS9cnrUmub6N/mUbmWxzdt2rTQ1Vd7RY/5r7/+qqPXcWhTxbZt29b5/1pH91KeKz1+jXfIujJ0Q2nu9aFxHTq+vMdlpg/Xql6TRxxxRMgXXHABAGDFFVes3G9W7JuMMcYYY2oMP+gYY4wxprBUzHVFM+SkSZNC99NPP4U822yzhTxhwgQAwGeffRY6NT0utdRSAMq7phZZZBEAwBxzzBE6NWmXKzNeaepz06kJVcfKc9SxY8fQtW/ffrqfrxblxtSYVD9+h7pD0lqA5I2O7+233w65a9euAIC55pordBMnTgyZLpM2bdqEbtVVVw151113BQD069cv9bdqxbSuc/3999+H/MUXXwAA1l577dC1bt26egf2/+j1/8orrwBINg3+4YcfQtbzy3GpO/LJJ58MmXtFu3btQqdNJQcNGgQgeX3WomtZry91A7z22msAgD///DN0a6yxRsgM9tRzVq3xVcIdyO8YPXp06DRwlft/rVxnjSXtHLXUsaTB8b3zzjuhm3/++UNmGEAlx2yLjjHGGGMKix90jDHGGFNYmuXjSYvqv+aaa0J34403hqymqW+//RYA8M0334ROTePLL788gGRWy48//hgyTerbb7996NTMtfrqq4dM90KlzGDlMhnuv//+kEeMGAEgaTp/7rnnQqbrY6211grdKaecEjKjzfPI2qHbAgBeeOGFkOmOAUpuyLRMOgD46quvAJSi5wGgU6dOIe+///51PpMHOn+6vnbYYQcAwIYbbhi6iy66KOTff/8dADB16tTQvfXWWyHTdTDvvPOGrnfv3iHXSqdmXV/33HNPyOeccw4A4NNPPw0dM5GA6rk5dH19+eWXdY5JXYdp5n6dX3Ujrr/++gCAp556KnS6V+2xxx4Akq6rPCjn5qFe3a0nnXRSyC+++CKApDuf4QAA0L17dwDJTJfFFlss5Czml262jz76KHTjxo0LeaONNgq5odfHfffdF3KvXr1C5v2jltw9aXOpOh1z2vnXvTItNKMWXauKHv8vv/wCADjttNNCt++++4bMZ4VKjskWHWOMMcYUlopF7U6ZMgUA8NBDD4Xuu+++C3ns2LEhL7nkkgCAlVdeOXQaWMc35XnmmSd0u+yyS8jXX389gKQVSN8IsiDtiVzfCPv27RsygwD1KX3LLbcM+dhjjwUAPPHEE6Hr0aNHyBdeeGGdz2QN336OPPLI0L300kshq3Xq0EMPTXwGSM4f37T0LVnrlDCw95hjjqnIsTeGtDcLIGm9oUVH34i32mqrkGmRHDJkSOiGDh0aMi0Jd999d+h0/aolIs+3TrV4jBw5MmSu9bzfiHVN0SKmb+71ocevb8G8Lmn5+Pff1gp6TLfffnvItG6pFXn8+PEh9+nTB0DSivrMM8+EfMsttwAAfv7559DdeuutIWdhSeZcjho1KnRXXnllyLSC6++X+21ew7yPAMDgwYPrfC/vSXmhe40eCy0VtPwCwG233RYyA+d1n1hnnXVCpvVj4403Dh1rd+n3500578d1110HIJmgpB6DLK5FW3SMMcYYU1j8oGOMMcaYwlIx1xVrUmi9hg8++CBkDTyim6ZciXnKWgdC3Vw02amJLq2E+7//pjmk1ebQYDg1TS666KIAygezzjfffACSdUr0XNF91K1bt9CVq0nTHNS0SHO41qZQc7+6sei6KvddNNlqnRKtE0TTcv/+/UNXrTotuh60Tk4aajpefPHFQ+b8rrbaaqHjnALA5ZdfDqAUlA0kg52XWGKJkPOsKaTrSGteLbDAAgCS818rrp2GBLBzLerf6nXLYOurr746dNtss03IrKmTx5j1On/99ddDPv7440Omy1WP+a677gqZNWV0/e65554h06V81llnhe7hhx8OWZM8KuXG5Oc1HEH3BL0O0trlpKEtAtQNxjplWeyZ5eB50nGoO5HhCECp/pOGLuj6pEuO1yGQ3D/23ntvAMB//vOf0J1//vkhs84ckK8bS8+/Jrlw/dGFCiTvFVnsibboGGOMMaaw+EHHGGOMMYWlYq6rNHfT7LPPHrKaQ2edddY6n1ddWp0ArVky55xzlv19IBtzHU2TrKECAB9//HHICy64YMg0iatrSo+ZY1F3m2Y7sc6MluXXOheVMsPqeb7qqqsAJOdP3Unrrrtunc+ru4odv4GSy0ZNl+qm7NmzZ53fz4PGnMe07t3agoRzBpRq0uiarRXXD5C+lrUmy7bbbgsg6fqodXStcXyaVaSuA651dS2feeaZIdNlUM16RzxmzfS7+eabQ/71119DXmaZZQAAp59+eujUjcrv0O/S88MMHp3/a6+9NmR1iXCPasr6TctUpYscSF4fjampxWPROkd0JwOlc6Xu5KyvPx6/1kvTrFIdN7NpL7744tDpvYLHrfdEPZesP6c165gJCiRdV3nAY9X51XOx++67AwA6d+4cuqxdbLboGGOMMaaw+EHHGGOMMYWl4r4DddGoaf/ggw8O+c033wSQzI469dRTQ6abRNtGaAQ6zVzVdAfQHKcumq+//jrkTTbZJGSaftX0nRZJrsev3XfnnntuAMmCYGr6a46ZT02g2vGYxR3LFQtTMzBdWmnmVAB45JFHACQj6TUrjfNbix29G4Mes2arsTgmS9EDlenaXCl4LJ988kno/vjjj5B53Oq6rPX50eKkLH6omY7aouPAAw8EAJxxxhmh030rjxYdvBaGDRsWOi04qWEAzBpbZZVVQqdugvrg+NQ1qa01mLUEJN3rzYH7nxbJU9eFHou63KaH7i+//fZbyMx2SrtnVJK0vfSGG24InYYeaGjCCSecACB5/2sMvD4vvfTS0GUdutEYuJYff/zx0On1mVbwt777Y7OPqWLfZIwxxhhTY1TMosMgVi01rnVEtE4An3q16SOfcoGSJWivvfYKnb4db7fddgCST/RZP8Xy6VKtOGoRWW+99eocS1ODXflGo+dP3zKbU6JdrSjaYI/BqOUaJWpgJMu16/9rgz7Odbk6LHw7rWbTUv5WOctKfcGQacenb54azEv0ja1adYIaAs+Bzr++ubNOVVrbhLzRoNoxY8aEvM8++4TMmlQ6p1qHZsCAAQCyr91RH2kl8rWFjlqPdX9kMGtj9ry0YHpdv2x0CiTbCVT6utQ50TpWadefnh+V0+rsaM2aarV+0GNiALRaMQ455JCQtekq91idP/0uWr0ee+yx0GkDVlr8a8nKmtZa57LLLgud1kyjd0DbQum9lIHllWyVY4uOMcYYYwqLH3SMMcYYU1ia5bpScxVN91pKXrtva7Au9dp9VWsCsJy5duxV1xdNe+eee27osu4Ize/UegUatDfvvPNW/Lc+/PDD1N9qjmlZzaUdOnQIeaGFFgKQNAFrifb33nsvZA3sJLoW+Dn9LXUTHHXUUQCAzTffPHRZ1NRRczCPRV0wenzqeuPfqIlcg3XfffddAMm1ftNNN4XMz2kAtwaT5m1y5nnR9aXHVMv1c8p1JNcWHQwC1To6r7zySsjvvPMOAGDNNdcMnc51tYI5dX1yTT3wwAOho4seSJr+OT+Ncbelucl0nHouswycV3euus7Sjk+vVXVt8F6ge67WoanW/Ola5P6m9dQ4pwBw5513hpzmxlY3Drt7671G9xKuhTzbxwDlQw/ovtN7lnaaP+644wAk3bQ6FtaMU9ed3ouasn/aomOMMcaYwuIHHWOMMcYUlmb5C9REuNxyywFIdtHVTCQ1PfFzWmeH7gyg1GlXO9Jqd2+aprUjOs1hQLImRqXdBNUwi9IkuNRSS4VOXT/NGZN+VusUHXvssQCAk08+OXRqTlXTPs3c6q6qz/SvOpo0s3Dh6DGp6fvWW28FALz44oupx8RMMj0+HZOa2bVmB1FzNH9Xz6+u9YbWCckKnnc9Ds2AqcWsDqJzxlYIQLITMut03XbbbaF78MEHQ6ZLSDNZ+vTpEzLPReZl6WWtcq/TtXXAAQeErG6axtTMITqWZ599FkDSjbT11luHXCnXpa4fXktsLwIAO++8c8hPPfVUyGxNoXWCNCtw4sSJAEqtLIBk/SF2dVd3Vhbo+LhmWCMGSLqzzzvvvJA///xzAMk6P9qOhK0fdM9YddVVQ66Vmly6ftWNz07q2rZkv/32C5nzrnXitJ0Su5tX9Fgr/o3GGGOMMTVCsyw6+kTLRmLaUEzfIuqrfKhvxAxG0qZ1rHYKlIKQtfKpBpOyaR9Qejtp7tspn6L1LUMtRxqs2tjvBJLHR4uABlg2pXJofajFY6uttgKQfLPQehQarEhLj769aBBl2nFq4DkbLFaytgzfLvSNmFYqPb5y1X51fc4222wASvUg/v23fBPW72IwN1B6I9W317yrlepao8VKg5E12JFvp7Vo0VHKBbtvsMEGAJKVd3v37h0yq4yfcsopofvxxx9DZuXh5gZANgauv3L1Ypry+3rNamArrV9rrbVW6LTpcloQf3Ph+DQBQa04upfyvKsVR+eC50X3F1Zj1+/dZZddQpd1zS5+/0YbbRQ6bYSseylltajpXty3b986/7/GGmuEnGcQslpx9Pyr9ZT1uXbaaafQnX322SGrp4I8//zzIQ8cOBBAcv6buw5t0THGGGNMYfGDjjHGGGMKS7NcV2ktAOaZZ57U/29KAJW6BthiAigFLmkwV7maGJVmiSWWCHmllVYK+dFHHw2ZQYTlmlbyXKg5Tk2vdL/stttuoauWuVLrvZSbM7o5Nttss9ANHTq0zue0joIGBi677LIAkrWRmgt/U+sxDRkyJGSavvU86pwsvPDCITOw/uWXXw6dmpYZDKpjUjcr3Vh0wf77d/OG605bDKjriq67vN1tjSHNHaH7h7pOWb9j//33D93gwYNDZp0vNuct9/21Cq8FPeYnnngi5C+//BJAsk6PukmyWKs8Fv2dTTfdtEGfKYd+l86VtumpFmnHquEGaQ081bWo7VjoetNgdA1MzmMv4b1M78OaDKTNTNmgWxOM9L7CfV+DtfVapcvPTT2NMcYYYxqAH3SMMcYYU1gq1gKCZZ81+4n1DIBSbQ4gPcNAzXHMBtGy2S+99FLIbFOgUe29evUKWc1glTLz0YxPs/6/f1/rBzGDg11Y9fNAybX26aefhk7bWfB71fVRLdO5/k653+S8a1l9zSqgyVZrfzATBsi2joyWGtfaMFwTzIgCkmuD5nwA+OKLLwCUbyuy8sorA0hmnXXs2LHOseic15LrI811qqZxZjDlXe9H4fnTPadcdlBaiwPWXgHS3ew6Vt3DqgXHVe76q6+7d5qbfPjw4aE788wzQ15hhRUAAP369Uv9rSwpl+nYGDhu3XPY1gNI7tF5Ut9equtT3fhsd6GhGXnsH7q+eHxae0qz5vSc9+jRA0ByTWrWNGtGqTtL6wyluV6biy06xhhjjCksFeukyKfrE044IXQXXHBByI2ptsknWn3K1cAtVsTUN2ptdJllMJ0ehwZbaZVHBsSyHgCQfDr+7LPPACSDIbX+C2t+5NFosCHw/Oox69M3j1WtK+uvv36dz2dxTLvuumvoNNiSsGEekHxz1/XDtxM9//r2wbGoFadWrTfTQ69JHUuex69vgdpg9pJLLgGQTAbQOfnqq69CZtNftdKMGjUqZO5VGiyvwawaZJ8lumZY80mTGi6++OKQaUUESpZeDSbXOkCsI3b11VeHrlOnTiEz8LpWg+Ubiq5TtdQyMUXXUi2OTxMctIE19yJtip0Hes9i7TRdM5pAo94XJoHo+Wc3AwBYffXVAQAHHXRQ6LQOVhb3Olt0jDHGGFNY/KBjjDHGmMJSsaaeLPesQX/qWtIGker+IWpaXHrppQGUmpsBwBZbbBEyXTsa7Fstc7uOecEFFwyZpnWg5LKiiwpImuYYWD1hwoTQaTAyg7hryQWS1sCNQbv//n+i81Mt9Di0bDw58sgjQ66vtlO58099LZrDGwKPX8+PlmvP002qc6LuiMceewwAMGbMmNS/7dChQ8hdunQBkJy/bt26hUy9tojYcccdQ2ZNpazPg34/a0tddtllodMwgN133z1kumT1+tNkDdZk0UaKGozMJIGWun6JXuvqUmEDzHINfvOGx5XWlgMoteFJa5VQTXR98p6stXP0/7WmWNq+mdaCQ9df5g10M/12Y4wxxpgc8YOOMcYYYwpLxbqX0xzKzsAA0LNnz5A1K2nEiBEAklkf3bt3D5kZEGpa106m/Fze5kg1vWmGD83Q7IIMAG+99VbINLNqVpqazpntU0uZVnosbBfA6HkAGD16dMjMmuvTp0+Vjq5Efe6+lm6ubyp6Xri+dt5559BpVk+e607nR90RrNmktVOU+srtp6HuZCXP8eue2bVr15DvvffekB944AEAyaxBdRPTjU4XCJB9i4dqwrWs7hBtl8NsvLzvD/Xx888/h8w9EyjVOdJ6cHmHMfCaKHdt1NK9Kg1bdIwxxhhTWPygY4wxxpjC0mp6JrGpU6c22l5WrmN5Y7qXpx1TQ1oTNJQ2bdq0Apo2vnKkjbUxY65kwTmOb/LkyZnYOzmuP/74I3Rp3ZH79+8fOnVDNnd87dq1awUA06ZNq520tArSunXrqowvLROiGjRlfGlZfeVo6FiyGjPH15TrryH7Z33Hndbio5Jj5fU3adKkmrn+0vbapo65ffv2Fb8/KFzLmpWrndz32WcfAMkMp7QWH00li/tfLcHxKbboGGOMMaawVNyi0xKYUZ5os7LoEH2L0nYJ1GfVFNIWnZbNjDK+rK+/vKhFi04lydqiQzRY+rvvvguZ9eO06WwlmVHuf4otOsYYY4wpLH7QMcYYY0xhma7ryhhjjDGmJWOLjjHGGGMKy3QrIxc9WLDowVhFH98///xTyPHNNNNMM0Qwa9HHV/Trr+jByEW//xV9fIotOsYYY4wpLM3qdVVJ0gqC1Xr/jKaSVlCwkgURTWUoV6SO8+N5qm0aU7DU15+pNcqt36LeF7PEFh1jjDHGFJaasehMnDixjm622WYLWQvS8Y2rJT3ZqnWAYz3yyCNDd+ihh4a81lprAWhZXYb1jYNjLfcWzXHV6psz11XamgSAmWeeGUCyI3TaG1etjo+kzZmSVQuBrOFeoQUrJ02aFPLUqVMBJLtDs0gbUDovtTRmnauZZpqpji4Nnb9a7+RtSnBedc3qvWCWWWap+jE1Bl5Xev3kvf5s0THGGGNMYfGDjjHGGGMKSy6uK5rmhg4dGrojjjiizt8ddNBBIS+00EIhd+nSBQCw/PLLZ3WIFUFNy2p6vPLKKwEA//3vf0N34oknVu/AKoS6O3R8P/74IwDg119/DR3dBQCw8sorA0h3R+aFjuXNN98EAGy33Xap/9+9e3cAwNprrx26zp07h7zSSisBSLpG8h6fktbd+uuvv67z/4suumgdHVA7Yynnevv+++8BABdffHHohg8fHvK3334LAJh//vlDd/LJJ4e82267Ach/feqY1A336quvAgB+/vnn1L/ltbj44ouHbvXVVw+5VuavHBxLfR3rdc+p9THVR5pr8rrrrgvd66+/HvINN9wAoORCB/IZvx6zrs8XXngBQPL4dK+sz+WaBbboGGOMMaaw+EHHGGOMMYWlaq4rNQPT9Hr00UeHbt111w15iSWWAJDMerniiitC7tu3LwDg9NNPD12tZ2A9+OCDIV9wwQUAgMMPPzx0yyyzTMi1mG2V5iZQd9Rpp50W8hNPPAEgOX8adf/QQw8BANZYY43Q5W161bFcc801AIDff/89dO3btw/57rvvBgDcfPPNoZt33nlD3nvvvQEA5557bujUDF8rZnbN6qC7Biitxeuvvz507dq1CznP4y9XW4RrDgBOOOEEAMmsuK222ipk7kXqzurfv3/IdNltsskmqceQZTaarpMffvgh5Pvuuy9krqvx48eHLu363GOPPUJ3yy23hJyWtZr3/qn3h1GjRgEArrrqqtDpnkiXo7obZ5999pBr5fqqD50z3R9HjBgBALjrrrtCN3bs2JBvvfVWAECfPn2yPsTpUm7/PPjggwEAyy67bOi45//7c2m6LObPFh1jjDHGFJZMLTr6lPb333+HfNFFFwFIWgH4FqzoU64GO/GN5bHHHgvdiiuuGPJSSy0Vch7WER6fBgvqGyPPxTzzzFPdA2sk5Z6y33jjDQDA8ccfH7p333035PXWWw8AsOeee4ZOLVoM9lWLTh7o+PTtePTo0QCSb/TnnHNOyIcddhiA5FuoctlllwEAOnXqFDq1mOQRjKfw9//444/QffnllyHPNddcAPJ/y1d4zHo933///SGr9YyWjH79+oVOAyPJscceG/LOO+8cMgM/N95449CpdWXuuecOuU2bNgCa/xbKPeOXX34J3YEHHhjya6+9FjL3RSZlAMCqq64aMtdax44dQzdhwoSQ+RufffZZ6HT/1CD0LPdPtV5pYgbnQoOp1WJzzz33AEhawTVxpdYtOhy3ntsBAwaEfNtttwEAJk+eHDrdM84++2wAyXumWpzzGL+OhdfETjvtFDoGWAOl4/vzzz9D99FHH4XM+0Il90lbdIwxxhhTWPygY4wxxpjCUjXXlZpOhw0bBgA4//zzQ5dWc0SDJT/88MOQWadl3LhxoWPbBP183qi7bcqUKSHTNLzNNtuErlaOWdH5++CDD0KmSVJdOxoYzpoJWqp8gw02qPO9ebtwlJNOOilkrrXzzjsvdOqG6tGjBwCga9euodN2JdSz3gUA7LDDDiHnUf8izQ2prh9dq+VccnnCY/riiy9Cx6QEIGn6Z00qdX2rG47ngi46AOjZs2fI3Fdefvnl0F199dUhM1gdKAU8V8p1pe7EMWPGhKyuAQZW00UKJF07/BxdIEAy8Jr1rXR95xHMq2tO2+FwL7/xxhtD99Zbb4X80ksvAUgG6NY6ek0xyeGmm24KndbM4ZrS0AYN/eD85J20Uu7+wHlZZZVVQpe2p+j9W/dKXmuVDFC2RccYY4wxhcUPOsYYY4wpLFWro6Pm+jnnnBMAcOGFF4bu0ksvDfmTTz4BkMzqYe0doGSaPuaYY0LHSG8gadLLwz1CM90zzzwTOq0ps+OOOwIo1QsCat919fHHH4fMc33KKaeETttx0E2g7jqtqcCslrfffjt0q622Wp3PZ80DDzwQstasYOuH9ddfP3R6Lpjhoe5WNc3yvJxxxhmh++mnn0LOIyswrUXCvffeGzo1jXfr1g1A/iXmFf6+1sbR2kXqhqNLWNec7g88F7/99lvo6A4BgCeffBIA8M4774ROXZtZuHm45t9///3Q6fWjdYAGDx4MILnmBg4cGDKzknTNqWufrgFmRwLl3XyVRteh7ikMRwBK2Waa/cU1C5Rc4rXk+k6jXJ0c1sHROkCaNTVo0CAAwNZbbx06ZloBpflnKxMgmTWX5bWq86frS2vCrbPOOgCA5ZZbLnQahvLXX38BSGYY6vXH711kkUVC19x90hYdY4wxxhQWP+gYY4wxprBk6rpSE6hGkF977bUAkgWP1LTFcu4j72+UAAAMa0lEQVRadv6OO+4ImaZpNaOlZVVUEz0WRtVrQUMdCzM81Ayvps1aQU2gWtwvzfWonaJZfE+zJvRc8Pxo1od2V84Czo+6aDQrRd1QRxxxBIBkJpWaTvm35UzEXH/6/3m7fnR9sjjgV199FTp1U9ElVK47fR7w99WcrdlPLOIIlFwye+21V+i0+B6Ll+maffzxx0PefffdAQCnnnpq6BZYYIE6xwI0b151n+J36nWiBdV0/+T8aaaOul75vVpEUc8Fs8006ymP7D9156ubji45PabvvvsuZF6Xea/J+tDrR8MY0lqU8J4IJAvtEXWX8hyqu6ta6Px98803IetewkKOGm6i9+9HHnmkzndpEU5dl5XCFh1jjDHGFJZMLToaLKdv0gzy0yc3feLjk57WXmGAqJL3W7KiT+8MZtRGZhrYutBCCwFIlt1nozqgcrU5mov+vpZj51xpUzmtg/Hee+8l/gWSwcZXXnklgOQ5yfrtjGPRVhRaJ0XrqDBws1xQJr9L30j0jZRv5ZxnIGkRqFawdblgSI5b19xGG20UsrYTIHmvxTQ23XTTkLVOzCWXXAIgaVHkW6SiFruhQ4eGvOGGGwJIWvmyWJ96TrlX9u7dO3SPPvpoyGqx4RrWNafHyrlm0CcAzDHHHCGnWRyrha79pZdeOmRdi2wR9Nxzz4VOW0QwiHzJJZfM7Dibit7zNFhYA495r1CLOBNUFD1Xeq/kXC+44IKhq9Zc6nWgViptV8F50//X/YcWVV2/WmePySqLLbZYpQ7bFh1jjDHGFBc/6BhjjDGmsFTcdaXmcg0g02C4ESNGAAA222yz0B1wwAEhswy6mvvuvPPOkBksmDdptUmAUv0frd3BjthAySWnpjt1F9x8880A0mvTVBM1h+pYaTLWOkDqemSwo3b81vllHYxqms5pOtV6K2pO1XYkdB3W567Qc6J1QLi+tXt03gHyWqeCa3HIkCGhGzVqVMg0k2vHYSXPwPlya1KDlNluQ10/2i6A87vPPvuETveiPEvsa9D/nnvuGbK63lh/RN0kOidTp04FUHIRA8n96bjjjgOQvH6rtb/o/GmAtbbYoKz74y677BLy9ddfDwDo0KFDZsfZWLgW1V2odd7UjX/77bcDSHdXKT/88EPIeq3mEdrA8akLUddXmptc93wNbWAbF73+NJhZx10pbNExxhhjTGHxg44xxhhjCkvFXFc0XWn0tXYUfuWVV0KmaVIzXWadddY636m1LTSrgqbpvEvUq7lOTct02Wmdg+233z5kujRWWGGF0F1++eUh00ypdTDyRsf65ptvAkhmLakZnd3LtXaJdjKvlktAj5kmZS2xr+4KXUv1mfH5vXQRAEkzLkuY6/rWOkpZrtVymWBaE4ZdhVdeeeXQqevx66+/BpB0PWuGB90rlewu3FDUXaV7DTN1gFLWlbaAUNcI6yexFD8A7L///iFXMtujoXDN6To5/fTTQ9YMI7Z70HPO2mJAqY6QttVR1wfbSeSdtaTH36VLl5A7d+4MILm+nn322ZC5V7KeVy3AYx05cmTomH0LAD169AiZ9y8lzSWrHb3ZcR7IZ9w8Ph2fuus1q5TX2pZbbhk6rRnEvURrB7HtDJC8xiuFLTrGGGOMKSwVt+g8//zzodOmgVqnQpuVEX3L5xOd1iHhW2be6FuGVnNmIz2gZN245ZZbQqdN+fgdb7zxRui0SigtPXm8MSvlgq3Z1FItGjqnnKtaqgzMuRo3blzo1MrUmGBhzu+YMWNCp2/MrGJ6yCGH1PkMkE/gpwaesmkum+MCwH333Rcya67Qcgck1ydrumjTxaytdJwfDfbUprJaJXnfffcFkLSILLzwwiEziJVB4wDwwQcfhMxzlUcCgP6mWoQ18JYVk59++unQaYNOJkHonqTBnroWawVdqwyC12syzaKhFqm8Lfpcl/369Us9JrW48fzrNaNzwvpqamXVvZgV5XV9VGv8anHUY9amt/Re6DGljVUbkWaNLTrGGGOMKSx+0DHGGGNMYamY64q58zfddFPoOnXqFPLmm28eMk1+5czd/H8tW64lwmk+y9tcqWWr1TRMkyLrAQGl2glAqaaC1gZibQsA2GOPPSp3wM1Ax6rtLD777DMASdeMBtgdffTRAErNO4Gkm6gW0bFSLtc0ljVndt1119Bp4C+DyNW1k4e7Sus4XXXVVSGzDov+rdZh4XWprh+dy/nmmw9AdV07nBMdh7rbtN0DAz+1DpCOj01LdX/Rpom1gp5fPf60YPi0YHd1LeRRx6mp8Ph1/C+++GLIDDLXBII80P2BSQ4awM96YkDy/kd0fvReQTcQ680AQNeu/9fe+evS9sRRfEkQXoNCIRFCoRKSn0gkGhqNJxA6hZp4ASoPIRGJQuUJSFQS0WgkOhVB8avWnDW5+ziOs+fMvnPXp5pM7j327Nl7Zvb3z/r+F9osh5Sj6K4m1ej6psHEnL92+zP7+6nHZYuOMcYYY4rFBx1jjDHGFEttriuao15eXkKfttUMNzExASA2TWqblc41q0XdOTRJ55BoV3OcVj+uqh68v78f+tT0Pzs7CyDOFFlbWwttmiRzZyopKv3N61KdBM36GB8fBwA8Pj6GPs16yQF1mrQKu2baqOuJZv6np6fQd3Z2FtrHx8cAWno5QCvTB2hpsuTOmtO/qa4NlktQ14664Q4ODgDE2heqLcP3LvWYqlwDqr2xvb0d2loWhtelFZ812+709BRAvH5wTQLyZFt1Qu8150VL5GiGKp87daerG7NdaY+mwOtndhkAXF9fh/bCwgKAeM3Ngb7f3KtU20nvuZYgoctUq5vv7u6GNsu1aFmTw8PD0Oa+08/9j89fVfYiELuhmrRvEVt0jDHGGFMstR3t+ZVA1U4gLtpFtUsAmJmZARCfAmnFAVqKixrgpEFQOSw5pJ1FR6+PJ3JVhtZifQys1i/mJmnOVLG4uBja5+fnAGI1aNW5YLCuji8Heh8ZIK5q1BpgrQUUGRh4e3v7Rx/Q0n/Q+d3a2gptfsk1yTJQ9XxpnwZ20nqiVhD9esvxfFKnSIM9VadKr5Vf2nd3d6FPrcMcq1pEGKAMNGveiFrkuNY+PDyEvpWVlT/+j1qRGcAKtKyvTVxnFN0TdH6po5PboqP7EIuOqnaRFsrV+eHzp8HkTBAAWokdur6oinnO57OdF6ZOrIxsjDHGGNMFPugYY4wxplhqD0bWfP+rq6vQ1qJ77NfA0MnJydDe3NwEEAd4Nh112V1eXgIApqenQ59qDlTpRDQRNW2vr6+HNt0IWnROg0SXl5cBxAGeuc3k1Kxg+QogLgHAOQOAqakpALE7Ul13S0tLAGIJep3L3GP9DWoufn5+BhAHW+vzmwMGoGrZFA3w1BIzDMxVHS8td8HAal1/mjhnek3z8/OhzcQM1ebScjR03bVbX1K4BlKj94JByvf396FPg7Hp2ko9p/r71AnTsg0stQLEblSuNZrgoQWsuW9o8c6c4Rqp0OdQ3ZCaRFDb36r9F40xxhhjGoIPOsYYY4wploHvzHufn5892f5Ur0H1BVjpVc1V+m+rsnXqNEMODQ0NAMDHx0dtP6pmuCqdn36aHoeHh2sfn8qVU39GK9aq5gWr687NzYW+OsfP8X19ffU0Ps1K0QwIZmipDoZmvZBUczo4ODgAAO/v70lt7/rM6r1gOZKdnZ3Qp67lXl2uIyMjvx6fumh0zlTThO+friM6f7z+VO5Gji/V+sJsJNXpurm5CW2uqzpne3t7oU0tFH2nuxk/37+3t7ckzyfn8vX1NfTRXQy09IF0fTk5OQntKp22bhgdHR0Afrf/6Tzp/dUMY+6F+ixXZf2lCm3g/tfr/v5bOL+qXXZ0dBTaq6urAGJ3bTf3guNTbNExxhhjTLH4oGOMMcaYYknquor+UEV16E7VTVORwnXVJFK4rhSaZ9tVRE6dVVaX66pT9kkuEcd+ua4UnUvel9SunW7Gx+vrpgp3rvlL4bpSfnov2pUg6fW9TO26Inr9mmF1cXEBANjY2Ah9Y2Njod3rXPfiumpH1f6n9DMDN7frqgpdiztVP++EXVfGGGOM+afoW3W3ppc4MD+n6fo/P6WUcdSBvpNN1Ozo9SuvJP6Ve6Hj09ItLIfQ9EKSive/70m9FtuiY4wxxphi8UHHGGOMMcXybTCyMcYYY8zfjC06xhhjjCkWH3SMMcYYUyw+6BhjjDGmWHzQMcYYY0yx+KBjjDHGmGLxQccYY4wxxfI/vpcAHPViZy0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Randomly select 100 data points to display\n", "rand_indices = np.random.choice(m, 100, replace=False)\n", @@ -145,9 +158,7 @@ }, { "cell_type": "markdown", - "metadata": { - "collapsed": true - }, + "metadata": {}, "source": [ "### 1.3 Vectorizing Logistic Regression\n", "\n", @@ -158,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -267,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -336,6 +347,11 @@ " do the following: `utils.sigmoid(z)`.\n", " \n", " \"\"\"\n", + " \n", + " def sigmoid(z):\n", + " g = 1 / (1 + np.exp(-z))\n", + " return g\n", + " \n", " #Initialize some useful values\n", " m = y.size\n", " \n", @@ -348,9 +364,15 @@ " grad = np.zeros(theta.shape)\n", " \n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - "\n", - " \n", + " mask = np.eye(len(theta))\n", + " # Skip the theta[0, 0] parameter when performing regularization\n", + " mask[0, 0] = 0\n", + " \n", + " X_dot_theta = X.dot(theta)\n", + " J = 1.0 / m * (-y.T.dot(np.log(sigmoid(X_dot_theta))) - (1 - y).T.dot(np.log(1 - sigmoid(X_dot_theta)))) \\\n", + " + lambda_ / (2.0 * m) * np.sum(np.square(mask.dot(theta))) \n", + " grad = 1.0 / m * (sigmoid(X_dot_theta) - y).T.dot(X).T + 1.0 * lambda_ / m * (mask.dot(theta))\n", + " \n", " # =============================================================\n", " return J, grad" ] @@ -389,9 +411,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "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 +453,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): n\n", + "Login (email address): Gregory.Hilston@gmail.com\n", + "Token: eGlsD2vJW6U3Dmzc\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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 +518,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -526,8 +596,11 @@ " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - " \n", - "\n", + " initial_theta = np.zeros(n + 1)\n", + " for i in range(0, num_labels):\n", + " label = 10 if i == 0 else i\n", + " result = optimize.minimize(fun=lrCostFunction, x0=initial_theta, args=(X, (y==label).astype(int), lambda_), method='TNC', jac=True)\n", + " all_theta[i, :] = result.x\n", "\n", " # ============================================================\n", " return all_theta" @@ -542,7 +615,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -559,9 +632,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): Y\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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": [ "grader[2] = oneVsAll\n", "grader.grade()" @@ -580,7 +685,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -650,9 +755,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 10.00%\n" + ] + } + ], "source": [ "pred = predictOneVsAll(all_theta, X)\n", "print('Training Set Accuracy: {:.2f}%'.format(np.mean(pred == y) * 100))" @@ -667,9 +780,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): y\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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": [ "grader[3] = predictOneVsAll\n", "grader.grade()" @@ -690,9 +835,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# training data stored in arrays X, y\n", "data = loadmat(os.path.join('Data', 'ex3data1.mat'))\n", @@ -735,7 +893,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -774,7 +932,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -821,6 +979,10 @@ " You can use this function by calling `utils.sigmoid(z)`, where you can \n", " replace `z` by the required input variable to sigmoid.\n", " \"\"\"\n", + " def sigmoid(z):\n", + " g = 1 / (1 + np.exp(-z))\n", + " return g\n", + " \n", " # Make sure the input has two dimensions\n", " if X.ndim == 1:\n", " X = X[None] # promote to 2-dimensions\n", @@ -834,6 +996,14 @@ "\n", " # ====================== YOUR CODE HERE ======================\n", "\n", + " m, n = X.shape\n", + " X = np.hstack((np.ones((m, 1)), X))\n", + " A_1 = sigmoid(X.dot(Theta1.T))\n", + " A_1 = np.hstack((np.ones((m, 1)), A_1))\n", + " A_2 = sigmoid(A_1.dot(Theta2.T))\n", + "\n", + " p = np.argmax(A_2, axis=1)\n", + " p += 1 # The theta_1 and theta_2 are loaded from Matlab data, in which the matrix index starts from 1.\n", "\n", "\n", " # =============================================================\n", @@ -849,9 +1019,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 0.2%\n" + ] + } + ], "source": [ "pred = predict(Theta1, Theta2, X)\n", "print('Training Set Accuracy: {:.1f}%'.format(np.mean(pred == y) * 100))" @@ -868,9 +1046,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neural Network Prediction: 4\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if indices.size > 0:\n", " i, indices = indices[0], indices[1:]\n", @@ -890,13 +1088,52 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "Use token from last successful submission (Gregory.Hilston@gmail.com)? (Y/n): y\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 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": [ "grader[4] = predict\n", "grader.grade()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -915,9 +1152,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }