diff --git a/examples/QuantumNAS/quantumnas.ipynb b/examples/QuantumNAS/quantumnas.ipynb
new file mode 100644
index 00000000..bc8ec0b8
--- /dev/null
+++ b/examples/QuantumNAS/quantumnas.ipynb
@@ -0,0 +1,14341 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8c9NBZ6t9JlZ",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "# Setup"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KaKMLJng1qke",
+        "outputId": "1bf252ff-2af8-40c6-95d4-e0f5cb7aae80",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Installing torchquantum...\n",
+            "Cloning into 'torchquantum'...\n",
+            "remote: Enumerating objects: 14088, done.\u001b[K\n",
+            "remote: Counting objects: 100% (2359/2359), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (1019/1019), done.\u001b[K\n",
+            "remote: Total 14088 (delta 1390), reused 2129 (delta 1248), pack-reused 11729\u001b[K\n",
+            "Receiving objects: 100% (14088/14088), 105.49 MiB | 28.00 MiB/s, done.\n",
+            "Resolving deltas: 100% (7747/7747), done.\n",
+            "Updating files: 100% (223/223), done.\n",
+            "/content/torchquantum\n"
+          ]
+        }
+      ],
+      "source": [
+        "print('Installing torchquantum...')\n",
+        "!git clone -b isca https://github.com/mit-han-lab/torchquantum.git\n",
+        "%cd /content/torchquantum\n",
+        "!pip install --editable . 1>/dev/null\n",
+        "# print('All required packages have been successfully installed!')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wpUx-xoonx5K",
+        "outputId": "491e687a-915c-4feb-cacb-c5fe08f5136a",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+            "arviz 0.15.1 requires matplotlib>=3.2, but you have matplotlib 3.1.3 which is incompatible.\n",
+            "mizani 0.9.3 requires matplotlib>=3.5.0, but you have matplotlib 3.1.3 which is incompatible.\n",
+            "plotnine 0.12.3 requires matplotlib>=3.6.0, but you have matplotlib 3.1.3 which is incompatible.\n",
+            "torchquantum 0.1.7 requires matplotlib>=3.3.2, but you have matplotlib 3.1.3 which is incompatible.\u001b[0m\u001b[31m\n",
+            "\u001b[0mCollecting torchdiffeq\n",
+            "  Downloading torchdiffeq-0.2.3-py3-none-any.whl (31 kB)\n",
+            "Requirement already satisfied: torch>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from torchdiffeq) (2.0.1+cu118)\n",
+            "Requirement already satisfied: scipy>=1.4.0 in /usr/local/lib/python3.10/dist-packages (from torchdiffeq) (1.11.3)\n",
+            "Requirement already satisfied: numpy<1.28.0,>=1.21.6 in /usr/local/lib/python3.10/dist-packages (from scipy>=1.4.0->torchdiffeq) (1.23.5)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (3.12.4)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (4.5.0)\n",
+            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (1.12)\n",
+            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (3.1)\n",
+            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (3.1.2)\n",
+            "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.3.0->torchdiffeq) (2.0.0)\n",
+            "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.3.0->torchdiffeq) (3.27.6)\n",
+            "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=1.3.0->torchdiffeq) (17.0.2)\n",
+            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.3.0->torchdiffeq) (2.1.3)\n",
+            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=1.3.0->torchdiffeq) (1.3.0)\n",
+            "Installing collected packages: torchdiffeq\n",
+            "Successfully installed torchdiffeq-0.2.3\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install tensorflow_model_optimization . 1>/dev/null\n",
+        "# !ls artifact\n",
+        "# !cp artifact/aerbackend.py ../../usr/local/lib/python3.7/dist-packages/qiskit/providers/aer/backends/ -r\n",
+        "# !wget https://www.dropbox.com/s/pvoqeab2z2cazke/max-acc-valid.pt\n",
+        "!pip install matplotlib==3.1.3 1>/dev/null\n",
+        "!pip install torchdiffeq\n",
+        "%matplotlib inline"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "w-yEeEJFKfjf",
+        "outputId": "7d3be931-305d-4e44-b7fa-91bc1adf455a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "--2023-10-15 20:02:09--  https://www.dropbox.com/s/pvoqeab2z2cazke/max-acc-valid.pt\n",
+            "Resolving www.dropbox.com (www.dropbox.com)... 162.125.3.18, 2620:100:6030:18::a27d:5012\n",
+            "Connecting to www.dropbox.com (www.dropbox.com)|162.125.3.18|:443... connected.\n",
+            "HTTP request sent, awaiting response... 302 Found\n",
+            "Location: /s/raw/pvoqeab2z2cazke/max-acc-valid.pt [following]\n",
+            "--2023-10-15 20:02:09--  https://www.dropbox.com/s/raw/pvoqeab2z2cazke/max-acc-valid.pt\n",
+            "Reusing existing connection to www.dropbox.com:443.\n",
+            "HTTP request sent, awaiting response... 302 Found\n",
+            "Location: https://uc81abd662c48c14921279d415de.dl.dropboxusercontent.com/cd/0/inline/CFpTc9Q69WYcxJJP7c7HueMNsfG-GvwQoZhE5ZZfVBT-jfD3JDc_biilmNAJOl5RGEC99GUTZdRas4pxTtucpzflTvXh-2va2N9pcijkWMi2u9k1GS0AvyUabZt7x3XPSgjE_OS8BafQFJeBZ5S0hbNU/file# [following]\n",
+            "--2023-10-15 20:02:09--  https://uc81abd662c48c14921279d415de.dl.dropboxusercontent.com/cd/0/inline/CFpTc9Q69WYcxJJP7c7HueMNsfG-GvwQoZhE5ZZfVBT-jfD3JDc_biilmNAJOl5RGEC99GUTZdRas4pxTtucpzflTvXh-2va2N9pcijkWMi2u9k1GS0AvyUabZt7x3XPSgjE_OS8BafQFJeBZ5S0hbNU/file\n",
+            "Resolving uc81abd662c48c14921279d415de.dl.dropboxusercontent.com (uc81abd662c48c14921279d415de.dl.dropboxusercontent.com)... 162.125.64.15, 2620:100:6030:15::a27d:500f\n",
+            "Connecting to uc81abd662c48c14921279d415de.dl.dropboxusercontent.com (uc81abd662c48c14921279d415de.dl.dropboxusercontent.com)|162.125.64.15|:443... connected.\n",
+            "HTTP request sent, awaiting response... 302 Found\n",
+            "Location: /cd/0/inline2/CFp3Sb4ZOtKuNnQ-53Bq68RjM98_N_tKFJDIY6QCjAjOvRNdyoFIMW5v4BwV3aVJiwbp-__xXIw7-O2YAebDX917fcU9J02X64BVJpakzU6GaNl6mtQpNjSS9EuIi2lDdUp2ezSNgpuOah537TRmvMwTfVX4ofGN6h7BznB8XrkrdMLFzcmluj3hv06wvNtlhTkcx-amjZzc94Xd5YXvuKEsyK9g8XCVZJdQ9I5sPpos2ocXSdOjs16E8iJXLTeiiCjgZDxgOS2NX1eW6Kz1k2kxyC11Cy6lu0EwUe6jyHCF0Xxv53C1rIawO-tz6Y6NTpN7YnhxYZkMjqj7a6SUiWlLjZGjG3tHsEay2HR3LfdoixeHpetrQ9vo3yukbkWZ1U4/file [following]\n",
+            "--2023-10-15 20:02:10--  https://uc81abd662c48c14921279d415de.dl.dropboxusercontent.com/cd/0/inline2/CFp3Sb4ZOtKuNnQ-53Bq68RjM98_N_tKFJDIY6QCjAjOvRNdyoFIMW5v4BwV3aVJiwbp-__xXIw7-O2YAebDX917fcU9J02X64BVJpakzU6GaNl6mtQpNjSS9EuIi2lDdUp2ezSNgpuOah537TRmvMwTfVX4ofGN6h7BznB8XrkrdMLFzcmluj3hv06wvNtlhTkcx-amjZzc94Xd5YXvuKEsyK9g8XCVZJdQ9I5sPpos2ocXSdOjs16E8iJXLTeiiCjgZDxgOS2NX1eW6Kz1k2kxyC11Cy6lu0EwUe6jyHCF0Xxv53C1rIawO-tz6Y6NTpN7YnhxYZkMjqj7a6SUiWlLjZGjG3tHsEay2HR3LfdoixeHpetrQ9vo3yukbkWZ1U4/file\n",
+            "Reusing existing connection to uc81abd662c48c14921279d415de.dl.dropboxusercontent.com:443.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 50439 (49K) [application/octet-stream]\n",
+            "Saving to: ‘max-acc-valid.pt.1’\n",
+            "\n",
+            "max-acc-valid.pt.1  100%[===================>]  49.26K   279KB/s    in 0.2s    \n",
+            "\n",
+            "2023-10-15 20:02:11 (279 KB/s) - ‘max-acc-valid.pt.1’ saved [50439/50439]\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "!wget https://www.dropbox.com/s/pvoqeab2z2cazke/max-acc-valid.pt"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "02aTGqazoQP4",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "import argparse\n",
+        "import os\n",
+        "import sys\n",
+        "import pdb\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "import torch.backends.cudnn\n",
+        "import torch.cuda\n",
+        "import torch.nn\n",
+        "import torch.utils.data\n",
+        "import torchquantum as tq\n",
+        "import tqdm\n",
+        "import random\n",
+        "\n",
+        "from torchpack.utils import io\n",
+        "# from torchpack import distributed as dist\n",
+        "from torchpack.environ import set_run_dir\n",
+        "from torchpack.utils.config import configs\n",
+        "from torchpack.utils.logging import logger\n",
+        "from torchquantum.datasets import MNIST\n",
+        "import torch.optim as optim\n",
+        "\n",
+        "from torchquantum.plugins import tq2qiskit, qiskit2tq\n",
+        "from torchquantum.utils import (build_module_from_op_list,\n",
+        "                                build_module_op_list,\n",
+        "                                get_v_c_reg_mapping,\n",
+        "                                get_p_c_reg_mapping,\n",
+        "                                get_p_v_reg_mapping,\n",
+        "                                get_cared_configs)\n",
+        "from torchquantum.super_utils import get_named_sample_arch\n",
+        "from torch.utils.tensorboard import SummaryWriter"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "p7BluZ5WEw_H",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "# **2. QuantumNAS with TorchQuantum**"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-cE2SxIwnrM7",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "## 2.1 QuantumNAS: Circuit Search and Pruning"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LW4qHrUVn5dX",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        " **Goals**\n",
+        "\n",
+        "In this sectio you will practice searching an optimal subcircuit from a supercircuit and pruning the searched subcircuit to reduce the impact of noise and improve accuracy on real Quantum Computer. The goals of this assignment are as follows:\n",
+        "\n",
+        "- Understand the basic concept of **supercircuit** and **subcircuit**\n",
+        "- Implement and apply **Evolutionary Search**\n",
+        "- Implement and apply **Pruning**\n",
+        "- Get a basic understanding of performance improvement (such as accuracy) from **Evolutionary Search** and **Pruning**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "gWadMc1vsYUs",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "import torchquantum as tq\n",
+        "import torchquantum.functional as tqf\n",
+        "import torch.nn.functional as F\n",
+        "\n",
+        "from torchpack.utils.logging import logger\n",
+        "from torchquantum.encoding import encoder_op_list_name_dict\n",
+        "from torchquantum.super_layers import super_layer_name_dict\n",
+        "\n",
+        "from torchquantum.plugins import (\n",
+        "    tq2qiskit_measurement,\n",
+        "    qiskit_assemble_circs,\n",
+        "    op_history2qiskit,\n",
+        "    op_history2qiskit_expand_params,\n",
+        ")\n",
+        "\n",
+        "class SuperQFCModel0(tq.QuantumModule):\n",
+        "    def __init__(self, arch):\n",
+        "        super().__init__()\n",
+        "        self.arch = arch\n",
+        "        self.n_wires = arch['n_wires']\n",
+        "        # self.q_device = tq.QuantumDevice(n_wires=self.n_wires)\n",
+        "        self.encoder = tq.GeneralEncoder(\n",
+        "            encoder_op_list_name_dict[arch['encoder_op_list_name']]\n",
+        "        )\n",
+        "        self.q_layer = super_layer_name_dict[arch['q_layer_name']](arch)\n",
+        "        self.measure = tq.MeasureAll(tq.PauliZ)\n",
+        "        self.sample_arch = None\n",
+        "\n",
+        "    def set_sample_arch(self, sample_arch):\n",
+        "        self.sample_arch = sample_arch\n",
+        "        self.q_layer.set_sample_arch(sample_arch)\n",
+        "\n",
+        "    def count_sample_params(self):\n",
+        "        return self.q_layer.count_sample_params()\n",
+        "\n",
+        "    def forward(self, x, verbose=False, use_qiskit=False):\n",
+        "        bsz = x.shape[0]\n",
+        "        qdev = tq.QuantumDevice(n_wires=self.n_wires, bsz=bsz, record_op=True, device=x.device)\n",
+        "        # self.q_device.reset_states(bsz=bsz)\n",
+        "\n",
+        "        if getattr(self.arch, 'down_sample_kernel_size', None) is not None:\n",
+        "            x = F.avg_pool2d(x, self.arch['down_sample_kernel_size'])\n",
+        "\n",
+        "        x = x.view(bsz, -1)\n",
+        "\n",
+        "        if use_qiskit:\n",
+        "            # use qiskit to process the circuit\n",
+        "            # create the qiskit circuit for encoder\n",
+        "            self.encoder(qdev, x)\n",
+        "            op_history_parameterized = qdev.op_history\n",
+        "            qdev.reset_op_history()\n",
+        "            encoder_circs = op_history2qiskit_expand_params(self.n_wires, op_history_parameterized, bsz=bsz)\n",
+        "\n",
+        "            # create the qiskit circuit for trainable quantum layers\n",
+        "            self.q_layer(qdev)\n",
+        "            op_history_fixed = qdev.op_history\n",
+        "            qdev.reset_op_history()\n",
+        "            q_layer_circ = op_history2qiskit(self.n_wires, op_history_fixed)\n",
+        "\n",
+        "            # create the qiskit circuit for measurement\n",
+        "            measurement_circ = tq2qiskit_measurement(qdev, self.measure)\n",
+        "\n",
+        "            # assemble the encoder, trainable quantum layers, and measurement circuits\n",
+        "            assembled_circs = qiskit_assemble_circs(\n",
+        "                encoder_circs, q_layer_circ, measurement_circ\n",
+        "            )\n",
+        "\n",
+        "            # call the qiskit processor to process the circuit\n",
+        "            x0 = self.qiskit_processor.process_ready_circs(qdev, assembled_circs).to(  # type: ignore\n",
+        "                x.device\n",
+        "            )\n",
+        "            x = x0\n",
+        "\n",
+        "            # x = self.qiskit_processor.process_parameterized(\n",
+        "                # self.q_device, self.encoder, self.q_layer, self.measure, x)\n",
+        "        else:\n",
+        "            self.encoder(qdev, x)\n",
+        "            self.q_layer(qdev)\n",
+        "            x = self.measure(qdev)\n",
+        "\n",
+        "        if verbose:\n",
+        "            logger.info(f\"[use_qiskit]={use_qiskit}, expectation:\\n {x.data}\")\n",
+        "\n",
+        "        if getattr(self.arch, 'output_len', None) is not None:\n",
+        "            x = x.reshape(bsz, -1, self.arch.output_len).sum(-1)\n",
+        "\n",
+        "        if x.dim() > 2:\n",
+        "            x = x.squeeze()\n",
+        "\n",
+        "        x = F.log_softmax(x, dim=1)\n",
+        "        return x\n",
+        "\n",
+        "    @property\n",
+        "    def arch_space(self):\n",
+        "        space = []\n",
+        "        for layer in self.q_layer.super_layers_all:\n",
+        "            space.append(layer.arch_space)\n",
+        "        # for the number of sampled blocks\n",
+        "        space.append(list(range(self.q_layer.n_front_share_blocks,\n",
+        "                                self.q_layer.n_blocks + 1)))\n",
+        "        return space\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Q1Xidh0AsopD",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "**Load configs**\n",
+        "\n",
+        "The config file describes everything about the model structure."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "724tThVysiJw",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "config_str = '''model:\n",
+        "  arch:\n",
+        "    n_wires: 4\n",
+        "    encoder_op_list_name: 4x4_ryzxy\n",
+        "    n_blocks: 3\n",
+        "    n_layers_per_block: 2\n",
+        "    q_layer_name: u3cu3_s0\n",
+        "    down_sample_kernel_size: 6\n",
+        "    n_front_share_blocks: 1\n",
+        "    n_front_share_wires: 1\n",
+        "    n_front_share_ops: 1\n",
+        "  sampler:\n",
+        "    strategy:\n",
+        "      name: plain\n",
+        "  transpile_before_run: False\n",
+        "  load_op_list: False\n",
+        "\n",
+        "dataset:\n",
+        "  name: mnist\n",
+        "  input_name: image\n",
+        "  target_name: digit\n",
+        "\n",
+        "optimizer:\n",
+        "  name: adam\n",
+        "  lr: 5e-2\n",
+        "  weight_decay: 1e-4\n",
+        "  lambda_lr: 1e-2\n",
+        "\n",
+        "run:\n",
+        "  n_epochs: 40\n",
+        "  bsz: 256\n",
+        "  workers_per_gpu: 2\n",
+        "  device: gpu\n",
+        "\n",
+        "debug:\n",
+        "  pdb: False\n",
+        "  set_seed: True\n",
+        "  seed: 42\n",
+        "\n",
+        "callbacks:\n",
+        "  - callback: 'InferenceRunner'\n",
+        "    split: 'valid'\n",
+        "    subcallbacks:\n",
+        "      - metrics: 'CategoricalAccuracy'\n",
+        "        name: 'acc/valid'\n",
+        "      - metrics: 'NLLError'\n",
+        "        name: 'loss/valid'\n",
+        "  - callback: 'InferenceRunner'\n",
+        "    split: 'test'\n",
+        "    subcallbacks:\n",
+        "      - metrics: 'CategoricalAccuracy'\n",
+        "        name: 'acc/test'\n",
+        "      - metrics: 'NLLError'\n",
+        "        name: 'loss/test'\n",
+        "  - callback: 'MaxSaver'\n",
+        "    name: 'acc/valid'\n",
+        "  - callback: 'Saver'\n",
+        "    max_to_keep: 10\n",
+        "\n",
+        "qiskit:\n",
+        "  use_qiskit: False\n",
+        "  use_real_qc: False\n",
+        "  backend_name: null\n",
+        "  noise_model_name: null\n",
+        "  basis_gates_name: null\n",
+        "  n_shots: 8192\n",
+        "  initial_layout: null\n",
+        "  seed_transpiler: 42\n",
+        "  seed_simulator: 42\n",
+        "  optimization_level: 0\n",
+        "  est_success_rate: False\n",
+        "  max_jobs: 1\n",
+        "\n",
+        "\n",
+        "es:\n",
+        "  random_search: False\n",
+        "  population_size: 100\n",
+        "  parent_size: 20\n",
+        "  mutation_size: 40\n",
+        "  mutation_prob: 0.5\n",
+        "  crossover_size: 40\n",
+        "  n_iterations: 5\n",
+        "  est_success_rate: False\n",
+        "  score_mode: loss_succ\n",
+        "  gene_mask: null\n",
+        "  eval:\n",
+        "    use_noise_model: False\n",
+        "    use_real_qc: False\n",
+        "    bsz: qiskit_max\n",
+        "    n_test_samples: 150\n",
+        "\n",
+        "\n",
+        "prune:\n",
+        "  target_pruning_amount : 0.5\n",
+        "  init_pruning_amount : 0.1\n",
+        "  start_epoch : 0\n",
+        "  end_epoch : 30\n",
+        "\n",
+        "'''\n",
+        "f = open(\"configs.yml\", \"w\")\n",
+        "f.write(config_str)\n",
+        "f.close()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "2N52sKjzssBP",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "configs.load('configs.yml')\n",
+        "if configs.debug.set_seed:\n",
+        "    torch.manual_seed(configs.debug.seed)\n",
+        "    np.random.seed(configs.debug.seed)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0kphBPbasxHc",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "Load the model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DI6G_q2wsu4T",
+        "outputId": "f0f3451a-8f41-47ed-ff1f-e4838a059239",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 9912422/9912422 [00:00<00:00, 100055378.46it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Extracting ./mnist_data/MNIST/raw/train-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw\n",
+            "\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 28881/28881 [00:00<00:00, 33472145.30it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Extracting ./mnist_data/MNIST/raw/train-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw\n",
+            "\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "100%|██████████| 1648877/1648877 [00:00<00:00, 23373815.90it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Extracting ./mnist_data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./mnist_data/MNIST/raw\n",
+            "\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
+            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 4542/4542 [00:00<00:00, 1021859.61it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Extracting ./mnist_data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./mnist_data/MNIST/raw\n",
+            "\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\u001b[32m[2023-10-15 20:02:51.847]\u001b[0m \u001b[33m\u001b[1mOnly use the front 5000 images as TRAIN set.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:02:51.973]\u001b[0m \u001b[33m\u001b[1mOnly use the front 3000 images as VALID set.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:02:51.991]\u001b[0m \u001b[33m\u001b[1mOnly use the front 300 images as TEST set.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:02:52.549]\u001b[0m \u001b[1mModel Size: 72\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "device = torch.device('cuda')\n",
+        "if isinstance(configs.optimizer.lr, str):\n",
+        "    configs.optimizer.lr = eval(configs.optimizer.lr)\n",
+        "dataset = MNIST(\n",
+        "    root='./mnist_data',\n",
+        "    train_valid_split_ratio=[0.9, 0.1],\n",
+        "    digits_of_interest=[0, 1, 2, 3],\n",
+        "    n_test_samples=300,\n",
+        "    n_train_samples=5000,\n",
+        "    n_valid_samples=3000,\n",
+        ")\n",
+        "dataflow = dict()\n",
+        "for split in dataset:\n",
+        "    sampler = torch.utils.data.RandomSampler(dataset[split])\n",
+        "    dataflow[split] = torch.utils.data.DataLoader(\n",
+        "        dataset[split],\n",
+        "        batch_size=configs.run.bsz,\n",
+        "        sampler=sampler,\n",
+        "        num_workers=configs.run.workers_per_gpu,\n",
+        "        pin_memory=True)\n",
+        "model = SuperQFCModel0(configs.model.arch)\n",
+        "state_dict = io.load('max-acc-valid.pt', map_location='cpu')\n",
+        "model.load_state_dict(state_dict['model'], strict=False)\n",
+        "model.to(device)\n",
+        "model.set_sample_arch([4,4,4,4,4,4,3])\n",
+        "total_params = sum(p.numel() for p in model.parameters())\n",
+        "logger.info(f'Model Size: {total_params}')\n",
+        "\n",
+        "def log_acc(output_all, target_all, k=1):\n",
+        "    _, indices = output_all.topk(k, dim=1)\n",
+        "    masks = indices.eq(target_all.view(-1, 1).expand_as(indices))\n",
+        "    size = target_all.shape[0]\n",
+        "    corrects = masks.sum().item()\n",
+        "    accuracy = corrects / size\n",
+        "    loss = F.nll_loss(output_all, target_all).item()\n",
+        "    logger.info(f\"Accuracy: {accuracy}\")\n",
+        "    logger.info(f\"Loss: {loss}\")\n",
+        "    return accuracy\n",
+        "\n",
+        "def evaluate_gene(gene=None, use_qiskit=False):\n",
+        "    if gene is not None:\n",
+        "        model.set_sample_arch(gene)\n",
+        "    with torch.no_grad():\n",
+        "        target_all = None\n",
+        "        output_all = None\n",
+        "        for feed_dict in tqdm.tqdm(dataflow['test']):\n",
+        "            if configs.run.device == 'gpu':\n",
+        "                # pdb.set_trace()\n",
+        "                inputs = feed_dict[configs.dataset.input_name].cuda(non_blocking=True)\n",
+        "                targets = feed_dict[configs.dataset.target_name].cuda(non_blocking=True)\n",
+        "            else:\n",
+        "                inputs = feed_dict[configs.dataset.input_name]\n",
+        "                targets = feed_dict[configs.dataset.target_name]\n",
+        "            outputs = model(inputs, use_qiskit=use_qiskit)\n",
+        "            if target_all is None:\n",
+        "                target_all = targets\n",
+        "                output_all = outputs\n",
+        "            else:\n",
+        "                target_all = torch.cat([target_all, targets], dim=0)\n",
+        "                output_all = torch.cat([output_all, outputs], dim=0)\n",
+        "        accuracy = log_acc(output_all, target_all)\n",
+        "    return accuracy"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "CSiUP-4atKk6",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "**Let's use the model to predict MNIST images**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 321
+        },
+        "id": "phZ_woE_tPOw",
+        "outputId": "5e5b2ab5-5808-4e31-bf2e-8bc2fe706dd7",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAB6EAAAGNCAYAAABQcwTMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfzklEQVR4nO39eZzVdd0//j8PAgOyDKKxGKAIbiUquSAqhle4VAJKmluJS3ZpoCmpl5ailoYf9zUtLTS/mUmK63WhhqhhgIlSLohplhuLS+zJNu/fH/2c65rOIMPM+8z7fc7c77fb3G4zr3PO6/V8nfN+zDlnnnPOKSRJkgQAAAAAAAAApKBV1gUAAAAAAAAAUDk0oQEAAAAAAABIjSY0AAAAAAAAAKnRhAYAAAAAAAAgNZrQAAAAAAAAAKRGExoAAAAAAACA1GhCAwAAAAAAAJAaTWgAAAAAAAAAUqMJDQAAAAAAAEBqNKEBAAAAAAAASE1ZNKFvuumm2HrrraNdu3YxaNCgePbZZ7MuCQAAAAAAAIB6FJIkSbIu4tP85je/ieOOOy5uueWWGDRoUFx77bUxadKkmDdvXnTr1m2Dl6+pqYn33nsvOnXqFIVCoRkqptwlSRLLli2LLbfcMlq1Kov/09ggOWBjyQHIAUTIAUTIAUTIAUTIAUTIAUTIAUQ0PAe5b0IPGjQo9thjj7jxxhsj4l9h6N27d5x22mlx7rnnbvDy77zzTvTu3bvUZVKB3n777ejVq1fWZaRCDmgsOQA5gAg5gAg5gAg5gAg5gAg5gAg5gIgN5yDX/6axevXqmD17dgwbNqx2rFWrVjFs2LCYMWNGvZdZtWpVLF26tPYr5z12cqxTp05Zl5CaStoLzauSjp1K2gvNq5KOnUraC82rko6dStoLzauSjp1K2gvNq5KOnUraC82rko6dStoLzauSjp1K2gvNq5KOnUraC81rQ8dOrpvQH3zwQaxbty66d+9eZ7x79+6xYMGCei8zYcKEqK6urv3q06dPc5RKBaqkt52opL3QvCrp2KmkvdC8KunYqaS90Lwq6dippL3QvCrp2KmkvdC8KunYqaS90Lwq6dippL3QvCrp2KmkvdC8KunYqaS90Lw2dOzkugndGOedd14sWbKk9uvtt9/OuiQAAAAAAACAFqN11gV8mi222CI22WSTWLhwYZ3xhQsXRo8ePeq9TFVVVVRVVTVHeQAAAAAAAAD8m1y/Erpt27ax2267xdSpU2vHampqYurUqTF48OAMKwMAAAAAAACgPrl+JXRExLhx42L06NGx++67x5577hnXXnttrFixIk444YSsSwMAAAAAAADg3+S+CX3kkUfG+++/H+PHj48FCxbErrvuGlOmTInu3btnXRoAAAAAAAAA/yb3TeiIiLFjx8bYsWOzLgMAAAAAAACADcj1Z0IDAAAAAAAAUF40oQEAAAAAAABIjSY0AAAAAAAAAKnRhAYAAAAAAAAgNZrQAAAAAAAAAKSmddYF0HCvv/560Vi/fv2aZe2HHnqoaGzEiBHNsjYAQFYOPPDAorFHH3200fMVCoWmlAMAAAAAZcEroQEAAAAAAABIjSY0AAAAAAAAAKnRhAYAAAAAAAAgNZrQAAAAAAAAAKSmddYFELHLLrsUjc2ZM6f5C/kUw4cPLxpLkqRorFAoNEc5ADRSfb+718fvdMrNzJkzi8YGDRqUQSXr5/ET5aih9x2OZbKwMY9tGqJjx471jq9YsSLVdQBovBtuuKFo7KSTTioaa9++fXOU0yQnnHBC0djtt9/e/IUAtDBTpkwpGjvooIMyqGT9evbsWTS2YMGCDCppPK+EBgAAAAAAACA1mtAAAAAAAAAApEYTGgAAAAAAAIDUaEIDAAAAAAAAkJrWWRdAxJw5c7IuITVJkhSNFQqFDCqhpauuri4aW7x4cYMvP2jQoKKxZ599tiklAdAAPXr0KBqbP39+BpUA0FxuvfXWorFvfetbGVQSsXz58gaf13Nd8mz48OFFYw8++GCzrP3b3/62aOyII45olrWpPAsXLiwa69atWwaVlMbEiROLxm6//fbmLwSgDG233XZFY/PmzcugktKo7+9h5fYcxCuhAQAAAAAAAEiNJjQAAAAAAAAAqdGEBgAAAAAAACA1mtAAAAAAAAAApKZ11gUQMWDAgKKxF198MYNK/uWuu+4qGjvmmGMaPd/MmTOLxvbaa69Gzwf/rrq6umhs8eLFTZpz1qxZRWO//e1vi8bWrVvXoPnefvvtorGzzz574wuDZlTf8b3JJptkUAktyfz587MuoY5TTjmlQee75ZZbGr3GqaeeWjR28803N3o+aKwrrriiSZf/+te/XjR2zz33NGlOWoZvfetbWZfQKEmSFI0VCoUMKqElmTRpUtHY4YcfnkEl65e3eihv3bp1y7qEZtemTZuisTVr1mRQCeWmvscmDeUxDOVo3rx5JV9jzpw59Y4PHDgw1XUamt9yew7ildAAAAAAAAAApEYTGgAAAAAAAIDUaEIDAAAAAAAAkBpNaAAAAAAAAABS0zrrAoh46aWXGn3ZyZMnF42NGjWqKeXU65hjjmn0ZQcNGpRiJVBs8eLFzbLO4Ycfnup8Z511VoPO16VLl6KxJUuWpFoL1KdVK/+rRvM7++yzi8auuOKKRs83YMCAorGmPPZan1tuuaXRlz3kkEOKxm6++eamlAON0tDHJuuzzz77FI3dc889TZoT/q/f//73RWP77bdfo+e77rrrisZOP/30Rs8XEZEkSdFYoVBo0py0XPUdT2krxfFZX92TJk0qGjviiCNSXxsqwerVq4vG3Je0bM1xf3DrrbcWjZ188slNmvPuu+8uGttyyy2LxoYMGdKg+eSAxpozZ07R2MCBA5u/kBbIX5cBAAAAAAAASI0mNAAAAAAAAACp0YQGAAAAAAAAIDWa0AAAAAAAAACkpnXWBVC/QqGQdQl11FfPsmXLisY6duzYHOXQgi1evDjrEppdfXvef//9i8aefPLJ0hcDUGJXXnllg8aA/Pnud7+bdQmUqcMPP7xo7Le//W3R2Ouvv57quvUds+s7jpMkafQ69V02b8/5yV5TjrH6OMYAylPa9wcNdfLJJzf4vFnV2NB13Qfy7wYOHJh1CSXVq1evorF33nkng0qKeSU0AAAAAAAAAKnRhAYAAAAAAAAgNZrQAAAAAAAAAKRGExoAAAAAAACA1LTOugDKV6dOnYrGkiRp0GXrO1+hUGhyTVS+6urqrEvIhWnTphWNDRgwoGjspZdeao5yqFA1NTVZlwBlo77HMQ19XATQ0t17771FY3l7fvitb32raOy2227LoBIqwaRJkxp92bxlw+MdSm3IkCFFY7///e8bdNm2bds2et3Vq1c3+rLQUGn/Ds3bfURW9B5ajnK9XZ955plU53vnnXdSnS9NXgkNAAAAAAAAQGo0oQEAAAAAAABIjSY0AAAAAAAAAKnJtAn99NNPx/Dhw2PLLbeMQqEQ999/f53TkySJ8ePHR8+ePaN9+/YxbNiw+Mtf/pJNsQAAAAAAAABsUOssF1+xYkXssssuceKJJ8aoUaOKTr/88svj+uuvjzvuuCP69u0bF1xwQRx00EHxyiuvRLt27TKoGKg0hUIh6xLqSJKk0Zd98cUXi8bytj+AStWU398A5N/Pf/7zorHbbrstg0qoBEcccUTWJTRKUx7vlOueyd706dOLxpryt44OHToUjS1fvrzR85WCv+VUprSfM2Z5nGS19te+9rWisd/+9rcZVAJNs/feezf6srvvvnuKlZRepk3oL3/5y/HlL3+53tOSJIlrr702zj///Bg5cmRERPzyl7+M7t27x/333x9HHXVUc5YKAAAAAAAAQAPk9jOh33zzzViwYEEMGzasdqy6ujoGDRoUM2bMWO/lVq1aFUuXLq3zBQAAAAAAAEDzaHQT+o033ojzzz8/jj766Fi0aFFERPzP//xPvPzyy6kUtmDBgoiI6N69e53x7t27155WnwkTJkR1dXXtV+/evVOpBwAAAAAAAIANa1QT+qmnnooBAwbErFmz4r777qv93Iw//elPceGFF6Za4MY677zzYsmSJbVfb7/9dqb1AAAAAAAAALQkjfpM6HPPPTcuueSSGDduXHTq1Kl2/D/+4z/ixhtvTKWwHj16RETEwoULo2fPnrXjCxcujF133XW9l6uqqoqqqqpUaqB5HXjggUVjjz32WAaVkBdJkqQ635AhQ1KdrxQKhULRWNrXAy3Hdttt16TLt2qV20/tgIry/PPPZ10CLVCvXr2yLgHKXlMeu9d3vvrmgyw09TmoY5m88PcUKoXfq/9y7733Zl0CbLS074tmz56d6nyl1qi/Lr/44otx2GGHFY1369YtPvjggyYXFRHRt2/f6NGjR0ydOrV2bOnSpTFr1qwYPHhwKmsAAAAAAAAAkK5GvRK6S5cuMX/+/Ojbt2+d8RdeeCE++9nPNnie5cuXx+uvv17785tvvhlz5syJrl27Rp8+feKMM86ISy65JLbddtvo27dvXHDBBbHlllvGoYce2piyAQAAAAAAACixRjWhjzrqqPiv//qvmDRpUhQKhaipqYlnnnkmzjrrrDjuuOMaPM9zzz0X+++/f+3P48aNi4iI0aNHx+233x7nnHNOrFixIr797W/H4sWLY999940pU6ZEu3btGlM2AAAAAAAAACXWqCb0j3/84xgzZkz07t071q1bF5/73Odi3bp1ccwxx8T555/f4HmGDh36qe+HXigU4oc//GH88Ic/bEyZAAAAAAAAADSzRjWh27ZtG7feemtccMEF8dJLL8Xy5ctj4MCBse2226ZdH9BCPPjgg6nOV9/n1k+fPj3VNSDvXnvttaxLgIp02mmnpTrfBRdckOp80BBvvPFG1iUAkAOf9uKQhhgxYkRKlUDDNfW4hVJryjFaKBRSrAQoZ0OGDMm6hCZrVBP6E3369Ik+ffqkVQsAAAAAAAAAZa5RTehPPrv53xUKhWjXrl30798/Ro4cGV27dm1ScQAAAAAAAACUl0Y1oV944YV4/vnnY926dbH99ttHxL/e8nOTTTaJHXbYIX7yk5/E9773vZg+fXp87nOfS7VgAAAAAAAAAPKrVWMuNHLkyBg2bFi89957MXv27Jg9e3a88847ccABB8TRRx8d7777buy3335x5plnpl0vAAAAAAAAADnWqFdCX3HFFfH4449H586da8eqq6vjoosuigMPPDC++93vxvjx4+PAAw9MrVDyZ9q0aanOt8kmm6Q6H+Vl+PDhqc53//33pzpfc7niiiuyLgGADbj++usbfdm//e1v6RUCTdC2bdsmXX758uUpVQJ8or6/oTz22GMZVEIlSJIk9TkLhULqcwLFxo8fXzT2wx/+MINKKLWHHnoo6xKAFKX9+Gv69OmpzpeFRr0SesmSJbFo0aKi8ffffz+WLl0aERFdunSJ1atXN606AAAAAAAAAMpKo9+O+8QTT4zJkyfHO++8E++8805Mnjw5TjrppDj00EMjIuLZZ5+N7bbbLs1aAQAAAAAAAMi5Rr0d909/+tM488wz46ijjoq1a9f+a6LWrWP06NFxzTXXRETEDjvsELfddlt6lQIAAAAAAACQe41qQnfs2DFuvfXWuOaaa+Kvf/1rRERss8020bFjx9rz7LrrrqkUCAAAAAAAAED5aFQT+hMdO3aMnXfeOa1ayLG99tqraGzo0KGprvH000+nOh+Uo7POOivrEgAoob59+2ZdAqRi2bJlWZdAhUuSJNX5zj777KKxK6+8MtU1IiIKhULRWEP38uijjzZoPlq2tLOxMYYPH1409tBDD2VQCVS2iy++uGjsiSeeKBqbPn16c5RDCZ1zzjlZl1BWqqursy4BaqX9mKxSH/c3ugn93HPPxT333BNvvfVWrF69us5p9913X5MLAwAAAAAAAKD8tGrMhe6+++7Ye++9Y+7cuTF58uRYs2ZNvPzyy/HEE0/4bxQAAAAAAACAFqxRTegf//jHcc0118RDDz0Ubdu2jeuuuy5effXV+PrXvx59+vRJu0YAAAAAAAAAykSjmtBvvPFGfPWrX42IiLZt28aKFSuiUCjEmWeeGT/72c9SLRAAAAAAAACA8tGoJvRmm20Wy5Yti4iIz372s/HSSy9FRMTixYtj5cqV6VUHAAAAAAAAQFlp3ZgL7bfffvH444/HgAED4ogjjojvfve78cQTT8Tjjz8eX/rSl9KusaJcfPHFRWPjx49v9HwjRoxo9GUfeuihBp93xowZjV6noVasWFHyNciHSZMmpTpfoVBIdb7mcvzxx6c634ABA1Kdj/K33XbbZV0ClL0kSbIuAXJpyy23zLoEKsjw4cNLvsYVV1zRoLEPP/yw3svfeuutRWPnnXde0wuDMvLggw82+rLl+rwd8mLIkCFFY9OnT8+gEtI0d+7cojG/L9dv8eLFWZdAhWuuvwG1pJw3qgl94403xscffxwRET/4wQ+iTZs28Yc//CG+9rWvxfnnn59qgQAAAAAAAACUj0Y1obt27Vr7fatWreLcc89NrSAAAAAAAAAAylejmtCfWLRoUSxatChqamrqjO+8885NKgoAAAAAAACA8tSoJvTs2bNj9OjRMXfu3KL3SC8UCrFu3bpUigMAAAAAAACgvDSqCX3iiSfGdtttFz//+c+je/fuLepDtDfGXnvtVTQ2fvz4VNd48MEHU52vuVxyySVZl0CGDj/88KxLyIWJEyc2+rJDhgwpGnvppZeaUg5ALuywww5FY3Pnzs2gkqY75ZRTsi4BoCzk6Xnt5ptvXu94fR9DVt+Yv49QalkeY8OHDy8aa2h+//1FLBHy0pKsXLmyaGzPPfcsGsvT3zU25vi8+OKLi8bS/htwmzZtUp2P0qrv+Knv9yDr15Try/0LDfHII480yzot/XhsVBP6r3/9a9x7773Rv3//tOsBAAAAAAAAoIy1asyFvvSlL8Wf/vSntGsBAAAAAAAAoMw16pXQt912W4wePTpeeuml2GmnnYreDmTEiBGpFAcAAAAAAABAeWlUE3rGjBnxzDPPxP/8z/8UnVYoFGLdunVNLgwAAAAAAACA8tOoJvRpp50W3/jGN+KCCy6I7t27p11TxZg5c2bWJeTWBRdckHUJNJNHHnkk1fkKhUKq85XCdtttVzQ2b968Rs83ZMiQorHp06c3ej5oqJqamqxLoMKdccYZRWPXXHNN8xdSIrfcckvR2E9/+tMMKgGoXA19frDVVlsVjf3tb39LuZqIJElSnxPy4qGHHioaa2gG68tGfWPl8JyfT9fQ34Mvvvhi0Vjv3r2Lxt55552isR133LFobO7cuQ1ad/vtty8ae+211xp02fUZP358ky7fEGvWrCn5GuTDgQceWDT22GOPZVBJ8/H4iTRleTx5HFOsUZ8J/eGHH8aZZ56pAQ0AAAAAAABAHY1qQo8aNSqmTZuWdi0AAAAAAAAAlLlGvR33dtttF+edd15Mnz49BgwYEG3atKlz+umnn55KcQAAAAAAAACUl0Y1oW+77bbo2LFjPPXUU/HUU0/VOa1QKGhCAwAAAAAAALRQjWpCv/nmm2nX0WIsX768aKxjx44ZVALN4ytf+UrWJTS7efPmpTrf9OnTU50PGqpVq0Z9agfUa4cddigau+aaazKoJFtJkhSN/fSnPy0aO+WUU5qjHIBcWLRoUdFYt27dGnTZH/3oR0VjF1xwQdHY3//+96KxQqFQNPbNb36z3nV++ctfNqgeoH715a2+x0X1jdV3WSrT22+/XTQ2YsSIorEnnniiaKwpf1/t0KFD0Vh9f8OFpujdu3fRWH3H/KOPPlo0Nnjw4KKxmTNnplNYCX3mM58pGqvvcV9D3XjjjUVjp512WqPnI7/22muvorEZM2ZkUEnEcccdV+/4nXfe2cyVlKcGN6HHjRsXP/rRj6JDhw4xbty49Z6vUCjEVVddlUpxAAAAAAAAAJSXBjehX3jhhVizZk3t9+vjvxMBAAAAAAAAWq4GN6GnTZtW7/cAAAAAAAAA8Akf9ggAAAAAAABAagpJkiRZF1FKS5cujerq6qzL+FQVfhM02KBBg4rGnn322Qwq+ZclS5ZE586dM1s/TVnmIO3jO8u3/D/++OOLxiZOnJjqGnn7SAM5qDxNzeQxxxxTNPbrX/+6SXPmnRyko1wf77z44otFYwMGDMigkmzvI+Sg8jQ1k3l7zNIc5KB5NeUYba7jM+37ts0337xo7KOPPkp1jaaSA9I0adKkorHDDz+8aCxv9zlysPHK9blAnshB6ZTr8+TevXsXjb3zzjtNKafBnn766aKxIUOGpLrGXXfdVTR27LHHprpGU8nBxrvhhhuKxsaOHVvydRuqY8eORWMrVqzIoJLysaEceCU0AAAAAAAAAKnRhAYAAAAAAAAgNZrQAAAAAAAAAKQm0yb0hAkTYo899ohOnTpFt27d4tBDD4158+bVOc/HH38cY8aMic033zw6duwYX/va12LhwoUZVQwAAAAAAADAp2md5eJPPfVUjBkzJvbYY49Yu3ZtfP/7348DDzwwXnnllejQoUNERJx55pnxyCOPxKRJk6K6ujrGjh0bo0aNimeeeSbL0lO1evXqorG2bdtmUEm2unTpknUJUCtJkpKvUSgUSr4G/Lu77rqraOyYY45p0uV//etfN6kmyIOePXvWO75gwYJGz5n2fUl987kvoSFeeOGFrEuAZtVcvy+XLFlSNFZdXd3o+T766KOmlANAhfAYv+Wo77Zu6PPIt99+O+1yMuOYL3877bRT0diLL76YQSUN57hrHpk2oadMmVLn59tvvz26desWs2fPjv322y+WLFkSP//5z+Ouu+6K//iP/4iIiIkTJ8aOO+4YM2fOjL322iuLsgEAAAAAAABYj1x9JvQn/0XctWvXiIiYPXt2rFmzJoYNG1Z7nh122CH69OkTM2bMqHeOVatWxdKlS+t8AQAAAAAAANA8ctOErqmpiTPOOCP22Wef2pfuL1iwINq2bVv0Ns3du3df71sjTpgwIaqrq2u/evfuXerSAQAAAAAAAPj/y00TesyYMfHSSy/F3Xff3aR5zjvvvFiyZEntVyV9NgIAAAAAAABA3mX6mdCfGDt2bDz88MPx9NNPR69evWrHe/ToEatXr47FixfXeTX0woULo0ePHvXOVVVVFVVVVaUuOVX11furX/2qaOyYY45Jdd277rqrwedNe+2//e1vRWOPPfZYqmuQD5dddlnR2Lnnntvo+er7R5UJEyYUjX3jG98oGqvvnRGOPPLIRteyMQqFQrOsAxty7LHHFo2l/Tse8mTy5MlFY6NGjWqWtRv6u3/48OFFYw8++GCDLvuLX/yiaOzEE09s0GVpOQYOHFg0liRJBpVAw9X3O7Qpx61jHvLn8MMPz7oEmsmIESOKxhr6eLfSzZ8/P+sSyJn6HgPV97zvhBNOaI5ymsTfQ1uO1atXZ13CRmvo84MXX3yx3vGdd945zXIqVqavhE6SJMaOHRuTJ0+OJ554Ivr27Vvn9N122y3atGkTU6dOrR2bN29evPXWWzF48ODmLhcAAAAAAACADcj0ldBjxoyJu+66Kx544IHo1KlT7ec8V1dXR/v27aO6ujpOOumkGDduXHTt2jU6d+4cp512WgwePDj22muvLEsHAAAAAAAAoB6ZNqFvvvnmiIgYOnRonfGJEyfG8ccfHxER11xzTbRq1Sq+9rWvxapVq+Kggw6Kn/zkJ81cKQAAAAAAAAANkWkTuiHvud6uXbu46aab4qabbmqGigAAAAAAAABoikLS0E/fLlNLly6N6urqrMtoVi+//HLR2Oc///nU15kwYULR2LnnntugyxYKhbTLSd2SJUuic+fOWZeRirzloJJ+7QwZMqRobPr06RlUUhpy0DI0NZPl8Du9KeSgdNK+P6ikY7FNmzZFY6tXry4amzhxYtHYiSeemHo9clB5/O7feHKQT+Xw3GL58uVFY506dcqgkqaTg+bVlOM7b7+nG7qXvNVdHzlIx3nnnVc09uMf/ziDSprP97///aKx+v6+Wg7kIJ/q20fPnj1TX+fVV19Nfc5yJAcbb8qUKUVjm266aYMuO2nSpKKxG264oWjs6aefLhqr72/45aASHhe1asZaAAAAAAAAAKhwmtAAAAAAAAAApEYTGgAAAAAAAIDUaEIDAAAAAAAAkJpCkiRJ1kWUUnN9oDqVZ0MfqF5O8paDcv21M2DAgKKxl156KYNKmo8ctAxXX311veNnnnlm0diHH35YNLbFFlukXlOeyAHIQSUaPnx40diDDz7Y4MsXCoU0yykLclA+Hn/88aKxYcOGpb7O7373u6KxAw44IPV18kQOsjdp0qSiscMPPzyDSkqjHO5f5CB7y5Yta9D5OnbsmPray5cvb9D5OnXqlPraeSIHIAeV6L777isaO+yww5pl7TfeeKNorH///s2ydlNsKAdeCQ0AAAAAAABAajShAQAAAAAAAEiNJjQAAAAAAAAAqdGEBgAAAAAAACA1rbMuAGh5CoVC0diDDz5YNDZ8+PCS1/LKK6/UO/75z3++5GtDXowbN26jxgEofw899FDRWH2P0aAcHXDAAVmXACVzxBFHNPqySZKkWMnGcR9Dmjp16pR1CQBUoFGjRmVdQsXxSmgAAAAAAAAAUqMJDQAAAAAAAEBqNKEBAAAAAAAASI0mNAAAAAAAAACpaZ11AQARESNGjMi6BAAAAKhYhUIh6xIAAGhBvBIaAAAAAAAAgNRoQgMAAAAAAACQGk1oAAAAAAAAAFKjCQ0AAAAAAABAajShAQAAAAAAAEiNJjQAAAAAAAAAqdGEBgAAAAAAACA1mtAAAAAAAAAApEYTGgAAAAAAAIDUaEIDAAAAAAAAkBpNaAAAAAAAAABSowkNAAAAAAAAQGo0oQEAAAAAAABITcU3oZMkyboEylQlHTuVtBeaVyUdO5W0F5pXJR07lbQXmlclHTuVtBeaVyUdO5W0F5pXJR07lbQXmlclHTuVtBeaVyUdO5W0F5pXJR07lbQXmteGjp2Kb0IvW7Ys6xIoU5V07FTSXmhelXTsVNJeaF6VdOxU0l5oXpV07FTSXmhelXTsVNJeaF6VdOxU0l5oXpV07FTSXmhelXTsVNJeaF6VdOxU0l5oXhs6dgpJhf+LQ01NTbz33nuRJEn06dMn3n777ejcuXPWZTXJ0qVLo3fv3mW/l7zuI0mSWLZsWWy55ZbRqlVl/J+GHORXXvchB+Uhr8fPxsrrPuSgPOT1+NlYed2HHJSHvB4/Gyuv+5CD8pDX42dj5XUfclAe8nr8bKy87qOSc9CpU6dYtmxZLq/3jZXX42dj5XUfclAe8nr8bKy87kMOykNej5+Nldd9NDQHrZuxpky0atUqevXqFUuXLo2IiM6dO+fqhmqKStlLHvdRXV2ddQmpkoP8y+M+5KB8VMpe8rgPOSgflbKXPO5DDspHpewlj/uQg/JRKXvJ4z7koHxUyl7yuI9KzUFERKFQiIh8Xu+NYR+lIwflwz5KRw7Kh32UTkNyUBn/pgEAAAAAAABALmhCAwAAAAAAAJCaFtOErqqqigsvvDCqqqqyLqXJKmUvlbKPclJJ13ml7KVS9lFOKuk6r5S9VMo+ykklXeeVspdK2Uc5qaTrvFL2Uin7KCeVdJ1Xyl4qZR/lpJKu80rZS6Xso9xUyvVuHzRFpVzv9kFTVMr1bh/5UEiSJMm6CAAAAAAAAAAqQ4t5JTQAAAAAAAAApacJDQAAAAAAAEBqNKEBAAAAAAAASI0mNAAAAAAAAACpaTFN6Jtuuim23nrraNeuXQwaNCieffbZrEv6VE8//XQMHz48ttxyyygUCnH//ffXOT1Jkhg/fnz07Nkz2rdvH8OGDYu//OUv2RT7KSZMmBB77LFHdOrUKbp16xaHHnpozJs3r855Pv744xgzZkxsvvnm0bFjx/ja174WCxcuzKjiyiYH2ZCDfJGDbMhBvshBNuQgX+QgG3KQL3KQDTnIFznIhhzkS7nlIKIysiAH+SIH2ZCDfJGDbFRyDlpEE/o3v/lNjBs3Li688MJ4/vnnY5dddomDDjooFi1alHVp67VixYrYZZdd4qabbqr39Msvvzyuv/76uOWWW2LWrFnRoUOHOOigg+Ljjz9u5ko/3VNPPRVjxoyJmTNnxuOPPx5r1qyJAw88MFasWFF7njPPPDMeeuihmDRpUjz11FPx3nvvxahRozKsujLJQXbkID/kIDtykB9ykB05yA85yI4c5IccZEcO8kMOsiMH+VGOOYiojCzIQX7IQXbkID/kIDsVnYOkBdhzzz2TMWPG1P68bt26ZMstt0wmTJiQYVUNFxHJ5MmTa3+uqalJevTokVxxxRW1Y4sXL06qqqqSX//61xlU2HCLFi1KIiJ56qmnkiT5V91t2rRJJk2aVHueuXPnJhGRzJgxI6syK5Ic5IccZEcO8kMOsiMH+SEH2ZGD/JCD7MhBfshBduQgP+QgO+WegySpnCzIQXbkID/kIDtykB+VlIOKfyX06tWrY/bs2TFs2LDasVatWsWwYcNixowZGVbWeG+++WYsWLCgzp6qq6tj0KBBud/TkiVLIiKia9euERExe/bsWLNmTZ297LDDDtGnT5/c76WcyEG+yEE25CBf5CAbcpAvcpANOcgXOciGHOSLHGRDDvJFDrJRiTmIKN8syEE25CBf5CAbcpAvlZSDim9Cf/DBB7Fu3bro3r17nfHu3bvHggULMqqqaT6pu9z2VFNTE2eccUbss88+sdNOO0XEv/bStm3b6NKlS53z5n0v5UYO8kMOsiMH+SEH2ZGD/JCD7MhBfshBduQgP+QgO3KQH3KQnUrMQUR5ZkEOsiMH+SEH2ZGD/Ki0HLTOugBajjFjxsRLL70U06dPz7oUyIwcgBxAhBxAhBxAhBxAhBxAhBxAhBxAROXloOJfCb3FFlvEJptsEgsXLqwzvnDhwujRo0dGVTXNJ3WX057Gjh0bDz/8cEybNi169epVO96jR49YvXp1LF68uM7587yXciQH+SAH2ZKDfJCDbMlBPshBtuQgH+QgW3KQD3KQLTnIBznIViXmIKL8siAH2ZKDfJCDbMlBPlRiDiq+Cd22bdvYbbfdYurUqbVjNTU1MXXq1Bg8eHCGlTVe3759o0ePHnX2tHTp0pg1a1bu9pQkSYwdOzYmT54cTzzxRPTt27fO6bvttlu0adOmzl7mzZsXb731Vu72Us7kIFtykA9ykC05yAc5yJYc5IMcZEsO8kEOsiUH+SAH2ZKDfKjEHESUTxbkIB/kIFtykA9ykK2KzkHSAtx9991JVVVVcvvttyevvPJK8u1vfzvp0qVLsmDBgqxLW69ly5YlL7zwQvLCCy8kEZFcffXVyQsvvJD8/e9/T5IkSS677LKkS5cuyQMPPJD8+c9/TkaOHJn07ds3+ec//5lx5XWdeuqpSXV1dfLkk08m8+fPr/1auXJl7XlOOeWUpE+fPskTTzyRPPfcc8ngwYOTwYMHZ1h1ZZKD7MhBfshBduQgP+QgO3KQH3KQHTnIDznIjhzkhxxkRw7yoxxzkCSVkQU5yA85yI4c5IccZKeSc9AimtBJkiQ33HBD0qdPn6Rt27bJnnvumcycOTPrkj7VtGnTkogo+ho9enSSJElSU1OTXHDBBUn37t2Tqqqq5Etf+lIyb968bIuuR317iIhk4sSJtef55z//mXznO99JNttss2TTTTdNDjvssGT+/PnZFV3B5CAbcpAvcpANOcgXOciGHOSLHGRDDvJFDrIhB/kiB9mQg3wptxwkSWVkQQ7yRQ6yIQf5IgfZqOQcFJIkSQIAAAAAAAAAUlDxnwkNAAAAAAAAQPPRhAYAAAAAAAAgNZrQAAAAAAAAAKRGExoAAAAAAACA1GhCAwAAAAAAAJAaTWgAAAAAAAAAUqMJDQAAAAAAAEBqNKEBAAAAAAAASI0mdAW6/fbbo0uXLk2ep1AoxP3339/keSALcgByABFyABFyABFyABFyABFyABFyABFy0Fw0oXPo+OOPj0MPPTTrMjba3/72tzjppJOib9++0b59++jXr19ceOGFsXr16qxLowyVaw4iIj766KM49thjo3PnztGlS5c46aSTYvny5VmXRRkq5xxceumlsffee8emm26aygM6Wq5yzYHHRaSpXHMQ4f6A9JRrDtwfkKZyzUFExIgRI6JPnz7Rrl276NmzZ3zzm9+M9957L+uyKENyAOWdA383JS3lmoOW9vxAE5rUvPrqq1FTUxM//elP4+WXX45rrrkmbrnllvj+97+fdWnQrI499th4+eWX4/HHH4+HH344nn766fj2t7+ddVnQrFavXh1HHHFEnHrqqVmXApnwuAj+xf0BLZ37A/iX/fffP+65556YN29e3HvvvfHGG2/E4YcfnnVZ0KzkAPzdFFra8wNN6DJ09dVXx4ABA6JDhw7Ru3fv+M53vlPvfwvdf//9se2220a7du3ioIMOirfffrvO6Q888EB84QtfiHbt2sU222wTF198caxdu7bRdR188MExceLEOPDAA2ObbbaJESNGxFlnnRX33Xdfo+eE9clrDubOnRtTpkyJ2267LQYNGhT77rtv3HDDDXH33Xf771ZSl9ccRERcfPHFceaZZ8aAAQOaNA9sSF5z4HERzSmvOYhwf0DzyWsO3B/QnPKag4iIM888M/baa6/YaqutYu+9945zzz03Zs6cGWvWrGnSvPDv5ADymwN/N6U55TUHLe35gSZ0GWrVqlVcf/318fLLL8cdd9wRTzzxRJxzzjl1zrNy5cq49NJL45e//GU888wzsXjx4jjqqKNqT//9738fxx13XHz3u9+NV155JX7605/G7bffHpdeeul61x06dGgcf/zxG1XrkiVLomvXrht1GWiIvOZgxowZ0aVLl9h9991rx4YNGxatWrWKWbNmNX7DUI+85gCaUznlwOMiSqWccgClUk45cH9AqZRLDj766KP41a9+FXvvvXe0adNmo/cJn0YOIL858HdTmlNec1Cfin5+kJA7o0ePTkaOHNng80+aNCnZfPPNa3+eOHFiEhHJzJkza8fmzp2bREQya9asJEmS5Etf+lLy4x//uM48d955Z9KzZ8/anyMimTx5cu3P3/zmN5Nzzz23wXX95S9/STp37pz87Gc/a/Bl4BPlmoNLL7002W677YrGP/OZzyQ/+clPGrwfSJLyzcH/NXHixKS6urrBe4B/Vwk5SBKPi2iaSsiB+wOaqhJykCTuD2iacs/BOeeck2y66aZJRCR77bVX8sEHHzR4L/AJOYDyzYG/m5Kmcs3Bv6v05wetS9/mJm2/+93vYsKECfHqq6/G0qVLY+3atfHxxx/HypUrY9NNN42IiNatW8cee+xRe5kddtghunTpEnPnzo0999wz/vSnP8UzzzxT5z821q1bVzTP//XLX/6ywTW+++67cfDBB8cRRxwRJ598chN2C/UrhxxAqckBlEcOPC6i1MohB1Bq5ZAD9weUWt5zcPbZZ8dJJ50Uf//73+Piiy+O4447Lh5++OEoFApN3Dn8LzmA/OcAmkM55KAlPD/QhC4zf/vb3+KQQw6JU089NS699NLo2rVrTJ8+PU466aRYvXp1vQd9fZYvXx4XX3xxjBo1qui0du3aNanG9957L/bff//Ye++942c/+1mT5oL65DkHPXr0iEWLFtUZW7t2bXz00UfRo0ePRs0J9clzDqC5lEMOPC6i1MohB1Bq5ZAD9weUWjnkYIsttogtttgitttuu9hxxx2jd+/eMXPmzBg8eHCT5oVPyAHkOwf+bkpzyXMOPtFSnh9oQpeZ2bNnR01NTVx11VXRqtW/PtL7nnvuKTrf2rVr47nnnos999wzIiLmzZsXixcvjh133DEiIr7whS/EvHnzon///qnW9+6778b+++8fu+22W0ycOLG2RkhTnnMwePDgWLx4ccyePTt22223iIh44oknoqamJgYNGpTaOpDnHEBzyXsOPC6iOeQ9B9Ac8p4D9wc0h7zn4N/V1NRERMSqVatKug4tixxAvnPg76Y0lzznIKJlPT/QhM6pJUuWxJw5c+qMbb755tG/f/9Ys2ZN3HDDDTF8+PB45pln4pZbbim6fJs2beK0006L66+/Plq3bh1jx46NvfbaqzZM48ePj0MOOST69OkThx9+eLRq1Sr+9Kc/xUsvvRSXXHJJvTUdd9xx8dnPfjYmTJhQ7+nvvvtuDB06NLbaaqu48sor4/333689zX8y0RjlmIMdd9wxDj744Dj55JPjlltuiTVr1sTYsWPjqKOOii233LJpVwgtUjnmICLirbfeio8++ijeeuutWLduXe0e+vfvHx07dmzclUGLVY458LiItJVjDiLcH5CucsyB+wPSVo45mDVrVvzxj3+MfffdNzbbbLN444034oILLoh+/fp59SeNIgdQnjnwd1PSVo45aHHPD7L+UGqKjR49OomIoq+TTjopSZIkufrqq5OePXsm7du3Tw466KDkl7/8ZRIRyT/+8Y8kSf71gerV1dXJvffem2yzzTZJVVVVMmzYsOTvf/97nXWmTJmS7L333kn79u2Tzp07J3vuuWedDz+Pf/tA9S9+8YvJ6NGj11v3Jx/kXt8XbKxyzUGSJMmHH36YHH300UnHjh2Tzp07JyeccEKybNmyVK4XWpZyzsH6ap82bVoaVw0tSLnmwOMi0lSuOfi02t0fsLHKNQfuD0hTuebgz3/+c7L//vsnXbt2TaqqqpKtt946OeWUU5J33nknteuGlkMOoHxzkCT+bkp6yjUHLe35QSFJkmT9LWoAAAAAAAAAaLjKfaNxAAAAAAAAAJqdJjQAAAAAAAAAqdGEBgAAAAAAACA1mtAAAAAAAAAApEYTGgAAAAAAAIDUaEIDAAAAAAAAkBpNaAAAAAAAAABS0zrrAkqtpqYm3nvvvejUqVMUCoWsy6EMJEkSy5Ytiy233DJataqM/9OQAzaWHIAcQIQcQIQcQIQcQIQcQIQcQIQcQETDc1CyJvSdd94Zt9xyS7z55psxY8aM2GqrreLaa6+Nvn37xsiRI0u1bJH33nsvevfu3WzrUTnefvvt6NWrV9ZlpEIOaCw5ADmACDmACDmACDmACDmACDmACDmAiA3noCRN6JtvvjnGjx8fZ5xxRlx66aWxbt26iIjo0qVLXHvttc3ahO7UqVOzrdUQ++67b9Yl1LrrrruyLqGOPn36ZF1CHXk7dpqikvZC86qkY6eS9kLzqqRjp5L2krbHHnss6xLqOPDAA7MuoY5KOnYqaS80r0o6dvK2l7Zt22ZdQq2ampqsS6hj7dq1WZdQR96OnaaopL3QvCrp2MnbXqqqqrIuodaNN96YdQl1nHzyyVmXUEfejp2mqKS90Lwq6dippL2k7aKLLsq6hDryVs+Gjp2SNKFvuOGGuPXWW+PQQw+Nyy67rHZ89913j7POOqsUS65X3t46oHXr/LwDeufOnbMuIdfyduw0RSXtheZVScdOJe2F5lVJx04l7SVtHTp0yLqEXKukY6eS9kLzqqRjJ297yVM9eaoljyrp+qmkvaQtb9dNkiRZl1BH3q6fpsjbXvJUz6abbpp1CbmWp9uqqSppLzSvSjp2KmkvaWvXrl3WJeTaho6dkrxh/ZtvvhkDBw4sGq+qqooVK1aUYkkAAAAAAAAAcqAkTei+ffvGnDlzisanTJkSO+64YymWBAAAAAAAACAHSvLe0OPGjYsxY8bExx9/HEmSxLPPPhu//vWvY8KECXHbbbeVYkkAAAAAAAAAcqAkTehvfetb0b59+zj//PNj5cqVccwxx8SWW24Z1113XRx11FGlWBIAAAAAAACAHChJEzoi4thjj41jjz02Vq5cGcuXL49u3bqVaikAAAAAAAAAcqJkTehPbLrpprHpppuWehkAAAAAAAAAcqAkTeiBAwdGoVAoGi8UCtGuXbvo379/HH/88bH//vuXYnkAAAAAAAAAMtKqFJMefPDB8de//jU6dOgQ+++/f+y///7RsWPHeOONN2KPPfaI+fPnx7Bhw+KBBx4oxfIAAAAAAAAAZKQkr4T+4IMP4nvf+15ccMEFdcYvueSS+Pvf/x6PPfZYXHjhhfGjH/0oRo4cWYoSAAAAAAAAAMhASV4Jfc8998TRRx9dNH7UUUfFPffcExERRx99dMybN68UywMAAAAAAACQkZI0odu1axd/+MMfisb/8Ic/RLt27SIioqampvb7Dbnpppti6623jnbt2sWgQYPi2WefTbVeAAAAAAAAANJRkrfjPu200+KUU06J2bNnxx577BEREX/84x/jtttui+9///sREfHoo4/GrrvuusG5fvOb38S4cePilltuiUGDBsW1114bBx10UMybNy+6detWivIBAAAAAAAAaKSSNKHPP//86Nu3b9x4441x5513RkTE9ttvH7feemscc8wxERFxyimnxKmnnrrBua6++uo4+eST44QTToiIiFtuuSUeeeSR+MUvfhHnnntuKcoHAAAAAAAAoJFK0oSOiDj22GPj2GOPXe/p7du33+Acq1evjtmzZ8d5551XO9aqVasYNmxYzJgxI5U6AQAAAAAAAEhPyZrQafjggw9i3bp10b179zrj3bt3j1dffbXey6xatSpWrVpV+/PSpUtLWiMAAAAAAAAA/6tVKSZdt25dXHnllbHnnntGjx49omvXrnW+SmnChAlRXV1d+9W7d++SrgcAAAAAAADA/ypJE/riiy+Oq6++Oo488shYsmRJjBs3LkaNGhWtWrWKiy66qMHzbLHFFrHJJpvEwoUL64wvXLgwevToUe9lzjvvvFiyZEnt19tvv92UrQAAAAAAAACwEUrShP7Vr34Vt956a3zve9+L1q1bx9FHHx233XZbjB8/PmbOnNngedq2bRu77bZbTJ06tXaspqYmpk6dGoMHD673MlVVVdG5c+c6XwAAAAAAAAA0j5I0oRcsWBADBgyIiIiOHTvGkiVLIiLikEMOiUceeWSj5ho3blzceuutcccdd8TcuXPj1FNPjRUrVsQJJ5yQet0AAAAAAAAANE3rUkzaq1evmD9/fvTp0yf69esXjz32WHzhC1+IP/7xj1FVVbVRcx155JHx/vvvx/jx42PBggWx6667xpQpU6J79+6lKB0AAAAAAACAJihJE/qwww6LqVOnxqBBg+K0006Lb3zjG/Hzn/883nrrrTjzzDM3er6xY8fG2LFjS1ApAAAAAAAAAGkqSRP6sssuq/3+yCOPjD59+sSMGTNi2223jeHDh5diSQAAAAAAAAByoCRN6H83ePDgGDx4cHMsBQAAAAAAAECGStaEfu+992L69OmxaNGiqKmpqXPa6aefXqplAQAAAAAAAMhQSZrQt99+e/znf/5ntG3bNjbffPMoFAq1pxUKBU1oAAAAAAAAgApVkib0BRdcEOPHj4/zzjsvWrVqVYolAAAAAAAAAMihknSIV65cGUcddZQGNAAAAAAAAEALU5Iu8UknnRSTJk0qxdQAAAAAAAAA5FhJ3o57woQJccghh8SUKVNiwIAB0aZNmzqnX3311aVYFgAAAAAAAICMlawJ/eijj8b2228fERGFQqH2tP/7PQAAAAAAAACVpSRN6Kuuuip+8YtfxPHHH1+K6QEAAAAAAADIqZJ8JnRVVVXss88+pZgaAAAAAAAAgBwrySuhv/vd78YNN9wQ119/fSmmL2tPPvlk1iXUGjRoUNYl1PHII49kXUJERKxcuTKOOOKIrMuoaCeffHLWJdT62c9+lnUJubR06dKorq7OugyayYsvvph1CXUMGDAg6xJoJrvuumvWJdT6+te/nnUJdfz5z3/OuoSIiFi+fHnsvffeWZdBM0mSJOsS6vBRTi3HgQcemHUJtR588MGsS6hDDlqOG264IesSauXpOXtERLt27bIugWYya9asrEuotfPOO2ddQh2f/exnsy4hIiJWrFgRX/3qV7Muo6Ll6TH5f/zHf2RdQh1XX3111iVExL+eJw8ZMiTrMira5z//+axLqHXuuedmXUIdefkd0dD+QUma0M8++2w88cQT8fDDD8fnP//5aNOmTZ3T77vvvlIsCwAAAAAAAEDGStKE7tKlS4waNaoUUwMAAAAAAACQYyVpQk+cOLEU0wIAAAAAAACQc62yLgAAAAAAAACAypHaK6G/8IUvxNSpU2OzzTaLgQMHRqFQWO95n3/++bSWBQAAAAAAACBHUmtCjxw5MqqqqiIi4tBDD01rWgAAAAAAAADKSGpN6AsvvLDe7wEAAAAAAABoOXwmNAAAAAAAAACp0YQGAAAAAAAAIDWa0AAAAAAAAACkRhMaAAAAAAAAgNRoQgMAAAAAAACQmtZpTTRu3LgGn/fqq69Oa1kAAAAAAAAAciS1JvQLL7xQ5+fnn38+1q5dG9tvv31ERLz22muxySabxG677bZR8z799NNxxRVXxOzZs2P+/PkxefLkOPTQQ9MqGwAAAAAAAIAUpdaEnjZtWu33V199dXTq1CnuuOOO2GyzzSIi4h//+EeccMIJMWTIkI2ad8WKFbHLLrvEiSeeGKNGjUqrXAAAAAAAAABKILUm9P911VVXxWOPPVbbgI6I2GyzzeKSSy6JAw88ML73ve81eK4vf/nL8eUvf7kUZQIAAAAAAACQspI0oZcuXRrvv/9+0fj7778fy5YtK8WStVatWhWrVq2qUwsAAAAAAAAAzaNVKSY97LDD4oQTToj77rsv3nnnnXjnnXfi3nvvjZNOOqnkb6k9YcKEqK6urv3q3bt3SdcDAAAAAAAA4H+VpAl9yy23xJe//OU45phjYquttoqtttoqjjnmmDj44IPjJz/5SSmWrHXeeefFkiVLar/efvvtkq4HAAAAAAAAwP8qydtxb7rppvGTn/wkrrjiinjjjTciIqJfv37RoUOHUixXR1VVVVRVVZV8HQAAAAAAAACKleSV0J+YP39+zJ8/P7bddtvo0KFDJElSyuUAAAAAAAAAyFhJXgn94Ycfxte//vWYNm1aFAqF+Mtf/hLbbLNNnHTSSbHZZpvFVVdd1eC5li9fHq+//nrtz2+++WbMmTMnunbtGn369ClF+QAAAAAAAAA0UkleCX3mmWdGmzZt4q233opNN920dvzII4+MKVOmbNRczz33XAwcODAGDhwYERHjxo2LgQMHxvjx41OtGQAAAAAAAICmK8kroR977LF49NFHo1evXnXGt9122/j73/++UXMNHTrU23gDAAAAAAAAlImSvBJ6xYoVdV4B/YmPPvooqqqqSrEkAAAAAAAAADlQkib0kCFD4pe//GXtz4VCIWpqauLyyy+P/fffvxRLAgAAAAAAAJADJXk77ssvvzy+9KUvxXPPPRerV6+Oc845J15++eX46KOP4plnninFkgAAAAAAAADkQEleCb3TTjvFa6+9Fvvuu2+MHDkyVqxYEaNGjYoXXngh+vXrV4olAQAAAAAAAMiBkrwSOiKiuro6fvCDH5RqegAAAAAAAAByKLUm9J///OcGn3fnnXdOa1kAAAAAAAAAciS1JvSuu+4ahUIhkiT51PMVCoVYt25dWssCAAAAAAAAkCOpNaHffPPNtKYCAAAAAAAAoEyl1oTeaqut0poKAAAAAAAAgDKVWhP6382bNy9uuOGGmDt3bkRE7LjjjnHaaafF9ttvX6olAQAAAAAAAMhYSZrQ9957bxx11FGx++67x+DBgyMiYubMmbHTTjvF3XffHV/72tdKsWxZePDBB7Muoda+++6bdQl1VFVVZV1CREQsXbo06xIq3s9+9rOsS6hVKBSyLqGOtWvXZl1CRESsW7cu6xJoRjvttFPWJdBCdejQIesSar3wwgtZl1BH3759sy4hIiJqamqyLgFoAc4///ysS6j13HPPZV1CHa+99lrWJURExPLly+MLX/hC1mVUtOuuuy7rEmp961vfyroEWqidd9456xJy64tf/GLWJUREZf/d9JBDDok2bdpkXUbu/laZJ8uXL8+6hIiIWLFiRdYlVLyXX3456xJqJUmSdQl1lNvviJI0oc8555w477zz4oc//GGd8QsvvDDOOeecFt2EBgAAAAAAAKhkrUox6fz58+O4444rGv/GN74R8+fPL8WSAAAAAAAAAORASZrQQ4cOjd///vdF49OnT48hQ4aUYkkAAAAAAAAAcqAkb8c9YsSI+K//+q+YPXt27LXXXhHxr8+EnjRpUlx88cV1Phd5xIgRpSgBAAAAAAAAgAyUpAn9ne98JyIifvKTn8RPfvKTek+L+NcHaK9bt64UJQAAAAAAAACQgZI0oWtqakoxLQAAAAAAAAA5V5LPhAYAAAAAAACgZSrJK6EjIv74xz/GtGnTYtGiRUWvjL766qtLtSwAAAAAAAAAGSpJE/rHP/5xnH/++bH99ttH9+7do1Ao1J72f78HAAAAAAAAoLKUpAl93XXXxS9+8Ys4/vjjSzE9AAAAAAAAADlVks+EbtWqVeyzzz6lmBoAAAAAAACAHCtJE/rMM8+Mm266qRRTAwAAAAAAAJBjJXk77rPOOiu++tWvRr9+/eJzn/tctGnTps7p9913XymWBQAAAAAAACBjJXkl9Omnnx7Tpk2L7bbbLjbffPOorq6u89VQEyZMiD322CM6deoU3bp1i0MPPTTmzZtXipIBAAAAAAAASEFJXgl9xx13xL333htf/epXmzTPU089FWPGjIk99tgj1q5dG9///vfjwAMPjFdeeSU6dOiQUrUAAAAAAAAApKUkTeiuXbtGv379mjzPlClT6vx8++23R7du3WL27Nmx3377NXl+AAAAAAAAANJVkrfjvuiii+LCCy+MlStXpjrvkiVLIuJfTe71WbVqVSxdurTOFwAAAAAAAADNoySvhL7++uvjjTfeiO7du8fWW28dbdq0qXP6888/v9Fz1tTUxBlnnBH77LNP7LTTTus934QJE+Liiy/e6PkBAAAAAAAAaLqSNKEPPfTQ1OccM2ZMvPTSSzF9+vRPPd95550X48aNq/156dKl0bt379TrAQAAAAAAAKBYSZrQF154YarzjR07Nh5++OF4+umno1evXp963qqqqqiqqkp1fQAAAAAAAAAapiRN6LQkSRKnnXZaTJ48OZ588sno27dv1iUBAAAAAAAA8ClK0oRet25dXHPNNXHPPffEW2+9FatXr65z+kcffdSgecaMGRN33XVXPPDAA9GpU6dYsGBBRERUV1dH+/btU68bAAAAAAAAgKZpVYpJL7744rj66qvjyCOPjCVLlsS4ceNi1KhR0apVq7jooosaPM/NN98cS5YsiaFDh0bPnj1rv37zm9+UomwAAAAAAAAAmqgkr4T+1a9+Fbfeemt89atfjYsuuiiOPvro6NevX+y8884xc+bMOP300xs0T5IkpSgPAAAAAAAAgBIpySuhFyxYEAMGDIiIiI4dO8aSJUsiIuKQQw6JRx55pBRLAgAAAAAAAJADJWlC9+rVK+bPnx8REf369YvHHnssIiL++Mc/RlVVVSmWBAAAAAAAACAHStKEPuyww2Lq1KkREXHaaafFBRdcENtuu20cd9xxceKJJ5ZiSQAAAAAAAAByoCSfCX3ZZZfVfn/kkUdGnz59YsaMGbHtttvG8OHDS7EkAAAAAAAAADlQkib0vxs8eHAMHjy4OZYCAAAAAAAAIEMleTvuO+64Ix555JHan88555zo0qVL7L333vH3v/+9FEsCAAAAAAAAkAMlaUL/+Mc/jvbt20dExIwZM+LGG2+Myy+/PLbYYos488wzS7EkAAAAAAAAADlQkrfjfvvtt6N///4REXH//ffH4YcfHt/+9rdjn332iaFDh5ZiSQAAAAAAAAByoCSvhO7YsWN8+OGHERHx2GOPxQEHHBAREe3atYt//vOfpVgSAAAAAAAAgBwoySuhDzjggPjWt74VAwcOjNdeey2+8pWvRETEyy+/HFtvvXUplgQAAAAAAAAgB0rySuibbropBg8eHO+//37ce++9sfnmm0dExOzZs+Poo48uxZIAAAAAAAAA5EBJXgndpUuXuPHGG4vGL7744lIsV1by9ErwzTbbLOsS6rjtttuyLiEiwlvGtzBJkmRdQh0jR47MuoSIiFizZk3WJQAtwPTp07MuoVaeaomIuPPOO7MuISIiVqxYEQcffHDWZdBM3nzzzaxLoIXadNNNsy6h1k477ZR1CXX853/+Z9YlRETE6tWrsy6h4r3++utZl1Cra9euWZdQx9e//vWsS4iIfz1Pnjx5ctZl0EKdffbZWZcQERGrVq3KuoSSefjhh7MuISLy81wwImLLLbfMuoQ6Dj/88KxLiIiImpqarEsombZt20ahUMi6jPj444+zLqHWn//856xLKGslaUJHRCxevDieffbZWLRoUZ1QFgqF+OY3v1mqZQEAAAAAAADIUEma0A899FAce+yxsXz58ujcuXOd/5zQhAYAAAAAAACoXCX5TOjvfe97ceKJJ8by5ctj8eLF8Y9//KP266OPPirFkgAAAAAAAADkQEma0O+++26cfvrpufpcJwAAAAAAAABKryRN6IMOOiiee+65UkwNAAAAAAAAQI6V5DOhv/rVr8bZZ58dr7zySgwYMCDatGlT5/QRI0aUYlkAAAAAAAAAMlaSJvTJJ58cERE//OEPi04rFAqxbt26UiwLAAAAAAAAQMZK0oSuqakpxbQAAAAAAAAA5FxJPhP6448/LsW0AAAAAAAAAORcSV4J3aVLl9hzzz3ji1/8YgwdOjT23nvvaN++fSmWAgAAAAAAACBHSvJK6N/97ndx8MEHx6xZs2LkyJGx2Wabxb777hs/+MEP4vHHHy/FkgAAAAAAAADkQEma0Pvuu298//vfj8ceeywWL14c06ZNi/79+8fll18eBx98cCmWBAAAAAAAACAHSvJ23BERr732Wjz55JO1X6tWrYpDDjkkhg4d2uA5br755rj55pvjb3/7W0REfP7zn4/x48fHl7/85dIUDQAAAAAAAECTlKQJ/dnPfjb++c9/xtChQ2Po0KHxX//1X7HzzjtHoVDYqHl69eoVl112WWy77baRJEnccccdMXLkyHjhhRfi85//fClKBwAAAAAAAKAJSvJ23J/5zGdi5cqVsWDBgliwYEEsXLgw/vnPf270PMOHD4+vfOUrse2228Z2220Xl156aXTs2DFmzpxZgqoBAAAAAAAAaKqSNKHnzJkTCxYsiHPPPTdWrVoV3//+92OLLbaIvffeO37wgx80as5169bF3XffHStWrIjBgwev93yrVq2KpUuX1vkCAAAAAAAAoHmU7DOhu3TpEiNGjIh99tkn9t5773jggQfi17/+dcyaNSsuvfTSBs/z4osvxuDBg+Pjjz+Ojh07xuTJk+Nzn/vces8/YcKEuPjii9PYAgAAAAAAAAAbqSSvhL7vvvvi9NNPj5133jm6d+8ep556aixfvjyuuuqqeP755zdqru233z7mzJkTs2bNilNPPTVGjx4dr7zyynrPf95558WSJUtqv95+++2mbgcAAAAAAACABirJK6FPOeWU2G+//eLb3/52fPGLX4wBAwY0eq62bdtG//79IyJit912iz/+8Y9x3XXXxU9/+tN6z19VVRVVVVWNXg8AAAAAAACAxitJE3rRokWlmDYiImpqamLVqlUlmx8AAAAAAACAxivZZ0KvW7cu7r///pg7d25ERHzuc5+LkSNHxiabbNLgOc4777z48pe/HH369Illy5bFXXfdFU8++WQ8+uijpSobAAAAAAAAgCYoSRP69ddfj6985Svx7rvvxvbbbx8RERMmTIjevXvHI488Ev369WvQPIsWLYrjjjsu5s+fH9XV1bHzzjvHo48+GgcccEApygYAAAAAAACgiUrShD799NOjX79+MXPmzOjatWtERHz44YfxjW98I04//fR45JFHGjTPz3/+81KUBwAAAAAAAECJlKQJ/dRTT9VpQEdEbL755nHZZZfFPvvsU4olAQAAAAAAAMiBVqWYtKqqKpYtW1Y0vnz58mjbtm0plgQAAAAAAAAgB0rShD7kkEPi29/+dsyaNSuSJIkkSWLmzJlxyimnxIgRI0qxJAAAAAAAAAA5UJIm9PXXXx/9+vWLwYMHR7t27aJdu3axzz77RP/+/eO6664rxZIAAAAAAAAA5EBJPhO6S5cu8cADD8Rf/vKXePXVVyMiYscdd4z+/fuXYjkAAAAAAAAAcqIkTehPbLvttrHtttuWcgkAAAAAAAAAciS1JvS4ceMafN6rr746rWUBAAAAAAAAyJHUmtAvvPBCnZ+ff/75WLt2bWy//fYREfHaa6/FJptsErvttltaSwIAAAAAAACQM6k1oadNm1b7/dVXXx2dOnWKO+64IzbbbLOIiPjHP/4RJ5xwQgwZMiStJQEAAAAAAADImValmPSqq66KCRMm1DagIyI222yzuOSSS+Kqq64qxZIAAAAAAAAA5EBqr4T+v5YuXRrvv/9+0fj7778fy5YtK8WS65UkSbOutyHLly/PuoRaS5cuzbqEOv75z39mXUJE/G8deTt2miJve8nbsZcna9asybqEiPjfOvJ27DRFJe0lbTL56Srp2MnbXvJ07K1YsSLrEnLpk+slb8dOU1TSXtLW3M/Vyk0lHTt524vnyeu3evXqrEuIiP+tI2/HTlNU0l7SlrfrxvPk0snbXvL2OzhPVq1alXUJEeH+oDnk5W/kEfl7nlxTU5N1CRHxv3Xk7dhpik/2kpc95en+IE/PVfJoQ8dMSZrQhx12WJxwwglx1VVXxZ577hkREbNmzYqzzz47Ro0aVYol1ytvf0jZe++9sy6BBlq2bFlUV1dnXUYq8paDSrleWwI5aBkq5TYuFTkonUq5XlsCOWgZdtlll6xLyDU5KJ3BgwdnXQINJActw8cff5x1CXVMnjw56xLqkIPSqZTrtSWQg9L59re/nXUJNFAl5iAv//hVKddrS7ChHBSSEvxrw8qVK+Oss86KX/ziF7UHbevWreOkk06KK664Ijp06JD2kutVU1MT7733XnTq1CkKhUKj5li6dGn07t073n777ejcuXPKFZa3SrxukiSJZcuWxZZbbhmtWpXkHeubXRo5iKjM2zsNlXi9yMH6VeLtnYZKvF7kYP0q8fZOQyVeL3KwfpV4e6ehEq8XOVi/Sry901CJ14scrF8l3t5pqMTrRQ7WrxJv7zRU4vUiB+tXibd3GirxepGD9avE2zsNlXi9NDQHJWlCf2LFihXxxhtvREREv379mrX5nKalS5dGdXV1LFmypGIOkLS4bloWt3f9XC8ti9u7fq6XlsXtXT/XS8vi9q6f66VlcXvXz/XSsri96+d6aVnc3vVzvbQsbu/6uV5aFrd3/Vry9VKSt+P+RIcOHWLnnXcu5RIAAAAAAAAA5EhlvFcAAAAAAAAAALmgCd0AVVVVceGFF0ZVVVXWpeSO66ZlcXvXz/XSsri96+d6aVnc3vVzvbQsbu/6uV5aFrd3/VwvLYvbu36ul5bF7V0/10vL4vaun+ulZXF7168lXy8l/UxoAAAAAAAAAFoWr4QGAAAAAAAAIDWa0AAAAAAAAACkRhMaAAAAAAAAgNRoQgMAAAAAAACQGk3oBrjpppti6623jnbt2sWgQYPi2WefzbqkTE2YMCH22GOP6NSpU3Tr1i0OPfTQmDdvXtZlUWJyUJcctExyUJcctExyUEwWWh45KCYHLY8cFJODlkcOislByyMHxeSg5ZGDYnLQ8shBMTnQhN6g3/zmNzFu3Li48MIL4/nnn49ddtklDjrooFi0aFHWpWXmqaeeijFjxsTMmTPj8ccfjzVr1sSBBx4YK1asyLo0SkQOislByyMHxeSg5ZGD+slCyyIH9ZODlkUO6icHLYsc1E8OWhY5qJ8ctCxyUD85aFnkoH5yEFFIkiTJuog8GzRoUOyxxx5x4403RkRETU1N9O7dO0477bQ499xzM64uH95///3o1q1bPPXUU7HffvtlXQ4lIAcbJgeVTw42TA4qnxw0jCxUNjloGDmobHLQMHJQ2eSgYeSgsslBw8hBZZODhpGDyiYHDdMSc+CV0J9i9erVMXv27Bg2bFjtWKtWrWLYsGExY8aMDCvLlyVLlkRERNeuXTOuhFKQg4aRg8omBw0jB5VNDhpOFiqXHDScHFQuOWg4OahcctBwclC55KDh5KByyUHDyUHlkoOGa4k50IT+FB988EGsW7cuunfvXme8e/fusWDBgoyqypeampo444wzYp999omddtop63IoATnYMDmofHKwYXJQ+eSgYWShsslBw8hBZZODhpGDyiYHDSMHlU0OGkYOKpscNIwcVDY5aJiWmoPWWRdAeRszZky89NJLMX369KxLgczIAcgBfEIWQA4gQg4gQg4gQg4gQg4gouXmQBP6U2yxxRaxySabxMKFC+uML1y4MHr06JFRVfkxduzYePjhh+Ppp5+OXr16ZV0OJSIHn04OWgY5+HRy0DLIwYbJQuWTgw2Tg8onBxsmB5VPDjZMDiqfHGyYHFQ+OdgwOah8crBhLTkH3o77U7Rt2zZ22223mDp1au1YTU1NTJ06NQYPHpxhZdlKkiTGjh0bkydPjieeeCL69u2bdUmUkBzUTw5aFjmonxy0LHKwfrLQcsjB+slByyEH6ycHLYccrJ8ctBxysH5y0HLIwfrJQcshB+snB14JvUHjxo2L0aNHx+677x577rlnXHvttbFixYo44YQTsi4tM2PGjIm77rorHnjggejUqVPt+/pXV1dH+/btM66OUpCDYnLQ8shBMTloeeSgfrLQsshB/eSgZZGD+slByyIH9ZODlkUO6icHLYsc1E8OWhY5qJ8cRETCBt1www1Jnz59krZt2yZ77rlnMnPmzKxLylRE1Ps1ceLErEujhOSgLjlomeSgLjlomeSgmCy0PHJQTA5aHjkoJgctjxwUk4OWRw6KyUHLIwfF5KDlkYNicpAkhSRJknTa2QAAAAAAAAC0dD4TGgAAAAAAAIDUaEIDAAAAAAAAkBpNaAAAAAAAAABSowkNAAAAAAAAQGo0oQEAAAAAAABIjSY0AAAAAAAAAKnRhAYAAAAAAAAgNZrQZe7444+PQw89tPbnoUOHxhlnnNGkOdOYA5qTHIAcQIQcQIQcQIQcQIQcQIQcQIQcQIQcZEkTugSOP/74KBQKUSgUom3bttG/f//44Q9/GGvXri352vfdd1/86Ec/atB5n3zyySgUCrF48eJGz5Gm++67L3bffffo0qVLdOjQIXbddde48847m70O0iEHjTdp0qTYYYcdol27djFgwID47//+70zqoOnkoHFefvnl+NrXvhZbb711FAqFuPbaa5u9BtIjB43jcVFlkYPGcX9QWeSgcW699dYYMmRIbLbZZrHZZpvFsGHD4tlnn232OkiHHDSOx0WVRQ4ax/1BZZGDxpGDyiIHjVNuOdCELpGDDz445s+fH3/5y1/ie9/7Xlx00UVxxRVX1Hve1atXp7Zu165do1OnTpnP0dh1f/CDH8SMGTPiz3/+c5xwwglxwgknxKOPPtrstZAOOdh4f/jDH+Loo4+Ok046KV544YU49NBD49BDD42XXnqp2WshHXKw8VauXBnbbLNNXHbZZdGjR49mX5/0yUHj1vW4qLLIwcZzf1B55GDjPfnkk3H00UfHtGnTYsaMGdG7d+848MAD49133232WkiHHDRuXY+LKoscbDz3B5VHDjaeHFQeOdh4ZZeDhNSNHj06GTlyZJ2xAw44INlrr73qnH7JJZckPXv2TLbeeuskSZLkrbfeSo444oikuro62WyzzZIRI0Ykb775Zu0ca9euTc4888ykuro66dq1a3L22Wcnxx13XJ21vvjFLybf/e53a3/++OOPk3POOSfp1atX0rZt26Rfv37Jbbfdlrz55ptJRNT5Gj16dL1zfPTRR8k3v/nNpEuXLkn79u2Tgw8+OHnttddqT584cWJSXV2dTJkyJdlhhx2SDh06JAcddFDy3nvvNfm6HDhwYHL++ec3eR6anxw0Lgdf//rXk69+9at1xgYNGpT853/+50bNQz7IQdPvD7baaqvkmmuuafTlyZ4ceFyEHLg/IEnkIK37g7Vr1yadOnVK7rjjjibNQzbkwOMi5MD9AUkiB3JAkshBS8mBV0I3k/bt29f5T42pU6fGvHnz4vHHH4+HH3441qxZEwcddFB06tQpfv/738czzzwTHTt2jIMPPrj2cldddVXcfvvt8Ytf/CKmT58eH330UUyePPlT1z3uuOPi17/+dVx//fUxd+7c+OlPfxodO3aM3r17x7333hsREfPmzYv58+fHddddV+8cxx9/fDz33HPx4IMPxowZMyJJkvjKV74Sa9asqT3PypUr48orr4w777wznn766XjrrbfirLPOqj39k7cs+Nvf/tag6ytJktrraL/99mvQZcg/OdhwDmbMmBHDhg2rM3bQQQfFjBkzPnWPlA852Lj7AyqTHHhchBy4PyBCDhqTg5UrV8aaNWuia9euDb4M+SYHHhchB+4PiJADOSBCDioyB5m0vivc//0PjpqamuTxxx9PqqqqkrPOOqv29O7duyerVq2qvcydd96ZbL/99klNTU3t2KpVq5L27dsnjz76aJIkSdKzZ8/k8ssvrz19zZo1Sa9evdb7Hxzz5s1LIiJ5/PHH661z2rRpSUQk//jHP+qM/985XnvttSQikmeeeab29A8++CBp3759cs899yRJ8q//4IiI5PXXX689z0033ZR079699udZs2Yl22+/ffLOO+982lWXLF68OOnQoUPSunXrpKqqKvn5z3/+qecnv+SgcTlo06ZNctddd9UZu+mmm5Ju3bqt9zLklxw0/v7gE175Vv7kwOMi5CBJ3B8gB0nS9BwkSZKceuqpyTbbbJP885//bPBlyA858LgIOUgS9wfIQZLIAXKQJC0jB61L195u2R5++OHo2LFjrFmzJmpqauKYY46Jiy66qPb0AQMGRNu2bWt//tOf/hSvv/560XvIf/zxx/HGG2/EkiVLYv78+TFo0KDa01q3bh277757JElSbw1z5syJTTbZJL74xS82eh9z586N1q1b11l38803j+233z7mzp1bO7bppptGv379an/u2bNnLFq0qPbnPffcM1599dUNrtepU6eYM2dOLF++PKZOnRrjxo2LbbbZJoYOHdroPZAdOWhcDqgsciAHyIHHRUTIgfsDIuSgqTm47LLL4u67744nn3wy2rVr1+j6yZYceFyEHLg/IEIO5IAIOWgJOdCELpH9998/br755mjbtm1sueWW0bp13au6Q4cOdX5evnx57LbbbvGrX/2qaK7PfOYzjaqhffv2jbpcY7Rp06bOz4VCYb2h/jStWrWK/v37R0TErrvuGnPnzo0JEyZ4UlGm5GDjc9CjR49YuHBhnbGFCxdGjx49mlwf2ZCDxt0fUFnkwOMi5MD9ARFy0JQcXHnllXHZZZfF7373u9h5553TKI+MyIHHRciB+wMi5EAOiJCDlpADnwldIh06dIj+/ftHnz59ioJTny984Qvxl7/8Jbp16xb9+/ev81VdXR3V1dXRs2fPmDVrVu1l1q5dG7Nnz17vnAMGDIiampp46qmn6j39k/8gWbdu3Xrn2HHHHWPt2rV11v3www9j3rx58bnPfW6D+2qqmpqaWLVqVcnXoTTkYOMNHjw4pk6dWmfs8ccfj8GDB6e6Ds1HDkAO0uJxUXmTA5CDxrr88svjRz/6UUyZMiV233331OeneclBOjwuKm9y0DjuDyqLHDSOHFQWOWiccsqBJnROHHvssbHFFlvEyJEj4/e//328+eab8eSTT8bpp58e77zzTkREfPe7343LLrss7r///nj11VfjO9/5TixevHi9c2699dYxevToOPHEE+P++++vnfOee+6JiIitttoqCoVCPPzww/H+++/H8uXLi+bYdtttY+TIkXHyySfH9OnT409/+lN84xvfiM9+9rMxcuTIBu/v2WefjR122CHefffd9Z5nwoQJ8fjjj8df//rXmDt3blx11VVx5513xje+8Y0Gr0N5k4N/7W/KlClx1VVXxauvvhoXXXRRPPfcczF27NgGr0N5k4OI1atXx5w5c2LOnDmxevXqePfdd2POnDnx+uuvN3gdypsceFyEHES4P0AOIiL+3//7f3HBBRfEL37xi9h6661jwYIFsWDBgnrrojLJgcdFyEGE+wPkIEIOkIOI8suBJnRObLrppvH0009Hnz59YtSoUbHjjjvGSSedFB9//HF07tw5IiK+973vxTe/+c0YPXp0DB48ODp16hSHHXbYp8578803x+GHHx7f+c53YocddoiTTz45VqxYERERn/3sZ+Piiy+Oc889N7p3777eJtfEiRNjt912i0MOOSQGDx4cSZLEf//3fxe9dcCnWblyZcybNy/WrFmz3vOsWLEivvOd78TnP//52GeffeLee++N/+//+//iW9/6VoPXobzJQcTee+8dd911V/zsZz+LXXbZJX7729/G/fffHzvttFOD16G8yUHEe++9FwMHDoyBAwfG/Pnz48orr4yBAwe6P2hB5MDjIuQgwv0BcvBJratXr47DDz88evbsWft15ZVXNngdypsceFyEHHxSq/uDlk0O5AA5+KTWcspBIfHBXAAAAAAAAACkxCuhAQAAAAAAAEiNJjQAAAAAAAAAqdGEBgAAAAAAACA1mtAAAAAAAAAApEYTGgAAAAAAAIDUaEIDAAAAAAAAkBpNaAAAAAAAAABSowkNAAAAAAAAQGo0oQEAAAAAAABIjSY0AAAAAAAAAKnRhAYAAAAAAAAgNZrQAAAAAAAAAKTm/wcIbKo5O/sc8gAAAABJRU5ErkJggg==",
+            "text/plain": [
+              "<Figure size 2000x400 with 20 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import matplotlib\n",
+        "%matplotlib inline\n",
+        "n_samples = 10\n",
+        "for feed_dict in dataflow['test']:\n",
+        "  inputs = feed_dict['image']\n",
+        "  outputs = feed_dict['digit']\n",
+        "  break\n",
+        "images = inputs[:n_samples]\n",
+        "# Down sample the image from 28x28 to 4x4.\n",
+        "# This down sampled image is the circuit input.\n",
+        "after_down_sample = F.avg_pool2d(images, 6)\n",
+        "\n",
+        "# Forward the model to get prediction.\n",
+        "pred = model(images)\n",
+        "_, indices = pred.topk(1, dim=1)\n",
+        "\n",
+        "# Plot 10 samples with label and prediction.\n",
+        "fig, axes = plt.subplots(2, n_samples, figsize=(20, 4))\n",
+        "for k in range(n_samples):\n",
+        "    axes[0, 0].set_ylabel(\"image\")\n",
+        "    if k != 0:\n",
+        "        axes[0, k].yaxis.set_visible(False)\n",
+        "    axes[0, k].set_xlabel(\"Label: {0}\".format(outputs[k]))\n",
+        "    norm = matplotlib.colors.Normalize(vmin=0, vmax=1)\n",
+        "    axes[0, k].imshow(images[k, 0, :, :].cpu(), norm=norm, cmap=\"gray\")\n",
+        "\n",
+        "    axes[1, 0].set_ylabel(\"downsampled image\")\n",
+        "    if k != 0:\n",
+        "        axes[1, k].yaxis.set_visible(False)\n",
+        "    axes[1, k].set_xlabel(\"Prediction: {0}\".format(indices[k][0]))\n",
+        "    axes[1, k].imshow(after_down_sample[k, 0, :, :], norm=norm, cmap=\"gray\")\n",
+        "\n",
+        "plt.tight_layout()\n",
+        "plt.show()\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8gKWWgFDa7ki",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "**Supercircuit and  Subcircuit**\n",
+        "\n",
+        "We constructed a SuperCircuit by stacking a sufficient number of layers of pre-defined parameterized gates to cover a large *design space*. Then, we have already trained the SuperCircuit by sampling and updating the parameter subsets (SubCircuits) from the SuperCircuit. The performance of a SubCircuit with inherited parameters from the SuperCircuit can provide a reliable relative performance estimation for the individual SubCircuit trained from scratch. In this way, we only pay the training cost once but can evaluate all the SubCircuits fast and efficiently. Hence, the search cost is significantly reduced.\n",
+        "\n",
+        "In this supercircuit, there are totally 3 blocks and 2 layers(a U3 layer and a CU3 layer) in each block. The gene (Which covers all *design space*) length is 7. The front 6 positions mean how many front gates we put in the circuit in kth layer. The last position of gene means how many front blocks we put in the circuit.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5abKrxthWvzt",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "![image.png](data:image/png;base64,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)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c26bfc83TeDo",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "\n",
+        "In the following code cell we randomly sample a subcircuit to further show the relation between the subcircuit's architecture and its gene for you to understand.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 374
+        },
+        "id": "QmunD04ob2ol",
+        "outputId": "85db142b-4145-47b7-b415-ca02ba59c7a6",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Sampled gene: [1, 4, 2, 2, 4, 4, 2]\n",
+            "Circuit depth: 8\n",
+            "Architecture:\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1625.27x367.889 with 1 Axes>"
+            ]
+          },
+          "execution_count": 10,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from torchquantum.plugins import tq2qiskit\n",
+        "gene_choice = model.arch_space\n",
+        "gene_len = len(gene_choice)\n",
+        "n_samples=1\n",
+        "samp_gene = []\n",
+        "for k in range(gene_len):\n",
+        "    samp_gene.append(random.choices(gene_choice[k])[0])\n",
+        "print(\"Sampled gene: \" + str(samp_gene))\n",
+        "model.set_sample_arch(samp_gene)\n",
+        "circ = tq2qiskit(tq.QuantumDevice(n_wires=model.n_wires), model.q_layer)\n",
+        "print(\"Circuit depth: {0}\".format(circ.depth()))\n",
+        "print(\"Architecture:\")\n",
+        "circ.draw('mpl')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "my1EbXmpk4WH",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "**Different performance between noise-free simulator and noisy simulator**\n",
+        "On real quantum computers, noise can distort the output of the circuit. In this subsection we will show the accuracy gap brought by noise. We use qiskit's noisy simulator to simulate the noisy environment on real quantum computers.\n",
+        "\n",
+        "First, we setup a noisy simulator, **specify the *qubit mapping (layout)*** and attach it to our model."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "-MN848gJIxni",
+        "outputId": "15068df3-3c95-4827-f072-46ec5b52f0b6",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "ibmqfactory.load_account:WARNING:2023-10-15 20:05:10,215: Credentials are already in use. The existing account in the session will be replaced.\n"
+          ]
+        }
+      ],
+      "source": [
+        "from torchquantum.plugins import QiskitProcessor\n",
+        "from qiskit import IBMQ\n",
+        "IBMQ.save_account('47e33305e658576a384f0450958c9e054d68ea80313c29d44112a47dbc759c67a0b49a3de7e9e9c53cafa149324fd4591470858d68f177b35e6dedddd65c638a', overwrite=True)\n",
+        "\n",
+        "processor_real_qc = QiskitProcessor(use_real_qc=False, noise_model_name = 'ibmq_perth', backend_name='ibmq_perth')\n",
+        "\n",
+        "processor_real_qc.set_layout([0, 1, 2, 3]) # default layout: virtual qubit 0 for physical qubit 0, ..., virtual qubit 3 for physical qubit 3\n",
+        "\n",
+        "model.set_qiskit_processor(processor_real_qc)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "8yZ6LMHPyrge",
+        "outputId": "0194e1f7-56a6-46b3-d587-ff42e95b90a2",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 2/2 [00:00<00:00,  7.03it/s]\n",
+            "\u001b[32m[2023-10-15 20:05:17.760]\u001b[0m \u001b[1mAccuracy: 0.49666666666666665\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:05:17.762]\u001b[0m \u001b[1mLoss: 1.208074688911438\u001b[0m\n",
+            "  0%|          | 0/2 [00:00<?, ?it/s]\n",
+            "  0%|          | 0/256 [00:00<?, ?it/s]\u001b[A\n",
+            "  2%|▏         | 6/256 [00:00<00:04, 54.22it/s]\u001b[A\n",
+            "  5%|▌         | 13/256 [00:00<00:03, 61.82it/s]\u001b[A\n",
+            "  8%|▊         | 20/256 [00:00<00:03, 61.07it/s]\u001b[A\n",
+            " 11%|█         | 27/256 [00:00<00:03, 58.84it/s]\u001b[A\n",
+            " 13%|█▎        | 33/256 [00:00<00:03, 58.16it/s]\u001b[A\n",
+            " 16%|█▌        | 40/256 [00:00<00:03, 59.03it/s]\u001b[A\n",
+            " 18%|█▊        | 46/256 [00:00<00:03, 57.28it/s]\u001b[A\n",
+            " 20%|██        | 52/256 [00:01<00:07, 26.40it/s]\u001b[A\n",
+            " 23%|██▎       | 58/256 [00:01<00:06, 31.25it/s]\u001b[A\n",
+            " 25%|██▌       | 64/256 [00:01<00:05, 35.90it/s]\u001b[A\n",
+            " 27%|██▋       | 70/256 [00:01<00:04, 40.70it/s]\u001b[A\n",
+            " 30%|██▉       | 76/256 [00:01<00:04, 44.12it/s]\u001b[A\n",
+            " 32%|███▏      | 83/256 [00:01<00:03, 49.45it/s]\u001b[A\n",
+            " 35%|███▌      | 90/256 [00:01<00:03, 52.63it/s]\u001b[A\n",
+            " 38%|███▊      | 96/256 [00:02<00:03, 52.61it/s]\u001b[A\n",
+            " 40%|███▉      | 102/256 [00:02<00:02, 53.97it/s]\u001b[A\n",
+            " 43%|████▎     | 109/256 [00:02<00:02, 56.72it/s]\u001b[A\n",
+            " 45%|████▍     | 115/256 [00:02<00:02, 57.02it/s]\u001b[A\n",
+            " 47%|████▋     | 121/256 [00:02<00:02, 57.09it/s]\u001b[A\n",
+            " 50%|█████     | 128/256 [00:02<00:02, 57.98it/s]\u001b[A\n",
+            " 52%|█████▏    | 134/256 [00:02<00:02, 57.37it/s]\u001b[A\n",
+            " 55%|█████▍    | 140/256 [00:02<00:02, 52.62it/s]\u001b[A\n",
+            " 57%|█████▋    | 146/256 [00:02<00:02, 49.29it/s]\u001b[A\n",
+            " 59%|█████▉    | 152/256 [00:03<00:02, 46.67it/s]\u001b[A\n",
+            " 61%|██████▏   | 157/256 [00:03<00:02, 45.35it/s]\u001b[A\n",
+            " 63%|██████▎   | 162/256 [00:03<00:02, 45.16it/s]\u001b[A\n",
+            " 65%|██████▌   | 167/256 [00:03<00:01, 44.99it/s]\u001b[A\n",
+            " 67%|██████▋   | 172/256 [00:03<00:01, 44.52it/s]\u001b[A\n",
+            " 69%|██████▉   | 177/256 [00:03<00:01, 44.27it/s]\u001b[A\n",
+            " 71%|███████   | 182/256 [00:03<00:01, 43.33it/s]\u001b[A\n",
+            " 73%|███████▎  | 187/256 [00:03<00:01, 43.84it/s]\u001b[A\n",
+            " 75%|███████▌  | 192/256 [00:04<00:01, 43.78it/s]\u001b[A\n",
+            " 77%|███████▋  | 197/256 [00:04<00:01, 42.43it/s]\u001b[A\n",
+            " 79%|███████▉  | 202/256 [00:04<00:01, 43.36it/s]\u001b[A\n",
+            " 81%|████████  | 207/256 [00:04<00:01, 43.61it/s]\u001b[A\n",
+            " 83%|████████▎ | 212/256 [00:04<00:01, 42.22it/s]\u001b[A\n",
+            " 85%|████████▍ | 217/256 [00:04<00:00, 42.05it/s]\u001b[A\n",
+            " 87%|████████▋ | 222/256 [00:04<00:00, 42.03it/s]\u001b[A\n",
+            " 89%|████████▊ | 227/256 [00:04<00:00, 41.78it/s]\u001b[A\n",
+            " 91%|█████████ | 232/256 [00:05<00:00, 41.85it/s]\u001b[A\n",
+            " 93%|█████████▎| 237/256 [00:05<00:00, 40.91it/s]\u001b[A\n",
+            " 95%|█████████▍| 242/256 [00:05<00:00, 41.56it/s]\u001b[A\n",
+            " 96%|█████████▋| 247/256 [00:05<00:00, 41.04it/s]\u001b[A\n",
+            "100%|██████████| 256/256 [00:05<00:00, 45.50it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 50%|█████     | 1/2 [00:11<00:11, 11.86s/it]\n",
+            "  0%|          | 0/44 [00:00<?, ?it/s]\u001b[A\n",
+            "  9%|▉         | 4/44 [00:00<00:01, 37.70it/s]\u001b[A\n",
+            " 18%|█▊        | 8/44 [00:00<00:01, 32.64it/s]\u001b[A\n",
+            " 27%|██▋       | 12/44 [00:00<00:01, 25.96it/s]\u001b[A\n",
+            " 34%|███▍      | 15/44 [00:00<00:01, 26.32it/s]\u001b[A\n",
+            " 41%|████      | 18/44 [00:00<00:01, 25.14it/s]\u001b[A\n",
+            " 48%|████▊     | 21/44 [00:00<00:00, 25.47it/s]\u001b[A\n",
+            " 55%|█████▍    | 24/44 [00:00<00:00, 24.97it/s]\u001b[A\n",
+            " 64%|██████▎   | 28/44 [00:01<00:00, 26.72it/s]\u001b[A\n",
+            " 73%|███████▎  | 32/44 [00:01<00:00, 25.00it/s]\u001b[A\n",
+            " 80%|███████▉  | 35/44 [00:01<00:00, 23.51it/s]\u001b[A\n",
+            " 86%|████████▋ | 38/44 [00:01<00:00, 18.65it/s]\u001b[A\n",
+            " 93%|█████████▎| 41/44 [00:01<00:00, 19.22it/s]\u001b[A\n",
+            "100%|██████████| 44/44 [00:01<00:00, 23.37it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 2/2 [00:17<00:00,  8.60s/it]\n",
+            "\u001b[32m[2023-10-15 20:05:34.975]\u001b[0m \u001b[1mAccuracy: 0.5\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:05:34.979]\u001b[0m \u001b[1mLoss: 1.2077587599493789\u001b[0m\n",
+            "100%|██████████| 2/2 [00:00<00:00,  7.79it/s]\n",
+            "\u001b[32m[2023-10-15 20:05:35.245]\u001b[0m \u001b[1mAccuracy: 0.5466666666666666\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:05:35.248]\u001b[0m \u001b[1mLoss: 1.1071999073028564\u001b[0m\n",
+            "  0%|          | 0/2 [00:00<?, ?it/s]\n",
+            "  0%|          | 0/256 [00:00<?, ?it/s]\u001b[A\n",
+            "  2%|▏         | 4/256 [00:00<00:06, 39.41it/s]\u001b[A\n",
+            "  3%|▎         | 8/256 [00:00<00:06, 39.65it/s]\u001b[A\n",
+            "  5%|▍         | 12/256 [00:00<00:06, 39.45it/s]\u001b[A\n",
+            "  6%|▋         | 16/256 [00:00<00:06, 39.58it/s]\u001b[A\n",
+            "  8%|▊         | 20/256 [00:00<00:06, 38.02it/s]\u001b[A\n",
+            "  9%|▉         | 24/256 [00:00<00:06, 36.90it/s]\u001b[A\n",
+            " 11%|█         | 28/256 [00:00<00:06, 37.54it/s]\u001b[A\n",
+            " 12%|█▎        | 32/256 [00:00<00:06, 37.04it/s]\u001b[A\n",
+            " 14%|█▍        | 36/256 [00:00<00:05, 37.72it/s]\u001b[A\n",
+            " 16%|█▌        | 41/256 [00:01<00:05, 39.25it/s]\u001b[A\n",
+            " 18%|█▊        | 45/256 [00:01<00:05, 35.48it/s]\u001b[A\n",
+            " 19%|█▉        | 49/256 [00:01<00:06, 33.72it/s]\u001b[A\n",
+            " 21%|██        | 53/256 [00:01<00:06, 33.04it/s]\u001b[A\n",
+            " 22%|██▏       | 57/256 [00:01<00:06, 32.47it/s]\u001b[A\n",
+            " 24%|██▍       | 61/256 [00:01<00:06, 31.41it/s]\u001b[A\n",
+            " 25%|██▌       | 65/256 [00:01<00:06, 31.24it/s]\u001b[A\n",
+            " 27%|██▋       | 69/256 [00:01<00:05, 31.51it/s]\u001b[A\n",
+            " 29%|██▊       | 73/256 [00:02<00:05, 31.72it/s]\u001b[A\n",
+            " 30%|███       | 77/256 [00:02<00:05, 30.90it/s]\u001b[A\n",
+            " 32%|███▏      | 81/256 [00:02<00:05, 31.15it/s]\u001b[A\n",
+            " 33%|███▎      | 85/256 [00:02<00:05, 30.56it/s]\u001b[A\n",
+            " 35%|███▍      | 89/256 [00:02<00:05, 29.97it/s]\u001b[A\n",
+            " 36%|███▋      | 93/256 [00:02<00:05, 29.92it/s]\u001b[A\n",
+            " 38%|███▊      | 97/256 [00:02<00:05, 30.34it/s]\u001b[A\n",
+            " 39%|███▉      | 101/256 [00:03<00:05, 30.82it/s]\u001b[A\n",
+            " 41%|████      | 105/256 [00:03<00:04, 30.53it/s]\u001b[A\n",
+            " 43%|████▎     | 109/256 [00:03<00:04, 29.67it/s]\u001b[A\n",
+            " 44%|████▍     | 112/256 [00:03<00:04, 29.17it/s]\u001b[A\n",
+            " 45%|████▍     | 115/256 [00:03<00:04, 29.08it/s]\u001b[A\n",
+            " 46%|████▌     | 118/256 [00:03<00:04, 28.67it/s]\u001b[A\n",
+            " 47%|████▋     | 121/256 [00:03<00:04, 28.18it/s]\u001b[A\n",
+            " 48%|████▊     | 124/256 [00:03<00:04, 27.70it/s]\u001b[A\n",
+            " 50%|████▉     | 127/256 [00:03<00:04, 27.92it/s]\u001b[A\n",
+            " 51%|█████     | 130/256 [00:04<00:04, 27.31it/s]\u001b[A\n",
+            " 52%|█████▏    | 133/256 [00:04<00:11, 11.13it/s]\u001b[A\n",
+            " 53%|█████▎    | 136/256 [00:04<00:09, 13.31it/s]\u001b[A\n",
+            " 54%|█████▍    | 139/256 [00:04<00:07, 15.59it/s]\u001b[A\n",
+            " 55%|█████▌    | 142/256 [00:05<00:06, 17.84it/s]\u001b[A\n",
+            " 57%|█████▋    | 145/256 [00:05<00:05, 19.71it/s]\u001b[A\n",
+            " 58%|█████▊    | 148/256 [00:05<00:05, 21.22it/s]\u001b[A\n",
+            " 59%|█████▉    | 151/256 [00:05<00:04, 22.26it/s]\u001b[A\n",
+            " 60%|██████    | 154/256 [00:05<00:04, 23.35it/s]\u001b[A\n",
+            " 61%|██████▏   | 157/256 [00:05<00:04, 24.13it/s]\u001b[A\n",
+            " 62%|██████▎   | 160/256 [00:05<00:03, 24.29it/s]\u001b[A\n",
+            " 64%|██████▎   | 163/256 [00:05<00:03, 24.07it/s]\u001b[A\n",
+            " 65%|██████▍   | 166/256 [00:06<00:03, 23.81it/s]\u001b[A\n",
+            " 66%|██████▌   | 169/256 [00:06<00:03, 23.42it/s]\u001b[A\n",
+            " 67%|██████▋   | 172/256 [00:06<00:03, 23.82it/s]\u001b[A\n",
+            " 68%|██████▊   | 175/256 [00:06<00:03, 24.60it/s]\u001b[A\n",
+            " 70%|██████▉   | 178/256 [00:06<00:03, 24.81it/s]\u001b[A\n",
+            " 71%|███████   | 182/256 [00:06<00:02, 27.10it/s]\u001b[A\n",
+            " 73%|███████▎  | 186/256 [00:06<00:02, 30.36it/s]\u001b[A\n",
+            " 74%|███████▍  | 190/256 [00:06<00:02, 30.77it/s]\u001b[A\n",
+            " 76%|███████▌  | 195/256 [00:06<00:01, 34.18it/s]\u001b[A\n",
+            " 78%|███████▊  | 199/256 [00:07<00:01, 34.93it/s]\u001b[A\n",
+            " 80%|███████▉  | 204/256 [00:07<00:01, 36.82it/s]\u001b[A\n",
+            " 82%|████████▏ | 209/256 [00:07<00:01, 38.40it/s]\u001b[A\n",
+            " 83%|████████▎ | 213/256 [00:07<00:01, 37.17it/s]\u001b[A\n",
+            " 85%|████████▌ | 218/256 [00:07<00:00, 38.60it/s]\u001b[A\n",
+            " 87%|████████▋ | 223/256 [00:07<00:00, 38.99it/s]\u001b[A\n",
+            " 89%|████████▊ | 227/256 [00:07<00:00, 37.84it/s]\u001b[A\n",
+            " 90%|█████████ | 231/256 [00:07<00:00, 35.35it/s]\u001b[A\n",
+            " 92%|█████████▏| 236/256 [00:08<00:00, 36.72it/s]\u001b[A\n",
+            " 94%|█████████▍| 240/256 [00:08<00:00, 37.38it/s]\u001b[A\n",
+            " 95%|█████████▌| 244/256 [00:08<00:00, 36.19it/s]\u001b[A\n",
+            " 97%|█████████▋| 248/256 [00:08<00:00, 36.42it/s]\u001b[A\n",
+            " 98%|█████████▊| 252/256 [00:08<00:00, 35.75it/s]\u001b[A\n",
+            "100%|██████████| 256/256 [00:08<00:00, 29.66it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 50%|█████     | 1/2 [00:14<00:14, 14.29s/it]\n",
+            "  0%|          | 0/44 [00:00<?, ?it/s]\u001b[A\n",
+            " 11%|█▏        | 5/44 [00:00<00:00, 40.64it/s]\u001b[A\n",
+            " 23%|██▎       | 10/44 [00:00<00:00, 38.37it/s]\u001b[A\n",
+            " 32%|███▏      | 14/44 [00:00<00:00, 38.03it/s]\u001b[A\n",
+            " 43%|████▎     | 19/44 [00:00<00:00, 40.79it/s]\u001b[A\n",
+            " 55%|█████▍    | 24/44 [00:00<00:00, 38.76it/s]\u001b[A\n",
+            " 64%|██████▎   | 28/44 [00:00<00:00, 37.34it/s]\u001b[A\n",
+            " 73%|███████▎  | 32/44 [00:00<00:00, 37.21it/s]\u001b[A\n",
+            " 82%|████████▏ | 36/44 [00:00<00:00, 36.96it/s]\u001b[A\n",
+            "100%|██████████| 44/44 [00:01<00:00, 38.35it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 2/2 [00:18<00:00,  9.06s/it]\n",
+            "\u001b[32m[2023-10-15 20:05:53.392]\u001b[0m \u001b[1mAccuracy: 0.5466666666666666\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:05:53.393]\u001b[0m \u001b[1mLoss: 1.107359002986732\u001b[0m\n",
+            "100%|██████████| 2/2 [00:00<00:00,  4.96it/s]\n",
+            "\u001b[32m[2023-10-15 20:05:53.803]\u001b[0m \u001b[1mAccuracy: 0.7133333333333334\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:05:53.805]\u001b[0m \u001b[1mLoss: 1.0672136545181274\u001b[0m\n",
+            "  0%|          | 0/2 [00:00<?, ?it/s]\n",
+            "  0%|          | 0/256 [00:00<?, ?it/s]\u001b[A\n",
+            "  1%|          | 2/256 [00:00<00:12, 19.60it/s]\u001b[A\n",
+            "  2%|▏         | 4/256 [00:00<00:12, 19.60it/s]\u001b[A\n",
+            "  3%|▎         | 7/256 [00:00<00:12, 20.53it/s]\u001b[A\n",
+            "  4%|▍         | 10/256 [00:00<00:11, 21.24it/s]\u001b[A\n",
+            "  5%|▌         | 13/256 [00:01<00:27,  8.74it/s]\u001b[A\n",
+            "  6%|▌         | 15/256 [00:01<00:23, 10.20it/s]\u001b[A\n",
+            "  7%|▋         | 18/256 [00:01<00:19, 12.40it/s]\u001b[A\n",
+            "  8%|▊         | 20/256 [00:01<00:17, 13.65it/s]\u001b[A\n",
+            "  9%|▉         | 23/256 [00:01<00:14, 15.55it/s]\u001b[A\n",
+            " 10%|█         | 26/256 [00:01<00:13, 17.27it/s]\u001b[A\n",
+            " 11%|█▏        | 29/256 [00:01<00:12, 18.60it/s]\u001b[A\n",
+            " 12%|█▎        | 32/256 [00:02<00:11, 19.14it/s]\u001b[A\n",
+            " 14%|█▎        | 35/256 [00:02<00:11, 19.51it/s]\u001b[A\n",
+            " 15%|█▍        | 38/256 [00:02<00:10, 20.13it/s]\u001b[A\n",
+            " 16%|█▌        | 41/256 [00:02<00:10, 19.94it/s]\u001b[A\n",
+            " 17%|█▋        | 44/256 [00:02<00:09, 21.63it/s]\u001b[A\n",
+            " 18%|█▊        | 47/256 [00:02<00:08, 23.34it/s]\u001b[A\n",
+            " 20%|█▉        | 51/256 [00:02<00:07, 26.22it/s]\u001b[A\n",
+            " 21%|██▏       | 55/256 [00:02<00:07, 27.90it/s]\u001b[A\n",
+            " 23%|██▎       | 58/256 [00:03<00:07, 27.46it/s]\u001b[A\n",
+            " 24%|██▍       | 62/256 [00:03<00:06, 28.65it/s]\u001b[A\n",
+            " 26%|██▌       | 66/256 [00:03<00:06, 30.02it/s]\u001b[A\n",
+            " 27%|██▋       | 70/256 [00:03<00:06, 30.88it/s]\u001b[A\n",
+            " 29%|██▉       | 74/256 [00:03<00:05, 30.36it/s]\u001b[A\n",
+            " 30%|███       | 78/256 [00:03<00:05, 31.36it/s]\u001b[A\n",
+            " 32%|███▏      | 82/256 [00:03<00:05, 32.35it/s]\u001b[A\n",
+            " 34%|███▎      | 86/256 [00:03<00:05, 31.34it/s]\u001b[A\n",
+            " 35%|███▌      | 90/256 [00:04<00:05, 29.88it/s]\u001b[A\n",
+            " 37%|███▋      | 94/256 [00:04<00:05, 30.61it/s]\u001b[A\n",
+            " 38%|███▊      | 98/256 [00:04<00:04, 32.02it/s]\u001b[A\n",
+            " 40%|███▉      | 102/256 [00:04<00:04, 32.18it/s]\u001b[A\n",
+            " 41%|████▏     | 106/256 [00:04<00:04, 31.88it/s]\u001b[A\n",
+            " 43%|████▎     | 110/256 [00:04<00:04, 32.43it/s]\u001b[A\n",
+            " 45%|████▍     | 114/256 [00:04<00:04, 32.03it/s]\u001b[A\n",
+            " 46%|████▌     | 118/256 [00:04<00:04, 32.22it/s]\u001b[A\n",
+            " 48%|████▊     | 122/256 [00:05<00:04, 30.76it/s]\u001b[A\n",
+            " 49%|████▉     | 126/256 [00:05<00:04, 31.83it/s]\u001b[A\n",
+            " 51%|█████     | 130/256 [00:05<00:04, 30.79it/s]\u001b[A\n",
+            " 52%|█████▏    | 134/256 [00:05<00:03, 30.62it/s]\u001b[A\n",
+            " 54%|█████▍    | 138/256 [00:05<00:03, 30.86it/s]\u001b[A\n",
+            " 55%|█████▌    | 142/256 [00:05<00:03, 30.90it/s]\u001b[A\n",
+            " 57%|█████▋    | 146/256 [00:05<00:03, 31.34it/s]\u001b[A\n",
+            " 59%|█████▊    | 150/256 [00:06<00:03, 31.48it/s]\u001b[A\n",
+            " 60%|██████    | 154/256 [00:06<00:03, 32.62it/s]\u001b[A\n",
+            " 62%|██████▏   | 158/256 [00:06<00:03, 31.47it/s]\u001b[A\n",
+            " 63%|██████▎   | 162/256 [00:06<00:03, 31.24it/s]\u001b[A\n",
+            " 65%|██████▍   | 166/256 [00:06<00:02, 30.64it/s]\u001b[A\n",
+            " 66%|██████▋   | 170/256 [00:06<00:02, 31.14it/s]\u001b[A\n",
+            " 68%|██████▊   | 174/256 [00:06<00:02, 31.75it/s]\u001b[A\n",
+            " 70%|██████▉   | 178/256 [00:06<00:02, 32.87it/s]\u001b[A\n",
+            " 71%|███████   | 182/256 [00:06<00:02, 32.76it/s]\u001b[A\n",
+            " 73%|███████▎  | 186/256 [00:07<00:02, 33.21it/s]\u001b[A\n",
+            " 74%|███████▍  | 190/256 [00:07<00:01, 33.52it/s]\u001b[A\n",
+            " 76%|███████▌  | 194/256 [00:07<00:01, 32.36it/s]\u001b[A\n",
+            " 77%|███████▋  | 198/256 [00:07<00:01, 31.50it/s]\u001b[A\n",
+            " 79%|███████▉  | 202/256 [00:07<00:01, 30.41it/s]\u001b[A\n",
+            " 80%|████████  | 206/256 [00:07<00:01, 30.07it/s]\u001b[A\n",
+            " 82%|████████▏ | 210/256 [00:07<00:01, 30.72it/s]\u001b[A\n",
+            " 84%|████████▎ | 214/256 [00:08<00:01, 29.86it/s]\u001b[A\n",
+            " 85%|████████▌ | 218/256 [00:08<00:01, 29.13it/s]\u001b[A\n",
+            " 87%|████████▋ | 222/256 [00:08<00:01, 29.61it/s]\u001b[A\n",
+            " 88%|████████▊ | 225/256 [00:08<00:01, 28.77it/s]\u001b[A\n",
+            " 89%|████████▉ | 229/256 [00:08<00:00, 30.21it/s]\u001b[A\n",
+            " 91%|█████████ | 233/256 [00:08<00:00, 30.19it/s]\u001b[A\n",
+            " 93%|█████████▎| 237/256 [00:08<00:00, 30.60it/s]\u001b[A\n",
+            " 94%|█████████▍| 241/256 [00:08<00:00, 30.24it/s]\u001b[A\n",
+            " 96%|█████████▌| 245/256 [00:09<00:00, 28.25it/s]\u001b[A\n",
+            " 97%|█████████▋| 249/256 [00:09<00:00, 29.51it/s]\u001b[A\n",
+            "100%|██████████| 256/256 [00:09<00:00, 27.08it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 50%|█████     | 1/2 [00:16<00:16, 16.19s/it]\n",
+            "  0%|          | 0/44 [00:00<?, ?it/s]\u001b[A\n",
+            "  7%|▋         | 3/44 [00:00<00:01, 23.66it/s]\u001b[A\n",
+            " 14%|█▎        | 6/44 [00:00<00:01, 22.50it/s]\u001b[A\n",
+            " 20%|██        | 9/44 [00:00<00:01, 21.96it/s]\u001b[A\n",
+            " 27%|██▋       | 12/44 [00:00<00:01, 21.47it/s]\u001b[A\n",
+            " 34%|███▍      | 15/44 [00:00<00:01, 20.93it/s]\u001b[A\n",
+            " 41%|████      | 18/44 [00:00<00:01, 20.64it/s]\u001b[A\n",
+            " 48%|████▊     | 21/44 [00:00<00:01, 21.31it/s]\u001b[A\n",
+            " 55%|█████▍    | 24/44 [00:01<00:00, 21.20it/s]\u001b[A\n",
+            " 61%|██████▏   | 27/44 [00:01<00:00, 21.20it/s]\u001b[A\n",
+            " 68%|██████▊   | 30/44 [00:01<00:00, 21.27it/s]\u001b[A\n",
+            " 75%|███████▌  | 33/44 [00:01<00:00, 21.30it/s]\u001b[A\n",
+            " 82%|████████▏ | 36/44 [00:01<00:00, 21.60it/s]\u001b[A\n",
+            " 89%|████████▊ | 39/44 [00:01<00:00, 21.59it/s]\u001b[A\n",
+            "100%|██████████| 44/44 [00:02<00:00, 21.43it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 2/2 [00:21<00:00, 10.52s/it]\n",
+            "\u001b[32m[2023-10-15 20:06:14.854]\u001b[0m \u001b[1mAccuracy: 0.7166666666666667\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:06:14.855]\u001b[0m \u001b[1mLoss: 1.067921142801677\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "gene_list = [[3,2,4,4,2,4,1], [3,2,4,4,2,4,2], [3,2,4,4,2,4,3]]\n",
+        "param_num = []\n",
+        "accu_noise_free = []\n",
+        "accu_noisy_model = []\n",
+        "for gene in gene_list:\n",
+        "    total_params = 3 * sum(gene[k] for k in range(2 * gene[-1]))\n",
+        "    param_num.append(total_params)\n",
+        "    accu_noise_free.append(evaluate_gene(gene=gene, use_qiskit=False))\n",
+        "    accu_noisy_model.append(evaluate_gene(gene=gene, use_qiskit=True))\n",
+        "\n",
+        "plt.plot(param_num, accu_noise_free, marker='o', label=\"Noise free accuracy\")\n",
+        "plt.plot(param_num, accu_noisy_model, marker='o', label=\"Noisy accuracy\")\n",
+        "plt.ylabel(\"test accuracy\")\n",
+        "plt.xlabel(\"num of params\")\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FgBxcCWVWeT1",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "### Part 1: Search for the best gene\n",
+        "\n",
+        "In order to find the best subcircuit in real quantum computer's noisy environment, we need the noisy simulator to search for the best gene."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "XN1FxkE2OVhj",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "####Part 1.1: Random Search\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "qsWy34-fOvvJ",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "class RandomSearcher:\n",
+        "    def __init__(self, gene_choice, accuracy_predictor):\n",
+        "        self.gene_choice = gene_choice\n",
+        "        self.gene_len = len(self.gene_choice)\n",
+        "        self.accuracy_predictor = accuracy_predictor\n",
+        "\n",
+        "    def random_sample(self, sample_num):\n",
+        "        # randomly sample genes\n",
+        "        population = []\n",
+        "        i = 0\n",
+        "        while i < sample_num:\n",
+        "            samp_gene = []\n",
+        "            for k in range(self.gene_len):\n",
+        "                samp_gene.append(random.choices(self.gene_choice[k])[0])\n",
+        "            population.append(samp_gene)\n",
+        "            i += 1\n",
+        "\n",
+        "        return population\n",
+        "\n",
+        "    def run_search(self, n_subcircuits=100):\n",
+        "        # sample subcircuits\n",
+        "        self.population = self.random_sample(n_subcircuits)\n",
+        "        # predict the accuracy of subnets\n",
+        "        accs = []\n",
+        "        for gene in self.population:\n",
+        "          accs.append(self.accuracy_predictor(gene=gene, use_qiskit=True))\n",
+        "\n",
+        "\n",
+        "        # get the index of the best subnet\n",
+        "        accs = np.array(accs)\n",
+        "        best_idx = accs.argmax()\n",
+        "\n",
+        "        # return the best subnet\n",
+        "        return accs[best_idx], self.population[best_idx]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "pttB6AAEgjAl",
+        "outputId": "f396b1ec-d9a3-44b5-88c2-0339b02bcc75",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "  0%|          | 0/2 [00:00<?, ?it/s]\n",
+            "  0%|          | 0/256 [00:00<?, ?it/s]\u001b[A\n",
+            "  1%|          | 3/256 [00:00<00:08, 29.19it/s]\u001b[A\n",
+            "  2%|▏         | 6/256 [00:00<00:08, 28.59it/s]\u001b[A\n",
+            "  4%|▎         | 9/256 [00:00<00:09, 26.91it/s]\u001b[A\n",
+            "  5%|▍         | 12/256 [00:00<00:09, 25.88it/s]\u001b[A\n",
+            "  6%|▌         | 15/256 [00:00<00:09, 26.16it/s]\u001b[A\n",
+            "  7%|▋         | 19/256 [00:00<00:07, 29.80it/s]\u001b[A\n",
+            "  9%|▉         | 24/256 [00:00<00:06, 34.10it/s]\u001b[A\n",
+            " 11%|█▏        | 29/256 [00:00<00:06, 37.12it/s]\u001b[A\n",
+            " 13%|█▎        | 33/256 [00:01<00:05, 37.63it/s]\u001b[A\n",
+            " 15%|█▍        | 38/256 [00:01<00:05, 39.82it/s]\u001b[A\n",
+            " 16%|█▋        | 42/256 [00:01<00:05, 38.73it/s]\u001b[A\n",
+            " 18%|█▊        | 47/256 [00:01<00:05, 41.16it/s]\u001b[A\n",
+            " 20%|██        | 52/256 [00:01<00:04, 42.18it/s]\u001b[A\n",
+            " 22%|██▏       | 57/256 [00:01<00:04, 43.59it/s]\u001b[A\n",
+            " 24%|██▍       | 62/256 [00:01<00:04, 43.22it/s]\u001b[A\n",
+            " 26%|██▌       | 67/256 [00:01<00:04, 44.23it/s]\u001b[A\n",
+            " 28%|██▊       | 72/256 [00:01<00:04, 43.35it/s]\u001b[A\n",
+            " 30%|███       | 77/256 [00:02<00:04, 42.07it/s]\u001b[A\n",
+            " 32%|███▏      | 82/256 [00:02<00:04, 42.86it/s]\u001b[A\n",
+            " 34%|███▍      | 87/256 [00:02<00:04, 42.12it/s]\u001b[A\n",
+            " 36%|███▌      | 92/256 [00:02<00:03, 42.36it/s]\u001b[A\n",
+            " 38%|███▊      | 97/256 [00:02<00:03, 42.98it/s]\u001b[A\n",
+            " 40%|███▉      | 102/256 [00:02<00:03, 44.15it/s]\u001b[A\n",
+            " 42%|████▏     | 107/256 [00:02<00:03, 43.79it/s]\u001b[A\n",
+            " 44%|████▍     | 112/256 [00:02<00:03, 43.35it/s]\u001b[A\n",
+            " 46%|████▌     | 117/256 [00:02<00:03, 44.55it/s]\u001b[A\n",
+            " 48%|████▊     | 122/256 [00:03<00:03, 44.08it/s]\u001b[A\n",
+            " 50%|████▉     | 127/256 [00:03<00:02, 45.12it/s]\u001b[A\n",
+            " 52%|█████▏    | 132/256 [00:03<00:02, 44.81it/s]\u001b[A\n",
+            " 54%|█████▎    | 137/256 [00:03<00:02, 45.65it/s]\u001b[A\n",
+            " 55%|█████▌    | 142/256 [00:03<00:02, 46.79it/s]\u001b[A\n",
+            " 57%|█████▋    | 147/256 [00:03<00:02, 46.79it/s]\u001b[A\n",
+            " 59%|█████▉    | 152/256 [00:03<00:02, 46.00it/s]\u001b[A\n",
+            " 61%|██████▏   | 157/256 [00:03<00:02, 45.02it/s]\u001b[A\n",
+            " 63%|██████▎   | 162/256 [00:03<00:02, 43.12it/s]\u001b[A\n",
+            " 65%|██████▌   | 167/256 [00:04<00:02, 43.53it/s]\u001b[A\n",
+            " 67%|██████▋   | 172/256 [00:04<00:01, 42.86it/s]\u001b[A\n",
+            " 69%|██████▉   | 177/256 [00:04<00:01, 41.66it/s]\u001b[A\n",
+            " 71%|███████   | 182/256 [00:04<00:01, 43.19it/s]\u001b[A\n",
+            " 73%|███████▎  | 187/256 [00:04<00:01, 44.55it/s]\u001b[A\n",
+            " 75%|███████▌  | 192/256 [00:04<00:01, 43.74it/s]\u001b[A\n",
+            " 77%|███████▋  | 197/256 [00:04<00:01, 44.83it/s]\u001b[A\n",
+            " 79%|███████▉  | 202/256 [00:04<00:01, 45.36it/s]\u001b[A\n",
+            " 81%|████████  | 207/256 [00:04<00:01, 43.60it/s]\u001b[A\n",
+            " 83%|████████▎ | 212/256 [00:05<00:00, 44.83it/s]\u001b[A\n",
+            " 85%|████████▍ | 217/256 [00:05<00:00, 45.89it/s]\u001b[A\n",
+            " 87%|████████▋ | 222/256 [00:05<00:00, 44.35it/s]\u001b[A\n",
+            " 89%|████████▊ | 227/256 [00:05<00:00, 45.44it/s]\u001b[A\n",
+            " 91%|█████████ | 232/256 [00:05<00:00, 46.30it/s]\u001b[A\n",
+            " 93%|█████████▎| 237/256 [00:05<00:00, 45.70it/s]\u001b[A\n",
+            " 95%|█████████▍| 242/256 [00:05<00:00, 46.28it/s]\u001b[A\n",
+            " 96%|█████████▋| 247/256 [00:05<00:00, 43.87it/s]\u001b[A\n",
+            "100%|██████████| 256/256 [00:06<00:00, 42.35it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 50%|█████     | 1/2 [00:12<00:12, 12.35s/it]\n",
+            "  0%|          | 0/44 [00:00<?, ?it/s]\u001b[A\n",
+            "  9%|▉         | 4/44 [00:00<00:01, 34.11it/s]\u001b[A\n",
+            " 18%|█▊        | 8/44 [00:00<00:01, 33.24it/s]\u001b[A\n",
+            " 27%|██▋       | 12/44 [00:00<00:00, 33.06it/s]\u001b[A\n",
+            " 36%|███▋      | 16/44 [00:00<00:00, 32.80it/s]\u001b[A\n",
+            " 45%|████▌     | 20/44 [00:00<00:00, 32.46it/s]\u001b[A\n",
+            " 55%|█████▍    | 24/44 [00:00<00:00, 31.28it/s]\u001b[A\n",
+            " 64%|██████▎   | 28/44 [00:01<00:01, 15.89it/s]\u001b[A\n",
+            " 73%|███████▎  | 32/44 [00:01<00:00, 19.31it/s]\u001b[A\n",
+            " 82%|████████▏ | 36/44 [00:01<00:00, 21.80it/s]\u001b[A\n",
+            " 91%|█████████ | 40/44 [00:01<00:00, 24.01it/s]\u001b[A\n",
+            "100%|██████████| 44/44 [00:01<00:00, 25.16it/s]\n",
+            "Process ForkPoolWorker-39:\n",
+            "Process ForkPoolWorker-40:\n",
+            "Traceback (most recent call last):\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 114, in worker\n",
+            "    task = get()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 114, in worker\n",
+            "    task = get()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/queues.py\", line 368, in get\n",
+            "    with self._rlock:\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/queues.py\", line 369, in get\n",
+            "    res = self._reader.recv_bytes()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/synchronize.py\", line 101, in __enter__\n",
+            "    return self._semlock.__enter__()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/connection.py\", line 224, in recv_bytes\n",
+            "    buf = self._recv_bytes(maxlength)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/connection.py\", line 429, in _recv_bytes\n",
+            "    return self._recv(size)\n",
+            "KeyboardInterrupt\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/connection.py\", line 387, in _recv\n",
+            "    chunk = read(handle, remaining)\n",
+            "KeyboardInterrupt\n",
+            " 50%|█████     | 1/2 [00:14<00:14, 14.89s/it]\n",
+            "Process ForkPoolWorker-36:\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 39, in run_job_worker\n",
+            "    job = execute(**(data[0]))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/execute_function.py\", line 375, in execute\n",
+            "    job = backend.run(experiments, **run_kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit_aer/backends/aerbackend.py\", line 215, in run\n",
+            "    aer_job.submit()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/utils/deprecation.py\", line 27, in wrapper\n",
+            "    return func(*args, **kwargs)\n",
+            "Process ForkPoolWorker-37:\n",
+            "Process ForkPoolWorker-38:\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit_aer/jobs/aerjob.py\", line 58, in submit\n",
+            "    self._future = self._executor.submit(self._fn, self._qobj, self._job_id)\n",
+            "Traceback (most recent call last):\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/lib/python3.10/concurrent/futures/thread.py\", line 176, in submit\n",
+            "    self._adjust_thread_count()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/lib/python3.10/concurrent/futures/thread.py\", line 199, in _adjust_thread_count\n",
+            "    t.start()\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 940, in start\n",
+            "    self._started.wait()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 607, in wait\n",
+            "    signaled = self._cond.wait(timeout)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 39, in run_job_worker\n",
+            "    job = execute(**(data[0]))\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 320, in wait\n",
+            "    waiter.acquire()\n",
+            "KeyboardInterrupt\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/execute_function.py\", line 375, in execute\n",
+            "    job = backend.run(experiments, **run_kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/utils/deprecation.py\", line 27, in wrapper\n",
+            "    return func(*args, **kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit_aer/backends/aerbackend.py\", line 215, in run\n",
+            "    aer_job.submit()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit_aer/jobs/aerjob.py\", line 58, in submit\n",
+            "    self._future = self._executor.submit(self._fn, self._qobj, self._job_id)\n",
+            "  File \"/usr/lib/python3.10/concurrent/futures/thread.py\", line 176, in submit\n",
+            "    self._adjust_thread_count()\n",
+            "  File \"/usr/lib/python3.10/concurrent/futures/thread.py\", line 199, in _adjust_thread_count\n",
+            "    t.start()\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 940, in start\n",
+            "    self._started.wait()\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 607, in wait\n",
+            "    signaled = self._cond.wait(timeout)\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 39, in run_job_worker\n",
+            "    job = execute(**(data[0]))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/execute_function.py\", line 375, in execute\n",
+            "    job = backend.run(experiments, **run_kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/utils/deprecation.py\", line 27, in wrapper\n",
+            "    return func(*args, **kwargs)\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 320, in wait\n",
+            "    waiter.acquire()\n",
+            "KeyboardInterrupt\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit_aer/backends/aerbackend.py\", line 215, in run\n",
+            "    aer_job.submit()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit_aer/jobs/aerjob.py\", line 58, in submit\n",
+            "    self._future = self._executor.submit(self._fn, self._qobj, self._job_id)\n",
+            "  File \"/usr/lib/python3.10/concurrent/futures/thread.py\", line 176, in submit\n",
+            "    self._adjust_thread_count()\n",
+            "  File \"/usr/lib/python3.10/concurrent/futures/thread.py\", line 199, in _adjust_thread_count\n",
+            "    t.start()\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 940, in start\n",
+            "    self._started.wait()\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 607, in wait\n",
+            "    signaled = self._cond.wait(timeout)\n",
+            "  File \"/usr/lib/python3.10/threading.py\", line 320, in wait\n",
+            "    waiter.acquire()\n",
+            "KeyboardInterrupt\n"
+          ]
+        },
+        {
+          "ename": "KeyboardInterrupt",
+          "evalue": "ignored",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-17-b4ae853dddef>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# get the accuracy and gene of the best subcircuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0macc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_search\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\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      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-16-b3c7af4ba246>\u001b[0m in \u001b[0;36mrun_search\u001b[0;34m(self, n_subcircuits)\u001b[0m\n\u001b[1;32m     24\u001b[0m         \u001b[0maccs\u001b[0m \u001b[0;34m=\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     25\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m           \u001b[0maccs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccuracy_predictor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\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     27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-8-0001952830ed>\u001b[0m in \u001b[0;36mevaluate_gene\u001b[0;34m(gene, use_qiskit)\u001b[0m\n\u001b[1;32m     52\u001b[0m                 \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m                 \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_qiskit\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     55\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtarget_all\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m                 \u001b[0mtarget_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-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   1499\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   1500\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\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   1502\u001b[0m         \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1503\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\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<ipython-input-5-a9ce2bd20b11>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, verbose, use_qiskit)\u001b[0m\n\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;31m# call the qiskit processor to process the circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m             x0 = self.qiskit_processor.process_ready_circs(qdev, assembled_circs).to(  # type: ignore\n\u001b[0m\u001b[1;32m     71\u001b[0m                 \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m             )\n",
+            "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs\u001b[0;34m(self, q_device, circs_all, parallel)\u001b[0m\n\u001b[1;32m    720\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    721\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mprocess_ready_circs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq_device\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\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--> 722\u001b[0;31m         \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_ready_circs_get_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparallel\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    723\u001b[0m         \u001b[0mmeasured_qiskit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_expectations_from_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_wires\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mq_device\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_wires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    724\u001b[0m         \u001b[0mmeasured_torch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeasured_qiskit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs_get_counts\u001b[0;34m(self, circs_all, parallel)\u001b[0m\n\u001b[1;32m    695\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    696\u001b[0m             \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmultiprocessing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 697\u001b[0;31m             \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_job_worker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dicts\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    698\u001b[0m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\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    699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m    362\u001b[0m         \u001b[0;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    363\u001b[0m         '''\n\u001b[0;32m--> 364\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\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    365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    366\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    764\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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--> 765\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\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    766\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\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    767\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    760\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    761\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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--> 762\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\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    763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    764\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    605\u001b[0m             \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    606\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 607\u001b[0;31m                 \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\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    608\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    609\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    318\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m    \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    319\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m                 \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\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    321\u001b[0m                 \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    322\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;31mKeyboardInterrupt\u001b[0m: "
+          ]
+        }
+      ],
+      "source": [
+        "agent = RandomSearcher(model.arch_space, evaluate_gene)\n",
+        "\n",
+        "# get the accuracy and gene of the best subcircuit\n",
+        "acc, gene = agent.run_search(10)\n",
+        "\n",
+        "print(gene)\n",
+        "print(acc)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "tdpXf_JFOpy8",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "####Part 1.2 Evolutionary Search"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "RhoZuyUfij_i",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "\n",
+        "**Evolutionary Search**\n",
+        "In this part, we will implement a more sample-efficient search algorithm, evolutionary search. Evolutionary search is inspired by the evolution algorithm (or genetic algorithm). A **population** of sub-networks are first sampled from the design space. Then, in each **generation**, we perform random mutation and crossover operations as is shown in the figure above. The sub-networks with highest accuracy will be kept, and this process will be repeated until the number of generations reaches `max_time_budget`. Similar to the random search, throughout the search process, all sub-networks that cannot satisfy the efficiency constraint will be discarded.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Hn6oFg4jiois",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "![evolution.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABLAAAADcCAYAAABgWFj9AAABYWlDQ1BrQ0dDb2xvclNwYWNlRGlzcGxheVAzAAAokWNgYFJJLCjIYWFgYMjNKykKcndSiIiMUmB/yMAOhLwMYgwKicnFBY4BAT5AJQwwGhV8u8bACKIv64LMOiU1tUm1XsDXYqbw1YuvRJsw1aMArpTU4mQg/QeIU5MLikoYGBhTgGzl8pICELsDyBYpAjoKyJ4DYqdD2BtA7CQI+whYTUiQM5B9A8hWSM5IBJrB+API1klCEk9HYkPtBQFul8zigpzESoUAYwKuJQOUpFaUgGjn/ILKosz0jBIFR2AopSp45iXr6SgYGRiaMzCAwhyi+nMgOCwZxc4gxJrvMzDY7v////9uhJjXfgaGjUCdXDsRYhoWDAyC3AwMJ3YWJBYlgoWYgZgpLY2B4dNyBgbeSAYG4QtAPdHFacZGYHlGHicGBtZ7//9/VmNgYJ/MwPB3wv//vxf9//93MVDzHQaGA3kAFSFl7jXH0fsAAAA4ZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAKgAgAEAAAAAQAABLCgAwAEAAAAAQAAANwAAAAApP94BgAAQABJREFUeAHsnQd8FMUXx196SCMBQg29996LCEiVoiAiCKJYwEaR4h9RAQtYUEEFxAKKInawUKR3EFAQpNcQSoB00gv/+c1lj0tIwl1ye7e79x6f427blO9s7mbfvPmN201hxMYEmAATYAJMgAkwASbABJgAE2ACTIAJMAEmwAQ0SsBdo+XiYjEBJsAEmAATYAJMgAkwASbABJgAE2ACTIAJMAFJwFPLHBAcprzc3NwoKyuL8A7LK3Asr31arh+XjQkwASbABJgAE2ACTIAJMAEmwASYABNgAmoRUHwolukr++BDcXd3l/4V7FNeludq6bPTHVhwSmVmZkrnFD7jpTittASKy8IEmAATYAJMgAkwASbABJgAE2ACTIAJMAGjE1AcWXBuKS8PDw/52Zl1dxPOIodrYMFhlZ6ebnZcORMA580EmAATYAJMgAkwASbABJgAE2ACTIAJMAEmUDABOLPgyPLy8pLvBZ9t/6MOc2DBT5aRkWF2XNm/KpwiE2ACTIAJMAHjEUhLS6PIyEiKj4+Xv6Pe3t4UEhJCoaGhTuk4GI8w14gJMAEmwASYABNgAkzAVgKKI8vT09Ms9WRrGrae7xAHFqKt0AHH9EA2JsAEmAATYAJMwDoCiYmJdObMGem4yn2Fr68v1ahRQ46A5T7G20yACTABJsAEmAATYAJMwBEEEJWFAVZEZaltqjqwMFUwJSWFHVdqtyKnzwSYABNgAoYjgEGfI0eOyMjl/CoXGBgonVj5Hef9TIAJMAEmwASYABNgAkzAEQTgyMIAKyKz1DJ3tRJOTU2lpKQkdl6pBZjTZQJMgAkwAUMTiImJKdB5hconJCRQcnKyoTlw5ZgAE2ACTIAJMAEmwAS0TwCDr/ABwRekltndgQWtK3SmMWWQjQkwASbABJgAEygcAXQArDFrz7MmLT6HCTABJsAEmAATYAJMgAkUhQB8QfAJqbFeoF0dWCggOtIQa2djAkyACTABJsAECk/A2t9STNdnYwJMgAkwASbABJgAE2ACWiGAfix8Q/Z2YtnNgaWEi7FQu1ZuGS4HE2ACTIAJ6JmAtT/41p6nZxZcdibABJgAE2ACTIAJMAF9EVDDR2QXBxY6zwgRY+eVvm4oLi0TYAJMgAkwASbABJgAE2ACTIAJMAEmwATUIAAfkT2nE9rFgcUrDarR1JwmE2ACTIAJMAEmwASYABNgAkyACTABJsAE9EsATiz4jOxhRXZgpaens+aVPVqC02ACTIAJMAEmwASYABNgAkyACTABJsAEmIDBCEATC76jolqRHFjwpKm5RGJRK8fXMwEmwASYABNgAkyACTABJsAEmAATYAJMgAk4lwB8R0WVnSqSAwthYCwe69ybgHNnAkyACTABJsAEmAATYAJMgAkwASbABJiAlgnAd1TUqYSFdmAhBIyX7tby7cFlYwJMgAkwASbABJgAE2ACTIAJMAEmwASYgDYIwIcEX1JhrdAOLJ46WFjkfB0TYAJMgAkwASbABJgAE2ACTIAJMAEmwARcj0BRfEmFcmDBY1bUuYuu10xcYybABJgAE2ACTIAJMAEmwASYABNgAkyACbguAfiSChuFVSgHlj3U4123ubjmTIAJMAEmwASYABNgAkyACTABJsAEmAATcE0ChfUp2ezAgvBWYb1lrtk0XGsmwASYABNgAkyACTABJsAEmAATYAJMgAkwARCAT6kwCwLa7MAqrKeMm4kJMAEmwASYABNgAkyACTABJsAEmAATYAJMgAkUxrdkswOLo6/4RmMCTIAJMAEmwASYABNgAkyACTABJsAEmAATKCyBwviWbHJgIcQLyx6yMQEmwASYABNgAkyACTABJsAEmAATYAJMgAkwgcIQgG/J1mmENjmweOXBwjQLX8MEmAATYAJMgAkwASbABJgAE2ACTIAJMAEmYEnAVh8TO7As6fFnJsAEmAATYAJMgAkwASbABJgAE2ACTIAJMAHVCajqwLI1vEv12nIGTIAJMAEmwASYABNgAkyACTABJsAEmAATYAK6I2Crj8mmCCzWv9Ld/cAFZgJMgAkwASbABJgAE2ACTIAJMAEmwASYgOYI2OpjssmBpbnacoGYABNgAkyACTABJsAEmAATYAJMgAkwASbABAxPwCYHlq3zEw1PjyvIBJgAE2ACTIAJMAEmwASYABNgAkyACTABJmAzAVt9TDY5sGydn2hz6fkCJsAEmAATYAJMgAkwASbABJgAE2ACTIAJMAEmkIuATQ6sXNfyJhNgAkyACTABJsAEmAATYAJMgAkwASbABJgAE7CZgK1BUp625GBr4rak7ehzUZf9+/fTn7//Tv+s30TxKcnkVbY0JScmUuzZ83TTw50CwypQQsRFysrIkJ/dPT1V2w6qGEYeXl50Q+TnlplFZerUphKhpSjj1Fmq6OtHzy78iMJq1qBNk16m5Kho6vz2TPIrVdLw25snvyLre9fs6eQneOx97yPKTE+nBiOGUkC5Mo6+bTg/JsAEmAATYAJMgAkwASbABJgAE2ACTMAOBGz1MdnkwLJD+ZyeRHpaGs2ZOIWWrPyFLsVE5yzPiWM5t69dvbWd+1yVt49tt8hblOKTVi2pf//+1OpyDAUlJFFWeoYsW+zpM5R45apht2NOnZb1uymcerALW3ZQ0rXr1PDRh+X2rjfnUGjDelS9Tw9yc+eAQgmF/2MCTIAJMAEmwASYABNgAkyACVhB4Pqly3TtaiRlIZgiNpbiRUCFu48P+ZcpTbFnzhG5uVFwtSpEIgBEre2Q6lXJTZQ14Vw4eXl7U7kG9ah4UBDRlWvkJgJLQsX2zawsun74KJG7m+ts/3dMPOO6Uan6dWVL4jnYJ7i4DHyRO1zwPzfh8bppbb0TEhKsPVWT550/f54efughOnj4sCxf2QoVqFOPnlSjTl0R7RRK/gEB4g/GhzxEpJVHtjPETfzBOsLQDGiJrKxMgpMtNSWF4uNi6fKFC3Tgrz20a9NGwhKTXqJs0ydOoqcnTZQ3bsypM8J5lU7BNaoZdjtT8AipWV3WL2LHHkq6epVq3ddXRMNdopWDHyF3by/q+/VnIkquvCOaivNgAkyACTiEwJkzZyguLu6OeZUvX57KlOGI1DuC4hOYABNgAkyACTABSrpxg374Zhmt2riBtm/dSgliBpJWzVM8i1f2C6QnXp5KDw4cRKvvGyaf/YZuXkWZqWn07d19jL8tHItDt6yiLOELWNaxpwzaeHDdCvIsVoziL0QQZnLp3QIDA62ugtURWDb4uazO3JEnHt69hwYMG0pXr12jMqKz//SLL1Ev8Ufg4eHhyGIUOq+I8+fo0znv0O/ff0cvzZ5FEcK59dZbb1GIcFxZmtG3w9q3NlfXX0whbPO/F4Q3PlM6r9ISblB6YhL5i6mgbEzA2QSSxb24bsN6Wrt2Le1e8ydFJcRThpcnpQqHLJzUWdaPHdi1Ku5u7uRON8nH15eKh4SQnwhuDE5OpXsHDaQnZr5KRxd9SSd+Wkktxj9DdR4YQH/N+cjQ25iWfPzHW/X994uv6dy6TVRv6CCq0beX7Cy46+R3wq43ipWJZYop9ht/XkF7t2+ntBLBFB8fTxf27qc0DDzUriVHTa+L0UN0unzFiGFgxQqUEhtHCRcu8rYFD8gHFBN/jyXECHeG+C1LFQM05apUoRZ9elKdEqEUv3UnlW7ckGoP6k+RBw7Jv8nCbl87dIRO/rqKQsVobs0BfSg1Ll5GOofUqi4G2R0zaGfl7cWnMQEmwASYgJ0JfPHe+zT9zTcpNi3VnLK3kKsJDC5JPsX8yNPLWzhIPMhdBnM48jcBwRw3RX8hgzIy0ilNyPskJcSKVxydToynF198kV577TXqX6MO3V+voansiEwSM3EQfCLNiNsN6pqjrTJEgEsxISHkLhxacF4lR8fQb0NHUZmmjemuWdPJy9/P3KZ6+4C2t7YPYrUDS28QLMsbFxVFg4Wz6qr4A2japi2989liCilVyvIUzX8Oq1yFZsz7mNp0vptmjh9LCxYsoLCwMHruuec0X3a1CoiHyhp9e8rkU8VD04bnp4jH8pvU85N55OHjrVa2nC4TKJAAnFMzxzxDX6z4hRLS03Kem5Jz0xlbWTezCBNyM5KTKVG8FNv3+SKa8/231K9pC2opQrQVy/08a7TtW/U0ddKSRWh2/Plw84/ov59+SdcO/UfNnx9DJWrXUE53+ffo69dpwSef0JLFiylSRMXmaUf/u3333ly7eDsnkD27bm0f2E+frPhJbtcQo8/D7ukhHViJVyLp/IYtBF1OOLRs3Ya255k/1tJN4VSEA+vSnn20Y/osKteqOXX9YPat/F3kE5ytmzZtoj9Xr6Z96zZQrIhM8CgZQqmpqZQQKSQaRKca0zXSxP6bGZnkHRggHLMeKm4HiocVT8q4ISIihIO4eNkycpaAx/VoKp1JNEoMNHQZeJ/QQJ1GUUeOU+d3XqdS9Wq7wPbLFH3sBN311gxR3zq05+25dENMe2r85Ei57SK3K1eTCRSaAGbyTJgwgRaL321Y6bCq1HXwk1S/VRcKDi1b6HTVvjDpRhyd+Gcnbfrpczp9aC8tO7ifosuFUmsRoV68eHHx3DfXXAToSRtue9E8c/28/f1p4K/LpaMPO+PEdEsPMdXTS+zXs/PKXEErP7iEA+t/kyZThHBeVa1Vi+Z98y35+QdYiUd7p/W6f5Cc//vys0/T9OnTqXfv3lS9enXtFdTBJXL3EJ094ZXGKH/CxUumedoOLgNnxwQiIyNp6NChtHev6am8Rt161PfBIVSvSVMqU648BYofWm/xQ+MpfmAR/WntSIO9yGJ0Ax0YRM2kiYezG2Ja+LXIK3T80L+0+qcf6eDev+ibrZvo34YNqWurpjLblhOeJbwUM+I2os0Ua/r049IpUEwsGgEL37JdOLQuiMUkosQWO7DAZOmc9+nFN98wO2grVq0mB4fKV6xIQcEhMroP+hUYZHDDv9xeTyTCZiagRLjfFM7lDPG3CSd4UuINihFOwjPHj4votm10KimBZqz8kf56MJHef+0N6jDzJfNCJojEsmU7tGF9ajv1BQqoYJp2D20RP6FzUr5tK1kmRHh5iKn5cBIY2TCFZuYzz9E3q/6guNRcowsx+Hu3MBG9b7boXPqpdt/OmXeUkL84I16K/fboI9RAROT3DilDVWLgVDNpoqbGJ1BKTKyBt+Ploj6KJmr08RMUdfQENRkzSqLZMWO2dDRCI9UnKFDBxe9MgAlkExjVpx/9vHOb6H960v1Pv0Id+w3PjrLSNiK/gOLUpGMv+fpvzyb6avZ4WrNmDQ0YMID++OMP8vPTb9RRYckr/aqyzRrTgB+XmvtZR779kUoI2Z2yLUx9+MKmr/XrrNbAyhIj8okanh+bH+jw8HBq1KiR9FQu37iVatQ1CaDld75e9k97ejSt/vlHGjJkCC1atEgvxVa1nIlipNQ3OJijr1SlzInnRyBSfNd0veceCr98mUqVLkNTZr9Nd/fqbf5Rye86Le3Hg/KsKZPo/OlTVLJkSTn9sZZw/LuyYXrVpd17qWqPrlJrAQ6tqt27OASJFjWwvvjiCxo3bpysf6MWLempyS9S606dHcLDVTNJvJFAP3zxOX358TxKECPONWrUoF9++YUqV65sNyRwoiEiKzMtnX5/+AlKEdMS7p7zBpVt3sRueWgpIfxtDRWaqEeOCjFgYeWr1qZmne+l8tXqUvESpclXDHRCE9Xd3VOK55oeFhw1lSZ7Go3od2eKaTTpwrmWLKbPxFy9TOeO/k17N6wUIssmJ9fwh4bSnPffI1/xAIdI9CwRIQbnDaLzjLiN+xNTkVE/rBieePmKfFDLSEmlH/sMEr+37tRr8XyCGDQbE2ACtwh8+PKr9NLc98nT04ueeftrqtm4za2DOvsUHRlB740dRLHXLtMjjzxCH374oc5qoE5xL+/9mzaMnUI+IcHUd+ki8i0Rok5GKqXqL6LITNNW75yB1Q4sdG5uiNEqvdnEkY/RIuHouadff5q96HO9FT/f8uIBc2CHtuQlIjnOnj1Ltgif5ZuoAQ5AzC988za5WoajHjINgI2rUEQCiGi6u2FjOnDxAtWq30BGeoaWLVfEVJ1zOaKyJo8aSXu2bpHRndu2baMAscAFG9GGcS/S5b/2yyksFTu2Ux2J1hxYG/78kwYOHiwWG8miUeNeoNFT/qcrB63qDaZyBljUZeKjw+n44UNUs2ZN2rJli93/NhHFvO+D+TLqsPPbM8lTaOUZzf7b8xfdK+7jKLGadMlylWjgmJepYbt7dHMvQxdm269L6ffF74povVRq3749/fzzz1RM6KG4sl3/7yjFh0dQtV73COddgtDZizCv2uXKXLjuTCBWrCqIYA68D5v4NrXt9aDuoYSfOETvPX8/ZQipDkwBb968ue7rVNQKwFez87W3qVzLZvJ7sKjpOfp6PGsokWV3ytv9Ticox5UQd2VbL+9rNmyQRb1/+CN6KbJV5axcvQa1aN9BCuWuX7/eqmtc4aTL+/4hhJEfFyLUbEzAUQQWf7FYOq9CSpaiD5YuI706r8ArQKwC8s4XS6iKeEA+ffq0XCzCURy1nk/5ti2lCDm0BlzNrpw7T8NFxAqcV49PmERjXpxqdUfD1VipVd9yYormQvHbhimbJ0+epGnTptk9K0z7bPXCc9Tl/VnSeXX138OUIaYbG8XiY2LkKlZwXtVs0pYmz/+NGrXvrqt72du3mNStmTDvZypeqgzt2LGDxo4da5QmKnQ9sMQ8nFdYzGf9c5No08RphMh8Nibg6gSWfPa5dF5VrtPEEM4rtGelWg2pfZ+hsmnnzbulEeXKbQ3nT/tXppidV5lCjkBPZouvyWoHlp4AKGWF1stFoX0Fw1QHo5lSp0OHDhmtaoWuT6hYiaJyt84U1l6/obGFrjxf6BQC+J5574P3Zd4TZr4mVzl1SkHsmKl/QCC98t5cmSKmKMeIhz42oroPDqR7v/6UoDngava6mCp4Iz2dmrVtR09NmuJq1ddMfaGj984XX0qHy5IlSwhRemoYHFmHFn9Df44eTyfEKp1GsdfFClbh8bFUpmJ1enLmp+QfFKzbqlWs2YCeeu1zOdVx+fLl9KeIkGQj8vQrRn6lS5FvyRKUGhvPSJiAyxP4ItvB02PYLT1TI0DpNmS0mOLtTqvFAhx6lDlSqw0iduyhlQ+OpGPf/axWFk5P19AOrGtCdDNTjBZjxUFfA4ZWYzQWduXKFaffSFopALQfOgpx2wYjHtJKkbgcBifwi5iaHBERQWFVqlKPAfcbpraNW7ailh06UrJYqXDlSuM8wNqjgY4u/0ms+PWyPZLSRRoQFv9tz05Z1tGTedqgsxsNi0N073+fjIaDE0stC65WhdyFmHuyEAY3gl0XovhffPWVrMqIF9+nYv76F/pGFELP4aboq1mzZhmhmYpcB0QhdJjxEvVZsoBXji0yTU5A7wSuC13Wc7Ex0tFdv1VnvVcnR/lDQstR5dqNKUUs4rVnz54cx1x5I0NMM0+4cJEQQW1UM7YDS8x/hwUGFTdk+yn1ihOirmy3CEAD67gYMU5L0J9m261a8Ce9EFj1q8m503vgILmyoF7KbU05ew8aLE9bu3atNae7xDkyMmXJN3Rxx26XmZ6yRUzFRxRezXr1ZQSWSzS0xis5eNQTsoS///67aiUN69SOBv32PTV/9knV8nBkwh+/MkPKLtQTD3GV6xgnivKuAY+QX2Bx2r9/Px07dsyRSDWbl5eIwoIm6rEfVtC/X3yt2XJywZiA2gSwsBCsdFg18hAC7kYzLMABUysaWY+8yrduKRezaD/9f3osvlVlNrQDK/ZypITgY0ARUlRMqVeqgfQprLpr73DSwUVLaO97H1HS9ZxLUd/hMj7MBApF4OrNTHld3UbGeSBSQNQVop+wEydOKLtc/h3h6i3GjiF0DFxFC2vdsu9kuzdv197l218rABo0a07ePj506tQpiherz6lhUkzV3Y2ijh6nG9n9KTXycVSaf240aaK27WlyzDsqX7Xz8fULEMvL95bZYGl5NhOBpGvXad/7H9PJX35jJEzAZQlERZmehQJDShmSgVIvpZ6GrKSNlfIO8KeStWuSt4H1Wg3twHLzM62e4ylW6jOieXl7y2qlC10StlsEoIFVc8C9hD9gNiagNoEYsWofLLRsWbWzcnj6ihj91asshGsJH0LBWOXUVb5jLmWP4JavVMkSA392IgEPoVFVtkKYLMHl7PZRozj/fbWcVo96ls6u1f9iMZeSTFHZEDI2mikRZUeOHDFa1Qpdn+JVKlG9oQ9Qg5HD6KaQE2FjAq5I4Pzev2W14eg2ovkUM9Xrxg3T97sR62hrnSCG/vuIp2jFA8ZawM6Sg6flhtE+ews9JJiHhzH9dO4iEgAGEWm2WwQaPTb81gZ/YgIqE7iePVU5IChI5Zwcn7xSp4RsJ53jS6DNHMO3bBdTCPdQpc4dqEK71tospB1L5VNZOEp2EwUFh9gxVU6qqASU9sDS6GpZUMUKFFKrunDW6vvhB6tnRmVzCi5lvMGGkNLl5S3Amqg5/xKaGWT6a85a8RYTsJ5AcqLJsePpZQp6sP5KfZyp1CtNZyvuqUkX0dNxZ8/RzcwsyhIapu6exnP3GK9GFndESrbwqBu5Wew1zkcZ3i+qY8uyk8apff41Cd+0jVJER7XS3Z3IN9iY+mf5156POJpAclKSzNLbxxTx6ej81czPU/zowVGOhz8IeWObjSjqyHE6/fsaCgwr7xIOLAj5w4y4GIqe72dfofMDg4CtWlb93p6El94tNnsajU8xf4KOndFMEaTnwYacLXtm9TqKOxdONfr2kt/XOY/yFhMwPoEQMZUMZsTvPdQL0cgwDuaQGMz/3bt0EYklGsnNgL93qKShn0aSo6JNDSk8kUY2dmDlbN3DXy6j6BOnqGTd2uzAyomGt1Qg4IGHyLRU8vQy5tcppmCnCZ09dmDdunkQeRVQoRyVEt8xrmBXDh6W1VSmrbtCnfVQR8WhrObIc6rQ10q8fJW8gwIooJx+I5duZA9oenn76KFpbS6jV/YAiprOTJsLpYELzqxZT1fEFKoyzRqzA0sD7cFFcAKB7Nk60O80oin1YgdWztYtXqVyzh0G2zLmE1d2I/kEBxusuXJWR4nAyrmXtyp16UQl69URzitjtz+3tEYIZI9uuIuRDiOaMmrHnYNbrQvnOF6uYpnZ+jEe7saLXNFzGzpi5Dli2y7a9ca7BN23di9P1i0ut+wBBg+DRpF6eJi68xhoYLtFoHqfHlSmaSPhvKpwayd/YgIuROD6f8dkbXk2kgs1uqjqHyNHU2ZKKvX+ciF5igVfjGaGdmAVK8l6HUa7Ya2pT4MRD1lzGp/DBOxCID17CiEZNNJT6fRwpOet2+XCtp0UIV5hHdpRxU7tbh0w6KcSdcQUhAvnRDi6saOZ9dZ8ysizmn+bPsWLSw0s/7Jl9IYnR3ndshfzcTOoE1YZaMB0b7ZbBLDYBhsTcGUCWYZf6Iv7JXnd3/HnIyhTzJ4QGiB5Hdb9PkM7sFJj43TfQFwB2wmwBpbtzPiKwhPITDeNeHNEZOEZ6u3KGDFF+fTva8mvdGmXcGAp7cP3uEJCG+9Ke6jpwArr0EY4attoo8JFKEVqgknIWGFWhKQ0eqnpIU7Ne0GjFS+wWNDAij9/gar27EZYlZCNCbgagZL1XCda3NXatqD69hGRV1h91cPXePq8qLehHVjJUTEFtS0fMygB1sAyaMNqtFqexcSPQ0K6RkvHxVKDACKv/EqHUolaJnFUNfLQUppRx05oqThcFgcSSI1PoMQrkeQjVln1L1vagTnbN6v0JNNCBPZNlVPTOoHzG7eKFWN3U6kGddmBpfXG4vKpQsA9O/pUlcQ5Uc0SCKokVo82sBnageXDK9AZ+NbNv2qsgZU/Gz5ifwIe3DmwP1SNp1iidg3Cy2Xs5k2XqSpXNCcBPPzvfO1tGcHS/pUpOQ/qaMsnwF9HpeWi2otAtV7dpPMqqHJFeyXJ6TABXRGIOnpcV+XlwtqHgNTASk2j3ksWsAaWfZA6LhXWwHIcay3lxBpYWmoN45eFR/aN38a5a2jSwNpFYR3bUsWOrqCBVYsoIjw3Bt52AQLegQEUUrO6WIFQ3xpYnlgtls3lCFTucpfL1ZkrzAQsCWSl8QwBSx6u8jk+/KIQcU9hDSw9NjhrYOmx1YpeZtbAKjpDTsF6Alm86pP1sAxypkkDa42cRugKDizj6gYZ5IZUsRphHdoKDay2KubgmKTTbiQ6JiPORVMEzqxZT/HnwlkDS1OtwoVxJAHWwHIkbe3k1UdEXrEGlnbaw6aSsAaWTbgMczJrYBmmKXVREdbA0kUz2bWQrIFlV5ycmIYJGEUDKyNZjESzuRyB8xu2sAaWy7U6V9iSAGtgWdJwnc+sgaXjtmYNLB03XhGKzhpYRYDHl9pMgDWwbEam+wtYA0v3TcgVsJKAUTSwvP39rKwxn2YkAqyBZaTW5LoUhgBrYBWGmv6vYQ0sHbcha2DpuPGKUHTWwCoCPL7UZgKsgWUzMt1fwBpYum9CroCVBFgDy0pQfJomCbAGliabhQvlQAKsgeVA2BrKijWwNNQYthaFNbBsJWaM81kDyxjtqJdasAaWXlrKfuVkDSz7seSUtE2ANbC03T5cuoIJsAZWwXz4qPEJsAaW8ds4rxqyBlZeVHSyjzWwdNJQdi4ma2DZGSgnVyAB1sAqEI8hD7IGliGblSuVBwHWwMoDCu/SDQHWwNJNU3FBVSLAGlgqgdV4sqyBpfEGKqh4rIFVEB3jHmMNLOO2rRZrxhpYWmwVdcvEGljq8uXUtUOANbC00xZcEtsJsAaW7cz4CmMRYA0sY7WntbVhDSxrSWnwPNbA0mCjOKBIrIHlAMichZkAa2CZUbjMB9bAcpmmdvmKsgaWy98CugbAGli6bj4uvB0IsAaWHSDqMAnWwNJhoylFZg0shYRrvbMGlmu1t7NryxpYzm4Bx+fPGliOZ845OocAa2A5hzvnah8CrIFlH46cin4JsAaWftuuKCVnDayi0HPytayB5eQGcFL2rIHlJPAumi1rYLlew7MGluu1uavWmDWwXLXljVFv1sAyRjtyLQpPgDWwCs9Oz1eyBpaOW481sHTceEUoOmtgFQEeX2ozAdbAshmZ7i9gDSzdNyFXwEoCrIFlJSg+TZMEWANLk83ChXIggagjxx2YG2elFQKsgaWVlihEOVgDqxDQDHAJa2AZoBF1VAXWwNJRY9mpqKyBZSeQnIzmCbAGluabiAtYAAHWwCoADh9yCQJZ6ekuUU+uZE4CrIGVk4eutlLj4nVVXlsLe/PmTVsvcYnzWQPLJZpZM5VkDSzNNIXDCsIaWA5DzRk5mQBrYDm5ATj7IhFgDawi4eOLDUCANbAM0IiFqAJrYBUCmlYuSYmKMRXFoI4exYHl5uamFeSaKIdZA6teHfINLq6JMnEhjEuANbCM27b51Yw1sPIjw/uNRoA1sIzWoq5VH9bAcq325treToA1sG5n4gp7WANLx61crESwLH3WzSwd1yL/oisOLHd39/xPcsEjUgOrbm12Xrlg2zujyqyB5Qzqzs2TNbCcy59zdxwB1sByHGvOyf4EWAPL/kw5RX0RiDpq0sC6SUadtWOqFwdz5LwvWQMrJw9dbQWUDpXlzczI1FW5rS1sZqapXp6entZe4hLnsQaWSzSzZiqZkZwiy6I4lDVTMC6IagRYA0s1tJywxgiwBpbGGoSLYxMB1sCyCRefbEACNzMyTLXi2UgGbN38qxR/PoIyU1OJDNruhvZ8uKWb/mjT0kQDGtDSs+vl7e1twNoVvkpnVq+jTCFaWKVrZ/Ly9yt8QnwlE7CCgFkg06A/EsqoHY9u3boZoo+fotO/ryH/MqFUsWO7WwcM+klpe3bSaquBHdEerIGlrTbn0thGgDWwbOPFZxuPQOkG9WSlsrKMGYGVlWUK5vDw8DBe4xWhRn2+XEg3BRsPH58ipKLdSw3twFLcOkmJidptgSKUTKmXnx87aSwx/v3xp5QSHUMV2rZiB5YlGP6sCgGfAH+6ERtLRp2qnJUd6clTlW/dPnBawXkVUqvGrZ0G/hR9/KSBa6fjqmU7zRUHoxo1SY2Pp8QrV8mneJC450urkYVD0jR+pCxPo8nrRjq/YTNd3LGHSjWoS8WrVMrrFN7HBAxNwLtYMVm/rExjrkaYmR1hxrORct7GrIGVk4eutspWrSLLGxsVpatyW1vY6OvX5aklSpSw9hKXOK9m/96UEHGZfFjA3SXa29mVlJ0D4cAy7FRl7hzcdou5mgaWO5kWClGcmbcB4R1OIZCVZdL3VHPkOWLrTtr15hyq1rs7tZs2ySn1tEemvkGBMpmbRtVEzb4X1HRm2qMdHJ1GtV73UKn6dSmockVHZ835MQFNEEiOuCTLkZZqkrvQRKHsWIiM7NlIPgaNNCoMKsxC+m3oKPIOCKDei+cXJgnNX2PoCKwSoaEE5050dDRdvnCBylU01g/YuRMn5A1WpUoVzd9ojixg4ydGOjI7zsvVCaSYpiinGrBzAJ09vPBQ5OXl5eotba4/pqVE/n2QqvboSmWbNzHvN+qHUBG9QOFnxb2QraVh1IrqrF6K01xNB5Z3UBCF1Kyu6+grNKtvYIBsXaM6YVkTNe8/XtbAypsL73UdAoGBJud98o14Q1Y6KbteQeK3is1EIC3hBt24aOxADkM7sNCMrZs1p9Xr19GWtWtoyONPGObezhBREds3rJP16dixo2HqVdSKnF27gW5cviIeLLtRQLkyRU3OLtfv2bOHlJFyJFirVi0qWbKkVWlfEI7XiIgI87k1atSgUOGYZdMOAa9MUxREYkKCdgplp5Ik3bghUwoQozhstwhE/n1AaGCtldNSXMGB5evrKyuflpp2CwJ/cjoBRd9TzZHnip3aEV56N0/hhIdlpBnzHs5IN9WLNVFz3qnHf/pVSEpEU42+vcm/rH6nwOasFW8xAesJ1GrZXJ4cc+2y9Rfp6MzY7HqVKaONZz4toPMNCab7Viyj1Ng4LRRHlTK4q5KqhhLtJhxYsK8/mU/pIqTOKLbqxx/o6uXLBIdGkybGjwCwpt0gaHvgk8V0cNESij191ppLVD8H99w999xDPXr0ML8++OADq/MdO3as+Tqk8eOPP1p9rbUnHjlyhKZMmWLt6Tadd0M4QF5++WU6deqUTdfp6eTy1arK4l6PjNRTsa0qq1KnUqVKWXW+q5xU676+1GryWCrdqIFLVDn5XLisZ1KiyaHpEpXWQSUVB7O/v79qpcWAUPSJU4QRXT1bQHYUQkqyvuuRXxukJpnqpea9kF/eWt5/6rdVdGjxN5QS5/wHuX379tH48eOpe/fuVLduXSpXrhy1bNmShgwZQu+//z4lGHAQTMv3hquUraa41zDIEXU5nBJijSepc+7YAdmU9eqZxOpdpV0Lqmf6jUTyLy1moRlYp9XwDqyRkydS2eLBcgrh1ws+Lqi9dXMsLiaGPnlntizvc889p5tyq11QTHPqMGMqVe3ZjSq0b612doVO/5dffrHq2iih3bZp0yarzi3sSdOnT6f27dvTqlWrCptEvtdt3ryZmjdvTnPnzpXTePM9UecHGrQwOclP/Pefzmtye/FP/HdY7oSjnO0WgZJ1a1OtAfe6jChwSFBxWfmoq8Zz0t5qVf19irp2TRba2ojewtTwyLIfaNXIMYTVffVsPkLI2N+3mFiVKYtuxEXruSp5lj0+Rv17Ic+MNb6z3kMPUIMRD1FAWedFZxw/fpw6depEXbp0oc8//5x2795NFy9epESxwBSOof/16quvUoMGDWjBggUaJ8rF0xsBRGW2qlVbFnv3mu/1VvwCy3vin53SMVe2bFkO5rAgtWHcFFoxaDhhxWyjmuEdWF7iD3fuok9k+82f/SZt/XOtrtsyNSWFXnxyFF0RP34tWrSgESNG6Lo+9ip8xPZdFCeiBEIb1qP2r0yRmj32Stve6YSHh9P+/fvvmOzKlSul/tAdTyzCCV9//bVqefz55590WUQJGt06tmolq/jnSusck3risXaFqU5du3bVU7FVLevVfw/T6lHP0qnfVquaj5YSb9mnpyzOqWNHtVQsly4LBrKuR16RI+sVKlRQjQVWHgyoUJ4CK6qXh2qFz5VwzTqmh7hLZ47lOqL/zUtnj8tKVKtWTf+VsWMNoFPYZPRjchVNOyZrdVIYsLzrrrvowAFTlAguxFSndu3aUe/evalhw4akrPAbI/6mEQ2PaCw2JmBPAkPuHyiT2/DDp5SanGTPpJ2a1uqlc2X+w4cP1/RznyMhYeXgtIRESk9OMfQgq+EdWLhpevXqRaMffUzqEL0wcjgtFZFYlppEjryxipIXhOhH9b+X/tq2lUqXLk3ffPMNqSneWpSyOvLaa4eO0OYpr9La0ePkct+OzLuweVkThaXGdMHClpevy59Ajz59KFAInJ888p/uHeSWtTx59IjQDlwtxdsHDjR1fiyPu+rnc+s2U9TR4+K7xnWikbr1NDmwdm/aSDyNUBt3/obff5UFgQammv2A+g8/SAN++JIqtDU56rVR+8KVom3TZvLCA9vXFC4BjV4F+YSD20x1QpQPm4nA2T830o6ZbxH6iM6wQ4cO0RNPPEFJSSaHAaY4ffvtt3RCLMC0Zs0aWr58Oe3YsYMwtRDPKYohGgsDmGxMwF4EHp4wjhrUqUM3xBTCZXOm2CtZp6YDZ9zJg7upePHi9PTTTzu1LFrJHL8FPkLMvu+yz6jLnDfIw8dbK0WzezlcwoEFam998D6N7N5LOq4+mPEqPdCpPf323XK6oYM553gwnjVlEg1o14qOHjxACJVcsWKFnD9v9ztCJwmmxifQ6VV/UnpiklgiuQ6VbtyQ6g0drGmRTugdKGLYaL+CDJFL6NjAQkJCCjrV4ceg66WseGTvzJEuvoD1ZH5CW+Wxh4bKIs95+SWKj43VU/HzLGu6EDp+44Xx8tjDDz8sR4zzPNEFd7YYN4ZaTXqeag8a4DK1r1y5MtWrUFH+Xv6w+AuXqbdWK4rvya8+mieLN3jwYNWKCQHscxs2y2l3qmXiwIT79zQ5CXatWk7x0aYpdw7MXrWsDmxbTZEXTss+YYcOHVTLR28JH/vuZzorVoyFjpujLU38ho4aNYrwDmvdujUhKr2PGPCC3IWlYYo+BqShl6rY7NkmmRBlm9+ZQFEI4J5b9MUXMmJ3/6Zf6YePppOeV2TdKb7DVyx6UyLBtFs1p9EXhbsjr026dp1WP/q0WGBoDbl7elLJOrUcmb3D83ITD4tWPS0iYgnztfVuv/36K02aPJkuXbokq4I/6jIi/L6kWNnNzz+QvIW30sPDU4b05vqNUbXqaAU0RVZWJmUIB0FKcjLFx8XSFbECXWL2SmAoQI8OHWnBV19S/N5/6MKWHVSt1z1U8a72Up/CiNtVe3WjSnd1kNN1zq3bRBBPrnR3Rzmqho5Ji3FPU53B91Gm6CR4iOmiWjM4e5Qv1qpVq1IrMd3su+++k8XcuHGjnAaaV5nnz59PL774ojz0+OOP02effSY/v/XWWzRmzBjzJRD/RB61a9emN980fZmbD2Z/eO+996QzDPc60gkODiak89dff9GGDRukU9dLRBB17txZXjFp0iRq06aNORmshLhw4UKC2DtGDrENQxQgprFClBSdM8V27txJc+bMkedD5wEGLawSJUrIdJG+pf3zzz/0ySefEEYrjx07RpivDy0IXINzFX6W12jtc2pqqtS4OHr0KLUUf6NzlnxF/gGmpYu1VtY7lQf304yxz9Hqn3+kSpUq0ZYtW3TRBneqV1GPX977N13Z94+cjpL7AaSoaed3/ZkzZyjOCvHh8uXLq+5kXPLWu/T8GzMpUIx2LhWRDWGVq+RXbN6vMoHPP5hDC4QkAv4+//77b/mdae8sE69eo5WDRlCWWPG452cfUql6deydhVPS69aqDf117Ag1v7svPTrtI6eUwZ6ZJiXE0Vtj7pU6MG+88QaxLuotuslR0XT02x/Fd/Yo8UDnceuAAz799ttvNGzYMJlTMaG/hv4N+kwFGZ5L0PfBKuMwDHQqEXUQeMeiOOirYVEV/C6sX7+eINqPvpuyUqxl+tevX5d9KiyigygVpF29enXzlEXLcy0/oz+D8p49e1bmCQdbHRG9c6cVsAt7HfKGU/706dNSE+zq1atUs2ZNql+/fp59D3BQBO8xwJtX3ZX6gAH6NIhSzYs/jkGHDPWFYUon+tPgnJcpeXsKBwF4xIvpWuhHo9+KtkJba9mWzv2Qnn9lGmWK583qDVvR/aOnUeU6jbVc5Bxli46MoD+WvEd7/vxJ7p82bRpNFs/0bEThm7fR1qkzqXi1KtTr84/IUwj3683wfaZMqb5T2T3vdILRjvft14+6iVGOhTNfpx9++omOXYuUTiI4irRqiNxpXbka1bsWR32HjpA/XuFnztGFrTvkMu4od6xRt0V0FSz+wkX58FimmemLFlpXydejCPocMC06r2TBcv13//33mx1Y6JzAAZSX/STuTRiOV6lSRX7O67/Vq1dLx+e1bDHfvM6B3ta6devkIYSyw4G1d+9e8z4cwI+4cs7QoaZoIuz/6KOPaObMmZQitNdyGzoZEB9FGV566SXzjwgcXEpayjWK5pdlpwAdFjjXZs2aZe6w4XyUZc+ePfKFaZRwnnXr1k1JSpPvWOEFI6id27alvdu30Yhe3WnmvI+pfvaUFU0WOo9CnT99imaOH0sH/tojO2LLli3LswOZx6WG3pUp7skdM2aL5dhjKDCsvFiS3RTJYehK56rcyCkTaeWOrbRh82aa+MjDtODHFRQiHqTYHEtg/W8raeFbs2QUB1a0xYOTGoYVjFpOfI6ij500jPMKnOZ//RVh2uX+Tb9RmYrVqfcjpkhTNRiqnWZaSjJ98drT0nnVtGlTeuqpp9TOUhfpn9+4RfYJwzq0pWbPPumUMisDlcgcg5B5OU9yFwwDEZgKhYE/aGTBkaLY//73P/rqq69kRP6nn34qnWNwGMHw0IcFeZT2x/V4sFf6kUoaeIcjC4Od0AzKyz788EM5ABkdfftCB3BiLVq0KE+x7MJehzL8KgIL0Ic8f/78bUXCIkMY0MUAsGIY8JwxY4bcHDdunOyjKscs32NFNDzKjCg4OJvgIFMM/c93332X3nnnHXOUnHIM/TnwgzM498M0+sPok+Ic8H3ggQcoWQQcwOC8mjp1KmH1cK3acDE4GSp+t595aSqdPvQXvfNMP6rZpC01aN2FylSqTgHFS5JPMT/y9PImd+H0c3MzTdRy1KAdAjlu3sySA+uZ6WmUlppCifFC7/HSeTpxYBcd3L5WRI5lSAcj7uNHHhxCiZFXySe4uHTYpMTGUab4uzDqNqKsMAMJi1J4+fvR4a++pXN/bqJ75r9LlTp3pOZjx1D13t116byy9W/G5SKwcgPCFxseuC8cO05RERfJMyhQvhBynJjtIPErVVLqnSSJ0Rw4TNTaxsNRUPlyFFSuLGVExZC7+FKs2bQJVW3ciGJPn6V4Ub5g4VkNqhjmOttVRX0rhVF8uIhEE19SqLt/2YJHsXK3sTO34YxRIojwAwzHEUbAMHpWsWJF+i+PlevOnTtHjRo1ksVGGDlG4/BjCssdgYXOCL7wmzRpQlu3bpXn5P4Po4AYDYQhwgmdJGgv4PPHH39M6AShA6R0fhDVhR99jEphiWfFoNFw9913y2mQEcLhC+cGygrDQxTqAnFSRGp9//33clTq4MGD8jimuYSFhRE0IJQpL3j4euWVV+Rx/HfffffJFRER6YlQe2UKJUa6sGpPrVq1zOdq9cPRvfvpwcEP0Lmo67KI7bp0pX5DhlID4cgKFY5o1EVLhk5clHBEHjv0r4y4WrdyhbyfMMKL9rWMxNNSuR1RFkSgnF2zQXz/VJAdg/At2+n64aPU9OnHb5sColZ5tBSBhTpiZdSuYpT5jBiZLyO+R95Y8Ck1aX0rWlMtDpwuiY58Ki2e9wF9OudtiQM6OS+88ILd0UTs2CM6xBuo3cuT5TQEu2eggQS/FY6Ap559VpakRdcBNPi5meQXWFwDJbO+CFfOn6TFrz9HF88clYOa27ZtIzXF/K0vmXPPTIi4RCsfHCm/o3uKKISStWs6vEDok6EvpAz8wZllqXFVmAI988wztHTpUnkpoo4g+G5p6NNBFB5i8T2FZqGiu2V5juVnnJtbRxfOqYkTJ1qeJiOX0E9QDH0Y6Hj16NFD2SWdWoW5DglMmDDBPMPAnGCuD35+fjKPfiIAAQZHFyKlYLjn0efMy8GyePFiszPpWfH3rsxSADs4njALoSDDypFwUsFZpRhmBcCBBoNTLPfgMfLUg2YofsvxfLHks88pVTiE9GLuYiZJo8Bgeu3tt+muoQ/S5smvEBbxuuutGVSxYzvjbs8W9evUjjZNmkYXxW/03ULfCrqUmyaK7Z17zLOR9NKO+ZWTI7DyI5PHfjx4w6GAl5YtuHpVwksxV9uGEwsvvRvut759+xJW/4PjFA4tSycR6vfzzz/LauIHGRFbcAbZ2+CkgqEciKSCw2K6GMGzNIwyKZZXmC4entApQycAjuDff/9daj7ASYW0sE9xYD355JNy+qSS3pUrV+ht8QMEwwgXOniWHSKMqqGzAYcdHHiYTqlwUdLQ4nvdls1p1+FDhKkc6OTs3LhBvpSy+oqOGDpDnp5eYnTLPc9Ol3KuGu9ymnJmlgjXz6DUlFRKTso5LdyN3KhL7Xq06I9fyf16DP3c/yEqKaYO3TXrVbp+5Dht/d90423XrU13zZ4uhX43TXxJRLXWk+KXsafO0IGFn4tBg6rSgYWpzHi5ssEZv/L7H+iB3n3omJju8nj/PtTmrrtp8GOPU9M2beX0QlfmY++64+/1wtkztGXNalq2aCFdu3JZZoGVyuzpvEoWg2eYYuUt9Pz+mf8pxZ09TyWEfka9hwbZu0qaSO8hsXpz6pWrNFlEsu3bsIIO71pPHfsNp+Zd+lG5KrWkjIQmCpqrEKnJiXTu6D8E/Ze/N/8uBxswMISHbFd2Xt24HCmnz4S1byP7ibXu70cB5co4xXmFJoNzQHFeYRsDgvY0OGAgyQA9LWWaYPfu3eV0v0cffdTsvMIUPEQYNWvWTDq8ENGOCCIMrCJ6Hn08OMZgcFIpUU3okyHKS3EYYTARzi1cg/4YIqKU/lphr0OeWMxIkcfANiKXRo4cKQd3Dx8+TC+//DLBMQtnHKKhEI2F3yBoMmJlR8gbINps+/btMqoSaVgaHG2KQctTMfTPFOcVZrigL4rpf/i+RX4oB/rFGBRGZFlu55ySDpxXcCaiHdAm6O/isx4MHHFvvDjhBVr+8QI6ej2SLkZG0oUjRykx4Qa5BwWQm6cnJYsotszUNPIWwR2Y6ZImon8g2aLatpgqezMtnYphamiAP90U+XmJ7dotW1DHHt2p3JkISjt6kmqJaa0wn+Ag8hPRwsp0OaNuK2LsCKLBFEE38TcKqztkINUVv9NlmpqCHuROF/lPW+EALgLdEdXEnGxE+XTt2lWGDDsiT87DOgJwSsFxBMM0wtwOLGX1QUxzgGC/swyaABj5gtPt+eefv60YmA6I6YZKRyD3iOBtF1jsmDdvnuxsYRc6C0pnSDkFzjuElEMnDE4+aD1gZBGRZlo3jCDA+fb0o4/RorfeoR3/HqTwmCjZIUoRHTG8tGRBPr5Uv1lTatewMQVv3k11RGcX0x2uXr5KCFf2Fw+3sCzR6TXitp9FRGea6LghEhaGB/jq9/YQGoMdZcc2rxFeeaKL/Ve5di3advhfmikeLhZ9+SXt3rJJvoAhQDhAAsUUZR/fYjLEX66OJ/6Wmd2dbxI8PN0UWqOZ4gERzv8kEYkaKyI5FT0cpABdmBeGDKPgo6fpiND2gYMJK60dXf4TVbnnbqu2z6xZL3WBoJ+Jzu/hr5ZLR23jJ0dSw5HDqOmYUVKSoM4D99250Do+Y+TkidS2f1/5+wPdxnXLF8gXHgwCipcgX7+A7Gk00ETFVBrHVVbcCsKEJqpwKmCwIV1Mo0m6EU/JN+LMhUBx+rXvSB8u+5ri9h2gVe98RFW6dRaL2YgIYKEXivvDqNtnVq+jw18uo+p9elD94UOEaPFqOrT4G0L0VWuxwEarF0zRdWZYDv6ARXgUgz4THC72NExVQ58I2lSWBmeLMk0OfaW1a9eaNZnQl0NfC5FLAwaYFiCBIwfRQuhnor+n6Er1799fRigpacO5gymqmBmA54rNmzfLyCNEIBX2OugqQz9VMUTkP/bYY8qmdLphaiFmEMBxhv4lHFpwnsHgkIIDC4boM/SXLQ36XYjch6HsGFiFIVpLcZphBgP6mJbOXzig4PBD9DnyxDRDlAGOrtyGPjAkNJS0cx/Xw3ZJMePnmddn6KGoeZax7dScEYNG3241MeezWNkWTfPk4go72YFl0FZGxAymdKFjhi9pNu0Q6Ny5sxw9g8YARqDQiVAMIukYeYIhxNmZhg4SDJ2avEQyITiqTCHEeRjVs9YUwUycr0SD5XUtRgDhwIJBIF0PDiylHmE1a9DMz0yh5tiHDlucmIYMB5a7rw+lCV0xzNf3EKNcmK8PnaXUuHhVtzF65uXtRf4i4s5TPJF5pAstAeGg9C0RIkfVlPKgvCXr1qL7ViyT5XGV7QfW/ESe2SKsxQST3J0hcGATo56C0RuiYz9eREZ+OH2mfMA4FxcjVynUw8q+emrDkuL3uyp50oA+99Kz8+fS8R9+of2/rKbSjRrIaqSIh6zoYyes2K6ffX4sxZw8TYnZI7a+IcEi8ipAfvfgBOgG4eUKBo2hNWvW0Jpvv6cvRTTKPxHhdOnaVUqIuS5fWmPgKTRp6omomlaVq1Ll4+epXffeMgLkinC64x6ANigMEXWG3G5QV9Yv7UailJVA5BWsdJNGVLnbRXHfamM6M5w8imEwKLeOknKssO8jRARhbucV0rKUkUA0VV6C4nBGIXIejhcIkmOwGw4aZYVspAPNUjh6LB0ziDT6448/5GBOlSpVzM8Vhb0O6Ss6W4hQQ+RVbsMACPrHcMQh0mvlypVmBxb6hohChYg69kNP1XKqn6UGGeqnGPajLwbD9ZbOK+UcOKtGjx4t9VkR/YX88yof+q6WjJTr+Z0JMAH1CbADS33GnAMTyEEAGgL48V2yZAlBS8pyGqESfaWck+NCJ23AeYWRLjidsJoNXidPniTLUUYUDREE1poySojzEcWVXwcPYdyKWV6j7NPTO+oYEloqZ5HtOzCbM20btxAeDuFmxVxtG8sO+wQFKdXndysIYOrxjI/m0QyaJ8/GA8l14diOFQ+WbmJFXy8x7SBZOGlTxH5vwRZOQQiQ8vbtPHyEo8pf6G2mi4fzLDFoECKiIsJqC92/ZBF9I/Qf4WTGd0iVe7pIZxW2YbZuV+vRlco2byLTw/WIMqzRtyc+uqz1fGgw4QVD9BsW9YkW0TyZYpq3l3DuJcXEUrKYFubIezhN5OkrBjaChFgvienenuJVrmoVKd4LB5VyT6DMiL4r3ai+uU0Nuy2cKLCq3btQuZbNCM5XGD7jpRVTdE9RHkxxwz2FSHZ7maW4u5Im8ti3b5/cxPRC6JXmZ4MGDZIOLBxHXw4GhxhWNQ0PD5evtmJBGqyafY9Y9AozOZQILHmyxX+FvQ6D64phVkJ+fUDIuyAiCv1kDKZGimlu0BeDcw7RY9CcghMLjmhEjimmOLDA3XIwGP1XxRBBtWvXLmUzx7tlefLre+bVDjkS4Q2nE8AgO8T84XTFAlZsxiHADizjtCXXREcE8IMNBxYMUVjKNEJl1Rh0GjDi5WyDDsKcOXMI0Vb2MnS04LhTLLLzVgAAAEAASURBVL/OgXJcec9rhRrlGL8zASbgfAJ4cMJLrNfu/MIYpQTiQQ2OP8XwuSjbcHwpzi+kydM7FbKmdzzwVqpWTb5yHtHOVlHvAb1f71M8iPDSqlmuOIjIITiJoEdlL8tLsxf9I2VVQjiiCjLLKY2I+lcMmlgYUMQDPwYkldWgX3/9dak9hel10Nhq3ry5col8L8x1WCRIMWvKq0Tio7xwYMEwjRAOLBimESoOLMhaKP1KlNmyL63sxzVY2dEas3R6WZ6fVztYHufPzieAaaeI0MMKnsrUWeeXiktgDwLswLIHRU6DCdhIAPP1lRVMoIOFMGlEOCmjYbauYlJQ9BMcRoWxuXPnSs0By2sxioGQ6QbiARUimnBEKasXWp5X0GdElyHUW+lsQaDdGrNnB9Ca/Picggn8/fffUrsMI7NYNZKNCTABJsAEmICrE4ATH9EecATBIH9gbf8Fq0NjIBOC5a1bt85zGqClg0xhjWgixfKSfFCO4T3IItIYqz4r1qFDB6mthcVzsHK1pRA9hOnhBIB+62uvvSZF1YtynWV585rqqKSN90ChragYpj0qhoFfREHBGYY+CDSr4KyCM0sxS/F27EMEl60Gofy8LK92yOs83scEmID9CbADy/5MOUUmcEcCmNuP0SKIScIJhNBvrOIHw4+5tSuZYPQczquC9KdsEVdXCg4NByzTrtjTTz9NWD7YMjQex5SVBPFZ0RXA54IModlVq1YldNRg0BqQURsFXcTHNEcA9x2ckIV1kGquQlwgJpAHgeTkZBkhi4dCZYpOHqfxLiagWQKYTgWnw+DBg+mVV17RbDmNUjD0y7AqoLKCNAYnMW3PGkM00xdffCFP7dmzpzmNO12rRCXhPDibCjLLCHhMA7e0WrVq0eeff0743sPqg9BCXbdunXlwFf08LLCDaX1wsilm63WWCxTdqbyYhqlY7vLCQYUoG/SBMRiMbWXFamhZYfqjpWHVTiU/1M+avqeltpZlWvyZCTAB5xEwrcPovPw5ZybgsgQso6wQ4oqphDAIbGIlO2tM0VVQfpBzXwPngqVgeu7jynbuCC7oEygOKXRSZs+efZvzCtdiZFExy9WylH3Ke+70LQVIoV2Qn8HBh/wfeugh2TnJ7zzezwSYABNQgwC+u6ALc+HCBTWS5zSZgOoEELWCe1gRzVY9Q86AevfubaaAaW7WsMfAodIPxMWYzmetYeBTESRHW8MBlZ9ZThu0jCKCrimE4HG/IL1u3brJvh9E3TGFD2LrisGppVhhrrPsA1pOJ1TSVN7x/avMTMA+y/JiG31Dudqt+Ix+NFYVVFjjmKWWFc63zBeRVWCW1wuLX0GDFZFiuQdukQ4bE2ACziXADizn8ufcXZgARDKVUah58+aZV/SzFJy8Ex7lhxVh0VghJrdNmDChwI6M4gDLHaVlua0srZw7bUSMYcRLsdwOLMsQccv0cP69996rXCZHhHMfx0F0iqC9AAcc6mapY2C+mD8wASbABJgAE2ACTEBDBNDHUZwlmEo4duzYAiPlMWD4+OOPy2lwqAYcNdZG4ivVVkTFERm9aNEiZXeOd0QqLViwwLwPchawyZMny+l4KPfHH39sPq58QNqWcg9nz56Vhwp7HSK2FPvmm2/MUVHKPuUdUxmVvKDdZanfhXPAqUePHvJ0ON8UbVnssFx9UJ4g/rN0wuVVT+U8DNpCJgNtiLZjYwJMQFsE2IGlrfbg0rgQAYwM3XfffTlqjFEfCLhba8oPN84fN24cLVu2TK56s3nzZhozZozULCgoLWUJZDipEIaNVRARadCwYUPzZf/++y9BD+vatWtyH8RC0Tl65JFH5NLGyom5nVCWugUffPCBDIXftm2bPB0jY1jhBoZRLnSioGGAUUPkA60FdKSUkTSUB50JNibABJgAE2ACTIAJaJkABgehJaUYooMgG/Hff/8pu8zvZ86ckdFWa9euNe+bNm2ajP4x77DiAwYsFcPiOxBhtzQMMk6dOpWUBXEwHU+ZYmfZv/roo4/MjjTL6y2nUBf1OjiwlIFMRHw999xzZKnHhXwRKQYOij344IPKxxzvis4V6qcM5EI/rGbNmjnOw8Zjjz1G6GfD0OfMy4mFfuonn3wiz8F/6OuyMQEmoC0CrIGlrfbg0rgYAaxGaDka1q9fP5uWW37yySelqCamCiIKC3pSlgYnWaNGjejAgQOWu82f4RhStKjgpIKhw4BRNegvKNP74NyCdgb0AiynKyJtOLhg//zzj3xX/oPQu2KYkogXOi3oBEEjAvmh/oi0Qsg7NCIUTS/lOrwjSg2OOTYmwASYABNgAkyACeiBAAYjp0yZYnZkbd++nRB536JFC6pbt66c3oYV7rBqnqWOKSJ+Ro4caXMVO3XqJAdFMQ0RUV+Qoxg+fLhcNRCDgb/++qtZxw8R7XCqKfpOmC5YRSzSc+7cOcJURizW06VLFzmgin4ZHENKfxBT9pA2rLDX4dpZs2ZJjS2IxSOiH+WHTht0quDoQzSVItqOFeTyWzUQA7lwxlmKrStOLeRjaVg8CRpe6OPCkCYch+jvIgoOdYQ2FlaPhKFPnnvVRXmA/2MCTMCpBNiB5VT8nLmrE0AUEn6sFVFNa4U+FW7oZGzYsEGOEGEUz9KwCs78+fOlgyg/BxbCpA8ePChHupRrFT0CONbwI//DDz/IQ9AiUJxXWMVm+vTpcjQLnRysSHf48GGZjhIajg4BHGyWoexYwhijZFiJEKvyYIQQYemKg8pSKwudJji44DjLHTaulJXfmQATYAJMgAkwASagRQJwlkBgHe+KLhUG8SyjmZRyQ3fq+eefl1FSyj5b3xHtjoFLrGSIvhb0t/CyNEQgwXllGWkPRxZE5+GQio+Pl9FQmL6Hl6XBUQTHEhxBsMJeh2vRr8MCA1gkCELt0LrCity5DZFaELZXtK5yH4dcxZAhQwiRYzBwRN8xP3viiSekkw4RcmCEGQt45TZEpUGHlY0JMAHtEWAHlvbahEtkIAL4YYVjB6M5eS1tDCcNfjiV0Om8HDUIee7bt6+kklvAEjsbN24sHUgYyYPYJjpJCJ+GcwvpI210SvC5fPnyOeiiEwJxTji40IGA06t69eryHOhrYTUahJwfOXJERkkhfzieEJqtaFxh2qGikwVnnKW9++67hLB2pA+nVcWKFXN0QpAfVt3BaoYQhMcLI5HggPLnTs8ybf7MBJgAE2ACTIAJMAEtE4C2FQYnly5dKnVDIdOAiHkM2Cl9LvTZxo8fL51dedUF/SFEKMEwgJifIbIKDitELH377bcykglTBuHUglg5nEEYWFT6eZbpQB8KkfRwgmFgFA4l9MeQH5xdTZo0kVP9cvcjC3sd8r777rtp9+7dhL4i3tHXRH8SCxkhih+RVBCzR/+xIBsxYoQcjMU57dq1I0sJi9zXwRGGyDhojGEmAKK9MF0RMxngoIPeFyQ40O9Gv9nScExpB9ZltSTDn5mAYwm4iS/Qm9ZkidBK5SHbmvP5HOcSQJgyvpQxbctyKpdzS8W5MwEmYBQCcJai84nltPMavTRKPZ1ZD0RVYjrHnQwPFJbLqN/pfD5uPYGkpCQ5jRmj+njoZGMCeiOAgSg4RzAYBucEm/MJwDGEZyo4sNQ2fIdBk+tOTqDc5UB0EqbwIWIrtyMn97mW24W9TkkDDqyCHFDKefZ8R5nhwPLz87NnspyWkwlgCi2iDaGrC6cum7YJwHENZ7s1VrBL25oU+BwmwASYABNgAkyACTABJsAEmAATuCMBRLA7wnmFghTWKQOHV2HKWNjrFGiOdl4hX5TZVgefUl5+ZwJMwPEErHNzOb5cnCMTYAJMgAkwASbABJgAE2ACTIAJMAEmwASYABOQBNiBxTcCE2ACTIAJMAEmwASYABNgAkyACTABJsAEmICmCbADS9PNw4VjAkyACTABJsAEmAATYAJMgAkwASbABJgAE2AHFt8DTIAJMAEmwASYABNgAkyACTABJsAEmAATYAKaJsAOLE03j/WFw5K377zzjlx+Nq+rVq1aRa+//npeh3gfE2ACTIAJMAEmwASYABNgAkyACTABJsAENE2AHViabh7rC4fl7L/77jtq0KCBdGRlZmbKi7dv306dOnWiIUOGUK9evaxPkM9kAkyACTABJsAEmAATYAJMgAkwASbABJiARgiwA0sjDVHUYri7u9OLL75IMTEx9Nprr9HJkydlkpMnT6YDBw5Q9+7dqXnz5kXNhq9nAkyACTABJsAEmAATYAJMgAkwASagGQLHjx+nTz/9lFJTU/Ms08WLF3MEeeR5Eu/UBQF2YOmimawr5P3330+1atWSJysRWMqV//vf/5SP/M4EmAATKBSBP/74I9+OARI8ffo0HTx4sFBp80VMgAkwASbABJgAE2ACTKAwBGrXrk3ff/89NW7cWDqylGfh6OhomjBhAjVq1IgCAgLIw8OjMMnzNRoiwA4sDTVGUYuiRGHlToejr3IT4W0mwAQKQyAiIsLcMUhLSzMnAcfV6NGjqWvXrlS5cmXzfv7ABPRIYM+ePWR5f+euQ1JSEu3bty/3bt62kcC1a9foxIkThHc2+xFISUmhv/76q8AET506RZcvXy7wHD7IBJgAE9AbgalTp9KlS5fohRdeoPXr18vi4/Nnn31GJUuWpEcffVRvVeLy5kGAHVh5QNHzLssoLKUeHH2lkOB3JsAEikJg5MiRdPPmTdkxGDZsmEzq3LlzcnrysmXL6Mknn6Tg4OCiZMHXMgGnE4iKipKO2s8//zyHIwuOqw8//JAaNmxIWVlZTi+n3gvw8ssvU4sWLejVV1/Ve1U0VX5fX195nw4YMIDgjLU0OK7wPY3v7zJlylge4s9MgAkwAd0TgCZ069atZT3gzIcpkVjjx48nfD+y6Z8AO7D034Y5aoAorClTppj3cfSVGQV/MDiB9PR0g9fQ+dXz8fGRYdgoyfXr12WBEJqNh/mgoCB6+umnnV9ILgETKCKB3r17U2hoKKGz26ZNG5kavl/guHrppZfkNIRWrVoVMRe+nAmoRwADlxs3bqR77rmHFi5cKDPasmWLdBguX75cDkKgv8jGBJiA/Qlwf9T+TG1JEVFYua1s2bIcfZUbio63+ddLx42XX9EHDhxo1sLi6Kv8KPF+oxGYNGmSdK5ApJFNPQKIwipXrtxtGcB5xdFXt2HhHTolgEVRYJiKAMvIyDBPdePfVYmE/9MwgXr16lH//v1lCSFsDMNUbww21KxZkwYNGiT38X9MgAnYnwAiHGfOnEkY4GNzPAHLKCwld46+UkgY450dWMZoxxy1UKKwOPoqBxbeMDgBaNZgjjtEGiHWyI4sdRrcMgpLyYGjrxQS/G4UAojCatKkyW3Vgc4bR1/dhsWqHeHh4bR7927z6+rVq/K6yMhI8z4cx3lsRSeQn6MVUfocfVV0vpwCE8iPQEJCAr377rvUoEEDdmTlB0nl/ZZRWBx9pTJsJyTPDiwnQHdElojCmj17tiOy4jyYgKYIIHSbHVnqNknuKCyOvlKXN6fuHAJKFJZl7vk5BSzP4c95E5g/fz5hYE15KQK769atM+/DsY8//jjvBHivTQQso7CUCzn6SiHB70xAfQI3btxgR5b6mPPMwTIKi6Ov8kSk652eui49Fz5fAhhdq1GjRr7H+YDtBHbu3GmeTmL71XyF2gQgJm5piiPryy+/pEceeURqflSoUMHyFP5cSAJKFBambXL0VSEh8mWaJ6BEYR04cECWlaOvitZkbm5uViXA0UFWYbLqJDhcV65caT6Xo6/MKOz2gfuGdkNpmIQUjVClQoojC3p0WLH52WefpRIlSiiH+V0lAojCeuqpp1j7SiW+zkzWTawoddOaAmDefGJiojWn8jlMwJAEBg8eTGvWrDFk3VyhUl5eXoRVr8aNG+cK1VW9jqmpqXK6JpyDlqHaqmfsQhmcOXOG4uLi7ljj8uXL84pid6RUuBNWrVpFQ4YMkRcjYoinDxaOo3KVZZdzzJgxhNVLH3744RxRV9Y6upQ0+b1gAsOHD5dOLERf7d27l6cPFozL5qP4fsD3BBsTsJZAQEAAffDBB4TnCjZ1CezYsYPat2+vbiacul0I+Pv7W/375LIRWJifjLD1jStW0qlD/1Gatye5BfjTjetRlBgVTZ7+fuQlXomR18jdy5P8y5SmLDE1ibdNPALKlpE8kgUfT7EyWalqVchbRH1lhF+kikLgefir06hRpSq0/eXXKahSGN315qsUHx5BW6bOsGl769SZFFipgrw+8eo1+uudeRRUsQI1f360Xf5YbEmkXbt2hD8uNm0S2LdvH50/fz7PwlWqVIkQLTR06NA8j/NO2wkgCmv69OnUq1cv2y/mK5iATggoUVglS5Zk55Ud2iw/51R+++2QpcsnoURhcfSVOrcC+obFihVTJ3FOVZcEsOJn7igspSKY2ou/yX79+im7+F1FAuy8UhGuE5N2OQfW+WPHaOqYZ2ndoQOUIkSf87X42JyHoqN425JALh6nr0Waj+66GE7f9+1LZUJLUzt3HxqQ1UYeyxS8486cI6Wjas127JmzRO6maQcpMbF0ccduSq5dU6aXEh1D26fPogYjh1HZZo3N+av1gSN31CJrn3Shw5TbgWXpuEIEFpt9CTz00EP2TZBTYwIaJICHDTiw2JiAHgnggXny5Mm88qBKjff888+rlDInq1cCGNjL7cCydFwpz0F6rR+Xmwk4m4BLObCgAzD6yScpMTlZcm/RvgO16tiJKlatRsElQsi3mIi68vYmDw8PchPRRDA38Y/tdgI3Scw8FbNPMbU0KzOTsAJcohArjLl+jU6LJZu3rFlN506dpF/EpSdO+VMzERkTVjGM7l26iDx8vGWCQVZs98H52Y6HwArl6a7ZM8zXn1mznq7s+4fSk5Kp56fzzI6x20vLe1yNADuuXK3Fub5MQD0CHGWoDltEcSJyBe9s6hKYNm2auhlw6kyACeRJgB1XeWLhnUygSARcRgNr/qy36MVZb0hYbe/uQs9OnUZ1GjYqEjy+OH8C0LnYtOoPmvf6TLpw9gyFhIRIDYa8liXPP5WCj6TdSKSj3/5AVe65m4pXqUzRJ05RcLWq5O7pUfCFfNSQBBCBtXXrVvNUQa1EXEVFRdGeNWvp4tlz5FEmlDLE38aVf8W05aRECqlVg5LFlOXka1EUGFaBioWWpISIi3luYypuoJi6m3TpCmWKaMSKDRtQrRbNKCQplVIvXKSy4nOJ2jXo8t6/KUb8LfC2dTzgBI8+eVpEcTaR/PA9kiymkgfXqEb+pUOd+rfCGlhOxc+ZMwEmwASYABOwmQAGPWJiYsxTBTniymaEfIELEmANrFyNvmbZcnpp9pty71OTptATEyZytE4uRvbexJd1lz73UqtOd9FLY56k7evXyfD1Xbt2UWiofR4KvYVmWeMnRsqiX/n7IG2aOI1q9u9NLcaOsXd1OD0dEIAg8Ny5c0kLjqskobH38fSZtObA31I0V018XiJitI5fID322GM06rXpFLFtJx3/cSW1GP+MdMjwdsE8LmzdkYPX6T/W0vEfVlCT0aOowYghFHX0uGy+knVrq9mMuk8bgxbHD/5LZ48coUwRUZMpBhKixZTxJOGgDQgrJ6N1EyIuU7GSIYRo2uToaOGsLfq2f6mSFFy5IqXHxVO60EksW7UK1evQngKzbtL1/45JzcRS9etS/IUIl9+OOnKcAoWGZKl6daTjPDHyKkHP0ldEoLORjCI/vGsPXYmIIC8x2JCSkkJX/vlX3rulGtaj2FNnxMBDMoVUryo1Unk7Jw9IRGQJZqF1alOQ+LtMj7hEwd4+1Kx3Tyom7rFLu/dSSmwclW/dgnxDggu1nRqfQOVaNpPXx4iBB6H4S0Fi8EeJ7Of7mAlogcCbb75JGLDXuuMKv9t//fUXrV/5K/0nvvuSbmaRZ6kSlCgGSePCL5CHiJD1L1eGYk6flXUJFt99mH1jr+1SQhIGs54SxN+yn/iuaNS7B9WsUYN8t+6h0KDi1G3e25Qp9Kc3jJ0ighM8XXj7RanH3W3uW/L23jHzLfmd2uiJR6QOtRbueUeXwfBTCJPFdMHnp02lTPEHN+ypMfTkC5Mczdil8wsIDKR3Pl9CT9zXlw7//beMjlmyZIndmXj6+tDNjAwhsn+VssQ7vujYXItAw4YNNVHhzZs20aiHhtI1EWEF8xE/yjUr16KyJctSgH+g2PaVP9ge7mKqsjhuTQcHnQwsF5uZlUkZGemUnJpC8Tfi6NLVi3T6wik6lBBL4+e+Rz/s3U2vPzmG6g59QDqvkH/Z5k3JXUyNRnQWb+fDQ3xfKHyCxYIU5cQDVqn6dSSvf79YKrT39lCrSc9TLfE9xpaTwJpvvqWfNq6ntWJRlNjYXNqROU916FbJ4sWpvocPPTzwARoyZxZd2X+A/np7rhjk6CPatq7LbtcQgzxwYEUIPck9s9+nyt06U8eZL5kiQa9Hm/8OHNpYTswsUTg+P/9gLq3Zs4t27twpnVVOLI4hsy4RHEx9+/enuleiKejiVeqx8APpgPp38dd0/dARm7e7L3xfXr/3vY/o6sHDdPecN6hC21bCQX1UOGjDyCco0JAcuVL6IdC0aVNNFzZJSL7MGjuelovggsiY6ILLeu7MreORl299xic7b2/96KQ5/bqBweQ3ZAC1bt6Crh44JPqx2Tq2YnDK9bb/JQ/Rj4dlCL/GWSGh4+HrS02feYJuCikf6EHX6NtLOvfNAA3+wfBTCBcsWEBYeaV6nTr07YYt8sHR4G2qyepdCg+n+9q1Eg/fGbRnzx6qW7eu3ct543IkBYiRAjYm4CwCny5aRBPFaodwOFUuX4UeH/QU9WjfSzqx1CpTbHwMfb9mOS397Uvp1EKEI5amb926tVpZulS6++ctpPObtlGfJQvIp3iQ7CwoGolqg9DyFMKLFy/SiHv70d7TtzqcJcXCHeUqVqTA4sFCU7IYeQr9Qjhq4am1xlFrK0/8ncGzC8duutBhTBEdu/jYGLoUfp5iRYSXYsOGDaNJw0bQZdEHKNu8CVW/t6d0YJ3+fY3rbIupsqdEfcu1aCrrHy7u6cNLl1PVHl2o7oMDCY7afz/7iuoPH0JNx4xS0Bn6feX3P9DYZ56haDEgAHMX92qp8pUoqERp8vUPEPevT7YmqhhsEFHlbPkTMP0tQhc1kzLFIEuaYJokBlairkTQjdhbiyDdVbseLfhyMYXVqyvvuQQx/b3hYw+LSMkwq7bjz0eIyPsRcsr97lnv0TWxiniX92aRn4iYWzl4JKWKCK+uH8ySTur8S8tHmIDrEjh8+DANHTyYzolIU1hY5SrUtktXqlKjFoWIxUr8xHefl9AqloOsIsJRje8++X0h8oaGMgZlU1NTKVHMXLh2+TIdO3RQzNr5U/6eo3yjR4+msQ8MkRrVpRs3kH0wOK7RD3Od7UOiE+VOZZo0JCyAdl70ZRCsAacVIls3TphKPiKqdcD3X8roYHDTo9kyhdDwDqzGNWrS2auRNGvhp9R9wH16bE/DlPn1F8bTL98spWdEh3HWrFmq1AtOrNO/r6bKXTsLPawqquTBiTKBvAgsnfM+PTPjVXloRL+RNG7ERIc6zOPEw8KU9ybSrgM7KFBEPq4TETEQD2UrOgElqhP6YgcWfk73fPQueTpg2XStOrD27dsnp4RHCycRFj954NFRNPCRR2VHuOi07ZPCqaNHaPmnn9Dv338rB04waLJ8uXDYVK1qnwwMlsqhxd/Q4S+XySkaoY3qG6x2t1fnjTfeoLfeMk3HKB1WjboPfYaadhKDDcX8bz+Z9xSJwJXwU7TllyW0a/V3lJGeRtWrV5d/i7Vr229adlrCDdo8+WVKFe+9F883L/5TpILzxUzAYAQ2//YHDRv9JCUIZ1Hl6jVozIsvUVcxEKWGk6oo6DAA9fXCj+ibhfPl4FSnTp3ohx9+kIt+FCVdI16blgg96J+oRM3qVPGu9pR07TpBYscRfVR782QHVjbRY3//Q60630VBInx53eFj5MnTyux9r9mU3n///E0jenWXDxAHDx606VprT94jpoicXPG7Wb/G2uv4PCZQFAJnT52i1i1bUUpmBo0dPoEeu/+JoiRX6GszxWjWC2+PpU1/baA6Iup0x44dmtAEK3SFNHbh6lHPCE2sEyJiYDg1fnyE6qXTogPr6N591LV3L7ohRkybtmlLsxZ9QaVKazfy9fzpUzTpsRF05vgxCgsLo01iim+ZMtotr+o3VQEZYGEUdHzRAYbGBqYWQqvIaPbamGfpnW++kg9tfUa+IJ1X7tkrTxutrlqqT9SVC/TZ9NF04eRhqYWKv0WsGGxPU+7hc+s3U6TQRm09eaw9k+e0mIBuCZw7eow6dexIsWmp1LlXH5r50QIZbaXlCh3ev48mit/v65FXaMCAAfTVV19pubhOL9uNy1do3bOTpAQGfr/1ZrY4sNz1VjlbyntEdFhh9Zs0ZeeVLeBUOrdOo8ZySsnZs2cpUXiM1bBKnTtQrYH9qESt6mokz2kygTwJvC4iCuG86trmHqc5r1AwiGG+Me4tCitbkY4dO0Zq6M3lCcBFdnaYMZVaTniWGokpL65o6UJM9cFBD0jnVcfuPWiBELvXsvMKbYRR5iWr/qS6jZtQhJgy8dRTT7li01lVZzivYP/M/4wioRn27jyrrtPTSZv/WEVzli2VRR7xvw+o58PPiamDhu4Ka6Z5SorfpfFzf6LqDVvRtWvXaNSoUXK6vT0LiHsYTqzds9+Tg5kR23fZM3lOiwnolsCYp8dI51WLDh3prc+WaN55BdANhP7Vh2K1eV8/P1qxYgX9+OOPuuXviIJjtkCaWOgi7ux5SomOcUSWTsvD0L/aMUlJEmzZCmFOA8wZ3yKAh+vS5crJHVeuXLl1wI6fyrVqTq1eeI7Kt2lpx1Q5KSaQP4HzJ07Szz//LB+CEH3lbPMXU2DGPPisLMbChQudXRxD5R8YVoFqD+ov6xR9/JSh6mZNZT777DM6FxNFYVWq0msffyIHJKy5ztnnQNPj3cVLZTT2xo0b6Y8//nB2kTSdf7PnnqLaDwjx3MnjNF3OwhTulbdmU5bQTuvywBPUsuuAwiTB1xSBgLePLz3+6gKpMwY91O+++64IqeV9KZxYbf43gVq/OJ4qtG+T90m8lwm4EIHt27fTjv37pdNqlpBBwPOYXqxmvfo07pWZsrivvfYaL7RRQMNBS7DHorliGvUCw68ubGgH1qVjx2UzB4rViNi0QSBQLIsKw/xrNQw6CMd/XEmnflujRvKcJhO4jcDX8z4kTN27u1VXKdx+2wlO2NGrYx8KDQmlkydPEgQ72exHIENMnftl4HBaO3qcFNO0X8raTilLrHTz0TxTRM6YKVMpIDBI2wXOVboy5SvQiKefl3s//vjjXEd505JAsRIh1HL8M3LRgsQrVy0P6frzBhF9deDAAfILLE69RxjPOaeXxgkMKUU9hpkGWebPn69KsasIHdSa/XqLRR5uUuLVa6rkwYkyAb0Q+GD6DFnUwaMep5BSpfRSbHM5+w99mBCMghk8W7duNe/nD7cTCK5aWQi8pws96DVyldbbzzDGHkM7sK6fC5et5COWmmTTBgGlLVJSUlQpUGpcHGFp5cNfLVMlfU6UCeQm8Pd//8ld7Zt2yH3IadsYXWvTuJ3Mf/fu3U4rhxEz9vTxkau8eAcGkJEe7u/UVht//IkuiJUHywvNmnv663NBlAceGyWnIkAbLjIy8k5VdvnjW/43g365fxglXLxsCBaL57wn69Gx3whxHwQYok56rUS73kPIPyhYOhRPnz6tSjXizp2nFYOG0/ZX3lQlfU6UCeiBAFZ/3yIWXoENeuQxPRT5tjJ6eXtTv4eGyf0cQX0bntt2HP/pV9r15hw6s3rdbceMssPQDqxioSVlO2EpbzZtEFDaAl+oaph3UKCc4lNNiMWzMQFHEIj3NH2NVi5fxRHZWZ2HUp7wcJMj3+oL+cQ7EuizZCEN/HU5BVVynenpWzZuklzademmW80g/4BAatamndTd2bWLtXHueKOL6BWhdE6xp87c8VQ9nPCPWGwD1rBtVz0U19Bl9PL2oVpN28s6wqGshvmFhspBBujB3BQRpGxMwBUJnDp+nFKzMmUEk54ldRq3ai2bT61FwIx0b5Rr0Ywq3d1R6EHXMFK1ctTFM8eWwTZ8S4fKGrm762eur8Ga4LbqKPOuMeVKDfMJCpIiy2qkzWkygbwIRIkVu2DBQSF5HXbaPqU8MTHGFnJ0FmBMV3b39NDlUsWFYZbg6y0vq1KjVmEu18w1VWrUpJ0b19O5c+c0UyatFqTN1BeoQ7GXyMMgg4DXU5Ml6jIVq2sVuUuVq2wl08PV+fPnVam3l78fDfz9e8KUWDYm4KoErkVHy6qXFavw6tnKhVWUxVdLQ1nPbHKXvUTtGtTpjVdy7zbUtqEjsLCcJEwMILJphoCpMaCnooalJyXT0e9+opO/rlIjeU6TCdxGIObSJbmvmK/fbcecuaOYTzGZfXKy6aHNmWUxWt4HhAjq9z3uo+M//2a0quVbn+ioKHkspKQpsjnfEzV+IKSkSf8jOrtTr/HiOrV4PiKi2SjOq1ShXYfvQg9PLyoWoC/9NqfeBCpmHhBs+i5R82+RnVcqNiAnrQsCV86YImiDigfrorz5FVIpf5yQimErmMBNET19bv1mQ+tBG9qBlXBJcWCxB6vgW91xR9V2JqYnJtL+uf9v70zAqyiyPX6y74GwBULYguDCJsoiu4gKOOJDXICnMirvzQzghuIDFxwQkEUFEcQBwR3UwVEEVJBFkWVAQXYEgbAFQsISEpIQsr46lXQmJOHmLt33Vnf/+/tucru7uuqcX/W9t/v0qX/9g3bN/9h7TqElWxPQcgmDxY2RSktwUHHGTG5urkpmWcKWQDGlc5CY6crP39I/oVf01Ynfdsp1ntHPzEtYRIQ0P7tklmIz+2K07Ud+WEuLbr2LNk183eimDK8/reSBZrBiDxoMd1zhBkLEjLm8GPmQ5cfnX6aF3XrT6W07FCYB00DAOAJnDh+VlYeEFT/UNK4lY2sOLbHfKA1lY633bu1+4mZ7w99fo82T37Ts8GlLDyGMqFvHu2cMWvM5gUDxBXfdgwPkzaXPjYEBtiAQKAIZlHNJ6AKpNVTZvyS4YpTenC069ypOtn78YeKXnZZ8oaHBS1BIcWDUrL4Hl9jPGTlYqiZQmJtHhXl5VRdUvEROSSZqYElgX3FzbWGe1hdGfhYL8wuoqKDQEuewLU4KOKk7gaBqxRmngYHmvuXXNJTzLPB7pHsnV1JhQt875CysRYVF4mFrJQVMvsncZ3MV8CPr1a2iBHZbjUCwCCa0e2aY1dyCPwoTKCzRc9MCRqqYqtnDqcRY9CVQcDmX8kUAhGckDDB5QMdZMtEJjYlOnqAAxQK1ztqvlQsIKL7sMWoYu9aOFf436tWDGt7alfzErKZmX4LEcEhe/AMseCVv0s7xLzmvjNJEZSy3TntV0vE3+c27SbsYZitAILwkmUPTIFbAJLdM8Mb3hVuGKXpQ55efV9Qyfcyy9C+5naY41+d0MH8t0MAyfx+azYPLQsxbxcWPiodOI4Clf+/s/fRzWtxnAO355HP9K1e0xkKRxcCL2YdNaoFdBLCqPtH4hiFATF+u3ThUfYS6JbT+9rPio2h1sTu0jIe58KL1jcPCbu5kDTd+aW25WQ0OAwHTEsgqmWjI7ILQ2mcY17TOnYosAXD4ux+Is1CtuFg6gKWJuFux4+BT5QSggVU5F2w1joD2owqlPeMYq1ZzgMi8Co6KFBlY5h5O5wrXtEOHZXHtfHflWBXL4iK46l45/tN6WtS9L61/ZVLVhRUvkZVaPFusVc5fxXE7ZZ7WF0Z+FteNGSc0sPpQ0sYtTtmEQiBgNQIXk4onGtI+b2b1z+z2e5v75snT6d9Cv7Iwz5o6uJYeQggNLG9/XHzfHjSwfN8HdrOAAxmEGc1s1e0tHh5I/LLVYvQMHF6CiYtg50GzdkZhfr7QEDL/E1z0u/P9bqWSPMRfnr9Fxsx8bSVW8MWaBMJq1bCmY/DKIYEmvXtRgZjEyc+iw6ctHcCCBpbDc9uSO6GBZcluVdqpokJcGCvdQQYYZ0cNrJhrEohSkg2giSpVJcD6V4PXfSdGnpg/WT+8dk1VMcMuAwn0mDyOikTwChpYBkJG1UoTiKofp7R9MM4YAreMGWlMxYrUav6rEgcgoYHlAI5Fd0EDy6Idq7BbuZlZClsH04wgYEcNLMJcAEacSkrXyXpnrB/kH2h+EXelQcM4wwjwuQsNLMPwomITELh07rwJrISJehNgDazE71dBA0tvsN6oDxpY3qCsVhvQwFKrP+xgDYam2KGXr/TRzhpYV5LAmpUJWFEDy8r9Bd8qElj3wnip4wYNrIpssMUeBDJLNLDs4S281AhsnjKDNk2YBg0sDYiZ/kMDy0y9pY+t0MDShyNqcZ4ANLCcZ2WVktDAskpPwg9HBKCB5YgO9pmBAGu48YuggWWG7oKNBhAIhQaWAVTVr7LJnbdBA0v9bqrcQmhgVc7FyluhgWXl3lXTN2hgqdkvRloFDSwj6aJuVQhAA0uVnoAd7hKABpa75HCcVQhAA8sqPemaH9DAco2XUqWhgaVUd3jFGGhgeQUzGilDABpYZWDY5C00sGzS0TZ3ExpYNj8BLOA+NLAs0IlwwSMC0MDyCJ9pD4YGlmm7jggaWCbuPDdNhwaWm+BwmNsEoIHlNjrTHggNLNN2HQx3gQA0sFyAhaJKEoAGlpLdAqO8SAAaWF6ErVBT0MBSqDNcNQUaWK4SM395aGCZvw/N5gE0sMzWY57bCw0szxmiBvUJQANL/T6ChY4JQAPLMR/stT4BaGBZv48r8xAaWJVRMck2aGCZpKN0NBMaWDrCRFVOEYAGllOYLFUIGliW6k44cxUC0MC6ChhsNg0BaGCZpqtgqEEEoIFlEFjFq4UGluId5Mg8aGA5omPNfdDAsma/quwVNLBU7h1jbIMGljFcUataBKCBpVZ/wBrXCUADy3VmOMJaBKCBZa3+dNYbaGA5S0rBctDAUrBTDDYJGlgGA0b1FQhAA6sCEstvgAaW5bsYDgoC0MDCaWB2AtDAMnsPwn5PCUADy1OC5jweGljm7DdpNTSwTNx5bpoODSw3weEwtwlAA8ttdKY9EBpYpu06GO4CAWhguQALRZUkAA0sJbsFRnmRADSwvAhboaaggaVQZ7hqCjSwXCVm/vLQwDJ/H5rNA2hgma3HPLcXGlieM0QN6hOABpb6fQQLHROABpZjPthrfQLQwLJ+H1fmITSwKqNikm1ZKanS0qKiIpNYDDM9JVCsgfUVHVr2vadV4XgQcIoANLCcwmSpQtDAslR3wpmrEIAG1lXAYLNpCEADyzRdBUMNIgANLIPAKl4tNLAU7yBH5mUln3a0G/t8QECLJRqlG5SbmUnbZr5LO9/7yAfeoUk7EjDqXLYjS7P4DA0ss/QU7PSEADSwPKGHY1UgAA0sFXoBNviSADSwfEnfd21DA8t37D1uOapuXVlHYWGhx3WhAn0IFBUV94W/v78+FZarJSgsjK57cAAFRUaU24NVEDCGADSwjOGqcq3QwFK5d2CbXgSggaUXSdTjKwLQwPIVebSrCgFoYKnSE961AxpY3uWta2vVGzWQ9RUUFOhaLypzn0BBfr48ODAw0P1KHBzJwYR2zwxzUAK7QEBfApoGFgYq68tV5dqggaVy78A2vQhAA0svkqjHVwSggeUr8mhXFQLQwFKlJ7xrBzSwvMtb19by0zNkfXmXL+taLypzn0BubnFfBAUFuV+JgyNzLqTTvkWL6eiqHx2Uwi4Q0I9AXmaWfpXpWFMRIaSmI84rqrKlBtYVBLBiBwJW0sCCFqodztiKPkIDqyITbLEXAWhg2au/NW+hgaWRMOH/IhHM4CUrK9OE1lvT5Oys4pv9iAhjhvhlnkqm32bPo32ffWlNgPBKOQJ8k8eLakOVtRs2o4brKtcRXjQoIDiYONszMCTYi636tqm0g4d9a4BOrWufC2jXVQ3UShpY2WfOVe0wSniVgPZZNLLRdWPG0aLufSlp4xYjm0HdIKAsgayTydI2b3zejIRgdvuNZFNZ3ZsnT6dNE6ZRYX5eZbtNv82YcVyKYKnfrJm05PzZs4pYBDPOnzkjIdSsWdMQGKExMXTDwwMppFq0IfWjUhAoTyCsejW6mJoqAlhqDVXWAmoBAQHlTca6hwRaPDKI+GWnRQv4aENmzeq7dhGs+WNWP7xhN/c1awiZvc+ZlX+An0RmBV+80fdeaaNkVh8jH7IUFuTLc5i0GYS84hgaAQF1CITXriWNMft3n3ZNa+T3hTq95rklTXr3ooLcXPKz6D2ApQNYrbt3lWdA4oH9np8JqMFjAhy8Sk9Lo/DwcKpTp47H9VVWQWS9WLpp+P9UtgvbQMAQAkElem754kJZpSWv5KmLUcN1VfLV27bkZWXLm/pAMWkED1Gxw1LruuZEKclUoFig1lX2WqAZF8FVk2vYszsNXvcdWSHYFxUbKx3WboKq9h4ljCag9YWRD1l6TBlPRUIH198g3VWjGaF+EPCUgFX0oDUNZSO/LzxlrdLx0MBSqTdctOXGG2+kiLBwOrx/P504esTFo1FcbwI/rfxeVtm1a1fDLoh/nT6b/vhqGeVfuqS3+agPBColUFiitZdzOafS/b7amHO5+DMQJoIsWPQlsP0fC+ifve+lg0uW6VuxwrVpgdD8PHOno+flFtuv+aMwcp+bxoGrAKFXaYWbf62/Cyw6nMLnJ4sbBmh9YdSkPmySv8g+4CHf2lB/N8zEISBgagJF2cXXgnkiG8fMS15esf0hISFmdsMrtnOm+aFl31taD7pYvMUrOL3fCJ/knRKukQ1/NOtt7xuAFksJ8EyQH82eJdfvv//+0u16vjl/4BAd+PIb2jH3fT2rRV0g4JBApAiS85KeWay557CwF3dq9lSrVs2LrdqjKb4hCgwPo+Bo+wxVzkw8Kjv3co5agVpXz7jLOcUX86Ghoa4earvyfyxZTgu79aGtb80xve/acIO8XHOfv6bviDIOaH1h5Gdx5V+foUW33kVn9/5epmW8BQH7ECjMuCid1TSIzer5pRINZTyUrboH87KziTWwNk+dUXVhk5awdACL+2TUK2Nlts+yLz6jvdt/M2k3md/shXPfpSSRBRcfH08DBgwwxKGY5k2p8yujqdXjjxAP7cECAt4gcH3nW2QzSadPeKM5p9s4lXpSlo2Li3P6GBR0jsDNT/6VBq1eSo3v6OncARYoFVUy8UbGhQum9kazP9pGwUd3O6wg57IcfhVggSfe0TVqEKtg5YoAZn7Jk3x3ueA4fQhkXyx+6GPkQ5YCMQt5oci6DIooftCkj+WoBQTMQyAuIUEam3a2WIPYPJZfaWnaueKJOGqI73IsVRAQk5A3H9CPGt3Wo4qC5t1t+QBW5769aejQoZQvhEhHPf5nSk5KMm9vmdTyjWtW06yJr0rr33jjDQoW2Qt6LoUiu+v3z/9FBSIzIKHP7XT9QGMCZHrajLqsQ6Bt27bSma17f1XKqV/3/CLtuemmm5Syy+zGsP5Vyo7dUgPLCtpAzvZH69tvk0WTTxx39hAlyyUnFQeaEditunuuH3QfDf7pW2o5ZHDVhRUvwZpnWp+fTykO7itusuXN0/qhbt26hvl614fv0oMrv6aoBvGGtYGKQUBlAi1u6SDNO56YSDwaxqzLkT8OSNMbN25sVhe8ZndwZAR1GPUUdXrxOa+16e2GLB/AYqCTJk2ilglNKTU5mR6+sxf9sn6dtznbsj0W6OTMq5FDHhIztBXS6NGj6a677tKdxc55H9K2t/9BP456Wfe6USEIVEWg1y2dZJEVG76lCxlpVRX3yv4tu/5NR5ISqXbt2tSxY0evtGmXRg4tX0Grhj9L68dOtIvL0s82JYHanb+aezp6zf7WrVvbqv/ccTbtUKLUD7JK9krrNm0khsQ9W93BgWN0JnB4T/FDnzYl/aJz9ZRzPo0unTtPwVGRUgtL7/pRHwiYgQBfBzZt1JiyszJp+783mcHkSm1cv2ql3N6lS5dK92Pjfwgc+HIJHVz6HeVmZv1no8Xe2SKAxeNll634nm6Kb0gXzp+jYQ/cR8MfvI82rV1DuSK9GIu+BC6cP0/fLFpI93frTNP/PlZG/IcPH04vvviibg1dOHyEDosbSV6a39tPPF2rT21H/EW3+lERCDhL4MYunalF3Ti6JIamvP/Ve84eZlg5Dha/s+htWf+jjz5KmLFFX9RhtWpQaI0YSuh7h74VK15bzx49KEhksWzbtJG0J6GKm1zBvE1rV9Op48epfv36xJO8YLk6gTO799G3Q/5K3z0+4uqFTLan87XXSYvXL/vUZJZbz1wOXp1K3E8xMTHUuXNnQxzcOf9j+tc9g+j3L/5lSP2oFATMQqD7tddLUz+cPdMsJl9hJ/9ur/rmaykJdO+9916xDytXErgsNM9+e2c+bZkygy6dPXvlTgutabqWFnKpcldqihTl1Tu30/QZM4iHsW35eZ188c1dHaERUz1G3JSIQFdgkBDn5WnRxew7dhoeUjk1x1t5loMicbPMKakcCMzKzKQ08WE5dya19MB6gvu011+n2P2J9ONzL1HHMSMpok5tKSyXnXLG6fWN46fQxaRT1GPqeAoTN48/iAyI3IuZVLtNS4oWqeH9Fi6wzXT2pXDxRhkC0xe8R33uvps++uYDuqlFe7q1ve+0kWYtfIt2Htghs6+eeuopZRiZ3RD+rsu5kE6Ne91K9Tt1FDp79hIBryZuNHu2bEM/7NpO896cRpPnLjBVl3Jgd94bU6XNHNjF77vj7mMRWA7Uxt3SznFBE+3981NP0muzZtGx/Tto75a11KJj8bBYE7lgGVO//bBYXPiRR4RmaaAxtyLa7INxJUOoLAMPjoCAiwSeFTIui9auos0/raWNa1ZRl17megD31vixUgronnvuoUaNGrnovb2Kh0RHyaGDLHVRrbF1WfmJIESRM13LF39ZJTMAOFNe5TKnT52iN0eNppUb1tOx9DRyEoHKLillG8/+2DyqOrUNiaCxSxZT7LXNaOmgxyjjeBL1W7RAfKAaurA+X34Alw4eShnHjtOfPplHMU2bEAe0/MX03i0eGSgDWEoBgDG2JPDqq6/K4HhocCiNGzGB+na/26sc+Dv67U9n0Adfz5dZV8uXLyekWuvTBYVCQ3H9yxPp7L79dNuMyfI7SJ+aHdeSKDQr0tOLhY4dlWRtn9jYWEdFdNn3x5491KVnT7osHli8/OZM6v/QI7rU641K5kyeSO/PnC4Du9u3byeIuF+dep6Ydj1IzLLJ/zlwy3oaVlmmTZxEE6dNpaiYWvR/7y6nmNr1rOKaafz44bN3aen8KcTi7fxZrFWrlq62F+Tmkp/IFvUXgbHsM2cpvLa+9etqLCoDAS8R4OQNvk6NFBOYfPjtD9S4WXMvtexZM/y7zb/f/Ju9fv16atKkiWcVWvjoo2t+onrtbyYOYplxiRCTBbFepTOLLQNYZcHkCOHvUyKgdXzXbrooZlcKixMXMwLe+YOHqSAvj6onNJYaEDxkDetX8igUfGo0a0rBInMt69gJChHZbM1EZkJ848Z0dtdeyhdsY29sJWcETNm+y6N1vnHkC+mYaxIoENOflz2F8V4RAhxAeuSO3rSsRCPozi596C8PDKNmjYy/SNi4fQO9+9ks2n1wl8wsmSWyDIYMGaIIGfOawRNE8PdYsPhRXSsySHkq9p5vTKTaLW/wilOqBbDY6Xnz5tGoUaNEtnIQjZnyhvJBLH5AtWDGG/SPaZNlYHfp0qXUrVs3r/SfGRvZ99mXtPeTz6nn6xOoVoviYSdm9ONqNvOEPn369KFffvmF6sQn0F8nzqfYBk2vVhzbdSawZvF7tGTuJPng+J///KfsCz2bYM2Xn/7vFXHdHkTdX/u7DMTqWT/qAgGzEuDRMvf07kPrf9kig1gTZs+lbnf2VtYdHtkz/e8v0Zcfvi9t/OKLL6hv377K2utrw46sXCOTO6o1aUR933+HAk04ezACWL4+i9A+CICAbQm89eoEmvj2TMoVT4F5admsFbW4phXF1oylyPAoCg0JpcCAQPIXw5SdHaoss0TFjXiBCJLl5edRzuVLlJGVQSdTkui3fdvoxOnjsq0a1arTlNEv0KAnhsnhbqe3bqeQatHiicxNWBfD/xzxuCQEf09u3EKhMdUpvustlPzrb7Rh3GRqeGs36vj8U5STdoFYW6BaowaStTf+qBjAYr+HD3iAPl1dLKh6e7//or+IjOaEEn0hb3Bxto0927bSnCmTSidueeutt+jxxx939nBbleMsQ85Y2Tx5OvFEBR1GPSn1Ja0I4dTRY9S7W3eZgR8aHkl3/vcT1KP/EAoJs06mmWr9duLgHlr+wZty6CbbNmHCBHr66ad1M5MfcPLvJEtLsHYbZ2DdPmsaMvR1I4yKrEDgosjoHtjzdtpw6IB0p33X7vTnJ5+mdl26GTaU11VurKO84l+L6aN33qYzp5Plg6eZM2fioWwlIC9nZNCpzVupyZ23yevT7x8fTq2HDjGtRqsrASxjBp5XAhmbQAAEQMAOBJ55ZSz1H/IITRg9hpauXEl7Du6WLyN9r1evHj3Q5y5qtHkHxewuvjDJEFmRG16ZRLVbtZABLKw75nHxxElx8/4m1RG6ehzA4pmrLoug1bnfD8gbIw5s8QsL0ZyvFlOLca/S+DmzafWyb2jN8qV0c+cu1KZ9R6rXoAFFiUBqiMiUDQoOpgB/4zQl+YaVb1wLCkWmXK4I7F7KpvQLIhB57JgQm99Ae7f/JrsrKjKSJo95gYaI4FVhfgGd2b2H/Fj/snVLG67ny+Asg6nfqQNlJp8W3xOvyfP9tumvUbuRwym+exeK72Ld2UvjhC7Ixh2/0f8++hh9v+4nOZxt1WfvUItbelF80+spukYd4sBWYHCIvHny8xNDGqCL6vCrT34WiwqpsIBfeZQrJjXJuphO55KP06Fdv9AR8aCFF75BmSqGMfVu10Homp6kqPj6cpgfv+ehfs6sZyanEI+KiIyrK0dJHP52Je2YK/Qnn/iLvJHrPukVCo+tLfVWHRqNnSBgMwJRYtjut1u30NsiIDR56lT6dcPP8hUiRtI0aNSEqteqSeHhEcW/3eKBhj9/9/EinrfqugjxIv7OKBTfGfliNA9nW2WKYEzq6VOUfOJEaVNN6sXREz160Z86dpLbOEP4/IGDdP3g+6mmkKex2/qejz+jM2KEU5v/fZRqXHsNrXl6jOTB2tB127Wluz99zzajlBDAKv2YWOsNP2Xmp/cLFiygpk2RHm+t3oU3qhNoLIbRLvjic8oUT7t+XLGSjqam0ImDh+jEzt1UKIY2RIksnhyRzZMmLsJ5inoeqpyXlU0XEo9Wus66b/lCjybjyFEKi4qiuDatKFRcURQePkqtW7WmwRNekRpzu+Z/RNENizOEQqpXo0a9emDdSR5hNWtQ07t7ixuoeHl68XDlfouKNfhUP998Yd+Ica/Q3Y/9mSa8PJa+EsPytm7cIF++sOVqbbJmxuAHB1LChm0UsnwNkRDxzr90iVaNGEVBQtdp4A9L7LMuAgcDVy2RulY8oUqw0Mh4cMVX8j8PjQ0Umlc8SUGo+N6wcvBKO1eia9akL5Ytpe+++04+bNh77ChtXbNEvrQy+K8fgRCREdX75g70+qcfUfr6zfIzeO0D/an9yBF0/Mf1tPWtOeTs+omfN9K2me/SdQMHULunh4nPcI6YbescJa3fJANYtVt5Z4i3fnRQEwh4jwBnJz49ciT998MP05SnnxVB/B8p6WIL7MGaAAAOi0lEQVQGHdq/z3tGOGgpUDws6NKuPQ198gmK2rCVkjdtoezUMzJglSrkaJI2/Fte23IAyzbrt/WQ/vNv9UnBg69VOYBVu3UL+RvuF1AcaLSTxI7tNbAcfIZMvatTp060d+9e2rRpE7Vs2dLUvsB4EAABELAjAVWHEJbvi3OnU2i50Kc4ln6BTorpro+I4Zd5IisqSmgxcGZU2uFEqS3JgVrOmOLsCc6A8nSdA7viES5lcOA3KJDqt21D0SLbKnfPfrq2fjw99bGYnVZkXP34/FgRGA4Tuk4TZaDYlusiQMX6bfniSffPL4wX2kDh1G3iy7Irebgs3/Tb6eK3/Dm8a+MmWrdpIyWJmZSP7/udzohhhgEiyBcsnmxnnzsvs4SCRfZCeO2adFkE+lgcPKR6dayX8OAAEmeoRtWNpQIxjC839SzVadSQbujSieIDgqlGYhI1u6MnXSeCVhyw2r94CTXs2c2tdb6BPfjNt1S/c0c5zJX74pLoo5rXGa83Wf68wToIWIFAWloaHRe/3Ud37KQLYob40Lp1KED8ZqSJ39bL6RlUrUlDkaUbReliMq3cdCGl4OF69YRGQmg8mi4eP0H5mdkUe31zqi0eHvqL75Ea4vsivsPNMiMzZftOEbw6S7E3tbH1ep22rWVG6Zk9+8TvTwbVFLz4oavVFleGECKAZbXeL/EHASyLdizcAgEQsA0BswSwbNMhcBQEQAAEQAAEQAAEQEB3Aq4EsEoGt+puAyoEARAAARCwMIEzZ87IGem+/vprC3sJ10AABEAABEAABEAABEAABFQhgACWKj0BO0AABEDARAQ43XzUqFHEs8NgAQGrEuCpx5csWULLly+3qovwy+IEjhw5Is/hnTt3WtxTuAcCIAAC/yHw+uuvU//+/aWczn+24p0VCCCAZYVehA8gAAIgAAIgAAK6E7gsNKOGDBlCQ4cO1b1uVAgC3iCwdu1aeQ5/8MEH3mgObYAACICAEgR27dpF/P2XmpqqhD0wQj8CCGDpxxI1gQAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIGEAAASwDoKJKEAABEAABEAABEAABEAABEAABEAABEAAB/Qg4HcDy8/PTr1XUBAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgYGsCrsSanA5gFRUV2RoqnAcBEAABEAABEAABEAABEAABEAABEAABENCPgCuxJqcDWK5ExfRzBTWBAAiAAAiAAAiAAAiAAAiAAAiAAAiAAAhYkYArsSanA1hWBAWfQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAE1CeAAJb6fQQLQQAEQAAEQAAEQAAEQAAEQAAEQAAEQMDWBBDAsnX3w3kQAAEQAAEQAAEQAAEQAAEQAAEQAAEQUJ8AAljq9xEsBAEQAAEQAAEQAAEQAAEQAAEQAAEQAAFbE3A6gOWKsJaticJ5EAABEAABEAABEAABEAABEAABEAABEACBKgm4EmtyOoDFrbpScZVWogAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgIAtCbgaY3IpgGVLoiZx+uDBg5STk+PQ2t27dzvcj50gAAIgAAIgAAIgAAIgAAIgAAIgAAIgoCIBlwJYrkbHVHTYqjYFBARQ27Ztac6cORUCWT///DP16dOHVqxYYVX34RcIgAAIgAAIgAAIgAAIgAAIgAAIgICJCPj7uxSSokBXfEMAyxVa3i2bkJBAPXv2pDFjxtCMGTNKh3sOHz6cduzYQTExMbR48WLvGoXWQAAEQAAEQAAEQAAEQAAEQAAEQAAEQEAHAi6Fu1yNjulgH6pwgcCoUaOIM7FSUlLo9OnT8kgOXvHyxBNPUFRUlHyPPyAAAiDgDoGCgoIqD3OmTJWVoAAIgAAIgAAIgAAIgAAIgIDlCbgaY3IpgIUMLLXPH87CGjx4cAUjOfvqb3/7W4Xt2AACIAACrhAYO3YsLVq0iCoLUp08eZKee+452rx5sytVoiwIgAAIgAAIgAAIgAAIeESAkzcuXbrksI7jx49Xeg3r8CDsNJyAqzEmlwJYrkbHDPcWDVQgoGVhld2B7KuyNPAeBEDAXQIPPPCADIbffPPNpZp6ubm5MnDVpk0b2rlzJ3Xp0sXd6nEcCChBYO7cufT5559XepHL5/v7779PCxcuVMJWGAEC5QnwhD7PPvssXW3inqSkJHr++eeJ/2MBARAAAasQCA0Npa5du9Ls2bMrBLKOHj1KI0aMoPHjx8vRSlbx2Sp+uBpjQgDLKj1f4kf5LCxkX1msg+EOCPiQAE8U0bdvX0pMTKSpU6dKS/bu3Uvvvfce8Y39Cy+84EPr0DQI6EPgnnvukcPu27dvX6odWVRUJANXN954I40bN4769eunT2OoBQR0JsA3cXwtyA8THnroIeLsWF4yMzNp5MiRxA8b+H18fLzOLaM6EAABEPAdgerVq9N9991HL774IrVs2ZIOHTokjZk/f76c6OyTTz6RD1x9ZyFavhoBVwNYfuKirOhqlZXfzkX5Rw+L2gT45pIzJHiYDw/54SdtWEAABEBADwLbt2+nHj16VKiqQ4cOtHr16grbscF9Avxdnp6eXmUFcXFxFBsbW2U5FHCeAGczz5s3r/QATm/XLpdeeuklGj16dOk+vAEB1QjwMJpWrVpRampqqWl8g1BYWCizD7Zt2yaDXKU78QYEQAAELEDgwoULMniVkZFRwZv+/fvTxx9/XGE7NvieQGRkZOkEdM5Y41IGFl/AsUg4FrUJaFlYyL5Su59gHQiYkYCWhVXedmRflSeCdTMTYD234ODgUhe04BU/4R02bFjpdrwBARUJhIWF0TPPPHOFaRy84mXQoEEIXl1BBisgAAJWIcC/0cOHD6/UnTFjxlS6HRt9S4BjS4ZqYLF7CGD5tpOdbZ2fHvPFC2YedJYYyoEACDhLoPxFAGdf9erVy9nDUQ4ElCdQr149euyxxyrYyRoa0dHRFbZjAwioRmDo0KFUp06dK8zia3hk5V+BBCsgAAIWI8ABrPK/05x9dcMNN1jMU2u4405syaUMLMYUFBRkDVoW94KzsMo/fbO4y3APBEDASwTKZ2Eh+8pL4NGMVwmwEHbZLCxkX3kVPxrzkEBlWVjIvvIQKg4HARBQnkBlv9XlH7wq74SNDHQntuRyAIvH0LsTKbNRPyjjqqvpeMoYDkNAAASUJ6BdDCD7SvmugoFuEiifhYXsKzdB4jCfESibhYXsK591AxoGARDwMoGyv9fIvvIyfBea498lVwXcuXqXA1h8kDuRMj4OCwiAAAiAgDUIaFlYyL6yRn/Ci8oJaFlYlT3RrfwIbAUBdQiUzcJC9pU6/QJLQAAEjCVQ9jdbe+BqbIuo3R0C7saUAt1pLDAwUEbLNEFId+rAMSAAAiAAAuYmMH36dKpfv765nYD1IOCAgJaFVatWrQqaGg4Owy4QUIYAZ2HNnj0b2lfK9AgMAQEQ8AYBzsJKTk6G9pU3YLvRBmdecUzJncVPzKxT5M6BeXl5lJOT486hOAYEQAAEQAAEQKAKAomJiZSenl5FKaK4uDiKjY2tshwKuEeAL4AjIiIQwHIPH45SgMAff/xBzZs3V8ASmAACIAAC3iNQUFAA6SPv4XappdDQULdH9bkX9hLmccpXbm4uIQvLpb5CYRAAARAAARAAARMR4CwsLCBgZgIIXpm592A7CICAuwSg2+0uOWOP4+wrd4cPsmVuaWBpLnHkDAsIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIOCLgaQzJowAWRzXLTjHtyFDsAwEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQsB8Bjh15mhnnUQCLkbMR7kx/aL/ugscgAAIgAAIgAAIgAAIgAAIgAAIgAAIgYC8CHDPSI/nJ4wCWn58fhYeHI4hlr/MP3oIACIAACIAACIAACIAACIAACIAACICAQwIcvOKYEceOPF08DmCxAWxIWFiYLgZ56hCOBwEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQ8C0BvWNFugSwGIkWVcNwQt+eIGgdBEAABEAABEAABEAABEAABEAABEAABHxJwIgYkW4BLAbDBnImlqfCXL6EjLZBAARAAARAAARAAARAAARAAARAAARAAATcI8AxIY4N6Z3gpGsAi13TglhBQUHueYqjQAAEQAAEQAAEQAAEQAAEQAAEQAAEQAAETEeAY0FGBK8YRKARNHicY2hoKAUGBlJOTg4VFRUZ0QzqBAEQAAEQAAHLEnBW6NLZcpYFBcdAAARAAARAAARAAAR8TqBsHMgoYwwJYGnGcgArIiKCcnNz5Uvbjv8gAAIgAAIgAAKOCTibcu1sOcetYS8IgAAIgAAIgAAIgAAIuEcgODiY+GX0g1VDA1jsOjsQEhJCnEaWl5cnX8jIcu+kwFEgAAIgAAL2IcC/nc4sfLGABQRAAARAAARAAARAAAS8SYBjPRzn4Ze3HqgaHsDSALJDfDHOF9r5+fnyVVBQgOGFGiD8BwEQAAEQAIEyBGJiYig5ObnMlopv+YIhMjKy4g5sAQEQAAEQAAEQAAEQAAGdCXDQigXaebQdv4zOuCpvvp/IhvKZQBU3zUEsLZCl/fehSeX5YB0EQAAEQAAEfEYgJSWFTp06ddX2mzZtStHR0Vfdjx0gAAIgAAIgAAIgAAIg4A4BDk5pASvtPwevvB20Kmu7TwNYZQ0p/76wsLA0O4sDWlpQS/tftjxv8yXEsrbgPQiAAAiAAAjoSeDs2bMyiMXZy9rCE6U0aNCAoqKitE34DwIgAAIgAAIgAAIgAAKVErhazESLo/D/8u+19Uor9NFGZQNYPuKBZkEABEAABEBAOQL8UCc7O1sOv+eh+Dw1sYoXFcqBg0EgAAIgAAIgAAIgAAKWIYAAlmW6Eo6AAAiAAAiAAAiAAAiAAAiAAAiAAAiAgDUJ+FvTLXgFAiAAAiAAAiAAAiAAAiAAAiAAAiAAAiBgFQL/Dxjop9T4U5xnAAAAAElFTkSuQmCC)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "_VMiljqIiu-G",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "class EvolutionarySearcher:\n",
+        "    def __init__(self,\n",
+        "                 gene_choice,\n",
+        "                 accuracy_predictor,\n",
+        "                 configs,\n",
+        "                 n_iter):\n",
+        "        self.gene_choice = gene_choice\n",
+        "        self.gene_len = len(self.gene_choice)\n",
+        "        self.accuracy_predictor = accuracy_predictor\n",
+        "        self.n_iterations = n_iter\n",
+        "        self.parent_size = 2 #configs.es.parent_size\n",
+        "        self.mutation_size = 4 #configs.es.mutation_size\n",
+        "        self.mutation_prob = configs.es.mutation_prob\n",
+        "        self.crossover_size = 4 #configs.es.crossover_size\n",
+        "\n",
+        "    def random_sample(self, sample_num):\n",
+        "        # randomly sample genes\n",
+        "        population = []\n",
+        "        i = 0\n",
+        "        while i < sample_num:\n",
+        "            samp_gene = []\n",
+        "            for k in range(self.gene_len):\n",
+        "                samp_gene.append(random.choices(self.gene_choice[k])[0])\n",
+        "            population.append(samp_gene)\n",
+        "            i += 1\n",
+        "        return population\n",
+        "\n",
+        "    def ask(self):\n",
+        "        \"\"\"return the solutions\"\"\"\n",
+        "        return self.population\n",
+        "\n",
+        "    def select_and_transform(self, scores):\n",
+        "        \"\"\"perform evo search according to the scores\"\"\"\n",
+        "\n",
+        "        # sort the index according to the scores (descending order)\n",
+        "        sorted_idx = (-np.array(scores)).argsort()[:self.parent_size]\n",
+        "\n",
+        "        # hint: update self.best_solution and self.best_score\n",
+        "        self.best_solution = self.population[sorted_idx[0]]\n",
+        "        self.best_score = scores[sorted_idx[0]]\n",
+        "\n",
+        "        parents = [self.population[i] for i in sorted_idx]\n",
+        "\n",
+        "        # mutation\n",
+        "        mutate_population = []\n",
+        "        k = 0\n",
+        "        while k < self.mutation_size:\n",
+        "            mutated_gene = self.mutate(random.choices(parents)[0])\n",
+        "            mutate_population.append(mutated_gene)\n",
+        "            k += 1\n",
+        "\n",
+        "        # crossover\n",
+        "        crossover_population = []\n",
+        "        k = 0\n",
+        "        while k < self.crossover_size:\n",
+        "            crossovered_gene = self.crossover(random.sample(parents, 2))\n",
+        "            crossover_population.append(crossovered_gene)\n",
+        "            k += 1\n",
+        "\n",
+        "        self.population = parents + mutate_population + crossover_population\n",
+        "\n",
+        "    def crossover(self, genes):\n",
+        "        crossovered_gene = []\n",
+        "        for i in range(self.gene_len):\n",
+        "            if np.random.uniform() < 0.5:\n",
+        "                crossovered_gene.append(genes[0][i])\n",
+        "            else:\n",
+        "                crossovered_gene.append(genes[1][i])\n",
+        "        return crossovered_gene\n",
+        "\n",
+        "    def mutate(self, gene):\n",
+        "        mutated_gene = []\n",
+        "        for i in range(self.gene_len):\n",
+        "            # use np.random.uniform() to decide whether to mutate position i\n",
+        "            # mutate ith position of gene with self.mutation_prob as mutation probability\n",
+        "            if np.random.uniform() < self.mutation_prob:\n",
+        "                mutated_gene.append(random.choices(self.gene_choice[i])[0])\n",
+        "            else:\n",
+        "                mutated_gene.append(gene[i])\n",
+        "        return mutated_gene\n",
+        "\n",
+        "    def run_search(self):\n",
+        "        # sample subcircuits\n",
+        "        self.population = self.random_sample(self.parent_size + self.mutation_size + self.crossover_size)\n",
+        "        for i in range(self.n_iterations):\n",
+        "            # predict the accuracy of subnets\n",
+        "            accs = []\n",
+        "            for gene in self.population:\n",
+        "                accs.append(self.accuracy_predictor(gene=gene, use_qiskit=True))\n",
+        "            self.select_and_transform(accs)\n",
+        "            logger.info(f\"Best solution: {self.best_solution}\")\n",
+        "            logger.info(f\"Best score: {self.best_score}\")\n",
+        "        # return the best subnet\n",
+        "        return self.best_score, self.best_solution"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "buUm6hVan9lT",
+        "outputId": "2b3717b3-cc65-4ef9-8236-87dba13e38cd",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "  0%|          | 0/2 [00:00<?, ?it/s]\n",
+            "  0%|          | 0/256 [00:00<?, ?it/s]\u001b[A\n",
+            "  2%|▏         | 4/256 [00:00<00:06, 37.91it/s]\u001b[A\n",
+            "  3%|▎         | 8/256 [00:00<00:06, 37.70it/s]\u001b[A\n",
+            "  5%|▍         | 12/256 [00:00<00:07, 34.77it/s]\u001b[A\n",
+            "  6%|▋         | 16/256 [00:00<00:06, 36.59it/s]\u001b[A\n",
+            "  8%|▊         | 20/256 [00:00<00:06, 34.02it/s]\u001b[A\n",
+            "  9%|▉         | 24/256 [00:00<00:06, 34.89it/s]\u001b[A\n",
+            " 11%|█▏        | 29/256 [00:00<00:06, 36.67it/s]\u001b[A\n",
+            " 13%|█▎        | 33/256 [00:00<00:05, 37.19it/s]\u001b[A\n",
+            " 15%|█▍        | 38/256 [00:01<00:05, 38.11it/s]\u001b[A\n",
+            " 16%|█▋        | 42/256 [00:01<00:05, 37.38it/s]\u001b[A\n",
+            " 18%|█▊        | 46/256 [00:01<00:05, 37.76it/s]\u001b[A\n",
+            " 20%|█▉        | 50/256 [00:01<00:05, 37.50it/s]\u001b[A\n",
+            " 21%|██        | 54/256 [00:01<00:05, 37.61it/s]\u001b[A\n",
+            " 23%|██▎       | 58/256 [00:01<00:05, 37.91it/s]\u001b[A\n",
+            " 24%|██▍       | 62/256 [00:01<00:05, 38.06it/s]\u001b[A\n",
+            " 26%|██▌       | 66/256 [00:01<00:05, 37.67it/s]\u001b[A\n",
+            " 27%|██▋       | 70/256 [00:01<00:05, 35.52it/s]\u001b[A\n",
+            " 29%|██▉       | 74/256 [00:02<00:05, 34.22it/s]\u001b[A\n",
+            " 30%|███       | 78/256 [00:02<00:05, 33.50it/s]\u001b[A\n",
+            " 32%|███▏      | 82/256 [00:02<00:05, 33.91it/s]\u001b[A\n",
+            " 34%|███▎      | 86/256 [00:02<00:05, 33.41it/s]\u001b[A\n",
+            " 35%|███▌      | 90/256 [00:02<00:04, 34.45it/s]\u001b[A\n",
+            " 37%|███▋      | 94/256 [00:02<00:04, 34.58it/s]\u001b[A\n",
+            " 38%|███▊      | 98/256 [00:02<00:04, 35.53it/s]\u001b[A\n",
+            " 40%|███▉      | 102/256 [00:02<00:04, 36.53it/s]\u001b[A\n",
+            " 41%|████▏     | 106/256 [00:02<00:04, 34.66it/s]\u001b[A\n",
+            " 43%|████▎     | 110/256 [00:03<00:04, 35.51it/s]\u001b[A\n",
+            " 45%|████▍     | 115/256 [00:03<00:03, 37.30it/s]\u001b[A\n",
+            " 46%|████▋     | 119/256 [00:03<00:03, 37.04it/s]\u001b[A\n",
+            " 48%|████▊     | 123/256 [00:03<00:03, 36.47it/s]\u001b[A\n",
+            " 50%|█████     | 128/256 [00:03<00:03, 38.21it/s]\u001b[A\n",
+            " 52%|█████▏    | 132/256 [00:03<00:03, 37.71it/s]\u001b[A\n",
+            " 53%|█████▎    | 136/256 [00:03<00:03, 34.27it/s]\u001b[A\n",
+            " 55%|█████▍    | 140/256 [00:03<00:03, 33.47it/s]\u001b[A\n",
+            " 56%|█████▋    | 144/256 [00:04<00:03, 34.17it/s]\u001b[A\n",
+            " 58%|█████▊    | 148/256 [00:04<00:03, 35.69it/s]\u001b[A\n",
+            " 60%|█████▉    | 153/256 [00:04<00:02, 37.31it/s]\u001b[A\n",
+            " 61%|██████▏   | 157/256 [00:04<00:02, 33.91it/s]\u001b[A\n",
+            " 63%|██████▎   | 161/256 [00:04<00:03, 31.07it/s]\u001b[A\n",
+            " 64%|██████▍   | 165/256 [00:04<00:03, 29.65it/s]\u001b[A\n",
+            " 66%|██████▌   | 169/256 [00:04<00:02, 29.13it/s]\u001b[A\n",
+            " 67%|██████▋   | 172/256 [00:04<00:02, 28.58it/s]\u001b[A\n",
+            " 68%|██████▊   | 175/256 [00:05<00:02, 28.49it/s]\u001b[A\n",
+            " 70%|██████▉   | 178/256 [00:05<00:02, 28.60it/s]\u001b[A\n",
+            " 71%|███████   | 181/256 [00:05<00:02, 28.90it/s]\u001b[A\n",
+            " 72%|███████▏  | 184/256 [00:05<00:02, 29.17it/s]\u001b[A\n",
+            " 73%|███████▎  | 187/256 [00:05<00:02, 28.41it/s]\u001b[A\n",
+            " 74%|███████▍  | 190/256 [00:05<00:02, 27.77it/s]\u001b[A\n",
+            " 75%|███████▌  | 193/256 [00:05<00:02, 26.89it/s]\u001b[A\n",
+            " 77%|███████▋  | 196/256 [00:05<00:02, 27.62it/s]\u001b[A\n",
+            " 78%|███████▊  | 199/256 [00:05<00:02, 27.15it/s]\u001b[A\n",
+            " 79%|███████▉  | 202/256 [00:06<00:02, 26.78it/s]\u001b[A\n",
+            " 80%|████████  | 205/256 [00:06<00:01, 27.56it/s]\u001b[A\n",
+            " 81%|████████▏ | 208/256 [00:06<00:01, 27.99it/s]\u001b[A\n",
+            " 82%|████████▏ | 211/256 [00:06<00:01, 28.43it/s]\u001b[A\n",
+            " 84%|████████▍ | 215/256 [00:06<00:01, 29.15it/s]\u001b[A\n",
+            " 85%|████████▌ | 218/256 [00:06<00:01, 28.39it/s]\u001b[A\n",
+            " 86%|████████▋ | 221/256 [00:06<00:01, 28.48it/s]\u001b[A\n",
+            " 88%|████████▊ | 224/256 [00:06<00:01, 28.66it/s]\u001b[A\n",
+            " 89%|████████▊ | 227/256 [00:06<00:01, 27.89it/s]\u001b[A\n",
+            " 90%|████████▉ | 230/256 [00:07<00:00, 28.12it/s]\u001b[A\n",
+            " 91%|█████████ | 233/256 [00:07<00:00, 27.29it/s]\u001b[A\n",
+            " 92%|█████████▏| 236/256 [00:07<00:00, 27.49it/s]\u001b[A\n",
+            " 93%|█████████▎| 239/256 [00:07<00:00, 27.29it/s]\u001b[A\n",
+            " 95%|█████████▍| 242/256 [00:07<00:00, 26.05it/s]\u001b[A\n",
+            " 96%|█████████▌| 245/256 [00:07<00:00, 25.33it/s]\u001b[A\n",
+            " 97%|█████████▋| 248/256 [00:07<00:00, 24.80it/s]\u001b[A\n",
+            " 98%|█████████▊| 251/256 [00:07<00:00, 24.96it/s]\u001b[A\n",
+            "100%|██████████| 256/256 [00:08<00:00, 31.78it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n",
+            "Job Status: job has successfully run\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 50%|█████     | 1/2 [00:14<00:14, 14.69s/it]\n",
+            "  0%|          | 0/44 [00:00<?, ?it/s]\u001b[A\n",
+            "  9%|▉         | 4/44 [00:00<00:01, 37.36it/s]\u001b[A\n",
+            " 18%|█▊        | 8/44 [00:00<00:01, 34.65it/s]\u001b[A\n",
+            " 27%|██▋       | 12/44 [00:00<00:00, 35.77it/s]\u001b[A\n",
+            " 36%|███▋      | 16/44 [00:00<00:00, 34.80it/s]\u001b[A\n",
+            " 45%|████▌     | 20/44 [00:00<00:00, 34.45it/s]\u001b[A\n",
+            " 55%|█████▍    | 24/44 [00:00<00:00, 35.60it/s]\u001b[A\n",
+            " 64%|██████▎   | 28/44 [00:00<00:00, 35.71it/s]\u001b[A\n",
+            " 73%|███████▎  | 32/44 [00:00<00:00, 36.93it/s]\u001b[A\n",
+            " 84%|████████▍ | 37/44 [00:01<00:00, 38.22it/s]\u001b[A\n",
+            "100%|██████████| 44/44 [00:01<00:00, 36.05it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Job Status: job is actively running"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Process ForkPoolWorker-53:\n",
+            "Process ForkPoolWorker-51:\n",
+            "Process ForkPoolWorker-49:\n",
+            "Process ForkPoolWorker-52:\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "Traceback (most recent call last):\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 42, in run_job_worker\n",
+            "    job_monitor(job, interval=1)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 89, in job_monitor\n",
+            "    _text_checker(\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 44, in _text_checker\n",
+            "    time.sleep(interval)\n",
+            "KeyboardInterrupt\n",
+            "Process ForkPoolWorker-50:\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 315, in _bootstrap\n",
+            "    self.run()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            " 50%|█████     | 1/2 [00:17<00:17, 17.09s/it]  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/process.py\", line 108, in run\n",
+            "    self._target(*self._args, **self._kwargs)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 125, in worker\n",
+            "    result = (True, func(*args, **kwds))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\", line 48, in mapstar\n",
+            "    return list(map(*args))\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 42, in run_job_worker\n",
+            "    job_monitor(job, interval=1)\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 42, in run_job_worker\n",
+            "    job_monitor(job, interval=1)\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 42, in run_job_worker\n",
+            "    job_monitor(job, interval=1)\n",
+            "  File \"/content/torchquantum/torchquantum/plugins/qiskit_processor.py\", line 42, in run_job_worker\n",
+            "    job_monitor(job, interval=1)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 89, in job_monitor\n",
+            "    _text_checker(\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 89, in job_monitor\n",
+            "    _text_checker(\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 89, in job_monitor\n",
+            "    _text_checker(\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 44, in _text_checker\n",
+            "    time.sleep(interval)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 89, in job_monitor\n",
+            "    _text_checker(\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 44, in _text_checker\n",
+            "    time.sleep(interval)\n",
+            "KeyboardInterrupt\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 44, in _text_checker\n",
+            "    time.sleep(interval)\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/qiskit/tools/monitor/job_monitor.py\", line 44, in _text_checker\n",
+            "    time.sleep(interval)\n",
+            "KeyboardInterrupt\n",
+            "KeyboardInterrupt\n",
+            "KeyboardInterrupt\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\rJob Status: job is actively running"
+          ]
+        },
+        {
+          "ename": "KeyboardInterrupt",
+          "evalue": "ignored",
+          "output_type": "error",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-19-42e3c07bc683>\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# get the accuracy and gene of the best subcircuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0macc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_search\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      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-18-1f83cc71c738>\u001b[0m in \u001b[0;36mrun_search\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     87\u001b[0m             \u001b[0maccs\u001b[0m \u001b[0;34m=\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     88\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mgene\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpopulation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 89\u001b[0;31m                 \u001b[0maccs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maccuracy_predictor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgene\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\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     90\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect_and_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maccs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m             \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Best solution: {self.best_solution}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m<ipython-input-8-0001952830ed>\u001b[0m in \u001b[0;36mevaluate_gene\u001b[0;34m(gene, use_qiskit)\u001b[0m\n\u001b[1;32m     52\u001b[0m                 \u001b[0minputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minput_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m                 \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mconfigs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_qiskit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_qiskit\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     55\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtarget_all\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m                 \u001b[0mtarget_all\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtargets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-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   1499\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   1500\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\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   1502\u001b[0m         \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1503\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\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<ipython-input-5-a9ce2bd20b11>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x, verbose, use_qiskit)\u001b[0m\n\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;31m# call the qiskit processor to process the circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m             x0 = self.qiskit_processor.process_ready_circs(qdev, assembled_circs).to(  # type: ignore\n\u001b[0m\u001b[1;32m     71\u001b[0m                 \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m             )\n",
+            "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs\u001b[0;34m(self, q_device, circs_all, parallel)\u001b[0m\n\u001b[1;32m    720\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    721\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mprocess_ready_circs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq_device\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\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--> 722\u001b[0;31m         \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocess_ready_circs_get_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircs_all\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparallel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparallel\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    723\u001b[0m         \u001b[0mmeasured_qiskit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_expectations_from_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcounts\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_wires\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mq_device\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_wires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    724\u001b[0m         \u001b[0mmeasured_torch\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmeasured_qiskit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/content/torchquantum/torchquantum/plugins/qiskit_processor.py\u001b[0m in \u001b[0;36mprocess_ready_circs_get_counts\u001b[0;34m(self, circs_all, parallel)\u001b[0m\n\u001b[1;32m    695\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    696\u001b[0m             \u001b[0mp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmultiprocessing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax_jobs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 697\u001b[0;31m             \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_job_worker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dicts\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    698\u001b[0m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\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    699\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mmap\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m    362\u001b[0m         \u001b[0;32min\u001b[0m \u001b[0ma\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mthat\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mreturned\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    363\u001b[0m         '''\n\u001b[0;32m--> 364\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_map_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmapstar\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\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    365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    366\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mstarmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    764\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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--> 765\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\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    766\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mready\u001b[0m\u001b[0;34m(\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    767\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mTimeoutError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/multiprocess/pool.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    760\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    761\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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--> 762\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_event\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\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    763\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    764\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    605\u001b[0m             \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_flag\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    606\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 607\u001b[0;31m                 \u001b[0msignaled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cond\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimeout\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    608\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0msignaled\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    609\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+            "\u001b[0;32m/usr/lib/python3.10/threading.py\u001b[0m in \u001b[0;36mwait\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    318\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m    \u001b[0;31m# restore state no matter what (e.g., KeyboardInterrupt)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    319\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mtimeout\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 320\u001b[0;31m                 \u001b[0mwaiter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0macquire\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    321\u001b[0m                 \u001b[0mgotit\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    322\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;31mKeyboardInterrupt\u001b[0m: "
+          ]
+        }
+      ],
+      "source": [
+        "agent2 = EvolutionarySearcher(model.arch_space, evaluate_gene, configs, 3)\n",
+        "\n",
+        "# get the accuracy and gene of the best subcircuit\n",
+        "acc, gene = agent2.run_search()\n",
+        "\n",
+        "print(gene)\n",
+        "print(acc)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "i2h7bD3qAc4N",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "The searched best subcircui's architecture is this:"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 614
+        },
+        "id": "-7uxHQEEAcQu",
+        "outputId": "dedf78a8-0e21-4268-ffaa-4330b29e4d05",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Circuit depth: 13\n",
+            "Gate counts: OrderedDict([('cu3', 10), ('u3', 9)])\n",
+            "Architecture:\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 2210.55x785.944 with 1 Axes>"
+            ]
+          },
+          "execution_count": 20,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "model.set_sample_arch(gene)\n",
+        "circ = tq2qiskit(tq.QuantumDevice(n_wires=model.n_wires), model.q_layer)\n",
+        "print(\"Circuit depth: {0}\".format(circ.depth()))\n",
+        "print(\"Gate counts: {0}\".format(circ.count_ops()))\n",
+        "print(\"Architecture:\")\n",
+        "circ.draw('mpl')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3VdNbEbjMbmA",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "###Part 2: Prune the best subcircuit"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "omnamjl3lxGu",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "Before pruning, we need to record the parameters for comparision with those after pruning.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "id": "1aNpqCvxWaAM"
+      },
+      "outputs": [],
+      "source": [
+        "import locale\n",
+        "locale.getpreferredencoding = lambda: \"UTF-8\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ZRDAMeubWiDh",
+        "outputId": "475fa8e7-7ede-4b6d-d31f-4d54210fa99c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Requirement already satisfied: tensorflow_model_optimization in /usr/local/lib/python3.10/dist-packages (0.7.5)\n",
+            "Requirement already satisfied: absl-py~=1.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (1.4.0)\n",
+            "Requirement already satisfied: dm-tree~=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (0.1.8)\n",
+            "Requirement already satisfied: numpy~=1.23 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (1.23.5)\n",
+            "Requirement already satisfied: six~=1.14 in /usr/local/lib/python3.10/dist-packages (from tensorflow_model_optimization) (1.16.0)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install tensorflow_model_optimization"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "tnq4ele1mFcL",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "def mod_pi(x):\n",
+        "    while x > np.pi:\n",
+        "        x = x - 2 * np.pi\n",
+        "    while x < -np.pi:\n",
+        "        x = x + 2 * np.pi\n",
+        "    return x\n",
+        "\n",
+        "params_before_prune = []\n",
+        "for param in model.parameters():\n",
+        "    for x in param.reshape(-1):\n",
+        "        params_before_prune.append(mod_pi(x.cpu().detach().numpy()))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "1AQjjFuprZqp",
+        "outputId": "b0b8f573-63b3-4f87-fb1c-4e69ad6c0e0b",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[array(1.2060113, dtype=float32), array(2.2385259, dtype=float32), array(-1.831825, dtype=float32), -1.8875616232501429, array(-0.16537467, dtype=float32), array(-1.1199452, dtype=float32), array(-3.0714889, dtype=float32), array(1.319183, dtype=float32), array(1.8012493, dtype=float32), array(-0.55449617, dtype=float32), -1.776839558278219, array(1.1050001, dtype=float32), array(1.3458017, dtype=float32), array(2.2216663, dtype=float32), array(1.2591805, dtype=float32), array(1.3722651, dtype=float32), array(0.46867403, dtype=float32), array(-1.3104833, dtype=float32), array(-2.6374984, dtype=float32), array(1.1927967, dtype=float32), array(-1.537862, dtype=float32), array(-0.961351, dtype=float32), array(-0.6752364, dtype=float32), array(0.6030566, dtype=float32), array(-1.2493807, dtype=float32), array(-1.7007474, dtype=float32), array(0.1528023, dtype=float32), array(-0.5733373, dtype=float32), array(0.05264929, dtype=float32), array(-1.218637, dtype=float32), -0.9736960569964808, 2.276383701954977, array(2.9545443, dtype=float32), array(0.6112427, dtype=float32), array(-1.768812, dtype=float32), -2.8226218859301966, array(0.2936784, dtype=float32), array(2.0202014, dtype=float32), array(0.8791962, dtype=float32), 0.7627599875079554, array(0.3225196, dtype=float32), array(-1.5350167, dtype=float32), array(1.2173138, dtype=float32), array(1.9756929, dtype=float32), array(3.0122225, dtype=float32), array(-0.3282573, dtype=float32), array(0.5098736, dtype=float32), array(-0.5967889, dtype=float32), array(-0.23826292, dtype=float32), array(-0.8825165, dtype=float32), array(-2.1583827, dtype=float32), array(-0.00144892, dtype=float32), array(-1.1891487, dtype=float32), array(2.0944161, dtype=float32), array(1.0276417, dtype=float32), -1.7321627775775355, array(1.5605937, dtype=float32), array(0.4463723, dtype=float32), array(1.2150304, dtype=float32), array(-1.6005719, dtype=float32), array(0.27260005, dtype=float32), array(-0.6578254, dtype=float32), array(0.6727466, dtype=float32), array(-1.172121, dtype=float32), array(1.4109098e-06, dtype=float32), array(0.9533401, dtype=float32), array(0.7146789, dtype=float32), array(-5.851705e-06, dtype=float32), array(-2.014969, dtype=float32), array(0.19204804, dtype=float32), array(-2.6795934e-07, dtype=float32), array(0.74116415, dtype=float32)]\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(params_before_prune)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "5M5EUs4Y1k7z",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "Build the pruning trainer."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "id": "2M_8ch7LMj8z",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "import torch.nn as nn\n",
+        "import torch.nn.utils.prune\n",
+        "from torchquantum.prune_utils import (PhaseL1UnstructuredPruningMethod,\n",
+        "                                      ThresholdScheduler)\n",
+        "from torchpack.train import Trainer\n",
+        "from torchpack.utils.typing import Optimizer, Scheduler\n",
+        "from torchpack.callbacks.writers import TFEventWriter\n",
+        "from typing import Any, Callable, Dict\n",
+        "\n",
+        "class PruningTrainer(Trainer):\n",
+        "    \"\"\"\n",
+        "    Perform pruning-aware training\n",
+        "    \"\"\"\n",
+        "    def __init__(self, *, model: nn.Module, criterion: Callable,\n",
+        "                 optimizer: Optimizer, scheduler: Scheduler) -> None:\n",
+        "        self.model = model\n",
+        "        self.legalized_model = None\n",
+        "        self.criterion = criterion\n",
+        "        self.optimizer = optimizer\n",
+        "        self.scheduler = scheduler\n",
+        "        self.solution = None\n",
+        "        self.score = None\n",
+        "\n",
+        "        self._parameters_to_prune = None\n",
+        "        self._target_pruning_amount = None\n",
+        "        self._init_pruning_amount = None\n",
+        "        self.prune_amount_scheduler = None\n",
+        "        self.prune_amount = None\n",
+        "\n",
+        "        self.init_pruning()\n",
+        "\n",
+        "    @staticmethod\n",
+        "    def extract_prunable_parameters(model: nn.Module) -> list:\n",
+        "        _parameters_to_prune = [\n",
+        "            (module, \"params\")\n",
+        "            for _, module in model.named_modules() if isinstance(module,\n",
+        "                                                                 tq.Operator)\n",
+        "            and module.params is not None]\n",
+        "        return _parameters_to_prune\n",
+        "\n",
+        "    def init_pruning(self) -> None:\n",
+        "        \"\"\"\n",
+        "        Initialize pruning procedure\n",
+        "        \"\"\"\n",
+        "        self._parameters_to_prune = self.extract_prunable_parameters(\n",
+        "            self.model)\n",
+        "        self._target_pruning_amount = configs.prune.target_pruning_amount\n",
+        "        self._init_pruning_amount = configs.prune.init_pruning_amount\n",
+        "        self.prune_amount_scheduler = ThresholdScheduler(\n",
+        "            configs.prune.start_epoch, configs.prune.end_epoch,\n",
+        "            self._init_pruning_amount,\n",
+        "            self._target_pruning_amount)\n",
+        "        self.prune_amount = self._init_pruning_amount\n",
+        "\n",
+        "    def _remove_pruning(self):\n",
+        "        for module, name in self._parameters_to_prune:\n",
+        "            nn.utils.prune.remove(module, name)\n",
+        "\n",
+        "    def _prune_model(self, prune_amount) -> None:\n",
+        "        \"\"\"\n",
+        "        Perform global threshold/percentage pruning on the quantum model.\n",
+        "        This function just performs pruning re-parametrization, i.e.,\n",
+        "        record weight_orig and generate weight_mask\n",
+        "        \"\"\"\n",
+        "        # first clear current pruning container, since we do not want cascaded\n",
+        "        # pruning methods\n",
+        "        # remove operation will make pruning permanent\n",
+        "        if self.epoch_num > 1:\n",
+        "            self._remove_pruning()\n",
+        "        # perform global phase pruning based on the given pruning amount\n",
+        "        nn.utils.prune.global_unstructured(\n",
+        "            self._parameters_to_prune,\n",
+        "            pruning_method=PhaseL1UnstructuredPruningMethod,\n",
+        "            amount=prune_amount,\n",
+        "        )\n",
+        "        self.summary.add_scalar('prune_amount', prune_amount)\n",
+        "\n",
+        "    def _before_epoch(self) -> None:\n",
+        "        self.model.train()\n",
+        "\n",
+        "    def run_step(self, feed_dict: Dict[str, Any], legalize=False) -> Dict[str, Any]:\n",
+        "        output_dict = self._run_step(feed_dict, legalize=legalize)\n",
+        "        return output_dict\n",
+        "\n",
+        "    def _run_step(self, feed_dict: Dict[str, Any], legalize=False) -> Dict[str, Any]:\n",
+        "        if configs.run.device == 'gpu':\n",
+        "            inputs = feed_dict[configs.dataset.input_name].cuda(\n",
+        "                non_blocking=True)\n",
+        "            targets = feed_dict[configs.dataset.target_name].cuda(\n",
+        "                non_blocking=True)\n",
+        "        else:\n",
+        "            inputs = feed_dict[configs.dataset.input_name]\n",
+        "            targets = feed_dict[configs.dataset.target_name]\n",
+        "        if legalize:\n",
+        "            outputs = self.legalized_model(inputs)\n",
+        "        else:\n",
+        "            outputs = self.model(inputs)\n",
+        "        loss = self.criterion(outputs, targets)\n",
+        "        nll_loss = loss.item()\n",
+        "        unitary_loss = 0\n",
+        "\n",
+        "        if loss.requires_grad:\n",
+        "            for k, group in enumerate(self.optimizer.param_groups):\n",
+        "                self.summary.add_scalar(f'lr/lr_group{k}', group['lr'])\n",
+        "\n",
+        "            self.summary.add_scalar('loss', loss.item())\n",
+        "            self.summary.add_scalar('nll_loss', nll_loss)\n",
+        "            if getattr(self.model, 'sample_arch', None) is not None:\n",
+        "                for writer in self.summary.writers:\n",
+        "                    if isinstance(writer, TFEventWriter):\n",
+        "                        writer.writer.add_text(\n",
+        "                            'sample_arch', str(self.model.sample_arch),\n",
+        "                            self.global_step)\n",
+        "            self.optimizer.zero_grad()\n",
+        "            loss.backward()\n",
+        "            self.optimizer.step()\n",
+        "\n",
+        "        return {'outputs': outputs, 'targets': targets}\n",
+        "\n",
+        "    def _after_epoch(self) -> None:\n",
+        "        self.model.eval()\n",
+        "        self.scheduler.step()\n",
+        "        # update pruning amount using the scheduler\n",
+        "        self.prune_amount = self.prune_amount_scheduler.step()\n",
+        "        # prune the model\n",
+        "        self._prune_model(self.prune_amount)\n",
+        "        # commit pruned parameters after training\n",
+        "        if self.epoch_num == self.num_epochs:\n",
+        "            self._remove_pruning()\n",
+        "\n",
+        "    def _after_step(self, output_dict) -> None:\n",
+        "        pass\n",
+        "\n",
+        "    def _state_dict(self) -> Dict[str, Any]:\n",
+        "        state_dict = dict()\n",
+        "        # need to store model arch because of randomness of random layers\n",
+        "        state_dict['model_arch'] = self.model\n",
+        "        state_dict['model'] = self.model.state_dict()\n",
+        "        state_dict['optimizer'] = self.optimizer.state_dict()\n",
+        "        state_dict['scheduler'] = self.scheduler.state_dict()\n",
+        "        if getattr(self.model, 'sample_arch', None) is not None:\n",
+        "            state_dict['sample_arch'] = self.model.sample_arch\n",
+        "        try:\n",
+        "            state_dict['q_layer_op_list'] = build_module_op_list(\n",
+        "                self.model.q_layer)\n",
+        "            state_dict['encoder_func_list'] = self.model.encoder.func_list\n",
+        "        except AttributeError:\n",
+        "            logger.warning(f\"No q_layer_op_list or encoder_func_list found, \"\n",
+        "                           f\"will not save them\")\n",
+        "\n",
+        "        if self.solution is not None:\n",
+        "            state_dict['solution'] = self.solution\n",
+        "            state_dict['score'] = self.score\n",
+        "\n",
+        "        try:\n",
+        "            state_dict['v_c_reg_mapping'] = self.model.measure.v_c_reg_mapping\n",
+        "        except AttributeError:\n",
+        "            logger.warning(f\"No v_c_reg_mapping found, will not save it.\")\n",
+        "        return state_dict\n",
+        "\n",
+        "    def _load_state_dict(self, state_dict: Dict[str, Any]) -> None:\n",
+        "        # self.model.load_state_dict(state_dict['model'])\n",
+        "        self.optimizer.load_state_dict(state_dict['optimizer'])\n",
+        "        self.scheduler.load_state_dict(state_dict['scheduler'])\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VuuhStq21gJ8",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "Some callbacks function useful for pruning."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "id": "MDCcYTS8P1ht",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "from torchpack.callbacks import (InferenceRunner, MaxSaver, Saver, CategoricalAccuracy)\n",
+        "from examples.gradient_pruning.callbacks import NLLError\n",
+        "\n",
+        "def get_subcallbacks(config):\n",
+        "    subcallbacks = []\n",
+        "    for subcallback in config:\n",
+        "        if subcallback['metrics'] == 'CategoricalAccuracy':\n",
+        "            subcallbacks.append(\n",
+        "                CategoricalAccuracy(name=subcallback['name'])\n",
+        "            )\n",
+        "        elif subcallback['metrics'] == 'NLLError':\n",
+        "            subcallbacks.append(\n",
+        "                NLLError(name=subcallback['name'])\n",
+        "            )\n",
+        "        else:\n",
+        "            raise NotImplementedError(subcallback['metrics'])\n",
+        "    return subcallbacks\n",
+        "\n",
+        "\n",
+        "def make_callbacks(dataflow):\n",
+        "    callbacks = []\n",
+        "    for config in configs['callbacks']:\n",
+        "        if config['callback'] == 'InferenceRunner':\n",
+        "            callback = InferenceRunner(\n",
+        "                dataflow=dataflow[config['split']],\n",
+        "                callbacks=get_subcallbacks(config['subcallbacks'])\n",
+        "            )\n",
+        "        elif config['callback'] == 'Saver':\n",
+        "            callback = Saver(max_to_keep=config['max_to_keep'])\n",
+        "        elif config['callback'] == 'MaxSaver':\n",
+        "            callback = MaxSaver(config['name'])\n",
+        "        else:\n",
+        "            raise NotImplementedError(config['callback'])\n",
+        "        callbacks.append(callback)\n",
+        "\n",
+        "    return callbacks\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "WywirsgA1tXq",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "You can set the pruning ratio on your own. If you have tried a pruning ratio and want to try another, simply change the pruning ratio and rerun the following codecell."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "b7270619be5b4e638c49ab9543ec5610",
+            "65fc01a8608846d185bac6a498c4694c",
+            "902476f4033b4c2e9ca49aaef966e117",
+            "44954230ed0a4fe9a416604c59f6e58e",
+            "d60ba45ddde4424c96331d083a91a187",
+            "103457d1e98b434dbbdbfac203bf9b90",
+            "1d975fd51c7c49b0aa19b1635b98bc2f",
+            "beec379e14b44b0aaf26bf4fd763c835",
+            "069ba0d8ae3346aab9b139d55a1d1705",
+            "9a29fe7dd04f4b9f95070a39f0cf2e23",
+            "df57df5495924f95a2c2e3f8855dd121",
+            "9738d0ac2d50413b8b45fd30d3896e02",
+            "972e0f1d733b4993a4cae82fc47e124d",
+            "8bdd09525f45448fa9eec393b9e06082",
+            "d7bdad9f9355485695fdbc6f2731fad4",
+            "33991b02f66d42efb8ee9d048df52c8d",
+            "6de2285eac56405bb60a3e3c7f4c21d9",
+            "68ed37e451e0498f9ed9fd2ea2a5531b",
+            "5d9b0a399157483bb79c0936347df4dd",
+            "f1e2794dd40541399316d77d2ae30c40",
+            "4d87f28dce814e9d8a4abf84e30d02b5",
+            "01c6b75083b949afab571f99ea5f2275",
+            "2e5859150aa24fe4992346e26b0923a7",
+            "ddc20c1e23e348f69980e0c37736409e",
+            "f5e24770e5e341e39b341869796db2a7",
+            "153c07684894462088d68a6883d51e3b",
+            "572ae926714d4804bb99aa41684720c5",
+            "8913810f447b471e9eb96e11a64c18eb",
+            "12d65b7f3cda42b784484a31f672e379",
+            "c4c7988172154020abf7ca546250bd45",
+            "ae64800630624d06b600aa63200a7753",
+            "d739f5cb184f49b8b61ab4b4edc6646d",
+            "ce13cadf5f94487696c870f956f41147",
+            "ceb7e9da20e0440382d80bbe23580848",
+            "f4c1939a308544b8aad47c011eaeb07b",
+            "6d856a27234c4437b3ec49ca4eeca36d",
+            "a1258da98bbc487d8a2410695c982508",
+            "1199ffb349584d7599d7240e26653580",
+            "48157fc41bd64f8cbd1dc3e9863eca97",
+            "01a717c12a494f9bade13620b195cfd9",
+            "0c8d3178f8294b50896c13599aef3b2a",
+            "fae629f7891846c6bd4eb39795053d6b",
+            "dc842e0a59df48169437db4b2106e524",
+            "6fb2cdd8154940eabdcc7a470f26d37e",
+            "1467002494a44ff782881592c8ec91b2",
+            "8b937d390a2e431c87aa7d01de20423a",
+            "7d8c09a01dbd44dc8056409402e4e9c7",
+            "150543e4fb284b1481041eac10ada746",
+            "5002ef29438248cfb56146eafdb02ff1",
+            "9f384cc0c9bd4f1c96b58b22b094446e",
+            "503680c2cf6e43589d795cdb3a8cb949",
+            "b9653be5f6554faab6521f15d632fe60",
+            "41b6b4ecd14340beba715f7eff584c90",
+            "341ee0c0cc184a6ebbeae4209a36258f",
+            "bb68b50116cd4f1f9c15fce1770d3105",
+            "2ef02ac3d9fe40e58bd4ac387742ce35",
+            "50e44bcb6282447ba718d54b3eb63318",
+            "bec72bacba0b4d5e9d650dfe7ca6e77e",
+            "7b0ee4d02db34b2a8b1896639f54a862",
+            "1330aecb41c640deb7a8a49df564f1a7",
+            "4374447a37e449b09111aecb5e216f99",
+            "801c8d0b42e14241b6be8a30e2cd9aac",
+            "1b13c08c7e55498686b31e6519ab618a",
+            "689257a51152408db4d93f98d0e62a78",
+            "ba2c117a55784623af4b49a92efa9451",
+            "d855437dc30d4c1db0ab25854763140c",
+            "2ade945fa7d74bb29579e243813214fe",
+            "aeb6c118f3704e35b54f95fecf97657a",
+            "2f84b7d105e94f7b88cf8c53d07087fa",
+            "1057e14d89fa4f85a2dfb4693bb5557f",
+            "507e2b30906e47418f2167cb5d2066db",
+            "8cb378b74173480da6069536f3cc752b",
+            "f015c88c2412411f854871c14388cc5d",
+            "88ef4ca635394253b00dc164e7f9f51e",
+            "64748cb1cf2e4d0cbc0ff7b9813fe35b",
+            "bb53df44d0c740bfac7920a5164c6e70",
+            "7caef7151a9249d8a11960bee05df66b",
+            "882aaa8ea30149248018563b95d64cef",
+            "6cf3bea675b040aabf28a88694280385",
+            "79f61439f4db45e38c5d3ea1709fa786",
+            "fd025febe00e4b06a7c9e6204fc08b50",
+            "d9b9fd061ebc4f6f9d9587d17062f3f6",
+            "0b4d00274f3345cc916460ab7de92d88",
+            "e5558cda2ad74becb5a20cff6b1195b8",
+            "e5b60e57eac84a8daec873bdf663ff78",
+            "e40f2266ce194eabbf6bde90c195cc3f",
+            "a8b986636cbc4ddc8fabd880897db568",
+            "34ab1d45802044c1a1a8d85691015681",
+            "de534eba45b74551a7d8ba5e90971f12",
+            "38b5d9bce9924321bb7952c4ee22dfdb",
+            "ec0105fb3abe4f4db387b4a98d38cc71",
+            "3996067baf8647a3951e00a7e8fc9148",
+            "b4eb50d852fd46c9b675caab8070ec36",
+            "09fcdf4a98474d218ce6c783fb8bf858",
+            "9e4f6ee70e1942f6aea5ee9e34c4cc36",
+            "8328a3bfda174305956041df2dccb259",
+            "6d4e5f40efd64ac5b6d69754472ccf36",
+            "97bbead0378d41e2bdcd20c786a69ba5",
+            "0beb88257c7844fa9b8a634d7ebeedc1",
+            "27efd00b555c4634ab5b45bdbf983109",
+            "ce22ae9633ce44f0bed4017bbf9be9da",
+            "46320ad8dfff492d8cad5e1313981592",
+            "43356d3e10f34b48ac4e29428a6916d6",
+            "52e606a5d3a44292818324e2be53c136",
+            "91381de219ac47739b8e0907e487583e",
+            "0a45c5c6690947f9abfb5e8c13c78826",
+            "aba185ddea19446a816c4a865cd26b31",
+            "9530de20144c4cb3901561e0d725fad2",
+            "8f5d6456620a4c1089cc854e154cc9b4",
+            "64e22301d6e44864b4f751ad6c115858",
+            "9ffacb579af6479392fb6d9aa83922bf",
+            "4c0a81679d06428a8edb3d5bb00f5849",
+            "07b5b61ee48246cca5b1de06d4bcf097",
+            "c43d55b254b443cebd61b8ad84bca9ac",
+            "627f1f3b5a1e40d5a83b1046e22c0167",
+            "269397ad6d234b779acf2580f3d68082",
+            "549a22d7772149b7a924b2e924ab9ec1",
+            "53b7565f0f1f43108a4d945fc60806e3",
+            "f12f039497c646bdabf7f735e7973665",
+            "2a32af82ab86434fa38c169ea82d762f",
+            "e30a841229f3449cb0bab37a0ac662ee",
+            "1c9694d5efcb47d0a615c0a11f97209c",
+            "06785380fb8b43f7a83d7c18b8336dfc",
+            "e4d556d781194a018bcdb0768abf2584",
+            "6b308556ac31444f86374ea813396b75",
+            "b3bfc0a50026417498d814455b3e6528",
+            "e0ce8f98ad1c4e639a86daf88cd844a3",
+            "0e165d79e425494ca0d7c37a0e7a372b",
+            "286cca83cfa14b57ad63fd90baafe6fe",
+            "0e72173e1bdc4787ad92102d0a60015e",
+            "0fefed8032784463ba00125da7211e45",
+            "17fb1d205d124628b13ec46fcda73014",
+            "33aa492ce3854ef19c3c1279a2b58a5a",
+            "e5535812c2794fd99bfe3c80c8d924e4",
+            "dc511da3d8034266b6bb8070e0fc4796",
+            "5e0dee9c9cd74a0fb69b16a8f890bbca",
+            "9b68eb45f4824fe09a35fdfed01e6b84",
+            "010a745b57464f218702d4e8e4f6a9c1",
+            "41d8c0c48e9e45468fb80763df83eaf2",
+            "78f3c6c9183649c1804a9169bcbd4fe2",
+            "d39f14ae61084b55abb92b9d6ac7706e",
+            "b30f7e59474d4436acad24f4c96a1e1b",
+            "3057a16ecbc6426d9075a63c65eb3788",
+            "d3320caa762546d5b68f862bfda1a610",
+            "9d87317235394b3fa4b7b44b94713d99",
+            "243a82ddfc734be397b896db73d600e8",
+            "643044d3241e42acac6caa904c427672",
+            "a73a24f103a4473d8f91f7ee25b96e7c",
+            "6538daa9bb3b498d96332c98b1f7d723",
+            "2f6711f9abe94245a58399b38077abfa",
+            "ebeac59943ed4e5d9448b3e395037cbe",
+            "f9d771a613144a18ab0271812bd3842b",
+            "3c084f1f743f489bb3c7cf30b2dce6f3",
+            "3e20d81230fe4a4ca07892d58a18f8fd",
+            "992c199e1c85444c9727a0bd2ae5dbd2",
+            "354053feba474fefb583661c26bf7546",
+            "aaa208280ffa4e9ba9aa2dfa9a3e5236",
+            "35aefb99cd054ca184d12bec5a4de805",
+            "6e5bc2858bc342fb95383ec05ec1ed50",
+            "32cdbee5dd984e2ab72df6e9aec7f9e8",
+            "19e04a3cf7204f38bdd130c8204799cf",
+            "f93e99b23ab24f359c2dea674611dbb4",
+            "3bb9c81dc321483abc2b493c57b10e79",
+            "96147fdf695b4ee489c1b3f6339b746e",
+            "55f9bd1947b043e0b979594892c09e97",
+            "4abd54da2cb64417843d23e6f83f97d9",
+            "ef1fdca48c0448748eca0e1fba68779b",
+            "bffb3950a3614e22b2f8d5213a70d89d",
+            "4c09b008802e4bbfad8b698355056f14",
+            "402d70f3ae3c484b80e9885ae2ed1bae",
+            "6a39c54e39b048cb86056b70fc0fd224",
+            "7ed7914804514338b5142eaca84e8e4c",
+            "a3f22c44214940ff9cdaf10bd2713aef",
+            "76c01e6c851c4ebbb75392cee6efe39c",
+            "d102be0015e244b39b1c595ce91d61a1",
+            "c77ca934fe134c688eadde6035fec218",
+            "6e70c2e613ec42b4bc33a061061715da",
+            "abbbe2a017e9404dbcbf508200bbd0db",
+            "abaccc36cc594169b77db02b2ebeb338",
+            "2173dc5a2a634147abce6341e898be35",
+            "adb11afff90142c9bd09dbc7f1a0d1c5",
+            "357df50390b4435c8402361fdb2347dd",
+            "42e49d1f889a488b82220ac128f523a1",
+            "bff253bfd785437dbfe3833634923c17",
+            "da2eca44b4f64f87b52e9a8ac43fa160",
+            "f87c90bdb92448858a56abc98f311705",
+            "fa42eb82e5b944ed92c8e1e4282f78c2",
+            "e8104b737efc41c5a0615d71fe2f4d6c",
+            "07af6b31efdb48f28689ff413c23eb55",
+            "bdf39c2a2e8a4a53a85c11d6b66f48a8",
+            "cee3af91f7214e56bc95fbd90bf42bd7",
+            "224d3297cd20417d906a062c09218b7b",
+            "8b0e0c61d7d24ccca91e1edccc86a99f",
+            "9924545171344c428b7dd60f7d0c8dbd",
+            "b1223d95dab94ba4a8100c45857c3ef9",
+            "583f8afd53e845d99666666e99d6686b",
+            "f413b4a0bc1c4552b09ff74c0488dfc6",
+            "b3b377399e5b4e9397d5d109a85bfc31",
+            "c5fa73b8e5c14a18aff3934e3a3998ce",
+            "9d834b4705ad47e98da98bbc9a055050",
+            "8295fa5451314e20ba7487ff94c488d9",
+            "a69129198e784707bab17fa23c75841e",
+            "a0e5e22ddf6348008b1dc1f0c8b09258",
+            "c994bf6dcda741fab53ee2d31a088fa0",
+            "038c21f6e4b74cd5ac55b78a84de3177",
+            "10e139bc8cee42489c80ed38b69afbd1",
+            "aebf3a4dbd344f78b84cb60ed5b90883",
+            "a9f92d8a14a147a9bf7e3db30bc6c269",
+            "c9f6121f05b2496e87b642c3367cb281",
+            "0600be20dae34485b7fd3aaf6048e2c9",
+            "a374b54402c9479d843f30d5eb1d3af4",
+            "9f4589cf946a479fafe3eb505eb85f0f",
+            "10001578875b4d1a88669ceb334ee049",
+            "926c1b111ae2498bb60241a62046b349",
+            "3fd7e99e5a0e465f8237c3ac795598fc",
+            "d142c7694fe843d48efb69cee5a8d379",
+            "a022bffd9dc041498a7fde40da0730cc",
+            "41fe82b4d7d14243b4a7e4d2fc1fa576",
+            "2c8e3d7091984d3283403587fe8d1d4f",
+            "d4a89367fa5a48fb958da89c8b7bb967",
+            "636475475f6e4a34bf8155893d6384b9",
+            "d8ad739fe8084b93866f38c03c313a3a",
+            "e7fa725880394a43a300427f4b78d6f9",
+            "2c86523ea4d5464cb6350c08e925cd15",
+            "981878f4289e4a2ba88a37be13182325",
+            "0507291838064afdaa0612f7e137344a",
+            "53f425d3a97647958077b2322a01bcc3",
+            "de3afeb45f8e4775b9b55bec37bdc9f2",
+            "8f9ab828e3b9431ab57ad94e920618fa",
+            "2e1ed355944742768c18a386a7354664",
+            "06ba08ce49a341878609baca0f3f5538",
+            "c2a62d7bb77f486f8d36858a488672dd",
+            "db68e578f6d8407793150c2f48a9b7b9",
+            "91b38cbeb8ed4466b9bdd6aba89054ef",
+            "4390ddd534374a3d98d2d735f7d29dbd",
+            "d743dc1d02984af791662404a86b8cce",
+            "406ad8da915d4c36ad87532e7884652d",
+            "db2ba0d15e7c43f49b2c8f8b1f15aafb",
+            "acc7a9864fbd4b5186246aa395f55d0f",
+            "5104b0b53c2a420d9654f12cf25e3e55",
+            "4f66af989a9f4f48b3277a60d40ea457",
+            "b9abf2a5e59340dfa1016e44e083fa9c",
+            "e6d37796e8864a0a95b0054bdcbcbc82",
+            "8cbe2daaf322456faac28786a25b7dcb",
+            "e7fce353e9504f92b21375925733b402",
+            "48684bd4de50427aa5cab57dd6fe7025",
+            "f908a82f4d8b4c4e8c35bb7fc02dabba",
+            "9ac2f647993e4f81b707500fe7fa63cd",
+            "7bf9c542e6c84c68a04c9a6f691709af",
+            "eb872d3f694c45bb9297c9a37c738b06",
+            "966e4ec0154d47b7bf85bb58eaea6214",
+            "aa3c59ed265c43ca8a3c2bf12917d8fd",
+            "ac847f2e6efa4e5088cb72e58c59d26d",
+            "7993f2d2fe3a4b90a8864a99108f3d86",
+            "47386360e6a047c0a2398ec506cdf556",
+            "0f8bcacb1fee444e951b1083eed28ef1",
+            "f4a96f3d7fc843f3897067b3d85fc3d7",
+            "061348ef25ef4b96bfe148e0e840b9e0",
+            "bcb8e1b114ce48459f8bb1ac866b6f75",
+            "7a5cff18459c46a58fe9886adb818338",
+            "a58081de471048c59120e9bd78448972",
+            "d61e3e1f14e744938d52212992818ec5",
+            "2536dbeb6dce4c3aa1700905c35d20e0",
+            "0bed638168604ded86989c465fc4564f",
+            "b82e7822cc0c4e84852ac2fbe0f9f261",
+            "36ddb9594ed14a6bbb29d8643fc4e44a",
+            "7f52ddd7be9a45a78bceba4662d5e985",
+            "6fd236f1aefe4f2c8d6b5a4aa60b8d8b",
+            "a895bcdda57b48d48a73b7553e1861c1",
+            "ad3209a986974337bf10afd7686ee404",
+            "94cd6a9ef3bc4f8897787bb93d925d17",
+            "0bbf98a8c4ed4ab880307f49206e828d",
+            "67b0bb206ef64cb4a2336d2d5a396736",
+            "f6f0dc3debd148d8bcbae13a377428c5",
+            "260cfaccfabd4bd0b82512f6bb5986d4",
+            "450d82cf7683448cac6945334ae9c068",
+            "26e9ae325ca2442a94e02936f2c90ba3",
+            "2c24a443def6444a8a725d0d23d9edda",
+            "56d11a7b0aaa49a4bab83068f166ab38",
+            "5028851f9082480c8be9382d7904e03f",
+            "8a0dbd18fe094b9cb6991ebb1cc82f8f",
+            "0216e31d410941eebca42618d9c6ed64",
+            "75f9e359e5d343309d6603e2f73cdb14",
+            "2982d94a561e41ca8283181349d18770",
+            "4cc5fc352511401dbc4ce88c2727e5be",
+            "95cd432664bb4effa26233e77c693072",
+            "6b518ce880a94960940419502f7c1a2b",
+            "b6c11c998990444db71e45ed7f9f03a8",
+            "f00d610a35054ee98b323d9bbca3d4a9",
+            "4290b1c25aa7416b893cf616f3fe0026",
+            "a724beaae3ca4b9a869066a01e59f820",
+            "21deef013bf44711ac38fb14d1528972",
+            "ede97b2c2d8d46a19ee7a20346ad2a47",
+            "f539b3c6e85749799d3466df9ad2fe4b",
+            "d7dc40674fcf4ef28415ccb421abe09a",
+            "8016e285f13c403793fe8dea69dbe405",
+            "a90459a1164e4658b4e94c3ca27f0a49",
+            "b5273100a9494aeda77459b563e8aeb3",
+            "ffa89d92b7c84fc598f0a0a7ce28f8db",
+            "703bb37324604fafb616b53c4701af35",
+            "3fd1b8d27f4e46f8b590e3b7a1711f6a",
+            "c96fa78298d147ecbf97232c3f71e130",
+            "15b84bc102f3475d877a034f8ca06e78",
+            "75c90ce2877440f49ea38d31666714a6",
+            "a9d7de20f91e4080a5ff42c405d9d56a",
+            "c35104a5ca714c43859f7093835f3f5d",
+            "566a273b36434f5bbf1d18b11784451f",
+            "662d22de99f34a70a06437434f2bcbce",
+            "d72d47d862fd4df9a570e43a1b47679d",
+            "48667de2565f4c328a1581c86f14868f",
+            "72766cb0b675414e8118e57a8d59c657",
+            "341283f0354e424aa71f77d60c9728d4",
+            "fa819a6082c34f6faa10444f15f62868",
+            "3e1af7eb2d39491782da90e20c898b6a",
+            "b5e0bd5fb9744bebb25efb93dae0b336",
+            "0d376758033a4fa7bc20389b3f0138e6",
+            "959d909762044c99a3d5e156511e5214",
+            "c57a732df20044008081507e45112bac",
+            "8daf659848924936a4bdefb9061a8e5b",
+            "beec965b8b4041e19f1c3174912c3e9d",
+            "edee16194d7942eca9da9ad77ae9dfed",
+            "1adf8644607a4e788e6a9e40fcb586d7",
+            "efc27cac36474b2c941615f463689315",
+            "03d6ca44703548279c08017b47e9b29e",
+            "ca6f696005594623b23a425758e7d195",
+            "fe2d0b0e31ee438c94b25a463d400e60",
+            "59e517c7d73e4cb49cbdfa22f2f7f34c",
+            "191feb563e6f49eb98b3bade4f02c8bb",
+            "ede492733ddf4971bad1be522bd1472d",
+            "2a16922810434bcf86dcd87d7d75c666"
+          ]
+        },
+        "id": "Tq09LjFtPGxt",
+        "outputId": "e6248062-6be9-48f9-cc38-3b46d3f2efdf",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:07:50.807]\u001b[0m \u001b[1m/usr/bin/python3 /usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py -f /root/.local/share/jupyter/runtime/kernel-9970d1b6-3493-4bf5-96e3-1e5dedc0107f.json\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:07:50.812]\u001b[0m \u001b[1mPruning started: \"runs/quantumnas/\".\n",
+            "model:\n",
+            "  arch:\n",
+            "    n_wires: 4\n",
+            "    encoder_op_list_name: 4x4_ryzxy\n",
+            "    n_blocks: 3\n",
+            "    n_layers_per_block: 2\n",
+            "    q_layer_name: u3cu3_s0\n",
+            "    down_sample_kernel_size: 6\n",
+            "    n_front_share_blocks: 1\n",
+            "    n_front_share_wires: 1\n",
+            "    n_front_share_ops: 1\n",
+            "  sampler:\n",
+            "    strategy:\n",
+            "      name: plain\n",
+            "  transpile_before_run: False\n",
+            "  load_op_list: False\n",
+            "dataset:\n",
+            "  name: mnist\n",
+            "  input_name: image\n",
+            "  target_name: digit\n",
+            "optimizer:\n",
+            "  name: adam\n",
+            "  lr: 0.05\n",
+            "  weight_decay: 0.0001\n",
+            "  lambda_lr: 1e-2\n",
+            "run:\n",
+            "  n_epochs: 40\n",
+            "  bsz: 256\n",
+            "  workers_per_gpu: 2\n",
+            "  device: gpu\n",
+            "debug:\n",
+            "  pdb: False\n",
+            "  set_seed: True\n",
+            "  seed: 42\n",
+            "callbacks: [{'callback': 'InferenceRunner', 'split': 'valid', 'subcallbacks': [{'metrics': 'CategoricalAccuracy', 'name': 'acc/valid'}, {'metrics': 'NLLError', 'name': 'loss/valid'}]}, {'callback': 'InferenceRunner', 'split': 'test', 'subcallbacks': [{'metrics': 'CategoricalAccuracy', 'name': 'acc/test'}, {'metrics': 'NLLError', 'name': 'loss/test'}]}, {'callback': 'MaxSaver', 'name': 'acc/valid'}, {'callback': 'Saver', 'max_to_keep': 10}]\n",
+            "qiskit:\n",
+            "  use_qiskit: False\n",
+            "  use_real_qc: False\n",
+            "  backend_name: None\n",
+            "  noise_model_name: None\n",
+            "  basis_gates_name: None\n",
+            "  n_shots: 8192\n",
+            "  initial_layout: None\n",
+            "  seed_transpiler: 42\n",
+            "  seed_simulator: 42\n",
+            "  optimization_level: 0\n",
+            "  est_success_rate: False\n",
+            "  max_jobs: 1\n",
+            "es:\n",
+            "  random_search: False\n",
+            "  population_size: 100\n",
+            "  parent_size: 20\n",
+            "  mutation_size: 40\n",
+            "  mutation_prob: 0.5\n",
+            "  crossover_size: 40\n",
+            "  n_iterations: 5\n",
+            "  est_success_rate: False\n",
+            "  score_mode: loss_succ\n",
+            "  gene_mask: None\n",
+            "  eval:\n",
+            "    use_noise_model: False\n",
+            "    use_real_qc: False\n",
+            "    bsz: qiskit_max\n",
+            "    n_test_samples: 150\n",
+            "prune:\n",
+            "  target_pruning_amount: 0.5\n",
+            "  init_pruning_amount: 0.1\n",
+            "  start_epoch: 0\n",
+            "  end_epoch: 30\n",
+            "  target_pruning_amout: 0.5\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:07:50.882]\u001b[0m \u001b[1mEpoch 1/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "b7270619be5b4e638c49ab9543ec5610",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:07:56.842]\u001b[0m \u001b[1mTraining finished in 5.96 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "9738d0ac2d50413b8b45fd30d3896e02",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:07:58.789]\u001b[0m \u001b[1mInference finished in 1.94 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "2e5859150aa24fe4992346e26b0923a7",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:07:59.290]\u001b[0m \u001b[1mInference finished in 0.49 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:07:59.325]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/max-acc-valid.pt\" (68.215).\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:19.391]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-20.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:19.397]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 66\n",
+            "+ [acc/valid] = 68.215\n",
+            "+ [acc/valid/max] = 68.215\n",
+            "+ [loss] = 0.95486\n",
+            "+ [loss/test] = 0.96308\n",
+            "+ [loss/valid] = 0.97644\n",
+            "+ [lr/lr_group0] = 0.05\n",
+            "+ [nll_loss] = 0.95486\n",
+            "+ [prune_amount] = 0.1\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:19.404]\u001b[0m \u001b[1mEstimated time left: 4 minutes 16 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:19.405]\u001b[0m \u001b[1mEpoch finished in 28.5 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:19.407]\u001b[0m \u001b[1mEpoch 2/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "ceb7e9da20e0440382d80bbe23580848",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:23.176]\u001b[0m \u001b[1mTraining finished in 3.77 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "1467002494a44ff782881592c8ec91b2",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:25.842]\u001b[0m \u001b[1mInference finished in 2.66 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "2ef02ac3d9fe40e58bd4ac387742ce35",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:26.587]\u001b[0m \u001b[1mInference finished in 0.74 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:26.628]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/max-acc-valid.pt\" (69.507).\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:26.657]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-40.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:26.660]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 67\n",
+            "+ [acc/valid] = 69.507\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.97453\n",
+            "+ [loss/test] = 0.94944\n",
+            "+ [loss/valid] = 0.95863\n",
+            "+ [lr/lr_group0] = 0.049923\n",
+            "+ [nll_loss] = 0.97453\n",
+            "+ [prune_amount] = 0.13868\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:26.663]\u001b[0m \u001b[1mEstimated time left: 2 minutes 23 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:26.665]\u001b[0m \u001b[1mEpoch finished in 7.26 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:26.667]\u001b[0m \u001b[1mEpoch 3/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "2ade945fa7d74bb29579e243813214fe",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:30.342]\u001b[0m \u001b[1mTraining finished in 3.67 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "882aaa8ea30149248018563b95d64cef",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:32.040]\u001b[0m \u001b[1mInference finished in 1.69 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "de534eba45b74551a7d8ba5e90971f12",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:32.530]\u001b[0m \u001b[1mInference finished in 0.485 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:32.565]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-60.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:32.567]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 65.333\n",
+            "+ [acc/valid] = 69.184\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.98753\n",
+            "+ [loss/test] = 0.94255\n",
+            "+ [loss/valid] = 0.95429\n",
+            "+ [lr/lr_group0] = 0.049692\n",
+            "+ [nll_loss] = 0.98753\n",
+            "+ [prune_amount] = 0.17479\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:32.574]\u001b[0m \u001b[1mEstimated time left: 1 minute 37 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:32.577]\u001b[0m \u001b[1mEpoch finished in 5.91 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:32.579]\u001b[0m \u001b[1mEpoch 4/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "27efd00b555c4634ab5b45bdbf983109",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:35.667]\u001b[0m \u001b[1mTraining finished in 3.09 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "9ffacb579af6479392fb6d9aa83922bf",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "Exception ignored in:   File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "      File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    \n",
+            "self._shutdown_workers()  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "self._shutdown_workers()    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "\n",
+            "AssertionError    : can only test a child processif w.is_alive():\n",
+            "\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "Exception ignored in: AssertionError: can only test a child process<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "\n",
+            "Traceback (most recent call last):\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "\n",
+            "Traceback (most recent call last):\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "      File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    if w.is_alive():self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "\n",
+            "    if w.is_alive():  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "\n",
+            "      File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError\n",
+            "AssertionError: : \n",
+            "can only test a child processcan only test a child processException ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Exception ignored in: \n",
+            "<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "\n",
+            "    Traceback (most recent call last):\n",
+            "self._shutdown_workers()  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "        if w.is_alive():self._shutdown_workers()\n",
+            "\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process    \n",
+            "if w.is_alive():Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'    self._shutdown_workers()\n",
+            "AssertionError\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            ":     if w.is_alive():can only test a child process\n",
+            "\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "\u001b[32m[2023-10-15 20:08:37.942]\u001b[0m \u001b[1mInference finished in 2.27 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "1c9694d5efcb47d0a615c0a11f97209c",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:38.585]\u001b[0m \u001b[1mInference finished in 0.639 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:38.635]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-80.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:38.638]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 66.667\n",
+            "+ [acc/valid] = 69.467\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.92631\n",
+            "+ [loss/test] = 0.94973\n",
+            "+ [loss/valid] = 0.96571\n",
+            "+ [lr/lr_group0] = 0.049309\n",
+            "+ [nll_loss] = 0.92631\n",
+            "+ [prune_amount] = 0.2084\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:38.639]\u001b[0m \u001b[1mEstimated time left: 1 minute 11 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:38.641]\u001b[0m \u001b[1mEpoch finished in 6.06 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:38.642]\u001b[0m \u001b[1mEpoch 5/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "33aa492ce3854ef19c3c1279a2b58a5a",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:43.358]\u001b[0m \u001b[1mTraining finished in 4.71 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "d3320caa762546d5b68f862bfda1a610",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:45.893]\u001b[0m \u001b[1mInference finished in 2.53 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "992c199e1c85444c9727a0bd2ae5dbd2",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:46.408]\u001b[0m \u001b[1mInference finished in 0.505 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:46.438]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-100.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:46.440]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 64.667\n",
+            "+ [acc/valid] = 69.144\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.96767\n",
+            "+ [loss/test] = 0.95259\n",
+            "+ [loss/valid] = 0.96073\n",
+            "+ [lr/lr_group0] = 0.048776\n",
+            "+ [nll_loss] = 0.96767\n",
+            "+ [prune_amount] = 0.23961\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:46.442]\u001b[0m \u001b[1mEstimated time left: 55.6 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:46.451]\u001b[0m \u001b[1mEpoch finished in 7.81 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:08:46.452]\u001b[0m \u001b[1mEpoch 6/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "4abd54da2cb64417843d23e6f83f97d9",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:49.602]\u001b[0m \u001b[1mTraining finished in 3.15 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "6e70c2e613ec42b4bc33a061061715da",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:08:51.370]\u001b[0m \u001b[1mInference finished in 1.76 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e8104b737efc41c5a0615d71fe2f4d6c",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()if w.is_alive():\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    \n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "\u001b[32m[2023-10-15 20:08:52.232]\u001b[0m \u001b[1mInference finished in 0.858 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:02.299]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-120.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:02.307]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 66\n",
+            "+ [acc/valid] = 69.265\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.93785\n",
+            "+ [loss/test] = 0.9535\n",
+            "+ [loss/valid] = 0.96044\n",
+            "+ [lr/lr_group0] = 0.048097\n",
+            "+ [nll_loss] = 0.93785\n",
+            "+ [prune_amount] = 0.26852\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:02.310]\u001b[0m \u001b[1mEstimated time left: 47.6 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:02.312]\u001b[0m \u001b[1mEpoch finished in 15.9 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:02.314]\u001b[0m \u001b[1mEpoch 7/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "c5fa73b8e5c14a18aff3934e3a3998ce",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:05.340]\u001b[0m \u001b[1mTraining finished in 3.02 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "0600be20dae34485b7fd3aaf6048e2c9",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:07.124]\u001b[0m \u001b[1mInference finished in 1.78 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "636475475f6e4a34bf8155893d6384b9",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:07.657]\u001b[0m \u001b[1mInference finished in 0.528 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:07.687]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-140.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:07.689]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 64.333\n",
+            "+ [acc/valid] = 65.711\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.97069\n",
+            "+ [loss/test] = 0.98161\n",
+            "+ [loss/valid] = 0.98304\n",
+            "+ [lr/lr_group0] = 0.047275\n",
+            "+ [nll_loss] = 0.97069\n",
+            "+ [prune_amount] = 0.2952\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:07.692]\u001b[0m \u001b[1mEstimated time left: 32.9 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:07.694]\u001b[0m \u001b[1mEpoch finished in 5.38 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:07.695]\u001b[0m \u001b[1mEpoch 8/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "c2a62d7bb77f486f8d36858a488672dd",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:11.374]\u001b[0m \u001b[1mTraining finished in 3.68 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "e6d37796e8864a0a95b0054bdcbcbc82",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:13.961]\u001b[0m \u001b[1mInference finished in 2.58 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "7993f2d2fe3a4b90a8864a99108f3d86",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:14.710]\u001b[0m \u001b[1mInference finished in 0.745 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:14.763]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-160.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:14.766]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 65.333\n",
+            "+ [acc/valid] = 68.174\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.94833\n",
+            "+ [loss/test] = 0.95228\n",
+            "+ [loss/valid] = 0.96339\n",
+            "+ [lr/lr_group0] = 0.046316\n",
+            "+ [nll_loss] = 0.94833\n",
+            "+ [prune_amount] = 0.31975\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:14.768]\u001b[0m \u001b[1mEstimated time left: 21 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:14.770]\u001b[0m \u001b[1mEpoch finished in 7.07 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:14.772]\u001b[0m \u001b[1mEpoch 9/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "b82e7822cc0c4e84852ac2fbe0f9f261",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:18.702]\u001b[0m \u001b[1mTraining finished in 3.93 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "450d82cf7683448cac6945334ae9c068",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "Exception ignored in:   File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "    Traceback (most recent call last):\n",
+            "assert self._parent_pid == os.getpid(), 'can only test a child process'  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "\n",
+            "AssertionError    : self._shutdown_workers()can only test a child process\n",
+            "\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():Exception ignored in: \n",
+            "<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "\n",
+            "    Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "\n",
+            "AssertionError  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            ": can only test a child process    \n",
+            "if w.is_alive():Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    Traceback (most recent call last):\n",
+            "assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "AssertionError    : self._shutdown_workers()can only test a child process\n",
+            "\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>Exception ignored in: \n",
+            "<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>Traceback (most recent call last):\n",
+            "\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "Traceback (most recent call last):\n",
+            "      File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "self._shutdown_workers()    \n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "self._shutdown_workers()    \n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "if w.is_alive():    \n",
+            "if w.is_alive():  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    \n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError\n",
+            ": can only test a child processAssertionError: \n",
+            "can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Exception ignored in: Traceback (most recent call last):\n",
+            "<function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "self._shutdown_workers()\n",
+            "    self._shutdown_workers()  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    \n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "if w.is_alive():\n",
+            "    if w.is_alive():  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    \n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "assert self._parent_pid == os.getpid(), 'can only test a child process'    \n",
+            "assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError\n",
+            "AssertionError: : can only test a child process\n",
+            "can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "Exception ignored in: <function _MultiProcessingDataLoaderIter.__del__ at 0x7cb30fbe44c0>\n",
+            "Traceback (most recent call last):\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1478, in __del__\n",
+            "    self._shutdown_workers()\n",
+            "  File \"/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py\", line 1461, in _shutdown_workers\n",
+            "    if w.is_alive():\n",
+            "  File \"/usr/lib/python3.10/multiprocessing/process.py\", line 160, in is_alive\n",
+            "    assert self._parent_pid == os.getpid(), 'can only test a child process'\n",
+            "AssertionError: can only test a child process\n",
+            "\u001b[32m[2023-10-15 20:09:21.995]\u001b[0m \u001b[1mInference finished in 3.29 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "6b518ce880a94960940419502f7c1a2b",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:22.840]\u001b[0m \u001b[1mInference finished in 0.836 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:22.941]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-180.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:22.955]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 64\n",
+            "+ [acc/valid] = 63.207\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.99323\n",
+            "+ [loss/test] = 0.98909\n",
+            "+ [loss/valid] = 1.0204\n",
+            "+ [lr/lr_group0] = 0.045225\n",
+            "+ [nll_loss] = 0.99323\n",
+            "+ [prune_amount] = 0.34225\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:22.960]\u001b[0m \u001b[1mEstimated time left: 7.94 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:22.966]\u001b[0m \u001b[1mEpoch finished in 8.19 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:22.971]\u001b[0m \u001b[1mEpoch 10/10 started.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "b5273100a9494aeda77459b563e8aeb3",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/20 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:26.210]\u001b[0m \u001b[1mTraining finished in 3.24 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "d72d47d862fd4df9a570e43a1b47679d",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/10 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:28.293]\u001b[0m \u001b[1mInference finished in 2.08 seconds.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "application/vnd.jupyter.widget-view+json": {
+              "model_id": "beec965b8b4041e19f1c3174912c3e9d",
+              "version_major": 2,
+              "version_minor": 0
+            },
+            "text/plain": [
+              "  0% 0/2 [00:00<?, ?it/s]"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\u001b[32m[2023-10-15 20:09:29.039]\u001b[0m \u001b[1mInference finished in 0.742 second.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:29.081]\u001b[0m \u001b[1mCheckpoint saved: \"runs/quantumnas/checkpoints/step-200.pt\".\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:29.088]\u001b[0m \u001b[1m\n",
+            "+ [acc/test] = 57.667\n",
+            "+ [acc/valid] = 55.816\n",
+            "+ [acc/valid/max] = 69.507\n",
+            "+ [loss] = 0.96137\n",
+            "+ [loss/test] = 1.0431\n",
+            "+ [loss/valid] = 1.1078\n",
+            "+ [lr/lr_group0] = 0.04401\n",
+            "+ [nll_loss] = 0.96137\n",
+            "+ [prune_amount] = 0.3628\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:29.090]\u001b[0m \u001b[1mEpoch finished in 6.12 seconds.\u001b[0m\n",
+            "\u001b[32m[2023-10-15 20:09:29.095]\u001b[0m \u001b[32m\u001b[1m10 epochs of training finished in 1 minute 38 seconds.\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "from torch.optim.lr_scheduler import CosineAnnealingLR\n",
+        "\n",
+        "# Reset the pruning ratio here\n",
+        "configs.prune.target_pruning_amout = 0.5\n",
+        "n_finetune_epochs = 10\n",
+        "\n",
+        "model2 = SuperQFCModel0(configs.model.arch)\n",
+        "state_dict = io.load('max-acc-valid.pt', map_location='cpu')\n",
+        "model2.load_state_dict(state_dict['model'], strict=False)\n",
+        "model2.to(device)\n",
+        "model2.set_sample_arch(gene)\n",
+        "\n",
+        "\n",
+        "if isinstance(configs.optimizer.lr, str):\n",
+        "    configs.optimizer.lr = eval(configs.optimizer.lr)\n",
+        "if isinstance(configs.optimizer.weight_decay, str):\n",
+        "    configs.optimizer.weight_decay = eval(configs.optimizer.weight_decay)\n",
+        "criterion = torch.nn.NLLLoss()\n",
+        "optimizer = torch.optim.Adam(\n",
+        "    model2.parameters(),\n",
+        "    lr=configs.optimizer.lr,\n",
+        "    weight_decay=configs.optimizer.weight_decay)\n",
+        "scheduler = CosineAnnealingLR(optimizer, T_max=configs.run.n_epochs)\n",
+        "trainer = PruningTrainer(model=model2,\n",
+        "                    criterion=criterion,\n",
+        "                    optimizer=optimizer,\n",
+        "                    scheduler=scheduler)\n",
+        "run_dir = 'runs/quantumnas/'\n",
+        "set_run_dir(run_dir)\n",
+        "logger.info(' '.join([sys.executable] + sys.argv))\n",
+        "logger.info(f'Pruning started: \"{run_dir}\".' + '\\n' +f'{configs}')\n",
+        "callbacks = make_callbacks(dataflow)\n",
+        "trainer.train_with_defaults(\n",
+        "    dataflow['train'],\n",
+        "    num_epochs=n_finetune_epochs,\n",
+        "    callbacks=callbacks)\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "l9z0Oox7oGwk",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "Record the parameters after pruning and compare them with those before pruning."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "id": "LpiZJHvXoFv3",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [],
+      "source": [
+        "params_after_prune = []\n",
+        "for param in model2.parameters():\n",
+        "    for x in param.reshape(-1):\n",
+        "        params_after_prune.append(mod_pi(x.cpu().detach().numpy()))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 430
+        },
+        "id": "Vf_dFgnVqdDA",
+        "outputId": "e5769d77-c666-4153-a0ea-4f6626172b48",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "plt.hist(params_before_prune, bins=50, alpha=0.5, label='Before pruning')\n",
+        "plt.hist(params_after_prune, bins=50, alpha=0.5, label='After pruning')\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-aj7cjv3Sjgc",
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "source": [
+        "*pruning ratio* of the parameters are zero after pruning."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 337
+        },
+        "id": "R0C6wygWSh6u",
+        "outputId": "24ae9746-6427-4594-baeb-235a5d528cdf",
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Circuit depth: 13\n",
+            "Architecture:\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 2043.33x367.889 with 1 Axes>"
+            ]
+          },
+          "execution_count": 31,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "circ = tq2qiskit(tq.QuantumDevice(n_wires=model.n_wires), model2.q_layer)\n",
+        "print(\"Circuit depth: {0}\".format(circ.depth()))\n",
+        "print(\"Architecture:\")\n",
+        "circ.draw('mpl')\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "collapsed_sections": [
+        "8c9NBZ6t9JlZ"
+      ],
+      "provenance": [],
+      "toc_visible": true
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.8.16"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "010a745b57464f218702d4e8e4f6a9c1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "01a717c12a494f9bade13620b195cfd9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "01c6b75083b949afab571f99ea5f2275": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "0216e31d410941eebca42618d9c6ed64": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "038c21f6e4b74cd5ac55b78a84de3177": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "03d6ca44703548279c08017b47e9b29e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "0507291838064afdaa0612f7e137344a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0600be20dae34485b7fd3aaf6048e2c9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_a374b54402c9479d843f30d5eb1d3af4",
+              "IPY_MODEL_9f4589cf946a479fafe3eb505eb85f0f",
+              "IPY_MODEL_10001578875b4d1a88669ceb334ee049"
+            ],
+            "layout": "IPY_MODEL_926c1b111ae2498bb60241a62046b349"
+          }
+        },
+        "061348ef25ef4b96bfe148e0e840b9e0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "06785380fb8b43f7a83d7c18b8336dfc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e0ce8f98ad1c4e639a86daf88cd844a3",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0e165d79e425494ca0d7c37a0e7a372b",
+            "value": ""
+          }
+        },
+        "069ba0d8ae3346aab9b139d55a1d1705": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "06ba08ce49a341878609baca0f3f5538": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "07af6b31efdb48f28689ff413c23eb55": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8b0e0c61d7d24ccca91e1edccc86a99f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9924545171344c428b7dd60f7d0c8dbd",
+            "value": ""
+          }
+        },
+        "07b5b61ee48246cca5b1de06d4bcf097": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_53b7565f0f1f43108a4d945fc60806e3",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_f12f039497c646bdabf7f735e7973665",
+            "value": 10
+          }
+        },
+        "09fcdf4a98474d218ce6c783fb8bf858": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0a45c5c6690947f9abfb5e8c13c78826": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "0b4d00274f3345cc916460ab7de92d88": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0bbf98a8c4ed4ab880307f49206e828d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0beb88257c7844fa9b8a634d7ebeedc1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "0bed638168604ded86989c465fc4564f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "0c8d3178f8294b50896c13599aef3b2a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0d376758033a4fa7bc20389b3f0138e6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0e165d79e425494ca0d7c37a0e7a372b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "0e72173e1bdc4787ad92102d0a60015e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "0f8bcacb1fee444e951b1083eed28ef1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a58081de471048c59120e9bd78448972",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d61e3e1f14e744938d52212992818ec5",
+            "value": 2
+          }
+        },
+        "0fefed8032784463ba00125da7211e45": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "10001578875b4d1a88669ceb334ee049": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2c8e3d7091984d3283403587fe8d1d4f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d4a89367fa5a48fb958da89c8b7bb967",
+            "value": "100% 10/10 [00:01&lt;00:00,  7.63it/s]"
+          }
+        },
+        "103457d1e98b434dbbdbfac203bf9b90": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1057e14d89fa4f85a2dfb4693bb5557f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bb53df44d0c740bfac7920a5164c6e70",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7caef7151a9249d8a11960bee05df66b",
+            "value": "[loss] = 0.988, [lr/lr_group0] = 0.0497, [nll_loss] = 0.988: 100% 20/20 [00:03&lt;00:00, 11.27it/s]"
+          }
+        },
+        "10e139bc8cee42489c80ed38b69afbd1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1199ffb349584d7599d7240e26653580": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "12d65b7f3cda42b784484a31f672e379": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1330aecb41c640deb7a8a49df564f1a7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "1467002494a44ff782881592c8ec91b2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_8b937d390a2e431c87aa7d01de20423a",
+              "IPY_MODEL_7d8c09a01dbd44dc8056409402e4e9c7",
+              "IPY_MODEL_150543e4fb284b1481041eac10ada746"
+            ],
+            "layout": "IPY_MODEL_5002ef29438248cfb56146eafdb02ff1"
+          }
+        },
+        "150543e4fb284b1481041eac10ada746": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_341ee0c0cc184a6ebbeae4209a36258f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_bb68b50116cd4f1f9c15fce1770d3105",
+            "value": "100% 10/10 [00:02&lt;00:00,  5.28it/s]"
+          }
+        },
+        "153c07684894462088d68a6883d51e3b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d739f5cb184f49b8b61ab4b4edc6646d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ce13cadf5f94487696c870f956f41147",
+            "value": "100% 2/2 [00:00&lt;00:00,  2.32it/s]"
+          }
+        },
+        "15b84bc102f3475d877a034f8ca06e78": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "17fb1d205d124628b13ec46fcda73014": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "191feb563e6f49eb98b3bade4f02c8bb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "19e04a3cf7204f38bdd130c8204799cf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1adf8644607a4e788e6a9e40fcb586d7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_59e517c7d73e4cb49cbdfa22f2f7f34c",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_191feb563e6f49eb98b3bade4f02c8bb",
+            "value": 2
+          }
+        },
+        "1b13c08c7e55498686b31e6519ab618a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1c9694d5efcb47d0a615c0a11f97209c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_06785380fb8b43f7a83d7c18b8336dfc",
+              "IPY_MODEL_e4d556d781194a018bcdb0768abf2584",
+              "IPY_MODEL_6b308556ac31444f86374ea813396b75"
+            ],
+            "layout": "IPY_MODEL_b3bfc0a50026417498d814455b3e6528"
+          }
+        },
+        "1d975fd51c7c49b0aa19b1635b98bc2f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "2173dc5a2a634147abce6341e898be35": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f87c90bdb92448858a56abc98f311705",
+            "placeholder": "​",
+            "style": "IPY_MODEL_fa42eb82e5b944ed92c8e1e4282f78c2",
+            "value": "100% 10/10 [00:01&lt;00:00,  7.94it/s]"
+          }
+        },
+        "21deef013bf44711ac38fb14d1528972": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "224d3297cd20417d906a062c09218b7b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "243a82ddfc734be397b896db73d600e8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ebeac59943ed4e5d9448b3e395037cbe",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_f9d771a613144a18ab0271812bd3842b",
+            "value": 10
+          }
+        },
+        "2536dbeb6dce4c3aa1700905c35d20e0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "260cfaccfabd4bd0b82512f6bb5986d4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "269397ad6d234b779acf2580f3d68082": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "26e9ae325ca2442a94e02936f2c90ba3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8a0dbd18fe094b9cb6991ebb1cc82f8f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0216e31d410941eebca42618d9c6ed64",
+            "value": ""
+          }
+        },
+        "27efd00b555c4634ab5b45bdbf983109": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_ce22ae9633ce44f0bed4017bbf9be9da",
+              "IPY_MODEL_46320ad8dfff492d8cad5e1313981592",
+              "IPY_MODEL_43356d3e10f34b48ac4e29428a6916d6"
+            ],
+            "layout": "IPY_MODEL_52e606a5d3a44292818324e2be53c136"
+          }
+        },
+        "286cca83cfa14b57ad63fd90baafe6fe": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2982d94a561e41ca8283181349d18770": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "2a16922810434bcf86dcd87d7d75c666": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "2a32af82ab86434fa38c169ea82d762f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2ade945fa7d74bb29579e243813214fe": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_aeb6c118f3704e35b54f95fecf97657a",
+              "IPY_MODEL_2f84b7d105e94f7b88cf8c53d07087fa",
+              "IPY_MODEL_1057e14d89fa4f85a2dfb4693bb5557f"
+            ],
+            "layout": "IPY_MODEL_507e2b30906e47418f2167cb5d2066db"
+          }
+        },
+        "2c24a443def6444a8a725d0d23d9edda": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_75f9e359e5d343309d6603e2f73cdb14",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_2982d94a561e41ca8283181349d18770",
+            "value": 10
+          }
+        },
+        "2c86523ea4d5464cb6350c08e925cd15": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2e1ed355944742768c18a386a7354664",
+            "placeholder": "​",
+            "style": "IPY_MODEL_06ba08ce49a341878609baca0f3f5538",
+            "value": "100% 2/2 [00:00&lt;00:00,  2.16it/s]"
+          }
+        },
+        "2c8e3d7091984d3283403587fe8d1d4f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2e1ed355944742768c18a386a7354664": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2e5859150aa24fe4992346e26b0923a7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_ddc20c1e23e348f69980e0c37736409e",
+              "IPY_MODEL_f5e24770e5e341e39b341869796db2a7",
+              "IPY_MODEL_153c07684894462088d68a6883d51e3b"
+            ],
+            "layout": "IPY_MODEL_572ae926714d4804bb99aa41684720c5"
+          }
+        },
+        "2ef02ac3d9fe40e58bd4ac387742ce35": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_50e44bcb6282447ba718d54b3eb63318",
+              "IPY_MODEL_bec72bacba0b4d5e9d650dfe7ca6e77e",
+              "IPY_MODEL_7b0ee4d02db34b2a8b1896639f54a862"
+            ],
+            "layout": "IPY_MODEL_1330aecb41c640deb7a8a49df564f1a7"
+          }
+        },
+        "2f6711f9abe94245a58399b38077abfa": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "2f84b7d105e94f7b88cf8c53d07087fa": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_88ef4ca635394253b00dc164e7f9f51e",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_64748cb1cf2e4d0cbc0ff7b9813fe35b",
+            "value": 20
+          }
+        },
+        "3057a16ecbc6426d9075a63c65eb3788": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "32cdbee5dd984e2ab72df6e9aec7f9e8": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "33991b02f66d42efb8ee9d048df52c8d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "33aa492ce3854ef19c3c1279a2b58a5a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_e5535812c2794fd99bfe3c80c8d924e4",
+              "IPY_MODEL_dc511da3d8034266b6bb8070e0fc4796",
+              "IPY_MODEL_5e0dee9c9cd74a0fb69b16a8f890bbca"
+            ],
+            "layout": "IPY_MODEL_9b68eb45f4824fe09a35fdfed01e6b84"
+          }
+        },
+        "341283f0354e424aa71f77d60c9728d4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c57a732df20044008081507e45112bac",
+            "placeholder": "​",
+            "style": "IPY_MODEL_8daf659848924936a4bdefb9061a8e5b",
+            "value": "100% 10/10 [00:02&lt;00:00,  7.49it/s]"
+          }
+        },
+        "341ee0c0cc184a6ebbeae4209a36258f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "34ab1d45802044c1a1a8d85691015681": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "354053feba474fefb583661c26bf7546": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_32cdbee5dd984e2ab72df6e9aec7f9e8",
+            "placeholder": "​",
+            "style": "IPY_MODEL_19e04a3cf7204f38bdd130c8204799cf",
+            "value": ""
+          }
+        },
+        "357df50390b4435c8402361fdb2347dd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "35aefb99cd054ca184d12bec5a4de805": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_96147fdf695b4ee489c1b3f6339b746e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_55f9bd1947b043e0b979594892c09e97",
+            "value": "100% 2/2 [00:00&lt;00:00,  2.26it/s]"
+          }
+        },
+        "36ddb9594ed14a6bbb29d8643fc4e44a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ad3209a986974337bf10afd7686ee404",
+            "placeholder": "​",
+            "style": "IPY_MODEL_94cd6a9ef3bc4f8897787bb93d925d17",
+            "value": ""
+          }
+        },
+        "38b5d9bce9924321bb7952c4ee22dfdb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_09fcdf4a98474d218ce6c783fb8bf858",
+            "placeholder": "​",
+            "style": "IPY_MODEL_9e4f6ee70e1942f6aea5ee9e34c4cc36",
+            "value": ""
+          }
+        },
+        "3996067baf8647a3951e00a7e8fc9148": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_97bbead0378d41e2bdcd20c786a69ba5",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0beb88257c7844fa9b8a634d7ebeedc1",
+            "value": "100% 2/2 [00:00&lt;00:00,  2.35it/s]"
+          }
+        },
+        "3bb9c81dc321483abc2b493c57b10e79": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "3c084f1f743f489bb3c7cf30b2dce6f3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3e1af7eb2d39491782da90e20c898b6a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3e20d81230fe4a4ca07892d58a18f8fd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "3fd1b8d27f4e46f8b590e3b7a1711f6a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_566a273b36434f5bbf1d18b11784451f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_662d22de99f34a70a06437434f2bcbce",
+            "value": "[loss] = 0.961, [lr/lr_group0] = 0.044, [nll_loss] = 0.961: 100% 20/20 [00:03&lt;00:00, 11.76it/s]"
+          }
+        },
+        "3fd7e99e5a0e465f8237c3ac795598fc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "402d70f3ae3c484b80e9885ae2ed1bae": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "406ad8da915d4c36ad87532e7884652d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "41b6b4ecd14340beba715f7eff584c90": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "41d8c0c48e9e45468fb80763df83eaf2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "41fe82b4d7d14243b4a7e4d2fc1fa576": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "4290b1c25aa7416b893cf616f3fe0026": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8016e285f13c403793fe8dea69dbe405",
+            "placeholder": "​",
+            "style": "IPY_MODEL_a90459a1164e4658b4e94c3ca27f0a49",
+            "value": "100% 2/2 [00:00&lt;00:00,  3.24it/s]"
+          }
+        },
+        "42e49d1f889a488b82220ac128f523a1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "43356d3e10f34b48ac4e29428a6916d6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8f5d6456620a4c1089cc854e154cc9b4",
+            "placeholder": "​",
+            "style": "IPY_MODEL_64e22301d6e44864b4f751ad6c115858",
+            "value": "[loss] = 0.926, [lr/lr_group0] = 0.0493, [nll_loss] = 0.926: 100% 20/20 [00:03&lt;00:00, 10.11it/s]"
+          }
+        },
+        "4374447a37e449b09111aecb5e216f99": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4390ddd534374a3d98d2d735f7d29dbd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4f66af989a9f4f48b3277a60d40ea457",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b9abf2a5e59340dfa1016e44e083fa9c",
+            "value": "[loss] = 0.948, [lr/lr_group0] = 0.0463, [nll_loss] = 0.948: 100% 20/20 [00:03&lt;00:00,  7.93it/s]"
+          }
+        },
+        "44954230ed0a4fe9a416604c59f6e58e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9a29fe7dd04f4b9f95070a39f0cf2e23",
+            "placeholder": "​",
+            "style": "IPY_MODEL_df57df5495924f95a2c2e3f8855dd121",
+            "value": "[loss] = 0.955, [lr/lr_group0] = 0.05, [nll_loss] = 0.955: 100% 20/20 [00:05&lt;00:00,  5.83it/s]"
+          }
+        },
+        "450d82cf7683448cac6945334ae9c068": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_26e9ae325ca2442a94e02936f2c90ba3",
+              "IPY_MODEL_2c24a443def6444a8a725d0d23d9edda",
+              "IPY_MODEL_56d11a7b0aaa49a4bab83068f166ab38"
+            ],
+            "layout": "IPY_MODEL_5028851f9082480c8be9382d7904e03f"
+          }
+        },
+        "46320ad8dfff492d8cad5e1313981592": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_aba185ddea19446a816c4a865cd26b31",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_9530de20144c4cb3901561e0d725fad2",
+            "value": 20
+          }
+        },
+        "47386360e6a047c0a2398ec506cdf556": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bcb8e1b114ce48459f8bb1ac866b6f75",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7a5cff18459c46a58fe9886adb818338",
+            "value": ""
+          }
+        },
+        "48157fc41bd64f8cbd1dc3e9863eca97": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "48667de2565f4c328a1581c86f14868f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3e1af7eb2d39491782da90e20c898b6a",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b5e0bd5fb9744bebb25efb93dae0b336",
+            "value": ""
+          }
+        },
+        "48684bd4de50427aa5cab57dd6fe7025": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_aa3c59ed265c43ca8a3c2bf12917d8fd",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ac847f2e6efa4e5088cb72e58c59d26d",
+            "value": "100% 10/10 [00:02&lt;00:00,  5.22it/s]"
+          }
+        },
+        "4abd54da2cb64417843d23e6f83f97d9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_ef1fdca48c0448748eca0e1fba68779b",
+              "IPY_MODEL_bffb3950a3614e22b2f8d5213a70d89d",
+              "IPY_MODEL_4c09b008802e4bbfad8b698355056f14"
+            ],
+            "layout": "IPY_MODEL_402d70f3ae3c484b80e9885ae2ed1bae"
+          }
+        },
+        "4c09b008802e4bbfad8b698355056f14": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_d102be0015e244b39b1c595ce91d61a1",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c77ca934fe134c688eadde6035fec218",
+            "value": "[loss] = 0.938, [lr/lr_group0] = 0.0481, [nll_loss] = 0.938: 100% 20/20 [00:03&lt;00:00, 11.76it/s]"
+          }
+        },
+        "4c0a81679d06428a8edb3d5bb00f5849": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_269397ad6d234b779acf2580f3d68082",
+            "placeholder": "​",
+            "style": "IPY_MODEL_549a22d7772149b7a924b2e924ab9ec1",
+            "value": ""
+          }
+        },
+        "4cc5fc352511401dbc4ce88c2727e5be": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4d87f28dce814e9d8a4abf84e30d02b5": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4f66af989a9f4f48b3277a60d40ea457": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5002ef29438248cfb56146eafdb02ff1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "5028851f9082480c8be9382d7904e03f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "503680c2cf6e43589d795cdb3a8cb949": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "507e2b30906e47418f2167cb5d2066db": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "50e44bcb6282447ba718d54b3eb63318": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4374447a37e449b09111aecb5e216f99",
+            "placeholder": "​",
+            "style": "IPY_MODEL_801c8d0b42e14241b6be8a30e2cd9aac",
+            "value": ""
+          }
+        },
+        "5104b0b53c2a420d9654f12cf25e3e55": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "52e606a5d3a44292818324e2be53c136": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "53b7565f0f1f43108a4d945fc60806e3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "53f425d3a97647958077b2322a01bcc3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "549a22d7772149b7a924b2e924ab9ec1": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "55f9bd1947b043e0b979594892c09e97": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "566a273b36434f5bbf1d18b11784451f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "56d11a7b0aaa49a4bab83068f166ab38": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4cc5fc352511401dbc4ce88c2727e5be",
+            "placeholder": "​",
+            "style": "IPY_MODEL_95cd432664bb4effa26233e77c693072",
+            "value": "100% 10/10 [00:03&lt;00:00,  4.10it/s]"
+          }
+        },
+        "572ae926714d4804bb99aa41684720c5": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "583f8afd53e845d99666666e99d6686b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "59e517c7d73e4cb49cbdfa22f2f7f34c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5d9b0a399157483bb79c0936347df4dd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5e0dee9c9cd74a0fb69b16a8f890bbca": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b30f7e59474d4436acad24f4c96a1e1b",
+            "placeholder": "​",
+            "style": "IPY_MODEL_3057a16ecbc6426d9075a63c65eb3788",
+            "value": "[loss] = 0.968, [lr/lr_group0] = 0.0488, [nll_loss] = 0.968: 100% 20/20 [00:04&lt;00:00,  5.94it/s]"
+          }
+        },
+        "627f1f3b5a1e40d5a83b1046e22c0167": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "636475475f6e4a34bf8155893d6384b9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_d8ad739fe8084b93866f38c03c313a3a",
+              "IPY_MODEL_e7fa725880394a43a300427f4b78d6f9",
+              "IPY_MODEL_2c86523ea4d5464cb6350c08e925cd15"
+            ],
+            "layout": "IPY_MODEL_981878f4289e4a2ba88a37be13182325"
+          }
+        },
+        "643044d3241e42acac6caa904c427672": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3c084f1f743f489bb3c7cf30b2dce6f3",
+            "placeholder": "​",
+            "style": "IPY_MODEL_3e20d81230fe4a4ca07892d58a18f8fd",
+            "value": "100% 10/10 [00:02&lt;00:00,  5.79it/s]"
+          }
+        },
+        "64748cb1cf2e4d0cbc0ff7b9813fe35b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "64e22301d6e44864b4f751ad6c115858": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "6538daa9bb3b498d96332c98b1f7d723": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "65fc01a8608846d185bac6a498c4694c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_103457d1e98b434dbbdbfac203bf9b90",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1d975fd51c7c49b0aa19b1635b98bc2f",
+            "value": ""
+          }
+        },
+        "662d22de99f34a70a06437434f2bcbce": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "67b0bb206ef64cb4a2336d2d5a396736": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "689257a51152408db4d93f98d0e62a78": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "68ed37e451e0498f9ed9fd2ea2a5531b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "6a39c54e39b048cb86056b70fc0fd224": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6b308556ac31444f86374ea813396b75": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0fefed8032784463ba00125da7211e45",
+            "placeholder": "​",
+            "style": "IPY_MODEL_17fb1d205d124628b13ec46fcda73014",
+            "value": "100% 2/2 [00:00&lt;00:00,  1.81it/s]"
+          }
+        },
+        "6b518ce880a94960940419502f7c1a2b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_b6c11c998990444db71e45ed7f9f03a8",
+              "IPY_MODEL_f00d610a35054ee98b323d9bbca3d4a9",
+              "IPY_MODEL_4290b1c25aa7416b893cf616f3fe0026"
+            ],
+            "layout": "IPY_MODEL_a724beaae3ca4b9a869066a01e59f820"
+          }
+        },
+        "6cf3bea675b040aabf28a88694280385": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0b4d00274f3345cc916460ab7de92d88",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e5558cda2ad74becb5a20cff6b1195b8",
+            "value": ""
+          }
+        },
+        "6d4e5f40efd64ac5b6d69754472ccf36": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "6d856a27234c4437b3ec49ca4eeca36d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0c8d3178f8294b50896c13599aef3b2a",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_fae629f7891846c6bd4eb39795053d6b",
+            "value": 20
+          }
+        },
+        "6de2285eac56405bb60a3e3c7f4c21d9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6e5bc2858bc342fb95383ec05ec1ed50": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "6e70c2e613ec42b4bc33a061061715da": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_abbbe2a017e9404dbcbf508200bbd0db",
+              "IPY_MODEL_abaccc36cc594169b77db02b2ebeb338",
+              "IPY_MODEL_2173dc5a2a634147abce6341e898be35"
+            ],
+            "layout": "IPY_MODEL_adb11afff90142c9bd09dbc7f1a0d1c5"
+          }
+        },
+        "6fb2cdd8154940eabdcc7a470f26d37e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "6fd236f1aefe4f2c8d6b5a4aa60b8d8b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f6f0dc3debd148d8bcbae13a377428c5",
+            "placeholder": "​",
+            "style": "IPY_MODEL_260cfaccfabd4bd0b82512f6bb5986d4",
+            "value": "[loss] = 0.993, [lr/lr_group0] = 0.0452, [nll_loss] = 0.993: 100% 20/20 [00:03&lt;00:00,  8.74it/s]"
+          }
+        },
+        "703bb37324604fafb616b53c4701af35": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a9d7de20f91e4080a5ff42c405d9d56a",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_c35104a5ca714c43859f7093835f3f5d",
+            "value": 20
+          }
+        },
+        "72766cb0b675414e8118e57a8d59c657": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0d376758033a4fa7bc20389b3f0138e6",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_959d909762044c99a3d5e156511e5214",
+            "value": 10
+          }
+        },
+        "75c90ce2877440f49ea38d31666714a6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "75f9e359e5d343309d6603e2f73cdb14": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "76c01e6c851c4ebbb75392cee6efe39c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "78f3c6c9183649c1804a9169bcbd4fe2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "7993f2d2fe3a4b90a8864a99108f3d86": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_47386360e6a047c0a2398ec506cdf556",
+              "IPY_MODEL_0f8bcacb1fee444e951b1083eed28ef1",
+              "IPY_MODEL_f4a96f3d7fc843f3897067b3d85fc3d7"
+            ],
+            "layout": "IPY_MODEL_061348ef25ef4b96bfe148e0e840b9e0"
+          }
+        },
+        "79f61439f4db45e38c5d3ea1709fa786": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e5b60e57eac84a8daec873bdf663ff78",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_e40f2266ce194eabbf6bde90c195cc3f",
+            "value": 10
+          }
+        },
+        "7a5cff18459c46a58fe9886adb818338": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7b0ee4d02db34b2a8b1896639f54a862": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ba2c117a55784623af4b49a92efa9451",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d855437dc30d4c1db0ab25854763140c",
+            "value": "100% 2/2 [00:00&lt;00:00,  1.54it/s]"
+          }
+        },
+        "7bf9c542e6c84c68a04c9a6f691709af": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7caef7151a9249d8a11960bee05df66b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7d8c09a01dbd44dc8056409402e4e9c7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b9653be5f6554faab6521f15d632fe60",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_41b6b4ecd14340beba715f7eff584c90",
+            "value": 10
+          }
+        },
+        "7ed7914804514338b5142eaca84e8e4c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "7f52ddd7be9a45a78bceba4662d5e985": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0bbf98a8c4ed4ab880307f49206e828d",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_67b0bb206ef64cb4a2336d2d5a396736",
+            "value": 20
+          }
+        },
+        "8016e285f13c403793fe8dea69dbe405": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "801c8d0b42e14241b6be8a30e2cd9aac": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "8295fa5451314e20ba7487ff94c488d9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_10e139bc8cee42489c80ed38b69afbd1",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_aebf3a4dbd344f78b84cb60ed5b90883",
+            "value": 20
+          }
+        },
+        "8328a3bfda174305956041df2dccb259": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "882aaa8ea30149248018563b95d64cef": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_6cf3bea675b040aabf28a88694280385",
+              "IPY_MODEL_79f61439f4db45e38c5d3ea1709fa786",
+              "IPY_MODEL_fd025febe00e4b06a7c9e6204fc08b50"
+            ],
+            "layout": "IPY_MODEL_d9b9fd061ebc4f6f9d9587d17062f3f6"
+          }
+        },
+        "88ef4ca635394253b00dc164e7f9f51e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8913810f447b471e9eb96e11a64c18eb": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8a0dbd18fe094b9cb6991ebb1cc82f8f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8b0e0c61d7d24ccca91e1edccc86a99f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8b937d390a2e431c87aa7d01de20423a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9f384cc0c9bd4f1c96b58b22b094446e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_503680c2cf6e43589d795cdb3a8cb949",
+            "value": ""
+          }
+        },
+        "8bdd09525f45448fa9eec393b9e06082": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_5d9b0a399157483bb79c0936347df4dd",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_f1e2794dd40541399316d77d2ae30c40",
+            "value": 10
+          }
+        },
+        "8cb378b74173480da6069536f3cc752b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8cbe2daaf322456faac28786a25b7dcb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9ac2f647993e4f81b707500fe7fa63cd",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7bf9c542e6c84c68a04c9a6f691709af",
+            "value": ""
+          }
+        },
+        "8daf659848924936a4bdefb9061a8e5b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "8f5d6456620a4c1089cc854e154cc9b4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8f9ab828e3b9431ab57ad94e920618fa": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "902476f4033b4c2e9ca49aaef966e117": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_beec379e14b44b0aaf26bf4fd763c835",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_069ba0d8ae3346aab9b139d55a1d1705",
+            "value": 20
+          }
+        },
+        "91381de219ac47739b8e0907e487583e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "91b38cbeb8ed4466b9bdd6aba89054ef": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_acc7a9864fbd4b5186246aa395f55d0f",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_5104b0b53c2a420d9654f12cf25e3e55",
+            "value": 20
+          }
+        },
+        "926c1b111ae2498bb60241a62046b349": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "94cd6a9ef3bc4f8897787bb93d925d17": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9530de20144c4cb3901561e0d725fad2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "959d909762044c99a3d5e156511e5214": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "95cd432664bb4effa26233e77c693072": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "96147fdf695b4ee489c1b3f6339b746e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "966e4ec0154d47b7bf85bb58eaea6214": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "972e0f1d733b4993a4cae82fc47e124d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6de2285eac56405bb60a3e3c7f4c21d9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_68ed37e451e0498f9ed9fd2ea2a5531b",
+            "value": ""
+          }
+        },
+        "9738d0ac2d50413b8b45fd30d3896e02": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_972e0f1d733b4993a4cae82fc47e124d",
+              "IPY_MODEL_8bdd09525f45448fa9eec393b9e06082",
+              "IPY_MODEL_d7bdad9f9355485695fdbc6f2731fad4"
+            ],
+            "layout": "IPY_MODEL_33991b02f66d42efb8ee9d048df52c8d"
+          }
+        },
+        "97bbead0378d41e2bdcd20c786a69ba5": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "981878f4289e4a2ba88a37be13182325": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "9924545171344c428b7dd60f7d0c8dbd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "992c199e1c85444c9727a0bd2ae5dbd2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_354053feba474fefb583661c26bf7546",
+              "IPY_MODEL_aaa208280ffa4e9ba9aa2dfa9a3e5236",
+              "IPY_MODEL_35aefb99cd054ca184d12bec5a4de805"
+            ],
+            "layout": "IPY_MODEL_6e5bc2858bc342fb95383ec05ec1ed50"
+          }
+        },
+        "9a29fe7dd04f4b9f95070a39f0cf2e23": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9ac2f647993e4f81b707500fe7fa63cd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9b68eb45f4824fe09a35fdfed01e6b84": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "9d834b4705ad47e98da98bbc9a055050": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c994bf6dcda741fab53ee2d31a088fa0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_038c21f6e4b74cd5ac55b78a84de3177",
+            "value": ""
+          }
+        },
+        "9d87317235394b3fa4b7b44b94713d99": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6538daa9bb3b498d96332c98b1f7d723",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2f6711f9abe94245a58399b38077abfa",
+            "value": ""
+          }
+        },
+        "9e4f6ee70e1942f6aea5ee9e34c4cc36": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "9f384cc0c9bd4f1c96b58b22b094446e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9f4589cf946a479fafe3eb505eb85f0f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a022bffd9dc041498a7fde40da0730cc",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_41fe82b4d7d14243b4a7e4d2fc1fa576",
+            "value": 10
+          }
+        },
+        "9ffacb579af6479392fb6d9aa83922bf": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_4c0a81679d06428a8edb3d5bb00f5849",
+              "IPY_MODEL_07b5b61ee48246cca5b1de06d4bcf097",
+              "IPY_MODEL_c43d55b254b443cebd61b8ad84bca9ac"
+            ],
+            "layout": "IPY_MODEL_627f1f3b5a1e40d5a83b1046e22c0167"
+          }
+        },
+        "a022bffd9dc041498a7fde40da0730cc": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a0e5e22ddf6348008b1dc1f0c8b09258": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "a1258da98bbc487d8a2410695c982508": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_dc842e0a59df48169437db4b2106e524",
+            "placeholder": "​",
+            "style": "IPY_MODEL_6fb2cdd8154940eabdcc7a470f26d37e",
+            "value": "[loss] = 0.975, [lr/lr_group0] = 0.0499, [nll_loss] = 0.975: 100% 20/20 [00:03&lt;00:00,  7.75it/s]"
+          }
+        },
+        "a374b54402c9479d843f30d5eb1d3af4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3fd7e99e5a0e465f8237c3ac795598fc",
+            "placeholder": "​",
+            "style": "IPY_MODEL_d142c7694fe843d48efb69cee5a8d379",
+            "value": ""
+          }
+        },
+        "a3f22c44214940ff9cdaf10bd2713aef": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a58081de471048c59120e9bd78448972": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a69129198e784707bab17fa23c75841e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a9f92d8a14a147a9bf7e3db30bc6c269",
+            "placeholder": "​",
+            "style": "IPY_MODEL_c9f6121f05b2496e87b642c3367cb281",
+            "value": "[loss] = 0.971, [lr/lr_group0] = 0.0473, [nll_loss] = 0.971: 100% 20/20 [00:03&lt;00:00, 12.01it/s]"
+          }
+        },
+        "a724beaae3ca4b9a869066a01e59f820": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "a73a24f103a4473d8f91f7ee25b96e7c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "a895bcdda57b48d48a73b7553e1861c1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "a8b986636cbc4ddc8fabd880897db568": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a90459a1164e4658b4e94c3ca27f0a49": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a9d7de20f91e4080a5ff42c405d9d56a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a9f92d8a14a147a9bf7e3db30bc6c269": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "aa3c59ed265c43ca8a3c2bf12917d8fd": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "aaa208280ffa4e9ba9aa2dfa9a3e5236": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f93e99b23ab24f359c2dea674611dbb4",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_3bb9c81dc321483abc2b493c57b10e79",
+            "value": 2
+          }
+        },
+        "aba185ddea19446a816c4a865cd26b31": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "abaccc36cc594169b77db02b2ebeb338": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_bff253bfd785437dbfe3833634923c17",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_da2eca44b4f64f87b52e9a8ac43fa160",
+            "value": 10
+          }
+        },
+        "abbbe2a017e9404dbcbf508200bbd0db": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_357df50390b4435c8402361fdb2347dd",
+            "placeholder": "​",
+            "style": "IPY_MODEL_42e49d1f889a488b82220ac128f523a1",
+            "value": ""
+          }
+        },
+        "ac847f2e6efa4e5088cb72e58c59d26d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "acc7a9864fbd4b5186246aa395f55d0f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ad3209a986974337bf10afd7686ee404": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "adb11afff90142c9bd09dbc7f1a0d1c5": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "ae64800630624d06b600aa63200a7753": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "aeb6c118f3704e35b54f95fecf97657a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8cb378b74173480da6069536f3cc752b",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f015c88c2412411f854871c14388cc5d",
+            "value": ""
+          }
+        },
+        "aebf3a4dbd344f78b84cb60ed5b90883": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "b1223d95dab94ba4a8100c45857c3ef9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b30f7e59474d4436acad24f4c96a1e1b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b3b377399e5b4e9397d5d109a85bfc31": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "b3bfc0a50026417498d814455b3e6528": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "b4eb50d852fd46c9b675caab8070ec36": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "b5273100a9494aeda77459b563e8aeb3": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_ffa89d92b7c84fc598f0a0a7ce28f8db",
+              "IPY_MODEL_703bb37324604fafb616b53c4701af35",
+              "IPY_MODEL_3fd1b8d27f4e46f8b590e3b7a1711f6a"
+            ],
+            "layout": "IPY_MODEL_c96fa78298d147ecbf97232c3f71e130"
+          }
+        },
+        "b5e0bd5fb9744bebb25efb93dae0b336": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "b6c11c998990444db71e45ed7f9f03a8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_21deef013bf44711ac38fb14d1528972",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ede97b2c2d8d46a19ee7a20346ad2a47",
+            "value": ""
+          }
+        },
+        "b7270619be5b4e638c49ab9543ec5610": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_65fc01a8608846d185bac6a498c4694c",
+              "IPY_MODEL_902476f4033b4c2e9ca49aaef966e117",
+              "IPY_MODEL_44954230ed0a4fe9a416604c59f6e58e"
+            ],
+            "layout": "IPY_MODEL_d60ba45ddde4424c96331d083a91a187"
+          }
+        },
+        "b82e7822cc0c4e84852ac2fbe0f9f261": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_36ddb9594ed14a6bbb29d8643fc4e44a",
+              "IPY_MODEL_7f52ddd7be9a45a78bceba4662d5e985",
+              "IPY_MODEL_6fd236f1aefe4f2c8d6b5a4aa60b8d8b"
+            ],
+            "layout": "IPY_MODEL_a895bcdda57b48d48a73b7553e1861c1"
+          }
+        },
+        "b9653be5f6554faab6521f15d632fe60": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "b9abf2a5e59340dfa1016e44e083fa9c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ba2c117a55784623af4b49a92efa9451": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bb53df44d0c740bfac7920a5164c6e70": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bb68b50116cd4f1f9c15fce1770d3105": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "bcb8e1b114ce48459f8bb1ac866b6f75": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bdf39c2a2e8a4a53a85c11d6b66f48a8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b1223d95dab94ba4a8100c45857c3ef9",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_583f8afd53e845d99666666e99d6686b",
+            "value": 2
+          }
+        },
+        "bec72bacba0b4d5e9d650dfe7ca6e77e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1b13c08c7e55498686b31e6519ab618a",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_689257a51152408db4d93f98d0e62a78",
+            "value": 2
+          }
+        },
+        "beec379e14b44b0aaf26bf4fd763c835": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "beec965b8b4041e19f1c3174912c3e9d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_edee16194d7942eca9da9ad77ae9dfed",
+              "IPY_MODEL_1adf8644607a4e788e6a9e40fcb586d7",
+              "IPY_MODEL_efc27cac36474b2c941615f463689315"
+            ],
+            "layout": "IPY_MODEL_03d6ca44703548279c08017b47e9b29e"
+          }
+        },
+        "bff253bfd785437dbfe3833634923c17": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "bffb3950a3614e22b2f8d5213a70d89d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a3f22c44214940ff9cdaf10bd2713aef",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_76c01e6c851c4ebbb75392cee6efe39c",
+            "value": 20
+          }
+        },
+        "c2a62d7bb77f486f8d36858a488672dd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_db68e578f6d8407793150c2f48a9b7b9",
+              "IPY_MODEL_91b38cbeb8ed4466b9bdd6aba89054ef",
+              "IPY_MODEL_4390ddd534374a3d98d2d735f7d29dbd"
+            ],
+            "layout": "IPY_MODEL_d743dc1d02984af791662404a86b8cce"
+          }
+        },
+        "c35104a5ca714c43859f7093835f3f5d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "c43d55b254b443cebd61b8ad84bca9ac": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2a32af82ab86434fa38c169ea82d762f",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e30a841229f3449cb0bab37a0ac662ee",
+            "value": "100% 10/10 [00:02&lt;00:00,  6.36it/s]"
+          }
+        },
+        "c4c7988172154020abf7ca546250bd45": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c57a732df20044008081507e45112bac": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c5fa73b8e5c14a18aff3934e3a3998ce": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_9d834b4705ad47e98da98bbc9a055050",
+              "IPY_MODEL_8295fa5451314e20ba7487ff94c488d9",
+              "IPY_MODEL_a69129198e784707bab17fa23c75841e"
+            ],
+            "layout": "IPY_MODEL_a0e5e22ddf6348008b1dc1f0c8b09258"
+          }
+        },
+        "c77ca934fe134c688eadde6035fec218": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c96fa78298d147ecbf97232c3f71e130": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "c994bf6dcda741fab53ee2d31a088fa0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "c9f6121f05b2496e87b642c3367cb281": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ca6f696005594623b23a425758e7d195": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ce13cadf5f94487696c870f956f41147": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ce22ae9633ce44f0bed4017bbf9be9da": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_91381de219ac47739b8e0907e487583e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0a45c5c6690947f9abfb5e8c13c78826",
+            "value": ""
+          }
+        },
+        "ceb7e9da20e0440382d80bbe23580848": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_f4c1939a308544b8aad47c011eaeb07b",
+              "IPY_MODEL_6d856a27234c4437b3ec49ca4eeca36d",
+              "IPY_MODEL_a1258da98bbc487d8a2410695c982508"
+            ],
+            "layout": "IPY_MODEL_1199ffb349584d7599d7240e26653580"
+          }
+        },
+        "cee3af91f7214e56bc95fbd90bf42bd7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f413b4a0bc1c4552b09ff74c0488dfc6",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b3b377399e5b4e9397d5d109a85bfc31",
+            "value": "100% 2/2 [00:00&lt;00:00,  1.25it/s]"
+          }
+        },
+        "d102be0015e244b39b1c595ce91d61a1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d142c7694fe843d48efb69cee5a8d379": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d3320caa762546d5b68f862bfda1a610": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_9d87317235394b3fa4b7b44b94713d99",
+              "IPY_MODEL_243a82ddfc734be397b896db73d600e8",
+              "IPY_MODEL_643044d3241e42acac6caa904c427672"
+            ],
+            "layout": "IPY_MODEL_a73a24f103a4473d8f91f7ee25b96e7c"
+          }
+        },
+        "d39f14ae61084b55abb92b9d6ac7706e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "d4a89367fa5a48fb958da89c8b7bb967": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d60ba45ddde4424c96331d083a91a187": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "d61e3e1f14e744938d52212992818ec5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "d72d47d862fd4df9a570e43a1b47679d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_48667de2565f4c328a1581c86f14868f",
+              "IPY_MODEL_72766cb0b675414e8118e57a8d59c657",
+              "IPY_MODEL_341283f0354e424aa71f77d60c9728d4"
+            ],
+            "layout": "IPY_MODEL_fa819a6082c34f6faa10444f15f62868"
+          }
+        },
+        "d739f5cb184f49b8b61ab4b4edc6646d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "d743dc1d02984af791662404a86b8cce": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "d7bdad9f9355485695fdbc6f2731fad4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4d87f28dce814e9d8a4abf84e30d02b5",
+            "placeholder": "​",
+            "style": "IPY_MODEL_01c6b75083b949afab571f99ea5f2275",
+            "value": "100% 10/10 [00:01&lt;00:00,  7.65it/s]"
+          }
+        },
+        "d7dc40674fcf4ef28415ccb421abe09a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "d855437dc30d4c1db0ab25854763140c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "d8ad739fe8084b93866f38c03c313a3a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0507291838064afdaa0612f7e137344a",
+            "placeholder": "​",
+            "style": "IPY_MODEL_53f425d3a97647958077b2322a01bcc3",
+            "value": ""
+          }
+        },
+        "d9b9fd061ebc4f6f9d9587d17062f3f6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "da2eca44b4f64f87b52e9a8ac43fa160": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "db2ba0d15e7c43f49b2c8f8b1f15aafb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "db68e578f6d8407793150c2f48a9b7b9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_406ad8da915d4c36ad87532e7884652d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_db2ba0d15e7c43f49b2c8f8b1f15aafb",
+            "value": ""
+          }
+        },
+        "dc511da3d8034266b6bb8070e0fc4796": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_78f3c6c9183649c1804a9169bcbd4fe2",
+            "max": 20,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d39f14ae61084b55abb92b9d6ac7706e",
+            "value": 20
+          }
+        },
+        "dc842e0a59df48169437db4b2106e524": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ddc20c1e23e348f69980e0c37736409e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8913810f447b471e9eb96e11a64c18eb",
+            "placeholder": "​",
+            "style": "IPY_MODEL_12d65b7f3cda42b784484a31f672e379",
+            "value": ""
+          }
+        },
+        "de3afeb45f8e4775b9b55bec37bdc9f2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "de534eba45b74551a7d8ba5e90971f12": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_38b5d9bce9924321bb7952c4ee22dfdb",
+              "IPY_MODEL_ec0105fb3abe4f4db387b4a98d38cc71",
+              "IPY_MODEL_3996067baf8647a3951e00a7e8fc9148"
+            ],
+            "layout": "IPY_MODEL_b4eb50d852fd46c9b675caab8070ec36"
+          }
+        },
+        "df57df5495924f95a2c2e3f8855dd121": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "e0ce8f98ad1c4e639a86daf88cd844a3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e30a841229f3449cb0bab37a0ac662ee": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "e40f2266ce194eabbf6bde90c195cc3f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "e4d556d781194a018bcdb0768abf2584": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_286cca83cfa14b57ad63fd90baafe6fe",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_0e72173e1bdc4787ad92102d0a60015e",
+            "value": 2
+          }
+        },
+        "e5535812c2794fd99bfe3c80c8d924e4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_010a745b57464f218702d4e8e4f6a9c1",
+            "placeholder": "​",
+            "style": "IPY_MODEL_41d8c0c48e9e45468fb80763df83eaf2",
+            "value": ""
+          }
+        },
+        "e5558cda2ad74becb5a20cff6b1195b8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "e5b60e57eac84a8daec873bdf663ff78": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e6d37796e8864a0a95b0054bdcbcbc82": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_8cbe2daaf322456faac28786a25b7dcb",
+              "IPY_MODEL_e7fce353e9504f92b21375925733b402",
+              "IPY_MODEL_48684bd4de50427aa5cab57dd6fe7025"
+            ],
+            "layout": "IPY_MODEL_f908a82f4d8b4c4e8c35bb7fc02dabba"
+          }
+        },
+        "e7fa725880394a43a300427f4b78d6f9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_de3afeb45f8e4775b9b55bec37bdc9f2",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_8f9ab828e3b9431ab57ad94e920618fa",
+            "value": 2
+          }
+        },
+        "e7fce353e9504f92b21375925733b402": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_eb872d3f694c45bb9297c9a37c738b06",
+            "max": 10,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_966e4ec0154d47b7bf85bb58eaea6214",
+            "value": 10
+          }
+        },
+        "e8104b737efc41c5a0615d71fe2f4d6c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HBoxModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_07af6b31efdb48f28689ff413c23eb55",
+              "IPY_MODEL_bdf39c2a2e8a4a53a85c11d6b66f48a8",
+              "IPY_MODEL_cee3af91f7214e56bc95fbd90bf42bd7"
+            ],
+            "layout": "IPY_MODEL_224d3297cd20417d906a062c09218b7b"
+          }
+        },
+        "eb872d3f694c45bb9297c9a37c738b06": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ebeac59943ed4e5d9448b3e395037cbe": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ec0105fb3abe4f4db387b4a98d38cc71": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_8328a3bfda174305956041df2dccb259",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_6d4e5f40efd64ac5b6d69754472ccf36",
+            "value": 2
+          }
+        },
+        "ede492733ddf4971bad1be522bd1472d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ede97b2c2d8d46a19ee7a20346ad2a47": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "edee16194d7942eca9da9ad77ae9dfed": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ca6f696005594623b23a425758e7d195",
+            "placeholder": "​",
+            "style": "IPY_MODEL_fe2d0b0e31ee438c94b25a463d400e60",
+            "value": ""
+          }
+        },
+        "ef1fdca48c0448748eca0e1fba68779b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6a39c54e39b048cb86056b70fc0fd224",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7ed7914804514338b5142eaca84e8e4c",
+            "value": ""
+          }
+        },
+        "efc27cac36474b2c941615f463689315": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ede492733ddf4971bad1be522bd1472d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2a16922810434bcf86dcd87d7d75c666",
+            "value": "100% 2/2 [00:00&lt;00:00,  1.55it/s]"
+          }
+        },
+        "f00d610a35054ee98b323d9bbca3d4a9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f539b3c6e85749799d3466df9ad2fe4b",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_d7dc40674fcf4ef28415ccb421abe09a",
+            "value": 2
+          }
+        },
+        "f015c88c2412411f854871c14388cc5d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f12f039497c646bdabf7f735e7973665": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "f1e2794dd40541399316d77d2ae30c40": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "f413b4a0bc1c4552b09ff74c0488dfc6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f4a96f3d7fc843f3897067b3d85fc3d7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2536dbeb6dce4c3aa1700905c35d20e0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0bed638168604ded86989c465fc4564f",
+            "value": "100% 2/2 [00:00&lt;00:00,  1.51it/s]"
+          }
+        },
+        "f4c1939a308544b8aad47c011eaeb07b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_48157fc41bd64f8cbd1dc3e9863eca97",
+            "placeholder": "​",
+            "style": "IPY_MODEL_01a717c12a494f9bade13620b195cfd9",
+            "value": ""
+          }
+        },
+        "f539b3c6e85749799d3466df9ad2fe4b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f5e24770e5e341e39b341869796db2a7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "FloatProgressModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c4c7988172154020abf7ca546250bd45",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_ae64800630624d06b600aa63200a7753",
+            "value": 2
+          }
+        },
+        "f6f0dc3debd148d8bcbae13a377428c5": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f87c90bdb92448858a56abc98f311705": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f908a82f4d8b4c4e8c35bb7fc02dabba": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "f93e99b23ab24f359c2dea674611dbb4": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": "2",
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f9d771a613144a18ab0271812bd3842b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "fa42eb82e5b944ed92c8e1e4282f78c2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "fa819a6082c34f6faa10444f15f62868": {
+          "model_module": "@jupyter-widgets/base",
+          "model_module_version": "1.2.0",
+          "model_name": "LayoutModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": "inline-flex",
+            "flex": null,
+            "flex_flow": "row wrap",
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "0"
+          }
+        },
+        "fae629f7891846c6bd4eb39795053d6b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "ProgressStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "fd025febe00e4b06a7c9e6204fc08b50": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a8b986636cbc4ddc8fabd880897db568",
+            "placeholder": "​",
+            "style": "IPY_MODEL_34ab1d45802044c1a1a8d85691015681",
+            "value": "100% 10/10 [00:01&lt;00:00,  7.63it/s]"
+          }
+        },
+        "fe2d0b0e31ee438c94b25a463d400e60": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "DescriptionStyleModel",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "ffa89d92b7c84fc598f0a0a7ce28f8db": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_module_version": "1.5.0",
+          "model_name": "HTMLModel",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_15b84bc102f3475d877a034f8ca06e78",
+            "placeholder": "​",
+            "style": "IPY_MODEL_75c90ce2877440f49ea38d31666714a6",
+            "value": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}