solutions/lab_3/lab3_solution.ipynb

{
    "cells": [
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Lab 3: Iterative phase estimation\n",
                "\n",
                "The quantum phase estimation (QPE) algorithm is one of the most important and famous quantum algorithms. It is a key subroutine of Shor's factoring algorithm, as well as algorithms for quantum simulation. The textbook version of the algorithm uses a number of auxiliary qubits which scales with the desired precision, leading to circuits that are challenging to execute on today's noisy devices with limited qubit number and connectivity.\n",
                "\n",
                "Iterative phase estimation (IPE) is a variant of QPE which requires only one auxiliary qubit. In IPE, the auxiliary qubit is repeatedly measured, with the measurement results used to guide future quantum operations. Until the introduction of dynamic circuits, such classical feed-forward was impossible to execute on IBM's quantum hardware.\n",
                "\n",
                "In this lab, we will use the recently introduced dynamic circuits capabilities to implement IPE."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Background\n",
                "\n",
                "Like any phase estimation algorithm, IPE is designed to solve the following problem:\n",
                "\n",
                "**Problem statement:** Given a unitary matrix $U$ and an eigenstate $|\\Psi\\rangle$ of $U$ with an unknown eigenvalue $e^{i 2\\pi \\varphi}$, estimate the value of $\\varphi$.\n",
                "\n",
                "A few important details need to be clarified in this problem statement, namely, how $U$ and $|\\Psi\\rangle$ are specified. We assume that $U$ is given as a quantum circuit implementing $U$, and in fact, we assume we have the ability to efficiently implement the operations *controlled*-$U^{2^t}$ for positive integers $t$.\n",
                "This is the same assumption used in the original QPE algorithm.\n",
                "The eigenstate is also given as a quantum circuit: we assume we have the ability to efficiently prepare $|\\Psi\\rangle$.\n",
                "\n",
                "Let's first assume for simplicity that $\\varphi$ can has an exact binary expansion, that is, it can be written as\n",
                "$$\n",
                "\\varphi = \\varphi_1/2 + \\varphi_2/4 + \\cdots + \\varphi_m/2^m = 0.\\varphi_1 \\varphi_2 \\cdots \\varphi_m\n",
                "$$.\n",
                "where in the final equality we are using \"decimal\" point notation in base 2.\n",
                "For simplicity, suppose $U$ is a unitary operator acting on one qubit (everything we say here also applies to the case where $U$ acts on multiple qubits). Since IPE requires an auxiliary qubit, we need a system of two qubits, $q_0$ and $q_1$, where $q_0$ is the auxiliary qubit and $q_1$ represents the physical system on which $U$ operates.\n",
                "\n",
                "Now, suppose that we initialize $q_0$ in the state $|+\\rangle = \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}$ and $q_1$ in the state $|\\Psi \\rangle$.\n",
                "What happens if we apply the *controlled*-$U^{2^t}$ gate, with $q_0$ being the control and $q_1$ being the target?\n",
                "Since $|\\Psi \\rangle$ is an eigenstate of $U$ with eigenvalue $e^{i 2\\pi \\varphi}$, we have\n",
                "$$\n",
                "\\begin{align}\n",
                "|+\\rangle |\\Psi \\rangle &= \\left(\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\right) |\\Psi \\rangle \\\\\n",
                "&= \\frac{|0\\rangle |\\Psi \\rangle + |1\\rangle |\\Psi \\rangle}{\\sqrt{2}} \\\\\n",
                "&\\xrightarrow{\\text{controlled-}U^{2^t}} \\frac{|0\\rangle |\\Psi \\rangle + e^{i 2 \\pi 2^{t} \\varphi} |1\\rangle |\\Psi \\rangle}{\\sqrt{2}} \\\\\n",
                "&= \\left(\\frac{|0\\rangle  + e^{i 2 \\pi 2^{t} \\varphi} |1\\rangle}{\\sqrt{2}}\\right) |\\Psi \\rangle.\n",
                "\\end{align}\n",
                "$$\n",
                "That is, the state of the system qubit remains unchanged, while a phase of $e^{i 2 \\pi 2^{t} \\varphi}$ has been \"kicked back\" into the state of the auxiliary qubit.\n",
                "\n",
                "Now, note that\n",
                "$$\n",
                "e^{i 2 \\pi 2^{t} \\varphi} = e^{i 2 \\pi 2^{t} (0.\\varphi_1 \\varphi_2 \\cdots \\varphi_m)}\n",
                "= e^{i 2 \\pi (\\varphi_1 \\cdots \\varphi_t . \\varphi_{t + 1} \\cdots \\varphi_m)}\n",
                "= e^{i 2 \\pi (0. \\varphi_{t + 1} \\cdots \\varphi_m)},\n",
                "$$\n",
                "where in the last equality, the whole number part of the \"decimal\" representation of the phase has disappeared because $e^{i 2\\pi n} = 1$ for any integer $n$.\n",
                "For example:\n",
                "- for $t=0$, the phase would be $e^{i 2 \\pi 2^{0} \\varphi} = e^{i 2 \\pi \\varphi} = e^{i 2 \\pi 0.\\varphi_1 \\varphi_2 ... \\varphi_m}$\n",
                "- for $t=1$, the phase would be $e^{i 2 \\pi 2^{1} \\varphi}= e^{i 2 \\pi \\varphi_1} e^{i 2 \\pi 0.\\varphi_2 \\varphi_3 ... \\varphi_m} = e^{i 2 \\pi 0.\\varphi_2 \\varphi_3 ... \\varphi_m}$\n",
                "- for $t=2$, the phase would be $e^{i 2 \\pi 2^{2} \\varphi} = e^{i 2 \\pi 0.\\varphi_3 \\varphi_4 ... \\varphi_m}$\n",
                "- for $t=m-1$, the phase would be $e^{i 2 \\pi 2^{m-1} \\varphi} = e^{i 2 \\pi 0.\\varphi_m}$.\n",
                "\n",
                "In the last case where $t = m - 1$, the phase is $e^{i 2 \\pi 0.\\varphi_m}$, which is equal to $1$ if $\\varphi_m = 0$ and $-1$ if $\\varphi_m = 1$.\n",
                "In the first case, the auxiliary qubit $q_0$ would be in the state $|+\\rangle = \\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}$, and in the second case it would be\n",
                "in the state $|-\\rangle = \\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}$. Therefore, measuring the qubit in the Pauli $X$ basis would distinguish these cases with a 100\\% success rate.\n",
                "This is done by performing a Hadamard gate on the qubit before measuring it. In the first case we would measure 0 and in the second case we would measure 1;\n",
                "in other words, the measured bit would be equal to $\\varphi_m$.\n",
                "\n",
                "### The algorithm\n",
                "\n",
                "In the first step of the IPE algorithm, we directly measure the least significant bit of the phase $\\varphi$, $\\varphi_m$, by initializing the 2-qubit registers as described above ( $q_0 \\rightarrow |+\\rangle$ and $q_1 \\rightarrow |\\Psi \\rangle$ ), performing a *controlled*-$U^{2^{m-1}}$ operation, and measuring $q_0$ in the Pauli $X$ basis.\n",
                "\n",
                "in the second step, we initialize the systems in the same way and apply a *controlled*-$U^{2^{m-2}}$ operation. The relative phase in $q_0$ after these operations is now $e^{i 2 \\pi 0.\\varphi_{m-1}\\varphi_{m}}= e^{i 2 \\pi 0.\\varphi_{m-1}} e^{i 2 \\pi \\varphi_m/4}$. \n",
                "To extract the phase bit $\\varphi_{m-1}$, first perform a phase correction by rotating around the $Z$-axis by an angle $-2 \\pi \\varphi_m/4=-\\pi \\varphi_m/2$, which results in the state of  $q_0$ to be $|0\\rangle + e^{i 2 \\pi 0.\\varphi_{m-1}} | 1 \\rangle$. Perform a measurement on $q_0$ in the Pauli $X$ basis to obtain the phase bit $\\varphi_{m-1}$. \n",
                "\n",
                "Therefore, the $k$-th step of the IPE, getting $\\varphi_{m-k+1}$, consists of the register initialization ($q_0$ in $|+\\rangle$, $q_1$ in $|\\Psi\\rangle$), the application of a *controlled*-$U^{2^{m-k}}$, a rotation around $Z$ of angle $\\omega_k = -2 \\pi 0.0\\varphi_{m-k+2} ... \\varphi_m$, and a measurement of $q_0$ in the Pauli $X$ basis: a Hadamard transform to $q_0$, and a measurement of $q_0$ in the computational basis. Note that $q_1$ remains in the state $|\\Psi\\rangle$ throughout the algorithm."
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Implementation\n",
                "\n",
                "In this lab, we will perform IPE on the single-qubit $S$-gate. The $S$ gate is given by the matrix\n",
                "\n",
                "$$ S =\n",
                "\\begin{bmatrix}\n",
                "1 & 0\\\\\\\\\n",
                "0 & e^{i\\pi / 2}\\\\\\\\\n",
                "\\end{bmatrix}$$\n",
                "\n",
                "We will use the eigenstate $|\\Psi\\rangle = |1\\rangle$, which has eigenvalue $e^{i\\pi / 2}= e^{i2\\pi \\cdot 1/4}$. So we have $\\varphi = 1/4 = 0.01 = 0.\\varphi_1 \\varphi_2$. Since $\\varphi$ can be represented exactly with 2 bits, our quantum circuit implementation will use a classical register with two bits to store the result.\n",
                "\n",
                "The controlled-$S$ gate can be implemented using the controlled phase gate, available in Qiskit as `CPhaseGate`, which can also be applied by calling the `cp` method of a `QuantumCircuit`. The controlled phase gate is parameterized by an angle $\\theta$ and has the matrix\n",
                "$$\n",
                "        \\text{CPhase}(\\theta) =\n",
                "            \\begin{pmatrix}\n",
                "                1 & 0 & 0 & 0 \\\\\n",
                "                0 & 1 & 0 & 0 \\\\\n",
                "                0 & 0 & 1 & 0 \\\\\n",
                "                0 & 0 & 0 & e^{i\\theta}\n",
                "            \\end{pmatrix}\n",
                "$$"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "\n",
                "### Step 1\n",
                "\n",
                "In the first step of the algorithm, we measure the least significant bit of $\\varphi$.\n",
                "\n",
                "#### Exercise 1\n",
                "\n",
                "Obtain the least significant bit of $\\varphi$ by performing the following steps:\n",
                "1. Initialize the qubits:\n",
                "   - Apply a Hadamard on the auxiliary qubit.\n",
                "   - Apply an X gate on the system qubit to put it in the $|1\\rangle$ state.\n",
                "2. Apply a *controlled*-$S^{2}$ gate by applying a `CPhaseGate` with the appropriate angle.\n",
                "3. Measure the auxiliary qubit in the $X$ basis:\n",
                "   - Apply a Hadamard gate on the auxiliary qubit.\n",
                "   - Measure it in the computational basis.\n",
                "\n",
                "The resulting circuit should look something like this:\n",
                "\n",
                "![step1-circuit](resources/step1-circuit.png)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 454.517x284.278 with 1 Axes>"
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
                "import numpy as np\n",
                "\n",
                "\n",
                "def step_1_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
                "    # qr is a quantum register with 2 qubits\n",
                "    # cr is a classical register with 2 bits\n",
                "\n",
                "    qc = QuantumCircuit(qr, cr)\n",
                "\n",
                "    ########## your code goes here #######\n",
                "\n",
                "    ##1 Initialization\n",
                "\n",
                "    q0, q1 = qr\n",
                "    # apply Hadamard on the auxiliary qubit\n",
                "    qc.h(q0)\n",
                "    # put the system qubit into the |1> state\n",
                "    qc.x(q1)\n",
                "\n",
                "    ##2 Apply control-U operator as many times as needed to get the least significant phase bit\n",
                "\n",
                "    # controlled-S is equivalent to CPhase with angle pi / 2\n",
                "    s_angle = np.pi / 2\n",
                "    # we want to apply controlled-S 2^k times\n",
                "    k = 1\n",
                "    # calculate the angle of CPhase corresponding to 2^k applications of controlled-S\n",
                "    cphase_angle = s_angle * 2**k\n",
                "    # apply the controlled phase gate\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    ##3 Measure the auxiliary qubit in x-basis into the first classical bit\n",
                "\n",
                "    # apply Hadamard to change to the X basis\n",
                "    qc.h(q0)\n",
                "    # measure the auxiliary qubit into the first classical bit\n",
                "    c0, _ = cr\n",
                "    qc.measure(q0, c0)\n",
                "\n",
                "    return qc\n",
                "\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(2, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = step_1_circuit(qr, cr)\n",
                "qc.draw(\"mpl\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Grading your answer. Please wait...\n",
                        "\n",
                        "Congratulations 🎉! Your answer is correct.\n"
                    ]
                }
            ],
            "source": [
                "# Submit your circuit\n",
                "\n",
                "from qc_grader.challenges.spring_2023 import grade_ex3a\n",
                "\n",
                "grade_ex3a(qc)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Step 2\n",
                "\n",
                "In the first step, we measured the least significant bit $\\varphi_2$. In the second (and final) step, we extract the next bit $\\varphi_1$, which will involve applying a phase correction to cancel out the phase contribution from $\\varphi_2$. The phase correction depends on the value of the classical register holding $\\varphi_2$. We need dynamic circuits to perform this classical feedback! The phase correction can be applied using `PhaseGate` or by directly calling the `p` method of a QuantumCircuit.\n",
                "\n",
                "#### Exercise 2\n",
                "\n",
                "In this exercise, we begin with the circuit from Step 1, which you should have constructed in Exercise 1.\n",
                "\n",
                "Obtain the next bit of $\\varphi$ by performing the following steps:\n",
                "1. Reset and re-initialize the auxiliary qubit.\n",
                "2. Apply the controlled unitary gate.\n",
                "3. Measure the auxiliary qubit in the $X$ basis.\n",
                "\n",
                "The resulting circuit should look something like this:\n",
                "\n",
                "![step1-circuit](resources/step2-circuit.png)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1123.41x367.889 with 1 Axes>"
                        ]
                    },
                    "execution_count": 3,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "def step_2_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
                "    # qr is a quantum register with 2 qubits\n",
                "    # cr is a classical register with 2 bits\n",
                "\n",
                "    # begin with the circuit from Step 1\n",
                "    qc = step_1_circuit(qr, cr)\n",
                "\n",
                "    ########## your code goes here #######\n",
                "\n",
                "    ##1 Reset and re-initialize the auxiliary qubit\n",
                "\n",
                "    q0, q1 = qr\n",
                "    # reset the auxiliary qubit\n",
                "    qc.reset(q0)\n",
                "    # apply Hadamard on the auxiiliary qubit\n",
                "    qc.h(q0)\n",
                "\n",
                "    ##2 Apply phase correction conditioned on the first classical bit\n",
                "\n",
                "    c0, c1 = cr\n",
                "    with qc.if_test((c0, 1)):\n",
                "        qc.p(-np.pi / 2, q0)\n",
                "\n",
                "    ##3 Apply control-U operator as many times as needed to get the next phase bit\n",
                "\n",
                "    # controlled-S is equivalent to CPhase with angle pi / 2\n",
                "    s_angle = np.pi / 2\n",
                "    # we want to apply controlled-S 2^k times\n",
                "    k = 0\n",
                "    # calculate the angle of CPhase corresponding to 2^k applications of controlled-S\n",
                "    cphase_angle = s_angle * 2**k\n",
                "    # apply the controlled phase gate\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    ##4 Measure the auxiliary qubit in x-basis into the second classical bit\n",
                "\n",
                "    # apply Hadamard to change to the X basis\n",
                "    qc.h(q0)\n",
                "    # measure the auxiliary qubit into the first classical bit\n",
                "    qc.measure(q0, c1)\n",
                "\n",
                "    return qc\n",
                "\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(2, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = step_2_circuit(qr, cr)\n",
                "qc.draw(\"mpl\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Grading your answer. Please wait...\n",
                        "\n",
                        "Congratulations 🎉! Your answer is correct.\n"
                    ]
                }
            ],
            "source": [
                "# Submit your circuit\n",
                "\n",
                "from qc_grader.challenges.spring_2023 import grade_ex3b\n",
                "\n",
                "grade_ex3b(qc)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Run on simulator\n",
                "\n",
                "Now that we have the complete circuit, let's first run it on a local simulator."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "{'01': 1000}"
                        ]
                    },
                    "execution_count": 5,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit_aer import AerSimulator\n",
                "\n",
                "sim = AerSimulator()\n",
                "job = sim.run(qc, shots=1000)\n",
                "result = job.result()\n",
                "counts = result.get_counts()\n",
                "counts"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "If your circuit is correct, you should have gotten the bitstring `01` with 100% probability. This value corresponds to the phase written in binary as $\\varphi = 0.01 = 1/4$. Indeed, this is the correct phase!"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Exercise 3\n",
                "\n",
                "Construct an IPE circuit to estimate the phase of the T gate, whose matrix is given by\n",
                "\n",
                "$$ T =\n",
                "\\begin{bmatrix}\n",
                "1 & 0\\\\\\\\\n",
                "0 & e^{i\\pi / 4}\\\\\\\\\n",
                "\\end{bmatrix}$$\n",
                "\n",
                "How many bits are needed to represent the phase in this case?"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "iVBORw0KGgoAAAANSUhEUgAABfgAAAFvCAYAAAAWkqoGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABQaElEQVR4nO3dd3RUdf7/8ddMeiG0IEkIIQQBaSEIiBQpEVARIShBLFiw7NqQ7yKsZVdw7eKKggXLz7KuICsozYZIFRUQpIYOARISMVLTSJn5/ZFllpBCZjKTyb15Ps7hwNz7uXfeE27mvvPKnc+12O12uwAAAAAAAAAAgKFYvV0AAAAAAAAAAABwHgE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYkK+3C0BZdrtUUOztKpzj7yNZLN6uwjw4BiS73a7c3Fz37dDDgoODZXHjF8Bor19y79eA74HqsdslW6G3qzAeq1/t+T8EeB803rmQXoBegF7A+MzUC3AMuMZMxwCMr66fC+t6L+QMAv5aqKBY+uscb1fhnBdvlAI4mtyGY0DKzc1VaGio+3boYdnZ2QoJCXHb/oz2+iX3fg34HqgeW6G0fLq3qzCeAeMkH39vVwGU4H3QeOdCegF6AXoB4zNTL8Ax4BozHQMwvrp+LqzrvZAzmKIHAAAAAAAAAAADIuAHAAAAAAAAAMCACPgBAAAAAAAAADAgAn4AAAAAAAAAAAyIgB8AAAAAAAAAAAMi4AcAAAAAAAAAwIAI+AEAAAAAAAAAMCACfgAAAAAAAAAADIiAHwAAAAAAAAAAAyLgBwAAAAAAAADAgAj4AaAK6tevr44dO3q7DAAA4CWhoaHq3Lmzt8sAAACAl8TGxio6OtrbZZTh6+0CAMBTYmJidOWVV6pr167q2rWrIiMj5e/vr4KCAh05ckQbNmzQhg0btHTpUqWlpVW4n/r16+u7775Tq1atdOWVV2rTpk019yIAAIDLmjVrpoEDBzp6gWbNmjl6gczMTEcv8P333+vgwYMV7ic0NFRfffWVOnfurMGDB2vt2rU1+CoAAADgqvbt26tfv37q2rWrunTpoiZNmsjPz0/5+flKTU3VL7/8og0bNmjJkiU6duxYhfuJjY3VihUrVFhYqAEDBlSaI9U0An4ApmKxWHT11Vfr/vvv15AhQ2S1lv9BpRYtWqhnz56SpOLiYi1evFhvvvmmvvvuO9ntdse4s+F+9+7dJUmzZs1Sx44dZbPZPP9iAACASwYOHKj7779fw4YNk4+PT7ljWrRooR49ekiSbDabvvnmG7355pv6+uuvS53nz4b7V1xxhSRp9uzZatu2rQoLCz3/QgAAAOA0Pz8/3XDDDbr//vsdPVx5YmNj1b9/f0lSfn6+5syZozfffFPr1q0rM27FihVq0aKFJOnNN9/UsGHDPFa/s0w/RU9WVpYmTZqkiy++WIGBgWrevLkefvhh5eTk6K677pLFYtHrr7/u7TLhYWdypPStUuo66fBG6fhh6ZwMFyZx8cUXa+XKlfrqq680dOjQMuH+b7/9poMHD+q3334rtdzHx0fDhw/Xt99+q++//16xsbGSyob7R48e1ciRI2ttuL98+XItX77c5e3/9Kc/qbi4WBEREW6sCgBK5J6Q0jb/91z8q3TqtwtuAjitRYsWWrp0qb777juNGDGiTLh/thfIzMwstdxqtWrIkCFavHixVq1apdatW0sqG+4fO3ZMN9xwQ60N9+kFAAC12anMkj4wdV1JX5h30tsVwYwuu+wybd68WbNnzy4T7hcXF+vIkSM6ePCgsrKySq0LDAzU7bffrrVr12rWrFlq3LixpLLhfkpKiu65556aeTFVZOqAf9OmTerUqZOmTp2qzMxMtW/fXoWFhZo+fbpuvPFG7dixQ5KUkJDg3UI9JC1lhV671aINX75c4ZjXbrVowctDa7CqmnX6d2nrYumHt6Ud30p7V0m7lkkb5kg/f1ByYjFz0F+XjoEHHnhAmzdvLvXmfejQIT355JPq37+/6tevr4iICMXGxioiIkINGjRQYmKinnrqqVIfqxowYIC2bt2qhx9+uEy4P2DAAKWkpNT4a6sui8Wi8ePHa8eOHcrLy9OhQ4f08ssvKzg4uNS4hQsXSpKuu+46b5TpEXXpe8BZNptN81ZN09iXLtGQxwJ18zPNNXPRBOUV5Hi7NJjMsUPSr/OkH9+Tdn7333Px99K6j6X1n0i/7fR2heZWl94Hx44dq61bt+rKK690LEtPT9fTTz+tK6+8Ug0bNnT0ApGRkapfv7769++vv//970pNTXVs07t3b23evFkTJ04sE+4PHDhQv/76a02/tGqjF6gb3wPOohcAxwBqgt0uZaSU9H7r/l3SB+5dVdIXrnlX2vS5dCLd21WaW105F/r4+Oj555/Xjz/+qHbt2jmWb9u2TX/5y1/Us2dP1atXT82aNVNsbKyaNGmipk2b6pprrtErr7yi48ePO7a56aabtH37do0dO7ZMuJ+YmFjmwlFvM23An5WVpeuuu06ZmZmaMGGCMjIytHHjRmVmZurFF1/Ul19+qfXr18tisSg+Pt7b5cIDsvb/Lziwl3PBdc6xkhPL1oWSrbjm64P7vPTSS3r99dcdP6Tu379fI0aMUFxcnJ5++mmtXLlSp06dKrXNyZMntXz5ck2ZMkWxsbEaOXKkY+7d0NBQvfrqq6YI9yVp2rRpmjZtmlJSUvTQQw/ps88+07hx47Ro0SJZLBbHuIyMDP3yyy9KSkryXrGoMW8t+j/NXPQXxTRtrweTZqhvfLLm/zBdT75/Xa39lAqMJ22ztPEz6Y8D5a8/mVHyi/jdK8z9C3d43uTJk/X//t//U7169SSV/JJ/1KhRio2N1ZNPPqlly5bpxIkTpbY5deqUVq5cqWeeeUatWrXS8OHDtXfvXklSUFCQXnrpJVOE+xK9AMpHLwCOAXia3V6Su2z/quJPb2btl375VDqyrWZrg7n4+fnp008/1aOPPur4BOf69evVr18/derUSdOmTdPPP/+svLy8UtsdPXpU33zzjSZMmKBmzZrpz3/+s2Me/qZNm+q9996r9eG+ZOI5+MeNG6e0tDQ9+OCDevnl0r+hmjRpkmbNmqXNmzerZcuWCgsL81KV8JSTGdKWBVUL7o/ukXZ8J3W42vN1wf2eeeYZTZw40fF4xowZeuyxx5STU/WrToqLizVv3jx9++23eu211zR27FjHuuzsbEOH++3bt9dDDz2kefPmaeTIkY7lBw4c0IwZMzR69GjNnj3bsXz+/Pl68sknFRIS4tTXEMaSmrldC9bMUJ+O12vy7fMcyyMatdQbC8ZpxeZPldjlZi9WCDM4urvkyqyqOPSL5Bcktezh2ZpgTo899pimTJniePzuu+/qkUceKfPL/crYbDYtXLhQS5cu1dSpU3X//fc71uXl5Rk63KcXQHnoBcAxgJqwf42UtqkKA+1SyreSf5AU3srTVcFsrFar/v3vfzv6nIKCAk2ePFlTp05VcXHVr+jNy8vT22+/rQULFujjjz/WwIEDHRdCpKWl1dpwXzLpFfw7duzQnDlzFB4erueff77cMV27dpUkde7cudTyAwcOaNiwYapXr54aNmyo2267TX/88YfHa4Z77fvBuavyM7ZJ2b97rh54RlJSkp544gnH43vuuUfjxo1z+YdRHx8fderUqdSy0NBQxcTEVKtOb7rppptktVr16quvllr+7rvvKicnR7feemup5QsWLFBgYKCuvprfeJnZ8k2zZbfbdf0V40stH9LjHgX6BWvpxn97pzCYht0u7Vnp3DYHfpQK8z1TD8xr0KBBeu655xyPx48fr3vvvdepcP9cVqu1TC8QFBSkuLi4atXpTfQCKA+9ADgG4Glnckrm2q8yu7RnFZ/qhPMeeeQRjRo1SlJJSH/dddfphRdecCrcP1dgYKDjfkxnNWnSRI0aNap2rZ5iyoB/9uzZstlsuuWWWxQaGlrumKCgIEmlA/7Tp09rwIABSktL0+zZs/XOO+9o9erVGjp0qKE/nlZUkKu801nl/jGjnGPSsYPOb1el3yoblBmPgUaNGumtt95yPH7ooYf03nvvuby/82+om52d7Vj37rvvqn79+q4X60Xdu3dXcXFxmTvAnzlzRps2bXK83rNSUlK0Z88e030034zfA9Wx6/B6WS1WtY25rNRyf79AxUUlaPfh9V6qDGbxxwHnb5pmK+aj2Z5kxvfBsLCwUuf+Rx99VK+99prL+zv/hrrnXjDw5ptvKjw83PVivYheoIQZvweqg14AHAPwtCNby58uuTI5f0gn0i48Dq4x47mwXbt2+sc//iGpZHaGG264QUuWLHF5f+ffUPfsvPwBAQH68MMPHdP/1DamnKJn2bJlkkpullmRszfVPDfgf+edd5Senq5Vq1Y5rtiNjo5Wr169tHDhQsM2uT/Pm6yf5032dhk15rddrm2XuVO6ZJB7a6ktzHgM/POf/1RERISkkhvCvf766y7v6/xw/+yc+6+88oquuuoqRUdH64UXXtB9993nltprUlRUlLKyslRQUFBmXXp6unr37i0/Pz8VFhY6li9YsEBjx46Vj4+Py7/xrm3M+D1QHX+cOqKwkHD5+waUWRdev5lSDv6owqIC+fn6e6E6mEGmizfO/W2n1KKbe2tBCTO+Dz777LOOnn3p0qV68cUXXd7X+eH+2Tn3n3jiCd1www266KKLNG3aNI0ZM8YttdckeoESZvweqA56AXAMwNNc7Qczd0oNm7u3FpQw47nwvffeU0BAyfvYK6+8oq+//trlfZ0f7qekpOiaa67RN998o3bt2umyyy7TuHHjNG3aNLfU7k6mDPjP3ijz7H/I+YqKirRmzRpJpQP+xYsXq0+fPqWm4+jZs6fi4uK0aNEilwP+bt26KTMzs8rjffyCNOKZPS49V3k6DrhXrXskl7vuixfck2i3ad1axYV5Fx5YA27p9w8N6jL2wgPPU3RGahHTUsW2wgsP9jCOAVX6qZnIyEjdcsstkkp+m/qnP/3J5eepKNxPSUnRPffco23btiksLEx33nmn/va3v1U4ZVfr1q1ltbrvQ1Hu+tRQcHCwzpw5U+66/Px8x5iTJ/93qe2CBQv0yCOPqG/fvlq+fHmVn8udXwO+B6rH3zdI7zxY8dfvTEGu/Mr5Ya5k28CSMYW5de4HutZtWqugqHb8HxrdhKR/q1Nsf6e32787TddHX+7+ggyI98HKz4UNGzbUXXfdJankU3dn/+2KisL9X3/9Vffff7/69++vxo0ba/To0Xr00UeVnp5e7n7oBegF6AWMz0y9AMeAa8x0DHjb9Hs3KSzY+U+/LZz3jQbdebcHKjKeun4uvFAv1LNnT/Xq1UuStHPnTj355JMuP1d54f7ZOffvvPNO/fjjj7JarRo/frymT59e4QUQ1emFIiIi9Msvv7i0rSkD/rMfpz3/zshnzZkzR1lZWapXr55atmzpWJ6SkqLk5LIHeocOHap1g83MzMwKfxAoj29AsMvPVZ4GEa0V03GgW/d5viMZR1R0Jtejz1FVJ0+fcHnbtLRDsjn7GTIP4Bio3N133y0/Pz9J0htvvOHUL9DOVVm4L0mHDx/WO++8o0ceeUQBAQEaO3aspk6dWu6+MjIyXKrB03Jzc3XRRReVuy4wMNAx5lxnT1TOfvTMnV8DvgeqJ9Cv8q9fgH+w8rKPlruuoKgk7Am4wD7MKOPIEeUX1o7/Q6PLyc2+8KBynDmT51TPZGa8D1bujjvucEy5+e677+rQoUMu7aeycF8q6Q1mzJihKVOmyNfXV/fcc0+pG/qei16AXoBewPjM1AtwDLjGTMeAtxUUlv/L5QvJzjlFP/hfnAsrd//99zv+/eyzzzouXHBWZeG+JK1du1aLFy/WsGHDFBMTo2uvvVYLFy4sd1/e6gdNGfBHRETo+PHj2rhxo3r27FlqXUZGhiZOnChJio+Pd9wNWSq5ErhBgwZl9teoUSPt2uXivC//rccZPn5BLj+Xt0RFRtWaq1Vyily7W+5vJ1IVGRXp5mpcwzFQ8pvait4Yx44t+YRGcXGx3nnnHZf2f6Fw/6yZM2fqkUcecTxvRQF/ZGSk26/ac8eJ4ciRI2rfvr38/f3LfDS/WbNm+v3330t9JF8quXnxiRMntGLFCqeey51fA74Hqsfft/KvX+OwKB36LUUFRWfKfCw762S66oeE17mrtSQpMiqKK7bc5GS+a+9fWdmH1axZMzdXY0y8D1Z+Ljz3iv2ZM2e6tP8Lhftnvfvuu/rb3/4mX19f3XXXXRUG/PQC9AL0AsZnpl6AY8A1ZjoGvC3r9CGF13e+rzt1JpN+8L/q+rmwsl4oNDTUcZF2VlaWPvvsM5ee40Lh/llvvfWWhg0bJqmkD60o4K9OL+RsfnwuUwb8AwcO1I4dO/Tiiy9q0KBBatOmjSRp/fr1GjNmjLKySm4ekZCQUCP1OPvxijNF0l/neKgYD9m9Z48CasnRVHRGWvWWZCtybrvew2KV9kztuJsLx0DJJ3HKu0l2RESEYmNjJUmrVq3S4cOHnd53VcN9Sdq3b59++ukn9ezZU5dccokaNmzouMnKufbs2aOQkBCna6lIRa/fWevXr9dVV12lyy67TD/88INjeUBAgBISErRq1aoy2wwfPlxfffWVioqc+yZy59eA74HqKS6Qlk+veH3b5t21YfcS7Tq0Tp3irnAsLyjM1/4jm9Qprm8NVFn77Nm9Rz517+dYj8jOkn7+0PntxoxP1IQ3ase52Nt4H6z4XBgWFqYOHTpIKjnP7d692+l9VzXcl0oC8hUrVmjgwIGKjo5WdHS0435e56IXoBegFzA+M/UCHAOuMdMx4G0ZKdL2r5zf7vl3xum1BuPcX5AB1fVzYWW90KWXXuqYe3/evHkVTkdYmaqG+5L07bffKisrS+Hh4WUuJj+Xu/vBqnLfJSa1yKRJk9S4cWMdPnxYHTp0UKdOndS6dWtddtlliouLU2JioqTS8+9LJXN5njhxosz+jh07pkaNGtVE6XAD3wApsr1z21h9pKiOnqkH7tW1a1fHv9evX+/09s6E++U9z6WXXur0c3rTnDlzZLPZNH78+FLL77nnHoWEhOiTTz4ptfySSy5R27ZttWDBghqsEjWtf+cbZbFY9PnqV0st/2rtu8ovzFVil1u8UxhMIzTc+ZujBdSTwlt5ph6Yy7nn4nXr1jm9vTPhfnnPc24vYgT0AigPvQA4BuBpTdtIzl6A3rilFNzAI+XAZM7tx1zpB50J9yXJbrc7LuBu0qSJmjevXXeCNmXAHx0drdWrV+vaa69VYGCgUlNT1ahRI7399tv68ssvHVf5nB/wt2vXrtyQLyUlRe3atauR2uEera6QghtWffwlgyX/uje9oCHFx8c7/r1x40antnUl3JekDRs2OP59/vtGbbdt2za98cYbuuGGGzRv3jzdddddevnll/XKK69oxYoVmjVrVqnxw4cP15kzZ6p153nUfi0jO2lYrwf0w7bPNeWj6/XV2vc0c9EEzVz0F8XH9VNil5u9XSJMoN1gyS+wamMtPlLHIZIbZzeBiVWnF3Al3JfoBWA+9ALgGICnWX1L+jtZLjhUkuQfIl3i2enhYSLV6QedDffPqs39YC35AKH7tWvXTosXLy6zPDs7W6mpqbJarerYsfQl20OHDtXjjz+utLQ0RUdHSyq5kcK+ffsqnHcbtZN/kHTpKGnT51J2JVPyW6zSJYOkqA41VxuqJywszPFvZ26u62q4L6nUm3y9evWcqLZ2GD9+vFJTU3Xvvffq2muvVVZWlmbMmKEnn3xSdru91Njhw4dr+fLlOn36tJeqRU25b9iratowVl+tfUfrdnypsJBwJfV+SLdf9Q+3ziGNuiu4odT1RunXz6Uzlbyl+PhL8cOcv+IfdZervYCr4b5ELwBzohcAxwA8rXFLqXOStHVR5dMoB9WXEq4v+Ruoivr1/3ewONMPuhruS7W7H7TYz+/oTG7t2rW6/PLL1bZtW+3cubPUulOnTqlTp04KDw/XU089pfz8fE2aNElNmjTRTz/9VGMnOCPOsfXijao1802ey1YkHd0jpW2STpx3E/YW3aVmnWvnx784Biqeay00NFQNGjRQUFCQ0tLSlJdXtZu3tG/fXitXrlR4eLhT4b4kBQcHKyoqSvn5+Tp+/LhycnLKjMnOzvb6vLvLly+XJA0YMMCl52zatKmOHDmiBx54wKUbFrrza8D3QPVcaM5VlG/AODHnqgcUFUiZKdLhTVJOVul1ra4omSIvoOanqaz1eB+s+FwYEhKihg0bKjAwUBkZGeWel8vTqlUr/fDDD4qIiHAq3JekoKAgRUdHKy8vTydOnFB2dnaZMfQC9AL0AsZnpl6AY8A1ZjoGapMz2VL6Vil9c8m/zwq9SGqeIEVcwte9PHX9XFhZL9SgQQOFhYUpMDBQ+/btU3FxcZX2OXDgQC1evFgBAQFOhftSydTujRo1Un5+vv744w/l5+eXGePufrCqakn7UXO2bt0qqfyPUoSFhWnZsmV6+OGHNXr0aPn6+mro0KGaNm0av702KKuvFNGu5E9BrrTqzf+ta93Pe3XBddnZ2eX+UH0hKSkpuvLKKzVr1iyNGjWqyuG+JOXm5mrv3r1OP6fRnL0jPHPuAnAnX38pOqHkl+oFOdLqczLDlj28VhYMLCcnp8qh/rn27dun/v37a968eRozZkyVw31JysvL0549e5x+TqOhFwAAeEJAqBTXU4rtIS175X/Le4yRLFWcwgc414kTJ8q9j+qFLF26VElJSXruued0zTXXVDncl6Tjx4/r+PHjTj9nTSDgP0+rVq3KndoHxucfrJK53+yq8hxwMJctW7YoPj5eNpvN26XUSu+//74++ugjFRQUeLsUACZksZT8cMe5GN60a9cueoFK0AsAADzJalWpXpBwH97wzTffaMmSJabqBwn4AdQpZnoDd7fi4uIqf6wNAACjoheoGL0AAACoC8zWD9a5gH/ZsmXeLgEAPMLV+XYBAIA50AsAAADUPUwsDwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGJCvtwtAWf4+0os3ersK5/j7eLsCc+EYkIKDg5Wdne2WfU19+1OdyslVWEiwJv5pdIXLqiM4OLja+zh/f+56/TXFnV8DvgcA1HW8D9IL0AvwPQAAqNvq+rnQ3b3Q+b2fu3tByf39YFUR8NdCFosUwP9MncYxIFksFoWEhLhlX/4BgfIvLJZ/QKBjn+Utq03c+fqNiO8BAHUd74P0AvQCfA8AAOq2un4udHcvdH7vV9t7QWcwRQ8AAAAAAAAAAAZEwA+UIzY2Vm3btlVCQoLat2+vN954o8KxycnJ+umnny64zyuuuEIHDhxwZ5kAAJiWJ87FkjR37lzdeeedSkpKUps2bdS5c2cNGjRIe/fudYzhnA0AAOB9nuwH77vvvlLLPvjgA1ksFs2fP9+xjJ4QRkHAD1Rgzpw52rRpk77++ms9/vjj2rJlS5kx69at07Fjx9SzZ88L7m/ChAmaPHmyJ0oFAMCU3H0ulqQvvvhCSUlJuvfee7Vr1y5t3rxZw4cP19133+0YwzkbAACgdvBkP3hWamqq3n33XV1++eWlxtETwigI+IELaNGihdq2bavdu3eXWff222/r5ptvliSdOHFC0dHRaty4sRISEtSuXTsFBAQ4AoNrr71WX3/9tU6ePFmj9QMAYHTuOhcXFhZqzZo1GjJkiIYMGSKLxSJJuvzyy5WamurYJ+dsAACA2sXd/WBiYqIkyWaz6e6779aMGTMUEBBQar/0hDAKAn7gArZu3aqdO3eqc+fOZdatWLFCPXr0kCQ1aNBAN998s8aPH69Nmzbp1Vdf1eWXX6733ntPkuTn56dOnTpp9erVNVo/AABG565z8fLly9WrVy/5+fmV2sdrr72m4cOHOx5zzgYAAKhdPNUPvvLKK+rdu7e6du1aZr/0hDCKOnwvZqByN954o4KCghQcHKz3339frVu3LjMmLS1NTZs2dTzetGmTxo0bJ0nasGGDunTpUmp8RESE0tLSPFs4AAAm4e5z8fz58zVixIhS2z/33HPau3evvv/++1LLOWcDAAB4nyf7wW3btmnevHlatWpVhc9PTwgjIOAHKjBnzhwlJCRUOiY4OFj5+fmOx5s2bXKcODZs2KBhw4aVGp+fn6+goCC31woAgBm581xst9v17bff6qWXXnKMffnll/X5559r6dKlCg4OLrVfztkAAADe58l+cPXq1UpNTXX80iAzM1P33nuvMjIyHDfhpSeEETBFD1AN8fHx2rVrlyQpPT1dFotFzZo1kyRt2bJFnTp1KjV+x44d5X6cDAAAuKaq5+J169apXbt2Cg0NlVTycezZs2fru+++U4MGDcrsl3M2AACAMbjaD953333KyMhQamqqUlNTdfnll+udd95xhPsSPSGMgYAfqIaRI0fq22+/lST9+uuvpT721aBBA7355puOx6mpqSouLubEAACAG1X1XPzFF18oKSlJUsnHuCdMmKATJ05owIABSkhIcMzbKnHOBgAAMBJX+sGqoCeEUTBFD1CO1NTUKo2788471atXL02ZMkVDhw7V0KFDHevWr19fauzMmTM1adIkWSwWd5YKAIApuftcvGjRIi1fvlySFB0dLbvdXuE+OWcDAAB4nyf7wfKsWLGi1GN6QhgFV/AD1RAaGqpp06bpwIEDFxwbFRWlsWPH1kBVAADUHVU9F2/fvl0XXXRRlfbJORsAAMA4PNEPSvSEMA6u4Aeq6corr6zSuLN3cAcAAO5V1XNxVXHOBgAAMBZ394MSPSGMgyv4AQAAAAAAAAAwIAJ+AAAAAAAAAAAMiIAfAAAAAAAAAAADIuAHAAAAAAAAAMCACPgBAAAAAAAAADAgX28XgLLsdrtybcXeLsMpwVYfWSwWb5cBAAAAAAAAAHUGAX8tlGsrVsNl33m7DKccTxykEB8OJwAAAAAAAACoKUzRAwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAAdWJgD8rK0uTJk3SxRdfrMDAQDVv3lwPP/ywcnJydNddd8lisej111/3dpnwMJtNkv2/D+yVjQQAXEh+Qa7emD9ONz8bo6sm+ejW52I98jz/WjJFgyZalHks1SP7R82yFYtzMACYBL0AAJeQywBu5+vtAjxt06ZNuuaaa5SZmamQkBC1b99eR44c0fTp07Vv3z4dO3ZMkpSQkODdQj2k+P0PZfv0P/L5y3hZrx5cap3dblfxxEdl37FDvq9Pl6VlrHeK9CC7XTp2UErbJP2+r/S61HVSVCfJP8grpQGAYWzet0KPzByge6+dquT+j0iS5ix/UfPXzFByv0fUMjJewQH1vFwlaitbsfT73pJz8fHD56ywS+lbpIhLJB9/b1UHAKgKegEA1VFUIGWmSIc3lV6+8TMpOkEKbyVZ68QlyIBnmDrgz8rK0nXXXafMzExNmDBBkydPVr16JU3HSy+9pL/+9a/y9fWVxWJRfHy8l6v1DOuYW2T7ea2K335Xlq6XytIk3LHO9vl82bdslXXsHaYM9wvzpM0LpBNp5a/fu0ra/6PUcah00cU1WxsAGN3GPd+pZUQn3Tt0qrdLQS2Wd0La9LmUc6z89TuWSHt/kBJGSPUja7Q0AEA10QsAqIoTadLm+VJhftl1xw6W/AltIiVcLwXye0LAJab+/di4ceOUlpamBx98UC+//LIj3JekSZMmqXPnzioqKlJsbKzCwsK8WKnnWPz85DtxgpSfr+JXXnUstx9Ok+3Df8lySVtZk2/wXoEeUlQgbZxbcbh/lq1I2rJAOrq3ZuoCALM4djpT9YIbebsM1GL5p6Vf5lQc7p9VmCtt/I90KrNm6gIAuAe9AIALOXGk5Cr98sL9c2X/Lm34VDqTUzN1AWZj2iv4d+zYoTlz5ig8PFzPP/98uWO6du2qzZs3q3Pnzo5laWlpeuGFF7Ru3Tpt3rxZBQUFstuNPTGYpfXFso4eJdsns2X78mtZrh6s4pdelux2+UycIIuPj7dLdLt9P0inf6viYLu0/Uup4Z8kv0CPlgUAhvft+g/18n/ulCRlHjugQRMtkqQxgybrtsFTqryftN/36N9L/6Ff9yzVqdw/1DgsSn3jkzVm8BQF+YdUuu2p3GP6ZOnT+mn7QmWdSlegf4giGsaqf8Jojeo/sdTYFZvmaP6aGdqfsVk2W7FaRnRScv+J6hs/0rkXDqftWCKdOV21scWF0tbFUq+7JIvFs3UBAKqHXgBAVdiKpa2L/nsPpirIOyntWirFD/dsXYAZmTbgnz17tmw2m2655RaFhoaWOyYoqGTy9XMD/r1792revHnq3r27/P39tWbNmhqp19Ost9wk209rVfzue7Lu2y/7rt2y3nu3LM2jvV2a2xUXSEe2OblNoZSRIsVc6pmaAMAs4uP66q+jP9bMRf+nsJBw3Zz4hCQpLrLqU93tTtugiW8nKjSwga69/E8Kr99M+45s1vwfpmt76hr9876V8vXxq3D7pz9O1tb9qzS0558VFxmvM4V5OvTbDm3et6LUD/UffPM3zfr+WXVve7XuuOppWSxWrdn2hZ7+OFkPJr2u4b0fcP0LgUrlnpD+OODcNnknpD9SpfCWHigIAOA29AIAqiJrX9Uv9jjr970lnwJlqh7AOaYN+JctWyZJGjBgQIVj0tJK5m85N+Dv27evMjIyJElTpkwxTcBv8fWV78S/qOih8bIt/lKWjh1kvT7J22V5ROaukpDfWembCPgB4EIiG8cpsnGcPvz2b2oY2lQDu97q9D7++Z+xalwvUq+PW6/gc7r3Lhdfqaf+db2+3/iJrup+R7nb5uSd1Ka9y3Rdz/v0YNKMCp9jT9pGzfr+WY1OfEx3XfOcY/mIPuM0+cMkvf/1YxrU9bZSzw/3Sd/i4nabCfgBoLajFwBQFWku9IN2u3RkqxTXy/31AGZm2oD/4MGDkqQWLVqUu76oqMgR3p8b8Fs9cNvubt26KTOz6hPL2v39pbffcHsdCgmR/PykoiJZuneTxY2vtU3rNrIUuJCqe8DoK/6uq7v+yentTv9hU/PoFrLL2FMyoawRd45XSGiYMjIzFB0dXeEywCz8fYP0zoN7vF1GuQ5kbNX+jC26bfBTKiw+o5M5ZxzrOrbso0D/EG3YvaTCH+r9/YLk5xugnYfWKvNYqiIaxZY77vtfP5HFYtHgrrfrZE5WqXU92w/Tj9sXKOXgT+rWdrBjees2rVVQlFft1whp/LAPlBA3yOnttq7fr2sf7OuBilDX0QugrqEXoBeozcdAbWamY8DbXrlrvRrVi3R6u9kfLtRbo+73QEWo687v/WpbLxgREaFffvnFpW1NG/Dn5JTcmSMvr/w35jlz5igrK0v16tVTy5aevVQsMzNT6enpVd8gMEAVfxjRNXa7XcX/nCYVFUoxzWWb9ams/frKEuX8m215jmQckfLPXHhgDTiTX+jSdlaLVb9lHlWhK5f/o1azFRc7/j77vVjeMsAsAv2CvV1ChQ4d3SFJ+teSyfrXksnljjmeXfFNVPx8/XXfsFf11oKHNeb5lmrRtL0SLk5Urw5JurT1laWex263a+zUSyrc1/nPk3HkiPILc515OahAcZFrvyy3ypf3ZHgEvQDqGnoBeoHafAzUZmY6BrzNanEtciwqsHFehkec3/uZqRc0bcAfERGh48ePa+PGjerZs2epdRkZGZo4sWRevvj4eFk8fDe3iIgIp8bb/f31u5trsM1fKPvmLbLeebusPS9X0QMPqfif0+Tz8otuef1RkVG15gp+u49rdeQVZOuiiCZurga1gfW/N5K2+vioWbNmFS4DzMLfN8jbJVTo7I3rR/adoO5try53TGhww0r3cV3PP6tXh+Fau+NLbdm/Uqu3zNWCNa+rf+cb9cStn559IlksFj1719fysZR/M/kWER1KPY6MiuKKLTcpsLn2g3FuwQnek+ER9AKoa+gFVOd7gdp8DNRmZjoGvC234IQayPmMpUh5nJfhEef3frWtF3Q2Pz6XaQP+gQMHaseOHXrxxRc1aNAgtWnTRpK0fv16jRkzRllZJR/RS0hI8Hgtzn68Iqe4SA2Xfee257enp8v2/oeytG0j66iRsvj4yHrrLbJ98JFs8xfKZ0T1b1G+e89uhfjUjsMp+3fp54+c3y6uS6jjvgwwl+fe+ESnsnMUGRHp+D8ubxlgFsUF0vLp3q6ifM3CW0uSrFYfXdpmoMv7aRwWqSE97taQHner2FasF2eP0fJNszWy3wS1bd5dzcJba/2ub3RRgxi1aNquSvvcs3uPfPxdLgnnOLpb2rLQ+e2uHBmvu6fyngz3oxdAXUMvQC9Qm4+B2sxMx4C37ftBOvCz89s9PPkmPf3hTe4vCHXe+b2fmXpB9084X0tMmjRJjRs31uHDh9WhQwd16tRJrVu31mWXXaa4uDglJiZKKj3/vhnZbTYVT31FstnkM/Evspz97dSokbK0aS3b+x/KfiTDy1W6V2gTqYELU2dFJ7i9FADAeS5u1kWxER21+OeZyvhjf5n1xcVFOpV7rMLt8wtylV9Q+upwH6uP4iLjJcmx7cCuYyRJH3z9uIptxWX2c/x0xR/9R/WFXywFhDq3jcUqNevomXoAALUHvQBQNzSLl+TkhBFBDaTGsR4oBjC52nHJtQdER0dr9erVmjhxolauXKnU1FS1b99eb7/9tu655x61atVKkvkDftvcz2VP2SHr3XfKEhPjWG7x8ZHPI39x+1Q9tUVcL+nXuZLdVrXxTVpL9d1zOwIAQCUsFov+OvpjTXo7Ufe+Eq+ru49Vi6YddKYwV+lZe7Vm2+cae83zFd5YL+333Zows596dxihlhEdFRrcUId+26HFP72liEYt1anlFZKkts2767ZBU/Sv76boz9MS1Dc+WY3DonTsVIb2pG/Qup1f6esXasfUcmZktUqt+kgp31R9m5hukn+I52oCANQO9AJA3RAYJjXvIh3eWPVtWvWRTBRNATXGtAG/JLVr106LFy8uszw7O1upqamyWq3q2NG8l4rZDx2S7aOPZWl3iaw3XF9mvSW2hdun6qktGsVIHa6Rtn994ZC/YYzUcUjN1AUAkC5ulqC3/u9XzV72vH5KWajFP89UUEA9RTSM1eBud6jLOTfIO99FDZrr6u5jtWnvcv24fb4Ki84ovH4zXdPjHt044K8K9P/fDeXGDJ6sNs276YsfpuuL1a8qvyBHDUIvUmxER90/nM+se1pUR+lMjrRv9YXHRnaQLr7C8zUBAGoHegGgbmjdXyrIlX7beeGxbQZIERXfExtAJUwd8Fdk+/btstvtatOmjYKDy95Zfu7cuZKklJSUUo9jY2PVrVu3miu0miwxMfL7ckGlY3xuulE+N91YQxXVrIh2UkA96cBP0rGDZdf7h0jRnaXYHpK1/HsuAQAkdW7VX99NtZda9u/HU6u1z6YNW2j8DTMvOO62wVN02+ApjsdhIY1137BpVX6eHu2uVY9217pSItygZQ8ppJGUulY6lVl2fXBDKaar1KwzV2sBQG1GLwDAFVar1PHakhkTDm+U8k6WHVM/qiSXadKq5usDzKJOBvxbt26VVPH0PMnJyeU+vv322/Xhhx96tDa4V8NoqWGylHNM+n2vVJhfEuaHNik5eRDsAwDgWRe1LvlzMqPkF+5FZyQf/5If9Bq1INgHAAAwM4ul5IKO5pdKfxwoueijuFDyDZAat5TCmnq7QsD4CPjLYbfby10O4wppJIVc5u0qAMC8cvJO6kxhXqVjfH39FRbcqIYqQm1TP5L73QCAmdELAKiMxSKFx5X8AeBeBPwAAKDa3ljwsL7b8FGlY+Lj+umf962omYIAAECNohcAAMA76mTAv2zZMm+XAACAqdw4YJIGXnprpWNCgxvWUDUAAKCm0QsAAOAddTLgBwAA7tWiaXu1aNre22UAAAAvoRcAAMA7rN4uAAAAAAAAAAAAOI+AHwAAAAAAAAAAAyLgBwAAAAAAAADAgAj4AQAAAAAAAAAwIAJ+AAAAAAAAAAAMiIAfAAAAAAAAAAADIuAHAAAAAAAAAMCACPgBAAAAAAAAADAgAn4AAAAAAAAAAAyIgB8AAAAAAAAAAAPy9XYBKCvY6qPjiYO8XYZTgq0+3i4BAAAAAAAAAOoUAv5ayGKxKMSH/xoAAAAAAAAAQMWYogcAAAAAAABOyS/I1Rvzx+nmZ2N01SQf3fpcrEee519LpmjQRIsyj6V6ZP8AYHRcJg4AAAAAAIAKbd63Qo/MHKB7r52q5P6PSJLmLH9R89fMUHK/R9QyMl7BAfW8XCUA1E0E/AAAAAAAAHDKxj3fqWVEJ907dKq3SwGAOo0pegAAAAAAAOCUY6czVS+4kbfLAIA6jyv4AQAAAAAAUCXfrv9QL//nTklS5rEDGjTRIkkaM2iybhs8pcr7Sft9j/699B/6dc9Sncr9Q43DotQ3PlljBk9RkH9Ipdueyj2mT5Y+rZ+2L1TWqXQF+ocoomGs+ieM1qj+E0uNXbFpjuavmaH9GZtlsxWrZUQnJfefqL7xI5174QBQSxHwAwAAAAAAoEri4/rqr6M/1sxF/6ewkHDdnPiEJCkuMr7K+9idtkET305UaGADXXv5nxRev5n2Hdms+T9M1/bUNfrnfSvl6+NX4fZPf5ysrftXaWjPPysuMl5nCvN06Lcd2rxvRamA/4Nv/qZZ3z+r7m2v1h1XPS2Lxao1277Q0x8n68Gk1zW89wOufyEAoJYg4AcAAAAAAECVRDaOU2TjOH347d/UMLSpBna91el9/PM/Y9W4XqReH7dewYH/uzlvl4uv1FP/ul7fb/xEV3W/o9xtc/JOatPeZbqu5316MGlGhc+xJ22jZn3/rEYnPqa7rnnOsXxEn3Ga/GGS3v/6MQ3qelup5wcAI2IOfgAAAAAAANSIAxlbtT9jiwZ0uVmFxWd0MifL8adjyz4K9A/Rht1LKtze3y9Ifr4B2nlorTKPpVY47vtfP5HFYtHgrreXeo6TOVnq2X6Ycs+cVsrBnzzwCgGgZnEFPwAAAAAAAGrEoaM7JEn/WjJZ/1oyudwxx7N/q3B7P19/3TfsVb214GGNeb6lWjRtr4SLE9WrQ5IubX1lqeex2+0aO/WSCvdV2fMAgFEQ8AMAAAAAAKBG2O12SdLIvhPUve3V5Y4JDW5Y6T6u6/ln9eowXGt3fKkt+1dq9Za5WrDmdfXvfKOeuPXTs08ki8WiZ+/6Wj4Wn3L30yKig+svBABqCQJ+AAAAAAAA1Ihm4a0lSVarjy5tM9Dl/TQOi9SQHndrSI+7VWwr1ouzx2j5ptka2W+C2jbvrmbhrbV+1ze6qEGMWjRt567yAaDWYQ5+AAAAAAAA1IiLm3VRbERHLf55pjL+2F9mfXFxkU7lHqtw+/yCXOUX5JZa5mP1UVxkvCQ5th3YdYwk6YOvH1exrbjMfo6fZnoeAObAFfwAAAAAAACoERaLRX8d/bEmvZ2oe1+J19Xdx6pF0w46U5ir9Ky9WrPtc4295nld1f2OcrdP+323Jszsp94dRqhlREeFBjfUod92aPFPbymiUUt1anmFJKlt8+66bdAU/eu7KfrztAT1jU9W47AoHTuVoT3pG7Ru51f6+oWCGnzlAOAZBPwAAAAAAACoMRc3S9Bb//erZi97Xj+lLNTin2cqKKCeIhrGanC3O9TlnJvlnu+iBs11dfex2rR3uX7cPl+FRWcUXr+Zrulxj24c8FcF+gc7xo4ZPFltmnfTFz9M1xerX1V+QY4ahF6k2IiOun/49Jp4qQDgcQT8AAAAAAAAqFDnVv313VR7qWX/fjy1Wvts2rCFxt8w84Ljbhs8RbcNnuJ4HBbSWPcNm1bl5+nR7lr1aHetKyUCgCEwBz8AAAAAAAAAAAbEFfwAAAAAAAColpy8kzpTmFfpGF9ff4UFN6qhigCgbiDgBwAAAAAAQLW8seBhfbfho0rHxMf10z/vW1EzBQFAHUHADwAAAAAAgGq5ccAkDbz01krHhAY3rKFqAKDuIOAHAAAAAABAtbRo2l4tmrb3dhkAUOdwk10AAAAAAAAAAAyIgB8AAAAAAAAAAAMi4AcAAAAAAAAAwIAI+AEAAAAAAAAAMCACfgAAAAAAAAAADMjX2wUAgDsVFhVJ9vOX2h1/FxYWVbJMkkXy8+WtEQAAAAAAALUfKRYAU1n2469a/tOv5a47lZ2rv7/yfqXLBl3RTVf2utSjNQIAAAAAAADuwBQ9AEzlyt6XqlnTcJe2jYm6SP0vT3BvQQAAAAAAAICHEPADMBVfHx+NGjpAvj4+Tm3n5+erUUMHyMfK2yIAAAAAAACMgSQLgOk0DW+oq/tf5tQ2QxMvV3jD+h6qCAAAAAAAAHA/An4AptSra0dd3KJZlca2jWuuyzq383BFAAAAAAAAgHsR8AMwJavFopFD+ikwwL/SccFBAbrhmn6yWCw1VBkAAAAAAADgHgT8AEyrQViokgb3qXTMiKuuUFhocA1VBAAAAAAAALiPr7cLAABP6tyulVL2pGrLzv1l1nXp0Fqd2sZ5oSrA+2w2m7744TV9+fPbyjyeqgYhTdS38yjdftU/FOQf4u3yAACAh9ELAABgDnXmCn6bzaa5c+cqKSlJUVFRCggIUFRUlBITE/Xaa6+poKDA2yUC8ACLxaKkwX1U77yr9BuEhWr4oN5eqgrwvrcW/Z9mLvqLYpq214NJM9Q3Plnzf5iuJ9+/TjabzdvlAQAAD6MXAADAHOrEFfxHjx7VqFGjtHLlSklSTEyMEhISlJmZqeXLl+vnn3/Wgw8+6OUqAXhKcFCgkq/pp/c/+9qxLHlI/wvOzw+YVWrmdi1YM0N9Ol6vybfPcyyPaNRSbywYpxWbP1Vil5u9WCEAAPAkegEAAMzD9Ffw5+TkaMiQIVq5cqX69eunzZs36+DBg1q7dq0OHjyobdu26dFHH5WPj4+3SwXgQW3imqvnpe0lSX26d1KrFlFergjwnuWbZstut+v6K8aXWj6kxz0K9AvW0o3/9k5hAACgRtALAABgHqa/gn/ChAnasGGD+vTpoyVLlsjfv/QVux06dFCHDh28VB2AmnRN/8t1KjtXV/Xt7u1SAK/adXi9rBar2sZcVmq5v1+g4qIStPvwei9VBgAAagK9AAAA5mGx2+12bxfhKTt37lTHjh3l6+ur3bt3KyYm5oLbHDhwQA8//LCWL18uX19fXXfddZo2bZoaN27sch0zPvpcp7PzXN4eAABnWO0+6pY/usL19/yzk05kH9Vnk38rs+7pj0dp1ZbP9NXzZ+TnW7emsfol8FPZLMXeLgOAB5zOyZXdbpfFYlG9kOAKlwFmQS/gGjP1Ahc6BlA+Mx0DAEo7v/erbb1gvdAgPXT79S5ta+or+GfNmqXi4mLddtttVQr3T58+rQEDBqhRo0aaPXu28vLyNGnSJA0dOlRr1qyR1erajEans/N0KjvHpW0BAHCWVb5SJTPPnSnIlZ9vQLnr/H0DS8YU5ta5H+pP5eTKpiJvlwHAg+x2e5m+vLxlgNHRC7jGTL3AhY4BlM9MxwCA8p3f+5mhFzR1wL906VJJ0pAhQ6o0/p133lF6erpWrVrl+IVAdHS0evXqpYULFyopKcmlOuqFBrm0HQAArrDafaT8itcH+AcrL/touesKiko2DPDz/hUMNS0sJJgrtgCT4gp+1DX0Aq4xUy9woWMA5TPTMQCgNCNcwe8qUwf8hw8fliTFxcVVafzixYvVp0+fUlf79+zZU3FxcVq0aJHLAb+rH68AAMAVxQXS8ukVr28cFqVDv6WooOiM/M+7ei/rZLrqh4TXuSv2JGnivaPlU/deNlAnPPfGJzqVnaN6IcF6/IFbKlwGmAW9gGvM1Atc6BhA+cx0DAAo7fzez0y9oKkD/pycko9X5OVVbf77lJQUJScnl1neoUMHpaSkuFwHc/ADAGqS1e6jbqp4ztW2zbtrw+4l2nVonTrFXeFYXlCYr/1HNqlTXN+aKLPWmfoOc64CZnU6J9fx93NvfFLhMsAs6AVcY6Ze4ELHAMpnpmMAQGnn9361rRdkDv4KNG/eXMePH9ePP/6o3r17X3D88ePH1aBBgzLLGzVqpF27drlcB3PwAwBq0oXmXO3f+UbNXvacPl/9aqkf6r9a+67yC3OV2MXYVy+4ijlXAfNjDn7UFfQCrjFTL8Ac/K4x0zEAoHzMwW8wI0aM0JYtW/Tss8+qc+fOGjx4sGNdenq6PvroIyUnJ6t169YerYM5+AEANelCc662jOykYb0e0II1r2vKR9frskuG6NDRHZr/w3TFx/VTYpeba67YWoQ5VwHzYg5+1DX0Aq4xUy/AHPyuMdMxAKA0M8/Bb7Hb7XY31lKrZGdnq1+/ftq4caMkKSIiQs2bN9exY8e0f/9+WSwWnTp1SiEhIZKkpk2bKjk5Wa+//nqp/QwbNky///67fvrppxp/DQAAOKsqc64W24r1+epX9dXad/TbsVSFhYSrf+cbdftV/1BQQGjNFFrLDBgn5lwFTOrsHKthoSFl5uA/dxlgFvQCrjFTL8Ac/K4x0zEAoLTzez8z9YKmvoI/NDRUq1ev1rRp0/TZZ59p9+7dOnnypCIiIpSUlKTrr7/eEe5LUrt27cqdaz8lJUV9+9bNOQgBAObkY/VRcr8JSu43wdulAAAAL6AXAADAHEwd8EtScHCwnnjiCT3xxBMXHDt06FA9/vjjSktLU3R0tCRp7dq12rdvn6ZOnerpUgEAAAAAAAAAqDKrtwuoTe69915FRkZq+PDhWrx4sebOnaubbrpJl112mYYPH+7t8gAAAAAAAAAAcCDgP0dYWJiWLVumyMhIjR49Wnfffbd69eqlxYsXy2rlSwUAAAAAAAAAqD1MP0WPs1q1aqXFixd7uwwAAAAAAAAAACrFZekAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBAvt4uAAAAuJfVTxowzttVGI/Vz9sVAADgHvQCrqEXAAAYEQE/AAAmY7FIPv7ergIAAHgLvQAAAHUHU/QAAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBAvt4uAAAAAADc5edfU7T/0JFSy/Ly8x1/z1qwtMJlktQ88iJdcVl8DVULAAAAVA8BPwAAAADTaNcqRt+sXKf8MwVl1hUWFWvLzv0VLvPz89XgK7rXSJ0AAACAOzBFDwAAAADTqB8WqqTBfVza9toBlyu8UX03VwQAAAB4DgE/AAAAAFNJaH+xOrdr5dQ2beOaq0dCOw9VBAAAAHgGAT8AAAAA0xk+qLfCQoOrNDY4KEA3XNNPFovFw1UBAAAA7kXADwAAAMB0goMClTykf5XGjrjqiir/MgAAAACoTQj4AQAAAJhS65bR6nlph0rHdOnQWp3axtVQRQAAAIB7EfADAAAAMK1r+vdQkwpunNsgLFTDB/Wu4YoAAAAA96lTAb/NZtPcuXOVlJSkqKgoBQQEKCoqSomJiXrttddUUFDg7RIBAAAAuJG/n69GDR0gaznz6ycP6a/AAH8vVAUA3mez2TRv1TSNfekSDXksUDc/01wzF01QXkGOt0sDADihzgT8R48eVWJiopKTk7VgwQL5+fkpISFBfn5+Wr58uR577DH5+Ph4u0wAAAAAbtY88iIl9r601LI+3TupVYsoL1UEAN731qL/08xFf1FM0/Z6MGmG+sYna/4P0/Xk+9fJZrN5uzwAQBX5eruAmpCTk6MhQ4Zow4YN6tevn6ZPn674+HjH+u3bt2vevHkE/AAAAIBJDejZRbv2HdLhjN/VNLyhrurb3dslAYDXpGZu14I1M9Sn4/WafPs8x/KIRi31xoJxWrH5UyV2udmLFQIAqqpOXME/YcIEbdiwQX369NGSJUtKhfuS1KFDBz355JNeqg4AAACAp/lYrRo1dIACA/w1augA+fnWiWudAKBcyzfNlt1u1/VXjC+1fEiPexToF6ylG//tncIAAE6z2O12u7eL8KSdO3eqY8eO8vX11e7duxUTE1Pp+LS0NL3wwgtat26dNm/erIKCAlX3SzTjo891OjuvWvsAAAAAUH02u01WS524zglAHWa1+6hb/ugK1z/67lX6dc9SLXouV/6+AaXWPfx6b6Vn7dbcKb97usxa55fAT2WzFHu7DAAecDonV3a7XRaLRfVCgss89rZ6oUF66PbrXdrW9JetzJo1S8XFxbrtttsuGO5L0t69ezVv3jx1795d/v7+WrNmTbVrOJ2dp1PZ3KQGAAAAAAB4nlW+UiWzEP9x6ojCQsLLhPuSFF6/mVIO/qjCogL5+datG5GfysmVTUXeLgOAB9nt9lI57fmPjcj0Af/SpUslSUOGDKnS+L59+yojI0OSNGXKFLcE/PVCg6q9DwAAAAAAgKqw2n2k/IrXnynIlV854b4k+fsGlowpzK1zAX9YSDBX8AMmZYQr+F1l+oD/8OHDkqS4uLgqjbda3f9xXVc/XgEAAAAAAOCs4gJp+fSK1wf4Bysv+2i56wqKSn4zEODn/cCrpk28d7R86tbvNIA647k3PtGp7BzVCwnW4w/cUuaxkZk+4M/JKfmIRV6e9+bAZw5+AAAAAABQU6x2H3VTxXPwNw6L0qHfUlRQdKbMND1ZJ9NVPyS8zl29L0lT32EOfsCsTufkOv5+7o1Pyjz2Nubgr0Tz5s11/Phx/fjjj+rdu7dXamAOfgAAAAAAUFMuNAd/2+bdtWH3Eu06tE6d4q5wLC8ozNf+I5vUKa5vDVRZ+zAHP2B+zMFvQCNGjNCWLVv07LPPqnPnzho8eLBjXXp6uj766CMlJyerdevWHquBOfgBAAAAAEBNudAc/P0736jZy57T56tfLRXwf7X2XeUX5iqxi7Gnq3AVc/AD5mXmOfgtdrvd7sZaap3s7Gz169dPGzdulCRFRESoefPmOnbsmPbv3y+LxaJTp04pJCSkzLZTpkzRU089JZN/iQAAAAAAgIlcaA5+SXp9/kNasOZ19e44QpddMkSHju7Q/B+mq0Nsb0390zKP3KOwthswTszBD5jU2Tn3w0JDSs3Bf/axkZn+Cv7Q0FCtXr1a06ZN02effabdu3fr5MmTioiIUFJSkq6//vpyw30AAAAAAACzum/Yq2raMFZfrX1H63Z8qbCQcCX1fki3X/WPOhnuA4BRmT7gl6Tg4GA98cQTeuKJJ7xdCgAAAAAAgNf5WH2U3G+CkvtN8HYpAIBqqBMBv7Pmzp0rSUpJSSn1ODY2Vt26dfNaXQAAAAAAAAAAnEXAX47k5ORyH99+++368MMPvVARAAAAAAAAAAClEfCXg5vqAgAAAAAAAABqO+6aAgAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABuTr7QIAAAAAAADgPlY/acA4b1dhPFY/b1cAAM4j4AcAAAAAADARi0Xy8fd2FQCAmsAUPQAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGJCvtwsAAAAAAAAAAKC67Ha79h06IpvNXmp5UXGx4+/dB9LKPD5X/dBgNW3SqGYKdgOL3W63X3gYAAAAAAAAAAC123c//KLv12x0aVsfq1X335akZk3D3VyV5zBFDwAAAAAAAADAFBJ7XqroyCYubTuwT1dDhfsSAT8AAAAAAAAAwCR8fKy68doB8vP1cWq7Fs2aqm+Pzh6qynMI+AEAAAAAAAAAptGkcQMNGXB5lcf7+/lq1LUD5GM1XlxuvIoBAAAAAAAAAKjE5V3aq3VsdJXGDk3sqcYNwzxckWcQ8AMAAAAAAAAATMVisWjkkH4KCgyodNwlrWLUvfMlNVSV+xHwAwAAAAAAAABMp369ECUN7lPh+pCgQN1wdV9ZLJYarMq9CPgBAAAAAAAAAKbUuV0rJbS/uNx1I66+QvVCg2u4IveqUwG/zWbT3LlzlZSUpKioKAUEBCgqKkqJiYl67bXXVFBQ4O0SAQAAAAAAAABuNGxQb4WFhpRa1rVjG3Vs09JLFbmPxW63271dRE04evSoRo0apZUrV0qSYmJiFBERoczMTB06dEhBQUE6ffq0fHx8vFwpAAAAAAAAAMCd9qSm6f/N+UqS1CAsVOPHjlRggL+Xq6o+X28XUBNycnI0ZMgQbdiwQf369dP06dMVHx/vWL99+3bNmzePcB8AAAAAAAAATKh1bLR6de2onzZs06hr+5si3JfqyBX8f/7zn/X222+rT58++v777+XvX7P/eTM++lyns/Nq9DkBAAAAAAAAAOeyq6CwSP5+ft4upJR6oUF66PbrXdrW9Ffw79y5U++9954CAgL0ySefXDDcnzt3rmbPnq1ffvlFv//+u2JiYnTDDTfoscceU2hoqEs1nM7O06nsHJe2BQAAAAAAAAC4T/4Z89yL1fQB/6xZs1RcXKzbbrtNMTExFxz/8ssvKyYmRs8995yio6O1adMmPfXUU1q5cqVWrVolq9X5+xLXCw1ypXQAAAAAAAAAgMlVJz82fcC/dOlSSdKQIUOqNH7RokVq0qSJ43G/fv3UpEkT3XLLLfrhhx/Ut29fp2tw9eMVAAAAAAAAAABUxPQB/+HDhyVJcXFxVRp/brh/Vrdu3SRJ6enpLtXAHPwAAAAAAAAAgPIwB38lcnJK5r7Py3M9YF++fLkkqV27di5tzxz8AAAAAAAAAAB3M33A37x5cx0/flw//vijevfu7fT26enp+vvf/66rr75aCQkJLtXAHPwAAAAAAAAAgPJUJz+22O12uxtrqXWmTJmip556SvXr19d//vMfDR482LEuPT1dH330kZKTk9W6desy22ZnZ6t///7KzMzU+vXrFRkZWZOlAwAAAAAAAABQIdMH/NnZ2erXr582btwoSYqIiFDz5s117Ngx7d+/XxaLRadOnVJISEip7fLy8jRkyBBt2bJFq1evVvv27b1RPgAAAAAAAAAA5bJ6uwBPCw0N1erVq/XMM8+oc+fOOnnypLZt2yabzaakpCR99NFHZcL9wsJCjRw5Ur/88ou+/vprwn0AAAAAAAAAQK1j+iv4nWWz2TR69GgtXLhQX331lRITE71dEgAAAAAAAAAAZZj+JrvOeuCBB/TZZ5/p0UcfVXBwsH7++WfHulatWqlJkyZerA4AAAAAAAAAgBJcwX+e2NhYHTx4sNx1H3zwge64446aLQgAAAAAAAAAgHIQ8AMAAAAAAAAAYECmv8kuAAAAAAAAAABmRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIABEfADAAAAAAAAAGBABPwAAAAAAAAAABgQAT8AAAAAAAAAAAZEwA8AAAAAAAAAgAER8AMAAAAAAAAAYEAE/AAAAAAAAAAAGBABPwAAAAAAAAAABkTADwAAAAAAAACAARHwAwAAAAAAAABgQAT8AAAAAAAAAAAYEAE/AAAAAAAAAAAGRMAPAAAAAAAAAIAB/X/GnajZI88Q+gAAAABJRU5ErkJggg==",
                        "text/plain": [
                            "<Figure size 1959.52x451.5 with 1 Axes>"
                        ]
                    },
                    "execution_count": 6,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
                "import numpy as np\n",
                "\n",
                "\n",
                "def t_gate_ipe_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
                "    # qr is a quantum register with 2 qubits\n",
                "    # cr is a classical register with 3 bits\n",
                "\n",
                "    qc = QuantumCircuit(qr, cr)\n",
                "\n",
                "    ########## your code goes here #######\n",
                "\n",
                "    # Initialization\n",
                "    q0, q1 = qr\n",
                "    qc.h(q0)\n",
                "    qc.x(q1)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the least significant phase bit\n",
                "    t_angle = np.pi / 4\n",
                "    k = 2\n",
                "    cphase_angle = t_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis into the first classical bit\n",
                "    qc.h(q0)\n",
                "    c0, c1, c2 = cr\n",
                "    qc.measure(q0, c0)\n",
                "\n",
                "    # Reset and re-initialize the auxiliary qubit\n",
                "    qc.reset(q0)\n",
                "    qc.h(q0)\n",
                "\n",
                "    # Apply phase correction conditioned on the first classical bit\n",
                "    with qc.if_test((c0, 1)):\n",
                "        qc.p(-np.pi / 2, q0)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the next phase bit\n",
                "    k = 1\n",
                "    cphase_angle = t_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis into the second classical bit\n",
                "    qc.h(q0)\n",
                "    qc.measure(q0, c1)\n",
                "\n",
                "    # Reset and re-initialize the auxiliary qubit\n",
                "    qc.reset(q0)\n",
                "    qc.h(q0)\n",
                "\n",
                "    # Apply phase correction conditioned on the first and second classical bits\n",
                "    with qc.if_test((c0, 1)):\n",
                "        qc.p(-np.pi / 4, q0)\n",
                "    with qc.if_test((c1, 1)):\n",
                "        qc.p(-np.pi / 2, q0)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the next phase bit\n",
                "    k = 0\n",
                "    cphase_angle = t_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis into the third classical bit\n",
                "    qc.h(q0)\n",
                "    qc.measure(q0, c2)\n",
                "\n",
                "    return qc\n",
                "\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(3, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = t_gate_ipe_circuit(qr, cr)\n",
                "qc.draw(\"mpl\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "{'001': 1000}"
                        ]
                    },
                    "execution_count": 7,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit_aer import AerSimulator\n",
                "\n",
                "sim = AerSimulator()\n",
                "job = sim.run(qc, shots=1000)\n",
                "result = job.result()\n",
                "counts = result.get_counts()\n",
                "counts"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Grading your answer. Please wait...\n",
                        "\n",
                        "Congratulations 🎉! Your answer is correct.\n"
                    ]
                }
            ],
            "source": [
                "# Submit your circuit\n",
                "\n",
                "from qc_grader.challenges.spring_2023 import grade_ex3c\n",
                "\n",
                "grade_ex3c(qc)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### When the phase does not have an exact binary expansion\n",
                "\n",
                "Let's consider the case when the phase does not have an exact binary expansion, for example, $\\varphi = 1/3$.\n",
                "In this case, the single-qubit gate has the unitary\n",
                "\n",
                "$$ U =\n",
                "\\begin{bmatrix}\n",
                "1 & 0\\\\\\\\\n",
                "0 & e^{i2\\pi / 3}\\\\\\\\\n",
                "\\end{bmatrix}\n",
                "$$\n",
                "\n",
                "The angle $\\varphi = 1/3$ does not have an exact finite binary expansion. In contrast, it has the infinite binary expansion\n",
                "\n",
                "$$\n",
                "1/3 = 0.010101\\ldots\n",
                "$$\n",
                "\n",
                "In practice we work with a fixed number of bits of precision, so our goal is to obtain the closest value that can be represented with those bits. In the following example, we will use two bits of precision. In this case, the closest value is $0.01 = 1/4$. Because this value does not represent the exact phase, there is some probability that we will obtain a different, less precise result.\n",
                "\n",
                "In the following code cells, we construct and simulate an IPE circuit to measure the phase of this gate."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 1207.02x367.889 with 1 Axes>"
                        ]
                    },
                    "execution_count": 9,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
                "import numpy as np\n",
                "\n",
                "\n",
                "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
                "    # qr is a quantum register with 2 qubits\n",
                "    # cr is a classical register with 2 bits\n",
                "\n",
                "    qc = QuantumCircuit(qr, cr)\n",
                "\n",
                "    # Initialization\n",
                "    q0, q1 = qr\n",
                "    qc.h(q0)\n",
                "    qc.x(q1)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the least significant phase bit\n",
                "    u_angle = 2 * np.pi / 3\n",
                "    k = 1\n",
                "    cphase_angle = u_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis into the first classical bit\n",
                "    qc.h(q0)\n",
                "    c0, c1 = cr\n",
                "    qc.measure(q0, c0)\n",
                "\n",
                "    # Reset and re-initialize the auxiliary qubit\n",
                "    qc.reset(q0)\n",
                "    qc.h(q0)\n",
                "\n",
                "    # Apply phase correction conditioned on the first classical bit\n",
                "    with qc.if_test((c0, 1)):\n",
                "        qc.p(-np.pi / 2, q0)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the next phase bit\n",
                "    k = 0\n",
                "    cphase_angle = u_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis into the second classical bit\n",
                "    qc.h(q0)\n",
                "    qc.measure(q0, c1)\n",
                "\n",
                "    return qc\n",
                "\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(2, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = u_circuit(qr, cr)\n",
                "qc.draw(\"mpl\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "{'11': 36, '10': 54, '00': 187, '01': 723}\n",
                        "Success probability: 0.723\n"
                    ]
                }
            ],
            "source": [
                "from qiskit_aer import AerSimulator\n",
                "\n",
                "sim = AerSimulator()\n",
                "job = sim.run(qc, shots=1000)\n",
                "result = job.result()\n",
                "counts = result.get_counts()\n",
                "print(counts)\n",
                "success_probability = counts[\"01\"] / counts.shots()\n",
                "print(f\"Success probability: {success_probability}\")"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "As you can see, this time, we are not guaranteed to obtain the desired result. A natural question to ask is: How can we boost the success probability?\n",
                "\n",
                "One way that the algorithm fails is that the first measured bit is incorrect. In this case, the phase correction applied before measuring the second bit is also incorrect, causing the rest of the bits to be likely incorrect as well. A simple way to mitigate this problem is to repeat the measurement of the first few bits several times and take a majority vote to increase the likelihood that we measure the bit correctly. Implementing this procedure within a single circuit requires performing arithmetic on the measured outcomes. Due to a temporary limitation in Qiskit, it is currently not possible to perform arithmetic on measured bits and condition future circuit operations on the results. So, here we will measure each bit using separate circuits.\n",
                "\n",
                "The following code cells construct and simulate an IPE circuit for measuring just the first bit of the phase."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAADuCAYAAABcSIIkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAcg0lEQVR4nO3deXRU9f3/8eedrCQkshNIICE10LCGVcA1NFB2sIrKotbij5/tD8VCiRb1qKdWilKwVPmBX+CnoGIUKCJLPShQ+VJEtgBli1CCTJJBI2FJQoBk5vdHZL6mCZIZJpl8Jq/HORy493OX98DcvPjc+7n3Wi6Xy4WIiIihbP4uQERE5EYoyERExGgKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiATERGjKchERMRoCjIRETGagkxERIymIBMREaMpyERExGgKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiATERGjKchERMRoCjIRETGagkxERIymIBMREaMpyERExGgKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiATERGjKchERMRoCjIRETGagkxERIymIBMREaMF+7sAqczlgstl/q7CM6FBYFn+rkICiWnHga+PAZfLRXFxse82WAsiIiKw/PCDQEFWB10ug6cy/F2FZ2bdD2H6NokPmXYc+PoYKC4upmHDhr7bYC0oLCwkMjKy1verU4siImI0BZmIiBhNQSYiIkZTkImIiNEUZCIiYjQFmYiIGE1BJiIiRlOQiYiI0RRkIiJiNAWZiIgYTUEmIlIPWJZFq1atSExMJCEhgSZNmni0fkhICL///e8JCwuroQq9p6fjiYgEqB49evDAAw/Qu3dvunfvzk033VShPScnh927d7N9+3aWLl1Kbm5uldsJCQnhww8/ZNSoUdx6663cc889XLp0qTY+QrWoRyYiEkAsy2L8+PF88cUX7N69m+nTp3PXXXdVCjGA2NhYRo4cycyZMzl58iQffvgh/fr1q7DMD0MMIDU1lc6dO9fKZ6mugA+y/Px80tPTufnmmwkPD6dNmzZMmTKFoqIiJk6ciGVZvP766/4uUwKYywVnc+DwRti3GvZ9BFlboOg7f1cmgaZdu3Zs2rSJd955h1tuuaVC26lTp1i7di3vvvsu7733Hps2beLs2bPu9uDgYO69917++c9/Mm/ePCIjIyuFWHFxMSNGjGD37t21+bGuK6BPLWZmZjJkyBAcDgeRkZF07NiR3Nxc5s2bx/Hjxzlz5gwAKSkp/i20htgPbWHly6ncNvZVeg77XZXL/GWCRULKMEb9bm0tV1c/nPkasjZD4beV277eBY3bwE/TILJp7ddWH9SnY2D8+PEsXLiwwmtU9u7dy/z581mzZg3ffPNNpXUsyyIpKYlx48YxadIkWrVqBcDjjz/OsGHDOHnyJKmpqcD/hNimTZtq5wN5IGB7ZPn5+YwYMQKHw8G0adPIy8tjz549OBwOZs2axbp169i5cyeWZdG1a1d/lysB6Jss2Lui6hC7quAU7FwO5x21V5cEnt/85je888477hDLzs5m0KBB9OjRg0WLFlUZYlD+8s6srCxeeOEF2rZty5QpU9wv80xMTDQixCCAg+yJJ57AbrczefJkZs+eTVRUlLstPT2dbt26UVpaSkJCAtHR0X6sVALRhW/gX+vA5bz+sqUlkLkKLpv1MmCpIyZMmMAbb7zhnl6yZAldunRh48aNHm2ntLSUefPm0atXLwoKCtzzXS4XkydPrrMhBgEaZIcPHyYjI4NmzZoxc+bMKpfp2bMnAN26dasw/8SJE4wcOZKoqCgaN27MQw89xHff6WKGeObkLnCWVX/5y8WQ+6+aq0cCU2JiIgsWLHBP//GPf2TixIkUFhZ6tb2QkBBmzpxJ48aN3fMsy2Ly5MkEB9fdK1EBGWTLly/H6XQyfvz4a74qvEGDBkDFILtw4QKpqanY7XaWL1/Om2++ydatWxk+fDhOZzX+a11HlV4u5uKF/Cp/ie9dLobTRz1fL2df9Xpw4rlAPAYsy2LJkiXu04mLFi3i2Wef9Xp7VQ3sOHHiBFA+jP/pp5++8aJrSN2N2BtwtQt89fxuVex2O1AxyN58801ycnL4/PPPadu2LQBxcXH079+fNWvWMHr06JorugZ9sfJ5vlj5vL/LqDcKToHLg97YVRfPQXGBBn7UhEA8BiZMmMCdd94JwL///W+efPJJr7d1rdGJZ8+eZceOHQQHB/Pcc8+xbNkyTp486YvyfSogg+zqX3R8fHyV7aWlpWzbtg2oGGRr167ltttuc4cYQL9+/UhMTOTjjz/2Osh69eqFw1H9q/lBIQ24+6WvvNpXVTqnTiLpljFVtv3tTwN9so/2SUmUXbnok22Z7o5OY/nVwFe9Wnfo4JEcz9vj44rM5MvjwMRj4HpngR5//HH3nydNmkRRUZFX+7lWiF3tEMyePZunn36a0NBQJk2axDPPPHPNbSUlJWGzeXeiLyYmhl27dnm1bkAG2dV/0IsXq/5SZWRkkJ+fT1RUFO3atXPPP3ToEGPGVP6yd+rUiUOHDnldj8PhICcnp9rLB4dFeL2vqjSKSaJt5zSfbvM/5eblUnpJoxUAHM3tXq/7tf0EOY7qf1cCmS+Pg0A7Bnr37k3v3r0B2LVrF5999plX27leiAG89tprTJ06ldDQUB599FFefPFFLl++XOX28vLyvKrjRgVkkMXExFBQUMCePXsq3aWel5fH9OnTAejatSuWZbnbCgoKaNSoUaXtNWnShKNHvbjo8YN6PBEU0sDrfflL61at1SP73tnLp4Dy0V4//H5dT2HJWQi9SGxsbA1VZhbTjgNfHwNOp/OawTB27Fj3n+fPn+/V9qsTYgCnT59m5cqVjB07lhYtWpCWlsb69eur3GarVq1uqEfmrYAMsrS0NA4fPsysWbMYOHAg7du3B2Dnzp08+OCD5OeXX+CtrRuhPe0uXyqFpzJqqJgakvXVV4QF5LfJO3s+hDMnqx9iAB1vbcSJZ4/VUEXmMe048PUxUFRUdM3Bald7YwBr1qzxeNvVDbGrPvroI3d49urV65pB9tVXX1W4Ibu2BOSoxfT0dJo2bcqpU6fo1KkTXbp0ISkpiT59+pCYmMiAAQOAykPvGzduXOGRLVedOXPG4ydFS/3Wtqdny1tBEJdSI6VIgLHZbHTv3h0ov13I09uDPA0xqPif8au3LtUlARlkcXFxbN26lWHDhhEeHk52djZNmjRh4cKFrFu3jqysLKBykCUnJ1d5LezQoUMkJyfXSu0SGJolQru+1V++02CIaHz95UTi4uLcvZ59+/Z5tK43IQZw/PhxLly4AFAnfxYG7Mmg5ORk1q6t/Oy0wsJCsrOzsdlslZ7gPHz4cGbMmIHdbicuLg6AHTt2cPz4cV591btRaFJ/Jd4KwWFw/L+vfXN0cDh0/Dm0SKrd2sRcQUFBHD9+nPDwcPdtRNVhs9m8CrGrTpw4QePGjT0agV1bLJfL5fJ3EbVpx44d9O3blw4dOnDkyJEKbefPn6dLly40a9aMF198kZKSEtLT02nevDnbt2/3+iKmp0y7NgAw6350jewarlyE3IPgOFT+6KqrOg6Glh0gKMR/tdVlph0Hvj4GfuwambeeffZZ/vCHP9TYsxMLCwv9co2s3v3oOXDgAFD5tCJAdHQ0mzZtYsqUKTzwwAMEBwczfPhw5s6dW2shJoEnpAHE9yr/9emfARdgQeu69UonqQdeeuklrly5ws6dO+v0sxM9pSD7Dz/5yU+qPCUpIhIIZs2a5e8SfK7edTOuF2QiImKWetcjC6TutIiI1MMemYiIBBYFmYiIGE1BJiIiRlOQiYiI0RRkIiJiNAWZiIgYTUEmIiJGU5CJiIjRFGQiImI0BZmIiBhNQSYiIkard+8jM4HLBZev8SLGuio0CCzL31XUfT98jUvaNH9XU7eZdhz4+hhwuVwUFxf7bHuvLnyf80XFREdGMP1/P1Bp2hciIiKw/PCDoN49NNgElqWXVIrU9+PAsiyfvqQyNCyc0CtlhIaFExkZWWnaZDq1KCIiRlOQidRRCQkJdOjQgZSUFDp27Mgbb7xxzWXHjBnD9u3bKSkpYfTo0bRv355u3boxcOBAjh07Vu19rlixgl//+tcADBo0iK5du5KSksLtt9/O3r173cvdfvvtnDhxwvsPJ+JDCjKROiwjI4PMzEw2bNjAjBkz2L9/f6VlvvzyS86cOUO/fv0AmDRpEkePHmXfvn2MGjWKRx99tNr7+9vf/sbo0aMB+OCDD9i/fz+ZmZlMnTqVX/7yl+7lpk2bxvPPP39Dn03EVxRkIgaIj4+nQ4cOZGVlVWpbuHAh48aNAyA8PJyhQ4e6L7j37duX7OxsAM6ePUtcXBxNmzYlJSWF5ORkwsLC3EF35coVtm3bxoABAwBo1KiRex/nzp2rcBF/2LBhbNiwgXPnztXExxXxiIJMxAAHDhzgyJEjdOvWrVLbli1buOWWW6pc7y9/+QujRo0CyoNp3LhxPPnkk2RmZvLaa6/Rt29fFi1aBMDmzZvp378/ISEh7vUfeugh2rRpw3PPPceyZcvc80NCQujSpQtbt2715ccU8Uo9HhMkUvfdf//9NGjQgIiICJYsWUJSUlKlZex2Oy1btqw0/+WXX+bYsWN89tln7nmZmZk88cQTAOzevZvu3bu721avXs3dd99dYRtLly4F4O233+app55i/fr17raYmBjsdvuNfUARH1CQidRhGRkZpKSk/OgyERERlJSUVJg3e/ZsVq1axaeffkpERIR7fmZmpju8du/ezciRI4Hye5Y++eQTXnnllSr38fDDD/PYY4/x3Xff0bRpUwBKSkpo0KCBtx9NxGd0alHEcF27duXo0aPu6Tlz5rB8+XI2btxY4TpXTk4OlmURGxsLwP79++nSpQtQPmAkOTmZhg0bAuXX03Jzc93rrl69mqZNm9KkSRP3vMOHD1d5qlOktqlHJmK4e++9l08++YS0tDTsdjvTpk0jMTGR1NRUAMLCwtixYwd79+6tcCqxUaNGzJ8/n0WLFlUYrQjlgzvGjBnDxYsXsdlsNG/enLVr17oHfGRnZ1NWVqYgkzpBQSZSR10dbXg9jzzyCP379+eFF14gLi6Oaz11bvjw4QwfPtw9vXPnTvefP/74YzZv3uyejo+P58svv7zmPhcsWEB6erpfHkck8p90alHEcA0bNmTu3Lk3dIPywYMHadGiRbWXb926Nb/61a+83p+IL6lHJhIAfvazn9Xq/q6OfBSpC9QjExERoynIRETEaAoyERExmoJMRESMpiATERGjadRiHeRyuSh2GvSOdyDCFqR7ikTELxRkdVCxs4zGmzb6uwyPFAwYSGSQvk4iUvt0alFERIymIBMREaMpyERExGgKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiATERGjKchERMRoCjIRETGagkxERIxWL4IsPz+f9PR0br75ZsLDw2nTpg1TpkyhqKiIiRMnYlkWr7/+ur/LlADmcsG5PMB1dYY/qxEJLAH/3o3MzEyGDBmCw+EgMjKSjh07kpuby7x58zh+/DhnzpwBICUlxb+F1pCyJW/hfP8DgqY+iW3woAptLpeLsulP4zp8mODX52G1S/BPkQGs9DLkHgD7Pig+U7Ft57sQlwItk8FWL/5LKVIzAvrwyc/PZ8SIETgcDqZNm0ZeXh579uzB4XAwa9Ys1q1bx86dO7Esi65du/q73Bphe3A8JMRTtvC/cH2bX6HNuWo1rv0HsD04QSFWAy4Vwq73IWtz5RCD8h7awQ2w/yMou1L79YkEioAOsieeeAK73c7kyZOZPXs2UVFR7rb09HS6detGaWkpCQkJREdH+7HSmmOFhBA8fRqUlFA25zX3fNcpO863lmL9tAO2Mff4r8AAVXoZ9q6Ewm+uv2z+cfjXOnA5a74ukUAUsEF2+PBhMjIyaNasGTNnzqxymZ49ewLQrVs397yrwdenTx/CwsKwLKtW6q1JVtLN2B64D9fuPTjXbcBVVkbZK7PB5SJo+jSsoCB/lxhwTu2Bwm+rv/y3xyD/3zVXj0ggC9ggW758OU6nk/Hjx9OwYcMql2nQoAFQMciOHTvGypUriYmJoXfv3rVSa22wjR8LiYmU/dcinG8swHU0C9svH8JqE+fv0gKOywk5+zxfz57p81JE6oWADbJNmzYBkJqaes1l7HY7UDHI7rjjDvLy8lizZg1paWk1W2QtsoKDCZ4+FS5fwbl2HVbnTth+MdrfZQWkglNQcsHz9b7LLr+uJiKeCdhRiydPngQgPj6+yvbS0lK2bdsGVAwyWw0MH+vVqxcOh6Pay7tCQ2HhGz6vg8hICAmB0lKs3r2wfPhZ2ye1x7p82WfbM9ltHcfw6KC5Xq2bducwTpz2ojsnch13P/IkkQ2jyXPkERcXV2na32JiYti1a5dX6wZskBUVFQFw8eLFKtszMjLIz88nKiqKdu3a1WgtDoeDnJyc6q8QHkaIj2twuVyU/XkulF6Btm1wvvc+tjvvwGrdyifbz83LhZJLPtmW6QpaFXi97jffnPbsuyJSTc6yMvfvOTk5laZNFrBBFhMTQ0FBAXv27KFfv34V2vLy8pg+fToAXbt2rfEBHTExMR4t7woNxYNxAtXiXL0G17792B55GFu/vpT+n8cp+/NcgmbP8snnb92qtXpk33MGFXu3nstJcAMnsbGxPq5IBGzfD+qyBQURGxtbadrfPP05+UMBG2RpaWkcPnyYWbNmMXDgQNq3bw/Azp07efDBB8nPL7+nqjZuhPa0u1xUVkrjTRt9tn9XTg7OJW9hdWiP7b57sYKCsE0Yj/P/vY1z9RqC7h51w/vI+iqLyKCA/Tp5xOWEbYug5Lxn6zVPtHEwa0/NFCX13stvvMv5wiJaxbTCbrdXmjZZwA72SE9Pp2nTppw6dYpOnTrRpUsXkpKS6NOnD4mJiQwYMACoeH0sELmcTspenQNOJ0HTp7qH2tvuuxerfRLOJW/hys3zc5WBxbJBnBdfq7gUn5ciUi8EbJDFxcWxdetWhg0bRnh4ONnZ2TRp0oSFCxeybt06srKygMAPMueKVbgOHcb28ASstm3d862gIIJ+NxWcZZT9eS4ulx7+50tx3SGqZfWXb5EEzRJrrh6RQBbQ54KSk5NZu3ZtpfmFhYVkZ2djs9no3LmzHyqrHa6vv8b59jKs5J9iu+cXldqthHifn2KUcsGhkPIL2LcKzp/+8WWbJ0GnoRAA996L+EVAB9m1HDx4EJfLRfv27YmIiKjUvmLFCgAOHTpUYTohIYFevXrVXqE3yGrblpB1H/3oMkFj7ydo7P21VFH9EhYJPR+AvINwai8UfVexvVHc9w8Nbl9+OlJEvFMvg+zAgQPAtU8rjhkzpsrphx9+mLfeeqtGa5PAEhRSHlax3cofWXWpsDy0wqMhsom/qxMJDAqyKuh6kfiaZUFUi/JfIuJb9fKExvWCTEREzFEve2RXn8MoIiLmq5c9MhERCRwKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiATERGjKchERMRoCjIRETGagkxERIxWL5+1WNdF2IIoGDDQ32V4JMIW5O8SRKSeUpDVQZZlERmkfxoRkerQqUURETGagkxERIymIBMREaMpyERExGgKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiATERGjKchERMRoCjIRETGagkxERIymIBMREaMpyERExGgKMhERMZqCTEREjKYgExERoynIRETEaAoyERExmoJMRESMpiCrIz7//HNGjRpFfHw8lmXx0ksv+bskEZEftX79elJSUggLCyMhIYE5c+b4pQ4FWR1RWFhIx44deeWVV4iJifF3OSIiP2rXrl2MGjWKIUOGkJmZyQsvvMCMGTNYsGBBrdcSXOt7lCoNHTqUoUOHAvDUU0/5uRoRkR83Z84cevfuzcyZMwFITk7m4MGD/OlPf+Kxxx6r1VoUZCIiAeTs+UK++e5spfmlZWXu37NO2CtN/1BCXAyhIT8eD9u2bWPixIkV5g0ePJjZs2djt9uJi4u7gU/hGQWZiEgACQkJ5sP1W7hQWFxle/HFEpZ8sP6a0z/9SVuSEmKvu5+8vLxKl0GuTufl5dVqkOkamYhIAIlsEM69Q+70et17htyBZVk+rqpmKchERAJMh8Q29O3e0eP17h58O1GREdVatlWrVjgcjgrzTp8+7W6rTQoyEZEANPSuW2jW+KZqL9+zc3s6t29X7eVvvfVWPvnkkwrz/v73vxMfH1+rpxVBQVZnFBYWkpmZSWZmJpcvX8bhcJCZmcmxY8f8XZqIGCg0NIT7hqdiq8ZpwkbRDRmR1t+j7f/2t7/lyy+/5JlnnuHIkSO8/fbb/PWvf+Xpp5/2tmSvWS6Xy1Xre5VKtmzZQmpqaqX5d955J1u2bKn9gkQkIGzcuovP/rnnmu0W8L/GjSCxjeenA9etW8eMGTM4cuQIMTExTJkyhalTp95Atd5RkBnmxKk84mKaE3KdobEiIgBlZU7+7zsfYXd8W2X7HX26MjS1by1X5Vs6tWiQC4XFLP5gPa+8+T7nzhf6uxwRMUBQkI37hqcSHBxUqS2meRMG3d7bD1X5loLMIP/YsY/S0jIaR0cRHRXp73JExBAtmjZi6F23VJgXFGTj/msEnGkUZD9QVlbGsmXLGDRoEM2bNycsLIy2bdsyePBgFi1aRNn3d8L7w4XCYr7IPARA2m09jbvPQ0T8q2+PThVudB50ey9atWjqx4p8R9fIvnf+/HlGjx7N5s2bAWjdujWxsbHk5uaSm5uLy+WioKCARo0a+aW+tZ9t5793HaBt65b8esJIBZmIeOzchSJeW7KCls0aM2nscGy2wOjLKMi+N2bMGFasWEFcXBxLly6tMILw9OnTLF68mClTphAZ6fkpvb++vYoLhRe9rs3pdFJYXL5+RHgYwcEa6CEi3iktLcUWZMNm1a0Qi2rYgMcf/oVX6+onIrB7925WrFhBcHAwGzZsoHPnzhXaW7ZsyYwZM7ze/oXCi5wvLLrRMgEoLrkEXPLJtkREAoGCDFi9ejUAw4YNqxRivhDVsIHX66o3JiL1wY38nNRPReDQofJBFP369auR7XvbXQZdGxMRuR4FGeUDPQBuuqn6zyXzhLfXyH7YG8s/c5aZ89/zdWkiInWCrpHdoOjoaADOnTtXI9v3xTUyXRsTEamaggzo1KkTq1atYvv27TWyfW/O/eramIjUJzdyjUzD74G9e/fSo0cPQkJCyMzMpGNHz9/j42u6NiYiUj1160YCP+nevTv33XcfV65cYciQIfzjH/+o0H769GlmzpxJUZFvhtBfj57iISJSfeqRfe/8+fOMGjXK/cqU2NhYWrduTV5eHjk5ObX6ZA/1xkREqk89su9FR0fz6aefsnjxYu666y6Ki4vZt28fNpuNn//85yxevJioqKhaqaVhZAPCw0LVGxMRqQb1yOqokkuXCQsNUZCJiFyHgkxERIymU4siImI0BZmIiBhNQSYiIkZTkImIiNEUZCIiYjQFmYiIGE1BJiIiRlOQiYiI0RRkIiJiNAWZiIgYTUEmIiJGU5CJiIjRFGQiImI0BZmIiBhNQSYiIkZTkImIiNEUZCIiYjQFmYiIGE1BJiIiRlOQiYiI0RRkIiJiNAWZiIgYTUEmIiJGU5CJiIjRFGQiImI0BZmIiBhNQSYiIkZTkImIiNEUZCIiYjQFmYiIGE1BJiIiRlOQiYiI0RRkIiJiNAWZiIgYTUEmIiJGU5CJiIjRFGQiImI0BZmIiBhNQSYiIkb7/zZv8aor1bFsAAAAAElFTkSuQmCC",
                        "text/plain": [
                            "<Figure size 538.128x284.278 with 1 Axes>"
                        ]
                    },
                    "execution_count": 11,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
                "import numpy as np\n",
                "\n",
                "\n",
                "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
                "    # qr is a quantum register with 2 qubits\n",
                "    # cr is a classical register with 1 bits\n",
                "\n",
                "    qc = QuantumCircuit(qr, cr)\n",
                "\n",
                "    # Initialization\n",
                "    q0, q1 = qr\n",
                "    qc.h(q0)\n",
                "    qc.x(q1)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the least significant phase bit\n",
                "    u_angle = 2 * np.pi / 3\n",
                "    k = 1\n",
                "    cphase_angle = u_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis\n",
                "    qc.h(q0)\n",
                "    (c0,) = cr\n",
                "    qc.measure(q0, c0)\n",
                "\n",
                "    return qc\n",
                "\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(1, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = u_circuit(qr, cr)\n",
                "qc.draw(\"mpl\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "{'1': 8, '0': 7}\n"
                    ]
                }
            ],
            "source": [
                "job = sim.run(qc, shots=15)\n",
                "result = job.result()\n",
                "counts = result.get_counts()\n",
                "print(counts)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Hopefully, the correct bit was measured more often than not.\n",
                "\n",
                "### Exercise 4\n",
                "\n",
                "Examine the counts dictionary from the output of the last code cell. What is the correct value for the first bit? Was it measured more often than not? If not, rerun the last code cell until it is. Then, write some code in the code cell below that sets the variable `step1_bit` equal to the value of the bit that was measured the majority of the time."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "1\n"
                    ]
                }
            ],
            "source": [
                "step1_bit: int\n",
                "\n",
                "########## your code goes here #######\n",
                "step1_bit = 1 if counts[\"1\"] > counts[\"0\"] else 0\n",
                "\n",
                "print(step1_bit)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Grading your answer. Please wait...\n",
                        "\n",
                        "Congratulations 🎉! Your answer is correct.\n"
                    ]
                }
            ],
            "source": [
                "# Submit your result\n",
                "\n",
                "from qc_grader.challenges.spring_2023 import grade_ex3d\n",
                "\n",
                "grade_ex3d(step1_bit)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### Exercise 5\n",
                "\n",
                "Now construct the circuit to measure the second bit of the phase. Replace the first stage of the circuit with one which simply sets the auxiliary bit to the value we measured above, so that we always measure the correct value for the first bit of the phase."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 15,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvQAAAEvCAYAAAAqzVVnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzxElEQVR4nO3deVyU5f7/8fc9w77lViIqKrkvoOGSipqUVq5oobaoZfumfTOtU6ejZynbNZdz0sqjdcrsqGmpHavjkpn7ggsqbqiAZOQKiMjM/P7g55wIUMCB4R5ez8fDh869XPfnBrnnzTXXfd2Gw+FwCAAAAIApWdxdAAAAAICyI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDEvdxeAwhwOh7LtNneXUSoBFqsMw3BZew6HQ9nZ2S5rryIEBAS47GtQ1c9fkhwOKddEPwY+VsmFp3/NHA7JfsndVZiPxbtyfR9RdZntGii5/jrIe2HJEegroWy7TdVXfufuMkrldGwvBVpd998pOztbQUFBLmuvImRmZiowMNAlbVX185fy38hemO+y5srdG0Ml30p0RbVfklZNdXcV5tNztGT1cXcVgPmugZLrr4O8F5YcQ24AAAAAEyPQAwAAACZGoAcAAABMjEAPAAAAmBiBHgAAADAxAj0AAABgYgR6AAAAwMQI9AAAAICJEegBAAAAEyPQAwAAACZGoAdKyGLhxwUAgKqssmYBL3cXAJQnwzDUtGlTRUdH68Ybb5Svr6/y8vJ0+vRpbd++Xdu3b9f58+ev2k6vXr307rvvqk+fPjp+/HgFVA4AAFzBMAw1btxY0dHRaty4sfz8/GSz2XTmzBlt375d27Zt07lz567aTkxMjGbOnKn+/fvr8OHDFVB5yRHo4ZFuvvlmPfnkk4qLi1NwcPAVt92+fbtmzZqlf/3rX8rMzCy0vlevXlqyZIn8/f21atUqxcTEKD09vbxKBwAALhAdHa0nn3xSd911l6677rorbrtz50598MEH+vjjj4sM9zExMfrmm28UFBSk1atXq2vXrpWqg69yfm7gQhkZGRo/frzzN7L69etrzJgxysrK0kMPPSTDMDR9+nR3lwkXiYmJ0datW7V+/XoNHz78qmFektq1a6d//OMfSk1N1V//+lf5+Pg41/02zEtSQkKCMjIyyq3+a7Vq1SqtWrWqzPs/9thjstlsCg0NdWFVAJDPYZcuXZDyciWHw93VwFN16NBBGzZs0JYtWzRq1KirhnlJioyM1LRp05SWlqY333zT+b4vFQzzkrRr1y6dPHmy3OovC4/uod+xY4fuvPNOpaenKzAwUC1btlRaWpqmTp2qQ4cO6dSpU5Kktm3burfQcmSbPUf2z7+Q9blnZbmjd4F1DodDtnEvyrF3r7ymT5XRqKF7inQBf39/vfbaaxo9enSB8W2nTp3S6tWrtXXrVu3evVuZmZmyWq0KDw9XdHS0Onfu7Pz+h4SE6I9//KMGDRqkBx54QNWrVy8Q5hctWqShQ4cqLy/PHad4TQzD0JgxY/TYY4+pYcOG+uWXX/TFF1/oT3/6k7Kzs53bffXVV/r73/+u/v3764MPPnBjxa6RkrhaC1/rqZh73lJ03+eL3Oa9+w01bNtXA59fWsHVuZfdbteXP76nZRtmKv10sqoFXq/uUUM08va/yN8n0N3lwYM4HNLZNCllh/Tz/vxQL0m+QVLdyPw/vkFuLdGjVaXroK+vryZOnKhx48bJarU6l585c0Zr1qzRli1btGvXLp0/f15Wq1X16tVTdHS0OnXqpPbt20uSAgMDNW7cOA0cOFCjRo2SYRgFwvzy5cs1ePBgXbx40S3nWByPDfQZGRnq37+/0tPTNXbsWE2YMMHZW/vmm2/qhRdekJeXlwzDUGRkpJurLT+W4ffJvmGjbDM/kBF9k4zraznX2RctlmPnLllGPWDqMH/DDTdoxYoVBX4x2759u6ZMmaIvvvhCOTk5Re730UcfSZKioqL05JNP6oEHHpCPj49atWqlDRs2yGazOXvrzRzmJWny5MkaM2aMFi1apHfeeUctWrTQ6NGj1a5dO912221y/P+ushMnTmjLli2Ki4vziECP4v3j6//T4h+nqmvrQbq7x1gd+3mvFv84VYdSt+uNR7+vtDd+wVxsl6Tdy6RfDhZedzFTOvyTdGSD1LyXVLdNxdcHz1GjRg0tX75cnTp1ci7btWuX3nvvPc2bN69A59Vv/fOf/5QktWrVSk888YQeeugh+fn5qWnTpvrhhx+Um5srPz8/SZU3zEsePORm9OjRSklJ0dNPP6233367wNCL8ePHKyoqSnl5eWrYsKFCQkLcWGn5Mry95TVurJSTI9u7U5zLHcdTZJ/zsYzmzWSJv8t9BV6j66+/XmvWrHGG+QsXLui5555T+/bt9fHHHxcb5n8rISFBjz32mG666SZt2bJFkmS1Wj0mzLds2VLPPPOMFi5cqLvuuksffvihxo4dq+eee06xsbEaNmxYge0XL16s2NhYBQbSS+upktP3aMm6aYppPVgTRy5Sn06P6PEB7+rx/u9qx6FVWp3wubtLhAew26SEL4sO87/lsEt7V0ipOyumLnieatWqaeXKlc4wn5ubq5deeknt2rXTRx99VGyY/609e/bo6aefVlRUlH766SdJ+TPamCHMSx4a6Pfu3av58+erVq1amjRpUpHbREdHS8rvnf2tI0eOaMCAAQoODlb16tU1YsQI/frrr+Vec3kymjSWZdgQObZuk33ZN3LYbLK9+bbkcMg6bqyM33wsZSZeXl5aunSpmjdvLkk6duyYoqOjNXnyZNnt9lK3t2fPHr3yyisFgrvD4dCsWbNMG+Yl6Z577pHFYtGUKVMKLP/ggw+UlZWl+++/v8DyJUuWyM/PT3fccUcFVomKtGrHPDkcDg3u9myB5X06PSI/7wB9v+1f7ikMHuXYFunUsZJvv+876cLZ8qsHnslisWjx4sXOPHfixAl17NhRkyZNks1mK3V7SUlJ+sMf/qDc3NwCyz/66KNKG+YlDw308+bNk91u13333ecc8/R7l8dF/zbQnz9/Xj179lRKSormzZunWbNmae3aterXr1+ZAmJlYrnvHikiQrYPPpR9xvty7E+S5YERMurXc3dpZfbiiy+qY8eOkqTjx4+re/fu2rt3b5nb69WrlxYtWiQvr/+NRDMMQ7NmzTL1pzgdOnSQzWbTpk2bCiy/ePGiduzYoQ4dOhRYnpiYqAMHDiguLq4CqyxfebnZunA+o8g/VdH+45tlMSxqFt6xwHIfbz9FhLVV0vHNbqoMnsJhzx8zX6p9HPTSlydPvQ6OGTNGPXr0kCSlp6ere/fuSkhIKHN7MTExWrZsWYEJMiRpxowZqlGjxjXVWp48cgz9ypUrJUk9e/YsdpuUlBRJBQP9rFmzlJqaqh9++EHh4eGSpHr16qlLly766quvTB1wDC8veY17TnnPPCv70mUyWreSZXCcu8sqszZt2uiVV16RJOXl5Wnw4ME6evRomdv7/Ww2ixYtUrVq1RQbG6vw8HC9/fbbevTRR11Se0ULCwtTRkZGod4GSUpNTVXXrl3l7e2tS5cuOZcvWbJEo0aNktVqLVMPR2WzYeEEbVg4wd1lVBq/nktTSGAt+Xj5FlpX67q6Sjz6ky7l5crby6eIvYGr+zVZyrn6Iz4KSd0pRXSVuIXD9TzxOtikSRO9+uqrkvJv9I+Pj9fBg1cZ43UFv5/NZvny5bLb7erXr59CQ0M1bdo03XfffS6p3dU8MtBfDnYNGjQocn1eXp7WrVsnqWCgX7p0qWJiYpxhXpI6d+6siIgIff3112UO9O3bty/VvOUOHx9p5owyHeuKAgMlb28pL09Gh/YyXHjFbNqkqYwiAmNZXe0TkYkTJzp/e37jjTecY9/LoqgwP3ToUNWtW1e7du1ScHCwHnnkEb3++utXfJBEkyZNXHYjoSs/EQoICCj2Y8LL9xgEBATo7Nn/fda9ZMkSPf/88+revXuJp8F05flLktXbX4P+dsAlbbXu+aiadIovct2Xr/dyyTGaNmki26ULLmnLFXy8/DXr6aK/fhdzs+VdRJjP3y9/vOjFS9lVMtA3adpEuXmV5/toVndGP66h3f5Y6v0uXZBaN2+rc9nm7jV2BVdeAyVzXgev9l74yiuvON+7p06dqh9//LHMxyoqzA8ePFjVq1fXnj17VKNGDd17772aNGmSdu/eXWw71/JeGBoaWuY845GBPisrS1L+DZJFmT9/vjIyMhQcHKxGjRo5lycmJio+vvB/9latWikxMbHM9aSnpys1NbXkO/j5yrvMRyuaw+GQ7Z3JUt4lKby+7J99LkuP7jLC6rik/bQTaVJOxYwtq1u3rgYOHJh/3LQ0/eUvfylzW8WF+by8PB09elSvvfaa8z6Mxx9/XOPHjy+2rRMnTpS5jvKUnZ2tG264och1l2/2+f0NQ5d75a2luL/C1efv5RvgsraqhTZReOvbXNZeUdJOpCnv4tVvvKooft7Ff/18fQJ0IbPoOZRz8/J/yfO9wv6e7ERamnIuVZ7vo1llN7/6hATF+fWX0zp5phTvmR7KlddAyfOug7Vq1dKQIUMkSb/++qtefvnlMrdVXJi/ePGi0tPTNXHiRE2dOlWS9MQTT+ipp54qti13ZQGPDPShoaE6ffq0tm3bps6dOxdYd+LECY0bN05S/kMEDMNwrjt9+rSqVatWqL0aNWpo//7911RPaTh8fPRLmY9WNPvir+RI2CnLgyNl6Xyz8p56RrZ3Jsv69hsFvgZlFVYnzOU99MX9UDzyyCPOoDlr1qwih5KUxJXC/GUffvihJk6cKF9fX40aNUqvvPJKsb3dderUcWkPvasuCmlpaWrZsqV8fHwKfa3q1q2rX375pcBwG0mKi4vTmTNntHr16hIfx5XnL+X3TplJWJ2wStdDX5yaIWE69nOicvMuFhp2k3E2VdcF1qqSvfOSVCcsjB56F7B4l20iAbvDrqBqvvIOrOviiszHbNdAyfXXwSu9Fz744IPy9c2/fs2ePbtEM9kU5Uph/rK5c+fqtddeU1BQkIYPH64XXnihyCfLS9f2XngtD3X0yEB/2223ae/evXrjjTfUq1cvNW3aVJK0efNmDR8+3Pmkz4p6oFRpPz7JsuWp+srvXHZ8R2qq7LPnyGjWVJYhd8uwWmW5/z7Z/zlX9sVfyTpo4DUfI+lAkgKtrvvvlJWVVewNzbfffrvz32WdK70kYV7Kf57BokWLdM8996hmzZqKjo52Tmf1ewcOHHDZVI9XOv/S2rx5s26//XZ17NixwMeRvr6+atu2rX744YdC+wwcOFDLly8v1ew+rjx/SbqYJ70w32XNlbukAwfkW4muqLZcadXUotc1q99BW5O+1f5jm9Qmoptzee6lHB1O26E2Ed0rqMrK50DSAVmr5u8yLnUxU/px1v8eIlVS10dYdOhIUvkUZTJmuwZKrr8OljQLzJo1q0ztlyTMS9K5c+f0+eef6+GHH1ZwcLA6d+6s774rOqe5+r2wpDzytpPx48erZs2aOn78uFq1aqU2bdqoSZMm6tixoyIiIhQbGyup8JSV1atX15kzZwq1d+rUqUp9Z/OVOOx22d56V7LbZR33nHOKSsuQu2U0bSL77DlypFXOoSJF8fLycn7fDhw4oLS0tFK3UdIwf9maNWuc/7483amZzJ8/X3a7Xc8++2yB5Y888ogCAwP16aefFljevHlzNWvWTEuWLKnAKlGRbokaKsMwtGjtlALLl2/8QDmXshXbrnLe9AXz8A2Srm9c+v3qtXV5KfBQN910k6T8T6HLciNsScP8ZZU9C3hkoK9Xr57Wrl2rvn37ys/PT8nJyapRo4ZmzpypZcuWKSkp/7f/3wf6Fi1aFDlWPjExUS1atKiQ2l3NvmCRHIl7ZRl5v4zf3OxrWK2yPv+cZLfJ9s5k55NCK7sWLVo4g/jWrVtLvX9pw/zvj1MZf4ivZvfu3ZoxY4buuusuLVy4UA899JDefvttvfvuu1q9erU+++yzAtsPHDhQFy9e1DfffOOmilHeGtVpowFdntKPuxdp4tzBWr7xQ73/9Vi9//Vziozoodh297q7RHiARp0lSyl6a6vVk2o1uvp2QKNGjVS9enVJZcsCpQ3zvz9O+/btS33M8laJPiB2rRYtWmjp0qWFlmdmZio5OVkWi0WtW7cusK5fv3566aWXlJKSonr18udn37hxow4dOqS33nqrQup2JcexY7LP/URGi+ay3DW40HqjYQOXD70pb2FhYc5/X/7FrKTKEuYlFbh/ok4d19xEXNGeffZZJScn69FHH1Xfvn2VkZGhadOm6U9/+lOhX+YGDhyoVatW6fz5Msw5B9N4YsAU1a7eUMs3ztKmvcsUElhLcV2f0cjb/+LSeyFQdQVfL0UNlBKWSParjN4Lrp2/rcF/PZTAtWSBsoT53x+nMmYBw2GWrlkX2bhxo26++WY1a9ZM+/btK7Du3LlzatOmjWrVqqU///nPysnJ0fjx43X99ddr/fr1FfYm5+ox9BXhdGyvChlD37hxYw0bNkx+fn5auXKl85kDVxMSEqLk5GTnb/QlDfNS/kwvr776qnJycnTgwIFCQ1Quy8zMdPsY+stTTF7pGQxXUrt2baWlpempp57S+++/X6p9XXn+kvnGj74xVKYZQ4/i9RwtxtC72LmfpSPrpV8OSfpd4vD2k8La5PfmV9H7sItltmug5PrrYHHvheHh4Ro+fLj8/f31448/6j//+U+J2vP399eRI0dUu3ZtSSUP85dNmjRJFy9eVHJysubMmVPkNq5+LyypSvT2UzF27dolqfBwGyk/9K1cuVJjxozRsGHD5OXlpX79+mny5Mn0WFUSBw8e1N/+9rdS73fu3Dndc889Wrx4sZYvX17iMC/lT+H44osvlvqYZjRgwABJYvw8AJcJqS1FxUk556Sfk6QDq/+3LuYxyerqeZrh8Y4dO+Z8oFRpXLhwQUOHDtWyZcu0Zs2aUoV5SfrDH/5Q6mNWFAL979x4441FDtWB+a1YsUIxMTFKSEgo1ewtVcns2bM1d+7cMk8FCgDF8QuRGrSXDqxRfk+9QZhHxVuzZo26deumxMTEUoX5yo5AjyqlLDfPVCU2m835UCkAADzR9u3b3V2Cy1W5QF/SMdeAGZV17DwAADAvBoYDAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYmJe7C0BhARarTsf2cncZpRJgsbq2vYAAZWZmuqy9t2Z+rnNZ2QoJDNC4x4YVeu0KAQEBLmnncluuPP+K4MrzlyQfq/TGUJc2Wa58XPsjAKCKM9s1UHL9dbCqZ4HSINBXQoZhKNBatb81hmEoMDDQZe35+PrJ55JNPr5+CgwMLPS6snH1+ZuRYUi+VfvHAEAVxjWQLFAaDLkBAAAATIxADwAAKp2GDRuqWbNmatu2rVq2bKkZM2YUu218fLzWr19fonYXLFigJ554QpLUu3dvRUZGqm3bturWrZu2b9/u3K5bt246cuTItZ0EUEGq+Ic5AACgspo/f77atm2ro0ePKjIyUt26dVNkZGSBbTZt2qRTp06pc+fOJWrzyy+/1IgRIyRJX3zxhapVq+Zc/sADDyghIUGSNHbsWE2YMEEff/yx604IKCf00AMAgEqtQYMGatasmZKSkgqtmzlzpu69915J0pkzZ1SvXj3VrFlTbdu2VYsWLeTr66uHH35YknTp0iWtW7dOsbGxkuQM85J09uxZGYbhfN23b1998803Onv2bDmeGeAaBHoAAFCp7dq1S/v27VNUVFShdatXr1anTp0k5Qf0e++9V88++6x27NihKVOm6Oabb9aHH34oSVq1apW6dOkib29v5/4jRoxQ/fr19corr+iTTz5xLvf29labNm20du3acj474Nox5AYAAFRKQ4cOlb+/vwICAjR79mw1adKk0DYpKSmqXbu28/WOHTs0evRoSdLWrVvVrl0757rFixdr0KBBBfa/PKRm7ty5euGFF7R8+XLnutDQUKWkpLj0nIDyQKAHAACV0uUx9FcSEBCgnJwc5+sdO3Y4Q/zWrVs1YMAASZLD4dCKFSv05ptvFtnOyJEj9fjjj+vXX39VzZo1JUk5OTny9/d3wZkA5YshNwAAwLQiIyO1f/9+SVJqaqoMw1DdunUlSTt37lSbNm0k5d8826JFCwUFBUnKH2+flpbmbGfx4sWqWbOmatSo4Vy2d+/eIof5AJUNgR4AAJjW3XffrRUrVkiStm/fXmCITbVq1fT3v/9dUv4sNnFxcc51Z8+eVVxcnNq0aaOoqChNnz5dS5cudd4Ym5ycLJvNRqCHKTDkBgAAVDrJyckl2u7BBx9Uly5dNHHiRPXr10/9+vVzrtu8ebPz319//bVWrVrlfN2gQQNt2rSp2Hbff/99jR8/vsDMN0BlRQ89AAAwraCgIE2ePPmqD4Has2ePbrjhhhK3GxYWplGjRl1reUCFoIceAACY2q233uryNi/PlAOYAT30AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDGmrayEHA6Hsu02d5dRKgEWKw/fAAAAcAMCfSWUbbep+srv3F1GqZyO7aVAK/+dAAAAKhpDbgAAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYWJUI9BkZGRo/frwaN24sPz8/1a9fX2PGjFFWVpYeeughGYah6dOnu7tMADCNnNxszVg8Wve+Gq7bx1t1/2sNy+U4H387Ub3GGUo/lVwu7QOAJ/BydwHlbceOHbrzzjuVnp6uwMBAtWzZUmlpaZo6daoOHTqkU6dOSZLatm3r3kLLiW32HNk//0LW556V5Y7eBdY5HA7Zxr0ox9698po+VUajhu4pEkCllnBotZ5/v6ce7fuW4m95XpI0f9UbWrxumuJ7PK9GdSIV4Bvs5ipRmTkc0qlj0s/7JDkuL5QunJH8q7mvLsBTeHSgz8jIUP/+/ZWenq6xY8dqwoQJCg7Of9N588039cILL8jLy0uGYSgyMtLN1ZYPy/D7ZN+wUbaZH8iIvknG9bWc6+yLFsuxc5csox4gzAMolW0HvlOj0DZ6tN9b7i4FldzJA9LBH6Ts04XXrftQqhUhNe8l+fE7IVBmHj3kZvTo0UpJSdHTTz+tt99+2xnmJWn8+PGKiopSXl6eGjZsqJCQEDdWWn4Mb295jRsr5eTI9u4U53LH8RTZ53wso3kzWeLvcl+BAEzp1Pl0BQfUcHcZqORSEqSdS4oO85dlHJY2f3rlbQBcmcf20O/du1fz589XrVq1NGnSpCK3iY6OVkJCgqKiopzLUlJS9Prrr2vTpk1KSEhQbm6uHA5HkfubhdGksSzDhsj+6TzZl30j447esr35tuRwyDpurAyr1d0lAjCJFZvn6O0vHpQkpZ86ol7jDEnS8F4TNKL3xBK3k/LLAf3r+79o+4HvdS77V9UMCVP3yHgN7z1R/j6BV9z3XPYpffr9X7V+z1fKOJcqP59AhVZvqFvaDtOQW8YV2Hb1jvlavG6aDp9IkN1uU6PQNoq/ZZy6R95duhNHqZ06Ku37vmTbXsyUdiySOo2UrB6bTIDy47E/NvPmzZPdbtd9992noKCgIrfx9/eXpAKB/uDBg1q4cKE6dOggHx8frVu3rkLqLW+W++6Rff1G2T74UJZDh+XYnyTLow/LqF/P3aUBMJHIiO56Ydgnev/r/1NIYC3dG/uyJCmiTsmHLSalbNW4mbEK8qumvjc/plrX1dWhtAQt/nGq9iSv0ztPrJGX1bvY/f/6Sbx2Hf5B/To/rog6kbp46YKO/bxXCYdWFwj0//zPH/XZf19Vh2Z36IHb/yrDsGjd7i/110/i9XTcdA3s+lTZvxC4quRN+t94+RLIPi2d3C/VaVVuJQEey2MD/cqVKyVJPXv2LHablJQUSQUDfffu3XXixAlJ0sSJEz0m0BteXvIa95zynnlW9qXLZLRuJcvgOHeXBcBk6tSMUJ2aEZqz4o+qHlRbt0XfX+o23vlilGoG19H00ZsV8JuB0+0a36o/fzxY/932qW7v8ECR+2ZdOKsdB1eqf+cn9HTctGKPcSBlmz7776saFvsHPXTna87lg2JGa8KcOM3+5g/qFT2iwPHhOlmn8nvoSytlB4EeKAuPHUN/9Gj+laRBgwZFrs/Ly3OG9d8GeovFY78kUmCg5J3f62V0aC/Dk88VQKV05MQuHT6xUz3b3atLtos6m5Xh/NO6UYz8fAK1NenbYvf38faXt5ev9h3beMWpLP+7/VMZhqHe0SMLHONsVoY6txyg7IvnlXh0fTmcISTp1+Sy7Xf2hHQpx6WlAFWCx/bQZ2VlSZIuXLhQ5Pr58+crIyNDwcHBatSoUbnW0r59e6Wnp5d4e4ePjzRzhktrcDgcsr0zWcq7JIXXl/2zz2Xp0V1GWB2XtN+0SVMZubkuaas8DHrwWQUGhehE+gnVq1ev0GvA0/h4+WvW0wfcXUYhx07ulSR9/O0EffzthCK3OZ35c7H7e3v56IkBU/SPJWM0fFIjNajdUm0bx6pLqzjd1OTWAsdxOBwa9VbzYtsq6jhNmjZRbl7R7xsouQEdx2hwl3FX37AIHW66WRnnUlxcEVD5s0BoaKi2bNlSpn09NtCHhobq9OnT2rZtmzp37lxg3YkTJzRuXP6FJjIyUoZhlGst6enpSk1NLfkOfr4qfvRo2dgXfyVHwk5ZHhwpS+eblffUM7K9M1nWt99wyfmnnUiTci66oNLyYbfZnH+npqYWeg14Gj/vAHeXUKTLkwzc3X2sOjS7o8htggKqX7GN/p0fV5dWA7Vx7zLtPLxGa3cu0JJ103VL1FC9fP/nlw8kwzD06kPfyGoUfeN/g9DCYztOpKUp51J2Kc4IRTn564ky73vk6EGdy/7VhdUA+Tw5C3hsoL/tttu0d+9evfHGG+rVq5eaNm0qSdq8ebOGDx+ujIwMSRXzQKnQ0NBSbe/w8dEvLjy+IzVV9tlzZDRrKsuQu2VYrbLcf5/s/5wr++KvZB008JqPEVYnrFL30Fv+/0w+FqtVdevWLfQa8DQ+Xv7uLqFIdWs1kSRZLFbd1PS2MrdTM6SO+nR6WH06PSyb3aY35g3Xqh3zdHePsWpWv4Pq1mqizfv/oxuqhatB7RYlbrdOWBg99C7w64UjkvJ/gStNp9HJM8kKqe6v4Opcl+F6lT0LlDYv/pbHBvrx48frs88+0/Hjx9WqVSs1b95cOTk5OnjwoO688041bNhQK1asKDB+vryU9uOTLFueqq/8ziXHdtjtsr31rmS3yzruOecUlZYhd8ux7ifZZ8+RpVPHax56k3QgSYGVeK6x12Z8qnOZWaoTWkcpKSmFXgOexpYrrZrq7ioKa1y3nRqGttbSDe+r382PqU7NiALrbbY8ZV08p5Bi5rjPyc3vPffz+d8nEFaLVRF1IrVqxzydy85/+vdt0cO1eN00/fObl/TKiAWyWgr20p8+/7OqB9cu1P6BpAOy+lzTKUL5T4bdMFfKyijdJ8BdBjTU8b8dL6eqUNV5chaovAnsGtWrV09r167VuHHjtGbNGiUnJ6tly5aaOXOmHnnkEd14442SVCGB3p3sCxbJkbhXlocflBEe7lxuWK2yPv+cy4feAMCVGIahF4Z9ovEzY/Xou5G6o8MoNajdShcvZSs146DW7V6kUXdOKnaWm5RfkjT2/R7q2mqQGoW2VlBAdR37ea+Wrv+HQms0UptG3SRJzep30IheE/XxdxP1+OS26h4Zr5ohYTp17oQOpG7Vpn3L9c3rlfdTRbMzDCk8Wtq7ouT7WH2ksNblVxPgyTw20EtSixYttHTp0kLLMzMzlZycLIvFotatPffq4Th2TPa5n8ho0VyWuwYXWm80bODyoTcAcDWN67bVP/5vu+atnKT1iV9p6Yb35e8brNDqDdW7/QNq95ubW3/vhmr1dUeHUdpxcJV+2rNYl/IuqtZ1dXVnp0c0tOcLBXruh/eeoKb12+vLH6fqy7VTlJObpWpBN6hhaGs9ObASfnzhYcJaS2fTpLRdV9/WsEiRAySfynnrB1DpeXSgL86ePXvkcDjUtGlTBQQUvnosWLBAkpSYmFjgdcOGDdW+ffuKK/QaGeHh8l625IrbWO8ZKus9QyuoIgBmFHXjLfrurYJPCPrXS8nX1Gbt6g307F3vX3W7Eb0nFngCbUhgTT0xYHKJj9OpRV91atG3LCXiGhmG1KK35OMvHd0iOexFb+cTKLXuK9UIL3o9gKurkoF+16787oLihtvEx8cX+XrkyJGaM2dOudYGAICnMAypcXepfrSUulP6eb90KVsyrFJgdalulHR9Y8lS9EREAEqIQF+Ey9OqAQBKJuvCWV28dOXZYby8fIq92RWezTdQiuic/weA6xHoAQDXbMaSMfpu69wrbhMZ0UPvPLG6YgoCgCqkSgb6lStXursEAPAoQ3uO12033X/Fba72wCgAQNlUyUAPAHCtBrVbqkHtlu4uAwCqJIu7CwAAAABQdgR6AAAAwMQI9AAAAICJEegBAAAAEyPQAwAAACZGoAcAAABMjEAPAAAAmBiBHgAAADAxAj0AAABgYgR6AAAAwMQI9AAAAICJebm7ABQWYLHqdGwvd5dRKgEWq7tLAAAAqJII9JWQYRgKtPKtAQAAwNUx5AYAAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMQI9AAAAYGIEegAAAMDECPQAAACAiRHoAQAAABMj0AMAAAAmRqAHAAAATIxADwAAAJgYgR4AAAAwMS93FwC4UtLh49qya3+h5Rdycpx/f7bk+0KvLwsODFDfWzvLYhgVUzAAAMA1ItDDo0SEh2n56o1K/+VUkesv5dm0c9/hYl8/cPcdhHkAAGAqDLmBR/Hysmpov56yWkv/X7tjVHM1vzG8HKoCAAAoPwR6eJw6N9RU724dSrVPzWoh6hvbuZwqAgAAKD8Eenikbh3aqGG90BJtaxiGhvS9Rb4+3uVcFQAAgOsR6OGRLBaLhvTrWaKQfsvNUWpQwvAPAABQ2RDo4bFqXBes/rd2ueI2YbVr6tau0RVUEQAAgOsxyw08WnSbpko8eFSJB5ILrfOyWjW0X6y8rNaKLwxwM7vdri9/fE/LNsxU+ulkVQu8Xt2jhmjk7X+Rv0+gu8sDAJRClemht9vtWrBggeLi4hQWFiZfX1+FhYUpNjZW7733nnJzc91dIsqBYRgafEc3BQX4F1p3R4+Oql2ruhuqAtzvH1//n97/+jmF126pp+OmqXtkvBb/OFV/mt1fdrvd3eUBAEqhSvTQnzx5UkOGDNGaNWskSeHh4Wrbtq3S09O1atUqbdiwQU8//bSbq0R5CQrw1+A7u+vjhSucy25sEKYu7Vu7sSrAfZLT92jJummKaT1YE0YudC4PrdFIM5aM1uqEzxXb7l43VggAKA2P76HPyspSnz59tGbNGvXo0UMJCQk6evSoNm7cqKNHj2r37t168cUXZWXYhUdr2biBOkQ2lyT5+foovs8tPEAKVdaqHfPkcDg0uNuzBZb36fSI/LwD9P22f7mnMABAmXh8D/3YsWO1detWxcTE6Ntvv5WPj0+B9a1atVKrVq3cVB0qUr/Ym3XoWKp6xbRXtZAgd5cDuM3+45tlMSxqFt6xwHIfbz9FhLVV0vHNbqoMAFAWhsPhcLi7iPKyb98+tW7dWl5eXkpKSlJ4+NWfAnrkyBGNGTNGq1atkpeXl/r376/JkyerZs2aZa5j2txFOp95ocz7w3XsDrsshsd/MAXI4rCqfc6wItc98k4bnck8qX9P+LnQur9+MkQ/7Py3lk+6KG8vnyL29mxb/D6X3bC5uwwA5eB8VrYcDocMw1BwYECh1+4WHOSvZ0YOLtO+Ht1D/9lnn8lms2nEiBElCvPnz59Xz549VaNGDc2bN08XLlzQ+PHj1a9fP61bt04WS9mC4PnMCzqXmVWmfQGgLCzykooZSXgxN1veXr5FrvPx8svf5lJ2lQz057KyZVeeu8sAUI4cDkeBXPb712bk0YH++++/lyT16dOnRNvPmjVLqamp+uGHH5y/ANSrV09dunTRV199pbi4uDLVERxUeIYVAChPFodVyil6na9PgC5knixyXW5e/k6+3u7vrXKHkMAAeugBD2WGHvqy8uhAf/z4cUlSREREibZfunSpYmJiCvTmd+7cWREREfr666/LHOjL+vEJAJSVLVdaNbXodTVDwnTs50Tl5l2Uz+966jPOpuq6wFpVsndeksY9OkzWqnnqgMd7bcanOpeZpeDAAL301H2FXpuZRwf6rKz8j08uXCjZ+PXExETFx8cXWt6qVSslJiaWuQ7G0AOoaBaHVe1V9Bj6ZvU7aGvSt9p/bJPaRHRzLs+9lKPDaTvUJqJ7RZVZ6bw1izH0gKc6n5Xt/Pu1GZ8Weu1ujKEvRv369XX69Gn99NNP6tq161W3P336tKpVq1ZoeY0aNbR///4y18EYegAV7Upj6G+JGqp5K1/TorVTCgT65Rs/UM6lbMW2M3dP1bVgDD3g+RhDbzKDBg3Szp079eqrryoqKkq9e/d2rktNTdXcuXMVHx+vJk2alGsdjKEHUNGuNIa+UZ02GtDlKS1ZN10T5w5Wx+Z9dOzkXi3+caoiI3pU6YdKMYYe8FyePIbeo6etzMzMVI8ePbRt2zZJUmhoqOrXr69Tp07p8OHDMgxD586dU2BgoCSpdu3aio+P1/Tp0wu0M2DAAP3yyy9av359hZ8DAJTFlcbQS5LNbtOitVO0fOMs/XwqWSGBtXRL1FCNvP0v8vetus9p6DlajKEHPNTlMfMhQYEFxtBffm1mHt1DHxQUpLVr12ry5Mn697//raSkJJ09e1ahoaGKi4vT4MGDnWFeklq0aFHkWPnExER17151x5QC8DxWi1XxPcYqvsdYd5cCALhGHh3oJSkgIEAvv/yyXn755atu269fP7300ktKSUlRvXr1JEkbN27UoUOH9NZbb5V3qQAAAECp8cjM33j00UdVp04dDRw4UEuXLtWCBQt0zz33qGPHjho4cKC7ywMAAAAKIdD/RkhIiFauXKk6depo2LBhevjhh9WlSxctXbq0zE+JBQAAAMqTxw+5Ka0bb7xRS5cudXcZAAAAQInQ7QwAAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxLzcXQAAwPUs3lLP0e6uwnws3u6uAABKj0APAB7IMCSrj7urAABUBIbcAAAAACZGoAcAAABMjEAPAAAAmBiBHgAAADAxAj0AAABgYgR6AAAAwMQI9AAAAICJEegBAAAAEyPQAwAAACZGoAcAAABMjEAPAAAAmBiBHgAAADAxAj0AAABgYgR6AAAAwMQI9AAAAICJEegBAAAAEyPQAwAAACZGoAcAAABMjEAPAAAAmBiBHgAAADAxAj0AAABgYgR6AAAAwMQI9AAAAICJEegBAAAAEyPQAwAAACbm5e4CAAAAAFfJOH1Wp86cL7Q8z2Zz/p10JKXQ69+6sUGYrBbz9HsbDofD4e4iAAAAAFc4ffa8psxeoIu5l8q0f8eo5hp8R3cXV1W+zPOrBwAAAHAV1a8L1oDbupZp3xrVgtU3trOLKyp/BHoAAAB4lJtaN1Grpg1LtY9hGBrSt6d8fbzLp6hyRKAHAACARzEMQ4Nu76agQP8S79OjU5Qa1gstx6rKD4EeAAAAHicowF9339mjRNvWuaGmbouJLueKyg+BHgAAAB6p+Y3h6hjV/IrbeFmtGtavp7ys1gqqyvUI9AAAAPBYfWM7q2a1kGLX396jg2pfX6MCK3K9KhXo7Xa7FixYoLi4OIWFhcnX11dhYWGKjY3Ve++9p9zcXHeXCAAAABfy9fHWkL63yDCMQusiwsPUtX0bN1TlWlVmHvqTJ09qyJAhWrNmjSQpPDxcoaGhSk9P17Fjx+Tv76/z58/LauKPWwAAAFC0FT9s0qr1O5yvfX289X8PxataSJD7inKRKvGk2KysLPXp00dbt25Vjx49NHXqVEVGRjrX79mzRwsXLiTMAwAAeKhbu0Zr/+HjSvv5V0nSwF5dPSLMS1Wkh/7xxx/XzJkzFRMTo//+97/y8fFxd0kAAACoYD9nnNa0OYvUonG47h14W5HDcMzI4wP9vn371Lp1a3l5eSkpKUnh4eFX3D4lJUWvv/66Nm3apISEBOXm5upav0TT5i7S+cwL19QGAAAArt2lvEvysnpVujAfHOSvZ0YOLtO+Hj/k5rPPPpPNZtOIESOuGuYl6eDBg1q4cKE6dOggHx8frVu37pprOJ95Qecys665HQAAALiCZ02E4vGB/vvvv5ck9enTp0Tbd+/eXSdOnJAkTZw40SWBPjio5E8pAwAAQNVzLXnR4wP98ePHJUkREREl2t5icf1MnmX9+AQAAAC4Go8P9FlZ+UNdLlxw3xh2xtADAADgShhDfwX169fX6dOn9dNPP6lr165uqYEx9AAAACgvHh/oBw0apJ07d+rVV19VVFSUevfu7VyXmpqquXPnKj4+Xk2aNCm3GhhDDwAAgCu5lrzo8dNWZmZmqkePHtq2bZskKTQ0VPXr19epU6d0+PBhGYahc+fOKTAwsNC+EydO1J///OdrnrYSAAAAKC+uvwO0kgkKCtLatWv1t7/9TVFRUTp79qx2794tu92uuLg4zZ07t8gwDwAAAJiBxw+5kaSAgAC9/PLLevnll91dCgAAAOBSVSLQl9aCBQskSYmJiQVeN2zYUO3bt3dbXQAAAMDvefwY+rIo7lHAI0eO1Jw5cyq2GAAAAOAK6KEvAr/jAAAAwCw8/qZYAAAAwJMR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBiBHoAAADAxAj0AAAAgIkR6AEAAAATI9ADAAAAJkagBwAAAEyMQA8AAACYGIEeAAAAMDECPQAAAGBi/w+SQWsmV/7ZIwAAAABJRU5ErkJggg==",
                        "text/plain": [
                            "<Figure size 956.183x367.889 with 1 Axes>"
                        ]
                    },
                    "execution_count": 15,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister\n",
                "import numpy as np\n",
                "\n",
                "\n",
                "def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:\n",
                "    # qr is a quantum register with 2 qubits\n",
                "    # cr is a classical register with 2 bits\n",
                "\n",
                "    qc = QuantumCircuit(qr, cr)\n",
                "\n",
                "    ########## your code goes here #######\n",
                "\n",
                "    # Initialization\n",
                "    q0, q1 = qr\n",
                "    if step1_bit:\n",
                "        qc.x(q0)\n",
                "    qc.x(q1)\n",
                "\n",
                "    # Measure the auxiliary qubit\n",
                "    c0, c1 = cr\n",
                "    qc.measure(q0, c0)\n",
                "\n",
                "    # Reset and re-initialize the auxiliary qubit\n",
                "    qc.reset(q0)\n",
                "    qc.h(q0)\n",
                "\n",
                "    # Apply phase correction conditioned on the first classical bit\n",
                "    with qc.if_test((c0, 1)):\n",
                "        qc.p(-np.pi / 2, q0)\n",
                "\n",
                "    # Apply control-U operator as many times as needed to get the next phase bit\n",
                "    u_angle = 2 * np.pi / 3\n",
                "    k = 0\n",
                "    cphase_angle = u_angle * 2**k\n",
                "    qc.cp(cphase_angle, q0, q1)\n",
                "\n",
                "    # Measure the auxiliary qubit in x-basis into the second classical bit\n",
                "    qc.h(q0)\n",
                "    qc.measure(q0, c1)\n",
                "\n",
                "    return qc\n",
                "\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(2, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = u_circuit(qr, cr)\n",
                "qc.draw(\"mpl\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 17,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Grading your answer. Please wait...\n",
                        "\n",
                        "Congratulations 🎉! Your answer is correct.\n"
                    ]
                }
            ],
            "source": [
                "# Submit your result\n",
                "\n",
                "from qc_grader.challenges.spring_2023 import grade_ex3e\n",
                "\n",
                "grade_ex3e(qc)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 18,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "{'11': 637, '01': 9363}\n",
                        "Success probability: 0.9363\n"
                    ]
                }
            ],
            "source": [
                "from qiskit_aer import AerSimulator\n",
                "\n",
                "sim = AerSimulator()\n",
                "job = sim.run(qc, shots=10000)\n",
                "result = job.result()\n",
                "counts = result.get_counts()\n",
                "print(counts)\n",
                "success_probability = counts[\"01\"] / counts.shots()\n",
                "print(f\"Success probability: {success_probability}\")"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Now, the success probability is much higher than before!"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Run on hardware\n",
                "\n",
                "In the final part of this lab, we will run some circuits on real hardware! The code cells below initialize and run the circuit you created in Exercise 2 to measure the phase of the $S$ gate. Because current quantum hardware suffers from noise, the results will not be as good as what you got on the simulator. Feel free to try running the other circuits you created in this lab, though be aware that larger circuits, like the one from Exercise 3 for measuring the phase of the $T$ gate, will suffer from even more noise."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "from qiskit_ibm_provider import IBMProvider\n",
                "\n",
                "provider = IBMProvider()"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "hub = \"system-request\"\n",
                "group = \"3-9-23-access\"\n",
                "project = \"main\"\n",
                "\n",
                "backend_name = \"ibm_peekskill\"\n",
                "backend = provider.get_backend(backend_name, instance=f\"{hub}/{group}/{project}\")"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "from qiskit import transpile\n",
                "\n",
                "qr = QuantumRegister(2, \"q\")\n",
                "cr = ClassicalRegister(2, \"c\")\n",
                "qc = QuantumCircuit(qr, cr)\n",
                "qc = step_2_circuit(qr, cr)\n",
                "qc_transpiled = transpile(qc, backend)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "job = backend.run(qc_transpiled, shots=1000, dynamic=True)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "from qiskit.tools.visualization import plot_histogram\n",
                "\n",
                "counts = job.result().get_counts()\n",
                "plot_histogram(counts)"
            ]
        },
        {
            "attachments": {},
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "This lab was adapted from the [Qiskit Textbook lab](https://learn.qiskit.org/course/ch-labs/lab-6-iterative-phase-estimation-algorithm) on iterative phase estimation as well as material from the [dynamic circuits documentation](https://quantum-computing.ibm.com/services/resources/docs/resources/manage/systems/dynamic-circuits/Getting-started-with-Dynamic-Circuits)."
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "spring-challenge-2023-IPKbsBMi",
            "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.3"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}