From 93cd24a32187553470518e724b233b1f974a787a Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Sun, 19 Oct 2025 12:18:19 +0300 Subject: [PATCH 1/7] added qlbm files --- applications/cfd/qlbm/qlbm.ipynb | 1442 +++++++++++++++++ applications/cfd/qlbm/qlbm.qmod | 147 ++ .../cfd/qlbm/qlbm.synthesis_options.json | 44 + tests/resources/timeouts.yaml | 2 + 4 files changed, 1635 insertions(+) create mode 100644 applications/cfd/qlbm/qlbm.ipynb create mode 100644 applications/cfd/qlbm/qlbm.qmod create mode 100644 applications/cfd/qlbm/qlbm.synthesis_options.json diff --git a/applications/cfd/qlbm/qlbm.ipynb b/applications/cfd/qlbm/qlbm.ipynb new file mode 100644 index 000000000..3a89c605e --- /dev/null +++ b/applications/cfd/qlbm/qlbm.ipynb @@ -0,0 +1,1442 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0", + "metadata": {}, + "source": [ + "# Quantum Lattice Boltzmann Method\n", + "\n", + "\n", + "The Quantum Lattice Boltzmann Method (QLBM) brings the ideas of the classical lattice Boltzmann method into the quantum computing framework.\n", + "In this notebook, we introduce the background concepts, explain how the classical method works, and motivate why a quantum version can help overcome some of its limitations. We exemplify the algorithm by analyzing a collisionless model example is inspired by the work of Schalkers and Moller [1].\n", + "\n", + "## Background\n", + " Fluid dynamics are commonly well characterized by the famous Navier-Stokes equations - a set of non-linear coupled partial differential equations. Due to the non-linearity and multiscale nature of the dynamics, a precise solution for practical systems requires infeasible numerical resources (for further details see the technical supplementary at the bottom). \n", + " \n", + "Instead of working directly with the macroscopic fluid equations, one can take a microscopic viewpoint: Fluids are modeled as collections of particles and their behavior is described statistically, using the Boltzmann transport equation. A solution to the dynamics of the distribution function can be obtained by employing the (classical) Lattice Boltzmann Method (LBM).\n", + "\n", + " \n", + "\n", + "## Lattice Boltzmann Method (LBM)\n", + "The Lattice Boltzmann Method simplifies the complex dynamics over the whole of phase space by replacing the velocity distribution with a discrete set of velocities, $\\{\\mathbf{v}_i\\}$. Each lattice site $\\mathbf{x}$ is characterized by a vector of distributions $f_i(\\mathbf{x})$, representing the number of particles at that point with a velocity $\\mathbf{v}_i$. The distributions evolve according to a discretized version of the Boltzmann transport equation.\n", + "\n", + "Within the simplified description, the evolution is dictated by three distinct processes:\n", + "1. Streaming: distributions move along the velocity directions to neighboring lattice sites $$ f_i(\\mathbf{x} +\\mathbf{v}_{i},t +\\Delta t) = f_i (\\mathbf{x},t) $$.\n", + "2. Collision: distribution of each site relaxes to equilibrium $$ f_i(\\mathbf{x}, t) = f_i(\\mathbf{x},t) - \\Gamma (f^{eq}_i(\\mathbf{x},t) - f_i(\\mathbf{x},t))~~,$$ where $\\Gamma$ is the relaxation rate.\n", + "3. Specular Reflection: particles reaching the boundary walls or obstacles reflect off them. \n", + "\n", + "We can approximate the microscopic dynamics by repeating these steps over small time intervals. Moreover, for sufficiently small lattice spacing the results converge to the hydrodynamic variables of the Navier–Stokes equations for an incompressible isothermal fluid.\n", + " For example, the density and velocity density can be expressed as\n", + "$$ \\rho(\\mathbf{x},t) = \\sum_i f_i(\\mathbf{x},t)~~~,~~~\\rho \\mathbf{u}(\\mathbf{x},t) = \\sum_i f_i(\\mathbf{x},t) \\mathbf{v}_i ~~,$$\n", + "where $\\mathbf{u}$ is the (macroscopic) velocity field.\n", + "\n", + "The method enables a local description that can be efficiently parallelized, incorporates complex boundary conditions, and can be extended to other dynamical problems, such as heat transport and magnetohydrodynamics.\n", + "\n", + "### Challenges in the classical approach\n", + "Despite the simplification, all classical solvers face several fundamental challenges:\n", + "- The number of lattice sites required to accurately describe turbulence scales unfavorably with the Reynolds number. As a result, for realistic turbulence, the cost becomes prohibitive.\n", + "- Numerical instabilities can appear at high resolutions.\n", + "- For 3D systems of interest, the required number of lattice sites may be trillions.\n", + "\n", + "The quantum Boltzmann lattice method is motivated by these challenges.\n", + "Quantum computers have the potential to bypass the scaling issues, offering potential exponential or polynomial speedups in simulating fluid dynamics.\n", + "This opens the door to study regimes that are entirely out of reach for classical solvers." + ] + }, + { + "cell_type": "markdown", + "id": "1", + "metadata": {}, + "source": [ + "## Quantum Lattice Boltzmann Method\n", + "\n", + "In the Quantum Lattice Boltzmann Method (QLBM) the distributions $\\{f_i\\}$ are encoded in the amplitudes $\\psi_{\\mathbf{x},i}(0)$ of a quantum wavefunction $\n", + "\\ket{\\Psi}$, while the streaming, collision and reflections are achieved by application of unitary transformations.\n", + "\n", + "The algorithm is composed of three stages:\n", + "1. Initialization - the initial classical distributions and velocities are mapped to separate qubit registers. The $N$ lattice sites, and $V$ velocities are represented by the possible configurations of $\\log(N)$ \"positional\" registers and $\\log(V)$ \"velocity\" registers.\n", + " $$ \\ket{\\Psi(0)} = \\sum_{\\mathbf{x},\\mathbf{v}} \\psi_{\\mathbf{xv}}(0) \\ket{\\mathbf{x}} \\otimes \\ket{\\mathbf{v}}~~.$$ \n", + "2. Evolution - repeated operatortion of $U_{\\Delta t} = U_{\\text{ref}} U_{\\text{str}}$ propagates the state in time $$ \\ket{\\Psi(t = n\\Delta t)} = (U_{\\Delta t})^n \\ket{\\Psi (0)}~~.$$ Streaming and reflections are obtained by a conditional shift operator, inducing the mapping: $\\ket{\\mathbf{x}}\\otimes \\ket{\\mathbf{v}} \\rightarrow \\ket{\\mathbf{x} + \\mathbf{v}\\Delta t} \\otimes \\ket{\\mathbf{v}}$, while collision can be performed by local rotations which mix the velocity states at each site.\n", + "3. Readout - measurement in the computational basis.\n", + "\n", + "Repeating the experiment many times allows us to infer statistical averages, corresponding to the macroscopic hydrodynamic variables.\n" + ] + }, + { + "cell_type": "markdown", + "id": "2", + "metadata": {}, + "source": [ + "## Simulation of a Collisionless Model with Classiq\n", + "\n", + "As a conceptual example, we consider a collisionless model in which the particle distribution evolves according to repeated streaming and reflection operations. " + ] + }, + { + "cell_type": "markdown", + "id": "3", + "metadata": {}, + "source": [ + "We begin by defining the encoding of the initial distribution in the quantum register" + ] + }, + { + "cell_type": "markdown", + "id": "4", + "metadata": {}, + "source": [ + "### State encoding\n", + "The set of classical states are encoded in quantum states of the form\n", + "$$\\ket{ֿֿ\\text{grid|velocity}}=\\ket{g_x g_y| v_{\\text{dir},x} u_x v_{\\text{dir},y} u_y}~~,$$ where \n", + "the grid ($g_x$, $g_y$) and velocity magnitude ($u_x$, $u_y$) variables are encoded as QNum variables, and the velocity directions ($v_{\\text{dir},x}$, $v_{\\text{dir},y}$) are encoded as standard qubits. The QNum's allow a straight forward implemintation of shift operations, while the velocity directional encoding enables flipping the direciton in the $i$'th dimension by application of a single NOT operation on $v_{\\text{dir},i}$.\n", + "\n", + "### Time evolution: \n", + "The time-step is composed from two operations:\n", + "1. Streaming: particles move one lattice site if there speed allows it (descretized via CFL-based-schedule)\n", + "2. Reflection: partilces hitting the obstacle are specularly reflected—direction is flipped, and they are pushed back into the domain.\n", + "\n", + "We condiser periodic boundary conditions in space, while the obstacle is placed between selected lattice sites, acting as a perfectly reflecting wall. The obstacle is placed within the lattice forming a barrier around the center of the grid.\n" + ] + }, + { + "cell_type": "markdown", + "id": "5", + "metadata": {}, + "source": [ + "The quantum initial part of the circuit is of the form:" + ] + }, + { + "attachments": { + "707b125d-b9c2-4fbf-ba83-0aebaa224c46.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "6", + "metadata": {}, + "source": [ + "![main.png](attachment:707b125d-b9c2-4fbf-ba83-0aebaa224c46.png)" + ] + }, + { + "cell_type": "markdown", + "id": "7", + "metadata": {}, + "source": [ + "#### Initial condition\n", + "We start with a uniform velocity distribution located at a single grid point left of the obstacle.\n", + "\n", + "### Observables\n", + "After running the quantum circuit, we measure the\n", + "- spatial distribution $p(x)$ - probability to find a particle at each site\n", + "- velocity distribution $p(u)$ - propability over velocity magnitudes" + ] + }, + { + "cell_type": "markdown", + "id": "8", + "metadata": {}, + "source": [ + "Next, we evaluate the scheduling function employed in the streaming and initialize the initial distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "9", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Tuple\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from classiq import *" + ] + }, + { + "cell_type": "markdown", + "id": "10", + "metadata": {}, + "source": [ + "### Schedulling function" + ] + }, + { + "cell_type": "markdown", + "id": "11", + "metadata": {}, + "source": [ + "A classical time-series function implements a CFL counter, tracking the velocity magnitudes streamed at each time-step. The time steps duration are set such that at each step the distributions $f_i(\\mathbf{x})$ will at most transition to a neighboring lattice site. As a consequence, the durations generally vary between time-steps.\n", + "\n", + "To evaluate the streamed velocities we first need to compute the time interval after the $m$'th time-steps, $\\Delta t^m$. To this end, consider a distribution $f_i(\\mathbf{x})$ at a time-step $m$ at position $x_m$, advancing with a speed $u_k$ away from a lattice site at $x_0$. The fraction of the distance from the lattice site in the following time-step can be expressed as $$c^{m+1}_k = \\frac{x_m + |u_k| \\Delta t^m -x_0}{\\Delta x} = c^{m}_k + |u_k|\\frac{\\Delta t^m} {\\Delta x}~~,$$ where $\\Delta x$ is the lattice spacing.\n", + "\n", + "If particles may only travel to the nearest lattice site during a single time-step, to evaluate $\\Delta t^m$, we set $c^{m+1}_k = 1$, leading to\n", + "$ \\Delta t^{m} = (1-c^m_k)\\frac{\\Delta x}{|u_k|}$.\n", + "\n", + "Finally, for multiple possible velocities, the limiting time step is evaluated by minimizing over all velocity magnitudes\n", + "$$ \\Delta t^{m} = \\min_{k}(1-c^m_k)\\frac{\\Delta x}{|u_k|}~~.$$\n", + "\n", + "Utilizing $\\Delta t^{m}$ we can evaluate $c^{m}_k$ for all velocites and determine which distributions have reached a lattice site.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "12", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "def time_series(\n", + " discrete_velocities: np.ndarray,\n", + " time: float = 10.0,\n", + " tolerance: float = 1e-6,\n", + " max_iters: int = 10**3,\n", + ") -> List[List[int]]:\n", + " \"\"\"\n", + " Implements a CFL counter, evaluating the time series of streaming velocities for a discrete set of velocities\n", + "\n", + " Parameters:\n", + " discrete_velocities: list,\n", + " time: float, simulation time\n", + " tolerance: float,\n", + " max_iters: int, maximum number of propagation steps\n", + "\n", + " Returns:\n", + " schedule: List[List[int]], each list dictates the velocities streamed at the corresponding time step.\n", + " accumulated_time: float, total time duration of the simulation\n", + " \"\"\"\n", + "\n", + " num_discrete_velocities = discrete_velocities.shape[0]\n", + " velocity_magnitudes = np.array(sorted(set((np.abs(discrete_velocities).tolist()))))\n", + "\n", + " # Assumes that velocity magnitudes are the same in all directions\n", + " M = discrete_velocities.shape[0] // 2 + (discrete_velocities.shape[0] % 2)\n", + "\n", + " # Track the \"progress\" of each distribution towards the next grid point\n", + " cfl_counter = np.zeros(M)\n", + " inverse_velocities = 1 / velocity_magnitudes\n", + " ones = np.ones(M)\n", + "\n", + " # Contains the velocities to be streamed at for each time step\n", + " schedule: List[List[int]] = []\n", + "\n", + " # Accumulated time\n", + " accumulated_time = 0\n", + "\n", + " #\n", + " for _ in range(max_iters):\n", + " # The \"ground\" covered by each velocity magnitude after this step\n", + " time_intervals = np.multiply(ones - cfl_counter, inverse_velocities)\n", + "\n", + " # The minimum of time_intervals dictates which velocity limits the time step such that in the next step\n", + " # the associated distribution will reach the next grid point\n", + " min_time_interval = time_intervals[np.argmin(time_intervals)]\n", + "\n", + " # Update the accumulated time\n", + " accumulated_time += min_time_interval\n", + "\n", + " # Update the progress of each velocity\n", + " cfl_counter += min_time_interval * velocity_magnitudes\n", + "\n", + " # Get the indices of the velocities that have reached the next grid point\n", + " streamed = np.squeeze(\n", + " np.argwhere(np.isclose(cfl_counter, 1.0, tolerance)), axis=1\n", + " )\n", + "\n", + " # Reset the progress of the velocities streamed at this time step\n", + " cfl_counter[streamed] = 0.0\n", + "\n", + " # Track the controlled velocities\n", + " schedule.append(streamed.tolist())\n", + "\n", + " n_mag_bits = int(np.ceil(np.log2(M))) if M > 1 else 1\n", + "\n", + " if accumulated_time >= time:\n", + " break\n", + "\n", + " return schedule, accumulated_time" + ] + }, + { + "cell_type": "markdown", + "id": "13", + "metadata": {}, + "source": [ + "## Initialization" + ] + }, + { + "cell_type": "markdown", + "id": "14", + "metadata": {}, + "source": [ + "We initialize the model parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "15", + "metadata": {}, + "outputs": [], + "source": [ + "def num_bits(n):\n", + " \"\"\"Returns the number of bits required to represent n numbers\"\"\"\n", + " return int(np.ceil(np.log2(n)))\n", + "\n", + "\n", + "# Grid parameters\n", + "n_g_i = 8\n", + "n_g_i_bits = num_bits(n_g_i)\n", + "\n", + "# Velocities\n", + "discrete_velocities = np.array([-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0])\n", + "\n", + "# Velocity magnitudes\n", + "u = np.unique(np.abs(discrete_velocities))\n", + "n_u_i = u.shape[0]\n", + "n_u_i_bits = num_bits(\n", + " n_u_i\n", + ") # number of bits required to represent the magnitudes in the x and y directions" + ] + }, + { + "cell_type": "markdown", + "id": "16", + "metadata": {}, + "source": [ + "The quantum register is conveniently stored within a QStruct variable. The customized object will allow simple and direct access the different registers." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "17", + "metadata": {}, + "outputs": [], + "source": [ + "class PhaseSpaceStruct(QStruct):\n", + " \"\"\"Wrapping class including all the quantum variables\"\"\"\n", + "\n", + " # Grid variables\n", + " g_x: QNum[n_g_i_bits, UNSIGNED, 0] # x-axis grid register\n", + " g_y: QNum[n_g_i_bits, UNSIGNED, 0] # y-axis grid register\n", + "\n", + " # Velocity directions\n", + " v_dir_x: QBit\n", + " v_dir_y: QBit\n", + "\n", + " # Velocity magnitudes\n", + " u_x: QNum[n_u_i_bits, UNSIGNED, 0] # velocity magnitude in the x direction\n", + " u_y: QNum[n_u_i_bits, UNSIGNED, 0] # velocity magnitude in the y direction" + ] + }, + { + "cell_type": "markdown", + "id": "18", + "metadata": {}, + "source": [ + "### Initial state preparation, setting parameters\n", + "\n", + "The presented algorithm imposes an essential constraint on the initial condition: particles' initial velocity, on lattice sites adjacent to the boundary surfaces, should only be towards the surface.\n", + "\n", + "We initialize the particles at a lattice point on the left-hand side of the lattice with a uniform velocity distribution in the y-direction and a non-negative uniform distribution in the x-direction." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "19", + "metadata": {}, + "outputs": [], + "source": [ + "# Setting the initial spatial and velocity magnitude probabilities\n", + "g_dist_x, g_dist_y = [0] * n_g_i, [0] * n_g_i\n", + "g_dist_x[1] = 1\n", + "g_dist_y[2] = 1\n", + "u_dist = list(np.ones(n_u_i) / n_u_i)" + ] + }, + { + "cell_type": "markdown", + "id": "20", + "metadata": {}, + "source": [ + "State preperation function for the `PhaseSpaceStruct`:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "21", + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def init_state2D(\n", + " qs: PhaseSpaceStruct,\n", + " g_dist_x: CArray[CReal],\n", + " g_dist_y: CArray[CReal],\n", + " u_dist: CArray[CReal],\n", + ") -> None:\n", + " \"\"\"Prepares the initial grid, velocity magnitude, and velocity direction quantum variables\"\"\"\n", + " inplace_prepare_amplitudes(g_dist_x, 0, qs.g_x)\n", + " inplace_prepare_amplitudes(g_dist_y, 0, qs.g_y)\n", + " inplace_prepare_amplitudes(u_dist, 0, qs.u_x)\n", + " inplace_prepare_amplitudes(u_dist, 0, qs.u_y)\n", + "\n", + " ## Initialize velocity direction register (v_dir) in an equal super position\n", + " X(qs.v_dir_x)\n", + " H(qs.v_dir_y)" + ] + }, + { + "cell_type": "markdown", + "id": "22", + "metadata": {}, + "source": [ + "### Initiating model parameters and CFL schedule\n", + "\n", + "The model is propagated for `max_iters` time-steps (each containing a streaming and reflection operation), and the reflecting object is placed between the corners of `limits`." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "23", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/f9/dqrhj23922x926lhkszh0c5h0000gn/T/ipykernel_42717/2314929453.py:29: RuntimeWarning: divide by zero encountered in divide\n", + " inverse_velocities = 1/velocity_magnitudes\n" + ] + } + ], + "source": [ + "# An error will appear when the velocity magnitude can vanish. This does not effect the program.\n", + "tolerance = 1e-6\n", + "# time-series schedule\n", + "schedule, simulation_time = time_series(discrete_velocities, max_iters=9)\n", + "\n", + "# set boundary points of the reflection object\n", + "x_low, x_high = 2, 5\n", + "y_low, y_high = 1, 5\n", + "limits = [x_low, x_high, y_low, y_high]" + ] + }, + { + "cell_type": "markdown", + "id": "24", + "metadata": {}, + "source": [ + "#### Schematic representation of the considered grid" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "25", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.patches as patches\n", + "\n", + "\n", + "def plot_2d_grid_with_obstacle(\n", + " Lx=4, Ly=4, obs_x_start=x_low, obs_x_end=x_high, obs_y_start=y_low, obs_y_end=y_high\n", + "):\n", + " \"\"\"\n", + " Plot a 2D lattice with a rectangular obstacle.\n", + "\n", + " Parameters\n", + " ----------\n", + " Lx, Ly : int\n", + " Number of lattice sites in x and y directions.\n", + " obs_x_start, obs_x_end : int\n", + " Left and right faces (inclusive) of the obstacle region in x.\n", + " obs_y_start, obs_y_end : int\n", + " Bottom and top faces (inclusive) of the obstacle region in y.\n", + " \"\"\"\n", + " # Basic sanity\n", + " assert 0 <= obs_x_start <= obs_x_end < Lx, \"Obstacle x must be within [0, Lx-1].\"\n", + " assert 0 <= obs_y_start <= obs_y_end < Ly, \"Obstacle y must be within [0, Ly-1].\"\n", + "\n", + " # Generate grid coordinates\n", + " x_sites, y_sites = np.meshgrid(np.arange(Lx), np.arange(Ly))\n", + "\n", + " fig, ax = plt.subplots(figsize=(5, 5))\n", + "\n", + " # Draw lattice sites\n", + " ax.scatter(x_sites, y_sites, marker=\"x\", s=60, zorder=3, color=\"k\")\n", + "\n", + " # Draw obstacle as shaded rectangle\n", + " rect = patches.Rectangle(\n", + " (obs_x_start - 0.1, obs_y_start - 0.1),\n", + " obs_x_end - obs_x_start + 0.2,\n", + " obs_y_end - obs_y_start + 0.2,\n", + " linewidth=1,\n", + " edgecolor=\"r\",\n", + " facecolor=\"tab:red\",\n", + " alpha=0.35,\n", + " label=\"Obstacle\",\n", + " )\n", + " ax.add_patch(rect)\n", + "\n", + " # Cosmetics\n", + " ax.set_xlim(-0.5, Lx - 0.5)\n", + " ax.set_ylim(-0.5, Ly - 0.5)\n", + " ax.set_xticks(np.arange(Lx))\n", + " ax.set_yticks(np.arange(Ly))\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(True, which=\"both\", linestyle=\"--\", alpha=0.4)\n", + " ax.legend(loc=\"upper right\")\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "# Example usage: 4x4 grid, obstacle at x=2, y=1..2\n", + "plot_2d_grid_with_obstacle(\n", + " Lx=8, Ly=8, obs_x_start=x_low, obs_x_end=x_high, obs_y_start=y_low, obs_y_end=y_high\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "26", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize which |u| move on each step\n", + "plt.figure(figsize=(6, 2))\n", + "plt.imshow(\n", + " (pd.Series(schedule).apply(lambda s: np.isin(range(n_u_i), s)).tolist()),\n", + " aspect=\"auto\",\n", + ")\n", + "plt.xticks(range(len(u)), u) # place ticks at 0..N-1, label them with magnitudes\n", + "plt.xlabel(\"Velocity magnitude index\")\n", + "plt.ylabel(\"Time-step\")\n", + "plt.title(\"Streaming schedule (CFL-based)\")\n", + "plt.gca().invert_yaxis()\n", + "\n", + "cbar = plt.colorbar(label=\"Streaming prob.\")\n", + "cbar.set_ticks([0, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "27", + "metadata": {}, + "source": [ + "The schedule dictates which velocity magnitudes are propagated at each time step. The time duration of sub-steps is chosen so that distributions do not propagate beyond the neighboring cell per sub-step. This prevents overshoot and reproduces integer grid walks." + ] + }, + { + "cell_type": "markdown", + "id": "28", + "metadata": {}, + "source": [ + "## Streaming operator\n", + "The streaming operation receives the `schedule`, containing the streamed velocities at each time step. Conditioned on whether the velocity magnitude appears in `schedule[t]`, a sequential modular addition operation is performed on the associated grid variable $ \\ket{\\mathbf{x}}\\ket{\\mathbf{v}} \\mapsto \\ket{\\mathbf{x}+\\Delta \\mathbf{x}}$. Finally, the ancilla and velocity registers are restored to their initial state. The operation manifests a conditional translation of a specific set of positional states." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "29", + "metadata": {}, + "outputs": [], + "source": [ + "## Stream operator\n", + "\n", + "\n", + "@qfunc\n", + "def stream(qs: PhaseSpaceStruct, indx: int) -> None:\n", + " control(\n", + " qs.u_x == indx,\n", + " lambda: control(\n", + " qs.v_dir_x,\n", + " lambda: inplace_add(1, qs.g_x),\n", + " lambda: inplace_add(-1, qs.g_x),\n", + " ),\n", + " )\n", + " control(\n", + " qs.u_y == indx,\n", + " lambda: control(\n", + " qs.v_dir_y,\n", + " lambda: inplace_add(1, qs.g_y),\n", + " lambda: inplace_add(-1, qs.g_y),\n", + " ),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "30", + "metadata": {}, + "source": [ + "Implementation of the streaming operator in Classiq" + ] + }, + { + "attachments": { + "1efaa199-9bca-47b7-982c-366975a479aa.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7YAAAH2CAYAAABEPRDdAAAKsmlDQ1BJQ0MgUHJvZmlsZQAASImVlwdUU0kXx+e99EaAQKQTehOkE0BK6KH3JiohCRBKiIHQxM7iCq4FERFQlrIqouBaAFkrFqwoFrAvyKKgrIsFC1j2AYewu187331n3vzOzZ3/3Jkzk3MfABQGRyRKg2UBSBdmiUO93RjRMbEM3AggAHlAAhrAlsPNFLGCg/0BYrP93+19L4Cm+tumU1r/+vt/NTkeP5MLABSMcAIvk5uO8FGkTXBF4iwAUIcQv05OlmiK7yCsIEYSRHh4ipNm+PMUJ0wzWnY6JjzUHWFdAPBkDkecBADZHPEzsrlJiA55ai5zIU8gRHg1ws7p6Rk8hM8gbIjEiBCe0mcm/EUn6W+aCVJNDidJyjNrmTa8hyBTlMbJ+z+3439beppkdg4DpJGTxT6hSE9H9uy31Aw/KQsTAoNmWcCbjp/mZIlPxCxzM91jZzkzLYw9yzyOh59UJy3Qf5YTBV7SGEEWO3yW+ZmeYbMszgiVzpsodmfNMkc8l4MkNULqT+azpfr5yeFRs5wtiAyU5pYa5jcX4y71iyWh0rXwhd5uc/N6SfchPfMvaxewpWOzksN9pPvAmcufL2TNaWZGS3Pj8T0852IipPGiLDfpXKK0YGk8P81b6s/MDpOOzUIO59zYYOkepnB8g2cZeABP4I88DBAMLIEd0mwAkm0WPzdrajHuGaI8sSApOYvBQm4cn8EWcs3mMyzNLW0AmLq/M8fjbej0vYTop+Z8GQ3IsX6P3Jmtc76EMgDaigBQejDn090NALUQgNZOrkScPeNDT70wgAioQAEoI/8NOsAQmCK52QJH4Ipk7AuCQDiIAUsAFySDdCAGOaAArAFFoARsAdtBJagB9WAfOAgOgzZwApwFF8FVcBPcBQ9BPxgCL8EYeA8mIQjCQRSIBilDmpAeZAJZQkzIGfKE/KFQKAaKh5IgISSBCqB1UAlUClVCtVAj9DN0HDoLXYZ6oPvQADQCvYEmYBRMhhVgdVgfXgAzYRbsB4fDi+EkeBmcDxfCm+AKuA4+ALfCZ+Gr8F24H34Jj6MAioSio7RQpigmyh0VhIpFJaLEqJWoYlQ5qg7VjOpAdaFuo/pRo6hPaCyahmagTdGOaB90BJqLXoZeid6IrkTvQ7eiz6NvowfQY+ivGApGDWOCccCwMdGYJEwOpghTjtmDOYa5gLmLGcK8x2KxdKwB1g7rg43BpmCXYzdid2FbsGewPdhB7DgOh1PGmeCccEE4Di4LV4TbiTuAO427hRvCfcST8Jp4S7wXPhYvxK/Fl+P340/hb+Gf4ycJsgQ9ggMhiMAj5BE2ExoIHYQbhCHCJFGOaEB0IoYTU4hriBXEZuIF4iPiWxKJpE2yJ4WQBKTVpArSIdIl0gDpE1mebEx2J8eRJeRN5L3kM+T75LcUCkWf4kqJpWRRNlEaKecoTygfZWgyZjJsGZ7MKpkqmVaZWzKvqASqHpVFXULNp5ZTj1BvUEdlCbL6su6yHNmVslWyx2X7ZMflaHIWckFy6XIb5fbLXZYblsfJ68t7yvPkC+Xr5c/JD9JQNB2aO41LW0droF2gDSlgFQwU2AopCiUKBxW6FcYU5RWtFSMVcxWrFE8q9tNRdH06m55G30w/TO+lT8xTn8eax5+3YV7zvFvzPiipKrkq8ZWKlVqU7ipNKDOUPZVTlbcqtyk/VkGrGKuEqOSo7Fa5oDKqqqDqqMpVLVY9rPpADVYzVgtVW65Wr3ZNbVxdQ91bXaS+U/2c+qgGXcNVI0WjTOOUxogmTdNZU6BZpnla8wVDkcFipDEqGOcZY1pqWj5aEq1arW6tSW0D7Qjttdot2o91iDpMnUSdMp1OnTFdTd0A3QLdJt0HegQ9pl6y3g69Lr0P+gb6Ufrr9dv0hw2UDNgG+QZNBo8MKYYuhssM6wzvGGGNmEapRruMbhrDxjbGycZVxjdMYBNbE4HJLpOe+Zj59vOF8+vm95mSTVmm2aZNpgNmdDN/s7VmbWavFuguiF2wdUHXgq/mNuZp5g3mDy3kLXwt1lp0WLyxNLbkWlZZ3rGiWHlZrbJqt3ptbWLNt95tfc+GZhNgs96m0+aLrZ2t2LbZdsRO1y7ertquj6nADGZuZF6yx9i72a+yP2H/ycHWIcvhsMMfjqaOqY77HYcXGizkL2xYOOik7cRxqnXqd2Y4xzv/6NzvouXCcalzeeqq48pz3eP6nGXESmEdYL1yM3cTux1z++Du4L7C/YwHysPbo9ij21PeM8Kz0vOJl7ZXkleT15i3jfdy7zM+GB8/n60+fWx1NpfdyB7ztfNd4Xvej+wX5lfp99Tf2F/s3xEAB/gGbAt4FKgXKAxsCwJB7KBtQY+DDYKXBf8Sgg0JDqkKeRZqEVoQ2hVGC1satj/sfbhb+ObwhxGGEZKIzkhqZFxkY+SHKI+o0qj+6AXRK6KvxqjECGLaY3GxkbF7YscXeS7avmgoziauKK53scHi3MWXl6gsSVtycil1KWfpkXhMfFT8/vjPnCBOHWc8gZ1QnTDGdefu4L7kufLKeCN8J34p/3miU2Jp4nCSU9K2pJFkl+Ty5FGBu6BS8DrFJ6Um5UNqUOre1G9pUWkt6fj0+PTjQnlhqvB8hkZGbkaPyERUJOpf5rBs+7IxsZ94TyaUuTizPUsBKZSuSQwl30kGsp2zq7I/5kTmHMmVyxXmXsszztuQ9zzfK/+n5ejl3OWdBVoFawoGVrBW1K6EVias7Fyls6pw1dBq79X71hDXpK65vtZ8benad+ui1nUUqheuLhz8zvu7piKZInFR33rH9TXfo78XfN+9wWrDzg1fi3nFV0rMS8pLPm/kbrzyg8UPFT9825S4qXuz7ebdW7BbhFt6t7ps3VcqV5pfOrgtYFtrGaOsuOzd9qXbL5dbl9fsIO6Q7Oiv8K9o36m7c8vOz5XJlXer3KpaqtWqN1R/2MXbdWu36+7mGvWakpqJHwU/3qv1rm2t068rr8fWZ9c/a4hs6PqJ+VPjHpU9JXu+7BXu7d8Xuu98o11j4361/Zub4CZJ08iBuAM3D3ocbG82ba5tobeUHAKHJIde/Bz/c+9hv8OdR5hHmo/qHa0+RjtW3Aq15rWOtSW39bfHtPcc9z3e2eHYcewXs1/2ntA6UXVS8eTmU8RThae+nc4/PX5GdGb0bNLZwc6lnQ/PRZ+7cz7kfPcFvwuXLnpdPNfF6jp9yenSicsOl49fYV5pu2p7tfWazbVj122uH+u27W69YXej/ab9zY6ehT2nbrncOnvb4/bFO+w7V+8G3u3pjei91xfX13+Pd2/4ftr91w+yH0w+XP0I86j4sezj8idqT+p+Nfq1pd+2/+SAx8C1p2FPHw5yB1/+lvnb56HCZ5Rn5c81nzcOWw6fGPEaufli0Yuhl6KXk6NFv8v9Xv3K8NXRP1z/uDYWPTb0Wvz625uNb5Xf7n1n/a5zPHj8yfv095Mfij8qf9z3ifmpayJq4vlkzmfc54ovRl86vvp9ffQt/ds3EUfMmS4FUEiDExMBeLMXAEoMALSbABAXzdTX0wbNfBNME/hPPFODT5stAPV9AIQvB8D/OgA7KwHQR/SpcQAEUxG/I4CtrKRtthaertunTPYAUhVZm3v4/pvvEwBmavq/5P3PHkypWoN/9n8CZbMK+oYtuUgAAABWZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAOShgAHAAAAEgAAAESgAgAEAAAAAQAAA7agAwAEAAAAAQAAAfYAAAAAQVNDSUkAAABTY3JlZW5zaG90ct/B9AAAAdZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+NTAyPC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjk1MDwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlVzZXJDb21tZW50PlNjcmVlbnNob3Q8L2V4aWY6VXNlckNvbW1lbnQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgqaZ+o1AABAAElEQVR4AeydB3xUxRbGv/SEltCbARI60hWkFxUUVFAQCyqi8FAUeSgIPMSOvQEqiAIiIiAoICAgCFKkSC/SS+gdQgrpCW9mwt1skt1sNrlb7u43/Ja9O/XM/2x279kzc8anYsWKN8BEAiRAAiRAAiRAAiRAAiRAAiRAAgYl4GtQuSk2CZAACZAACZAACZAACZAACZAACSgCNGz5RiABEiABEiABEiABEiABEiABEjA0Af+qNQMMPQEKTwIkQAIkQAIkQAIkQAIkQAIk4N0E/ENL+3k3Ac6eBEiABEiABEiABEiABEiABEjA0AR8GDzK0Pqj8CRAAiRAAiRAAiRAAiRAAiTg9QS4x9br3wIEQAIkQAIkQAIkQAIkQAIkQALGJuBvLr7cb8ulyeZEeE0CJEACJEACJEACJEACJEACJOBuBGKupOPE4VSTWCbDtmGLYISW8sXpY+mmQl6QAAmQAAmQAAmQAAmQAAmQAAmQgDsRKFHSB1VuBkHWjFuTYSuN2r1bUxEbneFOMlMWEiABEiABEiABEiABEiABEiABEshGILy6f+Zq45teW+6xzYaHL0iABEiABEiABEiABEiABEiABIxGwOSxNZrgrpY3rWok0qpEuFoMjk8CJEACJOAFBHxjohG4e7sXzJRTJAESIAESIIGCEaBhWwBuGaEllVHrf+o4fGOvFaAHNiEBEiABEiCB/BNIC68G+YOq/4lj+W/EmiRAAiRAAiTgRQRo2BZA2RlhJZVBKw1bJhIgARIgARJwNAF/HEfKrY1p2DoaNPsnARIgARIwLAEatoZVHQUnAf0IpJWtrF9n7MkhBPwvnXFIv+yUBEiABEiABEiABDyBQJ6G7csvv2x1jps2bsLGTRutlrOABEjA/QlIgzauXXf3F5QSImT/FgTv20ISJEACJEACJEACJEACFgjkadjihoUWzCIBEvAYAol1mxVqLn5HdsAnPrpQfbCxbQI3ipWE1JX/pbPiQc+tbWKsQQIkQAIkQAIk4G0E8jRsvxj7hbfx4HxJwKsIpJWt5FXzNepk5Y8HPvHXIPVFw9aoWqTcJEACJEACJEACjiTAc2wdSZd9kwAJkAAJkAAJkAAJkAAJkAAJOJxAnh5bh4/uQQO0bNECQwYPsTqjR3s/ZrXMGwp8fHzhk2OicqX7jRsZOXJzv6wX2QL7jm3KXcAchxNIP3UMfuGRDh+HA5AACZCAMQn4IMA/AKlpKfkSv15kS/F9xvgk+YLFSiRAAiRgJwEatnYCy6v62PFj8yr26rIXHvkCJYqWysYgJTUZn/3YP1uepRej+8/GmMmP0bi1BMfBeSkbViCwVScatw7mzO5JgASMR6BGlSbo3LIvypS8Be9809PmBKRRO/q5Oeg9ItxmXVYgARIgARKwnwANW/uZWWyxcRM9ihbB3MxMT081/aJdpXwdlA6riJnLPsyriSqT3lqZ6LFVGPgfCZAACZCAywn4oEndO/HiY1/iasw57D2yHr5iVVKGjRVIPTq9TG+ty3VHAUiABDyZAA1bT9auG83tm1+GKWmCA4vg3RcW4ujpXVi+cZpNCXvcOYRGrU1KrGCLQHBQIJKS87dUMK++urdriw5Nm+BafDzenjw1r6osIwHDEEirGomM0DDDyOtqQW+v3Awvt/sf1kX9hSlbv0NSWhLQoHGeYtUvXQfSY/vWshFIadg0z7osJAESIAFPJeAbcw3+J445bHo0bB2Glh1bItCr0zCULRWOdyb1MnlwLdXT8qTHVi5DZnIegfhPR2QbLPHnSabXcllyYKu7Ta/d/aJy2bJ49YneePLezqjyYE8kJIkb0EKk3p07ofMdzcV7N42GbSE4sqn7EJBGbVqVCPifOu4+Qrm5JHe2bI+r8Rfx45rxSEmORb6icJbxUT/S7ov6J3/13ZwBxSMBEiABewnIH1Dl941MjjJuadjaqxXWLzCBBjXaoEvrZzFv5ThcjD4lgkn5iKOSrR+WzGXIBUZdqIbFhn1kai+NWiPvsR0qgrY9fV8XpGfYDlJmmjQvSMCLCMibjMC9OyF/RWeyTaBoSAk0i2iDcbNeQER6CAKDw3D83H7EXr+SZzDER+7J3HrDHxBsM2YNEiABDyVwCkgLr+bQFUI0bD30veOO07qtbiekioBRPe76L+5u8RRmLn0fa7f/YlVULkO2isbwBf5+fnj+oQdxe906CAoMxJWYGHwx+2exRP2MaW5NatfC8w92F0HHiiIhORkb//0XU35bZPopZPAjvVAvohqmLV6CVg3ro2nt2khLT8e035dg9fYdqHFLZbRrkrk80NfHB+NfGYLxc+aibeNGaFC9Ojbs+RcNxXO5UiUx76/VWLB2HYqGBOP1Z55BlQrlkS762n7wkJLLJBQvSIAEvJpAw5rt4SM+T/o/+L6IhhwMf78A8bmTgh8WvYXV2+ZYZCN/pOXqI4tomEkCJEACuhKgYasrTnaWF4Fpi96EfFQoHYGXRNCN53p+gp0H/1K/dOdsxxuBnEQ853WAvz8mjxqJbm3bZJvUvS3uQJeXh+LwqdPK4P15zDsoVaKEqU6PDu1xmzBeX/zkMxGk5QbkftemwviV7UKLFTPVk/12Hz5SGKYZqF65ssqXN6I9O3ZQBm/3tm3RrF5dPHxnR/j5Zi4i3HnoEKpVrIjVE74SfRU19XV/m9Z4qsu9uH/Yqzh76bIpnxckQALeSaBuxB1iK0Iy5q74DKu2zEKxIiXx9sD56N5xkFXDVpKSARAZBNE73zOcNQmQgPMI5GtriPPE4UjeQOD8lSj88ufnaqpVK9azOmXeCFhF47QCRyxD7tftfpNRK720dw0ajKuxsSgdGoqPB72A6sLTuvjTj5VRe+7KFdw7ZCh++mO5mvOjd9+NoU88nm3+0qh96bMv0PWVYWIp4A3lTakfGYmDJ07g7127VV1pCA/+fCxWbN5saiuN2n/27lV1FqxZhymvjVRGbYrYP9vvvQ/wxreTVX8RlSpiyKOPmtrxggRIwHsJlC9dTfzIdRQr/pkhtjikIyb+MtZt/xVlwipZhSJXH+2P4skJVgGxgARIgAR0IkCPrU4g2Y19BEoUK60MEHlUgqUkbwSYXE/ALzxSVyGk57RutWqqz6uxcXh36jRlPEovbIXSpbHtwEE0r1dPLU+Wu697jRqNvceiID2qXVq2UMbuPSJ406c/zTLJtWzTP5ix7A/1WtatXz0SlcqUwRVhLB8+dQptGjVUY/wqlhubB4/KEPtu+7w9Ruz3jhZelxA0qVVL9THy64mYt3qNui4TFgq55Llnx/YY/tXXpjF5QQIk4J0Ejp7aJc6ufQpBASFITk1UEMqXqoqUVMuB6bTVR/NWjfVOYJw1CZAACTiRAD22ToTtzUPJ5VvlSlURHrEyaFCjLfp1f0/86n0MZy4dyYWFNwK5kHhMRpHgINPy4gtXZbCVzOBh0jiVe2P3HD2KYLHnVqaU1FRl1MrrZHF94PgJean23BYJDlbX8r/DJ0U0gpspLiFBXfn7+2lZVp+TUlKVUSsrVK1QQf3QIsU5dzlrybG25zeseHGr/bCABEjAewj8/ve3Yl9tEN58/lexyqSS2jvbvH4X7Dnyt0UIWqwILkO2iIeZJEACJKArAXpsdcXJziwRkNGP+3Z7F5XL1lBBNgL8g7DjwEp8O2+4peqoG9GC+5EskjF+ZkJSMq7FxamJhJcvf9OYvIHnHuouPKuNxPLhk4g6e1aVB4q9uJGVK+HYmbNqL2y9iMwQ8bHXE7J5XlPSUk1gNEPZlHHzwkc8S2+xeUo1ayfHkElWKRWata9XyiiTJrN6wf9IwMMJvPxf6ytmNv2zCRs3ee+y2uuJMZg8fwQG9PwUY4etga+vvzqXXQZDtJborbVGhvkkQAIkoC8BGrb68mRvFgjII31GjOuMCmUiEFasLE6c24fE5HgLNTOzpGHLGwGreHQv8DuyAz7x0br3a6lDaXjuOZp5MHexkBB8MPB5/LV9u1ruK5cPFy9SBPPXrFHRjWXk5Fnvvo03v5uCVg3qI6x4ZoCo3zdsMHl65RjWD4zK9PQqOYTFel/rlti6/4BJrDQRXEpLiSLq8u4jR9GwRnW8/Z/+iImLRwkRRGrwIw+rKov+Xq9V5TMJkICXE/h75wJs2LUQlcpWx/WkWETHXrBIJGv1kcViZpIACZAACehMgIatzkDZnXUC5y9HQT7ySrwRyIuOZ5RNXbQYD4sIxTIysfTUDhAP6UuNE57YkV9PwEGxtLjDwEFY9fV41AoPx8y33zR5Wxeu+xvjfp6bbxCrtm5TxwrJ434mjRgu2lo+jkN22P/9D7Dxu0koI4JYzRBjaknuy/1w+gztJZ9JwOMJfDGO+0FtKTnjRgZOXzycZzUuQ84TDwtJgARIQHcCNGx1R8oOC0OANwKFoWeMtvKs2QdH/E8co3MP6lStqqIhHzl9Gks2bMQBsRRZpr1RUegx8jW0bthALE2vhotXr+KYWKIsz6yVQZ9k+mHJEiz/Z7M4j3aPei3/k9GT1+7cJTyz+1Xeis1b8No336Jlg1vFTeglrNmxU52Vu1IYvNJLa57kMUON+/RFjw4d1DFBcqXBIWFkf/fbQnG8R5qqOmflKnW2rYyGykQCJEACeRGQP9SOmfxYXlVYRgIkQAIkoCMBGrY6wmRX+hDgMmR9OLpzL9ILOmn+b3mKuH73bsiHtTR9ybJcRTOXr8iVN+HXeZCP/CRp/I6fY90jLCMrM5EACZCALQLSqJWJQaNskWI5CZAACehHgFGR9WPJngpJQFuGzBuBQoJkcxIgARIgAZcS0FYfuVQIDk4CJEACXkaAHlsvU7j5dKtXyPxF2TzP2vWlmMyAP9bKZX7Z0Mi8im2WaTcC9shls1NWyJPA1jxLWeiOBBz193H0vPdGunVHPVMm+wjY83dh6/ussN9lUnL5Q+2sxWNhj1z2zZi1SYAENALy+0v7W+N3mUbFO59p2HqZ3js3zjzGQXvO7/TnrLV8NI/WvlxYJDo0fF57WaDnSsIuvnwaGHjv7AK1ZyP7CfSL+9j+RmzhMgLy77ZbYGuHjS9vCJbvHAveGDgMMTvWkYD8e5A3s9oNbX663ntiBeQjr9Sh0XMoF1o9ryp5lgUWySxuX2sI2tfKsyoLSYAEHECA32UOgGqQLmnYGkRRhRWzIDcAhR3TnvbajUBKgj2tWJcESEBPAtJA0H5YkgaufDCRgLsRkN9n8uGuqXgpcdQYv8vcVT2UywsIaN9lNHC9QNk5pkjDNgcQT3zp7jcBkjlvBDzxncc5GZmA9mMYPbhG1qJnya7drLr7rIKEx1auPmIiARJwLQHtM0MauBOXMUK5a7XhnNFp2DqHs8tGkd4X+YdtKdnjjTkTvddSF6Y8WZ6SkWR6be9FX7FkS+5H4q/c9pIrZP2Cr7Yr5MBsXhAC6tfnq1sK0jTPNtpnhPasVdZuCuQNgRybiQRcRcDWD7T5/T6T+2svXjua5zRW7BxX4JgRcm9tJbTA4g1c7ZAnZBaSgAMIyO+snN9jchjtu4w/1DoAupt1ScPWzRSipzjWjFr5h53fmwB75LFl/FrrSzsWYRFvBKwhclx+9Rcc17eb9tzvgfvRs2MHdH1lmJLwl/fHYPWOHfhq7q9uKnGWWNK4PLNPf8NWG0F++WueWi1PPsvPEhq35kR47UwC2vsy55jaTareP7oU9LtMytf89tnqiB9HfMfmnD9fkwAJWCagfWbIZy3Ja/ldNmxaNS2Lzx5IgMf9eKBS5ZQs3ZzKL1r5B+1uX7haNGQPVQWn5WYEbqtbBy0b1DdJ1a5JY7Son/XaVOCFF9JAkAaspc8IeUPARALOJqDdjOYcV75H5UNvozbnOPa81o6s41ns9lBjXRLQnwC/y/RnapQeadgaRVN2yKn9UmXeRLsJMM9zl2t5M8AbAXfRhvfJ0X7gILwydrz3TTyPGcvPC0v7keQPZkwk4EwClt5z1n58caZc1saS57DzLHZrdJhPAs4lYOm7zNI9snOl4miOJEDD1pF0XdR3zhsBdzdqeSPgojeKg4YNL18eCz/5CJf/WIJDc2fjtb5PY//sn9CoRg34+PigVYMG2DdrBqJXLMPphQvwxZDBCAkKsijN5qmTMfOdt1Q7rcKAB7thn+ivoejPVpLjdW3VEsfmzVXjrfp6PIrkGGvmO29iUK+eqqv5H32AH94YjXXfTMCFJYswsMdDeQ4R4O+P3TOm48DPM1GhdGlVt0TRotj14w/Y89N0yHKjJvmLt/zsME85P1vMy3hNAnoTkDeg8mGe3HlJfN2I7LKay81rEiAB1xDgd5lruLtqVBq2riLvoHFz3ghY+oN20NAF6lYatWMmP1agtmzkfgQiK1fCsi8+w+1iue/oSd/i71278crjj6JcyZIICQ4Sxmh1zPvofVyJjcUr48Zj/e7d6HtfV3w3aqTFyRw9fVosE74VVSuUN5V3a9sGvsJgPXflsinP2sWtkRGYOPxVxF6/jlETJyHQPwDd27XNVr1y2bKIrFxZ5VWrWAH3t2mNCDGPq7FxYowr2ermfJGaloZR30xCmbAwjHv5v/Dz88PHg15A5XJl8cH0HyHLjZws/ShG49bIGjWW7Dnfa/L9KL/T3DX9unIsv8/cVTmUy6sJ8LvMe9RPw9bDdG3pRsCTpujvFyCMiMq4pXxt9ezr65dteiWKlRZGSgNUqVAXRYJLZCvL+UK2LR1aSdUtX7oq/P0Dc1bJ9TrAPwilQisIT1yWh9HP1z9XXq6GXpLRu3NnlCtVEr1GvY5v5i3As2Pex9KNWTei4eXKCePSHyv+2YKf/1yJR0e/oZ5TUlMtEpJBncKKFUO9iAhVLr2hzevVw7YDB3Ep+prFNuaZXw8biuCgQHR/dSQmzpuP+4a+iriEvA+YlEbzY0Kuuo/1xoI1a827s3j9x6Z/8Pv6DejUvBmee7A7HrnrTvy5eQvmrvzLYn2jZdJrazSNeYa8RvuR1jOocxYk4LkE+F3mubo1n5lx18mZz4LXJgLmy7bkL9vu/Ou2Seh8XgQHFcXofrNQoUw1SGMyPSMNSSkJGD62MxKSYhFeoQ5e7z8bgYEhuHEjA9diL2LMlMdx5drZXCOUDq2I1//zM4oVCRNetgBkZKTjwpUTGPXVfbnqmmeULFEeY15YiPNXjuONiQ+qoj4PvCmCET2A4eM641rcRfPqXnVdNCQElcuWQUz8dZw4f9409w17/kWXlplL9A6fOo0U4cUc1OthPHFPZ+w8fBgfCs/mjkOHTfXNL376YwU+GPi88vou2bAR7w98Ti3vHTruS/NqVq/rVquKAydOmOSJiY8XRuhGPNbpLqttbty4gQ2791gtz1kgvbIDP/pEBaR67/kBiDp7Dn3ffc/w3lrzecobAvMfzeR1zpsE8/q8JgESIAESIAF3IyDvic3vk+W1J90nuxtvV8hDj60rqDtoTPM/VgcN4bJuixUpiXGv/i28sMXx8/JPMW3RWzgQtRkli5dTnla5l7LP/W8iOTUBk34Zhm9/HY7lm6YjPsGyV2/Qo18iTLSdt2o8pi54DVFn/lUeYFsTvHj1JFZtmYUa4Y3QuvGDqH5LI7Rp/BA27PrNq41aya2IWGpcqkQJ8YNDejajztxDevDkSXQZMhQzlv0hdJWqvJwrvxqPb0cOh79YxpszxQvv6k9/LEfT2rXRqGYNyGXIm/ftw/mrV3NWzfVa9if3uMYnJmYrO3XxQrbXOV8kpaQgQxi39iTZ5ohYNi3TpWvXlPFuT3vWJQESyE7A/IcUWcIfUrLz4SsSIAH7CeQ0Yj35vtl+Op7RgoatZ+jR4iw86UagfvVWKC6M27krPsMKYbCu2TYHe46sM81betmCA4qI1z4qIuXmvUuxdP0UJAuPbs4ULpYx1652O76eMwRL/p6MdTvm4cjJ7TmrWX294K8vcT0xFk/d9wZeeuxLJCUnYMaS96zW95YCuSf1+LlzwsANRskSxU3TrlCqlOla7rVt1bA+Pp4hgj892QcNnngKpy5cRC+xfLdxrZqmeuYXn8+ajbT0DHw19BUUFX3/smq1ebHV67R04YW/Go3ISpWEhz/ro65prVpW28gC+V6yJ8kfVd4TnuQWt96Kvcei0EzsL57w6lD4mo1pT3/uWNeTPkvckS9lsk0g5w2p7RasQQIkQALZCfBzJDsPT3yVdbfnibPzsjl58i9PRUNClcEhlwBbSz8ueUdE1y2G8cPX43/P/Ig61ZpbrFqzShPhkcvAlr3LLJbbypTLn0d//QCCxJLn0GJl8fmM/wjDK8VWM48vTxeG5HqxhLeYWJL8Vr9nBZ9AESm4FHrf08k093aNG+HdAQPw+rN9VSTklNQ0RMfFqfLL12KEB744PnnpRTx17z2mNtI4PSQ8vTIQlDQWV23dZiqzdTF54UKUF4b1iD5PqoBT0uPb8bbbbDWzq7xmeLhaVi33/XZ88SWsEfuCZYCq5vXq2tWPkSp78meNkfRAWUmABEiABEiABLII0LDNYsErNyZg8qEJ71hWMr8GDp3Yhlc+66CWIFcoE4HBj38tPIdZ0XRztvPxMXv7Z+s3q6a1q9rVmgkvYAACA4JRq4q+hpK1MY2Qv3Dd35gplg53aNoEZxctEMf8zERZETFYS6u378D2gwfFHte7cWbxbzg4ZxZqht+C7xf/rry9oSJQVJ8u96Jdk8ZaE7F/OkkYizvVkT87xV7co2fOmMpsXUz8dT5WbtmKYb0fx3lxfM/U0aOEh9jCUuSbXlrT+8xWxzfLw4QhPv/D95UR//aUqWoJ9gfTZygP8bTXXxM/fBTLZ0+sRgIkYE7A/McTelnMyfCaBEigoARyfpaYf84UtE+2cy8CDB7lXvqgNFYIJCdfV4ZNhdLVxH7YzMA+dSPuyFU79voV/LRkDE5fOIgBPT4Wy5dLITo2uyFzSpT5CqO2ZcP7xd7Yharf2lWb5erLWobcVyv7/vOfn1C8aEn07ir26J79FweOb7bWxKvyX/p8LN6ZOg3thXG6++hRdG/bFsOf7K0YXI6JwQPDhotI1OVx1+23CWYnsUfUkfkyyf2vjZ58WgQFy+4Bf3fq9/hy7i9iCXj2/bKqUR7/XRdGcZ+330XtqlXQulFDLN2wSe2BlcultSSXRCenZEZlvmfwy3YtIU4Q8tz10n9F8LEMXIyOVl1u3rsP9cUSa/kek0Y5EwmQAAmQAAmQAAmQgOMJ0LB1PGOOoAOBfVGbVFCiRzu/KpaWVhUGZSncfmvWclV5/M6Anh/jcvRpcWbpVdxRvysSk+OFgXRdBYV6c8Bc7Dy0GlMWjMKRUztw7tIxPN/zMxHFtyaKFgkV55bWR0qqbSNERmN+QhiyicLQXrxukoqmXEcY2E92HY3RE7rpMFPjdyGNvAsiuNOclavUZDo3z74kPDE5GQdPnFSPnLNNF3tpLQWGkobu+Rxnyspjg+T+VmtJBoCSEYsTxHgy6rJ55GV5rq2Wzl/JCkQlAz+Zp/yMkVMu2f6iWD7NRAIkQAIkQAIkQAIk4DwCNGydx5ojFYKA9Lq+/Gk7vNZ/Frq26Sf2tKZh54FVaFLnTtWrPN9Wnlvbsdlj6iigtPRU/PLn58LAOCnOqq2IgIAg5UGTlWVwoPGzB+HVPlNxd4snkZqajKOndyO8fN5BhWTb+9oOEOe0VlXHAl2+lrkkVkZVfrb7GHRu+TSWb/xBVmMyIyANXWlk2huUyayLXJcVS5fGukkTxFLzErnKtAzpTQ3v3kN7afezM8awWyg2IAESIAESIAESIAESsEiAhq1FLMx0RwLSkBz6eUcRGbeE8MLF4e7mT5gMW+md/eSHZ1TwKBlAKj5RHLly0wN7JeYchgijOC0ta3nriXP7MOijFirSsmz70uNfiSNabHtsF66ZAPkwT9v2r4B8MFkmMH/NWuyLOo79x09YrlCA3CuxsXjm3ffFHucAq61T0jKXF1utYKPAGWPYEIHFJEACJEACJEACJEAC+SRAwzafoFjNPQhkiDNS4xKsL/OURqp85ExJYumweWpUq4OI2FsVl8TS5VLCo1u/emvsP7ZJValW8VaUL1PNvLq6TkyKw79H16vlx7kKmWGVwJlLlyAfeqYUcQbuul279OwyV1/OGCPXoMwgARIgARIgARIgARIoEAEatgXCxkbuQCBVeGDjE2KEoZlmtzhVxFm2j94zQgUKuiGO/tl9eB2+nTdC9dPutl7o1OKpXH2euXgYb058CMkZ9gUwytURM0iABEiABEiABEiABEiABHQlQMNWV5zszJkEVm2ZBfkoSFokAj/JR1BAiFiCnCz2f2aYupm++C3IBxMJkAAJkAAJkAAJkAAJkIAxCNCwNYaeKKWDCCSn0vvqILTslgRIgARIgARIgARIgAScRsDXaSNxIBIgARIgARIgARIgARIgARIgARJwAAEatg6Ayi5JgARIgARIgARIgARIgARIgAScR4BLkZ3HmiORgFsSyKgQAf9LgQjZv0XJF9fuQfXsf+mM4fIGdLyAphFZUbGfn1pdzM1487Ak841iYW75/qFQJEACJEACJEACJOAOBGjYuoMWKAMJuIiAZsz6XzoLv8QEJUXwqcPq2Yh5TRqUFoZt1tm2ci5GnIclmRPrNnPRu4TDkgAJkAAJkAAJkID7E6Bh6/46ooQk4DACwfsyvbTmAxg5L+BSAyAi1DSdnHPJ+VpWNFKeNHiZSIAESIAESIAESIAEchOgYZubCXNIgARIwO0IWDLA3U5ICkQCJEACJEACJEACLiLA4FEuAs9hSYAESIAESIAESIAESIAESIAE9CFAw1YfjuyFBAxJQAaKSitb2ZCye5vQSfWaQT6YSIAESIAESIAESIAEchOgYZubCXNIwGsIpJWt5DVzNfpEU8vwBwij65DykwAJkAAJkAAJOI4ADVvHsWXPJOD2BBiMyO1VZBIw4PIZFeHZlMELEiABEiABEiABEiABEwEGjzKh4AUJeB+B4msXeN+kDTpjBo8yqOIoNgmQAAmQAAmQgFMI0GPrFMwchARIgARIgARIgARIgARIgARIwFEEaNg6iiz7JQEDEGDwKAMo6aaIDB5lHF1RUhIgARIgARIgAecToGHrfOYckQTchgCDR7mNKmwKwuBRNhGxAgmQAAmQAAmQgBcToGHrxcrn1EmAwaOM8x5g8Cjj6IqSkgAJkAAJkAAJOJ8Ag0c5nzlHJAG3IcDgUW6jCpuCMHiUTUSsQAIkQAIkQAIk4MUE6LH1YuVz6iRAAiRAAiRAAiRAAiRAAiTgCQRo2HqCFjkHEiggAQaPKiA4FzRj8CgXQOeQJEACJEACJEAChiFAw9YwqqKgJKA/AQaP0p+po3pk8ChHkWW/JEACJEACJEACnkCAhq0naJFzIIECEmDwqAKCc0EzBo9yAXQOSQIkQAIkQAIkYBgCDB5lGFVRUBLQnwCDR+nP1FE9MniUo8iyXxIgARIgARIgAU8gQI+tJ2iRcyABEiABEiABEiABEiABEiABLyZAw9aLlc+pkwCDRxnnPcDgUcbRFSUlARIgARIgARJwPgEats5nzhFJwG0IMHiU26jCpiAMHmUTESuQAAmQAAmQAAl4MQEatl6sfE6dBBg8yjjvAQaPMo6uKCkJkAAJkAAJkIDzCTB4lPOZc0QScBsCDB7lNqqwKQiDR9lExAokQAIkQAIkQAJeTIAeWy9WPqdOAiRAAiRAAiRAAiRAAiRAAp5AgIatJ2iRcyCBAhJg8KgCgnNBMwaPcgF0DkkCJEACJEACJGAYAjRsDaMqCkoC+hNg8Cj9mTqqRwaPchRZ9ksCJEACJEACJOAJBGjYeoIWOQcSKCABBo8qIDgXNGPwKBdA55AkQAIkQAIkQAKGIcDgUYZRFQUlAf0JMHiU/kwd1SODRzmKLPslARIgARIgARLwBAL02HqCFjkHEiABEiABEiABEiABEiABEvBiAjRsvVj5nDoJMHiUcd4DDB5lHF1RUhIgARIgARIgAecToGHrfOYckQTchgCDR7mNKmwKwuBRNhGxAgmQAAmQAAmQgBcToGHrxcrn1EmAwaOM8x5g8Cjj6IqSkgAJkAAJkAAJOJ8Ag0c5nzlHJAG3IcDgUW6jCpuCMHiUTUSsQAIkQAIkQAIk4MUE6LH1YuVz6iRAAiRAAiRAAiRAAiRAAiTgCQRo2HqCFjkHEiggAQaPKiA4FzRj8CgXQOeQJEACJEACJEAChiFAw9YwqqKgJKA/AQaP0p+po3pk8ChHkWW/JEACJEACJEACnkCAe2w9QYucAwkUkACDRxUQnAuaMXiUC6BzSBIgAUMRSK8aYSh5vVFYvxNR3jhtztlJBGjYOgk0hyEBdyTA4FHuqBXLMjF4lGUuzCUBEiCBlHZ3IaXdnQRhAAKBa1chcO1KA0hKEY1IgIatEbVGmUmABEiABEiABEiABBSBwhq1fju2wic6mjQdTCAjIlL9AEHD1sGgvbh77rH1YuVz6iTA4FHGeQ8weJRxdEVJSYAESIAEchPwjTqmMrlkPDcb5uhDgIatPhzZCwkYkgCDRxlHbQweZRxdUVISIAESIAESIAHnE6Bh63zmHFEQ8PP1h4/4l59UL7JFfqqxTgEIMHhUAaC5qAmDR7kIPIclgRwEfHx84Zvj4ePD77McmNzqZdrB/W4lD4UhARJwDAHusXUMV/ZqhUCAfyC6dxiE2lVvx/jZgxB3/aqVmlnZo/vPxpjJj2HfsU1ZmbzShQCDR+mC0SmdMHiUUzBzEBKwSWBE32nIacj+tfVnbNq9OM+28kda+X3We1S1POuxUH8Cib/NQ0j3HvCvXVf/ztkjCZCA2xCgYes2qvB8QcqEVcKwPlMQVrw8DkT9gxs3btictOatpVFrExUrkAAJkAAJOIFAWnqqGkX6aG+t3kYZubOWfWhz5B53DuEPtDYpsQIJkAAJFJwADduCs2NLOwkMfvxrlCtZBW99+zBOnT+QL8OWNwJ2QrazugweFbJ/C/wvnbGzJas7m4AMHiUTPbfOJs/xSCA7gU+n91MZrRt1R6PaHfHlrEE4fnZv9ko5XskfaeVDrj5iIoGCEggK8EdyalpBm5va9b3rTtSvWgUHTp/G5OV/mvJ5QQJGJ0DD1ugaNIj8zW/tgqoVb8U73z2Ck+fyv9eFNwKOVbAKHpV/dThWGPaeJwEZPErus2UiARJwPYGQoGJ4+O6Xxeqjzdh+IH+GgVx5xNVHztNddL8nsw0W9/F7ptdyWXJwtx6m1+5+EVmhPEY+3AM1KlbEPW++jdS09EKJPOj+LqhStiy2Hz1Gw7ZQJNnY3QjQsHU3jXigPH5+AejzwFvYeXAVYuMvo3n9LurX7asx56At6bI0bS5DtkRF3zwGj9KXpyN7Y/AoR9Jl3ySQfwJyf+1j94xA+dLVMHHuULEU2c9mY7n6iMm5BEpOmWEaUBq1Rt5j+1HfPmhf/1bsPXnKNCdekAAJ5CZAwzY3E+boTCC0WBkEBQSjYc32GDuss/ilMQX+wtg9cGILPpzaRxi3KRZH5DJki1h0zWTwKF1xOrQzLkF2KF52TgL5JlBSxIlo26QH0jPS8cZzc9XWmi9nD8bZS0cs9sFlyBaxeERmUEAARvR8CBHly4v7Gl9cuBaDzxcsxNmrWYExpUH6ePu2KBYcjLjERCzbtgO//bNZzV/u0x7ZqycqlSqJj36djyc7tMetVcKRkJKCSUv/UB5V2b5u+C2q/i2lS2H8gP74ZN4CPH1nR5QpUQL/HDqE5rVqivusAPz41xqs/XcvwsuUwSsPdhPlxZGano51e/fh+z9XeQRzToIE8iJAwzYvOizThUCJoqUQ4B+Ef4+sx1dzBiMp+bqIjPwiHuk0FK0aPYC123/NNQ5vBHIhYQYJkAAJkIAbELgaex7Pvn2rkkQauP956EN0avEkflj0llXpuAzZKhrDFgT6++Pn4eI+pm6dbHNoVbc2Or3+Fq4nJaPbHc3w5XP/QUhgoKnOQy3uQMNqVTFmzi8q78EWzZVhfHfjRihdvLipXscG9XH36LdQq1IllAsNVfmhRYuiZ6uW+HX9Rjx9V0cUCQpCz9YtxfFTmcdNLd22HQ1E37+N/p8ypLXO7m92u5ClOfp8Pk4Z11o+n0nA0wjwHFtP06gbzicosIg4t9YPa7bPVUatFHHrvj9EAIRElA6rbFVi3ghYRaNbgQwelVbWug50G4gdFZqADB6lBZAqdGfsgARIQBcCf++cj6uxF1BNxJCwluTqo/1RPK7OGh9n5DtiGfJbvR8zGbXDpk7Ds+O/QqLwtMp9sGP/0w9Nq0diwsDnlFG75/gJtBkxCmuEN9XX1xeD7u+KR9q0yjZ1adT2HfslHv3oU8gzI8KEEVutfDms3L0bh8+eU3XPXLmKlyZNxrajR01tpUm7fMdO/L1vPxZs2ozvBr2gjNrk1FQ8+dlYjF+0WPXXqk5tPHVnB1M7XpCAJxKgx9YTtepmc7qeEKP20lYsE2GSLNPY9UdqapIpz/yC+5HMaTjumsGjHMdW754ZPEpvouyPBApPINA/WK1IuiJiRlhK2uqjeavGWipmnpMI6H1+rdxnfXuN6kr6C9euqSXAallxyI/wEf82Hz4slhW3g/TqyqMN+43/GscvXsTTX4zH7i+/QIkiRdCsZk3M+XuDicAMsYx4ydZt6vio05cuI7xsGUSUK6eWFsulzTUrVcS169cxb+PGbMGjjpw7j+e+nqg8xNIYjhDGcHpGBh4RBvLGAweV0VtTeH273NYUz997Dyb8vtQ0Ji9IwNMI0LD1NI264XzOX4nCZfGlL5cfb9u/AtcTY9Hr7qHCi+uPf4+uzyWxdiPAYxFyodE9g8GjdEfqsA4ZPMphaNkxCdhFoGaVprh49ZQwQIAurfuJs9nL4sDxzD2TOTvSYkUwGnJOMsZ+XUQsLS4SHKQmcfryFWW8Si/r7DXrlHdUFhQVe2plkp5TadTKlJCcLK4vqaXI5cPCVJ72386oKO0SiamZsUcChGFsK0XHxyujVtaTBqw0upOSU3AxJsbUVHp6ZdKWNJsKeEECHkbA9l+Mh02Y03E+ARn5+JMfnsHAhz/HJ0NWqF8SE5PjMH7WixbP/qsb0UIdicAbAcfrisGjHM9YrxEYPEovkuyHBApOwNfHF6/1mymWk2ZGQk5NS8YPi9/C6q0/W+2U3lqraAxbIIM7JQrjUabqFSsIH21mevfJ3qgoAkHtE9GLk0QdmWRQJ5l37mq0CDDlpzyqMl96es1TUkpq1ktpJVtJ0iNsntJEcCgtyXNpZQoODEDxkBAtG+XDMvfoXorNMnZNhbwgAQ8iQMPWg5TpzlO5ePUk3v72YZQsXk78ylkCZy8fVb9wWpJZGra8EbBEhnkkQAIkQAKuJJBxIwPPv9cUlcvVRIrYSnNGRELOENGRLSVt9dE8BqO1hEf3PL8dW+ETHa17v5Y6lMuLNx08hEYR1dRe2P92f0AZqjL6sWZQTlv5F/p37iRWp/mqSMYTlywT+2pbm8rlMuH8piTh9ZWpZLGiuKdpE2w9khWBWy471lJ8UhJOXrqkzqj9YchgDJ82XXlp5TJkKTMjI2uk+OypBBg8ylM166bzio67qG4E5AespaTdCFgqY57+BBg8Sn+mjuqRwaMcRZb9koB9BJJSEnD09C6cunDQqlEre+QyZPu4Gq32O7N/xsEzZ5TYo8SRPeNEwChp1ErP7IvffKuCOQ34aqJapSaP7Jn56ivo0aqFqj95+Z+YvzH/AcV+E0GhZKpUqhSmDH4RnUQEZUtJ3ltpY0ov8fSXB+Ozfn2Vp3j/qdP4dtlyS82YRwIeQ4AeW49RpWdMhDcCztUjg0c5l3dhRmPwqMLQY1sScD4B+UMtY0U4n7uzRkxNS8eD732IPnd2FEGeyorlv0E4ev48FgiDVVtW/PuWrSJw1FeoX7WqeFRB1PkL2HPipDJqM4QRKhcVf/fHCuGJLYZ/Rb5KIn/KipXqDNptRzKjH/+6fgNuKVNa7c09Ifbo7hZRlsf+tkgELvOHfG2eth89hjtfewOdmzRWEZqvCy/uobNnMX3VXyKQZ6Z3d5IwcGWgKfPzds374DUJGJUADVujas6D5eYyZOcpl8GjnMe6sCMxeFRhCbI9CTiPgDRqZWKsCOcxd8VIV2Lj8MWChVaHlsbrkq3b1cNSJbl2TXpvzZPM+/7PleZZKiCVNGTN085jUeYvs11L76x8WEvSmGYiAU8kwKXInqhVg85JW4bMGwHnKVAGj/K/lLmUynmjcqSCEJDBo6irgpBjGxJwPgFt9ZHzR+aIJEACJOC9BOix9V7do3qFzF+U84PgUswxm9XKhkbarJNXBe1GwB658uqPZd5I4Hq2SfO9lA1Hni+Ons//fq88O2IhCbiAgD1/67a+zwr7XSanL3+onbV4rF3fsy7A5jFD7vKYmXjHROTfq19yed0mK7+/tM8AfpfphtWQHdGwNaTaCi5058ZDVGPtOb89zVk7PM+q5cIi0aHh83nWsVVYSdjFl8XKmYH3zrZVleU6Efg4YTa6B7VCbb8qOvXo2m4iK7wnBNhvEsKT3ksLUzLPfO4W2No0P70v5A3B8p1jxT4xGrl6s2V/+hOQ32PyZla7oc3PCHtPrIB85JU6NHpORJKtnleVPMsCi2QWt681BO1r5VmVhToReB4/6dQTu3EGAfm3W6uufoZtTpn5XZaTiPe8pmHrJbouyA2AM9FoNwIi2CSTEwkcTJfBKlo5cUQOVVACB9JOoY5/eEGb56udNBC0HwOkgSsfTCTgbgTk95l8uGsqXgpI5neZu6qHcnkBAe27jAauFyg7xxRp2OYA4okv3f0mQDLnjYBr3nme4ql1DT3njiqN2tp+jjVszWek/RhGD645FV67koB2s+pKGfIzdpDw2MrVR0wkQAKuJaB9ZkgDd+Kyx1wrDEd3CgEatk7B7LpBpPdF/mFbSvZ4Y85E77XUhSlPlqdkJJle23vRVyzZkvuR+Cu3veQKV7+xaH4C88TDM9LzOb637HmPuzuBYKWrLQ7RlfYZoT1rLLSbAt4QaET47CoCtn6gze/futxfe/Fa5hEq1uayYuc4FHSfrdxbWwktsHgDVztY4+uQ/FvKOqRbduoYAvLv9biOe2w1KeV3Vs7vMVmmfZfl93NC64/PxiNAw9Z4Osu3xNqSwpwN5B+2I/64bRm/OeXQXmvHIizijYCGhM8FJND5fAM0rBJqau2I97mpcw+8kF/+mqfWfHrWPkvM6/CaBBxFwNrNqvz7lp4Y+dAzFfS7TMrQ/PbZ6ogffvboqZF89HW/jK/gXWnYQ93R7tZ66DbmA5QLC8XEgc9hxuq16oxcdych/2aPn7B+XFFh5bf0XaYZt4Xtm+3dmwCP+3Fv/egqnfyiHTatmkOM2sIIqkVDLkwfbFswAnHtHkRa2coFa8xWTiWQVK8Z5MORSVuuxZtyR1Jm33oQkO9R+dDbqC2MbNqRdTyLvTAU2Ta/BG6rUR0t6tRW1YsEBaFV3Tq4tYrztqvkV05X1ON3mSuou8eYNGzdQw8Ol0K7CXD4QAUYQN4M8EagAOB0aJJWtpIOvbALZxBILeO8HyDk5wWXHztDqxyjIATke1O+R90xyXPYeRa7O2rGs2U6c/kK7hr9Jr7+fYlnT9TO2fG7zE5gHlCdhq0HKNHWFNzdqOWNgC0NOq7c/9JZx3XOnnUlEHD5DJypL/mLt7saD7qCZWeGIiCNWnfy0prDqxthOZ6FeR1eG4dAk8hIrHzvHZyfPhWbPv0IIx7uga1ffALpHfX18UG3O5rhwMSvcHHGNBz9biJe7v4AAv1z7/CrVKokto39FG88/ki2yb/31BPYcrO/bAUWXvj6+uLxdm1x7LtvcP7H7zFv1AgEBQSYasqlyDOHvYyHWma+B5e9/QYmvTgQO8Z9ptp0a573ap9q5cph/8Qv8dbjj5r6lBfPdrpL5devatwjAfldlk2lHv8i91+gx0/Zuybo7n/QmUZtjog/3qUil862+NoFLh2fg+efQPC+LfmvrFNNzbCV+26ZSMDVBOT70V2NWsnm15Xu6UV2td6MOH6DalXx07AhCAkMwsjpM9D1tqZ4udv9SM/IUEZtpyaN8d2gF7Dx4CEs2rwF3e9ojv/16imCjoVilKhvnmISEhGflCTiFzTGR7/MR3JqKkKLFsHdjRviUkwsUtPSzKtbvO7StAk+7/8M9p48hXkbNmHAvZ0hDWYtBQiDunxYmMgTZ02JdEvp0mgSGYG4xEQkpabg0Nm8f8Q+cfEiricl4z/3dMJnCxaqdrKf/4o5+wmj+uCZvNvLuu6c+F3mztrRVzZ6bPXl6Xa9aX/MbicYBSIBEjAEAX6GGEJNHi+ku/9IWxAFhAQVQ6Wy1dUjtFgZ+AgvoJb8fP1UfmTlhqhYJgK+4nVeSfYl64WXr42w4rYjBPvAB6VKVECwdoj8zc6LhYShaHCJvIbyirIRPR8SHIJx+8vDMO3PVXhm3JfYf/q0ae5yL2vGjRuYu249Zvy1Bt3efR8LNv0j8jJMdbSL68Ko3bj/IGpUrIiKJTON0Sply0I+Nuw/gNT0dK2q1efXH3sEaaLe4598hglLluJusew4ITnZan1ZECsM6k6vv416LwzGgdNn8qx7Q5ROXr4C0kCWBrdMdzZsoOR9Z/acfBnfqpEb/8fvMjdWjo6i0WOrI0x360reCLjzr9vuxssb5ZHBo0L2bxFLXPP+0vNGNu42Zy1wlKs8t/Tauts7gvIYmcCdzR7HI52HiaWr4iAvYc+mpaVi/l/jsXT9VDWtHncNQZfWzwpvmb8waFKx+/A6jJs50OKUG9XqgOd6foygwKLCm+grDKVk7Dq4Gl/Psb7Swkd44T4YvBTHz+7DB1OfMPU7ou8POHZmN75f+Lopz9suigYHoWyJEog6f8HkuZTezG1HjqFWpcy4FP8IT630ZH70TB+xRPkhbD50BO/P/QXHRBtL6cNf5uEZsaz3k2efRq8PP4E0nOXy4gm/L7VUPVdelbJlxPhHlYdXFl6OjcUmIYM0Pq2lK3FxOC48sflNck7SyG5Vp46IrPwP+nfuhJjrCeo6v324ez15TyyjIzN5LgF6bD1Xt5wZCdgkwOBRNhG5TQVnBo9ym0lTEBK4ScCTvC0Rlerj6QfexqET2zDlt9cwZ/mnKFYkDMWLZC4jld7Ze1s9iwNRW/Dl7Jcwc+n7WL11tsX3Qr3IlhjRdxqizu7FD4vexKxlHyA1NVl4e2tYrK9lZmSkC2N5LepF3oHSYZnGWqnQCoi8pQFWb5ujVfPKZ7mHtogwbpPFjw03hFdWS9Hx8dol1gtPa4/3P1JGn/S0y/22Gz75EG+KParSYM2Zrl2/jhU7dqKtOJ5H7le9u1FDLN++A1fN+szZRnst9+36+/khJiFBy1LPF6/FZHud84Vcgmwuf87ynK93Hz+Bs1euqrmUDS0h5AzHP4cOIdGGZzhnP+78ms4ed9aOPrLl/uvTp1/24gYEPOlGwA1weqQIzgxG5JEAnTgpZwePMp8aP0vMafDaFQQ86Yb0uZ6fIDklAZ/PGID1Oxfgj40/ZEN6QyxnDfQPEnk3VITllZtnYdehNdnqaC+a1LlT7PtMw/e/jcba7b9g+abpuBaXPy/dtn3LlUe4TrXmqjtpTMclXEPUmT1a9175fDUuHldi41AuNEwZlBKCXCQuvaZaksGWat9SGa/9OAMNBg3BHUOHqza927dF5Zv7XLW62vPMNetUP+MH9Bcd+oglxcu0ojyfU8QeXGlU1w2/Re3v1SrXrFRRu7T8nGWTWy7PkSv3D78z+2eULFYMT3XsgApi2fRyYYzLJdeekjzpc8RTdKL3PGjY6k2U/ZGAgQjI4FFchmwMhcklyNSVMXRFKUkgLwIVy0Ti4AnrweCkl23phqloXLsjPvrvH+j/0AeQe2gtpUplqgsPbQouX7N/O8muQ6vVMueWDR+An18AGtZsh71HN1gaxqvypIG3ZNt2VCpdCh+LpcYBwltav2pVtK9f38ThiQ7tIKMav9C1i4pOnCQCQskAUcmpabienITalSupYE8dGmS12XrkiAjklKrOmr0UE4PDNgI6mQYTF4u3bEV4mTJ4okN7tRdbBnlqWj3SvIou14s3b8WFa9cw9KHuaj4/iz3ETCRgJAI0bI2kLcpKAiRAAiRAAl5GwNO8LNL/5SP2wmpJegNzJrn8+PWJD+LoqZ3ocFsvtXQ5Zx312tTYdCGyza8ttlKZicnXxRny45QBHSmWR5cWS5EPndhqvYEXlXy7bDmWbt2GXm1a4+T332HFmLfEHuYAE4Ef/1qNo+fOqSN+Tk79FrvGf4HSxYth+qq/ID2+ERXK44n27ZQRqzWSS4f/3rtfGaZbDh8R+2TjtCKbz5/M+00EgDqNT/v1xZlpk/HOE48LAzTvpcgF8bPKNkuFUS+N+e9XrFQRnG0KZ6AKnvZZYiD0ThOVwaOchpoDkYD7EWDwKPfTiTWJXBk8yppMzCcBErCfwNXYc6hd9XZTw/AKdUzX5hfSqB0/60W88uS3aNmoG775Zah5sbq+HH0GgTWDUK7ULbh49ZRaWly5XA2cuXgkV11LGb+v+w4PtH0OD989VOwrDcWGXb9ZquaVef/5agLKFC+BDg3rQwZWerXHg9DOgz156TI6v/EOIsqXQ5t6dVVgJxk4SgZskumv3f+i0eCXTcGnNICyzxJFQlTEYi0vP8/no6PR9a0xaCiOIZJLkpfv2KX6Dr5pbJ8S8jQe/IopUnLH196wGKE5P2NFx1+HXP78uzDsmUjAaARo2BpNY5SXBHQkoIJH7dexQ3blMAIyeJTcZ8tEAiRgbAJTf3sd/3tmugr6tD9qMxrVap9tQmVK3oInu76GqNN7lHdPBoiKOr1b1bmtbic80/1dTBOBorbu/QP/HvkbnVo8hWe7v4eDx7egQc22CAwQkZbzmdLSU7D32AbcXu8etQw5LiE6ny09v1pqWjrOCYNyltgbK5M09syTPMbn3xMn1cM8X17Ls2rPR1/Lma0MT/NjemTgKekdzcvJnpFxQx31I5c6bzhwUD1MHV/PvJLLp+USYi3Jpc5ayu8YNSpWQDVhqD/QvBmk4b7/1GmtCz6TgGEI0LA1jKooKAnoT4DBo/Rn6qgeXRk8ylFzYr8k4I0EpDG6eN23aNe0p4hC3ChXsKbQoqXFebR1UC+ipcJzKfoUxs3KPOonXRz94+8XCJ+b60y37PtDRE3+AF3b9EdE5QaIjb+Cc5ej8o1V7ufdfmAVbqvbGb+uHJvvdt5YURqP6ToHUrqjVk38+r/hYo+z9XOKY0U05FrPvVhg5PkdY4XwAvdq0wqJKSl46L0P1XOBB2VDEnARARq2LgLPYUnAHQjI4FFMxiDgivNrjUGGUpKA0QjcUMfy/LryC+FdDUFCUixmjDlqmsTR07vw6ti7xfE/JdVxLfHCi5ohIiXLtFMEfHrls/aiTdb+zMXrJonIytMQHFgE8YnXMOF/W3ApOv/etvDytREdd8Eug9gkrBddyDNnF2zarKvBt+/UKTzx2dhs0Y5zIpUBpwqT8jvGReHxXbp9O05evAR59A8TCRiRAA1bI2qNMpMACZAACZAACRiaQEpqEuTDPJCUNiF5zmxM/GXtZbZnc6PWz9dfRU3ec2QdksQRQq0adlMG8fJNP6g2comxn1/uWz25fzclNRHdO7yIu+94AmvEUUEx8ZeyjcMX2QkcOXce8qFnik1IxOo9/+rZZa6+7BlD7/nlEoYZJOBgArk/7Rw8ILsnARJwHwIMHuU+urAlCYNH2SLEchIwLoH4xBgkJsfbPYEiwSVEIKpmYlnzw2o/bmpaCn4SEZW37/9T9fX8w5+KaL5FcvU7ce7LOH/5uNif2web/12K6YvfzlWHKCrYwwAAQABJREFUGSRAAiRgNAI0bI2mMcpLAjoSYPAoHWE6uCsGj3IwYHZPAi4icEMsMx7wbqMCjR6XcBWvfN5BRUP2F2fRJgsPMHBzA6646v9Ogzz77fN6zTzLWUgCJEACRiJAw9ZI2qKsJKAzAQaP0hmoA7tj8CgHwmXXJGBwAukZaZAPJhIgARLwZgI0bL1Z+5y71xNg8CjjvAUYPMo4uqKkJEACJEACJEACzifg6/whOSIJkAAJkAAJkAAJkAAJkAAJkAAJ6EeAHlv9WLInEjAcAQaPMo7KGDzKOLqipCRAAs4nkFGtuthrHIXAtSvV4IlP9lfPfieNl9ev4WE0KXfVBHHQn3fAiPOwJLNpUrwgAQcQoGHrAKjskgSMQoDBo4yiKYDBo4yjK0pKAiTgXAKBa1epAf1OHINvzDV1HbBnh2HzGvcqKgzbrCBgAV/sgKfMLaXdnc59c3A0ryJAw9ar1M3JkkB2AgwelZ2HO79i8Ch31g5lIwEScCUBzUtrLoOR8/yPi2jW5UJN08k5l5yvZUWj5KVXjTDNixckoDcBGrZ6E2V/JGAgAgweZRxlMXiUcXRFSUmABEiABCwTCPlxsuUC5pKADgQYPEoHiOyCBEiABEiABEiABEiABEiABEjAdQRo2LqOPUcmAZcTkMGj0spWdrkcFMA2ARk8SgsgZbs2a5AACZCA9xBIfKo/uMTVGPqmroyhJ6NKScPWqJqj3CSgAwEVPEqHftiF4wnI4FFMJEACJEACuQnQqM3NxF1zqCt31YxnyEXD1jP0yFmQQIEIMHhUgbC5pBGDR7kEOwclARIwAAG/E1EGkJIiSgLUFd8HjiTA4FGOpMu+ScDNCTB4lJsryEw8Bo8yg8FLEiABEjAjwIBEZjDc/JK6cnMFGVw8emwNrkCKTwIkQAIkQAIkQAIkQAIkQALeToCGrbe/Azh/rybA4FHGUT+DRxlHV5SUBEjAuQQYkMi5vAszGnVVGHpsa4sADVtbhFhOAh5MgMGjjKNcBo8yjq4oKQmQgHMJMCCRc3kXZjTqqjD02NYWARq2tgixnAQ8mACDRxlHuQweZRxdUVISIAHnEmBAIufyLsxo1FVh6LGtLQIMHmWLEMtJwIMJMHiUcZTL4FHG0RUlJQEScC4BBiRyLu/CjEZdFYYe29oiQI+tLUIsJwESIAESIAESIAESIAESIAEScGsCNGzdWj0UjgQcS4DBoxzLV8/eGTxKT5rsiwRIwJMIMCCRcbRJXRlHV0aUlIatEbVGmUlAJwIMHqUTSCd0w+BRToDMIUiABAxJgAGJjKM26so4ujKipDRsjag1ykwCOhFg8CidQDqhGwaPcgJkDkECJGBIAgxIZBy1UVfG0ZURJWXwKCNqjTKTgE4EGDxKJ5BO6IbBo5wAmUOQAAkYkgADEhlHbdSVcXRlREnpsTWi1igzCZAACZAACZAACZAACZAACZCAiQANWxMKXpCA9xFg8Cjj6JzBo4yjK0pKAiTgXAIMSORc3oUZjboqDD22tUWAhq0tQiwnAQ8mwOBRxlEug0cZR1eUlARIwLkEGJDIubwLMxp1VRh6bGuLAA1bW4RYTgIeTIDBo4yjXAaPMo6uKCkJkIBzCTAgkXN5F2Y06qow9NjWFgEGj7JFiOUk4MEEGDzKOMpl8Cjj6IqSkgAJOJcAAxI5l3dhRqOuCkOPbW0RoMfWFiGWkwAJkAAJkAAJkAAJkAAJkAAJuDUBGrZurR4KRwKOJcDgUY7lq2fvDB6lJ032RQIk4EkEGJDIONqkroyjKyNKSsPWiFqjzCSgEwEGj9IJpBO6YfAoJ0DmECRAAoYkwIBExlEbdWUcXRlRUhq2RtQaZSYBnQgweJROIJ3QDYNHOQEyhyABEjAkAQYkMo7aqCvj6MqIkjJ4lBG1RplJQCcCDB6lE0gndMPgUU6AzCFIgAQMSYABiYyjNurKOLoyoqT02BpRa5SZBEiABEiABEiABEiABEiABEjARICGrQkFL0jA+wgweJRxdM7gUcbRFSUlARJwLgEGJHIu78KMRl0Vhh7b2iJAw9YWIZaTgAcTYPAo4yiXwaOMoytKSgIk4FwCDEjkXN6FGY26Kgw9trVFgIatLUIsJwEPJsDgUcZRLoNHGUdXlJQESMC5BBiQyLm8CzMadVUYemxriwCDR9kixHIS8GACDB5lHOUyeJRxdEVJSYAEnEuAAYmcy7swo1FXhaHHtrYI0GNrixDLSYAESIAESIAESIAESIAESIAE3JoADVu3Vg+FIwHHEmDwKMfyZe8kQAIkQAKOJ8CARI5nrNcI1JVeJNmPJQJcimyJCvNIwEsIyOBRiWiGAPEs99v6XzqjZi4j8MpkvLwkJbf2n3HnYZu9Nkc+kwAJkIC3E2BAIuO8A6gr4+jKiJLSsDWi1igzCehIID2kCNLDayIk/hp8xLVMSeK1TEbL23z+AtL2xCvZ5X9GnYeUPSf7G8XCEIItph8fZB0mEiABEiABgAGJjPMuoK6MoysjSkrD1ohao8wkoCMB3/NR8ImPRkqAH1IqVVE9+x3Zrp6NljflCDDFjI0fjDkPOYWc7NNrNDWbGS9JgARIgAQ0AgxIpJFw/2fqyv11ZGQJucfWyNqj7CRAAiRAAiRAAiRAAiRAAiRAAqBhyzcBCZAACZAACZAACZCAYQkwIJFxVEddGUdXRpSUhq0RtUaZSYAESIAESIAESIAEFAEGJDLOG4G6Mo6ujCgpDVsjas3gMgcGBNs1g3qRLeyqz8okQAIkQAIkQALeQ4ABiYyja+rKOLoyoqQ0bI2oNQPL3KpRN7z1/Dy7ZjC6/2zQuLULGSuTAAmQAAmQgNcQkAGJaDAZQ93UlTH0ZFQpGRXZqJozmNyBASF4+K4huL/dc3ZJrhm0+45tsqsdK5MACZAACZAACZAACZAACXgPAXpsvUfXLptpsSJhePeF39CldT+s2DTDLjl63DkENGrtQsbKFggEBwVayLU/q3u7tvhiyGC82f9Z+xuzBQmQAAmQgEMIMCCRQ7A6pFPqyiFY2elNAjRs+VZwOIGklARs27cc73z3KHYfXmPXeNJjO2/VWLvasDIJaAQqly2LsUP+i9O/zUeRYPv2dmt9mD/37twJfe/rihd79jDP5jUJkAAJkIALCTAgkQvh2zk0dWUnMFa3iwANW7twsXJBCKSlpWDOik9x+OQ2u5pzGbJduFjZAoGhvR/D0/d1AXx8LJQyiwRIgARIwBMIcH+tcbRIXRlHV0aUlHtsjag1L5GZy5A9V9H+fn54/qEHcXvdOggKDMSVmBh8MftnHD19xjTpJrVr4fkHu6NE0aJISE7Gxn//xZTfFuHGzRqDH+mFehHVMG3xErRqWB9Na9dGWno6pv2+BKu370CNWyqjXZPGqravMGzHvzIE4+fMRdvGjdCgenVs2PMvGorncqVKYt5fq7Fg7ToUDQnG6888gyoVyiNd9LX94CEll0koXpAACZAACbgdARmQiMkYBKgrY+jJqFLSsDWq5jxcbumtlY8xkx/z8Jl63/QC/P0xedRIdGvbJtvk721xB7q8PBSHT51WBu/PY95BqRIlTHV6dGiP24Tx+uInnyHjxg3I/a5NhfEr24UWK2aqJ/vtPnykMEwzUL1yZZXvIwzbnh07KIO3e9u2aFavLh6+syP8fDMXrew8dAjVKlbE6glfib6Kmvq6v01rPNXlXtw/7FWcvXTZlM8LEiABEiABEiABEiAB9yLApcjupQ9KY0ZABo1i4CgzIB5y2a/b/SajVnpp7xo0GFdjY1E6NBQfD3oB1YWndfGnHyuj9tyVK7h3yFD89MdyNftH774bQ594PBsJadS+9NkX6PrKMNwQBq80YutHRuLgiRP4e9duVVcawoM/H4sVmzeb2kqj9p+9e1WdBWvWYcprI5VRm5KWhn7vfYA3vp2s+ouoVBFDHn3U1I4XJEACJEAC7kWAAYncSx95SUNd5UWHZYUlQI9tYQmyvUMIyGXITJ5HQBqddatVUxO7GhuHd6dOU8aj9MJWKF0a2w4cRPN69dTyZLnkuNeo0dh7LArSo9qlZQtl7N5zR3N8+tMsE5xlm/7BjGV/qNeybv3qkahUpgyuCGP58KlTaNOooRrjV7HcOCEpydQuIyMDfd4eg4vR0ShWJARNatVSZSO/noh5qzODnJUJC4Vc8tyzY3sM/+prU1tekAAJkAAJuA8BBiRyH13YkoS6skWI5YUhQMO2MPTYNt8EQouVQdEioSgdVkm1qVSuunq+eOWk2BeZmq0fLkPOhsOjXhQJDjItL75w9YoyOOUEpXGqJbnvVqaU1FRl1MrrZHF94PgJsZe2gdpzax7h+PDJU7KKSnEJCerZ39/vZo71p6SUVGXUyhpVK1RQnl7h2MW5y1lLjrU9v2HFi1vviCUkQAIkQAIuJcCARC7Fb9fg1JVduFjZTgI0bO0ExuoFI9Cr01Dc2SxrCemnQ1aqjoZ+cSfOXTqWrdO6ES3UEmQuQ86GxSNeJCQl41pcnJpLePnyN43JG3juoe7Cs9pILB8+iaizZ1V5oNiLG1m5Eo6dOav2wtaLiFD5sdcTsnleU9KyfhiRS5EtJRkTWXqLzVOqWTs5hkyySqnQrH29UkaZNJnVC/5HAiRAAiTgVgQYkMit1JGnMNRVnnhYWEgCNGwLCZDN80dg8vz/QT7yk6Rhy7Nr80PKeHWk4bnnaOYPGcVCQvDBwOfx1/btarmvXD5cvEgRzF+zRkU3lpGTZ737Nt78bgpaNaiPsOKZAaJ+37DB5OmVBCybsplspKdXJWGx3te6JbbuP5D5WvyfJoJLaSlRRF3efeQoGtaojrf/0x8xcfEoIYJIDX7kYVVl0d/rtap8JgESIAESIAESIAEScEMCDB7lhkrxZpG0ZcjezMDT5z510WJs2bdfTVN6aqXxKo3aOOGJHfn1BOyLOo4OAweppci1wsMx8+038VKvTANz4bq/Me7nuflGtGpr5tnJ8rifSSOGo4+IcGwt9X//A3XETxkRxGqGGHPCq8MQGBCgvMMfTp9hrRnzSYAESIAEXEyAAYlcrAA7hqeu7IDFqnYToMfWbmRs4EgC2tm1XIbsSMqu7VueNfvgiP+JY3TuQZ2qVVU05COnT2PJho04IJYiy7Q3Kgo9Rr6G1mJPbd2Iarh49SqOiSXK8sxaGfRJph+WLMHyfzaL82j3qNfyPxk9ee3OXcIzm2k4r9i8Ba998y1aNrgVpy9ewpodO9VZuSuFwSu9tOZJHjPUuE9f9OjQQR0TdEP4gg+J/bvf/bYQqSJSskxzVq5SZ9umZ6SbN+U1CZAACZCACwkwIJEL4ds5NHVlJzBWt4sADVu7cLGyMwhwGbIzKLt2DBmdeNL83/IUYv3u3ZAPa2n6kmW5imYuX5Erb8Kv8yAf+UnS+B0/x7pHWEZWZiIBEiABEnAvAgxI5F76yEsa6iovOiwrLAEuRS4sQbbXjYC2DJneWt2QsiMSIAESIAES8HgCMiARDSZjqJm6MoaejColPbZG1ZwOclev0CLfvVyKyR652FLDsqGRlrLznactQ7ZHrnx3zooWCWy1mMtMdybgqL+Po+c3ufO0KRsJkAAJkAAJkAAJ5EmAhm2eeDyvsHPjIWpS2nN+Zzhn7fA8q5YLi0SHhs/nWcdWYSVhF18+DQy8d7atqizXiUC/uI916ondOIOA/LvtFtjaYUNJ43b5zrGgkeswxOyYBEjAAQRkQKLAtSvptXUAW727pK70Jsr+zAnQsDWn4cHX8oZYenoc5e0pLLrAIpk9pCQUtie2JwESKCgB+fmg/bAkDVz5YCIBEiABdyfAgETurqEs+airLBa80p8ADVv9mbpdj9KotddD6+xJFC8FJNOodTZ2jkcCVgloP4bRg2sVEQtIgATchAD317qJIvIhBnWVD0isUmACNGwLjM4YDaX3xZqX1h5vzJnovXlOWJanZCTlWSevwr61hmDW4rE0bvOC5Iiy6o7olH06ioBaKnx1i+7da58R2rM2gObBnbjsMS2LzyRAAiTgdgRkQCImYxCgroyhJ6NKScPWqJrLh9zaksKcVR21xNCW8ZtTDu21jIYs06INXPaoMXHac/UXnDaUuwzU74H70bNjB3R9ZZgS6Zf3x2D1jh34au6v7iKiVTmkYXtmn/6GrTagNGQ1T62WJ5+tfZaY1+E1CZAACZAACZAACbiSAI/7cSV9J48tDdph06q53b45LRqyk3FwOC8lcFvdOmjZoL5p9u2aNEaL+lmvTQVeeCENZ+mdtWc1hxdi4pRJgATcjIAMSMS9m26mFCviUFdWwDBbFwL02OqC0f07cZSXVo+ZS4/tmMnGXOro6+OLwIAQJKcm4MaNGwpHqRIVEB13wfRaD0bsw3EE2g8chCsxMY4bwIA9y88LaeTSU2tA5VFkEvBCAjRqjaN06so4ujKipPTYGlFrdsrs7kbtvmObIB9GTBGVG2DqW3tRoXSEEv+eVs/gy5EbUbNKUyNORxeZw8uXx8JPPsLlP5bg0NzZeK3v09g/+yc0qlEDPj4+aNWgAfbNmoHoFctweuECfDFkMEKCgiyOvXnqZMx85y3VTqsw4MFu2Cf6ayj6s5XkeF1btcSxeXPVeKu+Ho8iOcaa+c6bGNSrp+pq/kcf4Ic3RmPdNxNwYckiDOzxUJ5DBPj7Y/eM6Tjw80zxHiit6pYoWhS7fvwBe36aDllu1KT28zIqslHVR7lJwKsIMCCRcdRNXRlHV0aUlIatEbVmh8zufnMqDVqjemstqeHE2b04EPUP4hOuWSr2+LzIypWw7IvPcLtY7jt60rf4e9duvPL4oyhXsiRCgoOEMVod8z56H1diY/HKuPFYv3s3+t7XFd+NGmmRzdHTp8Uy4VtRtUJ5U3m3tm3gKwzWc1cum/KsXdwaGYGJw19F7PXrGDVxEgL9A9C9Xdts1SuXLYvIypVVXrWKFXB/m9aIEPO4GhsnxriSrW7OF6lpaRj1zSSUCQvDuJf/Cz8/P3w86AVULlcWH0z/EbLcyMmdfxQzMlfKTgIkoC8BGZCIBpO+TB3VG3XlKLLsVxKgYevh7wN5Y+pJyd8vQBgRlXFL+drq2dfXL9v0ShQrLYyUBqhSoS6KBJfIViZf+Pn5o2SJ8mr5sHlh8aKlUEI88pOkDGVL3oJwIUNo8bLZmhw5JYIQ/fxfXLhywpQfWqyMGrdsyXBULBNpyrd0IedTsng5FA3Jkl0udw4TeZbmY6kPV+b17twZ5UqVRK9Rr+ObeQvw7Jj3sXRjljc+vFw5YVz6Y8U/W/Dznyvx6Og31HNKaqpFsWVQp7BixVAvItMjLr2hzevVw7YDB3Ep2vaPB18PG4rgoEB0f3UkJs6bj/uGvoq4hLzPlZJG82NCrrqP9caCNWstymWe+cemf/D7+g3o1LwZnnuwOx656078uXkL5q78y7yaYa897TPEsIqg4CRAAiRAAiRAAnkSMO46uTynxUJJQHpr5cNTUnBQUYzuNwsVylSDn68/0jPSkJSSgOFjOyMhKRbhFerg9f6zERgYIva3ZuBa7EWMmfI4rlw7a0JQsXQkXus/E6u3zsHPyz9W+YEBwRj+9PeIjr2Az2cMMNW1dBEk9tOOfPZHZdRKGeQ45qleZEu8+MhYvPPdIzhz8YhYQuuLkc/8iKgzu9G8flckJV/HoI8yo0Cbt9Oui4WEYVS/n8R84vDmNz1UdvXwxhjWZwqW/j0ZC1Z/rVV1u+eiISGoXLYMYuKv48T58yb5Nuz5F11aZs758KnTSBFezEG9HsYT93TGzsOH8aHwbO44dNhU3/zipz9W4IOBzyuv75ING/H+wOfU8t6h4740r2b1um61qjhw4oRJnpj4eGGEbsRjne6y2kbuld6we4/V8pwF0is78KNPVECq954fgKiz59D33fcM7601n6c0bt39LGxzeXlNAiTgXQRkQKLAtSvptTWA2qkrAyjJwCLSY2tg5XmT6MWKlMS4V/8WXsviwiD9FNMWvSWW/G5W3k1//0C1B7PP/W+qIE6TfhmGb38djuWbpudaEnwx+hTirl/F7fU6m/DJ/bFVhFF84PhmU56lCxkk6vX//CyW1Ybj15Vj8e284Vi3c162qtKbWzQkVCyVzfIkS5mb3XoPlq6fYjKmszUyexF7/YoyXmsIY/bZ7u8pz/CQ3hNx5sJhLFk/1aym+10WEUuNS5UoIX5wSM9m1Jl7SA+ePIkuQ4ZixrI/hK5SlZdz5Vfj8e3I4fAXy3hzpnjhXf3pj+VoWrs2GtWsAbkMefO+fTh/9WrOqrley/7kHtf4xMRsZacuXsj2OueLpJQUZNwMBJazzNpr2eaIWDYt06Vr15Txbq0u80mABEiABPQlwIBE+vJ0ZG/UlSPpsm8ath78HvCkJYT1q7dCcWHczl3xGVYIg3XNtjnYc2SdSXvSyxYcUES89lGBqDbvXaoMyWTh0TVPKamJyuCtXK6GWLLcUBW1a9pTGKK+WLV5pnnVXNflSoWLJdC1sFqMLY3UjbsXYe22X3LVs5Sx//gWZQyv25HdELZUd/3OBVgpZLmreW/l7ZUe5W9+GQopuzsnuSf1+Llz4seHYLHcu7hJ1AqlspZ4y722rRrWx8czRPCnJ/ugwRNP4dSFi+gllu82rlXT1Mb84vNZs5GWnoGvhr6CoqLvX1atNi+2ep2Wno4LV6MRWamS8PBnfdQ1rVXLahtZoEW3zrOSWaEMUPWe8CS3uPVW7D0WhWZif/GEV4fC12xMs+qGvPSkzxJDKoBCkwAJ5EmA+2vzxONWhdSVW6nD44TJutvzuKlxQp5EQHpBpcFx/spxq9P6cck7IrpuMYwfvh7/E8t/61RrbrHuX1tni+NdzmFw7wnKA3z3HU9g4dpv1LJmiw1uZgb6BwsPYBCOntqVVzWLZYmJsRbzrWXO/ytzqW3FMhH4bc0E4QXM9AZaq+8O+enCkFwvlvAWE0uS3+r3LIICA0Wk4FLofU8nk3jtGjfCuwMG4PVn+6pIyCmpaeJopDhVfvlajPDAF8cnL72Ip+69x9RGGqeHhKdXBoKSxuKqrdtMZbYuJi9ciPLCsB7R50kVcEp6fDvedputZnaV1wwPV8uq5b7fji++hDU7dqgAVc3r1bWrH1YmARIgARIoGAEGJCoYN1e0oq5cQd17xqRh6z26NvRMM0+IFVMQ3rGsZH4NHDqxDa981kF5ZCsIg3Dw41+rQFFZ9TOv0tPTlEe0rAhC9WTX19Wy03XbbXtStX5uwCRNtmNotHI9niuK5dHSE5ienio8mR3FMt1APbp1eB8L1/2NmWLpcIemTXB20QJxzM9MlBURg7W0evsObD94UOxxvRtnFv+Gg3NmoWb4Lfh+8e/K2xsqAkX16XIv2jVprDUR+42ThLG4U/HYKfbiHj1zxlRm62Lir/OxcstWDOv9OM6L43umjh4lPMQWliLfXHqcpVlbPWeWhwlDfP6H7ysj/u0pU9US7A+mz1Ae4mmvvwY5HyYSIAESIAESIAESIAHHE2DwKMcz5gg6EEgWQZekoVehdDURiCkzsE/diDty9Sz3qP60ZAxOXziIAT0+FsuXS6mgUDkr7jiwEo90Goq2YhnycXFEz8Xokzmr5Hqdlp4ilsSmCkOsCWR7me6of596lkuZ9Uz/6fERklMSlQF+b+tn0Lh2B2zZ+4eeQzisr5c+F8Gzpk5De2Gc7j56FN3btsXwJ3ur8S7HxOCBYcPFnubyuOv228S+5pPYI+rIfJnk/tdGTz4tvOcp6rX237tTv8eXc3/B9Rz7ZbVya8/XhVHc5+13UbtqFbRu1BBLN2xSe2DlcmktySXRySmZUZnvGfyyXUuIE4Q8d730X2RkZIj3ULTqcvPefagvlljL94Q0yplIgARIgAQcS4ABiRzLV8/eqSs9abKvnARo2OYkwtduSWBf1CYVlOjRzq+KpaVVIY/nuV0EZNKSXCI8oOfHuBx9WpxZelUYnF2RmBwvDKTr6ligNwfMxc5DqzFlwSjV5OT5/WJ563bUqtIUi9ZMFIZJutaV1edLom/56NjsMREcKEkdv3NPq75qiXRgYJahZLWDfBT4ieBTA3p8qAJQjfqqKy6LiM5VK9YVkZbH4Y1vHsLJc/vz0Ytrq0gj74II7jRn5SolSOfm2ZeEJyYn4+CJk+qRU9J0sZfWUmAoaeiez3GmrDw2SP7YYS3JAFAyYnGCGE9GXTaPvCzPtdXS+StZgahk4CfzlJ8xcsol218Uy6eZSIAESIAEnEOAAYmcw1mPUagrPSiyD2sEaNhaI8N8tyIgj+J5+dN24qieWejapp/wnKZh54FVaFLnTiWnjEYsz3mVRqc8hkd6Vn/583NhYJxE6dCKCAgIUh40bVJyv+7Yn57HqGdnQAaayk+ShvKY7x7NlKF1f2E0JWPm0g/QpsmDyjMs+0hOTVIeYnkUkZauxV1EXGJ2g0kry/ks99TWjWghPItTce5ylCqePH8khvf9AZ3ueAozhDc6Z0CsnH2422tp6Eoj096gTHnNo2Lp0lg3aYJYal7CajXpTQ3vnnlkktVKeRQ4Y4w8hmcRCZAACZBAPgkwIFE+QblBNerKDZTgwSLQsPVg5Xra1C5fO4Ohn3cUkXFLCC9cHO5u/oTJsJVG5yc/PKOCR8kAUvHCkEwRRqZMMlDUEGEUp6VlX94qDc43J/W0C9O1+EsYMa6z8hhfFwGh5PLkFZt+EIZb5nm2e4+ux0sftzL1Kc+51c6jNWXmcXH6wiEM/rh1thoXhHEu523UNH/NWuyLOo79x0/oNoUrsbF45t33ERgQYLXPlLTM5cVWK9gocMYYNkRgMQmQAAmQQD4IyIBETMYgQF0ZQ09GlZKGrVE156VyyyXDcQnWl3lKA1c+cqYksUfXUkpMyozIq5XJ823lcuCc6ezFIyLo0EGVLY3YmPjLpiry3FZ7UsUykagilhfnTCliT+2Og5nLd3OWGfn1mUuXIB96phRxBu66XfZHp7ZHBmeMYY88rEsCJEACJEACJEACJGCdAA1b62xY4uYEUoUHNj4hRuyPzVr2W1iRZcCpkOCsM1i1/haunmAybLW8gj43rt0Rvbtk7vU17+NS9CmPNGzN58hrEiABEiABEtCbAAMS6U3Ucf1RV45jy54BGrZ8FxiWwKotsyAfeqYBY7KOmdGzX/O+lq6fAvlgIgESIAESIAESKDwBBiQqPENn9UBdOYu0d46j7xkl3smQsyYBEiABEiABEiABEnARAQYkchH4AgxLXRUAGpvkmwA9tvlGxYokQAIkQAIkQAIkQALuRoABidxNI9bloa6ss2FJ4QnQY1t4huyBBEiABEiABEiABEiABEiABEjAhQR099gGBRZB8wZdsG7brxanFfb/9s4DTooia+BvM3mXHCSjJBUwoKCCioLhjCgehjOcGO8+xXjnGc9wd554ot6ZTz0jBjCcJ4qCigkFFJGgKBmUnGHz7tev1x5mZmd3Znd6erpm/sVvmJ7q6qpX/9c706/fq9dN20jfHoPlp/WLZflPC6xnW1Y9JiVi418q+3YfLCOHXyV3PnpGbc3YBwEI1INARbtukr0+VxounGkfvX3oKfZ79vrVxtVFmr6J84gkc2WTgkjToy6IQPvW3e3Hgf24ck5QbdVmRkaGdN+jn7Rt2VXm/vCRlXhuS7U2kSpuGjNBFi6dIROnjo+0mzoIQMAHBEhI5AMlxCgCuooOqkv7vlJUslPWbqz+mMRs68kde3U+QJo0KrB+y6ZLccmu6B1aLdLlt8xVw7ZX14Fyzgm3SI9OA6oZtvps0RvGvGDt6289X7RY8nIbysIlM+Qfz4yRnYVba1WKGrUUCEDAfQKOMZu9/ifJKqz6cmyw8gd7IBPrCvsMDIGk8zNxHpFkDp9byETT/ENGRqYcf+iFMmr41fLu589IuGF78D7Hy6Wn3yuV1r+crFzJyMyU59++00ri9mRUcn27D5JJ0zBqo4KiAQSSSICEREmEX8eh0VXNwDKt37JRw6+Rk4/4nTw44f9CDNsMyZDjDrtQzhh+nZSVl0gDy5Goj5/850tXyJfzJtfcqbVHf8fS5bfMFcM2MzNL+nQ7WK7/7TM1emD12aKLls+S2x89Xcqsx7Qcd9gY+c2Jt8iQ/U+Xd6JkiFWPLd7aWs9ZdkKgXgTUgFLvYHBpsKDKc2tiXWmrPaSsdYeA6OFzCf+sDU2qU31RQgnk5TSU3/36ftmv9zDRi4JIZVfRNnnzo4fkjQ//ZT/O629XvCMnDLk0qmGrFwJaFlg3YSkQgIB/CZCQyL+6CZcMXYUTqfrctHELufHCF6SDFXkUqeiN2V2F2+Q//71VPpz1krQs6CDjr50uo4/5Q1TDVvvT37F0+C2LfBUQiWgtdaqMP174vEz+5N/y+tQHa2z53Fu320atNpj34yeW+7xQGjVsVmN73aFGrZYFSz633/kPAhBwj8D2oSdbhuAe7nVITwkjoAZ4+E2IhA1mUMd7dh4ge3baT/710ljZumNjRMm/tX5vXvvgQfvutkYI6e9PwwaNI7YNrhw5bGxaXAgEz5ltCJhIQBMSYTCZoTl0FVlPB+9znDRq0Mz6Las5SvXD2S/LB7Mm2NFHG7astn+fmjZqHrnDoFr9LUuX4orHduv29fJ/fz1ItljvIwafFxO7BrmNJdsKCVu7cVmt7TUMGaO2VkTshAAEIJC2BPQO9Nhxh1m/J3k1RgwFw9FwrnbWOtuNW6J7v9Vje+cTo4MPZxsCEIAABCDgOoEPZ70i02ZOkIImrWPqW/NGaF6JVeuqlo/VdJAThpwuv2WueGwVphq1dSlD9j9NNIT5qwXv1XqYemwnvXdfrW3YCQEI1I9A0+lv4AWsHzrPjyrqO1D0RQklUFlZaedtCK2t+ZOGb+3RZk+Zv7j2KCDCkGtmyB4I+I2AJiRi7abftBJZHnQVmYuum62oKI+8M0KtJkNsmd9ePvn6tQh7d1f16TbI9uymQxiyzto1w3Y3wuhb3Tv2kyMPOlNefvdu0bW3NRXCkGsiQz0E3CFAaKs7HL3oRdcPU+InMGS/kdK4YYFM/+qVWjsjDLlWPOyEgK8IYNT6Sh21CoOuasUT886jDj7buqlbZGdGru0gNWzTKQGi54atemlHH3eDrNu8Qt6f8VxturAf8UMYcq2IQnb2aFeV6CSkkg8QqIUA62trgeOzXTkbVtsZnv0glqnfNR3b9pTTj77aWm/7gCxZ/W2tKNVjm04XA7XCYCcEfE6A9bU+V1CQeOgqCEY9NzWvxOH7j5Jn375D1m9eWWMvThhyjQ1ScIfnhu2oEddKH+uC4anXb4z6mB/CkOM74xavIZNnfART/2iSR5mj42QnjzL9+yQnO09+f8b9snLt9/LW9MdqVbxeDKRLBslaQbATAoYQICGRIYqyxPSTrky8SdumeSe55pzH5KvvpsrUL56vVfFO5FG6hCErDNcMW/XEZmVl2+tmtWPd1ldwGdz/ZDnJejbTK1PG2c+wtdvX8HgGwpCDycW2beIfaGwzoxUEIJBsAuGG7YgB/smymJW5+/dGH/kT/tuiyQovP+M+yW/aWh559RopLS+u9vsUzDedMkgGz9sv2+G/ZeHnnl/kRA4IQMA8Av79PsmQkN+yX+wqfU67Uxo3zJeLRt4tZRWl8vzkuyLaWk5b5z3dIo9CLU+HQj3eLz59nPTrOVTyrAcGa3nwhi/sR/vc+tApsnnbWunRqb9cfPo9olm8fjXkYjn20N/a7fShwk+/fpO9Hfwf2ZCDaUTf5kIgOiNaVCdA8qjqTPxa4ySOivTcXb/K7IVcudZzbG+75FVp3qyt6KPnjrbWHR064BSZ+uVzMnHq/bYIo4ZfLQfvc7yUlhXL9ec9HRDrrn+fJavDMko6oVvpkkEyAMNHG+E3Tfx7IeojaGkuiiYkyp0+lUf+GHAeJFtX+n0SfM2s3zdT5oxPOrkOrXvIdef9WxrmNbFlueCk2+Xs426Ul6b8XT6a/YrtOLz0tHGyd49DrLW1hXLLRS8HZL7t0ZGyblNoSPLu37L0it50zbD95vsPrDjvFQHIulFRXi5FxTvtupYFe1jhXw+H7NcPK9d8X61OvbX6uvPRM6rtoyIygfALAT/8kUaWlFo/ESB5lJ+0UbssmjxK19kmq+h3SvD3jF8uBioqyuSTOa8FLgYcPt8vn+1sij7vb+LU6hcuhUXbA22CNwhDDqbh7bZecAZfdOroGLbe6sDE0UhIZI7Wkq2r8O8Tv/yW7SjcLB/Oetl6dF1OiDJX/LzQ/qzRSN+vmCXLfp4fsl8/FBXvqlbnhCFX25HiFa4Ztp9/82atqL789m3RV6xFk0aROCo2WvpHGXwhoH+04X+4sfVEq3QjoMmjMG7N0Lofkkf50bgtKy+Vtz95olYlTv70yVr3B+/Ui4GFS9PrDnfw/JO9HXzzRGXhJm2yNWLG+CQkMkNPKmWydaXXx378Ldu2Y6O88eG/alSk/ta9Nf3RGveH71CPbTpGHu0O3A4nksTPGoZMiY2AGrRcCMTGilbVCZA8qjoTv9YkO3mUcgk3MvS7J/z7x6/8YpHLCd3CsI2Flvtt9FwKvkmrI4Sfc+6PSo+pQMBPCYlSgWci5+BHXaXib5nqMJ2SRjnnrO8MWycMedJ79zky8l4DAf1DvOzYCSF78daG4OADBCDgMoFwQyOVLgic0K10vBhw+TSpc3eRzqPwc63OnXIABCAAgQgE9Lsl/Psl0ndQhEONqHJ+y4wQ1mUhfWfY6vwIQ46u5Zr+AB9+Z3T0g2kBgV8IkDzKnFNBk0c5CaSSKXVNFwR6ky3c25ZMOes7drplkKwvJ7eOc37L9D24RDrPgvezDYFgApqQKNlrN4PlYbtmAn7RlX7HhC/b0++hVPgt0+ijdP0tc22Nbc2ncN32aBgy3trIzPSiMVLosdMao9YhwXusBFhfGyup5LdLdvKoYAJ6QeB8Hzn1+lkvCJz1S+EXDE47v747YciTpvlVwtSSyzFknffg2TnnUHAd2xCojQBGbW10/LXPT7rS6+Zx5y8LAZQKv2U6oXSNPMq465JPKxXA16uekG2bK3QzYmmd31327jI84j63KvVJQQcPHCxfzPxcSqon+HJrmLj7qShobveRuXVL3H3F0oH+kUUr+sdp2oVktDmxP/EEUi151Pahp0hZ6w4BcM0nPhTYNn1DvbXZ63/yVbKvWO5sR/teWr91icxf/l6t6tm7y9HSOr9HrW3i3XnQgVXfs1/O8m/iqIr8AsncsjneqYYcr79nfvotw1Mboh4+xEgg2Y+QiVHMmJuNe3pf6XdQfqD9iL6fBLZN3/Cjrvgt8+6s0t8xLW79ljVrkSnrtyyRz75+x+43e88Oh9gbX/34ujRtaG9G/K9ZozbSo/3giPvcqmzZUUQzVnfKt8bZ/ffsVvfu91MLL/cHi9wjFwGRuVAbGwFNHkU4cmyskt3Kj8+v1Rtq6nGL5HVzeEW7MVdUvF2aNmjtNI/43t26udcmwYZtnnVjdcMq8X84dSJ+dxLRZ0RN1l7J71ntfNhbMwFNSEQxg4AfdcVvWRLOHRd/dyqta4hmjb62J+G7NbbbNyUBrsFDRrtoNHhqiA4BCEDAEwIaLaTFz5FCVRLyPwQgAAEIQCAyAX7LLE9wZDTe16oy9I45pW4EnLUAGLh140brKgJ4a805E/ySPCqYWDRvbXBbP283bVEVLeRnGdNBtlQ5n9JBV36bo18SEvmNix/l8aOuNBS5tsgjP3KMJBO/ZSLZYx+pWo825PhGMn9Waa3rbN+aeVckjq7U3XTJy7Juicidj57hSn+J7KSsS3fRdUm58+Ykcphqfavxqn944UasY9yyzrYaMiqiECB5VBRAPtrtp+RRiqWmNUkaTqrFebc/xPnfl0tejrOH2g9/4S/L7AfZ+znZhq5LKtl7gDT4eGrtk6nj3qIhR0nu/DmerbN1xKvp98z5jdPfMwoEYiXgp4REscqcru38pCvn+jmSLpzfMOc9Upu61iXyt0wTIN40ZoLvf8vKOnWVimb5kjv3q7rii9i+U49saVqQIXMXFNn7fZMVWZ9fa4JRG5GqR5WahMX5sY90Z1svNK99uqtH0jBMKhBIteRRqaCTmuaQs2G1nTyqpv1e1kcyavXH380LAK/moxcDWvxs1HrFwstxnN+zSAauU2fi+eQlQ8baTSBr+dLdH9jyNQE/6SqSl9bU3zJVuv6OpftvmS9CkdWorVLI5/Y7/0UnoH94jpEb3FovOCkQiJWAJo9S45bifwKaPMoPHnbHoxZMzOQLgXR+kH2wDpO17Ri44UZspJu3yZKRcf1PQBMS+clg8j+x5EnoF12l4m9Z8rTqn5F9Ydjqs2sXLMGoretp4VwQBB/n3OkOrmMbAhCAgBsEIn2/mGzUKpN0fpC9G+eEW31EOo8ieVPcGo9+IACB9CWQar9lu5/DXrUUKH0165PkUZPeu0/0Rak7ATVuI93prntPHJGOBEgeZY7W/ZA8KtzQiPT9Yw7RKknvfGJ02odu+UVnGLd+0YR5cvgxIZF5FL2R2A+6Cv8ti/Td4w0Nd0bR8GN+y6pY+sJjq95aPLb1P7n1D1IvMINL+B9t8D62IeAQ8ENoqyML77UT0ORRyS56lzu4hN9UC95nyna6r0fyu574LfO7hvwhn58SEvmDiH+lSLau9HeM3zL/nh/xSuab5FGxTqRBXmPp2eUA2b/PcKmorJAlK+fI7IXvS2HRdruLlgUd5KQjLpfWzTvJip8XyrufPSWbt62NtXtj26lhG/6HauxkENwzAiSP8gx13AMlO3lU+PeLfueE31CLe5I+7iBDMqRFfjsZ0OtI6b5HP9m07WeZ8/2HsvSneVJRUS6ZmVnSq8uBMnzQufb2rPnvypfzJ0tJaVWmRh9PzVeiOTdLgg1aPffS6VzzlUIMEYb1tYYoyhLTb7pyvnPMIRifpBkZGdK2RRfZr/cw6dS2l6zZuNyyo6bIz+uX2HZVVma2ve/w/UdJSVmxfP7NGzJn0YdSVl4a38AeHe0Lj22sc1Wj9pZLX5Vrz39a9uy8nwzqd6JcPvoBOXrQbwJd6L7DDxwt2dm5Mqj/SXLykf8X2JfKG+F/mMEXBak8b+YWHwGSR8XHz8ujk508Kvw7Jfw7x0sWyRhr+OBz5W9XvCNnDL9OunfsLycNvVzuuPwN6wKhsy3OgX1GyM0XvSSd2/WWJg3z5aKRd0vPzgckQ9SUGzP8pkrKTZAJxU3ALwmJ4p5IGnSQbF2F/5al202zM4/5o/zl9/+TE4dcKj067SenHzVW7hn7vhQ0bWOffccecoFcdfaj0qKgvX0z99JR99mGsCmnplEe21OHXWHdXegtdz95jsz78VPJzMiU5/623H5X4NlZOdKlfR95Zco4eW3q/VZNhnXnPMMUXcQtp/5xcgEQN0Y6gAAEYiCQThcDelP1mMHnWXe2l8kdj//a9sK2KthDHrj+U8nIyLJpdenQV4pKdsp9z18iq9f9aP8uVUplDCRpEk5Ab5oEX3zyuxZOiM8QgEB9CQR/n+jvWDr9lrVr2VWOOvhsmfvDdBn/wmU2wgOsCNhrfvO4ZGSqrzND+liPwFu3eYW1ZvdMOxpWbS2TfsuM8tgefuAZsmj5LNuojXRCq5tcw441FPnM4/5kGbrZVohYRaSmKVkX/scZ/MebkhNmUnETIHlU3Ag968APyaOcyYZ/1zj1qfqel9NIWhV0lM/n/rfG0OJNW9dIXm4jue7cJ+1w5cpK61LAelEgAIHEE/BDQqLEzzI1RkBXydOj3pDV36nPvnmzBiEqZa0VmqzLOW+/dJIdHavLPk36LTPKsG3SqIVs3PpzDcqoqh7/3CUy57sP5JhDL5AH//Sl7LPnkFrbsxMC6UyA5FHmaD/ZyaPS+UaZ3rHWiKCNW36q8YT5cNZL8sLbf7G8trts4/bGMS9I82Zta2zPDghAwD0CyU5I5N5MUr8ndJU8HesyTf0927ZzY41CvPjOX2XS1PGSk50nf75kklx51kPSqEGzGtv7bYdRhm1h0TbrrnmHAMOcnLzAtrPxw/LZcv/zl8pVfz9MdAH0JaPGObt4hwAEwgho8iiKGQSSnTzKDEqJkbJSKqS8osz6/dn999KoQdOQwXT//z55XP74wLHy2MTrpXe3g+XgfX4V0oYPEIBAYgj4LSFRYmaZGr2iq+Tpsby8zPK+VkizJi0DQjTIaxTY1g2Nfp007QEZO26ovPHRQzKw7zFWwsR9Q9r4+YNRhu2sBVNkLyvrZP9eR9hMhw86L4StZvrq2fVAu27L9nX2HQmT7jKETIYPEPCAAMmjPIDs0hDJTh7l0jSM7EYzG+syl0P6nyx5OQ2tu9dN5f9G/zNkLprfoUmj5nbd2k3L7UzJuRFuvoYcxAcIQMAVAslOSOTKJNKkE3SVPEVv3r7WXk4zZMBIW4hmjVvYCRGDJerbY7D9G6d16zettPJIZEqWFbFkSjEqedQLb99lhRYfJtdf8IytmLLykhDOfboPlhus8K+yshIraZRls1vLm16YfFdIGz5AAAIQgAAE6kJgl/U4uY+/mmjnb3j8lm+tQyurPUbu+EPHyGH7jZRdVmSR3lDdbN1c1UckUCAAAQhAAAJ+ILB63Q8y03ISDu53gvzn9h+syNbQsOQcK1R51FFXW07EA2Rn4VYrw3+BrF7/o6xa+70fxI9JBqMM2+07N8kfx4+QDq17WGuX2skPViKpf900OzDRRctmybXjjrC9tmrcaqIpTehBgQAEIhMgeVRkLn6s1eRRWtRzS/GewMRp98sHs1+S7h32lS071tvZIv8+9r2AIP9568/y7oxnpNse+9jPA9TnqO8o3BLYzwYEIJA4ApqQKHf6VN89IzVxM6ZnCNSdgCaBeuTVa+TV9/9h/5b9vHGJZVPtaUUgPWh3VlpWKvc+d5F0bNNTOrXrJct+mi+rLGO40Lq5a0oxyrBVqHoH4YcVX9l8dQF0cFEP7lrrcQz6okAAAtEJkDwqOiO/tNDkUbrOlpIcArouSZNHOQmkgtfbqkTqqV2y6hv7lRwJGRUC6UtAExKVDD3KNmzVwNWideVdutvb5tWts+V2/tO5aTFvHrXL7MyPd+8IVFSUy7pNK+yXjqoZ/3eXStmxa4t8t+xL+7W73pwt4wzbcLR6saEvCgQgUHcCmjwK47bu3JJxBMmjkkG99jGrfnt4pE/tlNgLAW8IVOQXSEW//SRjyybbwNXPpdZnLabVzSr6Qcq/3xQAZ+o8IrGvLGhu6WcJ3vWAdpO9oY+ms+yoFHk8XUb79u3tX+UhxzeS+bNKZdtmk4zEDOnXc6gd9rV+80rPzowy6w5ghfWHmTtvjmdjxjKQPtA++KH2D78zOq0ePB0LI9qEEth82uWSSuHI24eeImWtd2dObz7xodAJ86neBMadvyxwrD7HVr9f0rnkZjewMh8fZN3VnmnlfChMOAq9SC/Ze4A0+LjKG+XWgEVDjpLc+XMkc6u/wqY539zScHr0s+OmuyTr61mSsXlzekzY4FmWDRsuyUwgxXdL6MnTrHFL6dphb1m4dIaUWss4E13KOnWVimb5kju3Kvo23vE69ciWpgUZMndGkd2V4R7bSpm76KN4mXA8BCAAAQhAoE4ESsqKZO4P0+t0DI0hAAEIQAACfiKgz7RNpd+y0EWqfiKNLBCAQMIJpJK3NuGwkjyAJo9yEkglWRSGhwAEIAABCEAAAr4jgGHrO5UgEAS8I8D6Wu9YxzuSJo+iQAACEIAABCAAAQhEJoBhG5kLtRBICwKaPIpiBgGSR5mhJ6RMHwKZmVmSk51Xpwn37T6oTu1pDAEIQAACsRPAsI2dFS0hkHIEtg892Uq2hHFrgmL1+bV42E3QFDKmAwE1aC8eebecffyNMU9XjdqbxkyIuT0NIQABCECgbgQMTx5Vt8nSGgIQgAAEIAABCMRDoGPbnvL7M+6Xzu37yOyF78fc1chhY2XBkhkxt6chBCAAAQjUjQCGbd140RoCKUWA5FHmqNNJHKWeWwoEIJAcAnt13l/+eMEzUlZeJus2rYhZCPXW6uvOJ9L7MVkxA6NhRAJ5OdlSXFoWcV9dKs8/apjs06WzfLdqlTwxJfabM3UZg7YQSAYBQpGTQZ0xIeATAoS2+kQRMYhB8qgYINEEAgkmsHbjMvnv9EfkqnFDZeuODXUaTb21eGzrhIzGvxDo3q6tPPb7y2TybbdY67qz4uby+xOOk3OHHSGnH3pI3H3RAQT8RADD1k/aQBYIeEyA9bUeA49jOJJHxQGPQyHgEoFtOzfJ6x/8U0pKi+rUo4YhUyBQXwJ3n3+unDLoYMnIyKhvFxwHgbQgQChyWqiZSUIgMgFNHkU4cmQ2fqslBNlvGkEeCMRGgDDk2DiZ2CovJ0f+cNqp0q1tW8nOypS1W7bKP15/U37atCkwncP32VvOPHyINGnQQLYXFso7s7+WN7740t6vZuofR50mHVo0l7snvibnHHG47N25k+wqKZFHJ78rXy1eInp8n04d7fYdW7aQBy4eI/dMel3OG3aktGrWTL5YtEgO6rmXqCzPfvCRTJ83Xzq1aiVXn3KStb+plJaXy8fzF8hT708LyMQGBFKVAIZtqmqWeUEAAhCAAARSgECPduY/Iocw5BQ4EcOmkJudLS9df40c0qd3yJ5D+vSS4TffJjuLiuWkgwfKg5dcJA1zcwNtTrU8r/26dpE7X37Vrjtl0EG2YXz0gP7SsmnTQLsj991Hjr7pNunZoYO0yc+36/MbN5bTDhksEz/9XM476khplJcnpx06WDJ/8eROnv2V7Gv1/cZNN9iGtNPZCQMPtGQ5SM79x/22ce3Up9t7KnyXpJvO6jpfQpHrSoz2EEghAnhrzVGmJo9yEkiZIzWSQgACGoa8cCnZkFPtTLjtrNEBo/baJ5+W3z7wTym0PK17tm8v4y+6UPbv0V0euuwS26j9dtlyOewPf5KPLG9qZmam/P6E4+WMw0LXt6pRe/74B+XXd4+TSgtWgWXEdm3bRqbOnSs//PSzjW/1xk3yf48+IbMXLw7gVK/vlK/nyCcLFsrrM76Ux39/uW3UFpeWyjn3jpcH/vuW3d8hvXvJb4YdETiODQikIgE8tqmoVeYEgRgJkDwqRlA+aKbJo3SdLQUC6UhAPS2L15hnHDphyJOmjU9HtaXsnHWt64F79rDnt3bLFjsE2A4rbvisZFj/vvzhByuseKioV7eyslIufOBfsmzdOjnvvgdk7oP3SbNGjWTgXnvJy598FmD0nBVG/Pas2fY62lXrN0in1q2kW5s2dmixhjbv1aG9bNm5UyZ9/rmUlpUHjvvx5zVyyb8etj3Eagx3s4zh8ooKOcMykD//7nvb6N3L8voed8D+cumxx8hD/5scOJYNCKQaAQzbVNMo84FAHQho8iiM2zoAS2JTkkclET5DJ52Anwzb1i06ScO8xpKb00AaWO8d2vSQwqIdsnnb2mqcnGfXkg25GhqjKxpZocWNGuTZc1i1YaNtvKqXdcJHH9veUd3R2FpTq0U9p2rUatlVXGxtr7dDkdsWFNh1zn9zli51NqWwtMTezrEM42hl844dtlGr7dSAVaO7qLhE1m3dGjhUPb1anJDmwI402xgxgCRuqa7y6H8xqU6A+UEgjQmQPMoc5ZM8yhxdIan7BPSCdMocf3g9rz/vKdmj9Z6BSY4bO1U+/eYN+ddLVwbqgjfw1gbTSI1tTe5UaBmPWnq0b2f5aKvKHeecJe2tRFALVqyUIquNFk3qpHU/b9psJZjKsj2qWq+e3uBSVFK6+6NayTUU9QgHlzIrOZRT9Lm0Whrk5kjThg2damlbULVGd/223cZuYGeabOjNMX1RUpsAhm1q65fZQQACEIAABFKCgF+M2wfVdiMAAD7QSURBVOvuOzomnrvDkGNqTiODCGh48YzvF0n/bl3ttbBXnnyibahq9mPHoHx66gcyZsRwybLW1Gom44fffsdaV3toYL+GCcdaiiyvr5bmTRrLMfvvJ7N+/DFwqIYdO2VHUZGsWL9eOrduLf8Ze4Vc//QztpdWw5BV5nTOjIy31jlLUvud5FGprV9mB4FaCZA8qlY8vtpJ8ihfqQNhkkBAL0xN8rgQhpyEk8TDIW+f8JJ8v7oq78GfrEf23G8ljFKjVj2zv3vkMTuZ08X/fNhe76qP7Hnhuqtl5CFVHsMnprwvr30e+5rxN6ykUFo6tGgh/77idzLcyqAcqajx6oypXuJnrrpC7r3wfNtTvHDlKnnsnSmRDkv5OtO+O1JeIQmcIB7bBMKlawj4nQDra/2uod3ykTxqNwu20pfAZcdOkIffGW1EIin12N75xOj0VVaKz1wTOJ1y19/k3GFHWkmeWlvhv3nWeblGXrcMVies+H8zZ1mJo/4p+3TpYr06y9I1a+Xb5Stso7bCMkI1qPjxd9+zPLFNZJ5Vbxer/t/vTbWfQTv7x6rsxxM//Uw6tmppr81dbq3RnWtlWR7/xn9F1+Dq5+Ciz74dduMtMmK/AXaG5p2WF3fRTz/JM9M+kLLyKu/uo5aBq4mmgp+3G9xHKm2rUYu3NpU0WvtcMGxr58NeCKQ0AZJHmaNekkeZoyskTSwBE4xbNWq1kDQqsedCsnvfuG273Pf6mzWKocbr27O+sl+RGulSWvXeBhete+r9qcFVdkIqNWSDy5wlu5NNBdfrtnpn9VVTUWM6HQpGbTpoOXSOhCKH8uATBNKKgCaPUuOW4n8CmjwKD7v/9YSE7hOI9JgfNW715dfQZCcM2X0a9AgBCEQjoAatfj/gqY1GKvX247FNPZ0yIwhAAAIQgEBKEdDwY71QDS5q1GqdY/jqu7Md3C58e/3WJeFVIZ9b53cP+VyfD+qxffGt8b41vOszJz8f842fhUO2agT0bzeruG21+vpWBN/gqs2YjfQ9Ut8xOc6fBDBs/akXpIKAJwRIHuUJZlcG0eRRWnjsjys46cQwAmqw6kWpXrQGX8TqNJzPznttU5u//D3RV23liP6XWJlke9TWpNZ9uY2qdh/ec6wc3rPWpux0icCl8rxLPdGNFwT077hnH/cM22gy66PC/PK4sGiysj8+AoQix8ePoyFgNAFCW81RnyaPokAgnQk4xq3fL1CbthAp3pXOmmLuEPAPAYxa/+jCC0nw2HpBmTEg4FMCJI/yqWIiiEXyqAhQqEpLAs6Fqnpowz24avzG4rlNJLg8y2O7oea8PYkcmr4hkJYEwv/unZtfzntaQknTSWPYpqnimTYElIAmjyIc2YxzgRBkM/SElN4RcDy4OmKwMRu8HS6Nrq9dt6XqESrh+5zP7825X+q7zlbX1naQQfLWZ+Od7nj3gkDH1l6MwhguEVCDc5mLa2xVLMeI1e8FSvoSwLBNX90zcwhAAAIQgEBKEAi+mA3ers/kVm+eX5/D7GMOOnCC/Ygf5yK73h1xYN0InHBX3dqnQOtrTz1Zhu7dV06686/SpiBfHr7sEnnuw+n2M3L9Pj39G122vObHFfldfuTzLwHW2PpXN0gGgYQTwFubcMSuDaDJo5wEUq51SkcQgIBrBNRbq69J0/DWugaVjmokcMCePWRQ7172/kZ5eXJIn96yd+dONbZnBwTSgQAe23TQMnOEQA0ESB5VAxgfVmvyKF1nS4EABPxLYMGSGbbH1r8S1ixZXk5DqaiskNKyYrtRTnaeZGVmSVEJmbBqpuaPPas3bJSjbrpVft60yR8CIQUEkkQAj22SwDMsBPxAQJNHUcwgQPIoM/SElOlLoE+3QUZP/vbLXpf/G/1AYA43XviCPH7Lt6IGbjqW/bp3l6l33S5rnnlSZoy7W/5w+kiZdd89ot7RzIwMOenggfLdw/+Udc89LYsff1iuOvlEyc2u7i/q0KK5zB4/Tm4584wQjHf95myZ+Ut/ITsifMjMzJQzhw6RJY8/ImuefUom/ekPkpeTE2ipocgvXHuVnDq46hx858+3yKO/u0y+vv9e+5iTDqp6XFzggLCNrm3ayMKHH5Tbzvx1yJ7fDj/Krt+nS+eQej5AwK8EMGz9qhnkgoAHBDR5FMatB6BdGEKTR+FhdwEkXUAgQQQmTh0vdz4xOkG9e9/tnO8/kM/nvun9wD4Ycd+uXeT5a8dK97Zt5Y/PPCcr1q+Xq046Qdo3b24btcP3GyCP//5y+W71arnB2j9/xUq5YdRpcttZ1fW/dVeh7CgqsjJ4DwgYo/mNG8nRA/rJ+q3bLA95WdQZH7f/fvKPMRfIkrVr5fYXX5bu7drJYX37BI7LsQzqtgUF0qGF9awpq3Rs2VJOGXSQNG3YUIpKS2TRTz8F2kbaWL5unewsKpaLjhluH+O0udKac5ZlVH+/uvbjnfa8QyDZBDBsk60BxocABCAAAQhAIO0INMxrIh1a97Bf+U1aSYblBXSKhgDrvu579JP2rbpJpvU5vDRp1Fz0uPDSvFlbycu1njkUQ6mSYU/Zo/WekpUV6m189/On5fm37wqEJufmNJBmTVqKvu/RZk/RcWoqOpeCpq2lScOCkCYNGzS1+wip9OGHP5x2qjRu0EAOvOpaefr9aXLB/Q/KwlWrApLqWtaKykp55eNP5bkPPpKT7viLvD7jCzuUO9Dol42dllH7+cLvZc/27W3DWKs7t25tvz5b+J2UlpeHH1Lt882jz5Ayq92Z99wrD709WY62wo53FVeFjFdr/EvFNsugHn7zn6Xv5VfId6tqX8ZSaR3zxJT3LO98tm1waxfD+u1ry3v7hJdjMr5/GZY3CCSVQOi3WFJFYXAIQMBrAiSP8pp4/cdzEkfx2J/6M+RICPiFwLCBZ8oZI661QlcbiFj2bFlZqbz2wQMy+dMnbRFHHjVWjjv0t5a3LNsyaEpl7g8fy/0vXBYi/gUn3S579zhELv/LwIBB1c4ygu+wQoqfeO0G+WLe2yHtwz8c2GeEjBn5V9tQ1X251hrbn9b/GGh2+tFXycC+x8oV9xxq1x3a/xT51ZCLpNIy6FoWdJAVP38ntz06MtA+eEON3+vOe0p2FW2Xu544M7DryjP/ZY93+2OhYbmBBj7YaNwgT1o3ayZL16yV7YWFtkTqzZz94xLp2aGD/fmL7xfZnsy7LzjXClE+Vb5c9KP85ZVXZYl1TKTyt1cnyQVWWO89vz1PRv3tHlHDWcOLH/rf5EjNq9V1bt3KGn+x7eHVnRu2bZMZlgxqfNZUNm7fLsssT2ysReekRvYhvXtbmZW/kDEjhsvWnbvs7Vj7oB0Ekk0Aj22yNcD4EEgiAUJbkwi/jkNr8igKBCBgPoFuHfaR8078syxaPlv+/caN8vKUcdKkUYE0bVQVRqre2WMP+a18t3SmPDjh/+SFyX+RD2dNqDbxV6feZ3tELzjpjsC+M4/5o5SUFkU1atu36i6/H32/rFq7SJ5+81b7tX3nxkA/uqFe38YN8wN1Odm5thd507afZeL798nL798T2Be+UVxSKPMXfya9uw4MeHbV29uxTU9Zsea78Oa++qxraBtZxm2xdbNBjXinbN6xw9mUTy1P68i/3G0bfeqd1vW2n93zN7nVWqOqBmt42bJzp7z39RwZYj2eR9erHt2/n0z56mvZFNRn+DHOZ123m52VJVt3hSbxWrdlq9Mk4ruGIAfLH7FRUOXcZcvlp42b7Lm0zm9mydlJvli0SAqjeIaDumATAkknUP2vL+kiIQAEIOAVAdbXekU6/nFIHhU/Q3qAgB8IXHLaPVJsZRr+x3MXy6dzXpd3P/9PiFiVVmbiXDthU6WdYXnqly/KN4s+CmmjH35ev0S+/fFjOeLAX1tGcXMr9LeN7NV5P5n93fvV2oZXnDH8WimvKLfWBJ8p07961X5t2xE9o25pWYk8/d/b5H+fPC4LFn8e3m3I55en3CMVFRVy3gl/tutbF3SU/KatLO/z9JB2fvuwafsO2bhtu7TJL7ANSpXPcqpbocO7w7412VKvjnvIjc8+J/v+fqwcfM319jFnHT5E9vhlnWv4vF746GO7nwcuHmN1mGGFFL8T3iTi5xJrDa4a1X06dbTX9zqN9urQ3tmM/L7bJo+8P6y23NLV7RNekuZNmshvjjxC2lnriadYxriGXFMgYAoBDFtTNIWcEEgAAZJHJQBqgrokeVSCwNItBDwmoN7S75fPrHFU9bJN/uxJGdDrSLn7yndlzKl/FV0LG6l8YhnGWZY3b589D5PO7Xvba24/+fq1SE1D6lq36GSFHS8JqYvlQ0VFmWWsRl8Tqn1pCPVnlnz79znKXm/bb6+h9nrdb31u2KqB9/bsr6RDyxbydyvUOEf5dukih++zTwDR2UcMFc1qfPnxx9kJoYpKS+0EUcWlZbKzuEh67dHBTvZ0xL67j5n1449WIqdS+1mz67dulR+iJHQKDGZtvDVzlnRq1UrOPuJwey22Jnnav0f34CaubL/15SxZu2WLXHPqyfZ8XrLWEFMgYBIB1tiapC1khQAEIAABCEDAaALq/8rI2O1XUG9geNHwY10je+KQS+SIA0ZZnsMceeTVa8KbydffTbNCj4tlyP6nWQZYrhXm+70V4jyrWrvIFWGeuEiCRD4w5tqvvpsqQw8cJb26DJRhB50l0yzvs3p9/V4ee2eKtda0l4w67FA5/dBDbGOysGS33M9+8KEcf+D+9iN+9DE/Go68zQoVfmTyu6Ie34N67iVnHz5UFv+8Rj78dp49XQ0d/mT+Qhm+X3+Z+cOP1jrZ7TFjuGfSGzJwrz1l3IXny93n/8Yeb63VX7vmocm5gjsM027wrhq39ZjJllF//lHD5BHLo1xsGeIUCJhEAMPWJG0hKwRcJkDyKJeBJrA7kkclEC5dQ8BDArpGtVeXAwMjdmrXO7AdvLF45Rx54MXfydXnPCaD+58U0bDdVbRNJlprbX894nr70DtifNzQ1u3rpU+3gwPDaRizrvNdt2m3wR3YGcfGnEUf2OHIGi7d3BpDw55NKRf98yFp1bSZHNFvH9HESteNPEWc58GuWL9BRtxyu3Rr28Z+7I4mdtLEUZqwScsHc+dJ/yuuCiSfcuasfTZr1NAygquSUjn10d7XbN4sx992p/SzHkOkIclTvv7G7rtBbtWzbFda8gy44upApuQjb7wlkFAsWt/h+zfv2Cka/vy/WbPDd/EZAr4ngGHrexUhIAQSR4DkUYlj63bPmjxK19lSIAABswk8+cbNcsMFz8gfzn9aFi79Uvr3PDxkQq2ad5Rzjr9Rlq761vbM9e0+2Nqea7c5oM9wueDkO6x1rrfKrPnv2nWTP3vKylZ8sRQV75TV634I6aumDxOn3S+3X/aa/PnSSaJe1e577Gsnr8q2vL5uFvXOPv/2nXLuCbfK2k3LZdPWNW52n9C+SsvK5WfLoHzRWhurRY294KKP8Zm3fIX9Cq7XbfV0rtm8JbzaNjyDH9Ojnl4NdbYX31ZrXVVRUVFpP+pHn4X72Xff269A051VWxo+rSHETtFQZ6fEOsae7dtJV8tQP/GggdZzezfIwpWrnC54h4AxBDBsjVEVgkLAfQKaPArj1n2uieiR5FGJoEqfEPCewLwfP5G3Pn5Mhlrhw9079pelq78NESK/cUvp1La39O022K5fv3ml3P9i1aN+yq11q2p8ZgTFmZZZxuPshe9LhfWolh27dhs3IZ2GfViy6ht56vWb5PThV8nxh42RtRtXWB7ha2Xofrsf36N9bdq22xAtLN4hm7ettTywoQZeWNfVPr73xXPWo42uk5VWmPSOwtjkq9aJDyrUeCx3OZHSwVbI8sQbrrfXSdc0RQ1x7nnJ72raHbU+1jHes7zAow47RDTk+tS7/ma/R+2cBhDwGQEMW58pBHEg4CUBTR5FOLKXxOs/Fs+vrT87joSAvwhUyovv/NUOIdZnx2o48XN3Lg6IuNgyOq8bf7Sd6VgTSe3YtTkQVjpn0Ydy9b2H28+HDRxgbTz71u0xJ3Vyjps68wX56KtXpIGVmErH0DLj27ec3TLh3bvtl1Px8deTRF91LR1b72k/u3bi1PF1PdRX7fWZs6/P+NJVg2/BypVy9r3jQ7Idh09aE07FU2IdY53l8Z381VeyYt160Uf/UCBgIgEMWxO1hswQgAAEIAABCBhNQJ83q6/gRFLOhDTz8NYdG5yPIe+7iqonHSoq+SUm9ZeW2ufAvY+J2Lc+bqfwlz40c7Fj1OqhsWY81rYZ1r+9exwija21ueFl/eZVol7hXx12kfz6mOtFvdTLf14Q3syozz9aiaD05WbRtbZOcik3+w3uqy5juD2/YDnYhoAXBDBsvaDMGBDwKQG8tT5VTASxSB4VAQpVEEgRAjsKt4qG+rpVsjKz5LJR99nZlMP7/OMDx8rqCMZxeLton3Xt5ijrebjdO/ar1vTD2S/bhu0RB462ElKtlCffuKlaGyogAAEIuE0Aw9ZtovQHAYMIsL7WHGWRPMocXSEpBOpCoLKyQi6+o39dDonaVj2xF9waOdty1INjbFBhyX3rI6fW2vq68UfVup+dEIAABNwk4G5edzcloy8IQCDhBDR5FMUMAiSPMkNPSAkBCEAAAhCAQHIIYNgmhzujQsAXBDR5FMatL1QRVQhNHoWHPSomGkAAAhCAAAQgkKYEMGzTVPFMGwIQgAAEIAABCEAAAhCAQKoQYI1tqmiSeUCgHgRIHlUPaEk6hORRSQLPsBCAgBEEKrr2kKzMpZI7faotb+E5Y+z3rBXm1UUCbuI8IskcaW7UQcAtAhi2bpGkHwgYSIDQVnOURvIoc3SFpBCAgLcEcqdPswfMWr5EMrdusbdzvv3a2LqSocNCAOr8UnVuIRPlAwTiJIBhGydADoeAyQR0fS3GrRkaJHmUGXpCSghAwHsCavRlLV8aMrDjuQ2uNKWuvEs30ZdTwuUO/6ztTKkLnpczP94h4BYB1ti6RZJ+IGAgAZJHmaM0kkeZoyskhQAEvCVQ+JsxIYagt6MzWl0INHz2iWo3IepyPG0hUBsBDNva6LAPAhCAAAQgAAEIQAACEIAABHxPAMPW9ypCQAgkjgDJoxLH1u2eNXmUk0DK7b7pDwIQgIDJBPACmqM9vOvm6MpESTFsTdQaMkPAJQKsr3UJpAfdaPIoCgQgAAEIVCcQvr62egtq/EKANbZ+0URqyoFhm5p6ZVYQiImAJo+imEGA5FFm6AkpIQAB7wlgLHnPvL4jchOivuQ4LhYCGLaxUKINBFKUAMmjzFEsyaPM0RWSQgAC3hIgvNVb3vGMRth4PPQ4NhoBDNtohNgPAQhAAAIQgAAEIAABCEAAAr4mgGHra/UgHAQSS4DkUYnl62bvJI9ykyZ9QQACqUQAL6A52sS7bo6uTJQUw9ZErSEzBFwiQPIol0B60A3JozyAzBAQgICRBFi3aY7aWA9tjq5MlBTD1kStITMEXCJA8iiXQHrQDcmjPIDMEBCAgJEEMJbMURs3IczRlYmSYtiaqDVkhoBLBEge5RJID7oheZQHkBkCAhAwkgDhreaojbBxc3RloqQYtiZqDZkhAAEIQAACEIAABCAAAQhAIEAAwzaAgg0IpB8BkkeZo3OSR5mjKySFAAS8JYAX0Fve8YyGdz0eehwbjQCGbTRC7IdAChMgeZQ5yiV5lDm6QlIIQMBbAqzb9JZ3PKOxHjoeehwbjQCGbTRC7IdAChMgeZQ5yiV5lDm6QlIIQMBbAhhL3vKOZzRuQsRDj2OjEcCwjUaI/RBIYQIkjzJHuSSPMkdXSAoBCHhLgPBWb3nHMxph4/HQ49hoBDBsoxFiPwQgAAEIQAACEIAABCAAAQj4mgCGra/Vg3AQSCwBkkcllq+bvZM8yk2a9AUBCKQSAbyA5mgT77o5ujJRUgxbE7WGzBBwiQDJo1wC6UE3JI/yADJDQAACRhJg3aY5amM9tDm6MlFSDFsTtYbMEHCJAMmjXALpQTckj/IAMkNAAAJGEsBYMkdt3IQwR1cmSopha6LWkBkCLhEgeZRLID3ohuRRHkBmCAhAwEgChLeaozbCxs3RlYmSYtiaqDVkhgAEIAABCEAAAhCAAAQgAIEAAQzbAAo2IJB+BEgeZY7OSR5ljq6QFAIQ8JYAXkBvecczGt71eOhxbDQCGLbRCLEfAilMgORR5iiX5FHm6ApJIQABbwmwbtNb3vGMxnroeOhxbDQCGLbRCLEfAilMgORR5iiX5FHm6ApJIQABbwlgLHnLO57RuAkRDz2OjUYAwzYaIfZDIIUJkDzKHOWSPMocXSEpBCDgLQHCW73lHc9ohI3HQ49joxHAsI1GiP0QgAAEIAABCEAAAhCAAAQg4GsCGLa+Vg/CQSCxBEgelVi+bvZO8ig3adIXBCCQSgTwApqjTbzr5ujKREkxbE3UGjJDwCUCJI9yCaQH3ZA8ygPIDAEBCBhJgHWb5qiN9dDm6MpESTFsTdQaMkPAJQIkj3IJpAfdkDzKA8gMAQEIGEkAY8kctXETwhxdmSgphq2JWkNmCLhEgORRLoH0oBuSR3kAmSEgAAEjCRDeao7aCBs3R1cmSopha6LWkBkCEIAABCAAAQhAAAIQgAAEAgQwbAMo2IBA+hEgeZQ5Oid5lDm6QlIIQMBbAngBveUdz2h41+Ohx7HRCGDYRiPEfgikMAGSR5mjXJJHmaMrJIUABLwlwLpNb3nHMxrroeOhx7HRCGDYRiPEfgikMAGSR5mjXJJHmaMrJIUABLwlgLHkLe94RuMmRDz0ODYaAQzbaITYD4EUJkDyKHOUS/Ioc3SFpBCAgLcECG/1lnc8oxE2Hg89jo1GAMM2GiH2QwACEIAABCAAAQhAAAIQgICvCWDY+lo9CAeBxBIgeVRi+brZO8mj3KRJXxCAQCoRwAtojjbxrpujKxMlxbA1UWvIDAGXCJA8yiWQHnRD8igPIDMEBCBgJAHWbZqjNtZDm6MrEyXFsDVRa4bKnJGRITnZefZLt2MtfbsPirUp7epIgORRdQSWxOYkj0oifIaGAAR8TQBjydfqCRGOmxAhOPjgMgEMW5eB0l1kAp3b9ZGxZz0it17yiv0678TbbQM3cuvQ2pvGTBCM21Ambn0ieZRbJBPfD8mjEs+YESAAATMJEN5qjt4IGzdHVyZKimFrotYMkzk7K1cuO32ctGjWTpb/tFCKinfJiEG/kWMPuSDqTByDdsGSGVHb0gACEIAABCAAAQhAAAIQSE8C2ek5bWbtJYGy8hK544nRUlpWYr2KJSsrRx68/jM59tDfyn+nP1KrKCOHjRWM2loRxbWT5FFx4fP0YE0epUU9txQIQAACENhNAC/gbhZ+31Lveu70qUJIst81ZaZ8eGzN1JtxUu8q2m4btSp4eXmpbN+5UXbs3Bx1HuqxnTRtfNR2NKgfAZJH1Y9bMo4ieVQyqDMmBCBgAgGMJBO0VCUj66HN0ZWJkmLYmqg1w2Vu1KCZdGzbS76Y93atMyEMuVY8ruwkeZQrGD3phORRnmBmEAhAwEACGEvmKI2bEOboykRJMWxN1JrhMo8afo3sLNwq02a+UOtMCEOuFY8rO0ke5QpGTzoheZQnmBkEAhAwkADJo8xRGmHj5ujKREkxbE3UmsEytyzoIIP7nSCzFkyRrTs21jgT9dYShlwjHnZAAAIQgAAEIAABCEAAAkEEMGyDYKTaZo92/nr+a2Zmltx4oeWlrRR5+r+3SGVlRa3INWkUiaNqRRT3TpJHxY3Qsw40eZSTQMqzQX8ZyG/fJV7Pn/EgAAF/E8AL6G/9BEuHdz2YBttuE8CwdZtoEvtbvMbfj8Q585g/Ssv89nL/i5dLSWlRraQ0DJmSeAIkj0o8Y7dG8FPyKL9/17jFnH4gAAEzCLBu0ww9qZSshzZHVyZKimFrotZqkDn8YnPEAH8YhxkZmTJkv5HyqyEXyftfPC9bd26QDm16SIfWPSTT2hdeCEMOJ5K4zySPShxbt3tOZvKo8O+S8O8at+dKfxCAAATqQgBjqS60ktuWmxDJ5Z/qo1e3KlJ9xik+vylzQh+NE35Bmozpd7IyIP/25LvsoY+znl07buzUqtdVU6WgWdtqIvXpNsgOQSYMuRoa1ytIHuU60oR1mMzkUeGhyBi2CVMzHUMAAvUgQHhrPaAl6RDCxpMEPk2GzU6TeabtNNWwDTd2vYaxYs1CueC2PjEPq4Ytz66NGRcNfyGg60/LWncI4bF96CnScOFMIeQ6BEudPoTfHMOorRM+GkMAAhCAAAQg4BEBPLYegfZqmEhGbPiFqVey1GccJwy5PsdyTN0JpELyKDVoN592uRT2GVgNgBq66pVOVtKlagLFUaFz8Hoe6qkN//6I9B0Tx7Q4FAIQgEDcBPACxo3Qsw7wrnuGOi0HwrBNQbWHX3jqhWn4xalfp+08u5YwZG80ZLonUw29SAZtOD1t47VRGC5DvJ+9Th6lRu1lx04IEVu9tXhsQ5DwAQIQ8AEB1m36QAkxisB66BhB0axeBDBs64XN3wepYWuycUsYsnfnl8nJo1T2WIxah6bpxq2XyaP0Rlgko/bhd0Y7OHmHAAQg4BsCGEu+UUVUQbgJERURDeIggGEbBzw/H6qGbbhnxblYDU8E45d5OGHIeGu904jJyaPqYtQ6ROtzjHNsst+9SB7lRHdEivAIv1mWbB6MDwEIQMAhQHirQ8L/74SN+19HJktI8iiTtRdFdvWuqNcl2JANDi8MDisMN4LDu16/dUl4VbXPrfO7V6urS4UThhwsb12Op23dCcyyDlHe2Vmr635wko+YFZYoKlZxNCR5701ZsTZP6XbBf2uRjFln8vpdEu07wmnLOwQgAAEIQAACEEgGAQzbZFD3cEy9IHW8MOHD6kVt8IVt+P7gzy9Pvz74Y7XtNgXd5Yh+l1arr0tFB8su3rBKqoVA1qUP2taNwPflK6TXAZ3rdpAPWqvcs3aFrv+MVSz9ezgp99BYm/um3Zsln9qyeCm7GrOEH/vmFEAQCECgBgJ4AWsA48Nq9a7nTp8qhCT7UDkpIBKhyCmgxGhT0BDC2jwufvDE5DaqmkXJrmizYb+bBHplmWfUxjv/78pWxttFUo73Wm7neyMpk2VQCEAAAnUggJFUB1hJbsp66CQrIMWHx2Ob4gp2pud4XtRDqx6rWD21zvGJfm/aQqQYozbRmKv1b3ts09C4rQbCgIre2Z2kV1anhErqrKN13hM6GJ1DAAIQcImAGksYty7BTHA36CnBgNO8ewzbNDsBHANXpx1s3AZvR0KyevP8SNWBOt1fUlEU+FzXjfN7jpUX3xqPcVtXcHG2f6lHiQxYtDbhBlOcYkY+vEfk6mi1DRfOlClZa6I1893+BpZEy2Wm9XK3OBEbzru7vdMbBCAAgcQT0PBWwpETz9mNEVRPFAgkigCGbaLIGtBv8IVs8HZ9RY9m/NbUr2ZD1vLfz8bX1IT6RBHocbmdFGj5+omJGiFh/TYsie0ZtuEC6Llu4nzD58FnCEAAAhCAAAQgAIHdBFhju5sFW0ki4GRDTtLwaT1s0+lvSPZ68zIiq9L08Td1LeqtNXW+ms1ZXxQIQAACEAglgLc2lIefP/FoJj9rx3zZMGzN16HxM1CP7aRpeGuToUhTjTyHlRqqsZbs9T/VyxiOtf9EtytttUeih6B/CEAAAkYSYN2mOWojeZQ5ujJRUgxbE7WWQjKrUbtgyQz7lULTMmYqZa3NNpbUa6te52hFDeCm01+P1szX+3M2rLa8zT/5WkaEgwAEIJAMAhhLyaBevzG5CVE/bhwVGwHW2MbGiVYJIlBl1I5OUO90G43A9qEn24ahyZ5blb35xIdEjfTCPgOt9w6BaTse3fqELQc68clGKszBJygRAwIQSDECJI8yR6EkjzJHVyZKimFrotbSWObsrBwpaNpGGuQ1kaLiHbJp2xqpqCgPEGnWpKW0yu8gZeVlsmHLatlVtC2wL3ijebO2sn3nJqtdqV2dl9NQGjZoIlu2rw9uVm07JztPmjZubh27WUrLiu39WZnZkt+0VUhdtQOpSDgBNXCbGrpeOOFwGAACEIAABCAAAQikOAEM2xRXcCpNr0FeY7npwhelXauuosZkeUWZFJXskuvHj7AN2E7tesvNYyZIbm5DqayskC3b1smd/z5TNm6pHr759yunyH3PXxIIgT7q4HPk2EPOlyv+fmityNQgvvPyN2XNxmVyy8On2G3PPfFWGbzviXL9/SMsw3hdrcf7bafJyaP8xjLR8jiJo/DcJpo0/UMAAqYRIHmUORpT73ru9Kk8d9gclRklKYatUepKX2GbNGou9149TXbu2iIvTRknJaVFMrDvCNmv9zDJzs6VjIwMOfeEW6W4dJc89ebNNij17O6w2kcqjRvmS3ZmTmBXruWJbdwgP/C5po11m1bItJkvykmHXyqHDjhF1mxYKocNOFU+/mqicUatztHkEOSadJSq9Zo8StfZUiAAAQhAIJQA6zZDefj5E+uh/awd82XDsDVfh2kxg316HCJNLeP26Tduls+/fcuecwPLM6uGrZbKykppkNPI2sqwvbA7CjdLuRWOnIjy+gcPylEHnSW/+dUtdjh0UfEuee7tuxIxVML71HWpGLcJx+zKACSPcgUjnUAAAilIQI0ljFszFIuezNCTqVKSFdlUzaWZ3OphVeNVQ4BrKs++fbs0tNbePnD9p3LDBc9K764H1dQ0rnoNf77pXydKnmVY5zdpLf947iJrrW5JXH0m62BNHmV6ZuRksfN6XA1B5iaE19QZDwIQMIEAz0Y1QUtVMhI2bo6uTJQUw9ZEraWhzJXOnK2Q490leFtk0fLZcvW9R8iUGc9Y63C7yRVn/kt0TWxNRUOYnaKhzHUpvboOtNb55khuTgPp2fmAuhxKWwhAAAIQgAAEIAABCEDAZQIYti4DpbvEECgu3mmvo23XsmtggD7dDg5sOxvbdm6U59++U155717Lm9rKCl9u4ewKeddsyN079rfr1Kjd2wp1tqKYYyo9rOMuHvl3mfblCzLDCos+6/gbE+YdjkmgOBqRPCoOeB4fqsmjnARSHg/NcBCAAAR8TQAvoK/VEyIc3vUQHHxwmQBrbF0GSneJIbBg6QwrC3K5/HrEddK2RRfrkTst5MC9jwkMpo/hufi0v8uGzatkm/UYn4P3OV4KrccBFZXslFYFe8itF78icxZ9KP9+/U/2MSvXfCcnHHaRlJQVSeuCjtKxTU/RRwlFK5qN+WzLkC20DO23Pn7UftRQb8vAPuf4m+Smh06Kdrjv9hPa6juV1CgQyaNqRMMOCEAgzQmwbtOcE4DkUeboykRJ8diaqLU0lHnztrVy1bihoiHJxx92oQzud6LM+W5agIQapY0aNJMjB46WkcOukLYtu8ir7/9DNIuxPvonJydPMjN2n+4TpvxdCi2jV43bvt0GyZ8fG2Wt310e6K+mjV8NuVjaWIb1n/75K/s5ufoc3Sdfv9EOeR4x+LyaDvNtPetrfauaaoKRPKoaEiogAAEI2AQwlsw5EbgJYY6uTJQUj62JWktTmTdsWS3X/ONI67E8zWRX8XY5+qCzA1mR1Tt7z38usJNHaQKpHYVb7EcCKaqNW3+WsZZRXFa2O8HTtz98LFf+/TBpkNdItu/abCem+oP1HNpo5c2PHhJ9BZfZC98TfZlYNHkU4chmaI7n15qhJ6SEAAS8J6DhrYQje8+9PiOqnigQSBQBDNtEkaXfhBCosMKR1RCtqaiBq6/wUmSFDocXDUPWV3jp2n5vaduqa3i1FBZtl3mLP7XDj6vtpAICEIAABCAAAQhAAAIQSBoBDNukoWfgeAmUWh7YHbu2Woamu8+rHXrAKBk+6DfVxFu97ge59eFTpbiisNo+Uyvw1pqjOSdxFJ5bc3SGpBCAgDcE8NZ6w9mNUdS7njt9Ks8ddgMmfVQjgGFbDQkVphCYNvNF0Zfb5Zm3bhN9pUMheZQ5WiZ5lDm6QlIIQMBbAqzb9JZ3PKOxHjoeehwbjcDubDrRWrIfAhBIOQIkjzJHpSSPMkdXSAoBCHhLAGPJW97xjMZNiHjocWw0Ahi20QixHwIpTECTR2HcmqFgDUHGw26GrpASAhDwlgDPRvWWdzyjETYeDz2OjUaAUORohNgPgRQnoMatloYLZ4qzfnPzaZdT53MGtoL4DwIQgAAEIAABCEDAJoBhy4kAgTQmoMmjnBLsDXTqqZMQL6mfuDh64x0CEIBAuhPAC2jOGUDyKHN0ZaKkGLYmag2ZIeASgWDDNbjLSPXUhRq5Dq9kcXHG5x0CEIBAuhNg3aY5ZwDroc3RlYmSssbWRK0hMwQgAAEIQAACEICATQBjyZwTgZsQ5ujKREkxbE3UGjJDAAIQgAAEIAABCNgESB5lzolA2Lg5ujJRUgxbE7WGzBCAAAQgAAEIQAACEIAABCAQIIBhG0DBBgQgAAEIQAACEICAaQTwApqjMbzr5ujKREkxbE3UGjJDAAIQgAAEIAABCNgEWLdpzonAemhzdGWipBi2JmoNmSEAAQhAAAIQgAAEbAIYS+acCNyEMEdXJkqKYWui1pAZAhCAAAQgAAEIQMAmQHirOScCYePm6MpESTFsTdQaMkMAAhCAAAQgAAEIQAACEIBAgACGbQAFGxCAAAQgAAEIQAACphHAC2iOxvCum6MrEyXFsDVRa8gMAQhAAAIQgAAEIGATYN2mOScC66HN0ZWJkmLYmqg1ZIYABCAAAQhAAAIQsAlgLJlzInATwhxdmSgphq2JWkNmCEAAAhCAAAQgAAGbAOGt5pwIhI2boysTJcWwNVFryAwBCEAAAhCAAAQgAAEIQAACAQIYtgEUbEAAAhCAAAQgAAEImEYAL6A5GsO7bo6uTJQUw9ZErSEzBCAAAQhAAAIQgIBNgHWb5pwIrIc2R1cmSopha6LWkBkCEIAABCAAAQhAwCaAsWTOicBNCHN0ZaKkGLYmag2ZIQABCEAAAhCAAARsAoS3mnMiEDZujq5MlBTD1kStITMEIAABCEAAAhCAAAQgAAEIBAhg2AZQsAEBCEAAAhCAAAQgYBoBvIDmaAzvujm6MlFSDFsTtYbMEIAABCAAAQhAAAI2AdZtmnMisB7aHF2ZKCmGrYlaQ2YIQAACEIAABCAAAZsAxpI5JwI3IczRlYmSYtiaqDVkhgAEIAABCEAAAhCwCRDeas6JQNi4OboyUVIMWxO1hswQgAAEIAABCEAAAhCAAAQgECCAYRtAwQYEIAABCEAAAhCAgGkE8AKaozG86+boykRJMWxN1BoyQwACEIAABCAAAQjYBFi3ac6JwHpoc3RloqQYtiZqDZkhAAEIQAACEIAABGwCGEvmnAjchDBHVyZKimFrotaQGQIQgAAEIAABCEDAJkB4qzknAmHj5ujKREkxbE3UGjJDAAIQgAAEIAABCEAAAhCAQIAAhm0ABRsQgAAEIAABCEAAAqYRwAtojsbwrpujKxMlxbA1UWvIDAEIQAACEIAABCBgE2DdpjknAuuhzdGViZJi2JqoNWSGAAQgAAEIQAACELAJYCyZcyJwE8IcXZkoKYatiVpDZghAAAIQgAAEIAABmwDhreacCISNm6MrEyXFsDVRa8gMAQhAAAIQgAAEIAABCEAAAgECGLYBFGxAAAIQgAAEIAABCJhGAC+gORrDu26OrkyUFMPWRK0hMwQgAAEIQAACEICATYB1m+acCKyHNkdXJkqKYWui1pAZAhCAAAQgAAEIQMAmgLFkzonATQhzdGWipBi2JmoNmSEAAQhAAAIQgAAEbAKEt5pzIhA2bo6uTJQUw9ZErSEzBCAAAQhAAAIQgAAEIAABCAQIYNgGULABAQhAAAIQgAAEIGAaAbyA5mgM77o5ujJRUgxbE7WGzBCAAAQgAAEIQAACNgHWbZpzIrAe2hxdmSgphq2JWkNmCEAAAhCAAASSRiAzM0vychpKVlZOnWTo231QndrTODYCGEuxcfJDK25C+EELqStDdupOjZlBAAIQgAAEIAABdwkcM+g8OaDvCGnWpIXsLNwmUz7/j3wx7+2og6hRe9OYCXLWn7pGbUuDuhHQ8FbCkevGLFmtVU8UCCSKAB7bRJGlXwhAAAIQgAAEUopAs8Yt5IShl0hxyS5ZuWaRFDRtI1ee9ZB022OfqPMcOWysLFgyI2o7GkAAAhCAQP0I4LGtHzeOggAEIAABCEAgzQhs27lJ/vDAsbKraLs180rp3/MIue7cf0vvrgfJ0tXzaqSh3lp93fnE6BrbsKP+BPDW1p+d10eqdz13+lQhJNlr8ukxHoZteuiZWUIAAhCAAAQg4AKBXUXbAr0UWgZuRWWF5cEtDNTVtKHeWjy2NdGJrx4jKT5+Xh7NemgvaaffWIQip5/OmTEEIAABCEAAAi4QaNOys2RbCaSWr1lYa28ahkxJHAGMpcSxdbtnbkK4TZT+gglg2AbTYBsCEIAABCAAAQjEQEAzI486+hpZtGK2LFk1t8YjnDDkSdPG19iGHfER4Nmo8fHz8mjCxr2knX5jYdimn86ZMQQgAAEIQMDXBBav2Z1kqUc7/z0iJyMjQ84Yfo00bdRcHnn1Wqm0wpFrK4Qh10aHfRDwhoAfv0u8mXn6jIJhmz66ZqYQgAAEIAABCLhAoEWz9jJi8Pny5fzJsnbjslp71DDkhUt3G+q1NmZnvQjgBawXtqQc5CfvevANtKTAYFDXCWDYuo6UDiEAAQhAAAIQiIdA+AWnnzwtrZt3lJsvekmW/TRPnnrzFstbW1njVJ0wZAzbGhG5soN1m65g9KQTP62HDv+e8QQAgySUAIZtQvHSOQQgAAEIQAAC8RLwi2GbnZUrF5x0h+Q3aSVvfvSwtCxoLx3a9LA+t4w4RefZtWRDjojHtUo/GUuuTSpFO0rmTYgRA0jilqKnVWBaGLYBFGxAAAIQgAAEIOAHAlPmhCZa8ssF6ZnH/VEG9DpS8nIbyvXnPSXjxk61X6OGX1sjNpJG1YjGtR1+Cm91bVIp2lGywsb15ljwDTL11uKxTb2TjOfYpp5OmREEIAABCEDAeAJq3AYbtLodbvB6Pcln37pd9BVLccKQJ02LpTVtIFBFoGToURLugVbDPXf6VEmmt9N0/QR/l+hcMGpN12hk+fHYRuZCLQQgAAEIQAACPiKgF6bBHhcfiRZRFMKQI2JJSGWyvIBuTkYN2h033SUlQ4dV61YNXTVutY3pJRne9UjfHcm+SWa6Hv0qP4atXzWDXBCAAAQgAIE0JqAXnuEXn5cdO8EY41Y9toQhe3MCm+7JVIM1kkEbTk/bmG7chnujw+fo9mc1asO9teHfK26PSX/JI4Bhmzz2jAwBCEAAAhCAQC0EIl2AmmDcqlGrhaRRtSjXxV1eG0suim6HHcdi1Dpjmm7cenkTIpJRqyHIkb5XHL68m00Aw9Zs/SE9BCAAAQhAIKUJPPzO6GrzU+PWzwauE4ZcTXAqEkIgGeGtbk2kPh7YuhjCbsnpVj9ehI2rQavfD+GeWp1DpO8Tt+ZGP8knQPKo5OsACSAAAQhAAAIQqIGAelj0YlQvVIOLrrfVOicJjL4728HtwrfXb10SXhXyuXV+95DP9fmgHtsX3xpvTNh0febop2O+sYTR8yGruK2fxIoqi3qa51mv+hQ1iPss2lmfQ1PumOC195GMWWfCGLUOidR9x7BNXd0yMwhAAAIQgEBKEHCMW71oDb6I1ck5n5332iY8f/l7oq/ayhH9L5E2+T1qa1LrvtxGVbsP7zlWDu9Za1N2ukRg0fq10rPP2SJ9XOrQo24W5a2VefJ+vUYbMeBKOaF7v3odm8yD/tH6fTlh277S08ObEBp6TPhxMrXu3diEInvHmpEgAAEIQAACEKgnAce49fsFatMWIsW76jlJDqsXAS+NpHoJyEEBAmrMe1kwar2knfyx8NgmXwdIAAEIQAACEIBAjAScC1X10IZ7cNX4jcVzG+NQ9WqWZ3lsN6yq16EcVE8Caixh3NYTnseHJUJP4X/3zs0v593jKTJcEglg2CYRPkNDAAIQgAAEIFA/Ao4HV48ONmaDt8N71vW167YsDq8O+fzenPulvutsdW1tBxkkb302PqRPPiSWwKQTWss+780z07i1ZK9PWfbFizKleFp9Dk3qMftYoy+zArCXuSyFY8Tq9wIlfQlg2Kav7pk5BCAAAQhAICUIBF/MBm/XZ3KrN8+vz2H2MQcdOMF+xI9zkV3vjjiwbgROuMtOHLZs+dK6HeeD1rnNYnuGbbioatguC6/kMwTSnABrbOt5AlQ0K5CK/IJ6Hs1hEIAABCAAgdgJlHXqKplbN8d+AC09J6DeWn1Nmoa31mv4XjxCxus51TaeztfUYvKjmUxlnk5y47Gth7azl1c9KqBk7wH1OJpDIAABCEAAAnUnkDv3q7ofxBGeEliwZIbtsfV0UAaTLAM9tY7acqdPtTdjfTZt7vRpRs9XH3FEgUCiCGDY1pOsGrf6qshvXs8eOAwCEIAABCAQnQCe2uiM/NCiT7dBfhAjLWVQYykdjFs1ah1D2FRFm6wnU5mnk9wYtnFqmwuOOAFyOAQgAAEIQCAFCEycSghystSo4a2mhyOrwaovnYsWx7OphqC+TDdonXPD5DBqZw68+5cAhq1/dYNkEIAABCAAAQikKIGGeU2kebO29ux2Fm6VbTs3SmVlpf05KzNL2rbsKg1yG0th8XZZu2mFVFSUVyORl9tQGjfIl83b11nHVtj7mzaqiiTbvqvmNdkZkmGPvatomxSV7H7obpOGBZJpja2yUJJDAMMvOdwZNTUIYNimhh6ZBQQgAAEIQAAChhAYNvBMOWPEtZKb3UAsG1PKykrltQ8ekMmfPmnPYORRY+W4Q38rWZnZUlZeKnN/+Fjuf+GyarM7tP8p8usR18kfHjhGtmxfb++//Iz7RA3Umx8+pVp7pyIjM1P+esVkWfbTAvnrk2c71fKH8/8jpeXFcvtjZwTqTNgw3VtrAmO3ZFSPtHqfCUl2iyj9BBPAsA2mwTYEIAABCEAAAhBIIIFuHfaR8078s3yz6EP5Yt7boh7Wc0+41XpvYY+qHtNjD/mtfLd0pkyb+YLkN2klG7asjihRTnauNGrYTDIydj/kooHlCW7UoFnE9k6len/n/jBdBu37K2lZ0EE2bvlJWuS3k+4d95W/PHmO08yYd4wkY1QVCLE2R2IkNYkAhq1J2kJWCEAAAhCAAASMJnDJafdIsRX++4/nLrbnoUapGrZO0ZDi3Ow862OlnWF5V9F2e9vZ79b77AVT5ND+J0vvrgfJp3Net43p7bu2yPzFn7k1hGf9mJ48yjNQPhiImxA+UEIKi7D7Fl8KT5KpQQACEIAABCAAAT8QaN+qu3y/fGaNoug628mfPSkDeh0pd1/5row59a+i63HdLuox1jDnwf1OlKysHOm311AjjVrlwrNR3T47EtcfYeOJY0vPIhi2nAUQgAAEIAABCEDAIwKaHio4dNhaYlutvDD5L/Ya2cUr58gRB4yyQ5erNQqqyAwKRdbEULGUwuKdMmna/bYB3d0Kj25phSIvWj4rlkNpAwEIQMCXBDBsfakWhIIABCAAAQhAIBUJbNr2s/TqcmBgap3a9Q5sB2+oUfvAi7+TOd9/IIP7nxS8K7Bdbq2VVUO2aeOq9bmabKqz9pcRm3H7v48fl2LLwD396Gusdbn58tk3bwT6NmkDL6A52sK7bo6uTJSUNbYmag2ZIQABCEAAAhAwksCTb9wsN1zwjJWB+GlZuPRL6d/z8JB5tGreUc45/kZZuupbyz7NkL7dB1vbc+02B/QZLhecfIc8/d9bZdb8d2Xd5pX243lGDrtSFq2YLUP2G2m3a5jXOKTPmj6UlZfI/CWfyYF9j7HDkGt7RFBNffihnnWbftBCbDI4z+eNrTWtIFA3Anhs68aL1hCAAAQgAAEIQKDeBOb9+Im89fFj0tUK//3VkIuktKw4pK/8xi2lU9ve1r6L5fjDLpL1lvF6/4tVj/opt9bEZmflSkbV427lWyuz8aeWl1U9wCcMuUQ2bV0jT7z+JykpDe0zZICgD7qe96vvptnPz504dXzQHrM2MZbM0Rc3IczRlYmS4rE1UWvIDAEIQAACEICAoQQq5cV3/ioTp94nuTkNZVfRNnnuzsWBuSxe9Y1cN/5o+zFAanju2LVZKqxMyVrmWAmfrr73cOsYzZRs5U229v/rpSulccN8e1v70lKXkOJObXvJ5u1r5ecNS+1jTfxPw1sJRzZDc6onCgQSRQDDNlFk6RcCEIAABCAAAQjUQKCktMjyrBaFJJJymupzZrfu2OB8DHl3jNrgyp2FW4M/BrY1xDgrq/qlnq7fLSktlJOP+J0cffDZ8tFXr1rjrQ8cxwYEIAABEwlU/7YzcRbIDAEIQAACEIAABAwlsMMyTAuLd7gu/aWnj5O83EbV+n34latkzYZlMnzQufLlvMnyzFt/rtbGpAq8teZoS73rudOnCiHJ5ujMJEkxbE3SFrJCAAIQgAAEIJBSBCqtMOOL7+ifkDmNuX3fWvs99+a9at1vyk6MJFM0JcJ6aHN0ZaKkJI8yUWvIDAEIQAACEIAABCBgE8BYMudE4CaEOboyUVIMWxO1hswQgAAEIAABCEAAAjYBno1qzolA2Lg5ujJRUkKRTdQaMkMAAhCAAAQgAAEIBAiocavFMZzUi0udvxkElMcGBFwikNG+fXv7aWhDjm8k82eVyrbNVSnlXeqfbiAAAQhAAAIQ8CmBoiFHSe78OZK5dYtPJUQsCEQnEByKHBzq6tRTJyHJmvzEJbp2aZFKBMo6dZWKZvmSO/crV6bVqUe2NC3IkLkziuz+MGxdwUonEIAABCAAAfMIYNiapzMkhgAEIGAqgUQbtoQim3pmIDcEIAABCEAgTgLZK5aKXmhky7I4e+JwCEAAAhCAQM0EKpoVSEV+gUilHSxcc8M49mDYxgGPQyEAAQhAAAImE8hevkRK8veXkr0HmDwNZIcABCAAAQMI6M1U/d1JVMGwTRRZ+oUABCAAAQgYQMCttU4GTBURIQABCEAghQnwuJ8UVi5TgwAEIAABCEAAAhCAAAQgkA4EAh7bFT+USqceWVZWZGzddFA8c4QABCAAAQhAAAIQgAAEIGAqgY7ds0RtWKcEDNvlv1Tmt8xy9vEOAQhAAAIQgAAEIAABCEAAAhDwHQE1ah0bVoULPO7Hd5IiEAQgAAEIQAACEIAABCAAAQhAIAYCxB3HAIkmEIAABCAAAQhAAAIQgAAEIOBfAtn9BjXwr3RIBgEIQAACEIAABCAAAQhAAAIQiEIge+vG8ihN2A0BCEAAAhCAAAQgAAEIQAACEPAvgezgBbf+FRPJIAABCEAAAhCAAAQgAAEIQAACkQmwxjYyF2ohAAEIQAACEIAABCAAAQhAwBACGLaGKAoxIQABCEAAAhCAAAQgAAEIQCAygf8Hl+ZjeJ8QLAQAAAAASUVORK5CYII=" + } + }, + "cell_type": "markdown", + "id": "31", + "metadata": {}, + "source": [ + "![stream.png](attachment:1efaa199-9bca-47b7-982c-366975a479aa.png)" + ] + }, + { + "cell_type": "markdown", + "id": "32", + "metadata": {}, + "source": [ + "## Specular Reflection\n", + "The boundary reflection operation effectively reflects particles that enter the boundaries.\n", + "The boundary surfaces are assumed to be orthogonal to the lattice sites, and located right between two lattice sites. Each boundary surface is characterized by the lattice site inside the boundary closest to its surface, `position`, and the direction normal to the surface, `direction`.\n", + "\n", + "Two types of reflections can occur:\n", + "(i) reflections from the corners of the reflecting object, and\n", + "(ii) reflections from the bulk of its surface.\n", + "\n", + "(i) For particles colliding with a corner, the velocity components along both the $x$ and $y$ axes are reversed.\n", + "\n", + "(ii) For particles colliding with the flat surface, only the velocity component normal to the surface is reversed, while the tangential component remains unchanged. \n", + "\n", + "Such a reflection scheme enables modeling the reflection process with a constant number of ancilla qubits.\n", + "This is achieved by ensuring that particles incident from different directions never scatter into the same outgoing direction.\n", + "Allowing multiple distinct incoming states to map onto a single outgoing state would correspond to a non-invertible transformation, thereby violating the unitarity condition required by the quantum circuit computation model.\n", + "\n", + "A reflection operation is performed unitarily by a series of controlled operations, effectively reversing the appropriate velocity and placing the particles outside the boundaries in the appropriate lattice site:\n", + "\n", + "1. For particles (distributions) reaching sites within the boundaries, flag an ancilla register.\n", + "2. For flagged particles, flip the velocity direction qubit and shift the particles according to the normal direction\n", + "3. For the translated particles, conditioned on the velocity normal to the surface and position, reset the ancilla register\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "33", + "metadata": {}, + "source": [ + "Schematic representation of the two kinds of reflections — \n", + " corner reflections (top-left) and surface reflections (bottom and side surfaces):" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "34", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import math\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# === Create the figure and axis ===\n", + "fig, ax = plt.subplots()\n", + "\n", + "# === Draw the reflecting object (red square) ===\n", + "# The square is centered in the figure with semi-transparent red fill\n", + "square = plt.Rectangle(\n", + " (0.25, 0.25), 0.5, 0.5, linewidth=1, edgecolor=\"r\", facecolor=\"tab:red\", alpha=0.35\n", + ")\n", + "ax.add_patch(square)\n", + "\n", + "# === Add first arrow pair (top-left corner reflection) ===\n", + "# Solid arrow: incoming direction (up-right)\n", + "arrow_start = (0.3, 0.8)\n", + "arrow_dx, arrow_dy = (0.1, 0.1)\n", + "ax.arrow(\n", + " arrow_start[0],\n", + " arrow_start[1],\n", + " arrow_dx,\n", + " arrow_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"black\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflected direction (down-left)\n", + "arrow2_start = (arrow_start[0] + arrow_dx, arrow_start[1] + arrow_dy + 0.05)\n", + "arrow2_dx, arrow2_dy = (-0.1, -0.1)\n", + "ax.arrow(\n", + " arrow2_start[0],\n", + " arrow2_start[1],\n", + " arrow2_dx,\n", + " arrow2_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Add second arrow pair (upper-left side) ===\n", + "# Solid arrow: incident from top-left toward the object\n", + "arrow3_end = (0.16, 0.84)\n", + "arrow3_start = (arrow3_end[0] - 0.1, arrow3_end[1] + 0.1)\n", + "arrow3_dx = arrow3_end[0] - arrow3_start[0]\n", + "arrow3_dy = arrow3_end[1] - arrow3_start[1]\n", + "ax.arrow(\n", + " arrow3_start[0],\n", + " arrow3_start[1],\n", + " arrow3_dx,\n", + " arrow3_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"black\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflection opposite to incident direction\n", + "arrow4_start = (arrow3_start[0] + arrow3_dx + 0.01, arrow3_start[1] + arrow3_dy - 0.07)\n", + "arrow4_dx, arrow4_dy = (-0.1, 0.1)\n", + "ax.arrow(\n", + " arrow4_start[0],\n", + " arrow4_start[1],\n", + " arrow4_dx,\n", + " arrow4_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Define helper for rotation (used below) ===\n", + "angle_rad = math.radians(90)\n", + "\n", + "\n", + "def rotate(dx, dy):\n", + " \"\"\"Rotate a vector (dx, dy) 90 degrees counterclockwise.\"\"\"\n", + " new_dx = dx * math.cos(angle_rad) - dy * math.sin(angle_rad)\n", + " new_dy = dx * math.sin(angle_rad) + dy * math.cos(angle_rad)\n", + " return new_dx, new_dy\n", + "\n", + "\n", + "# === Add third arrow pair (lower-left side, rotated 90° CCW) ===\n", + "arrow5_end = (0.16, 0.64)\n", + "arrow5_start = (arrow5_end[0] - 0.1, arrow5_end[1] + 0.1)\n", + "arrow5_dx, arrow5_dy = rotate(\n", + " arrow5_end[0] - arrow5_start[0], arrow5_end[1] - arrow5_start[1]\n", + ")\n", + "\n", + "# Solid arrow: incident direction\n", + "ax.arrow(\n", + " arrow5_start[0] - 0.03,\n", + " arrow5_start[1] - 0.155,\n", + " arrow5_dx,\n", + " arrow5_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"black\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflection (opposite)\n", + "arrow6_start = (arrow5_start[0] + arrow5_dx + 0.02, arrow5_start[1] + arrow5_dy - 0.06)\n", + "arrow6_dx, arrow6_dy = rotate(-0.1, 0.1)\n", + "ax.arrow(\n", + " arrow6_start[0],\n", + " arrow6_start[1] - 0.1,\n", + " arrow6_dx,\n", + " arrow6_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Add pair of arrows to bottom surface (center reflection) ===\n", + "# Solid arrow: incoming (upward)\n", + "arrow7_start = (0.35, 0.06)\n", + "arrow7_dx, arrow7_dy = (0.1, 0.1)\n", + "ax.arrow(\n", + " arrow7_start[0],\n", + " arrow7_start[1],\n", + " arrow7_dx,\n", + " arrow7_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflected (downward)\n", + "arrow8_start = (0.52, 0.2)\n", + "arrow8_dx, arrow8_dy = (0.1, -0.1)\n", + "ax.arrow(\n", + " arrow8_start[0],\n", + " arrow8_start[1],\n", + " arrow8_dx,\n", + " arrow8_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Add final vertical pair (top reflection) ===\n", + "# Solid: downward arrow from top\n", + "arrow9_start = (0.6, 0.93)\n", + "arrow9_dx, arrow9_dy = (0, -0.1)\n", + "ax.arrow(\n", + " arrow9_start[0],\n", + " arrow9_start[1],\n", + " arrow9_dx,\n", + " arrow9_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed: reflected upward\n", + "arrow10_start = (0.64, 0.78)\n", + "arrow10_dx, arrow10_dy = (0, 0.1)\n", + "ax.arrow(\n", + " arrow10_start[0],\n", + " arrow10_start[1],\n", + " arrow10_dx,\n", + " arrow10_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Final plot settings ===\n", + "ax.set_xlim(0, 1)\n", + "ax.set_ylim(0, 1)\n", + "ax.set_aspect(\"equal\")\n", + "\n", + "# Remove all tick marks and labels\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_xticklabels([])\n", + "ax.set_yticklabels([])\n", + "\n", + "fig.suptitle(\"Schematic of particle reflections at object surfaces\")\n", + "\n", + "# Optionally remove axis spines for a cleaner figure\n", + "for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "35", + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def flip_velocity(\n", + " change_pos: QNum,\n", + " fixed_pos: QNum,\n", + " change_u: QNum,\n", + " change_v_dir: QBit,\n", + " mag: int,\n", + " arr: CArray[CReal],\n", + ") -> None:\n", + " \"\"\"flips the velocity of a certain direction \"change\" for particles in a regime defined by array arr.\"\"\"\n", + " change_low, change_high, fixed_low, fixed_high = arr[0], arr[1], arr[2], arr[3]\n", + " # if the particle entered the object and is on the lattice points closest the surface, flip the associated velocity\n", + " control(\n", + " ((change_pos == change_low) | (change_pos == change_high))\n", + " & (fixed_pos >= fixed_low)\n", + " & (fixed_pos <= fixed_high)\n", + " & (change_u == mag),\n", + " lambda: X(change_v_dir),\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def reflection(qs: PhaseSpaceStruct, mag: int, limits: CArray[CReal]) -> None:\n", + " \"\"\"\n", + " Performs a reflection of the particles reaching lattice sites on the boundary\n", + " Note that such a reflection limits the initial conditions.\n", + "\n", + " Parameters:\n", + " reg: PhaseSpaceStruct, the complete register of the system\n", + " mag: int, velocity magnitude\n", + " limits: list (of QArray[CInt]), defines the limits of the reflecting object\n", + " \"\"\"\n", + "\n", + " x_low, x_high, y_low, y_high = limits[0], limits[1], limits[2], limits[3]\n", + " # reverse the velocity\n", + "\n", + " # from the top and bottom of the object\n", + " top_bottom_arr = [y_low, y_high, x_low, x_high]\n", + " flip_velocity(\n", + " change_pos=qs.g_y,\n", + " fixed_pos=qs.g_x,\n", + " change_u=qs.u_y,\n", + " change_v_dir=qs.v_dir_y,\n", + " mag=mag,\n", + " arr=top_bottom_arr,\n", + " )\n", + " # from the left and right of the object\n", + " flip_velocity(\n", + " change_pos=qs.g_x,\n", + " fixed_pos=qs.g_y,\n", + " change_u=qs.u_x,\n", + " change_v_dir=qs.v_dir_x,\n", + " mag=mag,\n", + " arr=limits,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "36", + "metadata": {}, + "source": [ + "Implementation of the reflection operator within the main quantum circuit:" + ] + }, + { + "attachments": { + "517a2527-5749-4913-b4a0-3d1ab6dbc41a.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "37", + "metadata": {}, + "source": [ + "![stream.png](attachment:517a2527-5749-4913-b4a0-3d1ab6dbc41a.png)" + ] + }, + { + "cell_type": "markdown", + "id": "38", + "metadata": {}, + "source": [ + "## Build the quantum program" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "39", + "metadata": {}, + "outputs": [], + "source": [ + "@qfunc\n", + "def main(qs: Output[PhaseSpaceStruct]) -> None:\n", + " allocate(qs)\n", + "\n", + " # Prepare the initial register\n", + " init_state2D(qs, g_dist_x, g_dist_y, u_dist)\n", + "\n", + " # Number of time steps\n", + " Nt = len(schedule)\n", + "\n", + " # Iterate over time steps\n", + " for t in range(Nt):\n", + " # Iterate over magnitudes to stream\n", + " for mag in schedule[t]:\n", + " # Stream\n", + " stream(qs, mag)\n", + "\n", + " # Reflect from boundaries\n", + " reflection(qs, mag, limits)\n", + "\n", + "\n", + "write_qmod(main, \"qlbm\", symbolic_only=False)\n", + "qprog = synthesize(main)\n", + "job = execute(qprog)" + ] + }, + { + "cell_type": "markdown", + "id": "40", + "metadata": {}, + "source": [ + "## Execution and results" + ] + }, + { + "cell_type": "markdown", + "id": "41", + "metadata": {}, + "source": [ + "We run the quantum program on a statevector simulator to retrieve the full solution." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "42", + "metadata": {}, + "outputs": [], + "source": [ + "with ExecutionSession(qprog) as es:\n", + " results = es.sample()\n", + "table = results.dataframe.to_numpy()" + ] + }, + { + "cell_type": "markdown", + "id": "43", + "metadata": {}, + "source": [ + "Taking a look at a small part of the results" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "44", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
qs.g_xqs.g_yqs.v_dir_xqs.v_dir_yqs.u_xqs.u_ycountprobabilitybitstring
0641131880.042969011111100110
1120110790.038574000110010001
2140012780.038086100100100001
3740121770.037598011010100111
4641132760.037109101111100110
\n", + "
" + ], + "text/plain": [ + " qs.g_x qs.g_y qs.v_dir_x qs.v_dir_y qs.u_x qs.u_y count probability \\\n", + "0 6 4 1 1 3 1 88 0.042969 \n", + "1 1 2 0 1 1 0 79 0.038574 \n", + "2 1 4 0 0 1 2 78 0.038086 \n", + "3 7 4 0 1 2 1 77 0.037598 \n", + "4 6 4 1 1 3 2 76 0.037109 \n", + "\n", + " bitstring \n", + "0 011111100110 \n", + "1 000110010001 \n", + "2 100100100001 \n", + "3 011010100111 \n", + "4 101111100110 " + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.dataframe.head()" + ] + }, + { + "cell_type": "markdown", + "id": "45", + "metadata": {}, + "source": [ + "Evaluating the spatial and velocity magnitude distribution, $p(x)$ and $p(u)$." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "46", + "metadata": {}, + "outputs": [], + "source": [ + "def get_p(dataframe, jx, jy, n):\n", + " \"\"\"\n", + " Extracts a 2D probability map from the dataframe\n", + " where columns jx and jy correspond to the x and y indices.\n", + "\n", + " Parameters:\n", + " dataframe: pandas.DataFrame, the table containing measurement results.\n", + " jx, jy: int, column indices for the x and y registers.\n", + " n: int, number of discrete x and y states (assumes square grid n x n).\n", + "\n", + " Returns:\n", + " p: np.ndarray, 2D array of summed probabilities p[x, y].\n", + " \"\"\"\n", + " p = np.zeros((n, n))\n", + " for x in range(n):\n", + " for y in range(n):\n", + " # mask the case of interest\n", + " mask = (dataframe.iloc[:, jx] == x) & (dataframe.iloc[:, jy] == y)\n", + " p[y, x] = np.sum(dataframe.loc[mask].to_numpy()[:, 7])\n", + " return p\n", + "\n", + "\n", + "# 2D distribution\n", + "p_xy = get_p(results.dataframe, jx=0, jy=1, n=n_g_i)\n", + "p_u_xy = get_p(results.dataframe, jx=4, jy=5, n=n_u_i)" + ] + }, + { + "cell_type": "markdown", + "id": "47", + "metadata": {}, + "source": [ + "### Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "48", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(\n", + " p_xy,\n", + " cmap=\"viridis\",\n", + " origin=\"lower\", # make (0,0) appear bottom-left\n", + " aspect=\"equal\",\n", + ")\n", + "\n", + "# Add colorbar\n", + "plt.colorbar(label=\"Probability\", shrink=0.7)\n", + "\n", + "# Label axes\n", + "plt.xlabel(\"x position (grid site)\")\n", + "plt.ylabel(\"y position (grid site)\")\n", + "\n", + "# Set tick positions and labels\n", + "plt.xticks(range(p_xy.shape[1]), range(p_xy.shape[1]))\n", + "plt.yticks(range(p_xy.shape[0]), range(p_xy.shape[0]))\n", + "\n", + "plt.title(\"Spatial Distribution\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "49", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Map pixels to real x/y coordinates\n", + "plt.imshow(\n", + " p_u_xy,\n", + " cmap=\"viridis\",\n", + " aspect=\"auto\",\n", + " origin=\"lower\",\n", + " extent=[u[0], u[-1], u[0], u[-1]], # x_min, x_max, y_min, y_max\n", + ")\n", + "\n", + "plt.colorbar(label=\"Probability\")\n", + "\n", + "# Tick marks exactly at your u values\n", + "plt.xticks(u, [f\"{val:.1f}\" for val in u])\n", + "plt.yticks(u, [f\"{val:.1f}\" for val in u])\n", + "\n", + "plt.title(\"Velocity Magnitude Distribution\")\n", + "plt.xlabel(\"Velocity Magnitude (x)\")\n", + "plt.ylabel(\"Velocity Magnitude (y)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "50", + "metadata": {}, + "source": [ + "## Analysis \n", + "\n", + "The simulation starts with particles placed at lattice site $(x_0, y_0) = (1,2)$, and their velocities are distributed uniformly — meaning each possible speed is equally likely at the beginning. We apply periodic boundary conditions, so particles that leave the domain on one side re-enter from the other. In addition, a reflecting obstacle is a rectangle with the corners situated at $(2,1)$, $(2,5)$, $(5,1)$, and $(5,5)$.\n", + "\n", + "As the system evolves, particles outside the obstacle move freely, while those reaching the obstacle bounce back. After several time steps, the particles cover the free space surrounding the reflecting object. \n", + "\n", + "\n", + "The velocity-magnitude plot shows that all speeds still have roughly the same probability. This makes sense because no collisions occur in this setup, so the distribution of speeds doesn’t change over time, only the direction of the velocities. The small differences between probabilities come only from statistical fluctuations, since we are working with a finite number of samples from the quantum simulation." + ] + }, + { + "cell_type": "markdown", + "id": "51", + "metadata": {}, + "source": [ + "## Technical Background\n", + "\n", + "\n", + "### Classical methods\n", + "\n", + "The dynamics of fluids with low compressibility and isothermal conditions are described by the small Mach number limit of the Navier--Stokes equations:\n", + "$$\\frac{\\partial\\rho}{\\partial t} + \\nabla \\cdot \\rho\\mathbf{u} = 0~~,~~\\text{(Continuity eq.)}$$\n", + "$$\\rho\n", + "\\left(\n", + "\\frac{\\partial \\mathbf{u}}{\\partial t} \n", + "+ \\mathbf{u} \\cdot \\nabla \\mathbf{u}\n", + "\\right)\n", + "= \n", + "-\\nabla p \n", + "+ \\mu \\nabla^2 \\mathbf{u} \n", + "+ \\rho \\mathbf{F}~~,~~ \\text{(Momentum eq.)}$$\n", + "where $\\mathbf{u}$ is the velocity field, $\\rho$ is the fluid density, \n", + "$p$ is the hydrodynamic pressure, $\\mu$ is the dynamic viscosity, \n", + "and $\\mathbf{F}$ represents external body forces.\n", + "\n", + "\n", + "The nonlinear and multiscale nature of these equations imposes significant computational demands on classical solvers. For standard discretization-based approaches, the per-time-step computational complexity scales as $O(N_x^d)$ where $N_x$ is the number of grid points per spatial dimension and $d$ is the dimensionality of the system. However, resolving all relevant turbulent scales requires a grid resolution that scales unfavorably with the Reynolds number, approximately as, $Re^{9/4}$. Consequently, the total computational cost of direct numerical simulation (DNS) grows effectively exponentially with $Re$. Moreover, classical Navier–Stokes solvers are difficult to parallelize efficiently because enforcing incompressibility introduces global dependencies that prevent fully local computation. \n", + "\n", + "### Kinetic Formulation\n", + "An alternative, microscopic viewpoint is provided by the Boltzmann transport equation:\n", + "$$ \\frac{\\partial f}{\\partial t} + \\mathbf{v}\n", + " \\cdot \\nabla f + \\mathbf{F}\\cdot\\frac{\\partial f}{\\partial \\mathbf p} = Q(f,f)~~,$$\n", + "where $f(\\mathbf{x}, \\mathbf{v}, t)$ is the single-particle distribution function over phase space, \n", + "$\\mathbf{F}$ represents external forces, and $Q(f,f)$ is the collision operator describing molecular interactions. \n", + "The collision term involves a high-dimensional integral over all pre- and post-collision velocities and scattering angles, \n", + "making its evaluation the dominant computational cost. \n", + "For deterministic discretizations, the complexity per time step scales as\n", + "$$O(N_x^d N_v^{2d})~~,$$\n", + "where $N_v$ is the number of discrete velocity points per dimension. \n", + "\n", + "### BGK Approximation\n", + "\n", + "A major simplification is obtained by replacing the collision operator with a local relaxation term toward equilibrium:\n", + "$$\\frac{\\partial f}{\\partial t}\n", + "+ \\mathbf{v} \\cdot \\nabla f\n", + "+ \\mathbf{F} \\cdot \\frac{\\partial f}{\\mathbf{\\partial p}}\n", + "= -\\Gamma (f - f^{\\text{eq}})~~,\n", + "\\tag{1}\n", + "$$\n", + "where $\\Gamma$ is the relaxation rate and $f^{\\text{eq}}$ is the local Maxwellian equilibrium distribution. \n", + "This Bhatnagar--Gross--Krook (BGK) approximation replaces the complex integral operator with a local operation that depends only on a few velocity moments. \n", + "Despite this simplification, direct numerical integration of Eq.~(1) still requires evolving $f(\\mathbf{x}, \\mathbf{v}, t)$ across both position and velocity grids, leading to a per-time-step complexity of\n", + "$$O(N_x^d N_v^d)~~. $$\n", + "\n", + "### Lattice Boltzmann Method (LBM)\n", + "The (LBM) offers an efficient and scalable alternative. \n", + "LBM discretizes velocity space into a small set of representative directions, allowing collisions and streaming to be computed locally in time and space. \n", + "This locality enables excellent parallelization and simplifies the handling of complex geometries and boundary conditions. \n", + "The resulting per-time-step complexity scales as\n", + "$$O(N_x^d V^d)~~,$$\n", + "where $V$ is the number of discrete velocity directions per dimension (typically small and fixed). \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "52", + "metadata": {}, + "source": [ + "## References" + ] + }, + { + "cell_type": "markdown", + "id": "53", + "metadata": {}, + "source": [ + "[1] [Schalkers, M.A. & Möller. Efficient and fail-safe quantum algorithm for the transport equation. M., Journal of Computational Physics, 502, p.112816](https://www.sciencedirect.com/science/article/pii/S0021999124000652?ref=pdf_download&fr=RR-2&rr=984897380e483d7c) \n", + "\n", + "[2] [Budinski, L.. Quantum algorithm for the advection–diffusion equation simulated with the lattice Boltzmann method. Quantum Information Processing, 20(2), 57.](https://link.springer.com/article/10.1007/s11128-021-02996-3)\n", + "\n", + "[3] [Todorova, B. N., & Steijl, R. (2020). Quantum algorithm for the collisionless Boltzmann equation. Journal of Computational Physics, 409, 109347](https://www.sciencedirect.com/science/article/abs/pii/S0021999120301212)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 9 +} diff --git a/applications/cfd/qlbm/qlbm.qmod b/applications/cfd/qlbm/qlbm.qmod new file mode 100644 index 000000000..7de45b876 --- /dev/null +++ b/applications/cfd/qlbm/qlbm.qmod @@ -0,0 +1,147 @@ +qstruct PhaseSpaceStruct { + g_x: qnum<3, UNSIGNED, 0>; + g_y: qnum<3, UNSIGNED, 0>; + v_dir_x: qbit; + v_dir_y: qbit; + u_x: qnum<2, UNSIGNED, 0>; + u_y: qnum<2, UNSIGNED, 0>; +} + +qfunc init_state2D_expanded___0(qs: PhaseSpaceStruct, g_dist_x: real[], g_dist_y: real[], u_dist: real[]) { + inplace_prepare_amplitudes(g_dist_x, 0, qs.g_x); + inplace_prepare_amplitudes(g_dist_y, 0, qs.g_y); + inplace_prepare_amplitudes(u_dist, 0, qs.u_x); + inplace_prepare_amplitudes(u_dist, 0, qs.u_y); + X(qs.v_dir_x); + H(qs.v_dir_y); +} + +qfunc stream_expanded___0(qs: PhaseSpaceStruct) { + control (qs.u_x == 3) { + control (qs.v_dir_x) { + qs.g_x += 1; + } else { + qs.g_x += -1; + } + } + control (qs.u_y == 3) { + control (qs.v_dir_y) { + qs.g_y += 1; + } else { + qs.g_y += -1; + } + } +} + +qfunc flip_velocity_expanded___0(change_pos: qnum<3, False, 0>, fixed_pos: qnum<3, False, 0>, change_u: qnum<2, False, 0>, change_v_dir: qbit, arr: real[]) { + control (((((change_pos == arr[0]) | (change_pos == arr[1])) & (fixed_pos >= arr[2])) & (fixed_pos <= arr[3])) & (change_u == 3)) { + X(change_v_dir); + } +} + +qfunc reflection_expanded___0(qs: PhaseSpaceStruct, limits: real[]) { + flip_velocity_expanded___0(qs.g_y, qs.g_x, qs.u_y, qs.v_dir_y, [ + limits[2], + limits[3], + limits[0], + limits[1] + ]); + flip_velocity_expanded___0(qs.g_x, qs.g_y, qs.u_x, qs.v_dir_x, limits); +} + +qfunc stream_expanded___1(qs: PhaseSpaceStruct) { + control (qs.u_x == 2) { + control (qs.v_dir_x) { + qs.g_x += 1; + } else { + qs.g_x += -1; + } + } + control (qs.u_y == 2) { + control (qs.v_dir_y) { + qs.g_y += 1; + } else { + qs.g_y += -1; + } + } +} + +qfunc flip_velocity_expanded___1(change_pos: qnum<3, False, 0>, fixed_pos: qnum<3, False, 0>, change_u: qnum<2, False, 0>, change_v_dir: qbit, arr: real[]) { + control (((((change_pos == arr[0]) | (change_pos == arr[1])) & (fixed_pos >= arr[2])) & (fixed_pos <= arr[3])) & (change_u == 2)) { + X(change_v_dir); + } +} + +qfunc reflection_expanded___1(qs: PhaseSpaceStruct, limits: real[]) { + flip_velocity_expanded___1(qs.g_y, qs.g_x, qs.u_y, qs.v_dir_y, [ + limits[2], + limits[3], + limits[0], + limits[1] + ]); + flip_velocity_expanded___1(qs.g_x, qs.g_y, qs.u_x, qs.v_dir_x, limits); +} + +qfunc stream_expanded___2(qs: PhaseSpaceStruct) { + control (qs.u_x == 1) { + control (qs.v_dir_x) { + qs.g_x += 1; + } else { + qs.g_x += -1; + } + } + control (qs.u_y == 1) { + control (qs.v_dir_y) { + qs.g_y += 1; + } else { + qs.g_y += -1; + } + } +} + +qfunc flip_velocity_expanded___2(change_pos: qnum<3, False, 0>, fixed_pos: qnum<3, False, 0>, change_u: qnum<2, False, 0>, change_v_dir: qbit, arr: real[]) { + control (((((change_pos == arr[0]) | (change_pos == arr[1])) & (fixed_pos >= arr[2])) & (fixed_pos <= arr[3])) & (change_u == 1)) { + X(change_v_dir); + } +} + +qfunc reflection_expanded___2(qs: PhaseSpaceStruct, limits: real[]) { + flip_velocity_expanded___2(qs.g_y, qs.g_x, qs.u_y, qs.v_dir_y, [ + limits[2], + limits[3], + limits[0], + limits[1] + ]); + flip_velocity_expanded___2(qs.g_x, qs.g_y, qs.u_x, qs.v_dir_x, limits); +} + +qfunc main(output qs: PhaseSpaceStruct) { + allocate(12, qs); + init_state2D_expanded___0(qs, [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0.25, 0.25, 0.25, 0.25]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); + stream_expanded___1(qs); + reflection_expanded___1(qs, [2, 5, 1, 5]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); + stream_expanded___2(qs); + reflection_expanded___2(qs, [2, 5, 1, 5]); + stream_expanded___1(qs); + reflection_expanded___1(qs, [2, 5, 1, 5]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); + stream_expanded___1(qs); + reflection_expanded___1(qs, [2, 5, 1, 5]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); + stream_expanded___2(qs); + reflection_expanded___2(qs, [2, 5, 1, 5]); + stream_expanded___1(qs); + reflection_expanded___1(qs, [2, 5, 1, 5]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); + stream_expanded___0(qs); + reflection_expanded___0(qs, [2, 5, 1, 5]); +} diff --git a/applications/cfd/qlbm/qlbm.synthesis_options.json b/applications/cfd/qlbm/qlbm.synthesis_options.json new file mode 100644 index 000000000..f5323ff51 --- /dev/null +++ b/applications/cfd/qlbm/qlbm.synthesis_options.json @@ -0,0 +1,44 @@ +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "custom_hardware_settings": { + "basis_gates": [ + "u2", + "cy", + "u", + "ry", + "r", + "cx", + "u1", + "h", + "tdg", + "id", + "x", + "sx", + "sxdg", + "y", + "t", + "p", + "rz", + "z", + "s", + "rx", + "sdg", + "cz" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "machine_precision": 8, + "optimization_level": 1, + "output_format": ["qasm"], + "pretty_qasm": true, + "random_seed": 2683937649, + "synthesize_all_separately": false, + "timeout_seconds": 300, + "transpilation_option": "auto optimize" + } +} diff --git a/tests/resources/timeouts.yaml b/tests/resources/timeouts.yaml index dd739f4df..50b86b41e 100644 --- a/tests/resources/timeouts.yaml +++ b/tests/resources/timeouts.yaml @@ -243,6 +243,8 @@ qft.qmod: 10 qgan_bars_and_strips.ipynb: 360 qiskit_discrete_quantum_walk.ipynb: 300 qiskit_qsvt.ipynb: 300 +qlbm.ipynb: 400 +qlbm.qmod: 400 qls_chebyshev_lcu.ipynb: 800 qls_qsvt.ipynb: 600 qmc_user_defined.ipynb: 176 From 653b7408233a1c7776b913675caa149d4adf9a57 Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Sun, 19 Oct 2025 13:41:55 +0300 Subject: [PATCH 2/7] added test_qlbm --- tests/notebooks/test_qlbm.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 tests/notebooks/test_qlbm.py diff --git a/tests/notebooks/test_qlbm.py b/tests/notebooks/test_qlbm.py new file mode 100644 index 000000000..2db4300ff --- /dev/null +++ b/tests/notebooks/test_qlbm.py @@ -0,0 +1,18 @@ +from tests.utils_for_testbook import ( + validate_quantum_program_size, + wrap_testbook, +) +from testbook.client import TestbookNotebookClient + + +@wrap_testbook("qlbm", timeout_seconds=400) +def test_notebook(tb: TestbookNotebookClient) -> None: + # test quantum programs + validate_quantum_program_size( + tb.ref_pydantic("qprog"), + expected_width=30, + expected_depth=45000, + ) + + # test notebook content + pass # Todo From 9843a6c5b5c6d276dcc73641644d642e970897c8 Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Wed, 22 Oct 2025 09:00:09 +0300 Subject: [PATCH 3/7] Update qlbm files --- applications/cfd/qlbm/qlbm.ipynb | 1153 +++++++++-------- applications/cfd/qlbm/qlbm.qmod | 8 +- .../cfd/qlbm/qlbm.synthesis_options.json | 36 +- 3 files changed, 657 insertions(+), 540 deletions(-) diff --git a/applications/cfd/qlbm/qlbm.ipynb b/applications/cfd/qlbm/qlbm.ipynb index 3a89c605e..668e7fabf 100644 --- a/applications/cfd/qlbm/qlbm.ipynb +++ b/applications/cfd/qlbm/qlbm.ipynb @@ -9,21 +9,24 @@ "\n", "\n", "The Quantum Lattice Boltzmann Method (QLBM) brings the ideas of the classical lattice Boltzmann method into the quantum computing framework.\n", - "In this notebook, we introduce the background concepts, explain how the classical method works, and motivate why a quantum version can help overcome some of its limitations. We exemplify the algorithm by analyzing a collisionless model example is inspired by the work of Schalkers and Moller [1].\n", + "In this notebook, we introduce the background concepts, explain how the classical method works, and motivate why a quantum version can help overcome some of its limitations. A variety of QBLM algorithms have been proposed (see Refs. below). Here, we focus on the collisionless case, including specular reflections. We exemplify the algorithm by analyzing an example inspired by the work of Schalkers and Moller [1].\n", "\n", - "## Background\n", - " Fluid dynamics are commonly well characterized by the famous Navier-Stokes equations - a set of non-linear coupled partial differential equations. Due to the non-linearity and multiscale nature of the dynamics, a precise solution for practical systems requires infeasible numerical resources (for further details see the technical supplementary at the bottom). \n", + "\n", + "## Part I — Theory and Framework\n", + "\n", + "### Background\n", + "Fluid dynamics are commonly well characterized by the famous Navier-Stokes equations - a set of non-linear coupled partial differential equations. Due to the non-linearity and multiscale nature of the dynamics, a precise solution for practical systems requires substantial numerical resources (for further details see the technical supplementary at the bottom). \n", " \n", - "Instead of working directly with the macroscopic fluid equations, one can take a microscopic viewpoint: Fluids are modeled as collections of particles and their behavior is described statistically, using the Boltzmann transport equation. A solution to the dynamics of the distribution function can be obtained by employing the (classical) Lattice Boltzmann Method (LBM).\n", + "Instead of working directly with the macroscopic fluid equations, one can take a microscopic viewpoint: Fluids are modeled as collections of particles and their behavior is described statistically, using the Boltzmann transport equation. The solution to this equation gives the dynamics for the distribution of particles positions and velocities. A numerical approach for solving the kinetic PDE equation can be obtained by employing the (classical) Lattice Boltzmann Method (LBM).\n", "\n", " \n", "\n", - "## Lattice Boltzmann Method (LBM)\n", - "The Lattice Boltzmann Method simplifies the complex dynamics over the whole of phase space by replacing the velocity distribution with a discrete set of velocities, $\\{\\mathbf{v}_i\\}$. Each lattice site $\\mathbf{x}$ is characterized by a vector of distributions $f_i(\\mathbf{x})$, representing the number of particles at that point with a velocity $\\mathbf{v}_i$. The distributions evolve according to a discretized version of the Boltzmann transport equation.\n", + "### Lattice Boltzmann Method (LBM)\n", + "The Lattice Boltzmann Method simplifies the complex dynamics over the whole of phase space by replacing the velocity distribution with a discrete set of velocities, $\\{\\mathbf{v}_i\\}$. Each lattice site $\\mathbf{x}$ is characterized by a $d$-dimensional vector of distributions $f_i(\\mathbf{x})$, representing the number of particles at that point with a velocity $\\mathbf{v}_i$. The distributions evolve according to a discretized version of the Boltzmann transport equation under the Bhatnagar–Gross–Krook (BKG) approximation.\n", "\n", "Within the simplified description, the evolution is dictated by three distinct processes:\n", - "1. Streaming: distributions move along the velocity directions to neighboring lattice sites $$ f_i(\\mathbf{x} +\\mathbf{v}_{i},t +\\Delta t) = f_i (\\mathbf{x},t) $$.\n", - "2. Collision: distribution of each site relaxes to equilibrium $$ f_i(\\mathbf{x}, t) = f_i(\\mathbf{x},t) - \\Gamma (f^{eq}_i(\\mathbf{x},t) - f_i(\\mathbf{x},t))~~,$$ where $\\Gamma$ is the relaxation rate.\n", + "1. Streaming: distributions move along the velocity directions to neighboring lattice sites $$ f_i(\\mathbf{x} +\\mathbf{v}_{i},t +\\Delta t) = f_i (\\mathbf{x},t)~~ .$$\n", + "2. Collision: distribution of each site relaxes to equilibrium $$ f_i(\\mathbf{x}, t) = f_i(\\mathbf{x},t) - \\Gamma (f^{\\text{eq}}_i(\\mathbf{x},t) - f_i(\\mathbf{x},t))~~,$$ where $\\Gamma$ is the relaxation rate, and $f^{\\text{eq}}(\\mathbf{u}(f),\\rho(f),T(f))$ is the local Maxwell-Boltzmann distribution.\n", "3. Specular Reflection: particles reaching the boundary walls or obstacles reflect off them. \n", "\n", "We can approximate the microscopic dynamics by repeating these steps over small time intervals. Moreover, for sufficiently small lattice spacing the results converge to the hydrodynamic variables of the Navier–Stokes equations for an incompressible isothermal fluid.\n", @@ -33,9 +36,9 @@ "\n", "The method enables a local description that can be efficiently parallelized, incorporates complex boundary conditions, and can be extended to other dynamical problems, such as heat transport and magnetohydrodynamics.\n", "\n", - "### Challenges in the classical approach\n", + "#### Challenges in the classical approach\n", "Despite the simplification, all classical solvers face several fundamental challenges:\n", - "- The number of lattice sites required to accurately describe turbulence scales unfavorably with the Reynolds number. As a result, for realistic turbulence, the cost becomes prohibitive.\n", + "- The number of lattice sites required to accurately describe turbulence scales unfavorably. As a result, for realistic turbulence, the cost becomes prohibitive.\n", "- Numerical instabilities can appear at high resolutions.\n", "- For 3D systems of interest, the required number of lattice sites may be trillions.\n", "\n", @@ -49,18 +52,22 @@ "id": "1", "metadata": {}, "source": [ - "## Quantum Lattice Boltzmann Method\n", + "### Quantum Lattice Boltzmann Method\n", "\n", "In the Quantum Lattice Boltzmann Method (QLBM) the distributions $\\{f_i\\}$ are encoded in the amplitudes $\\psi_{\\mathbf{x},i}(0)$ of a quantum wavefunction $\n", - "\\ket{\\Psi}$, while the streaming, collision and reflections are achieved by application of unitary transformations.\n", + "|{\\Psi}\\rangle$, while the streaming, collision and reflections are achieved by application of unitary transformations.\n", + "\n", + "The template of QLBM algorithms is composed of three stages:\n", + "1. Initialization - the initial classical distributions and velocities are mapped to separate quantum variables. The $N$ lattice sites and $V$ velocities are each represented by a quantum variable, composed of $\\log(N)$ \"positional\" qubits and $\\log(V)$ \"velocity\" qubits, respectively.\n", + " $$ |{\\Psi(0)}\\rangle = \\sum_{\\mathbf{x},\\mathbf{v}} \\psi_{\\mathbf{xv}}(0) |{\\mathbf{x}}\\rangle \\otimes |{\\mathbf{v}}\\rangle~~.$$ \n", + "2. Evolution - repeated operatortion of $U_{\\Delta t} = U_{\\text{ref}} U_{\\text{str}}$ propagates the state in time $$ |{\\Psi(t = n\\Delta t)}\\rangle = (U_{\\Delta t})^n |{\\Psi (0)}\\rangle~~.$$ Streaming and reflections are obtained by a conditional shift operator, inducing the mapping: $|{\\mathbf{x}}\\rangle\\otimes |{\\mathbf{v}}\\rangle\\rightarrow |{\\mathbf{x} + \\mathbf{v}\\Delta t}\\rangle \\otimes |{\\mathbf{v}}\\rangle$, while collision can be performed by local rotations which mix the velocity states at each site.\n", + "3. Readout - measurement of global observables or a restricted number of local observables. In the implemented example, we consider a small number of grid points and measure the computational basis.\n", "\n", - "The algorithm is composed of three stages:\n", - "1. Initialization - the initial classical distributions and velocities are mapped to separate qubit registers. The $N$ lattice sites, and $V$ velocities are represented by the possible configurations of $\\log(N)$ \"positional\" registers and $\\log(V)$ \"velocity\" registers.\n", - " $$ \\ket{\\Psi(0)} = \\sum_{\\mathbf{x},\\mathbf{v}} \\psi_{\\mathbf{xv}}(0) \\ket{\\mathbf{x}} \\otimes \\ket{\\mathbf{v}}~~.$$ \n", - "2. Evolution - repeated operatortion of $U_{\\Delta t} = U_{\\text{ref}} U_{\\text{str}}$ propagates the state in time $$ \\ket{\\Psi(t = n\\Delta t)} = (U_{\\Delta t})^n \\ket{\\Psi (0)}~~.$$ Streaming and reflections are obtained by a conditional shift operator, inducing the mapping: $\\ket{\\mathbf{x}}\\otimes \\ket{\\mathbf{v}} \\rightarrow \\ket{\\mathbf{x} + \\mathbf{v}\\Delta t} \\otimes \\ket{\\mathbf{v}}$, while collision can be performed by local rotations which mix the velocity states at each site.\n", - "3. Readout - measurement in the computational basis.\n", + "The algorithm has several variants depending on the specific physical scenario. For instance, reflecting objects may be absent from the medium and are, therefore, excluded from the evolution. In the example presented here, we consider the collisionless case, where the dynamics are governed solely by streaming and reflection. \n", "\n", - "Repeating the experiment many times allows us to infer statistical averages, corresponding to the macroscopic hydrodynamic variables.\n" + "Repeating the experiment many times allows us to infer statistical averages, corresponding to the macroscopic hydrodynamic variables.\n", + "\n", + "Having established the general form of the QLBM update rule, we now illustrate it using a simplified, collisionless system." ] }, { @@ -68,7 +75,7 @@ "id": "2", "metadata": {}, "source": [ - "## Simulation of a Collisionless Model with Classiq\n", + "## Part II — Explicit Example: Collisionless Quantum Lattice Boltzmann Dynamics with Classiq\n", "\n", "As a conceptual example, we consider a collisionless model in which the particle distribution evolves according to repeated streaming and reflection operations. " ] @@ -78,7 +85,7 @@ "id": "3", "metadata": {}, "source": [ - "We begin by defining the encoding of the initial distribution in the quantum register" + "We begin by defining the encoding of the initial distribution in the quantum register." ] }, { @@ -88,36 +95,38 @@ "source": [ "### State encoding\n", "The set of classical states are encoded in quantum states of the form\n", - "$$\\ket{ֿֿ\\text{grid|velocity}}=\\ket{g_x g_y| v_{\\text{dir},x} u_x v_{\\text{dir},y} u_y}~~,$$ where \n", - "the grid ($g_x$, $g_y$) and velocity magnitude ($u_x$, $u_y$) variables are encoded as QNum variables, and the velocity directions ($v_{\\text{dir},x}$, $v_{\\text{dir},y}$) are encoded as standard qubits. The QNum's allow a straight forward implemintation of shift operations, while the velocity directional encoding enables flipping the direciton in the $i$'th dimension by application of a single NOT operation on $v_{\\text{dir},i}$.\n", + "$$|{\\text{grid|velocity}}\\rangle=|{g_x g_y| v_{\\text{dir},x} u_x v_{\\text{dir},y} u_y}\\rangle~~,$$ where \n", + "the grid ($g_x$, $g_y$) and velocity magnitude ($u_x$, $u_y$) variables are encoded as QNum variables, and the velocity directions ($v_{\\text{dir},x}$, $v_{\\text{dir},y}$) are encoded as single qubits. The QNums allow a straightforward implementation of shift operations, while the velocity directional encoding enables flipping the direction in the $j$'th dimension by application of a single NOT operation on $v_{\\text{dir},j}$.\n", + "\n", + "For example, a quantum state $|{2}\\rangle |{4}\\rangle |{2}\\rangle |{6}\\rangle |{1}\\rangle |{3}\\rangle$ means that there is a particle on lattice site $(2,4)$ with a left velocity of magnitude $4$ and down velocity of magnitude $3$. \n", "\n", "### Time evolution: \n", - "The time-step is composed from two operations:\n", - "1. Streaming: particles move one lattice site if there speed allows it (descretized via CFL-based-schedule)\n", - "2. Reflection: partilces hitting the obstacle are specularly reflected—direction is flipped, and they are pushed back into the domain.\n", + "The time-step is composed of two operations:\n", + "1. Streaming: particles move one lattice site if their speed allows it (see below for further details).\n", + "2. Reflection: particles hitting the obstacle are specularly reflected—direction is flipped and pushed back into the domain.\n", "\n", - "We condiser periodic boundary conditions in space, while the obstacle is placed between selected lattice sites, acting as a perfectly reflecting wall. The obstacle is placed within the lattice forming a barrier around the center of the grid.\n" + "We consider periodic boundary conditions in space, while the obstacle is placed between selected lattice sites, acting as a perfectly reflecting wall. The obstacle is placed within the lattice forming a barrier around the center of the grid.\n" ] }, { + "attachments": { + "707b125d-b9c2-4fbf-ba83-0aebaa224c46.png": { + "image/png": "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" + } + }, "cell_type": "markdown", "id": "5", "metadata": {}, "source": [ - "The quantum initial part of the circuit is of the form:" + "![main.png](attachment:707b125d-b9c2-4fbf-ba83-0aebaa224c46.png)" ] }, { - "attachments": { - "707b125d-b9c2-4fbf-ba83-0aebaa224c46.png": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAABcCAYAAAA8qz+yAAAKsmlDQ1BJQ0MgUHJvZmlsZQAASImVlwdUU0kXx+e99EaAQKQTehOkE0BK6KH3JiohCRBKiIHQxM7iCq4FERFQlrIqouBaAFkrFqwoFrAvyKKgrIsFC1j2AYewu187331n3vzOzZ3/3Jkzk3MfABQGRyRKg2UBSBdmiUO93RjRMbEM3AggAHlAAhrAlsPNFLGCg/0BYrP93+19L4Cm+tumU1r/+vt/NTkeP5MLABSMcAIvk5uO8FGkTXBF4iwAUIcQv05OlmiK7yCsIEYSRHh4ipNm+PMUJ0wzWnY6JjzUHWFdAPBkDkecBADZHPEzsrlJiA55ai5zIU8gRHg1ws7p6Rk8hM8gbIjEiBCe0mcm/EUn6W+aCVJNDidJyjNrmTa8hyBTlMbJ+z+3439beppkdg4DpJGTxT6hSE9H9uy31Aw/KQsTAoNmWcCbjp/mZIlPxCxzM91jZzkzLYw9yzyOh59UJy3Qf5YTBV7SGEEWO3yW+ZmeYbMszgiVzpsodmfNMkc8l4MkNULqT+azpfr5yeFRs5wtiAyU5pYa5jcX4y71iyWh0rXwhd5uc/N6SfchPfMvaxewpWOzksN9pPvAmcufL2TNaWZGS3Pj8T0852IipPGiLDfpXKK0YGk8P81b6s/MDpOOzUIO59zYYOkepnB8g2cZeABP4I88DBAMLIEd0mwAkm0WPzdrajHuGaI8sSApOYvBQm4cn8EWcs3mMyzNLW0AmLq/M8fjbej0vYTop+Z8GQ3IsX6P3Jmtc76EMgDaigBQejDn090NALUQgNZOrkScPeNDT70wgAioQAEoI/8NOsAQmCK52QJH4Ipk7AuCQDiIAUsAFySDdCAGOaAArAFFoARsAdtBJagB9WAfOAgOgzZwApwFF8FVcBPcBQ9BPxgCL8EYeA8mIQjCQRSIBilDmpAeZAJZQkzIGfKE/KFQKAaKh5IgISSBCqB1UAlUClVCtVAj9DN0HDoLXYZ6oPvQADQCvYEmYBRMhhVgdVgfXgAzYRbsB4fDi+EkeBmcDxfCm+AKuA4+ALfCZ+Gr8F24H34Jj6MAioSio7RQpigmyh0VhIpFJaLEqJWoYlQ5qg7VjOpAdaFuo/pRo6hPaCyahmagTdGOaB90BJqLXoZeid6IrkTvQ7eiz6NvowfQY+ivGApGDWOCccCwMdGYJEwOpghTjtmDOYa5gLmLGcK8x2KxdKwB1g7rg43BpmCXYzdid2FbsGewPdhB7DgOh1PGmeCccEE4Di4LV4TbiTuAO427hRvCfcST8Jp4S7wXPhYvxK/Fl+P340/hb+Gf4ycJsgQ9ggMhiMAj5BE2ExoIHYQbhCHCJFGOaEB0IoYTU4hriBXEZuIF4iPiWxKJpE2yJ4WQBKTVpArSIdIl0gDpE1mebEx2J8eRJeRN5L3kM+T75LcUCkWf4kqJpWRRNlEaKecoTygfZWgyZjJsGZ7MKpkqmVaZWzKvqASqHpVFXULNp5ZTj1BvUEdlCbL6su6yHNmVslWyx2X7ZMflaHIWckFy6XIb5fbLXZYblsfJ68t7yvPkC+Xr5c/JD9JQNB2aO41LW0droF2gDSlgFQwU2AopCiUKBxW6FcYU5RWtFSMVcxWrFE8q9tNRdH06m55G30w/TO+lT8xTn8eax5+3YV7zvFvzPiipKrkq8ZWKlVqU7ipNKDOUPZVTlbcqtyk/VkGrGKuEqOSo7Fa5oDKqqqDqqMpVLVY9rPpADVYzVgtVW65Wr3ZNbVxdQ91bXaS+U/2c+qgGXcNVI0WjTOOUxogmTdNZU6BZpnla8wVDkcFipDEqGOcZY1pqWj5aEq1arW6tSW0D7Qjttdot2o91iDpMnUSdMp1OnTFdTd0A3QLdJt0HegQ9pl6y3g69Lr0P+gb6Ufrr9dv0hw2UDNgG+QZNBo8MKYYuhssM6wzvGGGNmEapRruMbhrDxjbGycZVxjdMYBNbE4HJLpOe+Zj59vOF8+vm95mSTVmm2aZNpgNmdDN/s7VmbWavFuguiF2wdUHXgq/mNuZp5g3mDy3kLXwt1lp0WLyxNLbkWlZZ3rGiWHlZrbJqt3ptbWLNt95tfc+GZhNgs96m0+aLrZ2t2LbZdsRO1y7ertquj6nADGZuZF6yx9i72a+yP2H/ycHWIcvhsMMfjqaOqY77HYcXGizkL2xYOOik7cRxqnXqd2Y4xzv/6NzvouXCcalzeeqq48pz3eP6nGXESmEdYL1yM3cTux1z++Du4L7C/YwHysPbo9ij21PeM8Kz0vOJl7ZXkleT15i3jfdy7zM+GB8/n60+fWx1NpfdyB7ztfNd4Xvej+wX5lfp99Tf2F/s3xEAB/gGbAt4FKgXKAxsCwJB7KBtQY+DDYKXBf8Sgg0JDqkKeRZqEVoQ2hVGC1satj/sfbhb+ObwhxGGEZKIzkhqZFxkY+SHKI+o0qj+6AXRK6KvxqjECGLaY3GxkbF7YscXeS7avmgoziauKK53scHi3MWXl6gsSVtycil1KWfpkXhMfFT8/vjPnCBOHWc8gZ1QnTDGdefu4L7kufLKeCN8J34p/3miU2Jp4nCSU9K2pJFkl+Ty5FGBu6BS8DrFJ6Um5UNqUOre1G9pUWkt6fj0+PTjQnlhqvB8hkZGbkaPyERUJOpf5rBs+7IxsZ94TyaUuTizPUsBKZSuSQwl30kGsp2zq7I/5kTmHMmVyxXmXsszztuQ9zzfK/+n5ejl3OWdBVoFawoGVrBW1K6EVias7Fyls6pw1dBq79X71hDXpK65vtZ8benad+ui1nUUqheuLhz8zvu7piKZInFR33rH9TXfo78XfN+9wWrDzg1fi3nFV0rMS8pLPm/kbrzyg8UPFT9825S4qXuz7ebdW7BbhFt6t7ps3VcqV5pfOrgtYFtrGaOsuOzd9qXbL5dbl9fsIO6Q7Oiv8K9o36m7c8vOz5XJlXer3KpaqtWqN1R/2MXbdWu36+7mGvWakpqJHwU/3qv1rm2t068rr8fWZ9c/a4hs6PqJ+VPjHpU9JXu+7BXu7d8Xuu98o11j4361/Zub4CZJ08iBuAM3D3ocbG82ba5tobeUHAKHJIde/Bz/c+9hv8OdR5hHmo/qHa0+RjtW3Aq15rWOtSW39bfHtPcc9z3e2eHYcewXs1/2ntA6UXVS8eTmU8RThae+nc4/PX5GdGb0bNLZwc6lnQ/PRZ+7cz7kfPcFvwuXLnpdPNfF6jp9yenSicsOl49fYV5pu2p7tfWazbVj122uH+u27W69YXej/ab9zY6ehT2nbrncOnvb4/bFO+w7V+8G3u3pjei91xfX13+Pd2/4ftr91w+yH0w+XP0I86j4sezj8idqT+p+Nfq1pd+2/+SAx8C1p2FPHw5yB1/+lvnb56HCZ5Rn5c81nzcOWw6fGPEaufli0Yuhl6KXk6NFv8v9Xv3K8NXRP1z/uDYWPTb0Wvz625uNb5Xf7n1n/a5zPHj8yfv095Mfij8qf9z3ifmpayJq4vlkzmfc54ovRl86vvp9ffQt/ds3EUfMmS4FUEiDExMBeLMXAEoMALSbABAXzdTX0wbNfBNME/hPPFODT5stAPV9AIQvB8D/OgA7KwHQR/SpcQAEUxG/I4CtrKRtthaertunTPYAUhVZm3v4/pvvEwBmavq/5P3PHkypWoN/9n8CZbMK+oYtuUgAAABWZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAOShgAHAAAAEgAAAESgAgAEAAAAAQAABJagAwAEAAAAAQAAAFwAAAAAQVNDSUkAAABTY3JlZW5zaG901OChGwAAAdZpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+OTI8L2V4aWY6UGl4ZWxZRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpQaXhlbFhEaW1lbnNpb24+MTE3NDwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlVzZXJDb21tZW50PlNjcmVlbnNob3Q8L2V4aWY6VXNlckNvbW1lbnQ+CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgp9IlpfAABAAElEQVR4Ae2dB5xU1fXH79KlV5EmHRUFAUURK4i9YVcsqDEmUaNGEzXJP7HEmEQjajRqYoyxN2yoiIpYUJqFIkUF6b13pO7/fO/sXd4OszC7zMyW+Z39zM7Mm/fuu+/3zjv33NNuTpMmTXKdSAgIASEgBISAEBACQkAICAEhIASEgBAQAkJACBQRgQpF3F+7CwEhIASEgBAQAkJACAgBISAEhIAQEAJCQAgIAY+ADEtiBCEgBISAEBACQkAICAEhIASEgBAQAkJACAiBYiEgw1KxYNNBQkAICAEhIASEgBAQAkJACAgBISAEhIAQEAIyLIkHhIAQEAJCQAgIASEgBISAEBACQkAICAEhIASKhYAMS8WCTQcJASEgBISAEBACQkAICAEhIASEgBAQAkJACMiwJB4QAkJACAgBISAEhIAQEAJCQAgIASEgBISAECgWAjIsFQs2HSQEhIAQEAJCQAgIASEgBISAEBACQkAICAEhUCkRBHUaVHR161dwe7evnOhnbRMCQkAICAEhIASEgBAQAkJACAgBISAEhIAQEAIuoWGp86FVPTSrlm8TREJACAgBISAEhIAQEAJCQAgIASEgBISAEBACQiAhAjsYlohWgmZP3exm2UskBISAEBACQkAICAEhIASEgBAQAkJACAgBISAEEiGwQ42llnnpbzIqJYJL24SAEBACQkAICAEhIASEgBAQAkJACAgBISAEAgI7GJbCD3oXAkJACAgBISAEhIAQEAJCQAgIASEgBISAEBACO0Ngh1S4ne2s34RAaUCg//Wt3YGH1isNXVEfhMBOEXj6HzPcuFErdrpPOn/Us5JOdEtH2+Kx0nEf1IvdQ6A08DFXIN1i9+5jaT5aPFaa7476VhQESgMvS1YW5Y6VvX2Ly2M5TZo0yY1ebuce1VwdWxFu+OD10c36LARKBQIDnu/muvSoWyr6ok4IgWQQeOrBGY5XpknPSqYRL7nzicdKDnudOXUIjBu10t3Y7+vUNZhkSxjgeYnKPwIlJSvFY+WftzJ9hTf2G5txx2WXHvXcgOe7ZvpSdb4SQqB3m2FFPrMilooMmQ4oKQQQaOkyKt127aiSuiydt5wi0Kp9bXf59R39hCXThiU9K+WUqeIuqyR5LJ2GS8njuBudBV+PObm562UvJuCZlJfIynQZlT4ePNd9ZC9R6UAgjMf0przw2JMPTnYzp64uHQCrFxlBIMjKS69rnXHDEudMB8HD8LKodCAQeKw447FqLJWOe6heJIFAugRaEqfWLkKgyAgwUIZJBZOXTJKelUyiXXLnivJYyfVCZxYCu48ARhiREEgnAmE8Tuc51LYQSDcCyErG/nQ52nfW/5I45876o9/Sg0AYj4vjdJFhKT33RK0KASEgBISAEMgYApk2XmbswnSirEJAdTuy6nZnxcUeeKjKN2TFjdZFCoFyhADGy+KQDEvFQU3HCAEhIASEgBAQAkJACAgBISAEhIAQEAJCQAi4ItVYuummm5KCbOTIkW7EiBFJ7audhIAQEAJCQAgIASEgBISAEBACQkAICAEhIATKJgJFMiwddthhrmfPnru8UoxKMiztCFPFipVcq2YH+B9+mD1uxx0iW/aoWtM136uDa1S/hZu/+Ac3b9FUt3nLxsgeyX+8/eqBjqX/7njknOQPKuN7jvl0kfvnn79x1/y+kzvkqMZl/GrUfSGQPgT0rKQPW7UcQyDw2FPv9REkQqBMI4BeAaFbiIRAOhDof8JQr7eKx9KBrtrMFAIa9zOFdOk6T5EMS+eckz2GiXTcpjN6Xe36HvtL99GYF11hhqUGdZu6s/pc7w7tfLKrUmUPVyGngtu6baubs/A79+ygO9y3M74octc6tuvpJk3LvggyhJoG5iKziw7IQgT0rGThTc/wJcNjIiFQ1hGAj+WsKut3sXT3XzxWuu+PepccAl8MX+w07ieHVXnaSzWW0nw3c8wwVLtmA/e7q553F5x8q6tWtYarWLFywrNWrlTVHdntTHdM9/PMoFTRLVwyw61cvdj2zXUdWnZzfftc5/a0CKai0P5mVBIJASEgBISAEBACQkAICAEhIASEgBAQAkIgHQgUKWIpHR0oz21WqVzNtdu7q7vy7L+4po3buRWrF7l6tQtPyyLV7Zupnztnxqgx3wx2C5ZMd7m5ue6QTie7Gy591LVr0cV1aNXdLV4+J2nYzj3+Rr/vwPcHJH2MdhQCQkAICAEhIASEgBAQAkJACAgBISAEhEAyCMiwlAxKxdynXu093fkn3ezq1dnLjRj7ppu94FvX75Tf7rS1H+aMc7yiNHXWV27R0lmuYb1mFvFUPfrTLj+HNLjyngoXH25JCCYU3qNAKYw9ioY+ZxsCelay7Y5n/noL47H47fRM8jjz90dnTB6BRDzL0fHbxcfJY6o9CyIQz0vh1/jt4rGAjN5LIwLx/Bq+h/don8XLUTTK12cZltJ4P1etXeYNSiPHDXIff/Gy67Jvr2KdjailLVs3uY2b1vtXso1kUxocBTUTCa+H75pQAC6EmQRaAUj0JcsQ0LOSZTe8BC63MB6jKG2UJI+jaOhzaUMAnSKeZ+ljIl2DwvTSLUrbHSz9/UFWxuup9DrRtikbLir9F6QeZi0CiWQlYMRvv/b/OktWlmMukWEpjTf3x43rfKHuzVs2WUrbtmKfiSilxg1auUXLZrllKxck3U42pcFRpDtaqJtIJQZmBFj3I/dMGjPtKATKOwJ6Vsr7HS756yuMx7QqXMnfG/UgeQQwFMXzLIYAKKpv8F1GJVAQFRUB9NN4HmMiDj/F81hR29b+QiCTCMTzcZiHxW+XrMzkXcn8uWRYSjPmmzb/uNtn6NnlDFfVVoibvWCKmzV/ctLtZUsaHIAUJqgYtAv7LWkgtaMQKEcIFPY86FkpRze5hC+lMB4rbHsJd1enFwKFIhDPsxiW2Ba/vdAG9IMQ2AkChfGReGwnoOmnUolAPC+HUiTx20tl59WplCGgVeFSBmV6GqpkK8id2uvnbvXapW7yDyPdug2rkjpRSINT0e6k4NJOQkAICAEhIASEgBAQAkJACAgBISAEhEAxEJBhqRigZeqQChUquqvOu9fVqFbbzZg3yVGrKVkKaXDJ7q/9hIAQEAJCQAgIASEgBISAEBACQkAICAEhUFQEZFgqKmIZ2j8nJ8cduM8x7qiDznYrVi9yb3/ymFv/45qkzk60UjalwRUGisIvC0NG24VAQQT0rBTEQ99Sj4B4LPWYqsXMIwAfq25j5nHPpjOKx7Lpbpfva9W4X77vb6KrU42lRKiUgm2tmh7gLj39jw4D0ye2otyE7z4tcq+yOQ0OYSaBVmSW0QFZiICelSy86Rm+ZPFYhgHX6dKGgAoqpw1aNZyHQHyxYwEjBMoiAvGLeJTFa1Cfi46AIpaKjlnaj9irYSt3Zp/rXGN7Hzn+bffGsH8W6ZwhDW7StBFFOk47CwEhIASEgBAQAkJACAgBISAEhIAQEAJCoCgIKGKpKGgVY9+KFSq5ipUquxw7tkrlar4FtrHKG7R5yya3bdtW/5l/dWs1ciccfpmlwR3tvp/1lRv4/v32+5b8/bds2ey22vfCKJoGV9g+2i4EhIAQEAJCQAgIASEgBISAEBACQkAICIFUIFCuDEsnHnyTx6Rd08PysZk2f6SLvUomeueog89xvQ69wBuGauxR1/ere6cTXZsWnfznQcMedSPGvelyc3Nd9Wq1XO9DL3THHHK+26NaTdeicQf3y4sesv1yY9djb8O/etUNHfWc+3Hjuti2uP8d28auPZvT4OIg0VchIASEgBAQAkJACAgBISAEhIAQEAJCIE0IlHnDUjAmhfd4nNo17Zm/aciX9zlemaQ6NRu4lk07uj2q1sw/be0a9R0vqPoetfO379WwtTvq4HNdjT3q+G21bB9eUfp2xhhXqWLl6KYCn/fPMywpDa4ALPoiBISAEBACQkAICAEhIASEgBAQAkJACKQBgTJtWMKYVJhBKRFWYf+HB51jUUyZiWCiPlKyNZKmz53gbvjrkYm6ntS2bEmDu+3aUUnhkYqdMOJVrlLVN7V16xa3efNGH11W1LYpwk4qZIWKFf2hmzdtdFu2bi5qM2ncn2TNvMi4NJ4l2abBq1KlKmZENRFln7dt3bpD2ihtVa5cNWZopftRskvJtb/YccW7Z9HmyurnTD4ru4NRjiULc79EZQ+BssJjO0OW1PRKpKznVDD5vs3LGvaviPwxttxqsnqTyf6SJORh5cpVfBe2Wkr85s2b9Myk8IZ8PHiu+8heIiGQLgSefHCymzl1dbqaz0i7yKEqpndVNF2WTIstphdvs1eFChVdTgXkZ6778cfEGRUZ6aCdhL7QR/qD/P5x43ov1zN1/vJ+HngYXhYJgUQIlEnDElFI154+MNH1JLWNY0sieimpzu3GTqFot9LgdgPEuEMP6Xa8O/boC/zW76d97d5+/wm3bn3RFYOaNeq400+8yrVpFUuBfH/Ys2701+/ln43Ux7323Nut37DWLVoyO397Jj40brS3q1G9tps1Z4rV79pe76uo507VNdCX1i0PcPvvc6jHi8nUwsWz3IRJn7sfZk5wS5fN88oL/etj96Zb515ekYj2F4PSxk0b3KLFs924SZ+6OfO+cytXLY3uos+lAAEMg00at/IT+BmzJpWCHqkL2YZA86bt3Ml9Lnf7tj/YIaeRE1+OH2oG6yqubetOLnfbNjdh8udu0JB/ZwQaJkUN6jexdPgabvHSufmTtCMOPc0deVhf34dx33zihn7ygttQwhO4jACik3gE4Iu6dRq5urUbugWLZ7oNpiuIhEAmEahTu4E7skdfh17cdK+2Jn/WuOkzJ7qZcya7ls33c7Vq1TN5td7d+/DPMtYtZHaTxq3dshUL3XJ7QW1Mfzzx2Etdvbp7+hq2jz15q/89Y53SiUocgapV93BNjS8wKi5YNLPE+5NNHShzhqXdNSqFmxsinTKdGhfOn853pcGlDt1923d3B+wbq1u1dcsWt8cetYplWCLlsW3rA72xhN7NnD3ZG5Yo5M7EpjsGrCPPdx9/PtC99Mb9qbuAnbRUu1Z9t/++PdxxR1/oqplh6+77L3Nr163ayRGJf0rlNTAYnHbCT93xvS7yxq5wxv336eGOOfwcN37ip+7F1wd4Ixi/sb3Tfj19pEHYN/79hN6XuBFj3nLvf/y8N0zhUROVPALNmrR1nTse4U4+7jIzFs53d9x7Ucl3Sj3IKgQq2mT9mp/83U9EwoXXsYn70uXzzNDfysGj0LoNa8LPaX3HON+9ax93+KGn+wiqZ1662yZtU/w5kXVhLFq5aomrWrW6DEtpvRulp3Ei6rp2Otr1POQ0z5OPPnmLmzZjfOnpoHpS7hEgmrPXEee6vif93PTgWGmPWjXret0LI3iHdt18bVgiPjNBRE61N53aO3+PusA988pf3Aem40FN9mrtddv6dRt7w1LdOnvKsJSJm1JKztG+TVfXqWNPm9v0c6O+etc99eJdpaRn2dGNMmdYOvHgG1N2ZzAulWRh75RdiDWULWlwqcQsmbaIegmr9rEaX/iczLHRfTiOcOFwPO1CGHcwfBzd80yf+kXaV6bo0INOdBedc7NXBqbPmljs06byGrp17u1OOf4KH8ZMhwJOKNZMAjt1PNwtX7nIPT/wnh0MfCg0IV0F7y5pjKTUEfF05GFnmveqsXvqpT+7ufOnFvtadWBqEOC+HN3zLHdSn/4+RRTDkkgIZBqBhg2b5xuVSHWeMXuS926O/eZjb+DOdH/27XCwu7zfbVZ7sZab8v0XBU5fYCyyvhJJJcoOBOrXa+wuu/CPPgJjiUWxiYRAphGoUb2W27v5vvlGJSL3vxj7vlu1epmPIMewlElq3KiFO6/vDW7fDt13qOKwxVbbRp6jbxOFTyqzKDsQwAAKX3S2uQLp4qLMI1CmDEsYgqLFuFMBF2lxNzzWNBVNlWgbSoNLD/yfjnzdBaPLipWL3dq1K4p1otVrlrnX3nnEfTj8ZX88qVkQnp/69faKGZX8lsz927tZB1elSrXdPmEqr+FEM7KRGw9N/m6M+2TEqz498IyTrnLtzDtV2bxUhDk3a9LOff/D1wX6vsRS5F57+5/e4FTBBpfatRq443r1c3s328dS5Sp4j9rBXY71qYbUyhKVHALUVCKlg7pjIiFQUgi0brFf/qmJAhr6yYtu3MRPfJrRycdelv9bpj4QJYVRKREN/fRFN+m70f4njAvrMxRFlagv2pZZBEgZJq1HJARKCoG6tRu5OqZTBfp6wkfu+VfvNaOSc4d0PS5sztg7Dk2iS9H1tsVFSX1nZSv++9wdFtW5hzd6kVIsyg4EcFo2atAsOy62lF5lmTMspQNHDFZlPSWuY7uejhQ4pcGllkNIU+t1xDm+0ak/jPW1eoiKIaqm036H26C1zadnzV0wzR1/zEU+KoadmaQ89+o9bmFebm9lm0B33v+IfO849TE2m1fl4nNvMYNJ5/xOH2EpEC3NKzTqy8Hu05Fv5G9P5gMCtelebdypx//Eh8uH1QM5z3fTvnLvf/ScpXjM90aWM076mTvowGNtUI4VE29iE5obf/FPP3H50CYw9J9JTt+Tf25ttbFooZiowPvDNT3zyl8dxrLGVhcqmWugXyf3ucy1MGMWxiG87xjshpmhbd6CH/Ivr7kZjCC8TRO/HeGGj3rTf2ayhWEJwmDUwIxx8bRu/Ro31mqP0HeI66eNO2992dWqWc9Vs9SR7qYATZj0Wb6xML4Nfd89BEgdOvvUa13DBk09/iQdbtmy0U2dPs69/s6j3uhHPYSTrP5BJ3seArVssa+75brH/bOEwkoUH7xC2uILr/3d9Tvr16661d7CuEudM/gZ4pk72FKHaliq6bbcrd57yrP1zZQRnm9C+0StHdyljzvi0DNMGW3gn4FYkdH1Vk/nQ3vWXnfr8tJAMVr2v+D3/lBSLxctmeMOO/gk4/WWvj+z537r3vngSUsbXenTV3muq1hE3RozOn89fpilXD4XTqv3FCNw5sm/cPvtc4jbtOlHnwpEqgN16zZu3ODgm3c++K83TPOcH9HjDP/c04XVa5abd/0D99Fnr/gekXJ2vnk1iYAMVLNGXZ+Ce4ClBw9866GdFsbGKNrvnFvcno2amzyravJsvaXnGl+8/18vY0Ob4X3Phi0cRvPWLfePTXYs2miV9WnEmLd9v5CHl5x7qzvIDN+B9m6+j/vJxXda5NIYM5g/4seFw63OEjR+4nCTm9Pyi4wj+9u26uzriuDJp+g449SKFYvMofFPG7emhmZdPUsLOevUqz0/b7Ei4M/bONW1Uy93oPExTgKwJVrq5TcfyD9GH1KPABPj40x+dTR+3qNqDVukgnFvq8NoiBERGcc4eNoJV/pxK/SgjtVZuuzCP3gHycP/uclk08nuGHQUk5Wjv3rPNTOdpUPbLiZ3t7hJ346M8bL9Rg2x3kee58f1SpUqeYfNd1O/dB988ryvKxba5x0eQo9oaYbXoEcgX5csnWd88aBF9c3wu3MNZ55ytdc3iA7B0NDjoJPcfhZFgtMAmTjko2e8XO9oNRNPOe5yP37j2CHFc+Cgf+wQeRzthz4XH4ED9z/SHX342b5u3LLlC8wRN9ZHCeNkIzLzbZNV8Br13Pqd/RvXsL6N2baAAYW30c0YrzFeE/2NnDzntF/6+xx61KFtV/ez/n9x1HsjQqgwQu+iNhzjL/WQ0JmXmVwaabJv1FdDdjgMxyKlIY60sbpmzTpeR0WHpQbj6+acXWV6Jyn0fU/5he8zDVSokGM6RX/P4x99NtCuYa079KATvDEWvpxqTsioIZ5aZWF/9FEMU/DqSNO7x3z1vtXliRUfJ90OZyTPDTR46P/8+HLUYWdZvbOG/lrmL5zhhgx7xvpX/Kh/37j+FYoA41msbEc/X2cuFI7fZIsgMe5/YDoXtZTYh3tFhCeEnDuk6/He0EQpjDXGO9S6rWF8uMbGX+rcntDLnNm2QNNi0/OY1zB/QD8gmp7082rVqht/b/a656umF8yJy3ggJb2PpWLCJzjqGYtzt+V6/fDD4S9Z/z72zwfX0OWAo7xuS9/eM55B5+jZ/RTj87o27m50E01vHfbZyz7Q4AzrJ/KX9qgr+8mI121+8zGHlnoqM4alVEcqRe9Mu6axGjrRbWXpM2lwovQgsE+7g/wgRusMiAgcQoAROCjiUFub2DAAoZTjPYHYl+1//ceVbvbc76xeUC3Xvk0Xfxy/Mwmh2OD+Vr+JgTfQnpaawWRphaV7FdWw1Lxpe3f7zS+Yx9v6YcpAlDDKtGl1gPv7w7/wk5FWJrBQKALRdxQ/DEejLScZT9Bvr38ibxIe31Znr2j8/s9necG4q2uguDaKS9OIgYpJPdii/Dzx3O1+8kRffvnbXn6lt/rmnSXEGsUaap5X64TPG0zZWWOT+l0Rq+4x6GOYuOrSP/vdmeBhWBClHoEDrNbVb6551BtZUF63U67xfldT+rq7/7v7HK+Qcd/h80A1qtfxgy41vn6Y+Y3bz/YNhe7hXQq6M8CiwI6x8HuKuN909SO+vhbPHr9BPHcone9++D+77/f5bSjLJ/a+1CbT19jzW8P23d63GB92MwW1iXtj8KOmXK50jRo2y3/m27TsRKv+/OGZ4rlGqWbffSz8v2JeyiVtxWRBZa+A+pPrX0oR6Nr5GMO+mzf6dLGaM8hbFDawZ2JOjbozbcJxfK+L/QQg3Gv4gsUA2rc50CuP1WwiTzs4DgLh3W699/4OI/t7ZoQvjJhk/az/3d64HeNzUySZuLc72HW3ydM9VrgWmR8IZbKfpRxjNIeHorx6wH6HGb81N359ynE9FLIPBM8zZsCzb733Hy+f4W0IQ1nVMdtrLPGM/O5XT/qxJPApfLvNFNwD7fxvDXncvW78DWEM4FmMGW63maGpkaW47FOAj8GmnWF19/2X+2P0L7UIMM5fct5vbeGJ3p5/A09wFu7lPu0Pcg88dp03yHP/uB+BmHizDxHHRH5iUAx8gfEIeYTMgyeZ6Lz61sPeyHrh2b/29zrwB78jZznm2YF/8xN3zoHj5o5bXvJ8wrMVpbatDvSTnUf+e7M37CK3GceJIobfmllBZyKwOY5r8ucwwxkGXerzVPUTr9jKYRzHeJzJQs/Raynvn3m+GWeRIxhXjjRDe2xVSYsWtmf+0xFveGP1NT+5t4Dc8PeswyFWu+gEd/s9F1qU/kq/sAyyKMqnGB8xRqEPT8mLpIzHFF4474zrfc04DDjh+LYmj6mNycT5jXcf844BjoU3f3HFPX6SHts/jNXoEF28U2HAo9dYf1q6DvadSL4Y5XgHKLodTiz0COR0qLGEMRZ9G0Lv/fllf3Ud7RoxPPiBw/4zRqDD4JT41/9+5w0DrEpMxHt4vjDK4zSL6hE8i+gDD5mRd7rpLqLUI0DB+Csuuq3AmM5ZWEm4rc1rcPA88ext3vDJvaJ0BsT4z/2C33EoV7exlDG3Vs363piIIwddAL5s1aKje8UM3Twjt/3mWRsfGRNjcoy2tpkzqEuno6wMx735zkPO8zObW8AzrB6OPA4UnqOnrfwGjgKc8zgtAy+1sPladZsXVq1S3Z+fa2lvDgFSO+HbsKgN7SHjSUOFR8eZs7O0U8FRoxT3NpW1leIvE6NVOg1X8edL9feQBjdu4sgyfR27xuXHXe+S4j2I6AmDYY6zQS5vAsuEAqHFbxhhmPAS8YAgqmbCiwkPoetEBj30OHXBTOTk7U8XOZ4aGRvNys7gSP0giHZY6ac4ucHXXnlfzCNkAooVY/DsoFjSPxRNlNO+5vEf+NY/zMO+0c612W/nvCgeeM035dV+6n/+770w5vrwFq035YH+o6RwjVzb+Wfe6IZ8+PROrwEF4Fiz5qPkQJs2/+iVCLyZTOTYjmUeb8GyFQtiXiUzHK1avdTvzz8KRBJ9EKNc72WbH4lyyvuh0LevLIokEApBKtL/QnvJvmO8Xtt018awZNvb9X6ZfVbgDQZYeJ8BFe8gHkCUQ5Q9JjtEa+B9x3OKdwnDX7433Phvg3kZNxt/wHPhxXXi5fT1EmxQXbBwusP7ivcUxZRnhwGfY+3ErqqdH76Cz/EU4fVHIcWjFFKM1q1f5aMyiDKCn2nj2KPOtyjBIdbnsV454PwQvEc/Y97OHN8X+J9BHuL55VowOLOdSTvFRL+aMMyvSOh3ytC/8s5jwBgMMyhwFYy34AtkJR7Md82bjIw79fgrPf8g01i1CGWMRRfgzcPMO0iE5MgvBvv7hpcwyAP4CPkEL3FsIuL+nt/3V/mh9pwbuYkyikzDSHT9VQ+6m28/xRvpWXHzuGP6+Qkc7dE+qyaxPwotiim8zGSIdmgvTJboA1FH8BcqNGNK4MvwTptManAowH88e0QccRznYCIPj1Mgn4nV8FEWBRt5vnJsfGMFTs7NuIP3FcMF4wUTLyZ+rBaaacqkPtauaV27vEzKyxwfLUzEMPeMcRgvOXKGVCOcPEzYTz/xp+5fT/3Oj8ncn+CAgp832j0OS7rnWLRG4AfuX4yPN3qdAg94G1vZ8PSTfpof5Ut036bNG/LudTU/mSY6hDEYI8F1Px3gx3fuOXyEI4f2a9ao5/UWJjxElE57Yrzfzm+x81sKivE//MozxPOG/KffRIfAz7SPI8DXTLRrx8tPQfqJFlmVacosj7W2y1uQ0UvkngSZAZ8hOzcbr7GdSTa65hV59dyY1Aa5gTysYrID3e3mX/7b3f63Cz2PMtbxWzBMbkL2eV5K/OwwtlNwnkVXOCf3f/2GWCQQzk/kUp+jL/QRICO/eMfLrhPMIUAEB4Rs/3HjWr+d/bkGovkvtkhRVunkGUBOoXtA9AcZtjXvGjln/itvwk+k+2UX/MHrDqFP6Mo5po8H2UeEy2pzav7n2dsKyErOgQGe5xXDFTo8i/KABxH5+5qhdI45FNCXM0mZ5ONMXlc4F/f3Jxff4ccleGjtuhUmR1Z5nYu5Dfet6wFHe0Mo9wb5E4rK0wbbkEfIV9qKvXJcRRv7GIO989rUve8sqg2euu6nD/gx0R9rx8D33GP2Rc8j2vdbi/ScbeVMjrLauLGI9VhJB3Re2kP2IffQRS+waHsil2DBwI+0jdGVyM01a5d7mYh+irykNhSEzkkEK88JvEY2QLcDe3vHK+fJJBWVx8qMYSndIFJrqawSTlfjfder4032KqtXset+t2lK1Enmldxd9Qxh9Il5yrF2MxizyhDvDFZ4OAoj0ucef+YPPt0Mrwc06st3vfd6STGKGTe1lTCgLTbAIsg+Gv6KNy6hPNAfBl2EFZbz195+2Ec2HWSCCqG5cPEsWznhz7aM8Qy32SZbK1Yt9oITBZBw0Zcs+mMvUyiJ/MHDCXG+nV3DUjMAIHTx2EMIXELfScnDUHShCVyE5oEHHOnbWr5yoVci/M55/1BUr7r0Lh/lwqZ161abEjrKF/CO7rezzyjaDEhcZyVTmDByZJpItz1iz+31XNJ9/kw/Kyh+DKIQAzEpjryY/FBIkWg6BnwUU0LaH37i175wfNdOx/hj5sz73v376d/7lIwQxux/sH8owB9//qo3VLEUPEbOLnYcE3Am0ix1/N/nbvcKHQbR/WxCzAB+5SV3ut/chpKa458DovFQLogEIJWDCc1vLcoDoy5KAIprPME3o75416cLVTQl9v4/ve+VWfZjcCf148txQ91PL7nLG5TYXsdqUZDut2jxbL5mjMo7j8UDicJIaDiGD2TTeJss/eX/Xvf3nn2ps0Ga1+o1K9zPL/+Lj85AeetgEwBkGpN2UojOslQeaPHSORa19phXGkkZTkQYKEOUE/Js0HuPO1KHmYyQNoxnlN9J8ySNkijRwONMOAYOeshHH6E8XnHR7V65ZHJG9Ab9wQjP5AqaO39aftonab6JiOfpavPwB97FOD/IopO+tLQ/lFDSUnECEIXCAhGJJvBExz5niyGMMUxIazrZ0pV4HpCXGK0ybVjCQHrt6bFU1ETXnOptNfdGp4hFtKa67UTtEQWBpzrcM1Z3e/L5O9xamyzhNSfiDt5mos8k6D/P/tFkVU/TK+71za1avdxWRr3PR23Gt488JP174pSRPorokxGvOaL8iLqAMOw8a+kepP6y+uq5p1/n+0GqEs8EhnjOSZoaBsbhlo5P6jFGeJ6tPS1KBb7AQZOIWFgDWfzt1C8snfgPPkoGWYzhgvRkVrPDY3/BWTflR6yiIyTiy0Ttp2obsrLrxrNS1dwu22nc9DXbh1fJEQ4Z7juGy6/Hf+R6H3Weq50Xvb3e5Av1KUlNo/QDqepEoxHZ3tZKNXhDvI3lZ9iKcKStQ0M/ft7Sdl7x0ZMHWVR6PNWzdCQcSdx/aPyk4e6Zl//iP19zxb2+XQz1RM1hAEU/JbITQmeDX+BVdIifmg5INBHPBP1ibH3Bxt4zbZKPERZjK+lQn1q6ELU2kX3xxDh/WPeTLUqwl+8T5xhp+vbLtgozpRKIaIY3MVYhhz/89CU3Py/lM7TFAj6kjiIviTq89fr/+Kg7fidqD3mcacNS5ueusfEpYJLud+4NsgiiFMKgIf/2UTvwwo1X/9NvjzkxK/v5E+PVTdc8Yob0Jl7fQz97891/eb4Iq6r6g+wf8gqjJvccYytjJdFHEDKY6Hj4Y09zEOE4JdqNsfSU4y83WXarN9zCixi6NpjR9K4B/b3+S6mU8/veaLIy5oz3Dcb9Q39Atr70xgOWuXKo+90Npovm6aA8qw/86zrLuJhuPPaEd45yOMYl8Mi0YamoPLajJh138aXla1EtZqWl3+nuh0XRiUoYgUVmlCFfnfQEXuSt46lmQA2CIlEXEYx4z0mpCbTYBsVpMyaEr0V6X2WTbgwxTLjxKB64/1FewaNeBvVFUN7oH4QhiQkFCh/EpH/ajFgIMd+JsmLAxuhD/1hBjpBSFIFAeOh3dg1MThh8EdoQ51hoQhjDFEKbSVDMGl/RGwOmmDLK9kBM0DA+kaKHsosgHmuFdSnoXVxCxYkpOnyKXXtx29Jx2xHAs403FMJbw+SYUPQpVoB9lnnxvhz3odX7GJUX+ePcPJs04xUMxIQn8H28YWnegul+csWkCep5yKn5RUTZhqedqCYI/oZP4LnGlmaBokeNGgZ8FD94mpQklOW29p2VGlE4Y14s30SBf/A+y9WGMHraD/1DERlrUVFsQ2EnUgkivD4oQgUa05eUIoDShdxlEgthBMdzHAiPIjUMkDHfmIebCQzUeu+Ofj/uH7I6ELKM+nGhfkzYHn1vYPyD5xLC6EhdDVKSMNjDIxiWoGOPPN/XKcLAGMYAVqPE2MpxyOQXzVgPH7Ii4mRLJaF2wwI7fyCeCZRkZHVhRIg8Yf0Qz+Bomxi+N+xZ+5brl96mP0REQSjHLM+9cMl2gycTMqKlPhs9yO9DmH0PqyfmcbTxK1qs1++gf7uNALWKiJRjYsvEg/Hw1huesDow4/wYjOMFYxP3HVkGYTwPRFQnhnjSLYlIidJq835jvAw16PDo79f+kPxdmLBg+CfakygpaskwUWdc51lhbPzTfZd4OckqX8jXgyy9k9QMIo0CIS/jiX1JBWIiBy238R2ngHcA2LW+YrWZmBjCb8j/kArN8ylKLwI850QrvmST5EDUu8rXzcx4A7+1MJ1ruckxxj34gvt8uI23yCfKCoTaQ7SB8R0+LIwYA0l1DPSD6bXh+7fTvvSyj9+ox+UXsLFJdRg3mah/ZTpDaB8jEsYe+IdngVT4zVa7EaM8hGqA7MQgWhhhECDSOFwzcv6hx3/leZxrJ92YlHj24TkgipmaO1FatnyhGSn+7SNN6At9PKnPZX6Xmjbhx+gqSi0C1C/EIUgEHIYdjNLUGsTBzLjFHIooeOQaNGP2ZC9f+UytI4xH1AyLJ2TrBG/s5B7HdEtqOMbmB7H5CnMknPIQ5Tc4P+N5fTNaIQ/f++hZX7IEHkaOUS8POUpJBJ45i7H2Mt43EPeP+c9QM16yX8w4tTp/fkWdTngZneRzq0VG1D3EnCtE+cc1V6q+lhnDUqlCrRR1Jszz8+wFpahn2dMVPC0U+A1E2HpMUIUQ8fBLet/ftsK1F519s59ME1LZoll7/0Jw+UHQityNGPOWX21tVz1hQoHwJrVk7+Yd/IQJoRalRMpl9HfCRplYBcLQdLktmYwCikKN5ywQ9ZeiSjJGpQss1Y5opyBIKRKJ54Ew5KIQhfk4H0RB05jxKjaQFKUd7Vs4AoT0fmxFM8867Rp/H5lMELbOi4n08hWLrEj2UPfZqEF+YlF4Szv+guEAngmE8lctLzqKop14MkMNEjzpYSKfY0oeaRsop3heu1tUCYXyibQLaR2hzcLeKdCNNzcQqUyBUAxW5qVsBoMtv9lT7xXysJ/e04PAnPnfm0K23ejC5Djce854hMmv7l1i3segLLKd6LpgHOJ7soThikKeoS0Uyyv63Z5/eI0a2yfIGDDh0WYRQxcKcDCcM0aMME8pr90h6jSEiRLh/kQDBiWZdnkmg2EJxZcogoKGpVyLUp3Jrp7g95CGjek9tJ33s95SgAAGJSbGGD5b+eiPHB/ZjGEabzkGRVY8/Xz0Wz6KDINhsoRhNCxCwDGkQ+LcCURdnEvO+13eGBxL7wi/UaeEsZZIaxYRaWspdMjvemZUiq8fEo6Jf8fIH4ixNqzW5Y1OeZM7eD8qRzUZD4il7x38ce4E8iUBTD4xVkEYoH9y0R3hZ1erVr38z0RxFIeYYEflMc7O3hZND5G6HIj9MCgRrRcIw9LS5fPCV28sIHJvd4iCzQ0jq4VhLIvqFTPNIDHbdIWQ5k69vXhaYlGtW83IAWGYiI77RCKKUo8AxsPhI9+0lMqzvF7FvAJ9jxf3AAMhkWcshIGzKVlCBuH0jI6XzEMC8YwcZZGchx18it8UnJd84TfqwOJMIvqYqEuyTnDso1/sam5EGxgpSduE4MOgG/CdxTZwPkDRlcj9HCn2yPrfSus/PQml9c4k2S+bq/s0ODPqikoIgZhlevvEl4l0SRCpb3gIWfmK6IyQmoSQwyPU24pnspoRK3JEJ2TxfeW4c63gIrnxKKZcH6GXeNmJxNrLVoJj+hyUxvjjw3cUVAxcgegHxqUQJcWgEKtdY3Z9+82ksd8V4dzPDGQI6+AlZdAg1bAoA0c4bxfLv6a/EEZAjCCi1CPAilwYW47ueZb32GBcgpg4EO1GFBMTblYyCp7GZHoRooXCvr5Ydp6hkPuKUhoMh/AWE2yIZ4Gw4VYWoUKhXKI7UHR5PlEQmWCjDMQ85tuf33Ae34YpkYS/B4oqokwQY8++KZkl9MyHfmXjO2mx4V5z/dFJDN9ZrS2q4AVZgwzYFrmn7JsMwWNR4zfHYGgKFJVnMedCQQOjX1kzohRioOIFHxWXgiz1xxsLx8vk6HdOHSaS4XzwMzWfAnENgafDNr2nHgGidp568S4bY8/2qTnIKQh+YAJDug6RcLNsBcoQtZFML3C6bLJIjkDc76hxENkZHYNjfBrbu7pN2JDVl/f7o0WpnOYdVLGxf6WPgMJzz9gco0TyMtdtjBjeo7zJZ3gLos3d4fnY+fW/KAjwnEfTe7nPwUBOO3yOyjJ0JK8n2XFFMWxG+xQvjxmno9uCPCYKCn5AXwyE3I43OHJs4KGwX9HejWftegLF6+nwaHR8N1DCrvnvP5qRI/Au+2/J4+n8HfQhLQiwQulCc4AQrU46WHA2wxOUWTjthGY+8pxVA5O9J9QvYmW4KKEzBIIfcaaH0hlETW3ZEDMEwTvUbTzUIonOO+OGWOkT4xeemdlzv7daTevNKL+fn4MV4KnQuL2zb3R8hp8CxfST2Peo/hl+L+3vMiyV9ju0k/6FNLi4Z2MnR+indCCQSHAgEnYclnZ99viJy66P2L4Hud3TzWPNwPf64FiOMQVCsaiTEoQQZpJN9EYiw1KYhHWwFbyoC4JRCWFKlAnLq6/fsNpdat7OWJpfzMq+/ezbP4VroBB41Ciwas1Sd/+j13qjQgXrCxZ/xnlqK+GlxVNOIT7qgpCCFwYPct1ftZpQhPEXlRgUqFkRCO8G4a2i1CPAJIWJEHXCqAFCtBpeeFKQSI+DvygGzOt7q39TgBIoceH3EOIcvuMlZFDGc8UAz/KsGFWhWha1Uss8oIvMcIRhCa8QUQDtWnfxxieUWWoswUvse/1VD+QZlkLrce/GoIme77i99LUEEEDeRb18rCLJvWKSxDu1GL4gLcc+I/vwRM9f+IPJsbXFkiVMKqITceTbnfdebM3bpMjO2dgm3hhMYylG6/2+0Wig5hZBGmQaCisRoX2OvsD3B+/5YJOxUfITv508F+xLKl+YbPGMocwS6RIoFMLl+zrjfdIC4ik6wRKvx6OTnu9EPVALhsgk6hiBO8uj4wTBeMO9J7qCmiBFMSzxTETvJ5MsoipDiuj308f6lDTq1FEzrpEZ+jdYCgmLZfCCh4467Ez/vPBsUaPpvY+e8VGb1HjablhKjEuhRsnYHCnxQdqaEQRCsXdORsHqEJnI98UmRx547JeeDxmniRiHb5h4Iy+LQzgjt8vjbT6tDIOqbfR6Hnok6Ws4B5Ysm1vAAEoaXqMGwYjJqsDt3DVX/t2nBqHDDcsb76P9CvprdFv0Mw6F6KIwrIwZpRZNOxSIMI2mn4b9os9WbJsYO2CTznfkFdG4ZF4w5rU1h+Ah3Y7zKWLcd4zlpJXjwKTcRpTinSnhN2RVNHKS7ThGA1GqAWcpKfMQaXDIx/lWmgE9AP4+/ph++UYlvt/9wBX+2cIpjgGsqovVHQ1tRt+jhqTo9vLwucwYloZ8eZ+j4F666IbHmqar6bS1e/vVA11D19P9c9A5btK0EWk7T2lpeMBR3VyXvVnBpfwQFutcq7kQKNQwKqp3BkF2w8/+4a32KJOvDHrQF8n+3HKQu5r381c/f8ifgggijEyQ97zkjYtEBjGYE0bPMu8UF4VQLhGss81gEEI9/YTHfgsGpMKugaLm86xAeVAu6tRq6JUUFGVC7AnJZ8UwFBwKR5JXjBGM8FOuH2KyiIHgaFN2wxCOYWHC5IL1UdiXEFRynCnWy2pIrSyU+VgrUEkRPwhjBLWmMH5kmh62Z3TcqBUZO22mn5WT+vR3fa2wJwMvhqA3bVL/7tCn/CQXw96px//E19qAd/BEwjPbTMEMhLc8/Ba2hff4YpjU8YAHqJmAUoFCSAg7/Nj/wv9zrHBE+6ttVcS77rPaSlZAOUQ0oZRMn/WNpVOudgdbmlLdOg3Dacr8e3nnsfgbhEElGinGd+45dWXgJQw9TCRQRi+78A9WlPZcb4ShbhFF1/0kJ77RnXxHESUiBH5EjmK0Jopj5JeDvQGAFUBJvURmsrw65yD9Lci/5qZoUjyWGjqNLeqTQtmkJvE7K8NUsPSQkGZBN4gcjXlM8dRvHyOiXaRIc6xOTm0v81hla/J3o3xx0/ZWePuU467I393zvj071Ut5TZtp80e6GzOoj3XpUc8NuKBrPk7p/gCPXHnxnX4iRBQbtQ/veegqvyoR9TRIrwwFkkO0UTAe0reYk8gWojDD0LY4vqBmHKvNBmLSTr0lVviDGHep6UWhegz8V/X/s5eh1PJ45MmbXQ1b5SqMvUzEeVZmzfnWR5ruyqgUzlkW3plPPPXYtRnrav+qrV3/w1tn7HyJThQdRxkfMRphKGE8ZmJex9LhKDdAPU0KWbPwDNFKTK4pQVBUQt8itZZoPMZpJtqfjXrTT8qvuvRuSzE6yUeXYFx9+uW7HTWYYkb6WMFjdFoWZ4BfLzr3Fh+Fb1YpL9/R45DFyE4I+3tYCSzop/H9JR2fWjusDMo+lHig3MKLrw/wbbLCF47XQJ98/lr4WKrfMz13HXZz74ziweJDLC5ALUyi7p55+a9u8NAnfbH2X1z+N18TkA6h/7HKacz4l8cXViqBcTTof9GOwztRxxS/UWPwVCu8TVgAKZq8SJdD1l7V/25veMTZzkIhb9kiGaGWLsdSQxHdlGeJzBBWDCwvVFQeKzOGpXTeoGnzy55RZv92PV1He2FQygajUjrvf0m2jUK3IZKKwOTniB6nuzFfvecespShZOmbySP8oFytWkyYXXzOrT71DQWCUFEICzmpZOSSQ35gzjPXUI/p/rve8wWUJ38/2g/+rKCEkCQ0/sRjL/FeTwRtIH5jgN7ZNbxvK4egnKLEItzvue0tX3S0UcNm3pBFWzk5673nFuUZ40RQbPkNwxO5+VEiIgBPAxOlKCHkWeo7EWFEG2eFvyn2F0KZE+2nbcVD4Ovxw/wqQ/AErwvPvMmMgWd5nsRbHtLiKDBPYVoo5t1GAcjxCt3Tj0w0w9/7bsiHT/vf8/9ttz/5TTNmT/I1F0JhZIyJj977mTcc4lUKIfQYEFeZoQGvaJjcM2H7w03P+Eg8aihs93Lm+AiowpTS/L7oQ6lFAIXvdVvV7ZJzb/Uy5EhbeZLCyMiVUIATeUg9vEWRAtZFuSDkB0XpqY2DskkUx3l9b8gvfkxbGMJHfTnE8xzKJosSUNwTXqOOCbK5alWM+7GYVvZn1UMiCpBtgeDPO255wU+sfn/3OWFzgXeumaKzLHJADSgmb7dc97gvpF/Z+heeBbyprPpFlEzLUm5YKnCB5fALhk4WKmBRCu4PaW+P3vu5m2fRdERmhALwOFzG2kQ/UJh0Yzj946+f9ZsvufqA8LN/jxOVnqcmmm7Q+4jz/FhK2u99d77rVxxkzA9yGYcSqaU8GzwjTNKYqGNgYMK9156tfIpeOBmOqOCgCtv0XrYQIBItFM6G53BMEs2NQSnUv4Q/MTYVh4h4+sD0P1bLpJ2Tju3vl4Wn9iEGdQgjAEXo0QswfL3zwf/MGH6Zl5U8FzgaOZYXxDjO/hNsMQZkOrITQraee/r1duzlfmXPFRE56newfzw/lHPA0Ep9HvRRjPun2sp1tEuqHsR+Y8xwxX44ykQli8BQW3W1txVSx5nTzOQjUeY4p6mZFSIx0emRn4uWzPKdDTo+EcKU9EAXoBB7dMGYRFfFIh8sFuPT7Wz8xCHKYhbUVGKRDPRDDKa0w1jK6tnGMfbKMV2ju7vbVs5E/6WOZ9AlecdpHx8dlej85WVbhbJyIXgY0kVDvhyQrqbT3u7A98tu39MOTkpOEFXV+Jz33b9Ff9t+ssRb+X37Lwxk0EoTTBheQooFQggBGiKG/E5J/GMwZPlLJkxMNkhjw5jD5IT2GMAXLJzpC9yF0Pqvxn9oheFW+tYJF2XwRvH81gbfqbbKAu1AeJwYiPGek0oRrPwUq6Vmzs6uASPC4KH/8wX2mOBxDrxCCFr6TETSIPOGMfnHkEV0SaoIjDkn0S1cKytIseKJKPUIMCF50yb1S22whdd88W6bfHOvmYCwDaPmm0P+5Q2R9ICVWKLLqKPYVapYJV+JDL1MFDLM6jYolwzWKJUoxnjU4S8GflYGeeSJ3/jPeJGInKMPKAA8F9RbYpVCvKGBiPZgcl7gOQ0/5r9vf4bzN/Eh73kusE1fMooA93fUF4N9BFHwZjeydKJgVEJuIdeo14ZMSESJeM3vl3d/McqzrDXKJ/ILPke5xeCOvKHdIcOeyV8KnnoLrNLGKlhBnsZq38XS9Vh9iTRjwvw5npUTo+ka8DMRRhVsXCisb0QGsow3si3IWCI2OZY2Sftk1UIipWJUCA8nACT5PRMcrE0JEUDujDEjH95xPkMUSCbtDTkW46NYGkaoi4PzZq7xUJBNGHb8y+RlHmv6dsLveV/8G4XC3xj8qOcDJlzIY8ZZeJdnBv54w2Q3E3aKf39j3vgQ3UJ/iFRmskT0XSCeK3SCHc4XzzDx32kgblthfB3OpffdQSAO7EhT31k6OrKKMRBZxuQZWYZRCR7EyP3We49HIrwLthX9Fv0cToGh/DNLy/3KnE6k3nHj97JovWBUgqe/mTLCL+ke6i298Nq9BVaPhceRYxCy7XtbOZE+McajT/CKjesYl6zeoo3flFOI57GwAX2USNIp5jzl/BD6ccyolOtLMrDa2JPP3+l/27Gd2Obwv+CzF7bqPZUIIJfeNucJ/IjRG/5kxUqMP9xzeGGSRekyroe5Cc5HeBjCgIisw9FiB+yyawOsXAc6I0ZLnNw4rGPR8Tl+nobeiTwlGo9naPmKxf5c9IXV4JqYUYl5Dc6cQH2OvjCPBSNPSgHmiWwPB4X3yE9lRVaWqYildKTDEa1UFiOWzj3+Rs92ilYKT1963qdOH5/vvUHAhUKnDIgs7YswYRnWKE3+drT3FPIbBhOIkPQJEz/Lr+2B4IJQ9DB6ULDTT8Ix3tgEIUR1+J2S/Pe1rfrGAI2FvYEV645FF5FmsdILOpYBRpkNRFjwIAvn3Kf9QbasdH2fpobyinHquYH3mBFpsVcCMPggJJlMsbw2Qp3+4lElQgTLfWHXgDLwyYjXfeTIQeaBQkCjRDMY4FViIkVYM/1u0axD/rLXoY+J3lmlK0QchCXswTqeUDioi8J9+9RqRQRlOX4/fU8NAiy9Sq2G7l37mHe8kfFIbT/gwn88K4TB4zEMNNy+M2Fp3XJ/b9DEk//t1C99JB28PNeMQRA1FeKJaDVqQpx12rWuga1aBF+x+h8GBXiDSTR8CfEswc/+uciLaOIZw6ALv5OeBLGcLIoHdcGYiEMo3UQ9BYJXmWxBKC+BuL5wDMYFDGyi1CMwdsLH+fyALAoThnAmPIjPvBRLq2htCxiQ6oixMPDFSFuFjaWJA8Fb4b4ttQl21Kgz1njQ854pdtNsch5o6CcvernOylkYfVhBEznHsUR7fmrybjvlWvTSYP8bNXRIy6VPOBJWrVrmIzVHfTUkXwkl/eiF1/5uUSy9fcQI9U2oQUdKCh70IOeoURYmRpzrQ/PqwncH7NvDP3tEmyBTue6vJwxzoy0CNhDbWCEK/mX8QT4GYpz6yvZnxTJ+i60yF37Ve6oQ+MHG/2df+ZvrabIHLzzOGww+1BJBliAnMT6FujhMqjCmw3NE8WKQQq5WMgcShqPAw37ZbeOtKMFTyEOcQp07HuGPJ+oJ/iBChagonqvgUX/4iV/7uoREKVHHjhW6kKXDhr9sUalX+qapJUZqCmOxl9UWmcdELkRDsxPylQg/nFzRVE54n4kgvAZ9P2378+g36F9KEJhj94TUSgzZPMsYj+KJFDeef2QTESC1jQ83mV6HLKMEQuArjmN8JHop6F5EYwaisDK13WJOpO3nwaHz1Et/9sXgqdtENBT8gKwiwmTEmHc8n4R2MAwMsHG9j0WosEoc4zoryMHr8OpHtsplGHeRuegcPAukPdsF+ho5s2ZP8fWhRlvUKM5Prn11ZJKPHOXZ45pZ1AZ9FMcqEVY4pKh5FsaBrds2+20Bh+kzJ+ZHSZGGysqk4TccttIxw51M7ftrVpR7nhkRMb4j/0gzw/DjdS1Lj+OeRUtcDBz0kDcy1bdVUIla4n4uMEcm6Z+sxIoRFbmYqG4rfH3fI1e7ky2NHN5gfGfcZQ7EXA9HOSn30PBRb/j3/W3crW96KH3CGYBxco+qNVz7tl3875UqxRaNwdEU+IUU4yBzmaeMttqkNW3cxphJ2mYgdOpwDPWjiCwt7ZTTpEkTu4zt1LlHNVenfgU3fHDMk7L9l9Lx6drTB7p2TXumrDPUpShrhiXS4G6z+koYle545JyUYVHaGxrwvNVY6lHX3XbtqNLe1SL3DyUNIw3eFgbu6KShqI1hoSciiEEcCzcTdqzrhRGGI86N4IwVwI0pBghTJtEovSi21C6Kn8hF20zmGggtxmOFYkq/QqRWtJ3y9PmYk5u7Xva6sd/YzNZYKsFnBf7DqMnkhXofTPaZxAQPUvT+wmMsZ01tscXG90yki0p4lVAQMVLBp6R14NmKJ5ReDK4V83RPIAAADJhJREFUrK4JxetDBEn8fmXtezbyWDL3CL7gfuPhXGmpFoSvp9rjh4LawKI2USiZuO9KbiOXSQPGg89zkWh/nglkMkotEypfCyUBPxeGAcaueia3kee8Ej13hR1b0tvveLiHycmVJi+/zlhXfI2l57u6jwfPdR/ZK9OE3KpL+lG16mbEXu4nLcHzHt8XeLlB3b18IXZkXSJjQfwx8d8Zz4k4gjdoI9FkGBnOpB45zqQM/aEs8VH8NYfvrdrXdpdf39E99eAM/wrb0/3e/3qrsWSvJx+c7GZOLX0TQy9zTG4wOY7pZosS8sXu4IQ8piA3acBMnJFtO9MniSJiXCflGF2RBV4SUYgqoa0lS+cVqd9c954NW3jDAUaGRM9ConOWhm3wMfzcu82wjHZn2PTenofh5UwTvFDbUtJYeIWxEwdhYXMI7i1yjmglHISF7beza0BnbGhzI8vn8ON7MIbHH4MBnsLhOMwxwmP0LA9UXB4rUxFL3CgMQQ/8fHv6wu7cPCKgyppRievt2PYwf9lKg9udu1+6jqUILZZpiIGSlaywgidLeEtYPQ3CQxMmFckcz6R//bw1O+yKIsmAzisZil5DYfvjgcVSLyq/CHgPoZ8gJU43il45PIZywKu4xCAeX28rUVsoIiGCMNHv2la+EIAvgkxN15Xh9Yx67nd1HqI/1s1etdPdeCaYRBU2kdrpwfYjUS+8RGUDASIuiPhIhjBIzt0Qi+RMZv9E+ySjGyDDMTrxEpV/BLzMMYcMTpl0EfI4WT6nD0Rpki6/K6JdUuKKQ1x3iMAqzvE6JrMIYHDHgcNrV8S93d3xH50xPiMl0XkxOIUSI4l+z7ZtZc6wxA3CuETk0u4QRqV01m3anb7t6thX3rvPTf5hpIp27wqoMvo7eeUHHdjbinifkfQVEIIeDEtJH6QdhYAQEAJCQAgIASEgBISAEBACQkAI7CYCZaZ4d/Q6iTJi+bviRhuVZaNSwEG1lQIS5e+d8HZyh1m2PdlXolzh8oeMrkgICAEhIASEgBAQAkJACAgBISAEShsCZTJiKYBI5BL1lk48+Mak6i6VB4NSuPbdfWelBYqahZVjtm3b4muOED4YJfJUK1eq6tOzWFGJgshbtmx0pD2J0oMA4ZesXMFLJASEgBAQAkJACAgBISAEhIAQEAJCoDQjUKYNSwBL1NLDg0bkG5YwMgWaNn+k/8h7caObQlvl5b2CLc29V6M2rk3zTq61vRrUbWpRMevckhVz3bTZY92U6aPzi5yRktWyaUfXs8vp/r2iFb1dvHyOG//tR27itM9tpYXtqyWVF3x0HUJACAgBISAEhIAQEAJCQAgIASEgBIRA8giUecNSuNRgOMLIJCocga77HevOPfEm17rZAX6lpk1bfnTVq9VyVSrv4VdGuOW+492MeRN9Ay2b7OcuP/NPrv3e3dzKNYttWc91bu8m+zpWpXv2rT+5UePfLvxE+kUICAEhIASEgBAQAkJACAgBISAEhIAQKPcIlBvDUrm/Uym4wMYNWrqLTv29a9a4vRs75UP35aQPLDppvatdo7478YgrXOOGLV0lW5oRIgWuXcturlXT/d0Pc8a7D0Y+Y8vOLnZ1a+/pU+im2zaREBACQkAICAEhIASEgBAQAkJACAgBIZDdCMiwlEX3v2fXM1yj+s3d2vUr3dOD7nDzF//gr546Swftf7w3LEXhqFK5mkUyVbP9V7gvJw5xa9at8D9jdIorxRQ9TJ+FgBAQAkJACAgBISAEhIAQEAJCQAgIgSxBoEyuCpcl9ybll9mySUdfiHvC95/mG5UKOwlFvKmhhBFq39aHuBv7/8cd3q2vj1aKFfguWOS7sHa0XQgIASEgBISAEBACQkAICAEhIASEgBAovwjIsFR+7+0OV1azel2/CtzMvBpKO+wQt2H0hHfcJ1+84o/p2LaH+8X5A9zfbvrAddm3V9ye+ioEhIAQEAJCQAgIASEgBISAEBACQkAIZCMCMixl0V3flrvN5dofqW/xZNltOxDFup968zb3x4f6WqHud9zmLRtdc6vPdMnpf3Qd2x62w/7aIASEgBAQAkJACAgBISAEhIAQEAJCQAhkFwIyLGXR/d5ohqLcbbm+IHf0solkqlwpVrQ7uj18nj53grv/6avc7x44xS1bOd9RBHy/NoeGn/UuBISAEBACQkAICAEhIASEgBAQAkJACGQpAjIsZdGNn79kutuydZPr3OEo16LJvv7KK1eq4g478DQzFrXaAYk6tRq6+nX2yo9wWrJ8jltgbVSqWNlVrVJ9h/21QQgIASEgBISAEBACQkAICAEhIASEgBDILgS0KlwW3e8R4950R3c/19Wr3dhd1vdON3naCG8g6taxj6tds0EBJKpVreF6djndtW95kFu4ZIbbsHGtq7FHXdeuZVe3xlaJW7RsVoH99UUICAEhIASEgBAQAkJACAgBISAEhIAQyD4EZFjKons+e8G37oV3/uIu7Xu769T+CF8nidJKcxZ+541FtWvUz0ejauU9XJNGbV2Pzqf4iKXNFulUpVI1t2nzBjdi7CD39ZSh+fvqgxAQAkJACAgBISAEhIAQEAJCQAgIASGQnQjIsJRF9z3Xind/PvYNN3P+ZNegbhPXsG5Tt2rtUjd/8TR31bn3utqttxuW1m5Y6QYNe8SKdr/lmu7ZztWxiKblqxe5eYumukVLZ/njsgg6XaoQEAJCQAgIASEgBISAEBACQkAICAEhkAABGZYSgFKeN23ZutnNmj/JzV4wxVXIqeAwNjlbEm7zlk0FLnvr1i1u6cp5btmq+e67GV/YLhUcq8pt27a1wH76IgSEgBAQAkJACAgBISAEhIAQEAJCQAhkLwIyLGXpvcegtBWjklGFnIqFopCbm2v7YUySQalQkPSDEBACQkAICAEhIASEgBAQAkJACAiBLEVAq8Jl6Y2Pv+xtZjzaum2Ly90WMzbF/67vQkAICAEhIASEgBAQAkJACAgBISAEhIAQiEdAEUvxiGThd6KSvp481C2w1d9WWB0lkRAQAkJACAgBISAEhIAQEAJCQAgIASEgBJJBQIalZFAq5/uQFjf40/+U86vU5QkBISAEhIAQEAJCQAgIASEgBISAEBACqUZAqXCpRlTtCQEhIASEgBAQAkJACAgBISAEhIAQEAJCIEsQkGEpS260LlMICIHMI9C6fe3Mn1RnzCoExGNZdbvL7cW2kqwst/dWFxZDQLJanFAeEJCsLg93MX3XIMNS+rBVyylGYPzoFb7FXic3T3HLak4IpB4B+DQMwONGxXg39WdJ3KKelcS4lLetgcfGjVrpxGPl7e5m1/WESffT/5iR0QsPz80xEXmd0Q7oZBlDIOiO40evzNg5OVE4H/pA0Aky2gGdrFwhEB33M31hTz0Yk8/hWcr0+XW+zCCwOzyW06RJk9xoNzv3qObq1K/ghg9eH92sz0KgVCAw4PlurkuPuqWiL+qEEEgGAQbiMBgns3+q9tGzkiokS387N/Ybm3HDEqiIx0o/b5SlHmIgvbHf1xnvcv/rWzteovKPQEmNx+Kx8s9bmb7Ckhr3h03vnelL1flKCIHi8JgMSyV0s3Ta4iPQpUc9d+l1UgKLj6COzAQCIWqoJIxK4fr0rAQkyuc7PFaS/AWq4rHyyVuZvqqS5mXxcabveGbPp/E4s3jrbOlDQLIyfdiq5RgCu8NjMiyJi4SAEBACQkAICAEhIASEgBAQAkJACAgBISAEioXADjWWVi3bWqyGdJAQEAJCQAgIASEgBISAEBACQkAICAEhIASEQHYhsINhKVx+y/aVw0e9CwEhIASEgBAQAkJACAgBISAEhIAQEAJCQAgIgR0QqBS/ZdbUzW5vMyrxqtOgYvzP+i4EhIAQEAJCQAgIASEgBISAEBACQkAICAEhIAQ8AjsYltg6YfRGR8QSq8OJhIAQEAJCQAgIASEgBISAEBACQkAICAEhIASEQCIEdijenWgnbRMCQkAICAEhIASEgBAQAkJACAgBISAEhIAQEALxCCgkKR4RfRcCQkAICAEhIASEgBAQAkJACAgBISAEhIAQSAoBGZaSgkk7CQEhIASEgBAQAkJACAgBISAEhIAQEAJCQAjEIyDDUjwi+i4EhIAQEAJCQAgIASEgBISAEBACQkAICAEhkBQCMiwlBZN2EgJCQAgIASEgBISAEBACQkAICAEhIASEgBCIR0CGpXhE9F0ICAEhIASEgBAQAkJACAgBISAEhIAQEAJCICkEZFhKCibtJASEgBAQAkJACAgBISAEhIAQEAJCQAgIASEQj8D/A5DGg6pgY+RQAAAAAElFTkSuQmCC" - } - }, "cell_type": "markdown", "id": "6", "metadata": {}, "source": [ - "![main.png](attachment:707b125d-b9c2-4fbf-ba83-0aebaa224c46.png)" + "Figure 1. Collisionless QLBM algorithm circuit. The preparation step and the first two iterations of the time-evolution stage." ] }, { @@ -125,8 +134,8 @@ "id": "7", "metadata": {}, "source": [ - "#### Initial condition\n", - "We start with a uniform velocity distribution located at a single grid point left of the obstacle.\n", + "### Initial condition\n", + "The quantum state is initialized to be localized at a single grid point positioned to the left of the reflection obstacle. Velocities along the $y$-axis are initialized uniformly, whereas along the $x$-axis only non-negative velocities are sampled, uniformly distributed over their possible magnitudes. \n", "\n", "### Observables\n", "After running the quantum circuit, we measure the\n", @@ -144,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 1, "id": "9", "metadata": {}, "outputs": [], @@ -163,36 +172,67 @@ "id": "10", "metadata": {}, "source": [ - "### Schedulling function" + "### Defining model hyperparameters" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 2, "id": "11", "metadata": {}, + "outputs": [], + "source": [ + "# Grid length size\n", + "GRID_LENGTH = 8 # The total number of lattice points is GRID_LENGTH^2\n", + "\n", + "# Velocities\n", + "# The velocities are normalized with respect to the lattice spacing,\n", + "# meaning that unity velocity corresponds to a distance change of one lattice spacing per model unit time-step\n", + "# in the positive direction of the axis.\n", + "VELOCITIES = np.array(\n", + " [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0]\n", + ") # in units (lattice spacing)/(model unit time)\n", + "\n", + "# Number of time-steps\n", + "NUM_TIMES_STEPS = 9\n", + "\n", + "# Boundary points of the reflection object\n", + "X_LOW, X_HIGH = 2, 5\n", + "Y_LOW, Y_HIGH = 1, 5" + ] + }, + { + "cell_type": "markdown", + "id": "12", + "metadata": {}, + "source": [ + "### Scheduling function" + ] + }, + { + "cell_type": "markdown", + "id": "13", + "metadata": {}, "source": [ - "A classical time-series function implements a CFL counter, tracking the velocity magnitudes streamed at each time-step. The time steps duration are set such that at each step the distributions $f_i(\\mathbf{x})$ will at most transition to a neighboring lattice site. As a consequence, the durations generally vary between time-steps.\n", + "A classical time-series function implements a Courant–Friedrichs–Lewy (CFL) counter, tracking the velocity magnitudes streamed at each time-step. The time steps duration are set such that at each step the distributions $f_i(\\mathbf{x})$ will at most transition to a neighboring lattice site. As a consequence, the durations generally vary between time-steps. Note, that in the following example $\\mathbf{x}$ represents a two dimensional vector.\n", + "\n", "\n", - "To evaluate the streamed velocities we first need to compute the time interval after the $m$'th time-steps, $\\Delta t^m$. To this end, consider a distribution $f_i(\\mathbf{x})$ at a time-step $m$ at position $x_m$, advancing with a speed $u_k$ away from a lattice site at $x_0$. The fraction of the distance from the lattice site in the following time-step can be expressed as $$c^{m+1}_k = \\frac{x_m + |u_k| \\Delta t^m -x_0}{\\Delta x} = c^{m}_k + |u_k|\\frac{\\Delta t^m} {\\Delta x}~~,$$ where $\\Delta x$ is the lattice spacing.\n", + "To evaluate the streamed velocities we first need to compute the time interval after the $m$'th time-steps, $\\Delta t^m$. To this end, consider a distribution $f_i(\\mathbf{x})$ at a time-step $m$ at position $x_m$, advancing with a speed $u_i$ away from a lattice site at $x_0$. The fraction of the distance from the lattice site in the following time-step can be expressed as $$c^{m+1}_i = \\frac{x_m + |u_i| \\Delta t^m -x_0}{\\Delta x} = c^{m}_i + |u_i|\\frac{\\Delta t^m} {\\Delta x}~~,$$ where $\\Delta x$ is the lattice spacing.\n", "\n", "If particles may only travel to the nearest lattice site during a single time-step, to evaluate $\\Delta t^m$, we set $c^{m+1}_k = 1$, leading to\n", - "$ \\Delta t^{m} = (1-c^m_k)\\frac{\\Delta x}{|u_k|}$.\n", + "$ \\Delta t^{m} = (1-c^m_i)\\frac{\\Delta x}{|u_i|}$.\n", "\n", "Finally, for multiple possible velocities, the limiting time step is evaluated by minimizing over all velocity magnitudes\n", - "$$ \\Delta t^{m} = \\min_{k}(1-c^m_k)\\frac{\\Delta x}{|u_k|}~~.$$\n", + "$$ \\Delta t^{m} = \\min_{i}(1-c^m_i)\\frac{\\Delta x}{|u_i|}~~.$$\n", "\n", - "Utilizing $\\Delta t^{m}$ we can evaluate $c^{m}_k$ for all velocites and determine which distributions have reached a lattice site.\n" + "Utilizing $\\Delta t^{m}$ we can evaluate $c^{m}_i$ for all velocites and determine which distributions have reached a lattice site.\n" ] }, { "cell_type": "code", - "execution_count": 40, - "id": "12", - "metadata": { - "jupyter": { - "source_hidden": true - } - }, + "execution_count": 3, + "id": "14", + "metadata": {}, "outputs": [], "source": [ "def time_series(\n", @@ -223,7 +263,10 @@ "\n", " # Track the \"progress\" of each distribution towards the next grid point\n", " cfl_counter = np.zeros(M)\n", - " inverse_velocities = 1 / velocity_magnitudes\n", + " eps = 1e-12 # tolerance for \"vanishing\"\n", + " regulated_magnitudes = velocity_magnitudes.copy()\n", + " regulated_magnitudes[regulated_magnitudes == 0] = eps\n", + " inverse_velocities = 1 / regulated_magnitudes\n", " ones = np.ones(M)\n", "\n", " # Contains the velocities to be streamed at for each time step\n", @@ -268,41 +311,37 @@ }, { "cell_type": "markdown", - "id": "13", + "id": "15", "metadata": {}, "source": [ - "## Initialization" + "### Initialization" ] }, { "cell_type": "markdown", - "id": "14", + "id": "16", "metadata": {}, "source": [ - "We initialize the model parameters" + "Initializing the model parameters. " ] }, { "cell_type": "code", - "execution_count": 41, - "id": "15", + "execution_count": 4, + "id": "17", "metadata": {}, "outputs": [], "source": [ "def num_bits(n):\n", " \"\"\"Returns the number of bits required to represent n numbers\"\"\"\n", - " return int(np.ceil(np.log2(n)))\n", + " return (n - 1).bit_length() # int(np.ceil(np.log2(n)))\n", "\n", "\n", "# Grid parameters\n", - "n_g_i = 8\n", - "n_g_i_bits = num_bits(n_g_i)\n", - "\n", - "# Velocities\n", - "discrete_velocities = np.array([-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0])\n", + "n_g_i_bits = num_bits(GRID_LENGTH)\n", "\n", "# Velocity magnitudes\n", - "u = np.unique(np.abs(discrete_velocities))\n", + "u = np.unique(np.abs(VELOCITIES))\n", "n_u_i = u.shape[0]\n", "n_u_i_bits = num_bits(\n", " n_u_i\n", @@ -311,7 +350,7 @@ }, { "cell_type": "markdown", - "id": "16", + "id": "18", "metadata": {}, "source": [ "The quantum register is conveniently stored within a QStruct variable. The customized object will allow simple and direct access the different registers." @@ -319,8 +358,8 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "17", + "execution_count": 5, + "id": "19", "metadata": {}, "outputs": [], "source": [ @@ -328,39 +367,37 @@ " \"\"\"Wrapping class including all the quantum variables\"\"\"\n", "\n", " # Grid variables\n", - " g_x: QNum[n_g_i_bits, UNSIGNED, 0] # x-axis grid register\n", - " g_y: QNum[n_g_i_bits, UNSIGNED, 0] # y-axis grid register\n", + " g_x: QNum[n_g_i_bits] # x-axis grid register\n", + " g_y: QNum[n_g_i_bits] # y-axis grid register\n", "\n", " # Velocity directions\n", " v_dir_x: QBit\n", " v_dir_y: QBit\n", "\n", " # Velocity magnitudes\n", - " u_x: QNum[n_u_i_bits, UNSIGNED, 0] # velocity magnitude in the x direction\n", - " u_y: QNum[n_u_i_bits, UNSIGNED, 0] # velocity magnitude in the y direction" + " u_x: QNum[n_u_i_bits] # velocity magnitude in the x direction\n", + " u_y: QNum[n_u_i_bits] # velocity magnitude in the y direction" ] }, { "cell_type": "markdown", - "id": "18", + "id": "20", "metadata": {}, "source": [ - "### Initial state preparation, setting parameters\n", - "\n", - "The presented algorithm imposes an essential constraint on the initial condition: particles' initial velocity, on lattice sites adjacent to the boundary surfaces, should only be towards the surface.\n", + "#### Initial state preparation, setting parameters\n", "\n", "We initialize the particles at a lattice point on the left-hand side of the lattice with a uniform velocity distribution in the y-direction and a non-negative uniform distribution in the x-direction." ] }, { "cell_type": "code", - "execution_count": 43, - "id": "19", + "execution_count": 6, + "id": "21", "metadata": {}, "outputs": [], "source": [ "# Setting the initial spatial and velocity magnitude probabilities\n", - "g_dist_x, g_dist_y = [0] * n_g_i, [0] * n_g_i\n", + "g_dist_x, g_dist_y = [0] * GRID_LENGTH, [0] * GRID_LENGTH\n", "g_dist_x[1] = 1\n", "g_dist_y[2] = 1\n", "u_dist = list(np.ones(n_u_i) / n_u_i)" @@ -368,7 +405,7 @@ }, { "cell_type": "markdown", - "id": "20", + "id": "22", "metadata": {}, "source": [ "State preperation function for the `PhaseSpaceStruct`:" @@ -376,8 +413,8 @@ }, { "cell_type": "code", - "execution_count": 44, - "id": "21", + "execution_count": 7, + "id": "23", "metadata": {}, "outputs": [], "source": [ @@ -401,142 +438,62 @@ }, { "cell_type": "markdown", - "id": "22", + "id": "24", "metadata": {}, "source": [ - "### Initiating model parameters and CFL schedule\n", + "#### Initiating model parameters and CFL schedule\n", "\n", "The model is propagated for `max_iters` time-steps (each containing a streaming and reflection operation), and the reflecting object is placed between the corners of `limits`." ] }, { "cell_type": "code", - "execution_count": 45, - "id": "23", + "execution_count": 8, + "id": "25", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/f9/dqrhj23922x926lhkszh0c5h0000gn/T/ipykernel_42717/2314929453.py:29: RuntimeWarning: divide by zero encountered in divide\n", - " inverse_velocities = 1/velocity_magnitudes\n" - ] - } - ], + "outputs": [], "source": [ - "# An error will appear when the velocity magnitude can vanish. This does not effect the program.\n", - "tolerance = 1e-6\n", "# time-series schedule\n", - "schedule, simulation_time = time_series(discrete_velocities, max_iters=9)\n", + "schedule, simulation_time = time_series(VELOCITIES, max_iters=NUM_TIMES_STEPS)\n", "\n", "# set boundary points of the reflection object\n", - "x_low, x_high = 2, 5\n", - "y_low, y_high = 1, 5\n", - "limits = [x_low, x_high, y_low, y_high]" + "limits = [X_LOW, X_HIGH, Y_LOW, Y_HIGH]" ] }, { "cell_type": "markdown", - "id": "24", + "id": "26", "metadata": {}, "source": [ "#### Schematic representation of the considered grid" ] }, { - "cell_type": "code", - "execution_count": 46, - "id": "25", - "metadata": { - "jupyter": { - "source_hidden": true + "attachments": { + "75f3cde8-1982-46c7-bb6b-8f4bb80e4078.png": { + "image/png": "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" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "cell_type": "markdown", + "id": "27", + "metadata": {}, "source": [ - "import matplotlib.patches as patches\n", - "\n", - "\n", - "def plot_2d_grid_with_obstacle(\n", - " Lx=4, Ly=4, obs_x_start=x_low, obs_x_end=x_high, obs_y_start=y_low, obs_y_end=y_high\n", - "):\n", - " \"\"\"\n", - " Plot a 2D lattice with a rectangular obstacle.\n", - "\n", - " Parameters\n", - " ----------\n", - " Lx, Ly : int\n", - " Number of lattice sites in x and y directions.\n", - " obs_x_start, obs_x_end : int\n", - " Left and right faces (inclusive) of the obstacle region in x.\n", - " obs_y_start, obs_y_end : int\n", - " Bottom and top faces (inclusive) of the obstacle region in y.\n", - " \"\"\"\n", - " # Basic sanity\n", - " assert 0 <= obs_x_start <= obs_x_end < Lx, \"Obstacle x must be within [0, Lx-1].\"\n", - " assert 0 <= obs_y_start <= obs_y_end < Ly, \"Obstacle y must be within [0, Ly-1].\"\n", - "\n", - " # Generate grid coordinates\n", - " x_sites, y_sites = np.meshgrid(np.arange(Lx), np.arange(Ly))\n", - "\n", - " fig, ax = plt.subplots(figsize=(5, 5))\n", - "\n", - " # Draw lattice sites\n", - " ax.scatter(x_sites, y_sites, marker=\"x\", s=60, zorder=3, color=\"k\")\n", - "\n", - " # Draw obstacle as shaded rectangle\n", - " rect = patches.Rectangle(\n", - " (obs_x_start - 0.1, obs_y_start - 0.1),\n", - " obs_x_end - obs_x_start + 0.2,\n", - " obs_y_end - obs_y_start + 0.2,\n", - " linewidth=1,\n", - " edgecolor=\"r\",\n", - " facecolor=\"tab:red\",\n", - " alpha=0.35,\n", - " label=\"Obstacle\",\n", - " )\n", - " ax.add_patch(rect)\n", - "\n", - " # Cosmetics\n", - " ax.set_xlim(-0.5, Lx - 0.5)\n", - " ax.set_ylim(-0.5, Ly - 0.5)\n", - " ax.set_xticks(np.arange(Lx))\n", - " ax.set_yticks(np.arange(Ly))\n", - " ax.set_aspect(\"equal\")\n", - " ax.grid(True, which=\"both\", linestyle=\"--\", alpha=0.4)\n", - " ax.legend(loc=\"upper right\")\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n", - "\n", - "\n", - "# Example usage: 4x4 grid, obstacle at x=2, y=1..2\n", - "plot_2d_grid_with_obstacle(\n", - " Lx=8, Ly=8, obs_x_start=x_low, obs_x_end=x_high, obs_y_start=y_low, obs_y_end=y_high\n", - ")" + "![model_scheme.png](attachment:75f3cde8-1982-46c7-bb6b-8f4bb80e4078.png)" + ] + }, + { + "cell_type": "markdown", + "id": "28", + "metadata": {}, + "source": [ + "Figure 2. Schematic representation of the analyzed example. An eight-by-eight grid, with a reflection object located in the center. " ] }, { "cell_type": "code", - "execution_count": 47, - "id": "26", - "metadata": { - "jupyter": { - "source_hidden": true - } - }, + "execution_count": 9, + "id": "29", + "metadata": {}, "outputs": [ { "data": { @@ -569,25 +526,35 @@ }, { "cell_type": "markdown", - "id": "27", + "id": "30", "metadata": {}, "source": [ - "The schedule dictates which velocity magnitudes are propagated at each time step. The time duration of sub-steps is chosen so that distributions do not propagate beyond the neighboring cell per sub-step. This prevents overshoot and reproduces integer grid walks." + "Figure 3. Streaming schedule. Each yellow cell indicates that the associated velocity magnitude is propagated in that time step." ] }, { "cell_type": "markdown", - "id": "28", + "id": "31", + "metadata": {}, + "source": [ + "The schedule dictates which velocity magnitudes are propagated at each time step. The time duration of sub-steps is chosen so that distributions do not propagate beyond the neighboring cell per sub-step. This prevents overshoot and reproduces integer grid walks.\n", + "\n", + "For example, at time step 3, distributions with absolute velocities of 1,2,3 will stream. " + ] + }, + { + "cell_type": "markdown", + "id": "32", "metadata": {}, "source": [ - "## Streaming operator\n", - "The streaming operation receives the `schedule`, containing the streamed velocities at each time step. Conditioned on whether the velocity magnitude appears in `schedule[t]`, a sequential modular addition operation is performed on the associated grid variable $ \\ket{\\mathbf{x}}\\ket{\\mathbf{v}} \\mapsto \\ket{\\mathbf{x}+\\Delta \\mathbf{x}}$. Finally, the ancilla and velocity registers are restored to their initial state. The operation manifests a conditional translation of a specific set of positional states." + "### Streaming operator\n", + "The streaming operation receives the `schedule`, containing the streamed velocities at each time step. Conditioned on whether the velocity magnitude appears in `schedule[t]`, a sequential modular addition operation is performed on the associated grid variable $ |{\\mathbf{x}}\\rangle |{\\mathbf{v}}\\rangle \\mapsto |{\\mathbf{x}+\\Delta \\mathbf{x}}\\rangle|\\mathbf{v}\\rangle$. Finally, the ancilla and velocity registers are restored to their initial state. The operation manifests a conditional translation of a specific set of positional states." ] }, { "cell_type": "code", - "execution_count": 48, - "id": "29", + "execution_count": 10, + "id": "33", "metadata": {}, "outputs": [], "source": [ @@ -614,14 +581,6 @@ " )" ] }, - { - "cell_type": "markdown", - "id": "30", - "metadata": {}, - "source": [ - "Implementation of the streaming operator in Classiq" - ] - }, { "attachments": { "1efaa199-9bca-47b7-982c-366975a479aa.png": { @@ -629,7 +588,7 @@ } }, "cell_type": "markdown", - "id": "31", + "id": "34", "metadata": {}, "source": [ "![stream.png](attachment:1efaa199-9bca-47b7-982c-366975a479aa.png)" @@ -637,10 +596,18 @@ }, { "cell_type": "markdown", - "id": "32", + "id": "35", "metadata": {}, "source": [ - "## Specular Reflection\n", + "Figure 4. Implementation of the streaming operator in Classiq" + ] + }, + { + "cell_type": "markdown", + "id": "36", + "metadata": {}, + "source": [ + "### Specular Reflection\n", "The boundary reflection operation effectively reflects particles that enter the boundaries.\n", "The boundary surfaces are assumed to be orthogonal to the lattice sites, and located right between two lattice sites. Each boundary surface is characterized by the lattice site inside the boundary closest to its surface, `position`, and the direction normal to the surface, `direction`.\n", "\n", @@ -652,7 +619,7 @@ "\n", "(ii) For particles colliding with the flat surface, only the velocity component normal to the surface is reversed, while the tangential component remains unchanged. \n", "\n", - "Such a reflection scheme enables modeling the reflection process with a constant number of ancilla qubits.\n", + "Such a reflection scheme enables modeling the reflection process without any ancillas.\n", "This is achieved by ensuring that particles incident from different directions never scatter into the same outgoing direction.\n", "Allowing multiple distinct incoming states to map onto a single outgoing state would correspond to a non-invertible transformation, thereby violating the unitarity condition required by the quantum circuit computation model.\n", "\n", @@ -666,7 +633,7 @@ }, { "cell_type": "markdown", - "id": "33", + "id": "37", "metadata": {}, "source": [ "Schematic representation of the two kinds of reflections — \n", @@ -674,232 +641,30 @@ ] }, { - "cell_type": "code", - "execution_count": 49, - "id": "34", - "metadata": { - "jupyter": { - "source_hidden": true + "attachments": { + "28a38802-1e07-494a-a361-2b47b91c6ae9.png": { + "image/png": "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" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "cell_type": "markdown", + "id": "38", + "metadata": {}, "source": [ - "import math\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# === Create the figure and axis ===\n", - "fig, ax = plt.subplots()\n", - "\n", - "# === Draw the reflecting object (red square) ===\n", - "# The square is centered in the figure with semi-transparent red fill\n", - "square = plt.Rectangle(\n", - " (0.25, 0.25), 0.5, 0.5, linewidth=1, edgecolor=\"r\", facecolor=\"tab:red\", alpha=0.35\n", - ")\n", - "ax.add_patch(square)\n", - "\n", - "# === Add first arrow pair (top-left corner reflection) ===\n", - "# Solid arrow: incoming direction (up-right)\n", - "arrow_start = (0.3, 0.8)\n", - "arrow_dx, arrow_dy = (0.1, 0.1)\n", - "ax.arrow(\n", - " arrow_start[0],\n", - " arrow_start[1],\n", - " arrow_dx,\n", - " arrow_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"black\",\n", - " ec=\"black\",\n", - ")\n", - "\n", - "# Dashed arrow: reflected direction (down-left)\n", - "arrow2_start = (arrow_start[0] + arrow_dx, arrow_start[1] + arrow_dy + 0.05)\n", - "arrow2_dx, arrow2_dy = (-0.1, -0.1)\n", - "ax.arrow(\n", - " arrow2_start[0],\n", - " arrow2_start[1],\n", - " arrow2_dx,\n", - " arrow2_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - " linestyle=\"--\",\n", - ")\n", - "\n", - "# === Add second arrow pair (upper-left side) ===\n", - "# Solid arrow: incident from top-left toward the object\n", - "arrow3_end = (0.16, 0.84)\n", - "arrow3_start = (arrow3_end[0] - 0.1, arrow3_end[1] + 0.1)\n", - "arrow3_dx = arrow3_end[0] - arrow3_start[0]\n", - "arrow3_dy = arrow3_end[1] - arrow3_start[1]\n", - "ax.arrow(\n", - " arrow3_start[0],\n", - " arrow3_start[1],\n", - " arrow3_dx,\n", - " arrow3_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"black\",\n", - " ec=\"black\",\n", - ")\n", - "\n", - "# Dashed arrow: reflection opposite to incident direction\n", - "arrow4_start = (arrow3_start[0] + arrow3_dx + 0.01, arrow3_start[1] + arrow3_dy - 0.07)\n", - "arrow4_dx, arrow4_dy = (-0.1, 0.1)\n", - "ax.arrow(\n", - " arrow4_start[0],\n", - " arrow4_start[1],\n", - " arrow4_dx,\n", - " arrow4_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - " linestyle=\"--\",\n", - ")\n", - "\n", - "# === Define helper for rotation (used below) ===\n", - "angle_rad = math.radians(90)\n", - "\n", - "\n", - "def rotate(dx, dy):\n", - " \"\"\"Rotate a vector (dx, dy) 90 degrees counterclockwise.\"\"\"\n", - " new_dx = dx * math.cos(angle_rad) - dy * math.sin(angle_rad)\n", - " new_dy = dx * math.sin(angle_rad) + dy * math.cos(angle_rad)\n", - " return new_dx, new_dy\n", - "\n", - "\n", - "# === Add third arrow pair (lower-left side, rotated 90° CCW) ===\n", - "arrow5_end = (0.16, 0.64)\n", - "arrow5_start = (arrow5_end[0] - 0.1, arrow5_end[1] + 0.1)\n", - "arrow5_dx, arrow5_dy = rotate(\n", - " arrow5_end[0] - arrow5_start[0], arrow5_end[1] - arrow5_start[1]\n", - ")\n", - "\n", - "# Solid arrow: incident direction\n", - "ax.arrow(\n", - " arrow5_start[0] - 0.03,\n", - " arrow5_start[1] - 0.155,\n", - " arrow5_dx,\n", - " arrow5_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"black\",\n", - " ec=\"black\",\n", - ")\n", - "\n", - "# Dashed arrow: reflection (opposite)\n", - "arrow6_start = (arrow5_start[0] + arrow5_dx + 0.02, arrow5_start[1] + arrow5_dy - 0.06)\n", - "arrow6_dx, arrow6_dy = rotate(-0.1, 0.1)\n", - "ax.arrow(\n", - " arrow6_start[0],\n", - " arrow6_start[1] - 0.1,\n", - " arrow6_dx,\n", - " arrow6_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - " linestyle=\"--\",\n", - ")\n", - "\n", - "# === Add pair of arrows to bottom surface (center reflection) ===\n", - "# Solid arrow: incoming (upward)\n", - "arrow7_start = (0.35, 0.06)\n", - "arrow7_dx, arrow7_dy = (0.1, 0.1)\n", - "ax.arrow(\n", - " arrow7_start[0],\n", - " arrow7_start[1],\n", - " arrow7_dx,\n", - " arrow7_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - ")\n", - "\n", - "# Dashed arrow: reflected (downward)\n", - "arrow8_start = (0.52, 0.2)\n", - "arrow8_dx, arrow8_dy = (0.1, -0.1)\n", - "ax.arrow(\n", - " arrow8_start[0],\n", - " arrow8_start[1],\n", - " arrow8_dx,\n", - " arrow8_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - " linestyle=\"--\",\n", - ")\n", - "\n", - "# === Add final vertical pair (top reflection) ===\n", - "# Solid: downward arrow from top\n", - "arrow9_start = (0.6, 0.93)\n", - "arrow9_dx, arrow9_dy = (0, -0.1)\n", - "ax.arrow(\n", - " arrow9_start[0],\n", - " arrow9_start[1],\n", - " arrow9_dx,\n", - " arrow9_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - ")\n", - "\n", - "# Dashed: reflected upward\n", - "arrow10_start = (0.64, 0.78)\n", - "arrow10_dx, arrow10_dy = (0, 0.1)\n", - "ax.arrow(\n", - " arrow10_start[0],\n", - " arrow10_start[1],\n", - " arrow10_dx,\n", - " arrow10_dy,\n", - " head_width=0.03,\n", - " head_length=0.05,\n", - " fc=\"none\",\n", - " ec=\"black\",\n", - " linestyle=\"--\",\n", - ")\n", - "\n", - "# === Final plot settings ===\n", - "ax.set_xlim(0, 1)\n", - "ax.set_ylim(0, 1)\n", - "ax.set_aspect(\"equal\")\n", - "\n", - "# Remove all tick marks and labels\n", - "ax.set_xticks([])\n", - "ax.set_yticks([])\n", - "ax.set_xticklabels([])\n", - "ax.set_yticklabels([])\n", - "\n", - "fig.suptitle(\"Schematic of particle reflections at object surfaces\")\n", - "\n", - "# Optionally remove axis spines for a cleaner figure\n", - "for spine in ax.spines.values():\n", - " spine.set_visible(False)\n", - "\n", - "plt.show()" + "![reflection_scheme.png](attachment:28a38802-1e07-494a-a361-2b47b91c6ae9.png)" + ] + }, + { + "cell_type": "markdown", + "id": "39", + "metadata": {}, + "source": [ + "Figure 5. Schematic representation of the reflection types. Incoming and reflected particles are indicated by continuous and dashed arrows, respectively." ] }, { "cell_type": "code", - "execution_count": 50, - "id": "35", + "execution_count": 11, + "id": "40", "metadata": {}, "outputs": [], "source": [ @@ -936,11 +701,11 @@ " limits: list (of QArray[CInt]), defines the limits of the reflecting object\n", " \"\"\"\n", "\n", - " x_low, x_high, y_low, y_high = limits[0], limits[1], limits[2], limits[3]\n", + " X_LOW, X_HIGH, Y_LOW, Y_HIGH = limits[0], limits[1], limits[2], limits[3]\n", " # reverse the velocity\n", "\n", " # from the top and bottom of the object\n", - " top_bottom_arr = [y_low, y_high, x_low, x_high]\n", + " top_bottom_arr = [Y_LOW, Y_HIGH, X_LOW, X_HIGH]\n", " flip_velocity(\n", " change_pos=qs.g_y,\n", " fixed_pos=qs.g_x,\n", @@ -960,14 +725,6 @@ " )" ] }, - { - "cell_type": "markdown", - "id": "36", - "metadata": {}, - "source": [ - "Implementation of the reflection operator within the main quantum circuit:" - ] - }, { "attachments": { "517a2527-5749-4913-b4a0-3d1ab6dbc41a.png": { @@ -975,7 +732,7 @@ } }, "cell_type": "markdown", - "id": "37", + "id": "41", "metadata": {}, "source": [ "![stream.png](attachment:517a2527-5749-4913-b4a0-3d1ab6dbc41a.png)" @@ -983,16 +740,24 @@ }, { "cell_type": "markdown", - "id": "38", + "id": "42", + "metadata": {}, + "source": [ + "Figure 6. Implementation of the reflection operator within the main quantum circuit." + ] + }, + { + "cell_type": "markdown", + "id": "43", "metadata": {}, "source": [ - "## Build the quantum program" + "### Building the quantum program" ] }, { "cell_type": "code", - "execution_count": 51, - "id": "39", + "execution_count": 12, + "id": "44", "metadata": {}, "outputs": [], "source": [ @@ -1024,15 +789,15 @@ }, { "cell_type": "markdown", - "id": "40", + "id": "45", "metadata": {}, "source": [ - "## Execution and results" + "### Execution and results" ] }, { "cell_type": "markdown", - "id": "41", + "id": "46", "metadata": {}, "source": [ "We run the quantum program on a statevector simulator to retrieve the full solution." @@ -1040,8 +805,8 @@ }, { "cell_type": "code", - "execution_count": 52, - "id": "42", + "execution_count": 13, + "id": "47", "metadata": {}, "outputs": [], "source": [ @@ -1052,7 +817,7 @@ }, { "cell_type": "markdown", - "id": "43", + "id": "48", "metadata": {}, "source": [ "Taking a look at a small part of the results" @@ -1060,8 +825,8 @@ }, { "cell_type": "code", - "execution_count": 53, - "id": "44", + "execution_count": 14, + "id": "49", "metadata": {}, "outputs": [ { @@ -1099,63 +864,63 @@ " \n", " \n", " 0\n", - " 6\n", - " 4\n", - " 1\n", " 1\n", - " 3\n", + " 6\n", + " 0\n", + " 0\n", " 1\n", - " 88\n", - " 0.042969\n", - " 011111100110\n", + " 2\n", + " 86\n", + " 0.041992\n", + " 100100110001\n", " \n", " \n", " 1\n", - " 1\n", + " 7\n", " 2\n", " 0\n", " 1\n", + " 2\n", " 1\n", - " 0\n", " 79\n", " 0.038574\n", - " 000110010001\n", + " 011010010111\n", " \n", " \n", " 2\n", " 1\n", - " 4\n", - " 0\n", + " 2\n", " 0\n", " 1\n", - " 2\n", + " 1\n", + " 1\n", " 78\n", " 0.038086\n", - " 100100100001\n", + " 010110010001\n", " \n", " \n", " 3\n", - " 7\n", - " 4\n", - " 0\n", " 1\n", " 2\n", + " 0\n", + " 1\n", " 1\n", - " 77\n", - " 0.037598\n", - " 011010100111\n", + " 0\n", + " 74\n", + " 0.036133\n", + " 000110010001\n", " \n", " \n", " 4\n", - " 6\n", - " 4\n", - " 1\n", " 1\n", - " 3\n", " 2\n", - " 76\n", - " 0.037109\n", - " 101111100110\n", + " 1\n", + " 1\n", + " 0\n", + " 0\n", + " 73\n", + " 0.035645\n", + " 000011010001\n", " \n", " \n", "\n", @@ -1163,21 +928,21 @@ ], "text/plain": [ " qs.g_x qs.g_y qs.v_dir_x qs.v_dir_y qs.u_x qs.u_y count probability \\\n", - "0 6 4 1 1 3 1 88 0.042969 \n", - "1 1 2 0 1 1 0 79 0.038574 \n", - "2 1 4 0 0 1 2 78 0.038086 \n", - "3 7 4 0 1 2 1 77 0.037598 \n", - "4 6 4 1 1 3 2 76 0.037109 \n", + "0 1 6 0 0 1 2 86 0.041992 \n", + "1 7 2 0 1 2 1 79 0.038574 \n", + "2 1 2 0 1 1 1 78 0.038086 \n", + "3 1 2 0 1 1 0 74 0.036133 \n", + "4 1 2 1 1 0 0 73 0.035645 \n", "\n", " bitstring \n", - "0 011111100110 \n", - "1 000110010001 \n", - "2 100100100001 \n", - "3 011010100111 \n", - "4 101111100110 " + "0 100100110001 \n", + "1 011010010111 \n", + "2 010110010001 \n", + "3 000110010001 \n", + "4 000011010001 " ] }, - "execution_count": 53, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -1188,7 +953,7 @@ }, { "cell_type": "markdown", - "id": "45", + "id": "50", "metadata": {}, "source": [ "Evaluating the spatial and velocity magnitude distribution, $p(x)$ and $p(u)$." @@ -1196,8 +961,8 @@ }, { "cell_type": "code", - "execution_count": 54, - "id": "46", + "execution_count": 15, + "id": "51", "metadata": {}, "outputs": [], "source": [ @@ -1224,27 +989,31 @@ "\n", "\n", "# 2D distribution\n", - "p_xy = get_p(results.dataframe, jx=0, jy=1, n=n_g_i)\n", + "p_xy = get_p(results.dataframe, jx=0, jy=1, n=GRID_LENGTH)\n", "p_u_xy = get_p(results.dataframe, jx=4, jy=5, n=n_u_i)" ] }, { "cell_type": "markdown", - "id": "47", + "id": "52", "metadata": {}, "source": [ - "### Plots" + "Propagating the dynamics for nine time time-steps, we obtain the following spatial and velocity magnitude distributions:" ] }, { "cell_type": "code", - "execution_count": 55, - "id": "48", - "metadata": {}, + "execution_count": 16, + "id": "53", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAegAAAGiCAYAAAAsk1UGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUGJJREFUeJzt3Qd4VNXWBuCVQkKvoQiEjnRCryogSEBUsACCCiIXFQkgUUSQn2AFC4hKBEEpXuWCIAgq0ouF3qRJkxZpAUU6AZLzP9/yztyZZAamJXMm8733OQ+ZM2fOnJl4s87ee+29QgzDMISIiIhMJdTfF0BEREQZMUATERGZEAM0ERGRCTFAExERmRADNBERkQkxQBMREZkQAzQREZEJMUATERGZEAM0ERGRCTFAU0Bq2bKlbp4ICQmRkSNH+vyaVq1apefGv5kN14/3soXHcXFxkhWmTZum73f48OEseT+iYMQATbe0Y8cOeeSRR6Rs2bKSM2dOKVWqlNxzzz3y0UcfZer77t69WwORP4IA3hMByLLlyJFDoqKipFmzZjJs2DA5evSoz97rrbfekm+++UbMyMzXRpTdhXAtbrqZNWvWSKtWraRMmTLSs2dPKVGihCQlJcm6devk999/lwMHDmTae8+ZM0c6d+4sK1euzNBavnbtmv4bERHh9nkRcBMSEm7aikaALl++vHTr1k3uvfdeSUtLk7Nnz8rGjRtl7ty5eo7PPvtMHn30UetrcAyuC9cUGur6vW/evHn1BgitUlfduHFDN9ww2X6ufv36yfjx410+j6fXlpqaKtevX5fIyMgMLXki8o1wH52Hsqk333xTChQooIGpYMGCds8lJyf77bo8CcyeqFevnjz++ON2+44cOSJt27bVG5Zq1apJTEyM7kdQtg2YmeHSpUuSJ08eCQ8P181fwsLCdCOizMMubroptJJr1KiRIThDsWLFHI6Bfvnll1KlShUNVvXr15cff/wxQ4B77rnn9JhcuXJJkSJFtKVs25WNFhv2AVrwlq5my/hu+jFotFxHjBih74cbCgSxO++8U1vfvoauflwf3vOdd9656Rj0/v375eGHH9aeB3wfpUuX1lb3uXPnrN8Zgu706dOtn/HJJ5+0G2dGV3/37t2lUKFCcscdd9g958itvn+cv1y5chlel/6cN7s2Z2PQH3/8sf73gpZ1yZIltUX/999/2x2D31vNmjX1c+F3mzt3bh02sf0uiYgtaHIhGK1du1Z27typf1RvZfXq1TJr1iwZMGCA/pHGH+x27drJhg0brK9Haxxd5whUCFj4Iz9hwgT9w40/2viDfdddd+k5PvzwQx3zRUsVLP+md/78efn000+1S7pPnz5y4cIF7YKOjY3V965Tp45Pv5emTZtKxYoVZenSpU6PQQDH+6ekpEj//v01SB87dky+++47DVq4kfj3v/8t//rXv6RRo0by9NNP6+twXlu4UalcubKOB99qRMqV799Vrlxb+gD/6quvSps2baRv376yd+9e/b3i9/3LL7/oOL4FhgtwXQ899JB06dJFhzOGDBkitWrVkvbt27t1nUTZFsagiZxZsmSJERYWplvTpk2Nl156yVi8eLFx7dq1DMfiPydsmzZtsu47cuSIkTNnTuPBBx+07rt8+XKG165du1Zf+/nnn1v3zZ49W/etXLkyw/EtWrTQzeLGjRtGSkqK3TFnz541ihcvbjz11FMZrjMhIeGmn/vQoUN63Lvvvuv0mI4dO+ox586d08e4Ttvr3bp1qz7G57iZPHnyGD179sywH9eI13fr1s3pc558/3ivsmXLunROZ9c2depUPRbfEyQnJxsRERFG27ZtjdTUVOtx48eP1+OmTJli3YffW/rfNX53JUqUMB5++GEn3xJR8GEXN90UsrXRgn7ggQfk119/1W5ItArRJblgwQKHLUt0q1oguaxjx46yePFiTSwCdGtbINHozz//lEqVKmk3+pYtWzy6ToyHWsalkaz1119/aRJVgwYNPD6nKwlUgNa6I2ghAz775cuXPX6fZ5991uVjXfn+M8OyZcu0x+D555+3S5BDb0b+/Pnl+++/z/Dd2Y7t43eHlvrBgwcz7RqJAg0DNN1Sw4YNNXMZ3ZLoKh06dKgGJWT3okvaFrpi07v99ts1QJ0+fVofX7lyRceLo6OjtRsW05eKFi2q3b6WsVlPYKy0du3aOvaKcW2cE4HBm3PezMWLF/XffPnyOXweWeDx8fHa9Y7PiBubxMREt68H53GVK99/ZkBeAWDs2xYCb4UKFazPW2BoI/0YOsbY8d8YEf2DAZpchj+2CNYYC8XYIlq/s2fPdvs8GI9FdjjGHr/66itZsmSJjuUiqKL164kvvvhCE5gwRoqx50WLFuk57777bo/PeSsYl0eiHFqIzowZM0a2b9+u4+i4McHYMJKo/vjjD5ffx7bHwRecJZdlZgs7PWcZ4Jz1SfQ/TBIjj6DrGE6cOGG3H1nL6e3bt08Tv9CiBSQEYYoSgpfF1atXM2T7ujO/FudES80yR9kC850zA7r9keGefgqWI0h8wjZ8+HBNjmvevLlMnDhR3njjDX3el/OIXfn+0VJN/11D+lauO9eGZEJAYhh+Dxbo9j506JAmjhGRe9iCppvCNCVHrZqFCxc67NJE4LId88WiJvPnz9d5w5ZWE/5Nf06sSpa+BYepUuAomKRnObftedevX6/X42sIZGito0dh8ODBTo9DZjnGwW0hUGOMFpndtp/Tlc/oCle+f/QyoJsdLXsL3GjNmzcvw/lcvTYEYHwfyLq3/R2gNwPv1aFDBx98OqLgwhY03bI7GuOXDz74oFStWlVbRGgFYioP5tL26tXL7nhM5cFYq+00H8D0G4v77rtPp/Agiap69eoaVJBkhC5uW5gahaDy9ttv6x95nA9d1unnX1vOidYzrhPBAK02tFJxfstYsScQ7NB9jm5yBCpMGfr666+1ZYnPgDFvZ1asWKHzwjFNCuPACNZ4DT4T5kZbIKkLn3/s2LE6dxhjzo0bN/boel35/jG9DVOa8F3hOPx+MWSBa0yfUOfqtaF1jtwEvA+mTyGpEK1pvD+GRVzpaSCidPydRk7m9sMPP+g0papVqxp58+bVqTSVKlUy+vfvb5w6dcruWPzn1K9fP+OLL74wKleubERGRhp169bNME0K05969eplREVF6TljY2ONPXv26NSf9FN6Jk+ebFSoUEGnedlOYUo/zSotLc1466239ByW9/3uu+8cTilyZ5qVZQsPDzcKFy5sNG7c2Bg6dKhOX0ov/TSrgwcP6ndXsWJFneqE17dq1cpYtmyZ3evw2e+66y4jV65c+nrLd2CZ9nT69GmXp1m58v1bps/VrFlTf59VqlTR1zg6p7NrSz/NynZaFf5byZEjh05x69u3r/6+beH3VqNGjQzX5Gz6F1Gw4lrc5DOZsRY0EVGw4hg0ERGRCTFAExERmRADNBERkQkxi5t8hukMRES+wxY0ERGRCTFAExERmVBAd3Fj8Yjjx49rsQJfLpdIRJRdh6FQ6AaLzthWHSNzCugAjeCMikhEROQ6LAGLimJkbgEdoC1l/u6QeyVccvj7ciiLpN4VI4Eg7NJ1CQib7UuGUvZ1Q67Lz7LQaYlUMpeADtCWbm0E5/AQBuhgERKeUwJBWLjjkoqmw//vBI//TrTgkGBgCOgATURE/odysSik4ylUQsuZMzBuvLMSAzQREXkVnMuXzSsnk+3LxbqjRIkSWoGOQdoeAzQREXkMLWcE50Oby0r+fO5nhp+/kCbl6x/R8zBA22OAJiIir+XJ+8/mrlQuQOgUJ8IRERGZEFvQRETktTQxdPPkdeQYAzQREXktTf/n2evIMQZoIiLyWqph6ObJ68gxBmgiIvIau7h9j0liREREJsQWNBEReQ0t4VS2oH2KLWgiIvJZF7cnmycSExOlXLlyurhJ48aNZcOGDU6P3bVrlzz88MN6PNYhHzdunMPjjh07Jo8//rgUKVJEcuXKJbVq1ZJNmzaJvzBAExGRz5LEPNncNWvWLImPj5eEhATZsmWLxMTESGxsrCQnJzs8/vLly1KhQgUZPXq0LivqyNmzZ6V58+aSI0cO+eGHH2T37t0yZswYKVSokPgLu7iJiMhrmCzl2TQr940dO1b69OkjvXr10scTJ06U77//XqZMmSIvv/xyhuMbNmyoGzh6Ht5++22Jjo6WqVOnWveVL19e/MmvLWhLd0P6rV+/fv68LCIiymLnz5+321JSUhwehzW7N2/eLG3atLHuCw0N1cdr1671+P0XLFggDRo0kM6dO0uxYsWkbt26MnnyZAnaAL1x40Y5ceKEdVu6dKnuxxdERESBAwlinm6A1muBAgWs26hRoxy+z5kzZyQ1NVWKFy9utx+PT5486fH1Hzx4UCZMmCCVK1eWxYsXS9++fWXAgAEyffp0Ccou7qJFi9o9xvhAxYoVpUWLFg6Pxx2V7V0V7rKIiMj/UPTCk8IXltckJSVJ/vz5rfsjIyMlK6WlpWkL+q233tLHaEHv3LlTu8979uwpQZ0khm6LL774Qp566int5nYEd1S2d1i44yIiIvOMQXuyAYKz7RbpJEBHRUVJWFiYnDp1ym4/HjtLAHPFbbfdJtWrV7fbV61aNTl69Kj4i2kC9DfffCN///23PPnkk06PGTp0qJw7d8664Y6LiIj8L01CJNWDDa9zR0REhNSvX1+WL1/+v/dOS9PHTZs29fj6kcG9d+9eu3379u2TsmXLigR7Fvdnn30m7du3l5IlSzo9BndUWd3tQURE5hIfH6/dzuiSbtSokc5rvnTpkjWru0ePHlKqVCnrODZ6aDFtyvIz5jtv27ZN8ubNK5UqVdL9gwYNkmbNmmkXd5cuXXRe9aRJk3QL6gB95MgRWbZsmcydO9ffl0JERB5IM/7ZPHmdu7p27SqnT5+WESNGaGJYnTp1ZNGiRdbEMXRLI7Pb4vjx4zqmbPHee+/phnynVatW6T5Mw5o3b5721L722ms6xQqB/7HHHhN/CTEM/5cSGTlypHzyySfaZR0e7vo9A5LEMBbdUjpKeEiOTL1GMo/UVvUkEIRdui4BYcMOf18BZZEbxnVZJfN1iNA2Icsblr/D63eVkLz53B81vXghTRrXOOnTa8ou/N6CxtgBJoaju8Kd4ExEROZhGVP25HVk0iQxdG2jOwLZ20RERPQPvzdZ27ZtKyboZSciIi+kGSG6efI6MmmAJiKiwMcubt9jgCYiIq+lSqhu7r+OnGGAJiIirxkednHjdWTSJDEiIiLKiC1oIiLyGsegfY8BmoiIvJZqhOrm/usy5XKyBQZoIiLyGopepHkwapr233rQlBEDNBEReY1d3L7HJDEiIiITYguaiIj8OAbNLm5nGKCJiMhHY9AeLPXJLm6nGKCJiMhraR6uJMYkMec4Bk1ERGRCbEFnkYMz6ojZVei+TQJB2MotEghu3F1fAgH/CPhQk9piajeuimycnymn5hi07/H/m0RE5JMubs6D9i0GaCIi8lqqEaKbJ68jxxigiYjIj+Um2YJ2hkliREREJsQWNBEReS3NCNXN/dexBe0MAzQREXmNXdy+xwBNREReS/Mw4QuvI8cYoImIyI/TrJgK5Qy/GSIiIhNiC5qIiPy4khjbic4wQBMRkddYzcr3eOtCREQ+a0F7snkiMTFRypUrJzlz5pTGjRvLhg0bnB67a9cuefjhh/X4kJAQGTdu3E3PPXr0aD3u+eefF39igCYiIp9Ns/Jkc9esWbMkPj5eEhISZMuWLRITEyOxsbGSnJzs8PjLly9LhQoVNPCWKFHipufeuHGjfPLJJ1K7tv8LnzBAExFRQBk7dqz06dNHevXqJdWrV5eJEydK7ty5ZcqUKQ6Pb9iwobz77rvy6KOPSmRkpNPzXrx4UR577DGZPHmyFCpUSPyNAZqIiLyWZoR4vMH58+fttpSUFIfvc+3aNdm8ebO0adPGui80NFQfr1271qvP0K9fP+nQoYPduf2JAZqIiLyW5mH3tmUedHR0tBQoUMC6jRo1yuH7nDlzRlJTU6V48eJ2+/H45MmTHl//zJkztbvc2fsGZRb3sWPHZMiQIfLDDz/oOEGlSpVk6tSp0qBBA39fGhERZfpa3P+8JikpSfLnz2/dH3mTrmhfw3sPHDhQli5dqklnZuHXAH327Flp3ry5tGrVSgN00aJFZf/+/abo+ycioqyD4GwboJ2JioqSsLAwOXXqlN1+PL5VApgz6DJHglm9evWs+9BK//HHH2X8+PHa3Y73DKoA/fbbb2u3BlrMFuXLl/fnJRERkQdSJUQ3T17njoiICKlfv74sX75cOnXqpPvS0tL0cVxcnHiidevWsmPHDrt9SECrWrWq9vD6Izj7PUAvWLBAU+M7d+4sq1evllKlSslzzz2n2XmO4C7GNnEAiQRERBT4XdzuiI+Pl549e+pQaKNGjXRe86VLlzSoQo8ePTSeWMaTkVi2e/du688YWt22bZvkzZtXh1Xz5csnNWvWtHuPPHnySJEiRTLsD5oAffDgQZkwYYJ+2cOGDdP5ZwMGDNA7JHz56eHLfvXVV/1yrURE5FyqB61hy+vc1bVrVzl9+rSMGDFCE8Pq1KkjixYtsiaOHT16VDO7LY4fPy5169a1Pn7vvfd0a9GihaxatUrMKsQw/FctG4EYd0Br1qyx7kOARqB2lC7vqAWNLvKW0lHCQ3KImR2cUUfMrkL3bf6+hGzlxt31JRCEr9js70vIPpr4f3GLm7lx46qs2viWnDt3zqXxXlfg7zCyroevays587r/d/jqxevyRpMlPr2m7MKv06xuu+02nWRuq1q1anr34wiy+iyJBK4mFBAREQUiv3ZxI4N77969dvv27dsnZcuW9ds1ERGR+1jNKpsF6EGDBkmzZs3krbfeki5duuhi55MmTdKNiIgCh+FhNSu8jkwYoLE+6rx582To0KHy2muv6RQrZONhLVQiIgocbEFnw5XE7rvvPt2IiChw2a6r7e7ryDHeuhAREZmQ31vQREQU+Dyt7ezJa4IFAzQREXmNXdy+xwBNREReS7MpHenu68gxfjNEREQmxBY0ERF5LdUI0c2T15FjDNBEROQ1jkH7HgM0ERF5zfCw3CReR44xQBMRkddQatKzcpNsQTvDWxciIiITYguaiIi8lmZ4Np6M15FjDNBEROS1NA/HoD15TbBggCYiIq+leVhu0pPXBAsGaCIi8hrnQfseA3QWqdB9m78vgbJY+IrN/r4EymrrtoupGdf9fQXkBgZoIiLyGsegfY8BmoiIfDMG7UkWN8egnWKAJiIirxkeJonhdeQYAzQREXmNa3H7Hjv/iYiITIgtaCIi8hqTxHyPAZqIiLzGLm7fY4AmIiKvcSUx32PfAhERBZzExEQpV66c5MyZUxo3biwbNmxweuyuXbvk4Ycf1uNDQkJk3LhxGY4ZNWqUNGzYUPLlyyfFihWTTp06yd69e8WfGKCJiMhnXdyebO6aNWuWxMfHS0JCgmzZskViYmIkNjZWkpOTHR5/+fJlqVChgowePVpKlCjh8JjVq1dLv379ZN26dbJ06VK5fv26tG3bVi5duiT+wi5uIiIKqDHosWPHSp8+faRXr176eOLEifL999/LlClT5OWXX85wPFrG2MDR87Bo0SK7x9OmTdOW9ObNm+Wuu+4Sf2ALmoiI/N6CPn/+vN2WkpLi8H2uXbumQbNNmzbWfaGhofp47dq1Pvs8586d038LFy4s/sIATUREfg/Q0dHRUqBAAes2atQoh+9z5swZSU1NleLFi9vtx+OTJ0/65rOkpcnzzz8vzZs3l5o1a4q/sIubiIj8LikpSfLnz299HBkZ6bdrwVj0zp075eeffxZ/YoAmIiKvGR5OmcLrAMHZNkA7ExUVJWFhYXLq1Cm7/XjsLAHMHXFxcfLdd9/Jjz/+KKVLl5aACtAYF1i/fr0cOXJEM+OKFi0qdevWlfLly2fOFRIRkellVZJYRESE1K9fX5YvX65TofQcaWn6GMHVU4ZhSP/+/WXevHmyatUqU8Q0lwP0L7/8Ih988IF8++23mn6OMYJcuXLJX3/9pUEbKexPP/20PPvsszqPzBUjR46UV1991W5flSpVZM+ePe5/EiIiCoos7vj4eOnZs6c0aNBAGjVqpPOaMR3KktXdo0cPKVWqlHUcG4llu3fvtv587Ngx2bZtm+TNm1cqVapk7daeMWOGzJ8/X2OYZTzbEutMG6AfeOABnWvWvXt3WbJkiX4pthd88OBB+emnn+Q///mPpr9//vnncs8997h0ATVq1JBly5b974LC2etORBRosjJAd+3aVU6fPi0jRozQQFqnTh2dJmVJHDt69KhmdlscP35ce3ot3nvvPd1atGihrWWYMGGC/tuyZUu795o6dao8+eST4g8uRcMOHTrI119/LTly5HD4PFrP2HBHg7uUEydOuH4B4eE+GTcgIqLgERcX57RL2xJ0LbCCGLqwb+ZWz5s2QD/zzDMun7B69eq6uWr//v1SsmRJXa6tadOm2iVRpkwZh8eiK912bhzmyhERkf+xWIZJ5kH//fff8umnn8rQoUN1DBrQBY5+fXdg/VSs1oKuCXQvHDp0SO688065cOGCw+MRvG3nyWHeHBER+Z9hhHi8kWNuD/hu375dV2xBgDx8+LAut4aVVubOnav9/hh/dlX79u2tP9euXVsDdtmyZeWrr76S3r17ZzgeNwRIDrBtQTNIExH5H6tZmaAFjQCJAXN0TaNb2uLee+/VeWPeKFiwoNx+++1y4MABh89j4rplrpyrc+aIiIiCIkBv3LjR4Zg0Utq9XWbt4sWL8vvvv8ttt93m1XmIiCj7VrMKFm4HaLRiHSVn7du3TxctcceLL76oJb7QVb5mzRp58MEHdYWYbt26uXtZRETkRxyDNkGAxpzo1157TRcrARS/xtjzkCFDtCC2O/744w8NxlicpEuXLlKkSBGtxeluoCciIv9iC9oESWJjxoyRRx55ROtkXrlyRSd6o2sbU6TefPNNt841c+ZMd9+eiIhMyNPWMFvQPgzQyN5eunSpLv3566+/6rhxvXr17GpzEhERURYHaEyjwjJrqJOJzQLrm6JFjDVQiYgouBgedlezBe3DMWgsRn7u3LkM+7G4iGWhciIiCi5YKBOrZbq9+fvCs1MLGuuVIjHMUcIXur+JiCj4YMER/M+T15GXARqVQBCYsbVu3dqu6lRqaqou09muXTtXT0dERNkIk8T8GKAthbFRQzM2NlbraNoW0Ea1EHenWREREZGXATohIUH/RSBGkpjtMp9ERBTckCAWwmpW/h2DRs1nIiIiW5akL09eR14EaFSrwlKeUVFRUqhQIYdJYhaW8pNERBQ8OAbtpwD9/vvvS758+aw/3yxAExFR8GGA9lOAtu3WRqlJIiIiMtlCJVu2bJEdO3ZYH8+fP18zvIcNG6ariRERUfBhsQwTBGjUgsZ4NBw8eFAzunPnzi2zZ8+Wl156KRMukYiIzM6jVcQ8TCwLFm5ncSM416lTR39GUEY1qxkzZmjxjEcffVTGjRuXGdcZ8A6830TMrtKgdf6+BCKH/uzTVALBtXzmbg2mplwVGT8/U879T7D1ZAw6Uy4nOFvQWOozLS1Nf162bJnce++9+nN0dLScOXPG91dIREQUhNxuQTdo0EDeeOMNLS+5evVqmTBhgu7HUp/FixfPjGskIiKTYxa3CVrQ6MJGolhcXJy88sorUqlSJd0/Z84cadasWSZcIhERBUQ1Kw838lELunbt2nZZ3BbvvvuuhIWFuXs6IiLKBtiCNkGAdoZrcxMRBTFPm8NsQvuui5uIiIgyHwM0ERF5779d3O5ueJ0nEhMTtboiem8bN24sGzZscHrsrl27tBwyjsdS1c6mA7tzzqzAAE1ERAG1UMmsWbMkPj5eyyAjaTkmJkZiY2MlOTnZ4fGXL1+WChUqyOjRo6VEiRI+OWdWYIAmIiKvedJ69jSxbOzYsdKnTx/p1auXVK9eXSZOnKgrWk6ZMsXh8Q0bNtREZiymFRkZ6ZNzOrJy5UrJ8iQx3FW4Ch+SiIiCjKfd1f99zfnz5+12R0ZGOgymqPmwefNmGTp0qHVfaGiors2xdu1aT67cZ+ds166dlC5dWoM8ikxhAa9MD9Bbt261e4zm/40bN6RKlSrW5T8xxap+/fpeXQwREQWn9MEsISFBRo4cmeE4rFiZmpqaYWEsPN6zZ49H7+2rcx47dkz+/e9/y/Tp0+XVV1+Vu+++W3r37q0FpSIiIjInQNs229FCRm1oXEChQoV039mzZ/WO4c4773T7AoiIKPB5Op5seU1SUpLkz5/fuj/SSVe0mUVFRcmgQYN0Q0N26tSp8txzz+nWvXt3DdYY2860MegxY8bIqFGjrMEZ8DOW/8RzREQUhLxcSgzB2XaLdBKgEQTRY3vq1Cm7/XjsLAHsVjLjnPXq1dMuc6y6efHiRR3LRi8zGrLIKs+UAI1xgtOnT2fYj30XLlxw93RERJQNZFWSWEREhAa65cuXW/ehgBMeN23qWdUzX57z+vXruvQ1CkmVLVtWFi9eLOPHj9dgf+DAAd3XuXPnzFlJ7MEHH9TubLSWGzVqpPvWr18vgwcPloceesjd0xEREbklPj5ek7BQvAlxCPOaL126pLEJevToIaVKldLeXksS2O7du60/Y6x427ZtkjdvXms9iVud0xX9+/eX//znP1r18YknnpB33nlHatasaX0+T5488t5770nJkiUzJ0Aj9fzFF1/U/nTcKehJwsO1bx1p7EREFKSyaNnOrl27aq/tiBEj5OTJk1KnTh1ZtGiRNcnr6NGjmoVtcfz4calbt671MYIkthYtWsiqVatcOqcrcBPw0UcfaWP1Zl30rk7HCjEQ6j2AO4vff/9df65YsaLeGWQ1dLcXKFBAWkpHCQ/JIWZ24P0mYnaVBq3z9yUQOfRnH8+6LrPatXzmLvyQmnJV9owfJufOnbNLyPLF3+HoTxIkNJf7NRnSrlyVpGde9ek1+cuPP/6oVR3RaLWFWU9r1qyRu+66K2sWKkFARmUrbL4IzljhBUuwPf/8816fi4iIshjrTUqrVq3kr7/+yrAfNx94zl0udXGjuT5t2jS9u7nVOPPcuXPdvoiNGzfKJ598osGeiIgCEXoPPOlBMHevgzvQIY2GZnp//vmnRw1ZlwI0ui8sb4qffQnp54899phMnjxZp2rdTEpKim4W6VeeISIiymqWhivi5JNPPmk3/owFULZv365d35kSoDHZ2nJ3gNVRihYtKrly5RJf6Nevn3To0EGXVLtVgEZGHt6fiIhMJojrQRf4b8MVMRILednGR0zhatKkia7z7S63srjx5khJxyTrypUri7dmzpypq62gi9sVmPRtuy44WtDernVKREQ+EMQBeup/G7EoVYlZTr5KmnYrQCNtHYEZ/eneBmgs6zZw4EBZunSp1t50hbPF04mIKLCLZWQHCQkJPj1fuCfZ1liUZMKECXYTsN2FyiGos4nl0Gz76pGmjlVXMNaMpdeIiCj7r8UdqOrVq6crjmHJa8y1dpQkZoEe40wN0FihBcWvseA3+tbTj0U7SjF3pHXr1rJjxw67fVixpWrVqjJkyBAGZyIiMr2OHTtae3ZRtcqX3A7QWP7MFzCQnr4Fjn77IkWKeNUyJyIiPwjSMegEm25tv3dxY61SIiIiOxyD9jm3A7Szucfod0cz35Oi1BaWNVGJiCiwhBj/bJ68LpAVKlTopuPOngwBexygCxYseNOLKV26tE7URlPfdrFyIiLKxoK0i3ucj4Z9fRKgseTnK6+8okHYUm5yw4YNMn36dBk+fLhWA0GVELSmhw0blhnXTEREZAqZOezrdoBGIEYt6C5dulj33X///VKrVi1dTxvp5mXKlJE333yTAZqIKFgE6Rj0+fPnrVW4brX8tLvVutwO0CiZhZrQ6WH+19q1a/XnO+64Q+txEhFRkAjSLu5ChQrJiRMnpFixYk6HgC1FNLDWR6YGaCyt+dlnn+mCJbawz7LsJlYaw0UTEVGQCNIAvWLFCilcuLD+vHLlSp+e2+0AjfHlzp07yw8//CANGzbUfZs2bZI9e/bInDlz9DHW1u7atatPL5SIiMhsWrRo4fBnvwToBx54QPbu3avjzfgX2rdvL998840uFA59+/b16UUSEZHJBWkLOr2zZ89qj/Jvv/2mj6tXr66rZFpa2ZkaoAGBGKUfiYiIgjlJzBZqSSBpGuUnGzRooPs+/PBDee211+Tbb7+Vu+66S3weoJHwhcxsVx07dkxKlSrl1oUQEVHgCtaFSmz169dPh3dRTMpSTwKJYc8995w+l77+xK24tJIIxpqfeeaZm9ZtPnfunEyePFnX0f7666/duggiIsomXdyebNnEgQMH5IUXXrAr9oSf4+Pj9Tl3udSC3r17t85rvueee7R2c/369aVkyZL6M/rb8fyuXbu07NY777wj9957r9sXQkREFMjq1aunY89VqlSx2499qACZKQEaFabGjh2rQfr777+Xn3/+WY4cOSJXrlyRqKgoeeyxxyQ2NpZVqIiIKKhs377d+vOAAQNk4MCB2lpu0qSJ7lu3bp0kJiZmmJrs8yQx1H5+5JFHdCMiIrJAqpdHY9AS2OrUqaOLkGAxEouXXnopw3Hdu3d3e/qxR1nc5L6Ks6/4+xKIAlaRyf+sUmh6TWqLmd24cVX2ZNbJgzSL+9ChQ5l2bgZoIiLyXpDOgy5btmymnZsBmoiIyIeQOI3pydeuXcuw0Jc7GKCJiMh7QdqCtnXw4EF58MEHdb6z7bi0pYCGu8UyXJoHTURE5MpCJZ5snkhMTNRVLTHdt3HjxrJhw4abHj979mypWrWqHo/yyAsXLrR7/uLFixIXFyelS5fWhGgs0emocuPNIIO7fPnykpycLLlz59bpx1hdDKuKrVq1yu3P6FELev/+/Vq1AxeRlpZm99yIESM8OSUREQWyLGxBz5o1Sxf/QABFcB43bpxO9UV9CJR9dFQmuVu3brpE9X333SczZsyQTp06yZYtW6zTg3E+VKb64osvNPAvWbJEVwDDmh+udk2j5DLOgenHoaGhuqH8Mt4XU7C2bt2auS1orBZWrVo1DcSoXjVv3jzrhoIZRERE7jp//rzdlpKS4vRYrMvRp08fLUJhaemixTplyhSHx3/wwQfSrl07GTx4sMav119/XRcVGT9+vF0Q79mzp7Rs2VID9NNPP62Li9yqZW4LXdj58uXTnxGkjx8/bk0ksxSXytQA/cYbb+iCJSdPnpRt27bpHYFlw90IEREFIS+X+oyOjtYiE5ZtlJOCTEi82rx5s7Rp08a6Dy1VPEYL1hHstz0e0OK2Pb5Zs2ayYMECrSWBsWP0Eu/bt0/atm3r8leA1vivv/6qP6Nlj5U1f/nlFy2WUaFCBcn0Lm4s7Yl60ERERL4qlpGUlCT58+e37o+MjHR4/JkzZ7SlWrx4cbv9eLxnj+NZ3mhQOjoe+y0++ugjbTVjDDo8PFyDPnqM3alANXz4cLl06ZL+jKCM7vQ777xTV+NEt3ymB2gEZ/TNP/vss26/GRERZVNeLlSC4GwboLMaAjSW5UQrGl3SSO5CBSqMQadvfTuDVrlFpUqV9Ibhr7/+kkKFClkzuTM1QONN/+///k8/CDLhcuTIYfc8BsKJiCjIZFGSWFRUlFaIOnXqlN1+PC5RooTD12D/zY5HXYlhw4ZpLlWHDh10X+3atXUY97333nM5QNtCj4Cl695Tbo9BT5o0SfLmzSurV6/WAfb333/fuiGTjoiIKLNERERoRcXly5db92E2ER43bdrU4Wuw3/Z4WLp0qfX469ev64ZubVu4EUg/U+lmbty4oQ1YjKEj0QwbfkbXN86f6S3ozFx3lIiIgnMM2h3x8fGacY35xY0aNdLGIcZ+kdUNPXr0kFKlSlkTzTA/uUWLFjJmzBhtIc+cOVM2bdqkDU5A1zqeR5Y35kCjixuN0M8//1wzxl3Vv39/mTt3riaHWYI/EtFGjhwpf/75p0yYMCHrVhJLv0oKEREFqSycB921a1c5ffq0TvdFohcqSi1atMiaCIZlNm1bw8jQxtxntGTRlV25cmWdFmxbIhlBe+jQoVo+GePGCNKYseROvhXeA+dp3769dR+6ytHNjXnYWRKgcVfx7rvv6oIlcPvtt+udxxNPPOHJ6YiIKNB5uiqYhyuJxcXF6eaIo1W7kOB8sxlIGI+eOnWqeAOZ5+jWTg+ri6FrPtPHoNHc79u3r9x7773y1Vdf6YYJ4LjLwDg0EREFIS/nQWcHcXFxugiK7SIr+BktcWc3Ez5tQSMVHc109PFbYBm0GjVqaD/7oEGD3L4IIiKiQPTQQw/ZPV62bJnOpcYqZICFS7C4SuvWrTM/QJ84cUL789PDPjznDgR6bIcPH9bHCPIYU7DtvyciogAQpNWsChQoYPf44YcftnvszTQrj+ZBo1sbA+22sEoKBt7dgbuM0aNH6+uQcDZ9+nTp2LGjLhuKYE1ERIEhK7O4zcTbcWufBuhXX31VM+iwykrz5s11H9YaxRwzBG533H///XaP0U+PFjUWQWGAJiKiQIQMc0txjCpVqkjRokU9Oo/bARrN9/Xr12tCmKV6FaqDoOJH3bp1xVNYWxX1OjGXzdlkcwy22w6+o+IJERGZQJB2cdtC/MJcaMx0sixwgsVOkLOF/C1U3Mr0aVZYxQU1M31hx44dGpCvXr2qK5RhqTWUD3MEk87RgiciIjIbLKCCBU6+/fZbaw/zzz//rEtgv/DCC5kzDxotVcsi5rdqtbq72Dma/1jv9Ny5c1pfGqvD4AM6CtKYRI4vwPa6vBmAJyIi3wjWMWhbX3/9tcYx1JS2wJRkrE7WpUuXzAnQqMSBDO1ixYpJwYIFHa4chiQv7EdXtTsweRuJZ5aW+caNG7W49ieffOJwErizEmRERORn2SjYeuLy5csZyloCYieec5dLAXrFihVSuHBh/RlFrDMT+u1tx5mJiCgAcAxaMFybkJCgY9A5c+a0VsrC0Kyz3CqvAzQWEbddsgzdyulb0WhBW8pruQpd1pjzXKZMGblw4YKuY4ol2hYvXuzWeYiIiPwNRTuwsmb6hUoQrD2Ja24niSFAW7q7bWFxcTznThd3cnKyZrfhfJjsjUXF8SHuuecedy+LiIj8iGPQIrVq1dIaFV9++aXs2bNH96FIBgpwYBw60wO0Zaw5vYsXL1qb9K767LPP3H17IiIyoyDv4r5+/bpUrVpVvvvuO+nTp49PzulygLZkTyM4oyC17XwutJoxNxolv4iIKPgEews6R44cOl3Yl1wO0Fh+09KCxtxl29JZ+Bn97S+++KJPL46IiAJEkLegoV+/fvL222/Lp59+KuHhHi0zYsflM1iyt3v16qXToNyd70xERJSdbdy4UZe9XrJkiY5H58mTx+75uXPnunW+cDMtDE5ERAGKLWjBOiHpq1l5I9zVepfTpk3TVnP62pfpuXuHQEREgS+Yx6DT0tLk3XfflX379mnt57vvvltGjhzpUea22wEaU6Asmdvpa18SEREFcwv6zTff1IDcpk0bDcoffvihVrSaMmVK5gdo225tdnETEVEGQRygP//8c/n444/lmWee0cfLli2TDh06aLJYaGiox+d1+5VYtsx2TdEjR47o6ikYFCciIgo2R48e1aIYFmhJo9f5+PHjXp3X7QDdsWNHvVuAv//+Wxo1aiRjxozR/e5W6iAiouzBMgbtyRbobty4kWGhLsyLxuIl3nA7i3vLli3y/vvv688oq1WiRAmdI40yWyNGjJC+fft6dUFERBSAgriL2zAMefLJJ+2qLWLRkmeffdZuqlWmT7NC93a+fPn0Z3RrI6sbfexNmjTR7m4iIgo+wZzF3bNnzwz7Hn/8ca/P63aARu3mb775Rh588EEtbDFo0CBr4QsuXkJERMFmaiYlT7s9Bo1ubCzpWa5cOR1/ttS4RGu6bt26mXGNREQUKF3cnmzkmxb0I488InfccYeWiLTUu4TWrVtrq5qIiIJQEI9BZxaPVvNGYhi2P/74Qx+jODVa0+TckjnTxexiS7IaGZnTsZebSSBIqf2/KahmlHY5VGRj5pwbS1mFePg6TyQmJurqXSdPntTG4kcffXTTODR79mytxHj48GGpXLmyFrWwnRoFv/32mwwZMkRWr16tmdnVq1fXBOgyZcqIP4R6sqTZa6+9piuKlS1bVjesP/r666/rc0REFISysIt71qxZWgI5ISFBZxYhQMfGxmoulCNr1qyRbt26Se/evXXWUadOnXTbuXOn9Zjff/9de4dR03nVqlWyfft2Dejpp0+ZugX9yiuvyGeffSajR4+W5s2b676ff/5ZlzlDWjmWPCMiIsosY8eOlT59+mh1RZg4caJ8//33urTmyy+/nOF4VGBs166dDB48WB+jQbl06VIZP368vtYS29Cifuedd6yvq1ixoviT2y3o6dOn6/JlmO9cu3Zt3Z577jmZPHmyFtQgIqLg4+1CJefPn7fbUlJSHL4PilFs3rxZV+uywFRfPF67dq3D12C/7fGAFrflePT+IsDffvvtur9YsWLSuHFjnbEUUAH6r7/+0i6A9LAPzxERURDysos7Ojpah04t26hRoxy+zZkzZyQ1NVWKFy9utx+PMR7tCPbf7Hh0jV+8eFF7htHSxqwkJD1jnQ+MRwdMFzf6+tEtgGodtrDPNqubiIiCjBcZ2UlJSXZraUTarMqV2Sz5U1iy2rK2R506dXTsGl3gLVq0kIAI0OifR5UOVOuwzIFGNwG+3IULF2bGNRIRUTZfSQzB2ZXFrqKioiQsLExOnTpltx+PMbvIEey/2fE4Z3h4uGZt26pWrZrmWAVMFzfuJFCUGs1/FMvAhm6AvXv3yp133pk5V0lERCQiERERUr9+fVm+fLldCxiPLY3G9LDf9nhAkpjleJyzYcOGGsdsIdZhplJAzYMuWbIks7WJiMgvC5XEx8fr+tcNGjTQuc8oeXzp0iVrVnePHj2kVKlS1nHsgQMHauMSlRfRAzxz5kzZtGmTTJo0yXpOZHh37dpV7rrrLmnVqpUsWrRIvv32W51yFVAB+uzZszrVCpO6Ad0C+GIKFy7s6+sjIqIAkJXFMrp27SqnT5/WpaeR6IXxYgRUSyIY6jMjs9uiWbNmMmPGDBk+fLgMGzZMFypBhnbNmjWtx6BXGOPNCOoDBgyQKlWq6CIlmBvtLyEG6mS54ccff5T7779fs+xw9wJIeUdXN+42cPeRVZCKj+toKR0lPCSHmNni49vE7LiSGJkVVxLzjbTLV+Vw7zfk3LlzPituZPk7XKv3WxIW4f6iHqnXrsqOz4b59JqyC7db0P369dO7lwkTJuhAPSDlHXOh8dyOHTsy4zqJiMjEgrncpGmSxA4cOCAvvPCCNTgDfsaYAJ4jIiIiPwToevXqWceebWEf50ETEQUplpv0fxc3Bs+REYfWcpMmTXTfunXrtLIIVmHBAuMWWAaUiIiCAMtN+j9AoyIIvPTSSw6fCwkJEeSd4V+MTRMRUfbHMWgTBOhDhw5lwmUQERGRVwHal6uqYL7Z3LlzZc+ePZIrVy6dq4Yi2ph/RkREAYRd3P5PEvMlVAnB1CyMYWPZtevXr0vbtm11RRgiIgocIRja9HAjH64k5itY+cUW6kmjDicWPsnKBU+IiMhLbEFnrwCdHlaSAWdLhqKAt20Rb6xgQ0RE/scksWzWxW0L1Uief/55ad68ud36qOnHrG0LeqPANxERUXbkdoBGBRGsx+1rGIveuXOnVhlxZujQodrKtmyoQU1ERCbAhUr8H6ARGNu0aaPVQN566y05duyY1xcRFxcn3333naxcuVJKly7t9LjIyEhrUW9Xi3sTEVHWdXF7spGPAjRKdCEo9+3bV2bNmiXlypWT9u3by5w5czQL2x1Y0ATBed68ebJixQopX768u5dDRERmwBa0OcagixYtqsUxfv31V1m/fr1UqlRJnnjiCSlZsqQMGjRI9u/f73K39hdffKF1OvPly6d1PbFduXLFk8siIiI/YQvaZEliJ06c0PnL2FDR6t5779Vyk9WrV5f333//lq9HyUp0mbds2VJuu+0264aWORERUTBze5oVurEXLFggU6dOlSVLlmhBDGRfd+/e3TomjC7rp556SlvTt+riJiKibIDzoP0foNHCxZQoFMbYsGGD1KlTJ8MxrVq1koIFC/rqGomIKACwu9rPARpd1507d5acOXM6PQbBmUU1iIiCCHpEPekVZU+q7wI0ksGIiIgoiJb6JCKiwMSlPn2PAZqIiLzHJDGfY4AmIiKvhaT9s3nyOnKMAZqIiLzHFnT2rWZFRERE/8MWNBEReY1JYr7HAE1ERN7jPGifY4AmIiKvsQXtexyDJiKigCs3mZiYqOWOsapl48aNdenpm5k9e7ZUrVpVj69Vq5YsXLjQ6bHPPvushISEyLhx48SfGKCJiCigzJo1S0seJyQkyJYtWyQmJkZiY2MlOTnZ4fFr1qzR+hG9e/eWrVu3SqdOnXTbuXNnhmNR7GndunVaPtnfGKCJiCig6kGPHTtW+vTpI7169dLyxhMnTpTcuXPLlClTHB7/wQcfSLt27WTw4MFSrVo1ef3116VevXoyfvx4u+OOHTsm/fv3ly+//FJy5Mgh/sYx6CxS7/W+YnZFZa2/LyFbMZrFSCAIWfOrmF2p0WskEKS1qCtmduNGiBw2aZLY+fPn7XZHRkbqlt61a9dk8+bNMnToUOu+0NBQadOmjaxd6/hvGPajxW0LLe5vvvnG+hhVGlFrAkG8Ro0aYgZsQRMRkd9b0NHR0VKgQAHrNmrUKIfvc+bMGUlNTZXixYvb7cfjkydPOnwN9t/q+LffflvCw8NlwIABYhZsQRMRkd8lJSVJ/vz5rY8jHbSeMwta5OgGx3g2ksPMgi1oIiLyexY3grPtFukkQEdFRUlYWJicOnXKbj8elyhRwuFrsP9mx//000+aYFamTBltRWM7cuSIvPDCC5op7i8M0EREFDBJYhEREVK/fn1Zvny53fgxHjdt2tTha7Df9nhYunSp9XiMPW/fvl22bdtm3ZDFjfHoxYsXi7+wi5uIiLyXZvyzefI6N8XHx0vPnj2lQYMG0qhRI52vfOnSJc3qhh49ekipUqWs49gDBw6UFi1ayJgxY6RDhw4yc+ZM2bRpk0yaNEmfL1KkiG62kMWNFnaVKlXEXxigiYgooKpZde3aVU6fPi0jRozQRK86derIokWLrIlgR48e1cxui2bNmsmMGTNk+PDhMmzYMKlcubJmcNesWVPMjAGaiIgCTlxcnG6OrFq1KsO+zp076+aqw4czbUKayxigiYjIa8h99mgt7sy4mGyCAZqIiLzHalY+xwBNREReYzUr32OAJiKigEoSCxacB01ERGRCbEETEZHXQgxDN09eR44xQBMRkffS/rt58jpyiAGaiIi8xhZ0NhuD/vHHH+X+++/XNU9RQcS2NicREQVPsQwyWYDG2qkxMTGSmJjoz8sgIiIyHb92cbdv3143IiIKcFyoJLjHoFNSUnSzOH/+vF+vh4iI/sGFSoJ8HjRKhxUoUMC6RUdH+/uSiIjItgXtyUaBH6CHDh0q586ds25JSUn+viQiIqJMEVBd3JGRkboREZG5hKT9s3nyOsoGAZqIiEyKSWLZK0BfvHhRDhw4YH186NAh2bZtmxQuXFjKlCnjz0sjIiJ3sFhG9grQmzZtklatWlkfx8fH6789e/aUadOm+fHKiIjIHVxJLJsF6JYtW4rBXw4REVEGHIMmIiLvcQza5xigiYjIe4iznmRkMz47xQBNRERe4xi07zFAExGRj7K4PenizoyLyR4CaiUxIiKiYMEWNBEReY9JYj7HAE1ERN5DgliIh68jhxigiYjIa0wS8z2OQRMREZkQAzQREQVcPejExEQpV66c5MyZUxo3biwbNmy46fGzZ8+WqlWr6vG1atWShQsXWp+7fv26DBkyRPfnyZNHSpYsKT169JDjx4+LPzFAExFRQAXoWbNmae2GhIQE2bJli8TExEhsbKwkJyc7PH7NmjXSrVs36d27t2zdulU6deqk286dO/X5y5cv63n+7//+T/+dO3eu7N27Vx544AHxJwZoIiIKqAA9duxY6dOnj/Tq1UuqV68uEydOlNy5c8uUKVMcHv/BBx9Iu3btZPDgwVKtWjV5/fXXpV69ejJ+/Hh9vkCBArJ06VLp0qWLVKlSRZo0aaLPbd68WY4ePSr+wgBNRETeS/NiE5Hz58/bbSkpKQ7f5tq1axo427RpY90XGhqqj9euXevwNdhvezygxe3seDh37pyEhIRIwYIFxV8YoImIyO+io6O1JWvZRo0a5fC4M2fOSGpqqhQvXtxuPx6fPHnS4Wuw353jr169qmPS6BbPnz+/+AunWWWRwnsc3w1S9mWEBcb9rydTV8mx0NVbxcxCjeumnWaVlJRkFwwjIyPFH5Awhq5ulEKeMGGC+BMDNBER+X0lMQRnV1qrUVFREhYWJqdOnbLbj8clSpRw+Brsd+V4S3A+cuSIrFixwq+tZwiMW3wiIjK3NMPzzQ0RERFSv359Wb58+f/eOi1NHzdt2tTha7Df9nhAUpjt8ZbgvH//flm2bJkUKVJE/I0taCIiCqi1uOPj46Vnz57SoEEDadSokYwbN04uXbqkWd2AOcylSpWyjmMPHDhQWrRoIWPGjJEOHTrIzJkzZdOmTTJp0iRrcH7kkUd0itV3332nY9yW8enChQvrTYE/MEATEVFA6dq1q5w+fVpGjBihgbROnTqyaNEiayIYpkYhs9uiWbNmMmPGDBk+fLgMGzZMKleuLN98843UrFlTnz927JgsWLBAf8a5bK1cuVJatmwp/sAATUREPuDpqmCerSQWFxenmyOrVq3KsK9z5866OYIVyZAUZjYM0ERE5D2Wm/Q5BmgiIvKeJnt5EGzdTBILJgzQRETkPSPtn82T15FDnGZFRERkQmxBExGR9zgG7XMM0ERE5D2OQfscAzQREXmPLWif4xg0ERGRCbEFTURE3tMebk9a0JlxMdkDAzQREXmPXdw+xwBNRETeS8N85jQPX0emHYNOTEzUtVBz5swpjRs3lg0bNvj7koiIyJMWtCcbmTNAz5o1S0uHJSQkaKmvmJgYiY2NleTkZH9fGhERUfAG6LFjx0qfPn20jmf16tVl4sSJkjt3bpkyZYq/L42IiFzFFnT2CtDXrl2TzZs3S5s2bf53QaGh+njt2rUZjk9JSZHz58/bbUREZAJYcMTTjcwXoM+cOSOpqanWItsWeIwi3OmNGjVKChQoYN2io6Oz8GqJiMgZw0jzeCOTdnG7Y+jQoXLu3DnrlpSU5O9LIiIiMDxsPbOL25zTrKKioiQsLExOnTpltx+PS5QokeH4yMhI3YiIiLI7v7agIyIipH79+rJ8+XLrvrS0NH3ctGlTf14aERG5g0li2W+hEkyx6tmzpzRo0EAaNWok48aNk0uXLmlWNxERBQgsOBLiwXgyx6DNG6C7du0qp0+flhEjRmhiWJ06dWTRokUZEseIiMjEtCXMpT6zVYCGuLg43YiIiMhEAZqIiAKbkZYmhgdd3Jxm5RwDNBEReY9d3D7HAE1ERN7DnOYQBmhfYoAmIiLvaaD1JIubATpbrCRGREQULNiCJiIirxlphhgedHEbbEE7xRY0ERF5D9nYnm4eSExMlHLlyknOnDmlcePGsmHDhpseP3v2bKlataoeX6tWLVm4cKH95RuGrsdx2223Sa5cubSq4v79+8WfGKCJiMg3LWgPN3fNmjVLV6FMSEiQLVu2SExMjMTGxkpycrLD49esWSPdunWT3r17y9atW6VTp0667dy503rMO++8Ix9++KFMnDhR1q9fL3ny5NFzXr16VfyFAZqIiAKqBT127Fjp06ePLgldvXp1Daq5c+eWKVOmODz+gw8+kHbt2sngwYOlWrVq8vrrr0u9evVk/Pjx/1y6Yegy08OHD5eOHTtK7dq15fPPP5fjx4/LN998I/7CAE1ERF67IdflhuHBJtf19efPn7fbUlJSHL7PtWvXZPPmzdoFbREaGqqP165d6/A12G97PKB1bDn+0KFDutS07TEFChTQrnNn58wKTBIjIiKvqhKiPPDPJ+3HdN2RN29eiY6OttuXkJAgI0eOzHDsmTNnJDU1NUO9Bjzes2ePw/Mj+Do6Hvstz1v2OTvGHxigiYjIY0i6QgsULVtPoYs5JCTEbl9kZKQEOwZoIiLyOkhjywpRUVESFhYmp06dstuPx2jJO4L9Nzve8i/2IYvb9hhUWPSXgA7QlvlzOoZh8ql0qTf8lwnoKsP4ZyyIfCMtAH7nEMrfe9CwjPcG8tzjiIgIqV+/vixfvlwzsSEtLU0fO6uK2LRpU33++eeft+5bunSp7ofy5ctrkMYxloCMcXBkc/ft21f8xghgSUlJltXZuXHjxo2bixv+dgaymTNnGpGRkca0adOM3bt3G08//bRRsGBB4+TJk/r8E088Ybz88svW43/55RcjPDzceO+994zffvvNSEhIMHLkyGHs2LHDeszo0aP1HPPnzze2b99udOzY0Shfvrxx5coVw18CugVdsmRJSUpKknz58mUYv/AU7pqQrIDz5s+fX8wqEK4zEK4ReJ3BdY2Bcp2ZcY1oOV+4cEH/dgayrl27yunTp3VhESRxodW7aNEia5LX0aNHNbPbolmzZjJjxgydRjVs2DCpXLmyTp+qWbOm9ZiXXnpJLl26JE8//bT8/fffcscdd+g5s6rr3pEQRGm/vbtJ/0+B9Ppz586Z9v+4gXKdgXCNwOsMrmsMlOsMhGukzMV50ERERCbEAE1ERGRCDNDpYO4dJsibfQ5eIFxnIFwj8DqD6xoD5ToD4Ropc3EMmoiIyITYgiYiIjIhBmgiIiITYoAmIiIyIQZoIiIiE2KAtpGYmCjlypXTlWNQB3TDhg1iNj/++KPcf//9uhIQVk/zZzFxZ0aNGiUNGzbUFd6KFSum6+Xu3btXzGbChAlamB2LQGDDurw//PCDmNno0aP19267prAZoCwgrst2q1q1qpjNsWPH5PHHH5ciRYpIrly5pFatWrJp0yYxE/wNSv9dYuvXr5+/L42yGAP0f82aNUvi4+N1WsOWLVskJiZGC3onJyeLmWApOlwbbibMavXq1frHZN26dbog/fXr16Vt27Z67WZSunRpDXgo/o4/0nfffbd07NhRdu3aJWa0ceNG+eSTT/Smwoxq1KghJ06csG4///yzmMnZs2elefPmkiNHDr0R2717t4wZM0YKFSokZvs9236P+P8QdO7c2d+XRlnNb6uAm0yjRo2Mfv36WR+npqYaJUuWNEaNGmWYFX598+bNM8wuOTlZr3X16tWG2RUqVMj49NNPDbO5cOGCUblyZWPp0qVGixYtjIEDBxpmguIDMTExhpkNGTLEuOOOO4xAg991xYoVjbS0NH9fCmUxtqBFtNA4WlFt2rSx7sNC63i8du1av15bdoC1hKFw4cJiVqmpqTJz5kxt5VtK0JkJeiQ6dOhg99+o2ezfv1+HXipUqCCPPfaYFiwwkwULFkiDBg20JYqhl7p168rkyZPF7H+bvvjiC3nqqad8VhCIAgcDtIicOXNG/0BbKqFY4DEqpZDnUKcV46XoWrStHGMWO3bskLx58+pqTc8++6zMmzdPqlevLmaCGwcMu2Bs36yQszFt2jSt/oOx/UOHDsmdd96plZPM4uDBg3ptqGS0ePFirfM7YMAAmT59upgVckxQWenJJ5/096WQHwR0uUkyP7T8du7cabrxSIsqVarItm3btJU/Z84c6dmzp46hmyVIo9TgwIEDdRzSn2XvbqV9+/bWnzFGjoBdtmxZ+eqrr6R3795ilptFtKDfeustfYwWNP7bnDhxov7ezeizzz7T7zbQy0OSZ9iCFpGoqCgJCwuTU6dO2e3H4xIlSvjtugJdXFycfPfdd7Jy5UpNyDKjiIgIqVSpktSvX19bqEjA++CDD8QsMPSCRMV69epJeHi4briB+PDDD/Vn9PyYUcGCBeX222+XAwcOiFncdtttGW68qlWrZrqueIsjR47IsmXL5F//+pe/L4X8hAH6v3+k8Qd6+fLldnfbeGzG8UizQ/4agjO6i1esWCHly5eXQIHfe0pKiphF69attRserXzLhlYgxnjxM24szejixYvy+++/a1A0CwyzpJ/ut2/fPm3pm9HUqVN1rBy5BxSc2MX9X5hihW4u/PFr1KiRjBs3ThOGevXqJWb7w2fbKsFYH/5QIwGrTJkyYpZu7RkzZsj8+fN1LrRlHB/F5zH31CyGDh2q3Yf43jBWimtetWqVjk+aBb6/9GP3efLk0Xm8ZhrTf/HFF3V+PoLd8ePHdboibh66desmZjFo0CBp1qyZdnF36dJF1zmYNGmSbma8UUSAxt8k9JRQkMrqtHEz++ijj4wyZcoYEREROu1q3bp1htmsXLlSpyyl33r27GmYhaPrwzZ16lTDTJ566imjbNmy+vsuWrSo0bp1a2PJkiWG2ZlxmlXXrl2N2267Tb/LUqVK6eMDBw4YZvPtt98aNWvWNCIjI42qVasakyZNMsxo8eLF+v+ZvXv3+vtSyI9YbpKIiMiEOAZNRERkQgzQREREJsQATUREZEIM0ERERCbEAE1ERGRCDNBEREQmxABNRERkQgzQREREJsQATdkWSvR16tTppsdgaU/U2UVJv8z2559/6trKhw8fzpLP1rJlSy316QmUjkTBC2+hUhSWACUi93ElMcq2UEIS/3lbAg0CVp06dXSddYtr167JX3/9pbW/Eagze713rPk9efJkn382Rxx9XldduXJFrxU3FDBy5EitTYx1392B7xfFUlDTGvWhich1XIWdsi0U53ClkllWlBS9fPmy1vb1thAHykviRsKVz+YNFDXxRWETfL/du3fX8pgM0ETuYRc3ee306dMa5FAlyGLNmjX6x9m2hKctdPMi0KBlhQpDOXPm1OpMqHVsC49RXSwyMlJLF7788sty48YN6/Nz5syRWrVqaTBBhac2bdpoFbL03cD4GedCrWe8LzZcg6Mu7q+//lpq1Kih71muXDkZM2aM3TVhHz7rU089pdWmUA3rVhWRFi5cqOdr0qSJ3f4FCxZI5cqV9fO3atVKpk+fbnc9lq5mHIdaxjgH6hen7+LGZ+7Ro4fkzZtXv6f01+zIr7/+qu+Jz5A/f34tubpp0ya797X8/Oqrr+rxlu8O+wDXiXrFRYsW1XPcfffdepwtdHHj+tEqJyI3+LNSB2Uf33//vZEjRw5j48aNxvnz540KFSoYgwYNcnr8oUOHtFpP6dKljTlz5hi7d+82/vWvfxn58uUzzpw5o8f88ccfRu7cuY3nnnvO+O2334x58+YZUVFRRkJCgj5//PhxIzw83Bg7dqyeb/v27UZiYqJx4cIFfR4Vvjp27Kg///3330bTpk2NPn36GCdOnNDtxo0b1upgZ8+e1eM2bdpkhIaGGq+99ppWEkIFrly5ctlV4kIFrMKFC+t77d+/3xg1apS+Zs+ePU4/74ABA4x27drZ7Tt48KB+Zy+++KK+9j//+Y9WgrK9HrwvjmnWrJnxyy+/6HGXLl2y+2zQt29frcS2bNky/R7uu+8+/S5vVvWqRo0axuOPP67f7b59+4yvvvrK2LZtm/V9CxQooD9fvnzZeOGFF/R4y3eHfdCmTRvj/vvv1987zoHjihQpYvz555/W98H14vvBd01ErmOAJp9BIL399tuN7t27G7Vq1TKuXr16ywA9evRo677r169rwH777bf18bBhw4wqVaoYaWlp1mMQFPPmzWukpqYamzdv1nMcPnzY4XukD2KOyjSmD9C49nvuucfumMGDBxvVq1e3C9AIbBa4vmLFihkTJkxw+nlxHShvaWvIkCFa+tDWK6+8kiFA47ElcDr6bLghQZlHBFgLBEjcWNwsQCOAT5s2zeFztgEacFMUExNjd8xPP/1k5M+fP8PvuWLFisYnn3xit69QoUJO34uIHGMXN/nMe++9p93Ps2fPli+//FK7Y2+ladOm1p9RmL5Bgwby22+/6WP8i+dtk7eaN28uFy9elD/++ENiYmKkdevW2sXduXNnTb46e/asV58B74n3sIXH+/fv1/Ffi9q1a1t/xvWhiz85OdnpedG9i25sW3v37pWGDRva7UN3fnoYKrB9v/R+//13TcZq3LixdV/hwoWlSpUqcqukNXRPY1hg9OjReh53oCsbvwsMLaBr3bIdOnQow7kwBIFxeCJyHQM0+Qz+KB8/flzS0tJ8MpXoVsLCwmTp0qXyww8/6PjsRx99pEEJASKz5ciRw+4xgjQ+tzNRUVEe3zwguGVGhjkys3ft2iUdOnSQFStW6Hc4b948l1+P4IzxbmR222648Rg8eLDdsciUxzg1EbmOAZp8Ai24xx9/XLp27Sqvv/66tsxu1qK0WLdunfVntL43b94s1apV08f4d+3atTqdyOKXX37RpKbSpUvrYwQutHCRxLR161ZtbToLMnjOthXsCN4T72ELj2+//Xa9IfBU3bp1Zffu3Xb7cDNhScqy2Lhxo9vnrlixot4wrF+/3roPNwP79u275WvxuQYNGiRLliyRhx56SKZOneryd1evXj05efKk9nxUqlTJbsMNie2N29WrV/U7ICLXMUCTT7zyyis6NxfTaYYMGaJ/+JHlfCuJiYkaUPfs2SP9+vXTwGJ53XPPPSdJSUnSv39/fX7+/PmSkJCgXbOhoaEakJBNjSCHzOa5c+dqRrklwKeH7Gu8Bq37M2fOOGzxvvDCC5p5jpsMBDhkVY8fP15efPFFr76f2NhYba3atqKfeeYZ/Vz4vvBeX331lTU72p0WM7qVe/fura1WtIR37typWd74jm7W5R4XF6dZ7EeOHNGbENwc3Oy7Q88EWsj47lJSUrRrHEMQyCZHgMf3iux9/Ldge+Px008/SYUKFfRGgojc4GRsmshlSLRCNjWShmyTwJBA9PHHH980SWzGjBlGo0aNNMkJiVgrVqywO27VqlVGw4YN9fkSJUpoYhWSyQCZ37GxsUbRokWNyMhITVD76KOPnCaJISu7SZMmmjyF98Y1pE8SA2SV41qQPY3M6HfffdfumpAk9v7779vtQwKVJbvcGXzOiRMn2u2bP3++UalSJb3+li1baqIZrufKlSsOk7WcfTYkiiFxDVnvxYsXN9555x2HSXEWKSkpxqOPPmpER0frd1uyZEkjLi7O6fsiEezhhx82ChYsqNdnyWpHxn7//v319fi+cL7HHnvMOHr0qPW1bdu21Ux3InIPVxIjv0BrCytMoVsaq10Fg++//15buWjhOmvdvvnmm7o8JnoOsgP0GmBuNHoIMntxFaLshiuJEWURJGMhG/zYsWMSHR2t+z7++GPN5EYmNLqZ3333Xe16zi5OnDghn3/+OYMzkQcYoImyUPriFQjYb7zxhmY5Y0UyjIEPHTpUsguMUxORZ9jFTUREZELM4iYiIjIhBmgiIiITYoAmIiIyIQZoIiIiE2KAJiIiMiEGaCIiIhNigCYiIjIhBmgiIiIxn/8HrBOjwso/iXQAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -1279,24 +1048,35 @@ ] }, { - "cell_type": "code", - "execution_count": 56, - "id": "49", + "cell_type": "markdown", + "id": "54", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, + "source": [ + "Figure 7. Spatial distribution. Probability at each lattice site. Obtained by summing over all the velocity probabilities at each site." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "55", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "# Map pixels to real x/y coordinates\n", "plt.imshow(\n", " p_u_xy,\n", " cmap=\"viridis\",\n", @@ -1320,10 +1100,18 @@ }, { "cell_type": "markdown", - "id": "50", + "id": "56", + "metadata": {}, + "source": [ + "Figure 8. Velocity magnitude distribution. Obtained by summing over all the lattice sites for each velocity magnitude. " + ] + }, + { + "cell_type": "markdown", + "id": "57", "metadata": {}, "source": [ - "## Analysis \n", + "### Analysis \n", "\n", "The simulation starts with particles placed at lattice site $(x_0, y_0) = (1,2)$, and their velocities are distributed uniformly — meaning each possible speed is equally likely at the beginning. We apply periodic boundary conditions, so particles that leave the domain on one side re-enter from the other. In addition, a reflecting obstacle is a rectangle with the corners situated at $(2,1)$, $(2,5)$, $(5,1)$, and $(5,5)$.\n", "\n", @@ -1335,10 +1123,10 @@ }, { "cell_type": "markdown", - "id": "51", + "id": "58", "metadata": {}, "source": [ - "## Technical Background\n", + "## Part III - Technical Background\n", "\n", "\n", "### Classical methods\n", @@ -1359,7 +1147,11 @@ "and $\\mathbf{F}$ represents external body forces.\n", "\n", "\n", - "The nonlinear and multiscale nature of these equations imposes significant computational demands on classical solvers. For standard discretization-based approaches, the per-time-step computational complexity scales as $O(N_x^d)$ where $N_x$ is the number of grid points per spatial dimension and $d$ is the dimensionality of the system. However, resolving all relevant turbulent scales requires a grid resolution that scales unfavorably with the Reynolds number, approximately as, $Re^{9/4}$. Consequently, the total computational cost of direct numerical simulation (DNS) grows effectively exponentially with $Re$. Moreover, classical Navier–Stokes solvers are difficult to parallelize efficiently because enforcing incompressibility introduces global dependencies that prevent fully local computation. \n", + "The nonlinear and multiscale nature of these equations imposes substantial computational demands on classical solvers. For discretization-based approaches, the per-time-step computational complexity scales as $O(N_x^d)$ where $N_x$ is the number of grid points per spatial dimension and $d$ is the dimensionality of the system. However, fully resolving all relevant turbulent scales requires a grid resolution that scales unfavorably with the Reynolds number, approximately as $Re^{9/4}$. Consequently, the overall computational cost of direct numerical simulation grows nearly exponentially with $Re$.\n", + "\n", + "The Reynolds number is a unitless quantity that measures the relative importance of inertial forces to viscous forces in a fluid flow. Turbulent flows correspond to high Reynolds numbers, where nonlinear interactions between scales dominate the dynamics.\n", + "\n", + "A further challenge lies in parallelization: enforcing incompressibility introduces global constraints that couple the velocity field across the entire domain, hindering the scalability of classical Navier–Stokes solvers and preventing fully local computation.\n", "\n", "### Kinetic Formulation\n", "An alternative, microscopic viewpoint is provided by the Boltzmann transport equation:\n", @@ -1399,7 +1191,324 @@ }, { "cell_type": "markdown", - "id": "52", + "id": "59", + "metadata": {}, + "source": [ + "### Figure codes" + ] + }, + { + "cell_type": "markdown", + "id": "60", + "metadata": {}, + "source": [ + "#### Figure 2" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "61", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [], + "source": [ + "import matplotlib.patches as patches\n", + "\n", + "\n", + "def plot_2d_grid_with_obstacle(\n", + " Lx=4, Ly=4, obs_x_start=X_LOW, obs_x_end=X_HIGH, obs_y_start=Y_LOW, obs_y_end=Y_HIGH\n", + "):\n", + " \"\"\"\n", + " Plot a 2D lattice with a rectangular obstacle.\n", + "\n", + " Parameters\n", + " ----------\n", + " Lx, Ly : int\n", + " Number of lattice sites in x and y directions.\n", + " obs_x_start, obs_x_end : int\n", + " Left and right faces (inclusive) of the obstacle region in x.\n", + " obs_y_start, obs_y_end : int\n", + " Bottom and top faces (inclusive) of the obstacle region in y.\n", + " \"\"\"\n", + " # Basic sanity\n", + " assert 0 <= obs_x_start <= obs_x_end < Lx, \"Obstacle x must be within [0, Lx-1].\"\n", + " assert 0 <= obs_y_start <= obs_y_end < Ly, \"Obstacle y must be within [0, Ly-1].\"\n", + "\n", + " # Generate grid coordinates\n", + " x_sites, y_sites = np.meshgrid(np.arange(Lx), np.arange(Ly))\n", + "\n", + " fig, ax = plt.subplots(figsize=(5, 5))\n", + "\n", + " # Draw lattice sites\n", + " ax.scatter(x_sites, y_sites, marker=\"x\", s=60, zorder=3, color=\"k\")\n", + "\n", + " # Draw obstacle as shaded rectangle\n", + " rect = patches.Rectangle(\n", + " (obs_x_start - 0.1, obs_y_start - 0.1),\n", + " obs_x_end - obs_x_start + 0.2,\n", + " obs_y_end - obs_y_start + 0.2,\n", + " linewidth=1,\n", + " edgecolor=\"r\",\n", + " facecolor=\"tab:red\",\n", + " alpha=0.35,\n", + " label=\"Obstacle\",\n", + " )\n", + " ax.add_patch(rect)\n", + "\n", + " # Cosmetics\n", + " ax.set_xlim(-0.5, Lx - 0.5)\n", + " ax.set_ylim(-0.5, Ly - 0.5)\n", + " ax.set_xticks(np.arange(Lx))\n", + " ax.set_yticks(np.arange(Ly))\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(True, which=\"both\", linestyle=\"--\", alpha=0.4)\n", + " ax.legend(loc=\"upper right\")\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(\"model_scheme.png\")\n", + " plt.show()\n", + "\n", + "\n", + "# Example usage: 8x8 grid, obstacle in the range x in (x_low, x_high) y in (y_low, y_high)\n", + "# plot_2d_grid_with_obstacle(Lx=8, Ly=8, obs_x_start=x_low, obs_x_end=x_high, obs_y_start=y_low, obs_y_end=y_high)" + ] + }, + { + "cell_type": "markdown", + "id": "62", + "metadata": {}, + "source": [ + "#### Figure 5" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "63", + "metadata": { + "jupyter": { + "source_hidden": true + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import math\n", + "\n", + "# === Create the figure and axis ===\n", + "fig, ax = plt.subplots()\n", + "\n", + "# === Draw the reflecting object (red square) ===\n", + "# The square is centered in the figure with semi-transparent red fill\n", + "square = plt.Rectangle(\n", + " (0.25, 0.25), 0.5, 0.5, linewidth=1, edgecolor=\"r\", facecolor=\"tab:red\", alpha=0.35\n", + ")\n", + "ax.add_patch(square)\n", + "\n", + "# === Add first arrow pair (top-left corner reflection) ===\n", + "# Solid arrow: incoming direction (up-right)\n", + "arrow_start = (0.3, 0.8)\n", + "arrow_dx, arrow_dy = (0.1, 0.1)\n", + "ax.arrow(\n", + " arrow_start[0],\n", + " arrow_start[1],\n", + " arrow_dx,\n", + " arrow_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"black\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflected direction (down-left)\n", + "arrow2_start = (arrow_start[0] + arrow_dx, arrow_start[1] + arrow_dy + 0.05)\n", + "arrow2_dx, arrow2_dy = (-0.1, -0.1)\n", + "ax.arrow(\n", + " arrow2_start[0],\n", + " arrow2_start[1],\n", + " arrow2_dx,\n", + " arrow2_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Add second arrow pair (upper-left side) ===\n", + "# Solid arrow: incident from top-left toward the object\n", + "arrow3_end = (0.16, 0.84)\n", + "arrow3_start = (arrow3_end[0] - 0.1, arrow3_end[1] + 0.1)\n", + "arrow3_dx = arrow3_end[0] - arrow3_start[0]\n", + "arrow3_dy = arrow3_end[1] - arrow3_start[1]\n", + "ax.arrow(\n", + " arrow3_start[0],\n", + " arrow3_start[1],\n", + " arrow3_dx,\n", + " arrow3_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"black\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflection opposite to incident direction\n", + "arrow4_start = (arrow3_start[0] + arrow3_dx + 0.01, arrow3_start[1] + arrow3_dy - 0.07)\n", + "arrow4_dx, arrow4_dy = (-0.1, 0.1)\n", + "ax.arrow(\n", + " arrow4_start[0],\n", + " arrow4_start[1],\n", + " arrow4_dx,\n", + " arrow4_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Define helper for rotation (used below) ===\n", + "angle_rad = math.radians(90)\n", + "\n", + "\n", + "def rotate(dx, dy):\n", + " \"\"\"Rotate a vector (dx, dy) 90 degrees counterclockwise.\"\"\"\n", + " new_dx = dx * math.cos(angle_rad) - dy * math.sin(angle_rad)\n", + " new_dy = dx * math.sin(angle_rad) + dy * math.cos(angle_rad)\n", + " return new_dx, new_dy\n", + "\n", + "\n", + "# === Add third arrow pair (lower-left side, rotated 90° CCW) ===\n", + "arrow5_end = (0.16, 0.64)\n", + "arrow5_start = (arrow5_end[0] - 0.1, arrow5_end[1] + 0.1)\n", + "arrow5_dx, arrow5_dy = rotate(\n", + " arrow5_end[0] - arrow5_start[0], arrow5_end[1] - arrow5_start[1]\n", + ")\n", + "\n", + "# Solid arrow: incident direction\n", + "ax.arrow(\n", + " arrow5_start[0] - 0.03,\n", + " arrow5_start[1] - 0.155,\n", + " arrow5_dx,\n", + " arrow5_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"black\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflection (opposite)\n", + "arrow6_start = (arrow5_start[0] + arrow5_dx + 0.02, arrow5_start[1] + arrow5_dy - 0.06)\n", + "arrow6_dx, arrow6_dy = rotate(-0.1, 0.1)\n", + "ax.arrow(\n", + " arrow6_start[0],\n", + " arrow6_start[1] - 0.1,\n", + " arrow6_dx,\n", + " arrow6_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Add pair of arrows to bottom surface (center reflection) ===\n", + "# Solid arrow: incoming (upward)\n", + "arrow7_start = (0.35, 0.06)\n", + "arrow7_dx, arrow7_dy = (0.1, 0.1)\n", + "ax.arrow(\n", + " arrow7_start[0],\n", + " arrow7_start[1],\n", + " arrow7_dx,\n", + " arrow7_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed arrow: reflected (downward)\n", + "arrow8_start = (0.52, 0.2)\n", + "arrow8_dx, arrow8_dy = (0.1, -0.1)\n", + "ax.arrow(\n", + " arrow8_start[0],\n", + " arrow8_start[1],\n", + " arrow8_dx,\n", + " arrow8_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Add final vertical pair (top reflection) ===\n", + "# Solid: downward arrow from top\n", + "arrow9_start = (0.6, 0.93)\n", + "arrow9_dx, arrow9_dy = (0, -0.1)\n", + "ax.arrow(\n", + " arrow9_start[0],\n", + " arrow9_start[1],\n", + " arrow9_dx,\n", + " arrow9_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + ")\n", + "\n", + "# Dashed: reflected upward\n", + "arrow10_start = (0.64, 0.78)\n", + "arrow10_dx, arrow10_dy = (0, 0.1)\n", + "ax.arrow(\n", + " arrow10_start[0],\n", + " arrow10_start[1],\n", + " arrow10_dx,\n", + " arrow10_dy,\n", + " head_width=0.03,\n", + " head_length=0.05,\n", + " fc=\"none\",\n", + " ec=\"black\",\n", + " linestyle=\"--\",\n", + ")\n", + "\n", + "# === Final plot settings ===\n", + "ax.set_xlim(0, 1)\n", + "ax.set_ylim(0, 1)\n", + "ax.set_aspect(\"equal\")\n", + "\n", + "# Remove all tick marks and labels\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_xticklabels([])\n", + "ax.set_yticklabels([])\n", + "\n", + "fig.suptitle(\"Schematic of particle reflections at object surfaces\")\n", + "\n", + "# Optionally remove axis spines for a cleaner figure\n", + "for spine in ax.spines.values():\n", + " spine.set_visible(False)\n", + "plt.savefig(\"reflection_scheme.png\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "64", "metadata": {}, "source": [ "## References" @@ -1407,14 +1516,22 @@ }, { "cell_type": "markdown", - "id": "53", + "id": "65", "metadata": {}, "source": [ "[1] [Schalkers, M.A. & Möller. Efficient and fail-safe quantum algorithm for the transport equation. M., Journal of Computational Physics, 502, p.112816](https://www.sciencedirect.com/science/article/pii/S0021999124000652?ref=pdf_download&fr=RR-2&rr=984897380e483d7c) \n", "\n", - "[2] [Budinski, L.. Quantum algorithm for the advection–diffusion equation simulated with the lattice Boltzmann method. Quantum Information Processing, 20(2), 57.](https://link.springer.com/article/10.1007/s11128-021-02996-3)\n", + "[2] [Budinski, L.. (2021) Quantum algorithm for the advection–diffusion equation simulated with the lattice Boltzmann method. Quantum Information Processing, 20(2), 57.](https://link.springer.com/article/10.1007/s11128-021-02996-3)\n", + "\n", + "[3] [Todorova, B. N., & Steijl, R. (2020). Quantum algorithm for the collisionless Boltzmann equation. Journal of Computational Physics, 409, 109347](https://www.sciencedirect.com/science/article/abs/pii/S0021999120301212)\n", + "\n", + "[4] [Gaitan, Frank. (2020). \"Finding flows of a Navier–Stokes fluid through quantum computing.\" npj Quantum Information 6.1: 61.](https://www.nature.com/articles/s41534-020-00291-0)\n", + "\n", + "[5] [Itani, Wael, and Sauro Succi. (2022). Analysis of Carleman linearization of lattice Boltzmann. Fluids 7.1: 24.](https://www.mdpi.com/2311-5521/7/1/24)\n", + "\n", + "[6] [Wang, Boyuan, et al., (2025). Quantum lattice Boltzmann method for simulating nonlinear fluid dynamics. arXiv:2502.16568.](https://arxiv.org/abs/2502.16568)\n", "\n", - "[3] [Todorova, B. N., & Steijl, R. (2020). Quantum algorithm for the collisionless Boltzmann equation. Journal of Computational Physics, 409, 109347](https://www.sciencedirect.com/science/article/abs/pii/S0021999120301212)" + "[7] [Kocherla, Sriharsha, et al. (2024). A two-circuit approach to reducing quantum resources for the quantum lattice Boltzmann method. arXiv:2401.12248.](https://arxiv.org/abs/2401.12248)" ] } ], diff --git a/applications/cfd/qlbm/qlbm.qmod b/applications/cfd/qlbm/qlbm.qmod index 7de45b876..ccd10d099 100644 --- a/applications/cfd/qlbm/qlbm.qmod +++ b/applications/cfd/qlbm/qlbm.qmod @@ -1,10 +1,10 @@ qstruct PhaseSpaceStruct { - g_x: qnum<3, UNSIGNED, 0>; - g_y: qnum<3, UNSIGNED, 0>; + g_x: qnum<3>; + g_y: qnum<3>; v_dir_x: qbit; v_dir_y: qbit; - u_x: qnum<2, UNSIGNED, 0>; - u_y: qnum<2, UNSIGNED, 0>; + u_x: qnum<2>; + u_y: qnum<2>; } qfunc init_state2D_expanded___0(qs: PhaseSpaceStruct, g_dist_x: real[], g_dist_y: real[], u_dist: real[]) { diff --git a/applications/cfd/qlbm/qlbm.synthesis_options.json b/applications/cfd/qlbm/qlbm.synthesis_options.json index f5323ff51..19ae5c427 100644 --- a/applications/cfd/qlbm/qlbm.synthesis_options.json +++ b/applications/cfd/qlbm/qlbm.synthesis_options.json @@ -6,28 +6,28 @@ "preferences": { "custom_hardware_settings": { "basis_gates": [ - "u2", - "cy", - "u", - "ry", - "r", - "cx", - "u1", - "h", - "tdg", - "id", + "p", + "s", + "sdg", "x", - "sx", "sxdg", - "y", + "ry", "t", - "p", + "tdg", + "cx", + "rx", "rz", + "cz", "z", - "s", - "rx", - "sdg", - "cz" + "id", + "u", + "h", + "cy", + "r", + "y", + "sx", + "u1", + "u2" ], "is_symmetric_connectivity": true }, @@ -36,7 +36,7 @@ "optimization_level": 1, "output_format": ["qasm"], "pretty_qasm": true, - "random_seed": 2683937649, + "random_seed": 3217275041, "synthesize_all_separately": false, "timeout_seconds": 300, "transpilation_option": "auto optimize" From b4f139824c3746b431d363e6e56c54b3926d1857 Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Sun, 26 Oct 2025 11:58:15 +0200 Subject: [PATCH 4/7] updated qlbm notebook --- applications/cfd/qlbm/qlbm.ipynb | 156 ++++++++---------- .../cfd/qlbm/qlbm.synthesis_options.json | 30 ++-- applications/cfd/qlbm/reflection_scheme.png | Bin 0 -> 15793 bytes 3 files changed, 87 insertions(+), 99 deletions(-) create mode 100644 applications/cfd/qlbm/reflection_scheme.png diff --git a/applications/cfd/qlbm/qlbm.ipynb b/applications/cfd/qlbm/qlbm.ipynb index 668e7fabf..73c9dda11 100644 --- a/applications/cfd/qlbm/qlbm.ipynb +++ b/applications/cfd/qlbm/qlbm.ipynb @@ -61,7 +61,7 @@ "1. Initialization - the initial classical distributions and velocities are mapped to separate quantum variables. The $N$ lattice sites and $V$ velocities are each represented by a quantum variable, composed of $\\log(N)$ \"positional\" qubits and $\\log(V)$ \"velocity\" qubits, respectively.\n", " $$ |{\\Psi(0)}\\rangle = \\sum_{\\mathbf{x},\\mathbf{v}} \\psi_{\\mathbf{xv}}(0) |{\\mathbf{x}}\\rangle \\otimes |{\\mathbf{v}}\\rangle~~.$$ \n", "2. Evolution - repeated operatortion of $U_{\\Delta t} = U_{\\text{ref}} U_{\\text{str}}$ propagates the state in time $$ |{\\Psi(t = n\\Delta t)}\\rangle = (U_{\\Delta t})^n |{\\Psi (0)}\\rangle~~.$$ Streaming and reflections are obtained by a conditional shift operator, inducing the mapping: $|{\\mathbf{x}}\\rangle\\otimes |{\\mathbf{v}}\\rangle\\rightarrow |{\\mathbf{x} + \\mathbf{v}\\Delta t}\\rangle \\otimes |{\\mathbf{v}}\\rangle$, while collision can be performed by local rotations which mix the velocity states at each site.\n", - "3. Readout - measurement of global observables or a restricted number of local observables. In the implemented example, we consider a small number of grid points and measure the computational basis.\n", + "3. Readout - measurement of global observables or a restricted number of local observables. In the implemented example, we consider a small number of grid points and measure the full state in the computational basis.\n", "\n", "The algorithm has several variants depending on the specific physical scenario. For instance, reflecting objects may be absent from the medium and are, therefore, excluded from the evolution. In the example presented here, we consider the collisionless case, where the dynamics are governed solely by streaming and reflection. \n", "\n", @@ -548,7 +548,7 @@ "metadata": {}, "source": [ "### Streaming operator\n", - "The streaming operation receives the `schedule`, containing the streamed velocities at each time step. Conditioned on whether the velocity magnitude appears in `schedule[t]`, a sequential modular addition operation is performed on the associated grid variable $ |{\\mathbf{x}}\\rangle |{\\mathbf{v}}\\rangle \\mapsto |{\\mathbf{x}+\\Delta \\mathbf{x}}\\rangle|\\mathbf{v}\\rangle$. Finally, the ancilla and velocity registers are restored to their initial state. The operation manifests a conditional translation of a specific set of positional states." + "The streaming operation propagates the particles based on the `schedule`, which contains the streamed velocity magnitudes at each time step. Conditioned on whether the velocity magnitude appears in `schedule[t]`, a sequential modular addition operation is performed on the associated grid variable $ |{\\mathbf{x}}\\rangle |{\\mathbf{v}}\\rangle \\mapsto |{\\mathbf{x}+\\Delta \\mathbf{x}}\\rangle|\\mathbf{v}\\rangle$. The operation manifests a conditional translation of a specific set of positional states." ] }, { @@ -623,21 +623,9 @@ "This is achieved by ensuring that particles incident from different directions never scatter into the same outgoing direction.\n", "Allowing multiple distinct incoming states to map onto a single outgoing state would correspond to a non-invertible transformation, thereby violating the unitarity condition required by the quantum circuit computation model.\n", "\n", - "A reflection operation is performed unitarily by a series of controlled operations, effectively reversing the appropriate velocity and placing the particles outside the boundaries in the appropriate lattice site:\n", + "A reflection operation is performed unitarily a controlled operations, effectively reversing the appropriate velocity of a particle colliding with the reflection object's boundary. The $y$-component velocities of particles reaching the upper and lower surfaces of the rectangular object and $x$-component, for particles reaching the left and right surfaces.\n", "\n", - "1. For particles (distributions) reaching sites within the boundaries, flag an ancilla register.\n", - "2. For flagged particles, flip the velocity direction qubit and shift the particles according to the normal direction\n", - "3. For the translated particles, conditioned on the velocity normal to the surface and position, reset the ancilla register\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "37", - "metadata": {}, - "source": [ - "Schematic representation of the two kinds of reflections — \n", - " corner reflections (top-left) and surface reflections (bottom and side surfaces):" + "A reflection operation is implemented unitarily through controlled operations, effectively reversing the relevant velocity component of a particle upon collision with the boundary of the reflecting object. Specifically, the $y$-component of velocity is reversed for particles striking the upper or lower surfaces, while the $x$-component is reversed for those hitting the left or right surfaces. As a consequence, the velocity of particles reaching the corners is reversed." ] }, { @@ -647,7 +635,7 @@ } }, "cell_type": "markdown", - "id": "38", + "id": "37", "metadata": {}, "source": [ "![reflection_scheme.png](attachment:28a38802-1e07-494a-a361-2b47b91c6ae9.png)" @@ -655,7 +643,7 @@ }, { "cell_type": "markdown", - "id": "39", + "id": "38", "metadata": {}, "source": [ "Figure 5. Schematic representation of the reflection types. Incoming and reflected particles are indicated by continuous and dashed arrows, respectively." @@ -664,7 +652,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "40", + "id": "39", "metadata": {}, "outputs": [], "source": [ @@ -732,7 +720,7 @@ } }, "cell_type": "markdown", - "id": "41", + "id": "40", "metadata": {}, "source": [ "![stream.png](attachment:517a2527-5749-4913-b4a0-3d1ab6dbc41a.png)" @@ -740,7 +728,7 @@ }, { "cell_type": "markdown", - "id": "42", + "id": "41", "metadata": {}, "source": [ "Figure 6. Implementation of the reflection operator within the main quantum circuit." @@ -748,7 +736,7 @@ }, { "cell_type": "markdown", - "id": "43", + "id": "42", "metadata": {}, "source": [ "### Building the quantum program" @@ -757,7 +745,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "44", + "id": "43", "metadata": {}, "outputs": [], "source": [ @@ -789,7 +777,7 @@ }, { "cell_type": "markdown", - "id": "45", + "id": "44", "metadata": {}, "source": [ "### Execution and results" @@ -797,7 +785,7 @@ }, { "cell_type": "markdown", - "id": "46", + "id": "45", "metadata": {}, "source": [ "We run the quantum program on a statevector simulator to retrieve the full solution." @@ -806,7 +794,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "47", + "id": "46", "metadata": {}, "outputs": [], "source": [ @@ -817,7 +805,7 @@ }, { "cell_type": "markdown", - "id": "48", + "id": "47", "metadata": {}, "source": [ "Taking a look at a small part of the results" @@ -826,7 +814,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "49", + "id": "48", "metadata": {}, "outputs": [ { @@ -864,63 +852,63 @@ " \n", " \n", " 0\n", - " 1\n", " 6\n", + " 2\n", + " 1\n", " 0\n", + " 3\n", " 0\n", - " 1\n", - " 2\n", - " 86\n", - " 0.041992\n", - " 100100110001\n", + " 85\n", + " 0.041504\n", + " 001101010110\n", " \n", " \n", " 1\n", - " 7\n", - " 2\n", + " 1\n", + " 4\n", + " 0\n", " 0\n", " 1\n", " 2\n", - " 1\n", " 79\n", " 0.038574\n", - " 011010010111\n", + " 100100100001\n", " \n", " \n", " 2\n", + " 4\n", " 1\n", - " 2\n", " 0\n", - " 1\n", - " 1\n", - " 1\n", + " 0\n", + " 3\n", + " 3\n", " 78\n", " 0.038086\n", - " 010110010001\n", + " 111100001100\n", " \n", " \n", " 3\n", " 1\n", - " 2\n", - " 0\n", + " 4\n", " 1\n", " 1\n", " 0\n", - " 74\n", - " 0.036133\n", - " 000110010001\n", + " 1\n", + " 76\n", + " 0.037109\n", + " 010011100001\n", " \n", " \n", " 4\n", " 1\n", - " 2\n", - " 1\n", + " 3\n", " 1\n", " 0\n", " 0\n", - " 73\n", - " 0.035645\n", - " 000011010001\n", + " 3\n", + " 75\n", + " 0.036621\n", + " 110001011001\n", " \n", " \n", "\n", @@ -928,18 +916,18 @@ ], "text/plain": [ " qs.g_x qs.g_y qs.v_dir_x qs.v_dir_y qs.u_x qs.u_y count probability \\\n", - "0 1 6 0 0 1 2 86 0.041992 \n", - "1 7 2 0 1 2 1 79 0.038574 \n", - "2 1 2 0 1 1 1 78 0.038086 \n", - "3 1 2 0 1 1 0 74 0.036133 \n", - "4 1 2 1 1 0 0 73 0.035645 \n", + "0 6 2 1 0 3 0 85 0.041504 \n", + "1 1 4 0 0 1 2 79 0.038574 \n", + "2 4 1 0 0 3 3 78 0.038086 \n", + "3 1 4 1 1 0 1 76 0.037109 \n", + "4 1 3 1 0 0 3 75 0.036621 \n", "\n", " bitstring \n", - "0 100100110001 \n", - "1 011010010111 \n", - "2 010110010001 \n", - "3 000110010001 \n", - "4 000011010001 " + "0 001101010110 \n", + "1 100100100001 \n", + "2 111100001100 \n", + "3 010011100001 \n", + "4 110001011001 " ] }, "execution_count": 14, @@ -953,7 +941,7 @@ }, { "cell_type": "markdown", - "id": "50", + "id": "49", "metadata": {}, "source": [ "Evaluating the spatial and velocity magnitude distribution, $p(x)$ and $p(u)$." @@ -962,7 +950,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "51", + "id": "50", "metadata": {}, "outputs": [], "source": [ @@ -995,7 +983,7 @@ }, { "cell_type": "markdown", - "id": "52", + "id": "51", "metadata": {}, "source": [ "Propagating the dynamics for nine time time-steps, we obtain the following spatial and velocity magnitude distributions:" @@ -1004,7 +992,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "53", + "id": "52", "metadata": { "jupyter": { "source_hidden": true @@ -1013,7 +1001,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1049,7 +1037,7 @@ }, { "cell_type": "markdown", - "id": "54", + "id": "53", "metadata": {}, "source": [ "Figure 7. Spatial distribution. Probability at each lattice site. Obtained by summing over all the velocity probabilities at each site." @@ -1057,8 +1045,8 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "55", + "execution_count": 17, + "id": "54", "metadata": { "jupyter": { "source_hidden": true @@ -1067,7 +1055,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1100,7 +1088,7 @@ }, { "cell_type": "markdown", - "id": "56", + "id": "55", "metadata": {}, "source": [ "Figure 8. Velocity magnitude distribution. Obtained by summing over all the lattice sites for each velocity magnitude. " @@ -1108,7 +1096,7 @@ }, { "cell_type": "markdown", - "id": "57", + "id": "56", "metadata": {}, "source": [ "### Analysis \n", @@ -1123,7 +1111,7 @@ }, { "cell_type": "markdown", - "id": "58", + "id": "57", "metadata": {}, "source": [ "## Part III - Technical Background\n", @@ -1191,7 +1179,7 @@ }, { "cell_type": "markdown", - "id": "59", + "id": "58", "metadata": {}, "source": [ "### Figure codes" @@ -1199,7 +1187,7 @@ }, { "cell_type": "markdown", - "id": "60", + "id": "59", "metadata": {}, "source": [ "#### Figure 2" @@ -1207,8 +1195,8 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "61", + "execution_count": 18, + "id": "60", "metadata": { "jupyter": { "source_hidden": true @@ -1279,7 +1267,7 @@ }, { "cell_type": "markdown", - "id": "62", + "id": "61", "metadata": {}, "source": [ "#### Figure 5" @@ -1287,8 +1275,8 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "63", + "execution_count": 19, + "id": "62", "metadata": { "jupyter": { "source_hidden": true @@ -1508,7 +1496,7 @@ }, { "cell_type": "markdown", - "id": "64", + "id": "63", "metadata": {}, "source": [ "## References" @@ -1516,7 +1504,7 @@ }, { "cell_type": "markdown", - "id": "65", + "id": "64", "metadata": {}, "source": [ "[1] [Schalkers, M.A. & Möller. Efficient and fail-safe quantum algorithm for the transport equation. M., Journal of Computational Physics, 502, p.112816](https://www.sciencedirect.com/science/article/pii/S0021999124000652?ref=pdf_download&fr=RR-2&rr=984897380e483d7c) \n", diff --git a/applications/cfd/qlbm/qlbm.synthesis_options.json b/applications/cfd/qlbm/qlbm.synthesis_options.json index 19ae5c427..494d44dbd 100644 --- a/applications/cfd/qlbm/qlbm.synthesis_options.json +++ b/applications/cfd/qlbm/qlbm.synthesis_options.json @@ -6,28 +6,28 @@ "preferences": { "custom_hardware_settings": { "basis_gates": [ - "p", - "s", - "sdg", - "x", "sxdg", "ry", - "t", "tdg", - "cx", + "sx", + "z", + "u", + "t", + "p", + "r", "rx", + "s", + "u1", + "u2", + "x", "rz", - "cz", - "z", + "cy", "id", - "u", "h", - "cy", - "r", "y", - "sx", - "u1", - "u2" + "cz", + "cx", + "sdg" ], "is_symmetric_connectivity": true }, @@ -36,7 +36,7 @@ "optimization_level": 1, "output_format": ["qasm"], "pretty_qasm": true, - "random_seed": 3217275041, + "random_seed": 1756940809, "synthesize_all_separately": false, "timeout_seconds": 300, "transpilation_option": "auto optimize" diff --git a/applications/cfd/qlbm/reflection_scheme.png b/applications/cfd/qlbm/reflection_scheme.png new file mode 100644 index 0000000000000000000000000000000000000000..d97e02231c68c88f84d2b95eeaa778de7fb87973 GIT binary patch literal 15793 zcmeHuS5#D8m+dKn5)_djDxw4hB}x{MAR?fM1SxV7BuB|Pih@cIlpq;Va?V9Y1rd=P ziz0~RC`gbZ+*RLyM?ZDn(cMpX^ymkMNS!+8?7i1sYpyxx4pV)gaFXIY1%eD|j88Eco*BLq5S>$Q>1RoDt;IBf<|VTRO`MK_r>(%H7iN zNLs;>*Y!Ie9UW;Uo>9vvH@tlMwfdXw3~n7>dfnx_aoj8|1L&~K%z0MX%Xef$?_HtM z%6_W(f_tR*qrr#oN83LBN2!~M4=fVIEM~uN_>DPK-JVP8O7QHmkV;LMs~hjgQoTw? zaSmRhPVGj|N%&W$nH3>I5RYdF8G=lnBVtC701L7J_#}npKmMRaY;XSk%Km0omCMGb zQ_|Y$vLVZV=TiB)@wf)xS_5~St7eJG9rvTEaj(1&Et~#Z16o<14?8;KLs7KZOtjV4jx2N`(uD$8RYh+i{{tdL{slHsOC9uD_@P%1EOi*V~#Q_u;c zxsreHE$84zWk&DilD6+0eD!~#CE+z*I*b`ERyQZ}} zYuxXRR%VT` z@Q@uMl3z>^bugSy3#OuAf~Te9*BYh&d>8C`y0^1-$r@W}mn|QDUTtDrO@WEtdZ^Ig zDt!*l+TYy&=)irxOZw=<3a++F2HRKs=#y#;yRvM%`Ec=vKvz9G9_Z2#Zv;cufCf{Uextu-Et-8*01jV7RysRu{Kzs7gy|dh1NALTR^wF{7B{I zZ#kti5^l@I!Kb8dwAsC2;InVHTpO?7-kI>n-a5`i*R#DeROEit<@4aOdg&@wBRbnz zOwDa&bSC2OfzSPkGAv)!I-|aG&G0tmvEV<7GEy@G&Y@M)aYmV?aj5C)rob}+1Cme zpLDrTwS?R@^7(y7t}1cB^h89+GG{XFT!lDz-T+(dpwghi8lCNn-%e+X zyxD8_-j1(!xwLz>Gtqf$?vmebx{X4G^}v{OzO!yu4W|mKLNc!{E>Z2he8>Zc9QRuB z=ib}P3lTZ_oB^r6+dA{F1b;Z(6@#~nn=s|cG8L=c6v?ulgoom6j2*qj zyMBl-<#%V?c_~oYzUX=CVp#)G^MOjzjUMzKr&i$wPL1rS+JohYIYpyWPTtE?XzMNJ zg^HUus8;JXAM9*8mYH`t)iauXdqd9Tv);UVxK=ZlV!J~d%}C!w_u+|us?SCkBn>0@sGv)4}H90sd1A(o2n-KmRjlDmIgb+B|KMa=Ef$s_O_Pv zRz@puBCxjQXLxjnVc(lbdi^Q(-=Dr@zuzahGiKU&u#H8T{x*c=z?NA=;(RtcE3Nw2 zz30=PFZU|(Rlp#z$1nL9Lz;`LH44|On~sne^F1aMQRuSJ>xN&csy)i9Kfv!)73fus zLJk-cfyu9c_Z^1ZU>kXJBNU%d+4&>-ic-E#nYm`ZHh=Bm-VzQu7|7GYVjUV+a&t%i zZgxrI0$eM$J|^0iE)L{j^NJc4whX zvsfLg5wYsMTssr1r(ZE2#*tF&{6nnm47YaF@3Gw8yo0fvhaB$M^K?hQVpK391==Mo zkW?!s?6#Lj`fx?tahw5jDc*$zx)tBpA0*9h_nlU_@Y)nB^!g5d0p6h0rl@}Kf#jA3 zw)jzSJw&;^(Q*IO5!eF-cVpP?Z!Y58CssHki|RIB9Bif@mAA)mV81XJ+18wsaLdmN znE%^zcvY)VU#<$<;Onh*t>otcVrZ`Pa-6T?NOT|rsBwFC(fCKP%^m9J&$lr zzHLzJ<~mnAzu#**T<={a(Ixa(ac-_Z=OL~nCnack{;Z~ikRf`dn?K80t*gY3L%d5^ zeih!`70*rMRo}DpL&qX{#@>78+gtmI#TzN24k_5UKuCa}B(=N@x;H=0q5aExsN7g$kL0Lr7esM~6Go?w2qJb=60Qc%13r zX8xQyUan17v&}iP==kfTw%p>S;fMIG-3n=;S=F}Eh$Z9Ru$KXJ6`410cF`vDUSRH32FM+L^x|stylE=W#V=@_Cd=2W z`r(_qimP>R?GhSSP2JacLgo%zq_#2}!*Cd8koxLV9`#;%c515Aw`=K*hkIPpbIB6! zZmBmvNk4g}#XhJA`9$vd_jYKzQ`wTa(Rq9HNm;kd=AY6& zAX^!)moUY?W>dhV@)=bZ2yAI>kAz{5vYFt4BzM&ORj)i4+}r3Qi&8c zU&+v4C3)_OYp18$-oLsiIeJjgn)otzV^6BiDYUpYVE7k9L_X5Dv9OmJ9hK;nPOm59&JMnY^IWbz$-P+agx_m`wrcP_zIi6U zw}y-q>brze)mL)E;zyFtB|$MJrL0sx zOrFp&jS;o2J8v(b9a{{XJB9J#fhT_SOxB(F!NUXT!CYMw72S8dwF%suXf-=XXC$ilq4}GyXQ9L z3Y_Q4m47aMNi6Ko7ISo4;gAdZzIm(8fj_iVBCNpZgu`F**92 zID4J>C;7bu?8Q9n$*gJZKkRXTMJzhsy?x^SSIoThz3H7x`2roQ+TVPr7Lra#Yn3+& z-8cCj&%au&ikug=){vX~3j1vA`Z3osuBVH?Z9)|cyGqu#E&N_lxV2qy{*H<)a+>*e z{JwhcZ@!TN?AcEK*Kwv|qI*pRQ=;OR=w}CJm=14=@nwiv{44gC^t)~BW)IHZJl^bA zw_MtxA6GkgLvrIQo54;QW{f;I=OurD70ebz@LuoTycdB|1EhRUUw=y))cEjKdA71`(X9-l9B%c{Otfr$(Iw-KlOfe5sWDP9 zv<00pI>8Ti{z{*Uw5#do(u~E@A7?aqi;Ikvto*t*k`$7#ccM+p+PYZ9ML38g9V9e*rAo24#Di*FE80cv-NKC zWp^fucJ2NJXr4M}e*t|-E_G~EU_m|xRnGS*FW{C|xnHW*En&{2V@5X2?%njcsJTVf zUPfOT+AA449yi{t@=A8~tY#S><=WhgZBw{uuNA36z*^IG@?PKN${bwtE!E}B|4PRG zVJ|E?+MkoQ4+_W?eyv{ByYHi>YN%^fA334^_ZU6PR-WSo^zNz zD6sGUu0)?>Ky&|ddl&!d_L8Ky!byM+HSL;v>TmDUatmF%N*0jYZ|>@sOLV@$XoIzP zC|L1gZDr5(48g9OfpJkeVv5;D$BXJ$K5wQ}Qi$9cf`t_B#GJN*;HL`52 zpN&TcYkpM+%Vk}d&2qpcc)Oy?rJ9q{U0e0rzPrQ2br)#~_2i~hvU7rwL;porv*&9L zq+Dp@Ef1o12?d)HjjaFFl_g;V^n^ux@a}g2q}Yp)Xd7F z^4;LIEh~fIRpC{6JIy%x2XTSDm0o2%rh`o`E2ff$Jb`H+9H_*8MctIv4DV56CO0|; zkCvCg>qQzFNK%kdoH}n?^g)7^zAj?%<*UeJg(60Z zYm4$|q+6=z;CbYylO&NUD+49D*um-VFSg&evMucnILW`u{%D;RVUwKNd}BPo@Oi&) zu5a%4lK!9{nwiRom%XS>?s8k{b}+lxymxYk*SOHRt9eg6&s!AOyM|W`PAqQ8&t(`s z{KVySo+}GKAf@`X*Q1V{mi@6t>L%O2_Q(%Z_)K4~2q*XauvV1D9bM_6=e}FqIiYF1 z#-tu-PxMy5bFS}csdVydmwWo6UW=~PZAR$5sn#sewLcdo$hbZDyOJhJ zhl{1yvw+x3mi^hU^{#5Ye1A*{XDNYuV2s~hN#`}dRGUe%>X7MD9$1Ib+ZD}dmS?*) z`W-mo=0=N#^qs@K>%7KvgIM#-*fI=`v1^m*Dro`Q-=sU-4f>)Vj33+tWN-1j0s0)` z*mqy8rJwZ)Na>Pkc1ZoI)Gj$Q+pzF4acsN!XYr`{r)MX{R*iU^d}iKiJ>%5OKMOzc zcs%q&(tiNz&s6i3N|#gFuI>_UI}q9(=|ShoqKnnl2@SLMe6mcHE&zR@;S@l2~jBx2}vXr4|E^u29>R zN9Fg!&)gkU*VMhJ*kQ6T0i?@k6xP}^(HP~xla}9>fD^c`!!sR&`+Z?y=~iZ>K@s-$ zb1K)aJL?zI?^GP8x^Q;1)a)g8wti=v(!izX&T55r)%zoxzlGnGf>>PXdi`mbWKl*r zrJmE_qUIWj$OXj#!7cOb#kVy*gDc+9&u>>;C`zSNC1Od%n&W4*l6` z8HvQ1CpiOzt^XqUDE@Pt-+!GY{2%iT#cXIjvB#(`SjKRu zJaBo4G%<$ArmJ4<2}dR!c5V7ThSx)D=XUsaj?lg*&$FWf7_t!}#rQ;fOnXQp(3w(^i5(yAyq^&G=`jPFJ}$La({paxMN*M73!-om*l zhrW->o{QT9$DcyWr2FCC+vO39)bQI%DCUFH$ZHpXjdEo7Kdl4#F*E}F&c=m97sm5^ z9)#wA_c2bsJ^D%~2cw8>G4LIiG3St81Vw!}j5^*B2nu_>D*Fn^d-0knFWC33@aF{0 zwUfnNmp3~2s*L>pesN{AnRU#1ko>)h!n59ME90=1(CTEXypErmA00liVhHG;9?IiTr-EB?_+(pW%@|(vnokcs+D>$6D2ZT_!0-nHaokZY zc}+btlrltD=KO2&GsB0gwQIIGjBA)ZRlsE#M6Q>OYbHTvDgF=JKc;#5@vF0UW%$w+HeyI+xLDVSlbD#*y`(7=A&|^{y!6WWXq|^OrRc23&9(Lx$dV z`lDpb!q<;clX7aNik_v7ucMW6qV#uyC+PwkV}RzP(OvzZk}75Rys@tPt-6rmMp5J8 zx7~!4ROpoX%;#7G`sEP0z`{pvi#b`N4^<>9CK%NXPZK?KZg~z2-%&B3F@Mc;SyIsw zHc{XgOUCQH+cG<)dY(qAf4HYpV)8}6?<4QtCI9`NSRTFD?n;y*HxV<%_f-EwD_}E9 zmkI~a7Yw~uDtxq9$O6MY6pjH|QS-#J$8cO(t0MF=NiL=HWK*C$D{+Rz#JKN{0mE(! z@b@kE;&?l4jhmcFWa#1vlyQjfmbw3*9);R-8Dh$Gp>!<8lh>;G4C{vXwpVN%>bGLC zYdwZoQL;cb`Bz_^+T)n_(FM8#UVr9K2W#SIAfDY>)MXZuQVTN5EIHo8&d^gB#7h*Vk9xHI~Ga z=0B+(swaFa(0#GBvYn}H7 zFhHm39UUInZTxCKrxg-fsi;i$>J-oFP2fkX&N}CRGGZnR%tfjkCdPp}pe@_R%i(6v zn%D41Y(B-6eLab5E_rW13`ufS z`slAp?RpF4rjLYJi1g<|N^RU9OkpXJw_7Z)fi)-%PXuear0~n}RrE4W?}I>q7Ty4H0UDXUj@vol5l zeSb5z&L*5Zu^WbjKIJ{(+s5Qxok#OnLCdfE7j?MA!#lTex_eUUPn-5tcH^adF?c_? zz1vro=f4&z$^1zb%9gHZ>&`*#DF#BTcE+guM9g791tVJd=Jv2D&XE#1guVO7#r1dr zTNXLnT^wnz0 ztdqJxr|e^As&wjlTu?{T)4pGvXng-nUPluOp_jS*W)Rhn@n3w_Tm2!wC6)91d-?Fv zqJ}+Aqn$fft_z%B%1V<2*+#FzntqBe{BZ*(8RD;ol54RN2+j4^WftGRM=dUtht8WF zJkjsv2%>=Z{nf~O#@o0C_X*!BNr-Lef-%_O7Z1zH{M*r}esw;~=#M9DOmRh=;sJkd zL85mhKdyEBbV!5ot7r_XaH!-N*i-Hyr&^4D5~p$NmVXUD4uFq#x?2FrdB$seIsExW zudk%fnIznXDf#Lq$A8JcIy=Rwo>6FmrZf#)ojiKJ9(OocWVBZJsdLL8MM4&!cpe)6 zDuM|4KsLsurL9XQ@^j@W{3%GEHvXw}UDDj~ zKbeIfux3_Qqg+?VMqpJfpnyBaky7frjhL-|Bc(jUT@3kQ6n4~wGW`8H>g*R*pc9Sd zkLPn6HH@L33r*cdy^efZmx%DU30<<<4{_ z>(3a$2s~vUvD}Y0SLd3~*&qOK443x>*M7CZ3Y(#u6UV1cA?l}~>T~$8JDTe@iJYY! zhH@io%u8zx`srF>N(R5*gzrvrG7yK`YyL-AU;l*C=6RC|5$m*x3^pjqqXi1-|cr|RHU9%I3%ve>7pQunKH>_ zmM`>W)fN&c=F#s7f`S;f>5>O&=FAf=eah#s7yNdo?4Q{=8Vo$nc=E=qBev7E{*GOi zjetVgq#&*#r-~{q#X&h&d}qvg1t{m250{WknpTAM13?#Y8!~Vo0S)F62ni9`_@?a@ z>>9)2FKBeXYG;ZkSmvBE*mMOcam4=pde+t%;WNb!6Ah=2Q?wXa_wttj9pVkumj*|N z+zmoP-(*pYrQHhtDbD{3l;sfj^zBIaS17}G^7Ly;2|{h*%NtepCa_<*bxJQ|r$`gp zHWtJNWEV!R>F*v%E!h|-BGl$6HXgf)2AneWUl2FOv|t~x9qPF*Sx3v2XFV&-(u2-g zNyK^f`x9ETGraoq+hMKy1E8l3HL~qr`2j@ga`kjX87M9a<@K1~5Ik)cEc}RNZa@{O zq`j>{-qG=yS~;z|x&f3w-Pf#lSoaw1hO$&HDZLpfv%msFHqHL=X`k69Z^N!hl}~6; zT4BlkT_wMnjyQL8E#MR^fff9{1)Xqh8pB~(+F~*`Ugad(0~%$DWqw4_UITeOD8yb2 zD0_9{JZ*f9jSvTrjLx^NS92#}wAsi_fIj+2e>wbi|CMoI1t&4bDn!y-*1FT7XoTcx z7L>vm==4E4Lk5F^BVxj@lNJ(=pt-^8whEAQ)INiUdQPQp-^0MmpbQ>0c&q{>EYBAQn zwzIz7CeW5tT1|^}if>Dw05yNNUBb48GnV0I0fawk%c|@QV?X)|!0X(m8vURt@c0>Tnob6cS@!LdnBqJ?5_uPr)wf>x#a3+bt z0^)3A>J_vaWcL{WP41W2p`<0-R(XO}YkrF!0 zJ+fbF8F3`LMB{a4zrAaZeG(?hGr13QfZ7{S5(Qjrn~5{B z2cYL@dYEx%SIKa3G@0M@SzcskQd^j`Besz-s4Ewih{LgD#tjJCmVqRw-3>}-=Faatw4 zuM7&xV2cgLD=3%i{NvQrFcuvirWns4#nSFqk689UJR<;}bkZqY)5EL>70`a@LaL`7 z6+v=dB4lehco83yP>e#~$YgWy3NS~k`ya?cqzg6~E+ShF%794ZhQ(50ISqs#kTgt`U)grG}>JX~(bj7@V$6kD>a> z(C1*a=?v#VBN|ofpm5RPE+f}o@ftJ7h`TOUQyBa4G9Lf@o+6tf?M%pE5->*nPo`IS4SZXY(IydUZuEno{E7KuXl<*7hlNsdt@=I^I1R*8mfRDvCrvr}S|cf&CaPHB-U^n}X{CZPoNrX^KK&rHv`;jc-^h=T95WHe<)mA$02RZ`HKsqjkAU{K3Pi137-IleN zuvJBN!^O>{b<38^spdx)!B9s!Di7C$A!H6$=j(sBG7dr&)T{S$mGgfHZkVNsM*lJF zF+}DTE7C$q;H^F?Cyus+P!>2&eVvuEk_h<%P9}lX6=EcfnV<5k;c%U2neXo}44T=h zEO>}Yw!K7x!_XBXMNt&q6bLX15wmY}q90XQu8WSELxb)Hg7FzeJc3+RgbSu&yS%(g zvgnS^({zoIMi4~>`0F_$=XZbeCQdSm_fv__rxDpPA_!^7UFP*4ug(c>=WT~PzoopN zZBScj07#qMnh8OEE09tf)&Le2DBR_TW}O%lEPU(N)bmRb9v{~ssVokXC4sSUZ1e;o zldpz)8aK5Di(CPmnl`A#%b>YCX`$5Sp+ion0LM`VRhWid-)V2t{d{(k@k|f*6!2`-jdtB>fp|Q4y4nu-5rmpc1DUehrM&vJ6LKkl|5+jf z`+nv8yx@5^;1)DvU!ai83s6g_`~#ulD%_k^!8I)Mrd)qS1lT<)dY1`U*MnCoue(@4O{Sg_#P*bEg`03dA3{s7;mijj#D`N==4GSF~EDRvkT zbiz6;93zQLW{Agw-Lv57Om-dA`R5hd19*)y>$IOY{@t8g6P=odSdY9b0au@atIIvU zZxgyX!In$35Q7V$aBaTF{aw`|2WWU~e|`>o^_LjQHfJ%GeGXCfBnXauokpTz}{I-a{lqe^blw(;T9N*j`0cRUh9@N z=mo~mQgFX7@euN*gk=i<%cWmkT)+GC7K8c<5%bSN@F@&}Gc&t&|JpLZrLWJZm=-Y}9QWfVgVJI>tU%RD z-2G?0po190o;=5H+PY1uL3%;NHr{Tmx(9TruY|#E1QJO562CmHqRNL4#J*5T@2?;DWl`U7TONM3 zCXHVfwCPT}MWjoP$XJ`6V2=J4dYWwvW?_Vn|$OXNi9k$`e2wU=MX z{u3HNnpMG%9@vlVfO4`w7Z37!&FUm{e;k+u7!nf^GtDgIn=)9`8hZouUyRFw2{ciS zXz1j6lwmvtAZc_j9ay^+wHSfpIDUWdpgDxy z=JD@V_5ZNk|L+I?d1&;%bM@b!tA|2xq=PzHR>Do2AWi;s)F-}rgG7cIO~+?X0J=1Z zqKONXih|+|u1Un9ji6wLnh-^Cx~&Rf>m_;$ke|1wivA5M6Bgn=5kT$#CzAbdFIQ+U zP+2R`_f~?fmaRt_6>#$!9Yu(&C;lO_-UnQzEtKXbpsKDl7O1An68ZzV5KyX%c(jX~ z41Ko-vJXE#`t-~VtcTV9c{F6eyTYe@1^P9;1O)|j+Db?R*tNzZdr*18cGq@RuojT( z%0TiT1|y5HD9$B@AiF-X6GT2!pr`}1{O~KHj5i$9!p{k|f~(04XwNdB`w5KJ`7OI^ zB)q_u>Q-2rz2(xX1OsvuH5v02K>Qw$;8cW&?eKN)U#}JN<-%wR_o~2~PdJK#_Xk9@ z>4ODxU@=gKLkHeKDLs`z?nd$lAibl2fDGpIz}OakmcIp!r`r{GnV-xJ0NT%@p(Pc1 zJ$BRk#x+hewm{V38g264`_}BCokR{hNB-g;5c`Givi5R zGqHotR6MO$Zuy$fu=^ej>N$LwJdMcg(}hpl5z7SjWyiup+Q1QiQ4czY3Q#~?dk7M< zDdU0ulp|OMG$B*Qj}^&ITBQ2UvOm)Yr|zm7-0+tB^?=OJXJrs8)5HD0|FDx#Q3}8u zOt5X+^k?^=us{O;0AI?C`T7|yP43yZZD7kDy%MKy0#jcOhWFD%sLM>40959eXkK8* zT^I^K6xTCEQA7hlWtO9ej|~%w zABYVl5FZm5x0OX%ZOuPU?ycu6s`K2lb-ORho;bh~`l_g2p|UDqZ0&o$ zB#Ala69hv0DqtD&0P{l$!6{Q*yP8X42xisopD+1F!C!7bs$Ld_Vtx(0NF7-q_|D3= z=6gPYjs4}T8C?ni66?-p&>ye{P7z@&2u(Ob#%w2R42KfJt#CjqACfUO-M{`C3 zQS5eP?sh#u4%%!*SeVW-K!6zk31EUNeerHK1G#T011bD;PZe8qrP%KqW%vSeJx6;R z=!7@(v&cG~K@-x;zAw4?UC<3Q{uNPn=nkLRZx`QZZ=Hcmb`qF$6T)c>D9&BcVX~7CRV5<)TrX94PkQxGn+PIC8YivxPjCReY>4@N1k4oZ=Cnf}`y;BX=k)~I8 z->i^?a1x}GY#f|6wO-`7X5?oeyu`v^>O&$p98|>v=5T`wxwp-*!D)z4pD(~fM88v+ zQYq(tb>_uj&>+yitF_)EXZe~B6cJ?x@(FLIHbZ$+yGGT zxx^rur@?d+9kDjW2Lzz*bzMqb_qFk4{y=1du<$w5how}39dUeBuvv5nM{ov|$>1{} z<(RFg51mB3w`~d561=F^2~^Z2fE;%N*BK5zM}bhJmmpw9gX2c7h2CXGXd>1baKM_- zvOWBGza7L=Y-Nehi2&Qv2)UetTXJH@MM2ggT9g3?kt0=R=h3aB(`w zgRSHKN4~K0wozEil_r8+B$ivp1dyGwq6F$P0}t1w#pE#=2bEqGHvq(ux+i>pTpV)+j`0|t*d4(dOHhS8)TX1|A zbO2o#Qa-3Em5>N7R9zCXj5>g-Bm&(%kqsM69^6(GF7Eji;kq<90*6TK2q%07veiC8 zYaO?;y;na-TnFw5%JO6+nigW}XVAKqqu;@n7NOV>yaAAFf93`fpf|cDe|fAX#{M6p z0K%`ZtHd3?qgP@Qa`K$O=O1EoNe6?dBuVc|0`F^&YXYL^3fz_EIj=Fo55#dDlq($w zjb)%S$^b!QgGea_{Iaf?meYL?KoQdb>k>wIU%{u1zq+&4*b*h&3zd__2Y624K%f&f zR0Y>2HLx#@jC|D)9RRpxf}kg5W(VTj3c5D1@TJy#n}GePKT`zRqfj8*l~|acB)}h5 zdm|i3-g0IaD4PbRtI8 zMeqwPgFB%TjwgxtbfUog@h?Lg!3Fo9KhgR>#;f*UKFj<6`N)m^{vIJx=)MR3DVlx2 Pr6PClJdi7tH4gee%`Y|x literal 0 HcmV?d00001 From b837981c392e4362f6fcf45df908c98739a152f8 Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Mon, 27 Oct 2025 11:15:49 +0200 Subject: [PATCH 5/7] updated link in qlbm --- applications/cfd/qlbm/qlbm.ipynb | 179 ++---------------- .../cfd/qlbm/qlbm.synthesis_options.json | 34 ++-- 2 files changed, 31 insertions(+), 182 deletions(-) diff --git a/applications/cfd/qlbm/qlbm.ipynb b/applications/cfd/qlbm/qlbm.ipynb index 73c9dda11..6e300b9fa 100644 --- a/applications/cfd/qlbm/qlbm.ipynb +++ b/applications/cfd/qlbm/qlbm.ipynb @@ -497,7 +497,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfMAAADvCAYAAADmbD0fAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN6BJREFUeJzt3Qm8TPX/P/D3XNe+yxLZCZElS7ZsUYpEFAkpkq9dRHxlS0IhJVEJ8UskkfS1lOxL9n3LThHZrqz33jn/x+v9/Z75z8yd4c7cWe6583p+H+dr5sy5Zz7zmdO8z2e3GYZhCBEREVlWVLgTQEREREnDYE5ERGRxDOZEREQWx2BORERkcQzmREREFsdgTkREZHEM5kRERBbHYE5ERGRxDOZEREQWx2BOYbVq1Sqx2Wz6r1W98sorkilTppC8V+HChfX9/FG3bl3dAq1Ro0bSqVMnSa6GDRum19jff/8tVuL+XS9dulSvswsXLoQ1XZQ8MZgnQ3v27JHnn39eChUqJOnSpZMHHnhAnnjiCZk4caLLce+9954sXLgwbOkkWr9+vSxfvlzeeuutBJnx119/yZtvvimlSpWSDBkySMaMGaVSpUry7rvvypUrVxzH4QYDwdbTdvDgQZebvu+++y5iM/2pp56S4sWLy6hRo8KdFEqGosOdAHK1YcMGqVevnhQsWFBLO/fff7+cPn1aNm3aJB999JH06NHDJZgj6Ddr1syy2Vi7dm25efOmpEmTJtxJIT988MEHUr9+fQ0yzrZs2aIl9n/++Ufatm2rQRy2bt0qo0ePljVr1uhNgCl//vweg1S+fPn4vTjp3Lmz3iANHz5cMmfOzLwhBwbzZGbkyJGSNWtW/THMli2by2vnz5/3+7zXr1/XklFyExUVpbUPZD24Hn/66SeZMmWKy36Uup977jlJlSqV7NixQ0vm7tf4F1984bIP1zyCPt1dixYt9IZ+3rx50qFDB2YXObCaPZk5evSolClTJkEgh9y5czseo8oRAfqrr75yVEma7WtmG+H+/fvlpZdekuzZs8tjjz3m+Nv/+7//05JS+vTpJUeOHPLiiy9q6d/Z2rVr5YUXXtAagrRp00qBAgXkjTfe0FK0p/biU6dOyTPPPKOP0SwwadIkR5PB448/rjcSaDaYPXv2PdvMUe368MMPa/pRS4EqWpzz/fffT5AnJ0+elGeffVbPj/xBGpctW5aodvhr165J7969tW0SnxF/j+aM7du3uxz322+/aSkT+Yj3KVeunNaSuPvjjz+0lgR5kCtXLi1BxcfHuxxjt9tlwoQJ+h3jJiZPnjxa2rp8+bLLcVjMENXRKLHi8yMf9u3bl+A9ze/a3YwZM3T/iRMn7poHt2/flqFDh2rJ2vye+/fvr/vvBYE8Li5OGjRo4LL/s88+07wYP358gkAO+Mxvv/22hBrazFu2bClZsmSR++67T3r16iW3bt1yOWb69Ol6veJaQH6ULl1aJk+enOBcqGFo2LCh5MyZU/87KlKkSILgGujvGpAuXH8//PBDQPKEUg6WzJMZBLyNGzfK3r17NaB5M2vWLHnttdfk0Ucflddff133FStWzOUYBOMHH3xQq+PNlW5RKho8eLD+qOHv0ZkGbfGo7kYpyryJwJ3/jRs3pEuXLvrDt3nzZj3uzJkz+pozBKynn35az4GA+/XXX0v37t018A0aNEjatGkjzZs31xLcyy+/LNWrV9cfv7vBDx7aCPF3SCvaStEuW7ZsWX0vwM0MfnjPnj2rP8xoksDNwsqVKxOV1//617/0vEgrfrQvXrwo69atkwMHDkjFihX1mJ9//llvUvLmzet4D7y+ePFife6cB/hxr1q1qowdO1Z++eUXGTdunH4nyEMTfswRaF999VXp2bOnHD9+XD755BPNe7Q/p06dWo8bMmSI/sDjJgIbbjCefPJJuXPnjgQKgg1uhPCZcQ099NBDevP14YcfyuHDh+/ZHwNNQrg2cM06W7RokQY4NAElFvLPvYMaAmAgOxbiOsKNG6rz0Wz18ccf63U2c+ZMxzEI3Ai+yJfo6Gj58ccfpWvXrppX3bp1c9RI4LvADduAAQP0vxncNH3//fcu7xes7xo34uwrQwlgPXNKPpYvX26kSpVKt+rVqxv9+/c3li1bZty5cyfBsRkzZjTat2+fYP/QoUMRuY3WrVu77D9x4oSed+TIkS779+zZY0RHR7vsv3HjRoLzjho1yrDZbMbJkycd+/D+eK/33nvPse/y5ctG+vTp9dg5c+Y49h88eFCPRfpMK1eu1H3411SnTh3dN3PmTMe+27dvG/fff7/RokULx75x48bpcQsXLnTsu3nzplGqVKkE5/Qka9asRrdu3by+HhcXZxQpUsQoVKiQfiZndrs9QR688847Lsc88sgjRqVKlRzP165dq8d9/fXXLsctXbrUZf/58+eNNGnSGI0bN3Z5n3//+996nPN3bn7X7qZPn677jx8/7pKv2EyzZs0yoqKiNF3OpkyZon+7fv16424ee+wxl89nyp49u1G+fHkjsczv231z/pzmdTJv3jzDV2YePfvssy77u3btqvt37dp11+u+YcOGRtGiRR3PFyxYoH+3ZcsWr+8ZjO/ahP/W8Npff/2V6DyglI/V7MkMqnlRMkfJYNeuXVrSRYkP1cwo8fgCJU9nKDmghIESCkpB5obSJkrwziValKxMKAHjuBo1amgJHyULdyjlm1BSKVmypJbM8V4m7MNrx44du2faUSJzbkNFBznUQjj/LYbqIF+QV86lucQOk0JaUIX+559/enwdnxOlKVTFuzd7eKrads/vWrVquaQXNRpoG8Z37Jz/KGnh85r5j1I9SmVoG3V+H6QjkJAelMZRFe6cHtR2wL1qOFCTgaYHdzExMT53zkKJGbUgzhuq+wPJLFmbzM6k//nPfzxe91evXtX8qFOnjn6PeA7mtYDamdjYWI/vFczv2sxzqw21o+BiNXsyVKVKFQ28+I8cAX3BggVa9Ylqy507d2qVcGK4V2X//vvvGowRuD0xq/0AbeCo/sMNhHsbn/mj5hxAUeXoDD9kaAN0D3rY734+Tzz9LX7Edu/e7dJejmps9+Pce1Z7gxul9u3bazsxfmRRxYlmgKJFizr6L8DdmjvulgdIr/NnRf4j75z7Pnjq4IjPBe7fE87vKXj6C+lBk4F7ut3Tczdm840ztEmjP4IvcOPn3vbuC1TTu4+/Rn8Q51ES7vmJawcdMJ37FaD6G30IcEONZiZn+O5w/SK4oyMaepTjv0v08UBfCfRPQTt7sL9rM8893VBS5GIwT8bwQ4TAjq1EiRLa9oY7fvzYJIZzKQNQKscPwJIlS7SnsTuzfRI/jChRXLp0SdupUXLDjy06NaHDG87jzNO57rbfUwAI5N8mFmoNUHrGzRKGSWGY1ZgxY/RGymyXTyxv6XWGfMOPO/oUeOItqN6Ntx9094533tKDPgjoqOYJbnLuBu3lnm7McL3gphM3o6EacogOnO43ryj93m2SHPe8w80bhtkh/cgTfH6kHyV3BG3zujfHu6PdHW3q6HCJzm/oI4F9+O8oGN+1ycxzdL4jMjGYW0TlypX1X3T2Mvl6Z46SCIIhfvRwc+ANOkGhAxR6yqOkakLVZ3KCjlfo8Y7P5JwXR44cSfQ50LENHZywobSEjm/oJIhgbnYoRGfEpJQaTTgfqlVr1qyZ4EbLmdmhDKU7s5YAUPJ0D55m6Q3DwZybAswS373Sg5ofBDB/SnkIevPnz0+wv0mTJlqyxWutW7eWUEBTkfv1Wb58eZfnyE/ngI/rBEEXVfyAwIxe/KiNwigOk7fmhmrVqumG6wUdL9HRc86cOdrkFIzv2oSmHwTypNwQUMrDNvNkBj8cnkqfZrse2p1NKC07z6R1L+gZjhIkqgfd3wPP0QbqXMp0PgaPPQ3HCif0JUBtgXNfAgw1ch/D7K3k6t5cgJIUJikxh2UhsOPHH8OL3PPZnxoC1ATgfUeMGJHgNQzxMt8DNw5o8sDoAef3QTrcmTccmITFZA5ZTEx6kH+e8gtDEHGeu8GoBAQc9z4Q6DuAm6S+ffvqTaE73DSh93YgoZkD+ea8uVdTm8MlTeaMimYtjKfrHtcIhqs5w2d2//4rVKig/5rXTjC+a9O2bds074mcsWSezKAjDNrqMOkGSj6oqsQQoLlz52oJAlXtJrTz4u4fVYIIQgg8GBrlDX748SM6cOBAbSdEOx86KuFOH1XNGJ5kTr+JY/EYP/ZoA0UpKzFt3aGEoT8Y6oPSH4aJIYCgWtOchOZupU206aJdHv0QUIJD1SjyEpP1oLoU0J6KoUooaeLHGnmP98AUoxgHjOpVX6CtFWnG0ChUQ2P4EX7IUSpD8wlulpAec4w6jsOwOLTlozMemkfcq1ZxDpQiO3bsKP369dOANG3aND0H+j3cTbt27eTbb7/V4IubSJQiEYDw+bAfn8+sEfKkcePGOnwL+WYOjwQEUVxPSDfyzXkGOAy7+uabb/wORrgOzSlenZl9H+4G1zk6S2LII2oOMN8C2rnNEjzyEtXq+L7xPWH2Otzo4CbPuUYMN0qffvqp/jeK/05wLeE4/HeCzxys79q8EUK/EffOfEQcmpbMLFmyxOjQoYMOr8qUKZMOWylevLjRo0ePBENRMNSrdu3aOgzMeRiLORTnwoULHt9j/vz5OqwIQ9uw4b0wROvQoUOOY/bv3280aNBA05AzZ06jU6dOOoQH58WwJxPeE+fwNNyoTJkyCfZjmBeG4dxraJqnv8V74e+dHTt2TM+HPMiVK5fRt29f/Xw456ZNm7zmM4a69evXT4dQZc6cWT8DHn/66acJjl23bp3xxBNPOI4rV66cMXHixHvmgbdhY59//rkO6UKacc6yZcvqEMQ///zTcUx8fLwxfPhwI2/evHpc3bp1jb179+rndx+utG3bNqNq1ap6rRQsWNAYP358ooamAYY8jhkzRvM7bdq0OqwMacN7X7161bgXDPeqX7++x9fwed544w2jRIkSRrp06YwMGTLouTEE0vnc3r5vZ+Z14m1zH17n6XvANf38889rnuNzdu/eXYcyOlu0aJF+v0hv4cKFNW+mTZvmkpfbt2/XYZ/Ia+RZ7ty5jWeeecbYunVr0L/ryZMnaz7GxMTcNb8o8tjwf7ynoZQEVZSYCQ4T3GDoGgUPZgpEJzOUlr2NkqDAeeSRRzS/0SGPyBmDOVka2nadOxihzRw/eKgu9tReS4GHNmc0WSSmrwL5D/MqoGoefRS8DXmjyMVgTpYPJGgzRtssOiuhHRTt2Wg7R3soEVEkYAc4sjT0aJ86daoGb5TGMaEOhge1atUq3EkjIgoZlsyJiIh8gKGgmGQKwwQx0gGjNzA6KJw4zpyIiMgHmIMBQxrd5y4IJ1azExER+dhXx9cpn4PN0sEcUzFixStMfMJFB4iIrAujpDEBDybAwoRNgXbr1i2va8Sb7+8eR7Bwjrl4TnJn6WCOQH6vWZ+IiMg6sGgOhjoGOpAXKZRJzp33vgARZoHErH/OsKjVsGHDxAosHczNNZMfk0YSLf9/+U4iokBYcHgPMzJEYv6xS6GKJxy/64F0584dDeRHthaQLJkTlvpjrtmleOXTeiOBaXlNVimVWz6Ym1UiCOTRNgZzIgosTz/8FFzBbDLNkNnQzV2czgosGsidg7mVWDqYExERJVasYZdYw/N+qwvrbScm+Rg8eLCu9oUpObECEZYM5HTxREQUaHYxJN7Dhv2+QNs6VsPDZq7Ih8f3WqkwxZbMx4wZo0tMYknBMmXKyNatW3WZyaxZs0rPnj3DmTQiIkphYgNUMkesqlevnuN5nz59HEvxzpgxQyIumGOd7qZNm+q6yID1urHW8ebNm8OZLCIiSoFixdDN035fYOW65FaDHNZq9ho1asiKFSscq1vt2rVL1q1b53Uw/u3btyUmJsZlIyIiSox4w/tmdWEtmQ8YMEADcqlSpSRVqlTahj5y5Ehp06aNx+NHjRolw4cPD3k6iYjI+uLEJrFi87jf6sJaMv/22291tavZs2fL9u3bte187Nix+q8nAwcO1GUuzQ1jAomIiBIj1rB53awurCXzfv36aen8xRdf1Odly5aVkydPagkcHQncWWlqPSIiSl7ixaabp/1WF9ZgfuPGjQRz8KK6HXOuExERBVKsEaVbwv3Wz+ewBvMmTZpoG3nBggV1aNqOHTtk/Pjx0qFDh3Ami4iIUqA4I5XHYB7HavakmThxok4a07VrVzl//ryultO5c2cZMmRIEs9MRETkitXsQYIJ9SdMmKAbERFRMMVqyTyVh/3eV1OzCs7NTkREEeGOkUpSewjmd9hmTkREZA12senmab/VsWROPlv2538XFyAispJYI1pL5wn3M5gTERFZvM1cLI8lcyIiigjxEqVbwv3Wj+YM5kREFDHV7LGsZiciIrKuOInyWM0ex5I5ERGRNcQbUbp52m91rGYnIqKIEGukkmiP1ezWbzO3/u0IERGRD73ZPW3h1qBBAylatKjff8+SORERRQS7l97s2B9uzz33nPz9999+/z2DORERRYRYI5WkSqbV7N26dUvS3zOYExFRRIg1orwEc3tY0nP69Gn9t0CBAkk+V/jrFoiIiELAbkR53UIlLi5Ol/7OmjWrFC5cWDc8fvvttyU2Ntbv87JkTkREESHOS2e3uBCWzHv06CHff/+9vP/++1K9enXdt3HjRhk2bJhcvHhRJk+e7Nd5GcyJiCgixNpTSZTdQzW7PXTBfPbs2TJnzhx5+umnHfvKlSunVe2tW7dmMCciIvJvbvbQVbOnTZtWq9bdFSlSRNKkSeP3edlmTkREEVPNHudlC5Xu3bvLiBEj5Pbt2459eDxy5Eh9zV+sZicioogQa4+SKHuUx/3B1Lx5c5fnv/zyi+TPn1/Kly+vz3ft2iV37tyR+vXr+/0eDObks4b5KjDXKCIs+3NnuJNAAWR46bmO/cGE3urOWrRo4fI8EEPTGMyJiCgixBo2sXkI3NgfTNOnT5dgYzAnIqKIEGekkiiPQ9NCPzf7hQsX5NChQ/q4ZMmSkitXriSdjx3giIgoIsQbNq9bqFy/fl06dOggefPmldq1a+uWL18+6dixo9y4ccPv8zKYExFRRIhDz3W7hy2EJfM+ffrI6tWr5ccff5QrV67o9sMPP+i+vn37WjeY//HHH9K2bVu57777JH369FK2bFnZunVruJNFREQpTLwRJXEeNuwPlfnz58uXX36pk8ZkyZJFt0aNGskXX3wh3333nTXbzC9fviw1a9aUevXqyZIlS7TN4Pfff5fs2bOHM1lERJQC2b30Zg/l3OyoSs+TJ0+C/blz505SNXtYg/mYMWO0S75zTz/MgkNERBRocUaUx97s2B8qmI996NChMnPmTEmXLp3uu3nzpgwfPtwxV7vlgvmiRYukYcOG8sILL2h7wQMPPCBdu3aVTp06eTwes+Q4z5oTExMTwtQSEZGVxdmjxOZhghjsD5UJEybIU089lWDSGAT2ZcuWWbPN/NixYzqp/IMPPqgfokuXLtKzZ0/56quvPB4/atQoHXxvboEYaE9ERJHBbti8bqGCfmFoTkY8q1Chgm6jR4/WfWXKlPH7vDbDMAx//9j8U5vNv4zApPKVK1eWDRs2OPYhmG/ZskWXhEtMyRwBva40lWhbar/SQETkDWeAC52Ya3bJXuKYXL16VTuFBfTcMTFaAGzwn84SnTFtgtfjrt+WXxp9FpT3dob1ykuVKiWLFy+Whx56KKDn9qtkjp54Dz/8sFYLYMPjqVOn+nwejLMrXbq0yz58wFOnTnldbcbs/WduREREiYHqdG9bKKROnVpu3boVlHP7/AmGDBkivXr1kiZNmsi8efN0w+M33nhDX/MFerKbM+CYDh8+LIUKFfI1WURERMm+mr1bt27a+TsuLi6g5/W5AxzauDEeDouom5599lldXL1Hjx7yzjvvJPpcuAGoUaOGvPfee9KyZUvZvHmzfP7557oREREFUryXDnDYHypoRl6xYoUsX75c288zZszo8vr3338fmmCOOn+0c7urVKmSz3caVapUkQULFsjAgQP1JgDD0tDTr02bNr4mi4iI6K50CFqYh6Zly5YtwappgeBzMG/Xrp2WzsePH++yH6Vpf4LwM888oxsREVEwGYZNN0/7QyVYK6hF+9sBDlUE1apV0+e//fabdlp7+eWXdd5Zk3vAJyIiiuRqdtP58+ddVk3DDHAhDeZ79+6VihUr6uOjR4/qvzlz5tQNr5n8Ha5GRAlxiFR4NMxXIUzvHHnijFjMPhLU97BjhTR7wtgUyg5wGCaHTnBz5syR+Ph43ZcqVSpp1aqVTJo0SYfQhSSYr1y50q83IiIiCie72PR/nvaHCmY43bFjh441N6dvxbwqGCXWuXNnDfIhnc71yJEjWjLHWqxY7QwTyLA0TkREyVU8qtPDXM2OII4ZTx977DHHPkxrjlFimObVXz5/gosXL0r9+vWlRIkSumzb2bNndT8WVk/KWqxERETBZLfbvG6hguW+PVWlY19SVgz1OZhjbDhmsUGHtwwZMjj2o75/6dKlfieEiIgoFL3ZDQ9bqLz99tvaUfzcuXOOfXjcr18/GTx4sN/n9bmaHb3YUUWAFV+cYbGUkydP+p0QIiKiYIpHCdxDKdxTp7hgwdBuNFMXLFhQN0DhGNOVX7hwQT777DPHsdu3bw9eML9+/bpLidx06dIlTQwREVFyZLfbPA5NC2U1e7NmzYJyXp+Dea1atXRR9REjRuhzdHqz2+3y/vvvS7169YKRRiIioiQz/rd52h8qQ4cOTR7BHEEbHeC2bt0qd+7ckf79+8u+ffu0ZL5+/fqgJJKIiCipDLtNN0/7rc7nDnBY7hQrm6FbfdOmTbXavXnz5jpurlixYsFJJRERURIZXnqyp4Rg7nPJHA31BQoUkEGDBnl8zWzQJyIiSk6MZDA3e7IpmWNlM/S48zT+HK8REREl52p2w8MWcSVzbzO9/fPPP5IuXbpApYuIiCigjBTcZp7oYG6uhoZAjoHtzsPTMFk8Vk6rUIGLEhARUTJmhPftnVcWdYbYigJx8eLFtT9ajhw5ghPM0cHNLJnv2bNH0qRJ43gNj8uXLy9vvvmmT29OREQUSSXzHTt26GQwKARj6VNAp3KsnFaqVCn59NNPdWr0devWSenSpQMfzM3V0l599VX56KOPJEuWLP58DiIiovAwbP/dPO0PEbPUPX36dEccvXr1qrz22ms6Sgyrqr300ks6dTpmWw1aBzjnBJhrsy5cuFAOHjzo66mIiIhCP2uM4WELkQ8++EAnXXOOo1hkZdiwYTqPC5qwhwwZItu2bQtuB7iWLVvqsqfdu3eXmzdvSuXKleXEiRNa/Y51WFu0aOHrKYnoHhrmY3+UcFj2586wvG8kirlml+wlUn41+9WrV+X8+fMJqtAxSgyFY8iWLZtOyuYLn0vma9as0SldYcGCBRrEr1y5Ih9//LG8++67vp6OiIgoYkrmTZs2lQ4dOmj8PHPmjG54jGXEzXnbN2/erMuMBzWY467C7GWHJU9REke1QOPGjeX333/39XREREQhYdOFVjxvoYJV0TAl+osvviiFChXSDY+xb8qUKXoMOsJNnTo1uNXsmP1t48aNGtARzFG1DpcvX+Y4cyIiSr7snpdA9bgvSDJlyiRffPGFfPjhh3Ls2DHdV7RoUd1v8meYt8/BvHfv3tKmTRt9Y0zdWrduXUf1e9myZX1OABERUcQsm/Y/iKHlypWTQPG5mr1r166yadMmmTZtmq6SFhUV5bizSEqb+ejRo3XQPG4WiIiIAs5+ly1EsDgZJl6rUaOGThCD2Om8+cvnkjlUqlRJNwRz9GZPmzattpn7a8uWLdqOEMi7FCIiImfe2sdD2WaO8eSrV6+Wdu3aSd68eT1Ojx6yYG56+umnZefOnUm6m8Cc7qi2RxsCe8MTEVFKrmZfsmSJ/PTTT1KzZs2AntfnanZnGJaWVN26ddNSfYMGDe557O3bt3UcnvNGRESUGCgD2wwPm4RO9uzZfZ53PejBPKnQEx5z1I4aNSpRx+M4zJRjbuhZT0RE5FNvdk9biGD2N8zwduPGjYCeN0nV7GjnzpMnj19/e/r0aenVq5f8/PPPiR7SNnDgQJcVZ1AyZ0AnIiKrVLOPGzdOjh49qrGzcOHCkjp1apfXUcANaTA/cuSI3HfffY7e7N7WOfcG885iSruKFSs69mEVGQxx++STT7RKHavIOENHO2xERES+stn/u3naHyrmLG+B5nMwv3jxorRq1Up+/fVXDd6Y9Q0d4DAVHdoCcNeRGJjtBkupOsOKbJj55q233koQyImIiKwezIcOHRqU8/rcZo5l2aKjo+XUqVM6jasJAR4zwiVW5syZ5eGHH3bZMmbMqKV9PCYiIgrKEqiGh83ifC6ZL1++XNdYzZ8/v8v+Bx98UE6ePBnItBEREVm+ZJ4jRw45fPiw5MyZU2uw79YkfenSpdAEc8xe41wid05AUtuzV61alaS/JyIi8spLMA/2DHCYhx210TBhwoSgvIfPwRzLn86cOVO71wPuMOx2uy6qXq9evWCkkYiIyLK92du3b+/xcViDOYI2Oq9t3bpVF0/v37+/7Nu3T0vmmN6ViIgoObIlgw5wJozmwobCsDN/pzX3OZijcxrq/jF8DNUGmI61efPmOpMb5pmllG/ZnzvDnQQiIkuOM9+2bZuWzg8cOJBgFlXUdGOIdsjGmWP2tUGDBvn1hkREROFg+9/0rZ72h0qHDh2kRIkS8uWXX+rEMWFdaOXWrVuye/duj1UEzz77bEASRkREFFCGl85uIQzmx44dk/nz5+vyp4HkczDHWPKXX35Z/v777wSvJaWKgIiIKKW3mdevX1927doV/mDeo0cPeeGFF3SieH/nZSciIorEavapU6dqm/nevXu1D5r73Oz+1m77HMz/+usvXeyEgZyIiCzF7qWaPYQl840bN+rIL6xrHsjabZ+nc33++ec5uQsREVm2mt3mYQsV1G63bdtWzp49q33OnLekNFP7XDLHkDRUs69du1bKli2boIqgZ8+efieGiIgoJQ9Nu3jxoq5xEujabZ+D+TfffKPzs2MNcky/6tytHo8ZzImIKDmyJYMOcJiXZeXKlVKsWLHwBnOMLx8+fLgMGDDAsZY5ERFRcmdLBsEcY8wHDhwo69atC2jtts/BHFO4YrlTBnIiIrIUI/zV7OjNnilTJlm9erVuzpJSu+1zMEeX+rlz58q///1vv96QiIgoUoemHT9+PCjn9TmYo7cdFlvBmuaYEN69imD8+PGBTB8REVGKqWYPFp+D+Z49e+SRRx7Rxxj07ixQc8wSEREFhRH+fD1z5owsWrRITp06pU3XgSgQ+xzM0QuPiIjIamzJoGS+YsUKneWtaNGicvDgQZ0F7sSJE7qCWsWKFf0+L7ujExFRRLAlg0lj0JP9zTff1FpuDPHGoiunT5+WOnXq6Bwu/opO7Li4GTNmSJYsWfTx3Xz//fd+J4aIiCgld4A7cOCAztcC0dHRcvPmTe3d/s4770jTpk2lS5cuwQvmWL/cbA/HY4psDfNVCHcSiEJi2Z87mdMpiT38c7NnzJjR0U6eN29eOXr0qJQpU0afe1qNNKDBfPr06XrXgKoBPCYiIrIaWzJoM69WrZpOGPPQQw9Jo0aNpG/fvlrljlptvBb0NnPM+vbPP//4/UZEREThZDMMr1uooLd61apVHXEV65tj7pbChQvLl19+6fd5E92bHT3tiIiIrMqWDErm6MXuXOU+ZcqUgJzXp97sgR5HPmrUKKlSpYpkzpxZcufOLc2aNZNDhw4F9D2IiIiSS292uHLlik7rip7tly5d0n3bt2+XP/74w+9zRvs6Qfy9ArqZsMTAvLTdunXTgB4XF6dTxD755JOyf/9+vWMhIiJKSXOz7969Wxo0aKCdyTG+vFOnTpIjRw5tM8ckMjNnzgx+MEf9fiB7sy9dutTlOYa/oYS+bds2qV27dsDeh4iIyJYMqtn79Okjr7zyik6LjlppEzrDvfTSS36f16dg/uKLL2qwDZarV6/qv7hL8eT27du6mWJiYoKWFiIiSmEMQ2x2D8XwEPYJ27Jli3z22WcJ9j/wwANy7ty54LeZB3vedbvdLr1795aaNWvq9Hbe2thRM2BuBQoUCGqaiIgo5U0aY/OwhUratGk9FkQPHz4suXLlCn4wD3ZvdrSdY+GWOXPmeD0GnQVQejc3TIFHRESUGLZ471uoYF52zNsSGxv73zTZbNpW/tZbb0mLFi2CH8xRcg5WFXv37t1l8eLFuohL/vz573pHgyllnTciIiKr9GYfN26cztmCeIqpXDEne/HixbX9fOTIkX6f1+dV0wIJpf0ePXrIggULZNWqVVKkSJFwJoeIiFIyw/DcPh7CNnM0Ef/888+yfv162bVrlwZ2rJaGHu5JEdZgjqr12bNnyw8//KB3JWbjPz5s+vTpw5k0IiJKYWxh7s2OqnXEtp07d2r/MGyBEtYlUCdPnqxt33Xr1tUJ580NU9sREREFks1ueN1CIXXq1FKwYEGJjw98I33Yq9mJiIgiZQnUQYMG6QRps2bN8joM23LBnIiIKFKq2eGTTz6RI0eOSL58+aRQoUIJZjvFtK7+YDAnIqLIEG+IRBme94dI06ZNgzJvC4M5kQUs+3NnuJMQkRrmqxDuJESMOAPjro8F9T1sXqrUgzslmqthw4YF5bxh7QBHREQUKR3gzCVQL168KJ5WUnNeHtVXLJkTEVFEsHkJ3KEM5lgpzVNvdqw7cubMGb/Py2BORESRwf6/zdP+IFu0aJHj8bJly1xWIEVwX7FiRZImTmMwJyKiiGALY8m8WbNm/30vm03at2+fYPx54cKFdapXfzGYExFRRLCFMZhjfRNA6RvLoObMmTOg52cwJyKiyGCEf27248ePB+W87M1OREQRwRZveN2CbePGjbo6qLOZM2dqSR0rqL3++uvaCc5fDOZERBQRbGEcmoY1zPft2+d4vmfPHunYsaOuljZgwAD58ccfZdSoUX6fn8GciIgiq5rd8LAFGVZKq1+/vuP5nDlzpGrVqvLFF19Inz595OOPP5Zvv/3W7/OzzZyIiCKCze65Sj0UJfPLly9Lnjx5HM9Xr14tTz/9tON5lSpV5PTp036fnyVzIiKKDHYD3co9bMEP5gjkZue3O3fu6IIq1apVc7x+7do1HaLmLwZzIiKKrElj7B62IGvUqJG2ja9du1YGDhwoGTJkkFq1ajle3717txQrVszv87OanYiIIoLNbhebh/VOsT/YRowYIc2bN5c6depIpkyZ5KuvvpI0adI4Xp82bZo8+eSTfp+fwZyIiCKD3cuC5iEI5pgkZs2aNXL16lUN5qlSpXJ5fd68ebrfXwzmREQUGexe1jsNQTW7yXlOdmc5cuRI0nkZzImIKCLYwljNHmwM5kQW0DBfhXAnISIt+3NnuJMQMWKu2SV7iSC/SbyX3m6639oYzImIKEIYXiaICd3c7MHCYE5ERJEh3i5ihKcDXLAxmBMRUWSwxyOie9lvbcli0phJkybpwuzp0qXTuWo3b94c7iQREVGKnAHO8LxZXNiD+dy5c3WS+aFDh+r0duXLl5eGDRvK+fPnw500IiJKSezhm841xQfz8ePHS6dOneTVV1+V0qVLy5QpU3SaO8yGQ0REFDDx8d43iwtrMMdk89u2bdP1XB0JiorS51jI3R0Wbo+JiXHZiIiIkvsSqCk6mP/9998SHx/vsiwc4Pm5c+cSHI+F2zF7jrkVKFAghKklIiLL92aP97JZXNir2X2BlWYwr625JWXtVyIiiiyGYfe6WV1Yh6Zh4nlMNv/XX3+57Mfz+++/P8HxadOm1Y2IiMhndi/jzFNAMA9ryRzLv1WqVElWrFjh2Ge32/V59erVw5k0IiJKaeJTbge4sE8ag2Fp7du3l8qVK8ujjz4qEyZMkOvXr2vvdiIiokAx7HYxPCy0khKq2cPeZt6qVSsZO3asDBkyRCpUqCA7d+6UpUuXJugUR0RElJw6wE1KRhOehT2YQ/fu3eXkyZM69Oy3337TTCEiIgokI94uRny8h81u+QnPkkUwJyIiCjrD7n2z+IRnYW8zTwrjfwP94yQ2JaxgR0TJcI1tClFe/2N3+V0Phtj4W2J4WGhFYwjS4DYRmbcRVOaEZxgunZgJz0LB0sH82rVr+u86+U+4k0JEKVD2EuFOQeTB7zomBQv0yKn7779f1p3zHisyZcqUYCIyVKEPGzbMpwnPDh48KOFg6WCeL18+nTgmc+bMYrPZxEpwB4gLB+nPkiVLuJMTEZjnzPNIYNXrHCVyBHL8rgdaunTp5Pjx41qivtv7u8cRK81rYulgjmqN/Pnzi5XhPzYr/QeXEjDPmeeRwIrXeaBL5O4BHVs4JjwLBXaAIyIisviEZ5YumRMREYVDcpvwjME8TNAWg84VVmqTsTrmOfM8EvA6D92EZxcuXNAJz7DKJyY9C+eEZzYjmOMAiIiIKOjYZk5ERGRxDOZEREQWx2BORERkcQzmREREFsdgHkS+Lo83b948KVWqlB5ftmxZ+c9/OE1tYq1Zs0aaNGmis0dhFqeFCxfe829WrVolFStW1N6/xYsXlxkzZiT6/Uhk1KhRUqVKFZ2BMXfu3NKsWTM5dOjQPbOG17n/Jk+eLOXKlXNMCIMxzUuWLGF+E4N5sPi6PN6GDRukdevW0rFjR9mxY4f+MGLbu3cvL9NEwPhO5DFuoBIDUzs2btxY6tWrJzt37pTevXvLa6+9JsuWLWN+J9Lq1aulW7dusmnTJvn5558lNjZWnnzySf0uvOF1njSY8XL06NG6yMfWrVvl8ccfl6ZNm8q+ffuY35EOQ9Mo8B599FGjW7dujufx8fFGvnz5jFGjRnk8vmXLlkbjxo1d9lWtWtXo3Lkzvx4f4bJesGDBXY/p37+/UaZMGZd9rVq1Mho2bMj89tP58+c171evXu31GF7ngZc9e3Zj6tSpzO8Ix2r2IDCXx8NyeIldHg/7nY8HlOTDtZxeSsf8DryrV6/qvzly5GC+hwBW7ZozZ47WhHibQpTXeeTgDHBB4M/yeJhByNPx2E+B5y2/seLUzZs3JX369Mx2H2BeajRV1KxZUx5++GGf853XeeLt2bNHg/etW7d02c4FCxZI6dKlmd8RjsGciJIMbefo37Fu3TrmZpCVLFlS+3mgJuS7777T+cHRf8FbQKfIwGAeBP4sj4f9yWk5vZTOW36jhzBL5b7p3r27LF68WEcU3GtJYl7ngVmxC6MvACt3bdmyRT766CP57LPPmN8RjG3myWR5POx3Ph7QQzhcy+mldMzvpENfQwRyVPP++uuvUqRIEeZ7GOC35fbt2x5f43UeQcLdAy+lmjNnjpE2bVpjxowZxv79+43XX3/dyJYtm3Hu3Dl9vV27dsaAAQMcx69fv96Ijo42xo4daxw4cMAYOnSokTp1amPPnj1h/BTWce3aNWPHjh264bIeP368Pj558qS+jrxGnpuOHTtmZMiQwejXr5/m96RJk4xUqVIZS5cuDeOnsJYuXboYWbNmNVatWmWcPXvWsd24ccNxDK/zwMJ1jNECx48fN3bv3q3PbTabsXz5cuZ3hGMwD6KJEycaBQsWNNKkSaND1TZt2uR4rU6dOkb79u1djv/222+NEiVK6PEYNvXTTz8FM3kpysqVKzWIu29mHuNf5Ln731SoUEHzu2jRosb06dPDlHpr8pTf2Jzzkdd5YHXo0MEoVKiQXrO5cuUy6tev7wjkzO/IxiVQiYiILI5t5kRERBbHYE5ERGRxDOZEREQWx2BORERkcQzmREREFsdgTkREZHEM5kRERBbHYE5ERGRxDOaUrBQuXFgmTJiQbM9nBSdOnBCbzaYrawUDzr1w4UK//37VqlV6jitXriQpHa+88oo0a9YsSecgSikYzCkgmjRpIk899ZTH19auXas/3rt37w55bmNFqddffz1ggcgKChQoIGfPnnWsKx6o4BkoNWrU0PRlzZo13EkhSjEYzCkgOnbsqKu8nTlzJsFr06dPl8qVK0u5cuVCntu5cuWSDBkySCTB8rtYajQ6OjrZriqI9OEGg4gCg8GcAuKZZ57RwDljxgyX/f/884/MmzdPgz2sW7dOatWqpWuGowTZs2dPuX79utfznjp1Spo2bSqZMmXStcZbtmyZYB3yH3/8UapUqSLp0qXTteSfe+45j9XseAx4HYEEz1ElHRUVJVu3bnU5J/6mUKFCurykJ/jbd999V15++WVNG45dtGiRXLhwwZFe3Lw4n/fixYvSunVreeCBB/QGo2zZsvLNN9+4nPfatWvSpk0byZgxo+TNm1c+/PBDqVu3rvTu3dvlvd977z3p0KGDZM6cWQoWLCiff/65x2p2PK5Xr57uz549u+5H9bR73pgqVKggw4YNczz//fffpXbt2pq3pUuX1hs2d6dPn9bvJVu2bJIjRw79/Hhfb9xrCnDN4G+XLVsmDz30kOYdanlQejfFx8dLnz599Lj77rtP+vfvr0uwOsN3NWrUKF2KFddX+fLl5bvvvtPXcGyDBg2kYcOGjr+7dOmSrr8+ZMgQr2klsgoGcwoIlAIR2PDD7Pwji0COH2IEsaNHj+qPdIsWLbTKfe7cuRrcsSa2J/hxRmDAj+7q1as1kBw7dkxatWrlOOann37S4NyoUSPZsWOHrgn/6KOPeq1yN2sKECjwHAENP/LY5wzPEfQQ6L1BoK1Zs6a+b+PGjaVdu3aaB23btpXt27dLsWLF9LmZH7du3dJ17pHmvXv3avU//mbz5s2OcyJgrV+/Xm8M8HnRRIFzuRs3bpzWduC9u3btKl26dJFDhw4lOA43TPPnz9fHeB2f+6OPPpLEQP43b95cS9K//fabTJkyRd566y2XY2JjYzVA4qYCaUXazWB8584dSawbN27I2LFjZdasWbJmzRq9iXvzzTddPi+urWnTpuk1g2sC66g7QyCfOXOmpnPfvn3yxhtv6HeBawc3D1999ZV+5x9//LEe/69//UtvrBjMKUUI97JtlHJgXXBcUlha1FSrVi2jbdu2+rhjx466rruztWvXGlFRUcbNmzf1OZZ3/PDDD/UxlnbEGuOnTp1yHL9v3z59j82bN+vz6tWrG23atPGaJufzAf52wYIFLsfMnTvXyJ49u3Hr1i19vm3bNl0jGmtG3+285ucCrOONcw8ePNixb+PGjboPr3nTuHFjo2/fvvo4JiZG17CfN2+e4/UrV67ouuu9evXy+t52u93InTu3MXnyZH2OdON9sZ678/Kwly9fvmveQPny5Y2hQ4fq42XLlhnR0dHGH3/84Xh9yZIlLnk4a9Yso2TJkpoG0+3bt4306dPr33vinh4smYrnR44ccRyD9eXz5MnjeJ43b17j/fffdzyPjY018ufPbzRt2lSf47tDPm3YsMHlvXDNtW7d2mWZ4XTp0uk64BkzZjQOHz7sMY1EVsOSOQVMqVKltHMTSk9w5MgRLa2ZVey7du3S0hVKbuaGUh1KgMePH09wvgMHDmjJEpsJVb2oasVrgKrk+vXrJynd6BGNdmazpIc0omrarJb3xrkPQJ48efRfVJ277zt//rz+ixqKESNG6DGojsbnR9UySqGAWgeUdJ1rFtBJrGTJknd9b5Q60QZtvk+gmPmfL18+x77q1au7HIPvFN8zSubmd4rPhloI1MQkFpodUJNhQhOD+XmuXr2qNQpVq1Z1qQlCzYQJaUDp/oknnnC5vlBSd07HCy+8oDU5o0eP1pqABx980I+cIUp+kmcPGbIsBO4ePXrIpEmTtKoaP9B16tRxtJ937txZ28ndod3XH2gbTSpUI6M6HOlFtfLs2bMTVRWdOnVqx2OzM5enfWa7+wcffKDnRTs1AjraxdEW7kt1tKf3Nt/LW/u+N2hCcG93xs2EL/Cdoung66+/TvAa+lAk5fO4p+1e6QA0YaDq3FnatGkdjxHwt23bpjdv6A9AlFKwZE4BhY5QCBIIiCgVoZOWGdQqVqwo+/fvl+LFiyfYEFDdoTMUOldhM+Hv0XEKJXSzhIp2cl+CBkrI7l577TX55Zdf5NNPP5W4uDgN6oGG9mT0AUA7LjpnFS1aVA4fPux4Hc+RPrNt3yyVOh/jDzNv3T83gq1zJ7OYmBiXGhIz/52P2bRpk8s58J0iKObOnTvBdxqooWc4D0rqaLc34TtCUDbhekDQRi2Hezqca3b69u2r1+eSJUu07fzXX38NSBqJwo3BnAIKVZvooDZw4EANAmbPaUDnqQ0bNmiHN1SPIwj88MMPXjvAoWMaSrDo3Y1OYOgohhI0SvpmFevQoUO1Rzj+RbXwnj17ZMyYMV7Th6pzBP9z587J5cuXXQJXtWrVNI3orBeIEr87VOmiUxvyAGlFLYVzz3xUVbdv31769esnK1eu1E5cqOlA8EnKMC70tMffL168WHvbm6XYxx9/XDucoSkE+Yb3RonVOf9LlCih+1GdjuMGDRrkcm58NxhBgJsUvI6bAfRWR+2Lp2GK/urVq5dWjWOOgIMHD2qnP+dx88g7dJhDpzd0dEPVOq6ZiRMn6nOz1I4mINQioDoe+YzP5nwdEFkVgzkFHAIQfiDRHu7c3opSNHoWo6SJ4WmPPPKI9iR2PsYZAhCCPYZUYXgUggtKr+gFb8KwLfSYR+9vDKtCgHLuHe4OvaIRUFFaw/u7pxtV3qhNCIa3335bS7LIF6Qb7dzuM5iNHz9e26Ux1A+fF73lcaOBoWH+QrXz8OHDZcCAAdqOb9484YYLN0Z4L/TGR1qc261xE4F+BDdv3tR2fNRejBw5MkFbN3qfo5kEtRlIK/IRbeYYShgoKFGj5z+CL/IHwdt5CCKgP8LgwYO1VzvSgR71COAYqoabGKQLw+7wHQDyBPmBXu1EVmdDL7hwJ4IoOUAwwI1BOGaq8wZj8BGMcRNidiQkInLHDnAU8VDtjElOPvnkE50IJpwwbhzVyCgJo738nXfe0f2oxiYi8obV7BTxUO2MHtmo+g5WFbsvMGQKHeRQzY6SOdqi0S5NROQNq9mJiIgsjiVzIiIii2MwJyIisjgGcyIiIotjMCciIrI4BnMiIiKLYzAnIiKyOAZzIiIii2MwJyIiEmv7fyyXG13swbA8AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -744,7 +744,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "43", "metadata": {}, "outputs": [], @@ -793,7 +793,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "46", "metadata": {}, "outputs": [], @@ -813,128 +813,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "48", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
qs.g_xqs.g_yqs.v_dir_xqs.v_dir_yqs.u_xqs.u_ycountprobabilitybitstring
0621030850.041504001101010110
1140012790.038574100100100001
2410033780.038086111100001100
3141101760.037109010011100001
4131003750.036621110001011001
\n", - "
" - ], - "text/plain": [ - " qs.g_x qs.g_y qs.v_dir_x qs.v_dir_y qs.u_x qs.u_y count probability \\\n", - "0 6 2 1 0 3 0 85 0.041504 \n", - "1 1 4 0 0 1 2 79 0.038574 \n", - "2 4 1 0 0 3 3 78 0.038086 \n", - "3 1 4 1 1 0 1 76 0.037109 \n", - "4 1 3 1 0 0 3 75 0.036621 \n", - "\n", - " bitstring \n", - "0 001101010110 \n", - "1 100100100001 \n", - "2 111100001100 \n", - "3 010011100001 \n", - "4 110001011001 " - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "results.dataframe.head()" ] @@ -949,7 +831,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "50", "metadata": {}, "outputs": [], @@ -991,25 +873,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "52", "metadata": { "jupyter": { "source_hidden": true } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(\n", @@ -1045,25 +916,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "54", "metadata": { "jupyter": { "source_hidden": true } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.imshow(\n", " p_u_xy,\n", @@ -1195,7 +1055,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "60", "metadata": { "jupyter": { @@ -1275,25 +1135,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "62", "metadata": { "jupyter": { "source_hidden": true } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import math\n", "\n", @@ -1515,7 +1364,7 @@ "\n", "[4] [Gaitan, Frank. (2020). \"Finding flows of a Navier–Stokes fluid through quantum computing.\" npj Quantum Information 6.1: 61.](https://www.nature.com/articles/s41534-020-00291-0)\n", "\n", - "[5] [Itani, Wael, and Sauro Succi. (2022). Analysis of Carleman linearization of lattice Boltzmann. Fluids 7.1: 24.](https://www.mdpi.com/2311-5521/7/1/24)\n", + "[5] [Itani, Wael, and Sauro Succi. (2022). Analysis of Carleman linearization of lattice Boltzmann. Fluids 7.1: 24.](https://doi.org/10.3390/fluids7010024)\n", "\n", "[6] [Wang, Boyuan, et al., (2025). Quantum lattice Boltzmann method for simulating nonlinear fluid dynamics. arXiv:2502.16568.](https://arxiv.org/abs/2502.16568)\n", "\n", diff --git a/applications/cfd/qlbm/qlbm.synthesis_options.json b/applications/cfd/qlbm/qlbm.synthesis_options.json index 494d44dbd..321581aee 100644 --- a/applications/cfd/qlbm/qlbm.synthesis_options.json +++ b/applications/cfd/qlbm/qlbm.synthesis_options.json @@ -6,28 +6,28 @@ "preferences": { "custom_hardware_settings": { "basis_gates": [ - "sxdg", - "ry", "tdg", - "sx", - "z", + "sxdg", + "rz", + "u2", "u", - "t", - "p", + "y", "r", - "rx", - "s", - "u1", - "u2", - "x", - "rz", - "cy", "id", - "h", - "y", + "sx", + "cy", "cz", + "t", + "h", + "s", "cx", - "sdg" + "x", + "z", + "ry", + "p", + "sdg", + "u1", + "rx" ], "is_symmetric_connectivity": true }, @@ -36,7 +36,7 @@ "optimization_level": 1, "output_format": ["qasm"], "pretty_qasm": true, - "random_seed": 1756940809, + "random_seed": 4191582914, "synthesize_all_separately": false, "timeout_seconds": 300, "transpilation_option": "auto optimize" From 3f7cc56d7f229d1475d10c322d59dab6d52fa31e Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Mon, 27 Oct 2025 11:28:04 +0200 Subject: [PATCH 6/7] added a metadata file to qlbm --- applications/cfd/qlbm/qlbm.metadata.json | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 applications/cfd/qlbm/qlbm.metadata.json diff --git a/applications/cfd/qlbm/qlbm.metadata.json b/applications/cfd/qlbm/qlbm.metadata.json new file mode 100644 index 000000000..83547c4b3 --- /dev/null +++ b/applications/cfd/qlbm/qlbm.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "Quantum Lattice Boltzmann Method", + "description": "Solving the Boltzmann transport equation on a 2D lattice.", + "problem_domain_tags": ["cfd"], + "qmod_type": ["application"], + "level": ["demos"] +} From e3151a03c7ceba4a2b64a08c4ce35e0eec44606c Mon Sep 17 00:00:00 2001 From: roie-d-classiq Date: Mon, 27 Oct 2025 18:11:44 +0200 Subject: [PATCH 7/7] updated qlbm notebook --- applications/cfd/qlbm/qlbm.ipynb | 177 ++++++++++++++++-- .../cfd/qlbm/qlbm.synthesis_options.json | 28 +-- 2 files changed, 178 insertions(+), 27 deletions(-) diff --git a/applications/cfd/qlbm/qlbm.ipynb b/applications/cfd/qlbm/qlbm.ipynb index 6e300b9fa..29f8c2313 100644 --- a/applications/cfd/qlbm/qlbm.ipynb +++ b/applications/cfd/qlbm/qlbm.ipynb @@ -744,7 +744,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "43", "metadata": {}, "outputs": [], @@ -793,7 +793,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "46", "metadata": {}, "outputs": [], @@ -813,10 +813,128 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "48", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
qs.g_xqs.g_yqs.v_dir_xqs.v_dir_yqs.u_xqs.u_ycountprobabilitybitstring
0111103880.042969110011001001
1621130770.037598001111010110
2121100760.037109000011010001
3470133760.037109111110111100
4120111740.036133010110010001
\n", + "
" + ], + "text/plain": [ + " qs.g_x qs.g_y qs.v_dir_x qs.v_dir_y qs.u_x qs.u_y count probability \\\n", + "0 1 1 1 1 0 3 88 0.042969 \n", + "1 6 2 1 1 3 0 77 0.037598 \n", + "2 1 2 1 1 0 0 76 0.037109 \n", + "3 4 7 0 1 3 3 76 0.037109 \n", + "4 1 2 0 1 1 1 74 0.036133 \n", + "\n", + " bitstring \n", + "0 110011001001 \n", + "1 001111010110 \n", + "2 000011010001 \n", + "3 111110111100 \n", + "4 010110010001 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "results.dataframe.head()" ] @@ -831,7 +949,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "50", "metadata": {}, "outputs": [], @@ -873,14 +991,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "52", "metadata": { "jupyter": { "source_hidden": true } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(5, 5))\n", "plt.imshow(\n", @@ -916,14 +1045,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "54", "metadata": { "jupyter": { "source_hidden": true } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.imshow(\n", " p_u_xy,\n", @@ -1055,7 +1195,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "60", "metadata": { "jupyter": { @@ -1135,14 +1275,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "62", "metadata": { "jupyter": { "source_hidden": true } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import math\n", "\n", @@ -1364,7 +1515,7 @@ "\n", "[4] [Gaitan, Frank. (2020). \"Finding flows of a Navier–Stokes fluid through quantum computing.\" npj Quantum Information 6.1: 61.](https://www.nature.com/articles/s41534-020-00291-0)\n", "\n", - "[5] [Itani, Wael, and Sauro Succi. (2022). Analysis of Carleman linearization of lattice Boltzmann. Fluids 7.1: 24.](https://doi.org/10.3390/fluids7010024)\n", + "[5] [Itani, Wael, and Sauro Succi. (2022). Analysis of Carleman linearization of lattice Boltzmann. Fluids 7.1: 24.](https://arxiv.org/abs/2111.11327)\n", "\n", "[6] [Wang, Boyuan, et al., (2025). Quantum lattice Boltzmann method for simulating nonlinear fluid dynamics. arXiv:2502.16568.](https://arxiv.org/abs/2502.16568)\n", "\n", diff --git a/applications/cfd/qlbm/qlbm.synthesis_options.json b/applications/cfd/qlbm/qlbm.synthesis_options.json index 321581aee..9e942d885 100644 --- a/applications/cfd/qlbm/qlbm.synthesis_options.json +++ b/applications/cfd/qlbm/qlbm.synthesis_options.json @@ -6,28 +6,28 @@ "preferences": { "custom_hardware_settings": { "basis_gates": [ + "x", + "z", + "id", "tdg", + "p", "sxdg", - "rz", - "u2", - "u", "y", + "rx", "r", - "id", + "u1", + "cx", "sx", - "cy", - "cz", + "u2", + "s", "t", "h", - "s", - "cx", - "x", - "z", + "rz", + "cy", + "cz", "ry", - "p", "sdg", - "u1", - "rx" + "u" ], "is_symmetric_connectivity": true }, @@ -36,7 +36,7 @@ "optimization_level": 1, "output_format": ["qasm"], "pretty_qasm": true, - "random_seed": 4191582914, + "random_seed": 1310324548, "synthesize_all_separately": false, "timeout_seconds": 300, "transpilation_option": "auto optimize"