From 4aa435325c2e64b6340701424800bf0558e5310e Mon Sep 17 00:00:00 2001 From: Anton Quelle Date: Mon, 31 Aug 2026 09:06:08 +0200 Subject: [PATCH] exercise 3 and solution 2 --- ...ule3_compilation_execution_EXERCISES.ipynb | 364 +++++++++++++++ ...le2_register_drive_program_SOLUTIONS.ipynb | 418 ++++++++++++++++++ 2 files changed, 782 insertions(+) create mode 100644 exercises/module3_compilation_execution_EXERCISES.ipynb create mode 100644 solutions/module2_register_drive_program_SOLUTIONS.ipynb diff --git a/exercises/module3_compilation_execution_EXERCISES.ipynb b/exercises/module3_compilation_execution_EXERCISES.ipynb new file mode 100644 index 0000000..73f3375 --- /dev/null +++ b/exercises/module3_compilation_execution_EXERCISES.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4168bf47", + "metadata": {}, + "source": [ + "# QoolQit Exercises — Module 3\n", + "## Compilation and Execution\n", + "\n", + "In Module 2 we assembled device-agnostic `QuantumProgram`s. This module makes\n", + "them run: we **compile** programs to devices with real physical constraints,\n", + "and **execute** them on an emulator. Along the way you will run your first\n", + "genuinely quantum experiments: a **π-pulse** and the **Rydberg blockade**.\n", + "\n", + "### In this module you will learn\n", + "- The built-in devices (`MockDevice`, `AnalogDevice`, ...) and their\n", + " constraints\n", + "- How `compile_to` adapts a dimensionless program to hardware limits\n", + "- How to run a compiled program on the `LocalEmulator` and read out the\n", + " measured bitstrings\n", + "- What a `CompilationError` means and how to reason about it\n", + "\n", + "\n", + "> **How to use this notebook.** \n", + "> - Cells marked **✏️ Exercise** contain gaps\n", + "> indicated by `...` or `# TODO` — replace them with working code following\n", + "> the instructions. \n", + "> - Cells marked **✅ Check** verify your answer: run them\n", + "> after completing the exercise. Everything else is provided and runs as-is.\n", + "> A separate **solution notebook** will be published.\n", + ">\n", + "> **API note:** we use qoolqit version 1.4" + ] + }, + { + "cell_type": "markdown", + "id": "a1a0339c", + "metadata": {}, + "source": [ + "## 1. Devices\n", + "\n", + "A `Device` bundles the physical constraints of a machine: maximum amplitude,\n", + "maximum sequence duration, minimum atom spacing, maximum radial distance.\n", + "QoolQit ships default devices you can use offline:\n", + "\n", + "- **`MockDevice`** — a *virtual* device with (almost) no constraints, for\n", + " unconstrained prototyping;\n", + "- **`AnalogDevice`** — a *realistic* analog device;\n", + "- **`AnalogDeviceWithDMM`**, **`DigitalAnalogDevice`** — variants with extra\n", + " capabilities.\n", + "\n", + "Real remote devices (e.g. Pasqal's FRESNEL) can be fetched with\n", + "`Device.from_connection(connection=PasqalCloud(), name=\"FRESNEL\")` — same\n", + "interface, specs downloaded from the cloud." + ] + }, + { + "cell_type": "markdown", + "id": "cba9bf8e", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.1 — Meet the devices\n", + "\n", + "1. Call `available_default_devices()` (imported from `qoolqit`) to list the\n", + " built-in devices and their constraints.\n", + "2. Instantiate `device = AnalogDevice()` and print it.\n", + "3. Read the printout and note down (mentally or in a comment): its\n", + " **max_duration**, **max_amplitude** and **max_radial_distance**. Compare\n", + " with `MockDevice()` — what is different?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e3954d5", + "metadata": {}, + "outputs": [], + "source": [ + "from qoolqit import MockDevice\n", + "\n", + "# TODO: list the default devices\n", + "\n", + "# TODO: instantiate and print the realistic analog device\n", + "device = ...\n", + "print(device)\n", + "\n", + "print(MockDevice())" + ] + }, + { + "cell_type": "markdown", + "id": "22037080", + "metadata": {}, + "source": [ + "## 2. Compilation: your first physical experiment, the π-pulse\n", + "\n", + "Compilation translates the dimensionless program into a concrete pulse\n", + "sequence in physical units, rescaling amplitude, duration and atom spacing to\n", + "fit the device (by default with the `MAX_ENERGY` profile, which uses the\n", + "device's maximum capabilities while preserving the program's ratios).\n", + "\n", + "**The experiment.** Drive a *single atom* with a constant amplitude\n", + "$\\Omega$ and zero detuning. The atom oscillates between $|0\\rangle$ and\n", + "$|1\\rangle$ (*Rabi oscillation*), and is fully flipped to $|1\\rangle$ when\n", + "\n", + "$$\n", + "\\Omega \\cdot t = \\pi \\qquad \\text{(a \"π-pulse\")}.\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "id": "19943521", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.2 — Compile a π-pulse\n", + "\n", + "1. Build a **single-atom** register at the origin.\n", + "2. Build a drive with a `ConstantWaveform` amplitude of value `1.0` and a\n", + " duration realizing a π-pulse. No detuning needed.\n", + "3. Assemble the program, compile it to the `AnalogDevice` with\n", + " `program.compile_to(device=..., profile=\"max_energy\")`, check `is_compiled`, and draw the\n", + " compiled sequence with `program.draw(compiled=True)`.\n", + "\n", + "Note the units in the drawing: compilation has translated dimensionless time\n", + "and amplitude into nanoseconds and rad/µs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbafe7f0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from qoolqit import ConstantWaveform, Drive, QuantumProgram, Register\n", + "\n", + "# TODO: single atom at the origin\n", + "register_1atom = ...\n", + "\n", + "# TODO: constant pi-pulse: Omega = 1.0, duration such that Omega*t = pi\n", + "pi_pulse = ConstantWaveform(..., ...)\n", + "drive_pi = Drive(amplitude=pi_pulse)\n", + "\n", + "# TODO: assemble, compile to the AnalogDevice, and draw compiled\n", + "program_pi = ...\n", + "program_pi.compile_to(device=..., profile=\"max_energy\")\n", + "print(\"Compiled?\", program_pi.is_compiled)\n", + "program_pi.draw(compiled=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39a2adba", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check\n", + "assert program_pi.is_compiled\n", + "assert abs(drive_pi.duration - np.pi) < 1e-9\n", + "print(\"π-pulse compiled!\")" + ] + }, + { + "cell_type": "markdown", + "id": "d3483f79", + "metadata": {}, + "source": [ + "## 3. Execution on the LocalEmulator\n", + "\n", + "Executing follows a simple, backend-independent workflow:\n", + "\n", + "```\n", + "emulator = LocalEmulator() # from qoolqit.execution\n", + "job = emulator.run(program)\n", + "results = job.results()\n", + "counts = results.final_bitstrings # a Counter of measured bitstrings\n", + "```\n", + "\n", + "Remote backends (`RemoteEmulator`, `QPU`) expose exactly the same `run` /\n", + "`results` interface — only the construction differs (they need a cloud\n", + "connection)." + ] + }, + { + "cell_type": "markdown", + "id": "b748f67f", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.3 — Run the π-pulse\n", + "\n", + "Run `program_pi` on a `LocalEmulator` and print the measured bitstring\n", + "counts. If your pulse is a true π-pulse, (almost) **all shots should return**\n", + "`'1'` — the atom is deterministically flipped." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "72154f94", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: run the program and get the bitstring counts\n", + "emulator = ...\n", + "job = ...\n", + "results = ...\n", + "counts = ...\n", + "\n", + "print(counts)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5a587bc", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check — at least 95% of shots in '1'\n", + "total = sum(counts.values())\n", + "assert counts.get(\"1\", 0) / total > 0.95, \"Expected (almost) all shots in '1'\"\n", + "print(f\"π-pulse verified: {counts.get('1', 0)}/{total} shots measured '1'.\")" + ] + }, + { + "cell_type": "markdown", + "id": "f9c4e178", + "metadata": {}, + "source": [ + "## 4. A two-atom experiment: the Rydberg blockade\n", + "\n", + "Now the same π-pulse on **two atoms**. The interaction $J = 1/r^6$ changes\n", + "everything:\n", + "\n", + "- **Far apart** ($J \\ll \\Omega$): the atoms don't feel each other and are\n", + " *independently* flipped → you measure `'11'`.\n", + "- **Close together** ($J \\gg \\Omega$): exciting *both* atoms costs a huge\n", + " interaction energy, so the doubly-excited state is **blockaded** → `'11'`\n", + " is (almost) never measured. This *Rydberg blockade* is the fundamental\n", + " mechanism behind unit-disk connectivity (Module 1) and neutral-atom\n", + " entanglement." + ] + }, + { + "cell_type": "markdown", + "id": "cc51d1ec", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.4 — Observe the blockade\n", + "\n", + "1. `register_far`: two atoms at distance **3.0** (so $J = 1/3^6 \\approx\n", + " 0.0014 \\ll 1$). Apply the same π-pulse drive, compile to the\n", + " `AnalogDevice`, run, and print the counts.\n", + "2. `register_close`: two atoms at distance **0.7** (so $J = 1/0.7^6 \\approx\n", + " 8.5 \\gg 1$). Same pulse, compile, run, print.\n", + "3. Compare the frequency of `'11'` in the two cases. Blockade in action!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d5ff774", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO 1: two distant atoms -> independent flips\n", + "register_far = Register.from_coordinates([...])\n", + "program_far = QuantumProgram(register_far, Drive(amplitude=pi_pulse))\n", + "program_far.compile_to(device=device, profile=\"max_energy\")\n", + "counts_far = ...\n", + "print(\"far (r=3.0):\", counts_far)\n", + "\n", + "# TODO 2: two close atoms -> blockade\n", + "register_close = Register.from_coordinates([...])\n", + "program_close = ...\n", + "counts_close = ...\n", + "print(\"close(r=0.7):\", counts_close)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4ed1447", + "metadata": {}, + "outputs": [], + "source": [ + "# ✅ Check\n", + "tot_far = sum(counts_far.values())\n", + "tot_close = sum(counts_close.values())\n", + "assert counts_far.get(\"11\", 0) / tot_far > 0.9, (\n", + " \"Far atoms should (almost) always give '11'\"\n", + ")\n", + "assert counts_close.get(\"11\", 0) / tot_close < 0.05, (\n", + " \"Close atoms should (almost) never give '11'\"\n", + ")\n", + "print(\"Rydberg blockade observed!\")" + ] + }, + { + "cell_type": "markdown", + "id": "cd39b586", + "metadata": {}, + "source": [ + "## 5. When compilation fails: `CompilationError`\n", + "\n", + "Compilation rescales amplitude, duration and spacing *together* to fit the\n", + "device. Sometimes no consistent rescaling exists — e.g. bringing a large\n", + "amplitude down to the device maximum stretches the duration beyond the device\n", + "limit. QoolQit then raises a **`CompilationError`** with a message explaining\n", + "which constraint broke." + ] + }, + { + "cell_type": "markdown", + "id": "d3e0cabd", + "metadata": {}, + "source": [ + "### ✏️ Exercise 3.5 — Trigger and read a CompilationError\n", + "\n", + "1. Build `program_bad`: the **close** two-atom register with a\n", + " `ConstantWaveform(400, 1.0)` amplitude — a very long pulse.\n", + "2. Try to compile it to the `AnalogDevice` inside a\n", + " `try/except CompilationError` block (import it from `qoolqit.exceptions`)\n", + " and print the message. Read it: which device limit was violated?\n", + "3. Now compile the **same** program to a `MockDevice()` — it succeeds! Why is\n", + " that both useful and dangerous?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1166e97c", + "metadata": {}, + "outputs": [], + "source": [ + "from qoolqit.exceptions import CompilationError\n", + "\n", + "# TODO: an over-long program\n", + "program_bad = QuantumProgram(\n", + " register_close, Drive(amplitude=ConstantWaveform(..., ...))\n", + ")\n", + "\n", + "try:\n", + " ...\n", + "except CompilationError as err:\n", + " print(\"CompilationError:\", err)\n", + "\n", + "# TODO: same program on the unconstrained MockDevice\n", + "print(\"Compiled on MockDevice?\", program_bad.is_compiled)" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/solutions/module2_register_drive_program_SOLUTIONS.ipynb b/solutions/module2_register_drive_program_SOLUTIONS.ipynb new file mode 100644 index 0000000..438c89f --- /dev/null +++ b/solutions/module2_register_drive_program_SOLUTIONS.ipynb @@ -0,0 +1,418 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "solution-banner", + "metadata": {}, + "source": [ + "> **📗 SOLUTION NOTEBOOK — Module 2.** All exercise cells are completed and\n", + "> annotated. Every explanation cell is identical to the exercise notebook." + ] + }, + { + "cell_type": "markdown", + "id": "8454d054", + "metadata": {}, + "source": [ + "# QoolQit Exercises — Module 2\n", + "## Register, Drive and Quantum Programs\n", + "\n", + "In Module 1 we learned how to describe geometry with graphs. This module\n", + "introduces the three objects that define a computation in the Rydberg analog\n", + "model:\n", + "\n", + "- the **`Register`** — *where the atoms are*;\n", + "- the **`Drive`** — *what we do to them over time* (laser amplitude, detuning\n", + " and phase);\n", + "- the **`QuantumProgram`** — the combination of the two.\n", + "\n", + "### In this module you will learn\n", + "- How to build a `Register` from coordinates or from a graph, and inspect its\n", + " distances and interactions\n", + "- The waveform classes (`ConstantWaveform`, `RampWaveform`,\n", + " `PiecewiseLinearWaveform`, ...) and their rules\n", + "- How to compose a `Drive` and what QoolQit validates for you\n", + "- How to assemble a `QuantumProgram`" + ] + }, + { + "cell_type": "markdown", + "id": "037e35be", + "metadata": {}, + "source": [ + "## 1. The Register\n", + "\n", + "A `Register` describes the layout of atoms loaded on the device. " + ] + }, + { + "cell_type": "markdown", + "id": "6af3af8d", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.1 — Build and inspect a Register\n", + "\n", + "1. Build `register`, a 3-atom register at coordinates\n", + " `(0, 0)`, `(1, 0)` and `(0.5, 0.9)` (a near-equilateral triangle).\n", + "2. Print `n_qubits` and draw it.\n", + "3. Print the pairwise `distances()` and `interactions()`.\n", + "4. **Sanity check the physics yourself**: for the pair `(0, 1)` at distance\n", + " $r = 1$, verify by hand that the printed interaction equals $1/r^6 = 1$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "aa9b16f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of qubits: 3\n", + "Distances: {(0, 1): 1.0, (0, 2): 1.0295630140987, (1, 2): 1.0295630140987}\n", + "Interactions: {(0, 1): 1.0, (0, 2): 0.839619283032302, (1, 2): 0.839619283032302}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qoolqit import Register\n", + "\n", + "register = Register.from_coordinates([(0.0, 0.0), (1.0, 0.0), (0.5, 0.9)])\n", + "\n", + "print(\"Number of qubits:\", register.n_qubits)\n", + "register.draw()\n", + "\n", + "print(\"Distances: \", register.distances())\n", + "print(\"Interactions:\", register.interactions())\n", + "\n", + "# Pair (0, 1) is at distance exactly 1, so its interaction is 1/1**6 = 1.\n", + "# The other two pairs are slightly further apart -> interaction < 1." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "576a962c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Register built correctly — J(0,1) = 1/r^6 = 1 as expected.\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert register.n_qubits == 3\n", + "assert abs(register.interactions()[(0, 1)] - 1.0) < 1e-9\n", + "print(\"Register built correctly — J(0,1) = 1/r^6 = 1 as expected.\")" + ] + }, + { + "cell_type": "markdown", + "id": "7bef6f88", + "metadata": {}, + "source": [ + "## 2. Waveforms\n", + "\n", + "A `Drive` is built out of **waveforms** — functions of (dimensionless) time.\n", + "The main ones:\n", + "\n", + "| Class | Signature | Shape |\n", + "|-------|-----------|-------|\n", + "| `ConstantWaveform` | `(duration, value)` | flat |\n", + "| `RampWaveform` | `(duration, initial_value, final_value)` | linear ramp |\n", + "| `PiecewiseLinearWaveform` | `(durations, values)` | N connected ramps through N+1 values (**N ≥ 2**) |\n", + "\n", + "Two handy facts:\n", + "- waveforms can be **rescaled** by multiplication: `wf * 2.0`;\n", + "- every waveform has `.duration`, `.max()`, `.min()` and can be inspected\n", + " with `Drive(...).draw()` once inside a drive." + ] + }, + { + "cell_type": "markdown", + "id": "dc351eb2", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.2 — Build the classic annealing waveforms\n", + "\n", + "1. Build `wf_trap`: a `PiecewiseLinearWaveform` with total duration `T = 4`\n", + " that ramps `0 → 1` in the first quarter (`T/4`), stays at `1` for half\n", + " (`T/2`), and ramps back `1 → 0` in the last quarter (`T/4`) — a\n", + " *trapezoid*. Remember: **N durations, N+1 values**.\n", + "2. Build `wf_ramp`: a `RampWaveform` of duration `T` from `-1` to `+1`.\n", + "3. Rescale the trapezoid to double height: `wf_trap2 = wf_trap * 2.0`, and\n", + " verify with `.max()`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "921f4e6c", + "metadata": {}, + "outputs": [], + "source": [ + "from qoolqit import PiecewiseLinearWaveform, RampWaveform\n", + "\n", + "T = 4\n", + "\n", + "wf_trap = PiecewiseLinearWaveform([T / 4, T / 2, T / 4], [0.0, 1.0, 1.0, 0.0])\n", + "wf_ramp = RampWaveform(T, -1.0, 1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "79198629", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Waveforms built correctly!\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert abs(wf_trap.duration - 4.0) < 1e-9\n", + "assert abs(wf_trap.max() - 1.0) < 1e-9\n", + "assert wf_ramp.min() == -1.0 and wf_ramp.max() == 1.0\n", + "print(\"Waveforms built correctly!\")" + ] + }, + { + "cell_type": "markdown", + "id": "a66b0685", + "metadata": {}, + "source": [ + "## 3. The Drive\n", + "\n", + "The `Drive` collects the control parameters of the time-dependent Hamiltonian\n", + "\n", + "$$\n", + "H_{\\mathrm{drive}}(t) = \\sum_i \\frac{\\Omega(t)}{2}\\left(\\cos\\varphi\\,\\hat\\sigma^x_i - \\sin\\varphi\\,\\hat\\sigma^y_i\\right) - \\sum_i \\delta(t)\\, \\hat n_i\n", + "$$\n", + "\n", + "- **amplitude** $\\Omega(t)$ — the Rabi frequency driving the qubits\n", + " (*required*, must be $\\geq 0$ at all times);\n", + "- **detuning** $\\delta(t)$ — the energy offset of the Rydberg state\n", + " (*optional*, defaults to zero);\n", + "- **phase** $\\varphi$ — a global phase (*optional*, defaults to 0).\n", + "\n", + "All arguments are **keyword-only**: `Drive(amplitude=..., detuning=...)`." + ] + }, + { + "cell_type": "markdown", + "id": "055488be", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.3 — Compose a Drive (and let QoolQit catch your mistakes)\n", + "\n", + "1. Build `drive = Drive(amplitude=wf_trap, detuning=wf_ramp)` and `draw()` it.\n", + " Print its `duration`.\n", + "2. **Negative amplitude is unphysical**: in a `try/except ValueError`, try\n", + " `Drive(amplitude=RampWaveform(2.0, 0.5, -0.5))` and print the error.\n", + "3. **Drive compositions**: `Drive`s can be composed with `>>` to concatenate them." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "786ace14", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drive duration: 4.0\n", + "As expected: 'amplitude' must be positive.\n", + "Drive duration: 8.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qoolqit import Drive\n", + "\n", + "drive = Drive(amplitude=wf_trap, detuning=wf_ramp)\n", + "drive.draw()\n", + "print(\"Drive duration:\", drive.duration)\n", + "\n", + "try:\n", + " Drive(amplitude=RampWaveform(2.0, 0.5, -0.5))\n", + "except ValueError as err:\n", + " print(\"As expected:\", err)\n", + "\n", + "# The >> operator concatenates two Drives in time:\n", + "# amplitudes and detunings are appended one after the other.\n", + "double_drive = drive >> drive\n", + "double_drive.draw()\n", + "print(\"Drive duration:\", double_drive.duration)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6cf4e95e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Drive composition rules understood!\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert abs(drive.duration - 4.0) < 1e-9\n", + "assert abs(double_drive.duration - 8.0) < 1e-9\n", + "print(\"Drive composition rules understood!\")" + ] + }, + { + "cell_type": "markdown", + "id": "1c016719", + "metadata": {}, + "source": [ + "## 4. The QuantumProgram\n", + "\n", + "A `QuantumProgram` is simply *register + drive*: where the atoms are, and\n", + "what we do to them. It is created **device-agnostic** — in dimensionless\n", + "units, without reference to any hardware. Turning it into something a real\n", + "machine can run is the job of *compilation* (Module 3)." + ] + }, + { + "cell_type": "markdown", + "id": "efe5b8fd", + "metadata": {}, + "source": [ + "### ✏️ Exercise 2.4 — Assemble a QuantumProgram\n", + "\n", + "1. Build `program = QuantumProgram(register, drive)` from the register of\n", + " Exercise 2.1 and the drive of Exercise 2.3, and print it.\n", + "2. Print `program.is_compiled` — it should be `False`: no device yet!\n", + "3. Draw the (uncompiled) program with `program.draw()`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2cfc9a6d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quantum Program:\n", + "| Register(n_qubits = 3)\n", + "| Drive(duration = 4.000)\n", + "| Compiled: False\n", + "Compiled? False\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAApUdJREFUeJzsnXl4VOXdsO+ZSWYmyWQyk22ykn1lJ6xqXQpKxaqoCFJXXLHFqvStrf2sFn2rtlVr60bdqq21glatdWspCtaCyCoSkgnZE5LJnkzWmWRmvj/ycsJIICHM5GQOz31dXBd5zva7n5k855dznkXl8Xg8CAQCgUAgEJyGqOUOQCAQCAQCgUAuRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bguQOYKLjdrupq6sjPDwclUoldzgCgUAgEAhGgcfjobOzk4SEBNTq4z/3EYnQCNTV1ZGcnCx3GAKBQCAQCMZATU0NSUlJx90uEqERCA8PBwYr0mg0+vTcRUVF5OXl+fScEw2lOyrdD5TvKPwCH6U7Cr+xYbfbSU5Olu7jx0MkQiNw5HWY0Wj0eSJkMBh8fs6JhtIdle4HyncUfoGP0h2F36kxUrcW0VlaRkwmk9wh+B2lOyrdD5TvKPwCH6U7Cj//ElCJ0GeffcbFF19MQkICKpWKd999d8RjtmzZwqxZs9DpdGRmZvLKK6/4Pc7RkpiYKHcIfkfpjkr3A+U7Cr/AR+mOws+/BFQi1N3dzfTp03nmmWdGtX9FRQUXXXQR5513Hvv27eOuu+7i5ptv5p///KefIx0dpaWlcofgd5TuqHQ/UL6j8At8lO4o/PxLQPURuvDCC7nwwgtHvf/69etJS0vj8ccfByAvL4/PP/+c3/72tyxevNhfYY4ah8Mhdwh+R+mO7V3tfFL0CU6XU+5Q/EZVVRWlfcptiIVf4GLUG5mbNlfx7Yzw8y8BlQidLNu3b2fRokVeZYsXL+auu+467jEOh8PrQ7Hb7f4KTxDAdPR0cOcbd7Jx50Z6B3rlDkcgOG2JCovi8vzLWZ+3/oRzxQgEx0PRiZDNZsNisXiVWSwW7HY7vb29hISEHHPMI488wrp1644pLyoqwmAwAJCdnU1PTw+1tbXS9tTUVNRqNeXl5VJZfHw8JpOJoqIiqSwqKoq4uDisVisej4fCwkIMBgMpKSlUVlbS3d0NgFarJSsri/r6elpbW6Xj8/PzaW1txWazSWUZGRkMDAxQVVUllSUnJ6PX6zl06JBUFhsbS0xMDAcPHsTj8QCDndQSExMpLS2VEsCQkBDS09OpqamREkGNRkNubi4NDQ00NzdL58zJyaGrq4vDhw8PWxdHHBMSEjAajRQXFw9bFwMDA8DgdAWTJk2ioqKCnp4er7qoq6ujra1NOn7y5Mk0NzfT0NAglWVmZuJ0OqmurvaqC51O5/X41WKxEB0dTWFhoVQ2XF2EhoaSlpZGdXU1nZ2dAKjVan6+5ef8bc/fBs9lsBAZEklrXyvBmmDCg4eGanY4OgCI0EVIZZ39nfS7+onUR0plPQM99Az0EKmPRP1/b6wdLged/Z1EaCMIVgcDMOAZoN3RjiHYgF6jB8CDh5a+FkKCQggLCpPO2eZoQ6PSYNQOjcawO+24PC7MOrNU1t3fTa+rl2h9tFTW5+qjq78Ls86MRqUBoN/dT4ezA6PWiFatBcDtcdPqaCUsKIyQoKHfp5a+FnQaHYZgg1TW7mhHpVIRoZWnLoJUQYRrhz4bu9OO2+PGpDN51UWfq48ofdSEqosofRQqVF51YdKaCFIHedVFeHA4Oo3Oqy4idZGoVUMJQltfG0Hqkeuiq78Lh8vhVRe9rl66+7u96sLpdmJ32r3qwuVx0eZoIyw4jBDNyHWhVqm9vqedzk4G3AOY9UPf0+HqotZeS0t3Cy/sfIHQ4FBumXuL1H7V1tbS0TH4+6dWq8nLy6OxsZGmpibpnL5qy4+0X/5sy49uq+Roy4/gj7Y8NDTUL215WVkZo0HlOVKLAYZKpeKdd95h6dKlx90nOzubVatWce+990plH374IRdddBE9PT3DJkLDPRFKTk6mo6ND0cMXBaPnuS3P8f2/fB+1Ss0l0y/hW1nfwqA3jHygQCDwKQOuAT4u/Jh/fPUP1Co1m3+0mXNzzpU7LMEEwW63ExERMeL9W9HPEePi4rwyTICGhgaMRuOwSRCATqeT5gzyx9xBR3N0pqtUlOb4Vc1X3L3hbgAWpC/gh/N/qPgkKDssW+4Q/IrwC1yCNEFcNPUizss4D7fHzfI/LKe1u3XkAwMMpbWj30RuP0UnQgsWLGDz5s1eZZs2bWLBggUyReTNkVctSkZJjl19Xax4fgWOAQepUalcNusyorRRIx8Y4ERqI0feKYARfoGNSqXifxf9L5FhkTR1NrHiDysI0Bcdx0VJ7ehwyO0XUIlQV1cX+/btY9++fcDg8Ph9+/ZJ2eS9997LddddJ+2/evVqysvLueeeeyguLubZZ59l48aN3H333XKELwhw1ry+BqvNSrgunCsLriRcf+Jp2wUCwfhg0BlYfc5q1Co1/y76N7/++NdyhyQIIAIqEdq1axczZ85k5syZAKxdu5aZM2dy//33A1BfX+/1iC0tLY0PPviATZs2MX36dB5//HFefPHFCTF0HgY7rSkdpTj+efufeXX7q6hUKr4z5TtkWjIB6Pf0yxyZ/1G6o/ALfPo9/aREpXD5rMsBuO/d+/iy4kuZo/IdSmlHj4fcfgHbWXq8GG1nK4FysdqsFPxvAd2ObuakzuGGM24gSKPoAZcCQUDi8Xh46pOnKKwrJNGUSNFDReLJ7WmM6CwdAHyzI7cSCXTHvv4+VvxhBd2ObpLMSSwrWOaVBCWHJMsY3figdEfhF/gccVSpVNx41o0Y9UYOtx/mmhevUUR/oUBvR0dCbj+RCMnI0XM4KJVAd/yfN/+Hr2q/IlQbyrKCZZhCTV7bE/XKXgMIlO8o/AKfox0NOgO3nXMbKpWK9756j+e2PCdjZL4h0NvRkZDbTyRCAsFxeGfPOzzz6eC6dufnnU9uXK7MEQkEgtGQGZvJd6d+F4C1G9dSeLhwhCMEpzMiERIIhqGqpYobX70RgJnJMzl/8vmoVCqZoxIIBKNlydQlZMVm4RhwcOkzl9LrFEvhCIZHdJYeAX92lh4YGCAoSNmdbgPRsX+gn3MeO4ftZduJM8Zxx8I7iDZED7tvkCqIAc/AOEc4vijdUfgFPsdz7OjtYN176+h2dnPNvGv4881/liG6UycQ29GTwV9+orN0ACD3JFLjQSA63v/e/Wwv244+SM9lsy47bhIEYA42H3ebUlC6o/ALfI7nGBESwc3fuhmA13a8xp+3B2YiFIjt6Mkgt59IhGSkrq5O7hD8TqA5/qvwXzz60aMAnJd7HtOSpp1w/4ywjPEIS1aU7ij8Ap8TOeYn5HN+/vkArH5tNWWNo1uIcyIRaO3oySK3n0iEBIL/w9Zh49qXrgVgSsIULpxyodeq3QKBIDC5bOZlpESm0OPs4dJnLsU54JQ7JMEEQrTyAgHgcru45qVraOxsJMYQw/I5y9EF6+QOSyAQ+ACNWsNt59yGPkhPYV0hd75xp9whCSYQIhGSkbS0NLlD8DuB4vjoR4+yuWgzwZpgLp1xKRajZVTHHbAf8HNk8qN0R+EX+IzGMcoQxQ1n3gDA+q3reXfvu/4NyocESjs6VuT2E4mQ4LTn80Ofc//fB9erOzvrbApSC2SOSCAQ+IOZk2ZydtbZAFz/8vXUttbKHJFgIiASIRmpqKiQOwS/M9EdW7paWPnCStweNzmWHL477bsn1S9oinGKH6ObGCjdUfgFPifjuHzOcuIj4rH32bns2ctwuV1+jMw3TPR29FSR208kQoLTFo/Hw42v3EhtWy3mUDPLZy8nVBcqd1gCgcCPBGuCuf3c2wnWBLOrahf3/u1euUMSyIxIhASnLb/f/Hve++o9NGoNF0+7mKTIJLlDEggE44DFaOHqeVcD8Nimx/j3wX/LHJFATkQiJCMJCQlyh+B3Jqrj7qrd/PitHwNwZsaZzM+YP6bzlHUH3pwkJ4vSHYVf4DMWxwUZC5ibNhePx8NVz19FU2eTHyLzDRO1HfUVcvuJREhGwsPD5Q7B70xER3uvnRV/WEG/q5+MmAwunXEpGrVmTOdq62/zcXQTD6U7Cr/AZ6yO18y7hhhDDC3dLSx7bhlut9vHkfmGidiO+hK5/UQiJCNWq1XuEPzORHP0eDyDs8s2lWEMMXJlwZUY9IYxn2+2abYPo5uYKN1R+AU+Y3XUBetYfe5qNGoNnx36jP/94H99HJlvmGjtqK+R208kQoLTipc/f5m/fvlX1Co1SyYvIS1G2fNzCASCE5NkTuLKgisBePAfD7KtdJvMEQnGG5EICU4bCg8Xcsdf7wBgbupcvpX9LZkjEggEE4Fzc85lWtI0XB4Xy9Yvo6OnQ+6QBOOISIRkJDr6+KuaK4WJ4tjj6GHF8yvo7e9lUuQkrii4giBN0Cmf93DfYR9EN7FRuqPwC3xO1VGlUrHqzFWYQk3Ud9Sz8oWVeDweH0V36kyUdtRfyO0XcInQM888Q2pqKnq9nnnz5vHll1+ecP8nn3ySnJwcQkJCSE5O5u6776avr2+coj0xFsvolnEIZCaK410b7qKwrpAwXRjLCpZhDDH65Lw1vTU+Oc9ERumOwi/w8YVjqDaU1WevRq1S89GBj/jdv3/ng8h8w0RpR/2F3H4BlQht2LCBtWvX8sADD7Bnzx6mT5/O4sWLaWxsHHb/119/nZ/+9Kc88MADFBUV8dJLL7FhwwZ+9rOfjXPkw1NcXCx3CH5nIjhu2LmBF/7zAipUXJB/ATlxOT47d4FJ+ctxKN1R+AU+vnJMi0nj0hmXAnDP3+5hX80+n5z3VJkI7ag/kdsvoBKhJ554gltuuYVVq1aRn5/P+vXrCQ0N5eWXXx52/23btnHmmWfyve99j9TUVC644AJWrlx5wqdIDocDu93u9c9fuFwTf2r3U0Vux/Kmcm79060AzEqZxcK8hT49f7Aq2Kfnm4go3VH4BT6+dLxg8gXkxuXS7+pn6TNL6XZ0++zcY0XudtTfyO136p0kxgmn08nu3bu5996h6dDVajWLFi1i+/btwx5zxhln8Nprr/Hll18yd+5cysvL+fDDD7n22muPe51HHnmEdevWHVNeVFSEwTA4zDo7O5uenh5qa4cW7EtNTUWtVlNeXi6VxcfHYzKZKCoqksqioqKIi4vDarXi8XgoLCzEYDCQkpJCZWUl3d2Dv3RarZasrCzq6+tpbW2Vjs/Pz6e1tRWbzSaVZWRkMDAwQFVVlVSWnJyMXq/n0KFDUllsbCwxMTEcPHhQev9tMplITEyktLQUh8MBQEhICOnp6dTU1EiJoEajITc3l4aGBpqbm6Vz5uTk0NXVxeHDQ+/oj66LI44JCQkYjUavzP/ouhgYGAAG55OYNGkSFRUV9PT0eNVFXV0dbW1D84VMnjyZ5uZmGhoapLLMzEycTifV1dX0u/q5ZuM12PvsJJuT+cPFfyBYPdhgVvVWUd9XzzzzPFSoAGh0NFLeU8404zRCNYNLbXQOdFLYWUh2WDaR2kgA+j397G7fTXJIMipUzDcPTsa4q30X5mAzGWEZUjxHVsU+ei2ksu4y2vrbvIb8Hu47TE1vDQWmAqlRb3W2UtJdwuTwyYQHDc6z0ePqYb99P+mh6cTqYgHw4GFH2w7i9fGkhKRI59zbsZdQTSg5hqEnYMVdxfS5+pgRMUMqq+qpot5RL3kANDgaqOipYLpxuuRoH7BzsPMgOYYczMFmAJxuJ3s69jApZBIJ+qFJ0Xa27SRKG0V6WLpU9rX9a9QqNZPDJ0tlpd2ltPe3D1sXs02zCVINNlEtzhYOdR8ati4yQjOI0cUA4MbNl21fkqBPYFLIJK+6CNOEkW3IlsqKOotwup1en2FlTyU2h82rLmwOG5U9lcyImIFerQego7+Doq6iYesiJSSFeH28dPyXbV8SrYsmPdS7LjQqDfnh+VLZoe5D2PvtXk83antrqe2rZY5pDhrV4FxXzc5mSrtLmRI+BUPQYJvU7erma/vXZIZlEq0d7G/h8rjY2b4TwMtnT/seDEEGr7o42HmQAc8A04zTpLKKngoaHY3MM887pi5mRsxEp9YB0N7fTnFXMbmGXEzBJgAcbgd7O/aSGppKnC5OOn5H2w5idbGkhQ6N1txv30+QKsirLkq6Suga6GKWaZZUVtNbw+G+w8PWxdGfYddAFwc6DwxbF0n6JJJChmaQ392+G2OwkaywLK+6+OG5P+SBfzxAVUsV1z57LS9e/+IJ2/Ij7Ze/2vIj7egR5GjLj+CPthw4YVt+dF3odDpKS0ulMovFQnR0tFf9HKmLsrLRTbSp8kykHmEnoK6ujsTERLZt28aCBQuk8nvuuYetW7eyY8eOYY/7/e9/z//8z//g8XgYGBhg9erVPPfcc8e9jsPhkL5EAHa7neTkZDo6OjAafdOv5AjV1dVMmjRp5B0DGDkdf7TxRzyx6QlCgkO46Vs3MTVxqs+vkR2WTUl3ic/PO5FQuqPwC3z84Wi1WXli0xMAvHT9S9x41o0+Pf/JoPR7hb/87HY7ERERI96/A+rV2MmyZcsWHn74YZ599ln27NnD22+/zQcffMBDDz103GN0Oh1Go9Hrn79Q8hf7CHI5frD/A6kRW5i3kCkJ/lmBW+k3GFC+o/ALfPzhmBOXw4VTLgTgB6//AGu9fJP+Kf1eIbdfwCRC0dHRaDQar0dnAA0NDcTFxQ17zM9//nOuvfZabr75ZqZOncpll13Gww8/zCOPPDIhplKvqKiQOwS/I4djbWst1798PQDTkqaxePJiVCqVX6519GsepaJ0R+EX+PjL8eLpF5MenU5ffx+XPnspjn7HyAf5AaXfK+T2C5hESKvVUlBQwObNm6Uyt9vN5s2bvV6VHU1PTw9qtbeiRjP4bnkivBE88t5UyYy344BrgKtfupqW7hZiw2NZXrAcbZDWb9c70l9FySjdUfgFPv5y1Kg13HrOrYQEh2C1Wfn+X77vl+uMhNLvFXL7BUwiBLB27VpeeOEFXn31VYqKirj99tvp7u5m1apVAFx33XVenakvvvhinnvuOd544w0qKirYtGkTP//5z7n44oulhEigLB56/yE+K/kMbZCWpTOXEmOMkTskgUAQwJhDzdx45mD/oJf/+zIbd26UOSKBrwmYUWMAK1asoKmpifvvvx+bzcaMGTP4+OOPpcmYqqurvZ4A3XfffahUKu677z4OHz5MTEwMF198Mb/85S/lUvBCp9PJHYLfGU/HT4s/5aEPBvt/nZt9LjMnzfT7NXtcyv5LDZTvKPwCH387Tkuexnk55/Gp9VNuevUm5qXNIyU6ZeQDfYTS7xVy+wXMqDG5GG2vc4G8NNobmfHgDOo76smLz2P1OavRB+vlDksgECiEAdcAj3z0CLVttcxInsHO/7fTJ8v0CPyHGDUWABw9X4NSGQ9Ht9vN9X+8nvqOeqLColg+e/m4JUFHzw2jVJTuKPwCn/FwDNIEsfqc1eiCdOyr2ceP3vyR3695BKXfK+T2E4mQjLS3t8sdgt8ZD8fHNz3Oxwc+JkgdxMXTLybBlDDyQT7iyKSGSkbpjsIv8Bkvx5jwGK5dMDgh71Obn+LDrz8cl+sq/V4ht59IhAQBzRdlX/CztwfXjjsr6yzmpc0b4QiBQCAYO3NS53BGxhl48HD1i1fTYG8Y+SDBhEYkQoKApb2nnZUvrGTAPUBmbCaXTr/0mOkS/I0H5XexU7qj8At8xttx5dyVWIwW2nvaueyZyybEvHSCsSM6S4+A6Cw9MfF4PFy5/kr+tudvmEJMfP+875MSNX6jOAQCwelNXXsdv/zglwy4B/h/S/4f/3vZ/8odkuAbiM7SAcDRC94pFX85rt+6nr/t+RsalYYlU5fIlgQdvbimUlG6o/ALfORwTDAlsHLuSgAe+egRtli3+O1aSr9XyO03LolQe3s7L774Ivfee6+0+u6ePXtk7ykuN99cLkSJ+MPxq5qvuHvD3QDMT5/PWVln+fwao+Xo1d6VitIdhV/gI5fjmZlnUjCpALfHzfI/LKe1u3Xkg8aA0u8Vcvv5PRHav38/2dnZ/OpXv+Kxxx6Teoe//fbbXrNACwSjoauvixXPr8Ax4CA1KpXLZl2GRi1mCRcIBOOPSqXiujOuIyosiqbOJpb/YfmEWL5JcHL4PRFau3YtN9xwA4cOHUKvH5rbZcmSJXz22Wf+vrxAYdzx1zuw2qyE68K5suBKwvXKX0dJIBBMXPTBem475zbUKjWbizbzm3/+Ru6QBCeJ3xOhnTt3cttttx1TnpiYiM1m8/flJzSZmZlyh+B3fOn42hev8cq2V1CpVHxnynfItMhff3s79sodgt9RuqPwC3zkdkyJSuHyWZcD8P/e+X/srNjp0/Mr/V4ht5/fEyGdTofdbj+mvKSkhJiY03tBTIfDIXcIfsdXjiW2Ela/thqAOSlzODfnXJ+c91QJ1YTKHYLfUbqj8At8JoLjorxFTE6YzIB7gMufu5zOvk6fnVvp9wq5/fyeCF1yySU8+OCD9Pf3A4PvVKurq/nJT37CFVdc4e/LT2hqamrkDsHv+MKxr7+PFc+voNvRTZI5iSsKrpgwa/zkGHLkDsHvKN1R+AU+E8FRpVJx41k3YtQbqW2r5dqXrvVZfyGl3yvk9vN7IvT444/T1dVFbGwsvb29nHPOOWRmZhIeHj5hVoEXTGx+/OaP2Vezj1BtKMsKlmEKNckdkkAgEByDQWfgtnNuQ6VS8fd9f2f91vVyhyQYBX7/szoiIoJNmzbx+eefs3//frq6upg1axaLFi3y96UFCuCdPe/w9KdPA3B+3vnkxuXKHJFAIBAcn8zYTL479bv8Y/8/uHvD3Xwr61tMSZwid1iCEyBmlh4Bf84s3dnZSXi4skc9nYpjVUsVMx6cQXtPOzOTZ3LjWTeiDdL6OMJTwxRsor2/Xe4w/IrSHYVf4DPRHN1uN09seoJDjYfIiMng6198TYg2ZMznU/q9wl9+o71/++WJ0O9///tR7/vDH/7QHyEEBFrtxLqp+4OxOvYP9LPyhZW097QTZ4xj2exlEy4JAuhz9ckdgt9RuqPwC3wmmqNareaWs29h3XvrKGsq49Y/3cqfb/7zmM+n9HuF3H5+SYR++9vfev3c1NRET08PJpMJGJxpOjQ0lNjY2NM6ESotLWXy5Mlyh+FXxup4/3v3s71sO/ogPZfNuoxoQ7Qfojt1ZkTM4Iu2L+QOw68o3VH4BT4T0TEiJIKbv3Uzv9v8O17b8RoXTL6AaxdcO6ZzKf1eIbefXzpLV1RUSP9++ctfMmPGDIqKimhtbaW1tZWioiJmzZrFQw895I/LCwKcfxX+i0c/ehSA83LPY1rSNJkjEggEgpMnPyGf8/PPB2D1a6spayyTOSLBcPh91NjPf/5znnrqKXJyhoY35uTk8Nvf/pb77rvP35cXBBi2DhvXvjT4V9OUhClcOOVC1CqxNrBAIAhMLpt5GSmRKfQ4e7j0mUtxDjjlDknwDfx+h6mvr2dgYOCYcpfLNaaF1p555hlSU1PR6/XMmzePL7/88oT7t7e384Mf/ID4+Hh0Oh3Z2dl8+OGHJ31df2CxWOQOwe+cjKPL7eKal66hsbORGEMMy+csRxes82N0p05VT5XcIfgdpTsKv8BnIjtq1BpuO+c29EF6CusKufONO0/6HEq/V8jt5/dEaOHChdx2223s2bNHKtu9eze33377SQ+h37BhA2vXruWBBx5gz549TJ8+ncWLF9PY2Djs/k6nk/PPP5/KykreeustrFYrL7zwAomJiafk5CuioydmvxdfcjKOj370KJuLNhOsCebSGZdiMU78X/56R73cIfgdpTsKv8BnojtGGaK44cwbAFi/dT3v7n33pI5X+r1Cbj+/J0Ivv/wycXFxzJ49G51Oh06nY+7cuVgsFl588cWTOtcTTzzBLbfcwqpVq8jPz2f9+vWEhoby8ssvH/fara2tvPvuu5x55pmkpqZyzjnnMH36dF+onTKFhYVyh+B3Ruv4+aHPuf/v9wNwdtbZFKQW+DMsnzHfPF/uEPyO0h2FX+ATCI4zJ83k7KyzAbj+5eupba0d9bFKv1fI7ef3RCgmJoYPP/yQ4uJi3nzzTd58802Kior48MMPiY2NHfV5nE4nu3fv9nqKpFarWbRoEdu3bx/2mPfee48FCxbwgx/8AIvFwpQpU3j44YdxuVzHvY7D4cBut3v9E/iXlq4WVr6wErfHTY4lh+9O+67oFyQQCBTH8jnLiY+Ix95n57JnL8PlPv69SDB+jNuCTdnZ2WRnZ4/5+ObmZlwu1zHvEi0WC8XFxcMeU15ezieffMLVV1/Nhx9+SGlpKd///vfp7+/ngQceGPaYRx55hHXr1h1TXlRUhMFgkFx6enqorR3K6FNTU1Gr1ZSXl0tl8fHxmEwmioqKpLKoqCji4uKwWq14PB4KCwsxGAykpKRQWVlJd3c3MDivQlZWFvX19bS2tkrH5+fn09rais1mk8oyMjIYGBigqmroPXlycjJ6vZ5Dhw5JZbGxscTExHDw4EFpDRyTyURiYiKlpaXSwnchISGkp6dTU1MjJYIajYbc3FwaGhpobm6WzpmTk0NXVxeHDx8eti6OOCYkJGA0Gr0+q6ioKCwWC8ufXk5tWy2TTJN4dPGjNHoayQ/Pxxg0OAFWr6uXr+xfkRaahkU39Pl/0fYF8bp4UkJTpLJ9HfvQa/TkGoZmoLZ2Welx9TAzYqZUVtVbRX1fPfPM81ChAqDR0Uh5TznTjNOkRRw7Bzop7CwkOyybSG0kAP2efna37yY5JBkVKumv0V3tuzAHm8kIy5Cuc8B+AIApxqGZZcu6y2jrb2O2abZUdrjvMDW9NRSYCghWBQPQ6mylpLuEyeGTCQ8anGysx9XDfvt+0kPTidUN/iHhwcOOth3E6+NJCRmqi70dewnVhHqtw1TcVUyfq48ZETOG6qKninpHvddf1Q2OBip6KphunC452gfsHOw8SI4hB3OwGQCn28mejj1MCplEgj5BOn5n206itFGkh6VLZV/bv0atUjM5fGiYbGl3Ke397cPWxWzTbIJUg01Ui7OFQ92Hhq2LjNAMYnSDCzi7cfNl25ck6BOYFDLJqy7CNGFkG4baoKLOIpxup9dnWNlTic1h86oLm8NGZU8lMyJmoFfrAejo76Coq2jYukgJSSFeHy8d/2Xbl0TrokkP9a4LjUpDfni+VHao+xD2fjsFpqGnobW9tdT21TLHNAeNSgNAs7OZ0u5SpoRPwRA02CZ1u7r52v41mWGZRGsHXzO4PC52tg+ugn60z572PRiCDF51cbDzIAOeAaYZh0ZoVvRU0OhoZJ553jF1MTNiJjr1YP+99v52iruKyTXkYgo2AeBwO9jbsZfU0FTidHHS8TvadhCriyUtNE0q22/fT5AqyKsuSrpK6BroYpZpllRW01vD4b7Dw9bF0Z9h10AXBzoPDFsXSfokkkKSpHPubt+NMdhIVliWV124PC6mGqdKZeU95TQ7mplrniuV1ffVU9VbxayIWWjVg/PgtPW3Ye2ykmfIIyI4AoA+dx/7OvZJdbH+kvVc9cZV7Kraxf/89X+4ecbN0jmP15YfaUePIEdbfoTjteVH7mtH+gSHh4czadIkKioq6OnpAYbua3V1dbS1tXE0zc3NXv2GMzMzcTqdVFdXe9WFTqejtLRUKrNYLERHR3vVz5G6KCsb3Sg9v88sfeONN55w+/Fea32Turo6EhMT2bZtGwsWLJDK77nnHrZu3cqOHTuOOSY7O5u+vj4qKirQaAZ/cZ544gl+85vfUF8//Dtlh8PhtRKu3W4nOTnZLzNL19XVkZCQMPKOAcxIjr/79++4a8NdaNQarp57NWdmnTmO0Z06aaFpVPRUyB2GX1G6o/ALfALNcXvZdl7Z9goqlYp/3fUvFuWfuL+s0u8V/vKTdWbpo/lm1tff38+BAwdob2/n29/+9qjPEx0djUajOWakWUNDA3FxccMeEx8fT3BwsJQEAeTl5WGz2XA6ncPOZnmkH9N4oOQv9hFO5Li7ajc/fuvHAJyZcSbzMyb+e/5vEkiN71hRuqPwC3wCzXFBxgIO1h/ky4ovuer5qyh6qIiY8Jjj7q/0e4Xcfn7viPHOO+94/Xv//fcpLy9nxYoVzJ8/+hufVquloKCAzZs3S2Vut5vNmzd7PSE6mjPPPJPS0lLcbrdUVlJSQnx8vOxTegNer62UyvEc7b12VvxhBf2ufjJiMrh0xqVo1Jph953ITDdOjI73/kTpjsIv8AlEx2vmXUOMIYaW7haWPbfM6z71TZR+r5DbT5YeqWq1mrVr1x6zFMdIrF27lhdeeIFXX32VoqIibr/9drq7u1m1ahUA1113Hffee6+0/+23305rayt33nknJSUlfPDBBzz88MP84Ac/8KnPWHE6lT+x1nCOHo9ncJbVpjKMeiNXFlyJQW+QIbpTJ0Qz9oUUAwWlOwq/wCcQHXXBOlafuxqNWsNnhz7j4Q8fPu6+Sr9XyO03bp2lv0lZWdmwEy2eiBUrVtDU1MT999+PzWZjxowZfPzxx1IH6urqatTqodwuOTmZf/7zn9x9991MmzaNxMRE7rzzTn7yk5/41EVwcvzxv3/kr1/+FbVKzZIpS0iLSRv5IIFAIFAYSeYklhcs5687/8ov/vELFuYuZEHm8G84BP7D74nQ2rVrvX72eDzU19fzwQcfcP3115/0+dasWcOaNWuG3bZly5ZjyhYsWMAXX0ysxfiOEBoaKncIfuebjgfrDrLm9cHPb27qXM7OOVuOsHyGfUD50yso3VH4BT6B7HhOzjkcrD/IV7VfccX6Kyh6sIiI0AivfZR+r5Dbz++jxs477zyvn9VqNTExMXz729/mxhtvJChItodSo2K0vc4FI9Pr7GXuw3M5cPgAkyIncce378AYIupUIBCc3vQ4e1j3j3W097Rz4ZQL+eCHH6BSqeQOK+AZ7f3b732EPv30U69/mzdv5o033uDWW2+d8EmQvzl6fgSlcrTjXRvu4sDhA4TpwlhWsEwRSdDRc/QoFaU7Cr/AJ9AdQ7WhrD57NWqVmo8OfMTvNv/Oa7vS7xVy+/k9Efr2t79Ne3v7MeV2u/2khs8rkc7OTrlD8DtHHDfu3Mjznz2PChUX5F9ATlxgN1xHODKZnpJRuqPwC3yU4JgWk8alMy4F4J637mFfzT5pm9LvFXL7+T0R2rJly7A9wvv6+vjPf/7j78sLJgDlTeXc8qdbAJiVMouFeQtljkggEAgmHhdMvoDcuFz6Xf0sfWYp3Y5uuUM6LfDbu6n9+/dL/z948KDXkhAul4uPP/54wqwCLxenw6tBt8rNij+swN5nJyEigWUFywjWBMsdls9wupU9rBWU7yj8Ah+lOKpVam7+1s384r1fUNVSxY2v3MiG2zYo/l4ht5/fOkur1Wqps9dwlwgJCeGpp54acQkOuRGdpU+NH238EU9seoKQ4BBu+tZNTE2cOvJBAoFAcBpjtVl5YtMTALx4/YvcdNZNMkcUmMjeWbqiooKysjI8Hg9ffvklFRUV0r/Dhw9jt9snfBLkb45+SqZEPtj/gfTLvDBvIVMSpoxwROBx9MKeSkXpjsIv8FGaY05cDhdOuRCANa+v4b8H/itzRP5F7nuh3xKhlJQUUlNTcbvdzJ49m5SUFOlffHy81/pfpystLS1yh+A3altruf7lwXmipiVNY/HkxYocDnr0iutKRemOwi/wUaLjxdMvJj06nb7+Pm756y04+h0jHxSgyH0v9MuLuffee48LL7yQ4OBg3nvvvRPue8kll/gjBIGMDLgGuPqlq2npbiEvJo/lBcvRBsm/tptAIBAEChq1hlvPuZV1762jqLGI7//l+7x0w0tyh6VI/JIILV26FJvNRmxsLEuXLj3ufiqVCpfL5Y8QBDLy0PsP8VnJZ2iDtDz6nUexoexXgAKBQOAPzKFmbjzzRp7Z8gwv//dlFk9ezPI5y+UOS3H4fWbpQMefnaVdLpfiXhF+WvwpC59YiMfj4YL8C1hWsAwPyv2KadDgQtnJvNIdhV/go3THjTs3srl4MwadgQO/OEBKdIrcIfkUf90LZe8sLRgZuz1w18cZjkZ7I1e/eDUej4e8+DwumnYRMdoYucPyK1HaKLlD8DtKdxR+gY/SHW+bfxtJ5iS6HF0sfXYpA66TW7B8oiP3vdAvr8Z+//vfj3rfH/7wh/4IISCoq6vDbA78GVEB3G431//xeuo76okKi2L57OXog/Wkh6XT6GyUOzy/oXQ/UL6j8At8lO6YY8xh9Tmreej9h9hXs48fvfkjfnfV70Y+MECQ+17ol0Tot7/97aj2U6lUp3UipCQe3/Q4Hx/4mCB1EBdPv5gEk/JGcQgEAoFcxITHcO2Ca3nxPy/y1OanWDx5MUumLpE7LEXgl0SooqLCH6cVTFC+KPuCn739MwDOyjqLeWnzZI5IIBAIlMec1DkcrDvItrJtXP3i1RQ/VIzFaJE7rIBnXPsIeTyeYWeZPl1JT0+XO4RTpr2nnZUvrGTAPUBmbCaXTr8UtXroa/W1/WsZo/M/SvcD5TsKv8BH6Y5H+62cuxKL0UJ7TzuXPXMZbrdbxsh8g9z3wnFJhF566SWmTJmCXq9Hr9czZcoUXnzxxfG49IQm0L/AHo+Hm1+9mcqWSkwhJpbPXk6oLtRrH7VK2f3xle4HyncUfoGP0h2P9tMGaVl9zmqC1EFsL9/OA+89IGNkvkHue6Hfvz33338/d955JxdffDFvvvkmb775JhdffDF33303999/v78vP6GprKyUO4RT4g9b/8Df9vwNjUrDkqlLSIk6dkjn5PDJMkQ2fijdD5TvKPwCH6U7ftMvwZTAyrkrAXj4w4fZat0qR1g+Q+57od+XfH3uued44YUXWLlypVR2ySWXMG3aNO644w4efPBBf4cg8AP7a/dz14a7AJifPp+zss6SNyCBQCA4jTgz80wO1h1kd/Vulv9hOUUPFREZFil3WAGJ358I9ff3M3v27GPKCwoKGBhQ1lwIpwvdjm5W/GEFjgEHqVGpXDbrMjRqZU0MKRAIBBMZlUrFdWdcR1RYFI2djaz4wwrRB3eM+D0Ruvbaa3nuueeOKX/++ee5+uqrT/p8zzzzDKmpqej1eubNm8eXX345quPeeOMNVCrVCZf8GG8SExPlDmFMrHl9DcW2YsL14VxZcCXh+vDj7lvaXTqOkY0/SvcD5TsKv8BH6Y7H89MH61l9zmo0Kg3/Lvo3v/nnb8Y5Mt8g973Q70ts3HHHHfzpT38iOTmZ+fPnA7Bjxw6qq6u57rrrCA4OlvZ94oknTniuDRs2cN1117F+/XrmzZvHk08+yZtvvonVaiU2Nva4x1VWVnLWWWeRnp5OZGQk77777qjj9+cSGwMDAwQF+f3tpE957YvXuPala1GpVCybtYxF+YtOuH+QKogBj3Kf/CndD5TvKPwCH6U7juT374P/5s3dbxKkDmLbT7cxJ23OOEZ36vjrXjhhltg4cOAAs2bNIiYmhrKyMsrKyoiOjmbWrFkcOHCAvXv3snfvXvbt2zfiuZ544gluueUWVq1aRX5+PuvXryc0NJSXX375uMe4XC6uvvpq1q1bN6oheg6HA7vd7vXPX1itVr+d2x+U2EpY/dpqAGanzObcnHNHPGa26djXokpC6X6gfEfhF/go3XEkv4V5C5mcMJkB9wCXP3c5nX2d4xSZb5D7Xuj3xxGffvqpT87jdDrZvXs39957r1SmVqtZtGgR27dvP+5xDz74ILGxsdx000385z//GfE6jzzyCOvWrTumvKioCIPBAEB2djY9PT3U1tZK21NTU1Gr1ZSXl0tl8fHxmEwmioqKpLKoqCji4uKwWq14PB4KCwsxGAykpKRQWVlJd3c3AFqtlqysLOrr62ltbZWOz8/Pp7W1FZttaEX3jIwMBgYGqKqqksqSk5PR6/UcOnRIKouNjSUmJoaDBw9K75JNJhOJiYmUlpbicDgACAkJIT09nZqaGikRHPAMcMPbN9Dt6GZ24mzWf3c9QeogdrXvwhRsIjMsU7pOYWchbo+bqcapqFAx3zyf8u5yWpwtzDEP/aVS11dHdW81syJmoVVrAWjrb8PaZSU/PB9j0GAG3+vq5Sv7V6SFpmHRDU0e9kXbF8Tr4kkJHRqttq9jH3qNnlxDrlRm7bLS4+phZsRMqayqt4r6vnrmmeehQgVAo6OR8p5yphmnEaoZnAagc6CTws5CssOyidQOdkTs9/Szu303ySHJkh/ArvZdmIPNZIRlSNc5YD8AwBTjFKmsrLuMtv42r8btcN9hanprKDAVEKwafEra6mylpLuEyeGTCQ8afP3Y4+phv30/6aHpxOoGn4J68LCjbQfx+nhSQobqYm/HXkI1oeQYcqSy4q5i+lx9zIiYMVQXPVXUO+olD4AGRwMVPRVMN06XHO0Ddg52HiTHkIM5eHA6fKfbyZ6OPUwKmUSCfmg28Z1tO4nSRpEeNvTHx9f2r1Gr1F4jYEq7S2nvbx+2LmabZhOkGmyiWpwtHOo+NGxdZIRmEKMbXNPOjZsv274kQZ/ApJBJXnURpgkj25AtlRV1FuF0O70+w8qeSmwOm1dd2Bw2KnsqmRExA71aD0BHfwdFXUXD1kVKSArx+njp+C/bviRaF016qHddaFQa8sPzpbJD3Yew99spMBVIZbW9tdT21TLHNAeNarAfXrOzmdLuUqaET8EQNNgmdbu6+dr+NZlhmURrowFweVzsbN8J4OWzp30PhiCDV10c7DzIgGeAacZpUllFTwWNjkbmmYcmSD1SFzMjZqJT6wBo72+nuKuYXEMupmATAA63g70de0kNTSVOFycdv6NtB7G6WNJC06Sy/fb9BKmCvOqipKuEroEuZplmSWU1vTUc7js8bF0c/Rl2DXRxoPPAsHWRpE8iKSRJOufu9t0Yg41khWV51YXL42KqcapUVt5TTrOjmbnmuVJZfV89Vb1Vw7ZfeYY8IoIjAOhz97GvY98xdfFF2xfE6eJIDU2Vyr7q+AqtWkteeJ5XXYD3Z1jdW01dXx1zzXNR/9/zjJjzY1i1YRW1bbV875nv8cjiRwgNDT2mLddoNOTm5tLQ0EBzc7N0zpycHLq6ujh8+LBUNtx9LSEhAaPRSHFxsVR29H3tSN/f8PBwJk2aREVFBT09PcDQfa2uro62tjaOprm5mYaGBunnzMxMnE4n1dXVUllycjI6nY7S0qFXhRaLhejoaAoLC6WyI/e1srIyRkPArD5fV1dHYmIi27ZtY8GCBVL5Pffcw9atW9mxY8cxx3z++edcddVV7Nu3j+joaG644Qba29tP+GrM4XBICQEMPlpLTk72y6uxwsJCJk8OjGGfd7x+B09/+jSh2lBu+dYt5Cfkj3wQg7+8X7R94efo5EPpfqB8R+EX+CjdcbR+pY2lPPavx/B4PDx79bPcfu7t4xDdqeOve+FoX435/YlQX18fTz31FJ9++imNjY3HTJy0Z88ev1y3s7OTa6+9lhdeeIHo6OhRH6fT6dDpdH6J6ZucTFxy8s6ed3j606cBOD/vfPLi80Y4YojDfYdH3imAUbofKN9R+AU+SnccrV9mbCbfnfpd/rH/H9y94W7OzjqbyYkT/49tue+Ffk+EbrrpJv71r3+xbNky5s6di0qlGtN5oqOj0Wg0Xo/OABoaGoiLiztm/7KyMiorK7n44oulsiNJWFBQEFarlYyMjGOOG08slom/RkxVSxU3vnojADOTZ7Iof9FJfYY1vTX+Cm1CoHQ/UL6j8At8lO54Mn5Lpi6h2FbMocZDXPrMpXz9i68J0Yb4MbpTR+57od8Toffff58PP/yQM88885TOo9VqKSgoYPPmzdIQeLfbzebNm1mzZs0x++fm5vL1197rz9x33310dnbyu9/9juTk5FOKxxcUFxeTm5s78o4y0T/Qz8oXVtLe006cMY5ls5ehDdKe1Dlmm2azq32XnyKUH6X7gfIdhV/go3THk/FTq9XccvYtrHtvHWVNZdz6p1v5881/9nOEp4bc90K/jxpLTEwkPPz488ycDGvXruWFF17g1VdfpaioiNtvv53u7m5WrVoFwHXXXSd1pj6yptnR/0wmE+Hh4UyZMgWt9uRu6P7A5XLJHcIJuf+9+9leth19kJ7LZl1GtOHkH18e6eyqVJTuB8p3FH6Bj9IdT9YvIiSCm791MwCv7XiNP2+f2ImQ3PdCvydCjz/+OD/5yU+8RjSNlRUrVvDYY49x//33M2PGDPbt28fHH38sPVarrq6mvr7+lK8jgH8V/otHP3oUgPNyz2Na0rQRjhAIBALBRCE/IZ/z888HYPVrqylrHN0IqtMRv6fRs2fPpq+vj/T0dEJDQ70mUAS8hoaPhjVr1gz7Kgxgy5YtJzz2lVdeOalr+Rtfj0LzFbYOG9e+dC0AUxKmcOGUC8e8unOLs8WXoU04lO4HyncUfoGP0h3H6nfZzMsosZVQ1VrFpc9cyp6f7znp7g3jgdz3Qr8Pn1+0aBHV1dXcdNNNWCyWYzraXn/99f68/Cnjz5mlJyIut4vFTy5mc9FmYgwx3LHwDizGid+pWyAQCATH0tLVwoP/eJC+gT5Wn7Oa5645dskrpTJhhs9v27aN7du3M336dH9fKuAoLy8f1WzX48mjHz3K5qLNBGuCuXTGpaecBE0On0xhZ+HIOwYoSvcD5TsKv8BH6Y6n4hdliOKGM29g/db1rN+6nsWTF7N05lLfBniKyH0v9HsfodzcXHp7e/19mYBkotXL54c+5/6/3w/A2VlnU5BaMMIRI3NkFmClonQ/UL6j8At8lO54qn4zJ83k7KyzAbj+5eupba0d4YjxRe57od8ToUcffZQf/ehHbNmyhZaWlnFbx0twcrR0tbDyhZW4PW5yLDl8d9p3x9wvSCAQCAQTi+VzlhMfEY+9z85lz16Gyz2xRy2PJ36/033nO99h+/btLFy4kNjYWMxmM2azGZPJhNls9vflJzTjNYP1SHg8Hm585UZq22oxh5pZPns5obpQn5y7x9Xjk/NMVJTuB8p3FH6Bj9IdfeEXrAnm9nNvJ1gTzK6qXfzs7Z/5IDLfIPe90O+dpbdu3XrcbV9//fVxR4BNFE6HztK/3/x77nzjTjRqDVfPvZozs05t8kuBQCAQTEy2l23nlW2voFKp+Ndd/2JR/iK5Q/Ibo71/+/2J0DnnnOP1b9asWVitVn784x9z5513+vvyE5qjV/mViz1Ve/jxWz8G4MyMM5mfMX+EI06OjFB5lzHxN0r3A+U7Cr/AR+mOvvRbkLGAuWlz8Xg8XPX8VTR3No98kJ+R+144bp1APvvsM66//nri4+N57LHH+Pa3v80XXyh3teDR0N7eLuv1O/s6WfH8CpwDTjJiMrh0xqVo1BqfXiNGF+PT8000lO4HyncUfoGP0h197XfNvGuIMcTQ0t3CsvXL8POLoRGR+17o10TIZrPx6KOPkpWVxZVXXonRaMThcPDuu+/y6KOPMmfOHH9eXnACPB4Pq/+8mtLGUowhRq4suBKD3iB3WAKBQCDwM7pgHavPXY1GrWFryVb+94P/lTskWfFbInTxxReTk5PD/v37efLJJ6mrq+Opp57y1+UCkpNZxd3X/PG/f+T1L19HrVKzZPIS0mLS/HIdN26/nHeioHQ/UL6j8At8lO7oD78kcxLLC5YDsO4f69heut3n1xgtct4LwY+dpYOCgvjhD3/I7bffTlZWllQeHBzMV199RX5+vj8u63OU2Fn6YN1BZv/vbHr7e5mfNp9rF1xLkEbZixYKBAKBwBuPx8NzW57jq9qviI+Ip+jBIiJCI+QOy2fI3ln6888/p7Ozk4KCAubNm8fTTz9Nc7P8nbImEk1NTeN+zV5nLyueX0Fvfy+TIidxRcEVfk2CEvQJfjv3REDpfqB8R+EX+Cjd0V9+KpWKG868AVOoifqOela+sFKW/kJy3AuPxm+J0Pz583nhhReor6/ntttu44033iAhIQG3282mTZvo7Oz016UDhsbGxnG/5l0b7uLA4QOE6cJYVrAMY4h/n3JNCpnk1/PLjdL9QPmOwi/wUbqjP/1CtaGsPns1apWajw58xO82/85v1zoectwLj8bvo8bCwsK48cYb+fzzz/n666/50Y9+xKOPPkpsbCyXXHKJvy8vOIqNOzfy/GfPo0LFBfkXkBOXI3dIAoFAIJCZtJg0Lp1xKQD3vHUP+2r2yRvQODOuayjk5OTw61//mtraWv7617+O56VPe8qbyrnlT7cAMCtlFgvzFsockUAgEAgmChdMvoDcuFz6Xf0sfWYp3Y5uuUMaN/w+s3Sg48/O0k6nE61W69NzDnudASdnPnomu6p2kRCRwB0L7yAyLNLv1wXQqXU43I5xuZYcKN0PlO8o/AIfpTuOl19nXye/eO8XdDm6WD57ORtu2+D3a4L/7oWyd5YWjExfX9+4XOfet+9lV9UuQoJDuLzg8nFLggDCNGHjdi05ULofKN9R+AU+SnccL79wfTi3nn0rABt3beTlz18el+uO173weIhESEZqamr8fo0P9n/AE5ueAGBh3kKmJEzx+zWPJtuQPa7XG2+U7gfKdxR+gY/SHcfTLycuhwunXAjAD17/AdZ6q9+vOR73whMhEiEFU9tay/UvXw/AtKRpLJ68WPaJqwQCgUAwsbl4+sWkR6fT19/Hpc9eiqNfua8dIQAToWeeeYbU1FT0ej3z5s3jyy+/PO6+L7zwAt/61rcwm82YzWYWLVp0wv2VxIBrgKtfupqW7hZiw2NZXrAcbZD/+yMJBAKBILDRqDXces6thASHYLVZ+f5fvi93SH4loBKhDRs2sHbtWh544AH27NnD9OnTWbx48XHnINiyZQsrV67k008/Zfv27SQnJ3PBBRfIvtLtEVJSUvx27ofef4jPSj5DG6Rl6cylxBjlWZSwqLNIluuOF0r3A+U7Cr/AR+mOcviZQ83ceOaNALz835fZuHOj367lz3vhaAioUWPz5s1jzpw5PP300wC43W6Sk5O54447+OlPfzri8S6XC7PZzNNPP8111103qmv6c9RYX18fer3ep+cE+LT4UxY+sRCPx8MF+Rdw2azLUKvkyXlD1CH0untlufZ4oHQ/UL6j8At8lO4op98bX77Bp9ZPMegMHPjFAVKifZ+0+OteqLhRY06nk927d7No0SKpTK1Ws2jRIrZvH91icT09PfT39xMZefxRUw6HA7vd7vXPX5SVlfn8nI32Rq5+8Wo8Hg958XlcNO0i2ZIggOkR02W79nigdD9QvqPwC3yU7iin37KCZSSZk+hydLH02aUMuAZ8fg1/3AtPhoBZabO5uRmXy4XFYvEqt1gsFBcXj+ocP/nJT0hISPBKpr7JI488wrp1644pLyoqwmAwAJCdnU1PTw+1tbXS9tTUVNRqNeXl5VJZfHw8JpOJoqKhx5pRUVHExcVhtVrxeDwUFhZiMBhISUmhsrKS7u7BSay0Wi1ZWVnU19fT2toqHZ+fn09rays2m00qy8jIYGBggIrKCn7w9x9Q31FPXHgc1827jnNjz5X2q+6tpq6vjrnmuaj/LwducjRR1lPGNOM0QjWhAHQOdFLYWUhWWBZR2igABjwD7GrfRXJIMon6ROmcu9p3YQo2kRmWKZUVdhbi9riZapyKChXzzfMp7y6nxdnCHPMcab+6vjqqe6uZFTELrXqw/1JbfxvWLiv54fkYgwYz+F5XL1/ZvyItNA2Lbujz/6LtC+J18aSEDv2Fsq9jH3qNnlxDrlRm7bLS4+phZsRMqayqt4r6vnrmmeehYrADeaOjkfKe8mHrIjssm0jtYALd7+lnd/tukkOSJb8jdWEONpMRliFd54D9AABTjEOj9cq6y2jrb2O2abZUdrjvMDW9NRSYCghWBQPQ6mylpLuEyeGTCQ8KB6DH1cN++37SQ9OJ1cUC4MHDjrYdxOvjSQkZqou9HXsJ1YSSYxiaQby4q5g+Vx8zImYM1UVPFfWOeskDoMHRQEVPBdON0yVH+4Cdg50HyTHkYA42A+B0O9nTsYdJIZO81kPa2baTKG0U6WHpUtnX9q9Rq9RMDp8slZV2l9Le3z5sXcw2zSZINdhEtThbONR9aNi6yAjNIEY3+OrXjZsv274kQZ/gtSzB3o69hGnCvEbfFHUW4XQ7vT7Dyp5KbA6bV13YHDYqeyqZETEDvXrwr9aO/g6KuoqGrYuUkBTi9fHS8V+2fUm0Lpr0UO+60Kg05IcPLT59qPsQ9n47BaYCqay2t5bavlrmmOagUWkAaHY2U9pdypTwKRiCBtukblc3X9u/JjMsk2htNAAuj4ud7TsBvHz2tO/BEGTwqouDnQcZ8AwwzThNKqvoqaDR0cg887xj6mJmxEx0ah0A7f3tFHcVk2vIxRRsAsDhdrC3Yy+poanE6eKk43e07SBWF0taaJpUtt++nyBVkFddlHSV0DXQxSzTLKmspreGw32Hh62Loz/DroEuDnQeGLYukvRJJIUkSefc3b4bY7CRrLChhcEPdh7E5XEx1ThVKivvKafZ0cxc81yprL6vnqreqmHbrzxDHhHBg4uX9rn72Nex75i6+KLtC+J0caSGpkplX3V8hVatJS88z6suwPszHNe2XOPmD5f8gRV/XcG+mn3c9Ze7+N3Vv/O67x59XxsYGEyUwsPDmTRpEhUVFfT09ABD97W6ujra2to4mubmZhoaGqSfMzMzcTqdVFdXS2XJycnodDpKS0ulMovFQnR0NIWFhVKZyWQiMTFx1AlWwLwaq6urIzExkW3btrFgwQKp/J577mHr1q3s2LHjhMc/+uij/PrXv2bLli1MmzbtuPs5HA4cjqEe8na7neTkZL+8GissLGTy5Mkj7zhKHvvnY/z4rR8TpA7imvnXsCBjwcgH+Zn55vl80faF3GH4DaX7gfIdhV/go3THieC3s3InL/7nRVSoeP+H77Nk6hKfndvX98IjKO7VWHR0NBqNxitjBGhoaCAuLu44Rw3y2GOP8eijj/Kvf/3rhEkQgE6nw2g0ev3zFyPFfTLsKN/BvW/fC8BZWWcxL23eCEeMD5U9lXKH4FeU7gfKdxR+gY/SHSeC35zUOZyRcQYePFz94tU02BtGPmiU+PJeOBYCJhHSarUUFBSwefNmqcztdrN582avJ0Tf5Ne//jUPPfQQH3/8MbNnzz7ufnJwor5KJ0N7TztXPX8VA+4BMmMzuXT6pajVE+OjtTlsI+8UwCjdD5TvKPwCH6U7ThS/lXNXYjFaaO9p5/JnL8ftdvvkvL66F46ViXG3HCVr167lhRde4NVXX6WoqIjbb7+d7u5uVq1aBcB1113HvffeK+3/q1/9ip///Oe8/PLLpKamYrPZsNlsdHV1yaXgxcGDB0/5HB6Ph1v+dAuVLZWYQkwsn72cUF2oD6LzDUe/11YiSvcD5TsKv8BH6Y4TxU8bpGX1OasJUgexrWwbD7z3gE/O64t74akQUInQihUreOyxx7j//vuZMWMG+/bt4+OPP5Y6UFdXV1NfXy/t/9xzz+F0Olm2bBnx8fHSv8cee0wuBZ/zh61/4K3db6FRaVgydQkpUfLOxyAQCAQC5ZJgSmDl3JUAPPzhw2y1bpU5olMnYEaNHWHNmjWsWbNm2G1btmzx+rmystL/AcnI/tr93LXhLgDmp8/nrKyz5A1IIBAIBIrnzMwzOVh3kN3Vu1n+h+UUPVQ0rot5+5qAeiKkNE7lvWi3o5sVf1iBY8BBalQql8+6HI1a48PofMNEebftL5TuB8p3FH6Bj9IdJ5qfSqXiujOuIyosisbORpb/YTmnMgBd9BE6jYmPjx95p+Ow5vU1FNuKCdeHc2XBlRj0Bh9G5jsmwmgHf6J0P1C+o/ALfJTuOBH99MF6Vp+zGo1Kw+aizfzmn78Z87lO5V7oC0QiJCOHDh0a03GvffEar2x7BZVKxXcmf4dMS+bIB8nE0RP3KRGl+4HyHYVf4KN0x4nqNylqEpfPuhyA//fO/2Nnxc4xnWes90JfIRIhGXE6nSd9TImthNWvrQZgTsoczs0518dR+ZYjM/EqFaX7gfIdhV/go3THiey3MG8hUxKmMOAe4PLnLqezr/OkzzGWe6EvEYlQANHX38eK51fQ7egmyZzEFQVXEKQJuP7uAoFAIFAIKpWKG8+6kYiQCGrbarn2pWtPqb+QHIhESEbCwsJOav8fv/lj9tXsI1QbyrKCZZhCTf4JzId09HfIHYJfUbofKN9R+AU+Snec6H5hujBuPftWVCoVf9/3d9ZvXX9yx5/kvdDXBMxaY3Ix2rVK/M07e97h8ucG38VeOv1SLpx6ISqVSrZ4BAKBQCA4mve/ep9/7P8HuiAdu+/bzeRE368fdjIobq0xJVJVVTW6/VqquPHVGwGYmTyT8yefHzBJ0NErnysRpfuB8h2FX+CjdMdA8VsydQlZsVk4Bhxc+syl9Dp7R3XcaO+F/kIkQjIymqU++gf6WfnCStp72okzxrFs9jKCNcHjEJ1vMAeb5Q7BryjdD5TvKPwCH6U7BoqfWq3mlrNvIUwbRllTGbf+6dZRHSf3slciEZrg3P/e/Wwv244+SM/lsy4n2hAtd0gCgUAgEAxLREgEN3/rZgBe2/Eaf97+Z5kjGhmRCMlIUNCJR3z9q/BfPPrRowCcl3se05KmjUdYPsXplndYpL9Ruh8o31H4BT5Kdww0v/yEfM7PPx+A1a+tpqyx7IT7j3Qv9Deis/QIyNVZ2tZhY/q66TR2NjIlYQq3nn0rumDduF1fIBAIBIKx4nK7+NVHv6KqtYrJCZPZ+/O9BAeNb7cO0Vk6ALDZhl8/xu12c+1L19LY2UiMIYblc5YHbBKUEpIidwh+Rel+oHxH4Rf4KN0xEP00ag23nXMb+iA9hXWF3PnGncfd93j3wvFCJEIy0tLSMmz5ox89yr+L/k2wJphLZ1yKxWgZ58h8R7xe3jVk/I3S/UD5jsIv8FG6Y6D6RRmiuOHMGwB4butzvLv33WH3O969cLwQidAE47+l/+X+9+4H4OyssylILZA5IoFAIBAIxsbMSTM5O+tsAK5/+XoOtx2WOaJjEYnQBKK1u5WVL6zE5XaRY8nhu9O+i1olPiKBQCAQBC7L5ywnPiIee5+dy569DJfbJXdIXojO0iPgz87SbrcbtXow0fF4PCx9ZinvffUe5lAza85bQ1Jkkk+vJwdq1Lhxyx2G31C6HyjfUfgFPkp3VIJfg72Bh95/iH5XP/csvodfLfuVtO3oe6EvEZ2lA4D29nbp/0998hTvffUeGrWG7077riKSIIBonbLnPVK6HyjfUfgFPkp3VIKfxWjh6nlXA/Cbf/2Gfx/8t7Tt6HuhHIhESEbq6+sB2FO1hx+/9WMAzkg/gwUZC+QMy6ekh6bLHYJfUbofKN9R+AU+SndUit+CjAXMTZuLx+PhquevormzGRi6F8qFSIRkprOvkxXPr8A54CQjJoOlM5eiUWvkDksgEAgEAp9zzbxriDHE0NLdwrL1y5gIvXMCLhF65plnSE1NRa/XM2/ePL788ssT7v/mm2+Sm5uLXq9n6tSpfPjhh+MU6ch4PB5W/3k1pY2lGPVGriy4EoPeIHdYAoFAIBD4BV2wjtXnrkaj1rC1ZCu//OCXcocUWInQhg0bWLt2LQ888AB79uxh+vTpLF68mMbGxmH337ZtGytXruSmm25i7969LF26lKVLl3LgwIFxjnx4Pm/8nNe/fB21Ss2SKUtIi0mTOySf87X9a7lD8CtK9wPlOwq/wEfpjkrzSzInsbxgOQC/+McvaFI1yRpPQI0amzdvHnPmzOHpp58GBnuaJycnc8cdd/DTn/70mP1XrFhBd3c377//vlQ2f/58ZsyYwfr164e9hsPhwOFwSD/b7XaSk5N9PmrsYN1BZv/vbHr7e5mfNp/rzrhOka/EjEFG7AN2ucPwG0r3A+U7Cr/AR+mOSvTzeDw8t+U5vqr9iviIeIoeLCIiNMKn1xjtqDF5Vzo7CZxOJ7t37+bee++VytRqNYsWLWL79u3DHrN9+3bWrl3rVbZ48WLefffd417nkUceYd26dceUFxUVYTAMvrbKzs6mp6eH2tpaaXtqaipqtZry8nKpLD4+HpPJRFFRkVQWFRWFxWLhmj9cQ29/LwsmLeCeb93Dp7Wf8p3U7xAfNjiDaKezk7cOvcWC+AXkRuZKx79S+Ap5kXnMi58nlb1T+g5hwWFckHKBVPZJzSe09LZwZfaVUtnuht3sb97P9fnXS/MTlbaX8p/D/2FpxlLMejMATT1NvF/xPucln0eqMRUAp8vJX4r/wqzYWUyPmS6d86/FfyXRkMjZSWdLZR9WfIjL4+Li9IvRqDS4PC7+W/dfKjoquCbvGmm/A80H2Nmwk6tyriIkKASAms4a/l39by5MvZC4sDgA7E47fzv0N85IOIMcc450/B8L/8jkqMnMjZsrlb196G3CteGcn3K+VLa5ejNtjjaWZS2TynY17OLr5q+5YfINqFABcKjtEJ/Xfc5lmZdh0pkAaOxp5IOKD/h28rdJMQ5Oc9/n6uOvxX+lwFLAZPNkXJ7BOTFeL36d5PBkvpX4Lek6H5R/AMBF6RdJZf85/B9qOmv4Xu73pLL9zfvZ3bCblbkr0Wv0AFTZq/ik5hMuSruI2NBYANod7bxT+g5nJZxFljkLAA8eXil8hanRU5ltmS2d861Db2HWmVk4aaFUtqlqE53OTi7Pulwq+9L2JYUthayavEoqs7ZZ2Va3jSuyrsCsM+PyuLB12/io8iMWTVpEcngyAL0DvbxhfYM5ljlMiZ4iHf9a0WukRaRxZsKZUtk/yv+BRqVhSdoSqeyz2s843HWYlbkrpbKvmr5iT+Mers69Gq1GC0ClvZJPaz7lu2nfJSY0BoC2vjbeLXuXbyV+i0xTJgBuj5tXD77KtOhpFFiGJiN9s+RNokKi+Hbyt6Wyf1X9i+7+bhZkLZA+wx31OyhqLeKGyTdI+xW3FrO9fjvLspYRrg0HoL67no8rP+b8SeeTFD44wrOnv4cNJRuYGzeXyVGTpeP/fPDPZJgyOCPhDKnsvbL3CFYHc2HahVLZ1tqt1HfXc1XOVVLZvsZ97G3ayzV51xCsHlynqaKjgi21W7g4/WKiQwZHE7X0tfBe2XucnXg2GaYMAAbcA/y56M/cOPlGPAz9vbvRupGY0BjOSz5PKvtn5T/pHehlaeZSqeyL+i+wtlm5Pv96qayotYgv6r/gyuwrMQQPtod1XXX8s+qfLE5ZTIIhAYCu/i7eLHmT+fHzyYvMk45/9eCr5JhzmB8/Xyp7t/RdQoJCWJy6WCr7tOZTmnqaWJ6zXCrb07iHr5q+4tq8awlSD966ytrL+OzwZ9w85WbpM2zubeYf5f/g3KRzSYsYfMre7+7ntaLXmBkzkxmxM6RzvmF9g/iweM5JOkcq+6jiI/rd/VyScYlUtq1uG2XtZVybf61UVthSyJe2L1mRvYLQ4FAAajtr2VS9yedt+dzkoTYO5GnLj+DLtjx/ST5XvXEVdR113PHaHfzkzJ9I58zMzMTpdFJdXS2VJScno9PpKC0tlcosFgvR0dEUFhZKZSaTicTERMrKTrzY6xEC5olQXV0diYmJbNu2jQULhkZV3XPPPWzdupUdO3Ycc4xWq+XVV19l5cqhRvbZZ59l3bp1NDQ0DHud8XoiVNpYyk0v3MT3z/8+5jCzz8470Yj3xFOvkndEgD9Ruh8o31H4BT5Kd1SyX7GtmI/2fMTvrv0d2XHZPj234p4IjRc6nQ6dzv8LnGbGZvLs0meZPHnyyDsHMIWFhVww+YKRdwxQlO4HyncUfoGP0h2V7HfB5AtYGLfQ50nQyRAwnaWjo6PRaDTHPMlpaGggLi5u2GPi4uJOav/xJilJGZMmngilOyrdD5TvKPwCH6U7Cj//EjCJkFarpaCggM2bN0tlbrebzZs3e70qO5oFCxZ47Q+wadOm4+4/3oSGhsodgt9RuqPS/UD5jsIv8FG6o/DzLwGTCAGsXbuWF154gVdffZWioiJuv/12uru7WbVqsJPndddd59WZ+s477+Tjjz/m8ccfp7i4mF/84hfs2rWLNWvWyKXgRUlJidwh+B2lOyrdD5TvKPwCH6U7Cj//ElB9hFasWEFTUxP3338/NpuNGTNm8PHHH2OxWACorq72WrjtjDPO4PXXX+e+++7jZz/7GVlZWbz77rtMmTLleJcQCAQCgUBwGhFQiRDAmjVrjvtEZ8uWLceUXXnllVx55ZXH7jxKjgyqs9t9P4dDV1eXX847kVC6o9L9QPmOwi/wUbqj8BsbR8450uD4gEuExpvOzk5gcP4CgUAgEAgEgUVnZycREcefrDFg5hGSC7fbTV1dHeHh4ahUKp+d98j8RDU1NT6dn2gioXRHpfuB8h2FX+CjdEfhN3Y8Hg+dnZ0kJCR4dZv5JuKJ0Aio1Wq/Du0zGo2K/HIfjdIdle4HyncUfoGP0h2F39g40ZOgIwTUqDGBQCAQCAQCXyISIYFAIBAIBKctIhGSCZ1OxwMPPDAuy3nIhdIdle4HyncUfoGP0h2Fn/8RnaUFAoFAIBCctognQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtEUkQgKBQCAQCE5bRCIkEAgEAoHgtCVI7gAmOm63m7q6OsLDw1GpVHKHIxAIBAKBYBR4PB46OztJSEhArT7+cx+RCI1AXV0dycnJcochEAgEAoFgDNTU1JCUlHTc7SIRGoHw8HBgsCKNRqNPz11UVEReXp5PzznRULqj0v1A+Y7CL/BRuqPwGxt2u53k5GTpPn48RCI0AkdehxmNRp8nQgaDwefnnGgo3VHpfqB8R+EX+CjdUfidGiN1axGdpWXEZDLJHYLfUbqj0v1A+Y7CL/BRuqPw8y8BlQh99tlnXHzxxSQkJKBSqXj33XdHPGbLli3MmjULnU5HZmYmr7zyit/jHC2JiYlyh+B3lO6odD9QvqPwC3yU7ij8/EtAJULd3d1Mnz6dZ555ZlT7V1RUcNFFF3Heeeexb98+7rrrLm6++Wb++c9/+jnS0VFaWip3CH5H6Y5K9wPlOwq/wEfpjsLPvwRUH6ELL7yQCy+8cNT7r1+/nrS0NB5//HEA8vLy+Pzzz/ntb3/L4sWLhz3G4XDgcDikn+12+6kFfQKOvo5SUbqj0v1A+Y7CL/BRuqNS/TqqOih5s4R9r+zDtNFEdH60LHEEVCJ0smzfvp1FixZ5lS1evJi77rrruMc88sgjrFu37pjyoqIiDAYDANnZ2fT09FBbWyttT01NRa1WU15eLpXFx8djMpkoKiqSyqKiooiLi8NqteLxeCgsLMRgMJCSkkJlZSXd3d0AaLVasrKyqK+vp7W1VTo+Pz+f1tZWbDabVJaRkcHAwABVVVVSWXJyMnq9nkOHDkllsbGxxMTEcPDgQTweDzD4bjYxMZHS0lLply0kJIT09HRqamqkRFCj0ZCbm0tDQwPNzc3SOXNycujq6uLw4cPD1sURx4SEBIxGI8XFxcPWxcDAADA4Sm/SpElUVFTQ09PjVRd1dXW0tbVJx0+ePJnm5mYaGhqksszMTJxOJ9XV1V51odPpvP7qsFgsREdHU1hYKJUNVxehoaGkpaVRXV1NZ2fnMXVxxO9IXXR2dlJXVyedMy0tDRh8OnmEhIQEwsPDsVqtUll0dDQWi4Xi4mJcLtdx6+LIK97Dhw/T3t4+Yl04HA5qamqkskmTJqHVakesC7PZTEJCAocOHZIch6uLoKAgcnJysNlstLS0SMfn5uZit9u96iI9PR23201lZaVUlpiYiMFgGLEujEYjycnJlJeX09vbe9y6UKlU5Ofn09TURGNjo3TOrKws+vr6vOoiJSWFoKAgr88wLi6OyMhIDh48KO0XGRlJfHw8hw4dwul0AhAWFkZqaipVVVV0dXWdsC7y8vJob2+nvr7+hHWRlJREaGgoJSUlUllMTAyxsbEUFRXhdrsBiIiIICkpyasu9Ho9GRkZ1NbW0tHRAYBarSYvL8/LD4Zvv47URVlZmVQ2XPt1pC5KSkro7+8HkNqvo+siODiY7OzsY9qv4epiuPZruLo40n4NVxdHOx5pv4ari8bGRpqamk5YF2Npy4+0X/5qy7/5GcrRlh/hVNvyuJA4dr60k/J3ymn/ql06x44nd5B6Z6r0sy/a8qO/zydC5TlSiwGGSqXinXfeYenSpcfdJzs7m1WrVnHvvfdKZR9++CEXXXQRPT09hISEHHPMcE+EkpOT6ejo8Hmv9oqKCulGqVSU7qh0P1C+o/ALfJTuGOh+3bZurG9ZsW6wcvjzoUQLFRgSDOgSdJzzi3NIX5Lu0+va7XYiIiJGvH8r+onQWNDpdOh0unG5ViB/sUeL0h2V7gfKdxR+gY/SHQPRr6eph5K/lWDdaKV2ay0e99Azl7CEMMxZZuJmx2FMM9Je0o4+Ui9brIpOhOLi4rxeFQA0NDRgNBqHfRo03lRXVzNp0iS5w/ArSndUuh8o31H4BT5KdwwUv97WXg69fQjrRivVn1TjcR2V/MSFYcoyYZltwZRhQhOskbYdedUuF4pOhBYsWMCHH37oVbZp0yYWLFggU0TeyP3hjwdKd1S6HyjfUfgFPkp3nMh+fe19lL5binWjlapNVbgH3NK2UEsopszB5MecaUaj1Qx7jiN97+QioBKhrq4ur05SFRUV7Nu3j8jISCZNmsS9997L4cOH+dOf/gTA6tWrefrpp7nnnnu48cYb+eSTT9i4cSMffPCBXAoCgUAgEAQ0DruDsvfKsG60UvnPSlxOl7QtJCZkMPkpsBCZHYlGN3zyM5EIqERo165dnHfeedLPa9euBeD666/nlVdeob6+3quHeVpaGh988AF33303v/vd70hKSuLFF1887tD58UajmfhfkFNF6Y5K9wPlOwq/wEfpjhPBz9ntpPz9cqwbrJR/WI7LMZT86KP0mDPNxM6KJTI3kiD9yaUWIy2B4W8CdtTYeDHaXucCgUAgECiJ/t5+Kj6soHhDMeXvlzPQOyBt05l1UvITlRdFUMjYn6u0FLaQuzKXhPkJvghbQowaCwAaGhqwWCxyh+FXlO6odD9QvqPwC3yU7jiefgN9A1T+s5LiDcWUvVdGf3e/tE0XocOUaSJmZgxRk6PQhmp9cs3unm6fnGesiERIRpqbmxX9ywvKd1S6HyjfUfgFPkp39Lefy+miclMl1g1WSv9eitM+1HlZa9RiyjARMz2G6KnRaA2+SX6Opq+3z+fnPBlEIiQQCAQCwWmGq99F9SfVWDdYOfTOIRztQxMJB4cHY0ofTH5ipsf4JfmZSIhESCAQCASC0wC3y03NlhqsG62U/K2EvpahJzHBYcGYMkxET4smZnoMOuP4TCw8ERCdpUfAn52lBwYGCApSdi6qdEel+4HyHYVf4KN0x1Pxc7vcHP7vYawbrJS8VUJPY4+0LSg0iIj0CKKnRGOZaUFnkif5afq6ifyr80Vn6dORzs5OzGaz3GH4FaU7Kt0PlO8o/AIfpTuerJ/H7aHuizqsG6xY37TSXT/UGTkoJIiItAiipkRhmTWY/Mg9fF1MqHgaU1dXp+hfXlC+o9L9QPmOwi/wUbrjaPw8Hg+2nTaKNxRT8mYJnTVDs1FrdJqh5KfAgt6slz35OZrubjFqTCAQCAQCwUni8Xho3NtI8YZirBut2Cvt0jaNVoMxzUhUXhSW2RZCokJQqSdO8jOREImQQCAQCAQBgsfjofnrZin5aS9tl7apg9UYUweTn7g5cYREi+RnNIhESEbS0tLkDsHvKN1R6X6gfEfhF/go3TEtLY3mg82DfX42WmktbpW2qYMGk5/I3EgscyyExYYFXPJjjJB31QaRCAkEAoFAMAFpLWnFutFK0V+LaD04lPyoNCqMKYPJT9zsOMLiAy/5mUiIREhGKioqmDx5stxh+BWlOyrdD5TvKPwCHyU5tpe3Y91oxbrBSuO+RqlcpVERnhxOZM7gkx9DggG1Ri1jpL7D3mEfeSc/IhIhgUAgEAhkpKOqg5I3SyjeUEzDrgapXKUeTH6CE4LJ/HYmhkTlJD8TCZEICQQCgUAwznTWdlLy1mDyU/9F/dAGFYQnhWPONmOZY8GYbMTWaMOYIG8/GiUjEiEZSUjw7SyaExGlOyrdD5TvKPwCn0Bx7LZ1Y31r8LXX4c8PD21QgSHBICU/ESkRqIOGnvyYIkzjH+w4EhYWJuv1RSIkI+Hh4XKH4HeU7qh0P1C+o/ALfCayY09TDyV/K8G60Urt1lo87qFVrcISwjBnmYmbE4cx1YgmWDPsOfR6/XiFKwtarbyLuopESEasVqtiOvgdD6U7Kt0PlO8o/AKfiebY29rLobcPYd1opfqTajyuo5KfuDBMWSYsBRZMGSY02uGTn6OxNdgC5qnXWGhra5P1+iIREggEAoHgFOlr76P03VKsG61UbarCPeCWtoVaQjFlmrDMtmDONI8q+RGMHyIREggEAoFgDDjsDsreK8O60UrlPytxOV3StpCYkMHkp8BCZHYkGp1IfiYqIhGSkejoaLlD8DtKd1S6HyjfUfgFPuPp6Ox2Uv5+OdYNVso/LMflGEp+9FF6zJlmYmfFEpkbSZDeN7dYg8Hgk/NMVPQh8vaBEomQjFgsFrlD8DtKd1S6HyjfUfgFPv527O/tp+LDCoo3FFP+fjkDvQPSNp1ZJyU/UXlRBIX4/rZqNCp76HxYqBg1dtpSXFxMbm6u3GH4FaU7Kt0PlO8o/AIffzgO9A1Q+c9KijcUU/ZeGf3d/dI2nUmHKcNEzMwYoiZHoQ3176gnm81GXFycX68hJ62trSPv5EdEIiQjLpdr5J0CHKU7Kt0PlO8o/AIfXzm6nC4qN1Vi3WCl9O+lOO1OaZvWqB1MfqbHED01Gq1h/IZ8u93ukXcKYDwez8g7+RGRCAkEAoHgtMXV76L6k2qsG6wceucQjnaHtC04PBhT+mDyEzM9ZlyTH8H4IRIhGZnIk4D5CqU7Kt0PlO8o/AKfk3V0u9zUbKnButFKyd9K6Gvpk7YFhwVjyjARPS2amOkx6Iw6X4d70ogJFf2LyiP3M6kJjt1uJyIigo6ODsV3WBMIBAKl4na5Ofzfw1g3WCl5q4Sexh5pW1BoEBHpEURPjcYyw4LOJH/yczrRUthC7spcEub7dtLI0d6/xRMhGamoqCAtLU3uMPyK0h2V7gfKdxR+gc/xHD1uD3Vf1GHdYMX6ppXu+m5pW1BIEBFpEURNicIyazD5UalU4xn2qGlublb0NAgd9g5Zrx9widAzzzzDb37zG2w2G9OnT+epp55i7ty5w+77yiuvsGrVKq8ynU5HX1/fsPuPNz09PSPvFOAo3VHpfqB8R+EX+Bzt6PF4sO20UbyhmJI3S+is6ZS2aXQaItIjiJochaXAgt6sn7DJz9E4nc6RdwpgBvoHRt7JjwRUIrRhwwbWrl3L+vXrmTdvHk8++SSLFy/GarUSGxs77DFGoxGr1Sr9HAhfeoFAIBCMHo/HQ8OeBoo3FGPdaMVeaZe2abQajGlGovKjsMy2EBIZgkot7gOCIQIqEXriiSe45ZZbpKc869ev54MPPuDll1/mpz/96bDHqFSqCTv/gk6n/PfQSndUuh8o31H4BSYej4fmr5sp3lDMgb8coLtq6LWXOliNMdVIVF4UcXPiCIkO7OQnOChY7hD8ikYj7/IjAZMIOZ1Odu/ezb333iuVqdVqFi1axPbt2497XFdXFykpKbjdbmbNmsXDDz98wlWKHQ4HDsfQ8Em73X7cfU+VzMxMv517oqB0R6X7gfIdhV9g0XywebDPz0YrrcVDE/GpgwaTn8jcSCxzLITFhgV08nM0MbExcofgV0wmk6zXD5hEqLm5GZfLdcxU6haLheLi4mGPycnJ4eWXX2batGl0dHTw2GOPccYZZ1BYWEhSUtKwxzzyyCOsW7fumPKioiJpvZfs7Gx6enqora2VtqempqJWqykvL5fK4uPjMZlMFBUVSWVRUVHExcVhtVrp7+9HpVJhMBhISUmhsrKS7u7Bv2q0Wi1ZWVnU19d7zbqZn59Pa2srNptNKsvIyGBgYICqqiqpLDk5Gb1ez6FDh6Sy2NhYYmJiOHjwoDSBlclkIjExkdLSUikBDAkJIT09nZqaGikR1Gg05Obm0tDQQHNzs1cdd3V1cfjw4WHrwuPxoFKpSEhIwGg0en1WR9fFwMDgO+Lw8HAmTZpERUWF9N7/SF3U1dXR1tYmHT958mSam5tpaGiQyjIzM3E6nVRXV3vVhU6no7S0VCqzWCxER0dTWFgolQ1XF6GhoaSlpVFdXU1nZ+cxddHU1CS9bs3JyaGzs5O6ujrpnEc6cFZUVEhlCQkJhIeHe72yjY6Olr7LRyaHG64udDodmZmZHD58mPb29hHrwuFwUFNTI5VNmjQJrVY7Yl2YzWYSEhI4dOgQDocDlUo1bF0EBQWRk5ODzWajpaVFOj43Nxe73e5VF+np6bjdbiorK6WyxMREDAbDiHVhNBpJTk6mvLyc3t7e49aFSqUiPz+fpqYmGhsbpXNmZWXR19fnVRcpKSkEBQVRWloqfYZxcXFERkZy8OBBab/IyEji4+M5dOiQ1FcjLCyM1NRUqqqq6OrqOmFd5OXl0d7eTn19/QnrIikpidDQUEpKSqSymJgYYmNjKSoqkibVi4iIICkpyasu9Ho9GRkZ1NbW0tEx2PFUrVaTl5fn9X2G4duvI3VRVlYmlQ3Xfh2pi5KSEvr7B2daPtJ+HV0XwcHBZGdnH9N+DVcXw7Vf36yL7spu7J/bqX2/luYDQ+2PSqPCmGJEm6jFOMWILlqHTqfDEGOgra1Nqh+1Sk1cfByd9k46u4b6DFksFpxOp1e7Eh0VjUqloqm5SSqLiIggNCSUettQ3IYwA8YIIw22Blzuwe+pXqcnMiqSluYWHM7BOg/SBBFriaWjo0Nq3wES4hPo7u726igcExOD2+WmpXXo+xNpjqSnt8erb6sx3Igh3EB9XT0eBtvy0JBQTGYTTY1N9A8MfjbaYC3RMdG0tbbR2/d/daFWExcXh91ulz4vgDhLHA6Hg7b2E9eFKcKEPkTvdQ8ati70eiIjI2lubpZ+b6S6aO+gu2eoLvq7+mlvb6etcOjavmjLj/4+n4iAGT5fV1dHYmIi27ZtY8GCBVL5Pffcw9atW9mxY8eI5+jv7ycvL4+VK1fy0EMPDbvPcE+EkpOT/TJ8vrCw8IRPp5SA0h2V7gfKdxR+E5P28nasG61YN1hp3DeU1Ko0KsKTw4nMiSRubhxh8WHYGmwkJPh26PVEoq6uTtF+JZ+VcOaaM8Xw+ZGIjo5Go9F4/cUL0NDQMOo+QMHBwcycOdMrm/wmOp1Ose/UBQKBYCLTUdVByZslFG8opmHXUFuvUg8mP+YsM3Hz4jAkGlBr1DJGKlASAZMIabVaCgoK2Lx5M0uXLgUG11/ZvHkza9asGdU5XC4XX3/9NUuWLPFjpAKBQCAYLZ21nZS8NZj81H8x9OoJFYQnhWPONmOZY8GYbEQdJJIfge8JmEQIYO3atVx//fXMnj2buXPn8uSTT9Ld3S2NIrvuuutITEzkkUceAeDBBx9k/vz5ZGZm0t7ezm9+8xuqqqq4+eab5dSQCMTH1SeL0h2V7gfKdxR+40+3rRvrW4OvvQ5/PtS/EBUYEgxS8hOREjGq5EfJr41A+X5RUVGyXj+gEqEVK1bQ1NTE/fffj81mY8aMGXz88cdSB+rq6mrU6qFfmra2Nm655RZsNhtms5mCggK2bdtGfn6+XApeKH22UFC+o9L9QPmOwm986GnqoeRvJVg3WqndWovHPdQ9NSwhbPC115w4jKlGNMEnN5y6q6tLGsyiRJTud6Qjt1wEVCIEsGbNmuO+CtuyZYvXz7/97W/57W9/Ow5RjY2GhoYJ0UD5E6U7Kt0PlO8o/PxHb2svh94+hHWjlepPqvG4jkp+4sIwZZmwzLZgSjeh0Y59Lhm73a7oREHpfj3d8s5+HnCJkEAgEAgmLn3tfZS+W4p1o5WqTVW4B9zStlBLKKZME5YCC+Ys8yklPwKBrxCJkEAgEAhOCYfdQdl7ZVg3Wqn8ZyUup0vaFhITIiU/kdmRaHQi+RFMLEQiJCNKm/F1OJTuqHQ/UL6j8Bsbzm4n5e+XY91gpfzDclyOoeRHH6XHnGkmdlYskbmRBOn9e6uJjRl+rUmloHS/gJxZ+ve///2w5SqVCr1eT2ZmJmeffbbs64dMdBwOh+LnLFK6o9L9QPmOwm/09Pf2U/FhBcUbiil/v5yB3qFVw3VmnZT8ROVFERQyfn9nDwwMEBSs3L/rFe/nCsDV53/729/S1NRET08PZrMZGByhFRoaisFgoLGxkfT0dD799FOSk5N9GrCSqKmpmZBDW32J0h2V7gfKdxR+J2agb4DKf1ZSvKGYsvfK6O/ul7bpInSYMk3EzIwhanIU2lCtL0I+aVrbWkkIUe4Qc6X7dXV2jbyTHxlTIvTwww/z/PPP8+KLL5KRkQFAaWkpt912G7feeitnnnkmV111FXfffTdvvfWWTwMWCAQCgX9xOV1UbqrEusFK6d9Lcdqd0jatUYspw0TM9Biip0ajNciT/AgEvmJMidB9993H3/72NykJgsH30I899hhXXHEF5eXl/PrXv+aKK67wWaACgUAg8B+ufhfVn1Rj3WDl0DuHcLQPrbkYHB6MKX0w+YmZHiOSH4GiGFMiVF9fL60WfjQDAwPSirQJCQnSCtWC4Zk0aZLcIfgdpTsq3Q+U73g6+7ldbmq21GDdaKXkbyX0tQytcB4cFowpw0T0tGhipsegM07cflSRkZFyh+BXlO4XHh4u6/XHlAidd9553Hbbbbz44ovMnDkTgL1793L77bfz7W9/G4Cvv/6atLQ030WqQLRa5f9VpXRHpfuB8h1PNz+3y83h/x7GusFKyVsl9DQOTWYXFBpERHoE0VOjscywoDNN3OTnaII0yu1IDMr3k3tg1Zhq96WXXuLaa6+loKCA4OBgYPBp0MKFC3nppZcAMBgMPP74476LVIGUlpYqupMmKN9R6X6gfMfTwS8/L5+6L+qwbrBifdNKd323tD0oJIiItAiipkRhmTWY/KhUKhkjPnkamxoVvR6X0v3a29tlvf6YEqG4uDg2bdpEcXExJSUlAOTk5JCTkyPtc9555/kmQoFAIBCcNB6PB9tOG0XPFvH5J5/TWTPUVUGj0xCRHkHU5CgsBRb0Zn3AJT8Cga84pedtubm55Obm+ioWgUAgEJwCHo+Hxr2NFG8oxrrRir3SLm3TaDUY04xE5Q8mPyFRIajUIvkRCMaUCLlcLl555RU2b95MY2Mjbrfba/snn3zik+CUjsVikTsEv6N0R6X7gfIdA93P4/HQ/HWzlPy0l7ZL29TBasKSw4idEkvcnDhCopWZ/BiNRrlD8CtK9wsNC5X1+mNKhO68805eeeUVLrroIqZMmSIeqY4RJa94fQSlOyrdD5TvGKh+zQebB/v8bLTSWtwqlauD1BhTjUTmRmKZYyEsNkyRyc/RKHlldlC+X4g+RNbrjykReuONN9i4cSNLlizxdTynFYWFhYrupAnKd1S6HyjfMZD8WktasW60Yt1gpflAs1Su0qgwpgwmP3Gz4wiLH0p+6urqFN3RFpTvqHS/lpYWWa8/pkRIq9UqfqFCgUAgmAi0l7dLyU/jvkapXKVREZ4cTmROJHFzB5MftUYtY6QCQWAypkToRz/6Eb/73e94+umnxWsxgUAg8DEdVR2UvFlC8YZiGnY1SOUq9WDyY84yEzcvDkOiQSQ/AsEpMqZE6PPPP+fTTz/lo48+YvLkydJcQkd4++23fRKc0jmyYK2SUbqj0v1A+Y4Txa+ztpOStwaTn/ov6oc2qCA8KRxztpm4uXGEJ4efVPITFhrmh2gnFkp3VLqfTi/vxJ1jSoRMJhOXXXaZr2M57VDyO98jKN1R6X6gfEc5/bpt3VjfGnztdfjzw0MbVGBIMGDONmOZYyEiJQJ10Nie/ESYInwU7cRF6Y5K9zOEydsZfEyJ0B//+Edfx3FacujQIbKysuQOw68o3VHpfqB8x/H262nqoeRvJVg3WqndWovH7ZG2hSWEDb72mhOHMdWIJvjUlx5obGgk1hJ7yueZyCjdUel+be1tsl5f2QuYTHCcTqfcIfgdpTsq3Q+U7zgefr2tvRx6+xDWjVaqP6nG4zoq+YkLw5RlwjLbginD5JPk52gGXMcukK00lO6odD+3yz3yTn5k1InQrFmz2Lx5M2azmZkzZ56wk/SePXt8EpxAIBAEKn3tfZS+W4p1o5WqTVW4B4Ya+1BLKKbMweTHnGlGo5V30UmB4HRm1InQpZdeik432KFp6dKl/orntCI0VN7ZNMcDpTsq3Q+U7+hLP4fdQdl7ZVg3Wqn8ZyUup0vaFhITMpj8FFiIzI5Eoxuf5Oebq88rEaU7Kt0vKFjel1Mqj8fjGXm30xe73U5ERAQdHR2Kn+ZcIBCcPM5uJ+Xvl2PdYKX8w3JcjqHkRx+lx5xpJnZWLJG5kQTpRW8EgeCbtBS2kLsyl4T5vh24MNr79yn9VjqdzmHXGps0adKpnPa0obq6WvF1pXRHpfuB8h3H4tff20/FhxUUbyim/P1yBnqH+nDozDop+YnKiyIoRN7kp7W1lcjISFlj8DdKd1S6X2dnp6zXH9NvaElJCTfddBPbtm3zKvd4PKhUKlwu13GOFByN3B/+eKB0R6X7gfIdR+s30DdA5T8rKd5QTNl7ZfR390vbdBE6TJkmYmbGEJUfhTZs4rzK6OvrkzsEv6N0R6X7yT0gY0yJ0KpVqwgKCuL9998nPj5ezC4tEAgUicvponJTJdYNVkr/XorTPtRga41aTBkmYqbHED01Gq1h4iQ/AoFg9IwpEdq3bx+7d+8mNzfX1/GMyDPPPMNvfvMbbDYb06dP56mnnmLu3LnH3f/NN9/k5z//OZWVlWRlZfGrX/1qwiwWGxSk/P4CSndUuh8o3/Gbfq5+F9WfVGPdYOXQO4dwtDukbcGG4KHkZ1o0unB5Z8QdDRq18kekKd1R6X5qtbzLxIyphcvPz6e5uXnkHX3Mhg0bWLt2LevXr2fevHk8+eSTLF68GKvVSmzssZNNbdu2jZUrV/LII4/w3e9+l9dff52lS5eyZ88epkyZMu7xf5OcnBy5Q/A7SndUuh8o3zEnJwe3y03NlhqsG62U/K2EvpahVxHBYYPJT/S0aGKmx6AzTvzk52gscRa5Q/A7SndUup/cy9yMadTYJ598wn333cfDDz/M1KlTj1lrzF+jq+bNm8ecOXN4+umnAXC73SQnJ3PHHXfw05/+9Jj9V6xYQXd3N++//75UNn/+fGbMmMH69etHdU1/jhqz2WzExcX59JwTDaU7Kt0PlOvodrk5/N/D7P3jXmo/rKWnsUfaFhQaRER6BNFTo7HMsKAzBVbyczT2DjvGCGWPeFW6o9L9qndWU3BTQWCNGlu0aBEACxcu9Cr3Z2dpp9PJ7t27uffee6UytVrNokWL2L59+7DHbN++nbVr13qVLV68mHffffe413E4HDgcQ4/C7Xb7qQV+Auqsdahtyl45uqKsAnWGch2V7gfKcvS4PTTtb6LyX5VUbaqit7lX2hYUEoQxxYghwUBkXiQ6kw6VSoWz04mzM3Bn125qakIVo+x+nEp3VLpfT2fPyDv5kTElQp9++qmv4xiR5uZmXC4XFov3I0KLxUJxcfGwx9hstmH3t9lsx73OI488wrp1644pLyoqwmAYXBguOzubnp4eamtrpe2pqamo1WrKy8ulsvj4eEwmE0VFRVJZVFQUcXFxWK1W2r5qo3R7KVq9lnBjOJ32Tvr7B0eiaDQaIkwR9HT3eI0YiIyMpM/RR0/30BcnIiICt9vtNfolPDwcjUZDe3u7VBYaGoo+RE9rayv833NAnU5HmCGMjvYOKYENCgrCGGGkq7NL6s2vUqkwR5rp6emhr3coHrPZjLPfSXdXt1RmNBpRqVR0dHTg8XioVdUSZghDq9XS1jq0poxeryc0LJS2tjZpvSWtVosh3IDdbmegf8CrLrq7u3H0DSWpkVGR9PX20dNzVF2YInC7jq0LtUZNR3vHsXXR0iqVDVsXwUEYjcevi96eXmpVtcevi//7K87eMZRQhxnC0AZraWs7qi5C9ISGhtLW2saRh7QnrIuubq+E3ed1odcRFjZYFwMDA9SqaoevC7UKs9l8zPfUHGnG6fSui4iICDwej9cfFyddFx12BgZOUBeq//sdOaouPB4POqeO1pJW2kvbcfUM/aGm0WswZBsIzwwndFIo5lgzoWGh2Gw2HO7Bc4aGhRJhjKCxqRHXwOCxOq2OyKhIWltbpWtr1BpiLbHY7Xa6u4e84+Li6O3ppcM+VOfRUdF4PB5aWlukMpPJhFarpbGxUSozGAyEh4djs9mkuggJCcFkMtHc0ky/c7C9CA4OJjo6mvb2dnp7B5M7lUpFXFwcugEdHa6ha8fGxuJ0Or3ahsjISNRqtVeXhwhjBCGhIV7tpVQXjY3S74hOpyMy8ht1odEQGxtLh73Dq60ati6io3G73YPt0gnqItwQjiHcMGxdHO0YrA0mOmr4uujs7KSrq+uEdREVGYVKpaK55cR1ERYWhtFopLGhEZf7G3XR0orD+X91EaQhNmb4uujp6fH6fRiuLsxm8zGfoVQX9TY8eNdFU1OT9DtypC7a2tqk30+1Wo3FYjm2LiyxOBwOr7Zh2LqIiECv19PQ0HDCutDr9JgjzbS0tEjthVQXHR1ebVV4Zji9ql4KCwulsszMTJxOJ9XV1VJZcnIyOp2O0tJSqcxisRAdHe11rMlkIjExkbKyMkZDwEyoWFdXR2JiItu2bWPBggVS+T333MPWrVvZsWPHMcdotVpeffVVVq5cKZU9++yzrFu3zutDPJrhngglJyf75dXY5t9vRl2pJjJXufND1NXVKXr1cqX7QWA6ejweOms6adjZgG23zavPj1qrJmZ6DNmXZ5OzPIfa7lqmTJW/z6C/KCwsZPLkyXKH4VeU7ij8xoZfX4199tlnJ9x+9tlnj+W0JyQ6OhqNRnNMAtPQ0HDc/gtxcXEntT8MZvRHlhLxN0lJSdRV1o3LteRCiX1LjkbpfhA4jh6Ph67DXTTsGkx+ehuHXnupg9VET40m67Iscq/KxZRuQqUefNUQ7gqXK+RxQY7RveON0h2Fn38ZUyJ07rnnHlN29FxC/ugjpNVqKSgoYPPmzdJaZ263m82bN7NmzZphj1mwYAGbN2/mrrvukso2bdrk9URJTnp7ekfeKcDp6+0jNEy5a1Up3Q8mvmNX3WDy07C7gW7b0CspdZCaqMlRZC7NJG9lHuYss5T8HI3dbpd91Io/UbofKN9R+PmXMSVCR7/PB+jv72fv3r38/Oc/55e//KVPAhuOtWvXcv311zN79mzmzp3Lk08+SXd3N6tWrQLguuuuIzExkUceeQSAO++8k3POOYfHH3+ciy66iDfeeINdu3bx/PPP+y3Gk6GltQU1yuiEejzaO9on9E30VFG6H0xMx+6G7sHkZ1cDXXVD/RxUGhVReVFkXJpB3so8InMjUWtO/DtWV1en6JuM0v1A+Y7Cz7+MKRGKiIg4puz8889Hq9Wydu1adu/efcqBDceKFStoamri/vvvx2azMWPGDD7++GOpQ3R1dbXXxExnnHEGr7/+Ovfddx8/+9nPyMrK4t13350QcwgJBIKTo6eph4bdg8lPZ81QB3CVWoU5x0zGxRnkXZ1HdH406iBl/4EhEAh8h0+njLVYLFitVl+e8hjWrFlz3FdhW7ZsOabsyiuv5Morr/RrTAKBwD/0tvRKyY+96qipLNRgzjKTviSd/GvyiZ4ajSZY2bPvCgQC/zCmRGj//v1eP3s8Hurr63n00UeZMWOGL+I6LYiLi6OxsnHkHQOYmOgYuUPwK0r3g/F37Gvrk5KfjoqhobyowJRhIn1JOnlX5xE7IxaN9tSTn/T09FM+x0RG6X6gfEfh51/GlAjNmDEDlUrFN0fez58/n5dfftkngZ0OuN1uuUPwOwEyO8OYUbofjI+jo8NBw57B5Ke9tN1rW0RaBKnfSSX/2nziCuJ8kvwcjdJ/D5XuB8p3FH7+ZUyJUEVFhdfParWamJgY9Hq9T4I6XWhsbFR8Z+nmluaAm4PmZFC6H/jP0dnpHEx+djfQVtImTfIJYEwxknJBCvnX5BM/N54gvf8Wfq2srFT0HC1K9wPlOwo//zKm1mXr1q2sWLHimPl2nE4nb7zxBtddd51PghMIBMqiv7ufhr2DT37arEMzigMYkgyknp9K3jV5JJ6R6NfkRyAQCI4wppZm1apVfOc73zlmxffOzk5WrVolEiGBQCDR39NP074mbLtttB5s9Up+whLCSFmYQt41eSSdlURwaPAJziQQCAS+Z0yJ0JHFVb9JbW3tsEPrBcMTFRVFW2XbyDsGMGaTcue+AOX7wdgcB3oHaPpqMPlpOdiCZ2Ao+QmNC2XSeZPIuzqP5HOT0YZpfRnuSZOYmCjr9f2N0v1A+Y7Cz7+cVCI0c+ZMVCoVKpWKhQsXEhQ0dLjL5aKiooLvfOc7Pg9SqZwOfarGa7kSuVC6H4ze0eVw0bS/iYZdDTQfaMY9MNQBMiQ2hORzksm/Jp9J356E1iBv8nM0RxZTVipK9wPlOwo//3JSidCRpS327dvH4sWLvYLXarWkpqZyxRVX+DRAJXP48GHFd5a2NdgU3ZlY6X5wYkeX00XzgWYadjXQtL8Jd/9Q8qOP0pN0dhL5V+eTcn4KOuPETBqtVquiO6Iq3Q+U7yj8/MtJJUIPPPAAAKmpqaxYseK0eKIhEAi8cfW7aClskZIfl2NobUGdWUfSWUnkfi+XtO+koTeJNkIgEExsxtRH6Prrr6e9vZ3XXnuNsrIyfvzjHxMZGcmePXuwWCyyv+8TCAS+xT3gpqVoMPlp3NeIq++o5CdCR8KZCeRelUv6RemERIbIGKlAIBCcHGOeWXrRokVERERQWVnJLbfcQmRkJG+//TbV1dX86U9/8nWcisRoNNJF18g7BjByv/v1N0r2c7vctBa30ri9EWuhlYGeAWmbNlxL/IJ4cq/KJeOSDEKjJtairCdDdHS03CH4FaX7gfIdhZ9/GVMidPfdd3PDDTfw61//mvDwcKl8yZIlfO973/NZcErHZDIpPhEyGo1yh+BXlObncXtotbbSsLuBxj2N9Hf3S9uCw4KJnx9PzoocMi/NJCw2TMZIfceRRZuVitL9QPmOws+/jCkR2rVrF88///wx5YmJidhstlMO6nShtrZW7hD8js1mIy4uTu4w/IYS/DxuD+2l7dh22Wjc04iz0yltCwoNwjjZyMwbZpJ5WSbh8eEnOFNgUlxcTG5urtxh+A2l+4HyHYWffxlTIqTT6bDb7ceUl5SUEBOj/EUofYXb7Vb8qDG515DxN4Hq53F76KjowLbLRsPuBpwdRyU/+iAssy1kL8sme1k2VW1VTJkyRcZo/YvL5Rp5pwBG6X6gfEfh51/GlAhdcsklPPjgg2zcuBEAlUpFdXU1P/nJT8TweYFgguLxeLBX2gef/OxupK+tT9qm0WmInRVL9hXZZF+ZjTHZKE2aqmo/dvJUgUAgUApjSoQef/xxli1bRkxMDL29vZxzzjnYbDYWLFjAL3/5S1/HqFhCQ0Ppo2/kHQOYEL2yRxBNdD+Px0NnTScNOxuw7bbR1zL0fVNr1cRMjyH78mxyr8rFmGIcdsZ4pfWD+ibCL/BRuqPw8y8qj8fjGXm34fnvf//LV199RVdXF7NmzWLRokW+jG1CYLfbiYiIoKOjw+cf1qF3D1H7WS2RuZE+Pa/g9Mbj8dB1uIuGXYPJT29jr7RNHawmemo0WZdlkXtVLqZ0Eyq1eOIjEAiUx2jv3yf9RMjtdvPKK6/w9ttvU1lZiUqlIi0tjbi4uOOuQSYYngZbg9wh+J3mpmaiY5Q79HMi+XXVDSY/Dbsb6LZ1S+XqIDVRk6PIXJpJ3so8zFnmk0p+ysvLSU9P90fIEwLhF/go3VH4+ZeTSoQ8Hg+XXHIJH374IdOnT2fq1Kl4PB6Kioq44YYbePvtt3n33Xf9FKrycDgdiu8s7ex3jrxTACO3X3dD92Dys6uBrrqhqRhUGhVReVFkXJJB3vfyiMyNRK0Z23ett7d35J0CGOEX+CjdUfj5l5NKhF555RU+++wzNm/ezHnnnee17ZNPPmHp0qX86U9/4rrrrvNpkAKBYIieph4adg8mP501nVK5Sq3CnGMm4+LB5Cd6cjTqIGUn2gKBQHCqnFQi9Ne//pWf/exnxyRBAN/+9rf56U9/yl/+8heRCI2S4OBgXCh7WGRwULDcIfiV8fLrbemVkh971VFTV6jBnGUmfUk6+dfkEz01Gk2wxqfXHu3q84GK8At8lO4o/PzLSXWWjouL4+OPP2bGjBnDbt+7dy8XXnihoiZVFJ2lBXLR19YnJT8dFR1DG1RgyjCRdmEa+dfkEzsjFo3Wt8mPQCAQBDp+6Szd2tp6wqmwLRYLbW1tJ3PK05rWlla5Q/A77W3tmMwmucPwG772c3Q4aNgzmPy0l7Z7bYtIiyD1O6nkX5tPXEHcuCU/hw8fVvRCysIv8FG6o/DzLyeVCLlcLoKCjn+IRqNhYGDguNsF3nR1dym+s3RPb4+iEyFf+Dk7nYPJz+4G2kra4KhntMYUIykXpJB/TT7xc+MJ0o9p6q9Tor29XdGNsPALfJTuKPz8y0mPGrvhhhuO+z7P4XD4JCiBQOn0d/fTsHfwyU+btQ2Peyj7CU8KJ+WCFPKuziPxjERZkh+BQCA4XTipFvb6668fcR/RUXr0nA5zLqlQtuPJ+PX39NO0rwnbbhutB1u9kp+whDBSFqaQd00eSWclERw6cTqZK/17KvwCH6U7Cj8/X/9UZpY+HRCdpQWnwkDvAE1fDSY/LQdb8AwM/bqFxoUy6bxJ5F2TR/I5yWjDtDJGKhAIBMpitPfvgOmg0traytVXX43RaMRkMnHTTTfR1dV1wmPOPfdcVCqV17/Vq1ePU8QjY++wj7xTgNPVeeLPKNAZzs/lcGHbaeOr575i6/9s5cAfD9C8vxnPgIeQmBCyr8xm6d+XcvOhm/nu698lY0nGhE6Cmpqa5A7Brwi/wEfpjsLPvwRM54Orr76a+vp6Nm3aRH9/P6tWreLWW2/l9ddfP+Fxt9xyCw8++KD0c2hoqL9DHTXtHe2K7yxt77RjCDfIHYbfOOLncrpoPtBMw64GmvY34e53S/voo/QknZ1E/tX5pJyfgs4YWHOCNDY2EhMTI3cYfkP4BT5KdxR+/iUgEqGioiI+/vhjdu7cyezZswF46qmnWLJkCY899hgJCQnHPTY0NJS4uLjxClVwGuHqd2EvttPyYQtN+5twOYYmx9SZdSSdlUTu93JJ+04aepNexkgFAoFAcDwCIhHavn07JpNJSoIAFi1ahFqtZseOHVx22WXHPfYvf/kLr732GnFxcVx88cX8/Oc/P+FTIYfD4TX6zW5X/usrwehxD7hpKWqhYVcDjfsacfUdlfxE6Eg4M4Hcq3JJvyidkMgQGSMVCAQCwWgIiETIZrMRGxvrVRYUFERkZOQJZ7H+3ve+R0pKCgkJCezfv5+f/OQnWK1W3n777eMe88gjj7Bu3bpjyouKijAYBl/xZGdn09PTQ21trbQ9NTUVtVpNeXm5VBYfH4/JZKKoqEgqi4qKIi4uDqvVCkBzSzO0QGRUJC3NLTicg0lYkCaIWEssHR0ddHcPrSSeEJ9Ad3c3HfahmYZjYmJwu9y0tLZIZZHmSIKDg2loHFrh3hhuxBBuoL6uHs//TVYTGhKKyWyiqbGJ/oF+ALTBWqJjomlrbaO3b3AxPLVaTVxcHHa73atvVpwlDofDQVv70ESa0VHRqFQqmpoH3/vW1dVhijChD9F7fV6GMAPGCCMNtgZc7sGEQq/XExkZSXNzM06n07su2jvo7jmqLhIS6Orq8kpWY2NiGXAN0No6NFllpDmSoKAgGpsah+rCaMRgMFBXVyeVDVsXWi2R5kiqdlbRvLcZe7Edd9/Qay9NmAbTdBPxF8Zz5i1nMqAdoK6ujvL6cqiHtLQ0ACoqKrziDg8Pl74DANHR0VgsFoqLi3G5BusiPDycSZMmUVFRQU9PDzA4FX1mZiaHDx+mvb1dOn7y5Mk0NzfT0DD0eWdmZuJwOKipqZHKJk2ahFarpbS0VCqzWCxER0dTWFgolZnNZhISEjh06BAAhYWFhIaGkpaWRnV1NZ2dg2ucBQUFkZOTg81mo6Vl6PuXm5uL3W73qt/09HTcbjeVlZVSWWJiIgaDYcS6MBqNJCcnU15eLi3QOFxdqFQq8vPzaWpqorFx6PPOysqir6/Pqy5SUlKkedGOuMfFxREZGcnBgwel/SIjI4mPj+fQoUPSdzIsLIzU1FSqqqqk34fj1UVeXh7t7e3U19efsC6SkpIIDQ2lpKREKouJiSE2NpaioiLc7sHvXUREBElJSV51odfrycjIoLa2lo6OwbZBrVaTl5dHVFSU12c7XPt1pC7KysqksuHaryN1UVJSQn//4O+IwWAgJSXFqy6Cg4PJzs6mvr7e63dxuLrIyMhgYGCAqqqqE9ZFbGwsMTExw9aFTqeTHENCQkhPTx+2LhobG736o/iqLT8yf96RuqisrJTaba1WS1ZW1jF1kZ+fT2trq1ebOFxdJCcnk5qa6vUZHqmLgwcPcmS8k8lkIjExkdLSUumP+SN1UVNTI7WTGo2G3NxcGhoaaG5uls6Zk5NDV1cXhw8fPmFdJCQkYDQaKS4uPmFdDNd+HamLuro6r8mXs7Kyhm2/nE4n1dXVXnWh0+lGbL+O1MXR3+cTIeuosZ/+9Kf86le/OuE+RUVFvP3227z66qtejSUMfhnWrVvH7bffPqrrffLJJyxcuJDS0lIyMjKG3We4J0LJycl+GTW2//X9tOxqUfSosb7ePvQhgfdayOP20GptpWF3A417Gunv7pe2BYcFEz8/npzlOcQtjMOScfzZ1pWA3W73+Xd/IiH8Ah+lOwq/sZ/X50ts+Jof/ehH3HDDDSfcJz09nbi4OK+/7gAGBgb/6j+Z/j/z5s0DOGEipNPpxm0BuKbmJsV3lm5tayUh5Ph9uCYSHreH9tJ2bLtsNO5pxNnplLYFhQYRNyeOnOU5ZF6WSXh8ODD4JMGCshOhmpoaJk+eLHcYfkP4BT5KdxR+/kXWRCgmJmZUPcUXLFhAe3s7u3fvpqCgABh8uuN2u6XkZjTs27cPGHzMKRDAYPLTUdGBbZeNht0NODuOSn70QVhmW8helk32smwMCQbZJ/4SCAQCgW8JiD5CeXl5fOc73+GWW25h/fr19Pf3s2bNGq666ippxNjhw4dZuHAhf/rTn5g7dy5lZWW8/vrrLFmyhKioKPbv38/dd9/N2WefzbRp02Q2EsiJx+PBXmkffPKzu5G+tj5pm0anIXZWLNlXZJN9ZTbGZKNIfgQCgUDBBEQiBIOjv9asWcPChQtRq9VcccUV/P73v5e29/f3Y7VavTpl/fvf/+bJJ5+ku7ub5ORkrrjiCu677z65FI4hJjaGlsqWkXcMYKIio+QOARhMfjprOmnY2YBtt42+lqHkR61VEzs9lqwrsshZnkNESgQq9eiSn5SUFH+FPGFQuqPwC3yU7ij8/EvAJEKRkZEnnDwxNTWVo/t9Jycns3Xr1vEIbcxo1Bq5Q/A7ao18faA8Hg9dh7to2DWY/PQ29g7FFawmemo0WZdlkXtVLqZ006iTn6M5MupIySjdUfgFPkp3FH5+vr6sVz/Nsdlsiu8s3dTUdMIJL/1BV91g8tOwu4Fu29Bwe3WQmqjJUWRelkneVXmYs8xjSn6OpqysTNGdGEH5jsIv8FG6o/DzLyIREiiC7obuweRnVwNddUPzHKk0KqLyosi4NIO8lXlE5kbK+pRKIBAIBBMLkQgJApaeph4adg8mP501nVK5Sq3CnGMm4/+3d/dBUZ33HsC/u8Cy4sICAgsruLzDYn1BE72Qe68mGr2N4w2992r0GmvsSxrHeGWaNLUzrTbpi0mm0zRtnNRJG8m0f5i2jmmnabTW+NJa0yi4DQpBVEQMsLwvLO/sPvcPhiOrvMvZwzn7/czsjJzznLPP9zycw8+zz+6uT4N9ix0xOTHQB7P4ISKie7EQUlBUVBRcN13jN1Qxc4R5WvfX3dwtFT/t1cO+/kQPRGVEIXVdKnK25CB2Yaxfip9A+B47rWdkPvXTekbmkxcLIQWZTCa4oO1CaPbs2fe9j57WHqn4cVUNO146IDItEqmPpcL+pB1xi+IQZPDvBPToaO1+KvgQrWdkPvXTekbmkxcLIQXV1NRofrJ0bV3tlCZL97p64SwZLH7arrX5rDOnmJH8H8nI2ZqD+KXxfi9+hisrK9P0JEZA+xmZT/20npH55MVCiGaMvo6+weKn2InWq63AsG/Bi7BFwLbGhpwnc5CwLAHBRv7qEhHR/eNfE1JUf2c/nJcG7/y0VrRCeO9UP6ZEE5IfTYb9STuseVaEzApRsKdERKRFLIQUFB4ejk50jt9QxUaaI9Tf1Y9GRyPqi+vRUtbiU/zMts6GbZUN9i12JP5bIkLCZnbxo/Rr2/6g9YzMp35az8h88mIhpKCoqCjNF0Jm8+C7xga6B9D4z8Hip7msGWLgTvETFh+GeQ/Pg/1JO5JWJMEw26BUdyctEL7AV+sZmU/9tJ6R+eTFQkhBdbV1SndBVp5eD6799Rp6KnvQdLkJ3gGvtG5W3CwkrUiCfYsdtlU2GEzqKX6Gq6ysREZGhtLdkJXWMzKf+mk9I/PJi4WQgvoH+jX3rjFPnwdNl5vgvOhE4yeN8PbfKX6Mc4xI/PdE5GzJge1RG0IjQhXs6fTo6+tTuguy03pG5lM/rWdkPnmxEKL75un3oPlKs1T8eHo90rrgiGDYVtiQ/b/ZSF6bjFlRsxTsKRERkS8WQgoyGo3ogzorfe+AF83lg8VPg6MBnp47xU+oORTWh6zI3pSN4AXByFqcpWBP5TUdHxg502k9I/Opn9YzMp+8dEIIMX6zwNXe3g6z2QyXy4WIiIhp3Xfle5W4ffY2orPV8Y4Ar8eLlk9bpOJnoGtAWmcINyAhLwHZm7KR9p9pCJsTpmBPiYgo0E307zfvCCmosaFR6S6MS3gFWipa4Cx2oqGkAf2d/dK6kNkhSPiXBGRtzEJ6QTpmx91b1VdXV8Nms/mzy36l9XyA9jMyn/ppPSPzyYuFkIK6e7pn5GRp4RVou9aG+ov1aChpQF/HnZfvgsOCEf9g/GDx84V0hCeEj7kvt9std3cVpfV8gPYzMp/6aT0j88mLhRABGCx+XFUu1F+sh7PYiT7XsOLHGAzLAxZk/k8mMv87E6a5Juh0OgV7S0REND1YCCkoKCgIAspN0RJCoP1m++Cdn+IG9LT23OlbaBDicuMGi58NmYhIiphS8RMcrO1fMa3nA7SfkfnUT+sZmU9enCw9Dq1NlhZCoKOmA84LTtQX16On+U7xozfoEbcoDhn/lYGsJ7Jgtpmh0/PODxERqQ8nS6tAW2ubX55HCAH3Z244Lw4WP90N3dI6fYgeMQtikPGFDGRvykZkauS0Fj/19fWIj4+ftv3NNFrPB2g/I/Opn9YzMp+8WAgpqL2jXdbJ0u7aweLHWexEZ/2d7zTTB+sxZ/4cpBekw77ZjqiMKNnu/DQ3N2v6BNZ6PkD7GZlP/bSekfnkxUJIYzqdnYPFz0Un3LV3ZuLrgnSYY5+DtMfTYN9sR3R2NPRBM+8da0RERP7EQkgDuhq74CweLH46ajqk5Tq9DlFZUUhbnwb7FjticmKgD2bxQ0RENISTpcch52TpiqMVqP1r7ZQmS3c3d0vFT3t1+50VeiAqIwqp61KRsyUHsQtjFS1+vF4v9HrtFl9azwdoPyPzqZ/WMzLf1HCytAp0ubsm1b6ntUcqflxVrjsrdEBkWiRSH0uFfYsdcYvjEGQImubeTk1bWxuio9XxFSJTofV8gPYzMp/6aT0j88mLhZCCWlpbxp0s3evqhbNksPhpu9bms86cakby2mTkbM1B/NL4GVP8DFdXV6fpE1jr+QDtZ2Q+9dN6RuaTl2oKoR/84Ad4//334XA4YDAY0NbWNu42Qgjs27cPb731Ftra2vDQQw/hzTffREZGhvwdvg99HX2DxU+xE61XWzH8MxcjbBGwrbUhZ0sOEpYlINiomiEkIiKacVTzV7Svrw8bNmxAXl4efvnLX05om1dffRU//elP8c477yAlJQXf+c53sHbtWpSVlcFoNMrc48np7+yH89LgnZ/WilYI753qx5RoQvKjybA/acfc/LksfoiIiKaJ6iZLFxUVobCwcNw7QkIIWK1WPPfcc3j++ecBAC6XCxaLBUVFRdi0adOEnk/OydKOQw5UHq6Eu9aNlrIWn+JntnU2bKtssD9pR+K/JiIkLGRan9tfuru7MWvWLKW7IRut5wO0n5H51E/rGZlvagJ+snRVVRXq6+uxevVqaZnZbMby5ctx/vz5UQuh3t5e9Pb2Sj+3t7eP2O5+nfy/k3C86YAYuFP8hMWHwfaIDdlbspG0IgmG2QZZntufvF6v0l2QldbzAdrPyHzqp/WMzCcvzRZC9fX1AACLxeKz3GKxSOtGsn//frz44ov3LC8vL4fJZAIAZGZmoqurC7dv35bWJycnQ6/X48aNG9KyhIQEREZGory8XFo2Z84cxMfHwz3ghhgQMEQbEJcXhweefgBIA3rRix70oLq2GhkZGairq0NLS4u0fU5ODlpaWnwypKWlYWBgANXV1dKypKQkGI1GVFZWSsvi4uIQGxuLsrIyDN0IjIyMxNy5c3Ht2jWpAJw1axZSU1NRU1MjFYJBQUHIzs6G0+lEU1OTtM+srCy43W589tlnIx4LIQR0Oh2sVisiIiLw6aef3nMsKioqMDAwAAAIDw/HvHnzUFVVha6uwXfVGQwGZGRkoLa2Fq2trdL28+fPR1NTE5xOp7QsPT0dfX19uHXrls+xCA0NxbVr16RlFosFMTExuHLlirRspGMRFhaGlJQU3Lp1Cx0dHfcci8bGRunLaLOystDR0YHa2lppnykpKQAGC/MhVqsV4eHhqKiokJbFxMTAYrHg008/hcfjGfVYhIaGIj09HZ999pnPXdHRjkVvby9qamqkZfPmzYPBYBj3WERFRcFqtaKyshK9vb3Q6XQjHovg4GBkZWWhvr4ezc3N0vbZ2dlob2/3ORapqanwer24efOmtGzu3LkwmUzjHouIiAgkJSXhxo0b6O7uHvVY6HQ65OTkoLGxEQ0NDdI+MzIy0NPT43MsbDYbgoODUVVVJY1hfHw8oqOjUVZWJrWLjo5GQkICKisr0dfXBwCYPXs2kpOTUV1dDbfbPeaxsNvtaGtrQ11d3ZjHIjExEWFhYbh69aq0LDY2FnFxcSgvL5f+WJjNZiQmJvocC6PRiLS0NNy+fRsu1+A7SvV6Pex2u08+YOTr19CxuH79urRspOvX0LG4evUq+vv7AQAmkwk2m83nWISEhCAzM/Oe69dIx2Kk69dIx2Lo+jXSsRiecej6NdKxaGhoQGNj45jHYrLX8uHXr6FjcfPmTXR2Dn6a/9D1636u5bdu3fIZQyWu5UPkuJYDg9eh6b6WD/99HpNQ0De/+U2BwanAoz7Ky8t9tjl06JAwm83j7vvcuXMCgKitrfVZvmHDBrFx48ZRt+vp6REul0t61NTUCADC5XJNKeNo2m+3i3PvnhO97b3Tut+Z5vLly0p3QVZazyeE9jMyn/ppPSPzTY3L5ZrQ329F7wg999xzeOqpp8Zsk5qaOqV9D31vidPpREJCgrTc6XRi8eLFo24XGhqK0NDQKT3nZITPDYd5vhmGcPW//EVERKRWihZCsbGxiI2NlWXfKSkpiI+Px8mTJ6XCp729Hf/4xz+wY8cOWZ5zshITE5Xuguy0nlHr+QDtZ2Q+9dN6RuaTl2o+s/vWrVtwOBy4desWPB4PHA4HHA6H9Jo0MDgv4ejRowAG5woUFhbi+9//Pv7whz+gtLQUX/ziF2G1WlFQUKBQCl9hYWFKd0F2Ws+o9XyA9jMyn/ppPSPzyUs1hdDevXuRm5uLffv2we12Izc3F7m5ubh48aLUpqKiQpocBwAvvPACdu3ahaeffhoPPvgg3G43jh07NmM+Q2j4RECt0npGrecDtJ+R+dRP6xmZT16qeddYUVERioqKxmwj7vpIJJ1Oh5deegkvvfSSjD0jIiIitVJNIaSUoeJKjs8Tcrvdsn1O0Uyh9YxazwdoPyPzqZ/WMzLf1Azt8+6bJHdjITSOoc9LSUpKUrgnRERENFkdHR0wm82jrlfdV2z4m9frRW1tLcLDw30+0Op+tbe3IykpCTU1NdP+1R0zhdYzaj0foP2MzKd+Ws/IfFMnhEBHRwesViv0+tGnRPOO0Dj0er2sb+2LiIjQ5C/3cFrPqPV8gPYzMp/6aT0j803NWHeChqjmXWNERERE042FEBEREQUsFkIKCQ0Nxb59+/zydR5K0XpGrecDtJ+R+dRP6xmZT36cLE1EREQBi3eEiIiIKGCxECIiIqKAxUKIiIiIAhYLISIiIgpYLIRkdODAASQnJ8NoNGL58uX4+OOPx2z/29/+FtnZ2TAajViwYAH+9Kc/+amnUzeZjEVFRdDpdD4Po9Hox95OztmzZ7F+/XpYrVbodDq89957425z+vRpLFmyBKGhoUhPTx/3i4KVNNl8p0+fvmf8dDod6uvr/dPhSdq/fz8efPBBhIeHIy4uDgUFBaioqBh3O7Wch1PJp7Zz8M0338TChQulD9vLy8vDBx98MOY2ahk/YPL51DZ+d3v55Zeh0+lQWFg4Zjt/jyELIZm8++67+PrXv459+/ahpKQEixYtwtq1a9HQ0DBi+7///e/YvHkzvvzlL+PSpUsoKChAQUEBLl++7OeeT9xkMwKDnx5aV1cnPaqrq/3Y48np7OzEokWLcODAgQm1r6qqwrp16/Dwww/D4XCgsLAQX/nKV3D8+HGZezo1k803pKKiwmcM4+LiZOrh/Tlz5gx27tyJjz76CCdOnEB/fz/WrFmDzs7OUbdR03k4lXyAus7BxMREvPzyyyguLsbFixfxyCOP4PHHH8eVK1dGbK+m8QMmnw9Q1/gNd+HCBRw8eBALFy4cs50iYyhIFsuWLRM7d+6UfvZ4PMJqtYr9+/eP2H7jxo1i3bp1PsuWL18uvva1r8naz/sx2YyHDh0SZrPZT72bXgDE0aNHx2zzwgsviPnz5/sse+KJJ8TatWtl7Nn0mEi+U6dOCQCitbXVL32abg0NDQKAOHPmzKht1HgeDplIPjWfg0OioqLEL37xixHXqXn8hoyVT63j19HRITIyMsSJEyfEihUrxO7du0dtq8QY8o6QDPr6+lBcXIzVq1dLy/R6PVavXo3z58+PuM358+d92gPA2rVrR22vtKlkBAC32w2bzYakpKRx/+ejNmobw6lavHgxEhIS8Oijj+LcuXNKd2fCXC4XACA6OnrUNmoew4nkA9R7Dno8Hhw+fBidnZ3Iy8sbsY2ax28i+QB1jt/OnTuxbt26e8ZmJEqMIQshGTQ1NcHj8cBisfgst1gso86nqK+vn1R7pU0lY1ZWFt5++238/ve/x69//Wt4vV7k5+fj9u3b/uiy7EYbw/b2dnR3dyvUq+mTkJCAn//85zhy5AiOHDmCpKQkrFy5EiUlJUp3bVxerxeFhYV46KGH8LnPfW7Udmo7D4dMNJ8az8HS0lKYTCaEhobimWeewdGjR5GTkzNiWzWO32TyqXH8Dh8+jJKSEuzfv39C7ZUYQ377PPlNXl6ez/908vPzYbfbcfDgQXzve99TsGc0EVlZWcjKypJ+zs/Px/Xr1/Haa6/hV7/6lYI9G9/OnTtx+fJl/O1vf1O6K7KYaD41noNZWVlwOBxwuVz43e9+h23btuHMmTOjFgtqM5l8ahu/mpoa7N69GydOnJjRk7pZCMkgJiYGQUFBcDqdPsudTifi4+NH3CY+Pn5S7ZU2lYx3CwkJQW5uLq5duyZHF/1utDGMiIjArFmzFOqVvJYtWzbji4tnn30Wf/zjH3H27FkkJiaO2VZt5yEwuXx3U8M5aDAYkJ6eDgBYunQpLly4gNdffx0HDx68p60ax28y+e4208evuLgYDQ0NWLJkibTM4/Hg7NmzeOONN9Db24ugoCCfbZQYQ740JgODwYClS5fi5MmT0jKv14uTJ0+O+tpvXl6eT3sAOHHixJivFStpKhnv5vF4UFpaioSEBLm66VdqG8Pp4HA4Zuz4CSHw7LPP4ujRo/jwww+RkpIy7jZqGsOp5LubGs9Br9eL3t7eEdepafxGM1a+u8308Vu1ahVKS0vhcDikxwMPPIAtW7bA4XDcUwQBCo2hbNOwA9zhw4dFaGioKCoqEmVlZeLpp58WkZGRor6+XgghxNatW8WePXuk9ufOnRPBwcHiRz/6kSgvLxf79u0TISEhorS0VKkI45psxhdffFEcP35cXL9+XRQXF4tNmzYJo9Eorly5olSEMXV0dIhLly6JS5cuCQDixz/+sbh06ZKorq4WQgixZ88esXXrVqn9jRs3RFhYmPjGN74hysvLxYEDB0RQUJA4duyYUhHGNNl8r732mnjvvfdEZWWlKC0tFbt37xZ6vV785S9/USrCmHbs2CHMZrM4ffq0qKurkx5dXV1SGzWfh1PJp7ZzcM+ePeLMmTOiqqpKfPLJJ2LPnj1Cp9OJP//5z0IIdY+fEJPPp7bxG8nd7xqbCWPIQkhGP/vZz8S8efOEwWAQy5YtEx999JG0bsWKFWLbtm0+7X/zm9+IzMxMYTAYxPz588X777/v5x5P3mQyFhYWSm0tFot47LHHRElJiQK9npiht4vf/RjKtG3bNrFixYp7tlm8eLEwGAwiNTVVHDp0yO/9nqjJ5nvllVdEWlqaMBqNIjo6WqxcuVJ8+OGHynR+AkbKBsBnTNR8Hk4ln9rOwS996UvCZrMJg8EgYmNjxapVq6QiQQh1j58Qk8+ntvEbyd2F0EwYQ50QQsh3v4mIiIho5uIcISIiIgpYLISIiIgoYLEQIiIiooDFQoiIiIgCFgshIiIiClgshIiIiChgsRAiIiKigMVCiIiIiAIWCyEi0oynnnoKBQUFSneDiFSEhRARqYJOpxvz8d3vfhevv/46ioqK/N63oqIiREZG+v15iej+BSvdASKiiairq5P+/e6772Lv3r2oqKiQlplMJphMJiW6RkQqxjtCRKQK8fHx0sNsNkOn0/ksM5lM97w0tnLlSuzatQuFhYWIioqCxWLBW2+9hc7OTmzfvh3h4eFIT0/HBx984PNcly9fxuc//3mYTCZYLBZs3boVTU1NI/br9OnT2L59O1wul8/dKSJSBxZCRKRp77zzDmJiYvDxxx9j165d2LFjBzZs2ID8/HyUlJRgzZo12Lp1K7q6ugAAbW1teOSRR5Cbm4uLFy/i2LFjcDqd2Lhx44j7z8/Px09+8hNERESgrq4OdXV1eP755/0ZkYjuAwshItK0RYsW4dvf/jYyMjLwrW99C0ajETExMfjqV7+KjIwM7N27F83Nzfjkk08AAG+88QZyc3Pxwx/+ENnZ2cjNzcXbb7+NU6dO4erVq/fs32Aw3HOHii/REakH5wgRkaYtXLhQ+ndQUBDmzJmDBQsWSMssFgsAoKGhAQDwz3/+E6dOnRqxmLl+/ToyMzNl7jER+RMLISLStJCQEJ+fdTqdzzKdTgcA8Hq9AAC3243169fjlVdeuWdfCQkJMvaUiJTAQoiIaJglS5bgyJEjSE5ORnDwxC6RBoMBHo9H5p4RkRw4R4iIaJidO3eipaUFmzdvxoULF3D9+nUcP34c27dvH7XYSU5OhtvtxsmTJ9HU1CRNvCaimY+FEBHRMFarFefOnYPH48GaNWuwYMECFBYWIjIyEnr9yJfM/Px8PPPMM3jiiScQGxuLV1991c+9JqKp0gkhhNKdICIiIlIC7wgRERFRwGIhRERERAGLhRAREREFLBZCREREFLBYCBEREVHAYiFEREREAYuFEBEREQUsFkJEREQUsFgIERERUcBiIUREREQBi4UQERERBaz/B7toSHzPpnPYAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from qoolqit import QuantumProgram\n", + "\n", + "program = QuantumProgram(register, drive)\n", + "print(program)\n", + "print(\"Compiled?\", program.is_compiled)\n", + "program.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8e6d8461", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Program assembled — and correctly not compiled yet.\n" + ] + } + ], + "source": [ + "# ✅ Check\n", + "assert not program.is_compiled\n", + "print(\"Program assembled — and correctly not compiled yet.\")" + ] + }, + { + "cell_type": "markdown", + "id": "4ae9cbb9", + "metadata": {}, + "source": [ + "### Next module\n", + "In **Module 3** we bring in the hardware: compiling programs to devices with\n", + "real constraints, and executing them on an emulator — including your first\n", + "genuinely quantum experiment, the **Rydberg blockade**." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}