--- a
+++ b/Code/All Qiskit ML Demos/04 Quantum Kernel 100% Cluster kkawchak.ipynb
@@ -0,0 +1,1203 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quantum Kernel Machine Learning\n",
+    "\n",
+    "## Overview\n",
+    "\n",
+    "The general task of machine learning is to find and study patterns in data. For many datasets, the datapoints are better understood in a higher dimensional feature space. This is the fundamental principle behind a series of machine learning algorithms known as *kernel methods*.\n",
+    "\n",
+    "In this notebook, you will learn how to define quantum kernels using `qiskit-machine-learning` and how these can be plugged into different algorithms to solve classification and clustering problems.\n",
+    "\n",
+    "All examples used in this tutorial are based on this reference paper: [_Supervised learning with quantum enhanced feature spaces_](https://arxiv.org/pdf/1804.11326.pdf).\n",
+    "\n",
+    "The content is structured as follows:\n",
+    "\n",
+    "1. [Introduction](#1.-Introduction)\n",
+    "2. [Classification](#2.-Classification)\n",
+    "3. [Clustering](#3.-Clustering)\n",
+    "4. [Kernel Principal Components Analysis](#4.-Kernel-Principal-Component-Analysis)\n",
+    "5. [Conclusion](#5.-Conclusion)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Introduction\n",
+    "\n",
+    "### 1.1. Kernel Methods for Machine Learning\n",
+    "\n",
+    "Kernel methods are a collection of pattern analysis algorithms that use kernel functions to operate in a high-dimensional feature space. The best-known application of kernel methods is in **Support Vector Machines (SVMs)**, supervised learning algorithms commonly used for classification tasks. The main goal of SVMs is to find decision boundaries to separate a given set of data points into classes. When these data spaces are not linearly separable, SVMs can benefit from the use of kernels to find these boundaries.\n",
+    "\n",
+    "Formally, decision boundaries are hyperplanes in a high dimensional space. The kernel function implicitly maps input data into this higher dimensional space, where it can be easier to solve the initial problem. In other words, kernels may allow data distributions that were originally non-linearly separable to become a linearly separable problem. This is an effect known as the \"kernel trick\".\n",
+    "\n",
+    "There are use-cases for kernel-based unsupervised algorithms too, for example, in the context of clustering. **Spectral Clustering** is a technique where data points are treated as nodes of a graph, and the clustering task is viewed as a graph partitioning problem where nodes are mapped to a space where they can be easily segregated to form clusters.\n",
+    "\n",
+    "### 1.2. Kernel Functions\n",
+    "\n",
+    "Mathematically, kernel functions follow:\n",
+    "\n",
+    "$k(\\vec{x}_i, \\vec{x}_j) = \\langle f(\\vec{x}_i), f(\\vec{x}_j) \\rangle$\n",
+    "\n",
+    "where \n",
+    "* $k$ is the kernel function\n",
+    "* $\\vec{x}_i, \\vec{x}_j$ are $n$ dimensional inputs\n",
+    "* $f$ is a map from $n$-dimension to $m$-dimension space and \n",
+    "* $\\langle a,b \\rangle$ denotes the inner product\n",
+    "\n",
+    "When considering finite data, a kernel function can be represented as a matrix: \n",
+    "\n",
+    "$K_{ij} = k(\\vec{x}_i,\\vec{x}_j)$.\n",
+    "\n",
+    "### 1.3. Quantum Kernels\n",
+    "\n",
+    "The main idea behind quantum kernel machine learning is to leverage quantum feature maps to perform the kernel trick. In this case, the quantum kernel is created by mapping a classical feature vector $\\vec{x}$ to a Hilbert space using a quantum feature map $\\phi(\\vec{x})$. Mathematically:\n",
+    "\n",
+    "$K_{ij} = \\left| \\langle \\phi(\\vec{x}_i)| \\phi(\\vec{x}_j) \\rangle \\right|^{2}$\n",
+    "\n",
+    "where \n",
+    "* $K_{ij}$ is the kernel matrix\n",
+    "* $\\vec{x}_i, \\vec{x}_j$ are $n$ dimensional inputs\n",
+    "* $\\phi(\\vec{x})$ is the quantum feature map\n",
+    "* $\\left| \\langle a|b \\rangle \\right|^{2}$ denotes the overlap of two quantum states $a$ and $b$\n",
+    "\n",
+    "Quantum kernels can be plugged into common classical kernel learning algorithms such as SVMs or clustering algorithms, as you will see in the examples below. They can also be leveraged in new quantum kernel methods like [QSVC](https://qiskit.org/ecosystem/machine-learning/stubs/qiskit_machine_learning.algorithms.QSVC.html) class  provided by `qiskit-machine-learning` which is explored in this tutorial, and other methods as shown in later tutorials on [Pegasos QSVC](07_pegasos_qsvc.ipynb) and [Quantum Kernel Training](08_quantum_kernel_trainer.ipynb).\n",
+    "\n",
+    "***\n",
+    "\n",
+    "Before introducing any example, we set up the global seed to ensure reproducibility:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit.utils import algorithm_globals\n",
+    "\n",
+    "algorithm_globals.random_seed = 12345"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Classification\n",
+    "\n",
+    "This section illustrates a quantum kernel classification workflow using `qiskit-machine-learning`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.1. Defining the dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For this example, we will use the _ad hoc dataset_ as described in the reference [paper](https://arxiv.org/pdf/1804.11326.pdf). \n",
+    "\n",
+    "We can define the dataset dimension and get our train and test subsets:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit_machine_learning.datasets import ad_hoc_data\n",
+    "\n",
+    "adhoc_dimension = 2\n",
+    "train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(\n",
+    "    training_size=20,\n",
+    "    test_size=5,\n",
+    "    n=adhoc_dimension,\n",
+    "    gap=0.3,\n",
+    "    plot_data=False,\n",
+    "    one_hot=False,\n",
+    "    include_sample_total=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This dataset is two-dimensional, the two features are represented by the $x$ and $y$ coordinates, and it has two class labels: A and B. We can plot it and see what the distribution looks like. We define utility functions to plot the dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "def plot_features(ax, features, labels, class_label, marker, face, edge, label):\n",
+    "    # A train plot\n",
+    "    ax.scatter(\n",
+    "        # x coordinate of labels where class is class_label\n",
+    "        features[np.where(labels[:] == class_label), 0],\n",
+    "        # y coordinate of labels where class is class_label\n",
+    "        features[np.where(labels[:] == class_label), 1],\n",
+    "        marker=marker,\n",
+    "        facecolors=face,\n",
+    "        edgecolors=edge,\n",
+    "        label=label,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def plot_dataset(train_features, train_labels, test_features, test_labels, adhoc_total):\n",
+    "\n",
+    "    plt.figure(figsize=(5, 5))\n",
+    "    plt.ylim(0, 2 * np.pi)\n",
+    "    plt.xlim(0, 2 * np.pi)\n",
+    "    plt.imshow(\n",
+    "        np.asmatrix(adhoc_total).T,\n",
+    "        interpolation=\"nearest\",\n",
+    "        origin=\"lower\",\n",
+    "        cmap=\"RdBu\",\n",
+    "        extent=[0, 2 * np.pi, 0, 2 * np.pi],\n",
+    "    )\n",
+    "\n",
+    "    # A train plot\n",
+    "    plot_features(plt, train_features, train_labels, 0, \"s\", \"w\", \"b\", \"A train\")\n",
+    "\n",
+    "    # B train plot\n",
+    "    plot_features(plt, train_features, train_labels, 1, \"o\", \"w\", \"r\", \"B train\")\n",
+    "\n",
+    "    # A test plot\n",
+    "    plot_features(plt, test_features, test_labels, 0, \"s\", \"b\", \"w\", \"A test\")\n",
+    "\n",
+    "    # B test plot\n",
+    "    plot_features(plt, test_features, test_labels, 1, \"o\", \"r\", \"w\", \"B test\")\n",
+    "\n",
+    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n",
+    "    plt.title(\"Ad hoc dataset\")\n",
+    "\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we actually plot the dataset for classification:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {
+    "tags": [
+     "nbsphinx-thumbnail"
+    ]
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.2. Defining the quantum kernel\n",
+    "\n",
+    "The next step is to create a quantum kernel instance that will help classify this data. \n",
+    "\n",
+    "We use the [FidelityQuantumKernel](https://qiskit.org/ecosystem/machine-learning/stubs/qiskit_machine_learning.kernels.FidelityQuantumKernel.html) class, and pass two input arguments to its constructor: \n",
+    "\n",
+    "1. `feature_map`: in this case, a two-qubit [ZZFeatureMap](https://qiskit.org/documentation/stubs/qiskit.circuit.library.ZZFeatureMap.html).\n",
+    "\n",
+    "2. `fidelity`: in this case, the [ComputeUncompute](https://qiskit.org/documentation/stubs/qiskit.algorithms.state_fidelities.ComputeUncompute.html) fidelity subroutine that leverages the [Sampler](https://qiskit.org/documentation/stubs/qiskit.primitives.Sampler.html) primitive.\n",
+    "\n",
+    "**NOTE:** If you don't pass a `Sampler` or `Fidelity` instance, then the instances of the reference `Sampler` and `ComputeUncompute` classes (found in `qiskit.primitives`) will be created by default."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit.circuit.library import ZZFeatureMap\n",
+    "from qiskit.primitives import Sampler\n",
+    "from qiskit.algorithms.state_fidelities import ComputeUncompute\n",
+    "from qiskit_machine_learning.kernels import FidelityQuantumKernel\n",
+    "\n",
+    "adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement=\"linear\")\n",
+    "\n",
+    "sampler = Sampler()\n",
+    "\n",
+    "fidelity = ComputeUncompute(sampler=sampler)\n",
+    "\n",
+    "adhoc_kernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=adhoc_feature_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.3. Classification with SVC\n",
+    "The quantum kernel can now be plugged into classical kernel methods, such as the [SVC](https://scikit-learn.org/stable/modules/svm.html) algorithm from `scikit-learn`. This algorithm allows us to define a [custom kernel](https://scikit-learn.org/stable/modules/svm.html#custom-kernels) in two ways:\n",
+    "\n",
+    "1. by providing the kernel as a **callable function**\n",
+    "2. by precomputing the **kernel matrix**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Kernel as a callable function\n",
+    "\n",
+    "We define a SVC model and directly pass the `evaluate` function of the quantum kernel as a callable. Once the model is created, we train it by calling the `fit` method on the training dataset and evaluate the model for accuracy with `score`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Callable kernel classification test score: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.svm import SVC\n",
+    "\n",
+    "adhoc_svc = SVC(kernel=adhoc_kernel.evaluate)\n",
+    "\n",
+    "adhoc_svc.fit(train_features, train_labels)\n",
+    "\n",
+    "adhoc_score_callable_function = adhoc_svc.score(test_features, test_labels)\n",
+    "\n",
+    "print(f\"Callable kernel classification test score: {adhoc_score_callable_function}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Precomputed kernel matrix\n",
+    "\n",
+    "Instead of passing a function of the quantum kernel as a callable, we can also precompute training and testing kernel matrices before passing them to the `scikit-learn` `SVC` algorithm. \n",
+    "\n",
+    "To extract the train and test matrices, we can call `evaluate` on the previously defined kernel and visualize them graphically as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "adhoc_matrix_train = adhoc_kernel.evaluate(x_vec=train_features)\n",
+    "adhoc_matrix_test = adhoc_kernel.evaluate(x_vec=test_features, y_vec=train_features)\n",
+    "\n",
+    "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n",
+    "\n",
+    "axs[0].imshow(\n",
+    "    np.asmatrix(adhoc_matrix_train), interpolation=\"nearest\", origin=\"upper\", cmap=\"Blues\"\n",
+    ")\n",
+    "axs[0].set_title(\"Ad hoc training kernel matrix\")\n",
+    "\n",
+    "axs[1].imshow(np.asmatrix(adhoc_matrix_test), interpolation=\"nearest\", origin=\"upper\", cmap=\"Reds\")\n",
+    "axs[1].set_title(\"Ad hoc testing kernel matrix\")\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To use these matrices, we set the `kernel` parameter of a new `SVC` instance to `\"precomputed\"`. We train the classifier by calling `fit` with the training matrix and training dataset. Once the model is trained, we evaluate it using the test matrix on the test dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Precomputed kernel classification test score: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "adhoc_svc = SVC(kernel=\"precomputed\")\n",
+    "\n",
+    "adhoc_svc.fit(adhoc_matrix_train, train_labels)\n",
+    "\n",
+    "adhoc_score_precomputed_kernel = adhoc_svc.score(adhoc_matrix_test, test_labels)\n",
+    "\n",
+    "print(f\"Precomputed kernel classification test score: {adhoc_score_precomputed_kernel}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4. Classification with QSVC\n",
+    "\n",
+    "`QSVC` is an alternative training algorithm provided by `qiskit-machine-learning` for convenience. It is an extension of `SVC` that takes in a quantum kernel instead of the `kernel.evaluate` method shown before."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "QSVC classification test score: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit_machine_learning.algorithms import QSVC\n",
+    "\n",
+    "qsvc = QSVC(quantum_kernel=adhoc_kernel)\n",
+    "\n",
+    "qsvc.fit(train_features, train_labels)\n",
+    "\n",
+    "qsvc_score = qsvc.score(test_features, test_labels)\n",
+    "\n",
+    "print(f\"QSVC classification test score: {qsvc_score}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.5. Evaluation of models used for classification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 81,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Classification Model                    | Accuracy Score\n",
+      "---------------------------------------------------------\n",
+      "SVC using kernel as a callable function |       1.00\n",
+      "SVC using precomputed kernel matrix     |       1.00\n",
+      "QSVC                                    |       1.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Classification Model                    | Accuracy Score\")\n",
+    "print(f\"---------------------------------------------------------\")\n",
+    "print(f\"SVC using kernel as a callable function | {adhoc_score_callable_function:10.2f}\")\n",
+    "print(f\"SVC using precomputed kernel matrix     | {adhoc_score_precomputed_kernel:10.2f}\")\n",
+    "print(f\"QSVC                                    | {qsvc_score:10.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As the classification dataset is small, we find that the three models achieve 100% accuracy."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Clustering\n",
+    "\n",
+    "The second workflow in this tutorial focuses on a clustering task using `qiskit-machine-learning` and the spectral clustering algorithm from `scikit-learn`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.1. Defining the dataset\n",
+    "\n",
+    "We will once again use the _ad hoc dataset_, but now generated with a higher gap of `0.6` (previous example: `0.3`) between the two classes. \n",
+    "\n",
+    "Note that clustering falls under the category of unsupervised machine learning, so a test dataset is not required."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adhoc_dimension = 2\n",
+    "train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(\n",
+    "    training_size=25,\n",
+    "    test_size=0,\n",
+    "    n=adhoc_dimension,\n",
+    "    gap=0.6,\n",
+    "    plot_data=False,\n",
+    "    one_hot=False,\n",
+    "    include_sample_total=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " We plot the clustering dataset below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.ylim(0, 2 * np.pi)\n",
+    "plt.xlim(0, 2 * np.pi)\n",
+    "plt.imshow(\n",
+    "    np.asmatrix(adhoc_total).T,\n",
+    "    interpolation=\"nearest\",\n",
+    "    origin=\"lower\",\n",
+    "    cmap=\"RdBu\",\n",
+    "    extent=[0, 2 * np.pi, 0, 2 * np.pi],\n",
+    ")\n",
+    "\n",
+    "# A label plot\n",
+    "plot_features(plt, train_features, train_labels, 0, \"s\", \"w\", \"b\", \"B\")\n",
+    "\n",
+    "# B label plot\n",
+    "plot_features(plt, train_features, train_labels, 1, \"o\", \"w\", \"r\", \"B\")\n",
+    "\n",
+    "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\", borderaxespad=0.0)\n",
+    "plt.title(\"Ad hoc dataset for clustering\")\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.2. Defining the Quantum Kernel\n",
+    "We use an identical setup as in the classification example. We create another instance of the `FidelityQuantumKernel` class with a `ZZFeatureMap`, but you might notice that in this case we do not provide a `fidelity` instance. This is because the `ComputeUncompute` method provided in the previous case is instantiated by default when the fidelity instance is not provided explicitly. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 176,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement=\"full\")\n",
+    "\n",
+    "adhoc_kernel = FidelityQuantumKernel(feature_map=adhoc_feature_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.3. Clustering with the Spectral Clustering Model\n",
+    "\n",
+    "The `scikit-learn` spectral clustering algorithm allows us to define a custom kernel in two ways (just like `SVC`):\n",
+    "\n",
+    "1. by providing the kernel as a **callable function**\n",
+    "2. by precomputing the **kernel matrix**. \n",
+    "\n",
+    "With the current `FidelityQuantumKernel` class in `qiskit-machine-learning`, we can only use the latter option, so we precompute the kernel matrix by calling `evaluate` and visualize it as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 177,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAHDCAYAAABF+E9FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABZPElEQVR4nO3dd3iT5foH8G/SJulOW+iglA2yh5S9dxVBhgh6PAouBEEZogeOIkMUxIX+ZDrAgRZBQHGACAgqu0xROIwCZbSlQJvOtEne3x+e9lDJc78U0fbV7+dcva5jvrmTN2/SPqR97twmTdM0EBERGYy5rA+AiIjoenABIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSFxAfuLWrJkCUwmE06ePCleb9iwYQgKCvpzDuoGuNbHVV5Vr14dw4YN+9Pv9+TJkzCZTHj55Zf/9Pv+vb777juYTCZ89913ZX0ov8uwYcNQvXr1sj6MvxQuYOXcvHnzYDKZ0Lp167I+lL+Fr776ClOnTi3rw6ByLDc3F1OnTjX8gvpXwAWsnFu6dCmqV6+OnTt34tixY2V9OH95X331FaZNm/aH3f6RI0fw1ltv/WG3T3+83NxcTJs2rdQL2FtvvYUjR478MQf1N8UFrBxLSkrC1q1b8eqrryIiIgJLly4t60Oi66BpGvLy8gAANpsNFouljI/oj5Gbm1vWh1Au5eTkAAAsFgtsNlsZH81fCxewcmzp0qUICwvDbbfdhkGDBikXsEOHDqFbt27w9/dHbGwsZsyYAY/HU6r7Onv2LPr374+goCBERERgwoQJcLvdJa6Tk5ODJ554AlWqVIHNZkPdunXx8ssvw9tAgw8//BCtWrVCQEAAwsLC0KlTJ3zzzTe6x3H48GEMHjwYERER8Pf3R926dfH000+LNSaTyeuv/X7796bCwkJMmzYNderUgZ+fHypUqIAOHTpg/fr1AH79G8XcuXOLb7Poq4jH48GcOXPQsGFD+Pn5ISoqCo888gguX7581f326dMH69atQ4sWLeDv74+FCxd6Paaiv+n9+OOPGD9+PCIiIhAYGIgBAwbgwoULJW7X4/Fg6tSpiImJQUBAALp27Yqff/75uv+upmkahg8fDqvVipUrVxZf/uGHHyIuLg7+/v4IDw/HXXfdheTk5BK1Xbp0QaNGjZCYmIhOnTohICAA//73v0v8rW3RokWoVasWbDYbWrZsiV27dl11DIcPH8agQYMQHh4OPz8/tGjRAp9//nmpHwsATJ06FSaTCf/5z3/wz3/+E3a7HREREZg8eTI0TUNycjL69euHkJAQREdH45VXXilRX1BQgGeffRZxcXGw2+0IDAxEx44dsWnTpuLrnDx5EhEREQCAadOmFb9Gil5/RX9TPn78OHr37o3g4GDcc889xdmVfwObMmUKzGYzNmzYUOI4ip6T/fv3X9d5+DvxLesDILWlS5di4MCBsFqtuPvuuzF//nzs2rULLVu2LL5OSkoKunbtCpfLhYkTJyIwMBCLFi2Cv7//Nd+P2+1GfHw8WrdujZdffhnffvstXnnlFdSqVQsjR44E8OsPu9tvvx2bNm3Cgw8+iGbNmmHdunV48skncfbsWbz22mvFtzdt2jRMnToV7dq1w/Tp02G1WrFjxw5s3LgRvXr1Uh7HgQMH0LFjR1gsFgwfPhzVq1fH8ePHsWbNGjz//PPXcQZLmjp1KmbOnImHHnoIrVq1gsPhwO7du7Fnzx707NkTjzzyCM6dO4f169fjgw8+uKr+kUcewZIlS3D//ffj8ccfR1JSEt58803s3bsXP/74Y4l3VkeOHMHdd9+NRx55BA8//DDq1q0rHttjjz2GsLAwTJkyBSdPnsScOXMwevRoLFu2rPg6kyZNwuzZs9G3b1/Ex8dj//79iI+PR35+fqnPhdvtxgMPPIBly5Zh1apVuO222wAAzz//PCZPnozBgwfjoYcewoULF/B///d/6NSpE/bu3YvQ0NDi27h48SJuvfVW3HXXXfjnP/+JqKio4uyjjz5CVlYWHnnkEZhMJsyePRsDBw7EiRMnis/ToUOH0L59e1SuXLn4tfvJJ5+gf//++PTTTzFgwIBSPy4AGDJkCOrXr49Zs2bhyy+/xIwZMxAeHo6FCxeiW7duePHFF7F06VJMmDABLVu2RKdOnQAADocDb7/9Nu6++248/PDDyMrKwjvvvIP4+Hjs3LkTzZo1Q0REBObPn4+RI0diwIABGDhwIACgSZMmxffvcrkQHx+PDh064OWXX0ZAQIDX43zmmWewZs0aPPjggzh48CCCg4Oxbt06vPXWW3juuefQtGnT63r8fysalUu7d+/WAGjr16/XNE3TPB6PFhsbq40ZM6bE9caOHasB0Hbs2FF8WVpamma32zUAWlJSkng/Q4cO1QBo06dPL3H5zTffrMXFxRX/9+rVqzUA2owZM0pcb9CgQZrJZNKOHTumaZqmHT16VDObzdqAAQM0t9td4roej0c8lk6dOmnBwcHaqVOnlHWLFy++6nEB0KZMmXLV7VWrVk0bOnRo8X83bdpUu+2228RjGDVqlObt2+L777/XAGhLly4tcfnatWuvurxatWoaAG3t2rW6x1T0eHr06FHicY4bN07z8fHRMjIyNE3TtJSUFM3X11fr379/idubOnWqBqDEbXqTlJSkAdBeeuklrbCwUBsyZIjm7++vrVu3rvg6J0+e1Hx8fLTnn3++RO3Bgwc1X1/fEpd37txZA6AtWLDA6/1UqFBBu3TpUvHln332mQZAW7NmTfFl3bt31xo3bqzl5+cXX+bxeLR27dppderUKb5s06ZNGgBt06ZN4mOcMmWKBkAbPnx48WUul0uLjY3VTCaTNmvWrOLLL1++rPn7+5c4by6XS3M6nSVu8/Lly1pUVJT2wAMPFF924cIF5Wuu6Ptp4sSJXrNq1aqVuOzgwYOa1WrVHnroIe3y5cta5cqVtRYtWmiFhYXiY6Vf8VeI5dTSpUsRFRWFrl27Avj1V1pDhgxBQkJCiV/tffXVV2jTpg1atWpVfFlERETxry2u1YgRI0r8d8eOHXHixIkS9+Pj44PHH3+8xPWeeOIJaJqGr7/+GgCwevVqeDwePPvsszCbS768rvx13G9duHABW7ZswQMPPICqVatec11phIaG4tChQzh69Gipa5cvXw673Y6ePXsiPT29+CsuLg5BQUElfs0EADVq1EB8fPw13/7w4cNLPM6OHTvC7Xbj1KlTAIANGzbA5XLh0UcfLVH32GOPlepxFBQU4M4778QXX3yBr776qsQ74pUrV8Lj8WDw4MElHmN0dDTq1Klz1WO02Wy4//77vd7PkCFDEBYWVuLxACh+TV26dAkbN27E4MGDkZWVVXxfFy9eRHx8PI4ePYqzZ8+W6rEVeeihh4r/v4+PD1q0aAFN0/Dggw8WXx4aGoq6deuWeI37+PjAarUC+PXXtZcuXYLL5UKLFi2wZ8+eUh1D0W8u9DRq1AjTpk3D22+/jfj4eKSnp+O9996Dry9/OXYteJbKIbfbjYSEBHTt2hVJSUnFl7du3RqvvPIKNmzYUPyD59SpU1632Ov9yupKfn5+xb/XLxIWFlbibzunTp1CTEwMgoODS1yvfv36xTkAHD9+HGazGQ0aNLjm+wf+94OtUaNGpaorjenTp6Nfv3646aab0KhRI9xyyy249957S/z6R+Xo0aPIzMxEZGSk1zwtLa3Ef9eoUaNUx/bbRbvoh3/Rc1B0fmvXrl3ieuHh4SUWCj0zZ85EdnY2vv76a3Tp0qVEdvToUWiahjp16nit/e3mk8qVKxf/wP8tvcdz7NgxaJqGyZMnY/LkyV5vIy0tDZUrV9Z9THr3bbfb4efnh4oVK151+cWLF0tc9t577+GVV17B4cOHUVhYWHx5aZ5PX19fxMbGXvP1n3zySSQkJGDnzp144YUXSv2983fGBawc2rhxI86fP4+EhAQkJCRclS9dulT8W1Jp+fj43LDbKk9+uwmlU6dOOH78OD777DN88803ePvtt/Haa69hwYIFJf7V7o3H40FkZKRyI81v/wFQmr9BAurnQPOyQeb3iI+Px9q1azF79mx06dIFfn5+xZnH44HJZMLXX3/t9Xh+2/AuPUa9x1O0yWjChAnKd6q/Xayvlbf7vpbz++GHH2LYsGHo378/nnzySURGRsLHxwczZ87E8ePHr/n+bTbbVb99kJw4caL4twIHDx685jriAlYuLV26FJGRkcU74q60cuVKrFq1CgsWLIC/vz+qVavm9VdiN7rfpFq1avj222+RlZVV4l3Y4cOHi3MAqFWrFjweD37++Wc0a9bsmm+/Zs2aAICffvqp1McWFhaGjIyMEpcVFBTg/PnzV103PDwc999/P+6//35kZ2ejU6dOmDp1avECpvp1Za1atfDtt9+iffv2pV6cboSi83vs2LES7wYuXrx41S5ISZs2bTBixAj06dMHd955J1atWlX866patWpB0zTUqFEDN9100419AL9R9HxbLBb06NHjD72va7VixQrUrFkTK1euLPE6mDJlSonr3ahfaQO/LuTDhg1DSEgIxo4dixdeeAGDBg0q3hxCMv4NrJzJy8vDypUr0adPHwwaNOiqr9GjRyMrK6t4q3Hv3r2xfft27Ny5s/g2Lly4cMN7xnr37g23240333yzxOWvvfYaTCYTbr31VgBA//79YTabMX369Ku28kvvJiIiItCpUye8++67OH369DXXAb/+4N2yZUuJyxYtWnTVO7Df/rooKCgItWvXhtPpLL4sMDAQAK5aEAcPHgy3243nnnvuqvt3uVxXXf9G6969O3x9fTF//vwSl//2+bgWPXr0QEJCAtauXYt77723+HkaOHAgfHx8MG3atKvOuaZpV52/3yMyMhJdunTBwoULvf5D47ctBH+GondpVz72HTt2YNu2bSWuV7Sr8EY856+++iq2bt2KRYsW4bnnnkO7du0wcuRIpKen/+7b/jvgO7By5vPPP0dWVhZuv/12r3mbNm2Km5qHDBmCp556Ch988AFuueUWjBkzpngbfbVq1XDgwIEbdlx9+/ZF165d8fTTT+PkyZNo2rQpvvnmG3z22WcYO3YsatWqBeDXX/s8/fTTeO6559CxY0cMHDgQNpsNu3btQkxMDGbOnKm8jzfeeAMdOnRA8+bNMXz4cNSoUQMnT57El19+iX379inrHnroIYwYMQJ33HEHevbsif3792PdunVX/c2jQYMG6NKlC+Li4hAeHo7du3djxYoVGD16dPF14uLiAACPP/444uPj4ePjg7vuugudO3fGI488gpkzZ2Lfvn3o1asXLBYLjh49iuXLl+P111/HoEGDfscZlkVFRWHMmDF45ZVXcPvtt+OWW27B/v378fXXX6NixYqlflfQv39/LF68GPfddx9CQkKwcOFC1KpVCzNmzMCkSZNw8uRJ9O/fH8HBwUhKSsKqVaswfPhwTJgw4YY9prlz56JDhw5o3LgxHn74YdSsWROpqanYtm0bzpw586f3QfXp0wcrV67EgAEDcNtttyEpKQkLFixAgwYNkJ2dXXw9f39/NGjQAMuWLcNNN92E8PBwNGrUqNR/v/3ll18wefJkDBs2DH379gXwa19gs2bN8Oijj+KTTz65oY/vL6lM9j6SUt++fTU/Pz8tJydHeZ1hw4ZpFotFS09P1zRN0w4cOKB17txZ8/Pz0ypXrqw999xz2jvvvHPN2+gDAwOvurxoS/KVsrKytHHjxmkxMTGaxWLR6tSpo7300ktet8e/++672s0336zZbDYtLCxM69y5c3FLgOSnn37SBgwYoIWGhmp+fn5a3bp1tcmTJxfn3rbRu91u7V//+pdWsWJFLSAgQIuPj9eOHTt21Zb1GTNmaK1atdJCQ0M1f39/rV69etrzzz+vFRQUFF/H5XJpjz32mBYREaGZTKarzsGiRYu0uLg4zd/fXwsODtYaN26sPfXUU9q5c+eKr1OtWjXldn3VNvpdu3aVuJ63reMul0ubPHmyFh0drfn7+2vdunXTfvnlF61ChQraiBEjxPN65Tb6K82bN08DoE2YMKH4sk8//VTr0KGDFhgYqAUGBmr16tXTRo0apR05cqT4Op07d9YaNmx4zfejad7bHY4fP67dd999WnR0tGaxWLTKlStrffr00VasWCGeC2+KXrMXLlwocbnqNf7bx+DxeLQXXnhBq1atmmaz2bSbb75Z++KLL7xuf9+6dasWFxenWa3WEo9LdV9FWdHtuFwurWXLllpsbGxxq0SR119/XQOgLVu2THy8pGkmTbvBfyUmoj9NRkYGwsLCMGPGDN1PLCH6q+HfwIgMoujzFK80Z84cALhqSzzR3wH/BkZkEMuWLcOSJUvQu3dvBAUF4YcffsDHH3+MXr16oX379mV9eER/Oi5gRAbRpEkT+Pr6Yvbs2XA4HMUbO2bMmFHWh0ZUJvg3MCIiMiT+DYyIiAyJCxgRERlSufsbmMfjwblz5xAcHHxDP7KFiIjKP03TkJWVhZiYGP3PlPyjGszefPPN4obAVq1alZhXJUlOTtYA8Itf/OIXv/7GX8nJybrrxR/yDmzZsmUYP348FixYgNatW2POnDmIj4/HkSNHlOMoihR/UGyHKMDX++r7wevqXVeXnJfF239iyXtivnb8LGX27anvxdpZCavF/Km7vH88VJG31m1SZjHRFZUZANSvGiPmGU711N5vP9yizACgYlP5ttOT1Z+R9+bYUWLt5BUfi/nuce+L+bdn1yuzTafkj9JauXGHmBe6XMpMyyoQa/0rBIn5xEH9lFnf6reKtS5NfVwAYDbJ/2qtHFhNmTkK5O+fQ5flD1tuEXH1aJ8iZ3NOKzMAiA6QR6eczk5SZnXs9cVas85fS87lJot5qFU9skavNsg3RMwLPerXkt0mj8qxmL2Psyni53P9Hzyd77667/BKF/PTxNztcSuzyIBKyiwrKwtNat181egmb/6QBezVV1/Fww8/XDzsbsGCBfjyyy/x7rvvYuLEiWJt8a8Nfc3KBSwg2PuIbgDIs8jj1U02eXRIYHCgMvMLsom1sMq3bQuU60029dPh429RZgBgCZRfyBYfjxDK39xm4bgAiI/bP0j+BtK77eAQ+UXsn6m+favOOdF7LZh8NGWmOXVqdW7bL8hPmQWFyIvf713AQgLVP1C1Avm2A13q7z0ACAlR33amj/y4QgLk5zrIpP7elO4X0F/AsnzlYwu2qo8tSOdxBVvkvEBYwIJt8jmx6i5g8vMlsbjl702nNVfMpQVM77kGru1T/2/4Jo6CggIkJiaWGJFgNpvRo0ePqz7VGQCcTiccDkeJLyIiIj03fAFLT0+H2+1GVFRUicujoqKQkpJy1fVnzpwJu91e/FWlSpUbfUhERPQXVObb6CdNmoTMzMzir+Rk+ffJREREwB/wN7CKFSvCx8cHqampJS5PTU1FdHT0Vde32Wyw2XT+tkRERPQbN/wdmNVqRVxcHDZs2FB8mcfjwYYNG9C2bdsbfXdERPQ39YfsQhw/fjyGDh2KFi1aoFWrVpgzZw5ycnKKdyVeiw9en6HcbXjHcGEqbJS86+3cog1iXuPZ/srM4ivvLJs7YriYP/WBvCX8+NTVyszlkXeHfXnqSzG/s9YQZfZGjDyWfk/KGTGfNfYxZdbxtUfF2r1Pyuek+5IRYn5wzT5ldnnVHrH2/kaJYl4pUN0+8NkJ+XzfW/cfYh4zQb1Vfugr/xRrM3S2ukf4Xf2bjivlFKo3SoUI28UBoFpwdTG3+ah3V0b4yS00VrP8m5gqQer7dmvqHW8AkOfOEfOYgKpiLu38rOAnt7iE2SLEPKcwS5kFWa5/Cz6gvxVeYjHJO5/P55wT85srtlRmHk29K9pUivdVf8gCNmTIEFy4cAHPPvssUlJS0KxZM6xdu/aqjR1ERETX6w/7KKnRo0dj9OjRf9TNExHR31yZ70IkIiK6HlzAiIjIkLiAERGRIXEBIyIiQyp388CKXHJeVn8wr7RVPlXnE5Sd6WLuTMtWZxlOsXZv6nExr1tH3qp7Qfh0Z5enUKwNsqg/6BQAHIXqrdfpeeptvAAQbJU/MDRL2Jadlyefs7T8VDH31WldkGQKjxkALuZfEnOLWb2NWO/DYXNc6tcRAMCh3v5sNau3ov+ay8+HnkBha7be6yyzIEPMpe3Reo9LqgWAArf6tRSg82G8GQXyc61X7xHaWC7myz9T/HVuW/rQWr1z4tb5YGe9xyXR26JfOTBWzDVxq7xaaaZA8h0YEREZEhcwIiIyJC5gRERkSFzAiIjIkLiAERGRIXEBIyIiQ+ICRkREhmTSNE0r64O4ksPhgN1uh++jjWGyee8BOjXjM2W9Xp9X48G3i3nK5zuU2b50efzGsMUvi/k3o18V8yZ3D1BmMR1rirVP3d5PzOdt+EaZmcxy50W7BrXFfPHH65XZrhffEWtb/utBMc9euFPMU/PUIx36vi+M3QFw8nSKmOeeV/e3Ne/cSKzds1p+rexY/KEyu5wv96/pOZ8rP64BNQYpM5NJ/jftgp8WiPnjTR5XZnvS1d9bAFApQD2+BgC2pWxTZgNrDhZrc13yOJV1yV+JeY2Q6spM7/nKcyv6Wf+recXmyqyinzzBIznnpJjHBFQRc8m53GQxD7YEi/mZHHV99eBayizLkYWbohsgMzMTISHyOBm+AyMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjIkLmBERGRIXMCIiMiQym0f2LfHvkRgsPcZV11mj1PWS/O8ACBl4SYxj769tTKzNokQa+c88ICYH0g7IeZT26j7lk5nJ4m1Jx0nxbx+WH1ltid9r1gbarWLectI9TmLe+VesXbX+PfEPHZCbzGHW/3y3TtziViaUyj3BkUHVFJmenOxqgfLvXPt5t+nzLaOfF+szdWZNRZskZ8vac5ToK/c25NRcFHM7dZwZVbgkWfD2XTmhUn1VrNNrD2Xe1rMKwdWE3O35lZmWYWZYm2Qzjn1ManHMkqzwgD9mV1m0/XP0zPpTOb6T+YhMa9rV/dKSs+lw+FA1Yga7AMjIqK/Li5gRERkSFzAiIjIkLiAERGRIXEBIyIiQ+ICRkREhqTev1nGvj31PfyCvG+Ntfiqt4Y6M+StunojUaSt8gUHLoi1n/wsj/7wt1jEfG/6bmVm85G3Cf+e7bJrT+wR83yXS8y1Ruqt7HlO+fnYmSaP2LinXxcxX5qwQZn56JyTny7+LOanstRbrw+mHxVr+9XqJeZHdh8TUrmzJc+VK+Y2H3k7urTNXm+L/oGL+8S8fXQXZaa3LTvPLT+u9PxUZVY5oKpYm1EgjzyJ8Fe3TABAplPdPnAk84hYWy1I3qIfJIwlCfANEmv1ttH7+3pvRboWWYUZYh6lc87S89VjfYKE16CnFJ1dfAdGRESGxAWMiIgMiQsYEREZEhcwIiIyJC5gRERkSFzAiIjIkLiAERGRIZXbcSp4uB5g9d7HM3fEcGX93tTj4u1/8aM8OuTZO+5UZnp9Xt8tkke1fDz/BTEfu/QtZVatWrRY27NePTH/OV3dQ7Nq1Rax9rbb24n50RPnlNmIbj3E2mX75XO6+PanxfzDX5Yrs/9ckvv2fjqeLObZ2XnKLDIyTKx1OuX+nJ5N1ONt+tbsJtbmuOQxMHo9g+2jOiuzc7nyOVl3+lsx/+dN9yizA5f2ibWVhPE1AHAy66Qyu7linFir1992JEPu5aoeXF2ZrTqxRqxtEdlUzIOs6l6vSv4xYq3eWJ/advXrTM9lZ7qYp+adF3OpH7FqUE1l5nA4EFMhluNUiIjor4sLGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSFxASMiIkMqt31gT214CrZA7/0sr678Sllft448F2jJwH+L+bz9S5XZqcxMsfa+Rl3E/O6R8n0fXvG1MssqcIi1Y9e/KebL+7+ozJ76Xp0BwOpNcq/WxyMnKbPnNn0s1s7rM07M96cfFPMpKxPUtU98ItbOP7hQzHtXV/ewPbR6tlj7Zt/HxfzuJc8ps+2PvyfW5hbKPU2htnAxP+FQzzJrECb3LF1yyr114Tb1PL2MAvVMLQAI8pV7fgq1QmVmMVvlWr25WT4BYp5TqP7+07tvX7M8BzBH6FGTZrddi3O56pl2ekIsoWL+82X5e7NJhZuVWVah+mdpliMbjSs3Zx8YERH9dXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMiQuYEREZEjltg8s7KmWMNl8vV7n50nq/p4L+Wni7Te+q5+Yp6zersz2pu8Wa4e9+7KYbx47T8zrDbpVmcV0riXWju/TR8zf+m6jMgsIVM/tAYCeDeqK+ZyV65RZ4tNvi7VNp98v5lkvbxXztDz1LLLeS+Qes/Opcl9SxqUsZdala3Ox9rtlP4r5rvkfKLMLeXKvlclkEvPk7LNiPrDmIGXma/L+PVdk7sH5Yj6+mfqc70j7QaytEij3cG5PVX9vDqihnuMHANlC3xEArDklz/SqEhSrzDKcl8VaR4Hct9ezirrfMMxWUaw9mXVMzCsHVhPz33PbUf7y/LakLPVsxnqhDZVZliMLNaNuYh8YERH9dXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMiR5z2wZiomuCB9/72MIXB6Xss7lUY9cAICYjjXF/HR2kjKz+Xgf71KkWrVoMdcbiSJtlT+3Wb0lFQDeryhvUT6y8Wdl1v6udmJt9dDKYt6uTSNlllkgb19u2lBuD9AbwVEoPN+/7PiPWAuL/O+3uA7qrb7NouXn+kzb2mIe5a+uj9XZTp7ryhHzKkFyvbRVXm80yN03qbfgA/L35tlsdcsDAMRVbCPm3WLV280LPE6x1myWf9T1rtpbzF2a+nH5+fiLtU53vpgH+gYpM7POe4wYndfKjlS5nUPSpEIzMd+j01bUNqqDMvNonuvKfovvwIiIyJC4gBERkSFxASMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjKkUo9T2bJlC1566SUkJibi/PnzWLVqFfr371+ca5qGKVOm4K233kJGRgbat2+P+fPno06dOtd0+0XjVAateBCWQO89KV2qqvtzgiyB4u1fyLsk5jGBkcrMbPIRa/emqXutAOC7E/J4ggEN1CM63t8u93kd+DRRzO9+4nZldjkvT6wNtHjvxyu+7QZdlVm4X5hY69DpjasWLI+D2J9+QJkdz0gWa9/bJPfILLzncWX2/iH1CBkAaFVJ7m9rUOEmZdYhWn0+r4XZJP+79ItTq5VZr1j1SB8A0CD/uLD5qEfz/HJZ/VwBwE3CiA0AMEE9RibXJY8scWtuMQ+yyGM7MpzqfkS7NVysdRTK41bsFvX3SKEm97VazXJv6oaza8Vc0ii8sZjvTd8r5t0r91JmbqGvzuHIQo3I2n/MOJWcnBw0bdoUc+fO9ZrPnj0bb7zxBhYsWIAdO3YgMDAQ8fHxyM+Xm/mIiIhKo9SfxHHrrbfi1lu9/ytN0zTMmTMHzzzzDPr1+3Vw5Pvvv4+oqCisXr0ad9111+87WiIiov+6oX8DS0pKQkpKCnr0+N9HvtjtdrRu3Rrbtm3zWuN0OuFwOEp8ERER6bmhC1hKSgoAICoqqsTlUVFRxdlvzZw5E3a7vfirSpUqN/KQiIjoL6rMdyFOmjQJmZmZxV/JyfIf3omIiIAbvIBF//cTulNTU0tcnpqaWpz9ls1mQ0hISIkvIiIiPTd0AatRowaio6OxYcOG4sscDgd27NiBtm3b3si7IiKiv7lS70LMzs7GsWP/62dKSkrCvn37EB4ejqpVq2Ls2LGYMWMG6tSpgxo1amDy5MmIiYkp0St2LTKc+bD4eJ8Lc2etIco6vZ6LXm89JuafDn1e/+AUlv68ScyX939RzLsuekSZSfO8ALnPCwA+fuVzZTZ8kjzj6e56cm/Q/H2rlNmTLe8Va6ds+UDMP+wzTcxvEeY4RY+R50uFt5L/3vr8D8uU2bBmncTa17/7Ssy/e+A+ZZaad1aszXPJfXuOQnkG2y1V+igzH51ex/R873/LLhJiVfc0bU/dJdbWCqkr5tku9QavIItdrHW6csU8LU+eVSb1oBV45BYhqRYA8tzqYwsQZoUBQHahvOkt33X97UsWs9z/6S/0/AFAoadAmUn9hB6dnr0rlXoB2717N7p2/V+j5fjx4wEAQ4cOxZIlS/DUU08hJycHw4cPR0ZGBjp06IC1a9fCz09+sERERKVR6gWsS5cukD68w2QyYfr06Zg+ffrvOjAiIiJJme9CJCIiuh5cwIiIyJC4gBERkSFxASMiIkMq9SaOP8u3H24BLN7X1zdi3lTWpedlibdrMstbWvcIIwLWntgj1q5atUXMAy3yNvqAQPVOzfZ3tRNr9UaiSFvlF81cIdaubr9bzCVNIuXWggKnPC4ix5Uj5m/sW6TMJk5Rb1UHgPc3yCNqzianKbOHflS/BgGgSSN5nMqz22YqsydbjBRr9bY3xwbK7QEmk/p7QG8L/9mcM2JeL1S97btlpHpcEKC/fTpL2DIeYgkVa/W22RcIW75/rVd/wEJS1lGxNjqgspin5KrPeahNHtXi7xMg5rdUVbdM6NGbtBWmMypJ2uJf0S9KmRX6qEet/BbfgRERkSFxASMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjIkLmBERGRI5bYPrGLTGJht3g9vT4q6FyXYahVvt12D2mIealX3i+S75P6E226Xe7VWb9op5o/27a7MqofKvSQbkg6KuTQSRa/PK+3Hk2Ied1crZXYm66JYW7dSpJjbraFifvyyenzO9Pbq8TQAsOHwETFvGFtJmSVtPabMAKByjwryfR84rMyebR0o1no072OGitjM8uSHfGG0SKhV7js6dPmQmFvM6u+/Cn4VxVq3Th+Yo0A9JqZqoPyjLFtnxEygztiSAo9TmQVZgsVavRE1kmCd/jU9Tvf1j1PRGwOj97ilfsP0/FRllpWfLR/YFfgOjIiIDIkLGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSFxASMiIkMqt31g6ckXAav3/olZYx9T1kkzgwCg9b8eFvPn33xSmWmN5Pk4T616V8w/HjlJzO944zll1q5NI7F2dFxvMZ+/b5WYS6Q+LwBITFD3t01cqJ5DBgB3Pv2smL/eZZqYT22nfj7f3PehWJuScknMd32eqMyC68v9a19/vlXMP58yQ5ntv6ieSXctsgvlPpoO0R2VmY9Z/pFwLue8mEs9T74m+bYdhRliftJxUpk1CrtZrNV7XHvSd4l5sFXd81TokWfaHc+UewZrhNQUc0mOS55/GG6LuO7bPuZQ9yoCQISf/D2wM227MqsXWl+ZuXTO55X4DoyIiAyJCxgRERkSFzAiIjIkLmBERGRIXMCIiMiQuIAREZEhmTRNk/eG/8kcDgfsdjve3PUa/IP8vV7nqY/fV9bn5anHHgDA5idfF/PbF/xbfdtO+bafvVPeMp6wd4eYv3P7RGWWKYySAIACT4GYBwujD9ad2iTW6o1E6V6tpTK785GnxNolb04R8w9++kHMd+7+RZmtGztbrD2ZdUrMcwvzlFmGU96+3Lt6LzHvOXeMMkt4cLJYezorWcwjA+TtzU3Cmykzf98AsTbfrT4nemw+3r+fi3g88rgiX7NFSOXRHxfy5e3//r7yCBtpBI1erd44lUBf9femNMYFAMwm+T2Ij07rgkRvi75T57VgMduU2cFL+9X3m5WL/vXvRGZmJkJCQsT74DswIiIyJC5gRERkSFzAiIjIkLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDKncjlOZvOJjmG3eD2/vk+o+sLT8VPF2Wzz1gJif+b+1ymxnmtzH9eL3n4r5vD7jxLzp9PvVWcNaYu2UnnfL+ZYPlFmBUx5fULeS3FckjUTR6/MaNloel+L46icxP9v9tDIbt+k1sXbP/qNinrbvjDJr3qe5WDvhXfVrFAA2T1Ifm5+Pn1gbE1hJzNPz5b49q4+6P6dQp5/wh/NbxLxTTFdl5ii4LNbq9Usdv6x+vhqHy+NUgi12MT+ZdVzMLwrntEpQVbH2uEMep9KpUjdlptcHpteLFaTzuCXHMo+I+U129UgUAFh/Zp0yi/RXj3kx6/T0lbwuERGRAXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMiQuYEREZEjldh7Y8ZTDCA7xPien+5IRynpfX7mX5Pth74l50ONtlNk9/bqItU+3eUTMt6VsF/O7at+jzDIK5N6etLwUMQ+3VVBmOa4csdZuDRXzAN8gZTZozXixdtXt8ny2kN6NxLzxQHU/1op/vCDWhlrDxVyateSrM2fJqtPLNStRPavs/gbq1wEAmHT6ZIIs8gyly071aykmoIpYq/fDwqWpewo9mkes9feRZ5Fpwr17NLdYqzfbymK2irmfzrFJ9B63ySQ8nzo/nn3M8uvQ6c4Xc4ne62xH2lYxbxXZ9rru1+FwoGpEDc4DIyKivy4uYEREZEhcwIiIyJC4gBERkSFxASMiIkPiAkZERIbEBYyIiAyp3M4D+/bsevhn+nvNDq7Zd923mzrknHwFt7rvYmnCBrG0ml3uK3p/049i3u0x9SylQo88s2t/+gExv6Vqb2X2xr5FYu3xy/Icp6ntHlZmO3f/ItZK87wAuc8LAA6u3KPMQofJz0fihZ1iXkmYu7X2pPxa+EfdwWL+3JsJyuzxtx4VazMKLom5j06PWlRAZWUm9VoBwNFM+fmsF9pYmWW7HGJtodBDBgA5her6YEuoWKvfgxYo5lJ/29kc+TUcG1hNzHMKs5VZoMV7L2yRXJ0eTptZPftNl9SfBqCCn/z9ZRL6KD0elzIrTWsy34EREZEhcQEjIiJD4gJGRESGxAWMiIgMiQsYEREZEhcwIiIypHK7jX7TqQOwBnofcXB5lXrrdGahvOW795JxYr535hJl5mOSR7VM3/aWmO9/4hMx77BomDL7Zcd/xNrJj90t5tFj1GNiJk65T6yd3l4eE/Pmvg+V2bqx6rEhADBu02tirjsSRdgqH3V7K7G2bh/1lm8AqBRTUZmNb9VPrL1zxSQxv/y2ehTFmZxTYm2+zoiMY5lHxbxTpe7KTBohAwAV/SLE3OlRH9uyo/Lr/96694q5RO+43Zp62zYAHHcc1rl99fd+Rb9IsfaiM03Mg3zVI0P0fuYU6LwWvj+/ScwljcObiHlmQaaYO125ykzaYq/3XF2J78CIiMiQuIAREZEhcQEjIiJD4gJGRESGxAWMiIgMiQsYEREZEhcwIiIypFL1gc2cORMrV67E4cOH4e/vj3bt2uHFF19E3bp1i6+Tn5+PJ554AgkJCXA6nYiPj8e8efMQFRVVqgNbuXEHTDbvPRD3N0pU1l3Ml0dNnDydIuY5herxBD9d/Fms/el4spjPj1oo5udTL6pDi/xvjfd0RrWEt6qizN7f8INYu+HwETFPSVGf8y5VbxZr9+yXe5ZCb7n+kSh6fV5Hvjgo5gU96ymzcafkETQpF+TX4ebzG5VZm6h2Yq1Dp//Gbg0Vc4/mVmZ6PTgpeefFPNym7hNrVEF9Pq9Fjks9dsTPJ0CsrWCTf/5YzX5i7mu2KLNCT4FYqzeqReoxc+r0eVnM3ntlizQKl78HJOE2dR8kAJzIOiHmZrN6ebmYr+6Ny3aqn+er7uOarwlg8+bNGDVqFLZv347169ejsLAQvXr1Qk7O/37ojxs3DmvWrMHy5cuxefNmnDt3DgMHDizN3RAREekq1TuwtWvXlvjvJUuWIDIyEomJiejUqRMyMzPxzjvv4KOPPkK3bt0AAIsXL0b9+vWxfft2tGmj/jQIIiKi0vhdfwPLzPz1Vxnh4b/+micxMRGFhYXo0aNH8XXq1auHqlWrYtu2bV5vw+l0wuFwlPgiIiLSc90LmMfjwdixY9G+fXs0atQIAJCSkgKr1YrQ0NAS142KikJKive/Pc2cORN2u734q0oV9d9qiIiIilz3AjZq1Cj89NNPSEhI+F0HMGnSJGRmZhZ/JSfLGyGIiIiA6/w0+tGjR+OLL77Ali1bEBsbW3x5dHQ0CgoKkJGRUeJdWGpqKqKjo73els1mg81mu57DICKiv7FSvQPTNA2jR4/GqlWrsHHjRtSoUaNEHhcXB4vFgg0bNhRfduTIEZw+fRpt27a9MUdMRESEUr4DGzVqFD766CN89tlnCA4OLv67lt1uh7+/P+x2Ox588EGMHz8e4eHhCAkJwWOPPYa2bduWegdiocsFk4/mNasUGKOsswj9GgCQe17eJBIdUEmZnco6LdZmZ+eJee/qPcT8mUsfK7O4Dg3F2hm9hor58z8sU2Znk+V5RQ1j1ecEAHZ9ru7Ly+0vn5O0fWfEXG/OU6VA9bFJ87wAuc8LAJLWq2dENR0UJ9bmnHaKeaAlSJkduiT3p7k1j5hfcso9aD1i5ZlekpRcuY+yfqi676heaAOxNs+tnh8FAKnCfccEVP1dt33o8gExL3Cre73C/MLE2hOZSWLetbJ6PpvezzO30NMHANH+lcVcsu/ibjFvXrGlmH9x6jNl1rFSR2Um9dxddd1rviaA+fPnAwC6dOlS4vLFixdj2LBhAIDXXnsNZrMZd9xxR4lGZiIiohupVAuYpnl/R3QlPz8/zJ07F3Pnzr3ugyIiItLDz0IkIiJD4gJGRESGxAWMiIgMiQsYEREZ0nU1Mv8ZtKwCaE7vYwY+O/Glss6ssyY379xIzDMLMpTZwXR59EdkpLyd9qHVs8W8S9fmyqyZohG8yPuH1on5sGad1Mf145tibdLWY2IeXD9SmWU4s8Ta5n3UjxkAfE3yS3TtyQ3KbHyrfmKt3kgUaav8/hXq1gEAqHubPMZi3t7Vymxut2fE2ny33Jrg5+Mv5tL3iN44FT0uoV4ahwIAdqv8/SO1VJhgkg9MR8OwJmIu3frlArltoXNMNTFPyT2rzGKDqou1Vh/5QyAKdEa9SOrqtD1cyJdbKlpEtFBmUnuARRjD8lt8B0ZERIbEBYyIiAyJCxgRERkSFzAiIjIkLmBERGRIXMCIiMiQuIAREZEhlds+MP8KQTDZvPeB3Vv3H8o6vV6TJyfLHzJc/d7ayqxfrV5i7Zo9+8X8rUETxLzdqAeU2Zm26uMCgFE94sX89e++UmZNGtUSayv3qCDmX3++VZn1ri6fswnvvi/mVh8/Mf9H3cHK7M4Vk8TalAty/440EkWvz+vIl/JIlPeWqo9t/8W9Yq2e1Fx5PM6AmncqM6tJ7ivacmaXmPeM7a3MDmeox9MAQLVguV/q+3PblVmzCvJoDx+T958lRb4+84WYt4xU3/4Jx3GxNkgYnQMAIdYQZebvEyDW/pIhj4GpHSKPDJLkCyNkroXeKKQbge/AiIjIkLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMqRy2wc2cVA/+AV57wGKmXCrutAh9y7sWPyhmLebf58yO7Jbnos19pH+Yn73kufEfNf8D5RZlL88D+yXjJ/F/LsH1I/r2W0zxdoNB+T+nc+nzFBmPeeOEWs3T3pNzGclyjPUnnszQZldflvdnwYAm89vFPNAoX9HmucFyH1eANDmHnUv44U1u8Xai84LYt4iorWYSzPWCtz58m1Hy/P0XB71PLA2ke3EWo/mFvOusR2Umd4cs6QseZZf3+oDxDxLmBPoK8y2AoDqwTXEPEO4bb3HVSWwupj/Hmad3rkAnR41DZoy8xNqC33k18GV+A6MiIgMiQsYEREZEhcwIiIyJC5gRERkSFzAiIjIkLiAERGRIZk0TVPvdSwDDocDdrsde05vR1CI923MIVa7st5qlsdv7EyTt1a3jGwrpPKp2peeKOYNwuURHHsvqLdP31wxTqwNsYaJeWreWWWmN/bA3ydQzKXxH/6+8vPhpzMupYJfRTEPtqhfCym56scMABH+UWJ+6JJ6JEr9sIZird5IFGmre0TfFmItQq1ybpG3P983TD16p31sfbF2ceIWMX+ifT9ldjY7Rayd+MFSMa9ZrZIy69ywjljbKkZ+XPdPlds1PpkxVZlNWL5YrH2oexcx333+lDK7vY78Wnh5/edivnPkR2IuOZ2dJOY/Xzok5q2i1K/xid+/qswKcwvw6aB3kZmZiZAQ9agZgO/AiIjIoLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMqRyO07FpbngUowSyCi4rKyzmnV6ZHTkurKVWZ4rV6zNceXIt12ovm0AMJlMwnHJt63XB5bnylNmFp1xEB7NI+aS01nJYh4TqO7tAYCKfhFinlFwSZnl64wGcRRkirlbeNz5bvX5vBbiSBS9Pq8MeWSQXn3rmJuUWaBFHpHhdsmjLgrc6mNLy1E/VwAQHCD3BAYGqnO9Ztajl06LeUCVUDG3+qjPqa+P/D6gZmismDsK1D8XLD7yj2hnvvxa0BuJIrEL/bYAkJ6v/jkMAEFCj+Yvp88pM3deoXxgV+A7MCIiMiQuYEREZEhcwIiIyJC4gBERkSFxASMiIkPiAkZERIbEBYyIiAyp3PaBmU1m5ZyqCL/o677d87nyTKI2UR2UmU1ndpXNxybmobZwMU/OVs+vqhJUVazVm+nlKFT3PMUGVhFrbToz1rKF/rbIgEixNj3/opg3Cm8q5j4m9Uv4WOZRsdZuDRXzS05135Kfj79Ym5qbJubSPDC9eV6/t0/sYp76tVA7tIZYW1Ag9+gEW73P8LsWvr7yj6O8PKcya1ixulibliu/znLTssQ8KVPdz2ixyMd9NjtVzKMD1TPvInTm4eXp9IGZoO4t1XNZeP0DQIPwumJe6FEfW0Cg+vvHZb72ZYnvwIiIyJC4gBERkSFxASMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjIkk6ZpeqN0/lQOhwN2ux3nL55FSEiI1+vkFDqU9YEW7zVFpN4EvTxI57bdHu/zy4r8knFQzGuE1FFmvkK/EwCsP7NWzG+p0keZSXPIACBfZw6aR1PPiNJ7cVl1eucu5Ml9e1EBlZWZ3jmTjhsAnB5135FZ599+Pjq9LNKxjdw4UayV5nkBcp8XADz774XKLHn1FrF2e+p2Me9Vpbcy05vV98iGp8T85ih1j1rDCvXE2mWH14l5plP9XAPA4VPq+VXxTeqLtct/SBTzBf94TJk1riD3Qe5L3yvmTrf8uCSvbP1MzFcMfFHMFxx8R5n1q3WLMsvOykGXmr2QmZmpXAOK8B0YEREZEhcwIiIyJC5gRERkSFzAiIjIkLiAERGRIXEBIyIiQyq341QcBZehFXjflh5iDVPWuTzyuAeTztiRQN9gZZbrUo8NAYCL+RfEvEGYvCVW2sJv0dmC3Cv2VjH3MalHdKTmqce4AECoVR4DI20Zl+4X0G9riAmQR71owkZ9vREzbk1ue/g9tVaT3B5Q4M5XZu1j5W3ZgZYAMdcbiSJtla/Sv5NY+/0H74m5/YFWymzc8H5irZ7Y4ErKrNdsufUg7UV5G/3qk6vFfEn8y8rswyPyOdn++Ggx7/vxWGWWuGynWHvH4+q2BQAY2riXmEs+HThbzBf99K6Yt4uJU2Yzti1WZoW58s+EK/EdGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSFxASMiIkPiAkZERIZUqj6w+fPnY/78+Th58iQAoGHDhnj22Wdx662/9iDl5+fjiSeeQEJCApxOJ+Lj4zFv3jxERUWV+sAOXf4JgS7v/S7Vgqsr6zILMsTb/e7Mj2J+b91/KLMDF/eJtUczksS8f83bxfz9wx8ps7tvGiTWhtsixDw9Xz2W5GzOGbH20OVDYn4u57wy619jgFj7w3l5fEdPnf62o5m/KLOKfvI5SclTHzcApOTKo1wkW87sEvMW0Y2U2eJE+Zy4XfIYmIICuRfymZ5DlJlen1fHe4eK+aFPvlBmnx5bI9YuXve9mL8/T33bC194Uqyds2+emH/8vTwmJnJwRWU24vW5Ym3qw5fEPDgkUJntXJog1vZ6fYKYL4l/Scwl53PlnwudYtuIeR27euxPzxqnlFledj6+lA+tWKnegcXGxmLWrFlITEzE7t270a1bN/Tr1w+HDv36A27cuHFYs2YNli9fjs2bN+PcuXMYOHBgae6CiIjompTqHVjfvn1L/Pfzzz+P+fPnY/v27YiNjcU777yDjz76CN26dQMALF68GPXr18f27dvRpo28WhMREZXGdf8NzO12IyEhATk5OWjbti0SExNRWFiIHj16FF+nXr16qFq1KrZt26a8HafTCYfDUeKLiIhIT6kXsIMHDyIoKAg2mw0jRozAqlWr0KBBA6SkpMBqtSI0NLTE9aOiopCSov5bwsyZM2G324u/qlSRP/uOiIgIuI4FrG7duti3bx927NiBkSNHYujQofj555+v+wAmTZqEzMzM4q/k5OTrvi0iIvr7KPWn0VutVtSuXRsAEBcXh127duH111/HkCFDUFBQgIyMjBLvwlJTUxEdHa28PZvNBptN/uRuIiKi3/rdfWAejwdOpxNxcXGwWCzYsGFDcXbkyBGcPn0abdu2/b13Q0REVIJJ0zT1QKXfmDRpEm699VZUrVoVWVlZ+Oijj/Diiy9i3bp16NmzJ0aOHImvvvoKS5YsQUhICB577DEAwNatW6/5gBwOB+x2O05fSEJISIjX69h8/JT1Hs0j3r7ejCipXu+2XTqzrazCcQPysbk88vwpX2EmFwA4hflTejPU9GaRSTO/ct05Yq1ZZ16Y3jwxm1l9Tp0e9WMGAIvJIubSrDGXzjwwPx9/MZeez7XJ6n4nAChwy6+zYGuQmHeO6aHMpHleAHDojU/EvOHgPsqs9b3txNo7m7QU87aVWiiz+z96Uaz9YaR6/hQA7EhVbzQDgI6Vuiiz/2TKf0KpF6ru+QOAIV+OV2Zff/qDWHvfvfK8rwYVK4u5ZHAduQVq/HfqGWkAcL8wi+yFzcuVmSuvEIkjVyMzM1O5BhQp1a8Q09LScN999+H8+fOw2+1o0qRJ8eIFAK+99hrMZjPuuOOOEo3MREREN1qpFrB33nlHzP38/DB37lzMnSt3phMREf1e/CxEIiIyJC5gRERkSFzAiIjIkLiAERGRIZW6kfnPcjbnNDJ9vG8HjvCLVNZZhW3VAPBLxkExbxDWRJmZYBJrD1zaJ+a17XXE/GjmEWV2NvucWFs/rJ6Yb09Vj/doGdlcrK3gpx4lAQC+JvXLyG6rINY6Ci6LeYCvvCU826X+7MxlR+Ut340qyOesXmgDZZbjyhZrD2ccFvM2keot5Wez5TEuaTnyeA49PWN7K7Nxw/uJtXojUaSt8js+kNtpBrx4s5ivP7VZmY3uES/WejR5BM3RjBNi3i66gzI74ZDHKDUKkx9XvkvdUvHvRweLtRuPHRVzP9/r/xEf6Bss5hu27hfz+T2mKLOBTY4rs/zsfCRitXjbRfgOjIiIDIkLGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSFxASMiIkMqt31g0QGVERLgvQ/BalYPwNQbeVIpIEbMpfEcee5cnduuJOZBvvJogCqBVZVZXMU2Yq3JJPeo1Qqpq8z0emTcOrmjMEN92zpjYPTGpfj7BIh5oaYeBXNv3XvFWj3S8223hom11YKribl0zid+sFSsDQ6Qex19dXp/zmQ9JeaSxeu+F/NnBt2hzPT6vCb+S+dDwGuqv39uqqf+3gGAC7lyv+ELH38m5s3/pe4Pves1eZTLnOEXxDz5lLrvr+YVw4G92f79ATFf/fqrYi7J1el1fG/4E2Iu/UT68j8/KTNXrjze6Up8B0ZERIbEBYyIiAyJCxgRERkSFzAiIjIkLmBERGRIXMCIiMiQuIAREZEhlds+sNPZSQgyBXrNqgRVV9YVuJ3i7W5L2Sbmt1W7XZml56eKtaeyTol5uF+EmG9P3a7MusX2EGtDLKFiLs3NyipUZwDgKMgU85OOk8rs1qp9xdrjl+V5Rs0rhot5js6xi7U6fS6puer+HLNJ/rff9+fUzyUAdI1Vz5eqWU3uJwwMlPvA8vLk74Gbo2oos9hg+b7fn/eFmLd9rIUyk+Z5ARD7vAAAJ9TP9ZAHWomlkQHyXLrgIH8xl/pLTT5yD6bTXSDmZrP6tTTgpq5i7ceh8ow1aVafHg2amAdb5XlhhR51P1f/es2UWX52PrZCnuVXhO/AiIjIkLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGVK53UZfx14fISHet9VK4z0CfIPE2x1Yc7CYa5p662jlAHlkQ7itophbzFYxH1DjTmVW4JG3RuuNPgiy2JWZ3hb8qoHyy6RRmHpMht4olsbh8ogNvVEvwcKx621199MZ1RIjPN8mcVgE0KxCSzF3a+oxM50b1hFr5c3NQMOK1cW8blhtZdZr9kSxduELT4r5/R+pR4uM7hEv1uqNRJG2yj/3zLti7cb33hbzsbffIubNK6rve1ifLmLtnbUHiPnnv+xXZn1mPi0fV1w9MT/qOCzmkjoh8m3vTNkr5rVCaimzd39Ut1S48zhOhYiI/uK4gBERkSFxASMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjKkctsHZv7v/7zJc+co6zIKLom3G26TR5pcdqYLt31ZrI3wixRzk05fktOTq8zMZvmp0uu3crrUty31iAFAdqE8TsVHOLZMnXMWrHPf+UK/FCCPuZB6rQCggi1KzPPc6nOmx8fkI+ZJWeoxMq1i6ou1Ry+dFvO03Itivi/1uLr2xXVi7Zx988T8h5GLlZleT9+FXPm1Io1E0evz6jb0ITFf9Ma/5fr31fVhYfJYkcc3zhbz5f3VvXPoL5bigyMfibndGirfgOClPXPE/JmWk8R8e9oPymxYu07KLD87H89Afh0W4TswIiIyJC5gRERkSFzAiIjIkLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDMmkSQOwyoDD4YDdbsee5B0IDvE+20ua06Tns5Ofirk8k6tArN2R+qOYt4/uLOYJx5Yqs95Ve4u1wTr9Hml555SZ1WwTawN1ZqztSd+lzBqENxZrz2SfEvOaIfJsLH+fQGV2XGcWUqR/JTE/dPmAMmsY1kSsXX9G7mPpW109I8p+XwuxNqBKqJjnpmWJ+aA7uyizXjWbirUz16wU8zeGPKrMjmacEGufXPyBmAcH+SszvXleMcFyj+bwx18Qc6lPbMIH74m1g7u3EfPz2erna3D9dmLtkx8tEfOkZ9aKueRwxkEx15uJJ/WgvXPoQ2XmzHHilZ4vIzMzUzkTsgjfgRERkSFxASMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjIkLmBERGRI5XYeWKg1DMFW73N2XMKcJ49HngFVI6S6mEtztTKd8pyl6sHybecUOsS8SlCsMpMeMwBk6Byb1LMRZJF7LQo8TjFXPU8AkC/MIQOAi/nycTcIk/uSXFqhMjPrzOTyNVvEvMCt7vuTO2CAlpEtxTyrIEOZfTJjqlhr9bGKeVJmspi/8+N3ymxJ/MtibeTgimLesVIXZdYuuoNY2/xfcm+dNPutecVWYq00zwvQnwcm9YnNnKXufQOASa8vEfOzC9YrszCrfL7jxsSJ+fSdz4u55MU3V4j55SXbxbzh7IHKbMvjC5RZliMbr0B+HRbhOzAiIjIkLmBERGRIXMCIiMiQuIAREZEhcQEjIiJD4gJGRESGVG630Z/LTUaQj/cxHhX81FtLL+ani7d7Of+ymGcVZiqzI5lHxNo9aerxGwAwvIG8lTfDqT42Px/1KIlf8wAxL/DkK7OkrKNibZBFvU0eAAo96q3s/r7qcScAUCXo+kfjAMDZnNPKrKKfPEKjUGc8TphfmDK7XHBJrD3hOC7m0hb+CcsXy7U+8r87LRb527pPC/WImw+PyKNBRrw+V8x3Ph+jzE44ksTau157UcxNPurmhWF9uoi1YWHya1hvJIq0VX7SxHliba+RPcR88OqJyuyRFnLtkx8vEfMjkz4Tc0mPlzqKeZJD/rmxZsQsZfZN8rfKLC87Tz6wK/AdGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSFxASMiIkPiAkZERIb0u/rAZs2ahUmTJmHMmDGYM2cOACA/Px9PPPEEEhIS4HQ6ER8fj3nz5iEqKqpUtx3kG4Jgi/c+sDBbhLLO39d7TZHjjhM696vuF6kWVE2sNesM2dAb3+EoyFZmTre6jwvQH3kijVOJDqgs1vrojCU5nnns+msd6loAqBpUU8xjA9XPyUVnmljr7yP3qJ3IVPctdY6RXwtBitdukerBNZTZQ927iLU1Q9VjdwDgbHaqmM9dpx7fsf3x0WJt6sNy/1u90EbKrFHYzWLtnOEXxNwpjLe5s/YAsfbxjbPFfHD3NmIujUTR6/P6Zr665wkAvn5X3VsXFyGPiakzsraYrzj+iZhLHpr7pphnvvaDmNd/sZ8y2z9hmTLLcmThCfxLPrj/uu53YLt27cLChQvRpEnJGT7jxo3DmjVrsHz5cmzevBnnzp3DwIHquTBERETX47oWsOzsbNxzzz146623EBb2v08ryMzMxDvvvINXX30V3bp1Q1xcHBYvXoytW7di+3Z5+BkREVFpXNcCNmrUKNx2223o0aPkW+fExEQUFhaWuLxevXqoWrUqtm3b5vW2nE4nHA5HiS8iIiI9pf4bWEJCAvbs2YNdu3ZdlaWkpMBqtSI0NLTE5VFRUUhJSfF6ezNnzsS0adNKexhERPQ3V6p3YMnJyRgzZgyWLl0KPz+/G3IAkyZNQmZmZvFXcnLyDbldIiL6ayvVApaYmIi0tDQ0b94cvr6+8PX1xebNm/HGG2/A19cXUVFRKCgoQEZGRom61NRUREdHe71Nm82GkJCQEl9ERER6SvUrxO7du+PgwYMlLrv//vtRr149/Otf/0KVKlVgsViwYcMG3HHHHQCAI0eO4PTp02jbtu2NO2oiIvrbM2mapv2eG+jSpQuaNWtW3Ac2cuRIfPXVV1iyZAlCQkLw2GOPAQC2bt16TbfncDhgt9ux69SPCArx3ksTblPPAzOZ5F6snMIsMY/yV/dEZRRcFGuTc06JeTWdnianWz0HJ8QSKtZazFYxz3PnKrOU3LNirR6rj02ZVQlU9zsB+v1rer1z0vOp14Nm1smlY9M7Z3qvQ+m+n/5eni91U4UKYh4dqP7+AIAG4XWU2eT174u1wSFy75y/Rf185btcYm3yKe9/Jy9iNqt/YRQRpZ7dBgDL+8uzxh5eP1XMF/WcosykeV4A8EzHu8T81gdGKbMeI7qLtQUut5jH164v5pLe1eX+tmd+WCjmDze9RZnZhJ8ZOVm5GNTwH8jMzNT9jdwNH2j52muvwWw244477ijRyExERHQj/e4F7Lvvvivx335+fpg7dy7mzpUntxIREf0e/CxEIiIyJC5gRERkSFzAiIjIkLiAERGRId3wXYg3it0WhmCb99EmQRb11kqP5hFv198nQMyl7c8BOqNaKvnHiHmwxS7mAb7qLcpmnX9rFGqFOretPvZQW7hYq3fcEr1t8rrb6E3ySzTQoh5/o7eNXm9EjUXYwh8bVF2s1XuduTX1lvLb67SQj8tHPicRfvI2+sYVmiqzxGU7xdqdSxPEvNX4B5TZvx8dLNbW/M1H0P3WgJu6KrM+M58Wa9FfjgfXbyfmYVb1OX2khbzdXG8kirRV/tsFG8TaAWN6i3mraHmEjSQmoIqYd6yibscAgDDh58rEDW8rM1ee/LPsSnwHRkREhsQFjIiIDIkLGBERGRIXMCIiMiQuYEREZEhcwIiIyJC4gBERkSGV2z4wi9kKq2JESKGnQFkn9dcAQGreeTGPDaymzKT7BYDMggwxr+AXJeYns44ps5jAqmKtXt9RdqHjumv15LjUI030esikETLXUp/rylFmBbp9XvIIGremHlUhjZABgF8yDoh5lcDqyuzl9Z+Ltc58+XWYp5O/NXSsMrvjcbmvqNfrE8T8vnt7KbONx46Ktdu/l8/Zx6HqkUzN4+qJtR8c+UjMX/nsCzGPGxOnzJ78eIlYW2dkbTGXRqLo9Xmtev0rMV+0ZrqYS/S+P0IVfbpFWkWqe+scmXOUmZt9YERE9FfHBYyIiAyJCxgRERkSFzAiIjIkLmBERGRIXMCIiMiQuIAREZEhmTRN08r6IK7kcDhgt9tx/uJZhIR4n/uVL/QOSTO1AP0ZUL7CDCg9evOnzuScFPNwW4Qy25H6o1jr0ul/y3epH/ctVfuItXrn7PfMZ9ObB2aCej4bIM8L+/bsWrG2UXhjMY/2r6zMCnR6As2m6/+3oV6tWed1pnfOvj69RplZfeTXf9eYnmI+9+A8ZXYiI1Wsnd72STGXnuujjsNird0aKubVgmqJ+fSdzyuzSS3k415x/BMxT829qMz05nk1q9BczCP6yrPlxNu+U64NDPIXc5fQ37Zm8OvKLMuRhVpRdZGZmalcA4rwHRgRERkSFzAiIjIkLmBERGRIXMCIiMiQuIAREZEhcQEjIiJD4gJGRESGxAWMiIgMiQsYEREZEhcwIiIyJC5gRERkSFzAiIjIkLiAERGRIXEBIyIiQ1LPJyhj+e48WNzeD89iUo98KNQZc3EuN1nMpbEKWYUZYq3e6JAQS6iYn8w6psyaVGgm1uqNJbEIY2L0Jurojec4JoyyiPKvJNdmHhHzhmFNxRwm9bE1Dm8ilobbKor5vou7lVnd0AZibb5bb9yKeiRKen6aWGu32sX8svOSmL+y9TNl9unA2WLt+dwzYj64zkBlFugbLNbmurLFXIP6dVonpJ5Y+9KeOWI++KbbxfzFN1cosx4vdRRrH5r7ppjvnfaOMosJqCLWWsxWMdcbiSLZt1z9+geAg598LuaNH79LmVnvsikzi1n+WXYlvgMjIiJD4gJGRESGxAWMiIgMiQsYEREZEhcwIiIyJC5gRERkSFzAiIjIkMptH9jF/DQ4rbles/M555R1lQNjxdsNtsi9KP/JPKTM9HqaUvPOi3mGM0PM69jrKrM96XJPRqHHJeb+Pn7KLMwvTKwN0jlnEX6RyszpzhNrb7LXF/MdaVvFvIJfuDLLLMgUa09knRDz5hVbKrML+SlirZ4AnwBl9vMl9WsQANLzL4t5g3D16wgAVgx8UZkt+uldsbZTbBsxfyPxU2W2Yet+sfa94U+IebBV/TrcmbJXrH2m5SQxP5r5s5hfXrJdmSU5joq1ma/9IOb/+Gq8MutYpY5YG2qTvzcDg/zFXKLb5zVY7p3btnSpMlub/KUyy82Sf2Zcie/AiIjIkLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDIkLGBERGRIXMCIiMiSTpjcM6k/mcDhgt9ux4+T3CAoJ8nqdyoFVlfWazkyuw0KfFwA0DVfPz0nX6f3J1plnpNdH9vPlg8qsXmhDsVZvLpA0Jy270CHWmoSZWwBw4KK6v6dVZFuxdtPZDWJ+a9U+Ym4yqf8N5nR57yMsYjbLbZBfnlL3wbSIkOcsmYXjAoAAX3UfmDT3CgCCLPI8ML2ZePMOLFJm7WLixNpG4Y3FfM+FRGXWKkp+LcivMqDQUyhk8mM+7jgu5jWDa4p5xzceUWZrRswSa/sumCjm8/45SpmF2dR9jgDQKrKdmHdZOkzMJTvW7xPzba+8JeZt77lHmWV8eUCZORwOVI2ogczMTISEhIj3wXdgRERkSFzAiIjIkLiAERGRIXEBIyIiQ+ICRkREhsQFjIiIDKncbqNPSjuGkBDvowJMwrqrtxU335Mv5v7CmAuPzhZ9q49NzPW24Qf6qkcj6N23r86WcLfmVmbSYwaA9PxUMZe2N5/KPiXWmnWesbiI1mIutU24NHnEzCVnuphbzJbryq6Fn3DOH9s0Taz95bR6nBAABATKIzT+75bHldmMbYvF2p415G307yeqR4cMbNJcrP3yPz+Jef96zZTZuz9uFmuHtesk5pfy5NE7DzRUbwn/JvlbsfbOWneK+e4LO5TZ9M0fi7WOTLl1Z9OD8lZ3idUs/zyTRqIAwC1VblNmobc1URe6PMB357mNnoiI/rq4gBERkSFxASMiIkPiAkZERIbEBYyIiAyJCxgRERmSvPe6DBTt6s/KylJe5/dso3fqbKMv9FFvvfbodBxYfZxinpUvb3n1CM+G3jZ6H51t9B5hG730mAH943YJ2+hzcnQ+EV7nGXPY5E/Kl7pA3Drb6LOd8uPyFbfR/75vnUIf4fnIlT9Z3Z2nPt8A4NI5tuysnOu+77xs+fvHJRxbvl5trvy4pHq9c6J33858ne9dh/q1kpedp1Or/lkGADlZ6u8R6XwC+o9b774lFrN8TnKz5MftcAjfuy7h59l/s2vp8Cp3fWBnzpxBlSpVyvowiIioDCUnJyM2Nla8TrlbwDweD86dO4fg4GCYTCY4HA5UqVIFycnJuk1t9Cues9LjOSs9nrPS4znTp2kasrKyEBMTA7NZ/itXufsVotls9rrqhoSE8AkvJZ6z0uM5Kz2es9LjOZPZ7fLQ1iLcxEFERIbEBYyIiAyp3C9gNpsNU6ZMgc0mf7Ak/Q/PWenxnJUez1np8ZzdWOVuEwcREdG1KPfvwIiIiLzhAkZERIbEBYyIiAyJCxgRERlSuV/A5s6di+rVq8PPzw+tW7fGzp07y/qQyo0tW7agb9++iImJgclkwurVq0vkmqbh2WefRaVKleDv748ePXrg6NGjZXOw5cDMmTPRsmVLBAcHIzIyEv3798eRI0dKXCc/Px+jRo1ChQoVEBQUhDvuuAOpqalldMTlw/z589GkSZPi5tu2bdvi66+/Ls55zmSzZs2CyWTC2LFjiy/jObsxyvUCtmzZMowfPx5TpkzBnj170LRpU8THxyMtLa2sD61cyMnJQdOmTTF37lyv+ezZs/HGG29gwYIF2LFjBwIDAxEfH4/8fPmDTf+qNm/ejFGjRmH79u1Yv349CgsL0atXL+Tk/O/DbceNG4c1a9Zg+fLl2Lx5M86dO4eBAweW4VGXvdjYWMyaNQuJiYnYvXs3unXrhn79+uHQoUMAeM4ku3btwsKFC9GkSZMSl/Oc3SBaOdaqVStt1KhRxf/tdru1mJgYbebMmWV4VOUTAG3VqlXF/+3xeLTo6GjtpZdeKr4sIyNDs9ls2scff1wGR1j+pKWlaQC0zZs3a5r26/mxWCza8uXLi6/zyy+/aAC0bdu2ldVhlkthYWHa22+/zXMmyMrK0urUqaOtX79e69y5szZmzBhN0/g6u5HK7TuwgoICJCYmokePHsWXmc1m9OjRA9u2bSvDIzOGpKQkpKSklDh/drsdrVu35vn7r8zMTABAeHg4ACAxMRGFhYUlzlm9evVQtWpVnrP/crvdSEhIQE5ODtq2bctzJhg1ahRuu+22EucG4OvsRip3H+ZbJD09HW63G1FRUSUuj4qKwuHDh8voqIwjJSUFALyev6Ls78zj8WDs2LFo3749GjVqBODXc2a1WhEaGlriujxnwMGDB9G2bVvk5+cjKCgIq1atQoMGDbBv3z6eMy8SEhKwZ88e7Nq166qMr7Mbp9wuYER/pFGjRuGnn37CDz/8UNaHYgh169bFvn37kJmZiRUrVmDo0KHYvHlzWR9WuZScnIwxY8Zg/fr18PPzK+vD+Usrt79CrFixInx8fK7amZOamoro6OgyOirjKDpHPH9XGz16NL744gts2rSpxOie6OhoFBQUICMjo8T1ec4Aq9WK2rVrIy4uDjNnzkTTpk3x+uuv85x5kZiYiLS0NDRv3hy+vr7w9fXF5s2b8cYbb8DX1xdRUVE8ZzdIuV3ArFYr4uLisGHDhuLLPB4PNmzYgLZt25bhkRlDjRo1EB0dXeL8ORwO7Nix4297/jRNw+jRo7Fq1Sps3LgRNWrUKJHHxcXBYrGUOGdHjhzB6dOn/7bnTMXj8cDpdPKcedG9e3ccPHgQ+/btK/5q0aIF7rnnnuL/z3N2g5T1LhJJQkKCZrPZtCVLlmg///yzNnz4cC00NFRLSUkp60MrF7KysrS9e/dqe/fu1QBor776qrZ3717t1KlTmqZp2qxZs7TQ0FDts88+0w4cOKD169dPq1GjhpaXl1fGR142Ro4cqdntdu27777Tzp8/X/yVm5tbfJ0RI0ZoVatW1TZu3Kjt3r1ba9u2rda2bdsyPOqyN3HiRG3z5s1aUlKSduDAAW3ixImayWTSvvnmG03TeM6uxZW7EDWN5+xGKdcLmKZp2v/93/9pVatW1axWq9aqVStt+/btZX1I5camTZs0AFd9DR06VNO0X7fST548WYuKitJsNpvWvXt37ciRI2V70GXI27kCoC1evLj4Onl5edqjjz6qhYWFaQEBAdqAAQO08+fPl91BlwMPPPCAVq1aNc1qtWoRERFa9+7dixcvTeM5uxa/XcB4zm4MjlMhIiJDKrd/AyMiIpJwASMiIkPiAkZERIbEBYyIiAyJCxgRERkSFzAiIjIkLmBERGRIXMCIiMiQuIAREZEhcQEjIiJD4gJGRESGxAWMiIgM6f8BcMhyYmU+pc8AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "adhoc_matrix = adhoc_kernel.evaluate(x_vec=train_features)\n",
+    "\n",
+    "plt.figure(figsize=(5, 5))\n",
+    "plt.imshow(np.asmatrix(adhoc_matrix), interpolation=\"nearest\", origin=\"upper\", cmap=\"Greens\")\n",
+    "plt.title(\"Ad hoc clustering kernel matrix\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we define a spectral clustering model and fit it using the precomputed kernel. Further, we score the labels using normalized mutual information, since we know the class labels a priori (before hand)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 178,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Clustering score: 1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.cluster import SpectralClustering\n",
+    "from sklearn.metrics import normalized_mutual_info_score\n",
+    "\n",
+    "adhoc_spectral = SpectralClustering(2, affinity=\"precomputed\")\n",
+    "\n",
+    "cluster_labels = adhoc_spectral.fit_predict(adhoc_matrix)\n",
+    "\n",
+    "cluster_score = normalized_mutual_info_score(cluster_labels, train_labels)\n",
+    "\n",
+    "print(f\"Clustering score: {cluster_score}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Kernel Principal Component Analysis\n",
+    "\n",
+    "This section focuses on a Principal Component Analysis task using a kernel PCA algorithm. We calculate a kernel matrix using a `ZZFeatureMap` and show that this approach translates the original features into a new space, where axes are chosen along principal components. In this space the classification task can be performed with a simpler model rather than an SVM."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.1. Defining the dataset\n",
+    "\n",
+    "We again use the _ad hoc dataset_ with a gap of `0.6` between the two classes. This dataset resembles the dataset we had in the clustering section, the difference is that in this case `test_size` is not zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 179,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adhoc_dimension = 2\n",
+    "train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(\n",
+    "    training_size=25,\n",
+    "    test_size=10,\n",
+    "    n=adhoc_dimension,\n",
+    "    gap=0.6,\n",
+    "    plot_data=False,\n",
+    "    one_hot=False,\n",
+    "    include_sample_total=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We plot the training and test datasets below. Our ultimate goal in this section is to construct new coordinates where the two classes can be linearly separated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 180,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.2. Defining the Quantum Kernel\n",
+    "\n",
+    "We proceed with the same kernel setup as it was in the classification task, namely a `ZZFeatureMap` circuit as a feature map and an instance of `FidelityQuantumKernel`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 181,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement=\"linear\")\n",
+    "qpca_kernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=feature_map)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, we evaluate kernel matrices for the training and test features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 182,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "matrix_train = qpca_kernel.evaluate(x_vec=train_features)\n",
+    "matrix_test = qpca_kernel.evaluate(x_vec=test_features, y_vec=test_features)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.3. Comparison of Kernel PCA on gaussian and quantum kernel\n",
+    "\n",
+    "In this section we use the `KernelPCA` implementation from `scikit-learn`, with the `kernel` parameter set to \"rbf\" for a gaussian kernel and \"precomputed\" for a quantum kernel. The former is very popular in classical machine learning models, whereas the latter allows using a quantum kernel defined as `qpca_kernel`.\n",
+    "\n",
+    "One can observe that the gaussian kernel based Kernel PCA model fails to make the dataset linearly separable, while the quantum kernel succeeds.\n",
+    "\n",
+    "While usually PCA is used to reduce the number of features in a dataset, or in other words to reduce dimensionality of a dataset, we don't do that here. Rather we keep the number of dimensions and employ the kernel PCA, mostly for visualization purposes, to show that classification on the transformed dataset becomes easily tractable by linear methods, like logistic regression. We use this method to separate two classes in the principal component space with a `LogisticRegression` model from `scikit-learn`. As usual we train it by calling the `fit` method on the training dataset and evaluate the model for accuracy with `score`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 183,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.decomposition import KernelPCA\n",
+    "\n",
+    "kernel_pca_rbf = KernelPCA(n_components=2, kernel=\"rbf\")\n",
+    "kernel_pca_rbf.fit(train_features)\n",
+    "train_features_rbf = kernel_pca_rbf.transform(train_features)\n",
+    "test_features_rbf = kernel_pca_rbf.transform(test_features)\n",
+    "\n",
+    "kernel_pca_q = KernelPCA(n_components=2, kernel=\"precomputed\")\n",
+    "train_features_q = kernel_pca_q.fit_transform(matrix_train)\n",
+    "test_features_q = kernel_pca_q.fit_transform(matrix_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we train and score a model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 184,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Logistic regression score: 0.05\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.linear_model import LogisticRegression\n",
+    "\n",
+    "logistic_regression = LogisticRegression()\n",
+    "logistic_regression.fit(train_features_q, train_labels)\n",
+    "\n",
+    "logistic_score = logistic_regression.score(test_features_q, test_labels)\n",
+    "print(f\"Logistic regression score: {logistic_score}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's plot the results. First, we plot the transformed dataset we get with the quantum kernel. On the same plot we also add model results. Then, we plot the transformed dataset we get with the gaussian kernel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 185,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, (q_ax, rbf_ax) = plt.subplots(1, 2, figsize=(10, 5))\n",
+    "\n",
+    "\n",
+    "plot_features(q_ax, train_features_q, train_labels, 0, \"s\", \"w\", \"b\", \"A train\")\n",
+    "plot_features(q_ax, train_features_q, train_labels, 1, \"o\", \"w\", \"r\", \"B train\")\n",
+    "\n",
+    "plot_features(q_ax, test_features_q, test_labels, 0, \"s\", \"b\", \"w\", \"A test\")\n",
+    "plot_features(q_ax, test_features_q, test_labels, 1, \"o\", \"r\", \"w\", \"A test\")\n",
+    "\n",
+    "q_ax.set_ylabel(\"Principal component #1\")\n",
+    "q_ax.set_xlabel(\"Principal component #0\")\n",
+    "q_ax.set_title(\"Projection of training and test data\\n using KPCA with Quantum Kernel\")\n",
+    "\n",
+    "# Plotting the linear separation\n",
+    "h = 0.01  # step size in the mesh\n",
+    "\n",
+    "# create a mesh to plot in\n",
+    "x_min, x_max = train_features_q[:, 0].min() - 1, train_features_q[:, 0].max() + 1\n",
+    "y_min, y_max = train_features_q[:, 1].min() - 1, train_features_q[:, 1].max() + 1\n",
+    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n",
+    "\n",
+    "predictions = logistic_regression.predict(np.c_[xx.ravel(), yy.ravel()])\n",
+    "\n",
+    "# Put the result into a color plot\n",
+    "predictions = predictions.reshape(xx.shape)\n",
+    "q_ax.contourf(xx, yy, predictions, cmap=plt.cm.RdBu, alpha=0.2)\n",
+    "\n",
+    "plot_features(rbf_ax, train_features_rbf, train_labels, 0, \"s\", \"w\", \"b\", \"A train\")\n",
+    "plot_features(rbf_ax, train_features_rbf, train_labels, 1, \"o\", \"w\", \"r\", \"B train\")\n",
+    "plot_features(rbf_ax, test_features_rbf, test_labels, 0, \"s\", \"b\", \"w\", \"A test\")\n",
+    "plot_features(rbf_ax, test_features_rbf, test_labels, 1, \"o\", \"r\", \"w\", \"A test\")\n",
+    "\n",
+    "rbf_ax.set_ylabel(\"Principal component #1\")\n",
+    "rbf_ax.set_xlabel(\"Principal component #0\")\n",
+    "rbf_ax.set_title(\"Projection of training data\\n using KernelPCA\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, the data points on the right figure are not separable, but they are on the left figure, hence in case of quantum kernel we can apply linear models on the transformed dataset and this is why SVM classifier works perfectly well on the _ad hoc_ dataset as we saw in the [classification section](#2.-Classification)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Conclusion\n",
+    "\n",
+    "In this tutorial:\n",
+    "\n",
+    "* We reviewed the fundamentals of quantum kernel learning\n",
+    "* We understood how to define quantum kernels as instances of `FidelityQuantumKernel`\n",
+    "* We learned how to use the `scikit-learn` `SVC` algorithm with a custom quantum kernel as a callable function vs precomputed quantum kernel matrix for classification\n",
+    "* We learned how to train classifiers with the `QSVC` algorithm from `qiskit-machine-learning`\n",
+    "* We learned how to use the `scikit-learn` `SpectralClustering` algorithms with a precomputed quantum kernel matrix for clustering\n",
+    "* We investigated how to plug in a quantum kernel into `scikit-learn`'s `KernelPCA` algorithm and transform the ad-hoc dataset into a new one that can be tackled by a linear model."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For further reference, `scikit-learn` has other algorithms that can use a precomputed kernel matrix, such as:\n",
+    "\n",
+    "- [Agglomerative clustering](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AgglomerativeClustering.html)\n",
+    "- [Support vector regression](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html)\n",
+    "- [Ridge regression](https://scikit-learn.org/stable/modules/generated/sklearn.kernel_ridge.KernelRidge.html)\n",
+    "- [Gaussian process regression](https://scikit-learn.org/stable/modules/gaussian_process.html)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 186,
+   "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.14303207397461</td></tr><tr><td colspan='2'>Tue Oct 03 21:31:30 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": {
+     "01d066c1f1c54c6c8cfb7842f68b10a6": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_87dbae66a3634ce9a17e663132e049af",
+       "style": "IPY_MODEL_02a2f339bd9145feb46db29329c08d1d",
+       "value": "<h5>Queue</h5>"
+      }
+     },
+     "02a2f339bd9145feb46db29329c08d1d": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "0eede61492c84361a1162a251e9748ed": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "4307f7cfa8754e28aede069c72cecc43": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_aa639da14ee24fb6b017115d2c7d102c",
+       "style": "IPY_MODEL_d8838e34cdaf45e1b5d77c5a7035b4e1",
+       "value": "<p style='font-family: IBM Plex Sans, Arial, Helvetica, sans-serif; font-size: 20px; font-weight: medium;'>Circuit Properties</p>"
+      }
+     },
+     "4aeec806743247e8a17287ee5a25494a": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_aee57f277cdf4edfb3617e7224f7933b",
+       "style": "IPY_MODEL_0eede61492c84361a1162a251e9748ed",
+       "value": "<h5>Message</h5>"
+      }
+     },
+     "568e3882e1a14cfaabb25e8c0e381599": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "ButtonModel",
+      "state": {
+       "button_style": "primary",
+       "description": "Clear",
+       "layout": "IPY_MODEL_56b5c9b59ddc4ec7820139770c33929f",
+       "style": "IPY_MODEL_805dc61de96b42b480a3b71dccea1c63",
+       "tooltip": null
+      }
+     },
+     "56b5c9b59ddc4ec7820139770c33929f": {
+      "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"
+      }
+     },
+     "662bd9ab875446a38b40fd53e41a7a95": {
+      "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%"
+      }
+     },
+     "7729f5d6c8a0479e9450127f73dee66a": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_ae9088c42d7a426aaa942c8b10e8070c",
+       "style": "IPY_MODEL_98bc89a17b254b5180657f8b616321f2",
+       "value": "<h5>Job ID</h5>"
+      }
+     },
+     "7e39e325220040478aed085939ceb13c": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_7729f5d6c8a0479e9450127f73dee66a",
+        "IPY_MODEL_88a43a8aab17497b988d98fe58011310",
+        "IPY_MODEL_bf977d5fba7f40149adeed029aca024b",
+        "IPY_MODEL_01d066c1f1c54c6c8cfb7842f68b10a6",
+        "IPY_MODEL_4aeec806743247e8a17287ee5a25494a"
+       ],
+       "layout": "IPY_MODEL_e9929efdf3d948f284c88be52b7683f0"
+      }
+     },
+     "805dc61de96b42b480a3b71dccea1c63": {
+      "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
+      }
+     },
+     "87dbae66a3634ce9a17e663132e049af": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "70px"
+      }
+     },
+     "881d7fb7653143b886d3fe7d452946f3": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "145px"
+      }
+     },
+     "88a43a8aab17497b988d98fe58011310": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_881d7fb7653143b886d3fe7d452946f3",
+       "style": "IPY_MODEL_d13264c6c07d44299ac4a6f8d67b22a9",
+       "value": "<h5>Backend</h5>"
+      }
+     },
+     "9288ad31da9341a79b2c28f4da1fb995": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "95px"
+      }
+     },
+     "98bc89a17b254b5180657f8b616321f2": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "9bbd7caa4133469c97d1810d18c52541": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "aa639da14ee24fb6b017115d2c7d102c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 10px 0px"
+      }
+     },
+     "ae9088c42d7a426aaa942c8b10e8070c": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "width": "190px"
+      }
+     },
+     "aee57f277cdf4edfb3617e7224f7933b": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {}
+     },
+     "bf977d5fba7f40149adeed029aca024b": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLModel",
+      "state": {
+       "layout": "IPY_MODEL_9288ad31da9341a79b2c28f4da1fb995",
+       "style": "IPY_MODEL_9bbd7caa4133469c97d1810d18c52541",
+       "value": "<h5>Status</h5>"
+      }
+     },
+     "d13264c6c07d44299ac4a6f8d67b22a9": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "d8838e34cdaf45e1b5d77c5a7035b4e1": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "HTMLStyleModel",
+      "state": {
+       "description_width": "",
+       "font_size": null,
+       "text_color": null
+      }
+     },
+     "e9929efdf3d948f284c88be52b7683f0": {
+      "model_module": "@jupyter-widgets/base",
+      "model_module_version": "2.0.0",
+      "model_name": "LayoutModel",
+      "state": {
+       "margin": "0px 0px 0px 37px",
+       "width": "600px"
+      }
+     },
+     "efd0a78a618741649620bdff3b084938": {
+      "model_module": "@jupyter-widgets/controls",
+      "model_module_version": "2.0.0",
+      "model_name": "GridBoxModel",
+      "state": {
+       "children": [
+        "IPY_MODEL_568e3882e1a14cfaabb25e8c0e381599"
+       ],
+       "layout": "IPY_MODEL_662bd9ab875446a38b40fd53e41a7a95"
+      }
+     }
+    },
+    "version_major": 2,
+    "version_minor": 0
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}