From 0512b3405c6df13381bb67738b456d0b687db605 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 19:11:01 +0000 Subject: [PATCH 01/19] add neutron scattering tutorial Co-authored-by: nathanearnestnoble <51792809+nathanearnestnoble@users.noreply.github.com> --- .../simulate-neutron-scattering-spectra.ipynb | 1019 +++++++++++++++++ 1 file changed, 1019 insertions(+) create mode 100644 docs/tutorials/simulate-neutron-scattering-spectra.ipynb diff --git a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb new file mode 100644 index 00000000000..745a39a870a --- /dev/null +++ b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb @@ -0,0 +1,1019 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8e82ead7", + "metadata": {}, + "source": [ + "---\n", + "title: Simulate neutron scattering spectra of KCuF3 with quantum circuits\n", + "description: Compute the dynamical structure factor of a quantum magnet using Trotter circuits and MPS simulation.\n", + "---\n", + "\n", + "# Simulate neutron scattering spectra of KCuF₃ with quantum circuits\n", + "\n", + "*Usage estimate: 13 minutes on a Heron r2 processor (NOTE: This is an estimate only. Your runtime might vary.)*" + ] + }, + { + "cell_type": "markdown", + "id": "11033666", + "metadata": {}, + "source": [ + "## Learning outcomes\n", + "\n", + "After completing this tutorial, you can expect to understand the following information:\n", + "- How inelastic neutron scattering (INS) spectra connect to dynamical structure factors (DSFs) of quantum spin models.\n", + "- How to prepare a ground state, apply a local perturbation, and perform Trotter time evolution on a quantum circuit.\n", + "- How to use approximate quantum compiling (AQC) with `qiskit-addon-aqc-tensor` to compress deep Trotter circuits for hardware execution.\n", + "- How to extract the retarded Green's function (RGF) from qubit expectation values and Fourier-transform it into a DSF.\n", + "\n", + "## Prerequisites\n", + "It is recommended that you familiarize yourself with these topics:\n", + "- [Basics of Quantum Circuits and Gates](https://learning.quantum.ibm.com/course/basics-of-quantum-information)\n", + "- [Variational Algorithms and Hamiltonian Simulation](https://learning.quantum.ibm.com/course/variational-algorithm-design)\n", + "- [Introduction to Qiskit Primitives (Estimator & Sampler)](https://docs.quantum.ibm.com/guides/primitives)\n", + "\n", + "## Background\n", + "\n", + "In this tutorial, we reproduce the results of [Lee et al., arXiv:2603.15608](https://arxiv.org/abs/2603.15608) at a smaller scale. While that paper ran a 50-qubit experiment, here we run a 20-qubit experiment to keep the cost of performing approximate quantum compilation (AQC) more manageable.\n", + "\n", + "### Inelastic neutron scattering and the dynamical structure factor\n", + "\n", + "Inelastic neutron scattering (INS) is one of the most powerful experimental probes of magnetic excitations in quantum materials. When a beam of thermal or cold neutrons impinges on a crystal, individual neutrons exchange both momentum $\\mathbf{q}$ and energy $\\omega$ with the magnetic subsystem. The measured scattering intensity is proportional to the dynamical structure factor (DSF),\n", + "\n", + "$$S^{\\alpha\\beta}(q,\\omega) = \\sum_{j} e^{-iq\\,j}\\int_{-\\infty}^{\\infty} dt\\; e^{i\\omega t}\\, \\langle S_0^{\\alpha}(0)\\, S_j^{\\beta}(t)\\rangle,$$\n", + "\n", + "which encodes the full space-time correlations of the spin degrees of freedom.\n", + "\n", + "### KCuF$_3$ — a canonical Luttinger-liquid magnet\n", + "\n", + "Potassium copper fluoride (KCuF$_3$) is a quasi-one-dimensional antiferromagnet in which chains of spin-$\\frac{1}{2}$ Cu$^{2+}$ ions interact via a nearest-neighbor Heisenberg exchange $J \\approx 34\\;\\mathrm{meV}$, while the interchain coupling is only $\\sim 2.7\\%$ of $J$. At $T = 6\\;\\mathrm{K}$ where INS data are available, the spectrum is dominated by fractionalized spinon excitations characteristic of a Tomonaga-Luttinger liquid. Because the intrachain dynamics are well described by the one-dimensional spin-$\\frac{1}{2}$ XXZ Hamiltonian at the isotropic point ($\\epsilon = 1$),\n", + "\n", + "$$H = 2J\\sum_{i}\\left[S_i^Z S_{i+1}^Z + \\epsilon\\left(S_i^X S_{i+1}^X + S_i^Y S_{i+1}^Y\\right)\\right],$$\n", + "\n", + "KCuF$_3$ serves as an ideal benchmark for quantum simulation: the Hamiltonian is simple enough to implement on a quantum processor, yet the ground state is strongly entangled and the excitation spectrum features a broad two-spinon continuum.\n", + "\n", + "### What we simulate and measure\n", + "\n", + "The physical quantity we compute is the **retarded Green’s function** (RGF), defined as the time-dependent spin–spin correlation function\n", + "\n", + "$$G^R_{\\alpha\\beta}(j, j_c, t) = -i\\,\\theta(t)\\,\\langle\\psi_{\\mathrm{GS}}|\\,[S_j^\\alpha(t),\\, S_{j_c}^\\beta(0)]\\,|\\psi_{\\mathrm{GS}}\\rangle,$$\n", + "\n", + "where $j_c$ is a reference site (the chain center) and $S_j^\\alpha(t) = e^{iHt}S_j^\\alpha e^{-iHt}$ is the Heisenberg-picture spin operator. In this tutorial we focus on the $zz$ component ($\\alpha = \\beta = z$). On a quantum computer the RGF is accessed by preparing the ground state, applying a local perturbation at $j_c$, time-evolving the perturbed state, and measuring the single-qubit expectation value $\\langle\\sigma_j^z\\rangle$ at every site $j$ for each time step. The key insight is that each $\\langle\\sigma_j^z\\rangle$ gives the difference from the ground-state magnetization, which — for the antiferromagnetic ground state — directly yields $G^R(j, j_c, t)$.\n", + "\n", + "By collecting $G^R(j, j_c, t)$ over all sites and time steps, we assemble a two-dimensional dataset that is then Fourier-transformed in both space and time to produce the **dynamical structure factor** $S(q,\\omega)$. The DSF is the quantity directly measured in an INS experiment: it tells us what magnetic excitations exist at each momentum $q$ and energy $\\omega$. For the isotropic Heisenberg chain the exact excitation spectrum is a **two-spinon continuum** — a broad band of scattering intensity bounded below by $\\omega_{\\mathrm{lower}}(q) = \\frac{\\pi}{2}|\\sin q|$ (the des Cloizeaux–Pearson dispersion) and above by $\\omega_{\\mathrm{upper}}(q) = \\pi|\\sin(q/2)|$. Reproducing this continuum from a quantum circuit serves as a stringent end-to-end benchmark: it validates the ground-state preparation, perturbation, Trotter time evolution, and measurement protocol all at once.\n", + "\n", + "### Quantum-simulation workflow\n", + "\n", + "The workflow mirrors the physics of an INS event. We (1) prepare the many-body ground state $|\\psi_{\\mathrm{GS}}\\rangle$ on $n$ qubits, (2) apply a local spin-flip perturbation $U_{j_c} = \\frac{1}{\\sqrt{2}}(I - i\\sigma^z_{j_c})$ at the chain center to mimic the neutron’s spin transfer, (3) evolve under $H$ for discrete time steps using second-order Trotterization, and (4) measure $\\langle\\sigma_i^z\\rangle$ on every qubit at each step to obtain the RGF. A two-dimensional discrete Fourier transform then yields the DSF $S(q,\\omega)$.\n", + "\n", + "The observable we measure at every time step is $\\sigma_i^z$ on each qubit $i$. In Qiskit this is represented as a list of `SparsePauliOp` operators — one single-qubit $Z$ embedded in the $n$-qubit identity string for each site. These observables are constructed once during the problem-mapping step (Step 1) and reused for every circuit.\n", + "\n", + "### Approximate quantum compiling (AQC)\n", + "\n", + "Deep Trotter circuits can be compressed with **approximate quantum compiling (AQC)**, which replaces the first several Trotter layers with a shorter parameterized ansatz whose parameters are classically optimized to maximize the MPS-level fidelity with the original deep circuit. The remaining Trotter steps are appended exactly, producing a \"mixed\" AQC + Trotter circuit with substantially fewer two-qubit gates. In this tutorial AQC is demonstrated conceptually in Step 2 and applied programmatically in the large-scale section.\n", + "\n", + "### MPS simulation\n", + "\n", + "For a one-dimensional system, matrix-product-state (MPS) methods can efficiently simulate both ground-state preparation (via DMRG) and circuit-level time evolution. By controlling the bond dimension $\\chi$, one trades off accuracy against computational cost. In this tutorial we use MPS simulation within `qiskit-addon-aqc-tensor` to compute high-fidelity AQC ansätze that compress the deep Trotter circuits for hardware execution." + ] + }, + { + "cell_type": "markdown", + "id": "de1ad5a2", + "metadata": {}, + "source": [ + "## Requirements\n", + "Before starting this tutorial, be sure you have the following installed:\n", + "\n", + "- Qiskit SDK with visualization extras (`pip install qiskit[visualization]`)\n", + "- Qiskit Runtime (`pip install qiskit-ibm-runtime`)\n", + "- qiskit-addon-aqc-tensor with quimb and JAX extras (`pip install 'qiskit-addon-aqc-tensor[quimb-jax]'`)" + ] + }, + { + "cell_type": "markdown", + "id": "9938e4bd", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "71835ff6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete - all functions defined.\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from qiskit import QuantumCircuit\n", + "from qiskit.primitives import StatevectorEstimator\n", + "from qiskit.quantum_info import SparsePauliOp, Statevector\n", + "from scipy import sparse\n", + "from scipy.sparse.linalg import eigsh\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Hamiltonian construction (exact diagonalisation)\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def build_xxz_hamiltonian(n, J=1.0, Jz=1.0):\n", + " \"\"\"Build the 1D XXZ Hamiltonian as a sparse matrix (open boundary).\n", + "\n", + " H = 2*J * sum_i [ Jz * Sz_i Sz_{i+1}\n", + " + 0.5*(S+_i S-_{i+1} + S-_i S+_{i+1}) ]\n", + " \"\"\"\n", + " dim = 2**n\n", + " H = sparse.csr_matrix((dim, dim), dtype=complex)\n", + " sz = sparse.diags([0.5, -0.5])\n", + " sp = sparse.csr_matrix(np.array([[0, 1], [0, 0]]))\n", + " sm = sparse.csr_matrix(np.array([[0, 0], [1, 0]]))\n", + " I2 = sparse.eye(2)\n", + "\n", + " def _kron_op(op_a, site_a, op_b, site_b, n):\n", + " ops = [I2] * n\n", + " ops[site_a] = op_a\n", + " ops[site_b] = op_b\n", + " result = ops[0]\n", + " for k in range(1, n):\n", + " result = sparse.kron(result, ops[k], format=\"csr\")\n", + " return result\n", + "\n", + " for i in range(n - 1):\n", + " H += 2 * J * Jz * _kron_op(sz, i, sz, i + 1, n)\n", + " H += 2 * J * 0.5 * _kron_op(sp, i, sm, i + 1, n)\n", + " H += 2 * J * 0.5 * _kron_op(sm, i, sp, i + 1, n)\n", + " return H\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Two-qubit Trotter gate\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def two_opt(theta_x, theta_y, theta_z):\n", + " \"\"\"Two-qubit gate implementing exp(-i dt H_pair) for XXZ interactions.\n", + "\n", + " Parameters\n", + " ----------\n", + " theta_x, theta_y, theta_z : float\n", + " Rotation angles proportional to the XX, YY, ZZ coupling strengths\n", + " and the Trotter time-step length.\n", + " \"\"\"\n", + " qc = QuantumCircuit(2)\n", + " qc.cx(0, 1)\n", + " qc.rx(theta_x, 0)\n", + " qc.h(0)\n", + " qc.rz(theta_z, 1)\n", + " qc.cx(0, 1)\n", + " qc.s(0)\n", + " qc.h(0)\n", + " qc.rz(-theta_y, 1)\n", + " qc.cx(0, 1)\n", + " qc.sxdg(0)\n", + " qc.sx(1)\n", + " return qc\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Trotter circuit builder (2nd-order Suzuki-Trotter)\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def trotter_circuit(n, gs_circuit, time_steps, half_t, full_t, site):\n", + " \"\"\"Build a 2nd-order Trotter circuit for time evolution.\n", + "\n", + " Parameters\n", + " ----------\n", + " n : int - number of qubits\n", + " gs_circuit : QuantumCircuit - ground-state preparation circuit\n", + " time_steps : int - number of Trotter steps\n", + " half_t : QuantumCircuit - half-time-step 2Q gate\n", + " full_t : QuantumCircuit - full-time-step 2Q gate\n", + " site : int - perturbation site (center qubit)\n", + " \"\"\"\n", + " qc = gs_circuit.copy()\n", + " qc.rz(np.pi / 2, site) # perturbation\n", + " for i in range(n // 2): # half even layer\n", + " qc.compose(half_t, [2 * i, 2 * i + 1], inplace=True)\n", + " for i in range(n // 2 - 1): # full odd layer\n", + " qc.compose(full_t, [2 * i + 1, 2 * i + 2], inplace=True)\n", + " for _ in range(time_steps - 1): # interior steps\n", + " for i in range(n // 2):\n", + " qc.compose(full_t, [2 * i, 2 * i + 1], inplace=True)\n", + " for i in range(n // 2 - 1):\n", + " qc.compose(full_t, [2 * i + 1, 2 * i + 2], inplace=True)\n", + " for i in range(n // 2): # half even layer\n", + " qc.compose(half_t, [2 * i, 2 * i + 1], inplace=True)\n", + " return qc\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Mixed (AQC + Trotter) circuit\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def mixed_circuit(n, aqc_circuit, time_diff, half_t, full_t):\n", + " \"\"\"Concatenate additional Trotter steps onto an AQC-compressed circuit.\n", + "\n", + " Parameters\n", + " ----------\n", + " n : int - number of qubits\n", + " aqc_circuit : QuantumCircuit - AQC-optimized circuit (first few steps)\n", + " time_diff : int - additional Trotter steps to append\n", + " half_t : QuantumCircuit - half-time-step 2Q gate\n", + " full_t : QuantumCircuit - full-time-step 2Q gate\n", + " \"\"\"\n", + " qc = aqc_circuit.copy()\n", + " if time_diff != 0:\n", + " for i in range(n // 2):\n", + " qc.compose(half_t, [2 * i, 2 * i + 1], inplace=True)\n", + " for i in range(n // 2 - 1):\n", + " qc.compose(full_t, [2 * i + 1, 2 * i + 2], inplace=True)\n", + " for _ in range(time_diff - 1):\n", + " for i in range(n // 2):\n", + " qc.compose(full_t, [2 * i, 2 * i + 1], inplace=True)\n", + " for i in range(n // 2 - 1):\n", + " qc.compose(full_t, [2 * i + 1, 2 * i + 2], inplace=True)\n", + " for i in range(n // 2):\n", + " qc.compose(half_t, [2 * i, 2 * i + 1], inplace=True)\n", + " return qc\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# DSF via discrete Fourier transform\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def get_dsf(n, Gjjc, dt, time_steps, q_steps, w_steps):\n", + " \"\"\"Compute the dynamical structure factor from the retarded Green's function.\n", + "\n", + " Uses the center-site approximation and a discrete Fourier transform.\n", + " \"\"\"\n", + " green = Gjjc / 4 # sigma -> S=1/2\n", + " omega_max = np.pi / dt\n", + " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", + " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", + " green_map = np.zeros((omegas.shape[0], qpoints.shape[0]))\n", + " center = n // 2 - 1\n", + " for iw, w in enumerate(omegas):\n", + " exponent = np.exp(1j * w * dt * np.arange(1, time_steps + 1))\n", + " S_w = np.dot(green.T, exponent) * dt\n", + " for iq, q in enumerate(qpoints):\n", + " q_matrix = np.exp(-1j * q * np.arange(-center, center + 2, 1))\n", + " green_map[iw, iq] = np.imag(np.dot(S_w, q_matrix))\n", + " return green_map\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Plotting helpers\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def plot_dsf(\n", + " dsf, dt, q_steps, w_steps, title=None\n", + "):\n", + " \"\"\"Heat-map of the dynamical structure factor.\"\"\"\n", + " omega_max = np.pi / dt\n", + " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", + " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", + " x, y = np.meshgrid(qpoints, omegas)\n", + " fig, ax = plt.subplots(figsize=(8, 5))\n", + " c = ax.pcolormesh(x, y, dsf / np.max(dsf), cmap=\"viridis\", shading=\"auto\")\n", + " fig.colorbar(c, ax=ax, label=\"Normalized intensity\")\n", + " ax.set_ylim(0, 3.6)\n", + " ax.set_xlim(0, 2 * np.pi - 2 * np.pi / q_steps)\n", + " ax.set_xlabel(r\"$q$\", fontsize=16)\n", + " ax.set_ylabel(r\"$\\tilde{\\omega} = \\omega / J$\", fontsize=16)\n", + " ax.set_xticks([0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi])\n", + " ax.set_xticklabels([\"0\", r\"$\\pi/2$\", r\"$\\pi$\", r\"$3\\pi/2$\", r\"$2\\pi$\"])\n", + " if title:\n", + " ax.set_title(title, fontsize=14)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "def plot_rgf(n, Gjjc, time_steps, dt, title=None):\n", + " \"\"\"Heat-map of the retarded Green's function in real space and time.\"\"\"\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " qubit_axis = np.arange(n)\n", + " t_axis = np.arange(1, time_steps + 1) * dt\n", + " x, y = np.meshgrid(qubit_axis, t_axis)\n", + " c = ax.pcolormesh(\n", + " x, y, np.real(Gjjc), cmap=\"RdBu\", vmax=0.5, vmin=-0.5, shading=\"auto\"\n", + " )\n", + " fig.colorbar(c, ax=ax, label=r\"Re $G^R(j, j_c, t)$\")\n", + " ax.set_xlabel(\"Qubit\", fontsize=16)\n", + " ax.set_ylabel(r\"Time\", fontsize=16)\n", + " if title:\n", + " ax.set_title(title, fontsize=14)\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# ════════════════════════════════════════════════════════════\n", + "# Variational ground-state ansatz (HVA)\n", + "# ════════════════════════════════════════════════════════════\n", + "\n", + "\n", + "def _apply_xxz_pair_gate(qc, q0, q1, theta):\n", + " \"\"\"Apply the parameterized XXZ-type two-qubit gate used in the HVA.\"\"\"\n", + " qc.cx(q0, q1)\n", + " qc.rz(theta, q1)\n", + " qc.h(q0)\n", + " qc.rz(theta + np.pi / 2, q0)\n", + " qc.cx(q0, q1)\n", + " qc.rz(-theta, q1)\n", + " qc.h(q1)\n", + " qc.cx(q1, q0)\n", + " qc.rz(np.pi / 2, q1)\n", + " qc.rz(-np.pi / 2, q0)\n", + " qc.h(q1)\n", + " qc.h(q0)\n", + "\n", + "\n", + "def build_gs_ansatz(n, params, layers):\n", + " \"\"\"Build the Hamiltonian variational ansatz (HVA) circuit for\n", + " ground-state preparation of the 1D Heisenberg model.\n", + "\n", + " Starts from a product of singlet pairs and applies alternating\n", + " odd/even layers of parameterized XXZ gates.\n", + "\n", + " Parameters\n", + " ----------\n", + " n : int - number of qubits (must be even)\n", + " params : array - variational parameters, length 2 * layers\n", + " layers : int - number of HVA layers\n", + " \"\"\"\n", + " qc = QuantumCircuit(n)\n", + " # Initial singlet product state\n", + " for i in range(n // 2):\n", + " qc.x(2 * i)\n", + " qc.x(2 * i + 1)\n", + " qc.h(2 * i + 1)\n", + " qc.cx(2 * i + 1, 2 * i)\n", + " # Variational layers\n", + " for r in range(layers):\n", + " for i in range(1, (n + 1) // 2): # odd layer\n", + " _apply_xxz_pair_gate(qc, 2 * i - 1, 2 * i, params[2 * r])\n", + " for i in range(n // 2): # even layer\n", + " _apply_xxz_pair_gate(qc, 2 * i, 2 * i + 1, params[2 * r + 1])\n", + " return qc\n", + "\n", + "\n", + "print(\"Setup complete - all functions defined.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d28d01a6", + "metadata": {}, + "source": [ + "## Small-scale simulator example\n", + "\n", + "We first demonstrate the full workflow on **10 qubits** using exact diagonalisation for the ground state and Qiskit Aer's statevector simulator for time evolution. This small-scale example lets us validate every step before scaling up." + ] + }, + { + "cell_type": "markdown", + "id": "3818ed8f", + "metadata": {}, + "source": [ + "### Step 1: Map classical inputs to a quantum problem\n", + "\n", + "We begin by defining the physical model and constructing the quantum circuits.\n", + "\n", + "**Hamiltonian.** KCuF$_3$ is modelled by the 1D XXZ Hamiltonian at the isotropic point ($J = J_z = 1$, setting $2J = 1$ as the energy unit).\n", + "\n", + "**Ground state.** We use a Hamiltonian variational ansatz (HVA) circuit, `build_gs_ansatz`, as the ground-state preparation circuit. At 10 qubits, exact diagonalisation is tractable, so we classically optimize the HVA parameters by minimising $\\langle\\psi_{\\mathrm{HVA}}(\\theta)|H|\\psi_{\\mathrm{HVA}}(\\theta)\\rangle$ against the exact Hamiltonian matrix. This gives near-exact ground-state preparation within the HVA circuit ansatz.\n", + "\n", + "**Trotter gates.** Each nearest-neighbor interaction term $e^{-i\\Delta t\\, H_{\\mathrm{pair}}}$ is decomposed into the `two_opt` gate with angle $\\theta = 2\\Delta t\\, J / 4$.\n", + "\n", + "**Perturbation.** An $R_z(\\pi/2)$ gate on the center qubit implements $U_{j_c} = \\frac{1}{\\sqrt{2}}(I - i\\sigma^z_{j_c})$, mimicking the local spin-flip produced by a scattered neutron.\n", + "\n", + "**Observables.** We construct a $\\sigma^z$ observable for each qubit site. These `SparsePauliOp` objects are passed to the Estimator primitive in Step 3 to extract $\\langle\\sigma_i^z\\rangle$ at every time step." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "58305fbc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exact ground-state energy: -8.516070\n", + "HVA energy: -8.462051 (exact: -8.516070)\n", + "HVA GS circuit depth: 57\n", + "Built 10 circuits, deepest depth = 226\n", + "Defined 10 Z observables.\n" + ] + } + ], + "source": [ + "import scipy.optimize\n", + "\n", + "# -- Physical parameters --\n", + "n_small = 10\n", + "J = 1.0\n", + "Jz = 1.0\n", + "dt = 0.6\n", + "time_steps_small = 10\n", + "center_small = n_small // 2 - 1\n", + "\n", + "# -- Exact Hamiltonian and ground-state energy --\n", + "H_mat = build_xxz_hamiltonian(n_small, J, Jz)\n", + "E0, _ = eigsh(H_mat, k=1, which=\"SA\")\n", + "print(f\"Exact ground-state energy: {E0[0]:.6f}\")\n", + "\n", + "# -- Optimize HVA parameters against the exact Hamiltonian --\n", + "gs_layers_small = 3\n", + "\n", + "\n", + "def hva_energy(params):\n", + " sv = Statevector(build_gs_ansatz(n_small, params, gs_layers_small)).data\n", + " return np.real(sv.conj() @ H_mat @ sv)\n", + "\n", + "\n", + "x0 = np.array([2.99, 1.477] * gs_layers_small)\n", + "opt = scipy.optimize.minimize(hva_energy, x0, method=\"L-BFGS-B\")\n", + "gs_params_small = opt.x\n", + "gs_circuit_small = build_gs_ansatz(n_small, gs_params_small, gs_layers_small)\n", + "print(f\"HVA energy: {opt.fun:.6f} (exact: {E0[0]:.6f})\")\n", + "print(f\"HVA GS circuit depth: {gs_circuit_small.depth()}\")\n", + "\n", + "# -- Trotter gates --\n", + "theta = 2 * dt * J / 4\n", + "half_t = two_opt(theta / 2, theta / 2, theta / 2)\n", + "full_t = two_opt(theta, theta, theta)\n", + "\n", + "# -- Build circuits for each time step --\n", + "circuits_small = [\n", + " trotter_circuit(n_small, gs_circuit_small, t, half_t, full_t, center_small)\n", + " for t in range(1, time_steps_small + 1)\n", + "]\n", + "print(\n", + " f\"Built {len(circuits_small)} circuits, deepest depth = {circuits_small[-1].depth()}\"\n", + ")\n", + "\n", + "# -- Observables: Z on each qubit site --\n", + "observables_small = [\n", + " SparsePauliOp(\"I\" * (n_small - 1 - i) + \"Z\" + \"I\" * i) for i in range(n_small)\n", + "]\n", + "print(f\"Defined {len(observables_small)} Z observables.\")" + ] + }, + { + "cell_type": "markdown", + "id": "39191552", + "metadata": {}, + "source": [ + "### Step 2: Optimize problem for quantum hardware execution\n", + "\n", + "For real hardware, the Trotter circuits above would be too deep. **Approximate Quantum Compiling (AQC)** addresses this by replacing the first $k$ Trotter layers (including the ground-state circuit) with a shorter parameterized ansatz optimized to maximize the MPS-level fidelity with the original deep circuit. The remaining Trotter steps are appended exactly, producing a shallower \"AQC + Trotter\" circuit.\n", + "\n", + "The AQC workflow has four sub-steps:\n", + "\n", + "1. **Build target circuits** — the first $k$ circuits from Step 1 serve directly as AQC targets.\n", + "2. **Compute target MPS** — simulate each target circuit as a matrix-product state using `quimb.tensor.CircuitMPS`.\n", + "3. **Generate and optimize ansatz** — `generate_ansatz_from_circuit` creates a parameterized ansatz; parameters are optimized via L-BFGS-B with JAX-accelerated gradients to minimize $1 - |\\langle\\psi_{\\mathrm{ansatz}}|\\psi_{\\mathrm{target}}\\rangle|^2$.\n", + "4. **Assemble mixed circuits** — for time steps beyond the AQC checkpoint, append exact Trotter layers to the optimized AQC circuit using `mixed_circuit`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e78f8d9a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Step 2a — target circuit depths:\n", + " k=1: depth = 82\n", + " k=2: depth = 98\n", + " k=3: depth = 114\n", + "\n", + "Step 2b — target MPS:\n", + " k=1: max bond = 25\n", + " k=2: max bond = 26\n", + " k=3: max bond = 31\n", + "\n", + "Step 2c — ansatz: 389 parameters, depth = 19\n", + " k=1: fidelity = 1.0000, depth = 19, 11.9s\n", + " k=2: fidelity = 0.9988, depth = 19, 15.6s\n", + " k=3: fidelity = 0.9969, depth = 19, 15.7s\n", + "\n", + "Step 2d — assembled 10 circuits\n", + " Depth at step 10: Trotter = 226, AQC+Trotter = 139\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import timeit\n", + "from functools import partial\n", + "\n", + "import quimb.tensor as qtn\n", + "import scipy.optimize\n", + "from qiskit_addon_aqc_tensor import generate_ansatz_from_circuit\n", + "from qiskit_addon_aqc_tensor.objective import MaximizeStateFidelity\n", + "from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit\n", + "from qiskit_addon_aqc_tensor.simulation.quimb import QuimbSimulator\n", + "\n", + "aqc_steps_small = 3\n", + "\n", + "# ── Step 2a: Target circuits (first aqc_steps circuits from Step 1) ──\n", + "target_circuits_small = {\n", + " k: circuits_small[k - 1] for k in range(1, aqc_steps_small + 1)\n", + "}\n", + "print(\"Step 2a — target circuit depths:\")\n", + "for k, qc in target_circuits_small.items():\n", + " print(f\" k={k}: depth = {qc.depth()}\")\n", + "\n", + "# ── Step 2b: Compute target MPS ──\n", + "aqc_sim_small = QuimbSimulator(\n", + " quimb_circuit_factory=partial(\n", + " qtn.CircuitMPS, gate_opts=dict(cutoff=1e-8, max_bond=32)\n", + " ),\n", + " autodiff_backend=\"jax\",\n", + ")\n", + "print(\"\\nStep 2b — target MPS:\")\n", + "target_mps_small = {}\n", + "for k in range(1, aqc_steps_small + 1):\n", + " target_mps_small[k] = tensornetwork_from_circuit(\n", + " target_circuits_small[k], aqc_sim_small\n", + " )\n", + " print(f\" k={k}: max bond = {target_mps_small[k].psi.max_bond()}\")\n", + "\n", + "# ── Step 2c: Generate ansatz and optimize parameters ──\n", + "ansatz_small, initial_params_small = generate_ansatz_from_circuit(\n", + " target_circuits_small[1], qubits_initially_zero=True\n", + ")\n", + "initial_params_small = np.array(initial_params_small)\n", + "print(\n", + " f\"\\nStep 2c — ansatz: {ansatz_small.num_parameters} parameters, depth = {ansatz_small.depth()}\"\n", + ")\n", + "\n", + "aqc_circuits_small = {}\n", + "aqc_params_small = {}\n", + "for k in range(1, aqc_steps_small + 1):\n", + " x0 = aqc_params_small.get(k - 1, initial_params_small)\n", + " obj = MaximizeStateFidelity(target_mps_small[k], ansatz_small, aqc_sim_small)\n", + " t0 = timeit.default_timer()\n", + " result = scipy.optimize.minimize(\n", + " obj.loss_function, x0, method=\"L-BFGS-B\", jac=True, options=dict(maxiter=300)\n", + " )\n", + " elapsed = timeit.default_timer() - t0\n", + " aqc_params_small[k] = result.x\n", + " aqc_circuits_small[k] = ansatz_small.assign_parameters(result.x)\n", + " print(\n", + " f\" k={k}: fidelity = {1 - result.fun:.4f}, depth = {aqc_circuits_small[k].depth()}, {elapsed:.1f}s\"\n", + " )\n", + "\n", + "# ── Step 2d: Assemble full circuit set (AQC + Trotter) ──\n", + "all_circuits_small = []\n", + "for k in range(1, aqc_steps_small + 1):\n", + " all_circuits_small.append(aqc_circuits_small[k])\n", + "for k in range(1, time_steps_small - aqc_steps_small + 1):\n", + " all_circuits_small.append(\n", + " mixed_circuit(n_small, aqc_circuits_small[aqc_steps_small], k, half_t, full_t)\n", + " )\n", + "\n", + "full_depths = [circuits_small[k - 1].depth() for k in range(1, time_steps_small + 1)]\n", + "aqc_depths = [qc.depth() for qc in all_circuits_small]\n", + "print(f\"\\nStep 2d — assembled {len(all_circuits_small)} circuits\")\n", + "print(\n", + " f\" Depth at step {time_steps_small}: Trotter = {full_depths[-1]}, AQC+Trotter = {aqc_depths[-1]}\"\n", + ")\n", + "\n", + "steps_axis = np.arange(1, time_steps_small + 1)\n", + "fig, ax = plt.subplots(figsize=(7, 4))\n", + "ax.plot(steps_axis, full_depths, \"-o\", color=\"black\", label=\"Full Trotter\")\n", + "ax.plot(steps_axis, aqc_depths, \"-o\", color=\"cadetblue\", label=\"AQC + Trotter\")\n", + "ax.set_xlabel(\"Trotter steps\", fontsize=13)\n", + "ax.set_ylabel(\"Circuit depth\", fontsize=13)\n", + "ax.set_title(f\"AQC circuit-depth reduction ({n_small} qubits)\", fontsize=13)\n", + "ax.legend(fontsize=11)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "43ad6048", + "metadata": {}, + "source": [ + "### Step 3: Execute using Qiskit primitives\n", + "\n", + "We simulate each AQC-compiled circuit using the `StatevectorEstimator` primitive and extract the expectation value $\\langle\\sigma_i^z\\rangle$ for every qubit $i$ at each time step $t$. These values form the retarded Green's function matrix $G^R(j, j_c, t)$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b8f9e41c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Completed time step 5/10\n", + " Completed time step 10/10\n", + "RGF matrix shape: (10, 10)\n" + ] + } + ], + "source": [ + "estimator = StatevectorEstimator()\n", + "Gjjc_small = np.zeros((time_steps_small, n_small))\n", + "\n", + "for t_idx, qc in enumerate(all_circuits_small):\n", + " pub = (qc, observables_small)\n", + " job = estimator.run([pub])\n", + " result = job.result()\n", + " Gjjc_small[t_idx, :] = result[0].data.evs\n", + "\n", + " if (t_idx + 1) % 5 == 0:\n", + " print(f\" Completed time step {t_idx + 1}/{time_steps_small}\")\n", + "\n", + "print(f\"RGF matrix shape: {Gjjc_small.shape}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cb12662c", + "metadata": {}, + "source": [ + "### Step 4: Post-process and return result in desired classical format\n", + "\n", + "We now Fourier-transform the RGF into the dynamical structure factor $S(q, \\omega)$, apply mirror symmetry, clip negative values, and plot both the RGF and the DSF." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4585d139", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Small-scale demonstration complete.\n", + "The two-spinon continuum (bounded by dashed lines) is visible,\n", + "although finite-size effects are significant at only 10 qubits.\n" + ] + } + ], + "source": [ + "# -- Compute DSF --\n", + "q_res, w_res = 100, 100\n", + "spectrum_small = get_dsf(n_small, Gjjc_small, dt, time_steps_small, q_res, w_res)\n", + "spectrum_small = -(spectrum_small + spectrum_small[:, ::-1]) / 2\n", + "spectrum_small = np.clip(spectrum_small, a_min=0, a_max=None)\n", + "\n", + "# -- Plot retarded Green's function --\n", + "plot_rgf(\n", + " n_small,\n", + " Gjjc_small,\n", + " time_steps_small,\n", + " dt,\n", + " title=f\"Retarded Green's function — {n_small} qubits (simulation)\",\n", + ")\n", + "\n", + "# -- Plot DSF --\n", + "plot_dsf(\n", + " spectrum_small,\n", + " dt,\n", + " q_res,\n", + " w_res,\n", + " title=f\"Dynamical structure factor — {n_small} qubits (simulation)\",\n", + ")\n", + "\n", + "print(\"Small-scale demonstration complete.\")\n", + "print(\"The two-spinon continuum (bounded by dashed lines) is visible,\")\n", + "print(\"although finite-size effects are significant at only 10 qubits.\")" + ] + }, + { + "cell_type": "markdown", + "id": "ls-intro", + "metadata": {}, + "source": [ + "## Large-scale hardware execution\n", + "\n", + "We now scale up to **20 qubits**. Note that the paper scaled to 50 qubits, but reaching that scale required a large amount of computational resources to run AQC.\n", + "\n", + "The code below follows the same four-step structure as the small-scale example. The following table summarizes how the large-scale experiment differs from the small-scale one:\n", + "\n", + "| | Small scale | Large scale |\n", + "|---|---|---|\n", + "| Qubits | 10 | 20 |\n", + "| Time steps | 10 | 20 |\n", + "| AQC checkpoints | 3 | 5 |\n", + "| HVA layers | 3 | 6 |\n", + "| Ground-state energy | Exact diagonalization | DMRG |\n", + "| MPS max bond dimension | 32 | 10 |\n", + "| Estimator | `StatevectorEstimator` | QPU with DD + Pauli twirling + TREX |" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fbe57e1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ground-state energy: -8.682473\n", + "Built 20 circuits, deepest depth = 440\n", + "Ansatz: 1327 parameters, depth = 31\n", + " k=1: fidelity = 0.9648, depth = 31, 64.6s\n", + " k=2: fidelity = 0.8870, depth = 31, 64.8s\n", + " k=3: fidelity = 0.7164, depth = 31, 66.5s\n", + " k=4: fidelity = 0.6035, depth = 31, 66.5s\n", + " k=5: fidelity = 0.5625, depth = 31, 66.9s\n", + "Backend: ibm_pittsburgh\n", + "Job 1: d8guj81e8nrc73bghpbg\n", + "Job 2: d8guj89e8nrc73bghpcg\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from functools import partial\n", + "import timeit\n", + "\n", + "import quimb.tensor as qtn\n", + "import scipy.optimize\n", + "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n", + "from qiskit_addon_aqc_tensor import generate_ansatz_from_circuit\n", + "from qiskit_addon_aqc_tensor.objective import MaximizeStateFidelity\n", + "from qiskit_addon_aqc_tensor.simulation import tensornetwork_from_circuit\n", + "from qiskit_addon_aqc_tensor.simulation.quimb import QuimbSimulator\n", + "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n", + "from qiskit_ibm_runtime import QiskitRuntimeService\n", + "\n", + "# ── Parameters ──────────────────────────────────────────────────────────────\n", + "n_large = 20 # 10 → 20\n", + "J = 1.0\n", + "Jz = 1.0\n", + "dt = 0.6\n", + "time_steps_large = 20 # 10 → 20\n", + "center_large = n_large // 2 - 1\n", + "aqc_steps_large = 5 # 3 → 5\n", + "gs_layers_large = 6 # 3 → 6\n", + "gs_params_large = np.array([2.99, 1.477] * gs_layers_large)\n", + "\n", + "# ── Step 1: Map ──────────────────────────────────────────────────────────────\n", + "# Ground-state energy via DMRG (replaces exact diagonalisation)\n", + "builder = qtn.SpinHam1D(S=1 / 2)\n", + "builder += J * 0.5, \"+\", \"-\"\n", + "builder += J * 0.5, \"-\", \"+\"\n", + "builder += Jz, \"Z\", \"Z\"\n", + "H_mpo = builder.build_mpo(L=n_large)\n", + "dmrg = qtn.DMRG2(H_mpo, cutoffs=1e-10)\n", + "dmrg.solve(tol=1e-10, verbosity=0)\n", + "print(f\"Ground-state energy: {dmrg.energy:.6f}\")\n", + "\n", + "gs_circuit_large = build_gs_ansatz(n_large, gs_params_large, gs_layers_large)\n", + "\n", + "theta_lg = 2 * dt * J / 4\n", + "half_t_lg = two_opt(theta_lg / 2, theta_lg / 2, theta_lg / 2)\n", + "full_t_lg = two_opt(theta_lg, theta_lg, theta_lg)\n", + "\n", + "circuits_large = [\n", + " trotter_circuit(n_large, gs_circuit_large, t, half_t_lg, full_t_lg, center_large)\n", + " for t in range(1, time_steps_large + 1)\n", + "]\n", + "print(\n", + " f\"Built {len(circuits_large)} circuits, deepest depth = {circuits_large[-1].depth()}\"\n", + ")\n", + "\n", + "observables_large = [\n", + " SparsePauliOp(\"I\" * (n_large - 1 - i) + \"Z\" + \"I\" * i) for i in range(n_large)\n", + "]\n", + "\n", + "# ── Step 2: AQC ──────────────────────────────────────────────────────────────\n", + "target_circuits_large = {\n", + " k: circuits_large[k - 1] for k in range(1, aqc_steps_large + 1)\n", + "}\n", + "\n", + "aqc_sim_large = QuimbSimulator(\n", + " quimb_circuit_factory=partial(\n", + " qtn.CircuitMPS,\n", + " gate_opts=dict(cutoff=1e-4, max_bond=10), # truncated (32 → 10)\n", + " ),\n", + " autodiff_backend=\"jax\",\n", + ")\n", + "\n", + "target_mps_large = {}\n", + "for k in range(1, aqc_steps_large + 1):\n", + " target_mps_large[k] = tensornetwork_from_circuit(\n", + " target_circuits_large[k], aqc_sim_large\n", + " )\n", + "\n", + "ansatz_large, initial_params_large = generate_ansatz_from_circuit(\n", + " target_circuits_large[1], qubits_initially_zero=True\n", + ")\n", + "initial_params_large = np.array(initial_params_large)\n", + "print(\n", + " f\"Ansatz: {ansatz_large.num_parameters} parameters, depth = {ansatz_large.depth()}\"\n", + ")\n", + "\n", + "aqc_circuits_large = {}\n", + "aqc_params_large = {}\n", + "for k in range(1, aqc_steps_large + 1):\n", + " x0 = aqc_params_large.get(k - 1, initial_params_large)\n", + " obj = MaximizeStateFidelity(target_mps_large[k], ansatz_large, aqc_sim_large)\n", + " t0 = timeit.default_timer()\n", + " result = scipy.optimize.minimize(\n", + " obj.loss_function, x0, method=\"L-BFGS-B\", jac=True, options=dict(maxiter=10)\n", + " )\n", + " elapsed = timeit.default_timer() - t0\n", + " aqc_params_large[k] = result.x\n", + " aqc_circuits_large[k] = ansatz_large.assign_parameters(result.x)\n", + " print(\n", + " f\" k={k}: fidelity = {1 - result.fun:.4f}, depth = {aqc_circuits_large[k].depth()}, {elapsed:.1f}s\"\n", + " )\n", + "\n", + "all_circuits_large = []\n", + "for k in range(1, aqc_steps_large + 1):\n", + " all_circuits_large.append(aqc_circuits_large[k])\n", + "for k in range(1, time_steps_large - aqc_steps_large + 1):\n", + " all_circuits_large.append(\n", + " mixed_circuit(\n", + " n_large, aqc_circuits_large[aqc_steps_large], k, half_t_lg, full_t_lg\n", + " )\n", + " )\n", + "\n", + "# ── Step 3: Execute on IBM Quantum hardware ───────────────────────────────────\n", + "# (replaces StatevectorEstimator)\n", + "service = QiskitRuntimeService()\n", + "backend = service.least_busy(min_num_qubits=n_large, operational=True, simulator=False)\n", + "print(f\"Backend: {backend.name}\")\n", + "\n", + "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", + "isa_circuits = pm.run(all_circuits_large, num_processes=1)\n", + "isa_obs = [\n", + " SparsePauliOp.from_list(\n", + " [(\"I\" * i + \"Z\" + \"I\" * (n_large - i - 1), 1)]\n", + " ).apply_layout(isa_circuits[0].layout)\n", + " for i in range(n_large)\n", + "]\n", + "\n", + "estimator = Estimator(backend)\n", + "estimator.options.dynamical_decoupling.enable = True\n", + "estimator.options.dynamical_decoupling.sequence_type = \"XY4\"\n", + "estimator.options.twirling.enable_gates = True\n", + "estimator.options.twirling.num_randomizations = 1000\n", + "estimator.options.twirling.shots_per_randomization = 128\n", + "estimator.options.resilience.measure_mitigation = True\n", + "estimator.options.resilience.measure_noise_learning.num_randomizations = 32\n", + "estimator.options.resilience.measure_noise_learning.shots_per_randomization = 100\n", + "\n", + "mid = time_steps_large // 2\n", + "pubs = [(qc, isa_obs) for qc in isa_circuits]\n", + "job_1 = estimator.run(pubs[:mid])\n", + "job_2 = estimator.run(pubs[mid:])\n", + "print(f\"Job 1: {job_1.job_id()}\")\n", + "print(f\"Job 2: {job_2.job_id()}\")\n", + "\n", + "result_1 = job_1.result()\n", + "result_2 = job_2.result()\n", + "\n", + "Gjjc_large = np.zeros((time_steps_large, n_large))\n", + "for i in range(mid):\n", + " Gjjc_large[i, :] = result_1[i].data.evs[::-1]\n", + "for i in range(time_steps_large - mid):\n", + " Gjjc_large[mid + i, :] = result_2[i].data.evs[::-1]\n", + "\n", + "# ── Step 4: Post-process ──────────────────────────────────────────────────────\n", + "q_res, w_res = 100, 100\n", + "spectrum_large = get_dsf(n_large, Gjjc_large, dt, time_steps_large, q_res, w_res)\n", + "spectrum_large = -(spectrum_large + spectrum_large[:, ::-1]) / 2\n", + "spectrum_large = np.clip(spectrum_large, a_min=0, a_max=None)\n", + "\n", + "plot_rgf(\n", + " n_large,\n", + " Gjjc_large,\n", + " time_steps_large,\n", + " dt,\n", + " title=f\"Retarded Green's function — {n_large} qubits (QPU)\",\n", + ")\n", + "plot_dsf(\n", + " spectrum_large,\n", + " dt,\n", + " q_res,\n", + " w_res,\n", + " title=rf\"KCuF$_3$ DSF — {n_large} qubits (QPU)\"\n", + " \"\\n(AQC + DD + Pauli twirling + TREX)\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ls-nextsteps", + "metadata": {}, + "source": [ + "## Next steps\n", + "If you found this work interesting, you might be interested in the following material:\n", + "\n", + "\n", + "- [Lee et al., \"Benchmarking quantum simulation with neutron-scattering experiments\" (arXiv:2603.15608)](https://arxiv.org/abs/2603.15608) — the reference paper this tutorial is based on\n", + "- [Error Suppression and Mitigation with Qiskit Runtime](https://docs.quantum.ibm.com/guides/error-mitigation-and-suppression-techniques) — DD, Pauli twirling, and TREX used in the hardware experiments\n", + "- [Approximate quantum compilation for time evolution circuits](https://quantum.cloud.ibm.com/docs/en/tutorials/approximate-quantum-compilation-for-time-evolution) — tutorial on AQC-Tensor\n", + "- [AQC-Tensor documentation](https://qiskit.github.io/qiskit-addon-aqc-tensor/)\n", + "\n", + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From f1d51b5d40762fcd4e84e9823338ce04519b907e Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 15:33:25 -0400 Subject: [PATCH 02/19] run ./fix --- .../simulate-neutron-scattering-spectra.ipynb | 87 ++++++++++++------ .../extracted-outputs/4585d139-0.avif | Bin 0 -> 24787 bytes .../extracted-outputs/4585d139-1.avif | Bin 0 -> 36047 bytes .../extracted-outputs/e78f8d9a-1.avif | Bin 0 -> 33882 bytes .../extracted-outputs/fbe57e1a-1.avif | Bin 0 -> 27515 bytes .../extracted-outputs/fbe57e1a-2.avif | Bin 0 -> 42642 bytes 6 files changed, 57 insertions(+), 30 deletions(-) create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-0.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-1.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/e78f8d9a-1.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-1.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-2.avif diff --git a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb index 745a39a870a..292fedc61bf 100644 --- a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb +++ b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb @@ -281,9 +281,7 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def plot_dsf(\n", - " dsf, dt, q_steps, w_steps, title=None\n", - "):\n", + "def plot_dsf(dsf, dt, q_steps, w_steps, title=None):\n", " \"\"\"Heat-map of the dynamical structure factor.\"\"\"\n", " omega_max = np.pi / dt\n", " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", @@ -462,7 +460,9 @@ "\n", "# -- Build circuits for each time step --\n", "circuits_small = [\n", - " trotter_circuit(n_small, gs_circuit_small, t, half_t, full_t, center_small)\n", + " trotter_circuit(\n", + " n_small, gs_circuit_small, t, half_t, full_t, center_small\n", + " )\n", " for t in range(1, time_steps_small + 1)\n", "]\n", "print(\n", @@ -471,7 +471,8 @@ "\n", "# -- Observables: Z on each qubit site --\n", "observables_small = [\n", - " SparsePauliOp(\"I\" * (n_small - 1 - i) + \"Z\" + \"I\" * i) for i in range(n_small)\n", + " SparsePauliOp(\"I\" * (n_small - 1 - i) + \"Z\" + \"I\" * i)\n", + " for i in range(n_small)\n", "]\n", "print(f\"Defined {len(observables_small)} Z observables.\")" ] @@ -524,9 +525,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -582,10 +582,16 @@ "aqc_params_small = {}\n", "for k in range(1, aqc_steps_small + 1):\n", " x0 = aqc_params_small.get(k - 1, initial_params_small)\n", - " obj = MaximizeStateFidelity(target_mps_small[k], ansatz_small, aqc_sim_small)\n", + " obj = MaximizeStateFidelity(\n", + " target_mps_small[k], ansatz_small, aqc_sim_small\n", + " )\n", " t0 = timeit.default_timer()\n", " result = scipy.optimize.minimize(\n", - " obj.loss_function, x0, method=\"L-BFGS-B\", jac=True, options=dict(maxiter=300)\n", + " obj.loss_function,\n", + " x0,\n", + " method=\"L-BFGS-B\",\n", + " jac=True,\n", + " options=dict(maxiter=300),\n", " )\n", " elapsed = timeit.default_timer() - t0\n", " aqc_params_small[k] = result.x\n", @@ -600,10 +606,14 @@ " all_circuits_small.append(aqc_circuits_small[k])\n", "for k in range(1, time_steps_small - aqc_steps_small + 1):\n", " all_circuits_small.append(\n", - " mixed_circuit(n_small, aqc_circuits_small[aqc_steps_small], k, half_t, full_t)\n", + " mixed_circuit(\n", + " n_small, aqc_circuits_small[aqc_steps_small], k, half_t, full_t\n", + " )\n", " )\n", "\n", - "full_depths = [circuits_small[k - 1].depth() for k in range(1, time_steps_small + 1)]\n", + "full_depths = [\n", + " circuits_small[k - 1].depth() for k in range(1, time_steps_small + 1)\n", + "]\n", "aqc_depths = [qc.depth() for qc in all_circuits_small]\n", "print(f\"\\nStep 2d — assembled {len(all_circuits_small)} circuits\")\n", "print(\n", @@ -613,7 +623,9 @@ "steps_axis = np.arange(1, time_steps_small + 1)\n", "fig, ax = plt.subplots(figsize=(7, 4))\n", "ax.plot(steps_axis, full_depths, \"-o\", color=\"black\", label=\"Full Trotter\")\n", - "ax.plot(steps_axis, aqc_depths, \"-o\", color=\"cadetblue\", label=\"AQC + Trotter\")\n", + "ax.plot(\n", + " steps_axis, aqc_depths, \"-o\", color=\"cadetblue\", label=\"AQC + Trotter\"\n", + ")\n", "ax.set_xlabel(\"Trotter steps\", fontsize=13)\n", "ax.set_ylabel(\"Circuit depth\", fontsize=13)\n", "ax.set_title(f\"AQC circuit-depth reduction ({n_small} qubits)\", fontsize=13)\n", @@ -682,9 +694,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -692,9 +703,8 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvMAAAHqCAYAAACJNMEZAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjJZJREFUeJzt3Xd8VFXeBvDnTsoklAQQSSghVClSDQIBpKwoC4qwa2FZX5qCDRBEF8VC0ZWIKIKKYqNYUAQpIghikCYoEATpiNJEEkAggQApM+f9g83IMOcX5s7cZDLJ893PfFZObs49c9uc3DnnuYZSSoGIiIiIiIKOLdANICIiIiIi37AzT0REREQUpNiZJyIiIiIKUuzMExEREREFKXbmiYiIiIiCFDvzRERERERBip15IiIiIqIgxc48EREREVGQYmeeiIiIiChIsTNPQadjx44wDKPQ1te/f38YhoGDBw8W2jrJNzk5ORg7dizq1q0Lu90OwzCwcOHCQDeLgsSqVatgGAbGjh3r9e8U9vXocufPn0fVqlXxwAMP+PT7RfHaZhgGOnbsGPTruNK3334LwzCwdOnSQl0vlQzszBdhBw8ehGEYbq9SpUqhSpUquPnmmzF69Gj8+uuvgW4m+ahGjRqoUaNGoJvhIe+469+/f6CbYtqrr76KcePGoUqVKnjiiScwZswY1K9fv0DXWRQ7RAXp119/xdixY3HHHXegatWqMAzDq+N4+fLl6NChA8qWLYuoqCh06tQJycnJBd/gAJg5cyYMw8DMmTMLdD0TJ07EyZMn8eyzzxboeoJNIP/AknTu3Bnt2rXDyJEj4XA4At0cKmZCA90AurratWvj//7v/wAAWVlZOH78ODZu3IgXXngB48ePx8iRI/Hiiy8WuYtXQfnwww9x/vz5QDeDiqCvvvoKZcqUwYoVKxAeHh7o5hRLa9euxbhx4xASEoIGDRogNTX1qr/z8ccfo0+fPrj22mtdfyTOmTMHt9xyCz7//HPcddddBdzqghOo61FGRgZeeeUV9OrVC9WrV/epjqSkJDz11FOoWrWqxa0r2nbv3o1SpUoV+npHjhyJO+64A5999hnuvffeQl8/FV/szAeBOnXqaL/2XbduHfr06YOkpCSEhITghRdeKPzGBYCvH1xU/P3xxx+45ppr2JEvQO3bt8eGDRvQtGlTREZGIiIiIt/lT58+jaFDh6JixYrYsmULqlWrBgB48skn0bx5czz88MPo0qULypYtWxjNt1ygrkcfffQRzp07h759+/pcR+XKlVG5cmULWxUcCvrbOsnf//53VKxYEdOmTWNnnizFYTZBrF27dli2bBnsdjtefvllHDlyBADw/vvvwzAMvPzyy9rfW7lyJQzDwIMPPugqyxvyce7cOQwbNgxVqlSB3W5HkyZNMG/ePI869u3bh5EjR+KGG27ANddcg4iICFx33XV46qmncO7cOY/l8772zMrKwtNPP43q1asjMjISCQkJ+PbbbwEA6enpGDx4MKpUqYKIiAgkJiZi48aNYl06ixYtwq233upqU40aNdCnTx/s2LHD57abtWXLFtx1112oXr067HY7rr32Wtx444148cUXAfw1jOXQoUM4dOiQ2zCqvD/aLh+7u379etx6660oV66c633nN7Y3v2Eyx48fx+OPP4569eohMjISFSpUQKtWrfDKK68AuDQ8oGbNmgCAWbNmubVt1apVAPIfVjJ27Fi3Zb15LwCglML06dPRtm1bREVFoVSpUmjRogWmT5/u1TbPW++BAwfctmne8I/s7Gy88cYb6NKlC+Li4mC321GpUiX885//xE8//STWe7XjqUaNGpg1axYAoGbNmq71Xjke9/vvv8dtt92GChUqICIiAvXr18eYMWO0d3Tzfv/o0aPo27cvYmNjYbPZ3LZpINWqVQutW7dGZGSkV8vPnTsXZ86cwdChQ10deQCoVq0ahgwZgpMnT2LBggVer3/dunXo0KEDSpcujWuuuQa9evXCkSNHtNcFs8fqlevp2LEjypYti3LlyuHOO+/E/v37PZa7cr39+/fHgAEDAAADBgxwO4fyHDt2DMOGDUPdunURGRmJcuXKoUGDBnjooYeQnp7u1XaYMWMGKlSogL/97W8eP/vll18wYMAA1KxZE3a7HRUqVEDTpk0xfPhwKKXy3T5Xnq+dOnVC2bJlce211+KRRx7BhQsXAABLlixBYmIiSpcujZiYGIwcORK5ublu7chvG5sZimTmmm0YBlavXu3677zX5ddDacz8yZMnMXz4cNd2q1SpEu655x63z48rt92BAwfw+uuvo379+rDb7YiPj8e4cePgdDo9ficsLAw9e/bEunXrtMcSka94Zz7I1atXD/fccw8++ugjLFy4EEOHDkXv3r3x+OOP44MPPsDIkSM9fue9994DAAwaNMitPCcnB7feeitOnz6NO++8E+fPn8dnn32Ge+65B8uWLcOtt97qWnb+/Pn44IMP0KlTJ3Ts2BFOpxM//PADJkyYgNWrV2PNmjUICwvzWHevXr2wfft23HHHHbhw4QI++eQT3H777fj+++/xwAMPIDs7G3fffTdOnDiBOXPm4O9//zsOHDiA6Ojoq26Lxx9/HJMmTUKFChXQs2dPVKpUCUeOHMG3336LhIQENGrUyK+2e2Pr1q1o06YNQkJC0KNHD8THx+PMmTPYtWsX3n33XTzzzDMoV64cxowZg8mTJwMAhg8f7vr9Kz9g1q9fj/Hjx6NTp0544IEHcPjwYZ/aBQB79+5Fp06dcOzYMbRr1w49e/ZEZmYmdu7cifHjx+OJJ55As2bNMGzYMEyZMgVNmzZFz549Xb/v7/h+6b0opXDvvffi008/Rd26dfHvf/8b4eHhWLFiBe6//37s2rXL9ceGJG+7XblNy5UrBwA4deoUhg8fjptuugndunVD+fLl8dtvv+HLL7/E119/jTVr1uDGG290q9Ob42n48OGYOXMmtm3bhmHDhrnWd/m2mjt3Lnr37g273Y5evXqhUqVK+Oabb/D8889j+fLlWLVqlcfd7T///BOJiYmoUKEC/vWvf+HixYuIiooyv9GLgLyO3OXXjzxdunTB2LFjsXr1aq/uMCcnJ6Nr166w2Wzo1asXqlSpguTkZLRt2xbly5e3rM0//PADkpKS8Pe//x1Dhw7Fzp07sWDBAqxduxY//PADatWqJf5uz549cebMGSxatAg9evRAs2bN3H5+/vx5tG3bFgcPHsStt96Kf/zjH8jOzsaBAwfw0Ucf4Yknnrjq9e706dP46aefcOutt8Jmc78n98cff6Bly5bIzMzEbbfdhl69eiEzMxO//PIL3nrrLbzyyisIDb36R/+PP/6ICRMmoEuXLnjwwQfx3Xff4e2330ZGRga6d++O/v37o0ePHkhMTMSSJUswceJElClTBqNHj75q3WaZuWaPGTMGM2fOxKFDhzBmzBhXHVfuhyudOHECiYmJ+PXXX9GxY0f861//woEDBzBv3jwsWbIEy5cvR7t27Tx+7z//+Q9Wr16N22+/HV26dMHChQsxduxYZGdnu27gXC4xMRHvv/8+Vq5ciTp16vi3YYjyKCqyDhw4oACoLl265LvcBx98oACoPn36uMoefvhhBUCtWrXKbdk///xT2e121axZM7fy+Ph4BUD16NFDZWVlucq//fZbbRt+//13t+XyjBs3TgFQH3/8sVt5hw4dFADVrl07de7cOVf5nDlzFABVrlw5dffdd6ucnBzXzyZMmKAAqFdffVVb1+UWL16sAKjGjRurkydPuv0sJydHpaam+tz2fv36KQDqwIEDHr9zpREjRigAauHChR4/u7Jd8fHxKj4+XlvPd999pwAoAGr69Oniz8eMGePxs7zjpl+/fm7lLVq0UADUu+++6/E7R44cuerv58lve4wZM0YBUN99953X7+Xdd99VANSAAQNUdna2qzwrK0t1795dAVCbN2/WtuVK0ja9ePGi+v333z3Kd+zYocqUKaM6d+7sVm7meMpve6Snp6vo6Ghlt9vVtm3bXOUOh0P16tVLAVDPP/+82+/kbasBAwao3Nxcb952QNntdvE4Vuqv4+7K7ajUpXMCgLrpppuuuh6Hw6Fq1aqlDMNQa9eudZU7nU7173//27XdLufPsTpt2jS35adNm6YAqNtvv92tXHc9mjFjhgKgZsyY4bHeL7/8UgFQw4cP9/jZ2bNn1cWLF6VN4LJkyRIFQD3zzDMeP3v99dcVADV58mSPn/35559u/9Ztn8u3weXXsezsbNWkSRNlGIaqWLGi2rhxo+tnGRkZqlKlSqpChQpu57BuG+eRthEA1aFDB7cyXz9vJLp1DBgwQAFQo0aNcivP29Z16tRRDofDVZ637WrWrKn++OMPV/mJEydUuXLlVNmyZbVt3rZtmwKg+vbtK7aPyCwOsykGqlSpAuDSV4R5HnroIQCXhtxc7qOPPkJWVpbHXfk8r732mtt445tvvhnx8fHYtGmT23JVq1bVjkseMmQIALiGzlzpxRdfROnSpV3/vuuuuxAWFoYzZ8543DHq3bs3AGDbtm3aui731ltvAQCmTJmCa665xu1noaGhiImJ8bvtZuiGIFzZLm/ccMMNrq/s/bFx40Zs3rwZ7du31+77y4c/FBTpvbz55psoXbo0pk6d6vaNSHh4uOvO1qeffurXuu12u3aS3/XXX49OnTphzZo1yMnJcZWbOZ7ys2jRIqSnp+O+++5DkyZNXOU2mw0vv/wyQkNDtcMMwsPD8fLLLyMkJMSr9RRlecNGdHeb875t8GZoybp16/Dbb7/h9ttvd7tDahgGxo8fb+m2uu666zzOk0GDBqFu3bpYsmQJTpw44fc6dNeIMmXKwG63X/V3f//9dwDI9zjU1V+hQgWv29epUyf06NHD9e+wsDDcddddUEqhe/fubt9klS1bFrfffjtOnTrlapuVCvqanZ2djU8//RTXXHONRzJQt27dcMstt2D//v34/vvvPX73ueeec5t3ULFiRfTo0QNnz57F3r17PZbP22cFsZ2o5OIwm2KqSZMmaN26NebNm4c33njD9fX/Bx98gFKlSmkn35QrV841Xvpy1apVw4YNG9zKlFKYMWMGZs6ciR07diA9Pd1tjOAff/yhbdeVX3XabDZUqlQJ58+f95hIlneBlOq63MaNG2G329GhQ4erLutr271xzz33YPLkyfjHP/6BXr164ZZbbkH79u19Tou4cuiHr/LmHuiGOhQW3Xs5f/48tm/fjipVqmDChAkeP8/rYO/Zs8fv9W/duhUvv/wy1q1bh9TUVLfOO3Dpj+G8Y87M8ZSfvPH4uvG51atXR61atbBv3z6cPXvWbQJozZo1UbFiRa/Xs3XrVkvy9Pv3718k41KBv/6ov+mmmzx+Fh8fj7i4OMviQdu2besxfMVms6Ft27b45ZdfsG3bNnTu3Nmnutu3b4/KlSvjpZdewrZt23D77bejQ4cOaNCggdeJZH/++SeAv4aRXa579+4YNWoUBg8ejOTkZPz9739Hhw4d8h0apKMblpJ3fuT3sz/++EP7OeKPgrxmA5euLxcvXkSnTp20KTedOnXCihUrsHXrVo/jLyEhwWP5vJsjZ86c8fhZ3h9Ul998I/IXO/PFQN6F7Nprr3Urf/DBBzFgwAB8/PHHGDJkCH788Uds374d/fr1094lk8ZphoaGekzmefTRR/Hmm28iLi4Od9xxBypXruy6ozRu3DhkZWVp69KN+w0NDRXLAXh0unTS09NRtWpVjw9gHV/b7o1WrVph1apVGD9+PGbPno0ZM2YAuNSRnTBhAjp16mSqPm/vAF9N3p3PQEbQ6d7L6dOnoZTC0aNHMW7cOPF3MzMz/Vr3+vXrXRMFb731VtStWxdlypRxPVRq27ZtbvvdzPGUn4yMDADyfqxcuTL27duHjIwMt8682f2+devWfLeftzp27Gh5Zz7vupKenu7xLUfe9vFmTkzeMVypUiXtz2NiYizrzEvbP6/c20mqOtHR0fjhhx8wevRoLF682PUQobi4ODz11FN45JFHrlpH3l33ixcvevysRo0a+OGHHzB27FgsXboUn3/+OYBLCS7PP/887r77bq/amd812d/rtVkFec0GvDtPL1/ucvltC12efN4E4kBEY1Lxxc58MZA3wezKO5+9evXCY489hvfffx9DhgxxDbmRhth46/jx45g6dSqaNGmCDRs2uF2UUlNTLelUmFWuXDmkpqbC6XTm2wErjLbfdNNN+Prrr3HhwgX8+OOPWLx4Md566y3cdttt2LFjh6k7ZNKdurz3eGV6BKDvaOTdwTt69KjX65aYXXce3XvJ+yBMSEjA5s2b/W6b5MUXX0RWVhbWrl3rMYnthx9+8BjK5e3xdDV57y8tLU3787yM9is7BGafGdG/f/8i+5CvunXrYvPmzfjll188OvO//PKLa5mryevwHz9+XPtz3Tb29ViV9ldeuTd/fOSnevXqmDlzJpxOJ37++Wd88803eP311zF48GCUL1/eNcRQknfj5tSpU9qfN2rUCPPmzUNOTg5SUlLw9ddf4/XXX3dNGm7btq1f7feWr9v/coVxzfb1PPVF3j678uYbkT84Zj7I7du3D59//jnsdjv+8Y9/uP0sMjISffv2xbZt2/Ddd99hzpw5aNCggd8X8t9++w1KKXTu3Nnj7sLatWv9qttXLVu2RFZWliuSTFKYbY+MjETHjh3x6quv4umnn8aFCxewYsUK189DQkJ8fhJgXnKHrnOui1ps2bIlAOCbb765at15Y4+ltpldd37Kli2LBg0aYPfu3dqvpK3y66+/okKFCh4d+fPnz2PLli0ey3t7PAH5b6/mzZsDgDaa78iRI/j1119Rq1atoM1Y90beUCXdsbd8+XK3ZfLTtGlTAPrz9NChQ65o3sv5eqx+//33Ht9GOp1OrF+/HoZhuNoiudo5lMdms6FZs2YYOXKka17Il19+me/vAEDjxo0BQDsm+3JhYWFo3bo1xo0bh9dffx1KKXz11VdXrd8qVlwrfLlme7v989SvXx8RERHYtGmTNi427/y9WiKON/L2Wd4+JLICO/NB7Pvvv0eXLl2QlZUlPsUvL0v+//7v/3D27Fm/78oDl8anApeGLlz+gff7779j1KhRftfvi8GDBwMAhg0b5nG3Kjc313XHpaDbvmHDBu1X33nrvzyCsEKFCjh58qR2+aupV68eypYtiy+//NLt/aalpeG///2vx/I33ngjbrzxRqxZs8YVTXq5yz9sy5cvD8MwtJ2jvLoAeEzcnDdvnled3ys9+uijOH/+PAYNGqQdTnPgwAG/h0/Ex8fj9OnT2Llzp6vM4XDgiSee0E5m9PZ4Av4aA6vbXj169EB0dDRmzJjhtm6lFJ588knk5uYW2TvqVrnnnnsQHR2NN954w23S3++//44333wTFStW9LgRodOuXTvUrFkTX331FdatW+cqV0rh6aef1nbcfD1W9+3b53GevPfee9i3bx9uu+22q95Vze+Y2Llzp/YOsO4aIWncuDEqVKiAH3/80eNnKSkp2uEgZuq3St72//DDD92utxs2bMAnn3ziVR2+XLPz2/464eHh6N27N06ePImkpCS3ny1btgzLly9HnTp1LPlGI2+f+Tsfh+hyHGYTBPbv3+96OFB2djaOHz+OjRs3Yvv27QgJCcGzzz7rlqd7uYYNG+Kmm27C2rVrYbfb/XpaYJ7KlSvjzjvvxBdffIEWLVrg5ptvRlpaGr766ivcfPPN+PXXX/1eh1ndunXDE088gVdeeQV169bFP/7xD1SqVAlHjx5FcnIynnjiCQwfPrzA2z5hwgR89913aN++PWrWrImIiAhs2bIFycnJqFWrllun5W9/+xs2b96Mrl274qabbkJ4eDjat2+P9u3bX3U94eHhGDp0KMaPH48bbrjBlZ6wePFidOjQQfs+PvnkE3Ts2BEPPPAAPvroIyQmJuLixYvYuXMnfvrpJ9ekujJlyrg6/n369EHdunVhs9nQp08fxMfHo0ePHqhduzZmzpyJI0eOoHnz5ti9ezdWrlyJbt26ucYAe+vBBx/EDz/8gFmzZuH7779H586dUaVKFaSlpWHPnj348ccfMXv2bL/Gcg8dOhTffPMN2rVrh3vuuQcRERFYtWoVjh49io4dO3rcOff2eAIu7cdXXnkFDzzwAO68806ULl0a8fHx6NOnD6KiovDee++hd+/eaNWqFXr16oVrr70W3377LVJSUtCyZUv85z//8fl9BcLJkyfxxBNPuP6dk5ODkydPuv1R8sorr7gm8JYvXx5vvvkm+vTpgxtuuAG9evUCAMyZMwd//vkn5syZ49U3EzabDe+++y66deuGzp07u4aMrFy5EseOHUOTJk3w888/u/2Or8dqly5d8Oijj2Lp0qW4/vrrsXPnTixevBgVK1bElClTrtrWxMREREZGYvLkyTh9+rSr8//ss89ixYoV+M9//oO2bdviuuuuwzXXXON65kFERITrD8n8GIaBHj16YObMmfj999/d0qg++ugjvPPOO2jfvj1q166NqKgo7Nq1C0uXLkWFChUsScfyVuvWrdG2bVusXLkSiYmJaN++PQ4dOoRFixahe/fuXj0szJdr9t/+9jfMmzcPd955J7p27YqIiAg0bdoU3bt3F9eTl1n/3//+F+vXr0erVq1w8OBBzJ07F6VKlcKMGTP8nkMDACtWrED58uW9us4TeS1AkZjkhby878tfkZGRqnLlyqpTp07queeeU/v3779qPe+//74CoP71r3+Jy+SXea7L7D179qx6/PHHVY0aNZTdbld169ZVL7zwgsrOztZm+OaX+5vfus3W9cUXX6hOnTq5sr1r1Kih+vTpo3bs2OFz283kzC9btkz17dtX1atXT5UtW1aVKVNGNWzYUD399NPqxIkTbsuePXtWDRo0SFWuXFmFhIS45cbnlyOfx+FwqLFjx6q4uDgVHh6urrvuOjVlyhT122+/iTnxqampatiwYapWrVoqPDxcVahQQbVq1UpNmjTJbbm9e/eqbt26qXLlyinDMDyyog8cOKB69uypypYtq0qXLq1uvvlmtWnTpnyzu/N7L0pdeuZA586dVfny5VVYWJiqWrWq6tixo3r11Vc9tp0kv2Np3rx56oYbblClSpVSFStWVPfcc4/69ddf892/3hxPSin18ssvq7p166qwsDDtMbRmzRrVtWtXVa5cOde+eu6559yeuZBH9/tFie66dOVLty2//vprddNNN6nSpUurMmXKqA4dOqgVK1aYXv+aNWtU+/btVWRkpKpQoYK6++671aFDh8Trgq/H6tq1a1WHDh1U6dKlVVRUlPrHP/6hfvnlF4/6pfUuWbJE3XjjjSoyMtItA3/Xrl1q2LBhqnnz5uqaa65Rdrtd1apVS/Xr10/t3LnT6+3w448/KgBqwoQJbuU//PCDevDBB1WjRo1UuXLlVGRkpKpbt64aMmSIOnTokNuy+eXM687X/PLzpUz5kydPqr59+6oKFSqoyMhI1bp1a7V8+XJTOfNmr9k5OTlq5MiRqnr16io0NNTjeiidYydOnFCPPvqoio+PV2FhYapixYrqrrvuUtu3b/dY1uwzDJS6dCwahqF9xgCRPwylLnu2MxVLQ4YMwdSpU5GcnKx99DcRUbDr2LEjVq9ejZL0kXbTTTfhxIkT2LVrlyV3jalgPfvss3j55Zexe/du1K5dO9DNoWKEZ38xd+LECcyaNQv16tUzHYtIRERF18SJE7F371589tlngW4KXcXp06fxxhtv4OGHH2ZHnizHMfPF1JIlS7BlyxbMmzcP586dw9ixY03H3RERUdHVunVrvPPOOz6nYlHhOXDgAB577DEMHTo00E2hYojDbIqp/v37Y9asWahSpQqGDBkSsJQZIqLCUBKH2RARARxmU2zNnDnT9WRNduSJqLhbtWoVO/JEZMqaNWvQvXt3VKlSxfVE8KtZtWoVbrjhBtjtdtSpU8cj+jYQ2JknIiIiohInMzMTTZs2xdSpU71a/sCBA7jtttvQqVMnbN26FcOHD8fAgQNdD8ALFA6zISIiIqISzTAMLFiwAD179hSXefLJJ7FkyRLs2LHDVfavf/0LZ86cwbJlywqhlXqcAHsVTqcTf/zxB8qWLcsJpERERBTUlFI4e/YsqlSpUiQiTS9evIjs7GzL6lNKefTX7HY77Ha733Vv2LABnTt3divr0qWL6yGCgcLO/FX88ccfiIuLC3QziIiIiCxz5MgRt6cHB8LFixdRM74MUo9bl8hUpkwZnDt3zq1szJgxGDt2rN91p6amIiYmxq0sJiYGGRkZuHDhAiIjI/1ehy/Ymb+KvMeMt0M3hCIswK0hKsYM/R0iw+b5jZgREiLUIXx7FuJZtyHdkTJTt7A+Q3gv/lLKKf3A+3IhxlA5hbodmnJhfUqsW7O89F6IqEAsSv8QAJCRkYG4uDhX/yaQsrOzkXrcgUMpNRBV1v/rZsZZJ+ITDuLIkSOIiopylVtxV74oY2f+KvK+qglFGEINduaJ/Gai0w4IHXeps6zptIt1CJ128Q8FXfukPx4KakiemU47AGg60com3AGTOuKGplzXwQcAQ1+u6+RrO/iXfqAvJyK/XN65BVCkhg6XKWugTFn/2+PEpTqioqI83q8VYmNjkZaW5laWlpaGqKiogN2VB9iZJyIiIqIAcignHBbEsTgK+GZAYmIili5d6la2YsUKJCYmFuh6rybwMx+IiIiIiArZuXPnsHXrVmzduhXApejJrVu34vDhwwCAUaNGoW/fvq7lH3roIfz2228YOXIk9uzZg7feeguff/45HnvssUA034V35omIiIgoYJxQcML/W/Nm69i8eTM6derk+veIESMAAP369cPMmTNx7NgxV8ceAGrWrIklS5bgsccew5QpU1CtWjW8//776NKli99t9wc780RERERU4nTs2DHfJ0frnu7asWNH/PTTTwXYKvOCapjN22+/jSZNmrgmNiQmJuLrr78Wl585cyYMw3B7RUREFGKLiYiIiCg/Tgv/VxIF1Z35atWq4aWXXkLdunWhlMKsWbPQo0cP/PTTT7j++uu1vxMVFYW9e/e6/l2UZm8TlURSao2YUKMrN5NaA+iTa6R2iOWadUrxloWdZiPFSuo+2JTUNiHdR9cMoQZIUdGG528YNin5RqqciIorh1Jw5HOH3Ew9JVFQdea7d+/u9u8XX3wRb7/9Nn744QexM28YBmJjYwujeUREREREhSqohtlczuFw4LPPPkNmZma+kUDnzp1DfHw84uLi0KNHD+zcuTPferOyspCRkeH2IiIiIqKCkTcB1opXSRR0nfnt27ejTJkysNvteOihh7BgwQI0bNhQu2y9evUwffp0LFq0CB9//DGcTifatGmD33//Xaw/KSkJ0dHRrldcXFxBvRUiIiKiEs8JBYcFr5LamTdUftN4i6Ds7GwcPnwY6enpmDdvHt5//32sXr1a7NBfLicnBw0aNEDv3r3xwgsvaJfJyspCVlaW6995jz3uiB58AiyRBcRx7dKTYbVPby24MfPyE2CDcMy8plz3NNZLywp1657eKtUhPBlWu7zwcBexbiLyywrnXACX+jXR0dFIT08vkKekmpHXlgN7KqNsWf/vL58960TN+seKxHsrTEE1Zh4AwsPDUadOHQBAQkICNm3ahClTpuCdd9656u+GhYWhefPm2L9/v7iM3W6H3W63rL1EJZo0qVW7aOFOTjdMtM00qdNtppNfQPdZpPetxNmrFqxTs2/Fia7SfingJzsSUeAEKme+uAi6YTZXcjqdbnfS8+NwOLB9+3ZUrly5gFtFRERERN7IS7Ox4lUSBdWd+VGjRqFr166oXr06zp49i9mzZ2PVqlVYvnw5AKBv376oWrUqkpKSAADPP/88WrdujTp16uDMmTOYOHEiDh06hIEDBwbybRARERERWSKoOvPHjx9H3759cezYMURHR6NJkyZYvnw5brnlFgDA4cOHYbtsDOvp06cxaNAgpKamonz58khISMD69eu9Gl9PRERERAXPCe1TMXyqpyQKugmwhS1vcgYnwBL5QDP+WRobb2pirAUTYOWJrhY8NEpSUGPmTUyAlSa6ypNa/Z8AqxvvLtWhpIm4HDNP5JeiPAF25+5Klk2Avb7B8SLx3gpT0I+ZJyIiIiIqqYJqmA0RFQOBSJHRlEt3hg0Id+x1X+AWlS82xchK79+3mW1nCfE4YDQlUUnjUJdeVtRTErEzT0REREQBwzHz/uEwGyIiIiKiIMU780REREQUME4YcMD/Bwc6LagjGPHOPBERERFRkOKdeSIiIiIKGKcSU3NN11MSsTNPRP4TkkmkTHm/CQkrSshb17ZCyHw39egNM7nxBcmKTHoz27QAU3ykY0Y5NccYs+eJigWHRcNsrKgjGHGYDRERERFRkOKdeSIiIiIKGN6Z9w8780REREQUME5lwKksSLOxoI5gxGE2RERERERBinfmiYiIiChgOMzGP+zME1HhEhJItGklAAybZnmHULeQqqMcFqSeFFQyT0EqqJw2kykyStcOJtEQ0f84YIPDgsEi0kdDccdhNkREREREQYp35omIiIgoYJRFE2BVCZ0Ay848EREREQUMx8z7h8NsiIiIiIiCFO/ME5H3hAmmlpAmxpqa0aRfWDsB06xgnLBpwf4yivLEX+n9BeO+IirBHMoGh7JgAmwBzfkv6tiZJyIiIqKAccKA04LBIk6UzN48h9kQEREREQUp3pknIiIiooDhBFj/8M48EREREVGQ4p15IiIiIgoY6ybAlswx8+zME5GeBUkoJTZFpqiwYNuZSxMSFGQKkpn18VgiKpIuTYD1f4iMFXUEIw6zISIiIiIKUrwzT0REREQB44QNDkZT+oydeSIiIiIKGI6Z9w+H2RARERERBSnemSciIiKigHHCxifA+oGdeaKSrrCTRpgoUvKY2ecFeTzq6ubxSBRwDmXAoSx4aJQFdQQjDrMhIiIiIgpSvDNPRERERAHjsCjNxsFhNkREREREhcupbHBakGbjZJoNEREREREFE96ZJyIiIqKA4TAb/7AzT0VXQaVaFKf0isJOopEUp21KgVXYyTdW1FGcjv+CvKYUp+1EVISwM09EREREAeOENbGSJfXPRXbmiYiIiChgrHtoVBH5trqQlcx3TURERERUDPDOPBEREREFjEPZ4LAgmtKKOoIRO/MUeIU9ibOoTBolouKB1xTv6LYTJ8USACcMOGHFmHn/6whGvAIREREREQUp3pknIiIiooDhMBv/BNW7fvvtt9GkSRNERUUhKioKiYmJ+Prrr/P9nblz56J+/fqIiIhA48aNsXTp0kJqLRERERFdTd5Do6x4lURB9a6rVauGl156CSkpKdi8eTP+9re/oUePHti5c6d2+fXr16N37964//778dNPP6Fnz57o2bMnduzYUcgtJyIiIiKynqGUCupn31aoUAETJ07E/fff7/GzXr16ITMzE1999ZWrrHXr1mjWrBmmTZvmVf0ZGRmIjo5GR/RAqBFmWbvpMpw8Fvw4iY0CgdeO4MdrR6FZ4ZwL4K9+TXp6OqKiogLapry2vLzpJkSW8X/k94VzuRh549oi8d4KU9COmXc4HJg7dy4yMzORmJioXWbDhg0YMWKEW1mXLl2wcOFCsd6srCxkZWW5/p2RkWFJe6lgGbaSOYPdCspp4u95fvBSUSIdjyY6+bx2+M7UtYMoH06LhsjwoVFBYvv27ShTpgzsdjseeughLFiwAA0bNtQum5qaipiYGLeymJgYpKamivUnJSUhOjra9YqLi7O0/UREREREVgm6zny9evWwdetW/Pjjj3j44YfRr18/7Nq1y7L6R40ahfT0dNfryJEjltVNRERERO6cymbZqyQKumE24eHhqFOnDgAgISEBmzZtwpQpU/DOO+94LBsbG4u0tDS3srS0NMTGxor12+122O12axtNRERERFoOGHBY8MAnK+oIRkH/J4zT6XQb4365xMREJCcnu5WtWLFCHGNPRERERBRMgurO/KhRo9C1a1dUr14dZ8+exezZs7Fq1SosX74cANC3b19UrVoVSUlJAIBhw4ahQ4cOePXVV3Hbbbfhs88+w+bNm/Huu+8G8m0QERER0f9YNUSGw2yCwPHjx9G3b18cO3YM0dHRaNKkCZYvX45bbrkFAHD48GHYbH/tyDZt2mD27Nl49tln8fTTT6Nu3bpYuHAhGjVqFKi3QDoWJFKYUpzi7AoyXYbJNRSseE3xHa8pREEnqDrzH3zwQb4/X7VqlUfZ3XffjbvvvruAWkRERERE/nDAmvHuDv+bEpSCqjNPRERERMULh9n4p2S+ayIiIiKiYoCdeSIiIiIKGIeyWfYya+rUqahRowYiIiLQqlUrbNy4Md/lJ0+ejHr16iEyMhJxcXF47LHHcPHiRV/fuiU4zIaIiIiIAkbBgNOCMfPKZB1z5szBiBEjMG3aNLRq1QqTJ09Gly5dsHfvXlSqVMlj+dmzZ+Opp57C9OnT0aZNG+zbtw/9+/eHYRiYNGmS3+33Fe/ME/nAsBkF9jLZEP2LiAqGBedbkbh2EBEmTZqEQYMGYcCAAWjYsCGmTZuGUqVKYfr06drl169fj7Zt2+Lf//43atSogVtvvRW9e/e+6t38gsZPfSIiIiIKmEAMs8nOzkZKSgo6d+7sKrPZbOjcuTM2bNig/Z02bdogJSXF1Xn/7bffsHTpUnTr1s2/DeAnDrMhIiIiooBxKgNO5f+3S3l1ZGRkuJXb7XbY7Xa3spMnT8LhcCAmJsatPCYmBnv27NHW/+9//xsnT55Eu3btoJRCbm4uHnroITz99NN+t90fvDNPRERERMVGXFwcoqOjXa+kpCRL6l21ahXGjx+Pt956C1u2bMH8+fOxZMkSvPDCC5bU7yvemSciIiKigHHABocF95fz6jhy5AiioqJc5VfelQeAihUrIiQkBGlpaW7laWlpiI2N1db/3HPPoU+fPhg4cCAAoHHjxsjMzMQDDzyAZ555BjZbYO6R8848EREREQVM3jAbK14AEBUV5fbSdebDw8ORkJCA5OTkv9rhdCI5ORmJiYnadp4/f96jwx4SEgIAUEpZtTlM4515KrqU07MsAEkthZ0SoVufcvp/kbCiDqLiRjovrDjvi8K1AwjAua+7dhMVQSNGjEC/fv3QokULtGzZEpMnT0ZmZiYGDBgAAOjbty+qVq3qGqbTvXt3TJo0Cc2bN0erVq2wf/9+PPfcc+jevburUx8I7MwTERERUcA4YYPTgsEiZuvo1asXTpw4gdGjRyM1NRXNmjXDsmXLXJNiDx8+7HYn/tlnn4VhGHj22Wdx9OhRXHvttejevTtefPFFv9vuD0MF8nuBIJCRkYHo6Gh0RA+EGmGBbg4Jd+ZN3QEzeXe/KOQ3m76zprkzZkUdREHNxLkvnvdW1FHITJ37Js57sV5eO4qkFc65AP7q16Snp7uNKw+EvLY8vPafsJfxv4+VdS4Hb980v0i8t8LEMfNEREREREGKw2yIiIiIKGCszpkvadiZp2LB1CQ26Stg4etzM19RW/G1ekF9JV6gdQQjK4ZbBWBCtpawDwv9WCrqrJhUb6KOgppca8mEVpP7mxPoiYouduaJiIiIKGCUssGp/L85oiyoIxixM09EREREAeOAAQf8/2bbijqCUcn8E4aIiIiIqBjgnXkiIiIiChinsmbyakmd2sHOPBEREREFjNOiMfNW1BGM2Jmn4GI6gcHMA15M1G1B8o0pJSF5wswDwcw+PEy3fIhUh3DMGJq6zSxrBekZf07h+NAsr6RlHVIdJh5AZiZVp4in5xSVhCxTrHjgkwV1E1HhYmeeiIiIiALGCQNOCyavWlFHMGJnnoiIiIgCxqEMOCwYM29FHcGoZA4uIiIiIiIqBnhnnoiIiIgChhNg/cPOPBEREREFjBOGNdGUHDNPVAyZSncooOSbAlRkUmuE1A79ovqLrRES4n3dUhKNVIemXF7WREKNVIfETMqNlFyj43B4XYchpNYoqQ5dubisvm5Dl4gj1GHqmA5AwoqufWKKUiG3r6hvOyIqGOzMExEREVHAKIvSbFQJvTNfMgcXEREREREVA7wzT0REREQB41QWjZkvodGU7MwTERERUcAwzcY/JfNdExEREREVA7wzT5THTPKNEOZhiokEmAJlQRKNVId2eWl9ZhJqhBQZI0y4pNl0iThCEk2olKpjIs3GTGqNGVLCjYk0G+TqlzWkOpya8yIn11Q7dMk1hnTMCOehNqlF+Eq9sFOeLFkf02WoBOMwG/+wM09EREREAeO0KM2mpObMF5Fbg0REREREZBbvzBMRERFRwHCYjX/YmSciIiKigGFn3j/szBclhT0hkhOuAqsgt38BTWo1OwFWN6lVO6EVkCe1aifACusLFS5pukmtNqkdQt3aSbT6ZVUBTYA1xAmwwnvRTV6V3rdTmACrmTBrSO9PaoduYqyJybIAYDg070X64DaE7aQ550xPXuV1s3gKRCABjyWyCDvzRERERBQwvDPvH3bmiYiIiChg2Jn3D9NsiIiIiIiCFO/MExEREVHAKFiTEV+4j4srOtiZJyIiIqKA4TAb/wRVZz4pKQnz58/Hnj17EBkZiTZt2mDChAmoV6+e+DszZ87EgAED3MrsdjsuXrxY0M0t+szM3ues+6BnNolGmyIj1GEqoUZIgBHr0CXU6JJl8qnbijqUbnnpFCqgNBspzAaGkATk1LRDaptuWYlUR4j+OmHkei6vpGNJ2i82z5QbMflGSLNRmsUNm77NplNuqOgJREINUQAE1ZG+evVqDB48GD/88ANWrFiBnJwc3HrrrcjMzMz396KionDs2DHX69ChQ4XUYiIiIiLKT96deSteJVFQ3ZlftmyZ279nzpyJSpUqISUlBe3btxd/zzAMxMbGFnTziIiIiIgKVVDdmb9Seno6AKBChQr5Lnfu3DnEx8cjLi4OPXr0wM6dO8Vls7KykJGR4fYiIiIiooLBO/P+CdrOvNPpxPDhw9G2bVs0atRIXK5evXqYPn06Fi1ahI8//hhOpxNt2rTB77//rl0+KSkJ0dHRrldcXFxBvQUiIiKiEo+def8EbWd+8ODB2LFjBz777LN8l0tMTETfvn3RrFkzdOjQAfPnz8e1116Ld955R7v8qFGjkJ6e7nodOXKkIJpPREREROS3oBozn2fIkCH46quvsGbNGlSrVs3U74aFhaF58+bYv3+/9ud2ux12u92KZpqnS4wpKrPxpXYw5aZI0ibXmEmtAbSpLqZSa6TlzSTOAPrUGakOqX26OqRElgJKogkI3XuR3p+UIqPbL4Y+RQYO77epIW5/IV3GRB1iyo12WaEZUsqNsDwFUFH5nJTwc/KqlDKgLLirbkUdwaiInwHulFIYMmQIFixYgJUrV6JmzZqm63A4HNi+fTsqV65cAC0kIiIiIjOcMCx7lURBdWd+8ODBmD17NhYtWoSyZcsiNTUVABAdHY3IyEgAQN++fVG1alUkJSUBAJ5//nm0bt0aderUwZkzZzBx4kQcOnQIAwcODNj7ICIiIiKyQlB15t9++20AQMeOHd3KZ8yYgf79+wMADh8+DNtlXxefPn0agwYNQmpqKsqXL4+EhASsX78eDRs2LKxmExEREZGAT4D1T1B15pX4+MO/rFq1yu3fr732Gl577bUCahERERER+YNj5v0TVGPmiYiIiIiCUb9+/bBmzRrL6w2qO/NEdAUpxUFTbia1BgCMsDDvlzWTImNmWWmdUh1WJNEI3wAaunIppKKgEnG8+HbScrr3Im1/M6T0IiEpR5fQpHSpTQAM4VhSyPFcVmiemFpjaPYB00qI/FJShtmkp6ejc+fOiI+Px4ABA9CvXz9UrVrV73p5Z56IiIiIAiZvmI0Vr6Js4cKFOHr0KB5++GHMmTMHNWrUQNeuXTFv3jzk5HjebPAWO/NERERERIXg2muvxYgRI7Bt2zb8+OOPqFOnDvr06YMqVargsccewy+//GK6TnbmiYiIiChg1P+G2fj7Kup35i937NgxrFixAitWrEBISAi6deuG7du3o2HDhqaDW9iZJyIiIqKAUbg0JcjvV6DfyFXk5OTgiy++wO233474+HjMnTsXw4cPxx9//IFZs2bh22+/xeeff47nn3/eVL2cAFvUSROrivrjq6lQ6CYFiuVmJroKyxvSpEVTE2ClSbvCHRUzx7qZCaJO4dySJj5awWmifcK+LTDS9jezTaV9pTs8pPcntUOzvwxhWYVcfdXwPNZ1k2IBwJCuvZo7f+JkWSpZOBGarqJy5cpwOp3o3bs3Nm7ciGbNmnks06lTJ5QrV85UvezMExEREVHAOGHAELOlzNVTlL322mu4++67ERERIS5Trlw5HDhwwFS9vL1LRERERFTAvvvuO21qTWZmJu677z6f62VnnoiIiIgCpqREU86aNQsXLlzwKL9w4QI+/PBDn+vlMBsiIiIiChinMmAU44dGZWRkQCkFpRTOnj3rNszG4XBg6dKlqFSpks/1szNPRERERFRAypUrB8MwYBgGrrvuOo+fG4aBcePG+Vw/O/PBysys+YJMvpHq5qx+awnb2ZBSZDSpM1JqjZxQo1mntKwutUaqw+zxqEs9MZMKA+jjRqSUFoeUYqJZ3kzSCyAn6OhI21RHTALyPtXIkjQhKaHGqTsOhDqkdjg05cKy4r05w/vtL+1ZXd1KOh55HbReYSe5cR8WirxoSSvqKYq+++47KKXwt7/9DV988QUqVKjg+ll4eDji4+NRpUoVn+tnZ56IiIiIAsaq8e5Fdcx8hw4dAAAHDhxA9erVxVhdX7EzT0RERERUAH7++Wc0atQINpsN6enp2L59u7hskyZNfFoHO/NEREREFDDF+c58s2bNkJqaikqVKqFZs2YwDANKMx7IMAw4HL49gY6deSIiIiIKmOKcZnPgwAFce+21rv8uCOzMExEREREVgPj4eO1/W4md+ZLA7Gx8M2kBnOlvPc32t4UJp6qQLqNNrpFSTKRyXd1mUmsA/bEkJZ5IdEkh0nEnJdHoUmSkrzNz9eVKt7wUnSCl1piJWtBNkJK2v5Tqoks7ChUSkKRkJN06pf2tS60BzO1zqQ6heVpS6hJyPYuUkBQFffqTbg9KV0xnjmZ9AK+b/tBtO7MJN9z+RU5xT7PJM2vWLFSsWBG33XYbAGDkyJF499130bBhQ3z66ac+d/b5BFgiIiIiCphLnXkrngAb6HeSv/HjxyMyMhIAsGHDBrz55pt4+eWXUbFiRTz22GM+18s780REREREBezIkSOoU6cOAGDhwoW466678MADD6Bt27bo2LGjz/XyzjwRERERBYw1d+WtScQpSGXKlMGff/4JAPjmm29wyy23AAAiIiJw4cIFn+vlnXkiIiIiogJ2yy23YODAgWjevDn27duHbt26AQB27tyJGjVq+Fwv78wTERERUcAoC19F2dSpU5GYmIgTJ07giy++wDXXXAMASElJQe/evX2ul3fmyRNn+ltLSFrQJo1I5UJ6iDa1BoChS/MoyBQTKU3CVIqJlAyjSZGRUmtyhfQQTUKNEpZVOTle161NuMmn3F+mjhkASnMcmDpmAP1xo4RlQ6SPUk0d0rEhletSbswk3ADalBvxseqG9/tQetc24bzQHR/iMcPr8dVxGwW94vzQqMuVK1cOb775pkf5uHHj/KqXnXkiIiIiokJw5swZbNy4EcePH4fzshhjwzDQp08fn+pkZ56IiIiIAseqMTI+1DF16lRMnDgRqampaNq0Kd544w20bNlSXP7MmTN45plnMH/+fJw6dQrx8fGYPHmya/x7fhYvXox7770X586dQ1RUlNs3g/505jlmnoiIiIgCx6okG5PDbObMmYMRI0ZgzJgx2LJlC5o2bYouXbrg+PHj2uWzs7Nxyy234ODBg5g3bx727t2L9957D1WrVvVqfY8//jjuu+8+nDt3DmfOnMHp06ddr1OnTplq++V4Z56IiIiISpxJkyZh0KBBGDBgAABg2rRpWLJkCaZPn46nnnrKY/np06fj1KlTWL9+PcL+N//ITArN0aNH8eijj6JUqVKWtD8PO/MUeGYfxV3IDN2EPGlSq4llxUmt2gmwwsTHMOEU1k1elSY4ipNaNe9FmixrhpmJroB28qo00VWa1Ipsz0mtKjtb34wcoY4iMMnO9IRbzXuxSdsoPFxYqeeEWUN6zKI0MVZbLE28NjMx1uTxqD0/zd3J05/jQh3SfnF4nnOGQ3gvmuNOSeeQcIyKyxcFReC8osC79ARYa+rxVnZ2NlJSUjBq1ChXmc1mQ+fOnbFhwwbt73z55ZdITEzE4MGDsWjRIlx77bX497//jSeffBIhXnw+dunSBZs3b0atWrW8b6gX2JknIiIiooCxOs0mIyPDrdxut8Nut7uVnTx5Eg6HAzExMW7lMTEx2LNnj7b+3377DStXrsS9996LpUuXYv/+/XjkkUeQk5ODMWPGXLV9t912G/7zn/9g165daNy4sevufp477rjjqnXosDNPRERERMVGXFyc27/HjBmDsWPH+l2v0+lEpUqV8O677yIkJAQJCQk4evQoJk6c6FVnftCgQQCA559/3uNnhmHA4WOsMTvzRERERBQ4PkxeFesBcOTIEURFRbmKr7wrDwAVK1ZESEgI0tLS3MrT0tIQGxurrb5y5coICwtzG1LToEEDpKamIjs7G+HScMX/uTyK0kqmBys3a9YMgwYNwrRp07Bp0yZkC+NOiYiIiIiuJm/MvBUvAIiKinJ76Trz4eHhSEhIQHJysqvM6XQiOTkZiYmJ2na2bdsW+/fvd+uU79u3D5UrV75qR/5KFy9eNLV8fkx35n/++WdMnz4dgwcPRuvWrVG2bFnccMMNeOCBB/DOO+8gJSUFOdITFImIiIiIioARI0bgvffew6xZs7B79248/PDDyMzMdKXb9O3b122C7MMPP4xTp05h2LBh2LdvH5YsWYLx48dj8ODBXq3P4XDghRdeQNWqVVGmTBn89ttvAIDnnnsOH3zwgc/vw/Qwmw8++AApKSlISUnBtm3bcPHiRWzduhVbt251NSQsLAyNGjVCQkICWrRogYSEBDRp0gShUpoGlQwmU2u0qREm67aiDl0ChjZxBjCXACO0TVu3Lp0m37o1y4upNd6/b9N0KRpmUmsAbXKNmdQaQJ9c4ywJ3ypqkkKk9y2dnbqjQAqMMHXEiB8HJlNutFUIdeiORymJRirXfE1uSOen9JW6blyslDijWVZKE5JSjQxd3SZTZLSJOFbUIV1/mHJTsgTooVG9evXCiRMnMHr0aKSmpqJZs2ZYtmyZa1Ls4cOHYbvs/I6Li8Py5cvx2GOPoUmTJqhatSqGDRuGJ5980qv1vfjii5g1axZefvll1/h5AGjUqBEmT56M+++/39wb+B9DKd/DgBwOB3bt2uXq3Od18C9cuPDXCv53QbTb7WjdujXuuece9O3b1/KMzYKSkZGB6OhodEQPhBqeEW1kAjvzV61XrJudeTfszFvPJnxFbOjKw/XXQkO6YaMrD5WOXQs68xIzHVKHUK7roEuT1oTOvLbTbaIzL+XviRGlRbkzLy9sqm66uhXOuQD+6tekp6e7jSsPhLy2VH93NGylIvyuz3n+Ig4/8HyReG86derUwTvvvIObb74ZZcuWxbZt21CrVi3s2bMHiYmJOH36tE/1+nWrPCQkBI0bN0bjxo3Rv39/AJfGG+3atQubN2/26OCvWrUKq1evxn//+1/Mnj0b7du392f1RERERERB4ejRo6hTp45HudPp9GuIuuXjXmw2Gxo1aoRGjRp5dPDXrVuH2bNnY926dbjtttuwZcsW1K1b1+omEBEREVEwKcLPNrNKw4YNsXbtWsTHx7uVz5s3D82bN/e5XtMTYOfNm4fz58+bW8n/OvgPPfQQ1qxZgzfffBOZmZmYMGGC2dUTEREREQWd0aNHY8iQIZgwYQKcTifmz5+PQYMG4cUXX8To0aN9rtd0Z/6ee+7BtddeizvvvBOffPKJx1O2vPHII4+gcePGbnFARERERFTy5D0B1opXUdajRw8sXrwY3377LUqXLo3Ro0dj9+7dWLx4MW655Raf6zU9zOa5557D/PnzsWDBAixcuBBhYWG4+eabceedd+KOO+5AxYoVvaqnYcOGWLBggekGU/EjTlLVTMwUlzUxIVWcvCpOMtW0Q5o0qptkanZ92km0FkxeldI5zJDmy0sT23STXU1MdAWEya4mJroCnOzqDTMpN9KRVOgpN+K1Q7pO6Mqlc9nEsW5yEq02jcZM8o00OddMO8xMzoXQZmFZaaKrYfNcp6lJsVR8BSjNJhBuuukmrFixwtI6Td+ZHzduHLZv3449e/bghRdeQKNGjfD1119j0KBBqFy5Mm6++Wa89dZbOHbsWL71PProoxg6dKjPDSciIiIiCha1atXCn3/+6VF+5swZ1KpVy+d6TXfm81x33XV4+umnsXnzZhw4cAATJ05Ey5YtsWrVKgwZMgRxcXFo27YtJk2ahIMHD3r8fmJiIiZOnOhzw4mIiIioODAsfBVdBw8ehEPzjVZWVhaOHj3qc70+d+YvFx8fjxEjRuD777/H0aNH8eabb6JDhw7YuHEjnnjiCdSuXRstWrTA+PHjsWfPHp/Xk5SUhBtvvBFly5ZFpUqV0LNnT+zdu/eqvzd37lzUr18fERERaNy4MZYuXepzG4iIiIjIQsrCVxH05Zdf4ssvvwQALF++3PXvL7/8EgsWLMALL7yAGjVq+Fy/5dGUsbGxeOSRR/DII4/g1KlTWLhwIb744gskJydjy5YteO655zBhwgQ88cQTputevXo1Bg8ejBtvvBG5ubl4+umnceutt2LXrl0oXbq09nfWr1+P3r17IykpCbfffjtmz56Nnj17YsuWLWjUqJG/b5eIiIiISNSzZ08Alx6k2q9fP7efhYWFoUaNGnj11Vd9rt/yzvzlKlSogPvuuw/33XcfMjIysHjxYixYsMD1VFizli1b5vbvmTNnolKlSkhJSREfQDVlyhT8/e9/x3/+8x8AwAsvvIAVK1bgzTffxLRp03xqBxERERFZpJhPgHX+b8J5zZo1sWnTJq/DYrxVoJ35y0VFReHee+/Fvffea1md6enpAC790SDZsGEDRowY4VbWpUsXLFy40LJ2kJ+ERBZt6oyQ6iIm1GjKxWWlx8vrljeRfGNJmo0Vj7KXiEk0ugQME6k1gD65xkxqDaBNrlE5+mWdQjn5TrdNbdI5K9ShO2pMH9HaTyvpnBVq151zgTi3CijNxjBTh5QqJSTU6MqVcGPOENqntFUL66OSRRmXXlbUU4QdOHCgQOq1pDOfnZ2NX375BceOHYPD4UCVKlXQsGFDhEidGAs4nU4MHz4cbdu2zXe4TGpqKmJiYtzKYmJikJqaql0+KysLWVlZrn/7kqNPRERERHSl5ORkJCcn4/jx46479nmmT5/uU51+d+bbt2+PTZs2IfuKjOJSpUqhc+fOuO+++9C9e3d/V+Nh8ODB2LFjB9atW2dpvUlJSRg3bpyldRIRERGRnlLyY0zM1lOUjRs3Ds8//zxatGiBypUr+zzs/Ep+d+Yv70yHhoZCKQWHw4HMzEwsWrQIX375JRITEzF79mxUr17d39UBAIYMGYKvvvoKa9asQbVq1fJdNjY2FmlpaW5laWlpiI2N1S4/atQot2E5GRkZiIuL87/RREREROSpmI+ZzzNt2jTMnDkTffr0sbRev6Mp3333Xfz0009IT09HdnY2cnJy8Mcff+Crr77Cww8/jOjoaKxfvx6dOnXCqVOn/FqXUgpDhgzBggULsHLlStSsWfOqv5OYmIjk5GS3shUrViAxMVG7vN1uR1RUlNuLiIiIiMgf2dnZaNOmjeX1+t2ZHzhwIJo2bYqyZcu6ymJjY9GtWzdMnToVBw8exD333IMDBw5g/Pjxfq1r8ODB+PjjjzF79myULVsWqampSE1NxYULF1zL9O3bF6NGjXL9e9iwYVi2bBleffVV7NmzB2PHjsXmzZsxZMgQv9pCRERERBbImwBrxasIGzhwIGbPnm15vQWeZhMVFYVPPvkEP/30ExYsWIBXXnnF57refvttAEDHjh3dymfMmIH+/fsDAA4fPgzbZYkFbdq0wezZs/Hss8/i6aefRt26dbFw4UJmzAeAIaRGSOW6lAkxiSZMfygboZpyXRkgp9nolhfTczz/PlZmkjUAfZqNRBogqCt36Jc1ICRg6IqVlJYhlGsSasyk1gD65BqVq19WbB/5TrNNxe0v0B3R0rfh4tGvOy/Ec0U4tzTXFCUmUwl1m2qHwESajaE7b6XzTUqi0Z1zIfplDTFtSnM91q8NSrguGbqOltD50iffUHFlqEsvK+opyi5evIh3330X3377LZo0aYKwsDC3n0+aNMmnegslmjIkJATNmzfHokWL/KpHukBcbtWqVR5ld999N+6++26/1k1ERERE5Kuff/4ZzZo1AwDs2LHD7Wf+TIa1vDN/7NgxbNiwAfXr10dsbCwcDgfWrl2LZcuWXXWyKhERERGVMCVkAux3331XIPVa3pn/7bffcNddd3n8hRESEoLRo0dbvToiIiIiohLL8s587dq1MXz4cKxduxZbtmyBUgr//Oc/MWHCBNSuXdvq1RERERFRMCvGT4D95z//iZkzZyIqKgr//Oc/8112/vz5Pq3D8s58bGysawD/77//jrfeeguTJ0/GH3/8gaVLl6JcuXJWr5KCnfRoeN0kU2HiqXaiKwBcMblELAPESbQq3Pt2qFDNBFhpgp2ZLClhvpshzSPJ9fwFQ3psupmLn4mJroAw2VUzoRUAlDB5T1eunEX8u9RiTtz+0gRM3WT2HGHio7BO7XhSaYyp9MmmW16Y6KqkSe66c1xqhxXnuGZirKE5vwGI29/I1rwXmzARXXgv2knMwnEgXZf0y3OmK6FYD7OJjo52Xb+io6MLZB1+d+Y3b96MFi1aaH9WrVo1jB8/HnfeeSfat2+P0aNH4/XXX/d3lURERERERd6MGTO0/20lv3PmExMTMXToUJw4cUJcJiEhAV27dsWCBQv8XR0RERERFSfKwlcJ5HdnPiYmBm+99RZq166NESNGYPfu3R7LOJ1O7N+/H3/++ae/qyMiIiKi4oSdeb/4Pcxm165dePzxxzFjxgxMmTIFU6ZMQXx8PG688UZUr14dTqcTK1euxPbt29G4cWMr2kxERERERLCgMx8VFYX33nsPQ4cOxdixY7F48WIcPHgQBw8edA34V0rBMAw888wzfjeYiIiIiIqRYpxmUxgsS7Np0qQJ5s+f70qtSUlJwcGDB5GTk4OaNWuiX79+aNeunVWrK3yGTUxdAcDHyF9Jt62k7adJuri0vCYBQ0yYMJFmY9en2agwIaEm3LNucdkQTdKF9Fh4M6THo+fqy7VbWnyCsnDs6paX6hAeRa9Lv9Em3AByEoqZcyu/c9RjUSG1QzrGdHVr9velRf0ewailTGzn//2CZ5GUGmRFQpC0r3SJREIV4rYL0dQtHY9ePC3cRVqfJrUGAJyac1+Fen8NM8tweL4XQ9jfRo7wXnTXUum6K9FsU6kd0jGmvdZL56wh7Vt+1roxcc0rygwl73Kz9ZRElkdTVqlSBQMHDsTAgQOtrpqIiIiIKGiYSXF89NFHfVqH5Z15IiIiIiKvFeOc+ddee83t3ydOnMD58+ddz106c+YMSpUqhUqVKvncmS8e388QERERERUxBw4ccL1efPFFNGvWDLt378apU6dw6tQp7N69GzfccANeeOEFn9fBzjwRERERUQF77rnn8MYbb6BevXqusnr16uG1117Ds88+63O9HGZDRERERAFjwKIJsP5XUaCOHTuGXE0IhMPhQFpams/1sjNvFd2Mcs66dyOmJ0iJD7pUESE9BKFSyo0mecJEag0AOLVpNvp26JJrpDQbJbxvQ5saIVzlhKuf0qV55ArHo9QOXbqJkBIiplfoyoXUFDNpKqaTaDTlhpiApC/XLi/VISWkmEkQ0WwPQ0qzERKCdMlBRo73ywLQJ9FI+1ug27eG9Mktpe04PLep7lwBIB9jmmNdOg+VkGajO/fFc9zEuS+9F32ajXD8C+/FzFfwUkINnJpzK1dKHhLOQ82+lc5lZe4QK/6KSWpNSXfzzTfjwQcfxPvvv48bbrgBAJCSkoKHH34YnTt39rleHh1EREREFDh5OfNWvIqw6dOnIzY2Fi1atIDdbofdbkfLli0RExOD999/3+d6Lbszv2bNGsTGxuK6664DAOzbtw+pqalo3769VasgIiIiouKmGKfZXO7aa6/F0qVLsW/fPuzZswcAUL9+fVff2VeWdeY7duyIAQMG4IMPPgAAJCUl4cMPP4TD5NexRERERETFVY0aNaCUQu3atREqDdc0wdJhNtpxukREREREEmXhqwg7f/487r//fpQqVQrXX389Dh8+DAAYOnQoXnrpJZ/r5Zh5IiIiIgoYQ1n3KspGjRqFbdu2YdWqVYiIiHCVd+7cGXPmzPG5XqbZFCRp9nkJSLnRJhQI28Mwk/whpSTYTKTZCHWIKTea9ApnuL7NTl2ajZkEEwCGZgKPlPxhE44l3ToNIVnDFLPpIbr0FZPHvzahRjqWwsOE8nDPQmFZsTzMs1wJyTcQklDE5CYdE4lEUkKNkZPjWZitKQNgCOUqO9vrOqR9q00qEpcV3qOJdCVTpMQZKWVFU+6Ukm/ENBtdqZTQ5PkebUK6lXR3TinNOSTUYYRKiUm6dDHpeiwcj5prvRI/F0poyg1Ta4q1hQsXYs6cOWjdurVb+tT111+PX3/91ed62ZknIiIiosApIRNgT5w4gUqVKnmUZ2ZmitGy3uCfgEREREQUOCVkzHyLFi2wZMkS17/zOvDvv/8+EhMTfa6Xd+aJiIiIiArY+PHj0bVrV+zatQu5ubmYMmUKdu3ahfXr12P16tU+18s780REREQUMCVlAmy7du2wdetW5ObmonHjxvjmm29QqVIlbNiwAQkJCT7XyzvzgWBmgksRnyyrnZwI6N+jNBFUqENbtzRZNsTEBDSzE95MTGrVLmt24qluYppwgRIn1/ox9s4nQju0E96k/S1dhTX71tBMRgXkCbCw2z3LIjRlAFSEvg5l9yx3mpg0DZh7OKFucxg5+uuBLUc/K9DI8pyoalwUJq+GZOnr0O1b4TxUugm3AAyHpt0mjpn8li8wwjmkO+eUlHUglZu5Jmh2rTTvV5xwa2JCvFSHobvGCvtK+lxQIZrjQHoWjTQxVlO1KurPs+Gk1quz6umtRfwJsABQu3ZtvPfee5bWySOMiIiIiKiAbdmyBdu3b3f9e9GiRejZsyeefvppZOuSw7zEzjwRERERBU4JmQD74IMPYt++fQCA3377Db169UKpUqUwd+5cjBw50ud62ZknIiIiooApKWPm9+3bh2bNmgEA5s6diw4dOmD27NmYOXMmvvjiC5/rZWeeiIiIiKiAKaXg/N+D8b799lt069YNABAXF4eTJ0/6XK9lE2D79euHdu3auf59+X8TEREREWmVkIdGtWjRAv/973/RuXNnrF69Gm+//TYA4MCBA4iJifG5Xss68zNmzHD79/3334/777/fquoDTzkB5JMsU1Cz1YvILHjp0dpy4oBn5ICcfGMikcXMshbVoTTl4oR5KxI3dHWIh56JK5f0vqVDTNcOoQ5DOA50yTWmn3Knq8Merl9WLPdMrlGR+mWdkfo0G0eE5+XSGa5/385Qc0khOoYm1ciWq9/ftmz9uRUS6tk+m5RAIh4fmiQUKXFGqsNM2ojYPk25iTZfKtdW7F278mO2HWbo0nOEsQS6axWAInMt1ZWLnwtO4T1qDiVdwg0AKKGOYqWIJ96Ru8mTJ+Pee+/FwoUL8cwzz6BOnToAgHnz5qFNmzY+18toSiIiIiIKHKvGuxfxv9+aNGnilmaTZ+LEiQiR/rD1AjvzRERERBQ4JWSYjSQiIsKv32dnnoiIiIioAFSoUAH79u1DxYoVUb58+XyHmp46dcqndbAzT0RERESBU4zvzL/22msoW7YsgEtj5gsCO/NEREREFDBWZcQXxZz5fv36af/bSpZ05rOzs/HLL7/g2LFjcDgcqFKlCho2bOjXYP6go5tRbkESjZgiU5A07TabZoMQ75MnxDQDXbmu3nzqtiKpwlCeVwdDiLNRmgQSw0SCCQBAV4eQyqBrm2liEodmW4dKsRH6BBhTx6/UjlDNZSpMuHRFeKbWAIAzwjO5RkqtcUbo32OuptwZrm+zmGZjYnvo9rmYZiMdY5piKfHEJpWbSTWSzuXcXE1DTB67uuNAOh7Npu2YoL0emEheAUxeE3TXA2HTFej1QFcuXY+F48AI8fycVFLSkVC3tnVSvJi0oQo5AcaSVB2m1gStjIwMr5eNioryaR1+d+bbt2+PTZs2ITs72628VKlS6Ny5M+677z50797d39UQEREREQWVcuXKXTWSWSkFwzDgMBPjexm/O/Pr1q37q7LQUCil4HA4kJmZiUWLFuHLL79EYmIiZs+ejerVq/u7OiIiIiIqTorxmPnvvvuuwNfhd2f+3XffxY033ohatWq5BvinpqZiy5YtWLJkCT799FOsX78enTp1wqZNm1ChQgW/G01EREREVNR16NChwNfh9aDu6OhotGnTBkuXLnUrHzhwIJo2berqyANAbGwsunXrhqlTp+LgwYO45557cODAAYwfP966lhMRERFR0MubAGvFKxicP38ee/bswc8//+z28pXXnfmkpCTk5uaiZ8+eOHbsmNcriIqKwieffIK6detiwYIFPjWSiIiIiIoxZcGriDtx4gRuv/12lC1bFtdffz2aN2/u9vKV18NsHnnkERw+fBgpKSk4c+YMKleu7PVKQkJC0Lx5cyxatMinRuZZs2YNJk6ciJSUFBw7dgwLFixAz549xeVXrVqFTp06eZQfO3YMsbGxfrXFK9LscwtSbszUYToRR1e3mGZjItVCSiAxm1Bjhi7dQUp8kBJjdGkSwp//Nt3qTCYZ6KqW0jKkNptKCpG2s26/hOkTYOQ6TCRaSceBiTQbp13fPhXhubzTrm+bQyjXJdc4w/RtdgqHujJx6htO71NkAP21xqE078VkEoquZin5BqGa1BpAn2bjMJnOoTs+dMeGtCxg7ppi4johnZ/S7jZzTTB0QWmaa1J+5drrhPT+CjIRR3tN0e9DaU9pWyek2UjXaTH9Rreomeu3FYkzTK0p1oYPH44zZ87gxx9/RMeOHbFgwQKkpaXhv//9L1599VWf6/W6M7948WK88sor+Ne//oUGDRqIyx07dgwbNmxA/fr1ERsbC4fDgbVr12LZsmWoVq2azw0FgMzMTDRt2hT33Xcf/vnPf3r9e3v37nWL+6lUqZJf7SAiIiIiixTjCbCXW7lyJRYtWoQWLVrAZrMhPj4et9xyC6KiopCUlITbbrvNp3q97swPGzYMDRo0wMyZM/Nd7rfffsNdd93lEcMTEhKC0aNH+9TIPF27dkXXrl1N/16lSpVQrlw5v9ZNRERERNYrzg+NulxmZqbrhnL58uVx4sQJXHfddWjcuDG2bNnic71ef+nrcDhw4cIFLFmyJN8A/Nq1a2P48OG44YYbAFzKzvzHP/6B3bt3o0+fPj431B/NmjVD5cqVccstt+D7778PSBuIiIiIqOSqV68e9u7dCwBo2rQp3nnnHRw9ehTTpk0zNXz9Sl535j/66CPY7Xbceeed2Lp1q7hcbGwsJk2ahE2bNuHQoUN46qmnsHTpUvTp0wdnzpzxuaG+qFy5MqZNm4YvvvgCX3zxBeLi4tCxY8d8//rJyspCRkaG24uIiIiICogVk1+DYBLssGHDXCEyY8aMwddff43q1avj9ddf9yvx0VDK3GyXc+fOITw8HOHhlx6PvnnzZrRo0SLf30lJSUH79u1x//334/XXX/e5sZczDOOqE2B1OnTogOrVq+Ojjz7S/nzs2LEYN26cR3lH9ECoIUz+M0uYvGpqoqqZOqTJsiYmtRrS49GlCY6aiU7io97FSWya5aVlhUlUKtyzDiXVESpMZgzT1aHfdkq7/S14hLyJybmXyj0nURm5wsQqodzQPYlOWp9TqFvXbuG4U9IxptkvSrNP8ivXTWp1ao4NAHCG6dvnDPdsh1M4DqQJsOKsPh3dphPml9pyhQmY2Z77xZYjLat/8mBIlme5kaNfVirXHWOmjhlAe9yIx0yIcIxpryn6OpRUrrm2KWl9ZsMHtJV4P+HWkI4D3X6RznvdZGUAhu74yDEx4RkAdNcUYVklPQlTN3FaWFZJx5iu2yOGCejr0E6MNTl51Yo6zFjhnAsAyMjIQHR0NNLT093mEwZCXlvq/mc8QuwRftfnyLqIXyY+XSTemzfyIiqrV6+OihUr+lyP6ViVMmXKuDryAJCYmIihQ4fixIkT4u8kJCSga9euRSKasmXLlti/f7/481GjRiE9Pd31OnLkSCG2joiIiKhkKWk583lKlSqFG264wa+OPOBDZ/5KMTExeOutt1C7dm2MGDECu3fv9ljG6XRi//79+PPPP/1dnd+2bt2a77gku92OqKgotxcRERERFZAADrOZOnUqatSogYiICLRq1QobN2706vc+++wzGIZhaoSIUgpz587FI488grvuugv//Oc/3V6+8jrNRrJr1y48/vjjmDFjBqZMmYIpU6YgPj4eN954I6pXrw6n04mVK1di+/btaNy4sV/rOnfunNtd9QMHDmDr1q2oUKECqlevjlGjRuHo0aP48MMPAQCTJ09GzZo1cf311+PixYt4//33sXLlSnzzzTd+tYOIiIiIgtucOXMwYsQITJs2Da1atcLkyZPRpUsX7N27N98Y84MHD+KJJ57ATTfdZGp9w4cPxzvvvINOnTohJibGI/nRV3535qOiovDee+9h6NChGDt2LBYvXoyDBw/i4MGDrkYqpWAYBp555hm/1rV582a3h0CNGDECANCvXz/MnDkTx44dw+HDh10/z87OxuOPP46jR4+iVKlSaNKkCb799lvtg6SIiIiIKAAClDM/adIkDBo0CAMGDAAATJs2DUuWLMH06dPx1FNPaX/H4XDg3nvvxbhx47B27VpT4S4fffQR5s+fj27duplr6FX43ZnP06RJE8yfPx9//PEHli5dipSUFBw8eBA5OTmoWbMm+vXrh3bt2vm1jo4dOyK/+bpXZuCPHDkSI0eO9GudRERERFRwrM6ZvzKJ0G63w263u5VlZ2cjJSUFo0aNcpXZbDZ07twZGzZsENfx/PPPo1KlSrj//vuxdu1aU+2Ljo5GrVq1TP2ONyzrzOepUqUKBg4ciIEDB1pddfEhzo7XJMAIaQhi8o0uucZEag0gpM5ISTRS+3TLS8kT0tdMZpIghD/y9GkvQtKCZvsDgE2XiJBtIpHF75kpPjATiCAmcWj2oRDoZOoaLOxvM8kkukQRQE6X0SaQmNwvumNJqsIQgjj8TbORPuykVCNttUKjpW3qsHuW2YRlDSFNSJeCJKbZmAtYM8fMV9pScpPSpPsIlxRLaDaT2W2nTbIS6hCPJTP7Rbp2OzXlwnkv7SltK6TPMinlRlcunczC54Jh89x+mkPjUrnJpBzyX1xcnNu/x4wZg7Fjx7qVnTx5Eg6HAzExMW7lMTEx2LNnj7bedevW4YMPPsg3oj0/eYmJ06dPR2RkpE916FjemSciIiIi8prFw2yOHDniFmBy5V15X5w9exZ9+vTBe++953P6zD333INPP/0UlSpVQo0aNRAW5n6HzNenwLIzT0RERESBY3Fn3ps0wooVKyIkJARpaWlu5WlpaYiNjfVY/tdff8XBgwfRvXt3V5nzf99whYaGYu/evahdu3a+6+zXrx9SUlLwf//3f0VrAiwRERERUTAJDw9HQkICkpOTXfGSTqcTycnJGDJkiMfy9evXx/bt293Knn32WZw9exZTpkzxGNqjs2TJEixfvtzvOaRXYmeeiIiIiALG6gmw3hoxYgT69euHFi1aoGXLlpg8eTIyMzNd6TZ9+/ZF1apVkZSUhIiICDRq1Mjt98uVKwcAHuWSuLi4Anl+ETvzRERERBQ4AYqm7NWrF06cOIHRo0cjNTUVzZo1w7Jly1yTYg8fPgybFM7gg1dffRUjR47EtGnTUKNGDcvqNVR+WY+EjIwMREdHoyN6INQQojysokmiEdNspHQZXZqNlDwh1aEpl5eVEkgsSLPR1a17f/m1Q1e3Fek5UiKLmfFvYhSKiTZL7dAl1FiRImNy2+naoaRNJLbP/21qar9YM4Sx6DJ5xTd0HxEmQzgMXZqHlLxiJrFHSAnRthmwJFVH2w5pfWbKTWxT8f2Z+TgXE1ZMlDukbSeU65aX1iftF10SjdAObWqNUIe8rPfvUaqjqKTZrHDOBfBXvyY9PT3gT7nPa0v9oeMRYo/wuz5H1kXseePpIvHedMqXL4/z588jNzcXpUqV8pgAe+rUKZ/q5Z15IiIiIgqYQA2zKWyTJ08ukHrZmSciIiIiKkA5OTlYvXo1nnvuOdSsWdPSugPxOBsiIiIiokuUha8iKiwsDF988UWB1M3OPBEREREFTgnozANAz549sXDhQsvr5TAbIiIiIqICVrduXTz//PP4/vvvkZCQgNKlS7v9/NFHH/WpXnbmixtN8ochpZWI5Zo4DzOpNVLdZhJnADm5RkdKHNCREgTEVAUTSRzaQpPpOTbNNpW2XZhwCod6Lq/ChWV1yTcAnGGaOjT1SssC+iQaJe1WaXtot79+UW1qCgBDs8ttufrjQJtWAsDQLG9Ix51QLKaQaGgTeKS0HuH40O0vbdIRAKe0b3WJRGHSOasv1u5bE/vqUrnn8rYcYR8K+9am2zHS+nL0ySTaunNy9ZWIx4embrPpMjpmrjVWXHfFdkifF5qyggzUE6/1muQ4oR1i4J8QfkO+MWBNkFhRDyP74IMPUK5cOaSkpCAlJcXtZ4ZhsDNPREREREEoQDnzhe3AgQMFUi/HzBMRERERFSKllPzNj0nszBMRERFRwOTlzFvxKuo+/PBDNG7cGJGRkYiMjESTJk3w0Ucf+VUnh9kQERERUeCUkGE2kyZNwnPPPYchQ4agbdu2AIB169bhoYcewsmTJ/HYY4/5VC8780WJdrKOfoKp9HhoQ5iPql9YP1XE0E1qNTPRFdBP2NRN7ATkiY860iQx3YQyQD8BTXpMeK5+EpvSTW4TJ0Vp2iFOStNvOyNUc1qGh3mW5VNuRHo+FluFCRO8hO3vDPPcXw67MEkyXJpUaWLinUA38VGapGrL1tcRku25X2xZ+mPGdjFH346LnseBka1fFjlCuXT8ahui2U5h+v2thONARXgeS84I4VgS5EZ4HgfS/pYm10rHmH5hYd/maibACusLyRKubZrjRpr4KE2ixYWLnmXScSCUK921Rrou6donXY+la7puorzuOgMU8DVds7yZc8IkcVKrBes0VYc0EZdKnDfeeANvv/02+vbt6yq74447cP3112Ps2LHszBMRERFRkCrid9WtcOzYMbRp08ajvE2bNjh27JjP9XLMPBEREREFTEkZM1+nTh18/vnnHuVz5sxB3bp1fa6Xd+aJiIiIiArYuHHj0KtXL6xZs8Y1Zv77779HcnKytpPvLXbmiYiIiChwSsgE2DvvvBM//vgjXnvtNSxcuBAA0KBBA2zcuBHNmzf3uV525omIiIgoYKwaIlPUh9kAQEJCAj7++GNL62RnvogznVqjW95Mwg2gT0SQEkiEx8hrUw6khAOpbl0SgZQKID02XZMqoqSEiWx9FIpueZUrpFdYwAj1TBuxadJpAMAoFamvRJNUYYQLp7uw/Z1hnuVOIc0mN8L7NBvNk9QvNUO4CNs0wR8hWfplpdsyuhQTKbXGlnFBX/W5TM+1ZZ7XLuq8qG+gmeNGexxE2PXLli6lLy9T2uv1qVDvp1BJqTUOu4njQLocOPU/0KXZhAoHjS4BCdCn3EjJSNClWAGAZt+q8/pjxqlLvkHBXT90xwwAGJq0IyM83OtlL9GUi8lUJtJ2xMPOxAeXlC5mMjlLy0RqjRUpOUS+YGeeiIiIiAKnmA+zsdlsMK7yx6VhGMgVIrKvhp15IiIiIqICsmDBAvFnGzZswOuvvw6n9KwJL7AzT0REREQBU9zHzPfo0cOjbO/evXjqqaewePFi3HvvvXj++ed9rp8580REREQUOMrCVxH3xx9/YNCgQWjcuDFyc3OxdetWzJo1C/Hx8T7Xyc48EREREVEBSk9Px5NPPok6depg586dSE5OxuLFi9GoUSO/6+YwG/KONHFDKtcl11iRLCClFghjzZRmMonK0ieNOC8IKSaFTJd04Tjn0C4bYtP/PW7YNUkVSp+EIqXLKM0+dGgSbgDAES4l4mjqFY4DQ9q38FzeJoSBSF+xGjmex4ftvD69CBlntcWOU6c9ypRDv1+soD8O9G/cEI7dEM15YQvVp4Q47UISii5USkim0qXWAIBDdziaPA506zSEzW/TpNZcqkNXKKXZCKlXmjQbhybp6NLCvo+B9YWUkqMrt0nvW9i3RojmuJEuHmaInyHC8roYJCs+WyiwivkE2JdffhkTJkxAbGwsPv30U+2wG3+wM09EREREAVPcx8w/9dRTiIyMRJ06dTBr1izMmjVLu9z8+fN9qp+deSIiIiKiAtK3b9+rRlP6g515IiIiIgqcYj7MZubMmQVaPzvzRERERBQwhlL5zJsyV09JxDQbIiIiIqIgxTvzRZ2UhqCb0Z9feVEgjRcz85e0U1hWShXJ0aTZZAspJkWZcBwoIcXEiNAk1+Tq6zCkwI0Qz/2l9EEoYrku3UQKwDAcUoqG98eHIRwftmzNI7IvXNQu68w4py0vyOQaf0lt070XW2SEdllbaX3akaGLJBI4pePAxLFkOIXjQLNvpTp0x+6lOjSFwnmBLP11QnvOFXJqjRWk66ARKnQLdOW6hBuzrPhcKEjiZ7CmPAiPgyKjmA+zKWjszBMRERFRwBT3NJuCxmE2RERERERBinfmiYiIiChwOMzGL+zMExEREVHAcJiNfzjMhoiIiIgoSPHOfAmgnEKKifgLmj9trUgWMFuHLplEqsMhpL3katJsinAqiVlOKZEiJ8ezLFd439I21W1/KXhCuC2gLZcOPDNBTEKbjVyhPEfz3i9maZd1ZulTboKR7r3YhPet3UYQtql4Lgs7UVdckMeSlHqlabd0XijNOQTI51ywka6DumsmABi6a6yZawegTxkqyM8WE3VLn5NUSDjMxi+8M09EREREFKR4Z56IiIiIAoZj5v0TVHfm16xZg+7du6NKlSowDAMLFy686u+sWrUKN9xwA+x2O+rUqYOZM2cWeDuJiIiIyEvKwlcJFFSd+czMTDRt2hRTp071avkDBw7gtttuQ6dOnbB161YMHz4cAwcOxPLlywu4pUREREREBS+ohtl07doVXbt29Xr5adOmoWbNmnj11VcBAA0aNMC6devw2muvoUuXLuZWbtguvSSF/BhnJU0w0nzHZFgwOcj0BCNd+6TNJ70Xp2aCljBJSZzMlaOfzFXsZWsm7wnbSDuxDYChKTaEObS6ZaVyaYKjdEdF2w5xfUIluZ6/oHTbqAQQ37dmGwH6bWpmf19aqZdlJus2fTzqjnVpQnxJPT6Ea6buGmtIk0Z1126JTZjFbGISs+lJtCbqkD5rxc/gwpZfvyTIlNQhMlYoPkeBxoYNG9C5c2e3si5dumDDhg0BahERERERuVHKulcJFFR35s1KTU1FTEyMW1lMTAwyMjJw4cIFREZGevxOVlYWsrL+im7LyMgo8HYSEREREfmiWN+Z90VSUhKio6Ndr7i4uEA3iYiIiKjYykuzseJVEhXrznxsbCzS0tLcytLS0hAVFaW9Kw8Ao0aNQnp6uut15MiRwmgqERERUcnENBu/FOthNomJiVi6dKlb2YoVK5CYmCj+jt1uh91uL+imERERERH5Lag68+fOncP+/ftd/z5w4AC2bt2KChUqoHr16hg1ahSOHj2KDz/8EADw0EMP4c0338TIkSNx3333YeXKlfj888+xZMkS0+s2bAYMQ37evHJqvuQo5IQbkZgW430yjGETvsQRklD0FUvPbxfaZyZ5QkqzkZYv5nSJFIaQzmFk6beRLdtz+9ty9MeBLUe/b5XmO08lpFdISTQ2TfNsDv2yUh26RKcSegNHJKVe6baptP11+woAbLma7e80eRxoDl9bjrCs5tgFhGNdOC9KahKWeM3UlUvLSp8X2hVa8LlgMuVMu3xRSaeRCKk1hpQGFGQMZz5pWCbrKYmCqjO/efNmdOrUyfXvESNGAAD69euHmTNn4tixYzh8+LDr5zVr1sSSJUvw2GOPYcqUKahWrRref/9987GURERERFQwrBoiU8T/JisoQdWZ79ixI1Q+sUO6p7t27NgRP/30UwG2ioiIiIgoMIKqM09ERERExYtVSTRMsyEiIiIioqDCO/NEREREFDhWPb2VT4ClfBk2cTb5pR97TqHWJtzkp7DTb6SDXjerX0gLQK6Q+KBCPMvySQPytm4lrE9MLSgqiUKFzJmd7VFm05QBgC1Ln+YRcjHMoyw0XH9MK+FQNzSJJeKywuEYkuX5A0OTjgIAhpCyojTHnhFWMi9/0vvWbSNAv02l7a/bV//7Dc36zCUS6eoOvaA/v0Mu6q8T2mNdOC9051CJIFwztddY4XosJ7+ZOOfENBtNO6TPJymhpqh0+PLpU3guKmxTE3UUZRxm45/icRQQEREREZVAJfPWFBEREREVDYym9As780REREQUMBxm4x8OsyEiIiIiClK8M09EREREgcM0G7+wM+8lw2bkM0Nfn1yjS7jJj5n0G3Fmu75ifbGQAKN7n2JGhZQIojuhpO0nphZo2q0ry6+8pNLsc5WlT+cwLlzUloeEe+5bFSLtQ/1xEJLjeUw7pToENk1yiq7sUjuE8lDNuRUZoV00pGxZbbnj7Fl93UWY9r0I71u7jQDtNpW2f0iW/jw0HN7vc5uQSGTT1B16Xp+mEpIpJNFojnXpvCipSVgiM9djQ0oXs+BzQVOucoRUNeEzTvvZZ3J/6z6DzSbYmfocF1JrTNVRhHGYjX84zIaIiIiIKEjxzjwRERERBQ7TbPzCzjwRERERBQyH2fiHw2yIiIiIiIIU78x7yzDyfWyybrKr+ckwRWPClW5ykDTFRkmTlHSTmqSJOiYeua1yNI9jhzyZl/6iLmZpy43zF/TlmuM9VHhsui07XFvutHteYpzCREtpcq2hOQ4MaQKsMJlOaSbzomwpfRWh+stiaJnSnvVm6bcpsv0/To2QEM/C8DD9sna7vhLNZFcVqd9X2m0EaLepLVuY6Cqcy0pThyFNdM0VjrEsz0mOtvPCpO5z+knd0Bzr0nlB7rTHrnA9FukmQlvwuQDhulTYnwumJ6Pm06fwum4TdRRpTiXvc7P1lEDszBMRERFR4HDMvF+KyZ90REREREQlD+/MExEREVHAGLBoAqz/VQQl3pknIiIiIgpSvDNPRERERIGjlPzUX7P1lEDszFtFM6PcfDqNJr1CoIQZ26Zm00uzvjXf16hc4XHZ0qO4raA7KaV0Aj56/aqcWULCR4a+2NClGmXr00NCzuvTVGx2z+QUKTVFhemPf6VLvxGOcyV81+iI9FynoUnaAQBERerLVbRnHSYeOW+WtgYprUc6D3XFUh0mvqe15QjnW5ZwXdIk1Bg5+nPZyNZfa4wszbEnJNGoi/pjXWV6ptmI5wW5011jhc8FUylnVjB7vplIPJE+U3VpdabTbMwoLqk1gkDmzE+dOhUTJ05EamoqmjZtijfeeAMtW7bULvvee+/hww8/xI4dOwAACQkJGD9+vLh8YSneRwcRERERkcacOXMwYsQIjBkzBlu2bEHTpk3RpUsXHD9+XLv8qlWr0Lt3b3z33XfYsGED4uLicOutt+Lo0aOF3HJ37MwTERERUeAoC18mTJo0CYMGDcKAAQPQsGFDTJs2DaVKlcL06dO1y3/yySd45JFH0KxZM9SvXx/vv/8+nE4nkpOTTb9lK7EzT0REREQBYyhl2QsAMjIy3F5Zmgf8ZWdnIyUlBZ07d3aV2Ww2dO7cGRs2bPCq3efPn0dOTg4qVKhgzYbwETvzRERERFRsxMXFITo62vVKSkryWObkyZNwOByIiYlxK4+JiUFqaqpX63nyySdRpUoVtz8IAoETYImIiIgocJz/e1lRD4AjR44gKirKVWy360Ma/PHSSy/hs88+w6pVqxAREWF5/WawM+8tm5H/THzd7PgCnH1ueB98I5MSYITAGH0VVkRJ6dthqm6m2fhMTPPQlBuhYdpFbRH6C6WhuYAawrKI1F8MVaRnIo4zUt8OZ4T+kuaI8DxhnHb9+ekI15c7Nat0huqvCU7p/DQTdqE5/G3CuWnL1Z8rthzPspBs/bliy9KXh1z0XKlNSJyxXdCsEIBxQZNEc0E47qSEGs3X5E5p2Vx9O8h3SpNuJV6jc4REIl3aiwWfk5akyJhshyWfwVYoyASdQnT5EBl/6wGAqKgot868TsWKFRESEoK0tDS38rS0NMTGxub7u6+88gpeeuklfPvtt2jSpIl/jbYAh9kQERERUYkSHh6OhIQEt8mreZNZExMTxd97+eWX8cILL2DZsmVo0aJFYTT1qnhnnoiIiIgCx4ckGrEeE0aMGIF+/fqhRYsWaNmyJSZPnozMzEwMGDAAANC3b19UrVrVNeZ+woQJGD16NGbPno0aNWq4xtaXKVMGZcqUseAN+IadeSIiIiIKnAA9AbZXr144ceIERo8ejdTUVDRr1gzLli1zTYo9fPgwbLa/BrG8/fbbyM7Oxl133eVWz5gxYzB27Fi/m+8rduaJiIiIqEQaMmQIhgwZov3ZqlWr3P598ODBgm+QD9iZJyIiIqKAMdSllxX1lETszHvLeZUjzZLZ9CbqMPNVksnEGV1CgS7J4H8Lm6q7SBPSDPxOYDCb1lOEt6mUEuI4J6SHnDvnUSQm4kTpxxsamkQCI1TY/qX0deeW8oyeyIrW15FTRn8e5pTyLHNE6puhS74BAKeJK65NEwiiS6cBgJAL+jaHndeUndMva0/Xl+vSb4wc/fXAOHtBW64yMjzKnBmexwZQQpJoNNcPMZGloK41VlxnTNahtIeNifg0qV7p2h2ij5wxlX5jZlkzn+GANcNKrEiUKwoCNMymuGCaDRERERFRkOKdeSIiIiIKGMN56WVFPSUR78wTEREREQUp3pknIiIiosDhmHm/sDNfkExOhjFs/n9Ropya75ikaqV5R7pJTUV4UqZZ0gRMI0x/OhihmnJpYpWmXEnbTpi4pLKzNWX6SYHBOFlQnER76rS2PFSzTY0yEdplncLE2NxSnuVZ5fTnZ1YFbTGyy3nuRxWlf2x9aKT+PYaGen8e5eZ6tjn7gnDsZuiP3fAznnU4Q4WJrjn6bRd2TjNZU5gAi8xMbbG0b4sL8ZoSLpWHexYKEy0NzeROMZBAKFe5nsepytEfu8F4TRE/n5T0Gay5fosTkIX9UlCf1+LCxbyTGqCHRhUXHGZDRERERBSkeGeeiIiIiALGUAqGBd8+WFFHMGJnnoiIiIgCh2Pm/cJhNkREREREQYp35omIiIgocBQAK3I2SuaNeXbmvaaucqQ5NV9yhJicBa+bNW9yxryhqUNMPhAfE+7/47WLMvER37qECQCGXVMepk+pQKgmeUVqiEN/PBnZnnWrCxf1VZwNwuQJk5znPBNSbBXKaZdVwiGdE+m5F7Kj9MtmVdQf/+GVLniUxZbL0C5budRZbXl0mGcdkvScSI+yY+fLapdNPaN/M1mhnnUYufrjP+yc/kiN0GxTKc1Gt69KAlukPl3JEMqhu9aEeH+tN3KFa3SOcD3I8kzIEtO0gjHNxizdZ5+UWiN8Xpj6bBZSa3R9ATHhRthfxSVpjmPm/ROUw2ymTp2KGjVqICIiAq1atcLGjRvFZWfOnAnDMNxeERHCBZaIiIiIKIgEXWd+zpw5GDFiBMaMGYMtW7agadOm6NKlC44fPy7+TlRUFI4dO+Z6HTp0qBBbTEREREQihb8mwfr1CvQbCYyg68xPmjQJgwYNwoABA9CwYUNMmzYNpUqVwvTp08XfMQwDsbGxrldMTEwhtpiIiIiIRJZ05C1KxAlCQdWZz87ORkpKCjp37uwqs9ls6Ny5MzZs2CD+3rlz5xAfH4+4uDj06NEDO3fuLIzmEhEREREVqKDqzJ88eRIOh8PjznpMTAxSU1O1v1OvXj1Mnz4dixYtwscffwyn04k2bdrg999/1y6flZWFjIwMtxcRERERFRCnha8SqNin2SQmJiIxMdH17zZt2qBBgwZ455138MILL3gsn5SUhHHjxnmUK4cDyrCJCTCGbsK72a97dLPjhRn2ZuqQZncrIU1FSbPmiwshNcIIFxJqIuyeZULyjS7NRkkpCVJqQajnaSntQ1tWlrbcma1JrwhSzgueCTA2Kc1D2NZOze7KLa2vwlZOv+3irznlUda0/B/aZetH6suvDdWn3OicyPVMrtlTqop22W0h+vJfs6/1KMs965lwA+i3EQD9NhW2v25fFTc2zblv6K4RAFCqlL7crkmsEtJRtOe+dPxL1zZNHUpKvilGpM8y3VVCTJkzkz4nkerQJc2Z7Ddo32MxSbgh7wXVnfmKFSsiJCQEaWlpbuVpaWmIjY31qo6wsDA0b94c+/fv1/581KhRSE9Pd72OHDnid7uJiIiISC8vmtKKV0kUVJ358PBwJCQkIDk52VXmdDqRnJzsdvc9Pw6HA9u3b0flypW1P7fb7YiKinJ7EREREVEB4QRYvwTdMJsRI0agX79+aNGiBVq2bInJkycjMzMTAwYMAAD07dsXVatWRVJSEgDg+eefR+vWrVGnTh2cOXMGEydOxKFDhzBw4MBAvg0iIiIiIr8FXWe+V69eOHHiBEaPHo3U1FQ0a9YMy5Ytc02KPXz4MGyXjU87ffo0Bg0ahNTUVJQvXx4JCQlYv349GjZsGKi3QERERER5rLqrzjvzwWPIkCEYMmSI9merVq1y+/drr72G1157rRBaRURERESmsTPvl6DszAeCciooQ8GwCbPElW5muy7iJh+62fE2IQlFSNVRZmax62bSAzA061RCeEIwMp1aoEmXUXb9qaM0y4ozUxzeJy0gR0rPEU7hYpRmo5Wba2pxp2YzOSP050rp0vqEoPgypz3KGpfST5BvZteXx4R4fyKlhf7pURZm6H//TI4+oSa1tOecn0whecUZamIKlcntX6zozjkp3UqTWgMASpdmE6K/1usu6YawrJiQpUs5k653xYjuswyA/nM1RPi8lhKCNJ/B4uevFeEyUt2a8mKfSEce2JknIiIiosBxQriT5UM9JRA780REREQUMFbFSjKakoiIiIiIggrvzBMRERFR4HACrF/YmfeWcgJwmpoIKk1SNTMvVqzDxPLKEA5uM4+jLgnMTIwVJkupME25tAttwn7RTGIzQvXrM6RJW8Wd9Dh76UKuOdS1c9YBhIXq6y4betGj7NrQDO2y0kTXSiFl9CvVOuf1+nRtA/TvRXrf4nhV3TaVtn8JoD3nhPNTez0QyqUJsLoxwOJQArOT+0sq3Wef8Hlo5jNYDKaAifNFmLyqhMAKqTzoOBUg9VXM1lMC8QwnIiIiIgpSvDNPRERERIHDYTZ+YWeeiIiIiALIos48SmZnnsNsiIiIiIiCFO/MExEREVHgcJiNX9iZt4ju8cmG8PhlJTxy29TDDqTHVOtmcgvLSo/zVtoZ+cVkxjzy2f5WVK7ZdEpMkhDaYSI9Rywv7nJztcU2h/4cMjSLG079Hs916PdXltPzcnnRGaZd9qJwLucofbu9rUNan65tgP69SO9bt40AYZsK279E0J1z0nkoXWM1yTXSdcIooEdaStfBYkVIl9FeY6XPVIlueSlJRbgeaPeB2G8omZ1U8g4780REREQUOE4FS8a7l9A/etiZJyIiIqLAUU7xWwnT9ZRAnABLRERERBSkeGeeiIiIiAKHE2D9ws48EREREQUOx8z7hZ15q2jGaSmHPgHGkJIPNDPblTD+y4CUnqCZYS8F0RhSyo0maUGoIihJf7kL+0u3X7RlAAxtmoowhs/M0D5hX5lOYCgmVE6OttyWpd+HIVmasgv6bZd53q4tP3q+nEfZ/ohY7bKlbZoVAkh3ntWW66Q6ynuuL0u/Pl3bAP17kd63bhsB+m0qbf8SQXfOSeenRHPuS6k12muKlEQjleuubSXgDqbus+zSD0zsLxPXWOnzWtwvmn0g9RtK6lhw8g4780REREQUOBxm4xd25omIiIgocBQs6sz7X0UwYpoNEREREVGQ4p15IiIiIgocDrPxCzvzRERERBQ4TifMpULkV0/Jw858ARLTbKTZ6rqUGylmySjAvz6NYj76Stj+KjdXW25oyo0c4dSxabadU0hDkK45uvY5SuYFSpSj31chF/Tl4Zme2y88XX+cZ57Sp9n8Yq/oZeOAY2WiteWVwjO8ruN4dpRH2W/n9G345aS+3KF5LxHp+vXpthEgbFNh+5dY0vkpfQbkaK4JwmVXl2Zj5AifIcI1THttkz6HihMrPsvMRB1Ky5pIUBPTbIjywc48EREREQUOh9n4hZ15IiIiIgocdub9UszHUxARERERFV+8M09EREREgeNUsCQk3swch2KEd+aJiIiIiIIU78wHgDhbXVNuGPokFPFvT5uQnKJdVvhbTlOHoUvaQXDOvHdKSShSQkdWtmeZsF8M3V2BUP22kxi6dggpFXIlmn2rik8ijpQ8ZMvM0pbbT0d6lEWU0R//zjD9/rqQW9aj7OdMffLN/jL6dJlS4ZpjSXA+O9yz7Jx+fTjluSwARJ7wfI8Rf+qrsJ/Wn8u6beo0ezwGIzNJKFISVpZw7ps4FY1czX7JFo4j3bUK0KYPSdfBYCR9Pomfh9Jnn4aSrpu6a72UlGayvCRSyilva5P1lETszBMRERFR4ChlzRAZToAlIiIiIqJgwjvzRERERBQ4yqIJsCX0zjw780REREQUOE4nYFgw3p1j5qmwSJNeDN2jnaWJlmLtJiZbOoWDXrPO4jQBVjrZVZZ+8qSOIW07zWQ1I0R6TruwF3WPhs/J8X5Z6PeXyi0+FzklTQA8m6kttp/wnCCqbKW0y4Zk6S+L4Rme+zEnLUK7bE6kvvx0mLZYy6bZ5ZEX9MuGndOX20973qWKPKmf+Gg/cV5fiWabitu/GBEnVZo5P6W6dctLdxR16xO2v7qov4Zpr23FqNMj7ivpGqu7fkvLSnSf1ybCLfJdnsgkduaJiIiIKHA4zMYv7MwTERERUcAopxPKgmE2JTWakmk2RERERERBinfmiYiIiChwOMzGL+zMExEREVHgOBVgsDPvK3bmixDd47WlcVDS4WroDmSzs/S1FetbUpxSbpxCQoQuZciQHt8eqkmNMPuocR3pyXhSMpKm7uJ0iRMfj56eoS23ac6LUpn65A/7iUhtuaO0ZxRNbqR+3zrD9ftWhXi/zw2HZ5tt2fq9GHpBvz1CMj1TU0LOCpE4QhKQyjjrWRaE57dZunMIgD7FJEtI9zGTcmPiHFfC9UdKGSpO+0v7mSN8PpkibSOhc6h0iTjCftF9thNZiZ15IiIiIgocpQBYkTNfnG5beY8TYImIiIiIghTvzBMRERFRwCingrJgzLzinfngMXXqVNSoUQMRERFo1aoVNm7cmO/yc+fORf369REREYHGjRtj6dKlhdRSIiIiIsqXclr3Mqk49CmDrjM/Z84cjBgxAmPGjMGWLVvQtGlTdOnSBcePH9cuv379evTu3Rv3338/fvrpJ/Ts2RM9e/bEjh07CrnlRERERFRUFJc+paGC7DuJVq1a4cYbb8Sbb74JAHA6nYiLi8PQoUPx1FNPeSzfq1cvZGZm4quvvnKVtW7dGs2aNcO0adOuur6MjAxER0ejI3og1PBMsyhwwix9W5gwQko701+fymDY9HVrZ+lLh4mQwKBLTxATFUroE9ukJKACS2sQtrOSUjQ0yxenVAyzzOwXMQnFT2b2FVBy95d0bun2l7ivCvKcM3N9LO5MJqVpy8V96P1nn/ZzD5A/+zT7S0ytKSKfcSuccwH81a9JT09HVFRUQNvk6mMZ/7Ckj5WrcrBKLfD6vRV2n7KgBNWd+ezsbKSkpKBz586uMpvNhs6dO2PDhg3a39mwYYPb8gDQpUsXcXkiIiIiKkQBGGZTnPqUQTUB9uTJk3A4HIiJiXErj4mJwZ49e7S/k5qaql0+NTVVu3xWVhaysv7Kn05PTwcA5CInQEHdwp156W6B0t3dEe5OKOHOvO5kENcn3JnX3dXVtg1F5q5FYTOE960vt+BOr7ivTNyZl/ZhCaDfL8JdRVVAd+ZN7KtLy5fM/SWdW7r9Je+rgjznNHfmS+i+ks8h6fqo2U4m96Hus0/7uXfpB0K55/JOVbTvzGdkZLj9f1EamGFVHysXl57tkPce89jtdtjtdreywuhTFpag6swXhqSkJIwbN86jfB0CNMFBOriFZ5RQEJE+u0vqZ3pRx/0SPLivgof0GSc9Z4nPX/JZdHS027///PNPj7LCFh4ejtjYWKxLta6PVaZMGcTFxbmVjRkzBmPHjrVsHUVNUHXmK1asiJCQEKSlpbmVp6WlITY2Vvs7sbGxppYfNWoURowY4fr3mTNnEB8fj8OHDwf8oKfgkZGRgbi4OBw5ciTgYxIpOPCYIbN4zJAv0tPTUb16dVSoUCHQTUFERAQOHDiAbOHpxb5QSsG4Yr7ElXflgcLpUxaWoOrMh4eHIyEhAcnJyejZsyeAS5MVkpOTMWTIEO3vJCYmIjk5GcOHD3eVrVixAomJidrldV/FAJf+ouXFksyKioricUOm8Jghs3jMkC9sQghGYYuIiEBEREShr7cw+pSFJag68wAwYsQI9OvXDy1atEDLli0xefJkZGZmYsCAAQCAvn37omrVqkhKSgIADBs2DB06dMCrr76K2267DZ999hk2b96Md999N5Bvg4iIiIgCqLj0KYOuM9+rVy+cOHECo0ePRmpqKpo1a4Zly5a5JiQcPnzY7a/NNm3aYPbs2Xj22Wfx9NNPo27duli4cCEaNWoUqLdARERERAFWXPqUQZczX9iysrKQlJSEUaNGaYffEOnwuCGzeMyQWTxmyBc8boofduaJiIiIiIJU0Zj9QEREREREprEzT0REREQUpNiZJyIiIiIKUuzMX8XUqVNRo0YNREREoFWrVti4cWOgm0REREQkSkpKwo033oiyZcuiUqVK6NmzJ/bu3RvoZlEBYWc+H3PmzMGIESMwZswYbNmyBU2bNkWXLl1w/PjxQDeNgsSAAQPw7LPP8sJKRFf19ttvo0mTJq6HQCUmJuLrr7/2qS5ee0q21atXY/Dgwfjhhx+wYsUK5OTk4NZbb0VmZmagm0YFgJ35fEyaNAmDBg3CgAED0LBhQ0ybNg2lSpXC9OnTA900CgIOhwNfffUV7rjjDl5YSdSgQQMYhqF9vfnmm4FuHhWiatWq4aWXXkJKSgo2b96Mv/3tb+jRowd27txpqh5ee2jZsmXo378/rr/+ejRt2hQzZ87E4cOHkZKSAoDXnWJHkVZWVpYKCQlRCxYscCvv27evuuOOOwLTKCoy6tevrwBoX2+88YZSSqk1a9aoypUrK6fT6fH7x48fVwDU6tWrC7vpVMTs3LlTAVDJycnq2LFj6uDBg8pms6m5c+eqixcvBrp5FGDly5dX77//vlLKu+uOUrz2kKdffvlFAVDbt29XSvG6U9zwzrzg5MmTcDgcrqeA5YmJiUFqamqAWkVFxRdffAEASE5OxrFjx3Dw4EHYbDbMnTsXgwYNAgB8+eWX6N69OwzD8Pj99PR0AECFChUKr9FUJKWlpSE0NBRt27ZFbGwsTp48CafTiZtuuokPdCnBHA4HPvvsM2RmZiIxMRGAd9cdgNcecud0OjF8+HC0bdvW9aRSXneKF3bmiXzgzYVw0aJFuOOOOzx+V3dhpZJr+/btuO6661zHzbZt21CpUiWPGwlUMmzfvh1lypSB3W7HQw89hAULFqBhw4YAvO+A8dpDlxs8eDB27NiBzz77zFXG607xEhroBhRVFStWREhICNLS0tzK09LSEBsbG6BWUVFxtQvh7t278ccff+Dmm2/2+N28C+u6desKtc1UNP38889o3Lix69/btm1z+zeVLPXq1cPWrVuRnp6OefPmoV+/fli9ejUaNmzoVQeM1x663JAhQ/DVV19hzZo1qFatmquc153ihXfmBeHh4UhISEBycrKrzOl0Ijk52fWVJ5VcV7sQfvnll7jlllsQERHh9nt5F9bvvvvO7cJKJdfPP/+MJk2auP69bds2t39TyRIeHo46deogISEBSUlJaNq0KaZMmQLAuw4Yrz0EAEopDBkyBAsWLMDKlStRs2ZNt5/zulO8sDOfjxEjRuC9997DrFmzsHv3bjz88MPIzMzEgAEDAt00CrCrXQgXLVqEHj16uP59tQsrlUxOpxM7d+50O3Z+/fVX1KhRI3CNoiLF6XQiKysLgHcdMF57CLj0LczHH3+M2bNno2zZskhNTUVqaiouXLjA605xFOAJuEXeG2+8oapXr67Cw8NVy5Yt1Q8//BDoJlGAORwOVapUKbV48WJXWbVq1dSUKVOUUkqlpaWpsLAwdeLECdfPH374YRUdHa1WrVqljh075nqdP3++0NtPRce+ffsUAHXo0CFXWdeuXVW5cuXUunXrAtgyCoSnnnpKrV69Wh04cED9/PPP6qmnnlKGYahvvvnmqtcdpXjtob9ASD2aMWMGrzvFkKGUUoH7U4Io+Pzyyy+47rrrcOjQIVSvXh0A0K1bN2zYsAFfffUV9uzZgxkzZriNS9WlSgDAjBkz0L9//8JoNhEVcffff78rqSY6OhpNmjTBk08+iVtuueWq1522bdvigw8+4LWHqARiZ57IYnfccQfatWuHkSNHBropRFSC8NpDVDJxzDyRxdq1a4fevXsHuhlEVMLw2kNUMvHOPBERERFRkOKdeSIiIiKiIMXOPBERERFRkGJnnoiIiIgoSLEzT0REREQUpNiZJyIiIiIKUuzMExEREREFKXbmiYiIiIiCFDvzRERERERBip15IqIA+vXXXzFw4EBUq1YNdrsdNWvWxNNPP43s7GwkJCTAMAz8/PPPgW4mEREVUXwCLBFRgCxcuBD//ve/ceHCBTRt2hT16tXDb7/9hs2bN2PAgAH47LPPAABnz55FSEhIgFtLRERFUWigG0BEVBJt2rQJvXv3Rnh4OObPn4+///3vrp+98cYbePTRRwEAiYmJ7MgTEZGIw2yIiAqZw+FA//79cfHiRcyePdutIw8AQ4YMQbVq1QAALVq0CEQTiYgoSLAzT0RUyD7//HPs2rULN998M2677TaPnxuGgdq1awMAEhISCrt5REQURNiZJyIqZF988QUAoE+fPuIyFy5cAMA780RElD9OgCUiKmQ1atTAoUOHsGPHDlx//fUeP8/JyUH58uUBABkZGbDZeN+FiIj0+AlBRFTIjh8/DgAoXbq09ufz589HZmYmmjdvzo48ERHli58SRESFrEyZMgCA/fv3e/zszJkzePLJJwFwvDwREV0dO/NERIWsXbt2AICkpCTX2HgAOHz4MLp06YJDhw4B4Hh5IiK6Oo6ZJyIqZCkpKWjTpg2ys7MRFxeHli1bIiMjA6tXr0aXLl2wa9cu/Prrr9i9ezfq168f6OYSEVERxs48EVEAfP/993jmmWewceNGhISEoHHjxhg4cCDuuusulC9fHqVLl0Z6ejoMwwh0U4mIqAjjE2CJiAKgbdu2WLVqlUf56tWr4XQ60bx5c3bkiYjoqjhmnoioCNm0aRMAjpcnIiLvsDNPRFSEsDNPRERmsDNPRFSEsDNPRERmcAIsEREREVGQ4p15IiIiIqIgxc48EREREVGQYmeeiIiIiChIsTNPRERERBSk2JknIiIiIgpS7MwTEREREQUpduaJiIiIiIIUO/NEREREREGKnXkiIiIioiDFzjwRERERUZBiZ56IiIiIKEj9P0w6ntAoiJ32AAAAAElFTkSuQmCC", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -713,7 +723,9 @@ "source": [ "# -- Compute DSF --\n", "q_res, w_res = 100, 100\n", - "spectrum_small = get_dsf(n_small, Gjjc_small, dt, time_steps_small, q_res, w_res)\n", + "spectrum_small = get_dsf(\n", + " n_small, Gjjc_small, dt, time_steps_small, q_res, w_res\n", + ")\n", "spectrum_small = -(spectrum_small + spectrum_small[:, ::-1]) / 2\n", "spectrum_small = np.clip(spectrum_small, a_min=0, a_max=None)\n", "\n", @@ -787,9 +799,8 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwkAAAJOCAYAAAD8sUvsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAalFJREFUeJzt3Xd8FNX+//H3bDoloRNCCyAIUhUEEaRGikqxgiKCBe8PwYYFK+D1ehH18rVxQb0CNgTvVQFR8QKCgFSBIAJioymGKgkkkrJ7fn/wzX4ZUkiy2dlN9vV8PObxYGdnzufMMLvZM58551jGGCMAAAAA+F+uQFcAAAAAQHChkQAAAADAhkYCAAAAABsaCQAAAABsaCQAAAAAsKGRAAAAAMCGRgIAAAAAGxoJAAAAAGxoJAAAAACwoZGAkLNixQpZlqVJkyb5LUZiYqISExP9Vj7ySklJ0YgRI1S/fn2FhYXJsiwdP3480NUqlkmTJsmyLK1YsSLQVUEpKcn3TY8ePWRZlv8qVYiMjAzVrVtXd955Z0Di++Jf//qXwsLCtG3btkBXBSgXaCRAkrRnzx5ZlmVbIiIiVLduXd1www365ptvfI4xcuRIWZalPXv2+F7hcuqrr77SLbfcovPOO0+VKlVSVFSU6tWrp6uuukozZszQiRMnAl1Fn+ReZ/5ooI0cOVLvvPOOunXrpieeeEITJ05UdHR0qcfxhRMN1LLGGKPPP/9co0ePVps2bRQXF6cKFSqobdu2+vvf/65Tp04VuO8XX3yh7t27q3LlyoqNjVXPnj21bNkyB2vvnNmzZ8uyLM2ePduvcZ5//nkdOXJETzzxRL7vp6SkaPz48WrTpo0qV66sChUq6Pzzz9fdd9+t3bt357tPbt3PXGJiYtS8eXONGzdOR44csW2fmJh4zkZSftuMGDFCDRs21EMPPVSMIwZQkPBAVwDBpUmTJrr55pslSenp6dq0aZP+/e9/a/78+Vq6dKm6desW4BqWT3/++adGjRql9957T9HR0erZs6cGDhyoqKgo/f7771q9erU+/fRTPfHEEzp06JBcLtr3Z8rKytKSJUuUlJSk9957L9DVKbGxY8dq6NChatCgQaCr4pjMzExdccUVioqKUo8ePdS3b1+dOnVKX3zxhR5//HHNnz9fK1asUIUKFWz7vfvuuxo+fLhq1qypkSNHSpLmzZunyy+/XB988IGuu+66ABxN6Xj77beVkZHheNy0tDS98MILGjJkSL7X4GeffaahQ4fqxIkTuuSSSzRq1CiFh4crOTlZ//znP/XGG29o5syZuummm/Itv3fv3uratask6fDhw/riiy/0P//zP/roo4+0adMmVa9e3af6R0RE6P7779c999yjr7/+Wl26dPGpPCDU0UiAzXnnnZfnLuezzz6rRx99VE8++aS++uqrwFSsnLvttts0d+5c9enTR2+99Zbi4+PzbLNixQo98MAD8ng8NBLOkpKSIo/Ho4SEhEBXxSc1atRQjRo1Al0NR4WFhelvf/ub7rrrLlWtWtW7Pjs7W9dee60++eQTTZs2zXZ3+I8//tDdd9+tGjVqaPPmzapXr54kafz48brwwgs1evRo9e3bV5UrV3b8eEpDoBqJ77zzjk6ePKlbbrklz3ubNm3SNddcI5fLpfnz52vQoEG299euXauBAwdq+PDhqlOnjnr27JmnjKSkJD3yyCPe19nZ2erbt6+WL1+uV155pVQybEOHDtW4ceM0Y8YMGgmArwxgjNm9e7eRZPr27ZvnvUOHDhlJpmLFinney8zMNP/4xz/MhRdeaCpUqGAqVapkunbtahYsWGDbrmHDhkZSnqV79+7ebT766CMzdOhQ06RJExMTE2NiY2NN165dzX/+858C6ztixAizY8cOM3jwYFOtWjUjyezevdsYY0xGRoYZP368qVevnomKijItW7Y0r7/+ulm+fLmRZCZOnJin3F9++cXcfvvtpn79+iYyMtLEx8ebESNGmD179uR73ubPn286dOhgoqOjTa1atcwdd9xhjh07Zho2bGgaNmxY8Ak/w9KlS40k07x5c5ORkVHottnZ2bbXZx7L119/bS6//HITFxdnzvxoezwe8+abb5pLL73UVK5c2cTExJj27dubN998M98Yxdl+4sSJRpJZvny5ee+990zbtm1NdHS0iY+PN/fcc0+e48n9fzv73P/www9m5MiRJjEx0URGRpqqVauaNm3amHvvvdd4PJ5Cz0n37t3zvbZGjBhhjDFmxIgRtuuioPrnd043btxokpKSTKVKlUxsbKwZPHhwvuUYY8zPP/9sRo0a5T2GmjVrmu7du5tZs2bZYuW35JaZX31yLVy40PTo0cPExsaa6Oho06ZNG/OPf/wjzzVx5mfjxx9/NIMHDzZVqlQxFSpUML179zbJycmFns9gsmbNGiPJXHnllbb1r732mpFknnrqqTz7TJo0yUgyb731VpHjrFq1ynTr1s1UqFDBVKtWzdxwww1m37593mvrTL5cT6tWrTLdu3c3lSpVMnFxceaaa64xP/74Y55yzo6bGzO/JdeBAwfMPffcY8477zwTHR1t4uLiTPPmzc1f/vIXc/z48SKdh/bt25tq1aoZt9ud570uXboYSeaNN94ocP///ve/RpJp0aKF7XM7a9YsI8lMnjw5zz5z5841kswVV1zhXZf796IwhW2TlJRkoqOjzYkTJwotA0DhyCSgyMLD7ZdLZmam+vXrpxUrVqhdu3a6/fbblZ2drU8//VSDBg3SK6+8orFjx0qS7rvvPs2ePVtbt27VvffeqypVqkiSrXPvo48+qsjISHXt2lV16tTR4cOHtXDhQl133XV6+eWXdffdd+ep008//aRLLrlErVu31siRI3X06FFFRkbK4/Fo4MCBWrp0qVq3bq2bbrpJR48e1f3335/vHS5JWr9+vfr27av09HRdddVVatq0qfbs2aP33ntPn3/+udauXavGjRt7t3/77bc1YsQIxcbGavjw4apSpYoWLVqkpKQkZWVlKTIyskjndebMmZKkBx98UDExMYVue/b/Qa41a9bo73//u3r27Kk777xT+/btk3T6ee9hw4bp/fffV9OmTXXTTTcpMjJSS5Ys0e23364dO3bohRde8JZT3O1zvfrqq1q8eLEGDRqkXr16afHixXr55Zd15MiRcz7+c+DAAXXs2FHp6em68sorNWTIEKWnp+vHH3/UP//5T73wwgsFHrd0ui9Cu3bt9NJLL6lt27YaPHiwJKldu3aFxj2XjRs36rnnnlPPnj31l7/8RVu2bNH8+fO1bds2fffdd7b+DqtXr9aVV16pEydOqG/fvho6dKj++OMPbdmyRS+99JJGjhypHj16aM+ePXrrrbfUvXt39ejRw7t/7uehIFOnTtUDDzygatWq6aabblLFihW1cOFCPfDAA1q1apU++uijPM9n79mzR5dccolatmyp2267TT///LMWLFignj17aufOnapdu7ZP58cJERERkvJe97kdu/v06ZNnn759+2rSpEne/j3nsmzZMvXv318ul0tDhgxRQkKCli1bpi5dutgyG75at26dJk+erH79+unuu+/W9u3b9fHHH2vVqlVat26d7bvlbIMHD9bx48e1YMECDRo0KM+1nZGRoS5dumjPnj3q06ePrr76amVlZWn37t1655139OCDDyouLq7Q+uVer3369MmTqfzxxx/19ddfq27durr11lsLLOPyyy9Xp06dtH79eq1evVqXXXbZuU/M/yrNjtqdO3fW0qVLtWbNmnyvEQBFFOhWCoJDYZmEv//97/nezXvssceMJPPkk0/a7hqlpaWZDh06mMjISPPbb7951xd2B86Y03diz3bixAnTunVrExcXZ9LT0/PUV5KZMGFCnv1y71z169fP5OTkeNd/++23JjIyMs/d7KysLJOYmGgqV65sNm/ebCtr1apVJiwszFx11VXedampqSY2NtZUrFjR7Nq1y1ZOt27djKQiZxIaNWpkJOV7/OeSe5dSkpk5c2ae919//XUjydx6660mKyvLuz4zM9MMGDDASDLffPNNibfPvXMaFxdnvv/+e+/6jIwM06xZM+NyuWzXQH5efvllI8m8+OKLed47evRokc7DmXfPz1bSO7+SzNy5c23bDx8+3Egy77//vnfdqVOnTN26dY3L5TKff/55nhj79+/PU3Z+WayC6vPTTz+Z8PBwU6tWLbNv3z5b3K5duxpJ5u23385zLiSZZ5991lb+E088UeAd3WA0evRoI8lMmzbNtr5Dhw5Gkjly5EiefY4cOWIkmcsuu+yc5bvdbtO4cWNjWZZZtWqVd73H4zE33XRTnrv1xvh2Pc2YMcO2/YwZM4wk23eLMXkzCcb833dabmbqTAsXLjSSzH333ZfnvRMnTphTp04VdAq8Pv30UyPJPP7443nemz17tpFkhg0bds5ycv8unHmNFZRJyM7ONr169cqTFfI1k7BgwYIC/zYAKDoebIbNTz/9pEmTJmnSpEl66KGH1KtXLz322GOqXbu2nn/+ee92Ho9H06dPV5MmTfTUU0/Z7gJVrlxZEyZMUFZWlj766KMix87vTlqlSpU0cuRIpaamauPGjXnej4+P1+OPP55n/dtvvy1JeuaZZxQWFuZd37p1aw0fPjzP9osWLdKePXv00EMP6cILL7S917VrVw0aNEifffaZ0tLSJEnz589XWlqabrvtNjVr1sy7bUREhJ555pkiHvFpKSkpkpTv8/Tz58/3/n/kLsnJyXm2u+iii/K9w/fqq6+qYsWKmjZtmveurCRFRkZ66/n++++XePtc9957r84//3zv65iYGN14443yeDzatGnTuU6Bd5+zVatWrUj7+kO3bt00ZMgQ27rbbrtNkmzX4oIFC/Tbb7/p5ptvVr9+/fKUk/u8fEnNmTNHOTk5euCBB1S/fn3v+qioKE2ZMkWS8h3xplGjRnlGebn99tvz1D9Yff7553rttdfUokULb71zpaamSlK+d8djY2Nt2xRm9erV+uWXX3TVVVd5O9RKp+9q//3vf7d9d/iqWbNmGjVqlG3dqFGj1LRpU3366ac6fPiwzzHy+wzljpJ2Lr/++qsk5Zthyv2OOvP6K0juNr/99lue95YuXer9Hrv77rt1wQUX6Msvv1SjRo28WefSkHsMuccEoGR43Ag2P//8s5566inbuvj4eK1atUrnnXeed92uXbv0xx9/KCEhIc/2krx/8L7//vsixz506JCeffZZff7559q7d6/+/PNP2/sHDhzIs0/btm3zfaxn69atqlixoi666KI871122WV68803bevWrVvnPa78Os/ldoz94Ycf1KFDB23dutVb1tk6d+5c6OMxxTF//ny99dZbtnWJiYl5Hje4+OKL8+ybkZGhbdu2KSEhwftj8kzZ2dmS/u//qLjbn6l9+/Z51uX+OD7XXAUDBgzQo48+qjFjxmjZsmXq16+funfvXujjF04o6jFt2LBBUv6PvpSGLVu2SJLt8aRcnTt3VnR0dL4Nx3bt2uV5bKSo/yeSlJycrPnz5xe3unmMHDmy2HOGbNy4UUOGDFFcXJz+/e9/F+lHbkkU9jlu2LCh6tevX2pDNnfp0iXP/4fL5VKXLl30448/auvWrUpKSipR2d26dVOdOnX07LPPauvWrbrqqqvUvXt3tWjRosiP8Rw9elTSuR99KyqPx5Nn3bJly7xD1EZFRSkxMVHjxo3To48+Wqo3BHLLOntoVQDFQyMBNn379tXixYslnf6h/9Zbb2n8+PEaOHCgNmzYoEqVKkmSjh07Jknavn27tm/fXmB56enpRYp77NgxXXzxxdq3b5+6dOmipKQkValSRWFhYUpOTtaCBQuUmZmZZ7+CnqtOTU0t8K5XfvvkHs+5np/PPZ7cu5S1atXKs01YWFixhvKrXbu29uzZowMHDuT5YTx79mzvXeLcUaYKKuNsf/zxh4wx+u233/JtyOXKPabibn+m3Lu3Z8ptKLnd7gLLkk43etatW6dJkybps88+0wcffCBJat68uf7617/q+uuvL3R/fynqMeVeC3Xr1vVLPXKzV/n9H1uWpdq1a+d719aX/xPpdCOhsOugqHr06FGsRsI333zjfS7+iy++UMuWLfNsk5tBSE1NzfNZyz1f53oGP3d/Kf/PsfR/n83SUNB3Ve76omQ+ChIXF6d169ZpwoQJ+uSTT/TZZ59JOn1X/5FHHtFdd911zjJysxD5zUuRO9ra/v37z1lO7jb5fR4mT55sG92oILmNqcJGcvN4PAU2gHJvMJ09bC6A4uFxIxSoZs2aevDBB/XYY49p586dtsl1cn+AXHvttTLGFLjMmjWrSLHefPNN7du3T08//bRWr16tV155RU8//bQmTZqkSy65pMD9CvojERcXV2D6/uDBg3nW5R7PJ598UujxdO/e3Vu+dDr7cTa32+29K1cUl156qSRp+fLlRd7nbPmdh9xjat++faHHlBu3uNuXplatWuk///mPjh07prVr12rChAlKSUnRkCFD9PXXX/tUdu6PjJycnDzv+fLDLFfundf8fqiXhtz/l/yuW2OMDh48mG+DwFcjR44s9Doo6pJfBqQg33zzjS6//HJ5PB598cUX+WbIJKlp06aSTneoPVvuutxtClPY51jK/5yX9HrKr6wz1xelUVOYBg0aaPbs2Tp8+LC2bNmiKVOmyOPxaMyYMfk+Ini2mjVrSvq/GyZnyv2OWrFixTkbmLmZggsuuKC4h+CVey4K+h41xujYsWMFnrPcY8g9JgAlQyMB5/TYY48pISFB//znP7131Vq0aKHY2Fh988033sdQziX3+d78/sj8/PPPkpRn7G1JWrVqVbHr3LZtW6Wnp2vz5s1FKq9Tp06STo/1XdTyCypr7dq1+f6AKEjuc+7/+Mc/Cp1dtrgqV66sFi1aaOfOnUV6vKS42/tDRESELrnkEj311FN6+eWXZYzRokWLfCozd4Sa/H7E5z7K44uOHTtKkv773/+ec9vCPgMFye0jkzuiz5nWr1+vU6dO+TySUzDIbSC43W4tXrzY+5nMT25jPb9z/sUXX9i2KUxhn+O9e/fme+e8pNfT119/necRHI/HozVr1siyLG9dClLUa8flcqldu3Z6+OGHvY2DhQsXFrqPdLq/lnT6kcuzNW3aVF27dtVvv/2W5/HHMy1btkzr169XjRo1dMUVV5wz5rnqUtD38bfffqv09HS1adMm3/dzjyG3HAAlQyMB5xQTE6Px48crOztbTz/9tKTTjy2MHj1ae/fu1YMPPphvQ+G7776z3aHLfU40vz+8DRs2lHS6I+GZ5syZ402dF0du5+THH3/c9kd127Zteuedd/JsP2jQIDVo0EBTp07VypUr87yfnZ1tq9ugQYMUGxurmTNn6ocffrBtd2bGpSh69+6toUOHaufOnbr66qu9nQTPVpK73vfcc48yMjI0atSofB8T2r17t+1xiuJuXxo2bdrkfUTkTLl3WM8carQkcu9Gn9259z//+U+pTA44cOBA1atXT++++673B+qZzvwxWdhnoCA33XSTwsPDNXXqVFu/nKysLI0fP16SvDMOl1WbNm3S5ZdfrpycHH3++efq3LlzodvfcMMNiouL0yuvvGLrnPrrr7/q1VdfVY0aNXT11VefM27Xrl3VqFEjLVq0yPb5Nsbosccey/cHeUmvpx9++EFvvPGGbd0bb7yhH374QVdeeeU573oXdu1s374930xFcT5DrVu3VrVq1bR+/fp833/ppZcUFRWlu+++O9+G+4YNG7wzLT/22GNFHgI6PyNGjJAkTZgwIc8Ni8zMTD388MOSVOAQt7nHUJSGIoCC0ScBRXLnnXdqypQpevvtt/XYY495RzXavHmzXn75ZX366afq1q2batWqpd9++03btm3T1q1btXbtWu/zvr169dILL7ygO++8U9dee60qVqyohg0bavjw4Ro+fLimTJmiu+++W8uXL1fDhg21detWLVu2TNdcc02xRkmSTv+RmTNnjhYvXqwLL7xQ/fv317Fjx/T++++rT58+ef7IRUVF6T//+Y/69++v7t27q1evXmrdurUsy9LevXu1atUqVa9e3dtpNy4uTi+//LJGjhypiy++WEOHDlVcXJwWLVqkmJgY1alTp1j1nTlzplwul+bMmaNGjRqpZ8+eatGihSIjI3Xw4EFt2LBB27dvV40aNdS8efMil/uXv/xF69at01tvvaWvv/5aSUlJSkhI0MGDB/X9999r/fr1mjNnjveZ8eJuXxreeecdvfbaa+rWrZuaNGmi2NhY7dixQ5999pmqVatW6LjsRTFo0CA1adJEs2fP1v79+3XhhRdq586d+vLLL3XFFVeUqBF6pqioKH3wwQfq16+f+vfvr379+qlt27ZKS0tTcnKyMjIyvHeYmzdvroSEBM2dO1dRUVGqV6+eLMvS3XffXeCjE02aNNGUKVP0wAMPqE2bNrrhhhtUsWJFffLJJ9q1a5cGDRqkm2++2adjCKRjx47p8ssv1/Hjx9WvXz8tWbJES5YssW1TpUoV3Xfffd7XVatW1auvvqrhw4froosu8o5CNW/ePB09elTz5s0r0mzLLpdLr7/+uq644golJSV550n48ssv9fvvv6tNmzb69ttvbfuU9Hrq27ev7rnnHn322Wdq2bKltm/frk8++UQ1atTQSy+9dM66du7cWTExMXrxxRf1xx9/eBsVTzzxhJYsWaKHHnpIXbp0UbNmzVS9enX98ssvWrhwoaKjozVmzJhzlm9ZlgYNGqTZs2fr119/zTMq10UXXaQPP/xQQ4cO1YABA9S5c2fvIA3JyclaunSpPB6Pbr31Vt1///3njFeY3r17695779VLL72kZs2aaeDAgYqPj9fRo0f12Wefad++fbr66qvz/W4wxmjZsmVq0aKFbeQ5ACVQuiOqoqwqbJ6EXK+88oqRZIYPH+5dl5OTY1577TXTpUsXExsba6KiokyDBg1Mv379zPTp083JkydtZTz33HOmadOmJiIiIs+My8nJyaZPnz6matWqpnLlyqZ79+5m6dKl+Y4PXti4+LnS09PNww8/bOrWrWuioqLMBRdccM4Zl3/99Vdz7733mqZNm5qoqCgTGxtrWrRoYe644w6zbNmyPNt//PHHpn379iYqKqrEMy6fafny5Wb48OGmcePGJiYmxkRGRpqEhATTv39/889//tOkpqbm2b6gYznTvHnzTFJSkqlataqJiIgwdevWNT169DD/+Mc/zOHDh0u8fWEzBBc2rvuZ1q1bZ/7yl7+YVq1amSpVqpiYmBjTtGlTM3bsWLN3795C9811ruth9+7dZvDgwaZy5cqmYsWKpnfv3mbjxo3nnCG3OHF++uknc/vtt5t69eqZiIgIU6tWLdOjRw/bHAa5x9u9e3dTuXLlYs24vGDBAu9+UVFRpnXr1ueccTk/Z3/uAu3MeR0KWgr6LH3++efmsssuMxUrVjSVKlUy3bt3N0uWLCl2HVauXGm6detmYmJiTLVq1cz1119v9u7dm+98Bbl1Lsn1lDvjcsWKFU1sbKy5+uqrizTjcq5PP/3UXHzxxSYmJsY2h8OOHTvMvffeay688EJTvXp1ExUVZRo3bmxGjBhhtm/fXuTzsH79eiPJTJkypcBtDhw4YB566CHTsmVLU7FiRW89KlasmGdekVyFzbhcmA8//ND07dvX1KhRw4SHh5sqVaqYbt26mX/961/5zgptjDErVqwocN4VAMVjGWOMX1shAACUQT169NBXX32lUPozedlll+nw4cPasWNHgSMLncnj8ejqq6/WwoUL9corr5TqfAclcfPNN+vzzz/Xzz//XGrDuQKhij4JAABAkvT8889r165dmjt3bpG2d7lceu+999S2bVvdc889+fb5csoPP/yguXPn6oknnqCBAJQC+iQAAABJ0iWXXKLXXnutWCNwVapUSZ988ol3KOuTJ09659Rx0q+//qqJEycWqQ8GgHPjcSMAAPIRio8bAUAuGgkAAAAAbOiTAAAAAMCGRgIAAAAAm5DtuOzxeHTgwAFVrlxZlmUFujoAAAB+YYzRiRMnlJCQUKShbZ1w6tQpZWVl+TVGZGRkkWYcR/5CtpFw4MAB1a9fP9DVAAAAcMT+/fvzzKYdCKdOnVJM5WpSzp9+jRMfH6/du3fTUCihkG0kVK5cWZK0O3mdKld2bqg2YznbgjfRsY7GOx3U43xMh89rtuX8RyfC5Dge07icPU6PQiOr5zJFH16yrPJYYc7HdHgcjjCX89drIIYaOZXj7Hd6AE5rQP4vnYx44sQJNW/W1PvbJ9CysrKknD8VfsENUliEf4K4s5Wy4wNlZWXRSCihkG0k5D5iVLlyJcU6+KFxvJEQQyPBH2gk+AeNhPKDRoJ/BKKREEkjwS8C8W0XbI9XWxHRssIi/VK2cTn/HVTeBMeDaQAAAACCRshmEgAAABA4litMlr/u+BsyCb4ikwAAAADAhkwCAAAAHEcmIbiRSQAAAABgE5SNhJUrV2rAgAFKSEiQZVmaP3++973s7GyNHz9erVu3VsWKFZWQkKBbbrlFBw4cCFyFAQAAUCyWFebNJpT6EoAR1sqboGwkpKenq23btpo2bVqe9zIyMrR582Y9+eST2rx5sz766CPt2rVLAwcODEBNAQAAgPInKPsk9O/fX/3798/3vbi4OC1ZssS27tVXX1XHjh21b98+NWjQwIkqAgAAwAdWmEtWmL/6JATlffAypVycwdTUVFmWpSpVqgS6KgAAAECZF5SZhOI4deqUxo8frxtvvFGxsQXPLpyZmanMzEzv67S0NCeqBwAAgHy4/Di6ETMu+65MZxKys7N1ww03yBij6dOnF7rt5MmTFRcX513q16/vUC0BAACAsqXMNhJyGwh79+7VkiVLCs0iSNKjjz6q1NRU77J//36HagoAAICz+W1kI3/OvxBCyuTjRrkNhB9//FHLly9X9erVz7lPVFSUoqKiHKgdAAAAULYFZSPh5MmT+umnn7yvd+/ereTkZFWrVk116tTRddddp82bN2vRokVyu91KSUmRJFWrVk2RkZGBqjYAAACKyK93/Mkk+CwoGwnffPONevbs6X09btw4SdKIESM0adIkLVy4UJLUrl07237Lly9Xjx49nKomAAAAUC4FZSOhR48eMsYU+H5h7wEAACD4WS6XLJefusf6q9wQwhkEAAAAYBOUmQQAAACUb/RJCG5kEgAAAADYkEkAAACA4073SfBXJoH74L7iDAIAAACwIZMAAAAAx1mWH/skWPRJ8FXINxJc6X/I5cp2LN7Jmuc7FkuSYrJPOBpPkkxEjOMx3a4IR+OFWY6GO80dgJgOswJwXkNiRGXL+aRxIP4vXXI2aCCuHU8AgkY6/IX3Z47zxxiI6zUgf0eAYgj5RgIAAAACICxMVph/7vgbD5kEX9EnAQAAAIANmQQAAAA4zp/zJPitr0MIoZEAAAAAx9FICG48bgQAAADAhkwCAAAAHOdyhcnlt8nUyCT4ikwCAAAAABsyCQAAAHCc5XL5sU8C98F9xRkEAAAAYEMmAQAAAI5jdKPgRiYBAAAAgA2ZBAAAADiOTEJwI5MAAAAAwIZMAgAAABxHJiG4kUkAAAAAYEMmAQAAAI6zLD9mEiwyCb4ikwAAAADAhkwCAAAAHGeFhckK81MmwU/lhhIyCQAAAABsyCQAAADAcZbL5cfRjbgP7ivOIAAAAELetGnTlJiYqOjoaHXq1EkbNmwo0n5z586VZVkaPHiwfyvoMBoJAAAAcFzuPAn+Wopj3rx5GjdunCZOnKjNmzerbdu26tu3rw4dOlTofnv27NGDDz6oyy67zJdTEZRoJAAAACCkTZ06VaNGjdKtt96qCy64QDNmzFCFChU0c+bMAvdxu90aNmyYnnrqKTVu3NjB2jqDRgIAAAAc50QmIS0tzbZkZmbmqUdWVpY2bdqkpKQk7zqXy6WkpCStXbu2wPr/9a9/Va1atXT77beX/skJAiHfcdkc+10mq4Jj8Q5XbOJYLElqaDIcjSdJ7uhYx2O6PG6nIzocT/KERTge02mW4/+PkmU5/39p/NRRL5gE4v9SIXBejXE+puVwPHcADjIQ59Xt4Jl1B+D4gkX9+vVtrydOnKhJkybZ1h05ckRut1u1a9e2ra9du7a+//77fMtdvXq13nzzTSUnJ5dmdYNKyDcSAAAA4DyXy5LL5afG0v+Wu3//fsXG/t/Ny6ioKJ+LPnHihIYPH6433nhDNWrU8Lm8YEUjAQAAAOVSbGysrZGQnxo1aigsLEwHDx60rT948KDi4+PzbP/zzz9rz549GjBggHedx+ORJIWHh2vXrl1q0sTZJ0f8gT4JAAAAcJzlsvy6FFVkZKTat2+vZcuWedd5PB4tW7ZMnTt3zrN98+bNtW3bNiUnJ3uXgQMHqmfPnkpOTs7ziFNZRSYBAAAAIW3cuHEaMWKEOnTooI4dO+rFF19Uenq6br31VknSLbfcorp162ry5MmKjo5Wq1atbPtXqVJFkvKsL8toJAAAAMBxlmXJsvzTJ6G45Q4ZMkSHDx/WhAkTlJKSonbt2mnx4sXezsz79u2TK8RmcaaRAAAAgJA3duxYjR07Nt/3VqxYUei+s2fPLv0KBRiNBAAAADjO8uPoRsZfoyaFkNDKmwAAAAA4JzIJAAAAcJxlFW8UouKWDd+QSQAAAABgQyYBAAAAjivufAbFLRu+IZMAAAAAwIZMAgAAABznsiy5/NR3wNAnwWc0EgAAAOA4HjcKbjxuBAAAAMCGTAIAAAAcRyYhuJFJAAAAAGBDJgEAAACOc7ksufx0x9+QSfAZmQQAAAAANmQSAAAA4DjLdXrxV9nwDacQAAAAgA2ZBAAAADjOsixZfpr0zF/lhhIyCQAAAABsyCQAAADAcS6X/Di6kV+KDSkh30jwZJ+SJ8u5KynHYxyLJUmWO9PReJKU5Xb2GCUp2uQ4Gs+4nP/ouEPgGy88AD3NLI+z144keVwRjsd0mst4nA/q8GfEI+cfZ3A7/DdEkqJdzsYMxDddeACGyzyZ7dxn5FROAD6PKPNCvpEAAAAA5zHjcnAr/7cmAQAAABQLmQQAAAA4zrL8mElgdCOfkUkAAAAAYEMmAQAAAI5zWZZcfrrjb8gk+IxMAgAAAAAbMgkAAABwnh9HNxKjG/mMTAIAAAAAGzIJAAAAcBzzJAQ3MgkAAAAAbMgkAAAAwHEulyWXn+74+6vcUEImAQAAAIANmQQAAAA4zrIsv82MzIzLviOTAAAAAMCGTAIAAAAcZ7lOL/4qG74JylO4cuVKDRgwQAkJCbIsS/Pnz7e9b4zRhAkTVKdOHcXExCgpKUk//vhjYCoLAAAAlDNB2UhIT09X27ZtNW3atHzff+655/Tyyy9rxowZWr9+vSpWrKi+ffvq1KlTDtcUAAAAJZE7upG/FvgmKB836t+/v/r375/ve8YYvfjii3riiSc0aNAgSdLbb7+t2rVra/78+Ro6dKiTVQUAAADKnaDMJBRm9+7dSklJUVJSknddXFycOnXqpLVr1wawZgAAACiq3BmX/bXAN0GZSShMSkqKJKl27dq29bVr1/a+l5/MzExlZmZ6X6elpfmnggAAAEAZV+YyCSU1efJkxcXFeZf69esHukoAAAAhK3eeBH8t8E2ZayTEx8dLkg4ePGhbf/DgQe97+Xn00UeVmprqXfbv3+/XegIAAKBgdFwObmWukdCoUSPFx8dr2bJl3nVpaWlav369OnfuXOB+UVFRio2NtS0AAAAA8grKPgknT57UTz/95H29e/duJScnq1q1amrQoIHuu+8+/e1vf1PTpk3VqFEjPfnkk0pISNDgwYMDV2kAAAAUmWX5r4Mxjxv5LigbCd9884169uzpfT1u3DhJ0ogRIzR79mw9/PDDSk9P15133qnjx4+ra9euWrx4saKjo4sdyxVVQa7oiqVW93OJCnP4os3xOBtPUo7HOB5Txu1oOCsAUzmaAMQMha/YgJzXUDixgWAc/r6zwpyNFyLCQuQxkcwc5/5WZroD8HcZZV5QNhJ69OghYwq+oC3L0l//+lf99a9/dbBWAAAAKC1hLstvjUITIo1NfypzfRIAAAAA+FdQZhIAAABQvrn8mEnwkEnwGZkEAAAAADZkEgAAAOA4f/ZJIJPgOzIJAAAAAGzIJAAAAMBxZBKCG5kEAAAAADZkEgAAAOA4MgnBjUwCAAAAABsyCQAAAHBcuEsK99uMy34pNqRwCgEAAADYkEkAAACA4+iTENzIJAAAAACwIZMAAAAAx7n8mElwk0nwGZkEAAAAADZkEgAAAOC4MMulMJd/7leHWdwH9xVnEAAAAIANmQQAAAA4zp+jG/mr3FBCJgEAAACADZkEAAAAOI5MQnAjkwAAAADAhkwCAAAAHEcmIbiRSQAAAABgE/KZBFflqnJVruRYvKrRYY7FkiRlh8h/scvh82o8zsZTaNwVMQE4RCsA90osY5wNGIDrNSAcHhfdJYf/HxWY7wHLuB2NF2Y5/H2uwJzX9GznPpcZDsYqjjDLUpjlp0yCn8oNJWQSAAAAANiEyG1mAAAABBOXH/skuEIg++5vZBIAAAAA2JBJAAAAgOMY3Si4kUkAAAAAYEMmAQAAAI4Ld1kK99MdfzeZBJ/RSAAAAIDjeNwouPG4EQAAAAAbMgkAAABwHJmE4EYmAQAAAIANmQQAAAA4LszyYybBIpPgKzIJAAAAAGzIJAAAAMBxLj/2SXDRJ8FnZBIAAAAA2JBJAAAAgOMY3Si4kUkAAAAAYEMmAQAAAI4jkxDcyCQAAAAAsCGTAAAAAMeFufx3xz+M2+A+4xQCAAAg5E2bNk2JiYmKjo5Wp06dtGHDhgK3feONN3TZZZepatWqqlq1qpKSkgrdviyikQAAAADH5fZJ8NdSHPPmzdO4ceM0ceJEbd68WW3btlXfvn116NChfLdfsWKFbrzxRi1fvlxr165V/fr11adPH/3222+lcWqCAo0EAAAAhLSpU6dq1KhRuvXWW3XBBRdoxowZqlChgmbOnJnv9u+9957uuusutWvXTs2bN9e//vUveTweLVu2zOGa+w+NBAAAADguWDIJWVlZ2rRpk5KSkrzrXC6XkpKStHbt2iKVkZGRoezsbFWrVq3Y5yFY0XEZAAAA5VJaWprtdVRUlKKiomzrjhw5Irfbrdq1a9vW165dW99//32R4owfP14JCQm2hkZZF/KNBE9MnDwxlRyLFx1W/sftjQrEMea4HQ3niazgaDxJCsvJdDymcTn7FZFtnE9uBuITGeHJcjag5fx5zbac//MSCn/QwqwAXLEej7PhTJij8STJlX3K8ZjpWcbBWM7+jSwqlx/nSXD9b7n169e3rZ84caImTZpUqrGeffZZzZ07VytWrFB0dHSplh1IofCdCgAAgBC0f/9+xcbGel+fnUWQpBo1aigsLEwHDx60rT948KDi4+MLLf+FF17Qs88+q6VLl6pNmzalU+kgQZ8EAAAAOC7Msvy6SFJsbKxtya+REBkZqfbt29s6Hed2Qu7cuXOB9X/uuef09NNPa/HixerQoUPpn6AAI5MAAACAkDZu3DiNGDFCHTp0UMeOHfXiiy8qPT1dt956qyTplltuUd26dTV58mRJ0pQpUzRhwgTNmTNHiYmJSklJkSRVqlRJlSo59xi7P9FIAAAAgONcliWXn/rZFLfcIUOG6PDhw5owYYJSUlLUrl07LV682NuZed++fXK5/u8BnOnTpysrK0vXXXedrRx/9HkIFBoJAAAACHljx47V2LFj831vxYoVttd79uzxf4UCjEYCAAAAHBcmyV8DIjo/Rlb5Q8dlAAAAADZkEgAAAOA4l8vyzmfgj7LhGzIJAAAAAGzIJAAAAMBxZ85n4I+y4RsyCQAAAABsyCQAAADAccE0TwLyIpMAAAAAwIZMAgAAABznsvw3TwKDG/mORgIAAAAcxxCowY3HjQAAAADYkEkAAACA4+i4HNzIJAAAAACwIZMAAAAAx4X5seOyv8oNJWQSAAAAANiQSQAAAIDj6JMQ3MgkAAAAALAhkwAAAADHhbkshflpPgN/lRtKymQjwe12a9KkSXr33XeVkpKihIQEjRw5Uk888YSsYqaXPJEV5Ims6Kea5sN4nIsVIOFy/hgtT46j8bLcxtF4khTteETJysl0NF54ZAVH40lSZo7z12uE4xFDg0fO/ihwGbej8aQApf8tZ6O6A/Jn0vmgTv4Z8Rjn/2ah7CuTjYQpU6Zo+vTpeuutt9SyZUt98803uvXWWxUXF6d77rkn0NUDAADAOdAnIbiVyUbCmjVrNGjQIF155ZWSpMTERL3//vvasGFDgGsGAAAAlH1lsuPypZdeqmXLlumHH36QJG3dulWrV69W//79A1wzAAAAFEXuPAn+WuCbMplJeOSRR5SWlqbmzZsrLCxMbrdbzzzzjIYNG1bgPpmZmcrM/L/nq9PS0pyoKgAAAFDmlMlGwgcffKD33ntPc+bMUcuWLZWcnKz77rtPCQkJGjFiRL77TJ48WU899ZTDNQUAAEB+LD/2SSjuQDbIq0w+bvTQQw/pkUce0dChQ9W6dWsNHz5c999/vyZPnlzgPo8++qhSU1O9y/79+x2sMQAAAFB2lMlMQkZGhlwue/smLCxMHk/BQ5hFRUUpKirK31UDAABAETBPQnArk42EAQMG6JlnnlGDBg3UsmVLbdmyRVOnTtVtt90W6KoBAAAAZV6ZbCS88sorevLJJ3XXXXfp0KFDSkhI0F/+8hdNmDAh0FUDAABAEbgk+euGf5l8nj7IlMlGQuXKlfXiiy/qxRdfDHRVAAAAgHKnTDYSAAAAULaFWZbC/DQKkb/KDSVkYwAAAADYkEkAAACA41x+nCfBX+WGEjIJAAAAAGzIJAAAAMBxYa7Ti7/Khm84hQAAAABsyCQAAADAcS7Lf30HmHDZd2QSAAAAANiQSQAAAIDjXH6cJ4HRjXxHJgEAAACADZkEAAAAOI55EoIbmQQAAAAANmQSAAAA4DjmSQhunEIAAAAANmQSwiKl8EjHwnmsMMdiSZJxOf9f7MpKdzymPDmOhosIwADMxjj/f2kZ42g8lzvb0XinOfuZlJz/XBqX88focvbSCQjL4e8dSTJhzv298sa0nL2fmJXlcTSeJFnmlOMxpegAxAwu9EkIbjQSAAAA4DjLOr34q2z4hseNAAAAANiQSQAAAIDjXLLkkp8eN/JTuaGETAIAAAAAGzIJAAAAcBx9EoIbmQQAAAAANmQSAAAA4DiXdXrxV9nwDZkEAAAAADZkEgAAAOA4+iSUXHZ2tlJSUpSRkaGaNWuqWrVqpR6DTAIAAAAQ5E6cOKHp06ere/fuio2NVWJiolq0aKGaNWuqYcOGGjVqlDZu3Fhq8WgkAAAAwHG58yT4aylPpk6dqsTERM2aNUtJSUmaP3++kpOT9cMPP2jt2rWaOHGicnJy1KdPH/Xr108//vijzzF53AgAAAAIYhs3btTKlSvVsmXLfN/v2LGjbrvtNk2fPl2zZ8/WqlWr1LRpU59i0kgAAACA8/zYJ6GcJRL0/vvve/996aWXavHixYqNjc2zXXR0tP7f//t/pRKTx40AAACAMmLdunU6depUnvVpaWkaP358qcWhkQAAAADH5c6T4K+lvLnuuuv07LPPyrIsHTp0KM/76enpeuGFF0otHo8bAQAAAEGuQYMGWrRokYwxatu2rapXr662bduqbdu2ateunXbt2qU6deqUWjwaCQAAAHCcJf91HSiHiQRNnTpVkhQZGamvv/5aBw4c0JYtW5ScnKyPP/5YHo9Hzz33XKnFo5EAAAAAlBHp6emKiIiQJA0aNMhvcWgkAAAAwHEuy5LLT8Mb+avcYJDbQPA3Oi4DAAAAsCGTAAAAAMdZ8t88CeU3j+AcMgkAAAAAbGgkAAAAwHEuPy+hyOVyqVevXtq0aZPPZfn8uNGOHTu0Zs0aHT58WC1bttTAgQMlSR6PRzk5OYqMjPS5kgAAAAAKN3PmTO3Zs0djxozRunXrfCqrxI2E/fv369Zbb9Xy5cu960aMGOFtJLzxxhu666679N///le9e/f2qZLlSbbHOBovPLqyo/EkyVjOt99dWRmOxgvLyTsdut+5whwPmRUW5Wi8qMxUR+NJUkxEjOMxTxlnb564sz2OxpOkii634zE9Yc6M+JHLuEKjW5/H4ae73cbZv5OSpAD8X1aIcO473eNgrOKwLEuWnzol+KvcYDdy5EhJ0qRJk3wuq0S/5o4dO6bu3bvryy+/VMuWLTV69GiZsz7UN9xwg1wulxYuXOhzJQEAAADk79dff5XbXbo3Z0rUSJgyZYr27NmjBx98UFu3btWrr76aZ5uqVauqdevWWr16tc+VBAAAQPnisvy7hJIrrrhCJ0+e9L7+448/tGHDBp/KLFEjYcGCBUpMTNSzzz5baDqncePGOnDgQIkrBwAAAKBw4eHhiouL876Oi4vT6NGjfSqzRI2EvXv36qKLLpLLVfjukZGROnbsWIkqBgAAgPLLsvy7hJJ69epp1apV3tcul0tZWVk+lVminjrR0dE6ceLEObfbt2+frVUDAAAAoHS9+uqruuKKK9S5c2d17NhR27ZtU4MGDXwqs0SZhObNm2vz5s1KT08vcJsjR45o69atatOmTYkrBwAAgPKJeRJKT4MGDbRlyxZdfvnl2rdvn5o1a6Z58+b5VGaJzuF1112no0ePaty4cfJ48h9a76GHHlJGRoaGDBniUwUBAACAUDZo0CDvzfkdO3bk+/s7IiJCN9xwg55++mmNHTtWlSpV8ilmiR43GjNmjN566y3961//0qZNm3TNNddIkn7++WdNnTpV//73v7Vhwwa1a9fOO14rAAAAkIt5Eoru/PPP9w5x2qpVK0VHR6tly5Zq166d2rZt611iY2NLLWaJ+yR88cUXuv7667VmzRpt2bJFkrR69WqtXr1axhhdfPHFmj9/viIinJ3cBgAAAMHPn0OVlrchUJ977jnvvw8fPqytW7dq69atSk5O1r/+9S/t3LlTOTk5atiwoTp27Kh+/fpp+PDhCgsr+UR6JZ5isE6dOlq9erW++OILffrpp/rll1/k8XhUv3599e/fX4MGDSp3rTgAAAAgkKpXr65evXqpV69e3nXZ2dnauXOnkpOTtXHjRj322GPauHGjpk2bVuI4ljl7quQQkZaWpri4OB3e+5NiYys7FvfPCOdiSVJMTsGdy/3FWM53F3KdSnM0niemiqPxJEmukt8NKKksq8T3EUokKjPV0XiSZCJiHI95yop0NJ7b4/zXfEVX6c78WRSeMGcz15bH+WNUAL5fPXL2ht+RP3McjSdJ8a4Mx2N+nxHlWKyTJ9LUpXkDpaamlurjKCWV+xts96+/+60+aWlpalSvTtAcs9M2bdqkPn366OjRoyUuI9Q6fwMAAADlWqtWrfTwww/7VIbPtwndbreOHj2qU6dOFbiNr+O0AgAAoHyhT4L/REVFafz48T6VUeJGwpo1a/TUU09p5cqVhc7oZlmWcnKcTx0CAAAAKJkSNRK+/PJL9e/fX9nZ2ZKkatWqqXJlZ5+1BwAAQNnFEKilz+VyqUePHnr++efVvn17n8oqUSPhiSeeUHZ2tu677z498cQTqlatmk+VAAAAAOCbmTNnas+ePRozZozWrVvnU1klaiQkJyerXbt2mjp1qk/BAQAAEJrok1D6cicxnjRpks9llWh0o0qVKql58+Y+BwcAAABQuEGDBik9/fSw9jt27JDH4/F7zBJlEi655BL98MMPpV0XAAAAhAjrfxd/lV2enH/++XK7T8/N0qpVK0VHR6tly5Zq166d2rZt611Kc06IEmUSHn/8cW3btk1z5swptYoAAAAAyOu5557zNgAOHz6sRYsW6aabblJWVpb+9a9/KSkpSVWrVlXjxo01dOhQzZ4929uoKKkSZRI6deqkefPm6Y477tAnn3yi/v37q0GDBnK58m9zdOvWzadKAgAAoHxxWZZcfhqFqCTlTps2Tc8//7xSUlLUtm1bvfLKK+rYsWOB2//73//Wk08+qT179qhp06aaMmWKrrjiCl+qXSTVq1dXr1691KtXL++67Oxs7dy5U8nJydq4caMee+wxbdy4UdOmTStxnBLPk+B2u1WhQgV98MEH+uCDDwrcjnkSAAAAEMzmzZuncePGacaMGerUqZNefPFF9e3bV7t27VKtWrXybL9mzRrdeOONmjx5sq666irNmTNHgwcP1ubNm9WqVatSr9++ffsKnZw4IiJCbdq0UZs2bXTLLbfouuuu0zXXXONTI8Eyxpji7rRw4UJdc8018ng8qlatmho1aqRKlSoVuP3y5ctLXEF/SUtLU1xcnA7v/Umxsc7N8fBnhLPzScTkpDsaT5KMVaKn2HziOpXmaDxPTBVH40mSXGGOh8yyfJ6UvViiMlMdjSdJJiLG8ZinrEhH47k9xf6a91lFl29p7pLwhEU4Gs/yOH+MCsD3q8fhp7uP/On8jcV4V4bjMb/PiHIs1skTaerSvIFSU1NL9Zn1ksr9DZZy8KDf6pOWlqb42rWLfMydOnXSxRdfrFdffVWS5PF4VL9+fd1999165JFH8mw/ZMgQpaena9GiRd51l1xyidq1a6cZM2aU3oH8r9q1a2vw4MG64447dPHFF+e7TWpqqj744AO99NJLuuWWW2SM8WnW5RL9Avjb3/4mY4xefvlljR49WmFhzv94AQAAAAqTlma/iRgVFaWoKHsDLSsrS5s2bdKjjz7qXedyuZSUlKS1a9fmW+7atWs1btw427q+fftq/vz5pVPxs+zYsUPPPPOMLr/8ckVHR6t9+/ZKSEhQdHS0/vjjD+3YsUPbt2/XRRddpOeee65UHnsqUSNhx44d6ty5s8aOHetzBQLOcjl6ZybM4e72Jty5OxWBZMKdvTPrdOZCkkyYs3f1JSk9LM7ReNHZpxyNJ0ky/h9G7mxZ4c7e8c4JQCahUvYJx2O6o6s6Gs9lOX+DzCXn/y/dxX/gwCdZbuePUZbz3wMx4c799nA7GKs4LGNk+en6yi23fv36tvUTJ07MM4fAkSNH5Ha7Vbt2bdv62rVr6/vvv8+3/JSUlHy3T0lJ8bHm+atevbqmTp2qZ555Rp9++qlWr16tvXv36s8//1SNGjU0bNgw9e3bt1QfdSrRr46KFSuqYcOGpVYJAAAAoLTt37/f9rjR2VmEsiYmJkbXXXedrrvuOr/HKlEjoUePHtqyZUtp1wUAAAChwnj8l83933JjY2PP2SehRo0aCgsL08GDB23rDx48qPj4+Hz3iY+PL9b2ZVGJ8k9PP/209u/fr2effba06wMAAAA4JjIyUu3bt9eyZcu86zwej5YtW6bOnTvnu0/nzp1t20vSkiVLCty+pJYuXapLLrlE3bt319KlSyVJv//+u2bNmqUbb7yxVGOdrUSZhHXr1um2227T448/roULF6pfv36FzpNwyy23+FRJAAAAlC+W8cjyUyahuOWOGzdOI0aMUIcOHdSxY0e9+OKLSk9P16233irp9G/ZunXravLkyZKke++9V927d9c//vEPXXnllZo7d66++eYbvf7666V6HGPHjtXTTz+txo0ba+bMmXrvvff04YcfasCAARo4cGCpxjpbiRoJI0eOlGVZMsZo3bp1Wr9+faHb00gAAABAsBoyZIgOHz6sCRMmKCUlRe3atdPixYu9nZP37dtnuxl+6aWXas6cOXriiSf02GOPqWnTppo/f36pz5EQExOj66+/XpLUrl071axZUzt27FC9evVKNU5+StRIuOWWW2T5aYY8AAAAhAAH+iQUx9ixYwscuXPFihV51l1//fXeH/D+cvjwYc2bN09NmzZVs2bNlJiY6EgDQSphI2H27NmlXA0AAAAAZ3rggQf03//+V1OnTtXOnTuVmZmpQYMGqV27dmrXrp2uvvpqv8UOzoFzi+C3337TzTffrOrVqysmJkatW7fWN998E+hqAQAAoCiM8e9SDtx///168803tX79eqWlpen777/XHXfcoejoaH344Yd+je387Eyl4I8//lCXLl3Us2dPff7556pZs6Z+/PFHVa3q7EQ6AAAAgFMaNWqkRo0aacCAAX6PVaRGwsqVKyVJHTt2VHR0tPd1UXXr1q34NSvElClTVL9+fc2aNcu7rlGjRqUaAwAAAH4UZH0SYFekRkKPHj1kWZZ27typZs2aeV8XhWVZysnJ8amSZ1u4cKH69u2r66+/Xl999ZXq1q2ru+66S6NGjSpwn8zMTGVmZnpfp6WllWqdAAAAAH/58MMP9fTTTys5OVmS9Mgjj6hZs2Zq27atWrVqVeqzSRepkdCtWzdZlqUKFSrYXgfKL7/8ounTp2vcuHF67LHHtHHjRt1zzz2KjIzUiBEj8t1n8uTJeuqppxyuKQAAAPJjGePHeRLKR5+EM82aNUsjR470vp42bZrcbrdOnTqlsLAwtWjRQitXrlSVKlVKJZ5lTNk7i5GRkerQoYPWrFnjXXfPPfdo48aNWrt2bb775JdJqF+/vg7v+0WxsZX9XudcWREVHYslSRGmdLM4wcrKPOFsPLfz59WEOd+F6FhYnKPxqmcedjSeJJnwSMdjpoZXcTRejsf5r/nqnlTHY2ZFO9svzRWAm2UuOf9/me1wyIPpzn+/NghPdzzm3mznfg+cPJGmi86rp9TUVMXGxjoWtyBpaWmKi4vz62+wtLQTqtmgcdAcc2lo1KiRPv30U11wwQWSpMqVKys5OVlhYWHatm2bJk2apOuvv16PPPJIqcQr0uhGvXr10vPPP18qAUtDnTp1vCcoV4sWLbRv374C94mKilJsbKxtAQAAQIDk9knw11LO/P7774qL+7+bd2FhYbIsS4mJiRowYIAeeughffLJJ6UWr0i3JlesWKHExMRSC+qrLl26aNeuXbZ1P/zwgxo2bBigGgEAAAD+U6NGDe3Zs0d169aVJKWkpCgiIsL7frt27bRjx45Si1cm50m4//77tW7dOv3973/XTz/9pDlz5uj111/XmDFjAl01AAAAFAWZhGLp1auX3nzzTe/r6OhohYWFeV+7XC5lZ2eXWrwy2Ui4+OKL9fHHH+v9999Xq1at9PTTT+vFF1/UsGHDAl01AAAAoNQ99NBDmjNnjl566aV83//666/VuHHjUotXJidTk6SrrrpKV111VaCrAQAAgJJgnoRiad26td59913ddNNN+uSTTzR69GhdfPHFCg8P1+rVq/Xoo4/q/vvvL7V4ZbaRAAAAgDLMeCQPjYTiuO6669SkSRPdf//9uv76671TEhhjNGDAAI0bN67UYhW5kfDWW2/prbfeKnYAf0ymBgAAAISiCy+8UCtWrNC+ffu0bds2nThxQi1btlTr1q1LNU6RGwllcDoFAAAABCnLePw4mVr5zCScqUGDBmrQoIHfyi9yI6Ffv34aP3683yoCAAAAIDgUuZEQHx+v7t27+7MuAAAACBV0XA5qZXIIVAAAAAD+E/KjGxnLkrHKb1spIMcWiJjh0Q4HPOVwPCks7ZDjMVU17tzblKYA9H0yjl87Uky45Wi8Y6cCcEctAN8DOR5nr5/osHNvU9pOuZ3/jOSOnuKUyDBn40kKyPVaIcK5mO7wIP2dY4z/vvfpS+uzIL1qAAAAAORn1apVuvnmm9W5c2f99ttvkqR33nlHq1evLrUYNBIAAADgvNw+Cf5ayqkPP/xQffv2VUxMjLZs2aLMzExJUmpqqv7+97+XWpwiNRI8Ho9mzpxZakEBAAAAFN/f/vY3zZgxQ2+88YYiIiK867t06aLNmzeXWpyQ75MAAAAA51nG+HGehPLbJ2HXrl3q1q1bnvVxcXE6fvx4qcXhcSMAAACgjIiPj9dPP/2UZ/3q1avVuHHjUotDIwEAAADOo09CiYwaNUr33nuv1q9fL8uydODAAb333nt68MEHNXr06FKLw+NGAAAAQBnxyCOPyOPxqHfv3srIyFC3bt0UFRWlBx98UHfffXepxaGRAAAAAOcx43KJWJalxx9/XA899JB++uknnTx5UhdccIEqVaqkP//8UzExMaUSh8eNAAAAgDImMjJSF1xwgTp27KiIiAhNnTpVjRo1KrXyaSQAAADAefRJKJbMzEw9+uij6tChgy699FLNnz9fkjRr1iw1atRI//M//6P777+/1OLxuBEAAAAQ5CZMmKDXXntNSUlJWrNmja6//nrdeuutWrdunaZOnarrr79eYWFhpRaPRgIAAAAcZxmPH+dJKH+ZhH//+996++23NXDgQH333Xdq06aNcnJytHXrVlmWVerxeNwIAAAACHK//vqr2rdvL0lq1aqVoqKidP/99/ulgSCRSQAAAEAgeDynF3+VXc643W5FRkZ6X4eHh6tSpUp+i0cjAQAAAAhyxhiNHDlSUVFRkqRTp07p//2//6eKFSvatvvoo49KJR6NBAAAADjPmNOLv8ouZ0aMGGF7ffPNN/s1Ho0EAAAAIMjNmjXL0Xg0EgAAAOA8ZlwOaoxuBAAAAMCGTAIAAAAcxzwJwY1MAgAAAAAbMgkAAABwHn0SghqZBAAAAAA2ZBIAAADgPGP8mEkof/MkOI1GguU6vTgkXA6nvxw8tkAy4VHOBgyR81olwuGApxyOJyklO/LcG5Wyesd2ORovLK6po/EkyYRHOx4zy+3sj4IYZTsaT5KOnXL+u6dWBWd/KoRZlqPxJMlExDgeM9rj3HFmhzt/TlH20UgAAACA84xb8rj9VzZ8QiMBAAAAjjMej4zHP09Y+KvcUBIaz0wAAAAAKDIyCQAAAHCex4+PG/mr3BBCJgEAAACADZkEAAAAOI9MQlAjkwAAAADAhkwCAAAAHGfcbhm3f+74+6vcUEImAQAAAIANmQQAAAA4z+M5vfirbPiETAIAAAAAGzIJAAAAcJ7H48fRjcgk+IpMAgAAAAAbMgkAAABwnPG4ZfyUSfBXuaGETAIAAAAAGzIJAAAAcJ7x4+hGhj4JviKTAAAAAMCGTAIAAAAcR5+E4EYmAQAAAIANmQQAAAA4z+P24zwJZBJ8RSYBAAAAgA2ZBAAAADjP48fRjZhx2WdkEgAAAADYkEkAAACA44zbLeP20+hGfio3lNBIsKzTi2PxHE7eBGIyEaePMQAxPRHRjsaTJBMR5XjMsJOHnY2XftTReJK0OcP5/8tae752NF7YZU0djSdJ2WHOX6/pmTmOxotzGUfjSVJapvM/fOrGOBsvwuX83xATgL9bMeHOxcx2MBbKDxoJAAAAcJ7H48fRjeiT4CualgAAAABsyCQAAADAecyTENTIJAAAAACwIZMAAAAAxxmPR8ZPfQf8VW4oIZMAAAAAwIZMAgAAAJxHn4SgRiYBAAAAgA2ZBAAAADjP+DGTYMgk+IpMAgAAAAAbMgkAAABwHKMbBTcaCQAAAHCex+PHjss0EnzF40YAAAAAbMgkAAAAwHkMgRrUyCQAAAAAsCkXjYRnn31WlmXpvvvuC3RVAAAAUATG7fbrAt+U+UbCxo0b9dprr6lNmzaBrgoAAABQLpTpRsLJkyc1bNgwvfHGG6patWqgqwMAAICi8nj8u8AnZbqRMGbMGF155ZVKSko657aZmZlKS0uzLQAAAADyKrONhLlz52rz5s2aPHlykbafPHmy4uLivEv9+vX9XEMAAAAUKHd0I38tfnLs2DENGzZMsbGxqlKlim6//XadPHmy0O3vvvtunX/++YqJiVGDBg10zz33KDU11W91LA1lspGwf/9+3XvvvXrvvfcUHR1dpH0effRRpaamepf9+/f7uZYAAAAob4YNG6bt27dryZIlWrRokVauXKk777yzwO0PHDigAwcO6IUXXtB3332n2bNna/Hixbr99tsdrHXxlcl5EjZt2qRDhw7poosu8q5zu91auXKlXn31VWVmZiosLMy2T1RUlKKiopyuKgAAAPJhPG4ZP93x91e5O3fu1OLFi7Vx40Z16NBBkvTKK6/oiiuu0AsvvKCEhIQ8+7Rq1Uoffvih93WTJk30zDPP6Oabb1ZOTo7Cw4Pz53iZzCT07t1b27ZtU3Jysnfp0KGDhg0bpuTk5DwNBAAAAMBXa9euVZUqVbwNBElKSkqSy+XS+vXri1xOamqqYmNjg7aBIJXRTELlypXVqlUr27qKFSuqevXqedYDAAAg+BiPR8ZPoxDllnv2QDW+PlmSkpKiWrVq2daFh4erWrVqSklJKVIZR44c0dNPP13oI0rBoEw2EkqV5Tq9oPQY54cdMy5ns0duj3E0niSFVQjAML8O/19m79vlaDxJio53fhADK7JofalKy5/Zzn8mq7md75B3JCPG0XgJkc5/D5zKcTykJGe/X8NdlqPxJMm4nP8d4PJjx9o8sUzoTix29kA1EydO1KRJk/Js98gjj2jKlCmFlrVz506f65OWlqYrr7xSF1xwQb71CCblppGwYsWKQFcBAAAARWQ8Rsbtr0zC6Ub8/v37FRsb611fUBbhgQce0MiRIwsts3HjxoqPj9ehQ4ds63NycnTs2DHFx8cXuv+JEyfUr18/Va5cWR9//LEiIiKKcCSBU24aCQAAAMCZYmNjbY2EgtSsWVM1a9Y853adO3fW8ePHtWnTJrVv316S9OWXX8rj8ahTp04F7peWlqa+ffsqKipKCxcuLPLonIHEczYAAABwnHF7/Lr4Q4sWLdSvXz+NGjVKGzZs0Ndff62xY8dq6NCh3pGNfvvtNzVv3lwbNmyQdLqB0KdPH6Wnp+vNN99UWlqaUlJSlJKSIrc7eB8FI5MAAAAAFNF7772nsWPHqnfv3nK5XLr22mv18ssve9/Pzs7Wrl27lJGRIUnavHmzd+Sj8847z1bW7t27lZiY6Fjdi4NGAgAAABznxOhG/lCtWjXNmTOnwPcTExNlzP8NbNCjRw/b67KCx40AAAAA2JBJAAAAgOP82XfAX+WGEjIJAAAAAGzIJAAAAMBxZBKCG5kEAAAAADZkEgAAAOA443bL46d5AkwQzz9QVpBJAAAAAGBDJgEAAACOM8aP8yQY+iT4ikwCAAAAABsyCQAAAHAcoxsFNzIJAAAAAGzIJAAAAMBxZBKCG5kEAAAAADZkEgAAAOA44zH+G93IY/xSbiihkQAAAADHedweefz0WJC/yg0lPG4EAAAAwIZMAgAAABxHx+XgRiYBAAAAgA2ZBOM5vTgkx/F+NKHRDtx3PMvReE0qOd8hatYPmY7HvM211dF43yT2czSeJPWxfnU8Zk7nax2NV2fVu47Gk6TMHiMdj9k62tk7h1kB+H5tV9P5u6NOf9tVCHP++zUQfVwty8Hrx8lYxUAmIbgF51UDAAAAIGDIJAAAAMBxxnj8NwSqg0+JlFdkEgAAAADYkEkAAACA4+iTENzIJAAAAACwIZMAAAAAx5FJCG5kEgAAAADYkEkAAACA4zwejzx+Gt3IX+WGEjIJAAAAAGzIJAAAAMBx9EkIbmQSAAAAANiQSQAAAIDjTmcS3H4rG74hkwAAAADAhkwCAAAAHGc8Hhk/jULkr3JDCZkEAAAAADZkEgAAAOA44/Hj6EZkEnxGJgEAAACADZkEAAAAOM+P8ySI0Y18RiYBAAAAgA2ZBAAAADjO4/bI46c7/v4qN5SQSQAAAABgQyYBAAAAjmOehOBGJgEAAACADZkEAAAAOM74cXQjv42aFEJCvpHgDouSOyzKsXjhxu1YLEnKcFuOxpOkii5nj1GSalZw9lI2Yc6fV48xjsd0H01xNN47e391NJ4kXVx/t+Mxtfs7R8OFt+3haDxJynT+clWO5WxyPML5rwEF4gEAj5w9UJcCcPEEgLGcO69OxkL5EfKNBAAAADjPuI2M2z+NQn+VG0rokwAAAADAhkwCAAAAHOfx+HGeBEY38hmZBAAAAAA2ZBIAAADgOOMxMh4/9UnwU7mhhEYCAAAAHOdxSx6Xf37Me5wfaLHc4XEjAAAAADZkEgAAAOA44/bIuJhMLViRSQAAAABgQyYBAAAAjjNuI+OnPglMpuY7MgkAAAAAbMgkAAAAwHEet/Hj6EZkEnxFJgEAAACADZkEAAAAOI7RjYIbmQQAAAAANmQSAAAA4DiPMfJ4/NQnwdAnwVdkEgAAAADYkEkAAACA89xGxvLTHX9GN/IZmQQAAAAANmQSAAAA4DiP2yOP5Z9RiDyMbuQzMgkAAAAAbMgkAAAAwHHGj30SDH0SfEYmAQAAAIANmQQAAAA4jkxCcCuTjYTJkyfro48+0vfff6+YmBhdeumlmjJlis4///xil+WSkUvOXUgeK8yxWJIUGRaAD0kAQkaHW47Gszw5jsaTpMZVKzgeMyK2maPx9q5MdzSeJKWlfO14zKp9Bjsa71S1Ro7GkyQTgE6DEZ4sR+OZsAhH40mScTn7N0SSXA5PSuWRs9/nkhz9HeDlYEiLicVQAmXycaOvvvpKY8aM0bp167RkyRJlZ2erT58+Sk93/gcGAAAAis/j9vh1gW/KZCZh8eLFttezZ89WrVq1tGnTJnXr1i1AtQIAAADKhzLZSDhbamqqJKlatWoFbpOZmanMzEzv67S0NL/XCwAAAPkzxsh4/NQngUesfFYmHzc6k8fj0X333acuXbqoVatWBW43efJkxcXFeZf69es7WEsAAACg7CjzjYQxY8bou+++09y5cwvd7tFHH1Vqaqp32b9/v0M1BAAAwNk8buPXBb4p048bjR07VosWLdLKlStVr169QreNiopSVFSUQzUDAAAAyq4y2Ugwxujuu+/Wxx9/rBUrVqhRI+eH9wMAAEDJGbeRkX9GIWKeBN+VyUbCmDFjNGfOHC1YsECVK1dWSkqKJCkuLk4xMTEBrh0AAABQtpXJRsL06dMlST169LCtnzVrlkaOHOl8hQAAAFAspzMJzLgcrMpkI4FhrQAAAAD/KZONBAAAAJRtHreRx0+ZBEY38l2ZHwIVAAAAQOkikwAAAADHGY9HxrL8VjZ8QyMBAAAAjuNxo+DG40YAAAAAbMgkAAAAwHHG48chUD1kEnxFJgEAAACADZkEAAAAOM/tkTH+6bgsOi77jEwCAAAAABsaCQAAAHCcx238uvjLsWPHNGzYMMXGxqpKlSq6/fbbdfLkySLta4xR//79ZVmW5s+f77c6lgYaCQAAAEARDRs2TNu3b9eSJUu0aNEirVy5UnfeeWeR9n3xxRdl+WluiNJGnwQAAAA4zriNjClboxvt3LlTixcv1saNG9WhQwdJ0iuvvKIrrrhCL7zwghISEgrcNzk5Wf/4xz/0zTffqE6dOn6pX2kikwAAAAAUwdq1a1WlShVvA0GSkpKS5HK5tH79+gL3y8jI0E033aRp06YpPj7eiar6jEwCAAAAHOcxRh4/ZRJyy01LS7Otj4qKUlRUVInLTUlJUa1atWzrwsPDVa1aNaWkpBS43/33369LL71UgwYNKnFsp9FIMJ7Ti1OsMOdiSXIF4rm3AMxfEubwcXpcEY7Gk6S28c4n/tzuZo7Gu7hR2rk3KmVbxq1wPGbVQY87Gi8xx/mhACtEOH+9ehTtaDw//bYpVECeZHbyb6Qkl+X8tZMTgP/LCE+WY7Est3Oxgk39+vVtrydOnKhJkybl2e6RRx7RlClTCi1r586dJarDwoUL9eWXX2rLli0l2j9QaCQAAADAcW5j5PZTazu33P379ys2Nta7vqAswgMPPKCRI0cWWmbjxo0VHx+vQ4cO2dbn5OTo2LFjBT5G9OWXX+rnn39WlSpVbOuvvfZaXXbZZVqxYkXhBxMgNBIAAABQLsXGxtoaCQWpWbOmatasec7tOnfurOPHj2vTpk1q3769pNONAI/Ho06dOuW7zyOPPKI77rjDtq5169b6n//5Hw0YMKAIRxEYNBIAAADgOLc5vfirbH9o0aKF+vXrp1GjRmnGjBnKzs7W2LFjNXToUO/IRr/99pt69+6tt99+Wx07dlR8fHy+WYYGDRqoUaNG/qloKWB0IwAAAKCI3nvvPTVv3ly9e/fWFVdcoa5du+r111/3vp+dna1du3YpIyMjgLX0HZkEAAAAOM6JPgn+UK1aNc2ZM6fA9xMTE885/4O/5ocoTWQSAAAAANiQSQAAAIDjymKfhFBCJgEAAACADZkEAAAAOM7jxz4J/prJOZSQSQAAAABgQyYBAAAAjnPLj30S/FNsSCGTAAAAAMCGTAIAAAAc5zZGbpW9eRJCBZkEAAAAADZkEgAAAOA4t/Ff3wHmSfAdmQQAAAAANmQSAAAA4DgyCcGNTAIAAAAAGzIJAAAAcByjGwU3MgkAAAAAbMgkAAAAwHEeP/ZJ8JBI8BmZBAAAAAA2ZBIAAADgOPokBDcaCQAAAHAcQ6AGNxoJluv04hCXn1rMwcTtinA8psv462smf8YKczSeJFWMcP7pQBNW0dF4SU2jHI0nSfHdGjoec8sfGY7Ga1Ej2tF4oSIg3+eBCOly9vsuEDeAw/32U7VgnnDnvu+cjIXyg0YCAAAAHHc6k+Cvx438UmxIoeMyAAAAABsyCQAAAHAcfRKCG5kEAAAAADZkEgAAAOA4hkANbmQSAAAAANiQSQAAAIDjjCSPH8uGb8gkAAAAALAhkwAAAADH0SchuJFJAAAAAGBDJgEAAACOY56E4EYmAQAAAIANmQQAAAA4jj4JwY1MAgAAAAAbMgkAAABwHH0SghuZBAAAAAA2ZBIAAADgOPokBDcyCQAAAABsyCQAAADAcR4/9knwkEjwGZkEAAAAADZkEgAAAOA4+iQENzIJAAAAAGzIJAAAAMBxbvlvPgN/9XUIJSHbSDD/m4Y6ceJEgGtS/nhkOR7TZZz9OjCuMEfjSVJOAHphRXqyHI2XfsL5r/WTWdmOx8w46ez3Tlqa81/1lvNfA46zQuRxBuPwf2YgTqvTf0MkZ/+O5P7WMUF2zWbJUybLDhUh20jI/cCc17RpgGsCIOTMXBjoGgAIQSdOnFBcXFygq6HIyEjFx8frvZTf/BonPj5ekZGRfo1Rnlkm2JqVDvF4PDpw4IAqV64sqxh3SdLS0lS/fn3t379fsbGxfqxh2cT5KRznp2Ccm8JxfgrH+SkY56ZwoXB+jDE6ceKEEhIS5HIFR3fUU6dOKSvLv9nqyMhIRUdH+zVGeRaymQSXy6V69eqVeP/Y2Nhy+2VSGjg/heP8FIxzUzjOT+E4PwXj3BSuvJ+fYMggnCk6Opof8EEuOJqTAAAAAIIGjQQAAAAANjQSiikqKkoTJ05UVFRUoKsSlDg/heP8FIxzUzjOT+E4PwXj3BSO8wPkL2Q7LgMAAADIH5kEAAAAADY0EgAAAADY0EgAAAAAYEMjIR/Tpk1TYmKioqOj1alTJ23YsKHQ7f/973+refPmio6OVuvWrfXZZ585VFNnTZ48WRdffLEqV66sWrVqafDgwdq1a1eh+8yePVuWZdmW8jou8qRJk/Ica/PmzQvdJ1SuncTExDznxrIsjRkzJt/ty/t1s3LlSg0YMEAJCQmyLEvz58+3vW+M0YQJE1SnTh3FxMQoKSlJP/744znLLe53V7Aq7PxkZ2dr/Pjxat26tSpWrKiEhATdcsstOnDgQKFlluTzGYzOde2MHDkyz3H269fvnOWGwrUjKd/vIcuy9PzzzxdYZnm5doDiopFwlnnz5mncuHGaOHGiNm/erLZt26pv3746dOhQvtuvWbNGN954o26//XZt2bJFgwcP1uDBg/Xdd985XHP/++qrrzRmzBitW7dOS5YsUXZ2tvr06aP09PRC94uNjdXvv//uXfbu3etQjZ3XsmVL27GuXr26wG1D6drZuHGj7bwsWbJEknT99dcXuE95vm7S09PVtm1bTZs2Ld/3n3vuOb388suaMWOG1q9fr4oVK6pv3746depUgWUW97srmBV2fjIyMrR582Y9+eST2rx5sz766CPt2rVLAwcOPGe5xfl8BqtzXTuS1K9fP9txvv/++4WWGSrXjiTbefn99981c+ZMWZala6+9ttByy8O1AxSbgU3Hjh3NmDFjvK/dbrdJSEgwkydPznf7G264wVx55ZW2dZ06dTJ/+ctf/FrPYHDo0CEjyXz11VcFbjNr1iwTFxfnXKUCaOLEiaZt27ZF3j6Ur517773XNGnSxHg8nnzfD6XrRpL5+OOPva89Ho+Jj483zz//vHfd8ePHTVRUlHn//fcLLKe4311lxdnnJz8bNmwwkszevXsL3Ka4n8+yIL9zM2LECDNo0KBilRPK186gQYNMr169Ct2mPF47QFGQSThDVlaWNm3apKSkJO86l8ulpKQkrV27Nt991q5da9tekvr27Vvg9uVJamqqJKlatWqFbnfy5Ek1bNhQ9evX16BBg7R9+3YnqhcQP/74oxISEtS4cWMNGzZM+/btK3DbUL12srKy9O677+q2226TZVkFbhdK182Zdu/erZSUFNu1ERcXp06dOhV4bZTku6s8SU1NlWVZqlKlSqHbFefzWZatWLFCtWrV0vnnn6/Ro0fr6NGjBW4bytfOwYMH9emnn+r2228/57ahcu0AZ6KRcIYjR47I7Xardu3atvW1a9dWSkpKvvukpKQUa/vywuPx6L777lOXLl3UqlWrArc7//zzNXPmTC1YsEDvvvuuPB6PLr30Uv36668O1tYZnTp10uzZs7V48WJNnz5du3fv1mWXXaYTJ07ku32oXjvz58/X8ePHNXLkyAK3CaXr5my5///FuTZK8t1VXpw6dUrjx4/XjTfeqNjY2AK3K+7ns6zq16+f3n77bS1btkxTpkzRV199pf79+8vtdue7fShfO2+99ZYqV66sa665ptDtQuXaAc4WHugKoGwaM2aMvvvuu3M+l9m5c2d17tzZ+/rSSy9VixYt9Nprr+npp5/2dzUd1b9/f++/27Rpo06dOqlhw4b64IMPinSnKlS8+eab6t+/vxISEgrcJpSuG5Rcdna2brjhBhljNH369EK3DZXP59ChQ73/bt26tdq0aaMmTZpoxYoV6t27dwBrFnxmzpypYcOGnXNQhFC5doCzkUk4Q40aNRQWFqaDBw/a1h88eFDx8fH57hMfH1+s7cuDsWPHatGiRVq+fLnq1atXrH0jIiJ04YUX6qeffvJT7YJHlSpV1KxZswKPNRSvnb1792rp0qW64447irVfKF03uf//xbk2SvLdVdblNhD27t2rJUuWFJpFyM+5Pp/lRePGjVWjRo0CjzMUrx1JWrVqlXbt2lXs7yIpdK4dgEbCGSIjI9W+fXstW7bMu87j8WjZsmW2u5pn6ty5s217SVqyZEmB25dlxhiNHTtWH3/8sb788ks1atSo2GW43W5t27ZNderU8UMNg8vJkyf1888/F3isoXTt5Jo1a5Zq1aqlK6+8slj7hdJ106hRI8XHx9uujbS0NK1fv77Aa6Mk311lWW4D4ccff9TSpUtVvXr1Ypdxrs9nefHrr7/q6NGjBR5nqF07ud588021b99ebdu2Lfa+oXLtAIxudJa5c+eaqKgoM3v2bLNjxw5z5513mipVqpiUlBRjjDHDhw83jzzyiHf7r7/+2oSHh5sXXnjB7Ny500ycONFERESYbdu2BeoQ/Gb06NEmLi7OrFixwvz+++/eJSMjw7vN2efnqaeeMl988YX5+eefzaZNm8zQoUNNdHS02b59eyAOwa8eeOABs2LFCrN7927z9ddfm6SkJFOjRg1z6NAhY0xoXzvGnB4xpUGDBmb8+PF53gu16+bEiRNmy5YtZsuWLUaSmTp1qtmyZYt3dJ5nn33WVKlSxSxYsMB8++23ZtCgQaZRo0bmzz//9JbRq1cv88orr3hfn+u7qywp7PxkZWWZgQMHmnr16pnk5GTbd1FmZqa3jLPPz7k+n2VFYefmxIkT5sEHHzRr1641u3fvNkuXLjUXXXSRadq0qTl16pS3jFC9dnKlpqaaChUqmOnTp+dbRnm9doDiopGQj1deecU0aNDAREZGmo4dO5p169Z53+vevbsZMWKEbfsPPvjANGvWzERGRpqWLVuaTz/91OEaO0NSvsusWbO825x9fu677z7vuaxdu7a54oorzObNm52vvAOGDBli6tSpYyIjI03dunXNkCFDzE8//eR9P5SvHWOM+eKLL4wks2vXrjzvhdp1s3z58nw/S7nnwOPxmCeffNLUrl3bREVFmd69e+c5bw0bNjQTJ060rSvsu6ssKez87N69u8DvouXLl3vLOPv8nOvzWVYUdm4yMjJMnz59TM2aNU1ERIRp2LChGTVqVJ4f+6F67eR67bXXTExMjDl+/Hi+ZZTXawcoLssYY/yaqgAAAABQptAnAQAAAIANjQQAAAAANjQSAAAAANjQSAAAAABgQyMBAAAAgA2NBAAAAAA2NBIAAAAA2NBIAAAAAGBDIwEAJBljNG/ePF1zzTWqX7++oqOjVbVqVbVr104PP/yw9u3bV6rxZs+eLcuyNHLkyGLtt2fPHlmWpcTExFKtDwAAZ6KRACDkHThwQJdccomGDh2q+fPnKz4+XoMHD9Zll12m3377Tc8//7yaNWumadOmBbqqhUpMTJRlWdqzZ0+gqwIAKOPCA10BAAikP/74Q5dddpl++eUXXXjhhXrnnXfUsmVL7/s5OTl66aWXNH78eI0dO1Zut1v33HNPwOpbt25d7dy5UxEREQGrAwCg/COTACCkjR07Vr/88osaNWqkL7/80tZAkKTw8HA98MADeumllyRJDz74oL7//vtAVFWSFBERoebNm6tJkyYBqwMAoPyjkQAgZP3yyy+aO3euJOmFF15QlSpVCtz2rrvuUtu2bZWdna3nn3/eu37kyJGyLEuzZ8/Od7+i9D04evSoxowZowYNGigqKkoNGzbU/fffrz/++CPPtvn1SciNsXfvXklSo0aNZFmWd1mxYkWBsQEAyA+PGwEIWZ988ok8Ho+qVKmigQMHFrqtZVkaPny4tm7dqoULF8oYI8uyfK7DH3/8oU6dOuno0aPq0aOH90f9iy++qM8//1yrVq1SzZo1Cy3jvPPO04gRI/Sf//xH6enpuvbaa1WpUiXv+/Hx8T7XEwAQWmgkAAhZmzZtkiRdeOGFCg8/99fhxRdfLEk6cuSI9u7dWyojDC1cuFCXXHKJNmzYoGrVqkmSjh8/riuvvFJr1qzRPffco/fff7/QMrp27aquXbtqxYoVSk9P1wsvvMDoRwAAn/C4EYCQdfjwYUlS7dq1i7T9mdvl7lsapk+f7m0gSFKVKlU0Y8YMWZalDz74QL/++mupxQIAoChoJABAERljvP92u92lUmbbtm3Vrl27POtbt26tCy+8UB6PRytXriyVWAAAFBWNBAAhq0aNGpKkgwcPFmn7Q4cOef99rn4CRdWoUaNzvkcmAQDgNBoJAEJW+/btJUmbN29WTk7OObffsGGDJCkuLq7QH/dn8ng8Ja/g/zozgwEAgBNoJAAIWQMGDJDL5VJqaqoWLFhQ6LbGGL3zzjuSpEGDBsnlOv31GRkZKUk6ceJEvvvlDktakN27dxf4Xu7MyfXq1Su0DAAAShuNBAAhq0mTJrrhhhskSQ899JCOHz9e4Lb//Oc/9e233yoyMlIPP/ywd33dunUlSTt37syzjzFGn3/+eaF1+Pbbb/Xtt9/mWb99+3Zt3rxZLpdL3bp1K8rheBssRcmKAABQGBoJAELatGnTlJiYqN27d6tXr17avn277f2cnBxNnTpV9957ryTp9ddft83KnJSUJEl65513tGPHDu/67OxsjR8/Xhs3biw0vjFGo0ePtk2clpqaqtGjR8sYo2uvvVb169cv0rHkZhzOPgYAAIqLeRIAhLRq1app1apVGjx4sDZt2qTWrVurQ4cOatKkiTIyMrR27VodPnxYsbGxev755zVixAjb/l26dNGgQYO0YMECdejQQV27dlVMTIw2b96stLQ03XvvvXrppZcKjD9w4EB99913aty4sXr27OmdTO3YsWNq2rSpXn311SIfy7XXXqvly5fr5ptvVp8+fVS1alVJp7Mk559/fslOEAAgJNFIABDy6tWrpw0bNmjevHmaN2+eNm7cqOTkZGVnZ0uSKlSooM2bN6tJkyb57j9v3jz97W9/05w5c7RixQpVrVpVvXv31tNPP61Vq1YVGrtq1apat26dnnzySX366ac6dOiQateurZtvvlkTJ060zZ9wLqNHj9aJEyf07rvv6rPPPtOpU6ckSTfffDONBABAsViGYTMAIF+pqanq2bOntmzZoj59+mjhwoWKiooKdLUAAPA7+iQAQAHi4uL0xRdfqEWLFvrvf/+rIUOG0CkYABASyCQAwDkcOHBAb7zxhowx6t+/vzp16hToKgEA4Fc0EgAAAADY8LgRAAAAABsaCQAAAABsaCQAAAAAsKGRAAAAAMCGRgIAAAAAGxoJAAAAAGxoJAAAAACwoZEAAAAAwIZGAgAAAAAbGgkAAAAAbP4/fHHgRDqzkAgAAAAASUVORK5CYII=", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -797,9 +808,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -849,7 +859,9 @@ "full_t_lg = two_opt(theta_lg, theta_lg, theta_lg)\n", "\n", "circuits_large = [\n", - " trotter_circuit(n_large, gs_circuit_large, t, half_t_lg, full_t_lg, center_large)\n", + " trotter_circuit(\n", + " n_large, gs_circuit_large, t, half_t_lg, full_t_lg, center_large\n", + " )\n", " for t in range(1, time_steps_large + 1)\n", "]\n", "print(\n", @@ -857,7 +869,8 @@ ")\n", "\n", "observables_large = [\n", - " SparsePauliOp(\"I\" * (n_large - 1 - i) + \"Z\" + \"I\" * i) for i in range(n_large)\n", + " SparsePauliOp(\"I\" * (n_large - 1 - i) + \"Z\" + \"I\" * i)\n", + " for i in range(n_large)\n", "]\n", "\n", "# ── Step 2: AQC ──────────────────────────────────────────────────────────────\n", @@ -891,10 +904,16 @@ "aqc_params_large = {}\n", "for k in range(1, aqc_steps_large + 1):\n", " x0 = aqc_params_large.get(k - 1, initial_params_large)\n", - " obj = MaximizeStateFidelity(target_mps_large[k], ansatz_large, aqc_sim_large)\n", + " obj = MaximizeStateFidelity(\n", + " target_mps_large[k], ansatz_large, aqc_sim_large\n", + " )\n", " t0 = timeit.default_timer()\n", " result = scipy.optimize.minimize(\n", - " obj.loss_function, x0, method=\"L-BFGS-B\", jac=True, options=dict(maxiter=10)\n", + " obj.loss_function,\n", + " x0,\n", + " method=\"L-BFGS-B\",\n", + " jac=True,\n", + " options=dict(maxiter=10),\n", " )\n", " elapsed = timeit.default_timer() - t0\n", " aqc_params_large[k] = result.x\n", @@ -909,14 +928,20 @@ "for k in range(1, time_steps_large - aqc_steps_large + 1):\n", " all_circuits_large.append(\n", " mixed_circuit(\n", - " n_large, aqc_circuits_large[aqc_steps_large], k, half_t_lg, full_t_lg\n", + " n_large,\n", + " aqc_circuits_large[aqc_steps_large],\n", + " k,\n", + " half_t_lg,\n", + " full_t_lg,\n", " )\n", " )\n", "\n", "# ── Step 3: Execute on IBM Quantum hardware ───────────────────────────────────\n", "# (replaces StatevectorEstimator)\n", "service = QiskitRuntimeService()\n", - "backend = service.least_busy(min_num_qubits=n_large, operational=True, simulator=False)\n", + "backend = service.least_busy(\n", + " min_num_qubits=n_large, operational=True, simulator=False\n", + ")\n", "print(f\"Backend: {backend.name}\")\n", "\n", "pm = generate_preset_pass_manager(optimization_level=3, backend=backend)\n", @@ -956,7 +981,9 @@ "\n", "# ── Step 4: Post-process ──────────────────────────────────────────────────────\n", "q_res, w_res = 100, 100\n", - "spectrum_large = get_dsf(n_large, Gjjc_large, dt, time_steps_large, q_res, w_res)\n", + "spectrum_large = get_dsf(\n", + " n_large, Gjjc_large, dt, time_steps_large, q_res, w_res\n", + ")\n", "spectrum_large = -(spectrum_large + spectrum_large[:, ::-1]) / 2\n", "spectrum_large = np.clip(spectrum_large, a_min=0, a_max=None)\n", "\n", @@ -997,7 +1024,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1011,7 +1038,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.13" + "version": "3" } }, "nbformat": 4, diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-0.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..d98d7bd5fe999a897725f1e5809e44d3149ad3c7 GIT binary patch literal 24787 zcma*P2VBkl-#^}^i(I5^qG2Q|DlHlcp&{)dQXwrGPJ3sSUE0w=dm9av3ZW%wN$N=2 zTT9yi=lkUP-rudq!`Mk&L^?W^_&)55!ijwS-Me7#P(a|lDmphkJt;R3w#&B0k8FB?wFsU4xCbK;_-^SDe$H;%VFI_T(Z1?cFy4Cv^@gX!qj zScPV*O5zU-P92s#KsQ7F_kM1yAKv-LN>0a`j*c0hWH$KA$>HEFyt&2Z;87dHlQw6> zPgBm|g-%dFP;`fY=#HHt8au_rg#^R}M0f@8{{_mKE-}veg1M!ksgdLV{e?VriAVUt zw*Oqg#?<_bwarO$tN;5uorl(0;ydExJL;B3HufheXXuWcw6Qv8X>-o>)CRjV6l+sU z3n9Lp0(@fIH<;MiSXqnn^PB(Y6MU8wV}7nfRXTKZ`e)@2?9*`g+)K50SlRlyaG=pb zj^1}~#}*%t4RZ26>pGWmD-2zISb6b!yA_>k6wkc8IFAkdn^>26d(8j4^ufYK4Ez3$ zTJ*Q+sm&TPL3@`je=;=vpe`tQ|L1qxi$|?bSfA+W=@A-z*XNnr9^UTA>UnbQJlwj< zSFv6uywZ6XZxAD|8}6`@7rA{D^0Idm?M6cohD{TX14YH&8c~lgNN}4*XgnLz`iw)mKR^Rb?Wr#R;%4=JHCARlA!Y7BD>qqldcoJ znOR@Fwob=3ndVK8pB?F}lC^I*?{$6k4jz4dea)n!s$t@`m7!wRHe-Wla%A2G_?L&U zT+^|!N&DhH`J$3Mulf?K~dxVJFq=Ri|<-t`v8a@S0 zMQW5>qq24B=jzn{`s=SnjEoxHACuE9sNy-yg)0}Y-j0uaxHx~YBDLI~TivFwLF^Wb z(Az$lAKUD>&aqs(eqHUUQJL_m*9*67-CEDaWN>}I9RppwSxrJ$O=1uy_r{I;a_o95 z3pw1A&Xfjrmh$Io+*rM%hiRw&_|#})O}@MP4&7%eZf+Zo6b#mw5jp#)X&cy zpK2u^i{5$qZO6M1A&Pi$v}Is$a9sM?S{@!Ag~e<5(j-Dz*9)8YusgOa(@fAP?o-*G zZd%2aJ6w5qaBxtq?5@bFHEZlkYhAv-Way&iWGV#kL}NzeD}A>dw&~9u?TYl4QXB1~ z_DUtOI^*9qBVC%Mqw6_1QsdQQ6J)*F#ikjRLU*f19=fG=Wznkb-i=CLOl)dRudeK9 z?7zBfb9MCLH9Pd4AKl~pBW*&M&hd833;Krhg>0rNW=eO3kT6dt(j17Di*ZFQ-4@T-_7XjJiiBFNHhziDl{X`CiJudgF#)X{*}UU~4ba7Hx&V z?eVzP&upHp$I?t5Bp=V@k(AV(o}SK3`lpT z_$eo-MJo)BjA&+2T352MC1YG;a;64bOKTpTlo^|tNK_0F>}t%<=hJ&0oII3+bxS5i z#H{+mlQX52M;M2Vb(}FAJQ^J{Lml@l)$5*|x$!yuZ0xBw*Q0sd*Lyy|?Zul`#gK)M zxvjaskG|~QE`I8iq4C7M{yX|EYpkU;kPzVmxYOs`_1dfJ6m24Z+bhDZg*Y!m|2bycLZO_VA9_G*W?^>Pb zFDle+{k_gOBHp(9^)L%nQ!|2>&w2^dwqGdlH&GVTF}{$ zWqk~H5ICCeIAlb^!olk+Rj)1IQXMJF%qHz7Nj)zAWWsU0+YRw7+QWlx6|a^ev((S~ zxNfX){giEfMMXtdZE6H(yneo0yp#mD+ti5m5*EP&H3^!2xZmrmcw_F0obBS6`RT=X zBHKTDNWgvCWj+H#;*oozrs1Vs_QJVCL$&$pSn^tX_j-_x>pndc(U-p>Q7c)^&@hTT zmEf5Ylh;?5nMyT=gf;gxIE@rAOOrRUu^=@c9{6W$Y%Jbsq-&jsnSY9Imao}yuY#sL z0lT3r<+1gVisP)I681{vl0%9K`HPvQCm;RjZ;UXi_qVohDOy$*yi*1X$R{;56+0y< zNY6>0FNnA7?DO2*n&jiV%)dMrqn0nX%88_WZL*kF<&m#V)z?OBNIO}u;NXD+9oRi8 zYHGeDe5IVo=_=dRSbcxrB~E!n4@b(>j z2iEZGRfq3!9)7#tl8i4By4tyONncz?PhbNG)-Yf5@0U3gbL3u3d$_aG%a<>mdL9>Q zM9D2nKKgin`JT~GQS;AHGn4Jorf#p_zI~e@@5hy(nHb3KK6!p>a;W@Ro=X-PEJWIP zgsUuZX*-3nlb^6Sgv-+{8}*tCz3oREvjVWE<4+gfrih1iRYZD~1o5YmcMzPgl^w$0 zJU6cwJ%Wsc0Q%wU%S*OjU;MS>M79RTurkBEUTw;JEYX6R-I>|wRz>0?Ql)T2FM%ZZ zh3mI&X_D0Qf}VLBrd9SfYXwOQCks5e5re9Js!63{t`4h*yz8|WeuKdhaU3)x_vSt` z(Ku40t#A6Hr|!D9w>G9}6~Zv?okvhm4I8o&us|ctMD-S%glPE}uaz@nHTN`puiw z<7U1rlrMUa?}u zEu_uO8#cW7lNbaTcuem- zY3I!A?XeMVf{Rx182a;__`KV$=V-!|=-H3&d<>tDesMN^e}(gOWt4pUXAU8wn;VOR zcb`8M_&)K3i>s^9)U>e4hZjDE2+n+E)>vvnoGi%3`K@lgetx%jG!xb`c@=z0Gxc-M zEo~JfL1xtPxsHXDvUS@#`SdAZVMh7*>5R3WC)2QP%iPqbW6C0=rOVv3la68-!yVf~ zgv(Flxzs(g>;1f={0%lKCT21JbDy@X9v9gv3F%!Cmw;2VYPWK6t-}Hq0c=-&VknPY z$=28Y4eO#Z`tW)LfcWXv(e}43ZEth3>^PpGnBMpL+KRUr`>M17d9~gxT)0qfR~sVmI^Ua8 zuHy}Zt_v)7HE6Z`Me_MA4rvl4YQHxX)WjTFzh`E0h(|r{7-3fxEWa)N(xg8ijoWOtJSD%VkJEE2Rf0RVYpZTEyzT?gK*Q6H(_2FQ*pB$Nj6cVktU zW+*$BzuT?sL4B57L_dk7f zN3^;|h*=-<<2q8gM&IQDLDyOOQ+Rq)y%p^2;e8xGu_6=X?rb8ss!FoHv8N+Sd zI2mDf9qGudG0&ApKkxa3Y)hH1udiCJY#nvlh+yfbe66wr$!+U88nT`q@@7xIK+k|Q zZrk97=Z}ob**nW8KFp9zgc7oo>*lg$%SNLt=B&Ybio;`~u;h_7 z&qU$eS`ttdCGVGJ->(N?C667hf#v^Ha5(JPNbbKWLmZ3n1-)S z)2sRNl^7qJuP-hz)*qIWE2?zk*L`;1bIJOyPmfQVeNKyi`0$}d($Srcj*i@1T!*ku zYDs*0&KH@ei=R@k4H(f%l@|*?PUVQ8NOEg$!QF-#tw$6H*rvLvwEa1d3Q$80f>hud83+5{;H8roD_kU{7M))B zIWUfOI8q_YA@6>BdO&(+NZP66f!7lkz9BU&Z|>Ho1|L7%;;u;;{&L!@-~j-A2X?90 zZRyRJx)3*}Cy35kj^V6P8jPe&Xv+ztn#T&*M!3AS#$NboxuH>cv~FwRc2jWTr7@~DA0ZT7whspWD>OX zT?3jETRX$N{7)w!*9USvF75l_7>_hIjvCqD-#-c&xf6uLhnp-y4QvMh3hy>&sHc3K zwyj>#I>?}N-JdtPb82t-V($LZ&Z<~yq+qlFqfD%Fgwkl?0gHpOva#!Kz46mX)H*`S zQ{e4F;o_Ir7#&~Qw6Jw}FXgWio05#K{aDuh)c2iX461Un%z^ImCi*0%M)PNCaAjeu zuX|VV>*;z+jhn=z@@ppe+f-fg%@-V!xXb1^;3{R^cGIZrZZtN58Ca%xH;uwKZ(8Nm zT!uzP_i$(WwY{<5)w<`fBlCsH%Tf&NUC1@sphHGd-KR=jS0&@CDATI}aPPGyigScsq&)aR}dcQ?#|Pmj0GP`0(h-!j7qKw zbxt`bXPw!)3q>WT{CL0njB}~E&;*kqXEd{-lguuQ#=H~AkfkF2^|tS z`!VV>mr#hSw>SHq1f=j-ortRPs$GpPen#6Af=Z(iTZ)>jo}Dh1(~_1zJVFFpxAWBH z9QP0UUV%!=fQ3=gmdWpKvNTro6y4|_Lb120Kw#ynRRL{g&WC0i4M%g1M;=;&a+hTG zP9>9|LD%;;uwtD92ifP1{Zo9wYjAY5w&>3004$P!R&dF=2kvHITuTGqpB|m;5qlC2Gel zh@D5)@3K%Fa#2%LOZY_6(Tf**0oatKC%?-i^iCfedlmrj-vuClzP#3_qUVuVR>>5| zpl(1=ur}`5ne=R86wVs+6?If8{vI$+)Jmt4Rhh?+T(#xpp4vJ6*>u!TS*qAieu`AO zpbomQ$E;=qa_h>ZPYGh|TOJp(t3TL(McDjvn#Slp;5M_CqC1sXH;a9dmX7Y*x6f&) zY?r$2E6MZUE|U!pQmyL(1N*Zx5(Ls5JsPZ)q8rjRVZPQg+Wgs2eX z*51sC<|!vInUMkZu`6G+eWe_W9}dl)wUc* zL0UH0)4@H{h+27z=K8Hlp+(<6mi4&VySlgxcSL%3fn>Q0;G58{m8zGFMbdFwqOZvB z`e964z~!~is8+}CFgSw^5=M~C1!{IejY5rF+508;I3W86gvRQJ2NwtMojA5tIlLMb z4arqN9W}1fme~8kwp|)~Myl1FKz?eXP9Md?-@dH{u6(3uvo~S8Kt$Ro&kJN5YAf@r>cm6bSh;$2 z%*W*8iP+tsK`IcO(vjxac3bV;ayanaN5xQ5f~KSPC0yfp+dWGx{%9b-?%~d=anx_= zt`l}Uj-?g3Dm&O^mM_Lk<$ZDL-a!a(BoIvlgZoVEl5wahbun9=w_o|Q5#|B)WIA#h z2rXT}$EpW1UTJPqPE;gYF$F2hw(jmk#4tIaN)=eCR zr`EcOlU^uuOtBC93gzYH#qIla6QYcPKKtq-!4{{42pJ~;juY@jja1m7^W*@ipIWTo zC&Cg>Fnm}>wvDc%+&nxbt~cI|k93cq#!kQ$$H6d5>svV^LrD)5eeFc-lp12}ug9b2rd2zn@`ELgjR5NIs08p|Tk(iX;fPrQe53k%tI`d4R7vQ=9$U~I*s=A>e-_}Xim=jA_#KZ?C%8&)?o?{MJoi{L?&4K)VN%fkcJ7j zYW1AU;=pG$_4bAt>2?GMuZ_gwIW+L?%`GsWkth}4;$}knKGlTWIvcTRE4JR;DC4;n>rM!z?kxn$NUZp`h;F7y$20lLegJ=o zfH$@LIX=EF`f!kFxXYk?Gm3;mfF@5R%U_n|jd$@zVl^BJ;L&76nN(0%Shx*9y5jL^ z*=GHj@u2g-B*OK^q84t~v31s}s;ZJZU1Diz83|SD5XhRFU`?pIoqwFWompNS-0V)a zRWlMd4ix-1ygwX!~K14QEWZ6`C>8RxSP^)wF1;9p)IzlMP04PFh718 z=_cg%;fOC{W#^Nh4NaE!NSO(v@#hint}+!zLJ5Ab9I#{Z>_wi!UefpjM}Y{ z)B9@2@SH%`JN4YBY&Uarb02TtlsoXL*KVkRk!43`8SnQuYxLJ5ne0N%cxvU2W7Q^g zPof_K@to^-$IKssjzmUb^X}cB8~`hCqINObo#Cn^t&9LDh{$A0Xq1JFjKb^=U;k=` z0Havtc4*=R>b44K2L+8N=2#gSnAwFr8CgzMCu)~(Q+;^3sk{3uX!185^_i*X0j{@4 zc!5U+odO~#_EI18@o{O%#q2Cj_zDF#0FOY8XmbB5fRHTy2j<< zH7_qQ47DVPz9Z0U0fP3s^nlG>`q<7KnMbelPb<~4UF=NRqFZsfuZ)_1LvkN(&!*Xa zRd)Bu;?nxiFwU*qeP3l26csteXcv!aP|)~Pdida=Bjszael>n;+1Im`97~zipT)IL z{E>vS}|#hgx4)tIq1+v=@&W zR;Cra417EcS^HYaZ+IM_y=YlGh_wow<>R?@wlV8v9r@J_zrGO4bzAE-V{w+uoX-o{ zhSTFm_Ro0}+DBI0>?G4(UYIe(sx!sP*T$8ZWqN$=A$R8U>o3D%-*wrKi|uwCi~^vD zMlLC8Y}6-;1(5t%`=j{i-n`a30hf^R2v<#tUDk zYUf#x>gmM5z(D+JeAI!)8p-_oFpFIg+FmlTRn z0;o2b5xdVnym;|q1Iq2IR4;s=uE9=nFk=&zIOyUIRA~X6w)`^ zf%vzTzU}S3bsxU-T|-Zg;t*nerO`@NtZ0dM601M2wvs*7Ry)BKNU-|x>B36tm)crw ztPa{;($zI%aG*YPf#`|SrVm!iKf9OzAGCF~= zAHm1Y0=wLmuuo}wA9i+j1h@Fom$%-@TqSbulL`_}4IpwHzvdC06vz6y zurT&mihh1L*KKGPM0i22?z2VthgVXsdJfE#&rEtN1o0(r4R?6erykNiXzSGy%}`#l zHKJYmUhQiV-AYDH&LNyV(`#r%K)DlYQ$XTMyn+vjGLJ?INQ^7;xH#Zu*1SJw^P|@{ zl?P`gIu)Lq*)PlhGb%sg0F4617ncNEBy)8NCb!ICZEltr>7>my1H6ZhmrDXAQBJ(pI8cPx4zrY zNfJVlJwBwqg`txh?>>M2+-7{ZQ==Pxgk&&;F?G|xrdrV30DpV*+9_F_@`My^D)7=w zH`B~v-lIJ@x@Q-D=KF4@*n;XUiO^Ft^4(lf&%e(l>^J5UvXSCbS3vSK%SNd;uU|g{ z#g$DYsO#6R$y@VQ^+T-ClIr}sxkg$zlxpxfXyiM@JtAym!JRQWNyL0NrY zCrF+wP?h^j)(Ojj990<20{v?^{(1i5)t}hh{#^~Mh`ENrB8$}iQnfPU#24rU57HuS zAZ7QHT?s07^@rZi4eL)NIQISdZYYyiDA&jmfevdQUfP&HTA8`Zk9`Hr_HA1 zb;b1_sqFgovCR1Wf0NB=Ps8%r=lS;?>)nb;tOCbWQ&i?8E86{^XxbIW+OlX)aCnd3 zeQk2^xBPQDoc{OU6=$Q|wYk!mWVd+H+-EFk5-{gFZ6x=e?YH;G3QuX(7l|oxkP*2y zn?~Q791OoP=h5CW7XSW^Bt!TOnu9Fxq0E!^ZyB4&5Bv&dWlaK)Wdt)Z!!vhlg)4rsIW^!MP5bnQ!Ye@;BpH{tUbsDjqhI zA90BCkh<}!=&X0`u%j5;pkO@3;6wWc?GE@05q19!mq(IVpJC*#%W5$}2<>N|5j_*H z8tF+rNhWXXZlM+v&}THbqrn;a9W9R^U{P#X|E|Y+Z|eqo$scR%L7-@WEYB$*zq*Lg z`v}e762Pyohxkb(S?mcgKG8Orxo%V0h+KVctQ;Jc_CN9QBDw&QQ(T$Awk2V4o1mV) zyT>^La_K|Fk8Z%cP77&Nh%f_X1tDGMFq6A_*6U!{dLQgUpL=ccaqU~{cWD9j61KP# z1`4^SQymqNA~qc=qs>2mIxPPi-(Wrnh~sET`L6xu`YLr?Wu!`3I(p(cd>SsUi{CP4 z<1-#QNXQTKvnj3D-KNKkQB=O~Q^ET_hp&XHZHz65deaw~lk3>hxnA^KFtODUOGIhl z4yUgd7+P9eqh&cfMU8~A(#?jtRZ|!DaXEF%faCpaeN3FzmLk9f>c7I z;vlA1f`3}IeECBZmz|((>>@r&(oCct^Ui{cAoem)E3r9!*@q!CtHMEpGV8fbrv5Xl z2h*@S@NC+&pE%Bljx1jKW;P$fCY)ApQ#ic+VUY@rlBKmz0(sCb~lUGzdB#@H8>Kps_WH#0ah=9^C(D z*JqAg?)qBDL>`3$l--IaIJpG`1ZsTsC|{eKBgt5IDTY>N?G_Yl<{3Skni~V&nuHaS zwW+Z}%Cv+C0EVd@>8;mBhE;)QNZ57UW(y~091y;56eRRGkRBjeA99)wwiFXheD#iF zQ7~V;dGkiz7dG02hX*ZZ>X~V2+JHN@fP@DrhPrc^Fn@|W|41T&(z9o~Vd)~*?o%ou zMyIN=nO*ho!uK49F|zARu5*IjyN)UY24Aw}SDGNtSHkO6>1qMWGoHN=-e0zqcsa5! z47mB__1ac4t-Z<<)Zs%6-v5c-VN9bge;cLU3XPnTf~k@m7g)?Ux6h3Q;lkyAsm=YM z7+YJJ^$UZ8Su(WmAKvL7|65YJ#q@g)Yddqw%ka-gL&DkIZOk7lqsLVyYoL`gfBu}r zd`s&0Nbr{A#ksLT0I}!NpRwo9?5!Z!Jx^LY&)RE<;FEuchD0?%Q;m(}MkVto0;ZLm za8BFMd2>NR(F^MaSpk-@|5UA_BAXuC(nbxI+w2cEJf<%C2{_NIf^;|^R~Zu*hj zR*?jI5ZS*Q+zFDhJft zLaHtH&1Ewp%m1hy*=CXJ+&xm!zM&m%gOxz)#1aRJZxIvI`>G%DwA9Sr1C&BQ3lTIx z%_7+(fSrZo$e(B=uzZ|Fh2;2zpEfW@dCr8>KMkBTL~>ZPWJwK(=T*=ozy=eg9opBW z3=3+)`R2EsaJ!k+ri6igyU*c1xl?UzRK$K?{zRyS=bX4|}^$Zm#|H%U?ww z0iR%v?I;@uZo>KyRQ@sB5OFyAowdP7-$tAMFDDR;(XsFW@=4+yN^H56D^^5;$u4Q7bf(wpmHN5PHfUsCxP19RwXMA_S%Mds7A5^_@s7&eE zTMhly=0}eX==Q@WvTg2gA}_-sEdxuRT?8+FcZ2@DU6$d*;RMMVy2Fmb-j>~2B$*N4 zM643q)KtHFZSc<1#OE|R1nwwfa%zg!7g4?n-chxL^i%xQ-Ljy>l!EGi zK5Eu#LwO43Nl0dkKnp-oXs7}il2 zYyj%;W|N{Cya{Rr1#+2yOL)Ts6gFJQMOOES*aZzT;do{WwVmWZ_REe;gGzwbX)yCp z;dFxD6HF8*2pBE6Vpu-hQ{C8L>%?v1bosQi>lrzubhT6UG{LLQKHm%T__MVseTxS% z?TVwB|CXr1`eyw+pOvabya_Z35nhF45``_@C+=}}f_wOwW?D529~+^| zu3x>Xf)*NT`$}?muiuR=9ITgQu>ay1>l{~!B~}UyioK}@`!O~L^)Pl}cn^P}E7Qj$ zok%ZsCpiF~3aoujd91IGsDH4F)`^~rLvSdrudna3CV7VWRGUxanEAFUqAyMLgK#v% zsC>?`Pd#<&)G+jzMXcgMV%}sOJ69x0@SA(2#lIm3qh$G?g2sYGSxa&F&&BK}MFUDnCxzKd^w%VD&ba4}*;5sivrS)2^=} z9{Wd6!oKg_0AsOOc>4x1F&(1CqK=M&fWEDuH@F>FrwcbjuM*kAXfujLRy+#^5JtdU zqCmk&6W|HtOyVk@!Ub(Q_HlV5-OI!m-1!__=saxEOK^sCN6gpLGTliBs!3N zoL>AA+B9iV!OWnSgm?RPMfgR_hWxPpJSJyRMQ=|qY*FK*{i$wK;v96>x*_LJ+S>)z=5z8Wa%`0o6W^ z{1wVRL6u|;wT}OYVco)jh^T>>3~|D+M81gkWG;uA!JSujUMCYu^X6~fDe-9B1HkN| zZF{BThwJS*-;N7#Dc!uG`~-MTS8qC*fHsX9E`stFDNC9V<;*4R33X#I-$2)@vWZW9 z+bY`y7{wS1(lWMib8>RljAJ`ThtPlh-%3`SdhZ)I4%<(lqEf#d3m{6`%JdvtR}q<* z#7g9&5%_Epp?P-IJ&i>eiZIR;#%L17nMeEmj6M&Bupyin&CMLj^R<>(?1FCrMOaR@ zeZNJQ8+LUXf`appp2yt{_~=(Vqi54c-bKTJ}BP=iz~>FGrB zJpembHL6^0`SFojeG!=Wh?hAg%#T%*385#3bOG`||9%nua}VG&FcdG}7a`@UD1l4S zHR!Q=9%l06VW=~=@A&Yb3j*{yVUznXGMZwgBY#?X>s2EHYsRVUTd`HipOaJ`?PixngPJGtHY6XbS0pGPA^CSnpIftCaSz^p2aw~(z#Sc_(%7r_sjR$;WoDwsP5i%?vsxZRfc&_%XE`P zAW4Xb7o?MjU;)(ZRV(OQg~g7-aoBl*0I2yjxP#akH29EZgrSTA=1RnVCHWhYU`pC#nnBhL>yXO;&F2p^5+Gn=Ky?XVESdmch-OG;HzJ&qs z+@F&qUr?ZZg*r6|rRvP2=*(Qk+->bK6BONYAK`=eo`|@vo!aLXx(cJY%c9}Y#BLIH z>MPL*kpS)j`pF?*VYBLOnyGpxnwpxBG3~${_cZjBniqFL3 z*^Xxb%9<=|WBBED;ZoHJ@8K;CxP-~bDJL*d<*Wa89W~@t(y`3R&Bv#N?&ZGr&6_qM zLB5o%(+;H3e0#$mP<(d4omU~z|Ge3)r@ehE=`=VUTNNJ_6(w1>hQ>60ed)=}k%GbK zytV6#+~^poB1l)SpX<(l*5P7FZzLJ&)PRRwVI3mfSHqY}f@RGd1Mon4>P6Vas+iM*<_n!u95@B*ul-Txe$ zPGW6H0$N5%>dS3zEGCA%f9cR|R@36Y?9pvq)2yxMNF?cxh##~{iO$bZOl%u`{lwzp z=mE3vI6654P{kD$$(4?RP4eC>yF~fRF#9j@a5x~<*gl!hSFqK9B=K@$n~hS#HQhsgi9oiIs9HQ!-a_s#;r zI#%Wtaxu8KQnJ*j;xg0PP$b|+cH1~`7&wL&5;5Bv6t`H&a{lU1b~o8F7Ocr73sG_Y3l%8 z0!ry8HWDGes+I)qNJO}mfAHWz{6~<*Ic)TAHK z&2%5qX*WVoCFBnq%y+y=#Y57zi~)@3cC|Xb48Ll%9#Eu$$ks?Os7#In3BwF~G(7DH zjYK>P!sIxFo)j{!D5SDsWg?}pd?jH!5GQA*8fR*rmP_5+Ix#DNy|{!HKrPGMkw8?? zX=h4TlQcjYfl1=SPFGL>zo@&W00@FPbz7z$5j* zk3K4|SHYdw|6Cw!_xb%;xj~$OgvU`&IKfXjB)N0xtgiCDb(|LExqv~Dw)+a9B9rp( z$bVuCV*#n{V8+@a57$wZ^z;BTn%X&Q>`2ohCHEJ*Qz}4EgG5AUeWqnXVXo7Npt(M6 zj6E3cNxSEr`9*!C2XCx9z4I6u%>RgozZ0O_Wh3al=ZG7DLX41w#w^3>c|m!-I4?^t zhSG+qKtn#|;=ufEy03_oUomidIYC|b8{LQ)sCb=w?VGv|3XQFon*M@6-TJVQDEiH3 z21onp<+CYbdP6--^D=+2@-OIFihX(Oo@d-SJ-aykn<&LrA=bz5=)gEJKeBBJ?)hur ztUu=%-wI1!!9?o3Ig0Lf+13}Q=L*j^TMSu>+jN_D{jUCQZ>LN>4z3ZU-289y7w?Ab zKDI32Qp5c@v^GnMAq$r#(>t@w`*Z$K%0i@YYz%0?WK93tJ~W4t7Sn!mZHQF`-kCW% zQfMiZ;^2*9+H=2ti1Os7q2D21!QX|kU-t*&&m1Gw_CiSp_PH#!(KB5^#jf>#QsB4I zq%h~B+l_;diU~l8T`-p_uedHbo9B{RDIuRWhO}(hHA}YrQpE#LZ&RPUPPBx4{myXS zgG=ZSK|8ec%$KWX;zO$E5+Cil!QRKwc<)o9+=dSik2Wjobsw(WrftP#ei9A13H7W%q z|G*G$0QqOiE9eO?mp{mZ>Chm%^nK{e()Y~!p`Gnv|D~N7<$&BJ0#rx_O3Mejg)4Bv z2tn(_@Rfbu;rgtO_F`x)pUj~rIsx=DzBW)5<}a9@Ir!~n!UED=4vtaC{3%>SP}7p$ zhl=@`O@SLCJzxPlj*C{+LI%_!PIVlX5Xg6e2Y%nG_vRKfhIB*YKa7lu0j!2mV7$Q{ zRPV^V0XZLZW(+_Ftjj|DiW{&ca7|ACxgKz+l zBR6npMI45->tpgg)b8hK?!6-VLr+Sp-!Q_xrU7Q4I^W%$H0d?E43ReKC^Xo=-lJ9l z1Fa?`3-Xt7p`9k6#g{K%PCCW6;hN{qpU32=Q=T{u?QHRs*qco}wCXX!e%g%}g(JE1G6<|K8ZB+22JvDH0}`*vUw znphBAW3jJkAmGvkG&asmPaT7F?OCsgmVR`p^tGloeAksf`W2dbHf!R^@|SzexP#C=#GAnfqnfSd#X2}cDfJf^R?=o>f^=02)#c{MbOy%wwPp|hJRyp5`>aQD>hZFTF9>q=k z+e;^&7+#}U4e7=LVK1@B955i1o~`G}Z;}iPXtqgSf*)*|xe;63b ztXSH>CZDPsh*`0Lw4J zV3L%C9)$wFOIV6M$-~NVlZyLa|3^?M%G0&U+kQ*4o~1rbg7M`vXXY==!K*_ND;rzZ zuaGg(VPV;zMHsMugUi zSN{4ZYXwaG=l&r!kbfb5I-9ROwdF3B={zshaRpKCx))UXIQ65PJQelCh}*I)wN zTrqbUkc&DRwi=)tq6;n4I531CJvmSs>e!ZJtbO`nmhwSe`2D*TTHQ)#wedp6pwjAD zjhisVY!Y^95=4m!_Nc!u8H62<|E4=yj-XaYByT9q)T!N4QeXOf$WQ)NaORsz3^A48 z;pbrh4W)r#;*1k89!qfI?_V?g_#NjK877hyG?LE2Jn#NUU0+ zEcpN=xnXCz=gBx!e(cg-K}Z~=eHFHvSk#*GzMf2M3HT4wo==bMyda`^%u9e}Q{3vS z2kE{>fHlL|kyDqR41b0d6z95qa$T6&0{x%J3!eLwVYBm?ERqvdoJcnQXmXIqGWhXy z95N$f@?o#PY7dCfeRF-HCM&^$q-oFKOWq10Hx#qkZs5@X}BwJzH>5iE6^ z5+f%%wiKWUqQWTuZVNf9hEV;mEXSi^(2nEn4ooY)LN^vvD$oMYpHF3I&Yb>AFGBG z^RWS!0b{;;wt0gpA)j#y8vu+4jrvVAa;PKkO3gT`7~I||DuK*8MoZi5R)?<#k8YO*Cw?*&g?rn;JC%b z#j8XUHR2zFBJ4t$9sjWrQtTQ&-J_1=*JNZrZ$=c61f0IKn&(w|l$8gb!T-RwdxAPMjE{n4W^J#PPU8IDChXaRpIgIP-&545P^^eN|2xtr7Kd#x3Pwg*~LV|wtwjO(O z&6VD_SL#_k>zrh=qfWp-sopaD(nXIsfh+J_aP2M+M<$BboVWk%9r-h!>2m!Lvr^st zyPc0D*k4{jm6+eWg6Yyc3`SHf!_f-rm$~8WPn(ga;K*;rBN^Y)*BN)L=M0U=`0ozp zbwhu=^JmWg!>M#A;&;!XH5uT8O&fkoYk%Bmy5WlU%>s%1GW+iE`_VU-Q!1gt^fJA% zxjj!!+?sPMak!-DWt~E{mGdt}CT>!gq~c{6vCEEBR5 z@6H=MHnVr%nDpE2Oa&{XcV^jqd;QOq%a=c~k*L*6LGH^x}otC z+$ad(v)x2+I`bHUuOIz?^;_LYVMM0^FDK`LLT?UjG{RD2>9Sr=gyesBYvX?&F}Aor z))D>fcmTvMN3pQ*sd&@7emIP(4g4kLw*n)a;`dRB{+SiPyU(tT$ z?&fXViu#sTejgfY_R3)x3Kb@K$0K=`rt+m%a^yi$VF4hgyOe@^l&k{}c~PUeK)r5buCiim zfIx&1WQ&AD4gw?2a!md=1E&3 zCV;-|GWZJN{-{Qrr8Rz|agX%m^)fBl_5qNKS=gfCC@h%OxcnBJNk`=Vb&?K`5TMT3 zI}}|3OPqk(jNBDbD{>0B%S zK9}E{&4h@ym409!zUH#$<_#YrMG1Ub!9LiqmP&0;t@7lx7E z#(ZKF%8*#u@&O0GiWn9xg?B^?l8~L(C0)YG!jh`zI-)7BhDS?tpK*iE;??q16jC;a zDUt(G$%ywJq&l%J!m=ybztv!~?P9Z-#PL1qX!9gpSMPgtE);NvG3x5A04Vqx*_o;csExRp}Jwoc_f zI^O8fWu*yWflxz4Uc*5sY|86!>7JSK1Z0mHd9AnXVE5>pr(z?(3h`2P_#Tv%o*rU7-{yF z=7H0IJP}|-FVkW%D;&m~`}5lk9HAKxswNV3cQ=*-=@M#fZa!`Au=m2jUvy|WDXTnI z(l8DkCk>p?asLXPvv2;}M?3pw)c+iFyzMHc2VU#p%>1b%hysH{L+XeltClT$ux#_8 z4qVJJJ0HCmI9kNeIj|RE6>PIGHGXz2fp+?L@n0VES^-(jDxP00z zZUp?0@c>BzN@shHOqm8kFDsK5OlsI&bUxlIpFpyHRD#}Ng4W21S1`uek@c%Bfm&@kK5T^huimwb+zMdJ{I^(WWXEp9P=Yg24p=Lv z1~cq1up^NJeK-;G6v^>*<^wonED_<39Ck*HWujBri%#QhOWnp=X=m~Jl5;P>dTuW; zCyYKhFc+sP5TVoA6*Gt@0Cnlp*Zrh2^DFU`!4L#U#|h1e9FT#-gObQGvPSj8jrBlZbWKQ>vBbJK{0i|}Rz0xed% zDQpE~fRL`j&^`hJi82!mwLhEmwn7h;hwH5*?UqE}GZ`4>YPLqWJVfHy^YiN^Vmz7{ z16cm-n(!B0=1we)`L94yagvkHaM(%abX6^=IQdE_{Wjo*Bw2Qv;7-VFqR;UGoKNzV zgyADJBeA1FKTC#pRG>-}t?4lc4@4P*q2L3S0880IIv-<@(R(jg!7nMVhCYKQX;WqO z(a%Ns;d8GK!(;%P3j-o!AY2jGNK*_ob`hP52h#LjamE6x841{yl|M7$?41J#4%{7q zfkzeLumygJ^Ua5HnAv7OyKN~BHRhHVhfhB+LmKgHqA|0J!ABFpCDY|L5a|mgtoucm z5eg3b;sl>$Nbn6fO-;g1&KG^Rf>WyQLP4bg-McMQKm{6zka5|MB++Ukjw775>_BX- zGG9{g0ng1ZPXyP{_tMiE@WILvNiejpTg`J#8N`2CK^ML=G0h~nx+Y)|t|j~70ipvr zr(=seIb9ON7ub|BGhUlN43e?9uuyjMp_^8zsYL4T{O~}=RPXd!PfX+u#nV6Gks=?8 z)^W#)oaBTS6n5l5lFET7P9B~3izu5l$#dQO)sl*?byYa>$kAOI<)jiKhmrYgl;M;| z+&Ut1g957;Cpl@S7G3<*Za-hz+0H-{LRC{Zuo#Y_sJq{LfOpmj7^ ztZ=0%wGbqWg+Mu;2qz;PC01f$qeAxyIj@FvN??cDA~GX&YoZn==cC{l!G~}O#5lR) zPH=9hHbzpHd=#LIU?OUcJvsVB#*?vPz2);eP1881lBUz47&Ak&w)65dkg{>aGA3qi z6zJXhl7XWdM^;4>#D$WSoJ5TC`dYyCrcG$j(^;sK;qb@!o568;3)0$1AaE#4f9a$T$p{9+Rj^ zG9?;WBXM<86tVGb($4}gXdMW}1kMcOR4HOl^o_y?2+*XwJ1HQ%fUW~0N}h(O^nf|0 z*iqmq(j~Uz#Das6IDT3eRU#b5k@O0SW+M9@rw?^&V1oc#=W#Do+*W~@gds8FnaHNk zk(o#LLU1;abI#)0|JPyk$Om-GY1P#KkrsTXndRl(rQgpt#?x3;jdw=lbZ!O_Up&dkb^{rU~o>%7btOzrKh z?f6(&9{%SQ*R5<#Sm-2rG+=2k(qgw%oWCs%J2|VUem=gs)qXkZ>Fb+fL^3B;{Z+hg zVi=ejv1k|X-TfMrqKAF7OZ>fp{S{jOw~1*|@86zO5+kU+Ag6HQWH%wMxD?jO%LEsU zmbVXHwX(JHHVw7PEz7PS{ERZ0o|WYYxG?EVp}&bPNZIdCOko`3J!laAr#<&9+3$C~fWJmFh&M6M^#{<~79 z`U|Yu5{HGiX6NW+BgZyZNSq$oXWx#vo^bEe1LwH}-&32r2mJ+R(LQ%#`Ht;9(po89 zsqjuQyIX8)^uB^63~#Y@_x&Zwmp6Mj3e}_7j1)dSP#yBvT_WeUJP&_xXR3#sN;htc zPSeOw>CGI!xKc*RVfv~!^M3zAZsp78#Po>|dNZ8o(^FYJ_MACPJKsu;_R#Q)iGME~ z^{9D@Lu}or?Sw9+lcOzj!+CSQcdq~arRE5hpw(4t`{f~u=g*(3S=|Ya`adx~t-6LypKvF+LTLf4Re|1eLzbo=k!$Cd^Q8zOHQjM?*L>rgT3KgrTL!gx29 z&tcW`aLW_pm6gT(hR@-YW}#)>ZI<$<(jj#Et&umJx2GfabJiFcY21GhUe_)$+s_x!iW#z#a%wA#wv z@fL2ouHr!LTcxLPb0~xI;tIcUEBTN^pZ2f4jSic`{VmOM%Cw{UCPJ7m*_!G*pH@=j zVmd25JuhFrTxD4}`7T1|gRANbaed*Uv?+d<^~;t;GzvtqhNSbf(s_Nd z8l}!u%YITbUX__!;Xm0BgpGl)I40M#I-i*<<7u_@?GuD5zVKdNCbLyzL){Cq8@5wY zD%tl)@qDr6Vz}xO#a{@_^VrW3)CW*_Yg!f`;~uic77-P->5=0ek1~m?hPMcYckF&+ zXJR_tA+*a3i}^S&kF~b0ZX9A38q?Rw_EDVP?{Zw~A8w1`o_xu_eDm2UQmw(*(f*M=pC%Mh@hsF1!G_pBhKc01iW@9}Yr(s!cee>*ekgp?SQB&eFCHc;<|9ne&H+bjT<+tdCsS46|)^|cX&?B#(S!L z)$H6>$v2j3jp4?}C}gT#>)X{4rrz?U@wnL$CrC&^@w~HB0gfF8HY8%Ct8I6mnEsAl zmDdr!moI(VjO_+f)iSh8xxRfg^M4c9HQzStfw97K3YqKI!DqfqYZaE3ep9pmw6n*P9+#Lyu7Mez>LD}$I>8KLl8|w!D)$(-i1+=nXc+q2r#OodBL7g`r_04 zyt}-!Ma5xCa2%id42E35Id70Nl>W+MWT-ozuz_SszMD?Q*} zad`MB?Hs%3Oe;meInL%!qm1e~0lUkk9ZMUNJMIy0-UM)ux)I}^=0XNeT`*V^5@GIcA3mP=QJ-1gQQ?v~gyNCc2S_SoMUhcrm~rb_gGy-x_wJQOmyfjDNYP z=F=ja!?kf=nnXClb6?Vl?X??%gb)0hLg)?lcQzs5v7dN*3yzdpjaKxRKjL04S-7rM z;YJbfvBR)jwsB`~wFV#M`B$;Afsaz^Duy}DI-NCiQLii)+a!1h!~B%cE# zta(?eJdH|@76t5T16-4DQ4tS^KZ9&P*DWP<^O6UIw1Nut=}a0fpUj*UTgvh>_gF*~*E+{N?!j#-_v&DGu~ zx{B>gl9Q9)y6^s+>q*6DV`qQww4x&$&4D8?xJeStZS^wvlH~oJAKy*CW>LT&uphb& zTbTvoCm-*wRMNz||D=FC=IeR5J9-iar#hO`e09tl|Ndx&dyX)d%KFd2&E1b8&rV^y z@=ZGKL*^}7Dj4iclEhcZx=UDjc)(w=GtcC<(Z-F|(6W3}t!B0df{N8?S!?mzr_&Ih z_T{6Wb{~v?em2*aOLHFY#Lmy97tLWzlY>^3buU;d{CYFh4Teh`sGSNA_cr8f8yYS_ zY##3PRa#FslRowJ-Tio&{kku>v|zunCtH(SHj?$oLSOFIJf7YC`?MuaD|j(&J{9h} zs68jD70U5mivArr8(X z|3OSA9~WRbTrv(3Sr7Xj1TjKJK|wLsn@M&Y_uSKw@<*41gs7R+vZ|n@DL@SkpyY1< zIQgnUDn<|>Kx-^N8A`0b)+V(bv^>w}IPLr}gO!^EJRq8SCw4X0bN@8N<=u~_glbuL zAHxzSL3~hGZp9z&oq*MAh;KB;^o!A5Wp6-I2A+bQNR#D`gaNw+?h+l^154S89VsF^I$s_vTCBs#*F1O#59)I z+;C}OV{@}@m?xaWZiio!LBd1fE$lWEVn=SetvAtIPE+wal3>Jke=gNQP12q|eU_O3 zBL-EWwtQ=Z$=23ZOE^Zrx=2F4ynsJ4=hKcBn z<(>VjIXc9c+J}Y1YGb=Rv3C?p9Umr`MfVrkBxP##IjpUC9u9sQ&6#c~=ChlTEu4nh z!hrGPUn%R!*7{1_7R4@!A+VciU2`7It=N&l5F|+iuKyZ%cABg%)jn?2xBNLMskeE-&^@zQb39J2@t*I^C(%47< zpKvxfIM}i;&w_^RV-UvgB^7^380pUq3GtuQ-Y4*32m0R|yxT2-0Q>yi-gU7QYR>Zz zdij!O`FNpgkl!u|nt|JIx&U=x&>)8ejYqIrY{}Wqa!_P^+>QMiC@| zlx}md=Muy(0XZHU1NkVk%6%0MBL!CNd=xwft-=0G7QaO#dqz+Ok$@Q?BbzfHA z>XqXjp0bHOL&Zk|V86znl*t+rK>VoaSBX$2bv!)Zq^i+JSqPWe&jM832#ol57e= z)PkL#%+=2exseO+t$H`CRIGkJZMlKRsG5ON)#T@Ar+J)L-!`nfG-O@w#V3nf!+q#*qoAdo2j9zF)5nw^IRs%D6 zZ_+^x7_>ByP{3t9*}gpIFr&vfKLJivk^T4A4Pqb4jw`A5eJZdVJ_TqKBJXUGg?`^K zC93uitUjK5lQf7VlsGQ=*l8OF~g&!8BwCRN^z#vi+g_KiU(> z^>!btIubwXIolqKw&lH94_$IfN{PdW&1TSenO!^D!m_nrAJ&RFAAGq9$&=$K@FO@H0xya9@dl<#gy@?*l)p;;d=RfgH{f z0JmG?gDVP!4^_1!z>wQ`xUYk8Z#R_+t?v%N{k)66RB^SLi&A|sf=NB+Ex?`b&=|lR z27vbZi|tYyw#mrIX5YJwv;}X>c0Af+Uct{Wx2hoA_K)2rx{!OZ6j<1BGmXbD{WH`8 zIIvi2&V(0Hi%}-$)f!NBwr773B_}3yf6*y{*fF< zLwcx-aIusb9fSN;Ba1XzRgrQBu1xKFGa;2ky` z0?}gIX)XM)Z=cK~25q=)g{J8*T@o!`D*ASW57-bJ8`}`yhD6XVeE7z&=g9n*^pNkd z+hvYd1O;B8l}E;SY~TQpPupaH&nEltk>UOpU&|; zSyx*-hNzT5kf53#m5b9b6o84fd_YbJSJVPG$+Ml7aa*e+tLi-(0X&v)YvfU``a+a$ z%%b_DhboE%1FP$N<&L~oTOrKyLRMJsNxLFdY~Qo%Vok}hmL9a50Qg#~C6?Fwnx#Q5 z3=Q`7|h{C&EL@;;nInxJ|Zr8X$5Zt6b82up`?}A z(Sj*=g8I5TeJIO9xiQTxER_Mk_$`Ktx(tX00sPF}2yGeMNWb7R7!e*$x9_4OvAaoy zmDCYH4uZv~&{U>QxodxgJHN;Nrg~8OUT)>V{JoS5E>s7=X{0@`4>mj#R99_a${mUk z7Ft(MlE6h!rX*)FLf4}jz{?9n6HtWL`IBmko>5)59C{=8NNs1MK9JI&D^a|$sp*!I z5>dtW3}xB&OiYe+4V=aev;A__{(aBv3Df-3k7CbCjNB+an4t`2;V~AfqT;hZsq40O z41njsT99YaJ~K1(8SLX{s&ceTSD~~UR6jXp+Mk!ufxEp@d5CxMXo>yz2^%N<$@;+X zMPJ|#7nzt^NTp}+7pQ?_!4`}IplitQ5PH!P!GaD|PW<4~PZ41pR+eJXue=fB*9so= zp2Dmy6^@?0>on4D&|5;`zOokzITjR;+JpVwce>Is(+H?RT9%YNK%%i=7bZ z$I5#jO^;}8oY?yGl1BLDsK+kuC-XkM{s0H7DO}apv5zvtkFj-l@SCc6OsoU*O}i8aX4^qqUHz)X5pz0I3r&89BRgfVoa1R2kK=3e)an9Ba-5 zM&at}YSW$+T;O7UXxT+hy6tcF9s6o^mi?Rm=Z^y;%ZCEM*lwDdUM+YyNEi5`t<>YR zOzj#hZwtSVn6aLTkk>w>^trFulyKZb<=0wTULRH-?h2#SI9s}2#3w|m?t5Kp_wg2- z3%$ku_u-2#Agdk0NW47%-KLNcP>(~yyR<%cK;PZD6&oXm-%fsRY?OM#YbR0Sb_=Ni z5W`eEi6<2Xt%m?g3Pjy6nOce^}3=MCn|ICEte-E`W|c+C4R|I8x#jPV&Hb)tayz?FVOJ3zP+_j)KrTGJvY1$GznyI*SRcl3(-;<;$i)3~i3fvWTrw3D;W>YSB!_knbD z^H+V~5_tzwnqNRbt-SF5)LMRW^5yT=1eZ2ru2>y<{^*jlTv`ghrnw5I*;Q3i|J&l; z&q`S-sgpaK3%(%YUATA=kPIkCpMlCL7Fud6S9CS<8&|Y9Tr4^3J8;ws@KGr>UMQ4x zIEVTRU$apKTy*4*^E_}V6c{##x^}W~*pZUUa_FRQ&3I1_)`m*D(lJD*EB4lJf3z4N zf{5ks?(SZN@SlX6Zm_D{S6kdo0~&&a$<=S>xe0Lge>DgnJVxxU_Bk=Iv07z$!Dql> zNw-Vn;{+%G$_PR__JUQq$iYFv@3?pqO4)MAJ|I3OJ=$7E923DJSgNXWb{tH4KHhaHpkchXtwbB431kM$HAGw~D zAn^WQ5JNYtMg))q00sLr!VM6M=XtC#h{?@##IN++T?VOV3<#|_4W%ZN8;pN8rFaW)`;Q@K1H$)fI@MQLeRy4OzXB?W&Ul;w*LVnaf_Ve5|PRRAg++)O1d;+qxOV2VeFqnS($l$R(O;$L{uvq*J zST?Hcpk7}=aCULHlnj!cB#;1B5NojdIDwmjCK}20@Ep|B+4((TVD5MGjd2e);t$^f zsxSJU5@TJ1%Uu-bLU8Wf{EjG_aCAxn94w?jBdS!$k%5@>O8FKwiU&T2`3nL9=V9?` zAa+1-Gn3&9FGPBptXXgd6tDGpef?)<`G-FXEA^o;6oJ^( zRsP87sgF-0Fjyec5$o>jYzv@j9NyoUX)_%z;e2_X_X#kdMA;}dkj7qi*qLJVAd#ls zeV?elBoN$})n0%3Q(4)Hxh~vXB1p4HESh*mrb7S<-1WRT_*@*!gzn)^gl*IwTZd6p zIoWkB0?;j!k#3LZFC2gg5R{1q1_rv%jPBWbZalI|a&QN69DP)d#R^~qe<%SjfGCo< z4hK%P=HB}xbB3Jt=9gSuU8oT{0N?L$JoqAo634`k?>*GJ)^nW+=wd!w7M4!e&qiE| zZ}@KSk3&r77a2)TNJKS)26}(>|9Q^5aU!~#hdJI5ONJKG+ z#9dX-c>|4%B#5lQ@vYH3eQ#I_?~|ub69fC47r)gEL`t;eeVxzH@!9w|f^SnxM+(m{UNI#ET`@xZa z@fiDrfBB;=*K!(R@f;C*zb05i;;4%G(|5q5-Um7jEi z9%MSGujs@9;h~oZJooIPs812KmkB9e{zcRg1Rl-7tnuL}Bs0b98$WvF4FEs%=bHp& zF2d<1L()B5s7Ar^8;mAKyU%8QN*c~)9I+I17_Yv?xoAE9`55$EdRb`Y0Qx^!T(nRw zT-iB@t{De;d$oA^nr6XUXbxH$fo5hWDAvii*h)4A>Y(5A=kHxP0bKaW+Cjl7Og*7F z4*4#PR1+^fwe_|ki00?7>y*u@ae)v8I%oB437lp^QqpO)v!tZYpaq6BX-H0WMOz2H zvD;Wvg2rWnt`|;LtL5S;HoY4lsf!!+Gjl9W#H%YbaqKAJ?4@G3He8#Icb9o4C-a^3SX}oJ`?{Co=mzZaue@WLX z=Ik;$*cNb_@BZY=F%TS~&*BsoW1~J24}`_5Ecd|^f`AKw&})sSnENQ&YoqQEzQnb% zpkV(k%=2o0*-C3tn$Hx)_m9|K$;8(z{Q31VUKY_YI5F}~M3-rOZHjPQt-d3qs90QJ z_riRK`{1pX3+{CDZiNsZM_++XWw|l*SS0S_=oY@tE{`%ga z0fPblT<3KJTdPHQz46j7U;{Ux!GS9KO4$Zp#jlCe0zkvUEl;fcZZZcO*`J(S-TzwF z#aCc8`Vu~@^gz({hbg8CXz>jYyg`O9;`{l#gM|7f@&ao|kmRFInLMDH7h;bp~puFw4sJR-VIB;4|P;P zD5PoLAtoXMufVt~ko3FdP3SVNgyS7a#mVjd7S;FkWY!T0D9${Ni{#xsJ?~AsXj`K> zPlF(??l_kl28hZBmoibe(!=@tyNKi#Ln9-^{x(<28mOH_tb~q)Hy&-aS&9x$Ej&9M z>9R?zhi%bsn!FN0ehfNe87T)Y~ zNHl6tG6Bz6X>P!71qXU<1gh+S}fE4{13|r~Dj-Rj&%8lBtG^gM)+dLh1&ne77LeA*mIh z)iEfGb+0apW{r?QuBD}oKc-@G@FiUty5JZkB_-IL$3TwmBa_0nPfVCG_@+Ezs-&!}2<;oR1OVG~0&|hiBQY_xCEi~#%~dAJD+Z%Ev`%MYjm4~ZQL0|pT!KFC zY?o-#7h-KWXVXwyPm-=k7i?lZRbuVlkbCa&7$(YfnfPP7p%pR{V=&0 z%plnrw{#Z!D)Q)hr`uNFUn3N1JPiOGgoFj2sG}0a0X(5YgZj@Om9Biy$ zf3_~5$8kl`Y?8#YyfrPAk)Ti7G0*505JwKD7{x z6cZIw=hgS_d0I_-C*J&|?0I8R6f`7no&VTsm@mmjW0+*VAHDlGKeL@@U!nX{a>1yB zZhNH1e|5#PxAv|md-T-l)9iFlj!!(5BYqh%(?RU1I!NZ%;GaffcZ%}O=chP%;vBQ1 zqu|s*UlQJxaEn_%&+ldTK+Np_x{o_vo49{&9(+K5*SRH<`$&QP%P14LxG7mF5r$6; zYzLp8x|=Y|NhMrWeicwg({Y8i@<-p%yQ991k&6F+>qEuGLm{VO`fn|Hj7PZt*G(tY z)YDh(c*VLTcIOm@NJL&$+9Bti5qA-4o}by4GUQF|93!C<;AnozhehZ+@Y}}p-)rQN zlgYQSMIZ>wO>5oHa7%E^xcGYhZ0OZjtAC738a_1^ZZ+)!+qsD{pRP)OC#{PWOHz9M zlR+c1D8#BYE$MRXq4+>bX!5?;l;mGyRLdM)olN*wVX}cgVb>D5)p=ETyPza8tUa3! zg(>5afBQB`!o?%!m%@?s@@8$jfJSZ+z0FQbvLY=bMSqI3WI;R+LpWxx^KDH4#CRW} zUq2SQ-2cx?TSo?3VLiwM+N;e0qW}2#IPzk+xe0(w7vtt>083X;*=96AJZ%^zCuhNbWG^Z{Yy-FODEkd`2E|?xnH!FtE7Xb4ctz6 zj`B!JS;-RD)36QqsjcZ3#pHGi62J3yp21A)9s0A^wftIJWdVfTju`l0bXp>adPxo1 zN8HTXB`O+LYHDXeAk#W*Z*0tSRc<;Roo(N)$L-yTyC>Lzud_~{vC(ytKK`NPIK=~g zzx9L|4ly76z*7VuxJ!VlJ!Z|b+IT5Quj%y_(=Tbk_5)wOsECP+7l(<9i(lmARMqf= zCO6!TRxT9POztR@45S#x_%^_r(EuQ2tw&xM!T35rDetXDg?i>`_#K&{{AuTcpGEUu zk-Tn^QV!{r(ike}6Hw-{FcT9Kc@GD`{d z1izqdJ~}V=8_%2j3`8o*n~^BQZX%0kf@OZ3UHGzXoQI%@T*y!(r$Swc1l!6>5aBxN(*bT4;JZQ=x2i%5fW>x z4E96l*U#*3K#_I{9frzW1j2r{jsq+{?Q833j*(%rO`p4$-}3!-AgX*o2Sa97?e{&0 zVg99&H=m8awWJ{-A1Dj>%EUn^dJiAz77-7E%3li^l??tYh@nx{F`;c2|M4$ zuo~--XCc*^T+o%nxc$v@h%@9BK{6~JwSXTGibu@Cu$lrJt?ZG4kGQ@SJbVEnn*JY~ zBP`G-i^H{c0mX}^T-l8}$JNCSpuXyV-kc$Oc!E$LIwPnIBc~8BCuB~$s+@AhxFhbG zwg=Kt`f{ia_E$WU;M$A8`p}uHTZy$YL&oVbk8U&AD2v=U1Y|~#t-wrJr)r!((E08* z8FWm=clbeA5LZ%qow;!UQU!wRb6rWk0Ez!putv6$&bOyWE47<5FI~D+lRY$UT{Ui9 z6c)>Ccl=H&v7(})q6#Pxk2MP=X30 zht?aM1?zIK3d*KC0Yr)9Fe4gqnWX|L8v6wqOFaT3fcjwQIO=5W07CLB9C0GD;)rbLI$!!>s!#09@n| zT7~9nwQ>FoHSfQIybkfXhUEo7yf7k*od(Vq_<=6d(H&R`+Ealy6V$DUoLPuL0lr0W zMq(~J&HKGY+bju>!ZlufQ5s?({IEq_vJ&`|!hs-+BV*xnz`_X4H@v$xOD*3lX@xm} zg`7FhLjc563{+s&hu=61jg9Yvvj7A1<~Z_5=IHZ*YW5j`7^r2ZKUxl-15vB~G)tKm zs58ZUn`(N0t9Vk)@nIz{)L^1PBdUbuX5*3MDljfU= zJ2GWb3n#^l&lG;p6DbItAV0fXJhjpqsbcl^Wn#3JdGk{>?}ixSx#xRi{~+8&i_T{& z+>%cbg!_kUAklr^vMOjxyF?JyF079dF2Kfrz+>+7o2JZn4i8TJ`-tJ>8ym)7pm0W| zR^8`$T-}JRbLPuKk#)H)ODD`o9P9c`)+BuVkZV@zy$L)f9MZ!Q;hf&{6rLr^o9iN< zvXoVQAD?(dA>F&S@#DOwbR%0)w~$plg#)qT+CTJ}B%4&;2P z*QD+SXUDUNr$_d6jBZg8lH&gRvd_sJl!`Jdtr6|j;;3+oUBUc2CHDH=k=sh=xn!#BuQ1BVvQmkPy%)80Ha#SW9*{7w-OEdq&L1et z!M>HDLWOO{C81;$bMI*}lxh63Vgc{tF7xUlM=Glou(- z$+`%qv?wst>vL7;|2qXSp~lMh>}K|-zFt7dgplGtp#CpvhHE#ZaGY_kX)hCISjGu{ zV{Me3ICLn^k={FZ^zJ~injEK@3TL`1-x0Mnk6Zq9a$M=XDfjTjhr6Xet{aIH%6avM z66=u;(#Di!e6!TPafC~q%SH9Qd&cG~xd2X9jk6ezR6|V_nxW|X!qPdsH6iK)mf^B$ zM~POoXhZ(`;KRpbT}J=?T_0e->~DeVFWQDH3@4;BswG>QoY?zMG{WV}0egokpXa=G zABi0xD49Y{M4mM0Coy@NEDsfvgT+)c3Vg^=fU-u;FHl64cW7)K=`bY<lwGx{JJev^tn1oq;HlO3aTumP~J6BrE+xPPndSS&Z08= zdcLS%K-n_1iQAup@}h=TepBCobu;cZ4HMA=KV||2lO6c}8y5Yndtets{RD7YaVRz z`G5?(-kqj-g)1LO6o~?_aKM4#!fp@`No}n9zAw}px~m&}-QX>rQFEZZM%{xnB}6OkbOn?Tg z4^0CpIXQ8VcnQhKe4&gbK|@l_3J)SeF}(rE8yx^P5t2Qz3IJin`@7&WtAd@--^}=p zXpT0t?$W)j|2t-q2yKG(nma-vO&D3ErVj;DXuC@{H^TtjU$E`zTX z(vur@T2r&?MN;uFzsb77kd%;zFCH9HCdjZTU7l_vihe4m%*-Slanx2ILNzOn?UO{v zdF+%hg6-swXY!@x<&Sw#j?uy_{0a0;@;py2~( z@p(aiDG@X^fLq9fxCe?i*gLPIMj=%634}ADrSqWZ&c7@@ zG0#e=t9#&Ka&QltgXkoJeu-T=49oAT2bvM$A>(6b|NHXL3-P*YR#HdcOIN2ObSJ=L zCkDMu#EW3D$3goB|2}oa?lM2J#W=%%xVc>w0l;-SP=O7w2H-Ms`34#BIV}f( zbA~)4;*TWzApj5eoUBy-jf9tpKVZ4WKzkE6HBGaPLjD?F-T{U3vhv#~>{M!zHPq~Z zoUt(-we#3xk-nC{+miB8Ot~HU9N?Y*d9~7Qn@tEzvhZVlF7!S_3T@L)nN`swup?b~ z>P3JB(wa4;@gy7;FbsiTyts2S|Bv9IA_g`|j9d>)9HIVRP&`=ep_zQP#KUn0J1kgZ zLp;hYDI+F-r|n&TM>M0j#B07JnQTS+FH$4QpR(F!+^HlwBsJ!r2dj`@osdvrxOPX? z|M_YK9_etEgFbs+JO_3Yt9TS$vP@c+(d^^uhc*v%STf7FQ(Y<#RVCHb3Ke35EKank z4@p}J_|(y|-0Kc--RlC%1z`ICTCU?@3=#wX%7O_vApHUZ#euDz))xMUc=GE@cNZeJ z!NrD!0b?$N0IpG%rT$+rN98DLHG?0X9NN)f3j;4gq3r;Of@kLi|H&7jQ~VonR3#rg zU__$?plXZuaGY#%z982#W`A}W$NnGAk+F@Iv$bWjEL)T4^CUa=CnWv+VaOosM`c@W zyPKJwJy%8WM@;(D0$!=ZA07zVx?v654hb3g6OIsbH^U8Hv~Bsq@YY{e zlg7dP0xw4wm^(4Z=W|`RLTk>|(pbLHR$6OaSCJ%-SzGP|S zcm5|8NkslyH$g2)P<#+yV5!_ALQ_YW3k(c6aN?Nk5xa`x=^54XPd+9WOig=DJ=s@E z*&Ji~fg>nU_C{B$)D6WeHBw53D(RfX{yzw$MFJI=!2({EqsfDNc{H-BlNbA@R6Dll z>=}|-_>sA~d#KF3LM&y5twwWT@Kef002M*1ePzNv8QBF4Ij0A<69i29smTI%ua1RH z`ATSKLc<#w6$P8=@4T5)F8>ofgrwf!fiwXA&Eqgn^27Xo0H>Vj;lciCRrzQ4$b5#TfwmE3 z5A72BYVbuRS8hO;`y$v(|P^nzuXo<9YLxQboygT4*zAD z$XMf$;NWq!WosT#*@l{7vH&}^=XqM%)xvf74Z!iudxv0{c?l-G2@owBKwPo;wW=@h zv)=%$h}CfDPHR;{vw1@Ja2p>D@zBXd7cDQ(7BA$Kp87QWC(IO|gFkli=L#C?0byIH zFLQwpB{ekg19acU#)ijc;wa2xPN1O?T7ondL46#JeYh9O_ z6PU;mGG5(`sC;LF=na@005J@Az~3en^_ z2FKuYBx0c`1`!9^bThrXys>x6estePfDtyv7a8R-;7n&312ZJ^4@Yup;|&n(Xdw+r zOH22EGADxy`y`g%={~emb4YRU@Fc+Hi9jKQ5bgErcrcbHu0SBU8T#P3vN=c0`#W}KG6@Hnk}eUQW$DepmY6oL@JU#zn95&$Xhxs48^z?MokuqNJq)tbZJX-9( z(VtUXVQ~L`p6liV)Tl-#F2Hj>Ft#)SM!}!+`$&vID+@Cq8RmNe7*um%&ZEW~U+8XH z+t;U8-N;|{e6Iz+nO5v>8QuZx)#280bxJX?)`NLv3;2+o zZpjk^{PH=nK{{pdG?szbTD1Rj5P6l*Xc?TzdO+g@z@s1ml4j_{TZRoTIU*%aE}Ekn zy!Z#-f=gb44Gwh_sHye<-s?j>`USHyFSa*klOUedR@8qhBeYH+VIfyZ5)9YG`=rGP zE!Tl{7Njp^{E?wriG2po0hkOlQLLHlx+vx4<^d5T_?D^o^I!VcG3BWf? za~m9}o$#MXpSd&EBK*brd-oLsE89=rhe*qZG=<6$^u(WoXP<0V=ra1854A-$lZZ=! z_lTk-$6#%u4r#Gy7h(T%IycWPw~m4-5KT(kfJJTT=5TK6M~gS$zH6`HAy(`s z6JJJO6}`4@f>SvuqO^QdMcTv@5!0NHcT+$PdeTq?5?q%#!c z5;^tPGmPu8c}YgSGw2GM=t|E;&YkKtRL3UPu5QZFx$)XIi7&)oaJt@@^?ChuCUxzW ziL@JXz!v~onAq*u@VHQArF{G755$mqt!`^ z?9I`pL=$V0+YkmYS+xYaRKy-Xn-XLB89BSbg?fpXmqIy3_7=zrdC>Sqv>Vi9q<*8q z3R8{FdmeyyAZg#97P^8quf>e6Vy_R*-dLzxQdn5nGZRLVo&1C3IG>4+Ni7m0WwcWcmcu{^E* zcPlNR?RPg%7l&BaV-B3spTXpP40E^K_0z(ruKOk_ns|)Ram9i53$y)xilnlHq~zrL z2I?A^UhqK>0Py0k^%j=k$Vfl%(~g1Nu?pzg8hA`8avs5PA?LCnM;8NgzZ0OZ*HJkQ zJ%%%d;;DOdpv;9Gd61tzJv!tv8;gzzjF@`E2fc-}V{G+DcexEW;FXE5LuH zr3k~;Wd}P8&vHh8wC{aFL&{ay_+yVxP~U{kTsVvF%PY6Ti{eh1e}Q~9bRY=c8Z=D{ zS-km#f*katko>=fW*IR^zt;yBCpu10&{`9R+|X_?O5wy~GIe9Ebzqzuid@@59=R2% z84z0N=lup|0KH?>Ok7?0tT%&>hr#;m0lxih*{T6c{tNS-^b7uCXU*mVhO0ijqHnqy zfxBLT2LfaYGD%#0L~2A7XsM^6DiX-tR)6yW?o<;etz<=3&ehba^G7`OiU)Bb15z(bL!0XZ7!pio4>iMY zucD(FwS{1?UqeG9$CHdsG9JbIoGY{#kQX~$IaSMPaRZz)r3wx^Ls2U*cm&RVpTz|> z|CUe&Z*TiMY1XNVeZ-O?BWsNP6WddSigJxGG$8Rw zV|mg8dW41g=O8PycYz{^S~g_AkqQfp$Rd|f&%$OgyRcy+0eUb5BvPj^aY;!SJEew+ zz~jha3`S&p7`+9Q@>+g{6F?A}c15?1p2q>LTbL}HfSjCTbo>mt7wA+a2ZHbjhpc;_ zPJsr)hj*UG3%tF0P_fYD&v*V1w1sDyV=(6REkU>xY)65yaF>tJ%ID+YOe?aL#|Lb%Hq%vLMh+4 zRr98DvP4?55d(4a59a?IBZRyQ#k3K&8i97xm+5E6UQ}ND^dI zl)gMP6(l*6JYf1^;j7sNKukv&Nt?>r{$LSFJ7!`}~>- z*!QcUUl;@~v)>5K+B$Er18(qMn(K=z(cPAXN#ZZg-Yu|*lHWYZV$20ikU^_=JkA5!N>_)MK=*z9NrY0xrfeeY<35iKbNVJ6KlfYJFR5fKF zK&;Xn`Whz>aHV_j7jsvW13>Hzf?GqAYh*sdmJLv>{VnlPbP$HIr8vzjd`b5PsRNA; z0Y5qMl;GE_@FA-2Nid$EX2pVDxE(^YceLLVjPl3|4?ugZ!}EZB)Cl~vT4`IXZo4#9Uk27`drfS|3xehQ`uB2q?`t2z6Uk3}|3od+%}*VQV^ai(vUG+k+COQY}d zCs^qdJt|FCl|k1}(ezrW)u~5iL&{dr^Omw8*Ra&2iC!X;N{F@{Ned(0N>lT*<=N49 z;nvOjxzSz>F|Bb)k-yTM<=Yx-doCDVi8Jzlo+HB9r0p1(`L!m%T#N07S_>!F5w(_Z zix+Y?2({l|>y~aUd61Y{rd1(eQlivEZ48HV{6Qro2mdKSx8+u_UQj_!4L!($5l@8J zmn(KHVUqR;EKUtnYK+s=0?i-p?oQ+ z?E0gZVg<9Vsh-*%iVE`g{|uAP-r%4_IlI5ov$BB=X2`%;{0j#1vqyA(Cnh2pD*eqlhCPGF9RS=+1-STiLGN)t~Mxd`st6eQ-r=g~P zi8%KqiGV6J(+5*@=Xq_9!gGRbaDS1Bz_WY=V95Bt`})RM`Mm7yd^14dAm%U1WJ?24 z1w8NyY=zK()rZn(hCG^=bHdo0BA zXcOozH|`oOy-q$|N`V_n%So%QW67@I%O)XOP?mwG9hNh$ah;@zyZJK7rM~c){l;5z zHX{rjH#CMF#fd`NW(foQwa528Dt1oCiD!Jdz)tk!=@tW1^OtkI75TU4)nbEm1g;H< zZ+hHXx7D^?dU0W8kTr=T^;KxoR(^O=|5**q2kb?bpLaJ2jw=O*_GP8;73^g>7`$!U zFo{;6u}#_xl>j6GLRbgtlJ_ltcpvkk7zR{n(6}$7W)z>Y+qpexE_6+%ly(S7=nDmog{e zZ0H8V|K3_+h&nVQ;fZR zvD$x~phKkYL-V>`hi!sX#ba6=@u;E8!!9HAMCn8iKE65M@p=2U-ha)k zE!#`Y)GjHl$r2iW`W?r#Pdew7Z-7PLgH8x_p#GZsJX#Pmc!#3*_XE%tP=SJ{(MW)x zE7%Nu(y*=%BV+MisCpU3DzO41KZ6hfX#z1O@XQ&{S ze36@*42DMlRH0jNSD6+4Q^tjx zs+P%eug>4=Ez{M1`%qcV4~!N~-|p7ES8~68vUEy7LGXnH=M6QbPpezA1J+9B)vd0s zneoC$&SJm~1+n<6>I-pcYt;CkqUsp=TE%#%Q5o8yWFeRs6jrFf+so z(~CzjXsV#A&`K9viN{ZqU9Sb0_@B0%VN^Gp@d0pFBL{7Yt{~)W_rnVKL zu^P?BS+~o9?XVvBSnTYjmS`2MTZ9_~n$};Yhb* zCrR^v;5&bD-6(824hWHKMHV%ke7=p3D_4Z8pIhnX1q11eY|)o{8^f7|M+z*qKN;b# z!*gC3AB(woNWE52dCs1}7myrywXcJY>4$6VAtQHQy9Bv5{w2fjy#DWxe(o4l(kNcH zyQOZCG^Nr_qIz<;P9WUEjO5+hCC1V(Icbc9xd~NnnQ-k1Bd@dfW4iYY|*dL z!ekkIb#@Xy+|34^-qMWA1qeJ=={&wB%U>78SB5J!7Ahj5qV7BH|LG+e8eT?2yFhRf zKt|uj-JcaAOa&ajw{2HLs&nA2p0$e5esPxzlJW^L52R z%B*>R{|VN;F3dLb{#O00j@J(hm{h(DS~^vJ-A`v5t~(;bb^2ZYSd-C7d_41cE%n|D zPTCE`mXxHa zoqFf7<-4|k=Qd7T~pCaT!q`^*;Q zSv;w_c6!3fZ+f<9DM21P<2JOm4LMtl}GP8ke$eRl%7*&m{ zJ50}nNc1YioU)QgZ>BY?y~DqFI%Y4IW|ZC!vRl;Cl)tc)X1(|dhFnmQUpIh8JvOE!$xvTNv-tI$$=N~y9j^-?y8AsB3~eypXUAD0 zT}0ypI12`HwAhI;ac$ks$uvDuHdCs4j8%Lz@927$^QGUbyra_I9sTj^vm%3{a*wqj zF-FyQIW1x7GivJnIuUl6d_B%}@;ezSN9?ejB9%Ex`;R%Xpe`6|uM^!BYW38M%TPZNhK} z*}wi2S{a$pu9SOv94(2260E$$%o*^O7Vjs*3VwkW2f!TDAqo$tOx5(+)(pc3lKIM2gS*OQyW+*8z5L5By+A7lwtz9~T@N+6+}(892lb$ojB! z$t*FTiV%{f<51i;)%GB!4KyCnKK24m-w(i@?m6>@Z=~K2%<$pRc3VLoVg{#G^F%); zp6Vp1ASUEj z_$1rWF!8>gD0@WTu_ovNF33ZB1uNaVHXT%JJL_UNf3la#w9A80P(IFRlAvDXbKffC zVyW-Xue-XIU$IX4J8cmRN!~`V$c;be)P~b)XkU>Lsyfh1ARXEHu3Vw8m`H{S3MXg@YCPQ$UeDe1h z{mD5cL&Q7*2b%G^FI41^b-Vf$@FlLx{7ABkG0i?|FQ*F$adbTS_9jC0g7i{<@c(j% zAG(NvS~FqcG4`J_94jMz-~f96f}E`ch6O}RfONah@^usokkA&FP*9@vhd99)dQ*Z_ za|cN+=oKv8p<)Z`<{F4`qV}B!P^bZlT~#nCA#oe!+@RqCk}3jY0Ay~g=Q@N&U(Xl& zfVl(}y?`Y_e+VT;k%SL<3JMHZR_-C-2dc_JrxyW<9q|;PFfJ-d+VHJXIR9Ub`tfcd zWKahX%we=@&{h1aA9`jXR1gT64K99uA{V)=6qJ;}z`${+K^s6B5xLMvg}4`J^MSu= zF2EOX3mn++D)IFxfu_Y1St=(GL@>9INexV#kb?LNb_;X)uFlS8B!R#~@Cf?*s8NW# zSkrg1(9YMgW%p#eZi+N3oaUO~6+nSO@+x@aMWD<G7jAXM2>({=%tAk#)*lEM<5jJJ#pzUc=Z>0uERTkj@;4z zRF3i{+(<;G$v+u_evEeOE8xyl4*-(wj=<+df+tVz2f=?YfG!K#p%(|ISwuY|$y)j@ zDx+=yl&pt=SK{FC6J8^Fz{l%ZO>;~k%b<)oY}z8A(e{{Bz0m6njl(wZcJBh)DPdwC zCB$B{JM$tPoM~oC*?eErMqp_#VCR)1Dju~#)v2k}A{pK?w$vW2Ai{M2k=9uF0Y&9U zQR$MV;_-G|X7Xkkv?TSo2%hl0GD3vQtvTk#%aoLEyaW08ohNblh>9~!8U-u)J)>rJ zhJpor-2payYKak9jOBaD8fRnPW3kh6HI{EoOe2SEJV(@{3O#W_G5ozv4et7tL$z7v z?n4Ek(Vj<*(roe3`^{=*tom@R?x}0Kyv5fqi0}pa?)j&Wz||I@fBvAb8yQ8P^)@nM z0qyv3(N*YFegjm=(nE(XT}!Jm&`%h5@3wollDO$lCndH%cZR3)^X~H=KP||Ok1vgG zK~6w)0(dnoju1C;Yjfi06Gji&rP8&7ghn~)*v*TOH zAnVB?D*BpL80bYz%*>+D01cZ20QRk+Cs&`u$O2mg{fv;L{w!LdY6p89>TY#iRx5eA z>AGv4qbnWW2TlT-9S1gA5wHXhoCHXm7SoaddpcF=)Ef>J7{d4hhIM{b0L*n5_DO!| z=_!+b{4w@R?^ZSh6UPSK6~tX=rv$-nX$_{EV)ZiEQSNluSq3!$Rw5KY4(A~nlLy=n z$7Lr47F*9#9{`OAz;Y_-^y9ZH&NDl;2iieZ6eGl?S+38m3l{n4g1Aa=i@;Hd{boan z9c#8YucV07Obr`Rv2|^>yH@8@aI+UypY2fO6Qfy83Gcgb{s{#w*GuJ?H&zpmycm25@$$7zg^8EmZ5{0_(E|P&WB@-~H%K;*H^2iM^u#+65ZUqFtaB zFmo3B1nkimt2@(?*=C$a#e zDg~AZYB;*e-$ddfPWa>!_d_fh)U_DiHg0!z6@!aLUi;OPPs_C)6Vsv0$26MyP={dM z_YTP6G=jAWy0|qVQ+K+p-a^6(EN$;5XVbT8&d?IPp9-?5ODK4m;?@*ve@zBE;XRpK zIjSd#U6hVz=rE9m&5>SUX-f33V07FP#$TlB?$;6;r+3h;w=9O6iMpWJtf{#rw8-C@ zx~Z&kk~cJc?Cm?7tt!iYQY0HD$06_lYD7;3X1Qigi*?6{zv_#B{h7aCaoKxxe1$FB zd6v7?J!n~vW}UCmE$@;<)a@5PWJBh_x`H66sKSQ~)v8y&#P4G$FUBld{M>tRQwC>Q zhW-|R_*E2WV6DC$14DQNQVJ*hOGVYvX@)`W}P-O@jEz6(BWgV z6Ze`isspbKG?`973v4UqZG|H<3fY5&ng+lHO6fDU_QPpvM`qu$2J`cT@qNrB?&$*u z3(tAf(QgXSPQve?G&DAfdf`bKHfAi#BV!`>K)Z#fn(v6RdY_^cpZ2qbio>n8Y)pbB ziu%QOz2$bFr4rz|HekejUN$VQCp{j^mXT=Wcz!J9w)0q~QzZWAS<67#!KKG<2@_Kx z^BSSPvc=a@x1Oo;HJjiidQqlH5XPAV<%bpA+3)LhT~^sa2L9o$)NF@A?9@Xi_`*y_h0ZMs8m4Rw^5D35(UX#S2{&Jc*N)SU-f7_b zV~=B!klAp{u?yiI1_g8rj(IyS9Dd}lQ2_{ZdW1EACfx`AC*bC~1jQ(FZ*5w-ZjqLr z%-ErrAslUGiSSEsbaXW6j=$qb8_Lcz;GcdQ3l^3k?g48y^g&o_EjM4n{8q3PD?vR{ zcHucqe>@p@ixkj&?ACc!{ZADM@wX6-rVb1rNY}t1z&ElD0Cz|KZw;_5{+LqpNZ?lo;5*2RCgE3K3cQhrg(I4+>#^le>dTRNtr#k+= z9=Dc_y#SHhYl6R9K#x-jAGic#?P8I7*%lic&GGNFqe<$B8j{OiUYxA2{o-?$`N= zFpCvaldm7t`n*_^)GIV{kBz3SXrjuq;J?I2L@FBX-E;** zlUQVbQU^`ZEqNiZbQW`RJ~{ly@)-fv0^XZdfc8fO!B@+T@?ntPMn@5Xmii&_ktbK( z!U%BI8$*akXw;$+0^=}^0NfMpo0=;vcr6g^8JTmSR=f=d`?>cu%+Ov`bar-5hfjY) zqt2tv&dnVMCzc9C4-u3b%fn*@zEB6S6m@xBj^FOBDju(7EgpW~I)K0OlxUxp8c)=H zLGSMSer6F?2JJTLdpd)4rU_S)ek{0maH!*Vk+3Yd+7Kv7>`OVDuu3uax$;fi*&XoK z^j(uKK_a_)O$yJ1PLVG>!RiVtG*go$Q)Q=Wj_Q!zMeqEO33q#(bK>fJO6@ zP9wDNea<`Arn26-$R(BdOY(YTwv2ZzoZp=}F2;PJD}^RMKZ+53`s9Et&D|G{Kl>9a zH0*xaE)TUN0F)Hr<3RKwaHi?jzK4SyJ#N!EuB2=O0T5~x!|%5@Z;1}wAv^J_pWky9 zrTr1rc$DOpazc6y_lb6F>=eAG7CY2-Etj-3knv2ESjMihI&h>So2L}?4g6?khlMq%1xBAc2kqPR7$-!g z+8Mq%@q61t7qgLGH4B8$f8*xwHvj;?GXyZ#wdbMym3-2fzB*wc;$`(1A8s?ZUM~)8|1MI^$1M->2cs(!Fpoes z=W^M~!l$TA9}3 zH7>DqSWWbRFi9Zw=1l@#l+83nH!qAfDVe|5z%LaTO zU!I`vrQ&M6s+C9=b%#M$B(f;YX*It}IZo@9ftG=R&PQT|?nnMb0(aCZ%bJ>@7JHxP z0O5;|8Lr0ZcIHfIkf&_)LT(hssy&kQE9YCQ z&~_#6DZy~$_eUtw4U7PkK20+?F7%Qz|7lGuG~r``^wC2N@S~&R-wcX>aLHUElWYMy z=KVuw130k0XDBuz0@C>#pOJdZr;|%}BcKSrf1kErfQP4f28X^Le;KLUx&2y<3U@8? z9y~-9Jpq0J)4JvYk+K0arU*#j`W%$^d;c5Tz+V$@Hy*_#+s*@y8DI>13Y>+25C{V? z_2U~p>cZcN_>3)x`~r{n3Eyv}vm4P?RjTZ>@yggQRy7yi?2MN0;(^To_rH&Mv%5$|c z!y7Bt-{>xrQmk4!U$<0+AX$!Jd;Rmxv!Op^N+(;wio$)T_*kY{@z{MyhQ>S$y&RgJ z{MpAZMH}Ut5N_b#{gP~&v}=o*yE*j1JDf|vP%x=T?PEmBY|v~*1-KMdCepEQZf@I~uX%A4}90H;<9;{_5LZ%Ft)H4=&mdEC(>Cp?r1(j>kYVfMhl} zRFRVloH!r9dqYI7)T(J4^6Vlv0^Xz~6gqQkVcAH_hAe*HE;jjJNrib-MjPGKUE~)# zT2nv21CZnoud&!ZFVZd++sAZ8&TRuYqyE#QUDxn)XY%?_AR# z%h|3ORsOPlIWyy?Hr!>(8BzH8Q5$J?&`)_-N3F}N$tzues3~*dFq_J2_JXJp2J_2A ziT$lUd2(q+bjQ}aM|I?>*IoO@hwLu}>0t1(r?hgK|UXGqRhy3MO( zLuuT9=c>$#bTote!nkCRdU*_NR(exrJp}ooNJyYf#5lq*@j9_`ApGAW8re3j3*?p&0qYAlw%M_Ot~9rxCmy<(lOBB|~XbhQ7x zhI07CyKVF_C6~#hZjY(E^!NG(52;lvmko8_pd!mvfv5#^4g>8nM!dQP zL0udFK$?cV=BS6q1eEpCuYcVaFzfc1@3!@>neg3dAR{>xdyw;J|G`x4km7iU{6zBt z=;|HqZ}8rFN{weJ!Y zUTV~a9UjT8a&A&GX{r>&dO6@96xRe@7Hqp5nK>V6Ww5GD&T>`j^y>9G4J4}K3|V83 z-5pa~Jgqr)DmQ(xG3p3-MNjGV?U+SgSj}r64URt<2p|eYF_DfOL=S-e^z%Q9pd+ib zfSb!}jaRp|p?@n$2D3t(Ft zb00Xv=$Fs^gcmnW<@?pg|Er*Kqw2jn)2QrywrxF%bLj3#2HJZB@gGyBYU{emp;@n= zJf*N`ktyE3Bzr6{gG|3ODlV9|OPWE(W0==*JHCRw*DH@L?|H*&Mb&|(<=AY8I4s?< zGoe4u^bsaq9>#J@t-{fBEa->%o`h6KN#gA7_oyR1bvr#;+_10X!?NAsMWy8ge$4{$ zWIJmmb@d{Bm(;sbOOUf_fL1b+CXh~#tS{hR%xd!k1^gSBK2W}R;~W47z%27;kE7?x z@1Wzfn$@Nd*&KEV_zhPcAxJ7@V!)ZkZQ%z68Dh_(R3mIP)S!wWw#Oy##A{an>2ijO zEZR1J;4ca+WrT(Y5?dqiE)mcl9HnP#e;^Jonj3^-dv|EIBQ^9>Z78r`G_M}|bEC9r zdn_><+CMQ;=7aEWi4P%0|0(gA%-#UAJP3y{q^P_5=cdZ@UvM5WvEb%n0AK8e^)++D z`a09QCiC-a55h$b9-=b-KxK;F7KBj0Wm^?l48m!Ho71H1`6#b%$~FYdll%4KGD6M( zRIjO~TBcNd;b>CqFD>7Jxo@1wH;TOv`DW&5+;ZQS-x$KnXQA)>$TeqxB~h#cNC?!_ zntLkm68CFpci(afvSs9PV^EH_=L}`%Ik!{RXgEtsQC4{G5J$aS3I{l>NU=WQb=t3R z{kajP^sUowhUQ6C=HyDNwnf2m`?eC+v$1vW{hF4vU4mY)4Ne|#thr(qsdU-QeHff2 z*mF^{c-za9v#0MK!A=_!C8bp()UcY@MMp1pN3*cqnY}=?FJ%i7JDt1N;-pe@zYhjT zy6=m`g$-dU0Sp<+%FeEd$<5B@kd~Gn8My%?wZ0GqN5B6?Z3W#StJ8|Q?1bF!a z!6z%>HhciSv4?h$EYSL#tA1^_LS#e~Wroj<`Dwtgx5rL z)VV+@TkPOLo^#t}P4!(LHC3u_Iqe)Y%(%|xDxz)RU4N*L-xpCv%VJl z6Cpe4BE-1#I}e#kwC7}i#y`dq%DHVx>i+&G%=Dxl ztjtL{dWYMjIZY~Lx6K4SD1&QnE9Y-1=_*ts``DX&kqPBAUw`}kkqB9mhT8k)!O4$4 z#g|uXn`)9cQsJ9D^76#HJ2dLl6s!p9q##Rk1d3;$1J^5l^&x^!|Iiv()GEi|9$gs zb5J-XK03JdA25`Si~o0WTOk)FKB8P-+O54@eBqdWLqd+`vx(CE$<)G0$J{P8*YV^l zCip&LdsxHA79I92mRk$+>OdsvytfARZEULmp4FY$b>!$^xvM)ls4j?}B3|Y~xZi7W zj;7sar)vxKlDnlYq^fe9G=Ju7%uOaAG9VLF%{=ciOcQWK^YBHSyRy72$ijBGqf?kid`AeIxE?%u zh>i^@C{U0JJO;pH1PthE6NtE{uWp#I z5rA}qeWAD?Y!L7^K<`%t%g#EHQCr|%aRG7+{!|nAnMALBIgip%&__aKXw*lVTyRLd z2f9GN0JOG#A0#;Adn1nXF&@D{$t?HxR?zlKvcXOf8Tmk>nOs2VRv0J+=-ku5fqB7g2XDYGlv1?xndS~dEDsTAd4+k5dMY?b+HMKqN&4dYb(TG8 zReTP0j)#u2IPxn9kDfE+GvKP&rL3Tx_q<#y!WT4uMtn3C&gpdclx@EBy{bY%$C}iX zhmi{Pa|sx0!)$Nfl}aHg^BUVp+*^KlB<8l;%MufDGJFG#~aRK5U;h@0v)Y zw8d-04cW%U{ffPjId$b6ZIn=ffR5v|9B%IBKpDTIbL7QyQI(7sy_}G`_Z;el23eVE zB{zD>ZqQ1IFeDjXgk}=KSRp~o9(zMa85bz%*m=JGbnQcK?C8C^J#dQrZ#p?R)k~K| zKw|U<%C+WAIRLexi9D7t%&yv}9GQAG3hNv+#4WQC1{NS~yC6ad`@Bg)@hs#_JfEzk z9s)xG9LAB+pgZm4fgLCU{TuIkAG-6pTU_Hi{`ai|&;k^gFCd_1Krj=9+mXuyajN03 zf&y^=5Bo3b)@=Lg|J1gbPh50_$merdnLrx}g3cyNdnO%sQ-PN2CZ|+vwpe2vfEPKU@<79HUk`d#-7>9NydjU4r!0XAln?JT*g>hvx8*;Bki zqfF6uTro)(9o#JlNniEIl?GLXG90{B@1?>BJhl_e6GOHui1map$HXr+ri{-wz>a4c7&+M|V;00!k|A-7pu?OMCz@!{N>QsvZd zqH7dhv!tbUcj2ClEuD$kg(Wi>`>iK33T5KY8d#1oPq$G1IW<~%9VytgQ7>=MPi)(R zVr(S1QN7Jb&9Yfu&!T$>pG52{icj}=ZsU3K_a*EpD16>PQeej44R)}n=7nT8YgD#U zX_mPctxM22XTpmd>edn6^8Lv+76y6j_9ad&+_|-S$?JceCe^lWwOHhRBFd{+Tj-Q= z(e}C&<$mwiv#U`>Nls_MVR)c~e=xU(+d-x7boWJ}mQ&Xs@tSDgig`$3yn|arx~9G& z^2Ul|b0bfPpuqVLK41rB4Qkki^KN)e{V3rTqi}ZAP4BztV*aI0%>tPZE?~n!OP}y2 zL3Mhr9rRfAXY~KxOLqhgd<#hNj%r~~E97IZ7i0;0FZs2Uvez1KD_+CehG(BTnk7!s zYzZO5Fb=jD%_}K-JnFoC&rkX6&~QoAF0Od{G5VZhqK&(D+@VGD+#lC$r&Bv7S!GRY z=UAI6les2l=Uoos|Gr8-W9?eq%TGr_nN+WIsK6Po04Kg+VS_@ix(e$8omA+Xrbt0%v3)S-MAV04Y#>( z5&XBS1Mm%8-A0ML0}wax`*O8rN4i`Y3Kc`{Luz(a^w46|&px7N_qO1+g9MKF5bK!! zX~lfe@aJUl2}{EG793}>oHiy{?v5a!qAo$qjl6_miP|J*w%)FmDz~Xd~T-^KRuh zD({|uTXkUcmBTc_*2S!wQaN3{WGxB)7 z(6m1XhbyEkD*1zKie6nU(g*Cung5iXwXPzpob^5$hpv1K4j1cCId;|})*~~>tUKsS ziEdFq*fWErL<-mH`ne}k zNWM$Fi`e7r=Ve6lSvDXltF;LP+FY}EnLl?aj4&ch>>uqHCwTzYOQC0S;mDw>-n?Pc zx^QJOje!luK`K)6^y@idw{yjTCj0vt+oP&n@LlPVFG9MY;0wgtZpY?5=)Pp$@&|q5 z1@Z`#bQ_PU7kV$z9n#%UQH?zQXvnI2J_fwlpD?a>dlMzQvAXGb?F%%C$Fx%eGJXv9 z5nX?%^PXDp zbDit1)}PWy{0F8c`U%cyGb&v#PuXDUlw$&7vLCN(HxD{fJn`5@pfgiYxh6~dwWc0t z#LSX9+1p`h{p~i~6TXYHICV#wHcc)L&*f*5rl^wNT;;Tv@3jCB8m(|fYNkJLDcUHW zhS=_tOMgBi&x5bD_AYdaE*Y5{MOjJ=WTxPlkH&yC-8o-C$EV0f_ZH4#j#Hp*mS3Xx zS(KJ>&m4ZLLLf9_?)4WbDKLbcu;i?sknm7AM)5@Af-5QPDxT)^W2#- zUu_Ko;=^LK`{CIPj`)|=Th$G?LgbvxYd!E;^vYt9S)U`{yx=<&mYT|Ov|7D5SS*1w zvGe7$h+|E8p*@SXYy6M5GaMvqfw|#Bmpi6wI>Fto&rmBka%e@X>kZ2qwK6u8lTOXX z9Blm!vxB_aUN?vaS_GD9ITZs}2J>-+*Xwx(_cXc}BmF))@PzC&p661Y(rW>r;7jF| z0UaBjKaZ>eMuf}$8Fr|O#C~McMDjQDnbzV|Jn&J!bozckaZIPaLNvJ%Mkf4sE(;Dy~&27bC5L?|YNVQ3C0x6R;11pCwul=K9JPL zv)bH->)60cj}Qv?QSuTJ0LWpBbeGM-RM5cSdvqdg=>itH(_rujE1JrKfz&QQUC+ZH z+G`&Z>}6tM4v8=rR2E^L(i0-WoFS_TcuJ_Bo%<)9c+cayX_oS@E`J3v8gwVDlZk_Vw~kvhRv|Xq;GOv##8D-zR$ii{Fod zK@d33)t)KlHw5Po<$NvkP~P$8wiFKrLw{CX>9kSb18z&Vv+k>W!5XKA62M}n0`4AY zS&-_tm;M9#dbY~h{VY2M&Ja1~8*R~`2FXSM{lu&!2fe>(Dl(cwhL?S;v3JDF8%~02y}@5=Jq--y-%V>;+y|RwHoa+uC%#8FaYLV~ z3Du|@*3uEGV4f3sI-i~IEQkMc-zRwF;^Jef9qa`S>EA=zj+yFELx%Cv+A1uWX?^4O z3Q#mdvqd}q<8m27mw-36n(#-^aJ{I%Ew9rTz$)jf2O+EW(Kr?S%y4#^UI3rf{xc{S z4cwH9*^#NPG~{4}u7Vv|UDqG5xs;&Y0lN0_q%{+t$d_b}%xj%`7od8FLU$jG0;=%A z!9b=UaIM?eCtVFRprx3vB{KoyR#kMFFIe-xl=H}|{#e=!tXYh34v1UV0p0s&!0II(TL z1!qUZvvU|AaD#dBE(9?+#KoDR`#2$G(4>lf4=Et1sZSfyn0NZRx50{o%vy8k zL4kvQirD8%_d>>`6jc_J(;Gi{81f!oJRLf^%;e1`A8e)*vFpV1xE-SO^*at%D2bfWP3WjF(7N{uS zg72dBFS94YkF_UDG20TO5w)iXz6%D-@Q5*qhM-FpX1yuBpy-gubK@znSBy*8Su=q< zIUZwTi3Twuq*DFQc{iB$e0=5e(8WCVDp^Pr@-ys{poN)&;>bdevP{rL1Z>lmx1XbB zZfAl0J7CCl4`dVE1rCXvzx5dGHHDV41XECrsW8(J%pGP@pheCY#PUd=t$n$WChY}7 zjA2ekwU1$o6%YvW+|0{@FOgmN}uHxt8;#2Zp>j=@1Sv<@R*>5 zQE`Z12$Z8O7&PV_=04LW=6L_`18M{YiPOLz56%W{m6w+mti!-Wmp}w5m>2}pUl;v_ zvf}}+17XzA-)wkF%c_&-2NnBYdmV(wQ31Fk=DPg0PYemLs*GrdB?3TWeQt4eXmarh z;a-eJ2^^ru0ZHPKavUK_P{7X>t2bQ=T+QD@eksFbNVJIW0nauCjr4iv>z~eSQX9Si zocRe6K5oI&#wEAv!HUlW)BZN-3OyTi1()TSh^B2$w5yP-g~`lg(0yI~HdJ@d3q)a< zFhll-&w?5-I_^KO!=PH%Upd{`AgrJUE`WN_+!WN*g!`ciS5h}~t86~~BAQI~4>ai$ z;sAX6I`NWSfAg+uiJlg!aNA}DbormcH?N1!)N}qFE4(3G>*M-M{lIGDx?Lc~vi=8& z9t}$Vz6uPq_v_jl;`B^kQ840WW3i}tff}bDY`2EE>>Mp2ha(#s`Xqn}gj)Zu^7b1a zYg!n>t|0exo%d4d&0l^pfRk#0kpSRwhLuh*J-vMtXko9w^V45X?_`?q+3j@@R+rbw zt3Z%B4xGClXuHd&&q~9Z#R#8-kC@h^{w{eUN*D3!5uXL1Ot5^KAYTHPt7P2Ouzc0+ z>2hqIe&#*MD=>m8&LqG7Ewi^kY4>I66f}DdS%8WO@DK$s<^^1ig)OX$JpcpPl_cpx@LA4_mjzpm71Si0 zFsB_Qj*xSSF)`->lpR$KS5!;k-sBmCL22>)N-kCRi*s93?$><<7wZ_}-N08w{dmkN z81jr1H#7qj5bGHDfiEMa}!WHiQuEA*%>9 z*uhcmkF5F#djTOlz?uPB6JaO|On|WQgCz~4sbmuYv8@ei9B>drpuLt3OCIGn(G>8F zX~>W-Hi%jfMPmc#|Qd9wkam z3`Bt1z>TJ%@Y})r6<&3XC^7)6s5(>zgJ>k+cioDCPD=MoF93z)(Y~TDx(4!BDGY5u zL?bZ4P_)oz%} z#;E`78{cUqqjuP|wqlT_<7F4p4W%(h}Qs1_a2HYL9zaiixdQ3 zyZncmsZ<1Uy-+=fhz$&YL_xFO`Hc(j!;cNr~8 zBnvMf$jZHin~|}_y;6d9-!^Jz)oQ mr2l@wfqCQqbKTDTqR^5~ef5x*bshu%s4MFz6)T*-{eJ*Ec6Ijv literal 0 HcmV?d00001 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/e78f8d9a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/e78f8d9a-1.avif new file mode 100644 index 0000000000000000000000000000000000000000..5a542ce1fed989788a475c14d9807434249253b6 GIT binary patch literal 33882 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 C5)+sJ literal 0 HcmV?d00001 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-1.avif new file mode 100644 index 0000000000000000000000000000000000000000..aa607cb2b54fbf2a9de4ef67e481619cb39df768 GIT binary patch literal 27515 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 Oa+)z`dbWe_*Z%^tA=pI# literal 0 HcmV?d00001 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-2.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-2.avif new file mode 100644 index 0000000000000000000000000000000000000000..d190feb4506b3d90c1a05215c33e2f9661b4c7b5 GIT binary patch literal 42642 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 Date: Mon, 15 Jun 2026 16:07:17 -0400 Subject: [PATCH 03/19] change title --- docs/tutorials/simulate-neutron-scattering-spectra.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb index 292fedc61bf..77b2024732b 100644 --- a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb +++ b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb @@ -6,11 +6,11 @@ "metadata": {}, "source": [ "---\n", - "title: Simulate neutron scattering spectra of KCuF3 with quantum circuits\n", + "title: Simulate neutron scattering quantum materials with quantum circuits\n", "description: Compute the dynamical structure factor of a quantum magnet using Trotter circuits and MPS simulation.\n", "---\n", "\n", - "# Simulate neutron scattering spectra of KCuF₃ with quantum circuits\n", + "# Simulate neutron scattering in quantum materials with quantum circuits\n", "\n", "*Usage estimate: 13 minutes on a Heron r2 processor (NOTE: This is an estimate only. Your runtime might vary.)*" ] From 75e29568dca6962083e11d6e25cf420a66c5c23e Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 16:28:58 -0400 Subject: [PATCH 04/19] fix title --- docs/tutorials/simulate-neutron-scattering-spectra.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb index 77b2024732b..e76a6dfb369 100644 --- a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb +++ b/docs/tutorials/simulate-neutron-scattering-spectra.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "source": [ "---\n", - "title: Simulate neutron scattering quantum materials with quantum circuits\n", + "title: Simulate neutron scattering in quantum materials with quantum circuits\n", "description: Compute the dynamical structure factor of a quantum magnet using Trotter circuits and MPS simulation.\n", "---\n", "\n", From f6ae8715669c3d2dd4f633992388d0c0423247b4 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 16:29:45 -0400 Subject: [PATCH 05/19] rename file --- ...scattering-spectra.ipynb => simulate-neutron-scattering.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/tutorials/{simulate-neutron-scattering-spectra.ipynb => simulate-neutron-scattering.ipynb} (100%) diff --git a/docs/tutorials/simulate-neutron-scattering-spectra.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb similarity index 100% rename from docs/tutorials/simulate-neutron-scattering-spectra.ipynb rename to docs/tutorials/simulate-neutron-scattering.ipynb From a4d49bb47869b60dd90710f11c1cbbb1e387cb08 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 16:35:48 -0400 Subject: [PATCH 06/19] ruff --- docs/tutorials/simulate-neutron-scattering.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index e76a6dfb369..65eca009624 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -817,8 +817,8 @@ } ], "source": [ - "from functools import partial\n", "import timeit\n", + "from functools import partial\n", "\n", "import quimb.tensor as qtn\n", "import scipy.optimize\n", From 7b4efdbf99e55248ef4df9544010c5f84c67e519 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 16:39:12 -0400 Subject: [PATCH 07/19] no british spelling --- docs/tutorials/simulate-neutron-scattering.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 65eca009624..6e212ada980 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -124,7 +124,7 @@ "from scipy.sparse.linalg import eigsh\n", "\n", "# ════════════════════════════════════════════════════════════\n", - "# Hamiltonian construction (exact diagonalisation)\n", + "# Hamiltonian construction (exact diagonalization)\n", "# ════════════════════════════════════════════════════════════\n", "\n", "\n", @@ -380,7 +380,7 @@ "source": [ "## Small-scale simulator example\n", "\n", - "We first demonstrate the full workflow on **10 qubits** using exact diagonalisation for the ground state and Qiskit Aer's statevector simulator for time evolution. This small-scale example lets us validate every step before scaling up." + "We first demonstrate the full workflow on **10 qubits** using exact diagonalization for the ground state and Qiskit Aer's statevector simulator for time evolution. This small-scale example lets us validate every step before scaling up." ] }, { @@ -394,7 +394,7 @@ "\n", "**Hamiltonian.** KCuF$_3$ is modelled by the 1D XXZ Hamiltonian at the isotropic point ($J = J_z = 1$, setting $2J = 1$ as the energy unit).\n", "\n", - "**Ground state.** We use a Hamiltonian variational ansatz (HVA) circuit, `build_gs_ansatz`, as the ground-state preparation circuit. At 10 qubits, exact diagonalisation is tractable, so we classically optimize the HVA parameters by minimising $\\langle\\psi_{\\mathrm{HVA}}(\\theta)|H|\\psi_{\\mathrm{HVA}}(\\theta)\\rangle$ against the exact Hamiltonian matrix. This gives near-exact ground-state preparation within the HVA circuit ansatz.\n", + "**Ground state.** We use a Hamiltonian variational ansatz (HVA) circuit, `build_gs_ansatz`, as the ground-state preparation circuit. At 10 qubits, exact diagonalization is tractable, so we classically optimize the HVA parameters by minimizing $\\langle\\psi_{\\mathrm{HVA}}(\\theta)|H|\\psi_{\\mathrm{HVA}}(\\theta)\\rangle$ against the exact Hamiltonian matrix. This gives near-exact ground-state preparation within the HVA circuit ansatz.\n", "\n", "**Trotter gates.** Each nearest-neighbor interaction term $e^{-i\\Delta t\\, H_{\\mathrm{pair}}}$ is decomposed into the `two_opt` gate with angle $\\theta = 2\\Delta t\\, J / 4$.\n", "\n", @@ -842,7 +842,7 @@ "gs_params_large = np.array([2.99, 1.477] * gs_layers_large)\n", "\n", "# ── Step 1: Map ──────────────────────────────────────────────────────────────\n", - "# Ground-state energy via DMRG (replaces exact diagonalisation)\n", + "# Ground-state energy via DMRG (replaces exact diagonalization)\n", "builder = qtn.SpinHam1D(S=1 / 2)\n", "builder += J * 0.5, \"+\", \"-\"\n", "builder += J * 0.5, \"-\", \"+\"\n", From c2fde42ce8e863a475d3b6e75026c35898d7ba1c Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 16:40:42 -0400 Subject: [PATCH 08/19] cspell ignore --- docs/tutorials/simulate-neutron-scattering.ipynb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 6e212ada980..a48003be002 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -10,6 +10,8 @@ "description: Compute the dynamical structure factor of a quantum magnet using Trotter circuits and MPS simulation.\n", "---\n", "\n", + "{/* cspell:ignore DSFs spinon Cloizeaux DMRG eigsh */}\n", + "\n", "# Simulate neutron scattering in quantum materials with quantum circuits\n", "\n", "*Usage estimate: 13 minutes on a Heron r2 processor (NOTE: This is an estimate only. Your runtime might vary.)*" From 3de618300c36308bcab35ffcedd4e590e9eeea3f Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 23:02:41 +0000 Subject: [PATCH 09/19] use SparsePauliOp --- .../simulate-neutron-scattering.ipynb | 73 ++++++++----------- 1 file changed, 32 insertions(+), 41 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index a48003be002..798a580decb 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -122,7 +122,6 @@ "from qiskit import QuantumCircuit\n", "from qiskit.primitives import StatevectorEstimator\n", "from qiskit.quantum_info import SparsePauliOp, Statevector\n", - "from scipy import sparse\n", "from scipy.sparse.linalg import eigsh\n", "\n", "# ════════════════════════════════════════════════════════════\n", @@ -131,32 +130,18 @@ "\n", "\n", "def build_xxz_hamiltonian(n, J=1.0, Jz=1.0):\n", - " \"\"\"Build the 1D XXZ Hamiltonian as a sparse matrix (open boundary).\n", + " \"\"\"Build the 1D XXZ Hamiltonian as a SparsePauliOp (open boundary).\n", "\n", " H = 2*J * sum_i [ Jz * Sz_i Sz_{i+1}\n", " + 0.5*(S+_i S-_{i+1} + S-_i S+_{i+1}) ]\n", + " = J * sum_i [ Jz/2 * ZZ + 0.5*(XX + YY) ]\n", " \"\"\"\n", - " dim = 2**n\n", - " H = sparse.csr_matrix((dim, dim), dtype=complex)\n", - " sz = sparse.diags([0.5, -0.5])\n", - " sp = sparse.csr_matrix(np.array([[0, 1], [0, 0]]))\n", - " sm = sparse.csr_matrix(np.array([[0, 0], [1, 0]]))\n", - " I2 = sparse.eye(2)\n", - "\n", - " def _kron_op(op_a, site_a, op_b, site_b, n):\n", - " ops = [I2] * n\n", - " ops[site_a] = op_a\n", - " ops[site_b] = op_b\n", - " result = ops[0]\n", - " for k in range(1, n):\n", - " result = sparse.kron(result, ops[k], format=\"csr\")\n", - " return result\n", - "\n", + " terms = []\n", " for i in range(n - 1):\n", - " H += 2 * J * Jz * _kron_op(sz, i, sz, i + 1, n)\n", - " H += 2 * J * 0.5 * _kron_op(sp, i, sm, i + 1, n)\n", - " H += 2 * J * 0.5 * _kron_op(sm, i, sp, i + 1, n)\n", - " return H\n", + " terms.append((\"ZZ\", [i, i + 1], J * Jz / 2))\n", + " terms.append((\"XX\", [i, i + 1], J * 0.5))\n", + " terms.append((\"YY\", [i, i + 1], J * 0.5))\n", + " return SparsePauliOp.from_sparse_list(terms, num_qubits=n)\n", "\n", "\n", "# ════════════════════════════════════════════════════════════\n", @@ -435,7 +420,8 @@ "center_small = n_small // 2 - 1\n", "\n", "# -- Exact Hamiltonian and ground-state energy --\n", - "H_mat = build_xxz_hamiltonian(n_small, J, Jz)\n", + "H_op = build_xxz_hamiltonian(n_small, J, Jz)\n", + "H_mat = H_op.to_matrix(sparse=True)\n", "E0, _ = eigsh(H_mat, k=1, which=\"SA\")\n", "print(f\"Exact ground-state energy: {E0[0]:.6f}\")\n", "\n", @@ -517,9 +503,9 @@ " k=3: max bond = 31\n", "\n", "Step 2c — ansatz: 389 parameters, depth = 19\n", - " k=1: fidelity = 1.0000, depth = 19, 11.9s\n", - " k=2: fidelity = 0.9988, depth = 19, 15.6s\n", - " k=3: fidelity = 0.9969, depth = 19, 15.7s\n", + " k=1: fidelity = 1.0000, depth = 19, 11.7s\n", + " k=2: fidelity = 0.9988, depth = 19, 14.9s\n", + " k=3: fidelity = 0.9969, depth = 19, 15.1s\n", "\n", "Step 2d — assembled 10 circuits\n", " Depth at step 10: Trotter = 226, AQC+Trotter = 139\n" @@ -527,8 +513,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -696,8 +683,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -705,8 +693,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -789,20 +778,21 @@ "Ground-state energy: -8.682473\n", "Built 20 circuits, deepest depth = 440\n", "Ansatz: 1327 parameters, depth = 31\n", - " k=1: fidelity = 0.9648, depth = 31, 64.6s\n", - " k=2: fidelity = 0.8870, depth = 31, 64.8s\n", - " k=3: fidelity = 0.7164, depth = 31, 66.5s\n", - " k=4: fidelity = 0.6035, depth = 31, 66.5s\n", - " k=5: fidelity = 0.5625, depth = 31, 66.9s\n", - "Backend: ibm_pittsburgh\n", - "Job 1: d8guj81e8nrc73bghpbg\n", - "Job 2: d8guj89e8nrc73bghpcg\n" + " k=1: fidelity = 0.9648, depth = 31, 63.4s\n", + " k=2: fidelity = 0.8870, depth = 31, 63.0s\n", + " k=3: fidelity = 0.7164, depth = 31, 61.3s\n", + " k=4: fidelity = 0.6035, depth = 31, 62.0s\n", + " k=5: fidelity = 0.5625, depth = 31, 62.7s\n", + "Backend: ibm_marrakesh\n", + "Job 1: d8o7jnrnn5bs738vg43g\n", + "Job 2: d8o7jo832u0s73fdb59g\n" ] }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -810,8 +800,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -1026,7 +1017,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1040,7 +1031,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3" + "version": "3.13.13" } }, "nbformat": 4, From a156b0edb90827e401786678db50a8116729740c Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 23:30:10 +0000 Subject: [PATCH 10/19] add type annotations --- .../simulate-neutron-scattering.ipynb | 89 +++++++++++-------- 1 file changed, 54 insertions(+), 35 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 798a580decb..61c1b5876d3 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -104,21 +104,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "71835ff6", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Setup complete - all functions defined.\n" - ] - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "from numpy.typing import NDArray\n", "from qiskit import QuantumCircuit\n", "from qiskit.primitives import StatevectorEstimator\n", "from qiskit.quantum_info import SparsePauliOp, Statevector\n", @@ -129,7 +122,9 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def build_xxz_hamiltonian(n, J=1.0, Jz=1.0):\n", + "def build_xxz_hamiltonian(\n", + " n: int, J: float = 1.0, Jz: float = 1.0\n", + ") -> SparsePauliOp:\n", " \"\"\"Build the 1D XXZ Hamiltonian as a SparsePauliOp (open boundary).\n", "\n", " H = 2*J * sum_i [ Jz * Sz_i Sz_{i+1}\n", @@ -149,7 +144,7 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def two_opt(theta_x, theta_y, theta_z):\n", + "def two_opt(theta_x: float, theta_y: float, theta_z: float) -> QuantumCircuit:\n", " \"\"\"Two-qubit gate implementing exp(-i dt H_pair) for XXZ interactions.\n", "\n", " Parameters\n", @@ -178,7 +173,14 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def trotter_circuit(n, gs_circuit, time_steps, half_t, full_t, site):\n", + "def trotter_circuit(\n", + " n: int,\n", + " gs_circuit: QuantumCircuit,\n", + " time_steps: int,\n", + " half_t: QuantumCircuit,\n", + " full_t: QuantumCircuit,\n", + " site: int,\n", + ") -> QuantumCircuit:\n", " \"\"\"Build a 2nd-order Trotter circuit for time evolution.\n", "\n", " Parameters\n", @@ -211,7 +213,13 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def mixed_circuit(n, aqc_circuit, time_diff, half_t, full_t):\n", + "def mixed_circuit(\n", + " n: int,\n", + " aqc_circuit: QuantumCircuit,\n", + " time_diff: int,\n", + " half_t: QuantumCircuit,\n", + " full_t: QuantumCircuit,\n", + ") -> QuantumCircuit:\n", " \"\"\"Concatenate additional Trotter steps onto an AQC-compressed circuit.\n", "\n", " Parameters\n", @@ -243,7 +251,14 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def get_dsf(n, Gjjc, dt, time_steps, q_steps, w_steps):\n", + "def get_dsf(\n", + " n: int,\n", + " Gjjc: NDArray[np.floating],\n", + " dt: float,\n", + " time_steps: int,\n", + " q_steps: int,\n", + " w_steps: int,\n", + ") -> NDArray[np.floating]:\n", " \"\"\"Compute the dynamical structure factor from the retarded Green's function.\n", "\n", " Uses the center-site approximation and a discrete Fourier transform.\n", @@ -268,7 +283,13 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def plot_dsf(dsf, dt, q_steps, w_steps, title=None):\n", + "def plot_dsf(\n", + " dsf: NDArray[np.floating],\n", + " dt: float,\n", + " q_steps: int,\n", + " w_steps: int,\n", + " title: str | None = None,\n", + ") -> None:\n", " \"\"\"Heat-map of the dynamical structure factor.\"\"\"\n", " omega_max = np.pi / dt\n", " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", @@ -289,7 +310,13 @@ " plt.show()\n", "\n", "\n", - "def plot_rgf(n, Gjjc, time_steps, dt, title=None):\n", + "def plot_rgf(\n", + " n: int,\n", + " Gjjc: NDArray[np.floating],\n", + " time_steps: int,\n", + " dt: float,\n", + " title: str | None = None,\n", + ") -> None:\n", " \"\"\"Heat-map of the retarded Green's function in real space and time.\"\"\"\n", " fig, ax = plt.subplots(figsize=(8, 6))\n", " qubit_axis = np.arange(n)\n", @@ -312,7 +339,9 @@ "# ════════════════════════════════════════════════════════════\n", "\n", "\n", - "def _apply_xxz_pair_gate(qc, q0, q1, theta):\n", + "def _apply_xxz_pair_gate(\n", + " qc: QuantumCircuit, q0: int, q1: int, theta: float\n", + ") -> None:\n", " \"\"\"Apply the parameterized XXZ-type two-qubit gate used in the HVA.\"\"\"\n", " qc.cx(q0, q1)\n", " qc.rz(theta, q1)\n", @@ -328,7 +357,9 @@ " qc.h(q0)\n", "\n", "\n", - "def build_gs_ansatz(n, params, layers):\n", + "def build_gs_ansatz(\n", + " n: int, params: NDArray[np.floating], layers: int\n", + ") -> QuantumCircuit:\n", " \"\"\"Build the Hamiltonian variational ansatz (HVA) circuit for\n", " ground-state preparation of the 1D Heisenberg model.\n", "\n", @@ -392,22 +423,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "58305fbc", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exact ground-state energy: -8.516070\n", - "HVA energy: -8.462051 (exact: -8.516070)\n", - "HVA GS circuit depth: 57\n", - "Built 10 circuits, deepest depth = 226\n", - "Defined 10 Z observables.\n" - ] - } - ], + "outputs": [], "source": [ "import scipy.optimize\n", "\n", @@ -429,7 +448,7 @@ "gs_layers_small = 3\n", "\n", "\n", - "def hva_energy(params):\n", + "def hva_energy(params: NDArray[np.floating]) -> float:\n", " sv = Statevector(build_gs_ansatz(n_small, params, gs_layers_small)).data\n", " return np.real(sv.conj() @ H_mat @ sv)\n", "\n", @@ -1036,4 +1055,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 1abe2486e2d612e6ea6bcd7d3d8c92576888052c Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 23:33:17 +0000 Subject: [PATCH 11/19] google-style docstrings --- .../simulate-neutron-scattering.ipynb | 116 +++++++++++++----- 1 file changed, 83 insertions(+), 33 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 61c1b5876d3..4e4aed8d058 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -130,6 +130,14 @@ " H = 2*J * sum_i [ Jz * Sz_i Sz_{i+1}\n", " + 0.5*(S+_i S-_{i+1} + S-_i S+_{i+1}) ]\n", " = J * sum_i [ Jz/2 * ZZ + 0.5*(XX + YY) ]\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " J: XY coupling strength.\n", + " Jz: Ising coupling strength.\n", + "\n", + " Returns:\n", + " The XXZ Hamiltonian as a SparsePauliOp.\n", " \"\"\"\n", " terms = []\n", " for i in range(n - 1):\n", @@ -147,11 +155,16 @@ "def two_opt(theta_x: float, theta_y: float, theta_z: float) -> QuantumCircuit:\n", " \"\"\"Two-qubit gate implementing exp(-i dt H_pair) for XXZ interactions.\n", "\n", - " Parameters\n", - " ----------\n", - " theta_x, theta_y, theta_z : float\n", - " Rotation angles proportional to the XX, YY, ZZ coupling strengths\n", - " and the Trotter time-step length.\n", + " Args:\n", + " theta_x: Rotation angle proportional to the XX coupling strength\n", + " and the Trotter time-step length.\n", + " theta_y: Rotation angle proportional to the YY coupling strength\n", + " and the Trotter time-step length.\n", + " theta_z: Rotation angle proportional to the ZZ coupling strength\n", + " and the Trotter time-step length.\n", + "\n", + " Returns:\n", + " A 2-qubit QuantumCircuit implementing the Trotter gate.\n", " \"\"\"\n", " qc = QuantumCircuit(2)\n", " qc.cx(0, 1)\n", @@ -183,14 +196,16 @@ ") -> QuantumCircuit:\n", " \"\"\"Build a 2nd-order Trotter circuit for time evolution.\n", "\n", - " Parameters\n", - " ----------\n", - " n : int - number of qubits\n", - " gs_circuit : QuantumCircuit - ground-state preparation circuit\n", - " time_steps : int - number of Trotter steps\n", - " half_t : QuantumCircuit - half-time-step 2Q gate\n", - " full_t : QuantumCircuit - full-time-step 2Q gate\n", - " site : int - perturbation site (center qubit)\n", + " Args:\n", + " n: Number of qubits.\n", + " gs_circuit: Ground-state preparation circuit.\n", + " time_steps: Number of Trotter steps.\n", + " half_t: Half-time-step 2-qubit gate.\n", + " full_t: Full-time-step 2-qubit gate.\n", + " site: Perturbation site (center qubit).\n", + "\n", + " Returns:\n", + " The full Trotter circuit with perturbation applied at ``site``.\n", " \"\"\"\n", " qc = gs_circuit.copy()\n", " qc.rz(np.pi / 2, site) # perturbation\n", @@ -222,13 +237,15 @@ ") -> QuantumCircuit:\n", " \"\"\"Concatenate additional Trotter steps onto an AQC-compressed circuit.\n", "\n", - " Parameters\n", - " ----------\n", - " n : int - number of qubits\n", - " aqc_circuit : QuantumCircuit - AQC-optimized circuit (first few steps)\n", - " time_diff : int - additional Trotter steps to append\n", - " half_t : QuantumCircuit - half-time-step 2Q gate\n", - " full_t : QuantumCircuit - full-time-step 2Q gate\n", + " Args:\n", + " n: Number of qubits.\n", + " aqc_circuit: AQC-optimized circuit covering the first few steps.\n", + " time_diff: Number of additional Trotter steps to append.\n", + " half_t: Half-time-step 2-qubit gate.\n", + " full_t: Full-time-step 2-qubit gate.\n", + "\n", + " Returns:\n", + " The mixed AQC + Trotter circuit.\n", " \"\"\"\n", " qc = aqc_circuit.copy()\n", " if time_diff != 0:\n", @@ -262,6 +279,17 @@ " \"\"\"Compute the dynamical structure factor from the retarded Green's function.\n", "\n", " Uses the center-site approximation and a discrete Fourier transform.\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " Gjjc: RGF matrix of shape ``(time_steps, n)``.\n", + " dt: Trotter time-step size.\n", + " time_steps: Number of time steps.\n", + " q_steps: Number of momentum points.\n", + " w_steps: Number of frequency points.\n", + "\n", + " Returns:\n", + " DSF array of shape ``(w_steps, q_steps)``.\n", " \"\"\"\n", " green = Gjjc / 4 # sigma -> S=1/2\n", " omega_max = np.pi / dt\n", @@ -290,7 +318,15 @@ " w_steps: int,\n", " title: str | None = None,\n", ") -> None:\n", - " \"\"\"Heat-map of the dynamical structure factor.\"\"\"\n", + " \"\"\"Heat-map of the dynamical structure factor.\n", + "\n", + " Args:\n", + " dsf: DSF array of shape ``(w_steps, q_steps)``.\n", + " dt: Trotter time-step size.\n", + " q_steps: Number of momentum points.\n", + " w_steps: Number of frequency points.\n", + " title: Optional plot title.\n", + " \"\"\"\n", " omega_max = np.pi / dt\n", " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", @@ -317,7 +353,15 @@ " dt: float,\n", " title: str | None = None,\n", ") -> None:\n", - " \"\"\"Heat-map of the retarded Green's function in real space and time.\"\"\"\n", + " \"\"\"Heat-map of the retarded Green's function in real space and time.\n", + "\n", + " Args:\n", + " n: Number of qubits (sites).\n", + " Gjjc: RGF matrix of shape ``(time_steps, n)``.\n", + " time_steps: Number of time steps.\n", + " dt: Trotter time-step size.\n", + " title: Optional plot title.\n", + " \"\"\"\n", " fig, ax = plt.subplots(figsize=(8, 6))\n", " qubit_axis = np.arange(n)\n", " t_axis = np.arange(1, time_steps + 1) * dt\n", @@ -342,7 +386,14 @@ "def _apply_xxz_pair_gate(\n", " qc: QuantumCircuit, q0: int, q1: int, theta: float\n", ") -> None:\n", - " \"\"\"Apply the parameterized XXZ-type two-qubit gate used in the HVA.\"\"\"\n", + " \"\"\"Apply the parameterized XXZ-type two-qubit gate used in the HVA.\n", + "\n", + " Args:\n", + " qc: Circuit to modify in place.\n", + " q0: Index of the first qubit.\n", + " q1: Index of the second qubit.\n", + " theta: Variational rotation angle.\n", + " \"\"\"\n", " qc.cx(q0, q1)\n", " qc.rz(theta, q1)\n", " qc.h(q0)\n", @@ -366,11 +417,13 @@ " Starts from a product of singlet pairs and applies alternating\n", " odd/even layers of parameterized XXZ gates.\n", "\n", - " Parameters\n", - " ----------\n", - " n : int - number of qubits (must be even)\n", - " params : array - variational parameters, length 2 * layers\n", - " layers : int - number of HVA layers\n", + " Args:\n", + " n: Number of qubits (must be even).\n", + " params: Variational parameters, length ``2 * layers``.\n", + " layers: Number of HVA layers.\n", + "\n", + " Returns:\n", + " The HVA preparation circuit.\n", " \"\"\"\n", " qc = QuantumCircuit(n)\n", " # Initial singlet product state\n", @@ -385,10 +438,7 @@ " _apply_xxz_pair_gate(qc, 2 * i - 1, 2 * i, params[2 * r])\n", " for i in range(n // 2): # even layer\n", " _apply_xxz_pair_gate(qc, 2 * i, 2 * i + 1, params[2 * r + 1])\n", - " return qc\n", - "\n", - "\n", - "print(\"Setup complete - all functions defined.\")" + " return qc" ] }, { @@ -1055,4 +1105,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 7305a500a288cbc987b512321a794d5734910bf2 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 23:35:11 +0000 Subject: [PATCH 12/19] consistent multiply --- docs/tutorials/simulate-neutron-scattering.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 4e4aed8d058..927a096b109 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -141,9 +141,9 @@ " \"\"\"\n", " terms = []\n", " for i in range(n - 1):\n", - " terms.append((\"ZZ\", [i, i + 1], J * Jz / 2))\n", - " terms.append((\"XX\", [i, i + 1], J * 0.5))\n", - " terms.append((\"YY\", [i, i + 1], J * 0.5))\n", + " terms.append((\"ZZ\", [i, i + 1], 0.5 * J * Jz))\n", + " terms.append((\"XX\", [i, i + 1], 0.5 * J))\n", + " terms.append((\"YY\", [i, i + 1], 0.5 * J))\n", " return SparsePauliOp.from_sparse_list(terms, num_qubits=n)\n", "\n", "\n", From 97b426142b569fad4a4d5327c9056b66e57f3648 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 19:37:36 -0400 Subject: [PATCH 13/19] format --- .../simulate-neutron-scattering.ipynb | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 927a096b109..928362b6346 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -582,9 +582,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -752,9 +751,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -762,9 +760,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -859,9 +856,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -869,9 +865,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -1086,7 +1081,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1100,7 +1095,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.13" + "version": "3" } }, "nbformat": 4, From 6e4fabe6985d610cedb56d562e87cf69599fef3f Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 19:42:14 -0400 Subject: [PATCH 14/19] spell --- docs/tutorials/simulate-neutron-scattering.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 928362b6346..76fc5fd5a42 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -10,7 +10,7 @@ "description: Compute the dynamical structure factor of a quantum magnet using Trotter circuits and MPS simulation.\n", "---\n", "\n", - "{/* cspell:ignore DSFs spinon Cloizeaux DMRG eigsh */}\n", + "{/* cspell:ignore DSFs spinon Cloizeaux DMRG eigsh viridis fontsize vmax vmin Aer's cadetblue */}\n", "\n", "# Simulate neutron scattering in quantum materials with quantum circuits\n", "\n", @@ -328,9 +328,9 @@ " title: Optional plot title.\n", " \"\"\"\n", " omega_max = np.pi / dt\n", - " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", + " q_points = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", - " x, y = np.meshgrid(qpoints, omegas)\n", + " x, y = np.meshgrid(q_points, omegas)\n", " fig, ax = plt.subplots(figsize=(8, 5))\n", " c = ax.pcolormesh(x, y, dsf / np.max(dsf), cmap=\"viridis\", shading=\"auto\")\n", " fig.colorbar(c, ax=ax, label=\"Normalized intensity\")\n", From ffd907859641705094b156188f6db608446a6d9a Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 23:45:53 +0000 Subject: [PATCH 15/19] remove stale images --- .../extracted-outputs/4585d139-0.avif | Bin 24787 -> 0 bytes .../extracted-outputs/4585d139-1.avif | Bin 36047 -> 0 bytes .../extracted-outputs/e78f8d9a-1.avif | Bin 33882 -> 0 bytes .../extracted-outputs/fbe57e1a-1.avif | Bin 27515 -> 0 bytes .../extracted-outputs/fbe57e1a-2.avif | Bin 42642 -> 0 bytes 5 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-0.avif delete mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-1.avif delete mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/e78f8d9a-1.avif delete mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-1.avif delete mode 100644 public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-2.avif diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-0.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/4585d139-0.avif deleted file mode 100644 index d98d7bd5fe999a897725f1e5809e44d3149ad3c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 24787 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 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/e78f8d9a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/e78f8d9a-1.avif deleted file mode 100644 index 5a542ce1fed989788a475c14d9807434249253b6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33882 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 C5)+sJ diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-1.avif deleted file mode 100644 index aa607cb2b54fbf2a9de4ef67e481619cb39df768..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 27515 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 Oa+)z`dbWe_*Z%^tA=pI# diff --git a/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-2.avif b/public/docs/images/tutorials/simulate-neutron-scattering-spectra/extracted-outputs/fbe57e1a-2.avif deleted file mode 100644 index d190feb4506b3d90c1a05215c33e2f9661b4c7b5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 42642 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 Date: Tue, 16 Jun 2026 00:51:17 +0000 Subject: [PATCH 16/19] re-run --- .../simulate-neutron-scattering.ipynb | 55 ++++++++++++------- 1 file changed, 36 insertions(+), 19 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 76fc5fd5a42..57814b71bb4 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "71835ff6", "metadata": {}, "outputs": [], @@ -473,10 +473,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "58305fbc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exact ground-state energy: -8.516070\n", + "HVA energy: -8.462051 (exact: -8.516070)\n", + "HVA GS circuit depth: 57\n", + "Built 10 circuits, deepest depth = 226\n", + "Defined 10 Z observables.\n" + ] + } + ], "source": [ "import scipy.optimize\n", "\n", @@ -572,9 +584,9 @@ " k=3: max bond = 31\n", "\n", "Step 2c — ansatz: 389 parameters, depth = 19\n", - " k=1: fidelity = 1.0000, depth = 19, 11.7s\n", - " k=2: fidelity = 0.9988, depth = 19, 14.9s\n", - " k=3: fidelity = 0.9969, depth = 19, 15.1s\n", + " k=1: fidelity = 1.0000, depth = 19, 11.1s\n", + " k=2: fidelity = 0.9988, depth = 19, 14.6s\n", + " k=3: fidelity = 0.9969, depth = 19, 14.7s\n", "\n", "Step 2d — assembled 10 circuits\n", " Depth at step 10: Trotter = 226, AQC+Trotter = 139\n" @@ -582,8 +594,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -751,8 +764,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -760,8 +774,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -833,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "fbe57e1a", "metadata": {}, "outputs": [ @@ -844,20 +859,21 @@ "Ground-state energy: -8.682473\n", "Built 20 circuits, deepest depth = 440\n", "Ansatz: 1327 parameters, depth = 31\n", - " k=1: fidelity = 0.9648, depth = 31, 63.4s\n", - " k=2: fidelity = 0.8870, depth = 31, 63.0s\n", - " k=3: fidelity = 0.7164, depth = 31, 61.3s\n", + " k=1: fidelity = 0.9648, depth = 31, 61.1s\n", + " k=2: fidelity = 0.8870, depth = 31, 61.6s\n", + " k=3: fidelity = 0.7164, depth = 31, 62.4s\n", " k=4: fidelity = 0.6035, depth = 31, 62.0s\n", " k=5: fidelity = 0.5625, depth = 31, 62.7s\n", "Backend: ibm_marrakesh\n", - "Job 1: d8o7jnrnn5bs738vg43g\n", - "Job 2: d8o7jo832u0s73fdb59g\n" + "Job 1: d8o95mbqv2lc7389p9ag\n", + "Job 2: d8o95mjnn5bs738vhq40\n" ] }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -865,8 +881,9 @@ }, { "data": { + "image/png": "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", "text/plain": [ - "\"Output" + "
" ] }, "metadata": {}, @@ -1081,7 +1098,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1095,7 +1112,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3" + "version": "3.13.13" } }, "nbformat": 4, From 984944f08bf2e64ee14179b2707a2109639b2fc8 Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 20:51:56 -0400 Subject: [PATCH 17/19] run ./fix --- .../simulate-neutron-scattering.ipynb | 19 +++++++----------- .../extracted-outputs/4585d139-0.avif | Bin 0 -> 6380 bytes .../extracted-outputs/4585d139-1.avif | Bin 0 -> 6849 bytes .../extracted-outputs/e78f8d9a-1.avif | Bin 0 -> 6242 bytes .../extracted-outputs/fbe57e1a-1.avif | Bin 0 -> 6737 bytes .../extracted-outputs/fbe57e1a-2.avif | Bin 0 -> 8459 bytes 6 files changed, 7 insertions(+), 12 deletions(-) create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-1.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif create mode 100644 public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-2.avif diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 57814b71bb4..5ce75904944 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -594,9 +594,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -764,9 +763,8 @@ "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -774,9 +772,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -871,9 +868,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -881,9 +877,8 @@ }, { "data": { - "image/png": "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", "text/plain": [ - "
" + "\"Output" ] }, "metadata": {}, @@ -1098,7 +1093,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -1112,7 +1107,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.13" + "version": "3" } }, "nbformat": 4, diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif new file mode 100644 index 0000000000000000000000000000000000000000..3561258d5abae6bda70017a25fdd986b776d0576 GIT binary patch literal 6380 zcmYLtWmuG5*Y*$&-Q7rcNq2WMG}1M+lyv7vcXy|BcSuM`qjU+<-SDFK_Z;8)vDX>v zJg#f)pBn%G5L>!>I+?hGEdg(354L3gi|xTCZyd_W-on-7ul`o=tJ{n z0ASz%0BGemfbInL0RL0q;o;x<|C=ZNE4^*;p9l5V;WcsdkoYURIXm#%J6Tx$JH+|T zz-CVTE}kx~7WOXuZ!=&!u!*xLzloib^}qWf0Xy0M18>o{?O_6;VF1vuA<*x_-ULFh zv&DaFzJ2a3Z1?Yi-j>8Owl_C%#RMQC63{q-d4iw`QQ$cOSQG=Gue$y2^2uta%&`M1z3^x1XUV*2biD+hFdLf@F&}&d@8H^C=+p z>d$(aw*evE{<2Vz`#i$xyBa?rS)90Bond*{msj|fVAh~RS z)(jIx`oQzopxsMhEs5k3&)l0amv4z$U$tLghKMLU!;TGY8TCUmc8u0wa=;>AH}D9% zUVUW>dX?dX4Bp}NC6!*ibP!Sk=F=nOAH85kRYRLo;h#?mOddezQ1`HtO)Lc^;b5;N zRbYDEB4*Tt8A=ysEP;8WF{r#_A;`jIAgAJxeUY{JQJcXggLIv?^v|r+_!RPDB^gH{ z0TtTBw?yZ0`InpwbvvAOB-+VT**;!fv+Z4PN%(^ZS!OYO#v)AAJ3s5Cnncd_Znlph z9M1f-qULAe44SyA?q42x?8QN8lNrATze7Vlx2!g!k`Jq)2nuKyZ5T3TRqYa2 z9a>-K!ti9y-^;R%iy3{#01+lO7Qz+-8`%=!1RG^77peGv9t1E+f6P0Gygrs{8IFo! zTU&-LoO8y?otH1&FY%6V$lRVjUQ44WkNVBY2ZHt#65hokrK%NFke^vP_KYz0hf3J! z_b)MwFcj~4iM$tebr~!|ieZrSms&H*W3T#TsR^n`M$YET>ir4;l>~~Aeqv`MxqS<2Zz+owk8o+q@ zaRtO_syx6%mqqBv{PXhG3^qah!we^XR-^x8tR7dm8@e?0&?C{K_gCh77H;oRI^y1p z#xI5g{4^v|yO}+8l~uB;htKr%Vb5JQ0a(H-CO4nAr)_52E!`Dk*ij)1g@eimbGm^v z)ms(SBKBLUEB414g#90H*Dw7X3XvKGC*LhaSgl%Qjp$$I2JG zA5xfvZu*w`#|Z)x{NFv2D7Ds?$g$DX8D08O5Mj<> z;@HP>0y=~SQaIpW>>{i1BITENDQjZc3N&lAPr}VY6au9)KcX<B<+V~EP1*%WapmI zNde8?Qwhfs%T5ui56};a9*$ugt2fJ*4Uy}1-|@q+fo3PhoD9UGD_vbc5|4An)G;Q% z&9!HzznD6Z_yLpkD7^bs&8~hsR5O}!VYT;ke@SW{pF0;r?Ch#RhB+}&(@eOhc>6q! zW6f*0hvJ&aRpM1F1lk6gC{VGl72(LGEuajKL8qsi7-sy6D_m}+9Qc{qZh852q-V$^ zv_*FV=MN{0ko=@Z)gwiC`#p{Ht8tFb^JN;NUQ+y!NyZjh>mJc9K>Hjovp&%u}OI};yL=5=AVtq4aSOcRR>b$AI zg&vQTwy-rhH7c=HCj*PP6RH@p^XcxzbR|d1MSci0BrYs=8<%+|*%fVtsqi|#?~6(G zQPE&Rf!oJ=PDELJlLJ{JF2fheMh1339^ssF?{%N z<#Yrp{t^T52SnhVQ)~$?y>VE|@_S~Z;Xtd;%g>}qCQM13`(=gu zYRjlBnGO<)cPo>X+c0F~j$yW935$yMsQCw^#Kff5Lm{ml4!TvPPorhAY-Zyg+fo^J zo5Qh5BraRiAz~s0S`oocBPcZliuE2H(zQ(1-jE~rD2~bHW zm`NE|aZqRuSGKLAmgk!#X+(Z!$d-cT&fb?&0XnCV*iOX&m|n7ny0+MiX?~#;)9xxY z8Z;nI-Yc@ms=7L_Q7TVY)h^BnxH>_|`9K9f{-=mP*WK#@FTar7O{qBWxxy>*O2jnG z_s*M|TX6UNCh1Y1Ac}BkE)bn#kDbJPQdFG8=tu|A7VcACY&b)!{}2$pZc>$zzFkCo zbcMB5mOt?VvC0O!-ct1JgWuAsQKn#wjL5RGvwU#r`NZMu?@xC=L!<$_Ui@c88kLqG z+zak%QP9+PZ@hki4x-fcI3uIYyE#u@iGRcrAx)>#q<0VFoeA5ImS%YwpnKp>QU{=s z>`jDqf*DYA159g8l|Lp_!suG}=ktsofD#lSWG$i~m_C>w|1Q2MXgC+rGma|Iw{e`n z=PaYs2vXB22saL4rt0T#mj#px5-A*2!v@ zYqX><9QmcqmA`Z1aXvt*On8I4S6(EFeF1#+8onCu{V7WPOCX-#C{5-|eC z#f<)0JFJ|AO*w(7(awgiK@qlaqY|e-^!F+NS!EGUd88iaw4Nx{5E>@ZS#PDvu+D+@ zrTbCvS8z275bS+jd6xErSPR^SsKnj?c!qT-^Tk0`MC|d$o)KzD;Al-Fbor98olM@} zSU$UG;xcUxU$1>-`CC91SRlZkNjH8%tPzEoZnMGX*nMgL)glKyUbe4J)jqBJkx;8*o4qng$& zI~)za4Yf6Y^ToaA=e#G`CdJkX`;*OsYW+NMpwcar10#|fL~VpH&?p3THGbi=n?lKD zy4!N>aP6oPcRwx}yEn3A1x9T2_T2x4^rWx3jK$)>*WZdLJX*uSOYFI{E9-Y1PJ+>{ zzG?UaM>p}qsuJW@1aq!oy=^yO&+^pPPkki}(L~GVLC|!uiFOc$<@W^Yuf5qo?a{GJ z#tN2#NM}}y*^H}jW+9x(D4+Yi$yYtc&vlR&+o1WRDH zjilQd+hk;CU1uX1>*P!Uc@P29RNy?G{vgJuunEXK=$Dw7(A1cr-kB>Z9@-&muiU`> zw{lhoN_K?P8IonOPGx6R)xTE!Ko_dp^0tC+U=`60 zV<93{Gh#>qmHq5wBXX%0=%JM5BM`0UC0r!VNT>Q z>QEVuN__=Uqy6D7q#-C__^`O$E!!O@e}K?L)*dVBtnR0LrT%&`eHh(3k;5>YPtFRg zABx&zddMmrNt4qmr8)EOap()y>df!%arve9J_V<*s*8o-F6~&dHQJjgOvV81i}AE+r4|3b;3d@ zN-_BQW&b*{GaD-8aIVpLpoLf65a^Jfem<0fX=(eV zFnAYnV-88wefY;nsYuuEGlbkmeXErSqxGr;nl0Njr9@*7es;w9l|pm73-46WUXWXx z^|bg^EFk0orRXidHyCv}c*4}e&T~Y+iL9HQ%-xBQP9d*K7@azs!W!LF;~6ktmh{wB zM)MG1n~|t>k&3%=$bp>--Ni(jmX6uf0(2E!_6leNx7a_AB4hHU8Ti8O_wn+gd12yy zZDXuvf8U?KVo7@`Ue&Q=>|o?_R_VRK<(~O1-QQyiPbW2L-vj$Duqod7(Xa7Ezv7Hp zC02SZP7P*pz9}CGaV&6towMA@(BZj`<9-A~#W3hJ6^95*)z!!c9yhnr3e`7ocXU;f?@|S`4L+%;-yx-GVP{HZ#<kaR$dr2(be$Fp%D3u*C*O5b!C)*B~s@e46VBy zw_CB#U-M(|ruX(_0>ho&8!pw7T=s-`GNmy~@_pbM3Lo=QSNbVFFK8k>CRX<7q&Y4( z>+eT$Z=)Oc%sf?hs~Nk1M{);Uy%9!ys)X?^(JuWJ+_~<;c95tL)hdX$|6c zL5R@GW^OplcEoP^b=I#Y6^3QY_#VtkcI2a{OEybgb#YZ_5-_OlG!<)VuuhU6S3Q}m zmYai9)Ew-6Wrx?jVI6^(}4MMMFW}K&|Bd7AmrUUxgmz9hM0A= zbf8aJ_&S41{YjKna5=QW%G8b?j;dG&8k_o2p?(`2peFAJUd?YZXwS>iEZ66|^en^Yo&;yUsuKX~kOG}P2qal+{h^`e~{yTXy z(ex(`n+|R2$tyuv>BYV}^{fJ_%v;@_w5U#syK7E7feoZ*+??|A?JxCsmaB>x9AcTEm$uH3@X(q2=+r*u?8e~=l&lvV{=$}pOLEBz;(18s%&&{Q|ef_R> zF&Rrtv?6APJ-zN4I1^E(!xNG&jyB|!IchVF5ep|}}k#2_ZeDz$1Mx(RiIOobba~L&ufHR>F6Kgc)S1^@B*2Hv)McLuw^l1mPzC5FuW#TAc%VY*A%rW=1PKwNA0zso437306bt-fWgY%C! zg<6i%=>6!$5?jBfO$%H;f1@C|xtx-veZt8|!g4l9Ka3u_l7@j1pz$%;chE7GTFn0P z_27?fz0ca~Zrz+Aa)>M9+#TUw_E1dxucTgf_OmXJa{zt*re0;RE8ZQEalG3yAlK5D zVr<}NzBgaVt?$z9#cc=AxO=l4q7^+RaVBKsP^w0JYu=zmw!_7q&c-ZyXZu+fg!-L^ zTQWE+e!>a`j5$V3qz@{~IFpwZR>4pD9zzffx3j1Do-W!MLMZR0cu1tN@;VSsntoRr zP?@omYs7RY^OJKSa|GNc2?a?b;{yT6?wMzP>O|`3f(FLNrWyJ(MNSy$yS^QgIk@pK zsD%Q@Ik5ASLXk$OD;U-TtB(|d5Cga2=hw$YdROv?nsBUAo#M*?JXTk?WmZDa<_Yx)0FC{iiSzy4eVy$Cq7ip_9i||Ht7RzeLeiYh z7Y>5Eqky*uakzgE;-R7({BML#^y& zj)9vpDs~{xP`{nBa*(-x+xH7u8i9yKl!;oOT1uxQ%2m+UDzMhVW{JDAQ%}ew^gE5h z1`}E7 zWz=I2WA2{nGishAeECVgf-_^!A71Nxrz?UF0y=;C19X~>?t|3Js^TR_jy)Ci0~-$h zDE>O$7!&n`y$RS!vN1LQ8n(D06a6?-IC(4@x$6ukIK%tKM|N(ax8|f|_$K;~YwHfO zk1dbxS1cQXgmpWdn~$-{9JD{3ESV&K?Aa(w(S49|;Nq z-UyWG<2k)6b66}(=w&%MJ_350C01a#aU~o)270r*c+X|8@&Vj9e3)B?cj1FAp^|9T zQ8+Y`FEy-i_}j7HJY}$7%=6armB`BNyK;x|{@aYlSU#dGu?B&cy%$r*d-!w8@r-r3 zvg97OC{zjl5+&bvY#-wa*O_<6rZ@~P^g1g1C~)Z+HyG-Nc*P2qzRIrPPtB5tcX!c2 zXET2W@6cp~#-*O-Z_g3UHkore+0u&K9$0=M1PASunw zFGdx9wz4;LW{Qjj>Og^xBU%j@@uAb9VO|_DeY76+Bsl%7yGN- zf@ziZpe+Yd%NYV3C^5PUU;3+q0sL{(_i|x9-{ZB0evTm@>A{+;->0h%O&u@EZbsTVGFMr!w^nh;1cXyPl z{d+eQhfj#ceyojw!>_rb4;E=Q?(4I(^%IA1o?`bY_d7^dlp>154DguuyaoBAlu>@@ z^xe%9Y2^ne`cEfM+%Ut=Pq?UWph9=sFXT*_&ZWP9671N?`KQKbbevD_y z+yXGW6##zkD5*X$-&E4P)R;OLn4qxUPqIHc^Y)F*hD02SQ%>pJ$Pv#v^*X#PbkmfC z$ucAfZ=f-J5jZ?gH_T$Bb$FY;hF4M-N9K&p#BDDm zSCCg+SJ9QWq9)oS-IvH>p7bd^eUL663|-S%h%kiF^%&#p`=JkUl%n4~yZUNrEf&;pt zsL|)#x#SCt{3oGAi%4X(-q3ix(YY~2`}jlmlYZy1;Y9}g_bd{96qSDnE; z4iaH-eLR! zWnw;%-%uq)kMn(Z174iOeskRrw_O}6lt~pjcr7g( zF@Cl=40>`B|t zzUtgp&HMKAG>{n$Ap}l%#*RqphJK&-86(*>mhU|h`!MCoD9p3T`$hpehqEF4hK+m@u#(-GY-|})W!2Ty% zm+u8#)eD8+`kPnvm%UK&iC)CAB|K6zEKRqF$HFt4Z{vx0HG|E70Y0g!Hu?@m08+#9O$0N zRXi~}gekeWN7+2xstZ4y@}ja~7g8}L(%Xy^dMugC zbA8<|dd$|YSGWqcZ8TP}KF^KQjq(LWu}9qX9(<(`f-_Zl)N&kWfU6B5_alB%kR4gB19`G{QY7V0 z{2#CYS>kA)xXX1 zV?bF963RZJC#`*FAXTc2RgKgx*JgOEBYba^HgUWkt~hUJHf1_+&a<|zdN%>0tjH@Z z&?gPj+z^jFAV#2s%@I~u5&u~UB5dgj6tk?s(flKc#l&1DUN19+OFv?DkqlSx#Ft*` zy7A3?qlO<|?WlVAVN-GfDHA3sNAhnWrmafvM>SZb8}+h_l1gQxk?3h05xLCTFy!Ye zsN_;QtyXV}o(@p?WmecLt`HL=81NGu$&}~5lZ;U*?Y+a^3#_T8L5P5_H0;F^WaiAT zYBF10j`qk&_O)an z9q?0dtQJG!){Cl8$*?2!i&FTQ%EIMRo=YQNmPsgtEq{U!2pj<|;EXCT4SAg#%7h-- zYy*ReMG0eL}VV{Qyti?`mtc)iGOEoa3$HF5=p(>+F^ z#JO502gR;`8nX&TH>dDV?NuvLof|z8nhtpn)B`uzptc*wOz3D`kD7K`=rz2v<$NC- z+Dg?*E2=6yWca1&&R07w{fPCaH&QsS-1iQ~fb%k96;~4kBbav;F8x)k;i$ooTEGs}RE9EZ7@sZE{! z^KZ7bs4+enk)DsnCQX-9xcC?(XK%E>1}kc8G$b!E`C)yVa%VOLA9L&%um+wb)*yc< zgf`goll$%|y#9olIL&C>rWP+r5n+b9W8B9w`x^yl{yXR9L?KADq(P4tAz!Ae2Cb z<-JLPNZoYK;+K{*lbSOg_UxOqD`MdI`M&Fh&8lttqaF_m1{+2Z@! zG9L*h@tYi%T)0uiM3RbFT2vBXa|LkLy^I9AWKb?7%_h09$*(C8P^0^WZva~_K|L>t z>!gw^E{7OfN|YRy*J(rcmY2MiD_Uj-A&{{9CJ#&S*5Tp<2r5l~kKEN6&nfevufQeC@TIB84 zz{)$gMNEPc_!RS*Ikb}}KM%Y#dVHJL5N}FTjw_|CDLWkQ+BBL8FQhCii*0o$D zq^G+M?Q%MK270j4-NksU+pzedlAgiEw@iZhnWf*>@sLkZpp!0a}f;=4yVX~eo`>|_( zc;Fkrh&oVn3$7%@rqn6aK5`YM-I{}%W)73tLtprn0im#q?y>op^Fme9)q*SORS%U7 z{)Y;P@;$acIEHRG56*N|f93e(-Vrx1G$(JqG4AgjBye<%5|W*v7Dd4<*VpPS>N(@g z;ywVWjco=w!}0F&+&Q*C@&b0)#@j~BWnFyhE|FJ82Jclp4Dwz==0ZW^4oJ{wy8iLx z^>-ItD%QhtE(wYiWN)!@xzR=dG%IHxf(=@Z=~@$JEf1h8=M&goVKQRJzJWqc>Ug#b|qyv!@9cBU8)4 z6Gcn(i4GX#1m3)FvY{u`&E*kW=8{EvI zY8+(|3#76d>96C18>AvgNm3&~hNoreSsik$x6JJKA-Cz=le7*z@C#6|sZ#5R)2Kw* z^&M_w5By{C7tG>_?VJn%*&bQG1k3(LAYbs+fVjE|Cd%H)T$r9KV zN;1Nu;IG4k>*^e3eOh|N<4`1d-iqwUP0_4#p*|yk8!jzq$C@@NTzg-v!mPKF^}fbG;hus zY$9P(LUxtKUWADPk1S9H@*=`Vm;wX8k@Ff)f9@T1UvYyT>46cH9+iShAZ?;CT;-b% zRAzV9?1SYRXG$bjMsx z>A&(ra#KZq;)n*-o#mu$XX1BLr3>#iX_uh~nrng>vTS{3!BX)2jX(e&64^sFJ)2<> zX+XeYl$Vr1l{vsI$}CxgxW&F!^ToOd*gl^zM@%HtNn+-wqyGTVTv$`1UwZXGgS0%W z$1|2Ll>&dUZ0Xl14L_B`?+aT7N6f_hEZk)FRe05Wm&`C1^&&$DK@!nu*okmmq;LF( zf~Aw7P!ve}?o%8i?Qvkn+0WDi`{VXT15Jl?b1Cr1ez`(?W#)3#OP`3Af(3W!7#x1E ze9PLm7;uK}L%u9Ww@wWD(wf(PVn(5xvOC~Xbm%2RuOR!D-ihM(`f<`GZ^2XZNQ+Kh zQGp)h6M$;W}#&~W8VpBe7cb{Q` zJx2~m@qQCm@@z{J5@9AL$`G4PZh-h4!fC%eRa04Qblua5`ENO*9*YuBZ8Dn&^rYAH8D7k2{-7?Z;=^K$G;)2pdJEWdww1mduw zXs|g$^T#q$?MW(S|A4vK*7yb@s^C|N)zavz(@aIcjZCcYG=R%=Z_TDFvf}YDu5R%< z=}bi0uB58rprftf@}1WFUQ9Qdyw5`07mR@ZV{gF;vT5?TKQgF-F8#K-4Ok&{oqYps z0lnXiC*cXy^`9e_AK1}llL+9Jvg~#QNi?&82wWo&Lxh$$4-TvBS99Tk zmE<(&Xr^Kp-$DLW;=4Ju1*#CAPI(;{C zh(KMo7s^G1a=_J}H3aU^K>PRAf#J{2`Aq19u6}`5YiMn=6sv|71kW(eN3YW5 hGL29xExF_(3Z1qtk`6UYDHDx`@4f^z878os{vT6Z<^ccz literal 0 HcmV?d00001 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif new file mode 100644 index 0000000000000000000000000000000000000000..50b0338d18d439bac13f7cc5bd0a5cdfe33672a6 GIT binary patch literal 6242 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 literal 0 HcmV?d00001 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif new file mode 100644 index 0000000000000000000000000000000000000000..3d6627475345b368daa9e706c93a11038d6a5592 GIT binary patch literal 6737 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 XO2P~36$rJ+Y(nXSFnUT|ZtwmNT|J;V literal 0 HcmV?d00001 diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-2.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-2.avif new file mode 100644 index 0000000000000000000000000000000000000000..eee47397c424a6c56ea04562c390c705af04c7ec GIT binary patch literal 8459 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 literal 0 HcmV?d00001 From 0d7b021c3a5acb6abc46616fa362ec94dc65e15a Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Mon, 15 Jun 2026 21:05:12 -0400 Subject: [PATCH 18/19] rename variables --- .../simulate-neutron-scattering.ipynb | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index 5ce75904944..bcf52037b28 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "71835ff6", "metadata": {}, "outputs": [], @@ -270,7 +270,7 @@ "\n", "def get_dsf(\n", " n: int,\n", - " Gjjc: NDArray[np.floating],\n", + " rgf_mat: NDArray[np.floating],\n", " dt: float,\n", " time_steps: int,\n", " q_steps: int,\n", @@ -282,7 +282,7 @@ "\n", " Args:\n", " n: Number of qubits (sites).\n", - " Gjjc: RGF matrix of shape ``(time_steps, n)``.\n", + " rgf_mat: RGF matrix of shape ``(time_steps, n)``.\n", " dt: Trotter time-step size.\n", " time_steps: Number of time steps.\n", " q_steps: Number of momentum points.\n", @@ -291,16 +291,16 @@ " Returns:\n", " DSF array of shape ``(w_steps, q_steps)``.\n", " \"\"\"\n", - " green = Gjjc / 4 # sigma -> S=1/2\n", + " green = rgf_mat / 4 # sigma -> S=1/2\n", " omega_max = np.pi / dt\n", - " qpoints = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", + " q_points = np.arange(0, 2 * np.pi, 2 * np.pi / q_steps)\n", " omegas = np.arange(0, omega_max, omega_max / w_steps)\n", - " green_map = np.zeros((omegas.shape[0], qpoints.shape[0]))\n", + " green_map = np.zeros((omegas.shape[0], q_points.shape[0]))\n", " center = n // 2 - 1\n", " for iw, w in enumerate(omegas):\n", " exponent = np.exp(1j * w * dt * np.arange(1, time_steps + 1))\n", " S_w = np.dot(green.T, exponent) * dt\n", - " for iq, q in enumerate(qpoints):\n", + " for iq, q in enumerate(q_points):\n", " q_matrix = np.exp(-1j * q * np.arange(-center, center + 2, 1))\n", " green_map[iw, iq] = np.imag(np.dot(S_w, q_matrix))\n", " return green_map\n", @@ -348,7 +348,7 @@ "\n", "def plot_rgf(\n", " n: int,\n", - " Gjjc: NDArray[np.floating],\n", + " rgf_mat: NDArray[np.floating],\n", " time_steps: int,\n", " dt: float,\n", " title: str | None = None,\n", @@ -357,7 +357,7 @@ "\n", " Args:\n", " n: Number of qubits (sites).\n", - " Gjjc: RGF matrix of shape ``(time_steps, n)``.\n", + " rgf_mat: RGF matrix of shape ``(time_steps, n)``.\n", " time_steps: Number of time steps.\n", " dt: Trotter time-step size.\n", " title: Optional plot title.\n", @@ -367,7 +367,7 @@ " t_axis = np.arange(1, time_steps + 1) * dt\n", " x, y = np.meshgrid(qubit_axis, t_axis)\n", " c = ax.pcolormesh(\n", - " x, y, np.real(Gjjc), cmap=\"RdBu\", vmax=0.5, vmin=-0.5, shading=\"auto\"\n", + " x, y, np.real(rgf_mat), cmap=\"RdBu\", vmax=0.5, vmin=-0.5, shading=\"auto\"\n", " )\n", " fig.colorbar(c, ax=ax, label=r\"Re $G^R(j, j_c, t)$\")\n", " ax.set_xlabel(\"Qubit\", fontsize=16)\n", @@ -715,7 +715,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "b8f9e41c", "metadata": {}, "outputs": [ @@ -731,18 +731,18 @@ ], "source": [ "estimator = StatevectorEstimator()\n", - "Gjjc_small = np.zeros((time_steps_small, n_small))\n", + "rgf_mat = np.zeros((time_steps_small, n_small))\n", "\n", "for t_idx, qc in enumerate(all_circuits_small):\n", " pub = (qc, observables_small)\n", " job = estimator.run([pub])\n", " result = job.result()\n", - " Gjjc_small[t_idx, :] = result[0].data.evs\n", + " rgf_mat[t_idx, :] = result[0].data.evs\n", "\n", " if (t_idx + 1) % 5 == 0:\n", " print(f\" Completed time step {t_idx + 1}/{time_steps_small}\")\n", "\n", - "print(f\"RGF matrix shape: {Gjjc_small.shape}\")" + "print(f\"RGF matrix shape: {rgf_mat.shape}\")" ] }, { @@ -757,7 +757,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "4585d139", "metadata": {}, "outputs": [ @@ -793,7 +793,7 @@ "# -- Compute DSF --\n", "q_res, w_res = 100, 100\n", "spectrum_small = get_dsf(\n", - " n_small, Gjjc_small, dt, time_steps_small, q_res, w_res\n", + " n_small, rgf_mat, dt, time_steps_small, q_res, w_res\n", ")\n", "spectrum_small = -(spectrum_small + spectrum_small[:, ::-1]) / 2\n", "spectrum_small = np.clip(spectrum_small, a_min=0, a_max=None)\n", @@ -801,7 +801,7 @@ "# -- Plot retarded Green's function --\n", "plot_rgf(\n", " n_small,\n", - " Gjjc_small,\n", + " rgf_mat,\n", " time_steps_small,\n", " dt,\n", " title=f\"Retarded Green's function — {n_small} qubits (simulation)\",\n", @@ -1042,23 +1042,23 @@ "result_1 = job_1.result()\n", "result_2 = job_2.result()\n", "\n", - "Gjjc_large = np.zeros((time_steps_large, n_large))\n", + "rgf_mat = np.zeros((time_steps_large, n_large))\n", "for i in range(mid):\n", - " Gjjc_large[i, :] = result_1[i].data.evs[::-1]\n", + " rgf_mat[i, :] = result_1[i].data.evs[::-1]\n", "for i in range(time_steps_large - mid):\n", - " Gjjc_large[mid + i, :] = result_2[i].data.evs[::-1]\n", + " rgf_mat[mid + i, :] = result_2[i].data.evs[::-1]\n", "\n", "# ── Step 4: Post-process ──────────────────────────────────────────────────────\n", "q_res, w_res = 100, 100\n", "spectrum_large = get_dsf(\n", - " n_large, Gjjc_large, dt, time_steps_large, q_res, w_res\n", + " n_large, rgf_mat, dt, time_steps_large, q_res, w_res\n", ")\n", "spectrum_large = -(spectrum_large + spectrum_large[:, ::-1]) / 2\n", "spectrum_large = np.clip(spectrum_large, a_min=0, a_max=None)\n", "\n", "plot_rgf(\n", " n_large,\n", - " Gjjc_large,\n", + " rgf_mat,\n", " time_steps_large,\n", " dt,\n", " title=f\"Retarded Green's function — {n_large} qubits (QPU)\",\n", From ca1ab5758bceab50bb7ed600f1a0a9adb12522bf Mon Sep 17 00:00:00 2001 From: "Kevin J. Sung" Date: Tue, 16 Jun 2026 16:49:54 +0000 Subject: [PATCH 19/19] change factor of 2 convention --- .../simulate-neutron-scattering.ipynb | 62 +++++++++--------- .../extracted-outputs/4585d139-0.avif | Bin 6380 -> 6415 bytes .../extracted-outputs/4585d139-1.avif | Bin 6849 -> 6880 bytes .../extracted-outputs/e78f8d9a-1.avif | Bin 6242 -> 6279 bytes .../extracted-outputs/fbe57e1a-1.avif | Bin 6737 -> 6553 bytes .../extracted-outputs/fbe57e1a-2.avif | Bin 8459 -> 8091 bytes 6 files changed, 32 insertions(+), 30 deletions(-) diff --git a/docs/tutorials/simulate-neutron-scattering.ipynb b/docs/tutorials/simulate-neutron-scattering.ipynb index bcf52037b28..068a6de2501 100644 --- a/docs/tutorials/simulate-neutron-scattering.ipynb +++ b/docs/tutorials/simulate-neutron-scattering.ipynb @@ -52,7 +52,7 @@ "\n", "Potassium copper fluoride (KCuF$_3$) is a quasi-one-dimensional antiferromagnet in which chains of spin-$\\frac{1}{2}$ Cu$^{2+}$ ions interact via a nearest-neighbor Heisenberg exchange $J \\approx 34\\;\\mathrm{meV}$, while the interchain coupling is only $\\sim 2.7\\%$ of $J$. At $T = 6\\;\\mathrm{K}$ where INS data are available, the spectrum is dominated by fractionalized spinon excitations characteristic of a Tomonaga-Luttinger liquid. Because the intrachain dynamics are well described by the one-dimensional spin-$\\frac{1}{2}$ XXZ Hamiltonian at the isotropic point ($\\epsilon = 1$),\n", "\n", - "$$H = 2J\\sum_{i}\\left[S_i^Z S_{i+1}^Z + \\epsilon\\left(S_i^X S_{i+1}^X + S_i^Y S_{i+1}^Y\\right)\\right],$$\n", + "$$H = J\\sum_{i}\\left[S_i^Z S_{i+1}^Z + \\epsilon\\left(S_i^X S_{i+1}^X + S_i^Y S_{i+1}^Y\\right)\\right],$$\n", "\n", "KCuF$_3$ serves as an ideal benchmark for quantum simulation: the Hamiltonian is simple enough to implement on a quantum processor, yet the ground state is strongly entangled and the excitation spectrum features a broad two-spinon continuum.\n", "\n", @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "71835ff6", "metadata": {}, "outputs": [], @@ -127,9 +127,9 @@ ") -> SparsePauliOp:\n", " \"\"\"Build the 1D XXZ Hamiltonian as a SparsePauliOp (open boundary).\n", "\n", - " H = 2*J * sum_i [ Jz * Sz_i Sz_{i+1}\n", + " H = J * sum_i [ Jz * Sz_i Sz_{i+1}\n", " + 0.5*(S+_i S-_{i+1} + S-_i S+_{i+1}) ]\n", - " = J * sum_i [ Jz/2 * ZZ + 0.5*(XX + YY) ]\n", + " = J/4 * sum_{nn pair} [ Jz * ZZ + (XX + YY) ]\n", "\n", " Args:\n", " n: Number of qubits (sites).\n", @@ -141,9 +141,9 @@ " \"\"\"\n", " terms = []\n", " for i in range(n - 1):\n", - " terms.append((\"ZZ\", [i, i + 1], 0.5 * J * Jz))\n", - " terms.append((\"XX\", [i, i + 1], 0.5 * J))\n", - " terms.append((\"YY\", [i, i + 1], 0.5 * J))\n", + " terms.append((\"ZZ\", [i, i + 1], 0.25 * J * Jz))\n", + " terms.append((\"XX\", [i, i + 1], 0.25 * J))\n", + " terms.append((\"YY\", [i, i + 1], 0.25 * J))\n", " return SparsePauliOp.from_sparse_list(terms, num_qubits=n)\n", "\n", "\n", @@ -367,7 +367,13 @@ " t_axis = np.arange(1, time_steps + 1) * dt\n", " x, y = np.meshgrid(qubit_axis, t_axis)\n", " c = ax.pcolormesh(\n", - " x, y, np.real(rgf_mat), cmap=\"RdBu\", vmax=0.5, vmin=-0.5, shading=\"auto\"\n", + " x,\n", + " y,\n", + " np.real(rgf_mat),\n", + " cmap=\"RdBu\",\n", + " vmax=0.5,\n", + " vmin=-0.5,\n", + " shading=\"auto\",\n", " )\n", " fig.colorbar(c, ax=ax, label=r\"Re $G^R(j, j_c, t)$\")\n", " ax.set_xlabel(\"Qubit\", fontsize=16)\n", @@ -481,8 +487,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Exact ground-state energy: -8.516070\n", - "HVA energy: -8.462051 (exact: -8.516070)\n", + "Exact ground-state energy: -4.258035\n", + "HVA energy: -4.231026 (exact: -4.258035)\n", "HVA GS circuit depth: 57\n", "Built 10 circuits, deepest depth = 226\n", "Defined 10 Z observables.\n" @@ -584,9 +590,9 @@ " k=3: max bond = 31\n", "\n", "Step 2c — ansatz: 389 parameters, depth = 19\n", - " k=1: fidelity = 1.0000, depth = 19, 11.1s\n", - " k=2: fidelity = 0.9988, depth = 19, 14.6s\n", - " k=3: fidelity = 0.9969, depth = 19, 14.7s\n", + " k=1: fidelity = 1.0000, depth = 19, 11.7s\n", + " k=2: fidelity = 0.9987, depth = 19, 14.6s\n", + " k=3: fidelity = 0.9960, depth = 19, 15.4s\n", "\n", "Step 2d — assembled 10 circuits\n", " Depth at step 10: Trotter = 226, AQC+Trotter = 139\n" @@ -715,7 +721,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "b8f9e41c", "metadata": {}, "outputs": [ @@ -757,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "4585d139", "metadata": {}, "outputs": [ @@ -792,9 +798,7 @@ "source": [ "# -- Compute DSF --\n", "q_res, w_res = 100, 100\n", - "spectrum_small = get_dsf(\n", - " n_small, rgf_mat, dt, time_steps_small, q_res, w_res\n", - ")\n", + "spectrum_small = get_dsf(n_small, rgf_mat, dt, time_steps_small, q_res, w_res)\n", "spectrum_small = -(spectrum_small + spectrum_small[:, ::-1]) / 2\n", "spectrum_small = np.clip(spectrum_small, a_min=0, a_max=None)\n", "\n", @@ -845,7 +849,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "fbe57e1a", "metadata": {}, "outputs": [ @@ -856,14 +860,14 @@ "Ground-state energy: -8.682473\n", "Built 20 circuits, deepest depth = 440\n", "Ansatz: 1327 parameters, depth = 31\n", - " k=1: fidelity = 0.9648, depth = 31, 61.1s\n", - " k=2: fidelity = 0.8870, depth = 31, 61.6s\n", - " k=3: fidelity = 0.7164, depth = 31, 62.4s\n", - " k=4: fidelity = 0.6035, depth = 31, 62.0s\n", - " k=5: fidelity = 0.5625, depth = 31, 62.7s\n", - "Backend: ibm_marrakesh\n", - "Job 1: d8o95mbqv2lc7389p9ag\n", - "Job 2: d8o95mjnn5bs738vhq40\n" + " k=1: fidelity = 0.9648, depth = 31, 58.5s\n", + " k=2: fidelity = 0.8870, depth = 31, 57.7s\n", + " k=3: fidelity = 0.7162, depth = 31, 56.4s\n", + " k=4: fidelity = 0.6036, depth = 31, 57.3s\n", + " k=5: fidelity = 0.5632, depth = 31, 58.4s\n", + "Backend: ibm_fez\n", + "Job 1: d8ont10q90bc73e6qfpg\n", + "Job 2: d8ont1gq90bc73e6qfqg\n" ] }, { @@ -1050,9 +1054,7 @@ "\n", "# ── Step 4: Post-process ──────────────────────────────────────────────────────\n", "q_res, w_res = 100, 100\n", - "spectrum_large = get_dsf(\n", - " n_large, rgf_mat, dt, time_steps_large, q_res, w_res\n", - ")\n", + "spectrum_large = get_dsf(n_large, rgf_mat, dt, time_steps_large, q_res, w_res)\n", "spectrum_large = -(spectrum_large + spectrum_large[:, ::-1]) / 2\n", "spectrum_large = np.clip(spectrum_large, a_min=0, a_max=None)\n", "\n", diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/4585d139-0.avif index 3561258d5abae6bda70017a25fdd986b776d0576..ff664325c79f3bcdcee95fb145d0f7afd5e1c89a 100644 GIT binary patch delta 6086 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 MnH%%#6ZM`E#M4%;2LJ#7 delta 6043 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 TAeFwFY`_u#3I`b`lfnT!n&Iln diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/e78f8d9a-1.avif index 50b0338d18d439bac13f7cc5bd0a5cdfe33672a6..b7a12c838a5b75d900fd6a10d3595dc3babab627 100644 GIT binary patch delta 215 zcmaE4&~B)}z`!7rR#I7zSeBUvWHW&1+{`q?+{{EEpK-=S1rKE=kObo%21XDK1SSv` z;|G|C*z}3r*4o!I3yKPW(i<}ilJkMIaB_Z5QC@OR1p^ZhvNZsOcoNGDof{ctCf<{n zEX3$G@tT3HTxLOTB2Wqhm>3vY8r#@A7?@a^m|I$bB2t+}sbF^j*?ftm6*(X^AZx`g d=cXiE=&Lb delta 170 zcmZoSd}N@&z`!7rR#I7zSeBUvWHaPurWu0RxtWPTK4ZZ|1rKFLkObot1~ARQAU2DE z2_zz+2NPj1nb>X3yFRm^r~oM5m06ISKiP-Tn3E^5%+R@!QHEhM8>6R`Y-T}jB1j_; zFflMPH!?9ZFtM~Sv9?W~#V9LuEjJ~xM2LZlOCn8MMw^AjL~8Rd#$K_>dl*ds_(miH diff --git a/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif b/public/docs/images/tutorials/simulate-neutron-scattering/extracted-outputs/fbe57e1a-1.avif index 3d6627475345b368daa9e706c93a11038d6a5592..cf175c90574660d05147080d74a9d596e90b6b04 100644 GIT binary patch delta 6174 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 y>5lN-`fe)o^Rf9I0001rX>en2lS~0K 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 EJdaq>Hvj+t