--- a
+++ b/Code/All Qiskit ML Demos/09 Qiskit ML Model 93.3% Train kkawchak.ipynb
@@ -0,0 +1,1083 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "measured-liabilities",
+   "metadata": {},
+   "source": [
+    "# Saving, Loading Qiskit Machine Learning Models and Continuous Training\n",
+    "\n",
+    "In this tutorial we will show how to save and load Qiskit machine learning models. Ability to save a model is very important, especially when a significant amount of time is invested in training a model on a real hardware. Also, we will show how to resume training of the previously saved model.\n",
+    "\n",
+    "In this tutorial we will cover how to:\n",
+    "\n",
+    "* Generate a simple dataset, split it into training/test datasets and plot them\n",
+    "* Train and save a model\n",
+    "* Load a saved model and resume training\n",
+    "* Evaluate performance of models\n",
+    "* PyTorch hybrid models"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "speaking-glance",
+   "metadata": {},
+   "source": [
+    "First off, we start from the required imports. We'll heavily use SciKit-Learn on the data preparation step. In the next cell we also fix a random seed for reproducibility purposes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "exposed-cholesterol",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from qiskit.algorithms.optimizers import COBYLA, ADAM, AQGD\n",
+    "from qiskit.circuit.library import RealAmplitudes\n",
+    "from qiskit.primitives import Sampler\n",
+    "from qiskit.utils import algorithm_globals\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import OneHotEncoder, MinMaxScaler\n",
+    "\n",
+    "from qiskit_machine_learning.algorithms.classifiers import VQC\n",
+    "\n",
+    "from IPython.display import clear_output\n",
+    "\n",
+    "algorithm_globals.random_seed = 42"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "rural-mileage",
+   "metadata": {},
+   "source": [
+    "We will be using two quantum simulators, in particular, two instances of the `Sampler` primitive. We'll start training on the first one, then will resume training on the second one. The approach shown in this tutorial can be used to train a model on a real hardware available on the cloud and then re-use the model for inference on a local simulator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "charming-seating",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampler1 = Sampler()\n",
+    "\n",
+    "sampler2 = Sampler()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "careful-allowance",
+   "metadata": {},
+   "source": [
+    "## 1. Prepare a dataset\n",
+    "\n",
+    "Next step is to prepare a dataset. Here, we generate some data in the same way as in other tutorials. The difference is that we apply some transformations to the generated data. We generates `40` samples, each sample has `2` features, so our features is an array of shape `(40, 2)`. Labels are obtained by summing up features by columns and if the sum is more than `1` then this sample is labeled as `1` and `0` otherwise."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "ceramic-florida",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_samples = 40\n",
+    "num_features = 2\n",
+    "features = 2 * algorithm_globals.random.random([num_samples, num_features]) - 1\n",
+    "labels = 1 * (np.sum(features, axis=1) >= 0)  # in { 0,  1}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "reduced-injury",
+   "metadata": {},
+   "source": [
+    "Then, we scale down our features into a range of `[0, 1]` by applying `MinMaxScaler` from SciKit-Learn. Model training convergence is better when this  transformation is applied."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "dirty-director",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(40, 2)"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features = MinMaxScaler().fit_transform(features)\n",
+    "features.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "julian-amount",
+   "metadata": {},
+   "source": [
+    "Let's take a look at the features of the first `5` samples of our dataset after the transformation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "thorough-script",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0.79067335, 0.44566143],\n",
+       "       [0.88072937, 0.7126244 ],\n",
+       "       [0.06741233, 1.        ],\n",
+       "       [0.7770372 , 0.80422817],\n",
+       "       [0.10351936, 0.45754615]])"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "features[0:5, :]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "racial-aluminum",
+   "metadata": {},
+   "source": [
+    "We choose `VQC` or Variational Quantum Classifier as a model we will train. This model, by default, takes one-hot encoded labels, so we have to transform the labels that are in the set of `{0, 1}` into one-hot representation. We employ SciKit-Learn for this transformation as well. Please note that the input array must be reshaped to `(num_samples, 1)` first. The `OneHotEncoder` encoder does not work with 1D arrays and our labels is a 1D array. In this case a user must decide either an array has only one feature(our case!) or has one sample. Also, by default the encoder returns sparse arrays, but for dataset plotting it is easier to have dense arrays, so we set `sparse` to `False`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "understood-ukraine",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/lib/python3.10/site-packages/sklearn/preprocessing/_encoders.py:828: FutureWarning: `sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(40, 2)"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "labels = OneHotEncoder(sparse=False).fit_transform(labels.reshape(-1, 1))\n",
+    "labels.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "statewide-symbol",
+   "metadata": {},
+   "source": [
+    "Let's take a look at the labels of the first `5` labels of the dataset. The labels should be one-hot encoded."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "german-agreement",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0., 1.],\n",
+       "       [0., 1.],\n",
+       "       [0., 1.],\n",
+       "       [0., 1.],\n",
+       "       [1., 0.]])"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "labels[0:5, :]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aquatic-toner",
+   "metadata": {},
+   "source": [
+    "Now we split our dataset into two parts: a training dataset and a test one. As a rule of thumb, 80% of a full dataset should go into a training part and 20% into a test one. Our training dataset has `30` samples. The test dataset should be used only once, when a model is trained to verify how well the model behaves on unseen data. We employ `train_test_split` from SciKit-Learn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "about-ordinary",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(30, 2)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_features, test_features, train_labels, test_labels = train_test_split(\n",
+    "    features, labels, train_size=30, random_state=algorithm_globals.random_seed\n",
+    ")\n",
+    "train_features.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "critical-angel",
+   "metadata": {},
+   "source": [
+    "Now it is time to see how our dataset looks like. Let's plot it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "fifty-scottish",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqUAAAFfCAYAAAB3ObXQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABrNUlEQVR4nO3deXhMZ/8/8PfMZLNkKYqQ0bEWSewSQh5Jm4q2VJr6UWltVVpbo6GKqlAltGhStFotUY89QvtFU4poEFQIQkpbiUQkVEsWS8jM/ftjnkyNJEwiM2eW9+u65hpzz33OfOaYzPnMfe5FJoQQICIiIiKSkFzqAIiIiIiImJQSERERkeSYlBIRERGR5JiUEhEREZHkmJQSERERkeSYlBIRERGR5JiUEhEREZHk7KQOwBAajQaXL1+Gs7MzZDKZ1OEQERFZDCEECgsL0ahRI8jlxmuLUqvVuHfvntH2T5bJ3t4eCoXCoLoWkZRevnwZSqVS6jCIiIgsVnZ2Njw8PKp9v0II5OXl4caNG9W+b7IObm5uaNiw4SMbFi0iKXV2dgag/YNycXGROBoiIiLLUVBQAKVSqTuXVrfShLR+/fqoWbMmr2iSjhACt27dwtWrVwEA7u7uD61vEUlp6QfcxcWFSSkREVEVGCNZVKvVuoS0bt261b5/snw1atQAAFy9ehX169d/6KV8DnQiIiKiKintQ1qzZk2JIyFzVvr5eFSfYyalRERE9Fh4yZ4extDPB5NSIiIiIpIck1IiIiIikhyTUiIiIqJKiI2NhZub22PvRyaTYdu2bY+9H2MKCAjAxIkTTfJaTEqJiIhIUmo1kJgIrF+vvVerjft6w4cPR0hIiHFfpJosW7YMKpUKTk5O8PX1xdGjRx9av7rfW3x8PObMmVNt+3sYJqUmYOo/NiIiIksRHw+oVEBgIBAWpr1XqbTltm7jxo2IiIhAZGQkjh8/jvbt2yM4OFg37+fjMHT1rTp16hhtjtsHVTop/eWXX9CvXz80atTI4GbnxMREdOrUCY6OjmjRogViY2OrEKpl4h8bERFR+eLjgQEDgEuX9MtzcrTlUp0rFy9eDG9vb9SqVQtKpRJjx45FUVFRmXrbtm1Dy5Yt4eTkhODgYGRnZ+s9//3336NTp05wcnJCs2bNMHv2bJSUlFQqjlGjRmHEiBFo27Ytli9fjpo1a2LlypXl1p81axZWr16N77//HjKZDDKZDImJicjMzIRMJsPGjRvRq1cvODk5Ye3atfj7778xePBgNG7cGDVr1oS3tzfWr1+vt88HL9+rVCrMmzcPb7zxBpydndGkSRN8/fXXBr+nh6l0Unrz5k20b98ey5YtM6h+RkYGXnzxRQQGBiI1NRUTJ07Em2++iZ9++qnSwVoac/1jIyIikppaDYSHA0KUfa60bOJEaa4uyuVyfP755zhz5gxWr16NvXv3YsqUKXp1bt26hblz5+K7777DwYMHcePGDbz66qu655OSkjB06FCEh4fj7Nmz+OqrrxAbG4u5c+caFMPdu3eRkpKCoKAgvbiCgoKQnJxc7jaTJ0/GwIED0adPH+Tm5iI3Nxd+fn6656dOnYrw8HCkp6cjODgYd+7cQefOnbFjxw6kpaVh9OjRGDJkyCO7CCxatAhdunTBiRMnMHbsWIwZMwbnzp0z6H09lHgMAMTWrVsfWmfKlCnC09NTr2zQoEEiODjY4NfJz88XAER+fn5VwpRESYkQHh5CaP+0yt5kMiGUSm09IiJTKikRYt8+Idat097ze8i6GfMcevv2bXH27Flx+/btSm+7b1/F58j7b/v2VXvYYtiwYaJ///4G19+8ebOoW7eu7vGqVasEAHH48GFdWXp6ugAgjhw5IoQQ4tlnnxXz5s3T28+aNWuEu7u77vHD8qicnBwBQBw6dEiv/L333hM+Pj4Vxlree8vIyBAARHR09EPfpxBCvPjii2LSpEm6x7169RLh4eG6x0899ZR4/fXXdY81Go2oX7+++PLLLyvcp6GfE6MvM5qcnKyX5QNAcHDwQ0dyFRcXo7i4WPe4oKDAWOEZTVJS2RbS+wkBZGdr6wUEmCwsIrJx8fHApElAZua/ZSoVsGgREBoqVVRki3Jzq7dedfr5558RFRWF3377DQUFBSgpKcGdO3dw69Yt3epEdnZ26Nq1q26b1q1bw83NDenp6fDx8cHJkydx8OBBvZZRtVpdZj+m1KVLF73HarUa8+bNw6ZNm5CTk4O7d++iuLj4kbG1a9dO92+ZTIaGDRtWSz9Xow90ysvLQ4MGDfTKGjRogIKCAty+fbvcbaKiouDq6qq7KZVKo8aYn59f7fs05z82IrJNpV2KvL2B5GSgsFB77+3NLkVkeu7u1VuvumRmZqJv375o164dtmzZgpSUFF2Xxbt37xq8n6KiIsyePRupqam62+nTp/H777/DycnpkdvXq1cPCoUCV65c0Su/cuUKGjZsWLk39T+1atXSe/zpp58iJiYG77//Pvbt24fU1FQEBwc/8n3a29vrPZbJZNBoNFWK6X5mOfp+2rRpyM/P190e7Dhcnf766y+0atUKEydOxM2bN6ttv+b6x0ZEtkmt1raQ9u0LbNsGdOsG1K6tvd+2TVs+eTJnByHT8fcHPDyAilaglMkApVJbz5RSUlKg0WiwaNEidOvWDa1atcLly5fL1CspKcGxY8d0j8+dO4cbN26gTZs2AIBOnTrh3LlzaNGiRZmbXP7o9MvBwQGdO3fGnj17dGUajQZ79uxB9+7dH7qd2sA/5IMHD6J///54/fXX0b59ezRr1gznz583aFtjMHpS2rBhw3KzfBcXF9SoUaPcbRwdHeHi4qJ3M5atW7fi6tWriImJQfv27fHLL79Uy37N9Y+NiGxTUpL2kv306cCD50O5HJg2DcjI0NYjMgWFAoiJ0f77wXNl6ePoaG09Y8jPz9drxUxNTUV2djZatGiBe/fuYcmSJbhw4QLWrFmD5cuXl9ne3t4eEyZMwJEjR5CSkoLhw4ejW7du8PHxAQDMnDkT3333HWbPno0zZ84gPT0dGzZswIwZMwyOMSIiAitWrMDq1auRnp6OMWPG4ObNmxgxYkSF26hUKpw6dQrnzp3DtWvXHjr1U8uWLbF7924cOnQI6enpeOutt8rkbKZk9KS0e/fuelk+AOzevfuhWb4pjR49Gj/++CM8PDzw559/olevXpgwYUK5Uz9UhtR/bERE9yvtKuTlVf7zpeXsUkSmFBoKxMUBjRvrl3t4aMuN2c85MTERHTt21LvNnj0b7du3x+LFi7FgwQJ4eXlh7dq1iIqKKrN9zZo18f777yMsLAw9evRA7dq1sXHjRt3zwcHB2L59O3bt2oWuXbuiW7du+Oyzz/DUU08ZHOOgQYOwcOFCzJw5Ex06dEBqaioSEhLKdIu836hRo/D000+jS5cuePLJJ3Hw4MEK686YMQOdOnVCcHAwAgIC0LBhQ2kXFXjkMKwHFBYWihMnTogTJ04IAGLx4sXixIkT4uLFi0IIIaZOnSqGDBmiq3/hwgVRs2ZN8d5774n09HSxbNkyoVAoREJCgsGvaYrR9zdu3BCjRo0SAAQA0bRpU7F3797H3u+WLWVH4SuV2nIiIlMpHemcnFz+84cOGW+kM0nLXEff348zQlg3Qz8nMiHKmyGsYomJiQgMDCxTPmzYMMTGxmL48OHIzMxEYmKi3jbvvvsuzp49Cw8PD3z44YcYPny4wa9ZUFAAV1dX5OfnG/VSPqBtxX3zzTeRlZWFUaNGVcuEsGq19pJYbq62D6m/P1tIici01GqgRQvtoKZt2/Qv4Ws0QEgIkJYG/P47v5+sjTHPoXfu3EFGRgaaNm1q0OAdsk2Gfk4qnZRKwZRJKQAUFhZi7ty5mDZtGlxdXQFol+N6cLQZEZElKR1937evtg+pl5c2EY2KArZvN/7lUpIGk1KSmqGfE7McfS81Z2dnzJ8/X5eQCiHQt29fjB492iLnTCUiAv7tv3f6NODnB7i4aO/T0piQEpH0jD55vjVITk7Grl27AAAJCQlYsWIFgoODJY6KiKjyQkOB/v3ZpYiIzA9bSg3g5+eHffv2oVmzZsjOzkafPn0wcuRI3LhxQ+rQyEyp1UBiIrB+vfaecz+SOVEotCvJDR6svWdCSkTmgEmpgQICAnDq1Cm88847kMlkWLlyJby8vLBz506pQyMzEx+vXbYxMBAIC9Peq1RcLYeIiOhhmJRWQq1atRATE4P9+/ejRYsWyMnJwaRJkx46MS3ZltKBJJcu6Zfn5HAZRyIioodhUloF/v7+OHnyJCIiIrBy5UrdqHwLmMiAjEitBsLDtbPRPqi0bOJEXsonIiIqD5PSKqpZsyYWLVqktzLVwoUL8frrr+Pvv/+WMDKSSlJS2RbS+wkBZGdzGUciIqLyMCmtJv/88w9mzZqFtWvXwtPTE9u2bZM6JDIxQ5dn5DKORESWLTY2Fm5ubo+9H5lMZvb5wvDhw0229CiT0mpSp04d7N27F23atMGVK1fw8ssvY/Dgwbh27ZrUoZGJuLtXbz0iIluh1qiRmJmI9afXIzEzEWqNcfs5mTLRehy//PIL+vXrh0aNGhmcwM6aNQsdOnSothhiYmIQGxtbbft7GCal1cjX1xfHjx/HtGnTIJfLsWHDBrRt2xZxcXFSh0Ym4O8PeHgAMln5z8tkgFKprUdERFrx6fFQxagQuDoQYfFhCFwdCFWMCvHpHBl68+ZNtG/fHsuWLav2fRs6SNvV1bVaWoUNwaS0mjk5OWHevHk4fPgwPD098ddffyEsLAxZWVlSh0ZGplAAMTHafz+YmJY+jo7mnJBERKXi0+MxYNMAXCrQ75CfU5CDAZsGSJaYLl68GN7e3qhVqxaUSiXGjh2LoqKiMvW2bduGli1bwsnJCcHBwcjOztZ7/vvvv0enTp3g5OSEZs2aYfbs2SgpKTE4jueffx4ff/wxXn75ZYPqx8bGYvbs2Th58iRkMhlkMpmulVMmk+HLL7/ESy+9hFq1amHu3LlQq9UYOXIkmjZtiho1auDpp59GTOmJ7H8ebFUOCAjAO++8gylTpqBOnTpo2LAhZs2aZfB7ehgmpUbStWtXpKSkYMaMGZgzZw6aNGkidUhkAqXLODZurF/u4cFlHImI7qfWqBGeEA6BslOWlJZNTJho9Ev55ZHL5fj8889x5swZrF69Gnv37sWUKVP06ty6dQtz587Fd999h4MHD+LGjRt49dVXdc8nJSVh6NChCA8Px9mzZ/HVV18hNjYWc+fONVrcgwYNwqRJk+Dp6Ync3Fzk5uZi0KBBuudnzZqFl19+GadPn8Ybb7wBjUYDDw8PbN68GWfPnsXMmTMxffp0bNq06aGvs3r1atSqVQtHjhzBJ598go8++gi7d+9+7Pi5zKgROTo6Ys6cOXplx44dw4IFC7BkyRI0bNhQosjImLiMIxFVhVptW98bSVlJZVpI7ycgkF2QjaSsJASoAkwXGICJEyfq/q1SqfDxxx/j7bffxhdffKErv3fvHpYuXQpfX18A2kStTZs2OHr0KHx8fDB79mxMnToVw4YNAwA0a9YMc+bMwZQpUxAZGWmUuGvUqIHatWvDzs6u3BwjLCwMI0aM0CubPXu27t9NmzZFcnIyNm3ahIEDB1b4Ou3atdO9h5YtW2Lp0qXYs2cPnnvuuceKn0mpCQkhMHr0aJw4cQJ79+7FkiVLMHjwYMgq6oRIFqt0GUciIkPEx2vnOb5/WjkPD22XIGu9wpJbaNhUJIbWq04///wzoqKi8Ntvv6GgoAAlJSW4c+cObt26hZo1awIA7Ozs0LVrV902rVu3hpubG9LT0+Hj44OTJ0/i4MGDei2jarW6zH5MqUuXLmXKli1bhpUrVyIrKwu3b9/G3bt3HzlQql27dnqP3d3dcfXq1ceOj5fvTah0edIOHTrgn3/+wWuvvYaXX34ZuZwjiIjIZtnqSnDuzoZNRWJoveqSmZmJvn37ol27dtiyZQtSUlJ0A43u3r1r8H6Kioowe/ZspKam6m6nT5/G77//DicnJ2OF/1C1atXSe7xhwwZMnjwZI0eOxK5du5CamooRI0Y88n2WLhpUSiaTQaPRPHZ8TEpNrEOHDjh69CjmzJkDe3t7fP/99/D09MSaNWu4IhQRkY2x5ZXg/Jv4w8PFAzKUf7VQBhmULkr4NzHtlCUpKSnQaDRYtGgRunXrhlatWuHy5ctl6pWUlODYsWO6x+fOncONGzfQpk0bAECnTp1w7tw5tGjRosxNLjde+uXg4AC1gR+YgwcPws/PD2PHjkXHjh3RokUL/Pnnn0aL7VGYlErA3t4eM2bMQEpKCjp37ozr169j6NCh2L59u9ShERGRCdnySnAKuQIxfbQjvR9MTEsfR/eJhkJunI61+fn5eq2YqampyM7ORosWLXDv3j0sWbIEFy5cwJo1a7B8+fIy29vb22PChAk4cuQIUlJSMHz4cHTr1g0+Pj4AgJkzZ+K7777D7NmzcebMGaSnp2PDhg2YMWOGwTEWFRXpYgOAjIwMpKamPnRGH5VKpat37do1FBcXV1i3ZcuWOHbsGH766SecP38eH374IX799VeD46tuTEol5O3tjcOHD2PevHno06cPXnzxRalDIiIiE7L1leBC24QibmAcGrvoT1ni4eKBuIFxCG1jvA61iYmJ6Nixo95t9uzZaN++PRYvXowFCxbAy8sLa9euRVRUVJnta9asiffffx9hYWHo0aMHateujY0bN+qeDw4Oxvbt27Fr1y507doV3bp1w2effYannnrK4BiPHTumiw0AIiIi0LFjR8ycObPCbV555RX06dMHgYGBePLJJ7F+/foK67711lsIDQ3FoEGD4Ovri7///htjx441OL7qJhMWcM24oKAArq6uyM/Ph4uLi9ThGIUQQjfgqaioCOHh4Zg1axaUSqXEkRERkbEkJgKBgY+ut29f1QdPGvMceufOHWRkZKBp06aP1U9SrVEjKSsJuYW5cHd2h38Tf6O1kJLpGfo5YUupmbh/BP4HH3yAlStXwtPTE9988w37mhIRWSmuBKelkCsQoArAYO/BCFAFMCG1UUxKzdCYMWPQrVs3FBYWYtSoUQgODsbFixelDouIiKoZV4Ij+heTUjPUunVrHDhwAAsXLoSTkxN2794NLy8vfPXVV2w1JSKyMlwJjkiLSamZUigUmDRpEk6ePIkePXqgqKgIb7/9Nj766COpQyMiomoWGgpkZmr7jq5bp73PyGBCSraFKzqZuVatWmH//v1YunQpFi1ahLfeekvqkIiIyAi4EhzZOraUWgCFQoHw8HD8/vvvemvZLliwQNJJbomIiIiqC5NSC+Lo6Kj79/fff4+pU6eiXbt2+Pzzz6tleS8iIiIiqTAptVDe3t4IDAzErVu3EB4ejoCAAPz+++9Sh0VERERUJUxKLVSzZs3w888/48svv0Tt2rWRlJSE9u3b47PPPjN4zVsiIiKqvNjYWLi5uT32fmQyGbZt2/bY+7EWTEotmFwux9tvv43Tp08jKCgIt2/fRkREBAYPHix1aERERGZr+PDhCAkJkToMgyxbtgwqlQpOTk7w9fXF0aNHH1rfGO9t1qxZ6NChQ7XuszxMSq2ASqXCrl278PXXX8PFxQXDhw+XOiQiIiKDqdXaJVfXr9fe84Kf1saNGxEREYHIyEgcP34c7du3R3BwMK5evSp1aEbBpNRKyGQyjBo1ChkZGXjhhRd05Tt27MDZs2cljIxMiV/sRGRp4uOBFi2AwEAgLEx736KFtlwqixcvhre3N2rVqgWlUomxY8eiqKioTL1t27ahZcuWcHJyQnBwMLKzs/We//7779GpUyc4OTmhWbNmmD17NkpKSioVx6hRozBixAi0bdsWy5cvR82aNbFy5cpy68+aNQurV6/G999/D5lMBplMhsTERABAdnY2Bg4cCDc3N9SpUwf9+/dHZmambtvExET4+PigVq1acHNzQ48ePXDx4kXExsZi9uzZOHnypG6fsbGxBr+HymBSamXq1Kmj+3dOTg5ee+01dOzYEfPnz6/UHwJZnvh4QKXS/2JXqaT9Yiciepj4eGDAAMDbG0hOBgoLtffe3tpyqb6/5HI5Pv/8c5w5cwarV6/G3r17MWXKFL06t27dwty5c/Hdd9/h4MGDuHHjBl599VXd80lJSRg6dCjCw8Nx9uxZfPXVV4iNjcXcuXMNiuHu3btISUlBUFCQXlxBQUFITk4ud5vJkydj4MCB6NOnD3Jzc5Gbmws/Pz/cu3cPwcHBcHZ2RlJSEg4ePIjatWujT58+uHv3LkpKShASEoJevXrh1KlTSE5OxujRoyGTyTBo0CBMmjQJnp6eun0OGjSoCkfVAMIC5OfnCwAiPz9f6lAsSk5OjnjhhRcEAAFAdOnSRZw+fVrqsMgItmwRQiYTAtC/yWTa25YtUkdovUpKhNi3T4h167T3JSVSR0Skz5jn0Nu3b4uzZ8+K27dvV3rbkhIhVCoh+vUTQq3Wf06t1pY3bWqcv6lhw4aJ/v37G1x/8+bNom7durrHq1atEgDE4cOHdWXp6ekCgDhy5IgQQohnn31WzJs3T28/a9asEe7u7rrHAMTWrVvLfc2cnBwBQBw6dEiv/L333hM+Pj4Vxlree1uzZo14+umnhUaj0ZUVFxeLGjVqiJ9++kn8/fffAoBITEwsd5+RkZGiffv2Fb7moxj6OWFLqRVr1KgRtm/frhsleOzYMXTq1Alz587FvXv3pA6PqolaDYSHa9PQB5WWTZzIS/nGYI6XHYksRVKSdmnV6dMB+QPZiFwOTJumXWo1Kcn0sf3888949tln0bhxYzg7O2PIkCH4+++/cevWLV0dOzs7dO3aVfe4devWcHNzQ3p6OgDg5MmT+Oijj1C7dm3dbdSoUcjNzdXbjymcPHkSf/zxB5ydnXWx1KlTB3fu3MGff/6JOnXqYPjw4QgODka/fv0QExOD3Nxck8YI8PK91ZPJZBg2bBjOnDmDvn374t69e5gxYwb8/PxQXFwsdXhUDZKSgEuXKn5eCCA7W5ovdmtmrpcdiSxFac7j5VX+86Xlps6NMjMz0bdvX7Rr1w5btmxBSkoKli1bBkB7Sd1QRUVFmD17NlJTU3W306dP4/fff4eTk9Mjt69Xrx4UCgWuXLmiV37lyhW91R0NjaVz5856saSmpuL8+fMICwsDAKxatQrJycnw8/PDxo0b0apVKxw+fLhSr/O4mJTaiEaNGuGHH37AmjVr8MQTT6Bnz556K0SR5TL0C1uCH71WS60GJk0C+vYFtm0DunUDatfW3m/bpi2fPJmt00QP4+6uvU9LK//50vLSeqaSkpICjUaDRYsWoVu3bmjVqhUuX75cpl5JSQmOHTume3zu3DncuHEDbdq0AQB06tQJ586dQ4sWLcrc5A82DZfDwcEBnTt3xp49e3RlGo0Ge/bsQffu3R+63YPzlXfq1Am///476tevXyYWV1dXXb2OHTti2rRpOHToELy8vLBu3boK92kMdkZ/BTIbMpkMr7/+OoKCguDi4qIr/+OPP1BUVGSSOcio+hn6hW3qL3ZrVnrZcf36ii87+vlp6wUESBEhkfnz99cOxpw3T/tj7v6/JY0GiIoCmjbV1jOG/Px8pKam6pXVrVsXLVq0wL1797BkyRL069cPBw8exPLly8tsb29vjwkTJuDzzz+HnZ0dxo8fj27dusHHxwcAMHPmTPTt2xdNmjTBgAEDIJfLcfLkSaSlpeHjjz82KMaIiAgMGzYMXbp0gY+PD6Kjo3Hz5k2MGDGiwm1UKhV++uknnDt3DnXr1oWrqytee+01fPrpp+jfvz8++ugjeHh44OLFi4iPj8eUKVNw7949fP3113jppZfQqFEjnDt3Dr///juGDh2q22dGRgZSU1Ph4eEBZ2dn4zRsVbnXqglxoJPxlJSUiB49egg7Ozsxc+ZMUVxcLHVIVEklJUJ4eJQ/0Kl0sJNSyQE41WndOu2xLSws//mCAu3z69aZNi6i8pjrQCch/h2k2a+fEIcOaf92Dh3SPjbmIM1hw4bpBgHffxs5cqQQQojFixcLd3d3UaNGDREcHCy+++47AUBcv35dCKEd6OTq6iq2bNkimjVrJhwdHUVQUJC4ePGi3uskJCQIPz8/UaNGDeHi4iJ8fHzE119/rXseDxnoVGrJkiWiSZMmwsHBQfj4+OgNrirP1atXxXPPPSdq164tAIh9+/YJIYTIzc0VQ4cOFfXq1ROOjo6iWbNmYtSoUSI/P1/k5eWJkJAQ4e7uLhwcHMRTTz0lZs6cKdT/G4F2584d8corrwg3NzcBQKxatcrwgy0M/5zIhChveIR5KSgogKurK/Lz8/Va+OjxFRUVYcSIEYiLiwMAeHt7Y9WqVejcubPEkVFllPZvBPQHPMlk2vu4OCA01PRxWavERO2gpuRk7SX7ByUna1tK9+1jS2llqdXaFubcXG3rvr8/oFBIHZVlM+Y59M6dO8jIyEDTpk0N6idZnvh4bXeY+6bMRNOmwMKF/N6yFoZ+Ttin1MbVrl0bmzdvxqZNm/Dkk0/i9OnT8PX1xQcffMCBUBYkNFSbeDZurF/u4cGE1Bjuv+yo0eg/Z4rLjtaKc+3aptBQ4I8/tD/i1q3T3v/+O7+3bBFbSknnr7/+wjvvvIMNGzYAANq2bYsff/wRTZo0kTgyMhRbmUyntHW6b19tH1IvL+3AjKgoYPt2/hiorNLj+eAZia39j8/cW0rJ+rGllCrtySefxPr167FlyxbUr18fDg4OcOfoGIuiUGgvFw8erL1nQmo8pa3Tp09rL9W7uGjv09KYQFUW59olIoCj76kcoaGh6NWrF/755x/Y29sD0M7Ndvr0afY1JbpPaCjQvz9bpx9XZebaZR9dIuvFllIqV926ddGyZUvd43nz5sHHxweTJ0/G7du3JYyMyLxYW+u0Wq0dyLV+vfbeFK2TnGuXiAAmpWQAIQQuXbqkm0y4Q4cOOHjwoNRhkQ2RIlGyRVINNOJcu0QEMCklA8hkMnzzzTfYvn07GjVqhPPnz8Pf3x/vvvuuydfvJdvD9eX/ZczkvHSg0YOX0XNyjL9sqr+/dqaI0kFND5LJAKWSsxkQWbsqJaXLli2DSqWCk5MTfH19cfTo0YfWj46OxtNPP40aNWpAqVTi3XffxZ07d6oUMEnnxRdfxJkzZzBixAgIIRAdHY127drpLbNGVJ24vvy/jJmcSz3QSKEAYmK0/34wMS19HB1t+V0jiOjhKp2Ubty4EREREYiMjMTx48fRvn17BAcH4+rVq+XWX7duHaZOnYrIyEikp6fj22+/xcaNGzF9+vTHDp5Mz83NDStXrsSPP/4IDw8PXL58GW5ublKHRVaI68v/y9jJeWUGGhkL59olokonpYsXL8aoUaMwYsQItG3bFsuXL0fNmjWxcuXKcusfOnQIPXr0QFhYGFQqFXr37o3Bgwc/tHW1uLgYBQUFejcyL3369EFaWhp++OEHtGjRQlf+559/ShgVWZPS9eWnT694ffmMDOMmSubAFMm5uQw0Cg3V/p/fP4l6RgYTUjI/sbGx1dIgI5PJsG3btsfej7WoVFJ69+5dpKSkICgo6N8dyOUICgpCcnJyudv4+fkhJSVFl4ReuHABO3fuxAsvvFDh60RFRcHV1VV3UyqVlQmTTMTV1VXvs5CUlIRWrVph7NixKCwslDAysgalCZCXV/nPl5bn5JgmHqmYIjk3p4FG1jabAZmn4cOHIyQkROowHumXX35Bv3790KhRI4MT2FmzZqFDhw7VGkd1JeGPUqmk9Nq1a1Cr1WjQoIFeeYMGDZCXl1fuNmFhYfjoo4/Qs2dP2Nvbo3nz5ggICHjo5ftp06YhPz9fd8vOzq5MmCSR/fv3Q6PR4Msvv4S3tzd+/vlnqUMiC1aaAKWllf98afnEidbdt9TQ5PxxWjE50IikptaokZiZiPWn1yMxMxFqjQ30yzHAzZs30b59eyxbtkzqUEzC6KPvExMTMW/ePHzxxRc4fvw44uPjsWPHDsyZM6fCbRwdHeHi4qJ3I/M3Y8YM7NmzByqVChcvXsRzzz2H0aNHs/sFVcmj1pefOxewswOuXbPuQU+GJueP04rJgUYkpfj0eLRY0gKBqwMRFh+GwNWBaLGkBeLTpfujXrx4Mby9vVGrVi0olUqMHTsWRUVFZept27YNLVu2hJOTE4KDg8s0on3//ffo1KkTnJyc0KxZM8yePRslJSUGx/H888/j448/xssvv2xQ/djYWMyePRsnT56ETCaDTCZDbGwsAODGjRt488038eSTT8LFxQXPPPMMTp48qdv25MmTCAwMhLOzM1xcXNC5c2ccO3YMiYmJGDFiBPLz83X7nDVrlsHvoVJEJRQXFwuFQiG2bt2qVz506FDx0ksvlbtNz549xeTJk/XK1qxZI2rUqCHUarVBr5ufny8AiPz8/MqESxIpLCwU48aNEwAEAKFUKsWuXbukDoss0JYtQshkQvTrJ8ShQ0IUFGjvX3xRCO3wG+1NJhNCqRSipETqiKtfSYkQKpX2GDz4lalWa8ubNq2e975lixAeHvrHVqnUlpPlMuY59Pbt2+Ls2bPi9u3bVdp+y9ktQjZLJvqt6yeSs5NFYXGhSM5OFv3W9ROyWTKx5axxPnzDhg0T/fv3r/D5zz77TOzdu1dkZGSIPXv2iKefflqMGTNG9/yqVauEvb296NKlizh06JA4duyY8PHxEX5+fro6v/zyi3BxcRGxsbHizz//FLt27RIqlUrMmjVLVwdAmZyqIobUvXXrlpg0aZLw9PQUubm5Ijc3V9y6dUsIIURQUJDo16+f+PXXX8X58+fFpEmTRN26dcXff/8thBDC09NTvP766yI9PV2cP39ebNq0SaSmpori4mIRHR0tXFxcdPssLCw0KOZShn5OKpWUCiGEj4+PGD9+vO6xWq0WjRs3FlFRUeXW79Spk5gyZYpe2bp160SNGjVEiYHfokxKLdO+fftEs2bNBACxevVqqcMhC7VlixDu7vqJkp2d/uPS2759UkdrHBUl5/36acurM2ksKdEex3XrtPfWmOjbGnNNSkvUJUIVrRL91vUTao3+Ly61Ri36resnmkY3FSXq6v8QPiopfdDmzZtF3bp1dY9XrVolAIjDhw/rytLT0wUAceTIESGEEM8++6yYN2+e3n7WrFkj3N3ddY+rOykVQojIyEjRvn17vbKkpCTh4uIi7ty5o1fevHlz8dVXXwkhhHB2dhaxsbHl7nPVqlXC1dXVoDjLY+jnxK6yLasREREYNmwYunTpAh8fH0RHR+PmzZsYMWIEAGDo0KFo3LgxoqKiAAD9+vXD4sWL0bFjR/j6+uKPP/7Ahx9+iH79+kHBa0FWLSAgAKdOncJ///tfDBkyRFf+999/o27duhJGRpYkNBS4fRt4/fV/yyq6+mWty1CWTpc0aRLg5/dvedOm1T9dUulAIyJjS8pKQuaNTKx/ZT3kMv3ehHKZHNN6ToPfSj8kZSUhQBVg0th+/vlnREVF4bfffkNBQQFKSkpw584d3Lp1CzVr1gQA2NnZoWvXrrptWrduDTc3N6Snp8PHxwcnT57EwYMHMXfuXF0dtVpdZj+mcPLkSRQVFZU5996+fVs3a05ERATefPNNrFmzBkFBQfh//+//oXnz5iaLEQAqnZQOGjQIf/31F2bOnIm8vDx06NABCQkJusFPWVlZkN83RHTGjBmQyWSYMWMGcnJy8OSTT6Jfv356/0lkvWrVqoW33npL9/j69evw9vZGcHAwFi9ejCeeeELC6MhSPDh3ZUWseRnK0FCgf3/tKPvcXO179fdnP0+yXLmF2l+RXvXLH8VXWl5az1QyMzPRt29fjBkzBnPnzkWdOnVw4MABjBw5Enfv3jU4mSwqKsLs2bMRWs6vRicnp+oO+5GxuLu7IzExscxzpaPqZ82ahbCwMOzYsQM//vgjIiMjsWHDBoP7s1aHSielADB+/HiMHz++3OcefMN2dnaIjIxEZGRkVV6KrMyuXbuQl5eH2NhY/PTTT/jqq6/Qr18/qcMiM1c6Ojwnp/xVh2Qy7fPWPjqcrZhkTdydtb8i066moZtHtzLPp11N06tnKikpKdBoNFi0aJGukW3Tpk1l6pWUlODYsWPw8fEBAJw7dw43btxAmzZtAACdOnXCuXPn9ObyNgUHBweoH5i4uFOnTsjLy4OdnR1UKlWF27Zq1QqtWrXCu+++i8GDB2PVqlV4+eWXy92nMRh99D3R/QYNGoQDBw7g6aefRm5uLl566SUMGTIE//zzj9ShkRnj6HAi6+PfxB8qNxXmJc2DRuhPsaERGkQdiEJTt6bwb2KcX5v5+flITU3Vu2VnZ6NFixa4d+8elixZggsXLmDNmjVYvnx5me3t7e0xYcIEHDlyBCkpKRg+fDi6deumS1JnzpyJ7777DrNnz8aZM2eQnp6ODRs2YMaMGQbHWFRUpIsNADIyMpCamoqsrKwKt1GpVLp6165dQ3FxMYKCgtC9e3eEhIRg165dyMzMxKFDh/DBBx/g2LFjuH37NsaPH4/ExERcvHgRBw8exK+//qpLsFUqFYqKirBnzx5cu3YNt27dqsSRroQq91o1IQ50sj63bt0S7733npDL5QKAaNCggcGdvcl2cXQ4UeWZ60AnIfRH3x/KOiQK7hSIQ1mHTDL6Hv+bIeb+28iRI4UQQixevFi4u7uLGjVqiODgYPHdd98JAOL69etCiH8H/mzZskU0a9ZMODo6iqCgIHHx4kW910lISBB+fn6iRo0awsXFRfj4+Iivv/5a9zweMXhp37595cY5bNiwCre5c+eOeOWVV4Sbm5sAIFatWiWEEKKgoEBMmDBBNGrUSNjb2wulUilee+01kZWVJYqLi8Wrr74qlEqlcHBwEI0aNRLjx4/X+399++23Rd26dQUAERkZWanjbejnRCZEeRfDzEtBQQFcXV2Rn5/POUutzJEjRzBixAikp6fj9ddfx5o1a6QOicycWs1+lUSVYcxz6J07d5CRkYGmTZtWuZ9kfHo8Ju2ahMwbmbqypm5NsbD3QoS24Rqz1sDQz0mV+pQSVRdfX18cP34cn3zyiV4/5eLiYjg6OkoYGZkr9qsksi6hbULR/+n+SMpKQm5hLtyd3eHfxB8KOX9t2hompSQ5JycnzJw5U/dYCIGBAwfC0dERS5cuRf369SWMjoiIjE0hV5h82icyPxzoRGYnLS0NO3bswObNm+Hp6YlNmzbBAnqZEBER0WNgUkpmx9vbG0eOHIG3tzeuXbuGQYMGYcCAAbhy5YrUoREREZGRMCkls9S5c2ccO3YMkZGRsLOzQ3x8PNq2bYt169ax1ZSIyMzwe5kextDPB5NSMlsODg6YNWsWfv31V3To0AH//PMPZsyYgTt37kgdGhERQTtXJwDjzVtJVqH081H6eakIBzqR2evQoQOOHj2K+fPnw9/fHzVq1ADw7y8v2YOzqRMRkUkoFAq4ubnh6tWrAICaNWvyO5l0hBC4desWrl69Cjc3NygeMX8f5ykli7V06VIkJCTgq6++QmNDF0cnIrIxxj6HCiGQl5eHGzduVPu+yTq4ubmhYcOGj/zBwqSULNLNmzfRpEkT/PPPP3B1dcVnn32G4cOH8xc6EdEDTHUOVavVuHfvntH2T5bJ3t7+kS2kpZiUksU6c+YMRowYgV9//RUA0KdPH3z99ddQKpUSR0ZEpsIVvh6N51CyFBzoRBbL09MThw4dwoIFC+Do6IiEhAR4eXnhm2++4UhQIhsQHw+oVEBgIBAWpr1XqbTlRGR52FJKViE9PR1vvPEGDh8+DIVCgbS0NLRu3VrqsIjISOLjgQEDgAfPYKU9eOLigFAumw6A51CyHExKyWqo1WpER0fj1q1b+PDDD6UOh4iMRK3WtoheulT+8zIZ4OEBZGTwUj7AcyhZDl6+tzJqjRqJmYlYf3o9EjMTodaopQ7JZBQKBSZNmqSXkJ4+fRrPP/88MjIyJIyMiKpTUlLFCSmgbT3NztbWIyLLwXlKrUh8ejzCE8JxqeDfb2sPFw/E9IlBaBvbvI41btw4JCUlwdvbGwsWLMCYMWMgl/O3GJEly82t3npEZB54drYS8enxGLBpgF5CCgA5BTkYsGkA4tNts+f/ypUr4e/vj5s3b2L8+PF45pln8Oeff0odFhE9Bnf36q1HROaBSakVUGvUCE8Ih0DZ7sGlZRMTJtrUpfxSLVq0QGJiIpYsWYKaNWti//79aNeuHZYsWQKNRiN1eERUBf7+2j6jFU1LLJMBSqW2HhFZDialViApK6lMC+n9BASyC7KRlGWaDlbm1q9VLpdj/PjxOH36NAICAnDr1i288847WL9+vaRxEVHVKBRATIz23w8mpqWPo6M5yInI0rBPqRXILTSs45Sh9R5HfHo8Ju2ahMwbmboylZsKi3ovkrxfa7NmzbBnzx589dVX2Lp1K1599VVJ4yGyBlJNXh8aqp32KTxcf9CTh4c2IeV0UESWhy2lVsDd2bCOU4bWq6rSfq3e9b2RPDIZhdMKkTwyGd71vU3Sr9WQFlq5XI4xY8bgp59+0i17dvv2bQwZMgTnzp0zanxE1iY+HmjRQn/y+hYtTDd5fWgokJkJ7NsHrFunvc/IYEJKZKk4T6kVUGvUUMWokFOQU26/Uhlk8HDxQEZ4BhRy4zRhqDVqtFjSAt71vbHt1W2Qy/79vaMRGoRsCEHa1TT8PuF3o8TwODMPTJ8+HVFRUXB0dMScOXMQERFh8Dq9RLaqdPL6vn2B6dMBLy8gLQ2YNw/Yvp2T15sTnkPJUrCl1Aoo5ArE9NF2sJJBv4NV6ePoPtFGS0gBbb/WzBuZmO4/XS8hBQC5TI5pPach40aGUfq1Pu7MA2+//TZ69+6N4uJiTJkyBT169EB6enq1x0lkLdRqYNIkbUK6bRvQrRtQu7b2fts2bfnkydp6RESGYlJqJULbhCJuYBwauzTWK/dw8UDcwDij9+cs7a/qVd+r3OdLy6u7X2t1zDzQpEkTJCQk4Ntvv4WLiwuOHDmCjh07Yv78+SgpKanWeImsQVKS9rL59OnAg9P+yuXAtGnay+icvJ6IKoNJqRUJbROKzPBM7Bu2D+tC12HfsH3ICM8wyQCj0v6qaVfTyn2+tLy6+7VW18wDMpkMb7zxBs6cOYPnn38excXFmDZtGqZMmVKt8RJZg9JJ6b3K/w2qK+fk9URUGUxKrYxCrkCAKgCDvQcjQBVg1Ev29/Nv4g+VmwrzkuZBI/Tn/9QIDaIORKGpW1P4N6neiQOre+YBDw8P7NixA6tWrUKTJk3w7rvvPk54RFapdFL6tPJ/g+rKOXk9EVUGk1KqFgq5Aot6L8L289sRsiEEydnJKCwuRHJ2MkI2hGD7+e1Y2HthtSfJxph5QCaTYfjw4fjjjz+gVCp15fPnz8epU6cqHSORtfH3B1Qq7aCmB9eg0GiAqCigaVNOXk9ElcOklKpNab/W01dPw2+lH1zmu8BvpR/SrqYZrV+rfxN/eLh4lBngVUoGGZQuyiq10Nrb2+v+vWvXLkybNg1dunTBRx99hHv37lU5ZiJLp1AAixZpR9mHhADJyUBhofY+JERbvnAhJ68nosrhlFBU7dQaNZKykpBbmAt3Z3f4N/E3ajeC0tH3APQGPJUmqtWREOfl5WHMmDHYtm0bAKB9+/aIjY1Fhw4dHmu/RJYsPl47Cj8z89+ypk21CSmngzIfPIeSpWBSSlahvHlKlS5KRPeJrrYWWiEENm7ciPHjx+Pvv/+GnZ0dpk+fjg8++AAODg7V8hpElqa6VnSSamUoW8BzKFkKJqVkNUzVQnvlyhWMGzcOW7ZsAQAEBQVh9+7d1f46RLYiPr785UJjYtjiWh14DiVLwaSUqIo2b96MsWPH4ssvv8SAAQOkDofIIpWuDPXgmUj2v27iXBnq8fEcSpaCSSnRY8jPz4erq6vu8Y8//oi6devCx8dHwqiILINarR3Ff6mCqYZlMm2LaUYGL+U/Dp5DyVJw9D3RY7g/Ib169SqGDBmC7t27Y+rUqbhz546EkRGZv6SkihNSQNt6mp3NlaGIbAWTUqJqYmdnh+DgYGg0GixYsAAdO3bE4cOHpQ6LyGwZuuITV4Yisg1MSomqSZ06dbB27Vps3boVDRo0wG+//YYePXrgvffew+3bt6UOj8jsGLriE1eGIrINTEqJqllISAjOnj2LIUOGQKPRYOHChejYsSOKioqkDo3IrPj7a/uMyspf+wIyGaBUcmUoIlvBpJTICOrUqYPvvvsOP/zwA9zd3dGrVy/Url1b6rCIzIpCoZ32CSibmJY+jo7mICciW8HR90RGdv36ddjZ2cHZ2RkAcPHiRWRlZcGfzT9EAMqfp1Sp1CaknA7q8fEcSpaCSSmRCQkh0Lt3b+zZswfjx49HVFQUatWqJXVYRJLjik7Gw3MoWQpevicyoeLiYqhUKgghsGTJErRr1w6JiYlSh0UkOYUCCAgABg/W3jMhJbI9TEqJTMjJyQkrVqzATz/9BKVSiQsXLiAwMBDjxo3jQCgiIrJpVUpKly1bBpVKBScnJ/j6+uLo0aMPrX/jxg2MGzcO7u7ucHR0RKtWrbBz584qBUxkDXr37o20tDS89dZbAIAvvvgCXl5e+O233ySOjIiISBqVTko3btyIiIgIREZG4vjx42jfvj2Cg4Nx9erVcuvfvXsXzz33HDIzMxEXF4dz585hxYoVaNy48WMHT2TJXFxcsHz5cvz8889QqVSoUaMGVCqV1GERERFJotIDnXx9fdG1a1csXboUAKDRaKBUKjFhwgRMnTq1TP3ly5fj008/xW+//QZ7e/sqBclO2mTtioqKkJubi5YtWwIASkpKcPjwYfTs2VPiyIjI0vEcSpaiUi2ld+/eRUpKCoKCgv7dgVyOoKAgJCcnl7vNDz/8gO7du2PcuHFo0KABvLy8MG/ePKjV6gpfp7i4GAUFBXo3ImtWu3ZtXUIKAIsXL4a/vz/efPNN5OfnSxgZERGRaVQqKb127RrUajUaNGigV96gQQPk5eWVu82FCxcQFxcHtVqNnTt34sMPP8SiRYvw8ccfV/g6UVFRcHV11d2USmVlwiSyeNeuXQMAfPvtt/Dy8sKPP/4ocURERETGZfTR9xqNBvXr18fXX3+Nzp07Y9CgQfjggw+wfPnyCreZNm0a8vPzdbfs7Gxjh0lkVj755BPs378fzZs3x6VLl/DCCy9gxIgRuH79+mPvW60GEhOB9eu19w+5aEFERGQylUpK69WrB4VCgStXruiVX7lyBQ0bNix3G3d3d7Rq1QqK+yada9OmDfLy8nD37t1yt3F0dISLi4vejcjW/Oc//8GpU6fw7rvvQiaTITY2Fl5eXti/f3+V9xkfD6hUQGAgEBamvVeptOVERERSqlRS6uDggM6dO2PPnj26Mo1Ggz179qB79+7lbtOjRw/88ccf0Gg0urLz58/D3d0dDg4OVQybyDbUrFkTixcvxoEDB9CqVStcu3YNTz75ZJX2FR8PDBigv5QjAOTkaMuZmBIRkZQqffk+IiICK1aswOrVq5Geno4xY8bg5s2bGDFiBABg6NChmDZtmq7+mDFj8M8//yA8PBznz5/Hjh07MG/ePIwbN6763gWRlfPz80Nqaip+/PFHtG3bVldu6LymarV2bfHy5tooLZs4kZfyiYhIOnaV3WDQoEH466+/MHPmTOTl5aFDhw5ISEjQDX7KysqCXP5vrqtUKvHTTz/h3XffRbt27dC4cWOEh4fj/fffr753QWQDatSogWeeeUb3+Ndff0W3bt0waNAgfP7556hXr16F2yYllW0hvZ8QQHa2tl5AQDUGbWW4PjsRkfFUep5SKXCONaKyli5divDwcN1gwi+++AKvvPJKuXXXr9f2IX2Udeu0a49TWfHx2tbm+5N7Dw8gJgYIDZUuLqJH4TmULIXRR98TkXGMHz8eycnJaNu2La5evYoBAwbormQ8yN3dsH0aWs/WsD8uEZHxMSklsmA+Pj44fvw4PvjgAygUCmzatAlt27ZF/ANZkr+/tlVPJit/PzIZoFRq65E+9sclIjINJqVEFs7R0REff/wxjhw5Am9vb1y7dg1Xr17Vq6NQaC8zA2UT09LH0dHsH1meyvTHJSKiqmNSSmQlOnfujGPHjuHbb7/F6NGjdeVXrlyBEAKhoUBcHNC4sf52Hh7acvaLLF9ubvXWIyKi8lV69D0RmS8HBwe88cYbuseFhYXw9fVFx44d8eWXXyI0tCH69+cI8spgf1wiItNgUkpkxQ4cOIDLly/j4sWL2L9/Pz7//HO89tprCAiooHMplVHaHzcnp/x+pTKZ9nn2xyUiejy8fE9kxZ5//nkcO3YMnTp1wvXr1zFkyBD0798fly9fljo0i8H+uEREpsGklMjKtWvXDocPH8bcuXPh4OCA//u//4OnpydWr14NC5im2CywPy4RkfFx8nwiG3LmzBmMGDECv/76K0JDQxEXFwdZRfNEURlc0YksEc+hZCmYlBLZmJKSEl3f0tLlgW/fvg0nJycmqERWiOdQshS8fE9kY+zs7BAREaFLSAHgjTfeQJ8+fZCVlSVhZEREZMuYlBLZuAsXLmDbtm3YtWsXvLy88PXXX7OvKRERmRyTUiIb16xZM6SmpsLPzw+FhYV466230Lt3b2RmZkodGhER2RAmpUSEp59+Gr/88gs+++wz1KhRAz///DO8vb3x5ZdfQqPRSB0eERHZACalRAQAUCgUmDhxIk6dOgV/f38UFRVh7ty5KCoqkjo0IiKyAVzRiYj0tGjRAomJiVi2bBlatmypG60rhIAQAnI5f8sSEVH149mFiMqQy+WYMGEC+vTpoytbtWoVAgMD8ccff0gYGRERWSsmpUT0SHfv3sXMmTPxyy+/oF27dvjss8+gVqulDouIiKwIk1IieiQHBwccOHAAzz77LG7fvo2IiAj85z//wblz56QOjYiIrASTUiIyiEqlwu7du/HVV1/B2dkZhw4dQocOHfDpp5+y1ZSIiB4bk1IiMphMJsPo0aORlpaG3r17486dO3j//feRmpoqdWhERGThOPreAqg1aiRlJSG3MBfuzu7wb+IPhVwhdVhkw5o0aYKEhASsXLkSWVlZ6Ny5s9QhERGRhWNSaubi0+MRnhCOSwWXdGUeLh6I6ROD0DahEkZGtk4mk2HkyJF6ZefOncNbb72FZcuWwdPTU6LIzJdaDSQlAbm5gLs74O8PKPj7kogIAC/fm7X49HgM2DRALyEFgJyCHAzYNADx6fESRUZUvoiICOzfvx+dOnXCvHnzUFJSInVIZiM+HlCpgMBAICxMe69SacuJiIhJqdlSa9QITwiHgCjzXGnZxISJUGs4wITMx9dff42+ffvi7t27+OCDD+Dr64tTp05JHZbk4uOBAQOAS/q/L5GToy1nYkpExKTUbCVlJZVpIb2fgEB2QTaSspJMGBXRwzVu3Bg//PAD1qxZgyeeeALHjx9Hly5d8NFHH+HevXtShycJtRoIDwdE2d+XurKJE7X1iIhsGZNSM5VbmFut9YhMRSaT4fXXX8eZM2fQv39/3Lt3D5GRkfjmm2+kDk0SSUllW0jvJwSQna2tR0Rky5iUmil3Z/dqrUdkau7u7ti6dSvWrVuH5557Dm+++abUIUki18DfjYbWIyKyVkxKzZR/E394uHhABlm5z8sgg9JFCf8m/iaOjMhwMpkMgwcPxk8//QR7e3sA2iVLw8LCcPz4cYmjMw13A383GlqPiMhaMSk1Uwq5AjF9YiAgYCfXn7nLTm4HAYHoPtGcr5Qsgkz274+rhQsXYv369fDx8cGMGTNQXFwsYWTG5+8PeHgAsvJ/X0ImA5RKbT0iIlvGpNTMySBDn+Z9kDwyGYXTCpE8MhnBzYMrbEElMnejRo3CwIEDoVarMXfuXHTu3Bm//vqr1GEZjUIBxMRo//1gYlr6ODqa85USEcmEKG9MqHkpKCiAq6sr8vPz4eLiInU4JqHWqNFiSQt41/fGtle3QS779/eDRmgQsiEEaVfT8PuE39laShZpy5YtGDt2LK5evQq5XI733nsPs2bNgpOTk9ShGUV8vHYU/v2DnpRKbUIaagHrYHDif8tli+dQskw22VKq1qiRmJmI9afXIzEz0Szn+kzKSkLmjUxM95+ul5ACgFwmx7Se05BxI4NTQpHFeuWVV3DmzBmEhYVBo9FgwYIFGDdunNRhGU1oKJCZCezbB6xbp73PyLCMhJQT/xORKdjcMqOWsmxn6VRPXvW9yn2+tJxTQpElq1evHtauXYv/9//+HyZNmoTp06dLHZJRKRRAQIDUUVRO6cT/D15TK534Py7OMhJrIjJ/NtVSaknLdpZO9ZR2Na3c50vLOSUUWYOQkBCcP38ezZs315V98sknOHTokIRRESf+JyJTspmk1NKW7fRv4g+VmwrzkuZBIzR6z2mEBlEHotDUrSmnhCKrobivg2JSUhLef/999OzZExEREbh165aEkdkuTvxPRKZkM0mppS3bqZArsKj3Imw/vx0hG0KQnJ2MwuJCJGcnI2RDCLaf346FvRdykBNZJS8vLwwfPhxCCHz22Wdo3749kpj5mBwn/iciU7KZpNQSl+0MbROKuIFxOH31NPxW+sFlvgv8Vvoh7Woa4gbGmVUfWKLq9MQTT2DVqlXYuXMnGjdujD/++AO9evVCeHg4bt68KXV4NoMT/xORKdnMlFCJmYkIXB34yHr7hu1DgCqgSq9hLGqNGklZScgtzIW7szv8m/izhZRsRn5+PiZPnoxvvvkGANClSxccPXpUb0J+Mg61WjvKPien/H6lMpl2YYCMDE4PZc44JRRZCptpKbXkZTsVcgUCVAEY7D0YAaoAJqRkU1xdXbFixQokJCRAqVTinXfeYUJqIpz4n4hMyWaS0tJlOwGUSUxLH3PZzsqzhDlfyToEBwcjPT0dr7/+uq5s165d2LNnj4RRWb/QUO20T40b65d7eHA6KCKqXjZz+b5UefOUKl2UiO4TzT6alWQpc76Sdfrnn3/g6emJvLw8vPXWW/jkk094adKIuKKT5eLle7IUNpeUAuyjWR1K53x9cIqt0lZnDsQiYysqKsL777+PL774AgCgVCrxzTffoHfv3hJHRmRemJSSpbDJpJQej1qjhipGVeEUWzLI4OHigYzwDCb7ZHT79u3DyJEjkZGRAQAYOXIkFi1aBFdXV4kjIzIPPIeSpbCZPqVUfSxtzleyboGBgTh16hQmTJgAAPj222/h5eWFv//+W+LIiIioMqqUlC5btgwqlQpOTk7w9fXF0aNHDdpuw4YNkMlkCAkJqcrLkpmwxDlfybrVrl0bn3/+Ofbv34/mzZsjMDAQdevWlTosIiKqhEonpRs3bkRERAQiIyNx/PhxtG/fHsHBwbh69epDt8vMzMTkyZPh729+Uy5R5bg7GzZTtqH1iKrLf/7zH5w6dQpLlizRlV2+fBk7duyQMCoiIjJEpZPSxYsXY9SoURgxYgTatm2L5cuXo2bNmli5cmWF26jVarz22muYPXs2mjVr9lgBk/Qsec5Xsn41a9bU9ScVQuDtt99G3759MXToUPzzzz8SR0dERBWpVFJ69+5dpKSkICgo6N8dyOUICgpCcnJyhdt99NFHqF+/PkaOHGnQ6xQXF6OgoEDvRuaDc76SpVCr1Xj66achl8uxZs0aeHp64vvvv5c6LCIiKkelktJr165BrVajQYMGeuUNGjRAXl5eudscOHAA3377LVasWGHw60RFRcHV1VV3UyqVlQmTTCC0TSjiBsahsYv+jNoeLh6cDorMhp2dHT799FMcPHgQrVu3Rl5eHkJCQhAWFoZr165JHR4REd3HqKPvCwsLMWTIEKxYsQL16tUzeLtp06YhPz9fd8vOzjZilFRVoW1CkRmeiX3D9mFd6DrsG7YPGeEZTEjJ7HTr1g0nTpzA+++/D7lcjvXr18PT0xPHjx+XOjQiIvofu8pUrlevHhQKBa5cuaJXfuXKFTRs2LBM/T///BOZmZno16+frkyj0Whf2M4O586dQ/Pmzcts5+joCEdHx8qERhJRyBUIUAVIHcZj44IK1s/JyQnz589HaGgoRowYgTt37uDpp5+WOiwiIvqfSiWlDg4O6Ny5M/bs2aOb1kmj0WDPnj0YP358mfqtW7fG6dOn9cpmzJiBwsJCxMTE8LI8mYX49HhM2jUJmTcydWUqNxUW9V7EVl8r5OPjg+PHjyMrKwu1atUC8O/32HPPPSdxdEREtqvSl+8jIiKwYsUKrF69Gunp6RgzZgxu3ryJESNGAACGDh2KadOmAdC2THh5eend3Nzc4OzsDC8vLzg4OFTvuyGqpNLlUr3reyN5ZDIKpxUieWQyvOt7Y8CmAYhPj5c6RDICR0dHtGzZUvd42bJl6N27NwYMGFDmShAREZlGpZPSQYMGYeHChZg5cyY6dOiA1NRUJCQk6AY/ZWVlITeXk6aT+VNr1Ji0axL6tuqLba9uQzePbqjtUBvdPLph26vb0LdVX0zeNRlqjVrqUMnIioqKYGdnhy1btsDT0xPr16+HBazATERkVWTCAr55uW4vGUNiZiICVwcieWQyunl0K/N8cnYy/Fb6Yd+wfVbRb5Ye7sSJExgxYgROnjwJAAgJCcGXX35Zbn95IkvCcyhZCqOOvicyZ6XLoHrV9yr3+dJyLpdqGzp27IijR49i9uzZsLOzw7Zt29C2bVubWg1KrQYSE4H167X3al4kICITYlJKNqt0GdS0q2nlPl9azuVSbYeDgwNmzpyJlJQUdOrUCQUFBXB3t43///h4QKUCAgOBsDDtvUqlLSciMgUmpWSz/Jv4Q+WmwrykedAIjd5zGqFB1IEoNHVryuVSbVC7du1w+PBh/Pzzz+jUqZOu/NSpU1bZ1zQ+HhgwALh0Sb88J0dbzsSUiEyBSSnZLIVcgUW9F2H7+e0I2RCC5OxkFBYXIjk7GSEbQrD9/HYs7L2Q85XaKHt7ewQEBOgenzp1Cl26dMGLL76ISw9mbxZMrQbCw4Hycu3SsokTeSmfiIyPSSnZtNLlUk9fPQ2/lX5wme8Cv5V+SLuaxuVSSc/Jkychk8nw448/wtPTE99++61VtJomJZVtIb2fEEB2trYeEZExcfQ9EbiiExnm7NmzeOONN3DkyBEAQO/evbFixQo0adJE4siqbv16bR/SR1m3Dhg82PjxUPXjOZQsBVtKifDvcqmDvQcjQBXAhJTK1bZtWxw8eBCffvopHB0dsWvXLnh5eWHVqlVSh1Zlho7jspHxXkQkISalRESVoFAoMHnyZKSmpqJ79+4oLCzE9evXpQ6ryvz9AQ8PQCYr/3mZDFAqtfWIiIyJSSkRURW0bt0aSUlJWLNmDcLDw3Xlly9fhkajeciW5kWhAGJitP9+MDEtfRwdra1HRGRMTEqJiKpIoVDg9ddfh+J/GdutW7cQEBCAZ599FhcuXJA4OsOFhgJxcUDjxvrlHh7a8lCO9yMiE2BSSkRUTY4fP46cnBwkJibC29sbS5cutZhW09BQIDMT2LdPO6hp3z4gI4MJKRGZDkffExFVoz///BMjR47E/v37AQD/+c9/8O2336JFixYSR0a2iudQshRsKSUiqkbNmzfH3r17sWzZMtSqVQu//PIL2rVrh+jo6Cq3mnJNeiKyBUxKiYiqmVwux9ixY3H69Gk888wzuH37Nnbt2gVZRUPcH4Jr0hORreDleyIiIxJCYMWKFXj++eehVCoBaAdEOTo66gZIVaR0TfoHv6VLc1sOQiJD8BxKloJJKRFZBGtadWvkyJE4e/YsVq1ahdatW5dbR63WtohWtASoTKYdHZ+Rwema6OF4DiVLwcv3RGT24tPjoYpRIXB1IMLiwxC4OhCqGBXi0y3vGnZeXh7i4uJw+PBhdOjQAQsWLEBJSUmZelyTnohsDZNSIjJr8enxGLBpAC4V6GdoOQU5GLBpgMUlpg0bNkRaWhr69OmD4uJiTJ06FX5+fjhz5oxevdxcw/ZnaD0iInPHpJSIzJZao0Z4QjgEyvYyKi2bmDARao1lDUdXKpXYuXMnVq1aBVdXV/z666/o1KkToqKidK2mXJOeiGwNk1IiE1Nr1EjMTMT60+uRmJlocQmVKSVlJZVpIb2fgEB2QTaSsizvGrZMJsPw4cNx5swZvPjii7h79y6io6ORn58PgGvSE5HtsZM6ACJbEp8ej/CEcL1Ey8PFAzF9YhDahsOoH5RbaNi1aUPrmaPGjRvj//7v//Df//4Xbm5uqFu3LgBALhdYvFiNQYPsIJPpj8DnmvREZI3YUmoAtmxRdbC2vpGm4O5s2LVpQ+uZK5lMhiFDhqBfv366sg0bNiAqygcLF57kmvREZBM4JdQjxKfHY9KuSci8kakrU7mpsKj3IrZskcHUGjVUMaoKL0XLIIOHiwcywjMsdpojYyg9bjkFOeX2K7XW46ZWq+Hp6Ylz587Bzs4O06Z9AH//6bh2zQHu7tpL9mwhJUNxSiiyFGwpfYjSli3v+t5IHpmMwmmFSB6ZDO/63mzZokqx5r6RxqSQKxDTJwaANgG9X+nj6D7RVpWQAoBCocD+/fsRGhqKkpISzJkzG5Mnd0Xr1icQEMCElIisE5PSCqg1akzaNQl9W/XFtle3oZtHN9R2qI1uHt2w7dVt6NuqLybvmsxL+WQQW+gbaSyhbUIRNzAOjV30r2F7uHggbmCc1V6xaNCgAeLi4rBx40bUq1cPp06dQteuXfHhhx+iuLhY6vCIiKodk9IKJGUlIfNGJqb7T4dcpn+Y5DI5pvWchowbGWzZIoPYSt9IYwltE4rM8EzsG7YP60LXYd+wfcgIz7DahLSUTCbDwIEDcfbsWQwcOBBqtRoff/wxfv31V6lDIyKqdhx9X4HSFiuv+l7lPl9azpYtMoR/E394uHg8sm+kfxPO71MRhVyBAFWA1GFI4sknn8TGjRsxcOBAnDhxAj179tQ9J4SArKJ5o4iILAhbSitQ2mKVdjWt3OdLy9myRYaw1b6RVL1eeeUVfPzxx7rHmZmZ6NatG44cOSJhVERE1YNJaQX8m/hD5abCvKR50AiN3nMaoUHUgSg0dWvKli0ymK32jSTjmTp1Ko4ePQo/Pz9MmTIFt2/fljokIqIq45RQD1E6+r5vq76Y1nMavOp7Ie1qGqIORGH7+e1MJKhK1Bo1krKSkFuYC3dnd/g38WcLKVXJ33//jYkTJ+K///0vAODpp5/GypUr4efnJ3FkZE44JRRZCialj1DePKVN3ZpiYe+FTEiJyCz83//9H9566y3k5uZCJpPh3XffxZw5c1CzZk2pQyMzwKSULAWTUgOwZYuIzN3169cRERGB2NhYAMCCBQswZcoUaYMisyD1OZTIUExKiYisyI8//ojo6Gh8//33cHJykjocMgM8h5Kl4EAnIiIr8vzzz+Onn37SJaQlJSUYNGgQEhMTpQ2MiOgRmJQSEVmxL774Aps2bUJgYCDGjx+PoqIiqUMiIioXk1IiIis2fPhwjB49GgCwbNkyeHt7Y+/evRJH9fjUaiAxEVi/Xnuv5orPRBaPSSkRkRVzcXHBV199hd27d+Opp55CZmYmnn32WYwZMwaFhYVSh1cl8fGASgUEBgJhYdp7lUpbTkSWi0kpkRVSa9RIzEzE+tPrkZiZCLWGzUi2LigoCKdPn8aYMWMAAMuXL8eIESMkjqry4uOBAQOAS5f0y3NytOVMTIksF0ffE1mZ+PR4hCeE41LBv2dtDxcPxPSJ4dy6BADYt28fxo0bhy1btqBNmzZSh2MwtVrbIvpgQlpKJgM8PICMDEDBWft0eA4lS8GWUiIrUroK2f0JKQDkFORgwKYBiE9nMxIBgYGBSEtL00tIP/30UyQkJEgY1aMlJVWckAKAEEB2trYeEVkeJqVEVkKtUSM8IRwCZS9+lJZNTJjIS/kEAJDL//36P3bsGKZOnYrnn38eb7zxBm7cuCFdYA+Rm1u99YjIvDApJbISSVlJZVpI7ycgkF2QjaQsNiORvrZt2yI8PBwymQyrVq2Cp6cnduzYIXVYZbi7V289IjIvTEqJrERuoWHNQ4bWI9tRs2ZNLF68GElJSWjZsiUuX76Mvn37Yvjw4bh+/brU4en4+2v7jMpk5T8vkwFKpbYeEVkeJqVEVsLd2bDmIUPrke3p0aMHTp48icmTJ0Mul2P16tXo3r07SkpKpA4NgHbwUkyM9t8PJqalj6OjOciJyFIxKSWyEv5N/OHh4gEZym9GkkEGpYsS/k3YjEQVq1GjBj799FMcPHgQrVu3xrvvvgs7Ozupw9IJDQXi4oDGjfXLPTy05aGcYILIYnFKKCIrUjr6HoDegKfSRDVuYBynhSKD3blzB46OjpD9rxly3759uH79OkLNIPNTq7Wj7HNztX1I/f3ZQloRnkPJUlSppXTZsmVQqVRwcnKCr68vjh49WmHdFStWwN/fH0888QSeeOIJBAUFPbQ+EVVdaJtQxA2MQ2MX/WYkDxcPJqRUaU5OTrqEtKCgAMOHD8crr7yCZ/o9g6/2fyXpwgwKBRAQAAwerL1nQkpk+SrdUrpx40YMHToUy5cvh6+vL6Kjo7F582acO3cO9evXL1P/tddeQ48ePeDn5wcnJycsWLAAW7duxZkzZ9D4wesvFeCvPKLKUWvUSMpKQm5hLtyd3eHfxB8KOc/aVHXFxcUIeycM8d/EAxoANQG8CKh6qLCo9yL+4DFjPIeSpah0Uurr64uuXbti6dKlAACNRgOlUokJEyZg6tSpj9xerVbjiSeewNKlSzF06NBy6xQXF6O4uFj3uKCgAEqlkn9QREbCJJYepbRrSE+7nshZk4ML5y4AANx93JH7n1xseWMLE1MzxaSULEWlLt/fvXsXKSkpCAoK+ncHcjmCgoKQnJxs0D5u3bqFe/fuoU6dOhXWiYqKgqurq+6mVCorEyYRVUJ8ejxUMSoErg5EWHwYAlcHQhWj4upPpKPWqDFp1yT0bdUXidMTkX4qHR9++CHs7OyQezQX9svtMXETF2YgosdTqaT02rVrUKvVaNCggV55gwYNkJeXZ9A+3n//fTRq1EgvsX3QtGnTkJ+fr7tlZ2dXJkwiMhCXJSVDJGUlIfNGJqb7T4dcJoeDgwM++ugjHD16FO3bt0fP//RENrgwAxE9HpNOCTV//nxs2LABW7duhZOTU4X1HB0d4eLioncjourFZUnJUKULLnjV99Ir79ixI44ePYrvVn2nq/fXX39h/fr1sICJXYjIzFQqKa1Xrx4UCgWuXLmiV37lyhU0bNjwodsuXLgQ8+fPx65du9CuXbvKR0pE1YrLkpKhShdcSLuaVuY5BwcHZBdn6+pNmDABYWFhCAkJQS4XoSeiSqhUUurg4IDOnTtjz549ujKNRoM9e/age/fuFW73ySefYM6cOUhISECXLl2qHi0RVRsuS0qG8m/iD5WbCvOS5kEjNHrPaYQGUQei0NStKXoqe6Jdu3awt7fHDz/8gLZt22L16tVsNSUig1T68n1ERARWrFiB1atXIz09HWPGjMHNmzcxYsQIAMDQoUMxbdo0Xf0FCxbgww8/xMqVK6FSqZCXl4e8vDwUFRVV37sgokrjsqRkKIVcgUW9F2H7+e0I2RCC5OxkFBYXIjk7GSEbQrD9/HYs7L0Qdgo7TJ8+HcePH0eXLl1w48YNDB8+HH379kVOTo7Ub4OIzFyVVnRaunQpPv30U+Tl5aFDhw74/PPP4evrCwAICAiASqVCbGwsAEClUuHixYtl9hEZGYlZs2YZ9HqczoKo+qk1aqhiVMgpyCm3X6kMMni4eCAjPIPTQxEA7cC4SbsmIfNGpq6sqVtTLOy9sMx0UCUlJVi4cCEiIyNx9+5duLi4YMeOHejZs6eJoyaeQ8lScJlRIhvGZUmpsio7p+3Zs2fxxhtvICcnB2lpaXB1dTVhtATwHEqWg0kpkY2LT49HeEK43qAnpYsS0X2imZBStVCr1cjMzETz5s0BAEIIbN++HX379tUtY0rGw3MoWQompUTEFZ3IpL799lu8+eabeO6557BixQo89dRTUodk1XgOJUthJ3UARCQ9hVyBAFWA1GGQjbh37x6cnJywe/dueHl54ZNPPsFbb70FudykU2cTkZnhNwAREZnU22+/jVOnTqFnz54oKirC2LFjERQUhAsXLkgdGhFJiEkpERGZXMuWLbF//37ExMSgZs2a2LdvH7y9vbF+/XqpQyMiiTApJSKSmFqjRmJmItafXo/EzESbWdpVLpfjnXfewalTp9CrVy/cvn0bKpVK6rCISCLsU0pEJKHyZj/wcPFATJ8Ym5n9oHnz5ti7dy+Sk5P1Vgc8fvw4OnTowL6mRDaCf+lERBIpnSf2/oQUAHIKcjBg0wDEp8dLFJnpyeVy9OjRQ/f4t99+g5+fH3r16oXff/9dwsiIyFSYlBIRSUCtUSM8Ibzc1bRKyyYmTLSZS/kPOnfuHOzt7XHgwAG0a9cOixYtglptm8eCyFYwKSUikkBSVlKZFtL7CQhkF2QjKSvJhFGZj/79+yMtLQ1BQUG4c+cOJk+ejJ49e+K3336TOjQiMhImpUREEsgtzK3Wetboqaeewq5du7BixQo4Ozvj8OHD6NChAz777DOpQyMiI2BSSkQkAXdn92qtZ61kMhnefPNNnDlzBn369EFxcTFu3boldVhEZAQcfW+huCwkkWXzb+IPDxcP5BTklNuvVAYZPFw84N/EX4LozI9SqcTOnTuxZcsW9O/fX1d+6dIlNGzYEHZ2PJ0RWTq2lFqg+PR4qGJUCFwdiLD4MASuDoQqRmVTI3WJLJ1CrkBMnxgA2gT0fqWPo/tE88fmfWQyGQYMGAB7e3sAQHFxMZ5//nl069YNp0+fljg6InpcTEotDKeQIbIeoW1CETcwDo1dGuuVe7h4IG5gnM3MU1pVZ8+exaVLl5CSkoLOnTtjzpw5uHfvntRhEVEVyYQQZa8bmZmCggK4uroiPz8fLi4uUocjGbVGDVWMqsIRu6WX+zLCM9i6QmRB2B2n6nJzc/H222/jhx9+AAB07NgRq1atQvv27SWOzHzwHEqWgi2lFoRTyBBZJ4VcgQBVAAZ7D0aAKoAJaSW4u7tj27ZtWLt2LerUqYMTJ06gS5cumDVrFkpKSqQOj4gqgUmpBeEUMkREZclkMoSFheHMmTN4+eWXUVJSgv3793N5UiILw+GKFoRTyBARVaxhw4bYsmULNm3ahK5du+qS0lu3bkGhUMDR0VHiCInoYfgz0oKUTiHz4EjdUjLIoHRRcgoZIrJZMpkMgwYNQrNmzXRlU6ZMQefOnXHs2DEJIyOiR2FSakE4hQwRUeXcuHEDcXFxOHPmDLp164Zp06bhzp07UodFROVgUmphOIUMEZHh3NzckJaWhldffRVqtRrz589Hp06dcOTIEalDI6IHcEooC8UpZIiIKmfr1q0YM2YMrly5ArlcjkmTJmH27NmoUaOG1KEZFc+hZCmYlBIRkc34+++/ER4ejrVr1+KJJ57A2bNn0bBhQ6nDMiqeQ8lScPQ9ERHZjLp16+K///0vBg4ciJKSEr2E9O7du3BwcJAwOiLbxj6lRERkc1566SWEhv7bB//777+Hl5cXDhw4IGFURLaNSSkREdk0IQQ+/vhj/P777/jPf/6DiRMn4ubNm1KHRWRzmJQSkdlSa9RIzEzE+tPrkZiZCLVGLXVIZIVkMhl2796NN954A0IIxMTEoF27dti/f7/UoRHZFCalRGSW4tPjoYpRIXB1IMLiwxC4OhCqGBXi0+OlDo2skJubG7799lv8+OOP8PDwwIULFxAQEIAJEyagqKhI6vCIbAKTUiIyO/Hp8RiwaQAuFVzSK88pyMGATQOYmJLR9OnTB2fOnMHo0aMBAEuXLsXBgwcljorINnBKKCIyK2qNGqoYVZmEtJQMMni4eCAjPINz85JR7d69G3v37kVUVJSuTAgBmaz8pZ7NFc+hZCnYUkpEZiUpK6nChBQABASyC7KRlJVkwqjIFj333HN6CWlOTg46duyIn3/+WcKoiKwXk1IiMiu5hbnVWo+ousyePRsnT57Ec889h9GjRyM/P1/qkIisCpNSIhtnbiPc3Z3dq7UeUXVZvHgxxo8fDwBYsWIFvLy8kJCQIHFURNaDSSmRDTPHEe7+Tfzh4eIBGcrvtyeDDEoXJfyb+Js4MrJ1tWvXxpIlS5CYmIhmzZrh0qVLeP755zFy5EjcuHFD6vCILB6TUiIbZa4j3BVyBWL6xABAmcS09HF0n2gOciLJ9OrVC6dOnUJ4eDhkMhlWrlyJRYsWSR0WkcVjUkpkg9QaNcITwiFQdvKN0rKJCRMlu5Qf2iYUcQPj0NilsV65h4sH4gbGIbRNaAVbEplGrVq1EB0djV9++QV9+vTB1KlTpQ6JyOJxSigiG5SYmYjA1YGPrLdv2D4EqAKMH1AF1Bo1krKSkFuYC3dnd/g38WcLKZk1jUaDV199Fa+//jpeeuklqcMBwHMoWQ47qQMgItOzlBHuCrlC0qSYqLJiY2OxefNmbN68Ga+99hpiYmJQt25dqcMisgi8fE9kgzjCncg4Bg8ejClTpkAul2Pt2rXw9PTE1q1bpQ6LyCIwKSWyQRzhTmQcNWrUwIIFC3Do0CG0adMGV65cQWhoKF599VX89ddfUodHZNaYlBLZII5wJzIuX19fHD9+HNOmTYNCocDGjRvx2muvSR0WkVljUkpkozjCnci4nJycMG/ePBw+fBgdO3bEJ598InVIRGaNo+/pkTgC2rrx/5fI+IQQkMn+vSrx2WefoVGjRhg4cKBeuTHwHEqWgkkpPVR8ejzCE8L1Jlj3cPFATJ8YtqQREVXBmTNn0KFDB5SUlODll1/GF198gYYNGxrt9XgOJUtRpcv3y5Ytg0qlgpOTE3x9fXH06NGH1t+8eTNat24NJycneHt7Y+fOnVUKlkzLXFf8ISKyZC1btsSMGTNgZ2eHrVu3wtPTE2vXroUFtBERGVWlk9KNGzciIiICkZGROH78ONq3b4/g4GBcvXq13PqHDh3C4MGDMXLkSJw4cQIhISEICQlBWlraYwdPxmPuK/4QEVkqBwcHREZG4tixY+jYsSP++ecfvP766wgJCUFurrRzAxNJqdKX7319fdG1a1csXboUgHb1CqVSiQkTJpS7zNqgQYNw8+ZNbN++XVfWrVs3dOjQAcuXLy/3NYqLi1FcXKx7XFBQAKVSyUsPJmQpK/4QEVmye/fuYcGCBfjoo49w7949NG7cGH/88QecnJyq7TV4+Z4sRaVaSu/evYuUlBQEBQX9uwO5HEFBQUhOTi53m+TkZL36ABAcHFxhfQCIioqCq6ur7qZUKisTJlUDS1nxh4jIktnb22PGjBk4fvw4unTpgsmTJ1drQkpkSSq1zOi1a9egVqvRoEEDvfIGDRrgt99+K3ebvLy8cuvn5eVV+DrTpk1DRESE7nFpSymZDlf8ISIyHS8vLyQnJxt9JD6ROatUUmoqjo6OcHR0lDoMm1a64k9OQU65/UplkMHDxYMr/hARVRM7O7M8JROZTKUu39erVw8KhQJXrlzRK79y5UqF01k0bNiwUvXJPHDFHyIiIjKlSiWlDg4O6Ny5M/bs2aMr02g02LNnD7p3717uNt27d9erDwC7d++usD6ZD674Q0RERKZS6WsFERERGDZsGLp06QIfHx9ER0fj5s2bGDFiBABg6NChaNy4MaKiogAA4eHh6NWrFxYtWoQXX3wRGzZswLFjx/D1119X7zshowhtE4r+T/fnij9ERERkVJVOSgcNGoS//voLM2fORF5eHjp06ICEhATdYKasrCzI5f82wPr5+WHdunWYMWMGpk+fjpYtW2Lbtm3w8vKqvndBRqWQKzjtExERERkVlxklIiKyYjyHkqWo0jKjRERERETViUkpEREREUmOSSkRERERSY5JKRERERFJjkkpEREREUnOItY0K50goKCgQOJIiIiILEvpudMCJtshG2cRSWlhYSEAQKlUShwJERGRZSosLISrq6vUYRBVyCLmKdVoNLh8+TKcnZ0hk8kevYEBCgoKoFQqkZ2dzXnbqgGPZ/XjMa1ePJ7Vj8e0+hnjmAohUFhYiEaNGuktbkNkbiyipVQul8PDw8Mo+3ZxceGXaTXi8ax+PKbVi8ez+vGYVr/qPqZsISVLwJ9MRERERCQ5JqVEREREJDmbTUodHR0RGRkJR0dHqUOxCjye1Y/HtHrxeFY/HtPqx2NKtswiBjoRERERkXWz2ZZSIiIiIjIfTEqJiIiISHJMSomIiIhIckxKiYiIiEhyTEqJiIiISHJWnZQuW7YMKpUKTk5O8PX1xdGjRx9af/PmzWjdujWcnJzg7e2NnTt3mihSy1CZ47lixQr4+/vjiSeewBNPPIGgoKBHHn9bVNnPaKkNGzZAJpMhJCTEuAFamMoezxs3bmDcuHFwd3eHo6MjWrVqxb/7B1T2mEZHR+Ppp59GjRo1oFQq8e677+LOnTsmita8/fLLL+jXrx8aNWoEmUyGbdu2PXKbxMREdOrUCY6OjmjRogViY2ONHieRZISV2rBhg3BwcBArV64UZ86cEaNGjRJubm7iypUr5dY/ePCgUCgU4pNPPhFnz54VM2bMEPb29uL06dMmjtw8VfZ4hoWFiWXLlokTJ06I9PR0MXz4cOHq6iouXbpk4sjNV2WPaamMjAzRuHFj4e/vL/r372+aYC1AZY9ncXGx6NKli3jhhRfEgQMHREZGhkhMTBSpqakmjtx8VfaYrl27Vjg6Ooq1a9eKjIwM8dNPPwl3d3fx7rvvmjhy87Rz507xwQcfiPj4eAFAbN269aH1L1y4IGrWrCkiIiLE2bNnxZIlS4RCoRAJCQmmCZjIxKw2KfXx8RHjxo3TPVar1aJRo0YiKiqq3PoDBw4UL774ol6Zr6+veOutt4wap6Wo7PF8UElJiXB2dharV682VogWpyrHtKSkRPj5+YlvvvlGDBs2jEnpfSp7PL/88kvRrFkzcffuXVOFaHEqe0zHjRsnnnnmGb2yiIgI0aNHD6PGaYkMSUqnTJkiPD099coGDRokgoODjRgZkXSs8vL93bt3kZKSgqCgIF2ZXC5HUFAQkpOTy90mOTlZrz4ABAcHV1jfllTleD7o1q1buHfvHurUqWOsMC1KVY/pRx99hPr162PkyJGmCNNiVOV4/vDDD+jevTvGjRuHBg0awMvLC/PmzYNarTZV2GatKsfUz88PKSkpukv8Fy5cwM6dO/HCCy+YJGZrw/MS2Ro7qQMwhmvXrkGtVqNBgwZ65Q0aNMBvv/1W7jZ5eXnl1s/LyzNanJaiKsfzQe+//z4aNWpU5gvWVlXlmB44cADffvstUlNTTRChZanK8bxw4QL27t2L1157DTt37sQff/yBsWPH4t69e4iMjDRF2GatKsc0LCwM165dQ8+ePSGEQElJCd5++21Mnz7dFCFbnYrOSwUFBbh9+zZq1KghUWRExmGVLaVkXubPn48NGzZg69atcHJykjoci1RYWIghQ4ZgxYoVqFevntThWAWNRoP69evj66+/RufOnTFo0CB88MEHWL58udShWazExETMmzcPX3zxBY4fP474+Hjs2LEDc+bMkTo0IrIAVtlSWq9ePSgUCly5ckWv/MqVK2jYsGG52zRs2LBS9W1JVY5nqYULF2L+/Pn4+eef0a5dO2OGaVEqe0z//PNPZGZmol+/froyjUYDALCzs8O5c+fQvHlz4wZtxqryGXV3d4e9vT0UCoWurE2bNsjLy8Pdu3fh4OBg1JjNXVWO6YcffoghQ4bgzTffBAB4e3vj5s2bGD16ND744API5WwHqYyKzksuLi5sJSWrZJXfEA4ODujcuTP27NmjK9NoNNizZw+6d+9e7jbdu3fXqw8Au3fvrrC+LanK8QSATz75BHPmzEFCQgK6dOliilAtRmWPaevWrXH69Gmkpqbqbi+99BICAwORmpoKpVJpyvDNTlU+oz169MAff/yhS+4B4Pz583B3d7f5hBSo2jG9detWmcSzNOkXQhgvWCvF8xLZHKlHWhnLhg0bhKOjo4iNjRVnz54Vo0ePFm5ubiIvL08IIcSQIUPE1KlTdfUPHjwo7OzsxMKFC0V6erqIjIzklFD3qezxnD9/vnBwcBBxcXEiNzdXdyssLJTqLZidyh7TB3H0vb7KHs+srCzh7Owsxo8fL86dOye2b98u6tevLz7++GOp3oLZqewxjYyMFM7OzmL9+vXiwoULYteuXaJ58+Zi4MCBUr0Fs1JYWChOnDghTpw4IQCIxYsXixMnToiLFy8KIYSYOnWqGDJkiK5+6ZRQ7733nkhPTxfLli3jlFBk1aw2KRVCiCVLlogmTZoIBwcH4ePjIw4fPqx7rlevXmLYsGF69Tdt2iRatWolHBwchKenp9ixY4eJIzZvlTmeTz31lABQ5hYZGWn6wM1YZT+j92NSWlZlj+ehQ4eEr6+vcHR0FM2aNRNz584VJSUlJo7avFXmmN67d0/MmjVLNG/eXDg5OQmlUinGjh0rrl+/bvrAzdC+ffvK/V4sPYbDhg0TvXr1KrNNhw4dhIODg2jWrJlYtWqVyeMmMhWZELymQkRERETSsso+pURERERkWZiUEhEREZHkmJQSERERkeSYlBIRERGR5JiUEhEREZHkmJQSERERkeSYlBIRERGR5JiUEhEREZHkmJQSERERkeSYlBIRERGR5JiUEhEREZHk/j/F8ggAaIg5xwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_dataset():\n",
+    "    plt.scatter(\n",
+    "        train_features[np.where(train_labels[:, 0] == 0), 0],\n",
+    "        train_features[np.where(train_labels[:, 0] == 0), 1],\n",
+    "        marker=\"o\",\n",
+    "        color=\"b\",\n",
+    "        label=\"Label 0 train\",\n",
+    "    )\n",
+    "    plt.scatter(\n",
+    "        train_features[np.where(train_labels[:, 0] == 1), 0],\n",
+    "        train_features[np.where(train_labels[:, 0] == 1), 1],\n",
+    "        marker=\"o\",\n",
+    "        color=\"g\",\n",
+    "        label=\"Label 1 train\",\n",
+    "    )\n",
+    "\n",
+    "    plt.scatter(\n",
+    "        test_features[np.where(test_labels[:, 0] == 0), 0],\n",
+    "        test_features[np.where(test_labels[:, 0] == 0), 1],\n",
+    "        marker=\"o\",\n",
+    "        facecolors=\"w\",\n",
+    "        edgecolors=\"b\",\n",
+    "        label=\"Label 0 test\",\n",
+    "    )\n",
+    "    plt.scatter(\n",
+    "        test_features[np.where(test_labels[:, 0] == 1), 0],\n",
+    "        test_features[np.where(test_labels[:, 0] == 1), 1],\n",
+    "        marker=\"o\",\n",
+    "        facecolors=\"w\",\n",
+    "        edgecolors=\"g\",\n",
+    "        label=\"Label 1 test\",\n",
+    "    )\n",
+    "\n",
+    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n",
+    "    plt.plot([1, 0], [0, 1], \"--\", color=\"black\")\n",
+    "\n",
+    "\n",
+    "plot_dataset()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "regulation-depression",
+   "metadata": {},
+   "source": [
+    "On the plot above we see:\n",
+    "\n",
+    "* Solid <span style=\"color:blue\">blue</span> dots are the samples from the training dataset labeled as `0`\n",
+    "* Empty <span style=\"color:blue\">blue</span> dots are the samples from the test dataset labeled as `0`\n",
+    "* Solid <span style=\"color:green\">green</span> dots are the samples from the training dataset labeled as `1`\n",
+    "* Empty <span style=\"color:green\">green</span> dots are the samples from the test dataset labeled as `1`\n",
+    "\n",
+    "We'll train our model using solid dots and verify it using empty dots."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "egyptian-campaign",
+   "metadata": {},
+   "source": [
+    "## 2. Train a model and save it\n",
+    "\n",
+    "We'll train our model in two steps. On the first step we train our model in `20` iterations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "brief-lending",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "maxiter = 20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "crude-franklin",
+   "metadata": {},
+   "source": [
+    "Create an empty array for callback to store values of the objective function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "integrated-palestinian",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "objective_values = []"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "legendary-sherman",
+   "metadata": {},
+   "source": [
+    "We re-use a callback function from the Neural Network Classifier & Regressor tutorial to plot iteration versus objective function value with some minor tweaks to plot objective values at each step."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "periodic-apparel",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# callback function that draws a live plot when the .fit() method is called\n",
+    "def callback_graph(_, objective_value):\n",
+    "    clear_output(wait=True)\n",
+    "    objective_values.append(objective_value)\n",
+    "\n",
+    "    plt.title(\"Objective function value against iteration\")\n",
+    "    plt.xlabel(\"Iteration\")\n",
+    "    plt.ylabel(\"Objective function value\")\n",
+    "\n",
+    "    stage1_len = np.min((len(objective_values), maxiter))\n",
+    "    stage1_x = np.linspace(1, stage1_len, stage1_len)\n",
+    "    stage1_y = objective_values[:stage1_len]\n",
+    "\n",
+    "    stage2_len = np.max((0, len(objective_values) - maxiter))\n",
+    "    stage2_x = np.linspace(maxiter, maxiter + stage2_len - 1, stage2_len)\n",
+    "    stage2_y = objective_values[maxiter : maxiter + stage2_len]\n",
+    "\n",
+    "    plt.plot(stage1_x, stage1_y, color=\"orange\")\n",
+    "    plt.plot(stage2_x, stage2_y, color=\"purple\")\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "plt.rcParams[\"figure.figsize\"] = (12, 6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "institutional-cyprus",
+   "metadata": {},
+   "source": [
+    "As mentioned above we train a `VQC` model and set `COBYLA` as an optimizer with a chosen value of the `maxiter` parameter. Then we evaluate performance of the model to see how well it was trained. Then we save this model for a file. On the second step we load this model and will continue to work with it.\n",
+    "\n",
+    "Here, we manually construct an ansatz to fix an initial point where to start optimization from."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "electronic-impact",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "original_optimizer = AQGD(maxiter=maxiter)\n",
+    "\n",
+    "ansatz = RealAmplitudes(num_features)\n",
+    "initial_point = np.asarray([0.5] * ansatz.num_parameters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "separated-classroom",
+   "metadata": {},
+   "source": [
+    "We create a model and set a sampler to the first sampler we created earlier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "revolutionary-freeze",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "original_classifier = VQC(\n",
+    "    ansatz=ansatz, optimizer=original_optimizer, callback=callback_graph, sampler=sampler1\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "minute-mexican",
+   "metadata": {},
+   "source": [
+    "Now it is time to train the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "suited-appointment",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<qiskit_machine_learning.algorithms.classifiers.vqc.VQC at 0x7f85463b1cf0>"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "original_classifier.fit(train_features, train_labels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "revised-torture",
+   "metadata": {},
+   "source": [
+    "Let's see how well our model performs after the first step of training."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "greek-memphis",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train score 0.8333333333333334\n",
+      "Test score  0.8\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Train score\", original_classifier.score(train_features, train_labels))\n",
+    "print(\"Test score \", original_classifier.score(test_features, test_labels))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "rental-moses",
+   "metadata": {},
+   "source": [
+    "Next, we save the model. You may choose any file name you want. Please note that the `save` method does not append an extension if it is not specified in the file name."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "broadband-interview",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "original_classifier.save(\"vqc_classifier.model\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "sitting-thread",
+   "metadata": {},
+   "source": [
+    "## 3. Load a model and continue training\n",
+    "\n",
+    "To load a model a user have to call a class method `load` of the corresponding model class. In our case it is `VQC`. We pass the same file name we used in the previous section where we saved our model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "steady-europe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loaded_classifier = VQC.load(\"vqc_classifier.model\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "reverse-shaft",
+   "metadata": {},
+   "source": [
+    "Next, we want to alter the model in a way it can be trained further and on another simulator. To do so, we set the `warm_start` property. When it is set to `True` and `fit()` is called again the model uses weights from previous fit to start a new fit. We also set the `sampler` property of the underlying network to the second instance of the `Sampler` primitive we created in the beginning of the tutorial. Finally, we create and set a new optimizer with `maxiter` is set to `80`, so the total number of iterations is `100`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "accessible-cowboy",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loaded_classifier.warm_start = True\n",
+    "loaded_classifier.neural_network.sampler = sampler2\n",
+    "loaded_classifier.optimizer = AQGD(maxiter=80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "revised-bruce",
+   "metadata": {},
+   "source": [
+    "Now we continue training our model from the state we finished in the previous section."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "metric-cyprus",
+   "metadata": {
+    "nbsphinx-thumbnail": {
+     "output-index": 0
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<qiskit_machine_learning.algorithms.classifiers.vqc.VQC at 0x7f854629cd60>"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "loaded_classifier.fit(train_features, train_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "bronze-spread",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train score 0.9333333333333333\n",
+      "Test score 0.8\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Train score\", loaded_classifier.score(train_features, train_labels))\n",
+    "print(\"Test score\", loaded_classifier.score(test_features, test_labels))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "apparent-bloom",
+   "metadata": {},
+   "source": [
+    "Let's see which data points were misclassified. First, we call `predict` to infer predicted values from the training and test features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "catholic-norway",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_predicts = loaded_classifier.predict(train_features)\n",
+    "test_predicts = loaded_classifier.predict(test_features)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "guided-croatia",
+   "metadata": {},
+   "source": [
+    "Plot the whole dataset and the highlight the points that were classified incorrectly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "tested-handling",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x7f8545de12a0>"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# return plot to default figsize\n",
+    "plt.rcParams[\"figure.figsize\"] = (6, 4)\n",
+    "\n",
+    "plot_dataset()\n",
+    "\n",
+    "# plot misclassified data points\n",
+    "plt.scatter(\n",
+    "    train_features[np.all(train_labels != train_predicts, axis=1), 0],\n",
+    "    train_features[np.all(train_labels != train_predicts, axis=1), 1],\n",
+    "    s=200,\n",
+    "    facecolors=\"none\",\n",
+    "    edgecolors=\"r\",\n",
+    "    linewidths=2,\n",
+    ")\n",
+    "plt.scatter(\n",
+    "    test_features[np.all(test_labels != test_predicts, axis=1), 0],\n",
+    "    test_features[np.all(test_labels != test_predicts, axis=1), 1],\n",
+    "    s=200,\n",
+    "    facecolors=\"none\",\n",
+    "    edgecolors=\"r\",\n",
+    "    linewidths=2,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "genuine-preference",
+   "metadata": {},
+   "source": [
+    "So, if you have a large dataset or a large model you can train it in multiple steps as shown in this tutorial."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "acknowledged-freight",
+   "metadata": {},
+   "source": [
+    "## 4. PyTorch hybrid models\n",
+    "\n",
+    "To save and load hybrid models, when using the TorchConnector, follow the PyTorch recommendations of saving and loading the models. For more details please refer to the [PyTorch Connector tutorial](05_torch_connector.ipynb) where a short snippet shows how to do it.\n",
+    "\n",
+    "Take a look at this pseudo-like code to get the idea:\n",
+    "```python\n",
+    "# create a QNN and a hybrid model\n",
+    "qnn = create_qnn()\n",
+    "model = Net(qnn)\n",
+    "# ... train the model ...\n",
+    "\n",
+    "# save the model\n",
+    "torch.save(model.state_dict(), \"model.pt\")\n",
+    "\n",
+    "# create a new model\n",
+    "new_qnn = create_qnn()\n",
+    "loaded_model = Net(new_qnn)\n",
+    "loaded_model.load_state_dict(torch.load(\"model.pt\"))\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "persistent-combine",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<h3>Version Information</h3><table><tr><th>Software</th><th>Version</th></tr><tr><td><code>qiskit</code></td><td>0.44.1</td></tr><tr><td><code>qiskit-terra</code></td><td>0.25.1</td></tr><tr><td><code>qiskit_machine_learning</code></td><td>0.6.1</td></tr><tr><th colspan='2'>System information</th></tr><tr><td>Python version</td><td>3.10.8</td></tr><tr><td>Python compiler</td><td>GCC 10.4.0</td></tr><tr><td>Python build</td><td>main, Nov 22 2022 08:26:04</td></tr><tr><td>OS</td><td>Linux</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>31.142807006835938</td></tr><tr><td colspan='2'>Wed Oct 04 16:00:17 2023 UTC</td></tr></table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import qiskit.tools.jupyter\n",
+    "\n",
+    "%qiskit_version_table\n",
+    "%qiskit_copyright"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Tags",
+  "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.10.8"
+  },
+  "widgets": {
+   "application/vnd.jupyter.widget-state+json": {
+    "state": {
+     "05d801b3ca724b568d9f00f81d77634f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "121f75ad442941c091a189f0dbd75769": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonStyleModel",
+      "state": {
+       "font_family": null,
+       "font_size": null,
+       "font_style": null,
+       "font_variant": null,
+       "font_weight": null,
+       "text_color": null,
+       "text_decoration": null
+      }
+     },
+     "1dd4e565d40f4e5389c306b47f96b197": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "2582c866efce4fa39f5cc9ec7c79a971": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_e4ac1b5d9c194107bc6e1a85e9309a06",
+       "style": "IPY_MODEL_05d801b3ca724b568d9f00f81d77634f",
+       "value": "<h5>Message</h5>"
+      }
+     },
+     "2ee5561e7d2547fcb5ce8b6858b31bfa": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "5a416fb50c0a4bceb60b9f61a99c4873": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "95px"
+      }
+     },
+     "6c86f32924084fd3890702b0e197035e": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_e38145db2403405ea93bffd7517a1b9e",
+       "style": "IPY_MODEL_c6b7f2cc6c10482fb881fe9f79bae620",
+       "value": "<h5>Job ID</h5>"
+      }
+     },
+     "7000ac91e2224bafadf9ad1af1bf1dfc": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "GridBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_70e29a72193c46baa79cefa5061d8aa2"
+       ],
+       "layout": "IPY_MODEL_81e9f85f5f1c45608235ca9bc3ca644f"
+      }
+     },
+     "70e29a72193c46baa79cefa5061d8aa2": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonModel",
+      "state": {
+       "button_style": "primary",
+       "description": "Clear",
+       "layout": "IPY_MODEL_e0f1faf5c0104de2a3f68279296df2f5",
+       "style": "IPY_MODEL_121f75ad442941c091a189f0dbd75769",
+       "tooltip": null
+      }
+     },
+     "756b3b675c9e4c64b595ab50eb1e1b95": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_5a416fb50c0a4bceb60b9f61a99c4873",
+       "style": "IPY_MODEL_f61862105e554dc29fe92cae62258299",
+       "value": "<h5>Status</h5>"
+      }
+     },
+     "81e9f85f5f1c45608235ca9bc3ca644f": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "grid_template_areas": "\n                                       \". . . . right \"\n                                        ",
+       "grid_template_columns": "20% 20% 20% 20% 20%",
+       "width": "100%"
+      }
+     },
+     "83600cca541d461885c530661ea2132f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_b2db8a7f424941a58c01e9bdc3e8724b",
+       "style": "IPY_MODEL_e4f102ba5d964da6b008a03f4d7bbee0",
+       "value": "<h5>Queue</h5>"
+      }
+     },
+     "acff33d7334a4a4d88fbc2cf8e96deba": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 0px 37px",
+       "width": "600px"
+      }
+     },
+     "b2db8a7f424941a58c01e9bdc3e8724b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "70px"
+      }
+     },
+     "bf028b8af62b4c6487e402338198e99c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_e728eaa916a4400ca266baa3fdc4948d",
+       "style": "IPY_MODEL_1dd4e565d40f4e5389c306b47f96b197",
+       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
+      }
+     },
+     "c6b7f2cc6c10482fb881fe9f79bae620": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "e0f1faf5c0104de2a3f68279296df2f5": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "grid_area": "right",
+       "padding": "0px 0px 0px 0px",
+       "width": "70px"
+      }
+     },
+     "e38145db2403405ea93bffd7517a1b9e": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "190px"
+      }
+     },
+     "e4ac1b5d9c194107bc6e1a85e9309a06": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "e4f102ba5d964da6b008a03f4d7bbee0": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "e728eaa916a4400ca266baa3fdc4948d": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 10px 0px"
+      }
+     },
+     "f0cf51690c6d4e0a83a8be6589c7f44f": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_6c86f32924084fd3890702b0e197035e",
+        "IPY_MODEL_fc6644b7409a4939bc10ce0103cd96b6",
+        "IPY_MODEL_756b3b675c9e4c64b595ab50eb1e1b95",
+        "IPY_MODEL_83600cca541d461885c530661ea2132f",
+        "IPY_MODEL_2582c866efce4fa39f5cc9ec7c79a971"
+       ],
+       "layout": "IPY_MODEL_acff33d7334a4a4d88fbc2cf8e96deba"
+      }
+     },
+     "f155ba4c692946fe8c2bf292f8fdb216": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "145px"
+      }
+     },
+     "f61862105e554dc29fe92cae62258299": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "fc6644b7409a4939bc10ce0103cd96b6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_f155ba4c692946fe8c2bf292f8fdb216",
+       "style": "IPY_MODEL_2ee5561e7d2547fcb5ce8b6858b31bfa",
+       "value": "<h5>Backend</h5>"
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}