{ "cells": [ { "cell_type": "markdown", "id": "ea2b4418", "metadata": {}, "source": [ "# Deprecated code suggestions\n", "\n", "```{seealso}\n", "Download the notebook: {nb-download}`deprecated.ipynb`\n", "```\n", "\n", "| **Target** | **Depr** | **Remv** | **Alternatives** |\n", "|---|---|---|---|\n", "| `ScheduleGettable.generate_diagnostics_report()` | 0.17 | - | See {ref}`ScheduleGettable.generate_diagnostics_report()` |\n", "| `plot_kwargs` parameter in `ScheduleBase.plot_pulse_diagram()` | 0.15 | - | See {ref}`plot_kwargs parameter in ScheduleBase.plot_pulse_diagram()` |\n", "| `repetitions` parameter in `ScheduleGettable.process_acquired_data()` | 0.15 | - | See {ref}`repetitions parameter in ScheduleGettable.process_acquired_data()` |\n", "| `t` parameter in `NumericalWeightedIntegrationComplex` | 0.13 | - | See {ref}`t parameter in NumericalWeightedIntegrationComplex` |\n", "| Qblox `convert_hw_config_to_portclock_configs_spec()` | 0.13 | - | See {ref}`Qblox Hardware Configuration` |\n", "| Qblox `instruction_generated_pulses_enabled` hardware config setting | 0.13 | 0.17 | See {ref}`Instruction-generated pulses (Qblox only)` |\n", "| `quantify_scheduler.visualization` | 0.12 | 0.15 | See {ref}`Circuit diagrams and pulse diagrams` |\n", "| `acq_channel` (in {class}`~quantify_scheduler.operations.gate_library.Measure` and {class}`~quantify_scheduler.operations.nv_native_library.CRCount`) | 0.10 | 0.13 | See {ref}`acq_channel` |\n", "| `quantify_scheduler.compilation.qcompile()`
`quantify_scheduler.compilation.device_compile()`
`quantify_scheduler.compilation.hardware_compile()` | 0.10 | 0.13 | See {ref}`qcompile() => SerialCompiler` |\n", "| The `data` parameter in `Operation` subclasses | 0.9 | 0.15 | - |\n", "| Old Qblox hardware configuration | 0.8 | 0.13 | See {ref}`Qblox Hardware Configuration` |\n", "| `TransmonElement` | 0.7 | 0.13 | See {ref}`TransmonElement => BasicTransmonElement` |\n", "| `add_pulse_information_transmon()` | 0.6 | 0.13 | See {ref}`add_pulse_information_transmon() => compile_circuit_to_device()` |\n", "| `plot_circuit_diagram_mpl()` | 0.6 | 0.9 | {meth}`~quantify_scheduler.schedules.schedule.ScheduleBase.plot_circuit_diagram` |\n", "| `plot_pulse_diagram_mpl()` | 0.6 | 0.9 | {meth}`~quantify_scheduler.schedules.schedule.ScheduleBase.plot_pulse_diagram` |\n", "\n", "As of `quantify-scheduler==0.10.0`, deprecation warnings are shown by default (as `FutureWarning`).\n", "\n", "## Compilation Setup" ] }, { "cell_type": "code", "execution_count": 1, "id": "60f6a4d8", "metadata": { "mystnb": { "code_prompt_show": "Set up an InstrumentCoordinator, MeasurementControl and a Cluster" }, "tags": [ "hide-cell" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n", "qcm => None\n", "qrm => None\n", "qcm_rf => None\n", "qrm_rf => \n" ] } ], "source": [ "from quantify_core.data import handling as dh\n", "from quantify_core.measurement.control import MeasurementControl\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "\n", "from qblox_instruments import Cluster, ClusterType\n", "from qcodes import Instrument\n", "\n", "dh.set_datadir(dh.default_datadir())\n", "\n", "Instrument.close_all()\n", "meas_ctrl = MeasurementControl(\"meas_ctrl\")\n", "ic = InstrumentCoordinator(\"ic\")\n", "\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "ic.add_component(ic_cluster)\n", "\n", "# Always picks the first module of a certain type, and ignores the others of same type!\n", "qcm_rf, qrm_rf, qcm, qrm = [None] * 4\n", "for module in cluster.modules:\n", " try:\n", " if module.is_rf_type:\n", " if module.is_qcm_type:\n", " if qcm_rf is None:\n", " qcm_rf = module\n", " else:\n", " if qrm_rf is None:\n", " qrm_rf = module\n", " else:\n", " if module.is_qcm_type:\n", " if qcm is None:\n", " qcm = module\n", " else:\n", " if qrm is None:\n", " qrm = module\n", " except KeyError:\n", " continue\n", "\n", "print(f\"qcm => {qcm}\\nqrm => {qrm}\\nqcm_rf => {qcm_rf}\\nqrm_rf => {qrm_rf}\")" ] }, { "cell_type": "code", "execution_count": 2, "id": "2acb779b", "metadata": { "mystnb": { "code_prompt_show": "Set up a QuantumDevice with one BasicTransmonElement" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "\n", "quantum_device = QuantumDevice(\"quantum_device\")\n", "quantum_device.add_element(q0)\n", "quantum_device.instr_measurement_control(meas_ctrl.name)\n", "quantum_device.instr_instrument_coordinator(ic.name)\n", "\n", "q0.clock_freqs.f01(7.3e9)\n", "q0.clock_freqs.f12(7.0e9)\n", "q0.clock_freqs.readout(8.2e9)\n", "q0.measure.acq_delay(100e-9)\n", "q0.measure.acq_channel(0)\n", "q0.measure.pulse_amp(0.2)\n", "\n", "device_cfg = quantum_device.generate_device_config()" ] }, { "cell_type": "code", "execution_count": 3, "id": "f4b1f3e4", "metadata": { "mystnb": { "code_prompt_show": "Provide the hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "hardware_cfg = {\n", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " \"cluster\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " f\"cluster_module{qrm_rf.slot_idx}\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"lo_freq\": 2e9,\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q0:res\",\n", " \"clock\": \"q0.ro\",\n", " },\n", " ],\n", " },\n", " },\n", " },\n", "}" ] }, { "cell_type": "code", "execution_count": 4, "id": "a3208002", "metadata": { "mystnb": { "code_prompt_show": "Define a simple schedule function" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset\n", "from quantify_scheduler.operations.pulse_library import DRAGPulse\n", "from quantify_scheduler.resources import ClockResource\n", "\n", "\n", "def simple_trace_sched(\n", " repetitions: int,\n", " pulse_amp: float = 0.2, \n", ") -> Schedule:\n", " sched = Schedule(\"Simple trace schedule\", repetitions)\n", "\n", " port = \"q0:res\"\n", " clock = \"q0.ro\"\n", "\n", " sched.add(Reset(\"q0\"))\n", " sched.add(Measure(\"q0\", acq_index=0, acq_protocol=\"Trace\"))\n", " sched.add(\n", " DRAGPulse(\n", " G_amp=pulse_amp,\n", " D_amp=0,\n", " phase=0,\n", " duration=160e-9,\n", " port=port,\n", " clock=clock,\n", " )\n", " )\n", "\n", " return sched\n", "\n", "\n", "sched = simple_trace_sched(repetitions=1)" ] }, { "cell_type": "markdown", "id": "603a2bcf", "metadata": {}, "source": [ "## qcompile() => SerialCompiler\n", "\n", "The `qcompile()`, `device_compile()` and `hardware_compile()` compilation functions have been replaced by the {class}`~quantify_scheduler.backends.graph_compilation.SerialCompiler`. For step-by-step guides on how to perform compilation to the device level and hardware, please see {ref}`Compiling to Hardware` and {ref}`Operations and Qubits`. A brief example is shown below.\n", "\n", "First, run {ref}`Compilation Setup`." ] }, { "cell_type": "code", "execution_count": 5, "id": "fa77e8b9", "metadata": {}, "outputs": [], "source": [ "# Old way:\n", "# from quantify_scheduler.compilation import qcompile\n", "\n", "# compiled_schedule = qcompile(sched, device_cfg, hardware_cfg)" ] }, { "cell_type": "code", "execution_count": 6, "id": "ed2d1141", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.backends.graph_compilation import SerialCompiler\n", "\n", "quantum_device.hardware_config(hardware_cfg)\n", "\n", "compiler = SerialCompiler(name=\"compiler\")\n", "compiled_schedule = compiler.compile(\n", " schedule=sched, config=quantum_device.generate_compilation_config()\n", ")" ] }, { "cell_type": "code", "execution_count": 7, "id": "4d73164a", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/schedules/schedule.py:514: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n", " timing_table = pd.concat(timing_table_list, ignore_index=True)\n" ] }, { "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", "
 waveform_op_idportclockis_acquisitionabs_timedurationoperationwf_idxoperation_hash
0Reset('q0')_acq_0Nonecl0.basebandFalse0.0 ns200,000.0 nsReset('q0')0-4852216573030640586
1Measure('q0', acq_index=0, acq_protocol=\"Trace\", bin_mode=None)_acq_0Noneq0.roFalse200,000.0 ns0.0 nsMeasure('q0', acq_index=0, acq_protocol=\"Trace\", bin_mode=None)0-8073448366116058761
2Measure('q0', acq_index=0, acq_protocol=\"Trace\", bin_mode=None)_acq_1q0:resq0.roFalse200,000.0 ns300.0 nsMeasure('q0', acq_index=0, acq_protocol=\"Trace\", bin_mode=None)1-8073448366116058761
3Measure('q0', acq_index=0, acq_protocol=\"Trace\", bin_mode=None)_acq_0q0:resq0.roTrue200,100.0 ns1,000.0 nsMeasure('q0', acq_index=0, acq_protocol=\"Trace\", bin_mode=None)0-8073448366116058761
4DRAGPulse(G_amp=0.2,D_amp=0,phase=0,duration=1.6e-07,port='q0:res',clock='q0.ro',reference_magnitude=None,t0=0)_acq_0q0:resq0.roFalse201,100.0 ns160.0 nsDRAGPulse(G_amp=0.2,D_amp=0,phase=0,duration=1.6e-07,port='q0:res',clock='q0.ro',reference_magnitude=None,t0=0)06651311029759675396
\n" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "compiled_schedule.timing_table" ] }, { "cell_type": "markdown", "id": "f0eecf60", "metadata": {}, "source": [ "## ScheduleGettable.generate_diagnostics_report()\n", "\n", "In version 0.17, the {meth}`.ScheduleGettable.generate_diagnostics_report` method received a major update. This method should no longer be called directly. Instead, the experiment should be run via the {meth}`.ScheduleGettable.initialize_and_get_with_report` method, which executes the experiment and generates a diagnostics report for debugging.\n", "\n", "## plot_kwargs parameter in ScheduleBase.plot_pulse_diagram()\n", "\n", "In version 0.15, the `plot_kwargs` parameter of the {meth}`.ScheduleBase.plot_pulse_diagram` method was replaced by variable keyword arguments (`**kwargs`). This means that the dictionary provided to `plot_kwargs` can be unpacked and passed to the method directly. For example,\n", "\n", "```python\n", "schedule.plot_pulse_diagram(plot_kwargs={\"x_range\": (201e-6, 201.5e-6)})\n", "```\n", "\n", "can now be written as" ] }, { "cell_type": "code", "execution_count": 8, "id": "ed0828d0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
,\n", " )" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABtOElEQVR4nO3dd3hUZdoG8PtMTZuSQnoFQg8QWggiRfgoKogidhFlsSzgAq6yuIquuyuIsrqyrK4NdO2sioiIUkKT0AKRFkICgQBppE56JjPn+2MyIyMJKUxyZib377rOBXPOO2eel4SZZ94qiKIogoiIiMhNyaQOgIiIiKg9MdkhIiIit8Zkh4iIiNwakx0iIiJya0x2iIiIyK0x2SEiIiK3xmSHiIiI3JpC6gCcgdlsRk5ODjQaDQRBkDocIiIiagFRFFFeXo7Q0FDIZE233zDZAZCTk4OIiAipwyAiIqI2uHDhAsLDw5u8zmQHgEajAWD5x9JqtRJHQ0RERC1hMBgQERFh+xxvCpMdwNZ1pdVqmewQERG5mOaGoHCAMhEREbk1JjtERETk1pjsEBERkVvjmB0iInIpJpMJRqNR6jCoAyiVSsjl8uu+D5MdIiJyCaIoIi8vD6WlpVKHQh1Ir9cjODj4utbBY7JDREQuwZroBAYGwsvLi4vAujlRFFFVVYWCggIAQEhISJvvxWSHiIicnslksiU6/v7+UodDHcTT0xMAUFBQgMDAwDZ3aXGAMhEROT3rGB0vLy+JI6GOZv2ZX884LSY7RETkMth11fk44mfOZIeIiIjcmqTJzrJlyzB06FBoNBoEBgZi2rRpSE9PtytTU1ODuXPnwt/fHz4+Ppg+fTry8/PtymRnZ+OWW26Bl5cXAgMD8fTTT6O+vr4jq0JEREROStJkZ+fOnZg7dy727duHLVu2wGg0YsKECaisrLSVWbhwIb777jusW7cOO3fuRE5ODu644w7bdZPJhFtuuQV1dXXYu3cvPvzwQ6xduxZLly6VokpERETkbEQnUlBQIAIQd+7cKYqiKJaWlopKpVJct26drUxaWpoIQExOThZFURQ3bdokymQyMS8vz1bmrbfeErVarVhbW9ui1y0rKxMBiGVlZQ6sDRFJzWQyiwWGGrHWaJI6FLpO1dXV4smTJ8Xq6mqpQ3EqDz30kHjbbbc55F5ms1l8/vnnxeDgYNHDw0McN26cePr0aYfc+3pc62ff0s9vp5p6XlZWBgDw8/MDAKSkpMBoNGL8+PG2Mr169UJkZCSSk5MxfPhwJCcnIy4uDkFBQbYyEydOxBNPPIETJ04gPj7+qtepra1FbW2t7bHBYGivKhFRB/vlQik+3ncex3MMOFdYiWqjCTIBCPf1QmygD6bFh2Fyv2Ao5ByySK7LZDI5fLD2ihUr8Oabb+LDDz9ETEwMnn/+eUycOBEnT56Eh4dHi+5RV1cHlUrl0LgcwWn+t5vNZixYsAA33HAD+vXrB8CygJRKpYJer7crGxQUhLy8PFuZKxMd63XrtcYsW7YMOp3OdkRERDi4NkTU0XaevowZb+/Fbat/xrqUi0jLNaDaaAIAmEUgu7gK204VYP5nR3DjiiS8t/ss6urNEkdN10MURVTV1UtyiKLY4jjHjBmDefPmYd68edDpdAgICMDzzz9vd4+SkhLMnDkTvr6+8PLywuTJk5GRkWG7vnbtWuj1emzYsAF9+vSBWq3GI488gg8//BDffvstBEGAIAjYsWNHozFUVlZi5syZ8PHxQUhICFauXIkxY8ZgwYIFtn/LN954A8899xxuu+029O/fHx999BFycnKwfv36Juv24osvYuDAgXjvvfcQExNjS4pKS0vxu9/9Dl26dIFWq8VNN92EX375xfa8X375BWPHjoVGo4FWq8XgwYNx6NChFv+btpbTtOzMnTsXx48fx549e9r9tZYsWYJFixbZHhsMBiY8RC6qxmjCy5vS8FHyeQCAXCZgaLQvhkX7I8rPCyF6D1TU1uNCURWO5pRhe1oBcstq8Lfv0/Btag7+ff8gRPhx7RZXVG00oc/SHyV57ZMvTYSXquUfoR9++CFmz56NAwcO4NChQ3j00UcRGRmJOXPmAABmzZqFjIwMbNiwAVqtFosXL8bNN9+MkydPQqlUAgCqqqrwyiuv4L333oO/vz9CQkJQXV0Ng8GANWvWAPi1Z+S3nn76aezcuRPffvstAgMD8eyzz+Lw4cMYOHAgACArKwt5eXl2PSk6nQ4JCQlITk7GPffcA8CSuEVHR2Pt2rW2cpmZmfjqq6/w9ddf2xb9mzFjBjw9PfHDDz9Ap9PhP//5D8aNG4fTp0/Dz88P999/P+Lj4/HWW29BLpcjNTXVVs/24BTJzrx587Bx40bs2rUL4eHhtvPBwcGoq6tDaWmpXetOfn4+goODbWUOHDhgdz/rbC1rmd9Sq9VQq9UOrgURdbSzlysw99MjSMu1dEWP7dkFd8SHI9LfC7Irmvg1HkqE6DwxrKs/Zg6Pxg/Hc/HpgWwcu1SGyf/cjRV3xuHmuFCpqkGdQEREBF5//XUIgoCePXvi2LFjeP311zFnzhxbkvPzzz9jxIgRAIBPPvkEERERWL9+PWbMmAHAsqjev//9bwwYMMB2X09PT9TW1jb5eQcAFRUVeP/99/Hxxx9j3LhxACzJ15Wft9aekMZ6Sq7sJYmMjLxq24a6ujp89NFH6NKlCwBgz549OHDgAAoKCmyfta+99hrWr1+P//3vf3j00UeRnZ2Np59+Gr169QIAxMbGtuJfs/UkTXZEUcT8+fPxzTffYMeOHYiJibG7PnjwYCiVSmzbtg3Tp08HAKSnpyM7OxuJiYkAgMTERPz973+3LSUNAFu2bIFWq0WfPn06tkJE1GFO55fjnnf2obiyDloPBWaNiMZNvYIgl117HINKIcNtA8MwPMYPyzenI/NyBX7/yRH8fZoR9w+P6qDoyRE8lXKcfGmiZK/dGsOHD7cbY5OYmIiVK1fCZDIhLS0NCoUCCQkJtuv+/v7o2bMn0tLSbOdUKhX69+/f6ljPnDmDuro6u/v7+fmhZ8+erb7XRx99dNW5qKgoW6IDWLqoKioqrtrWo7q6GmfOnAEALFq0CL/73e/w3//+F+PHj8eMGTPQrVu3VsfTUpImO3PnzsWnn36Kb7/9FhqNxpY96nQ6eHp6QqfTYfbs2Vi0aBH8/Pyg1Woxf/58JCYmYvjw4QCACRMmoE+fPnjwwQexYsUK5OXl4bnnnsPcuXPZekPkps5crsB97+5HcWUdIv288NSEHuga4NOqewTpPPHqnf3xn11nsflEHp5bfxwqhQwzhrBL21UIgtCqriRX5+np2W4rSFtbhvLz8+1abvLz821dXU3x9va2e1xRUYGQkJBGxw9Ze2lefPFF3Hffffj+++/xww8/4IUXXsDnn3+O22+//brq0RRJByi/9dZbKCsrw5gxYxASEmI7vvjiC1uZ119/HbfeeiumT5+OUaNGITg4GF9//bXtulwux8aNGyGXy5GYmIgHHngAM2fOxEsvvSRFlYionZ0vqsR97+5DYUUtInw98ezNvVud6Fgp5DL8fkw3TO4XDBHA4q+OYv2RS44NmAjA/v377R7v27cPsbGxkMvl6N27N+rr6+3KFBUVIT09vdkeCpVKBZPJdM0y3bp1g1KptLt/SUkJTp8+bXscExOD4OBgbNu2zXbOYDBg//79tp6Ulho0aBDy8vKgUCjQvXt3uyMgIMBWrkePHli4cCF++ukn3HHHHbZxR+1B8m6s5nh4eGD16tVYvXp1k2WioqKwadMmR4ZGRE6osrYesz88hHxDLcL0Hnj25t4I03te1z0FQcDjo7vBaDJja1oBnv7fL4jy90J8pK+DoiayrPS/aNEiPPbYYzh8+DBWrVqFlStXArCMV7ntttswZ84c/Oc//4FGo8Gf/vQnhIWF4bbbbrvmfaOjo/Hjjz8iPT0d/v7+0Ol0Vw309fHxwezZs/H000/D398fgYGB+POf/wyZ7Nf2DkEQsGDBAvztb39DbGysbep5aGgopk2bZis3c+ZMhIWFYdmyZU3GNH78eCQmJmLatGlYsWIFevTogZycHHz//fe4/fbb0bdvXzz99NO48847ERMTg4sXL+LgwYO24SrtofO0/xGRSxNFEX/+5hgyCyrg66XE4om9EO7rmFlUMkHA/JtiYaiux4FzxXji4xRsXjAKei/nWy+EXNPMmTNRXV2NYcOGQS6X4w9/+AMeffRR2/U1a9bgD3/4A2699VbU1dVh1KhR2LRpU7MzlObMmYMdO3ZgyJAhqKioQFJSEsaMGXNVuVdffRUVFRWYMmUKNBoNnnrqKdvadlbPPPMMKisr8eijj6K0tBQjR47E5s2b7dbYyc7OtkuSGiMIAjZt2oQ///nPePjhh3H58mUEBwdj1KhRCAoKglwuR1FREWbOnIn8/HwEBATgjjvuwF/+8pcW/Eu2jSC2ZrEAN2UwGKDT6VBWVgatVit1OETUiE/2n8efvzkOmQA8PaEnRsZ2af5JrVRZW48/fH4E+eW1uDE2AB8+PAyyZgY8U8eoqalBVlaW3VourmLMmDEYOHAg3njjDalDseOscf3WtX72Lf38dppFBYmImnL8Uhn+suEkAGBafBgSuwU084y28VYr8OzNvaGQCdidUYh/JWW2y+sQUcdiskNETs1oMuOZ/x1FncmMAeE63Ds0otnp5dejaxcfPDa6KwDgzW0ZyMgrb7fXIqKOwTE7ROTUPtiThZO5Bvio5Xh0VDd4KNv/bWtin2DszSzCkQulePqro/j6iRHszqI2a2oLB6k5a1ztgS07ROS0souq8PpWy/TYOwaFI7KDtnUQBAHzxnaHSiFD6oVSfLL/fIe8LjWPw0w7H0f8zJnsEJFTEkURf15/DDVGM3oGazClf0jzT3KgQK0HHkyIBAC8sjkdBYaaDn19snfl/lDUuVh/5tezdxa7sYjIKf1wPA+7MwqhlAt4eER0h3Rf/daUAWFISr+Ms4WVePG7E/j3/YM7PAaykMvl0Ov1KCgoAAB4eXm122rC5BxEUURVVRUKCgqg1+ttm4y2BZMdInI6RpMZKzafAgBM6BOE3iHSLAkhlwmYO7Y7nlr3C344lodjF0sRF66XJBb6dUsDa8JDnYNer7/mRqctwWSHiJzOZweyca6oCloPBabHR9jtYN7RegRpMLJ7APZkFuJv36fhi8dat3Q+OY4gCAgJCUFgYCCMRqPU4VAHUCqV19WiY8Vkh4icSnmNEf/cmgEAuKV/CLpopd/Qd2ZiFJLPFmF/VjGSThVgbK9AqUPq1ORyuUM+AKnz4ABlInIq7+46i6LKOgRr1bi1gwclNyVE54nJ/SzN6C9vSoPZzBlBRK6EyQ4ROY3Cilq8uzsLAHDbwDBoPZxnb6p7hkbCQylDRkEFvubO6EQuhckOETmN9/dkodpoQrS/F8b3dq6uIp2nEnfEhwEAVidlsnWHyIUw2SEip1BWbcR/ky2L990SFyLJVPPmTOkfBg+lDFmFlfjheJ7U4RBRCzHZISKn8NHec6iorUeY3hOjejh+R3NH8PFQ4JY4yziifyVlcDVfIhfBZIeIJFdZW48PfraM1ZncLxheKudr1bGaNjAMKrkMabnlSErnei9EroDJDhFJ7rMD2SipMiJQo8b43kFSh3NNei8VJva1xLhqW6bE0RBRSzDZISJJGU1mvLv7LABgYt9geKudt1XH6o5B4ZDLBBy5UIqDWcVSh0NEzWCyQ0SS2nQsF/mGWug8lZjU17lbdawCfNQY3TCu6J2GRI2InBeTHSKS1Nq95wAAo2IDoPV0nnV1mjN1QCgAYPupAlwqqZY4GiK6FiY7RCSZ1AulOJJdCoVMwKR+zrFackt16+KDPiFamMwi3t/D1h0iZ8Zkh4gks6ZhBtbQaF+E+3pKHE3rWVt3/pdyETVGk8TREFFTmOwQkSTyDTX4/mguAMvAZCl3Nm+r4V39EeCjgqGmHl8euiB1OETUBCY7RCSJT/adR71ZRPdAH/QP10sdTpvIZQJu7W9p3flw7zkuMkjkpJjsEFGHM5rM+OygpSVkXK9AKOWu+1Y0oU8QVHIZzlyuxL6zRVKHQ0SNcN13GCJyWdtPFeByeS20HgqMig2QOpzrovFQ4obu/gCAj/dnSxwNETWGyQ4RdbjPD1iSguFd/V1qunlTJvYNBgBsPZkPQ3WdxNEQ0W8x2SGiDnWptBo7Tl8GAIzv5RqLCDanT4gW4b6eqK0344uDF6UOh4h+g8kOEXWoLw9egCgCPYM1iA3ykTochxAEwda6w1lZRM6HyQ4RdRiTWcS6hmRgVGwAFC48MPm3xvYMhEImIKOgAinnuV8WkTOR9J1m165dmDJlCkJDQyEIAtavX293XRCERo9XX33VViY6Ovqq68uXL+/gmhBRS+w6fRk5ZTXwVssxKraL1OE4lM5TicRuDQOV93GgMpEzkTTZqaysxIABA7B69epGr+fm5todH3zwAQRBwPTp0+3KvfTSS3bl5s+f3xHhE1ErWbt4EmL8ofdy/YHJv2XtyvrxRB6q6+oljoaIrBRSvvjkyZMxefLkJq8HBwfbPf72228xduxYdO3a1e68RqO5qiwROZfSqjpsSysAAIzp4V6tOlZxYToE+KhQWFGH747m4q4hEVKHRERwoTE7+fn5+P777zF79uyrri1fvhz+/v6Ij4/Hq6++ivr6a3+jqq2thcFgsDuIqH1tPJqLOpMZ4b6e6BemkzqcdiETBNzUMMPs68OclUXkLFwm2fnwww+h0Whwxx132J1/8skn8fnnnyMpKQmPPfYYXn75ZTzzzDPXvNeyZcug0+lsR0QEv30RtTfrh//wrn4uvWJyc8b2tLRaHcgqRn5ZjcTREBHgQsnOBx98gPvvvx8eHh525xctWoQxY8agf//+ePzxx7Fy5UqsWrUKtbW1Td5ryZIlKCsrsx0XLnCqKFF7OldYicPZpRAEYHSPQKnDaVfhvl7oEegDswh8mcL3FiJn4BLJzu7du5Geno7f/e53zZZNSEhAfX09zp0712QZtVoNrVZrdxBR+/n6yCUAlsX3Iny9JI6m/d3U29KV9W1qjsSREBHgIsnO+++/j8GDB2PAgAHNlk1NTYVMJkNgoHt/eyRyFWazaOvCSuzqD7lMkDii9ndj9wDIZQIyCypw9GKp1OEQdXqSzsaqqKhAZmam7XFWVhZSU1Ph5+eHyMhIAIDBYMC6deuwcuXKq56fnJyM/fv3Y+zYsdBoNEhOTsbChQvxwAMPwNfXt8PqQURNO3S+BBdLquGhlOFGF9/0s6W0nkoMjfbFvrPF+PLQBfQP10sdElGnJmnLzqFDhxAfH4/4+HgAlvE38fHxWLp0qa3M559/DlEUce+99171fLVajc8//xyjR49G37598fe//x0LFy7EO++802F1IKJr2/CLpQtrUKQvfN1wbZ2m3NTT0rr84/F8mM2ixNEQdW6CKIqd/n+hwWCATqdDWVkZx+8QOVC9yYxhL29DcWUdFv1fLMb2dI+NP1uirt6MB97fj2qjCZ/MTsANnaRVi6gjtfTz2yXG7BCRa/r5TBGKK+ug8VBgaJS/1OF0KJVCZts+4usjXHOHSEpMdoio3Xz3i2U20qBIX/h4SDpEUBLW/b+2phWg3mSWOBqizovJDhG1i9p6E348ngcAGNGtc7XqWA0I10GjVqCs2ogd6ZelDoeo02KyQ0TtYmf6ZZTX1sPXS4mBEXqpw5GEQi7DDd0tY3W+Tb0kcTREnReTHSJqF98dzQUADI7yhZeq83VhWY1q2PR0e3oBao0miaMh6pyY7BCRw1XV1WPryXwAnbcLy6pPiBa+XkpU1pqwJS1f6nCIOiUmO0TkcEmnLqPaaEKAjwpxbrrDeUvJZQJubBiobB2wTUQdi8kOETncpuOWLqxBkb7wUHbeLiwr67id3RmF7MoikgCTHSJyqBqjCUmnCgAAw2P8JI7GOfQK1sDXS4mqOhO2pxdIHQ5Rp8Nkh4gcaufpy6iqM8HPW4W48M7dhWUlEwSM6GZp3fm+YeA2EXUcJjtE5FCbG9bWiY/QswvrCtaB2jvTL8PIBQaJOhSTHSJymNp6k20WFruw7PUN1UHroUB5bT12coFBog7FZIeIHGZvZhHKa+uh91SifyddSLApcpmAxK6W1p3vj7Eri6gjMdkhIofZ1PAhPjBS36kXEmzKiIZZWdtPFcBkFiWOhqjzYLJDRA5RbzJjS0MXVkI0u7Aa0z9MB2+1HGXVRvycya4soo7CZIeIHOLguRKUVhuhUSsQH+ErdThOSSGXYVhDIvhDw0BuImp/THaIyCGsrTr9wrTw9mAXVlOGN4zb2ZF+GaLIriyijsBkh4iumyiK2JJmaakYFMlWnWuJj/CFUi4gt6wGJ3IMUodD1Ckw2SGi65ZRUIELxdVQygUM5Xida/JUydE/XA/g1wHdRNS+mOwQ0XWzdmH1CtbAz1slcTTOL6FhDSLrthpE1L6Y7BDRdbMmOwMjfCEIgsTROD/rIOVTeeXIKa2WOBoi98dkh4iuS4GhBqkXSgEAw7uyC6sl/H3UiA30gQh2ZRF1BCY7RHRdtjV0xcQEeCFM7yVxNK7D2pW1NS1f4kiI3B+THSK6LtYurP7heshl7MJqqYQYyxT0lPMlKK8xShwNkXtjskNEbVZVV489mYUAgOENH97UMlH+XgjUqGE0ibaEkYjaB5MdImqz3RmFqKs3o4uPGj2CfKQOx6UIgmBbYJBdWUTti8kOEbWZtUUiLlwHlUIucTSuZ1jDuJ09GYWoN5kljobIfTHZIaI2MZlFbG8YnDw0iqsmt0XfEC28VXIYauqx92yR1OEQuS0mO0TUJoezS1BcWQdvlRwDI/RSh+OSFHIZhjSsufPTCW4MStRemOwQUZtsbejC6huqhY+HUuJoXJd1CvqOU5cljoTIfTHZIaI2sY7X4caf12dQpC/kMgEXS6txMqdM6nCI3JKkyc6uXbswZcoUhIaGQhAErF+/3u76rFmzIAiC3TFp0iS7MsXFxbj//vuh1Wqh1+sxe/ZsVFRUdGAtiDqfM5crcLawEnKZgKExXDX5enirFYgL0wEANh9nVxZRe5A02amsrMSAAQOwevXqJstMmjQJubm5tuOzzz6zu37//ffjxIkT2LJlCzZu3Ihdu3bh0Ucfbe/QiTo1axdWzyANAnzUEkfj+qxdWdvTuTEoUXtQSPnikydPxuTJk69ZRq1WIzg4uNFraWlp2Lx5Mw4ePIghQ4YAAFatWoWbb74Zr732GkJDQx0eMxH9ukXEgAgdZNz487oNi/HDf3adxYkcAy6X16CLxkPqkIjcitOP2dmxYwcCAwPRs2dPPPHEEygq+nV6ZnJyMvR6vS3RAYDx48dDJpNh//79Td6ztrYWBoPB7iCilimrNiLlfAkAYFg0V012hECNB6L8vCCKXGCQqD04dbIzadIkfPTRR9i2bRteeeUV7Ny5E5MnT4bJZAIA5OXlITAw0O45CoUCfn5+yMtruu972bJl0Ol0tiMiIqJd60HkTvZkFMJkFhGi80CUPzf+dJQh0ZaB3kmclUXkcE6d7Nxzzz2YOnUq4uLiMG3aNGzcuBEHDx7Ejh07ruu+S5YsQVlZme24cOGCYwIm6gSSGsaV9A3VQil36rcQlzI4yjJuZ9/ZIq6mTORgLvVO1bVrVwQEBCAzMxMAEBwcjIIC+wF99fX1KC4ubnKcD2AZB6TVau0OImqe2SxiR7ql5YFTzh2rd7AGnkrLasoHzxVLHQ6RW3GpZOfixYsoKipCSEgIACAxMRGlpaVISUmxldm+fTvMZjMSEhKkCpPIbZ3IMaCwohYeChkGhuulDsetKOQyxEfqAQBb0zgri8iRJE12KioqkJqaitTUVABAVlYWUlNTkZ2djYqKCjz99NPYt28fzp07h23btuG2225D9+7dMXHiRABA7969MWnSJMyZMwcHDhzAzz//jHnz5uGee+7hTCyidmDtwuoVooWPh6STOd3S0IaurF2nOW6HyJEkTXYOHTqE+Ph4xMfHAwAWLVqE+Ph4LF26FHK5HEePHsXUqVPRo0cPzJ49G4MHD8bu3buhVv+6rscnn3yCXr16Ydy4cbj55psxcuRIvPPOO1JVicitWZOd/uE6CJxy7nCDGjZUzSioQG5ZtcTRELkPSb+ajRkzBqIoNnn9xx9/bPYefn5++PTTTx0ZFhE1oriyDqkXSgEAw6K5anJ78PNWoWsXb5y9XImfTuTjoRHRUodE5BZcaswOEUln1+nLEEUg3NcT4b6cct5erF1ZO7iaMpHDMNkhohaxdmH1C9VCLmMXVnsZ0tCVtT+rGMZ6k8TRELkHJjtE1CyTWcTOhinn1vVgqH3EBmngo1agqs6EvWc5BZ3IEZjsEFGzUi+UorTaCC+V3LZDN7UPuUzA4IbWHW4dQeQYTHaIqFnW8SN9QrTwVnPKeXuzdmXt4RR0IodgskNEzbpyyjm1v/hIXwgAsoqqkF1cJXU4RC6PyQ4RXVOBoQbHLxkAAEM55bxD6DyV6BGkAQD8dKLpTY2JqGWY7BDRNe1o6EqJ9vdCiM5T4mg6D+su6DvZlUV03ZjsENE17bhil3NOOe84QxpmvR08V4xaI6egE10PJjtE1CSjyYzdpwsBcMp5R+vaxRs6TyVqjGbsySyUOhwil8Zkh4ialHK+BOW19dB4KNA3VCt1OJ2KTBBss7I4BZ3o+jDZIaImWceL9A7RwEvFKecdzbrezt7MIokjIXJtTHaIqEm7GpKduDC9tIF0UgMj9BAE4HxxFbKLKqUOh8hlMdkhokZdLq/FiRzLlHNrdwp1LI2HErGBPgCArWncGJSorZjsEFGj9mRaWnUi/TjlXEqDIy2J5q4MTkEnaismO0TUKOvGn31COOVcSoMakp1D57gLOlFbMdkhoquYzSJ2Z1imOw+M4BYRUooN0sBbJUdFrQkHzpVIHQ6RS2KyQ0RXOZlrQFFlHTwUMvTn4GRJyWUCBja07iSd4rgdorZgskNEV7FOOe8RrIGPB6ecS21QpB4AuLggURsx2SGiq1innPcL1UEQOF5HatZxO+n55Sgsr5E4GiLXw2SHiOyU1xiRct4yNoRTzp1DgI8aEb6eEEVgG7uyiFqNyQ4R2Uk+U4R6s4hAjRrRAd5Sh0MNrKsp7zrNriyi1mKyQ0R2rOu59A7RQinnW4SziG/oyko+WwRRFCWOhsi18J2MiOxYWw4GRuilDYTs9AvVQSWXobiyDkcvlkkdDpFLYbJDRDbnCiuRXVwFuUywzQAi56BSyNAvzLLz/PZT3AWdqDVaNKf0zTffbPWNH374YWg0mlY/j4ikY51y3r2LD/ReKomjod8aFOmLw9ml2J1RiIX/11PqcIhcRouSnQULFiA8PBxyubxFN71w4QJuvfVWJjtELsY65bxPqBYyTjl3OoOifIE9WTh2qQwVNfVcA4mohVr8P+XQoUMIDAxsUVkmOUSup67ejOSzRQCAwezCckrhek8E+KhQWFGHnacLcEv/UKlDInIJLRqz88ILL8DHx6fFN3322Wfh5+fX5qCIqOMdOl+MqjoTtB4K9AzWSh0ONUIQBNsu6DvSuQs6UUu1ONnx8vJq8U2XLFkCvV7f1piISALWWVh9QrXwULasy5o63qCG9Xb2nimSOBIi19Hi2VhDhgzB22+/DYPB0J7xEJFErIOT40K5y7kzGxCuh0wALpVW48zlcqnDIXIJLU52BgwYgGeeeQYhISF48MEHsWPHjut+8V27dmHKlCkIDQ2FIAhYv3697ZrRaMTixYsRFxcHb29vhIaGYubMmcjJybG7R3R0NARBsDuWL19+3bERdSYF5TVIyzVAADAkil3QzsxbrUDPYMu4yK0nuXUEUUu0ONl5//33kZeXh9WrV+PChQsYN24cunfvjpdffhmXLl1q04tXVlZiwIABWL169VXXqqqqcPjwYTz//PM4fPgwvv76a6Snp2Pq1KlXlX3ppZeQm5trO+bPn9+meIg6q90NXViR/l4I0nlIHA01xzpuZ08Gt44gaolWzVv08vLCrFmzMGvWLJw5cwZr1qzBf/7zH7zwwguYMGECZs+ejTvuuKPF95s8eTImT57c6DWdToctW7bYnfvXv/6FYcOGITs7G5GRkbbzGo0GwcHBrakKEV3BukVEnxAN5DJOOXd28ZG++Hh/Ng5ll6Cu3gSVgmOsiK6lzSsod+vWDX/7299w7tw5fPbZZ9i3bx9mzJjhyNiuUlZWBkEQrhr8vHz5cvj7+yM+Ph6vvvoq6uvrr3mf2tpaGAwGu4OoszKbRexuaCGIj2AXlivo1sUHGg8FqutMSD5bLHU4RE7vuraL2LFjh62lx2QyYc6cOY6K6yo1NTVYvHgx7r33Xmi1v06LffLJJ/H5558jKSkJjz32GF5++WU888wz17zXsmXLoNPpbEdERES7xU3k7I7nlKG4sg4eShniwjjl3BXIZQLiIyxdWUmnOG6HqDmtXn7z4sWLWLt2LdauXYuzZ8/ixhtvxL///W/MmDEDnp6e7REjjEYj7rrrLoiiiLfeesvu2qJFi2x/79+/P1QqFR577DEsW7YMarW60fstWbLE7nkGg4EJD3Va1lWTewZr4a3miryuYlCkHrsyLuPnTI7bIWpOi9/ZvvzyS3zwwQfYtm0bAgMD8dBDD+GRRx5B9+7d2zM+W6Jz/vx5bN++3a5VpzEJCQmor6/HuXPn0LNn43vHqNXqJhMhos7Gur5Ov1AtBG4R4TLiGwYpZxZUIM9QjWBt+3zZJHIHLe7GeuCBB+Dp6YlvvvkGFy5cwMsvv9xhiU5GRga2bt0Kf3//Zp+TmpoKmUzW4q0tiDqz8hojDmeXAAAGNyxWR67Bz1uFaH8viAC2p7Eri+haWtyyc/HiRYcnEBUVFcjMzLQ9zsrKQmpqKvz8/BASEoI777wThw8fxsaNG2EymZCXlwcA8PPzg0qlQnJyMvbv34+xY8dCo9EgOTkZCxcuxAMPPABfX75xEzVn75ki1JtFBGnViPb3ljocaqXBUb44V1SFXacLcV9ClNThEDmtFic7VyY6OTk52LNnDwoKCmA2m+3KPfnkky1+8UOHDmHs2LG2x9ZxNA899BBefPFFbNiwAQAwcOBAu+clJSVhzJgxUKvV+Pzzz/Hiiy+itrYWMTExWLhwod14HCJqmnXV5D4hWijl1zVfgSQQH+mLrw5fwr6zRTCbRci4bABRo1o9GnHt2rV47LHHoFKp4O/vb9fHLwhCq5KdMWPGQBTFJq9f6xoADBo0CPv27Wvx6xHRr0RRtA1O7h+ulzYYapM+IVqoFTKUVhuReqHUtm8WEdlr9Ve5559/HkuXLkVZWRnOnTuHrKws23H27Nn2iJGI2kFWYSUullRDIRMwKFIvdTjUBkq5DP3DLXuZbTuVL3E0RM6r1clOVVUV7rnnHshkbPImcmXWVp3ugT7Qe6kkjobaahC3jiBqVqszltmzZ2PdunXtEQsRdSDbeJ1QLWSccu6yrMnO8RwDyquNEkdD5JxaPWZn2bJluPXWW7F582bExcVBqVTaXf/HP/7hsOCIqH3U1puwr2GbAeuHJbmmEJ0HgrRq5BtqkXS6AFMHhEkdEpHTaVOy8+OPP9oW7PvtAGUicn6HzpWg2miC3lOJnkE+UodD10EQBAyK9MUPx/OwM/0ykx2iRrQ62Vm5ciU++OADzJo1qx3CIaKOYB2v0ztEAw8lt4hwddZkZ++ZIqlDIXJKrR6zo1arccMNN7RHLETUQazjdeLC9NIGQg7RP1wHuSAgt6wGGfnlUodD5HRanez84Q9/wKpVq9ojFiLqAPmGGpzKK4cAYHCUXupwyAG8VAr0CtEAALamcQo60W+1uv36wIED2L59OzZu3Ii+ffteNUD566+/dlhwROR41i6sKH8vBHHzSLcxONIXJ3IM2J1RiCfGtO++hUSuptXJjl6vxx133NEesRBRB9jVsB5LnxAt5NxewG0MivLFR/vO43B2CWqNJqiVcqlDInIarU521qxZ0x5xEFEHMJlF7G5o2YnnqsluJSbAGzpPJcqqjdh7pghjezl242YiV8ZlkIk6kaMXS1FabYSXSo5+oXqpwyEHkgkC4iP0AICk9AJpgyFyMi1KdgYNGoSSkpIW33TkyJG4dOlSm4MiovZhnYXVK1gDbzW7OdyNdSPQnzO5dQTRlVrUjZWamopffvkFfn5+LbppamoqamtrryswInI8a7LTL0zHRUDdkLVl58zlSuSVVSNYxwHoREArxuyMGzcOoii2qCzfRImcT0llHX65UAoAGBzFLSLckd5Lha4B3jhbWImtafl4YHi01CEROYUWJTtZWVmtvnF4eHirn0NE7WdPZiHMIhCm90SEr5fU4VA7GRzli7OFldiZXshkh6hBi5KdqKio9o6DiNrZr7uca6CUc26CuxoU6Yt1KRexP6sIZrMIGZcXIOJsLKLOQBRFW7IzIJxdWO6sV7AGnko5DDX1OJzd8oklRO6MyQ5RJ5CWW47L5bVQKWQYEK6TOhxqRwq5DP0bfsbb0jgFnQhgskPUKVhbdXoGaaD1VDZTmlyddQD6nszLEkdC5ByY7BB1AjtPW77h9w3TQsbZkm4vPtKS7JzMKUdZVZ3E0RBJr03JTmlpKd577z0sWbIExcXFAIDDhw9zIUEiJ1RRW49D5yxjNwZHcrxOZxCs9UCIzgMmUURSOlt3iFqd7Bw9ehQ9evTAK6+8gtdeew2lpaUALLudL1myxNHxEdF12ptZiHqziECNGjEB3lKHQx3Emtju4NYRRK1PdhYtWoRZs2YhIyMDHh4etvM333wzdu3a5dDgiOj6/TrlXAu1gltEdBbWrSP2ni1q8YKwRO6q1cnOwYMH8dhjj111PiwsDHl5eQ4Jiogc48op5/3DOAurM4kL00EhE1BgqEV6frnU4RBJqtXJjlqthsFguOr86dOn0aVLF4cERUSOkVVYiYsl1VDIBMRHcLxOZ+KhlKN3iBYAsPVkvsTREEmr1cnO1KlT8dJLL8FoNAKw7IOVnZ2NxYsXY/r06Q4PkIjaztqqExvkA19vlcTRUEcb0tCVtTuDu6BT59bqZGflypWoqKhAYGAgqqurMXr0aHTv3h0ajQZ///vf2yNGImoj23idEC3k3Dag07FOQU+9UIoaY73E0RBJp8W7nlvpdDps2bIFe/bswdGjR1FRUYFBgwZh/Pjx7REfEbVRjdGEfWeLAFj2S6LOJ9rfC75eSpRUGbEnswjjewdJHRKRJFqd7FiNHDkSI0eOdGQsRORAB7KKUWM0w9dLidhAH6nDIQkIgoBBkb7YdqoA29LymexQp9WiZOfNN99s8Q2ffPLJNgdDRI5z5ZRzT1Wbv9eQixscZUl2fs4skjoUIsm06B3w9ddft3t8+fJlVFVVQa/XA7CsqOzl5YXAwMBWJTu7du3Cq6++ipSUFOTm5uKbb77BtGnTbNdFUcQLL7yAd999F6Wlpbjhhhvw1ltvITY21lamuLgY8+fPx3fffQeZTIbp06fjn//8J3x8+E2WOjdrshPHKeedWnyELwQByC6uQtblSsR04cKS1Pm0aIByVlaW7fj73/+OgQMHIi0tDcXFxSguLkZaWhoGDRqEv/71r6168crKSgwYMACrV69u9PqKFSvw5ptv4u2338b+/fvh7e2NiRMnoqamxlbm/vvvx4kTJ7BlyxZs3LgRu3btwqOPPtqqOIjczcWSKmQWVEAmcIuIzs7HQ4FewZYp6FvSuBYadU6C2MqlNbt164b//e9/iI+PtzufkpKCO++8E1lZWW0LRBDsWnZEUURoaCieeuop/PGPfwQAlJWVISgoCGvXrsU999yDtLQ09OnTBwcPHsSQIUMAAJs3b8bNN9+MixcvIjQ0tEWvbTAYoNPpUFZWBq1W26b4iZzJp/uz8ew3x9C9iw9emzGAM7E6uS8PXcB/953HDd388cmc4VKHQ+QwLf38bvXU89zcXNTXXz2F0WQyIT/fcQtXZWVlIS8vz26Wl06nQ0JCApKTkwEAycnJ0Ov1tkQHAMaPHw+ZTIb9+/c3ee/a2loYDAa7g8idWHc57xOqYaJDtvV2Us6XcAo6dUqtTnbGjRuHxx57DIcPH7adS0lJwRNPPOHQ6efWrSeCguxnDwQFBdmu5eXlITAw0O66QqGAn5/fNbeuWLZsGXQ6ne2IiIhwWNxEUjOazLbBqFw1mQAgJsAbvl5K1NSbsTuDA5Wp82l1svPBBx8gODgYQ4YMgVqthlqtxrBhwxAUFIT33nuvPWJ0uCVLlqCsrMx2XLhwQeqQiBzm8PkSVNTWQ6NWoE8ou2XJMkxgSJQfAGBbGreOoM6n1fNRu3Tpgk2bNuH06dM4deoUAKBXr17o0aOHQwMLDg4GAOTn5yMkJMR2Pj8/HwMHDrSVKSgosHtefX09iouLbc9vjDVJI3JH1llYvUM18FRyl3OyGBzliy1p+fg5k1tHUOfT6pYdqx49emDq1KmYOnWqwxMdAIiJiUFwcDC2bdtmO2cwGLB//34kJiYCABITE1FaWoqUlBRbme3bt8NsNiMhIcHhMRG5gl+nnOshCByvQxYDI/SQCwIulFTjTEGF1OEQdahWt+w88sgj17z+wQcftPheFRUVyMzMtD3OyspCamoq/Pz8EBkZiQULFuBvf/sbYmNjERMTg+effx6hoaG2GVu9e/fGpEmTMGfOHLz99tswGo2YN28e7rnnnhbPxCJyJwWGGpzIsQy4H8Ip53QFb7UCvUI0OJFjwJa0fHTjqtrUibQ62SkpKbF7bDQacfz4cZSWluKmm25q1b0OHTqEsWPH2h4vWrQIAPDQQw9h7dq1eOaZZ1BZWYlHH30UpaWlGDlyJDZv3gwPDw/bcz755BPMmzcP48aNsy0q2JoVn4ncSVK6pVs32t8LIXpPiaMhZzMkyg8ncgzYkV6Ax0d3kzocog7T6nV2GmM2m/HEE0+gW7dueOaZZxwRV4fiOjvkLh777yH8eCIft/YPwWOj+GFG9s4VVmL+50egUshwdOn/wYPbiJCLa7d1dhq9iUyGRYsWXbWtBBF1nNp6E/ZkWAafWtdVIbpSlL8X/LxVqKs3Y2cGBypT5+GQZAcAzpw50+hig0TUMQ5mlaCyzgSthwK9Q9hCSVcTBAFDGxJhTkGnzqTVbZjWcTVWoigiNzcX33//PR566CGHBUZErbP9lGW8Tr8wHbzYPUFNGBzlix9P5mMPp6BTJ9Lqd8QjR47YPZbJZOjSpQtWrlzZ7EwtImo/1sHJA8L10gZCTm1AhB5ymYCc0hqczjegRxBbAcn9tTrZSUpKao84iOg6ZBVWIquwEnKZwPE6dE1eKgX6hGhx7FIZtpzMZ7JDnUKrx+zcdNNNKC0tveq8wWBo9dRzInIMaxdWbKAP/H24OjhdmzUh3pl+WeJIiDpGq5OdHTt2oK6u7qrzNTU12L17t0OCIqLWSbKO1wnVcpdzataQaMs+WUculKKyhhNLyP21uBvr6NGjtr+fPHnSbldxk8mEzZs3IywszLHREVGzKmrrsT/LspP10IYPMaJrifD1RBcfNS5X1GJ7egGmDOCK8+TeWpzsDBw4EIIgQBCERrurPD09sWrVKocGR0TN25NRCKNJRKBGja5dvKUOh1yAIAgYFuOH74/lYmtaPpMdcnstTnaysrIgiiK6du2KAwcOoEuXLrZrKpUKgYGBkMu5wzJRR7N2YfUN1cFDySnn1DLDoi3Jzu6MQoiiyE1jya21+J0xKioKgGVrCCJyDmazaJtyHh+hlzYYcilx4Tp4KGUorqxDyvkS2zgeInfUomRnw4YNmDx5MpRKJTZs2HDNslOnTnVIYETUvBM5BhSU10KtkGFQlF7qcMiFKOUyxEf4IvlsETafyGOyQ26tRcnOtGnTkJeXh8DAQEybNq3JcoIgwGQyOSo2ImqGdcp5r2ANNB5KiaMhVzMsxg/JZ4uwM/0ynrtF6miI2k+Lkp0ru67YjUXkPLZbV02O0EPGMRfUSkOifCEAyCiowMXiKoT7eUkdElG7cNhGoETUsQoranH0YikAYGgUuyCo9fReKvQI0gAANp/Ia6Y0ketqUcvOm2++2eIbPvnkk20Ohohabkf6ZYgiEOnnhXBfT6nDIReVEOOH9PxybEvLx+9u7Cp1OETtokXJzuuvv96imwmCwGSHqINsP5UPwLJqskLORlpqm2Exfvho33mknC9BVW09vNRcvoDcT4t+q7Oysto7DiJqhdp6k21fI278Sdcj0s/LtprytlNcTZnc03V9HRRFEaIoOioWImqhvWeKUFlngt5Tib5hOqnDIRcmCAISYixjvn46yXE75J7alOy8//776NevHzw8PODh4YF+/frhvffec3RsRNSELSctXVhx4Tp4qdjtQNdnaEOysyejEGYzv8CS+2n1u+TSpUvxj3/8A/Pnz0diYiIAIDk5GQsXLkR2djZeeuklhwdJRL8ym0VsbUh2BrMLixwgLsyymnJJlREp2SXcUJbcTquTnbfeegvvvvsu7r33Xtu5qVOnon///pg/fz6THaJ2dvRSGQrKa+GhlHG8DjmEUi7DoEhf7D1ThB+P5zHZIbfT6m4so9GIIUOGXHV+8ODBqK+vd0hQRNS0LQ3jKvqGaKHlqsnkIMMaEpwdDQtVErmTVic7Dz74IN56662rzr/zzju4//77HRIUETXtpxOWLqyBkXruVE0OMyTaDwKAzMuVyC6ulDocIodq08jG999/Hz/99BOGDx8OANi/fz+ys7Mxc+ZMLFq0yFbuH//4h2OiJCIAwLnCSmQUVEAmAAnR/lKHQ25E56lEz2ANTuWVY/PxPDw6qpvUIRE5TKuTnePHj2PQoEEAgDNnzgAAAgICEBAQgOPHj9vK8RsnkeNZZ2H1DNIgUOshcTTkbobF+OFUXjm2pRUw2SG30upkJykpqT3iIKIWsCY7/SN0kMv4hYIcKyHGHx8lW1ZTLquqg85LJXVIRA7BNeaJXERxZR0OnS8GYPlQInK0CF9PhOk9UW8W8QM3BiU30uqWnZqaGqxatQpJSUkoKCiA2Wy2u3748GGHBUdEv9qWlg+zCET4eSLa31vqcMgNCYKAEd38sS7lIn48nod7hkZKHRKRQ7Q62Zk9ezZ++ukn3HnnnRg2bBjH5hB1kJ+sXVhhOii58Se1k+FdLclO8pki1NTVw4MrdJMbaPVv8caNG7Fp0ybccMMN7REPETWius6E3RmWjT+HccE3akexgT7w91ahqLIOW08V4Nb+3BiUXF+rvx6GhYVBo9G0RyyNio6OhiAIVx1z584FAIwZM+aqa48//niHxUfUEfZkFqLGaIa/twq9Q7RSh0NuzNqVBQCbjuVKHA2RY7Q62Vm5ciUWL16M8+fPt0c8Vzl48CByc3Ntx5YtWwAAM2bMsJWZM2eOXZkVK1Z0SGxEHcW6anL/cB082a1A7SyxWwAAYPfpQtSbzM2UJnJ+rX7XHDJkCGpqatC1a1d4eXlBqbRfrr64uNhhwQFAly5d7B4vX74c3bp1w+jRo23nvLy8EBwc7NDXJXIWJrOIbWmWJfwHR7ELi9pfnxAtNB4KlNfUY3dGIcb2CpQ6JKLr0upk595778WlS5fw8ssvIygoqEMHKNfV1eHjjz/GokWL7F73k08+wccff4zg4GBMmTIFzz//PLy8vJq8T21tLWpra22PDQZDu8ZNdD0OZ5egqLIOXio54iN1UodDnYBcJmB4jB+2pBXg+2O5THbI5bU62dm7dy+Sk5MxYMCA9ojnmtavX4/S0lLMmjXLdu6+++5DVFQUQkNDcfToUSxevBjp6en4+uuvm7zPsmXL8Je//KUDIia6ftZxE3FhOmjU3PiTOsaIbgHYklaApFMFMJtFyLiIJbmwVic7vXr1QnV1dXvE0qz3338fkydPRmjor7MDHn30Udvf4+LiEBISgnHjxuHMmTPo1q3x5c6XLFlit4eXwWBARERE+wVO1EZms4jNxy3jdYZF+3GpB+owAyL08FTKUVRZh4PnipHQlQtZkutq9QDl5cuX46mnnsKOHTtQVFQEg8Fgd7SX8+fPY+vWrfjd7353zXIJCQkAgMzMzCbLqNVqaLVau4PIGR25UIrcshp4KGUYyinn1IGUchmGRPsCADZyVha5uFa37EyaNAkAMG7cOLvzoihCEASYTCbHRPYba9asQWBgIG655ZZrlktNTQUAhISEtEscRB3p1y4sPfRe7MKijjWiWwB2ZxRi28l8vDS1L1sWyWW5xEagZrMZa9aswUMPPQSF4teQz5w5g08//RQ333wz/P39cfToUSxcuBCjRo1C//79OzxOIkcym0X80JDsDI325QcNdbjBkb5QygXklNXgeE4Z4sL0UodE1CatTnaunPL9W8ePH7+uYJqydetWZGdn45FHHrE7r1KpsHXrVrzxxhuorKxEREQEpk+fjueee65d4iDqSL9cLEVOQxcWN/4kKXiq5BgYocfBcyX47pdcJjvksq57dbLy8nJ89tlneO+995CSktIu3VgTJkyAKIpXnY+IiMDOnTsd/npEzsDWhRWqYxcWSWZEtwAcPFeCrSfz8ezNvaUOh6hN2ryb4K5du/DQQw8hJCQEr732Gm666Sbs27fPkbERdVqiKGLTMcssrCHRfpCxC4skMizaDzIBOFtYicyCCqnDIWqTViU7eXl5WL58OWJjYzFjxgxotVrU1tZi/fr1WL58OYYOHdpecRJ1KkcvluFSaTXUChmGswuLJKT1VKJvqGUxy29TL0kcDVHbtDjZmTJlCnr27ImjR4/ijTfeQE5ODlatWtWesRF1WlcuJKhjFxZJ7MZYy15Z1jWfiFxNi5OdH374AbNnz8Zf/vIX3HLLLZDL5e0ZF1GnJYoivm9IdoZE+0LOlWtJYiO6BUAuCMgoqMDp/HKpwyFqtRYnO3v27EF5eTkGDx6MhIQE/Otf/0JhYWF7xkbUKR27VIaLJezCIueh81RiQIQeAPBVykVpgyFqgxYnO8OHD8e7776L3NxcPPbYY/j8888RGhoKs9mMLVu2oLyc2T6RI1gHJvcL1cLXWyVxNEQWo3tYurI2HcttdHYskTNr9Wwsb29vPPLII9izZw+OHTuGp556CsuXL0dgYCCmTp3aHjESdRqWWViWLqzBUZyFRc4jIcYfSrmACyXVOHapTOpwiFqlzVPPAaBnz55YsWIFLl68iM8++8xRMRF1WidyDMguroJKLkMiN14kJ+KtVmBwpGWvrK8Pc1YWuZbrSnas5HI5pk2bhg0bNjjidkSdlnVgcr8wLfx82IVFzmVUjy4ALLOy2JVFrsQhyQ4RXT9R/HUvrCHswiInNDTaD2qFDHmGGhw6XyJ1OEQtxmSHyEkcvViGc0UNXVjd2IVFzsdDKUdCjB8A4KvDnJVFroPJDpGT+DY1BwDQP1wHf87CIic1uqEr66cT+TCZ2ZVFroHJDpETMJlFfHfUkuwkdvWHwC4sclLxkb7wVslRXFmHnzO51hq5BiY7RE5g39kiXC6vhbdKjuFd/aQOh6hJyiu6Wb85wllZ5BqY7BA5AesGi4MifaHx4F5Y5NxGxVq6sral5cNoMkscDVHzmOwQSazGaMIPDRssjujOLixyfv3D9dB5KmGoqUfSqQKpwyFqFpMdIontSL+M8pp6+HopMahh0TYiZyaXCbihu6Uraz27ssgFMNkhkpi1C2tItC+8VAqJoyFqGWtX1o7Tl1FTVy9xNETXxmSHSEJlVUZsS7N0A4zs1kXiaIharneIFgE+KlTVmfDd0VypwyG6JiY7RBLaeCwHdSYzwn09EReukzocohaTCQJu6hUEAPiaCwySk2OyQyQh64aKw7v6QSnnf0dyLWN7Wloj92cVI7+sRuJoiJrGd1ciiWQVViLlfAkEARjdI1DqcIhaLdzXCz0CfWAWgS9TLkgdDlGTmOwQSeSbhqb/PiFaRPh6SRwNUdvc1NvSlcVZWeTMmOwQScBsFvF1w4fDiK4BkMu4tg65plGxlt/fM5cr8cvFUqnDIWoUkx0iCRw8V4yLJdXwVMpxY2yA1OEQtZnGQ4lh0ZYtTtYdZFcWOScmO0QS+F+KpQsrPlIPvRe3hyDXdlMvy5izjcdyuX0EOSUmO0QdrKK2Ht8fs6xLMqZHF24PQS5vSJQvdJ5KlFYZsblh6xMiZ8Jkh6iDbfwlB1V1JgRrPRAfqZc6HKLrppDLMLanpXXnC3ZlkRNiskPUwb44ZPkwSOzmBw8lt4cg9zChj2VW1t4zhcgtrZY4GiJ7THaIOlBGfjmOZJdCJgDjGlafJXIHEX5e6BmkgVkEPjuQLXU4RHaY7BB1IGsTf1yYDuFcW4fczIS+DdtHHLkEURQljoboV06d7Lz44osQBMHu6NWrl+16TU0N5s6dC39/f/j4+GD69OnIz8+XMGKiptXVm21r69wY24Vr65DbGdk9AGqFDBdLqvFzZqHU4RDZOHWyAwB9+/ZFbm6u7dizZ4/t2sKFC/Hdd99h3bp12LlzJ3JycnDHHXdIGC1R07al5aO4sg56TyVu6Ma1dcj9eKkUtnWjPtnPrixyHk4/OlKhUCA4OPiq82VlZXj//ffx6aef4qabbgIArFmzBr1798a+ffswfPjwjg6V6Jqsb/7Du/rBx8Pp/+sRtcnEvsHYmlZgSe4rauHno5Y6JCLnb9nJyMhAaGgounbtivvvvx/Z2ZYPjJSUFBiNRowfP95WtlevXoiMjERycvI171lbWwuDwWB3ELWnrMJK7MkshADg//pcnbwTuYueQRpE+3uhziTiUw5UJifh1MlOQkIC1q5di82bN+Ott95CVlYWbrzxRpSXlyMvLw8qlQp6vd7uOUFBQcjLu/aiVsuWLYNOp7MdERER7VgLol9np/QN06JbFx+JoyFqP4Ig4Oa4EACWAfkcqEzOwKmTncmTJ2PGjBno378/Jk6ciE2bNqG0tBRffvnldd13yZIlKCsrsx0XLnARLGo/NUYT1jWsrTOmRyAHJpPbG92jCzyUMlwoqcbO05elDofIuZOd39Lr9ejRowcyMzMRHByMuro6lJaW2pXJz89vdIzPldRqNbRard1B1F42H89DSZURft4qjOzOgcnk/rxUCozpYVlR+aPk8xJHQ+RiyU5FRQXOnDmDkJAQDB48GEqlEtu2bbNdT09PR3Z2NhITEyWMksjeJ/stb/Y3dPOHt5oDk6lzuDnO8qVz5+nLyC+rkTga6uycOtn54x//iJ07d+LcuXPYu3cvbr/9dsjlctx7773Q6XSYPXs2Fi1ahKSkJKSkpODhhx9GYmIiZ2KR0ziVZ8DBcyWQCcCEvhyYTJ1HTIAPegT5wGQW8WHyOanDoU7OqZOdixcv4t5770XPnj1x1113wd/fH/v27UOXLl0AAK+//jpuvfVWTJ8+HaNGjUJwcDC+/vpriaMm+tXan88BAAZG6BHBFZOpk7m1fygAy35wRpNZ4mioMxNEDpWHwWCATqdDWVkZx++Qw5RU1mH4sm2orTfjT5N64QaO16FOxmgy4+G1B1FWbcRrMwbgzsHhUodEbqaln99O3bJD5Mo+P3gBtfVmRPp5YUiUr9ThEHU4pVyGm/tZum/X/pwlcTTUmTHZIWoH9SYz/tswTuGmXl2gVsqlDYhIIpP6hUAuE3A8x4CU8yVSh0OdFJMdonbw08l85JTVQOOhwLheQVKHQySZK5dceH/3WYmjoc6KyQ5RO7AOTL6xewD0XippgyGS2NQBloHKP53M5zR0kgSTHSIH++VCKQ6cK4ZcEDCR082J0CNIg9hAH9SbRby3h6071PGY7BA52DsNTfVDon0R5e8tcTREzuH2+DAAlv2yqutMEkdDnQ2THSIHyi6qwg/HcgEAt8SFcB8sogYjugUgUKOGoaYeH3GRQepgTHaIHOj9PWdhFoE+IVrEhemkDofIachlgq11Z+3eczCZO/0Sb9SBmOwQOUhJZR2+PHQRADC5bzAUcv73IrrS+N5B8FErkFtWg29TL0kdDnUifDcmcpD/7juPaqMJEX6eSOzmL3U4RE7HQynHLf1DAADv7DoLLuBPHYXJDpEDVNXVY+3ecwCACX2CuYggURNujQuBUi7gVF45dp6+LHU41Ekw2SFygE/3Z6O4sg5dNGqM5yKCRE3Se6nwf30s/0fe3JYhcTTUWTDZIbpONUYT3tllmW4+qU8wfDwUEkdE5NymDwqHXCbgcHYpks8USR0OdQJMdoiu07qUiygor4WflxKT+rFVh6g5gRoP3NQrEADwT7buUAdgskN0HerqzXh7xxkAwP/1DYLWk1tDELXEXYMjIBOAfWeLcJgbhFI7Y7JDdB3WH7mES6XV0HkqcUu/UKnDIXIZwToPjIrtAgB4Y+tpiaMhd8dkh6iN6urNeHO7pQl+fO8g+HqzVYeoNe4aGgEBwK6MQqRms3WH2g+THaI2+uLQBVwssbTqTBkQInU4RC4nwtcLo3pYWnde2ZwucTTkzpjsELVBjdGEfzW06kzqFwR/b7XEERG5pvsTIiETgOSzRZyZRe2GyQ5RG3y87zzyDbXw91ZhSn+O1SFqqxCdJ8b1tsxiXPHjKa6qTO2CyQ5RK1XU1uPfDTOwbo4Lho4zsIiuy71DI6GQCTiSXYod6QVSh0NuiMkOUSu9vzsLxZV1CNKqcTNnYBFdty4aNSb1CwZgGbtj5o7o5GBMdohaocBQg//ssrTqTB0QytWSiRzkriER8FDKcCqvHF8fuSh1OORmmOwQtcLrW0+jqs6ErgHemNCHqyUTOYqvlwp3DgoHALz6YzpqjCaJIyJ3wmSHqIXS88rxxcELAIC7hoTDQ8lWHSJHum1gGPy8Vcg31OLtnWekDofcCJMdohZ6eVMazCIwKFKPhBh/qcMhcjseSjlmDo8CALyz6yyKKmoljojcBZMdohbYkV6AnacvQy4TcM/QSCjk/K9D1B7G9gpEtL8XqupMWP7DKanDITfBd2yiZtTWm/CX704CAMb27IKewRqJIyJyXzJBwKM3dgUAfHX4Io5eLJU2IHILTHaImvHe7ixkFVZC56nEPUMjIBMEqUMicmtx4XqM7O4Pswj8+ZvjnIpO143JDtE1XCqtxr+2ZwIA7ogPQ5DWU+KIiDqH2SO7Qq2Q4dilMnxx6ILU4ZCLY7JDdA0vf5+GaqMJ3QN9cHNcsNThEHUaAT5q3DM0AgDwyuZTKKs2ShwRuTKnTnaWLVuGoUOHQqPRIDAwENOmTUN6uv3OuGPGjIEgCHbH448/LlHE5E6S0gvw/bFcCALwQEIUp5oTdbDbBoYhVO+B0ioj/rbxpNThkAtz6mRn586dmDt3Lvbt24ctW7bAaDRiwoQJqKystCs3Z84c5Obm2o4VK1ZIFDG5i4raevz562MAgJt6BmJghF7agIg6IaVchnljugMA1qVcRPKZQokjIlfl1F9VN2/ebPd47dq1CAwMREpKCkaNGmU77+XlheBgdjGQ47y6+RRyymrQxUeNB4ZHQS7joGQiKcSF6zG+dyC2phXgmf8dxZZFo+GhlEsdFrkYp27Z+a2ysjIAgJ+fn935Tz75BAEBAejXrx+WLFmCqqqqa96ntrYWBoPB7iCySjlfjI/2nQcAPDg8CgE+aokjIurcZo/sCr2nEhdKqrHyp/Tmn0D0Gy6T7JjNZixYsAA33HAD+vXrZzt/33334eOPP0ZSUhKWLFmC//73v3jggQeuea9ly5ZBp9PZjoiIiPYOn1xEjdGExV8dgygCiV39cWNsgNQhEXV6PmoFnhjTDQDwwc/n8MuFUmkDIpcjiKLoEgsYPPHEE/jhhx+wZ88ehIeHN1lu+/btGDduHDIzM9GtW7dGy9TW1qK29tdlyA0GAyIiIlBWVgatVuvw2Ml1/OW7E1jz8znoPJV4ZXp/hOk51ZzIWby8KQ3JZ4sQ7e+FzQtGsTuLYDAYoNPpmv38domWnXnz5mHjxo1ISkq6ZqIDAAkJCQCAzMzMJsuo1WpotVq7g2hPRiHW/HwOADAzMYqJDpGTmTu2O3SeSpwrqsLfvufsLGo5p052RFHEvHnz8M0332D79u2IiYlp9jmpqakAgJCQkHaOjtxJWZURf1z3CwBgVI8A3NQzUOKIiOi3dJ5KLBgXCwD4eF82dp0ukDgichVOnezMnTsXH3/8MT799FNoNBrk5eUhLy8P1dXVAIAzZ87gr3/9K1JSUnDu3Dls2LABM2fOxKhRo9C/f3+JoydXIYoinl1/DHmGGgRp1Xh4RAw3+iRyUkOi/TCxTxAAYNGXv6C4sk7iiMgVOPU7+ltvvYWysjKMGTMGISEhtuOLL74AAKhUKmzduhUTJkxAr1698NRTT2H69On47rvvJI6cXMnH+87j+6O5kMsEzB4Zw9lXRE7udzd2RYjOA4UVdZj/6WHunUXNcpkByu2ppQOcyP0cu1iG6W/tRZ3JjDsHheHBxGhu9EnkArIKK/HUulQYTSIWje+BJ8fHSh0SScCtBigTtQdDjRFzPz2MOpMZA8J1uJs7mhO5jJgAbzw6qisA4I1tp7HvTJHEEZEzY7JDnZLJLGLRF6nILq5CgI8Kc8d0595XRC5mYp9gjO7RBWYR+P2nh5FXViN1SOSkmOxQp7Typ3RsTSuAUi7g8VHdEMJp5kQuRxAEzB3THRG+niiurMPDaw+gxmiSOixyQkx2qNP5NvUS/r3jDADggeFRGBrj18wziMhZearkWDqlL3zUCqTllmPhF6ngUFT6LSY71KmkXijFM/87CgCY2DcIU/uHcpwOkYsL1nrg2cm9IBeAH47n4Z9bM6QOiZwMkx3qNM5ersAjaw+itt6MuDAd19MhciNx4XrMsQ1YzsAXB7MljoicCd/pqVMoKK/BzA8OoLiyDtH+Xlg0vge81RyQTORObokLxbSBoQCAJV8fw/ZTXGGZLJjskNsz1Bjx8JqDuFhSjUCNGn+c0BMBGi4cSOSOHr4hBqNiAywztD5JwZHsEqlDIifAZIfcWnmNEQ99cAAncgzQeijwx//rgSh/b6nDIqJ2IhMELBjfA/3DdagxmvHg+wdw9GKp1GGRxJjskNuqrK3Hw2sO4kh2KXzUCiwa3wO9Q3VSh0VE7Uwpl+G5m/ugZ5AGFbX1uP+9/TiRUyZ1WCQhJjvklsprjHh47UEcOl8Cb5UcC8fHYnA0p5gTdRaeKjleuq0vugf6oLymHve9ux/HLzHh6ayY7JDbKaqoxX3v7seBrGJ4KuX4w/geGMpEh6jT8VIp8Lfb+qFrgDfKqo24+z/J2H+W20p0Rkx2yK3klFbjrv8k49ilMmg8FPjjhB4YHuMHgWvpEHVK3moFXr49Dr2CNaisM+HBDw5ge1q+1GFRB2OyQ27j+KUy3PHvvThzuRJ+3ir8aVIvDIvxZ6JD1Ml5qxX427R+GBSpR129Gb/76BA+3nde6rCoAzHZIbfw44k8zHg7GXmGGoTqPPDczb3RP1wvdVhE5CTUCjmev6UPRsVaNg59bv1xvLjhBExmbi3RGTDZIZdmNotYnZSJxz9OQbXRhN4hGrw4pS9igzRSh0ZETkYhl+GPE3rg3qERAIC1e89h1poDKK2qkzgyam9MdshllVbVYfaHB/Hqj+kQRWBUjwAsvaUvdzAnoiYJgoD7EqLw9ISeUMoF7M4oxOR/7uZaPG6OyQ65pJTzxbjlzT1ISr8MpVzAg8MjsWBcD/h4cAsIImreqB5dsGJ6fwRq1Mgtq8H0t/ZizZ4smNmt5ZYEURQ7/U/WYDBAp9OhrKwMWq1W6nDoGurqzXhj62m8vfMMzCIQqFHjiTHdMCjSl7uXE1GrVdbW47Wf0nHovGVbiRHd/LHyrgEI0bGF2BW09PObyQ6Y7LiKoxdLsfirY0jLNQAAhnf1w+9GxiBIyzclImo7URTx7S85+Cj5HIwmET5qBZbe2hszhkRwNqeTY7LTCkx2nFt5jRErfzqNj5LPwSwCPmoF7k+IxMS+wVDK2RNLRI5xobgSr/50GlmFlQCAIdG+WH5HHLoHcsKDs2Ky0wpMdpyTySziq5SLeO2ndBSU1wIAhkX7YWZiFDfzJKJ2UW8y46vDF/HloYuoM5mhkAl4aEQ0nrwpFjovpdTh0W8w2WkFJjvORRRF7M4oxLIfTtm6rII0atyXEIlRsV2gYGsOEbWzvLJqrN5xBqkXSgEAOk8lnrypO+4fHgUPpVza4MiGyU4rMNlxDqIoYk9mId7YmoGUhsGCXio5JvcLxu3xYdB5qiSOkIg6m/1ZRfjg5yzklNYAsEyKmDu2O+4eGsGkxwkw2WkFJjvSMprM+OF4Ht7ffRa/XLTsSqyUCxgV2wV3Dg5HmN6TgwSJSDIms4gfjufiy0MXUFJlBAAE+Kgwa0Q07k+Igq83v4hJhclOKzDZkUa+oQbrDl3Ap/uzkVNm+daklAu4MbYLbo8PQ6SfF6eTE5HTMJrM2HQsF18dvmhLejwUMtwWH4b7hkWif7iOX8w6GJOdVmCy03Eqa+ux7VQBNqTmICm9wLYvjdZDgdE9umByvxCE+XoyySEip2U0mbH9VAE2/JKD7OIq2/neIRpMHxSOyXEhCONK7h2CyU4rMNlpXxW19diWlo9Nx3KxI/0yauvNtmuxgT64MTYAY3sGQu/FpmAich2iKOKXi2XYdCwXB88Vo/6K1ZcHRuhxS1wIJscFI9zXS8Io3RuTnVZgsuNYZrOIU3nl2HumEHvPFGFPZiHqrkhwgrRqxEfqMTo2EL2CNZxdRUQur6y6DltO5iP5bBEy8itw5Qdr/zAdbuwRgBHdAjA4ypcDmx2IyU4rMNm5PkaTGafzy3EkuxTJZ4qQfLYIxZX2uwgHadUYFOmL4V390TtYA08V97AiIvdUYKjBztOXsS/r6sRHpZBhcKQvRnTzx9AYP/QN1ULjwfV72orJTisw2Wm5ytp6nL1ciRM5ZTh2qQzHL5UhLa/cruUGANQKGWIDfdAzWIP4CF/0CtZAzW8zRNTJFFbUIvlMEY5eKsOpXANKq41XlYkJ8EZcmA5xYTr0C9MhNsgH/t4qDnZugU6X7KxevRqvvvoq8vLyMGDAAKxatQrDhg1r0XOZ7PxKFEWUVhmRU1aN3NIanC+uQlZhBc5ersTZy5XIM9Q0+jxPlRyRfl7oGeSDuFAd+oRq4eOh5EBjIqIGZrMZWUVVOJJdguM5ZcgqrLqqFdxK66FATIA3unXxQdcu3ojy90ao3hNhek900aghl/G9Fehkyc4XX3yBmTNn4u2330ZCQgLeeOMNrFu3Dunp6QgMDGz2+e6c7IiiiKo6E8pr6lFeY4Shph4llXUorqxDYWUtiirqUFRRi8KKOluCU200XfOeGg8FQvWeiPTzQld/b8QGaxDp6wkPpZzfRIiIWqGwohan8gzILLB8qbxQUoWiijpc64NZIRMQqFUjVOeJQK0avl4q+Hn/elz52NdLBQ+lzG3fmztVspOQkIChQ4fiX//6FwBL9hwREYH58+fjT3/6U7PPb69kp8BQg9p6M0xmEfVmEaYrjnqzGWZRRL2p4ZzYUMZk+fuvzzHDaBJRazShxmhGbb3lzxqjCbX19n/W1JtRU2dCea0lsSmvqUdFbb1tendraDwU8PVSwd9bhSCtGqF6T4TrvRDh5wU/bxWUcsFt//MQEUmpqrYe2SVVuFBchYsl1cgtq0ZBeS1KqoworapDa9/SZQLgrVbAW6WAt1oOH7XC8litgLdKDg+lHCqFDGqFDCqFDCq55fGV59QKGVRyGZRyGeQyATKZAIVMgEwQoJBb/pRfcU4u+/VQNJQP1KgdvnlzSz+/XX6UaF1dHVJSUrBkyRLbOZlMhvHjxyM5ObnR59TW1qK2ttb22GAwtEtsd7+zz7Z7rtRkgqWryVMph7dKAR8Phe0XXqNWQOupgL+3Gl00anTxUcNLrYBCJqCxfKbebMZvhugQEZGjCECknxci/a6esl5nNKOwsg4F5TUorKhFadWvX2wra+tRWVePyloTKmp//bJrFtHQul8vQWV+tXXhKHQPkmYHeZdPdgoLC2EymRAUFGR3PigoCKdOnWr0OcuWLcNf/vKXdo9N3ZANX5nlygRAJhMgF37NfmUy2D8WBMhlgEywZMNymQCl/NesWiUXoJDLoFI0/Cm3ZN5KuQCVXAZPlRxeKoXlT6Ucnio51IrWNWOKEGFsQ4sQERG1IxkQoFEhQNP8umSiKNpa/quNv/YKWP7+6+O6ejPqzSKMJsuf9SYR9SYzjOaGP62PTWZb8mQWRZhFESbzr383X3Ht6nKi3TpEHc3lk522WLJkCRYtWmR7bDAYEBER4fDX2bxgFOpNZtTWm20tJAIsf7ky7xCEX88TERG5EhEifjsgRhQt561kgiDp+kIun+wEBARALpcjPz/f7nx+fj6Cg4MbfY5arYZare6I8KCQy7hoHhERkYRc/lNYpVJh8ODB2LZtm+2c2WzGtm3bkJiYKGFkRERE5AxcvmUHABYtWoSHHnoIQ4YMwbBhw/DGG2+gsrISDz/8sNShERERkcTcItm5++67cfnyZSxduhR5eXkYOHAgNm/efNWgZSIiIup83GKdnevlzosKEhERuauWfn67/JgdIiIiomthskNERERujckOERERuTUmO0REROTWmOwQERGRW2OyQ0RERG6NyQ4RERG5NSY7RERE5NaY7BAREZFbc4vtIq6XdRFpg8EgcSRERETUUtbP7eY2g2CyA6C8vBwAEBERIXEkRERE1Frl5eXQ6XRNXufeWADMZjNycnKg0WggCILD7mswGBAREYELFy647Z5b7l5H1s/1uXsdWT/X5+51bM/6iaKI8vJyhIaGQiZremQOW3YAyGQyhIeHt9v9tVqtW/4CX8nd68j6uT53ryPr5/rcvY7tVb9rtehYcYAyERERuTUmO0REROTWmOy0I7VajRdeeAFqtVrqUNqNu9eR9XN97l5H1s/1uXsdnaF+HKBMREREbo0tO0REROTWmOwQERGRW2OyQ0RERG6NyQ4RERG5NSY7bbBr1y5MmTIFoaGhEAQB69evt7suiiKWLl2KkJAQeHp6Yvz48cjIyLArU1xcjPvvvx9arRZ6vR6zZ89GRUVFB9aiadeqn9FoxOLFixEXFwdvb2+EhoZi5syZyMnJsbuHq9bvtx5//HEIgoA33njD7rwz1w9oWR3T0tIwdepU6HQ6eHt7Y+jQocjOzrZdr6mpwdy5c+Hv7w8fHx9Mnz4d+fn5HViLpjVXv4qKCsybNw/h4eHw9PREnz598Pbbb9uVceb6LVu2DEOHDoVGo0FgYCCmTZuG9PR0uzItiT87Oxu33HILvLy8EBgYiKeffhr19fUdWZVGNVe/4uJizJ8/Hz179oSnpyciIyPx5JNPoqyszO4+zlo/oGU/QytRFDF58uRGf5edtY4trV9ycjJuuukmeHt7Q6vVYtSoUaiurrZd76j3UiY7bVBZWYkBAwZg9erVjV5fsWIF3nzzTbz99tvYv38/vL29MXHiRNTU1NjK3H///Thx4gS2bNmCjRs3YteuXXj00Uc7qgrXdK36VVVV4fDhw3j++edx+PBhfP3110hPT8fUqVPtyrlq/a70zTffYN++fQgNDb3qmjPXD2i+jmfOnMHIkSPRq1cv7NixA0ePHsXzzz8PDw8PW5mFCxfiu+++w7p167Bz507k5OTgjjvu6KgqXFNz9Vu0aBE2b96Mjz/+GGlpaViwYAHmzZuHDRs22Mo4c/127tyJuXPnYt++fdiyZQuMRiMmTJiAyspKW5nm4jeZTLjllltQV1eHvXv34sMPP8TatWuxdOlSKapkp7n65eTkICcnB6+99hqOHz+OtWvXYvPmzZg9e7btHs5cP6BlP0OrN954o9Gtipy5ji2pX3JyMiZNmoQJEybgwIEDOHjwIObNm2e3rUOHvZeKdF0AiN98843tsdlsFoODg8VXX33Vdq60tFRUq9XiZ599JoqiKJ48eVIEIB48eNBW5ocffhAFQRAvXbrUYbG3xG/r15gDBw6IAMTz58+Louge9bt48aIYFhYmHj9+XIyKihJff/112zVXqp8oNl7Hu+++W3zggQeafE5paamoVCrFdevW2c6lpaWJAMTk5OT2CrVNGqtf3759xZdeesnu3KBBg8Q///nPoii6Vv1EURQLCgpEAOLOnTtFUWxZ/Js2bRJlMpmYl5dnK/PWW2+JWq1WrK2t7dgKNOO39WvMl19+KapUKtFoNIqi6Fr1E8Wm63jkyBExLCxMzM3Nvep32ZXq2Fj9EhISxOeee67J53TkeylbdhwsKysLeXl5GD9+vO2cTqdDQkICkpOTAViyXb1ejyFDhtjKjB8/HjKZDPv37+/wmK9XWVkZBEGAXq8H4Pr1M5vNePDBB/H000+jb9++V113h/p9//336NGjByZOnIjAwEAkJCTYNZ+npKTAaDTa/R736tULkZGRtt9jZzZixAhs2LABly5dgiiKSEpKwunTpzFhwgQArlc/a/eNn58fgJbFn5ycjLi4OAQFBdnKTJw4EQaDASdOnOjA6Jv32/o1VUar1UKhsGzp6Er1AxqvY1VVFe677z6sXr0awcHBVz3Hler42/oVFBRg//79CAwMxIgRIxAUFITRo0djz549tud05Hspkx0Hy8vLAwC7X07rY+u1vLw8BAYG2l1XKBTw8/OzlXEVNTU1WLx4Me69917bBm+uXr9XXnkFCoUCTz75ZKPXXb1+BQUFqKiowPLlyzFp0iT89NNPuP3223HHHXdg586dACx1VKlUtgTW6srfY2e2atUq9OnTB+Hh4VCpVJg0aRJWr16NUaNGAXCt+pnNZixYsAA33HAD+vXrB6Bl8efl5TX6PmS95iwaq99vFRYW4q9//atd94ar1A9ouo4LFy7EiBEjcNtttzX6PFepY2P1O3v2LADgxRdfxJw5c7B582YMGjQI48aNs41h7cj3Uu56Tm1mNBpx1113QRRFvPXWW1KH4xApKSn45z//icOHDzfah+4OzGYzAOC2227DwoULAQADBw7E3r178fbbb2P06NFShucQq1atwr59+7BhwwZERUVh165dmDt3LkJDQ+1aQ1zB3Llzcfz4cbtvxO6kufoZDAbccsst6NOnD1588cWODc5BGqvjhg0bsH37dhw5ckTCyByjsfpZ32cee+wxPPzwwwCA+Ph4bNu2DR988AGWLVvWoTGyZcfBrE2Rv50VkZ+fb7sWHByMgoICu+v19fUoLi5utCnTGVkTnfPnz2PLli22Vh3Ateu3e/duFBQUIDIyEgqFAgqFAufPn8dTTz2F6OhoAK5dPwAICAiAQqFAnz597M737t3bNhsrODgYdXV1KC0ttStz5e+xs6qursazzz6Lf/zjH5gyZQr69++PefPm4e6778Zrr70GwHXqN2/ePGzcuBFJSUkIDw+3nW9J/MHBwY2+D1mvOYOm6mdVXl6OSZMmQaPR4JtvvoFSqbRdc4X6AU3Xcfv27Thz5gz0er3tvQYApk+fjjFjxgBwjTo2Vb+QkBAAaPZ9pqPeS5nsOFhMTAyCg4Oxbds22zmDwYD9+/cjMTERAJCYmIjS0lKkpKTYymzfvh1msxkJCQkdHnNrWROdjIwMbN26Ff7+/nbXXbl+Dz74II4ePYrU1FTbERoaiqeffho//vgjANeuHwCoVCoMHTr0qmmip0+fRlRUFABg8ODBUCqVdr/H6enpyM7Otv0eOyuj0Qij0Wg34wMA5HK57dums9dPFEXMmzcP33zzDbZv346YmBi76y2JPzExEceOHbP7MLF+MfntB1BHa65+gOV9c8KECVCpVNiwYYPdTEHAuesHNF/HP/3pT1e91wDA66+/jjVr1gBw7jo2V7/o6GiEhoZe832mQ99LHTrcuZMoLy8Xjxw5Ih45ckQEIP7jH/8Qjxw5YpuNtHz5clGv14vffvutePToUfG2224TY2JixOrqats9Jk2aJMbHx4v79+8X9+zZI8bGxor33nuvVFWyc6361dXViVOnThXDw8PF1NRUMTc313ZcOTvAVevXmN/OxhJF566fKDZfx6+//lpUKpXiO++8I2ZkZIirVq0S5XK5uHv3bts9Hn/8cTEyMlLcvn27eOjQITExMVFMTEyUqkp2mqvf6NGjxb59+4pJSUni2bNnxTVr1ogeHh7iv//9b9s9nLl+TzzxhKjT6cQdO3bY/R+rqqqylWku/vr6erFfv37ihAkTxNTUVHHz5s1ily5dxCVLlkhRJTvN1a+srExMSEgQ4+LixMzMTLsy9fX1oig6d/1EsWU/w9/Cb2ZjOXMdW1K/119/XdRqteK6devEjIwM8bnnnhM9PDzEzMxMW5mOei9lstMGSUlJIoCrjoceekgURcv08+eff14MCgoS1Wq1OG7cODE9Pd3uHkVFReK9994r+vj4iFqtVnz44YfF8vJyCWpztWvVLysrq9FrAMSkpCTbPVy1fo1pLNlx5vqJYsvq+P7774vdu3cXPTw8xAEDBojr16+3u0d1dbX4+9//XvT19RW9vLzE22+/XczNze3gmjSuufrl5uaKs2bNEkNDQ0UPDw+xZ8+e4sqVK0Wz2Wy7hzPXr6n/Y2vWrLGVaUn8586dEydPnix6enqKAQEB4lNPPWWbui2l5urX1M8XgJiVlWW7j7PWTxRb9jNs7Dm/XUbBWevY0votW7ZMDA8PF728vMTExES7L1Si2HHvpUJD0ERERERuiWN2iIiIyK0x2SEiIiK3xmSHiIiI3BqTHSIiInJrTHaIiIjIrTHZISIiIrfGZIeIiIjcGpMdIiKiTu7cuXOYPXs2YmJi4OnpiW7duuGFF15AXV2dXbmjR4/ixhtvhIeHByIiIrBixQq76ydOnMD06dMRHR0NQRDwxhtvdGAtmsZkh4gkN2vWLEybNq3DX3ft2rUQBAGCIGDBggUOu6/1jV4QhKs26ySSypgxY7B27dpGr506dQpmsxn/+c9/cOLECbz++ut4++238eyzz9rKWPcri4qKQkpKCl599VW8+OKLeOedd2xlqqqq0LVrVyxfvtxpNisFwL2xiKh9oYll5a3HCy+8IJaWloolJSUdHtuaNWtErVYr5ubmigaDwWH3LSgoEL/66isRgCT1ImrM6NGjr7ldxW+tWLFCjImJsT3+97//Lfr6+trtg7h48WKxZ8+ejT6/sa12GvPCCy+IAwYMsDv3+uuvi1FRUbbHSUlJ4tChQ0UvLy9Rp9OJI0aMEM+dO9fiuigky7KIqFPIzc21/f2LL77A0qVL7XZC9vHxgY+PjxShAQAEQXD4N9AuXbrAz8/Pofck6mhlZWV2v8fJyckYNWoUVCqV7dzEiRPxyiuvoKSkBL6+vu0SR319PaZNm4Y5c+bgs88+Q11dHQ4cOABBEFp8D3ZjEVG7Cg4Oth06nc6WXFgPHx+fq7qxxowZg/nz52PBggXw9fVFUFAQ3n33XVRWVuLhhx+GRqNB9+7d8cMPP9i91vHjxzF58mT4+PggKCgIDz74IAoLC1sdc3R0NF5++WU88sgj0Gg0iIyMtGuqr6urw7x58xASEgIPDw9ERUVh2bJlbf43InI2mZmZWLVqFR577DHbuby8PAQFBdmVsz7Oy8trt1gMBgPKyspw6623olu3bujduzceeughREZGtvgeTHaIyCl9+OGHCAgIwIEDBzB//nw88cQTmDFjBkaMGIHDhw9jwoQJePDBB1FVVQUAKC0txU033YT4+HgcOnQImzdvRn5+Pu666642vf7KlSsxZMgQHDlyBL///e/xxBNP2Fqk3nzzTWzYsAFffvkl0tPT8cknnyA6OtpRVSdyiJdfftnWcurj44Pdu3fj8ccftzuXnZ191fMuXbqESZMmYcaMGZgzZ44Ekdvz8/PDrFmzMHHiREyZMgX//Oc/7VqMW4LJDhE5pQEDBuC5555DbGwslixZAg8PDwQEBGDOnDmIjY3F0qVLUVRUhKNHjwIA/vWvfyE+Ph4vv/wyevXqhfj4eHzwwQdISkrC6dOnW/36N998M37/+9+je/fuWLx4MQICApCUlAQAyM7ORmxsLEaOHImoqCiMHDkS9957r0PrT3S9Hn/8caSmptqOIUOG4KWXXrI7FxoaavecnJwcjB07FiNGjLBrzQQsrbT5+fl256yPHd0VbDKZ7B6vWbMGycnJGDFiBL744gv06NED+/bta/H9OGaHiJxS//79bX+Xy+Xw9/dHXFyc7Zy1+bygoAAA8MsvvyApKanR8T9nzpxBjx492vz61q4362vNmjUL//d//4eePXti0qRJuPXWWzFhwoRW3Z+ovfn5+dmNufH09ERgYCC6d+/eaPlLly5h7NixGDx4MNasWQOZzL49JDExEX/+859hNBqhVCoBAFu2bEHPnj2ve7zOb5Oos2fPXlUmPj4e8fHxWLJkCRITE/Hpp59i+PDhLbo/W3aIyClZ30ytBEGwO2cdnGg2mwEAFRUVmDJlit231tTUVGRkZGDUqFEOeX3raw0aNAhZWVn461//iurqatx111248847W/0aRM7i0qVLGDNmDCIjI/Haa6/h8uXLyMvLsxuLc99990GlUmH27Nk4ceIEvvjiC/zzn//EokWLbGXq6ups//fq6upw6dIlpKamIjMz85qvn5eXh5deeglnz57FV199hf/+978oKSnBqVOnkJWVhSVLliA5ORnnz5/HTz/9hIyMDPTu3bvF9WPLDhG5hUGDBuGrr75CdHQ0FIr2f2vTarW4++67cffdd+POO+/EpEmTUFxczFlY5JK2bNmCzMxMZGZmIjw83O6aKIoAAJ1Oh59++glz587F4MGDERAQgKVLl+LRRx+1lc3JyUF8fLzt8WuvvYbXXnsNo0ePxo4dO5p8/X79+uH06dPo27cvYmJi8N5772Hu3Ln44x//iPfffx+nTp3Chx9+iKKiIoSEhGDu3Ll2g6ebw2SHiNzC3Llz8e677+Lee+/FM888Az8/P2RmZuLzzz/He++9B7lc7rDX+sc//oGQkBDEx8dDJpNh3bp1CA4Ohl6vd9hrEDnatZKNWbNmYdasWc3eo3///ti9e3eT16Ojo23JUWvI5XJ8/PHH+Pjjj23nrpxc8M0337T6nldiNxYRuYXQ0FD8/PPPMJlMmDBhAuLi4rBgwQLo9fqrxh5cL41GgxUrVmDIkCEYOnQozp07h02bNjn8dYjIMQSxLSkYEZEbWLt2LRYsWNAuWzrs2LEDY8eORUlJCVt8iK7hxRdfxPr165Gamtpur8GvIUTUqZWVlcHHxweLFy922D379u2LyZMnO+x+RO7sxRdfbNdEB2DLDhF1YuXl5bYpr3q9HgEBAQ657/nz52E0GgEAXbt2ZfcWkcSY7BAREZFb49cNIiIicmtMdoiIiMitMdkhIiIit8Zkh4iIiNwakx0iIiJya0x2iIiIyK0x2SEiIiK3xmSHiIiI3Nr/A+ba2exxiENBAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "compiled_schedule.plot_pulse_diagram(x_range=(201e-6, 201.5e-6))" ] }, { "cell_type": "markdown", "id": "d1e548f8", "metadata": {}, "source": [ "## repetitions parameter in ScheduleGettable.process_acquired_data()\n", "\n", "In version 0.15, the `repetitions` parameter of the {meth}`.ScheduleGettable.process_acquired_data` method was deprecated. This parameter has no effect, and can simply be omitted. The {ref}`sec-tutorial-schedulegettable-repetitions` section of {ref}`sec-tutorial-schedulegettable` contains more information on how to set the number of repetitions in an experiment.\n", "\n", "## t parameter in NumericalWeightedIntegrationComplex\n", "\n", "In version 0.13.0, the `t` parameter in the {class}`~quantify_scheduler.operations.acquisition_library.NumericalWeightedIntegrationComplex` initializer was replaced by the `weights_sampling_rate` parameter, which takes a sampling rate in Hz.\n", "\n", "This means that creating a class instance as\n", "\n", "```python\n", "NumericalWeightedIntegrationComplex(\n", " weights_a=[0.1, 0.2, 0.3],\n", " weight_b=[0.4, 0.5, 0.6],\n", " t=[0.0, 1e-9, 2e-9],\n", " port=\"some_port\",\n", " clock=\"some_clock\",\n", " # other args\n", ")\n", "```\n", "\n", "should now be done as" ] }, { "cell_type": "code", "execution_count": 9, "id": "cacf3530", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "NumericalWeightedIntegrationComplex(weights_a=[0.1, 0.2, 0.3], weights_b=[0.4, 0.5, 0.6], weights_sampling_rate=999999999.9999999, port='some_port', clock='some_clock', interpolation='linear', acq_channel=0, acq_index=0, bin_mode='append', phase=0, t0=0)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from quantify_scheduler.operations.acquisition_library import NumericalWeightedIntegrationComplex\n", "\n", "\n", "NumericalWeightedIntegrationComplex(\n", " weights_a=[0.1, 0.2, 0.3],\n", " weights_b=[0.4, 0.5, 0.6],\n", " weights_sampling_rate=1e9,\n", " port=\"some_port\",\n", " clock=\"some_clock\",\n", " # other args\n", ")" ] }, { "cell_type": "markdown", "id": "2041349a", "metadata": {}, "source": [ "## Circuit diagrams and pulse diagrams\n", "\n", "The functions to plot circuit and pulse diagrams have moved to a private module in version 0.12.0.\n", "\n", "Instead, to plot circuit and pulse diagrams, call, directly on the schedule, {meth}`~quantify_scheduler.schedules.schedule.ScheduleBase.plot_circuit_diagram` and {meth}`~quantify_scheduler.schedules.schedule.ScheduleBase.plot_pulse_diagram`. \n", "\n", "For example, the line\n", "\n", "```python\n", "pulse_diagram_plotly(schedule)\n", "pulse_diagram_matplotlib(schedule)\n", "```\n", "\n", "should now be written as" ] }, { "cell_type": "code", "execution_count": 10, "id": "29b36c8f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
,\n", " )" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "compiled_schedule.plot_pulse_diagram(plot_backend=\"plotly\")\n", "compiled_schedule.plot_pulse_diagram(plot_backend=\"mpl\")" ] }, { "cell_type": "markdown", "id": "7b1a3a64", "metadata": {}, "source": [ "More examples can be found in the {ref}`Schedules and Pulses` and {ref}`Operations and Qubits` tutorials.\n", "\n", "## acq_channel\n", "\n", "In the {class}`~quantify_scheduler.operations.gate_library.Measure` and {class}`~quantify_scheduler.operations.nv_native_library.CRCount` classes, the `acq_channel` parameter has been removed from the initializers. For gate-level operations, the acquisition channel can be set in the {class}`~quantify_scheduler.device_under_test.device_element.DeviceElement` subclasses, such as {class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`, instead. See, for example, `q0.measure.acq_channel(0)` in the {ref}`Compilation Setup`.\n", "\n", "\n", "\n", "## add_pulse_information_transmon() => compile_circuit_to_device()\n", "\n", "The compilation step `add_pulse_information_transmon` has been replaced by `compile_circuit_to_device`. For steps on how to add device configuration to your compilation steps, please see {ref}`Operations and Qubits`.\n", "\n", "## Qblox Hardware Configuration\n", "\n", "In quantify-scheduler 0.8.0, the schema for the Qblox hardware configuration was revised. From version 0.13.0, old hardware configurations will no longer be automatically converted. Below is a summary of the changes.\n", "\n", "1. `seqx` => `portclock_configs` \n", "1. `latency_correction` => standalone/top-level `latency_corrections`\n", "1. `line_gain_db` removed\n", "\n", "The code below can be used to convert old-style to new-style hardware configurations.\n", "Note that helper function `convert_hw_config_to_portclock_configs_spec` will be removed in version 0.17.0." ] }, { "cell_type": "code", "execution_count": 11, "id": "14a80353", "metadata": {}, "outputs": [], "source": [ "depr_hardware_cfg = {\n", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " \"cluster\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " \"cluster_module1\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"line_gain_db\": 0,\n", " \"seq0\": {\n", " \"port\": \"q6:res\",\n", " \"clock\": \"q6.ro\",\n", " \"latency_correction\": 4e-9,\n", " },\n", " \"seq1\": {\n", " \"port\": \"q1:res\",\n", " \"clock\": \"q1.ro\",\n", " },\n", " },\n", " },\n", " },\n", "}" ] }, { "cell_type": "code", "execution_count": 12, "id": "4d8fc0d9", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1234/2486791990.py:5: FutureWarning:\n", "\n", "Function quantify_scheduler.backends.qblox.helpers.convert_hw_config_to_portclock_configs_spec() is deprecated and will be removed in quantify-scheduler-0.17.0. `convert_hw_config_to_portclock_configs_spec` will be removed in a future version.\n", "\n" ] } ], "source": [ "from quantify_scheduler.backends.qblox.helpers import (\n", " convert_hw_config_to_portclock_configs_spec,\n", ")\n", "\n", "new_hardware_cfg = convert_hw_config_to_portclock_configs_spec(depr_hardware_cfg)\n", "\n", "\n", "fnc = lambda sub: {\n", " key1: fnc(val1) if isinstance(val1, dict) else val1\n", " for key1, val1 in sub.items()\n", " if key1 != \"line_gain_db\"\n", "}\n", "\n", "new_hardware_cfg = fnc(new_hardware_cfg)" ] }, { "cell_type": "code", "execution_count": 13, "id": "9e52eab3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{\n", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\",\n", " \"cluster\": {\n", " \"ref\": \"internal\",\n", " \"instrument_type\": \"Cluster\",\n", " \"cluster_module1\": {\n", " \"instrument_type\": \"QRM_RF\",\n", " \"complex_output_0\": {\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"q6:res\",\n", " \"clock\": \"q6.ro\"\n", " },\n", " {\n", " \"port\": \"q1:res\",\n", " \"clock\": \"q1.ro\"\n", " }\n", " ]\n", " }\n", " }\n", " },\n", " \"latency_corrections\": {\n", " \"q6:res-q6.ro\": 4e-09\n", " }\n", "}\n" ] } ], "source": [ "import json\n", "\n", "print(json.dumps(new_hardware_cfg, indent=4))" ] }, { "cell_type": "markdown", "id": "23065385", "metadata": {}, "source": [ "## TransmonElement => BasicTransmonElement\n", "\n", "In quantify-scheduler 0.7.0, the {class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement` class was added and replaced the `TransmonElement` class." ] }, { "cell_type": "code", "execution_count": 14, "id": "c1590f25", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qcodes import Instrument\n", "\n", "Instrument.close_all()" ] }, { "cell_type": "code", "execution_count": 15, "id": "477eb314", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "basic: ['IDN', 'reset', 'rxy', 'measure', 'ports', 'clock_freqs']\n", "basic.reset: ['duration']\n", "basic.rxy: ['amp180', 'motzoi', 'duration']\n", "basic.measure: ['pulse_type', 'pulse_amp', 'pulse_duration', 'acq_channel', 'acq_delay', 'integration_time', 'reset_clock_phase', 'acq_weights_a', 'acq_weights_b', 'acq_weights_sampling_rate', 'acq_weight_type', 'acq_rotation', 'acq_threshold']\n", "basic.ports: ['microwave', 'flux', 'readout']\n", "basic.clock_freqs: ['f01', 'f12', 'readout']\n" ] } ], "source": [ "# Before:\n", "# from quantify_scheduler.device_under_test.transmon_element import TransmonElement\n", "\n", "# transmon = TransmonElement(\"transmon\")\n", "# print(f\"{transmon.name}: {list(transmon.parameters.keys())}\")\n", "\n", "# After:\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "\n", "basic = BasicTransmonElement(\"basic\")\n", "print(f\"{basic.name}: {list(basic.parameters.keys()) + list(basic.submodules.keys())}\")\n", "for submodule_name, submodule in basic.submodules.items():\n", " print(f\"{basic.name}.{submodule_name}: {list(submodule.parameters.keys())}\")" ] }, { "cell_type": "markdown", "id": "e9455821", "metadata": {}, "source": [ "The block below shows how the attributes of the `TransmonElement` (`transmon`) are converted to attributes of the `BasicTransmonElement` (`basic`).\n", "\n", "```\n", "transmon.IDN => basic.IDN\n", "transmon.instrument_coordinator => None\n", "transmon.init_duration => basic.reset.duration\n", "transmon.mw_amp180 => basic.rxy.amp180\n", "transmon.mw_motzoi => basic.rxy.motzoi\n", "transmon.mw_pulse_duration => basic.rxy.duration\n", "transmon.mw_ef_amp180 => None\n", "transmon.mw_port => basic.ports.microwave\n", "transmon.fl_port => basic.ports.flux\n", "transmon.ro_port => basic.ports.readout\n", "transmon.mw_01_clock => no longer settable, always \"basic.01\"\n", "transmon.mw_12_clock => no longer settable, always \"basic.12\"\n", "transmon.ro_clock => no longer settable, always \"basic.ro\"\n", "transmon.freq_01 => basic.clock_freqs.f01\n", "transmon.freq_12 => basic.clock_freqs.f12\n", "transmon.ro_freq => basic.clock_freqs.readout\n", "transmon.ro_pulse_amp => basic.measure.pulse_amp\n", "transmon.ro_pulse_duration => basic.measure.pulse_duration\n", "transmon.ro_pulse_type => basic.measure.pulse_type\n", "transmon.ro_pulse_delay => via:\tschedule.add(..., rel_time=...)\n", "transmon.ro_acq_channel => basic.measure.acq_channel\n", "transmon.ro_acq_delay => basic.measure.acq_delay\n", "transmon.ro_acq_integration_time => basic.measure.integration_time\n", "transmon.spec_pulse_duration => via:\tschedule.add(SpectroscopyOperation(\"basic\")), not implemented for BasicTransmonElement, see BasicElectronicNVElement.spectroscopy_operation\n", "transmon.spec_pulse_frequency => via:\tschedule.add(SpectroscopyOperation(\"basic\")), not implemented for BasicTransmonElement, see BasicElectronicNVElement.spectroscopy_operation\n", "transmon.spec_pulse_amp => via:\tschedule.add(SpectroscopyOperation(\"basic\")), not implemented for BasicTransmonElement, see BasicElectronicNVElement.spectroscopy_operation\n", "transmon.spec_pulse_clock => via:\tschedule.add(SpectroscopyOperation(\"basic\")), not implemented for BasicTransmonElement, see BasicElectronicNVElement.spectroscopy_operation\n", "transmon.acquisition => via:\tschedule.add(Measure(\"basic\", acq_protocol=...))\n", "transmon.ro_acq_weight_type => basic.measure.acq_weight_type\n", "schedule.add(Measure(\"transmon\", acq_channel=...)) => basic.measure.acq_channel\n", "```\n", "\n", "Both classes will generate the same device configuration." ] }, { "cell_type": "code", "execution_count": 16, "id": "af5a1928", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'backend': 'quantify_scheduler.backends.circuit_to_device._compile_circuit_to_device',\n", " 'clocks': {'basic.01': nan, 'basic.12': nan, 'basic.ro': nan},\n", " 'edges': {},\n", " 'elements': {'basic': {'Rxy': {'factory_func': 'quantify_scheduler.operations.pulse_factories.rxy_drag_pulse',\n", " 'factory_kwargs': {'amp180': nan,\n", " 'clock': 'basic.01',\n", " 'duration': 2e-08,\n", " 'motzoi': 0,\n", " 'port': 'basic:mw',\n", " 'reference_magnitude': None},\n", " 'gate_info_factory_kwargs': ['theta', 'phi']},\n", " 'Rz': {'factory_func': 'quantify_scheduler.operations.pulse_factories.phase_shift',\n", " 'factory_kwargs': {'clock': 'basic.01'},\n", " 'gate_info_factory_kwargs': ['theta']},\n", " 'measure': {'factory_func': 'quantify_scheduler.operations.measurement_factories.dispersive_measurement',\n", " 'factory_kwargs': {'acq_channel': 0,\n", " 'acq_delay': 0,\n", " 'acq_duration': 1e-06,\n", " 'acq_protocol_default': 'SSBIntegrationComplex',\n", " 'acq_rotation': 0,\n", " 'acq_threshold': 0,\n", " 'acq_weights_a': None,\n", " 'acq_weights_b': None,\n", " 'acq_weights_sampling_rate': None,\n", " 'clock': 'basic.ro',\n", " 'port': 'basic:res',\n", " 'pulse_amp': 0.25,\n", " 'pulse_duration': 3e-07,\n", " 'pulse_type': 'SquarePulse',\n", " 'reference_magnitude': None,\n", " 'reset_clock_phase': True},\n", " 'gate_info_factory_kwargs': ['acq_index',\n", " 'bin_mode',\n", " 'acq_protocol']},\n", " 'reset': {'factory_func': 'quantify_scheduler.operations.pulse_library.IdlePulse',\n", " 'factory_kwargs': {'duration': 0.0002},\n", " 'gate_info_factory_kwargs': None}}},\n", " 'scheduling_strategy': 'asap'}\n" ] } ], "source": [ "import pprint\n", "\n", "# device_config_transmon = transmon.generate_device_config().model_dump()\n", "# pprint.pprint(device_config_transmon)\n", "\n", "device_config_basic_transmon = basic.generate_device_config().model_dump()\n", "pprint.pprint(device_config_basic_transmon)" ] }, { "cell_type": "markdown", "id": "6fc6a432", "metadata": {}, "source": [ "## Instruction-generated pulses (Qblox only)\n", "\n", "Instead of using the ``instruction_generated_pulses_enabled: True`` field in the port-clock configuration for generating long square and staircase pulses, you can now create long square, staircase and ramp waveforms (that would otherwise not fit in memory), by creating these operations with the following helper functions." ] }, { "cell_type": "code", "execution_count": 17, "id": "93725c3d", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.pulse_factories import (\n", " long_ramp_pulse,\n", " long_square_pulse,\n", " staircase_pulse,\n", ")\n", "\n", "ramp_pulse = long_ramp_pulse(amp=0.5, duration=1e-3, port=\"q0:mw\")\n", "square_pulse = long_square_pulse(amp=0.5, duration=1e-3, port=\"q0:mw\")\n", "staircase_pulse = staircase_pulse(\n", " start_amp=0.0, final_amp=1.0, num_steps=20, duration=1e-4, port=\"q0:mw\"\n", ")" ] }, { "cell_type": "markdown", "id": "c30c6dc5", "metadata": {}, "source": [ "More complex long waveforms can now also be created, see section {ref}`Long waveform support `." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "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.9.18" }, "source_map": [ 6, 36, 90, 116, 143, 181, 189, 196, 207, 209, 225, 227, 252, 264, 282, 285, 310, 335, 352, 356, 362, 373, 387, 426, 434, 440, 452 ] }, "nbformat": 4, "nbformat_minor": 5 }