diff --git a/quantum_paradox/README.md b/quantum_paradox/README.md new file mode 100644 index 0000000..fd81c16 --- /dev/null +++ b/quantum_paradox/README.md @@ -0,0 +1,75 @@ +# Quantum Pigeonhole Paradox + +**Author:** Dikran Meliksetian (Qiskit Advocate) +**Date:** 2025 +**Compatible Qiskit version:** 2.x + +--- + +## 🧠 Overview +This tutorial explores the **quantum pigeonhole paradox** — a counterintuitive result from pre-/post-selection quantum mechanics, where three particles appear never to share two boxes. + +We show: +1. How a **single ancilla parity check** reveals the paradox for any pair. +2. Why using **three ancillas simultaneously** collapses the interference pattern. +3. How a **weak, reversible probe** (compute → $R_y(ε)$ → uncompute) restores the paradox, connecting to **weak measurement theory**. + +--- + +## 🧩 Learning Goals +- Represent pre-/post-selection circuits in Qiskit. +- Understand ancilla-based parity checking and post-selection. +- Observe interference collapse and recovery via weak measurement. +- Compute weak values and confidence intervals. + +--- + +## ⚙️ Requirements + +You can install dependencies with: + +```bash +conda env create -f environment.yml +conda activate pigeonhole +``` + +or with `pip`: + +```bash +pip install qiskit qiskit-aer matplotlib numpy +``` + +--- + +## ▶️ Running the Notebook + +Launch Jupyter and open: + +``` +quantum_pigeonhole_paradox.ipynb +``` + +Execute all cells sequentially. Inline circuit diagrams will appear automatically. + +--- + +## 🧪 References + +- Y. Aharonov, D. Rohrlich, *Quantum Paradoxes: Quantum Theory for the Perplexed*, Wiley-VCH (2005). +- N. Katz *et al.*, “Reversal of the weak measurement of a quantum state in a superconducting phase qubit,” *Phys. Rev. Lett.* **101**, 200401 (2008). +- Y. Aharonov *et al.*, “Quantum violation of the pigeonhole principle,” *PNAS* **111** (14), 4602–4605 (2014). + +--- + +## 🧾 Citation + +If you use or adapt this work, please cite: + +> Dikran Meliksetian (Qiskit Advocate), +> *The Quantum Pigeonhole Paradox in Qiskit 2.x: From Strong to Weak Measurements*, +> DOI: 10.5281/zenodo.17387139. + +--- + +## 🤖 Acknowledgments +This notebook was developed with assistance from AI tools(ChatGPT Anthropic Claude and Google Gemini) for drafting, code refactoring, and LaTeX/Markdown formatting. All content was reviewed and verified by the author. diff --git a/quantum_paradox/environment.yml b/quantum_paradox/environment.yml new file mode 100644 index 0000000..dfa7ca0 --- /dev/null +++ b/quantum_paradox/environment.yml @@ -0,0 +1,11 @@ +name: pigeonhole +channels: + - conda-forge +dependencies: + - python=3.10 + - qiskit=2.* + - qiskit-aer + - matplotlib + - numpy + - jupyter + - notebook diff --git a/quantum_paradox/quantum_pigeonhole_paradox.ipynb b/quantum_paradox/quantum_pigeonhole_paradox.ipynb new file mode 100644 index 0000000..44395cf --- /dev/null +++ b/quantum_paradox/quantum_pigeonhole_paradox.ipynb @@ -0,0 +1,739 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Quantum Pigeonhole Paradox in Qiskit 2.x: From Strong to Weak Measurements\n", + "\n", + "**Author:** Dikran Meliksetian (Qiskit Advocate)\n", + "\n", + "**Summary:** This tutorial demonstrates the *three particles in two boxes* (quantum pigeonhole) paradox with Qiskit 2.x. We begin with a strong ancilla-based parity check for one pair, then show why checking all three pairs at once collapses the effect. Finally, we restore the paradox using a **weak, reversible probe** (compute → weak-poke → uncompute) that preserves the interference required by post-selection. The notebook includes confidence-interval estimates for the weak readout.\n", + "\n", + "**Learning goals**\n", + "- Understand the pre-post-selection version of the quantum pigeonhole paradox.\n", + "- Implement ancilla-based strong parity checks in Qiskit.\n", + "- See why multiple which-path marks destroy interference.\n", + "- Implement a weak measurement via compute → $R_y(\\varepsilon)$ → uncompute.\n", + "- Analyze postselected results and compute confidence intervals.\n", + "\n", + "**Qiskit version:** 2.x\n" + ] + }, + { + "cell_type": "markdown", + "id": "4b2b853c", + "metadata": {}, + "source": [ + "\n", + "## 1. Background\n", + "The **quantum pigeonhole paradox** is a striking illustration of how quantum correlations defy classical logic. In classical reasoning, placing three pigeons into two boxes guarantees that at least two pigeons share the same box — a simple consequence of the pigeonhole principle. \n", + "\n", + "However, in the quantum realm, if we prepare three particles in a superposition of being in both boxes and then postselect them in a specific final state, it turns out that **no two particles are ever found in the same box** within the postselected ensemble. Each pair, when examined through a suitable measurement, appears to occupy different boxes, even though only two boxes exist. This paradox arises from the nonclassical interplay of quantum superposition, entanglement, and post-selection, revealing that the notion of “being in the same place” loses its classical meaning when quantum interference and measurement context are taken into account.\n", + "\n", + "Formally, we label the two boxes by computational basis states $\\ket{0} \\equiv \\ket{L}$ and $\\ket{1} \\equiv \\ket{R}$; and consider three qubits (particles) with $$\\text{pre-selection: } \\ket{\\Psi}=\\ket{+}^{\\otimes 3},\\qquad \\ket{+}=\\tfrac{1}{\\sqrt{2}}(\\ket{0}+\\ket{1}),$$ and post-select each qubit in the basis $$\\ket{\\phi}=\\tfrac{1}{\\sqrt{2}}(\\ket{0}+i\\ket{1}), \\quad \\text{i.e., project onto }\\ket{\\Phi}=\\ket{\\phi}^{\\otimes 3}.$$\n", + "For any pair $(i,j)$, we define the *same box* projector (acting as identity on the remaining qubit $k$): $$\\Pi^{\\text{same}}_{ij}=\\big(\\ket{00}\\!\\bra{00}+\\ket{11}\\!\\bra{11}\\big)_{ij}\\otimes I_k.$$\n", + "In this setting, one finds $\\langle \\Phi|\\,\\Pi^{\\text{same}}_{ij}\\,|\\Psi\\rangle=0$ for each pair $(i,j)$, suggesting that within the postselected subensemble **no two particles share a box**. We will explore how measurement back-action and post-selection interplay to produce (or erase) this effect." + ] + }, + { + "cell_type": "markdown", + "id": "015c1b0e", + "metadata": {}, + "source": [ + "## 2. Verifying the Pigeonhole paradox on a Quantum Computer\n", + "\n", + "The quantum pigeonhole paradox cannot be directly measured on a quantum computer because the act of measurement itself destroys the delicate quantum interference on which the paradox depends. The phenomenon arises only within a postselected subensemble of states — those that satisfy both a specific pre-selection and a specific post-selection condition. Any attempt to measure all pairwise correlations simultaneously, or to perform strong projective measurements on the “boxes,” collapses the superposition and erases the interference pattern that makes the paradox observable. To probe it experimentally, one must therefore use indirect measurements that reveal partial information about correlations without disturbing the underlying quantum coherence. This necessity makes the paradox a powerful demonstration of the difference between classical observation and quantum inference: the effect exists not as a directly observable state, but as a statistical feature of carefully prepared and postselected quantum ensembles\n", + "\n", + "In the single-ancilla implementation of the quantum pigeonhole paradox, we use one extra qubit as a probe to check whether a chosen pair of data qubits (say qubits 0 and 1) are in the same or different “box.” The idea is to encode the parity of the two qubits into the ancilla without directly measuring the data qubits themselves. We start by preparing the three data qubits in the superposition state $\\ket{\\Psi}=\\ket{+}^{\\otimes 3}$, corresponding to each particle being equally likely in both boxes. Then we apply two CNOT gates—one controlled by qubit 0 and one by qubit 1—with the ancilla as the target, followed by an X gate on the ancilla to create the logical XNOR of the two data qubits. This operation flips the ancilla if exactly one of the two control qubits is $\\ket{1}$, leaving it unchanged if both are the same (00 or 11). In this way, the ancilla encodes whether the pair is different (ancilla = 0) or the same (ancilla = 1). After this encoding, we “rotate” the three data qubits to the post-selection basis $\\{ \\ket{\\phi},\\ket{\\phi}^\\dagger \\}$ and measure all qubits. By keeping only the shots in which all data qubits are found in the desired post-selected state $\\ket{\\Phi}=\\ket{+}^{\\otimes 3}$, i.e, when the corresponding measurement is 000, we effectively reproduce the paradoxical prediction: the ancilla—serving as an indirect correlation meter—shows that the chosen pair is never “in the same box,” even though this is impossible classically.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "dd5d1e17", + "metadata": {}, + "source": [ + "## 3. Single-ancilla check (one pair)\n", + "\n", + "We encode the parity of $(q_0,q_1)$ into an ancilla $a_{01}$ with two CNOTs: $a_{01} \\leftarrow q_0 \\oplus q_1$. Interpreting ancilla `0` as **same** (00/11) and `1` as **different** (01/10), we then rotate data to the $\\ket{\\phi}$ basis and measure. Within postselected shots, this often shows a strong bias toward **different** for that pair.\n", + "\n", + "To perform the post-selection, we measure each data qubit in the basis of the state $\\ket{\\phi} = \\frac{1}{\\sqrt{2}} (\\ket{0} + i\\ket{1}$.\n", + "This is an eigenstate of the Pauli-Y operator, so this is equivalent to a Y-basis measurement.\n", + "A standard Y-basis measurement is implemented by applying a basis-change circuit before the standard Z-basis measurement.\n", + "The unitary for this transformation is the adjoint of the state preparation circuit for $\\ket{\\phi}$ (which is an H gate then an S gate).The required transformation is therefore $U^{\\dagger} = (S H)^{\\dagger} = H S^{\\dagger}$.\n", + "This sequence of gates (Hadamard followed by S-dagger) maps the target state $\\ket{\\phi}$ to the computational state $\\ket{0}$.\n", + "As a result, a successful post-selection on all three qubits in the $\\ket{\\phi}$ state corresponds to measuring the classical bits '000'.\n", + "\n", + "### Setup the circuit\n", + "In this tutorial we use Qiskit2.x\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "38fb52dc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Qiskit version: 2.1.1\n", + "Qiskit Aer version: 0.17.1\n" + ] + } + ], + "source": [ + "from qiskit import QuantumCircuit, transpile\n", + "from qiskit_aer import AerSimulator\n", + "import qiskit\n", + "import qiskit_aer\n", + "import numpy as np\n", + "from math import pi, sqrt\n", + "import matplotlib.pyplot as plt # if adding visualizations\n", + "\n", + "print(f\"Qiskit version: {qiskit.__version__}\")\n", + "print(f\"Qiskit Aer version: {qiskit_aer.__version__}\")\n", + "\n", + "# we are using a fixed seed to have reproducibility\n", + "\n", + "backend = AerSimulator(seed_simulator=42)\n" + ] + }, + { + "cell_type": "markdown", + "id": "51eaea76", + "metadata": {}, + "source": [ + "The circuit is build based on he description in the previous paragraph" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4a781223", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qc_single = QuantumCircuit(4,4)\n", + "# To perform the pre-selection, we need to prepare the qubits in |+> state, we use Hadamard gates to do this\n", + "qc_single.h([0,1,2])\n", + "qc_single.barrier()\n", + "\n", + "# To perform the XNOR of qubit 0 and 1 in qubit 3, we use two CX gates\n", + "qc_single.cx(0,3); \n", + "qc_single.cx(1,3)\n", + "qc_single.barrier()\n", + "\n", + "# To perform the post-selection, we measure each data qubit in the basis of the state |φ⟩ = (1/√2)(|0⟩ + i|1⟩).\n", + "for q in [0,1,2]:\n", + " qc_single.rz(np.pi/2, q); qc_single.h(q)\n", + "qc_single.barrier()\n", + "\n", + "\n", + "# We measure all the qubits\n", + "qc_single.measure([0,1,2,3],[0,1,2,3])\n", + "\n", + "\n", + "# Lets visualize the circuit\n", + "display(qc_single.draw(\"mpl\"))" + ] + }, + { + "cell_type": "markdown", + "id": "677e75e8", + "metadata": {}, + "source": [ + "\n", + "Postselection keeps only outcomes with data bits `c0=c1=c2=0` (i.e., $\\ket{\\phi}$ success on all three data qubits).\n", + "\n", + "Here is a helper function to perform this postselection\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8b4d674f", + "metadata": {}, + "outputs": [], + "source": [ + "#Note since Qiskit results are in MSB, the measured values of \n", + "# the c0, c1, c2 are the last bits of the measured bit string \n", + "\n", + "def postselect_data_000(counts):\n", + " kept = {}\n", + " for b, ct in counts.items():\n", + " if len(b) >= 3 and b[-3] == b[-2] == b[-1] == '0':\n", + " kept[b] = ct\n", + " return kept\n" + ] + }, + { + "cell_type": "markdown", + "id": "64791dc3", + "metadata": {}, + "source": [ + "We run the circuit using the simulator backend and count among the postselected data points the ones that have the ancilla=0 (same) and ancilla = 1 (different).\n", + "We then print those results" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "d44008d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'kept': 1064, 'same': 0, 'diff': 1064}\n", + "same frac: 0.0 diff frac: 1.0\n" + ] + } + ], + "source": [ + "res = backend.run(transpile(qc_single, backend), shots=8192).result().get_counts()\n", + "kept = postselect_data_000(res)\n", + "same = sum(ct for b, ct in kept.items() if b[0]=='0')\n", + "diff = sum(ct for b, ct in kept.items() if b[0]=='1')\n", + "print({'kept': sum(kept.values()), 'same': same, 'diff': diff})\n", + "if sum(kept.values())>0:\n", + " print('same frac:', round(same/sum(kept.values()),3), 'diff frac:', round(diff/sum(kept.values()),3))\n" + ] + }, + { + "cell_type": "markdown", + "id": "8e5219ee", + "metadata": {}, + "source": [ + "As expected, for all cases where the first three qubits are measured as 000, corresponding to the theoretical case of a projection on $\\ket{\\Phi}$, the ancillary is measured as 1, indicating that the two selected qubits are different" + ] + }, + { + "cell_type": "markdown", + "id": "7a8e6508", + "metadata": {}, + "source": [ + "### Formal Justification\n", + "\n", + "The preselected state with the ancilla qubit is $\\ket{0}_3 \\otimes \\ket{\\Psi}$.\n", + "The operator can be symbolically written as:\n", + "\n", + "$U_c = I_3 \\otimes \\Pi_{01}^{\\text{same}} + X_3 \\otimes \\Pi_{01}^{\\text{diff}}$ \n", + "\n", + "where $\\Pi_{01}^{\\text{same}} = I_2 \\otimes \\large(\\ket{0}_1\\bra{0}_0 + \\ket{1}_1 \\bra{1}_0 \\large)$ and $\\Pi_{01}^{\\text{diff}} = I - \\Pi_{01}^{\\text{\\text{same}}}$\n", + "\n", + "This operator acting on the preselected state gives:\n", + "\n", + "$U_c\\large(\\ket{0}_3\\otimes\\ket{\\Psi}\\large) = \\ket{0}_3 \\otimes \\Pi_{01}^{\\text{same}}\\ket{\\Psi} + \\ket{1}_3\\otimes\\Pi_{01}^{\\text{diff}}\\ket{\\Psi}$\n", + "\n", + "When we measure the ancilla in $Z$ and post select the data on $\\ket{\\Phi}$, the probabilities of measuring the ancilla are;\n", + "\n", + "$Pr(c_3 = 0, c_0c_1c_2 = 000) = \\left \\Vert \\langle \\Phi \\mid \\Pi_{01}^{\\text{same}} \\mid \\Psi \\rangle \\right \\Vert^2$ and $Pr(c_3 = 1, c_0c_1c_2 = 000) = \\left \\Vert \\langle \\Phi \\mid \\Pi_{01}^{\\text{diff}} \\mid \\Psi \\rangle \\right \\Vert^2$\n", + "\n", + "So the conditional probability that the pair is \"same\" is \n", + "\n", + "$\\displaystyle Pr(c_3 = 0 \\mid c_0c_1c_2 = 000) = \\frac{ \\left \\Vert \\langle \\Phi \\mid \\Pi_{01}^{\\text{same}} \\mid \\Psi \\rangle \\right \\Vert^2 } { \\left \\Vert \\langle \\Phi \\mid \\Pi_{01}^{\\text{same}} \\mid \\Psi \\rangle \\right \\Vert^2 + \\left \\Vert \\langle \\Phi \\mid \\Pi_{01}^{\\text{diff}} \\mid \\Psi \\rangle \\right \\Vert^2 }$\n", + "\n", + "since $\\langle \\Phi \\mid \\Pi_{01}^{\\text{same}} \\mid \\Psi \\rangle = 0$ for the pigeonhole setup, Pr(same) =0 and Pr(diff) = 1.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "d041e773", + "metadata": {}, + "source": [ + "### Checking other pairs with a single ancilla\n", + "\n", + "The paradox and the chosen pre-/post-selection are **symmetric** under permutations of the three qubits. If we couple the ancilla to $(0,2)$ or $(1,2)$ instead of $(0,1)$, we obtain **the same postselected statistics** (up to sampling noise). This symmetry is one of the signatures of the paradox: every pair *seems* to avoid sharing a box.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "371b28a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'pair': (0, 1), 'kept': 1064, 'same_frac': 0.0, 'diff_frac': 1.0}\n", + "{'pair': (0, 2), 'kept': 1064, 'same_frac': 0.0, 'diff_frac': 1.0}\n", + "{'pair': (1, 2), 'kept': 1064, 'same_frac': 0.0, 'diff_frac': 1.0}\n" + ] + } + ], + "source": [ + "def single_pair_result(i,j,shots=8192):\n", + " qc = QuantumCircuit(4,4)\n", + " qc.h([0,1,2])\n", + " qc.cx(i,3); qc.cx(j,3)\n", + " for q in [0,1,2]:\n", + " qc.rz(np.pi/2, q); qc.h(q)\n", + " qc.measure([0,1,2,3],[0,1,2,3])\n", + " res = backend.run(transpile(qc, backend), shots=shots).result().get_counts()\n", + " kept = postselect_data_000(res)\n", + " same = sum(ct for b, ct in kept.items() if b[0]=='0')\n", + " diff = sum(ct for b, ct in kept.items() if b[0]=='1')\n", + " tot = same+diff\n", + " return {'pair':(i,j), 'kept': tot, 'same_frac': (same/tot if tot else np.nan), 'diff_frac': (diff/tot if tot else np.nan)}\n", + "\n", + "for pair in [(0,1),(0,2),(1,2)]:\n", + " print(single_pair_result(*pair))\n" + ] + }, + { + "cell_type": "markdown", + "id": "6b4d3af0", + "metadata": {}, + "source": [ + "The results are as expected" + ] + }, + { + "cell_type": "markdown", + "id": "47084565", + "metadata": {}, + "source": [ + "## 4. Three ancillas \n", + "\n", + "Instead of checking each pair with a different run, we try to encode **all three parities at once** on three separate ancillas and keep them encoded through post-selection\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "554797ac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc_multi = QuantumCircuit(6,6)\n", + "qc_multi.h([0,1,2])\n", + "qc_multi.barrier()\n", + "qc_multi.cx(0,3); qc_multi.cx(1,3)\n", + "qc_multi.cx(0,4); qc_multi.cx(2,4)\n", + "qc_multi.cx(1,5); qc_multi.cx(2,5)\n", + "qc_multi.barrier()\n", + "for q in [0,1,2]:\n", + " qc_multi.rz(np.pi/2, q); qc_multi.h(q)\n", + "qc_multi.barrier()\n", + "qc_multi.measure([0,1,2,3,4,5],[0,1,2,3,4,5])\n", + "qc_multi.draw('mpl')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "id": "8d9eeafb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Postselected shots kept: 1068\n", + "(0,1): {'kept': 1068, 'same_frac': 0.4868913857677903, 'diff_frac': 0.5131086142322098}\n", + "(0,2): {'kept': 1068, 'same_frac': 0.4953183520599251, 'diff_frac': 0.5046816479400749}\n", + "(1,2): {'kept': 1068, 'same_frac': 0.47846441947565543, 'diff_frac': 0.5215355805243446}\n" + ] + } + ], + "source": [ + "res = backend.run(transpile(qc_multi, backend), shots=8192).result().get_counts()\n", + "kept = postselect_data_000(res)\n", + "\n", + "def stats(idx):\n", + " same = sum(ct for b, ct in kept.items() if b[idx]=='0')\n", + " diff = sum(ct for b, ct in kept.items() if b[idx]=='1')\n", + " tot = same+diff\n", + " return {'kept': tot, 'same_frac': (same/tot if tot else np.nan), 'diff_frac': (diff/tot if tot else np.nan)}\n", + "\n", + "print('Postselected shots kept:', sum(kept.values()))\n", + "print('(0,1):', stats(2))\n", + "print('(0,2):', stats(1))\n", + "print('(1,2):', stats(0))\n" + ] + }, + { + "cell_type": "markdown", + "id": "9b603712", + "metadata": {}, + "source": [ + "The result is contrary to the expected outcome. \n", + "The key challenge: any attempt to **strongly measure** whether pairs share boxes collapses the quantum state, destroying the delicate interference that creates the paradox. Strong measurements create \"which-path\" information that decoheres the superposition state needed for the effect. \n", + "Empirically, postselected counts drift to $\\sim$ 50/50." + ] + }, + { + "cell_type": "markdown", + "id": "7bab97b5", + "metadata": {}, + "source": [ + "### Formal Explanation\n", + "\n", + "Note $\\displaystyle \\ket{\\Psi}= \\ket{+}^{\\otimes 3} = \\frac{1}{\\sqrt{8}} \\sum_{x_2=0}^{1}\\sum_{x_1=0}^{1}\\sum_{x_0=0}^{1} \\ket{x_2x_1x_0}$\n", + "\n", + "Let $U_c$ be the operator representing taking the XOR operation on all pairs, then:\n", + "$$ U_c: \\ket{000}\\ket{x_2x_1x_0} \\rightarrow \\ket{s_{12}s_{02}s_{01}}\\ket{x_2x_1x_0} $$\n", + "where $s_{ij} = {x_i \\oplus x_j}$ \n", + "\n", + "Note also that $\\langle \\phi \\mid 0 \\rangle= \\frac{1}{\\sqrt{2}}$ and $\\braket{\\phi,1}= \\frac{i}{\\sqrt{2}}$ and consequently $\\langle \\Phi \\mid x_2x_1x_0\\rangle = \\frac{1}{\\sqrt{8}} i ^ {w_H(x_2x_1x_0)}$ where $w_H()$ is the Hamming weight\n", + "\n", + "Projecting the the 3 least significant qubits of $$\\frac{1}{\\sqrt{8}} \\sum_{x_2=0}^{1}\\sum_{x_1=0}^{1}\\sum_{x_0=0}^{1} \\ket{{x_1 \\oplus x_2}}\\ket{{x_0 \\oplus x_2}}\\ket{{x_0 \\oplus x_1}}\\ket{x_2x_1x_0}$$ onto $\\ket{\\Phi}$, we obtain\n", + " $$\\ket{A} = \\frac{1}{{8}} \\sum_{x_2=0}^{1}\\sum_{x_1=0}^{1}\\sum_{x_0=0}^{1} \\ket{{x_1 \\oplus x_2}}\\ket{{x_0 \\oplus x_2}}\\ket{{x_0 \\oplus x_1}} i ^ {w_H(x_2x_1x_0)}$$\n", + "\n", + " It is straighforward to evaluate the 8 possibilities to reformulate this expression as\n", + "$$\\ket{A} = \\frac{1}{{8}} (1-i)\\large(\\ket{000} - \\ket{110} -\\ket{101} - \\ket{011}\\large)$$\n", + "\n", + "Since all those states have the same magnitude amplitude, the ancilla probabilities are uniformly distributed over those triples and measuring any ancilla bit will result into a 0 or a 1 with probabilty 50\\% \n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "07b7a89e", + "metadata": {}, + "source": [ + "## 5. Restoring the effect: weak probe \n", + "\n", + "It is obvious that performing the XOR of a pair of data qubit in an ancilla and then measuring that qubit affects the overall system. The impact is minimal when we do that for only one pair, hence we get the expected result for that case.\n", + "However when we attempt to measure all 3 pairs in the same way, the impact destroys the delicate interference of the data qubits in the system.\n", + "\n", + "In order to minimize the impact, we try to use the principlee of weak prob \n", + "\n", + "The weak, reversible probe relies on three key steps that together allow us to *store* the measurement outcome as a coherent phase shift on the ancilla — without collapsing the data qubits.\n", + "\n", + "##### 1️ Compute — entangle the question\n", + "We begin by **computing** the “same box” condition onto the ancilla:\n", + "$$\n", + "U_c = I_3 \\otimes \\Pi^{\\text{same}}_{01} + X_3 \\otimes \\Pi^{\\text{diff}}_{01} .\n", + "$$\n", + "This entangles the ancilla with the data pair: the ancilla is flipped if the two qubits are in different boxes, and left unchanged if they are the same.\n", + "At this point the ancilla *contains the answer*, but the system remains coherent because we have not measured it.\n", + "\n", + "##### 2️ Poke — apply a weak, signed rotation\n", + "Next we apply a small rotation around the \\(Y\\)-axis to the ancilla qubit\n", + "$$\n", + "R_y(\\varepsilon) = e^{-i\\frac{\\varepsilon}{2}Y} \\approx \\begin{bmatrix}\n", + "1 & -\\varepsilon/2 \\\\\n", + "\\varepsilon/2 & 1\n", + "\\end{bmatrix}.\n", + "$$\n", + "Because the ancilla’s logical state depends on whether the data qubits are the same or different, the direction of this small rotation is **opposite** in those two cases:\n", + "- For “same” pairs: the ancilla tilts by $+\\varepsilon/2$.\n", + "- For “different” pairs: the ancilla tilts by $-\\varepsilon/2$.\n", + "\n", + "This creates a *tiny, signed phase displacement* on the ancilla’s Bloch vector — a coherent “pointer deflection” that encodes the parity information.\n", + "\n", + "##### 3️ Uncompute — erase the question, keep the answer\n", + "Finally, we apply the inverse of the compute operation:\n", + "$$\n", + "U_c^\\dagger = I_3 \\otimes \\Pi^{\\text{same}}_{01} + X_3 \\otimes \\Pi^{\\text{diff}}_{01}.\n", + "$$\n", + "This step **removes the entanglement** between the ancilla and the data, restoring the system’s superposition and preserving the interference required for post-selection. \n", + "However, the ancilla keeps its small tilt, proportional to the *weak value*\n", + "$$\n", + "\\langle X_3\\rangle_{\\text{post}} \\approx \\varepsilon\\,\\mathrm{Re}\\!\\left(\n", + "\\frac{\\langle\\Phi|\\Pi^{\\text{diff}}_{01}|\\Psi\\rangle}{\\langle\\Phi|\\Psi\\rangle}\n", + "\\right).\n", + "$$\n", + "Thus, the ancilla retains a coherent, reversible record of the measurement result.\n", + "\n", + "##### 4️ Readout — use Hadamard to measure the pointer\n", + "The weak rotation leaves the ancilla tilted along the **X-axis** of the Bloch sphere.\n", + "Because quantum hardware measures in the **Z basis**, we apply a Hadamard gate before measurement:\n", + "\\[\n", + "H X H = Z.\n", + "\\]\n", + "This rotates the ancilla’s tilt into a measurable population bias.\n", + "A slight excess of 0’s or 1’s now reflects the **sign** of the weak pointer shift:\n", + "| Pair type | Ancilla tilt | Measured bias |\n", + "|------------|---------------|----------------|\n", + "| Same (00,11) | $+\\varepsilon$ | More 0’s |\n", + "| Different (01,10) | $-\\varepsilon$ | More 1’s |\n", + "\n", + "##### Summary\n", + "The ancilla acts as a *phase-sensitive probe*:\n", + "- **Compute:** entangle the observable \n", + "- **Poke:** apply a weak, signed rotation \n", + "- **Uncompute:** erase entanglement, keep pointer shift \n", + "- **Hadamard + measure:** read the tiny bias \n", + "\n", + "In this way, the probe “remembers” the correlation between the qubits through a reversible, analog phase displacement — not a projective measurement — preserving the interference that makes the quantum pigeonhole paradox observable.\n", + "\n", + "We first try this with the single pair measurement" + ] + }, + { + "cell_type": "markdown", + "id": "35e7f870", + "metadata": {}, + "source": [ + "### Weak Probe with single pair" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "1babb2de", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def compute_same(qc, a, b, t):\n", + " qc.cx(a,t); qc.cx(b,t);\n", + "\n", + "def uncompute_same(qc, a, b, t):\n", + " qc.cx(b,t); qc.cx(a,t)\n", + "\n", + "# --- Build the weak measurement circuit for given epsilon ---\n", + "def create_circuit_with_weak_prob(eps):\n", + " qc = QuantumCircuit(4, 4)\n", + " qc.h([0, 1, 2]) # preselection |+++>\n", + " qc.barrier()\n", + "\n", + " # compute → poke → uncompute\n", + " compute_same(qc, 0, 1, 3)\n", + " qc.ry(eps, 3)\n", + " uncompute_same(qc, 0, 1, 3)\n", + " qc.barrier()\n", + "\n", + " # rotate data qubits for postselection\n", + " for q in [0, 1, 2]:\n", + " qc.rz(np.pi / 2, q)\n", + " qc.h(q)\n", + " qc.barrier()\n", + "\n", + " # measure ancilla in X basis\n", + " qc.h(3)\n", + " qc.measure([0, 1, 2, 3], [0, 1, 2, 3])\n", + " return qc\n", + "\n", + "\n", + "qc_weak = create_circuit_with_weak_prob(0.1)\n", + "qc_weak.draw('mpl')" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "2245fa8b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bias towards diff: 0.0995405819295559 for : 12407 kept values\n" + ] + } + ], + "source": [ + "eps = 0.1 # we select a small value for the perturbation \n", + "shots = 100_000\n", + "qc_weak = create_circuit_with_weak_prob(eps)\n", + "result = backend.run(transpile(qc_weak, backend), shots=shots).result().get_counts()\n", + "kept = postselect_data_000(result)\n", + "N = sum(kept.values())\n", + "# ancilla bit is the *leftmost* bit (q3)\n", + "same = sum(ct for b, ct in kept.items() if b[0] == '0') # ancilla=0 → \"same\"\n", + "diff = sum(ct for b, ct in kept.items() if b[0] == '1') # ancilla=1 → \"different\"\n", + "bias = (diff - same)/N\n", + "print(\"Bias towards diff:\", bias, \" for :\", N, \" kept values\")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3c09cffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0995405819295559 > 0.023126636142477425\n" + ] + } + ], + "source": [ + "# doing some statistical analysis, \n", + "# we observe that our bias is more significant than the 1% threshold\n", + "print(bias, \">\" ,2.576/np.sqrt(N))" + ] + }, + { + "cell_type": "markdown", + "id": "4c243926", + "metadata": {}, + "source": [ + "### Weak Probe with three pairs" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "98a24404", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAPzCAYAAADoBNyLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAA8MtJREFUeJzs3Xd8FHX+x/H3bja9EZIAgdAChCZFQQQRKYKKiA1BPOTsnQNPTvQ8G56nIng2lLN7Ng4RFAUVVFSK0kHpoYRASIFAIIX03d8f/IggCWTD7kx25/V8PHiQ7Mx35jOT/c4mn898v2NzuVwuAQAAAAAAAAAAAD7GbnYAAAAAAAAAAAAAQG1Q6AIAAAAAAAAAAIBPotAFAAAAAAAAAAAAn0ShCwAAAAAAAAAAAD6JQhcAAAAAAAAAAAB8EoUuAAAAAAAAAAAA+CQKXQAAAAAAAAAAAPBJFLoAAAAAAAAAAADgkyh0AQAAAAAAAAAAwCdR6AIAAAAAAAAAAIBPotAFAAAAAAAAAAAAn0ShCwAAAAAAAAAAAD6JQhcAAAAAAAAAAAB8EoUuAAAAAAAAAAAA+CQKXQAAAAAAAAAAAPBJFLoAAAAAAAAAAADgkyh0AQAAAAAAAAAAwCdR6AIAAAAAAAAAAIBPotAFAAAAAAAAAAAAn0ShCwAAAAAAAAAAAD6JQhcAAAAAAAAAAAB8EoUuAAAAAAAAAAAA+CQKXQAAAAAAAAAAAPBJFLoAAAAAAAAAAADgkyh0AQAAAAAAAAAAwCdR6AIAAAAAAAAAAIBPotAFAAAAAAAAAAAAn0ShCwAAAAAAAAAAAD7JYXYAwJlYuXKlW+vn5ORo9uzZuuaaaxQXF1ejNueee25tQgMAAAAAAF5mRF5AIjeAus2dfkAfAOCPGNEFS8nJydFbb72lnJwcs0MBAAAAAAAGIy8Aq6MPAPBHFLoAAAAAAAAAAADgkyh0AQAAAAAAAAAAwCdR6AIAAAAAAAAAAIBPotAFS4mMjNSll16qyMhIs0MBAAAAAAAGIy8Aq6MPAPBHNpfL5TI7CKC2Vq5c6fV9nHvuuV7fBwAAAAAAcJ8ReQGJ3ADqNvJjAKyOEV2wlJKSEu3Zs0clJSVmhwIAAAAAAAxGXgBWRx8A4I8odMFSUlNTNWzYMKWmppodCgAAAAAAMBh5AVgdfQCAP3KYHQCq5nK5JF+6syI4WDabzewoAAAAAAAAfJ7LJRVXmB2Fe0ICJE+mhnwuNyaRH4NHuVwuVVT41oUgICCAPgBTUOiqq0pKVD7iRrOjqDHHJ/+VQkLMDgMAAAAAAMDnFVdIfb4yOwr3LL5MCvVkptHHcmMS+TF4VkVFhWbNmmV2GG4ZNmyYHA5KDjAeUxcCAAAAAAAAAADAJ1HoAgAAAAAAAAAAgE9iHCEspV27dlqxYoXZYQAAAAAAABOQF4DV0QcA+CNGdAEAAAAAAAAAAMAnUeiCpaSlpemWW25RWlqa2aEAAAAAAACDkReA1dEHAPgjCl2wlKKiIm3YsEFFRUVmhwIAAAAAAAxGXgBWRx8A4I8odAEAAAAAAAAAAMAnOcwOAAAAAAAAAMCZy1//o1Ie6X/Ca/aQcAU3TlZsv9FqcPlfZAsgHQgA8C98sgEAAAAAAAB+JObC6xXd7TLJ5VJZbpYO/Pi+0t+5X8Xpm9X83jfMDg8AAI+i0AVLSUhI0MSJE5WQkGB2KAAAAAAAwGBWyQuEJZ2j2H43VH4ff9k92nhPO+V8+5Ya3/AvBUbHmxgdzGSVPgDAWnhGFywlOjpagwcPVnR0tNmhAAAAAAAAg1k1LxAQEq7wtj0ll0slWTvMDgcmsmofgGccPnzY7BCAKjGiC5aSm5ur7777TgMHDlRMTIzZ4QAAAAAAAANZOS9wrMDliKhvciQwk5X7gFUdOHBAO3fu1M6dO5WZmamSkhLZ7XaFhoaqWbNmatmypZKSkhQeHn7K7axevVovv/yy7r77bvXs2dOg6IGaodAFS8nOztbkyZPVqVMnPswBAAAAALAYq+QFnCVHVJ6XI5fLpfLcLO3/5j8q2rlWYW16KKRJstnhwURW6QNWV1ZWphUrVmjBggXaunXradcPCAhQjx49dPHFF6tdu3ay2WwnLF+9erX+/e9/q6KiQi+//LLq16+v5GSuJag7LFHoysnJ0XPPPafZs2crPT1d8fHxuuaaa/T0009r7Nixeuedd/TKK69ozJgxZocKeM3+g0VKSctTcUmFYusFq3NyfdntttM3BOAXXC6X1m/LVU5usYIC7WrTPFoNY0PNDgsGKi4p128pucovLFN4qEOd2sQoPCzQ7LAAGCgtI19pGQVyuqTG8WFKbsGURQDgrzKnP67M6Y+f8Fq9Xteo2Z2vmhQRAKOsWLFC7777rnJzc2vcpqKiQr/88ot++eUXtWrVSnfddZeaNm0q6cQilyT16tVLrVq18krsQG35faFr3bp1Gjx4sLKyshQeHq4OHTooIyNDL7/8snbs2KGDBw9Kkrp27WpuoF7yU84+DfrlRz3bobPub9WuynWCvvxElzVI0Ofn9TE4Ohjh53XZeuXjTZr13S6VlTsrX2/VNFJ3DW+vW69JVkxUsIkRAvCmvIJSvft5iqZ9skVbd/0+l3ZAgE1XD2iue0d2UL9zeQixP0vLyNe0T7bo7c9SlJNbXPl6VESgbryije69rr3atqxnXoAAvMrpdGnOD2l6bcZmfbcs44RlPc6K1z3XtdfIwUkKDgowKUIAgDfEXXKHYs4fLldFmYrS1itr9iSV5qTLFhhSuU7+xsXa/uTgk9q6ykvlclao22cVRobsNeTGYBX5+fl699139fPPP5/wemJiorp166ZWrVqpWbNmCgsLkyQdOnRIqamp2rFjh5YtW6a8vDxJ0o4dO/TQQw/p2muvVWJiol588cXKIlfv3r11zz33KCCA3x1Rt/h1oSsnJ0dDhw5VVlaWxo8fr8cff1yRkZGSpOeee04PPvigHA6HbDabOnfubHK0gGe5XC5NnLZWE/+ztsrlO/bk64F/r9BrMzbr69cuJskJ+KHU9Hxdevd8paSd/LDYigqXPv12lz79dpceuKmTJv313JOmJoDv+/aXvRp2//fKLyw7aVleQZle+XiT3vh0i97/V1+NuCTJhAgBeFNxSbn+/I9FmrkgtcrlKzbs14oN+/X2Z1s15+VB3PwEAH4kOKGNoroOlCRFdxusiPYXaOvfL9DuaXcp6YH/SZIiO/bR2TMKTmhXeiBDW8Z3V/wQZj0CfElOTo6efvppZWT8fmNT165ddeWVV1Y5FaEkRUVFqVmzZurbt69Gjx6t5cuXa/bs2crIyFBFRYVmzJghm80ml8sliSIX6ja72QF409ixY5Wenq4xY8ZoypQplUUuSZowYYK6dOmi8vJytWjRQlFRUSZGCqOEhYXpvPPOq7xzwZ9Neue3aotcx0vdm6+Bd3yjvdmFBkQFwCj7DhTpotu/rrLI9UeT31uvR6euNiAqGOmXX7N1xdhvqyxyHa+k1KnrH/xR8xbtNigyAEZwOl268ZHqi1zHW7wmW0P/8q2KissNiAwAzGWlvMDxItqfr/r9Rit3yQwVbP65ynWcZSXa+ew1iuhwgRKGP2xwhDCKVfuAP8vNzdU///nPyiJXeHi47r33Xj344INq3759jW5qDQwM1AUXXKBnn31WV1xxReXrx4pc559/PkUu1Gl+W+javHmzZsyYobi4OD3zzDNVrtOtWzdJUpcuXU54PTU1VVdccYUiIyMVExOjP//5zzpw4IDXY4b3NWvWTK+88oqaNWtmdihelZaRr3+8UvOkdXp2oVvrA6j7npi2Rql782u8/r/e/FVbUg95LyAYyuVy6Y6JS1VcUrPpZpxOl+54cqnKypynXxmAT5i3aI8+mX/6ItcxS9dm641Pt3gxIgCoG6ySF6hKwnWPSvYAZXz8WJXLd792l5xlxWox7j1jA4OhrNwH/FFFRYWef/55ZWdnS5IaNWqkZ555Rn369KnVrC1BQUFq27at7PYTywYxMTEUuVCn+W2ha/r06XI6nRo1apQiIiKqXCc0NFTSiYWu/Px89e/fX+np6Zo+fbreeOMNLV68WJdffrmcTt9N/hypqFBOSUmV/6ykoqJCBQUFlfPK+qvXZ26V0+lyq83/vtl5wrNbAPiuvIJSfTB3u9vtps3Y7IVoYIYla7K1YXvNHzwsSRn7juiLH9O8FBEAo736v01ut3ltxpbKu3YBwF9ZJS9QlZCE1qrfZ6Tyf/te+RsXn7Bs35cv6/CquWr1989lD/bPkT7kxo6ych/wR3PnztX27Uf//o+Li9Ojjz6qBg0a1Hp7q1ev1r///e/KPPixYtlXX32lbdu2nXnAgJf4baFr4cKFkqT+/ftXu056erqkEwtdb7zxhvbu3avPP/9cl19+uYYPH66PP/5Yy5Yt0xdffOHdoL3oya0b1XjBnCr/Wcm2bds0YMAAv78wv/N5itttSkorNP3rHV6IBoDRPv12lwqOuD/91HtfbFNFhe/e1IHf1eZz4EzaAahb9mYXav7Pe91ul5J2WD+v2+eFiACg7rBKXqA6jYb/Q7LbTxjVlf/bD0p//0ElTZip4IYtzAvOy8iNHWX1PuBP9u7dq5kzZ0o6WpAaO3asYmNja729Y0WuY0XQ3r17a8SIEZKOzhoybdo0lZWdemp8wF0ul0uFhYUqLCw8o5vuHB6MqU5JSzt6R3Lz5s2rXF5eXq6lS5dKOrHQNXfuXF1wwQUnDN/t1auXkpKS9OWXX+qqq65yO5bu3bsrKyvLrTahdrs2de3l9r6qc1uzJA1r3LTKZYOX/XTG209OTlaRCSPerr32WrfW37fv6B/uX3/9tVavrtlUfVdffbXbcZnJpQBl1696GoLTefjx5zVpwgIPRwTAaHmh/aXQfu63KyhT0xZtZXcVeT4oGGp/5I1SYJLb7Rb8sFqJibd6ISIARipxJEpRt9eq7dBhNymsdL2HIwIA7zEiLyAZnxuwBYWq4YvuFyIiO/VTtznVJwpDm7ZXt89+H8lTkr1LOyePUOJNkxXZqV9tQq2UnNxGrlLP/S3ha7kxyTfyY77SB3B0GsHqHskjHc1jl5cfvcl1yJAhSk5OrvW+qipy3XPPPZKkVatWaceOHcrIyNDy5ct1wQUXVLud5ORklZaW1joOWI/T6VRmZqYkqWvXrlq7dm2ttuO3ha7CwkJJUlFR1R+wM2bMUE5OjiIjI9WyZcvK1zdt2qThw4eftH7Hjh21aZP7039IUlZWlvbude+OyrCAAKlrrXZXpdYREboovqHnNvgHGRkZOmLCkOdjP+eaOvZ+KCoqqnFbd392prM5pPq1a1pQUKiCLB87XgAna5gvhdauaWZmplTh3rUVdVDLMinQ/Wbl5RW+97kH4GRhIVJU7Zrm5uYq9xDXAQC+w4i8gGR8bsAeHCbvZXGOcpYc0Y5nrlJ0jyvUYMiYM95eRkaGnCVHPBDZUb6WG5N8Iz/mK30AUnBwcLXLCgoKKgdxhIaGul30P151Ra5jz+S64YYbNHHiREnSt99+e8pCV0ZGhkosNh0oPOfYs+Zqw28LXY0aNVJubq7WrFmjXr1OvPsjMzNTDzzwgCSpc+fOJzyYLzc3V/Xq1Ttpe/Xr19fWrVtrHYu7Qu2+Natk48aNTbljJTw83K31j32Ah4aG1rhtkyZN3I7LbBnOI3LZ3Z9TOyrcqUgfPF4AJyoMlg7Vop3NVaqERvVlUz0PRwSjHQwsVm3upQ0OKFIcnwOAzyu3Bytbklwuyc2HkMdFOxQcznUAgO8wIi8gGZ8bsAXV8s41N+T+PEtFqb+qeG+KcpfMOGl5x6mbFBTfrIqWVWvcuLHHR3T5Gl/Ij/lKH8DREV3VWbJkSeXIqb59+yokJKRW+zhdkUuS2rVrp8TERKWnp2vr1q3as2ePmjatenRk48aNGdEFtxw/oqthw9rfjOC3ha6BAwdq8+bNmjRpkgYNGlQ5dHPlypUaPXq0cnJyJB0dDudtq1atcruNq7hY5SNu9EI03pGSkiJbLS+oZ2LlypVurb9lyxZNnz5dgwcPVrt27WrU5sUXX6xFZOb663PL9OKHG91q4wiwafPP76lxA/f+SABQ9xw4VKzEQf9TcYl7dxLedm0nvfH4bi9FBSMt+Dldl9w13+12b02+RTdc/rQXIgJgtL43z9Oi1e5Nn968cYR2rF2kgADfSywCsC4j8gKS8bmBonKpz1fe3Uds/9GK7T/aY9tLSdmmUA9mGn0tNyb5Rn7MV/oAjj56Z9asWVUuO37msX79+tVq+zUpcklHn//Vv39/ffDBB5KkzZs3V1voSklJkcPhtyUHeEFhYaEiIiIkHS3g1pbf/gUzYcIExcbGas+ePerYsaM6deqkNm3aqEePHkpKStKAAQMknfh8LkmKiYnRoUOHTtrewYMHVb9+LeeDQ53RunVrzZ8/X61btzY7FK+6a3jNf1E55uqLWlDkAvxEbL0QXXeJ+89nuue69l6IBmYY2LOJWjWNdKtNbL1gXTuohXcCAmC42lzT77y2HUUuAH7PKnkBoDr0Af+Qmpoq6ej0hs2a1Xzk5TE1LXId06ZNm8qvd+7cWYuIAe/y279iEhMTtXjxYg0ZMkQhISHatWuX6tevr9dff13z5s1TSkqKpJMLXe3bt6/yWVybNm1S+/YkAH2dw+FQTEyM399Z0LZlPY3/81k1Xj+2XrD+9ZduXowIgNEm3nO2GsbWfLqTu4a3U9d2sV6MCEay222a+vfzFRBQ8ynLXnqwp0KC/fvzEbCSay5qoUG9Gtd4/U5tYnTvSP7eAeD/rJIXAKpDH/B9BQUF2r9/vySpRYsWsrs5zae7RS5Jat68eeXjf3bt2lW7wAEv8ttCl3S0aDV37lzl5+crPz9fy5cv1x133KHCwkLt2rVLdrtdZ511YjHg8ssv15IlS5Senl752vLly7Vjxw4NHTrU6EOAh6Wnp2v8+PEn/Hz91XP399DdI04/sqtB/RB9M+0StWkebUBUAIzSvHGkvn39UjVucPrn9d10ZRu98vdep10PvuXSCxL18bP9FBR46l/37HabXvvH+Ro1hDs6AX8SGGjXrH9fpIvOO32xq3NyfX0z7RJFRVT/HAgA8BdWygsAVaEP+L6CgoLKr+Pi4txqW5sil3R05Fh0dPRJ+wfqCkuW7jdu3CiXy6Xk5GSFhZ2YALzjjjv0yiuv6Morr9TEiRNVXFysCRMmqEePHrryyitNirj2+sY1UOnQEadc53TL/UlBQYEWL16s22+/3exQvM5ut+nVf5yvi89voqnTN+v75RknLI+tF6xbr07WX67vqMRGTFkI+KNOyfW1avqVmjp9k96avVX7DhafsPzCbo1078j2Gn5xy8o7s+BfRlySpLYtovXSRxs1/eudJz23beSlSRo3qqN6dmlgUoQAvCkyPEhfvXax3vksRdM+2aLfUg6esLxlk0jdPaKd7hzejiIXAMuwUl4AR5EbOxF9wPfVq1dPDzzwgMrKytx61I7T6dSnn37qdpHrmNtuu01Op1OhoTWfPQYwiiULXevXr5d08rSFkhQVFaWFCxdq3LhxGjlypBwOhy6//HK98MILbg8DBcxms9l01YAWumpAC6XsOqxeo7/QwcOliq0XrPRvRzJFFWABCfFh+tfY7nr87rO1eHW2hv/te+XmlapB/RD99O4Qs8ODAbq0jdU7T16oKePP0y+/Zmv0wz8pN69UjWJDNf25/maHB8DLggIDdNeI9rpzeDut3pSjS+78RgfzShVXL1jb5w2X3c6NDgAAAL4kJCRE3bq5/wgSu92uhx56SP/85z/VvHlzt4pcktS9e3e39wkYxZJZ7lMVuiSpVatWmjt3rpEhAV6X3CJaocEOSaUKCQqgyAVYTFBggC7q2VhhIQ7l5pUq0MHNG1ZTPzpYQy5sVvkecOf5XQB8n81mU/eO8QoNcUh5pQoOCqDIBQAAYDHR0dF64oknFBoa6laRC6jrLJnpPl2hCwAAAAAAAPBHuUs/Vd5v36vprS9o55SRKt6zSfagUDmiG6jZ3dMUksCzWwF/FhERYXYIgMdZstC1cOFCs0OASeLj4zVu3DjFx8ebHQoAAAAAADAYeQHp0LLPVL//nyVJ8Rffoahug2Wz2bRv3lSlTb1Nbf/1o7kBwqvoAwD8kSULXbCu2NhYjRo1yuwwAAAAAACACayQFygvOKRNY8+Ss7RIQXFN5SorUUnWTtXvN1rN756mgi1L1WLce7I5AhXd/bLKduHJPZX9+RQTI4cRrNAHAFgPD+iApeTl5em7775TXl6e2aEAAAAAAACDWSEv4Iiop/oX/kkNh96nDi+uU+KtLyq8bU+1+Mtbyl//g8LbnS+bI/CkdvvmvqR6Pa40IWIYyQp9AID1UOiCpWRkZOjhhx9WRkaG2aEAAAAAAACDWSUvcCR1nUKTzj769Y7VCvv/rw8t/1wxPa8+af3MmU+rJHO7mvz5GUPjhPGs0gcAWAuFLgAAAAAAAMCPFKWuqyxuHSt0uVwuHV47X1HnDD5h3azPpujQL7PV+rGvZQ8OMyNcAADOCIUuAAAAAAAAwE+UHtgryaag2CaSpKJdvym0eScdSVmh0MT2CgiNqFw3e86/lbt4uto8+a0cEfXMCRgAgDPkMDsAAAAAAAAAAJ5xZOfaytFckhQQXk/7vnpNjqg41TvvqsrXS3PSlf7OeAU1SlLKI/0lSTZHsNpPWW50yAAAnBEKXbCU4OBgtW3bVsHBwWaHAgAAAAAADGaFvEC9cy9XvXMvr/y+/fMrJUkbx3RUw6d+qHw9KC5R3ea4DI8P5rJCHwBgPRS6YCktW7bUBx98YHYYAAAAAADABFbOC3ScutHsEFAHWLkPAPBfPKMLAAAAAAAAAAAAPolCFyxl69at6t27t7Zu3Wp2KAAAAAAAwGDkBWB19AEA/ohCFyzF5XKprKxMLhdzUAMAAAAAYDXkBWB19AEA/ohndNVVwcFyfPJfs6OoOR5gCQAAAAAA4BEhAdLiy8yOwj0hAR7eoK/lxiTyY/CogIAADRs2zGPbm/z6DOUXFioyPFwP3HndSd97QkCApy8EQM1Q6KqjbDabFBJidhgAAAAAAAAwmM0mhVo8a0duDFZns9nkcHjuQuCS5HQd/d/hcJz0PeDLmLoQAAAAAAAAAAAAPolSLSylRYsWmj59upo0aWJ2KAAAAAAAwGDkBWB19AEA/ohCFywlJCRErVq1MjsMAAAAAABgAvICsDr6AAB/xNSFsJTMzEw99dRTyszMNDsUAAAAAABgMPICsDr6AAB/RKELlnL48GF98cUXOnz4sNmhAAAAAAAAg5EXgNXRBwD4IwpdAAAAAAAAAAAA8EkUugAAAAAAAAAAAOCTKHQBAAAAAAAAAADAJ1HogqXY7XadffbZstt56wMAAAAAYDXkBWB19AEA/ogrGizF6XRq7dq1cjqdZocCAAAAAAAMRl4AVkcfAOCPKHQBAAAAAAAAAADAJ1HoAgAAAAAAAAAAgE+i0AUAAAAAAAAAAACfRKELlhIZGalLL71UkZGRZocCAAAAAAAMRl4AVkcfAOCPHGYHABipSZMmevLJJ80OAwAAAAAAmIC8AKyOPgDAHzGiC5ZSUlKiPXv2qKSkxOxQAAAAAACAwcgLwOroAwD8EYUuWEpqaqqGDRum1NRUs0MBAAAAAAAGIy8Aq6MPAPBHFLoAAAAAAAAAAADgk3hGVx3lcrkkXxpCHBwsm81mdhQAAAAAAAA+z+WSiivMjsI9IQGSJ1NDPpcbk8iPAR7kcrlUUeFbF8KAgACuASah0FVXlZSofMSNZkdRY45P/iuFhJgdBgAAAAAAgM8rrpD6fGV2FO5ZfJkU6slMo4/lxiTyY4AnVVRUaNasWWaH4ZZhw4bJ4aDkYgamLgQAAAAAAAAAAIBPorwIS2nXrp1WrFhhdhgAAAAAAMAE5AVgdfQBAP6IEV0AAAAAAAAAAADwSRS6YClpaWm65ZZblJaWZnYoAAAAAADAYOQFYHX0AQD+iEIXLKWoqEgbNmxQUVGR2aEAAAAAAACDkReA1dEHAPgjCl0AAAAAAAAAAADwSRS6AAAAAAAAAAAA4JMcZgcAAAAAAAAA4Mzlr/9RKY/0P+E1e0i4ghsnK7bfaDW4/C+yBZAOBAD4Fz7ZYCkJCQmaOHGiEhISzA4FAAAAAAAYzCp5gZgLr1d0t8skl0tluVk68OP7Sn/nfhWnb1bze98wOzyYyCp9AIC1UOiCpURHR2vw4MFmhwEAAAAAAExglbxAWNI5iu13Q+X38Zfdo433tFPOt2+p8Q3/UmB0vInRwUxW6QMArIVndMFScnNzNXPmTOXm5podCgAAAAAAMJhV8wIBIeEKb9tTcrlUkrXD7HBgIqv2AaCwsFCbNm3SypUrtWzZMq1Zs0Z79+6V0+msUXuXy6WZM2dq2bJlXo4UtcGILlhKdna2Jk+erE6dOikmJsbscAAAAAAAgIGsnBc4VuByRNQ3ORKYycp9ANbicrmUkpKiH374QVu2bFFWVlaV64WEhKhly5Y699xz1bdvX4WHh1e5rU8++USfffaZ7PajY4d69uzp1fjhHkuM6MrJydGECRPUunVrhYSEqGnTpho3bpwKCwt16623ymazaerUqWaHCQAAAAAAAJwxZ8kRleflqOzwfhXtWq/d/7lXRTvXKqxND4U0STY7PADwGpfLpZ9//lkPPfSQHn/8cf3444/VFrkkqbi4WJs3b9b777+ve+65R2+88YYOHTp0wvaOFbkkyel0nrAcdYPfj+hat26dBg8erKysLIWHh6tDhw7KyMjQyy+/rB07dujgwYOSpK5du5obqJf8lLNPg375Uc926Kz7W7Wrcp2gLz/RZQ0S9Pl5fQyODjDGrr35ev3TLZq3aI8O5ZcqLMSh7h3jdM917dWrSwPZbDazQ4QXuVwurdyQo9dmbNby9ftUWFSu6IggXdo7UXeNaKdWTaPMDhFeVl7u1NxFu/XmrK1KSctTWblTDeqHaOSlSbrpymTVjw42O0QAAACv2r47T//5ZLPm/7xXhwtKFR7qUM/ODXTPde117lk8q8kfZU5/XJnTHz/htXq9rlGzO181KSLzkBsDrOPQoUN6++23tXLlyhNeDwwMVIsWLdSyZUvFxsbKbreruLhYu3fvVmpqqnJyciRJJSUlWrhwoVasWKGbbrpJ559/vmbOnFlZ5JKkm266SZdeeqmhx4XT8+tCV05OjoYOHaqsrCyNHz9ejz/+uCIjIyVJzz33nB588EE5HA7ZbDZ17tzZ5GgBeFpxSbnufupn/feLbXK5Tly2dddhfTRvh7p1iNPMKQPUMjHSnCDhVelZhbpuwkL9vG7fCa/vUaE2bM/VlP+u18hLk/T2xD4KC/Xrj0TLWrImS3966EftySo84fW0jAKt3JCjf7yyWo/c3lUP396FojcAAPA7hUfKdOsTizXjm9STlm1JPaz35mxT77Mb6pPJ/dW4wclTNcF3xV1yh2LOHy5XRZmK0tYra/YkleakyxYYUrlO/sbF2v7k4JPauspL5XJWqNtnFUaGDABnZOvWrZoyZYry8/MrX2vVqpUuueQS9ezZU0FBQdW2TU9P17fffqtFixapqKhIBQUFmjp1qubMmaM9e/ZUrkeRq+7y66ze2LFjlZ6erjFjxmjKlCknLJswYYI+/vhj/frrr2rZsqWiorij3wrCwsJ03nnnKSwszOxQ4GWlZRUa+pdv9d2yjFOut3pTjnqN/lI/f3C5khK5DviT9KxCnf/nL08qcPzR/77ZqfTsQi14/VKFhvj1x6LlLFyeocvuna+S0uofLFtcUqFHpq7WgcPF+vcDzK8NAAD8R1FxuS6+65uTbvr6o6Vrs4/+TfT+UDVp6P/FLqvkBYIT2iiq60BJUnS3wYpof4G2/v0C7Z52l5Ie+J8kKbJjH509o+CEdqUHMrRlfHfFDxljeMwwhlX6AKxl48aNmjRpkkpLSyVJUVFRuuWWW2r8HK3ExETdfPPNGjZsmN5991398ssvkkSRy4f47TO6Nm/erBkzZiguLk7PPPNMlet069ZNktSlS5fK144Vxnr06KHg4GDu7vYzzZo10yuvvKJmzZqZHQq87JFXVp+2yHVM9oEiXTXuOzmdrtOvDJ/gcrk0/G/fn7bIdcyStdkaP2W5l6OCkXJyi3X1X787ZZHreC98sFH/+3qHl6MCAAAwzv2Tl5+2yHXM7sxCjXhgoVx/nArDD1k1LxDR/nzV7zdauUtmqGDzz1Wu4ywr0c5nr1FEhwuUMPxhgyOEUazaB+C/0tLSNHny5MoiV6dOnTRlypQaF7mOFxUVpbFjx+rcc8894fVWrVpR5Krj/LbQNX36dDmdTo0aNUoRERFVrhMaGirpxELX9u3bNWvWLDVq1OikN7QvO1JRoZySkir/WUlFRYUKCgpUUcHwe39WcKRMr3+6xa0267flauGKmhXGUPct+22flv223602787Zptw8a10T/dk7n6Uor6DMrTYvfLDRS9EAAAAY68ChYr33xTa32vy8bp9WbsjxUkR1h5XzAgnXPSrZA5Tx8WNVLt/92l1ylhWrxbj3jA3MIOTGjrJyH4D/KS8v12uvvabi4mJJ0jnnnKMJEybUevY2l8ulTz755KRnfO3YsaNylBfqJr8tdC1cuFCS1L9//2rXSU9Pl3RioevCCy9UZmamvvjiCw0cONC7QRroya0b1XjBnCr/Wcm2bds0YMAAbdvm3i/88C0ff7XD7QS3JL02Y7MXooEZavOzLC6p0HtzuDb4A6fTpf/MdK/YLUkrNuzXqo3uFUgBAADqovfmbFNxiftJ7Ff/t8kL0dQtVs4LhCS0Vv0+I5X/2/fK37j4hGX7vnxZh1fNVau/fy57sH9OaUdu7Cgr9wH4n88//1xpaWmSjo5WvO+++xQYGFirbR0rcn322WeVr1144YWVX7/zzjs6fPjwmQUMr/Hbh5Ece4M3b968yuXl5eVaunSppBMLXXa752t/3bt3V1ZWllttQu12beray2Mx3NYsScMaN61y2eBlP53x9pOTk1XkrNn0UJ507bXXurX+vn1Hp234+uuvtXr16hq1ufrqq92Oq67KrHe/ZI9WZlamEhMTzQ7Ha3LDr5KCz3a73Zxv1ysx8SaPxwPjZUWPlQJi3W73j6fe1vN/n+mFiOoOK1wHKmwRyop5oFZtB15xpyJKVng4orrFCu8BANXjGgBYw4GIEVJQR7fbffz5Mn3/31FeiMh7jMgLSMbnBmxBoWr4oucLEY2G/0MHF09XxsePqe2/fpAk5f/2g9Lff1BtHvtawQ1b1Hrbyclt5Cot8lCkvpcbk3wjP+YrfQCed/XN9yk8Iqry98A/fl/XBAUFVftIIkk6dOhQZVHKbrfr7rvvVlBQUK32VVWR66abbtIll1yi4uJirVixQvn5+Zo9e7ZuvvnmareTnJxcOYUiasZ53DXzggsu0Nq1a2u1Hb8tdBUWHn0uS1FR1R+wM2bMUE5OjiIjI9WyZUuvxpKVlaW9e/e61SYsIEDq6rkYWkdE6KL4hp7b4B9kZGToiAlDno/9nGvq2PuhqKioxm3d/dnVaZEVkl1yVlT413H9UdNyKdj9Zk5XkH+fFyuJDJAC3G9WVOL0//eAFa4DQQ2kmNo1PZxfrMP7/fS8HGOF9wCA6nENAKyhhVOqRa6v3Bngc9cGI/ICkvG5AXtwmGqTxYns1E/d5lT/rLXQpu3V7bPf8zcl2bu0c/IIJd40WZGd+tVij7/LyMiQs+TIGW3jeL6WG5N8Iz/mK30Anuf8//fmsd8D//h9XRMcfOrk3sKFCyun4Bw8eHCtc/zVFbmOPZPrlltu0a+//qqSkhItWrRI119/vUJCQqrcVkZGhkosNh2qJ2VnZ9e6rd8Wuho1aqTc3FytWbNGvXqdePdHZmamHnjg6J3enTt3ls1m83os7gr1wsgyb2rcuLEpd6yEh4e7tf6xD/DQ0NAat23SpInbcdVVmQEBckqyBwQowY+O649yQ+yqza/WdluJX58XK8m2l6u8Fu1Cg22q7+fvAStcByps4cqSJJdLcvMzPjoyWBFB/nlejrHCewBA9bgGANZwMMim2oyrcdjL1dDHrg1G5AUk43MDtqBQr+/DWXJEO565StE9rlCDIWPOeHuNGzf2+IguX+ML+TFf6QPwPHtAQOX/TZo0Oen7uuZUo7MqKir03XffSZJsNltlUcpdpytySVK9evXUu3dvLVy4UEVFRVq8eLEGDRpU5fYaN27MiC43OZ1OZWZmSpIaNqz9zQh+W+gaOHCgNm/erEmTJmnQoEFKTk6WJK1cuVKjR49WTs7RB6x27drV67GsWrXK7Tau4mKVj7jRC9F4R0pKimzVVLK96Y8PBjydLVu2aPr06Ro8eLDatWtXozYvvvhiLSKrmxIHTtfefUeU0ChB6RvSzQ7Ha2Z8s1MjJ/zgdrsbr+mud5703/NiJWOe/lmv/s/953S9Ouke3XzVi54PqA6xwnXA5XKp6/DP9VvKQbfbrlz4nto0j/ZCVHWHFd4DAKrHNQCwhrdmbdXtE5e43e6e0X310kMPeSEi7zEiLyAZnxsoKpf6fOXdfeT+PEtFqb+qeG+KcpfMOGl5x6mbFBTfrMbbS0nZplAPZhp9LTcm+UZ+zFf6ADzv6Vc/Ul5B4dHfA9PTT/q+rikvL9esWbOqXLZz504dPHj0b/6zzz5b8fHxbm+/JkWuYwYNGqSFCxdKOprrr67QlZKSIofDb0suXlFYWKiIiAhJ0pIl7v/ucozv3RpRQxMmTFBsbKz27Nmjjh07qlOnTmrTpo169OihpKQkDRgwQNKJz+eC/2vdurXmz5+v1q1bmx0KvOjqi5qrUZz7d7/dc117L0QDM9TmZxkTFaTrLknyQjQwms1m070j3X8PXHx+E78vcgEAAGv402WtFB3p/tyFVvibiLzA72L7j1a3OS6dM/OIzp5RcNI/d4pc8B30AfiD1NTUyq87d+7sdnt3ilyS1KJFC0VGRko6WmRzuaqfIhbm8NtCV2JiohYvXqwhQ4YoJCREu3btUv369fX6669r3rx5SklJkUShy2ocDodiYmKorPu5oMAAPXBTJ7faDOzZWN07un/3B+qmDq1idNWA5m61ue+GsxTmydsPYao/XdZKzRJqPg2HzSZNuMn9X44BAADqorBQh/56Q0e32lxzUQu1bVnPOwHVIeQFYHX0AfiDnTt3Vn6dlOTeTcvuFrmkozfUHttPfn6+Dhw44GbE8Da/LXRJUvv27TV37lzl5+crPz9fy5cv1x133KHCwkLt2rVLdrtdZ511ltlhwkDp6ekaP358nRyOC8/66+izdPuwtjVat1ObGM2YPMDLEcFo/33qQnXvGFejdUcNaaVH7ujq3YBgqIiwQH316iWKj6nZtCFT/95LF/Vs7OWoAAAAjPPonWfr+sE1S/71OCte7z3Vx8sR1Q3kBWB19AH4g3379lV+3bRp0xq3q02R65jExMTKr7Ozs2u8TxjDkqX7jRs3yuVyKTk5WWFhYSct//TTTyVJmzZtOuH7Fi1aqHv37sYF6gF94xqodOiIU65zuuX+pKCgQIsXL9btt99udijwMpvNptcf662kxEhNfm+9Dh4uOWkdR4BNIy5J0mv/OL9W03qgbouKCNIPb1+msc/+oo/m7VBp2ckPBI6ODNJ9ozrqsbvOlt1uMyFKeFPH1jH65cOhuv2JJfphZWaV67RoHKHn7u+h4Re3NDg6AAAA77LbbfrwmX5q0yxaL360QXkFZSetExRo1w2Xt9bLD/ZUeFigCVEaj7yA9ZAbOxF9AP6gbdu2Cg0NVWlpqYKDg2vcbv78+bUqcklSs2bN1LVrVwUGBlY+Uwp1hyULXevXr5dU/bSFw4cPr/L7G2+8Ue+9955XYwPgOTabTQ/d2kXjRnXUJ/NTNXfRbn35426VlDkVGR6orV9cq4T4k4vd8B8RYYF658kL9ey4c/X2Zyl68j9rVVxaoZDgAL3yUC9dPzjJMn/QW1WrplFa+PZl2rzzkN6ctUWvzdisklKnQoMDNPP5Abq0d6ICAvx6gDsAALAwu92mifeeowk3d9LHX+3QN0v3at6io38TRYUHavu84Yqv7/7zjQEAMNN1111Xq3a9evXSd999p/T0dLeKXJLUt29f9e3bt1b7hfdZMrNzukKXy+Wq8h9FLsA3hYY4dOOVbTTz+YsU9//TmEWFB1LkspAGsaH6+21dFFvv6F0+sdHBum1YW4pcFtI+qZ7+/UBPxdU7eg2oHx2sIRc2o8gFAAAsITwsULdf206zXvj9b6LI8ECKXAAAS4mOjtajjz6qe++9160iF+o+RnQBAAAAAAAAFpG79FPl/fa9mt76gnZOGaniPZtkDwqVI7qBmt09TSEJrc0OEQC8Jjo6Wn36WOO5lFZiyULXwoULzQ4BJomPj9e4ceMUHx9vdigAAAAAAMBg5AWkQ8s+U/3+f5YkxV98h6K6DZbNZtO+eVOVNvU2tf3Xj+YGCK+iDwDwR5YsdMG6YmNjNWrUKLPDAAAAAAAAJrBCXqC84JA2jT1LztIiBcU1lausRCVZO1W/32g1v3uaCrYsVYtx78nmCFR098sq24Un91T251NMjBxGsEIfAGA9PJgClpKXl6fvvvtOeXl5ZocCAAAAAAAMZoW8gCOinupf+Cc1HHqfOry4Tom3vqjwtj3V4i9vKX/9Dwpvd75sjpOfV7xv7kuq1+NKEyKGkazQBwBYD4UuWEpGRoYefvhhZWRkmB0KAAAAAAAwmFXyAkdS1yk06eyjX+9YrbD///rQ8s8V0/Pqk9bPnPm0SjK3q8mfnzE0ThjPKn0AgLVQ6AIAAAAAAAD8SFHqusri1rFCl8vl0uG18xV1zuAT1s36bIoO/TJbrR/7WvbgMDPCBQDgjFDoAgAAAAAAAPxE6YG9kmwKim0iSSra9ZtCm3fSkZQVCk1sr4DQiMp1s+f8W7mLp6vNk9/KEVHPnIABADhDDrMDAAAAAAAAAOAZR3aurRzNJUkB4fW076vX5IiKU73zrqp8vTQnXenvjFdQoySlPNJfkmRzBKv9lOVGhwwAwBmh0AVLCQ4OVtu2bRUcHGx2KAAAAAAAwGBWyAvUO/dy1Tv38srv2z+/UpK0cUxHNXzqh8rXg+IS1W2Oy/D4YC4r9AEA1kOhC5bSsmVLffDBB2aHAQAAAAAATGDlvEDHqRvNDgF1gJX7AAD/xTO6AAAAAAAAAAAA4JModMFStm7dqt69e2vr1q1mhwIAAAAAAAxGXgBWRx8A4I8odMFSXC6XysrK5HIxBzUAAAAAAFZDXgBWRx8A4I94RlddFRwsxyf/NTuKmuMBlgAAAAAAAB4REiAtvszsKNwTEuDhDfpabkwiPwZ4UEBAgIYNG+ax7U1+fYbyCwsVGR6uB+687qTvPSEgwNMXQtQUha46ymazSSEhZocBAAAAAAAAg9lsUqjFs3bkxgBrs9lscjg8dyF0SXK6jv7vcDhO+h6+jakLAQAAAAAAAAAA4JMoVcJSWrRooenTp6tJkyZmhwIAAAAAAAxGXgBWRx8A4I8odMFSQkJC1KpVK7PDAAAAAAAAJiAvAKujDwDwR0xdCEvJzMzUU089pczMTLNDAQAAAAAABiMvAKujDwDwRxS6YCmHDx/WF198ocOHD5sdCgAAAAAAMBh5AVgdfQCAP6LQBQAAAAAAAAAAAJ9EoQsAAAAAAAAAAAA+iUIXAAAAAAAAAAAAfBKFLlhK/fr1deONN6p+/fpmhwIAAAAAAAxGXgBWRx8A4I8odMFS7Ha7AgMDZbfz1gcAAAAAwGrIC8Dq6AMA/BFXNFhKTk6O3nrrLeXk5JgdCgAAAAAAMBh5AVgdfQCAP6LQBQAAAAAAAAAAAJ9EoQsAAAAAAAAAAAA+iUIXAAAAAAAAAAAAfBKFLlhKZGSkLr30UkVGRpodCgAAAAAAMBh5AVgdfQCAP3KYHQBgpCZNmujJJ580OwwAAAAAAGAC8gKwOvoAAH/EiC5YSklJifbs2aOSkhKzQwEAAAAAAAYjLwCrow8A8EcUumApqampGjZsmFJTU80OBQAAAAAAGIy8AKyOPgDAHzF1YR3lcrkkX7qzIjhYNpvN7CgAAAAAAAB8nsslFVeYHYV7QgIkT6aGfC43JpEfA+BRLpdLFRW+9WEQEBBgynWQQlddVVKi8hE3mh1FjTk++a8UEmJ2GAAAAAAAAD6vuELq85XZUbhn8WVSqCczjT6WG5PIjwHwrIqKCs2aNcvsMNwybNgwORzGl52YuhAAAAAAAAAAAAA+iUIXAAAAAAAAAAAAfBJTF8JS2rVrpxUrVpgdBgAAAAAAMAF5AVgdfQCAP2JEFwAAAAAAAAAAAHwShS5YSlpamm655RalpaWZHQoAAAAAADAYeQFYHX0AgD+i0AVLKSoq0oYNG1RUVGR2KAAAAAAAwGDkBWB19AEA/ohCFwAAAAAAAAAAAHySw+wAAAAAAAAAAJy5/PU/KuWR/ie8Zg8JV3DjZMX2G60Gl/9FtgDSgQAA/8InGwAAAAAAAOBHYi68XtHdLpNcLpXlZunAj+8r/Z37VZy+Wc3vfcPs8AAA8CgKXbCUhIQETZw4UQkJCWaHAgAAAAAADGaVvEBY0jmK7XdD5ffxl92jjfe0U863b6nxDf9SYHS8idHBTFbpAwCshWd0wVKio6M1ePBgRUdHmx0KAAAAAAAwmFXzAgEh4Qpv21NyuVSStcPscGAiq/YBAGeutLRUGzduNDuMKjGiC5aSm5ur7777TgMHDlRMTIzZ4QAAAAAAAANZOS9wrMDliKhvciQwk5X7AGBFOTk5WrdunXbu3KnU1FTl5OSorKxMAQEBioqKUsuWLdWyZUt17NhRSUlJ1W6ntLRUzz//vNavX6+xY8eqZ8+eBh7F6VHogqVkZ2dr8uTJ6tSpEx/mAAAAAABYjFXyAs6SIyrPy5HL5VJ5bpb2f/MfFe1cq7A2PRTSJNns8GAiq/QBwMpcLpfWr1+vBQsWaPXq1XK5XFWuV1hYqMzMTP3888+SpKSkJA0aNEi9e/dWUFBQ5XrHily//vqrJOnNN99Up06dFB4e7v2DqSFLFLpycnL03HPPafbs2UpPT1d8fLyuueYaPf300xo7dqzeeecdvfLKKxozZozZoXrcTzn7NOiXH/Vsh866v1W7KtcJ+vITXdYgQZ+f18fg6AAAAIyRm1eiWd/uUsb+Iwqw29SySaSuGtBcYaGW+HUYknbsydPcn3YrN69UoSEB6to2VoN6NZHdbjM7NBjA5XLpl1/3aenabBUWlSsyPFADezZWl7axZocGg5SVOTVv8W5t3nlYpWUVio8J0VUDmqtxg7qToAE8KXP648qc/vgJr9XrdY2a3fmqSRGZh9wYACs5cOCA3nzzTa1bt+6kZTabTXFxcQoKClJFRYUOHDigsrKyyuU7d+7U66+/rjlz5uiuu+5Su3btTipyhYSE6IEHHqhTRS7JAoWudevWafDgwcrKylJ4eLg6dOigjIwMvfzyy9qxY4cOHjwoSeratau5gQIAAMDj0jLy9eTr6zT96x0qKq44YVlMVJBuvipZj9zRVTFRwSZFCG9bujZbT72xTt8sTT9pWaumkRozsoP+8qcOCgjg8cX+yOVy6cO52/X8+xv069aDJy3vfXZDPXhzZw3t18yE6GCEktIKTXrnN73+6RZl7DtywrKxk5bp6gHN9eidZ6tzMlO5wb/EXXKHYs4fLldFmYrS1itr9iSV5qTLFhhSuU7+xsXa/uTgk9q6ykvlclao22cVJy0DANRdS5Ys0TvvvKMjR37/nScmJkYDBgxQp06d1KJFC4WE/P45UF5err1792rr1q364YcflJqaKknKysrSxIkTdfHFFyszM1O//fabpKNFroceekjt2lV904CZ/LrQlZOTo6FDhyorK0vjx4/X448/rsjISEnSc889pwcffFAOh0M2m02dO3c2OVoAAAB40q9bD+iSu+Yr+0BRlctz80r17/c36Osl6fr29UvVpGHduiMNZ276Vzv053/8pPKKqqfq2LEnX3+dvFyL1mTpf8/1V1BggMERwptcLpfum7RML3+8qdp1lq7N1hVrv9Wz93XXg7d0MTA6GCG/sFSXj/lWi1ZnVbm8osKlT7/dpa+XpOuzFwdqUK8mBkcIeE9wQhtFdR0oSYruNlgR7S/Q1r9foN3T7lLSA/+TJEV27KOzZxSc0K70QIa2jO+u+CH+N+sRAPizuXPn6sMPP6z8PiYmRqNHj1aPHj3kcFRdBnI4HGrevLmaN2+uQYMGafv27Xr//fe1bds2uVwuzZ8/v3LdulzkkiS/vm1x7NixSk9P15gxYzRlypTKIpckTZgwQV26dFF5eblatGihqKgoEyOFUcLCwnTeeecpLCzM7FAAAIAXZewr1OB7FlRb5Dre5p2HNGTMAh0pKjcgMhjl+2UZGn2KItfxPvs+TXc/9bMBUcFIT7/56ymLXMd76MVVem9OipcjgpFcLpdG/O2HaotcxyssKtfV932nX7ceMCAymM2qeYGI9uerfr/Ryl0yQwWbq/7Mc5aVaOez1yiiwwVKGP6wwRHCKFbtA4A/mz9//glFrj59+mjy5Mk6//zzqy1y/ZHNZlObNm00ceJE/elPf5LN9vsU73a7XRMmTKizRS7Jjwtdmzdv1owZMxQXF6dnnnmmynW6desmSerS5fc79z799FMNGzZMzZs3V1hYmNq1a6d//OMfKigoqHIbvuJIRYVySkqq/GclzZo10yuvvKJmzZiaBAAAf/bCBxuVuf/I6Vf8f79uPaiPv9rhxYhgtH+8skoVNShyHfPOZynaknrIewHBUIfySvSvt9a51ebhl1errMzpnYBguB9WZFY5ZWl1CovK9c/X13kvINQZVs4LJFz3qGQPUMbHj1W5fPdrd8lZVqwW494zNjCDkBs7ysp9APBH27Zt03vvvVf5/YgRI3TPPfcoIiKiVtsrLy/Xxo0b5XL9/reU0+nU9u3bzzRUr/LbqQunT58up9OpUaNGVftDDQ0NlXRioWvKlClq1qyZnn76aSUmJmrdunWaOHGifvrpJy1atEh2u2/WBp/culFPbt1odhimq6ioUFFRkUJDQxUQwNQ0AAD4o6Licr3zufsjM16dsUm3XpN8wp1r8E2rN+Vo+fr9brebNmOzXnqolxcigtH++8W2k57LdzqZ+49ozg9puvbill6KCkZ6bcZmt9t8/kOa9mYXMpWtn7NyXiAkobXq9xmpgz99pPyNixXZsU/lsn1fvqzDq+aq3ZSVsgf750gfcmNHWbkPAP6mtLRU//nPfyqLUkOHDtU111xzRtt7/vnn9euvv0qSgoKCVFpaKkmaOXOmunXrpiZN6uZUz75ZtamBhQsXSpL69+9f7Trp6Ufv7jq+0PXll1/qk08+0ahRo9S3b1+NGzdOU6dO1dKlS7VkyRLvBu1FtzVL0tc9+1b5z0q2bdumAQMGaNu2bWaHAgAAvGThigwdPOz+nbnrthzU9t15XogIRpu5ILVW7WbMr1071D2f1Po9sNPDkcAMJaUV+vyHNLfbVVS4NPv7XZ4PCHWK1fMCjYb/Q7LbTxjVlf/bD0p//0ElTZip4IYtzAvOy8iNHWX1PgD4kzlz5mjv3r2SpKSkJI0cObLW2/pjkSskJEQPP/ywhgwZIkkqKyvTG2+8ccJIr7rEb0d0paUd/aW2efPmVS4vLy/X0qVLJZ1Y6IqPjz9p3e7du0tS5ZvGXd27d1dW1unnBT9eqN2uTV09dzdp64gIXRTf0GPb+6Pk5GQVOY2f5uPaa691a/19+/ZJkr7++mutXr26Rm2uvvpqt+OqqzLr3S/Zo5WZlanExESzwzEF58Da+PlzDqx+/JI1zkFhUFcponaf3+f3vUTB5TWf6gp1U274lVLwOW63y84pUJPERPnzmD4rXAMkKSt6rBQQ63a7L776QYkzbvRCRDBShS1CFTEP1KrtPx5/VpMm/ODhiOoWf7sOGJEXkIzPDdiCQtXwRfcLEZGd+qnbnOqTkKFN26vbZ7+PeC3J3qWdk0co8abJiuzUrzahVkpObiNX6emfj1pTvpYbk3wjP+YrfQCed/XN9yk8Iqry+v/H7/2dLx5/UFBQtY9lKi0t1YIFCyRJAQEBuvvuu2s9SrOqItdDDz2kdu3aKSkpSatXr1ZWVpa2bt2qHTt2qHXr1tVuKzk5uXIUWE04j7tmXnDBBVq7dm2tjsFvC12FhYWSpKKiqj9gZ8yYoZycHEVGRqply1NPTfHDD0d/yW3fvn2tYsnKynK7SBYWECB1rdXuTJGRkaEjFe5NDeIJx37ONXXs/VBUVFTjtrUtcNZJkRWSXXJWVPjXcbmDc2Bt/Pw5B1Y/fska5yC6iVS76ciVk50lFfvpebGSxnlScC3aucqV4a/94hgrXAMkKaxYqsXf+aXFhf59XqwiIFyKqV3T/MO5yt/v5+8BP7sOGJEXkIzPDdiDw+TdkozkLDmiHc9cpegeV6jBkDFnvL2MjAw5S2r+jNTT8bXcmOQb+TFf6QPwPOf/vzePXf//+L2/88XjDw6u/o+aZcuWKT8/X5LUs2dPNW3atFb7OFWRSzpabLvyyiv1+uuvS5IWLFhwykJXRkaGSmr57MPs7OxatZP8uNDVqFEj5ebmas2aNerV68S7PzIzM/XAA0fv7urcufMpn8Owd+9ePfroo7r00kvVtWvXWsfirlAfexZY48aNTbljJTzcvbnTj32Ah4aG1rhtXZ13tDYyAwLklGQPCFCCHx2XOzgH1sbPn3Ng9eOXrHEOSgOc2i9JLpfkzvO2XBVqFBeoAJd/nhcrKQgu0uFatAt0HlQDP+0Xx1jhGiBJB+yHVSz3jy88sED1/Pi8WIVLNmU58+W0R7rdtn54qUKD/Ps94G/XASPyApLxuQFbUKjX95H78ywVpf6q4r0pyl0y46TlHaduUlB8sxpvr3Hjxh4f0eVrfCE/5it9AJ5n///RPvaAADVp0uSk7/2dLx5/UFBQtct++umnyq8vvvjiWm3/dEWuY84//3x9+OGHKiws1C+//KJbb7212iJc48aN3R7RlZmZKUlq2LD2t3j4baFr4MCB2rx5syZNmqRBgwYpOTlZkrRy5UqNHj1aOTk5knTK4lVBQYGuvPJKBQUF6Z133ql1LKtWrXK7jau4WOUjfGfKjJSUFNlCQgzf78qVK91af8uWLZo+fboGDx58UoetzosvvliLyOqmxIHTtXffESU0SlD6BmtOy8Q5sDZ+/pwDqx+/ZI1z4HK5dO71X2j1phy32v1pSLI+epZnFfiDA4eKlTjofyouce+O6pefGKa7RjzipajqBitcAyRpwc/puuSu+W63WzZvks5q86YXIoLRHp26Wk+9sc6tNg1jQ7V79dcKCqzdtD++wt+uA0bkBSTjcwNF5VKfr7y7j9j+oxXbf7THtpeSsk2hHsw0+lpuTPKN/Jiv9AF43tOvfqS8gsKj1//09JO+93e+ePzl5eWaNWvWSa87nU5t375dkhQbG1tZ+3BHTYtc0tGRZd27d9dPP/2ksrIypaWlVbvPlJQUORw1/zAoLCxURMTRKVmWLFni9nEc43u3RtTQhAkTFBsbqz179qhjx47q1KmT2rRpox49eigpKUkDBgyQdOLzuY5XVFSkoUOHKjU1VQsWLFBCQoKR4cNLWrdurfnz559yeCUAAPBtNptN9450f8rpe66r3TTVqHti64Xo+sFJbrWJigjUqCGtvBQRjDawZxO1aR7lVpu+3RvprDb1vRQRjHbHtW0VEODeE/duH9bW74tcIC8A0AcA35eZmVk5PWCrVq1OOWNdVdwpch3TqtXvfyvt3LmzFlF7l98WuhITE7V48WINGTJEISEh2rVrl+rXr6/XX39d8+bNU0pKiqSqC11lZWW69tprtWrVKn399dfq0KGD0eHDSxwOh2JiYtyqKgMAAN9z4xVtdO2gFjVe/++3dlHvs739JAwYafL9PdS2RXSN1rXbbfrw6X6KDK9+ahD4Frvdpo+f7afwGg4tiI8J0dsT+3g5KhipaaMITfvH+TVev1eXBnr4tqpvhIV/IS8Aq6MPAL5vz549lV+3bNnSrba1KXL9cT+7d+92a59G8NtClyS1b99ec+fOVX5+vvLz87V8+XLdcccdKiws1K5du2S323XWWWed0MbpdGrUqFH6/vvvNWfOHPXo0cOk6D2jb1wDlQ4doftbVf9GLR06Qp+fZ40/6tLT0zV+/Pg6OxwVAAB4ht1u00fP9tPoy09/p+pjd56tf43tZkBUMFJsvRD98PZlOqd97CnXCw0O0OwXLtLQfjV/Bgl8Q/eO8fr2jUsVF3PqKaRaNI7QT+8OUaum7o0AQ913+7Xt9MZjvU87suui8xrr69cuUWgISV8rIC9gPeTGTkQfAHzfkSNHKr+Oiqr577C1LXL9cT/FxcVuRGsMS/4Wt3HjRrlcLiUnJyssLOyEZffee69mzpyphx56SGFhYVq2bFnlslatWik+Pt7ocOFBBQUFWrx4sW6//XazQwEAAF4WFBig//7rQt1zXXu9NmOzZszfqdKyow8Ht9mkMdd30N0j2qt9Uj1zA4XXJMSHaflHV+iLH3frtRmb9f3yjMplAXab/jmmm269OlkNYkNNjBLe1KtLQ+2YN1wfzN2u12Zs1qYdhyqXnXtWnO69roNGXNKSAocfu/3adrqkd6Le+HSL3py1VfsO/p6YubJ/M91zXXsN7NlEdrt7U/7Ad5EXgNXRBwDfd+GFF6pHjx4qKytTaGjN/5YpLi7WgQMHJLlX5JKkuLg4vfrqqwoKClJwcHCt4vYmvx7RVZ3169dLqnrawq+//lqS9Oyzz6pXr14n/Js3b56hcQIAAODM2Gw29ezSQO8/3Vd5v/xZjf6/oJEQF6qXH+pFkcsCHA67rhnYQt+9OVgFy/6sRrFHR/c0jA3R32/rQpHLAqIignTvyA7aMPsaJcT9fg1Y8fGVuvHKNhS5LKBZQoSe+kt3ZXx/vRr9/3ugcXyoPn9pkC4+P5EiFwAA8CkOh0MRERGKiYlRSMipZy84XlRUlB599FG1adPGrSKXJAUEBCg2NlaRkZEKCqp7U75b8jf6UxW6du3aZXA0AAAAMEJwUEDl9FXuPqwX/iE8LFABAUfv9eM9YD02m62yoEFhw5oCAuwKsPM5AOQu/VR5v32vpre+oJ1TRqp4zybZg0LliG6gZndPU0jC6ad+BgD4pujoaD355JN+97sQI7oAAAAAAAAAizi07DPVO+8qSVL8xXeo42tb1eGlX1XvvCuVNvU2c4MDAHidvxW5JIuO6Fq4cKHZIcAk8fHxGjduHM9aAwAAAADAgqyQFygvOKRNY8+Ss7RIQXFN5SorUUnWTtXvN1rN756mgi1L1WLce7I5AhXd/bLKduHJPZX9+RQTI4cRrNAHAFiPJQtdsK7Y2FiNGjXK7DAAAAAAAIAJrJAXcETUU/0L/6SA0EglXPeoDq+Zr6xPn1aLv7ylvLULFN7ufNkcgSe12zf3JdXrcaUJEcNIVugDAKzHklMXwrry8vL03XffKS8vz+xQAAAAAACAwaySFziSuk6hSWcf/XrHaoX9/9eHln+umJ5Xn7R+5synVZK5XU3+/IyhccJ4VukDAKyFQhcsJSMjQw8//LAyMjLMDgUAAAAAABjMKnmBotR1lcWtY4Uul8ulw2vnK+qcwSesm/XZFB36ZbZaP/a17MFhZoQLA1mlDwCwFgpdAAAAAAAAgJ8oPbBXkk1BsU0kSUW7flNo8046krJCoYntFRAaUblu9px/K3fxdLV58ls5IuqZEzAAAGeIZ3QBAAAAAAAAfuLIzrWVo7kkKSC8nvZ99ZocUXGqd95Vla+X5qQr/Z3xCmqUpJRH+kuSbI5gtZ+y3OiQAQA4IxS6AAAAAAAAAD9R79zLVe/cyyu/b//8SknSxjEd1fCpHypfD4pLVLc5LsPjAwDA0yh0wVKCg4PVtm1bBQcHmx0KAAAAAAAwmJXzAh2nbjQ7BNQBVu4DAPwXhS5YSsuWLfXBBx+YHQYAAAAAADABeQFYHX0AgD+ymx0AAAAAAAAAAAAAUBsUumApW7duVe/evbV161azQwEAAAAAAAYjLwCrow8A8EcUumApLpdLZWVlcrl42CoAAAAAAFZDXgBWRx8A4I94RlddFRwsxyf/NTuKmuMBlgAAAAAAAB4REiAtvszsKNwTEuDhDfpabkwiPwbAowICAjRs2DCPbW/y6zOUX1ioyPBwPXDndSd97wkBAZ7+MKgZCl11lM1mk0JCzA4DAAAAAAAABrPZpFCLZ+3IjQGwOpvNJofDcx8GLklO19H/HQ7HSd/7MqYuBAAAAAAAAAAAgE/y7TId4KYWLVpo+vTpatKkidmhAAAAAAAAg5EXgNXRBwD4IwpdsJSQkBC1atXK7DAAAAAAAIAJyAvA6ugDAPwRUxfCUjIzM/XUU08pMzPT7FAAAAAAAIDByAvA6ugDAPwRhS5YyuHDh/XFF1/o8OHDZocCAAAAAAAMRl4AVkcfAOCPKHQBAAAAAAAAAADAJ1HoAgAAAAAAAAAAgE+i0AUAAAAAAAAAAACfRKELlmK323X22WfLbuetDwAAAACA1ZAXgNXRBwD4I65osBSn06m1a9fK6XSaHQoAAAAAADAYeQFYHX0AgD+i0AUAAAAAAAAAAACfRKELAAAAAAAAAAAAPolCFwAAAAAAAAAAAHwShS5YSmRkpC699FJFRkaaHQoAAAAAADAYeQFYHX0AgD9ymB0AYKQmTZroySefNDsMAAAAAABgAvICsDr6AAB/xIguWEpJSYn27NmjkpISs0MBAAAAAAAGIy8Aq6MPAPBHFLpgKampqRo2bJhSU1PNDgUAAAAAABiMvACsjj4AwB8xdSEA1EEul0vlRb51d5UjNFg2m83sMAAAAAAAgB9wuVySL408CyYvApiFQhcA1EHlRSX6qNUNZofhllE7PlRgWIjZYQAAAAAAAH9QUqLyETeaHUWNOT75rxRCXgQwA1MXAgAAAAAAAAAAwCdR6AIAAAAAAAAAAIBPYupCWEq7du20YsUKs8MAAAAAAAAmIC8Aq6MPAPBHjOgCAAAAAAAAAACAT6LQBUtJS0vTLbfcorS0NLNDAQAAAAAABiMvAKujDwDwR0xdCEspKirShg0bVFRUZHYohtixJ09L1mRr9eYcrd18QNkHjh73voNFGvbX79W9Y5y6dYjVhd0aKSTY/y4HBUfK9NOqTK3edECrNuYoLbOg8hzszy3W+CnL1a19nC7s1kiJjcJNjhbekLGvUIvXZGvVxhyt2ZxT+fPPPliky8csULf2cere8eh7IDoyyORoPa+ktEJL1mRr1ab9Wr3pgLbtPnxCHxjz9M/q1iFOvbs2VHKLaJOjBQAAALzPankB4I/oAwD8kf9ltgGLKytz6osf0/TajM1auCKz6nXKXZr9/S7N/n6XJCm2XrBuuSpZd41op6TEKAOj9Y6N23M17ZPNev/L7covLKtyndIyp/79/gZJkt1u05A+TXXPde118flNZLfbjAwXHuZyufT98gxNm7FFc35MU0WF66R1ystdmrdoj+Yt2iNJCg91aNSQVrrnuvbq0jbW6JA9Li0jX298ulVvzd6qfQeLq1yntMypV/+3ufL7C7s10j3XtdfVFzVXUGCAUaECAAAAAAAAZ4RCF+BHVm7Yr5seXaRNOw651e7AoRJNfm+9nn9/g+4ffZaevPcchYb43uUhr6BU46cs11uzU9xq53S69OVPu/XlT7vV46x4vffUhWqfVM87QXpZo14ddensiSe8VlZYpLydmdrx6SJtfvsruSqcJkXnfdt35+mWxxZp8Zpst9oVFpXrjU+36o1Pt+qGy1vppQd7qX50sJei9J7Ssgr98/V1eubtX6ss8J3KotVZWrQ6S22aR+ndJy9U77MbeilKAAAAAAAAwHN4RhfgB8rLnXr4pVXqecOXbhe5jud0ujTlv+t1znWfa9XG/Z4L0AALl2forGtmu13k+qMVG/br7BGfa8p76+VyuVcoqEt2zl6sRWNe0qK/vKx1z8+U3RGgHhNvUs9nbzc7NK9wuVyaOn2TOl872+0i1x99OHeHzrpmtr5avMdD0Rnjt5SD6j5yjp56Y53bRa7jbUvLU5+b5ur+yctUWlbhwQgBAAAAAAAAz6PQBUtJSEjQxIkTlZCQYHYoHlNSWqHhf1uoZ97+VU6nZwozW1IPq+/NX2nBz+ke2Z63Tf9qhy65+xvtySr0yPZKSiv0wL9X6M4nl6rCR0c/HVifqp2zFmvnp4u0cdoXmjfkYRXuzVHyny5ScKzvT095PJfLpb8+t1x/eeYXFRV7pjCTuf+Ihv7lW73z2ZkVTo2yaFWmLrhxrtZvy/XI9lwu6YUPNurKsd/pSFG5R7YJAAAA1AX+mBcA3EEfAOCPKHTBUqKjozV48GBFR0ebHYpHlJc7df2DP+jzhWke3/aR4nJdOe47/biy6ud81RWfLkjVDQ//pPJyz4++enPWVo15+hefHtl1THlRifav2Sab3a6o5v4zJZ3L5dL4Kcv10kcbPb5tp9OlWx9frA/nbvf4tj1p2a/7dNm9C6p9Ht2Z+GZpuobd/z0juwAAAOA3/C0vALiLPgDAH1HogqXk5uZq5syZys31zKgHsz31xjp99r3ni1zHFJdU6Jq/fqesnCNe28eZ2JJ6SDc8/JPHRrJV5T8zt+jNWVu9tn0jRbY4WuAqOVRgciSe89G8HXrhA88XuY5382OL9OvWA17dR20dOFSsq+77ToVeHHX1zdJ0/ePl1V7bPgAAAGAkf8sLAO6iDwDwRxS6YCnZ2dmaPHmysrPP7Bk+dcG6LQf0r7fWudVm5fQrtOfbkVo5/Yoat8nNK9Vd/1xa50Y1VVQ4dfOji1RS6t5Ik9qcg/FTVigtI9/dEE3lCA1ScP1IBcdGqV67Zjrv6dsU2ylJ+9dsU97Ouj1Kr6Yy9x/R2Gd/catNbX7+5eUu3fToIpWV1b1pLMc+u0zZB4rcalObc/D8++v1y6++f90EAAAA/CkvANQGfQCAP7JEoSsnJ0cTJkxQ69atFRISoqZNm2rcuHEqLCzUrbfeKpvNpqlTp5odJlBjTqdLNz+2yO3p+hrFhSmxYbgaxYW51W7OD7s1c0GqW2287ZWPN2nZb/vdblebc1BwpEx3PrnU7X2Z6ewJI3X9xnd1/YZ3dNUP/1b7my/VrnnLtPCmSWaH5jFjnv5FuXmlbrWpbR9Yt+Wgnnv3N7faeNu8Rbv18Vc73G5Xm3Pgckk3P7q4Thb7AAAAAAAAYG1+X+hat26dOnXqpMmTJysrK0sdOnRQWVmZXn75ZV133XXavHmzJKlr167mBgq44dtf9mrdloOG7nPSO7/VmVFd5eVOPf/+BkP3Of/nvfotxdhzfia2frBA80dM1Lej/qVV//xAxQfzFZ4Qq4qS3wtDfaf9VX1fv/+EdkH1IjRi3ZtKuqaP0SG7ZVvaYc3+fpeh+3zxo41ujyD0pknvGFt427rrsL78abeh+wQAAAAA4Ez8lLNPQV9+on/v2FLtOkFffqKrli82MCoAnubXha6cnBwNHTpUWVlZGj9+vDIzM7VmzRplZWVp0qRJmjdvnlauXCmbzabOnTubHS5QY6/N2Gz4PtdsPqCVG3IM329V5i7arfTsQsP3O82E815beTuzlLl4vfYuXKsNr83R9zc+q7iurdRr0p2V6/zy9zfV4Ny2anlV78rXej59m/at2KKds+v2L3j/mVn9L6jekpNbrFnf7jJ8v1XZsO2gFq8xfpoJM649AAAAAAAAwKn4daFr7NixSk9P15gxYzRlyhRFRkZWLpswYYK6dOmi8vJytWjRQlFRUSZGCqOEhYXpvPPOU1iYe9OW1SVZOUc0d9EeU/b95izjiwtVeWt2iin7/WDudhWXlJuy7zO1f9VW7fh0kVpe1Vvx3dtKkkoPFejn8dN03r9uU2jDGDUf0lONzu+oXx583eRoT62iwql3PzfnPfDm7K2m7PeP3v7MnOP/fnmGUtN963l1AAAAwPH8IS8AnAn6AAB/5LeFrs2bN2vGjBmKi4vTM888U+U63bp1kyR16dKl8rXFixdr4MCBSkhIUHBwsBITE0+Y4hC+rVmzZnrllVfUrFkzs0OptWW/7ZPTac4Ugj//us+U/R7P5XLp53XmPDC1sKhcv6XkmrJvT/j1hU/lLK/Q2Q9cV/na3h/WadeXP+vCqWPV89nb9fP4aSrJLTAxytPbknrY7Wdzecry9ftUXm7+c6qWmtQHJOmXOnAdAAAAAGrLH/ICwJmgDwDwR35b6Jo+fbqcTqdGjRqliIiIKtcJDQ2VdGKhKzc3V506ddLLL7+sBQsWaNKkSdq4caN69eql9PR0Q2KH91RUVKigoEAVFXXnOTvuWr3pgGn73pJ6WIVHykzbvyTt2ltgWpFDklZvqhvTN9ZG/q4spc5ZqsYXdlaD89pXvr5q4vuKbNlIexeuVfr3a0yMsGbM/BkUFVdoS+oh0/YvSWVlTlMLrqs3+24fAAAAAPwhLwCcCav2gSMVFcopKanyHwDf57eFroULF0qS+vfvX+06xwpXxxe6rrjiCr3wwgsaPny4+vbtq1GjRmn27Nk6fPiwZs2a5d2g4XXbtm3TgAEDtG3bNrNDqbVftx40bd9Op0vrt5k7ounXFPMKfZK0bqu5+z9Tv700S86KE0d1lReVqCBtn3I37zYxspr7NcW8PiBJ60zsg5K0ddchlZSa9wfJui2+3QcAAABgbf6QFwDOhFX7wJNbN6rxgjlV/gPg+xxmB+AtaWlpkqTmzZtXuby8vFxLly6VdGKhqyqxsbGSJIejdqere/fuysrKqlVbnNq1117r1vr79h2dcuvrr7/W6tWra9Tm6quvdjsub9ofebMU2KLKZSunX6FGcdXPsdwoLrTy/z3fjjzlfrJyjujc67846fXLrxyukPIdNQ/YwwqDukoRVf9MTnf8Us3PQXXH/8FHn2reG6c+d54Q6LLrcfVwu13WLxv1XkL1/eLwtr16P/G6apefieQ2ySqzeX9av9zwK6Xgc6pcZkQfGDNugh66a4UbEXtWiaOZFHVrlcuM6AOLf16lxMQ73Ii4bsmsd79kj1ZmVqYSExPNDscUVj8HVj9+8B7g+K19/OA9IPnfOTAiLyDVvdwAcDx3+oEv9YFQu12buvbyyLZua5akYY2bVrls8LKfPLKP5ORkFTnNf9xBda6++T6FR0RVXv//+L2/s/rxS3XzHDiP6zMXXHCB1q5dW6vt+G2hq7CwUJJUVFRU5fIZM2YoJydHkZGRatmy5UnLKyoq5HQ6lZaWpr///e9q1KiRRowYUatYsrKytHfv3lq1xakd+znX1LH3Q1FRUY3b1rmfXVKZFFj1okZxYUpsGH7aTTgC7DVaryoHDhyUCkw8JzEtpapnI63x8Uu1PwdFxSWGvCeCbAFSQ6/vxqMyMjNU6jJgpFFikRRc9SIj+sDhw3k6fMDEPhAeLkVVvciIPlBWVlH3rovuiKyQ7JKzwseP40xY/RxY/fjBe4Djt/bxg/eA5HfnwIi8gFQHcwPAcdx5L/tSHwgLCJC6emZbrSMidFG8dxMtGRkZOlKHp4R0/n9sx67/f/ze31n9+KW6fw6ys2v/THq/LXQ1atRIubm5WrNmjXr1OrHyn5mZqQceeECS1LlzZ9lstpPa9+3bt3LEV+vWrbVw4ULFx8fXOhZ4R3i4e0naYx/goaGhNW7bpEkTt+Pyppwgu6qbPTgr58gp2zaKC5UjwK7yCqeycqouAp9uW3Gx0QqONu+cHAkKV3WTJ57u+KWan4PqthUa4lB9A94TgS67VHdvAqpS44TGhozoOhQaqOp+FTeiD9SLDld4iHl9oDQgWvurWWZEHwhySPF17LrojsyAADkl2QMClODDx3EmrH4OrH784D3A8Vv7+MF7QPK/c2BEXkCqe7kB4HjuvJd9qQ+E2n3rqTuNGzeu0yO67AEBlf83adLkpO/9ndWPX6qb58DpdCozM1OS1LBh7YvRflvoGjhwoDZv3qxJkyZp0KBBSk5OliStXLlSo0ePVk5OjiSpa9euVbZ/++23dejQIaWmpmry5Mm6+OKLtXTpUjVr1sztWFatWlXr48CprVy50q31t2zZounTp2vw4MFq165djdq8+OKLtYjMe+55aqmmfbKlymVVTTN2vD3fjlRiw3Bl5RSp6aD/1Wr/65bPV5NajoTxhFUb91d7nKc7funMz8HD42/RI3e84nY7d5UdKdZHrW7w+n6O+WbY42e8jZRtKQoMC/FANKf2wgcbdP/k5VUuM6IPfD7jP+rbPaFWbT0hN69E9S/4sMplRvSB64ddpPeemuh2u7oiceB07d13RAmNEpS+Id3scExh9XNg9eMH7wGO39rHD94Dkv+dAyPyAlLdyw0Ax3OnH/hSH3AVF6t8xI2G77e2UlJSZAvxfl6ktp5+9SPlFRQevf6np5/0vb+z+vFLdfMcFBYWKiLi6PRdS5YsqfV2fKss7oYJEyYoNjZWe/bsUceOHdWpUye1adNGPXr0UFJSkgYMGCCp+udztW3bVuedd55Gjhyp77//Xvn5+XruueeMPAR4QevWrTV//ny1bt3a7FBqrVuHONP23TA2VI0bnPr5P97WqU19BTrMu3R1a2/e+cdR3drHmrr/s9uZu/+YqGAlJUaatv9uHcw9fgAAAOBM+ENeADgT9AEA/shvC12JiYlavHixhgwZopCQEO3atUv169fX66+/rnnz5iklJUVS9YWu49WrV0+tW7fW9u3bvR02vMzhcCgmJkYOh+8OZuze0bxCS/eOcVVO9Wmk4KAAdWoTY9r+zSw04qiz28fKrLdh2xbRiooIMmfnxzHzOkAfAAAAgC/zh7wAcCboAwD8kd8WuiSpffv2mjt3rvLz85Wfn6/ly5frjjvuUGFhoXbt2iW73a6zzjrrtNvZt2+ftm7dqlatWhkQNbwpPT1d48eP9+nhqJ2T66tti2hT9j3i4pam7PePhpsUR79zE9QgNtSUfeN3keFBGnxBoin7HnFJ3egDZvXFZgnhOq9T7Z5XCQAAANQF/pAXAM4EfQCAP/LrQld1Nm7cKJfLpTZt2igs7MRp2G644QY98cQT+vzzz/Xjjz/qzTffVL9+/eRwOPTXv/7VpIjhKQUFBVq8eLEKCgrMDqXWbDab7rmuveH7ja0XXGeS/LdenaygQOMvX2acd1Tt3pEdDN9nQIBNdwyr+fzl3nRFv+amTCN61/D2Cgiw5K8OAAAA8BP+kBcAzoTV+kDfuAYqHTpC97eq/u/50qEj9Pl5fQyMCoCnWTJbtX79eklVT1vYs2dPffXVV7r55ps1ePBgTZ48WX369NG6deuYuxZ1xp+HtlZEWKCh+7ztmrYKCa4bw9rj64dq5KVJhu6zcYMwXdW/uaH7RPUuOb+JWjU19jlVV/ZrrsRG4YbuszqBgXbdNdzYoltwUIBuvTrZ0H0CAAAAAAAAp1M3stYGO1Wha8yYMRozZozRIQFuqRcVrEn3dde9T/9iyP6aJYTr4dtO/zw7Iz0zrru++HG3DuWXGrK/qX/vpUATRpHVVmTLRurz0l8UXD9SZflHtGTcVB1KOXFagvhuyer17O2SJFugQ/tWbNbyR96Rs7TcjJDdEhBg16sPn69L755vyP7CQx2aMr6HIfuqqfF/7qT3v9yu7bvzDNnfP+89h6k7AQAAAAAAUOf4TtbWg05V6AJ8xV0j2qv/uQmG7OutJ/ooKiLIkH3VVOMG4XrpwZ6G7Ov6wUm6+qIWhuzLU85/7k6lfPitPrtgrNZP/VwXvHRyAf/gpl36cvBD+mLQA5rT/36FxEWr3U2XmhBt7VzSO1G3XWPMCKPJ9/dQy0RjR5CdTlioQ+8+2Uc2m/f31bNzvO7/8+mfaQkAAAAAAAAYzZKFroULF8rlcmnIkCFmhwKDxcfHa9y4cYqPjzc7lDNmt9v07j/7qFFczUdYZOUcUXp2obJyjtS4zfg/n6VBvZrUJkSvGz20tUYNaeVWG3fPQZvmUXrl771qE55pQmKjFNullXbMWiRJSpu3TOGNYxXZotEJ61UUlcpVXiFJCghyyBESJLlchsd7JqaMP08dW9Wr8fq16QNXX9Rcdxo8TWBNXXBOIz1259lutXH3HMTWC9Z/n+rLs7kAAADgF/wpLwDUBn0AgD+y5NSFsK7Y2FiNGjXK7DA8pnnjSC34z6W66PavtT+3+LTrn3v9F25t/7ZrkvXc/XVrurbj2Ww2vfvkhSo4UqY5P+yuURt3zkGLxhH67o3Biq0XUtsQTRHeJE5F2blyVTgrXyvYm6PwJnHK35V1wroRifEa8N6DimzRUOnfrdGW94yZCtBToiOD9O0bg9Xvlq+Uknb4tOu72wcuPr+JPn62n+x2A4ZN1dLjd5+tQ/mleumjjTVa351zUC8ySN9Mu0TJLaJrGx4AAABQp/hbXgBwF30AgD/i9mxYSl5enr777jvl5RnzTBsjdEqur8XvDVHrZlEe3e6Dt3TWG49fUKcT/JIUGGjXzCkX6darPTuF3dntYrXkv5erWUKER7db1xSk79cXA/+mGZ1vV0BwoJpfdp7ZIbktIT5Mi98bop6dPXs32p8ua6UvXh6kkOC6fU+IzWbTCxPO0xN3n+3RaQybN47QoneHqHtH7vIDAACA//DHvADgDvoAAH9EoQuWkpGRoYcfflgZGRlmh+JRbVvW068zr9a4UR3PONHdskmkfnj7Mj1737myGfHwHw8IDLTrrYl99PlLA9UwtuZTOVbF4bDpibvP1vKPrlCThuEeitBYhXtzFNowRrbjppqLaBKnwr051bYpP1Ks1M+XKumaPkaE6HENYkO1+L3L9ex93RUUeGYfbXExIZoxub8+erafgoMCPBShd9lsNj1+9zla8t/Lldz8zEdf3TW8ndbPulqdkut7IDoAAACg7vDXvABQU/QBAP6IQhfgJ8JCHXrxwZ5a8t/LdUW/Zm6PxGrcIEwT7zlHv826Wv3OTfBSlN51Zf/m2vT5ME24uZNi6wW71TbQYdf1g5O0+n9X6fG7z1HgGRZLzFR8IE8H16eq1bALJUnNh/RUYebBk6YtjGzRSDbH0UKOPdChZoN76ODmNMPj9RSHw64Hb+midTOv1ujLW7td8IqJCtJfR3fUxtnXaMQlSV6K0rvO79pQ62ZepWfGdVezBPcKtTabdFmfRP34zmWa9mhvRYYHeSlKAAAAAAAAwHPq9nxMANx2fteGmvPyIO3OLNA7n6Vo8Zosrd58QIfzS09Yz2aT2raIVrcOcRo2sIWG9m0mh8N3izvH1I8O1qS/9tDEe87RzAWpmrtoj1ZvytGOPfknrRsXE6Ju7WPV79wE3XxV8hmPBqtLfp7wui548V51GnuNygqKtOS+VyVJ50+5S3sWrNKeBauUcMFZan/rZXJVOGVzBChz8Xr99sKnJkd+5ton1dP7T/fVvx84T+/N2aYfVmZo1cYc7Tt48nPsWjSOUPeOcbqsT1ONvDRJoSG+/7EYGuLQQ7d20QM3ddJXi9M1c0GqVm/O0eadh+RynbhuVESgzmkfp95dG+iWq5OVlOjZKVABAAAAAAAAb/P9jB6AKjVLiNAT95wjSXK5XNq1t0C5eSUqK3cqNMShlk0i/HrERkiwQ6OHttHooW0kSbl5JdqdWaDikgoFBdoVFxOixIbhPjM9o7vydmToq6H/OOn1n//2n8qvUz78TikffmdkWIaKiwnR327qpL/d1Ekul0sZ+45o38EilZY5FRIcoMSG4YqtF2J2mF4TEGDX0H7NNLRfM0lSwZEy7UzPV1FxuRwOu2KigtSicWSdfw4fAAAAAAAAcCoUumApwcHBatu2rYKD3ZvWztfZbDa1TIxUS0WaHYppYqKCFRNlrZ87fmez2dSkYbjPPnfNEyLCAtWZZ24BAADA4qyaFwCOoQ8A8EcUumApLVu21AcffGB2GAAAAAAAwATkBWB19AEA/sj3H8gDAAAAAAAAAAAAS6LQBUvZunWrevfura1bt5odCgAAAAAAMBh5AVgdfQCAP6LQBUtxuVwqKyuTy+UyOxQAAAAAAGAw8gKwOvoAAH/EM7oAoA5yhAZr1I4PzQ7DLY5QHmQLAAAAAAA8JDhYjk/+a3YUNRdMXgQwC4UuAKiDbDabAsNCzA4DAAAAAADAFDabTQohNwLg9Ji6EAAAAAAAAAAAAD6JEV2wlBYtWmj69Olq0qSJ2aEAAAAAAACDkReA1dEHAPgjCl2wlJCQELVq1crsMAAAAAAAgAnIC8Dq6AMA/BFTF8JSMjMz9dRTTykzM9PsUAAAAAAAgMHIC8Dq6AMA/BGFLljK4cOH9cUXX+jw4cNmhwIAAAAAAAxGXgBWRx8A4I8odAEAAAAAAAAAAMAnUegCAAAAAAAAAACAT6LQBQAAAAAAAAAAAJ9EoQuWYrfbdfbZZ8tu560PAAAAAIDVkBeA1dEHAPgjrmiwFKfTqbVr18rpdJodCgAAAAAAMBh5AVgdfQCAP6LQBQAAAAAAAAAAAJ9EoQsAAAAAAAAAAAA+iUIXAAAAAAAAAAAAfBKFLlhKZGSkLr30UkVGRpodCgAAAAAAMBh5AVgdfQCAP3KYHQBgpCZNmujJJ580OwwAAAAAAGAC8gKwOvoAAH/EiC5YSklJifbs2aOSkhKzQwEAAAAAAAYjLwCrow8A8EcUumApqampGjZsmFJTU80OBQAAAAAAGIy8AKyOPgDAH1HoAgAAAAAAAAAAgE/iGV0AAABAHeNyuVRe5FvTyThCg2Wz2cwOAwAAAH7C5XJJvjTFYjC/DwNmodAFAAAA1DHlRSX6qNUNZofhllE7PlRgWIjZYQAAAMBflJSofMSNZkdRY45P/iuF8PswYAamLgQAAAAAAAAAAIBPYkQXLKVdu3ZasWKF2WEAAAAAAAATkBeA1dEHAPgjRnQBAAAAAAAAAADAJ1HogqWkpaXplltuUVpamtmhAAAAAAAAg5EXgNXRBwD4I6YuhKUUFRVpw4YNKioqMjsUAAAM4XK5lLo3X6s25ihj3xHlF5ZJko4Ul2tr6iG1aR4tu91mcpTedSivRGs2H9Dm1EOVx19YVKaf12Wra9tYhYXyK7E/c7lcyth3RKs35Sh1b/5x74Fy/ZZyUB2S6snh8O/7/wqPlGnd1oNav+2g8o8cPf6CI2VauDxD57SPVb2oYJMjBADjkBeA1dEHAPgj/qoHAADwMy6XS0vWZOu1GZs1/+d05eaVnrRObl6p2l05S5HhgbrovMa6e0Q7DezZxG+KXhn7CvXmrK366Ksd2paWd9LyQ/ll6v3nubLbbeqcHKObrmijG69oQ8Lfj/y69YCmfbJFc35IU1bOyYmcQ/ml6nLtZwoJDlDvrg115/B2uqp/cwUG+kfRKzevRP+ds03vfbFN67flyul0nbD8cEGZLrr9a0lScvNojRrSSrcPa6uE+DAzwgUAAACAWqPQBQAA4Ee+WrxHD76wUhu259Zo/fzCMn2+ME2fL0xT62ZR+ue95+i6S5Nks/lmwStjX6HGT1mhmd+mqqLCddr1nU6X1m05qPu2LNfDL6/Wrdck66kx3RQVEWRAtPCGFev36/4py7V0bXaN1i8uqdD3yzP0/fIMJcSH6cGbO2nM9R0UEOCbBa/D+aV6ZOpqvf3ZVhUVV9SoTUraYT3+2hr98421Gj6opaaM76HGDcK9HCkAAAAAeAaFLgAAAD9wKK9Ef528XO/N2VbrbWzfnafrH/xRnyxI1bRHeqthbKgHI/Qul8ul97/YrvueW6ZD+SePYKuJI8XleuXjTZrzQ5reeqKPBvVq4uEova9Rr466dPbEE14rKyxS3s5M7fh0kTa//ZVcFU6TovOu4pJyTfzPWj337vqTRi/VVOb+I7rvueWa+e0uvftkH7VpHu3hKL1r/tJ03fbEEqVnF9aqfXm5S9O/3qmvl6Tr5Yd66obLW/ts0RsAAACAdfjmbYpALSUkJGjixIlKSEgwOxQAADxmW9phdR3x+RkVuY732fdp6nTNbK3ZlOOR7XlbeblTtzy2WDc9uqjWRa7j7c4s1MV3fqN/vr5WLlftCiZm2zl7sRaNeUmL/vKy1j0/U3ZHgHpMvEk9n73d7NC8Yv/BIl1w4zw9+/ZvtS5yHW/p2mx1Gf6Zvlq8xwPReZ/L5dLEaWt06d3za13kOt6h/FL9+R+LdOvji1Ve7p+FUQDWRV4AVkcfAOCPKHTBUqKjozV48GBFR/vW3bkAAFRnW9ph9blpntIyCjy63f25xep/21d1vthVUeHUqL//6LEi3/Eee3WNHnlltce3a4QD61O1c9Zi7fx0kTZO+0Lzhjyswr05Sv7TRQqOjTI7PI/KyS1Wv1u/0moPv1eLiit05bhv9eWPuz26XW94+OVVemLaWo9v993Pt2n0wz+pwk9HAQKwJvICsDr6AAB/RKELlpKbm6uZM2cqN7dmzy0BAKAuy80r0aA7v1H2gSKvbD+voEyX3D1f6VlnPkLEW/72/Ap9Mj/Va9t/+q1fNW3GZq9t3yjlRSXav2abbHa7opo3NDscjykrc+ryMQu0acchr2y/vNyl4X9bqFUb93tl+57w6v826dm3f/Pa9v/3zU5NeGGl17YPAEYjLwCrow8A8EcUumAp2dnZmjx5srKza/ZwcgAA6rL7Ji1zeyTXyulXaM+3I7Vy+hU1Wj8nt1i3T1xSJ6fwW7g8Qy9+uNGtNu4evySNf365tu/Ocze8OieyxdECV8khz47+M9Oz7/yq5evdK0K5+x4oKa3QjY8sUnFJeW1C9KqUXYf1t+dXuNWmNn3g3+9v0E+rMt0NDwDqJPICsDr6AAB/RKELAADAB3354269/+V2t9s1igtTYsNwNYoLq3Gbb5am693PPT814JkoOFKmWx9f7Ha72hx/UXGFbnlskUee/WQUR2iQgutHKjg2SvXaNdN5T9+m2E5J2r9mm/J2+kfB4reUg/rn6+vcbleb98CmHYc08T+enxrwTFRUOHXL44tVXFLhVrvaHL8k3fLYYhUeKXOrDQAAAAAYwe8LXTk5OZowYYJat26tkJAQNW3aVOPGjVNhYaFuvfVW2Ww2TZ061ewwAQAAaszlcunBF42dSuzhl1eptMy9hLo3TZuxWbs8/FyyU1m8Jltzf6r7z2o65uwJI3X9xnd1/YZ3dNUP/1b7my/VrnnLtPCmSWaH5jGPvLJaZeXGPTvq+f9uUFbOEcP2dzpf/LhbS9cadyf2zvR8vf7pFsP2BwAA4Ak/5exT0Jef6N87qv89JujLT3TVcvdvogNQd/h1oWvdunXq1KmTJk+erKysLHXo0EFlZWV6+eWXdd1112nz5qPPW+jatau5gQIAALjhp1VZ2rzzkKH7zD5QpM8Xphm6z+o4nS5N+8T4hPtrPvSsrq0fLND8ERP17ah/adU/P1DxwXyFJ8SqoqS0cp2+0/6qvq/ff0K7oHoRGrHuTSVd08fokN2ya2++5i4ytvBYVu7U27NTDN3nqZjxfpz2yRafGtkIAAAAwBr8ttCVk5OjoUOHKisrS+PHj1dmZqbWrFmjrKwsTZo0SfPmzdPKlStls9nUuXNns8OFQcLCwnTeeecpLMy9qVoAAKhLzCq41JVCz/yl6Urdm2/8fn/e6zPP6srbmaXMxeu1d+FabXhtjr6/8VnFdW2lXpPurFznl7+/qQbntlXLq3pXvtbz6du0b8UW7Zxdt+9ofePTrTLjsXGvf7pFFRXGjSKrTsquw/puWYbh+92+O0/fLdtr+H4BwJPIC8Dq6AMA/JHfFrrGjh2r9PR0jRkzRlOmTFFkZGTlsgkTJqhLly4qLy9XixYtFBUVZWKkMFKzZs30yiuvqFmzZmaHAgBArTidLn2zNN2UfS9anaWCOvCMnq9NOn5Jmv+zefs+E/tXbdWOTxep5VW9Fd+9rSSp9FCBfh4/Tef96zaFNoxR8yE91ej8jvrlwddNjvb0vl66x5T97skq1MYdh0zZ9/HMugZI0tdLfLMPAMAx5AVgdfQBAP7ILwtdmzdv1owZMxQXF6dnnnmmynW6desmSerSpUu12xk8eLBsNpueeOIJb4QJE1RUVKigoEAVFXXnGSMAALhj++485ReaU2xyuaR1Ww6Ysu/jrd6UY8l9n6lfX/hUzvIKnf3AdZWv7f1hnXZ9+bMunDpWPZ+9XT+Pn6aSXOOefVYbxSXl2rA917T914X3AH0AAGqPvACszqp94EhFhXJKSqr8B8D3+WWha/r06XI6nRo1apQiIiKqXCc0NFRS9YWuTz75ROvWrfNWiDDJtm3bNGDAAG3bts3sUAAAqJVVG81NMpu9/4oKp9aaWGxbvcn8Ql9t5e/KUuqcpWp8YWc1OK995eurJr6vyJaNtHfhWqV/v8bECGvmt5RclZeb95youlDoMTOGNZsP1InpGwGgtsgLwOqs2gee3LpRjRfMqfIfAN/nMDsAb1i4cKEkqX///tWuk55+dMqNqgpdeXl5uu+++zRlyhTdcMMN3gkSAACgFtKzCy29/9y8UhUVm3f3qdnHf6Z+e2mWWl7VW2c/cJ3mX/uEJKm8qEQFafuUu3m3ucHVkNk/A7P3L0np+46Ytu/ConLlFZYpJirYtBgAAADcdVuzJA1r3LTKZYOX/WRwNAA8zS8LXWlpaZKk5s2bV7m8vLxcS5culVR1oesf//iHkpOTNWrUKI8Uurp3766srKwz3g5Odu2117q1/r59+yRJX3/9tVavXl2jNldffbXbcQEA6qbMevdL9mhlZmUqMTHR7HBqJS+krxQ2oMplK6dfoUZxp36odKO40Mr/93w7str1snKO6Nzrvzjp9f+88bb+9+IwNyL2rApbpBTzt2qXn+4cnOnx5x7KM+S9E+iy63H1cLtd1i8b9V5C9b8fHd62V+8nXlft8jOR3CZZZTbvj/Q5EnSWFDG8ymVG9IFv5n+vxMSb3YjY8w7HPCLZAqtc5u0+IEkdOnZRgKtuT3FZHX/4HMCZ4T3gf+fAiLyARG4AdZs7/cCX+kCo3a5NXXt5ZFutIyJ0UXxDj2yrOsnJySpy1t2R71fffJ/CI6Iqr/9//N7fWf34pbp5DpzH9ZkLLrhAa9eurdV2/LLQVVh49C7LoqKiKpfPmDFDOTk5ioyMVMuWLU9YtmrVKr355ptuXehPJysrS3v37vXY9vC7Yz/rmjr2nigqKqpxW352AOBHIisku+SsqPDd63vcQamaHHajuDAlNgyv0WYcAfYar3u8wvzDKswy8dwFREgx1S+u6Tmo7fG7KsoNee8E2QIk7/4d7nEZmRkqdRkw2i6qoVT17OSG9IGS4gLzrx/RZVJA1YUub/cBScrKTJcqzB/ZViv+8DmAM8N7wO/OgRF5AYncAOo2d97LvtQHwgICpK6G77bWMjIydKQOP/vM+f+xHbv+//F7f2f145fq/jnIzs6udVu/LHQ1atRIubm5WrNmjXr1OrHqn5mZqQceeECS1LlzZ9lstsplFRUVuvPOOzVmzBh17NjRo/HAO8LD3fvj/NgHeGhoaI3bNmnSxO24AAB1U2ZAgJyS7AEBSvDR63thkF2HqlmWlXP66cwaxYXKEWBXeYVTWTlV3xR0qm1FhUuRJp47lwKU4SqXbFX/Gnu6c3Cmx++wHVFDA44/0GWX6u7NoFVqnNDYkBFdJY4gVfeEKiP6QFhQhWJMvn5k6Ygqqql4e7sPyFWmxo3qy6Z6NQ23TvGHzwGcGd4D/ncOjMgLSOQGULe58172pT4Qarcbvs8z0bhx4zo9osseEFD5f5MmTU763t9Z/filunkOnE6nMjMzJUkNG9b+bk+/LHQNHDhQmzdv1qRJkzRo0CAlJydLklauXKnRo0crJ+fon8Zdu3Y9od3UqVOVnZ2tJ554wqPxrFq1yqPbw+9Wrlzp1vrl5eW66aabFBkZKYejZm//F198sRaRAQDqosSB07V33xElNEpQ+oZ0s8OplfUpB9X52s+qXFbdNGPH2/PtSCU2DFdWTpGaDvqf2/uf/eELuqhnY7fbeVL3kXO0elPVpY7TnYMzPf4RQ3vqo2cfcrudu8qOFOujVsY9K/abYY+f8TZStqUoMCzEA9GcWsGRMkX1el8u18nLjOgDzz81VneNmOZ2O08aOWGhZnyTWuUyb/eBHp0aa/nHvvE8t6r4w+cAzgzvAf87B0bkBSRyA6jb3OkHvtQHXMXFKh9xo+H7ra2UlBTZQrz/+3BtPf3qR8orKDx6/U9PP+l7f2f145fq5jkoLCxURMTRKTuWLFlS6+34Vlm8hiZMmKDY2Fjt2bNHHTt2VKdOndSmTRv16NFDSUlJGjDg6HMtjn8+V05Ojh599FE99thjKi8v16FDh3To0CFJUnFxsQ4dOnTCfJHwTQ6HQzExMW59kAMAUJe0T6qn0JAA0/Z/TodY0/Z9TDcTYzBz3zgqIixQ7VrWM23/3TrEmbbvyhjamxcDfQCAryMvAKujDwDwR35Z6EpMTNTixYs1ZMgQhYSEaNeuXapfv75ef/11zZs3TykpKZJOLHSlp6crPz9fd955p2JiYir/SdKkSZMUExOj3bt9985FHJWenq7x48dbpkoPAPA/DoddfbslmLLvc9rHKiYq2JR9H++i88wbUWbmvvE7s34OsfWC1Tm5vin7Ph59AABqj7wArI4+AMAf+W3pvn379po7d+5JrxcUFGjXrl2y2+0666yzKl9v3bq1fvjhh5PW79+/v2688UbddNNNPGvLDxQUFGjx4sW6/fbbzQ4FAIBau3tEO32z1Pg/TO8e0d7wfVblqgHN1TA2VNkHqn++kDf06tJAXdoymqUuuGt4O02dvsnw/d56dbKCg8wbUXnMOR3i1OOseK3YsN/Q/TZuEKYr+jU3dJ8A4GnkBWB1VusDfeMaqHToiFOuc7rlAOo+vy10VWfjxo1yuVxKTk5WWNjvD3COiIhQv379qmzTokWLapcBAAAYbciFTdUsIVy7MwsN22d0ZJCuH5xk2P5OJSgwQHdc21b/fH2dofu9d2TdKPRB6tg6Rv3OTdCPKzMN26fNJt01vO68B+4d2V4rHjG20HXHsLYKDPTLSUEAAAAA+DDL/ZWyfv16SSdOWwgAAOBLAgLsevyucwzd50O3dFZ4WKCh+zyVv1zfQXExxj3o+azWMRp+cUvD9ofTm3j32Ybu75arktUyMdLQfZ7KdZcmqUOreobtLz4mRPeO7GDY/gAAAACgpiw3osvdQpfL5fJmOAAAALVy81VtNHNBqiFTGJ57Vpz+dmMnr+/HHfH1Q/Xqw7103QMnTz3taQEBNr331IUKCjR/yrqaimzZSH1e+ouC60eqLP+IloybqkMpJ75X4rslq9ezR6essQU6tG/FZi1/5B05S8vNCNltF3ZP0JjrOxgyhWFiw3A9/7fzvL4fdwQHBejdJy9Ur9Ffyun0/t8s0x4539DiMgAAAADUFCO6YCnx8fEaN26c4uPjzQ4FAIAzYrPZ9ObjFygmKsitdlk5R5SeXaisnCM1Wj805Ggy3eGoe782jrgkSSMucW+UlbvHL0kP39ZF3TrEuRueqc5/7k6lfPitPrtgrNZP/VwXvDTmpHUObtqlLwc/pC8GPaA5/e9XSFy02t10qQnR1t6z47qrdbMot9q4+x6w2aS3nrhA0ZHu9TUj9OgUr4du6exWm9r0gesHJ2nYIEY0AvAP5AVgdfQBAP7IciO6Fi5caHYIMFFsbKxGjRpldhgAAHhEYqNwzXv1Yg264xsVFtVsFM65139R4+07HDbNev4idWwdU9sQve7dJy9U5v4jWrwmu0bru3P8knTD5a30xN3GThN5pkJioxTbpZUWjPynJClt3jL1fPpWRbZopPxdWZXrVRSVVn4dEOSQIyRI8rHZDMLDAjX/P5foghvnKXN/zQo37r4HXn34fF3SO7E24Rnin2O6KXVvvqZ/vbNG67t7/H27N9LbE/vUJjQAqJPIC8Dq6AMA/FHduzUX8KK8vDx99913ysvLMzsUAAA8oleXhlrw+qUeH20SEhygOS8N0uA+TT26XU8LC3Xoq9cu0UXnNfb4tm++qo3effJC2e02j2/bm8KbxKkoO1euCmflawV7cxTe5ORRaRGJ8briuykaufEdleYd0Zb35hsZqkckJUbpp3cuU7OEcI9u12aT/vNob919XXuPbtfT7Hab3v9XX/15aGuPb3tgz8aaO/VihYZY7v5IAH6MvACsjj4AwB9R6IKlZGRk6OGHH1ZGRobZoQAA4DHnd22oNTOuVN/ujTyyvW4d4rTy4yt0WR0vch0TERaor167WI/fdbYcjjMvSkWGB+qNx3rr7Yl96uSUjZ5UkL5fXwz8m2Z0vl0BwYFqflndeg5VTbVpHq1V0690eyrL6iQlRuqHty/TncPbeWR73uZw2PXeUxfqP4/2VkRYoAe2Z9PEe87RV69e4pHtAUBdQl4AVkcfAOCP/PsvdwAAAItISozSwrcu09SHe6l+dHCtthEZHqh//aWbln04VGe1qe/hCL0rKDBAT9xzjlZ+fKXO61T75w1cfmFTbZh9jW6/tp1sNt8ayXVM4d4chTaMkS3g91/1I5rEqXBvTrVtyo8UK/XzpUq6xnenqIuvH6oZkwdo5pQBatqodqO7ggLtGjeqo3779Gr17Z7g4Qi9y2az6c7h7bR+1tW6rE/tp1rs2Tleq6ZfqcfuOluBgfy5CAAAAKDuYw4KAAAAP2G323TvyA665apkzVyQqtdmbNby9ftP265zcn3dc117jRrSyudHb3RtF6tfPhyqlRty9NqMzZoxf6eKSypO2aZeZJBuvKKN7h7RTm1b1jMmUC8qPpCng+tT1WrYhdr+yY9qPqSnCjMPnvB8LkmKbNFIBen75SqvkD3QoWaDe+jg5jSTovacay9uqasGNNe8xXv02ozN+vaXvad99FjLJpG6a3g73XxVG8XXDzUmUC9p0SRS8169RFtSD2najM16/8vtOpRfeso2oSEBuu6SJN1zXXudexYPpgcAAADgWyh0AQAA+JnQEIf+fEUb/fmKNsrNK9GaTQe0elOO9u4r/D/27jzOq7LuH/9rFtYBlE1BURYBBURQFPcF09TcKjMtU+u2PdNKpaxfqW3m8u2+M+vObLciKsub1MwMLVxSlOgmQUUEEhnUSRAYUJjl94fJHQHKDDPz4cw8n4/HPJjPOec61/sMc/gM5zXXdeXl9Q3p3Kk8A/p2y4TR/bLfqL6Ff7D/78rKyjJxbP9MHNs/N152WB5dsDyPzK3JvKdWZM1LdSkrK0vPqk4ZO6J3Jozul5GDdyjcOlyv5/7JN+Sw//pIxl7w1qxfvTb3fuwbSZJDrv1gnr7z4Tx958MZeNjeGXXem9JY35CyyopUz5iT//3PX5a48pZRWVmeUycNzqmTBmf1mvWZ/dgr98DCZ1bnpXX16VRZnr47dMm+o/pmwqh+2XXn7oUdwbclew3dMV/71MH56iUHZv7fV+aRuTWZM395VtWuT2NjY6q6dcqoYTtmwui+GT2st9FbAABAYQm66FC6dOmSPffcM126NG9KJwAomt69uuQNB+2SNxy0S6lLKYlOncozfq++Gb9X31KX0qZWLlia20/+zCbb77/4Wxs+f+LHd+WJH9/VlmWVRI/unXLYfgNy2H4ts4Zd0VRUlGevoTtmr3YwWhGgJXguQEfnHgDaI0EXHcrQoUNz0003lboMAAAAoAQ8F6Cjcw8A7ZH5KQAAAAAAACgkQRcdyuOPP55DDz00jz/+eKlLAQAAANqY5wJ0dO4BoD0SdNGhNDY2Zv36VxbgBgAAADoWzwXo6NwDQHtkjS4AANjOVHbrkrMW/LjUZTRJZTcLmgMA0IK6dEnlz39Y6iq2Xhc/D0OpCLoAAGA7U1ZWlk7du5a6DAAAKJmysrKkq5+Jgddn6kIAAAAAAAAKyYguOpQhQ4ZkypQp2XXXXUtdCgAAANDGPBego3MPAO2RoIsOpWvXrtljjz1KXQYAAABQAp4L0NG5B4D2yNSFdCjV1dX54he/mOrq6lKXAgAAALQxzwXo6NwDQHsk6KJDefHFFzNt2rS8+OKLpS4FAAAAaGOeC9DRuQeA9kjQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOiiQ+nTp0/OPffc9OnTp9SlAAAAAG3McwE6OvcA0B4JuuhQysvL06lTp5SX+9YHAACAjsZzATo69wDQHvkXjQ6lpqYm3/nOd1JTU1PqUgAAAIA25rkAHZ17AGiPBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLjqUnj175vjjj0/Pnj1LXQoAAADQxjwXoKNzDwDtUWWpC4C2tOuuu+bzn/98qcsAAAAASsBzATo69wDQHhnRRYfy8ssv5+mnn87LL79c6lIAAACANua5AB2dewBojwRddCgLFy7MaaedloULF5a6FAAAAKCNeS5AR+ceANojUxcCAADAdqaxsTF1a4v12/aV3bqkrKys1GUA0E40NjYmRRp51sX7IJSKoAsAAAC2M3VrX85P9nhXqctokrMW/DidunctdRkAtBcvv5y6t59b6iq2WuXPf5h09T4IpWDqQgAAAAAAAApJ0AUAAAAAAEAhmbqQDmWvvfbKQw89VOoyAAAAgBLwXICOzj0AtEdGdAEAAAAAAFBIgi46lMWLF+c//uM/snjx4lKXAkAbW7e+Pg0NjUmShsbGElcDQFurr2/4v/eBhsYNn9NxbPSzQAf8+29oaMzK1etS/89rb+ygPw95LkBH5x4A2iNTF9KhrF27Nn/729+ydu3aUpcCQCtbsfLlTP3dwtw/+9k8Mrcm8xa+uOGhVvXza7PrMVMyYVS/7D+mX95+3NDsNXTH0hYMQIuqq2vIbTOezl1/XppH5tZk9uP/yNqX6pMk1TVrs+OhN2Xfvfpmwui+OeGw3fKGA3dJeXlZiaumJa1cvS4//93C3PfPnwXmPrUi9fX//FmgZm0GHv3TTBjdLxNG9cvpbxySvUf0KXHFLauxsTH3zKzObX96Oo/M+0dmzavJytXrN+xf+vzaHHTWtEwY3S9HTxyYU44anE6d2v/vQ3suQEfnHgDaI0EXANCuzF2wPP/140fzk9sWZM1LdVs8bulza7L0ub/nN3/8ey775qwcPXFgzn/H6Lz56MEpK/OgE6CoXnjx5Xxz6tzc8IvHs+TZ2i0et6p2ff70yLL86ZFl+c+bHs2Iwb3yobePyvtP2zNV3Tu1YcW0tCcWvZj/+vHfctOtC7J6zfotHresZm1u+9PTue1PT+fzN/wlh++3c85/x+i87dihhQ49175Ul+/86vF8c+q8PLbwxdc89sE5z+fBOc/nm1PnZWD/7nn/aXvm/HeMTr/eXduoWgCAbSfoAgDahXXr63Pld/6aL944O3V1TZ+KZ/pD1Zn+UHVOOGxQvv25wzJoQFUrVAlAa/qfuxfnA5+/L8/+o+m/pT5/8cp84poHc/2Uufne5w/PkfsPbIUKW9+Ag8fk+F9dsdG29bVrs/Kp6iz45Z8y77u3p7G+oUTVta66uoZc+8M5ueybs7JufdOvccasZzNj1rOZdMBj+e4Vh2fooJ6tUGXrun/2s3nPZ2fkicWvHXBtTvXza3LFt/6Sb0ydl29+5pCc/sahrVAhAEDLa/9j0gGAdu+pJStz4FnTcvl//6VZIde/+u29SzLmrTfnl3cubKHqAGhtL71cl3M+/ce8+cK7mhVy/aunlqzKUf9xey669sHUFzgQeupXM/Kn87+WP330usz+f79IeWVFJl7x7hz0lfeVurRW8fSy1TnknN/k0q893KyQ61/dPbM6Y0/7VW76zfwWqq71NTQ05tNfeziHnXtrs0Kuf1Wz/KW8/eLpOXPy9KxZu+XR8QAA2wtBFx3KwIEDc8UVV2TgwGL+diYAm5r31Iocdu5tmf3YCy12zpWr1+ftl0zPd25+vMXOCUDrWLO2Lied//vcdOuTLXrer/7ob3nXpX9MXV0xw65/zFmYp26ekad++ac8+t/TctuJn07tMzUZ+c43pEvfXqUur0U9tWRlDjv31sz8W02LnbN2bV3O+cyfct1PHm2xc7aWhobGnHfZjFz53b+mcdt+32cjU+9YmOM+eEdW1a5ruZNuBzwXoKNzDwDtkaCLDmWHHXbICSeckB122KHUpQDQAv5evTrHvv+3qX5+TYufu7Exef/n783Pfrugxc8NQMuoq2vI2y76Q/7w4NJWOf/P7ngq7//8vWlsyfSgROrWvpznZ81PWXl5eg3eudTltJjq59fkmPfdkb9Xb3k9tm1x4VV/zvd+/USrnLulfPTKB/KD/2md0Wf3/uXZvPnCu7JufX2rnL8UPBego3MPAO2RoIsOZfny5fnFL36R5cuXl7oUALZRQ0Njzv70H/PMcy0fcr2qsTF57+X3ZuGSVa3WBwDNd80P5uS39y5p1T6+f8v83PSblh0tVio9h7wScL28YnWJK2kZjY2N+Y/PzcjCZ1r3ffrDX7o/855a0ap9NNcv7lyYb06d16p9TH+oOl/89uxW7aMteS5AR+ceANojQRcdyrPPPptrrrkmzz77bKlLAWAbfXPqvPzpkWVNajNzyil5+vdnZuaUU7a6Te3auvzHZTPS0FD83+YHaE/+Nv+FXP7fs5rUpjnvA8kro3qWPtc6I4ZaS2W3zunSp2e69O2VHffaPQd++b3pO3ZYnp81Pyufqi51eS3iB/8zP3fc17SgsznfAy+vq897Pvun7W7NtudfWJsPf+n+Jrdrztfgy9/5a2bNbbmpIUvJcwE6OvcA0B51iKCrpqYmkydPzvDhw9O1a9fstttuufDCC1NbW5vzzjsvZWVluf7660tdJgCwlZ77x9p88j9nNrndgH7dM2jnqgzo171J7e6ZWZ0ft/DaLwBsmw9/6f6sW9+04KG57wMrVq3LRdc+1KQ2pbbv5DPzjke/n3f87Xt5891fzaj3HJ9Ft/050999ValLaxErVr6cj1/zYJPbNfd74ME5z+eGXzzW5P5a06e+9nBqlr/U5HbN+RrU1zfmA1+4r11M4wl0LH+seS6df/PzfHXBlv8N7/ybn+fND85ow6qAltbug67Zs2dn7Nixueaaa7Js2bKMHj0669evz3XXXZczzjgj8+a9MsR//PjxpS0UANhq3/31E1nzUl2b9vm1nzzq4Q7AdmLW3JrMmNW2v4n+i98vLNSorsdvujO/e/sV+f1ZX8rDX7gpL72wKlUD+6b+5XUbjjnyvz+eI2/4xEbtOu/YI2+ffWOGvfXwti65SX70myfz4qp1r39gC7rup3O3m58Fapa/1Oa/hPPwozX58/8+16Z9AgBsjXYddNXU1OTkk0/OsmXLctFFF6W6ujqzZs3KsmXLctVVV+W2227LzJkzU1ZWln322afU5QIAW6G+viHf+kXrrkWxObPm/SMz/9Y+puwBKLr//nnbvw/U1zfmxpsfb/N+m2vlU8tSPWNOnpn+l/ztm/+TP5z7lfQbv0cOvuoDG4554NIbs9MBe2bomw/dsO2gL783zz30WJ761fb7m+2NjY2tvi7V5jy+6MXc/dD2Me3j9379RJNHNLaEUnzdAQBeT7sOui644IIsWbIk559/fq699tr07Nlzw77Jkydn3Lhxqaury5AhQ9KrV68SVkpb6d69ew488MB07960aSoA2H7c+5dn8/fq0vxG/U2mLwQoubq6hvzsjoUl6bvI7wPPP/x4FvzyTxn65kPTf/89kyTrVqzO/Rf9dw780nvTbefeGXziQRlwyJg88MkbSlzta5s17x95fNGLJen7x7dtH98Dparj579bmJdebttR9S3NcwE6OvcA0B6126Br3rx5mTp1avr165crr7xys8dMmDAhSTJu3LgN2+65556UlZVt8mFqw/Zh9913z9e//vXsvvvupS4FgGYq5aiqmX97vmR9A/CKxxauyOo160vS94KnV2X5ypdL0ndL+Ot//jINdfXZ95IzNmx75u7ZWfSb+3PE9RfkoK+8L/df9N95efnqElb5+h6aU7r34+1hdHftmvV5dMGKkvS9bn1D/vbk8pL03VI8F6Cj66j3wJr6+tS8/PJmP4Diqyx1Aa1lypQpaWhoyFlnnZUePXps9phu3bol2TjoetU3vvGN7LfffhteV1VVtU6htKn6+vqsXbs23bp1S0VFRanLAaAZHplbugdMf33ihdTVNaSyst3+rhDAdu+Ruf8oaf+z5v4jbzhol5LW0FyrFi3Lwv+5L3ucdkR2OnBUnnvwlWnoHr7iR3nzjP/KM9P/kiV/mFXiKl9fKX8WmPvUiqxZW5fu3Ur3OGX24y+koaF0a4U9Mvcf2X9M/5L1v608F6Cj66j3wOcffzSff/zRUpcBtJJ2+5Rm+vTpSZJJkyZt8ZglS5Yk2XzQNXr06Bx00EEbPsaOHds6hdKm5s+fn6OPPjrz588vdSkANNPcp1aUrO+XXq7PwmdWlax/AJK5T5V2NEmp+99W//u1m9NQv/Gorrq1L2f14ueyfN7fS1jZ1ivlzwINDY15YnFppk181dwFJb4HStz/tvJcgI6uo94D7919WH570JGb/QCKr92O6Fq8eHGSZPDgwZvdX1dXl/vuuy/J5oOulrT//vtn2bJlrdpHR/W2t72tScc/99xzSZLf/va3eeSRR7aqzVve8pYm1wVA61m2wwVJRd/N7ps55ZQM6LflueYH9Ou24c+nf3/ma/dTsyYHvGPaJtsPPeIN6VzvfR2gVFZ0f1PS9cDN7muL94H/73NfyFWT721Cxc3TqbE8l2Vik9ste+DR/GDglv+f9OL8Z/KjQWdscf+2GDliZNaXNbTKuf/Vs70+lFQO2Oy+tvgeOPb4k9Kl7ukmVNyyVnc5KKk6YbP7Xu/6k63/Gmzp+r/zvZty8/WnN6Hi1tUWzwUSzwbYvjXlPijSPdCtvDxzxx/cIuca3qNH3tB/5xY515aMHDkyaxta/32wud7yno+lqkevVC+rzqBBgzZ53d519OtPts+vQcO/3DOHHXZY/vKXvzTrPO026KqtfWWR+rVr1252/9SpU1NTU5OePXtm6NChm+w/44wzUlNTk759++aUU07JV77ylfTr169ZtSxbtizPPPNMs9ry2l79e95ar34/rF27dqvb+rsD2M5U1SVbmGFjQL/uGbTz6083XFlRvlXHbc7zzz2bvOS9AaBkBq5Oum5+V1u8D6x88cWsrGn994HOZRVJ6z6Pa3FLq5dmXWN963fUbd0Wn2a0xfdAzfPPJ2tK+LNA3xXJFkrf2utPmv81WLOmNmu2o/8nt8VzgcSzAbZvTfleLtI90L2iIhnf5t0229KlS7Omvg3eB5up4Z+1NdTX55lnntnkdXvX0a8/2f6/Bs8++2yz27bboGvAgAFZvnx5Zs2alYMP3jj5r66uziWXXJIk2WeffVJWVrZh3w477JBLLrkkRxxxRHr06JEHHnggV155Zf785z/n4YcfTteuW/gf1evUQuto6tppr76Bd+vWbavb7rrrrk2uC4DW81xFfdZvYd+ymjWv2XZAv26prChPXX1DltVs/pdhXu9cO/ffMZUlXBcDoKN7sVunrN7CvrZ4H9ihV7f06NL6/0fo1FiebL+/FL5ZuwzcpU1GdD1f2Zh1W9jXFt8DO/XbIZ3qS/f/xNrO3bJiC/te7/qTrf8abOlcVd07Zcft6P/JbfFcIPFsgO1bU76Xi3QPdCsv1qo7u+yyy3Y9oqv8n2uylVdUZNddd93kdXvX0a8/2T6/Bg0NDamurk6S7Lxz83/Lq90GXcccc0zmzZuXq666Kscee2xGjhyZJJk5c2bOPvvs1NS8snjt+PHjN2q37777Zt99993w+qijjsree++dU045JVOmTMl73vOeJtfy8MMPN/9CeE0zZ85s0vGPPfZYpkyZkhNOOCF77bXXVrX5r//6r2ZUBkBrOefTf8xNtz652X2bm17nXz39+zMzaOeqLKtZm92O/VmT+67qVpln/vLXVFQU6z9cAO3JT29bkLMuvWez+1r7fSBJpk39Ro7Yf2Cz2jbF+jUv5Sd7vKvV+3nVHaddts3neGL+E+nUvem/HNpUH/rCffnWLx7b7L7W/h7oVFmev89/KF06b2F4eRt4aM7zOfCszV/n611/su1fg+uumpz/eMt3mtyutbTFc4HEswG2b025D4p0DzS+9FLq3n5um/fbXE888UTKmjFIoq18+Rs/ycrVtRk4YGCWLFmyyev2rqNff7J9fg1qa2vTo0ePJMm99zZ/evB2+5Rm8uTJ6du3b55++umMGTMmY8eOzYgRIzJx4sQMGzYsRx99dJKtW5/rpJNOSlVVlcCqHRg+fHh+97vfZfjw4aUuBYBmmjB68+tztYX9RvUVcgGU2P5jmjelfEsoK0v2HVW69yFeUcrvgbEjepc05EqSfUb2TmVl2esf2EpK+bNYS/BcgI7OPQC0R+32Sc2gQYMyY8aMnHjiienatWsWLVqUPn365IYbbshtt92WJ554IsnWBV2v+tcpDimmysrK9O7dO5WV7XYwI0C7d+DYnTpk3wC8YvjuvdJnhy4l6Xv0sB3Ts6pzSfrm/xw4tn+H7PtVXbtUZvyepQmbqrpVZvSw3iXpu6V4LkBH5x4A2qN2G3QlyahRo3Lrrbdm1apVWbVqVR588MG8//3vT21tbRYtWpTy8vLsvffer3ueadOmpba2NhMnTmyDqmlNS5YsyUUXXdRhhqMCtEcH7tM/ew7ZoSR9n3uK33oEKLXy8rKcfVJp/j1+96kjS9IvGxszvHf2K9HIunNPGVGSfv/du08tTR3vOml4OnUq9qMkzwXo6DraPXBkv52y7uS35xN7bHmaxnUnvz23HHh4G1YFtLRi/3TSTI8++mgaGxszYsSIdO/efaN973rXu/K5z30ut9xyS+6666584QtfyLve9a6MHz8+Z555ZokqpqWsXr06M2bMyOrVW1q+GoDtXVlZWT58xqg27/eICQOy94g+bd4vAJv60Nu3fk2RltKlc0Xe8+btI+To6Er1s8B+o/pm4nYwoitJzj5peKq6tf1ojFLcey3NcwE6OvcA0B51yKBrzpw5STY/beGYMWPy61//Ouecc05OOOGEfO9738v73ve+3HPPPenc2RQVALA9OOfk4W0+bdXHzx7Tpv0BsGV7Dt0xJx6xW5v2ee4pw9N3x+13gfmO5h0n7JEB/bq1aZ8fP3vv7WZJg149Oud9p+3Zpn0ePXFgxpVoykQAgNfSISdjfa2g69JLL82ll17a1iUBAE2wY68u+fqnDs5Zl97TJv299Q1DcuqkwW3SFwBb5xufPjh/fHhZVq9Z3+p9DezfPV/52AGt3k9L6jl0QA7/2kfTpU/PrF+1JvdeeH1WPLHxNFX9J4zMwV95X5KkrFNlnntoXh78/76XhnV1pSi5Sbp3q8y3Pnto3nzhXW3S33GH7JqzTtyjTfraWp//yH751R8W5e/Vta3eV7euFfnWZw9t9X4AAJrDiC4AoJDe8aZhOXXS7k1qs6xmTZY8W5tlNWu2uk3fHbvkm//fIdvNb3AD8IrBu/TMtRc1bR3l5rwPJMm3P3doevdq25HE2+qQqz+QJ378+/z6sAsy5/pbctjXzt/kmBfmLspvTvhUph17Sf5n0ifStd8O2evdx5eg2uY5ddLgvPNNTQufmvM90KtHp9x4+WHb3c8CPas657tXNH1NmeZ8Db780f0zYnBp1kgFAHg9HXJE1/Tp00tdAiXSv3//XHjhhenff/uYVx2A5isrK8t3Lj88Tyy+LfOeWrFVbQ54x7Qm9dG5U3l+dvWk7Ny3badGAmDrvP9te+aBvz6XH06bv1XHN/V9IEkuPW9cTjqyab9YUWpd+/ZK33F75M4zv5AkWXzbn3PQl89LzyEDsmrRsg3H1a9dt+Hzis6VqezaOWlsbPN6t8U3P3NI5j61PLMfe2Grjm/q90BFRVl+/OWjstuAHs0pr9Udc9Cu+fxH9svnvjFrq9s09WtwxvFDc8FZ7WcKZ88F6OjcA0B71CFHdNFx9e3bN2eddVb69jWvOEB70K931/z+huOz19CW/w3jLp0r8sv/94Ycc9CuLX5uAFrGK7/0cFiTR/VsrU+cs3e+dMGEVjl3a6ratV/WPrs8jfUNG7atfqYmVbv22+TYHoP655S7rs2Zj34v61auyWM/+F1blrrNdujZOb/77+Mzbs8+LX7uysqy/PQrR+Xko7bvoPP/e//4fOZ9rTNjzVvfMCQ/+tKRKS/fvkazbQvPBejo3ANAeyTookNZuXJl7rrrrqxcubLUpQDQQnbduSp/+v6JOe6QlgukdhtQlTu/ddx2/2ALgKSysjw3ffnIfPq941rsYXyXzhX5z0sOzLUXTdzupqtraauXPJ9px1ycqfu8LxVdOmXwmw4sdUlNtlPfbrnnu2/KKS34vj2gX7fc/o3j8vbjhrXYOVtLWVlZvvjR/fONTx+cbl0rWuicyUXn7J2p10xK504tc87thecCdHTuAaA9EnTRoSxdujSf/vSns3Tp0lKXAkAL6t+nW37738flO5cfll49Om3Tud771pGZc/Nbc8T+A1uoOgBaW3l5Wb50wf65/0cnbfMo3wPH9s9ffv7mfOzsvQsbctU+U5NuO/dOWcX//Ze/x679UvtMzRbb1K15KQtvuS/D3tr0NZ+2Bzv26pJbvnZMbvrykendq/M2nevsk4bn0V+flmMPLtao7g+fOTp//cVbcui+O2/TeUYM7pUZPzgp1158YCor299jI88F6OjcA0B71P5+YgEAOqSysrKc99Y98/i0t+WKD++XXXbqvtVtu3SuyDknD8+DPzklN15+eHbouW0PyAAojQP32Sl/+fmb8/0vHJ4D9t50mr7XMumAgfn5tUfn3h+elFHDdmydAtvIS/9YmRfmLMwepx2RJBl84kGprX5ho/W5kqTnkAEpq3xltE55p8rsfsLEvDBvcZvX21LKysryrpOG5/Fpb8uXL9g/uw+s2uq2nSrL88437ZF7f3hSfvTlI9Nnhy6tWGnrGTF4h/zxe2/KzV99Q445aJcmtd13r7658bLDWiQsAwBoS5WlLgAAoCUN6Nc9n/vgvvn0e8fld/cvyf2zn8sjc2vy1ydeyIur16W+vjHdu1Zm5OAdsv+Yfpkwul9OnbR7+u7YtdSlA9ACunapzLtPHZl3nzoyj8ytyR/+vDSPzKvJw4/W5Nl/rM269Q3p0rkig3bungmjX3kfOO6QXTN6j96lLr1F3T/5hhz2Xx/J2AvemvWr1+bej30jSXLItR/M03c+nKfvfDgDD9s7o857UxrrG1JWWZHqGXPyv//5yxJXvu369+mWS987LpPfMza/f2Bp7v/rs3n40ZrMfvyFrFj1curqGtO9W2VG7N7rle+BUX1z6qTB2alvt1KX3iIqKsrz1mOG5K3HDMkTi17Mb+99Oo/M/UcenluTJc/W5qWX69O5U3l26tMtE0b3zYTR/XL0xF1ywN79CjuKEQDo2ARdAEC7VFlZnhOP2D0nHmGdLYCO6tUgqyNauWBpbj/5M5tsv//ib234/Ikf35UnfnxXW5bVpioqynP8YYNy/GGDSl1KyYwcskNGDtm26TwBALZ3pi6kQ+nSpUv23HPPdOlSzGkoAAAAgObzXICOzj0AtEdGdNGhDB06NDfddFOpywAAAABKwHMBOjr3ANAeGdEFAAAAAABAIQm66FAef/zxHHrooXn88cdLXQoAAADQxjwXoKNzDwDtkaCLDqWxsTHr169PY2NjqUsBAAAA2pjnAnR07gGgPbJGFwAAAGxnKrt1yVkLflzqMpqksluXUpcAQHvSpUsqf/7DUlex9bp4H4RSEXQBAADAdqasrCydunctdRkAUDJlZWVJV++FwOszdSEAAAAAAACFZEQXHcqQIUMyZcqU7LrrrqUuBQAAAGhjngvQ0bkHgPZI0EWH0rVr1+yxxx6lLgMAAAAoAc8F6OjcA0B7ZOpCOpTq6up88YtfTHV1dalLAQAAANqY5wJ0dO4BoD0SdNGhvPjii5k2bVpefPHFUpcCAAAAtDHPBejo3ANAeyToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCqix1AbAtDjjggCYdP2jQoFx22WU55phjMnDgwFaqCgAAAGgLngtA0+4D9wDQHgm66FAGDhyYyy+/vNRlAAAAACXguQAdnXsAaI9MXQgAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOjaTtTU1ORDH/pQdtlll3Tp0iVDhw7NjTfeWOqyAAAAAABgE7fffnvGjx+fLl26ZMiQIfnqV79a6pLa1J/+9KeceuqpGTx4cMrKyvLFL36x1CW1qWuuuSYHH3xwevfunR133DGHHXZY7rjjjpLUUlmSXtnI6tWrc8QRR2TXXXfNlClTMnjw4FRXV6e+vr7UpQEAAAAAwEYefvjhnHrqqbn44oszZcqUPPjgg/ngBz+Y7t2754Mf/GCpy2sTq1evzujRo/POd74zH/vYx0pdTpubPn16/uM//iMHHHBAunfvnu985zs56aST8sc//jGHHnpom9Yi6NoOXHPNNVmzZk1uvfXWdOnSJUkyZMiQ0hYFAAAAAACb8dWvfjUHHHBArrzyyiTJqFGj8uijj+YrX/lKhwm63vSmN+VNb3pTkuSTn/xkiatpe7/97W83en311VfnjjvuyK9+9as2D7pMXbgduPnmm3PYYYfl4x//eAYOHJi99torl1xySdasWVPq0gAAAAAAYCP33Xdfjj/++I22HX/88Vm8eHGWLFlSoqoopYaGhqxcuTJVVVVt3rcRXduBBQsW5Mknn8zb3va2/OY3v8nSpUtz/vnnZ+nSpfnJT35S6vIAAAAAACiAF15claXLajbZXldXt+HPvz2+cJPX/2rk0EHp3LnTa/ZTXV2dAQMGbLTt1dfV1dUZNGhQs69hWzQ0NGTuk4uTxo23N+X6+/fdMTv3690m9baGJdXPZ8XK1Zts39qvQWVlRfYctlvKysqa1O+Xv/zlrFixIu9///u3ofrmEXRtBxoaGtK3b998//vfT6dOr/wDsm7dupx++un5+te/nj59+pS4QgAAAAAAtnfdu3bJrdMf2GzQkSRrXno5P77l91t8vffIoRkzckhrl9lqysvLs2jJstw7c85m97/e9Xft0jkf+4+3tXqdramsvCxTpv0h9Q0Nm93/el+Dk95wcPYq271JfX7zm9/Ml7/85UybNq0kIaepC7cDAwcOzMiRIzeEXEkyZsyYJMnixYtLVRYAAAAAAAXStUvnvP3Eo9K0sTiv6FHVLW857vCtGskzcODALFu2bKNtzz777IZ9pXTcEQc0e0TWqccemh179WjhitrWrjv3yzGHTWhW2+GDd80hE/ZuUptrr702l1xySaZNm5ZjjjmmWf1uK0HXduDwww/Pk08+uWGoYJI8/vjjSZIhQ4aUqCoAAAAAAIpm2O675PCJ+zS53dtOODJV3btu1bGHHnpofve732207Y477sjgwYNLNm3hqzpVVubtJ01KRXnT4o+xew7L+NHDW6mqtnXEgeMyeNedm9Sma5fOedubjkx5E6Ys/NznPpcrrrgit99+e8lCrkTQtV24+OKL8/zzz+fDH/5wHnvssdx99925+OKLc84556R37+LOBQoAAAAAQNs79vD9mzSq6cDxo7LXHls/Xd3HP/7xPPTQQ/nMZz6Txx57LD/84Q/z9a9/PZ/61KeaU26La+qopp49uufNxx3WpHWpVq9endmzZ2f27NlZt25dli1bltmzZ+fJJ59sTsktqqK8PG8/cVI6d9r61auaOprtYx/7WK655prcdNNN2XPPPbNs2bIsW7YsL774YnNK3iZljY2Nja9/GK3tD3/4Qz71qU9lzpw5GTBgQE4//fRcccUV6d69e6lLAwAAAACgYJY+949844e/3uJaTa/q27tXLnj3aenSudNrHvfvbrvttnz605/OY489lgEDBuTCCy/MJz7xiW0puUU1NDTkhp/+JoufefZ1j33P247Pnk0I+pLknnvuyaRJkzbZfuSRR+aee+5p0rlay4Oz5+XXv5vxusfts9ewvOOUNzQp6NvSseeee25+8IMfbNU5amtr06PHK+Ha6tWrU1VVtdX9b1SLoAsAAAAAANqfe/48O3f88aEt7i8rK8uHzjoluzdxmrui+Mfylfna93+ZdevrtnjMQfuOzpvfeFgbVtV2Ghsb88Obf5fHFvx9i8f07NE9H/+Pt6V7t62btrIltVTQZerCglm0ZFlWrV5T6jIAAAAAANjOHTFxnwwZNGCL+ycdNL7dhlzJK6PVTnrDIVvc36/3DnnTUQe2YUVtq6ysLKcdf0S6d+uyxWNOP+HIkoRcLUnQVSDr6+ry0/+5K1ffMCWLlywrdTkAAAAAAGzHysvLc/qJR6XzZqYl3HXnfnnDoVu/jlVRHbDPnhk1fNNpCcvLyvL2kyZt9mvTnvTs0T1vPe6Ize47aN/RGTlstzauqOUJuv5NfX19brrpprzxjW9M//7906VLl+y+++45/vjj853vfCf19fUlq23mXx/LytVr0r1b1+w6oH/J6gAAAAAAoBj67tgrJx998EbbKisr8vaTJqWiov1HBGVlZXnr8Uek6t9GLR118L7ZfZedSlRV29p7z6HZb++RG23r16f9jGZr/9/FTbBy5coce+yxOeecc/L73/8+nTt3zrhx49LQ0JA777wz73vf+7Jq1aqS1La+ri73/Hl2kmTSwfumsrKiJHUAAAAAAFAs+//bqKbjj5yYnfv1LmFFbatnVfe89fj/G9W064B+ecMh+5WworZ3yjGHZMder6yHVV5WljNObD+j2QRd/+K8887L3XffnUGDBmX69Ol55pln8tBDD2XJkiWprq7Ol770pXTqVJq/+FdHc+3Qsyr7j92zJDUAAAAAAFA8G0Y1de+a4YN3zSET9i51SW1uzMghmTB2ZCorK3LGiR1jNNu/6tqlc95+4lEpSzLpkH2zWzsazVbW2NjYWOoitgePPPJI9t9//1RWVuYvf/lL9t675W70r//wV1m1eu02nKExq2rXprGxMV27dE7nEoVtAAAAAAAU1/q6ulSUl6e8vGOFPK9qbGxMXV19OnWqLHUpJbNu/fp0qqxMWVlZqUvJupdfyhUXvTdJcs0NP8nF739ns87Tcf82/80tt9ySJDnxxBNbNORKklWr12bl6toWOddLL6/LSy+va5FzAQAAAABAR7P25ZdLXUJJbS8Zw7p1//f3sHobBgsJuv5p7ty5SZKDDz74dY5sup49um1Da6O5AAAAAACA9mXdyxUbPu+xDTmKoOufVq5cmSTZYYcdWvzcHz33rc1ue/8jf8u0u+7PDj2rcsn7z0xlZcXrNwIAAAAAANiO1dbWbpi68ENnndrs8wi6/qlXr15JkhdffLHFz938NbpeGc2VJC+vW5+rb/hZyxYGAAAAAABQAo2Njbns/30nSfLdX9yRC959WrPOI+j6pzFjxuRXv/pVHnjggRY/d0us0WVtLgAAAAAAoD1aXftSs9sKuv7pLW95S77whS/k9ttvz9y5czN69OgWO3fz1uiyNhcAAAAAAND+NS9HeUVZY2NjYwvWUmhnnHFGfv7zn2f33XfPj370oxx55JEb9j377LP53ve+lwsuuCBVVVWtXou1uQAAAAAAAF6boOtfrFy5MqeeemruueeeJMmuu+6aXXbZJdXV1XnmmWfS2NiY5cuXZ8cdd2zVOtbX1eWaG36WlavX5M1vPCwH7dtyo8sAAAAAAADai/JSF7A96dWrV+66665897vfzVFHHZU1a9bkr3/9a8rLy3Pcccflu9/9bnr27Nnqdcz862NZuXpNduhZlf3H7tnq/QEAAAAAABSREV3boTmPP5U77nkoh0/cx2guAAAAAACALRB0bafqGxqSxqSiwqA7AAAAAACAzRF0AQAAAAAAUEiGCwEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABRShwi6ampqMnny5AwfPjxdu3bNbrvtlgsvvDC1tbU577zzUlZWluuvv77UZQIAAAAAANAElaUuoLXNnj07J5xwQpYtW5aqqqqMHj06S5cuzXXXXZcFCxbkhRdeSJKMHz++tIUCAAAAAADQJGWNjY2NpS6itdTU1GTffffNkiVLctFFF+Wyyy5Lz549kyRXX311PvnJT6aysjL19fVZsWJFevXqVeKKAQAAAAAA2FrtOuh65zvfmSlTpuT888/P17/+9U32jx8/Pn/9618zdOjQPPXUUyWoEAAAAAAAgOZqt2t0zZs3L1OnTk2/fv1y5ZVXbvaYCRMmJEnGjRu30faFCxfmlFNOSc+ePdO7d++cc845+cc//tHqNQMAAAAAALD12m3QNWXKlDQ0NOSss85Kjx49NntMt27dkmwcdK1atSqTJk3KkiVLMmXKlHz729/OjBkzctJJJ6WhoaFNagcAAAAAAOD1VZa6gNYyffr0JMmkSZO2eMySJUuSbBx0ffvb384zzzyTP/3pT9l9992TJIMGDcohhxySadOm5c1vfvNW19DY2Jg1a9YkSbp3756ysrKmXgYAAAAAAABb0G6DrsWLFydJBg8evNn9dXV1ue+++5JsHHTdeuutOeywwzaEXEly8MEHZ9iwYfnNb37TpKBrzZo1G0aTDRw4MOXl7XYAHQAAAAAAQLMMGDAgDz/8cLPattugq7a2Nkmydu3aze6fOnVqampq0rNnzwwdOnTD9rlz5+b000/f5PgxY8Zk7ty5za6nurq62W0BAAAAAADYVLsNugYMGJDly5dn1qxZOfjggzfaV11dnUsuuSRJss8++2w0peDy5cuz4447bnK+Pn365PHHH292PUZ0AQAAAAAAbGrAgAHNbttug65jjjkm8+bNy1VXXZVjjz02I0eOTJLMnDkzZ599dmpqapIk48ePb5N65s+fn6qqqjbpCwAAAAAAoCNot0OMJk+enL59++bpp5/OmDFjMnbs2IwYMSITJ07MsGHDcvTRRyfZeH2uJOndu3dWrFixyfleeOGF9OnTpy1KBwAAAAAAYCu026Br0KBBmTFjRk488cR07do1ixYtSp8+fXLDDTfktttuyxNPPJFk06Br1KhRm12La+7cuRk1alSb1A4AAAAAAMDra7dTFyavhFa33nrrJttXr16dRYsWpby8PHvvvfdG+0466aR8+tOfzpIlSzJo0KAkyYMPPpgFCxbkmmuuaZO6AQAAAAAAeH1ljY2NjaUuoq09+OCDOeigg7Lnnnvmscce22jfypUrM3bs2PTr1y9XXHFFXnrppUyePDn9+/fPAw88kPLyrR8EV1tbmx49eiR5JVyzRhcAAAAAAEDLabdTF76WOXPmJNl02sIk6dWrV6ZPn56BAwfmzDPPzHvf+94ccsghufXWW5sUcgEAAAAAANC62vXUhVvyWkFXkuyxxx6bnfIQAAAAAACA7UeHHKL0ekEXAAAAAAAA278OuUZXW7FGFwAAAAAAQOvpkCO6AAAAAAAAKD5BFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgELqEEFXTU1NJk+enOHDh6dr167ZbbfdcuGFF6a2tjbnnXdeysrKcv3115e6TAAAAAAAAJqgstQFtLbZs2fnhBNOyLJly1JVVZXRo0dn6dKlue6667JgwYK88MILSZLx48eXtlAAAAAAAACapF2P6KqpqcnJJ5+cZcuW5aKLLkp1dXVmzZqVZcuW5aqrrsptt92WmTNnpqysLPvss0+pywUAAAAAAKAJ2nXQdcEFF2TJkiU5//zzc+2116Znz54b9k2ePDnjxo1LXV1dhgwZkl69epWwUgAAAAAAAJqq3QZd8+bNy9SpU9OvX79ceeWVmz1mwoQJSZJx48Zt2PZqMDZx4sR06dIlZWVlbVIvAAAAAAAATdNug64pU6akoaEhZ511Vnr06LHZY7p165Zk46DrySefzM0335wBAwbkgAMOaJNaAQAAAAAAaLp2G3RNnz49STJp0qQtHrNkyZIkGwddRxxxRKqrqzNt2rQcc8wxrVskAAAAAAAAzVZZ6gJay+LFi5MkgwcP3uz+urq63HfffUk2DrrKy1sn+xsxYkSrnRsAAAAAAKCoBgwYkIcffrhZbdtt0FVbW5skWbt27Wb3T506NTU1NenZs2eGDh3a6vVUV1e3eh8AAAAAAAAdSbsNugYMGJDly5dn1qxZOfjggzfaV11dnUsuuSRJss8++6SsrKzV6xk4cKARXQAAAAAAAP9mwIABzW7bboOuY445JvPmzctVV12VY489NiNHjkySzJw5M2effXZqamqSJOPHj2+TeubPn5+qqqo26QsAAAAAAKAjaLdDjCZPnpy+ffvm6aefzpgxYzJ27NiMGDEiEydOzLBhw3L00Ucn2Xh9LgAAAAAAAIqj3QZdgwYNyowZM3LiiSema9euWbRoUfr06ZMbbrght912W5544okkgi4AAAAAAICiardTFybJqFGjcuutt26yffXq1Vm0aFHKy8uz9957l6AyAAAAAAAAtlW7Drq25NFHH01jY2NGjhyZ7t27b7L/l7/8ZZJk7ty5G70eMmRI9t9//7YrFAAAAAAAgC3qkEHXnDlzkmx52sLTTz99s6/PPffc/OAHP2jV2gAAAAAAANg6gq7NaGxsbMtyAAAAAAAAaIbyUhdQCq8XdAEAAAAAALD9K2s0fKnV1NbWpkePHkmS1atXp6qqqsQVAQAAAAAAtB8dckQXAAAAAAAAxSfoAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAAqpQwRdNTU1mTx5coYPH56uXbtmt912y4UXXpja2tqcd955KSsry/XXX1/qMgEAAAAAAGiCylIX0Npmz56dE044IcuWLUtVVVVGjx6dpUuX5rrrrsuCBQvywgsvJEnGjx9f2kIBAAAAAABoknY9oqumpiYnn3xyli1blosuuijV1dWZNWtWli1blquuuiq33XZbZs6cmbKysuyzzz6lLhcAAAAAAIAmaNdB1wUXXJAlS5bk/PPPz7XXXpuePXtu2Dd58uSMGzcudXV1GTJkSHr16lXCSgEAAAAAAGiqdht0zZs3L1OnTk2/fv1y5ZVXbvaYCRMmJEnGjRu3Ydsvf/nLnHbaaRk8eHC6d++evfbaK5/5zGeyevXqNqkbAAAAAACArdNug64pU6akoaEhZ511Vnr06LHZY7p165Zk46Dr2muvTUVFRb785S/nt7/9bT70oQ/lv//7v3P88cenoaGhTWoHAAAAAADg9VWWuoDWMn369CTJpEmTtnjMkiVLkmwcdP3mN79J//79N7w+8sgj079//5x11lm59957c8QRR7RSxQAAAAAAADRFuw26Fi9enCQZPHjwZvfX1dXlvvvuS7Jx0PWvIder9t9//yTJM8880+x6RowYkfLydjuADgAAAAAAoFkGDBiQhx9+uFlt223QVVtbmyRZu3btZvdPnTo1NTU16dmzZ4YOHfqa57r77ruTJKNGjWp2PdXV1c1uCwAAAAAAwKbabdA1YMCALF++PLNmzcrBBx+80b7q6upccsklSZJ99tknZWVlWzzPM888k89+9rM5/vjjM378+GbXM3DgQCO6AAAAAAAA/s2AAQOa3bbdBl3HHHNM5s2bl6uuuirHHntsRo4cmSSZOXNmzj777NTU1CTJa4ZXq1evzqmnnprOnTvne9/73jbVM3/+/FRVVW3TOQAAAAAAAPg/7XaI0eTJk9O3b988/fTTGTNmTMaOHZsRI0Zk4sSJGTZsWI4++ugkG6/P9a/Wrl2bk08+OQsXLsydd96ZgQMHtmX5AAAAAAAAvI52G3QNGjQoM2bMyIknnpiuXbtm0aJF6dOnT2644YbcdttteeKJJ5JsPuhav3593va2t+Xhhx/Ob3/724wePbqtywcAAAAAAOB1lDU2NjaWuoi2tnr16vTq1StlZWVZtWpVunfvvmFfQ0NDzjzzzEybNi233377hpFfzVFbW5sePXps6NPUhQAAAAAAAC2n3a7R9VoeffTRNDY2ZuTIkRuFXEnykY98JL/4xS/yqU99Kt27d8+f//znDfv22GOP9O/fv63LBQAAAAAAYDPa7dSFr2XOnDlJNj9t4W9/+9skyVe+8pUcfPDBG33cdtttbVonAAAAAAAAW9YhR3S9VtC1aNGiNq4GAAAAAACA5jCiCwAAAAAAgEIqa2xsbCx1Ee1VbW1tevTokSRZvXp1qqqqSlwRAAAAAABA+9EhR3QBAAAAAABQfIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkCpLXQCb19jYmPr6+lKXsdUqKipSVlZW6jIAAAAAAIAORNC1naqvr8/NN99c6jK22mmnnZbKSt9OAAAAAABA2zF1IQAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXWy1hoaGUpcAAAAAAACwQWWpC6B1rV+/Pn//+9+zcOHCrFixInV1damsrMyOO+6YoUOHZvfdd0+nTp1e9zzTpk3Lo48+mosuuiidO3dug8oBAAAAAABem6CrHaqvr88jjzyS3//+95k7d27q6+u3eGxFRUVGjx6dY489NhMmTEhFRcUmx0ybNi0//elPkyT/7//9v0yePHmzxwEAAAAAALSlDjF1YU1NTSZPnpzhw4ena9eu2W233XLhhRemtrY25513XsrKynL99deXusxt1tjYmHvuuScf/ehH89WvfjVz5sx5zZAreSUUmzNnTr761a/mox/9aO655540NjZu2P+vIVeSjBo1SsgFAAAAAABsF9r9iK7Zs2fnhBNOyLJly1JVVZXRo0dn6dKlue6667JgwYK88MILSZLx48eXttBt9MILL+TGG2/MX/7yl4229+vXL3vttVeGDRuWgQMHplOnTlm/fn2qq6uzcOHCzJs3LzU1NRvO8a1vfSsPPvhg3ve+9+Xee+/dKOQ688wz8+Y3v7ktLwsAAAAAAGCLyhr/dfhOO1NTU5N99903S5YsyUUXXZTLLrssPXv2TJJcffXV+eQnP5nKysrU19dnxYoV6dWrV4v2X1tbmx49eiRJVq9enaqqqq1uW1dXl5tvvnmrjl2wYEG+8pWvZNWqVRu27bvvvjn++OMzduzYlJdveeBeQ0ND5syZkzvuuGOjkKxz585Zt27dhtevF3Kddtppqaxs97kpAAAAAACwHWnXycQFF1yQJUuW5Pzzz8+111670b7Jkyfnpz/9af76179m6NChLR5ytZUFCxbki1/8YtauXZsk6d27d9773vdmwoQJW9W+vLw848aNy7hx4/LII4/kO9/5TpYvX96kkAsAAAAAAKAU2u0aXfPmzcvUqVPTr1+/XHnllZs95tUwaNy4cRu2zZgxI8ccc0wGDhyYLl26ZNCgQTnjjDMyb968Nqm7Kf7xj3/kyiuv3BByjRo1Ktdcc81Wh1z/bsKECTn66KM32ta5c+ccfvjh21wrAAAAAABAS2u3QdeUKVPS0NCQs846a8P0gf+uW7duSTYOupYvX56xY8fmuuuuy5133pmrrroqjz76aA4++OAsWbKkTWrfGo2Njfn2t7+d1atXJ3kl5Lr00ku3eK1bY9q0aZtMl7hu3brceOONacczXAIAAAAAAAXVbqcunD59epJk0qRJWzzm1eDqX4OuU045JaeccspGxx1wwAHZc889c/PNN+fCCy9shWqb7o9//GP++te/JnllusKLLroonTt3bvb5pk2blp/+9KcbXr/1rW/N3XffneXLl2f27Nn54x//mKOOOmpbywYAAAAAAGgx7TboWrx4cZJk8ODBm91fV1eX++67L8nGQdfm9O3bN0lSWdn8L9eIESNSXr71A+g6d+68xSkX6+rqMnXq1A2v3/e+923zSK5/DbleXZNrjz32yDXXXJMk+fnPf57DDz88FRUVmz3HyJEjN1rXCwAAAAAAYGsMGDAgDz/8cLPattugq7a2Nkk2rF/176ZOnZqampr07NkzQ4cO3WR/fX19Ghoasnjx4lx66aUZMGBA3v72tze7nurq6iYd36VLly3umzVrVpYvX54k2W+//bLffvs1u64thVzJK2t27bfffpk1a1ZeeOGFPPLII5k4ceJmz7N06dK8/PLLza4DAAAAAACgqdpt0DVgwIAsX748s2bNysEHH7zRvurq6lxyySVJkn322SdlZWWbtD/yyCM3jPgaPnx4pk+fnv79+ze7noEDBzZ5RNeW/P73v9/w+XHHHdfsml4r5PrX88+aNWtDv1sKunbZZRcjugAAAAAAgCYbMGBAs9u226DrmGOOybx583LVVVfl2GOPzciRI5MkM2fOzNlnn52ampokyfjx4zfb/rvf/W5WrFiRhQsX5pprrskb3/jG3Hfffdl9992bVc/8+fNTVVW11cfX1dXl5ptv3mT7unXrMnfu3CRJ//79M3bs2GbVszUhV5KMHTs2/fv3z/PPP5+5c+dm/fr16dSp0ybHPfHEE9s0tSMAAAAAAEBTbf0Qo4KZPHly+vbtm6effjpjxozJ2LFjM2LEiEycODHDhg3L0UcfnWTL63PtueeeOfDAA3PmmWfmD3/4Q1atWpWrr766LS9hs55++unU19cnSUaNGtWkUWKv2tqQK0nKy8uz1157JXllOse///3vTS8aAAAAAACgFbTboGvQoEGZMWNGTjzxxHTt2jWLFi1Knz59csMNN+S2227LE088kWTLQde/2nHHHTN8+PA8+eSTrV3261q4cOGGzze3ttjraUrItbl+nnrqqSb3CQAAAAAA0Bra9Vxzo0aNyq233rrJ9tWrV2fRokUpLy/P3nvv/brnee655/L444/nwAMPbI0ym2T58uUbPh84cGCT2jYn5EpeWX/rVStWrGhSnwAAAAAAAK2lXQddW/Loo4+msbExI0eOTPfu3Tfa9653vSvDhw/P+PHjs+OOO2b+/Pn5z//8z1RWVubjH/94iSr+P6NHj05ZWVnWr1/fpMXZ5s+f36yQK3llEbhTTz01nTp1yqhRo5paMgAAAAAAQKvokEHXnDlzkmx+2sKDDjooP/rRj/K1r30tL730UnbbbbdMmjQpn/70pzN48OC2LnUTY8aMyZgxY5rcbsSIETnjjDMyderUJoVcyStB1zve8Y4m9wkAAAAAANCaBF3/5vzzz8/555/f1iW1ibe85S0ZM2ZMRo4cWepSAAAAAAAAtll5qQsohdcKuto7IRcAAAAAANBedMgRXdOnTy91CQAAAAAAAGyjDjmiCwAAAAAAgOITdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAAqprLGxsbHURbRXtbW16dGjR5Jk9erVqaqq2uq2jY2Nqa+vb5E6rrlhalbV1qZnVVUu+cAZW9y2LSoqKlJWVrbN5wEAAAAAANhalaUugM0rKytLZWXL/PU0JmlofOXPV8+5uW0AAAAAAABFYupCAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhVZa6ANicxsbG1NfXl7qMJqmoqEhZWVmpywAAAAAAgA5D0MV2qb6+PjfffHOpy2iS0047LZWVbikAAAAAAGgrpi4EAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqCLDqGhoSHLly/PsmXL8txzz2XVqlVNal9XV5dbbrkl69ata6UKAQAAAACApqosdQHQWhYuXJj77rsvTz31VBYuXJi1a9dutL93794ZOnRoRowYkSOOOCJ9+/bd7Hnq6uryta99LTNnzsy8efNy0UUXpXPnzm1xCQAAAAAAwGsQdNGuNDQ05P7778/vfve7zJ8//zWPXb58eZYvX55Zs2blF7/4RSZMmJCTTjope+6554Zj/jXkSpK5c+dm8eLFGTFiRKteBwAAAAAA8Pra/dSFNTU1mTx5coYPH56uXbtmt912y4UXXpja2tqcd955KSsry/XXX1/qMmkBzz33XL70pS/l+uuv3yTk6tOnT/bdd98ceuihOeSQQzJmzJh07959w/6GhobMnDkzl112Wb73ve/lpZde2iTk6tSpUy6++GIhFwAAAAAAbCfa9Yiu2bNn54QTTsiyZctSVVWV0aNHZ+nSpbnuuuuyYMGCvPDCC0mS8ePHl7ZQttl9992Xb3/723n55Zc3bNt9993zxje+Mfvvv3923HHHTdo0Njamuro69913X6ZPn57ly5cnSe68887MmjUrO++8cx599NEk/xdyjRs3rk2uBwAAAAAAeH3tNuiqqanJySefnGXLluWiiy7KZZddlp49eyZJrr766nzyk59MZWVlysrKss8++5S4WrbFXXfdle985zsbXvfr1y/vfe97M27cuJSVlW2xXVlZWXbZZZecfvrpectb3pK77rorU6ZMycsvv5yamprU1NQkEXIBAAAAAMD2qt1OXXjBBRdkyZIlOf/883PttdduCLmSZPLkyRk3blzq6uoyZMiQ9OrVq4SVsi3uu+++jUKuI444IldffXXGjx//miHXv6usrMzxxx+fL3/5y6mqqtpo37nnnivkAgAAAACA7VC7DLrmzZuXqVOnpl+/frnyyis3e8yECROS5DUDjBNOOCFlZWW5/PLLW6NMttFzzz2Xb3/72xten3zyyfnQhz600dpbTVFXV5ef/exnqa2t3Wj7nXfembq6um2qFQAAAAAAaHntMuiaMmVKGhoactZZZ6VHjx6bPaZbt25Jthx0/fznP8/s2bNbq0S2UUNDQ2644YYNa3IdccQReec739mkUVz/qq6uLl/72tcyc+bMJK9MV9i/f/8kyd///vf8+te/bpnCAQAAAACAFtMug67p06cnSSZNmrTFY5YsWZJk80HXypUr87GPfSzXXntt6xTINrv//vvz6KOPJnllTa53v/vdLRpyXXzxxfnEJz6RioqKJMktt9ySZcuWtUzxAAAAAABAi6gsdQGtYfHixUmSwYMHb3Z/XV1d7rvvviSbD7o+85nPZOTIkTnrrLPyrne9q0VqGjFiRMrLS5MrvuU9H0tVj16pXladQYMGbXHb9qRz585bnHYySe64444Nn7/3ve/dpukKNxdyvfp9cfLJJ+eWW25JfX19/vCHP+Sss87a4rlGjhyZdevWNasOAAAAAADoqAYMGJCHH364WW3bZdD16hpLa9eu3ez+qVOnpqamJj179szQoUM32vfwww/nxhtvzCOPPNKiNVVXV7fo+Zqiob5+w5/PPPPMFrdtT7p06bLFfU899VSefPLJJK+Ema+1ztpreb2QK3llnbZbb701dXV1ufvuu3P66aenc+fOmz3f0qVLN0ylCAAAAAAAtL52GXQNGDAgy5cvz6xZs3LwwQdvtK+6ujqXXHJJkmSfffbZaLq7+vr6fOADH8j555+fMWPGtGhNAwcOLNmIrvJ/Tr9XXlGRXXfddYvbtidbCpOSV6YtfNWxxx7brCkLtybkSpIddtghBx10UO69996sXr06//u//5v9999/s+fcZZddjOgCAAAAAIAmGjBgQLPbtsug65hjjsm8efNy1VVX5dhjj83IkSOTJDNnzszZZ5+dmpqaJMn48eM3anf99dfn2WefzeWXX97iNc2fPz9VVVUtft6t8eVv/CQrV9dm4ICBG9Ym29y27UldXV1uvvnmze5bsGDBhs8POOCAZp17a0KuV+2///659957k7wymmxLQdcTTzyRysp2eUsBAAAAAMB2qTRDjFrZ5MmT07dv3zz99NMZM2ZMxo4dmxEjRmTixIkZNmxYjj766CQbr89VU1OTz372s/nc5z6Xurq6rFixIitWrEiSvPTSS1mxYkUaGhpKcTn8i4aGhixatChJ0qdPn+ywww5Nat/UkCtJhg0btuHzhQsXNr1oAAAAAACgVbTLoGvQoEGZMWNGTjzxxHTt2jWLFi1Knz59csMNN+S2227LE088kWTjoGvJkiVZtWpVPvCBD6R3794bPpLkqquuSu/evfP3v/+9JNfD/1mxYsWGtdcGDx7cpLbNCbmSpH///unWrVuSbJfrmQEAAAAAQEfVbudZGzVqVG699dZNtq9evTqLFi1KeXl59t577w3bhw8fnrvvvnuT4ydNmpRzzz037373u7dpjkhaRn19fXbeeeesW7cuffv23ep2DQ0Nue6665occiVJWVlZdt5556xcuTI77rhjc0sHAAAAAABaWLsNurbk0UcfTWNjY0aOHJnu3btv2N6jR48cddRRm20zZMiQLe6jbfXv3z9f+9rXmtyuvLw8w4YNy0MPPdSkkOtVX/nKV5rcJwAAAAAA0Lo6XNA1Z86cJGlSyEH78OY3vzkVFRXZfffd/f0DAAAAAEA7IOh6HY2Nja1ZDm3s5JNPLnUJAAAAAABACykvdQFtzYguAAAAAACA9qHDjeiaPn16qUsAAAAAAACgBXS4EV0AAAAAAAC0D4IuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIVWWugDYnIqKipx22mktdr5rbpiaVbW16VlVlUs+cMYmr1tCRUVFi5wHAAAAAADYOoIutktlZWWprGy5b8/GJA2Nr/xZWVm5yWsAAAAAAKB4TF0IAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCFVlroAYFONjY2pr68vdRlNUlFRkbKyslKXAQAAAABAByLogu1QfX19br755lKX0SSnnXZaKiv9kwIAAAAAQNsxdSEAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF3AVlmxYkXWrVtX6jIAAAAAAGCDylIXALSeVatW5cknn8xTTz2VRYsWpba2NvX19encuXN23nnnDBs2LEOHDs3gwYNTXr7l3Hv58uX5whe+kP79++eiiy5K586d2/AqAAAAAABg8wRd0M40Njbmsccey+9///s8+OCDqa+v3+xxc+bM2fD5TjvtlGOPPTZHHnlkevXqtdFxr4ZcS5cuzdKlS/P9738/H/jAB1r1GgAAAAAAYGt0iKkLa2pqMnny5AwfPjxdu3bNbrvtlgsvvDC1tbU577zzUlZWluuvv77UZcI2W7p0aS6//PJcccUVuf/++7cYcv275557Lj/5yU/ykY98JL/5zW/S0NCQZOOQK0n69++ft7zlLa1WPwAAAAAANEW7H9E1e/bsnHDCCVm2bFmqqqoyevToLF26NNddd10WLFiQF154IUkyfvz40hYK26CxsTG33357fvazn2X9+vUbtvfq1SuHHHJIRowYkaFDh6Zfv34pLy/PSy+9lKeffjpPPfVUZs+evWF01/r16/OTn/wkDz30UM4666x8+9vf3ijk+uxnP5uddtqpJNcIAAAAAAD/rl0HXTU1NTn55JOzbNmyXHTRRbnsssvSs2fPJMnVV1+dT37yk6msrExZWVn22WefElcLzdPQ0JAbb7wxd99994ZtO++8c04//fQceOCB6dSp0yZtevTokVGjRmXUqFE58cQTU11dndtvvz133XVXGhsbM3/+/FxxxRVpbGxMIuQCAAAAAGD71K6nLrzggguyZMmSnH/++bn22ms3hFxJMnny5IwbNy51dXUZMmTIJusSQRE0Njbm29/+9kYh1/HHH5+rrroqhx122GZDrs0ZOHBgzjvvvFx++eXp37//hnMnSe/evYVcAAAAAABsl9pt0DVv3rxMnTo1/fr1y5VXXrnZYyZMmJAkGTdu3IZt99xzT8rKyjb5MLUh26Pbb78999xzT5KkoqIiH/vYx/Lud787Xbt2bdb5dtppp1RUVGy0rb6+Pt27d9/WUgEAAAAAoMW126kLp0yZkoaGhpx11lnp0aPHZo/p1q1bko2Drld94xvfyH777bfhdVVVVesUCs20dOnS/OxnP0uSlJWV5aMf/WgOOuigZp9v+fLl+cIXvpBly5YlSTp16pT169dn5cqV+eEPf5iPfOQjLVI3AAAAAAC0lHY7omv69OlJkkmTJm3xmCVLliTZfNA1evToHHTQQRs+xo4d2zqFQjM0NjbmhhtuyPr165O8Ml1hS4RcS5cuTfLKmlyf+9znNozkmjFjRv7yl79se+EAAAAAANCC2u2IrsWLFydJBg8evNn9dXV1ue+++5JsPuhqaSNGjEh5eWlyxbe852Op6tEr1cuqM2jQoC1ua8/+/Xq39+vv3LnzFqfcTJLHHnssjz/+eJJk5513zplnntnsvjYXcr26Jtc555yTb33rW0mSW265Jfvuu+8WzzNy5MisW7eu2XUAAAAAANAxDRgwIA8//HCz2rbboKu2tjZJsnbt2s3unzp1ampqatKzZ88MHTp0k/1nnHFGampq0rdv35xyyin5yle+kn79+jW7nurq6ma33VYN9fUb/nzmmWe2uK09+/fr3d6vv0uXLq+5/84779zw+emnn/66x2/Ja4VcSXLkkUfm1ltvzZIlS/L4449n8eLFWwyPly5dmpdffrlZdQAAAAAAQHO026BrwIABWb58eWbNmpWDDz54o33V1dW55JJLkiT77LNPysrKNuzbYYcdcskll+SII45Ijx498sADD+TKK6/Mn//85zz88MPp2rVrs+oZOHBgyUZ0lVdUbPhz11133eK29uzfr3d7v/7OnTtvcd/KlSvz0EMPJUl69eqVAw88sFl9vF7Ilbyy9texxx6b73//+0lemRL0Pe95z2bPt8suuxjRBQAAAABAkw0YMKDZbdtt0HXMMcdk3rx5ueqqq3Lsscdm5MiRSZKZM2fm7LPPTk1NTZJk/PjxG7Xbd999N5qe7aijjsree++dU045JVOmTNniQ/7XM3/+/FRVVTXvYrbRl7/xk6xcXZuBAwZuWJdsc9vas3+/3u39+uvq6nLzzTdvdt+TTz6Z+n+OSDv00EPTqVOnJp9/a0KuVx1++OH5wQ9+kMbGxjz22GNbPOcTTzyRysp2+08KAAAAAADbodIMMWoDkydPTt++ffP0009nzJgxGTt2bEaMGJGJEydm2LBhOfroo5Ns3fpcJ510Uqqqqpo9PyS0pIULF274fMSIEU1u35SQK0m6d+++YR2zJUuWGLUFAAAAAMB2o90GXYMGDcqMGTNy4oknpmvXrlm0aFH69OmTG264IbfddlueeOKJJFsXdL3qX6c4hFJZtGjRhs83t77ca2lqyPWqYcOGJUnq6+vz9NNPN61gAAAAAABoJe16nrFRo0bl1ltv3WT76tWrs2jRopSXl2fvvfd+3fNMmzYttbW1mThxYmuUCU2yevXqDZ/369dvq9s1N+RKkr59+262fwAAAAAAKKV2HXRtyaOPPprGxsaMHDky3bt332jfu971rgwbNiz77bdfevTokQceeCBXX311xo8fnzPPPLNEFcP/efe7352VK1dm/fr1TVoT65FHHmlWyJUkhx12WEaOHJnOnTtn9913b1bdAAAAAADQ0jpk0DVnzpwkm5+2cMyYMfnpT3+a//qv/8ratWszaNCgvO9978tll12Wzp07t3WpsInBgwc3q90xxxyTVatWZfr06U0KuZJkl112yS677NKsfgEAAAAAoLUIuv7NpZdemksvvbStS4I28Za3vCXHHXfcJiMZAQAAAACgiMpLXUApvFbQBe2dkAsAAAAAgPaiQ47omj59eqlLAAAAAAAAYBt1yBFdAAAAAAAAFJ+gCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiVpS4A2FRFRUVOO+20FjvfNTdMzara2vSsqsolHzhjk9ctoaKiokXOAwAAAAAAW0vQBduhsrKyVFa23O3ZmKSh8ZU/KysrN3kNAAAAAABFZOpCAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXduJmpqafOhDH8ouu+ySLl26ZOjQobnxxhtLXdYW3XTTTZkwYUJ69+6dbt26ZdSoUfnqV7+axsbGUpdWEtOnT09FRUWGDx9e6lLaxOWXX56ysrJNPp588slSlwYAAAAAQAdSWeoCSFavXp0jjjgiu+66a6ZMmZLBgwenuro69fX1pS5ti3baaad89rOfzZ577pkuXbpkxowZ+fCHP5yKiopceOGFpS6vTS1btiznnntu3vjGN2b+/PmlLqfNDBkyJA888MBG2/r371+iagAAAAAA6IgEXduBa665JmvWrMmtt96aLl26JHklRNieHXfccRu9HjZsWG655Zbcc889HSroamhoyLve9a585CMfyUsvvdShgq6KiooMGDCg1GUAAAAAANCBmbpwO3DzzTfnsMMOy8c//vEMHDgwe+21Vy655JKsWbOm1KVtlcbGxjz00EO57777MmnSpFKX06a+8IUvpKysLJ/85CdLXUqbW7JkSQYNGpRBgwblhBNOyP3331/qkgAAAAAA6GCM6NoOLFiwIE8++WTe9ra35Te/+U2WLl2a888/P0uXLs1PfvKTJp3r70ufy0svr9toW90/p0Csq6/PEwuXbHFbknTt0jm777LTVvX14osvZtddd826devS0NCQyy67LBdccEGT6m1pL65cnWf/sWKT7f9+vVu6/iQZsuvO6dy50+v2dffdd+db3/pW/vKXv6SsrGzbi28BDQ0NWbB4af59pbSmXH/vHXqkf58dX7OfiRMn5vvf/35Gjx6dlStX5oYbbsjhhx+eO+64I8cee2xLXQ4AAAAAALymssbGxn9/Jk4Lqa2tTY8ePZK8sg5XVVXVZo/r0qVL+vbtm8WLF6dTp1cCll/+8pc5/fTT849//CN9+vTZ6j7/d96C/HTaH5pd8ztPPSb77DVsq45taGjIU089lTVr1uT+++/PpZdemmuvvTbnnXdes/vfVmteejn/9d1fZuXq2ma133PYbnn3245/3eCqpqYm48aNy3e/+90cf/zxSZLLL788P/7xj/Pkk082q++W8j+/vy8PzHq0WW07darMhe85Lf1679DktkcddVQ6d+6cO++8s1l9AwAAAABAU5m6cDswcODAjBw5ckPIlSRjxoxJkixevLhJ59pn1B4ZP3p4s+oYP3r4VodcSVJeXp7hw4dnn332yQc/+MFMnjw5n/nMZ5rVd0vp3rVLTj/xyGa3Pe2EI7dqdNbf/va3LF26NCeddFIqKytTWVmZz3/+81mwYEEqKyvz05/+tFk1tIQTjjow/fs0PahKkpOOPqhZIVeSHHzwwVm0aFGz2gIAAAAAQHMIurYDhx9+eJ588snU1dVt2Pb4448nSYYMGdLk85167KHZoefmR49tyQ49q3LqsYc2ua9/1dDQkJdeemmbztESRgwZlEMm7N3kdm857vD06tF9q4494IADMmfOnMyePXvDxwc/+MHstttumT17dk488cQm999SOneqzNtPmpTyJk6nuOew3TJx3Khm9ztr1qzstttuzW4PAAAAAABNZY2u7cDFF1+cn//85/nwhz+cT3ziE6murs7FF1+cc845J717927y+bp17ZLT33RUvjP1tq1uc/qbjkq3rl22+vjLLrsshx9+eIYNG5b169fnT3/6U6666qq85z3vaXK9reGEIydm/sIlef6FFVt1/L5jRmRsE0azVVVVZe+9Nw7Tdtppp3Tu3HmT7aWw28CdcvQh++Wu+x7ZquO7d+uSt23laLYk+cQnPpGTTjopQ4YMycqVK3PjjTfm/2/v/mKrrO84jn/Oof+k/0D5J8Xq0G2KjNaBAsNYYAg6cAY3xCu8MGzc6N0W7xZjjFm2JcuWzMSAZuqWzGQINywThiSbMyNjzLixuCW7UJsGySaUlgltObsQGTpB2h6gT3m97trzPM/5Ju3dO9/nt3Pnzmzfvn00YwMAAAAAwLAIXWNAR0dHduzYkUcffTSdnZ2ZMWNG1q1bl8cee2zEz7zhurYsmT83r+77y6deu2TB3NxwXduwnt/b25tNmzalu7s7DQ0NmT17dp588sls2rRppCNXVW1tTdavWZafvLAtJ0+e+xi6amyzjUXLFt+SN//5Vt7uOfSp19636o40n+c2W5L09PRkw4YNOXToUFpbWzNv3rzs2rUry5cvH83IAAAAAAAwLKVKpXLuCsCI9ff3p6mpKUnS19eXxsbhvU5wtAYGBvPjn27Nu/86fNZrpl01KQ8/eF9qa8dn8/zNq3/Kzt/98ZzXbHxgTa6/duZFmujiOvTvw/nRs7/MwODQWa/54tzP5v7Vyy7iVAAAAAAAUB3O6CqYt3vezbH3j5/XtR9sNS1PufzJr6Mrl0tZv2b5uI1cSbJ0cWeuuXraWT+/fcEXxm3kSpKpV07KV5YtOuvnk1qa8tUV42+bDQAAAACAy4PQVSCDQ0N54aWd+e5TP89b3QfP6562GVOyYsn8T/xsxZL5aZsxpZojjjkTyuWsX7PsE2PetKsmZ1XXrZdgqotr0S1z8rnPzPq/35eSrFu9NA31dRd/KAAAAAAAqAKh62OGhoby/PPPZ+XKlZk6dWrq6+vT3t6eu+66K5s3b87Q0NlfAXeh7XvjzRw52p+6utpcPe2q876va1Fn2md+dKupfeb0dC3qrPKEY9OUK1uz+mNbTRPK5ay/Z1lqa8bvNtuHSqVSvn53V65oqP/I72+/dV6ubx+/22wAAAAAAIx/QtcZent7c+edd2bDhg3ZuXNn6urq0tHRkZMnT+bll1/Oxo0bc/To0Usy2+DQUHb/fn+SZOnCzmG9bnBCuZz7z9hqqqutyf1rlmZC+fL58y/svCmfn33N6Z9X3D4/bdPH9zbbmVqaG7N25e2nf54+ZXJW3rHgEk4EAAAAAACjd/mUjvPw0EMP5ZVXXsmsWbOye/fudHd3Z+/evXnnnXfS09OTJ554IrW1tZdktg+3uZqbJua2jhuHff+Uya1Zs/yDrabVyxdnyuTWao84ppVKpXzt7q5MbKjPtW3T07Ww41KPdNHNu+n6dM654X+vc7wMttkAAAAAABjfSpVKpXKphxgL9u3blwULFqSmpib79+/P3LlzR/3M/v7+NDU1JUm+84PNqatvGOGTKjna/59UKpU01NelboSxrVKp5MTAYOpqa1IqlUY4S7ENDA5mQrmc8mW0zXamSqWSgcHBEf8PAQAAAABAtTU3XZGHH7xvRPda6Thl27ZtSZLVq1dXJXJ9XG//sdQNjP58r/ePn8j7x0+M6hnHT4zufopvtP9DAAAAAAAwFghdpxw4cCBJsnjx4gvy/JbGiSPc6KrONhcAAAAAAMBY1Nx0xYjvFbpO6e3tTZK0tl6Ys6u+9c0H0tjYOOz7/vDnv+WlX/82zU0T8+1vPJDaWn8yAAAAAACAROg6raWlJUly5MiRqj1z4sSJ6evry1M/254fPvvSCM7F+mCbK0kGBgbzvad/UbXZAAAAAAAAxgJndFXBzTffnK1bt+a1116r2jNLpVIaGxtzYqCSo/3HRvWsapzNBQAAAAAAMJ4IXaesXbs2jz/+eHbs2JEDBw5kzpw5VXv2yN4t6WwuAAAAAABg/BvNGV2lSqVSqeIshbZ+/fq8+OKLaW9vz3PPPZeurq7Tnx08eDDPPPNMHnnkkRGdtTVczuYCAAAAAAA4N6HrDL29vbn33nuzZ8+eJElbW1tmzpyZnp6edHd3p1Kp5L333sukSZMu6ByDQ0P5/tO/yOHevtzz5S9lyYK5F/T7AAAAAAAAiqh8qQcYS1paWrJr165s2bIlS5cuzbFjx/L666+nXC5n1apV2bJlS5qbmy/4HPve+HsO9/aluWlibuu48YJ/HwAAAAAAQBHZ6BqD9v/1H/nVnr3pWthhmwsAAAAAAOAshK4xamBwMKWUUlMz4VKPAgAAAAAAMCYJXQAAAAAAABSSM7oAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKKT/Ah1em1uIz7iWAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "def create_circuit_with_weak_prob(eps):\n", + " qc = QuantumCircuit(6,6)\n", + " qc.h([0,1,2])\n", + " qc.barrier()\n", + " for (a,b,t) in [(0,1,3),(0,2,4),(1,2,5)]:\n", + " compute_same(qc, a, b, t)\n", + " qc.ry(eps, t)\n", + " uncompute_same(qc, a, b, t)\n", + " qc.barrier()\n", + " for q in [0,1,2]:\n", + " qc.rz(np.pi/2, q); qc.h(q)\n", + " qc.barrier()\n", + " qc.h([3,4,5])\n", + " qc.measure([0,1,2,3,4,5],[0,1,2,3,4,5])\n", + " return qc\n", + "\n", + "eps = 0.3 # we select a small value for the perturbation \n", + "qc_weak = create_circuit_with_weak_prob(eps)\n", + "display(qc_weak.draw('mpl'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "9b77dbf1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(0, 1) kept: 12458 bias: 0.045272114304061646\n", + "(0, 2) kept: 12458 bias: 0.039011077219457374\n", + "(1, 2) kept: 12458 bias: 0.0454326537164874\n" + ] + } + ], + "source": [ + "eps = 0.04 # we select a small value for the perturbation \n", + "qc_weak = create_circuit_with_weak_prob(eps)\n", + "res = backend.run(transpile(qc_weak, backend), shots=100_000).result().get_counts()\n", + "kept = postselect_data_000(res)\n", + "N = sum(kept.values())\n", + "for label, idx in {(0,1):0,(0,2):1,(1,2):2}.items():\n", + " same = sum(ct for b, ct in kept.items() if b[idx] == '0') # ancilla=0 → \"same\"\n", + " diff = sum(ct for b, ct in kept.items() if b[idx] == '1') # ancilla=1 → \"different\"\n", + " bias = (diff - same)/N\n", + " print(label,'kept:', N, 'bias:', bias)\n" + ] + }, + { + "cell_type": "markdown", + "id": "a49c93e0", + "metadata": {}, + "source": [ + "All pairs show stong significance ($5\\sigma$) individually" + ] + }, + { + "cell_type": "markdown", + "id": "2bae65f6", + "metadata": {}, + "source": [ + "## 6. Discussion\n", + "\n", + "- A **single strong** ancilla parity test can show a strong bias after post-selection, because it only partially marks the path (some coherence remains within that parity sector).\n", + "- **Three strong** parity encodings in parallel over-mark the path: the data become fully dephased in $Z$ upon tracing ancillas, killing the interference that creates the paradox.\n", + "- The **weak, reversible probe** (compute → poke → uncompute) restores the effect by erasing which-path entanglement while leaving a tiny, readable pointer shift proportional to the **weak value**. For the pigeonhole projector $\\Pi^{\\text{same}}_{ij}$, this weak value is $0$ for each pair, so $\\langle X\\rangle\\approx 0$ within postselected shots (up to noise).\n" + ] + }, + { + "cell_type": "markdown", + "id": "9f4bb7f8", + "metadata": {}, + "source": [ + "## 7. References\n", + "\n", + "- Y. Aharonov, D. Rohrlich, *Quantum Paradoxes: Quantum Theory for the Perplexed*, Wiley-VCH (2005), Chs. 10–11.\n", + "- N. Katz, M. Ansmann, R. C. Bialczak, E. Lucero, M. Neeley, A. O’Connell, H. Wang, M. Weides, J. M. Martinis, A. N. Korotkov, “Reversal of the weak measurement of a quantum state in a superconducting phase qubit,” *Phys. Rev. Lett.* **101**, 200401 (2008).\n", + "- Y. Aharonov, F. Colombo, S. Popescu, I. Sabadini, D. C. Struppa, J. Tollaksen, “Quantum violation of the pigeonhole principle and the nature of quantum correlations,” *PNAS* **111**(14), 4602–4605 (2014).\n", + "- Qiskit Documentation and Tutorials: \n", + "\n", + "## Acknowledgments / Use of AI Tools\n", + "This notebook was developed with assistance from AI tools(ChatGPT Anthropic Claude and Google Gemini) for drafting, code refactoring, and LaTeX/Markdown formatting. All content was reviewed and verified by the author.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "quantum", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}