diff --git a/Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb b/Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb
new file mode 100644
index 000000000..35f3619bf
--- /dev/null
+++ b/Phase 3 - 2020 (Summer)/Week 3(Apr 13 - Apr 18)/Priyansh_Mali190107052.ipynb	
@@ -0,0 +1,827 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def mapFeature(X1, X2, degree=6):\n",
+    "    \"\"\"\n",
+    "    Maps the two input features to quadratic features used in the regularization exercise.\n",
+    "    Returns a new feature array with more features, comprising of\n",
+    "    X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X1 : array_like\n",
+    "        A vector of shape (m, 1), containing one feature for all examples.\n",
+    "    X2 : array_like\n",
+    "        A vector of shape (m, 1), containing a second feature for all examples.\n",
+    "        Inputs X1, X2 must be the same size.\n",
+    "    degree: int, optional\n",
+    "        The polynomial degree.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    : array_like\n",
+    "        A matrix of of m rows, and columns depend on the degree of polynomial.\n",
+    "    \"\"\"\n",
+    "    if X1.ndim > 0:\n",
+    "        out = [np.ones(X1.shape[0])]\n",
+    "    else:\n",
+    "        out = [np.ones(1)]\n",
+    "\n",
+    "    for i in range(1, degree + 1):\n",
+    "        for j in range(i + 1):\n",
+    "            out.append((X1 ** (i - j)) * (X2 ** j))\n",
+    "\n",
+    "    if X1.ndim > 0:\n",
+    "        return np.stack(out, axis=1)\n",
+    "    else:\n",
+    "        return np.array(out)\n",
+    "\n",
+    "\n",
+    "def plotDecisionBoundary(plotData, theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure with the decision boundary defined by theta.\n",
+    "    Plots the data points with * for the positive examples and o for  the negative examples.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    plotData : func\n",
+    "        A function reference for plotting the X, y data.\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vector of shape (n+1, ).\n",
+    "    X : array_like\n",
+    "        The input dataset. X is assumed to be  a either:\n",
+    "            1) Mx3 matrix, where the first column is an all ones column for the intercept.\n",
+    "            2) MxN, N>3 matrix, where the first column is all ones.\n",
+    "    y : array_like\n",
+    "        Vector of data labels of shape (m, ).\n",
+    "    \"\"\"\n",
+    "    # make sure theta is a numpy array\n",
+    "    theta = np.array(theta)\n",
+    "\n",
+    "    # Plot Data (remember first column in X is the intercept)\n",
+    "    plotData(X[:, 1:3], y)\n",
+    "\n",
+    "    if X.shape[1] <= 3:\n",
+    "        # Only need 2 points to define a line, so choose two endpoints\n",
+    "        plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2])\n",
+    "\n",
+    "        # Calculate the decision boundary line\n",
+    "        plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0])\n",
+    "\n",
+    "        # Plot, and adjust axes for better viewing\n",
+    "        pyplot.plot(plot_x, plot_y)\n",
+    "\n",
+    "        # Legend, specific for the exercise\n",
+    "        pyplot.legend(['Admitted', 'Not admitted', 'Decision Boundary'])\n",
+    "        pyplot.xlim([30, 100])\n",
+    "        pyplot.ylim([30, 100])\n",
+    "    else:\n",
+    "        # Here is the grid range\n",
+    "        u = np.linspace(-1, 1.5, 50)\n",
+    "        v = np.linspace(-1, 1.5, 50)\n",
+    "\n",
+    "        z = np.zeros((u.size, v.size))\n",
+    "        # Evaluate z = theta*x over the grid\n",
+    "        for i, ui in enumerate(u):\n",
+    "            for j, vj in enumerate(v):\n",
+    "                z[i, j] = np.dot(mapFeature(ui, vj), theta)\n",
+    "\n",
+    "        z = z.T  # important to transpose z before calling contour\n",
+    "        # print(z)\n",
+    "\n",
+    "        # Plot z = 0\n",
+    "        pyplot.contour(u, v, z, levels=[0], linewidths=2, colors='g')\n",
+    "        pyplot.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "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",
+    "import matplotlib\n",
+    "\n",
+    "import utils\n",
+    "\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "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": "code",
+   "execution_count": 32,
+   "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": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO2de3hU5bXwf2sGyBCDQSC1UqJQoV65SWyl7YGEYKVfOQXb2gO13o6XeuspDfVyKocYxK9VqLY+52gLUpG0X/Bo2wge28MdrNrWYL1bSy2ICMpFiaTIJWF9f8yekISZZGYysy8z6/c877Nn7z177zV7ZvZ63/Wui6gqhmEYhgEQ8loAwzAMwz+YUjAMwzBaMaVgGIZhtGJKwTAMw2jFlIJhGIbRSg+vBegOAwYM0MGDB3sthmEYRqDYuHHjblUtibcv0Eph8ODBNDQ0eC2GYRhGoBCRtxLtM/ORYRiG0YopBcMwDKOVrCkFEfm5iOwUkVfabOsnIitFZJOzPMHZLiJyn4j8TUReEpFzsiWXYRiGkZhsjhQWA5M6bLsVWK2qw4DVzjrAF4FhTrsGeCCLchmGYRgJyJpSUNUNwPsdNk8BHnZePwxMbbN9iUb5A9BXRE7KlmzdoampiTlzqiktLSEcDlFaWsKcOdU0NTV5LZphGEa3cdv76ERV3QGgqjtE5GPO9k8Ab7d53zZn246OJxCRa4iOJjj55JOzK20HmpqaKC8/j+LiN6muPsCQIbB5827q6u5m2bJfsW7dHygqKnJVJsMwjEzil4lmibMtbvpWVV2gqmWqWlZSEtfNNmvcc888iovfZNasAwwdCuEwDB0Ks2YdoLj4Te65Z56r8hiGYWQat5XCezGzkLPc6WzfBpS2ed8gYLvLsnXJwoX3M336AaSDChOBadMO8OCD2Z0KaWxs5MILL6SxsTGr1zH8hX3vhpu4rRSWAZc5ry8DHm+z/VLHC+k8oDFmZvIT27fvYciQ+PuGDInuzybLli2jvr6e5cuXZ/U6hr+w791wk2y6pNYBzwKnicg2EbkS+CFwvohsAs531gGeBP4O/A1YCFyfLbm6w8CB/dm8Of6+zZuj+7PJz3/+83ZLwx287qnb9264STa9j6ar6kmq2lNVB6nqIlXdo6qVqjrMWb7vvFdV9QZVPVVVh6uqL3NXXH319dTVRehYrE4Vli6NcNVV12X0ehMnTkREWtszzzwDwNNPP91u+8SJEzN63XynoxJwu6cetO/da6VpZBa/TDQHgqqqm2hsPJW5cyNs2gTNzbBpE8ydG6Gx8VSqqm7K6PVuu+02CgsLW9cPHTrUbglQWFjIrFmzMnrdfKejEnC7p56J793NB7WZt3IMVQ1sGzNmjLrNvn37tKZmtpaWlmg4HNLS0hKtqZmt+/bty8r11qxZo4WFhUrUG6tdKyws1LVr12bluvlM3759293nXr16tVvGWmVlZdZk6O73vmTJEgW0trY2azLGKC8vV0ArKiqyfi0jMwANmuC56vmDvTvNC6XgBcuXL9dIJNLuwRCJRHT58uVei5YTVFZWtru3PXr0iPswdlshd+d7z+aDuuP98kJpGt2jM6Vg5qME+Clyee/evfTo0YNQKETv3r0JhUL06NGDvXv3ui5LLtLRXNPc3Nzp+wsLC/mf//kfysvLsypXKt+7m/MQZtbMcRJpiyC0bI0U9u3bp2PGnKUTJkR04UJ01Sp04UJ0woSIjhlzVtZMRYkoLy/XUCiko0eP1hUrVujo0aM1FArZcD2DdGauwaMRWirfezLyZ3J0Y2bNYIONFFLDb5HLxcXFzJs3j4aGBs4//3yee+457r77bo4//nhX5chlKioqeOSRR4hEIsfs82qElsr3XlFRwRNPPNGuB9+WTI9uEt2vSCTCI488kvVRlJFFEmmLILRsjRQGDRqgCxeia9ce2xYsQEtLS7JyXcNbamtrtaioSEOhkPbu3bu153vKKacEZoTm5vxTx/sVCoW0qKjIlclto3tgI4XU8Dpy2fCGRYsWsX//fkaOHMnjjz/e2iMfMmRIYEZobs4/dbxfI0eOZP/+/RZkF3BMKcTB68hlwxs6mmvef/995s+fT3FxMQDhcJiZM2dSX1/vsaSJcfNBbWbN3ESiI4lgUlZWpg0NmQ9+njOnmvXr72bWrPbJ71SjgWrjx9/M7Nk1Gb+uYSRLY2Mjl19+OYsXL25VWgBTp05l3LhxzJgxg1AoREtLCz/+8Y956qmnfK3MDHcRkY2qWhZ3nymFY2lbN2HatFjdhGgqi8bGU61uguE5tbW1XHrppdTW1vLNb37Ta3GMgNGZUjDzURyKiopYt+4PjB9/M3fcUcKkSSHuuKOE8eNvNoVg+AJLkmdkCxspGEYAmDhxIqtXr25d79WrF4cOHWpdxqisrGTVqlVeiBiXRGYuw1tspGAYASeoUcSWLC94mFIwjADgdnBapjAzV/AwpWAYASEIUcSJcjCtW7fOl7UgjGMxpWAYAcLvyRETmbnazl360cxlHMWUgmEEiGwGp2WiME9QzVzGUUwpGEaAyGYUcaYmhe+88072798fd9/+/fupqKgwE5KPMZdUw8hj2rqMTp06lXXr1lFRUcGaNWvSPufatWuZNGlSO8+ojtiIwVt855IqIt8RkVdE5FURmeFs6yciK0Vkk7M8wQvZDH9gxeCzz8SJE+nbty/19fX07ds3Y4V5KioqOOOMMxLuN4Xgb1xXCiJyNnA18GlgJDBZRIYBtwKrVXUYsNpZN/IU82/PPrfddhuh0NFHQCZjHwYPHsyVV155jKdUKBTyjaeUER8vRgpnAH9Q1f2q2gysBy4EpgAPO+95GJjqgWxGB7zqsZt/e3Zo6zI6YcKEdkqhI93p0dfX11NeXn6Mp1RhYaFvPKVSIZ9Grl4ohVeAcSLSX0QKgf8DlAInquoOAGf5sXgHi8g1ItIgIg27du1yTeh8xa0eu5s1hvOZZOtR9+zZs9s9+lyqt5BPI1fXlYKqvg7cBawEfge8CHReKb398QtUtUxVy0pKSrIkpRHDrR57UNM4BI2uXEYBRISCgoJu9+hzqd5CXo1cE5Vkc6sB/xe4HngDOMnZdhLwRlfHZqscZz5TWVnZrpRjr1692i1jrbKyMuPXtmLw7hGvbKeI6Jw5c3T06NEqIjpgwADdu3ev16K6zt69e3XAgAGe/Q/cAL+V4xSRjznLk4GvAHXAMuAy5y2XAY97IVuQyYTd08seexDSOOQKbSOjQ6EQIsJxxx3HkCFDeO655/iXf/kXdu/enRfmko4sW7aM3bt306tXr9Zt+TRy9Sp47Vci8hqwHLhBVT8AfgicLyKbgPOddSMFMmH39Doi1e9pHHKFtvb+3/3ud4waNarV3h8Oh3n33XeBPDGXdCD2mc8880xP/geeT2onGkIEoZn5qD3l5eUKaEVFRbfPFc+8EIlEdPny5RmQNDHl5eUaCoV09OjRumLFCh09erSGQqGMfCbjKFOmTNEf/ehH2tLSoqqqEyZMyGlzSWckazJ163+wZMkSBbS2tjZr18Bv5iMjM2TTY8erHrsXk5Oe98w8oL6+nqqqqlaX1FmzZuXtRH8yJlOIFjZy43/g+aR2Im0RhJbvI4XOJmZjLd0J2nzqsbvRMwsCy5Yt03A4nJcT/V39l4YOHZq1/4EXzh10MlLw/MHenZbvSkE1ex47Hc0Lzc3NOn/+fJ0yZUoGpfcHmTS7ZYK9e/fq1KlTXff8iSnHnj17um429APxTKahUEivvPLKrP4Pstm5S4QphRzHK/t/UPHS7TYZvBq5xJRjOBzWUCikvXv31lAopEVFRXkxiqqtrdWioiJPPrvb7tidKQWbU8gBzGMnNfweKOeWTbm8vDzunFRLSwtHjhzho48+4siRIzQ1NeWFF5KXEdh+csc2pZAD5FI6ATfw2u22I16l+Bg7dmy79XiprgsLC7n22msDGYWcKl5HYPumc5doCBGEZuajKPlk/88kfjG7eWFTVj1qLgqFQnk5uew33HTuwOYUDONYvLQhd8QNm3KiuZQePXq47otvHIubnTtTCoYRB7+53WZ75JLMiASiOZDyZXI5X+lMKdicgpG3eG1D7ki2bcpdzaWICPPmzWuX8sLIQxJpiyA0GykYuYRbI5d4I5IePXro448/rqo2J5UPYCMFw/A/bo1c4o1IIpEIH374IQDhcJiZM2dSX1+f0esawUCiSiOYlJWVaUNDg9diGEagqKioYMOGDYwcOZK77rqLW265hRdffJHx48ezZs0ar8UzXEBENqpqWbx9NlIwjDzDb3Mphr+wkYJhGEaeYSMFw8gy+Zh+28hNTCkYRgbIRNU7w/ADphQMIwN4XhjFMDKEKQXDSAOvktgZRrYxpWAYaeD39NuGkS6eKAUR+a6IvCoir4hInYhERGSIiPxRRDaJyCMi0ssL2QwjGfyWftswMoXrSkFEPgH8G1CmqmcDYWAacBdwr6oOAz4ArnRbNsNIBT8VRjGMTOGV+agH0FtEegCFwA5gAvCYs/9hYKpHsgWKpqYm5sypprS0hHA4RGlpCXPmVNPU1OS1aHmBbwqjYG6xRmZwXSmo6jvAfGArUWXQCGwE9qpqs/O2bcAn4h0vIteISIOINOzatcsNkX1LU1MT5eXnsX793VRX72bFCqW6ejfr199Nefl5phhcwE9V78wt1sgEXpiPTgCmAEOAgcBxwBfjvDVuqLWqLlDVMlUtKykpyZ6gAeCee+ZRXPwms2YdYOhQCIdh6FCYNesAxcVvcs8987wWMeeJpYxYvXo1999/P6tWrfIsZYS5xRqZwAvz0URgs6ruUtXDwK+BzwJ9HXMSwCBguweypYTXppuFC+9n+vQDiLTfLgLTph3gwQcfcEWOfKa+vp6qqiqeeOIJ6uvrefLJJ13LMGpusUY28EIpbAXOE5FCERGgEngNWAt8zXnPZcDjHsiWNH4w3WzfvochQ+LvGzIkut9wBy966eYW60+CPrfjxZzCH4lOKD8PvOzIsAC4BagSkb8B/YFFbsuWCn4w3Qwc2J/Nm+Pv27w5ut/IDn7opZtbrD8J+tyOJ95Hqlqtqqer6tmqeomqHlTVv6vqp1V1qKpepKoHvZAtWfxgurn66uupq4vQMdGtKixdGuGqq67Lugz5il966bngFhv0nnVHgj63YxHNaeIH001V1U00Np7K3LkRNm2C5mbYtAnmzo3Q2HgqVVU3ZV2GfMVPvXQ/ucWmQ9B71n4YNWYSUwppkk3TTbIT2EVFRaxb9wfGj7+ZO+4oYdKkEHfcUcL48Tezbt0fKCoqSluG7uLH3l+mZfJLL91PbrHpEPSetV9GjZnClEKaZMt0k+oEdlFREbNn17B1606am1vYunUns2fXeKoQwJ+9v2zI5Ideul8qqSWrdHOtZ+2nUWNGUNXAtjFjxqhX7Nu3T8eMOUsnTIjoggXoypXoggXohAkRHTPmLN23b19a562pma0TJkR0zRp07dqjbc2a6LlramZn+JNkh/LycgW0oqLCa1FayYZM5eXlGgqFdPTo0bpixQodPXq0hkIhX31ut1iyZIkCWltb2+n71qxZo4WFhUo0FiluKyws1LVr17ojeIZYvny5RiKRdp8jEono8uXLvRbtGIAGTfBctZFCGjQ1NXHPPfN49913Wbv2ADNmCF/8ItTUDOi26cYPE9jp4Mfenxsy+aWX7geSNQPlXM/awQ+jxoyQSFsEoXkxUmg7Qli4EF21Cl24sPsjhBihkOiqVe1HCbG2ciUaDocy9Ekyix97f36UKZeorKxsdy979erVbhlrlZWVcY8PUs86GYI0asRGCpkj2/EJQY098GPvz48y5RLJTLCGw2FmzJgR9/ic6Vk75MqosUulICKfEpHVIvKKsz5CRIIxjZ4Fsm3eCXLsgV+8cfwuU67QldLt1asXLS0tCR/yQfea6kgs5UkoFH2shsNh11KeZJJkRgoLgX8HDgOo6ktE6x/kJdmOTwh67IEfe39+lClX6EzpfupTnwISzzHkSs8610hGKRSq6p86bGuO+848INvmHT/HHiSDH3t/ycjkx7iKoBBTum05cOAAf/nLX4DEE/u50rPONZJRCrtF5FScVNYi8jWidRDykmTMO93NnurX2INk8GPvLxmZOsYwmJJInpjSHTp0KAUFBa3bm5ujfcegBnHlLYlmoGMN+CSwCtgPvAP8Hjilq+PcaF57H8WLT9ixY0dWvZOM7NAxhiFZn3tDdcqUKfqjH/1IW1paOvX4Mk+vzLF3716dOnWq7t27N63j6cT7qCuFEAK+7rw+DujT2fvdbl4Fr+3bt09ramZraWmJhsMhLS0t0Zqa2a3bcyH4LNdJ1p3yhBNO8FrUwJFrrqZ+pLudls6UQqfmI1U9AtzovP6Hqu7LxOgk6HRm3glq8Fm+kYw7JcC+ffsCmXrBS2xiP/tkM19UMnMKK0XkeyJSKiL9Yi3jkuQIfsieanRNV+6UMWJ2cTB7eLL40dkg6LiZMSAZpfCvwA3ABmCj0xq6feUcJdPeSV6X/MxlErlTxsMC3ZLHj84GQcfNTKyiHd1oAkRZWZk2NPhLP82ZU8369Xcza1Z7E5JqNNZg/PibmT27JqlzxTKmFhe/yfTpBxgyJKpY6uqiMQtBcFH1O7/4xS+47rrr2L9/PwUFBRw8eJAjR460e08kEuHRRx9l8uTJHklpGLB27VomT57M/v37j9mXaqdFRDaqalm8fclENPcUkX8TkcecdqOI9EzqynlIJoPP/FDyM9fpaOooLS1t3Wf28PaYm663uBWdn4z56AFgDHC/08Y424w4ZDL4zCats09HU8fgwYNbt7e1hy9YsCCnHojpPOD9WCMjXYKq4FyZxE/klhRrwIvJbPOieVlPwQ2CmjG1K7rrY51N2vrcq6o2Nzfr/Pnz9ZxzzsmpuIV0XBr9WCMjXYIah5KpTKx0M0tqixPRDICIfBJoSVcJichpIvJCm/ahiMxwvJpWisgmZ3lCutfIFYKaMbUr/NzjTJR6ITZJmiseNMm4NPqxRkamCGoJUFcm8RNpi1gDKoGtwDpgPbAFqOjquGQaEAbeBU4B7gZudbbfCtzV1fG5PlLI1UC4IPQ4u1srwG+k83mSqUfRu3fvQEQpB+X77GwUnckRNulGNOvRh3cBMAIYCRQkc0yS5/0C8LTz+g3gJOf1ScAbXR2f60ohWyU/3SYof8i25FqBnnQ/T1fHff/73/fmA6VIUL7PzsxamTR5dUspEI1R6Ntm/QTg+q6OS6YBPwdudF7v7bDvgwTHXEM0TqLh5JNP7vbN8TudpdQICkH5Q3Yk1/L4pPt54qWtCIVCvh/tdSQI32dno+hMjrC7qxReiLPtz10dl8R5ewG7gRM1BaXQtuX6SCGXCMIfMh65lscnnc9TW1ur4XA47nfn59FePPz2fSY7is70CLszpZDMRHNI5KhTpIiEnQd6d/ki8LyqvuesvyciJznXOAnYmYFrGD4hqBXQci2PTzqfZ9GiRRw5cgTp6BtN8NJi++37TDYHV6J92bjnySiF/wX+W0QqRWQCUAf8LgPXnu6cK8Yy4DLn9WXA4xm4huEj/PaHTIZcy+OTzucpLi5m/vz5rFy5MvD1rv32fXaVg6ugoKBdjYq2ZO2eJxpC6FEzTgi4FngM+BXwLSDc1XFdnLMQ2AMUt9nWH1gNbHKW/bo6j5mPgkWmfKzdJFHcwpQpUzyWLD26+3n8Zn5JFb9+n53d12zcc7rrfaRHH9z9gBGpHJPNZkohWPj1D+klfg7ki0dtba0WFRVpKBTS3r17aygU0qKiosAFgfmNzu5rNu55t5QC0fiE4x2FsJVoltR7ujrOjWZKITVinkyDBg3QUEh00KABgfNkyjWCFlkbxNFeEOjsvmbjnnemFJKZUyhW1Q+BrwAPqeoYIHghjHlOLOPq+vV3U129mxUrlOrq3axffzfl5edZKm6PCFpkbS6mxfZDHqTO7qvr9zyRtog14GWiwWQrgHOdbS91dZwbzUYKyZOr0dFBI4iBfLlONkZrfjcL0s2RwhyiHkh/U9XnnNxHmzKrmoxsYxlX/YGbxVKM5MjGaM3P+b26okuloKqPquoIVb3eWf+7qn41+6LlD25UV8uVMqF+GOp3h65cEIPi2hlk3Ej0FzSzYFuSGSkYWcQtW3+uZFwNcg8sRlAD+XKFbIzWcimjrCkFj3GrutrVV19PXV2E6JTQUVRh6dIIV111XUauk22C3ANrSxAD+XKFbIzWcsosmGiyIQgtFyaaBw0aoAsXxi+ks2ABWlpakpHrBDXjaq5OzJprp/dkOigsSPm9SHeiWUROd9JbFHXYPimzqil/ccvWn8kyoW6SUz2wNuSia2fQyPRoLWfMgom0BfBvRGsc1BMtrDOlzb7nEx3nZrORQn4QpB6YERyyMVoLSsQ3aY4UrgbGqOpUoBz4DxH5jrPv2HSJRlrkiq0/GdL1ssqZHpjhK7IxWvNbwr10EO34NIrtEHlNVc9ss15ENCnea8AEVR3ljoiJKSsr04aGBq/F6BYx76Pi4jeZNu0AQ4ZEvYGWLo3Q2Hiqr007qdD2c06ffvRz1tUl9zl/8YtfcN1117F//34KCgo4ePAghYWFPPDAA3zzm9908ZMYRmKmTp3KuHHjmDFjBqFQiJaWFn784x/z1FNPUV9f77V4rYjIRlUti7sz0RACWAOM6rCtB7AEaEl0nJstF8xHqrlRXa0ruhtRbROzhpE56MR81NlIYRDQrKrvxtn3OVV9OiMqqxvkwkghXygtLaG6ejdDhx67b9MmuOOOErZuTVxXKSg9MMMIAp2NFBIqhSBgSiE4hMMhVqxQwuFj9zU3w6RJIZqbW9wXzDDykM6UggWvGa6QKxHVmSDoqToMb3Drd2NKwXCFfPKy6opcSNVhuI9bv5uklYKIHC8i/WItm0IZuUdV1U00Np7K3LkRXn4ZFi+Giy6Cykr4058Oc+jQobyp6ZArqToMd3Hrd9OlUhCRb4nIe8BLRKuubQTMkI872U1zhVhE9XnnzeC228L89a/wgx/AypVw770tPPvsj3O22E8uJUsz3MOr300yI4XvAWep6mBVHeK0T2ZUigBilcyipKIYi4qKKCjoxbnn9uTOO8lKAkA/2utzNVWHkV28+t0koxTeBPZn8qIi0ldEHhORv4jI6yIy1jFLrRSRTc7yhExeM9O4ld3Uz6SjGLNd7MeP9nqroWCkg1e/m2SUwr8Dz4jIz0Tkvljr5nV/AvxOVU8HRgKvA7cCq1V1GLDaWfctVsksPcWY7QSAfrXXW6oOIx28+N0koxR+RjS6+Q8cnVPYmO4FReR4YBywCEBVD6nqXmAK8LDztoeBqeleww1ypZJZd0hHMWbaNTVI9nqroWCkg9u/m2SUQrOqVqnqQ6r6cKx145qfBHYBD4nIn0XkQRE5DjhRVXcAOMuPxTtYRK4RkQYRadi1a1c3xOge5nefnmLMtGtqkOz1uZAszXAft383ySiFtc6D+KQMuaT2AM4BHlDV0cA/SMFUpKoLVLVMVctKSkq6IUb3ML/79BRjW9fUTZui0cybNsHcudHEeFVVN6UkQ5Ds9VZDwUgHt383Xaa5EJF4f3tN1wNJRD4O/EFVBzvr/0RUKQwFylV1h4icBKxT1dM6O5eXaS7yJbtpZ8yZU8369Xcza1Z7E5Jq9CE/fvzNzJ5dc8xxTU1N3HPPPB588AG2b9/DwIH9ueqq66iquinte/bEE09w0UUXceDAgdZtkUiERx99lMmTJ6d1TsPIVbqV5qKNG+qQTLikOgn23haR2AO/kmg67mXAZc62y4DH072GGwS1klkmSbfXX1RUxOzZNWzdupPm5ha2bt3J7Nk13bpnZq/PP/zofpwTJEqf2rYBZwNfBy6NtWSO6+R8o4gGwL1EtLLbCUB/ol5Hm5xlv67Okyups4OMX9J+W2rt/GPJkiUK+K6qWRAgndTZMUSkmmjltTOBJ4EvAr9X1a9lVj2ljmVJNWJYau3cpLGxkcsvv5zFixdTXFzcbl9FRQXr1q2joqKCNWvWeCRhMEmryI4e7dW/TNTM9KKzfiKwvKvj3Gg2UkiPWO9+0KABGgqJDho0IOeK+hi5QdvRQGVlZbv63L169Wq3jLXKykqvxfY9pFmjOcZHqnoEaHZiDHYSdSs1Aoil5zCCRNtgxCC5HweZZJRCg4j0BRYSDVp7HvhTVqUysoal5zD8TGfBiBMmTGD//sQZd/zkfhxkUqq8JiKDgeNV9aVsCZQKNqeQOt0ti2kY2WTt2rVMnjy504d/QUEBR44c4fDhw63bzP04NbrlkioiV8Zeq+oW4FVn8tkIIJaew/AzyQQjzpw5k4KCAnM/zhLJmI8qReRJJ6L5bKI5kPpkWS4jS1h6DsPvdJUE7plnnrF0IVkkmeC1bxBNUPcyUZfUGar6vWwLZmQHS89hBIHOghEtXUh2SSZOYRhHlcIZRKOPq1Q1ozUW0sHmFFLH0nMYQaCiooINGzYwcuRI7rrrLm655RZefPFFxo8fbzEJGaBbcwrAcuA/VPVbwHiiEcfPZVA+w0UsPYcRBGw04B3JjBSOV9UPO2wbpqqbsipZEthIwTAMI3XSGimIyM0AqvqhiFzUYfcVGZTPMIw4WMI3wws6Mx9Na/P63zvsm5QFWQzDaIMf600buU9nSkESvI63bhgZp6mpiTlzqiktLSEcDlFaWsKcOdV5k4rDr/WmjdymM6WgCV7HWzfyjGw/sP2So8lNxRSketNG7pJwollEWoiWyhSgNxBzQRUgoqo9XZGwE2yi2RvaurVOn37UrbWuLnNurelWdcskbnzOtiST4sHy+xiZIK2JZlUNq+rxqtpHVXs4r2PrnisEwzvcSKq3cOH9TJ/eXiEAiMC0aQd48MEHun2NrnA7eWCQ6k0buUsycQqG0Q43Hth+yNHkhWLqKsWDKQQj25hSMFLGjQe2H3I0eaWYrN604SWmFIyUceOB7XWOpqamJvr27e2JYlq0aJElfDM8w5SCkTKdPbDr6iIMG3ZGt711qqpuorHxVObOjbBpEzQ3R+s9zJ0bneStqropg5+oPbEJ5hNOOEhtLa4rJkvxYHhJSkV2Mi9dOXMAABtASURBVHZRkS3APqAFaFbVMhHpBzwCDAa2AF9X1Q86O0+q3kdNTU3cc888Fi68n+3b9zBwYH+uvvp6qqpuspw/KZAoqV5dXYQ//1kZMQIuueRgt711Yt/Xgw8+0Pp9XXXVdVn/vmKeTzNnHmDmTDjxRLj4Ylo/T21tD/bvP81yRRmBpTPvIy+VQpmq7m6z7W7gfVX9oYjcCpygqrd0dp5UlILb7oW5TrwH9rBhZ9Dc/Eduv/2gZ26kmaBtdbqPPoJHH4Xf/hZ27oT+/eHw4ULefvs9+70YgSUoSuENoFxVd4jIScA6VT2ts/OkohT84Pee63RV6nPOnAG8/fYu9wVLkXA4xIoVSjh87L7mZpg0KURzc4v7guURjY2NXH755SxevJji4mKvxck5ups6OxsosEJENorINc62E1V1B4Cz/Fi8A0XkGhFpEJGGXbuSf8D4we891+nKW+edd3YHIkWFHzyf8h3L++QdXimFz6nqOcAXgRtEZFyyB6rqAlUtU9WykpKSpC/oB7/3XKerh2mfPmQ84CsbeO35ZFjeJy/xRCmo6nZnuRP4DfBp4D3HbISz3JnJa1rvL/tcffX1PPRQfG+dX/4SKioIxIjMS88nv5LtNN6W98k/uK4UROQ4EekTew18AXgFWAZc5rztMuDxTF7Xen/Zp6rqJp5/HmpqaPcwramB996DK68MxojMqtMdS7bNObfddlu79B6HDh1qt4Romo9Zs2Zl5fpGG1TV1QZ8EnjRaa8Ctznb+wOriZb7XA306+pcY8aM0WTZt2+fjhlzlk6YENEFC9CVK9EFC9AJEyI6ZsxZum/fvqTPlej8NTWzddCgARoKiQ4aNEBramZ3+7xBY+DA/jplCvrxj6OhUHR5xRXok09G73dpaYnXIhppUF5eroBWVFRk7Rpr1qzRwsJCJTrn2K4VFhbq2rVrs3btfANo0ETP6EQ7gtBSUQqqRx/cpaUlGg6HtLS0JCMP7rYKZ+FCdNUqdOHCzCmcIFFTM1snTIjomjXo2rXR9uSTUcXQpw8qQt4qzER43aHYu3evTp06Vffu3du6rbKyst1DuVevXu2WsVZZWZlRWZYvX66RSKTdNSKRiC5fvjyj18l3TClkmXgPwrVr0TVrooqhpma21yK6RscR2bJl6Cc/iX7+8+S9woyHHzoUS5YsUUBra2tbt3XWa89m7722tlaLioo0FApp7969NRQKaVFRUTvZjO7TmVKwNBcZwNxdj9LRHv+Vr8DHPw5z5uBK+umg4XZ67njE8/TxKo13ruV9CmKdbVMKGcDcXdtTVFTE7Nk1vPba3ykq6s1f/woTJ8K0abBkSTRKOB8VZjy86FAk6+lz5513up7G26u8T9l6eAcx3sKUQgYwd9djiaUVOeOMj/jBD2DFCpg7F/7+d6iqiiqGfFSYHfGiQ5GKp4/babzr6+upqqoiFIo+msLhMDNnzqS+vj4r14uRrYd3EOMtTClkAHN3PZaYWeTOO9ubjaqrownmHn00fxVmW7zoUKRiGuquOSco5pNMPbxzId7ClEIGsGCnY+nMLHLxxdEEc/mqMNviVYci2Qpv3TXn+NV8kq2Hd07EWySagQ5C84v3kWr23F2DSigkumpVe2+sWFu5Muqaat5H2Y+f6Qw3PH3ciG9Ih2x6VwUh3gJzST1KJnzCvfYrDwKDBg3QhQvjK4UFC9D+/Qvtfjl41aEoLy/XUCiko0eP1hUrVujo0aM1FAp16wGerfiGeLEU3SWbD2+/x1uYUnDIhE+4H/zKg4DFbvifKVOm6I9+9CNtaWlRVdXm5madP3++TpkyJe1zZqsHHi+WIhMkenifd9553VJAfo+3MKXgkOqDKt6IYMKEcTpuXIE97LrAS7OI4S3Z6IFnywwV7+FdUFDQbQWUjVFYJulMKeTVRHMqPuExl8r16++muno3K1Yo1dW7OXBgA9u2HeTAga7Pkc9YUrnOaWpqYs6c6m7XsvYjyU5id4ZbXjzxvKsOHjwIdM8TKdB1thNpiyC0VEcKXU1+hsOh1vd2NqoYPz6ay6ercxj+x4v5oXwwQSZjPuns3ruVZmPKlCk6dOjQducNhUKu5HnyEmykECUVn/BkXCq7OofhbxKNBtevv5vy8vOy1mv3Q2qLbNNVfENX9/7cc891Jc1GfX09CxYsaHedI0eOAAFzI80geaUUUvEJ7yrSdGeHEkDxzmH4G68ezvmQK6sr80ky9z4TZqhk8CrPk1/JK6WQSpBZV6OKoiIsUC3gePVw9kOurGzPaXSVriLZe+9Wmg23FFAQyCulkMrkZ2ejirq6CGVl42wCNeB49XD2OleWV2aztiR7793Mmup2nie/kldKAY5m8Ny6dSfNzS1s3bqT2bNrjnmYdzaq+PDDU3n88f/p8hyGv3H74Rzrne/fv59rrmmfNRbcM0H6YU4j2XvvphdPrqXtTpe8UwrJYi6VuY+beYfa9s7vums/K1dGs8a++WY0a+zLL7tngvTDnMbVV1/P//t/iUfisXvvZtbUQLuRZhDRjt9KgCgrK9OGhgavxTACSuxBXVz8JtOmHWDIkGgvdenS6MM5k8p/zpxq1q+/m1mz2j+MVeG22+D11wv57ne/R1XVTVnvcITDIVasUMLhY/c1N8OkSSGam1uyKsO7777LGWcM5qyzDnLZZbTe+4cfhldfLeD117fw8Y9/PKsy5DMislFVy+Lts5GCkbe4ORrsrHd+xRXQp89xrpkgvZ7TAFiw4AFGjIBPfQpmz4YLLoguP/UpGDEiut/wBs9GCiISBhqAd1R1sogMAZYC/YDngUtU9VBn57CRghEU/NA7j9HZqGXu3Ajjx9/M7Nk1WZWhtLSE6urdDB167L5Nm+COO0rYunXnsTuNjODXkcJ3gNfbrN8F3Kuqw4APgCs9kcoIBEFLE+GH3nkMP9T/8INbrhGfHl5cVEQGAV8C7gSqRESACcA3nLc8DNwOpDyGPHz4MNu2beNAx+REhmdEIhEGDRpEz549M3K+tnMB1dWxuYDd1NXdzbJlv/KlI0B0Ujt+79ztoMeY2eyee+Zxxx0PsH37HgYO7M9VV13nypwGxJRk/JFCEDIDNDU1cc8981i48P7W+3f11de7dv+yiSfmIxF5DPgB0Af4HnA58AdVHersLwV+q6pnxzn2GuAagJNPPnnMW2+91W7/5s2b6dOnD/3790c6GnAN11FV9uzZw759+xiSqGuYIn4wf6SKm5PaQSCI32GMtt/l9OlHv8u6uuB8l74yH4nIZGCnqm5suznOW+NqK1VdoKplqlpWUlJyzP4DBw6YQvARIkL//v0zOnLzg0tlqpiLc3v8YMJKl3TiPIJk7nR9pCAiPwAuAZqBCHA88BvgAuDjqtosImOB21X1gs7OFW+i+fXXX+eMM85ISabGxkYuv/xyFi9eTHFxcUrHGsmRzveSCD9N2hrpEzPBPPigNyasdEl1ktyPIwtfjRRU9d9VdZCqDgamAWtU9WJgLfA1522XAY+7JZNfi4sb8fHTpK2RPslmF/AbqU6S+yGCPBX8FKdwC9FJ578B/YFFbl04FsaeyXD23/zmN4gIf/nLX+Luv/zyy3nssceSPt/27dv52teiOvOFF17gySefbN23bt261iIkqTB48GB2796d8nFe42YksmF0JNVOSdDMnZ4qBVVdp6qTndd/V9VPq+pQVb1IVQ9m67puVHWqq6vj85//PEuXLs2IzAMHDmxVIplSCkElyPZoI/ik2ikJmvutn0YKrnHbbbe1y50eK6aRqaIaTU1NPP300yxatKhVKagqN954I2eeeSZf+tKX2NmmIMPgwYP5/ve/z9ixYykrK+P555/nggsu4NRTT+WnP/0pAFu2bOHss8/m0KFDzJ49m0ceeYRRo0Zx11138dOf/pR7772XUaNG8dRTT7Fr1y6++tWvcu6553Luuefy9NNPA7Bnzx6+8IUvMHr0aL71rW8R1BQnNmlreEmqnZLAmTsTlWQLQotXjvO1117rtAxdjGwUF49RW1ur//qv/6qqqmPHjtWNGzfqr371K504caI2NzfrO++8o8XFxfroo4+qquopp5yi999/v6qqzpgxQ4cPH64ffvih7ty5U0tKSlRVdfPmzXrWWWepqupDDz2kN9xwQ+v1qqurdd68ea3r06dP16eeekpVVd966y09/fTTVVX129/+ttbU1Kiq6hNPPKGA7tq1K+3PmQrJfi+GEQRipURLS0s0HA5paWlJwjKunZX2nTAhojU1s12Xn07KcXoSvOYHYkU1LrroonbukpkoqlFXV8eMGTMAmDZtGnV1dRw+fJjp06cTDocZOHAgEyZMaHfMl7/8ZQCGDx9OU1MTffr0oU+fPkQikZTzua9atYrXXnutdf3DDz9k3759bNiwgV//+tcAfOlLX+KEE05I+zMaRj4TmyRPJpaiquomli37FXPnxo9R8Zu5M2+VArQvqlFQUMDBgwe7XVRjz549rFmzhldeeQURoaWlBRHhwgsv7DR2oqCgAKBVlhihUIjm5uaUZDhy5AjPPvssvXv3PmZfUOM3cjmC1Mht/BBBngp5OacQIxtFNR577DEuvfRS3nrrLbZs2cLbb7/NkCFD6NevH0uXLqWlpYUdO3awdu3atK/Rp08f9u3bl3D9C1/4Av/5n//Zuv7CCy8AMG7cOH75y18C8Nvf/pYPPvggbRncxA+VwgyjOwTJ/TavlUI2imrU1dVx4YUXttv21a9+lXfffZdhw4YxfPhwrrvuOsaPH5/2NSoqKnjttdcYNWoUjzzyCP/8z//Mb37zm9aJ5vvuu4+GhgZGjBjBmWee2TpZXV1dzYYNGzjnnHNYsWIFJ598ctoyuEnQ/LwNI8jkXJGdTEbOGpmjO9+LpVk2jMziq4hmw0iVoPl5G0aQMaVg+J7A+XkbRoAxpWD4HktrYRjuYUrB8D2W1sIw3MOUguF7LK2FYbhHXiuFIBW+yHeC5OdtGEEmb5VCNgOiRISZM2e2rs+fP5/bb7+902Pq6+vbpaZIh1RTYS9btowf/vCHca+/ePFitm/fntL1Y0n7DMMILnmrFLIZEFVQUMCvf/3rlB7QmVAKqfLlL3+ZW2+9Ne7101EKhmEEn7xVCtksfNGjRw+uueYa7r333mP2vfXWW1RWVjJixAgqKyvZunUrzzzzDMuWLeOmm25i1KhRvPnmm+2OWb58OZ/5zGcYPXo0EydO5L333gMSp8LesmULp59+OldddRVnn302F198MatWreJzn/scw4YN409/+hMQffDfeOONx1z/rrvuoqGhgYsvvphRo0bx0UcfsXHjRsaPH8+YMWO44IIL2LFjBwAbN25k5MiRjB07lv/6r/9K+54ZhuETEqVPDULrTursUEh01ar2qWxjbeVKNBwOJXWeeBx33HHa2Niop5xyiu7du1fnzZun1dXVqqo6efJkXbx4saqqLlq0SKdMmaKqqpdddllrKu2OvP/++3rkyBFVVV24cKFWVVWpauJU2Js3b9ZwOKwvvfSStrS06DnnnKNXXHGFHjlyROvr61uv2TYFd8frjx8/Xp977jlVVT106JCOHTtWd+7cqaqqS5cu1SuuuEJVVYcPH67r1q1TVdXvfe97rem9O2Kpsw3DP9BJ6uy8HSlkOyDq+OOP59JLL+W+++5rt/3ZZ5/lG9/4BgCXXHIJv//977s817Zt27jgggsYPnw48+bN49VXXwVgw4YNfPOb3wSOTYU9ZMgQhg8fTigU4qyzzqKyshIRYfjw4WzZsiWlz/LGG2/wyiuvcP755zNq1Cjmzp3Ltm3baGxsZO/eva15nC655JKUzmt4izlaGPHIW6XgRkDUjBkzWLRoEf/4xz8SvieZVNbf/va3ufHGG3n55Zf52c9+1q7+Q6LjO6bfbpuaO9VU3KrKWWedxQsvvMALL7zAyy+/zIoVK1DVwKbizncs86yRiLxVCm4ERPXr14+vf/3rLFq0qHXbZz/72dYSnb/85S/5/Oc/Dxyb/rotjY2NfOITnwDg4Ycfbt2eyVTYnaXjPu2009i1axfPPvssAIcPH+bVV1+lb9++FBcXt452YrIY/scyzxqJcF0piEhERP4kIi+KyKsiUuNsHyIifxSRTSLyiIj0yqYcbgVEzZw5s50X0n333cdDDz3EiBEjqK2t5Sc/+QkQrdA2b948Ro8efcxE8+23385FF13EP/3TPzFgwIDW7ZlMhd3x+pdffjnXXnsto0aNoqWlhccee4xbbrmFkSNHMmrUKJ555hkAHnroIW644QbGjh0bt6iP4U+y6WhhBBvXU2dL1N5wnKo2iUhP4PfAd4Aq4NequlREfgq8qKqd/jItdXZwsO/FX4TDIVasUMLhY/c1N8OkSSGam1vcF8xwBV+lznYmv2MGy55OU2AC8Jiz/WFgqtuyGUa+YJlnjUR4MqcgImEReQHYCawE3gT2qmpsBnQb8IkEx14jIg0i0rBr1y53BDaMHMMyzxqJ8EQpqGqLqo4CBgGfBuLZFeLatVR1gaqWqWpZSUlJovNnTFaj+9j34T8s86yRCE+9j1R1L7AOOA/oKyI9nF2DgLRyLEQiEfbs2WMPIp+gquzZs4dIJOK1KEYbLPOskQgvJppLgMOquldEegMrgLuAy4BftZlofklV7+/sXPEmmg8fPsy2bdva+fIb3hKJRBg0aBA9e/b0WhTDMOh8orlHvI1Z5iTgYREJEx2p/LeqPiEirwFLRWQu8GdgUWcnSUTPnj0Zkqigr2EYhtEprisFVX0JGB1n+9+Jzi8YhmEYHpG3Ec2GYRjGsZhSMAzDMFpxfaI5k4jILuCtNA8fACRfBcd7giRvkGQFkzebBElWCJa83ZH1FFWN69MfaKXQHUSkIdHsux8JkrxBkhVM3mwSJFkhWPJmS1YzHxmGYRitmFIwDMMwWslnpbDAawFSJEjyBklWMHmzSZBkhWDJmxVZ83ZOwTAMwziWfB4pGIZhGB0wpWAYhmG0khdKwS8lQFPBqTnxZxF5wln3s6xbRORlEXlBRBqcbf1EZKUj70oROcFrOQFEpK+IPCYifxGR10VkrI9lPc25p7H2oYjM8Ku8ACLyXec/9oqI1Dn/PV/+dkXkO46cr4rIDGebb+6tiPxcRHaKyCtttsWVT6LcJyJ/E5GXROScdK+bF0oBOAhMUNWRwChgkoicRzQ7672qOgz4ALjSQxk78h3g9TbrfpYVoEJVR7Xxm74VWO3Iu9pZ9wM/AX6nqqcDI4neY1/KqqpvOPd0FDAG2A/8Bp/KKyKfAP4NKFPVs4EwMA0f/nZF5GzgaqL51kYCk0VkGP66t4uBSR22JZLvi8Awp10DpF9kW1XzqgGFwPPAZ4hGA/Zwto8F/tdr+RxZBjlf+ATgCUD8KqsjzxZgQIdtbwAnOa9PAt7wgZzHA5txHCz8LGsc2b8APO1neYlWS3wb6Ec02eYTwAV+/O0CFwEPtln/D+Bmv91bYDDwSpv1uPIBPwOmx3tfqi1fRgrdKgHqAT8m+gM94qz3x7+yQrRK3goR2Sgi1zjbTlTVHQDO8mOeSXeUTwK7gIcc09yDInIc/pS1I9OAOue1L+VV1XeA+cBWYAfQCGzEn7/dV4BxItJfRAqB/wOU4tN724ZE8sUUcoy073PeKAXtRglQNxGRycBOVd3YdnOct3ouaxs+p6rnEB3C3iAi47wWKAE9gHOAB1R1NPAPfGJ66QzHBv9l4FGvZekMx749BRgCDASOI/qb6Ijnv11VfZ2oWWsl8DvgRaC504P8TcaeEXmjFGJoFkqAZpjPAV8WkS3AUqImpB/jT1kBUNXtznInUZv3p4H3ROQkAGe50zsJW9kGbFPVPzrrjxFVEn6UtS1fBJ5X1fecdb/KOxHYrKq7VPUw8Gvgs/j0t6uqi1T1HFUdB7wPbMK/9zZGIvm2ER3pxEj7PueFUhCREhHp67zuTfTH+zqwFvia87bLgMe9kfAoqvrvqjpIVQcTNRmsUdWL8aGsACJynIj0ib0mavt+BVhGVE7wibyq+i7wtoic5myqBF7Dh7J2YDpHTUfgX3m3AueJSKGICEfvr19/ux9zlicDXyF6j/16b2Mkkm8ZcKnjhXQe0BgzM6WM1xM+Lk3WjCBa4vMlog+s2c72TwJ/Av5GdGhe4LWsHeQuB57ws6yOXC867VXgNmd7f6KT5ZucZT+vZXXkGgU0OL+FeuAEv8rqyFsI7AGK22zzs7w1wF+c/1ktUODj3+5TRJXWi0Cl3+4tUSW1AzhMdCRwZSL5iJqP/ovoXOnLRD3A0rqupbkwDMMwWskL85FhGIaRHKYUDMMwjFZMKRiGYRitmFIwDMMwWjGlYBiGYbRiSsHISUSkpUOGUdcil+NltzSMoGAuqUZOIiJNqlrk0bXHAU3AEo1mC3XjmmFVbXHjWkZuYyMFI28QkWIReSMW0ezk+7/aef2AiDRIm3obzvYtIvJ/ReRZZ/85IvK/IvKmiFwb7zqquoFo2oTOZLnIyeX/oohscLaFRWS+RGtTvCQi33a2VzoJ/F52RiEFbWSbLSK/By4SkVNF5HdOYsKnROT0TNw3I7/o0fVbDCOQ9Hay4sb4gao+IiI3AotF5CfACaq60Nl/m6q+LyJhYLWIjFDVl5x9b6vqWBG5l2iO+88BEaIR3D9NU77ZwAWq+k4sBQvRPPhDgNGq2uwUVIk416xU1b+KyBLgOqL5sAAOqOrnAURkNXCtqm4Skc8A9xPNnWUYSWNKwchVPtJoVtx2qOpKEbmIaEqAkW12fd1J+92DaJ76M4mmwoBoXhmIpg8oUtV9wD4ROSAifTWaZDFVniaqnP6baOI4iObk+qk6aaYdJTWSaJK5vzrveRi4gaNK4REAESkimnzu0WjaISCaYsIwUsKUgpFXiEiIaNr0j4gWg9kmIkOA7wHnquoHIrKY6EggxkFneaTN69h6Wv8hVb3W6c1/CXhBREYRzV/TcZIvXkrktvzDWYaI1i04RhEaRirYnIKRb3yXaIbc6cDPRaQn0Yps/wAaReRE4tcAyCgicqqq/lFVZxOtTFYKrACujaWZFpF+RJPLDRaRoc6hlwDrO55PVT8ENjujoFjN3pEd32cYXWFKwchVendwSf2hiHwKuAqYqapPARuAWar6ItEsuq8CPydq2kkbEakDngVOE5FtIhKvJvE8Z+L4FUeOF4EHiaaffklEXgS+oaoHgCuImoVeJjo6STSPcTFwpXPsq0QL3hhGSphLqmEYhtGKjRQMwzCMVkwpGIZhGK2YUjAMwzBaMaVgGIZhtGJKwTAMw2jFlIJhGIbRiikFwzAMo5X/D2r06iWZghgyAAAAAElFTkSuQmCC\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": "code",
+   "execution_count": 34,
+   "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",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "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": "code",
+   "execution_count": 36,
+   "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": "code",
+   "execution_count": 37,
+   "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",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "\n",
+    "    J = 1.0 / m * (-y.T.dot(np.log(sigmoid(z))) - (1 - y).T.dot(np.log(1 - sigmoid(z))))\n",
+    "\n",
+    "    grad = 1.0 / m * (sigmoid(z) - y).T.dot(X)\n",
+    "   \n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "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": "code",
+   "execution_count": 39,
+   "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,initial_theta,(X, y),jac=True,method='TNC',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": "code",
+   "execution_count": 40,
+   "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",
+    "plotDecisionBoundary(plotData, theta, X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "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 vecotor 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",
+    "    z=np.dot(X,theta.T)\n",
+    "    pred = sigmoid(z)\n",
+    "    p = np.where(pred >= .5, 1, 0) \n",
+    "    p=np.squeeze(p) \n",
+    "    \n",
+    "    \n",
+    "    # ============================================================\n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "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": "code",
+   "execution_count": 43,
+   "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": "code",
+   "execution_count": 44,
+   "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\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
+    "# term is handled\n",
+    "X = map_feature(X[:, 0], X[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "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",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "   \n",
+    "\n",
+    "    # ===================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "    i = np.eye(len(theta))\n",
+    "    # Skip the theta[0, 0] parameter when performing regularization\n",
+    "    i[0,0] = 0\n",
+    "    \n",
+    "    J = 1.0 / m * (np.dot(-y.T, np.log(sigmoid(z))) - np.dot((1 - y).T, np.log(1 - sigmoid(z)))) \n",
+    "    J += 1.0 * (lambda_) / (2 * m) * np.sum(np.power((i.dot(theta)), 2))\n",
+    "\n",
+    "    grad = 1.0 / m * np.dot((sigmoid(z) - y).T, X).T + 1.0 * (lambda_) / m * (i.dot(theta))\n",
+    "\n",
+    "   \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "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": "code",
+   "execution_count": 48,
+   "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",
+    "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')"
+   ]
+  },
+  {
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Priyansh_Mali190107052.ipynb b/Priyansh_Mali190107052.ipynb
new file mode 100644
index 000000000..35f3619bf
--- /dev/null
+++ b/Priyansh_Mali190107052.ipynb
@@ -0,0 +1,827 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def mapFeature(X1, X2, degree=6):\n",
+    "    \"\"\"\n",
+    "    Maps the two input features to quadratic features used in the regularization exercise.\n",
+    "    Returns a new feature array with more features, comprising of\n",
+    "    X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X1 : array_like\n",
+    "        A vector of shape (m, 1), containing one feature for all examples.\n",
+    "    X2 : array_like\n",
+    "        A vector of shape (m, 1), containing a second feature for all examples.\n",
+    "        Inputs X1, X2 must be the same size.\n",
+    "    degree: int, optional\n",
+    "        The polynomial degree.\n",
+    "    Returns\n",
+    "    -------\n",
+    "    : array_like\n",
+    "        A matrix of of m rows, and columns depend on the degree of polynomial.\n",
+    "    \"\"\"\n",
+    "    if X1.ndim > 0:\n",
+    "        out = [np.ones(X1.shape[0])]\n",
+    "    else:\n",
+    "        out = [np.ones(1)]\n",
+    "\n",
+    "    for i in range(1, degree + 1):\n",
+    "        for j in range(i + 1):\n",
+    "            out.append((X1 ** (i - j)) * (X2 ** j))\n",
+    "\n",
+    "    if X1.ndim > 0:\n",
+    "        return np.stack(out, axis=1)\n",
+    "    else:\n",
+    "        return np.array(out)\n",
+    "\n",
+    "\n",
+    "def plotDecisionBoundary(plotData, theta, X, y):\n",
+    "    \"\"\"\n",
+    "    Plots the data points X and y into a new figure with the decision boundary defined by theta.\n",
+    "    Plots the data points with * for the positive examples and o for  the negative examples.\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    plotData : func\n",
+    "        A function reference for plotting the X, y data.\n",
+    "    theta : array_like\n",
+    "        Parameters for logistic regression. A vector of shape (n+1, ).\n",
+    "    X : array_like\n",
+    "        The input dataset. X is assumed to be  a either:\n",
+    "            1) Mx3 matrix, where the first column is an all ones column for the intercept.\n",
+    "            2) MxN, N>3 matrix, where the first column is all ones.\n",
+    "    y : array_like\n",
+    "        Vector of data labels of shape (m, ).\n",
+    "    \"\"\"\n",
+    "    # make sure theta is a numpy array\n",
+    "    theta = np.array(theta)\n",
+    "\n",
+    "    # Plot Data (remember first column in X is the intercept)\n",
+    "    plotData(X[:, 1:3], y)\n",
+    "\n",
+    "    if X.shape[1] <= 3:\n",
+    "        # Only need 2 points to define a line, so choose two endpoints\n",
+    "        plot_x = np.array([np.min(X[:, 1]) - 2, np.max(X[:, 1]) + 2])\n",
+    "\n",
+    "        # Calculate the decision boundary line\n",
+    "        plot_y = (-1. / theta[2]) * (theta[1] * plot_x + theta[0])\n",
+    "\n",
+    "        # Plot, and adjust axes for better viewing\n",
+    "        pyplot.plot(plot_x, plot_y)\n",
+    "\n",
+    "        # Legend, specific for the exercise\n",
+    "        pyplot.legend(['Admitted', 'Not admitted', 'Decision Boundary'])\n",
+    "        pyplot.xlim([30, 100])\n",
+    "        pyplot.ylim([30, 100])\n",
+    "    else:\n",
+    "        # Here is the grid range\n",
+    "        u = np.linspace(-1, 1.5, 50)\n",
+    "        v = np.linspace(-1, 1.5, 50)\n",
+    "\n",
+    "        z = np.zeros((u.size, v.size))\n",
+    "        # Evaluate z = theta*x over the grid\n",
+    "        for i, ui in enumerate(u):\n",
+    "            for j, vj in enumerate(v):\n",
+    "                z[i, j] = np.dot(mapFeature(ui, vj), theta)\n",
+    "\n",
+    "        z = z.T  # important to transpose z before calling contour\n",
+    "        # print(z)\n",
+    "\n",
+    "        # Plot z = 0\n",
+    "        pyplot.contour(u, v, z, levels=[0], linewidths=2, colors='g')\n",
+    "        pyplot.contourf(u, v, z, levels=[np.min(z), 0, np.max(z)], cmap='Greens', alpha=0.4)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "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",
+    "import matplotlib\n",
+    "\n",
+    "import utils\n",
+    "\n",
+    "\n",
+    "# Optimization module in scipy\n",
+    "from scipy import optimize\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "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": "code",
+   "execution_count": 32,
+   "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": "code",
+   "execution_count": 33,
+   "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": "code",
+   "execution_count": 34,
+   "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",
+    "    # =============================================================\n",
+    "    return g"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "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": "code",
+   "execution_count": 36,
+   "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": "code",
+   "execution_count": 37,
+   "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",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "\n",
+    "    J = 1.0 / m * (-y.T.dot(np.log(sigmoid(z))) - (1 - y).T.dot(np.log(1 - sigmoid(z))))\n",
+    "\n",
+    "    grad = 1.0 / m * (sigmoid(z) - y).T.dot(X)\n",
+    "   \n",
+    "    \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "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": "code",
+   "execution_count": 39,
+   "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,initial_theta,(X, y),jac=True,method='TNC',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": "code",
+   "execution_count": 40,
+   "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",
+    "plotDecisionBoundary(plotData, theta, X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "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 vecotor 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",
+    "    z=np.dot(X,theta.T)\n",
+    "    pred = sigmoid(z)\n",
+    "    p = np.where(pred >= .5, 1, 0) \n",
+    "    p=np.squeeze(p) \n",
+    "    \n",
+    "    \n",
+    "    # ============================================================\n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "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": "code",
+   "execution_count": 43,
+   "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": "code",
+   "execution_count": 44,
+   "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\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that mapFeature also adds a column of ones for us, so the intercept\n",
+    "# term is handled\n",
+    "X = map_feature(X[:, 0], X[:, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "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",
+    "    # You need to return the following variables correctly \n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "   \n",
+    "\n",
+    "    # ===================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "    z = X.dot(theta)\n",
+    "    i = np.eye(len(theta))\n",
+    "    # Skip the theta[0, 0] parameter when performing regularization\n",
+    "    i[0,0] = 0\n",
+    "    \n",
+    "    J = 1.0 / m * (np.dot(-y.T, np.log(sigmoid(z))) - np.dot((1 - y).T, np.log(1 - sigmoid(z)))) \n",
+    "    J += 1.0 * (lambda_) / (2 * m) * np.sum(np.power((i.dot(theta)), 2))\n",
+    "\n",
+    "    grad = 1.0 / m * np.dot((sigmoid(z) - y).T, X).T + 1.0 * (lambda_) / m * (i.dot(theta))\n",
+    "\n",
+    "   \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "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": "code",
+   "execution_count": 48,
+   "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": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd3yT1f7H3yfpSKGlpWVTpoiCgiLLPcGFCldcLAW5F1EUB9cFQguIqFxUnKg/GbIcF0WGXgE3IiqogOxRRhkFCt1NmzTn90eSkpbsPFnteb9eeaXJs85T6PM95zs+XyGlRKFQKBQKf9GFewAKhUKhiG6UIVEoFApFQChDolAoFIqAUIZEoVAoFAGhDIlCoVAoAkIZEoVCoVAEhDIkiqhGCLFPCNErCOe9WgiR7cP+Q4UQa7Qeh0IRDShDolBEKUKIu4QQa4UQJUKI773Yf6AQYr8QolgIsUQIkeqwLVUI8blt234hxMCgDl5Ro1CGRKGIXk4CrwEvetpRCHEe8C4wBGgMlABvO+zyFlBu2zYIeMd2jELhEWVIFDUGIUQPIcQvQog8IcQRIcSbQog4h+1SCPGQEGKXEKJQCDFZCHGW7ZgCIcQnjvvbjhkrhDhhc6ENcvg+TQix1Hbcb8BZ1Y6bIYQ4aNu+QQhxhdb3K6VcLaX8BDjsxe6DgGVSyh+llEXAeOB2IUSSEKIu0B8YL6UsklKuAZZiNToKhUeUIVHUJCqAx4EGwCXAdcBD1fa5EegKXAw8BbyH9SHbAjgfGOCwbxPbuZoD9wHvCSHOsW17CzACTYH7bS9HfgcuBFKBhcCnQgiDs0ELIZ6xGT+nLx9/B644D9ho/yCl3IN1BdLe9qqQUu502H+j7RiFwiPKkChqDFLKDVLKdVJKs5RyH1ZXzlXVdntJSlkgpdwC/A2slFLulVLmA18BXartP15KWSal/AFYAdwlhNBjncFPkFIWSyn/BuZWG8t8KWWubSzTgXjgHJwgpXxRSpni6hXYb6WSRCC/2nf5QJKHbQqFR5QhUdQYhBDthRDLhRBHhRAFwAtYVxSO5Dj8XOrkc6LD51NSymKHz/uBZkBDIAY4WG2b41jGCCG2CSHybauKZCdjCSVFQL1q39UDCj1sUyg8ogyJoibxDrAdOFtKWQ8YC4gAzlffFj+w0xJrPOI4YMbqDnPcBoAtHvI0cBdQ37aqyHc1FlscpsjVK4DxO7IFuMDhmm2xrpJ22l4xQoizHfa/wHaMQuERZUgUNYkkoAAoEkKcCzyowTknCiHibMbhFuBTKWUF8BmQKYSoI4ToiDWG4jgOM1aDEyOEmMCZM/5KpJQvSCkTXb1cHSeE0NviLjGATghhEELEuth9AXCrEOIKm3GcBHwmpSy0rbo+AyYJIeoKIS4D+gLzvPsVKWo7ypAoahL/BgZidcm8D3wc4PmOAqewrkIWACOllNtt2x7G6gY7CswBZjsc9zXWeMtOrC4vI1XdYFoxBKs77h3gCtvP79s32lY0VwDYYkIjbfdxDKuxc0xEeAhIsG1bBDxoO0ah8IhQja0UCoVCEQhqRaJQKBSKgAirIRFCzBJCHBNC/O1i+9W2rJe/bK8JoR6jQqFQKNwTE+brzwHeBD50s89PUspbQjMchUKhUPhKWFckUsofseoFKRQKhSJKCfeKxBsuEUJsxJo5829nmSRCiBHACICEOgldW7VrFeIhKhQKRXSzfdP2E1LKhv4cG+mG5A+glZSySAhxM7AEOLv6TlLK97BqJtHhgg5y7sq51XdRKBQKhRt6Num53/NezonorC2bJlKR7ecvgVghRDhlJhQKhUJRjYg2JEKIJkIIYfu5B9bx5oZ3VAqFQqFwJKyuLSHEIuBqoIGtrWkGEAsgpZwJ3AE8KIQwY63avUeqCkqFQqGIKMJqSKSUAzxsfxNrerBCoVBoSwXEFsQizIHoekYfMkZiqmcCvXbnjPRgu0KhUASF2IJYGqY0JCU1BZsHvcYjpSTvZB7H845jqm/S7LwRHSNRKBSKYCHMolYZEQAhbPes8SpMGRKFQlFrqU1GxE4w7lkZEoVCofCS/Px87rnjHvLzq3cmrt0oQ6JQKBRe8uWyL1m+dDlfLf8q3ENxypqf1nBZj8tITkjm88Wfh+y6ypAoFAqFl3w4x6ov++Fcdzqz4aNFixa8+3/vctc9d4X0usqQKBQKhQtuufEWEuMSK1+/rvsVgHVr11X5/pYbfRcon5QxibfeeKvyc+b4TN5+8+2AxtuqdSvO73w+Ol1oH+0q/VehUChc8OQzT/Lrul8pLSkFoLy8vMo7QEKdBJ569imfz33fsPsYeNdARj0yCovFwuJPF/P9z9+fsV/va3pTVFh0xvcvvPQC11x3jc/XDQbKkCgUCoULrrr6Kv675L/c0e+OSmPiSEKdBBZ/sZgrr7rS53O3at2K1LRUNv65kWPHjtH5gs6kpaWdsd+q71b5NfZQogyJQqFQuOGqq6/iwwUfMmTAEIxGY+X3BoOBDxd86JcRsXPfsPuYP28+OUdzuHfovU73USsShUKhqAHk5+Wjj9Gj0+mIj4+nrKwMfYye/LzA0oBv63cbUyZOwWQ2MXvebKf7RMOKRAXbFQqFwgNzZ8+lpLiETp068fHij+nUqRMlxSUBZ2/FxcVxxdVXcHv/29HrAxe/2rB+A+3btOfzxZ/z6KhH6XZBt4DP6Q1qRaJQKBQeqJdcjxdeeoFRo0eh0+m46pqreOv1t/h5zc8BnddisfD7r78zb9E8TcbZtVtXdmbt1ORcvqAMiUKhUHjg48UfV/ms1+sZ/fhoRj8+2u9zbtu6jTv/cSe39r2Vdme3C3SIYUUZEoVCoQgDHTp24O8df4d7GJqgYiQKhUKhCAhlSBQKhUIREMqQKBQKhSIglCFRKBQKRUAoQ6JQKBQeKCoqYurzUzi3bSvqGZI4t20rpj4/haKiMyvOw0lZWRn3DryXzh06c/VlV7N/3/6QXFcZEoVCoXBDUVERN/W6hl/WvEpGRi4rV0oyMnJZ+9Or3NTrmogyJnNnzyWlfgqbtm1i1OhRjB87PiTXVYZEoVAo3PDGazOon5LFc88ZadcO9Hpo1w7GjzeSkpzFG6/N8Ou8wZCRX7FsBYOGDALgH/3/wffffY+UMqBzeoMyJAqFQuGGubPeY8AAI9VbnQsBAwYYmTv7fb/Oe9+w+1g4byFApYz83QPuPmO/3tf05pJul5zx+u6b787Y9/Chw6SnpwMQExNDcnIyubm5fo3PF1RBokKhULjh8OGTtGnjfFubNnDksH8P6mDIyDtbfYjqFjAIKEOiiCpKiktYNHM+Sxcu5tiRfBo1Tea2gf0ZMHIwderWCffwFDWQZs1SycrKpZ0TFZOsLGja7MyHv7doLSPfPL052dnZNE9vjtlsJj8/n9TUVL/H5y3KkCiihpLiEkbdPpzGadlMziynTRvIyspjwcJ5jLr9O9767ANlTBSac9/9I1i48FXGj6/q3pISFi0ycN+wf/l9bq1l5G++5WYWzFtAz4t78vniz7nq6qtCsiJRMRJF1LBo5nwap2Uz/rnyKkHPCePLaZSazaKZ88M9RK8pKS7hg+nv0bfrDVzS7GL6dr2BD6a/R0lxSbiHpqjGI489Sl5+GyZPNrBrF5jNsGsXTJ5sIC+/DY889qjf59ZaRv6+YfdxMvcknTt05s0ZbzJpyqSAz+kNIhQR/VDS4YIOcu7KueEehiII9O16A5Mz85y6GHbtgoyJKSzZ8HXoB+YjjiurgQPsKytYsDCOYyfT1coqRMQdj+Psc872at+ioiLeeG0Gc2e/z5HDuTRtlsZ9w/7FI489SmJiot9jsFgsXNbjMuYtmhdSBeBdO3ZR3rC8ync9m/TcIKX0q4GJWpEoooZjR/LdBj2PHQ2sW12oqEkrq9pCYmIizz43ju179pFfWsj2Pft49rlxARmRbVu3WQsHr7066mXklSFRRA2NmiaTleV8W1YWNGqSHNoB+cnShYsZOKDcaTrpwAHlLFu4ODwDU4QUu4z81JenhnsoAaMMiSJquG1gfxYsjKO6N1ZKWLgojlsH9g/PwHykpqysagI1zbXvDcG4Z2VIFFHDgJGDOXYynUmT46oEPSdNtsYWBowcHO4hekVNWVlFOzJGkncyr1YZEylt9xyj7T2r9F9F1FCnbh3e+uwDFs2cT8bExRw7mk+jJsncOrA/GVFUR2JdWc1jwvjyM9JJo2llFe2Y6pk4nnecEydOhHsoIUXGSEz1TJqeU2VtKRQhxp611Si1atbWwkUqa0sRPlTWluIMVJ1C5P4O7Cur9t2GkDExhRtvFGRMTKF9tyHKiCiikrCuSIQQs4BbgGNSyvOdbBfADOBmoAQYKqX8w9051Yqk5tUp+COLUtN+BwpFsInmFckc4EY3228Czra9RgDvhGBMUU8k1CkUFRTx1NCnKCoIrFeD3SDs2jCPyZl5rFwpmZyZx8718xh1+3CXq4tI+B0oFLWFsBoSKeWPwEk3u/QFPpRW1gEpQoimoRld9BIJdQo/fv0jP/zvB35a+VNA5/HXIETC70ChqC2Ee0XiiebAQYfP2bbvqiCEGCGEWC+EWJ93Mi9kg4tUIqFOYdmiZVXe/cVfgxAJvwOForYQ6em/zmQrzwjqSCnfA94Da4wk2IOKdKx1Cs41qYJVp/DwnQ/z+0+/V36OjY0FYNNvm+jZpGfl992v6M6bn77p9Xn9NQjh+B0oFLWVSF+RZAMtHD6nA4fDNJaoIRwV4EMfHYohwVD52WQyVXkHMCQYGPbYMJ/O62/xXqh+B5GaGaZQhJJINyRLgXuFlYuBfCnlkXAPKtIJpALc3wdjt8u7MX3e9CrGxBFDgoFX5r9C18u6+nQv/hoEb34HgRoBfxMBFIqaRrjTfxcBVwMNgBwgA4gFkFLOtKX/vok1s6sEGCalXO/unLU5/dcxTTbncB5J9eLR6QUF+WU0tlWABztlds3KNTz7r2cpLzstUR0XH8fU96dy+fWX+3VP/hbv2X8fyxZWrYK3G9JA7/WD6e+xa8M8xj93ZoX6pMlxtO82hOFjRvh8zwpFOAgk/VdVttcQtDACWjwYv/rvV7z09EuUlZYRGxeLqdxEfEI8T7/0NDfdcZPf9+bKIPhbC6LFvdaU/ii+otod10yiuY5EoRFa1E1okTK7dOFSjCVG2nVsx7S502jXsR3GEmNA2Vt16tZh+JgRLNnwNWsPrWPJhq8ZPmZEQA8tLe61NmaGKXeewhnKkNQQIuXBmJiUyOiM0cxdOZeeV/VkztdzeGTCI9RNrOvNbYQMLe61Nqr4qkJPhTOUIakhRMqDcdrcaQwcORCdzvpfS6/XM+jBQUybO83jsaFEi3utKf1RfEEVeiqcoQxJDUE9GH1Di3utKf1RfKE2uvMUnlGGpIagHoy+ocW91kYV39rozlN4RmVt1RC06nERjAwpT1ikBVOFiQpZgdlipsJSQYXF9rOsQCDQCR1CWN8dX/H6eOJi4tAJHUUFRUwaPYkJr08gsV5iRN6rFoQza+qD6e+xc73zplwq5Tm6Uem/DtRWQwLhfTBapIVTpafILcklz5hnfZVWfS8qL6LUVEqJucT6biqhxFRCmbns9ImMwBKgH+C8ttEpcfo4xCZB2adlpAxMIbVnKnXj6pIYl0jduLqVr8S4RJLikkg2JJNiSKl8TzGkYIj14YJhItzy+KopV81FGRIHarMhCQV5pXnsObmHA/kHOJh/sPL9cMFhyivKPZ/ABTEiBr3QY9koMS0ux3BnAgkXJqATekBiQSKlBQsWpJRYsGCRFswWEyZpk2GZA+wDWgNDfR9DfEw8Des0pElSExonNqZpYlOaJDWhSWKTyvdYfazf96gFkVAEGa0rOYV7lCFxQBkS7ThRfILtJ7az48QOdhzfwY4TOzhadNT5zkbQf6Gn4d2NSU5KITEmkcTYeiTGJJEUk0RiTBIJMXUw6BKI18dj0BmI1xuI18UTq7O6pgCmPzOFnZu3cU7njjwxdazb8b06birb/9pS+Vkfo6fCXFH5bqdZx3SuebI3pRWllFaUUmIuoshcRHFFEUWmQorMhRSZizBL932sBYKmSU1pkdyC9OR0WtSzvqcnp5NeLz0kRqa2FkEqgk8ghiTS1X8VIUJKSdapLP44/Ad/HP6DjUc3cqLkxBn7xYpY0uu0oomhKY0MTWhsaEIjQxP2rd3L/G0fcFPhbVzc3XsplDONgfW/5O6tO3mgz+mA97kXnsfjU56tcuzNd/Vl77ZdlXIsduPhaETi4uO4Z8i9nNOoo8f7L7MYySs/xZGCw6xb9gN7f9pCYW45dVL10CWO4u6lHOYwhwsP82v2r1WO16GjZUpLWtdvTbohncMrs9n85QZyc4o0jWGorClFJKIMSS1FSsmB/AOsP7SePw7/wYbDGzhVeqrKPgZ9Ai3rtLa+6lrfGxuaVq4eHPlktbUQbe2qH7n4Wu8NyZnGwFzlHazG4Oa7+55x7DkXdOThjH/z5sT/VNH2cjzu4cx/c05n90YEQAiBQZ9ACoK5L75Oi2Y5TJ9qssUAKpg338zBxc0ZMH4kBbo8cow5HC/L4ZjxKMfKjnKi7AT78vaxL2cfhvnQpQ28MAnb8XnMmTebQUs/4+GZT3J+i/NpVLcRonoxhhcoeXxFJKJcW7WMvSf3smLHCr7P+p7sguwq2+rFJnNOUgfaJ3WkfdK5NDI0cWo0wPlKosJsrny342wlUZ0dG7cGZAw2/fYn7019HVP5addUbFwsI54dTeceXdxeuzorFi0mP3s5GRNMZ8QgMifGktLiFvoMODOVutxSTo7xCF8t+pyE3D+YlGE54/hxGfBrDFiugnrx9WjfoD0dG3WkS9MuXNDkAurGea7+DyRrSmlkKdyhXFsKtxjNRr7d8y2fb/ucTUc3VX5fNyaRDvXOtxmPDjQ2NPV6lhzISqI651zQkX8984hTY/CvZx7xuKIoKSpGp9MjdGZiYmIxm03odDpKioq9uhdH1q5czdQpJqeV24MHmRg3frVTQxKni6NFnVbsX7ODqVMsTo8fNgQ2jdUjrzVQUFbA+kPrWX9oPR/++SECHR0bdeCiZhdxUbOLXBqWASMHM+r275g02XnWVIaL+hfHbK/JmeWVK6UFC+cx6vbvVLaVIiCUIanBHC08ysJNC1my5QvKLEYA4nTxXJx2Gd3TLuWsxLPRC71f59bSrQSBGYOfV/5AeVkZ6W1acvv99/DZrI/Izjrgs5sNIPdEodsYRO7xooCOLz1p4e0uMzlVfpIDJfvYW7SLnYXb2Ve8ly3HtrDl2Bbm/TUPHTo6N+3MxekX07NFT85teC46oassglw0cz4ZE6tmTWW4WVk4amTZjZxdI2vSZKtGlrtsL7WaUbhDGZIayMH8g3z454cs374cCxYAWtdtyxUNr6Vb6sUY9NrUSwS6knAkEGOQUDeB/sMHcF3fG9HpdJz72nl888VX7Nqy0+d7SmuQRFZWocsYRFpD94WO3hwvhCA1Po3U+DQurG9t9GWsMLKnaCc7C7axo3Ar+4qz+OvIX/x15C9m/j6TZEMyPdJ70DO9J5e0uIThY0b4lOa7dOFiJme61sjKmLjYrUtMrWYU7lCGJEpxNkO84h/XcqpLAd8c/AaJRCDokXopvZvcTMu6rV2ey1hq5JslK1i7cjW5JwpJa5DEpdf34rp+fVx2PKwch0Zupbj4OJq2aM7jLzxL3aREn4zBQ+OfqPJZp9fR+/Y+9L69j8djS4tLmPPKuwx94gES6tbh0ut7MW/+cjIzzoyRzF8QyyW9e7k9n7/HG/QGzkvuzHnJnQEoMRezvWArWws2sTV/M7nGE6zavYpVu1cB0LFhR65ofQVXtr6Ss1LP8uiSDCTbK9DVjKLmo7S2ohBXPSGyN37GmszVUAaXNriSiZ2mMfyshzwakRljM8nPXs7UKYWsWglTpxSSd3A5M8ZmYiw1uh1L5UqidUsemvA46a1bUl5WztpVP7o8prS4hHcmv0qpQ++K7lddwuED2Wz+/S/gtDF4aPzjXh3vLxt//YO/1m1g469/AHBdvz5kH2lM5sTYKhpcmRNjyT7SmOv6uTdOgR5vvzdRJrgotTuDWw9nSudXmdRpGve0vJdOyRcSI2LYenwr7/7+LoM+HcTdH9/N7A2zOVLougt1IBpZSvFX4QllSEJEoP3BHXHVE2LKROjaRsd1Wb25r80IGhuaeDzXN0tW0KJZDhkTTFXOlZlhIr1pDt8sWeH2eLtbaeyMyXTs0omxr02m//33YKiT4PKY6g9vsBokwK0Bcne8v1S/riHBwKMvZJLS4hbGjU/ihhsE48YnkdLiFh59IdPjCi3Q453dmxCCxoamXNP4eh5u/29e7fIuD7V7nMsaXEVSTD325+1n5u8z6begH6OWjWL17tWYKqoWVwYi6qlqVxSeUOm/IUBrfSRP1c3jxifx/Kx3vDrXuGEPMnWKc5++r+fyFnv1uiO+pA/7Uv1eHS3TloOBr/dWYTGzteBvfs1dw5+n1mOW5kqVgTueu4M7u91Ji+QWAWlkqWr62oFK/41wtPYxe5ohesosciTQLCVvcFW97oi79OFAqt+ro2XashYEem96XQydUi6kU8qFlJiL+TV3LV9/vYxT207y8X8/5uNdH9OjeQ/6dezHjE/f5dP3P/Ip2wvsqxnntSvB6lOjssSiC+XaCgFa+pi3HdtGfApu/d2eMoscsWYZaXMuV9x8V1/i4uMqPzs+tF3hmD7s6nh/a1Yezvh3lfO5um4o0PLe6sTU5ZrGvWm4tTEA9f5OJkbE8tuh3xi7aiwDvxhInV5JfPzrUtYeWseSDV8zfMwIjw/mUPepUX3how+XhkQIcZ4QYo0QIksI8bYQItlh2y+hGV7NQCsf8+aczTyw5AHKLpDM/lA49Xc7ywxyF5y2ZhnFen0uf/D08K5O9fRhrR/+9rTl2LiqIov+pC0Hihb39uq4qTzQZ3Dla8+2XQAUZxVjzjBBJpAJx98+zmu/vMYdi+7gi21fYLZ4NujgXQOvUMQAVV/4yMXdimQm8CLQHTgArBFC2B+Hkd+4IYLQoqvc5pzNPPTFKMosZVxwc3eO5DTzOjPIXXA60Cwjb3H18HaGqdzEWxOn80Cfwbw6bqrb4/19+J9OWxbExsUhdMLvavhACfTevF3V9B14J+kJLTlWfIwXfniBAR8PYPXu1VikxeMY69Stw/AxI1iy4eszVjNaryBUllj04c6QJEkpl0spT0gpXwQeB1YKIboDNStCH2QCbYO779Q+Rn3xMOWWMrqnXsy/OjzMYy9M9DozyF1GVKBZRr7g+PB2FiepTnWXjpYPf3/SlrXGWGpkxaLFjBv2IG9Pmo5eZ0Kvh5jYWJ/uzdtVzc2X9mXcec8zvO1DNIxvxIH8A4xbPY6hi4ey4dAGv+9D6xWEyhKLPlxmbQkhNgGXSykLHL67EPgUqC+lbBCaIfpGJGdt+ZMxcyjnEAMHDcR4i5ELmnTlgXajPcqaRGpm0vRnprDr7+2V1esL35rD8SM5TvcVOh2PT3mmymy8+vH26vf2nTr4nL319uRXOPv8cyur4S0VlsoCSGe1K1pjr99p0SyHwYNMlf8nZs8W7MtOQ+gSOLw/26d780W8ssJi5ucTP7Di8BLyTFbV515n9WL0JaNpnNjYp3vROqtLZYmFh0CyttytSKYB5zl+IaX8C+gNLPPnYrUVb3zMzpBS8uTrT2L820javgYMb/ugV9pYWgZwtaR6zcmkd6dxae8rz6jKjo2L5aHxj5/h0vGnZsUVD41/gt7/uBmdzvon4K4AMhi4qt95/nlJ6xa5dO7e2ed782XFptfFcGWj65jceTq3Ne9PjIhl9Z7V3LHgDpZuW4p9gulN7EPrFUSgK3hF6FF1JBHM17u+ZsKQCbAP2p5/Nk+/lOH1sYFKs4eKdd+uYeFbcygvL6uUWImLi2PgqGE+Cy6GguqSKv7iqX7nqWcMvDTv/3w6ZyArtpNlJ/j4wHz+ylsPwBWtruCxbo8xfvCTHuuftF5BqL7w4SFYKxJFGHj4zofp2aQnPZv0ZMIVE+Cg9fv927OqZObYg9CuiKTMJHdEQqzCF7SqqvdUv5N/yr00jTMCWbGlxjdgZLtHGd72IeJ1Bn7a/xMDHrubBvUPeIx9aL2C8HcFrwgfypBEGEMfHVo1wG3rGuuPWyqSMpNc4e7h5yptWUutLV/xRcrFHZ7qd+Lj8WniAIG764QQ9Ei7lImdXqJDvfPR/WlmyCCzx+ypYNSZuMsSU0QeHg2JEOJib75TaEO3y7vx8OsPg4ssWV/cUtEw23f38HM1+9dSa8sTrmo07JXn9td/nn7ep/O6q9+ZPRvKHTySoY5n1Y9LY3T7pyjLw6vYh1pBKLxZkbzt5Lu3tB5ITcTfIq2fdT/DHaCLrfrP46tbSsvgdDhwNfvXalXgDd4kLgCc1fHsM451t3JyVb8zbhz8+SdYbKUd4Ypn6YTO46rJsf5JrSBqN+7Sf3sAlwD/xprBZacecJeUsnPwh+c7kRJs91eocX/efu766C50m3TEfBmLqbw8KoLQWuAqbfkMhAApQ5bO7C5xQQiBlNKpyOK6b9cwe/pMho0Z6fTfzN4H5pdVq8k9XkhcnHUlYjci/vad14oVixaTd9B5bxVP/eEV0Uewgu11gQZYhR0bOrzKgTv9uVhtwt8irU82fwJA4uZ6mMrKw+qWCnUswmtNLtvkJ1TpzO6q8u2py9VdXa+Om+px5WRIMNBnQH+en/UO9z0+EokBSeTEs1yumjJg/7E0zTW2FNGLS0MipfxOSjkeuExKOd728wTgLSnljpCNMErxR+ahsKyQL7YuBaBpctOwu6VCGYsA3zW57ITC/VOZuFDtH9RiWz5UN3rb/9riMp7iLHAeCfGs6hMHZ6oHT4yN4dcY2N83h1+O+i+5p6U2lyL8eBMjyRRC1BNC1AG2AFlCiCc8HeQNQogbhRA7hBC7hRDPONk+VAhxXAjxl+31Ty2uGwr8KdJauXslJlnOOUkdeWLiOHr/42bKy8pZsWgx4/85isWzF3Fo705WLFrssXOhFoQyFmHHXdpynwH9wpbO7NhTvv+wAeC+sy3gW9LIPT0AACAASURBVCFoJMSznE0cHFdN7yybx7Q5s7jyzt5Y4iyMWzWO37J/8/k6St235uGNIelkk0npB6wE0oGhgV5YCKHHGrS/CegIDBBCOHsafCylvND28q1CK4z4I9S47uA6AHqkXQr43wbXX5eUtxlKrlJRtXKFuUpbLswrCFs6s+OD/vo7+vDgc49XZprZiY2Lpe+9d/ql5BvuSnvwbuKgEzruaXkv1ze5BYnkyS+fIjs/26frKHXfmoc3hiROCBED9AWWSCnLAc9yoZ7pAeyWUu61nfMj2zVqBL4WaUkp2Xh0IwDn1rM+aPxtg+uvSypQaRWtXGGu3Dy//7gubO6f6g96Y0lppTFzNGqpDdOiohAU/J84CCH4R/pddErugtFSypP/e5Licu+NuVL3rXl4Y0j+D6uMfH3gByFESyDwtnnQnMq6bQCybd9Vp78QYpMQ4r9CiBbOTiSEGCGEWC+EWJ93Mk+DoQWOr0Va+/P2k2/MJyW2PmlxDQFYu3I1gweZnP7BDR5k4pdVq51e21+XVKC9MbRyhbly88TGxYbd/WPHXUwjGgpBIbCJg07oGN72QZoYmrH31F4mfTfJrRx9UUERTw19iqKCIqXuWwPxWWtLCKEDYmyrCP8vLMSdwA1Syn/aPg8BekgpH3HYJw0oklKWCSFGYk07vtbdeSMl/RdOtwtdtrBqa1Nn7UK/2PYFL/zwAl3r92BEu9EAjLx1MKtWWlci1TGb4YYbBO8sm6e52q+3KrKRqjIcCtypB5cWl2imUhxsAtVkyzEeYcqW8ZRZjDzQ/QHu73q/0/2+/PRLJj4ykcw3M5k59TWl7huBBFVrSwjRUAjxrhBiue2rc4GB/lysGtmA4wojHTjsuIOUMldKWWb7+D7QVYPrhgxfirT2ntwLQKu6bSu/87YNrtZqv97OqCNVZTgUuItpRELg3FsC1WRrbGjKiLOsc7/3fn+fv3P+drrfskXLKt+Vum/NwxvX1hzgB04/9HcBYzS49u/A2UKINkKIOOAeYKnjDkKIpg4fbwO2aXDdiORo0VEA0uJPt3nxtg2u1q1ovU1FjbT+55FCJATOfSFQV9z5KRfQq/FNSCxkfptJqam0ivhozyY92fz7ZgA2/baJ96Z9wLpfyhk3jpD0gFcEH28MSSMp5UJsAXYppYlKKUH/kVKagYeBr7EaiE+klFuEEJOEELfZdhsthNgihNgIjEaDbLFIxW5IUuNOGxJf2uBqqfbry4w6GlSGwynyGA1oUcPSL/1Omie04GD+QWb8MuMM8VGTyVTl3WiEDRv0jHsuUWlz1QA89zuFYiFEKrb2urZWu4VaXFxK+SXwZbXvJjj8/CxQs5zrLsgptHYKTItLq/zOXhD2zZIVjBu/mtzjRaQ1TOSS3r3o/0ifM9rgnp5ZmitlVfwJ8j40vmqZkH1G3ft25/3btbpusHDMJqup8jKBYJ842OM95752XmW8x1tidXHc3/ZBXtg6ns+3fs7lN13O9HnTGTNkjNM0dUOCgVfmv0LXy6LKW61wgTcrkn9j7YjYVgjxA7AIeMT9IQpfMFWYOGU8hUBHUmzV+pLqBWHPz3qHPgP6O+2lHq7q6EioynZHOAorowmtXHHpdVrSt7lVPenln16m8yWdmfLulDNcn3HxcUx5d4oyIjUIlysSIcTFUsp1Usr1QohrgA5Y63m3BpqxpahKeYX11xmni0Mn/G8Ro8XMMpqu6wpn2WRwuj7CTk3MJgs3vZvczK+5P3Oo6CDLdywnoSABfYwenUlHbFwspnIT+hg9hQWaODUUEYK7p1alfLyUslxKuVFK+ZcyItpjtliznLzpx+6OcAV5/bluMOMWtTmbLNzohI4+zfoBMPePuXyx4AuMJUbadWzHtLnTaNexHcYSY2UWl5Yo/a7woTokRgBaGZJoIpiCkCqbLLx0qd+dpobmHC06SpEoYnTGaOaunEvPq3oy5+s5PDLhEeom1tX0mkq/K7y4MyRthRBLXb1CNsJaQHVDUhuyjIIdt4iGbLKaiuOqpKh/EXeNuKtytarX6xn04CCmzZ3m7hQ+o/S7wou7rK3jwPRQDaQ2E6Oz/jNUSGtWdU3MMgpH3CLSs8lqMl1Te7L00H85UniEtQfWcmXrK4N6vaULFzM507V+V8bExaoJVxBxtyIplFL+4OoVshHWAhLjrBXqpRUlSCkjLstIixVSOOIWkZ5NVpPRCR1XNroOgM+2fBb06yn9rvDibkWyL1SDiGTsellLFy7m2JF8GjVN5jYXeln+MmbAGPgJzJgZyZCIyzLSYoVkj1sEouvkK5GWTVbbuKTBFXye/Qm/HFzHoYJDNK/nTJNVG6xtG5zrd7lq26DQDncdEm8P5UAikVAF8IY+OhQcXPmRlmWk1Qop1HGLaJMqqWkkxiTRPfViQLJk65KgXkvpd4UXlbXlBl8CeIGkHna7vBuNH2hcxZg4Euoso0AbXLkjWiTWaztaJXzY3Vsrdq6gwhKwspJLfG3boNAWZUjc4G0DHi1WLm27tIU7QB9bNQU4HFlGwYxnqLhFdKBVenbbuu1Ii2tIbkkum3I2eX2crxOzOnXr8NZnH9C+2xAyJqYo/a4Q45UhEULcLoR4RQgxXQjxj2APKlLwNoCnReph83rNwQhCJ8I+Ww9mHUY0SazXZrRyZwoh6JraA4Bv93zr1TH+Tsx8adug0BZv+pG8DYwENgN/Aw8IId4K9sAiAW/7rmvROrR5vebwJ5jLzRExWw9WPEPFLSKTYLozL6pvNSTf7f3ObRdFO6omJPrwZkVyFdZOhrOllLOBm4GrgzqqCMHbAJ4WqYfN6zWHeGh8W9OIma2reEbtIZjuzNZ125Ial8bxkuMuG185onq6Rx/eGJIdQEuHzy0A752dUYy3ATxvVy7uaFO/DQyAsh7GkM3WPQVUVTyj9hBMd6YQgs4pFwHwW/ZvHvdXNSHRhzeGJA3YJoT4XgjxPbAVaFgbpFK8DeBpkXqYnpxOndg65JlOkW/K82u8vmbaeAqoqnhG7SKY6dnn1rMeu+HQBo/7ajExU4QWbxpbTfC8S83FHsBzJ68wYORgRt3+HZMmZzNwQDlt2lj/wy9cZF25ZHiReqgTOs5pcA5/HvmTA8VZdErp4vNYfS0cdAyoOtvf1wZXiugnWLIy7ZOsXSg2Ht2I0WzEEHNmPx071onZPCaMr+reUjUhkYtHQ6LkUDxjX7ksmjmfjImLOXY0n0ZNkrl1YH8yfKiAP7/x+fx55E/2FO3yy5B4MgyqT4fCE5XuzDYtuf3+e/hs1kdkZx1w+X/KW+rGJNKyTisOlOxj89HNdE/v7nJfLSZmitDirrHVGinl5UKIQmxtdu2bACmlrBf00UUR3qxcPHFBkwuYxzy2F2z1an9fDcPNd/Vl77ZdlRIl4aygLy0uYc4r7zL0iQdIUOmZEUMwZWXOTjqXAyX72Hh0o1tDotXETBE6XBoSKeXltvek0A2ndtO1eVf0Qk9W8R6KTIUkxrr/1ftqGMKhd+WKmqhwXBPwxp3p7ySgZZ3WAOzK3eVxXy0mZorQ4W1Bol4I0UwI0dL+CvbAaiN1YuvQtXlXQPJ3/kaP+/uTaRMpfToiTeFY4T3+Vr03r9MCgKxTLiLpiqjFY4xECPEIkAHkAPZqIgl0DuK4ai2XtryU37J/4+/8jVzcwPNM3W4Y3pv6OqZyU+X37gxDOPp0qPhMzcFTLM4VjQ1NAcHBvIOYK8zE6L3J9VFEA978Sz4KnCOlzA32YBRwWcvLeG3ta2zO+wuzxVzZ9ModvhqGYAVU3RFJ8RmFb2g1CYjTxdEgvgEnyo6TXZBN6/qtgzZmRWjxxrV1EFAVQCGiZUpL2tZvi9FSyraCzV4d42vhYDjqQ1Qf9ehFy6r31LgGABwrPqbxKBXhxF3Wlj3qthf4XgixAiizb5dSvhLksdVarm93PTN/n8lvub94lQbsa6ZNuOpD/HHDKcKPlkkaKbH1AThRckLzcSrCh7sVSZLtdQBYBcQ5fKcyuYJI73a9Afjz1HrKK8o87B1dQohKvys60SpJIzk2BYATxZFvSALpMVTbcJf+OzGUA1GcJj05nfManceWY1vYlP8n3VIvDveQNCMc8RmFNmiRpJEcZzUkx4uPB2uYVfC3VbZdyr5xWjaTM+1FkXksWDiPUbd/p3qcVMMbGflVQogUh8/1hRBfB3dYihvOvgGAtSdqVnqs0u+KXrQQ8UyKsdYx5xn905PzhUAazikpe9/wJtjeUEpZ+a8upTwFNArekBQAN559I3oRw5b8zZwoC83sLRREkxtOURUtJgEGvXXfUnNpsIZZSSDGQEnZ+4Y3hqTCsQBRCNGKqpIpiiCQbEimd7tegOTn49+HezgKhSaTgHh9PAClpuAbkkCMgZKy9w1vDMk4YI0QYp4QYh7wI6AqxnzEn8Bdvw79APj5xA9UyIqQjNNXKXp/j1HUTgw6q+pvKAxJIMZASdn7hkdDIqX8H3AR8LHt1VVKqWIkPuCvr/bCphfSKqUV+aY8Np7y3MdBC/yRv/BXMkNR+4jTWVckJabgTzoCMQZa9BiqTXiltQVcirW97tVAzUkhChH++mqFENxx3h0AfL1vRUhm/f5oYCndrMgkEleKwuZnkiHwjgdiDLztjqqw4o3W1otAd2CB7atHhRCXSSmVe8tLli5czORM177ajImLXaqc3nLuLbz5y1vs+2MPrENztVx/5C+UblZ0EIkKy9L2VBcID3v6jz3l94sF/+XYkXL6rodrr4Xhw+HoUe/6migpe9/wZkVyM9BbSjlLSjkLuBFQLfJ8IBBfbZ3YOtzZ6Q740/pZ61m/P/IXgUhmROIsuaYSySvFYBkSRzfy8xPzWbUKXnkFjh+Hu+6C8RnJZ7TKdoVdyn7Jhq9Ze2gdSzZ8zfAxI5QRcYK38pspwEnbz5pFmYQQNwIzAD3wf1LKF6ttjwc+BLoCucDdUsp9Wl0/VFh9tXm0a3fmNle+2ofvfJjff/r99Bd669vurTs0nfX7I38RiGRGJM6SawrRsFK0u7RE9eW5Rji6ke2XaNcOnn/e6pZq3+0O1eMkCHizIpkK/CmEmCOEmAtsAF4I9MJCCD3wFnAT0BEYIISo/uQZDpySUrYDXgVeCvS64cAfX+3QR4diSHDoa21L2qown87e0kot1x/5C38lMyJ5lhztaCmu6ApjqZEVixYzbtiDjLx1MOOGPciKRYsxlhq9Ot5ssWqseaNq7Q+q/iM8uP3XFNZpwxqsAfbuWNvsPi2lPKrBtXsAu6WUe23X+gjoCzj2me0LZNp+/i/wphBCSFn9kRzZ+NODutvl3Zg+bzpjhoxx+keqtVquP/IX3hwTDbPkmkKwO2AaS43MGJtJi2Y5TJ1isv0/LmTe/OXMGPs7j76QWXXy44RSizXtNzEu0a8xeELVf4QHtysS2wN7iZTyiJRyqZTyC42MCEBzrBL1drJt3zndR0ppxipnn1b9REKIEUKI9UKI9Xkngy+94Cv2wF37bkPImJjCjTcKMiamePTVdru8G1PenXKG9LqIEfzz6VGaquX6I3/hzTGhmCUrThPMDpjfLFlBi2Y5ZEwwVck+zMwwkd40h2+WrPB4DntFe924un6Pwx2q/iM8eOPaWieE6B6EaztzklZfaXizD1LK96SU3aSU3VJSU5wcEn78DdwVFhSij9Gj0+mIN8SDAKmTbD76l6bj80f+wn7MEy+OI2v7TkqLTgKSQ3t3Vro7VB+S0BMsheW1K1czeJDJqdto8CATv6xa7fEcxiCvSFT9R3jwxpBcA/wihNgjhNgkhNgshNikwbWzgRYOn9OBw672EULEYA30n6QWYK+E/88zkzGWlJKQAL1uu4ZGbRtBOfy86kdKzdplPvkjf/HQ+Ce44sZreeO5SeRnL2fqlEJWrYJXXzWTd3A5M8ZmVhqTSOgTX1vQQlzRGbknCt26jXKPF3k8R4nZasyCtSJR9R/hwZuI101BuvbvwNlCiDbAIeAeYGC1fZYC9wG/AHcA30ZLfMRf+Wr7sXYJ61dfrbD5oi0sWPgtaYnNoW8jjm0/xtLDi7m75ZAQ3ZFzHN0djlkymRkmMida3R19BvQPS5/42oqvjc68Ja1BEllZhS6zD9Mael5l5JlOAdCgTgOfr+/N35Sq/wgP3qxImgInpZT7pZT7sa4ImgR6YVvM42Hga2Ab8ImUcosQYpIQ4jbbbh8AaUKI3cATwDOBXjcUBCJfDe4r4RunHuKK9EsRAwTf5azkQPG+0NyUC7x1dwRrlqw4k2ApLF96fS/mzY916jaavyCWS3r38niOvHKrIWlU1zcBcV/+plT9R+jxxpC8AziuWYtt3wWMlPJLKWV7KeVZUsoptu8mSCmX2n42SinvlFK2k1L2sGd4RTqB9jLwlMK4dsn33N3pbiSShftnY5GWIN6Ne7x1d6g+JNHPdf36kH2kMZkTY6u4jTInxpJ9pDHX9fNcp2xfkTRK9M2QqP4gkY03hqRKuq2U0oL3hYy1kkBz2b1JYfxX93+RqE8iq3gPPx3/TqOR+47V3eF8m6O7Q/UhiX4MCQYefSGTlBa3MG58EjfcIBg3PomUFrd4lfoLcKrcGuJsWLehT9dW9SGRjTcGYa8QYjSnVyEPAVGxMggXgeaye1MJnxiXyNhrn2XsqrH89+BCOiVfQGq8c7+zsdTIN0tWsHblanJPFJLWIIlLr+/Fdf36ePXH7w6ru2M5mRlV3Vu+uDsU0YMhwUCfAf3pM8Ca/VRaXMKcV95FWjyvis0WM7llJwBB48TGPl1X1YdENt6sSEZiVf89hDWLqiegNAbcEGguu7cpjNe2vZar21xNuaWMefs+cOrisheRVWZVrYSpUwqrZFUFghbuDkX04ksLgWNlOUgsNEtqiiHGtwmMqg+JbLzpR3JMSnmPlLKRlLKxlHKglPJYKAYXrQSay+5tCqMQgqeueAqDLoGtBZtZefTMgjAtisjcoYW7IxJQYpL+4YvkzaESa/1x29S2Pl9H1YdENsJVNq0Q4ikp5ctCiDdwXgQ4OtiD84cOF3SQc1fODesY7BkmjVKdS6J4ozxqT3VctrBqCqOz9OE1+9cw5qsxCHSMOXcsZyedW7lt3LAHmTrFecrmrl0wbnwSz8/SJHciqln37RpmT5/JsDEjlZikG5xJ3lSYzZXvdpxJ3iw++BErjy5neNfhjOjum1NDi78phXt6Num5QUrZzZ9j3a1Ittne12MVaqz+UrjAX0mU6ufwNoXx8laXM+TCIUgsvLPrNU6V51Zu06KILNLRYjVR08UktVpxBSJ5k1W8G4ywbto6igp8+3+nxd+UIni4DLZLKZfZ3sM7vY9S7IYgVJLVI3uMZNvxbaw/tJ6Zu2fw73OfI1YXp0kRmTvswdahTzxAQpj+mP2Rpq9tYpJayff7KwxZVmFkT+Eu2AFbftzCTyt/4qY7fKt1DvXflMJ7XK5IhBBL3b1COUiFZ2J0MUzpNYWmSU3ZV7yXBftmI6XUpIjMHd4GW4MZg/BnNVHbxCS1XHH5I3mzu2gnFiqo87d1srFs0bKAx6GIHNyl/16CVXl3EfArzgUUFQEQiIyKM1ISUnj5hpe5f/H9/JL7Ey3rtua6fn2YMfZ3MifmMHiQqdK3PH+BNauq/yOBZVU5PqDczXS1bGilxWoi2JLr4SbYKy5vJW+qj8MYY80S3PTbJno26Vn5ffcruvPmp2/6Pg6N/4YU/uEuRtIEGAucj7WLYW/ghJTyBynlD6EYXE0mUBkVV7Rv0J7M6zIB+OTAAvaU79Q0q+rVcVN5oM/gyteebbuA0w8o++vVcVOrHKfljFir1USkiEkGY7UW7BWXt5I31cdhMVtT1E0mU+V3hgQDwx4b5vMYgvU3pPAdl4ZESlkhpfyflPI+rI2tdgPfCyEeCdnoajDBlHzo1a4Xwy4ahsTCzN0zOCGP0WdAf56f9Q7vLJvH87Peoc+A/n6l5nr7gCopLPbL4HiDltL0wZJc9wVfajG8Jdjy/Ql1E7htcH9SG6bRpv1ZLiVvzrmgI4OfHQ6xzs9jSDDwyvxX6HpZV5/HoGRTIge3dSRCiHghxO3AfGAU8DrwWSgGVtMJtuTDiO4j6HVWL8otZbyy/QVyjEcCOp8dbx9QdwwfGNQZsVariUgQkwxWxlgwV1wPjX+C1EYN2PjrH2z89Q+3kjd56afgDtDFVn3cxMXHMeXdKX4ZEVCyKZGEyxiJrT/7+cBXwEQp5d8hG1UU463PNtiSDzqhY8I1E8gz5rH+0HqmbZvM0x0yaGhwLU3hrZSK/QH13tTXMZWfdlFUf0AFOwahhTR9sCTX3RHKjLFgyvd7Gx/749RvYISYmBjMFWZi42IxlZvQx+gpLCj0+/pKNiVycLciGQK0Bx4F1gohCmyvQiFEQWiGF1344rMNheRDfEw8/7nxP3Rp2oVCcwEvb5vEcWPOGfuVFpfwZuZ/ePXZCV5LqXjjEgp0RuwpdqDFaiIcYpKhzBjTcsXlT3zsRNlx9hXvRfwpMBlNtOvYjmlzp9GuYzuMJcaAsreUbErk4C5GopNSJtle9RxeSVLKeqEcZLTgi882VJIPCbEJvHLzK3Ru0pkCcz4vbsvkaGnVRpQbf/2DLRv+okVT76VUvH1ABRKD8BQ7iFZp+lC2H9byd+SPAfzlxE8ANEhtwOiM0cxdOZeeV/VkztdzeGTCI9RN9L9TopJNiRxcSqREK+GUSOnb9QYmZzpX7d21CzImprBkw9dA6CUfisuL+fdX/+aPI39QR1+XJ84dS4s6rQCY/swUDuzaxhtv4LWUytuTX+Hs88+tdAlZKiyVLiHH2fz0Z6aw6+/tpLdpye3338Nnsz4iO+sA7Tt14ImpY92OefozU9i5eRvndO7ocd9oZNNvfzp1D454djSde3QJ48hcs2PjVq/dlRWygrEbHyPPdIq3bn2Lbs39Ut9wiZJN0ZZAJFJUXxEN8cVnG+yWoM5iNTff0xddGx3rp6/n+axxlfvqY2KwVOCTlMpD45+o8tnuEup9e9W6FF9iELWt2jwa2w97Gx8D+DvvL/JMp2iZ3JKuzfwLqLtDtdWNHJQh0RBv+og4EizJB8ee75Mz7TO1PBYsXETx6uac1+88try5BWzPgQqzGYPBOkatpVS8NThgdZ3s3barcrZbG6rNy8vKzliteQpehxtvDeCPx78FoF/HfojqqVUaoWRTIgNv+pEovCRSfLaeer5foutB1ye7VsntLy+HWbMImpSKN4QydhAJRGuMx5v4WI7xCH/nb0IvYujTXvWkqekoQ6Ih3vYRCTae8utXfPQ5bzz8Blc9eVXlmtRigT//hHHjCGuDqkipNg8F0dp+2BsD+L8jywBJn3NuJiUhJXyDVYQE5drSkEjx2XoTq9Hr9FzT7Bp+if2F8opy0IPRCOs36Nm2I5aCvDLSGiZySe9e9H8k8Ja8vhCNsYPahCd35Ymy46w7sQaB4L4u94VjiIoQowyJxkSCz9bbWM3ShUsxGU20OqcVhVcWcnLpSUw5FSQ2SeeleVNCPOrTRGvsQGHl6yPLsWDhxrNvJD05PdzDUYQA5dqqgXgbq0lMSmR0xmg++vYjPhr7ET0n94TekF2xn/8dWeq0B3wwMZYaWbFoMYezdgKS0qKTZG3fyRNTx0VF7EABOcaj/Hzie9BwNVJSXMIH09+jb9cbuKTZxfTtegMfTH9PiTJGEKqOpAbib359haWC935/jzl/zgGgXeI53NvmXzQ2NAn6mI2lRmaMzaRFs6py9/PmW2M0Dzz3FIvenhvWBloK91RYzLy8fRL7ivfSp30fJlw7IeBzOmYgOv5fXrBQ1YpoTbBa7SqiFH/bkup1eh7s+SDTb5pOXX0iu4t2MOnvZ1l19Mugr06+WbKCFs1cV9Z//O5cTRRyg9lgq7az7PBn7CveS5PEJjx+mTYJA0rhNzpQhqSG4kvP9+pc3upyPh/yGTeefSNmaeK/BxcybdvkM6RVtGTtytUMHmRymmk2eJCJHRv/su4XoEJuMCTb3VFbDNfOwu18dWQZAkHmdZkkxSdpcl6l8BsdqGB7BBOq7m+urvP0yKfp3a43Gasy2Vu8i0lbxnJb8/70bnwTep22/3VyTxS6zTQrKa4AAq9y91axViu07AzpC94qOWtBibmYWXvfASRDLxpGl6baybsohd/oQBmSCMV1dfo8Rt3+nWa+YW+us2TI57y29jWW71jO59kf81vuWu5oMZCOyZ00uFMraQ2SyMoqdJlpFh9vTU/2tco93LIroTZcUDXeNHWKPd5UyLz5y5kx9ne/OmO6wiItfLD3bU6V59KxYUf+2fWfmpzXjq9qEYrwoFxbEUqofMPeXCcpPonx14xnRp8ZNK/XnEOlB5mx8yVm7HiJgyX7NRnHpdf3Yt78WKeZZrNnWyvvHfG2yj2Uku3gfytiLfEUb6qu5BwIiw8u4u/8jSTo6/B87+eJ0Ws7N40UtQiFe5QhiVBC5Rv25ToXt7iYRXct4uGeDxOvM7C1YDPPb3mOOXvf5VR5bkDjuK5fH7KPNCZzYmyVyvpx46wV97GxYCsA96nKPdSyK6E2XM7wFG/6ZdVqTa7z8/EfWJ3zFTp0vNJnOs3rNdfkvI5EilqEwj3KkEQoofIN+3qd+Jh4hnQZwrJ7l3JPp3vQoeOX3J94btMYPs/+mFKzf0FlQ4KBR1/IJKXFLYx9Lonrr4cxY6BRI/j0U3jzTejZEwwGEEL4VOUeStmVSNAL8xRvqq7k7A+7C3cwf98sAJ6+8mkuanZRwOd0hr8ZiIrQogxJhBKq7m/+XifZkMzjlz3OpwM+oddZvTBLM/87soxnNj7KkuxPyTfl+TwWQ4KBPgP6c+n1vbjyqli++AIeewwSE62umSlT4KKLBBVm3zv8BdJgy1fCrRdmjTc53xaIkrOdbQV/8/rOaVio4O5Od9OvY7+AzueJQDIQo+awwwAAFGNJREFUFaFBGZIIJVS+4UCvk56czpTeU/jgHx/QpWkXjJZSvjryBc9ufJQPs97ncGm2z2Ny55oZOlSSmBTvc5W7li1nvSGUhqs67uJNgSg5Syn5NmclM3a8TJnFyNVtrmb0JaM1GLEi2lGGJEIJlW9Yq+uc3/h8Zvadyfv93ufqNldTIS38fOIHJv79DG/snMb2gi14q6LgyTVTWFDus0JuqCXbQ224HHEVbwpEydlsMTN//yw+PvAhEgv3dbmPF3q/QIzGaeCK6CQsEilCiFTgY6A1sA+4S0p5ysl+FcBm28cDUsrbPJ27Jkmk2Os7li2sqiQcrDoSLa9zMP8gizYt4outSzFLawet9ISWXNnoWnqkXUqC3vV5xw17kKlTnKcCO2v7GypKi0uY88q7Xsm0eNuKOFjY60h+WbWa3ONFlUrO1etIvLmnAlM+7+6ewe6incSIGCZcO4Ebzr4h6PegCC2BSKSEy5C8DJyUUr4ohHgGqC+lfNrJfkVSSp8cujXJkNQE8o35LN6ymPl/LKC4whrkjRVx9GxwGZc2uJK2ddud0T1vxaLF5B1cTmZGVfeWlNZZdUqLW+gzIPRpn+u+XcPs6TMZNmZk1KgQezIUnu7pQHEW7+x+jZPluSTGJPHGba/TsZHrGE9RQRGTRk9iwusTSKznfywmVMW4itNEo9ZWX8D+tJ8LBDdapwgbyYZk7u96P/+7/ysm95rMRc0uwiTLWXP8O17eNpEJm59kxeElnCg7VnlMMFwzWuBYXBgteJKEcXVPZRVGlh36jKlbMzlZnst5jc7j4wEfuTUiAD9+/SM//O8Hflr5k99jthfJ7towj8mZeaxcKZmcmcfO9fMYdftwpfobgYRrRZInpUxx+HxKSlnfyX5m4C/ADLwopVzi4nwjgBEATdKbdP1i/RfBGbhCE/ad2sfS7Uv5367/kVtyuv6kZZ3WdE3twUX1e1BPpnjlmgkmzqriK8zmync7waqK14Lpz0xh5+ZtnNO5I09MHev1Penb6qm41ypL0/+8/jx6yaPEx8R7vN6Dtz/IH2v/oOtlXXl78dt+jfmD6e+xa8M8xj9XfsaKdNLkONp3G6J6tAeBiHRtCSFWA870x8cBc700JM2klIeFEG2Bb4HrpJR73F1XubaiB7PFzG/Zv/HVzq/4fs/3lMvT5est6rTiovo9uKh+d5okNAvL+HZs3MqbE/9DeVm5y33C0UfenbvKW0PhllhgIHTo0YHRl4x2WyPy8J0P8/tPv58+NDYWk8lU+W6n+xXdefPTN12ex9GVlXM4j7Q0uPVWuPNOSHDIh9i1CzImprBkw9fe3YvCawIxJEFLuZBSuswxFELkCCGaSimPCCGaAsec7SelPGx73yuE+B7oArg1JIroIUYXw6UtL+XSlpdivNrIrwd/5du93/Ltnu84WLKfgyX7+eLQpzQ2NOX85AvolHIh7RLPIVYX6/nkGmAvLnRlTMJhRMC9EOTNd/Vl77ZdleN1VlkfE2v9szebnBiWWEgdnspjgx6jd7ve6IR77/fQR4eyef1mjKVGgErj4WhEDAkGhj02zOU5nOu9wfz58MQT8Morp42JEmqMTMLl2poG5DoE21OllE9V26c+UCKlLBNCNAB+AfpKKbe6O7dakUQ/5RXl/Jb9G9/s+YZvdn9LmcVYuS1GxNI+6VzOrXceHeqdR3qdVpQby4OqdLvptz95b+rrmMpN6HQQFwdlZZBcP4Erb74xKO42d+q9b02cXsVdVR13Kym78SssKWDWi+9QYao4vTEGbhl/C08Nf8orN5ad9WvWM2bImEpj4oghwcAr81+h62VdXR7vzpU1cSK0bQv33mv9Tq1IgkdEurbcXlSINOAToCVwALhTSnlSCNENGCml/KcQ4lLgXcCCNSngNSnlB57OrQxJzcJsMbM5ZzNrD6xl7f617D65u8r22PJYEhbq6NzKxH2DLWd0VtRC6Xbdt2tY8OZsdKKMiy6CYcNweR1fUoRd4apb5KxZVt2xcpMeS0WF21iNo/Gr/F3FxXLj6NvIaXmEDd//SsXyCjABehAWgcFg4OmXn+amO27yecxrVq7h2X89W8V4xcXHMfX9qVx+vfsMt75db2BypnOF3127YMIEWLRIxUiCTdRlbUkpc6WU10kpz7a9n7R9v15K+U/bz2ullJ2klBfY3j0aEUXNI0YXQ5emXRjVcxQL7lrAl/d+yaTrJnHrubfSLKkZFb+YOK9lGZMyLGco3TZrcoTPPlmA2eJlbMAFP6/8gQpzGRd1FTz/PG4VdbVonOVKvXfKFOjSBZDWVYQ7IUjHyvqYuBgQYMLEsj2L+e3IWuT3FRh0IIC0+nVo0Kg+pSWlLFu0zK8xFxYUoo/Ro9PpiDfEo9Pp0MfoKSwo9HisR723Y0qoMdJRle2KqCKtTho3nH0Dz139HJ8P+pwGO+px/xCcyqncO7iCX7/5jtF/DGfKlvHM2/cBPxz7hr1Fu30Sl0yom0BiUjzDhkqPirpapAi7k4gZNszqWnPEMVZjkRYOFO9j2fLPKCszIhtJzHeboTFQDnEb42i6uD6XdBS88QasWgUvvlBCxw5FNGuRisHg3+pt6cKlGEuMtOvYjmlzp9GuYzuMJUavDJMnvbe4OJRQY4Sj9A0UUc2Jo+7lVMpOgZQVHCjJ4kBJ1adVSmx9miQ0o3F8ExoZmtLY0Ji0+IakxqVh0J9OFXpo/BOMvHWw2+ucOFbIA30Ga9I4y5NETFnZ6c8xsTFc9VAvdqRt5dtdK9lVtJ1is03dtzdwMbRr2I5ut3WjYm0F65f/Suv0o4x/7rRRbNcOMsaXM2lyEe0vOterMVYnMSmR0RmjuWfEPeh0Orpd3o2P3vuIv9b95fFYq97bPCaMPzNGsnBRHPc+olxZkY4yJIqgEuwKZU8d9Jo0TWH+/YvZdWIX209sZ/vx7ew5uYesk1nkmU6RZzrFdraccWyCvg7141JtrzSSUuPIyir3uoNjIP1HvOoWWQGYwSzMrNr3JTiINDdJbEKPiT3ont6dbs27kZqQat1wBfT95Aa3/WcyJi7266E9be60Kp/1ej2DHhzEoAcHeTx2wMjBjLr9OyZNzmbggNNZWwsXWV1ZGcqVFfEoQ6IIGqFoF+xpNnvrwP4kxiXSpVkXujQ73Uu8wlLB0aKjZJ3K4mD+QQ7mH+RwwWEOFRwipziHUnMJpaUllerFuk4w60OYMpEzrjP7Qyh3SH5yRBer46wH2rM28UfW7v0RwemDLVgoqyijzGKk3FJW+XNxp3LX15oN5XFYtSFWATmQsj2FfkP70bp+a85rdB4tklucITtjJxJ7oNt7jiyaOZ+MiVX13jKUJEpUEJasrWCisrYih1BUKNuNVaNU57NZf4yVlJKCsgJyinI4VnyMnKL/b+/Og6QozziOf38cSsilSERREjXBC03FC4QkBskhigXBaBIq5VVYliZojtKUKS8ifyRWxSRaxoOIkUBEE4yKESOKB0kEDYpcEgUxVlYpFKNEUZfDJ390Lzsss7u9Ozs9x/4+VVPTM939zjvv9O7T/Xb3866n4fUGHrrsPg4cuGmHq8N+NwOW/BveHwbcQ5KDoUkv4DTgoA5+qUboMxOO2A/OPr35CrHbpsO/1vblgukXc8igQxj44YHMnjabZxc9u9MRQWvau0LKl9Z2XzV3+W85OZBUj7z+aVUyS/KYCeM5+axxPPrAo9x85c00vt9Ir9692LplK7137c2YH43h8K8dDrBTGv0e6kGf3n3o27svfXrt+NxjSw/unja7y7/TtGum8sLi4kdwvrS2e3MgKeBAUj2GDzyWefOCnj13nrd1K4weLZ54ZVH+FSuD8085nyULlzB4yGAmXT6J66dcz+qVqzlyxJGdzjlVDuU4grP6UJUpUszaOxHeVcMFV4NSrlrKk89HWDn4iMTKxt0oZrWj5u5st+4hr+GCzayy3LVlZeNuFLPuwV1bZlaUh7vtXnyy3cy6VB43k1r98DkSs9S7m95l2jVTGXfUCQwfeCzjjjqBaddM7ZZjhM+6aSYD9mjg8ss275CB+IrLN7NnvwZm3TSz0lW0KuJAYkbzHvjqp2cwZfJbzJsXTJn8Fi8snsH3TpnY5cGk2oPWnNvvajMn132331WZillVciAxI9898LyDVmdUY04uq14OJGbkuwdeC91G7Y0RUk83k1rpHEjMyHcPvBa6jZKsyrvQ8qLOwqzKZk0cSMzIdw+8FrqNfDOpdYQDiRn57oHXQrdR082kBx59Olf+dDdGj5aHu7VW+YZEM/LNiuscZFaNnGvLrER57oG728jqjY9IzCogr8G4zLLywFYFHEjMzDrOXVtmZlYxDiRmZlYSBxIzMyuJA4mZmZXEgcTMzEriQGJmZiVxIDEzs5I4kJiZWUkcSMzMrCQOJGZmVhIHEjMzK0lFAomk0yStlPSBpFZzu0gaLel5SWskXZJnHc3MLJtKHZGsAE4BFrS2gKSewG+AE4FDgQmSDs2nemZmllWvSnxoRKwCUMtBq3c0FFgTEWvTZe8AxgHPlb2CZmaWWUUCSUb7AP8peN0ADCu2oKRzgaYh5RqH7TVsRZnrViv6AxsqXYkq4bZo5rZo5rZodlBnVyxbIJH0MLBXkVmXRsS9WYoo8l7RwVMiYiowNf3cxZ3NqV9v3BbN3BbN3BbN3BbNJC3u7LplCyQR8ZUSi2gABhW83hd4tcQyzcysi1Xz5b//BAZL2l/SLsC3gTkVrpOZmbVQqct/x0tqAIYD90t6MH1/oKS5ABGxFZgEPAisAv4YESszFD+1TNWuRW6LZm6LZm6LZm6LZp1ui7obs93MzPJVzV1bZmZWAxxIzMysJDUfSJxupZmkfpIekrQ6fd69leW2SXo2fdTVBQzt/c6SdpV0Zzr/SUn75V/LfGRoi7MkvV6wLZxTiXqWm6RbJb0mqej9ZUpcl7bTMklH5l3HvGRoi5GSNhZsE1dkKbfmAwlOt1LoEmB+RAwG5qevi3kvIj6XPsbmV73yyvg7TwTejIjPAL8Crs63lvnowDZ/Z8G2cEuulczPbcDoNuafCAxOH+cCN+ZQp0q5jbbbAuBvBdvEVVkKrflAEhGrIuL5dhbbnm4lIjYDTelW6s04YHo6PR34egXrUglZfufCNpoNfFnt5OqpUd1lm29XRCwA/tvGIuOA30diEbCbpL3zqV2+MrRFp9R8IMmoWLqVfSpUl3IaEBHrANLnPVtZro+kxZIWSaqnYJPld96+THqJ+UZgj1xql6+s2/w30u6c2ZIGFZnfHXSX/w9ZDZe0VNIDkoZkWaGac21tl2e6lWrXVlt0oJhPRsSrkg4AHpG0PCJe7JoaVlSW37lutoV2ZPme9wGzIqJR0nkkR2qjyl6z6tNdtoksngE+FRHvSDoJuIeky69NNRFInG6lWVttIWm9pL0jYl16aP5aK2W8mj6vlfQYcARQD4Eky+/ctEyDpF7AxynDoX4VaLctIuKNgpe/pU7PF2VQN/8fShUR/yuYnivpBkn9I6LNxJbdpWuru6RbmQOcmU6fCex0tCZpd0m7ptP9gc9TP6n5s/zOhW10KvBI1Oddue22RYvzAGNJMkh0R3OAM9Krt44FNjZ1EXc3kvZqOmcoaShJjHij7bWAiKjpBzCeZI+iEVgPPJi+PxCYW7DcScALJHvel1a63mVqiz1IrtZanT73S98/GrglnR4BLAeWps8TK13vLm6DnX5n4CpgbDrdB/gTsAZ4Cjig0nWuYFv8DFiZbguPAgdXus5laodZwDpgS/q/YiJwHnBeOl8kV7i9mP5NHF3pOlewLSYVbBOLgBFZynWKFDMzK0l36doyM7MycSAxM7OSOJCYmVlJHEjMzKwkDiRmZlYSBxKrK5JC0oyC173SDLd/SV+PLWf2Z0mTJV3UyrwnOlDO3Wn21TUtsrGO6GB9RqX3RhSbN0TSQkmNkn7QkXLNCtXEne1mHbAJOEzShyLiPeCrwCtNMyNiDhlvRk1vzFJEfNAVFYuIzEEgIsandRgJXBQRJ3fyY0cBG0juCWhpA3AByY2ZZp3mIxKrRw8AY9LpCSQ3YQHbx+C4Pp0ekO75L00fIyTtJ2mVpBtI8g4NkjRB0nJJKyRdXVDWaEnPpOvOL/j8QyU9JmmtpAsLln8nfR4paUH62c9JuklS5r9FScdIelzS02livQHp+z9My1sqaaakTwPnABcXO5qJiPURsRjYmvWzzYrxEYnVozuAK9LurM8CtwJfLLLcdcDjETE+Hb/jI8DuwEHA2RHxXUkDSXJQHQW8CcxLMyb/gyQ/1XER8ZKkfgXlHgwcD3wUeF7SjRGxpcVnDyUZJ+Rl4K8kY+rMbu+LpeltriW5O32DpO8AU0jG0fgxScK9zZJ2i4i3JN0CbIiIX7dXtllnOZBY3YmIZUpGPpwAzG1j0VHAGek624CNSkaVfDmScSkAjgEei4jXAST9ATgO2AYsiIiX0vULEz/eHxGNQKOk14ABJOkoCj0VEWvTMmcBXyBDIAEOAYYAD6cpkXoWlL0SmCnpXpKsrWa5cCCxejUH+AUwko6PN7KpYLq1Qa9E66nGGwumt1H876zlullzFQlYFhHFjrBOAL5EMlDTZZIOy1imWUl8jsTq1a3AVRGxvI1l5gPnQzI0raSPFVnmSeBLkvqn3V8TgMeBhen7+6fr9yuybluGppl5ewDfAv6ecb3ngH3SzKxI2iW9+qonsG9EPAJcDHwC6Au8TdLFZlY2DiRWlyKiISKubWex7wPHS1oOPE3SZdSynHXAT0iy4y4FnomIe9OurnOBP0taCtzZwSouBH4OrABeAu7OslLaZXYq8Mv0c5cAw0iOem6XtIzkIoGrI+JtkqEEvilpScuT7ZL2ldQAXAhMltQgqW8Hv4eZs/+a5a0LLuk1qyo+IjEzs5L4iMTMzEriIxIzMyuJA4mZmZXEgcTMzEriQGJmZiVxIDEzs5L8H0Z5HxPyThcyAAAAAElFTkSuQmCC\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",
+    "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')"
+   ]
+  },
+  {
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Priyansh_Mali_190107052 b/Priyansh_Mali_190107052
new file mode 100644
index 000000000..65996b4bd
--- /dev/null
+++ b/Priyansh_Mali_190107052
@@ -0,0 +1,909 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "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",
+    "# tells matplotlib to embed plots within the notebook\n",
+    "%matplotlib inline\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "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)\n",
+    "    \n",
+    "    # ==============================\n",
+    "    return A"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "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": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "warmUpExercise()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "data=np.loadtxt(os.path.join('Data','ex1data1.txt'),delimiter =',')\n",
+    "X,y =data[:,0],data[:,1]\n",
+    "m=y.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "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",
+    "    pyplot.show()\n",
+    "\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "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": "code",
+   "execution_count": 37,
+   "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": "code",
+   "execution_count": 38,
+   "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",
+    "    A=np.zeros((2,1))\n",
+    "    A[0,0]=theta[0]\n",
+    "    A[1,0]=theta[1]\n",
+    "    product=np.dot(X,theta)\n",
+    "    \n",
+    "    sum=0\n",
+    "    for i in range(0,m):\n",
+    "        pred=product[i]\n",
+    "        sum += (pred - y[i])**2\n",
+    "        \n",
+    "    J = sum/(2*m)          \n",
+    "    # ===========================================================\n",
+    "    return J"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "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": "code",
+   "execution_count": 46,
+   "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 : arra_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",
+    "     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",
+    "    J_history =[]\n",
+    "    xtrans =X.transpose()\n",
+    "    for i in range(num_iters):\n",
+    "        h=np.dot(X,theta)\n",
+    "        loss = h-y\n",
+    "        gradient = np.dot(xtrans,loss)/m\n",
+    "        theta = theta - alpha*gradient\n",
+    "        J_history.append(computeCost(X, y, theta))\n",
+    "    return theta, J_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {
+    "scrolled": true
+   },
+   "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": [
+    "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": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEHCAYAAACncpHfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de5wcVZ338c9vZhqYcdIhMElkUcCdR10VI2jUILoPrvsooxhWjBcChEtCIBd2MwZNgrvP4uNrQdTA7hq8QMYLCRHciBrZzLoYb+yG4AaUAQRl2kVEuSTqhonhFTrh9/xR1UlPp7ureqaru6f7+3696tU91VVdpzud+tU5dc7vmLsjIiKtp63eBRARkfpQABARaVEKACIiLUoBQESkRSkAiIi0KAUAEZEW1ZHUG5vZi4GbgBcCzwM3uPs/mdmVwMXAjnDTK9x9c7n36unp8RNOOCGpooqINKV77rlnp7tPLfV6YgEA2Acsd/d7zWwScI+Z3RG+dp27fzruG51wwgls3749kUKKiDQrM/tVudcTCwDu/gTwRPh8xMweAo5N6ngiIlKZmtwDMLMTgJOBu8NVS81syMy+aGZTalEGEREZLfEAYGbdwNeBZe7+DPA5oBc4iaCGsLrEfgvNbLuZbd+xY0exTUREZBwSDQBmliI4+d/s7rcBuPtT7r7f3Z8HbgTeUGxfd7/B3We6+8ypU0vewxARaTqZTIb+xYuZnk7T3tbG9HSa/sWLyWQyVT1OYgHAzAwYAB5y92vz1h+Tt9l7gAeSKoOIyEQzODjIrBkz6Fy7lq0jI+x1Z+vICJ1r1zJrxgwGBwerdixLKhuomb0ZuBO4n6AbKMAVwNkEzT8OPApcEt4wLmnmzJmuXkAi0uwymQyzZsxg0549nFLk9buA2V1dbBsaore3N/L9zOwed59Z6vUkewH9B2BFXirb519EpFWtWb2ai7PZoid/gFOABdks1193HdeuWTPu42kksIhIg9iwfj3zs9my2yzIZtmwbl1VjqcAICLSIHbu3s3xEdscF25XDQoAIiINoqe7m7JDd4HHwu2qQQFARKRBzD33XAZSqbLbrE2lmHveeVU5ngKAiEiDWLp8OTemUtxV4vW7CALAkv7+qhxPAUBEpEH09vZy08aNzO7qYlUqRQbIAhlgVSrF7K4ubtq4MVYX0DgUAEREGkhfXx/bhobYu3Ahp6bTdLa1cWo6zd6FC9k2NERfX1/VjpXYQLBq0kAwEYFgoNSa1avZsH49O3fvpqe7m7nnnsvS5curdlXcTKIGgqkGICITQi1TJLQK1QBEpOFVO0VCq1ANQEQmvEpSJEh8CgAi0vBqnSKhVSgAiEjDq3WKhFahACAiDa/WKRJahQKAiDS8WqRIqNUsXI1EAUBEGl7SKRJatYupAoCINLwkUyRkMhnmzZnDpj17uCqbpZdgpqxe4Kpslk179jBvzpymrAkoAIjIhJBUioRW7mKqgWAi0tKmp9NsHRmhXN0hA5yaTvPkrl21KlZVaCCYiEgZhV1MM0A/MB1oDx//GdgxMlKH0iVLAUBEWlp+F9NBYBbQCWwF9oaPXcAR7k13M1gBQERaWq6LaQaYB2wCroJRN4OvBr4LTXczWAFARFparovp3wIXQ0vdDFYAEJGWluti+i1gfsS2zZZvSAFARFpeX18fe81aLt+QAoCICK2Zb0gBQESE2uQbajQKACIiJJ9vqBElFgDM7MVm9n0ze8jMHjSzvwnXH2Vmd5jZI+HjlKTKICISV5L5hhpVkjWAfcByd38FwdiKJWb2SmAlsMXdXwpsCf8WEam7pPINNaqa5QIys28Ba8LlNHd/wsyOAX7g7i8vt69yAYmIVK4hcgGZ2QnAycDdwHR3fwIgfJxWizKIiMhoiQcAM+sGvg4sc/dnKthvoZltN7PtO3bsSK6AIiItKtEAYGYpgpP/ze5+W7j6qbDph/Dx6WL7uvsN7j7T3WdOnTo1yWKKiLSkJHsBGTAAPOTu1+a9tAk4P3x+PvCtpMogIiKldST43qcC5wH3m9lPw3VXAJ8AvmZm8wkG1r0vwTKIiEgJiQUAd/8PwEq8/LakjisiIvFoJLCISItSABARaVEKACIiLUoBQESkRSkAiIi0KAUAEZEqymQy9C9ezPR0mva2Nqan0/QvXtyQk8krAIiIVMng4CCzZsygc+1ato6MsNedrSMjdK5dy6wZMxgcHKx3EUepWTbQ8VA2UBFpdJlMhlkzZrBpzx5OKfL6XcDsri62DQ3VbE6BhsgGOpFNpOqciNTPmtWruTibLXryBzgFWJDNcv1119WyWGUpAJQx0apzIlI/G9avZ342W3abBdksG9atq1GJoqkJqIRGrM6JSONqb2tjr3vZ/DpZoLOtjX3799ekTGoCGqOJWJ0Tkfrp6e7mVxHbPBZu1ygUAEqYiNU5kWbXyPfk5p57LgOpVNlt1qZSzD3vvBqVKJoCQAk7d+/m+Ihtjgu3E5HkNfo9uaXLl3NjKsVdJV6/iyAALOnvr2WxylIAKGEiVudEmlUmk2HenDls2rOHq7JZegly2fcCV2WzbNqzh3lz5tS1JtDb28tNGzcyu6uLVakUGYI2/wywKpVidlcXN23c2FD3DBUASpiI1TmRZjVR7sn19fWxbWiIvQsXcmo6TWdbG6em0+xduJBtQ0P09fXVtXyF1AuoBPUCEmkc09Npto6MUO5/WgY4NZ3myV27alWshqdeQGM0EatzIs1K9+SSoQBQxkSrzok0K92TS4YCQITe3l6uXbOGJ3ftYt/+/Ty5axfXrlmjK3+RGtI9uWQoAIhIw5uIXSwnAgUAEWl4uieXDAUAEZkQdE+u+iK7gZqZAW8AjgUc+C3wY69h/1HNByATUSaTYc3q1WxYv56du3fT093N3HPPZeny5bpSlZoYVzdQM3s78AhwJfBO4F3Ax4BHwtdEpIhGT1sgAhE1ADN7COhz90cL1r8E2Ozur0i2eAHVAGQi0SBCaRTjHQjWATxeZP1vgPJ9skRa1ERJWyASVQNYBbwfuAX4dbj6xcAHga+5+9WJlxDVAGRiUdoCaRTjqgGEJ/hzACO4cHlT+PycqJO/mX3RzJ42swfy1l1pZr8xs5+Gyzsr+TAiE4HSFshEEdkN1N1/5u6fAP4e+Dt3/4S7/yzGe38ZOL3I+uvc/aRw2VxZcUVqYzwTjyhtgUwUUb2AjjOzW8zsaeBu4MfhVf0tZnZCuX3d/UfA76tWUpEaGW8PHqUtkIkiqgZwK/AN4Bh3f6m7vxQ4BvgmwX2BsVhqZkNhE9GUMb6HSCKqMfGI0hbIRBEVAHrc/VZ3PzCFvbvvd/dbgKPHcLzPEfxfOgl4AlhdakMzW2hm281s+44dO8ZwKJHKVaMHj9IWyEQR1QvoFoJmnK8wuhfQ+QTB4f1l3zxoJrrd3U+s5LVC6gUktVLNHjyZTIbrr7uODevWHRwJfN55LOnv18lfaiKqF1BUADgMmA+cSZAKwgjGBWwCBtx9b8TBTyDvJG9mx7j7E+HzfuCN7v7BqA+hACC10t7Wxl53OspskwU629rYt39/ma1E6i8qAJT7nePuzxE023xuDAf+KnAa0GNmjxP0IjrNzE4iyCn0KHBJpe8rkqSe7m5+FVEDUA8eaRZRvYA6zOwSMxsMb9zeFz6/1MzKdnNw97Pd/Rh3T7n7i9x9wN3Pc/dXu/sMd5+dqw1IdYyn66IE1INHWknUTeB1BDdsP8boZHCvAdYnWzSphJKPVYd68EgriQoAr3X3Re6+zd0fD5dt7r4IOLkWBZRo1ei62IqK1ZjWrF7NNZ/5jHrwSEuICgB/MLP3mdmB7cyszcw+APwh2aJJXEo+VrlyNaYVl13GNZ/5jCYekaYX1QvoBOAa4C84eMI/Evg+sNLd/zvh8gHqBRRFyccqo3TN0irGmwzuUXf/gLtPJUwG5+7TwnU1OflLNCUfq4xqTCKB2HMCu/vv3H0ngJnNNLNjkyuWVELJxyqzYf165mezZbdZkM2yYd26GpVIpD7GOin8ZcDtZnZrNQsjY6Oui5VRjUkkMKYA4O7nu/vJwIIql0fGQF0XK6Mak0ggMgCY2WQz+4CZfcjM+sPnRwK4+0jyRZQoSj5WGdWYRAJRI4HnAfcSpHToAl4AvBW4J3xNGkRfXx/bhobUdTEG1ZhEAlHdQH9OkLDtfwrWTwHudveXJVw+QN1ApfoGBweZN2cOC7JZFmSzHEfQ7LM2lWJtKsVNGzcqaMqEN65uoATZP4tFiOfD12SCa9X8QY1aY2rVfw+pE3cvuRDk/c8QZAO9Ilw+H667oNy+1Vxe97rXucQzPDzsyxYt8mmTJnmbmU+bNMmXLVrkw8PDh2y7efNm7+nq8lWplA+DZ8GHwVelUt7T1eWbN2+uwydoXfr3kGoDtnu5c3y5F4P9mQJ8EFgOXB4+nxK1XzWXiRwAKjkhj/cYkzs7vQv88vDEUe4EMjw87D1dXb4Vgp9BwbIVvKerq6rllNL07yFJGHcAaIRlogaAWlzR5Y5xaUeHHx2eKOKcQJYtWuSrUqmi2+aWlamU9y9ZMu4ySjT9e0gSEgsAwP1j3bfSZSIGgFpc0eUfYxn4qjInj8ITyLRJk3w4Yvth8OnpdLW+EilD/x6ShKgAENUN9KwSy3uBF1b9hkQTqUW+mfxjbCCYu7Oc/PQGGg3bWPTvIfUQ1Q00C9xM8Z5Ac9x9UlIFyzcRu4HWIkNn/jHagb2Un+Mzfy5bZRBtLPr3kCSMtxvoEPBpd7+wcAH+J2LfllaLK7r8Y/RARekNNBq2sejfQ+ohKgAsA54p8dp7qlyWplKLfDP5x5gLDERsn38C0WjYxqJ/D6mHqPkA7nT3x0q8NrHaZGqsFld0+cdYCtwIsU8gyh/UWPTvIXVR7g5xeH9gGvCC8Hkn8FHgE8AxUftWa1EvoHjH2AzeA74y7DHyXPi4oqOjZLfT4eFh71+yxKen097e1ubT02nvX7JE/c3rRP8eUk1UYSDY94DjwuefBL4ErAC+H7VvtZaJGADcD/bRXxmOA8idkFcmMA4gd4yHwC8CnwzeBn50V5dOICItKioARHUDPR/oBU4Ln38A2A48CRxvZvPMbEa1ayXNohb5ZgqPcWJbG/+aTnPRkiX8YniYnX/8I9euWaOmAxE5RFQ30OOB7wDnAZOBq4A5BIngNgLvBXa5e6L90iZiN1ARkXqL6gZarts47v4rM/sn4HYgBcxz98fM7Dhgp5e4QSwiIo0vckYwd/8cQTPQi9z99nD174CzkyyYSC0o/bK0slhzArv7bnffk/f3H71gkhiRiWZwcJBZM2bQuXYtW0dG2OvO1pEROteuZdaMGQwODta7iCKJGtOk8HGY2RfN7GkzeyBv3VFmdoeZPRI+Tknq+CLlZDIZ5s2Zw6Y9e7gqm6WXoD20F7gqm2XTnj3MmzNHNQFpaokFAODLwOkF61YCW9z9pcCW8G+RmqtFsj6RRle2F9C439zsBOB2dz8x/PvnwGnu/oSZHQP8wN1fHvU+6gUk1abka9IKxpsMLvcmZ4XNNrvM7BkzGzGzUjmCypnu7k8AhI/TyhxzoZltN7PtO3bsGMOhREpT+mWR+E1AnwRmu/tkd0+7+yR3TydZMHe/wd1nuvvMqVOnJnkoaUG1SNYn0ujiBoCn3P2hKhzvqbDph/Dx6Sq855io+19rqyRZn34r0qziBoDtZnarmZ2dPzPYGI63CTg/fH4+8K0xvMe4qfufxE2/fOJrX6vfijSvcomCcgtBArjC5YsR+3wVeIIgq+3jBDMWHk3Q++eR8PGoOMevZjK4WmTplIkhKlnfwMCAfisyoTGeZHB5QeKQGcHc/aKIfc5292PcPeXuL3L3AXf/nbu/zd1fGj7+fgwxa1zU/U9yopL13b99u34r0tSiksF9xN0/aWafoci8wO7+10kWLqea3UDV/U/i0m9FJrpxJYMDcjd+m6YTvrr/SVz6rUizi8oG+u3w8Su1KU7yerq7+VXEVZ26/wnotyLNL8lUEA2pFnP1SnPQb0WaXcsFgLjd/3KTp0vjqHV/fP1WpNnFTQVxapx1E0Fvby83bdzI7K4uVqVSZAj6qWaAVakUs7u6uGnjRk2h2GDqMXZDvxVpeuX6iOYW4N4465JakpgUfnh42PuXLPHp6bS3t7X59HRak6eP0fDwsC9btMinTZrkbWY+bdIkX7ZoUdW+y3qP3dBvRSYqIsYBRHUDPQV4E7AMyO/snAbe4+6vSSwy5VE20MY1ODjIvDlzuDibZX42y/HAr4CBVIobUylu2riRvr6+cR2jf/FiOteu5apstuQ2q1Ip9i5cyLVr1ozrWCLNZLzZQA8Dugl6C03KW54hmBxeWkCptvfvfe97NZlUZcP69cwvc/KHYEDWhnXrxnUckVYTaz4AMzve3aOSJyZGNYD6KXeFf707p7tz6/79JfevxpV5e1sbe93L9lnOAp1tbewrUxaRVjOuGoCZ/WP4dI2ZbSpcqlrSBjERMz8mVeaoaRP/bd8+tuzfT7mjVOPKXKmbRZIR1QR0U/j4aWB1kaWpTMQsoUmWOVbeJOD6Mu9RaqRsJUFL/fFFElLuDjHB/L0A15TbLukliV5Aherd02Qski7ztEmTfLjEe+eWYfDpUa+n06PeN5eFc1WYhTMbbrcqzMK5efPmmn5OkWZFRC+gqADwM+B/E+QEOhl4bf5Sbt9qLrUIAMsWLfJVqVTZk93KVMr7lyxJ5Phj6Uo53jJHHbPNzLMRAeA58PbwBL4MfBp4W/i4DPySjo5Rxx/ryTwqdXNh0BCR8QeAOcAgMAJ8v2D5Xrl9q7nUIgDEvtotuJqthlJXxCs7Ojzd0eGTOzuLnqDHU+Y4V+Fx378bvAt8efh37r1WhOsHBgYOHHc8QUv98UUqM64AcGAj+Ls42yW11CIAxL7aNTuwTzUGQMW5Ij4a/OGCE/TAwIAfXuSKu/CE/Rx4e1tbxcfs6eryC+bOjTxZfwj8BeE+ca7o6xloRVpNVACIOyHMx81stpl9OlzOqMb9h0bS3dERq6dJd3gzslo3X+PcaL0Y+AKj+9dfNn8+5wFbgb3hYycwi6DKll/mwt4xcSfFaTOLzIVzI3BeuE+598pNmqIUyyINpFx0yC3A1QRTOF4ULncAV8fZtxpLLWoAk1MpXxlxZboCfHIqVdWbkmO90foR8P5Sx86rCRRrTqnkKrxU2/vlZj4ZfHKRWke5K3rVAERqhyo1AQ0BbXl/twNDcfatxlKLAGDhibPsSR28zayqN4wrudEaFRQOHDsMDqUCUexjhk1HxdreJ6dSvoWg+amS96r3zXaRVlLNAHBU3t9HNVsAmDZpkg+EJ/mV4Qn2QE+TcP1AeGVaeBVbrAfMheBHd3fHOu5YagDFgkL+9pPDk3+x3jHVuArPBZFpVFYDUJdOkdqJCgBx5wO4GviJmX3ZzL4C3ANcVY0mqEYx99xzGU6l2EbQpn4qQZv6qeHf24BHwsFG+e3YgwTt7p2Mbo+fDjy7e3fkvYBYg5yAuQXrHgN6Smx/HEG3rW1DQ0UTsVVjYFVudO5cYKDsO41+L6VYFmkg5aJDEEAw4MXAMcBs4EzghVH7VXOptAYwlt45lVyZ5q6gh4nRbBRxNRvruEWusleGtYxife+3RFy9V+MqPNeUM9bvQF06RZJHlZqA7omzXVJLJQGg0lGmxfaNGmyUO/ktA18V0fwRpz271HE/Ep5cNxc5qaYJuoeuYnTf+1Vh889fnXHGmI4Zd2BVfhDZTPGms+XgR3d2apCWSJ1UKwBcD7w+zrZJLHEDQDWubONcmW7ZssXT7e3eSfk++Ln276nd3ZE1ksLjHt3V5en2dr+ko2PUSXVFR4cfEZ7ky44d6OyMvJou9lkvOuccv2Du3Fi1p/wgsgX8b8Cnht9JF/hZZ5xR9Sv6pCefEWkm1QoAPwP2EzTVDgH304A3gWvRw2Tz5s1+dGenX27mwwQDtC4MT8gGflRBMHguPCGOpUZSKhi947TT/PIq1DyKfbZKa0+1bMoZT+1OpBVVKwAcX2yJs281lrgBIOk+5sPDw37kYYcduPLONX0UNsPkeg1t5uB9gmr2eKnkc8a9Ym703jmNXj6RRjSuAAAcQTAd5BrgEqCj3PZJLXEDwFjSOVTiHaed5svzTrBxxg0soPiArWJX6nFP1pV8zrhXzI3eP7/RyyfSiMYbAG4F1ocn/28C/1Ru+6SWatcAuqDiK8Xh4WHv5GDTTpwbwB8Bn8ToewOFYwZ6CEYXDwwMxD5ZV/I5myVHT6OXT6QRjTcA3J/3vAO4t9z2cRfg0fA+wk+jCugVBIBlixb5h83KniRWgs8yq/hKcdmiRaNGvcYdAHV03t+lmoyWhyfr1TFP1nGuhi8381lR30XeFXOlo4NrrdHLJ9KIxhsA7i3391iXMAD0xN2+kl5AkVe9jO4nH7fZZdqkSaP648dOgZAXDOI0GZUKKoVNRVHt4V3h54x7xdzoV9iNXj6RRhQVAKJGAr/GzJ4JlxFgRu65mT0TPcystnp7e3mWYLTaKhg9yjRcfxPwFoJsk5Vk9Ny5e/eoUa89ECt76KTw+RqCrJ5jnV5xQTbLF66/nva2Nt508smcetppvLuzs+Ro2meBP48oX37WzUafdrHRyycyIZWLDkktwH8D9xKklFhYYpuFwHZg+3HHHRc74k2bNMm3ENx4nR5egU8P/x7Ou1I8uru7ol4luffNXcXHuQewoqPD0+3tvpUKcuZE1Cby7w1MOeIIP+uMM4p2waz0irnRe9k0evlEGhHV6AZa7QX4k/BxGnAf8Ofltq9kJHCc9vEVHR1+7JQpFfWlX7Zoka/s6DjQjn8JQft+1Akpd3M3TpPRQ1BykpdiwaHwpDeqOYtgbEKpAWqFn8+98addbPTyiTSahgwAowoAVwKXl9umkgAQt308HfeKvMgV8jBBjeJIRk+FWOqENDw8HMwjUOZYm8OAcjmHpnboAX8fB2sx+b2IJoO//sQTS/YiWkHpdBITMUdPo5dPpJE0XAAAXgBMynu+FTi93D6VJoMrdaW4oqPjQG+bSvPY57/virz0DFvA3wDeSdDvPndC2rJly6iby5NTqVE9lPJP5EZ0l80u8Ksp3otoQYz9jyaoYZQKUEqvINJ8GjEA/GnY7HMf8CDw0ah9xjIfwJYtW3zmq17lXXkn2GOnTPFL2tvdqTyPfU6cK9BiKQu2cDB/T2F30L8Or9TLleXDBLWWYif5ZTH2X07QvFRYXqVXEGleDRcAxrKMtQZQeFLLn75wvJk8S101b9mypWQT1OawDIUn8qNiBqMjS7w2nmCmG6sizavlAkC5k1p+s894cvmXu2pOt7f7irCWUWy5EEbdfB4mqKGMZVrIYp8rbnOWu9IriDS7lgsApU5qm2FUKgcnmOIxzaE3cT9E6ekUo66aj464Gi+8Wl9GBROrx3zPuDUADa4SaW5RASDulJATxob165mfzY5alwHmEUxllhvINQisIJjS8A8cnALydcDngZNe/3pe9rKXHfL+a1av5uJstuSArj/Agekii9kB/DPBlJHtwA3AWURPq/hZ4F0lXqt0Wsac/KktS8kfLCYiTaZcdGiUpZIaQLGcMbn2/lyzz9eIbv7pAu9ua/OBgQF3P9jm30X5SWDKXY1vDt83N3NWNnyvh2OWZ0GZq/SxNGepBiDS3Gi1GkBusvJ8G4D5QC9BKogFwIWUT8uwBHjV889z2fz59Pf3H0gZMcTBid87CSaEz5/2fS7BJO6FcrWQ7wJXh2XpIEgp0RGWq1QKi3cDHUccwTe7uriryHv3htv9JbCyoyP2ROtKryDS4spFh0ZZxnIPoLCfff4Ve1Q7fe7Kd2pYW4iTYG5Umoki25fqdZS/PjfArDCFxSUdHd6/ZEnkSNiBgYGKBkmpF5BIc6PVbgIPDw97+vDD/SiKT5jeQ/xeN23hCfrDEduuZPSkL+9rb/d0R8eoE3WpTJ+VNt9UeySs0iuINK+WDABTDj+8KqmSu6g8iVvuhL1ly5ZRJ+pyQSc3MGwF5VNKJEXpFUSaU8sFgDh92z8EPqvISbwwx05nQW2hcJtcs9JDBE025U7YUTdch8EvCoOOTsIiUg1RAaDpbgIX6wZaaDEwBAduqA4S3MztJLi5u5cgT/XicN1NJbbJ3Qh+M8GN3L0LF7JtaIi+vr5Djhl1w7UXmJZKccmSJezbv58nd+3i2jVrDrlxKyJSLRYEicY2c+ZM3759e6xt29va2OtOR5ltsgSz3R8FvBfYCHyb4r2C7gLeDhwesc3pHR3c+/DDJU/YmUyGWTNmsGnPnpLvMburi21DQzrpi0hVmNk97j6z1OtNVwMo1g200GMEAeCzBLPSRHUJfQVwUcQ2i4Drr7uu5DF7e3u5aeNGZnd1lZzFq1hXTRGRpDRdACjV1JIB+glG4L4MsLY2FrS38xBwacR7/jdwScQ2F+/bx4Z168pu09fXx7ahIfYuXMip6TSdbW2cmk6XbToSEUlK0zUBZTIZ3vjqV/PtZ589cMU+SDAI62KCAWHHE8zn+3kzPuvOPwI/A9YDvyeoHewnmKxgHkHqhr0Q2azU2dbGvv37K/14IiKJaLkmoN7eXt781rfSRzA69nsEJ/FNwFUcHIHbC3zKne8Cy4A9wDaCE/0QQW3BgN8StP/HaVbq6e6u+ucREUlK0wUAgLvuvJPbCE7mZwHnU779finB1X5+cLia4Kbv94C/AD4XcUylTBCRiaYpA8DO3bv5c+Bagqv3RRHbLyTIF1ToFIK8QdMJ8vsUy8NDuP7Gjg6W9PePrcAiInXQlAEgvyfQTsqnZ4Yw5XGJ1xYAtwAjwNuANxDUCnI9eFYCfUD2+ef5xS9+Mc6Si4jUTlMGgPyeQD3EbL8v8dpxBE1Je4H7gdMIsnMeQTCHwHMEg8b+be9e5s2ZQyaTKfo+mUyG/sWLmZ5O097WxvR0mv7Fi0tuLyKStKYMAEuXL+fGVIq7iDlZSrhdMY8BhwHHAmsIuoN+l2AQ2X8SNDP1EjYXZbNFxwIMDg4eSCe9dWSEve5sHRmhc+1aZs2YweDg4CH7iIgkrSkDQP6gq90Es26Va79fS5D/v5gbCe4R5BuIi2gAAA+RSURBVOf//x+CpqHrC7ZdkM0eMhYgk8kwb84cNu3Zw1XZ7KgbzVdls2zas6dszUFEJClNGQDg4KCr5885h90Ek6VczujJVlaG61cRnJAL3UVQe7gsfP0qgu6k5wGPAF8gmNZxOkG30SyHTp8YNYVkuZqDiEiSmjYA5KTTaY7o7OR54E7gJGASMAP4FEEvoY8RjAYunIlrNkEiuPzgcApwAfAbOGR2sDcDkw4/fNTx4ySnK1ZzEBFJWtMGgPx293uefZafAvuA5wmu1nMn7/8iyPr5VYKgcDjBSX4vwcCwYskZFhGkhxjVnEMwbuD5bHZUc44mXheRRtWUAaBYu/tvgIc5dE7e3KCvfwNyGYR+y8Gbu8WU6jZ6CkFOoA+eeeaBIBA3OZ1GEYtIrTVlAMhvd88lgTuT4Mq9XFv8xUA34+s2uggYfvDBA717kpx4XV1LRWQ8mjIA5Nrd8ydxOYLoEcGXEjQTXRGxXbluo8cRDBrL9e5595w5B7qkFnMXQQCodBSxupaKyLiVmy4sqQU4Hfg5MAysjNq+kikh3d3bzPzhgsnW28rMyZs/EXx7OC3j18pN0l5mnuD8+YFXplLev2RJ1SdeHx4e9p6urtgTyYtIa6LRpoQ0s3aCLvR9wCuBs83sldU8Rk93N9cQNOnkmnwqGRG8lKCf/ypG9wz6sBl9HNozKF9+7SDXu6fa8wCoa6mIVEW56JDEQnB++k7e36uAVeX2qbQGsGzRIp9ccJW+DHxVRA1gJXh/uN/U8Pn0vFrBReec41OOOKL8lXfecZ8LJ3ivtqgJ5g/URNLpqh9bRCYOGq0GQJBV4dd5fz8erquapcuX8wyjk8AtJRjVG2dE8HEEE8NcCzwJfDicrH1g/Xpuvu02Znd1HTKorNi4gaR696hrqYhUQz0CgBVZd8i0ZGa20My2m9n2HTt2VHSA3t5epnR2jmry6SU4Of8lwQjgcifv/F4+hTdpc805P3zVq5hJcIP5VIqPG0hqjgB1LRWRaqhHAHgceHHe3y8i6Ho/irvf4O4z3X3m1KlTKz7IvAsuYG3H6Ekc+4D3Az8kOGmXOnnfCLyL0pO19/b2csu3vkVHVxd3EtQSCscNjLV3TxxJdi0VkRZSrn0oiYVg/NUvgZcQJNq8D3hVuX0qvQfgHvSUmXL44Ye01w8X9A4q1o7fBX50d7f3L1lStidNtXv3VPLZ1AtIRKLQaPcA3H0fQZP8d4CHgK+5+4NJHGs/cAaje/MAvJWgKWg5BU1B4RX/xs2b2TkywrVr1oy68i9U7d49ceVnO12VShX9DIW1FhGRQhYEicY2c+ZM3759e0X79C9eTOfatczPZrmeYMrHnQRt+3MJAsMVZjycSrF73z56uruZe955LOnvnzAnzkwmw/XXXceGdevYuXv3hPwMIpIcM7vH3WeWfL1ZA8D0dJqtIyMl++tDcMX8xq4udv7xj+Mqn4hII4oKAE2ZCgLid5X8w549FefOUQ4eEWkGTRsA4naVnAQVjZhVDh4RaRZNGwDmnnsun4/YZi3wXog9GYumdxSRZtK0AWDp8uV8luiRvx8m/ohZ5eARkWbStAGgt7eXVGcn7+bQpG75I39TxB8xq+kdRaSZNG0AALjwggt4X0cHeyk98reSEbPKwSMizaSpA8DS5cvZeNhhvI8gXcM+RqdtqDRdg3LwiEgzaeoAUO0Rs8rBIyLNpKkDAFQ3XcPS5csTmd5RRKQemjIAFA7UetPJJ+PPP89/3nsv+/bv58lduyLz/BSjHDwi0kyaLgAkPVCrXgngRESqralyAWUyGWbNmMGmPXuK9tW/C5jd1cW2oSFdpYtI02upXEAaqCUiEl9TBQAN1BIRia+pAoAGaomIxNdUAUADtURE4muqAKCBWiIi8TVVANBALRGR+JoqAGiglohIfE0VAEADtURE4mqqgWAiInJQSw0EExGR+BQARERalAKAiEiLmhD3AMxsB0SO8SqlB9hZxeIkTeVN3kQrs8qbrIlWXohf5uPdfWqpFydEABgPM9te7iZIo1F5kzfRyqzyJmuilReqV2Y1AYmItCgFABGRFtUKAeCGehegQipv8iZamVXeZE208kKVytz09wBERKS4VqgBiIhIEU0TAMzsUTO738x+amaH5I2wwD+b2bCZDZnZa+tRzrAsLw/LmVueMbNlBducZma78rb5vzUu4xfN7GkzeyBv3VFmdoeZPRI+Timx7/nhNo+Y2fl1LvOnzOzh8N/8G2Z2ZIl9y/5+aljeK83sN3n/7u8sse/pZvbz8Pe8so7lvTWvrI+a2U9L7FuP7/fFZvZ9M3vIzB40s78J1zfk77hMeZP7Dbt7UyzAo0BPmdffCQwCBswC7q53mcNytQNPEvTXzV9/GnB7Hcv158BrgQfy1n0SWBk+XwlcU2S/o4Bfho9TwudT6ljmtwMd4fNripU5zu+nhuW9Erg8xm8mA/wpcBhwH/DKepS34PXVwP9toO/3GOC14fNJwC+AVzbq77hMeRP7DTdNDSCGM4GbPLANONLMjql3oYC3ARl3H+tAt0S4+4+A3xesPhP4Svj8K8BfFdn1HcAd7v57d/8DcAdwemIFzVOszO7+7+6+L/xzG/CiWpQljhLfcRxvAIbd/Zfu/hxwC8G/TaLKldfMDHg/8NWkyxGXuz/h7veGz0eAh4BjadDfcanyJvkbbqYA4MC/m9k9ZrawyOvHAr/O+/vxcF29fZDS/2lOMbP7zGzQzF5Vy0KVMN3dn4DgxwpMK7JNo37PABcR1AKLifr91NLSsLr/xRLNE434Hb8FeMrdHynxel2/XzM7ATgZuJsJ8DsuKG++qv6GO8ZawAZ0qrv/1symAXeY2cPhFUuOFdmnrl2gzOwwYDawqsjL9xI0C+0O24G/Cby0luUbo4b7ngHM7KPAPuDmEptE/X5q5XPAxwm+s48TNKtcVLBNI37HZ1P+6r9u36+ZdQNfB5a5+zNBZSV6tyLravIdF5Y3b33Vf8NNUwNw99+Gj08D3yCoJud7HHhx3t8vAn5bm9KV1Afc6+5PFb7g7s+4++7w+WYgZWY9tS5ggadyzWbh49NFtmm47zm8gXcGcI6HjaWFYvx+asLdn3L3/e7+PHBjiXI01HdsZh3AWcCtpbap1/drZimCk+nN7n5buLphf8clypvYb7gpAoCZvcDMJuWeE9w0eaBgs03APAvMAnblqoF1VPKqycxeGLarYmZvIPi3+l0Ny1bMJiDXG+J84FtFtvkO8HYzmxI2X7w9XFcXZnY6sAKY7e57SmwT5/dTEwX3pd5Tohz/BbzUzF4S1iI/SPBvUy9/CTzs7o8Xe7Fe32/4/2cAeMjdr817qSF/x6XKm+hvOMm72rVaCHpD3BcuDwIfDddfClwaPjfgeoLeE/cDM+tc5i6CE/rkvHX55V0afpb7CG78vKnG5fsq8ATBtMqPA/OBo4EtwCPh41HhtjOBtXn7XgQMh8uFdS7zMEFb7k/D5fPhtn8CbC73+6lTedeFv88hghPVMYXlDf9+J0EvkUw9yxuu/3Lud5u3bSN8v28maLYZyvv3f2ej/o7LlDex37BGAouItKimaAISEZHKKQCIiLQoBQARkRalACAi0qIUAEREWpQCgMRiZvvDLIMPmNm/mFlXld//AjNbE7HNaWb2pry/LzWzedUsR5FjfirMzPipIq/1mdn2MHvjw2b26cJyhZ/rTyo85loze2UF2/+Zmd1lZnvN7PKC1yKzhlqJ7JjhmJmiGXStThlfpcpq0R9Xy8RfgN15z28GPlTl978AWBOxzZVEZMpM4HM/AxxeZP2JBH3w/yz8uwNYXGS7H5DwmBOCXDavB/4h//shZtZQSmTHpEQGXeqY8VVLdRfVAGQs7gT+F4CZfSisFTxg4ZwGZnZCeEX8lfDKcWOuxmBBzvKe8PlMM/tB4Zub2bvN7G4z+4mZfdfMpluQHOtSoD+sibzFgtz5l4f7nGRm2+xgzvTcVewPzOwaM/uxmf3CzN5S5HgWXuk/YEE+9Q+E6zcBLwDuzq3L8xHgH9z9YQB33+funw33u9LMLjezOQSDi24Oy/wuM/tG3nH/j5ndVvC+uTLPDJ/vNrN/sCAp4DYzm164vbs/7e7/RTBAK1/crKGlsmOWyqBbNFOmmbWb2Zfzvsf+IseSBqIAIBWxIO9LH3C/mb0OuBB4I8EV4sVmdnK46cuBG9x9BsFV9OIKDvMfwCx3P5ngpPURd38U+Dxwnbuf5O53FuxzE7AiPN79wN/nvdbh7m8AlhWszzkLOAl4DUFag0+Z2THuPht4NjxeYZ6bE4F7yn0Id98IbCfI33ISsBl4hZlNDTe5EPhSufcgCEDb3P01wI+AiyO2zxc3o2Wp7Jil9i+1/iSC9MUnuvurif5sUmcKABJXpwWzPW0HHiPIWfJm4Bvu/kcPEtfdRpAWGODX7v6f4fP14bZxvQj4jpndD3wYKJsK28wmA0e6+w/DVV8hmLwkJ3eVfQ9wQpG3eDPwVQ+SsD0F/JCgSaWq3N0JUj2ca8GsTqdQOrVvznPA7eHzUuUvZbwZLUvtX2r9L4E/NbPPWJC/5pki20kDUQCQuHJXwie5+2Vhk0K5vLqFJ5rc3/s4+Ls7osS+nyG4H/Bq4JIy28W1N3zcT/EU6LHyAxd4EHjdGPb7EnAuQSLAf/GDE32Ukg0DB5QufylxM1qWyo5Zav+i68PmoNcQ3PdYAqytoKxSBwoAMh4/Av7KzLosyED4HoL7AwDHmdkp4fOzCZp1IJi2LnfifG+J950M/CZ8nt/DZIRgqrxR3H0X8Ie89v3zCK7iK/kcHwjbsKcS1B5+HLHPp4ArzOxlAGbWZmYfKrLdqDJ7kLL3t8DfEiRRS1LJrKFmdrWZvSfcrlR2zFIZdItmygzv7bS5+9eBvyOYPlIaWDNNCCM15u73mtmXOXiyXOvuPwlv2D4EnG9mXyDIuvi5cJuPAQNmdgWHznaUcyXwL2b2G4JMqC8J138b2GhmZwKXFexzPvD58GbzLwna1+P6BkFzzH0ENZWPuPuT5XZw96HwpvdXw2M68K9FNv1yWK5ngVPc/VmCXlRT3f1nFZSxJDN7IUHTXBp4PizXKz2Y/GQpwQm7Hfiiuz8Y7vZqDqaQ/gTwNTObT9C8975w/WYOZqPcQ/iduvvvzezjBAEG4P+F614DfMnMcheWxSY6kgaibKBSdWEAuN3dT6xzURqSBeMdfuLuA3Usw3fc/R31Or40BtUARGrIzO4B/ggsr2c5dPIXUA1ARKRl6SawiEiLUgAQEWlRCgAiIi1KAUBEpEUpAIiItCgFABGRFvX/AYH/yuNsMedbAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "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[:, 1], y)\n",
+    "pyplot.plot(X[:, 1], np.dot(X, theta), '-')\n",
+    "pyplot.legend(['Training data', 'Linear regression']);\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "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": "code",
+   "execution_count": 16,
+   "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": [
+    "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": "code",
+   "execution_count": 17,
+   "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": "code",
+   "execution_count": 18,
+   "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",
+    "    # =========================== YOUR CODE HERE =====================\n",
+    "    mu=np.mean(X,axis=0)\n",
+    "    sigma=np.std(X-mu,axis=0)\n",
+    "    X_norm=(X-mu)/sigma\n",
+    "    \n",
+    "    # ================================================================\n",
+    "    return X_norm, mu, sigma"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "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": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add intercept term to X\n",
+    "X = np.concatenate([np.ones((m, 1)), X_norm], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "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",
+    "    # ======================= YOUR CODE HERE ===========================\n",
+    "    sum = 0\n",
+    "    h=np.dot(X,theta)\n",
+    "    \n",
+    "    for i in range (0,m):\n",
+    "        c=h[i]-y[i]\n",
+    "        d=np.transpose(c)\n",
+    "        sum += np.dot(d,c)\n",
+    "    J = (1/(2*m))*sum    \n",
+    "    # ==================================================================\n",
+    "    return J\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sum0(X,y,theta):\n",
+    "    sum=0\n",
+    "    for i in range (0,y.size):\n",
+    "        sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,0]\n",
+    "    return sum\n",
+    "\n",
+    "def sum1(X,y,theta):\n",
+    "    sum=0\n",
+    "    for i in range (0,y.size):\n",
+    "        sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,1]\n",
+    "    return sum\n",
+    "\n",
+    "def sum2(X,y,theta):\n",
+    "    sum=0\n",
+    "    for i in range (0,y.size):\n",
+    "        sum += (theta[0]*X[i,0]+theta[1]*X[i,1]+theta[2]*X[i,2]-y[i])*X[i,2]\n",
+    "    return sum"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "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",
+    "        \n",
+    "        T0=theta[0]-alpha*((1/m)*sum0(X,y,theta))\n",
+    "        T1=theta[1]-alpha*((1/m)*sum1(X,y,theta))\n",
+    "        T2=theta[2]-alpha*((1/m)*sum2(X,y,theta))\n",
+    "        theta[0]=T0\n",
+    "        theta[1]=T1\n",
+    "        theta[2]=T2\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": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "theta computed from gradient descent: [340412.65957447 109447.75525931  -6578.31364383]\n",
+      "[340412.65957447 109447.75525931  -6578.31364383]\n",
+      "Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): $293081\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.3\n",
+    "num_iters = 100\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",
+    "# Recall that the first column of X is all-ones. \n",
+    "# Thus, it does not need to be normalized.\n",
+    "\n",
+    "price = theta[0]*1+theta[1]*(1650-2000.68085106)/786.202619+theta[2]*(3-3.17021277)/0.752842809\n",
+    "print(theta)\n",
+    "# ===================================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using gradient descent): ${:.0f}'.format(price))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 330,
+   "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": "code",
+   "execution_count": 331,
+   "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",
+    "    \n",
+    "    Part1=(np.linalg.inv(np.transpose(X).dot(X)))\n",
+    "    Part2=(np.transpose(X).dot(y))\n",
+    "    theta=Part1.dot(Part2)\n",
+    "    \n",
+    "    # =================================================================\n",
+    "    return theta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 332,
+   "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 = theta[0]+theta[1]*1650+theta[2]*3\n",
+    "\n",
+    "# ============================================================\n",
+    "\n",
+    "print('Predicted price of a 1650 sq-ft, 3 br house (using normal equations): ${:.0f}'.format(price))"
+   ]
+  }
+ ],
+ "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Week4.ipynb b/Week4.ipynb
new file mode 100644
index 000000000..a8beab890
--- /dev/null
+++ b/Week4.ipynb
@@ -0,0 +1,724 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot\n",
+    "\n",
+    "sys.path.append('..')\n",
+    "# from submission import SubmissionBase\n",
+    "\n",
+    "\n",
+    "def displayData(X, example_width=None, figsize=(10, 10)):\n",
+    "    \"\"\"\n",
+    "    Displays 2D data stored in X in a nice grid.\n",
+    "    \"\"\"\n",
+    "    # Compute rows, cols\n",
+    "    if X.ndim == 2:\n",
+    "        m, n = X.shape\n",
+    "    elif X.ndim == 1:\n",
+    "        n = X.size\n",
+    "        m = 1\n",
+    "        X = X[None]  # Promote to a 2 dimensional array\n",
+    "    else:\n",
+    "        raise IndexError('Input X should be 1 or 2 dimensional.')\n",
+    "\n",
+    "    example_width = example_width or int(np.round(np.sqrt(n)))\n",
+    "    example_height = n / example_width\n",
+    "\n",
+    "    # Compute number of items to display\n",
+    "    display_rows = int(np.floor(np.sqrt(m)))\n",
+    "    display_cols = int(np.ceil(m / display_rows))\n",
+    "\n",
+    "    fig, ax_array = pyplot.subplots(display_rows, display_cols, figsize=figsize)\n",
+    "    fig.subplots_adjust(wspace=0.025, hspace=0.025)\n",
+    "\n",
+    "    ax_array = [ax_array] if m == 1 else ax_array.ravel()\n",
+    "\n",
+    "    for i, ax in enumerate(ax_array):\n",
+    "        ax.imshow(X[i].reshape(example_width, example_width, order='F'),\n",
+    "                  cmap='Greys', extent=[0, 1, 0, 1])\n",
+    "        ax.axis('off')\n",
+    "\n",
+    "\n",
+    "def sigmoid(z):\n",
+    "    \"\"\"\n",
+    "    Computes the sigmoid of z.\n",
+    "    \"\"\"\n",
+    "    return 1.0 / (1.0 + np.exp(-z))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "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",
+    "# will be used to load MATLAB mat datafile format\n",
+    "from scipy.io import loadmat\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": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 20x20 Input Images of Digits\n",
+    "input_layer_size  = 400\n",
+    "\n",
+    "# 10 labels, from 1 to 10 (note that we have mapped \"0\" to label 10)\n",
+    "num_labels = 10\n",
+    "\n",
+    "#  training data stored in arrays X, y\n",
+    "data = loadmat(os.path.join('Data', 'ex3data1.mat'))\n",
+    "X, y = data['X'], data['y'].ravel()\n",
+    "\n",
+    "# set the zero digit to 0, rather than its mapped 10 in this dataset\n",
+    "# This is an artifact due to the fact that this dataset was used in \n",
+    "# MATLAB where there is no index 0\n",
+    "y[y == 10] = 0\n",
+    "\n",
+    "m = y.size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 100 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Randomly select 100 data points to display\n",
+    "rand_indices = np.random.choice(m, 100, replace=False)\n",
+    "sel = X[rand_indices, :]\n",
+    "\n",
+    "displayData(sel)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# test values for the parameters theta\n",
+    "theta_t = np.array([-2, -1, 1, 2], dtype=float)\n",
+    "\n",
+    "# test values for the inputs\n",
+    "X_t = np.concatenate([np.ones((5, 1)), np.arange(1, 16).reshape(5, 3, order='F')/10.0], axis=1)\n",
+    "\n",
+    "# test values for the labels\n",
+    "y_t = np.array([1, 0, 1, 0, 1])\n",
+    "\n",
+    "# test value for the regularization parameter\n",
+    "lambda_t = 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lrCostFunction(theta, X, y, lambda_):\n",
+    "    \"\"\"\n",
+    "    Computes the cost of using theta as the parameter for regularized\n",
+    "    logistic regression and the gradient of the cost w.r.t. to the parameters.\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.  \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 (including intercept).\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 of a particular choice of theta. You should set J to the cost.\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",
+    "    Hint 1\n",
+    "    ------\n",
+    "    The computation of the cost function and gradients can be efficiently\n",
+    "    vectorized. For example, consider the computation\n",
+    "    \n",
+    "        sigmoid(X * theta)\n",
+    "    \n",
+    "    Each row of the resulting matrix will contain the value of the prediction\n",
+    "    for that example. You can make use of this to vectorize the cost function\n",
+    "    and gradient computations. \n",
+    "    \n",
+    "    Hint 2\n",
+    "    ------\n",
+    "    When computing the gradient of the regularized cost function, there are\n",
+    "    many possible vectorized solutions, but one solution looks like:\n",
+    "    \n",
+    "        grad = (unregularized gradient for logistic regression)\n",
+    "        temp = theta \n",
+    "        temp[0] = 0   # because we don't add anything for j = 0\n",
+    "        grad = grad + YOUR_CODE_HERE (using the temp variable)\n",
+    "    \n",
+    "    Hint 3\n",
+    "    ------\n",
+    "    We have provided the implementatation of the sigmoid function within \n",
+    "    the file `utils.py`. At the start of the notebook, we imported this file\n",
+    "    as a module. Thus to access the sigmoid function within that file, you can\n",
+    "    do the following: `utils.sigmoid(z)`.\n",
+    "    \n",
+    "    \"\"\"\n",
+    "    #Initialize some useful values\n",
+    "    m = y.size\n",
+    "    \n",
+    "    # convert labels to ints if their type is bool\n",
+    "    if y.dtype == bool:\n",
+    "        y = y.astype(int)\n",
+    "    \n",
+    "    # You need to return the following variables correctly\n",
+    "    J = 0\n",
+    "    grad = np.zeros(theta.shape)\n",
+    "    \n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    m, n = X.shape\n",
+    "\n",
+    "    I = np.eye(len(theta))\n",
+    "\n",
+    "    I[0, 0] = 0\n",
+    "\n",
+    "    z= X.dot(theta)\n",
+    "\n",
+    "    J = 1.0 / m * (-y.T.dot(np.log(sigmoid(z))) - (1 - y).T.dot(np.log(1 - sigmoid(z)))) \\\n",
+    "        + (lambda_) / (2.0 * m) * np.sum(np.square(I.dot(theta)))\n",
+    "\n",
+    "    grad = 1.0 / m * (sigmoid(z) - y).T.dot(X).T + 1.0 * (lambda_) / m * (I.dot(theta))\n",
+    "\n",
+    "\n",
+    "        \n",
+    "    # =============================================================\n",
+    "    return J, grad"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost         : 2.534819\n",
+      "Expected cost: 2.534819\n",
+      "-----------------------\n",
+      "Gradients:\n",
+      " [0.146561, -0.548558, 0.724722, 1.398003]\n",
+      "Expected gradients:\n",
+      " [0.146561, -0.548558, 0.724722, 1.398003]\n"
+     ]
+    }
+   ],
+   "source": [
+    "J, grad = lrCostFunction(theta_t, X_t, y_t, lambda_t)\n",
+    "\n",
+    "print('Cost         : {:.6f}'.format(J))\n",
+    "print('Expected cost: 2.534819')\n",
+    "print('-----------------------')\n",
+    "print('Gradients:')\n",
+    "print(' [{:.6f}, {:.6f}, {:.6f}, {:.6f}]'.format(*grad))\n",
+    "print('Expected gradients:')\n",
+    "print(' [0.146561, -0.548558, 0.724722, 1.398003]');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def oneVsAll(X, y, num_labels, lambda_):\n",
+    "    \"\"\"\n",
+    "    Trains num_labels logistic regression classifiers and returns\n",
+    "    each of these classifiers in a matrix all_theta, where the i-th\n",
+    "    row of all_theta corresponds to the classifier for label i.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    X : array_like\n",
+    "        The input dataset of shape (m x n). m is the number of \n",
+    "        data points, and n is the number of features. Note that we \n",
+    "        do not assume that the intercept term (or bias) is in X, however\n",
+    "        we provide the code below to add the bias term to X. \n",
+    "    \n",
+    "    y : array_like\n",
+    "        The data labels. A vector of shape (m, ).\n",
+    "    \n",
+    "    num_labels : int\n",
+    "        Number of possible labels.\n",
+    "    \n",
+    "    lambda_ : float\n",
+    "        The logistic regularization parameter.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    all_theta : array_like\n",
+    "        The trained parameters for logistic regression for each class.\n",
+    "        This is a matrix of shape (K x n+1) where K is number of classes\n",
+    "        (ie. `numlabels`) and n is number of features without the bias.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    You should complete the following code to train `num_labels`\n",
+    "    logistic regression classifiers with regularization parameter `lambda_`. \n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    You can use y == c to obtain a vector of 1's and 0's that tell you\n",
+    "    whether the ground truth is true/false for this class.\n",
+    "    \n",
+    "    Note\n",
+    "    ----\n",
+    "    For this assignment, we recommend using `scipy.optimize.minimize(method='CG')`\n",
+    "    to optimize the cost function. It is okay to use a for-loop \n",
+    "    (`for c in range(num_labels):`) to loop over the different classes.\n",
+    "    \n",
+    "    Example Code\n",
+    "    ------------\n",
+    "    \n",
+    "        # Set Initial theta\n",
+    "        initial_theta = np.zeros(n + 1)\n",
+    "      \n",
+    "        # Set options for minimize\n",
+    "        options = {'maxiter': 50}\n",
+    "    \n",
+    "        # Run minimize to obtain the optimal theta. This function will \n",
+    "        # return a class object where theta is in `res.x` and cost in `res.fun`\n",
+    "        res = optimize.minimize(lrCostFunction, \n",
+    "                                initial_theta, \n",
+    "                                (X, (y == c), lambda_), \n",
+    "                                jac=True, \n",
+    "                                method='TNC',\n",
+    "                                options=options) \n",
+    "    \"\"\"\n",
+    "    # Some useful variables\n",
+    "    m, n = X.shape\n",
+    "    \n",
+    "    # You need to return the following variables correctly \n",
+    "    all_theta = np.zeros((num_labels, n + 1))\n",
+    "\n",
+    "    # Add ones to the X data matrix\n",
+    "    X = np.concatenate([np.ones((m, 1)), X], axis=1)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "    initial_theta = np.zeros(n + 1)\n",
+    "\n",
+    "    for i in range(0, 10):\n",
+    "        label = 10 if i == 0 else i\n",
+    "        \n",
+    "        result = optimize.minimize(fun=lrCostFunction, x0=initial_theta, args=(X, (y==label).astype(int), lambda_),\n",
+    "                                  method='TNC', jac=True)\n",
+    "        print('one_vs_all(): label =', label, ', success =', result.success)\n",
+    "        all_theta[i, :] = result.x\n",
+    "\n",
+    "  \n",
+    "   \n",
+    "\n",
+    "    # ============================================================\n",
+    "    return all_theta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "one_vs_all(): label = 10 , success = True\n",
+      "one_vs_all(): label = 1 , success = True\n",
+      "one_vs_all(): label = 2 , success = True\n",
+      "one_vs_all(): label = 3 , success = True\n",
+      "one_vs_all(): label = 4 , success = True\n",
+      "one_vs_all(): label = 5 , success = True\n",
+      "one_vs_all(): label = 6 , success = True\n",
+      "one_vs_all(): label = 7 , success = True\n",
+      "one_vs_all(): label = 8 , success = True\n",
+      "one_vs_all(): label = 9 , success = True\n"
+     ]
+    }
+   ],
+   "source": [
+    "lambda_ = 0.1\n",
+    "all_theta = oneVsAll(X, y, num_labels, lambda_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predictOneVsAll(all_theta, X):\n",
+    "    \"\"\"\n",
+    "    Return a vector of predictions for each example in the matrix X. \n",
+    "    Note that X contains the examples in rows. all_theta is a matrix where\n",
+    "    the i-th row is a trained logistic regression theta vector for the \n",
+    "    i-th class. You should set p to a vector of values from 0..K-1 \n",
+    "    (e.g., p = [0, 2, 0, 1] predicts classes 0, 2, 0, 1 for 4 examples) .\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    all_theta : array_like\n",
+    "        The trained parameters for logistic regression for each class.\n",
+    "        This is a matrix of shape (K x n+1) where K is number of classes\n",
+    "        and n is number of features without the bias.\n",
+    "    \n",
+    "    X : array_like\n",
+    "        Data points to predict their labels. This is a matrix of shape \n",
+    "        (m x n) where m is number of data points to predict, and n is number \n",
+    "        of features without the bias term. Note we add the bias term for X in \n",
+    "        this function. \n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    p : array_like\n",
+    "        The predictions for each data point in X. This is a vector of shape (m, ).\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the following code to make predictions using your learned logistic\n",
+    "    regression parameters (one-vs-all). You should set p to a vector of predictions\n",
+    "    (from 0 to num_labels-1).\n",
+    "    \n",
+    "    Hint\n",
+    "    ----\n",
+    "    This code can be done all vectorized using the numpy argmax function.\n",
+    "    In particular, the argmax function returns the index of the max element,\n",
+    "    for more information see '?np.argmax' or search online. If your examples\n",
+    "    are in rows, then, you can use np.argmax(A, axis=1) to obtain the index \n",
+    "    of the max for each row.\n",
+    "    \"\"\"\n",
+    "    m = X.shape[0];\n",
+    "    num_labels = all_theta.shape[0]\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    p = np.zeros(m)\n",
+    "\n",
+    "    # Add ones to the X data matrix\n",
+    "    X = np.concatenate([np.ones((m, 1)), X], axis=1)\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "  \n",
+    "    p = np.argmax(X.dot(all_theta.T), axis=1)\n",
+    "   \n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Set Accuracy: 86.50%\n",
+      "[9 5 8 ... 9 9 7]\n"
+     ]
+    }
+   ],
+   "source": [
+    "pred = predictOneVsAll(all_theta, X)\n",
+    "print('Training Set Accuracy: {:.2f}%'.format(np.mean(pred == y) * 100))\n",
+    "print(pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 100 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#  training data stored in arrays X, y\n",
+    "data = loadmat(os.path.join('Data', 'ex3data1.mat'))\n",
+    "X, y = data['X'], data['y'].ravel()\n",
+    "\n",
+    "# set the zero digit to 0, rather than its mapped 10 in this dataset\n",
+    "# This is an artifact due to the fact that this dataset was used in \n",
+    "# MATLAB where there is no index 0\n",
+    "y[y == 10] = 0\n",
+    "\n",
+    "# get number of examples in dataset\n",
+    "m = y.size\n",
+    "\n",
+    "# randomly permute examples, to be used for visualizing one \n",
+    "# picture at a time\n",
+    "indices = np.random.permutation(m)\n",
+    "\n",
+    "# Randomly select 100 data points to display\n",
+    "rand_indices = np.random.choice(m, 100, replace=False)\n",
+    "sel = X[rand_indices, :]\n",
+    "\n",
+    "displayData(sel)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup the parameters you will use for this exercise\n",
+    "input_layer_size  = 400  # 20x20 Input Images of Digits\n",
+    "hidden_layer_size = 25   # 25 hidden units\n",
+    "num_labels = 10          # 10 labels, from 0 to 9\n",
+    "\n",
+    "# Load the .mat file, which returns a dictionary \n",
+    "weights = loadmat(os.path.join('Data', 'ex3weights.mat'))\n",
+    "\n",
+    "# get the model weights from the dictionary\n",
+    "# Theta1 has size 25 x 401\n",
+    "# Theta2 has size 10 x 26\n",
+    "Theta1, Theta2 = weights['Theta1'], weights['Theta2']\n",
+    "\n",
+    "# swap first and last columns of Theta2, due to legacy from MATLAB indexing, \n",
+    "# since the weight file ex3weights.mat was saved based on MATLAB indexing\n",
+    "Theta2 = np.roll(Theta2, 1, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(Theta1, Theta2, X):\n",
+    "    \"\"\"\n",
+    "    Predict the label of an input given a trained neural network.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    Theta1 : array_like\n",
+    "        Weights for the first layer in the neural network.\n",
+    "        It has shape (2nd hidden layer size x input size)\n",
+    "    \n",
+    "    Theta2: array_like\n",
+    "        Weights for the second layer in the neural network. \n",
+    "        It has shape (output layer size x 2nd hidden layer size)\n",
+    "    \n",
+    "    X : array_like\n",
+    "        The image inputs having shape (number of examples x image dimensions).\n",
+    "    \n",
+    "    Return \n",
+    "    ------\n",
+    "    p : array_like\n",
+    "        Predictions vector containing the predicted label for each example.\n",
+    "        It has a length equal to the number of examples.\n",
+    "    \n",
+    "    Instructions\n",
+    "    ------------\n",
+    "    Complete the following code to make predictions using your learned neural\n",
+    "    network. You should set p to a vector containing labels \n",
+    "    between 0 to (num_labels-1).\n",
+    "     \n",
+    "    Hint\n",
+    "    ----\n",
+    "    This code can be done all vectorized using the numpy argmax function.\n",
+    "    In particular, the argmax function returns the index of the  max element,\n",
+    "    for more information see '?np.argmax' or search online. If your examples\n",
+    "    are in rows, then, you can use np.argmax(A, axis=1) to obtain the index\n",
+    "    of the max for each row.\n",
+    "    \n",
+    "    Note\n",
+    "    ----\n",
+    "    Remember, we have supplied the `sigmoid` function in the `utils.py` file. \n",
+    "    You can use this function by calling `utils.sigmoid(z)`, where you can \n",
+    "    replace `z` by the required input variable to sigmoid.\n",
+    "    \"\"\"\n",
+    "    # Make sure the input has two dimensions\n",
+    "    if X.ndim == 1:\n",
+    "        X = X[None]  # promote to 2-dimensions\n",
+    "    \n",
+    "    # useful variables\n",
+    "    m = X.shape[0]\n",
+    "    num_labels = Theta2.shape[0]\n",
+    "\n",
+    "    # You need to return the following variables correctly \n",
+    "    p = np.zeros(X.shape[0])\n",
+    "\n",
+    "    # ====================== YOUR CODE HERE ======================\n",
+    "   \n",
+    "    m, n = X.shape\n",
+    "    X = np.hstack((np.ones((m, 1)), X))\n",
+    "    A_1 = sigmoid(X.dot(Theta1.T))\n",
+    "    A_1 = np.hstack((np.ones((m, 1)), A_1))\n",
+    "    A_2 = sigmoid(A_1.dot(Theta2.T))\n",
+    "\n",
+    "    p = np.argmax(A_2, axis=1)\n",
+    "     \n",
+    "    \n",
+    "    return p"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Set Accuracy:97.5%\n"
+     ]
+    }
+   ],
+   "source": [
+    "pred = predict(Theta1, Theta2, X)\n",
+    "print('Training Set Accuracy:{:.1f}%'.format(np.mean(pred == y) * 100))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Neural Network Prediction: 5\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 288x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if indices.size > 0:\n",
+    "    i, indices = indices[0], indices[1:]\n",
+    "    displayData(X[i, :], figsize=(4, 4))\n",
+    "    pred = predict(Theta1, Theta2, X[i, :])\n",
+    "    print('Neural Network Prediction: {}'.format(*pred))\n",
+    "else:\n",
+    "    print('No more images to display!')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}