diff --git a/src/qiboml/interfaces/pytorch.py b/src/qiboml/interfaces/pytorch.py
index ec950e65..7546c5c4 100644
--- a/src/qiboml/interfaces/pytorch.py
+++ b/src/qiboml/interfaces/pytorch.py
@@ -51,6 +51,11 @@ def __post_init__(
 
         params = utils.get_params_from_circuit_structure(self.circuit_structure)
 
+        # Inform the Pytorch model that we are adding sub-modules here
+        for i, circ in enumerate(self.circuit_structure):
+            if isinstance(circ, QuantumEncoding) and circ.encoding_rule is not None:
+                self.add_module(f"enc{i}", circ.encoding_rule)
+
         params = torch.as_tensor(self.backend.to_numpy(x=params)).ravel()
         params.requires_grad = True
         self.circuit_parameters = torch.nn.Parameter(params)
diff --git a/src/qiboml/interfaces/utils.py b/src/qiboml/interfaces/utils.py
index 440f557e..d1ccaab2 100644
--- a/src/qiboml/interfaces/utils.py
+++ b/src/qiboml/interfaces/utils.py
@@ -20,6 +20,11 @@ def get_params_from_circuit_structure(
     for circ in circuit_structure:
         if not isinstance(circ, QuantumEncoding):
             params.extend([p for param in circ.get_parameters() for p in param])
+        else:
+            if circ.encoding_rule is not None:
+                params.extend(
+                    [p for param in circ.circuit.get_parameters() for p in param]
+                )
     return params
 
 
diff --git a/src/qiboml/models/encoding.py b/src/qiboml/models/encoding.py
index 76b218c4..621a522c 100644
--- a/src/qiboml/models/encoding.py
+++ b/src/qiboml/models/encoding.py
@@ -1,8 +1,8 @@
 import inspect
-from abc import ABC, abstractmethod
+from abc import ABC
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Optional
+from typing import Optional, Union
 
 import numpy as np
 from qibo import Circuit, gates
@@ -19,10 +19,14 @@ class QuantumEncoding(ABC):
     Args:
         nqubits (int): total number of qubits.
         qubits (tuple[int], optional): set of qubits it acts on, by default ``range(nqubits)``.
+        encoding_rule (Optional[Union["torch.nn.module", "keras.layers.Layer"]]): optional
+            trainable encoding rule which can be used to preprocess the data with some
+            classical model.
     """
 
     nqubits: int
     qubits: Optional[tuple[int]] = None
+    encoding_rule: Optional[Union["torch.nn.module", "keras.layers.Layer"]] = None
 
     _circuit: Circuit = None
 
@@ -44,10 +48,11 @@ def _data_to_gate(self):
             f"_data_to_gate method is not implemented for encoding {self}.",
         )
 
-    @abstractmethod
     def __call__(self, x: ndarray) -> Circuit:
         """Abstract call method."""
-        pass
+        if self.encoding_rule is not None:
+            return self.encoding_rule(x)
+        return x
 
     @property
     def circuit(
@@ -107,6 +112,9 @@ def __call__(self, x: ndarray) -> Circuit:
         Returns:
             (Circuit): the constructed ``qibo.Circuit``.
         """
+        # Applying encoding rule if we have one
+        x = super().__call__(x)
+
         circuit = self.circuit
         x = x.ravel()
         for i, q in enumerate(self.qubits):
@@ -133,6 +141,9 @@ def __call__(self, x: ndarray) -> Circuit:
                 RuntimeError,
                 f"Invalid input dimension {x.shape[-1]}, but the allocated qubits are {self.qubits}.",
             )
+
+        x = super().__call__(x)
+
         circuit = self.circuit
         x = x.ravel()
         for i, q in enumerate(self.qubits):
diff --git a/tests/test_interfaces.py b/tests/test_interfaces.py
index 63d47335..9ab256e0 100644
--- a/tests/test_interfaces.py
+++ b/tests/test_interfaces.py
@@ -3,6 +3,9 @@
 
 import numpy as np
 import pytest
+import tensorflow as tf
+import torch
+import torch.nn as nn
 from qibo import hamiltonians
 from qibo.config import raise_error
 from qibo.symbols import Z
@@ -13,6 +16,25 @@
 from qiboml.operations.differentiation import PSR
 
 
+class TorchLinearEncoding(nn.Module):
+    """Activation function which helps in giving more sensitivity around zero."""
+
+    def __init__(self):
+        super().__init__()
+        self.param1 = nn.Parameter(torch.tensor(np.random.randn()))
+        self.param2 = nn.Parameter(torch.tensor(np.random.randn()))
+
+    def forward(self, x):
+        return self.param1 * torch.tensor(x) + self.param2
+
+
+def construct_linear_encoding(frontend):
+    if frontend.__name__ == "qiboml.interfaces.pytorch":
+        return TorchLinearEncoding()
+    elif frontend.__name__ == "qiboml.interfaces.keras":
+        pytest.skip("Trainable encoding are supported by Pytorch interface only.")
+
+
 def get_layers(module, layer_type=None):
     layers = []
     for _, layer in inspect.getmembers(module, inspect.isclass):
@@ -282,8 +304,9 @@ def backprop_test(frontend, model, data, target):
     # specific (rare) cases
 
 
+@pytest.mark.parametrize("encoding_rule", [False, True])
 @pytest.mark.parametrize("layer,seed", zip(ENCODING_LAYERS, [6, 4]))
-def test_encoding(backend, frontend, layer, seed):
+def test_encoding(backend, frontend, encoding_rule, layer, seed):
     set_device(frontend)
     set_seed(frontend, seed)
 
@@ -308,7 +331,14 @@ def test_encoding(backend, frontend, layer, seed):
         backend=backend,
     )
 
-    encoding_layer = layer(nqubits, random_subset(nqubits, dim))
+    enc_rule = None
+    if encoding_rule:
+        enc_rule = construct_linear_encoding(frontend)
+    encoding_layer = layer(
+        nqubits=nqubits,
+        qubits=random_subset(nqubits, dim),
+        encoding_rule=enc_rule,
+    )
 
     circuit_structure = [encoding_layer, training_layer]
 
diff --git a/tutorials/advanced_qru.ipynb b/tutorials/advanced_qru.ipynb
index dc9af42d..98a5e50c 100644
--- a/tutorials/advanced_qru.ipynb
+++ b/tutorials/advanced_qru.ipynb
@@ -2,10 +2,25 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 1,
    "id": "d7897ca2-9edf-4b32-b436-9b0fabdcb7dc",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2025-05-16 10:52:56.932989: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
+      "E0000 00:00:1747385576.952368   43518 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "E0000 00:00:1747385576.958127   43518 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+      "W0000 00:00:1747385576.972702   43518 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1747385576.972726   43518 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1747385576.972729   43518 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n",
+      "W0000 00:00:1747385576.972730   43518 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n"
+     ]
+    }
+   ],
    "source": [
     "import torch\n",
     "import numpy as np\n",
@@ -16,7 +31,7 @@
     "\n",
     "from qibo import Circuit, gates, hamiltonians, set_backend, construct_backend\n",
     "\n",
-    "from qiboml.models.encoding import TrainableEncoding\n",
+    "from qiboml.models.encoding import PhaseEncoding\n",
     "from qiboml.models.decoding import Expectation\n",
     "from qiboml.interfaces.pytorch import QuantumModel\n",
     "from qiboml.operations.differentiation import PSR, Jax"
@@ -24,7 +39,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 3,
+   "id": "2067b685-6481-4c77-8390-9c161a8de7f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ScaledTanhEncoding(nn.Module):\n",
+    "    \"\"\"Non-linear encoding layer using f(x) = (pi/2) * (tanh(a * x + b) + 1)\"\"\"\n",
+    "    def _init_(self):\n",
+    "        super()._init_()\n",
+    "        self.a = nn.Parameter(torch.tensor(np.random.randn()))\n",
+    "        self.b = nn.Parameter(torch.tensor(np.random.randn()))\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return (torch.pi / 2) * (torch.tanh(self.a * x + self.b) + 1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
    "id": "5c7218b3-0f3f-4734-91bc-3be6907e5665",
    "metadata": {},
    "outputs": [
@@ -32,14 +65,14 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "[Qibo 0.2.17|INFO|2025-04-02 18:26:51]: Using qiboml (pytorch) backend on cpu\n"
+      "[Qibo 0.2.19|INFO|2025-05-16 10:54:41]: Using qiboml (pytorch) backend on cpu\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 360x60 with 1 Axes>"
+       "<Figure size 480x60 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -50,7 +83,7 @@
     "set_backend(\"qiboml\", platform=\"pytorch\")\n",
     "\n",
     "nqubits = 1\n",
-    "nlayers = 3\n",
+    "nlayers = 4\n",
     "\n",
     "gates_list = []\n",
     "for _ in range(nlayers):\n",
@@ -66,13 +99,23 @@
     "    def forward(self, x):\n",
     "        return self.param1 * x + self.param2 \n",
     "\n",
+    "class ScaledTanhEncoding(nn.Module):\n",
+    "    \"\"\"Non-linear encoding layer using f(x) = (pi/2) * (tanh(a * x + b) + 1)\"\"\"\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.p1 = nn.Parameter(torch.tensor(np.random.randn()))\n",
+    "        self.p2 = nn.Parameter(torch.tensor(np.random.randn()))\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return (torch.pi / 2) * (torch.tanh(self.p1 * x + self.p2) + 1)\n",
+    "\n",
     "circuit_structure = []\n",
     "for k in range(2 * nlayers):\n",
     "    circuit_structure.append(\n",
-    "        TrainableEncoding(\n",
+    "        PhaseEncoding(\n",
     "            nqubits=nqubits,\n",
     "            encoding_gate=gates_list[k],\n",
-    "            encoding_rule=LinEncoding()\n",
+    "            encoding_rule=ScaledTanhEncoding()\n",
     "        )\n",
     "    )\n",
     "\n",
@@ -92,17 +135,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 8,
    "id": "86e30597-1263-438e-b0be-669539f5e19a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "tensor([[-0.3648]], dtype=torch.float64, grad_fn=<ViewBackward0>)"
+       "tensor([[-0.2908]], dtype=torch.float64, grad_fn=<ViewBackward0>)"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -113,17 +156,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 9,
    "id": "5e01b6ee-3fb4-4a7a-ab8c-697a1f3e6223",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_43518/4177352912.py:3: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n",
+      "  return np.exp(-100 * x**2)\n"
+     ]
+    }
+   ],
    "source": [
     "# Prepare the training dataset (using f(x) = sin(x) as the target function)\n",
     "def f(x):\n",
-    "    return 1 * torch.sin(x)  ** 2 - 0.3 * torch.cos(x) \n",
+    "    return np.exp(-100 * x**2)\n",
     "\n",
     "num_samples = 30\n",
-    "x_train = torch.linspace(0, 2 * np.pi, num_samples, dtype=torch.float64).unsqueeze(1)\n",
+    "x_train = torch.linspace(-1, 1 * np.pi, num_samples, dtype=torch.float64).unsqueeze(1)\n",
     "y_train = f(x_train)\n",
     "\n",
     "y_train = 2 * ( (y_train - min(y_train)) / (max(y_train) - min(y_train)) - 0.5 )"
@@ -131,7 +183,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 10,
    "id": "159cc515-65c4-4253-81db-d05f69996807",
    "metadata": {},
    "outputs": [],
@@ -142,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 11,
    "id": "10dcc7d7-c815-4529-a263-94d971b18fec",
    "metadata": {},
    "outputs": [
@@ -150,21 +202,21 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 0: Loss = 0.5993975481284752\n",
-      "Epoch 10: Loss = 0.12252327845965834\n",
-      "Epoch 20: Loss = 0.07329363271579338\n",
-      "Epoch 30: Loss = 0.07043200035156119\n",
-      "Epoch 40: Loss = 0.0588899228983448\n",
-      "Epoch 50: Loss = 0.04871306095020045\n",
-      "Epoch 60: Loss = 0.0385619181796812\n",
-      "Epoch 70: Loss = 0.032604775809823947\n",
-      "Epoch 80: Loss = 0.02820677441691633\n",
-      "Epoch 90: Loss = 0.02133313950283989\n",
-      "Epoch 100: Loss = 0.011316878169964243\n",
-      "Epoch 110: Loss = 0.007488550917430618\n",
-      "Epoch 120: Loss = 0.005002061413425241\n",
-      "Epoch 130: Loss = 0.003815110873085329\n",
-      "Epoch 140: Loss = 0.003180398051808933\n"
+      "Epoch 0: Loss = 0.43326687095072436\n",
+      "Epoch 10: Loss = 0.09300460665961802\n",
+      "Epoch 20: Loss = 0.07425949452394366\n",
+      "Epoch 30: Loss = 0.05113369700618761\n",
+      "Epoch 40: Loss = 0.03155547188785586\n",
+      "Epoch 50: Loss = 0.016159165187507034\n",
+      "Epoch 60: Loss = 0.006731749857651871\n",
+      "Epoch 70: Loss = 0.0028512539789306525\n",
+      "Epoch 80: Loss = 0.0013262792301996578\n",
+      "Epoch 90: Loss = 0.0006799866197943002\n",
+      "Epoch 100: Loss = 0.00039044099141931967\n",
+      "Epoch 110: Loss = 0.00024542513229722283\n",
+      "Epoch 120: Loss = 0.0001665639177986766\n",
+      "Epoch 130: Loss = 0.00012070314681404505\n",
+      "Epoch 140: Loss = 9.22423861532966e-05\n"
      ]
     }
    ],
