boosting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "1Rg2uSiFSRJe"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import preprocessing\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import math\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oDTSO7-MSRJj"
   },
   "source": [
    "# Problem 1\n",
    "## Dataset Generation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tx7KW28cSRJk"
   },
   "source": [
    "Write a function to **generate a training set** of size $m$\n",
    "- randomly generate a weight vector $w \\in \\mathbb{R}^{10}$, normalize length\n",
    "- generate a training set $\\{(x_i , y_i)\\}$ of size m\n",
    "  - $x_i$: random vector in $\\mathbb{R}^{10}$ from $\\textbf{N}(0, I)$\n",
    "  - $y_i$: $\\{0, +1\\}$ with $P[y = +1] = \\sigma(w \\cdot x_i)$ and $P[y = 0] = 1 - \\sigma(w \\cdot x_i)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "AUHuXrsgSRJl"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w_star:  [-0.35267002  0.40162094  0.6065412  -0.00245468  0.4828995   0.17742077\n",
      " -0.16159724 -0.13142696 -0.01228984  0.19549529]\n",
      "X:  [[-2.52374367e+00 -1.27949107e+00  7.60122525e-01  1.00916126e+00\n",
      "  -3.86284422e-01  3.33018318e-01 -7.99647772e-01  1.31631682e-01\n",
      "  -1.76533457e-01 -1.41934100e+00]\n",
      " [ 3.75806526e-01  4.40150269e-01  5.58463588e-01 -2.04726549e-01\n",
      "   1.22374743e+00 -6.81931560e-01 -5.23743605e-01 -1.78365985e+00\n",
      "  -1.08196060e-01  5.81712706e-01]\n",
      " [-8.36454825e-01 -6.08195909e-01 -1.33355406e-01 -9.55831011e-01\n",
      "  -3.68572608e-01 -1.47736009e-01  6.99198727e-01 -6.56944863e-01\n",
      "  -2.02658825e+00  1.68802816e-01]\n",
      " [-1.12041363e+00 -5.00009997e-01 -1.54845620e+00  8.01508462e-01\n",
      "  -3.75966885e-01  9.27855770e-01 -1.08483813e+00  5.02293069e-01\n",
      "  -9.21967136e-02  1.46298373e-01]\n",
      " [ 1.06981250e+00  8.39673985e-01 -1.98562376e-01 -6.03592517e-01\n",
      "  -2.49253660e-02  6.66236815e-02 -1.42779415e+00  5.21615110e-01\n",
      "  -4.21465015e-01  5.92849795e-01]\n",
      " [-8.72022742e-01  9.87575161e-01  9.80946926e-01  6.53465211e-01\n",
      "   1.25290944e+00 -4.41428959e-01  7.17594515e-01  1.22448950e+00\n",
      "  -3.21531610e-01 -3.21680129e-01]\n",
      " [ 7.96533598e-01  1.20157823e+00 -8.90900202e-02  1.44749624e+00\n",
      "  -1.50740023e+00  1.36543787e+00  8.55793131e-02 -1.19702544e+00\n",
      "   1.52244846e+00  9.94205966e-01]\n",
      " [-7.38066264e-01 -2.44907770e-01  3.53042686e-01  2.98825875e-01\n",
      "  -3.61464251e-02 -2.47841847e+00  6.14970864e-01 -7.88100335e-01\n",
      "   1.55602461e+00 -1.64966599e-01]\n",
      " [ 8.41761446e-01 -4.66988654e-01  1.97778401e+00 -5.83271100e-01\n",
      "   3.18318197e-01  7.98405609e-01  8.65708498e-01 -2.76681029e-01\n",
      "  -1.31162480e+00 -1.36031149e+00]\n",
      " [ 9.95626284e-01 -7.56435039e-01 -5.04128611e-01  2.84382173e-01\n",
      "  -2.41091812e-01 -9.04415542e-01 -6.78683394e-01  3.76952164e-01\n",
      "   9.23063997e-01 -7.79246170e-01]\n",
      " [ 2.39540821e+00  7.36104828e-01  9.93528029e-01  1.11650420e-01\n",
      "   1.24514726e+00 -4.10907274e-01 -5.19208018e-01 -4.70579860e-01\n",
      "   7.36485662e-01  5.31853387e-01]\n",
      " [ 1.27268453e+00 -4.43513125e-01 -9.89499466e-01  2.54359837e+00\n",
      "   5.60540030e-01 -1.96015642e-01 -9.58695971e-01 -4.99473031e-01\n",
      "  -5.00446483e-01  9.46927856e-01]\n",
      " [ 1.27366307e+00 -2.94260768e-01  2.00792944e-01 -1.10133172e+00\n",
      "   1.36874123e+00  1.55059850e+00  1.49727918e-01  1.32153004e+00\n",
      "   3.36825774e-01  2.09368793e+00]\n",
      " [ 6.43954331e-01 -4.97084901e-01 -1.51875071e+00  2.55525281e-02\n",
      "  -8.56147849e-01  7.54871154e-02 -9.33702909e-01  1.18290155e+00\n",
      "   9.69874189e-01  6.16602377e-01]\n",
      " [ 9.63764887e-01  1.27289586e+00 -2.02226601e-01  8.18849214e-01\n",
      "  -8.59646197e-01 -8.29340708e-01  8.09544835e-01 -4.83181236e-01\n",
      "  -8.88950051e-01 -8.37107752e-01]\n",
      " [-4.89061268e-01  1.70545685e+00 -9.19249918e-01  1.69996810e+00\n",
      "  -9.09391958e-01  3.27924449e-01  1.22089424e-01 -1.48904375e+00\n",
      "   1.51411889e+00  3.71220563e-02]\n",
      " [-6.14490321e-01  2.90040061e-01  8.41145046e-01 -5.73010391e-01\n",
      "   1.46021420e+00  2.44225355e-01 -4.67954847e-01  1.52313765e-01\n",
      "  -2.25007789e+00  1.00245630e+00]\n",
      " [-1.55203652e+00  7.48253439e-01  8.36065674e-01 -1.45381701e+00\n",
      "   5.28850849e-02 -2.84408864e-01  3.11491184e-01  1.50995096e-01\n",
      "  -4.98379368e-01 -5.70577875e-01]\n",
      " [-1.62947743e+00 -6.67662997e-01 -2.05895160e-01 -1.39198116e+00\n",
      "   5.75664172e-01 -1.91509296e+00  1.43541124e-01 -4.55685014e-01\n",
      "   4.68964323e-01 -2.91887449e-01]\n",
      " [-9.83222889e-03 -1.35830639e+00  7.59503489e-01 -7.54703693e-01\n",
      "  -7.81929146e-01 -1.10323341e+00 -3.83977812e-01  8.02622021e-01\n",
      "  -5.25453958e-01 -4.78820516e-01]\n",
      " [ 7.73690681e-01 -8.60061509e-01  1.59178297e+00 -1.12125410e+00\n",
      "   5.26874594e-01  2.66242120e-01 -3.06588903e+00  4.34219569e-01\n",
      "  -1.16081292e+00 -6.14308304e-01]\n",
      " [ 1.71352441e+00  8.68468550e-01 -2.21055633e-01  1.69960460e-01\n",
      "   7.79285160e-01 -1.17733405e-02 -4.37812117e-01  7.04529846e-01\n",
      "   1.26609899e-01 -1.77899390e+00]\n",
      " [ 2.26446332e-01  1.64867053e+00  2.61223338e-02  3.41871089e-01\n",
      "  -4.37130856e-01  3.27794825e-01  1.53111826e-01 -1.14667114e-01\n",
      "   1.55464878e-01 -4.14134207e-01]\n",
      " [ 3.42798527e-02  1.75415637e+00  8.95888887e-01 -3.47050654e-01\n",
      "  -8.83971946e-01 -2.38829366e-01 -1.81835966e-01  3.76770483e-02\n",
      "  -1.21499856e+00 -1.02451670e+00]\n",
      " [-9.35318130e-01  2.22495253e+00 -3.56226733e-01  7.61307873e-01\n",
      "   3.81963639e-01  3.66223734e-01 -2.18515758e-04 -1.89917489e-01\n",
      "  -1.18682600e+00 -2.35698558e+00]\n",
      " [ 2.16962289e+00  3.63054520e-01 -2.67475275e-01 -8.10714019e-02\n",
      "  -3.13094435e-01  3.98319736e-01  2.23294073e-01 -8.23022795e-02\n",
      "  -1.45610311e+00  1.00336189e-01]\n",
      " [-1.86441670e-01  6.93086647e-01 -5.12457521e-01 -9.69215651e-01\n",
      "  -3.53930926e-01 -1.58963955e+00 -5.92164900e-01 -5.02122911e-01\n",
      "  -1.15053824e-01  7.87880925e-01]\n",
      " [-4.16722221e-01  7.70172612e-01  8.82218694e-01  1.54168120e+00\n",
      "   4.32705757e-01 -1.69508922e+00  1.86925974e-01  1.91232901e-01\n",
      "   8.81191113e-02 -7.02874036e-01]\n",
      " [-2.33491755e+00 -3.15056678e-01 -1.21160736e+00 -1.13626362e+00\n",
      "  -3.69462873e-01 -9.26519356e-01  1.17658469e+00  4.12029882e-01\n",
      "  -1.47895559e+00  6.89887711e-01]\n",
      " [-6.79316376e-01 -3.74730580e-01 -4.87560235e-01 -1.50325912e+00\n",
      "  -2.97851194e-01  1.19125566e-01  3.28840458e-01  8.27615036e-01\n",
      "  -1.43848636e+00 -1.39730939e-01]\n",
      " [ 3.91251728e-01 -2.77994800e-01  9.15433654e-01 -9.86411101e-01\n",
      "   3.95095523e-01 -1.56514571e+00 -6.53873837e-01 -1.07391621e+00\n",
      "  -5.92148655e-02 -3.41735969e-01]\n",
      " [ 1.50011305e-01  1.23274495e+00 -8.65302156e-01 -8.49593870e-01\n",
      "   1.97827584e+00  5.58275277e-01  9.91310746e-01  5.90914670e-01\n",
      "  -1.91205141e+00  1.04949235e-01]\n",
      " [ 2.00241050e+00  7.10744640e-01 -1.72303132e+00  2.34581650e+00\n",
      "  -4.58342636e-01  9.76329000e-01 -3.18180298e-01  2.79727652e-01\n",
      "   4.24934991e-01  1.91735562e+00]\n",
      " [ 2.64663930e+00 -4.76568292e-01 -1.40919567e+00 -1.74833950e+00\n",
      "   2.05622865e+00  6.89203392e-01  2.20153675e-01 -1.34983201e+00\n",
      "  -1.92787133e+00  2.62294945e+00]\n",
      " [-1.71634346e+00 -3.03606222e-01 -2.35589894e-01 -6.30588987e-01\n",
      "  -2.41328990e-01 -1.06273404e+00  1.72502221e+00 -4.43958391e-01\n",
      "   8.18315172e-01 -2.70758938e-02]\n",
      " [ 1.19843462e+00  1.20002420e+00 -4.22855051e-01  6.93710281e-01\n",
      "  -6.67432251e-01 -1.29581408e+00  4.01982190e-01 -6.37663799e-01\n",
      "  -1.45359791e+00 -2.88901796e-01]\n",
      " [ 2.06908796e+00  8.34300642e-01 -3.12739803e-01 -9.48254512e-02\n",
      "   9.42009556e-02  1.15078813e+00 -7.75684790e-01  6.80697990e-02\n",
      "  -3.42452354e-01  1.83379182e+00]\n",
      " [ 1.08711761e+00  7.63151978e-01 -3.51619649e-01  1.57334889e-01\n",
      "   5.55504643e-01 -7.68256483e-01  9.41917350e-01  9.65234326e-01\n",
      "  -1.34446248e+00 -2.24169810e-01]\n",
      " [ 1.18959379e+00 -2.18883208e-01  1.45620237e+00  1.85000417e-01\n",
      "   1.89864600e+00  1.49948844e+00 -3.56527016e-01 -5.63199438e-01\n",
      "  -7.27003460e-01  7.63913042e-01]\n",
      " [ 8.40426325e-01  5.98076024e-01  7.76044966e-01  1.70386892e+00\n",
      "  -1.59310095e+00  2.63268860e-01  1.67718759e+00 -1.70886382e-01\n",
      "  -2.83729942e-01  4.12604597e-01]\n",
      " [ 3.34807555e-01  8.56653707e-01  1.11863369e+00 -3.34657684e-01\n",
      "  -1.09458250e+00  1.43027589e+00 -1.07176722e+00 -6.34257075e-01\n",
      "   6.62618019e-01  8.06959637e-01]\n",
      " [ 3.28307304e-01 -6.91226266e-02  1.05179951e+00 -5.97194140e-02\n",
      "  -4.17752089e-02  1.53127428e+00  1.33721086e-01 -1.72406818e+00\n",
      "   6.51347857e-01 -3.65508613e-01]\n",
      " [ 5.86604710e-01 -1.24491621e+00 -3.88587579e-02 -1.63698395e-01\n",
      "   3.73374734e-01 -6.29474206e-01  1.95016656e+00  4.01025447e-01\n",
      "   1.06574759e+00  4.48510325e-01]\n",
      " [ 4.96470682e-01 -4.93928806e-03  5.08034323e-01 -1.17729653e-01\n",
      "  -1.66036743e+00  3.58937678e-01  1.44136386e+00  5.54385610e-02\n",
      "  -1.88472747e-01 -1.10227323e+00]\n",
      " [ 1.51984105e+00  5.26966394e-01  1.42112670e+00 -1.00146204e+00\n",
      "   2.88947092e-01 -2.44280524e-01 -1.16878894e-01  1.88829576e+00\n",
      "   1.55294071e+00  8.11741589e-02]\n",
      " [ 2.12839096e+00  3.11489067e-01  1.42641881e+00 -6.98243795e-01\n",
      "  -5.11776344e-02 -9.45789648e-01  5.81632770e-01  2.45220539e+00\n",
      "  -2.03592846e+00  4.37359609e-01]\n",
      " [-1.41827511e+00  1.19587495e+00  1.37398350e+00 -2.17018415e-01\n",
      "  -6.74483565e-01  2.40303619e-01 -8.43899882e-01  2.42338788e-01\n",
      "  -9.08513317e-01  8.86711700e-01]\n",
      " [ 2.46897930e-01 -5.32489877e-01  7.65809716e-01  3.62274736e-01\n",
      "  -2.50841153e-01  2.24969277e+00 -6.81240096e-01 -1.90631615e-01\n",
      "   8.70464915e-03 -1.68810679e+00]\n",
      " [ 7.74920438e-01  1.39445000e+00  2.72579006e-01  4.85965115e-01\n",
      "   3.08981367e-01  3.91805253e-01 -4.38507857e-01  5.78053268e-01\n",
      "   7.86657297e-01  2.48055859e-01]\n",
      " [-1.36972627e+00 -2.78327855e-01 -9.81409562e-01  1.75570080e-01\n",
      "   2.12425663e-02  1.90231886e-01 -1.23040932e+00  7.94109572e-02\n",
      "   2.22793331e-01 -5.19901929e-01]]\n",
      "y:  [0 1 1 0 0 1 0 1 0 0 1 0 1 0 1 1 1 1 1 0 0 0 0 1 1 0 0 1 0 0 1 1 0 0 0 0 0\n",
      " 0 1 0 1 0 0 1 1 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "# get_w_star_vector - gets a weight vector (w*) whose Euclidean norm equals 1.\n",
    "def get_w_star_vector():\n",
    "    # i. generate each element of w* so that it's distributed standard normal N(0,1)\n",
    "    standard_norm_rand_vector = np.random.standard_normal(10)\n",
    "    # ii. normalize w* by |w*| so that it's Euclidean norm (L2) is equal to 1\n",
    "    euclidean_norm_vector_np = np.linalg.norm(standard_norm_rand_vector)\n",
    "    normalized_vector = standard_norm_rand_vector / euclidean_norm_vector_np\n",
    "    return normalized_vector\n",
    "\n",
    "# generate_random_vectors\n",
    "# m is the size of the vector produced, and m would represent the # of samples\n",
    "def generate_random_vectors(m):\n",
    "    rand_x_vectors = []\n",
    "    for i in range(m):\n",
    "        standard_norm_rand_vector = np.random.standard_normal(10)\n",
    "        rand_x_vectors.append(standard_norm_rand_vector)\n",
    "    return rand_x_vectors\n",
    "\n",
    "# generate_X generates X's from x^1 to x^m\n",
    "def generate_X(m):\n",
    "    X = generate_random_vectors(m)\n",
    "    return X\n",
    "\n",
    "# sigmoid function\n",
    "def sigmoid(x):\n",
    "    sig = 1 / (1 + math.exp(-x))\n",
    "    return sig\n",
    "\n",
    "# gen_label returns 1 if a random X in uniform dist ( in (0,1)) is less than\n",
    "# or equal to sigmoid of input x. else return 0\n",
    "def gen_label(x):\n",
    "    # get a uniform value between 0 and 1\n",
    "    rand_uniform_X = np.random.uniform(0, 1, 1)\n",
    "    sigmoid_check_val = sigmoid(x)\n",
    "    if rand_uniform_X <= sigmoid_check_val:\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "# generate_y_vector generates a y vector based on a x vector by\n",
    "# calling gen_label for each x^i value.\n",
    "def generate_y_vector(X_param, w_star_param):\n",
    "    y_vector = []\n",
    "\n",
    "    X_np = np.array(X_param)\n",
    "    w_star_np = np.array(w_star_param)\n",
    "    w_star_np_T = w_star_np.T\n",
    "\n",
    "    w_star_X = X_np.dot(w_star_np_T[:, None])\n",
    "\n",
    "    for i in range(w_star_X.shape[0]):\n",
    "        x_i = w_star_X[i]\n",
    "        y = gen_label(x_i)\n",
    "        y_vector.append(y)\n",
    "    return y_vector\n",
    "\n",
    "# generate_y generates y's from y^1 to y^m\n",
    "# uses the the following function to generate binary values at random\n",
    "# GenLabel (x^i) = { 1 - X <= sigma (w^*T x^i) , X ~ UNIFORM (0,1)\n",
    "#                  { 0 otherwise\n",
    "def generate_y(X, w_star):\n",
    "    y = generate_y_vector(X, w_star)\n",
    "    return y\n",
    "\n",
    "def generate_data(m):\n",
    "    # returns the true w as well as X, Y data\n",
    "    weight_vector = []\n",
    "    weight_vector = get_w_star_vector()\n",
    "\n",
    "    X = np.array(generate_X(m))\n",
    "    y = np.array(generate_y(X, weight_vector))\n",
    "\n",
    "    return weight_vector, X, y\n",
    "\n",
    "m = 50\n",
    "weight_vector, X, y = generate_data(m)\n",
    "\n",
    "print(\"w_star: \", weight_vector)\n",
    "print(\"X: \", X)\n",
    "print(\"y: \", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wx2-15fASRJy"
   },
   "source": [
    "## Algorithm 1: logistic regression\n",
    "\n",
    "The goal is to learn $w$.  Algorithm 1 is logistic\n",
    "  regression (you may use the built-in method LogisticRegression for this. Use max_iter=1000)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "Vj8b21jgSRJz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Coef  [[-0.36094276  0.98021383  0.84332625 -0.37307801  0.87295813 -0.27818831\n",
      "   0.42843547 -0.51103838  0.28501404 -0.04590906]]\n",
      "Intercept  [-0.90242885]\n"
     ]
    }
   ],
   "source": [
    "    lr_clf: LogisticRegression = LogisticRegression(random_state=0, max_iter=1000).fit(X, y)\n",
    "    print(\"LR Coef \", lr_clf.coef_)  # returns weights (coefficients)\n",
    "    print(\"Intercept \", lr_clf.intercept_)  # returns intercepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YzmNdy6ZSRJ3"
   },
   "source": [
    "## Algorithm 2: gradient descent with square loss\n",
    "\n",
    "Define square loss as\n",
    "$$L_i(w^{(t)}) = \\frac{1}{2} \\left( \\sigma(w^{(t)} \\cdot x) - y_i \\right)^2$$\n",
    "\n",
    "  Algorithm 2 is\n",
    "  gradient descent with respect to square loss (code this\n",
    "  up yourself -- run for 1000 iterations, use step size eta = 0.01)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GkCo7s9Oq6CF"
   },
   "source": [
    "## Algorithm 3: stochastic gradient descent with square loss\n",
    "Similar to gradient descent, except we use the gradient at a single random training point every iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "xHNo-56wq6CF"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gradient Descent W' vector  [-0.18612147  0.17454952  0.21073308 -0.09142408  0.22687008 -0.11241018\n",
      "  0.11792117 -0.13157732  0.10678818 -0.06466723]\n",
      "Stochastic Gradient Descent W' vector:  [-0.0446964  -0.05933969 -0.02555553 -0.00068454 -0.00052719  0.0097337\n",
      "  0.00929667 -0.00140612  0.04505165  0.00372675]\n"
     ]
    }
   ],
   "source": [
    "class GradientDescentClassifier:\n",
    "\n",
    "    def sigmoid(self, x):\n",
    "        return 1 / (1 + np.exp(-x))\n",
    "\n",
    "    def sigmoid_derivative(self, x):\n",
    "        return self.sigmoid(x) * (1.0 - self.sigmoid(x))\n",
    "\n",
    "    def calc_input_weights(self, inputs, weights):\n",
    "        return self.sigmoid(np.dot(inputs, weights))\n",
    "    \n",
    "    def __init__(self, step_size=0.01, steps=10):\n",
    "        self.w_prime_vector = None\n",
    "        self.learning_results = None\n",
    "        self.step_size = step_size\n",
    "        self.num_steps = steps\n",
    "\n",
    "    # fits a model using gradient descent\n",
    "    def fit(self, X, y):\n",
    "        # get the number of samples and number of features from the input training data features\n",
    "        num_samples, num_features = X.shape\n",
    "        weights = np.zeros(num_features)\n",
    "        for _ in range(self.num_steps):\n",
    "            # calculate weights against current features X\n",
    "            output = self.calc_input_weights(X, weights)\n",
    "            # calculate the error (difference between desired output (y) and predicted)\n",
    "            error_loss = y - output\n",
    "            # multiply error by X and gradient of sigmoid.\n",
    "            adjustment = np.dot(X.T, error_loss * self.sigmoid_derivative(output))\n",
    "            # adjust weights\n",
    "            weights += (1 / num_samples) * self.step_size * adjustment\n",
    "        self.w_prime_vector = weights\n",
    "        return self\n",
    "\n",
    "    # fits a model using SGD\n",
    "    def fit_sgd(self, X, y, random_state=0):\n",
    "        num_samples, num_features = X.shape\n",
    "        weights = np.zeros(num_features)\n",
    "\n",
    "        # Initializing the random number generator\n",
    "        seed = None if random_state is None else int(random_state)\n",
    "        rng = np.random.default_rng(seed=seed)\n",
    "\n",
    "        for i in range(self.num_steps):\n",
    "            # shuffle x and y\n",
    "            rng.shuffle(X)\n",
    "            rng.shuffle(y)\n",
    "            # calculate weights against current features X\n",
    "            output = self.calc_input_weights(X, weights)\n",
    "            # calculate the error (difference between desired output (y) and predicted)\n",
    "            error_loss = y - output\n",
    "            # multiply error by X and gradient of sigmoid.\n",
    "            adjustment = np.dot(X.T, error_loss * self.sigmoid_derivative(output))\n",
    "            # adjust weights\n",
    "            weights += (1 / num_samples) * self.step_size * adjustment\n",
    "\n",
    "        self.w_prime_vector = weights\n",
    "        return self\n",
    "\n",
    "    def get_w_prime(self):\n",
    "        return self.w_prime_vector\n",
    "\n",
    "# algo #2 - gradient descent classifier\n",
    "gd_clf = GradientDescentClassifier(steps=1000, step_size=0.01).fit(X, y)\n",
    "w_prime_gd = gd_clf.get_w_prime()\n",
    "print(\"Gradient Descent W' vector \", w_prime_gd)\n",
    "\n",
    "# algo #3 stochastic gradient descent classifier\n",
    "sgd_clf = GradientDescentClassifier(steps=1000, step_size=0.01).fit_sgd(X, y)\n",
    "print(\"Stochastic Gradient Descent W' vector: \", sgd_clf.get_w_prime())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5A-dLi3TSRJ-"
   },
   "source": [
    "## Evaluation\n",
    "\n",
    "Measure error $\\|w - \\hat{w}\\|_2$ for each method at different sample size. For any\n",
    "  fixed value of $m$, choose many different $w$'s and average the\n",
    "  values $\\|w - \n",
    "  \\hat{w}\\|_2$ for Algorithms 1, 2 and 3.  Plot the results\n",
    "  for for each algorithm as you make $m$ large (use $m=50, 100, 150, 200, 250$).\n",
    "  Also record, for each algorithm, the time taken to run the overall experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "ciMGYi4Vq6CH"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average_lr_error_rate_per_m  [1.0570549059445116, 0.7733554197328164, 0.5852172267326188, 0.433560259467629, 0.473600972695548]\n",
      "Total Time Logistic Regression:  0.14613652229309082\n",
      "Total Time Gradient Descent:  1.874532699584961\n",
      "Total Time SGD:  16.426692247390747\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2890d8623a0>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAACbEklEQVR4nOzdd1gUVxcH4N/sAsvSpVdBsaFIsfeKgl1jLxHEEhWsMZZo7CWx19iiqLHX6Bcr9i42VARRFKxUld7Z+/2BTFhYYEFgKed9nnl0Z+7MnCnsnL1z5w7HGGMghBBCCKkgBIoOgBBCCCGkOFFyQwghhJAKhZIbQgghhFQolNwQQgghpEKh5IYQQgghFQolN4QQQgipUCi5IYQQQkiFQskNIYQQQioUSm4IIYQQUqFQckMIkenq1avgOA5Xr15VdCiEEFIolNwQUsbt2rULHMeB4zjcvHkz13TGGCwsLMBxHLp3717g8iQSCfbs2YOmTZtCV1cXmpqaqFWrFoYPH467d++WxCYUmkQigYGBAZYvX55nmfnz5/P7RdYQFhZWihHLr127dlJxisVi2NnZYe3atZBIJEVa5u3btzF//nxER0cXb7CElFNKig6AECIfVVVV7N+/H61atZIaf+3aNXz48AEikUiu5UycOBGbNm1Cr169MHToUCgpKSEwMBBnz55F9erV0axZMwBAmzZtkJSUBBUVlWLfloL4+PggKioK3bp1K7Ds5s2boaGhkWu8jo5OCURWPMzNzbFs2TIAQFRUFPbv348pU6YgMjISS5YsKfTybt++jQULFsDNza1MbzchpYWSG0LKia5du+LIkSNYv349lJT++9Pdv38/GjZsiKioqAKXER4ejj///BOjR4/Gtm3bpKatXbsWkZGR/GeBQABVVdXi24BCOHPmDCwtLVGvXr0Cy/br1w/6+vqFWn5ycjJUVFQgEOSuvE5ISIC6unqhlpedRCJBampqvvtOW1sbw4YN4z+PHTsWderUwYYNG7Bw4UIIhcIir58QQrelCCk3Bg8ejM+fP8Pb25sfl5qaiqNHj2LIkCFyLSM4OBiMMbRs2TLXNI7jYGhoyH/O2eYm++2xnEO7du2klrV37140bNgQYrEYurq6GDRoEN6/fy/3tp4+fVquWht5ZG3HwYMHMWfOHJiZmUFNTQ2xsbFwc3ODhoYGXr9+ja5du0JTUxNDhw4FkJnk/Pzzz7CwsIBIJELt2rWxcuVKMMakls9xHDw9PbFv3z7Uq1cPIpEI586dK1SMqqqqaNy4MeLi4hAREcGPf/r0Kdzc3FC9enWoqqrC2NgY7u7u+Pz5M19m/vz5+OWXXwAA1apV449JSEgIX+Z7jwch5Q3V3BBSTlhZWaF58+Y4cOAAunTpAgA4e/YsYmJiMGjQIKxfv77AZVhaWgIAjhw5gv79+0NNTU3u9bdp0wZ///231Li3b99izpw5UknRkiVL8Ntvv2HAgAEYNWoUIiMjsWHDBrRp0waPHz8u8LZJWFgYHj9+jIULF8oV15cvX3KNU1JSyrWeRYsWQUVFBdOmTUNKSgp/uy09PR3Ozs5o1aoVVq5cCTU1NTDG0LNnT1y5cgUjR46Eg4MDzp8/j19++QUfP37EmjVrpJZ9+fJlHD58GJ6entDX14eVlZVcsWcXEhICjuOk4vb29sabN28wYsQIGBsb4/nz59i2bRueP3+Ou3fvguM4/PDDD3j58iUOHDiANWvW8LVYBgYGAL7/eBBSLjFCSJnm5eXFALD79++zjRs3Mk1NTZaYmMgYY6x///6sffv2jDHGLC0tWbdu3Qpc3vDhwxkAVqVKFdanTx+2cuVKFhAQkKvclStXGAB25coVmctJSkpiDRs2ZKampiw0NJQxxlhISAgTCoVsyZIlUmWfPXvGlJSUco2XZceOHUwsFvPbmJd58+YxADKH2rVr59qO6tWr51qmq6srA8BmzpwpNf6ff/5hANjixYulxvfr149xHMeCgoL4cQCYQCBgz58/L3DbGGOsbdu2rE6dOiwyMpJFRkayFy9esF9++YUByHX8ZO2DAwcOMADs+vXr/LgVK1YwACw4OFiqbHEcD0LKI7otRUg5MmDAACQlJeHff/9FXFwc/v33X7lvSWXx8vLCxo0bUa1aNZw4cQLTpk2DjY0NOnbsiI8fP8q9nPHjx+PZs2c4duwYjI2NAQDHjx+HRCLBgAEDEBUVxQ/GxsaoWbMmrly5UuByz5w5g/bt20MsFssVx7Fjx+Dt7S01eHl55Srn6uqa5zLHjRuXKwahUIiJEydKjf/555/BGMPZs2elxrdt2xZ169aVK14AePHiBQwMDGBgYIA6depgxYoV6NmzJ3bt2iVVLnu8ycnJiIqK4ht8P3r0qMD1FMfxIKQ8ottShJQjBgYGcHJywv79+5GYmIiMjAz069evUMsQCATw8PCAh4cHPn/+jFu3bmHLli04e/YsBg0ahBs3bhS4jK1bt8LLywtbt27lL7YA8OrVKzDGULNmTZnzKSsr57vctLQ0eHt7808SyaNNmzZyNSiuVq2azPFKSkowNzeXGvf27VuYmppCU1NTaryNjQ0/XZ5l58XKygrbt2+HRCLB69evsWTJEkRGRuZqhPzlyxcsWLAABw8elGqLAwAxMTEFrud7jwch5RUlN4SUM0OGDMHo0aMRFhaGLl26fFebCT09PfTs2RM9e/ZEu3btcO3aNbx9+5ZvmyOLj48PJk2ahFGjRmHMmDFS0yQSCTiOw9mzZ2U+8SPrke3sbt68idjYWHTt2rVoG5SPvGptRCKRzKemimPZeVFXV4eTkxP/uWXLlmjQoAF+/fVXqbZTAwYMwO3bt/HLL7/AwcEBGhoakEgkcHFxkatPnO89HoSUV5TcEFLO9OnTBz/99BPu3r2LQ4cOFdtyGzVqhGvXriE0NDTP5CYyMhL9+vWDg4MDNm3alGu6tbU1GGOoVq0aatWqVegYTp8+jbp16xapQW5xsrS0xMWLFxEXFydVe/PixQt+enGys7PDsGHDsHXrVkybNg1Vq1bF169fcenSJSxYsABz587ly7569SrX/BzHyVzu9x4PQsoranNDSDmjoaGBzZs3Y/78+ejRo0eh5g0LC4O/v3+u8ampqbh06RIEAgFq1Kghc96MjAwMGjQIqampOHbsmMzO/X744QcIhUIsWLAg1yPTjDGpR5hlOXPmTLE9Av49unbtioyMDGzcuFFq/Jo1a8BxHP+0WnGaPn060tLSsHr1agDga1py7se1a9fmmjerX56cPRR/7/EgpLyimhtCyiFXV9cizffhwwc0adIEHTp0QMeOHWFsbIyIiAgcOHAAT548weTJk/Nsv7JlyxZcvnwZY8eOzdUQ1cjICJ06dYK1tTUWL16MWbNmISQkBL1794ampiaCg4Nx4sQJjBkzBtOmTZO5/ODgYAQEBGDz5s2F2qajR4/KvL3SqVMnGBkZFWpZWXr06IH27dtj9uzZCAkJgb29PS5cuICTJ09i8uTJsLa2LtJy81O3bl107doVf/31F3777Tfo6emhTZs2WL58OdLS0mBmZoYLFy4gODg417wNGzYEAMyePRuDBg2CsrIyevTo8V3Hg5ByTVGPaRFC5JP9UfD8yPMoeGxsLFu3bh1zdnZm5ubmTFlZmWlqarLmzZuz7du3M4lEwpfN+Sh4fo9et23bVmo9x44dY61atWLq6upMXV2d1alTh3l4eLDAwMA8Y9u4cSPT1tZmaWlp+e+Qb/KLJ3vcWdtx5MiRXMtwdXVl6urqMpcfFxfHpkyZwkxNTZmysjKrWbMmW7FihdQ+YizzUXAPDw+5YmYs81HwevXqyZx29epVBoDNmzePMcbYhw8fWJ8+fZiOjg7T1tZm/fv3Z58+fZIqk2XRokXMzMyMCQSCXI+FF+V4EFKecYzlqKskhBAF6Nq1KzQ0NHD48GFFh0IIKefothQhpExo164dWrduregwCCEVANXcEEIIIaRCoaelCCGEEFKhUHJDCCGEkAqFkhtCCCGEVCiU3BBCCCGkQql0T0tJJBJ8+vQJmpqaeXZZTgghhJCyhTGGuLg4mJqaFvg+uEqX3Hz69AkWFhaKDoMQQgghRfD+/XuYm5vnW6bSJTdZL8F7//49tLS0FBwNIYQQQuQRGxsLCwsLqZfZ5qXSJTdZt6K0tLQouSGEEELKGXmalFCDYkIIIYRUKJTcEEIIIaRCoeSGEEIIIRUKJTeEEEIIqVAouSGEEEJIhULJDSGEEEIqFEpuCCGEEFKhUHJDCCGEkAqFkhtCCCGEVCiU3BBCCCGkQqHkhhBCCCEVCiU3hBBCCKlQKLkpRi/CYvH+S6KiwyCEEEIqNUpuiom3fzh6bbwFzwOPkZouUXQ4hBBCSKVFyU0xqWuqBZGSAE/eR2PlhUBFh0MIIYRUWpTcFBMzHTFW9LcHAGy7/gZXAiMUHBEhhBBSOVFyU4yc6xnDtbklAODnw08QFpOs4IgIIYSQyoeSm2I2q6sN6ppo4UtCKiYfeowMCVN0SIQQQkilQslNMVNVFmLjEEeoqQhx980XbLwcpOiQCCGEkEqFkpsSUN1AA4t72wIA1l16ibtvPis4IkIIIaTyoOSmhPzQwBx9G5hDwoBJBx/jS0KqokMihBBCKgVKbkrQwl71UN1AHeGxKZh25AkYo/Y3hBBCSEmj5KYEqYuUsHFwA6goCXD5RQR23AxWdEiEEEJIhUfJTQmra6qF37rZAAD+OPcCTz9EKzYgQgghpIKj5KYUDGtmiS62xkjLYPDc/xixyWmKDokQQgipsCi5KQUcx+H3vnYw0xHj3ZdE/Hr8GbW/IYQQQkoIJTelRFusjA1DHCEUcPj3aSgO3X+v6JAIIYSQComSm1LUoGoVTOtcGwAw/3/P8TI8TsEREUIIIRUPJTel7Kc21dGmlgGS0yTw2PcISakZig6JEEIIqVAouSllAgGH1QPsYaApwquIeCz897miQyKEEEIqFEpuFEBfQ4S1Ax3AccABn/f435NPig6JEEIIqTAouVGQljX04dGuBgBg1vFnePs5QcEREUIIIRUDJTcKNNmpJhpbVUF8SjomHHiM1HSJokMihBBCyj1KbhRISSjAukGO0FFTxtMPMVh+7oWiQyKEEELKPUpuFMxUR4wV/ewBAH/dDMblF+EKjogQQggp3yi5KQM61TWCWwsrAMDPh58gNCZJsQERQggh5RglN2XErK51YGumha+JaZh00BfpGdT+hhBCCCkKSm7KCJGSEBsGN4C6ihA+wV+w4XKQokMihBBCyiVKbsqQavrqWPpDfQDAhsuvcOf1ZwVHRAghhJQ/lNyUMb0czNC/oTkkDJh08DE+x6coOiRCCCGkXFFocnP9+nX06NEDpqam4DgO//zzT4HzXL16FQ0aNIBIJEKNGjWwa9euEo+ztC3oVQ81DDUQEZeCn488gUTCFB0SIYQQUm4oNLlJSEiAvb09Nm3aJFf54OBgdOvWDe3bt4evry8mT56MUaNG4fz58yUcaelSU1HCxiGOECkJcDUwEjtuBis6JEIIIaTc4BhjZaJagOM4nDhxAr17986zzIwZM3D69Gn4+fnx4wYNGoTo6GicO3dOrvXExsZCW1sbMTEx0NLS+t6wS9S+e28x+4QflAQcjo5rAQcLHUWHRAghhChEYa7fSqUUU7G4c+cOnJycpMY5Oztj8uTJigmohA1pUhW3gqJw5lkYJhx4hNMTW0NLVVnRYREihTGGDJaBdEn6fwPL/DdNkiY9Ptu0/MZJzSejfJokLfc6v5XNkGRIxcdx3H//BydzvFT5PMpIjc/6f7ZFFGq+711/HuOlllMOY8gaL+AEUBYqQ0WgAmWBMpSFypn/CpShJFCS+swPeZTP/llJoAQBR01NK4NyldyEhYXByMhIapyRkRFiY2ORlJQEsVica56UlBSkpPzXKDc2NrZEYotJicGj8EfgOA4CTgAO3/7lOP7/2cdn/YHx4zkOAuQuP9ZJE49DX+JDTBQmH72IBT1tIRQIwYHj15W13OzLyDWeE+Rafl5fbKTkZUgypC7aBSUBeV3M+flkJQxZ07NNy75eeRIPWUlGhiSD/5w1nZDyQonLTI6UBEqZyVAeiVLOz3mWL2j+gsrn+KwiVKEkrBiUq+SmKJYtW4YFCxaU+HpCYkMw8crEklm4AaBhANzPALqeKN5FZyU94AABsiVaciRGssbnTOiyEi55k7m85pU3mZNaR16JJHInoNmXmfOCn8EycicCedQm5JVk5BzPUCbuBpcoJYFS5q9lTglKAulByAn/m559moyyfJls04QCYeZFKuf835YtS/Y78Nn3v9T/8ygj13K+Z94c5UsiDqnlSP23kMvJoyVDscXwrSYw628uTZKGtIy0zH+zD9/GpUpSpaanS9KlPmcw6Zq8dJaO9PSyn5BnT8IKSoZyJmGFKS8riStMbVhZTcLKVXJjbGyM8HDpdy+Fh4dDS0tLZq0NAMyaNQtTp07lP8fGxsLCwqLYYxMriWFnYAfGGCRMAgbG/18CCRj79vnb/yVMIl0O3z4zBgbG/z9rfEpaBlLSMwCOQaTEAcicBga+TFFkxVcJrrVlnqwLu8wLfh7l8kok5FlOQUlG9ulZiUleiUdWGaoZJGVBVm0lnwxlpOaZKMlKjnKVz5loFdPn8pqECTmhzBquunp1sardKoXFVa6Sm+bNm+PMmTNS47y9vdG8efM85xGJRBCJRCUdGmpVqYV9XfeV2PIlEgb33fdxNTASxoYaOOXZEmoq0ocvV2KVLWHKGp8zaQLwX6KVLfnKK+HKuRy5xmdP2PIYnz3pk0oMc2yPzPE5lysrscy+7dkSOlnrzvpjlXUxz5UIFKKmQZnLXcuQfTmUDBBS/IQCIYQQQiQs+evA98iZhOWVDGUlWzmTsLxquPjkLMe0vOZPleRfPp1JJ1wZLAMZGRlIzkgG0v4bb6BmUMp7UJpCk5v4+HgEBf33moHg4GD4+vpCV1cXVatWxaxZs/Dx40fs2bMHADB27Fhs3LgR06dPh7u7Oy5fvozDhw/j9OnTitqEUiMQcFjV3x5d1t1AUEQ85p96juXf3iaeheO4PKvkCSGElF3lJQmTMInU7cK8kiFVoapC41RocvPgwQO0b9+e/5x1+8jV1RW7du1CaGgo3r17x0+vVq0aTp8+jSlTpmDdunUwNzfHX3/9BWdn51KPXRH0NERYO8gBQ/+6h8MPPqBlDX30cjBTdFiEEEIqCQEngIpQBSpCFaAMP7xbZvq5KS3lqZ+bvKz2fon1l15BXUWI0xNbw0pfXdEhEUIIISWqMNfvstnMmeRrYocaaGKli4TUDHgeeJTZ0JgQQgghACi5KZeUhAKsG+yAKmrK8PsYi9/PvlB0SIQQQkiZQclNOWWiLcbK/pkNir1uhcDbP7yAOQghhJDKgZKbcqyjjRFGtqoGAPjl6BN8ik5ScESEEEKI4lFyU87NcKmD+mbaiE5Mw6SDj5GeUbTO/AghhJCKgpKbck5FSYCNQxyhIVLC/ZCvWHfplaJDIoQQQhSKkpsKwFJPHUt/qA8A2HglCLeDohQcESGEEKI4lNxUED3tTTGosQUYAyYd8kVUfErBMxFCCCEVECU3Fci8HvVQ01ADkXEpmHr4CSSSStU/IyGEEAKAkpsKRawixMYhDSBSEuD6y0hsu/FG0SERQgghpY6SmwqmtrEm5vesBwBYeT4Qj959VXBEhBBCSOmi5KYCGtTYAt3tTJAuYZh44DFiktIKnokQQgipICi5qYA4jsPSH+qjqq4aPnxNwsxjT1HJ3o9KCCGkEqPkpoLSUlXGhsGOUBZyOOsXhr333ik6JEIIIaRUUHJTgdlb6GCGSx0AwKJ//REQGqvgiAghhJCSR8lNBTeyVTV0qGOI1HQJPPc/QmJquqJDIoQQQkoUJTcVHMdxWNnfHkZaIryOTMDck88VHRIhhBBSoii5qQR01VWwbpAjBBxw9OEHnHj8QdEhEUIIISWGkptKoll1PUzsWBMAMPuEH95Exis4IkIIIaRkUHJTiUzoUBPNqusiMTUDEw48Rkp6hqJDIoQQQoodJTeViFDAYd0gR+iqq+D5p1gsO/NC0SERQgghxY6Sm0rGSEsVq/rbAwB23Q7B+edhCo6IEEIIKV6U3FRC7esYYnTragCA6Uef4mN0koIjIoQQQooPJTeV1C/OdWBvoYOYpDRMOvAY6RkSRYdECCGEFAtKbiopFSUBNgxyhKZICQ/efsWaiy8VHRIhhBBSLCi5qcSq6qlhWd/6AIA/r77GzVdRCo6IEEII+X6U3FRy3e1MMbhJVTAGTD7ki8i4FEWHRAghhHwXSm4I5vWoi9pGmoiKT8HUw76QSJiiQyKEEEKKjJIbAlVlITYOcYSqsgA3XkVhy/XXig6JEEIIKTJKbggAoKaRJhb0rAcAWHXhJR6+/aLgiAghhJCioeSG8AY0skBPe1NkSBgmHvBFTGKaokMihBBCCo2SG8LjOA5L+tjCUk8NH6OTMP3YEzBG7W8IIYSUL5TcECmaqsrYOLgBlIUczj8Px9933yo6JEIIIaRQKLkhudQ318bMLjYAgMX/BuD5pxgFR0QIIYTIj5IbIpN7Sys42RgiNUOCCfsfIyElXdEhEUIIIXKh5IbIxHEcVvSzh4m2Kt5EJeC3k36KDokQQgiRCyU3JE9V1FWwbpAjBBxw/NFHHHv4QdEhEUIIIQWi5Ibkq0k1XUx2qgUA+O2kH15Hxis4IkIIISR/lNyQAnm0r4EW1npITM2A5/7HSE7LUHRIhBBCSJ4ouSEFEgo4rB3oAD11FQSExmLpmQBFh0QIIYTkiZIbIhdDLVWsGmAPANhz5y3O+YUqOCJCCCFENkpuiNza1TbET22qAwCmH32K918SFRwRIYQQkhslN6RQpjnXhoOFDmKT0zHp4GOkZUgUHRIhhBAiReHJzaZNm2BlZQVVVVU0bdoUPj4+eZZNS0vDwoULYW1tDVVVVdjb2+PcuXOlGC1RFgqwYbAjNFWV8OhdNFZ7v1R0SIQQQogUhSY3hw4dwtSpUzFv3jw8evQI9vb2cHZ2RkREhMzyc+bMwdatW7Fhwwb4+/tj7Nix6NOnDx4/flzKkVduFrpq+KOvHQBg89XXuP4yUsEREUIIIf/hmAJf+9y0aVM0btwYGzduBABIJBJYWFhgwoQJmDlzZq7ypqammD17Njw8PPhxffv2hVgsxt69e+VaZ2xsLLS1tRETEwMtLa3i2ZBKavaJZ9h37x30NVRwZlJrGGqqKjokQgghFVRhrt8Kq7lJTU3Fw4cP4eTk9F8wAgGcnJxw584dmfOkpKRAVVX6AioWi3Hz5s0SjZXI9lv3uqhjrImo+FRMOeQLiURheTIhhBDCU1hyExUVhYyMDBgZGUmNNzIyQlhYmMx5nJ2dsXr1arx69QoSiQTe3t44fvw4QkPzfiw5JSUFsbGxUgMpHqrKQmwc0gBiZSFuBX3G5muvFR0SIYQQovgGxYWxbt061KxZE3Xq1IGKigo8PT0xYsQICAR5b8ayZcugra3NDxYWFqUYccVXw1ADC3vVAwCs9n6JByFfFBwRIYSQyk5hyY2+vj6EQiHCw8OlxoeHh8PY2FjmPAYGBvjnn3+QkJCAt2/f4sWLF9DQ0ED16tXzXM+sWbMQExPDD+/fvy/W7SBAv4bm6ONohgwJw8QDjxGdmKrokAghhFRiCktuVFRU0LBhQ1y6dIkfJ5FIcOnSJTRv3jzfeVVVVWFmZob09HQcO3YMvXr1yrOsSCSClpaW1ECKF8dxWNTbFtX01fEpJhm/HH0KBbZTJ4QQUskp9LbU1KlTsX37duzevRsBAQEYN24cEhISMGLECADA8OHDMWvWLL78vXv3cPz4cbx58wY3btyAi4sLJBIJpk+frqhNIN9oiJSwYbAjVIQCePuHY/ftEEWHRAghpJJSUuTKBw4ciMjISMydOxdhYWFwcHDAuXPn+EbG7969k2pPk5ycjDlz5uDNmzfQ0NBA165d8ffff0NHR0dBW0CyszXTxq9d62D+//yx9MwLNLLSha2ZtqLDIoQQUskotJ8bRaB+bkoWYwxj/n4Ib/9wWOmp4d+JraEhUmgOTQghpAIoF/3ckIqJ4zis6GcHU21VhHxOxJwTz6j9DSGEkFJFyQ0pdjpqKlg/2BFCAYd/fD/h6MMPig6JEEJIJULJDSkRjax0MbVTLQDA3JPPERQRp+CICCGEVBaU3JASM66tNVrV0EdSWgY89z9GclqGokMihBBSCVByQ0qMQMBh9UB76Guo4EVYHBaf9ld0SIQQQioBSm5IiTLUVMXqAQ4AgL133+Hss7zfA0YIIYQUB0puSIlrU8sA49pZAwCmH3uK918SFRwRIYSQioySG1IqpnaqhQZVdRCXnI4JBx4jLUOi6JAIIYRUUJTckFKhLBRg/WBHaKkqwfd9NFZeCFR0SIQQQiooSm5IqTGvoobl/ewAAFuvvcHVwAgFR0QIIaQiouSGlCoXWxMMb24JAPj58BOExyYrOCJCCCEVDSU3pNT92tUGNiZa+JyQiskHfZEhodczEEIIKT6U3JBSp6osxMYhjlBTEeLOm8/480qQokMihBBSgVByQxTC2kADi3rZAgDWXHwJn+AvCo6IEEJIRUHJDVGYvg3N8UMDM0gYMOngY3xNSFV0SIQQQioASm6IQi3qZYvq+uoIjUnGtCNPwBi1vyGEEPJ9KLkhCqUuUsKGIY5QURLg0osIeN0KUXRIhBBCyjlKbojC1TPVxpxuNgCAZWcD8OxDjIIjIoQQUp5RckPKhB+bWcK5nhHSMhg8DzxCXHKaokMihBBSTlFyQ8oEjuOwvK89zHTEePs5EbNP+FH7G0IIIUVCyQ0pM7TVlLF+sAOEAg6nnnzC4QfvFR0SIYSQcoiSG1KmNLTUxc+dawEA5p16jlfhcQqOiBBCSHlDyQ0pc8a2sUbrmvpITpPAc/9jJKdlKDokQggh5QglN6TMEQg4rB7gAH0NEQLD47Dgf/6KDokQQkg5QskNKZMMNEVYO9ABHAcc8HmHf59+UnRIhBBCyglKbkiZ1aqmPsa3swYAzDr2DO8+Jyo4IkIIIeUBJTekTJviVAuNLKsgLiUdEw48Qmq6RNEhEUIIKeMouSFlmpJQgHWDHaEtVsaTDzFYcf6FokMihBBSxlFyQ8o8Mx0xlvezAwBsvxGMyy/CFRwRIYSQsoySG1IuONczhlsLKwDAtCNPERaTrNiACCGElFmU3JByY1bXOqhnqoUvCamYfOgxMiT0egZCCCG5UXJDyg2RkhAbhzSAuooQd998wYbLrxQdEiGEkDKIkhtSrlTTV8fiPrYAgPWXXuHum88KjogQQkhZQ8kNKXf6OJqjX0NzSBgw6eBjfElIVXRIhBBCyhBKbki5tLBXPVgbqCM8NgXTjjwBY9T+hhBCSCZKbki5pKaihI1DGkBFSYDLLyKw42awokMihBBSRlByQ8otGxMt/Na9LgDgj3Mv8OR9tGIDIoQQUiZQckPKtWFNq6KLrTHSMhgmHHiM2OQ0RYdECCFEwSi5IeUax3H4va8dzKuI8e5LIn49/oza3xBCSCVHyQ0p97TFytgw2BFKAg7/Pg3FwfvvFR0SIYQQBaLkhlQIjlWr4Bfn2gCA+aeeIzAsTsEREUIIURRKbkiFMbp1dbSpZYCUdAk89z9CUmqGokMihBCiAJTckApDIOCweoA9DDVFeBURjwX/e67okAghhCiAwpObTZs2wcrKCqqqqmjatCl8fHzyLb927VrUrl0bYrEYFhYWmDJlCpKT6Q3RJJO+hghrBzqA44CD99/j1JNPig6JEEJIKVNocnPo0CFMnToV8+bNw6NHj2Bvbw9nZ2dERETILL9//37MnDkT8+bNQ0BAAHbs2IFDhw7h119/LeXISVnWooY+JrSvAQD49fgzhEQlKDgiQgghpUmhyc3q1asxevRojBgxAnXr1sWWLVugpqaGnTt3yix/+/ZttGzZEkOGDIGVlRU6d+6MwYMHF1jbQyqfiR1roomVLuJT0jHhwGOkpksUHRIhhJBSorDkJjU1FQ8fPoSTk9N/wQgEcHJywp07d2TO06JFCzx8+JBPZt68eYMzZ86ga9euea4nJSUFsbGxUgOp+JSEAqwb7AAdNWU8+xiDP869UHRIhBBCSonCkpuoqChkZGTAyMhIaryRkRHCwsJkzjNkyBAsXLgQrVq1grKyMqytrdGuXbt8b0stW7YM2tra/GBhYVGs20HKLhNtMVb2swcA7LgZjEsB4QqOiBBCSGlQeIPiwrh69SqWLl2KP//8E48ePcLx48dx+vRpLFq0KM95Zs2ahZiYGH54/546eKtMnOoawb1lNQDAz0eeIDQmScEREUIIKWlKilqxvr4+hEIhwsOlf02Hh4fD2NhY5jy//fYbfvzxR4waNQoAUL9+fSQkJGDMmDGYPXs2BILcuZpIJIJIJCr+DSDlxowuteET8hl+H2Mx6YAv9o9uCiVhucrrCSGEFILCvuFVVFTQsGFDXLp0iR8nkUhw6dIlNG/eXOY8iYmJuRIYoVAIAPQ+IZInkZIQGwc3gIZICT4hX7D+cpCiQyKEEFKCFPrzderUqdi+fTt2796NgIAAjBs3DgkJCRgxYgQAYPjw4Zg1axZfvkePHti8eTMOHjyI4OBgeHt747fffkOPHj34JIcQWaz01bGkjy0AYMPlV7j9OkrBERFCCCkpCrstBQADBw5EZGQk5s6di7CwMDg4OODcuXN8I+N3795J1dTMmTMHHMdhzpw5+PjxIwwMDNCjRw8sWbJEUZtAypFeDma4HfQZhx68x+SDvjgzqTX0NeiWJSGEVDQcq2T3c2JjY6GtrY2YmBhoaWkpOhxSyhJT09Fz4y0ERcSjXW0D7HRtDIGAU3RYhBBCClCY6ze1qiSVipqKEjYNaQCRkgBXAyPx1803ig6JEEJIMaPkhlQ6tY01Ma9HPQDA8nOBePzuq4IjIoQQUpwouSGV0uAmFuhmZ4J0CcOEA48Rk5Sm6JAIIYQUE0puSKXEcRyW/VAfFrpifPiahF+PP6PuBAghpIKg5IZUWlqqytgwuAGUBBxOPwvFfp93ig6JEEJIMaDkhlRqDhY6mOFSBwCw8H/+eBFGL1YlhJDyjpIbUumNbFUN7WsbICVdAo99j5CYmq7okAghhHwHSm5IpScQcFjZ3x5GWiK8jkzAT38/REIKJTiEEFJeUXJDCAA9DRE2DmkAsbIQN15FYfD2u4iKT1F0WIQQQoqg0MlNWloalJSU4OfnVxLxEKIwja10cWBMM+iqq+Dphxj023wb7z4nKjosQgghhVTo5EZZWRlVq1ZFRkZGScRDiEI5WOjg6NjmMK8iRsjnRPyw+Tb8PsYoOixCCCGFUKTbUrNnz8avv/6KL1++FHc8hChcdQMNHB/fAnVNtBAVn4KBW+/g5it6izghhJQXRXpxpqOjI4KCgpCWlgZLS0uoq6tLTX/06FGxBVjc6MWZRF5xyWn46e+HuP36M5SFmY2OezmYKTosQgiplApz/VYqygp69+5dlNkIKVc0VZXhNaIxph15iv89+YRJB30RGZeCUa2rKzo0Qggh+ShSzU15RjU3pLAkEobFpwOw81YwAGBMm+qY6VIHAgGn4MgIIaTyKPGamywPHz5EQEAAAKBevXpwdHT8nsURUiYJBBx+624DIy0Rlp19gW3X3yAiNhnL+9lDRYl6UyCEkLKmSMlNREQEBg0ahKtXr0JHRwcAEB0djfbt2+PgwYMwMDAozhgJUTiO4/BTW2sYaIow/ehT/OP7CZ8TUrF5WENoiL7rNwIhhJBiVqSfnRMmTEBcXByeP3+OL1++4MuXL/Dz80NsbCwmTpxY3DESUmb80MAcf7k2gprKt87+tt1FZBx19kcIIWVJkdrcaGtr4+LFi2jcuLHUeB8fH3Tu3BnR0dHFFV+xozY3pDg8eR8N91338TkhFZZ6atjj3gSWeuoFz0gIIaRICnP9LlLNjUQigbKycq7xysrKkEgkRVkkIeWKvYUOjo5rAQtdMd5+TkTfzbfx7AN19kcIIWVBkZKbDh06YNKkSfj06RM/7uPHj5gyZQo6duxYbMERUpZV01fHsXEtUM9UC1HxqRi07Q5uvIpUdFiEEFLpFSm52bhxI2JjY2FlZQVra2tYW1ujWrVqiI2NxYYNG4o7RkLKLENNVRwc0wwta+ghITUDI7zu45/HHxUdFiGEVGpF7ueGMYaLFy/ixYsXAAAbGxs4OTkVa3AlgdrckJKQmi7BtCNPcOpJZm3m7K42GN2GOvsjhJDiUpjrd6GTm7S0NIjFYvj6+sLW1va7AlUESm5ISZFIGJacCcCOm5md/Y1qVQ2/drWhzv4IIaQYlGiDYnorOCGyZXb2Vxezu9oAAP66GYwph32Rmk6N7AkhpDTRW8EJKWaj21THmoH2UBJwOOn7Ce677iM+JV3RYRFCSKVBbwUnpIRcfxmJsXsfIjE1A7ZmWvByawIDTZGiwyKEkHKJ3gpOSBnQppYBDo5phhFe9+H3MRZ9N9/GHvcmsNKnzv4IIaQkFTq5SU9PB8dxcHd3h7m5eUnEREiFYWeug2PjWmD4Th+8+5LZ2Z/XiMawM9dRdGiEEFJhFbrNjZKSElasWIH0dGpDQIg8rL519mdrpoXPCakYtO0urr+kzv4IIaSkFLmH4mvXrhV3LIRUWAaaIhwc0xytaugjMTUD7rvu48TjD4oOixBCKqQitbnp0qULZs6ciWfPnqFhw4a5GhT37NmzWIIjpCLREClhp1tj/HL0CU76fsKUQ08QGZeC0a2rg+OoLxxCCCkuRXpaSiDIu8KH47gy3QcOPS1FFE0iYVh2NgDbb2R29jeyVTXMps7+CCEkX6XyVvC8hrKc2BBSFggEHGZ3+6+zvx03gzH5kC9S0ulvhxBCikOhkpuuXbsiJiaG//z7778jOjqa//z582fUrVu32IIrVxKigLtbAN/9wIvTQMhNIOwZ8PUtkBQNSKiXWiJtdJvqWDvQAcpCDqeeZHb2F5ecpuiwCCGk3CvUbSmhUIjQ0FAYGhoCALS0tODr64vq1TNfEBgeHg5TU9MyXXtTYrelPjwA/uqYTwEOEGkBqlqAqvZ/gyjHZ5nTdTLHC5WLL15SZtx4FYmxfz9EQmoG6plqwWtEYxhqqio6LEIIKVNKrBO/nHlQEV8oXjGpaAD1+gDJMUBy7Ld/vw0ZKQAYkBKTOcS8L9o6lNULmRzpSE9XpgtmWdS6pgEOjmmOEbt88PxTVmd/TVGNOvsjhJAiKdLTUkQGwzpA/12yp6UlAynZE57o3AlQSo7P2aenJXxbTkLmEBdatBiFIjmSI+28p6uoA/RUT4mob67Nd/b39vO3zv7cGsPeQkfRoRFCSLlTqOSG47hcj6zSI6xyUFbNHDQMizZ/RhqQEvctKZKR/BSUHKXEAmCZNUgJkZlDUXDCfG6b5XdbLdv/83nSrrKz1Mvs7G+E1308+xiDwdvv4s+hDdCudhHPG0IIqaQK1eZGIBCgS5cuEIkyX/73v//9Dx06dOD7uUlJScG5c+cqZ5ubskwiAVLj8k5++OQoOu/prDiOKbU7kkd8SjrG7X2IG6+ioCTgsLyfHX5oQK86IYRUboW5fhcquRkxYoRc5by8vORdZKmrlMnN92IMSEvMIzmKLrjmiG93VAwqSbuj1HQJph99gn98PwEAZnapg5/aUGd/hJDKq8SSm4qAkhsFydXuKEZGzVE+yVFWu6PvJU+7I7EOIK6SmRiJq3wbdACRdqneVpNIGH4/9wLbrr8BALi3rIY53aizP0JI5VRiT0sRUmTF3u6oEG2Oiq3dEZeZ5ORMerL+n9/4ItQYCQQcfu1qA0NNERafDsDOW8GIiEvGqgH2ECkJixA/IYRUDmUiudm0aRNWrFiBsLAw2NvbY8OGDWjSpInMsu3atZP50s6uXbvi9OnTJR0qURShMqCmmzkURa52R3kkR0nRmQlUUjSQ9DVzSI7OvC0H9t+4r8GFW7+SOI9kSCf/JEmkhVGtq8NAU4RpR57g36eh+JKQiq0/NoSmasVvf0QIIUWh8OTm0KFDmDp1KrZs2YKmTZti7dq1cHZ2RmBgIN9ZYHbHjx9Hamoq//nz58+wt7dH//79SzNsUt4IBP/ddiqKtGTZSU/W/2WOj878P5MA6UlAXBIQ96lw6+Uy4+4lroIOxhp4EsXh8zt1XFtTBe0dakFdx0B2jVERa4sIIaQiUHibm6ZNm6Jx48bYuHEjgMz3VllYWGDChAmYOXNmgfOvXbsWc+fORWhoaK63k8tCbW5IqZJI/nsSraBESGZt0Xfga4uqSNcQFXRbjR7ZJ4SUQeWmzU1qaioePnyIWbNm8eMEAgGcnJxw584duZaxY8cODBo0KM/EJiUlBSkp/z2pExsb+31BE1IYAsG3BEIHqGJVuHnzqC36GhWO/917DpYUDUPlJLQ0FUIL8dnKxBRLbZFcbYlyjlcSFW5dhBBSAhSa3ERFRSEjIwNGRkZS442MjPDixYsC5/fx8YGfnx927NiRZ5lly5ZhwYIF3x0rIaVOWRVQNgY0jaVGVwHQtVkK3Hfdx9MPMRC/E+LPYQ3QPquzv6zaogJvnUXLri1ikv/GFTpmNRlJj07BSRLVFhFCipHC29x8jx07dqB+/fp5Nj4GgFmzZmHq1Kn859jYWFhYWJRGeISUGH0NEQ6MboZx+x7h+stIjNr9AH/0tUO/hubStUWFVaS2Rdlqi9ISM4ci1RbpyP/0WfbxVFtECMlBocmNvr4+hEIhwsPDpcaHh4fD2Ng4j7kyJSQk4ODBg1i4cGG+5UQiEd+jMiEVibpICTtcG2HG0ac4/vgjph15goi4ZIxra130zv7yqC0qUKFqi3KMT0/6Vlv0JXModMxq0kmPmi6gbf5tsPjvX3V9ejcaIZWEQpMbFRUVNGzYEJcuXULv3r0BZDYovnTpEjw9PfOd98iRI0hJScGwYcNKIVJCyiZloQAr+9vDQEuErdfeYPm5QETEpmBu97ql29lfsdQWZUt6ilJbFPsx//UIRTKSnuyfzQBlceHjJ4SUOQq/LTV16lS4urqiUaNGaNKkCdauXYuEhAT+VQ/Dhw+HmZkZli1bJjXfjh070Lt3b+jp6SkibELKDIGAw6wuNjDUVMWif/2x63YIIuNTsLq8dPZX3LVFCVFAzIdvw/vMf+PCMjtw/PI6c8iLukH+CZC6AdX+EFIOKDy5GThwICIjIzF37lyEhYXBwcEB586d4xsZv3v3DoIcDQ0DAwNx8+ZNXLhwQREhE1ImjWxVDQaaIvx82Benn4biS3wqtg5vCK2K2tlfYWqL0lMz2wHlTHqyhuj3ma/4yOq9+tNj2csRijJrePjkx4JqfwgpgxTez01po35uSEV3KygKP/39EPEp6bAx0cLuEY1hqEUd+uWLfet9OnvCkzMBigsFIMfXpZq+7NofnW/JkJo+PRlGSBHQizPzQckNqQz8PsbAzes+ouJTYKYjxp6RTWBtoKHosMq39NTMBIdPevKo/SlIrtqfHLe+tMwAFbWS3x5CyhlKbvJByQ2pLN5/ScTwnT4IjkpAFTVl7HRrDMeqVRQdVsXFWGbbH6mE513x1v5k/V/dgGp/SKVDyU0+KLkhlcnn+MzO/p58iIFYWYhNQx3RoY5RwTOSkpGRBsTKavvzvpC1PyqZNTxZCY+OBdX+kAqPkpt8UHJDKpuElHSM3/cI115GQijgsOyH+hjQiDqyLJNk1f7IavvDJAUvS00vj1tfVan2h5RLlNzkg5IbUhmlZUgw49hTHH+U2RfML861Mb7dd3T2RxQnz9qfbJ9T4wteTs7aH1n9/qgU/DJiQkoLJTf5oOSGVFaMMSw/H4jNVzP7eXFtbom5PepBWJqd/ZGSx1hmB4eybnsVtvZHrPvfU165kh9zQN2Qan9IqaHkJh+U3JDKzutWMBb+6w/GgK71jbF6gANUlctBZ3+k+GSkfXvyK4+Gz/LW/giUvz35JaPRM9X+kGJGyU0+KLkhBPjfk0/4+fATpGZI0Ky6LrYNb1RxO/sjhSdV+5Oz5ud94Wt/8rr1pWNBtT9EbpTc5IOSG0Iy3Q6Kwphvnf3VMdbEbvcmMKLO/oi8ctb+yOr3JzWu4OXIqv3RMgU0TTJfyaFhnNn4WajwDvWJglFykw9Kbgj5z/NPmZ39RcZldva3270JahhSZ3+kGORb+5PV9ueTfLU/nCCzhkfTONtgAmgY/ZcEaZpkvvldQLdYKypKbvJByQ0h0nJ29rfDrTEaUGd/pDRkpOfu9Tn6feaLTuNCM/9NiJAvAQIATghoGP5X45OV9ORMiugVGOUSJTf5oOSGkNw+x6fAffcDPHkfDVVlAf4c2oA6+yNlgyQj82WmWckOP4QC8eHZkqDIQiZBRrmTnpxJkZoeJUFlCCU3+aDkhhDZElMzO/u7Gvits78+9TGgMXX2R8qJjHTpJCg+WxIUlyMJkucVGAAgUMqWBMm4Dab57bNYl5KgUkDJTT4ouSEkb2kZEsw6/gxHH34AAEzrXAse7WtQZ3+k4shIz7zVVWBNUBTkT4KUc9QEZUt8+NogE0BNF6C/pSIrzPWbmp8TQnjKQgFW9LODoaYIf159jZUXXiIiLgXzqLM/UlEIlTKfxtIyzb9cRhoQH5Et8clZE/Tt/4lRgCQNiP2QOeS7bpXcSZBUbdC3ceIqlAR9J6q5IYTItOtWMBZ86+yvi60x1gykzv4IySU99VtNUFju2qDsCVHiZ/mXKVSR0Sg6xy0xDaNKlwTRbal8UHJDiPxOPw3FlEO+SM2QoEk1XWwf3gjaYursj5BCS0/9dttLxi2w7LfGkr7Iv0yhqOBG0ZpGgKpOhUiCKLnJByU3hBTO7ddR+GnPQ8R96+xv14gmMNamzv4IKRHpKdJJUPbG0NlrgpK+yr9MJdV8boNlS4pEWmU6CaLkJh+U3BBSeP6fYuHm5YMIvrO/xqhhqKnosAipvNKS5asJSo6Wf5lK4vxvg/FJkKZCkiBKbvJByQ0hRfP+SyJcvXzwJjIBOmrK2OHaGA0tqbM/Qsq0tCT5aoKSY+RfprJa/rfBsidBxYiSm3xQckNI0X1JSIX7rvvw/dbZ38bBDeBUlzr7I6TcS0vK+7H47EOKnEmQYT1g/O1iDZGSm3xQckPI90lMTYfHvke48q2zv6V9bDGwcVVFh0UIKQ2piXl3kBifLQkybwz8eLxYV03JTT4ouSHk+6VlSPDr8Wc48q2zv5871YJnB+rsjxDyTUYaICzeJysLc/2m/qIJIYWmLBRgeT87eLavAQBY5f0Sv530Q4akUv1WIoTkpZgTm8Ki5IYQUiQcx2Gac20s7FUPHAfsvfsOHvseITktQ9GhEUIqOUpuCCHfZXhzK2wa0gAqQgHOPQ/D8B0+iElKU3RYhJBKjJIbQsh361rfBLvdm0BTpASfkC8YsOUOQmOSFB0WIaSSouSGEFIsmlvr4fDY5jDSEiEwPA59/7yNV+Fxig6LEFIJUXJDCCk2NiZaODauBaobqONTTDL6bbmDh28L8a4cQggpBpTcEEKKlXkVNRwb2wKOVXUQk5SGIdvvwds/XNFhEUIqEUpuCCHFroq6CvaPaoaOdQyRki7BT38/wAGfd4oOixBSSVByQwgpEWIVIbb+2BADGplDwoBZx59h3cVXqGT9hhJCFICSG0JIiVESCvBHXztM6JDZ2d+aiy8x5x/q7I8QUrIouSGElCiO4/Bz59pY9K2zv3333mHc3ofU2R8hpMRQckMIKRU/NrfCn0MaQEVJgAv+4fhxxz3EJFJnf4SQ4kfJDSGk1HSpb4K/3ZtAU1UJ90O+ov/W2/gUTZ39EUKKFyU3hJBS1bS6Ho586+zvZXg8+m6+jZfU2R8hpBhRckMIKXV1jLVwfHxLWBuoIzQmGf0238aDEOrsjxBSPCi5IYQohJmOGEfHtkCDqjqITU7H0L/u4fzzMEWHRQipACi5IYQoTBV1Fewb1QxONpmd/Y3b+xD77r1VdFiEkHKOkhtCiEKJVYTYMqwhBjW2gIQBs0/4YY33S+rsjxBSZJTcEEIUTkkowLIf6mNix5oAgHWXXuHXE35Iz5AoODJCSHlEyQ0hpEzgOA5TO9XC4t624DjggM87jNv3iDr7I4QUmsKTm02bNsHKygqqqqpo2rQpfHx88i0fHR0NDw8PmJiYQCQSoVatWjhz5kwpRUsIKWnDmlli89DMzv68/cMx7K97iE5MVXRYhJByRKHJzaFDhzB16lTMmzcPjx49gr29PZydnRERESGzfGpqKjp16oSQkBAcPXoUgYGB2L59O8zMzEo5ckJISXKxNcHekU2hpaqEB2+/ov+WO9TZHyFEbhxTYKu9pk2bonHjxti4cSMAQCKRwMLCAhMmTMDMmTNzld+yZQtWrFiBFy9eQFlZuUjrjI2Nhba2NmJiYqClpfVd8RNCSlZgWBxcd/ogLDYZxlqq2DOyCWoZaSo6LEKIAhTm+q2wmpvU1FQ8fPgQTk5O/wUjEMDJyQl37tyROc+pU6fQvHlzeHh4wMjICLa2tli6dCkyMvK+J5+SkoLY2FipgRBSPtQ21sTx8S1Qw1ADYbGZnf35BFNnf4SQ/CksuYmKikJGRgaMjIykxhsZGSEsTHZHXm/evMHRo0eRkZGBM2fO4LfffsOqVauwePHiPNezbNkyaGtr84OFhUWxbgchpGSZ6ohxdGxzNLSsgtjkdAzbcQ/n/KizP0JI3hTeoLgwJBIJDA0NsW3bNjRs2BADBw7E7NmzsWXLljznmTVrFmJiYvjh/fv3pRgxIaQ46KipYN+opnCyMUJqugTj9z3E3rvU2R8hRDaFJTf6+voQCoUIDw+XGh8eHg5jY2OZ85iYmKBWrVoQCoX8OBsbG4SFhSE1VfbTFCKRCFpaWlIDIaT8UVUWYsuwBhjcpCokDJjzjx9WU2d/hBAZFJbcqKiooGHDhrh06RI/TiKR4NKlS2jevLnMeVq2bImgoCBIJP917PXy5UuYmJhARUWlxGMmhCiWklCApX1sMelbZ3/rL73CrOPPqLM/QogUhd6Wmjp1KrZv347du3cjICAA48aNQ0JCAkaMGAEAGD58OGbNmsWXHzduHL58+YJJkybh5cuXOH36NJYuXQoPDw9FbQIhpJRxHIcpnWphSR9bCDjg4P33GLv3EZJSqbM/QkgmJUWufODAgYiMjMTcuXMRFhYGBwcHnDt3jm9k/O7dOwgE/+VfFhYWOH/+PKZMmQI7OzuYmZlh0qRJmDFjhqI2gRCiIEObWkJfQ4QJBx7jYkA4hu24hx2ujaCjRrW4hFR2Cu3nRhGonxtCKpb7IV8wctd9xCano4ahBna7N4GZjljRYRFCilm56OeGEEKKQ2MrXRwd1wIm2qoIiojHD3/ewsO31BcOIZUZJTeEkHKvlpEmjo1rgZqGGgiPTcGArXex4dIrZEgqVcU0IeQbSm4IIRWCqY4Yx8e3QC8HU2RIGFZ5v8SQ7XcRGkPvpCKksqHkhhBSYWiqKmPtQAes6m8PNRUh7gV/QZd1N3D+OfVoTEhlQskNIaRC4TgOfRua4/TE1qhvpo3oxDT89PdD/PaPH5LT6HFxQioDSm4IIRVSNX11HBvXAmPaVAcA/H33LXptvIXAsDgFR0YIKWmU3BBCKiwVJQF+7WqD3e5NoK8hQmB4HHpuvIm9d9/SaxsIqcAouSGEVHhtaxng7KTWaFvLACnpEsz5xw8//f0Q0Ymy30lHCCnfKLkhhFQKBpoieLk1xpxuNlAWcrjgH44u627g7pvPig6NEFLMKLkhhFQaAgGHUa2r48T4lqiur47QmGQM2X4Xqy8E0ss3CalAKLkhhFQ6tmba+N+EVujf0BwSBqy/HISB2+7iw9dERYdGCCkGlNwQQioldZESVvS3x/rBjtAUKeHh26/osu4G/n36SdGhEUK+EyU3hJBKrae9Kc5Mag3HqjqIS06H5/7HmHH0KRJT0xUdGiGkiCi5IYRUeha6ajj8U3N4tq8BjgMOPXiP7htu4vmnGEWHRggpAkpuCCEEgLJQgGnOtbFvVFMYaYnwJjIBfTbdxs6bwdQnDiHlDCU3hBCSTQtrfZyd1AZONkZIzZBg4b/+GLn7AT7Hpyg6NEKInCi5IYSQHHTVVbB9eEMs7FUPKkoCXH4RAZd1N3DzVZSiQyOEyIGSG0IIkYHjOAxvboWTHi1R01ADkXEp+HHnPfx+9gXSqE8cQso0Sm4IISQfNiZaOOXZCkOaVgVjwJZrr9Fv8228/Zyg6NAIIXmg5IYQQgogVhFiaZ/62DKsAbTFynjyIQbd1t/EP48/Kjo0QogMlNwQQoicXGxNcHZSazSx0kV8SjomH/LF1EO+iE+hPnEIKUsouSGEkEIw1RHjwJhmmOJUCwIOOP74I7qvv4En76MVHRoh5BtKbgghpJCEAg6TnGri0E/NYaYjRsjnRPTdfBtbr72GREJ94hCiaJTcEEJIETW20sWZia3Rtb4x0iUMy86+gKuXDyJikxUdGiGVGiU3hBDyHbTVlLFpSAP8/kN9qCoLcONVFLqsu4ErLyIUHRohlRbHKlm/4rGxsdDW1kZMTAy0tLTyLJeeno7U1NRSjIwQUt69/5KAP84GIvjbY+K9HMzg1sISKkpCBUdGSNmgoqICJSWlIs0r7/UbAIq2hgqMMYZ3794hKop6IiWEFJ5HAzEA8bdPKXj96qUiwyGkzNHX10fVqlXBcVyJrYOSmxyyEhszMzNoaGhAIKA7d4QQQsj3kkgkiI+Px8ePH5Geno7q1auXWIJDyU026enpfGJjbGys6HAIIYSQCkVDQwMA8PHjR+zfvx+dOnWCoaFhsa+HqiWyyWpjk7XzCSGEEFK8sq6xX758wb///ovIyMhiXwclNzLQrShCCCGkZGRdY01MTBAaGoqQkJDiX0exL5EQQgghpAAcx0EgECAxMbHYl03JDZGbm5sbevfuregwStz3bmdISAg4joOvr2+xxVRRVJZziBCiWJTcVBBubm7gOA5jx47NNc3DwwMcx8HNzS3fZWzfvh329vbQ0NCAjo4OHB0dsWzZMn76unXrsGvXrmKOPLfdu3ejVatWMqft2rULOjo6Jbr+wmynrIu1hYUFQkNDYWtrW6T1ZyVHWYOuri7atm2LGzduFGl5ZUlpnUPXrl1Dhw4doKurCzU1NdSsWROurq4Vsu+qrPNFKBTi40fpt5SHhoZCSUkJHMeVSNU/IWUVJTcViIWFBQ4ePIikpCR+XHJyMvbv34+qVavmO+/OnTsxefJkTJw4Eb6+vrh16xamT5+O+Ph4voy2tnaJJxYAcPLkSfTs2bPE15OX791OoVAIY2PjIndUleXixYsIDQ3F9evXYWpqiu7duyM8PPy7llmQkr74l8Y55O/vDxcXFzRq1AjXr1/Hs2fPsGHDBqioqCAjI6NE161IZmZm2LNnj9S43bt3w8zMTEERyY8xhvR0erM6KT6U3BSAMYbE1HSFDIXtPLpBgwawsLDA8ePH+XHHjx9H1apV4ejomO+8p06dwoABAzBy5EjUqFED9erVw+DBg7FkyRK+TPZaipy1C1lDu3bt+PI3b95E69atIRaLYWFhgYkTJyIhISHfOJKTk3HhwoUiJzfv3r1Dr169oKGhAS0tLQwYMCBXQrB48WIYGhpCU1MTo0aNwsyZM+Hg4CBzOwHg6NGjqF+/PsRiMfT09ODk5ISEhATMnz8fu3fvxsmTJ/ntv3r1qszbUs+fP0f37t2hpaUFTU1NtG7dGq9fv853W/T09GBsbAxbW1v8+uuviI2Nxb179/jpfn5+6NKlCzQ0NGBkZIQff/xRqvPJuLg4DB06FOrq6jAxMcGaNWvQrl07TJ48mS9jZWWFRYsWYfjw4dDS0sKYMWMAFHzs/vzzT9SsWROqqqowMjJCv379CtxfsvZtSkoKJk6cCENDQ6iqqqJVq1a4f/8+P/3q1avgOA6XLl1Co0aNoKamhhYtWiAwMDDP/XbhwgUYGxtj+fLlsLW1hbW1NVxcXLB9+3aIxZmd682fP1/qmAPA2rVrYWVlJTVu586dqFevHkQiEUxMTODp6clPi46Oxk8//QQjIyOoqqrC1tYW//77Lz+9pPZhXlxdXeHl5SU1zsvLC66urrnKFnTunDt3Dq1atYKOjg709PTQvXt3qfM1NTUVnp6eMDExgaqqKiwtLflaXlnnf3R0NP/3Afx3XM+ePYuGDRtCJBLh5s2bkEgkWLZsGapVqwaxWAx7e3scPXo03+0mRBbq56YASWkZqDv3vELW7b/QGWoqhTtE7u7u8PLywtChQwFkfjmPGDGC/1LJi7GxMa5du4a3b9/C0tKywPVk3XrJEhYWBicnJ7Rp0wYA8Pr1a7i4uGDx4sXYuXMnIiMj4enpCU9Pz1xfwNldunQJZmZmqFOnjhxbK00ikfCJzbVr15Ceng4PDw8MHDiQ3/59+/ZhyZIl+PPPP9GyZUscPHgQq1atQrVq1WQuMzQ0FIMHD8by5cvRp08fxMXF4caNG2CMYdq0aQgICEBsbCy/Tbq6uvj06ZPUMj5+/Ig2bdqgXbt2uHz5MrS0tHDr1i25f6kmJSXxv8hVVFQAZF4sOnTogFGjRmHNmjVISkrCjBkzMGDAAFy+fBkAMHXqVNy6dQunTp2CkZER5s6di0ePHuW6qK9cuRJz587FvHnzABR87B48eICJEyfi77//RosWLfDlyxf+lll++0uW6dOn49ixY9i9ezcsLS2xfPlyODs7IygoCLq6uny52bNnY9WqVTAwMMDYsWPh7u6OW7duyVymsbExX+OVdT4WxebNmzF16lT8/vvv6NKlC2JiYvh1SiQSdOnSBXFxcdi7dy+sra3h7+8PoVBY6vswS8+ePbFlyxbcvHkTrVq1ws2bN/H161f06NEDixYt4svJc+4kJCRg6tSpsLOzQ3x8PObOnYs+ffrA19cXAoEA69evx6lTp3D48GFUrVoV79+/x/v37wu9j2fOnImVK1eievXqqFKlCpYtW4a9e/diy5YtqFmzJq5fv45hw4bBwMAAbdu2LfTySeVFyU0FM2zYMMyaNQtv374FANy6dQsHDx4sMLmZN28efvjhB1hZWaFWrVpo3rw5unbtin79+sl8ND7r1guQWdvSu3dvNG/eHPPnzwcALFu2DEOHDuVrCWrWrIn169ejbdu22Lx5M1RVVWXG8T23pC5duoRnz54hODgYFhYWAIA9e/agXr16uH//Pho3bowNGzZg5MiRGDFiBABg7ty5uHDhgtTtt+xCQ0ORnp6OH374gU/66tevz08Xi8VISUnJt9PHTZs2QVtbGwcPHoSysjIAoFatWgVuT4sWLfgnCRhjaNiwITp27AgA2LhxIxwdHbF06VK+/M6dO2FhYYGXL1/CxMQEu3fvxv79+/l5vLy8YGpqmms9HTp0wM8//8x/HjVqVL7H7t27d1BXV0f37t2hqakJS0tLvmawoP2VXUJCAjZv3oxdu3ahS5cuADLbfXl7e2PHjh345Zdf+LJLlizhL24zZ85Et27dkJycLPM86t+/P86fP4+2bdvC2NgYzZo1Q8eOHfnaKXktXrwYP//8MyZNmsSPa9y4MYDMW4Y+Pj4ICAjgj2X16tX5cgWd/8W1D7NTVlbGsGHDsHPnTrRq1Qo7d+7EsGHD+HMuS0HnTq1atdC3b1+peXbu3AkDAwP4+/vD1tYW7969Q82aNdGqVStwHCfXDyJZFi5ciE6dOgHIrMVbunQpLl68iObNmwPI3Kc3b97E1q1bKbkhhULJTQHEykL4L3RW2LoLy8DAAN26dcOuXbvAGEO3bt2gr69f4HwmJia4c+cO/Pz8cP36ddy+fRuurq7466+/cO7cuXz7/nF3d0dcXBy8vb35ck+ePMHTp0+xb98+vhxjDBKJBMHBwbCxscm1HMYY/ve//+Hw4cOF3m4ACAgIgIWFBZ/YAEDdunWho6ODgIAANG7cGIGBgRg/frzUfE2aNOF/seZkb2+Pjh07on79+nB2dkbnzp3Rr18/VKlSRe64fH190bp161wXmYIcOnQIderUgZ+fH6ZPn45du3bxy3jy5AmuXLkis8PJ169fIykpCWlpaWjSpAk/XltbG7Vr185VvlGjRlKfCzp2nTp1gqWlJapXrw4XFxe4uLigT58+UFNTK9T+ev36NdLS0tCyZUt+nLKyMpo0aYKAgACpsnZ2dvz/TUxMAAAREREy25IJhUJ4eXlh8eLFuHz5Mu7du4elS5fijz/+gI+PDz9/fiIiIvDp0yc+MczJ19cX5ubmeSappbUPc3J3d0eLFi2wdOlSHDlyBHfu3MlVQ1jQuVOrVi28evUKc+fOxb179xAVFQWJRAIg87avra0t3Nzc0KlTJ9SuXRsuLi7o3r07OnfuXGB8OWU/94KCgpCYmMgnO1lSU1MLvK1OSE6U3BSA47hC3xpSNHd3d75twKZNmwo1r62tLWxtbTF+/HiMHTsWrVu3xrVr19C+fXuZ5RcvXozz58/Dx8cHmpqa/Pj4+Hj89NNPmDhxYq558mrc7OPjg/T0dLRo0aJQMZckoVAIb29v3L59GxcuXMCGDRswe/Zs3Lt3L89bWTlltfMoLAsLC9SsWRM1a9ZEeno6+vTpAz8/P4hEIsTHx6NHjx74448/cs1nYmKCoKAgudejrq4u9bmgY6eiooJHjx7h6tWruHDhAubOnYv58+fj/v370NHR+e79JUv2xDDrXTRZF9y8mJmZ4ccff8SPP/6IRYsWoVatWtiyZQsWLFgAgUCQ6zZPWloa//+CjllB0xW1D+vXr486depg8ODBsLGxga2tba4uCQo6dwCgR48esLS0xPbt22FqagqJRAJbW1u+wXmDBg0QHByMs2fP4uLFixgwYACcnJxw9OhR/gdO9v2bfd9ml/3cy6o9PX36dK5G0CKRKN/tJiQnalBcAbm4uCA1NRVpaWlwdi56rVPdunUBIM+GjMeOHcPChQtx+PBhWFtbS01r0KAB/P39UaNGjVxDVruRnE6ePIlu3brx7RYKy8bGJte9f39/f0RHR/PbUrt2bakGqwByfc6J4zi0bNkSCxYswOPHj6GiooITJ04AgFxP4NjZ2eHGjRt5fsHLo1+/flBSUsKff/4JIHP/Pn/+HFZWVrn2r7q6OqpXrw5lZWWpbYuJicHLlwW/oVqeY6ekpAQnJycsX74cT58+RUhICF/7ld/+ys7a2hoqKipSbWfS0tJw//59/ngVlypVqsDExIQ/lw0MDBAWFiZ1Ac6eBGhqasLKygqXLl2SuTw7Ozt8+PAhz/1ZWvtQFnd3d1y9ehXu7u55xpbfufP582cEBgZizpw56NixI2xsbPD169dcy9HS0sLAgQOxfft2HDp0CMeOHcOXL19gYGAAAFJt8uTp86lu3boQiUR49+5drriy18YSIo/yVSVB5CIUCvlqfXkThXHjxsHU1BQdOnSAubk5QkNDsXjxYhgYGPD3v7Pz8/PD8OHDMWPGDNSrVw9hYWEAMi/2urq6mDFjBpo1awZPT0+MGjUK6urq8Pf3h7e3NzZu3CgzhlOnTmHhwoUFxpqRkZHry1IkEsHJyQn169fH0KFDsXbtWqSnp2P8+PFo27YtX/09YcIEjB49Go0aNUKLFi1w6NAhPH36VKq9RHb37t3DpUuX0LlzZxgaGuLevXuIjIzkb6tZWVnh/PnzCAwMhJ6eHrS1tXMtw9PTExs2bMCgQYMwa9YsaGtr4+7du2jSpInM20SycByHiRMnYv78+fjpp5/g4eGB7du3Y/DgwZg+fTp0dXURFBSEgwcP4q+//oKmpiZcXV3xyy+/QFdXF4aGhpg3bx4EAkGBb+Et6Nj9+++/ePPmDdq0aYMqVargzJkzkEgkqF27doH7Kzt1dXWMGzeOj7Fq1apYvnw5EhMTMXLkSLn2iyxbt26Fr68v+vTpA2trayQnJ2PPnj14/vw5NmzYAABo164dIiMjsXz5cvTr1w/nzp3D2bNnpdrkzJ8/H2PHjoWhoSHfePjWrVuYMGEC2rZtizZt2qBv375YvXo1atSogRcvXoDjOLi4uJTaPpRl9OjR6N+/f56P3Bd07lSpUgV6enrYtm0bTExM8O7dO8ycOVNqGatXr4aJiQkcHR0hEAhw5MgRGBsbQ0dHBwKBAM2aNcPvv/+OatWqISIiAnPmzCkwbk1NTUybNg1TpkyBRCJBq1at+EbcWlpaMp/6IiRPrJKJiYlhAFhMTEyuaQkJCezBgwcsISFBAZF9H1dXV9arV688p/fq1Yu5urrmOf3o0aOsa9euzMTEhKmoqDBTU1PWt29f9vTpU5nr8PLyYgByDW3btuXL+/j4sE6dOjENDQ2mrq7O7Ozs2JIlS2SuPygoiIlEIhYfH5/vdua1Xmtra8YYY2/fvmU9e/Zk6urqTFNTk/Xv35+FhYVJLWPhwoVMX1+faWhoMHd3dzZx4kTWrFkzmdvp7+/PnJ2dmYGBAROJRKxWrVpsw4YNfNmIiAh+GwGwK1eusODgYAaAPX78mC/35MkT1rlzZ6ampsY0NTVZ69at2evXr2Vuo6z5Gcs8P6tUqcL++OMPxhhjL1++ZH369GE6OjpMLBazOnXqsMmTJzOJRMIYYyw2NpYNGTKEqampMWNjY7Z69WrWpEkTNnPmTH6ZlpaWbM2aNbliyO/Y3bhxg7Vt25ZVqVKFicViZmdnxw4dOiTX/sp5niYlJbEJEyYwfX19JhKJWMuWLZmPjw8//cqVKwwA+/r1Kz/u8ePHDAALDg6Wuf8ePXrEhg0bxqpVq8ZEIhHT09Njbdq0YadOnZIqt3nzZmZhYcHU1dXZ8OHD2ZIlS5ilpaVUmS1btrDatWszZWVlZmJiwiZMmMBP+/z5MxsxYgTT09NjqqqqzNbWlv37778lvg9zyut8yW9/FXTueHt7MxsbGyYSiZidnR27evUqA8BOnDjBGGNs27ZtzMHBgamrqzMtLS3WsWNH9ujRI375/v7+rHnz5kwsFjMHBwd24cIF/u+DMdnHlTHGJBIJW7t2Lb/PDQwMmLOzM7t27Vqe20/Kn6xr7dGjR9nSpUvZ1atX5Zovv+t3ThxjhexMpQRs2rQJK1asQFhYGOzt7bFhwwaphpDZ7dq1i3/SJYtIJEJycrJc64qNjYW2tjZiYmJyPTmRmJiIgIAA2NjYQE1NrWgbQ4pk9erVuHjxIs6cOVPq6+7UqROMjY3x999/l/q6S1NCQgLMzMywatWq76oZIYSQ75F1rQ0JCcHLly/RokULuZ6Gy+/6nZPCb0sdOnQIU6dOxZYtW9C0aVOsXbsWzs7OCAwMhKGhocx5tLS0pDrxKqianZR95ubmmDVrVomvJzExEVu2bIGzszOEQiEOHDiAixcvwtvbu8TXXdoeP36MFy9eoEmTJoiJieFv+fXq1UvBkRFCSMlSeHKzevVqjB49mq+N2bJlC06fPo2dO3fmus+bheO4fPsVIeXPgAEDSmU9HMfhzJkzWLJkCZKTk1G7dm0cO3YMTk5OpbL+0rZy5UoEBgZCRUUFDRs2xI0bN+TqGoAQQsozhSY3qampePjwodQvdoFAACcnJ9y5cyfP+eLj42FpaQmJRIIGDRpg6dKlqFevnsyyKSkpSElJ4T/HxsYW3waQckcsFuPixYuKDqNUODo64uHDh4oOgxBCSp1CHwWPiopCRkYGjIyMpMYbGRnxT9/kVLt2bezcuRMnT57E3r17IZFI0KJFC3z48EFm+WXLlkFbW5sf6JFCQgghpGIrd/3cNG/eHMOHD4eDgwPatm2L48ePw8DAAFu3bpVZftasWYiJieGHorz/hBBCCCHlh0JvS+nr60MoFOZ6a3N4eLjcbWqUlZXh6OiYZ4+sIpGIerckhBBCKhGF1txkNXLM3guoRCLBpUuXZHYcJ0tGRgaePXsm1/tiCCGEEFLxKfxpqalTp8LV1RWNGjVCkyZNsHbtWiQkJPBPTw0fPhxmZmZYtmwZgMy3yDZr1gw1atRAdHQ0VqxYgbdv32LUqFGK3AxCCCGElBEKT24GDhyIyMhIzJ07F2FhYXBwcMC5c+f4Rsbv3r2TeiP1169fMXr0aISFhaFKlSpo2LAhbt++XezvoiGEEEJI+VQmeiguTdRDcdG5ubkhOjoa//zzj6JDKXW7du3C5MmTER0dDSDzvUP//POPXC8EJIQQ8p/S6KG43D0tRWRzc3MDx3EYO3ZsrmkeHh7gOA5ubm75LmP79u2wt7eHhoYGdHR04OjoyN8OBIB169Zh165dxRx5brt370arVq3ynJ6amooVK1agQYMGUFdXh7a2Nuzt7TFnzhx8+vSpxOMDgGnTpuX5xuii2rVrV54vO8xZjuM4cBwHoVCIKlWqoGnTpli4cCFiYmKKNaaSdvXqVXAcxyeN+Sno/KxIso6xrJdlHjlyBBzHwcrKqvQDI6ScoOSmArGwsMDBgweRlJTEj0tOTsb+/ftRtWrVfOfduXMnJk+ejIkTJ8LX1xe3bt3C9OnTER8fz5fR1taW6+L7vU6ePImePXvKnJaSkoJOnTph6dKlcHNzw/Xr1/Hs2TOsX78eUVFR/FufZUlNTS22GDU0NKCnp1dsyyssLS0thIaG4sOHD7h9+zbGjBmDPXv2wMHBodQSvNIkz/lZ0airqyMiIiJXh6Y7duwo8O+5LCjOvzdCCu173uxZHhX6reASCWMp8YoZvr2hVx5Zb1u2tbVle/fu5cfv27eP2dnZFfhW8F69ejE3Nze51sHYf28izjlkfyv4jRs3WKtWrZiqqiozNzdnEyZMKPCt30lJSUxdXZ0FBATInL5s2TImEAik3kCcnSTbPmvbti3z8PBgkyZNYnp6eqxdu3aMMcZWrVrFbG1tmZqaGjM3N2fjxo1jcXFxUsvx8vJiFhYWTCwWs969e7OVK1cybW1tfvq8efOYvb291Dzbt29nderUYSKRiNWuXZtt2rSJn5a1v44dO8batWvHvwn69u3bjLH/3pKcfZg3b57MbfTy8pKKJUt4eDjT19dnQ4cO5cdlZGSwpUuXMisrK6aqqsrs7OzYkSNH+OlfvnxhQ4YMYfr6+kxVVZXVqFGD7dy5k5/+/v17NmjQIFalShWmpqbGGjZsyO7evctP/+eff5ijoyMTiUSsWrVqbP78+SwtLY2fDoBt376d9e7dm4nFYlajRg128uRJqX2SfcjrHJXn/Gzbti2bNGlSrvmyLzM5OZlNnz6dmZubMxUVFWZtbc3++usvfrqfnx/r1q0b09TUZBoaGqxVq1YsKCiIn57fMU5JSWEeHh7M2NiYiUQiVrVqVbZ06VLGWOZ5OW/ePGZhYcFUVFRyvWE8p6xj7OnpyUaNGsWPf//+PROJRGzmzJm53mBe0LEo6LwPCQlh3bt3Zzo6OkxNTY3VrVuXnT59Wiqe7E6cOMGyX0Ky/ia2b9/OrKysGMdxjDHGvn79ykaOHMn09fWZpqYma9++PfP19c1z20nFVxpvBVd4g+IyLy0RWGqqmHX/+glQUS/ULO7u7vDy8sLQoUMBZP7iHTFiBK5evZrvfMbGxrh27Rrevn0LS0vLAtdjYWGB0NBQ/nNYWBicnJzQpk0bAMDr16/h4uKCxYsXY+fOnYiMjISnpyc8PT3h5eWV53IvXboEMzMz1KlTR+b0AwcOoFOnTnB0dJQ5PedLVHfv3o1x48bh1q1b/DiBQID169ejWrVqePPmDcaPH4/p06fjzz//BADcu3cPI0eOxLJly9C7d2+cO3cO8+bNy3d/7Nu3D3PnzsXGjRvh6OiIx48fY/To0VBXV4erqytfbvbs2Vi5ciVq1qyJ2bNnY/DgwQgKCkKLFi2wdu1azJ07l38prIaGRr7rzMnQ0BBDhw7Fzp07kZGRAaFQiGXLlmHv3r3YsmULatasievXr2PYsGEwMDBA27Zt8dtvv8Hf3x9nz56Fvr4+goKC+Jq/+Ph4tG3bFmZmZjh16hSMjY3x6NEjSCQSAMCNGzcwfPhwrF+/Hq1bt8br168xZswYAJDaXwsWLMDy5cuxYsUKbNiwAUOHDsXbt29hYWGBY8eOoW/fvggMDISWlhbEYrHMbSvs+ZmX4cOH486dO1i/fj3s7e0RHByMqKgoAMDHjx/Rpk0btGvXDpcvX4aWlhZu3bqF9PR0AAUf4/Xr1+PUqVM4fPgwqlativfv3/Odhh47dgxr1qzBwYMHUa9ePYSFheHJkycFxuvu7o527dph3bp1UFNTw65du+Di4pKrV3d5jkVB572HhwdSU1Nx/fp1qKurw9/fv9DnYFBQEI4dO4bjx49DKBQCAPr37w+xWIyzZ89CW1sbW7duRceOHfHy5Uvo6uoWavmEyO17M7DyptA1NynxjM3TUsyQkn8tR3ZZtSoRERFMJBKxkJAQFhISwlRVVVlkZGSBNTefPn1izZo1YwBYrVq1mKurKzt06BDLyMjItY6ckpKSWNOmTVn37t358iNHjmRjxoyRKnfjxg0mEAhYUlJSnnGMHj2aTZs2Lc/pqqqqbOLEiVLjevfuzdTV1Zm6ujpr3rw5P75t27bM0dExz2VlOXLkCNPT0+M/Dx48mHXt2lWqzMCBA/OtubG2tmb79++XmmfRokV8PFm1FNlrCZ4/f84A8LVUedXI5JRfuc2bNzMALDw8nCUnJzM1NTW+dijLyJEj2eDBgxljjPXo0YONGDFC5rK2bt3KNDU12efPn2VO79ixI18zkeXvv/9mJiYm/GcAbM6cOfzn+Ph4BoCdPXuWMfZfjdXXr1/z3WZ5zs+Cam4CAwMZAObt7S1zHbNmzWLVqlVjqampMqcXdIwnTJjAOnToIFV7mGXVqlWsVq1aeS47p+zH2MHBge3evZtJJBJmbW3NTp48ydasWSNVcyPPscgp53lfv359Nn/+/ALjySKr5kZZWZlFRETw427cuMG0tLRYcnKy1LzW1tZs69atecZGKjaquSkLlNUya1AUte5CMjAwQLdu3bBr1y4wxtCtWze53gJtYmKCO3fuwM/PD9evX8ft27fh6uqKv/76C+fOnZN6HD8nd3d3xMXFwdvbmy/35MkTPH36FPv27ePLMcYgkUgQHBwss6EkYwz/+9//cPjw4UJt859//omEhASsX78e169fl5rWsGHDXOUvXryIZcuW4cWLF4iNjUV6ejqSk5ORmJgINTU1BAQEoE+fPlLzNG/eHOfOnZO5/oSEBLx+/RojR47E6NGj+fHp6enQ1taWKmtnZ8f/P6vjyYiIiDxrqgqLfXv4keM4BAUFITExEZ06dZIqk5qaytd8jRs3Dn379sWjR4/QuXNn9O7dGy1atAAA+Pr6wtHRMc9f10+ePMGtW7ewZMkSflxGRobUvsy5zerq6tDS0kJEREShtut7zs8svr6+EAqFeT6V4evri9atW0NZWTnXNHmOsZubGzp16oTatWvDxcUF3bt3R+fOnQFk1l6sXbsW1atXh4uLC7p27YoePXpASangr+Cs2tiqVasiISEBXbt2xcaNG6XKyHMsCjrvJ06ciHHjxuHChQtwcnJC3759pY6dPCwtLWFgYCAVV3x8fK72aUlJSXj9+nWhlk1IYVByUxCOK/StIUVzd3eHp6cnAGDTpk2FmtfW1ha2trYYP348xo4di9atW+PatWto3769zPKLFy/G+fPn4ePjA01NTX58fHw8fvrpJ0ycODHXPHk1hvTx8UF6ejp/cZWlZs2a/G2bLFlJgqyLsLq69LELCQlB9+7dMW7cOCxZsgS6urq4efMmRo4cidTU1CJ1AZDVqHX79u1o2rSp1LSsqvks2S+cWbfQsm7zFIeAgABoaWlBT08Pb968AQCcPn0aZmZmUuWyXknSpUsXvH37FmfOnIG3tzc6duwIDw8PrFy5Ms9bRFni4+OxYMEC/PDDD7mmqaqq8v/PmSxwHFfkbc7v/BQIBHxylyUtLY3/f0Hbk990eY5xgwYNEBwcjLNnz+LixYsYMGAAnJyccPToUVhYWCAwMBAXL16Et7c3xo8fjxUrVuDatWsyk6nshg4diunTp2P+/Pn48ccfZSZEBR0Lec77UaNGwdnZGadPn8aFCxewbNkyrFq1ChMmTChw32bJ+fcWHx8PExMTmbfFS+PhBFJ5UXJTAbm4uCA1NRUcx8HZ2bnIy8nqGDEhIUHm9GPHjmHhwoU4e/YsrK2tpaY1aNAA/v7+qFGjhtzrO3nyJLp165YrIchu8ODBmDNnDh4/fpxnu5v8PHz4EBKJBKtWreJ/7eesKbKxscG9e/ekxt29ezfPZRoZGcHU1BRv3rzh2zoVhYqKCjIyMoo8f0REBPbv34/evXtDIBCgbt26EIlEePfuXb59SBgYGMDV1RWurq5o3bo1fvnlF6xcuRJ2dnb466+/8OXLF5mJY4MGDRAYGFioY5yTiooKABRpu3OenwYGBlLtwDIyMuDn58cn5vXr14dEIsG1a9fg5OSUa3l2dnbYvXs30tLSciUc8h5jLS0tDBw4EAMHDkS/fv3g4uLC7z+xWIwePXqgR48e8PDwQJ06dfDs2TM0aNAg3+3U1dVFz549cfjwYWzZskVmmYKOhTznPZDZlm7s2LEYO3YsZs2ahe3bt2PChAkwMDBAXFwcEhIS+ARGnj6eGjRogLCwMCgpKdGj66RUUXJTAQmFQgQEBPD/l8e4ceNgamqKDh06wNzcHKGhoVi8eDEMDAxkvufLz88Pw4cPx4wZM/gGkkDmxUpXVxczZsxAs2bN4OnpiVGjRvENFL29vXNVqWc5deoUFi5cmG+cU6ZMwenTp9GxY0fMmzcPrVu3RpUqVfDy5UucPXu2wO2tUaMG0tLSsGHDBvTo0QO3bt3KdcGYOHEiWrZsiZUrV6JXr144f/58nreksixYsAATJ06EtrY2XFxckJKSggcPHuDr16+YOnVqvvNmsbKyQnx8PC5dugR7e3uoqanlWZPEGENYWBgYY4iOjsadO3ewdOlSaGtr4/fffwcAaGpqYtq0aZgyZQokEglatWqFmJgY3Lp1C1paWnB1dcXcuXPRsGFD1KtXDykpKfj333/5W4aDBw/G0qVL0bt3byxbtgwmJiZ4/PgxTE1N0bx5c8ydOxfdu3dH1apV0a9fPwgEAjx58gR+fn5YvHixXNtsaWkJjuPw77//omvXrhCLxTIbscpzfnbo0AFTp07F6dOnYW1tjdWrV0v1n2NlZQVXV1e4u7vzDYrfvn2LiIgIDBgwAJ6entiwYQMGDRqEWbNmQVtbG3fv3kWTJk1Qu3btAo/x6tWrYWJiAkdHRwgEAhw5cgTGxsbQ0dHBrl27kJGRgaZNm0JNTQ179+6FWCyWu3H0rl278Oeff+bZ/UBBx0Ke837y5Mno0qULatWqha9fv+LKlSv8uZAV96+//oqJEyfi3r17cvV55eTkhObNm6N3795Yvnw5atWqhU+fPuH06dPo06cPGjVqJNf2E1JoRW0QVF4VukFxOZFXY98sBTUoPnr0KOvatSszMTFhKioqzNTUlPXt25c9ffpU5jq8vLwKfBTcx8eHderUiWloaDB1dXVmZ2fHlixZInP9QUFBTCQSFfioOGOZj/P+/vvvzN7enonFYiYSiVidOnXYlClT2Lt37/hyshqYMsbY6tWrmYmJCROLxczZ2Znt2bMnV6PWHTt2MHNzcyYWi1mPHj3kehR83759zMHBgamoqLAqVaqwNm3asOPHjzPG/mtQ/PjxY778169fGQB25coVftzYsWOZnp5egY+CZ+1vjuOYtrY2a9KkCVu4cGGu81oikbC1a9ey2rVrM2VlZWZgYMCcnZ3ZtWvXGGOZDWJtbGyYWCxmurq6rFevXuzNmzf8/CEhIaxv375MS0uLqampsUaNGrF79+7x08+dO8datGjBxGIx09LSYk2aNGHbtm3jpwNgJ06ckIpJW1ubeXl58Z8XLlzIjI2NGcdxeZ6j8pyfqampbNy4cUxXV5cZGhqyZcuW5Trvk5KS2JQpU/jl5Hz0/cmTJ6xz585MTU2NaWpqstatW7PXr1/z0/M7xtu2bWMODg5MXV2daWlpsY4dO/JdFpw4cYI1bdqUaWlpMXV1ddasWTN28eJFmdvKWMGNy3M2KGas4GNR0Hnv6enJrK2tmUgkYgYGBuzHH39kUVFR/PwnTpxgNWrUYGKxmHXv3p1t27ZN5qPgOcXGxrIJEyYwU1NTpqyszCwsLNjQoUOl/lZJ5VIaDYrp9QvZ0OsXFGf16tW4ePEizpw5o+hQCCGElCB6/QKpNMzNzTFr1ixFh0EIIaQCoDY3pEwYMGCAokMghBBSQVDNDSGEEEIqFEpuCCGEEFKhUHJDCCGEkAqFkhtCCCGEVCiU3BBCCCGkQqHkhhBCCCEVCiU3hBBCCKlQKLkhcnNzc0Pv3r0VHYZChISEgOM4uV4WWBHW+71yxn316lVwHCf1ridS8nbs2IHOnTsrOgycO3cODg4ORX4bPCGFRclNBeHm5gaO4zB27Nhc0zw8PMBxHNzc3PJdxvbt22Fvbw8NDQ3o6OjA0dERy5Yt46evW7dOrpflfa/du3ejVatWMqdlZGTg999/R506dSAWi6Grq4umTZvir7/+4su0a9cOkydPLvE4i5us5NHCwgKhoaGwtbX9rmUfO3YMHTp0QJUqVSAWi1G7dm24u7vj8ePH37VcebVo0QKhoaHQ1tYutmXKm/hllcsaNDU1Ua9ePXh4eODVq1fFFk9p4TgO//zzT4HlkpOT8dtvv2HevHn8uMTERMyaNQvW1tZQVVWFgYEB2rZti5MnT0rNGxQUBHd3d1StWhUikQhmZmbo2LEj9u3bh/T0dKlYsgZ1dXXUrFkTbm5uePjwodTyXFxcoKysjH379uUbs7zxVRTF8b1NZKPkpgKxsLDAwYMHkZSUxI9LTk7G/v37UbVq1Xzn3blzJyZPnoyJEyfC19cXt27dwvTp0xEfH8+X0dbWho6OTkmFzzt58iR69uwpc9qCBQuwZs0aLFq0CP7+/rhy5QrGjBlTYWsEhEIhjI2NoaRU9M7EZ8yYgYEDB8LBwQGnTp1CYGAg9u/fj+rVq+f7yovU1NQirzMnFRUVGBsbg+O4YltmYV28eBGhoaF48uQJli5dioCAANjb2+PSpUsKi6kkHT16FFpaWmjZsiU/buzYsTh+/Dg2bNiAFy9e4Ny5c+jXrx8+f/7Ml/Hx8UGDBg0QEBCATZs2wc/PD1evXsWoUaOwefNmPH/+XGo9Xl5eCA0NxfPnz7Fp0ybEx8ejadOm2LNnj1Q5Nzc3rF+/Pt+Y5Ymvovme7+2yoDi/J4rV973bs/wp7FvBJRIJS0hNUMggkUjk3q6sN3bb2tqyvXv38uP37dvH7OzsCnwreK9evZibm5tc62Dsv7dc5xyyvxX8xo0brFWrVkxVVZWZm5uzCRMmFPjW76SkJKaurs4CAgJkTre3t2fz58/PN8acMQUHBzPGGLt69Spr3LgxU1FRYcbGxmzGjBksLS2NnzcjI4P98ccfzNramqmoqDALCwu2ePFiqe09duwYa9euHROLxczOzo7dvn2bnz8qKooNGjSImZqaMrFYzGxtbdn+/ful4jty5AiztbVlqqqqTFdXl3Xs2JHFx8ezefPm5Yr7ypUrMt8m7ufnx7p168Y0NTWZhoYGa9WqFQsKCpK5P+7cucMAsHXr1smcnv0cy3qr8/bt25mVlRXjOI4xxtjZs2dZy5Ytmba2NtPV1WXdunXLtb579+4xBwcHJhKJWMOGDdnx48el4r5y5UquN68XdH5YWlqyJUuWsBEjRjANDQ1mYWHBtm7dyk/P79zLTtY+ZCzzeLdr145ZWlqy9PR0fvw///zDHB0dmUgkYtWqVWPz58/nzxOJRMLmzZvHLCwsmIqKCjMxMWETJkzg501OTmbTp09n5ubmTEVFhVlbW7O//vqLn/7s2TPm4uLC1NXVmaGhIRs2bBiLjIzkp7dt25ZNmDCB/fLLL6xKlSrMyMhI6u3wlpaWUtuc883g2XXr1o1NmzZNapy2tjbbtWtXnvNIJBJmY2PDGjZsyDIyMvIskwUy3vrOGGPDhw9nmpqa7MuXL/y4t2/fMgB5nqvyxJfXOnO+af79+/ds0KBBrEqVKkxNTY01bNiQ3b17l59+6tQp1qhRIyYSiZienh7r3bs3Py05OZn9/PPPzNTUlKmpqbEmTZqwK1eu8NNDQkJY9+7dmY6ODlNTU2N169Zlp0+fZowx9uXLFzZkyBCmr6/PVFVVc711PqfCfm9nZGSwpUuXMisrK6aqqsrs7OzYkSNH+Onp6enM3d2dn16rVi22du1aqXVeuXKFNW7cmKmpqTFtbW3WokULFhISIhVPdpMmTZL622rbti3z8PBgkyZNYnp6eqxdu3aMsYLP7exK463g9G6pAiSlJ6Hp/qYKWfe9Ifegply4t5O7u7vDy8sLQ4cOBZBZIzNixAhcvXo13/mMjY1x7do1vH37FpaWlgWuJ+t2SZawsDA4OTmhTZs2AIDXr1/DxcUFixcvxs6dOxEZGQlPT094enrCy8srz+VeunQJZmZmqFOnTp5xXr58GePHj4eBgUGu6evWrcPLly9ha2uLhQsXAgAMDAzw8eNHdO3aFW5ubtizZw9evHiB0aNHQ1VVFfPnzwcAzJo1C9u3b8eaNWvQqlUrhIaG4sWLF1LLnz17NlauXImaNWti9uzZGDx4MIKCgqCkpITk5GQ0bNgQM2bMgJaWFk6fPo0ff/wR1tbWaNKkCUJDQzF48GAsX74cffr0QVxcHG7cuAHGGKZNm4aAgADExsby+0dXVxefPn2SWv/Hjx/Rpk0btGvXDpcvX4aWlhZu3boldasguwMHDkBDQwPjx4+XOT1nTUpQUBCOHTuG48ePQygUAgASEhIwdepU2NnZIT4+HnPnzkWfPn3g6+sLgUCA+Ph4dO/eHZ06dcLevXsRHByMSZMmyVxfFnnPj1WrVmHRokX49ddfcfToUYwbNw5t27ZF7dq14ePjgyZNmuDixYuoV68eVFRU8l1nTgKBAJMmTUKfPn3w8OFDNGnSBDdu3MDw4cOxfv16tG7dGq9fv8aYMWMAAPPmzcOxY8ewZs0aHDx4EPXq1UNYWBiePHnCL3P48OG4c+cO1q9fD3t7ewQHByMqKgoAEB0djQ4dOmDUqFFYs2YNkpKSMGPGDAwYMACXL1/ml7F7925MnToV9+7dw507d+Dm5oaWLVuiU6dOuH//PgwNDeHl5QUXFxf+GMly8+ZN/Pjjj1LjjI2NcebMGfzwww/Q1NTMNY+vry8CAgJw4MABCASyK/blqX2bMmUK9uzZA29vb/69cVWrVoWRkRFu3LgBa2trmfMVFJ884uPj0bZtW5iZmeHUqVMwNjbGo0eP+PY+p0+fRp8+fTB79mzs2bMHqampOHPmDD+/p6cn/P39cfDgQZiamuLEiRNwcXHBs2fPULNmTXh4eCA1NRXXr1+Huro6/P39oaGhAQD47bff4O/vj7Nnz0JfXx9BQUFSNTJ5kfd7e9myZdi7dy+2bNmCmjVr4vr16xg2bBh/+04ikcDc3BxHjhyBnp4ebt++jTFjxsDExAQDBgxAeno6evfujdGjR+PAgQNITU2Fj49PoWtUd+/ejXHjxuHWrVsA5D+3S5Vc6VIFUtiam4TUBGa7y1YhQ0JqQq4Y85KVcUdERDCRSMRCQkJYSEgIU1VVZZGRkQXW3Hz69Ik1a9aMAWC1atVirq6u7NChQ1K/3mRl9Yxl1rY0bdqUde/enS8/cuRINmbMGKlyN27cYAKBgCUlJeUZx+jRo3P92szu+fPnzMbGhgkEAla/fn32008/sTNnzkiVadu2LZs0aZLUuF9//ZXVrl1b6lfnpk2bmIaGBsvIyGCxsbFMJBKx7du3y1xv1q//7L/Cnz9/zgDkWcvEWOav559//pkxxtjDhw8ZAP5XUk6y9m/OWodZs2axatWqsdTU1DzXmZ2Liwuzs7OTGrdq1Sqmrq7OD9HR0YyxzJobZWVlFhERke8yIyMjGQD27NkzxhhjW7duZXp6elLHdfPmzfnW3MhzflhaWrJhw4bx0yUSCTM0NGSbN2+WuW/ykl+5gIAABoAdOnSIMcZYx44d2dKlS6XK/P3338zExIQxlrnvatWqJXP/BwYGMgDM29tbZhyLFi1inTt3lhr3/v17BoAFBgYyxjLP3VatWkmVady4MZsxYwb/GXnUlmT39etXBoBdv35davy1a9eYubk5U1ZWZo0aNWKTJ09mN2/e5KcfPHiQAWCPHj3ix4WHh0udL5s2bSowlqSkJAaA/fHHH1LjHR0d8615LSi+vNaZveZm69atTFNTk33+/FnmOpo3b86GDh0qc9rbt2+ZUChkHz9+lBrfsWNHNmvWLMYYY/Xr189zG3r06MFGjBiR5/blVJjv7eTkZKampiZVW8xY5t/S4MGD81yHh4cH69u3L2OMsc+fPzMAedaUyFtz4+joKFVGnnM7O6q5KQPESmLcG3JPYesuLAMDA3Tr1g27du0CYwzdunWDvr5+gfOZmJjgzp078PPzw/Xr13H79m24urrir7/+wrlz5/L8FQdk/uqIi4uDt7c3X+7Jkyd4+vSpVANCxhgkEgmCg4NhY2OTazmMMfzvf//D4cOH81xX3bp14efnh4cPH+LWrVu4fv06evToATc3N6lGxTkFBASgefPmUr9QWrZsifj4eHz48AFhYWFISUlBx44d891PdnZ2/P9NTEwAABEREahTpw4yMjKwdOlSHD58GB8/fkRqaipSUlKgppZZ+2Zvb4+OHTuifv36cHZ2RufOndGvXz9UqVIl33Vm5+vri9atW0NZWVnueXJyd3dHz549ce/ePQwbNgyMMX6apaVlrhqxV69eYe7cubh37x6ioqL4X8Dv3r2Dra0tAgICYGdnB1VVVX6e5s2b5xuDvOdH9v3NcRyMjY0RERFR5G3PKWvbs86LJ0+e4NatW1iyZAlfJiMjA8nJyUhMTET//v2xdu1aVK9eHS4uLujatSt69OgBJSUl+Pr6QigUom3btnlu85UrV/hf+dm9fv0atWrVyrXNQOZ5VthtzqotyH5MAKBNmzZ48+YN7t69i9u3b+PSpUtYt24dFixYgN9++03msvT09PhG2+3atZOrjUXO/ZpFLBYjMTExz/mKEl9Ovr6+cHR0hK6ubp7TR48eLXPas2fPkJGRwR+LLCkpKdDT0wMATJw4EePGjcOFCxfg5OSEvn378sds3Lhx6Nu3Lx49eoTOnTujd+/eaNGiRYExy/O9HRQUhMTERHTq1ElqfGpqKhwdHfnPmzZtws6dO/Hu3TskJSUhNTUVDg4OADJrg93c3ODs7IxOnTrByckJAwYM4L/L5NWwYUOpz/Ke26WJkpsCcBxX6FtDiubu7g5PT08AmSd6Ydja2sLW1hbjx4/H2LFj0bp1a1y7dg3t27eXWX7x4sU4f/48fHx8pKqR4+Pj8dNPP2HixIm55smrkZyPjw/S09ML/DIQCARo3LgxGjdujMmTJ2Pv3r348ccfMXv2bFSrVq0QW/sfsVi+RDJ7UpH1xZ11sV+xYgXWrVuHtWvXon79+lBXV8fkyZP5i4FQKIS3tzdu376NCxcuYMOGDZg9ezbu3bsnd9zyxpmlZs2auHnzJtLS0vjYdXR0oKOjgw8fPuQqr66unmtcjx49YGlpie3bt8PU1BQSiQS2trbf1ZBQ3vMjZxLHcVyxPk4cEBAAAPz+j4+Px4IFC/DDDz/kKquqqgoLCwsEBgbi4sWL8Pb2xvjx47FixQpcu3atwGMTHx+PHj164I8//sg1LfvFpTi2WU9PDxzH4evXr7mmKSsro3Xr1mjdujVmzJiBxYsXY+HChZgxYwZq1qwJAAgMDOQvmEKhEDVq1AAAuRu259yvWb58+SLzdrK88amoqIDjOKmEHADS0tL4/xd0HPKbHh8fD6FQiIcPH+a65Zd14R41ahScnZ1x+vRpXLhwAcuWLcOqVaswYcIEdOnSBW/fvsWZM2fg7e2Njh07wsPDAytXrsw3JqDg7+2shztOnz4NMzMzqWkikQgAcPDgQUybNg2rVq1C8+bNoampiRUrVuDevf9+oHt5eWHixIk4d+4cDh06hDlz5sDb2xvNmjWDQCDId99myfk9Ie+5XZroaakKyMXFBampqUhLS4Ozs3ORl1O3bl0AmW0uZDl27BgWLlyIw4cP57qH3qBBA/j7+6NGjRq5hrzaRpw8eRLdunXLtx2BPHGqqKggIyNDqoyNjQ3u3Lkj9Yd769YtaGpqwtzcHDVr1oRYLP6uJ2du3bqFXr16YdiwYbC3t0f16tXx8uVLqTIcx6Fly5ZYsGABHj9+DBUVFZw4cSLPuHOys7PDjRs3ZH7hyDJ48GDEx8fjzz//LNI2ff78GYGBgZgzZw46duwIGxubXBdMGxsbPH36FMnJyfy4u3fv5rvcopwfOWWVK2if5UUikWD9+vWoVq0afyFv0KABAgMDZcaVVSspFovRo0cPrF+/HlevXsWdO3fw7Nkz1K9fHxKJBNeuXctzm58/fw4rK6tcy5aVVOZFWVm5wG1WUVFB3bp14e/vX+Dy6tati/T0dCQnJ8PR0RF16tTBypUrvyuJXLt2LbS0tODk5MSPS05OxuvXr6VqGeSRPT4gs5Yje3u/V69eSdUG2dnZwdfXF1++fJG5PDs7uzz/zh0dHZGRkYGIiIhcx8jY2JgvZ2FhwT/Z9fPPP2P79u38NAMDA7i6umLv3r1Yu3Yttm3bJtd2FvS9XbduXYhEIrx79y5XbBYWFgAyv4NatGiB8ePHw9HRETVq1MDr169lbuesWbNw+/Zt2NraYv/+/Xzs2fctALn62Cquc7s4UXJTAQmFQgQEBMDf31/uRGHcuHFYtGgRbt26hbdv3+Lu3bsYPnw4DAwMZN5i8PPzw/DhwzFjxgy+YWVYWBj/hTJjxgzcvn0bnp6e8PX1xatXr3Dy5En+l4ksp06dyvMR8Cz9+vXDmjVrcO/ePbx9+xZXr16Fh4cHatWqxTdCtrKywr179xASEsLfRhk/fjzev3+PCRMm4MWLFzh58iTmzZuHqVOnQiAQQFVVFTNmzMD06dOxZ88evH79Gnfv3sWOHTvk2n9AZi1JVs1MQEAAfvrpJ4SHh/PT7927h6VLl+LBgwd49+4djh8/jsjISP4WjJWVFZ4+fYrAwEBERUXJTGA8PT0RGxuLQYMG4cGDB3j16hX+/vtvBAYGyoypefPm+Pnnn/Hzzz9j6tSpuHnzJn98d+zYAY7j8r3lWKVKFejp6WHbtm0ICgrC5cuXMXXqVKkyQ4YMAcdxGD16NPz9/XHmzJkCf6kW5fzIydDQEGKxGOfOnUN4eDhiYmLyLf/582eEhYXhzZs3OHXqFJycnODj44MdO3bwfydz587Fnj17sGDBAjx//hwBAQE4ePAg5syZAwDYtWsXduzYAT8/P7x58wZ79+6FWCyGpaUlrKys4OrqCnd3d/zzzz8IDg7G1atX+dusHh4e+PLlCwYPHoz79+/j9evXOH/+PEaMGFGoBM3KygqXLl1CWFiYzJqZLM7Ozrh586bUuHbt2mHr1q14+PAhQkJCcObMGfz6669o3749tLS0wHEcvLy8EBgYiJYtW+LUqVN49eoV/P39sWXLFkRGRub6TomOjkZYWBjevn0Lb29v9OvXD/v378fmzZuluo64e/cuRCJRvrcsC4oPADp06ICNGzfi8ePHePDgAcaOHStV2zV48GAYGxujd+/euHXrFt68eYNjx47hzp07ADIbhh84cADz5s1DQEAAnj17xtc41KpVC0OHDsXw4cNx/PhxBAcHw8fHB8uWLcPp06cBAJMnT8b58+cRHByMR48e4cqVK/zf8Ny5c3Hy5EkEBQXh+fPn+Pfff2XegpeloO9tTU1NTJs2DVOmTMHu3bvx+vVrPHr0CBs2bMDu3bsBZH4HPXjwAOfPn8fLly/x22+/4f79+/wygoODMWvWLNy5cwdv377FhQsX8OrVKz7GDh064MGDB9izZw9evXqFefPmwc/Pr8DYi+vcLlZyteKpQArboLi8yKuxb5aCGhQfPXqUde3alZmYmDAVFRVmamrK+vbty54+fSpzHV5eXgU+Cu7j48M6derENDQ0mLq6OrOzs2NLliyRuf6goCAmEokKfFR827ZtrH379szAwICpqKiwqlWrMjc3N6lGuoGBgaxZs2ZMLBYX+lHwxYsXM0tLS6asrMyqVq3KNy6V1Sg1q9Fm1mOinz9/Zr169WIaGhrM0NCQzZkzhw0fPpzfZ/7+/szZ2ZkZGBgwkUjEatWqxTZs2MAvLyIigt9fWcuVtd4nT56wzp07MzU1Naapqclat27NXr9+ne9+O3ToEGvXrh3T1tZmysrKzNzcnA0ZMkTq8disR8Fz8vb2ZjY2NkwkEjE7Ozt29erVXI0679y5w+zt7ZmKigpzcHBgx44dK/BR8ILOD0tLS7ZmzRqpWOzt7aUejd6+fTuzsLBgAoGgwEfBswY1NTVmY2PDxo8fz169epWr/Llz51iLFi2YWCxmWlparEmTJmzbtm2MMcZOnDjBmjZtyrS0tJi6ujpr1qwZu3jxIj9vUlISmzJlCv93lPNR4JcvX7I+ffowHR0dJhaLWZ06ddjkyZP5hu6yGsPn/Ns9deoUq1GjBlNSUsr3UfDnz58zsVjMNxhnjLGlS5ey5s2bM11dXaaqqsqqV6/OJk6cyKKioqTmDQwMZK6urszc3JwpKSkxbW1t1qZNG7Z161apv5ns+1VVVZVZW1szV1dX9vDhw1zxjBkzhv300095xitvfB8/fmSdO3dm6urqrGbNmuzMmTO5HgUPCQlhffv2ZVpaWkxNTY01atSI3bt3j59+7Ngx5uDgwFRUVJi+vj774Ycf+Gmpqals7ty5zMrKiikrKzMTExPWp08f/rvQ09OTWVtbM5FIxAwMDNiPP/7Ix7do0SJmY2PDxGIx09XVZb169WJv3rzJc3sL+70tkUjY2rVrWe3atZmysjIzMDBgzs7O7Nq1a4yxzEbHbm5uTFtbm+no6LBx48axmTNn8n/XYWFhrHfv3vz5aWlpyebOnSv14MjcuXOZkZER09bWZlOmTGGenp65GhTnPEcZK/jczq40GhRzjOW4wVbBxcbGQltbGzExMfwvgSyJiYkICAiAjY0N3wiUlI7Vq1fj4sWLUo9kEkK+T//+/dGgQYN8O2ssDVFRUahduzYePHhQ5HZxpOLIutaGhITg5cuXaNGiRZ4N8bPL7/qdE92WImWCubm5wr+ACaloVqxYIfMJltIWEhKCP//8kxIbUmroaSlSJmR19EUIKT5WVlaYMGGCosNAo0aN0KhRI0WHQSoRqrkhhBBCSIVCyQ0hhBBCKhRKbmQozk7CCCGEEPKf0rjGUnKTTVanYFk9QRJCCCGkeGVdY+XtjLQoqEFxNkpKStDX18fHjx8BZHa3nV8HZ4QQQgiRj0QiQXx8PD5+/Ijo6OgSrcGh5CaHrPfaZCU4hBBCCCk+0dHRCA8P51+WW9h35smDkpscOI6DpaUlhEIhLl++jISEBGhra1MNDiGEEPIdGGNITU2FRCKBRCLB58+foa+vD3Nz82JfFyU3eTA3N0e7du1w4cIFhIeHUyNjQgghpJgIBALo6uqic+fOMDU1LfblU3KTj6pVq+LHH39EXFyc4l7+RQghhFQwQqEQmpqaEIlEJbJ8Sm4KIBKJSmznE0IIIaT4UUMSQgghhFQola7mJusl6LGxsQqOhBBCCCHyyrpuZ13H81Ppkpu4uDgAgIWFhYIjIYQQQkhhxcXFQVtbO98yHJMnBapAJBIJPn36BE1NTXAcV6zLjo2NhYWFBd6/fw8tLa1iXXZZUNG3D6j420jbV/5V9G2k7Sv/SmobGWOIi4uDqalpgd2zVLqaG4FAUCLP1GenpaVVYU9aoOJvH1Dxt5G2r/yr6NtI21f+lcQ2FlRjk4UaFBNCCCGkQqHkhhBCCCEVCiU3xUgkEmHevHkVtl+cir59QMXfRtq+8q+ibyNtX/lXFrax0jUoJoQQQkjFRjU3hBBCCKlQKLkhhBBCSIVCyQ0hhBBCKhRKbgghhBBSoVByU0jz588Hx3FSQ506dfjpycnJ8PDwgJ6eHjQ0NNC3b1+Eh4crMOLCs7KyyrWNHMfBw8MDANCuXbtc08aOHavgqPN2/fp19OjRA6ampuA4Dv/884/UdMYY5s6dCxMTE4jFYjg5OeHVq1dSZb58+YKhQ4dCS0sLOjo6GDlyJOLj40txK/KW3/alpaVhxowZqF+/PtTV1WFqaorhw4fj06dPUsuQdcx///33Ut6SvBV0DN3c3HLF7+LiIlWmvB5DADL/HjmOw4oVK/gyZfkYLlu2DI0bN4ampiYMDQ3Ru3dvBAYGSpWR57vz3bt36NatG9TU1GBoaIhffvkF6enppbkpMhW0fV++fMGECRNQu3ZtiMViVK1aFRMnTkRMTIzUcmQd44MHD5b25sgkzzGU59pQWseQkpsiqFevHkJDQ/nh5s2b/LQpU6bgf//7H44cOYJr167h06dP+OGHHxQYbeHdv39favu8vb0BAP379+fLjB49WqrM8uXLFRVugRISEmBvb49NmzbJnL58+XKsX78eW7Zswb1796Curg5nZ2ckJyfzZYYOHYrnz5/D29sb//77L65fv44xY8aU1ibkK7/tS0xMxKNHj/Dbb7/h0aNHOH78OAIDA9GzZ89cZRcuXCh1TCdMmFAa4culoGMIAC4uLlLxHzhwQGp6eT2GAKS2KzQ0FDt37gTHcejbt69UubJ6DK9duwYPDw/cvXsX3t7eSEtLQ+fOnZGQkMCXKei7MyMjA926dUNqaipu376N3bt3Y9euXZg7d64iNklKQdv36dMnfPr0CStXroSfnx927dqFc+fOYeTIkbmW5eXlJXUMe/fuXcpbI5s8xxDI/9pQqseQkUKZN28es7e3lzktOjqaKSsrsyNHjvDjAgICGAB2586dUoqw+E2aNIlZW1sziUTCGGOsbdu2bNKkSYoNqogAsBMnTvCfJRIJMzY2ZitWrODHRUdHM5FIxA4cOMAYY8zf358BYPfv/7+9Ow9q4n7/AP4OckZACFfw4BAVpSKCjhns1FFBgaFK1SpS61kcz/EobRWtrcd4oeJUx4Ktioza8RpAhuJFNRWR6hcG8MBBoUG0JaIoCCJyPb8/+mPbQAKoSDA+r5nMZD/H5nn4JLsfdrPZ/wltTp8+TSKRiP76668Oi70tmuanzrVr1wgA3bt3TyhzdHSknTt3vt3g2om6HGfOnElBQUEa++jaGAYFBdHo0aNVyt6lMSwpKSEA9PvvvxNR27adycnJpKenR0qlUmgTFRVF5ubm9PLly45NoBVN81Pn+PHjZGhoSLW1tUJZW8a+s1CXY2v7ho4cQz5y8xru3r2L7t27o3fv3pg2bRqKiooAAJmZmaitrYWvr6/Qtn///nBwcEB6erq2wn0jNTU1OHz4MObMmaNyo9EjR47A2toaAwcORHh4OKqqqrQY5etTKBRQKpUqY9atWzfIZDJhzNLT02FhYYGhQ4cKbXx9faGnp4erV692eMxvqry8HCKRCBYWFirlW7ZsgZWVFTw9PbFt27ZOcbj/Vcjlctja2sLV1RULFixAaWmpUKdLY/jw4UP8+uuvav/rf1fGsPF0jEQiAdC2bWd6ejrc3d1hZ2cntPHz88OzZ89w69atDoy+dU3z09TG3Nwc+vqqt3hctGgRrK2tMWzYMBw4cADUSX+KTlOOLe0bOnIM37sbZ74pmUyGgwcPwtXVFcXFxVi3bh0++ugj3Lx5E0qlEoaGhs12GnZ2dlAqldoJ+A0lJCSgrKwMs2bNEso+++wzODo6onv37rh+/TpWrFiBvLw8xMXFaS/Q19Q4Lv/9sDUuN9YplUrY2tqq1Ovr60Mikbxz41pdXY0VK1YgJCRE5YZ2S5YsgZeXFyQSCa5cuYLw8HAUFxcjMjJSi9G2nb+/PyZOnAhnZ2cUFBRg1apVCAgIQHp6Orp06aJTYxgbGwszM7Nmp7vflTFsaGjAsmXL8OGHH2LgwIEA0KZtp1KpVPs5bazrLNTl19Tjx4+xYcOGZqdF169fj9GjR0MsFuPcuXNYuHAhKisrsWTJko4Ivc005djavqEjx5AnN68oICBAeD5o0CDIZDI4Ojri+PHjMDEx0WJkb8f+/fsREBCA7t27C2X//UC6u7vD3t4ePj4+KCgogIuLizbCZG1QW1uLKVOmgIgQFRWlUvfll18KzwcNGgRDQ0PMmzcPmzdvfid+Jn7q1KnCc3d3dwwaNAguLi6Qy+Xw8fHRYmTt78CBA5g2bRqMjY1Vyt+VMVy0aBFu3ryp8l1FXdJafs+ePUNgYCDc3Nywdu1albo1a9YIzz09PfH8+XNs27at001uNOXYmfYNfFrqDVlYWKBfv37Iz8+HVCpFTU0NysrKVNo8fPgQUqlUOwG+gXv37iElJQWhoaEttpPJZACA/Pz8jgirXTWOS9OrMv47ZlKpFCUlJSr1dXV1ePLkyTszro0Tm3v37uH8+fMqR23UkclkqKurQ2FhYccE2M569+4Na2tr4T2pC2MIAKmpqcjLy2v1Mwl0zjFcvHgxkpKScPHiRfTs2VMob8u2UyqVqv2cNtZ1Bprya1RRUQF/f3+YmZkhPj4eBgYGLa5PJpPhwYMHePny5dsK+ZW1luN/Nd03dOQY8uTmDVVWVqKgoAD29vYYMmQIDAwM8Ntvvwn1eXl5KCoqgre3txajfD0xMTGwtbVFYGBgi+2ys7MBAPb29h0QVftydnaGVCpVGbNnz57h6tWrwph5e3ujrKwMmZmZQpsLFy6goaFB+PB2Zo0Tm7t37yIlJQVWVlat9snOzoaenl6zUznvigcPHqC0tFR4T77rY9ho//79GDJkCDw8PFpt25nGkIiwePFixMfH48KFC3B2dlapb8u209vbGzdu3FCZpDZO1N3c3DomEQ1ayw/4Z7syduxYGBoaIjExsdmRN3Wys7NhaWnZKY68tSXHppruGzp0DNv168nvgbCwMJLL5aRQKCgtLY18fX3J2tqaSkpKiIho/vz55ODgQBcuXKCMjAzy9vYmb29vLUf96urr68nBwYFWrFihUp6fn0/r16+njIwMUigUdOrUKerduzeNGDFCS5G2rqKigrKysigrK4sAUGRkJGVlZQlXC23ZsoUsLCzo1KlTdP36dQoKCiJnZ2d68eKFsA5/f3/y9PSkq1ev0uXLl6lv374UEhKirZRUtJRfTU0NjR8/nnr27EnZ2dlUXFwsPBqvTrhy5Qrt3LmTsrOzqaCggA4fPkw2NjY0Y8YMLWf2r5ZyrKiooK+++orS09NJoVBQSkoKeXl5Ud++fam6ulpYx7s6ho3Ky8tJLBZTVFRUs/6dfQwXLFhA3bp1I7lcrvIerKqqEtq0tu2sq6ujgQMH0tixYyk7O5vOnDlDNjY2FB4ero2UVLSWX3l5OclkMnJ3d6f8/HyVNnV1dURElJiYSD///DPduHGD7t69Sz/++COJxWL67rvvtJmaoLUc27Jv6Mgx5MnNKwoODiZ7e3syNDSkHj16UHBwMOXn5wv1L168oIULF5KlpSWJxWKaMGECFRcXazHi13P27FkCQHl5eSrlRUVFNGLECJJIJGRkZER9+vShr7/+msrLy7UUaesuXrxIAJo9Zs6cSUT/XA6+Zs0asrOzIyMjI/Lx8WmWd2lpKYWEhJCpqSmZm5vT7NmzqaKiQgvZNNdSfgqFQm0dALp48SIREWVmZpJMJqNu3bqRsbExDRgwgDZt2qQyMdC2lnKsqqqisWPHko2NDRkYGJCjoyPNnTtX5XJTond3DBvt3buXTExMqKysrFn/zj6Gmt6DMTExQpu2bDsLCwspICCATExMyNramsLCwlQupdaW1vLTNL4ASKFQENE/P00wePBgMjU1pa5du5KHhwdFR0dTfX299hL7j9ZybOu+oaPGUPT/QTPGGGOM6QT+zg1jjDHGdApPbhhjjDGmU3hywxhjjDGdwpMbxhhjjOkUntwwxhhjTKfw5IYxxhhjOoUnN4wxxhjTKTy5YYx1OiKRCAkJCW+8njVr1jS78/KrmDp1Knbs2PHGccjlcohEomb3TmKMvR08uWHsPfTo0SMsWLAADg4OMDIyglQqhZ+fH9LS0rQdWrtRKpX44YcfsHr1aqFs1qxZEIlEmD9/frP2ixYtgkgkwqxZs4Syb7/9Fhs3bkR5eXmLr5WTk4Px48fD1tYWxsbGcHJyQnBwsHAPneHDh6O4uBjdunVrn+QYYy3iyQ1j76FJkyYhKysLsbGxuHPnDhITEzFy5EiUlpZqO7R2s2/fPgwfPhyOjo4q5b169cLRo0fx4sULoay6uhq//PILHBwcVNoOHDgQLi4uOHz4sMbXefToEXx8fCCRSHD27Fncvn0bMTEx6N69O54/fw4AMDQ0hFQqhUgkascMGWOa8OSGsfdMWVkZUlNTsXXrVowaNQqOjo4YNmwYwsPDMX78eKFdZGQk3N3d0bVrV/Tq1QsLFy5EZWWlUH/w4EFYWFggKSkJrq6uEIvF+PTTT1FVVYXY2Fg4OTnB0tISS5YsQX19vdDPyckJGzZsQEhICLp27YoePXpgz549LcZ8//59TJkyBRYWFpBIJAgKCkJhYWGLfY4ePYpx48Y1K/fy8kKvXr0QFxcnlMXFxcHBwQGenp7N2o8bNw5Hjx7V+DppaWkoLy/Hvn374OnpCWdnZ4waNQo7d+4U7pzc9LTUyJEjIRKJmj0acyorK0NoaChsbGxgbm6O0aNHIycnp8V8GWP/4skNY+8ZU1NTmJqaIiEhAS9fvtTYTk9PD7t27cKtW7cQGxuLCxcu4JtvvlFpU1VVhV27duHo0aM4c+YM5HI5JkyYgOTkZCQnJ+PQoUPYu3cvTp48qdJv27Zt8PDwQFZWFlauXImlS5fi/PnzauOora2Fn58fzMzMkJqairS0NJiamsLf3x81NTVq+zx58gS5ubkYOnSo2vo5c+YgJiZGWD5w4ABmz56ttu2wYcNw7do1jX8rqVSKuro6xMfHo6236ouLi0NxcbHwmDhxIlxdXWFnZwcAmDx5MkpKSnD69GlkZmbCy8sLPj4+ePLkSZvWz9h7r91vxckY6/ROnjxJlpaWZGxsTMOHD6fw8HDKyclpsc+JEyfIyspKWI6JiSEAlJ+fL5TNmzePxGKxyt22/fz8aN68ecKyo6Mj+fv7q6w7ODiYAgIChGUAFB8fT0REhw4dIldXV2poaBDqX758SSYmJnT27Fm1sWZlZREAKioqUimfOXMmBQUFUUlJCRkZGVFhYSEVFhaSsbExPXr0iIKCglTuxE1ElJOTQwCosLBQ499m1apVpK+vTxKJhPz9/SkiIkLlruSNd4V++vRps76RkZFkYWEh3Ik+NTWVzM3Nm93R28XFhfbu3asxBsbYv/jIDWPvoUmTJuHvv/9GYmIi/P39IZfL4eXlhYMHDwptUlJS4OPjgx49esDMzAzTp09HaWkpqqqqhDZisRguLi7Csp2dHZycnGBqaqpS1vjF2kbe3t7Nlm/fvq021pycHOTn58PMzEw46iSRSFBdXY2CggK1fRq/T2NsbKy23sbGBoGBgTh48CBiYmIQGBgIa2trtW1NTEwAQCXvpjZu3AilUono6Gh88MEHiI6ORv/+/XHjxg2NfQDg9OnTWLlyJY4dO4Z+/foJ+VZWVsLKykrI19TUFAqFQmO+jDFV+toOgDGmHcbGxhgzZgzGjBmDNWvWIDQ0FN9//z1mzZqFwsJCfPzxx1iwYAE2btwIiUSCy5cv44svvkBNTQ3EYjEAwMDAQGWdIpFIbVlDQ8Nrx1lZWYkhQ4bgyJEjzepsbGzU9mmcqDx9+lRjmzlz5mDx4sUA0OJ3fhpPBWlaTyMrKytMnjwZkydPxqZNm+Dp6Ynt27cjNjZWbfvc3FxMnToVW7ZswdixY4XyyspK2NvbQy6XN+tjYWHRYgyMsX/w5IYxBgBwc3MTflsmMzMTDQ0N2LFjB/T0/jnAe/z48XZ7rT/++KPZ8oABA9S29fLywrFjx2Brawtzc/M2rd/FxQXm5ubIzc0Vjog01fidHZFIBD8/P43runnzJnr27KnxyI46hoaGcHFxEa6Waurx48cYN24cJk2ahOXLl6vUeXl5QalUQl9fH05OTm1+TcbYv/i0FGPvmdLSUowePRqHDx/G9evXoVAocOLECURERCAoKAgA0KdPH9TW1mL37t34888/cejQIURHR7dbDGlpaYiIiMCdO3ewZ88enDhxAkuXLlXbdtq0abC2tkZQUBBSU1OhUCggl8uxZMkSPHjwQG0fPT09+Pr64vLlyxpj6NKlC27fvo3c3Fx06dJFY7vU1FSVIytNJSUl4fPPP0dSUhLu3LmDvLw8bN++HcnJycLfs6lJkyZBLBZj7dq1UCqVwqO+vh6+vr7w9vbGJ598gnPnzqGwsBBXrlzB6tWrkZGRoTEOxti/+MgNY+8ZU1NTyGQy7Ny5EwUFBaitrUWvXr0wd+5crFq1CgDg4eGByMhIbN26FeHh4RgxYgQ2b96MGTNmtEsMYWFhyMjIwLp162Bubo7IyEiNR0/EYjEuXbqEFStWYOLEiaioqECPHj3g4+PT4pGc0NBQzJ07FxEREcLRp6ZaOxJUXV2NhIQEnDlzRmMbNzc3iMVihIWF4f79+zAyMkLfvn2xb98+TJ8+XW2fS5cuAUCz3+BRKBRwcnJCcnIyVq9ejdmzZ+PRo0eQSqUYMWKEcDUVY6xlIqI2XrvIGGPtwMnJCcuWLcOyZcve6usQEWQyGZYvX46QkJDXWkdUVBTi4+Nx7ty5do6OMfY28WkpxphOEolE+Omnn1BXV/fa6zAwMMDu3bvbMSrGWEfg01KMMZ01ePBgDB48+LX7h4aGtl8wjLEOw6elGGOMMaZT+LQUY4wxxnQKT24YY4wxplN4csMYY4wxncKTG8YYY4zpFJ7cMMYYY0yn8OSGMcYYYzqFJzeMMcYY0yk8uWGMMcaYTuHJDWOMMcZ0yv8Bid6Xlwz7+PAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# compare the accuracy of w with w' / w^ with each sample size. \n",
    "# use for different sizes of m\n",
    "# run this several times - 10 times\n",
    "# then records the time taken to run it on average\n",
    "\n",
    "# measures the error and the time taken per algorithm\n",
    "def measure_error_all_classifiers(m):\n",
    "    weight_vector, X, y = generate_data(m)\n",
    "    \n",
    "    # sklearn Logistic Regression\n",
    "    start_lr = time.time()\n",
    "    lr_clf: LogisticRegression = LogisticRegression(random_state=0, max_iter=1000).fit(X, y)\n",
    "    end_lr = time.time()\n",
    "    lr_time_taken = end_lr - start_lr\n",
    "    w_prime_lr = lr_clf.coef_\n",
    "    \n",
    "    # gradient descent\n",
    "    start_gd = time.time()\n",
    "    gd_clf = GradientDescentClassifier(steps=1000, step_size=0.01).fit(X, y)\n",
    "    w_prime_gd = gd_clf.get_w_prime()\n",
    "    end_gd = time.time()\n",
    "    gd_time_taken = end_gd - start_gd\n",
    "\n",
    "    # stochastic gradient descent\n",
    "    start_sgd = time.time()\n",
    "    sgd_clf = GradientDescentClassifier(steps=1000, step_size=0.01).fit_sgd(X, y)\n",
    "    w_prime_sgd = sgd_clf.get_w_prime()\n",
    "    end_sgd = time.time()\n",
    "    sgd_time_taken = end_sgd - start_sgd\n",
    "    \n",
    "    error_lr_clf = np.linalg.norm(weight_vector - w_prime_lr)\n",
    "    error_lr_gd = np.linalg.norm(weight_vector - w_prime_gd)\n",
    "    error_lr_sgd = np.linalg.norm(weight_vector - w_prime_sgd)\n",
    "    \n",
    "    return error_lr_clf, error_lr_gd, error_lr_sgd, lr_time_taken, gd_time_taken, sgd_time_taken\n",
    "\n",
    "def run_all_m_samples(num_iterations):\n",
    "    total_time_taken_lr = 0\n",
    "    total_time_taken_gd = 0\n",
    "    total_time_taken_sgd = 0\n",
    "    \n",
    "    list_of_m = [50, 100, 150, 200, 250]\n",
    "    \n",
    "    average_lr_error_rate_per_m = []\n",
    "    average_gd_error_rate_per_m = []\n",
    "    average_sgd_error_rate_per_m = []\n",
    "        \n",
    "    for m in list_of_m:\n",
    "        total_error_rate_lr = 0.0\n",
    "        total_error_rate_gd = 0.0\n",
    "        total_error_rate_sgd = 0.0\n",
    "        for _ in range(num_iterations):\n",
    "            error_lr_clf, error_lr_gd, error_lr_sgd, lr_time_taken, gd_time_taken, sgd_time_taken = measure_error_all_classifiers(m)        \n",
    "            total_time_taken_lr += lr_time_taken\n",
    "            total_time_taken_gd += gd_time_taken\n",
    "            total_time_taken_sgd += sgd_time_taken\n",
    "            \n",
    "            total_error_rate_lr += error_lr_clf\n",
    "            total_error_rate_gd += error_lr_gd\n",
    "            total_error_rate_sgd += error_lr_sgd\n",
    "        \n",
    "        average_lr_error_rate_per_m.append(total_error_rate_lr / num_iterations)\n",
    "        average_gd_error_rate_per_m.append(total_error_rate_gd / num_iterations)\n",
    "        average_sgd_error_rate_per_m.append(total_error_rate_sgd / num_iterations)\n",
    "    \n",
    "    print(\"average_lr_error_rate_per_m \", average_lr_error_rate_per_m)\n",
    "    \n",
    "    return list_of_m, average_lr_error_rate_per_m, average_gd_error_rate_per_m, average_sgd_error_rate_per_m, total_time_taken_lr, total_time_taken_gd, total_time_taken_sgd\n",
    "        \n",
    "\n",
    "list_of_m, lr_avg_e, gd_avg_e, sgd_avg_e, time_lr, time_gd, time_sgd = run_all_m_samples(10)\n",
    "\n",
    "print(\"Total Time Logistic Regression: \", time_lr)\n",
    "print(\"Total Time Gradient Descent: \", time_gd)\n",
    "print(\"Total Time SGD: \", time_sgd)\n",
    "\n",
    "plt.plot(list_of_m, lr_avg_e, label=\"M Size / Logistic Regression Success Measure\")\n",
    "plt.plot(list_of_m, gd_avg_e, label=\"M Size / Gradient Descent Success Measure\")\n",
    "plt.plot(list_of_m, sgd_avg_e, label=\"M Size / Stochastic Gradient Descent (SGD) Success Measure\")\n",
    "\n",
    "plt.title(\"M Size / Error Rate\")\n",
    "plt.xlabel(\"Sample (M) Size\")\n",
    "plt.ylabel(\"Error\")\n",
    "\n",
    "plt.legend(loc=\"best\", shadow=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5HVIWkFzq6CH"
   },
   "source": [
    "# Problem 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "ljJ8LqMAq6CH"
   },
   "outputs": [],
   "source": [
    "from sklearn import datasets, tree\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.model_selection import KFold, cross_val_score\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "Nozi_7aYq6CH"
   },
   "outputs": [],
   "source": [
    "cancer = datasets.load_breast_cancer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e2pmw8njq6CI"
   },
   "source": [
    "For each depth in $1, \\dots, 5$, instantiate an AdaBoost classifier with the base learner set to be a decision tree of that depth (set `n_estimators=10` and `learning_rate=1`), and then record the 10-fold cross-validated error on the entire breast cancer data set. Plot the resulting curve of accuracy against base classifier depth. Use $101$ as your random state for both the base learner as well as the AdaBoost classifier every time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "fWNjLf4Vq6CI"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2890dcc7100>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# For each depth in 1,…,5, instantiate an AdaBoost classifier with the base learner\n",
    "# set to be a decision tree of that depth (set n_estimators=10 and learning_rate=1),\n",
    "# and then record the 10-fold cross-validated error on the entire breast cancer data set.\n",
    "# Plot the resulting curve of accuracy against base classifier depth.\n",
    "# Use 101 as your random state for both the base learner as well as the AdaBoost classifier every time.\n",
    "\n",
    "RANDOM_STATE = 101\n",
    "FOLDS = 10\n",
    "\n",
    "X, y = cancer.data, cancer.target\n",
    "\n",
    "depth_x_axis = []\n",
    "cross_val_acc_score_means = []\n",
    "for i in range(5):\n",
    "    max_depth_cv = i + 1\n",
    "    dt_clf_model = tree.DecisionTreeClassifier(random_state=RANDOM_STATE, max_depth=max_depth_cv).fit(X, y)\n",
    "    ada_clf = AdaBoostClassifier(estimator=dt_clf_model, n_estimators=10,\n",
    "                                 learning_rate=1).fit(X, y)\n",
    "    kf = KFold(n_splits=FOLDS, shuffle=True, random_state=RANDOM_STATE)\n",
    "    scores = cross_val_score(ada_clf, X, y, cv=kf)\n",
    "    cross_val_scores_mean = scores.mean()\n",
    "    depth_x_axis.append(max_depth_cv)\n",
    "    cross_val_acc_score_means.append(cross_val_scores_mean)\n",
    "\n",
    "plt.plot(depth_x_axis, cross_val_acc_score_means, label=\"Tree Max Depth / Cross Validation Accuracy\")\n",
    "\n",
    "plt.title(\"Decision Tree - Max Depth / Accuracy\")\n",
    "plt.xlabel(\"Max Depth\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "\n",
    "plt.legend(loc=\"best\", shadow=True)\n",
    "\n",
    "# note: may need to wait a little bit when running this part - wait 10-20 seconds if running it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}