From 7075b37231b03ab360473eab073e88835f4c3551 Mon Sep 17 00:00:00 2001 From: Yashar Zolmajdi <49378236+yasharzolmajdi@users.noreply.github.com> Date: Fri, 23 Aug 2024 15:10:20 +1000 Subject: [PATCH] feat: Add fire-opal get started doc (#2) --- .../discover/start-using/get-started.ipynb | 796 ++++++++++++++++++ 1 file changed, 796 insertions(+) create mode 100644 fire-opal/discover/start-using/get-started.ipynb diff --git a/fire-opal/discover/start-using/get-started.ipynb b/fire-opal/discover/start-using/get-started.ipynb new file mode 100644 index 0000000..464f885 --- /dev/null +++ b/fire-opal/discover/start-using/get-started.ipynb @@ -0,0 +1,796 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "fac33785", + "metadata": {}, + "source": [ + "# Get started\n", + "\n", + "**Fire Opal at a glance and quickstart**\n", + "\n", + "## Fire Opal overview\n", + "\n", + "Fire Opal is a Python package that applies a complete suite of error suppression techniques to vastly improve the quality of quantum algorithm results, often transforming quantum computer outputs from random to useful. For an in-depth explanation of Fire Opal's benefits and capabilities, check out the Fire Opal overview.\n", + "\n", + "This tutorial will run through the steps to set up Fire Opal and use it to run a Bernstein–Vazirani circuit. After completion, you will have demonstrated Fire Opal's benefits by comparing the success probabilities of executing the circuit with both Fire Opal and Qiskit. " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "5d1fff91", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "### 1. Sign up for an account\n", + "\n", + "You will need to [sign up for a Q-CTRL account](https://q-ctrl.com/fire-opal) to run the Fire Opal package.\n", + "\n", + "### 2. Install Fire Opal Python package\n", + "\n", + "Refer to [how to set up your environment and install Fire Opal](https://docs.q-ctrl.com/fire-opal/user-guides/how-to-set-up-your-environment-and-install-fire-opal) for more detailed information on how to set up your development environment to run Fire Opal. If you already have Python and a package manager installed, you can use the following command to install the necessary packages:\n", + "\n", + "```shell\n", + "pip install fire-opal qiskit matplotlib qiskit-ibm-runtime qctrl-visualizer\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "e69b7bc9", + "metadata": { + "pycharm": { + "is_executing": true + } + }, + "outputs": [], + "source": [ + "%pip install fire-opal qiskit matplotlib qiskit-ibm-runtime qctrl-visualizer -q\n", + "import fireopal as fo\n", + "import qiskit\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "import matplotlib.pyplot as plt\n", + "import qctrlvisualizer as qv\n", + "\n", + "plt.style.use(qv.get_qctrl_style())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ac41bad3", + "metadata": {}, + "source": [ + "#### 2.1. Specify your organization\n", + "If your Q-CTRL account is a member of multiple organizations, you must specify which organization to use by setting the organization parameter, as shown below. You can check organization names and other details by visiting your [Q-CTRL account](https://accounts.q-ctrl.com/). \n", + "\n", + "If your account details show multiple organizations, replace `organization_slug` with the unique identifier listed in your organization details. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9edc69de", + "metadata": {}, + "outputs": [], + "source": [ + "# Uncomment and replace \"organization_slug\" if you are a member of multiple Q-CTRL organizations\n", + "# fo.config.configure_organization(organization_slug=\"organization_slug\")\n", + "\n", + "# Uncomment and replace \"q-ctrl-token\" with your API key, which you can find at https://accounts.q-ctrl.com/security\n", + "# fo.authenticate_qctrl_account(\"q-ctrl-token\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "2c320b83", + "metadata": {}, + "source": [ + "### 3. Sign up for an IBM Quantum account\n", + "While Fire Opal's techology is inherently backend agnostic, in this tutorial we will run the circuit on an IBM Quantum backend device. \n", + "\n", + "You will need to [sign up](https://quantum.ibm.com/) for an IBM Quantum account, which you can use to access devices on the Open or Premium IBM Quantum plans. Simply input your hub, group, project, and access token to the [`make_credentials_for_ibmq`](https://docs.q-ctrl.com/references/fire-opal/fireopal/fireopal.credentials.make_credentials_for_ibmq.html) function.\n", + "\n", + "Alternatively, you can [authenticate with IBM Cloud](https://docs.q-ctrl.com/references/fire-opal/fireopal/fireopal.credentials.make_credentials_for_ibmq.html). Visit the documentation for more information on how to [get started](https://cloud.ibm.com/docs/quantum-computing?topic=quantum-computing-get-started).\n", + "\n", + "**Note:** IBM Quantum offers public access to some of their quantum computers. However, queue times for public systems can be long, which will cause delays in the execution steps of this guide (steps 5 and 7). These delays are extraneous to Fire Opal." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "188d827b", + "metadata": {}, + "source": [ + "## Demo: Running the Bernstein–Vazirani algorithm with Fire Opal\n", + "\n", + "We'll use Fire Opal to run a Bernstein–Vazirani circuit. This algorithm is broadly used to find a string from the outputs of a black box function, though this information is not necessary for the sake of running this example." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "dc2c48dc", + "metadata": {}, + "source": [ + "### 1. Define helper functions\n", + "\n", + "We will start by defining three helper functions:\n", + "- `draw_circuit`: draws our QASM circuit\n", + "- `plot_bv_results`: plots the results of our experiments\n", + "- `bitstring_count_to_probabilities`: converts bitstring counts to probabilities" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "58912482", + "metadata": {}, + "outputs": [], + "source": [ + "shot_count = 2048\n", + "\n", + "\n", + "def draw_circuit(qasm_str: str):\n", + " \"\"\"Draws a QASM circuit.\"\"\"\n", + " circuit = qiskit.QuantumCircuit.from_qasm_str(qasm_str)\n", + " display(circuit.draw(fold=-1))\n", + "\n", + "\n", + "def plot_bv_results(results, hidden_string, title=\"\", max_columns=None):\n", + " \"\"\"\n", + " Plot a probability histogram and highlight the hidden string.\n", + " \"\"\"\n", + "\n", + " # Restrict the number of columns displayed.\n", + " if max_columns is not None:\n", + " top_strings = sorted(results.keys(), key=lambda x: results[x], reverse=True)[\n", + " :max_columns\n", + " ]\n", + " if hidden_string not in top_strings:\n", + " top_strings.append(hidden_string)\n", + " results = {s: results.get(s, 0) for s in top_strings}\n", + "\n", + " bitstrings = sorted(results.keys())\n", + "\n", + " def to_probability(value, total):\n", + " if isinstance(value, float):\n", + " return value\n", + " return value / total\n", + "\n", + " probabilities = [to_probability(results[b], shot_count) for b in bitstrings]\n", + " plt.figure(figsize=(20, 5))\n", + " bars = plt.bar(bitstrings, probabilities)\n", + " plt.xticks(rotation=90)\n", + "\n", + " for index, bitstring in enumerate(bitstrings):\n", + " if bitstring != hidden_string:\n", + " bars[index].set_color(\"grey\")\n", + "\n", + " plt.ylabel(\"Probability\")\n", + " plt.ylim([0, 1])\n", + " plt.title(title)\n", + " plt.show()\n", + "\n", + "\n", + "def bitstring_count_to_probabilities(data, shot_count, number_of_counting_qubits):\n", + " \"\"\"\n", + " Process the results.\n", + " This function turns a dictionary of bitstring counts into a dictionary\n", + " of probabilities.\n", + " \"\"\"\n", + " probabilities = {\n", + " format(int(bitstring, 2), f\"0{number_of_counting_qubits}b\"): (\n", + " bitstring_count / shot_count\n", + " )\n", + " for bitstring, bitstring_count in data.items()\n", + " }\n", + "\n", + " return probabilities" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "3f5e35b0", + "metadata": {}, + "source": [ + "### 2. Provide the quantum circuit\n", + "\n", + "Here, we will define the Bernstein–Vazirani circuit as an [OpenQASM](https://openqasm.com/) string and visualize it using our previously defined helper function `draw_circuit`. Such a string can also be generated by exporting a quantum circuit written with any quantum-specific Python library." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a8082360", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
      ┌───┐                                                                                                     ░ ┌───┐ ░ ┌─┐                                                      \n",
+       " q_0: ┤ H ├───────■─────────────────────────────────────────────────────────────────────────────────────────────░─┤ H ├─░─┤M├──────────────────────────────────────────────────────\n",
+       "      ├───┤       │                                                                                             ░ ├───┤ ░ └╥┘┌─┐                                                   \n",
+       " q_1: ┤ H ├───────┼────■────────────────────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫─┤M├───────────────────────────────────────────────────\n",
+       "      ├───┤       │    │                                                                                        ░ ├───┤ ░  ║ └╥┘┌─┐                                                \n",
+       " q_2: ┤ H ├───────┼────┼────■───────────────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫─┤M├────────────────────────────────────────────────\n",
+       "      ├───┤       │    │    │                                                                                   ░ ├───┤ ░  ║  ║ └╥┘┌─┐                                             \n",
+       " q_3: ┤ H ├───────┼────┼────┼────■──────────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫─┤M├─────────────────────────────────────────────\n",
+       "      ├───┤       │    │    │    │                                                                              ░ ├───┤ ░  ║  ║  ║ └╥┘┌─┐                                          \n",
+       " q_4: ┤ H ├───────┼────┼────┼────┼────■─────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫─┤M├──────────────────────────────────────────\n",
+       "      ├───┤       │    │    │    │    │                                                                         ░ ├───┤ ░  ║  ║  ║  ║ └╥┘┌─┐                                       \n",
+       " q_5: ┤ H ├───────┼────┼────┼────┼────┼────■────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫─┤M├───────────────────────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │                                                                    ░ ├───┤ ░  ║  ║  ║  ║  ║ └╥┘┌─┐                                    \n",
+       " q_6: ┤ H ├───────┼────┼────┼────┼────┼────┼────■───────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫─┤M├────────────────────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │                                                               ░ ├───┤ ░  ║  ║  ║  ║  ║  ║ └╥┘┌─┐                                 \n",
+       " q_7: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────■──────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫─┤M├─────────────────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │                                                          ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐                              \n",
+       " q_8: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────■─────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫─┤M├──────────────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │                                                     ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐                           \n",
+       " q_9: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────■────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───────────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │                                                ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐                        \n",
+       "q_10: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■───────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├────────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │                                           ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐                     \n",
+       "q_11: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■──────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├─────────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │                                      ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐                  \n",
+       "q_12: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■─────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├──────────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │    │                                 ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐               \n",
+       "q_13: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │    │    │                            ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐            \n",
+       "q_14: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■───────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├────────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │    │    │    │                       ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐         \n",
+       "q_15: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■──────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├─────────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │                  ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐      \n",
+       "q_16: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■─────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├──────\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │             ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐   \n",
+       "q_17: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───\n",
+       "      ├───┤       │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │    │        ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘┌─┐\n",
+       "q_18: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■───░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├\n",
+       "      ├───┤┌───┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐ ░ ├───┤ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ └╥┘\n",
+       "q_19: ┤ X ├┤ H ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├─░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─\n",
+       "      └───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘ ░ └───┘ ░  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║  ║ \n",
+       "c: 19/═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩═\n",
+       "                                                                                                                           0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18
" + ], + "text/plain": [ + " ┌───┐ ░ ┌───┐ ░ ┌─┐ \n", + " q_0: ┤ H ├───────■─────────────────────────────────────────────────────────────────────────────────────────────░─┤ H ├─░─┤M├──────────────────────────────────────────────────────\n", + " ├───┤ │ ░ ├───┤ ░ └╥┘┌─┐ \n", + " q_1: ┤ H ├───────┼────■────────────────────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫─┤M├───────────────────────────────────────────────────\n", + " ├───┤ │ │ ░ ├───┤ ░ ║ └╥┘┌─┐ \n", + " q_2: ┤ H ├───────┼────┼────■───────────────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫─┤M├────────────────────────────────────────────────\n", + " ├───┤ │ │ │ ░ ├───┤ ░ ║ ║ └╥┘┌─┐ \n", + " q_3: ┤ H ├───────┼────┼────┼────■──────────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫─┤M├─────────────────────────────────────────────\n", + " ├───┤ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ └╥┘┌─┐ \n", + " q_4: ┤ H ├───────┼────┼────┼────┼────■─────────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫─┤M├──────────────────────────────────────────\n", + " ├───┤ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_5: ┤ H ├───────┼────┼────┼────┼────┼────■────────────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫─┤M├───────────────────────────────────────\n", + " ├───┤ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_6: ┤ H ├───────┼────┼────┼────┼────┼────┼────■───────────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫─┤M├────────────────────────────────────\n", + " ├───┤ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_7: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────■──────────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫─┤M├─────────────────────────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_8: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────■─────────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫─┤M├──────────────────────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + " q_9: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────■────────────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───────────────────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_10: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■───────────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├────────────────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_11: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■──────────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├─────────────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_12: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■─────────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├──────────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_13: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■────────────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_14: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■───────────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├────────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_15: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■──────────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├─────────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_16: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■─────────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├──────\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐ \n", + "q_17: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■────────░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├───\n", + " ├───┤ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘┌─┐\n", + "q_18: ┤ H ├───────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────■───░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─┤M├\n", + " ├───┤┌───┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐┌─┴─┐ ░ ├───┤ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ └╥┘\n", + "q_19: ┤ X ├┤ H ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├┤ X ├─░─┤ H ├─░──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫──╫─\n", + " └───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘└───┘ ░ └───┘ ░ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ ║ \n", + "c: 19/═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩══╩═\n", + " 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hidden_string = \"1111111111111111111\"\n", + "\n", + "circuit_qasm = (\n", + " circuit_qasm\n", + ") = \"\"\"\n", + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q[20];\n", + "creg c[19];\n", + "x q[19];\n", + "h q[0];\n", + "h q[1];\n", + "h q[2];\n", + "h q[3];\n", + "h q[4];\n", + "h q[5];\n", + "h q[6];\n", + "h q[7];\n", + "h q[8];\n", + "h q[9];\n", + "h q[10];\n", + "h q[11];\n", + "h q[12];\n", + "h q[13];\n", + "h q[14];\n", + "h q[15];\n", + "h q[16];\n", + "h q[17];\n", + "h q[18];\n", + "h q[19];\n", + "cx q[0],q[19];\n", + "cx q[1],q[19];\n", + "cx q[2],q[19];\n", + "cx q[3],q[19];\n", + "cx q[4],q[19];\n", + "cx q[5],q[19];\n", + "cx q[6],q[19];\n", + "cx q[7],q[19];\n", + "cx q[8],q[19];\n", + "cx q[9],q[19];\n", + "cx q[10],q[19];\n", + "cx q[11],q[19];\n", + "cx q[12],q[19];\n", + "cx q[13],q[19];\n", + "cx q[14],q[19];\n", + "cx q[15],q[19];\n", + "cx q[16],q[19];\n", + "cx q[17],q[19];\n", + "cx q[18],q[19];\n", + "barrier q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9],q[10],q[11],q[12],q[13],q[14],q[15],q[16],q[17],q[18],q[19];\n", + "h q[0];\n", + "h q[1];\n", + "h q[2];\n", + "h q[3];\n", + "h q[4];\n", + "h q[5];\n", + "h q[6];\n", + "h q[7];\n", + "h q[8];\n", + "h q[9];\n", + "h q[10];\n", + "h q[11];\n", + "h q[12];\n", + "h q[13];\n", + "h q[14];\n", + "h q[15];\n", + "h q[16];\n", + "h q[17];\n", + "h q[18];\n", + "h q[19];\n", + "barrier q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9],q[10],q[11],q[12],q[13],q[14],q[15],q[16],q[17],q[18],q[19];\n", + "measure q[0] -> c[0];\n", + "measure q[1] -> c[1];\n", + "measure q[2] -> c[2];\n", + "measure q[3] -> c[3];\n", + "measure q[4] -> c[4];\n", + "measure q[5] -> c[5];\n", + "measure q[6] -> c[6];\n", + "measure q[7] -> c[7];\n", + "measure q[8] -> c[8];\n", + "measure q[9] -> c[9];\n", + "measure q[10] -> c[10];\n", + "measure q[11] -> c[11];\n", + "measure q[12] -> c[12];\n", + "measure q[13] -> c[13];\n", + "measure q[14] -> c[14];\n", + "measure q[15] -> c[15];\n", + "measure q[16] -> c[16];\n", + "measure q[17] -> c[17];\n", + "measure q[18] -> c[18];\"\"\"\n", + "draw_circuit(circuit_qasm)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "7a0767ed", + "metadata": {}, + "source": [ + "### 3. Provide your device information and credentials\n", + "\n", + "Next, we'll provide device information for the real hardware backend. Fire Opal will execute the circuit on the backend on your behalf, and it is designed to work seamlessly across multiple backend providers. For this example, we will use an IBM Quantum hardware device. \n", + "\n", + "Note that the code below requires your IBM Quantum API token. Visit [IBM Quantum](https://quantum.ibm.com/) to sign up for an account and obtain your access credentials." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ef17a083", + "metadata": {}, + "outputs": [], + "source": [ + "# These are the properties for the publicly available provider for IBM backends.\n", + "# If you have access to a private provider and wish to use it, replace these values.\n", + "hub = \"ibm-q\"\n", + "group = \"open\"\n", + "project = \"main\"\n", + "token = \"YOUR_IBM_TOKEN\"\n", + "credentials = fo.credentials.make_credentials_for_ibmq(\n", + " token=token, hub=hub, group=group, project=project\n", + ")\n", + "\n", + "service = QiskitRuntimeService(\n", + " token=token, instance=hub + \"/\" + group + \"/\" + project, channel=\"ibm_quantum\"\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "a221f3a2", + "metadata": {}, + "source": [ + "Next we will use the function `show_supported_devices` to list the devices that are both supported by Fire Opal and accessible to you when using the `credentials` above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f998348", + "metadata": {}, + "outputs": [], + "source": [ + "supported_devices = fo.show_supported_devices(credentials=credentials)[\n", + " \"supported_devices\"\n", + "]\n", + "for name in supported_devices:\n", + " print(name)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f6b4036c", + "metadata": {}, + "source": [ + "From the resulting list, you can choose a backend device and replace `\"desired_backend\"`. The list will only include devices accessible to you." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "866877b2", + "metadata": {}, + "outputs": [], + "source": [ + "# Enter your desired IBM backend here or select one with a small queue\n", + "backend_name = \"desired_backend\"\n", + "print(f\"Will run on backend: {backend_name}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "29527972", + "metadata": {}, + "source": [ + "### 4. Validate the circuit and backend\n", + "\n", + "Now that we have defined our credentials and are able to select a device we wish to use, we can validate that Fire Opal can compile our circuit, and that it's compatible with the indicated backend. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c476b4e", + "metadata": {}, + "outputs": [], + "source": [ + "validate_results = fo.validate(\n", + " circuits=[circuit_qasm], credentials=credentials, backend_name=backend_name\n", + ")\n", + "\n", + "if validate_results[\"results\"] == []:\n", + " print(\"No errors found.\")\n", + "else:\n", + " print(\"The following errors were found:\")\n", + " for error in validate_results[\"results\"]:\n", + " print(error)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "65c1edca", + "metadata": {}, + "source": [ + "In this previous example, the output should be an empty list since there are no errors in the circuit, i.e. `validate_results[\"results\"] == []`. \n", + "Note that the length of the `validate_results` list is the total number of errors present across all circuits in a batch.\n", + "Since our circuit is error free, we can execute our circuit on real hardware." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "8dd93ffc", + "metadata": {}, + "source": [ + "### 5. Execute the circuit using Fire Opal\n", + "\n", + "In the absence of hardware noise, only a single experiment would be required to obtain the correct hidden string: `111 111 111 11`. However in real quantum hardware, noise disturbs the state of the system and degrades performance, decreasing the probability of obtaining the correct answer for any single experiment. Fire Opal automates the adjustments made by experts when running circuits on a real device." + ] + }, + { + "cell_type": "markdown", + "id": "244ac624", + "metadata": {}, + "source": [ + "**_Note: Once jobs are submitted, there may be a delay in returning results due to the hardware provider's queue. You can [view and retrieve results later](https://docs.q-ctrl.com/fire-opal/user-guides/how-to-view-previous-jobs-and-retrieve-results). Be sure to let your jobs finish executing, and do not cancel the process. Even in the case of kernel disconnection, the job will still complete, and results can later be retrieved._** " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48cb4b5f08d8833d", + "metadata": {}, + "outputs": [], + "source": [ + "fire_opal_job = fo.execute(\n", + " circuits=[circuit_qasm],\n", + " shot_count=shot_count,\n", + " credentials=credentials,\n", + " backend_name=backend_name,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c8cd4e6", + "metadata": {}, + "outputs": [], + "source": [ + "bitstring_results = fire_opal_job.result()[\"results\"]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "20d569f8", + "metadata": {}, + "source": [ + "### 6. Analyze results\n", + "\n", + "Now you can look at the outputs from the quantum circuit executions. The success probability is simply the number of times the hidden string was obtained out of the total number of circuit shots. For reference, running this circuit on a real device without Fire Opal typically has a success probability of 2-3%. As you can see, Fire Opal greatly improved the success probability." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "e1b9325d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Success probability: 22.93%\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKEAAAHOCAYAAABAXRoPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAAsTAAALEwEAmpwYAACnu0lEQVR4nOzdeXhU5d3/8U8yCQkJ+xKysQgIKKuyySIi/SmCqKWAIC6FujyihT51aRG0gm1RHxVbrFgBLYooUJC6sLmgVBER3BBFEFSQQMAICASyTeb3R8iQkElyH3JOzpzh/bquXBckH865v/c5MxO+c+bcUYFAICAAAAAAAADAQdFuDwAAAAAAAACRjyYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAQkeY9/ZL++dgct4dhC5NajmUf06Tb/6Qf92VV06js9cyM5/T28nfdHgYAAHBQjNsDAAAAOB3znn5JH72/ocz3//iXO5XePE3Dr/+lAgFn9n3owCGtWPqGvvp8i44cPqpadRJ1budzNGjoQNVvUM+ZnVbijVff0rmdz1HjJo2qfd/bv96ht5e/qx++/0E/Hzysa28epQv69SiVyTmeo2VLVujzjZt19PARpTdP17Drf6nmLZtJkgYNvUR//+uT6t2/p2om1Kz2GgAAgPNoQgEAAM9q276Nbrh1dKnvJdZOlKQKGxkFBQWKiTm9X4Oy9v+kxx+YoYaNG+q6/7lGjZs0Vtb+LL3+7xV69E+P6477f6eGjRuc1rZPV15unj54d73+544bq3W/xXJzcpWSnqwefbtp3tMvhsy8+Mwi7flhj67/n2tUr0FdbVj7sf7x0D81+aE/qF6DekptmqqGSQ21Ye3H6ndJ32quAAAAVAeaUAAAwLNiYmNUp16dkD+b9/RLyj6arVvvvEl//+uTSk5tohpxNfTR+xvUoFED3f3A7xUIBPT2sne09p11+vngz2rUpJEuGTJA3ft0K3ef/35uiaKio/TbibeqRlwNSVKDRvX124nN9cDd07TouSUad9fNkqS///VJNUlNUkxMjD56f6MkqXf/nrpy5BBFRxfdFeGrTVu06pW3tHd3pqKipGYtm2nYtb9UcloT43n48vMtioqSWrY5q9T3Dx44pD/97gHd/L+/0ftvr9WOrd+pTr3auubGq9Xm3LONt1+Z9l3OVfsu50qSXpj1Upmf5+Xl6fMNm3TjhDE6+5zWkqTBv7pMmz/9Su+//YGGjBgsSep4Xnt9/OGnNKEAAIhQNKEAAMAZYcMHH6v3xRfod/f+VjrxMb3XF6/QZx99rhG//pWSkpP0/fbv9dIz/1bNxAR1ONFUKSn7aLa2fLFVlw8fFGxAFasRV0MX/qKPli1ZqWPZx5SQmCBJ2vjBJ+p5YXfdcf8E7flhr156ZpHq1KujAYP6Syq6iuniy/optWmq8vPyteqVN/X09Dma/PAfja/W2rH1WzVt0VRRUVGlvp+xa48k6Z0V72rgLy/ViF//SktffFVLX3xVf/zLnaWyq159S2+8+laF+xl39y1q3bal0ZhKKvQXqrCwULGxpeuJrRGrHdu+C/69eatmWvXKW8rLy1ONGjVO3QwAAPA4mlAAAMCztmz6WnfeNDH491ZtW+q2u28JmW3YuIF+Nfqq4N9zc3L1zop3ddsfbw02VholNdTOb3fpvTffD9mE+jEzS4FAQMmpSSH3kZzWRIFAQPszf1SLVs0lSXXq1dHw64cqKipKyalNtH/vj3pnxZpgE6pL986ltnHtzaN09y2TtHPHLrUybPgcyDqouvXLXhGWsTND8TXjNfa3NwSvGOvSvbNeW7SsTLbvgF46v2fnMt8vqW79ukbjOVV8zXid1bqFVr7yplLSk1WnXh19vO4TfffN96XuYVW3Xl35/X79fPCwK/e2AgAAzqIJBQAAPKtV25a65sYRwb/HxsaWm23aIr3U3zP37FN+foGe+r9ZUokLiAr9fjVoZN89nVq0al7qCqWzzm6uZUtW6PjxHNWsGa8f92Vp2ZIV2rljl44ePqrCQECBQEAHfzpovI/8/HzVia1V5vsZu/aofZdzSn1k8cd9WWoUosGTWCtRibUSLVZn7vpbR+vF2Qt03+8eUHR0tNJbpKlrr/P0w/e7g5nYGkXHLz8v37FxAAAA99CEAgAAnlUjroYaN2lsnC0pUFj0mbxb7rhRDRrVK/Uzn88XchuNmzRSVFSUMjP2qXOI20ZlZuxTVFSUpat4np4+R/Xq19PIsSNUr35dRfui9deJD6ugwG+8jVq1EnUs+3iZ7+/etUcXnXJ/pd07M5TePLVM1smP40lFc/e7e3+r3Jxc5eTkqm69Onr2H8+rYeOGwcyxo8ckSbXqlG2oAQAA76MJBQAAzkjJaU0UExujgz8dVNv2ZjfpTqydqHYd2+q9t9fq4ssuKtXYysvN03/fWqtzOrUrdUXRzh07FQgEgldDfb99p+rWr6OaNeOVfSRb+/bs19W/Hha8UfgP3+9Wob/QUi3pzdO0/r0Npb6Xm5OrrH1ZSm+eVur7u3dmqHO3jmW24eTH8UqKi49TXHycjmUf09dffK2rRl4R/Nne3XtVr35d1albu8r7AQAA4YcmFAAAOCPF14zXLwb119KXXlUgEFDrdi2Vm5On77fvVFRUlPoM6BXy34244Vd6/IEZ+sdD/9TlwwcpKbmRsvb/pNf+vVwKBDTihl+Vyv986LCWvPAfXfj/+mjPD3v19vJ3NPDKSyRJNRNrqlbtRH3w7oeq37CeDh34Wf9Z8JqifdGWajmnU1u9svB1ZR/JVmLtogbYnh/2SlKpJlT2kWwdOnCoTGNKqtrH8XJzcvXjvixJCn6UcPfODCUkJqhBo/qSiu7fVRgIqElKkrL2Zek/C15Tk5QkXdCvR3A727d+p3Yd257WGAAAQPijCQUAAM5Ylw8fpNp1a2v18ne1aO5ixdeMV1qzNP2/yy8u9980btJIdz/we634zxua9/R8HTl8VLVq11L7zudo7G9vUP0G9Urlu/U+X4WFhXpsyt8kRemCi3rq4kEXSZKio6M15vYbtGTeUk275xE1TmqkoaOv1JwZcy3Vkdo0Vc1bNdPHH36qfic+fpexa48aJzdWXHxcMPfDzgz5fD4lpzWxtP3K7PruB82YNjP49+Uvr9Lyl1epR9/uuv5/rpEkHT+eo9cWLdOhA4eUkJigzt076YoRg+WLKfroY35evjZ9/IVu+0PoG8sDAADviwoEAgG3BwEAABCJ/v7XJ5WSnqyrfz3M8X19tWmLlsz7jyY//EdFR1u7kioc/PfN9/XFJ5t1+x9vdXsoAADAIVwJBQAAEAHO7XSO9v+/H3XowCFbV/erLj6fT8NP+SgjAACILGHbhFrz5nta/94G7f1hr86/4PzgpdyhrF6xRm8tW6383Dx16dFZV48ZrtjYsC0NAADAEf0H9nN7CKetvHtwAQCAyBG2H8f7bMMmRUVF6esvtiovL7/cJtSWTV9r3tMvavw9t6lu/Tqa/bd/qUXr5rpq5JBqHjEAAAAAAADKE7Y3DOjSvZM6d+uoxFoJFebWv79BF1zUUynpyUpITNBlv7ykzBLFAAAAAAAAcFfYNqFM7d2dqbRmqcG/pzVL1ZGfjyj7SLaLowIAAAAAAEBJnr9xUl5unmomxAf/XrNmTUlSTk6uEmsnlsquXb1Oa99dJ0m6Ysw1qlkzTgAAAAAAALBHfoFfZzdtHPJnnm9C1YiroZzjucG/5xzPkSTFx5dtMPUZ0Ct408vv9x5QixTvrRwDAAAAAAAQrr7fe6Dcn3n+43gp6cnK2LUn+Pfdu/aodt3aZa6CAgAAAAAAgHvCtgnl9/uVn5evwsJCBQKFys/Ll9/vL5Pr0beb1q1Zr70ZmTqWfVyrXnlTPS/s7sKIAQAAAAAAUJ6oQCAQcHsQoSx/eaVWLH2j1PcGDb1UF/Trqb9OfFiTH/qjGjSqL0laveJdvfX6auXn5atz904aOXaEYmMr/qQhH8cDAAAAAACwV0X9lrBtQjmNJhQAAAAAAIC9Kuq3hO3H8QAAAAAAABA5aEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAAAAAAOI4mFAAAAAAAABxHEwoAAAAAAACOowkFAAAAAAAAx9GEAgAAAAAAgONoQgEAAAAAAMBxNKEAAAAAAADgOJpQAAAAAAAAcBxNKAAAAAAAADiOJhQAAAAAAAAcRxMKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAAAAAAOI4mFAAAAAAAABxHEwoAAAAAAACOowkFAAAAAAAAx9GEAgAAAAAAgONoQgEAAAAAAMBxNKEAAAAAAADgOJpQAAAAAAAAcBxNKAAAAAAAADiOJhQAAAAAAAAcF+P2AMqTfTRbL85ZqK+/2KbE2om68urB6ta7a5lcfn6BlrywVJs2fiG/36+WZ5+lkWOHq16DetU/aAAAAAAAAIQUtldCLXruZfliYjTtyan69bhrtXDuEu3dnVkmt2bVf/XdN99r4rS79ZcZU1QzMUH/nre0+gcMAAAAAACAcoVlEyo3J1efb9ikIcMuU1x8nFq1bamO57fXR2s3lsn+9OMBndOxnerUra3YGrE6/4IuygzRrAIAAAAAAIB7wvLjePszf1S0L1pJKUnB76U1TdX2r3eUyfa6qKcWv7BUPx/8WTUTamrjBx/r3M7tQm537ep1WvvuOknS4GuHSykNnCkAAAAAAAAApYRlEyo3N0/xNeNLfS8+IV45Obllso2TG6l+g3q6d8JURUdHK7Vpikbc8KuQ2+0zoJf6DOglSfp+7wH7Bw4AAAAAAICQwvLjeHFxNZRzPKfU93KO5yo+Pq5MdtFzS1RQUKCHnvqzHp3zkDp366inHpldXUMFAAAAAACAgbBsQiUlN1ahv1D7M38Mfi9j1x4lpyeXyWbs3KOeF/ZQYq1ExcbGqN8lF2rnt7t09MjR6hwyAAAAAAAAKhCWTai4+Dh17tZRy5asVG5Orr7d9p2++GSzevTpVibbrGVTffT+Bh0/dlz+Ar/ee3ut6tavo1q1a7kwcgAAAAAAAIQSFQgEAm4PIpTso9maP3uhtm7epsTaCbry6svVrXdXbd/6rZ56ZJYem/NQUe5IthbPW6qvN2+T31+glPQUDR19pVq0al7h9r/fe0AtuDE5AAAAAACAbSrqt4RtE8ppNKEAAAAAAADsVVG/JSw/jgcAAAAAAIDIQhMKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAAAAAAOI4mFAAAAAAAABxHEwoAAAAAAACOowkFAAAAAAAAx9GEAgAAAAAAgONoQgEAAAAAAMBxNKEAAAAAAADgOJpQAAAAAAAAcBxNKAAAAAAAADiOJhQAAAAAAAAcRxMKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAAAAAAOI4mFAAAAAAAABxHEwoAAAAAAACOowkFAAAAAAAAx1lqQj00+VGtefM9Hcs+5tR4AAAAAAAAEIFirITbdzlXby97R6+89Jo6du2o3v17qm37Nk6NDQAAAAAAABEiKhAIBKz8g0AgoK82fa31//1IX3z6perUraML+nVXzwt7qEGj+rYNLPtotl6cs1Bff7FNibUTdeXVg9Wtd9eQ2R++360lL/xHP3y/W3FxNXTplf9P/Qf2q3D73+89oBYpDWwbLwAAAAAAwJmuon6LpSuhJCkqKkrtO5+j9p3PUfbRbK1dvU4r/vOGVv7nTbVpf7Yuvqyfzu10TpUHvei5l+WLidG0J6dq984M/fOxOUprlqaU9ORSuaNHjmrm/83Sr669Sl16dJa/oECHDvxc5f0DAAAAAADAPqd9Y/Lvtn+vVxcu05uvr1bdenU0aOilapTUUM/MeE5LXlhapUHl5uTq8w2bNGTYZYqLj1Orti3V8fz2+mjtxjLZ1SvW6JxObdW9T1fFxsYovma8ktOaVGn/AAAAAAAAsJelK6GO/HxEH72/UR++95Gy9v+kjue1143jf612HdsGMz36dNM/Hv6nhl039LQHtT/zR0X7opWUkhT8XlrTVG3/ekeZ7Pfbdyq1aYqmT52hH/dlqUWrZhrx62G2fjQQAAAAAAAAVWOpCXXf7x5Q4yaNdMFFPdXzwm6qVbtWmUxyerKat2xapUHl5uYpvmZ8qe/FJ8QrJye3TPbQwZ+1e+du3f7HW5WanqJXFrymuTPn6Y4/TSiTXbt6nda+u06SNPja4RL3hAIAAAAAAKgWlppQv71nnFq3bVlhpmbNeE2YdHuVBhUXV0M5x3NKfS/neK7i4+PKZGNjY9Spa0c1b9lMkjRo6EBNvO0+HT92XDUTapbK9hnQS30G9JJUdKMsAAAAAAAAVA9L94RavmSljmUfL/P948dzNGPaTNsGlZTcWIX+Qu3P/DH4vYxde5R8yk3JJSmtWaqioqJOfiOqTAQAAAAAAAAus9SE2v71DvkLCsp8vyAvXzu2fWvboOLi49S5W0ctW7JSuTm5+nbbd/rik83q0adbmWzPC3vo841faPfODPkL/Fr5nzfVss1ZZa6CAgAAAAAAgHuMPo73w/e7g3/O+GGvEg/+HPx7YWGhtmzaqnr169o6sKvHDNP82Qs16fb7lVg7QSPHDFNKerK2b/1WTz0yS4/NeUiS1Lb92bpixGD987HZysvNV6s2Z2nMbdfZOhYAAAAAAABUTVQgEAhUFppww50V/jw2NlbDbxiqXhf1tG1gTvt+7wG14MbkAAAAAAAAtqmo32LUhDqQdUCBgDT1zr/qrin/q1p1EoM/88XEqHadWoqOtvTJPtfRhAIAAAAAALBXlZtQkYgmFAAAAAAAgL0q6rdUek+ozzZsUsfz2ssX49NnGzZVmO3SvdPpjRAAAAAAAAARrdIm1LNPPKe/PjFFtevW1rNPPFdhdsbzj9k2MAAAAAAAAEQOPo4HAAAAAAAAW1TUb/HW3cQBAAAAAADgSUb3hDLFPaEAAAAAAAAQitE9oUxxTygAAAAAAACEwj2hAAAAAAAAYAvuCQUAAAAAAABXGd0TquN57eWL8VV6fyjuCQUAAAAAAIBQjO4J9dcnpqh23dqV3h+Ke0IBAAAAAAAgFO4JBQAAAAAAAFtwTygAAAAAAAC4qtKP453qh+93652V/1XmnkxJUnJqE1182UVq2iLd9sEBAAAAAAAgMli6EmrD2o/1yJ8e1+FDh9W+8zlq3/kcHfn5iB69/2/asHajU2MEAAAAAACAx1m6Eur1xct1+fBBGnjl/yv1/TdefUuvL16h7n262To4AAAAAAAARAZLV0IdPZyt83t2LvP983p21pHDR20bFAAAAAAAACKLpSbU2ee21jdbdpT5/jdbdqh1u1a2DQoAAAAAAACRpdKP4322YVPwz+d2aqfXFi3Tru9+UItWzSVJ3+/Yqc83fKFBvxro3CgBAAAAAADgaVGBQCBQUWDCDXcab2zG849VeUDV5fu9B9QipYHbwwAAAAAAAIgYFfVbKm1CRSqaUAAAAAAAAPaqqN9i6Z5QAAAAAAAAwOmo9J5QpzqWfUxffb5FB346JH9BQamfDRrKfaEAAAAAAABQlqUm1Hfbv9c/H5ujmJgYHT1yVPXq19XhQ4cVExOjBo0b0IQCAAAAAABASJY+jvefl15T917n6y8z7ldsbKzG33Obpv7tT2p6VlP9v8sHODVGAAAAAAAAeJylJtSeH/aq3yV9FRUVpejoKBXkF6hO3dq6atQQrVi6yqkxAgAAAAAAwOMsNaFiYnzBP9euU1sHfjogSYqLi9PPBw/bOzIAAAAAAABEDEv3hEpvka6d3/6gpJQknX1OK72+eIWO/HxUG9Z+rNRmKU6NEQAAAAAAAB5n6UqoK4YPVt36dSRJlw8frFq1a2nx8y/r2LFjuuY3IxwZIAAAAAAAALwvKhAIBNwehBu+33tALVIauD0MAAAAAACAiFFRv8XSx/GK/bgvS/v27JMkJaclq1FSw9MfHQAAAAAAACKepSZU9pFszZ+zUJs//VJRUVGSpEAgoA7nnatrbxqlxNqJjgwSAAAAAAAA3mapCfXiMwuVtS9L/3vvb9W8VTNJ0s4du7Rw7mK9+Owi3fy7sY4MEgAAAAAAAN5m6cbkW77YqmtuvFot25wln88nn8+nlm3O0qixI/T1pq1OjREAAAAAAAAeZ6kJVat2LdWIq1Hm+7E1YpVYO8G2QQEAAAAAACCyWGpCDfrlJVrywn906MCh4PcOHTikpS+9qst+eandYwMAAAAAAECEqPSeUNPu+b/gTcgl6acfD+j+O/6ievXrSpIOHfxZsbGxOnr4qHr3v8C5kQIAAAAAAMCzKm1CdeneuTrGAQAAAAAAgAhWaRNq8K8GVsc4AAAAAAAAEMEqbUKFsvXLb5S5J1NRilJKerLOPqe13eMCAAAAAABABLHUhDp04JBm//1f+uG73ap74p5QPx/8Wc3Oaqqb/3ds8HsAAAAAAABASZaaUIvnLVV0dLT+9OgkNUpqKEnK2v+Tnn9qvhbPW6obJ4xxYowAAAAAAADwuGgr4a2bt+nqXw8LNqAkqVFSQw2/fqi+3rzN9sEBAAAAAAAgMlhqQpUrypatAAAAAAAAIEJZakK1aX+2Fs9bqoM/HQx+70DWQS154T9q0/5s2wcHAAAAAACAyBAVCAQCpuGDPx3UrMef1Z7de1W33okbkx/6WanpKbrljhtVv0E92waWfTRbL85ZqK+/2KbE2om68urB6ta7a7n5goICPTT5UeUez9WfZ9xf6fa/33tALVIa2DZeAAAAAACAM11F/RZLNyZPrJWou6b8r77Zsl379u6XJDVJbaJ2HdpUfZSnWPTcy/LFxGjak1O1e2eG/vnYHKU1S1NKenLI/NvL3lGt2rWUezzX9rEAAAAAAACgaow/jldYWKi7/2eS9u/7Ue06ttVFl16oiy690JEGVG5Orj7fsElDhl2muPg4tWrbUh3Pb6+P1m4Mmc/a/5M2fPCxLrniF7aPBQAAAAAAAFVnfCVUdHS0GjSsL3+B38nxSJL2Z/6oaF+0klKSgt9La5qq7V/vCJlfPG+prhgxWDVqxFa43bWr12ntu+skSYOvHS7xcTwAAAAAAIBqYenjeJf98lK9uvB13TDuWtWqXcupMSk3N0/xNeNLfS8+IV45OWU/avf5xk0qLCxU526d9M2W7RVut8+AXuozoJekos8oAgAAAAAAoHpYakK9vfwd/fTjAd03YarqNainGnE1Sv38nml32zKouLgayjmeU+p7OcdzFR8fV+p7uTm5emXB67r1rptt2S8AAAAAAACcYakJ1aV7Z0VFSebr6Z2epOTGKvQXan/mj0pKbixJyti1R8mn3JT8x31Z+inrgP72l39IkvwFBTp+LEeTfnu/7rz/d2rYmI/bAQAAAAAAhAOjJlRebp7+89Jr2vTJF/IXFKpN+7M14oahjn0kLy4+Tp27ddSyJSs1+sarlbFrj774ZLPu+NOEUrmU9GT9+W9/Cv7922++17+ff1l//PMdqlXHuY8LAgAAAAAAwBqj1fGWv7xS69/boPadz1XXXudp25fbtPBfSxwd2NVjhik/L1+Tbr9fc2fO08gxw5SSnqztW7/VnTdNlCT5fD7VqVcn+JVYK0HRUVGqU6+OoqONF/4DAAAAAACAw6ICgco/XDf1zr9qyPDB6trrPEnS9zt26vE/P6HHn/0/zzZ7vt97QC1YHQ8AAAAAAMA2FfVbjDpIB386pFZtzwr+vUWr5vJFR+vngz/bM0IAAAAAAABENKMmVGFhoXwxpW8fFe3zye8vdGRQAAAAAAAAiCzGq+M9/8/5iinRiMrPz9dLzy5SjRo1gt/7nztutHd0AAAAAAAAiAhGTagefbuV+V733l1tHwwAAAAAAAAik1ET6rpbrnF6HAAAAAAAAIhg3lzaDgAAAAAAAJ5CEwoAAAAAAACOowkFAAAAAAAAx9GEAgAAAAAAgONoQgEAAAAAAMBxNKEAAAAAAADgOJpQAAAAAAAAcBxNKAAAAAAAADiOJhQAAAAAAAAcRxMKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAAAAAAOI4mFAAAAAAAABxHEwoAAAAAAACOowkFAAAAAAAAx9GEAgAAAAAAgONoQgEAAAAAAMBxNKEAAAAAAADgOJpQAAAAAAAAcBxNKAAAAAAAADiOJhQAAAAAAAAcRxMKAAAAAAAAjqMJBQAAAAAAAMfFuD0AAAAAAACASDau9v4Kf/7UkaRqGom7uBIKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcWF7Y/Lso9l6cc5Cff3FNiXWTtSVVw9Wt95dy+TeWrZaH723UQd+OqjEWom68P/11v+7fIALIwYAAAAAAEB5wrYJtei5l+WLidG0J6dq984M/fOxOUprlqaU9OTSwYB0/a2jldo0RVn7f9KTDz+t+g3qq2uv89wZOAAAAAAAAMoIy4/j5ebk6vMNmzRk2GWKi49Tq7Yt1fH89vpo7cYy2f83ZICatkiXz+dTk5QkdTq/vb795jsXRg0AAAAAAIDyhOWVUPszf1S0L1pJKUnB76U1TdX2r3dU+O8CgYB2bPtOfS7uFfLna1ev09p310mSBl87XEppYN+gAQAAAAAAUK6wbELl5uYpvmZ8qe/FJ8QrJye3wn+3/OVVKiwsVM9+PUL+vM+AXuozoKhB9f3eA/YMFgAAAAAAAJUKy4/jxcXVUM7xnFLfyzmeq/j4uHL/zZo339NH72/UrXfdrNjYsOytAQAAAAAAnLHCsgmVlNxYhf5C7c/8Mfi9jF17lHzqTclPWLdmvd56bbXG3zNO9RvUq6ZRAgAAAAAAwFRYNqHi4uPUuVtHLVuyUrk5ufp223f64pPN6tGnW5nshrUf67V/L9ftf7xVjZIaujBaAAAAAAAAVCYqEAgE3B5EKNlHszV/9kJt3bxNibUTdOXVl6tb767avvVbPfXILD025yFJ0v2//4sOHTykmJiTH8Hr3qerRo0dUeH2v997QC24MTkAAAAAAHDYuNr7K/z5U0eSKvy5l1TUbwnbJpTTaEIBAAAAAIDqQBOqSFh+HA8AAAAAAACRhSYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oQAAAAAAAOA4mlAAAAAAAABwHE0oAAAAAAAAOI4mFAAAAAAAABxHEwoAAAAAAACOowkFAAAAAAAAx9GEAgAAAAAAgONoQgEAAAAAAMBxNKEAAAAAAADgOJpQAAAAAAAAcBxNKAAAAAAAADiOJhQAAAAAAAAcRxMKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHBfj9gAAAAAAAMCZ49FHH1V2dna5P09MTNRdd91VjSNCdeFKKAAAAAAAUG0qakCZ/BzeRRMKAAAAAAAAjqMJBQAAAAAAAMfRhAIAAAAAAIDjaEIBAAAAAADAcTShAAAAAAAA4DiaUAAAAAAAAHAcTSgAAAAAAAA4jiYUAAAAAAAAHEcTCgAAAAAAAI6jCQUAAAAAAADHxbg9AAAAAAAAgHDy6KOPKjs7u9yfJyYm6q677qrGEUUGroQCAAAAAAAooaIGlMnPERpNKAAAAAAAADiOj+MBAAAAQDXiYz4AzlQ0oQAAAACgGvExHziNRifCFU0oAAAAwGMq+w+mxH8yUTU0MbyNRifCFU0oAAAAVCv+c1t1Jv+BPJP/k8k5VnU0MQA4IWybUNlHs/XinIX6+ottSqydqCuvHqxuvbuWyQUCAb268HV9sGa9JKn3RT115cghioqKqu4hAwAAwAD/uYXTOMcAIDyFbRNq0XMvyxcTo2lPTtXunRn652NzlNYsTSnpyaVya99Zp00fb9bEv96lKElPPvy0GjZuqL6/6O3OwAEAZyzeeQfOPDzuAZwJeK4rH3NjTVg2oXJzcvX5hk2a9ODdiouPU6u2LdXx/Pb6aO1GXTVySKnsR+9t1IBB/VW/QT1J0oBBF+mDdz+kCQUAqHa8845IdSb+gm1aM4/7M8OZ+BjwgnA/LqbjC/c6JH7HqQhzY01YNqH2Z/6oaF+0klKSgt9La5qq7V/vKJPdm5GptGapJ3PN0rQ3Y1+1jDNc2P3kZlfudLZpNzdrDtcx2j0+J8cY7nMjnTm//JTMusUL57bd3Dy/wv1x6uZrVbjnrLC70VLdj1Mnj7Pd/6nwwn9Gw/3cPhMfA1aE+znmxPjC/bnJdHxWnm/cqsWt7VnZZrg/BlAkKhAIBNwexKm2b/1Wzz7xnKb9Y2rwe2vfWaeNH3yi302+vVR2wg13atJDf1ByahNJRQ2sP9/9oGY8/1iZ+0KtXb1Oa99dJ0m6Ysw1qlkzzuFK3HH08FHVqlMrbHNeGCM1Vz3nhTFSc9VzXhgjNVc954UxUnPVc14YIzVXPeeFMVJz1XNeGCM1Vz3nhTFSc9VzXpRf4NfZTRuH/mEgDO367ofA73/zh1Lfe2vZO4F/Pjq7TPaum+8JfLf9++Dfd367K3DnTRMdH2M4e/i+x8I65+a+qbn6cm7um5qrL+fmvqm5+nJu7puaqy/n5r6pufpybu6bmqsv5+a+qbn6cm7um5qrLxdpoqu3H2YmKbmxCv2F2p/5Y/B7Gbv2KPmUm5JLUkpasjJ27SmVS0lrUi3jBAAAAAAAgJmwbELFxcepc7eOWrZkpXJzcvXttu/0xSeb1aNPtzLZHn276Z2Va3TowCH9fPBnrV7xrnpe2MOFUQMAAAAAAKA8YXljckm6eswwzZ+9UJNuv1+JtRM0cswwpaQna/vWb/XUI7P02JyHJEl9BvRS1v6f9OCkRyRJvS66QH0G9HJz6K7r09+sfrdybu6bmqsv5+a+qbn6cm7um5qrL+fmvqm5+nJu7puaqy/n5r6pufpybu6bmqsv5+a+qbn6cpEmLG9MDgAAAAAAgMgSlh/HAwAAAAAAQGShCQUAAAAAAADH0YQCAAAAAACA42hCAQAAAAAAwHE0oSKUv8CvGdNm2rrNQCCg7V/vqDRXWFio9e9vqDTn9/s1f/aC6s9ZmBvTrGmuoKBAU+74i9G+D2QdtC1neuysbNP0OFvJrVi6qtpzAAAAAIDqQRMqQhUaNh3y8ws04YY7jbZZYNqQ8Rdq/qzKm0GFhQGtf8+kOWFzzkJDxjRrmgsEzBo8+flmzSrTnOmxs7JN0+NsJbdi6RvVnpPMG2VVacRmZuzTq4uWadbjz2jGtJma9fgzenXRMmVm7LN1jG4180ybwJL9DW0rtZzO9rZ8sVVzZ87Tg5Me0ZQ7/qIHJz2iuTPn6esvtla6rWKm82N3E9/uObRynN06F91saJvOj5XHgN3ntp3PdVbHaOc55tbcWNm3E7XYvV+7a3Yi58YbXlbHaOdrRnU8v1fnGMN5Dqsyxqrm3Hp+qI592338nPg9zO4xrl29TtOnztDdt0zShBvu1N23TNL0qTO09p11Zttz4AKScBbj9gBw+ipqFAQCgeCfK2p6FOTnl/p7RS9m/gJ/8M8VPSH5/YXBP1f0YAoUOpcznRsrWdOcaVOvol/wC/ILLOdMj52VbZoeZ9NcRS94TuYqU9wo69m3e4W54mbejOcfs7S9jes+0aK5i9XhvA5q1baVaibEK+d4jjJ27dH0B2Zo5Njh6nrBebaMsbj5NmjowGrNFTeBr715VIU56fTnsapjPJ3trV6xRm8vW63eF1+gLt07Kb5mzeCxmzfrJV0yZID6D+xX4fYk8/kxHaPd23PiOLt1LrqVk8znx8pjwO5z287nOqtjtPMcc2turOzbiVrs3q/dNTuRs/P4WXk8n04tdrxmOP38Xt1jDOc5PN0x2pFz6/nB6X3bffyc+D3M7jG+svB1bf70Sw0Y1F9pzVJP/J6fq907M/TOijX6af9PunLkkIq3Z/FTK15HE8rDjmUf0y+vuVINGzco87OCAr+efmyOpIqbJ6eaP2uBmp6VrpiYik+Nla+8qQ5dzlVcfFyZnwUKTzZkdu7YpUuu+IXq1qtdJuf3F2rHtu8cyZnOjZWsaS6xVoJG3zRKyWlNQuQK9OA9j0gqaqjVqVdbUVEVX5BomjM9dla2aXqcTXMb132iXv16KqFWQplcYYkmot05ybxRZncjVpJeW7Rct955s1q2OatM9ttt3+m5p15Q1wvOC/tmnmkTWLJ/Hk3HaPf23l7+jsZPuk3JqaUfz126d1LXXufpiWkzg7+omM6P3U18u2u2cpzdOhfdbGibzo/pY8Duc9vu5zorY7T7HHNrbqzs2+5a7N6vEzXbnXPrDS8rWbtfM9x6fndijOE+h06MMdyfH9zct93Hz4nfw+we44dr1mvitLtVt16dUpmmLdJ1bqd2enDSo7py5BBLF0lEOppQHpbePF2xsbFq275NmZ/ll7iapU692rppwlg1a9m0bC4vX3ffMin498bJjXXVyCFqc+7ZIbN33jRRkpSc2kR9B/TWOZ3ahcx9/OGnkqS05qlqkpqk83p0DjnGRc8tcSRnOjdWsqa5pi3SlX00W42bNKowV79hff163LUhGxMl59o0Z3rsrGzT9Dib5lLTU3ROp7bqeH6HkLm3Xl/tSE4yb5TZ3YiVpKNHjiq9RVrI7aQ3T9PRI9mWtulWM8+0CSzZP4+mY7R7e3m5eapbv27IsdepW0d5eSevJjWdH7ub+HbXbOU4u3UuutnQNp0f08eA3ee23c91VsZo9znm1ty4WYvd+3WiZrtzbr3h5UQtpq8Zbj2/OzHGcJ9DJ8YY7s8Pbu7b7uPnxO9hdo+xsv5RQEUBKxdJRDqaUB42aOilqhFXI+TPYmJ8Gn/POElSs7OaavfODLVo3bxMLtrnK/X3s9u11L49+0M2MqKjo9W6XUtJUqeuHXTk8NGQ+472RatH326SpIsH9lNCYtknK0ny+aKDl4HanTOdGytZ09zQ0VfJ5wt9hVFsbIymTJ8sqei47Pruh5CNoKjoKNVvWN9SzvTYWdmm6XE2zfW8sLsKC0M/U/tifLrsl5c6kpPMG2V2N2IlqV2HNpo/e6GGDB9Uqjn5474sLV+yUu06tLG0TbeaeaZNYMn+eTQdo93b69K9k2Y9NkeXDb1UqU1TS32UctUrb6pL907Bf2c6P3Y38e2u2cpxdutcdLOhbTo/po8Bu89tu5/rrIzR7nPMrblxsxa79+tEzXbn3HrDy4laTF8z3Hp+d2KM4T6HTowx3J8f3Ny33cfPid/D7B5jr4t66IkHZ578OF7Noo/jZezK0OqVa9S7/wWSrF0kEeloQnnY2ee0LvdnUVFRwZ+PGjtCUVFRIXOxsTGl7vkw6jdXl7tNX4xPEybdLkm6fNig8nM+n6675RpJ0nk9u5Sbi46OVs8LuzuSM50bK1nTXEp6crk5SWrQqKj7Pea268rNxMTEaOrj91rKmR47K9s0Pc6muX6X9C03Fx0drcG/GuhITjJvlNndiJWka28epYVzl2jaxIcV7fMpvmbRi11hYaE6d+sYbJ6GezPPtAks2T+PpmO0e3sjxw7X8iUrNe/pF3X40JFgpm69Ourep6sGD7ss+D3T+bG7iW93zVaOs1vnopsNbdP5MX0M2H1u2/1cZ2WMdp9jbs2Nm7XYvV8narY759YbXk7UYvqa4dbzuxNjDPc5dGKM4f784Oa+7T5+TvweVt4269SrrR59ulke41WjrlDDpIb68L8fKTMjU7k5eYqLr6HktGRddOmF6jugtyRrF0lEuqjAmfYBxDPIgayDatCovtvDsGT/3v3am5GpnJxcxcfHKSUtWUkpSaedK4+VuTHNmuQCgYB2bP1Wrdu1Mto3Iktebp72Z/6o3JxcxcXHKSm5cbkvRgg/x7KPKzc3V3FxcUpIrOn2cAAAYcwLrxnhPsZwHx8qZvfxc+J84BxzB02oCJWfX6A7b/xjpSvbFBYWasMHHxuujOLXgmf/XflKCgV+Pfl/T2vCpNuMx3gg66D+9eTzyti1R42SGqpmQtEqBVn7flJas1SNuf16NWhU3zhnut/KmGbtzhUWFmrVK28arKxhlgt17LZ8sVXr3/tIe3dnBpsiKenJuuDCHmrXsW2F25PMj7NprqCgQH/5w0OaMv3eas3hpNyc3DJNslD3oQAiFY+BM8ex7GPKOZ6r+Jpx5b7TjfDl1vFz8zmCczb8uHU+uHkeRtLrZJmLGtJTlJTcuPKcQxc/ePECktNV8dJYCGvbv95R7tcOwyUei5d3NVG8FGWluRJLTB7IOlju18GsA8F/M3/2ArVq01IPzfyzJj34B/3+vvG6Z9rdmvbkVLVqe5ZemPWSpZyVuTHNmubWv7+h3K8NazcazXXxUqd25U49dqtXrNELT7+oxk0aadDQSzXqN1dr0NCBatyksebNeknvrvpv5ds0XErUNBcIFJ0v1Z2TihplFa2AEcz5/RWuDmJ1e1JRs8xkBUvTbZpur2TuWPZx/evJeZo47l79/a9P6rmZL2jGX5/UxNvu03MzX9Cx7OOVbi8/v0ATbriz0pxk/zy6NYdWajbNmo7R7u05UfPpnItu5ex4DEhl52ft6nWaPnWG7r5lkibccKfuvmWSpk+dobXvrDPant3n9qm5qo7PyhjtPsdOZ278BX69umiZJv/2fk0cd5+m3PEXTRx3nyaPn6LX/r28zKqAVd233bXYvV8nXqvsztl9/Ez3e2q2Ol8nS+aqu+bTGaMd+7b73Hb6tao6z4fqeK2qrn3bffxO9/ewA1kH9djUv+uhex/TsiUr9cE7H2r5y6v08OTHNH3qjOD/H8rN3Tu9VK6y/Zqe21ZWtPc67gnlYTOmzVSderUVFVVxL9HK8rymS1GaLjFp+mD6fsdOjbv75jKr9MTFx2nwsEGaeOu9lnKmc2Mla5ozXXHIrWVgJfOlSe04ziVzpi8UducqY9xQO9HMq+xqQNPtSebNMiebefPnLFCN2FhNfniiGiU1DGay9v+k5S+v1Pw5C3Tz78ZWuN2C/Pxyf3Yqu+fRyTm0UrMd83NqE9/O7VXkdGs23Wa450wfA5L5/Lyy8HVt/vTLkzcqTSi6UenunRl6Z8Ua/bT/J105cogttZzOmwJ2jM/KGO0+x05nbhbOXays/Vm6Ydx1Sm+WqvgTN6PdvXOP3nj1LS2cu1ijbxoZtrXYvV8nXqvsztl9/Ky8QeXk66Rpzoma7R6jlX2b5KpzfKc7xur8vcnp1yq792338XPi97DiixrGTxxX6rYYuTm5WvmfN/TCrJc0YdJtxrmKnkcLStxw3DR3JqAJ5WH1G9bXr8ddG3KFs5Ir21hZntd0KUrTJSbr1KutmyaMVbOWTUOO8e5bJp2opZ42f/pVqRUOin31+Veq36iexZzZ3FjJmuZMVxxyaxlYyXxpUtPjbJpLrJWg0TeNUnJakxC5Aj14zyOO5CTzRpndjVjJvFnmVjNv6+ZtmvaPqWXuT9UoqaFGjhmuyeOnVDq+U9k9j27NoZWaTbN2N/HdrNmtxrJbjwHJfH4+XLNeE6fdrbr16pT6ftMW6Tq3Uzs9OOlRXTlyiO3ntmnOdHyS/fNtOod2z81nGz7X1MfvU82Ek/f9SKyVqLbtz1bTFumacsefg/+hd6sWu/frxGtVddZyOsfPyhtUbr1OmuacqNnuMYbjuX26+3brfHDztSrcHwNO/B7m1sUPVi6SiHQ0oTys2VlNteu7H0I2RaKio1S/YdFnSq0sz2u6FKXpEpPNzmqq3Tsz1KJ18zK5aJ8v+OcRN/xKz8yYq3dWrlFa05Pv9GTs2qO9uzN144QxlnKmc2Mla5ozXXHIrWVgJfOlSU2Ps2muaYt0ZR/NVuMmjao1J5k3yuxuxErmzTI3m3m7d2aEPLczdu0J3nvCtKks2T+Pbs2hlZpNs3Y38d2s2a3GsluPAcl8fiq742ZAAUtjtPtNAdPxWRmj3eeY3XMTGxurnw8dLvUf+mKHDx1WTGys5ZrtrsXu/TrxWmV3zu7jZ+UNKrdeJ01zTtRs9xjdOrfdfq2y83xw87Uq3B8DTvwe5tbFD1Yukoh0NKE8bMxt15X7s5iYGE19vKg7a2V5XtOlKE2XmBw1doSioqJC5mJjY4I36G7bvo3uf3SyPtu4SZkZmTp6+Kji4muoR99u6tyto2rVrmUpZzo3VrKmuVG/ubrcnC/GpwmTbpfk3jKwkvlyp6bH2TQ3dPRV8vlCd/9jY2M0ZfpkR3KSeaPM7kasZN4sc6uZd8WIwXrqkVnqcH77oo/l1Cy64X/GD3u0+dMvNXLMCEnmTWXJ/nl0aw6t1GyatbuJ72bNbjWW3XoMSObz0+uiHnriwZknP+5Ws+jjbhm7MrR65Rr17n+BpTHa/aaA6fisjNHuc8zuufnF5QP0xLSZ6nVRT6U1S1X8icVNMnbt0bo163XJkAGu12L3fp14rbI7Z/fxs/IGlVuvk6Y5J2q2e4xundtuvlbZfT64+VoV7o8BJ34Pc+viBysXSUQ6VscDznBnytKk32zZrhpxNdS8ZbMyPwucuOfE2ee01qfrP1PCiUvdT1VYWKgNaz9Wzwu7G29PkvbuzpTPF13uShoHsg6oQaMGxts03Z5prniMG9d9UrRa4onzISU9Wd16n6+UtGRJRe+6RkVFqXbdslc3ncrueXRrDq3UbJo1HaPd23OiZrvPRbdyxbVU9hiQrD0O3l/9gT56f6MyMzKVm5OnuPgaSk5LVo++3dR3QO/gfu08t608N5mMz8oY7T7H7J4bSdqy6Wt99P5G7c0osTLsiZpLXjHuVi1279eJ1yq7c3YfP6uPezdeJ608j9hds91jdOvcdvO1qnibdp0Pbr5WhftjwInfwyQp+0h28KKGkq9/JS9qMM0VLxDgi/GF3Fcx09yZgCZUhCosLNSqV97UoKEDXdm/yRKThYWF2vDBx+rZt7skacsXW7X+vY+KntiKX2TTk3XBhT3UrmPbSvdpWrOVubF7m36/Xwue/XelN2T2CjuXHA0EAtqx9Vu1bteqWnMAAAAAgOrBXbEilN9fqBVL36g8Z2F5XivLZRotu+sv1PxZRSu/rV6xRi88/aIaN2mkQUMv1ajfXK1BQweqcZPGmjfrJb276r9G2zOq2TDnxDaLVwWrjFtL2lrJ2r3kaIHxUvL25oqZrpZj9/aK3+W1a5um2zPNFRYWav37lZ+zpjmr7KzZ7u1ZqdlK1mjFKJu350TNdp+Lp5vLPpKttavXafG8pZo/e4EWz1uqtavXKftIdqXbktw9znaf207k3Jpvtx73VrJ21+LE49Tu1yq7c5Lzr33Vdc7anXNirp0eY7jNdagxVjXn1nGuymtVuB2XU3OZGfv06qJlmvX4M5oxbaZmPf6MXl20TJkZ+8r8WyvZ8vZd0crybuciBfeE8rD5sxeU+zO/v7Dcn5V06vK8pktbmi4xWdGDqeQY317+jsZPuk3JqaVviteleyd17XWenpg2U/0H9jOu2crc2L1N01XBKuL0cs12H2fTXEUvPMWXqDqRq0xxo6z4HmUV5e688Y9GOZPtSSebZXZt03R7prniZnHxFYtVzUn2z6Nbc2ilZtOs6Rjt3p4TNdt9Lp5ObuuX2/TMjOeU2jRFac1SVbdeHeUcz9HGDz7Wq4te140TxoRcRKIkN4+z3ee23blTx1id8+3W495K1u5a7N6vE69Vduecfu2rznPW7pzdc+30GMNxrk8dox05t47z6b5WheNxKZnbuO4TLZq7WB3O66BWbVuVWkxp+gMzNHLscHW94DxJspStaN8rlr5h8OkWd3KRgiaUh21c94l69euphFplb0ZdeJpLyZsubWm6xOTKV95Uhy7nKi4+ruy+S9xsOy83T3Xr1w25jTp16ygvr6gxYlqzac6JbZquCubWkrZWsnYvOTp/1gI1PSu9zFKnTuck80aZ3Q06ybxZ5lYzz7RZbJqT7J9Ht+bQSs2mWbub+G7W7FZj2TS3+PmlGn3TyJAr23y+cZMWPbdE9z480dXjbPe5bXfOyhjtnm+3HvdWsnbXYvd+nTjOdufceu2T7D9n7c45UbNbY3Rrrq2M0a3fm9z8nSTcHwOvLVquW++8OeTNvL/d9p2ee+qFYGPJNGv3BQhOXCQR6WhCeVhqeorO6dRWHc/vUOZn+Xn5euv11ZKsLc9rvrSl2RKTyalN1HdA71I3+yyZ+/jDTyUVXfE067E5umzopUptmlqqc73qlTeDT4ymNZvmnNim6apgbi1payVr95KjjZMb66qRQ0K+o+JkTjJvlNndoJPMm2VuNfNMm8WmOcn+eXRrDq3UbJq1u4nvZs1uNZZNcweyDqp9l3ND/uzczufquafmS3L3ONt9btudszJGu+fbrce9lazdtdi9XyeOs905t177JPvPWbtzTtTs1hjdmmsrY3Tr9yY3fycJ98fA0SNHld4iLeT40pun6WiJjwyaZu2+AMGJiyQiHU0oD+t5YXcVnvKEU8wX49Nlv7xUkrXlea0sl2myxGSnrh105PDRkGOM9kWrR99ukqSRY4dr+ZKVmvf0izp86EgwU6debfXo002Dh11mqWbTnBPbvHhgPyUkln1ykSSfLzp4U3K3lrS1krV7ydGz27XUvj37QzaNoqOj1bpdS0dyknmjzO4GnWTeLHOrmWfaLDbNSfbPo1tzaKVm06zdTXw3a3arsWyaa96qmZYtXq5BQweW+kU3NydXK5a+oRatmlmu2a3jYvebAk48h9k932497q1k7a7F7v06cZztzrn12ifZf87anXOiZrfG6NZcWxmjW783ufk7Sbg/Btp1aKP5sxdqyPBBpf4v9OO+LC1fslLtOpz8/61p1u4LEJy4SCLS0YTysH6X9C33Z9HR0Rr8q6LPlA4aeqlqxNUImYuJ8Wn8PeOCfx81doSioqJCZmNjY4KfRx5z23Xl7jsmJkZTH79XknT5sEHl5nw+n6675Zrgv7ly5BBdOXKIjmUfDy77mZBYs9S/Ma3ZNOfENs/r2aXCXM8Liz4HPXT0VfL5Qr/rFxsboynTJ1vKmR47K1nT42yaG/Wbq8vN+WJ8mjDpdkdykrWGmp0NOsm8WeZWM8+0WWyaK67Fznl0aw6t1GyatbuJ72bNbjWWTXPX3TJKc598Qffcdp8aJjVUzZo1lXM8R1k//qT0Zmkac/v1lmt267jY/aaAE89hds+3W497K1m7a7F7v04cZ7tzbr32Sfafs3bnnKjZrTG6NddWxujW701u/k4S7o+Ba28epYVzl2jaxIcV7fMpvmbRp2UKCwvVuVvHUiuOm2btvgDBiYskIl1U4NSbAsFzcnNytT/zR+Xm5CouPk5JyY1DXtroBfv37tfejEzl5OQqPj5OKekpSkpu7PawSomk+T6TFH+m3hfjqzB3+NBhRUVFqXbdsvf0Op3tWeHENt3i1jx6YQ7PxJrdtj/zR+3dnam83FzViItTSnqy468tbh1nu3Ono7rnm8dA+bwwN+EwRjeeI85UzHV4Kvo/2L6wPS55uXll/v9V3kUWVrJwB00oDzuWfVwL5y7Wpo2b5IuJUc0T3d4Cv19dunXSiF8PK3MlUSgHsg6qQaOT74RlZuzTR2s3KjMjUznHcxVfM07Jacnq0adbyPsSnaqwsFCrXnmz8lUACvx68v+e1oRJt+lA1kH968nnlbFrjxolNVTNhBNd+H0/Ka1Zqsbcfn2pMYZSUFCgv/zhIU2Zfq8tuVOzdsy36apggUBAO7Z+q9btWkkqWjr1sw2btDcjM/iEmpKWrC7dOymxdmKldRQWFmrDBx+XWo2iuo6z8fng92vBs/8u9Y5GdeQAAACAM92x7GPB/xOUd2sRN3OIHHwcz8Pmz1mgGrGxmvzwRDVKahj8ftb+n7T85ZWaP2eBbv7d2Aq3cerSt9W5tGVhIBBcEWX+7AVq1aalxk8cV6pTnZuTq5X/eUMvzHpJEybdVuH2AoGKV+Symjs1azrfpquCVcTpJW3DcQnTwsKA1r+3odKmUVVyW77YqvXvfaS9u0s089KTdcGFPdSuY9tgzrRBZ7q9ipg2y1xr5pVoFlvNVdc8nlqL6fbWrl6n9e9tKNPc7dmvu/pc3Kvy/RrOjZXs6TTxrdRc7vZsPh8sbfM0c9V1/KpynN06t+3OSeE339XxuK+2ml06t02fb0KN0e6c3cevqnMoOXDOOvwYcLPmsHt+qMJrlVu1uPU7ib/Ar2Uvr9T6/35U6uNxtevW1gX9emjw0IHyxfhcy1XkdC8s8HIuUtCE8rCtm7dp2j+mlrm8sFFSQ40cM1yTx0+RZG15XruXtqxohaySF+F9v2Onxt19c5lVIeLi4zR42CBNvLXoATnhhjvL3V5JpjkrWdP5Nl0VzM0lxt1awnTGtJnl5gKFzuUkafWKNXp72Wr1vvgCdeneSfEnPvOesWuP5s16SZcMGaD+A/sZN+hMt1cZ06aaa828Es1iK7nqnMeStZhu75WFr2vzp19qwKD+SmtWvCJnrnbvzNA7K9bop/0/6cqRQ2yZGyvZ02ni2z2HdtRhaZunkavO43e6x9mtc9vunKSwnG+nH/fVWrNL57bp882pY7Q7Z/fxs2MOJQfOWQcfA27WHJbPD6f5WuVWLW7+TrJw7mJl7c/SDeOuU3qzVMWf+H1t9849euPVt7Rw7mKNvmmka7mKnO6FBV7ORQqaUB6WWCtBu3dmhGwkZOzaE7yc0cryvHYvbXks+5h+ec2Vati4QZlcQYFfTz82R5JUv2E9bf70q5CNlq8+/0r1G9WTVFTz6JtGhfy4WEFBgR685xFLOavbNJlv01XB3Fxi3K0lTHfu2KVLrviF6tYre58gv79QO7Z950hOkt5e/o7GT7pNyamlj3OX7p3Utdd5emLaTPUf2M+4QWe6Pcm8WeZWM8+0WWyak8wbnabzaFqL6fY+XLNeE6fdrbr16pTKNW2RrnM7tdODkx7VlSOHWKrZNGt3E9/uObRSs1uNZbuPnxPH2a1z2+6c5N58u/W4d6Jmt85t0+cbK2O0O2f38bNynO0+Z916DLhZs1vPD068VrlVi5u/k3y24XNNffw+1Uw4eUuRxFqJatv+bDVtka4pd/xZo28a6VrOiQsLwj13JqAJ5WFXjBispx6ZpQ7nty/qmhe/c/TDHm3+9EuNHDNCkrXlee1e2jK9ebpiY2PVtn2bsrkSV2GNuOFXembGXL2zco3Smp7shmfs2qO9uzN144QxkoqejLOPZpcaW6jtmeasZE3n23RVMDeXGHdrCdO05qlqkpqk83p0LpvLL9Ci55Y4kpOKblJYt37dMjlJqlO3jvLyij4qadqgM92eZN4sc6uZZ9osNs1J9s+jaS2m26vsbogBFQWs1GyatbuJb/ccWqnZrcay3cfPiePs1rltd05yb77detxbydpdi937NX2+sTJGu3N2Hz8rx9nuc9atx4CbNbv1/ODEa5Vbtbj5O0lsbKx+PnS4VDOo2OFDhxUTG+tqzqkLC8I5dyagCeVh3Xp3VVqzNG1c94m+3fa9cnNzFXdiNYPf/2mCUtKSJVlbntfupS0HDb203NUIYmJ8Gn/POElS2/ZtdP+jk/XZxk3KzMjU0cNHFRdfQz36dlPnbh1Vq3YtSdLQ0VfJ5wt9RVdsbIymTJ9sKWclazrfo8aOUFRUVLnbK77/lptLjLu1hOnFA/uVe8NBny86uF+7c1LRO6qzHpujy4ZeqtSmqaU+HrbqlTeDV+GZNuhMtyeZN8vcauaZNotNc5L982hai+n2el3UQ088OPPkpe81iy59z9iVodUr16h3/wss12yatbuJb/ccWqnZrcay3cfPiePs1rltd87N+Xbrce9EzW6d26bPN1bGaHfO7uNn5Tjbfc669Rhws2a3nh+ceK1yqxY3fyf5xeUD9MS0mep1UU+lNUtVfMLJj8OuW7NelwwZ4GrOiQsLwj13JmB1vDPA6Sx9y9KW4ceJJW3PpONcUFCg5UtW6qO1G3X40JHg9+vWq6Pufbpq8LDLFBMTo2PZx7Rw7hJt2rgpZIPu6l8PU0JigvH2JOnT9Z8p4cQlxqcqLCzUhrUfq+eF3fXfN99X3fp11blbx5C5lf95U4N/NdB4e6a5b7ZsV424GmreslmZXODEfQPOPqe1cU6S7fNoWouV4/L+6g/00ftFN07PzclTXHyNohun9+2mvgN6S5Klmk2zpsfZdHt2z6GVmu0+F01zkr3Hz4nj7Na5XdVcnXq11aNPt1KPFbfmu6pzE6oWkzqcqNmtc9v0+UZy7/HsxPEzzdl9zrr1GHCzZtN9uzWHkvm57VYtdu/XanbLpq/10fsby9wUvUffbqU+YeFGbu/uTPl80UpKSSpThyQdyDqgBo0aWMqGe+5MQBPK40xXnwpXB7IOqkGjoiuxqrqKUCAQ0I6t36p1u1a25KxkCwsLteGDj4Orz1U1B2cdyz4evJItIbHsZcCStQadyfbOVG7O45l4XM7Emr3ArXPb7pwXRFItZyKOHwBEvsrvVI2wtXHdJ5r+wN916MDPatW2lbr1Pl+t27XSzwd/1vQHZpS6B1B5CgsLK1xVraSCggKjld9Mc/n5J3OrV6zRC0+/qMZNGmnQ0Es16jdXa9DQgWrcpLHmzXpJ7676r8F+/RXeeNBqzkrW7y/U/Fnl3/zTes5f4c1EgznT8Vmq2d7jbOV8MLlhnx25hMSaqt+gXoW/4NaIq6H05mlq1bal0punVXiFmMn2vMx0tY5QOTfnsSrbq0rNdmRPd3vVcS56YfUWu49fVY+zW+e2SW7/3v36Zss32vbVN/pmyzfan/mj5fG4Od8lVbUWJx7P1fG4r479VofqOn5uHufTze3fu1+fb9yk9e9v0OcbN2n/3v1G27G636qM0Qu56prH08n5/X5t+WKrVq9YoxVLV2n1ijX6+out8vv9pf5NqNyWEDmr2VCKr5jyes4LY7RSSySgCeVhxatP3XDraP1icH/17n+BBgzqr+v/Z7RuvfMmvbrw9Uq3Ubw8r4nTWWJy+9c7yv3aUeKBVrwyyuXDBqlL985q16GNunTvpMuHXabx94zTm6+9LUla//6Gcr82rN0Y3J5pzkp2xdJV5X6teuVNy7mKFC8XW2nOgaVqnVxy9EDWwXK/DmYdCP4bu3OVMW1s2d1Qc3PfVnJWm8qVCcfG5Kk5u2s2zZ5OE7+ynBtz49S+3Th+ThxnN+emOHcg66Aem/p3PXTvY1q2ZKU+eOdDLX95lR6e/JimT51h/J8ot+bb7lqcOs52nw927tf0+cbqGN04F91+PDuVK3du7p3umXM7HHLVOY+nk9u9M0MP3DVNLz2zSN98VdSA/WbLdr307CI9cNeDyti1p8LcglNyVrPlsfsNfrdyXhijlVoiATcm9zDT1aesLM9r9xKTM6bNVJ16tRUVVXG/03RllPmzFqjpWeml7lMRimnOSnblK2+qQ5dzS61QVyxQ4qbcpjm7l0u3smyrW0uOmv4SZHdOqrhhVpCfX+7PSjq1oWa6Pbf2bZqrqEFZUOJGiaa5yjhZi5s12zE/pzbxTbbn1tw4sW+3jp8Tx9mtuTHNzZ+9QK3atNT4ieNKXaGYm5Orlf95Qy/MekkTJt0myb35trsWJ46z3bVU5/PxqW8mhfu56Obj2a2cF87tcM9J7p1jprmXnlmkAYP666JLLyyTW/Pme5o/Z4H+8MAdxjkr21z/fvlvehffV1hS2Oe8MEYrtUQ6mlAeZrr6lJXlee1eYrJ+w/r69bhrQ67Ml5+XrztvmijJfGWUxsmNddXIISFXlCu5PdOclWxyahP1HdC71A31SuaKP/5omrN7uXQry7a6teRonXq1ddOEsWrWsmmZXH5evu6+ZZIjOcm8YWV3Q83NfZvmTJvFpjkp/BuTTtRsmrW7ie/W3Dixb7eOnxPH2a25Mc19v2Onxt19c5k3YOLi4zR42CBNvPXe4Pfcmm+7a3HiONtdi937NX2+sTJGt85FNx/PbuW8cG6He05y7xwzzWVm7CuzMEKxPhf30qsLllnKWcna/Qa/WzkvjNFKLZGOGfCwa28epYVzl2jaxIdDrj5VvDy9leV57V5istlZTbXrux9CNqGioqNUv2HRTclHjh2u5UtWat7TL5a7Mooknd2upfbt2R+yYRQdHa3W7VpaylnJduraQUcOHy2TkaRoX7R69O1mKWf3culWlm11a8nRZmc11e6dGWrRunmZXLTP51hOMm9Y2d1Qc3PfpjnTZrFpzs1a3KzZNGt3E9+tuXFi324dPyeOs1tzYz6H9bT506+Cb/KU9NXnX6l+o3qWa7Y7Z3ctThxn+2uxd7+mzzdWxujWuejm49m9XPif2+GeK8q6c46Z5pqkJem9t9eq/8B+ZXJrV69Tk7QkSzkrWbvf4Hcr54UxWqkl0tGE8rCExASNvf36Slef6nlhdxWW+BhYSb4Yny775aXBvw8dfZV8vtDd+tjYGE2ZPtlSbsxt15U7/piYGE19/N7gn68cOURXjhxS4cooo35zdbnb88X4NGHS7ZZyVrKXDxtUfs7n03W3XGMpd/HAfkpILHt1WlEuOthEHDT00nJv5hwT49P4e8ZZykn2H2fT3KixIxQVFVVubsbzjzmSk8wbVnY31Nzct5WcSbPYNOd2LW7VbJq1u4nv1tw4tW83jp8Tx9nNuTHJjbjhV3pmxly9s3KN0pqmKr7EFch7d2fqxgljTqtmu3N21uLUcbb7fLBzv6bPN1bH6Ma56Pbj2Y2cV87tcM5J7p1jprnRN47U7L89q7eXv6vUpiknPhGSqz0/7FFUVLRu/t+xlnJWsna/we9WzgtjtFJLpIsKnHqzGHhObk5umSZUqPsRecH+vfu1NyNTOTm5io+PU0p6ipKSG7s9LESAw4cOKyoqSrXrlv34Y0l7d2fK54tWUkpSyJ8fyDqgBo0aGG/PzX2b5oo/h+6L8dmSk9yrxc2aTbOmc2O6Pbfmxol9u3X8nDjObs2Nleem7CPZ+mzjJmVmZCo3J09x8TWUnJaszt06qlbtWsGcW/Ntdy1OHGe7a7F7v6bPN1bG6Na56Obj2c3nnHA/t8M9V8yNc8zqcflmy3btLTG+lLRknX1O61L/3jRnNQtUJ5pQHnYs+7gWzl2sTRs3yRcTo5onPo5X4PerS7dOGvHrYaWuJKpqsyoQCGjH1m/Vul0rW3KFhYVa9cqbGjR0oA5kHdS/nnxeGbv2qFFSQ9VMqKmc4znK2veT0pqlaszt16tBo/oVbs/v92vBs/8OXkFU1ZylbRb49eT/PR28iWtVc1YcyDpY6dxYydl9nK2cDxs++Fg9+3av1hwAAAAAoHpUfic3hK35cxYoOipKkx+eqEdnP6g/z7hfj8x+UJMf+qOioqM0f07RqnjHso/rX0/O08Rx9+rvf31Sz818QTP++qQm3nafnpv5go5lHzfan91LTPr9hVqx9I2iWk6sWvHQzD9r0oN/0O/vG697pt2taU9OVau2Z+mFWS9Vur3CwoDWv1f+qgNWc5a2GQhUuAKG1ZybS8m7teSo31+o+bPKX8nRqZxU1LCqaMWKYgHT42y4PTf3bSW3Yukq23KSu7W4VbNp1srcmI7Rjblxat9uHD8njrPTc5OZsU+vLlqmWY8/oxnTZmrW48/o1UXLlJmxr9JtFW/PiZrtzoX74zncazF9vrE6RjfORa8c53DOeWGMVclt+WKr5s6cpwcnPaIpd/xFD056RHNnztPXX2wNi1x5/H5/hSudW805sc1wz3lhjFZqiQTcE8rDtm7epmn/mFrmPkCNkhpq5Jjhmjx+iqSiZlWN2FhNfniiGiU1DOay9v+k5S+v1Pw5C3Tz74o+F2z3EpMVPZj8/pMr81lZtaI8gRIr/ZnmrGQrauKUvKDQNOfmcs1uLTla0S8OJc8Hu3OVKW5YVXbVVHFDreS9pqqyPTf3bSW3YukbGjR0oC05yd1a3KrZNGtlbkzH6MbcOLVvN46fE8fZybnZuO4TLZq7WB3O66BWbVuVWm12+gMzNHLscHW94Dxb6rCSdSIX7o/ncK/F9PnG6hjdOBe9cpzDOeeFMZ5ubvWKNXp72Wr1vvgCdeneSfE1awbPxXmzXtIlQwao/8B+ruUqUvyGeGWfyjDNObHNcM95YYxWaokENKE8LLFWgnbvzAh5s7uMXXuCN702bVZJ9i8xuXHdJ+rVr6cSapW9AXdhiQaP6aoVO3fs0iVX/EJ165W9v4DfX6gd276zlLOSPZZ9TL+85ko1bNygTK6gwK+nH5tjKefmUvJuLTm68pU31aHLuSE/BhoocfN8u3OSecPK7oaam/s2zZk2i01zUvg3Jp2o2TRrdxPfrblxYt9uHT8njrNbc/PaouW69c6bQ/5u8O227/TcUy+o6wXnOVKz3TkvPJ7DvRbT5xsrY3TrXPTCcQ73nBfG6ETNby9/R+Mn3abk1NKrRHbp3klde52nJ6bNVP+B/VzLufkme6TkvDBGK7VEOppQHnbFiMF66pFZ6nB+e6U1S1XN4u76D3u0+dMvNXLMCEnmzSrJ/iUmU9NTdE6ntup4foeQubdeXy3JfNWKtOapapKapPN6dC67vfwCLXpuiaWclWx683TFxsaqbfs2IXPFTHNuLiXv1pKjyalN1HdAb53TqV3I3McffupITjJvWNndUHNz36Y502axac7NWtys2TRrdxPfrblxYt9uHT8njrNbc3P0yFGlt0grk5Gk9OZpOnok21IdVrJ257zweA73Wkyfb6yM0a1z0QvHOdxzXhijEzXn5eapbv26ZXKSVKduHeXl5buac/NN9kjJeWGMVmqJdDShPKxb765Ka5amjes+0bfbvldubq7i4uKUkp6s3/9pglLSkiWZN6sk+5eY7HlhdxWe8h/yYr4Yny775aWSpLbt2+j+RycHV604evio4uJrqEffbqVWrbh4YL9STbNS2/NFBy9hNM1ZyQ4aemmZq8mKxcT4NP6ecZZybi4l79aSo526dtCRw0fLZIpqjlaPvt0cyUnmDSu7G2pu7ts0Z9osNs25WYubNZtm7W7iuzU3TuzbrePnxHF2a27adWij+bMXasjwQWrcpFEw8+O+LC1fslLtOrRxrGa7c154PId7LabPN1bG6Na56IXjHO45L4zRiZq7dO+kWY/N0WVDL1Vq09RSHw1d9cqbwU9iuJVz8032SMl5YYxWaol0NKE8LiU9WVeMGFxhxrRZJUmjfnN1udvxxfg0YdLtlnL9Lulbbi46OlqDf3XyM92JtRPV5+JeFdZyXs8uFW6v54XdLeWsZM8+p3W5uaioqODPTXOjxo5QVFRUyFxsbEzwHg1jbruu3O3FxMRo6uP3WspJ9h9n09zlwwaVn/P5dN0t1ziSk8wbVnY31Nzct2nOtFlsmnOzFjdrNs3a3cR3a26c2Ldbx8+J4+zW3Fx78ygtnLtE0yY+rGifT/EnVs4tLCxU524dg2+sOFGz3TkvPJ7DvRbT5xsrY3TrXPTCcQ73nBfG6ETNI8cO1/IlKzXv6Rd1+NCR4Pfr1quj7n26avCwy1zNufkme6TkvDBGK7VEuqhAyTslw3MyM/bpo7UblZmRqZzjuYqvGafktGT16NNNyWlNKt9AGNnyxVatf+8j7d2dqdycXMXFFzXKLriwh9p1bOv28Cp1IOugGjSqb1sOAIDTlZebp/2ZPwZfT5OSG5d7lS7gJM5FhJNj2ceDb8gnJNYMuxxwJqj8DsYIWxvXfaLpD/xdhw78rFZtW6lb7/PVul0r/XzwZ01/YEapjwNVdYlcSbJ7icmCgoLgzblXr1ijF55+UY2bNNKgoZdq1G+u1qChA9W4SWPNm/WS3l3130q3l59foAk33Glbzuo2TW40bppzc+lp15YmPbFKT3XnzhTHso/pQNZBHcs+5vZQAFSDGnE1lN48Ta3atlR68zT+0w9HmLy2cC6eGXJzcvXD97u1/esd+uH73crNyQ2rXLGExJqq36BepY0gt3LAmYAmlIcVrzpyw62j9YvB/dW7/wUaMKi/rv+f0br1zpv06sLXJVlrVlWkeOlIu3KBQNFVQdLJVSsuHzZIXbp3VrsObdSleyddPuwyjb9nnN587W1JRfnyvg5mHQhu2zRnJbv96x3lfu34eoflXEWKlzg2ya1Y+oZtOcn+42ycCwS03WB+7M5JFhpbNjfUnN63v8CvVxct0+Tf3q+J4+7TlDv+oonj7tPk8VP02r+Xl1kZKZSSzWI7clL4NyadqNk0ezpN/Aq359LcOLFvt46fI8c5QubGiW3aPYdeqNnpWtauXqfpU2fo7lsmacINd+ruWyZp+tQZWvvOukq3FWqM4fja4oXjHO65093msezj+teT8zRx3L36+1+f1HMzX9CMvz6pibfdp+dmvqBj2cddzVXG7jexwz3nhTFSc+TjnlAeZrrqiOkSuZL9S0yaPphMV48wfRE1zVnJzpg2U3Xq1VZUVMW9W9Ocm0tPu7XkaEVzXfKTwXbnKmPc2DrRUKvsM9tWGmBO7nvh3MXK2p+lG8Zdp/RmJ1ed3L1zj9549S0tnLtYo28aWeH2SjaL7cidbi3VmXOiZtOs6dwYb8+luXFi324dP0eOc4TMjRPbtHsOvVCzk7W8svB1bf70Sw0Y1L9ocZqEeOUcz9XunRl6Z8Ua/bT/J105coilMYbja4sXjnO45053m/PnLFCN2FhNfniiGiU1DGay9v+k5S+v1Pw5C3Tz78a6lpMqrqkgPz/450jJeWGM1Fx+7kxAE8rDTFcdMW1WSfYvMZlYK0GjbxoV8v5UBQUFevCeRySZrx5Rp15t3TRhrJq1bFpme/l5+br7lkmWclay9RvW16/HXRuymVdyhRnTnJtLT7u15Oix7GP65TVXqmHjBmVyBQV+Pf3YHEdyknnDyu6Gmpv7/mzD55r6+H2qmXDy0u/EWolq2/5sNW2Rril3/Fmjbxpp3Cy28g5NuDcmnajZNGt3E9+tuXFi324dPyeOc6TMjRPbtHsOvVCzW7V8uGa9Jk67W3Xr1Sn1/aYt0nVup3Z6cNKjwSZUuL+2eOE4h3vOiW1u3bxN0/4xtczHLBslNdTIMcM1efwUV3OS/W9ih3vOzX1Tc9VzZwKaUB5muuqIabNKsn+JyaYt0pV9NLvUfkvmipW3ekSderXVo0+34OoRzc5qqt07M9SidfMy24v2+YJ/Ns1Z3eau734I2VyKio5S/Yb1LeXcXHrarSVH05unKzY2Vm3btwmZK2Z3TjJvWNndUHNz37Gxsfr50OFS/1EodvjQYcXExkoybxab5pyoxe6cEzWbZu1u4rs1N07s263j58RxjpS5cWKbds+hF2p2q5bKLgoO6GQg3F9bvHCcwz3n1L5378wI+Xtvxq49wdXA3MpJ9r+JHe45L4yRmiuuJdLRhPKwhMQEjb39+kpXHTFtVkn2LzE5dPRV8vlCfywtNjZGU6ZPliTFxMToypFDdOXIIRWuHjFq7AhFRUWVu70Zzz9mKWclO+a260Jmisc/9fF7LeXcXHrarSVHBw29tNwbksbE+DT+nnGO5CTzhpXdDTU39/2LywfoiWkz1euinkprlqr4hJrBKwzXrVmvS4YMkGTeLDbNOVGL3TknajbN2t3Ed2tunNi3W8fPieMcKXPjxDbtnkMv1OxWLb0u6qEnHpx58uN4NYs+jpexK0OrV65R7/4XWB6jW68tXjjO4Z5zYptXjBispx6ZpQ7ntz9xjp04H37Yo82ffqmRY0a4mpPsfxM73HNeGCM1V1xLpIsKWLlxCsJSbk5umSZUqI94eWGJ3P1792tvRqZycnIVHx+nlPQUJSU3dntYiADfbNmuGnE11LxlszI/C5y418XZ57TWp+s/U8KJjxWcqrCwUBvWfqyeF3Y33p7b+96y6Wt99P5G7c3IDD72U9KS1aNvt+BVeHt3Z8rni1ZSSlLIuTuQdUANGjUwzkmyvRa7c07UbJo1nRvT7bk1N5L5uR3ux8+J4xwpc2OlZrtzkVSzm7W8v/oDffT+RmVmZCo3J09x8TWUfOJ1oO+A3sF/E+6vLV44zuGec6Lm4m1uXPeJ9u7ODL6RnJKerG69z1dKWnLw37iVO3zosKKiolS7btkrkEuKlJwXxkjNZzaaUB52LPu4Fs5drE0bN8kXE3Pi3a0cFfj96tKtk0b8elipK4lMm1XVJRAIaMfWb9W6XSsdyDqofz35vDJ27VGjpIaqeeJdtax9PymtWarG3H69GjSqX+H2CgsLteGDj9Wzb3dbcla3ueqVNzVo6EBbcmeqA1kHKz3OTuQAAAAAAM6rePkuhLX5cxYoOipKkx+eqEdnP6g/z7hfj8x+UJMf+qOioqM0f07RamnhuoRpQYnlfufPXqBWbVrqoZl/1qQH/6Df3zde90y7W9OenKpWbc/SC7NeqnR7fn+h5s8yWPbdMGd1myuWvmFfzsWlp91cmtRkjHbnipmuHOPE9tzYd/G72tWds8p0bkrm/H6/tnyxVatXrNGKpau0esUabfliq/z+ypcNl5yp2e75sbK905lDO/Zr975Nc26e204fFy+f207s243zwaltOllLqPPm63LOm3A7x7zweHY6l30kW2tXr9PieUs1f/YCLZ63VGtXr1N2iYWFrOSc2mYohYWFWv/+hrDNeWGM1Fz1nBfGaKWWSEATysO2bt6ma268utSypNLJVSG2bt4mybxZJRX9ElTe18GsA5Zz69/fUO7XhrUbg7nvd+zUkBGDynw8MC4+ToOHDdLOHbskSSuWrir3a9Urbwb/nWnOSnb+7AXlfr30zCLLuYo4vfS03cfZNLf96x3lfu0oUa/ducpYaWzZ2VBzc98Fxo1Oe3PFY3SqMbl7Z4YeuGuaXnpmkb756hvtz/xR32zZrgXPLtIDdz2ojF17Kt2eEzWbZk+niV/Z9uxs2lo9zm40lt08t508Ll4/t+3OuXU+OLFNJ2sp77x5KcR5E47nmBcez07mtn65TVPvmqYNH3ysQCBQtMphIKCNH3ysB+6epm1ffWMp59Q2y2P3G8Ruv+EcCTkvjJGaIx83Jvcw01Uh3FzCdP6sBWp6VrpiYio+1eo3rKfNn36lLt07lfnZV59/pfqN6kmSVr7ypjp0OTfkxwgDJW7KbZqzkt247hP16tdTCbXK3oC7sMSy6qY5N5eedmvJ0RnTZqpOvdqKiqq4/213TlKFTb2CEjfYrKipV5Cfb3l7bu67ondU/AV+x3KS/bWY5l56ZpEGDOqviy69sExuzZvvaf6cBfrDA3c4UrNp1nRuTLdn9xxaqdnufXvh3HbruHjh3LY759b54MQ23arF9LyxknXrfPDCcbY7t/j5pRp908iQvx9/vnGTFj23RPc+PNE458Q2VyxdVX4t/pO/97qVc3Pf1Fx9OS+M0UotkY4mlIeZrgrh5hKmjZMb66qRQ9Tm3LI34M3Py9edNxW9II644Vd6ZsZcvbNyjdKapio+IT640sre3Zm6ccIYSVJyahP1HdA7eNPLU7f38YefWspZyaamp+icTm3V8fwOIXNvvb7aUs7NpafdWnK0fsP6+vW4a0OeiyXPB7tzknnDyu6Gmpv7Nm0C252T3GtMZmbsK3Wj3ZL6XNxLry5YJsmZmk2zdjfx7Z5DKzW71Vh289x267h44dy2O+fW+eDENt2qxfS8sZJ163zwwnG2O3cg66Dadzk35M/O7XyunntqvqWcE9u0+w1iN99wjpScF8ZIzRXXEuloQnlYt95dldYsTRvXfaJvt31falWI3/9pQnBVCDeXMD27XUvt27M/ZBMqOjpardu1lCS1bd9G9z86WZ9t3KTMjEwdPXxUcfE11KNvN3Xu1lG1ateSJHXq2kFHDh8NOR/Rvmj16NvNUs5KtueF3VVYzhOEL8any355qaWcm0tPu7k06a7vfgjZNIqKjlL9hvUdyUnmDSu7G2pu7tu0CWx3zolaTHNN0pL03ttr1X9gvzK5tavXqUlakmM1m2btbuLbPYdWanarsezmue3WcfHCuW13zq3zIZJqMT1vrGTdOh+8cJztzjVv1UzLFi/XoKEDS/3HNTcnVyuWvqEWrZpZyjmxTbvfIHbzDedIyXlhjNRccS2RjiaUx6WkJ+uKEYMrzJg2qyRp1NgRioqKCrmd2NgYzXj+MWu531xd7rh8MT5NmHR78O+JtRPV5+JeFdZy+bBB5W/P59N1t1xjKWcl2++SvuXmoqOjNfhXAy3lBg29tMxHJIvFxPg0/p5xkqSho6+Szxf6ndPY2BhNmT7ZUk5y4Dgb5sbcdl3IjCTFxMRo6uP3OpKTrDW27Gyoublv0yaw3TknajHNjb5xpGb/7Vm9vfxdpTZNUc2EeOUcz9WeH/YoKipaN//vWMdqNs3a3cS3ew6tHmc3GstunttuHRcvnNt259w6HyKpFtPzxkrWrfPBC8fZ7tx1t4zS3Cdf0D233aeGSQ2DbyRn/fiT0pulaczt11vKObFNu98gdvMN50jJeWGM1FxxLZEuKlDy5jPwnMyMffpo7UZlZmQq53iu4mvGKTktWT36dAv5saxwtuWLrVr/3kfauztTuTm5iosvapRdcGEPtevYtlrGcCz7WHAeS35MEd5XfI8FX4yvwtzhQ4cVFRWl2nVr27I9t/ftFrtrsTrf32zZrr0ZmcrNyVNcfA2lpCXr7HNah8Wcmc6NKSfm0K19e+HcNnUmntt2OxPPB6f2vW3LdmUanDdWsqg++zN/1N7dmcrLzVWNE28kJyU3Pu2cU9sEABM0oTxs47pPtGjuYnU4r0PRx+xK3Efpi0++1Mixw9X1gvMkWWtWmWar2gDz+/1a8Oy/de3No7R6xRq9vWy1el98gdKapSq++CODu/bog3c/1CVDBoS8PLzU9gr8evL/ntaESbdZyvkL/Fr28kqt/+9HpbrTtevW1gX9emjw0IGV/uJVUFCgv/zhIU2Zfq8tOanos/gNGtWvMBMIBLRj67dq3a6VLTmp6ObpGz74WD37dq/23KpX3tSgoQOrNQcAAAAAqB58HM/DXlu0XLfeeXPIS7u/3fadnnvqBXW94LxSzapWbVuValZNf2BGqWaVadbKNstTWBjQ+vc26NqbR+nt5e9o/KTblJxaunnVpXsnde11np6YNrPSJlRhIFDh6jPl5RbOXays/Vm6Ydx1Sm928qbou3fu0RuvvqWFcxdr9E0jK9xmIFDxildWc8XLNRd/jK08xcv42pWTTi4RWlnTyInciqVvVNo0sjsnWWts2dlQC5U1be5W9crBkk3g6swV13w68+jlmk2zpnNjZXtuzGGofYfbGKvjOJvWEkk1250Lt7nxYi1rV6/T+vc2nLiC7sR+05LVs1/3MrdBMM1GSs4rYwx5nE/zzdfq3Ga457wwRmques4LY7RSSySgCeVhR48cVXqLtJA/S2+epqNHsiWZN6usZE1zM6bNLHf8gcKTS1Hm5eapbv26IXN16tZRXl7RsuUVrSpV8qI+05wkfbbhc019/D7VTKgZ/F5irUS1bX+2mrZI15Q7/qzRN43UhBvuLHebJZnm3Fx62q0lR+fPXuBKrjJWGlt2NtROzZo2d0teOdile6dSVw7Om/WS0ZWDJZvA1ZkrrtnqPHq9ZtOs6dxY2Z4bc3jqvsNxjE4fZ9NaIqlmu3PhODdeq+WVha9r86dfasCg/iWums/V7p0ZemfFGv20/yddOXKIJBlnIyXnhZorPM6n+eZrdW4z3HNeGCM1Vz3nhTFaqSUS0ITysHYd2mj+7IUaMnxQqRXRftyXpeVLVqpdh6JV10ybVVayprmdO3bpkit+obr1yt77xO8v1I5t30kquuJp1mNzdNnQS5XatPRHC1e98qa6dO8kqeieTb+85ko1bNygzPYKCvx6+rE5lnKSFBsbq58PHS7VhCp2+NBhxcTGSpISayVo9E2jQn7UsKCgQA/e84ilnJtLT7u15OjGdZ+oV7+eSqhV9n5bhSWaknbnJPOGld0NNStZ0+au6ZWDpk1gu3OS/fPohZpNs6ZzY7o9t+bQyr7PxONsWksk1Wx3zq25sZIN91o+XLNeE6fdrbr16pTKNG2RrnM7tdODkx4NNjtMs5GS80LNTrz5avc2wz3nhTFSc9VzXhijlVoiHU0oD7v25lFaOHeJpk18WNE+n+JrFjVuCgsL1blbx+A7ZabNKitZ01xa81Q1SU3SeT06lxl/fn6BFj23RJI0cuxwLV+yUvOeflGHDx0JZurUq60efbpp8LDLJEnpzdMVGxurtu3bhNxeMdOcJP3i8gF6YtpM9bqoZ9H9qBJOvju5bs16XTJkgKSiXwyyj2aXqjfUNk1zbi497daSo6npKTqnU1t1PL9DyNxbr692JCeZN6zsbqhZyZo2d02vHDRtAtudk+yfRy/UbJo1nRvT7bk1h1b2fSYeZ9NaIqlmu3NuzU0k1VLZ/2sCOhkwzUZKzgtjdOLNV7u3Ge45L4yRmqn51FoiHU0oD0tITNDY269XXm6e9mf+GPw8eVJyY9WIqxHMmTarrGRNcxcP7FfuKnM+X3QwFxMToytHDtGVI4foWPZx5ebmKi4uTgmJpa9OGjT00lK1lRQT49P4e8ZZyknSgEEXKSWtiT56f6M2f/ZVqc/lX3fzqGBjZejoq+Tzhb5qKTY2RlOmT7aUc3PpabeWHO15YXcVFob+zcsX49Nlv7zUkZxk3rCyu6FmJWva3DW9ctC0CWx3TrJ/Hr1Qs2nWdG5Mt+fWHFrZ95l4nE1riaSa7c65NTeRVEuvi3roiQdnnvzYV82ij31l7MrQ6pVr1Lv/BcF/Z5qNlJwXxujEm692bzPcc14YIzVXPeeFMVqpJdKxOl4EyM3JLdOECvUOe2XNqtPJWtmmif1792tvRqZycnIVHx+nlPSUiF0GNpKWnvaC/775vurWr6vO3TqW+VlhYaFW/udNDf7VQC1bskKNmzQONs5K8vv9eumZRbrulmuMt2dl38eyj2nh3CXatHFTyObu1b8epoTEBBUUFGj5kpX6aO3GUlcO1q1XR937dNXgYZcpJiZGn67/TAkn7m8War8b1n6snhd2tz0nyfZ59ELNplnTuTHdnltzKJmf22ficTatJZJqtjvn1tw4UXN5tZS84tupWt5f/YE+er9owYvcnDzFxdcoWvCibzf1HdC71L81zUZKLtzH+M2W7aoRV0PNWzYrc5wDJ+4hc/Y5rY1zTmwz3HPUHJ5jpOaKa4l0NKE87Fj2cS2cu1ibNm6SLybmxLsoOSrw+9WlWyeN+PWwUlcSmTarrGStbLMiB7IO6l9PPq+MXXvUKKmhap74SFzWvp+U1ixVY26/Xg0a1Tfajp25QCCgHVu/Vet2rao1hzObleZuRVcORqozsWa7eWEOvTBGU6a1RFLNdoukuYmkWgAAsIomlIfN/vu/VCM2VpcPH6RGSQ2D38/a/5OWv7xSubl5uvl3Yy01q0yzVhtgoeTnF+jOG/+oGc8/picefEpNW6Rr8K8GlvrPdm5Orlb+5w3t/PaHSpesLLk9O3JObNM0Z7q0uSNLT7u05GhBQYH+8oeHNGX6vdWag/OOZR9TzvFcxdeMK/fjuQBwJjC94rtMLi1ZSSlJp50rj+mbclaykZLzwhipueo5L4yRmque88IYrdTidRUvy4WwtnXzNl1z49WlGlCS1CipoUaOGa6tm7dJkubPWaDoqChNfniiHp39oP484349MvtBTX7oj4qKjtL8OSdXLTLNmuYOZB0s9+tg1oHgfr/fsVNDRgwqc7VHXHycBg8bpJ07dkmStn+9o9yvHSWWtTTNSdL69zeU+7Vh7UbHchUpXrK8MsXLMNuVk9xbcjQQKDpfqjsnFTWsKlqxopi/wF/hikRWt2cla5rLzy/QhBvudD3nL/Dr1UXLNPm392viuPs05Y6/aOK4+zR5/BS99u/lwY+jVsRrNduRNT3HTLfn1hxa2feZeJwjJeeFMYZLzQeyDuqxqX/XQ/c+pmVLVuqDdz7U8pdX6eHJj2n61BnB16tyc/dOP61cZeMzfa0yzUZKzgtjpOaq57wwRmques4LY7RSSyTgxuQellgrQbt3ZoS8sXXGrj3BKw62bt6maf+YWqbBU9ysmjx+SvB7plnTnOmDqX7Detr86VfBG3OW9NXnX6l+o3qSipYkrlOvtqKiKu6fmuYkaf6sBWp6VrpiYip+ONieM1yy3Imlp91actT0F3y7c5UxbVjZ3VCzki2ZqyhfkJ8f/LNbOUlaOHexsvZn6YZx1ym9WariT9yEd/fOPXrj1be0cO5ijb5pZLnbk7xXs5VseUqeY3Zsz8k5tLJvt8bo5nGOlJwXxuiFmufPXqBWbVpq/MRxIa/4fmHWS5ow6TbbcxW9ZhWcciNc02yk5LwwRmques4LY6Tmque8MEYrtUQ6mlAedsWIwXrqkVnqcH77EytrFN1HKeOHPdr86ZcaOWaEJPNmlZWsaa5Ovdq6acJYNWvZtEwuPy9fd98ySZI04oZf6ZkZc/XOyjVKa3ryP6wZu/Zo7+5M3ThhjCSpfsP6+vW4a0PuNz8vX3feNNFSTpIaJzfWVSOHhFxVrmTW7pzpkuVOLD3t1pKjibUSNPqmUUpOaxIiV6AH73nEkZxk3rCyu6FmJWvHGMMhJ0mfbfhcUx+/TzUTTn4sN/HETXSbtkjXlDv+rNE3jYyomu3YpmlztyS35tDKvjnO3s25ue9Iqvn7HTs17u6by7xBVXzF98Rb73UkZ+VNObvf6Av3nBfGSM1Vz3lhjNRc9ZwXxmillkhHE8rDuvXuqrRmadq47hN9u+374E0uU9KT9fs/TVBKWrIk82aVlaxprtlZTbV7Z4ZatG5eZvzRvpOrwrVt30b3PzpZn23cpMyMTB09fFRx8TXUo283de7WUbVq1wpub9d3P4RsLkVFR6l+w/qWcpJ0druW2rdnf8imUXR0tFq3a+lIznTJcieWnnZrydGmLdKVfTRbjZs0qtacZN6wsruhZiVrmjNt7rqVk6TY2Fj9fOhwqSZUscOHDismNjbiajbNmp5jpttzaw6t7PtMPM6RkvPCGL1Qs+kV3/bnzN+Us/uNvnDPeWGM1EzN1Hzm1XwmoAnlcSnpybpixOAKM6bNKitZ09yosSMUFRUVclyxsTGlbtCdWDtRfS7uVWEtY267rtyfxcTEaOrj91rKSdKo31xdbtYX49OESbc7kut5YXcVFoZeF8AX49Nlv7xUknTxwH7l3szZ54sO3mzcNCdJg4ZeWu5qazExPo2/Z5wjuaGjr5LPF7r7HxsboynTJzuSk8wbVnY31KxkTXOmzV23cpL0i8sH6IlpM9Xrop5Ka5aq+BMrXmbs2qN1a9brkiEDIq5m06zpOWa6Pbfm0Mq+z8TjHCk5L4zRCzWbXvFtd87Km3J2v9EX7jkvjJGaqZmaz7yazwSsjudxmRn79NHajcrMyAyuPpWclqwefbqFfMc5nG35YqvWv/eR9u7ODC5Nn5KerAsu7KF2Hdu6PTx43N7dmfL5ostdNehA1gE1aNRA32zZrhpxNdS8ZbMymcCJ+/WcfU5r4+1Z2bdp7vChw4qKilLtumU/elmSW7liWzZ9rY/e36i9GSUe02nJ6tG3m87p1E6S+dx4oWbTrOk5Zro9t+bQyr7PxOMcKTkvjNELNUtS9pHs4BXfuTl5iouvoeS05FJXfNudK14EwhdTuskWimk2UnJeGCM1Vz3nhTFSc9VzXhijlVoiHU0oD9u47hMtmrtYHc7rUPSRuBLvgn3xyZcaOXa4ul5wniRrzSrTrJ251SvW6O1lq9X74guKrpqoefKqiQ/e/VCXDBmg/gP7STJvVtnR1PL7/Vrw7L9LXUVUHTm3ubHkaCAQ0I6t36p1u1aWctlHsvXZhk1lGh1dundSYu3ESscGAAAAAKge3BXLw15btFy33nmzbrh1tH4xuL96979AAwb11/X/M1q33nmTXl34uqSiZtX0B/6uQwd+Vqu2rdSt9/lq3a6Vfj74s6Y/MEMff/hpcJumWbtzby9/R+Mn3abLhw1Sl+6d1a5DG3Xp3kmXD7tM4+8Zpzdfe1tSUbPqhadfVOMmjTRo6KUa9ZurNWjoQDVu0ljzZr2kd1f911KuMoWFAa1/b0O159xcVt2tJUcLDJemL5nb+uU2Tb1rmjZ88LECgYDq1qsjBQLa+MHHeuDuadr21TeVbk86efWJCbPVvsy3d2o2+0i21q5ep8Xzlmr+7AVaPG+p1q5ep+wj2UbbKyws1Pr3Tc5Fd3KS+fyY5rxQ86lZv9+vLV9s1eoVa7Ri6SqtXrFGW77YKr/ff1rbK49bcxhq32fCuR3uY/RizZkZ+/TqomWa9fgzmjFtpmY9/oxeXbRMmRn7Sv07u3NObbO8mlcsXRW2OS+MkZqrnvPCGKm56jkvjJGaIx/3hPKwo0eOKr1FWsifpTdP09ETv9gXN6tCff70223f6bmnXgheMWWatTuXl5unuvXrhqylTt06yssrWua4uFmVnFr66q0u3Tupa6/z9MS0meo/sJ9xTlKFjY9AiVXq7M5VxOll1d1acrSi/4AUX6JqJbf4+aUafdPIkDdm/XzjJi16bonufbjym/wVN7ZK3qMslOKGWmU50+2dmt365TY9M+M5pTZNUVqzVNWtV0c5x3O08YOP9eqi13XjhDEhb3hfkt9fqPmzFqhn3+5hmZPM58c054WaS2Z378zQ7L89q0BASmuacuJeLrla88Z/JUXplt//RmnNUm3Zt1tzeOq+z5RzO9zH6LWaS17x3aptq1JXfE9/YEbwim+7c5Ic2WZFNa9Y+oYGDR0YljkvjJGaq57zwhipueo5L4yRmiMfTSgPa9ehjebPXqghwweVutnrj/uytHzJSrXrUHTTW9NmlZWs3bku3Ttp1mNzdNnQS5XatPRHC1e98mawyWDarDLNSdLOHbt0yRW/UN16Ze/n4PcXase27xzJubmsultLjs6ftUBNz0ovs6T06eYOZB1U+y7nhvzZuZ3P1XNPzQ/+3bSxZXdDzUrWtKlW0Tslfv/JRqdbOcn+hqMXajbNvvTMIg0Y1F8XXXphmdyaN9/T/DkL9IcH7jDenltzaGXfkXRuh/sYI6lmt94Yc2Lf82cvMKrZrZyb+6bm6st5YYzUXPWcF8ZIzeXnzgQ0oTzs2ptHaeHcJZo28WFF+3yKr1nUuCksLFTnbh2D9x0ybVZZydqdGzl2uJYvWal5T7+ow4eOBHN169VR9z5dNXjYZZLMm1WmOUlKa56qJqlJOq9H5zJznJ9foEXPLXEk5+ay6m4tOdo4ubGuGjkk5BUPp5Nr3qqZli1erkFDByouPi6Yyc3J1Yqlb6hFq5M3fjZtbNndULOSNW2qrXzlTXXocm6pmosFSqy46FZOsr/h6IWaTbOZGfvUd0DvMhlJ6nNxL726YJml7bk1h1b2HUnndriPMZJqduuNMSe2uXHdJ+rVr6cSapVdxbawxFXSbuW8MEZqrnrOC2Ok5qrnvDBGaq64lkhHE8rDEhITNPb265WXm6f9mT8Gb8qclNxYNeJqBHOmzSorWbtzMTExunLkEF05coiOZR9Xbm6u4uLilJBYs1TNps0q05wkXTywnxISyz4ZSJLPFx0co905N5dVd2vJ0bPbtdS+PftDNpeio6PVul1LS7nrbhmluU++oHtuu08Nkxqq5okb2mf9+JPSm6VpzO3XB/+daWPL7oaalaxpUy05tYn6DugdXGHu1O0V32vNrZyVmk1zXqjZNNskLUnvvb02+JHgktauXqcmaUmWtufWHFrZdySd2+E+xkiq2a03xpzYZmp6is7p1FYdz+8Qsua3Xl/tas4LY6RmaqZmaj4Taj4T0ISKAIFAoMxXSabNKitZu3Olx1CzTPOpmGmzyjQnSef17FLu3EZHR6vnhd0dyQ0dfZV8vtBX28TGxmjK9MmSpFFjRygqKqrcXPG9XkxzkjTmtuvKHWNMTIymPn6vI7lRv7m63JwvxqcJk263lGvQqIHuuH+C9mf+qL27M5WXm6sacUWrICYlNy7170wbW3Y31KxkTZtqnbp20JHDR0POT7QvWj36dnM1Z6Vm05wXajbNjr5xpGb/7Vm9vfxdpTZNOXGlZq72/LBHUVHRuvl/x1ranltzaGXfkXRuh/sYI6lmt94Yc2KbPS/srsJTrjAr5ovx6bJfXupqzgtjpOaq57wwRmques4LY6TmimuJdFGBUzsW8Ixj2ce1cO5ibdq4Sb6YGNU88YtPgd+vLt06acSvh5VquuTm5JZpBIW6FN5K1u5cKPn5Bbrzxj8a3eQZqKri+9j4YnyVJJ1j0lSDt/kL/Ppmy3btzchUbk6e4uJrKCUtWWef09rVc89pnNs4HaZvZNmdc2qbAACcyWhCedjsv/9LNWJjdfnwQWqU1DD4/az9P2n5yyuVm5unm3831lKzyjRrd66yld3+8seHjVYuM2lWWWlq2b1N01wgENCOrd+qdbtWFeYKCwu14YOPK11tyDRXnF31ypuVrs5gd87v92vBs/8Ovmu8dvU6rX9vw4n/pBf9Up+Slqye/bqrz8W9Kq3DX+DXk//3tCZMuq3SLAA46Vj2MeUcz1V8zbhyP67thZzb+wYAAN5X8Z13Eda2bt6ma268ulQDSpIaJTXUyDHDtXXzNknS/DkLFB0VpckPT9Sjsx/Un2fcr0dmP6jJD/1RUdFRmj/n5J36TbN256bc8Zdyv/7yx4eD4zuQdbDcr4NZByznnNimlX2Xp3hp88oUL2VtV644u2LpG9WeKywMaP17RSttvbLwdb37xn/Vq39Pjb9nnO57ZKImTLpNvfr31JpV7+nVha9Xvr1AoMxKd2tXr9P0qTN09y2TNOGGO3X3LZM0feoMrX1nXancli+2au7MeXpw0iOacsdf9OCkRzR35jx9/cXWSvdbVLO/whUwTifrNz0nwjwnla3Z9LhU1xgdqdn4MW3z+VAN51ekH7/TPc7+Ar9eXbRMk397vyaOu09T7viLJo67T5PHT9Fr/14evOoy3HNu77s8BQUFRqvC2p1zc9/UXH05L4yRmque88IYqbnqOS+M0UotkYB7QnlYYq0E7d6ZEfLeNRm79gTfUdy6eZum/WNqmcvCi5tVk8dPCX7PNGt3znRlN9MHp5UHsd3bNM25uay6W0uOVvQfuUCJVSE+XLNeE6fdrbr16pTKNG2RrnM7tdODkx7VlSOHVDjXp17k+crC17X50y81YFB/pTVLDd6HZ/fODL2zYo1+2v+Trhw5RKtXrNHby1ar98UXqEv3Too/ce+ajF17NG/WS7pkyICQN5QuqbihVvL+IlXNhmqqeTEnla7Z9LiEYy2Wajbdpt3ng8Pn15lw/E73OC+cu1hZ+7N0w7jrlN4sVfEnVmndvXOP3nj1LS2cu1ijbxoZ9jk3a6lIIKAKr6J2Kufmvqm5+nJeGCM1Vz3nhTFSc9VzXhijlVoiAU0oD7tixGA99cgsdTi/fdEv/8X/Wf5hjzZ/+qVGjhkhybxZZSVrd850ZTfTZpVpzoltmubcXFbdrSVHd+7YpUuu+IXq1qtdJuf3F2rHtu+KxlvJh4QDKgocyz6mX15zpRo2blAmU1Dg19OPzQn+3bSx9fbydzR+0m1KTm1SKteleyd17XWenpg2U/0H9jNuqEnmzTfTplq45yT3Go5u1myatft8cOv8kiLn+DlxnD/b8LmmPn6faiacvDdjYq1EtW1/tpq2SNeUO/6s0TeNDPucm7VMuOHOcue6JLtzTmwz3HNu7puaqy/n5r6pufpybu6bmqueOxPQhPKwbr27Kq1Zmjau+0Tfbvs+uAJcSnqyfv+nCUpJS5Zk3qyykrU7Z7qym2mzyjTnxDZNc24uq+7WkqNpzVPVJDVJ5/XoXDaXX6BFzy2RJPW6qIeeeHDmyasrahZdXZGxK0OrV65R7/4XSJLSm6crNjZWbdu3Cbm9kkwbW3m5eapbv27ITJ26dZSXly/JvKFmJWvaVAv3nJWa7W44ulmzadbu88Gt80uKnOPnxHGOjY3Vz4cOl2q0FDt86LBiYmM9kXNz34m1EjT6plFKTmtSJldQUKAH73nEkZyb+6ZmaqZmaqbmM7vmMwFNKI9LSU/WFSMGV5gxbVZZydqdq3PKu+jlMW1Wmeac2KZpzs1l1d1acvTigf3KvfGszxcd/MjQVaOuUMOkhvrwvx8ps8TqYclpybro0gvVd0BvSdKgoZeWu/pQTIxP4+8ZF/y7aWOrS/dOmvXYHF029FKlNi3+eFHRx/FWvfKmunTvJMm8oWYla9pUC/ec5F7D0c2aTbN2nw9unV9S5Bw/J47zLy4foCemzVSvi3oqrVmq4hNOfrR33Zr1umTIAE/k3Nx30xbpyj6arcZNGlU413bn3Nw3NVdfzgtjpOaq57wwRmques4LY7RSS6RjdTyPy8zYp4/WblRmRmZwdZnktGT16NMtZJc1nEVSLQhP76/+QB+9v7FMY6tH327BxlZBQYGWL1mpj9Zu1OFDR4L/tm69Ourep6sGD7tMMTEx+nT9Z0o48fGRUxUWFmrD2o/V88Ki1QhNs99s2a4acTXUvGWzMrnAiXvNnH1O67DPWalZMjsuXqjZNGv3+eDW+VUsEo6fE8dZkrZs+lofvb+xzCqfPfp2K3XVarjn3Nr33t2Z8vmilZSSVGauJelA1gE1aNTA9pyb+6ZmaqZmaqbmM7vmMwFNKA/buO4TLZq7WB3O61DihrBF7yR+8cmXGjl2uLpecJ4kaw0e06ydOSdqCfeacfoOZB1Ug0b1bcuV51j28eDVewmJZT82AgAAAAAwF+32AHD6Xlu0XLfeebNuuHW0fjG4v3r3v0ADBvXX9f8zWrfeeVNwGfuN6z7R9Af+rkMHflartq3Urff5at2ulX4++LOmPzCj1L2CTLN25+yuxQs1V6Q6llUvj1tLjubnFxjdsC8/33x7VlZJDLUiRUJiTdVvUM+2BtT+vfv1+cZNWv/+Bn2+cZP2791v6d+brpoRTrkzsWY7sqezPbfm2u/3a8sXW7V6xRqtWLpKq1es0ddfbJXf7680t8WDOavZUIqvmPJ6zgtjpOaq57wwRmques4LY6Tmque8MEZqjnw0oTzs6JGjSm+RFvJn6c3TdPRItiTzBo+VrN05u2vxQs0VKV5WvdKc4ROWlSXGnVxy9EDWwXK/DmYdCP6b7V/vKPdrR4k6THOVsdLYMm2UlcwdyDqox6b+XQ/d+5iWLVmpD975UMtfXqWH752u6VNnGM2j3c03p3NnYs12bdNqM9bNud69M0MP3DVNLz2zSN989Y32Z/6ob7Zs10vPLtIDdz2ojF17Kswt8FjOarY8BYZvDIR7zgtjpOaq57wwRmques4LY6Tmque8MEZqjnzcmNzD2nVoo/mzF2rI8EGlbnD2474sLV+yUu06FN001bTBYyVrd87uWrxQs5vLqru15Kjpf9hnTJupOvVqKyqq4j65aU5ShU24ghI3A6zoP+wF+fmWc5I0f/YCtWrTUuMnjit1I/XcnFyt/M8bemHWS5ow6TbjMYZ7Tjoza7b7HDPdnltzLUkvPbNIAwb110WXXlgmu+bN9zR/zgL94YE7IiZnpeb175f/RoK/4OQVU+Ge88IYqbnqOS+MkZqrnvPCGKm56jkvjJGay8+dCWhCedi1N4/SwrlLNG3iw4r2+RRfs+g+SoWFhercrWNwpTHTBo+VrN05u2vxQs1uLqvu1pKjderV1k0TxqpZy6Zlcvl5+br7lkmSpPoN6+vX465VyzZnhczdedNESznJvGFl2iiz8lG/73fs1Li7b1ZMTOmn3Lj4OA0eNkgTb73X0hjDPSedmTXbfY6Zbs+tuZaK7n9XfPPxU/W5uJdeXbAsonJWsvNnLVDTs9LLHJdThXvOC2Ok5qrnvDBGaq56zgtjpOaq57wwRmo+szEDHpaQmKCxt1+vvNw87c/8Mbi6TFJy41Lvhps2eKxk7c7ZXYsXanZzWXW3lhxtdlZT7d6ZoRatm5fJRft8pXK7vvshZHMpKjpK9RvWt5STzBtWpo0y01zRvutp86dfqUv3TmWyX33+leo3qmdpjOGeO3NrtvccMx+jO3MtSU3SkvTe22vVf2C/Mtm1q9epSVpSROWsZBsnN9ZVI4eozbllVy0sOY/hnvPCGKmZmqmZmqmZmsN9jFZqiXQ0oSJAIBAo81WSaYPHStbunN21eKHmiwf2U0JiQshj6vNFB5tVg4ZeGnKuJCkmxqfx94yzlJOkoaOvks8X+iqH2NgYTZk+2ZHcqLEjFBUVVW5uxvOPSZLG3HZdyExRLTGa+vi9lnKStcaWaaPMJCdJI274lZ6ZMVfvrFyjtKapii+x+uPe3Zm6ccIYy2MM59yZWrMT55jJ9tyaa0kafeNIzf7bs3p7+btKbZpyYmXTXO35YY+ioqJ18/+OjaiclezZ7Vpq3579IX/ZjI6OVut2LT2R88IYqZmaqZmaqZmaw32MVmqJdFGBU/+XD884ln1cC+cu1qaNm+SLiVHNE1fcFPj96tKtk0b8elipVb1yc3LLNEXi4uNCbts0a1fOqVrCuWZUr+LPWvtifBXmDh86rKioKNWuW/ZjkqeTK5Z9JFufbdykzIxM5ebkKS6+hpLTktW5W0fVql3L0hjDPVfsTKvZ7nPMyr7dmOuS+W+2bNfeEvtOSUvW2ee0LrWNSMlZzQIAAOAkmlAeNvvv/1KN2FhdPnyQGiU1DH4/a/9PWv7ySuXm5unm34211OAxzdqds7sWL9RslwNZB9WgUX3bcoFAQDu2fqvW7VpVa66wsFAbPvhYPft2rzS36pU3NWjoQFtyAAAAAIBqEoBn3XnTxEBuTm7In+UczwncedPEQCAQCMz627OBuU/OC/y4L6tU5sd9WYHnnnohMOtvzwa/Z5q1O2d3LV6ouSJ5efmB8dffUe05N/ftZs1+vz+w/OWVRrkP3/vItpzVfUdCzgtjrI6a9+7ODLyy8PXA09PnBP7+1ycDT0+fE3hl4euBvbszT2t7X236OvCvJ58PTLvn/wL3//7PgWn3/F/gX08+H9iy6etS/87uXEUKCgoCL8x66YzJeWGM1Fz1nBfGSM1Vz3lhjNRc9ZwXxkjNVc95YYxWaokElS99g7CVWCtBu3dmhPxZxq49wfsNbd28TdfceHWpK4wkqVFSQ40cM1xbN28Lfs80a3fO7lq8UPOBrIPlfh3MOhD8d9u/3lHu144SS6mb5qSiJULL+9qwdqNjuRVLV5X7teqVN4O5+bMXlPv10jOLLOcq4/cXasXSN4xy82ctsC1ndd+RkPPCGJ2ueeO6TzT9gb/r0IGf1aptK3Xrfb5at2ulnw/+rOkPzNDHH35qaXurV6zRC0+/qMZNGmnQ0Es16jdXa9DQgWrcpLHmzXpJ7676ryO5yhQWBrT+vfKXI460nBfGSM1Vz3lhjNRc9ZwXxkjNVc95YYzUXPWcF8ZopZZIwI3JPeyKEYP11COz1OH89kprlqqaNWsW3Yz2hz3a/OmXGjlmhKSTDZ5QN5kt2eCxkrU7Z3ctXqjZ7mXarSyr7taSoytfeVMdupwb8t5YgcKTnwzeuO4T9erXUwm1yt64vbCw0HJOKmpYlcfvP5ldsXSVrTkr+46UnBfG6GbNry1arlvvvDnkc8S3277Tc0+9oK4XnGe8vbeXv6Pxk25TcmqTUpku3Tupa6/z9MS0meo/sJ/tOanoeac8gRKPwUjJeWGM1Fz1nBfGSM1Vz3lhjNRc9ZwXxkjNVc95YYxWaol0NKE8rFvvrkprlqaN6z7Rt9u+V25uruLi4pSSnqzf/2mCUtKSJZk3eKxk7c7ZXYsXarZ/mXbzZdXdWnI0ObWJ+g7orXM6tQuZK74CJDU9Red0aquO53cImXvr9dWWcpJ5w8q0UWaas7LvSMl5YYxu1nz0yFGlt0grk5Gk9OZpOnok29L28nLzVLd+3ZDbq1O3jvLy8h3JSdLOHbt0yRW/UN16ZW+y7vcXase27yIq54UxUjM1UzM1UzM1h/sYqbniWiIdTSiPS0lP1hUjBleYMW3wWMnanbO7Fi/UbPcy7VaWVXdrydFOXTvoyOGjZTJFNUerR99ukqSeF3ZX4SmNnGK+GJ8u++WllnKSecPKtFFmmrOy70jJeWGMbtbcrkMbzZ+9UEOGD1LjJo2CmR/3ZWn5kpVq16GNpe116d5Jsx6bo8uGXqrUpqmqmVC0GELGrj1a9cqb6tK9kyM5SUprnqomqUk6r0fnsmPML9Ci55ZEVM4LY6RmaqZmaqZmag73MVJzxbVEOppQHpeZsU8frd2ozIxM5RzPVXzNOCWnJatHn25KTjv5UQqTBo/VrN05u2sJ95pHjR2hqKiokD+LjY3RjOcfkySNue26crcRExOjqY/fayknSaN+c3W5WV+MTxMm3e5I7vJhg8rP+Xy67pZrJEn9Lulbbi46OlqDfzXQUk4yb1iZNspMc1b2HSk5L4zRzZqvvXmUFs5domkTH1a0z6f4EytoFhYWqnO3jrr25lGWtjdy7HAtX7JS855+UYcPHQlm6taro+59umrwsMscyUnSxQP7lfp4c6kx+qKDtURKzgtjpOaq57wwRmques4LY6Tmque8MEZqrnrOC2O0UkukiwoEAqF/w0XY27juEy2au1gdzutQ9LGvEu9Wf/HJlxo5dri6XnCeJPMGj5WsnTknagn3mgGc2fJy87Q/80fl5uQqLj5OScmNVSOuRpW2eSz7ePDqy4TEmtWWAwAAAEzQhPKw+3//l3LvAVR8c9upj99nqcFjmrU7Z3ctXqhZqnqzqrCwUKteeVODhg60JSdJfr9fC579d6XdeNtzBX49+X9Pa8Kk2yrMFRQU6C9/eEhTpt9rSw5wS25ObpkmVKh7jJnmAAAAgLAXgGfdceMfA7m5uSF/lpuTG7jjxj8GAoFA4E//++fAjq3fhszt2Ppt4E//+0Dw76ZZu3N21+KFmjd88HHg7lvuCTz31PzAW8veCax9Z13g7eXvBJ7/5/zA3bdMCmxc90nIbZSUl5cfGH/9HbblnNhmuOcCgUAgPz8/cP/v/1xpriC/IPD3vz5pW87KviMl54UxOl1z9tFjgWf/8Xzgf8fcFbjzpomBe8dPCdx108TA/469OzD3yXmB7KPHLOUq4ubjKtwf+9Rc9ZwXxkjNVc95YYzUXPWcF8ZIzVXPeWGM1Bz5uCeUh5ne3NZ0JSYrWbtzdtfihZrtXqbdylLybi05OuWOv5SfK3FR5oQb7iw3V5JprjKBgHQg62ClucJAQNu/3mFbzsq+IyXnhTE6XfP8OQtUIzZWkx+eqEZJDYOZrP0/afnLKzV/zgLd/LuxxrmKxlCQf3IlO7tzTmwz3HNeGCM1Vz3nhTFSc9VzXhgjNVc954UxUnPVc14Yo5VaIh1NKA8zvbmtaYPHStbunN21eKFmu5dpt7KUvFtLjh7LPqZfXnOlGjZuUCZXUODX04/NkSQl1krQ6JtGhfxIYkFBgR685xFLOcm8YWXaKDPNWdl3pOTc3LcXat66eZum/WNqmfs/NUpqqJFjhmvy+CmWchWdiyXZnXNz39RcfTk3903N1Zdzc9/UXH05N/dNzdWXc3Pf1Fz13JmAJpSHJSQmaOzt11d6c1vTBo+VrN05u2vxQs12L9NuZSl5t5YcTW+ertjYWLVt3yZkrljTFunKPppdal6qkpPMG1amjTLTnJV9R0rOC2N0u+bdOzNCXgWZsWtPcOUU01yderV104SxatayaZlcfl6+7r5lkiM5N/dNzdRMzdRMzdRMzdQciTWfCWhCRYBAIFDmqyTTBo+VrN05u2vxQs12L9NuZSl5t5YcHTT00nJX/4qJ8Wn8PeMkSUNHXyWfLzpkLjY2RlOmT7aUk8wbVqaNMtOclX1HSs4LY3Sz5itGDNZTj8xSh/PbFy1eULNm0eIFP+zR5k+/1MgxIyzlmp3VVLt3ZqhF6+Zl9hvt8wX/bHfOzX1Tc/XlvDBGaq56zgtjpOaq57wwRmques4LY6TmimuJdKyO52HHso9r4dzF2rRxk3wxMap5oolR4PerS7dOGvHrYaWW1LaywpLdqzZVlnOqlnCuuZgTy7SjrL27M+XzRSspJSnkzw9kHVCDRg30zZbtqhFXQ81bNiuTCZy419PZ57Q2zlnZd6TkqNksu3HdJ9q7O1O5ubmKi4tTSnqyuvU+XylpycF/Y5I7fOiwoqKiVLtu2Y/DlmR3zs19U3P15bwwRmques4LY6Tmque8MEZqrnrOC2Ok5jMbTSgPm/33f6lGbKwuHz4o5E1rc3PzdPPvxlpq8Jhm7c7ZXYsXai7mVvPLCfv37tfejEzl5OQqPj5OKWnJ5f6HPJQDWQfVoFH9CjOBQEA7tn6r1u1a2ZIDAAAAAFQPmlAedtfN94S8aa1U1IiYPH6KHp39oHGDRzJvbNmds7sWL9TsdvOrPPn5Bbrzxj9qxvOPGecOZB3Uv558Xhm79qhRUkPVTCj62FDWvp+U1ixVY26/vtLm0uns146cVLZh5ff7te2r7UVXn+TkKC4+XinpyWpzbmv5Slwua5qzsu9IymUfydZnGzZpb0ZmsCmakpasLt07KbF2YsTlrGZDKSws1IYPPlbPvt09nfPCGKm56jkvjJGaq57zwhipueo5L4yRmque88IYqTnyhb6ZCjyh+Ka1oZS8ae3Wzdt0zY1Xl2qISCdXWNq6eVvwe6ZZu3N21+KFmufPWaDoqChNfniiHp39oP484349MvtBTX7oj4qKjtL8OQscyUlFVxyV93Uw64Dl3PzZC9SqTUs9NPPPmvTgH/T7+8brnml3a9qTU9Wq7Vl6YdZLkqTtX+8o92vH1zuC21v//oZyvzas3Wg5V5mCAr9mTJspSdq9M0MP3DVNLz2zSN989Y32Z/6ob7Zs14JnF+mBux5Uxq49lnJW9h1Jua1fbtPUu6ZpwwcfKxAIqG69OlIgoI0ffKwH7p6mbV99E1E5q9ny+P2Fmj9rgedzXhgjNVc954UxUnPVc14YIzVXPeeFMVJz1XNeGCM1Rz5uTO5hpjetNV1hyUrW7pzdtXihZruXaTfNSfYvJfr9jp0ad/fNiokp/ZQSFx+nwcMGaeKt90qSZkybqTr1aisqquL+9/xZC9T0rPQy2zvdnFTUsCqPv8Af/PNLzyzSgEH9ddGlF5bJrXnzPc2fs0B/eOAO45yVfUdKTpIWP79Uo28aqS7dO5XJfr5xkxY9t0T3PjwxYnJWal6xdFWZnxfz+wuDfw73nBfGSM1Vz3lhjNRc9ZwXxkjNVc95YYzUXPWcF8ZIzeXnzgQ0oTzs/7d39tFRlXce/04mySQBLCEhTDLhpbwGCCAm8hLRUnpai4vWVrKkUpQIoagHhCBLwBUBLR53RQSruKS1wSUrZKWtViJrBdZTICohqFVa0IAgAxMS7CpB5uZlnv0jOCbMJNzrcyd3nsn3c45HQz7c5/cZOXD4nZl7s3Oy4OrnQmVFFY4f+7TNTWsXr1zov2mt3gWPEddsz+wWFZqtWn4B5j9KNDGpJz48fCToX76PvH8Eick9L3uJuPvemUFnbGxoxJK5LX+Z7+3sjZ/MmIahI4aY4gH6F1Yedw0mTckJ+r0bvj8Rr27bacgzcnakeEDLu+hGXjsi6PdGjBmBLZtKI8oz4u565c/IvHZE0Hu1iVZPuAx3T4UZ2SzvqTAjm+U9FWZks7ynwoxslvdUmJHNHbdEOlxCKU5quhO35t7SoaN3wWPENdszu0WFZquWX4D5jxLNvetn+O3GEuzd9RZcfdMQl9ByPyr3qTM4e9qDOQtn+6936sRnQZdQtigbEpNa7hs1JGMgas6cC7pcioqKwuCMgYY8QP/Cqo8rBX/ZvR+Tb74pwNu/pwJ9XCmGPCNnR4oHAP0H9cPOl8sx9ac3t/nDVvNqeP0Pb2DAoH4R5RlxnWl9MGlKDoaPzgj6Oh56+7ASngozspnNbGYzm9kc7jOymc1XtkQ6XEIpjsddg3f3V8Lj9sB7SUNcvANOlxPjbsiG09XH7+lZ8Bh1zfbMbgn3ZisXfnn5ubDZbEHniomJ9t/MW683bORQPPLkQ3iv8gN43B7Uf1kPR1wsxk3KxpjsUejeozsAYPZ9v2j39YiOjsbq9S0f28u755/b9ezRdixccb8hD9C/sLpzzgwUP/0Cdpf/L9L6piI+IQ7eSxrOfHYGNlsUChblG/KMnB0pHgD8Yl4eSp7diuX3PYyklCT/UrSu9jzS+7kw+/5ZEeUZcUdnZeLCl/UBryEARNmjMG5SthKeCjOyWd5TYUY2y3sqzMhmeU+FGdks76kwI5s7bol0+HQ8hamsqEJZycvIHJvZ8s6XVu8++WvVR5iRPx1ZE8YC0L/gMeKa6YWiJdybSfjS3NSMY3/7BB63B5q3AY64WKS6nBgyfDDs0XbDXlfmnKcWZ0970KBpiL28FE1x9o5Yz6hLCCGEEEJIV4JLKIV5ZPFj7d5f5/ixE9iyaStWr3/Y0IJHr2u2Z3aLCs2Atcuvzlqo+Xw+/M8rf8bUn95sitfc3IxtL/w3ZhbkmeIRQgghhBBCCOkkBFGWwjnLhKZpQb+neTVROGeZEEKIlYseFdVHjwf1qo8eFysXrfF/rdc12zO7RYXmgwcOiaXzlostm0rFmzv3iv17K8Tu8r3ixedLxdJ5K0RlRVVIvFBdsz0aGhrFglmFYesJIURTU5PYuvkl/9f7dh8Q61ZtEA8WLBcLZhWKBwuWi3WrNoh9ew60+Xl6vVBcM9y9Dl/vxiax4VfPdhlPhRnZLO+pMCOb5T0VZmSzvKfCjGyW91SYkc3yngozGmmJBKKtXoKRb09G5lCUFm/HtOlT0btPsv/Ha2vqUL5jFzIyhwIA6i/UI32AK+g10vu7UH/hov9rva7ZntktKjT/qawc85cUdPjur6wJY033QnF2afG2oL1A20eO6vU2rn2uXU/4jHtXw+cTeOcvBzGzIA+vbH8NHx7+CFOmTm71TjYNp0+6sff1t3D+3HncNmOabg+A6dcMd++qr7cQ+OTv1V3GU2FGNst7KszIZnlPhRnZLO+pMCOb5T0VZmSzvKfCjEZaIgEuoRRmZkEetpfswNqiJxBltyMuvuVjXz6fD2OyR/k/hqR3wWPENdszu0WFZquWX6G4ZmVFFSbeNB4J3RMCPF+rZZBe72T1Kfzw1h/gOz17BHjNzT5UHzthyAP0L6zefusdFK1diu/0vKaN03dAOkaMzsDjK57EbTOm6fZCcc1w9wBgVeFj7b/erT4FHimeCjOyWd5TYUY2y3sqzMhmeU+FGdks76kwI5vlPRVmNNIS6XAJpTAJ3RKQf/8sNGgNOOephebV4IhzIMXZG7GOWL+nd8FjxDXbM7tFhWarll+huGZaeiqGjx6GUddlBvw6bWxoxJuv7THkufqnoU9aCsaOGxPoNTahbMsOQx6gf2F1tT8DBIQhLxTXDHcPAL66+BVu//ltSOrdK8BramrGf6z7TUR5KszIZjazmc1sZnO4z8hmNnf15q4Al1ARgBAi4J/W6F3wGHHN9sxuUaHZquVXKK45/sbr4fMF31DYo+348e0/MuR9/+abkNAt8N1SAGC3R/nP1esB+hdWE783Ds88/tw3HzmLb/nImfuUG3t2vYWcyRMMeaG4Zrh7AJDePx0xMTEYNvKb5Wfr1zvSPBVmZLO8p8KMbJb3VJiRzfKeCjOyWd5TYUY2y3sqzGikJdLh0/EU5quLl7C95GV8UPkB7NHRl/9C6EVTczOuzR6N3LvvQEK3eL+vebWApYgjzhH02npds7xQtYRz89foXdCZ7YXqmuHK4XfeQ0L3bhg2ckjA93w+Hw7uP4TxN14PANi35wDe3dfyREDN2wBHXGzLEwEnZWPSlBz/z9PrheKa4e59/LdPEOuIRf+B/QJeb3H5c+9Dhg+OGI/N4Tkjm9nMZjazmc3hPiOb2XxlS6TDJZTCFG/4HWJjYvBP06ciOSXJ/+N1586j/Pe7oGkNKHgg39CCR69rtmd2iwrNX2PV8svKs43MSAghhBBCCCEkMuASSmEeLFiOtb9eHfQdKZpXw0MLVuHJ4sd1L3gA/Ystsz2zW1RotnL5ZdXZRhd0wWhsbMKSOcuw8cV138o7d/Yczro98Ho1xMU5kOpyIiU1pcNrtebzun+gV3KiaV4orhnungozslneU2FGNst7KszIZnlPhRnZLO+pMCOb5T0VZmRzhCOIsqxctEZUHz0e9HvVR4+Lhx9YI4QQYsncIqF5taCe95JXLJlb5P9ar2u2Z3aLCs2bn35BlDz7n6K2pq6NU1tTJ7Zs2io2P/1CSDwrz9brna/9vN1/as7UiAWzCg15X7tPrnpaLL7nX8Svip4QT63ZKNYu/zdReM8ysW7VBnG+9nNxNRoaGttcU9YLxTXD3VNhRjbLeyrMyGZ5T4UZ2SzvqTAjm+U9FWZks7ynwoxsjnx4Y3KFuTX3Fmz6983IvG7k5ZsEx8N7yYvTp9z46L0jmDE7FwDQrXsCTp90Y+DQ7wZcw33qTJsbO+t1zfbMblGh+eiHx4K++ys5JQkzZk/HQwtWhcSz8my9XkePMG2NXg8ASou3YdDQgVhQdG+b8zWvhl1/fANbN7+EhSvuwyd/r273Gk2tbhqo1zPiRoqnwoxslvdUmJHN8p4KM7JZ3lNhRjbLeyrMyGZ5T4UZ2dy+1xXgEkphsnOy4OrnQmVFFU58/Kn/JsGpLicWr1yIVJcTgP4FjxHXbM/sFhWarVp+WXm2Xu+anj0wd2E++g3sG+A1NjRi6bwVhjwA+LT6JO5dWoDo6La/7TniHLjljqkomv+vAICNa5/DNT17wGaLCrhma/R6obhmuHsqzMhmeU+FGdks76kwI5vlPRVmZLO8p8KMbJb3VJiRzV0bLqEUx2azQfh88PkEfL7mln8LAZvN5nf0LniMuGZ7Zreo0GzV8svKs/V6/b7bF6dPujFgcP+AX/NRdrv/v/V6AJCY1BMfHj6Ca68fHeAeef8IEpN7XvYScfe9M4MuyhobGrFkbpEhLxTXDHdPhRnZzGY2s5nNbA73GdnMZjZ3veauANdwClNZUYWn1mzAF//3JQZnDEJ2ThaGDB+EL/7xBZ5avRGH3j7sd/UseIy6ZnqhaAn35uycLBQ+8gB6JffCiY8/xeF338fxj08gKbkXFq9ciKyJY0PiWXm2Xi8vPxdjskcF/H8CgJiYaP/NxvV6AJB718/wX7/ZhvWPPoOykh14tWwnyrbswPpHn0Fp8Xbk3nUHgJbF1qkTnwW9pi3KhsSkRENeKK4Z7p4KM7JZ3lNhRjbLeyrMyGZ5T4UZ2SzvqTAjm+U9FWZkc8ctkQ6fjqcwjyx+rN1t6vFjJ7Bl01asXv8wKiuqUFbyMkZdl4m0vmmIT2h5Ipn71Bn8teojzMifjqwJLX/51+ua7ZndokIzAHjcNXh330GcdddA83rhiItDaroT4yZlw5nWx/8amO1ZebYhb38lPG4PvJc0xMU74HQ5Me6GbDhdxj0AuHjhIt6r/AAet8f/DjWny4kx2aPQvUd3AEBzUzMAwB7d9p1UV6LXC8U1w91TYUY2y3sqzMhmeU+FGdks76kwI5vlPRVmZLO8p8KMbO7iWH1ndPLtKZyzTGha8KewaV5NFM5ZJoQQYuWiRzt88tzKRWv8X+t1zfbMblGh+eCBQ2LpvOXixedLxZs794r9eyvE7vK94sXnS8XSeStEZUVVSDwrzzbqbdlkjnc1mpubRfnvd3W6Z+XZbO48T4UZ2SzvqTAjm+U9FWZks7ynwoxslvdUmJHN8p4KMxppiQT4cTyFycgcitLi7aitqWvz47U1dXjpt2XIyBwKAKi/UI/0Aa6g10jv70L9hYv+r/W6Zntmt6jQ/KeycsxfUoBZv7wTP7hlMnImT8CUqZMx65d3Yv6SuXh1+2sh8aw826h313xzvKvR3OzD6394o9M9K89mc+d5KszIZnlPhRnZLO+pMCOb5T0VZmSzvKfCjGyW91SY0UhLJMAbkyvMzII8bC/ZgbVFTyDKbkdcfMvHvnw+H8Zkj8LMgjwA3yx4pk2fit59kv0/v7amDuU7dvkXPEZcsz2zW1Rotmr5ZeXZVjaXFm8L6gEtv/GHyrPybDZ3nqfCjGyW91SYkc3yngozslneU2FGNst7KszIZnlPhRmNtEQ6XEIpTEK3BOTfPwsNWgPOeWqheTU44hxIcfZGrCPW7+ld8BhxzfbMblGh2arll5VnW9lcWVGFiTeNR0L3BFyJz+cLmWfl2WzuPE+FGdks76kwI5vlPRVmZLO8p8KMbJb3VJiRzfKeCjMaaYl0uISKAGIdsUjvH/zdIID+BY8R12zP7BYVmq1afll5tpXNaempGD56GEZdlxnw66qxoRFvvrYnJJ6VZ7OZzWxmM5vZzGY2szm8Z2Qzm69siXS4hOpCXG3B821csz29hOLczm62cuFn1dlWNo+/8Xr4fMEfBmqPtuPHt/8oJJ6VZ7O58zwVZmSzvKfCjGyW91SYkc3yngozslneU2FGNst7KsxopCXSsQkhgr8ShBBCCCGEEEIIIYSYBJ+ORwghhBBCCCGEEEJCDpdQhBBCCCGEEEIIISTkcAlFCCGEEEIIIYQQQkIOl1CEEEIIIYQQQgghJORwCUUIIYQQQgghhBBCQs7/Ay5aTT/5Yt6hAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"Success probability: {100 * bitstring_results[0][hidden_string]:.2f}%\")\n", + "plot_bv_results(\n", + " bitstring_results[0],\n", + " hidden_string=hidden_string,\n", + " title=f\"Fire Opal ($n=19$)\",\n", + " max_columns=100,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "ac91cdf2", + "metadata": {}, + "source": [ + "### 7. Compare Fire Opal Results with Qiskit\n", + "\n", + "To get a true comparison, let's run the same circuit without Fire Opal. We'll run the circuit using Qiskit on the same IBM backend as used previously to get a one-to-one comparison." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e510737", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_ibm_runtime import SamplerV2 as Sampler\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "\n", + "backend = service.backend(backend_name)\n", + "sampler = Sampler(backend=backend)\n", + "\n", + "circuit_qiskit = qiskit.QuantumCircuit.from_qasm_str(circuit_qasm)\n", + "pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)\n", + "isa_circuit = pass_manager.run(circuit_qiskit)\n", + "ibm_result = sampler.run([isa_circuit], shots=shot_count).result()\n", + "ibm_probabilities = bitstring_count_to_probabilities(\n", + " ibm_result[0].data.c.get_counts(), shot_count, 19\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "0eec9327", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Success probability: 0.39%\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"Success probability: {100 * ibm_probabilities[hidden_string]:.2f}%\")\n", + "plot_bv_results(\n", + " ibm_probabilities,\n", + " hidden_string=hidden_string,\n", + " title=f\"{backend_name} ($n=19$)\",\n", + " max_columns=100,\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "707ca35c", + "metadata": {}, + "source": [ + "The above results demonstrate that noise has severely impacted the probability of obtaining the correct hidden string as the output. In this case, the string returned with the greatest frequency by the quantum computer was not the expected `111 111 111 11` state. We should also take note of the amount of incorrect states that now contain non-zero return probabilities. Not only do default configurations fail to find the correct answer, they also increase the probabilities of the incorrect answers.\n", + "\n", + "In fact, the performance degradation is so severe that in order to be reasonably sure of the hidden string, using the original classical algorithm would be more efficient." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "654c053b", + "metadata": {}, + "source": [ + "You can tell that Fire Opal found the correct answer because the mode of the output distribution, or the most frequent outcome, matches the desired output: bitstring `111 111 111 11`. Fire Opal significantly improves the probability of a successful outcome, often by a factor of ten or more." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "41681551", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fire Opal improved success probability by a factor of 58!\n" + ] + } + ], + "source": [ + "fire_opal_success = bitstring_results[0][hidden_string]\n", + "ibm_success = ibm_probabilities[hidden_string]\n", + "\n", + "if ibm_success != 0:\n", + " factor = fire_opal_success / ibm_success\n", + " print(f\"Fire Opal improved success probability by a factor of {int(factor)}!\")\n", + "else:\n", + " print(\"Fire Opal improved success probability by a factor of >1000X\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b1204cda", + "metadata": {}, + "source": [ + "Congratulations! You've run your first algorithm with Fire Opal and demonstrated its ability in transforming a device which finds the incorrect answer by default, to a device that finds the correct answer." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "77690d3e", + "metadata": {}, + "source": [ + "The package versions below were used to produce this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "99655780", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| Package | Version |\n", + "| --------------------- | ------- |\n", + "| Python | 3.11.8 |\n", + "| matplotlib | 3.8.4 |\n", + "| networkx | 2.8.8 |\n", + "| numpy | 1.26.4 |\n", + "| qiskit | 1.0.2 |\n", + "| qiskit-ibm-runtime | 0.23.0 |\n", + "| sympy | 1.12 |\n", + "| fire-opal | 7.2.0 |\n", + "| qctrl-workflow-client | 3.0.0 |\n" + ] + } + ], + "source": [ + "from fireopal import print_package_versions\n", + "\n", + "print_package_versions()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "FOcore39", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}