@@ -186,13 +238,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 12,
    "id": "5f0adefa-bc35-4d03-ac4d-6b6408410879",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x300 with 1 Axes>"
       ]
@@ -252,7 +304,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.0"
+   "version": "3.11.11"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/vqe.ipynb b/tutorials/vqe.ipynb
index a3c94387..794d9b6a 100644
--- a/tutorials/vqe.ipynb
+++ b/tutorials/vqe.ipynb
@@ -2,21 +2,10 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 18,
    "id": "530347f0-6842-4f70-a55f-b72c08f37150",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2025-03-27 09:41:30.075430: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:477] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
-      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
-      "E0000 00:00:1743064890.095145  143577 cuda_dnn.cc:8310] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
-      "E0000 00:00:1743064890.101059  143577 cuda_blas.cc:1418] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import torch\n",
     "import numpy as np\n",
@@ -42,28 +31,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 19,
    "id": "c5749a25-77ba-481e-96c7-c6e75055a92d",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "[Qibo 0.2.17|INFO|2025-03-27 09:41:31]: Using qiboml (pytorch) backend on cpu\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "set_backend(\"qiboml\", platform=\"pytorch\")\n",
-    "\n",
     "nqubits = 4\n",
     "nlayers = 3"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 20,
    "id": "82d6bbfd-a766-45da-820f-6fdb271f110d",
    "metadata": {},
    "outputs": [],
@@ -81,7 +60,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 21,
    "id": "f807a1c8-b92f-48d0-99f5-1994954f4891",
    "metadata": {},
    "outputs": [],
@@ -93,19 +72,20 @@
     "decoding = Expectation(\n",
     "    nqubits=nqubits,\n",
     "    observable=hamiltonian,\n",
-    "    backend=construct_backend(\"qiboml\", platform=\"pytorch\")\n",
+    "    # backend=construct_backend(\"qiboml\", platform=\"pytorch\")\n",
+    "    backend = construct_backend(\"numpy\")\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 22,
    "id": "051c51c4-66a7-439e-ad74-4315a5e6e59e",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABRwAAADMCAYAAAARZG/5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYYNJREFUeJzt3Xlcjen/P/DXaaEytpHKFpIlslSEQZYsYyuyV0ZZku3bh7EMsjP2kTH2rakwM6WIkH2GsY0oMcVYGozBhBKN1vv3h1+NtJ1zuk/3OafX8/G4Hx5zznVf52U6XW/nOvd9XTJBEAQQERERERERERERiUBH6gBERERERERERESkPTjhSERERERERERERKLhhCMRERERERERERGJhhOOREREREREREREJBpOOBIREREREREREZFoOOFIREREREREREREouGEIxEREREREREREYmGE45EREREREREREQkGk44EhERERERERERkWg44UhERERERERERESi4YQjERERERERERERiYYTjkRERERERERERCQaTjgSERERERERERGRaDjhSERERERERERERKLhhCMRERERERERERGJRk/qAKXh4cOHSExMlDoGAMDY2Bjm5uZFtlGnvB+SJzsREb2nbmM56w8RUdmgbmM56w8RUdmk9ROODx8+hJWVFVJTU6WOAgAwMjJCXFxcoYVL3fJ+qLjsRET0njqO5aw/RETaTx3HctYfIqKySesnHBMTE5GamoqgoCBYWVlJmiUuLg7u7u5ITEwstGipU94PyZOdiIjeU7exnPWHiKhsULexnPWHiKjs0voJxxxWVlawtbWVOobcNC0vERHlp4ljuSZmJiKivDRxLNfEzEREVLgyM+FIRERlx7179/DDDz/gt99+Q0xMDF6+fAkAMDc3R5s2beDg4IAhQ4agQoUKEiclIiJtcuXKFYSGhuLatWu4desW3rx5Ax0dHTRs2BD29vbo2bMn+vTpAz09fgwjIiJxZGVl4dixY4iMjERUVBTu3LmDd+/e4ZNPPkGzZs1ga2uLAQMGoH379pDJZKWWi7tUExGR1oiJiUGfPn3QsGFDrFq1Cm/fvsWQIUPg4eGB169fo2HDhoiJicHo0aNRq1YtzJgxAykpKVLHJiIiDRcREYE2bdqgbdu28Pf3h6GhIcaMGQMPDw8kJSWhWrVqOHHiBJydnWFhYYH169cjKytL6thERKTBsrOzsXnzZlhaWqJfv344cuQIzM3NMXjwYLx58wb9+/dHxYoVsWfPHnTo0AG2trY4cOBAqeXjhCMREWm8rKwsLF68GK1bt0ZCQgJ27tyJv//+GydOnMCqVaswatQoAICvry+ioqJw//59eHt7Y9OmTWjRogXOnj0r7V+AiIg0UnJyMkaNGoV+/fqhYsWKOHToEP766y8cPHgQixcvzq0/y5Ytw+3bt3H16lU4Ojpi6tSp6NixI/744w+J/wZERKSJHjx4gK5du2LixIno0KEDLl++jD/++AP79u3DuHHjAADe3t4ICwvDo0ePcOzYMZiYmGDgwIEYMWJE7h1gqsQJRyIi0mgZGRkYMWIEFi9ejNmzZyM6Ohqenp4wMjIq9Jx69ephxYoViI2NRb169dCjRw/88MMPpZiaiIg0XWJiIrp06YIDBw5g9+7dOHXqFPr16wddXd1Cz7Gzs8Pu3btx/vx5vHjxAu3atUNUVFQppiYiIk0XGxuLdu3a4eHDhzhz5gyCgoJgb29f6O3SOjo66NWrF44dO4a9e/ciMjISDg4OePr0qUpzKjXhuHDhQshkMiQkJIgch4iISDHjx49HWFgYQkJCsHjxYpQrV07ucy0sLHDixAkMHz4c7u7uOH78uAqTEhGRtkhLS0OfPn3w119/4fz58/Dw8FBoXazPPvsMly9fhqWlJXr16oV79+6pMC0REWmLR48eoUePHqhZsyauXLmCLl26yH2uTCbDiBEjcPHiRbx69Qq9evVCamqqyrKq/RWOkZGRkMlkKrvyJCEhATKZLM+hr6+PWrVqYejQobh69SoAwM/PDzKZDJ6enoX2dfbsWejo6KBNmzbIzMxUSV5FMufw9/fP176wQ5E3KxGR1Pbv34/du3dj+/btGDBggFJ96OnpYffu3XB0dISnpydevXolbshCsP6w/hCR5lq8eDGio6Nx9OhRNG/eXKk+qlatiqNHj6JSpUoYPXo0srOzRU5ZME2rP6w9RETvCYKAcePGQU9PD8ePH0f16tWV6qdx48aIjIzEnTt3MHfuXJFT/kftt0fr1q0bKleujAMHDmD48OEqe50GDRrA3d0dAPD27VtERUUhODgYBw4cwMmTJ+Hj44ODBw/C398fLi4u6N+/f57z37x5A09PT5QvXx4BAQGlsvNccZkdHBwAAK1atcKCBQuK7Gvjxo1ITExEs2bNVJ6biEgMKSkpmDhxIgYMGJC7Rpay9PT0sHPnTlhbW+Orr77C1q1bRUpZPNYf1h8i0iyxsbFYuXIlFi5cCDs7uxL19emnn2LXrl3o2rUrduzYAS8vL5FSFk/T6g9rDxGVdTm3Qx85ckTpycYc1tbWWLZsGaZPnw5XV1e0adNGpJQfEJSwYMECAYDw4MEDZU5XmKurq1CxYkXh3bt3Cp8bFRUlABCioqIKfP7BgwcCAKFXr175nlu+fLkAQHBwcBAEQRASEhKESpUqCaampkJiYmKetl5eXgIAYd26dUpnkbeNIpnlsWbNGgGAYGdnJ/z7779K5yIiKk2bN28WdHR0hD///LPYtvKOYStWrBDKly8v/PPPPyXKJvZYzvrD+kNE6mPs2LFC7dq1hfT09GLbyjuGDRkyRGjcuLGQnZ1domzaWH+kqD3yZiciKi3Z2dlCq1athL59+xbbVt7xKzMzU7C0tBRcXV3FipmH6LdUp6amYsmSJWjUqBEMDAxgYWGBtWvX4vr165DJZJgxY4bCfbq4uCAlJQWnTp0SO26RxowZAwC5CznXrVsXfn5+ePbsGSZMmJDbLjIyEtu2bUPXrl3h4+NTqhk/9nHm4pw8eRKzZs2CiYkJwsLCYGBgoMp4RESi2bJlC5ycnGBubi5anzljqL+/v2h9liQH6w8RkXp5/fo19uzZA29vb+jr64vW76RJk3D79m2cPXtWtD6VoWn1h7WHiMqKK1euIDo6GpMnTxatT11dXUyYMAHBwcH4559/ROs3h6gTjikpKejcuTPmz5+POnXqwMfHBzY2NpgxYwZmz54NALCxsVG4388//xwGBgYICwsTM67cPrw9wNPTE05OTggODsa+ffuQlJSEsWPHolKlSti9e7dCi0Wrkjy3NNy/fx/Dhg2DTCZDcHAw6tSpUwrJiMRx48YNjB49GkOGDMG3335bausekXp48eIFYmJiMGTIEFH7NTY2Rrdu3XDmzBlR+1UW6w+R+omIiICbmxtcXV0l+7cpSefy5cv4999/Ra8/Dg4OMDExYf1REmsPaTtBELBlyxYMHToUnp6e+dYuJe13+vRpVKpUCT179hS13yFDhiAjIwMXLlwQtV9A5DUcR48ejWvXriEwMDB3fQ0AWLNmTe6Vja1atVK43woVKqBnz54IDw/H1q1boaNTOnvd7NixAwDQsWPHPI9v27YNFy5cwKRJk+Dg4IDHjx9j165dqFu3bqnkKkphmT/29u1bDBgwAC9fvsSGDRty1zwh0gTXrl3DZ599hszMTAiCgJCQENy8eRPbtm2TOhqVkmvXrgEAWrduLXrfrVu3xtatWyEIgmQfolh/iNRTUFAQRo4cCV1dXQiCgH379mHbtm0YN26c1NGolERFRaFSpUqwtLQUtV+ZTAY7OzvJJxE0rf6w9lBZ8eWXX2LdunXQ0dGBTCbDnj178PPPP6N9+/ZSR6NSEhUVBVtbW9Hnw2rXrg0TExNcvXoVzs7OovYt2oTjqVOnEBISAm9v7zyTjQAwatQozJgxA4aGhmjcuLFS/bu4uCA8PBwXLlwotKDkfAD9UFxcnFz93717FwsXLgTw3yLEZ86cgampKVavXp2nrampKbZu3YpBgwbh4MGDcHJyKnL3NkUyyZtX0cwf8/DwQGxsLDw9PRW6JFeRfESq8uWXXyIjIyPPVY3bt2+Hs7MzatSoIWEyKi05t5y9fv26wLH/Y9HR0Xn+LEq5cuXw/PlzXLhwAYaGhkrlU9VYzvpDJK2pU6cCALKysnIf+/LLL0u8cQhpjitXrqBWrVpy1RNAsfpTtWpVXLhwQa66Vhhtrj9S1B5F8hGpyqtXr7Bu3ToAyP38k5WVhalTp2LTpk1SRqNSdOvWLTRt2lT0zz4AUKtWLURFRSlUf2xtbYtvpMzCjwVtGjNw4EABgHD//v187TMzMwUAgr29fZ7H/fz8BHNzc6F8+fJChw4dhOjo6EJf88WLF4Kenp4wbdq0QtsAKPQobhHigg4zMzPhjz/+KPT17O3tBQDC77//XmibD+Us3CnPIc9Cz8pkFgRBWLp0qQBAaNu2rdwb8SiSnQcPHjx4vD9UNZaz/vDgwYMHj6IObao/UtQeRbPz4MGDR1k75CHaFY4nT56EpaUl6tevn++5v//+G0De9Rv37t2LWbNmYdu2bbCzs8Pq1avRq1cv3LlzB5UqVcrXx6efforGjRsXeV95QYsFx8XF5bvisiC9evXCsWPHAAD//PMPvv/+e8yaNQtOTk64cuUKPvnkk3zn5Fz5ougVMEFBQbCysirwOXnzKps5IiIC8+fPh5mZGfbv34/y5cuLlp2otKxbtw579uyBIAi5jxkZGeHo0aMFvu9J+xw+fBgLFizA+fPn5RqDjxw5gnnz5mHJkiXo06dPkW1DQ0Px9ddf49KlS3KtCVUQVY/lrD9E0hg7dixu3LiRe4WjTCZD48aNsWfPHomTUWlZvXo1Ll26hP3798vVXpH6s2zZMty8eRP79u1TOp821x8pak9x2YlKw7t379C7d2+kpKTkfv6RyWRwcXHBnDlzJE5HpcXT0xO1atXC0qVLi22rSO0BAHd3dzRq1Ajz588XI2ouUSYck5KSkJKSUuhaWidPngSQd/3GdevWwdvbG1988QWA9+tvmJmZYe/evfD29s7Xx7NnzxAXF1fkLtdyXdIph+rVq2P69OlITk7G0qVL4evrCz8/P1H6BgArKyvRsuaQJ/OdO3fg5uYGPT09hISEoFatWgq/jiqyEylq69at+Ouvv3IXVjcwMMCBAwe4Hk8ZIpPJsGDBAshkMrnGpJzboerXr19s++3bt6Np06awt7cXJasiWH8Kx/pD6iA0NBSOjo64f/8+AMDExATh4eFo2LChxMmotDg6OuKnn35C48aNUaFChWLbK1J/Hj16hHbt2kky1mla/Smt2gOw/pB6OHToEPr374/Xr18DAJo3b47du3ejYsWKEiej0tK+fXucP39e9M8+6enpuH//Pry9vUUf60RZbVJfXx8A8PLly3zPpaenY9WqVQD+u8IxPT0d169fR/fu3XPb6enpoUuXLrh48WKBr3Hw4EFkZ2dj4MCBYkSWy5w5c1CzZk1s2rQJCQkJpfa6JVFY5tevX8PZ2RnJycn49ttv0aFDB+lCEpWQkZERTpw4AX9/fwBAeHg4evToIW0oKlXNmjVD+fLlcf78eVH7FQQBv/76q+TrsbH+EKmnevXq4caNG9i+fTsAIDg4mJONZUzr1q2RnZ2Ny5cvi9rv69evERMTw/qjINYeKiscHBxw9+7d3DUbt2/fzsnGMqZ169aIi4vDixcvRO03KioKaWlpKqk/okw4VqhQAXXr1kVsbCxiY2NzH09LS4OHhwfi4uKgo6OD5s2bAwASExORlZUFU1PTPP2YmJjg6dOnBb5GaGgoatasWapXnBgaGmLWrFnIyMjAkiVLSu11S6KgzIIgwN3dHfHx8fDy8sL48eMlTklUcrq6urljSrVq1SROQ6WtXLlyGDhwIHbu3Jnn1vqS+u233xAbG4thw4aJ1qcyWH+I1FeFChVyrwCQ5wo30i4tWrRAo0aNcndHFktQUBCysrLg4uIiar+K0rT6w9pDZUn16tXRtm1bAFB62R/SXE5OTtDT08u96EYsO3bsgLm5Odq1aydqv4CIu1RPnz4dU6ZMgYODA4YPHw4DAwOEh4fDwsICBgYGqF+/PoyMjJTqOzk5GadPn8a4ceMgk8nEiiwXLy8vrFy5EgEBAZgzZw4aNGhQqq+vjI8zh4aG4tChQyhXrhyqVauWu7tbYYp7nohIHUycOBEODg4IDw+Hs7OzKH2uXr0a9evXR69evUTpryRYf4iI1I+Ojg4mTJiAmTNnYunSpbCwsChxn2lpafj222/h7OyM2rVri5CyZDSt/rD2EFFZYGJigiFDhmDDhg2YMGGC0vNrH3r8+DH27dsHX19f6OrqipAyL9EmHCdNmoSkpCRs2bIFu3btgoWFBcaPHw9nZ2c0adIkz/qNxsbG0NXVxbNnz/L08fz5c5iZmeXrOyIiAhkZGaV6O3UOAwMDzJ49G1OmTMGiRYsQEBBQ6hkU9XFmHZ33F7Kmp6dj+fLlxZ7PoktEmqBjx47o1asXJk6ciM6dO6NKlSol6i8sLAwhISEIDAxUScFVFOsPEZF6Gjt2LNavX4/Ro0fj9OnTuWOdspYuXYp79+7hp59+EilhyWha/WHtIaKyYt68eWjVqhXmzZuHtWvXlqgvQRDg5eWFqlWrYsKECSIlzEu0CUeZTAZfX1/4+vrmeTw0NBRA3h2qy5UrBxsbG5w6dQr9+vUDAGRmZuLs2bMF7rgTFhaGqlWrokuXLmLFzVWvXr1ib8ebPHkyJk+enO/xs2fPip5HHspkFvuyWyIiqclkMmzfvh3W1tYYNWoU9u/fr/TtJbdv34aXlxecnJzg5uYmctKCsf4QEWmmTz75BDt37oSjoyMWLlyIxYsXK93X0aNHsXz5csyfPx8tWrQQMWXhNK3+sPYQEb3XuHFjLFmyBDNnzkTHjh1LdFHeqlWrcPToURw+fBhVq1YVMeV/RFnDsSgxMTEA8u5QDQBTp07Fli1bEBQUhN9//x1eXl7Q09ODq6trnnbv3r3D0aNH0a9fP65TQEREedSpUwf79u3DkSNHMHToULx580bhPqKjo9G1a1eYmJhg165dpb50BxERaZ5u3bph+fLlWLJkCXx9fZGVlaVwH6GhoRg4cCD69u2L2bNnqyAlERFpm6lTp2Lo0KEYNmwY9u7dq/D52dnZWLp0Kb766ivMmzcPffv2VUHK91Q+4RgdHQ0g7xWOAODq6ooVK1Zgzpw5sLGxwe3btxEZGYlKlSrlaXfu3DkYGBhg8ODBqo5KREQaqE+fPjhw4AAiIyPRokULnD59Wq7z0tPTsWTJEtjb28PMzAynT5/mBkRERCS3r776CitWrMDXX38NBwcHxMfHy3Xeq1ev4OnpiUGDBqF///746aefoK+vr+K0RESkDXR1dREYGIhhw4bBzc0Nbm5uSExMlOvce/fuwdHREfPmzcPChQuxaNEilWYtlSsca9WqBWNj43zP+fj44OHDh0hLS8Ovv/6Kli1b5mvTo0cPJCYmwsnJSdVRiYhIQ/Xt2xc3btxAnTp14OjoiHbt2mHXrl24f/9+ntuwMjMz8dtvv8HX1xd16tTBokWLMGPGDFy8eBGmpqYS/g2IiEgTzZo1Cz///DOeP3+Opk2bon///ggLC8PTp0/ztPv3339x9uxZeHl5oXbt2ggNDcWOHTvw008/oXz58hKlJyIiTaSvr4+AgAAEBgbi6NGjMDc3x+jRo3Hq1CkkJyfnafv8+XOEh4dj4MCBaNSoERISEnDq1CksWLBA5Xd2KXWPcs5aivIs0J+QkKDMSxARESmkQYMGOHPmDA4dOoRNmzZhzJgxAN7XqnLlygEAxowZg6ysLFSqVAlffPEFJk6cCCsrKyljExGRhuvUqRNu3LiBPXv2YOPGjXBxcQHwfkfRHOPGjQMA1KpVC7NmzYKXl1eBm2USERHJQyaTwd3dHb169cKOHTuwZcsW7N69GwBy12ScNGlS7gRk8+bNsXHjRowcORIVKlQolYxKTziqYgMXIiKiktDR0YGzszOcnZ3x/PlzREVFITo6GhcuXMDhw4fh7u6OiRMnokWLFjAwMJA6LhERaQlDQ0OMHTsWY8aMwZ9//omoqCjcvHkTv/32GyIiIuDl5YUpU6bAysoKurq6UsclIiItUb16dcyePRszZ87E7du3ERUVhf379+PgwYNwdHTE8OHDYWdnh/r165f6WvXchYWIiLSSiYkJevfujd69e+PXX3/F4cOHMW7cONjb20sdjYiItJRMJkO9evVQr149DBo0CL/++isiIiLwxRdfwNraWup4RESkpXR1ddG0aVM0bdoUFhYWOHjwIKZNm4YOHTpIlqnMTDjGxcVJHUGhDOqQ90PqloeISBGGhoZ5/iwt6jJ2sv4QEUmD9Yf1h4iotElVez6m9ROOxsbGMDIygru7u9RRAABGRkYFbqCTQ93yfqi47ERE9J46juWsP0RE2k8dx3LWHyKisknrJxzNzc0RFxcn9zbhqmZsbAxzc/NCn1e3vB8qLjsREb2njmM56w8RkfZTx7Gc9YeIqGzS+glH4H0R06RCoWl5iYgoP00cyzUxMxER5aWJY7kmZiYioqLpSB2AiIiIiIiIiIiItAcnHImIiIiIiIiIiEg0nHAkIiIiIiIiIiIi0XDCkYiIiIiIiIiIiETDCUciIiIiIiIiIiISDScciYiIiIiIiIiISDSccCQiIiIiIiIiIiLRcMKRiIiIiIiIiIiIRMMJRyIiIiIiIiIiIhINJxyJiIiIiIiIiIhINJxwJCIiIiIiIiIiItFwwpGIiIiIiIiIiIhEoyd1ACrcw4cPkZiYKHUMAICxsTHMzc2LbadOmT8kb34iIlKvsVye8Vud8n6ItYeISH7qNpaz/hARlQwnHNXUw4cPYWVlhdTUVKmjAACMjIwQFxdXZOFSt8wfkic/ERGp31he3Pitbnk/xNpDRCQfdRzLWX+IiEqGE45qKjExEampqQgKCoKVlZWkWeLi4uDu7o7ExMQii5Y6Zf6QvPmJiEi9xnJ5xm91yvsh1h4iIvmp21jO+kNEVHKccFRzVlZWsLW1lTqGQjQxMxER5aVpY7mm5SUiovw0cSzXxMxERKWBE45EpFHi4uLw888/IyoqCjExMQCA//3vf3B0dESbNm3g6OiI8uXLS5ySiIi0iSAIuHTpEi5evIioqCjcuXMHADBz5kz06tUL7dq1Q4cOHaCjw/0YiYhIPOnp6Th9+jR+++03xMTE4MGDBwCAefPmoW/fvujUqROaN28ucUqignHCkYjUniAICAsLg5+fH86dOwc9PT1YW1tDX18fAPDy5Uts2LABL168QPXq1TFmzBh8+eWXMDY2ljg5ERFpsoyMDGzduhUbN25EfHw8jIyM0KpVK+jq6gIAHj16hEWLFuHt27ewtLTExIkTMXHiRH7xRUREJfLq1St888032L59O549e4aqVavCxsYm9/PP77//jhMnTiAjIwPt2rWDj48Phg0bBplMJnFyov/wa1giUmt///03nJ2dMWjQIOjq6iI4OBgpKSm4fv06fHx8AACzZ8/GP//8g1u3bsHNzQ2bNm1Cs2bNEBoaKnF6IiLSVDExMbC3t8f//vc/tGjRAmfOnMHr16/x66+/YsqUKQCA+fPnIzk5GefOnYO9vT1mzpwJOzs7XL16VeL0RESkqSIiImBtbQ0/Pz8MHjwYMTExePHiBU6dOpVbf5YuXYqUlBSEhYXhk08+wYgRI9C7d288evRI4vRE/+GEIxGprdjYWNja2uLKlSsICwvDmTNnMHjwYBgYGORrK5PJ0LRpU6xbtw63b99G+/btMWjQIPj6+kIQBAnSExGRpgoPD0fbtm2RlZWFK1eu4Mcff0SXLl1yr2z8kK6uLjp27Ig9e/YgKioK5cqVQ/v27fHjjz9KkJyIiDTZ8uXL0a9fP7Rs2RJxcXH47rvv0KJFiwKvXCxfvjwGDBiAEydOICIiArGxsbCxsUFUVJQEyYnyU2rCceHChZDJZEhISBA5DhHRe/fu3UP37t1hamqKmJgYDBgwQO5zzczMEBYWhlWrVmHZsmVYtmyZ6oISEZFWOX78OAYPHoz+/fvjt99+U2gziBYtWuDy5csYPnw43NzccOjQIRUmJSIibbJ27VrMmTMHCxcuREREBGrXri33uX369MGNGzfQoEED9OjRA3FxcSpMSiQftb/CMTIyEjKZDD/88IPUUdRKQkICZDJZnkNfXx+1atXC0KFDc2/l8fPzg0wmg6enZ6F9nT17Fjo6OmjTpg0yMzMlz5zD398/X/vCji5duqgsN5W+rKwsuLu7o2LFijh58iRMTU0V7kMmk2HGjBlYtGgR5s+fj/Pnz6sgKVHZw/rD+qPNEhMTMXLkSHTr1g179+5Vai1GfX19+Pv7o3///hg1ahT+/vtvFSQlKntYf1h/tNnVq1cxa9YszJw5EwsWLFBqLcZq1aohMjISNWrUgJubGzIyMlSQlEh+ar9pTLdu3VC5cmUcOHAAw4cPlzqO2mnQoAHc3d0BAG/fvkVUVBSCg4Nx4MABnDx5Ej4+Pjh48CD8/f3h4uKC/v375zn/zZs38PT0RPny5REQEAA9PdW/JYrL7ODgAABo1aoVFixYUGRfGzduRGJiIpo1a6by3FR61q9fj8uXL+PcuXMl3vhl7ty5iIyMhKenJ2JjYwu8HZuIFMf6w/qjjXx8fJCZmQl/f//chfmVoaurix07dqBp06aYMGECDhw4IF5IojKO9Yf1R9tkZGTAw8MDLVu2xNKlS0vUV5UqVRAQEIC2bdti5cqV8PX1FSklkRIEJSxYsEAAIDx48ECZ0xXm6uoqVKxYUXj37l2pvJ46iIqKEgAIUVFRBT7/4MEDAYDQq1evfM8tX75cACA4ODgIgiAICQkJQqVKlQRTU1MhMTExT1svLy8BgLBu3Tqls6giszzWrFkjABDs7OyEf//9t8T5ST2kpaUJpqamwrhx44ptGxQUJAAQgoKCimx369YtAYAQEBAgVkzSMBwH5Kdp9UeeNlLUH77nNM/du3cFmUwmbNmypdi28tafgIAAAYBw8+ZNsWKShuFYIB+xx3LWH77nNElISIgAQPjtt9+KbStv/fHx8RGqVq0qpKamihWTNIi6jAOi31KdmpqKJUuWoFGjRjAwMICFhQXWrl2L69ev597iqCgXFxekpKTg1KlTYsfVSmPGjAGA3MVi69atCz8/Pzx79gwTJkzIbRcZGYlt27aha9euubv9SuXjzMU5efIkZs2aBRMTE4SFhfGqNS0SFhaGZ8+eifqebNq0KXr06IFNmzaJ1icR5cf6Q5ps69atqFKlCkaOHClan8OGDYOJiQk2b94sWp9ElB/rD2myTZs2oUOHDmjdurVofU6ZMgWvXr3iBmYkKVEnHFNSUtC5c2fMnz8fderUgY+PD2xsbDBjxgzMnj0bAGBjY6Nwv59//jkMDAwQFhYmZlyt9+HtAZ6ennByckJwcDD27duHpKQkjB07FpUqVcLu3buVWiNCFeS5peH+/fsYNmwYZDIZgoODUadOnVJIRqUlIiICtra2ot8mMnLkSFy6dAkvXrwQtV9FZWRk4Pvvv8eyZcsQFhbGHbRJK7H+kCaKiIjA4MGDYWRkJFqf5cqVw4gRIxARESFan8p6+fIlNm7ciBUrVnBdY9JarD+kad6+fYuzZ8+K+mUX8P42/o4dO6pF/bl79y6++eYbrF27FvHx8VLHoVIk6oIVo0ePxrVr1xAYGJi7RgUArFmzJvfKxlatWincb4UKFdCzZ0+Eh4dj69at0NFR+71uJLVjxw4AQMeOHfM8vm3bNly4cAGTJk2Cg4MDHj9+jF27dqFu3bpSxMyjsMwfe/v2LQYMGICXL19iw4YNueudkPaIiopSyc/V3t4eAHDt2jX06NFD9P7lkZ6eju7du+PcuXPQ09NDZmYmPD09sXPnTrX5Ry9RSbD+kKZ6+/Yt4uPjMW3aNNH7tre3x/r16/HixQtUq1ZN9P7l8eTJE7Rt2xZ//fUXdHR0kJWVhQ0bNmDy5MmS5CESG+sPaaro6GhkZ2ejbdu2ovdtb28v+UVbFy5cQPfu3ZGWlgYA8PX1xZEjR9C1a1dJc1HpEG3C8dSpUwgJCYG3t3eeyUYAGDVqFGbMmAFDQ0M0btxYqf5dXFwQHh6OCxcuFDsolyV3797FwoULAfy3APGZM2dgamqK1atX52lramqKrVu3YtCgQTh48CCcnJyK3L1NHTJ/zMPDA7GxsfD09OQ/krWQIAiIj4/HxIkTRe+7YcOGKFeuHOLj4yWbcNy6dWvuVSU5OyLu3r0brq6u6N69uySZiJTF+kPa5I8//kB2djasra1F77t58+YAgNu3b+Ozzz4TvX95zJ49G0+fPoUgCMjKygLwfoOcoUOHwsTERJJMRMpi/SFtknPFnyo2AWrevDm++eYbpKWloXz58qL3L4/Ro0cjLS0N2dnZAN5fgOHh4YE///xTkjxUukSbcNy4cSMAYObMmfme+/TTTwG8f8Pr6uoCAEJDQ7F582ZERUXh1atXePDgAerVq1do//3794eenh7CwsIKnXC8du1aCf8W6iMuLk6udvfu3cOiRYvyPGZmZoZz587B0tIyX3sXFxfY29vjypUrWLFihaiZVJU5x7JlyxASEoK2bdsqtRaSvPlIOpmZmcjOzsY///wj1+/zgwcPcv+Up325cuVw9+5dycaKS5cuQVdXN3eyMcfZs2dzx0lSjZzff44DxdO0+qPIz1SK+sP3nGaIjY0FAPz5559y7U6tSP159OgRAODGjRuSrbkWHR2dr/ZkZ2fjxIkTsLKykiRTWcH6Ix9VjuWsP6TO/vjjD+jp6eXWoeIoUn+ePn0K4P1nkIoVK5YsqJIePHiQO9kIvK89Dx8+xNWrV3nnqgqVRu2xtbUtvpEyO80UtEt1xYoVBUtLywLbP3r0SAAgjB8/PvexgIAAYfHixcKGDRvk3vG6WbNmQrt27Qp9HoDWHYrsEvr8+XNh9erVgo6OjmBlZSWkpKQUeG7nzp0V2mU8Z4cjKTMfPnxY0NHREczMzITHjx/LlVvZ/Dx48ODBQ/Pqj6K7hKq6/rD28ODBg4fih6rGctYfHjx48BD3kIcoVzgmJSUhJSWl0F2VTp48CSDv+o05i6LevHlTrtd49uwZ4uLiitzlWt4dvjRBXFxcvlvTi1O9enVMnz4dycnJWLp0KXx9feHn5ydapqCgoCK/BVdV5jt37sDNzQ16enoICQlBrVq1lIlfbH5SD4MHD4atrS3mzJlTbNvo6GiMGTMGO3fuLHZ92ISEBAwaNAgbN25Eu3btREqrmIyMDEyYMAHXr1/PfczJyQnz58/nGo4qljM+cRwonqbVH2XyAqVXf/ie0wz//vsvOnXqBF9fXwwYMKDY9orUn6NHj8LX1xenTp1ClSpVRMmrqH/++QdffPEFnj9/nvvYrFmzMHToUEnylCWsP/JR5VheEqw/pGo59WTv3r1yLT+nSP355ptvcObMGRw6dEiktIqLiYnBhAkTctdw1NPTw3fffYc2bdpIlqksUJvaI/dXJR/4+ArHN2/eCACEli1b5mublpYmWFlZCQCES5cu5Xs+NjY2T1+F2bp1a6F9aKOcb6YUucIkR2pqqlCzZk1BX1+/wP+vyn7DV9S3d6rKnJycLDRp0kQAIGzZskWuvMrmJ/UwcuRIwdbWVq62ivxsAwICBABCYmJiSSOWSHp6urBw4UIBgLB69WohOztb0jxlBccB+Wla/ZGnjRT1h+85zdO0aVNh3LhxcrVV5Ofr4+Mj1KtXr6TxSuzFixfCrFmzBADCjh07pI5TZnAskI+qxvIcrD+krt68eSPo6OjI/bNW5OfbsWNHYfDgwSWNWGJ//PGHMG3aNAGAEBISInWcMkFdxgFRbpqvUKEC6tati9jY2DxrD6SlpcHDwwNxcXHQ0dHJXTRbGaGhoahZs2buTrNUOENDQ8yaNQsZGRlYsmSJ1HHkUlBmQRDg7u6O+Ph4eHl5Yfz48RKnpNLQt29fXLt2Dbdu3RK138DAQLRr106yHUJz6Ovro3///gCAbt268cpG0iqsP6TJ+vbti5CQEKSmporWZ3p6Ovbt24e+ffuK1qeyPv3009wrGm1sbCROQyQu1h/SVBUqVECXLl0QGBgoar/37t3D+fPn1aL+WFpaws3NDQBQv359idNQaRJt05jp06djypQpcHBwwPDhw2FgYIDw8HBYWFjAwMAA9evXh5GRkVJ9Jycn4/Tp0xg3bhw/nMvJy8sLK1euREBAAObMmYMGDRpIHalYH2cODQ3FoUOHUK5cOVSrVi13Z7fCFPc8aYaBAwfC1NQU69evx7Zt20Tp8/fff8eJEycQEBAgSn9EVDjWH9JU48ePx5o1axAYGCjah/wff/wRz58/x4QJE0Tpj4gKx/pDmmrixIkYPHgwrl69WugydYrasGEDqlatimHDhonSH5EyRJtwnDRpEpKSkrBlyxbs2rULFhYWGD9+PJydndGkSZNi1xcoSkREBDIyMjBw4ECx4mo9AwMDzJ49G1OmTMGiRYs0YqLl48w5u1alp6dj+fLlxZ7PgqsdypUrh5kzZ2L69OkYNWoUOnToUKL+srKyMG7cOFhaWmLIkCEipSSiwrD+kKZq0KABRowYgTlz5sDZ2RlmZmYl6u/FixeYPn06nJ2d0axZM5FSElFhWH9IUzk5OaFZs2bw8vLC5cuXoa+vX6L+oqKi8N1332HhwoUwNDQUKSWR4kSbcJTJZPD19YWvr2+ex0NDQwGU7NaNsLAwVK1aFV26dClJRK1Sr149CIJQZJvJkydj8uTJ+R4/e/asilIVTZnM/v7+Kk5F6sjHxwfBwcEYNWoULl26BGNjY6X7WrZsGS5evIhffvkFBgYGIqYkKptYf0ibrV+/Hs2aNYOHhwcOHTqk9Ie+rKwsjB07FhkZGdi8ebPIKYnKJtYf0lb6+vrw9/dHu3bt4Ovri5UrVyrdV1JSEkaOHIkWLVpg1qxZIqYkUpwoazgWJSYmBgDyXeH48uVLREdH4/bt2wDe3/IYHR2Nly9f5mn37t07HD16FP369YOenmjzo0SkxnR1dREUFISUlBR0794dz549U7gPQRCwevVqLFiwAIsXL0bHjh1VkJSIiLSJsbExAgMDcfr0aYwYMSJ3V01FZGRkYNSoUTh06BC+//571KhRQwVJiYhIm7Ru3RqrVq3CqlWrsGjRomInqgvy4sUL9OrVC8+ePcOePXtKfKUkUUmpfMIxOjoaQP4rHMPDw2FjY4PBgwcDeL9Qt42NDcLDw/O0O3fuHAwMDHLbEVHZ0KBBA5w6dQrPnj1DixYtEBYWJve5T58+xYABAzBz5kzMnTsXc+fOVWFSIiLSJj179kRISAgOHz6M1q1bIyoqSu5zb9y4gbZt2+LHH3/E3r17czcJIyIiKs60adPw9ddfY+HChejbty8eP34s97lHjhxBixYtcP/+fRw/fhxWVlYqTEokn1K5wrFWrVr5bon08PCAIAj5Dg8PjzztevTogcTERDg5Oak6KhGpGWtra1y7dg1t27aFi4sLunTpguDgYLx79y5fW0EQ8Pvvv+N///sfGjdujEuXLmH//v1YunQpN5siIiKFODk54fLly9DT00Pbtm0xdOhQnDlzBpmZmfnaZmVl4fz583B1dYWdnR3S09Nx8eLF3B2hiYiI5DV79mwcPnwYMTExsLKywqRJk3Djxo0Cr3hMS0tDWFgYevTogb59+6J58+a4du0a7OzsJEhOlJ9S9yjnrKVYpUqVYtsmJCQo8xJERACAGjVq4ODBgwgLC8P69esxdOhQ6OnpoVmzZqhWrRoAYMKECbh37x5evHiB6tWrY+LEifjyyy9LtPYjERGVbS1btsSVK1ewbds2bNy4Ed26dYOhoSFatWqFChUqAABGjx6Nu3fv4u3bt2jYsCFWr16NCRMmoHz58hKnJyIiTdW3b1/cvHkT69atw/bt27Fp0yZUrVoVNjY20NXVBQC4urri/v37yMjIQPv27fHDDz9g6NChvNCC1IrSE47cwIWISotMJoOLiwtcXFwQFxeHX375BVevXsXNmzcBABUqVMD//d//oXXr1nB0dOQHPSIiEoW+vj4mTZqEiRMn4tKlS7h48SKuXbuGu3fvAgDMzMzg7u6Odu3a4bPPPsvdYZaIiKgkqlatisWLF8PX1xdnzpzBb7/9hujoaDx8+BAA0LhxY/j4+KBTp06wtraWOC1RwbgLCxFpFCsrK1hZWWH8+PFITU1FfHw8mjRpAiMjI6mjERGRlpLJZGjfvj3at28PAKw/RERUKsqVK4devXqhV69eAFh/SLNwwpGINJaRkRFsbW2ljkFERGUM6w8REUmB9Yc0CScc1VxcXJzUERTOoA6ZP6RueYiINIE6jJ2KZFCHvB9StzxERJpAXcZO1h8iopLjhKOaMjY2hpGREdzd3aWOAuD9NynFbcChbpk/JE9+IiJSv7G8uPFb3fJ+iLWHiEg+6jiWs/4QEZUMJxzVlLm5OeLi4pCYmCh1FADvC6q5uXmRbdQt84fkyU9EROo3lhc3fqtb3g+x9hARyUcdx3LWHyKikuGEoxozNzfXuEKhiZmJiCgvTRvLNS0vERHlp4ljuSZmJiIqLTpSByAiIiIiIiIiIiLtwQlHIiIiIiIiIiIiEg0nHImIiIiIiIiIiEg0nHAkIiIiIiIiIiIi0XDCkYiIiIiIiIiIiETDCUciIiIiIiIiIiISDScciYiIiIiIiIiISDSccCQiIiIiIiIiIiLRcMKRiIiIiIiIiIiIRMMJRyIiIiIiIiIiIhINJxyJiIiIiIiIiIhINJxwJCIiIiIiIiIiItHoSR2AtM/Dhw+RmJgodQwAgLGxMczNzYttp06ZPyRvfiIiUq+xnPWHiKjsUKexXJ7xW53yfoi1h0i7cMKRRPXw4UNYWVkhNTVV6igAACMjI8TFxRVZuNQt84fkyU9EROo3lrP+EBGVDeo2lhc3fqtb3g+x9hBpF044kqgSExORmpqKoKAgWFlZSZolLi4O7u7uSExMLLJoqVPmD8mbn4iI1GssZ/0hIio71Gksl2f8Vqe8H2LtIdI+nHAklbCysoKtra3UMRSiiZlJc2RlZSE+Ph5RUVE4ffo0AGDjxo3o1asX7OzsYGFhAZlMJnFKIs2niWO5JmYmzZGWloYbN24gKioKFy5cAABs2bIFTk5OaN26NczMzCROSKQdNG0s17S8pHlSUlJw7do1REVF4fr16wCAnTt3IikpCXZ2dqhcubLECUnVOOFIRKRC//zzD7Zv346tW7fi4cOHAICqVasCAPbv349du3YBAKytrTFx4kR88cUXqFChgmR5iYhIO/zxxx/YtGkTdu/ejeTkZOjp6aFKlSoAgD179mD79u0AgK5du2LixIkYOHAgdHV1JUxMRETa4OLFi/juu+8QHByMjIwMGBoaomLFigCAHTt2YNOmTdDT04OLiwsmTZoEBwcHiROTqnCXaiIiFRAEAYGBgWjUqBGWLl2K7t274+TJk0hKSsKGDRsAvL/C8dmzZzh48CAaNmyIyZMnw9raOvcKSCIiIkVlZGRg0aJFaNq0KYKCguDt7Y1Lly4hJSUFfn5+AIBt27YhISEB33//PTIyMjBkyBB07NgR8fHx0oYnIiKN9erVK4waNQqfffYZrly5gq+//hqxsbF4/fo1vvnmGwDvJxxv3bqF1atXIyYmBp07d8aIESPUchMjKjlOOBIRiSwjIwNffPEFvvjiC/Tp0wcPHz7Ezp074ejomO/WARMTEzg5OSE0NBR37txBvXr14OjoiEWLFkEQBIn+BkREpIlevHiBTp06YcmSJfjqq6/w6NEjrFixAm3btoWBgUGetnXr1sUXX3yBc+fO4dy5c3jx4gVatWqFkJAQidITEZGmunXrFlq0aIGDBw9i165duH37NqZPnw5ra2vo6f13Y62Ojg6aNm2K//3vf4iLi0NQUBCOHz8Oa2vr3NuuSXsoNeG4cOFCyGQyJCQkiByHiEizZWVlwd3dHT/++CP27NmDPXv2wNjYWK5zGzRogFOnTmHp0qVYuHAhFixYoOK0RESkLZKTk9G9e3fcv38fFy5cwJIlS/JNMhamY8eOiI6OhouLC4YNG4bQ0FAVpyUiIm1x+/ZtdO3aFdWqVcPNmzfh6ekJHZ3ip5pkMhnc3Nxw69Yt1KlTB926dcONGzdKITGVFrW/wjEyMhIymQw//PCD1FFIBAkJCZDJZHkOfX191KpVC0OHDsXVq1cBAH5+fpDJZPD09Cy0r7Nnz0JHRwdt2rRBZmam5Jlz+Pv752tf2NGlSxeV5SZprFu3DsHBwfjxxx/h6uqq8Pk6OjqYO3cuVqxYgSVLliAiIkIFKYnKHtYf1h9t5+3tjYSEBJw+fRr29vYKn29kZITAwEAMHToUI0eOxL1791SQkqjsYf1h/dFmaWlpGDRoEKpXr45Tp06hdu3aCvdhZmaGkydPol69ehg0aBBSU1NVkJSkoPabxnTr1g2VK1fGgQMHMHz4cKnjkEgaNGgAd3d3AMDbt28RFRWF4OBgHDhwACdPnoSPjw8OHjwIf39/uLi4oH///nnOf/PmDTw9PVG+fHkEBATkuUxbqsw5i922atWq2CvTNm7ciMTERDRr1kzluan03L59G76+vpg6dSoGDhxYor5mzpyJn3/+GV5eXrh582buRjNEVDKsP6w/2ig0NBQ//PAD9uzZA2tra6X70dXVxfbt23H58mWMHj0aZ86ckesqFSIqHusP6482Wrx4Me7cuYOoqChUq1ZN6X4qV66MH374Aa1atcLcuXOxbt06EVOSZAQlLFiwQAAgPHjwQJnTFebq6ipUrFhRePfuXam8HikvKipKACBERUUV+PyDBw8EAEKvXr3yPbd8+XIBgODg4CAIgiAkJCQIlSpVEkxNTYXExMQ8bb28vAQAwrp165TOoorM8lizZo0AQLCzsxP+/fffEucn9eHm5ibUrVtXePv2bZHtgoKCBABCUFBQke0ePXokGBoaCsuWLRMzZpnE3yftx/pTPNYf7ZSdnS00adJE6NOnj5CdnV1kW3nrz4kTJwQAwrFjx8SMWibx90n7aVr9kaeNFPWHvyuaJzExUShfvrwwb968YtvKW3+WL18u6OnpCX/99ZdYMcskdfl9Ev0ry9TUVCxZsgSNGjWCgYEBLCwssHbtWly/fh0ymQwzZsxQuE8XFxekpKTg1KlTYsclNTJmzBgAQFRUFID3i5n7+fnh2bNnmDBhQm67yMhIbNu2DV27doWPj48kWXN8nLk4J0+exKxZs2BiYoKwsDC511Yi9ff8+XMEBwdjypQpMDIyEqXP2rVrY8SIEdiyZQuysrJE6ZOI8mP9IU129uxZxMfHY8aMGZDJZKL06ejoiJYtW2LTpk2i9EdEBWP9IU22e/duCIKAKVOmiNbnhAkTUK5cOezYsUO0Pkk6ok44pqSkoHPnzpg/fz7q1KkDHx8f2NjYYMaMGZg9ezYAwMbGRuF+P//8cxgYGCAsLEzMuKSmPrw9wNPTE05OTggODsa+ffuQlJSEsWPHolKlSti9e7do/7AuKXluabh//z6GDRsGmUyG4OBg1KlTpxSSUWkJDw9HZmYmPDw8RO137NixePToES5duiRqv8pISEjAsWPHEBMTI3UUIpVg/SFN9NNPP6FBgwbo3LmzaH3KZDKMHTsWhw8fxtu3b0XrV1k3b97EsWPHcP/+famjEKkE6w9pop9++gkDBgxA9erVReuzcuXKGDp0KH788UfR+lRWVlYWLl26hBMnTuDZs2dSx9FIok44jh49GteuXUNgYCBOnTqFlStXYv/+/Vi1ahUiIyMBvF/fQVEVKlRAz549ER4ejuzsbDEjkxrJ+RajY8eOeR7ftm0bjI2NMWnSJHh4eODx48fw8/ND3bp1pYiZR2GZP/b27VsMGDAAL1++xLp163LXOyHtcfXqVVhZWZVo7ZKC2NnZoXz58nJ/i6wqO3bsgKWlJXr37o1WrVph7NixEARB0kxEYmH9IU129epVdOjQQfRJiA4dOiA7OxvR0dGi9quInCtnmjdvjt69e6Nhw4bYsGGDZHmIxMb6Q5oqPT0dMTExxb4PlNGhQwfEx8dL+oVXamoqevTogfbt26Nnz55o0KABTpw4IVkeTSXaSrOnTp1CSEgIvL29cxeWzTFq1CjMmDEDhoaGaNy4sVL9u7i4IDw8HBcuXFDJm5pK1927d7Fw4UIA/y1AfObMGZiammL16tV52pqammLr1q0YNGgQDh48CCcnpyJ3b1OHzB/z8PBAbGwsPD09MXny5FJIS6UtNjZWqS9UilOuXDlYW1vjxo0bovctr99//x3jx4/P84XPzp070b59+9zbaog0BesPaRNBEBAbGwtXV1fR+27WrBn09PRw48YNdOjQQfT+5fHjjz/iu+++y/3v7Oxs+Pj44LPPPoOdnZ0kmYiUxfpD2uSPP/5Aenq6Sj7/2NjYIDs7G7du3YK9vb3o/ctj/vz5+Pnnn3P/OzU1FYMGDcLjx49RqVIlSTJpItEmHDdu3Ajg/c6qH/v0008BAM2bN4euri4AYPny5di/fz9u374NIyMjdO7cGatWrUK9evUK7L9///7Q09NDWFhYoROO165dE+FvQiURFxcnV7t79+5h0aJFeR4zMzPDuXPnYGlpma+9i4sL7O3tceXKFaxYsULUTKrKnGPZsmUICQlB27ZtsXnzZrleS5l8JK3nz5+jdu3aco1DDx48yP1TnvY6Ojp4+PChZGPckSNH8l1drquriyNHjii1TIYUcn6P+PukvVh/8mP90X6ZmZlIS0tDcnKySuqPgYEB4uPjJas/hw4dgp6eHjIzM3MfEwQBBw4cUJvbSovD+qP9NK3+KPJelKL+8HdFM8TGxgIAnjx5Inr9efz4MYD38zulsRt7QU6ePJnn848gCEhJScHhw4fRpEkTSTIpojRqj62tbfGNlNlppqBdqitWrChYWloW2P7Ro0cCAGH8+PG5j/Xq1Uvw9/cXbt26JVy7dk1wdHQUmjRpImRkZBT6us2aNRPatWtX6PMAeKjJocgubc+fPxdWr14t6OjoCFZWVkJKSkqB53bu3Dnf+64oOTszSZn58OHDgo6OjmBmZiY8fvxYrtzK5ufBgwcPHqw/OVh/ePDgwaN0D02rP4ruUq3q+sPaw4OHZh3yEGW6OCkpCSkpKWjdunWBz588eRJA3vUbjx07lqfN9u3bYWFhgd9//x0tWrTI18ezZ88QFxdX5C7XUq9xRu9n0D++pb441atXx/Tp05GcnIylS5fC19cXfn5+omUKCgqClZVVoc+rKvOdO3fg5uYGPT09hISEoFatWsrELzY/qYcZM2YgOTkZ27ZtK7ZtdHQ0xowZg507dxZ7G4IgCOjRowdcXFwwceJEkdIqJjMzE97e3oiOjs5dt/GTTz5BSEiIqItEq1LO7zl/n7QX689/WH/Kln79+sHR0RFTp04ttq0i9efZs2fo06cP1qxZg65du4qUVjGvXr3CiBEj8OLFC2RnZ0Mmk6Fp06bYuXMn9PX1JcmkKNYf7adp9UeZvEDp1R/+rmiGpKQkODo6YtmyZfj888+Lba9I/Tl79iy+/PJLREREwMzMTKTEiomPj4eHhwcyMzNzP/8MHDgQvr6+kuRRlNrUHrm/cvjAx1c4vnnzRgAgtGzZMl/btLQ0wcrKSgAgXLp0qdA+r1+/LgAQHj16VODzW7duLbYPkl7ON1OKfMOXIzU1VahZs6agr69f4Ld4yn7DV9S3d6rKnJycLDRp0kQAIGzZskWuvMrmJ/Xw9ddfC5UqVRKysrKKbavIz/bhw4cCAOHAgQNixFTav//+KyxYsEDo2rWrAEA4evSopHkUxd8n7cf68x7rT9kzaNAgoXPnznK1VeRnGxYWVuS/zUvL06dPhWHDhgkAhNGjRwtv3ryRNI+i+Puk/TSt/sjTRor6w98VzVOvXj1h2rRpcrVV5Ofr6+srmJiYCNnZ2SWNWCIxMTGCk5OTAECYMWOGXJ/z1IW6/D6Jskt1hQoVULduXcTGxubeyw8AaWlp8PDwQFxcHHR0dNC8efMCz8/KysL06dPRp08f1K5du8A2oaGhqFmzpmSLhpLqGRoaYtasWcjIyMCSJUukjiOXgjILggB3d3fEx8fDy8sL48ePlzgllYZu3brh9evXOH78uKj9BgcHQ19fX7IF+3MYGBhg4cKFWLNmDQDAxMRE0jxEYmL9IU3WrVs3nD9/Hk+ePBG13+DgYFhaWip9haxYTE1Nc9eInzRpEipUqCBpHiIxsf6QJuvWrRv279+PrKws0foUBAHBwcHo2rWr5Gv1tmjRAgsWLAAADB8+HDo6okyflSmircA5ffp0TJkyBQ4ODhg+fDgMDAwQHh4OCwsLGBgYoH79+jAyMsp3niAI8Pb2xsOHD/Hrr78W2HdycjJOnz6NcePGSf6mI9Xy8vLCypUrERAQgDlz5qBBgwZSRyrWx5lDQ0Nx6NAhlCtXDtWqVcvd2a0wxT1PmsHe3h6tWrXCd999J9dtBfLIysrC5s2bMWTIEBgbG4vSJxEVjPWHNJWbmxtmzpyJrVu35tvcQVnPnj1DcHAwVqxYwX97E6kY6w9pKm9vb+zatQsRERFwcnISpc9Tp07h9u3b2Lp1qyj9kbREm3CcNGkSkpKSsGXLFuzatQsWFhYYP348nJ2d0aRJkwLv0xcEARMnTsTJkyfxyy+/FLoWWEREBDIyMjBw4ECx4pKaMjAwwOzZszFlyhQsWrQIAQEBUkcq1seZc775SE9Px/Lly4s9nwVXO8hkMkyfPh3u7u44cuQI+vTpU+I+169fj3v37mHv3r0iJCSiorD+kKaqXLkyxo0bh7Vr18LDwwP169cvcZ/Tpk3DJ598Ag8Pj5IHJKIisf6QpmrTpg06deqEGTNmoEePHjA0NCxRf2lpaZg6dSrs7Ozg4OAgUkqSkmgTjjKZDL6+vvkW0QwNDQUA2NjY5HlcEARMmjQJERER+Pnnn1GnTp1C+w4LC0PVqlXRpUsXseKSROrVq5e76GphJk+ejMmTJ+d7/OzZsypKVTRlMvv7+6s4FakjV1dXBAYGwsvLC9evXy/Rhio3b97E3Llz4ePjgzZt2oiYkqhsYv0hbbZ48WKEhYXBw8MDJ06cQLly5ZTu66effsLevXsRGBiITz/9VMSURGUT6w9ps23btqFVq1aYOXMmNmzYUKK+5s+fj/j4eFy9epVX12sJld+EHhMTAwD5rnCcNGkS9u3bh71798LQ0BBPnz7F06dPkZ6enqfdu3fvcPToUfTr1w96eqLNjxIRiU4mk2H79u3IzMxEz5498c8//yjVT3x8PHr16oVGjRph2bJlIqckIiJtU7FiRQQEBODSpUtwc3PL9+9peR07dgxffPEFhg8fDjc3N5FTEhGRtmnSpAnWrl2L7777DkuWLCl2orowa9euxapVq7B8+XK0bNlS5JQkFZVPOEZHRwPIf4Xj5s2bkZSUhE6dOqFGjRq5x4ULF/K0O3fuHAwMDDB48GBVRyUiKrE6dergxIkTePLkCezt7RX6ZloQBOzduxefffYZqlatisjIyALXviUiIvqYg4MDfvrpJ4SHh6NLly64c+eO3OfmbP7Qv39/9OzZE/7+/ry6hIiI5DJp0iQsXboU8+fPh5ubG168eCH3uUlJSfD09MT06dMxZ84cfPnllypMSqWtVK5wrFWrVr4NDwRBKPD4+LbpHj16IDExUbRFSImIVK158+a4dOkSzM3N0bVrV7i7u+Py5cuFfuOXnZ2NY8eO4fPPP4ebmxs+//xz/PLLLzAzMyvl5EREpMmcnZ1x5swZ/PPPP2jZsiW+/PJL3L17t9D27969Q2BgIFq3bo1FixZh5syZ2L9/P8qXL1+KqYmISNPNnTsXe/bswbFjx9C0aVOsXLmyyLu9Xr58ibVr16JZs2YIDQ3Frl27sGzZMn7ZpWWUukc5Z1KwSpUqxbZNSEhQ5iWIiDRa/fr1cebMGWzduhWrV6/Gnj170KBBA7Ru3RpVq1YFAGzZsgXPnz/HlStX8Pfff6NVq1YICwvDgAEDpA1PREQa67PPPkNMTAyWLVuGLVu24JtvvkHLli1hZ2eXu6D/t99+iydPnuDKlStITk5Gjx49sHPnTrRu3Vri9EREpKlcXV3RtWtXzJ07FwsWLMD8+fNhZ2cHOzu73InE1atX49GjR7h69SoEQcDQoUPx9ddfF7mnB2kupSccuYELEVHRdHR0MGHCBHh5eSEyMhKRkZGIiorC8ePHAbzfEKtVq1YYOXIkBgwYgHbt2vFbPSIiKjEjIyMsW7YMvr6+CAkJwS+//IKoqCjcv38fABAZGQl7e3tMmzYNw4cPR6NGjSROTERE2qBGjRrYtWsXVq9ejb179+LSpUs4efIknjx5AgC4cOECPvvsMwwePBiurq4wMTGRODGpEndhISJSMV1dXfTp0wd9+vQBAKSmpiI+Ph5NmjThGo1ERKQyhoaGGDlyJEaOHAmA9YeIiEpHtWrVMGXKFEyZMgUA609ZxQlHIqJSZmRkBFtbW6ljEBFRGcP6Q0REUmD9KZs44UgqERcXJ3UEhTOoQ+YPqVseIiJNoA5jJ+sPEVHZow5jpyIZ1CHvh9QtDxGVHCccSVTGxsYwMjKCu7u71FEAvP8m5eMd0j+mbpk/JE9+IiJSv7Gc9YeIqGxQt7G8uPFb3fJ+iLWHSLtwwpFEZW5ujri4OCQmJkodBcD7gmpubl5kG3XL/CF58hMRkfqN5aw/RERlg7qN5cWN3+qW90OsPUTahROOJDpzc3ONKxSamJmIiPLSxLFcEzMTEVFemjaWa1peItJMOlIHICIiIiIiIiIiIu3BCUciIiIiIiIiIiISDScciYiIiIiIiIiISDSccCQiIiIiIiIiIiLRcMKRiIiIiIiIiIiIRMMJRyIiIiIiIiIiIhINJxyJiIiIiIiIiIhINJxwJCIiIiIiIiIiItFwwpGIiIiIiIiIiIhEwwlHIiIiIiIiIiIiEg0nHImIiIiIiIiIiEg0nHAkIiIiIiIiIiIi0ehJHYBIXTx8+BCJiYlSx8hlbGwMc3PzItuoW+Yc8mQnIqL31Gksl3f8VqfMH2L9ISKSnzqN5aw/RNqHE45EeF+4rKyskJqaKnWUXEZGRoiLiyu0cKlj5hzFZSciovfUbSyXZ/xWt8wfYv0hIpKPuo3lrD9E2ocTjkQAEhMTkZqaiqCgIFhZWUkdB3FxcXB3d0diYmKhRUvdMueQJzsREb2nTmO5vOO3OmX+EOsPEZH81GksZ/0h0k6ccCT6gJWVFWxtbaWOoRBNzEyaRRAEJCQk4NatW7h+/ToA4ObNm2jRogX09FhGiMSgiWO5JmYmzZKVlYX4+HgcP34cAHDy5ElUrlwZFhYWkMlkEqcj0g6aOJZrYmbSLO/evUNsbGxu/Tlz5gxq1KiBGjVqSJxMs3DTGCIiKtC1a9cwduxYGBsbw8LCAv3798f8+fMBAKNGjUKlSpXQr18/REREICsrS+K0RESkDbKzsxEZGQlnZ2dUqlQJ1tbWmD17NgBg1qxZsLS0xKeffgoPDw9cuXIFgiBInJiIiLTBu3fvEBQUhE6dOqFixYqwt7eHr68vAGD69OmoWbMmateujRkzZuDevXsSp9UMnHAkIqI8njx5AmdnZ9jZ2eH48eOYMGECDh8+jEePHmH79u0AgLlz52LJkiX4+++/0a9fP7Rs2RK//fabxMmJiEiTRUdHw87ODp9//jn+/PNPLFiwAKdPn8amTZsAABs2bMCRI0fwf//3f/j555/Rtm1b9OnTB48ePZI4ORERabLDhw+jQYMGGDlyJAwMDLB+/XpcvnwZmzdvBgB88803CAkJwaBBg7Bz505YWlpiwoQJSElJkTi5euOEIxER5Tp69CiaNWuGy5cvY9++fbh//z6WLl2Kvn37onbt2jA0NATw/laWL7/8ElevXsXFixdRvnx5tG/fHitWrODVJkREpDA/Pz+0adMGWVlZ+OWXX3D9+nXMnDkTXbt2RaVKlQAAVatWRe/evbFo0SLcvXsX+/fvR2xsLJo1a4YDBw5I+xcgIiKNk5mZCS8vL/Tv3x8tW7ZEfHw8Tpw4gYkTJ8Le3h4VK1YEAJiYmGDQoEFYv349/vrrL/j5+SEgIADNmzdHTEyMxH8L9aXUhOPChQshk8mQkJAgchwiIpLKoUOH4OTkhI4dO+LWrVsYPnx4sWs0ymQytGvXDpcuXcJXX32F2bNnY968eaWUmIiItMGyZcswdepU+Pj44OrVq+jUqVOxazTq6urCxcUFN2/eRM+ePTFo0CAEBweXUmIiItJ0mZmZGDFiBHbv3o1t27YhIiICjRs3LvY8Q0ND+Pj4IDY2FtWqVUOXLl0QHR2t+sAaSO2vcIyMjIRMJsMPP/wgdRQq4xISEiCTyfIc+vr6qFWrFoYOHYqrV68CeP8NvUwmg6enZ6F9nT17Fjo6OmjTpg0yMzMlzZvD398/X/vCji5duqgkM0knPj4eQ4cOhZOTE8LCwlCtWjWFztfX18fSpUuxZs0aLFu2DEFBQSpKSlS2aFrtUSRzDtafsi00NBS+vr5YvHgx1qxZg3Llyil0fpUqVfDjjz9ixIgRcHNz45UmRCJh/WH90XYLFy5EWFgYQkJCMG7cOIU3I7OwsMDp06dhaWmJvn374tWrVypKqrnUfnvRbt26oXLlyjhw4ACGDx8udRwiNGjQAO7u7gCAt2/fIioqCsHBwThw4ABOnjwJHx8fHDx4EP7+/nBxcUH//v3znP/mzRt4enqifPnyCAgIUPkuv8XldXBwAAC0atUKCxYsKLKvjRs3IjExEc2aNVNpZipdWVlZ8PT0RJ06dRAYGFii9+SXX36JqKgo/N///R8cHR25kxuRSDSt9siTmfWHEhMTMWHCBDg7O+cuzK8MXV1d7Ny5EzExMbmbyejr64uYlKjsYv1h/dFGV69exYoVK7Bw4UI4Ozsr3U/lypURFhYGa2trTJ06Ff7+/uKF1AaCEhYsWCAAEB48eKDM6QpzdXUVKlasKLx7965UXo/KnqioKAGAEBUVVWibBw8eCACEXr165Xtu+fLlAgDBwcFBEARBSEhIECpVqiSYmpoKiYmJedp6eXkJAIR169aVKE9xbRTJK481a9YIAAQ7Ozvh33//LVF2Ui9BQUECAOH8+fNytw0KCiq0TWJiolC9enVh/PjxYsYsEb4vSV2JOZaXRu0RO7M8WH+019SpU4UqVaoIf//9d5Ht5Kk9gvD+PaCjoyNs27ZNzJglwvclqSvWn+Kx/mivTp06Ca1atRLS09OLbCdv/dm5c6cAQLh69aqYMZWmLu9J0W+pTk1NxZIlS9CoUSMYGBjAwsICa9euxfXr1yGTyTBjxgyF+3RxcUFKSgpOnToldlwiUYwZMwYAEBUVBQCoW7cu/Pz88OzZM0yYMCG3XWRkJLZt24auXbvCx8dHkqxA/rzFOXnyJGbNmgUTExOEhYXBwMBAlfGolG3atAndu3dHhw4dROmvWrVqmDRpEoKCgpCcnCxKn0SUn6bVHoD1h/7z9u1b7Nq1C+PHj4eZmZkofdra2qJv377YtGkTNzAjUiHWH9JksbGxOHfuHObMmSPa1fCjRo1CnTp1cne1pvdEnXBMSUlB586dMX/+fNSpUwc+Pj6wsbHBjBkzMHv2bACAjY2Nwv1+/vnnMDAwQFhYmJhxiUT34S0Cnp6ecHJyQnBwMPbt24ekpCSMHTsWlSpVwu7duxVeI0IV5Lml4f79+xg2bBhkMhmCg4NRp06dUkhGpeXu3bu4cOECvL29Re133Lhx+PfffxEaGipqv8oQBAGvX7+WOgaRymha7QFYfwg4fPgwkpOTMX78eFH79fb2RnR0NGJjY0XtVxmCIHBNL9JqrD+kiQIDA2FiYoIBAwaI1qeuri7GjRuHvXv3Ij09XbR+lZWVlQUAyM7OljSHqBOOo0ePxrVr1xAYGIhTp05h5cqV2L9/P1atWoXIyEgA79dJUFSFChXQs2dPhIeHS/4/jKggO3bsAAB07Ngxz+Pbtm2DsbExJk2aBA8PDzx+/Bh+fn6oW7euFDFzFZb3Y2/fvsWAAQPw8uVLrFu3Lne9E9IeV65cAQB07dpV1H5r1qyJJk2a5PYvlQcPHqBFixa5f7+VK1fmFmAiTadptQdg/aH/XL58GfXr10f9+vVF7bdz587Q0dGRvP6cO3cOZmZm6N69OwBwB23SKqw/pMkuX74MBwcH0df67datG/7991/cunVL1H4VtXv37tw71xwdHXHy5EnJsoi2YuupU6cQEhICb2/v3AVac4waNQozZsyAoaGhXNuMF8TFxQXh4eG4cOFCsYMEkSrdvXsXCxcuBPDfIsRnzpyBqakpVq9enaetqakptm7dikGDBuHgwYNwcnIqcgc3qfN+zMPDA7GxsfD09MTkyZNLIS2VtujoaNSrVw+ffvqp6H3b2dnh+vXrovcrr8zMTPTu3Rt3797Nfeynn35CixYtMHfuXMlyESlD02qPopk/xvqj/aKjo2Frayt6vxUqVECTJk0krT9//fUX+vTpg9TU1NzHVqxYAQcHB/Tu3VuyXETKYP0hbRMdHY2vvvpK9H5btWoFmUyG69evK3VnrxjOnj2LMWPG5C4rkpKSgv79++PWrVuwsLAo9TyiTThu3LgRADBz5sx8z+V8kG3evDl0dXUBAOvWrcOOHTvw559/Qk9PD7a2tli+fDnatm1bYP/9+/eHnp4ewsLCCp1wvHbtmhh/FSqD4uLi5G577949LFq0KM9jZmZmOHfuHCwtLfO1d3Fxgb29Pa5cuYIVK1aIlkvezIrmzbFs2TKEhISgbdu2Sq1Focj/U5LO7du38cknn8g9fj548CD3z+LOkclkePLkiWRj86NHj3D79u18j+/Zs4cf+EhtqGosV1Xtkef5HKw/VJTHjx/D2NhYrhqhSO0B3k863r17V7L6c/z4cbx58ybPYzo6OvD394epqakkmYg+xvqTH+uP9svKysLr16/x7t07ldQfIyMj3LhxQ7L6s3v3bujo6OTe0SUIAt69e4eAgAA4OTmJ+lpyfWmozE4zBe1SXbFiRcHS0rLA9o8ePRIA5NmxdP/+/cKxY8eEu3fvCrdu3RLGjRsnVK5cOd+uVh9q1qyZ0K5du0KfB8CDR4kORXepfv78ubB69WpBR0dHsLKyElJSUgo8t3PnzgIg/87uObtKlSRzSfIePnxY0NHREczMzITHjx/LlVmZ7Dx48ODB4/2hirFclbVHVZlZf3jw4MGjdA/Wn/dYf3jwUOyQhyhXOCYlJSElJQWtW7cu8Pmce8Y/XL/RxcUlT5s1a9Zg+/btuHnzJjp37pyvj2fPniEuLq7IXa7l3XGK6GNxcXH5lgKQR/Xq1TF9+nQkJydj6dKl8PX1hZ+fn2i5goKCYGVlVeBzymSWJ++dO3fg5uYGPT09hISEoFatWqJnJ/WxefNmhIaG4vjx43It5h0dHY0xY8Zg586dxa7JO3PmTLx69Qrbt28XKa1iBEHAlClTcPny5Tzr/y5dupRXOJLaUNVYXhLFjd+sPySGKVOmQCaT4dtvvy22rSK1B3h/Z1TXrl0xbdo0EZIq7s2bNxg+fDieP3+ee5WJrq4uAgMDlV5eikhsrD//Yf0pW7p3745Bgwbl2VG9MIrUn6SkJDg6Okr6WePBgwdwc3NDeno6BEGAjo4OPv30U/z444+oUqVK6QdSaOr+//v4Csc3b94IAISWLVvma5uWliZYWVkJAIRLly4V2F9aWpqwevVqoWrVqsKLFy8KbLN169Yi+yAqiZxvpRS9wjFHamqqULNmTUFfX7/Ab/KU/ZavqDzFtVEmb3JystCkSRMBgLBlyxa5siqTndTHgQMHBAByf5OryM+3Xr16wrRp00oasURSUlKEMWPGCHXq1BGsrKyE3bt3S5qH6GOqGMtzqKL2qCoz60/Z4+vrK5iamgrZ2dnFtlXkZ5uYmCgAEPbs2SNGTKU9fPhQ6N27t1CzZk3Bzs5O+OWXXyTNQ/Qx1p/3WH/Knt69ewt9+vSRq60iP9vjx48LAIT4+PiSRiyRS5cuCfb29kKNGjWE7t27C/fu3ZMsiyi7VFeoUAF169ZFbGwsYmNjcx9PS0uDh4cH4uLioKOjg+bNm+c579y5c/jkk09gaGiIdevW4cSJE4VuXBAaGoqaNWvC3t5ejMhEojI0NMSsWbOQkZGBJUuWSB2nWAXlFQQB7u7uiI+Ph5eXF8aPHy9xSioNbdu2hY6ODg4fPixqv7du3UJCQkLuDmlS+eSTT7Bjxw48fPgQv//+Ozw8PCTNQyQmTas9AOsP/adDhw549uyZ6HcoHTlyBADw2WefidqvourUqYMjR47gr7/+wtWrV9GpUydJ8xCJifWHNFmHDh3w888/4/Xr16L2GxERgerVq6Nhw4ai9quotm3b4vLly3jy5AlOnDghyWYxOUTbNGb69OmYMmUKHBwcMHz4cBgYGCA8PBwWFhYwMDBA/fr1YWRklOec1q1bIzo6Gi9evMD27dsxdOhQXL58GcbGxnnaJScn4/Tp0xg3bpxct/wRScHLywsrV65EQEAA5syZgwYNGkgdqUgf5w0NDcWhQ4dQrlw5VKtWLXdnt8IU9zxpBjMzM/Tv3x+bNm2Cl5eXaGPs5s2bYWpqin79+onSHxEVTNNqD8D6Q+/16NED5ubm2Lx5M3bu3Clav5s2bUKPHj1Qr1490fokovxYf0hTjRo1CgsWLEBQUBAmTpwoSp9v376Fv78/JkyYAB0dUa7r0wqiTThOmjQJSUlJ2LJlC3bt2gULCwuMHz8ezs7OaNKkSYH3uxsaGsLS0hKWlpZo27YtGjZsiN27d+dbpzEiIgIZGRkYOHCgWHGJRGdgYIDZs2djypQpWLRoEQICAqSOVKSP8+YMjOnp6Vi+fHmx57Pgao8pU6age/fu2LdvH1xdXUvc3+3bt7Fz507MmjUL5cqVEyEhERVG02oPwPpD7+nq6mLSpEnw9fWFj48PWrRoUeI+Dxw4gEuXLiE8PFyEhERUFNYf0lS1a9eGi4sLvv76a7i6uoqytuGKFSvw9u1bXiX7EdEmHGUyGXx9feHr65vn8dDQUACAjY1NsX0IgoC0tLR8j4eFhaFq1aro0qWLKFmJlFGvXj0IglBkm8mTJ2Py5Mn5Hj979qyKUhVOmbz+/v4qTkXqyNHREcOHD8fkyZPRpUsX1KxZU+m+MjMzMXr0aNSuXRszZ84UMSVR2aRptQdg/SH5+fj4ICAgAJ6enrh48WKJvqT6559/4O3tDScnJ15dTyQC1h/SZmvXroW1tTX+97//Yffu3SW6y+vq1atYvnw55s+fz6vrP6Lyaz1jYmIAIN8VjrNmzcKvv/6KP//8E9evX8e4cePw+PFjDBo0KE+7d+/e4ejRo+jXrx/09ESbHyUiog9s2LABhoaG6NOnD168eKFUH1lZWfD09MSVK1ewe/fufMtoEBERfah8+fLw9/fHzZs34erqioyMDKX6SUpKQt++fZGVlYUtW7ZwCSYiIipSnTp18O233+L777/H0qVLle7nzp076N+/P2xsbDB79mwRE2oHlU84RkdHA8h/heOTJ08wfPhwNGrUCH369MGzZ89w7ty5fNvInzt3DgYGBhg8eLCqoxIRlVnGxsaIjIzEkydP0KFDB4UX8X/69CmcnZ2xb98+BAUFoWPHjipKSkRE2qR169b46aefEB4ejj59+uDx48cKnX/jxg04ODjg7t27iIyMRI0aNVSUlIiItMmoUaOwdOlSzJ8/H97e3njz5o1C5x85cgQdO3ZE1apVERERAX19fRUl1VylcoVjrVq18m0EExgYiEePHiEtLQ1///03wsPD0aZNm3zn9+jRA4mJiXByclJ1VCKiMs3a2hrnz5+HoaEh2rZti+nTp+PRo0dFnvP69Wts2LABTZs2xW+//YZDhw5h2LBhpZSYiIi0gbOzM44ePYrff/8dzZo1w7p165CUlFTkOU+ePMGcOXPQunVrCIKAc+fOwdbWtnQCExGRVpg7dy62bt2KwMBANG/eHHv37kV6enqR59y6dQsjR45E3759YWtri19++QUmJiallFizKHWPcs5aivIsrpmQkKDMSxARkQQaNWqEK1euYPny5VizZg3WrVuHnj17ol27dmjZsiWePn0K4P2XRqtXr8bhw4eRmpoKV1dXrFu3Lt+XS0RERPJwdHTEzZs3MWPGDMycORO+vr7o168fWrdujfLlywMAfv75Z0RERODy5cs4duwYDAwMMHPmTMybNy+3DRERkSK8vLzg6OiISZMmwc3NDVOnTkW/fv1gZ2eXuyboiRMnEBwcjHPnzuHXX3+Fqakpdu7cCU9PTy7jUQSlJxy5gQsRkXbS19fH/PnzMXXqVOzZswehoaH49ttv8fLly9w2mzdvhq2tLaZNm4Zx48ahdu3aEiYmIiJtULVqVezYsQNLlizBjh07EBkZmfvFFgBMmzYNVapUgZ2dHfz8/DBy5EhUrlxZ4tRERKTpGjRogGPHjuH333/Htm3b8MsvvyAgIACZmZkAgK+++go1a9ZE69at8cMPP2DgwIEl2uisrOAuLEREVKCKFSvC29sb3t7eEAQBT58+xYsXL/Dw4UN07NgRlSpVkjoiERFpoRo1amDevHmYN28esrKycO/ePcTFxcHa2hoWFha8moSIiFSiadOm8PPzA/B+A+OEhATcvn0bNjY2MDc3lzacBuKEIxERFUsmk6FGjRqoUaMGrK2tpY5DRERlhK6uLho1aoRGjRpJHYWIiMoQAwMDNGnSBE2aNJE6isbihCPRB+Li4qSOAECxHOqSOYe65SEi0gTqMHYqmkEdMn9I3fIQEWkCdRg7WX+ItBMnHIkAGBsbw8jICO7u7lJHyWVkZFTkBhzqmDlHcdmJiOg9dRvL5Rm/1S3zh1h/iIjko25jOesPkfaRCTnb7hCVcQ8fPkRiYqLUMXIZGxsXu06EumXOIU92IiJ6T53GcnnHb3XK/CHWHyIi+anTWM76Q6R9OOFIREREREREREREotGROgARERERERERERFpD044EhERERERERERkWg44UhERERERERERESi4YQjERERERERERERiYYTjkRERERERERERCQaTjgSERERERERERGRaDjhSERERERERERERKLhhCMRERERERERERGJhhOOREREREREREREJBpOOBIREREREREREZFoOOFIREREREREREREouGEIxEREREREREREYmGE45EREREREREREQkGk44EhERERERERERkWg44UhERERERERERESi+X+NQu7qUtn7sgAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 1620x240 with 1 Axes>"
       ]
