diff --git a/Exercise1/.ipynb_checkpoints/exercise1-checkpoint.ipynb b/Exercise1/.ipynb_checkpoints/exercise1-checkpoint.ipynb
new file mode 100755
index 0000000..b3f2bc1
--- /dev/null
+++ b/Exercise1/.ipynb_checkpoints/exercise1-checkpoint.ipynb
@@ -0,0 +1,1640 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Programming Exercise 1: Linear Regression\n",
+    "\n",
+    "## Introduction\n",
+    "\n",
+    "In this exercise, you will implement linear regression and get to see it work on data. Before starting on this programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\n",
+    "\n",
+    "All the information you need for solving this assignment is in this notebook, and all the code you will be implementing will take place within this notebook. The assignment can be promptly submitted to the coursera grader directly from this notebook (code and instructions are included below).\n",
+    "\n",
+    "Before we begin with the exercises, we need to import all libraries required for this programming exercise. Throughout the course, we will be using [`numpy`](http://www.numpy.org/) for all arrays and matrix operations, and [`matplotlib`](https://matplotlib.org/) for plotting.\n",
+    "\n",
+    "You can find instructions on how to install required libraries in the README file in the [github repository](https://github.com/dibgerge/ml-coursera-python-assignments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "from mpl_toolkits.mplot3d import Axes3D  # needed to plot 3-D surfaces\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils \n",
+    "\n",
+    "# define the submission/grader object for this exercise\n",
+    "grader = utils.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Submission and Grading\n",
+    "\n",
+    "After completing each part of the assignment, be sure to submit your solutions to the grader.\n",
+    "\n",
+    "For this programming exercise, you are only required to complete the first part of the exercise to implement linear regression with one variable. The second part of the exercise, which is optional, covers linear regression with multiple variables. The following is a breakdown of how each part of this exercise is scored.\n",
+    "\n",
+    "**Required Exercises**\n",
+    "\n",
+    "| Section | Part                                           |Submitted Function                     | Points \n",
+    "|---------|:-                                             |:-                                     | :-:    \n",
+    "| 1       | [Warm up exercise](#section1)                  | [`warmUpExercise`](#warmUpExercise)    |  10    \n",
+    "| 2       | [Compute cost for one variable](#section2)     | [`computeCost`](#computeCost)         |  40    \n",
+    "| 3       | [Gradient descent for one variable](#section3) | [`gradientDescent`](#gradientDescent) |  50    \n",
+    "|         | Total Points                                   |                                       | 100    \n",
+    "\n",
+    "**Optional Exercises**\n",
+    "\n",
+    "| Section | Part                                                 | Submitted Function | Points |\n",
+    "|:-------:|:-                                                    |:-:                  | :-:    |\n",
+    "| 4       | [Feature normalization](#section4)                   | [`featureNormalize`](#featureNormalize) | 0      |\n",
+    "| 5       | [Compute cost for multiple variables](#section5)     | [`computeCostMulti`](#computeCostMulti) | 0      |\n",
+    "| 6       | [Gradient descent for multiple variables](#section5) | [`gradientDescentMulti`](#gradientDescentMulti) |0      |\n",
+    "| 7       | [Normal Equations](#section7)                        | [`normalEqn`](#normalEqn)        | 0      |\n",
+    "\n",
+    "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "At the end of each section in this notebook, we have a cell which contains code for submitting the solutions thus far to the grader. Execute the cell to see your score up to the current section. For all your work to be submitted properly, you must execute those cells at least once. They must also be re-executed everytime the submitted function is updated.\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "## Debugging\n",
+    "\n",
+    "Here are some things to keep in mind throughout this exercise:\n",
+    "\n",
+    "- Python array indices start from zero, not one (contrary to OCTAVE/MATLAB). \n",
+    "\n",
+    "- There is an important distinction between python arrays (called `list` or `tuple`) and `numpy` arrays. You should use `numpy` arrays in all your computations. Vector/matrix operations work only with `numpy` arrays. Python lists do not support vector operations (you need to use for loops).\n",
+    "\n",
+    "- If you are seeing many errors at runtime, inspect your matrix operations to make sure that you are adding and multiplying matrices of compatible dimensions. Printing the dimensions of `numpy` arrays using the `shape` property will help you debug.\n",
+    "\n",
+    "- By default, `numpy` interprets math operators to be element-wise operators. If you want to do matrix multiplication, you need to use the `dot` function in `numpy`. For, example if `A` and `B` are two `numpy` matrices, then the matrix operation AB is `np.dot(A, B)`. Note that for 2-dimensional matrices or vectors (1-dimensional), this is also equivalent to `A@B` (requires python >= 3.5)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section1\"></a>\n",
+    "## 1 Simple python and `numpy` function\n",
+    "\n",
+    "The first part of this assignment gives you practice with python and `numpy` syntax and the homework submission process. In the next cell, you will find the outline of a `python` function. Modify it to return a 5 x 5 identity matrix by filling in the following code:\n",
+    "\n",
+    "```python\n",
+    "A = np.eye(5)\n",
+    "```\n",
+    "<a id=\"warmUpExercise\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def warmUpExercise():\n",
+    "    \"\"\"\n",
+    "    Example function in Python which computes the identity matrix.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    A : array_like\n",
+    "        The 5x5 identity matrix.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Return the 5x5 identity matrix.\n",
+    "    \"\"\"    \n",
+    "    # ======== YOUR CODE HERE ======\n",
+    "    A = np.eye(5)   # modify this line\n",
+    "    \n",
+    "    # ==============================\n",
+    "    return A"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The previous cell only defines the function `warmUpExercise`. We can now run it by executing the following cell to see its output. You should see output similar to the following:\n",
+    "\n",
+    "```python\n",
+    "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.]])\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "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()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Submitting solutions\n",
+    "\n",
+    "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the grader object, and then sending your function to Coursera for grading. \n",
+    "\n",
+    "The grader will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "Execute the next cell to grade your solution to the first part of this exercise.\n",
+    "\n",
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Login (email address): videhraj29072000@gmail.com\n",
+      "Token: GnvUtUiXqleSQ6eA\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |   0 /  40 | \n",
+      "        Gradient Descent (for one variable) |   0 /  50 | \n",
+      "                      Feature Normalization |   0 /   0 | \n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  10 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# appends the implemented function in part 1 to the grader object\n",
+    "grader[1] = warmUpExercise\n",
+    "\n",
+    "# send the added functions to coursera grader for getting a grade on this part\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2 Linear regression with one variable\n",
+    "\n",
+    "Now you will implement linear regression with one variable to predict profits for a food truck. Suppose you are the CEO of a restaurant franchise and are considering different cities for opening a new outlet. The chain already has trucks in various cities and you have data for profits and populations from the cities. You would like to use this data to help you select which city to expand to next. \n",
+    "\n",
+    "The file `Data/ex1data1.txt` contains the dataset for our linear regression problem. The first column is the population of a city (in 10,000s) and the second column is the profit of a food truck in that city (in $10,000s). A negative value for profit indicates a loss. \n",
+    "\n",
+    "We provide you with the code needed to load this data. The dataset is loaded from the data file into the variables `x` and `y`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read comma separated data\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex1data1.txt'), delimiter=',')\n",
+    "X, y = data[:, 0], data[:, 1]\n",
+    "\n",
+    "m = y.size  # number of training examples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1 Plotting the Data\n",
+    "\n",
+    "Before starting on any task, it is often useful to understand the data by visualizing it. For this dataset, you can use a scatter plot to visualize the data, since it has only two properties to plot (profit and population). Many other problems that you will encounter in real life are multi-dimensional and cannot be plotted on a 2-d plot. There are many plotting libraries in python (see this [blog post](https://blog.modeanalytics.com/python-data-visualization-libraries/) for a good summary of the most popular ones). \n",
+    "\n",
+    "In this course, we will be exclusively using `matplotlib` to do all our plotting. `matplotlib` is one of the most popular scientific plotting libraries in python and has extensive tools and functions to make beautiful plots. `pyplot` is a module within `matplotlib` which provides a simplified interface to `matplotlib`'s most common plotting tasks, mimicking MATLAB's plotting interface.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "You might have noticed that we have imported the `pyplot` module at the beginning of this exercise using the command `from matplotlib import pyplot`. This is rather uncommon, and if you look at python code elsewhere or in the `matplotlib` tutorials, you will see that the module is named `plt`. This is used by module renaming by using the import command `import matplotlib.pyplot as plt`. We will not using the short name of `pyplot` module in this class exercises, but you should be aware of this deviation from norm.\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "In the following part, your first job is to complete the `plotData` function below. Modify the function and fill in the following code:\n",
+    "\n",
+    "```python\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",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(x, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points x and y into a new figure. Plots the data \n",
+    "    points and gives the figure axes labels of population and profit.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    x : array_like\n",
+    "        Data point values for x-axis.\n",
+    "\n",
+    "    y : array_like\n",
+    "        Data point values for y-axis. Note x and y should have the same size.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the training data into a figure using the \"figure\" and \"plot\"\n",
+    "    functions. Set the axes labels using the \"xlabel\" and \"ylabel\" functions.\n",
+    "    Assume the population and revenue data have been passed in as the x\n",
+    "    and y arguments of this function.    \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You can use the 'ro' option with plot to have the markers\n",
+    "    appear as red circles. Furthermore, you can make the markers larger by\n",
+    "    using plot(..., 'ro', ms=10), where `ms` refers to marker size. You \n",
+    "    can also set the marker edge color using the `mec` property.\n",
+    "    \"\"\"\n",
+    "    fig = pyplot.figure()  # open a new figure\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE ======================= \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"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now run the defined function with the loaded data to visualize the data. The end result should look like the following figure:\n",
+    "\n",
+    "![](Figures/dataset1.png)\n",
+    "\n",
+    "Execute the next cell to visualize the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plotData(X, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To quickly learn more about the `matplotlib` plot function and what arguments you can provide to it, you can type `?pyplot.plot` in a cell within the jupyter notebook. This opens a separate page showing the documentation for the requested function. You can also search online for plotting documentation. \n",
+    "\n",
+    "To set the markers to red circles, we used the option `'or'` within the `plot` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "?pyplot.plot"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section2\"></a>\n",
+    "### 2.2 Gradient Descent\n",
+    "\n",
+    "In this part, you will fit the linear regression parameters $\\theta$ to our dataset using gradient descent.\n",
+    "\n",
+    "#### 2.2.1 Update Equations\n",
+    "\n",
+    "The objective of linear regression is to minimize the cost function\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{2m} \\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)}) - y^{(i)}\\right)^2$$\n",
+    "\n",
+    "where the hypothesis $h_\\theta(x)$ is given by the linear model\n",
+    "$$ h_\\theta(x) = \\theta^Tx = \\theta_0 + \\theta_1 x_1$$\n",
+    "\n",
+    "Recall that the parameters of your model are the $\\theta_j$ values. These are\n",
+    "the values you will adjust to minimize cost $J(\\theta)$. One way to do this is to\n",
+    "use the batch gradient descent algorithm. In batch gradient descent, each\n",
+    "iteration performs the update\n",
+    "\n",
+    "$$ \\theta_j = \\theta_j - \\alpha \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta(x^{(i)}) - y^{(i)}\\right)x_j^{(i)} \\qquad \\text{simultaneously update } \\theta_j \\text{ for all } j$$\n",
+    "\n",
+    "With each step of gradient descent, your parameters $\\theta_j$ come closer to the optimal values that will achieve the lowest cost J($\\theta$).\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** We store each example as a row in the the $X$ matrix in Python `numpy`. To take into account the intercept term ($\\theta_0$), we add an additional first column to $X$ and set it to all ones. This allows us to treat $\\theta_0$ as simply another 'feature'.\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "#### 2.2.2 Implementation\n",
+    "\n",
+    "We have already set up the data for linear regression. In the following cell, we add another dimension to our data to accommodate the $\\theta_0$ intercept term. Do NOT execute this cell more than once."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add a column of ones to X. The numpy function stack joins arrays along a given axis. \n",
+    "# The first axis (axis=0) refers to rows (training examples) \n",
+    "# and second axis (axis=1) refers to columns (features).\n",
+    "X = np.stack([np.ones(m), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section2\"></a>\n",
+    "#### 2.2.3 Computing the cost $J(\\theta)$\n",
+    "\n",
+    "As you perform gradient descent to learn minimize the cost function $J(\\theta)$, it is helpful to monitor the convergence by computing the cost. In this section, you will implement a function to calculate $J(\\theta)$ so you can check the convergence of your gradient descent implementation. \n",
+    "\n",
+    "Your next task is to complete the code for the function `computeCost` which computes $J(\\theta)$. As you are doing this, remember that the variables $X$ and $y$ are not scalar values. $X$ is a matrix whose rows represent the examples from the training set and $y$ is a vector whose each elemennt represent the value at a given row of $X$.\n",
+    "<a id=\"computeCost\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def computeCost(X, y, theta):\n",
+    "    \"\"\"\n",
+    "    Compute cost for linear regression. Computes the cost of using theta as the\n",
+    "    parameter for linear regression to fit the data points in X and y.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1), where m is the number of examples,\n",
+    "        and n is the number of features. We assume a vector of one's already \n",
+    "        appended to the features so we have n+1 columns.\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The values of the function at each data point. This is a vector of\n",
+    "        shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The parameters for the regression function. This is a vector of \n",
+    "        shape (n+1, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The value of the regression cost function.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. \n",
+    "    You should set J to the cost.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "    \n",
+    "    # You need to return the following variables correctly\n",
+    "    J = 0\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE =====================\n",
+    "    J = (np.sum(np.square(np.dot(X,theta)-y)))/(2*m)\n",
+    "    \n",
+    "    # ===========================================================\n",
+    "    return J"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you have completed the function, the next step will run `computeCost` two times using two different initializations of $\\theta$. You will see the cost printed to the screen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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",
+    "print('Expected cost value (approximately) 32.07\\n')\n",
+    "\n",
+    "# further testing of the cost function\n",
+    "J = computeCost(X, y, theta=np.array([-1, 2]))\n",
+    "print('With theta = [-1, 2]\\nCost computed = %.2f' % J)\n",
+    "print('Expected cost value (approximately) 54.24')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions by executing the following cell.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): Y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |   0 /  50 | \n",
+      "                      Feature Normalization |   0 /   0 | \n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  50 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[2] = computeCost\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section3\"></a>\n",
+    "#### 2.2.4 Gradient descent\n",
+    "\n",
+    "Next, you will complete a function which implements gradient descent.\n",
+    "The loop structure has been written for you, and you only need to supply the updates to $\\theta$ within each iteration. \n",
+    "\n",
+    "As you program, make sure you understand what you are trying to optimize and what is being updated. Keep in mind that the cost $J(\\theta)$ is parameterized by the vector $\\theta$, not $X$ and $y$. That is, we minimize the value of $J(\\theta)$ by changing the values of the vector $\\theta$, not by changing $X$ or $y$. [Refer to the equations in this notebook](#section2) and to the video lectures if you are uncertain. A good way to verify that gradient descent is working correctly is to look at the value of $J(\\theta)$ and check that it is decreasing with each step. \n",
+    "\n",
+    "The starter code for the function `gradientDescent` calls `computeCost` on every iteration and saves the cost to a `python` list. Assuming you have implemented gradient descent and `computeCost` correctly, your value of $J(\\theta)$ should never increase, and should converge to a steady value by the end of the algorithm.\n",
+    "\n",
+    "<div class=\"alert alert-box alert-warning\">\n",
+    "**Vectors and matrices in `numpy`** - Important implementation notes\n",
+    "\n",
+    "A vector in `numpy` is a one dimensional array, for example `np.array([1, 2, 3])` is a vector. A matrix in `numpy` is a two dimensional array, for example `np.array([[1, 2, 3], [4, 5, 6]])`. However, the following is still considered a matrix `np.array([[1, 2, 3]])` since it has two dimensions, even if it has a shape of 1x3 (which looks like a vector).\n",
+    "\n",
+    "Given the above, the function `np.dot` which we will use for all matrix/vector multiplication has the following properties:\n",
+    "- It always performs inner products on vectors. If `x=np.array([1, 2, 3])`, then `np.dot(x, x)` is a scalar.\n",
+    "- For matrix-vector multiplication, so if $X$ is a $m\\times n$ matrix and $y$ is a vector of length $m$, then the operation `np.dot(y, X)` considers $y$ as a $1 \\times m$ vector. On the other hand, if $y$ is a vector of length $n$, then the operation `np.dot(X, y)` considers $y$ as a $n \\times 1$ vector.\n",
+    "- A vector can be promoted to a matrix using `y[None]` or `[y[np.newaxis]`. That is, if `y = np.array([1, 2, 3])` is a vector of size 3, then `y[None, :]` is a matrix of shape $1 \\times 3$. We can use `y[:, None]` to obtain a shape of $3 \\times 1$.\n",
+    "<div>\n",
+    "<a id=\"gradientDescent\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gradientDescent(X, y, theta, alpha, num_iters):\n",
+    "    \"\"\"\n",
+    "    Performs gradient descent to learn `theta`. Updates theta by taking `num_iters`\n",
+    "    gradient steps with learning rate `alpha`.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        Value at given features. A vector of shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        Initial values for the linear regression parameters. \n",
+    "        A vector of shape (n+1, ).\n",
+    "    \n",
+    "    alpha : float\n",
+    "        The learning rate.\n",
+    "    \n",
+    "    num_iters : int\n",
+    "        The number of iterations for gradient descent. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The learned linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    J_history : list\n",
+    "        A python list for the values of the cost function after each iteration.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Peform a single gradient step on the parameter vector theta.\n",
+    "\n",
+    "    While debugging, it can be useful to print out the values of \n",
+    "    the cost function (computeCost) and gradient here.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0]  # number of training examples\n",
+    "    \n",
+    "    # make a copy of theta, to avoid changing the original array, since numpy arrays\n",
+    "    # are passed by reference to functions\n",
+    "    theta = theta.copy()\n",
+    "    \n",
+    "    J_history = [] # Use a python list to save cost in every iteration\n",
+    "    \n",
+    "    for i in range(num_iters):\n",
+    "        # ==================== YOUR CODE HERE =================================\n",
+    "        theta = theta - (alpha/m)*(np.dot(X.transpose(),(np.dot(X,theta)-y)))\n",
+    "\n",
+    "        # =====================================================================\n",
+    "        \n",
+    "        # save the cost J in every iteration\n",
+    "        J_history.append(computeCost(X, y, theta))\n",
+    "    \n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After you are finished call the implemented `gradientDescent` function and print the computed $\\theta$. We initialize the $\\theta$ parameters to 0 and the learning rate $\\alpha$ to 0.01. Execute the following cell to check your code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "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",
+    "\n",
+    "# some gradient descent settings\n",
+    "iterations = 1500\n",
+    "alpha = 0.01\n",
+    "\n",
+    "theta, J_history = gradientDescent(X ,y, theta, alpha, iterations)\n",
+    "print('Theta found by gradient descent: {:.4f}, {:.4f}'.format(*theta))\n",
+    "print('Expected theta values (approximately): [-3.6303, 1.1664]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will use your final parameters to plot the linear fit. The results should look like the following figure.\n",
+    "\n",
+    "![](Figures/regression_result.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the linear fit\n",
+    "plotData(X[:, 1], y)\n",
+    "pyplot.plot(X[:, 1], np.dot(X, theta), '-')\n",
+    "pyplot.legend(['Training data', 'Linear regression']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pyplot.plot?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your final values for $\\theta$ will also be used to make predictions on profits in areas of 35,000 and 70,000 people.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-success\">\n",
+    "Note the way that the following lines use matrix multiplication, rather than explicit summation or looping, to calculate the predictions. This is an example of code vectorization in `numpy`.\n",
+    "</div>\n",
+    "\n",
+    "<div class=\"alert alert-block alert-success\">\n",
+    "Note that the first argument to the `numpy` function `dot` is a python list. `numpy` can internally converts **valid** python lists to numpy arrays when explicitly provided as arguments to `numpy` functions.\n",
+    "</div>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "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",
+    "print('For population = 35,000, we predict a profit of {:.2f}\\n'.format(predict1*10000))\n",
+    "\n",
+    "predict2 = np.dot([1, 7], theta)\n",
+    "print('For population = 70,000, we predict a profit of {:.2f}\\n'.format(predict2*10000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions by executing the next cell.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | \n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[3] = gradientDescent\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4 Visualizing $J(\\theta)$\n",
+    "\n",
+    "To understand the cost function $J(\\theta)$ better, you will now plot the cost over a 2-dimensional grid of $\\theta_0$ and $\\theta_1$ values. You will not need to code anything new for this part, but you should understand how the code you have written already is creating these images.\n",
+    "\n",
+    "In the next cell, the code is set up to calculate $J(\\theta)$ over a grid of values using the `computeCost` function that you wrote. After executing the following cell, you will have a 2-D array of $J(\\theta)$ values. Then, those values are used to produce surface and contour plots of $J(\\theta)$ using the matplotlib `plot_surface` and `contourf` functions. The plots should look something like the following:\n",
+    "\n",
+    "![](Figures/cost_function.png)\n",
+    "\n",
+    "The purpose of these graphs is to show you how $J(\\theta)$ varies with changes in $\\theta_0$ and $\\theta_1$. The cost function $J(\\theta)$ is bowl-shaped and has a global minimum. (This is easier to see in the contour plot than in the 3D surface plot). This minimum is the optimal point for $\\theta_0$ and $\\theta_1$, and each step of gradient descent moves closer to this point."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArcAAAFNCAYAAAAafEeVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvXdYnOl57/95ZobeiygCBEiIDhLqFaG6aqtd29u9Wdsn9jqOk6zjOI5P4t85juMTl5PdsznHzrrEsR2XrfHuaiXUVloJFYSEhISGoTfRQaL3Geb5/THMaEB0kEDwfK5rr4W33vPOK+Y793vf31tIKVEoFAqFQqFQKOYDmtkOQKFQKBQKhUKhmCmUuFUoFAqFQqFQzBuUuFUoFAqFQqFQzBuUuFUoFAqFQqFQzBuUuFUoFAqFQqFQzBuUuFUoFAqFQqFQzBuUuFUoFAqFYh4ihJBCiKgHePytQojCB3X8ySCE6BRCLJ3pbRWPJkrcKhQKhWLeI4R4QQiRPShs6oQQx4QQW2bguL8WQnxvJmJ81JBSnpdSxsx2HABSSncpZdlMb6t4NFHiVqFQKBTzGiHE14HXgX8GAoElwL8BT8xmXOMhhNDNdgwKxaOIErcKhUKhmLcIIbyA7wJflVL+UUrZJaU0Sik/klL+7eA2TkKI14UQtYP/vS6EcBpclyaEqBZC/I0QonEw6/uFwXUvA58FvjmYEf5ocHmcEOKsEKJVCJEnhDhkF89ZIcQX7X7/vBDigt3vUgjxVSFEMVA8gdcXJYQ4J4RoE0LcEUK8PWyTXUKIYiFEixDiJ0IIMbifRgjxbSFE5eDr+s/Ba4UQ4jdCiL8Z/DlkMKY/tztfs7CQJoSotoulQgjxDSFE7mA8bwshnO3Wf3Pw+tUKIb44VtnE4HX6nhDikvXaCiH8hBC/F0K0CyGuCiEihl23qMGffz34Wo8KITqEEFlCiGVjbPtvg5n8TiHERSFE0OA90CKEKBBCpIy0r93+3xv82XqvfNPuXnlSCLFfCFE0eN3+frz3VDF9lLhVKBQKxXxmI+AMvD/GNv8AbABWAiuAdcC37dYHAV5ACPCnwE+EED5Syp8Dvwd+NPio+3EhhAPwEXASCAD+Evi9EGIyj++fBNYD8RPY9p8Gz+UDhAL/b9j6g8Dawdf1DPDY4PLPD/63HVgKuAM/Hlx3Dkgb/HkbUDb4f4BU4LyUUo4SzzPAXiASSB48B0KIvcDXgV1AlN3xxuI54E+wXPdlQCbwK8AXyAf+5xj7Pg/8I5brUgL8rzG2fQbL++0P9A2e5/rg7+8Br00gVitBWO63EOB/AL8AXgRWA1uB/yFUve8DR4lbhUKhUMxn/IA7UkrTGNt8FviulLJRStmERRT9id164+B6o5QyHegERhOrG7AIxR9IKfullGeAI1jE1kT5vpSyWUrZM4FtjUA4sFhK2SulvDBs/Q+klK1SytvAJ1gEPFhe82tSyjIpZSfw34HnBkshzgFbhRAaLGL2R8Dmwf22Da4fjf8rpayVUjZjEfnW8z0D/EpKmSel7MZyjcfjV1LKUillG3AMKJVSfjz4Xr4LpIyx7x+llFcGt/29XRwj8b6U8pqUshfLl6BeKeV/SikHgLfHOc9wjMD/klIagbewCOR/lVJ2SCnzgDwsol/xAFHiVqFQKBTzmbuA/zj1q4uBSrvfKweX2Y4xTBx3YxGwox2rSkppHna8kImHTNUktv0mIIArgyUQ/23Y+nq7n+3jHuk164BAKWUpFgG/Eku28QhQO5h9Hk/cjnU++9c1kdfYYPdzzwi/j/YejBXHTJ9nOHcHRbF135GOP5njKaaAErcKhUKhmM9kAr1YHvWPRi2W7KeVJYPLJsLwx/O1QNhg1tP+eDWDP3cBrnbrgiZwzNFPLmW9lPJLUsrFwJeBfxutjnWEOIe/ZhP3hNg54CnAUUpZM/j7S1ge89+YaHx21GEpm7ASNoVjzAW6Gf/9U8wyStwqFAqFYt4y+Ej7f2Cpk31SCOEqhHAQQuwTQvxocLM3gW8LIRYJIfwHt//dBE/RgKVm1UoWFgH7zcHzpAGPY3lEDRZh+OnBOKKw1PCOyWBz1XdGWfe0EMIqGluwCOOBkbYdxpvAXwshIoUQ7licJN62y1CfA/4CyBj8/SyW+uELdpnJyfAO8AVhabZzxXKNH0VuAC8IIbSDdcQTqR1WPGSUuFUoFArFvEZK+RqWZqZvA01YHon/BfDB4CbfA7KBXOAWlmaiiXrX/hKIFxZnhA+klP3AIWAfcAeL5dhLUsqCwe3/D9CPRRT/Bks96HiEARdHWbcWyBJCdAKHgVeklOUTOOZ/AL/FIl7LsWS3/9Ju/TnAg3vi9gKWjGUGU0BKeQz4v1jqfkuwZNTB0sD1KPEKli8rrVjqlj8Ye3PFbCBGb3hUKBQKhUIxmwxmZd+VUm6c7VhmEiFEHKAHnMZp9lMoJo0StwqFQqFQKB44QohPAUcBNyxZa7OUcqxaaIViSqiyBIVCoZjjDNb35Qghjsx2LArFNPgylrKQUix1wV+Z3XAU8xU12k+hUCjmPq9gMa33nO1AFIqpIqXcO9sxKBYGKnOrUCgUc5jBmssDwL/PdiwKhULxKKDErUKhUMxtXsdi1G8eb0OFQqFQjF+WoLrNFArFo4yY7QCmgxDiINAopbw26Jc60jYvAy8DuLm5rY6NjX2IET6a1DS10d7VC4BGCNxdnfByc8bNxQnxSN8xigdNbWc7d3u7AdAIDd5Ozvg4ueDq4DDLkc0Prl27dkdKuWi6xxnPLUGJW4VC8SjzSEsVIcT3gT/BMjnKGUvN7R+llC+OtP2aNWtkdnb2Q4zw0aS1s4fTV4o4npnPzeJ7g8i8PVzYuTaavRtjSY5ajFBKVzGMtr5ePior4N0iPTea6mzLl3r58NTyRD69PIFgN49ZjPDRRghxTUq5ZtrHUeJWoVDMY+aNOhnM3H5DSnlwtG2UuJ08NU1tnLxcwPHMAspr79qWL17kxWMbYtm7MZbIxX6zGKFirlLUcof3ivT8scRAU08XYPmDszUkgqejE9kTvhxnnerbnwxK3CoUCsX4KHGrmBBSSoqr7nA8M5+TlwtobOm0rYsND+CxjXHsWR/DIh/3WYxSMRcxmc2cr6ng3SI9pypL6DdbphN7OjpxaFkcz0QnkuwfpJ4ETAAlbhUKhWJ8FtSniRK3M4PZLLleWMXxzAJOXy2iq6cfACFgdWwY+zbFsX3NctxdnGY5UsVco7W3hw9K83m3SI/+boNt+XJvP56KTuTTUfEEuKovSKOhxK1CoVCMjxK3imnR12/i4s0yjl8u4OLNcowmS1bOyUHL1pRl7NsYx4akCBx02lmOVDHXyL/byHvFebxfYrA1oWmFIC10Kc/EJLIjbBmOWnXf2KPEreKRpaGhgaeffpqcnBxefvllXn311dkOSTF/UeJWMWO0d/VyJruYE5n5XCuoti33cndm17oY9m2MIykqWD1+VgzBaB7gk6oy3i3Sc+Z2GSZpcfXzdXbhU1HxPLU8kXi/gFmOcm6gxK3ioXLhwgW++c1vkpeXh1arJS4ujtdff521a9dO+lj/9E//RE5ODv/1X/+lPgQUD5oFdYMpcfvwqL/bzonMAo5l5lNWM7QRbe+GWPZtiiM82HcWI1TMRZq6u/ig1MC7RXoKW+7Ylif4BfB0dBJPLovDx9llFiOcXZS4VTw02tvbWbJkCW+88QbPPPMM/f39nD9/nqCgIJKTkyd8HCklUkpefvllgoKC+N73vvcAo1YoACVuFQ8YWyPaJQMnswqHNKLFRwayb1Mcu9fH4uvpOotRKuYaUkpu3WngnaJbfFiaT3t/HwCOGi27w6N4JjqJrSHhaDULa9aWEreKh0Z2dja7du2itbX1vnXf+c53KCkp4Xe/+x0AFRUVREZGYjQa0el0pKWlsXnzZs6ePcv169f5zGc+w9tvv40QAkdHRz744AM8PT155ZVXyM/Px8XFhc985jO89tprODo6ApCXl8fXvvY1rl27hoODA6+88gp///d/j9ls5kc/+hG/+MUvaG1tZefOnfz0pz/F11dlSxQ2lLhVPDQGzGauF1RzPDOfM1eL6eq1NKJpNYL1ieHs3RjHtlVRuDgpw3/FPXpNJk5VlvBu8S0yqitswivI1Z3PLE/gqehElnotjM81JW4VD4329nYiIyM5ePAgzz33HBs2bMDHxweYmLgtKyvj2LFjxMTEIKXkS1/6EqGhobbM7bVr1zAajaxZs4bq6mr27dvHl7/8Zb72ta/R0dFBdHQ03/jGN/jqV7+K0WjEYDCwfv16Xn/9dd566y3ee+89Fi1axF/91V/R3t7Om2++OWvXSjHnUOJWMSv09hs5f6OMYxfzydRXMDBgqbN0cXIgbXUU+zfFsyY+bMFl5hRjU9vZzn8V5/FesZ6K9nsJpTWBITwTncSByBjcBxM/8xElbhUPlfz8fH74wx/y8ccfU19fz/79+/nFL37BG2+8Ma64TU1N5bvf/a7tWJ///OeHiNvhvP7665w7d47333+fN998kx/96Efk5OTct11cXBw//vGP2blzJwB1dXUsWbKEnp4edMo4W2FBiVvFrNPa0cPHVwo5lpnPrZJ7U638vd14bEMs+zbGsXzJItWDoLAhpeRqQw3vFN3iaFkh3SYjAK46Bw5ExvBMTBJrA0Pm3T0zU+JWKQDFhIiLi+PXv/41AAUFBbz44ot87WtfIyYmZtx9w8LCxlxfVFTE17/+dbKzs+nu7sZkMrF69WoAqqqqWLZs2Yj7VVZW8qlPfQqNXeZDq9XS0NBASEjIBF+ZQjF/6OszceVSMSlrl+LgoCyG5greHi48tXMlT+1cSXVjK8cu5XM8M5+qhlZ+f/wavz9+jWWhfuzdGMfeDXEE+qnxrQsdIQTrgkJZFxTKP27cydHyQt4pvMXVhhreLdbzbrGeCE9vnlqeyFPRiWrk7zDU8xDFpImNjeXzn/88er0eNzc3uru7bevq6+vv2368b5Zf+cpXiI2Npbi4mPb2dv75n/8Z6xOFsLAwSktLR9wvLCyMY8eO0draavuvt7dXCVvFgqWtpYtv/81bPHvgNV793mGuZpZgGvRlVcwNQgO8+dKTG3nvB1/gl99+jqd2rMDTzZnS6rv85N0LHPrGL/jKD9/lo/N6Onv6ZjtcxRzAzcGRZ6KTeO/xF/jk6T/lqyvWE+TqTkV7K/9y7QKb3voZLx1/j6NlhfQNmGY73DmBEreKcSkoKODVV1+lutri61hVVcWbb77Jhg0bWLlyJRkZGdy+fZu2tja+//3vT/r4HR0deHp64u7uTkFBAW+88YZt3cGDB6mvr+f111+nr6+Pjo4OsrKyAPizP/sz/uEf/oHKykoAmpqa+PDDD2fgFSsUjyaOTjoili6is6OXE0dv8g9ff5Nn97/Gq//rIyV05xhCCJKiFvPNl3Zy7F+/zKuvPMHOtdE4aLVcy6/in355kn2v/Ixvv3GUCzfK1HunAGCply/fXJvKpee+zG8ee4oDkTHohIZz1eX8+ZnDrPvDG3wn8zSGu42zHeqsosoSFOPi4eFBVlYWr732Gq2trXh7e3Pw4EH+9//+33h6evLss8+SnJyMv78/f/d3f8fhw4cndfx/+Zd/4eWXX+ZHP/oRKSkpPPvss5w5c8Z27lOnTvHKK6/wj//4jzg5OfG1r32N9evX88orryClZM+ePdTW1hIQEMCzzz7LE0888SAug0Ix5/H2cePnv/8zblc0ce60gYwz+VSWNXHiyA1OHLmBh4czm1JjSN0ZT8raSHRqqtacwEFnmXa2NWUZHV29nM4u5tglAzmFNZzMKuRkViE+Hi7sGfTPjYsInHe1lorJodVoSAuLJC0skpbeHj4oMfBO0S0MzU38Ku86v8q7vqC9c1VDmUKhmM8sKAUwUkNZZblF6J4/Y6Cy/J5pvKeXC5vTYknbmUBySjhanXqQN9eobWrjxOUCjl3Kp6Ku2bY8crEv+zbFs3djLEF+nrMYoWKuoR/0zv2gNJ+2vl7A4p27JzyKZ2KS2LJ4bnvnKrcExYwjpWRgYIC+vj50Oh06nQ6NRqMyBIpHmQV1847nllBZ3kTGGQPnPjZwu+Ke0PXycWVrWhypO+NJWrkErXbufvgtRKSU5Fc0cOxSPicvF9DS0QOAELAqJpR9m+LZsXY57i5OsxypYq7QazLx8e0S3ika6p272M2Dp6ITeXp5Iks8vWc1xpFQ4lYxo0gpMRqNNnFrj1arxcHBAa1Wi1arHeJOoFDMcZS4HQEpJRWljZw9bSDjtIGaqntZQW8fN7Zuj2PbrngSVyxBo1lQl3DOYzINcFlfSfolAxnXS+kfrMV1ctCSmhLF/s1xrE+MQKe+oCgGqe1stzgsFOmp6mizLd8YvIRnohPZHxmNs25uDBZR4lYxI1iztUajxUNPCEF/f78tW2sdmTv8PjGZTHh6etrErsruKuYoC+rGnIrPrZSSspIGzn1sqdGtrb4ndP38PUjdYcnoxiWGKqE7x+js7uP01SKOXcrnemG1bbmvpyuPbYzlwKZ45Z+rsGGWkst1VbxbdIv08iJ6B50VPB2dOLQ0lmdikkj2D5rV+0WJW8W0MZvNGI1GzGYzQgiEEEgph4jb4Ugp6enpoaSkhISEBNtyaxmDtZRBZXcVc4QF9ak+3SEOUkpKi+o5+3Ee507n01B3b0LSokBPtu2IJ3VnPDHxi5VgmmPU3WnneGY+Ry8auF3fYlu+LNTPVp8b4KO8UBUW2vv7+Kg0n3eK9NxoujdYJNbHn2diknhyWTx+Lq4PPS4lbhVTxpqtLSkpISAgAFdX1yGZ2rHELUBvby/FxcUkJSXZ9pFS2kQygEajsYldld1VzCIL6qabyQllUkoKDbWcO23g3GkDdxrbbesCg71J2xVP2q4Eli5XnftzCSklhvJ60i8aOJlVSFunpalICFgbv4QDm+NJW70cF6e58RhaMfsUNDfxTtEt3i8x0Nxrqed20GjYtSSKZ2OSSA2JeGhNaErcKqaEfbY2Ly+P8PBwPD3vddtOVNwWFRWRnJw84nr7UgYppS0rrNVqhwhe9YGoeAgsqJvsQY3fNZsl+frqQdeFfO7e6bCtC13iR9queLbtSiA8ctGMn1sxdYymAS7llnPsUj7nb5RhHKzPdXV2YPvq5ezfHM/q2DBVbqIAoH9gYLAJTc+56nLMg/owyNWdp6ITeTY66YE3oSlxq5gUUkpMJhMmk6XGRghBXl4eYWFheHl5DdluPHHb19dHYWHhqOJ2tPNbs7t37tzByckJb29vdDqdrVnNKoIVihlkQd1QD0rc2mM2S/Q3b3P2VB7nP8mnrfXehMKIpYvYtiuBtF3xhIT5PdA4FJOjvauXU1mFpF8ycKvk3mPoAF939m2MY//meCIXq/dMYaG+q4P3ivN4p+gWle33ypMedBOaEreKCTNSbS1AXl4eISEheHvf+yY2UXFbUFDAihUrphRPRUUFrq6u+Pv72xrVpJT3lTKo7K5iBlhQN9DDELf2DJjM3LhewdlTeVw8V0BnR69t3fLYYNJ2JbBtVzwBgV5jHEXxsKmsb+H4JQPpl/Kpu3Ov3CQ+MpD9m+PZsyEWb/eFZfqvGBmzlFypr+btwtwRm9Cei00m0W/mSpOUuFWMy0jZWvsb0GAwEBwcjI+Pz5B9xhO3/f395OfnT1vcBgQE3BfvcGeGkUoZlOBVTIIFdbM8bHFrj9E4wPUrZZz7OI9LGYV0d/fb1iUkh5G2K4GtO+Lw9XOflfgU92M2S24U15B+0cDpq0V09VjeM51Ww+YVkezfHM+WFUtxUJPsFFia0I6UFfBWYS43m+pty+N9F/FMTPKMTEJT4lYxJmazmf7+/iE1r8PJz88nMDAQX19f2zIpJX19fWO6HfT392MwGFi5cuWUYhtN3A5nJLErhMBsNuPs7Iyjo6NqVFOMx4K6OWZT3NrT32fiSmYxZ0/lcflCMf39li/YGo0gKSXcInS3x+Lp9fC7sRUj09tv5Nz1UtIvGsjSV9rqLT3dnHlsQwz7N8cTHzm7NlGKuUNBcxNvF1qa0Fr6LE1ojhotj0Us59noJDaHhKOZwr2ixK1iROyzteNlOQsKCli0aBF+fpY6q4GBAYqKimhsbMTJyQkvLy+8vLzw9PTE0dHRtp/RaESv15OSkjKlGCcqbkd6bQC5ublERUXh7OwMqCETijFZUJ/Ec0Xc2tPd1cflC0WcO23gamYJJpMZAK1Ww5r1y0jbk8CmrTG4uDqOcyTFw+JOayfHMwtIv2igpPreJLuIYF8ObI5n76Y4An2VrZgC+gZMfFxZyttFt8ioLreJxlB3T56OTuTp6CRC3Cc+IlqJW8V9TCRba09hYSF+fn74+/vT3NxMfn4+YWFhBAQEMDAwQFtbm+0/k8mEh4cHXl5euLm5UVpayqpVq6YU51TFrZXc3Fyio6NxdnYeMburbMgUdiyoN34uilt7Ojt6uXiugLMf55FztRyz2fLv1slJx/rNy0nbncDaDVE4OSubqrmAlJLi200cuWjg5OUCmtstzYPKVkwxEtZJaO8U6qnutExCE0BqaATPRiezK3wZTlrdmMdQ4lZhYzLZWnuKiorw9PSkubmZ7u5uEhIScHZ2HrHm1mw209nZSVtbGy0tLTQ3N+Pj4zMku6vVTqwuaybF7XCs97PZbB6yXA2ZWLAocTtHaWnu4vwZA5+cyiMvt8q23NXVkU2pMaTtSWTV2kh0qt5zTmAyDZCpr+Tohbz7bMV2rInm4JZ4VkarKXYKSxPapdpK3iq8xYmKYvrNlnvFx8mFTy+P57mYZKJ9/EfcV4lbhW0Yg8lkmnC21p6bN2/S2trKsmXLCAkJmdCEMrCM3r158ybx8fG0tbXR3t5Oe7ul49bT09MmeEcSn2ARty4uLgQGBk7uBQ8ylrgdieFDJurq6ggKCsLJyUlld+c/C+pNfZTErT2N9W1knDFw9uM8ivLv2VR5ebuydUcc23cnkpCs/FjnClZbsaMXDehL771fwf6eHNgcz/7N8YQGPFg/VMWjQWtvD++X5vN2YS75zU225SmLgnk2JpnHl8biblf2qMTtAkdKidFoJCcnhxUrVkxKmBmNRgoLC2lubiYyMpKwsLAhxx1P3A4MDHDjxg1Wr149ZLnJZKK9vd1WytDf34+rqyteXl54e3vj5uaGRqOhsrISZ2fnKYvbmzdvEhsbi5OT05T2z8nJIT4+Hp1Op4ZMzH8W1Jv4qIpbe2qqmvnklJ5PTuqpqrxrW74o0JNtOxNI253A8hjV2DRXqKxvIf2igfSLBhqa7w33WBEdwoHN8exaG42769T+VivmD1JKbt1p4O3CXD4szafDaHHmcNU5cGBpDM9GJ7EmMASNRqPE7UJkeLb28uXLbNy4ccJ/6JuamigqKiIiIoKenh7c3d0JCgoacvypituRYu3q6rKJ3c7OThwcLLVZHh4ehIeH236fDNMVt9evXyc5ORmd7l7tz0gjhJUN2bxgQb1h80HcWpFSUlbcwCen9Jz92EBjfZttXUiYL9v3JLJjTyKhS9TggbmA2SzJLqji6IU8PskupnfQIcPJQcu21VEc3JLA2vglD22Mq2Lu0mMykl5eyNuFt8iqr7YtX+7tx+mn/1SJ24WGVXjaD2PIzMxk/fr149aQGo1GCgoKMBqNxMfH4+zsTFlZGS4uLgQHB993jrFEnNls5vr166xZM/n7r7+/n5KSEoxGIyaTCbPZbGtU8/LywsXFZVwB+SDE7XCGN6qpIROPLAvqDZpP4tYes1mSf6uasx/nce60gdaWLtu65bHBbN+dwLZdCSwKmHhXtuLB0dXTz5nsItIvGrhWcE+8BPi4s29THAc2JxCx2HeMIygWCmVtzbxTeIv3ivVEefvz9sHnlLhdKFiztUajERg6jCErK4vVq1ePKdQaGxspLi5m6dKlBAXde5xXXl6Ok5MTixcvHnKuBylugSFlCWazmY6ODlt2t7u7GxcXF5vY9fDwuK9Rbbri9tq1a6xcuXLCDXBWrGK3uLiY4OBg3Nzc7rMhU9ndOceCejPmq7i1Z8BkJudaOWdP5XHhbAHdXX2ApYM/ccUStu9OZOuOOLy8lYfuXKC2qY30SwaOXjBQ03Qv+56wNIgDWxLYsz4GT7eJ9U8o5i9G8wB3e7oJdvdU4nYhMNroXCtXrlwhJSVlxMf71kliUkri4+OHeNWCpbHLwcGBkJAQ27KJiFspJdnZ2axdu3ZKr2msmlspJT09PTax29HRgUajGdKolp+fP+LrmSjZ2dmsWrVqyo4JeXl5RERE4OrqOuKQieHODErszioL6uIvBHFrT3+fiaxLxXxySk/WxWKM/ZaubK1Ww5oNy9jxWCIbtkTj4qI8dGcbKSU3imo4ciGPM1eL6eq11Fw66rSkrlrG41sSWJcYrsoWFjgz1VA2tuGYYtYYb3SuFY1Gc5/tFUB9fT2lpaUsW7ZsSE2tPVZ3hJGWj8VMiLXRvlQJIXB1dcXV1dVWLmEymWxit6amhvb2dgoLC/H19bX57j5MAWnfhGZ/XutrMhqNtiw7qCETCsWDwtFJx9btcWzdHkdXVx+XzhXwyck8rmeXkXWxmKyLxTi7OLApNYbtuxNZvX6pshabJYQQpMSEkhITyt++uIOz10o4cjGPq4bbfHyliI+vFOHv7WYrW1gaomqpFVNHids5yHjZWnuGC9S+vj4MBgMajYa1a9eOmd0cTdw+aCYrRHU6HX5+frZJajk5OYSEhNDd3U1lZSVdXV04OjoO8dwdr552OmJ4tP3tG9HstzWbzfT29tqWmUwmNBoN7u7uyoZMoZgh3Nyc2L1/Bbv3r6CluZNzpw2cPZmHQV/NmRN6zpzQ4+nlwtbtcex4LElZi80izk4O7N0Ux95NcTTc7SD9koEjF/Koamjlt+nZ/DY9m/jIQA5uSWD3+hi83F1mO2TFI4YSt3OIiWZr7bFmbqWU1NXVUV5ezvLlyyc8IGE2xO1M4O7ujq+vL6GhoYBF1Le1tXH37l3KysqQUt7nuWt/LR+EuB2JkbK7zc3N9Pf322KHoUMmVKOaQjE9fHzdefLpdTz59Drqalps1mJX3I7iAAAgAElEQVSV5Xc4+sF1jn5wnYAgL7bvTmDHY0lELpvaQBnF9An08+ALj6/n8wfXcaukjiMX8jh1pRBDeQOG8gb+z5vn2LZqGQe3JLAuIRydVj35UoyPErdzhMlka+0RQtDX10dBQQEODg6sW7duwvZao5U0PIo4OTkREBBgE/UDAwM2z93GxkZ6enpsnrsDAwOYzeYplwdMJ/NrzZZbSxSsx7M2DNqv1+l0ODg42CaqKcGrUEye4BAfXvj8Vp7/3BbKSxv55KSeMyf1NNa38fZvL/H2by8RuSyAHY8lkrYrgcBgNXxgNhBCkLx8McnLF/P1z6Zx7nopR87nccVQaStbWOTtxr5N8RzYEk/kYlW2oBgd1VA2y0x1dK5138uXL2MymYiNjWXRokWTOnd1dTUmk4mIiIghxxyvoQzg6tWrU24ou337No6OjqPWAo9HTk4OiYmJk/LIlVLS3d1NW1sbpaWlODs7o9Vqh2R3J9qgduPGjWk1tNXU1AAMaeQbHqv9f2rIxLRYUBdpoTWUTRWzWaK/eZszJ/ScP2Ogo+Ne2VDiijB27EkidWccnl7KcWG2abjbwdGLBo5etJQtWElYGsTBQbcFD+W2MG9QE8rmAWazmbq6OqSU+Pv7T0qs9Pb2kpeXR1dXF4mJifj6Tt4zsLa2lv7+/gUhbu2xxm40Gm2Nam1tbZhMJtzd3fH29sbLywtXV9cRr8N0z19VVYVOpxviLzwew4dMVFdXEx4eroZMjM+CuiCrV62WV65eRase3U4Yo3GA7MulfHJKT2ZGIX19lrIwnU7D2o1R7NhjcVxwcp7av3fFzCCl5GZxLUcv5PHxlaIhbgtpq6M4uFUNiZgPKLeERxj7bG1PT8+kHnNLKampqaGyspLY2Fjq6uom7dc6/HgLFQcHB/z9/fH39wcsXzY6Oztpa2ujvLycrq4unJ2dhzSqabXaB9aQNhZW4WotpWhoaCAsLIy+vj76+vps26ghEwubljsdfHb9d9i4K4FNe5NZuWk5Do7qz/xYODho2bg1mo1bo+nu6uNSRiGnT9wi52o5meeLyDxfhKurI5vTYtm+J5GU1ZFodUpAPWyEEKyMDmFldAh/89ntnL1WwkcXLG4LJ7MKOZlVSICvO/s3xXNgSwLhQT6zHbJiFlF/9R4i1syb0Wi0CRyNRjPENmosenp6yMvLw9XVlfXr16PT6WhoaJhy3axGoxlV3E5XwI3HdET1gxLkVj9dT09PwsLCAEuGvK2tjaamJkpLS23Lmpqa8PHxwdl58o/DplPva8Ve6Fqxfmkay4ZMZXfnN309/bTd7eT421kcfzsLNw9nNuxKZMu+ZFalxuDopLKPY+Hq5sSufcns2pdM891Ozp7K48zJWxTl13EqPZdT6bn4+rmTtjuBnXuTiIoOUv+eZgF7t4W6O+0cvZjHkQsGapva+PWRK/z6yBVWLF/MwS0J7FoXg5vyOV5wqLKEh4SUEqPRyMDAwBCBUVdXR09PD0uXLh1z36qqKqqrq4mNjR1SgpCfn09gYOCUyhLq6+vp6upi2bJltmWtra0UFRXh4uJiezw/koCbTlnCVB7L2zOR8bljMZ3YTSYT2dnZBAQE0N7eTl9fH25ubrbsrru7+7jCtby8HHd390nXSFuZ6BCN4SOEYUEOmZjXL244a9aske/+7jCXTtziwrFcKgrrbOtc3JxYtyOeLfuSWZMWh7P6wJ8wVZV3+ORUHmdO6KmtbrYtXxLhz47HEtm+J5HgxSpTOJuYzZIbxTUcOZ/H6atF9PRZvuQ7O+rYsTaax7ckkBITquzf5jiq5vYRwdoJbzKZhjQHWWloaKCjo4OoqKgR9+/u7iYvLw93d3eio6PvK0EoKChg0aJFNg/YydDY2Eh7eztRUVGYzWZKSkpobW0lKipqSD2qvYDz9vbGzc1tWhPKHmVxa91/zZo1NmeDrq4u27Xq7OxEp9PZrpWnp+d9tbmlpaV4e3tP6T0DixPEjRs3WL169aT2s/5bN5vNNjuyoKCg+T5kYkF9kg1vKKsua+Ti8VzOp9+kNK/GttzJ2YE1abFs3pvM+p0JuLqrhpyJIKWkwFDLmRO3OPtxHm0t3bZ18Umh7NybxLad8aoRbZbp7u3nzNViDp/Xc6Po3n2/eJEXB7fEc2BzAsH+nrMYoWI0lLh9BLA2Z41l79XU1ERLSwvR0dH37VtZWUltbS1xcXH4+IycFbBO6ppKFrCxsZG2tjYCAgIwGAwEBwcTHh4+pGzCGotVwLW2ttLV1UVPTw/h4eFDalEnynwQt2Pt39/fP6RRzWw24+HhYcvu1tTU4OfnN6VsO1gmoOn1elJSUqb6EqitrcVsNhMSEnJfdlej0Qyp3X3Es7uPbOBTYSy3hLrbd7l47CYXjuVSePO2bbmDo44122LZsi+Z9bsScfNQQncimEwDXMsq48yJW1wa3oi2KYqdjyWxYXM0jk6q+m82qWpo4cgFi9tCY3MnAELAmrglPL41gbTVUTg7qnKduYISt3MYe99SGHsYw927d2lqaiI2Nta2rKurC71ej7e3N1FRUWMKx+LiYry8vCY8tMGexsZGysrKEEKQkJCAu7s7YBFn49XcZmVlERERQVtbG+3t7Qgh8PT0tJUyjGWTNV1xe+3aNVasWDFnxe1wzGYzHR0dNrHb2tqKq6sr/v7+eHl54eHhMakvB1Zf4xUrVkwlfMBiA6fRaFi8ePGQ5fbZXXse4SETj0ygM8FErcCaalu4eOIWF4/lkpddbnvfdY5aVm+1CN0NuxNx91SToSZCT3c/F88VcOaEnutXyzCbLdfTzd2J1B3x7HwsicSVS9Qj8VlkwGwm21DFRxf0nM0uod80AIC7ixO718dwKDWB+EhVQz3bKLeEOcpkhzHYj8CVUlJRUUFdXR0JCQl4eXmNe76pjtDt6OigsLAQR0dH1q5dO+lH0RqNhsDAQAIDAwFLLapVvFVVVWEymWzZSm9vb1xcXGb0j8aj9AdIo9HYsrZgKSXx9fXFbDbT0NBAcXGxrZnNup2Tk9Oox7PeW9PBbDaP+OVgtBHCIw2Z0Gg0ODo6zofs7oJj0WIfnvxCKk9+IZW7DW1cOnGL8+k30V8pI+t0Hlmn89A5aFm5eTlb9q1g055EPLzdZjvsOYuLq+OQRrRPTuo5feIWJYX1HDucw7HDOSwK9GTHnkR27k0iYqmaiPaw0Wo0rE8MZ31iOO1dvZzMKuTIeT2G8gbeP5vL+2dziVzsx+NbE9i3KQ4/L3W/P8qozO0MMZlsrT2tra3U1NQQHh5OXl4evr6+LFu2bMJis6ysDBcXlwlnQc1mM+Xl5TQ1NRESEkJXV9eQrDFMLHM7XvbSaqvV2tpKW1sbPT09uLi44OXlZavhHZ41nCjXrl1j5cqVU7ZAe9iZ2+Hk5+cTGhqKh4eHbZn9l4O2tjaMRuN9jWrW96O7u5uysjISExOnHENFRQWurq5TyvhbyxgKCwsJCgrC09PT1qhmHTQxh7K7cyKIh8V0hzg0N7WTeVLP+fSb3LpcYstAanUaUjZHs/XASjbuScRD1ZROiMryJs6cuMWZE3oa6ttsy6Oig9i5N4ntexLx9XOfxQgVpdV3+Oh8Hscz82lut9RQa7UaNidHcig1kU1JEeh0U7fbVEwOVZYwh5jq6FyAtrY28vLybKUBnp6TK3IvLy/HyclpQkKxs7OTvLw8/Pz8WLp0Ka2trTQ0NBAXFzdku5kQt8ORUtLT00NbWxs1NTX09/fj7OxsK2Pw8vKacJnBdMXtlStXWLdu3ZT2hemLW4PBwJIlS2xlICMhpbR57ra1tdHV1YWDg4Mtq9vS0jItcTvdpjaAvLw8IiIicHNzu2/IBGATusXFxcTGxk55ots0UeJ2irTe7bS4LqTf5OblEswDllIVq9Ddsl9ldCeK2SzJy63i9PFbZJwx0Dk4EU2jFaxau5Sde5PYlBqDi3KwmDVMpgEu5pbz0fk8Lt4sY2Dwi52vpyv7N8VxcGsiS0PUyN8HjRK3cwBro9XAwACOjo6TFrYdHR3k5uYipWTTpk1T6lKvqKhAp9MRGho6ZpwVFRXU19cPEdAtLS3U1dURHx8/ZPsHIW7tqaqqQqvV4u/vf1/jlfXRvLe396gestnZ2aSkpDyy4lav1xMZGYmb2+REQV9fn81zt7m5GWdn5yGlDM7OzhO+/4qLi/H39x+1UXEi5ObmEh0dPeL7ZG9DdujQIT788MNpnWsaPNLiVgjhDGQATljKyN6TUv7P0bZ/UON3rUL3fPoNcjOHZnRXblrO1gMr2fRYksroToD+PhOXLxZx+vgtrmaWYDJZvjQ4uziwZVssu/Yls2J1hJoyN4vcae3i2CUDH53Po6LunvVb4tIgHk9NZPf6GNxdRi8dU0wdVXM7y1iztTU1NeOKy5H2LSsr486dO0RHR9uae6bCWIMY4F5zmo+PD+vXrx9ynqnW604XqwBzdHRk0aJFNqeHgYEB2tvbaWtro7CwcEQLMuu+c+SR95SQUk7p/XZyciIgIABHR0ccHBxYtmyZrVGtuLiYnp4eXF1dbWLXw8Nj1PPMxCCJsY5h/0Wvq6tr0kJeYaMP2CGl7BRCOAAXhBDHpJSXH2YQ3n7u7H9hI/tf2Ejr3U4yT1pqdG9mlnAto5BrGYX8+NvvsWprDFv3r1DNaGPg6KQjdUc8qTviaW/r5txpA6eP3cKgr+bj47f4+Pgt/Bd5sH1PIrv2JhEZFTjbIS84/L3d+JP9a3lx3xr0pXUcuZDHyaxC9GX16Mvqee0PZ9m5NppDWy3euY/y59F8RYnbSWI/OlcIgVarndSEsPb2dvLy8ggMDGTdunW2LOlUGU2gSim5ffs2NTU1xMfH4+3tPeF9ZwutVouPj48tw2dvQVZZWUlXVxeOjo709fXR2tqKl5fXtEYPzxZTFbdWrKJSq9Xi7e1te2+tpR+tra3U1tbS2dk5pJnN3sViYGBg2tduoscYGBi4z+tXMTGk5R9o5+CvDoP/zeo/Wm8/d/Y9v5F9z2+krdmS0c04asnoXjlj4MoZAzoHrRK6E8DTy5XHP72Gxz+9hpqqZk6fuMXp47eoq2nh3d9n8u7vM1m6PJBdg/W5fv4e4x9UMWMIIUiKWkxS1GL++vk0zmQX89F5PdcKqkm/aCD9ooHQAC8ObknkwJZ4An3V+zNXUOJ2EpjN5iGP7K3itq+vb0L7lpSU0NLSQlJSkq3eUggx5fG5wIjje62DHzw8PFi/fv2oAmSuidvhCCFwd3fH3d2dkJAQwDL6Nicnh6amJpuN2UQtyOyPO5tM1+1gtIypEAJXV1dcXV1tNdj2wzisLhbu7u50dXXR29s7JBs+U3EoZhYhhBa4BkQBP5FSZg1b/zLwMsCSJUseamxevveEbuudDi6euEXGkRz0V8ruCd1Be7Ftj69kw65EXNzU49yRCAnz5aUvbuNP/jQVQ241Hx/P5dxpA2XFDfy8uIF//8lpVq1dyq59SWzaFouzs/rC+DBxdnJg/+Z49m+Op7qxlSPn8zhyMY/qxjZ++seL/Pz9S6xPDOfxrYmkpizF0UHJq9lEXf0JMDxba/+BrtFoxhWn1qax4OBg1q1bN0RMTGT/sRhuJVZdXU1VVdWYgx9G2nciy+cCzs7O6HQ6li9fjkajGeIyUF1djdFofKAWZDPBTIjbie7v4OCAv78//v7+tn07OzvJz8+npqaG0tJSnJ2dbZnd0QZyCHMdUnO/I8d4cVjvo7n2HjxKSCkHgJVCCG/gfSFEopRSb7f+58DPwVJzO0th4u3vwYHPbuLAZzfR0tTBxRO5XEi/Se7lUpu9mKOTjrXb49l2cCVrd8SrEcAjIIQgYUUYCSvC+MpfP8aVSyWcPp5L1sVisrNKyc4qxcXVkdTtcezcl0xySrjyz33IhAZ482ef2cyXPrWRK/pKDp/PIyOnlMxbFWTeqsDL3Zl9G+M4lJpIVNjUxqwrpocSt+NgtfcaaXQujC1OBwYGKCkpoa2tjRUrVoxYdzhdcWvdv7e3F71ej6urK+vWrZuQ88BcFrHjYX0fdDodfn5+tq5/ewuy0tLSIRZk1jrU2WYmyhKmWlJg9dN1dHQkPj4eBwcHent7bY1qpaWlAPca1Tzd8dD+JxpzMX3Or005ZsX0kVK2CiHOAnsB/Tibzyo+izw4+OJmDr64meamdi6k3+TckRsYssu5eDyXi8dzcXJxZP3OeFIPrGRNWixOzkroDsfRUceWtFi2pMXa6nM/PpZLvr6GE0dvcuLoTZt/7u79ySyJUELqYaLVaNiYHMnG5EhaO3s4fimfw+f1lFTd4a1TObx1Koe4yEAObU1kz/oYPNzU9L+HhRK3ozBWttae0cRpS0sL+fn5hISEEB0dPWrmarriFiyZ4fr6emJjYydl7fQoi9vRsIo3qyOEvQWZtQ61u7vbZoU1GQuymWI8J4rxmKkhDtZ72tnZGWdn5yEDOTo6OujsKKO/5T9x9LrA3c61NDVV2Tx3JyrOTSbTI1kXPVcQQiwCjIPC1gXYBfxwlsOaFL6LPDn0ua0c+txWmmpbOJ9+k4yjNyi8cZuMIzfIOHIDF3cnNu1OIvXxlazaEoPOQd0zw7Gvz62+fZdTx3I5c/wWDfVtvP3bS7z920vExC1m9/5k0nYn4KmcKx4q3u4uPLdnFc/uTqGgspHDGXpOZBaQX95AfnkDr795lh1rojmUmsiqWNWE9qBR4nYY1mEMJpNp1GytPVqtloGBAdvvAwMDFBUV0dnZycqVK3F1HfsPzHRu8N7eXsrLLaMz169fP2mRNpvi9mGd174ONTg4GCklV65cwdPTk5aWFioqKiZsQTZTcU9XnE4382uNYbRj6HQ6fD1u4e/w/6HRLgMzuLgtRmPSUF1dTWdnJzqdjr6+Pu7cuYOXl9eoDWPKKWHaBAO/Gay71QDvSCmPzHJMU2bRYh8+/cU0Pv3FNBqqmzl/9AYZR29QfKua0+9nc/r9bDy8Xdn8WBKpB1NI3rAMrTLQv4/QJX584cvb+dyX0tDfvM3Hx3LJOJNPYX4thfm1/PRfT7Ju03J27Utm/eblOKgvCw8NIQRxEYHERQTyynOpnLteyofnbpGdX8WxzHyOZeYTGuDF41stTWgBPrP/NHE+osStHVJKjEYjAwMDY2Zr7bHPvDY3N1NQUEBoaCixsbEP7JuZlJK6ujrKy8sJCgrCZDJNKfs421Zgs3UMjUZznwVZR0cHra2t41qQTTfrao19upnbmcg2jxiDNKLpfx1h/B0CCWjo0aykHwgJCbmvsa+1tZXKykrMZjPu7u731TpPVNwWFhby7LPP2n4vKyvju9/9Li+99BLPPvssFRUVRERE8M477+Dj44OUkldeeYX09HRcXV359a9/zapVq6Z9TeYaUspcIGW243gQBIb68tSXd/DUl3dQU95ExtEbZBzJoaKwnuNvZ3H87Sy8/NzZsi+ZbQdTSFgbqRoYh6HRCJJTwklOCeerX9/LpfOFnErP5fqVMi5lFHIpoxAPTxfSdiWwe38yMfGLVcbwIeLs6MBjG2J5bEMsNY2tfHQ+jyMXLE1ob/zXRX72x0tsTIrgUGoiW1cuVZPQZhAlbpn66FzA1tRkMBjo7u4mJSUFF5cHZ3vT19eHwWBAp9Oxbt062tvbaWpqmtKx5mNZwniMJE5HstQayYLM29t7TtTsPiiXArO5Ek3f/0MzcBIAKQLoMWsYMGegdYgesq1Op8PJyYmoqChbTFbP3dLSUrq7uyksLOTmzZuYzWZb7fNoxMTEcOPGDcDyZSMkJIRPfepT/OAHP2Dnzp1861vf4gc/+AE/+MEP+OEPf8ixY8coLi6muLiYrKwsvvKVr5CVlTXq8RVzm5DIRTz/F7t5/i92U1lUz7kjOWQcuUFNeRNHf3eJo7+7hH+wN6kHVpJ2KIWoRPVYdzhOzg5s353I9t2J3L3TwScn9ZxKz6W8tJGP/pjNR3/MJizcj937V7BzbxKLAiY3DVMxPULsmtCy9JUcztCTkVPKxdxyLuaW2yahHUpNImKx72yH+8iz4MWtlJL+/v4pjc4Fi2/tnTt3iI2NJS4u7oH+wa2vr6e0tJTly5cTEBAATE+gjrRvT08PBoNhiOAbzXFgJrKYD5uJxDyaBZm16aqrq4tr165N2oJspngQ4tZkPExfz3dw01lG+po0ibSYinDWdltGfImhwnS4x629ny5YrnNQUBBVVVVcvHiRbdu24eDgwOHDh8etCz99+jTLli0jPDycDz/8kLNnzwLwuc99jrS0NH74wx/y4Ycf8tJLLyGEYMOGDbS2tlJXV0dw8P2ODopHi/DoIF76+j7+5K/3UmqoIePIDc59lENjTQt//Pez/PHfz7I4wp9tB1NIPbiSiBj1ng/Hz9+Dp17YyFMvbKS0qN5Sn3tCT1XlXf7jjTP86qdnWLkmkt37k9m8LVaN/X2IaDUaNiVHsik5kpb2bo5l5nM4Q09ZzV1+d/wavzt+jeSoxRxKTWTXumhcVaPllFiw4taarS0vLyc0NHTSwtZkMlFQUEBPTw+enp6TmlA2Wfr7+8nPzwdg7dq1Q4TUdBrShtuI1dbWUlFRQVRUFFqtdkgWztXV1SZ2rR69Cwlr05Wvry89PT0kJSXNmgXZTIpbKbvo7/0uJuMHg0sE3WIFHUZrFnTQyouhdcjjDXAQQhAeHk5qaiodHR385Cc/ob29fUKZ77feeovnn38egIaGBptgDQ4OprGxEYCamhrCwsJs+4SGhlJTU6PE7TxCCEFUQihRCaF8/m/3k3+9kowjOZw/epPaiju8+eNTvPnjU4RHB7Ht8RTSDq0ieMnEG2oXCsuig1gWHcQXv7qT7MulnErP5fKFInKulpNztRxnl3RSd8SzZ/8KElcuUbZiDxEfT1deeGw1z+9Zhb60jsMZek5dKSS3pJbcklpe+8Mn7F4Xw6HURBKXBT9yyaTZZEGKW+voXLPZTHV19aSNz5uamigqKiIiIoLly5eTm5v7gCKFxsZGiouLWbZsGUFBQfetn4nMbX9/P3l5eTg4OLB+/XqklLYmq7CwMKSUdHd309raSlVVFZ2dnfT09FBRUYG3t/eo3qhzkelmm637j2ZBZv1C0NPTg7Ozsy2zO9Yo3MkyU+LWOKDH1PvPmAeuWRaIcNrMRkwD2bZtbFdKDBW3E42hq6vL9mXI6mAxFv39/Rw+fJjvf//7Y243mj+zYn6i0WhIWBNJwppIXv72E+RmlZJx5AYXj+dSWVTPf756jP989RgxK5eQdmgVqQdW4qseuw9Bp9OyYUs0G7ZE09HeY7MVM9yq5uTRm5w8epOgxd7s2pfM7n3JBIeM7ZOumDmGTEJ7IY3TV4s4nKHnZnEtH2bo+TBDz9IQP55ITWLfpji8PdTEv/FYUOLW3t4LJv9haDQaKSgowGg0snr1apydnTGZTNO28hrtXPn5+QwMDNyXrbVnupnbvr4+rl69OqTUYfjEMyEEbm5uuLm52R7TX7lyBWdnZxobGykpKUGj0dgyu7NhrzVRpltjPJo4trcgs34hGG5BptVq8fLyst2DU71G0xW3ZrMZD5+j3O18D8/BwQxmzRqaTXo8tcPdPSxOIFIMFQoTHb3b3d09qUz/sWPHWLVqlc2WLDAw0FZuUFdXZ7tHQ0NDqaqqsu1XXV1tm8q2kOls6+bH3/wDG/auIHlzNI5O82+KlVanJWVzNCmbo/nzf/w0OReKOHv4Opmn9BTeuE3hjdv84nsfkrQhim0HV7JlXzIe3sqxwx4PTxcOfmo1Bz+1mpqqu5xMz+XjY7nU17byu19m8LtfZpC4Iozd+1eQuiMON3flz/qwcHV25PGtiTy+NZGK2mYOn9dz9EIeZTV3+T9vnuXH754nNWUZT2xLZF28GuAxGnNTgTwA7LO1w0sQJpLNs2ZQly5dSlBQkG37mfCpHR6DNTM8/FwjMdXMrclkIj8/n/7+frZu3TrpmlGtVktAQIDtMbB1zKvVXktKOaQm1clp6MjN2Wxkm4nM7UTOYW9BBpaspFXsWhutJmpBZs90rMQGzE20dv8d3osuDgbqRA/JdJquD25hGraHlg5W4SQdsZdJExW3k7UCe/PNN20lCQCHDh3iN7/5Dd/61rf4zW9+wxNPPGFb/uMf/5jnnnuOrKwsvLy8VEkC0NHSxZH/OMuR/ziLq7sza3clsulACmt3JeHqMf8EioOjjnU74lm3I57e7j4unzaQ8VEOV8/lc/NSMTcvFfNv//OPrE6NZfuTq1i/M0FNRRtGSNg9W7Gb1yo4lX6T82cL0N+sQn+zin977Tib02LZs38FK1ZHoNUqx4qHRcRiX/7q2VS+8pnNXLhRxuEMPZm3Kjh9tYjTV4sI9vPk8dQEHt+SSKDf7Dc7zyXmvbgdKVs70vjb0T6orfWuUkrWrFlzn0jTaDTTFmpWgTowMEBBQQH9/f22zPBE950Mzc3N5Ofns2TJEjo6Ou4TtlMRTsPHvA4MDNDe3k5rays1NTVDalKNRuOslTHMVFnCVHB0dGTRokVUVFSwevXqMS3IrMMSRmvkm0rmtsuYQVfPf8cs7wCg1cTTMtCJUZbabXUvay80sTQOSLoHbhHiNPWyhImUI4Aly3vq1Cl+9rOf2ZZ961vf4plnnuGXv/wlS5Ys4d133wVg//79pKenExUVhaurK7/61a8mdI75jm+gF8+/eIDMYzeoMNRw7oNszn2QjYOjjpWpsWzct5INe1fgG+g126HOOM6uTqQ9nkLa4yl0tvdw8Xgu5z7K4ealYtv4Xxc3JzbuTiTtiVWkbI5WwyLs0GgEKWsjSVkbyV98o4/zn+RzKj2X3JxKzpzQc+aEnkWBnuzam8Tu/SsIVfXNDw0HnZbta5azfc1yGpo7OHIhj8MZeurutPPz9zP5xQeZbEyK4InUJLasXIqDshRDjCOMHmmfqLGytVauXgvncyEAACAASURBVL3KihUrRsxcWt0JRqt3tXLp0iU2bdo05TizsrKIjIykuLiYiIgIFi+euBdhT08P+fn5E/L4NJvNFBcX097eTmJiIs7OzmRmZt4Xu8lksnn9jsb169dJTk6e8KN1+7G49fX19Pf327K61ia1ib7mq1evsnbt2gltO5y+vj4KCgpYsWLFlPbv7u6mrKyMxMTEKe0vpSQ7O3vE+O0tyFpbW20WZNZrZK1t1uv1LF26dNwBIVbMso87Pf9Ce9+7uGt6AB2dPbH0OJbgqXFC0mHb1ksTjFnWY9KspabfgLcujH5zMWHuP8PN4d590tDQQG9vL+Hh4WOe+9VXXyU6OpoXXnhhYhdo5llQz+zWrFkjs7MtNdN1FU1cSr/BpfQcDFmlti/BQghi10Sycd9KNu1PITQqcDZDfuA0N7WTceQGZw9fp/DGbdtyTx83tuxLJu3QKuWhOwZ1tS2cSs/lVHouDXWttuXxiaHs2p/M9t0JqmxhFjCbJdn5t/nwnJ6z10swmiwlZD4eLhzYHP/IWooJIa5JKddM9zjzMnM70dG5MHJZQX9/PwaDASHEmPWuM4HJZKKnp4fKysoJZ2vtmWjmtr29nby8PIKDg1mzZs1D97i1r0nV6XQMDAzg6+tLa2srt2/fpqurCycnpyFCbi5+2DzIzO9IFmR9fX20trbS1NREaWmprU66paUFnU437r3ZN1BMfeff0m8uRiPc0Qg/2gZc6HUsscRD37AgPGmVPrT16wfXW594jG0FNhrd3d1qQtksERyxiM/8+W4+8+e7aW1q5/KJXDLTb3D9nIH8q2XkXy3jP777R8JjF7P5QAqbDqSwLCls3jXm+S7y5MkvpPLkF1KprbzDucM5nP3oOreLG0j/Qybpf8gkYLEP2w6lsOPJ1cpabBjBi3146YvbePG/paK/cZuT6TfJOGPAoK/GoK/mp6+ftJQtHFjBSlW28NDQaATrEsJZlxBOa0cP6ZcM91mKrYwO4YltSexcsxzneVh/PxbzTtyazWb6+/snNDoXho7PlVJSX19PWVnZkAarB0VLSwv5+fnodDpbJnWyjFfzK6WkvLychoYGEhMTh1gxTedDbLrieKQmtd7eXltmt7i42NaANZNNarNZlgCTbwZzcnIiMDDQ1mBlMpnIycmhu7ubvLy8US3IpJQ0931AS88/2QSsTiTQaNIjuWN3hn7bTxrNGqqNDRjlXbv1ljIFzQhWYBN5P+zdEhSzh/ciT/a+uIW9L26hp7OXa2cNZKbfIOtELpUFtVQW1PKHV48SuMSPTftT2Hwghbh1y+adUFkc7s/zf7mb5/5iFxUFdXxy+DrnDufQWNvCuz89w7s/PUNETDDbn1jFtsdTCAx99DJfDwqNRpC8KpzkVZZpaBfO5nMyPZeb1yr45KSeT04Oli3sS2bP/mRCwlTZwsPi/2fvvaPizPMr789TmSqKjMgZBCIHAUIRZbVaseOkd9Yej90O87o32N7Z9VnPvrs+3gler8fT9s6MQ/dEezoq54ASiJxzzkFAFaGgqPS8f5SqAEVACSTuOTpH1JN+9VS6v+/vfu/10Lo4LcVq2wY4fq2ai0WNVDT1UtHUy//+5VX25cRxeFsSsWHPltcsF7w05HYx1dq5cJDbe5O/5PJnN8uxWq00NzczMTFBamoqDQ0NSz7Xo0jm1NQU1dXVeHl5kZ2dvShS9SICGlQqFf7+/k4JiKMBa3R0dF6TmtlsxmQyLami/qLJ7ZMeL5PJkEqlREREIJPJ7rMgm5qaQqUxIfH9GVLZCHLJDBLBA7MQxbB1CMWcSq2AEjAhoGVaiGdgphmPe94iNnEGieAGzK++LkZzu1q5XV5wcVWx+UA6mw+kYzFbqLrVxK1T5eSfKWewa4QvfnyJL358CQ9fLRv2prDpQBqpW9chV7w0PxcIgkDEukAi1gXyW3+6n9ridq4eL+XGmUo6Gvv58Pun+fD7p4lfH8H2w3ZrMTfP1fexAy5qBbv3p7B7fwoD/Xounqnkwmm7bOFfP7rJv350k/ikYPa8nsK2XQloNMrHn3QVTwxBEEiMCiAxKoB//+VcLhY1cvxaNbVtA3x6pZJPr1QSF7aGQ9uS2LchDlf1y/u6rHjNrcOT1Ww2L7haOxcOf9c7d+6wdu1afH19Fz2GxWhu9Xo9dXV1BAUFERoaiiAIVFRUEBMTsyQSYLFYKC0tJTs72/mYKIr09PTQ3d1NfHy8M1Z2oWN3TBIeRV4qKiqIj49fEsHs6+vDZrMtOvjCarUyNjZGXV0dGo3GWbV0WJCpVKrHvvbT09O0tLSQlJS06HEDjI2NMTAwQGxs7JKOf1LNL0BJSQnp6ekPfH30M3l0Tv5PrOiRWYKR2qxMCNPYZJMoWYNCMqs5lApuaKVr6DPPMG3TAeAmmWHux95dnkSPSU+W509xkc7O+Nva2nBzc3M2ED4M3/jGN/jOd76zZI3yU8DLtcb+GMzV3C4WVquNhpI2p063v3021lvj5sKGfSlsPpBO+vZ4lC+p44BpxkLZ9QbyTpZz+2INM0b7yoVMLiVjaxw7jmSQvSse5Wpq1H2w2cR5sgXjtP3eKZUytmxfx54DqSSnrVpXvQg0d9/hxPUazubXMW6wFzhUChm7smI5si2JpOjlExCxqrnFTuLMZrOz+WmxGk2j0cjw8DCurq5kZ2c/0bL34ypyNpuNlpYW9Ho9KSkp84jsk9iJ3XvszMwMNTU1uLi4kJWV9cz8Zl/EB0EqleLl5YVSqSQtLQ2bzeZ0G2hubmZ6ehqNRuMkuxqN5r5xvujK69OoiD/oHFbRSN/Uz7hj/CkAAgqUykhGLPnOfWxWCUgc55Bhsqyj1VLHbAqZHDA6jxckabQaW7Exg1SYP8N/Vj63q3hxkEolJGRHk5AdzTf/+5u01/Vy61QZt06V0VHfx+WPb3P549uoNErW70xg0+vpZO1JQvMSGcorlDI27E5kw+5EpiaN3L5Yw9XjZZTdaJx1XHBVsmlvMtsPp5OSE410tTMduF+2cONqPRdOV1JV3smlc9VcOleNX4AHu/cns3t/MgGBqyERzwsxIb78p69u51tvbyGvrIVj16opre/m1M1aTt2sJSLQm8PbEtm/Mf6lCYhYkeTWYZvV2dnpdBZYDGEQRZHe3l46Ozvx8PAgICDgiUigVCp9pJ2Yo5nL39+fzMzM+8b6tCJ0He4OS61ALxZPorl9Gs1sEonEaZvlOKfBYECv19PZ2cnk5KQzJczDwwOtVvvMQhwWiqeVLjZ3DOPmeuon/j80Evt9UEjCGLMpsIqGeceoFC4ggkQMYmDGFaugRyGbvR+CKHMeP2xVo59pRiWxN5RJH5BQtlCf21Vyu/IgCAKRCcFEJgTz//znQ/S0DHLrdBk3T5bRXNHJzRNl3DxRhlwhI23bOjYfyiDntZSXKixB7apix9H17Di6Ht2dCa6fKufKsVKaqrq59Fkxlz4rxtNXy7aDaew8up6ohKBlU/160XBRK9jzegp7Xk+hr2eUC6cruXjWLltwhESkpIex90Aqm7evQ6V6tZqdXhSUChl7N8Sxd0McXQM6Tlyv4dTNWtr7Rvjbf73GBx/fIDcjmiO5yayPC1nRVfYVJ0twxMXabDZu3769aAuu6elpamtrUavVrF27lq6uLlxcXJ7IAP5hdmI2m422tjZGRkZISEh46I98XV0dAQEBeHoubSZ769YttFotNptt0VKBpcoSqqqqiI2Nvc/3dyHo7+/HYrEQEhKy6GNh4VZgoig6m9TGxsaYmJhAEASsVisxMTFO54bFYHR0lNHRUaKjo5c0doPBQEdHBwkJCUs6Hmafvyha6Zz6OZ1THyJixVdul1r0mFoQseArj2PGWu48zk0Wg1RQ0zrdhShY0EoDYY7HrUx0Q25eQ79kAAQbgihDKZ0GBPatuTpvDHV1dYSGhj6WuO7cuZPr168vqVnyKWHlfjsvAU8iS1goBrtHKDhTwc2TZdQWtjgnjFKZxE50D9qJrvtLairf0zZE3okyrh4vo69jtjkzJNqPnUczyD2UvtqI9gDYbCIVJe2cP13JrbwGTCb7xFmtVrBtVwJ7Xk8hPil4dYLwnGGxWLlR0cbx69UUVHfgoIRBvu4c3pbEgc0J+DzHSesrJ0twVGsd0bCOau1CK2GiKNLd3U1PTw9xcXF4edm/fCQSidMtYal4UOV1YmKC2tpa1qxZQ2Zm5iPH+CTOAyMjIxgMBiIjI597QtOLTBlbCARBwMXFZd7kRafT0d7ezsjICG1tbQDzHBkeNzFYLpVbg6WXjql/4s7MBQAUEl+MNnfuWAqd+wjMXkcu+DBlC2LQXOqkexJBiu3uS6iQ+GIhmn5bpfMYqaAApsEmo6SkZN59WqgswWQyLWkCtIrlC78Qb468t5Mj7+1ENzRO/ulybpwopepWIyWXaym5XMvf/ScJyZvWsulAOhv3p+Lt/3Dd/0pDcOQavvbv9/HV9/fSVNnF5S9KuXaqnO6WQT76wRk++sEZEjMj2X4knS37X65q9pNAIhFIz4okPSsSw6SRvEt1nD9VQUNtL2dPlHP2RDnBod7seT2F3a8l4+37ck6OlhtkcwMiRiY4caOGE9dr6L0zxj98epOffH6LzamRHNmWxIakcKTL0KLzQVgRlduHhTE8KoBhLhy2Sa6urqxdu3bej3J3dzeiKBIaGrrk8ZWXlxMbG4tarcZms9He3s7Q0NB91lsPQ2NjI97e3o9tzpkLq9VKU1MTBoMBo9HI5s2blzT2pVZuq6uriY6OxsVl8fqc51W5fRAmJyfp6uoiPj4esD9XR5KaXq/HarXOs9a6t0lteHiY8fFxIiMjl3T98fFx+vr6iIuLW9LxANfr/p5pnzP4yMOZsFTgKkuhe6YfP0UE484YXfBTxDNtKcVFmkqrcQRPeTBT1hrndk9ZOBZbPWpZGu3GIVwk7tjEDud2lcQLGMJdvoFM7f903qexsTHGx8fx9vbGy8sLd3d31Gr1A0n/li1bKC8vf5HVmFeqDPQ8KrcPg354goIzFdw4WUrljQasFvuEXxAEEjdEs+XIejYfSH8p09EsZiul1xu4erxsfiOaQkrW9nh2HM0gMzcehXLF1JOeGzrb73DhdCWXzlahG7VLqSQSgcwN0ew9mEL2prXIV5PkniusNhuFNZ0cu1bNjfJWrHerIH5eWg5tTeTQlmcX9/vKVG4dMoQHOSHM9ah92LFdXV309vaybt26By77S6VSZmZmHnD0wuEYx+TkJLW1tXh7ey/KemuxmtuxsTFqa2sJDg4mLi6OgoKCpQ79oVjuVdml4t7Kq0wmw8vLy1nJn9uk1tTUNC8S18PDwznBWiqepHI7Yx2levx/M+ldACIISJFJ0mg3OqQF97xmogybkEX9dDsAEuZfV0ABkgwapzsAcBW8nZVcALmgxSj60WkcJcdz/n0qLS0lKCiIyclJ2tramJ6eduqb3d3d0Wq1i7pPer2eb37zm9TU1CAIAv/yL/9CbGws7777Lh0dHYSHh/Pxxx/j6emJKIq8//77nDlzBrVazUcffbSghL5VPFt4+Gh57etbeO3rW5jQGbh9vpKbJ8sou1pHdUEz1QXN/N9v/5ud6B7OYNOB9JemoiuTS8nemUD2zgSmJo3kn6/m6vEyKm41kX++mvzz1bi6u7D1gD0oIj4jfHX5/S7CInz53W/t4hu/v4Pi2y1cOF3J7ZtNFOY3U5jfjLunmp17k9h7IJWIqFfDo/VFQyqRsDE5go3JEQzrDZy+Wcvx69X0DI3xj8cK+Ofjt8lJDufItiQ2pUQiW4Z+2Cuicusgt/eisrKSqKioB+r+DAYDtbW1uLu7Ex0d/dAl1MHBQSYmJpasoQR7FVMmk6HX64mPj3c2OC0Ura2taDSaR0b8wnwNb2JiotNx4Unif+89dnJykurqaiwWC66urs5mrHsrc4uNgJ2LF1m5XWzldG6TmqNqKZVKCQgIcDapLYas6nQ6hoeHiYmJWdS4e4z5dBh+ybjF7omslcVhtrkwYqlz7hOsjGXMUgGAqzSOGdGXQdOs5jZQGcfE3e0uYgwmqTcj5irndh9ZGDM2+/ndZMkMWySMW9pwlwXxtv/fzRtPcXGxM+kO7PdpenqasbExxsbGqKmp4Yc//CHT09P87d/+LTk5OY+0pPt3/+7fsWXLFr75zW9iMpmYmprir/7qr/Dy8uLb3/423/3ud9HpdHzve9/jzJkz/OhHP+LMmTMUFhby/vvvU1hY+LBTv1IM4kVWbh8Gw8Q0heequH68hNIrtZhNjtQ7gfjsKLYczGDTwXR8X8Lu+ZHBMfJOlHPlixLa6vucj/uHeLH9SAY7jmQQHLlK2O6FXmfg8rlqzp2qoLNt1pJu7boA9ryeyvbdCWjdXo6u/pUCm02ktKGbY3nVXC1txmK1F+R8PDQc2JzA4W1JBPk++arM06rcrghy65Ak3IuamhpCQkLmkUlRFOno6GBgYGBBRPPOnTvodDrWrl27pLEZDAaKiorw9vYmMTFxSVW59vZ2lEolgYGBD91ncnKSmpoafH19iYiYn4P+NMito8rd19fHunXrUCqVTE9PO0mdwWBArVY7yW5HRwdRUVEvPbm9FwMDA0xOTqLRaNDr9UxMTCCXy+fpUR+lRR0ZGUGv1xMVFbWg65ltU5SN/5iO6Uv4y/0w2oYwGkIYUQwSoghDb2l07husjGHS0oRMkkSrsY0QZew88hqkjMNgbcQyE0kv/QQro9FbZmUKa+SRWG092IQIOma68JEFM2ntwFseyVG/H8wb10Jeg97eXo4ePcqhQ4fIz8/ne9/73gPfp+Pj46SkpNDW1jZvAhUbG0teXh4BAQH09/eTm5tLY2Mj7733Hrm5uXz5y1++b78HYJXcLiMYxqcoPF/NjRMllFypxTxjcW5L2BDN1sPr2Xzw5anozkV7Qx9Xvijl6vFSRgbHnY/HpYWx8431bDuQuqrPvQeiKNJU38/50xVcvVCDYdK+yqpQyNiUG8e+g6mkpIev6K7+lQjd+BSnb9Vx7Fo1XQN2j3RBgOyEMI7mJrMlNRLZEi3yXhlZwqNwryzBIQtYTCLX46QND8NcyYOXlxdBQUFLXm52NMY97joJCQmLrgovBEajkZqaGjQaDVlZWYB9QuHq6oqrqyvBwcGIosjU1BR6vZ6uri50Oh0NDQ34+Pjg4eGBq6vrohPQXgSehs+sQqEgICDASaZMJhN6vZ7h4eH7mtQ8PDzmpd0t5vqDM5UUjf0NU1Z75UIm8WbcIjChGLSfi3vfM1r0tmDGTPYx3H8VNTpLAOP0390+fw+p4E6vZZwpW9fdv+1fTjJhaQ1hbm5ueHt7873vfe+R+7W1teHr68tv//ZvU1lZSUZGBj/84Q8ZHBx03uOAgACGhoYAO2meOzEKDg6mt7f3uTdUrmLx0Lip2fF2NjvezmZqwkjRxSpunCil+FINtbdbqL3dwo//629IzIlhy+GMl0qjGxEXyO/8l0B+689ep7qwlStflHDzbBUN5Z00lHfyk/9xjMzt69h5dD2Z21f1uWD/bYyNDyQ2PpD3/t/d5F9v5NypCsqL252Rv/6BHnbbsf0prPF/Od4ryx2ebmq+9tp6vrovg/KmXo7nVXO5uInbNZ3crunEy03NwS32am7wmhczUV0Rn56HkQGZTIbFYsFms9HR0cHg4CAJCQm4ubkt+NxLIbeOBjWtVkt2djZtbW1P5LggkUgeSPbmks7s7OwFdacvFmazmdLSUmJjY50NbQ96LoIgoNFo0Gg0BAUFUVNTQ0BAACaTid7eXiYmJlAoFE5C5+bm9lCy+yK1Zs8ihEGhULBmzRrWrLEvL1osFsbGxtDr9XR3dzub1Dw8PJyBI4+CRZyheOyX9BnPYBGnkSDHVZZIz8wwhrtJYgAi9tdJghy1LIlBk40xy9ztdvIrRYFamsCwWcq4Ve/c7hiHXNAgF6K5YxGYss1640qwv98UkqVVkxwV7sfBYrFQVlbGj370I7Kzs3n//ff57ne/+9D9H/RZWdUv2mG12JjUG3BdARVAtVZF7htZ5L6RxdSEkcLzlVw7ZpcuVOc3UZ3fZNfo5sSw7ch6Nh/KwMNn5XfQS6USUjfGkLoxhj/8H29ScKGaS5+VUHGriYILNRRcqMHVzYWtB1LZ+cZ61qWv6nMBlCo52/cksn1PIgP9ei6cquD86UoG+vT8/B+v8Yt/ukZaZiT7DqaycWssipcoLnq5QhAE0mODSY8N5j9+NZez+fV8kVdNe98IPztdzM9OF5MZH8qR3CRy06ORP8fAkxX96kulUmdDi4+Pz6KauOaeY6HEdG6s7dwGtScJYXAcP3cMoijS399Pe3s7cXFxeHt7L/ncD4PFYqGhoQGz2UxOTs6iY3QlEglKpRJvb29nxWxmZga9Xs/g4CDNzc1IpVIn2X3ccv3zwvMIcZDJZHh7eztfN5vN5nQaGBoacmpKH6RnHjI1c2307xiz9OEmNeMqDUFnVdA/3cYa+XzCImLFVRrCiMWFrqkOIlT3yjxEtLIwhkxyOk2dRLvMl0IIgIcshm7jDOPWLiJc5jtASAQJ3vIEDNalvf+mpqYWRG6Dg4MJDg52Rki/9dZbfPe738XPz4/+/n6nLMExeQgODqa7u9t5fE9PzyMlPa8S9HfGeDv0j0jIiSFrbypZe1MIi1/+4QJqrYrtb2Wz/a1sDONT3L6r0S27Wuckuv/wX/6N1C2xbD2SyabX09B6Ln8C/zioXBRsP5zB9sMZ9+lzz/y6gDO/LiAw3IedR9ez8431q/65d+Ef4MHXfzeXr35jKxWlHZw7WU7+9UbKitooK2pD6+bCzn1J7DuYSmS034se7isBd1cXvrQnnXd3p1Hd0s8XeVVcKmqkuK6L4rouPLUuHNiSwJFtSYT4PXt9/YoltzabjdHRUQwGA+np6Quy3HoQFkpMHVVUtVp9X6zt0yC3Dv9ek8lEXV0dEomErKyseUvaTwt6vd5pwj82NvbUrqFUKvHz88PPz/5lcu9yvSAIuLu7I4riM4sFXgied3yuRCJxElmlUonJZMLLywu9Xk97ezsGgwGli4IRz9t0CFcQsSFBipssjpbpDmx3K7A2ZvWJAlIEAmmcbsaGvdo6V6YgQYZV9KRhagDxAdJ5GSosNg/qprrnnHP2eaklHphtPtRP15LkOp80L3SCMDk5uaB0Mn9/f0JCQmhsbCQ2NpbLly8THx9PfHw8P/vZz/j2t7/Nz372Mw4fPgzAoUOH+OCDD/jSl75EYWEh7u7uq5KEu7Ba7JPk6puNVN9s5J//22/wDfYic28KmXuSSd0Wj3qZx2tq3NTsfGcDO9/ZgGF8ioJzlVz/ooTSq7WU5dVTllfPj/7kl6TnxrP1yHpyXkvF1X3x2v/lBm8/d9783Vze/N1cpz73yrFS+jqG+cX/Occv/s85ErMi2fXGeja/loJmtaEKqVRCRlYkGVmRTIxPc/VCDedOVtDSNMCxj4s49nERa9cFsPdAKtt3J+KqfWFhMq8MBEEgOSaQ5JhA/uNXcjlbUM8XeVW09ozwizMl/OJMCevXhXA0N5lt6VEo5M+GC6yIhjKr1YrFMvvD7oizValUeHp6Eh4evuRzz8zMUF1dzfr1D9Yvi6JIX18fHR0dD62idnV1IZFICA4OXtIYBgYGMBgMuLm50dTURHR0tJMgLgT5+fnk5OQ8lnTNdVtISkpCrVZTUFBwX8XbEZbxqCp4fX09wcHBi5pUmM1mxsbG6O3txWAwoFAoHqpNfRSepKHsSRPGenp6kEgkS64U9vX1YbPZ5r1XBmc6uDHyC/Q2u5OB3OzJlNUV811trQNeMikm0YDC6o1R4o2AiXHrkHN7qNIfnaUDN1kQIxYXNBI1A6bZBLJolwgGTfW4mP0ZFuT4KX3pnal3bo9yiWLQXIuvfB1NBh2ByiB6TE2ka7dy0Pfrzv2sVisVFRVkZGQ88rnm5+fzxRdf8OMf//ix96WiosLplBAZGcmHH36IzWbjnXfeoauri9DQUD755BO8vLwQRZFvfetbnDt3DrVazYcffvjQzy+vYENZ3qVrlF2ppehcBSUXq9ENjTm3y+RSEjfFsmF/Ghv2pxEQsXI69Sd0Bm6dLuf6sWIqrjdgu+tbJ1fIyNiRQO4bmWzYm4JK8/KEhlitNipuNnHpixIKzlc7/XMVShk5e5LY9eZ60jbHIl2GVkwvEs2N/Zw7UcGVC9XzmtA2b4/jtUNpJKeFLfvVjJcJoihS3drPsbxqLhY1MnPXMcVD68KBTfEcyU0m1N9ezX2l3BIc5NZms9Ha2sro6CgJCQlMTEwwPT29ZEN9sC/Pl5aWOpdE52JmZoba2loUCgVxcXEPrTb29PRgtVoJCwtb0hgcEgSVSkVCQsKiE51u375NZmbmI5f9p6amqK6uxtvbm8jISCdxfdCxz4rcOjAwMIDJZCIwMPC+AAU3N7d5Vc4H4UWS2+7ubmQy2ZIrhb29vQAEBQVhE60UjZ2gcOwL3KQe2OjHW55A81QXUkGGTDIx71h3iYjKFk6LeRibYMNf4cqkdcS5PVTpB4IHdYYebNgIVwUxaGp3bo92icJok1I32QmCwFp1BH0zDXO2xzFmMdM6bbcsilZH0T3TSLbbLvb5fMm5n2N1ITU19ZHP9eLFi+Tn5/PXf/3XS7pXTwmv1C/YvW4JNpuN1spOis5XUnyhisbiVicpBAhdF8SG11LJ2pdKfHY00ueoiXsS6O+M3yW6JVTnNzmfk1KtIGdfKtuOridjRwIK5dNf+XpRMEwYuXWuiitflFBZ0OJ83GuNGzuOZLDrzUzC1j7aTvJVw4zRzK1rDZw/VUl5yex3YWCQJ3sPprJnf8pqEtpzxoTByNmCeo7lVdPSMxtfvX5dCEe3J7MnO+7VcksYGxujrq4Of39/srKyEASB6enpeRXdpeBBkoK5mte148Tw8gAAIABJREFUa9fi6+v72HM4ZAWLhU6no6mpCY1GQ1pa2pJmk4+K73VUnjs7O4mPj7/Pa3Sp0b9PEhnswL0BClar1Ul2+/r6MJvNzkYsDw+PJaWh3Ytn0VC2GNhsNmQyGSOmXs6N/F+G7pJPhUSLWXShYeru38L85TOt1JcZi4ou65CTrpksRuf/PWQBjFm0dJu6Zsc6R6bgIw9jxKSic6bV7tlydw8H/BWxjJpVdBg77xuzXDJfj73Q6F2DwbAgze0qnh0kEgkxaRHEpEXw1W8fYXxkguILVdw+W07JxWq66nvpqu/l4785jaunhvW7ksh+LZX1u5Nx83q8pORFwcPXjdd/axuv/9Y2RgfHuHGilLzPi6gvbiPv8yLyPi9C4+ZCzv5Uco9mkro1DtkzWv58XtBoVex5O4s9b2cx2DPKlS9KufR5MX0dw3z606t8+tOrRCcGs/ON9eQeTHspmu+eFEqVnB17k9ixN4n+Ph0XTlVy/lQFfb06PvzxVX720zwyc6LZeyCVDZtjlmxftYqFQ6tR8c6uNN7emUpNaz/HrlVzobCRkvrueWT3SbEiKrdDQ0M0NjaSkJAw78dydHSUwcFB1q1b90Tnn+sTazKZqK2tRSaTERcXt6ClcoesYKHepWAnOS0tLej1eoKCgpiYmFiy92pRURGpqan3NYU5KmyO5/KgynNRURFpaWnznqfNZsNkMj2yctvY2EhAQMCinCkccFRuHxd5PDctTK/XMzMzg6urKzqdjrS0NFxcXBZNNJ80PrejowO1Wu1sblr08Z0dNEgKGJa1cMfUgIDAGkU8etMM47YO536uUjdsDCMg4CNPoNEwgFRimHcuL6kUsziDyhRCm6jHV6pkSjLrnxmiXMOY5Q7usmjqJruJVAfSNzN7jRh1KOPmIQQhkKapPuI1YXQZm+dsj2LKNkmSay5bPbc7H783wvhh+NWvfsXExAR/+qd/uqR79ZTwSlduHwWL2ULNrSYKz1VQdK6CnuYB5zaJVELixrXkvJ5OzoH0FSNfGOgc5vrxEq59UUxr9aye3N3blS2HMsh9M4v4rKgl2zYuN4iiSH1ZB5c+K+b6qQoME0YApDIJWdvj2fVWJpm565CvOgc4YbXaKC1s5dzJCgpuNGG9G0bg4alhz+vJ7DuYRnDo02/iXsXDMWEwcq6gAZto40t7Ml4dWYLFYsFisdxHZMbGxuju7iYxMfGJzu8gtwMDA7S2thITE7Mo8nLnzh30ev2CU6cmJiaoqanB39+f8PBw9Ho9/f39jyULD0NJSQlJSUnzlvGHh4dpbGx8rH63uLiYlJSUecR4oeTW399/Sb67AwMDzMzMLFrGIYoik5OTVFVV4ebm5uzGd1R2NRrNY8nuk5Lb9vZ2XF1dH1vNfxDumHr5rPcfGKGPUGUEJtsoMzY3+kwDBCgCmLB2OPd1k3riIhWZsrrTOzOEXJAju4fchqn8GDHL6JuxSxP8FC4YbLP6ygBrEAOikTHRflyEiz8Dcyq769RJVE92MWWbuft3KN0z9uVOmSAnXBVP2XgzR/0OsdM713ncQoMwfvrTn+Li4sIf/uEfLvpePUWsktsFordlgMJzFRSeraD6ZqOzOQ0gPD6Y7P1p5LyeRuz6yBVBDrub+7l+zF7R7Z5D3H2DPNl2NJPcN7KISgp5abSXphkzhZdqufR5CSXXGrDdJW1uXhq2H0pn15uZRCUsf+eM5wndqIHL56o4f6qCzvbZqmFSaiivHUpj8/Z1qFQvj7RlJeCVCnGQSCQP/EAuNYDhXoiiSGVlJQCZmZlLssVayDjmpqclJiY69apP6rYwVyJgtVppbm5mcnKSjIwMVKpHd4c+iSxhqVjqsYIgoNVqUSgUJCUlOYMldDodHR0dGAwGXFxcnGRXq9Xed60XIUuwiTZKxq9yRfdvWLEgICAT3GmdGcAi2n90JXPOKSDBTRpK03QbFtHeMCYTZpfLJKIEP2Uc9YZOLOIcC7m7MgSFoMRdGsWgTcfYHN/aqelJkILS6oJKHkzvjNFJbOcev0YexJBJwojZgg0RuTD/y32hsoSpqaklV7hX8fwRFO3PG9/axxvf2sek3kDxhSoKTpdRfKGKjroeOup6+M1fn8TD143s11LZ8Hoa6TsSUamXZwNXSEwAX/3TA3zlT16nrabHKVe406vj0w8u8OkHFwiO9nMS3ZCYla1XVSjlbHk9lS2vpzJ6Z5yrx8q4+GkRnU0DHP/oBsc/ukF4rD8738hkx9EMvHwXv+r2ssHTS8NbX8nhzS9voL6ml7PHy8i7XEd1RRfVFV38/d+cY/ueRF47lEZM7Kojy0rCiiC3D8PTILdDQ0NOSYG//9K+3BZCTqempqipqcHd3f0+d4KnYSXmWMJ3hCvExsYuiIQ9iXb2RaWMOTA3WMKRouaIDO7p6WFychKlUom7uzuenp5otdrn4nM7FwMzvXw2+HM0MilW0YJG9MQsatGbzVjEWb24Iw3MXbaGSYsbXTOT92yXYQXchTXozHKqTL0opfPf+xbRjJ88jC6jhc7pHgKV8+2R5Eo5a6wRNJp0mC0DBKCFORxVQMBfsY7K8V5EwENu11wqnkBzu5R45lW8eLh6aNj+Tg7b38nBbLJQfbOB22fKuX2mnMHOYc7//Drnf34dpYuCjF1JbDyYQfZrqctSpysIAlFJIUQlhfDb/+0odYWt5H1RzI0TpfS0DPKrH5ziVz84RUxKGDvezmbrkfUrPv7Xy9eNN383lze+uY2Wmh4ufVZM3olyOhoH+Of/dZIPv3+a9dvi2PN2Flk74l952YIgCMQnBROfFMzv/4e9XLtUy9kT5TTW9XHq81JOfV5KdKw/+w+ls31PAhrXVUux5Y4V8Y5+XELZUmA2m2loaMBisaBWq5dMbOHR5FQURXp7e50NXY7gh7l4VPzuQtHT08PIyMi8ivBC8CIqt88KgiCgVqtRq9VOqy6j0eiUfTQ2NiKKIgqFAp1Oh5ub26KDJRZKbq2ilWuj57iqO4tVtLBWFkWgYh31kz1YGSFGMf81EkQBP0UC1ZP9WMQ7BCrmS0lkyPBVxFM90YsNIwpBDsxWXVUSFW7SYComeuaNwQF3mSciPtQYu+DuvEqhUsDdPkgPqzfdo2YGpHfmPVcAhWR+5dZmsy1oWdpgMCzZf3oVywdyhYz0HYmk70jkD37wNTpqe7h9tpz8k2U0lbaRf7KU/JOlSKQSkjbFsvFgBjkH0vEL9XnRQ78PEomExJwYEnNi+IO/epeKGw3kfV7MrZNlNFd20lzZyT/+xSckb45l+5tZbDqQvqI9dAVBICYphJikEL75Xw9RnFfPpU+LKbpaR9EV+z83Tw25h9LY/VbWqmwB0GiU7D+czv7D6bS3DnHuRDmXzlbR0jjA3/3gDD/5uwts3RnPa4fSSEh+eWQtLxtWhOZWFEVMJtN9j9tsNgoLC8nJyVnU+Rx61IiICAICArh9+/aS0s0ccKSkJScnz3t8oVZiU1NTNDY2kpaWtuhrG41GCgoK8PHxISEhYdHPoby8nNjY2HkVtoVobpubm/Hx8XkgWX8cBgcHMRqNS7ZOexIrsJ6eHsbGxpDJZIyPjyOVSp1eu+7u7o8Nl1jI8+419nB19DR1hnIAvOV+aCW+NE7P2m7FqCPomWl0blcJAdRPzW4PVvqjt9j1sb7yQEw2d7pnZq1sXKQqwN48FqQMp3PKyLQ4G61rP6+UGZuREGUMVRPDeCtk6C2zmtwQlQcT1gm8ZWFUjvcSqfamb2bWWzcQV6wSG3s1e8lak+Js4Ovv78disRAScm8i2ny8//77fPOb33Q2a74gvFK/PE+iuV0K7vSOUnCqjFsnSqi6MavzBIhMCmXjwXQ2H84kPCF4WZOAmWkThRequPppISWXazHf9eGUK2Ss35nAjrc3kL0nGcVLor/UD09w9XgZFz4poqOx3/l4eKw/u97MYseRDDxXLbKcMM1YuJlXz9mTFVSWdjgfDw71Zt/BVPa8noLHS5CYtxzwSmluHwaJRLKoqqPFYqGxsZGZmZl5elSpVLrgatTDxnGvPGJwcJCWlpYFNactVZbgaIDTarWEhYUtafwvqnL7oiQNMpkMrVbrdGowm83o9XpGR0dpb7eTx7mRwfe6ZTyqcmuxmbkwcp7LoxeJcglCiowAZTS1kz3EaebHZgqAFBn+yhiqJvqIdJk/eZMKEuSCAh95FBXjvfjd4/krR4ZcosFVGkzFeB8yQYrsnpdfK3VDIgZQPGb/8bLcc8vdZN4MGiX0TNm9d23i7HtQJsjwVAdRpO/EppLQ2trK1NSUcxKk0WgeW8VeaPzuKlYufIO8OPTeLg69t4sJnYHi85Xknyql5GI1bdVdtFV38cu/OkZQtB+bDq1n0+H1xGZELjuiq3RRsPXwerYeXs+E3sCtU+XkfVZE5c1GCs5WUnC2ErVWxeZDGex8K5ukTWtXRFPdw+Dho+Xo72zjyDe20lrby6XPirl6ooyOxgH+6a9O8OH3T5G1PZ49b2exPncdMvmrbZGlUMqclmK93aOcO1nOxTNV9HSN8E9/f5mPfnKVjVtjee1wOmnrI5BIltf7+1XEiiC3T+OLcGRkhIaGBsLDwwkMDJx3Tgc5XWok7FxyarFYqK+vx2KxLLg5bbHk1nENq9VKZmYmTU1NSyaLDyK3k5OTjI6O4unp+Uhv2Se55nKBXC7H19fX6X5gsVgYGxtDr9fT2dmJzWabl6L2MELXMd3Ovw38mkGTvUFMKaiRCv5UTd51J7jnEAlKIJDycbuM4N5zKgUNRqsv5dN24ilj/g+pjzyA9uk7dFrtgQsyYfa9K0VKqCqKhskezOKU83GHhlcpKvFUhNA4oUdvMdy3PUgZwJ0Z6JyexIpIqH8Q0ZpgZwNfW1sbOp2O4eFhFArFvAa+uTKPVVnCqwWtp4YdX9rIji9txGQ0UZFXz62TJRScKqO3ZZCP/+Y0H//NaXwCPck5mMGmgxkkbY5ddv6zWg8N+762mX1f28xIv55rx4q58kkhLVVdXPjVLS786hY+AR72RrQ3s4hODl1W32mLgSAIRCcGE50YzO/8l4MUXa3j4ifFFOfVU3CxhoKLNXh4u9pDIt7KJCJuacmMLxOCQrz4nT/cyW/93nYK85s5e7yc4tstXL9Sz/Ur9fgHetiruftT8Fmz2rT3orC8vlWeASwWC01NTUxNTT3UPeBJG9Mc5HR0dJT6+nqn3GGhX3iLIbd6vZ66ujrCwsKcJP1JGtLmkltRFOnq6qK3txdvb2+ampqc3rIeHh54enqiUqkQBGHFfpk/rtook8nw9vZ2xiw7giV0Oh09PT0YDAZMJhO+vr52aYJc4NjgWVqnq7hjtlt2BSgiGTSZGTCNzr2w/fyiDG9ZBKMmKf0zOudm4S77VUlc8JKFMGwSuGOaTSiTCHZyq0GDTPSmY3qaCeu0c7tckGIG/BR+jJtkVIwNIJXc23BmIUwZTo1eT7dxAF/l/I+/RJAQpoqmTN+LiECQi52YKu9qbh0NfK6urk47NIemeXBwkObmZqfMo76+nunp6QVVbsPDw53EWCaTUVJSwujoKO+++y4dHR2Eh4fz8ccf4+npiSiKvP/++5w5cwa1Ws1HH31Eenr6Y6+xiucLhUpB1r4Usval8Mc//C1qC5q5dbyEmydKGO4d5eRPLnHyJ5dw9dSQ83o6W49mkbYjYdk1NnkHePDGH+zmjT/YTXdzP1c+LeLKJ7cZ7Brhs3+4yGf/cJGQGH92vrOB7W9l4xeycv1R5QoZm/Yms2lvMqN3xrnyeQkXPi2mu2WQz//5Gp//8zWiE4PZ+0422w6loV3BWuSnAalMwsatsWzcGsudoXHOn6zg3KkKBvr0fPSTPH7+j9fI2hjN/sPpZG6IRnrv0toqnilWhOYW7IEEDxrr3ACGe6HT6aivryckJITg4IdrvqqqqoiIiFhylclkMnHr1i1cXV1JTExcdJLWQrTDc6OHk5KS5mlk6+vr8fPzcyZ9LQbV1dWEhYWhUqmoqalBpVIRExOD1Wp1yj7mBikYjUZcXV0xm834+vouisQ7MDQ0xNTUFOHh4YseLzyZ5ravrw+r1fpYvejDUFdXh4eHByaTiZqxeq5KCpiQGAiSa1DJXBg227hjGmetxo8u42xzV7wmBJPNRMeEEb1oJFkbSsv0bITmOk04FtFMu2EKvWWKWE0wncYO5/YIlwBUUjlV+mFmsBCk8kZnmfXu9Ja546PwonysDxsiaqkSG7NVWS+5OxqJlvrJIedjHnIwiea75w9h2Gik3zSryfVTqdGZJ/j7hP+In3JWY9zS0jIvWW4uzGYzo6Oj/OVf/iUXLlwgKCiInJwcvv71r7N+/YNlVOHh4ZSUlODjM9uA9Gd/9md4eXnx7W9/m+9+97vodDq+973vcebMGX70ox9x5swZCgsLef/99yksLHzUS7YyZ2FLREpyqnjyN6cJjg1YlsvmoijSXN7OrRP2JrSuhj7nNo27mg2vpbL5aCYZO5NQuizOkvF5QRRF6kvayPusiGvHShgbnp2EJm1cy463s9lyKGNFN6I5IIoiTVXdXPy0iGsnypkct0+o5QoZm/YlsfutLFI2xiCVLr/32ouA1WqjvLidcyfLyb/eiMViLzr5rHFj34EU9h5IxS9gZTtxPGs8Lc3tS0Fuc3Jy5hEsh9frxMQECQkJj7UjqqmpISQkZEmBBOPj49TU1DAzM0Nubu6SKpqiKFJQUPBQkm4wGKipqcHHx4eIiIj7frQaGhrw9fV1VhsXg5qaGrRaLT09PU59sM1mw2w2P/C5OIIUWlpasFqt2Gw2NBoNnp6ezojcx92DF01ubTYbwcHBSzq+rq4OnyBfzk5e4Za+CACVoCRAsoZG82xjRpjck0GbnUi6SFwIV0ZQPN7q3D6X3GqlrgQpwykZm00HW6cJod1o1wD7yL1wl/pTOTlLhsNUvtyx2IlBiCqIabOSjjlk2l2qZoZxJEiIdImgYVyPkdkfYQCNzIKrVI2HzI/KsQG0coEZ22yMtKdCzhqFN38e9TU8FLMWTwsN8NiyZQvXr1+npKQEb29vUlJSHrjfg8htbGwseXl5BAQE0N/fT25uLo2Njbz33nvk5uby5S9/+b79HoJXityGB0SKa0c2oPVyJSFnLYmbYknYFMvajMhlVxUF6Gro5ebxEq5/XkR7zWyimEqjJHNvCpsPrSdrXwpq7ZNHbz8LWMwWyvLqufzxbQrOVmAy2j8/coWMrD1JbH8rm6zdSSiUK78RzTRjJv9CDRd+U0hFfrPz99g30INdb2Sy661MAsOWn0PGi4Ju1MDFM5WcOV5OX499FU8QICM7itcOpZGzZe1q3O8DsNpQdhcOSYFDL+tYtg8KClqw1+tSZAk2m4329nbu3LlDcnIyVVVVTxRO8CA4bMS6urpISEh4KJlYqizBZrMxNjbGxMTEggIfHGPVarW4u7vj5uaGt7c3k5OT6PV6WlpaMBqNztQwh2Z3OUkYnjTEod7WwdWez7Fgr3CGq8LomJrkjmR63n7i3Xmht9mHHqsVlcVw33YBgXBVJDXjOrT3SAgEQUAqSAlTRVCuHyBKM7/hTCIIaKQueEqDKNP1E6ya794gl0jxlPkwZVFSqOtHK53/2ioEKVHqYOrGdHRa7RVgs23WVk8rU+Mr86VsdABFzNJCHAC0Wi07dux45D6CILBnzx4EQeC9997j937v9xgcHHQS1oCAAIaG7BOF3t7eeVX34OBgent7H0VuXykIgoB3oCcjfTpuny7j9ukyAJRqJUmbY0nNTSB1ewJRqeHLotoWGhfEV+KC+Mp/PkxvywA3jxVz41gxzeUd3Pi8iBufFyFXysnck8zWN7LYsD8Nl2XkMSqTy8janUTW7iQME9PcOlXOlU9uU3mjkVunyrl1qhxXDzXbjmSy890NrFu//JrpFgqFUk7uwTRyD6Yx2DPKpc+LufRpMQPdo/zrBxf51w8ukrwhir3vZLNxXzKqZVp5f17w9NLwztc28vZXc6gs6+Ts8TJu5jVQcruVktuteHpp2PN6CvsPpxMQtHjXoVU8GiuG3D6sq99BTCUSCS0tLeh0OlJSUhbVpb1YcuuopHp5eZGVlfVMlv9MJhO1tbXI5XKysrIe2ey2FMcDg8FAdXU1UqmUtWvXLojYPuiaDrKr1WoJCQlxVnb1ej2tra1O3eVcsvsisVRyO2oe4+e9xymz1QGwRqlBI/GlYtxerVXL5j8vjdIVX7Mb9UaHdGD+62M22nAlhELdIA+CTFAgF9dQpLNXZyX3jFkrdad7ykiHxX59qTD7HlQIMvzlAZSMd2K921Aml8gw3Z3/eAoatIo1FI3OVnrlggQbdnIbqwmjQa9nYOpuc5x08T63i3k/3rp1i8DAQIaGhti9e/cjY30fdN6VShaeBbwDPfl18QcMdg5Tc7OBmvxGqm800N3YR8mFKkouVAF2CUDylnWk5MaTsi2eiKSQFy5jCIr2590/Oci7f3KQwa5h8k+WcvN4CbX5TU4vXYVKzvrdyWw5mkn2a2lo3JZPRVejdWHPlzey58sbGe7Xce3zYi5/cpu2mh5Of3SN0x9dIzBiDTvezmbH29kERqzc9D6/YC+++sd7+fK3dlNT1MaFT4q4ebaKqtutVN1uRfOdz9l2KJ09b2ex9hX3ghUEgdSMcFIzwhkfm+LS2WrOniijs32Y3/win9/8Ip/0rEj2H0ojZ2ss8lfcmeJpYcWQ24dBKpUyNjZGa2sr/v7+ZGVlLfqDtFByK4oi3d3d9PT0EB8fj4fHs9HOOHx4F2IjBosLgbi3GtzX1/f4gxaBB5Fdg8GATqdz2knJZDLkcrkzwep5f/Et5nqiKHJ1pJTfDJxk+m5UbaQyjI6ZYbqsszIE293oWgGBSJdI+qem6ZmZ1bfKFXKYBokoEKYMQ2ey0WqeDUwwGo0AqCRKAhTB6GYk9Bhn9a+Su6vrbqhRSbwYMloZsxid22V3yW24SyB9UxY6pwxY5xBBhUTCjCglTB5I5fgIbpbxec9TIZHjpVAjiK4UjQyhlNi/GuSCdB5xhsVVbhdyrx2BG2vWrOHo0aMUFRXh5+dHf3+/U5bg+BwEBwfT3T27fN3T0+M8fhV2CIKAf7gv/uG+7PraFgBGB/RU5tVRkVdL+dUaBtrvUHCqlIJTpQBovVxJ3rKO1O3xZOxKJijG/4USEr9QH47+0V6O/tFehvtGuXmshGufFVJ3u9lJdOVKORm7EtlyJIucA+nLiuj6BHjy5h/t4c0/2kN7XQ+XP77NlU8K6Wsf4pffP8kvv3+SdZmR7Hh7A7lHM9GuUI9UiURC8oZokjdE8wf//Q2unSznwseFNFZ2ceZX+Zz5VT5ha/3Z/VYWO49m4OHzarunuLmreeNL2Rx9N4u6qh5OHyvl+pV6yoraKCtqw91TzZ79Kew/nEbQCm5OXA5YMZpbs9l8H4Gz2WwUFBQAkJKSgqvr0qIf29vbUSqVj/yRNBqN1NbW4uLiQmxs7H0/7o9qbFsI8vPzyc7Odjo7JCYmolQuLLO9ra0NFxeXxy7Nms1mamtrkUqlrFu3DplMRn19PWvWrJmn132U5taBjo4O1Gr1gsj3XDgmCDqdDolE4vRCdVR2F0J2n0Rz293djUwmW9Aydvf0ED/uOo7OrGfSNoKvwospg4RBcQqZdL5MwFcpRyNVM2N2oW1qhHCNO/0zI87tca5+mG1WBsZNDIlGkt0CaTR0ObcnuPhhNM/QbTQxjplYhQ/t1tmGsWRtCAgC5SNDmLCR4BZA89QsyYvVBCBBRrnefkyE2ode0+zx61yDGZqepsdoJ7X+Sjf0VrsOTC5IWacJp1zfg+mu162bVMWUOIVWpuJY9n+Y91zLyspITk5+5GqCzWYjNzeX8vLyR95jg8GAzWZDq9ViMBjYvXs3f/EXf8Hly5fx9vZ2NpSNjo7y/e9/n9OnT/PBBx84G8r++I//mKKiokdd4pUqGS00xGGw8w6V1+qouFpLxbU6hntG5233C/clY1cSGbuSSd0ej9ZzecTqOoju9S+KqCuY1X06pAvb3spmw2tpqDQL++58nrBabVRcr+fKJ4XcOl2O0WCfLMsVMrL3JrPr3RzW70xYdtZoS0FHYz8XPiniyrFSxkYmAZDJpWTvTGDfl7JJ2xy7LGQxywET49NcPl/N2ePltLfOFkRSM8J5/Ug6G7fFvVLV3Feuocxiscyrrk5MTFBbW4soisTGxi7JKcCBrq4uBEF4aAd9f38/bW1txMbGzmt6mYsnJbc3btxAJpMRGBhIaOjifBMXQs51Oh11dXVERkbOI3aNjY34+PjMI7eORLhnQW4B7ty5w+TkJBEREU7vVJ1Oh16vx2AwPJbsPmtya7ZZ+HQgj+ODN7GIVvwVHqxRulEx1o9FtKEUZAjS2aqpQpARqwmhTN+L5e7nKVStZdBkt/pykSiJUYdxW9eOeJdrJbkF0GSwk1NPuSuhqiAKdW3Ocya4+NFssnvc+ohatII7debZL74kt0Aap7oQgFhNKGaLnNrJWbIc4+pLp7EfV6mKAIU/o0YTPabZSnGIyoM7lmEiXPwYnhaxiiIjltmEM2+FBpPNSJI2gv+V+Oa8+1NSUkJ6evojl7ENBgNvvPEG+fn5D90H7BOzo0ePAvbP+Fe+8hX+/M//nJGREd555x26uroIDQ3lk08+wcvLC1EU+da3vsW5c+dQq9V8+OGHD3VhuItVcvsYiKLIQPsQFdfqqLhSS9nl6nkOABKJwNr1UaTvTCR9VxLrsmOWRXPaSL+eWydKuPFFEdU3G51EV+miIOu1VLYezSJrb8qyJLpGwwz5Zyq4/MltyvPqsNnsY3f30ZL7RiY7395ATGrYil/ON5ssFOfVc/43hZTk1Tufp0+AB7vfzGT321kEhK5WKMH+OWyo7eXMsTLyLtUyM2OXib1q1dxXltxXU2DEAAAgAElEQVQ6GrmGhoZITEykr68Pb2/vh5LOhaC3txez2Xxf977ZbKauzq6xjI+Pvy+tai6WSm5FUaSjo4OWlhZycnKWVH3u6OhAJpM90AHAZrPR1tbGyMgIycnJ92leGxsb8fLycoYYOMb0OHLb2dmJSqXCz89v0eOdS27vxYPIrlqtdroxaDQaSkpKlkxuu7q6UCgU+Pv7P3B71Xg7pwYLKJuoByBMFYAgqmiamiWOLhIFosSuZQ1XBdI/bWXaNjHPaSBY7codk55odSit4wZ8VC50TM+S00StP61TvaxVh1M5NsI6rS91c8hpqnsw7VP9hCiDKNX1k6Dxo9E4KyFZq/DCIDEiEV1pNoyS5OZPo6HXuT1O64dCIqFxbIIxs5G1rr60G2cruVFqX9RSBaWjds1viIs7A+bZ6l2KWyhtE3pUEiWfbvzGvHu0kMnF4OAgv//7v8+lS5ceud9zwMpmB4vE04jftdlstJR3UHqxitJL1dTmN2G1zBYWVBolKdviydybQtZrafiH+z7ibM8HI/06rn9exLXPCqkvnHUVUaoVZL+WSu5bG8jck4xCtfyanIb7dVz9pJCLvymga04UbujaAHa+u4Gd72zAJ2DlNxwND+i59FkJ5z8uZKBrdlUrJSeave9ms2lf8kvhKvE0MDlh5Mr5ak4fK5tXzU25W83d9BJXc19Jcjs2NkZtbS1eXl5ERUU5m8i0Wu2SSJYDAwMDGAwGoqKinI85dK9RUVEPJUJzUVBQQHZ29qKaMoxGI9XV1bi5uTE8PMymTZuWNP6HVZ6np6eprq7Gy8uLyMjIB46tubkZDw+PZUNu74WD7Or1enQ6HQaDgZmZGSIiIvD09ESj0SyquvGwcY+bp/iX7otcHq4g1jWAYfMwfgp/Ksf6CFZ5MjRHH+sqVeIiE/GW+TtlAK5yGxZxlgDEuvpisiqoHbcfF+3qSZdx9hyZHuF0T03RbrBXd9M8AqifnJUZZHtEUz02xIjJ7sKQ4RFE9YSd/CoEGQnqYIrGenBcca3Ckw7rMAD+Sg8C5T7k6zqc54vTrqF1uh8BiFaswSaoqJ+cJcuRGi+6Z+7go9DiJnFj3GShxzhCjKsvv8z++rx7tRBy29bWxne+8x2OHTv2yP2eA1bJ7RNiamKa6hsNlF2upuxSNZ31vfO2h8YFkfVaKpl7U0jYFPvCCcpQ9zA3vijm2meFNJbMroZo3NVsPJhB7lvZpG1PQLrMbJhEUaSlsotLHxeQ93mxs3oukQikblvH7i9tZOP+1GXr/7tQ2Gw2aoraOP+bQm6ercR0t0Lp6u7CjiMZ7Ht3AxHrVnX0MFvNPX2sjGv3VHP33nVaCAxe+qr1csQrR267u7tpbW0lPj5+niXWQpbkH4ehoSHGxsac4QWNjY1MT0+TkJCwYBeBwsJCMjIyFhzhOzAwQGtrK3FxcXh7ez/Qr3eh6O7uRhRFQkNDnY85pBTx8fH2JK2HoLm5GXd393nygoWQ28dVQB+FxZDbeyGKIkVFRQQHB6PX65mcnEStVjtlDI8jux0dHbi4uMwjt9dHavlJ5xnGLfZqbIZbNHWT/YzfbdgKdfFmwDTrapCgDqPRMMKEZVZ3q5ZZsCEiFSTEqMPoMowxbJ50bo90dafHOIICKZHqECbNFpqnZs+Z6u5Pg6EHH4UbatxRSuVUjc+S3QyPYKonOgnEHb0oI1jtTtXEbKU3UbOGduMggXjSMD1JpNKddutsJTbRzY9J2zRmo4T26Uni3dbQPDVbJVqr9cVVpqBi5A5Gm5VoV2/ap+6Q5B7AP63/yrx7uBByW11dzQcffMCvf/3rR+73HLCiya0gCCHAzwF/wAb8VBTFHz5s/2dBbu/FcO8opZeqKDpbQemlaqbGZ23wVBoladsTWb83mcy9qS+8qjvYNcz1zwq5+nEBrVWznxd3Hy2bDq9n25vZJG2OW3b6T4vZQumVOi7+Wz6F56swm+ykRq1VseXQenZ/KYf47KgX7nDxpDCMT5N3spzzv7lNc/Wse0tMcgh738km9+DycsR4kTBMGrl87v5qblpmxP/P3ntHx3XeZ/6fOx3TB2XQ2UmQBEAQhQ1soholUrKKRYmSLNlJdhM7yW6c3T1n43izq/ySzdn1Jo6d46KN7U1sFYqSVSyxiE0kxQKQ6B0gQRSiY4DpmD5zf38MMDMgQRCkJJCM9JzDoyPcO3feuXPn3ud93uf7fNn9RMm/maSFL13O7ZT14Nofs0wmIxQK3eBVc8NUWsKUMpyTk8OqVatuiWjONWs2FArR2tpKJBJh/fr1MavD1OvnWoV+7XsHg8HY8dva2giHw9OOP9trbzVG7E5iqt1wdnY22dnZiKKI1+vFZrPR29vLxMQEKpUqZmPQarXXfY9T/9/nHeefug4jCGGcIQ/pCiMyNIwHgjFiC/EYrkxlMm43tLvcuCNxYisBIogsUJmxByRUjg+TqpyuroTFCCvUOVyy2rnoHWalfrp3ShAEVmsWUWe14I9YKDFNn6zJBAlLVAuon4wOy9VMzzzWKjQofUaavVFCrVIoYZJzKJAieESueD0xpVcqiZ+TZZo01GiptMQf/lPpC2rp7alEHo/ntgs8v8I0hID/LIpirSAIOqBGEIRjoii23qkBpWYns/Ob97Hzm/cRCoZorbjMxcP1VB2pp7u5b1oKQ25eFht3l7Dp8RJWbVwx7yQyfUEqe/58N3v+fDdXOwajRPedSvovDXHoVyc59KuTmMwGtj+zgR3PbSKv9O7IoZXJo0VmG3auwWWb4NT7VRx/6zwdtT0ceeMsR944S8bCVB58bhMP7t1ExoJ7s3mCRp/E7hfL2f1iOZ0t/Rzdf4FPPqjhcmMflxv7+MXf/o4tu4p4ZO9G8ssW3xXfzZ2CRqvia8+s4/Gvl9HWPMDBD2o4fbyVuqpu6qq6MZo07HysiF1PlpCZde/bWD4r7hnlNhwOz0hiBwcHY8vUtwur1Up7eztSqZSCgoJbysidQm1tLatXr55V6Z0q6lq8ePF1SvOtKr+JmDoHycnJtLS0sGDBArKzs+d0I7hy5QoajWaaAjsX5fZWUgeuxWdRbmF25XCK7CbaGFQqVUzZtVgsKDVJHPN38M5gJUExTLEhF1GEBvsQQTFCgT6LSwlJBEvUaWikSdTahgmJIqkKDc5wPErLIEsiNymFGttQrGDMpJAxEY5WQ5sVelLlBmrtcaU0T59MlydqU1iqTkeJinpHfLm32JRJs6sfCQL5ulzCYSm19viY1qVk0eDsI1muIVVmQibIqLPHlY8SUxZNrj5W67K46vKQqdDSMhH33K5Q6BnDQ5YihTrbGGtM6bQm2BQKDOnIBAlmmZG/K35k2vmdi+f5xIkTnD59mn/8x3+cdb95wL+pp6EgCL8DfiKK4rGZts+HcjsbxgasVB1toPpIA7UnmplweGLb9Cla1j+ylo27Syh9aA2aO9SeVhRFupr6+PS9C5x+9wJDXXEVLGtpOvft2ciOPRtZsDL7joxvNly9NMSJtys58XYlY4O22N/Xbl3Jg89vYsvukruygO5W4PcFOPdxE0ffvkBDRdw/nbssnUee28D9T5VhTPlq4gzRpIVPjjRz8IMaerqizxNBgNL1S9n1ZAmbtqxAKru31P0vnS3hRuR2ZGQEl8vFsmXLbuu4brebhoYGADZt2nTbyzz19fUsX758RmIciUS4cuUKNpuNwsLCGRsZVFVVUVRUhEJx60rZ0NAQAwMDhEIhCgsLb4mcd3d3o1KpppHUuZDb/v5+pFLpbZNbl8vFkiVLbvm1cGtpCaIo4vP5YgVqleOd1MmG6WDSC6vOQCNRU+Poib2m0JBFx2SSwXJNNmJYQZMrThwzlDqsk8kCq7S59DgnsEWm58bq5ZKoWqvJoW7cQkqSEos/XoG+TGfEEfSSrkildnyEAmMqHe64TaHIlIE3HMDtF+h2OyhNzqAhgfyuS84mAjSNj+EJhyhLyZpGbjck5+IIBGi2R324JclZNDii2yUIrDfkUmMbwROO/qZWqHR0haOfKTfJSLbCxJnRPnZmLecHJXFyGw6Hqa+vp7S0dNbz/tFHH9HW1sbf/M3fzLrfPODfDLkVBGER8ClQIIqic6Z97jS5TUQoGKLl/CUqDtRQebCWwc749S2VSSnYkseGR4vZuLuEnBV3psOcKIpcruvmk7cqOP3bSqwj8WzppWsWcN+eTWx/ZgPpd5kyGolEqD/TzrE3z3PuYF2s7W+SRsnWJ0p58LlNFGxafs/bFgZ7xzj69gWOvnMRmyV6/5TJpWx8sIBHntvA2i3zvxpwN0IUxVhu7ulPWgkGomt0yalaHnlsLbueKMGcMXu79LsFXzpyO5W9ei3GxsYYHx8nLy/vlo4niiK9vb0MDQ2xZMkShoaGWLt27W2Pr7GxkcWLF6PTTQ+pnuoEZjabWbz4xssqNTU1t+TxnYLP56OmpgapVHpb3dJm8izPldxKJJLb8jqPjY3hdDrnhdzG3tPv4qfdJzg51k5+UiojISe6iJrLASd5ciPdkXj17hpDFpaAHa3ESJPdcl3SQJZKj0IKYlhFh9OKVqYgIExvv1ugNzM8EWTAG70hZ6hVjAeiLXglCGxIWUj12CgTk77d1cYULrujCpJepmKVNoszlt6YElySnEHjJLldpknDINVwwRpXcqfIrUIiZbU2C0SBalucDJclZ1Hn6CdbpiUcUZCWpKXWnqAUG810ei3kCHraXS6WqnRcDjrZlb6U/1n6SOy6CgaDNDc3U1xcPOv53rdvH1arlb/4i7+Yy9fzReLfBLkVBEELnAb+pyiK712z7Q+BPwRYsGBBaW9v7x0Y4ewQRZG+jkEqD9Zy8XA9zec6iITjNq7cvCzKv1bG5ifLWFE6c/HrF41wKEzDp22ceqeSs7+rnqY6F2zO4/7nNrH1qfXok+8u1dDt8HD6/SqO76+grSpeQJe5KJWHnt/MQ3s3kZZ9bxcdhYJhLp5s5eO3Kqk53R6LFDNnmdj53AYefnY9qRlfTFOlew1Oh4ejhxo59EEN/VejdRcSicC6Tct47KlSyjYuvasnBF+R20nYbDYGBwfJz8+f87G8Xi/Nzc3odDqWL18ea25wMzVqNjQ3N5ObmxsrdhNFkf7+fvr6+sjPz59WBDcT6urqyMvLQ62e+1Ld6Ogoly9fJj09HVEUWb58+S2Pu6enB7lcTnZ2fAkuEong8/lmtUgMDAwgCMK8k9u5LotPISxG+HConl/0nsITDiBBoFSTQ8PEKJ5w9Hoq1mfSMhFVNaUIrJCYaQ3Y8U82NJhKGoCof3WNfhEV41djHcAMchVeosQ1Wa4hTZZMk2No2o8nLUmBPeglXVAjkWoJEmbQG1eJ8gwmeibGyddn02Z1sECnp80ZV7qKTen0eW0Ygkou+TyUpmZQn0BOS5Oz8EdCjLh9DHknWJeaRW2CkrsxJQdfKEKNZRgRgbLUzGnkdlvaIhrHR7H6o17j4uR06h3D7DTkskeVjUwmw2g0olarGR4epqioaNbz/stf/hK5XM6f/umfzul7+gJxz5NbQRDkwAHgiCiKP5xt37tJuZ0NLpub6qPRorSLh+tw2SZi21KyTGx6rISNj5Wydkf+HUlfCPiDVB9r5NQ7lVQerMPvjU5CZXIp63YWcf9z5Wx49O5LLujvHOH4/vMc3x+3LQiCQPF9q3j4+XLKdxWjUN3bcVuWITvHf1vFkbcvMNIfJ2/r71/Nzuc2su6+lXddEsadgCiKNNb1cvCDWs6ebCMUij7P0jMM7HqihJ2PryX5LrR3fOkKym4EmUw2p9a5EP2yBwcH6enpYdWqVbHGD5FIZM7HuBGkUmmsoCwQCNDc3IxSqWTDhg1zKhKba0EaEEt08Pl8rFu3DqfTyfj4+M1fOAMEQZhWUBYKhWhpacHpdCKRSDAajbF/1xan3e2FaE2OAf7+0jFk0giecIDF6jTs7iC2YChGbIHYLHapOp1xb4SATIXfH/8ufN6oKrtClc4Vu5seiXtaa1spAlJBQr42h8bxcYYiI9EqswSoJHLytWnUjA0hYifrGuuIUaYmQybhwkhUvU08t1JBQCdV4/Y6GJlMdBATqHO6SocSJRcsIwlHjG6XIFBkyCIQlFA9NsQU15sS5ReojcgjCly+cIzYAkglUjQyBXnpuaxbUYrf78fhcGCxWHA4HNTW1mIwGDAajRgMhusmQh6PZ9qE6SvcHoTo8smvgLabEdt7CTqTlh3PlbPjuXJCwRBNZzs4/2E15z+sxtI3zoF/PsGBfz5BklZF6UNrKH+8lI2PlaA1zk+bWoVSTvljpZQ/VorH5eXchzWc3H+eupMtVByopeJALUlaFeWPl3L/c5vummixnGXpfOv7T/HSXzxB3ek2jr5xjorD9dSebKX2ZCsafRLbn1rHwy+Uk1dybxZopWUaef4/PMRzf/IA9ecuc3hfJRXHmqg83kLl8RZS0vU89Mx6dj63gYwvQdODG0EQBIpKFlFUsgibdYKjB+s5+EEtw4N2/uX/nuQ3vzxN+bY8dj9ZwtqyxUgk9961MBvuGeV2aqn8Wng8Hjo6Om66TBoIBGhpaUEmk8Vaz04hEolw8eJFNm7ceNvj6+joICUlBVEUuXTpEsuXL7+l7l1NTU0sWrToOlvDtXC5XDQ3N5OdnU1ubi6CIDA+Po7FYmHlypW3PO7EjNyptIiFCxeSmppKJBLB4XDE/KqiKMaIrtfrjaUW3Cq+aOXWFvDw867THBpuRgSKjBmIESm11mjBV6E+hQ5vnAhuSF6AOxCm1holliXJmTQ546pnoS4Dpz/ApYmozTFLmsQo8Ziv1boM7AE/Vye3KyQSwkLUyypBoECfRa/bEcusBUhXJzHmn0AnU7I4KY1Rr4e+BCV3pTGZy+4xlmlS8fpFdAoFLY6E1owpZi65LKzWZVA3aqEgJY16W7xgrSw1E1fIh88v0O10UJaWQY01XjC20ZxNMCRSZxkmLMI6cybV41ElVwC2mRfROG7hucUF/HF+/Fy7XC76+/tZtmwZdrsdu92OwxEd99S1oVar+ad/+ifWrl3Lnj17bvg9TSEcDlNWVkZ2djYHDhygu7ubvXv3YrVaKSkp4bXXXkOhUOD3+3n55ZepqakhJSWF/fv3X9d4ZQbc03dsQRC2AGeAJqJRYAB/KYrioZn2v1eU2xtBFEU663uo+KiGygO1dNb3xLbJ5FLW3l/AlifXUf61Moxp+nkf3/iQndO/reTkO5VcqolbAJLTDex4rpwHnt/MksLcu4o0umwTnHzvIsfePM/lhrhlZeHKLB5+YTMPPLsRY+rsz527HTaLixPvVfHx/gsMdE8VVgmUbF3Bo89vYsMD+cj+DcRkfVZEIiK1F7s4+EENFWcvEQlHKV52bjK7nyrl4V1F6A13NnrtS2dLuBG59fv9NDU1zdqCc2r5ftmyZTM2HRBFkYqKis/UPrejowO3O0p4CgoKUCpvrWL1WlvDTGPs6+tjYGCAgoKCaSTYarUyPDzM6tWrb3ncfX19RCKRaAvO4WEKCwtRq9Uzem6nGmnYbDYsFguiKJKenh4jNXONMfss5DYSiVBTUzMjuY2IIu8NNLK//wKDPscksczG5Q9yaWIstt8afQrt3pGY2hqJSKmxxclsaXIWjc4+VBIZKzRZ+ILQ5EpseGDiqm8MvUSBMazGGgphT/DcqqVy/PhZpE4mHJTR6bShVEBIjKvB5iQVOUkmLlnt2AMBcnVaBrzxGqGiZDNCRErtpBq7OjmVdme8CcS29IW0jY8z7I0qucWp6TRMpjGYFEkU6NP5dOhqzLNbmpZBrXUQAVhjyEAhyLg4Fv9MU+R3sdaEEJJiVKqoGRvizws38vt58Ymj3W5ndHSUFStWTDv3U9eG3W7nr/7qr2hubmbNmjW8/PLLbNu2bVqTkGvxwx/+kOrqapxOJwcOHODZZ5/l6aefZu/evXz729+mqKiI73znO/zsZz+jsbGRV199lbfeeov333+f/fv33/C4k7h7WMY84F4nt9di9OoYFQdqOPe7ahpPx9vUSiQCBVtWsvmJMjY9XnZH8nQHroxw6p0KTuw7x0BCsdyi1Tncv7ecHc9uxJx7dxWidbf2c2xfBSfeqYw1iZDJpWzYuYaH9paz7sGCu0KBvl2IokjThSsc2X+BM4caYvnAplQdD+1Zx87nNpK18O76Tu4Uxi0uDn9Ux6Hf1TE2Gn32yBVStj+Qz2NPlbKqYG6JS583viK3kwiFQtTU1LBhw4YZt7W3txMIBMjPz5+VcN5u+1wAp9NJTU0NaWlp5Ofn39YF0draSmZm5owNF6ZsDiqViry8vOtIpN1uZ2Bg4JZ8x1Po6emhv7+flJQU8vLyYrm3NysoGxoaIhAIoNFosNlsOBwOBEGI5csaDIYbkt3PSm5ra2uvm8w0O4b4QfsntLtGMCcpMcrV+IIC3W47K/QmrkzEbRuF+mTCErB7Ra5OOK9LGihNziIkhuhzehnxeVhjSqfFldjwIAWdTEmzdRxPKERWkpaRYFx1NUkUpMt1tLrsMalNKo8T2yWaZCQRGe2O+JiytGqGfW6kgoQiQyZWj4+uiXjUT54phcuuMVIlSlJU0cKJVkec7BalpNHmtFBkzKRl1MqK5GTqrfEiuJLUdFwhPxNOPwN+H6XmDGqt8c+00ZxNIBSmbnSUiAhl5gxqxof43totvLCsMLbf+Pg4drt9Wje/mfBnf/ZnrFmzBpvNhkql4nvf+96M+/X39/PNb36T73//+/zwhz/ko48+Ii0tjeHhYWQyGRUVFbzyyiscOXKEnTt38sorr7Bp0yZCoRAZGRlYLJab/d6+Irf/RmC3OKk4UMPZ9y9Sd6KZUDBuJVu2dhFbnlrP9mc2kL18fpMXRFGkveoKx988y+l3L+Cyxv3Da7au5IHnN7P1qfV3VTOCYCDExWNNHHn9LNUnmmOTBpNZzwPPbmTni1vIXX7rDXruJrjsExx/r5rD+yrpS5h8FJUvZ9fzm9j0cAFyxT3vzPzMCIciVJ67xMH3a6m+cCX29yXLzDz2VBn37yxAPY/xcl86z+2NHmBTDRiuxVSm7MKFC+ec+XqrEEWRnp4eRkZGyMrKQqfT3fb73MhzOz4+Tnt7+6w2h2t9s3OF1Wqlp6eHlJQUVq1adVtjTk1NJTU1OhMOBoPY7XbGxsa4cuUKUqk0li9rMBi+kApoW8DDTzvP8tFg1IJgkKvIVaZSNT4QUy0Tz4xBokQlqqkYG5rxeNlJBhQRFZWW+PKdkMCPciUatGi4OBovxpJONjyQCgKF+iwGHBM0u+zx7VPvLVOSEk7i0pgT9TU31ZAYYaUuDac3RNXwCLm66UZ/mSBQbMimbmSYEc8YK03TvWQGmQqzxMDFwehNPNETnKxMQi0oqbWMxM5JZPKsyAQJRaYM/D6R2vG47SEy+XqNbLrPOhwOz0mh9/l8bNu2jZKSkln3++53v8sPfvADXK6oijQ+Po7RaIzZhnJychgYiJ7rgYGBWItpmUyGwWBgfHw8dv19hekYuDxEa+Vl2i920lnXjcvmxuP04nF5kUglyJVyFCo5OqMGQ5oeQ5qelEwTaTkppOWmkL4wjayl6fPmc70ZjGl6Hv29HTz6eztw2yeo+riB8x9Wc/Hjejrre+is7+Ff/8fbLC1ayNanN7Dt6xvmJWJMEARWrV/GqvXL+PYPvkHN8SaO7zvHhUN1NJ5pp/FMOz/9T7+h/PFSHnxhCyX333l/rlwhY/PuYjbvLmZ8yM6Jdyo5+uY5+jtH+O1PjvLbnxylYONyHnlpC1seL0Glvveyc3VGDU/9/nae/L1ttNb08PFblZw5WE/D+cs0nL+MMUXLQ3vW88jeL7eaK5VJ2Lx9JZu3r2RowMbBD2o4crCBrs5R/un/HOIXPz3OA48U8vhTpSxedv3K992Ke4bc3gjXkslIJMLly5dxOBwUFxffUvrArWAqccFgMLB+/Xr6+/s/U1HateR26nM4nU5KS0tnjQi7lWI0mPS1dXZis9lYtGjRbRHjmUi8XC4nLS0ttgQdCARiy9idnZ2xivvE4rvbRViM8G5fE//SVcV4yDlJLLNptdq4FLbGSBxEi6/kgpR8XRb1llHs8mvzkkXUUjnLNRnUjo6QnDp9u0SANKWGNJmBhrFRlPLpKwhSicBybSoTPpGLw6OkqqZfcwqpjOVqIx02B2ORCUAgGIlfK+kqLVkKXcyCEP180e9EAIpMmbh9QZqdcSU2PKkJZyRpSZVpGXH76XPHc3QjYgS5REKRIYPW0XHsCv+0cxIRRVYZ0nB7gtQMjLDmmomTSiojX2tGyfXkdi6TFI/Hc1P/+IEDBzCbzZSWlnLq1Clg5iLFqWtttm1fIY72i538y3/fT92JppvsGbXSWPpmL0bVJWvJXpZBzvJMcvKyWLAymwWrsslamo5MfmceIVqjhh17y9mxt5yAL0DN8SbOvHuB8x/VcKWhlysNvfzr/3ibxQW5bH5yHVufWs+igi/eCytXyNi4q5iNu4qZcHo5+0EVx988S+OZdk69U8mpdypJTjdw356NPPD8ZpYWLbzj13BKppFn/+Mj7PkPO2mr7uLI6+c4/UEVzZWXaa68zM/+6z62P72OnS9uvieL0ARBIL9sMflli/mj//4kn7xfzeF9FfR0DPPOq5/wzqufULx5BY/s3filV3Mzs038uz95kJf//X2cO9XOR+/X0Fx/lQPv1XDgvRry1+Sy+6kStu1YjUJ5d5+nu3t01+BmCuVUsVVGRgbr1q37wn6EQ0NDdHV1TUtckEgknxu5ncrGTU9Pp6ys7Kaf41aUW5/PR2NjI8nJyaxbt47h4WG8Xu/NXzgDbvaeCoUCs9kcU5z9fj92u52hoSHcbjdutzum7Op0ujmRJlEU6Qw6+IeKN7nkGiNJKmO5No0JX4SLo1FyqLgm1SFNocPlFbkwOkUO4+MWAP2uWEYAACAASURBVLVEhRBUcXFkOPa3KSglUvTSJJpd4wyGo8qmJOH7SFWqyZQbOTsaz5yVJmxfqU8jEBCpH49bDCCq1CoFCQulWjodEzg90wlzMBJmqTYZQlJqhyzkGqYruRIklJmyaRgZZTjiZdk1dhaTPIk0QUf1lJIbiX/mLLUWjaigYjjuuQ1P+oG1cgUrdak43UFarGOo8qcrTHNtEe12u2/aTOTcuXN8+OGHHDp0CJ/Ph9Pp5Lvf/S52u51QKIRMJqO/vz8WN5eTk0NfXx85OTkxj+/U7+8rRGEdtvMfN/83ANS6JNbeX8CqDcvIW7eM5AwjGn0SKq0KMSIS8AUJ+AK4rBM4xpzYLU7GB61Y+sYZ7RtnuHuUoe5RXFY37Rc7ab/YOe295AoZC/NzWbl+WexfzorMec+oVagUbHqslE2PlcaJ7nsXqfiohu7mPrqb+3j9b98jZ3km9z27ifue2zQv3cc0+iR2vryNnS9vY7jXwidvnef4m2cZ6BzhvZ8c4b2fHGHBqmwefnELDzy/meQ7nNMqCAKr1y1l9bql/NHfPsvp96s48uY52qu7OPybMxz+zRkW5GXy6EtbeeDZjXdd3u9coNUn8bVvbuXxl7fQVtvD4X2VfHqgjrpzl6g7dwlDipaH96zn0ec3kbngy5u0oFDI2PFwATseLqD7yigH36/h+OFGWhr7aGns49UfHWXnY2t57KlSMrPvzla/94znFqJK4EzjPXfuHFlZWQwPD19XbDVXnD9/nk2bNs1KJIPBIG1tbQCsWrVqWjTWZ20DfOXKFdRqNZFIhN7e3jll405hYmKCy5cv37QJxVRhXSIpHx4eZmJiYpqHci6e25GREfx+PwsWLJjTGBMx5dvMycnBZrNhs9lwuVwolcqYZ3cmi8eoz82/dlazf6AegFSFhhyViRrrdIuBSSXDGfKTodJhELRMhAP0TMRtAvmGZNonxlisSUYMStErVNQmJAmsS8uixtZPoSGDIaeHbI2OuoQkggKTmc6JMQr1GTRaLORo9HROWGPbs9U6RCFMikxH45gFg1yJU0yI2RIECpPT6HdMYJksCFMpJPgn1Vy9RMYClY5mhz2mtmbq1Ax73ZNKbgZuf4BOR/wzLTYa6XLZyNXo0QtKApEInY44oV6eYmJgwkmOoKJrwsuyZBPttrhityotFZVERs+4A7vPR15KMu22cX7x4G42ZubE9rt69SoKhWJau+aZsHPnTo4cOTLn3+KpU6f4+7//ew4cOMCePXv4+te/HisoW7NmDX/8x3/MT3/6U5qammIFZe+99x5vv/32zQ59b8lMnxFmbaa41r+dx7/9MN/862c/MwERRRHbiIP+y0P0dwzSf2mQq+2D9Lb2MdI7dt3+WqOGvHVLWbl+Gas2LGfl+mXoU+5MJX4wEKLuk2bOfVDF+Q+rYwVUAEvWLGT7no1s+/oGspfNn7dUFEU6arr45K3znEoo6pJIJZQ9VMhDL25l4661KFR3T35ub8cgR984x/G34+OVK2WU7yrmkZe2ULQl757uhOZyePjk/Ro+fiuq5k6heMsKdr9Y/lXSwiS8ngAnjzVz4L0aOi9NCkEClG2MNodYX77sc2kO8aUrKIOZya3H4+HcuXMsXLiQZcuW3faP7MKFC5SVld1QlbJarbS1tbFkyZIZW85+1jbAnZ2dWCwWtFrtdVFlN4PX66Wtre2G/sZIJEJHRwcej4fCwsJpLX5nGvdcya3P52PhwoVzHucUblSU5PV6sdvt2Gw23G43KpUKo9GIxqDnA0snv+qsxqxSM+S3UWjIpnF8DBkCHqarnulqFblJJupGLQQiERYb9PQmkNtikxkBKbWjI0SA0tQMahPI62ZzLuNeH22T5C+6PU5+y9MW0Gm3MeKNFo6sMKRwyR190KulcopNmVwYGSQ4qcSnKJOwhqMkNkuuxqjQ0mKPF4MBSGUgk0hYY8ygdWQMpCIT4bg9wqSSYZArCXsj9Ht9ZOo1DHnicWQrkpPRSpQ0DI8QFkUWm4x0O6OfWSIIlGdm0zw6ht3nB2BZsjFGflcaU1AJMhoscc/tsmQTl+1WXnvkCdamxR/+3d3daLXaWdMPALZt20ZVVdWcr+NEctvV1RWLAisuLub1119HqVTi8/l46aWXqKurIzk5mbfeemsuRYlfKnKbmpQuloR28Mumf/jC1UmPy0tnXXdM1W27cJnxQdt1+2Uty2DlumWs2hAlvEvXLpp3z2k4FKb+VCun9p/n7AdV07qPLStexLavR4lu1tL58xQGAyGqjjZw9LUzXPy4gXAoOrnVGtVs+/oGHnxhC6s3LLtrbADBQIgLRxv5+LUz1HzSGnsWZyxM5aHny3n4+fJ7uhOaKIq01/Vy8I3znDlYT8A/mbSQpuPhPRt4ZO+XOzd3CqIo0t46yIH3qjl1vCXW6tecYWDXE8U88njxZ2oO8aUkt8FgMLZ0L4oiAwMDXL16lXA4THl5+ZyjqGZCVVUVRUVF04gfRIlhZ2cnDoeDgoICkpJmrni1WCzYbLbrIpLmApvNRn19PWaz+bYSD3w+3w07rE1ZHDIyMli48Hp/1+joKA6HY1p3s7mQ29HRUTwez1xyRq/DXCruRVHE5/NxrKeNn16tZSQUtU4UqlPo87iwTjZh0MoUeMQoYROAQmMmo+4JBrxx4rdIr+eqx45MkLBMbiAiSGl3x5XWktQM6mxD6ORKlmtSkEQkVCUouVPkdoHGQGQijEmrp9Een+GvNKbS4bKw1pTJVZsTnUxJtzdOps1JGkJCiAUKAw0WC1qZAhf+2HaJAIUpZkadXoYnooRZkaDkpqqSyFKoaRofZ4qrmZLk2IIBpILA2uQMRt0e+tzxKLEcvY7+CRcrjSn4fWEiAvS64okOi4x6ApEwqTI1zaNjLDDp6XXGt69KTSFJkPO9jZvJS47f0K9cuYLRaCQlZfab/NatW6mrq7sbHsx3fADziWRFmlgmPsCrNf+bJWtufeL5WWHpH6ftwuUY4b1c0xXr7jUFjUFN0X35lNxfwNodBeSuzJrX6yTgD1JzrJFPf3uBio9q8LjitqyV65exY28525/ZOK82Afuok5PvVHD8zXPTsn1zlmfw8De28uCLW0jJvHuWf0f7xzn65nmOvnmO0YQuYWUPFPDoS1tZ/3DhHS+a+yxw2Sc48X4Nh96siCUtCIJA6fY8dr+4mXU7Vt3VLWznC06HhyMHGjj4fg2DA9GJrUwmYcuOVTz+dBkFRbfuc/9Sk1u/309LSwtKpZK8vDzq6upmJKa3gtraWlatWjWNvLrdbpqbmzGbzSxePLuR/nYaKUQiEbq6umIV33K5/LaW+QOBAA0NDddlv051Y5vN4jATKb8byG2Xy8oPms7gDgdodg6TqzagEuW4/QEGgvHlRY1UhpcgSzTJEJJw2WFDrZThCcU7kC3U69DJlNg8AQbcbvKMRjpccXJbmpoBCFwat+MM+FmXnkn1eJzcrjdnEQpFYjFZa1PNNCSQ23WpWVg9Pq7Yo4R2icHIlckYL4VESllKJg2jo3hCUSXAqFRhm1RyF2mNaFHQYpu+xCvIo68tNJppHrYgkRF7PYBeJSdNrsTpCTLmD2BQybEH4yQiPzUVaURC82hUIc7QaxmciBJ+nVxBYUoaVYNDMS9ulkHLgNuFQiJlTYqZUdcEfS4XH+55loUJ186lS5cwm80YjTd+8IuiyLZt274it3cAOakLxNWOctbuyOd/ffz9O75cHAqG6Gnuiym7Lec7GLwyMm2f5EwTa+/Lp+i+1RRtX03mkvR5u24CvgDVRxv59N0o0fW6o/YhiUSgaEc+9z27ic1PrJtXf2lPSz/H953jxJtnsY44YuMpfbCQh76xlU27i+8a20I4HKH+0zaOvH6O84fqYvFsyekGHn5xMztf2EzmHcgg/rwgiiItVd0cevM8Zw43EJpUKdOyjOx8bgM7n91A6h32St8NiEREaqu6OPBeDZVnL8Wi5RYvNfPY06U8sLNwznFiX1pyOzg4yJUrV1ixYkVsaXQmYnqraGhoYOnSpWi12ljDhP7+fgoKCtDrb94Jx2azMTQ0NOdGCl6vl6amJpKTk1myZAlDQ0MEg8HbIovBYJC6ujrWr18PRPN929raiEQi5Ofnz7o0PDY2xvj4OHl5ebG/zYXcWiwW3G73bXmMZyO3zqCfn7Vf4O3uZkJihLXJ6Ugl0lgnrcVaAz3e+NKnWZ6ESZDTMeGK+VOTFFK8k0v6OWo9GUot1ZY4GV1hNHJpktyuMqShkyi5MJrQ0CA9k5rxwVhMliwipdISj/4qTkun3jZEmkpNlsJAKBihJSFzdpnRxGW3lTWmdCwOD3KJlL6EBg2pSUmEJREWq03UD42gkcpxJVgrpBKBgtQ0BqxuxieL/aQKgdDkqsUCrR69XEmLJU6ItSoZrmAQtUTKArmaYb8PZwIZTtYmYff7WapQM+oNolDKsHjiS7NpuiQy1VpG7BOMuj2kaJMY83o5+vwLpCcUhrW1tZGTkzOrl3aK3NbX199wn3nEHSO3giAcFkXx0fl8z+K1xeKykTIcYy7+9J9+n6995+H5fPs5YbhnlLpPmqn7pJn6ky3YRx3TtqflplC0PZ/i+wso21mEyTy32oPPCp/HT+WBWk7uP0/Vx/UxoiaVSSl9qJD7ni1n85NlJGlunFzzeSIcClN1rJFjr5+l8mBtbDxTtoWdL20jr2zJ3TCBBMA+5uLE/goO/eYMAwkTmLXbVvLIN7ZQvrsYhVI+yxHubjisbo79torD+yoY7IneeyVSCRseWM2uFzZRsvXe9h5/XhgddnDwd7Uc/l0ddlt0JTJJrYjGiT1dxuKls3du/VKS29bWVlwuF6tXr56m0iYS09tFc3MzCxYsQKlU0tzcTFJS0owNE24Ep9NJb28vhYWFN913eHiYK1eusHr16ljThqGhIXw+322RxcRGFk6nM/ZZ5pLvO5PiLIoiwWBwlld9dnJrs9mm+XzDYoR3ulr5dKSbs5beSWKZCWGoTvDDLtYa6fFao6qmIYNemwtL0D3t+AqZgAyBBXIdl1wu0rVqhrzxYPXlBiOeSBCTREOzZYwicxr11vjNuCw9E384hM0dYMDlojQjg+qEXNxScwYSBJqGLfjDYQpT02iyxf2qxWnpTPjDXBqPEuhFegM9nqiqKxcklJkzaRwZxROMkk+DUok9HFWMVhiSkYQFOmxxZVkQICIVMcgVZMvVXLI5EeRxsgugTZKzQp/CFYsNlz9Akko6TeldZTRi8wQYmYiSZb1GicMftUYsN5qQIaHdEi8w0yUpcAYCnHnpZfQJzU+am5tZvHjxrEkIkUiE7du3fynIrSAINwryFYADoijOa0eBsrIy8Yd/8RP+9vkfIZFK+C+//DYPfmPbfA7hliCKIr2t/dSfbKHx01YaP23DOe6ats+K0iWsf7SYdY+sZUXZ0nlZDnbZ3Jx9v4pT71TQcLIlpkSpNEq2PLmO+1/YQvGO+curdY67OPl2BUdfPzvNtrBwVTaPfHM79+8tvyPtiGeCKIo0V1zm8GtnOPtRLQFf9FliSNHy4N5ydr28lex59DZ/3ohEIjSc7+TQmxVUHGsiHIrehzMXprDr+U08tGc9hnswSeLzRiAQmhYnNoU1xQv52tfLKN+eh2yG38+Xktx6vd4ZZ0Y3a107F7S2tqJSqRgaGpqmCs8VbrebK1euUFRUdMN9phTVcDhMfn7+tLSFmVIL5opIJEJlZSXZ2dkMDg5SWFg4Z6JvtVoZGRmZ1sRhLuT2s3QZs1qtWK3WGLk9P9LH/2k6R6fTSllaJt5wAIc3SJ/bRVGKmUZHnHgu1hqRhoI4QwIjHg9GhRJHJO6ZkwkSilMzaB+z4prsaJeqUjAWihI5tSCl0JhGtcUSW5JPJLcLtQZyk4ycG4xHe02RWwFYrtSSqjFSMRJXctekmWm0jpCiSmJBkgF/IEyrPU4UlxiMdE/YWG1IYdjuJkmhZMATf4CnJiUhk0swKzQ0DVvQyhW4InFPrkYmZ1VaCq1DY3hDYUBETBDj16SYGZ/wMOSKE3iFUoI/HGaJwYg8LKHX6cSfEFWnUEgwKJVkKLW0DI2hUEnxJZDhTIOWdKWGX3ztMeQJZKKxsZEVK1bMmrvs9Xp5/PHHuXDhwg33mUd80eQ2DJy+wftsFEVxXttSTXUo+9f/sZ83/+59BEHgP/3zH7HzW/fN5zBuG5FIhJ7mPupPtlB9rIHG060xcgSgT9FR8mAhZQ+tofThonnxodpGHZx57yKf7DtHa8Wl2N9N6Qa279nIjr2bWblu6bwpqD0t/Rx9/QzH3zw7vYXurmIe/sZWyh4qvGP5w9fC7fBw8t2LHP7Np3Q1x7tArtm8gkdf2srmx0pQqO5dNddqcXL07YscfrOC0cliSplCytZHi9j1Yjn5ZfdeLvAXge7OEQ68X8vxjxvxTsZeJqdq2fVECbu+VkyqOT4x+1KS21AoNGOWbFtbG2az+aZFLjdCOBymsrISqVRKSUnJbXl3PR4PHR0dFBcXz7jd4XDQ0tJyQ0V1psKuucLv93PmzBmysrJuSW2Gme0U80VupeYUftPZwG97WoGohWCx1sSnQ/FZXiK5XaI1kSpVc8ESV1FNShX2Sf9qgdGMzR1gxOcmJMZVzQydBotvgkJ9GpdGrSQrlfQH4oS4IDWFAa+LxWoTDUOjrM3IoCbhPUozMnAHA/i9YXodTkoyMqhJUHKLzelIEWgZHcMXCrM6JXWah7bUnIHD56fLGlVvF+j19E5El2J1CgWFJjNVQ4OEJsl2skrFeNAbjf1KS8fu8tGbUCymkErwC2GWGkzIwhK6xmyEpYk/VRGzXkOmSkvjwCggIMjjXcf0SgWLtDpaR6xMxd+KMhER0MjlrEpOoWXYQigsUvUnfzDtu6urq6OgoGDaxOxajI2N8Qd/8Ad88sknN9xnHvFFk9tm4ClRFC/PsK1PFMXcL/L9r0Vi+923fvA7/t/39wHwnX94mSf/w6P33IPW5/HTeLqVi4fruPhxPcPdo9O2Ly5YwPpdxZR/rYy8dUu/8GXhgc5hPtl3jk/2nWOgM251ylxi5v69m3nwxS3z1v43GAhx8eN6Pv71aaqPNia00DXw4Aub2fnN7eTOQ4e2uUAURTpquzn0mzOcfu8ifm/0+aIzaXjw2Y3s+tY2cue5bfLniXA4QvWpNg6+cZ7qU+2xJIlFeRnseqGc+58qQ6ObHzvL3YyJCT8nDjfy4bvVXI1ZOwTKt+Xxta+vo6hkIRKJ5CtyO4XLly9jMBhu2J52NkyRTqVSSU5ODunpt7dc4vf7aW5uvi6xILFFb2Fh4Q2Xc2fyvs4FU22GQ6EQ27dvv+Vx2+12BgYGpqU0zIXczqUo7EboGRni1dZaPh7vZ01qGl1uG8s0KdSPjLDWnDGtmKsoxcyQ30WO0kDd8AhL9EauJMR6JStV6FRyNChpG4uqpTI5hBKu6/UZmQzYJxiYbPG61GTkymRMlkKQkK/W0eZ04Z98OKxNN1M3HiXU2RodS/UmzlxNUHIzM6i2DCERBIpS0lEi5UJCQ4SC1DSarBYyNVrMCjXBYJh2e9xmsNhgoM/jZE1KOpctVgwKJf0JSq5ZrcakVhH0h+mxOjCpVIyH4jm5uTodJlUSzYNR4qqSSfESVV21CgWrjCk0DI8SDEcJvkwiEJREUEilLE3SMOL2Tys+U0glhKQiK7R6+qwughGRgCCSJJNx+t99Y5pnu7q6mpKSkllJRE9PD3/5l3/JRx99dMN95hFfNLl9BmgSRbFjhm1PiqL4wRf5/tcikdwCvPPDj/jFf30DgG3PbOQ//+LbJGnvzYesKIoMdg5TdaSBmmMN1J9qxe+Jr3AkZ5qizRy+Vsra+/K/0KIrURS5XNvNiX3nOP1OBdah+D1p9cblPPjSNrY/swGdaX6Wp8eHbJzYd56jr39KX0d84l24JY+dL29n61Pr7poWuhNOD6fereLwa2fobIwLGYXlK9j1zW1sfuze9uaO9Fs5vK+So29fwDaprCdplOx4spTHXixn8aqsOzzCOw9RFGms6+Wjd6s5d7qD8OSzauGSNH755ne+fOQ2HA4TCl3bOhW6urpISkqaMX/2RhBFke7ubkZHRyksLGRkZOSWj5GIa4u6IBrR1dzcjE6nY/ny5bMSgpnsATcbf1dXF2NjY6xZs4a6ujrKy8tvedwOh4O+vj4KCgpifxscHKSzs5OkpCRMJhMmkwmtVjtN9bkdchuMhHm3q40fN17AFQogl0jYkrGA6uFB3JNkujQhqUAtk7M+JZsLQwP4Jic1UXIbXf5JViaRp03mwsggiZexVB5tX7tYZ0QZkTHu98aaJQAsMRrodjkoSklnyO7CrNHSPB4vCFuu1TAQ8LJQqeOS3UlRunlaa9zSzAwmQkF83hC9difFGenUjsVVnLVpZqSClMahEcIRkVWpKbQmNEzYmJlFr83BsDtqI1hg0MeU2VydniyVhqrB+AMqVaNm1O9BK5ezWK3F4vYz6osrz3qlAi8hClPNXBmxIkZEnOH45EQrl7MszcTAmJNxjw+NXI47Et0uAGsz0hlyuhlxTsSO5wgFMCjk/H1pAaIoYjAYMJlMdHV13bT7X2trKz/60Y/Yt2/fDfeZR9xbUuVnxLXkFuD0OxX84x/9Mx6Xl8UFC3jl3f9M5pJ71/M4hYA/SPPZdio+quH8h1XT2ggr1UpKHixk464S1u8q/kLtC+FwhMZP2zj++hnOvHcB30SUcMsVMtY9spYHXtjChnlqzCCKIu1VV/j4X09z6reVsbGo9Unct2cjO1/eRl7p3VOEdrmhl0O//pST716MjVWfrOGhveU88tJWcpfPX4ONzxvBQIiKo80cfOMcjZVXYn9fXbqIXS+Us3V30T1N4j8vjFtcHPqwloMf1JKTm8I//PybX5HbKfT29iKVSsnJyZnhVddjKqnAZDKxdGl0KetWjzHT2Kqqqti4cSMQ7waWl5dHamrqTV8/k4J6I/h8PpqamjAYDLHGFefPn78tcptYCBcOh2lrayMUCrF8+XJCoVCsg5jb7UatVsfIrs/nu64obDac6OvmHxsqUcqldDjGyVMbcAYjZGq11CUQw9L0TGrHh1ibnEGv1UGuTk+DNb4UuURvpM/joCg5g9bhMdRyOWNBz7T3StMmka3S0zgyiihCskbFeAIZ3JCeydiEl2571BqwOi2Nlklyq5RK2ZSZQ/XAEBOThHuFTkPHZMOEdIWS5aY0zg0kpCdkplNrGY7FaEnCAtUjcXK6Oi2VFusYi7V6IoEIKoWCS4lKrsmAIxBgodZA08AI2XodVxNsCFk6HRl6LR2DFjzBMGaNmhFf9DMLQElmBgN2J6Ou6N9MSSrGA77YexMUaR+LP/hNSSqsAR8rU1MI+sK4fD4svrgynKZRk6xNwiBT8PNndsda3drtdvr7+9FoNDGyazAYrrMoVFVV8cYbb/CrX/3qBlfDvGLenuKCIOwG8oGYNCqK4v83X+8PM5NbgKvtA7zyzD/Q3zGIzqThO//4LR54YctdQ3I+K0RR5Ep9D+d+V8WFg7XTiq4gml+77ZmNbHlqPRmLbn2Fb67wTvg4934Vx944M60QTWNQc9+zm9j5re3klc2PP9fj8nL63Qsc+fVp2i7GydXCVdns+v0dPPD8ZnSm2VtkzxcmXF4+eefCjN7cx37vPjbtWotccXf4iG8HvZeGOfjGeU68X43HFb3X6k0aHn52PbtfLP+qOQQQCoWxWScwpxu+IrdT6O/vJxQKzSlGa3BwkO7u7mlJBVPHCIfDt9VxC6I314qKCjZs2EBHRwder/e6bmCzwel0cvXq1WkK6kywWCxcunSJlStXTvMY3y65dblcdHd3s3TpUhobG8nOziYnJ4dgMDjtBiyKIh6PZ1q7XIlEwsKFCzGZTDcsMGoeH+Xv6ypiHtZNmTkMO1x0u6LkrSR9uuq5NXMBvXYnV53R7UVmMw2TxV4SQWB9WiZtIxack0kDqUlJWCbJrVomJ9+YSpNlFH847rmdIrc5Wj1Kf4SITEqvK04eV6Wm0mYdoygtnSGbmyy9jvrRuFJbkplOr9NBhjyJNouV5XpdjOwClGSkE0Zk2DaBxe2hKDOd+oTosdLMDHyBMK3DUY/RyrQU2iY9uWq5nFJzBtX9Q/gnOxQtMhnodtqRCAJrzGZC/ggtY3EPb5Zey8CEm1WpKfi8IfzBMMMJ4zFr1ahVChQRCZdHraRrNQwnpEWsTEtBEKFjOEp4EzNwF5uMpCpV1PQPsyTFxP5vfX3a91lVVUVxcXGM7Nrt9piyazQaMRgMnD9/nuPHj/PjH/94xmtiCj6fj23btuH3+wmFQjzzzDP89V//Nd3d3bEOZSUlJbz22msoFAr8fj8vv/wyNTU1pKSksH///rn85ueFvQmC8CqgBnYAvwSeAS6KovgHs77wc8aNyC3AhMPDD37vp1R8VAPA5ifX8R9/+u/mLWprPmHpH+fCoTouHKql7kTTtKK0FaVL2PL0BjY/sY7cvC9uiXh80MbJt8/zyb5zdNb1xP6+cFU2D35jKw+8sIXUeero1dPaz5HffMqJfecSWujK2frkOh79vfso3JJ3V0x0RFHkUl0Ph359htMfVMXUXGOajp0vbuHRl7aSsfDmYtHdCu+En1Mf1nLwjfNcaYkKJIIgsG7HKnZ/o5zSbSu/9M0hvpQFZZFIZEYv6FySBoLBIK2trQiCwOrVq6/Lfh0cHMTv999WtNUUzpw5g0wmIysriwULFtzSzWKKZK5Zs2bG7ZFIhMuXL+NyuSgsLESpnO6ful1yO9WoIhKJxDJ955Jza7VaGRoaQqfTYbPZ8Pv96PX6mLI7FvDzo7qLVI8NYPF5yFRrSVNoCITDtCckCRSnp1M3NswinQE1CtQyBdWjcdVzityuNqXi8YSQCxI6nfGc2zR1Etag7dK/xgAAIABJREFUl6KUDLrHHDj8PiLS6ZftQpOeFLmaxsERIiLkmnRcTSC3m7NzGbC76J1UctdkptMwSW41cjnr0jO50NePfzLypSQ7g+qRKHldotGiCQu0uOLksijTTL1lhOSkJBZpDIhhkfrRuPq82pzKJfs4a9LMdI/YSddqpkV/LUsxopDJcE/46be5WJRspMsZ9/QVpKcRDkXoGImexxyjnr7Jz5Ol15Gr1XHxatwDnG3Q0e92YVYnYZLK8YZE+l1xj2+uUU9IEElRJtHSP8rCFAM9dgerM9L49YtPTDuXVVVV1zULCYfDOBwObDYbv/71rzlw4ADJycl873vfY9u2bSQnz/wAF0WRiYkJtFotwWCQLVu28OMf/5gf/vCHPP300+zdu5dvf/vbFBUV8Z3vfIef/exnNDY28uqrr/LWW2/x/vvvs3///hmPnYD5IreNoiiuSfivFnhPFMV5DZqdjdxC9Jx//C8n+b//5TU8Li+GVB3fffUP2fzEuhu+5l6Hd8JH1eF6zrxXSeXBumk+3QWrsin/Whmbn1jPii8wM7a7uY9jr33KsdfP4LBEf6uCIFD8QAEPvrCFzU+tm5f83GAgROWhOg796iR1J1tihU9ZS9PZ+dI2HvrGVlIy746mBBNOD5/89iIH/+UUPW3R+5kgCJTsWM2ub25j484192wXNFEU6ai/yoHXznH6YF2sOURGbjKPvrCJh/dswPgZWtjey/iK3CbgZq1vrVYrbW1tLFmy5Iae2pGREVwu15yX2RMx1fShvb2dTZs2zRpwfyNMTExw+fJl1q5de902j8dDY2Mj6enpLFq0aMYb8O2Q23A4TFNTE3a7nS1btsQI/xS5BW54s7fZbIyNjcXSHSKRCC6Xi6ujI7zW2cax8RFCokiuXkOaUkvTqIVQRCQvLZn2BP/ppsxsfMEQjcNRC0FJZuY0crs+Iwu3PxDLYF1qNE4jt2XmDIZcEwxOkkupAKFJcquWyVhtSuOq1c5YwrJ7jlFLn9vFQr0BDXIiQMd4fEyFGWbaxsdYk2qma9TOkhQjdcNxJbYkO4MxnxcNctpHxinJyaBmKKFJhF4DIlx1eAiERQoz02iwRG0PAlCem0PXmC3mcV2VnkrreFSZXWoyYVYlcSGBnC5NNXHZbiMtSUWaIolAOEKXPR58vzDZgCsYYIFOT1PfCLkmAz2O+Pblaclo5XKa+0cIR2BRiiFmyUjTqFmRYqKyeyCWnLDUbKJz3Mbmxbn86Omd0773mcjttXjttdeoqakhKyuLS5cuzYWA4vF42LJlCz//+c/ZvXs3w8PDyGQyKioqeOWVVzhy5Ag7d+7klVdeYdOmTYRCITIyMrBYLDcjJPNFbi+IorhBEIRK4GlgHGgWRfHW408+A25Gbqcw0mvhH/79q9SfbAGixWZ/+L+/gXnBvauKzQU+j5/qIw2c++AiFw7V4bbHVzSylqZz33PlbN9TzuKCLybkIhQMUXWkgWOvneHCwVqCgegKlFqXxPZnN/LIt+5j5fpl86KiDvdYOPKb0xz5zRnGh6L3VIlUwqbdxez6/R2UPFBwVzQlEEWR1otXOPTrT/n0d9UE/ZOrdplGHnlpK4++dPcQ8tuBfdzNsXcucvCN84xMtjKWKaRs313MYy9tJm/trQll9zo+L3J775pYEiCVSmdMUZhSO51OJ6WlpbNmc97oGDdDIBCgubkZlUqFRqO5LWILIJFIiCSE8k9haGiIrq4u8vPzZ215eqtwu900NTVhNpuJRCLTlGxBEBAEgdkmPtduD4siBwau8vOmGhwBP0qplAJ9MsMuF3UJDQ7Ck0vvaqmUfJOZoC9Cw+jodcc3J6nJTtIR8oWn+UWnfuLLjckQEum3umL+06lxyQQoSs2g1+Kg7uoIOvV0T6heoaQ4WUPDwAggsNxsmnZ8k1JJmlRN/dXpbUIBUpRKtBIFdSPDXMubFFIphWlpyEWBi/1xgu6ZiD5AF6rVhEMi7gl/jNgCSATI0etIlqtoGbSgMk9XI5RSKSXp6TT1jWAVfSxPiyuhepWSXK2eqqsDNNii45VNPpB0SgUrUpLxeoM0DMU/i0wqxaBSstRkoqVvlDG5N0ZsITopWJuejvSaeWQkEpnTTTYUCrFmzRr+7M/+7Kb7hsNhSktL6ezs5E/+5E9YunQpRqMxdj3m5OQwMOlvHhgYIDc3SjpkMhkGgyHWuvouwAFBEIzA/wFqiQoDv7yzQ7ox0hem8b8+/j6/+8nH/L+/2s+nv63kwqE6vvHfnuaZP3/snlXEbgaVWsmWp9az5an1hIIhGj9t4/zvqjj7QRWDV0Z48+/e582/e5+Fq3P4/9l78/C26jvt+6PVWixZ++J9S7zFzr6RPSEJIRs7hZamQIFpS0u3mWk7z/R5+7yzlM7MO50pT1coYSktlLIEkkBIQshCyObYzmI7sR3vtmzLsiTbWizpvH9IluTsBDuEofd15So9ks7vnGPpnPv3/d3f+1581zwW3zmPnNJr68O4GKQyadTRYd1MPP2D7H31I957YS+1hxrY/sz7bH/mfXJKMli1aQnL71swoY1wtlwzm358F1/60e0c23mSd57bw8Gtxzmw5RgHthzDmmNizYNLWfWlRdfFT/hSEIlElM0tpGxuIY/90z3sfPkg257bS3uDgxd/9hYv/cdW5q+ZytoHlzBtUfENQcg/DnTGVO7+m+Xc8chSju2tY+uLH3Lk/Vp2vX6UXa8fZVJ5Jmu/tIAl66ejUN4YscufBXymvgWXerBejJgODg5y6NAh5HI5s2bNuiyxvdQ+rgSn08mRI0fIzMyktLT0E82uzie34XCYkydP4nA4mDNnzrgS287OTmpqaigrKyM9Pf2ajnv0M4IgsLWpgfWvv8K/H/0I70iQ6SYbOpGCGocTQTJ2/iREwkxOUSP2izjW7mDkPA21VCRilsmOxxOgJmZ1lQyFREqBXE2jw0WjM6pLjR8TUGY0Y5OmUtXqwOWLVmtHr6o2JYUiVSpud4DqjsS+R0l6qdFErlKHyxPAkRSIIAgCOoWCqUYzHk+QIf/ImOMSIWKa1YpBnEJVS3fcr3YUZr2eIq2edtcwXV5fnOwCmFQK9HIl3X1eTnVGq7uj92ZNipyZdhvSsIjqVkecgIrFIpQyKTPT7Qi+MH3uYYKhxHdHJhEzM92GKCBQdS5RUQZQSiXY1GpCvjBVzd2MhCNIYgPqlQpmpNsQj4g40eJAfh7BCYfDV+WhPDQ0dNWTPIlEQlVVFe3t7Rw+fJja2toL3pP8XbvUazcAfiYIwoAgCH8BcoBi4J8+5WO6LMRiMbd/61aeOfkfLLl7HoHhAM/86I9886b/xZljTZ/24U04pDIpM1aU8/h/P8Qfzv1fntzxv1jz0HI0hlRaTrfzwv95lUemfp+Hy7/L5v/9Mq21HVfe6ceA1pDKukdv5r/2/R9+V/Uz7vruWnQWLS21HfzuBy/xxbzH+YcNT7L31Y/iFd6JgEQqYc4tU/nxH5/gxfqfs+l/34U124SjpY/N/8+rfKnoO/zvu/+Tj7Yfj1s2fVrQGlK542sr+d3B/8NPX/suCzfMQCSCA28f50d3/pyvzv0xf/7Fu3j6B6+8sxsMEomYOctK+ckzX+X3H/yIux5bhlav5uyJdn7+9y/zwPyf8Lt/epPO5t4r7+yv+J9TuR1tNBMEgdbWVjo7OykrK0OrvbpIwktVTi+Gj1MRvlqIxeL4w9vr9XLy5EkyMzPJzMwctwf4qBtCOBxmzpw5SKVS/H7/VZ/3+TjpcvGPb79ObWxJvcxgYjA4QnVnohIrSvrfqSYrQkSgJsl2a1RmIheJmaxJI+wLczypkjtKZ0xKJdkqLcPDQc55k90RoiMUG4yEAhHOdjrxM/Z8UiQSiq12znQ5aQgOYUkb2yFsUCgp1oqpb49WiEvtiUqgWiZDJ0shNBTm5EDfmHMCmGIxkxIRc7w1UakdfT0zTYNeqmDEH6ahNyGl0Gg06EJhstRqznT30x1xjrEyE4tEzEy3cbbTSVVzN6XpibQ8mViMWamkxzlIVVN0TIkkOqJcImGK1YwoLHA8idSKRSIUUikFaRpa+7y4PX58SQ9LeYwM17b3Uj3QzZTMaDe54ryUo0gkclVVkaGhocvG814MOp2OpUuX8tFHHzEwMEAoFEIqldLe3k56erTpJzMzk7a2NjIzM+MODpfS834KOAjMABAEIQAERCJR5ei2GxmWLBP/8NK3Wf1gNf/1td/RcPwcj8/7ESvuX8jD/3L/dWt6+jQhkYiZvmwK05dN4ZtPPcTx3SfZ++eP+PCto7TVdcYrupNn5nPzlxaz5J7549qIl1OayaM//SIP/b/3cnh7FTue38uhbcc58k41R96pJs2kYeUDi7nlwaVkF2eM27jnw2jXcf/fbeDe762jctdJtm/ew0dbj/PRtug/S5aRNQ8t45YvL8Zg+/SkACKRiGmLi5m2uBhn9wDvvLif7c/vo/NcD8/85C88/9M3WXL7bNY/tIyiGbmf2nFeK2xZRh7+wXq+9O3V7N1azdvP7+dMTRuvPfMBrz3zAbOWFrP+ywuZteSzV6m+XvgfQW6lUinhcDgepKBSqZgzZ87HSuq62srt0NAQJ06cwGq1MmvWrAuIpyAI11wJDYfDtLW10dbWRnl5+TVLHC6GURnC+YT5Wo61tq+Pfz/4Ia2eARwjfgrS9MgEMXUOJ5HzfmciEZQaTPiHQ5xo76HIOtbyRKVUMl2hpK3Pw+keN8W68845EmGW2capjl6q+3soNI5dHjMoFOjlCuo7o8RUIZXEGbFULKbCYqHD5eF4S4LsjRLJDK0Go0xB/4Avnh4G0UqvXCKh3GKmqduFezCAbyRBBgUEikxGwsEwtW29TM8e68Uok0iYZrFyst1Bl+BlWtLrKpkUnTyF0HCY0+6ovkqr1cDQMDKxmAJtKiPuIU67EwReLAKJWEShVoPTG8TjDeL2JZpiJCIR09KtdPV6qG7qpiwzQYblEglGpRJHZJC6jpiuThz9m6tTZBSbjBCG421jybBFoyZdO/ZvcbWV2+Hh4auKf+7t7UUmk6HT6fD5fOzcuZO///u/Z9myZbz66qt84Qtf4LnnnmPjxmhT24YNG3juueeYP38+r776KsuXL//UK7cikcgGZABKkUg0ncTcRkvUPeEzg1krp/Kb4//Gi//0F9586h12vbSfA28e4f4f3cEdT9z6ufHklMqkzF49jdmrp/FETLqw5+UP2fuXjzhzrIkzx5r49fefZ/ryKSy95yYW3DabVN34WGpJZVJu2jCLmzbMwt3nYfefPuTdZ/fQdKKVV/9zK6/+51bKbprM6q8sZfGdc1FpJibdWSIRM3tVBbNXVeByuHnvD/vZ9vv36TrXw3M/eZUX//l15q+bwa0PLmX68rJPlWAZbTq++P11fOHbaziy8yRvP7uHo7tOsfNPB9n5p4NMmpbDugeXsOQGCrK4WqQo5Ky8czYr75zNmZo23n7xAHverOTonjqO7qnDnmNk7RcXsOru2WjG6Tv4PwWfqYYyiCaBnY+RkREOHTqESCRi8uTJmM3mi3zy8vD5fNTW1jJjxsULLYIg0NnZSUtLC2VlZaSlXThrH7UCu5YfeiAQYP/+/VitVkpKSj4WMYdoQ9n8+fMv+rDv7Oykubk57oaQjGAwSHV19QVNQsFg8AKi3u7x8N9Hj7DjXBMCkKtWoVGqOelIVGKFpMMu0OnQSOXUdCUqsUVWI7Wx5q0KkwWVWMrhjkTVc0aGjWPdXSgkEiZp0ogEQtR6Ep39BYY0znoGSE9NxZyiwukZpnM4scyvkkrxEabCYqbHNYTDO4Q8RRK32QIoNBtQS6MNVhGBqDuAK9pgJRGLuCknk7quPpxDUW/cKekWTnRHzyFDrSLHqOfguSSf2ywblZ3dGFRKcrRaJIKYyiTN7bRsG6d7+sjXqGnvH2KS1cTxjqTQh2wrggBdfR76vD6mZlup6ohqZEVAiUFDtzeAyxdt8ivPtFDT1YNYJGKK3YJKIuHQuUQDWnmWhdOOPsrtZjp6PKTrNbEY3iim5tgQiaCh3cmQf4SpuTaq2qPHY0pVUWozcfBsG3fPKeObt8yLf87r9dLe3n7FoJHvf//73HfffSxduvSy76upqWHTpk2Ew2EikQj33HMPP/7xj2lqaopbgU2fPp0XX3yRlJQU/H4/DzzwAMePH8dgMPCnP/3pauKfJzqhbBPwFWAWkNzJ5QGeEwThtYkc/3xcbUPZldB1roff/t0LHHjjCADphTa++i/3s+C2ywd4/E9GwBfk4FtH2fWHfRzdURPvH5DJpcy6ZRqrvryEOWumj7sfqyAI1B9tZNvTu9nzysG4PZZCncLiO+ey9pEV16UJLRKJULnrJG8/vZtD26uIxCQKtlwztz64lNWblqAzX91K6USj81wPWzfvZcdLB/C6os8HtVbJzV+Yz7oHl36mwyE8riHeffkQb794gJ5YwUKeImXJhhls2LSQwrLx04h/GvhcuiXAheQ2FApRV1dHd3c3ixcvvmpf2fNxKZIHCRsxsVhMSUnJBTZiozh06BAzZ8685OuXwsDAAKdOnbrmCF2Ajz76iNmzZ48hxckyhLKysose19WQ277hYX5zrJJ6p5NqZw8mpYp0hQrHgJee0Ni/hyCBTI0Gg1TBqa4+bGlqugYT+qdiq4mRUIjA0Aid3mGmZlo53p2U/pVhIyIItPa6cQ37mZpuocqRIGZ5qSqIRGj1+okIYNeq6UzSsFZYzbiHA7S5ElZfMrmEYDiMXqnAJJYwMBKmbzjhnpBtSKN1wE25zYJzYAiNSsGZ3kQTW5ndjNsfIFUs4Uy3i/JsK9WdiWOenZNOKBShtr2HYCjC9BwblTGyKJdImJebwYm2HgZiY46+HienYgmHm5Mih7OtVHc4KLNbGHD7MGlUsea32DXQKUEsxueP0OPxUZFEhiViEfMLMjnb4aTXE63+Ts2JktcUiZjJFj0KqZyj55LId56NVpeb7LQ0Trc4KMu2UtXazabF03h0ReIe43a7cTgcl3QlGcXXv/51nnjiCWbN+sT3p/HA9XJLuDOmt/1UMV7kdhTHdtbwq+8+F9ebTpqRz4P/dC+zVk4dtzE+i/D0D7L/tUO8//KH1HxwOi4pSzNpWPaFBax8YAmF0y/ubPNJ4Bv0s++1Q7yz+QNO7q+Lb8+vyOHWh5ex/L4F41ZFvhz6OvvZ8cI+3tn8AY7WqFxLJpey+I45rP3qckrnTbohJkEBX5B9W47x9rMfUHc0oSOfsayU9Q8tZc6qis+sr2w4HOHI7tO8/eIBju1NpH+Xzsxl/aZFLFhd/pkMvvjckttR0gXRh+2pU6fIzs6mpaWFBQsWXPN+Q6EQx44dY+7cuWO2u1wuTp8+fVkbsVEcPXr0oh60l4IgCDQ3N+NwOKioqKCqquqavGrhQmJ9KRnC+QiFQlRWVo6JDYbodfb4/WyuPsFLJ0/iD4Wi+lKJlJNdPQTDEQwpcpzhBLm1qFRkpGo40dkTb36y69Rxm658vQ5TioqjbUnEKtNKZbcjHligFEk51Jaoio6S2zRFCoU6PT5fkFpnwhPWqJDTNxIkN1WNKCKmf8iPNzy2zT9NraBAr6O2oxf/SBi9RkF/Ermdm5NBV7+X9v4oIS60GTjbFx3DrkklT6/jUFN7XM5Qnm2hurMHtTy6rC+KQGXSsv70HBs1nT1MsVno6HWTbdJRmXTO03NsjIQjDLh9dLq8TMu1jZEF3FSQRbvTTVtf9Him5dg43t6NCCi2GtEpFBxqTFyjPIOKc55hJpt0DAwGses1VCc5PUzPtSEATe19DAZCTM2zxWUahlQlZelmDp9tZyTWlDYt387xli6+sWoO9y9I+C739/fT399/Rbu8TZs28c///M9XHSU9wbhe5NYG/DOQLgjCGpFIVArMFwThusa0jTe5hag36vand/HSv75Of3dUvjNr9VQe+9kD4+ok8FmFs8vF7j/uZ8dzH9ByOpGulVOayfL7FrD03gXY88Y/Fa3jbBfbnnmfHc9/EA9mSFHKWXTnXG55cCnlC4snnGCGwxEqd56IV3NHn825pZnc+vAybr5vAeq0G0Od01DTytu/38P7fzlEwBd9RlgyDdy6aTGrv7gQveXGqDpfCzrO9fL2iwfY8efD8QQ0vVnDrffPZ8198zFaPztBLZ9rchuJRGhqaqKvr48pU6agVquvOcRgFKMJY6P7EASBxsZGnE4n5eXlqFRX/oFWVlZSUlKCUnllHVQgEODEiRNoNBomTZr0iSJ0Ieo/OnXqVORyeVyGcDW63YuRet/ICJuPHudYVxcfdrRH/WJNZkLBcNyvFcCQIsMZDqJXKMjX6jjZ3kNEHLUFG4Vdl4pEJEIvTeFUZx/FNiO1SVXRaZk2RiJh3N4AHQOeqGdsZ9KSfYYVCWLqu3oZDoaYZNZT359oziq3mhkJhTnjiJJRlUTMUKyhTCGVUGoycba3n8FAgvDqUhW4fH6KzUZC/jCBSJiOgSTpg1WPJxAgXa3hVJuDyXYTtd2JhLCpOTbEAjR09jPoD46REUhEIm4qyOJMp5OemN3X9FxbnPwWWwzolcox5HSU3JbYTPh9IfRqBcdbu8e8HgyF6e/30uP1R98fe10iEjGvMJPG7n4cMc/OfKOKRtcwKVIxRVYjComMo0myhWl5dlqcA2Tr06ht6aEsx8Lx5sR484uycLqHuXX6JO5akEjM6+3tZXBw8IpBJ3fddRfPPPPMNUdZjzOuF7ndDjwL/IMgCFNFIpEUOC4IQvn1GH8UE0FuR+EfDrDll+/y0r++zrDHh1giZuWXFnP/j27Hnm+dkDE/SxAEgbOV53jvhb28/6cDeJyJe8qUhcXc+vByFt05j5RxtnMKBkY48MYR3nn2fY7vPhXfnjnJzrrHbmblA4vQ6Cc+EKC7pZftz+7hnc0fMBALqkhRyVl+701seOxm8suzJ/wYrgZe1xDv/uEAWzfvoas5el+XyiQs2jiLjY8so3jmFaVONyx8QwF2v3GMLc/to/Vs7JkkFbPglgo2bFpE6czxX00Yb3xuye3AwAA1NTUYDAYKCgri+tZPSm6T9+Hz+Thx4gQGg4H8/Pyr1tBWVVUxadKkK3aKO51O6urqLtAHf5JzOHr0KKWlpTQ1NV1WhnA+IpEIhw8fZt68eQTDYf584hS/PVxJ3/AwM9NtCCI41+PC7Q9QZEnoZQEsihSyDHpqu6IVUQCJTEwo5r5gS00lW6vhWGtXvOpZbDNR2xu9oZSYTaTJUzjUmiB6o+RWKZVSajYhFkQcS9KvjpLbHF0aGokMry9ImychQdCkyAkQpkivo9nhZigYInLeZSjPsOD3hWiMEWK7QUOnO/ogMqqVTDYbOXaug1A4etBF6SbqHH3IJWIKdFpkUjknkjSs5dlWTnb2MMVuxukawqLTUJVcyc21ERgJ43J5cXj8TMuzjSGvN03KosvppbknWhVLfr3UbkKnUPBRQ6IiNC3XRk2bg9IMM/2uYSz6VKqSGuZm5NkZCYVo6Rpg0D9CvilKdiEaRVySYeHImUSldmqBjarmbibZDIhCoFbIqG528Ld3LGT9nOL4fru7uwkGg2RnX/4htWbNGt5+++1xta/7BLhe5PaIIAizRSLRcUEQpse2VQmCcGEqywSiZFKp8M31f88931s/YS4Hrh43L/zkz2x7ZjeRcASJVMLKB6Ik15Y7/hXKzyJGgiEqd9aw+48H+HDL0XgqWqpOzfL7orKFiUhE62x08O7mPex4YS/OzpgeUyFjyd3zWfvIckrmTrxcYCQY4uDblWx9ejdVH5yOby+7aTLrvrqchbfNviGaEyORCJV7atn67B4OvVtDJLbcOHl6LusfXsqS22YjV3z6x3ktEASBE4caeev5A3y440RcH104JZMNmxayZP30G+JvcDF8bsntsWPHyMjIQK8f2zU/XuQ2Pz+fxsZGSktLLxjjSqipqSEvL++S1dJIJEJDQwNut5vy8vILLMQ+yTkcOnSIUChEdnb2x7IPi0QiHPzoI3o0enY2NbHnXEvcZSBFJOZQe6LiN9lsoK6/H6VMSrFOT7fTjSOWZDYKqUyMTqEgK1XDiQ4HNq2GjqSGsGKbieDICCH/CG3uYaZlWTmeFDAwM8tOJCLQ4nAx4AtQkWkdE0AwxWZmeGiYc7EmgUy9Nk5u5RIJU+3RVDFXrBkMiJPbTI0K/CFcwTC+pAYzqz6VQChEnk7H6bYe0g1amp0J94SSDBMpEinNXf24fUFKs8wJT1qRiJsKMznX7aLLFZVfVORaqWqLHnOp3YRWLudwY1LlNFapLbaZGPGHSFONrdROz7PjHwkxPBykrcfNtIKEjEAsEnHT5EwaO110x8YblREoZFJK7CZkIjFHk8abmm+j3elGKxHR1jdMjklNozOhU76pJIse5xBNnVGyPyXfyokWB//r3qWsmp6QIHR0dCAIwhUrskuWLOHQoUPIZDfEzfN6kds9wJ3Ae4IgzBCJRPOAJwVBuDYR/TXCkpouTAsuRSaXsmrTEu792w3Ycj9+g+3VoKOhm5f+5TV2/WEfkYiAVCZh3WMrue+Ht4+rTdZnHcNeH3te/pDtz+ym/mhjfHt2SQYrH1jMzV9chDF9fCci4VCYg29X8vZvd1K580R8e96ULG55aBk3f3HhdanmttZ38vbvdvHei/viy+VpJg2rv7yYtQ8vn7Dv5seFo83J1mc/YPsL++INaFqDmtVfXMjaryzBlnNDBMVcE3o7XWz9w0G2//EgntFz06tZfe9c1n7xJqyZN5bV3+eW3I6MjFzUl/VybgFXg1AoxAcffIDRaKSsrOyaHsynTp0iIyPjohUrn89HTU0NJpOJ/PyLz9ivldx2dHRQW1tLRUUFFsvVV04igsD2urP85+59OPwBZmbbCUcEuvsHcXgHmZphpSqp2Wuy2YBaLqdncUAsAAAgAElEQVTJ4cLjD6CVS3GHExZZBqWCfIOeE+0ORmIzxQy9hvZYVbTAoMekUo5pnpqWbeN4ZzcysZhyqwW5SMzhlsTrFRlWqrsdpGtTMStUBAIj1DsTsoQsvYauoSGmWC109LgJRwRcgYSeViSCHIsOBVLqO6IVY5VSxlAwKlNQyyRka1U09Q0yEqvUZpvTaOl3I5dKKLOZCQRD1HYmZAnFmSbqu52U2c0MuH3oU5WcTK7k5loZCYUJDIdo6RmgIs9GVXKldnIW3U4vzY4ogZ6aHyWvIqA0w4xGJuNwQ9I1KohWanO0SnxBMXZD6hgZwYyC6ITgXIcL73AgXokFsKalUmgzcLiujXDs/KbkW6lpcZBv0uIfDqKQiWl2JqzHphbaIAJfWDyFm8py49vb2tqQSqVX1J4vXLiQqqqqG2X563qR2xnAL4ApwEnADNwlCELN9Rh/FOVlFcK9FQ+z77XDCIKAWCJmyV3zuPu76yicnjshY3ac7eLFf/oLu/94AEEQSFHKWfPwcu7+3nrMmcYr7+BzhMbqFnY8v4fdfzyAO7Z0L5aImb9+JmsfvZkZK8rH3Vars9HB9md2885zH8THTFHKWX7/AjY8tpKCabnjOt7F4Bv08/4rB9nym52cO9kGRG0o566Zxoa/WcmM5WU3xP0i4AvywetHeOuZPZytbgGixznvlgo2PrKCqYuKbojjvBYEAyN88NZxtjy3n4aT0ZVAsVjE/FVT2PiVxUyZM/4rCdeCv5Lb83CtTgWQaEwLBoMsWbLkmv/AtbW1WK3WC4zlHQ4HDQ0NV6wGf1xyGw6HOX062qkbCoUoKiq6KvN8QRDYdbaJ10/WsfdcCyKgwm5FLZFxsCWx/D1KbuUSCVMsZiLBCNVJzgUamRRPJIROkUKBTs/p9h6QisbYbmXotcjEYlRiKXWdfRSnmzjtSBDFGdk2woJAV5+XPu/wGKcBgJnZNkIjEU61RZvUJlkN1McayqRiMTMzbZzrHaAv5gygVyvp90ertnlGHWqJLF5lHYVCISVFKiXfoKOutZdUtZy+wUSl15amRK9U4HD5GBjyk2fX09gTJdQiEcwvzKLVMUBnf5S0l2abOdURHaMk3USqVM6xpiRrrjwr1a0OcnRqxIIUXaqC6pbEpKEi30YoFGHQ66e910NFvi0uM5BJxMyZnElDu5PemKa2IkZeUxVyJlkNiAURx5sS0o2KAhu9niFMKhWnzzmYkmelpjk6nlgkYm5JFu0ON+2OqP1ZaZ6ZU629aJUyLOoUAoEROlx+fnjPPJbOLIo7kDQ3N6NSqS47gRIEgUWLFn3uyC1ATGdbFBuzXhCEkSt8ZNwxqrltre3gj0++yfsvfxhfkpy5spz7/v42yhdNTKNRU00Lz/74ZQ5trQSi3fOrH1zGF/5uI5bsz27layIQGglx5N1q3nv+Aw6+dSxuK2bNNXPLg8tY9eUl4z4xGAmGOLjlKFuf2c3xXSfj20vnTWLdozez6M65464HPh+CIHD6UANbf7eLva8djievZU62s/6RFaz84sIbogFNEATqK8/x1jN72PvG0fhxZhfZ2fDwMlbcMw9l6icPb/o0IAgCdVUtbHluP/u2VhGOydPyS9LZsGkhSzfOIEXx6cX8/pXcnodjx45RVlb2sdLCkt0KysvLqa6u/kTV3/r6eoxGYzzrPhwOU19fTyAQoKys7Io2ZR+H3I66IWRlZZGRkUFNTQ35+flXbCDb09DMrw4codbRy5QMCyLA0TdA73CQmTnpHE2SIUxNtyASiWh3enAO+igw6WlwJaqmxhQ5OSYDdR0Jza1CKY0HHuTo0zArlVQm6UFHya1EJKLcbkGOmKOtY50EKtu7sWrU2NWpiCKMscGaZNXT0D9Aud1Cd58XhUxG64A7/rpBrUCjVqAWS6lr70MmERNISixTyyQUp5s53dJLIHbMBp0S56APuVRCqc2EZ8hPc29in3a9ki6vn0lGLW5vkDSNirPdCe1xSZYZETA0FJURlOVYONkenQSIRDB/chbtvR7aeqL7LM+zUtMadYgozTSjkEiobEhcg/J8G7UdvZRmmOnsdpNh0VLdnLgGMyalEw5HaGjpYzgQorzARk2sUpttTiNDp+FQXXv811uWb6G2rZdsnZJgUIReq+JUa4Lwz5hsJxSKUN/cw8hIhMJMI2c7nfzgzplY1CJCoRBarZZAIIDVasVqvXTz0Ci5ra6uvuR7rjOuJ7m9CcglKRxHEITnr9f4cGFDWU9rH68/9Q7bnt6NbzC6olE6fzL3fn89c9dOnxDz/aaaFv7409fZ++ohBCEqV7j1qyu4+3vrsebcGMvQNxKcXS62/3437z77Po6W6MRfLBYxY2UFax5azk0bZiGRfjzf8yuhrb6Tt3+7kx3P72UoFhij0au5+YHFbHjsZjImXX51Zjww0ONh27Pvs/Xp3fTF9MEpKjkrvrCADY/dTN6UrAk/hquBq8fDtuf3svXZD+iPFQRUGgUr77uJDQ8vI6Pgs9tM6XS42fqHD9n20kHczqjMTaNTsfreuax/YCGWjI8nzRwPfG7JbSgUumiS2NU2c43iYm4FnySEAeDs2bOkpaVhsVji5DMjI4OsrKyrIswHDx5k3rx5V3xvR0cHLS0tY9wQTpw4QU5OziXjhg80tvLCsWo+bI4uCZXbLCgkkjHEcpTcSsVipljNyBFzJMnCKs+ko8k1gCZFTqFOR5vDRf/I2OKUQinFkqpGK5Fzur2XTJN2jOdsaYYZIhG6+7y4hoNMzbVS1Z4gbnPy0gkEQ5xq7SESgYqY5ytEK7Uzsqw0dDrjgQY5pkQAQ55JhyElheNJVVG5RIyfCHqVgjyDjtrmbgSJhGBSddliUJOepqG1a4CBIT82YypdA9EfukQsYnqOlZbuAfpimrFMo5q2gaEoOc0wI0UcJ5cAJTlm6jr6KM0w4/H4SVMrONmWJFvIs4IAzv4huvsH4xpXAKVcyvSCdGrP9TAQIyNTCqKva1KkFNhMEBbGkN2yfCu+wAhyRJxp6aM0z8qp1uh4cqmEWUUZnG3pxTkQfYhNzjFT195HhkmLQaUgEBihoTNhr1aYaUSZIuPx2+czKctEOBzG4/HQ2NhIJBJBJBKRlpaGXq9Hp9ONkfB8XsmtSCR6ASgAqoDRL5cgCMK3rsf4o7iUW4Knf5Atv9zB60+9g7c/+t3OnGTn9m/dwsoHFk9IclPL6XZe+tfX2PPywYRE4u553PP9jRRMzRn38T7riIYknGD7M7s5uOUoodjk25Rp4NavrmDNQ8sx2seXbPiG/Lz/pw/Z+rtdnK08F98++5apbPz6amatqpjw9LFwKMzBrZVs+fVOqvfWxrdXLC7htq+tZN6t08ed3F8LRoIhPtx6nC3PvM+pjxqAqGRh9s1T2PjocmYsLb1RVqs+NoKBEfZtrWbLc/s4UxPlCGKJmJtWlbPxwUWUzcq7buf2V3J7Hq5E7pLR09PD2bNnKSoqildZAQ4fPsz06dOvuRGmqakJhUJBJBKhtbX1oolgl8PFghiSkSxDKC0tHSPBOHnyJFlZWRckp33Y1Mqv9x+husNBljENrSKF4eEgzX0DlGdZqUkKI5iVk04oHKHL6aHXO0xFppWqpGauApMObUoKZzqd+IIhVFIxQ0KiKpqtT0OnTOFka4LIZZm0tLo8SMTRSi1hgeokojdKbm3aVGwqNVKRiMokfWp5tpXa7l7K7BY6ez0Y1CnU9ySqxzkmHWKJCIVITH27E5NGRe9wQj9q1aqw67TUtvbE3QHE0qijg1IupdhmwuHy0j2QaLCyGFLpHxymNN1MT98gMrmUNmeikptrS0MGuAZ89A8GyTKrae2Pfl4iFjFnUiYtXS66YySiJNfMqbZepGIRpZkWxALUnEtc19I8Cy09A0yyGWhqdZJj13OiJXGNZhVnEAyMcLqph0hEoDTPGr/GRRkmNClyKs8kHCeKc8209rqZZDfS0u7CZkylvj0hBZlZnMHgUJAzLb0gQG6GnnPdLlKVcgrtBtxePy2dAzzzj3eRk/QwraurIz09HbVajdvtxuVyMTAwgCAIpKWloVQqkUgk3H///VzJjqqtrY0vf/nLdHd3IxaLefTRR3niiSfo7+/n3nvvpbm5mdzcXF555RX0ej2CIPDEE0+wbds2VCoVmzdvvmSa4Hm4XuS2FigVrnBDnWhcyQrMN+hn69O7eOOpd+mJme+nmTTc9vgtbPjayglpMjp3so2Xf/Yme15JSCTmrp3B/T+4nZJ5k8Z9vP8J8Di97HppP2/95j3a66OraRKphJs2zuLWr65g+vIp4046z1Q28davd/L+nw4Q9EeLFumFVtZ+dQWrNy1Baxy/OPhLobWug7d+t4sdL+yLJ7FZsoyse2QFt2xaQppp4o/hatB4oo03n97N+68eYiQQk1YUWtnw1WXcfO9NqDSfTckCQO3xZrZs3se+bdVxyULhlEw2fGURS9ZNm3CXhb+S2/Nw+vRp7Hb7ZTWtozIBn89HeXn5BTKBa5E2JKOxsZHe3l7UavVlk8wuhcuR6/NlCOfPos4//w8bW/nth8c4HrPRmmKzIIExMawV2TaqO7qRiERU2K0oxGIOJTV7lWdaqO7qQatIYbLRwOBwgDM9iQqfUipmWIiQrdeikcqpa+9DpZIxlOQpm2uJEuIe5yA97iGKM02c7koQrbkFGfgCI5xuiWpqk22w5BIJs/MzONPRS58nqomdbDdQHzuGQosBg1IxxhnArFXRMzSMWaMiI01LS2c/7vMcHdQqOYUWA+c6+vH6gqjVcgb90ffIpRKm5tpo7uzHGRsz3aKl3elBKhZRaNEhIkqk4+doS6PN6SFHp8LlDpKWmkKLM5HKVpZnRSISca61l0F/mOJcM7VtUVmAPlVBSZaZ6jOd+GI3yeJcC6fbeskyp5GmkENE4HSSjKAkzwKIGPL6ae92MznXTF1sf7rY/k6c6WI4tr+CLCONXU4y9EpSpAoEAc51JyYIxflm5CIxDc19+AMhLKZUHP1D/OH//QLWpAfaqVOnyM3NvWB1JBQK4Xa7OXz4MD/5yU/o7e3lwQcfZNmyZSxbtuyioSZdXV10dXUxY8YMvF4vM2fO5I033mDz5s0YDAZ+8IMf8NOf/hSXy8WTTz7Jtm3b+MUvfsG2bds4dOgQTzzxBIcOHbpgvxfB9SK3fwa+JQhC1xXfPIG4Wp/bcCjM/teP8Of/723OHIsmNylTFdzy0DJu+/qqCfGt7Wnt4y8/38q2p3cRiK28TF9Rzl3fWcvMlRNfIfwsQhAEqt4/yVu/fo8PtxyNTw6suWbWPXozax5egdYwvhMSj9PL9t+/z5Zfv0dvW/Q+J0uRsfSe+dz++C0T1piYjCH3MDte3Mebv36PrqaexDHcNZfbvr6KwuvQBHc1GOjzsj0mWejrijYIq1IVrPriAjZ8dRnpExDecb3Q1z3A1hc/ZNsfD+KJFW/SjKms+cI81j2wYMKCIT635DYcDhMKhS7YXl9fj8FgGOMbmwyv18vJkydJT08nOzv7oiX2qqoqJk+efFWBDefD7XZz/PhxjEYj5eXX5tt+qYSzi8kQzsdoM1uda5Df7DtKdXs3KSlSCk0Ghn1BmnsHyLXoOZfkNDA9xw6CQHNHH+5AiOm59jFJWlMzrYjFYurbevEFQ+QYdTQPJCyyJpkNyMRi6joSZFWtkjMYCCKTiCm1mfH7RzjbnSDExVlmTnf2YlErsGm1SESiMWla0/JsnO7spdRups0xQKYxjeq2JMcGuwFfwI9CqqCxs59ci45zSbZdBVY9qSlyTrf0EA4LqFNkDIaiZFurTMGikNLtCY4h4CqVjIggUGw30do5gEgioj+pwSzLloZeqaS1sx/3UJAsWxqtMU2uUi5lWr6d+pY+BrzRz+TatJzr9aCUSchIUxIOQXNfguwW5Zjo9/qw61Kpb+4hP91AXVviGs4pyWLA6+NsTH9XlGuirq0vWvnNtiBEBE41JSYphdlGPL4AVk0q9U09ZNl1NMZkBlKJmBlF6XQ4PHT1ROUhGfY02nrcZJijsgTnwBDdSWTcbk3DrFXxj4/ejE6TCCQ5ceIEhYWFlw0paWtr44knnuDb3/42e/bs4Yc//OEFDZYXw8aNG3n88cd5/PHH2bNnD3a7na6uLpYuXUp9fT2PPfYYS5cu5b777otek6Ki+PuugAkltyKR6C2i90kNMA04DMRj+wRB2DCR45+PjxviIAgCVXtO88q/b+HYe1HLKJFIxPz1M7njiTUTknLl6nHz2n9t461f7WA49pvJKk7nzifWcvMDi29Y/81PG30d/byz+f0x2tyo68FCbvvGLeSNc0hCOBTm8PYq3vrtTo7tqImnj1UsLuG2x29h/roZEy4XiEQiHN1xgrd+u5MjScdQvrCI27+xmnlrZ9wQ8bmhkRAfbqvizd/tHiNZmLu6gtse/Z/hsvDm5n00noquEEplEhbdOpWNDy6maOr4fu/+Sm7PQ2NjI2q1GpvNNma7IAi0tbXR0dHBlClTLttwdSWf2otBEARaWlro7u7GYrEgFovJzc296s8n4/yEs1AoRG1t7UVlCOfj5fcP8EZDO7UOJyJgSroFfyBEQ1KlNd9moLG3P+p+YI9Wco81J8hsgUFNg3uINIWcAoMBISyM0cNm6DS0e73k6rWopHJaewYYDo/9WxjTlGSmaenocdM/6CfLrKXVmdDczi7MwOP1cSZGvipybVTHKrUquYwZeXZONTtwx0zPy3OtcfJbkm4iVSLhWNKSfq5Vx7m+ATINWgwKBc6BYbo8CaKWqpAjT5GQbUjjTEsvgWCYcNL9WKOUMyndSEOrk8FYNUmnVeIa8pGqkFNoNeB0D9PelziHDIsG93CQQqueplYnRr06busFUastCXC2JVoJzbGncS5GLM2aFGw6FadbXQgx0/BJ2SbOdvRRlGkm6Ashk0k4kyQjKM23IBWLOdfcy5A/TGG2kbMd0YpKjk2HSaOmqq4jHpSRk6Gn2zXI5EwjnZ0DKFUptPckZBVTi+z4hkZoOBerHhtVON3DmPVq7HoNbR0u3IMB3vzlgyiSiEZVVRWlpaWXbYysq6vj3/7t33jllVcu+Z7z0dzczOLFizl58iTZ2dkMJE2g9Ho9LpeLdevW8YMf/ICFCxcCsGLFCp588klmzbriPXCiye2S2BhPAn933rhPCoIw96IfnCB8koSyhuPNvP7UO7z/pwNxvWfR7ALu+d56bto4a9xJhKd/kO3P7OLNX75LX3v0fmCw6bj9W2tY99hK1NpPv2v+qtHYCP/xH/DiizA4CKmp8KUvwfe+BwUF4zpUlPBV88Yv3uHojoS2vXxRCWsfWcHCO+aO+wShs9HBm7/awbvP7olPSMyjcoGHll0XX+POJgdv/uo9drywN+6Za802xSQLi6+LbOJq0HiijTd+u4s9f0m4QeSWpLPxkRUsu2vOhOjbrwcEQeDU0XO88fu9HNxxIh56UTIjl40PLmLB6gqksk8+2fkruT0Pzc3NyGQyMjIy4tuCwSAnT55EoVBQVFR0SS3rKC7nU3sxBINBTpw4gUqloqioCIfDgc/nIz//2uL7kpviBgcHqampITs7+6IyBIh+2T4408xvPzhKp2sAT2iEKelW3B4fbU4PqWo5Xn9iSb44w4xKKqXNMYDT62Nqro2qJNut2Xnp+P1BznQ4GQkLZOtVNHsS+tUCvRqJRE5DbEk7RSrBL0Qfgkq5lBKbGUf/IF1JUbbZljRa+tzkmnQoRBLEIhG1SbKEilwbTT39TLIYaGjvp9BuGOMJW55jJSwIDHqiNlmT0w3UORKEvSIn6ilb39oHAtj0qXFya01LJVOn4URzdzxtTCyCkBgMqUqyjWmcbekjTIRgKKEdzrRoMaaqaGzpZTgQwmRIpccdXZbRq1MoTDdysrGbQDB67lk2Ha29buwGDeZUJYPDAZq7EwQtN8OASCQiODRMZ5+PbJuGlt7oNZKIRZTlGOnt9+GIBSvkZxlo6OzHqFWRZdIyPBykoT1xznlZBmRSCeFgmHOtTrLTDbTE/iZ6rZKCDAO1DQ6GY7o5q0VLr2uQDKMSwlL8gRH6BhJ/10kFZiSCiDONPQgRAYlMQigc4Z2nHxnzvTt27BjTpk277O+osrKSzZs38+yzz17yPckYHBxkyZIl/MM//AN33HEHOp3uouR27dq1/PCHPxxDbn/2s58xc+bMKw1xvWQJlYIgzDhvW40gCBXXY/xRjEf8bn/3AG/9+j3e+s17eGIVfXu+hQ1fW8XqTUtI1V1d0+7VIjQSYu+rH/HKv22h6UQrACqtktWblrLha6uuS+f+J8L27XDXXTAyEv03Cpks+u/VV2HNmgkZuq2+ky2/fJcdz38Qd8NIM2tZ/zcrWf83q8addA55hnl38wds+fUOOhuiRQaZXMry+xZwx7fWjHv1+OLH4OO9F/fxxq92xCULcoWMFfct4PZvrCanJOMKe7g+cPV42PbcXt5+dg+uWHEjVadi7VeWsP7hpZjGuTnwesLR3s+W5/bz7ssfMRSbaBhtaWz48kLW3DcPzSe4R3xuyW0kEmFk5EL7yLa2NgRBiEeDjkbcTpo06aqDDerq6jCbzRiNV/YX7O/vp7a2dsz+HQ4HXq+XwsLCK3z64hi183K73ZeVIUQiAnvPNPPLPYc563AiEYspMmpx+YJ0uxOkJU2jYGDYj0ouo8Rqwh8IUduR0G5Oy4smZVm1ajI0GsSIqEyq5I7admVpFISDEcIREb2++IorcokYuULKJIuRxjYng/4g2lQFbl8iRGF2QQbuQX+80licaaS2K/rfOpWCsnQTx5u68MeI4tRY4IFULKY0w4xSLOVIQ6JZapTcTrYbEYUgEorQ2JuQWtj0qUjlEnTyFGpbetAqFQz4E8djUMvJMOupa+4lFCO0EpmIUETAqkvFplXT0t2PZzgxKdClqVDIpaRKRTR3eDAZVHS7Eg1oUyfZCfpD1DdHG7Sy7DpaewYQi0QUZZmQiERjZAS5GXocrkEmZRhpa3eRqpLRniRbKM41gCCmsbmPcFggO1NPc9cAUomI4hwL4ZFwdKwY0q1piEQidCoFZxocGIxqHLFmNpVCRkm+leYWJy53tOKi0SgY9AWYnGMmMDxCZ6+bYKxSJxaJyM4yoEmR8W8/2jjme3fkyBFmzZp12eW1vXv3sn37dp566qlLvmcUIyMjrFu3jtWrV/Pd734XGCs3+IzIEr4GfB3IBxqTXtIABwRB+NJEjn8+xoPcjsI35Oe95/fyl//aFicRCnUKKx9YzB3fvGXcSacgCBx5t4qXf7aFE/sSXfNz1kznzu+sZdrSG8PofwwaG6GiApKaWC+ASgU1NeNewU3GsNfH7j8eYOtvd9JY3QxENaorH1jM7d9cQ07p5VMFPy4ikQiVO0+w5VfvcWjb8bhcYObKcm5//BZmrZ464RrqUcnCm79+j6PvJbJSZq2s4PZvrGLmzeU3xPdlJBhi35vHePN3u6ivbAZAIhWzeOMsbnvsZopm5H6qx/dJ4BsKsOu1o2x5bh9tjdF7RIpSzoo7ZrHxK4vILvz42v2/ktvz0NnZSSAQICcnh7Nnz+LxeC4acfv0gWPkGHTMyc0gTTn2tbNnz6LT6S6p24XoDbihoQGXy0VFRcWY/ff29uJyuZg8efI1nVt1dTWhUAiZTHZRGUIoHOGdE2d5dl8lErGYZpeL8nQr3U4vniEfQ5GxjXZZ5jQsajUNbX14/UEmZ5qoT6qazpuUiS8wwqmWaBf+tLxojCtESc6MHCutPS56vVFCa9el0hmriqbKJWRqVLT2D8c9bgF0GiUDPh8l6WYCwyEiCDT3Jipx2QYVg+EIWXoddc090Waq8zS3giDQ6fDg9PioyEvIEkQimJFno6N3AIcrSljzkwIWCmx69EoFlWcTBF2XqsDl85NjSSNVJqeptRf/ed/qbHsaGpmcuuZehIiAUiWNN2Pl2/SoFTJONfbEfw0mo5pe9xBFmSZCgQi+wAhdzkS1OidDj1aVQl/vIA7nYFzjCmDQqijMMHDqTFe8gSwrXUerw01hphFGIvj8AbqS4nGz09NIVabQ2trPkC+E3aals8+DSASFWSZSJBJOn0lcQ4NJjUgEdoOGxsZe5AoZ7lhVR6WQMSnPREenG2esSQAxSCRiJudGZRFNrX1oUxX86VdfGXOdjhw5wuzZs7kctm/fTmVlJT/96U8v+z5BENi0aRMGg4Gf//zn8e1/+7d/i9FojDeU9ff387Of/YytW7fy1FNPxRvKvvWtb3H48OHLjhHDRJPbNEAP/Cvwg6SXvIIg9F/8UxOH8SS3owiHIxzedpw3/u87HN99CoilNq2bwZ3fvnVCdLlnK8+x5VfvjuncL5iay53fWcuSu+cjk3/8sJ4Jwde/Dk8/PbZiez5kMnj0UbiKCd8nhSAInNhXy6v/uZWP3j4W3z51SSkbvr56QjxzOxq6ef0X23n3ub0EYnKy9EIrG7+2ilWbllwXeUlrfSdv/HIHO/+wP96smFVkZ+PXVrHy/oUo1DeGFOD0kUZe//VODrxVmVjWn53PbY+uYMG66UhlN8j3+mMiEolQua+eN36/l2N76+PbZy4u4raHFjNjUdFVT3b+Sm7PQ09PD319fXg8HqxWK7m5uRe94d7/7J851dUbjTq1W1hZnE+ZzcLULBvtLS0X1e2Owu/3U1NTg8FgoKCg4IL99/f343A4KCkp+djn5fV6OXz4MFlZWReQ42AozHsnG/j1+0focHlQyKTMzLFzprMPZ0z/NOrnCmBQK8kz6nA4vXQOJDUyZZqo6+oj16RDI5Ujl4jjzgQA03JtnGjvoSzDgqPPg1wk0OZNNFbZdRpCRMhI01Db3IMQgRFRYjlfIhJRmmXC5QnQGdOo5tj1nIuRT7NaTp7FSGVjF6M5HFNjaVwaZdTBQCKIqGxMkOES4SkAACAASURBVNMpuZZoslmGif7+YbRKOXVdCc5QYDcgk0sI+kM0d/STbtLS4UoQzbIcCyPBEA2xrl+5VIw/9p2fnGFEFIazSfpWiHr15lr10X22u0jVpOCN3bSlEjHlhTa6e710x6QFZkMqPQODaFQp5Nv1uL1+WrsShN5u1SISi5CGRuhyDGOxaOiIxWBKJWKmFafjcHjp6I4S4HSblo5eD1ZDKkaNgj7nIL0Dieqz1aLGmKZmoN9Hd48Hg0Ed97DNyzSgUkqpre+JV1MUahlqZQpahYgehw9fKETsvopOqyTLrqOj3cWA2xetvA/7Sbem8fS/3zfmulwNuX311Vdpb2/nH//xHy/7vv3797No0SLKyxNxo//yL//C3Llzueeee2htbSU7O5s///nPGAwGBEHg8ccf55133kGlUvHss89ejd4WrmOIw42AiSC3yWg+1c5r/72NXX/YH9cT5pdns/5rK1l+3wKU6vG1QHL3eXjrN++x5Zc7GIhNEHWWNG55cClrH7n50w+F0GrB672697ndV37fOKKtvpPXf7GdnS/ujdtq2fMt3P3d9az88pJxTyPz9A/yzrPvs+VX78Vt5tRpKtZ+dQW3f/MWjOkTvwzvcXrZ9vs9vPXbnfFgiFS9mrUPL2fj39w87j7B14qedidvPbOH7c/vYzC22mrO0LPxkRXc8sBCUm+AlLZrRcvZbrZs3seu144SiE1Mswqt3P7QYpbfPvOK6WefW3IrCALB86ydBEHgzJkzdHR0MHPmzAu8XpPx0AtvcKwtYR01MzNarUyRSigy6ZibbWdxWRHFdjPSpAaKUW/ckpKSS3Z/DwwM0NHRQVlZ2cc6p/b2dlpbW1Gr1WRlZcX37wuO8JfDp/jD/mrSDRrO9vVTbDXR2OlEr1bSnOQSIBZHq5TZej11LQ6CoQhWQyKMAGDe5CzcXl/c83RafqJSmyKVMLsgk/q23niU7eR0I/WOKCnMMmhJT9NwrKEzPuOUiEWERAIpMgkldjMd3QOMRCJ4knS+WWYtESGMJCzQ1jtMSa6F00k+t3MmZxAMRTjT3IM/GGZqoZ2qWJSsMkXG9Dwr9a19uEatwDIN1HW5kEnEFGeakSPieBIZzjBp6XIPUpJlxuvxMzw8gnMosWSokInJj73W0e1GLBIREkfPRy6VUJxlwjkwRFdv4rqpU6M/xnS9kr4+H0jFuLwJslmYbUIpk3K2yUFwJILZlEqPawiRCCZlmZBLJJw+k5hEWKwaBocDFGQYaG8fQJ4ixZHkVlBRbCPgC9HQ1IcgCBhNqfS6hkhVSsm26ujr99LnSoyflqYk3axlyBugvcOFMlXOkC9W7co2IpWIONvYB4KAVCImiECGLQ2dWkF3xwCuwcS+8rKNqBQy/MMj/PeTd4/5nl4NuX3++ecJBoN85zvfuez7riP+Sm4nAC6Hmy2/2sHWp3cxENMTqtNUrHl4GRu/tmrcSWfQH2TXS/t5/b+303wqZjIvFjF/wyxue/wWKhZ/Sgb6YjFc/hmaeN9FLCyvB4bcw7z3wl7eeGo7nY3RFR6dJY2N31jN2kduRme+ei/2q0E4FObgW8d4/al3OLGvDoh21y+9Zz63f2sNk6bnjet4F0NoJMSBLcd4/f++S+2hhsQx3D2P27+x+oaxEvMPBdj1yke8/pudtMc0zAp1CqvuX8Btjy7/TFuJeVxDvPOnj9jy/H6cscKNVq/m1vvnX9ZK7K/kNoaRkRFOnz5NKBRCLpdf0YbrGy+/zf7G1vj/HyW3o8jWaWhzeklNkTM9x87MnHRMjGBOETO1ouKyneIejyeulb0ahEIhTp8+DUBpaSmNjY0YjUZkqlTerqzj93uO4fYF0KuVlGdaONbYwfBoFrcxjbZYMleWMQ21SERDzwDJycR2o4bOAW9UIuALoZRLOZ2suc230+BwMslq5Fx7P9nmNGraE8RzcrqREAIKJNS39mLWqnEMJpbLNcoUCuwGmjv68cQqAwadEqfXh0gEBRYdIX+AFmei+luUZaSu00mmUYtBpUQqElHVlCB+UwvttPQMkGvW0djSS36GkZpziddzLanI5TL6nH4GvD7y0w00xBrMlHIp5Xk2znX0xyuZJp2KXu8wyhQZkzOMdHW56PMmdMNSiZgUlYwCm4HWjn7cXj8iiShe2TTr1WSYtNQ3OeINZKkaBZ7hAPkZBhQiMQ6ndwzZtZq1mHUq+p3DdPd4ojKGmEbXatSQbknl9BkHwdj+TKZUXF4fRTlmvG4/Pn8wfvwAkwstiMICDed6iYQFNGlKPIN+tKkKMsypOBxuBjyJ34RCLSMv04i7fxiHw0M4NkcTi0UUF1gYHh6hpSU6adHr/n/23jxMjrre/n9VVe/7PtMzPXtmJvtGIIFsQMIWwr6LoKKICxf1qvd6l+/1x/Wn3x/q1XuVKygCIooihGAgIQkBQsIWEkL2bfZ9n+6Z6X2r3x9V092DBJCbGeKF9/PkeTLdVV1Vn66uOnU+532OiVA4zrQqD9lkllgkQffAGDWVHv7rQ4DbX/ziF7hcLm6//fb3XG4K62MFbuurp8s3L/kKV33lQmYvnXz7oWQixc51u9hw39YciBBFgaVXnskVX73olEsWZFnmyOsneOb+59nx5Os5V4eq2eVceefFnHvDORgtU2igfxozt++sTCbLq+vf5I/3PE3jvlZA0eWef9NSrvvmZZRPP/WNWMd2N/LkTzbyyvo3c6TInOXTufquSzj7sjOmxNv4yK4Gnvr5Zl798578Piyr5+o7L2bJJEVQ/7WVzWbZ/fwh1t+/jX3qA4EgCCy5eC5XfWk1c86pOy30wx+m0qkMrzy3n6cefJkGNf1Mo5VYcel8rvr8SqbNnqgH/wTcAsFgkCNHjlBdXY3FYqGlpYW5c9+7OfmeTTs5PjjEcCxK2/AI8wPF7CtoovJbTfSGJjYHGBDR67QsqPCzsLKERVUl1BZ7kN7xowiHwzQ1NTFv3rz3PY6xsTEOHjxIeXk5gYDy5b6x7yAvNPSy5VALM0p9dIVG8dusHGnvo77Ey8GuvK6yxGnFaNCiFyQlEEAGUSIHyjSSyMLqErr6R+hW9aCzKn25GFi31cSsUi97GrqIq9rPSreJ5lAUQYAZpV5sGh27G/LNXB41IMFjM1HmVKy1Yqn0BPjgc1sospsZHByjbzhCoMhG+2CBTCDgYGQsTrcKeGdX+zjYpgDuEreNap+DN4+2k06rnoo1xexv6cVtM+LQSeg1Oo4VOAdUl7oYCkcp99hp6RjGaTXRMZi/iVQUO3BYDTS1DhGNpzDqJaLqDbHYZaHIYeFYq8K45kqESr8Lo0bDiaYBNHoh56YgSQIza4oZCcXo7FKYc4vdwGgkjsNqoLzIycDgGH0FDWIOhxG3w0Q8HKWnL4rDYWRYZaLtVgPV5R5aWwcZGVUAss1uZCwSVzWwKQaDEcYieUBeXeXBoNHQ2NRPOpVF0omk01ncThNeh4n2jmFiceUYdToJnUlLoMhGd0cQURAJqZ9lteiprfLS3jHMkKrxDZQ6GY0kOHN+OV//6vm5bcqyzJ49e94X3P74xz9m+vTpucav06D+Nu8IH7KKrCXy/OxqAKpmlXH5l1Zz/g3nTInm8NjuRtb/fDM7ntxFRo23rpgZ4LI7VrP608sxWU/uj/xharg3xMYHtvHsL58n2Kf85k1WI+fduJS1d1wwNRG/p5nm9oOULMu8/eIh1v/8OXZt3AsoQGrFtYu56TtXUT331I9bT0s/G+7bynMPvURUvfaV1Zdw/bfWcv5Ny6ZEQ93T0s+G+59n8yMv56zESqcVcc1dl7D6U8tOuUzjw1bzoQ7W/3KilVjtvAqu/soFLL984d+sLleWZY681crTD+3gtS0Hcg8ac5fUcNXnz+Ws82cgiuLHG9wmEgmampoYGhpizpw5mEwmotEox48fZ8GCBe+5/r899QLP7lcEz2a9lnnlxcTTaYaiMdqGQnhMBgYLWDgAu07PaIFLwKwSH219IeZXFrOgsoQzqkuZXuIhnUpy9OjR940FHZchjLshtPQNs2HPMf7w2n4yWZlKr4Nyl4NXj7XmmNiZZT4Od/crwLPEhx6RfW29Ez5XoxHQajRM93vo7A1hMupoLwB6syt8BGNx3EYjR1v7mVNZzNsFwH52hQ9BFBkejtAzOEZNASsKUFviRq/VcLSlP3diChoFUFsMOmr9boZCYToH8p6wVaVuWvuDzCjzEh1LYDbqOFwQLVtdbCWWSqMXJNp7w8yZVjyBqV00PUA4HKOhbQhZVqJqx9cP+OyUeWzsOdqZA8MBn52OwRHKfHaseh0jI1F6CpwNTHqJYp8dHSInWgYwaDVEs8oFRBIF6iu8RKMp2jvzDgySXsCg1+J3GBkaihNPZogn83Z0NVVu9JLEiaZ+MmkZi9XAWDSBTitRV+EhHEnQ3pH/PKvdgM1qwG7Uc6KxD4NJT3gccJr1VFe46eoIMhxUHrJ0Jg2pdJayYgtCRqKrbyTn9CAIUFXpRiOINDYOoNWIJFRgUV7qwKSXaGgeIqtaoTnsBsxWAzazgebGPjxuK13qtHJVhRuXw8SBA53MmVXK3d/N5w+k02kOHDjwvuf23XffzYoVK7j88inNLniv+liB2/nzFsjfuOZf2PTQdkIDefuhiz+zksvuWE3xFGhUB7uGefZX29j88HaGVUs8k9XIBbeu4IovX0ig7tS6LCQTKXY88TobH3iBw6/lm1lmLqll7ZcuZMW1SyYvGOI0cUv4sNXV0MOTP93I1ke254DU4ksXcu03Lp0UqUd0LMaW32xn3X89l9PluvwOrvjyhVz6xdWnPG3tpPvw2x2sv3cLfQUR1GtvX8Vlt6/COUnJW39tBftHefbh7Tz70HZGVNmap8TJFbefzyW3Lv+b1uX2dQ6z4Tc7ee7xN4iFlXtfaaWXKz63nMs/s/zjCW4zmQyvvfYaTqeTmpqa3JRCMplk//7978ss/eCZl3lyz+Hc33MDRRxqVRhRo04i4FA6zUdTKfrCcTKyjNdkYnAsf/GaU1rEobY8i7qw0s/R9n5mBLz4jSKXnL2Q2eVFWIwT2ZJxGYIgCMyYMYPDnQM8uv1tdh5tZU5lMaORKKIs0NI7woIa/0RbroAXvVZiKBile3AUt83EQIGW1G7UUea00N43RkQVcRc2c9X63XgtRt441pn7VsebuYw6ieklXrSI7GnI65HHnQjqSj2IaZmhYITB6ETg73ObKXFYOdE6QDyRxmHTEYwk1fHUMn+an6aOIQZVgDmz2sehtn4kUWBGuQ+TVsueo535bRZbaB4IU+GzImYFdKLIie68tnhmlY9UNqtM07cOMq3cwwnVZkwUBObX+RkZi9PSrrzmc1noG4mgkUTqytyEg2N0DuZlEiaDFrQCNaVuejpDjIzFKORg/F4bboeRxuaBnIxAo5PIZGXqK70ko0m6B8dy7DdAid+Oy26irXWQSCSJyaInEk0iilBf5SOZytDckm9iM1p0uBwm7CYDjQ19iBoxJ4Fw2I2UlTpobx1idFR9wNKAwaijptxNaCiaa0QDsNuMlJTYGRuJ09UZxOk0MTwSRaeTKC22oBVEGpvzDyylJTYsNqMiYegZpabGS2PrIEvPqeEfvnVxbrlEIsGxY8fed1biH//xH7n22ms5//zz33O5KayPFbgd19wmEyleWb+bP9//PMd2Kw5loiiw5NKFXPbFVSw4b/JttdKpNK8+vYcN92/NaS8BFl04l7VfXM3iNQtOeed+6+EONj7wAs8/+nKOIXT47Fz02XO56DMrCdSVnNLtAR+pz+2pqoHOIZ78ybMTopFrF1bz6X+9miVrzzjl50o6lWb746/zp/94Nqeh1pv0XPzZlVz7jUunpFEwk86w8+ndPPmfm2h4uxVQPXtvPIdrv76G8vpJOFc+RCViSV58YhdP3fc8HQ0K8TOuy736S6sprvB8xHv44SsyFmfL42/w59/spL8riMNt4Y9vfe/jCW5BkSO8MyI3k8mwe/dulixZ8p7r/nTLqzz6Wj7VZVaJj6PteSbRoBFJJBVWTK+VKPc5cZkMDMfitA4GSaQzzA8Us7+1wGWgws+BljwQrfA66OgLUVPsYm6ln7mVxVR7LAx2tlJeUUFzMMmGt46x80grkigyK+DDoJEmSADGwa3ZoKO+2A0p2FegDXaYDQzH45S6bPgsZo429aLViUST+aaF6lKXwkxGkrT1hJhTXcSBAlBeW2RBq9XT2hMinkgzq7KIQ+pYaCSRhTV+eofG6FSn/OwWA0GVwa4scmLVaWnoHJgwpe+y60GUKHPbaW4bpMhjo6l7KPf+XNUbs6d7hKGRKHPq/OxXG8L0Og2LppfS3D6Ym9Yv9xlpG4qj1YjUlrox63S8VQCGays8tA+MUlfmob93DKNOQ2t/niUt9ztxWA10dAwzMhrHatYyGleAaLHHSrHLwrHGvP5Vp5VIyFlqK7zIqQytrUM5zSqAxaSjqtxNT1cox6xKeolUOkt1mRu9KNLSMThhTLxeKz6XhbaWfiKRNDqThkQyg0YSqa1SIopbW/NjJGlFygMu9BqJpsZ+0tn8zzBQ4sBuN9DU0E8ikcFk0hFJpCjyWfE6zQT7w3QXyEBqqj0Y9FpaGvqIx9MEAk46ekKUBZyY9BoS0QRtncr3K4pQX+8jmchSVurk69+6KPc50WiUpqam99WT33nnnXzlK19h8eIpDeZ6r/qbBreCIDwErAX6ZVme/X7Lv1tD2fG3mvnzfc/z8pNv5DSqgTo/l92+igtuXoZ5Chigpv1t/PkXW3jxD3lrL0+pizWfP59LPn/eKe9ij0XivPSHV9nwiy25YAhQUrwuue08ll29+NQmRTU1wU9/Co8+mk8ou+UW+MY3TkvG9mQVGhjlmfu3suG+rYyozP+0BVXc8n+umRSQK8sye184xLr/2sSeLcp9WdJIrPrUUq7/5mWUT0EggyzLHHzlOE/du5k3NuY9e89eu5Drvr6GWWd/OGvPU13ZbJa3XjzMul88z74dysOiKAosu+wMrvnqBdQvnPxGvcmqTDrDa1sPEY8lufDasz6+4DaZTPLO/ZZlmddff51zzjnnPdd94IXdvHSkGbNRRziVQiuJHCmYJteIApn0xM+ucDloHwghilDucxJw2xkOR+kKjhKMxJlXUczBgqn0UpeN7oKpeQBJBr1WgywIxJIpyoscOEwGegdGGRyJMq/GP0EisGhaKZmszIm2fmKJ9F9IBGaW+ZCzMsfbBnLfktmkIZxIo9eIVPscCDIc7civM6emmAOtvQRcFjSZDA6LhQMFxz6zsoi2gRC1fjcd3UGsJj1t/XnW1G424PfZScfTNKvWWhq9RFKdBg94bfgcFg4c78nJFqrLXDR1D+NzWvA7rWRSGY605Lc5p85Px8AI5V47LS2DVJd72N+YZ48XTC8llVZAZjSWoqzIRPtQvlmsNuDh4LEeoqo7QEWpk5a+IGXFDhxGA2OjMdoL0sI8TjNOpxk5naG5dQirKS85MRq01FZ46O0fZUAF1xpJJIVMoNiOVsjS0xOekGZm0GuorvISGorQ06OCRJ2oyEsCLoxaDU0t/aRS+XPK7bPg99joah9mZCQGkkBW3X5NpYfgcP6ztFoJWRSoCNiJjiUYCcZzTYUaSaS+rohYNEFrk8IEezwWgpEE06q9xMJx0okM3Sqzq9drmDXLT1/PKN2dypjU1PoYDkUV+7G2YZwuIy2tQeYt8HLjzfNxOp04nU6SySTt7e3MnDmT96rPfe5z3H333X+1Y8gk1t86uF0BhIHfflhwO17DvSE2P/IyG3/9Ys4myWDWs+qmpVzxpQumJNlpdGiMrY/uYNMDL9Kp+lFLGomlVyzi8i9fyJzlk9CA9toJNj/8Ei8/+XrOEstsN3HhrSu59IurJ6WR6m+9ErEkmx7YxuM/2pCTltTMq+TGf7yCZVcvPuVRzAAthzr404+f4aXHXyObUa6xi9cs4Lpvrp0UL+V3q67GXp782XM8/7tXSCWUe8qMs2q45q5LFI/gSTjuD1PNhzt56hfP89K6XWTU+9GsJdO45isXsPiieafNfn6Y+thqbuHdwS3Aa6+99r7g9pHte7l38xu5v6u8duKxBDazHjQaOodHiCTSE468xuukuTfPBi6o9LOvqQcZ8DnMTCtxE02kCEZidAyF8Nos9A+HmVBZlNusrPzTiwKpTH4jFUUOWgZDlDrNuM0WNIgTGt2qip20DY0wq8zH2Gic/uExYumJ1jJVpU5sBj1NrYNEEylKPGY6VXZREGDx9ACdPUN0DyqvzavN224VOy3UFLvZe7wzHytbpIB6o15LfcDD6Eic1oJxANAaRIrtBjSCjrbOID6vld6CYz9zVoCxcIKG5gFkWWbmtCIOq+C20u/E77Ky+2B7ThM6o8bL4bYByors2Ix6tILIgQIbrRnTioglk4iZLK0dIfweI91DilRCEgXmzSglOBKlVXUD8PuUwAOjXkOtmsjV0JaXBNitBoxmHW6bkabmQSRRIKJe1DSSSF2Vl1gsRVu78pAgigIZZHwelY1tHiRcYH2m12momeZldDhKl9pwhqh8AX6fGZvZRGPzYO7iLYoCRSV2nFYjzScULXNSVt7zeS0U+2y0NA8SVh0ebDYDWqMWv9dKR+sQWo3IkPodFxXZKPXbOX6ij4iqYyordyGIAjoJOlqGKSt309QyiKQRqan2YrEY2PdWG7L6MDJ7bikyMH2Gn7VXzWJ4eJhgMEgymUQQBKqrq3E4HGi1765hvP7667n//vupqJiCZp4PVn/T4BZAEIRK4Nn/Kbgdr0w6w2vP7uWZX25j/458Eti8FTNYe/sqzrls8ptWZFlm3/YjPHP/87y2YU/u91Axo5Q1XzifVTcvP+X6y+hYjO2Pv8ZzD77I8T35MLnZS+u54JaVrLh2yZSw2H9L9W4gN1Dn57P/fgPLrjprUpwGepr7eOInz7L1tztyLP+MxdO4+Z+v4syL508JyA32jbDhl8+z4VcvEFYldf4qH9d+fQ0XfnoZuvfxap2qGugOsuGBF9n0yA4iqgynpMrHNV+9gNU3nH3aNMn9NfUJuP2Q4PbxVw/w42deyf3tNesYLLBRkoFyhw2XwwSiwFAkilGjpaE7D4jGwe14zSzzcax1fDofast8pFNpuoIjhFWgKALjAWICoJfyjCcyWM06xsaSCOphFTkt9I6ngRl0zKksorFjkCHV8FkriSTVMagscmDV6egfHmOgIH63ttxD++AoNUV2entHsRpE2obzetO504qJJlNokTjR0k99hVdxXhhfv8yDSa9VwHI8pbDdCWWszAYtfqeR0Gic4ZF8s53PZ2NoJMr0CgXg6fQamjrzU+6zaouRgehYgvbOIHPq/RwYZ3BEgboyG5EEdKjAUHm/F71Woq7Ci0Er8dahAllClZeewVH8bjN9vaOYDBp6CzxgS30mbFYzrS1DJJIZfB4LfcEIoihQV+VFg8DhAvBsMevR6CQCRTa62oMk4mlimfFoWqip9JDNyjQ3D4KsMrtylmKfDY/TTGfLICOx/PlksxooL3PR3zvC4EAYjUYklZXR6SRqqhQ3hObm/LllsegpKXOSTqRpaRrAajEwGkkgSQJlATsWo4HDR7pzv8xivx2H00QinKSteZDSMkV2YLHoqSh3IwGHDuTlLjPnlIAg0NEyyNhInOmz/DSc6Ke6xgvZLDqtxJFD3Vx1wyI+/fllufUGBwfp7e3FaDQSCoWQZRmHw4HT6cThcCBJinZy7dq1PPXUU+8ZYX3bbbfx7LPP4vP5OHToEKAEoNxwww20trZSWVnJn/70J5xOJ7Is87WvfY1NmzZhMpn4zW9+875Nbe+oT8Dte1TrkU42/HIb2x57hYQaOe0qdnDxZ1ey5rbz8Ja+u6f3qayBziE2/fpFNj34Ys71QGfQsuKaxVx6+ypmnn3qbZAa327hmV8+z4t/eDWXqqUzaFl65VlcfNt5zFs587SwiDpdKhlPsvW3O3jiPzbkophr5lVy6/9zHUsuXTgpgDPYP8Iz9z/Phvu2Mqo2VNUurOKm71zJOZdPjY1YPJJg6+928tS9m3PH7fTZufIrF7L29vOxOMyTvg8fpKJjcbY+9irrf7mNPrXfxO6xcvnnz2PtbSuxu60f8R5+8PpYg9tUKkW20NBVrQ8Cbp97+zgPbNtD59AIMlBst9D3DpbVrs8nUgHMKfeRSGcxmXTEUinMeh1vFehj60s9NLTnAYokCmRUJlIGNIJitZLKyrlbrVGryXfcy2DR64gUgCKjXks0lUTIgJAFk05DNJ2esI36ch/xWJLWLoVNLfJYcqypz2GmusTNoeM9RFUmcma1l0NtA2glkXKvBU02Q0N33kmgvsLLsc4BppUq2tGx0TidBbGyRr0Wu82A22KgsWWAVErGaNYSVZ+uXXYT1QEXDU0DjKrMYU2lm8aOIRxWAxXFLshkOVgAJufU+2nvC+Gxahnoj1JZ5smBXYAFM0vJZGRaWgaIRJPMrCvmsGpEXl7ipMRjZe/BDtKqxrWyzEVbb4gSr4lkLAkZgYEC8F1e6sRuN9LdGWR4OIrLaWZIbRasqfBg0Ws5fKwnxySbTTokgwa/10x3+zDpFDnGXKMRqa32koglaW1RE9B0GuKZDJXlbkx6DZ2tQ4Tj+SaTQKkDu91EW9OA0mxm0hGJp/B6LRR5rQQHxujuy495ebkLq9Wg6HXHknh9VvoHw5SUOHDajcTCidy2BQFmzQ2QTKZpPtFHOpWlptZHV3eIkhIr8XAKq9XIcTWqt9hvp6zcyYnDPYyGVGu2BQFS6SxLl9dy6TV5EDme/lddXQ0ozZGhUIhgMEgoFEIURdatW8eePXvYunUrVuvJL6Y7duzAYrFw66235sDtP/zDP+ByuXKxu8FgkHvuuYdNmzbx85//PBe7+7WvfY1du3ad9LPfpf7XEClgQwAAIABJREFUg1tBEL4IfBGgvLz8jLa2tr96G5GRKNv+8CrP/vpF2o8q1zZREll6+Rlc9sXVzD3FcoF3q1QyzRvP7mXTgy/w1vMHc69XzS7jsi8pCWin2k4sOhbjlfVv8vxvX2b/y0dyr5fUFHHxbedzwS0rTptUq9Oh0qk0mx96id//4CmGVGlL/aIaPvUvV08ayI1F4mz81Qs88ZNncw8/gTo/131zLatvXj4lNmKZTJad69/kiZ9spHG/8vsyWgxc8tmVXHXnRfjKTo+mrkw6wyvP7OXJe7fSoO6n3qjlghvP4aovraa0pugj3sP3r0/A7UnA7dlnn/2eP7CNu47wvT9ux6ATKS9yKXGjkTidQyO56Wif2ZRL6QKYXVbE4dZ8I9a8qmL6h8O4XRZESUAU4UBjL9nCscwCeSyLIMD4HsuyjMOgJxxLkpVlZEEJRAgXgFuzXks0msytLwoCGUFWvpEsiKq8ofDW7ffaMBm06EWJ48391FV6OdaWZ2LPmBEglc7Q3jHEaDjB7Do/B5oUoKmRBGqKLITCKQZUdtfvtdE9PIYgQF25F40MR5v7J5wVZosOn8uCUaPlRFMfPu9EvfHC2aUk4mkaGvtIp+UJ4LQq4MJrN7L3YFfeXHtGCQcauqmt8CJmlaa+g8cLWPK6YhAFIiNxOjqD1NX4OK7KHBx2o3LMJ3oYG1PGMlDioKNvhBKfGZEsiWiGwVAe7PqL7bg9ZoZ6R+nrG8NhNxIciysWWxUeLIa/BLsGi55ij4XO1iHS6Wzu4cFk0lFT5WFwIEyvqpk1mXSkZJnKCiejw2GiY2nGVIZMq5Woq/URjSZpbVa0006XmbFYkppqL4lIguhYgn6VtTAYNUyf7mewL0yXKpMoq3ARjaUoLrbR2xnE7jDS3DyEIEBFlQePx8yhtzpIqG4OM+eWIgsC4WCEztYhZs4LcORQNxVq45lWI3Do7Q5u/fJKLr8h7zzS19dHPB4/qdwgGo3y5JNP8tOf/hSbzYbX6+V73/seZ5111rsu39raytq1a3Pgtr6+nu3bt+P3++np6eHcc8/l+PHj3HHHHZx77rk539zC5T5g/a8Ht4X1P00oG2+u2fCrbYrpvSoXKKv3s+a281j9qWVTYtfU09zHpgdfYssj23MJaAaznpXXLuGSz5/HjMW1pxxI9bb2s/W3L7P54ZcY7MzLkOadN5vzb1zK8msWn3Jw/bdayXiSjb/axh9/+Occ4JyzfAZ3/OgW6s6onpRtJmJJNj/8Ek/+dCN9qrTMW+bmxn+4nIs+e+7k2b0V1HgD3J9+spF96sOQpJFYddM5XP/3ayk7xTZ3H7ZkWebAqydY999beVN9UBQEgaVrF3Dd311M/cLKj3YH36M+AbfvAm7feOMNzjzzzNwU6TtrYGCA9dt389BrrbnXLAYdkUgSGSW6VSdl8Lgc9AbDdA2NkpVl5lYUc7AwRavKz4HGPODSayXi6QySAFpJ0dKOgzXUC7AkCKTlLIIKes06LbFEntEzG3UkUmmQZVJpGbNRRzSWzN2aJVEkk8lC9h136wk6XpFUQbOTz2WgLxSnqsSFSaNBL4nsK2BFZ9f66Roapcxrp7VtiCK3lYbOPAPttutx2Y2MBBMMDkfRavJSCL1WorbCSyyWoKUt37RW7LczGIxQV+ElPBpDp9XQWKBxnTPDT1aG0WCUru4Q5aUW2noU9thi1jOn3k9Ty0CuoWv2jBIOHu/G67bgd9uQZNh/LN9wVlfjI53NohNFGhr68bkN9KgBESajjpl1xXT3hHINWsVFVnoGwhR5TehFiEfSDI68A+y6zfT3jjLQN4bFomMslkIjKRpVCTh2rCf3y7BaDTg9Zkx6Lc0N/eh1GsbUh5SSEjtel4XGhn6iKqC12Y2YLHpcDhPtzQPodBqG1dCQ0oATr8dCw7FeoqqdWrHfjsGiQ8im6WwNUVRsVyJ7dRqqp3kx6jXs29uW25/ps0sQRZG+ziDD/WPUzSqh8UQ/JWU2tKKI0WTgyAFF1uHz26io8tB0rI9hNW54zhnlpFMZzl8zm/PW5J0Ruru7yWazucCRk9WyZcvYt28f3d3d6PV6PJ53ZzTeCW4dDgehUL7xz+l0EgwGWbt2Ld/5zndYtkyRSKxatYp77rmHRYs+8LXvE3D7IWuwe5hND23nuQK/Wp1By8prFnPZHaupnyQQU1jJRIpX1+/mmV9t49AreTuxipkB1nzhfFbfvAyr89SC7Uwmy54t+9j88Eu8uentnP+r3qhj6ZVnccGtK5h/3uy/6aadU1XxaIKNv9rGH/6/pxlVZ/lWXreEW/7tuklr1Eun0rz8xBv88YcbaDuiXMs8ARc3flsBuVOlM214u5Un/3MTO57aRTYrK+DxikXc8M1LqVs4+b+ND1ptx7tZ94vnefFPebeUuUvruO7vLmLRqtmnXfLZxxrcptNpMu+S0717927mzZv3FxG52WyWhoYGxsbGSBrd/P2vn8u9p5VE0smJQLnCY6ejL4ROKxEocuB3WwmG4/SPROgPhaktUabaJ3xGKjOBqZUBWVT+Nhl0CLJMRO3oR1DAbTSRyo2wRa/LASBQLKnimTRaUUQSRbLprCJrUNcfL6GAIdZIAunxJjVZxmzQEg2ncosXe6z0BJULUHWpiyKnhV0HOnLNRDXlbhq7hij12XFbjASDUbr68x6qkihgsxvwe2x0dASJRJJKYEFE0bh6XGYqAi5OnOjLhRLUVHlpbBukyGOlyGlBzmQ43JBnwWfWFzMWTWIz6Gls7KOutijH1IqiwKJ55QSHIzQ1KczmzOl+Djf2YjbpqC53IwkC+w/kNbjlZQ5kUcRm0tN0oo/iYntOtmEy6ZheW0Rfzyg9qqbX67UwEIpQ5DOhAWLhFMMj+e+huNiC22Ojs3WI0ZEYDoeJ0GgMm81AecBFLJKkuTnPjnu8Frw+K2PBGF3tw9gdRkLhBAaDluJiEwaNnuPH8g9KJQEnDpeJ0ECYns4gRX47vf1juL0WiotsZBLpCcvPmhsgk8nS3thPLJqiuk6RHVRWe4iPKcERDceV8Q1UuCgucXDsYBfhEeU7mn1GOdlMlrFglM6WQWYuKOPEkV4qa73IGUVze3R/J1/9lzWcWwBuOzs7EUWRkpKTez/Ksszy5cvZt2/f+14wPyi4vfTSS/mnf/qnCeD2hz/8IWecccZ7fn5BnV5X7r+yBEH4A3Au4AH6gO/KsvzgyZY/leB2vNKpNLue28fGX7/IWy8cyr1et7CKtbevYuU1i6ckAa3zRA+bH97O1kdfzrG5eqOOldct4ZLbzpsUbe5YMMzOdbt44bFXOLgz33znLXNzwS0rOP/GZVNiV3W6VzgU4bH/u54///cWUokUoiiw6ublfPbfb8AbOLn+/n9S2WyWV556k999f33OK9dZZOear63hsi9fgNE8NTHMXU19PPmfm3j+dztzD0LzV87khm+tnRI/6Q9aQz0h1v9yG5se2ZFLaKucUcI1X72Q864567RJPvsE3L4LuN27dy/Tp0+f4IEbjUY5cOAARUVFVFZWcrilj3v+uB2LWU8qm6UvNMZgKDrRHaHISUt3no2cX+Nn/4k84DLotURTKQy6At1s5l2GSpUQCCgAOJXN5jbjtBpIJDO5KW2LXpuzswIw6jXEoqkJd2ZZVP4SAJ0kkUpnFGCqLqTVKK/lrMG0WmLxQnZYSziWRMgqoNhi1jOmdvqLokBdhZdEPEWbah/mcZoZGIkoU/SlDrSCREPb0ISxslh1FHtsSAg0Ng5Q7LfRpU5TSZLIwjkBgsNRBQDKMH16MUcb+9BpRWorfRh0Gvbu68h93uxZJXT2jVBW7KC7fZgSv4NDx/Js88J5ZcQTKRob+kgls9TVFXG8sQ+dTqSm0otRq2FfAditqHCTFcBq1NF0og+v10anGgphtxuZVu2lo2OYgT7lZul2mwmFE/i8ejLJLMlYhtBYfoymT/eTSWdoPtFPJp3F6TITHI1SWenBoNcQGhijV9XMCgLUTS8GAZpP9JNOZvB4LQwFo1TVeBFliI7G6FZZZYNBS/1MP6FglHYVzJdXuQnHktgdOkIDURwOMy1Ng4iiQOU0Lw6HiYNvtZFKKL+HWQvKkJEZ6h2lvyvEjHkBmk70U1RqRUDAYjFwZF8noiRQWePD6bFw5O02YpEkggDzl1STiKa49MZFnLWyPjeObW1tGAwGiopOrtkaB7f79+8/6TLj9YksYXJqMsBtYXU19bHpwRfZ8ugOxoaVGReTzciqG8/hks+dR83c8knb9niNa3M3/voF9m7La3MDtX4u/MxKLvj0ctwlp14n29Pcx7bf7+T5R3fQW2BnWD2nnPNuWsq5158zJeEDp3MNdA7x2A/Ws/nhl8ikM+hNem7+l6u5+mtrJk02kM1mefXpPfzhnqdpVMMYHD4b13/zMtbesfrU+hm/Rw31BHnq55vZ9NBLOfA4/cwabvz2ZSxZs+C0AbmR0SibHtnJ0798gSF1RsZb6uSar1zIxZ9eNiUPqu9Vn4DbdwG3Bw4coKqqKtfM0tvbS1NTE7NmzcLhcADQ2DnIZ37w+IT1imxmnHYzBqOGgWAIu8XCkdb8xavUbaO7P68jtRh1hMNJcueqmB8orUYABFLJ7IS7qk4rkVTZXWSw6rW5JDEZBXim0hkkQSCeyqDTSCQLIl7HlxPeKUtQ35BlMGoE4sksggCyoOxnJFbADhu0RKLvaFpLpnJgV6cRSWbyLLbJoMWgE8gkYSycUHTDKsC2Ww2U+mwEg2P09ef1yUV+C4lklkCRg872YbxuCw0teWZzWrUdAQ1dnSPEYilmzyzh4LEeREGgpsqDy2FiT6E11cwSmjuGqSp3MdwfxukwcaSgIa1umotEIkV/d5hEIkNNjY/G1gEsFj2VZW5E4ODBfPNfoMyFwahFBJpO9FFUZMv5wAYCTlwOAyeO95FQwaLLbSIjy9isGkIDcTQaiVAorr5nprzcTVfHMIMqOPb4rGQBv99Ob2cIURAYUEMV/CV2iv12mo/35Rq4/AEHOqMWvU5D64k+fH47ne1BTGYdFVUedDqJ/W/lZQezF5SRzch0tQwyGoxSN7uEzo4g5VUeoqMxTGYdxw52I0kildO8OD1mDuxuJRlPK+D17Gri0RRdTYOMhaJMX1DG2GgMm91Ib+sQHr+DxiPdfOcn17HgnGm5cWtubsZms51UZgDK73LVqlXs3bv3pMuM1zvB7be//W3cbneuoWx4eJgf/vCHbNy4kXvvvTfXUHbXXXfx5ptvvu/nF9TpcUeZoppscDteiViSl5/cxaaHX+Lorsbc6zPOquHSL6xixdVnTcn0cFdjL889+BLbfr8zJ50QJZHFaxaw5vPns2gSPD+z2SwHdhzlhd/v5NWndxMO5ZtyP7EVU6qnuY9f//Nj7FynNH+W1hbzhf97M+dcvmjSQJ4sy+zZeoDf/vuTHFdT+ZxFdq7/1mVcevuqKQO54VCEZx94kafu3cyIeu2vmlXGDd9ay4qrzzrlqXwftlLJNNufepMnfraFdpW8szrNXHbbuVz+hfNweG0fyX59rMFtJpMhnU7/xeuHDx+mtLQUq9XK0aNHSafTzJo1a4InZ+fACDd893cT1nMYDYyG8/ZR9WWKvZQswmgsgc2oJxJPklEBl15SgapaAgq4LASespAfPJ1WwqDTMBpJ5N63jINbdfwtei3RSJ5l1UgiSbJoJRGdJBFPpsjJjNUPEYFsNr9drSTkNbc5e7EEAgIIis3UmCoXkCQBo15LJJxvWtOOg1tZRpBRbMnecQZodRJ6SSISTirSB+t4tKxAZcCJKGRpag7m1quqdNHZO0pVmYPQ0CgOh40TTXmwu2BeGel0lp6uIMNDEWbPLuXgkW51XQ8+t4W3324jpUpHZsz0094VpKLMSV/XMFaLnrZ2BZwKAsybV0Y8nqJJdQuorPLQ0jaE12ulyGclk0hz7HgeHJdXuLFYDYovbfswDpeB4GgCvV5DdbUXjSgoVlrq8Xi8ZoxmDalYir7usNKMNhzFYNRSVe1FEgQOHchHHHuKTDhcZuJjKbrahigpc9HdFaK41IHLZSaTTHP86LiZvciMuaUkoilaT/STTmWori9iZDSG1a4lPBzH6bLQcLQXvUFDRY0Pm03P27tayaQzCKLA/MVVxKMpOhr7iYzGmbmwnFAogkYrMzoQp6TczZF9HfjLXThdJgRB4PCeNgQBAtVePCU2Wo70cNf/exWzz6zMjVNDQwNutxuX6+TWUCMjI9x0003s3LnzpMsA3HTTTWzfvp3BwUGKioq4++67ufLKK7n++utpb2+nvLycJ554ApfLhSzL3HnnnWzevBmTycTDDz/81+ht4RNwO+nVcqiD536znW2PvUpEtSK0usysvmkZF392JZUz31unfSoqk86wZ+sBtvxmO68/u5eM6mjiCbi44NMruPCW5ZTWnvpmn2QixVtb9/PS46/x+jNvTbAVW7L2DJZfvZizLlmA0TI1U+SnW+194SD//fWH6VD7JGYvreeu//4ClbPKJm2bsizz5nP7ePR76zjxVjMAdq+NG759GZd/6YIp86iNRxJsevgl1v3Xc7nQlOJKLzd8cy0XfHpqXB4+SGWzWd7YvJ8//WwLx/Yo46UzaLnwU0u59s4LKS6fWieIT8Dtu4DbY8eOYbFY6OjoIBAIEAgE/uIpcSgU4bsPbiWaTNEzPMpoJIHPamaw4OnbalStwMabhvRaIrGU8qcAep1IPJ2dYPklvqO/TRBQROYqSDToNMTGmVhBibJNpTPE4ylkWcao0xKP563BdFqFuRUKvgFZAFkQkATQaSQy6QzpdF6WoNdKSgDDuCxB/y6yhGgyB4YNOomYCtIlScBs1BONJZTEE0HIgXZkOcc4C1kZCsZUlBT/XiGjHKtiDaYch8NmwGHT0tM9lgOn9dOLOdE8wLQqL2Sy6LUaDh3NN4jNV8HuQO8I/b2jzJpdyqGjPQgCVFd58bjM7N3blhPG19cXMzAUptTvoLcziMNpprFJYd31Bg2zZpUwPBihTZVFlFe66egKUl3jRSMIxCNJ2sYb4gSYMbMEBGht6CMeS+EvddDTO0pFpQeTUUt0JJZbXhAFqmvdJJNJettHSaey+IqtBEcSlFe6iIyMIcoS3d0K+Ha4zFTX+ujtDNGjuh1U1HhBEjCZdLQ39OHzO2hpHMBqN1Ja7kSnlTiwu1X5jjQicxdVEg0naD3eSzKeZvr8MsLhOFarge7WQUor3BzZ14m/zInTbUGjFTnwRgsAxeVOAlUe2o73MtA9giAKzDunhkQ0RU/bIKHBMNPmlCIIArf9w8XUzMrra48fP05xcTF2u52TVVdXF1//+tfZvHnzSZf5COoTcDtFFY8k2P7kGzz7wAs0qNPDoBjwr/nceay45qwpYc+CfSNs/e3LPPfQS3Q3Fej7z67jos+uZOW1SybF9SBnK/boDvZvP5x7XWfQcubF81l53dksvnThlGlBT5dKJdNsemAbv/v+U4wMjKLRSlz3rcu58R+vmNSxkGWZNzbu5bEfrOe4Cto8ARef+qeruOgzK6cMXCYTKbY99gpP/HRT7nz0Blxc//druejWFadN0IIsyxze1cgTP9vCrq0HAGUW5LxrzuK6v7uIyinSln8Cbt8BbmVZZu/evUQiERYsWHBSn81ILMmaOx9Q1gHcdiNFbiv9oTDDozEysozVqGNM7VYXUG25xkGiLCta23gaMatiPgFQZxpEUZEliLKcA74AxnF3BBXsmnVaoqreVQZMRi2pTBZJgGQqq1h/Zd6BmN/BDufsxdTv0KzTEImlc7IEm9mQ9+uVZeU4CnS9Bp2GeCKVsy3TSiLpAl2wQa9BBGLxtEpNqztbgBcEleUdL42q+xWyssIma/IODpIoYDVriYRTeV/aag9tncNUV3mRkNFrNBw8lJcRzJtfTiaTpbcjyPBgmNrpPo43DqDVStTUeLGY9Ly9Jy9jmFZXRDKTwWzU0XqiD3+pIxeSUOy3Ewg4aTzex4iaOhOocDE6FsPjMTM6HMeg19KpNqB5fVYC5W46WgYZUmUHJWVOZEHE6TLR3TqEyaynuyuIIAqUVTgxGiVajg/mNLCllS4sdhPJaJLWhj7Kqzy0tSgMrsNlgqzMkf2K5thk1jN9boCRwTAtJ3qRMzK1s0tIptOkkwmGeyKUVXs5cbiH0go3dqcJjUbkwC4FvPrLXZRWuWk/0Ue/2jC3YNk04rEUXS19jA7FmL6gnEQ8hd6goatpAF/ASV9XiECVh1QiRTKepLN5kB8/8WXKavP62iNHjlBeXo7FcvLO9IaGBr7//e+zbt26ky7zEdQn4PYjqIa3W9j08Ha2/+n1nP7Q4jCx6qalrLntvClhc7PZLAd3HuP5R3ewY92uXPSu3qRnxTWLueS2c5l1Tv2kTJP3tw+y86ld7HxqF0deP5F7XW/Sc/ZlZ3D+TUs544J5pw17NxUVGYny6396jI0PbAOUprw7fnQLy69ePKl61HEm9+H/8zjNB9sBKKr0cvM/X8Xqm5dNWSNVJpNlx7pdPPbDDTkvaVeRnavvuoS1Xzj/tGL3W49188TPNvPSujfzUcgXzeX6uy5m1uJp77P2/6w+1uA2m82SSuVBWiqV4vDhw8RiMcrKyt7TriidybLqi/dNeE0jiqQzeT2sWa8hkkyDKi0wG7REE2lQAZRWFMmkJgJPGQXojZvZarUiyYwCCDUaEYtBx8hoPHenNRu0SmiDOsKm8QYy9UcuCJARlAAIjSSSTGXzDKq6gEYSSKezObcEw4RgCBmb2cDoaF5uYbHoCMdSSJKATishCQKRsbzdmCgKisXaOEsLE4ArMsjIkMmTtxqtSDojo9drkGUZOZ3JOzYAOq1IMpFnk00GDbFYfh8NRol4JJ0bF7vdyGg4gd1mQJQV0N/VlXdsqJrmQG8w0t40SDSSpH6mn+PHenF7LBQX25EEOFjQoFZbX4xWr2FsWPF1rajx0to6iMmsp7zCRTwWoa0x//mV07wYLXoiwSjtTYMEKtx0dg7jdJspKXVCNsvh/XnwPX1uKZIk0t0yQGgoQlHAzlB/hIppXrKpNIl4gu4OBRg7vWbKqzz0doTo61TA57RZJUgakWw6Q8uxXqrri2k61kN5jQ+jSYsgyxzZqxxPaZWH4jIHLcd6GVab1uYtqSKZSDPQE2Kwe4SZiyoIj8QxW/X0tQ9RFHDRdKwXt9+E1aKk6ZzY14Gn2I631IGkETi8uw2tVqJ8mg+TWU/L0R5+8Mc7KCrLSxAOHjzItGnTMBpPzni9/fbbPPjggzzyyCMnXeYjqI8VuJ0/b4G88anNp41ZezyS4OUn32DjQy/l2DNQ2NxLPrOSFdcsnpKbeiwcZ+dTb7Llke0c3Jm3FCudVsyqm5ex+ublFFdOTjPYYNcwO558g5efeJ2juxpyr1scZpZcupBzrjyTRRfOmzJN6Eddh187zn9/7WEa97UCcObF8/n7X90x6WEZ2WyWneve5NHvraP9mHINL5lWxOfuvoEV104uwH7nfry64S3+cM+faTqggG2ry8y1d63h8i+tPq28lHvbBln3i61s+f2ruSjkWUumcdM31nDG+ZPjBPEJuFXBbSgU4vDhw1RXV5NKKeCwrOy99TzXf+sRBkIRBcgJAkatRCyengg8x226ZNT3M8r7Auh0iuZWEHKkKWTkCXdRrdpANq5btRi0E5Kq7FYD6XSGeCJFNiuj02pIJcfjeGUkSQHQf3nqyMgyaEQBSRQU0KsuZDRqicVSOYBtMWjz9mOqBjccTuSAq06nIa5q03SSgF6nIRxJ5lhaoTB5YrzS2QkntEYjkC5ontNoRIWBFgW0kogokgezAlhMBmLxZI6VNhu0EyzQjAaJWAHYNZlUizRVHmEy6nIsuigKeL0WYtEko8EYAlAScNA/MEagzIWEEpnbeEKNRtZKzJoXIBZN0HS8j0wqQ6DSRV/vGNXTfGRTGdLJNC1NCtNrtuipn1VCcChMW2M/clamrMpDPJHGV2RjoDuE3qClo3UQSRIpClgxW3R0NoaIqcdUN6cUrU4iNDBGd+sQ/koH/T1histsaEQRnUZLw5EeREmgvMaHp8jGif0djAajShDDDDd6rYHB7hGG+kaZtaiS8KgCXnvbBikqc9JwqIeyGi86nYRGUjS0VoeR0koPRouBQ282k0qmCVR58QWcdDUP0Nc2hMNjoWpWCaPDEdqP96LVaaiZXUoynuKbP/sUDk9+9mP//v3MmDHjL2z2CuuVV15hw4YN3HfffSdd5iOojxW4rfDXyDNSq5i/YjprPrOCsy+Zf9qwg03729j40Eu8+MfXiKk9DkaLgXOvW8IlnzuXuoVVUwIwuhp62PLIy2x9dAfDPXn7uXkrZ7L608tYcc2SSQPcPS39vPzE67z42Cs5+ypQLM3OuHAey69ezJK1CzHb/nc3o2UyWZ578EUe/tc/MBaMYHNb+dovvsDyqxdPyba3P/4av//+ejpV3/f6M2u47Xs3MH8KrbtkWebNLfv544+e4cgbykOP1WXm6r+7hCvuWH1aNSSGBkZ5+oEXefbB7YRVXX3tvApu+PrFnL1mwSlt2vzYg9tkMklrayt9fX3MnTsXk8lEV1cXqVSKysrK91z/vM/di5wd94iVMZpUnah6TluMOiUtLKdN1eQSnpBlNCrwzLOoIEgC2ayMJAoIooBGgESBf24hUyvIKlOralNlQK8VkUURjSgQi6cQBSGXijW+X4IMcgGIlkTVgUxldM06TU7viqAEDMQSKTSSRDKhWJfFCmQJer2GRDyVA7uSKOSa5pAVU+psWs6BegBBEjHoNGQzWRLJNKIg5CQBoAL/ggcFvU5DIpEH2Ea9hvi4fhmw2g2kVVCZSmexWQxKE5wAoiSg1QjEY5nc5xlNauOdesymcUCvnscms47oWJ4h1+s1pFKqPjotrIg6AAAgAElEQVSVwVzQVGd3GLFaDPR1h0irDxbFpQ50Rh3IMl0tA/jLXHS2DeP0WPCXOpBEgYO72wBl/2YtKCeVStN2ood4JE1lXRGhUIySgJPRYAS9TqLpeB96o5aKaT6sNgMHd7WQTKQVO67pbhKJNMHeMNHRJPXzy0jE02i00N0yQFl1EY1HeqioK0Kv06DRihx8oxmjWU/5NB9Wh5HDu5qJRZJ4Sx2U1/no7wjS0TSAXq9h5llVRMMJ2o93E4+kmHN2Nal4mmD/KH1tg1TODkBWJjIaY7A7iKfYgSDC95/46oQkqr179zJ37lw0mpMDpS1btrBr1y5+9KMfnXSZj6A+XuC2pEaeL11MQv2dO302Lr5lOZfcsgzfJPmN/rUVC8fZuX43mx/ZzuHX80xmzdxyLrntPM6//uwpubFn0hn2vnCIbb/byat/3p1jpsaT0C78zEpmnVOHKE5OWEPH8W5e/fNuXn36zVx3P4BWr2XRhXNZfs0SFq9ZcMpDKk6nGuoe5sdfuJ+3nlc0nufecA5f/o9bcRY5Jn3bmXSGzb/ZzqP/vi7ntDFv5Uw+e/d1zDqn/n3WPnUlyzJvv3SYR7+/PgdyLQ4TV3z5Qq78yoVTkgj4QSs6Fmfjw9tZd9/zhAaU2cPSmiKu+7uLWHX9klPyIP2xBrexWIy9e/ditVqpra3NXXx6e3uJRCLU1NS85/qrb72XwoAzg14zQQ9r1ArEUnJOlmAyKs1esgqoBFRgXFCSCJm0XMCKKk1nAHqdhMmgY3Q0jjzOFo83e6kjrNcqoHBCiYDK0mZSWURJICfDFcBoUKQM6p/oNAKpVF66YDXrGBvNOzQYjVqiyTR6rYScySIgT2B+NRrpL8IocmfAuCQiO5G5FVSNsSRAKpXBoJNIqJINrU7CoNcQHksokg5BmLDPoDC18YK/LVaDEjggK6Bap5dIpBV7M0kQ0GggHlUZbkHAZlMY8GRMsYczmnQ51hQU79hEpCAcQy8pDyqqJlin0+Qt12RZAecFDLrRpCMWToDiOYHBqCWdziJJAqlEGoPKPGu1EkaTDp1OYqB3VAnV0Ih4S+zEoylGhsNk01m8JXayWYVRHhkYw+mzMNgXxu42IWezCGKW4Z4IkkbE7jJjthroaRsmnUpjNOtwF9sJB6OEhsIIMhSXu4hFEsTCCRKxJO5iO/FogkwyTTyawOIwE48lyaYzZDPZ3MPHeGm0kvo9QjqZQauTkDQSv3rjX9Eb8tOku3fvZtGi97bxWb9+PS0tLXz3u9896TIfQX2swO2iRYvk7S/s4IU/vcHGh1/OWfwIgsCiVbNYc+sKzrpwzmljR9R2tIvNj7zMtsdeYVSNmdYbdSy7YhEXfWYlc5bVTxq4LKzISJQdT+1i6yMvc/i1vEa2qMLD+Tcu5fybllIxiTrhwa5hXln/JjvWvcHhV48zfl8WJZHZS+tZsnYRZ69dOCmODx91ybLMM/dt5YHv/J5ELInL7+TfHv8GM8+um5LtxyJxnr53C0/8xzOE1bTIZVeeyee/f+OUjrcsy+x/+Si/v+fPHNihBIaYbEauvvMirvrqRVgc5inbl/erRCzJ1j+8xpP3bqGvXQm08pY6ue6ui7noU0v/R01yH2twm0wmGRgY+AvPzYGBAYLBIHV17/2jWPP5+4mPSwQEAatp3DJLKYNWBabq2Bh1GmJRpVFrfLpeRtHCyjJkslmkLGQLxtJg0BKLq84EshKvG4klcwNqs+pJp7M5JlWrlQpkCeodOTtR6oA4bjmmAE2dRiQ5bv0lgN1mJJFIE0+k1cY3iUQ8b1lmNumIFLCaWm1B6IOsuiAUfONarYROJ5FKpEnlrM9ktYNO+a8oKGzyeCngMA8e9QYtiYTyYCBKIhazjrGRuCpSVsBsMplGFAWSiRQmo47IaDwn6rVY9YyNxAoAuo7YuFY5K6PXiyQT4/ZnMv8/e+8ZJkd5Z33/KneYPKOccxrlnJGQQGBMBsmAsVnzeO317uLnMYsXbK/tdVp7Adv7ru211xkMSARhGwRCKKEcUBplgYRQlibPdKquqvv9cFdX9wglpNFoMDrXxSWmpkN1dU/XqXOf/znRPIvGhgQZThMOG6QdD01TcVIOhqFKcqsohEIGpqnRWJ8MTPORPAvPFXiOi51yCIdNkknpUxbCv2hptIP9M0Madg45t8KGVM0yNcUhg5Rfx4uAUMQIBlsAovkhYvWJ4OdwnkmiPvv7UFQnlXDkw7keeYVhqbYjp5Dz8kLYaRdNVXDsNKap46RdNF3FSTsomvxXV2W6BorAc4T8rHoC3VBRFFV6vB0XzVDQNJ0/bPte7iePDRs2MHr0aM6Fp59+mlgsxsMPP3zO27UwPnbkNjNQJoSgYvVeXv39W6x+NVsjW9q+iFn3TWLWpyfRptPZo91aEnYqzeq/vM2C3y5l61vZJrAOPdpy/WemcN19UyjtcPnVPJBNaAv/sJzFz66k8nC2zKfPiB7MuG8y02ZPuKwZoFXHalj50jpWzl9PxcrdwXcTQOd+HZl48ygm3DKafqN7tQjxbykcO3CSxz/3CypW7EI3NL7wxGf45BdmtphNoLE2xgs/fpUXf7KAVMJG0zU++YUZ3PvYbRSWtWzma8WqPfzpBy+zealM3cgrinDbP87i1i/ObFUk13Vclr20gbk/fY33/WbR4rYF3P7FmXzis1OJ5H94e8/HmtwKIbBt+wPbq6urOX78OAMHDjzn/W984BeSIPgpAfmZpWr/bygaMWXZgU8ydU2V8ViQPSJuNiVAIFXKtOthGapvS1CJxbLDWtGwSSwTLyYkYU7mlDTomioVQeEPdfk8U1EUP4EBmcCQYwGwTF+FzAzChQ3iOUQrEjGwbanYeZ4gFNJIJjPRXyqmqclmKv/2iqIE6jQ5KnXOgc9knAXk1NA1HE8OlOETsMDCgW8TiGUH58JhXSq1mYSHqEmsMYfs5VmS3GasFvkWsVgaVVOwLB1D16iviQVfeNF8i3TaxU27uI6HFdJJJbNKbDhskshRbsMRk0QsmVXYLR07OIZCvo+2m72wiVokGhIBmQ2FDZJxOxguNEM6ti3911L5VUklJHnWVIVQ1CRWJ8mroipE80PE65N4vtc5rzBMPJaS77krsCKGvL+XJduZaXOEwAhppAMPs0I4Ism0ZmjSWqIrOLaL7ltHXDeNioaqqji2gyDncywEmqlJTdq/GBEIdFPjd9t+kPvOXxC5/eUvf0k0GuWLX/ziOW/XwvjYkttc1FY2sHjuGhb8cQVH/DgiVVUYc90Qbrh/MqOuLW/2soOLxfH3TrHwqbd446kVVB6R5FLVVMbeMIzr75/C6OuGtMiEu+d5bF+5h8XPrOStF9cFGb6arjHmhmFce88kxt44/LJGOTXUNLLxjW2sfWUjG17f2qQwoqxTCeNuGsmYG4Yx9JpBfxMRY07a4VePPM3L/y3jBMd/ciSP/O5LLeo/rTxSzR++/QJv/GE5Qggi+WHu+spN3Pl/P9HisV0VK3fzx+++xDZ/CDJaGOG2L13H7f84q1V5cj3PY/WCLTz7xKu8WyG95HlFEW55cDq3/v215BdfOCG/Sm7PQG7r6+s5ePAggwcPPuf9b7n/F9loLyBkaSR8gqN4EDK0wFKQGSAD8BwPJ+N59bNgg8cwNVIJJ0dhNIil5M+WKUsc6uoSwak2ZBlSYYVAAcU5w+HOSUjQdJmrq6hyeV9XVepzlNhI2MwOZwVkN2dJPpNc4DsRFE3JcDQsS8PQVeKNNrmfCUX1PbUZois8AuZN1o6RVYNzkx0EIUsPXqeua+TlmyRiaUkokcpsPG4HA3SGDnaO2pxXEKIhQw7JkNPsRUIorJPMSV+I5JvE67LKr2mqOI70Qjtp1yenaTRdxbR0dF2loSYevNa8wjBO2iUZtxGuRyTPwvEH5NKpNIapk2i00Q0Vw9DRDSW4v2Hpkgw3pkj7PuOCogjptEvadnBSDnmFYdy0C4pc2olELVJJB0WVSqpp6cQbUhj+xYJuqMTqk+i66pNbnURDKvhcGCGVdNJBNzQUVUU3/UFEVcFJOxiaKnmy50n1XFdBKCiKXFHwFA9V0VAU6bFGeOQVR3ly6WP+hZUkPG+//fZ5ye2TTz5Jr169uO+++855uxbGVXKbAyEE21buYcEf3mLVq5uDvOiyjsVcf89Err9vYqvx5rqux6bF23nt98tY++rmoJihqE0B0+dM4PpPT6H7oMsfKQbyb3XtK5t4808r2LBwa3alJz/MxFtHM23OBIZPG3RZ7R5O2qFi5W5W/3kjq/+ygVOHqoLfGaZO+aT+jLp+KKOvH0a3gR/MeP8oYdm81fz0H35NrC5Ov1G9+P6CR1vce/zu1oP85uvPsXGhrBNv27WMB7//KabeNa7Fj+3Wt3bx9A9eDuwKecVR7v7yjdzyxeuueF1uLoQQbFy8ned+8ho71srmwkheiE8+OI3bvziDwtIzR7Tm4mNNbgFSqdQHtsViMfbt28ewYcPOed9P/f1vqaxu9C0GEDY14rHThqAcNyAQGc8rZA+IaqiEDKmOJW0HS9eDZT/w1eCGrEIYCfsZs/7xDlmGH/0lb68bGo7jYRoarufJjFy3qb/VNFXpl/QfMxQyAgsCArnk7w9jgRwoiyfTMjLMdjENLUsEyVghnMDfChBEQGTUW9eDnKWvUFhHURRSiTSeK7D85AhNV1FVFVUhWDYHCIcM6YH1D1wk44nNKLd5Jo05EWnhqEEiLgfVvLQrPbiNKTRdlcqtoVFXHQvIa0FhmHTaxbHTOLZHJE8SfF1TEZ5A1WiidIYiBskcpVjaBnJtBHowjAOCUMRsYiMIRXSSjTnqeL6vrGaU6WjGo+v/7L/ezFBeOGKQaEii6RqKqmBaOrG6BIalo+sahqlSXx3HDMmfNZ98G6aGoigYhkasPhFYY8JhEzslLw48z0PRAKFI/66iYhiqHEz0BIqmoKjSPayoCoalk1cUobRDMR27t6HX8G4Mu2YABaX5uK6LEALP83Ach23btjFy5Ej5Hp9lKfS73/0u48eP59Zbbz3j768QPrpn+IvAh8m5rTlZzxvPrmLh06s4ekAmigTe3M9MYczM1uPNrTlRx5vPrOSNp1fw/u5s6Uu/UT2Z9RlZzBAtaJkIperjtSydu5qlz60OGrBAVr1eM3sCM++dTK9h3S57duu+TQdY+8rbbFi4hb0b9zcRJdp2LWPMDcMZc8Mwhk0r/0jGjB07cJKvXv9djh84Sc/BXfnuX/+Vsitgo9m6fCe/+MpT7N8mB4kHjO3N5390H4NayBOci4qVu/nDd16kYuUeQF7ozf7KTXziwemtpgwig+1r9vHMk6+yaelOAKyIySc+M5U7/mHmOS1GV8ntGchtMplkx44djBw58pz3ve/vf8vJk/XZyKyIzH8FOVgTjZikktJnqgRNXaLp0fAEuad40yfEhqrgOR6RiB+7lbElRC25/O4TU0PXsj5WIWTGbNoLiKkAUEHTNExD+l51TSGVyvHQZpb0MwQ6iM3KEEeLWF0yeEzL0kna/j4Kga6qcnjKJ/mmpcvWM9uPMPOVPKnU5ngwco6DacokhoxFw7A07JSLpimoKBimQiIuyaWqqeQXhkgl0oE1Ia8gRCyWQlXlU4VDOvGGrNp8duVWvh/hD5BlS3pYfZIezrNINCSD3xtWTuQaIjtgpSjomooVNrK2CFUhryBEKp6S9/EEoagp1S5P4NhpwnkWqaSLqiLJviWtHqhyqT8cNeXzZ96zwjCxHKXYiugkG1OomoZhapghg8bahD/YpaLpqiS/hoYQAsPUScZSqJqCqkiC6rleNrFClZ5aITxUVUEoHqFwiLzCCCXti+jQvYw+w3sy7NqBlLY/f65kKpVi69atdOjQgbZt2zY5gaqq2kTdffTRR7nllluYOXPmeR+3BXGV3J4HnudRsWovC/64ook3t6xDEdfdM5Hr7p3Y4hWcZ4MQgj0b97PwqbdY9vxa4r5f3YqYTL51NDPvncyQKf1bzIt6eO8xljy3iiXPreLoO9k2tG4DOzN9zgSm3jWeji2QOVxf1cDbi7axYeFWNr6xldqT2exuM2QwZMpAhk0vZ9g1g+g1rHursaCcDycPVfKvs77H4b3HKOtUwhNLvkmHni2f4ey6Hgt/v4w/fOt5ak7IYzvljrF8/kf30bZLy650ZNIVfv/tF4Ls6JJ2hcx55GZu/LtprSb6L4Pdb+/nmcdfZf2iCkCuMlx/70Rmf/mGM3r+P/bk1rabLp+DLHPYvHkzY8aMOev9hBDc+8D/UuUTDDg9S1UOaqWdbFOXacolezuZlgUFCtkIrIxiZzZVReVj5nhsLV1aH0AqeGETRZFDQem0bEVQvBwCiVw2Jsdja5g+IfaE7yc1gjgxRZEFCKmUQzKRlsNWIU2S4cw+hnSSOf5TTVNx/Mdqot7KAyV3NMdfC/jL8Qau62En01K59T2niqpgGmqT9IOMDSCr3BqS/AWeVpN4zjBftCDkk0v5vJF8i3ijjW5qqKosn2j0ya5maETzLVKJNCmf4EYLwthpBxVwUi5WxCDekMS0dDRdbWJD0E1N7l/MDqLAIgWh7EBZ0iaaF/LfH+Er1TqJWBLL7yfXdIXG2gRmyEDTpVJaXxWXz2VomGGDhpoYIFAVlUjUzNogFOmhitUn0DV5e8PSSTQm0Q0NIcDQFRlR5NtDTEvHdT0ZC4eQ3lo/TULVIZRn0KlHJ9r3bEPvYd3pN6Y7iiWorq6mvr6eSCRCSUkJJSUlRCKRc6pLiUSCrVu30rt372B40/PtDZ7nBf8vPy6Chx56iC996UuMHz/+rI95BXCV3H4InMmbqygKw6f2Z9anJ7eq3NxkPMXKlzey8I/LA08iQLuuZVx7z0Suu28yHXq0bZF9kaT7XRb/aSVL564Okh9ADqJNmz2Ba+4e3yLKo+d57Hv7AOte28T6BZubqMsgyyMGTxnA8GnlDJ9eTtcBnVq1haG+qoFv3v44O1bvod/oXvx4+bdbrFXsdMQbEjz/xCu88ONXSSVsrIjFfV+7jdsfurHF/y6EEKx7fQtPf29+UHfdrlsZ9z16G9d+akKrWXXJ4J1t7/PcTxaw6q+bEUKgGxrX3SNJbrucC4Sr5PYM5NbzPNauXcuECRPOeB/Hcdi+fTs//e8NHD0pM0h1TUNToaHBV4JPb/46PbEAgsEjJ+3hubLAIJonFUhFVdA0NYjAChIYLF0mNPhkV9OkwpsLRVUkKXNcFBQ0XcV1BXpmyR/RdMk/nKNaCqnkxjPkVQgiUZNYQyp4F0Nhg5TtYFm6VIpdTy7B51gjhCtwnZzyCK/pPgZKLvJ1mCEDO5EdvjNMDTvtoakyyUw31UC51Q2NvDyLRNyW90HaEBzHJ9q2Qyik01ifJNPsFo5YNNTGAzIcKQgRr0s0Ice5NgDDyhm4wifLddk0gki+RTyntS2wHfgE3wzpTaKyrIhOKpZGVRVUTSUUMWmsjaNqKoapYYVNGmpiKALMsIEZ0onXJ3AdDzNkSCW4No7wBIrq378uJo+VoROKmiQbU/4XkVRm7VTaH+6S1hHX8aSdwB9Sy9gJSjoU0aF7G7oP6YxeBt37dqVbt26nf1qzb50QxONxqqurqa6uJh6PU1BQEJBdy8ouXTY0NLB9+3YGDhxIYWHhWR8zQ3D379/PrFmzmDt3LlOmTDnr7a8AWu9Z+zKguep3M97c1/+0ipV/fZu0f2FeWJbPzDnjueHTk1tNCxrAkXdP8OYzK1n8zCpOvF8ZbB88qR/X3z+VybeObjFvYtp2eHvRNpY/v5bVf9kYFFYoisKQqQOYPmcik24b3WIe0urjtWxZup3NS7azdflOjvsWlAxKOhQzYno5w68dzIhryynt2DoSNHLRUNPIF0Z+lVOHqpj9yC187nufuqL7c/JQFb/8l6dY8dJ6ADr36cDnf3QvY28c3uIXCkIIVv/1bX7/7y8Gtb5d+nXg01+7ncm3jW51iRoH9xzl2ScWsHz+BoQQaLrKjNkTmP3QLDr2bHuV3J6J3AKsXr36jOS2vr6e7du30717dx5/Yjm7dh5rmv+adAKlzNAUEgmHM35G/afUVSWboIBvO8jx2JqmSiqd8ddqWJYhq3A94RM3Dcdxmx5hx/VzY+XzGL4dIbMbpqXL4gRVLqGbhirJK8hIs4IQqVQaJ+3iOR6hsPlBFTWWJdyybjer3GYeJwNDU/GE16Rq2AobqKqC62fLGoaKk/ZQNRVNU9F0hUSjLauIFUVO+zemsmQ0YjQhoxFfuc0grzAsJ4IzZDY/JH/v72PYJ8eZXY1ETWJ1PllVZLRWMpaSwydC3t9OpRGewE070kaQcFBUEK5UtxONdvCFFI4a2ecDzIhOqjGrdkcLwsTrE8GVp9y/pExqsHRCEVki4bkehqljhDRidQkUFFRVqqvplIthGMGwomO7vo1B3keSWYVwnkV+cYTi9kV07tWePqN6Uj6lH/mF2cnTZDLJtm3b6NatG+3afTiy4XkeDQ0NAdl1HIeioiJM0+T48eMMGTKEaPT8U67btm3j85//PL/+9a/PuWpyhXCV3F4iGmpjLHl+Ha89tYL3dmarpwdP6Mv1901k0k0jWo2n0/M8tr21mzeeXsHKlzcEMXzhvBCTb5O2hfKJl6+Y4XSkEjbrX9vC0rmrWbdgczBoqhsaI2cOYcodY5lw86gWnXw/duAkW5ftYPOS7WxZuj1YZs+gY692DBjbhwHj+jJwXB96DO7aKlTA7St38/C138bzBE8u/Rblk/pf6V1i46Jt/PzLfwiazsbeOJx/+q8HaHsFbDyu67F07hqe/v58jvkXMD0Hd+Vz37mbkTMGtzp1/tC+Yzz75AKWvbgez5PWzOl3jeNffv53H29ym06nZXzSaTid3AohOHToEEeOHAlO1l99ZB4V2w7LGyh+9FeOdzVonc3EYQlJhILPhj8YJFBQECSTDhHLkKqpf5u8PIvGHLKr6wqOI4LHVDUF13azHzhFLrNbpo5ru6RS6YA4Zp44EjaJxXLSESIm8ZzkAMtSs0kDQvo9U0lHqmueIBQ2SSXTfkqAhvC8JjFZmj+RnyGzSuYYnI6cFjMrbEhLgA89s8+e3KlQxJB2DcXPzbV06Yn1H6OgJELa9nDTLnbCJq8oTLwxhRWSaQGartJYE0dRFKyIgRUyiNUlpO9VUSgoDmMn06RtB9d2ySuM4DguqqKQttOYlkGiMYkZNmRUlqbSWCsHtjRdQzekTUFR5HCXGdKJ1SbwHBdV1wjnh6Ty6k9Hh/JMUrGUvBAyNML5VpBeYJg6uqWRaEgFM3hmSB4fGbPmYZo6mdAtBdAtnVDYoqhNPiUdi+jctwP9RvVk4IS+gfXhbGhsbGT79u3069eP4uJL72V3XZcDBw5w5MgRLMtC0zRKSkooLS2loKDgjIRgxYoVPPLII8ydO5f+/a/8yeYMaF3f6JcZl4PcZiCEYPfbB3jtqRUsn78h+LuP5IeYfudYrr9vEn2Gnn3loKURq0/w1kvrWPiH5exan20Aa9etjGs/NZGZ906iYwv6N2N1cVa+vJ4lz61m69IdUlhAehBHzhzC1LvGMeHmUZet+vdMEELw3o7DbF5cweYlFWxdvrPJAC3IxrZ+o3szcLwkuwPG9qHgAqbeLwce/9wveOOPy3nwB/dw98M3X5F9OB1p2+Gv/7OIp77zIrG6OFbE4t7HbuOOL7e8VQFkqsbCP77FM//xZyqP1gAwdMoAHvj2XQwY07vF9+d8OLr/JM/99DUWz11D2y6l/H7j96+S2/OR24wNwTAM+vfvj6bJq8+v/+sLbNp0UE6QCyGTDHL8sJap47mCtJ2tfc2N5AIwdUjn1OtGoiaxWBpNVfwIKZOYr/gpqkI0zyIZT+Ok/UxVRZHqZu7xPy1ezLQ0GZmV8dhGTBJJB01TMEOGzHytjQXDX+GoQdr2EJ6H63iEQrLqNrAlhGTGbDbX1ueY3hk8t8jhOgDhZFvMIhEToSg4qTRp39NqpxyskOEP3nmy5ABJ4K2Ijp2UObQIgRnWcfzj5nly8C5QboUgWmBllVgySm7WHx2UHmTSDSIGKT91QkEOlsg0AmnlMMMGsZo4mqaimzpWWKfBtwlYYWkbSDSksFNprJCBFTGJ1cXxHA/D0KRntz6J61crR/JDJBoS0kKiKqi6bCpTFTlcZYV1aYvwfdl6SMNNCzxcCorzaNO5mLJOpXTp14HyCf3oNbz7RV1RV1dXs3fvXgYPHnxB6uqF4NChQ5w8eZIhQ4ZgGAa2bQeqbl1dHaFQiNLSUkKhEGVlZbz66qs8/vjjzJ8/n86dWyaS6SJwldxeBsQaEix/aQML/7SSPZveC7b3HtKVGz49mWvuGE20oPXkcB7ae4zFz65i8bOrOJkToTV4Uj9m3juZybeNJpLfMmkLADUn61j18gaWv7CWbct3BauQVthk3CdGMPXu8Yy+fmiLT8C7jsuBivfZuXYfO9fsZde6vRzbf/IDt+vct0Og7vYd2ZNuAzu3yL4+/+Rf+d+v/onb/vkGvvjEZy77830YVB2r4Rf/74+89eI6ALr068g//tcDDJ826IrsTyph8+dfLGJuTvPa+JtG8Nl/u7PFIvQ+DI4frKTyWA2Dx/e9Sm7PRW4zNoQePXrQoUPTCr3vfmM+a1e9E/xsmhqptCvJps/jRA7h0HUVy1BJJR3pxVWykVaZHNho2CDemFsW4Cu5mSl9XZY0gLxaNnRNLpU7LjKuQObOmoaOAqT8dATHb9MCP9A/p80qErWINyYD5TYSzSksyCi3KQfPkYTXtAzSjosVMtB8W0WguvrKpfBcnLQXKJWygozgdaiQtTKAHFpL5PiAMx5Y/5PTRNn1ya2dcIL75xWGaMwZ7ssOlPk2hnzLfzw/HSHXYysgFDVI5NoGCkNBGgHIIOlYXdy3EehE/PQEJ+1ghgxCEXnM3Kec8zUAACAASURBVLSDYWqomow5E56Q3umISaIxgaZlortMUomUnxQg1VrHdvGEtJQYIZVQnkVx+2K69O1It0GdMNrC2EmjKShonpab48eP8/777zN06NAmPtmLhRCCd999l3g8Tnl5+VmXbDN+3d/97nc888wz2LbNN77xDW655RY6dep0yftxmXCV3F5mHNh5mNefXsnieWuDk6gVNpj0yZFcd89Ehkzs22qWRDO2hUV/WsGKl7PqsxU2GX/TCK6dM5GRM8pbdBm++ngtK+evZ9m8NWxftSfYHopajJk1jEm3jWHsjcNbVNHNRc2JWnate4dda/eyY81e9m58Vw655kBVFTr2bk/3QV3oOqATXft3otuAznTs077ZyiVOHDzFd+f8hD0b3+W6+6fy8G9aVVlMgI2LtvGzh37PkXeOA3DD303j8z+894qVLjTUxHjhpwuY/7OFpOI2qqow877J3P+N2ylrhf7qj73n1nEcXNf9wPZVq1bRuXNnjh49elbP4JM/eJUli3Zimjq6pqIgpC80Az9DlJzyAk1pSuoyw1qZxtponkki7gRNXbquBINRIP2yaduV9obM85yu3HKaOmzKWC2EAE9IchtPo/qZr5oqaKxLBTFceYUhbNtFeB5p28Wy9CaWAdPSm3wpyaQv0YS8NhkYy7DmzD4pMk7MTjlSzQVCeVZwXNIph1BEJxFzsCzZiqVpSpBuYIQMXz1OkfaHtvIKQ7iOHMxLxaUtwU45aJqG6zgYpk68PolpGSgqgVqtajL5IBQ2aKiVHlhNlR7fhtp4YHvIK44Qr0sihPSzhqIWicYEwpNJA6al+2RZxmdZIZN00kFRlcCqkCldAA9Nl68rUhCmuG0hZZ2L6dRb+mEHjOuDaRkkk0mqq6s5cuQI9fX1lJaW0rZtW0pKSgiFLv6LXgjBwYMHqa6uZsiQIej6pS95eZ7H7t27UVWVfv36nZeEeJ7Hk08+ybp163jsscdYtWoVR48e5Sc/+ckl78tlQutgVS2EK0FuM7CTaVa9sonXnlrBtlV7g+0derTh+nsmMnPOhBar0L0QxBsSvPXSet58ZmWQGwpQ3LaQaXePY8Y9k+jVwjaLk+9XsmzeGpa/sJZ9mw4E282QwejrhzHljrGMu2nEFSO6IJfh9289yM61e9m1bh8Htr/Pod1Hm9QE56Kscwmd+3SgQ892tO/Rlvbd29KmUwmlnUoo7VCEeRb7led5VB2t4b0dh3jtt0tY/fIGPE9ghU2+v+BRBk8acDlf5iXBTqV5/olXeOb780nbDmWdSnjoZ59j7I3Dr9g+1Zyo45kf/ZlXf70U13Gxwia3/9Ms7vryja2q7ewquT0DuU2n06xYsYI2bdowcODAwIZwOn75k0X89cVNwVlP0xTcTORVboGBf6JXVIW8qIXjeKSSNsLza10T2XKCvDyLxrpEtggiZMhkg0zMlqpkeazvP1UE2LZvO1AUDFMupSuA7Su36UyuraJIq4O/ZK8AVlgnlRkYE0IOjCWyP8vq2OwSv6ZroAg0XUO4Hq7jyIB/BUkeFUE65QYpDqpPHjOpCsL1MC0NgYKmqjiOi6YS1L9quoZhKsRqpadW1VSsiLQhOGkX4XrkFUWwU2mfDLuEogZ2XNbrCiHTDhINSRmt5cdj1VfFMEwN3dTRTenBVRUFw9Qxwybxuhiu66FpGqGoGahHqqoQLQiRaEgGA2+GpZOM26j+e2uEdOy4jee56Lr03LqOzIgNRS0KyqIUlhbSrnsZ3Qd3pXxyH9p3PbdPTwjB+++/T1VVFeXl5aRSKaqqqqiursa2bYqLiykpKaG4uPiCCaoQgj179uC6LgMGDGiWgRjXdamoqKCwsJDu3c9vj3Bdl0cffZT6+np+85vfyKG41o+r5PYK4Nh7p3jj2dUsenZ14PtTNZUxMwdz/T0TGT2z/IrFOZ0Jxw+eYum8Nbz5zCoO7z0WbO9R3oUZ90xi2t3jKO1w6b72D4MTB0+x8uUNrHhpPTvXZC8WzJDBmBuGM/n2MYy5YVirsH/YqTSH9xzlwPZDvL/7CId2H+HgrsMce/dE0IJ3NlgRi7yiCJGCMKoqy2hcx6PqSHUwEAjy/DX1rvHMfuQWepR3udwvqVlwcOdhnvj8r9i9Xq4UT71zHF/66WcpatM8q3gXgyPvHOe333yelS9vACC/JMqn/uVmbv7CzFYR83eV3J5Gbuvq6tixYwdCCEaOHHlOheyP/7OM559eGyhzmqbIYgAvS2izJFf+aOhq9o9UCKL5Fo31iSy5LQgRa7QJhWSagKoglVsfuikjnYSbc0g9r8mZV1GUrB1ACMJ5plxyz8RUhQ3slIuq+XFjIY2GmqxNoaA4guN4pFNpX0U1SSVkZaxk1iKI4MKPLHMzubmnI/dz0SS4X8Fzssc9FDFJNmZfZySvaWNXKM/M5toKQThPelYzrzeSZxGrT6Jpqlz2D2vE62RJgW5oWGGDeJ1s5NIMDc0AO54GPypNDpjF5c+qguk3gOm6jqJK0m77NgIUxW+Cc4MLDiOkoVk67TqV0bZrKV0HdmHAmJ70Gdnzogik53ns2bMHz/POSEJd16W2tpaqqipqamo+MLR1JoLpui7bt28nLy+Pnj17NssSbzqdDsoZLsRSYNs2X/jCF+jcuTM/+tGPWl28zDlwldxeQbiux+ZlO3ntqRWsfX1rkDBT1Caf6XeO47p7J9K9f8crvJdZCCHYu+kAbz6zkqXz1tBQHQPkd9WwawZy7ZwJTLxlVIv6cwFOHa5i5fz1LH9hXROia5g6w6YPYuItoxn/yZEUtz17bN+VgOu4nDh4isP7jnF8/0mOv3eS4++doupoDZVHq6k+VhvUKp8JhW0K6NSrHcOml/PJv5/ZKmPKzgfX9Zj/X6/xh2+/QCqeorhdIV/5379nzKxzN6lebuxct4/ffGNeYIXp0LMtn/vObCbdMuqK2og+9uTWdV0cx/lAGsK+ffvo06fPOYdsXnhqNX/82bJgiEqmI8hGK823KTieaEL68gtCOGkPJ+3gpF0ZYZVjZcjLt2iszSYZ6EbTwgVVkT5ef/YL3U8mcFJNiaLiN2slEzahsC5jqlQV3VAxLY1YbTJQlc2whh13yLxNsjAh6/O1wgap3DQEQ8O1nabEFXIsCZm4CBVVVfzXIiQBRl45myENO54OtoULQjgpeaHhpl3CUctXZmVEbiikBTXDQgg5QBb4hAXRItnYpWoqqqYQzgvRWBML2rk0QyXZaKNqsjLWCksynVG4ZRpByrcRqL6NQPqUhfDQDV0O9BWEKWyTT2mnYtp3b0vPIV1RSjwKS/Lp27d5ooEcxwmU0B49elzQF4Rt24GqmylZKC0tDUoWbNtm69atdOzYsdl8rclkkq1bt9KzZ0/atGlz3ts3Njby6U9/mmuvvZZ/+Zd/aTX+yQvER2pnLxWtjdzmouZkPW/OXcOi51bz/p6sOtpvRHeuv3cSU28fTbSFSeO5YKfSrH99C0vmrmH9a1uC5raMP3fGPZMYMX1Qi8dknTxUxYqX1rHqzxvZsWpPMIymqgrlk/oz8dbRTL5tzBWpqv2wEEKQjKVorI3JFTch/HOBSkn7ola1XH6pOP7eKR5/8H/Y9tYu4Mp7cUEe//ULt/K/jz3LIf9vcuC4Pnz+B5+6YskKV8mt65JIJNixYwemadKvXz80TaOiooJu3bqdc3hnwQsb+eWPXgck4dNURWahiuyZsKkfVXpNU5lEBSHILwjRUBeXmWGKLHFIJGwsS0cgEJ7nE0+CZX/Az6DN1r/mHmFVzSl28NXhWM4AmRXRScWdQFUORYwgx1bVVExLIZV0Az9sOGr5+yJIJW00VcXzBGbIQFUgnUr7A2tghUw0XcVxHGw/YcG0dIyQtBWkEjZ4HpGCCMLzPbKJFKGIhfA8FFWVpBIPNy0HrWRAs7QZ6IbmR4fpcoBMlQcmU6qgGyqaqmKGDJKNKVkogZCNXQ0JX3mVjWBp20XLkNmQTLbQDI1w1KKgNI+itkW071FGt/IuDJrYj7adm9Yj2rbNtm3baNu2LV27dr3wD905kMmb7dKlywcGGC8UQghisRjV1dVUVVWRSCSwbZvOnTvTrVu3ZrEBNDY2UlFRwYABAygqOr//saqqijlz5vDggw/y2c9+9qNGbOEquW11EEKwd/N7LPzTKpa9tF6u9CAvxiffPIqZc8YzuAWzaC8EDTUxVvgxXrn+3JJ2hUy9cxzTZo+n74gLu6BtTtScrGPtq5tY9fIGNr1Z0cQCMHBcH8Z/ciTjbxpJl/4dP4p/u39zcF2PF3/8Kn/41vOkbYc2XUp59I9fonzilY1RdNIOr/1+OU999yXqKhsAmHzbaB783hzadzu/ANKc+NiT25qaGrZs2fKBNISdO3fSvn17SkrOftX61sLtPPHYS01fnSL/033vpyLIflEoCgVFYRzbxbbTuLbrE8+cMoLTkgx0Q5Xh/LnDWqpymkoqwM3+Lhq1SKddHFsmHEQLQiSTaTRdqqiGrgfDWWZI95MDbDkkJgSR/JD0tuLh2LIlzLFddENW16Io2HG5z6omG7cQ4PhqrqZraIaCcOXQgBCCUMQEIfA8gZ1ME4oYMlFCVXDT0iLhOZ5PjF10XSGd8tAN+diaoQae10wubrzej+pSFKyoQTqR9nNg8cm0AygIz/VDhhU0TcMwdSKFYcJ5FtGSCIXt8sjvFKH7kM70GNCN0tJSCgsLz/klHovFqKiooFevXhekWl4IMm1e/fv3b5a8WcjabLp27UoymaSmpgYhRGBhKCws/NAn/9raWnbv3k15eTl5eedvRzp8+DBz5szhW9/6Fjff3DoyJS8CH6sz+keB3OYiGU+x8pVNLHx6FRWrs8vt7bqWMmP2eGZ+agLtr0Ag/rlw4v1KFj+3msXPrOTwvuPB9o692jHt7vFMnz2ezn0u7gL3UhCri7P21U2snL+BDQu3NBke7tS7PeNvHsnEm0fRf2wfNK31XDh8HPHejsM88X/+hz0b96NqKvf/253MfuTmK/6+xOoTzH3iFV7+2UJSCRvDMrjzoRuY/ZWbWmyI8WNPbuvq6nBd9wP2g71791JcXHxO4rJxxV6+88/P+oNdOoof+C9yqnYz7WAZdTVQSTMRVgVNI6yskI7teGiaguIJBD5pRC6dy0ayrCqKItuwPFf6khzbCYbQNE1FCBmzlchtICsM01CTbe8KR62c+l2pcqZzvtAMSyedE9OlasoH/U2n+W0VFTKGBM/1ME3Vd0HIul5Vl/EQmqbK6mFNwUu7CL/SwjB1edwUged4WGGZPoAi1WwrYuLaWeXasAzctIsnQFUziQom4cIQakjQe0hP+gztSb8xvejYq/0ZiWsmj7WqqqrJ0n5paSnhcHaZM5MNO2jQIPLzmyeEvKqqin379jVr3uypU6d49913GTp0aJP9T6fTwevMzZ0tKSkhGo2ek9SfPHmSAwcOMHTo0AtKbNi1axcPPPAAP/vZz5g8eXKzvK4rhKvk9iOCo/tPBraFU0dqgu3DJvfnunsmMvGm4S2e+3ouCCHYs3E/S+etYfkL66g5mW366juyJ9fOmcA1d46jqG3LDw8lGpNsfGMba/66kXWvbaGhujH4XXG7QsbdNIKJt4xm2LRBwariVbQsnLTD774xj+effAWAoVMH8tXf/0OrsJOcOlLNb74+l6Xz1gByheL+f7uD6z495bIT8I89ufU8j3Q6/YHt7777LtFolPbt25/1vnu3HeKR+379Qe9pAJEdtkL6Z6P5IVLJNMmEDZ4gryBEImZjGBqu56HgyfxWfE+t6RPNJklfosm/GdUzg1BELslnYEUNWf2aIbN5VpNGsVBYJ9loB7FVoYhBvCGJEAJFk3Fh6aSD57oIT6DqajbO7PTYlsy+KZLIKookt4Yfbaao4KU99JDuZwHLjF5NV3BsL4hEM0OGrwSDEB6hkBnUDCuqVHI1VSOUZ5Ffkkdp52Ladiql66BODBzfl3bd2nLkyJHAQ/1ho7MyS/tVVVVUVVVh23aw/F5fX99s2bAglc1jx44xdOhQTLN5TrqHDx8Oqm/P95iZ3Nmqqiri8TgFBQWBspt738xjDh069IKsDevWreOhhx7i6aefZsiQIZf8mq4wrpLbjxg8z2PLit0semY1q17dHCiQ0YIwU24ZxcxPTWDA6OYZrGwuuI7LluW7WDp3Nav+sjGwWqiayvBpg7jmznFMvHnkFfFXuo7LjjV7Wf2Xjaz+y0aOHzgV/C6cF2LkjMGM/cRwxswaTnG71jWQ9nHAxje28p+f+x9qTtRRUJrHN577MkOnDrzSuwXAjrX7+NW/PsPuDbLhr+fgrvzDE59m8MR+l+05r5Lbs5Db9957D8Mwzjl8c+xgJV/8xE/9ASkd4QnSyXRW1VQUrLCGnXCC9IJwXtNYrWh+TpOWEFgRU2bK5pDEjELrT1MFKqmmKai6hqYrJGM2uB6KppJXECKdcnBsB8d2iRaFSadkI5nrehimRmNNPFCCdf9nzy9osMIGdjId2BTCEQtXeHh+goKmydxZ4VsuhOdJIqzInRUeGKbqlwoDnocZMhCePN5CCAxTC+p5XddB01UUoeAJD13T0EwFz5HxLpF8i4I2+RS3K6JDj3b0GtqFARP6kl98ZtVUCMHevXtJpVIMGjTorFFuHwaO47Bz504aGhrQdR1d1wMCmJ+ff1EnyEzpQSwWo7y8vFn2UwjB/v37aWxsvKjHFEJQX18fDKe5rktxcTGpVArXdRk8ePAFPeYbb7zBv//7v/PSSy/RvXv3i3w1rQqthwG1AHr36C9uHPL3zJo9lqmfHEE0/8rloTYHGuviLH9pA6//aSX7thwMtnfq2ZYZc8YzY84E2nRs2Yiu8yEZT7F2wWYWP7uKt9/cHpxXDMtgzPVDmHb3eMbMGnZFVGghBAcqDrHqzxtY9eeN7N92sMnv+43uxdgbhzPhk6PoMbhLq7qA+FtGzYk6fvR3P+ftRRWomsoXHv80t/zDda3i+AshWP7COn7zjblBu9+0u8fz4PdmX5YSiKvk9izk9tChQwghzjkoFKuPc++Y7zTZphua9Mj6rWdWxGySsWeFNVKN2efLKwqTSsjMWyflSGKZ9rBC0ubgOa4ku34eq25q4Mm8WM9xUTWVSL6F68gM2HQyTSQ/hJ1Mo+kqeKCbKrG6RDbz1dJoqI7LlACfzKbiKZKJNLquEI5aOGlXPl7KIRw1QcjlbDctfbEKsozCc1xUVUEg5GwXirQkqNkeB1WRaQXCFSA8qehqCsIVCMUjlBeiuG0RRaV5lHYsoXP/jvQa2pU+o3phmB9uqSuTNFBQUNBscVeZCK1oNEqvXr1QFIVUKhWonQ0NDeTl5QUWhgtRdF3XZceOHYRCIfr06dMs++l5Hrt27ULXdfr2bZ42p3Q6TUVFBalUCkVRMAwjeJ15eXkfeA4hBHPnzuU3v/kN8+fPp23btpe8D60EV/7s0IJoX9JVDC+8E5DpK1NuGsasOePoP6xbqzhRXgre232UxXPXsHjeWqpPSAuAoiiMmDaQmXPGM/6GK0MYz4X6qgZW/nkjS59fS8WK3UGyQaQgzMSbRzF99niGThnQ4okLGZx8v5K1Czaz/rXNbF6yg3Qqe45r162McTeNZNwnRjB4cv+r9oXLDNf1+P035jL38b8CcP1npvJP/98DZy25aGkk4yme//GrzHvyVTl/E7WY/fAnufOfZzXrPn7sya0QAtu2P7D96NGjJJNJevbsedb7ep7HneVf92O/wLbTGJpK2nbRLR3D0DAMjYa6eJBLW1ASIZ1ycB0XO+VgWhrpRBrd1GWuraoEtbCZGCvPlUv3wpVpAoap4rqSWHpu1n+qKHKfVE3BSckBsEzsVUNVA5quoRsaobBJrCGBY7uYlk4oYvpKrY2mqVhhaQFwUo7fyGXICwAPQKDrGsIfDlMUZHqC4qGioirIgTffOwtC1gFHNKJFUUraFdGpV0c69m+PyEszesqIZiNA8XiciooKunfvTrt25y5IuFBk0gs6d+5Mx45nztEUQtDY2BhYGBzHobi4mNLSUoqKij6gdGZSFtq1a0eXLs0TIu44Dtu2baO0tJRu3ZqnDSlD6vPz84NIskxrWlVVFY2NjQGpD4fDFBUV8fOf/5xFixbx4osvNpsfuZXgo83oPiRGjhwp/vPrv+T1ueuoWPdusL1b3/Zcf/dYpt82ksKS8w8Ttma4jsumZTtZ9Owa1uREdGVsC9fOHsegsb1bHZmvPFrN8hfWsXTeGvZtfi/YXtSmgMm3jWbqHWMZNOHKpUQkYkm2LNnB2lc3sfbVTdScyHqIrYjFsGsGMnrWMEZfP5QOPf5mLn5bHZbOXc2Tn/8VqYTN4Mn9+faLXyGvqHnmOZoDxw+e4lf/+gyr/vI2IPNx//HJ+xk1s3ksbFfJ7VnI7cmTJ6mrq6NPnz7nvP9tfb+KcD0ZBaZl8lRT0oagQF5BOPCvCk98wJYQihgkG7L+WM3wSx6alB8EOytvo2d9vCCVWTclM1lRIByxiDck0HXNb/cyZBuX39SVSRoQnqySNSydVDyF8DxUTUPXNWw77ZdRyB2QX/CysAEF2cSlaSiKgq5rWFGTvKIoBWV5tOlSSvvubeg9ohd9RvXA8q/GkskklZWVHD16lIaGBsrKyoJEikuNp6qurmbPnj0MHDiQwsLm8XtdbHqB67rU1NQEBQumaQZqp6IozZ6ykEql2Lp1K127dj2nR/zDIFPO0L59ezp37nzG2+SS+m9/+9usW7cO0zT54Q9/yMyZMy8oSeEjhNbFcC4zcj23h/ef5PXn1rL4pY3UVsmBIt3QGDejnFmzxzJ8cuuK27oYNNTEWPriOhY9t6aJbaFDjzbMuHs8184e1+rSFgDe33PUH0Rby5F3TgTbyzoWM+WOsVxz17grEi2Wged57NnwLmv++jbrX9/6AftC574dGHvjcMbcMJzyif1aRbPV3xLe3fIeX7/1P6k6WkPPwV353itfbfGGvPNhy7Kd/Pzhpzi46wgAE28eyef/455Ljg67Sm7PQm6rqqo4deoU/fufOzfuzr6PBGkG4JPVWNYzG4lasmwAQECkwCLmx3DJpANLkuGMj9bQ8FxPHrDcYa2M99bzUP2EgUygrmlp2ElHFiaoKqGIQaIhhW5K8mmGdPmzrkoyauqkEkm/OlZBN2Wig8+NUTTAA094CAShsEUoZBLKtygoyae0cwltu5XSa0gP+o/rTX7xhZEYIQQHDhygtraWQYMGkUgkqKyspLq6GkVRAgJ4toats+FSBsfOhkzSwJAhQ4hELm14I5lMUlVVxbFjx6irq6O0tDQg9Zc6QNbY2Mj27dvp169fs8WHZcoZevTocUGqejqd5stf/jKGYXD77bezZMkSotEo3/zmN5tlfzJwXZdRo0bRqVMnXnnllWZ97AvAx5bcZuCkXdYt2cEb89azcdkuOVQKtO1UzHV3j2HmHWNo26l1nTgvBgf3HGXx3LUsnreWquO1wfahk/oxY854Jn5iBJFW5kEWQvDu1oMsf3Edy19cx4mDlcHvOvZqxzV3jmXK7WPpPqjzFVWiq47WsOGNrWx4fQubFm/3WyElIvlhRlxbzqjrhzJyxmDatXAu6t8qThw8xaOf+A8O7z1G+x5t+I8Fj9GxV/OsbDYXnLTD/P9eyNM/eJlkLIUZMpj9lZu4+/994qKtCh97cgtS+TodtbW1HDlyhEGDBp3xPnJZ3uO+wV8jnZLxX67jYkUMnJSLpqty6t8yaKz1m7I0OfxlJ2Uzl6aphKIWji1tCk7KQbc0OYglBJ7ryaIGTUERchueVImFm22K0HUF4cmJWuEJQhEjm00oBEbIwEk6wTyaZiq4judH8ioYIQMzZBDOk+UFBW3yUKPQo7wb42eNpl2XS186ynhMLcuiT58+H1B6Mg1bH8bDejkGx4QQvP/++1RWVjJkyJBmKTwAOH78OAcPHmTIkCFNXuulZM7W1NSwZ8+eC86bvRBkyHL//v0vqJwhkUjwwAMPMHLkSL7xjW9cVgXvySefZOPGjdTX118lt5cZ50tLqDxey6LnN7Bw3jpOHK4GpG91+KS+XHf3GMbPHIxpfbRVONf12PLWLhY9u4bVC7JpC1bYYMInRjBj9jiGTRlwxTNFT4cQgt0b3mXZvLUsf7FptFiXfh2YcvtYptw+hu4Dz7wi01Jw0g471+5j/YItrHttMwd3Hm7y+0692zNixmBGXFvOsGmDiBb87bSMtTTqKuv5+s0/Ys/G/bTrVsaPl32rVUSFnY7Ko9X8+mvZ6LDOfdrzTz/9LMMuIvXhKrnlzOS2oaGBAwcOnDHCSAiB67oIIfjssK/j2A6KqiJc6XdNNKYwQzqqpmGaqkwicAWaqRKOWqQTaWxfKQ1FTBzbxXNdHNtFM+QXpfAEwnURQtoOhFAQngcCdFPDdVwp5goPK2Lhpj0UBEKAGdaDOl5FkUNtuqERLYiSXxqluEMRbTuW0HlAR3qP6En77m2Cq/n6+np27txJ7969KStrnmW4RCJBRUXFOX2rpx/fhoaGgAB6nkdxcTFlZWUBAUyn02zfvv1DVdSeD57nsXu3HNYYMGBAsxA1IQQHDx6kurqaIUOGoOtNT/iO4zTJnLUsi7KysqA292yv68SJEwFZbi61ura2ll27djF48OALIsu1tbXce++93H333XzhC1+4rIrQ4cOH+cxnPsPXvvY1nnzyyavk9jLjQqPAPM9jy6p9LJy3jtVvVMhhWiC/KML020Yya/Y4uvdr+SKC5kasPs7y+RtZ/Pxadqx9J9he2r6I6XeNZcac8XTrd/7vtpaG63pse2sXy19cx6q/bKS+KptT221AJ665axxT7xhLp97NY2e6FJw4eIoNC7ey6c0KNi3Z3qTMSNM1Bozrw6iZQxh13RB6D+/+kbfCtDQSjUm+Ouv77F7/Dt0GdOKJRI/XnwAAIABJREFUpd+koJX65itW7uan//y7oMp3xj0T+T/f/xRFbS486/kquUWqhqfvfzweZ/fu3YwYMaLJdiEEjpPJoVV4YMhjJGKy5hWkitpYm8AwdTRdlcptXSOeK2tozbBBKmbjpKWNwLAMnFRaDmfh+2ld12+Vle1fquonCyD7shVNwUmlAYGiqqg6mJZJXlGEorYFtO3ahjadSuk+sDN9RvWk5AI9NseOHeP9999n8ODBl7wUn0FNTQ27d+++4JrWMyGXANbW1mKaJvF4nO7duzfbQFYmFaCkpIRu3ZpnIjxDlgH69+9/QV/G8Xg8IPWJRILCwsKgYCGjIh88eJCqqqozkuWLxalTp9i/f/8FlzMcP36cOXPm8PDDD3P33Xc3yz6cC3feeSePPvooDQ0NPP7441fJ7WXGxeTcNtTGWPLyJt6Yt479u44G2/sN7cp1d49h6k3DiRaEz/EIHw0ce+8US55fx5vz1nAsJ+u17/DuTL9rLNfcNvpDnYRbCk7aYetbu3nrpXWs/PNGGmtiwe96D+vO5FtHM/m20a2C6LqOy56N77Lpze1sXLSN3evfkVY8H4Vl+QybNoih1wxi2NSBdOpz5mKeq2iK+qoGvjL93zm46wgDxvbmiSX/hm60zhUWO5XmhZ8s4Jkf/oV0Kk1eUYQHvzeHWZ+ZekHv9VVyy5nJrW3bbN26ldGjRwNZG4Ln+VFW/sF9cPhjNNbGgwQB3VCJ1yd9squgqp7vh9VQ1Uwpg/T4Kqokr54jUBQ5tKWoCk7axjBMGaOlKlhhHSsaIVoQprAsD9dI07FXB0ZNG0afET0JR0MfWNbPz88PlvXP5+v0PI99+/aRSqUYOHBgsxGmw4cPc/To0WZVF6uqqti9ezdt2rShsbER27aDZILi4uKLsiZkUhYu1GN6IcikF1wKWfY8j7q6uiBzVlYLC3RdZ+jQoc1iwwDpWc6USFyIDeOdd97h/vvv5/HHH2fGjBnNsg/nwiuvvMKCBQv4+c9/zrJly66S2xbApZQ4CCF4Z/thFs5bx9I/bwqKCExLZ+KsIVw/eyyDx/b6yCtvQgh2rn+XRc+u5q0/Ny1cGDltIDNmj2fcrKGtLlYMZC365iU7WPbCWta88naw7yAD9iffPoYpt42+IvW/Z0JjbYwtS3ewcdE23l60rYmnGKCsUwlDpw5k+PRBDLtmEG1b4fBfa0HlkWq+PPVbnHy/kvu+fjv3/9udV3qXzokj757gZ//3D7y9eDsAw6YO5KH/foCOPc/tG75KbjkzuXVdlw0bNjBu3LizEluAfxz/TaqP10obgcjWxArhyZiusOGnH0gyq+mqzH/1EwgyNbGhqEl+aR6l7Yso6VJK134d6D28B+17tA2er6GhgR07dtCzZ89zkrDcIP6qKhmWXFJSQllZ2QeGtWzbDhTL7t27N5tiuXfvXtLpNAMHDmw2EpZp8hoyZEjgw3Vdl9ra2oAA5iYTnK9KFrJL8YMGDaKgoHnUlsxAVrdu3ZotvcB1XbZt2xZkzZ6rHvhCkRnwq6+vv+Byhs2bN/PFL36R3/3ud4wcOfJiXsqHxqOPPspTTz2Fruskk0nq6+u5/fbbefrpp1vk+X1cJbcXgWTCZvXr23jj+fVsXZNdzm/ftZTr7hrDzDtHU9b+4lZ0WhNSCZu1r29lyfPr2LhkO67fGBnJDzH55lHMmD2OQeN6t0pCn0rYvL24gpXzN7BmweYmdoCeg7sy9Y6xTLljzHnJREtBCMHhvcfYvHQHW5ftYNtbu6irbGhym4692jFs2iBGTC9n6DUDKSxrfUr6lcTW5Tt55LrvoagKP172TQaMPXcq1JWGEIJlz6/l5w8/RX1VI2bI4L7HbuOOf551VuX5KrlFLkl7XtMaWSEEa9asYfz48YG/9nRiC/CVa77D8QOnEJKxYoYN7ISNwCMcCRPOD2FZJtHiCIVlBbTpWkLnPh3o1K8jPYd0wbQu7Ko+YxkoLy8nGv1wWXXpdJqqqioqKyuDYa2ysjJM02Tfvn3N6q/NkOVM3mpzkeV9+/Zh2/Z5yXImmaCyspJ4PH7GZf0Mjh07xqFDh5pVWc7Eh12KDeN0nCmWK1MPXF1dTWVlZVAPnFGwz6e+CyHYs2cPnuddsGVi+fLlPProo8ybN4++ffs2y2v7sLiq3LYMLkf97vFDVbzx/HoWvbCBymMyhUBVFUZM7sfMO8cwbmb5R34IDaC2soHl8zeweN5a9ubk0LbtUsq0O8Yw/a6xrdKfC3IpeNPi7bz10nrWvLqpCdHtNaQrk24dzcSbR9G1f8dWYwPwPI+DOw6zZflOtiyVZDc3hQGga/9OlE/qR/mEfpRP6k+7bmWtZv+vFH71r3/ihSdfpXOfDvy64j9b5YXX6ag9Vc8vv/oMS+auBuRn8uFffZ6egz9YtnWV3HJ2crtq1SrGjBmDqqpn/UP473/6HScOnqKwNI/iDkXYepJeg7oxYdY48govPTA5o4JmiN2lWgYyw1oHDhygqqqKSCRCmzZtzqjqflhklOXmJMsZL2xRUdGHHhzzPI/6+vozxo2dOnUqqKhtLhtGZWUl77zzTrPEh2WQSCTYunXreXNxPc+jpqaG6upqqqurz1kPnEmuiEajF9ziNn/+fH7605/y8ssvX9BQ4OXCVXLbMrgc5DYD1/XYsnIvC+etY82i7XJlCzmEds3NI7ju7jH0HnRlJ/mbC4f2HePNuWtZ8vxaTh2pCbb3GtyF6XeNY9odYyhp1zy53M0NO5Xm7TcreOvF9axdsKmJdaFLvw5MvnU0k24dQ89WVq/rOi77Nh9g8+LtbF66g51r9mbTg3yUdS5h8MT+kvBO7E+3gZ0+EuSuOWGn0vzdoK9w8v1Kfvj6YwyfXn6ld+mC8fabFfzXQ7/n+Hun0A2NTz1yM7Mf/mSTnOSr5JYPktuMDWHv3r1UVVUFSue5/KuZEoF+/fpRUtI8ERupVIqKigrKysqaXQVNJpMMGjQIIURgX6ivr7+g13omnDhxggMHDjB48OAPrSyfDfF4nG3bttGjR49maRyzbTsYnHJdNyC6F1qZey4cOnSIEydOMGTIkEvOrs2gvr6eHTt2XFQxxdnqgQsKCtizZw9t27a9oGE8IQS//e1vefHFF5k/f36zZel+BNF6zt4tgMtJbnNRXxNj6Z83seiF9by740iwvefATlx31xim3TKCguLW06p0sfA8j+1r9rHk+XWs+MvbxHxFVFUVhl8zkBl3j2P8DcMIRS/te+hywU7abF62k5Uvb2DNq5toqM4Oo3Xs1S4YRus9rHmsbc2JtO2wb9N+tq/cQ8XK3excs5eGnGE6gPySPMon9GPw5P4MHN+H3sO6t5q62suJP377BZ7+3ktce88kvvr7f7jSu/OhkGhM8uuvP8cr/7sEgB7lXfjK//wf+gzvDlwlt4Ac/nFdqR7kxnzlel0rKysD/2ppaSllZWVBvejBgweprKykvLy82WOZmpMsn89fmxvBVVlZiRAiIH+FhYVn/NISQrB//37q6+spLy9vtlzYzMVCc3phM0OCHTp0oFOnTjQ2Ngbvq+u6gdJZVFR0wVfxQogmFwvN5S9uThX4/2fvvMOivNP1/6GIIr2qdKSXmaEKFrDiYE9MdhNTTC+76cmW5GRjzO5JstnNnmST7EnOZkv2l5wc18SSSLWgYAUBmaEXkQ7SQTrMvL8/cEZQVMSROp/r8rri+w4z35eMM/f7fJ/nvlVJYnV1dVRWVmJgYICtre1144FVKJVK/vCHPyCTydi1a9eY+nqnEZPrG/sOM17idijn86o5eHkI7VLr4LayvoEe4av9ibo3lOBIL/T0NfPvayLp6+kn7XA2SbvPkHYoW125nj3XgCXrAlhxzyKCV/pO2in2gf4B5McLOPFDOid/SKe1oV19zsbBkiWbglmyKRjR0sn5/0upVFKeV03OyYJBwXuygMbLXs0q9PT1WCh2wnuRO14hbniHuuHgtWDaVXerS+p4zPdV5poYsr/p7xO9nDEhS8nno5//ndoL9ejp6/HQm3dz32sb0dfX04pblbhVKBTqCu713sQqVwJV/6pCocDY2Bg/Pz+NVOwEQaCqqoq6ujpEIpFGe0Fzc3NvKfa1v79f3dOpquqqhL2BgQEDAwPk5uZiaGiIh4eHxu7YRxocu11U4QQeHh5YWVldc/5quzFDQ0P1tV5P1CkUCnJycpg7dy7u7prLoK+urqampgaJRKKxKnBnZyfZ2dl4eXlhamp63Xhg1RCeQqHgV7/6FT09Pfz1r3/V2E3LFEYrbseJvt4BzhzK4eB3qWQeL1IP+1rYmLB6awhrf7IIx0mWsDRW2ps7SNk/6J+bf7ZUfdzMypjIu0JYeW8YPiGjax2aCBQKJTknCzm+L41TBzJpqr3SemFmbcLiDUEs3RxCwEpfDGZPzs8QQRC4WN5I9vF8sk8UkJ9aQkV+9TVD5nNNDfEKWYhXiBteoW54h7pjZTe1d7IqCqp5UvxL5jlb83XxJxO9nDHT09nLP9/+jv2fHwTAb7EHHx3ZoRW3/f396taEkYbGRkI1ODRv3jyUSiXNzc3o6elhZWWFjY3NDQ34r4dCoSA/Px9dXV28vLw0VgW8nWE0Farqn6rSOTAwQG9vLw4ODqPu27wZd8plQVUFHW2SlyAIw/xme3t7MTc3x9raWm03NrQKrBryul1UVfBLly6N2r1gNLS1tZGXl4e/v796t2EoqiG8pqYmsrKyiImJoaurC39/fz7++ONpV60YI5NTXdwhJlLcDqWhtpWkfekc+v4s1UM8ZX2CXIi6N5TIDQHTwjsXoK68kWN700j6PpWKy+b1AAtcrFl1bzgr7gnFcZJYc42EUqmkML2Ukz9mcOpAOtUlF9Xn5poaEr4ukCWbggiJEmNoPLnii6+m61I3RRmlFKWXUpBWQsHZ8zRWN1/zOCs7C7xC3HAPcMFV5MhCsTPznK2nzGdm8ndnePfBTwhbH8jv9v9yopdz22QcyeFPz3yJwZxZ/Cv3T1px++KLL+Lm5kZ0dDQODjfP3q6pqaGysvIasXj1pL7Kf9XS0vKmQqWrq4ucnBzs7Ow0JpaUSiUlJSV0d3fj5+enscGp5uZmCgoKWLBgAV1dXbS3t2NkZKTu1R1LtVU1OGZhYaExSzLQTC/sULuxlpYWdHV16e7uZuHChdjb22tM2Ofn56Onp4eXl5fGrl8l7CUSyajaClpaWnj88cfR19dX+wh/9913GntPTmG04nYCEQSB/MwyDu5OIyU2i+7OwVRJg9n6LJGKWHPPIgKWeky6KNyxIAgCpTlVJH13hqN70mi+eCU+103kyMp7wli+NRSbSVw1FASB8rxqTvxwlhP707mQW6k+N2v2LAJX+rJ4YxCL1wdhMUkH6q6mqaaFwvTzFJ49T8HZEooyLlzjygBgaDwHZ18HXP0dcfFzwNnXARc/RyzmjdzaN1Hkpxbz9j1/orW+nYffuoeH37pnopekEdqbO2iua8XVz1ErbgsKCoiNjSU+Pp7W1lZWrFiBVColLCxsmCBUKpUUFhYyMDCAj4/PDcWiUqmktbVVPamvilUdaZu7sbGR4uLiMQ0OXY++vj5ycnLG5DJwPYa2TAxtGbi6qqtUKof56t7sLla1ZX4z/95bXevQKrCm7qRbWlrIy8tj/vz5dHZ20tnZeUO7sdEwMDCgFvaaGhyEwZuw6urqUbc3NDQ0cP/99/Ozn/2Mhx9+GB0dHfWNi6aqyDB4ExgZGUlvby8DAwPce++9vPPOOxp7/jvE5PlWGgcmm7gdSk9XL8fj5RzZc3aYd671AnNW3x1C1L2h2LuOrvVqsqNQKJEdL+DY3jROHLjiWKCjo4NoiQcr7w0jYnMwxmaacWe5U1Sfv8ipH9M5FZNJfmqJestfR0cH33B3lmwKYenmYBa4aubzfzxQKpVUF9dRmF5KaXY5F7IruJBdSXNd64iPN7EwwsnHHicfexy97HDyssPRyw5bZ5txvSnr7ujhh/8+yDf/uYe+nn6C1ojY8e+XmWsyPXZAVGgHyq6ivb2dgwcPEhsby9mzZ/H19WXt2rV4eHiwa9cuXnrpJRwdb936RLXN3djYSG9vr3p4qbW1ldbWVkQikcb6K8fSX3szVFGygiDg7e19Q7Fzda/ujaq6qsGx622ZjwWVWDQzM9OYsIeRfXFVdmOqbf2hdmOjsVbr7e1FJpPh6OjIggWa2XIUBIGysjJaW1sRi8WjEqYVFRU88MAD/O53v2PDhg0aWceN1tfZ2YmxsTH9/f0sW7aMP//5z4SHh9/R171NtOJ2EnKxqpnDe89y+Puz1FVe2Tb2C3Fl9daQadW2oBpEO7YnjdSDcvp7B2PgZxnoExolYsXdoSxaK2LO3MnpuKCi5WIbZ+LPcepABueO5tHfe8Wmy9XPkfANgYSvD8Qz2HXKbO8PpbWhnbLcSi7kVFKeV0V5XhVluVUjVnkB9GfpMc/ZhvmuNtg6WmNtb4m1gyVWCyywnGeOxXwzzKxNxjxg2NHaSXleFRdyKilML+VMTIY69GLDU6t57uNHJu3w4u2gFbc3QKlUcu7cOT766CPi4uKQSCRERkYSHR2NSCQa8z88hUJBQ0MDxcXFKBQKzM3N1V6ztztAVVdXR1lZmUYtufr6+pDL5djY2ODk5HRLYlFV1VUJe1VV18rKikuXLqlbBjQ1ONbd3Y1cLtdoOpgqyautrQ2RSHTDin1fX59a2A+14BpJ2Ksq1p6enhpzxFBVrFW7C6N5j+bl5fH444/z+eefs3TpUo2sY7R0dXWxbNkyPv/8c8LCwsb1tW+RKS9udXR0ooE/A3rA3wRB+P31HjtVxK0KpVJJ7tkLHPo+jeNxMnq6BiPOp2PbAkBnexcnY86R9F0qshOF6kroHKPZLI6WsGLrIoJW+g7z/ZyMdF3qJv1QNid/TCctUTYsNMLC1oyw9QEs3hBE4Eq/SRljPFoEQaC5tpWKgmrK8qqoKqqlqqiGysLaEXt5R2KuiSEmVsYYm83F0HgOc4znYDB7Fnr6uujq6YIw6F3b39tPd0cPLfVttNa3D/udqvBe5M72t+8lJEqs6UudNGjF7U04c+YMb7/9Nl9//TUAcXFxxMXFkZeXR2hoKFKplJUrV95S1VE1ue/q6oqtrS2dnZ3XWFJZW1tf135rJARBoKSkhM7OTo0GE6gG5zw9PUd0GbhVBgYGaGxspLS0VF3BVrVr3K7AVQ1OaTIdTNULqxryu5UbmqvbNYbajQEUFhYiEolGNeQ22rWq3Bvc3NxG9d45ffo0r7zyCt9++y3+/uNn4q1QKAgODqakpITnnnuODz74YNxee4xMaXGro6OjBxQBUUAVcBbYJghC3kiPn2ridihdHT2cTMzm8PdpyM+cVx+3mm/Gmq0hrNkaioPb1Nn+vhmNtS0c/yGD5H1nKci4oD5uYmFExOZgVt6zaNJG/w6lr7ef7OMFnIk/x5nYc9RXNqnPzZ5rQPBqEUs2BrEoOgAza83s8k0Gerp6qS2tp66snsbqZhqrW2ioaqLlYistdW001bVyqekSSuXYZJTBnFk4+djj4ufIQpETASv8cAvQXPvbZEUrbm+CKtDh6q3d/v5+Tp48SWxsLEePHsXCwoKoqCikUukNbaFUldXrTe4PDAyoq5yjDVVQDWOZmZlpzLlAtdby8vLbclm4mqGDY87OznR1dQ1zYBgq7G/lw/jixYuUlZUhFos15seqWquVldUtV6xHQmU3VlVVRUtLCxYWFuqK/e2ueWBgAJlMpq6uj4aEhATeffdd9u7di7Oz8229/lhpbW3l7rvv5tNPPx1XcT0GpvQ3gY6OzmJgpyAI0st/fwNAEIT3R3r8VBa3Q7lY1cyRvekc3nuW2vIrYsk70JnVW0NYvjEAE/OpHxKhorasgeR9Zzm6J43yghr1cesF5kRsCWHF1lA8Aydf0MLVCIJAaXYlZ+IyOR2TSfGQGGNdXR28F7kTFh1A2LoAXPxuPgQ+1VEqlXS1d9Pe1EFXezddHd30dPTQ292PUqFEqVAiCAIGhgYYzNZnjtEczG1NsZhnhrG50bT//YyEVtxqAFWPo6qqW11dzbJly4iOjmbp0qXMnj2bvr4+ioqKUCgUo3YuUIUqXC9AQkdH54701wqCwPnz59WWVJqqAt9scEwl/hobG2lra2Pu3LlqYX89v1/V776lpQWRSKQxP1ZVe4OLi4tG0tFUVFRU0NDQgEgkor+//xq7sdG6awxF1bfr7Ow8qrUKgsC3337Lv/71L/bt26ex981YeeeddzAyMuIXv/jFhK7jJkzpbwcdHZ17gWhBEJ68/PeHgTBBEJ4f8pingacBnJycgsvLyydkrXcCQRAG2xb2pHE8VqZ2W9A30CNsld/lkAhv9GdNvtCBsVKaW8WxvWkc23t2WBV0vrM1y+8OZcXWUFx9p4YLSkN1M2diMzl1IBP58Xx18AWAraMVYesCCIsOQLLcZ0Yki2m5OVpxewfo7u4mKSmJmJgYTp48yYIFC6ipqeGJJ57gySefHPP20NAAiY6ODmbNmkV3dzdisVhjLgsDAwPk5ORgZGSk0WCCpqYmiouL8fPzG1ULh2ro6Oqq7tAEsaH2WZ6enhrbdrud2NvroUoy6+3txc/P75q1KpXKYcEK+vr66hsZVbDCSNxq364gCHzyySckJyfz/fffa6wl4lZoaGhg1qxZmJub093dzdq1a/n1r3/Nxo0bx30tt8BUF7c/AaRXidtFgiC8MNLjp0vldiR6uvs4lZjNkb3pnDtxJSTC3MqYlXcFs2ZrCAt97Sd4lZpDEATy00tJ2Z9Oyv70YdZizt52rNgayvK7QrFbODVaNboudZOZlENqfBZnE+W01F+5njlGswle7U/YukBC14qxnK+Z9jQtUw+tuL3DnD59mscee4zIyEiKioro6upi5cqVSKVSQkJCxlQVVQmltrY2TE1NaWtrUwdI3EwM3Yiuri6ys7M1OowFg16zV9uH3SpXV3XnzJlDV1cX8+fPx83NTWNrbWho4Pz58xqJvVWhUCjUSW6jvWEYGqzQ2dmJqakp1tbWw+zGbhbOcDVKpZIdO3ZQV1fHV199pTF3jltFLpfzyCOPqBMBf/rTn7Jjx44JWcstMNXF7YxsS7gZjXWtJO3P4PCedCqHhA64eC1g9d3BrLwrGKsp4sM6GhQKJTmni9XWYpdaOtXn3MVORN4VQuSWEOY7W0/gKkePUqmkKPMCqfFZpMad47y8Yth5d4kzoVIJi6IleIW4TZuBQi03Rytu7zDffPMNy5Ytw8XFBRj0SU1MTCQ2NpbMzEzEYjFSqZSoqCjMzc1vKnyu1197OwESMFhZLSoqws/PD1NT09u+brjiC6xQKPDx8dGYV2pHRwcymQxzc3N6enpGrOqOBVXLgFgs1lh7Q39/P3K5HFtbWxwdHcf0HEPtxpqbBydrDQ0NaWtrIzAwcFQivL+/nxdeeAFzc3M++ugjjfrWzhCmurjVZ3CgbDVQzeBA2QOCIOSO9PiZIm5VCIJAkayCw3vSSY45x6XWQdsmXV0dApd5snprCIvXipgzhSf2r6a/b4DMY3kk7zvLmXgZXR096nNeQS4svzuUyLtCsF4wecMirqa+snFQ6MZnIUvJp6/nis2YiaURIWvELIqWEBIlxtRy/HettIwfWnE7gSgUCtLT04mJieHw4cPo6+sTFRVFdHT0iMEDKpeFm4Ud3EqAhCAIVFZWUl9fj0gk0pgl151KHGtublaLcFW1cmBggJaWFhobG2ltbWXu3LnqKvb1enWHcqcCH1R9uypXDE1RWVlJRUUFJiYmar/Y69mNwWBF/tFHH2Xx4sW88cYbk35qepIypcUtgI6OznrgYwatwP4hCMK713vsTBO3Q+nvG+DssXyS9qWTeiRP3d9paDybiPUSVt8dgv+ihdPq31FfTz8ZSbkk70/nTKKMnss9yTo6OviFuRN5dwjLNgZhOYWq2L3dfchT8jl7SE5agozaC/Xqc7q6OviEuRMqlRCyRoSbxHla/f/UohW3kwZBEKirq1MPpRUVFREeHo5UKmX58uX8+OOP2NraEhYWdst9kt3d3TQ2Ng4LkFClhxUWFqKjo4O3t7fG/nHficQxgOrqampqam7Y3iAIwjAHhv7+fiwsLLC2th6xqqtQKMjJycHY2FijThMqCzVN9u0C6uE5VTjDUB/hob3JFhYWGBsb093dzbZt23jooYd46qmnZuTUrIaYUb+4mSxuh9Le0klKTBaH95ylUHZly9vW3oKVW4JZvTUYRzfNDZxOBnq6ekk7lE3yvrOkHcpWh0WoUtEitgwKXQtbzezwjQeCIFBVXEdaQhZpCTKyTxaiGLgylGZmbULwahEhUSKCV4swn0LXpmVktOJ2ktLX18fx48f58ccf+f777zEzM+Ohhx5iy5Ytt1UJVSgUNDc3U19fT11dHXPnzsXR0XHUVc6bcauDY6NB5eHb3d2Nn5/fLW2pq65XVdU1NDRUV7F1dHSQy+XY29tjZ2enkbXCld+BJvt2R1tdVlWx5XI5L7/8Mv39/URHR/PGG2/g6uqqkbXMULTidoZTUXKRpH3pJO3PoKHmSsSqp9hx0FZsUyBm02yru/NSN2fiZaT8kE7m0Tz6+waFrq6uDuKlXkRsCWbpxiDMp5jvbGf74FBaxuFs0g/JaagaHqTgEehC6FoxIWsleIcsRE9f28Y11dCK20mMIAjcd999eHl58fDDDxMfH09cXBwNDQ1EREQQHR3N4sWLb3kwSOUG4OnpyezZs4c5Eqi2828lQEK1VlV7g1gs1tiwkqqyamRkNOpgghutUVXVvXjxIpcuXcLa2hpHR8fb6tUdSk1NDdXV1UgkEo39DpRKJbm5ucyZM2fUA2lFRUVs376d1157jUuXLpGQkMCbb77J4sWLNbImGGyP2L59O3V1dejq6vL000/z0kthD7yVAAAgAElEQVQvaez5JxkzStz6+YmF/9zxJaukIszMNXODNl1QKpXkpJVyZF86x+NkdHcMbuHr6esSusKHVXeHELbaF4PZmunbnyx0tndxOkHG8f0ZZBzNVbdr6OrpEhDhxbJNwSzZEDjlhK4gCFQW1pB+OJv0g3LkJwqHRQIbWxgRuMKXoFX+BK3yZ77LxFonahkdWnE7yamursbefrgtTUdHB0eOHCEuLo5Tp07h4eHB2rVrkUql2Nra3lD81NbWUlFRgUgkuqaqOJYACRg+OKbJntWenh7kcjkODg4arayq+nZ9fHzU9motLS3qqq6VldUthyqoInrb29sRiUQaG9gaGBhALpdjbW096nCGzMxMfv7zn/Ovf/2LwMBAjaxjJGpra6mtrSUoKIhLly4RHBzM/v378fX1vWOvOYHMKHFrv8BN8HN5FH19XRZHeCHdFEDwooXaafOr6Onu48zhXI7sOUvm8UJ1ipSRyRyWrZOw6u7gadefC9DR1sWpuCxS9p/lXHI+igElMKSiuzmYpRsDMbeZetv7PV29ZB8v4OwhOemH5FQPcdEAWLDQlqBV/gSv9idguS9GZtqbv8mIVtxOcZRKJdnZ2cTExJCQkEBfXx+rV68mOjqawMBAtchSbe13dXWNKkRiNAEScMUNwMrKCmdnzUX6qXpWvb29sbDQ3LRuTU0NVVVVSCSSYX27qqquStz39fWpe3UtLCxu+OWkVCopKChAR0fnliN6b0RfXx9ZWVk4OTmN2prt6NGj/OY3v+G7777D3d1dI+sYLVu2bOH5558nKipqXF93nJhR4tbby1+4Z8ObZKSeVws2axsTotaLWbshAHvHm3sqzzSaG9pJPnCOo/szKM6uUh+3tbNQ++dOp9hfFe3NHZyOz+L4jxkjC90p2rqgoqb0IplJuWQm5SBLzqPjspMGDFatvUPdCF7tT9Bqf7yCtS0MkwWtuJ1GCIJAc3MzCQkJxMXFIZPJCAwMJDIykn//+9+8/fbbBAUFjUmAXh0gYWpqiomJCdXV1bi7u2s05epOeM0KgkBpaak6de1mlVWFQjHMgeF6jhMKhQK5XI65ublGXSG6urqQy+V4eHhgZWU1qp/Zs2cPf/nLX9i/f79GfYpHQ1lZGZGRkeTk5GjMSm6SMaPErarntrG+nUNxchJjZdQM6Uv0lziydkMAkat8mGukGYeV6cRgf24GR/dnUF/Toj7uIXZk5ZYglm8KxHIKVjVvxqXWTs4kyDj+QwaZx644Tejq6uC/2INlm4JYuiEIqwVTM1xBoVBSnHmBjCPZZCblkp9aMmwwba6pIeJl3kiW+xCw3BcXP4dpV7WfKmjF7TRmYGCA3bt389prr+Hq6oqBgYG6feF2KoyCIFBRUUFZWRkGBgYYGBjcdoDE0OdtbGzUqNesUqkkLy+PWbNm4enpOeaAC5XjhKqqa2ZmRkVFBY6OjixYsEAja4UrPdGj9RwWBIEvv/ySH3/8kb1792JuPr5fHB0dHSxfvpw333yTrVu3jutrjyMzUtyqEASBHFklCQfOkZKUT+9l/9A5hrOIXOWLdGMA/hJHrRvHVVyvP1fln7vqrmCWSEXMmTv9bhAutXZyOl7G8R/SOZc8PDLXN8yNiE3BLNsUhI391N0F6GzvRpaSR2ZSLhmHs6k5P7yFwczaBMlyHwJX+BG40o8FrtOvcj9Z0YrbaYwgCPzkJz/hrbfeQiwWU11dTWxsLHFxcZSVlbF48WKkUimRkZGj7jEdaXDs6gAJc3NzdZrWaHtPVVv7giDg4+OjsbtdVduEjY3NqHtWb4ZCoaC2tpaSkhL09fUxMjK6ro/wrXKrTgtKpZL33nuPgoICvv32W404XtwK/f39bNy4EalUyquvvjqurz3OzCjVdiO3hK7OXlKS8jkYm0WOrFJ93M7BEukGCWvWi7HRWildQ29PH6mH8zj6QwbpyQVqsTdnrgFL1opYdVcwAUs9puW2dkdbF2cSZZw8kEl6Uq7aXgzAO2QhEZuCWLopiPlOUyMZ7XrUVzYiS84nKzmPrGN5NA6p2gPMc7YmcKUfAct9EUd4YzWFAjKmGjNS3H733Xfs3LmT/Px80tLSCAm5cv3vv/8+f//739HT0+OTTz5BKpVe8/MXLlzg/vvvp7m5maCgIL7++usJizIdKz09PaSkpBATE0NKSgp2dnZIpVKio6NxcHAYsQIzGgF6KwESKlSBD5aWlhrt271TIQqtra3k5+erY2+H+ur29vYO89W9lcGyuro6KioqCAgIGNX7aWBggNdeew2Azz//fExRzreDIAg88sgjWFpa8vHHH4/ra08AWnE7AlUVTRyMlXEoTk5T4yUAdHQgaNFC1m6QsCTCi9lzppdrgCZob+kkJTaLo/szyMsoUx+3sDYhcmMAK7cE4SlxmpaV8K5LPZw9nM3xHzM4ezib3u4rzgTuYieWbgxk6cYgnDw1txs2Eai8dbOS8zh3NBdZSj4dQ+KOAezc5iGO8Ea8zBtRhDe2DqNrQdNyc2akuM3Pz0dXV5dnnnmGDz/8UC1u8/Ly2LZtG2lpadTU1LBmzRqKioquESg//elP2bp1K/fffz/PPvssEomEn/3sZxNxKRpB5aEaExNDfHw8ra2tLF++HKlUSlhYGLNmzaKpqYkLFy5gbW19SwL0egESKuutrq4usrOzNS5A29rayMvL03iIQn19PRcuXEAikYxYJVX16qocGFTi3srK6oaV2PLycpqamhCLxaMSqT09PTz11FP4+Pjw29/+dkL6uk6cOEFERAQikUj9+u+99x7r168f97WMA9NPZdyAW/W5VSiUZKSVknggizMniui/XJU0Mp7Nyih/pBsD8PRZMC3F2u1SU97I0R8yOLo/k+oLDerj9i42rLwriJVbgrCbpvZTPZ29pB3O5sSPmaQdzlYnowE4esxn6aYgIjYFs9B/5ILLVEKhUFIqL+fc0TxkKfnkni6ie0jkMQw6MUgifBBHaMXu7TIjxa2KFStWDBO377//PgBvvPEGAFKplJ07dw7zBhUEARsbG+rq6tDX1+f06dPs3LmTxMTE8b+AO0R7ezuHDh0iNjaWtLQ0HB0dKSws5JNPPmHlypW3FSChGtJqaWlh1qxZdHV14evri7W15rajVAJULBbfdpvAUIa2Y4y2H3ioA4OqqmtlZYWFhYU6YaykpISenh78/PxGJVLb29t58MEH2bx5My+++OKU/9CfIsyoX/LthDi0t3Vz7FAOibEyigtq1cddFtqwdoOEVVIRllbTK+xAEwiCQHF2FUd/yCD5wDlaGi6pz3kFOLFySzCRGwKwsJmargM3o6+nn8xjeZyIyeRMgmyYK8ECF2uWbgxiyYZAvINdp8WQlmJAQXFWGdnHC5CfKCDnVBFd7d3DHrPA1RbRMi/8l3jhv8QTO7d52s/7UaIVt0PE7fPPP094eDgPPfQQAE888QTr1q3j3nvvVf9MY2Mj4eHhlJSUAIOCZ926deTk5Iz/BYwD8fHxvPLKK0RFRZGZmYkgCERFRSGVShGLxWP+kKmpqaG8vBwbGxva2tpuK0BCxZ0aSBuLAB0JhUKhbtloaWnBwMCA/v5+jI2N8fX1HdU119fXc//99/Piiy+ybdu2KflBV1FRgYPDlJsinnq/6NtAUwllF0oukhgr40hiNm0tg2JFV0+H0HB31m6QELbUAwOD8W2nmQooBhTITpeQtD+DU4nZdF+uaOrq6RK41IMVm4NYIhUx13h8e+zHi4H+AeQnizhxIJNTcedoHSL0LeeZsXhdAEs2BCBZ5oX+rOnx/lFVdmUpBciP55N9svAasWtuY4rfYg/8Fnvit8QTd4nztLl+TTNtxe2aNWuoq6u75vi7777Lli1bgGvF7XPPPcfixYuHidv169dzzz33qH++oaGBxYsXDxO369evJzs7+05f0oTw2Wefcd9992FjY4MgCDQ0NBAfH09sbCx5eXmEhIQglUpZtWrVqOJ2h1py+fv7q7fgxxogMfR5VUESmhxIG0s62GgYGBggKysLfX19BEGgt7dXPYinqupeTVlZGQ8++CDvv/8+0dHRGlnHePPee+/x+9//nl27drF27dpx7xO+DbTi9jbo71eQerKYQ/Ey0k6WoFAMeqGamBqySurP2g0S3D3nT8mbtTtNT3cfZw7lcPSHTDJSCtQ+sgaz9Qlf48/Ku4IJjvRi1jS9SVAolOSeKeZUXBanYs9RP8SSzthsLuHREpZuCCRopS+zDafW7MuNUIld+fECck8XkXu6mNaG9mGPmW1ogFeoG/6XBa9PmAdGpprbrZzKTFtxOxputy3hwQcf5Ny5c9TV1WFpaYm5uTlZWVnXvI6LiwsmJibo6emhr6/PdMls7+/v5+TJk8TFxZGUlISZmZnaaszDw+OaLyqFQkFeXh4GBgY3tOQSBIGOjg4aGhpuGCChYmBggOzsbMzMzHB1ddXYF6TKacHW1hZHR0eNPCcMegbLZDIcHBzUFmJKpXJYy4aBgQHW1taYmppibm5OdnY2Tz31FF9++SVhYWEaW8t4kpOTwzvvvIOdnR3l5eX88pe/ZMmSJVNF0EyJRWoKTYvbobQ0d3L0YA4H42SUFl+xTlrobsua9RJWS/2xsNS2LYxEe0snJ+JlHN2fSc7ZUvVxE/O5RKyXsHxT4LRMRFMhCAIl8gpOxWVxMiaTisIrbS9zjGYTvNKXxesDCIsSY2JhNIEr1TyCIFBz/iK5p4vJPV1Ezukiqopqhz1GR0cHFz8HfMLc8Q5xw2eRGw6eC6bt++FGaMXtEHGbm5vLAw88oB4oW716NcXFxddU0X7yk59wzz33qAfKxGIx58+fx8zMjB07dlzzOi4uLqSnp2u0r3SyIQgC5eXlaquxqqoqli1bRnR0NMuWLaOxsZG0tDRCQ0NxcHC4peceKUBCVdVVKBTIZDKNe8329PQgk8k0PujW3d2NTCa7aTiDahDv22+/5euvv6a3t5e33nqL7du3ayzYYrxpbW2lsrISkUjEhx9+SHJyMr/97W8Ri8Xo6emhVCon84ewVtzeAUoKa0mMlXH0YA7tbYNbsLp6OixarGpb8GTWrOlnjaUJLlY1k3zgHEn7MygvurJLaTXfjBWbAlmxJQg3X/upcvM4JiqL6zgVd44TBzIpzipXH9fV00W8xJPF6wNYsj5gSnvp3ojWhnbyUovJOVlE3pkiijLLhoVKABiZzcUzyBXvULfBPyFumM8Aq74ZKW737dvHCy+8QENDA+bm5gQEBKgHwt59913+8Y9/oK+vz8cff8y6desAWL9+PX/729+ws7OjtLRUbQUWGBjI119/jYeHB0lJSXh4eFzzejNB3F5Nd3c3R48eJSYmhsOHD9PR0cEDDzzAs88+y4IFY5+aFgSBtrY2GhsbaWhooLu7m/nz5+Pk5HRbARJDUUX/+vj4aDQQQfW8t+LgEBMTwx//+EdeeeUVMjMzOXnyJMeOHRsWHawJHn/8cWJiYrC1tdV4//hQ0drd3a0e8tuxYwe5ubm8++67eHt7U15ejrOzs0ZfW4NMX4UwAuMlblX09Q2QdqqYg7Ey0k6XoFQMfmWYmBqyaq0/azdq2xZuxIWCGpIPnOPYj+e4OGTb3tHNlhWbg1ixOXDaOi6oqK9q4kyCjFNxWWSfKlK3bwB4SJxZsiGAJRsCcfKcvq4dPV29lGSVkZ92nsL08+Snnaexuvmax81ztsYn1B2vkIV4hbrhJnaadkEiM1LcapqUlBReffXV67YbuLq6YmFhgY6ODs888wxPP/30OK9w4khKSuIXv/gFO3fupKCggPj4eDo6Oli5ciXR0dGEhISMqe9SFXbg5eWl9pkda4DESM8rEokwMtLctlZzczNFRUWjDmcQBIGvv/6ab7/9ln379o06gnespKSkYGxszPbt2zUqbhUKxQ2rsq+99hrd3d0YGxuTmppKTEwMxsbGk/HLZ9It6E4y3uJ2KC3NHSQl5nAoTkZpSb36uMtCG9asE7M6WoSV9fR0DLhdBEGg4Fw5R3/IJCU2i7amDvU5T7EjKzYHEbFBgvX8qRl/O1outXaSdjCbU3HnSE/KpberT33OztWW8GgJi9dJ8F3kNi1DM4bSVNtCwdnz6j9FmReGWa7BYKXbycsO9wBn3CTOeAS4sFDsPKX7d7Xi9iaMZjDtZz/7Ge7u7mpD/aupqanBzs6O+vp6oqKi+PTTT4mMjGTnzp18+eWX2NgM3lFfzyM0ISGBl156CYVCwZNPPsnrr7+uwSu8sxQWFmJpaam+Rhjcnk5MTCQ2NpbMzEz8/f2RSqVERUWpbwJuRHV1NTU1NUgkkmHDZlcHSKj6Vm1sbEZlCVZbW0tlZSUSiUSjldGLFy9SXl4+6ucVBIGPPvqI06dPs3v3bo2K7BtRVlbGxo0bNSZuVYL24sWLvPjii7i6uhIWFsaqVauGVa7t7e0xNzcnLi5OW7mdJEykuB1KSWEtB+PkJCVmX2lb0NUZFhJhMHt6DlLdLooBBVknizn6QyanDl5xXNDR0cF/0UJWbA5k2ToJptOsN/Vqerv7yDyWx6m4LFITZbQ3XwlSMLU0YlGUmMXrAwhe4csco+lVvRwJxYCC8vxqCtLPU5heSmF6KeV5VSiV18o0O7d5uEmccRc74yZ2wk3ijOUUuTHSitvbZGBgAHt7ezIyMkbVS7pz506MjY3V1UzVf18PhUKBp6cnhw4dwsHBgdDQUP7v//4PX19fTV7GhKFQKMjIyCAmJoZDhw6hr6/PmjVriI6OvsZ2SxAEzp8/T2dnJ/7+/jetzF4dIKFKDrOwsLjmecvKymhtbVX3f2qKiooKGhoakEgko6pQKxQKfvOb39Dc3Mzf//73cU2+07S4hUE3kXvvvZdXX32VwsJCDhw4wLZt23jyyScxNTXl+++/5/e//z1HjhzRaNjGHUArbieQ/n4FZ0+XcChORurJYgYubzkbm8xhxRo/ojZI8Pa1m4wV/0lBb08faUn5JB/IJC0pn/6+wfhbPX1dgiO9WbE5kPA1/hhOc3GnGFCQf7aU0/FZnI6XUXPhys6AwZxZBK3wZcn6ABZFiTC3mf59qSp6unopy62iOKuMkqwyzsvKKcutUr9PhmJha4abxJmFIkdc/Rxx9nXA0WsBBrMnVxKhVtzeJgkJCbz//vskJyePeL6zsxOlUomJiQmdnZ1ERUWxY8cOoqOjRyVurw6JuNrRYTohCAIXL14kNjaW+Ph4CgsLCQsLQyqVsmjRIv785z/z8MMP39Bp4XpcHSAxd+5ctQPDhQsXEAQBb29vjQ00qYR4V1cX/v7+o3revr4+fv7znzN//nw+/PDDcR+u0oS47evrQ1dXV21xFhsbi1KpJDQ0lE2bNhEREUFTUxMRERE88sgjtLS0YGtrOxVEyaRfoCaZbOJ2KG2tXRw9lMOhOPmwkAgHJ8vBtgWpiHkLpkZ1aSLobO/m1KEckn/M5NzJYpSXbdlmz5nFolW+LN8USOhKn0knVjSNIAhUFtcNCt24LAoyLqjP6ejo4BXkQphUTHi0BBef6T2YNxL9fQNUFNRwXlbOeVk5JfJySrMrrvHehcHdlAULbXHytsfJyw5HzwU4etvh6Gk3Ya0NWnF7mzz66KOEh4fz7LPPqo/V1NTw5JNPEhcXR2lpKXfffTcwWOV94IEHePPNN4HBKu5XX32FqakpISEh/OlPf8LCwmLY83///fckJCTwt7/9DYCvv/6a1NRUPvvss3G6womjr6+PEydO8N1337F7924kEgnr168nOjr6tiy/BEGgq6uL+vp6ysvL0dXVZcGCBdjY2Iw5QGIoSqWS/Px89PX1Ry3EOzs72b59O8uXL+fXv/71hHyQ3q647e3tZc+ePXh7e1NWVsaJEyf48MMP6evr4+WXXyY6Opq77rqLLVu20NXVxZtvvsmKFSs0exF3jhn1zTaZxe1QLpRc5GCcnKMHc2ge0l8qCXYhap2YiJU+GM6dPt6nmqa18RIpsVkkx2SRl35F3Bkaz2bJWhErNgcSsMQT/RngWNFU28qZBBlnEmVkHS+gv/dK1XKekxVh0sE+XdFijxkbnCAIAhfLGymRlVGaXUlZXhVluZXUltaP2NYAYDnfHAfPBTh4zMfBfT72l//Md7G5o97MWnF7h7lRz254eDjW1tbo6Ojw1ltvUVtbyz/+8Y9hj/vuu+9ITEwcJm7T0tL49NNPx2X9E01XVxeRkZG88847eHt7q63G6uvriYiIQCqVsmTJklvevld5zdrb22Nra0tzczMNDQ1jCpAYikKhQC6XY2FhgbOz86hEalNTE9u2beOxxx7j8ccfn7AKgSYqt4mJifzsZz9DX1+fTz75hOjoaPr7+9mwYQObNm3ihRdeGGalN4XQittJjGJASebZUg7FyzmVXEjf5e3UOYazWLbCh6h1YiTBLujqzqj/jbdEfXXLoNA9cI6SnCr1cVNLI5atk7B8YwB+oQvR05u0dn0ao6ezl8zkPM4kykk7KB+WkGZkakjoGhFha0WErPafdn66Y6Gvp4/qkouU51dTWVRDRWENlQW1VJ+vo6+nf8Sf0dXVwcbRigWutsxzssbWyRpbByus7S2wtrPAys6SuSZzxvx9qBW3k4TrCYsbtSX88pe/5MCBAxgYGODm5sY///nPEa2rpnqIRH19/TVesx0dHSQlJREbG8upU6dwd3dHKpWydu1a5s27cf52V1cXcrl8RK9ZVYCEqlcXbhwgMZShgtnOzm5U11ZdXc3999/PW2+9xV133TWqn7kTbNu2jWPHjtHY2Mi8efN45513eOKJJ0b1s1dbfT322GOUlZXxzTff4OjoyOzZs0lJSeGpp57CyMiI9evX85//+Z938nLuBDNKFU01cTuUjks9pCTlcTBWRl72FZFmbWvKmmgRa9aJcXKZObaMY6GqtJ7kmHMkH8iisuRK0Ialrak6LMI7cHQ371MdpVJJQcaFwapugmxYcISurg6+i9wJWytikVQ8rW3GxoJSqaS+somqolqqS+qoKqmjuriO6vMXqa9ovG61V8XsuQZYzjfHcp4ZZtammNuYYmZtgomFEcbmRphYGDHXxBBDkzkYGs/BYM4sDGbPYrahAcbmRlpxO1HU1taqgwc++ugjUlNT2bVr17DHDAwM4OnpyZEjR7C3tyc0NJRvv/0WPz8/Dh48yKpVq9DX1+fXv/41AB988ME1rzPdfXaVSiU5OTnExMSQkJBAT08Pq1evJjo6mqCgoGEDYm1tbeTl5eHv7z+quODrBUhYWloya9aVnjRVOIO7u/uof88FBQU89thjfPLJJyxfvvzWL3wSMFTYHjlyBGdnZ2xtbfnhhx/YtWsX7777LgEBASiVStrb26mqqsLf33+CVz0mZtQ31lQWt0OprmzicHw2hxOyuVjbqj7u5WNH1HoxK6L8MDWbmqEo44EgCFzIryE55hwpMVnUVV7xTLW1tyByYwDLNwVO+7CIoVSfv0jqQTlph7Kv8dOd72xNmFRMmFSMaLHntI1E1gT9fQPUVzRSc/4iFyubaKhqoqGyicaaFhprmmmsaRlm4XYrLBQ58UXqu1pxO1E8/PDDZGVlDUbmubjwP//zPyxYsGBYzy5AXFwcL7/8MgqFgscff1zdszuUffv28f333/O///u/15yb7uJ2KIIg0NzcTEJCAnFxcWRlZREYGEh0dDRtbW3U1tbyyiuvjMoabKTnVgVINDc3o6enh5WVFYaGhpw/fx4/P79RT/yfPXuWF154ga+//hqJRHLLa5lsvPzyyxQUFBAUFEReXh779+/njTfeoKKigrCwMP74xz+SkpKCq6vrRC91rMyMb+7LTBdxq0KpFMiVV3I4Xk7ykTy6Ltti6evrErbUgzXrxCxa4qFNQ7sBgiBQJK8kJSaLlNgsGofcLNi72hC5IYCIDRJcvGZO9bLzUjeZR/NIPSjn7KHsYb7Cc03mELTSl0VrRASv8sNqilhoTRYEQaDrUg8tF1tprmujrbGd1sZLtDVeoqOlk0stHXS0dtHV0UP3pW66O3ro6+mnv3cAFz8HPoh9XStupwObNm3ivvvu46GHHrrm3EwOkRgYGCA1NZXf/e53yGQyvL29WbNmDVKp9LbdEXp7e6moqKCqqgoDAwMsLS1HFSBx+PBhdu7cyZ49e6ay2FOzZ88eDh06xBdffMG2bduYNWsW/+///T8AvvjiC4qKilizZs2IHs5TiJnxbX2Z6SZuh9Lb08+plEIOxcnJPFuq3ho1MTVk+RpfotaJ8fabOZXIsaBUKsnLKCP5x3Mcj5cNE3WO7vNYvjGAyI0BOLrNm8BVji8KhZLCzAukJso5kyCjvKBm2Hl3sROLokSERonwDHSZEb3LE4m253aSM5oQiXfffZf09HT27t074gfy9UIkZgp79uxh9+7dfPXVVzQ3N6uH0kpLSwkPDyc6OprIyMhRJYcNZWg4w6xZs0YMkLC2tlY/ryAI7N69m7/+9a/s37+fefOm5ge/KnVMxe7duykvL+f8+fP09vbyz3/+E4CMjAyCg4OvefwUZUYpneksbofS1HCJpIM5HEmQD0tDs3e0VKehzdfait0QxYACeep5UmKyOJWYTXvLlZAEV+8FLN8USOTGQBY43dmUxclGXUUj6YdzOHs4h6zj+fR2XxmsMrM2IXSNP2FrxQSt8MHIVNsao2m04naK869//YsvvviCI0eOjEqc7dy5k6qqKo4fP37dxLPe3l62b99ORkYGVlZW/Pvf/8bFxeUOXcGdp7+/Hz09vWuqtL29vSQnJxMTE0NKSgoLFixAKpUSHR2No6PjDSs3lZWV1NfXIxaLh/XeqhgaIFFdXc2BAwcwNzcnLy+Pffv2YWo69QzCBUFQ/066u7tpbm7G3t6ekpISIiMjCQ8PZ+/evQC88847NDc384c//EGjaW8TiFbcTnPOF9dxJD6bpKtsxUZcC9IAACAASURBVEQBTqyOFhG5yhdjkzkTuMLJz0C/AtmpYpJjszidmE3HEE9UD5EDy9ZLiFgfMOOEbm93H/KThaQdyibtUDYXK5rU53T1dPENdSNkjT+hq/1Z6O+g3TXQAFpxO4VJSEjg1VdfJTk5eVi87VCuDpFYs2YNZWVlnDx58rqJZ//93/+NXC7niy++YNeuXezbt49///vf43VZE4IgCBQVFamrui0tLSxfvhypVEp4eLhawI4lnKGjo4Nf/epXZGRkoKuri5ubGzt27CAgIEDj13Gnopq7urp4/fXXeeuttzA0NGTt2rUolUp++tOfsnXrVtLT0/nggw948sknkclk5Ofns3v37uu+L6cgM+rbZiaKWxUqW7HD8XJODrEVm2Wgx+JlnqxZJyYk3A19/Sm/G3FH6e8bIPN4IckHznHmcK46/hfAQ+xI5HoJERsCmOdgOYGrHH8EQaCiqJa0RDmpB7PJO3teHaQBYDnPjJDVfoSuEWmrureBVtxOYdzd3ent7VXbWYWHh/PFF1/cMERi2bJllJWV3TDxTCqVsnPnThYvXszAwADz58+noaFhRt1Ntre3c/jwYWJjY0lNTcXb25vVq1eTmJjItm3b2Lhx46h+HwMDA7zyyisYGBjw2WefoaurS2FhIWZmZmqnDE1xp6KaBUGgpaWFDz/8kLKyMvT19dm0aROurq58/vnn+Pv7c88991BSUsKZM2fo6enhzTffnC4VWxUz583PzBa3Q+ns7OXE0XwOJ2QjzyxD9TVnZjGXlVH+rIkW4eE9cwaoxkpvTx8ZKYUcj80i9UjeMKHrFeBE5IYAlq2TYGtvcYNnmZ50tndxLjmfs4dzST+SQ1PdlUE9Pf3Bqm5olIiQVX64+mmruqNFK25nGKNJPPP39ychIQEHBwcA3NzcSE1NnRFuCyOhVCo5c+YMTzzxBHPmzGH27NmsXbsWqVSKRCK5bvW2u7ubJ554AolEwttvv33H43TvRFRzR0cHBw8eZOvWrSQkJPDb3/6WpqYmTp8+jaWlJceOHWPXrl34+Pjw0EMPXeMbPI2YUd8oWnF7LfUX20hKzOFwvJyKskb1cQcnK1ZHi7T9uaOkt6eP9GMFpMRkkZqUR2/3FbsnrwAnItYHsGydeMZVdOGy9VpeNWcPZ5N+OIfctGurukErfQlZ5UfQCl9MLY0ncLWTG02JW62Z2xRhpJuQq+8ER/OYmYSuri779+/nV7/6FY8++iiNjY3Ex8fzySefkJubS3BwMFKplFWrVql7adva2njwwQfZunUrzz333Lj8/qqrq3F0dFT/3cHBgdTU1Nt6TkNDQzIzM3nvvfcQBIHf/OY3fPPNN/z617/myy+/ZMWKFXR2dvLVV18RFBRERETE7V6GFi2TEtt5Zty/fSn3PbyE4sI6DsfLOXYol6qKJv7112P866/H8A9wYo22P/eGzJ5jwNJoMUujxfR093E2KY+UWBlnj+ZRmFVBYVYFf3vvxxlZ0dXR0WGhnwML/Ry476V1dLR1kXksj/QjOWQk5dFU18rhXac5vOs0Ojo6eAY6E7LKn+BVfngFuaCnbZXRONrK7RRhNNW9G7UlVFZWsn37durq6tDV1eXpp5/mpZdeGvYax44dY8uWLWqbq61bt7Jjx45xusI7w9CwgqEMDAxw8uRJ4uLiSEpKwsTEhPDwcOLi4nj99dfHNWL2TkU1Hzx4kIcffpglS5awb98+iouLeffdd7GxseGPf/wjADk5OVM1nGG0zKi7O23ldnQMDCjIPHuBI/FyTqUU0tt7pT83fKkna9aJCAl31/rnjoKerl7OHs3neJyMtKP5wyq63oHORKyXsDR6ZlZ0YbDoVJZfTUZSHhlHc8k5XUz/5X5wAGOzuQSu8CFohS9BK3yZ5zhtd9FGhbYtYYZxo8QzFX/5y1/Izs5WD5Tt3buX3bt3A4OparW1tQQFBXHp0iWCg4PZv3//sL7OY8eO8eGHHxITEzPu1zeRCIJARUUFn332Gfb29rz88svj+vp3oi0BBt8z+fn5/Md//Ac+Pj784Q9/oKamhqeeeoqlS5fyH//xH7e99imAVtxquSGdnb2cPFbA4Xg5siH9uSr/3NVSEb4ibc/kaOjp6uXssQKOx2aRlpRHb88VGy1PseOg0F0nmXGuC0Pp6exFfqqI9KRc0g/nUHOhfth5B/d5aqErXurF3Bm2k6AVtzOQkRLPduzYQUhICJs3b6anp4eHH36Yc+fOYWlpya5du1i4cOGIz7Vlyxaef/55oqKi1MdmqridaEZz43I7nD9/nscee4y7776b6OhoHnnkEX7zm9+wefNmjTz/JGdGKRKtuL096i+2cexQLkcSsrlw/oromG9nzmqpiDXrRNjP8MraaOnp6iUtKZ+TCfJrenTd/R2I2DAz7cWupuZCPelJuZw7lofsRCFdl3rU51SDaUErfQla4Ye7xGnah0hoxa2WMVNWVkZkZCQ5OTnDfFuPHTvGPffcg4ODA3Z2dnz44YcaE1habsxooppvh/z8fB599FH6+/t5++231UEiMwCtuNUyJkpLLnIkIZukxByaGi+pj3v52rE6WsTy1X5YWBpN4AqnDj3dfWSkFHAiXk7qVfZibn72LI0Ws2ydeEYlo43EQP8AhZllZB7LI/NYHoUZF9RJfAAmFkYERHoTEOFN4HIfFrjYTLsdBa24naI0NTVhYWFxxyfwr0dHRwfLly/nzTffZOvWrcPOtbe3o6uri7GxMXFxcbz00ksUFxdPyDq1aJ729nba2tqGDa/NAKbXJ/9N0IpbzaNQKJFnlnM4Qc6JYwV0dw1WIHX1dAgKXcjqaBFLIr0wNDSY4JVODdT2YnGya4Sus+d8lq0Ts2ydBGfP+dNOuN0qHW1dZB0vICMpl8xjecNCJADmOVkRGOlD4HIfJBHemFubTNBKNYdW3E5R3nzzTZ577jkMDAw4deoUq1atwth4fGxB+vv72bhxI1KplFdfffWmj3dxcSE9PX2YlZiLiwsmJibo6emhr6/P1V+kgiDw0ksvERcXx9y5c9XT+Fq0TBAz6ttRK27vLD09/Zw5UURSYjZnT59HcdnuaY7hLJYu92a1VERgiCt6+tN761hT9PX2k3m8iJMJcs4cyhmWjGbvasOydRIiNkhY6GM344WuIAjUlNaTlVLAueP5yI4XcmlIZDKAm8iRwOWDw2m+i9yYM3fqeZZrxe0UQxAEXn/9df73f/+Xqqoq8vLyePzxxzl06BAmJiYoFAr09O7cZK4gCDzyyCNYWlry8ccfj/iYuro65s2bh46ODmlpadx7772Ul5cP+1AZSfAOJS4ujk8//ZS4uDhSU1N56aWXbtvWSouW22BGfSNqxe340dbaRfKRPJISs8nLrlIfN7cwYkWUH6vW+uPlqxVlo6W/bwD56RJOJMg5dTCb9uYrwm2+kxVLpSKWRovxCnCasJ3PyYRCoaQ0u5KslHwyk/PJOVNMf+8VF4ZZBvp4B7siXuZFQIQ3XsGuGMy+NnJ+sqEVt1MMpVLJAw88wPHjx3FycsLKygpra2u+/PJLdUTs1Y/X5D/gEydOEBERgUgkUj/ve++9R0VFBQDPPvssn332GZ9//jn6+voYGhryX//1XyxZsmTY89xM3D7zzDOsWLGCbdu2AeDl5cWxY8c0nuqlRcsomVHKQituJ4aaqmaSEnM4kphNdWWz+ri9oyUr1/qzWuqvHUS7BRQDCuSp5zkRL+dUgpzWpg71Oat5pixZK2LpOjH+oQu1HrGX6e3uIzethHPH8jmXnM/57Mph3vezDWfhF+aOJGKwZ9dd4jwph9O04nYKct999/HQQw+xbt06li9fjrm5Of39/SgUCj7++GNEItE1PyMIwqS683d1dcXCwgIdHR2eeeYZnn766WHnN27cyOuvv86yZcsAWL16NR988AEhIbf9XtWiZSxMnn8844BW3E4sgiBQXFDLkcQckg/n0jxElHn52rFKKmLFGl8stAlVo0ahUJKfWcbJBDmnErKpr2lRnzOzMmZxlD/LosWIF7szy0CbS6XiUmsn2aeKyDpeiPxEAWX5NcPOG5kaIlriiWSZF+KlXrj62U+KirhW3E4xampqWLduHQcPHqS3t5ctW7bwySefEBERwebNm7n33nvZvn07XV1dxMTEoFAo2LhxIyYmgw3iJSUlyGQy1q1bh6Gh4YQJ3pqaGuzs7KivrycqKopPP/2UyMhI9fkNGzbwxhtvDBO3f/jDHwgODqawsJD77rtP/djS0lJ++9vfDvOVnY5BElomlBklbkXiAOGzr75nqdgVfW1Fa0JRKJRkZZSRlJg9fBBNV4fAUFdWRvmzdIU3RkZTry9yohAEgeLsKk4myDgRL6dmSJyykckcFq3yZWm0mOBIrynZb3onaW1oR3aikKzjBciOF17jr2tsPhf/cA/ESz0vi12HCansasXtFGP//v38+c9/5ujRo+zevZvvv/9eHbDw2GOPsWbNGh588EHuv/9+oqOjycjI4PTp03z11Vf4+vry4osvMm/ePN566y31cwqCgFKpvKO9ujdi586dGBsb84tf/EJ9bLRtCQqFAnt7e1JTU3F2dlYfny5eu9999x07d+4kPz+ftLQ0beV64phR4tbexVOwX/EsFiaGRC/xYeMyPzwcbSZ6WTOenp5+Th8vJCkxh/QzVwbRDAz0WRzhySqpvzYR7RYRBIGygtrBHt1EOWWFdepzs+fMIni5N0ulIhat9sPY1HACVzo5qa9qQnaiENnxQuQnC6mvah523sjUEP/FHoiXeiFe6slCf8dxEbuaErfaGv44UVpaiqWlJYIgUFRUhLe3NwB5eXnMmTMHKysrDh06xJ49e5BIJDz//PNERkZy4MABBgYG+OGHH5g7dy4lJSX85S9/wcjICB0dnWHCVtXCoOl+XRWdnZ0olUpMTEzo7Ozk4MGD11RVN2/ezGeffcb9999PamoqZmZmI/bbHjlyBDc3t2HCdjrh7+/P3r17eeaZZyZ6KVpmEHNm6+NqZ8WFmib+LzGT/0vMxNvZlg3L/JCGe2Nuov2SnwjmzJnFyih/Vkb5097WRUpSPkkHc8jJqiD5SB7JR/IwMTUkcpUPK6P88Q9wQld3Rt2X3TI6Ojq4+tjh6mPHw69EU32hgVOJ2ZxMkFMoq+BUYjanErPRn6VHwBIPFq8VER7lh6WN6c2ffAZg62BF1P1LiLp/cK6mrqKR7FNFyE8WkX2qiLryRlIT5aQmyoHLYjfcA/9wd/wWe+AhcZ7UbSDayu04kZuby3vvvUdxcTGXLl3i448/RiqV8u2335Kens4LL7zAN998Q0VFBQEBAezZs4eKigqioqL46KOP2PT/27v34CrqLIHj38M7QIaEuGgAx/DI8AqIIaKAWkEwcURhWXBlU5a8RnfWgnLKUgaBtVxxtmB4lIXlCA7iKDvqMKusDuNAojwG5BXQADcmQAhBMkISSMJDHuFx9o/uxJtw8wBy701uzqeqK327f9197q+77j3p++vf77HHmDVrFjk5OUyaNIn58+eTkZHB/fffz5NPPklUlPOwQkFBAfPmzWPv3r2MGTOGZ555hjZt6mf4vtzcXMaOHQs4o2qlpKQwe/Zsli5dCjgPpakq06ZNY+3atbRt25Z3333X513LKVOmEB8fz7Rp0yotD7WBJBITE1m4cKHduQ2eJpUhJCQkaHp6Oll5BazZnMm67dmcOef0I9qieTPuG9idUcP6WrOFBqLw+Ck2pHlYv85TaUS0Wzr9hMSR/RiRHEf32Fsb1HMXjUHRsVK2pTqJrmdnbsVACCJCn/g7GJLUn6HJ/el8h+8How0UHD3J3q/2VyS8x4+cqLS+dVhLesV3cxLeIbH0SehOWPubzzWsWUIj5vF46N27Ny1atOCFF14gLCyMuXPnMn78eEaNGsXkyZMBKC0tJTw8nA8++ID169fzzjvv0KxZM65cuUJJSQlFRUUsW7aMli1bsmDBAs6cOcPTTz/NwIEDiY+PZ8GCBSxevNjng2rBVFZWRufOncnMzOTWWyuPSBNqA0lYcht0TSorqPpA2cWyy/z9m0Os2ZLJDs8Rrrqf99ZsoeHJzSlgQ6qHjWmZFBw/VbH8pzG3MDwpjgeT4ojuEhnECBun0pNn2fGFh62pHr7ZcoBLZT92l9WtdzTDHh7A0KT+xPSOtn8ialBw9CT7th0gc1sOnu0HOXrweKX1zZo3o0f/24m7N5b+Q2Ppd09POkRd/6ASltw2cuVNCIqLiykuLqZnz55kZGQwa9YskpOTGTVqFGFhYXTp0oWUlBSGDx9OSkoK7dq1Y/PmzXz88ce0a9eOVq1aceTIEVasWMHKlSt5//33SUtLA+CNN96gqKiIV199NcjvtrJPP/2UN998k9TU1FrLxsTEMHToUL744gs6deqEx+MBoLi4mCeeeIK8vDxiYmJYtWoVkZHXfvC/9957vPbaawDMmTOHiRMn1tv7GDlyJMePH79m+W9+85uK4W0tuQ26RvttJSKPA68AfYDBqlprNwg19ZZQVHKWtduyWLMlk8Pf/9i+rtcdnRg1rC/J9/Ym8idt6yd4c8OuXlWyPPlsSPWw6ctvOVV6rmJd735dGP5QPx4Y0ZeoEBiNKtDOnb3A7k3ZbE3dx84NWZw7c6FiXfQdUQwZGceQpP70GRTTILvJakhKT5zh2505eNxkN2fvd1x125KX++nPoulzdw/6Du5O38E96Nqz9lHnLLkNUWvXruWTTz4hOzub6dOnM27cOCZPnszUqVMreiWIiorirbfe4vTp0yxfvpzY2FhWrlzJ6NGjGTFiBM899xwAL730EufPn+f1119vUF2KTZgwgeTk5Io71N58DSSxcuVKwsPDeeqppyqS2xkzZtCxY0dmzpzJvHnzKCkpYf78+ZX2VVxcTEJCArt27UJEGDRoELt37/aZBPuLJbdB1zAu+hsgIn2Aq8Ay4IWbTW7LqSpZhwtYs6Vys4XmzZsxbEA3Hr2vH8Pu7EZLa7YQdJcvX+Gb9MOsT/Xw1aZsLpy/BDg9LtwZH8PwpDjuS+xN+/D6aXrWlJRdvMyebQfZum4f29I8nPLqtq1DVHvuGdGXIQ/15677YmndxoZWrs35sxfI2p2LZ+tBPNsPkr37MGUXLlUqEx7Zjj4JTqLb5+4e9LorhjZVegux5LYJuHjxIq1bt2b58uXMmDGDF198kdGjRzNu3Diys7MBeP7554mIiODll1+ma9eu7Ny5k86dOwPOQ02LFi0iOTm5wSS3586d4/bbbyc3N5cOHToAVGqzW91AEnl5eTz66KMVya13LwzHjh0jMTGR/fv3VzrWhx9+yMaNG1m2bBlwbU8OgWDJbdAF/6K/SSKykXpMbr1dLLvM5oxc/vpVJtv35XHFbZsYER5G8r29GZs4gO5dbPCBhuD8+TK2bznAxrRM0rflcPmyc5esZcvmDB7ak+EPxXH/g30axOd8Y1Pel+62VA9bU/dx/LuTFevatG3FoAd6MzS5Pw+MGkgL69GiTi6VXSZn73dkpR/i2/RDfLvjEMUFpyqVKW/K0HdwD/re3YN7kgYQ1r6NJbdNSXFxMSdOnOC2224jJSWFH374gR49erBp0yaWLFnCgAEDSElJYe3atYSFhVFYWEhcXByFhYW177wRqJrcRkREUFpaWrE+MjKSkpKSStssXLiQCxcuMGfOHADmzp1LWFhYpa7L/GX16tVMnz6doqIiIiIiGDhwIOvWrfP7cc01Gv03vT+TW28nSn9g3fZs1mzxcCjf+XL/9VMjGPfgnTe0P+M/Z06fZ8vGbDaketjzdR6qENs7mjff/UWwQ2v0VJUjB45XJLo5Hmdo5Yio9vzPjlesucINUlUK84v5dkcOmTsPkZV+iMOZ+RUP+wGsOrCYDlHhAUluTQMlIvcAMUBPIBXYDSwB/gxsBv4L6Kqqk0WkmaperW5fjYGIxABrVDXOfV2qqhFe60tUNbLKNi8CrVX1Nff1fwLnVHVRwAI3pgYi8gVwm49Vs1X1U7fMRmpIbkXkGaB8qMA4wOOHUG/WLcCJWksFR0ONzeK6PhbX9WmocfVS1ZtuUN5wOykzNVLVHcAO72Uish9YDpwF/hf47/LigY0uIApEJFpVj4lINODrFnU+kOj1uiuwMQCxGVMnqjqyHvbxNvA2gIjsqo+7HvWtocYFDTc2i+v6WFzXpyHHVR/7sfvrIURV3wB+hnMXZ76qHnSXh2Jy+xlQ3vXBROBTH2XWAUkiEikikUCSu8wYY4wxIcqS2xCjjnTgSrBjqS8i8iGwDeglIvkiMhWYBzwkIgeBh9zXiEiCiCwHUNViYC6Q7k6vusuMafBEZKyI5ANDgL+KiP1jZowxdWDNEkJUKN2tVdXqujcY4aPsLuAXXq9XACv8FJoxfqOqq4HV17nZ2/6IpR401Lig4cZmcV0fi+v6hHRc9kCZMcYYY4wJGdYswRhjjDHGhAxLbo0xphERkcdFJFNEropIQpV1L4lIjojsF5HkarbvJiI7ROSgiPxJROp9+CV3vxnulCciGdWUyxORfW65enlKug6xvSIi//CK75Fqyj3s1mOOiMz0c0wLRCRbRPaKyGoRiaimXEDqq7b3LiKt3XOc415LMf6KxeuYt4vIBhHJcq//53yUSRSRU17n9mV/x+V17BrPjTiWuHW2V0TiAxBTL6+6yBCR0yLyqyplAlJnIrJCRApFxOO1rKOIpLmfRWnug9++tp3oljkoIhN9lbmGqtpkk0022dRIJqAP0AunW7sEr+V9gT1Aa6AbcAho7mP7VcAEd34p8B9+jncR8HI16/KAWwJcf6/g9BtcU5nmbv11B1q59drXjzElAS3c+fk4vd0Epb7q8t6BZ4Gl7vwE4E8BOG/RQLw7Hw4c8BFXIk5/6AG7nup6boBHgL/hDCxzL7AjwPE1B44DdwSjzoAHgHjA47Xst8BMd36mr+se6Ajkun8j3fnI2o5nd26NMaYRUdUsVd3vY9UY4CNVvaiqh4EcYLB3ARER4EGcfrAB3gP+2V+xusf7V+BDfx3DTwYDOaqaq6plwEc49esXqpqqqpfdl9tx+uQOlrq89zE41w4419II91z7jaoeU9Wv3fkzQBbQxZ/HrGdjgPfVsR2IcPtoD5QRwCFVPRLAY1ZQ1b8DVXsr8r6OqvssSgbSVLVYVUuANODh2o5nya0xxoSGLsBRr9f5XPvlHwWUeiVSvsrUp/uBAnX73PZBgVQR2e2OtBYo09yfhldU81NoXerSX6bg3OHzJRD1VZf3XlHGvZZO4VxbAeE2g7iLKgMZuYaIyB4R+ZuI9AtUTNR+boJ5TYFzh726fzKDVWe3quoxcP55ATr5KHND9WZdgRljTAMjdRiW19dmPpZV7Q6nLmXqpI4x/hs137Udpqrfi0gnIE1Est07PDelptiAt3D6v1b37yKchLLSLnxse1NdC9WlvkRkNnAZ+GM1u/FLfVUN1ccyv11H10tE2gMfA79S1dNVVn+N87P7Wbct9f8BsYGIi9rPTTDrrBUwGnjJx+pg1lld3FC9WXJrjDENjN7YsLz5wO1er7sC31cpcwLn59AW7h03X2XqJUYRaQH8CzCohn187/4tFJHVOD+J33SyVtf6E5HfA2t8rKpLXdZrTO6DMo8CI9RtbOhjH36pryrq8t7Ly+S757kD1/7kXO9EpCVOYvtHVf2k6nrvZFdVPxeR34nILap6wt+x1eHc1Ps1dR1+DnytqgVVVwSzzoACEYlW1WNuE41CH2XycdoFl+uK87xBjaxZgjHGhIbPgAnuk+zdcO6+7PQu4CZNG4Dx7qLqhq6uDyOBbFXN97VSRNqJSHj5PM5DVR5fZetTlXaOY6s5ZjoQK07PEq1wftL9zI8xPQz8GhitqueqKROo+qrLe/ce/nw8sL66hLy+uG163wGyVHVxNWVuK2/7KyKDcXKck/6Myz1WXc7NZ8BTbq8J9wKnyn+SD4Bqf0EJVp25vK+j6j6L1gFJIhLpNiFKcpfVzN9PyNlkk0022VR/E05Clg9cBAqAdV7rZuM86b4f+LnX8s+Bzu58d5ykNwf4M9DaT3H+AfhllWWdgc+94tjjTpk4P88Hov5WAvuAve6Xa3TV2NzXj+A8kX/I37G55+IokOFOS6vGFMj68vXegVdxkm+ANu61k+NeS90DcN7uw/k5eq9XPT0C/LL8OgOmuXWzB+fBvKEBuqZ8npsqsQnwplun+/Dq6cTPsbXFSVY7eC0LeJ3hJNfHgEvu59dUnHbaXwIH3b8d3bIJwHKvbae411oOMLkux7MRyowxxhhjTMiwZgnGGGOMMSZkWHJrjDHGGGNChiW3xhhjjDEmZFhya4wxxhhjQoYlt8YYY4wxJmRYcmuMMcY0ESISISLPuvOJIuJrEIuatp8kIp3rUK6jiKSJyEH3r69hjo3xC0tujTHGmKYjAnj2JrafhNP/bm1mAl+qaixOH6Yzb+KYxlwX6+fWGGOMaSJE5CNgDM5AH5eAH3CGZY4DdgNPqqqKyCBgMdDeXT8JGIYzOMc/gPPAEOBF4DEgDNgK/Lu7/X4gUX8cWnWjqvYK1Ps0TZslt8YYY0wTISIxwBpVjRORRJwhT/sB3wNf4SSrO4BNwBhVLRKRJ4BkVZ0iIhuBF1R1l7u/jqpa7M6vBFap6l9EpFRVI7yOW6Kq1jTBBESLYAdgjDHGmKDZqar5ACKSAcQApTh3ctNEBKA5ztCpvgwXkRk4w7x2xBnK9S9+jtmYGllya4wxxjRdF73mr+DkBQJkquqQmjYUkTbA74AEVT0qIq8AbdzVBSIS7dUsobD+QzfGN3ugzBhjjGk6zgDhtZTZD/yTiAwBEJGWItLPx/bliewJEWkPjPfax2fARHd+Ik7zB2MCwu7cGmOMMU2Eqp4Uka9ExIPzUFiBjzJlIjIeWCIiHXByhddxmhz8AVgqTQppgwAAAHlJREFUIuUPlP0e2AfkAeleu5kHrBKRqcB3wON+e1PGVGEPlBljjDHGmJBhzRKMMcYYY0zIsOTWGGOMMcaEDEtujTHGGGNMyLDk1hhjjDHGhAxLbo0xxhhjTMiw5NYYY4wxxoQMS26NMcYYY0zIsOTWGGOMMcaEjP8HHu+34ml+li0AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 864x360 with 2 Axes>"
+      ]
+     },
+     "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",
+    "theta1_vals = np.linspace(-1, 4, 100)\n",
+    "\n",
+    "# initialize J_vals to a matrix of 0's\n",
+    "J_vals = np.zeros((theta0_vals.shape[0], theta1_vals.shape[0]))\n",
+    "\n",
+    "# Fill out J_vals\n",
+    "for i, theta0 in enumerate(theta0_vals):\n",
+    "    for j, theta1 in enumerate(theta1_vals):\n",
+    "        J_vals[i, j] = computeCost(X, y, [theta0, theta1])\n",
+    "        \n",
+    "# Because of the way meshgrids work in the surf command, we need to\n",
+    "# transpose J_vals before calling surf, or else the axes will be flipped\n",
+    "J_vals = J_vals.T\n",
+    "\n",
+    "# surface plot\n",
+    "fig = pyplot.figure(figsize=(12, 5))\n",
+    "ax = fig.add_subplot(121, projection='3d')\n",
+    "ax.plot_surface(theta0_vals, theta1_vals, J_vals, cmap='viridis')\n",
+    "pyplot.xlabel('theta0')\n",
+    "pyplot.ylabel('theta1')\n",
+    "pyplot.title('Surface')\n",
+    "\n",
+    "# contour plot\n",
+    "# Plot J_vals as 15 contours spaced logarithmically between 0.01 and 100\n",
+    "ax = pyplot.subplot(122)\n",
+    "pyplot.contour(theta0_vals, theta1_vals, J_vals, linewidths=2, cmap='viridis', levels=np.logspace(-2, 3, 20))\n",
+    "pyplot.xlabel('theta0')\n",
+    "pyplot.ylabel('theta1')\n",
+    "pyplot.plot(theta[0], theta[1], 'ro', ms=10, lw=2)\n",
+    "pyplot.title('Contour, showing minimum')\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Optional Exercises\n",
+    "\n",
+    "If you have successfully completed the material above, congratulations! You now understand linear regression and should able to start using it on your own datasets.\n",
+    "\n",
+    "For the rest of this programming exercise, we have included the following optional exercises. These exercises will help you gain a deeper understanding of the material, and if you are able to do so, we encourage you to complete them as well. You can still submit your solutions to these exercises to check if your answers are correct.\n",
+    "\n",
+    "## 3 Linear regression with multiple variables\n",
+    "\n",
+    "In this part, you will implement linear regression with multiple variables to predict the prices of houses. Suppose you are selling your house and you want to know what a good market price would be. One way to do this is to first collect information on recent houses sold and make a model of housing prices.\n",
+    "\n",
+    "The file `Data/ex1data2.txt` contains a training set of housing prices in Portland, Oregon. The first column is the size of the house (in square feet), the second column is the number of bedrooms, and the third column is the price\n",
+    "of the house. \n",
+    "\n",
+    "<a id=\"section4\"></a>\n",
+    "### 3.1 Feature Normalization\n",
+    "\n",
+    "We start by loading and displaying some values from this dataset. By looking at the values, note that house sizes are about 1000 times the number of bedrooms. When features differ by orders of magnitude, first performing feature scaling can make gradient descent converge much more quickly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "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",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]\n",
+    "m = y.size\n",
+    "\n",
+    "# print out some data points\n",
+    "print('{:>8s}{:>8s}{:>10s}'.format('X[:,0]', 'X[:, 1]', 'y'))\n",
+    "print('-'*26)\n",
+    "for i in range(10):\n",
+    "    print('{:8.0f}{:8.0f}{:10.0f}'.format(X[i, 0], X[i, 1], y[i]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your task here is to complete the code in `featureNormalize` function:\n",
+    "- Subtract the mean value of each feature from the dataset.\n",
+    "- After subtracting the mean, additionally scale (divide) the feature values by their respective “standard deviations.”\n",
+    "\n",
+    "The standard deviation is a way of measuring how much variation there is in the range of values of a particular feature (most data points will lie within ±2 standard deviations of the mean); this is an alternative to taking the range of values (max-min). In `numpy`, you can use the `std` function to compute the standard deviation. \n",
+    "\n",
+    "For example, the quantity `X[:, 0]` contains all the values of $x_1$ (house sizes) in the training set, so `np.std(X[:, 0])` computes the standard deviation of the house sizes.\n",
+    "At the time that the function `featureNormalize` is called, the extra column of 1’s corresponding to $x_0 = 1$ has not yet been added to $X$. \n",
+    "\n",
+    "You will do this for all the features and your code should work with datasets of all sizes (any number of features / examples). Note that each column of the matrix $X$ corresponds to one feature.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** When normalizing the features, it is important\n",
+    "to store the values used for normalization - the mean value and the standard deviation used for the computations. After learning the parameters\n",
+    "from the model, we often want to predict the prices of houses we have not\n",
+    "seen before. Given a new x value (living room area and number of bedrooms), we must first normalize x using the mean and standard deviation that we had previously computed from the training set.\n",
+    "</div>\n",
+    "<a id=\"featureNormalize\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def  featureNormalize(X):\n",
+    "    \"\"\"\n",
+    "    Normalizes the features in X. returns a normalized version of X where\n",
+    "    the mean value of each feature is 0 and the standard deviation\n",
+    "    is 1. This is often a good preprocessing step to do when working with\n",
+    "    learning algorithms.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    X_norm : array_like\n",
+    "        The normalized dataset of shape (m x n).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    First, for each feature dimension, compute the mean of the feature\n",
+    "    and subtract it from the dataset, storing the mean value in mu. \n",
+    "    Next, compute the  standard deviation of each feature and divide\n",
+    "    each feature by it's standard deviation, storing the standard deviation \n",
+    "    in sigma. \n",
+    "    \n",
+    "    Note that X is a matrix where each column is a feature and each row is\n",
+    "    an example. You needto perform the normalization separately for each feature. \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You might find the 'np.mean' and 'np.std' functions useful.\n",
+    "    \"\"\"\n",
+    "    # You need to set these values correctly\n",
+    "    X_norm = X.copy()\n",
+    "    mu = np.zeros(X.shape[1])\n",
+    "    sigma = np.zeros(X.shape[1])\n",
+    "    n = X.shape[1]\n",
+    "\n",
+    "    # =========================== YOUR CODE HERE =====================\n",
+    "    for i in range(n):\n",
+    "        mu[i] = np.mean(X[:,i])\n",
+    "    for i in range(n):\n",
+    "        sigma[i] = np.std(X[:,i])\n",
+    "    for i in range(n):\n",
+    "        X_norm[:,i] = (X[:,i]-mu[i])/sigma[i]\n",
+    "    \n",
+    "    # ================================================================\n",
+    "    return X_norm, mu, sigma"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Execute the next cell to run the implemented `featureNormalize` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computed mean: [2000.68085106    3.17021277]\n",
+      "Computed standard deviation: [7.86202619e+02 7.52842809e-01]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# call featureNormalize on the loaded data\n",
+    "X_norm, mu, sigma = featureNormalize(X)\n",
+    "\n",
+    "print('Computed mean:', mu)\n",
+    "print('Computed standard deviation:', sigma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should not submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[4] = featureNormalize\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After the `featureNormalize` function is tested, we now add the intercept term to `X_norm`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section5\"></a>\n",
+    "### 3.2 Gradient Descent\n",
+    "\n",
+    "Previously, you implemented gradient descent on a univariate regression problem. The only difference now is that there is one more feature in the matrix $X$. The hypothesis function and the batch gradient descent update\n",
+    "rule remain unchanged. \n",
+    "\n",
+    "You should complete the code for the functions `computeCostMulti` and `gradientDescentMulti` to implement the cost function and gradient descent for linear regression with multiple variables. If your code in the previous part (single variable) already supports multiple variables, you can use it here too.\n",
+    "Make sure your code supports any number of features and is well-vectorized.\n",
+    "You can use the `shape` property of `numpy` arrays to find out how many features are present in the dataset.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** In the multivariate case, the cost function can\n",
+    "also be written in the following vectorized form:\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{2m}(X\\theta - \\vec{y})^T(X\\theta - \\vec{y}) $$\n",
+    "\n",
+    "where \n",
+    "\n",
+    "$$ X = \\begin{pmatrix}\n",
+    "          - (x^{(1)})^T - \\\\\n",
+    "          - (x^{(2)})^T - \\\\\n",
+    "          \\vdots \\\\\n",
+    "          - (x^{(m)})^T - \\\\ \\\\\n",
+    "        \\end{pmatrix} \\qquad \\mathbf{y} = \\begin{bmatrix} y^{(1)} \\\\ y^{(2)} \\\\ \\vdots \\\\ y^{(m)} \\\\\\end{bmatrix}$$\n",
+    "\n",
+    "the vectorized version is efficient when you are working with numerical computing tools like `numpy`. If you are an expert with matrix operations, you can prove to yourself that the two forms are equivalent.\n",
+    "</div>\n",
+    "\n",
+    "<a id=\"computeCostMulti\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def computeCostMulti(X, y, theta):\n",
+    "    \"\"\"\n",
+    "    Compute cost for linear regression with multiple variables.\n",
+    "    Computes the cost of using theta as the parameter for linear regression to fit the data points in X and y.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        A vector of shape (m, ) for the values at a given data point.\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The linear regression parameters. A vector of shape (n+1, )\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The value of the cost function. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to the cost.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0] # number of training examples\n",
+    "    \n",
+    "    # You need to return the following variable correctly\n",
+    "    J = 0\n",
+    "    \n",
+    "    # ======================= YOUR CODE HERE ===========================\n",
+    "    J = (np.sum(np.square(np.dot(X,theta)-y)))/(2*m)\n",
+    "    \n",
+    "    # ==================================================================\n",
+    "    return J\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | Nice work!\n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[5] = computeCostMulti\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"gradientDescentMulti\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gradientDescentMulti(X, y, theta, alpha, num_iters):\n",
+    "    \"\"\"\n",
+    "    Performs gradient descent to learn theta.\n",
+    "    Updates theta by taking num_iters gradient steps with learning rate alpha.\n",
+    "        \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        A vector of shape (m, ) for the values at a given data point.\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The linear regression parameters. A vector of shape (n+1, )\n",
+    "    \n",
+    "    alpha : float\n",
+    "        The learning rate for gradient descent. \n",
+    "    \n",
+    "    num_iters : int\n",
+    "        The number of iterations to run gradient descent. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The learned linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    J_history : list\n",
+    "        A python list for the values of the cost function after each iteration.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Peform a single gradient step on the parameter vector theta.\n",
+    "\n",
+    "    While debugging, it can be useful to print out the values of \n",
+    "    the cost function (computeCost) and gradient here.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0] # number of training examples\n",
+    "    \n",
+    "    # make a copy of theta, which will be updated by gradient descent\n",
+    "    theta = theta.copy()\n",
+    "    \n",
+    "    J_history = []\n",
+    "    \n",
+    "    for i in range(num_iters):\n",
+    "        # ======================= YOUR CODE HERE ==========================\n",
+    "        theta = theta - (alpha/m)*(np.dot(X.transpose(),(np.dot(X,theta)-y)))\n",
+    "        \n",
+    "        # =================================================================\n",
+    "        \n",
+    "        # save the cost J in every iteration\n",
+    "        J_history.append(computeCostMulti(X, y, theta))\n",
+    "    \n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | Nice work!\n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | Nice work!\n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[6] = gradientDescentMulti\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.2.1 Optional (ungraded) exercise: Selecting learning rates\n",
+    "\n",
+    "In this part of the exercise, you will get to try out different learning rates for the dataset and find a learning rate that converges quickly. You can change the learning rate by modifying the following code and changing the part of the code that sets the learning rate.\n",
+    "\n",
+    "Use your implementation of `gradientDescentMulti` function and run gradient descent for about 50 iterations at the chosen learning rate. The function should also return the history of $J(\\theta)$ values in a vector $J$.\n",
+    "\n",
+    "After the last iteration, plot the J values against the number of the iterations.\n",
+    "\n",
+    "If you picked a learning rate within a good range, your plot look similar as the following Figure. \n",
+    "\n",
+    "![](Figures/learning_rate.png)\n",
+    "\n",
+    "If your graph looks very different, especially if your value of $J(\\theta)$ increases or even blows up, adjust your learning rate and try again. We recommend trying values of the learning rate $\\alpha$ on a log-scale, at multiplicative steps of about 3 times the previous value (i.e., 0.3, 0.1, 0.03, 0.01 and so on). You may also want to adjust the number of iterations you are running if that will help you see the overall trend in the curve.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** If your learning rate is too large, $J(\\theta)$ can diverge and ‘blow up’, resulting in values which are too large for computer calculations. In these situations, `numpy` will tend to return\n",
+    "NaNs. NaN stands for ‘not a number’ and is often caused by undefined operations that involve −∞ and +∞.\n",
+    "</div>\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**MATPLOTLIB tip:** To compare how different learning learning rates affect convergence, it is helpful to plot $J$ for several learning rates on the same figure. This can be done by making `alpha` a python list, and looping across the values within this list, and calling the plot function in every iteration of the loop. It is also useful to have a legend to distinguish the different lines within the plot. Search online for `pyplot.legend` for help on showing legends in `matplotlib`.\n",
+    "</div>\n",
+    "\n",
+    "Notice the changes in the convergence curves as the learning rate changes. With a small learning rate, you should find that gradient descent takes a very long time to converge to the optimal value. Conversely, with a large learning rate, gradient descent might not converge or might even diverge!\n",
+    "Using the best learning rate that you found, run the script\n",
+    "to run gradient descent until convergence to find the final values of $\\theta$. Next,\n",
+    "use this value of $\\theta$ to predict the price of a house with 1650 square feet and\n",
+    "3 bedrooms. You will use value later to check your implementation of the normal equations. Don’t forget to normalize your features when you make this prediction!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "theta computed from gradient descent: [340412.57680449 109372.3081412   -6502.86652974]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $293098\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "Instructions\n",
+    "------------\n",
+    "We have provided you with the following starter code that runs\n",
+    "gradient descent with a particular learning rate (alpha). \n",
+    "\n",
+    "Your task is to first make sure that your functions - `computeCost`\n",
+    "and `gradientDescent` already work with  this starter code and\n",
+    "support multiple variables.\n",
+    "\n",
+    "After that, try running gradient descent with different values of\n",
+    "alpha and see which one gives you the best result.\n",
+    "\n",
+    "Finally, you should complete the code at the end to predict the price\n",
+    "of a 1650 sq-ft, 3 br house.\n",
+    "\n",
+    "Hint\n",
+    "----\n",
+    "At prediction, make sure you do the same feature normalization.\n",
+    "\"\"\"\n",
+    "# Choose some alpha value - change this\n",
+    "alpha = 0.03\n",
+    "num_iters = 500\n",
+    "\n",
+    "# init theta and run gradient descent\n",
+    "theta = np.zeros(3)\n",
+    "theta, J_history = gradientDescentMulti(X, y, theta, alpha, num_iters)\n",
+    "\n",
+    "# Plot the convergence graph\n",
+    "pyplot.plot(np.arange(len(J_history)), J_history, lw=2)\n",
+    "pyplot.xlabel('Number of iterations')\n",
+    "pyplot.ylabel('Cost J')\n",
+    "\n",
+    "# Display the gradient descent's result\n",
+    "print('theta computed from gradient descent: {:s}'.format(str(theta)))\n",
+    "\n",
+    "# Estimate the price of a 1650 sq-ft, 3 br house\n",
+    "# ======================= YOUR CODE HERE ===========================\n",
+    "\n",
+    "# Recall that the first column of X is all-ones. \n",
+    "# Thus, it does not need to be normalized.\n",
+    "\n",
+    "price = 0   # You should change this\n",
+    "price = theta[0]*1 + theta[1]*((1650-mu[0])/sigma[0]) + theta[2]*((3-mu[1])/sigma[1])\n",
+    "# ===================================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): ${:.0f}'.format(price))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You do not need to submit any solutions for this optional (ungraded) part.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section7\"></a>\n",
+    "### 3.3 Normal Equations\n",
+    "\n",
+    "In the lecture videos, you learned that the closed-form solution to linear regression is\n",
+    "\n",
+    "$$ \\theta = \\left( X^T X\\right)^{-1} X^T\\vec{y}$$\n",
+    "\n",
+    "Using this formula does not require any feature scaling, and you will get an exact solution in one calculation: there is no “loop until convergence” like in gradient descent. \n",
+    "\n",
+    "First, we will reload the data to ensure that the variables have not been modified. Remember that while you do not need to scale your features, we still need to add a column of 1’s to the $X$ matrix to have an intercept term ($\\theta_0$). The code in the next cell will add the column of 1’s to X for you."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]\n",
+    "m = y.size\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Complete the code for the function `normalEqn` below to use the formula above to calculate $\\theta$. \n",
+    "\n",
+    "<a id=\"normalEqn\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def normalEqn(X, y):\n",
+    "    \"\"\"\n",
+    "    Computes the closed-form solution to linear regression using the normal equations.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The value at each data point. A vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        Estimated linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the code to compute the closed form solution to linear\n",
+    "    regression and put the result in theta.\n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    Look up the function `np.linalg.pinv` for computing matrix inverse.\n",
+    "    \"\"\"\n",
+    "    theta = np.zeros(X.shape[1])\n",
+    "    \n",
+    "    # ===================== YOUR CODE HERE ============================\n",
+    "    theta = np.dot(np.dot(np.linalg.inv(np.dot(X.transpose(),X)),X.transpose()),y)\n",
+    "    \n",
+    "    # =================================================================\n",
+    "    return theta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | Nice work!\n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | Nice work!\n",
+      "                           Normal Equations |   0 /   0 | Nice work!\n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[7] = normalEqn\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Optional (ungraded) exercise: Now, once you have found $\\theta$ using this\n",
+    "method, use it to make a price prediction for a 1650-square-foot house with\n",
+    "3 bedrooms. You should find that gives the same predicted price as the value\n",
+    "you obtained using the model fit with gradient descent (in Section 3.2.1)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Theta computed from the normal equations: [89597.9095428    139.21067402 -8738.01911233]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using normal equations): $293081\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate the parameters from the normal equation\n",
+    "theta = normalEqn(X, y);\n",
+    "\n",
+    "# Display normal equation's result\n",
+    "print('Theta computed from the normal equations: {:s}'.format(str(theta)));\n",
+    "\n",
+    "# Estimate the price of a 1650 sq-ft, 3 br house\n",
+    "# ====================== YOUR CODE HERE ======================\n",
+    "\n",
+    "price = 0 # You should change this\n",
+    "price = theta[0]*1 + theta[1]*1650 + theta[2]*3\n",
+    "# ============================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations): ${:.0f}'.format(price))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Exercise1/Data/ex1data1.txt b/Exercise1/Data/ex1data1.txt
new file mode 100755
index 0000000..0f88ccb
--- /dev/null
+++ b/Exercise1/Data/ex1data1.txt
@@ -0,0 +1,97 @@
+6.1101,17.592
+5.5277,9.1302
+8.5186,13.662
+7.0032,11.854
+5.8598,6.8233
+8.3829,11.886
+7.4764,4.3483
+8.5781,12
+6.4862,6.5987
+5.0546,3.8166
+5.7107,3.2522
+14.164,15.505
+5.734,3.1551
+8.4084,7.2258
+5.6407,0.71618
+5.3794,3.5129
+6.3654,5.3048
+5.1301,0.56077
+6.4296,3.6518
+7.0708,5.3893
+6.1891,3.1386
+20.27,21.767
+5.4901,4.263
+6.3261,5.1875
+5.5649,3.0825
+18.945,22.638
+12.828,13.501
+10.957,7.0467
+13.176,14.692
+22.203,24.147
+5.2524,-1.22
+6.5894,5.9966
+9.2482,12.134
+5.8918,1.8495
+8.2111,6.5426
+7.9334,4.5623
+8.0959,4.1164
+5.6063,3.3928
+12.836,10.117
+6.3534,5.4974
+5.4069,0.55657
+6.8825,3.9115
+11.708,5.3854
+5.7737,2.4406
+7.8247,6.7318
+7.0931,1.0463
+5.0702,5.1337
+5.8014,1.844
+11.7,8.0043
+5.5416,1.0179
+7.5402,6.7504
+5.3077,1.8396
+7.4239,4.2885
+7.6031,4.9981
+6.3328,1.4233
+6.3589,-1.4211
+6.2742,2.4756
+5.6397,4.6042
+9.3102,3.9624
+9.4536,5.4141
+8.8254,5.1694
+5.1793,-0.74279
+21.279,17.929
+14.908,12.054
+18.959,17.054
+7.2182,4.8852
+8.2951,5.7442
+10.236,7.7754
+5.4994,1.0173
+20.341,20.992
+10.136,6.6799
+7.3345,4.0259
+6.0062,1.2784
+7.2259,3.3411
+5.0269,-2.6807
+6.5479,0.29678
+7.5386,3.8845
+5.0365,5.7014
+10.274,6.7526
+5.1077,2.0576
+5.7292,0.47953
+5.1884,0.20421
+6.3557,0.67861
+9.7687,7.5435
+6.5159,5.3436
+8.5172,4.2415
+9.1802,6.7981
+6.002,0.92695
+5.5204,0.152
+5.0594,2.8214
+5.7077,1.8451
+7.6366,4.2959
+5.8707,7.2029
+5.3054,1.9869
+8.2934,0.14454
+13.394,9.0551
+5.4369,0.61705
diff --git a/Exercise1/Data/ex1data2.txt b/Exercise1/Data/ex1data2.txt
new file mode 100755
index 0000000..79e9a80
--- /dev/null
+++ b/Exercise1/Data/ex1data2.txt
@@ -0,0 +1,47 @@
+2104,3,399900
+1600,3,329900
+2400,3,369000
+1416,2,232000
+3000,4,539900
+1985,4,299900
+1534,3,314900
+1427,3,198999
+1380,3,212000
+1494,3,242500
+1940,4,239999
+2000,3,347000
+1890,3,329999
+4478,5,699900
+1268,3,259900
+2300,4,449900
+1320,2,299900
+1236,3,199900
+2609,4,499998
+3031,4,599000
+1767,3,252900
+1888,2,255000
+1604,3,242900
+1962,4,259900
+3890,3,573900
+1100,3,249900
+1458,3,464500
+2526,3,469000
+2200,3,475000
+2637,3,299900
+1839,2,349900
+1000,1,169900
+2040,4,314900
+3137,3,579900
+1811,4,285900
+1437,3,249900
+1239,3,229900
+2132,4,345000
+4215,4,549000
+2162,4,287000
+1664,2,368500
+2238,3,329900
+2567,4,314000
+1200,3,299000
+852,2,179900
+1852,4,299900
+1203,3,239500
diff --git a/Exercise1/Figures/cost_function.png b/Exercise1/Figures/cost_function.png
new file mode 100755
index 0000000..b5f175f
Binary files /dev/null and b/Exercise1/Figures/cost_function.png differ
diff --git a/Exercise1/Figures/dataset1.png b/Exercise1/Figures/dataset1.png
new file mode 100755
index 0000000..8bded89
Binary files /dev/null and b/Exercise1/Figures/dataset1.png differ
diff --git a/Exercise1/Figures/learning_rate.png b/Exercise1/Figures/learning_rate.png
new file mode 100755
index 0000000..8701bb9
Binary files /dev/null and b/Exercise1/Figures/learning_rate.png differ
diff --git a/Exercise1/Figures/regression_result.png b/Exercise1/Figures/regression_result.png
new file mode 100755
index 0000000..622a6ec
Binary files /dev/null and b/Exercise1/Figures/regression_result.png differ
diff --git a/Exercise1/__pycache__/utils.cpython-37.pyc b/Exercise1/__pycache__/utils.cpython-37.pyc
new file mode 100644
index 0000000..1e2a402
Binary files /dev/null and b/Exercise1/__pycache__/utils.cpython-37.pyc differ
diff --git a/Exercise1/exercise1.ipynb b/Exercise1/exercise1.ipynb
new file mode 100755
index 0000000..b3f2bc1
--- /dev/null
+++ b/Exercise1/exercise1.ipynb
@@ -0,0 +1,1640 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Programming Exercise 1: Linear Regression\n",
+    "\n",
+    "## Introduction\n",
+    "\n",
+    "In this exercise, you will implement linear regression and get to see it work on data. Before starting on this programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\n",
+    "\n",
+    "All the information you need for solving this assignment is in this notebook, and all the code you will be implementing will take place within this notebook. The assignment can be promptly submitted to the coursera grader directly from this notebook (code and instructions are included below).\n",
+    "\n",
+    "Before we begin with the exercises, we need to import all libraries required for this programming exercise. Throughout the course, we will be using [`numpy`](http://www.numpy.org/) for all arrays and matrix operations, and [`matplotlib`](https://matplotlib.org/) for plotting.\n",
+    "\n",
+    "You can find instructions on how to install required libraries in the README file in the [github repository](https://github.com/dibgerge/ml-coursera-python-assignments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "from mpl_toolkits.mplot3d import Axes3D  # needed to plot 3-D surfaces\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils \n",
+    "\n",
+    "# define the submission/grader object for this exercise\n",
+    "grader = utils.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Submission and Grading\n",
+    "\n",
+    "After completing each part of the assignment, be sure to submit your solutions to the grader.\n",
+    "\n",
+    "For this programming exercise, you are only required to complete the first part of the exercise to implement linear regression with one variable. The second part of the exercise, which is optional, covers linear regression with multiple variables. The following is a breakdown of how each part of this exercise is scored.\n",
+    "\n",
+    "**Required Exercises**\n",
+    "\n",
+    "| Section | Part                                           |Submitted Function                     | Points \n",
+    "|---------|:-                                             |:-                                     | :-:    \n",
+    "| 1       | [Warm up exercise](#section1)                  | [`warmUpExercise`](#warmUpExercise)    |  10    \n",
+    "| 2       | [Compute cost for one variable](#section2)     | [`computeCost`](#computeCost)         |  40    \n",
+    "| 3       | [Gradient descent for one variable](#section3) | [`gradientDescent`](#gradientDescent) |  50    \n",
+    "|         | Total Points                                   |                                       | 100    \n",
+    "\n",
+    "**Optional Exercises**\n",
+    "\n",
+    "| Section | Part                                                 | Submitted Function | Points |\n",
+    "|:-------:|:-                                                    |:-:                  | :-:    |\n",
+    "| 4       | [Feature normalization](#section4)                   | [`featureNormalize`](#featureNormalize) | 0      |\n",
+    "| 5       | [Compute cost for multiple variables](#section5)     | [`computeCostMulti`](#computeCostMulti) | 0      |\n",
+    "| 6       | [Gradient descent for multiple variables](#section5) | [`gradientDescentMulti`](#gradientDescentMulti) |0      |\n",
+    "| 7       | [Normal Equations](#section7)                        | [`normalEqn`](#normalEqn)        | 0      |\n",
+    "\n",
+    "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "At the end of each section in this notebook, we have a cell which contains code for submitting the solutions thus far to the grader. Execute the cell to see your score up to the current section. For all your work to be submitted properly, you must execute those cells at least once. They must also be re-executed everytime the submitted function is updated.\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "## Debugging\n",
+    "\n",
+    "Here are some things to keep in mind throughout this exercise:\n",
+    "\n",
+    "- Python array indices start from zero, not one (contrary to OCTAVE/MATLAB). \n",
+    "\n",
+    "- There is an important distinction between python arrays (called `list` or `tuple`) and `numpy` arrays. You should use `numpy` arrays in all your computations. Vector/matrix operations work only with `numpy` arrays. Python lists do not support vector operations (you need to use for loops).\n",
+    "\n",
+    "- If you are seeing many errors at runtime, inspect your matrix operations to make sure that you are adding and multiplying matrices of compatible dimensions. Printing the dimensions of `numpy` arrays using the `shape` property will help you debug.\n",
+    "\n",
+    "- By default, `numpy` interprets math operators to be element-wise operators. If you want to do matrix multiplication, you need to use the `dot` function in `numpy`. For, example if `A` and `B` are two `numpy` matrices, then the matrix operation AB is `np.dot(A, B)`. Note that for 2-dimensional matrices or vectors (1-dimensional), this is also equivalent to `A@B` (requires python >= 3.5)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section1\"></a>\n",
+    "## 1 Simple python and `numpy` function\n",
+    "\n",
+    "The first part of this assignment gives you practice with python and `numpy` syntax and the homework submission process. In the next cell, you will find the outline of a `python` function. Modify it to return a 5 x 5 identity matrix by filling in the following code:\n",
+    "\n",
+    "```python\n",
+    "A = np.eye(5)\n",
+    "```\n",
+    "<a id=\"warmUpExercise\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def warmUpExercise():\n",
+    "    \"\"\"\n",
+    "    Example function in Python which computes the identity matrix.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    A : array_like\n",
+    "        The 5x5 identity matrix.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Return the 5x5 identity matrix.\n",
+    "    \"\"\"    \n",
+    "    # ======== YOUR CODE HERE ======\n",
+    "    A = np.eye(5)   # modify this line\n",
+    "    \n",
+    "    # ==============================\n",
+    "    return A"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The previous cell only defines the function `warmUpExercise`. We can now run it by executing the following cell to see its output. You should see output similar to the following:\n",
+    "\n",
+    "```python\n",
+    "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.]])\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "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()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Submitting solutions\n",
+    "\n",
+    "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the grader object, and then sending your function to Coursera for grading. \n",
+    "\n",
+    "The grader will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "Execute the next cell to grade your solution to the first part of this exercise.\n",
+    "\n",
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Login (email address): videhraj29072000@gmail.com\n",
+      "Token: GnvUtUiXqleSQ6eA\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |   0 /  40 | \n",
+      "        Gradient Descent (for one variable) |   0 /  50 | \n",
+      "                      Feature Normalization |   0 /   0 | \n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  10 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# appends the implemented function in part 1 to the grader object\n",
+    "grader[1] = warmUpExercise\n",
+    "\n",
+    "# send the added functions to coursera grader for getting a grade on this part\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2 Linear regression with one variable\n",
+    "\n",
+    "Now you will implement linear regression with one variable to predict profits for a food truck. Suppose you are the CEO of a restaurant franchise and are considering different cities for opening a new outlet. The chain already has trucks in various cities and you have data for profits and populations from the cities. You would like to use this data to help you select which city to expand to next. \n",
+    "\n",
+    "The file `Data/ex1data1.txt` contains the dataset for our linear regression problem. The first column is the population of a city (in 10,000s) and the second column is the profit of a food truck in that city (in $10,000s). A negative value for profit indicates a loss. \n",
+    "\n",
+    "We provide you with the code needed to load this data. The dataset is loaded from the data file into the variables `x` and `y`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Read comma separated data\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex1data1.txt'), delimiter=',')\n",
+    "X, y = data[:, 0], data[:, 1]\n",
+    "\n",
+    "m = y.size  # number of training examples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1 Plotting the Data\n",
+    "\n",
+    "Before starting on any task, it is often useful to understand the data by visualizing it. For this dataset, you can use a scatter plot to visualize the data, since it has only two properties to plot (profit and population). Many other problems that you will encounter in real life are multi-dimensional and cannot be plotted on a 2-d plot. There are many plotting libraries in python (see this [blog post](https://blog.modeanalytics.com/python-data-visualization-libraries/) for a good summary of the most popular ones). \n",
+    "\n",
+    "In this course, we will be exclusively using `matplotlib` to do all our plotting. `matplotlib` is one of the most popular scientific plotting libraries in python and has extensive tools and functions to make beautiful plots. `pyplot` is a module within `matplotlib` which provides a simplified interface to `matplotlib`'s most common plotting tasks, mimicking MATLAB's plotting interface.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "You might have noticed that we have imported the `pyplot` module at the beginning of this exercise using the command `from matplotlib import pyplot`. This is rather uncommon, and if you look at python code elsewhere or in the `matplotlib` tutorials, you will see that the module is named `plt`. This is used by module renaming by using the import command `import matplotlib.pyplot as plt`. We will not using the short name of `pyplot` module in this class exercises, but you should be aware of this deviation from norm.\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "In the following part, your first job is to complete the `plotData` function below. Modify the function and fill in the following code:\n",
+    "\n",
+    "```python\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",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(x, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points x and y into a new figure. Plots the data \n",
+    "    points and gives the figure axes labels of population and profit.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    x : array_like\n",
+    "        Data point values for x-axis.\n",
+    "\n",
+    "    y : array_like\n",
+    "        Data point values for y-axis. Note x and y should have the same size.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the training data into a figure using the \"figure\" and \"plot\"\n",
+    "    functions. Set the axes labels using the \"xlabel\" and \"ylabel\" functions.\n",
+    "    Assume the population and revenue data have been passed in as the x\n",
+    "    and y arguments of this function.    \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You can use the 'ro' option with plot to have the markers\n",
+    "    appear as red circles. Furthermore, you can make the markers larger by\n",
+    "    using plot(..., 'ro', ms=10), where `ms` refers to marker size. You \n",
+    "    can also set the marker edge color using the `mec` property.\n",
+    "    \"\"\"\n",
+    "    fig = pyplot.figure()  # open a new figure\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE ======================= \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"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now run the defined function with the loaded data to visualize the data. The end result should look like the following figure:\n",
+    "\n",
+    "![](Figures/dataset1.png)\n",
+    "\n",
+    "Execute the next cell to visualize the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plotData(X, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To quickly learn more about the `matplotlib` plot function and what arguments you can provide to it, you can type `?pyplot.plot` in a cell within the jupyter notebook. This opens a separate page showing the documentation for the requested function. You can also search online for plotting documentation. \n",
+    "\n",
+    "To set the markers to red circles, we used the option `'or'` within the `plot` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "?pyplot.plot"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section2\"></a>\n",
+    "### 2.2 Gradient Descent\n",
+    "\n",
+    "In this part, you will fit the linear regression parameters $\\theta$ to our dataset using gradient descent.\n",
+    "\n",
+    "#### 2.2.1 Update Equations\n",
+    "\n",
+    "The objective of linear regression is to minimize the cost function\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{2m} \\sum_{i=1}^m \\left( h_{\\theta}(x^{(i)}) - y^{(i)}\\right)^2$$\n",
+    "\n",
+    "where the hypothesis $h_\\theta(x)$ is given by the linear model\n",
+    "$$ h_\\theta(x) = \\theta^Tx = \\theta_0 + \\theta_1 x_1$$\n",
+    "\n",
+    "Recall that the parameters of your model are the $\\theta_j$ values. These are\n",
+    "the values you will adjust to minimize cost $J(\\theta)$. One way to do this is to\n",
+    "use the batch gradient descent algorithm. In batch gradient descent, each\n",
+    "iteration performs the update\n",
+    "\n",
+    "$$ \\theta_j = \\theta_j - \\alpha \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta(x^{(i)}) - y^{(i)}\\right)x_j^{(i)} \\qquad \\text{simultaneously update } \\theta_j \\text{ for all } j$$\n",
+    "\n",
+    "With each step of gradient descent, your parameters $\\theta_j$ come closer to the optimal values that will achieve the lowest cost J($\\theta$).\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** We store each example as a row in the the $X$ matrix in Python `numpy`. To take into account the intercept term ($\\theta_0$), we add an additional first column to $X$ and set it to all ones. This allows us to treat $\\theta_0$ as simply another 'feature'.\n",
+    "</div>\n",
+    "\n",
+    "\n",
+    "#### 2.2.2 Implementation\n",
+    "\n",
+    "We have already set up the data for linear regression. In the following cell, we add another dimension to our data to accommodate the $\\theta_0$ intercept term. Do NOT execute this cell more than once."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add a column of ones to X. The numpy function stack joins arrays along a given axis. \n",
+    "# The first axis (axis=0) refers to rows (training examples) \n",
+    "# and second axis (axis=1) refers to columns (features).\n",
+    "X = np.stack([np.ones(m), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section2\"></a>\n",
+    "#### 2.2.3 Computing the cost $J(\\theta)$\n",
+    "\n",
+    "As you perform gradient descent to learn minimize the cost function $J(\\theta)$, it is helpful to monitor the convergence by computing the cost. In this section, you will implement a function to calculate $J(\\theta)$ so you can check the convergence of your gradient descent implementation. \n",
+    "\n",
+    "Your next task is to complete the code for the function `computeCost` which computes $J(\\theta)$. As you are doing this, remember that the variables $X$ and $y$ are not scalar values. $X$ is a matrix whose rows represent the examples from the training set and $y$ is a vector whose each elemennt represent the value at a given row of $X$.\n",
+    "<a id=\"computeCost\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def computeCost(X, y, theta):\n",
+    "    \"\"\"\n",
+    "    Compute cost for linear regression. Computes the cost of using theta as the\n",
+    "    parameter for linear regression to fit the data points in X and y.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1), where m is the number of examples,\n",
+    "        and n is the number of features. We assume a vector of one's already \n",
+    "        appended to the features so we have n+1 columns.\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The values of the function at each data point. This is a vector of\n",
+    "        shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The parameters for the regression function. This is a vector of \n",
+    "        shape (n+1, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The value of the regression cost function.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. \n",
+    "    You should set J to the cost.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "    \n",
+    "    # You need to return the following variables correctly\n",
+    "    J = 0\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE =====================\n",
+    "    J = (np.sum(np.square(np.dot(X,theta)-y)))/(2*m)\n",
+    "    \n",
+    "    # ===========================================================\n",
+    "    return J"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you have completed the function, the next step will run `computeCost` two times using two different initializations of $\\theta$. You will see the cost printed to the screen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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",
+    "print('Expected cost value (approximately) 32.07\\n')\n",
+    "\n",
+    "# further testing of the cost function\n",
+    "J = computeCost(X, y, theta=np.array([-1, 2]))\n",
+    "print('With theta = [-1, 2]\\nCost computed = %.2f' % J)\n",
+    "print('Expected cost value (approximately) 54.24')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions by executing the following cell.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): Y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |   0 /  50 | \n",
+      "                      Feature Normalization |   0 /   0 | \n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  50 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[2] = computeCost\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section3\"></a>\n",
+    "#### 2.2.4 Gradient descent\n",
+    "\n",
+    "Next, you will complete a function which implements gradient descent.\n",
+    "The loop structure has been written for you, and you only need to supply the updates to $\\theta$ within each iteration. \n",
+    "\n",
+    "As you program, make sure you understand what you are trying to optimize and what is being updated. Keep in mind that the cost $J(\\theta)$ is parameterized by the vector $\\theta$, not $X$ and $y$. That is, we minimize the value of $J(\\theta)$ by changing the values of the vector $\\theta$, not by changing $X$ or $y$. [Refer to the equations in this notebook](#section2) and to the video lectures if you are uncertain. A good way to verify that gradient descent is working correctly is to look at the value of $J(\\theta)$ and check that it is decreasing with each step. \n",
+    "\n",
+    "The starter code for the function `gradientDescent` calls `computeCost` on every iteration and saves the cost to a `python` list. Assuming you have implemented gradient descent and `computeCost` correctly, your value of $J(\\theta)$ should never increase, and should converge to a steady value by the end of the algorithm.\n",
+    "\n",
+    "<div class=\"alert alert-box alert-warning\">\n",
+    "**Vectors and matrices in `numpy`** - Important implementation notes\n",
+    "\n",
+    "A vector in `numpy` is a one dimensional array, for example `np.array([1, 2, 3])` is a vector. A matrix in `numpy` is a two dimensional array, for example `np.array([[1, 2, 3], [4, 5, 6]])`. However, the following is still considered a matrix `np.array([[1, 2, 3]])` since it has two dimensions, even if it has a shape of 1x3 (which looks like a vector).\n",
+    "\n",
+    "Given the above, the function `np.dot` which we will use for all matrix/vector multiplication has the following properties:\n",
+    "- It always performs inner products on vectors. If `x=np.array([1, 2, 3])`, then `np.dot(x, x)` is a scalar.\n",
+    "- For matrix-vector multiplication, so if $X$ is a $m\\times n$ matrix and $y$ is a vector of length $m$, then the operation `np.dot(y, X)` considers $y$ as a $1 \\times m$ vector. On the other hand, if $y$ is a vector of length $n$, then the operation `np.dot(X, y)` considers $y$ as a $n \\times 1$ vector.\n",
+    "- A vector can be promoted to a matrix using `y[None]` or `[y[np.newaxis]`. That is, if `y = np.array([1, 2, 3])` is a vector of size 3, then `y[None, :]` is a matrix of shape $1 \\times 3$. We can use `y[:, None]` to obtain a shape of $3 \\times 1$.\n",
+    "<div>\n",
+    "<a id=\"gradientDescent\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gradientDescent(X, y, theta, alpha, num_iters):\n",
+    "    \"\"\"\n",
+    "    Performs gradient descent to learn `theta`. Updates theta by taking `num_iters`\n",
+    "    gradient steps with learning rate `alpha`.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        Value at given features. A vector of shape (m, ).\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        Initial values for the linear regression parameters. \n",
+    "        A vector of shape (n+1, ).\n",
+    "    \n",
+    "    alpha : float\n",
+    "        The learning rate.\n",
+    "    \n",
+    "    num_iters : int\n",
+    "        The number of iterations for gradient descent. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The learned linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    J_history : list\n",
+    "        A python list for the values of the cost function after each iteration.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Peform a single gradient step on the parameter vector theta.\n",
+    "\n",
+    "    While debugging, it can be useful to print out the values of \n",
+    "    the cost function (computeCost) and gradient here.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0]  # number of training examples\n",
+    "    \n",
+    "    # make a copy of theta, to avoid changing the original array, since numpy arrays\n",
+    "    # are passed by reference to functions\n",
+    "    theta = theta.copy()\n",
+    "    \n",
+    "    J_history = [] # Use a python list to save cost in every iteration\n",
+    "    \n",
+    "    for i in range(num_iters):\n",
+    "        # ==================== YOUR CODE HERE =================================\n",
+    "        theta = theta - (alpha/m)*(np.dot(X.transpose(),(np.dot(X,theta)-y)))\n",
+    "\n",
+    "        # =====================================================================\n",
+    "        \n",
+    "        # save the cost J in every iteration\n",
+    "        J_history.append(computeCost(X, y, theta))\n",
+    "    \n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After you are finished call the implemented `gradientDescent` function and print the computed $\\theta$. We initialize the $\\theta$ parameters to 0 and the learning rate $\\alpha$ to 0.01. Execute the following cell to check your code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "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",
+    "\n",
+    "# some gradient descent settings\n",
+    "iterations = 1500\n",
+    "alpha = 0.01\n",
+    "\n",
+    "theta, J_history = gradientDescent(X ,y, theta, alpha, iterations)\n",
+    "print('Theta found by gradient descent: {:.4f}, {:.4f}'.format(*theta))\n",
+    "print('Expected theta values (approximately): [-3.6303, 1.1664]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will use your final parameters to plot the linear fit. The results should look like the following figure.\n",
+    "\n",
+    "![](Figures/regression_result.png)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot the linear fit\n",
+    "plotData(X[:, 1], y)\n",
+    "pyplot.plot(X[:, 1], np.dot(X, theta), '-')\n",
+    "pyplot.legend(['Training data', 'Linear regression']);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pyplot.plot?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your final values for $\\theta$ will also be used to make predictions on profits in areas of 35,000 and 70,000 people.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-success\">\n",
+    "Note the way that the following lines use matrix multiplication, rather than explicit summation or looping, to calculate the predictions. This is an example of code vectorization in `numpy`.\n",
+    "</div>\n",
+    "\n",
+    "<div class=\"alert alert-block alert-success\">\n",
+    "Note that the first argument to the `numpy` function `dot` is a python list. `numpy` can internally converts **valid** python lists to numpy arrays when explicitly provided as arguments to `numpy` functions.\n",
+    "</div>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "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",
+    "print('For population = 35,000, we predict a profit of {:.2f}\\n'.format(predict1*10000))\n",
+    "\n",
+    "predict2 = np.dot([1, 7], theta)\n",
+    "print('For population = 70,000, we predict a profit of {:.2f}\\n'.format(predict2*10000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions by executing the next cell.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | \n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[3] = gradientDescent\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4 Visualizing $J(\\theta)$\n",
+    "\n",
+    "To understand the cost function $J(\\theta)$ better, you will now plot the cost over a 2-dimensional grid of $\\theta_0$ and $\\theta_1$ values. You will not need to code anything new for this part, but you should understand how the code you have written already is creating these images.\n",
+    "\n",
+    "In the next cell, the code is set up to calculate $J(\\theta)$ over a grid of values using the `computeCost` function that you wrote. After executing the following cell, you will have a 2-D array of $J(\\theta)$ values. Then, those values are used to produce surface and contour plots of $J(\\theta)$ using the matplotlib `plot_surface` and `contourf` functions. The plots should look something like the following:\n",
+    "\n",
+    "![](Figures/cost_function.png)\n",
+    "\n",
+    "The purpose of these graphs is to show you how $J(\\theta)$ varies with changes in $\\theta_0$ and $\\theta_1$. The cost function $J(\\theta)$ is bowl-shaped and has a global minimum. (This is easier to see in the contour plot than in the 3D surface plot). This minimum is the optimal point for $\\theta_0$ and $\\theta_1$, and each step of gradient descent moves closer to this point."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x360 with 2 Axes>"
+      ]
+     },
+     "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",
+    "theta1_vals = np.linspace(-1, 4, 100)\n",
+    "\n",
+    "# initialize J_vals to a matrix of 0's\n",
+    "J_vals = np.zeros((theta0_vals.shape[0], theta1_vals.shape[0]))\n",
+    "\n",
+    "# Fill out J_vals\n",
+    "for i, theta0 in enumerate(theta0_vals):\n",
+    "    for j, theta1 in enumerate(theta1_vals):\n",
+    "        J_vals[i, j] = computeCost(X, y, [theta0, theta1])\n",
+    "        \n",
+    "# Because of the way meshgrids work in the surf command, we need to\n",
+    "# transpose J_vals before calling surf, or else the axes will be flipped\n",
+    "J_vals = J_vals.T\n",
+    "\n",
+    "# surface plot\n",
+    "fig = pyplot.figure(figsize=(12, 5))\n",
+    "ax = fig.add_subplot(121, projection='3d')\n",
+    "ax.plot_surface(theta0_vals, theta1_vals, J_vals, cmap='viridis')\n",
+    "pyplot.xlabel('theta0')\n",
+    "pyplot.ylabel('theta1')\n",
+    "pyplot.title('Surface')\n",
+    "\n",
+    "# contour plot\n",
+    "# Plot J_vals as 15 contours spaced logarithmically between 0.01 and 100\n",
+    "ax = pyplot.subplot(122)\n",
+    "pyplot.contour(theta0_vals, theta1_vals, J_vals, linewidths=2, cmap='viridis', levels=np.logspace(-2, 3, 20))\n",
+    "pyplot.xlabel('theta0')\n",
+    "pyplot.ylabel('theta1')\n",
+    "pyplot.plot(theta[0], theta[1], 'ro', ms=10, lw=2)\n",
+    "pyplot.title('Contour, showing minimum')\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Optional Exercises\n",
+    "\n",
+    "If you have successfully completed the material above, congratulations! You now understand linear regression and should able to start using it on your own datasets.\n",
+    "\n",
+    "For the rest of this programming exercise, we have included the following optional exercises. These exercises will help you gain a deeper understanding of the material, and if you are able to do so, we encourage you to complete them as well. You can still submit your solutions to these exercises to check if your answers are correct.\n",
+    "\n",
+    "## 3 Linear regression with multiple variables\n",
+    "\n",
+    "In this part, you will implement linear regression with multiple variables to predict the prices of houses. Suppose you are selling your house and you want to know what a good market price would be. One way to do this is to first collect information on recent houses sold and make a model of housing prices.\n",
+    "\n",
+    "The file `Data/ex1data2.txt` contains a training set of housing prices in Portland, Oregon. The first column is the size of the house (in square feet), the second column is the number of bedrooms, and the third column is the price\n",
+    "of the house. \n",
+    "\n",
+    "<a id=\"section4\"></a>\n",
+    "### 3.1 Feature Normalization\n",
+    "\n",
+    "We start by loading and displaying some values from this dataset. By looking at the values, note that house sizes are about 1000 times the number of bedrooms. When features differ by orders of magnitude, first performing feature scaling can make gradient descent converge much more quickly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "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",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]\n",
+    "m = y.size\n",
+    "\n",
+    "# print out some data points\n",
+    "print('{:>8s}{:>8s}{:>10s}'.format('X[:,0]', 'X[:, 1]', 'y'))\n",
+    "print('-'*26)\n",
+    "for i in range(10):\n",
+    "    print('{:8.0f}{:8.0f}{:10.0f}'.format(X[i, 0], X[i, 1], y[i]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Your task here is to complete the code in `featureNormalize` function:\n",
+    "- Subtract the mean value of each feature from the dataset.\n",
+    "- After subtracting the mean, additionally scale (divide) the feature values by their respective “standard deviations.”\n",
+    "\n",
+    "The standard deviation is a way of measuring how much variation there is in the range of values of a particular feature (most data points will lie within ±2 standard deviations of the mean); this is an alternative to taking the range of values (max-min). In `numpy`, you can use the `std` function to compute the standard deviation. \n",
+    "\n",
+    "For example, the quantity `X[:, 0]` contains all the values of $x_1$ (house sizes) in the training set, so `np.std(X[:, 0])` computes the standard deviation of the house sizes.\n",
+    "At the time that the function `featureNormalize` is called, the extra column of 1’s corresponding to $x_0 = 1$ has not yet been added to $X$. \n",
+    "\n",
+    "You will do this for all the features and your code should work with datasets of all sizes (any number of features / examples). Note that each column of the matrix $X$ corresponds to one feature.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** When normalizing the features, it is important\n",
+    "to store the values used for normalization - the mean value and the standard deviation used for the computations. After learning the parameters\n",
+    "from the model, we often want to predict the prices of houses we have not\n",
+    "seen before. Given a new x value (living room area and number of bedrooms), we must first normalize x using the mean and standard deviation that we had previously computed from the training set.\n",
+    "</div>\n",
+    "<a id=\"featureNormalize\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def  featureNormalize(X):\n",
+    "    \"\"\"\n",
+    "    Normalizes the features in X. returns a normalized version of X where\n",
+    "    the mean value of each feature is 0 and the standard deviation\n",
+    "    is 1. This is often a good preprocessing step to do when working with\n",
+    "    learning algorithms.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    X_norm : array_like\n",
+    "        The normalized dataset of shape (m x n).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    First, for each feature dimension, compute the mean of the feature\n",
+    "    and subtract it from the dataset, storing the mean value in mu. \n",
+    "    Next, compute the  standard deviation of each feature and divide\n",
+    "    each feature by it's standard deviation, storing the standard deviation \n",
+    "    in sigma. \n",
+    "    \n",
+    "    Note that X is a matrix where each column is a feature and each row is\n",
+    "    an example. You needto perform the normalization separately for each feature. \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You might find the 'np.mean' and 'np.std' functions useful.\n",
+    "    \"\"\"\n",
+    "    # You need to set these values correctly\n",
+    "    X_norm = X.copy()\n",
+    "    mu = np.zeros(X.shape[1])\n",
+    "    sigma = np.zeros(X.shape[1])\n",
+    "    n = X.shape[1]\n",
+    "\n",
+    "    # =========================== YOUR CODE HERE =====================\n",
+    "    for i in range(n):\n",
+    "        mu[i] = np.mean(X[:,i])\n",
+    "    for i in range(n):\n",
+    "        sigma[i] = np.std(X[:,i])\n",
+    "    for i in range(n):\n",
+    "        X_norm[:,i] = (X[:,i]-mu[i])/sigma[i]\n",
+    "    \n",
+    "    # ================================================================\n",
+    "    return X_norm, mu, sigma"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Execute the next cell to run the implemented `featureNormalize` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Computed mean: [2000.68085106    3.17021277]\n",
+      "Computed standard deviation: [7.86202619e+02 7.52842809e-01]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# call featureNormalize on the loaded data\n",
+    "X_norm, mu, sigma = featureNormalize(X)\n",
+    "\n",
+    "print('Computed mean:', mu)\n",
+    "print('Computed standard deviation:', sigma)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should not submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | \n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[4] = featureNormalize\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After the `featureNormalize` function is tested, we now add the intercept term to `X_norm`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section5\"></a>\n",
+    "### 3.2 Gradient Descent\n",
+    "\n",
+    "Previously, you implemented gradient descent on a univariate regression problem. The only difference now is that there is one more feature in the matrix $X$. The hypothesis function and the batch gradient descent update\n",
+    "rule remain unchanged. \n",
+    "\n",
+    "You should complete the code for the functions `computeCostMulti` and `gradientDescentMulti` to implement the cost function and gradient descent for linear regression with multiple variables. If your code in the previous part (single variable) already supports multiple variables, you can use it here too.\n",
+    "Make sure your code supports any number of features and is well-vectorized.\n",
+    "You can use the `shape` property of `numpy` arrays to find out how many features are present in the dataset.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** In the multivariate case, the cost function can\n",
+    "also be written in the following vectorized form:\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{2m}(X\\theta - \\vec{y})^T(X\\theta - \\vec{y}) $$\n",
+    "\n",
+    "where \n",
+    "\n",
+    "$$ X = \\begin{pmatrix}\n",
+    "          - (x^{(1)})^T - \\\\\n",
+    "          - (x^{(2)})^T - \\\\\n",
+    "          \\vdots \\\\\n",
+    "          - (x^{(m)})^T - \\\\ \\\\\n",
+    "        \\end{pmatrix} \\qquad \\mathbf{y} = \\begin{bmatrix} y^{(1)} \\\\ y^{(2)} \\\\ \\vdots \\\\ y^{(m)} \\\\\\end{bmatrix}$$\n",
+    "\n",
+    "the vectorized version is efficient when you are working with numerical computing tools like `numpy`. If you are an expert with matrix operations, you can prove to yourself that the two forms are equivalent.\n",
+    "</div>\n",
+    "\n",
+    "<a id=\"computeCostMulti\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def computeCostMulti(X, y, theta):\n",
+    "    \"\"\"\n",
+    "    Compute cost for linear regression with multiple variables.\n",
+    "    Computes the cost of using theta as the parameter for linear regression to fit the data points in X and y.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        A vector of shape (m, ) for the values at a given data point.\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The linear regression parameters. A vector of shape (n+1, )\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The value of the cost function. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to the cost.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0] # number of training examples\n",
+    "    \n",
+    "    # You need to return the following variable correctly\n",
+    "    J = 0\n",
+    "    \n",
+    "    # ======================= YOUR CODE HERE ===========================\n",
+    "    J = (np.sum(np.square(np.dot(X,theta)-y)))/(2*m)\n",
+    "    \n",
+    "    # ==================================================================\n",
+    "    return J\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | Nice work!\n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | \n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[5] = computeCostMulti\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"gradientDescentMulti\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gradientDescentMulti(X, y, theta, alpha, num_iters):\n",
+    "    \"\"\"\n",
+    "    Performs gradient descent to learn theta.\n",
+    "    Updates theta by taking num_iters gradient steps with learning rate alpha.\n",
+    "        \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        A vector of shape (m, ) for the values at a given data point.\n",
+    "    \n",
+    "    theta : array_like\n",
+    "        The linear regression parameters. A vector of shape (n+1, )\n",
+    "    \n",
+    "    alpha : float\n",
+    "        The learning rate for gradient descent. \n",
+    "    \n",
+    "    num_iters : int\n",
+    "        The number of iterations to run gradient descent. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        The learned linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    J_history : list\n",
+    "        A python list for the values of the cost function after each iteration.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Peform a single gradient step on the parameter vector theta.\n",
+    "\n",
+    "    While debugging, it can be useful to print out the values of \n",
+    "    the cost function (computeCost) and gradient here.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.shape[0] # number of training examples\n",
+    "    \n",
+    "    # make a copy of theta, which will be updated by gradient descent\n",
+    "    theta = theta.copy()\n",
+    "    \n",
+    "    J_history = []\n",
+    "    \n",
+    "    for i in range(num_iters):\n",
+    "        # ======================= YOUR CODE HERE ==========================\n",
+    "        theta = theta - (alpha/m)*(np.dot(X.transpose(),(np.dot(X,theta)-y)))\n",
+    "        \n",
+    "        # =================================================================\n",
+    "        \n",
+    "        # save the cost J in every iteration\n",
+    "        J_history.append(computeCostMulti(X, y, theta))\n",
+    "    \n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | Nice work!\n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | Nice work!\n",
+      "                           Normal Equations |   0 /   0 | \n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[6] = gradientDescentMulti\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.2.1 Optional (ungraded) exercise: Selecting learning rates\n",
+    "\n",
+    "In this part of the exercise, you will get to try out different learning rates for the dataset and find a learning rate that converges quickly. You can change the learning rate by modifying the following code and changing the part of the code that sets the learning rate.\n",
+    "\n",
+    "Use your implementation of `gradientDescentMulti` function and run gradient descent for about 50 iterations at the chosen learning rate. The function should also return the history of $J(\\theta)$ values in a vector $J$.\n",
+    "\n",
+    "After the last iteration, plot the J values against the number of the iterations.\n",
+    "\n",
+    "If you picked a learning rate within a good range, your plot look similar as the following Figure. \n",
+    "\n",
+    "![](Figures/learning_rate.png)\n",
+    "\n",
+    "If your graph looks very different, especially if your value of $J(\\theta)$ increases or even blows up, adjust your learning rate and try again. We recommend trying values of the learning rate $\\alpha$ on a log-scale, at multiplicative steps of about 3 times the previous value (i.e., 0.3, 0.1, 0.03, 0.01 and so on). You may also want to adjust the number of iterations you are running if that will help you see the overall trend in the curve.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**Implementation Note:** If your learning rate is too large, $J(\\theta)$ can diverge and ‘blow up’, resulting in values which are too large for computer calculations. In these situations, `numpy` will tend to return\n",
+    "NaNs. NaN stands for ‘not a number’ and is often caused by undefined operations that involve −∞ and +∞.\n",
+    "</div>\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "**MATPLOTLIB tip:** To compare how different learning learning rates affect convergence, it is helpful to plot $J$ for several learning rates on the same figure. This can be done by making `alpha` a python list, and looping across the values within this list, and calling the plot function in every iteration of the loop. It is also useful to have a legend to distinguish the different lines within the plot. Search online for `pyplot.legend` for help on showing legends in `matplotlib`.\n",
+    "</div>\n",
+    "\n",
+    "Notice the changes in the convergence curves as the learning rate changes. With a small learning rate, you should find that gradient descent takes a very long time to converge to the optimal value. Conversely, with a large learning rate, gradient descent might not converge or might even diverge!\n",
+    "Using the best learning rate that you found, run the script\n",
+    "to run gradient descent until convergence to find the final values of $\\theta$. Next,\n",
+    "use this value of $\\theta$ to predict the price of a house with 1650 square feet and\n",
+    "3 bedrooms. You will use value later to check your implementation of the normal equations. Don’t forget to normalize your features when you make this prediction!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "theta computed from gradient descent: [340412.57680449 109372.3081412   -6502.86652974]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $293098\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "Instructions\n",
+    "------------\n",
+    "We have provided you with the following starter code that runs\n",
+    "gradient descent with a particular learning rate (alpha). \n",
+    "\n",
+    "Your task is to first make sure that your functions - `computeCost`\n",
+    "and `gradientDescent` already work with  this starter code and\n",
+    "support multiple variables.\n",
+    "\n",
+    "After that, try running gradient descent with different values of\n",
+    "alpha and see which one gives you the best result.\n",
+    "\n",
+    "Finally, you should complete the code at the end to predict the price\n",
+    "of a 1650 sq-ft, 3 br house.\n",
+    "\n",
+    "Hint\n",
+    "----\n",
+    "At prediction, make sure you do the same feature normalization.\n",
+    "\"\"\"\n",
+    "# Choose some alpha value - change this\n",
+    "alpha = 0.03\n",
+    "num_iters = 500\n",
+    "\n",
+    "# init theta and run gradient descent\n",
+    "theta = np.zeros(3)\n",
+    "theta, J_history = gradientDescentMulti(X, y, theta, alpha, num_iters)\n",
+    "\n",
+    "# Plot the convergence graph\n",
+    "pyplot.plot(np.arange(len(J_history)), J_history, lw=2)\n",
+    "pyplot.xlabel('Number of iterations')\n",
+    "pyplot.ylabel('Cost J')\n",
+    "\n",
+    "# Display the gradient descent's result\n",
+    "print('theta computed from gradient descent: {:s}'.format(str(theta)))\n",
+    "\n",
+    "# Estimate the price of a 1650 sq-ft, 3 br house\n",
+    "# ======================= YOUR CODE HERE ===========================\n",
+    "\n",
+    "# Recall that the first column of X is all-ones. \n",
+    "# Thus, it does not need to be normalized.\n",
+    "\n",
+    "price = 0   # You should change this\n",
+    "price = theta[0]*1 + theta[1]*((1650-mu[0])/sigma[0]) + theta[2]*((3-mu[1])/sigma[1])\n",
+    "# ===================================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): ${:.0f}'.format(price))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You do not need to submit any solutions for this optional (ungraded) part.*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section7\"></a>\n",
+    "### 3.3 Normal Equations\n",
+    "\n",
+    "In the lecture videos, you learned that the closed-form solution to linear regression is\n",
+    "\n",
+    "$$ \\theta = \\left( X^T X\\right)^{-1} X^T\\vec{y}$$\n",
+    "\n",
+    "Using this formula does not require any feature scaling, and you will get an exact solution in one calculation: there is no “loop until convergence” like in gradient descent. \n",
+    "\n",
+    "First, we will reload the data to ensure that the variables have not been modified. Remember that while you do not need to scale your features, we still need to add a column of 1’s to the $X$ matrix to have an intercept term ($\\theta_0$). The code in the next cell will add the column of 1’s to X for you."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex1data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]\n",
+    "m = y.size\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Complete the code for the function `normalEqn` below to use the formula above to calculate $\\theta$. \n",
+    "\n",
+    "<a id=\"normalEqn\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def normalEqn(X, y):\n",
+    "    \"\"\"\n",
+    "    Computes the closed-form solution to linear regression using the normal equations.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The dataset of shape (m x n+1).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The value at each data point. A vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    theta : array_like\n",
+    "        Estimated linear regression parameters. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the code to compute the closed form solution to linear\n",
+    "    regression and put the result in theta.\n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    Look up the function `np.linalg.pinv` for computing matrix inverse.\n",
+    "    \"\"\"\n",
+    "    theta = np.zeros(X.shape[1])\n",
+    "    \n",
+    "    # ===================== YOUR CODE HERE ============================\n",
+    "    theta = np.dot(np.dot(np.linalg.inv(np.dot(X.transpose(),X)),X.transpose()),y)\n",
+    "    \n",
+    "    # =================================================================\n",
+    "    return theta"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise linear-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Warm up exercise |  10 /  10 | Nice work!\n",
+      "          Computing Cost (for one variable) |  40 /  40 | Nice work!\n",
+      "        Gradient Descent (for one variable) |  50 /  50 | Nice work!\n",
+      "                      Feature Normalization |   0 /   0 | Nice work!\n",
+      "    Computing Cost (for multiple variables) |   0 /   0 | Nice work!\n",
+      "  Gradient Descent (for multiple variables) |   0 /   0 | Nice work!\n",
+      "                           Normal Equations |   0 /   0 | Nice work!\n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[7] = normalEqn\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Optional (ungraded) exercise: Now, once you have found $\\theta$ using this\n",
+    "method, use it to make a price prediction for a 1650-square-foot house with\n",
+    "3 bedrooms. You should find that gives the same predicted price as the value\n",
+    "you obtained using the model fit with gradient descent (in Section 3.2.1)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Theta computed from the normal equations: [89597.9095428    139.21067402 -8738.01911233]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using normal equations): $293081\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculate the parameters from the normal equation\n",
+    "theta = normalEqn(X, y);\n",
+    "\n",
+    "# Display normal equation's result\n",
+    "print('Theta computed from the normal equations: {:s}'.format(str(theta)));\n",
+    "\n",
+    "# Estimate the price of a 1650 sq-ft, 3 br house\n",
+    "# ====================== YOUR CODE HERE ======================\n",
+    "\n",
+    "price = 0 # You should change this\n",
+    "price = theta[0]*1 + theta[1]*1650 + theta[2]*3\n",
+    "# ============================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations): ${:.0f}'.format(price))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Exercise1/token.pkl b/Exercise1/token.pkl
new file mode 100644
index 0000000..927446d
Binary files /dev/null and b/Exercise1/token.pkl differ
diff --git a/Exercise1/utils.py b/Exercise1/utils.py
new file mode 100755
index 0000000..d0c909d
--- /dev/null
+++ b/Exercise1/utils.py
@@ -0,0 +1,48 @@
+import numpy as np
+import sys
+sys.path.append('..')
+
+from submission import SubmissionBase
+
+
+class Grader(SubmissionBase):
+    X1 = np.column_stack((np.ones(20), np.exp(1) + np.exp(2) * np.linspace(0.1, 2, 20)))
+    Y1 = X1[:, 1] + np.sin(X1[:, 0]) + np.cos(X1[:, 1])
+    X2 = np.column_stack((X1, X1[:, 1]**0.5, X1[:, 1]**0.25))
+    Y2 = np.power(Y1, 0.5) + Y1
+
+    def __init__(self):
+        part_names = ['Warm up exercise',
+                      'Computing Cost (for one variable)',
+                      'Gradient Descent (for one variable)',
+                      'Feature Normalization',
+                      'Computing Cost (for multiple variables)',
+                      'Gradient Descent (for multiple variables)',
+                      'Normal Equations']
+        super().__init__('linear-regression', part_names)
+
+    def __iter__(self):
+        for part_id in range(1, 8):
+            try:
+                func = self.functions[part_id]
+
+                # Each part has different expected arguments/different function
+                if part_id == 1:
+                    res = func()
+                elif part_id == 2:
+                    res = func(self.X1, self.Y1, np.array([0.5, -0.5]))
+                elif part_id == 3:
+                    res = func(self.X1, self.Y1, np.array([0.5, -0.5]), 0.01, 10)
+                elif part_id == 4:
+                    res = func(self.X2[:, 1:4])
+                elif part_id == 5:
+                    res = func(self.X2, self.Y2, np.array([0.1, 0.2, 0.3, 0.4]))
+                elif part_id == 6:
+                    res = func(self.X2, self.Y2, np.array([-0.1, -0.2, -0.3, -0.4]), 0.01, 10)
+                elif part_id == 7:
+                    res = func(self.X2, self.Y2)
+                else:
+                    raise KeyError
+                yield part_id, res
+            except KeyError:
+                yield part_id, 0
diff --git a/Exercise2/.ipynb_checkpoints/exercise2-checkpoint.ipynb b/Exercise2/.ipynb_checkpoints/exercise2-checkpoint.ipynb
new file mode 100755
index 0000000..f537d43
--- /dev/null
+++ b/Exercise2/.ipynb_checkpoints/exercise2-checkpoint.ipynb
@@ -0,0 +1,1211 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Programming Exercise 2: Logistic Regression\n",
+    "\n",
+    "## Introduction\n",
+    "\n",
+    "In this exercise, you will implement logistic regression and apply it to two different datasets. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\n",
+    "\n",
+    "All the information you need for solving this assignment is in this notebook, and all the code you will be implementing will take place within this notebook. The assignment can be promptly submitted to the coursera grader directly from this notebook (code and instructions are included below).\n",
+    "\n",
+    "Before we begin with the exercises, we need to import all libraries required for this programming exercise. Throughout the course, we will be using [`numpy`](http://www.numpy.org/) for all arrays and matrix operations, and [`matplotlib`](https://matplotlib.org/) for plotting. In this assignment, we will also use [`scipy`](https://docs.scipy.org/doc/scipy/reference/), which contains scientific and numerical computation functions and tools. \n",
+    "\n",
+    "You can find instructions on how to install required libraries in the README file in the [github repository](https://github.com/dibgerge/ml-coursera-python-assignments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils\n",
+    "\n",
+    "# define the submission/grader object for this exercise\n",
+    "grader = utils.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Submission and Grading\n",
+    "\n",
+    "\n",
+    "After completing each part of the assignment, be sure to submit your solutions to the grader. The following is a breakdown of how each part of this exercise is scored.\n",
+    "\n",
+    "\n",
+    "| Section | Part                                 | Submission function   | Points \n",
+    "| :-      |:-                                    | :-                    | :-:\n",
+    "| 1       | [Sigmoid Function](#section1)                   | [`sigmoid`](#sigmoid) | 5      \n",
+    "| 2       | [Compute cost for logistic regression](#section2) | [`costFunction`](#costFunction) | 30     \n",
+    "| 3       | [Gradient for logistic regression](#section2)     | [`costFunction`](#costFunction) | 30     \n",
+    "| 4       | [Predict Function](#section4)                     | [`predict`](#predict) | 5      \n",
+    "| 5       | [Compute cost for regularized LR](#section5)      | [`costFunctionReg`](#costFunctionReg) | 15     \n",
+    "| 6       | [Gradient for regularized LR](#section5)          | [`costFunctionReg`](#costFunctionReg) | 15     \n",
+    "|         | Total Points                         | | 100    \n",
+    "\n",
+    "\n",
+    "\n",
+    "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "At the end of each section in this notebook, we have a cell which contains code for submitting the solutions thus far to the grader. Execute the cell to see your score up to the current section. For all your work to be submitted properly, you must execute those cells at least once. They must also be re-executed everytime the submitted function is updated.\n",
+    "</div>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1 Logistic Regression\n",
+    "\n",
+    "In this part of the exercise, you will build a logistic regression model to predict whether a student gets admitted into a university. Suppose that you are the administrator of a university department and\n",
+    "you want to determine each applicant’s chance of admission based on their results on two exams. You have historical data from previous applicants that you can use as a training set for logistic regression. For each training example, you have the applicant’s scores on two exams and the admissions\n",
+    "decision. Your task is to build a classification model that estimates an applicant’s probability of admission based the scores from those two exams. \n",
+    "\n",
+    "The following cell will load the data and corresponding labels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "# The first two columns contains the exam scores and the third column\n",
+    "# contains the label.\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data1.txt'), delimiter=',')\n",
+    "X, y = data[:, 0:2], data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Visualizing the data\n",
+    "\n",
+    "Before starting to implement any learning algorithm, it is always good to visualize the data if possible. We  display the data on a 2-dimensional plot by calling the function `plotData`. You will now complete the code in `plotData` so that it displays a figure where the axes are the two exam scores, and the positive and negative examples are shown with different markers.\n",
+    "\n",
+    "To help you get more familiar with plotting, we have left `plotData` empty so you can try to implement it yourself. However, this is an optional (ungraded) exercise. We also provide our implementation below so you can\n",
+    "copy it or refer to it. If you choose to copy our example, make sure you learn\n",
+    "what each of its commands is doing by consulting the `matplotlib` and `numpy` documentation.\n",
+    "\n",
+    "```python\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",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure. Plots the data \n",
+    "    points with * for the positive examples and o for the negative examples.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        An Mx2 matrix representing the dataset. \n",
+    "    \n",
+    "    y : array_like\n",
+    "        Label values for the dataset. A vector of size (M, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the positive and negative examples on a 2D plot, using the\n",
+    "    option 'k*' for the positive examples and 'ko' for the negative examples.    \n",
+    "    \"\"\"\n",
+    "    # Create New Figure\n",
+    "    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",
+    "    # ============================================================"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we call the implemented function to display the loaded data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plotData(X, y)\n",
+    "# add axes labels\n",
+    "pyplot.xlabel('Exam 1 score')\n",
+    "pyplot.ylabel('Exam 2 score')\n",
+    "pyplot.legend(['Admitted', 'Not admitted'])\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section1\"></a>\n",
+    "### 1.2 Implementation\n",
+    "\n",
+    "#### 1.2.1 Warmup exercise: sigmoid function\n",
+    "\n",
+    "Before you start with the actual cost function, recall that the logistic regression hypothesis is defined as:\n",
+    "\n",
+    "$$ h_\\theta(x) = g(\\theta^T x)$$\n",
+    "\n",
+    "where function $g$ is the sigmoid function. The sigmoid function is defined as: \n",
+    "\n",
+    "$$g(z) = \\frac{1}{1+e^{-z}}$$.\n",
+    "\n",
+    "Your first step is to implement this function `sigmoid` so it can be\n",
+    "called by the rest of your program. When you are finished, try testing a few\n",
+    "values by calling `sigmoid(x)` in a new cell. For large positive values of `x`, the sigmoid should be close to 1, while for large negative values, the sigmoid should be close to 0. Evaluating `sigmoid(0)` should give you exactly 0.5. Your code should also work with vectors and matrices. **For a matrix, your function should perform the sigmoid function on every element.**\n",
+    "<a id=\"sigmoid\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Compute sigmoid function given the input z.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    z : array_like\n",
+    "        The input to the sigmoid function. This can be a 1-D vector \n",
+    "        or a 2-D matrix. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    g : array_like\n",
+    "        The computed sigmoid function. g has the same shape as z, since\n",
+    "        the sigmoid is computed element-wise on z.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the sigmoid of each value of z (z can be a matrix, vector or scalar).\n",
+    "    \"\"\"\n",
+    "    # convert input to a numpy array\n",
+    "    z = np.array(z)\n",
+    "    \n",
+    "    # You need to return the following variables correctly \n",
+    "    g = np.zeros(z.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    g = 1/(1+(np.exp(-z)))\n",
+    "\n",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following cell evaluates the sigmoid function at `z=0`. You should get a value of 0.5. You can also try different values for `z` to experiment with the sigmoid function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "g( 0 ) =  0.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Test the implementation of sigmoid function here\n",
+    "z = 0\n",
+    "g = sigmoid(z)\n",
+    "\n",
+    "print('g(', z, ') = ', g)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the submission object, and then sending your function to Coursera for grading. \n",
+    "\n",
+    "The submission script will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "Execute the following cell to grade your solution to the first part of this exercise.\n",
+    "\n",
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |   0 /  30 | \n",
+      "               Logistic Regression Gradient |   0 /  30 | \n",
+      "                                    Predict |   0 /   5 | \n",
+      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
+      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
+      "                                  --------------------------------\n",
+      "                                            |   5 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# appends the implemented function in part 1 to the grader object\n",
+    "grader[1] = sigmoid\n",
+    "\n",
+    "# send the added functions to coursera grader for getting a grade on this part\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section2\"></a>\n",
+    "#### 1.2.2 Cost function and gradient\n",
+    "\n",
+    "Now you will implement the cost function and gradient for logistic regression. Before proceeding we add the intercept term to X. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup the data matrix appropriately, and add ones for the intercept term\n",
+    "m, n = X.shape\n",
+    "\n",
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, complete the code for the function `costFunction` to return the cost and gradient. Recall that the cost function in logistic regression is\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^{m} \\left[ -y^{(i)} \\log\\left(h_\\theta\\left( x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)}\\right) \\log \\left( 1 - h_\\theta\\left( x^{(i)} \\right) \\right) \\right]$$\n",
+    "\n",
+    "and the gradient of the cost is a vector of the same length as $\\theta$ where the $j^{th}$\n",
+    "element (for $j = 0, 1, \\cdots , n$) is defined as follows:\n",
+    "\n",
+    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} $$\n",
+    "\n",
+    "Note that while this gradient looks identical to the linear regression gradient, the formula is actually different because linear and logistic regression have different definitions of $h_\\theta(x)$.\n",
+    "<a id=\"costFunction\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunction(theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression. \n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        The parameters for logistic regression. This a vector\n",
+    "        of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1) where m is the total number\n",
+    "        of data points and n is the number of features. We assume the \n",
+    "        intercept has already been added to the input.\n",
+    "    \n",
+    "    y : arra_like\n",
+    "        Labels for the input. This is a vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n+1, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to \n",
+    "    the cost. Compute the partial derivatives and set grad to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    J = (-1/m) * ((np.sum(y*(np.log(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))) + \n",
+    "                     (np.sum((1-y)*(np.log(1-(1/(np.exp(-np.dot(theta,X.transpose())) + 1)))))))\n",
+    "    \n",
+    "    for i in range(n+1):\n",
+    "        grad[i] = (1/m) * np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,i])\n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you are done call your `costFunction` using two test cases for  $\\theta$ by executing the next cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "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",
+    "\n",
+    "cost, grad = costFunction(initial_theta, X, y)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros):')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[-0.1000, -12.0092, -11.2628]\\n')\n",
+    "\n",
+    "# Compute and display cost and gradient with non-zero theta\n",
+    "test_theta = np.array([-24, 0.2, 0.2])\n",
+    "cost, grad = costFunction(test_theta, X, y)\n",
+    "\n",
+    "print('Cost at test theta: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.218\\n')\n",
+    "\n",
+    "print('Gradient at test theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[0.043, 2.566, 2.647]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
+      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
+      "                                    Predict |   0 /   5 | \n",
+      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
+      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  65 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[2] = costFunction\n",
+    "grader[3] = costFunction\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.2.3 Learning parameters using `scipy.optimize`\n",
+    "\n",
+    "In the previous assignment, you found the optimal parameters of a linear regression model by implementing gradient descent. You wrote a cost function and calculated its gradient, then took a gradient descent step accordingly. This time, instead of taking gradient descent steps, you will use the [`scipy.optimize` module](https://docs.scipy.org/doc/scipy/reference/optimize.html). SciPy is a numerical computing library for `python`. It provides an optimization module for root finding and minimization. As of `scipy 1.0`, the function `scipy.optimize.minimize` is the method to use for optimization problems(both constrained and unconstrained).\n",
+    "\n",
+    "For logistic regression, you want to optimize the cost function $J(\\theta)$ with parameters $\\theta$.\n",
+    "Concretely, you are going to use `optimize.minimize` to find the best parameters $\\theta$ for the logistic regression cost function, given a fixed dataset (of X and y values). You will pass to `optimize.minimize` the following inputs:\n",
+    "- `costFunction`: A cost function that, when given the training set and a particular $\\theta$, computes the logistic regression cost and gradient with respect to $\\theta$ for the dataset (X, y). It is important to note that we only pass the name of the function without the parenthesis. This indicates that we are only providing a reference to this function, and not evaluating the result from this function.\n",
+    "- `initial_theta`: The initial values of the parameters we are trying to optimize.\n",
+    "- `(X, y)`: These are additional arguments to the cost function.\n",
+    "- `jac`: Indication if the cost function returns the Jacobian (gradient) along with cost value. (True)\n",
+    "- `method`: Optimization method/algorithm to use\n",
+    "- `options`: Additional options which might be specific to the specific optimization method. In the following, we only tell the algorithm the maximum number of iterations before it terminates.\n",
+    "\n",
+    "If you have completed the `costFunction` correctly, `optimize.minimize` will converge on the right optimization parameters and return the final values of the cost and $\\theta$ in a class object. Notice that by using `optimize.minimize`, you did not have to write any loops yourself, or set a learning rate like you did for gradient descent. This is all done by `optimize.minimize`: you only needed to provide a function calculating the cost and the gradient.\n",
+    "\n",
+    "In the following, we already have code written to call `optimize.minimize` with the correct arguments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "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",
+    "\n",
+    "# see documention for scipy's optimize.minimize  for description about\n",
+    "# the different parameters\n",
+    "# The function returns an object `OptimizeResult`\n",
+    "# We use truncated Newton algorithm for optimization which is \n",
+    "# equivalent to MATLAB's fminunc\n",
+    "# See https://stackoverflow.com/questions/18801002/fminunc-alternate-in-numpy\n",
+    "res = optimize.minimize(costFunction,\n",
+    "                        initial_theta,\n",
+    "                        (X, y),\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# the fun property of `OptimizeResult` object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property\n",
+    "theta = res.x\n",
+    "\n",
+    "# Print theta to screen\n",
+    "print('Cost at theta found by optimize.minimize: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.203\\n');\n",
+    "\n",
+    "print('theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*theta))\n",
+    "print('Expected theta (approx):\\n\\t[-25.161, 0.206, 0.201]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once `optimize.minimize` completes, we want to use the final value for $\\theta$ to visualize the decision boundary on the training data as shown in the figure below. \n",
+    "\n",
+    "![](Figures/decision_boundary1.png)\n",
+    "\n",
+    "To do so, we have written a function `plotDecisionBoundary` for plotting the decision boundary on top of training data. You do not need to write any code for plotting the decision boundary, but we also encourage you to look at the code in `plotDecisionBoundary` to see how to plot such a boundary using the $\\theta$ values. You can find this function in the `utils.py` file which comes with this assignment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot Boundary\n",
+    "utils.plotDecisionBoundary(plotData, theta, X, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section4\"></a>\n",
+    "#### 1.2.4 Evaluating logistic regression\n",
+    "\n",
+    "After learning the parameters, you can use the model to predict whether a particular student will be admitted. For a student with an Exam 1 score of 45 and an Exam 2 score of 85, you should expect to see an admission\n",
+    "probability of 0.776. Another way to evaluate the quality of the parameters we have found is to see how well the learned model predicts on our training set. In this part, your task is to complete the code in function `predict`. The predict function will produce “1” or “0” predictions given a dataset and a learned parameter vector $\\theta$. \n",
+    "<a id=\"predict\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(theta, X):\n",
+    "    \"\"\"\n",
+    "    Predict whether the label is 0 or 1 using learned logistic regression.\n",
+    "    Computes the predictions for X using a threshold at 0.5 \n",
+    "    (i.e., if sigmoid(theta.T*x) >= 0.5, predict 1)\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data to use for computing predictions. The rows is the number \n",
+    "        of points to compute predictions, and columns is the number of\n",
+    "        features.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    p : array_like\n",
+    "        Predictions and 0 or 1 for each row in X. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the following code to make predictions using your learned \n",
+    "    logistic regression parameters.You should set p to a vector of 0's and 1's    \n",
+    "    \"\"\"\n",
+    "    m = X.shape[0] # Number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly\n",
+    "    p = np.zeros(m)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================    \n",
+    "    temp = sigmoid(np.dot(theta,X.transpose()))\n",
+    "    #p = [1 for i in range(m) if temp[i]>=0.5]\n",
+    "    for i in range(m):\n",
+    "        if temp[i] >= 0.5:\n",
+    "            p[i] = 1\n",
+    "        else:\n",
+    "            p[i] = 0\n",
+    "    # ============================================================\n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After you have completed the code in `predict`, we proceed to report the training accuracy of your classifier by computing the percentage of examples it got correct."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "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",
+    "prob = sigmoid(np.dot([1, 45, 85], theta))\n",
+    "print('For a student with scores 45 and 85,'\n",
+    "      'we predict an admission probability of {:.3f}'.format(prob))\n",
+    "print('Expected value: 0.775 +/- 0.002\\n')\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "print('Train Accuracy: {:.2f} %'.format(np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (approx): 89.00 %')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
+      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
+      "                                    Predict |   5 /   5 | Nice work!\n",
+      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
+      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  70 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[4] = predict\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2 Regularized logistic regression\n",
+    "\n",
+    "In this part of the exercise, you will implement regularized logistic regression to predict whether microchips from a fabrication plant passes quality assurance (QA). During QA, each microchip goes through various tests to ensure it is functioning correctly.\n",
+    "Suppose you are the product manager of the factory and you have the test results for some microchips on two different tests. From these two tests, you would like to determine whether the microchips should be accepted or rejected. To help you make the decision, you have a dataset of test results on past microchips, from which you can build a logistic regression model.\n",
+    "\n",
+    "First, we load the data from a CSV file:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Data\n",
+    "# The first two columns contains the X values and the third column\n",
+    "# contains the label (y).\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1 Visualize the data\n",
+    "\n",
+    "Similar to the previous parts of this exercise, `plotData` is used to generate a figure, where the axes are the two test scores, and the positive (y = 1, accepted) and negative (y = 0, rejected) examples are shown with\n",
+    "different markers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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": {},
+   "source": [
+    "The above figure shows that our dataset cannot be separated into positive and negative examples by a straight-line through the plot. Therefore, a straight-forward application of logistic regression will not perform well on this dataset since logistic regression will only be able to find a linear decision boundary.\n",
+    "\n",
+    "### 2.2 Feature mapping\n",
+    "\n",
+    "One way to fit the data better is to create more features from each data point. In the function `mapFeature` defined in the file `utils.py`, we will map the features into all polynomial terms of $x_1$ and $x_2$ up to the sixth power.\n",
+    "\n",
+    "$$ \\text{mapFeature}(x) = \\begin{bmatrix} 1 & x_1 & x_2 & x_1^2 & x_1 x_2 & x_2^2 & x_1^3 & \\dots & x_1 x_2^5 & x_2^6 \\end{bmatrix}^T $$\n",
+    "\n",
+    "As a result of this mapping, our vector of two features (the scores on two QA tests) has been transformed into a 28-dimensional vector. A logistic regression classifier trained on this higher-dimension feature vector will have a more complex decision boundary and will appear nonlinear when drawn in our 2-dimensional plot.\n",
+    "While the feature mapping allows us to build a more expressive classifier, it also more susceptible to overfitting. In the next parts of the exercise, you will implement regularized logistic regression to fit the data and also see for yourself how regularization can help combat the overfitting problem.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
+    "# term is handled\n",
+    "X = utils.mapFeature(X[:, 0], X[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section5\"></a>\n",
+    "### 2.3 Cost function and gradient\n",
+    "\n",
+    "Now you will implement code to compute the cost function and gradient for regularized logistic regression. Complete the code for the function `costFunctionReg` below to return the cost and gradient.\n",
+    "\n",
+    "Recall that the regularized cost function in logistic regression is\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ -y^{(i)}\\log \\left( h_\\theta \\left(x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)} \\right) \\log \\left( 1 - h_\\theta \\left( x^{(i)} \\right) \\right) \\right] + \\frac{\\lambda}{2m} \\sum_{j=1}^n \\theta_j^2 $$\n",
+    "\n",
+    "Note that you should not regularize the parameters $\\theta_0$. The gradient of the cost function is a vector where the $j^{th}$ element is defined as follows:\n",
+    "\n",
+    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\qquad \\text{for } j =0 $$\n",
+    "\n",
+    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\left( \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\right) + \\frac{\\lambda}{m}\\theta_j \\qquad \\text{for } j \\ge 1 $$\n",
+    "<a id=\"costFunctionReg\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunctionReg(theta, X, y, lambda_):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression with regularization.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Logistic regression parameters. A vector with shape (n, ). n is \n",
+    "        the number of features including any intercept. If we have mapped\n",
+    "        our initial features into polynomial features, then n is the total \n",
+    "        number of polynomial features. \n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data set with shape (m x n). m is the number of examples, and\n",
+    "        n is the number of features (after feature mapping).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The data labels. A vector with shape (m, ).\n",
+    "    \n",
+    "    lambda_ : float\n",
+    "        The regularization parameter. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the regularized cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost `J` of a particular choice of theta.\n",
+    "    Compute the partial derivatives and set `grad` to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "    n = theta.size\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ===================== YOUR CODE HERE ======================\n",
+    "    J = (-1/m) * ((np.sum(y*(np.log(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))) + (np.sum((1-y)*(np.log(1-(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))))) + ((lambda_/(2*m))*(np.sum(np.square(theta))-(theta[0]*theta[0])))\n",
+    "    \n",
+    "    grad[0] = (1/m) * np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,0])\n",
+    "    \n",
+    "    for i in range(n-1):\n",
+    "        grad[i+1] = (1/m) * (np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,i+1])+\n",
+    "                             (lambda_*theta[i+1]))                                \n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you are done with the `costFunctionReg`, we call it below using the initial value of $\\theta$ (initialized to all zeros), and also another test case where $\\theta$ is all ones."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at initial theta (zeros): 0.693\n",
+      "Expected cost (approx)       : 0.693\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "\n",
+      "------------------------------\n",
+      "\n",
+      "Cost at test theta    : 3.16\n",
+      "Expected cost (approx): 3.16\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1\n",
+    "# DO NOT use `lambda` as a variable name in python\n",
+    "# because it is a python keyword\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# Compute and display initial cost and gradient for regularized logistic\n",
+    "# regression\n",
+    "cost, grad = costFunctionReg(initial_theta, X, y, lambda_)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx)       : 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\\n')\n",
+    "\n",
+    "\n",
+    "# Compute and display cost and gradient\n",
+    "# with all-ones theta and lambda = 10\n",
+    "test_theta = np.ones(X.shape[1])\n",
+    "cost, grad = costFunctionReg(test_theta, X, y, 10)\n",
+    "\n",
+    "print('------------------------------\\n')\n",
+    "print('Cost at test theta    : {:.2f}'.format(cost))\n",
+    "print('Expected cost (approx): 3.16\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
+      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
+      "                                    Predict |   5 /   5 | Nice work!\n",
+      "       Regularized Logistic Regression Cost |  15 /  15 | Nice work!\n",
+      "   Regularized Logistic Regression Gradient |  15 /  15 | Nice work!\n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[5] = costFunctionReg\n",
+    "grader[6] = costFunctionReg\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.3.1 Learning parameters using `scipy.optimize.minimize`\n",
+    "\n",
+    "Similar to the previous parts, you will use `optimize.minimize` to learn the optimal parameters $\\theta$. If you have completed the cost and gradient for regularized logistic regression (`costFunctionReg`) correctly, you should be able to step through the next part of to learn the parameters $\\theta$ using `optimize.minimize`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4 Plotting the decision boundary\n",
+    "\n",
+    "To help you visualize the model learned by this classifier, we have provided the function `plotDecisionBoundary` which plots the (non-linear) decision boundary that separates the positive and negative examples. In `plotDecisionBoundary`, we plot the non-linear decision boundary by computing the classifier’s predictions on an evenly spaced grid and then and draw a contour plot where the predictions change from y = 0 to y = 1. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.5 Optional (ungraded) exercises\n",
+    "\n",
+    "In this part of the exercise, you will get to try out different regularization parameters for the dataset to understand how regularization prevents overfitting.\n",
+    "\n",
+    "Notice the changes in the decision boundary as you vary $\\lambda$. With a small\n",
+    "$\\lambda$, you should find that the classifier gets almost every training example correct, but draws a very complicated boundary, thus overfitting the data. See the following figures for the decision boundaries you should get for different values of $\\lambda$. \n",
+    "\n",
+    "<table>\n",
+    "    <tr>\n",
+    "        <td style=\"text-align:center\">\n",
+    "            No regularization (overfitting)<img src=\"Figures/decision_boundary3.png\">\n",
+    "        </td>        \n",
+    "        <td style=\"text-align:center\">\n",
+    "            Decision boundary with regularization\n",
+    "            <img src=\"Figures/decision_boundary2.png\">\n",
+    "        </td>\n",
+    "        <td style=\"text-align:center\">\n",
+    "            Decision boundary with too much regularization\n",
+    "            <img src=\"Figures/decision_boundary4.png\">\n",
+    "        </td>        \n",
+    "    <tr>\n",
+    "</table>\n",
+    "\n",
+    "This is not a good decision boundary: for example, it predicts that a point at $x = (−0.25, 1.5)$ is accepted $(y = 1)$, which seems to be an incorrect decision given the training set.\n",
+    "With a larger $\\lambda$, you should see a plot that shows an simpler decision boundary which still separates the positives and negatives fairly well. However, if $\\lambda$ is set to too high a value, you will not get a good fit and the decision boundary will not follow the data so well, thus underfitting the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Accuracy: 83.1 %\n",
+      "Expected accuracy (with lambda = 1): 83.1 % (approx)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1 (you should vary this)\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# set options for optimize.minimize\n",
+    "options= {'maxiter': 100}\n",
+    "\n",
+    "res = optimize.minimize(costFunctionReg,\n",
+    "                        initial_theta,\n",
+    "                        (X, y, lambda_),\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# the fun property of OptimizeResult object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property of the result\n",
+    "theta = res.x\n",
+    "\n",
+    "utils.plotDecisionBoundary(plotData, theta, X, y)\n",
+    "pyplot.xlabel('Microchip Test 1')\n",
+    "pyplot.ylabel('Microchip Test 2')\n",
+    "pyplot.legend(['y = 1', 'y = 0'])\n",
+    "pyplot.grid(False)\n",
+    "pyplot.title('lambda = %0.2f' % lambda_)\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "\n",
+    "print('Train Accuracy: %.1f %%' % (np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (with lambda = 1): 83.1 % (approx)\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You do not need to submit any solutions for these optional (ungraded) exercises.*"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Exercise2/Data/ex2data1.txt b/Exercise2/Data/ex2data1.txt
new file mode 100755
index 0000000..3a5f952
--- /dev/null
+++ b/Exercise2/Data/ex2data1.txt
@@ -0,0 +1,100 @@
+34.62365962451697,78.0246928153624,0
+30.28671076822607,43.89499752400101,0
+35.84740876993872,72.90219802708364,0
+60.18259938620976,86.30855209546826,1
+79.0327360507101,75.3443764369103,1
+45.08327747668339,56.3163717815305,0
+61.10666453684766,96.51142588489624,1
+75.02474556738889,46.55401354116538,1
+76.09878670226257,87.42056971926803,1
+84.43281996120035,43.53339331072109,1
+95.86155507093572,38.22527805795094,0
+75.01365838958247,30.60326323428011,0
+82.30705337399482,76.48196330235604,1
+69.36458875970939,97.71869196188608,1
+39.53833914367223,76.03681085115882,0
+53.9710521485623,89.20735013750205,1
+69.07014406283025,52.74046973016765,1
+67.94685547711617,46.67857410673128,0
+70.66150955499435,92.92713789364831,1
+76.97878372747498,47.57596364975532,1
+67.37202754570876,42.83843832029179,0
+89.67677575072079,65.79936592745237,1
+50.534788289883,48.85581152764205,0
+34.21206097786789,44.20952859866288,0
+77.9240914545704,68.9723599933059,1
+62.27101367004632,69.95445795447587,1
+80.1901807509566,44.82162893218353,1
+93.114388797442,38.80067033713209,0
+61.83020602312595,50.25610789244621,0
+38.78580379679423,64.99568095539578,0
+61.379289447425,72.80788731317097,1
+85.40451939411645,57.05198397627122,1
+52.10797973193984,63.12762376881715,0
+52.04540476831827,69.43286012045222,1
+40.23689373545111,71.16774802184875,0
+54.63510555424817,52.21388588061123,0
+33.91550010906887,98.86943574220611,0
+64.17698887494485,80.90806058670817,1
+74.78925295941542,41.57341522824434,0
+34.1836400264419,75.2377203360134,0
+83.90239366249155,56.30804621605327,1
+51.54772026906181,46.85629026349976,0
+94.44336776917852,65.56892160559052,1
+82.36875375713919,40.61825515970618,0
+51.04775177128865,45.82270145776001,0
+62.22267576120188,52.06099194836679,0
+77.19303492601364,70.45820000180959,1
+97.77159928000232,86.7278223300282,1
+62.07306379667647,96.76882412413983,1
+91.56497449807442,88.69629254546599,1
+79.94481794066932,74.16311935043758,1
+99.2725269292572,60.99903099844988,1
+90.54671411399852,43.39060180650027,1
+34.52451385320009,60.39634245837173,0
+50.2864961189907,49.80453881323059,0
+49.58667721632031,59.80895099453265,0
+97.64563396007767,68.86157272420604,1
+32.57720016809309,95.59854761387875,0
+74.24869136721598,69.82457122657193,1
+71.79646205863379,78.45356224515052,1
+75.3956114656803,85.75993667331619,1
+35.28611281526193,47.02051394723416,0
+56.25381749711624,39.26147251058019,0
+30.05882244669796,49.59297386723685,0
+44.66826172480893,66.45008614558913,0
+66.56089447242954,41.09209807936973,0
+40.45755098375164,97.53518548909936,1
+49.07256321908844,51.88321182073966,0
+80.27957401466998,92.11606081344084,1
+66.74671856944039,60.99139402740988,1
+32.72283304060323,43.30717306430063,0
+64.0393204150601,78.03168802018232,1
+72.34649422579923,96.22759296761404,1
+60.45788573918959,73.09499809758037,1
+58.84095621726802,75.85844831279042,1
+99.82785779692128,72.36925193383885,1
+47.26426910848174,88.47586499559782,1
+50.45815980285988,75.80985952982456,1
+60.45555629271532,42.50840943572217,0
+82.22666157785568,42.71987853716458,0
+88.9138964166533,69.80378889835472,1
+94.83450672430196,45.69430680250754,1
+67.31925746917527,66.58935317747915,1
+57.23870631569862,59.51428198012956,1
+80.36675600171273,90.96014789746954,1
+68.46852178591112,85.59430710452014,1
+42.0754545384731,78.84478600148043,0
+75.47770200533905,90.42453899753964,1
+78.63542434898018,96.64742716885644,1
+52.34800398794107,60.76950525602592,0
+94.09433112516793,77.15910509073893,1
+90.44855097096364,87.50879176484702,1
+55.48216114069585,35.57070347228866,0
+74.49269241843041,84.84513684930135,1
+89.84580670720979,45.35828361091658,1
+83.48916274498238,48.38028579728175,1
+42.2617008099817,87.10385094025457,1
+99.31500880510394,68.77540947206617,1
+55.34001756003703,64.9319380069486,1
+74.77589300092767,89.52981289513276,1
diff --git a/Exercise2/Data/ex2data2.txt b/Exercise2/Data/ex2data2.txt
new file mode 100755
index 0000000..a888992
--- /dev/null
+++ b/Exercise2/Data/ex2data2.txt
@@ -0,0 +1,118 @@
+0.051267,0.69956,1
+-0.092742,0.68494,1
+-0.21371,0.69225,1
+-0.375,0.50219,1
+-0.51325,0.46564,1
+-0.52477,0.2098,1
+-0.39804,0.034357,1
+-0.30588,-0.19225,1
+0.016705,-0.40424,1
+0.13191,-0.51389,1
+0.38537,-0.56506,1
+0.52938,-0.5212,1
+0.63882,-0.24342,1
+0.73675,-0.18494,1
+0.54666,0.48757,1
+0.322,0.5826,1
+0.16647,0.53874,1
+-0.046659,0.81652,1
+-0.17339,0.69956,1
+-0.47869,0.63377,1
+-0.60541,0.59722,1
+-0.62846,0.33406,1
+-0.59389,0.005117,1
+-0.42108,-0.27266,1
+-0.11578,-0.39693,1
+0.20104,-0.60161,1
+0.46601,-0.53582,1
+0.67339,-0.53582,1
+-0.13882,0.54605,1
+-0.29435,0.77997,1
+-0.26555,0.96272,1
+-0.16187,0.8019,1
+-0.17339,0.64839,1
+-0.28283,0.47295,1
+-0.36348,0.31213,1
+-0.30012,0.027047,1
+-0.23675,-0.21418,1
+-0.06394,-0.18494,1
+0.062788,-0.16301,1
+0.22984,-0.41155,1
+0.2932,-0.2288,1
+0.48329,-0.18494,1
+0.64459,-0.14108,1
+0.46025,0.012427,1
+0.6273,0.15863,1
+0.57546,0.26827,1
+0.72523,0.44371,1
+0.22408,0.52412,1
+0.44297,0.67032,1
+0.322,0.69225,1
+0.13767,0.57529,1
+-0.0063364,0.39985,1
+-0.092742,0.55336,1
+-0.20795,0.35599,1
+-0.20795,0.17325,1
+-0.43836,0.21711,1
+-0.21947,-0.016813,1
+-0.13882,-0.27266,1
+0.18376,0.93348,0
+0.22408,0.77997,0
+0.29896,0.61915,0
+0.50634,0.75804,0
+0.61578,0.7288,0
+0.60426,0.59722,0
+0.76555,0.50219,0
+0.92684,0.3633,0
+0.82316,0.27558,0
+0.96141,0.085526,0
+0.93836,0.012427,0
+0.86348,-0.082602,0
+0.89804,-0.20687,0
+0.85196,-0.36769,0
+0.82892,-0.5212,0
+0.79435,-0.55775,0
+0.59274,-0.7405,0
+0.51786,-0.5943,0
+0.46601,-0.41886,0
+0.35081,-0.57968,0
+0.28744,-0.76974,0
+0.085829,-0.75512,0
+0.14919,-0.57968,0
+-0.13306,-0.4481,0
+-0.40956,-0.41155,0
+-0.39228,-0.25804,0
+-0.74366,-0.25804,0
+-0.69758,0.041667,0
+-0.75518,0.2902,0
+-0.69758,0.68494,0
+-0.4038,0.70687,0
+-0.38076,0.91886,0
+-0.50749,0.90424,0
+-0.54781,0.70687,0
+0.10311,0.77997,0
+0.057028,0.91886,0
+-0.10426,0.99196,0
+-0.081221,1.1089,0
+0.28744,1.087,0
+0.39689,0.82383,0
+0.63882,0.88962,0
+0.82316,0.66301,0
+0.67339,0.64108,0
+1.0709,0.10015,0
+-0.046659,-0.57968,0
+-0.23675,-0.63816,0
+-0.15035,-0.36769,0
+-0.49021,-0.3019,0
+-0.46717,-0.13377,0
+-0.28859,-0.060673,0
+-0.61118,-0.067982,0
+-0.66302,-0.21418,0
+-0.59965,-0.41886,0
+-0.72638,-0.082602,0
+-0.83007,0.31213,0
+-0.72062,0.53874,0
+-0.59389,0.49488,0
+-0.48445,0.99927,0
+-0.0063364,0.99927,0
+0.63265,-0.030612,0
diff --git a/Exercise2/Figures/decision_boundary1.png b/Exercise2/Figures/decision_boundary1.png
new file mode 100755
index 0000000..f1399c5
Binary files /dev/null and b/Exercise2/Figures/decision_boundary1.png differ
diff --git a/Exercise2/Figures/decision_boundary2.png b/Exercise2/Figures/decision_boundary2.png
new file mode 100755
index 0000000..52c9f75
Binary files /dev/null and b/Exercise2/Figures/decision_boundary2.png differ
diff --git a/Exercise2/Figures/decision_boundary3.png b/Exercise2/Figures/decision_boundary3.png
new file mode 100755
index 0000000..82b6ea1
Binary files /dev/null and b/Exercise2/Figures/decision_boundary3.png differ
diff --git a/Exercise2/Figures/decision_boundary4.png b/Exercise2/Figures/decision_boundary4.png
new file mode 100755
index 0000000..b6c1370
Binary files /dev/null and b/Exercise2/Figures/decision_boundary4.png differ
diff --git a/Exercise2/__pycache__/utils.cpython-37.pyc b/Exercise2/__pycache__/utils.cpython-37.pyc
new file mode 100644
index 0000000..df8e42f
Binary files /dev/null and b/Exercise2/__pycache__/utils.cpython-37.pyc differ
diff --git a/Exercise2/exercise2.ipynb b/Exercise2/exercise2.ipynb
new file mode 100755
index 0000000..f537d43
--- /dev/null
+++ b/Exercise2/exercise2.ipynb
@@ -0,0 +1,1211 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Programming Exercise 2: Logistic Regression\n",
+    "\n",
+    "## Introduction\n",
+    "\n",
+    "In this exercise, you will implement logistic regression and apply it to two different datasets. Before starting on the programming exercise, we strongly recommend watching the video lectures and completing the review questions for the associated topics.\n",
+    "\n",
+    "All the information you need for solving this assignment is in this notebook, and all the code you will be implementing will take place within this notebook. The assignment can be promptly submitted to the coursera grader directly from this notebook (code and instructions are included below).\n",
+    "\n",
+    "Before we begin with the exercises, we need to import all libraries required for this programming exercise. Throughout the course, we will be using [`numpy`](http://www.numpy.org/) for all arrays and matrix operations, and [`matplotlib`](https://matplotlib.org/) for plotting. In this assignment, we will also use [`scipy`](https://docs.scipy.org/doc/scipy/reference/), which contains scientific and numerical computation functions and tools. \n",
+    "\n",
+    "You can find instructions on how to install required libraries in the README file in the [github repository](https://github.com/dibgerge/ml-coursera-python-assignments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# used for manipulating directory paths\n",
+    "import os\n",
+    "\n",
+    "# Scientific and vector computation for python\n",
+    "import numpy as np\n",
+    "\n",
+    "# Plotting library\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n",
+    "\n",
+    "# library written for this exercise providing additional functions for assignment submission, and others\n",
+    "import utils\n",
+    "\n",
+    "# define the submission/grader object for this exercise\n",
+    "grader = utils.Grader()\n",
+    "\n",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Submission and Grading\n",
+    "\n",
+    "\n",
+    "After completing each part of the assignment, be sure to submit your solutions to the grader. The following is a breakdown of how each part of this exercise is scored.\n",
+    "\n",
+    "\n",
+    "| Section | Part                                 | Submission function   | Points \n",
+    "| :-      |:-                                    | :-                    | :-:\n",
+    "| 1       | [Sigmoid Function](#section1)                   | [`sigmoid`](#sigmoid) | 5      \n",
+    "| 2       | [Compute cost for logistic regression](#section2) | [`costFunction`](#costFunction) | 30     \n",
+    "| 3       | [Gradient for logistic regression](#section2)     | [`costFunction`](#costFunction) | 30     \n",
+    "| 4       | [Predict Function](#section4)                     | [`predict`](#predict) | 5      \n",
+    "| 5       | [Compute cost for regularized LR](#section5)      | [`costFunctionReg`](#costFunctionReg) | 15     \n",
+    "| 6       | [Gradient for regularized LR](#section5)          | [`costFunctionReg`](#costFunctionReg) | 15     \n",
+    "|         | Total Points                         | | 100    \n",
+    "\n",
+    "\n",
+    "\n",
+    "You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "At the end of each section in this notebook, we have a cell which contains code for submitting the solutions thus far to the grader. Execute the cell to see your score up to the current section. For all your work to be submitted properly, you must execute those cells at least once. They must also be re-executed everytime the submitted function is updated.\n",
+    "</div>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1 Logistic Regression\n",
+    "\n",
+    "In this part of the exercise, you will build a logistic regression model to predict whether a student gets admitted into a university. Suppose that you are the administrator of a university department and\n",
+    "you want to determine each applicant’s chance of admission based on their results on two exams. You have historical data from previous applicants that you can use as a training set for logistic regression. For each training example, you have the applicant’s scores on two exams and the admissions\n",
+    "decision. Your task is to build a classification model that estimates an applicant’s probability of admission based the scores from those two exams. \n",
+    "\n",
+    "The following cell will load the data and corresponding labels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load data\n",
+    "# The first two columns contains the exam scores and the third column\n",
+    "# contains the label.\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data1.txt'), delimiter=',')\n",
+    "X, y = data[:, 0:2], data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1.1 Visualizing the data\n",
+    "\n",
+    "Before starting to implement any learning algorithm, it is always good to visualize the data if possible. We  display the data on a 2-dimensional plot by calling the function `plotData`. You will now complete the code in `plotData` so that it displays a figure where the axes are the two exam scores, and the positive and negative examples are shown with different markers.\n",
+    "\n",
+    "To help you get more familiar with plotting, we have left `plotData` empty so you can try to implement it yourself. However, this is an optional (ungraded) exercise. We also provide our implementation below so you can\n",
+    "copy it or refer to it. If you choose to copy our example, make sure you learn\n",
+    "what each of its commands is doing by consulting the `matplotlib` and `numpy` documentation.\n",
+    "\n",
+    "```python\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",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plotData(X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure. Plots the data \n",
+    "    points with * for the positive examples and o for the negative examples.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        An Mx2 matrix representing the dataset. \n",
+    "    \n",
+    "    y : array_like\n",
+    "        Label values for the dataset. A vector of size (M, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Plot the positive and negative examples on a 2D plot, using the\n",
+    "    option 'k*' for the positive examples and 'ko' for the negative examples.    \n",
+    "    \"\"\"\n",
+    "    # Create New Figure\n",
+    "    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",
+    "    # ============================================================"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we call the implemented function to display the loaded data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plotData(X, y)\n",
+    "# add axes labels\n",
+    "pyplot.xlabel('Exam 1 score')\n",
+    "pyplot.ylabel('Exam 2 score')\n",
+    "pyplot.legend(['Admitted', 'Not admitted'])\n",
+    "pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section1\"></a>\n",
+    "### 1.2 Implementation\n",
+    "\n",
+    "#### 1.2.1 Warmup exercise: sigmoid function\n",
+    "\n",
+    "Before you start with the actual cost function, recall that the logistic regression hypothesis is defined as:\n",
+    "\n",
+    "$$ h_\\theta(x) = g(\\theta^T x)$$\n",
+    "\n",
+    "where function $g$ is the sigmoid function. The sigmoid function is defined as: \n",
+    "\n",
+    "$$g(z) = \\frac{1}{1+e^{-z}}$$.\n",
+    "\n",
+    "Your first step is to implement this function `sigmoid` so it can be\n",
+    "called by the rest of your program. When you are finished, try testing a few\n",
+    "values by calling `sigmoid(x)` in a new cell. For large positive values of `x`, the sigmoid should be close to 1, while for large negative values, the sigmoid should be close to 0. Evaluating `sigmoid(0)` should give you exactly 0.5. Your code should also work with vectors and matrices. **For a matrix, your function should perform the sigmoid function on every element.**\n",
+    "<a id=\"sigmoid\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Compute sigmoid function given the input z.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    z : array_like\n",
+    "        The input to the sigmoid function. This can be a 1-D vector \n",
+    "        or a 2-D matrix. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    g : array_like\n",
+    "        The computed sigmoid function. g has the same shape as z, since\n",
+    "        the sigmoid is computed element-wise on z.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the sigmoid of each value of z (z can be a matrix, vector or scalar).\n",
+    "    \"\"\"\n",
+    "    # convert input to a numpy array\n",
+    "    z = np.array(z)\n",
+    "    \n",
+    "    # You need to return the following variables correctly \n",
+    "    g = np.zeros(z.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    g = 1/(1+(np.exp(-z)))\n",
+    "\n",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following cell evaluates the sigmoid function at `z=0`. You should get a value of 0.5. You can also try different values for `z` to experiment with the sigmoid function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "g( 0 ) =  0.5\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Test the implementation of sigmoid function here\n",
+    "z = 0\n",
+    "g = sigmoid(z)\n",
+    "\n",
+    "print('g(', z, ') = ', g)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After completing a part of the exercise, you can submit your solutions for grading by first adding the function you modified to the submission object, and then sending your function to Coursera for grading. \n",
+    "\n",
+    "The submission script will prompt you for your login e-mail and submission token. You can obtain a submission token from the web page for the assignment. You are allowed to submit your solutions multiple times, and we will take only the highest score into consideration.\n",
+    "\n",
+    "Execute the following cell to grade your solution to the first part of this exercise.\n",
+    "\n",
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |   0 /  30 | \n",
+      "               Logistic Regression Gradient |   0 /  30 | \n",
+      "                                    Predict |   0 /   5 | \n",
+      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
+      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
+      "                                  --------------------------------\n",
+      "                                            |   5 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# appends the implemented function in part 1 to the grader object\n",
+    "grader[1] = sigmoid\n",
+    "\n",
+    "# send the added functions to coursera grader for getting a grade on this part\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section2\"></a>\n",
+    "#### 1.2.2 Cost function and gradient\n",
+    "\n",
+    "Now you will implement the cost function and gradient for logistic regression. Before proceeding we add the intercept term to X. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup the data matrix appropriately, and add ones for the intercept term\n",
+    "m, n = X.shape\n",
+    "\n",
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, complete the code for the function `costFunction` to return the cost and gradient. Recall that the cost function in logistic regression is\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^{m} \\left[ -y^{(i)} \\log\\left(h_\\theta\\left( x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)}\\right) \\log \\left( 1 - h_\\theta\\left( x^{(i)} \\right) \\right) \\right]$$\n",
+    "\n",
+    "and the gradient of the cost is a vector of the same length as $\\theta$ where the $j^{th}$\n",
+    "element (for $j = 0, 1, \\cdots , n$) is defined as follows:\n",
+    "\n",
+    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left( x^{(i)} \\right) - y^{(i)} \\right) x_j^{(i)} $$\n",
+    "\n",
+    "Note that while this gradient looks identical to the linear regression gradient, the formula is actually different because linear and logistic regression have different definitions of $h_\\theta(x)$.\n",
+    "<a id=\"costFunction\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunction(theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression. \n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        The parameters for logistic regression. This a vector\n",
+    "        of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n+1) where m is the total number\n",
+    "        of data points and n is the number of features. We assume the \n",
+    "        intercept has already been added to the input.\n",
+    "    \n",
+    "    y : arra_like\n",
+    "        Labels for the input. This is a vector of shape (m, ).\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n+1, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "        \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost of a particular choice of theta. You should set J to \n",
+    "    the cost. Compute the partial derivatives and set grad to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    J = (-1/m) * ((np.sum(y*(np.log(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))) + \n",
+    "                     (np.sum((1-y)*(np.log(1-(1/(np.exp(-np.dot(theta,X.transpose())) + 1)))))))\n",
+    "    \n",
+    "    for i in range(n+1):\n",
+    "        grad[i] = (1/m) * np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,i])\n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you are done call your `costFunction` using two test cases for  $\\theta$ by executing the next cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "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",
+    "\n",
+    "cost, grad = costFunction(initial_theta, X, y)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros):')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[-0.1000, -12.0092, -11.2628]\\n')\n",
+    "\n",
+    "# Compute and display cost and gradient with non-zero theta\n",
+    "test_theta = np.array([-24, 0.2, 0.2])\n",
+    "cost, grad = costFunction(test_theta, X, y)\n",
+    "\n",
+    "print('Cost at test theta: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.218\\n')\n",
+    "\n",
+    "print('Gradient at test theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*grad))\n",
+    "print('Expected gradients (approx):\\n\\t[0.043, 2.566, 2.647]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
+      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
+      "                                    Predict |   0 /   5 | \n",
+      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
+      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  65 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[2] = costFunction\n",
+    "grader[3] = costFunction\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.2.3 Learning parameters using `scipy.optimize`\n",
+    "\n",
+    "In the previous assignment, you found the optimal parameters of a linear regression model by implementing gradient descent. You wrote a cost function and calculated its gradient, then took a gradient descent step accordingly. This time, instead of taking gradient descent steps, you will use the [`scipy.optimize` module](https://docs.scipy.org/doc/scipy/reference/optimize.html). SciPy is a numerical computing library for `python`. It provides an optimization module for root finding and minimization. As of `scipy 1.0`, the function `scipy.optimize.minimize` is the method to use for optimization problems(both constrained and unconstrained).\n",
+    "\n",
+    "For logistic regression, you want to optimize the cost function $J(\\theta)$ with parameters $\\theta$.\n",
+    "Concretely, you are going to use `optimize.minimize` to find the best parameters $\\theta$ for the logistic regression cost function, given a fixed dataset (of X and y values). You will pass to `optimize.minimize` the following inputs:\n",
+    "- `costFunction`: A cost function that, when given the training set and a particular $\\theta$, computes the logistic regression cost and gradient with respect to $\\theta$ for the dataset (X, y). It is important to note that we only pass the name of the function without the parenthesis. This indicates that we are only providing a reference to this function, and not evaluating the result from this function.\n",
+    "- `initial_theta`: The initial values of the parameters we are trying to optimize.\n",
+    "- `(X, y)`: These are additional arguments to the cost function.\n",
+    "- `jac`: Indication if the cost function returns the Jacobian (gradient) along with cost value. (True)\n",
+    "- `method`: Optimization method/algorithm to use\n",
+    "- `options`: Additional options which might be specific to the specific optimization method. In the following, we only tell the algorithm the maximum number of iterations before it terminates.\n",
+    "\n",
+    "If you have completed the `costFunction` correctly, `optimize.minimize` will converge on the right optimization parameters and return the final values of the cost and $\\theta$ in a class object. Notice that by using `optimize.minimize`, you did not have to write any loops yourself, or set a learning rate like you did for gradient descent. This is all done by `optimize.minimize`: you only needed to provide a function calculating the cost and the gradient.\n",
+    "\n",
+    "In the following, we already have code written to call `optimize.minimize` with the correct arguments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "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",
+    "\n",
+    "# see documention for scipy's optimize.minimize  for description about\n",
+    "# the different parameters\n",
+    "# The function returns an object `OptimizeResult`\n",
+    "# We use truncated Newton algorithm for optimization which is \n",
+    "# equivalent to MATLAB's fminunc\n",
+    "# See https://stackoverflow.com/questions/18801002/fminunc-alternate-in-numpy\n",
+    "res = optimize.minimize(costFunction,\n",
+    "                        initial_theta,\n",
+    "                        (X, y),\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# the fun property of `OptimizeResult` object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property\n",
+    "theta = res.x\n",
+    "\n",
+    "# Print theta to screen\n",
+    "print('Cost at theta found by optimize.minimize: {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx): 0.203\\n');\n",
+    "\n",
+    "print('theta:')\n",
+    "print('\\t[{:.3f}, {:.3f}, {:.3f}]'.format(*theta))\n",
+    "print('Expected theta (approx):\\n\\t[-25.161, 0.206, 0.201]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once `optimize.minimize` completes, we want to use the final value for $\\theta$ to visualize the decision boundary on the training data as shown in the figure below. \n",
+    "\n",
+    "![](Figures/decision_boundary1.png)\n",
+    "\n",
+    "To do so, we have written a function `plotDecisionBoundary` for plotting the decision boundary on top of training data. You do not need to write any code for plotting the decision boundary, but we also encourage you to look at the code in `plotDecisionBoundary` to see how to plot such a boundary using the $\\theta$ values. You can find this function in the `utils.py` file which comes with this assignment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot Boundary\n",
+    "utils.plotDecisionBoundary(plotData, theta, X, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section4\"></a>\n",
+    "#### 1.2.4 Evaluating logistic regression\n",
+    "\n",
+    "After learning the parameters, you can use the model to predict whether a particular student will be admitted. For a student with an Exam 1 score of 45 and an Exam 2 score of 85, you should expect to see an admission\n",
+    "probability of 0.776. Another way to evaluate the quality of the parameters we have found is to see how well the learned model predicts on our training set. In this part, your task is to complete the code in function `predict`. The predict function will produce “1” or “0” predictions given a dataset and a learned parameter vector $\\theta$. \n",
+    "<a id=\"predict\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(theta, X):\n",
+    "    \"\"\"\n",
+    "    Predict whether the label is 0 or 1 using learned logistic regression.\n",
+    "    Computes the predictions for X using a threshold at 0.5 \n",
+    "    (i.e., if sigmoid(theta.T*x) >= 0.5, predict 1)\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vector of shape (n+1, ).\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data to use for computing predictions. The rows is the number \n",
+    "        of points to compute predictions, and columns is the number of\n",
+    "        features.\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    p : array_like\n",
+    "        Predictions and 0 or 1 for each row in X. \n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the following code to make predictions using your learned \n",
+    "    logistic regression parameters.You should set p to a vector of 0's and 1's    \n",
+    "    \"\"\"\n",
+    "    m = X.shape[0] # Number of training examples\n",
+    "\n",
+    "    # You need to return the following variables correctly\n",
+    "    p = np.zeros(m)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================    \n",
+    "    temp = sigmoid(np.dot(theta,X.transpose()))\n",
+    "    #p = [1 for i in range(m) if temp[i]>=0.5]\n",
+    "    for i in range(m):\n",
+    "        if temp[i] >= 0.5:\n",
+    "            p[i] = 1\n",
+    "        else:\n",
+    "            p[i] = 0\n",
+    "    # ============================================================\n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After you have completed the code in `predict`, we proceed to report the training accuracy of your classifier by computing the percentage of examples it got correct."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "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",
+    "prob = sigmoid(np.dot([1, 45, 85], theta))\n",
+    "print('For a student with scores 45 and 85,'\n",
+    "      'we predict an admission probability of {:.3f}'.format(prob))\n",
+    "print('Expected value: 0.775 +/- 0.002\\n')\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "print('Train Accuracy: {:.2f} %'.format(np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (approx): 89.00 %')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
+      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
+      "                                    Predict |   5 /   5 | Nice work!\n",
+      "       Regularized Logistic Regression Cost |   0 /  15 | \n",
+      "   Regularized Logistic Regression Gradient |   0 /  15 | \n",
+      "                                  --------------------------------\n",
+      "                                            |  70 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[4] = predict\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2 Regularized logistic regression\n",
+    "\n",
+    "In this part of the exercise, you will implement regularized logistic regression to predict whether microchips from a fabrication plant passes quality assurance (QA). During QA, each microchip goes through various tests to ensure it is functioning correctly.\n",
+    "Suppose you are the product manager of the factory and you have the test results for some microchips on two different tests. From these two tests, you would like to determine whether the microchips should be accepted or rejected. To help you make the decision, you have a dataset of test results on past microchips, from which you can build a logistic regression model.\n",
+    "\n",
+    "First, we load the data from a CSV file:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load Data\n",
+    "# The first two columns contains the X values and the third column\n",
+    "# contains the label (y).\n",
+    "data = np.loadtxt(os.path.join('Data', 'ex2data2.txt'), delimiter=',')\n",
+    "X = data[:, :2]\n",
+    "y = data[:, 2]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1 Visualize the data\n",
+    "\n",
+    "Similar to the previous parts of this exercise, `plotData` is used to generate a figure, where the axes are the two test scores, and the positive (y = 1, accepted) and negative (y = 0, rejected) examples are shown with\n",
+    "different markers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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": {},
+   "source": [
+    "The above figure shows that our dataset cannot be separated into positive and negative examples by a straight-line through the plot. Therefore, a straight-forward application of logistic regression will not perform well on this dataset since logistic regression will only be able to find a linear decision boundary.\n",
+    "\n",
+    "### 2.2 Feature mapping\n",
+    "\n",
+    "One way to fit the data better is to create more features from each data point. In the function `mapFeature` defined in the file `utils.py`, we will map the features into all polynomial terms of $x_1$ and $x_2$ up to the sixth power.\n",
+    "\n",
+    "$$ \\text{mapFeature}(x) = \\begin{bmatrix} 1 & x_1 & x_2 & x_1^2 & x_1 x_2 & x_2^2 & x_1^3 & \\dots & x_1 x_2^5 & x_2^6 \\end{bmatrix}^T $$\n",
+    "\n",
+    "As a result of this mapping, our vector of two features (the scores on two QA tests) has been transformed into a 28-dimensional vector. A logistic regression classifier trained on this higher-dimension feature vector will have a more complex decision boundary and will appear nonlinear when drawn in our 2-dimensional plot.\n",
+    "While the feature mapping allows us to build a more expressive classifier, it also more susceptible to overfitting. In the next parts of the exercise, you will implement regularized logistic regression to fit the data and also see for yourself how regularization can help combat the overfitting problem.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
+    "# term is handled\n",
+    "X = utils.mapFeature(X[:, 0], X[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<a id=\"section5\"></a>\n",
+    "### 2.3 Cost function and gradient\n",
+    "\n",
+    "Now you will implement code to compute the cost function and gradient for regularized logistic regression. Complete the code for the function `costFunctionReg` below to return the cost and gradient.\n",
+    "\n",
+    "Recall that the regularized cost function in logistic regression is\n",
+    "\n",
+    "$$ J(\\theta) = \\frac{1}{m} \\sum_{i=1}^m \\left[ -y^{(i)}\\log \\left( h_\\theta \\left(x^{(i)} \\right) \\right) - \\left( 1 - y^{(i)} \\right) \\log \\left( 1 - h_\\theta \\left( x^{(i)} \\right) \\right) \\right] + \\frac{\\lambda}{2m} \\sum_{j=1}^n \\theta_j^2 $$\n",
+    "\n",
+    "Note that you should not regularize the parameters $\\theta_0$. The gradient of the cost function is a vector where the $j^{th}$ element is defined as follows:\n",
+    "\n",
+    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_0} = \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\qquad \\text{for } j =0 $$\n",
+    "\n",
+    "$$ \\frac{\\partial J(\\theta)}{\\partial \\theta_j} = \\left( \\frac{1}{m} \\sum_{i=1}^m \\left( h_\\theta \\left(x^{(i)}\\right) - y^{(i)} \\right) x_j^{(i)} \\right) + \\frac{\\lambda}{m}\\theta_j \\qquad \\text{for } j \\ge 1 $$\n",
+    "<a id=\"costFunctionReg\"></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def costFunctionReg(theta, X, y, lambda_):\n",
+    "    \"\"\"\n",
+    "    Compute cost and gradient for logistic regression with regularization.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    theta : array_like\n",
+    "        Logistic regression parameters. A vector with shape (n, ). n is \n",
+    "        the number of features including any intercept. If we have mapped\n",
+    "        our initial features into polynomial features, then n is the total \n",
+    "        number of polynomial features. \n",
+    "    \n",
+    "    X : array_like\n",
+    "        The data set with shape (m x n). m is the number of examples, and\n",
+    "        n is the number of features (after feature mapping).\n",
+    "    \n",
+    "    y : array_like\n",
+    "        The data labels. A vector with shape (m, ).\n",
+    "    \n",
+    "    lambda_ : float\n",
+    "        The regularization parameter. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    J : float\n",
+    "        The computed value for the regularized cost function. \n",
+    "    \n",
+    "    grad : array_like\n",
+    "        A vector of shape (n, ) which is the gradient of the cost\n",
+    "        function with respect to theta, at the current values of theta.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Compute the cost `J` of a particular choice of theta.\n",
+    "    Compute the partial derivatives and set `grad` to the partial\n",
+    "    derivatives of the cost w.r.t. each parameter in theta.\n",
+    "    \"\"\"\n",
+    "    # Initialize some useful values\n",
+    "    m = y.size  # number of training examples\n",
+    "    n = theta.size\n",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "\n",
+    "    # ===================== YOUR CODE HERE ======================\n",
+    "    J = (-1/m) * ((np.sum(y*(np.log(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))) + (np.sum((1-y)*(np.log(1-(1/(np.exp(-np.dot(theta,X.transpose())) + 1))))))) + ((lambda_/(2*m))*(np.sum(np.square(theta))-(theta[0]*theta[0])))\n",
+    "    \n",
+    "    grad[0] = (1/m) * np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,0])\n",
+    "    \n",
+    "    for i in range(n-1):\n",
+    "        grad[i+1] = (1/m) * (np.sum(((1/(1 + np.exp(-np.dot(theta,X.transpose())))) - y) * X[:,i+1])+\n",
+    "                             (lambda_*theta[i+1]))                                \n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once you are done with the `costFunctionReg`, we call it below using the initial value of $\\theta$ (initialized to all zeros), and also another test case where $\\theta$ is all ones."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost at initial theta (zeros): 0.693\n",
+      "Expected cost (approx)       : 0.693\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n",
+      "\n",
+      "------------------------------\n",
+      "\n",
+      "Cost at test theta    : 3.16\n",
+      "Expected cost (approx): 3.16\n",
+      "\n",
+      "Gradient at initial theta (zeros) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n",
+      "Expected gradients (approx) - first five values only:\n",
+      "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1\n",
+    "# DO NOT use `lambda` as a variable name in python\n",
+    "# because it is a python keyword\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# Compute and display initial cost and gradient for regularized logistic\n",
+    "# regression\n",
+    "cost, grad = costFunctionReg(initial_theta, X, y, lambda_)\n",
+    "\n",
+    "print('Cost at initial theta (zeros): {:.3f}'.format(cost))\n",
+    "print('Expected cost (approx)       : 0.693\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\\n')\n",
+    "\n",
+    "\n",
+    "# Compute and display cost and gradient\n",
+    "# with all-ones theta and lambda = 10\n",
+    "test_theta = np.ones(X.shape[1])\n",
+    "cost, grad = costFunctionReg(test_theta, X, y, 10)\n",
+    "\n",
+    "print('------------------------------\\n')\n",
+    "print('Cost at test theta    : {:.2f}'.format(cost))\n",
+    "print('Expected cost (approx): 3.16\\n')\n",
+    "\n",
+    "print('Gradient at initial theta (zeros) - first five values only:')\n",
+    "print('\\t[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}]'.format(*grad[:5]))\n",
+    "print('Expected gradients (approx) - first five values only:')\n",
+    "print('\\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You should now submit your solutions.*"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Submitting Solutions | Programming Exercise logistic-regression\n",
+      "\n",
+      "Use token from last successful submission (videhraj29072000@gmail.com)? (Y/n): y\n",
+      "                                  Part Name |     Score | Feedback\n",
+      "                                  --------- |     ----- | --------\n",
+      "                           Sigmoid Function |   5 /   5 | Nice work!\n",
+      "                   Logistic Regression Cost |  30 /  30 | Nice work!\n",
+      "               Logistic Regression Gradient |  30 /  30 | Nice work!\n",
+      "                                    Predict |   5 /   5 | Nice work!\n",
+      "       Regularized Logistic Regression Cost |  15 /  15 | Nice work!\n",
+      "   Regularized Logistic Regression Gradient |  15 /  15 | Nice work!\n",
+      "                                  --------------------------------\n",
+      "                                            | 100 / 100 |  \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "grader[5] = costFunctionReg\n",
+    "grader[6] = costFunctionReg\n",
+    "grader.grade()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.3.1 Learning parameters using `scipy.optimize.minimize`\n",
+    "\n",
+    "Similar to the previous parts, you will use `optimize.minimize` to learn the optimal parameters $\\theta$. If you have completed the cost and gradient for regularized logistic regression (`costFunctionReg`) correctly, you should be able to step through the next part of to learn the parameters $\\theta$ using `optimize.minimize`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4 Plotting the decision boundary\n",
+    "\n",
+    "To help you visualize the model learned by this classifier, we have provided the function `plotDecisionBoundary` which plots the (non-linear) decision boundary that separates the positive and negative examples. In `plotDecisionBoundary`, we plot the non-linear decision boundary by computing the classifier’s predictions on an evenly spaced grid and then and draw a contour plot where the predictions change from y = 0 to y = 1. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.5 Optional (ungraded) exercises\n",
+    "\n",
+    "In this part of the exercise, you will get to try out different regularization parameters for the dataset to understand how regularization prevents overfitting.\n",
+    "\n",
+    "Notice the changes in the decision boundary as you vary $\\lambda$. With a small\n",
+    "$\\lambda$, you should find that the classifier gets almost every training example correct, but draws a very complicated boundary, thus overfitting the data. See the following figures for the decision boundaries you should get for different values of $\\lambda$. \n",
+    "\n",
+    "<table>\n",
+    "    <tr>\n",
+    "        <td style=\"text-align:center\">\n",
+    "            No regularization (overfitting)<img src=\"Figures/decision_boundary3.png\">\n",
+    "        </td>        \n",
+    "        <td style=\"text-align:center\">\n",
+    "            Decision boundary with regularization\n",
+    "            <img src=\"Figures/decision_boundary2.png\">\n",
+    "        </td>\n",
+    "        <td style=\"text-align:center\">\n",
+    "            Decision boundary with too much regularization\n",
+    "            <img src=\"Figures/decision_boundary4.png\">\n",
+    "        </td>        \n",
+    "    <tr>\n",
+    "</table>\n",
+    "\n",
+    "This is not a good decision boundary: for example, it predicts that a point at $x = (−0.25, 1.5)$ is accepted $(y = 1)$, which seems to be an incorrect decision given the training set.\n",
+    "With a larger $\\lambda$, you should see a plot that shows an simpler decision boundary which still separates the positives and negatives fairly well. However, if $\\lambda$ is set to too high a value, you will not get a good fit and the decision boundary will not follow the data so well, thus underfitting the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train Accuracy: 83.1 %\n",
+      "Expected accuracy (with lambda = 1): 83.1 % (approx)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Initialize fitting parameters\n",
+    "initial_theta = np.zeros(X.shape[1])\n",
+    "\n",
+    "# Set regularization parameter lambda to 1 (you should vary this)\n",
+    "lambda_ = 1\n",
+    "\n",
+    "# set options for optimize.minimize\n",
+    "options= {'maxiter': 100}\n",
+    "\n",
+    "res = optimize.minimize(costFunctionReg,\n",
+    "                        initial_theta,\n",
+    "                        (X, y, lambda_),\n",
+    "                        jac=True,\n",
+    "                        method='TNC',\n",
+    "                        options=options)\n",
+    "\n",
+    "# the fun property of OptimizeResult object returns\n",
+    "# the value of costFunction at optimized theta\n",
+    "cost = res.fun\n",
+    "\n",
+    "# the optimized theta is in the x property of the result\n",
+    "theta = res.x\n",
+    "\n",
+    "utils.plotDecisionBoundary(plotData, theta, X, y)\n",
+    "pyplot.xlabel('Microchip Test 1')\n",
+    "pyplot.ylabel('Microchip Test 2')\n",
+    "pyplot.legend(['y = 1', 'y = 0'])\n",
+    "pyplot.grid(False)\n",
+    "pyplot.title('lambda = %0.2f' % lambda_)\n",
+    "\n",
+    "# Compute accuracy on our training set\n",
+    "p = predict(theta, X)\n",
+    "\n",
+    "print('Train Accuracy: %.1f %%' % (np.mean(p == y) * 100))\n",
+    "print('Expected accuracy (with lambda = 1): 83.1 % (approx)\\n')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "*You do not need to submit any solutions for these optional (ungraded) exercises.*"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Exercise2/token.pkl b/Exercise2/token.pkl
new file mode 100644
index 0000000..8f65fee
Binary files /dev/null and b/Exercise2/token.pkl differ
diff --git a/Exercise2/utils.py b/Exercise2/utils.py
new file mode 100755
index 0000000..7c52dbe
--- /dev/null
+++ b/Exercise2/utils.py
@@ -0,0 +1,147 @@
+import sys
+import numpy as np
+from matplotlib import pyplot
+
+sys.path.append('..')
+from submission import SubmissionBase
+
+
+def mapFeature(X1, X2, degree=6):
+    """
+    Maps the two input features to quadratic features used in the regularization exercise.
+
+    Returns a new feature array with more features, comprising of
+    X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..
+
+    Parameters
+    ----------
+    X1 : array_like
+        A vector of shape (m, 1), containing one feature for all examples.
+
+    X2 : array_like
+        A vector of shape (m, 1), containing a second feature for all examples.
+        Inputs X1, X2 must be the same size.
+
+    degree: int, optional
+        The polynomial degree.
+
+    Returns
+    -------
+    : array_like
+        A matrix of of m rows, and columns depend on the degree of polynomial.
+    """
+    if X1.ndim > 0:
+        out = [np.ones(X1.shape[0])]
+    else:
+        out = [np.ones(1)]
+
+    for i in range(1, degree + 1):
+        for j in range(i + 1):
+            out.append((X1 ** (i - j)) * (X2 ** j))
+
+    if X1.ndim > 0:
+        return np.stack(out, axis=1)
+    else:
+        return np.array(out)
+
+
+def plotDecisionBoundary(plotData, theta, X, y):
+    """
+    Plots the data points X and y into a new figure with the decision boundary defined by theta.
+    Plots the data points with * for the positive examples and o for  the negative examples.
+
+    Parameters
+    ----------
+    plotData : func
+        A function reference for plotting the X, y data.
+
+    theta : array_like
+        Parameters for logistic regression. A vector of shape (n+1, ).
+
+    X : array_like
+        The input dataset. X is assumed to be  a either:
+            1) Mx3 matrix, where the first column is an all ones column for the intercept.
+            2) MxN, N>3 matrix, where the first column is all ones.
+
+    y : array_like
+        Vector of data labels of shape (m, ).
+    """
+    # make sure theta is a numpy array
+    theta = np.array(theta)
+
+    # Plot Data (remember first column in X is the intercept)
+    plotData(X[:, 1:3], y)
+
+    if X.shape[1] <= 3:
+        # Only need 2 points to define a line, so choose two endpoints
+        plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2])
+
+        # Calculate the decision boundary line
+        plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0])
+
+        # Plot, and adjust axes for better viewing
+        pyplot.plot(plot_x, plot_y)
+
+        # Legend, specific for the exercise
+        pyplot.legend(['Admitted', 'Not admitted', 'Decision Boundary'])
+        pyplot.xlim([30, 100])
+        pyplot.ylim([30, 100])
+    else:
+        # Here is the grid range
+        u = np.linspace(-1, 1.5, 50)
+        v = np.linspace(-1, 1.5, 50)
+
+        z = np.zeros((u.size, v.size))
+        # Evaluate z = theta*x over the grid
+        for i, ui in enumerate(u):
+            for j, vj in enumerate(v):
+                z[i, j] = np.dot(mapFeature(ui, vj), theta)
+
+        z = z.T  # important to transpose z before calling contour
+        # print(z)
+
+        # Plot z = 0
+        pyplot.contour(u, v, z, levels=[0], linewidths=2, colors='g')
+        pyplot.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4)
+
+
+class Grader(SubmissionBase):
+    X = np.stack([np.ones(20),
+                  np.exp(1) * np.sin(np.arange(1, 21)),
+                  np.exp(0.5) * np.cos(np.arange(1, 21))], axis=1)
+
+    y = (np.sin(X[:, 0] + X[:, 1]) > 0).astype(float)
+
+    def __init__(self):
+        part_names = ['Sigmoid Function',
+                      'Logistic Regression Cost',
+                      'Logistic Regression Gradient',
+                      'Predict',
+                      'Regularized Logistic Regression Cost',
+                      'Regularized Logistic Regression Gradient']
+        super().__init__('logistic-regression', part_names)
+
+    def __iter__(self):
+        for part_id in range(1, 7):
+            try:
+                func = self.functions[part_id]
+
+                # Each part has different expected arguments/different function
+                if part_id == 1:
+                    res = func(self.X)
+                elif part_id == 2:
+                    res = func(np.array([0.25, 0.5, -0.5]), self.X, self.y)
+                elif part_id == 3:
+                    J, grad = func(np.array([0.25, 0.5, -0.5]), self.X, self.y)
+                    res = grad
+                elif part_id == 4:
+                    res = func(np.array([0.25, 0.5, -0.5]), self.X)
+                elif part_id == 5:
+                    res = func(np.array([0.25, 0.5, -0.5]), self.X, self.y, 0.1)
+                elif part_id == 6:
+                    res = func(np.array([0.25, 0.5, -0.5]), self.X, self.y, 0.1)[1]
+                else:
+                    raise KeyError
+                yield part_id, res
+            except KeyError:
+                yield part_id, 0
diff --git a/__pycache__/submission.cpython-37.pyc b/__pycache__/submission.cpython-37.pyc
new file mode 100644
index 0000000..e803db3
Binary files /dev/null and b/__pycache__/submission.cpython-37.pyc differ
diff --git a/requirements.txt b/requirements.txt
new file mode 100755
index 0000000..1a7539c
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,68 @@
+appdirs==1.4.3
+asn1crypto==0.24.0
+attrs==18.1.0
+Automat==0.7.0
+backcall==0.1.0
+bleach==2.1.4
+certifi==2018.8.13
+cffi==1.11.5
+constantly==15.1.0
+cryptography==2.3.1
+cycler==0.10.0
+decorator==4.3.0
+entrypoints==0.2.3
+html5lib==1.0.1
+hyperlink==18.0.0
+idna==2.7
+incremental==17.5.0
+ipykernel==4.8.2
+ipython==6.5.0
+ipython-genutils==0.2.0
+ipywidgets==7.4.0
+jedi==0.12.1
+Jinja2==2.10
+jsonschema==2.6.0
+jupyter==1.0.0
+jupyter-client==5.2.3
+jupyter-console==5.2.0
+jupyter-core==4.4.0
+MarkupSafe==1.0
+matplotlib==2.1.2
+mistune==0.8.3
+mkl-fft==1.0.4
+mkl-random==1.0.1
+nbconvert==5.3.1
+nbformat==4.4.0
+notebook==5.6.0
+numpy==1.13.3
+pandocfilters==1.4.2
+parso==0.3.1
+pexpect==4.6.0
+pickleshare==0.7.4
+prometheus-client==0.3.1
+prompt-toolkit==1.0.15
+ptyprocess==0.6.0
+pyasn1==0.4.4
+pyasn1-modules==0.2.2
+pycparser==2.18
+Pygments==2.2.0
+pyOpenSSL==18.0.0
+pyparsing==2.2.0
+python-dateutil==2.7.3
+pytz==2018.5
+pyzmq==17.1.2
+qtconsole==4.3.1
+scipy==1.1.0
+Send2Trash==1.5.0
+service-identity==17.0.0
+simplegeneric==0.8.1
+six==1.11.0
+terminado==0.8.1
+testpath==0.3.1
+tornado==5.1
+traitlets==4.3.2
+Twisted==18.7.0
+wcwidth==0.1.7
+webencodings==0.5.1
+widgetsnbextension==3.4.0
+zope.interface==4.5.0
diff --git a/submission.py b/submission.py
new file mode 100755
index 0000000..10113e4
--- /dev/null
+++ b/submission.py
@@ -0,0 +1,105 @@
+from urllib.parse import urlencode
+from urllib.request import urlopen
+import pickle
+import json
+from collections import OrderedDict
+import numpy as np
+import os
+
+
+class SubmissionBase:
+
+    submit_url = 'https://www-origin.coursera.org/api/' \
+                 'onDemandProgrammingImmediateFormSubmissions.v1'
+    save_file = 'token.pkl'
+
+    def __init__(self, assignment_slug, part_names):
+        self.assignment_slug = assignment_slug
+        self.part_names = part_names
+        self.login = None
+        self.token = None
+        self.functions = OrderedDict()
+        self.args = dict()
+
+    def grade(self):
+        print('\nSubmitting Solutions | Programming Exercise %s\n' % self.assignment_slug)
+        self.login_prompt()
+
+        # Evaluate the different parts of exercise
+        parts = OrderedDict()
+        for part_id, result in self:
+            parts[str(part_id)] = {'output': sprintf('%0.5f ', result)}
+        result, response = self.request(parts)
+        response = json.loads(response.decode("utf-8"))
+
+        # if an error was returned, print it and stop
+        if 'errorMessage' in response:
+            print(response['errorMessage'])
+            return
+
+        # Print the grading table
+        print('%43s | %9s | %-s' % ('Part Name', 'Score', 'Feedback'))
+        print('%43s | %9s | %-s' % ('---------', '-----', '--------'))
+        for part in parts:
+            part_feedback = response['partFeedbacks'][part]
+            part_evaluation = response['partEvaluations'][part]
+            score = '%d / %3d' % (part_evaluation['score'], part_evaluation['maxScore'])
+            print('%43s | %9s | %-s' % (self.part_names[int(part) - 1], score, part_feedback))
+        evaluation = response['evaluation']
+        total_score = '%d / %d' % (evaluation['score'], evaluation['maxScore'])
+        print('                                  --------------------------------')
+        print('%43s | %9s | %-s\n' % (' ', total_score, ' '))
+
+    def login_prompt(self):
+        if os.path.isfile(self.save_file):
+            with open(self.save_file, 'rb') as f:
+                login, token = pickle.load(f)
+            reenter = input('Use token from last successful submission (%s)? (Y/n): ' % login)
+
+            if reenter == '' or reenter[0] == 'Y' or reenter[0] == 'y':
+                self.login, self.token = login, token
+                return
+            else:
+                os.remove(self.save_file)
+
+        self.login = input('Login (email address): ')
+        self.token = input('Token: ')
+
+        # Save the entered credentials
+        if not os.path.isfile(self.save_file):
+            with open(self.save_file, 'wb') as f:
+                pickle.dump((self.login, self.token), f)
+
+    def request(self, parts):
+        params = {
+            'assignmentSlug': self.assignment_slug,
+            'secret': self.token,
+            'parts': parts,
+            'submitterEmail': self.login}
+
+        params = urlencode({'jsonBody': json.dumps(params)}).encode("utf-8")
+        f = urlopen(self.submit_url, params)
+        try:
+            return 0, f.read()
+        finally:
+            f.close()
+
+    def __iter__(self):
+        for part_id in self.functions:
+            yield part_id
+
+    def __setitem__(self, key, value):
+        self.functions[key] = value
+
+
+def sprintf(fmt, arg):
+    """ Emulates (part of) Octave sprintf function. """
+    if isinstance(arg, tuple):
+        # for multiple return values, only use the first one
+        arg = arg[0]
+
+    if isinstance(arg, (np.ndarray, list)):
+        # concatenates all elements, column by column
+        return ' '.join(fmt % e for e in np.asarray(arg).ravel('F'))
+    else:
+        return fmt % arg
diff --git a/test/.ipynb_checkpoints/Test-checkpoint.ipynb b/test/.ipynb_checkpoints/Test-checkpoint.ipynb
new file mode 100644
index 0000000..a14f259
--- /dev/null
+++ b/test/.ipynb_checkpoints/Test-checkpoint.ipynb
@@ -0,0 +1,197 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3,4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 2, 3, 4])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.ndim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(4,)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b=np.array([[1,2,3],[4,5,6]],dtype=complex)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.+0.j, 2.+0.j, 3.+0.j],\n",
+       "       [4.+0.j, 5.+0.j, 6.+0.j]])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1., 1., 1.],\n",
+       "       [1., 1., 1.]])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "c=np.ones((2,3))\n",
+    "c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pyplot.plot([1,2,3,4],[3,8,4,6],'bo',ms='10',mec='k')\n",
+    "pyplot.xlabel('this is x')\n",
+    "pyplot.ylabel('this is y')\n",
+    "pyplot.axis([0,10,0,15])\n",
+    "pyplot.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/test/Test.ipynb b/test/Test.ipynb
new file mode 100644
index 0000000..04805a8
--- /dev/null
+++ b/test/Test.ipynb
@@ -0,0 +1,913 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3,4])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 2, 3, 4])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.ndim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(4,)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b=np.array([[1,2,3],[4,5,6]],dtype=complex)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1.+0.j, 2.+0.j, 3.+0.j],\n",
+       "       [4.+0.j, 5.+0.j, 6.+0.j]])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1., 1., 1.],\n",
+       "       [1., 1., 1.]])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "c=np.ones((2,3))\n",
+    "c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pyplot.plot([1,2,3,4],[3,8,4,6],'bo',ms='10',mec='k')\n",
+    "pyplot.xlabel('this is x')\n",
+    "pyplot.ylabel('this is y')\n",
+    "pyplot.axis([0,10,0,15])\n",
+    "pyplot.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = np.array([[1,2],[3,4]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 2],\n",
+       "       [3, 4]])"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 3],\n",
+       "       [2, 4]])"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.transpose()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([[1],[2],[3]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1],\n",
+       "       [2],\n",
+       "       [3]])"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1, 2, 3]])"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.transpose()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1],\n",
+       "       [2],\n",
+       "       [3]])"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 4, 9])"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.square(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sum(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3,)"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([[1,2],[3,4]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=[[1,2],[3,4],[5,6]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "list indices must be integers or slices, not tuple",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-93-8b69ab097756>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m: list indices must be integers or slices, not tuple"
+     ]
+    }
+   ],
+   "source": [
+    "a[[1,2],0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'plotData' 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<ipython-input-65-7f5d3c3dd4b7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mplotData\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\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[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'plotData' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "plotData([1,2,3],[4,5,6])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.0"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.mean(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0. , 0.5, 1. ])"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(a-1)/2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.5, 1. , 1.5])"
+      ]
+     },
+     "execution_count": 95,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a/2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 2, 3])"
+      ]
+     },
+     "execution_count": 96,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.73105858, 0.88079708, 0.5       ])"
+      ]
+     },
+     "execution_count": 104,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1/(1+(np.exp(-a)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.36787944117144233"
+      ]
+     },
+     "execution_count": 101,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.exp(-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6931471805599453"
+      ]
+     },
+     "execution_count": 105,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.log(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3])\n",
+    "b=np.array([4,5,6])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 4, 10, 18])"
+      ]
+     },
+     "execution_count": 107,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a*b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-3, -3, -3])"
+      ]
+     },
+     "execution_count": 110,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a-b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "hi\n",
+      "hi\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i in range(2):\n",
+    "    print('hi')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 1,  2,  3,  4],\n",
+       "       [ 5,  6,  7,  8],\n",
+       "       [ 9, 10, 11, 12]])"
+      ]
+     },
+     "execution_count": 114,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 4,  8, 12])"
+      ]
+     },
+     "execution_count": 127,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a[:,3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 129,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12"
+      ]
+     },
+     "execution_count": 129,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "2*np.sum(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 134,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "round(0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([0.7,0.4,0.5])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 0., 0.])"
+      ]
+     },
+     "execution_count": 138,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.around(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 140,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1.,2.])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 141,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 2.])"
+      ]
+     },
+     "execution_count": 141,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 142,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.zeros(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 143,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0., 0., 0.])"
+      ]
+     },
+     "execution_count": 143,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 145,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "numpy.float64"
+      ]
+     },
+     "execution_count": 145,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(a[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 146,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([1,2,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 147,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1, 4, 9])"
+      ]
+     },
+     "execution_count": 147,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.square(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}