Switch to side-by-side view

--- a
+++ b/Code/All PennyLane QML Demos/37 Data-Reuploading 89.4% kkawchak.ipynb
@@ -0,0 +1,639 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "id": "bPJ9-Bl6wup5"
+      },
+      "outputs": [],
+      "source": [
+        "# This cell is added by sphinx-gallery\n",
+        "# It can be customized to whatever you like\n",
+        "%matplotlib inline\n",
+        "# !pip install pennylane"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "X6qyuFCrwup7"
+      },
+      "source": [
+        "Data-reuploading classifier {#data_reuploading_classifier}\n",
+        "===========================\n",
+        "\n",
+        "::: {.meta}\n",
+        ":property=\\\"og:description\\\": Implement a single-qubit universal quantum\n",
+        "classifier using PennyLane. :property=\\\"og:image\\\":\n",
+        "<https://pennylane.ai/qml/_images/universal_dnn1.png>\n",
+        ":::\n",
+        "\n",
+        "::: {.related}\n",
+        "tutorial\\_variational\\_classifier Variational classifier\n",
+        "tutorial\\_multiclass\\_classification Multiclass margin classifier\n",
+        "tutorial\\_expressivity\\_fourier\\_series Quantum models as Fourier series\n",
+        ":::\n",
+        "\n",
+        "*Author: Shahnawaz Ahmed --- Posted: 11 October 2019. Last updated: 19\n",
+        "January 2021.*\n",
+        "\n",
+        "A single-qubit quantum circuit which can implement arbitrary unitary\n",
+        "operations can be used as a universal classifier much like a single\n",
+        "hidden-layered Neural Network. As surprising as it sounds,\n",
+        "[Pérez-Salinas et al. (2019)](https://arxiv.org/abs/1907.02085) discuss\n",
+        "this with their idea of \\'data reuploading\\'. It is possible to load a\n",
+        "single qubit with arbitrary dimensional data and then use it as a\n",
+        "universal classifier.\n",
+        "\n",
+        "In this example, we will implement this idea with Pennylane - a python\n",
+        "based tool for quantum machine learning, automatic differentiation, and\n",
+        "optimization of hybrid quantum-classical computations.\n",
+        "\n",
+        "Background\n",
+        "----------\n",
+        "\n",
+        "We consider a simple classification problem and will train a\n",
+        "single-qubit variational quantum circuit to achieve this goal. The data\n",
+        "is generated as a set of random points in a plane $(x_1, x_2)$ and\n",
+        "labeled as 1 (blue) or 0 (red) depending on whether they lie inside or\n",
+        "outside a circle. The goal is to train a quantum circuit to predict the\n",
+        "label (red or blue) given an input point\\'s coordinate.\n",
+        "\n",
+        "![](../demonstrations/data_reuploading/universal_circles.png)\n",
+        "\n",
+        "### Transforming quantum states using unitary operations\n",
+        "\n",
+        "A single-qubit quantum state is characterized by a two-dimensional state\n",
+        "vector and can be visualized as a point in the so-called Bloch sphere.\n",
+        "Instead of just being a 0 (up) or 1 (down), it can exist in a\n",
+        "superposition with say 30% chance of being in the $|0 \\rangle$ and 70%\n",
+        "chance of being in the $|1 \\rangle$ state. This is represented by a\n",
+        "state vector\n",
+        "$|\\psi \\rangle = \\sqrt{0.3}|0 \\rangle + \\sqrt{0.7}|1 \\rangle$ -the\n",
+        "probability \\\"amplitude\\\" of the quantum state. In general we can take a\n",
+        "vector $(\\alpha, \\beta)$ to represent the probabilities of a qubit being\n",
+        "in a particular state and visualize it on the Bloch sphere as an arrow.\n",
+        "\n",
+        "![](../demonstrations/data_reuploading/universal_bloch.png)\n",
+        "\n",
+        "### Data loading using unitaries\n",
+        "\n",
+        "In order to load data onto a single qubit, we use a unitary operation\n",
+        "$U(x_1, x_2, x_3)$ which is just a parameterized matrix multiplication\n",
+        "representing the rotation of the state vector in the Bloch sphere. E.g.,\n",
+        "to load $(x_1, x_2)$ into the qubit, we just start from some initial\n",
+        "state vector, $|0 \\rangle$, apply the unitary operation $U(x_1, x_2, 0)$\n",
+        "and end up at a new point on the Bloch sphere. Here we have padded 0\n",
+        "since our data is only 2D. Pérez-Salinas et al. (2019) discuss how to\n",
+        "load a higher dimensional data point ($[x_1, x_2, x_3, x_4, x_5, x_6]$)\n",
+        "by breaking it down in sets of three parameters\n",
+        "($U(x_1, x_2, x_3), U(x_4, x_5, x_6)$).\n",
+        "\n",
+        "### Model parameters with data re-uploading\n",
+        "\n",
+        "Once we load the data onto the quantum circuit, we want to have some\n",
+        "trainable nonlinear model similar to a neural network as well as a way\n",
+        "of learning the weights of the model from data. This is again done with\n",
+        "unitaries, $U(\\theta_1, \\theta_2, \\theta_3)$, such that we load the data\n",
+        "first and then apply the weights to form a single layer\n",
+        "$L(\\vec \\theta, \\vec x) = U(\\vec \\theta)U(\\vec x)$. In principle, this\n",
+        "is just application of two matrix multiplications on an input vector\n",
+        "initialized to some value. In order to increase the number of trainable\n",
+        "parameters (similar to increasing neurons in a single layer of a neural\n",
+        "network), we can reapply this layer again and again with new sets of\n",
+        "weights,\n",
+        "$L(\\vec \\theta_1, \\vec x) L(\\vec \\theta_2, , \\vec x) ... L(\\vec \\theta_L, \\vec x)$\n",
+        "for $L$ layers. The quantum circuit would look like the following:\n",
+        "\n",
+        "![](../demonstrations/data_reuploading/universal_layers.png)\n",
+        "\n",
+        "### The cost function and \\\"nonlinear collapse\\\"\n",
+        "\n",
+        "So far, we have only performed linear operations (matrix\n",
+        "multiplications) and we know that we need to have some nonlinear\n",
+        "squashing similar to activation functions in neural networks to really\n",
+        "make a universal classifier (Cybenko 1989). Here is where things gets a\n",
+        "bit quantum. After the application of the layers, we will end up at some\n",
+        "point on the Bloch sphere due to the sequence of unitaries implementing\n",
+        "rotations of the input. These are still just linear transformations of\n",
+        "the input state. Now, the output of the model should be a class label\n",
+        "which can be encoded as fixed vectors (Blue = $[1, 0]$, Red = $[0, 1]$)\n",
+        "on the Bloch sphere. We want to end up at either of them after\n",
+        "transforming our input state through alternate applications of data\n",
+        "layer and weights.\n",
+        "\n",
+        "We can use the idea of the \\\"collapse\\\" of our quantum state into one or\n",
+        "other class. This happens when we measure the quantum state which leads\n",
+        "to its projection as either the state 0 or 1. We can compute the\n",
+        "fidelity (or closeness) of the output state to the class label making\n",
+        "the output state jump to either $| 0 \\rangle$ or $|1\\rangle$. By\n",
+        "repeating this process several times, we can compute the probability or\n",
+        "overlap of our output to both labels and assign a class based on the\n",
+        "label our output has a higher overlap. This is much like having a set of\n",
+        "output neurons and selecting the one which has the highest value as the\n",
+        "label.\n",
+        "\n",
+        "We can encode the output label as a particular quantum state that we\n",
+        "want to end up in and use Pennylane to find the probability of ending up\n",
+        "in that state after running the circuit. We construct an observable\n",
+        "corresponding to the output label using the\n",
+        "[Hermitian](https://pennylane.readthedocs.io/en/latest/code/ops/qubit.html#pennylane.ops.qubit.Hermitian)\n",
+        "operator. The expectation value of the observable gives the overlap or\n",
+        "fidelity. We can then define the cost function as the sum of the\n",
+        "fidelities for all the data points after passing through the circuit and\n",
+        "optimize the parameters $(\\vec \\theta)$ to minimize the cost.\n",
+        "\n",
+        "$$\\texttt{Cost} = \\sum_{\\texttt{data points}} (1 - \\texttt{fidelity}(\\psi_{\\texttt{output}}(\\vec x, \\vec \\theta), \\psi_{\\texttt{label}}))$$\n",
+        "\n",
+        "Now, we can use our favorite optimizer to maximize the sum of the\n",
+        "fidelities over all data points (or batches of datapoints) and find the\n",
+        "optimal weights for classification. Gradient-based optimizers such as\n",
+        "Adam (Kingma et. al., 2014) can be used if we have a good model of the\n",
+        "circuit and how noise might affect it. Or, we can use some gradient-free\n",
+        "method such as L-BFGS (Liu, Dong C., and Nocedal, J., 1989) to evaluate\n",
+        "the gradient and find the optimal weights where we can treat the quantum\n",
+        "circuit as a black-box and the gradients are computed numerically using\n",
+        "a fixed number of function evaluations and iterations. The L-BFGS method\n",
+        "can be used with the PyTorch interface for Pennylane.\n",
+        "\n",
+        "### Multiple qubits, entanglement and Deep Neural Networks\n",
+        "\n",
+        "The Universal Approximation Theorem declares that a neural network with\n",
+        "two or more hidden layers can serve as a universal function\n",
+        "approximator. Recently, we have witnessed remarkable progress of\n",
+        "learning algorithms using Deep Neural Networks.\n",
+        "\n",
+        "Pérez-Salinas et al. (2019) make a connection to Deep Neural Networks by\n",
+        "describing that in their approach the \\\"layers\\\"\n",
+        "$L_i(\\vec \\theta_i, \\vec x )$ are analogous to the size of the\n",
+        "intermediate hidden layer of a neural network. And the concept of deep\n",
+        "(multiple layers of the neural network) relates to the number of qubits.\n",
+        "So, multiple qubits with entanglement between them could provide some\n",
+        "quantum advantage over classical neural networks. But here, we will only\n",
+        "implement a single qubit classifier.\n",
+        "\n",
+        "![](../demonstrations/data_reuploading/universal_dnn.png)\n",
+        "\n",
+        "\\\"Talk is cheap. Show me the code.\\\" - Linus Torvalds\n",
+        "-----------------------------------------------------\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 388
+        },
+        "id": "RJadEWtGwup9",
+        "outputId": "2c5c00da-ba87-4cf7-c393-8a8878e62acb"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 400x400 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAFzCAYAAAAUmo/dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABotklEQVR4nO29f3gU1b0//s5EsmAhuxDSRFCoyA+tWuIKQfrZZDWAobFFe1ut4MWoLbReqfVaqdinyCdefaDCt7VFLJIHgRYvrPaKeC0QKgUVhRABRQGzEKhGBPyYlIAKKOH9/WN3NrO78+PMzDlnzizn9Tz7QGZnZ86cOef9ev8675OHiAgSEhISEhIOoXjdAAkJCQkJf0MSiYSEhISEK0gikZCQkJBwBUkkEhISEhKuIIlEQkJCQsIVJJFISEhISLiCJBIJCQkJCVc4z+sG5ALOnj0LH3/8MfTq1Qvy8vK8bo6EhISEayAinDhxAvr16weKYm5zSCKhgI8//hguuugir5shISEhQR2tra1w4YUXmp4jiYQCevXqBQCJDi8sLPS4NRISEhLucfz4cbjoootS8s0MkkgoQHVnFRYWSiKRkJDIKZC462WwXUJCQkLCFSSRSEhISEi4giQSCQkJCQlXkEQiISEhIeEKkkgkJCQkJFxBEomEhISEhCtIIpGQkJCQcAVfEclrr70G3/ve96Bfv36Ql5cHL774ouVvNm3aBOFwGAKBAAwePBiWLl2adc6CBQvgG9/4BnTv3h1GjRoF27Zto994CQkJXyAej8PatWth3759XjfFN/AVkXz++ecwfPhwWLBgAdH5Bw8ehBtuuAGuu+46ePvtt+G+++6Dn/zkJ9DQ0JA6JxaLwf333w+zZs2CHTt2wPDhw6G6uho++eQTVo/BBXIySEjYQ3t7O9wwfjwMGzYMampqYOjQoXDD+PHwr3/9y+umiQ/0KQAAV61aZXrOr371K7z88svTjv3oRz/C6urq1N/l5eV4zz33pP7u7OzEfv364ezZs4nb0tHRgQCAHR0dxL9hhba2NqyprkYASH1qqquxvb3d66ZJcEBzczOuWbMG4/G4103xHWqqq7FPfj4uB8APAXA5APbJz8cajbw4l2BHrvnKIrGLLVu2wNixY9OOVVdXw5YtWwAA4Msvv4Tt27ennaMoCowdOzZ1jh5Onz4Nx48fT/t4hUzLY/KkSbD1lVdgOQB8CADLAWDrK6/Av0+c6FkbJdiDlzadq5ZuPB6HNQ0N8MfOTrgNAC4CgNsA4A+dnbCmoSHnnpc2cppIjhw5AiUlJWnHSkpK4Pjx43Dy5En49NNPobOzU/ecI0eOGF539uzZEAwGUx8vKv/qCY7yESPkZHABPwtJ1gpErrt9WlpaAACgMuN4NPnv/v37ubbHCbwcvzlNJKzw0EMPQUdHR+rT2trKvQ16gmP39u0A4O/J4AVoCEkvJzEPbTrXLd1LLrkEAABeyzj+avLfwYMHc22PHYhA8jlNJKWlpXD06NG0Y0ePHoXCwkLo0aMH9O3bF/Lz83XPKS0tNbxuIBBIVfr1ouKvkeD4v8nv/TgZvIQbIel2EtMgINba9Lng9hk6dCjUVFfDvfn5sBwAWiExDn6Rnw811dUwZMgQj1toDCFInkPMhgmAMNh+xRVXpB2bOHFiVrB92rRpqb87Ozuxf//+Qgfb16xZg5AMCKLm8yEAKgAYAsC/JP/+CwD2Th6XAdhsNDc3IyQDq9q+/EsyUcGqz5wGaGkmRbh9BiuYjTcAwDVr1ri6vh2wTCZob2/3XaIKy3dvR675ikhOnDiBO3fuxJ07dyIA4O9+9zvcuXMnfvDBB4iIOGPGDJw8eXLq/AMHDuD555+P06dPx7179+KCBQswPz8f161blzpn5cqVGAgEcOnSpbhnzx6cOnUqhkIhPHLkCHG7eBOJ1eC5RjMRAACrPJjwfoEbIelmEtPOEFKvp1UgaGUcsSYqEvDMRozH477JfGNJ8jlLJBs3bkwbSOqntrYWERFra2sxGo1m/aasrAwLCgpw0KBBuGTJkqzrzp8/HwcMGIAFBQVYXl6OW7dutdUut0Si1bJINS5dwZG0PJYDYBwA1yT/5Tnh/QYrIRmNRAyFldNJzEIws9amWRKVnfvL1Nx0SIskh+CUSPS0LIVQEOgJjjIArICEK8urCe9HGJFymUXfWU3ihoYGXaWApRbJSpv20u0jgkUk8vocViQviYQznBKJnpbVGxKuqekAGFQUy8EQj8cxFothNBLRJSPWE97JBBNtUra3t6f1HwBgDQC2Ewgro0lcUlRk+A5EEIxO4YXbx8sYjR8W+LIieUkknOGESKyEiZYUmpqaiK6pneSsJ7yTCSbypFSF1TJIuANJhZXeJC4pKsKQopi6Ybx2FfkJXhKvn1xqtOe8JBLOcEIkVlrWsuSgDQLgyHCYYeudwckEE3lSuhVW6iRuaGgguo4fM4S8hBfEK4rl6JUFL4mEM1hYJHGPBi0JnEwwryalnUloJKxGhsPE7bPrhvFThpCX8IJ47b5L2gLfawteEglnuI2RZAZ5a2y4VrzQVpz4rFn6ufX6wMkk1BNWpMkP2rY4IVlJJmTgQbzq+yC1LlkJfK8teEkknOGUSIwyr9oJBJCX2oooFolZH7iZhPF4HEeEwxi0iHMYgdQN47XGeS7ADknrvY+SoiLLdzn2uuswoPkNAGAAAMdVVblqt9duNUkknOF2HYmqZUUjEWI/MA1txY0m7MRnTdvPbdQHagaW00nodhKTumG81jhzGU5IWu99hBTFMgNPgUS2ZWb2pZtqEiJUE5BEwhm0VraTCiC3go6GJuzEZ03Tz02S9eZ0EtKaxGZuGBE0Tp7g7b6zS9JW72P9+vW67V+0aJHp7+rr6x21X4TxIYmEM2iXSLHyA7sVdDQ1YSc+axp+bqs+8NIiodH+XCln44X7zsn7c/o+VCIx+p1TIkH0PkVcEgln0CASOxqbG0EngqZDAySlTawmoTaomtn3rCdxrrwHK3jhvnNCCk7fB8v36HWKuCQSznBDJE41NqeCzuuURpow6wOzSajtc6MqADwmsdcaJ2t4mfLt5L5O38e4qioM5eWl/S6Ul+cq2K4+x5o1awzdaqwhiYQz3BCJU43NqaAjnWR+yCgi6QM9N5ra52WQSLc263uW6aZea5wkcKNIOLUMaPS3E1Jw+j5ov0dR5p4kEs5wSiQ0NDYngi5zkj0OgD0VBaORSNY5fsgostMHap/PBXdxFJpgQVZuBTINYWZnfNMWnm6Eu9P3of0djYxIr+eeJBLOcEokmRpbMyRKv79qorHRgHaS6bl2tm3bRiwARHZ96UFbUysXg920BDItYUZqGbASnrwrB7jtf5FiZ5JIOMOtRbIQEqvZtYPPTrFGp4hWVGBvnUV3I8NhSyErivltFyJaJDRBa30Rrb4hsQxEEp5uEY1EdOcUaf+LlM0niYQz3MZIApC9oCmUl4fRSISZNkWyDsNsYotifjtBZowkV4LdtAQyC2FmZhmIJDydoq2tDStdLoRFFItUJZFwhhsisXIjsdL2rSbviHDY0CVhNdhZW1JuYeXao9HPfqmBpgfewkwk4ekUNdXV2FNRqPQ/qTuQ9RiTRMIZboiEtJw8DU05c0tfs8n7xBNPZG/2lBSyJCTkB6haMs30Sr/VQNO7ht1yPTTg51Ro2u5SK3cgrzEmiYQz3BAJ63Lyzc3NiR0UKyqyBt64qqq0yfsngKzic9GKCozFYqn7Njc3W5aFsBOQp6FViRTw99rl51QgGxUs5EWIdsoDsXT3Orm2VrGqgWx3aW+CnU71YOQO5DXGJJFwhtuV7bqTH+yVk89E5qK7IGSvlxhXVZU2eRVIxGb0BmimoFGvmdnmKk07zTQnGloV6TV4EY1WM11DQQlwAqdpr0bCKVpRwZWkM4Wn+u62bdvGTAunmWnVDtmJM9GKClfttONJoPmeJJFwhlsiISkn/3jy+Pr164muqQoGK3O7oaEB6+vr8b/+679Mz1NdHcuTZNELdOILkMhAUwe0meZEQ6uyugZvN1MsFtPtk102lQAacLK2RqQYhd67CwDg0y7GixFojkVVsZoL2Wuz7EKvD6745jcRILFEQPuuWCQmSCLhDFpFG/XKye9KkoodYagVDGtAf73ELh0iMIt7qNdr1vy/BhJWyQPJgW0nIE/Dl291Dd5upmgkkm35ad6fXk0vESBi1pTeu+sN6VY6DaKjRaIsqhRo+0BXDkCXsiktkhwA7eq/mVlFWcLJQhhqBYNW8GsnSlnGda0sF/V6WmLSM+NHhsNEAXm3gsvq+lZxHN6ZR71D6fGG6uoaYdbciGaRkMYNaRAdbRKltQAysw/U2EsmsVYBu8QESSScQZtIVJBu9ZkJo0GoLYliRi6ZgVrtRlF6xBSHhFWibZPXFkl9fT1XLdtcICmoKL0RYDkCfIgAyzE/vw9WV9dQbYMbiJQ1ZSncKRKdaCSqgkQZ1M4lmbWVA2BFJG60Ja1g0DOLSd1d6gDVXq8KEtoQadkLvfNoCC6za7gpC+5EozS63+OpvlyO6V/9xVNBlQk3RUBZ1Akze3eZblS37RKJRBGzMyON3NOqHHCz54kZcp5InnzySRw4cCAGAgEsLy/HxsZGw3Oj0WiWAAUArKnp0gZra2uzvq+2MYhoEUnm4HejLekJhmgkgrFYzNLS0VtXkXk9koV8ZsKJhk/Z6hp2BASNwLze/dRFaglLRNvdHzKxjNyC1DXT1taG1dU1af0VDo+kthhVry9DeXlp407v/Th5j6JUYTZKMKgD9xa8E+Q0kaxcuRILCgrwmWeewd27d+OUKVMwFArh0aNHdc9va2vDw4cPpz7vvfce5ufn45IlS1Ln1NbW4vjx49POszOI3BKJ2eB3qy1Z5aLbva72eqRCx+w8Nz5lq/0a7AgIGoF5vftVphZ1im2R2EV1dQ3m5/dBrbsOIIgACpX4j9G7a2pqMh0vbt4j7wKPmdBru0qeuun2jK2mnCaS8vJyvOeee1J/d3Z2Yr9+/XD27NlEv//973+PvXr1ws8++yx1rLa2Fm+88UbiNpw6dQo7OjpSn9bWVldEYjb4jSbU888/j3V1dcTpwJkQRQtzArtap5WAoO0nz7xfl9D9S1Lo/kW4GIkdqP1lRI6KEqT2bH5PYyaFXtuboSv2+MQTT+guKm5vb2e2TipnieT06dOYn5+Pq1atSjt+++2344QJE4iuccUVV+CUKVPSjtXW1mIwGMTi4mIcOnQo/uxnP8NPP/3U8BqzZs3KcoU5JRLSwa9OqL///e9ZK45LiorwwIEDtu+tva7IkywTtNN6Wae/tre3Z7mBRMrasgu1v4zcdQAPeCK4ab5H3tUStG1vA+NsSO18Zb1OKmeJ5NChQwgA+Oabb6Ydnz59OpaXl1v+vrGxEQEgK6ayYsUKXL16Ne7atQtXrVqFl112GY4cORLPnDmjex2aFondwV9SVJSVDhxMksm5ABZaJy9N1o+krQcriwTgVSoE7LRdbt6jV7XStG3XS/XluYeLCkkkBpg6dSpeeeWVlue1tLQgAOArr7xC1C6mtbY0g3/dunWm5zp1c/kJrKwH0TJ3zCBCbTE9dx1AHwSoQVbxH5LndvseeS9izbx3MJmcYSUPeCg/OUskblxbn332GRYWFuITTzxBdK++ffviwoULic5lUmtLZ/DW1dWZCtG6ujpH9/cTWE0gP8SM9DKlVBcZb3LRc9cBVCHAQurxHztWgpv36HWMpb29HUcQbCqHyKcaQc4SCWIi2D5t2rTU352dndi/f3/LYPuSJUswEAiYxj5UtLa2Yl5eHq5evZqoTSxqbekNfloWiQgarRuwtB5Edj/pZUopSgiLikp0yYUHmpqaMBwekXX/bdu2UetHJ1aCk/coQqkYUjJT3fTSInGIlStXYiAQwKVLl+KePXtw6tSpGAqF8MiRI4iIOHnyZJwxY0bW7yKRCP7oRz/KOn7ixAl84IEHcMuWLXjw4EF85ZVXMBwO45AhQ/DUqVNEbaJda8tsEKgxEq0QDQJZjMSv2+Nmwg/WA20YxyXKMJF26+2qeXXsbtu2jWpiAU8rwWuLRAWJolRT3bWzauZaGxkjIcT8+fNxwIABWFBQgOXl5bh169bUd9FoFGtra9POf//99w019i+++AKvv/56LC4uxm7duuHAgQNxypQpKWIiAauV7Xo4cOCA46wtL/2/LCCy9UAb+plS5kFv0n6haaHqWU1uiI23lSBCrMxKUVIJ72nIzu5SgN4OpTlPJKKBJ5GoWL9+va11JKJoWxLOoG+RmKfhWglZs5gLvTa6W3zJe9yKZO0aKUoque4yIJJYLEZFOZBEwhleEAkJtIPJjmbn9xhKriI7U+pxV4KblfVAuxyMF1aCyNauSq5lkJ0m3AsA+4ZCVIhQEglniEYkerGQSk0FXyPNLldiKLkKvUypoqISR6vmWVoPXddsTlpNc11ZDyJZCaLAaD6Xgf1tJ4wgiYQzRCMSo1hISVGRqWaXazGUXEVDQ0PKrel01Twr66G6ugYVJYSJJIB0wnMr+EW2EngjFotleRisys3b7TdJJJwhApGo7iiryr5m9XpkDEVsmMU07ApZFhYJYsJ6SKQje59J5hc4cSXrzVercvN2lQNJJJzhJZHouaMUSATijAaTntARIYcekW98xm+xINoxDRbFJFkRVC7CrSs5M3ZktGGdtEh8AqdEQkOQ6bmjgklfqZ3BRGqRsBK+POMzbrOVvCAgFgKaRTFJVi6zXIRbV7Je7MjKfW0Hkkg4wy6R0BKaVsJ/rs3BZJYdw1rQ047PmAl7p5o97XRZO2ApoGnGHqRFQgaarmTt+6OZmCCJhDPsEgktoWnljrI7mMwGIctAPM1JpSfsI5FKjMViGI/HHQk6lZQqKqJUXUt24CcB7ef9V3hZm1Zzd9GiRUTtMGovDeVAEgln2OlwmkLT6lpGOwdaIXMQsg7E04zPpFsbuzAze6irLpS1Zq9HSl4Kcr8IaK/2X3FDArxT363mlFU7eLRXEgln2Olw2kFtVou1nC5mdHovGkSVrbXXYKK0ubbIYZCYENJJaRkxAbGC3zbIYp2uq45RGvW9vEh915u7obw8DID3e5EgSiLhDtYWiZmmRXuxltPFjG5BgxDT4whmriDFUrPXX1wnhmvpXF9PkW0pKpiXF0KnLkfehSHN4hkKJGpombWDV3slkXCG0xiJldC0Y77SEi411dXYMy8PfwCAzwL5Yka3oEGI6cLfPDgdDo801WD1g9uqhSO2a8nvsHJRpVuKm1wTPI/Ud7O5rM7d+vp6onbwStWXRMIZdomEVGjyNrfXr1+P+Zo2AQCWAOD/B+aLGWnCLSF2CRnrOlRm99IPbrdjZsxFZNeS30CSFZf9Xpxns5Eu4uW1p4qdFHxpkeQgnK4jIRFkPFea9y4s1N0Pvlij6YjuVkmPIyiYWGHtzIIwCm5HIlGh+8CvIEnLzrYU7bsc9ayDkqIiDCkKE4vbzlwm9VbwKGQpiYQzWKxs573S3Gr3Rd5xALeIx+MYi8WwoiLq2IJgHdymkWrqt9X5RiBNb9Y/rwYBehMrDGa16FhY3HbmMqm3gkchS0kknMGCSHhbJFb7wQ+55BKq9+MJt1YUbSuMxsJGLxdHsoCdBZfZluJCBAgQ9QWrlHkzOJnLpGOOpYdAEglnsKq1xXMfBiuL5H/+53+o31N0sNL2adTMol13y2vYWXBpZCk2NTVZvi/eln5bWxtWRiKoQPa2uL0hkaUlqjUpiYQzWBEJ730Y3OwHn0tgqe3TWKHup1XudmB3waUTbZy3pV9TXY09FQUBAKs040n7N411WCwUHkkknMG6+i+vALeb/eD9BHvppXS1fRo1s6yuEQ6P8KWLi9eCS16Wvkpac5PPshwA45Ao9x6nQF6sV7dLIuEMEfYjoQm7+8H7Bc7SS+lq+zwsEkUJ+tbFhcheceJl6WvdaDWQ2BY3zbWlKK7Ii/XyAEkknJFrRIKYO9lAWjhLL7VvMZC3w/nCRr1rJBZL1gjv4hJlbPEo4aJaIu1JMtGSV7SiwjF58XDRSSLhjFwiklzdt53EEmhubsZFixYxjz/QcOG0t7dnrc5PkEg7VdKjiVzLNCNBphttLgD2VBSMRiKurssjaUASCWfkEpHk6r7tJHGFLgGn1m4itxicaNluNeIucpyOAHEmpEcTrDPNRLF0tGDlRpMWSQ4iV4gkl/dtJ4krdAm4p5F0XYLXWrZfSsun938zJkqbxKmQntfvgAQs3GhmSQM0SDXnieTJJ5/EgQMHYiAQwPLycmxsbDQ8d8mSJRnmP2AgEEg75+zZszhz5kwsLS3F7t2745gxY2y9AK+JhJYmJsq+7axgJHQTpVT0Caa+vt60X2lo2W7en19Ky3dZhFUZ87HK9diiZemIaNGYQc/aGXvddTiuKr2P5Q6JOli5ciUWFBTgM888g7t378YpU6ZgKBTCo0eP6p6/ZMkSLCwsxMOHD6c+R44cSTtnzpw5GAwG8cUXX8R33nkHJ0yYgBdffDGePHmSqE1eEQnteIYIFgmrydzc3KxbMqUrzuCs6J+beApNTZqWxsuy/xOE3TtN4Cf+Vii495zHtPxg0ZhB++5puqZzmkjKy8vxnnvuSf3d2dmJ/fr1w9mzZ+uev2TJEgwGg4bXO3v2LJaWluLcuXNTx44dO4aBQABXrFhB1CaviIRFPIPnanotWE1m/a13o6623lXhNsNLpNXprIUpq7RqGll2rN4DbwuHtiKYs0Ry+vRpzM/Px1WrVqUdv/3223HChAm6v1myZAnm5+fjgAED8MILL8QJEybge++9l/q+paUFAQB37tyZ9rvKykq89957da956tQp7OjoSH1aW1u5Ewkr64EkOMhigrCazCTXdRpnsBKOZm4x0VansyY1VmnVbvuRxXtgnfloNP9ou6ZzlkgOHTqEAIBvvvlm2vHp06djeXm57m/efPNNXLZsGe7cuRM3bdqE3/3ud7GwsBBbW1sREfGNN95AAMCPP/447Xc333wz3nLLLbrXnDVrVtogUT88iYR1PEPPVcJqgrASqqTXdRNnyCahPyFJoJ7HehVS8CA1lvdwk3DA4j2wyny0mn/SIiGEEyLJxJdffomXXHIJ/uY3v0FEZ0QigkViVWTRzqp0UguD1QRhJVTtXtdJnCGbhMi2fRXJIuFFanYFPum4dKMI0H4PLOOMJPOPpms6Z4nEiWtLDz/84Q/x1ltvRURnrq1MeBEjWbNmDSqQXXahDyQqipJMfjsWBssJopKiVxYJDcTjcduLGUVJ3eXVT6QC32m8xmnCAc33wMpToK3bpdbq0pt/NNet5CyRICaC7dOmTUv93dnZif379zcMtmfizJkzOGzYMPzP//xPROwKts+bNy91TkdHh/DBdnVglWkGjPZvkslkx8KwM0FINcnGxkbNQkB3uxkagaewtqvZi5S6y7OfrAQ+7yQEmu+BlcIVi8VQyZjrNQC4y4CgaGTx5TSRrFy5EgOBAC5duhT37NmDU6dOxVAolErpnTx5Ms6YMSN1fl1dHTY0NGBLSwtu374db731VuzevTvu3r07dc6cOXMwFArh6tWrcdeuXXjjjTf6Iv1XJYK5ALgsqa2QmrF2BzzJ+aSapN55ABUIcAV1ocpTWDvV7EXYvlgUUvPS5UfrPbDIfIxGIlnbYPexqTjaRU4TCSLi/PnzccCAAVhQUIDl5eW4devW1HfRaBRra2tTf993332pc0tKSrCmpgZ37NiRdj11QWJJSQkGAgEcM2YMNjc3E7fHKyJxY8Y6McGtJgipJql3XlfBwbloN8ZDAl7CWhR3lVN4TWoiJSE4Be2yKFZKnNu6XUbIeSIRDV6vbOe1wY/ZBHG353bXeQCv+kZg6EEUzT4Tflm1LVISglvQImUrpS8Wi1FqcTokkXCG10TiBG1tbbo7IpKY4HoThFSTtDoP4AHfCQw9eK3Zq6Cx0JA3CfndqqMNrypOSCLhDD8SSU11NYYUJStYX1JU5CrI6NYi8fumTKLBTeDaq9Iholp1XsKLihOSSDhDRCIx0yIzNRx1+091S1CnGg6pJqm/KVMQAZRzXmA4gdG7dusm8qKEi/ZZRLHqrMDDYuO1q6MWkkg4QyQiIVkbwirXnVST1DsvHB6JTU1Nrp79XIOVxeAmcM07VuHHwolebALHk1wlkXCGSERCsjaEdHGTU5AOdr9onKLCymLgVZCShkbuZQFL0vZnnsdjEzgvkyQkkXCGKERCGpRTA+1aTaoMAEOK4vudEM8F2NkSmFVBSjvrhkiex4tMLTfrniKRKNFcc9M2r7e8lkTCGaIQCanLSk+TCoLzQLsEH+gv5KzCxD7t+hZDS0sLFhWVpP2mqKgEDxw4YHk/KxKiZUV4tXbEzbonRUnso8KqaKoIW15LIuEMUYjEyiJZv369EJtXSTiD/kLO3phYyGllkcxDgGUIMI9Y2JvFvGhaEV5YJLSyDOcxmEeizFFJJJwhCpEg6qcJBgFSdXpGhMNEVovX8MsCOl4gW8j5F2oxEi3crBsiBe+1I7TWPfVUFOopuaJseS2JhDNEIhK9NMEySBR3Ww6AQUURQtsxgh+zd3jAeiEn/awtMyKnbUXwXjtCyyKJRiJpbaa5P4/Xc1QSCWeIRCQqGhoaDE1vJak58d5OlwQibT8rEpzsxuhE2NshchZWBM9MPjfrnrTnsWizV1teayGJhDNEJBIr8/jKb37TlSZFw/W0bt06rKurSxVozKU6SyzgRHDb/Y0dIvf7CnQ3655YP6cXCxAzIYmEM0QkEiPz+E8AWfsaRCsqiAcoDdfT/v37dTOJFi9e7NgVcy7AiUCz8xt9Im9Gq/pnfl8PJPK6Jy/7VhIJZ7glElaBZT3zOACQva+BDZOZhuspQSJBTM8+CmIo1FdaJARwIlxIfpMeU2nDRDZYevUBv1gbEu4hiYQznBIJ60VHeuaxmyAeDdeT1ba6I0aM1K3DVVRUIoUYY6S/3xpM7BHjfaxKZvB5A0kknOGUSHgtOopGIthTUfDHScJwmlZII+Wzrq7O9BozZszAPn2KM8hPQYACrKoaR6tLJAxQXV2DihIUwjKUGXzewo5cU0DCE8TjcVjT0AB/7OyE2wDgIgC4DQD+0NkJaxoaYN++fdTu8+rmzbDw7Fn4VfLYaxnnvJr8d/DgwabXuuSSS0yvYPV7AIBRo0aZXmPo0KHQ3t4GAIUAMD15/M8A8DX4xz82UOsXCX2sWLEcysqGJP+qzPg2CgAA+/fv59KWSZMmwyuvbAWA5QDwIQAsh1de2QoTJ/47l/tL2AAHYst5OLFIeC06yrxPDST2enaaVkgj5bMrRpLtvrKqIVVfX++0KyQIIUL2HM82SNeZPqRF4gOo2r1T68DpfZYDwNUAMBkABiT/PdbZCV999RX861//srzeihXLYezYa9KuMHbsNbBixXLiNjU1bYGiou5p1ygq6g5NTVs0Z+lrwxLsMXToUKiuroH8/HshMWJaAWA55Of/Aqqra2DIkCEWV3CPlpaW5P/YWUXt7e0wfvwNMGzYMKipqYGhQ4fC+PE3EM0DiQxwILach9sYCY1FR2ZaVeZ9ygCwJwBOB8BXdWIzJBoajbTE9evXp60jUe8NAvjnjXCuaK9erxHhMQ7k4ldzyGA7ZzglEhqLjkgyv/TuY5S5VVER9Ty4WVU1DvPyQmmur7y8kKfBdj8GfmmQnpfrGIx20gyF+mIsFqNSGFFUhUUESCLhDLfrSIwmK4kgsJP5FY/HU1lT+rEZJVke21sNzWttWA9+0l79SHp6aG9vz1q4ClCGAIWYyORz/lxela5X4QfLVhIJZ9Be2U66vsRJcTej3zyeupc4GpqX2rB2ovtNe3VKeqIJt65+n4cAaxAgntbvdkriG1+bb+n6WCzGpNAjC0gi4QzaREJqZTjN/NKLzfRMVgU+18uT6Gnz4fAIJn3DQnCzLtTIE9YVj9e4Evy8StfrKYZl0FWRW5SCqZnIeSJ58sknceDAgRgIBLC8vBwbGxsNz120aBFGIhEMhUIYCoVwzJgxWefX1tZmmM+A1TZeLE0isWNlOC03rRczqUxpSf7QulkhW5ufi3l551PtG5aC24nLRlS3nfUeLHFXZE7bhWqkGOgqhgBYCYBrAHCuxXz1CjlNJCtXrsSCggJ85plncPfu3ThlyhQMhUJ49OhR3fMnTZqECxYswJ07d+LevXvxjjvuwGAwiB999FHqnNraWhw/fjwePnw49bEzmGgSiV0rw03mV6briPfmQqIhXXBl1ppSMH3ty+OoKD0xEonavk9XP89Fu7sW2nsGa9IT3W2nH3Dvg127QmbvH8KiDpkZzBQDPWWvLWmRaM9XADAWizm6PyvkNJGUl5fjPffck/q7s7MT+/Xrh7Nnzyb6/ZkzZ7BXr164bNmy1LHa2lq88cYbHbfJK4sEkW65aRGD3DyRrs1n1pp6GgECGlLp6qOKiihxH3UJ7rK0a6h/001rtVYIvA46W0FvTCb6alfac3npnjOz6PQUQ3VRsNZCCUKiCrdIyFkiOX36NObn5+OqVavSjt9+++04YcIEomscP34cu3fvjv/7v/+bOlZbW4vBYBCLi4tx6NCh+LOf/Qw//fRTw2ucOnUKOzo6Up/W1lZqRILozMqgGZj2e1lwp+gS8nNNtPTszDY7RSUTgkXBzIKIib8VKoLbSCHYtm1b1nsV3SJREY/HMRaLYSSin57ulXvOqv/UDeZUxbAZ3BVO5YmcJZJDhw4hAOCbb76Zdnz69OlYXl5OdI27774bBw0ahCdPnkwdW7FiBa5evRp37dqFq1atwssuuwxHjhyJZ86c0b3GrFmzMjQkoEokPDa1ES1DRxQkihb2NNDSN5kKjUgkanl9q+rH2sWZRiB9d6pCsG3bNlNt3W8uzUxFx0syJLHotIrhsmT/e70fOwkkkRhg9uzZ2Lt3b3znnXdMz2tpaUEAwFdeeUX3e9YWiQoWlgHr0vV+R3t7O0YilQaC6QFToUEitNy4kpy6b6y09W3btmE4PNL2dUWBl+45EhKzsyCYZK7zUgJzlkjcuLbmzp2LwWAQm5qaiO7Vt29fXLhwIdG5ou2QSFIuhXXper+joiKadGF1aelW5dVJhJYb7dmJ+8bqfpmVDMLhEcRzRBR47Z4jtehUxTBaUeEoQYa3EpizRIKYCLZPmzYt9XdnZyf279/fNNj+29/+FgsLC3HLli1E92htbcW8vDxcvXo10fmiEInVQHOaLnwuwijOcM01/wezKxf3QTvBcieuJKfC0lxbF6OSgRNkKkteuufsJqk4dV3zVgJzmkhWrlyJgUAAly5dinv27MGpU6diKBTCI0eOICLi5MmTccaMGanz58yZgwUFBfjXv/41Lb33xIkTiIh44sQJfOCBB3DLli148OBBfOWVVzAcDuOQIUPw1KlTRG0ShUisBhqv0vW5hEz3olHZDkUJEQstJ9lxXYTwWwSox65V3ubuG2MCetxTLd4pjNx7Bw4c0F1IytO60o4V2oVPvVACc5pIEBHnz5+PAwYMwIKCAiwvL8etW7emvotGo1hbW5v6e+DAgRmTPvGZNWsWIiJ+8cUXeP3112NxcTF269YNBw4ciFOmTEkREwlYEwnJoCQZaLlmkXiVMJCIo+hnD9kBqSBpa2tLWkLaMawgwDgEWGj57vS0deOEAjHSfo0geryHVRqyF0pgzhOJaGBFJHZ8oqQDjWbpet5QicMqC8npde0SEq806erqmmQ1ZG26cG9MrGsJWFpCehaQcUKBuBYJiXvP61X6rO4vLZJzALSJRBVs0UiE2CdKOtCc+Ge9ThXW0/ISQvRpV5NV1BpTWliXCQFi943fKxlYZWf9/Oc/95QcWQf9eSuBkkg4gxaRGBV3ayfUQOwMNBJtmlTQsiYaPS0voZHXIEAzJor3zbU9Wb3WXklgXbjQuVvDb5UM9AV1G2ZXCfDGXcc6DZnH+jItJJFwBi0iMSruVmPiqtLC7kCzIgArQctDoyfRyLVxA9J6RV6njJKC5PndttVPlQyyragyTGTRLUerBaN+t0hU8Hpfkkg4gwaRWLqmCCwSFVYDjYQARPFHW2vk07HLSgliRUWUynVFCjZ3xUi0KceJGIlI1hMP6Nfe0o7RmmTfeOOuY+EuzNwbhxfpSyLhDBpEohcsb4aukgrLLFxVdkBCAFaCdtGiRVy0L7JS4vbv7ReLBDEhPKuqxmUITwWrqsYJ6YbiIey0u32mj9F2BKgyVZJYgqa7MNPVrWRY4KwrUkgi4QzaFkkbJNxZ2kGjUBo8pALU6rz6+npuGr3R3t0JgeH83n4LNsfjcayvr8f6+nqhiE6FkaWrVyySBkjGqFf9RMP9pHV1VwFgbwCuFSkkkXAG7RhJGWSXme6tKFTKTNtx6ZgJWp4avb47Q8FE1pbze/st2Cw69CzdhEtOYda/flMGSKHOr+kA2JDsO97rvySRcAYtImlvb0/tVMhq0NghACtBy3sSa7U8mvd2oz16nRptByzbau2CfBVZxNDslMz3C9ra2nBkOJz2TAoktubVdi7rihSSSDjDyx0SncCuENYTtM3NzRiLxbKK/vHS6L22JvywBkUFj7aS7a/OLgZFUjLfDpF6qSDUVFdjb0XJ2viqzKFy6fRZJJFwhpc7JGb+lmTAuBHCekIpEoliLBbjMukyn9Gr1FU/rEFRwaOt5EkRbLPi9J5VUUJZ9dGMxrvXCkJjY6Pp/J8L5IsR3VYLlkTCGbRXtpMsLNQKVKcDxokQ9kqAej3BtfBTxhfPtuonRagLR9n3kfGzateamI9ZrxWEEUmXlpFHws4cd1stWBIJZ9AmErOFhXqkUVJUxKW8tJcC1OsJrgXNNSisXSg818voJ0UEMFFYkn0MTf9Zyces1wpC1/2NLZL169cTjRcatbkkkXAGq6KNehZDppYx12Lg0Rz8Xi3i83qCa9uxZs2a1D7cbtqjZ2GFwyOplz33ou/UcdvU1GTLinRLqvrPSj5mvV6kqt6/ChJZm1qPRBAAR4bDtq/lJtYqiYQzeO1HoqdlrEkOjMwBsyl5vL6+nvr9eQqltrY2DIdHmE7wcHgEUxeXntAvKipxlTWmXz8siABKzqXI0qi0QIrsZyXfd4X1+LYiSvX+T4P+OjI7Soa0SHwIXkRitPpdO2D0FjPSXAHLWyhVV9dYbnGrKEGmQtFtADcTVgKL9vPwyHBzY03QdFvqPasd0mcxvu0QpTY++ioAPgCAQUVx5KZ2Wy1YEglneGmRICTSAoPJgcJ6BSzPtNt0gVuDiS1tM7e4rWFqEVkJfVKftRbWqbIPED2PXeFNM8ON1t4wVv3r1NWnfVY7Y5bF+LZDlDQr/Lq9liQSzuBBJGqQXdGQhqplhBQFS4qKUoOFR7yER9ptusBtT5KG1toamTzOzofNwm9OtnjP+NpeZrDR3hvGqn/D4RHU2m5nzNIa307dZTTnl9NrSSLhDB5EopqpTyetDj0tQ61/tQkSsRO1YrBf92TXn4TxlMbetTaha1LSzoJi5TfXT5Uls7C8zGAz3xvGvG/03g2PMvlegkcAP7Nfac0BSSScwWPP9kxLIw4J/6l2ojU2NmZXCAXAhQQTUtRSH8YFG8tQ68OuqhqnkwU1gkoWFAu/uX6qbBUCLDS9tpcZbE4XHVpZUIk91oM6pFrlSwVIC5bvy2gpAK34qCQSzmBNJHb2Yw/l5aUXewTAQHJA6YF3xVa7MAqeZra3qmpcUtgvRNplxFnGhZqamjRZadbX9jJF1WkZFCsLatu2bagt7Jj41CTfpf8skkyljFWCSuZSgDJIuL1pxUclkXCGFxYJQnrsw+ocI82cVcVW2hZOpp9X+7d+UJ6+24dlXIj02mJbJK9mCUnS9nZl5z2gex0/wEgpO3DgAHVFJHO+Z2Zv6skIu5BEwhluiIRU4Fql8jlZgMSiYqsXgeAuTXmTZ0KWJ7xcF6J3bzPFg9SC8roIJw1YWV40FZHM+W60nsxNfJQ5kXzxxRf40UcfZR1/7733nFzO93BCJHbrY1ml8jlZgMSiYqsXgeAuQpye8TzNyWcwz4LyG7wUukb3bmpq0hWSdi0or4pwugVvS9H3Fsnzzz+P/fv3x+HDh+OVV16JW7duTX131VVX2b1cTsAJkTgtqGY20ewuQKJdsdXrWlxdCxcXYnaqsEK9/IjX4C10tdaznXvzsKCculJpuWC9iF1lznc1RuJ0AWImmBLJ8OHD8ciRI4iI+NZbb+Hll1+Ozz77LCIilpWV2b2cIzz55JM4cOBADAQCWF5ejo2NjabnP/fcczhs2DAMBAJ4xRVX4N/+9re078+ePYszZ87E0tJS7N69O44ZM8bWwLJLJDTKF+jByQIkmhVbvQwEd2nKCibWNfTGzLiPn/ztJOCVaefWXcnSgnLatsbGRltJDlbwQonSm+++ydr65je/mfZ3W1sbVlZWYl1dHReLZOXKlVhQUIDPPPMM7t69G6dMmYKhUAiPHj2qe/4bb7yB+fn5+Pjjj+OePXvwN7/5DXbr1g3ffffd1Dlz5szBYDCIL774Ir7zzjs4YcIEvPjii/HkyZNEbbJLJKw3r7KjLW7bti2Zfpm5wMx+xVYRiiv+9a9/9bwNrME7DkXLXUlzkV/2TplkbdNfUFmFAE+7tpK8il2ZJaK4AVMiufbaa/Gdd95JO3b69Gm89dZbMT8/3+7lbKO8vBzvueee1N+dnZ3Yr18/nD17tu75t9xyC95www1px0aNGoU//elPETFhjZSWluLcuXNT3x87dgwDgQCuWLGCqE2iWCRG9zLa3TASiaZNqHB4BG7YsMGVkPK6QKDXFVx5gEUcysi6EUE5UKFPAgomVtUbt82KeGiV2smFhAEtmBDJ8ePHERGxtbUVDx8+rHvO5s2bSS/nCKdPn8b8/HxctWpV2vHbb78dJ0yYoPubiy66CH//+9+nHXv44YfxW9/6FiIitrS0IADgzp07086prKzEe++9V/eap06dwo6OjtSntbXVFpEgui+oZgW9YP7Y667DqqpxGROxDAF2ZQmjeDyOixYtwvr6elsTy+vJJJLgYwHaz2dl3YhEzMYVk6t02xaLxXSIxypL0f0zNTQ0YF1dHa5fv57Sk3sDJkQyfPhwQwLhhUOHDiEA4Jtvvpl2fPr06VheXq77m27duuF///d/px1bsGABfv3rX0fEhOsLAPDjjz9OO+fmm2/GW265Rfeas2bN0hmc9oiEZnE2PegF88+D/GSqpp421jWh3BbiQ/Q2+4aWVSTian/agt3KuhGFmMkTQ7qORSLRjGfLzOrLzFIkK5ZpBJF28aQBJkRyxx134IABA3Dv3r1px3fu3Inf+c537LfSAUQhEhoWiQoWAlfPddYMVtpYPDWhwuGROmXTgxgOjxBKqBrBrVUkskCgKdjtLBb00l2JSFoxuattkUhU59nYlu/3sgYaCzCLkTz88MNYVFSEr7/+OjY3N+PNN9+MiqLgd7/7XceNtQNRXFuZ4FVGnhR6wXx1wZL5mpGuQnldk60NM1NpRRGqVnBK0qILBFqC3U+LBUmKO2rbFovFDJ6tCrPregXR7YZiolhuNME02P7YY49h9+7dsVu3bjh+/HjL1FvaKC8vx2nTpqX+7uzsxP79+5sG2zOJbvTo0VnB9nnz5qW+7+joYBpsZw1nFslczM/vo7MbIbuSIyJCRIGQ6WKjJdjXrVuX/P08omf1erGgGYFmts34PS7EzLpeNLY4tuNyFNFlqgcmRHLkyBG89957sUePHhgOh/H888/HlStXumqoE6xcuRIDgQAuXboU9+zZg1OnTsVQKJRa2zJ58mScMWNG6vw33ngDzzvvPJw3bx7u3bsXZ82apZv+GwqFcPXq1bhr1y688cYbmab/2oHTQacXzO+KkWRrY6owShTQUyegeEKVNUQKLlu52JwKdv3sJzXpQtwaV3YJ1A7xuIWVAtLQ0ICxWAwrKqLE7fcaTIikR48eWFZWhi+//DIiIq5duxYLCwvx8ccfd95Sh5g/fz4OGDAACwoKsLy8PG11fTQaxdra2rTzn3vuORw6dCgWFBTg5ZdfbrggsaSkBAOBAI4ZMwabm5uJ2+OWSPTIwm4JlUzoBfPHVVVlZW1VVEQxFoul3btrAqr7fngvVHlBJIuElYvNOPupS6EQVbghkhMoC5ecmWJnRFxd1aqVZD/7w7pnQiR6bp7t27fjBRdcgP/xH/9hr4U5BqdEYkYWTkuoZEJv0llNxOwJ6L1Q5QkRgsusCI1k6+BcAw3rgyQBw2jLA0UJIcBc380lrtV/Dx48iJdeeqnby/gaTonEiCwqIxHMjHEg8FuwqCIej2syuLwTqrwhQnCZlYtNJNedn2DHOlSJq6GhQUMe/ut37mXkRTaDecAJkVitbs/MukKgu2UuaYqrCELVK3gZXPbKIhFRM/YaTvssnbT91+9yPxLOcEIkVvW2WFskdv3vLIKTfshc8RKsXGwiuO5owM4YcjPenFpx2QSkZkD6o98lkXAGC4skWlHBrISKl1qpyIv9RAMra5D2dXkrBXbGEI3x5ma+pJP2Lkxkx/lj7Esi4Qy3MRI9smBVQqW5uRnr6uocaVg0IPpiPxHBysXm9rpeKQV2xhCt8ebUitMj7UgkO1OSFDxJWxIJZzglEhKyoCVEjNcOtHOzSKR/PrfghVJgZwzRHG9urTgapM2yNp8eJJFwhtt1JDyCusZrB8q4+WtlxhBb8NRWaQlpu222M4ZYjDevEjBoLQewA0kknCFaiZRMkNYpYu2WyBWLRLREAVIXE812uxXSem2ORKKW488ri8RL8Ny/SAtJJJwhOpFYTfq6ujpu/lo/ZwyJmihg5WJi0W63Qrq6uia5UC89+FxUVGLZLjtjyM/jTQXrHVWNIImEM0QnEt6bIZnBz+tSREwUIHm37Eut2BPSXW0uw8yCoABBrKiImv7ezhjiNd5YWqnSIjlHIDqRINLVzNwIJq+0ercTXVQ3iXG59IS1uWjRImbtdiqkuyxkd+2yE69gFdvgNZ5Z76iqB0kknOEHIqGlmdFwafDU6mlNdFETBSKRStP3UV9fz7zddoV01xgSrz/tgtd4Zr2jqh4kkXCGH4hEhVvNzI1A9UKrpzXRRbBIMq2qbBdR+vYAFRVR6u2m5cKxIkA/BMK9GBM8s8YkkXCGn4jELoyFl/3Jw1urpz3RvQrcGllVXW6tXZi5iyWAgrFYjFq7abtw2tvbk+XVg9z7kxZEtVJpQRIJZ+QikZgJDvdBVj4aHO2JziNwq6fxG1lVkUg0oz/jmKgyOzetP2m0W68NihLEcHiE4/fW3t7uq42eMiGClWrVPjfWiyQSzshFIjFzCbkRTDy1elYTnYV7wYi403eszH6GSCRK3J9O253dj21ZFpD2/dsVYF5v4esGIqYX01oFL4mEM3KNSEgFsBMBwDv9V8SJrgcj4g6HR5haVbFYjHl/Zlt2ahXb9LZWVY3zbWq3U5iNZ68WrtJaBS+JhDNyjUh4+H55aaF+WLdCVnmAPqkbtUXdlEm9Xnr7zNuqKEFdKzbXoe1/Lxeu0lxzIomEM/xIJHpBdH3BIZ7v1wm0u9aJ5kaxIm4eu1SmCz8lSwhWVY1LtuEB07YCTM+ZMaOFHevCy4WrNFfBSyLhDD8RiZ7/tG/R100Eh9guIVKIWt4E0doiaWpqYt72LuGXvdpc321lZD29ysyK9QJ2x41XSpjWkpQWiU/hJyLJ9J9eCQomUjC993ez9CmLWN5EC5JYDit3YJfwm2spBOPxuKGFlLBkcseKRbQ/bninBOsphiVFRVRWwUsi4Qy/EEmm/7TZQrtUBQdrV5Bba8GKgPzgqvMyltMl/JYRCUGjtrqxYkWrqIzobNywGGtmfaMXWA8pCpYUFaW9H5m15QP4hUgy/adrUgPN2wVVTq0FUgLyYiGkU6HoRSqsHYvErK1OyFBkl6PTcUMrU9AqjdcqsL5+/Xq5jsRP8AuROLFIeLXJrFaUmgBAulAvc8LyskhEFopWyI6RpJdbISnvrsIOGYrscnQ6bmhZl1ZpvKzLy+cskbS1teGkSZOwV69eGAwG8a677sITJ06Ynj9t2jQcOnQodu/eHS+66CL8+c9/jseOHUs7T/vC1c+KFSuI2+UXIkHMriLaFSPxJqhupfV1fZS0SWm1UC9zkvNYT2IlFEV036hIF35KRt+XoaKEqI8JP7gc3YwbN9YlSRrvunXrEABwnsk5bpCzRDJ+/HgcPnw4bt26FV9//XUcPHgwTpw40fD8d999F//t3/4NX3rpJdy/fz9u2LABhwwZgj/4wQ/SzgMAXLJkCR4+fDj1OXnyJHG7/EQkelVE9bK2eGnR1msoXk1+1xsBqlLCORweaUpAmdqYUy2RVPhbPUckEvWFpaJm/QA8iIlyK3Fmwt0Ptaq82s/EytoYGQ6ntakMAHcB3fLyOUkke/bsQYBEKqSKtWvXYl5eHh46dIj4Os899xwWFBTgV199lToGALhq1SrHbROZSIwEYaa25GWZCj2tL0EcNTrEEtf83742S/qcdt1UVkJRUXoaWioigUS407Ks/GCRqGC5n4leHES1uPUsEiVJFlqXVzB53GlgXQ85SSSLFy/GUCiUduyrr77C/Px8fOGFF4ivU19fj3379k07BgDYr18/LCoqwpEjR+LixYvx7Nmzhtc4deoUdnR0pD6tra3CEQmtejtuQSJ09LS+hPXRniXIElpy4v+XXDIkuZKavrvKru/e2rKaJ7ywRLR+DtpFFv1SwoYVzOIgeptZBRXFkGDUADst5CSRPPbYYzh06NCs48XFxfjUU08RXeP//b//hwMGDMBf//rXaccfeeQR3Lx5M+7YsQPnzJmDgUAA//CHPxheZ9asWRlCD4QjElr1dpzCSeA5Ho9b7ugHsA0z9/nW+vSLikrwwIEDrtruVFPWE4qK0jvZPnHdN5kwEu5FRSXUA+Mil7BhHdPSxkGaIZFFGdeQQlNTU5YyOCLp0uKxf7uviOTBBx/UFcraz969e10TSUdHB5aXl+P48ePxyy+/ND135syZeOGFFxp+L7pF4tUez1q4ycYxdnVVJUkkmHbdxHfDEWAeFW3Wqe9eTyhGIqoGL777RoX+c7DdiEqkCsB6SlA4PDLNrU4D6jirypB36t/qONP2Dc+57Ssi+eSTT3Dv3r2mn9OnT7tybR0/fhxHjx6NY8aMIQqiv/zyywgAeOrUKaJnEC1Gwjot0Apufd/6ri5tJpH2us3YVf8pTnwPlu3PFIpW7htRs7m0z+GHwDgt6ClBCeVFoWotNTc3owKAvZPEoHoOekMi3mE0Hnjt3+4rIiGFGmx/6623UscaGhosg+0dHR14zTXXYDQaxc8//5zoXo8++ij27t2buG2iEYnXFgktoaMVZPF4HOvq6jTXzd4TA2AkJnYLtL6HlfCm6bs3ct+0tLQI69bJhJ8C425g9ZyKEqQWv3E6T3nt356TRIKYSP+96qqrsLGxETdv3oxDhgxJS//96KOPcNiwYdjY2IiIiY4YNWoUXnnllbh///609N4zZ84gIuJLL72E9fX1+O677+K+ffvwqaeewvPPPx8ffvhh4naJRiSI/LQWRLrb8epdT3u867rZe2Ik/i4zvYe+22JEltuChe/e2FIRP5sr0fcKJtyImS5HJWeIxHpd0wPUiFONBzr1HLB2B+YskbS1teHEiROxZ8+eWFhYiHfeeWfagsSDBw8iAODGjRsREXHjxo0ZGmvX5+DBg4iYSCEuKyvDnj174te+9jUcPnw4Lly4EDs7O4nbJSKR8NBaaG/HSxKgr66uSWZqma/ZMEJXuxZiIuZiThTsCyX6Q8PvErDpfab+nSuurfRyMdnraBLrmtw9b2ZGpZexTDPkLJGIChGJRAVLrcVMo3ai0ZNo6O3t7US7BurByqIRaUW/aII5ve/UveHpxKREQltbGxYVlWSQZRkChJJjxv3zajMqqyARE+HhObALSSScwZtIaAZnnV6L9na8djR0p9p8l/De5Lk14DeLBNEovTmI4fAIIdvrBMaB9mIEWOhK2Whubk65s1QrpB0AazK8JV6s99KDJBLO4EUkNBcZur0WbY3a7vWcuM66hPd0IawBvy3Gy7Yy02tyiZooQAqSLY+dPKPeXMuMi7yaPF5fX8/o6exDEgln8CISmosM3V7LrkZNe88QPddZRUXUcpKTxFh4add23H8ipQinb24lfqIAKayUGadCXjvXNoHYcREtJJFwBg8ioZnSS+taJBq1nRXudjX0trY2w2KIRoK3S3h7W/VYCzP3n4il6f3oliMBq02pMudaDYgbF9FCEgln0CISI+HX1tZGtTQCrQWLJBq1nRRXuwF6o2tnBkv1rtHU1KSpICyGgNaDiKXp/ZYoYAe03Y16c60dslezW7mVvXjPkkg4wy2RWMUraqqrLYu1NTQ0EA802gsWjTRqpxoeSYCerEiitctFpNIcmRC1NH2uWiSI9pUZUpet0VxTN24zgpfFVyWRcIZbIjGLV2gHYg0A9sk0iR3uz8xjwSJLzdV64dga3ws4kUvT+y1RwC6sFAw7Lkc3c83L4quSSDjDDZGQaCyqaayXKti7sBBDimJ7oNlZsMg6RdgJrC2SuOaYP10uIpemF7lqLw/Yddk6sSq8LnUkiYQz3BCJVbwiM+8cIVFq+gHNoHQz0FgHellqrvpVgoOYWECWGy4X0UvTi+waZAWWLlstvC6+KomEM1haJPF43NA0Zr03AY1aUCw1V71rFxWVoKKEmBCXF8iV0vS5BF7JBtIiOcdAK0Zi5EM1Mo3NtuNk7TqiFZCnAe21/ehyIXEdqpt+qcHZXI9RiAyeyQY8i69mQhIJZ7glElIfqp4wZjXQ/J7i6QeXC6nrUO+8qqpxWFU1zleE6QYiLchE5JdswKtkvB4kkXAGrXUkToQfq4GWyymeZuApsEhdh2bn+YEw3UDEBZmI/JMNvHjPkkg4Q4TqvywG2rnkPmElsMj2VjEm6nOV0FWIvmdLLhO5JBLOEIFIWID24iyRQVtgWRETqevQ7y5GNzjXSdRrSCLhjFwlEhU0F2eJCBYCi6S0ibRIzOEVifpZIaIJSSScwYtI1P0MrMoq8IB2sonufrACbYFFKvxJXYcsXYw8hKaIC1r14HeFiDYkkXAGayJpa2vDcVXpW5wqAPjta67BWCzGlVT0JpvfNWbaAouUmEhdhywCuzyEpugLWo3v5U+FiDYkkXAGayKpqa7GUF5eqgzKQgAMZAhyXimB2ZNNjE2i3MJIYEUilWnaNEmRPrUaASkxkQZsaQZ2eQhN0Re0Ina9z4aGBt8rRLQhiYQzWBKJ2X4GvAu56WvuueHDN1olb/a3VqDpW2oBBFjIXJO2CysLzE4laaf38HpBq7Fl7W+FiCYkkXAGSyLJrLfTDO7ra7ltS/Zkq0JRNolyC1VgVVREDfbuLtPVrvW077y8EGq3oxXF3278Hnchre1zRc82y35fc3NCIaIJSSScwYpItG4SlTjWJCe4F4Xc1q1bZzDZFlITQCKAvLJwlwZvdr4IyRFaGD9fWZIs3bu7RM42s35+/ytENGBHrp0HEsKhvb0dJk+aBGsaGlLHfgwAnwHApcm/XwOA2zS/eTX57+DBg5m16+zZswCgQD7cA52AABAFgFchHx6ETgCor6+H/v37w+DBg2HIkCHM2sEaLS0tyf9VZnwTTf67HwCGpP7eunWr6fn9+/d33R/xeBxaWlqo9O3QoUOhuroGXnnlXujsVN/jSgB4GwCWQ9fIug06OxEaGibDvn37TO+b2T79e7wK+fm/gLFjazwdH8bv988AUAYAk1NHRo+OwooVy/k0zM/gQGw5D9oWid5mNiFIZGpB8t8g8N/zWdXkrsywPtS/RdK63YC2ReKmX1hlV+nFhMCBK8qsfaIW0LR6vyNGlAvXZi+Qs66ttrY2nDRpEvbq1QuDwSDeddddeOLECdPfRKPRrMny05/+NO2cDz74AGtqarBHjx5YXFyMDzzwAH711VfE7aJJJFalox999FF84oknMFpRkfZMrLO21OyWaEUF9snPx7kAuAwA53IiMd4w3+sk2+3BKk2VdXaVGhNySoYk7ROxjIjR+yoqKuGaAuxmHQ/rNUA5SyTjx4/H4cOH49atW/H111/HwYMH48SJE01/E41GccqUKXj48OHUR9sxZ86cwSuuuALHjh2LO3fuxDVr1mDfvn3xoYceIm4XTSKx2swmFoulzuUxQfX2jHayta/fQJLFpdVU9c6vqIi66hfecQa7ZChyHMQK+vu8VNp6HjeC3M1e7Lz2cc9JItmzZw8CADY1NaWOrV27FvPy8vDQoUOGv4tGo/iLX/zC8Ps1a9agoih45MiR1LE//elPWFhYiKdPnyZqG0+LJBqJOL6uk0FvtGd0NBLhpmV6WbIik6ytdpSMRNItYDduEavMp7q6Ot12OO0vu64o0TOzSKB9n6TPQ0OQu9mLndc+7jlJJIsXL8ZQKJR27KuvvsL8/Hx84YUXDH8XjUaxb9++WFRUhJdffjnOmDEDP//889T3M2fOxOHDh6f95sCBAwgAuGPHDt1rnjp1Cjs6OlKf1tZWakSCiBiNRLJjIABYBvZTfN0Meq93aPNbyQrabih9jb8NE+617D6hRWSklq6fLRI9kD6PW0GunVfNkMjEjBPOK9I5SUP5ykkieeyxx3Do0KFZx4uLi/Gpp54y/N3TTz+N69atw127duHy5cuxf//++P3vfz/1/ZQpU/D6669P+83nn39uqlHNmjUrbbKqH1pEEovFUoH1lPAHwF1gP8XXzaD3es9oP5WsYCVUs91N+im6VVXjkq43Oum7es+nJ5iqqsYl18t0ucPy8kJYVTWOijDjbY1aufdoKFfqvKrKmONVBPOKxPVNy+3lKyJ58MEHdYWy9rN3717HRJKJDRs2IADg/v37EdEZkbC2SNTBOk+jrTixBNwOei8tEr9pu6zcPPrZVUbZZPT7y8oqTOzSGMhoXwB79y42/A2N+7KClXuPhnLV3NyMCmRXp+gNiYxMNxaJmgxDw+3lKyL55JNPcO/evaaf06dPO3ZtZeKzzz5DAMB169YhojPXViZYLEiksYUujUHv1Z7RfvO/sya+eDyOdXV1pn3Cor/MrML0Z44jwJrkv/pWkx3LyGtr1Mi9R0O5cnsNozlZGYlQVfx8RSSkUIPtb731VupYQ0ODZbA9E5s3b0YAwHfeeQcRu4LtR48eTZ3z9NNPY2FhIZ46dYromiyIhMYWujQGvVd7RvvNIkFkX6nWen0L3f6yul99fb0Oebl/b6K/e7fKlVsFz2hOxmIxV9fNRE4SCWIi/feqq67CxsZG3Lx5Mw4ZMiQt/fejjz7CYcOGYWNjIyIi7t+/Hx955BF866238ODBg7h69WocNGgQVlZWpn6jpv9ef/31+Pbbb+O6deuwuLjYs/RfxHS/sNsUX1oWhRdrAfy21W97ezvVrC09GK9vUZKWQPZ3FRVRR/eysgr1qxy7tyRFt0bdKle0XMaZc5K2KzpniaStrQ0nTpyIPXv2xMLCQrzzzjvTFiQePHgQAQA3btyIiIgffvghVlZWYp8+fTAQCODgwYNx+vTpWR3zz3/+E7/zne9gjx49sG/fvvjLX/7SkwWJLPLDvbIoaEDUldF60PPpRyLu1pHoob29PWs9S4JAChCgEDMzuoqKShy3gcQyyCa2x3PeIlHhRrli5TKmed2cJRJRQYtIWOaHi7i6mBR+aDsvn36XkJ2HXTEJRL3CmZGIeyKzsgr1yL5btx6YWfwQIIhFRSXU7msnm0vErXNZKXg0ryuJhDNoEInXazYknIOnBm3l9qmvr6cqNEmtwuxSK+mWkfo3abu2bduG4fCIrPu2tLQQW6k0M79YkRErJYnGdSWRcAYNIvF6zYZbiKj18QJPn75Xbh9SwZTeF9pMLrK+0BP+4fDIVEULO5YfDSuRVzkSESGJhDPOZYvkXJ5oKkSvicUTbndfJE83Nu9nWu+EVzkSESGJhDNox0h4r9lwg3N5omnBU7iLnoSg1xeKEjIteonoNN1Y3/KjYSX6VbmjBUkknEGLSGgH4Fi7m871iaaFF8Jd1CQEo8rJVm4mZ+nG7CwSv7ub3UISCWfQXkfiVkDwcjed6xNND6IKdy9gd68TZ+nGxpafWR0wEpzripIkEs5gtWe7U/ByN5FMtHM5CC+RgB03k5N0YyPLb1xVFZ4H+Wnnngf5OK6qirjtfnQ304IkEs4QiUh4a1FGE23sddcxs4rskpMkM29hx81kN93Y6J2q95wLgPXJj1mpdqMx4ucFvW4hiYQzRCISVu4ms4kWTRaL0060cVVV1K0iu+sC/LafCSuIQKR2kxHcughJt2IgdQOfiy5LSSScIRKR0LZIzCaa3nfRSAS3bdvGxCqyuy7A6wqyXkMkIuWdjKBuDpemyED25nA11dUYVBScDoCvMnQDO4WXSoAkEs4QiUgQ6fh11QFstr+BUSxmRDhM3Sqym4Xjl3pNLOEVkZoJPx6aPel21Y2NjbpWy0KXCg8NiLA+SxIJZ4hGJG78unoD2GhCOv3OyQS1CtjGYjFb59POKBPBfaSFF0RqZQHx6iOSXQQREUeGw7pWC8lOhawhwvosSSScIRqRqHCi/WkH8LLkhDKakGbfjQyHqWa7WAnGSCRq63xawkwk95EWtImUhAS60m27LKC8vBBWVFzLtY9IswmtFCGvlAJR0o4lkXCGqERiF5kDuNmF1dHU1ETdNI9EophdVbYPGhUE5LHaXNQ4DC0iJSVK8/sp3PvIyr1rZbWMCIeZtc0KoqzPkkTCGU6JRDR3iN4AroGEua83Ia0ma3NzM9bX12N9fT2VVN3EDnDppdIBahBgl+4EYx3gFT0OQ4NISYmya9V5pgW0ybSPrGpvOYWVe9dK61eLRHoBaZGco7BLJCIE0vSgN4DboSvTJbOtRpO1paXF9vOR9InxXhxd7i29e7AK8PphJz83RGqHKPXLl7QhwCDTPmLt7jJ79yIvNhShbZJIOMMukVgF0ry0VIwG8Mirr8a6ujpcv3591m8yJ6uTQCHpb/S3mk24t3i7lES3SFQ4JVI7RJnoCwUBemveTRkC9DTto4RS4I1LUOTFhiK0TRIJZ9jpcMvUxIoKZoPHjKDU7/RiGyVFRcRtcmKW2/mN3r7oCfdWuycCXOSS7m5hlyirqsYhQCDj3SxPvh+9febLTK/LQ6Fy4n7lCadKAI2+k0TCGXY63CyQpgBgb0WhnvJnd1FhTXU1NjU1JdaRRCK2rAsngUK7v+nSlJdhl3vLG5eS6CXd3cIOUer1ReI37Uky0R5XMBHbyrZ0YrEYc21cVPeyW9B8LkkknEHDInkc6K+9UGHmNjL7jrV14fQ3IrqUcrWEhhOijMfjBjGTOAI8kGGtZL8/u8qLE4iwToMFaD6XJBLOcBoj0cYheiqKbU2eBCT58kbfqRsJ2W2Tk0Ch3d/ksktJRGhLwpMSptk7MvouEolSU6iM3DuiZEXRBu3nkkTCGXaJRC+QVpksfEh7cFu5jcy+U7VKu21yEii0+5tcdymJBicLL83ekdF3iRRvdwqVlXtHlHUaWpiRHilx034uSSSc4XQdiVG2E82UPzcWSTwed9UmJ+4eu79xcg/R1u/4AW4WXpq9o8zvaGjVJFmRolgkRqTnJIVeWiQ+hyhb7RoJSDMysCIKEdIQaUGkAKufyIx3TMqN8kIqTEVYp6FtRybplRQVOYp10HwuSSSc4fVWu1YC0owMSIkiF4LJXgRYMwlD1NpcZuC98NKN8kLq3hFBQbIivXkOLAuaz5WzRNLW1oaTJk3CXr16YTAYxLvuugtPnDhheP7BgwfTOlT7ee6551Ln6X2/YsUK4nZ5XWuLVEDacTHkGni7M4wIo6pqnJC1uczgVZacU7elnffs5bi3Ir1lFmRoBhrPlbNEMn78eBw+fDhu3boVX3/9dRw8eDBOnDjR8PwzZ87g4cOH0z51dXXYs2fPNAICAFyyZEnaeSdPniRulxdEomq6DQ0NXAWkX8E7wGoUU0isnxAnbZkUfsqSE8VtZQUWFglN5CSR7NmzBwHSi6mtXbsW8/Ly8NChQ8TXKSsrw7vuuivtGADgqlWriK9x6tQp7OjoSH1aW1tdEwmpz1zPjSVaBoqIsJq06spmGrELKw0e4NWM42LU5jKDn7LkRHBbkcKI9NQYiay1RRmLFy/GUCiUduyrr77C/Px8fOGFF4iu8dZbbyEA4BtvvJF2HACwX79+WFRUhCNHjsTFixfj2bNnDa8za9YsXXeYEyKxGwDOdGPNBXYLGXMNepM2CJC2S55C+B7MYBVTAJiOAM3YVXhSfItEhZ9coH5oqxHpHThwwHMyzEkieeyxx3Do0KFZx4uLi/Gpp54iusbdd9+Nl112WdbxRx55BDdv3ow7duzAOXPmYCAQwD/84Q+G16FpkRjFN0aGw8QLqcqSAlF0U94LaC0MvUkbAMCnNX3fGxI75LkJxFtbJJn1qAJYVTWOwdNL+AVGpOclGfqKSB588EFd7V772bt3r2si+eKLLzAYDOK8efMsz505cyZeeOGFxM/gZj8SLTE0A+AajZWRqYUY+fl3ZWjSIpvyvGBm6UUjETw/L8/cknNp1RnFFPr0+bruLoKSSCREg6+I5JNPPsG9e/eafk6fPu3atfXnP/8Zu3Xrhp988onluS+//DICAJ46dYroGZwSiUoMuyCxgZRW6CkA+HOwt5Bq/fr1wpvyvGBk6akVBKaDRWwJ3MWZ9GIKkUilqaXil/fmpzUwEs7hKyIhhRpsf+utt1LHGhoaiIPt0WgUf/CDHxDd69FHH8XevXsTt82tRVIGiV0ItUIvCIBRHa3YLxkpXqG5udmytAsA4CawiC25tEhUaF0TJOsxeAtpO/cTaUGnBHvkJJEgJtJ/r7rqKmxsbMTNmzfjkCFD0tJ/P/roIxw2bBg2Njam/W7fvn2Yl5eHa9euzbrmSy+9hPX19fjuu+/ivn378KmnnsLzzz8fH374YeJ2uUn/taqx9WqGVuynjBSe0BNyZvXFloP+NsJqjEQl6MpIhJpgt4qdRJNjgcd7dUIKuVoxV0IfOUskbW1tOHHiROzZsycWFhbinXfembYeRF2AuHHjxrTfPfTQQ3jRRRdhZ2dn1jXXrl2LZWVl2LNnT/za176Gw4cPx4ULF+qeawQ3RGJVpO4BA63YDxkpPKEVclbWRrSiAvvk5+PCJGlohWme5v92NvQihVHspG/R17kKabukIFJ9qlyB6C7CnCUSUeGGSKwmaFBRhNb4RJgMen1Yk7Qu9FyAelZd2be+hf/nmmvSjmVmdNEQ7PqxkyhXIe2EFESsmOtX+MVFKImEM9yubK+MRLCnouBcyF7fIOIAQxRrMugJuXYdayOzfVqrTk9D750kpMxsOhqCXS92wktIO7kfKfmIoFiIDr+4CCWRcIZTItETxmoa78hwOG0Vv2gQaTKQrlp3+vvM9xOLxbi2XwSLBNFgQzZIuAO/fc01OK6qippikauE5CcXoSQSznBKJLpasKJgtKKCUUvpTFBak4GmsHCTzWaloU+HjGw6B+/H6ll5Z+MZ3c8suSDTJZi5duk8cO8KFMnSZQE/uQglkXCGEyLxohotrQnqdjKwEBZustks34WL90P6rLyz8fTuR5JcoPbVJWCcsu5mLLOwdEWybqRFImEIJ0TCWzOhOUGtJoPVvt4s3WJOs9mM6nBVuXw/dp+Vdzaeej81k82qnV1rYayJ125f0Rayolo3flkLJomEM0S3SFjcy6xqqdnEFVUj09PQFUi4apy2U9RnVdumEpaddnathTGvCuDkOWkrVyLF8bTwy1owSSSc4TZGwlozYWH9GLlGQopiOnG99hFbuTn0Mrmcvh+vn1UPelr6yHDYVjtJFtE6Gcs0iVdkElch+lowSSSc4ZRIeGkmLCeVOhlIN9jyaoI7cXO4fT8iCjMjLV2x0c729nYsKSrKqjgdAvdl+GkpVyKSuN8giYQz3K4j4aGZsLZ+7ExcL3zEbtwcbt6PSP5wksWvpO1sb2/HaEVFFsk2NTW5Gsu0lCsRSdxvkETCGV7v2U4C1taPnYnL20fspVDxwh9u5L6zIvsRSReX+qmMRDAWi5n2DysliMZ1RSJxP0ISCWf4gUhUsLR+7E5cXj5iEdwcLJ9VJY5t27aZkhYJocbjcYzFYrrWhmjBYCv4JagtKiSRcIafiIQlRJ24uerm0Iv7WNUHIyF7J25AkdZqZEL0oLaokETCGbyIROTJqqK5uRnr6+sty5LwRi66OczqgxmRpRXZNzY22iJdUddqSLiHJBLOYEEkWtLww2T1oo12iFVUa8kpSFfjG7nvjLT0ETZTgUVdqyHhHpJIOIMmkegJ5JKiIuEnK0+B4oa0csXNYRn3sem+0+4sSWqR5KrLUCIBSSScQZNIMgXyXBsT2yvwFihSC7buc9JFgXqkXAzZO0cGIbFwUQsRkhgk2EESCWfQIhI94bAGuspRqPtixBlOVidxGCuBsmjRIurb1YpMrLygF/cJ5eXZWhSoR8pBACzRXAMgsdAwc1sD+S5yG5JIOIMWkegJ5ObkpCzLmNhllCerG3eRkUD5E2SXGncbl1D7aJOGVEXVglknRxjFfUgXBVoRwbOQ2OrZbJfOXExiIIEfEl/cQhIJZ7C0SBASpSeCkF2yu6SoyNa1WVbk1RMogaSGTNMF1djYmE1OALhQIC2Yd+KB07iPlSVJ0vZcS2Kwgh8SX2hBEglnsIiRqAL5cXAXIyEZ+DRcFHoChYXbo6a6OouceidJSxQt2C8xHLc7S2phl8z8qtH75d3SgCQSzqBJJEYC2WlAk2TgazVTt3EYVaDU19e7arcerASfCFsT+y1uwNs15WeN3m/v1i0kkXAGi3Ukdqvq6oF04Kvn0YzDqNecC+mxDDeTToQsIStNWoQ22gGpa4qWBeFnjd5v79YtJJFwBuuV7U61RjsDXy0L7iYOo0VbW1vWJldlABgyCdxawUuNkFST9qvWauSaomlBiNw3JEQpcvtZQBIJZ7AmEqcBTbsWCYsdFPWIyY0bw6ssITuadC5lMtG0IETU6O0SZS69WyvkJJE8+uijOHr0aOzRowcGg0Gi35w9exZnzpyJpaWl2L17dxwzZoyuxjVp0iTs1asXBoNBvOuuu/DEiRO22sar1paT7BySgU97grPU3Lwqy27neXIlk4n2exRRo7dLlLnybkmQk0Ty8MMP4+9+9zu8//77iYlkzpw5GAwG8cUXX8R33nkHJ0yYgBdffDGePHkydc748eNx+PDhuHXrVnz99ddx8ODBOHHiRFttE7n6L8nApz3BeWiePEudOH0ev5djYfEeRdLo3Yx7v79bEuQkkahYsmQJEZGcPXsWS0tLce7cualjx44dw0AggCtWrEBExD179mBmts/atWsxLy8PDx06RNwmkYlEhdXApznBRdQ83SDXnocULJ5bJI1eRFebSJBEgogtLS0IALhz586045WVlXjvvfciIuLixYsxFAqlff/VV19hfn4+vvDCC4bXPnXqFHZ0dKQ+ra2twhOJFWhPcJE0TxrItechBavnFkGjP1cVBFJIIkHEN954AwEAP/7447TjN998M95yyy2IiPjYY4/h0KFDs35bXFyMTz31lOG1Z82alSZw1Y+fiUQFrQkukuZJA7n2PKTI9ec+VxUEEtghkvPAQ8yYMQN++9vfmp6zd+9euPTSSzm1iAwPPfQQ3H///am/jx8/DhdddJGHLaKHIUOGwJAhQ1xfp3fv3vC3detg3759sH//fhg8eDCV63qFXHseUuT6cy9fsQL+feJEmNzQkDpWM3YsLF+xwsNW+Q+eEskvf/lLuOOOO0zPGTRokKNrl5aWAgDA0aNH4YILLkgdP3r0KJSVlaXO+eSTT9J+d+bMGWhvb0/9Xg+BQAACgYCjdp1roEVMoiDXnocUufrcuU6UvOApkRQXF0NxcTGTa1988cVQWloKGzZsSBHH8ePHobGxEe6++24AABg9ejQcO3YMtm/fDldffTUAAPzjH/+As2fPwqhRo5i0S0JCQjzkKlHyguJ1A0jx4Ycfwttvvw0ffvghdHZ2wttvvw1vv/02fPbZZ6lzLr30Uli1ahUAAOTl5cF9990Hjz76KLz00kvw7rvvwu233w79+vWDm266CQAALrvsMhg/fjxMmTIFtm3bBm+88QZMmzYNbr31VujXr58XjykhISHhO3hqkdjBww8/DMuWLUv9fdVVVwEAwMaNG+Haa68FAIDm5mbo6OhInfOrX/0KPv/8c5g6dSocO3YMIpEIrFu3Drp3754659lnn4Vp06bBmDFjQFEU+MEPfgB//OMf+TyUhISERA4gDxHR60b4HcePH4dgMAgdHR1QWFjodXMkJCQkXMOOXPONa0tCQkJCQkxIIpGQkJCQcAVJJBISEhISriCJREJCQkLCFXyTtSUy1HyF48ePe9wSCQkJCTpQ5RlJPpYkEgo4ceIEAEDOlEmRkJCQUHHixAkIBoOm58j0Xwo4e/YsfPzxx9CrVy/Iy8sj+o1an6u1tVWmDGdA9o0xZN8YQ/aNMZz0DSLCiRMnoF+/fqAo5lEQaZFQgKIocOGFFzr6bWFhoRz0BpB9YwzZN8aQfWMMu31jZYmokMF2CQkJCQlXkEQiISEhIeEKkkg8QiAQgFmzZsly9DqQfWMM2TfGkH1jDNZ9I4PtEhISEhKuIC0SCQkJCQlXkEQiISEhIeEKkkgkJCQkJFxBEomEhISEhCtIIpGQkJCQcAVJJJzw2GOPwbe//W04//zzIRQKEf0GEeHhhx+GCy64AHr06AFjx46Fffv2sW2oB2hvb4fbbrsNCgsLIRQKwY9//GP47LPPTH9z7bXXQl5eXtrnZz/7GacWs8WCBQvgG9/4BnTv3h1GjRoF27ZtMz3/+eefh0svvRS6d+8OV155JaxZs4ZTS/nDTt8sXbo0a4xot9nOFbz22mvwve99D/r16wd5eXnw4osvWv5m06ZNEA6HIRAIwODBg2Hp0qWu2iCJhBO+/PJLuPnmm+Huu+8m/s3jjz8Of/zjH2HhwoXQ2NgIX/va16C6uhpOnTrFsKX8cdttt8Hu3bvh73//O7z88svw2muvwdSpUy1/N2XKFDh8+HDq8/jjj3NoLVvEYjG4//77YdasWbBjxw4YPnw4VFdXwyeffKJ7/ptvvgkTJ06EH//4x7Bz50646aab4KabboL33nuPc8vZw27fACRKgmjHyAcffMCxxXzw+eefw/Dhw2HBggVE5x88eBBuuOEGuO666+Dtt9+G++67D37yk59AQ0OD80agBFcsWbIEg8Gg5Xlnz57F0tJSnDt3burYsWPHMBAI4IoVKxi2kC/27NmDAIBNTU2pY2vXrsW8vDw8dOiQ4e+i0Sj+4he/4NBCvigvL8d77rkn9XdnZyf269cPZ8+erXv+LbfcgjfccEPasVGjRuFPf/pTpu30Anb7hnSu5RIAAFetWmV6zq9+9Su8/PLL04796Ec/wurqasf3lRaJoDh48CAcOXIExo4dmzoWDAZh1KhRsGXLFg9bRhdbtmyBUCgEI0aMSB0bO3YsKIoCjY2Npr999tlnoW/fvnDFFVfAQw89BF988QXr5jLFl19+Cdu3b09754qiwNixYw3f+ZYtW9LOBwCorq7OqTEC4KxvAAA+++wzGDhwIFx00UVw4403wu7du3k0V2iwGDOy+q+gOHLkCAAAlJSUpB0vKSlJfZcLOHLkCHz9619PO3beeedBnz59TJ9z0qRJMHDgQOjXrx/s2rULHnzwQWhuboYXXniBdZOZ4dNPP4XOzk7dd/7+++/r/ubIkSM5P0YAnPXNsGHD4JlnnoFvfetb0NHRAfPmzYNvf/vbsHv3bsfVunMBRmPm+PHjcPLkSejRo4fta0qLxAVmzJiRFczL/BgN8lwH676ZOnUqVFdXw5VXXgm33XYb/PnPf4ZVq1ZBS0sLxaeQ8DNGjx4Nt99+O5SVlUE0GoUXXngBiouL4emnn/a6aTkHaZG4wC9/+Uu44447TM8ZNGiQo2uXlpYCAMDRo0fhggsuSB0/evQolJWVObomT5D2TWlpaVaw9MyZM9De3p7qAxKMGjUKAAD2798Pl1xyie32ioC+fftCfn4+HD16NO340aNHDfuitLTU1vl+hZO+yUS3bt3gqquugv3797Noom9gNGYKCwsdWSMAkkhcobi4GIqLi5lc++KLL4bS0lLYsGFDijiOHz8OjY2NtjK/vAJp34wePRqOHTsG27dvh6uvvhoAAP7xj3/A2bNnU+RAgrfffhsAII10/YaCggK4+uqrYcOGDXDTTTcBQGL3zQ0bNsC0adN0fzN69GjYsGED3Hfffaljf//732H06NEcWswPTvomE52dnfDuu+9CTU0Nw5aKj9GjR2eliLseM47D9BK28MEHH+DOnTuxrq4Oe/bsiTt37sSdO3fiiRMnUucMGzYMX3jhhdTfc+bMwVAohKtXr8Zdu3bhjTfeiBdffDGePHnSi0dghvHjx+NVV12FjY2NuHnzZhwyZAhOnDgx9f1HH32Ew4YNw8bGRkRE3L9/Pz7yyCP41ltv4cGDB3H16tU4aNAgrKys9OoRqGHlypUYCARw6dKluGfPHpw6dSqGQiE8cuQIIiJOnjwZZ8yYkTr/jTfewPPOOw/nzZuHe/fuxVmzZmG3bt3w3Xff9eoRmMFu39TV1WFDQwO2tLTg9u3b8dZbb8Xu3bvj7t27vXoEJjhx4kRKngAA/u53v8OdO3fiBx98gIiIM2bMwMmTJ6fOP3DgAJ5//vk4ffp03Lt3Ly5YsADz8/Nx3bp1jtsgiYQTamtrEQCyPhs3bkydAwC4ZMmS1N9nz57FmTNnYklJCQYCARwzZgw2NzfzbzxjtLW14cSJE7Fnz55YWFiId955ZxrBHjx4MK2vPvzwQ6ysrMQ+ffpgIBDAwYMH4/Tp07Gjo8OjJ6CL+fPn44ABA7CgoADLy8tx69atqe+i0SjW1tamnf/cc8/h0KFDsaCgAC+//HL829/+xrnF/GCnb+67777UuSUlJVhTU4M7duzwoNVssXHjRl3ZovZFbW0tRqPRrN+UlZVhQUEBDho0KE3uOIHcj0RCQkJCwhVk1paEhISEhCtIIpGQkJCQcAVJJBISEhISriCJREJCQkLCFSSRSEhISEi4giQSCQkJCQlXkEQiISEhIeEKkkgkJCQkJFxBEomEhISEhCtIIpGQEBQrVqyAHj16wOHDh1PH7rzzztT+GhISokCWSJGQEBSICGVlZVBZWQnz58+HWbNmwTPPPANbt26F/v37e908CYkUZBl5CQlBkZeXB4899hj88Ic/hNLSUpg/fz68/vrrKRL5/ve/D5s2bYIxY8bAX//6V49bK3EuQ1okEhKCIxwOw+7du2H9+vUQjUZTxzdt2gQnTpyAZcuWSSKR8BQyRiIhITDWrVsH77//vu5+5ddeey306tXLo5ZJSHRBEomEhKDYsWMH3HLLLbB48WIYM2YMzJw50+smSUjoQsZIJCQExD//+U+44YYb4Ne//jVMnDgRBg0aBKNHj4YdO3ZAOBz2unkSEmmQFomEhGBob2+H8ePHw4033ggzZswAAIBRo0bBd77zHfj1r3/tceskJLIhLRIJCcHQp08feP/997OO/+1vf/OgNRIS1pBZWxISPsXYsWPhnXfegc8//xz69OkDzz//PIwePdrrZkmcg5BEIiEhISHhCjJGIiEhISHhCpJIJCQkJCRcQRKJhISEhIQrSCKRkJCQkHAFSSQSEhISEq4giURCQkJCwhUkkUhISEhIuIIkEgkJCQkJV5BEIiEhISHhCpJIJCQkJCRcQRKJhISEhIQr/P+Hbb38tIDSMAAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import pennylane as qml\n",
+        "from pennylane import numpy as np\n",
+        "from pennylane.optimize import AdamOptimizer, GradientDescentOptimizer\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "\n",
+        "# Set a random seed\n",
+        "np.random.seed(42)\n",
+        "\n",
+        "\n",
+        "# Make a dataset of points inside and outside of a circle\n",
+        "def circle(samples, center=[0.0, 0.0], radius=np.sqrt(2 / np.pi)):\n",
+        "    \"\"\"\n",
+        "    Generates a dataset of points with 1/0 labels inside a given radius.\n",
+        "\n",
+        "    Args:\n",
+        "        samples (int): number of samples to generate\n",
+        "        center (tuple): center of the circle\n",
+        "        radius (float: radius of the circle\n",
+        "\n",
+        "    Returns:\n",
+        "        Xvals (array[tuple]): coordinates of points\n",
+        "        yvals (array[int]): classification labels\n",
+        "    \"\"\"\n",
+        "    Xvals, yvals = [], []\n",
+        "\n",
+        "    for i in range(samples):\n",
+        "        x = 2 * (np.random.rand(2)) - 1\n",
+        "        y = 0\n",
+        "        if np.linalg.norm(x - center) < radius:\n",
+        "            y = 1\n",
+        "        Xvals.append(x)\n",
+        "        yvals.append(y)\n",
+        "    return np.array(Xvals, requires_grad=False), np.array(yvals, requires_grad=False)\n",
+        "\n",
+        "\n",
+        "def plot_data(x, y, fig=None, ax=None):\n",
+        "    \"\"\"\n",
+        "    Plot data with red/blue values for a binary classification.\n",
+        "\n",
+        "    Args:\n",
+        "        x (array[tuple]): array of data points as tuples\n",
+        "        y (array[int]): array of data points as tuples\n",
+        "    \"\"\"\n",
+        "    if fig == None:\n",
+        "        fig, ax = plt.subplots(1, 1, figsize=(5, 5))\n",
+        "    reds = y == 0\n",
+        "    blues = y == 1\n",
+        "    ax.scatter(x[reds, 0], x[reds, 1], c=\"red\", s=20, edgecolor=\"k\")\n",
+        "    ax.scatter(x[blues, 0], x[blues, 1], c=\"blue\", s=20, edgecolor=\"k\")\n",
+        "    ax.set_xlabel(\"$x_1$\")\n",
+        "    ax.set_ylabel(\"$x_2$\")\n",
+        "\n",
+        "\n",
+        "Xdata, ydata = circle(500)\n",
+        "fig, ax = plt.subplots(1, 1, figsize=(4, 4))\n",
+        "plot_data(Xdata, ydata, fig=fig, ax=ax)\n",
+        "plt.show()\n",
+        "\n",
+        "\n",
+        "# Define output labels as quantum state vectors\n",
+        "def density_matrix(state):\n",
+        "    \"\"\"Calculates the density matrix representation of a state.\n",
+        "\n",
+        "    Args:\n",
+        "        state (array[complex]): array representing a quantum state vector\n",
+        "\n",
+        "    Returns:\n",
+        "        dm: (array[complex]): array representing the density matrix\n",
+        "    \"\"\"\n",
+        "    return state * np.conj(state).T\n",
+        "\n",
+        "\n",
+        "label_0 = [[1], [0]]\n",
+        "label_1 = [[0], [1]]\n",
+        "state_labels = np.array([label_0, label_1], requires_grad=False)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "V7G5KnMrwup-"
+      },
+      "source": [
+        "Simple classifier with data reloading and fidelity loss\n",
+        "=======================================================\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "Qa4S7lBSwup-"
+      },
+      "outputs": [],
+      "source": [
+        "dev = qml.device(\"lightning.qubit\", wires=1)\n",
+        "# Install any pennylane-plugin to run on some particular backend\n",
+        "\n",
+        "\n",
+        "@qml.qnode(dev, interface=\"autograd\")\n",
+        "def qcircuit(params, x, y):\n",
+        "    \"\"\"A variational quantum circuit representing the Universal classifier.\n",
+        "\n",
+        "    Args:\n",
+        "        params (array[float]): array of parameters\n",
+        "        x (array[float]): single input vector\n",
+        "        y (array[float]): single output state density matrix\n",
+        "\n",
+        "    Returns:\n",
+        "        float: fidelity between output state and input\n",
+        "    \"\"\"\n",
+        "    for p in params:\n",
+        "        qml.PauliZ(wires=0)\n",
+        "        qml.Rot(*x, wires=0)\n",
+        "        qml.Rot(*p, wires=0)\n",
+        "    return qml.expval(qml.Hermitian(y, wires=[0]))\n",
+        "\n",
+        "\n",
+        "def cost(params, x, y, state_labels=None):\n",
+        "    \"\"\"Cost function to be minimized.\n",
+        "\n",
+        "    Args:\n",
+        "        params (array[float]): array of parameters\n",
+        "        x (array[float]): 2-d array of input vectors\n",
+        "        y (array[float]): 1-d array of targets\n",
+        "        state_labels (array[float]): array of state representations for labels\n",
+        "\n",
+        "    Returns:\n",
+        "        float: loss value to be minimized\n",
+        "    \"\"\"\n",
+        "    # Compute prediction for each input in data batch\n",
+        "    loss = 0.0\n",
+        "    dm_labels = [density_matrix(s) for s in state_labels]\n",
+        "    for i in range(len(x)):\n",
+        "        f = qcircuit(params, x[i], dm_labels[y[i]])\n",
+        "        loss = loss + (1 - f) ** 2\n",
+        "    return loss / len(x)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aFRr7XOQwup_"
+      },
+      "source": [
+        "Utility functions for testing and creating batches\n",
+        "==================================================\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "pvQPJp9Xwup_"
+      },
+      "outputs": [],
+      "source": [
+        "def test(params, x, y, state_labels=None):\n",
+        "    \"\"\"\n",
+        "    Tests on a given set of data.\n",
+        "\n",
+        "    Args:\n",
+        "        params (array[float]): array of parameters\n",
+        "        x (array[float]): 2-d array of input vectors\n",
+        "        y (array[float]): 1-d array of targets\n",
+        "        state_labels (array[float]): 1-d array of state representations for labels\n",
+        "\n",
+        "    Returns:\n",
+        "        predicted (array([int]): predicted labels for test data\n",
+        "        output_states (array[float]): output quantum states from the circuit\n",
+        "    \"\"\"\n",
+        "    fidelity_values = []\n",
+        "    dm_labels = [density_matrix(s) for s in state_labels]\n",
+        "    predicted = []\n",
+        "\n",
+        "    for i in range(len(x)):\n",
+        "        fidel_function = lambda y: qcircuit(params, x[i], y)\n",
+        "        fidelities = [fidel_function(dm) for dm in dm_labels]\n",
+        "        best_fidel = np.argmax(fidelities)\n",
+        "\n",
+        "        predicted.append(best_fidel)\n",
+        "        fidelity_values.append(fidelities)\n",
+        "\n",
+        "    return np.array(predicted), np.array(fidelity_values)\n",
+        "\n",
+        "\n",
+        "def accuracy_score(y_true, y_pred):\n",
+        "    \"\"\"Accuracy score.\n",
+        "\n",
+        "    Args:\n",
+        "        y_true (array[float]): 1-d array of targets\n",
+        "        y_predicted (array[float]): 1-d array of predictions\n",
+        "        state_labels (array[float]): 1-d array of state representations for labels\n",
+        "\n",
+        "    Returns:\n",
+        "        score (float): the fraction of correctly classified samples\n",
+        "    \"\"\"\n",
+        "    score = y_true == y_pred\n",
+        "    return score.sum() / len(y_true)\n",
+        "\n",
+        "\n",
+        "def iterate_minibatches(inputs, targets, batch_size):\n",
+        "    \"\"\"\n",
+        "    A generator for batches of the input data\n",
+        "\n",
+        "    Args:\n",
+        "        inputs (array[float]): input data\n",
+        "        targets (array[float]): targets\n",
+        "\n",
+        "    Returns:\n",
+        "        inputs (array[float]): one batch of input data of length `batch_size`\n",
+        "        targets (array[float]): one batch of targets of length `batch_size`\n",
+        "    \"\"\"\n",
+        "    for start_idx in range(0, inputs.shape[0] - batch_size + 1, batch_size):\n",
+        "        idxs = slice(start_idx, start_idx + batch_size)\n",
+        "        yield inputs[idxs], targets[idxs]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UXDm5DPGwuqA"
+      },
+      "source": [
+        "Train a quantum classifier on the circle dataset\n",
+        "================================================\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "7qWNg8VnwuqA",
+        "outputId": "8552179e-b628-4b2b-b687-8cbe34ad72cd"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch:  0 | Cost: 0.443627 | Train accuracy: 0.530000 | Test Accuracy: 0.474000\n",
+            "Epoch:  1 | Loss: 0.293484 | Train accuracy: 0.580000 | Test accuracy: 0.570500\n",
+            "Epoch:  2 | Loss: 0.243133 | Train accuracy: 0.625000 | Test accuracy: 0.645000\n",
+            "Epoch:  3 | Loss: 0.240216 | Train accuracy: 0.650000 | Test accuracy: 0.656500\n",
+            "Epoch:  4 | Loss: 0.203238 | Train accuracy: 0.790000 | Test accuracy: 0.761500\n",
+            "Epoch:  5 | Loss: 0.180222 | Train accuracy: 0.795000 | Test accuracy: 0.817000\n",
+            "Epoch:  6 | Loss: 0.147093 | Train accuracy: 0.785000 | Test accuracy: 0.814000\n",
+            "Epoch:  7 | Loss: 0.150330 | Train accuracy: 0.775000 | Test accuracy: 0.738000\n",
+            "Epoch:  8 | Loss: 0.135163 | Train accuracy: 0.790000 | Test accuracy: 0.748500\n",
+            "Epoch:  9 | Loss: 0.102370 | Train accuracy: 0.900000 | Test accuracy: 0.856500\n",
+            "Epoch: 10 | Loss: 0.095256 | Train accuracy: 0.940000 | Test accuracy: 0.894000\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Generate training and test data\n",
+        "num_training = 200\n",
+        "num_test = 2000\n",
+        "\n",
+        "Xdata, y_train = circle(num_training)\n",
+        "X_train = np.hstack((Xdata, np.zeros((Xdata.shape[0], 1), requires_grad=False)))\n",
+        "\n",
+        "Xtest, y_test = circle(num_test)\n",
+        "X_test = np.hstack((Xtest, np.zeros((Xtest.shape[0], 1), requires_grad=False)))\n",
+        "\n",
+        "\n",
+        "# Train using Adam optimizer and evaluate the classifier\n",
+        "num_layers = 3\n",
+        "learning_rate = 0.6\n",
+        "epochs = 10\n",
+        "batch_size = 32\n",
+        "\n",
+        "opt = AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999)\n",
+        "\n",
+        "# initialize random weights\n",
+        "params = np.random.uniform(size=(num_layers, 3), requires_grad=True)\n",
+        "\n",
+        "predicted_train, fidel_train = test(params, X_train, y_train, state_labels)\n",
+        "accuracy_train = accuracy_score(y_train, predicted_train)\n",
+        "\n",
+        "predicted_test, fidel_test = test(params, X_test, y_test, state_labels)\n",
+        "accuracy_test = accuracy_score(y_test, predicted_test)\n",
+        "\n",
+        "# save predictions with random weights for comparison\n",
+        "initial_predictions = predicted_test\n",
+        "\n",
+        "loss = cost(params, X_test, y_test, state_labels)\n",
+        "\n",
+        "print(\n",
+        "    \"Epoch: {:2d} | Cost: {:3f} | Train accuracy: {:3f} | Test Accuracy: {:3f}\".format(\n",
+        "        0, loss, accuracy_train, accuracy_test\n",
+        "    )\n",
+        ")\n",
+        "\n",
+        "for it in range(epochs):\n",
+        "    for Xbatch, ybatch in iterate_minibatches(X_train, y_train, batch_size=batch_size):\n",
+        "        params, _, _, _ = opt.step(cost, params, Xbatch, ybatch, state_labels)\n",
+        "\n",
+        "    predicted_train, fidel_train = test(params, X_train, y_train, state_labels)\n",
+        "    accuracy_train = accuracy_score(y_train, predicted_train)\n",
+        "    loss = cost(params, X_train, y_train, state_labels)\n",
+        "\n",
+        "    predicted_test, fidel_test = test(params, X_test, y_test, state_labels)\n",
+        "    accuracy_test = accuracy_score(y_test, predicted_test)\n",
+        "    res = [it + 1, loss, accuracy_train, accuracy_test]\n",
+        "    print(\n",
+        "        \"Epoch: {:2d} | Loss: {:3f} | Train accuracy: {:3f} | Test accuracy: {:3f}\".format(\n",
+        "            *res\n",
+        "        )\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "2gr-eItywuqA"
+      },
+      "source": [
+        "Results\n",
+        "=======\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 397
+        },
+        "id": "S2h1poLxwuqB",
+        "outputId": "1108dbef-bd3c-408c-d9d7-f5a2d61876b8"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cost: 0.095256 | Train accuracy 0.940000 | Test Accuracy : 0.894000\n",
+            "Learned weights\n",
+            "Layer 0: [-3.55540916  1.57180038  0.08886767]\n",
+            "Layer 1: [-2.22903303  0.25325487 -2.12708616]\n",
+            "Layer 2: [ 1.02481564 -1.52639634  0.32099705]\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x300 with 3 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "print(\n",
+        "    \"Cost: {:3f} | Train accuracy {:3f} | Test Accuracy : {:3f}\".format(\n",
+        "        loss, accuracy_train, accuracy_test\n",
+        "    )\n",
+        ")\n",
+        "\n",
+        "print(\"Learned weights\")\n",
+        "for i in range(num_layers):\n",
+        "    print(\"Layer {}: {}\".format(i, params[i]))\n",
+        "\n",
+        "\n",
+        "fig, axes = plt.subplots(1, 3, figsize=(10, 3))\n",
+        "plot_data(X_test, initial_predictions, fig, axes[0])\n",
+        "plot_data(X_test, predicted_test, fig, axes[1])\n",
+        "plot_data(X_test, y_test, fig, axes[2])\n",
+        "axes[0].set_title(\"Predictions with random weights\")\n",
+        "axes[1].set_title(\"Predictions after training\")\n",
+        "axes[2].set_title(\"True test data\")\n",
+        "plt.tight_layout()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "e1r3N05JwuqB"
+      },
+      "source": [
+        "References\n",
+        "==========\n",
+        "\n",
+        "\\[1\\] Pérez-Salinas, Adrián, et al. \\\"Data re-uploading for a universal\n",
+        "quantum classifier.\\\" arXiv preprint arXiv:1907.02085 (2019).\n",
+        "\n",
+        "\\[2\\] Kingma, Diederik P., and Ba, J. \\\"Adam: A method for stochastic\n",
+        "optimization.\\\" arXiv preprint arXiv:1412.6980 (2014).\n",
+        "\n",
+        "\\[3\\] Liu, Dong C., and Nocedal, J. \\\"On the limited memory BFGS method\n",
+        "for large scale optimization.\\\" Mathematical programming 45.1-3 (1989):\n",
+        "503-528.\n",
+        "\n",
+        "About the author\n",
+        "================\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.17"
+    },
+    "colab": {
+      "provenance": []
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}