@@ -118,15 +98,15 @@
     "model = QuantumModel(\n",
     "    circuit_structure=build_vqe_circuit(nqubits=nqubits, nlayers=nlayers),\n",
     "    decoding=decoding,\n",
-    "    differentiation=None,\n",
+    "    differentiation=PSR(),\n",
     ")\n",
     "\n",
-    "model.draw()"
+    "_ = model.draw()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 23,
    "id": "473d1ba4-a186-43fa-ae64-9f97c35c543e",
    "metadata": {},
    "outputs": [
@@ -144,24 +124,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 24,
    "id": "bf603c38-bb9a-4b10-8c7b-49879055714d",
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Iteration 0: Cost = 0.798020\n",
-      "Iteration 20: Cost = -3.750246\n",
-      "Iteration 40: Cost = -6.350567\n",
-      "Iteration 60: Cost = -6.683885\n",
-      "Iteration 80: Cost = -6.733274\n",
-      "Iteration 100: Cost = -6.738381\n",
-      "Iteration 120: Cost = -6.740079\n",
-      "Iteration 140: Cost = -6.740863\n",
-      "Iteration 160: Cost = -6.741506\n",
-      "Iteration 180: Cost = -6.742051\n"
+     "ename": "AttributeError",
+     "evalue": "'NoneType' object has no attribute 'clone'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_17496/3129168095.py\u001b[0m in \u001b[0;36m<cell line: 0>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0miteration\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0mcost\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mcost\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/dev/lib/python3.11/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1737\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1738\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1739\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1740\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1741\u001b[0m     \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/dev/lib/python3.11/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1748\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1749\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1750\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1751\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1752\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Documents/PhD/qiboml/src/qiboml/interfaces/pytorch.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     86\u001b[0m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecoding\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 88\u001b[0;31m             x = QuantumModelAutoGrad.apply(\n\u001b[0m\u001b[1;32m     89\u001b[0m                 \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcircuit_structure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/dev/lib/python3.11/site-packages/torch/autograd/function.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m    573\u001b[0m             \u001b[0;31m# See NOTE: [functorch vjp and autograd interaction]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    574\u001b[0m             \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_functorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munwrap_dead_wrappers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 575\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    576\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    577\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_setup_ctx_defined\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Documents/PhD/qiboml/src/qiboml/interfaces/pytorch.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(ctx, x, circuit_structure, decoding, backend, differentiation, *parameters)\u001b[0m\n\u001b[1;32m    176\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    177\u001b[0m         \u001b[0;31m# Cloning, detaching and converting to backend arrays\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m         \u001b[0mx_clone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdetach\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    179\u001b[0m         \u001b[0mx_clone\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_clone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx_clone\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    180\u001b[0m         params = [\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'clone'"
      ]
     }
    ],