{ "cells": [ { "cell_type": "markdown", "id": "e75da488", "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", "| `control_flow` argument in `Schedule.add` | 0.20.1 | 0.23 | See {ref}`New control flow interface`|\n", "| `common.DistortionCorrection` | 0.20.1 | 0.23 | See {ref}`DistortionCorrection => SoftwareDistortionCorrection`|\n", "| `ScheduleGettable.generate_diagnostics_report()` | 0.17 | 0.18 | 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 | 0.18 | See {ref}`repetitions parameter in ScheduleGettable.process_acquired_data()` |\n", "| `t` parameter in `NumericalWeightedIntegrationComplex` | 0.13 | 0.18 | See {ref}`t parameter in NumericalWeightedIntegrationComplex` |\n", "| Qblox `convert_hw_config_to_portclock_configs_spec()` | 0.13 | 0.18 | 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": "7f7f706d", "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" ] }, { "name": "stdout", "output_type": "stream", "text": [ "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": "f8a01aba", "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": "53751f20", "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:mw\",\n", " \"clock\": \"q0.01\",\n", " },\n", " {\n", " \"port\": \"q0:res\",\n", " \"clock\": \"q0.ro\",\n", " },\n", " ],\n", " },\n", " },\n", " },\n", "}" ] }, { "cell_type": "code", "execution_count": 4, "id": "2548d87a", "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": "ad3077bb", "metadata": {}, "source": [ "## New control flow interface\n", "\n", "This is an example for the loop control flow. For other control flow types, please use the respective operation classes in the same way.\n", "\n", "```{code-block} python\n", "# Old way:\n", "from quantify_scheduler.operations.control_flow_library import Loop\n", "\n", "schedule_with_loop = Schedule(\"Schedule with loop\")\n", "\n", "subschedule = Schedule(\"Subschedule\")\n", "subschedule.add(X(\"q0\"))\n", "\n", "schedule_with_loop.add(subschedule, control_flow=Loop(3))\n", "```\n", "\n", "```{code-block} python\n", "# New way:\n", "from quantify_scheduler.operations.control_flow_library import LoopOperation\n", "from quantify_scheduler.operations.gate_library import X\n", "\n", "schedule_with_loop = Schedule(\"Schedule with loop\")\n", "\n", "subschedule = Schedule(\"Subschedule\")\n", "subschedule.add(X(\"q0\"))\n", "\n", "loop_operation = LoopOperation(body=subschedule, repetitions=3)\n", "\n", "schedule_with_loop.add(loop_operation)\n", "```\n", "\n", "## DistortionCorrection => SoftwareDistortionCorrection\n", "\n", "To prepare for distortion corrections performed by hardware, distortion corrections will now come in two flavors: `SoftwareDistortionCorrection` and `HardwareDistortionCorrection`. \n", "\n", "In the hardware configuration, the following needs to be replaced:\n", "\n", "```{code-block} diff\n", "\n", "hardware_configuration = {\n", " ...\n", " hardware_options : {\n", " ...\n", " distortion_corrections = {\n", "- \"q0:fl-cl0.baseband\": DistortionCorrection(\n", "+ \"q0:fl-cl0.baseband\": SoftwareDistortionCorrection( \n", " filter_func=\"scipy.signal.lfilter\",\n", " input_var_name=\"x\",\n", " kwargs={\n", " \"b\": [0, 0.25, 0.5],\n", " \"a\": [1]\n", " },\n", " clipping_values=[-2.5, 2.5]\n", " )\n", " }\n", " }\n", "}\n", "```\n", "\n", "## 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": "97599284", "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": "9666f68b", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/helpers.py:1421: FutureWarning: The hardware configuration dictionary is deprecated and will not be supported in quantify-scheduler >= 1.0.0. Please use a `HardwareCompilationConfig` instead. For more information on how to migrate from old- to new-style hardware specification, please visit https://quantify-os.org/docs/quantify-scheduler/dev/examples/hardware_config_migration.html in the documentation.\n", " warnings.warn(\n" ] } ], "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": "7153b152", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 waveform_op_idportclockabs_timedurationis_acquisitionoperationwf_idxoperation_hash
0Reset('q0')_acq_0Nonecl0.baseband0.0 ns200,000.0 nsFalseReset('q0')01182162100816613305
1ResetClockPhase(clock='q0.ro',t0=0)_acq_0Noneq0.ro200,000.0 ns0.0 nsFalseResetClockPhase(clock='q0.ro',t0=0)0-9154256341553766103
2SquarePulse(amp=0.2,duration=3e-07,port='q0:res',clock='q0.ro',reference_magnitude=None,t0=0)_acq_0q0:resq0.ro200,000.0 ns300.0 nsFalseSquarePulse(amp=0.2,duration=3e-07,port='q0:res',clock='q0.ro',reference_magnitude=None,t0=0)0-8296145970981113017
3Trace(duration=1e-06,port='q0:res',clock='q0.ro',acq_channel=0,acq_index=0,bin_mode='average',t0=1e-07)_acq_0q0:resq0.ro200,100.0 ns1,000.0 nsTrueTrace(duration=1e-06,port='q0:res',clock='q0.ro',acq_channel=0,acq_index=0,bin_mode='average',t0=1e-07)0644093113277042821
4DRAGPulse(G_amp=0.2,D_amp=0,phase=0,duration=1.6e-07,port='q0:res',clock='q0.ro',reference_magnitude=None,sigma=None,t0=0)_acq_0q0:resq0.ro201,100.0 ns160.0 nsFalseDRAGPulse(G_amp=0.2,D_amp=0,phase=0,duration=1.6e-07,port='q0:res',clock='q0.ro',reference_magnitude=None,sigma=None,t0=0)0-8938848356965653937
\n" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "compiled_schedule.timing_table" ] }, { "cell_type": "markdown", "id": "c9030806", "metadata": {}, "source": [ "## ScheduleGettable.generate_diagnostics_report()\n", "\n", "In version 0.17, the `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": "ddcda728", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
,\n", " )" ] }, "execution_count": 8, "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(x_range=(201e-6, 201.5e-6))" ] }, { "cell_type": "markdown", "id": "409516c0", "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": "5bac5c85", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/operations/acquisition_library.py:591: FutureWarning: NumericalWeightedIntegrationComplex is deprecated and will be removed in quantify-scheduler>=0.20.0. Use NumericalSeparatedWeightedIntegration instead.\n", " warnings.warn(\n" ] }, { "data": { "text/plain": [ "NumericalSeparatedWeightedIntegration(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": "014cbeaf", "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": "ac03ca17", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
,\n", " )" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABau0lEQVR4nO3deXgUVboG8Le6091JyEZCVggQWYLIDhJQBAQEAoII6uA4ShABuQEGcMSbUdlcgisoIujIondkVBSRQRaRVYaAIATEwQAxGJEkLDHprN1J+tw/kirSZCGd9JKuvL/n6WfSVdVVpypM+vM73zlHEkIIEBEREamUxtUNICIiInIkBjtERESkagx2iIiISNUY7BAREZGqMdghIiIiVWOwQ0RERKrGYIeIiIhUjcEOERERqRqDHSIiIlI1BjtEjVzbtm0RFxfnkmsvWrQIkiS55NpqJj/Xq1evOvxagwcPxuDBg+v12bi4OLRt29au7SFyBQY7RC7y448/4oEHHkCbNm3g6emJli1b4p577sGKFStc3TSHOXToEBYtWoScnBxXN4WImhAGO0QucOjQIfTp0wcnT57E1KlT8c477+CJJ56ARqPBW2+9ZXVsSkoK/vGPf7iopfZ16NAhLF68mMEOETmVh6sbQNQUvfTSS/D398fRo0cREBBgte/y5ctW7w0GgxNb1nhYLBaYzWZ4enq6uilE5OaY2SFygdTUVNx2221VAh0ACAkJsXp/Y83O+vXrIUkSDh48iNmzZyM4OBgBAQGYPn06zGYzcnJy8Nhjj6F58+Zo3rw55s+fDyGE8vkLFy5AkiS8/vrrWLZsGdq0aQMvLy8MGjQIp0+frlP7//nPf6J3797w8vJCYGAgJk6ciN9++63WzyxatAhPP/00ACAqKgqSJEGSJFy4cAEAIEkSZs6ciY8//hi33XYbDAYDduzYAQB4/fXXcccddyAoKAheXl7o3bs3Pv/88xrb1rdvX3h7e6N58+YYOHAgvvnmG6tjtm/fjrvuugvNmjWDr68vRo8ejZ9++umm911SUoLFixejQ4cO8PT0RFBQEAYMGIBdu3ZZHffzzz/joYceQnBwMLy8vBAdHY1nn322yvlycnIQFxeHgIAA+Pv7Y/LkySgsLKz2nuryvN9//320a9cOXl5e6Nu3L7777rsqx8j/fuTnLtu3bx8kScK+fftqfQYWiwXLly/HbbfdBk9PT4SGhmL69On4448/av0ckSsxs0PkAm3atEFSUhJOnz6NLl261Oscs2bNQlhYGBYvXozDhw/j/fffR0BAAA4dOoTWrVvj5ZdfxrZt2/Daa6+hS5cueOyxx6w+/9FHHyEvLw/x8fEoLi7GW2+9hSFDhuDHH39EaGhojdd96aWX8Pzzz+Ohhx7CE088gStXrmDFihUYOHAgTpw4UW0ABwDjx4/H2bNn8a9//QvLli1DixYtAADBwcHKMXv27MFnn32GmTNnokWLFkpx7FtvvYWxY8fikUcegdlsxieffIIHH3wQW7duxejRo5XPL168GIsWLcIdd9yBJUuWQK/X48iRI9izZw+GDx8OAPi///s/TJo0CSNGjMArr7yCwsJCrFq1CgMGDMCJEydqLchdtGgREhMT8cQTT6Bv374wGo04duwYjh8/jnvuuQcAcOrUKdx1113Q6XSYNm0a2rZti9TUVPz73//GSy+9ZHW+hx56CFFRUUhMTMTx48fxwQcfICQkBK+88orNz3vNmjWYPn067rjjDsyZMwe//PILxo4di8DAQERGRtZ4T7aaPn061q9fj8mTJ2P27NlIS0vDO++8gxMnTuA///kPdDqd3a5FZDeCiJzum2++EVqtVmi1WtG/f38xf/58sXPnTmE2m6sc26ZNGzFp0iTl/bp16wQAMWLECGGxWJTt/fv3F5IkiSeffFLZVlpaKlq1aiUGDRqkbEtLSxMAhJeXl7h48aKy/ciRIwKAmDt3rrJt4cKFovKfiQsXLgitViteeuklqzb++OOPwsPDo8r2G7322msCgEhLS6uyD4DQaDTip59+qrKvsLDQ6r3ZbBZdunQRQ4YMUbadO3dOaDQacf/994uysjKr4+XnlJeXJwICAsTUqVOt9mdmZgp/f/8q22/UvXt3MXr06FqPGThwoPD19RW//vprtW0Q4vpzffzxx62Ouf/++0VQUJDyvq7P22w2i5CQENGjRw9hMpmU495//30BwOr3L//7ufF3sHfvXgFA7N27V9k2adIk0aZNG+X9d999JwCIjz/+2OqzO3bsqHY7UWPBbiwiF7jnnnuQlJSEsWPH4uTJk3j11VcxYsQItGzZElu2bKnTOaZMmWI1LDwmJgZCCEyZMkXZptVq0adPH/zyyy9VPj9u3Di0bNlSed+3b1/ExMRg27ZtNV5z06ZNsFgseOihh3D16lXlFRYWhg4dOmDv3r11antNBg0ahM6dO1fZ7uXlpfz8xx9/IDc3F3fddReOHz+ubN+8eTMsFgsWLFgAjcb6T5v8nHbt2oWcnBw8/PDDVu3XarWIiYm5afsDAgLw008/4dy5c9Xuv3LlCg4cOIDHH38crVu3rrYNlT355JNW7++66y5cu3YNRqMRQN2f97Fjx3D58mU8+eST0Ov1yvni4uLg7+9f6z3ZYuPGjfD398c999xj1Z7evXvDx8enwb9/IkdhNxaRi9x+++3YtGkTzGYzTp48iS+//BLLli3DAw88gOTk5Gq/9Cu78ctU/lK7scvC39+/2nqKDh06VNnWsWNHfPbZZzVe89y5cxBCVPtZAA3uwoiKiqp2+9atW/Hiiy8iOTkZJpNJ2V45gEhNTYVGo6n1uclBypAhQ6rd7+fnV2v7lixZgvvuuw8dO3ZEly5dMHLkSDz66KPo1q0bAChBZV27Jm/8HTZv3hxAeUDn5+dX5+f966+/Aqj6O9XpdLjlllvq1Ja6OHfuHHJzc6vUlcluLK4naiwY7BC5mF6vx+23347bb78dHTt2xOTJk7Fx40YsXLiw1s9ptdo6bxeVCpQbwmKxQJIkbN++vdrr+Pj4NOj8lTM4su+++w5jx47FwIED8e677yI8PBw6nQ7r1q3Dhg0bbDq/xWIBUF63ExYWVmW/h0ftfxIHDhyI1NRUfPXVV/jmm2/wwQcfYNmyZVi9ejWeeOIJm9oC1Pw7lH9fjnjeNU0SWVZWdtPPWiwWhISE4OOPP652f+X6K6LGhMEOUSPSp08fAEBGRobDr1VdV8zZs2drLdBt164dhBCIiopCx44dbb5mfWZj/uKLL+Dp6YmdO3daDcNft25dlbZZLBb897//RY8ePao9V7t27QCUj3gbNmyYzW0BgMDAQEyePBmTJ09Gfn4+Bg4ciEWLFuGJJ55Qsih1HdV2M3V93m3atAFQ/jutnLUqKSlBWloaunfvrmyTs0c3znUkZ4du1p5vv/0Wd955Z7WBKVFjxZodIhfYu3dvtdkWuV4mOjra4W3YvHkzfv/9d+X9999/jyNHjiA2NrbGz4wfPx5arRaLFy+u0n4hBK5du1brNZs1awag6hdtbbRaLSRJsso8XLhwAZs3b7Y6bty4cdBoNFiyZImSwancNgAYMWIE/Pz88PLLL6OkpKTKta5cuVJrW268Px8fH7Rv317pWgsODsbAgQOxdu1apKenV9sGW9T1effp0wfBwcFYvXo1zGazcsz69eurPGs54Dtw4ICyraysDO+///5N2/PQQw+hrKwML7zwQpV9paWlnCySGi1mdohcYNasWSgsLMT999+PTp06wWw249ChQ/j000/Rtm1bTJ482eFtaN++PQYMGIAZM2bAZDJh+fLlCAoKwvz582v8TLt27fDiiy8iISEBFy5cwLhx4+Dr64u0tDR8+eWXmDZtGv72t7/V+PnevXsDAJ599llMnDgROp0OY8aMUYKg6owePRpvvvkmRo4ciT//+c+4fPkyVq5cifbt2+PUqVNW9/Pss8/ihRdewF133YXx48fDYDDg6NGjiIiIQGJiIvz8/LBq1So8+uij6NWrFyZOnIjg4GCkp6fj66+/xp133ol33nmnxrZ07twZgwcPRu/evREYGIhjx47h888/x8yZM5Vj3n77bQwYMAC9evXCtGnTEBUVhQsXLuDrr79GcnJyjeeuTl2ft06nw4svvojp06djyJAh+NOf/oS0tDSsW7euSs3Obbfdhn79+iEhIQHZ2dkIDAzEJ598gtLS0pu2Z9CgQZg+fToSExORnJyM4cOHQ6fT4dy5c9i4cSPeeustPPDAAzbdI5FTuGIIGFFTt337dvH444+LTp06CR8fH6HX60X79u3FrFmzRFZWltWxNQ09P3r0qNVx8nDmK1euWG2fNGmSaNasmfJeHnr+2muviTfeeENERkYKg8Eg7rrrLnHy5Mlqz3mjL774QgwYMEA0a9ZMNGvWTHTq1EnEx8eLlJSUm977Cy+8IFq2bCk0Go3VEGgAIj4+vtrPrFmzRnTo0EEYDAbRqVMnsW7duhrbtnbtWtGzZ09hMBhE8+bNxaBBg8SuXbusjtm7d68YMWKE8Pf3F56enqJdu3YiLi5OHDt2rNa2v/jii6Jv374iICBAeHl5iU6dOomXXnqpypQBp0+fFvfff78ICAgQnp6eIjo6Wjz//PPK/pp+VzUNC6/r83733XdFVFSUMBgMok+fPuLAgQNi0KBBVkPPhRAiNTVVDBs2TBgMBhEaGir+/ve/i127dt106Lns/fffF7179xZeXl7C19dXdO3aVcyfP19cunSp1udH5CqSEHaqXCQit3DhwgVERUXhtddeqzULQ0SkFqzZISIiIlVjsENERESqxmCHiIiIVI01O0RERKRqzOwQERGRqjHYISIiIlXjpIIoX+/l0qVL8PX1rdd09kREROR8Qgjk5eUhIiICGk3N+RsGOwAuXbpUZaVoIiIicg+//fYbWrVqVeN+BjsAfH19AZQ/LD8/Pxe3hoiIiOrCaDQiMjJS+R6vCYMdXF+J2c/Pj8EOERGRm7lZCQoLlImIiEjVGOwQERGRqjHYISIiIlVjsENERESqxmCHiIiIVI3BDhEREakagx0iIiJSNQY7REREpGoMdoiIiEjVGOwQERGRqrk02ElMTMTtt98OX19fhISEYNy4cUhJSbE6pri4GPHx8QgKCoKPjw8mTJiArKwsq2PS09MxevRoeHt7IyQkBE8//TRKS0udeStERETUSLk02Nm/fz/i4+Nx+PBh7Nq1CyUlJRg+fDgKCgqUY+bOnYt///vf2LhxI/bv349Lly5h/Pjxyv6ysjKMHj0aZrMZhw4dwocffoj169djwYIFrrglIiIiamQkIYRwdSNkV65cQUhICPbv34+BAwciNzcXwcHB2LBhAx544AEAwM8//4xbb70VSUlJ6NevH7Zv3457770Xly5dQmhoKABg9erVeOaZZ3DlyhXo9fqbXtdoNMLf3x+5ubl2XQhUCIGM3GJYGs8jplp46rRo4WNwdTOIiKiO6vr93ahWPc/NzQUABAYGAgB++OEHlJSUYNiwYcoxnTp1QuvWrZVgJykpCV27dlUCHQAYMWIEZsyYgZ9++gk9e/asch2TyQSTyaS8NxqNDrmfpz47iU0nfnfIuckxXhzXBX/p18bVzSAicojPjv6G5d+exfyR0RjXs5Wrm+M0jSbYsVgsmDNnDu6880506dIFAJCZmQm9Xo+AgACrY0NDQ5GZmakcUznQkffL+6qTmJiIxYsX2/kOqkq+mAMA0GokaGpffZ5crMwiYBFAUuo1BjtEpEqm0jLM/+IUAODpz0/h3m4R8NA2jXFKjSbYiY+Px+nTp3Hw4EGHXyshIQHz5s1T3huNRkRGRjrsevNHROP2toEOOz813MYffsO/vv8NALsciUidktNzlJ9LygRO/PYHbm8b5LoGOVGjCHZmzpyJrVu34sCBA2jV6npaLSwsDGazGTk5OVbZnaysLISFhSnHfP/991bnk0drycfcyGAwwGBwXm2GViNB10SiZ3ellZh6IyJ1O3c53+r9qd9ym0yw49JvYCEEZs6ciS+//BJ79uxBVFSU1f7evXtDp9Nh9+7dyraUlBSkp6ejf//+AID+/fvjxx9/xOXLl5Vjdu3aBT8/P3Tu3Nk5N0JERNTIXbhaYPU+JSvPRS1xPpdmduLj47FhwwZ89dVX8PX1VWps/P394eXlBX9/f0yZMgXz5s1DYGAg/Pz8MGvWLPTv3x/9+vUDAAwfPhydO3fGo48+ildffRWZmZl47rnnEB8f79TsDRERUWN24VohACDc3xMZucX4PafIxS1yHpcGO6tWrQIADB482Gr7unXrEBcXBwBYtmwZNBoNJkyYAJPJhBEjRuDdd99VjtVqtdi6dStmzJiB/v37o1mzZpg0aRKWLFnirNsgIiJq9C5cK8/s3Bruh4zcYlw2mm7yCfVwabBTlyl+PD09sXLlSqxcubLGY9q0aYNt27bZs2lERESqYbEIpGeXZ3a6Rvhjz8+Xca3ADItFQNMEhguzapaIiEjljMUlMJdaAADRYb4AgD8KzSgqaRpLKzHYISIiUrmr+eVdVt56LYJ9DdBqJAgBZOY2ja4sBjtEREQqdzXfDADw9fSAwUODQO/ypZQuNZEiZQY7REREKidndnw9dZAkCYHNyoOdDGOxK5vlNAx2iIiIVO5aRWbHz7N8XJKfV/n//lFgdlmbnInBDhERkcpdz+xUBDueOgDlRcpNAYMdIiIilZODHX+v8u4r34pgJ6ewxGVtciYGO0RERCp39cZurIr/ZWaHiIiIVCG3IoPj51We0WFmh4iIiFQlt6g8qPExlGd05NodYxGDHSIiIlIBY3F5UONrsO7Gyi1msENEREQqIGd2fG/oxsovLoXFcvN1Kt0dgx0iIiIVKymzoNBcBuB6ZkfuxsozlSprZqkZgx0iIiIVq1yX41MR5Mj/KwSQb1L/YqAMdoiIiFRM7sLy0mmh05Z/7eu1GnhoJABATpH6h58z2CEiIlIxJdjRa6GtCHAkSYK3Xmu1X80Y7BAREamYsbi8m8pbr4VGkpTt3vqKup1idmMRERGRG5MzN3ImR+ZtYGaHiIiIVMCoBDseVtubyZkdBjtERETkzuRuKk+d9Ve+nOkxcjQWERERubMCkxzsWHdjyZmdfNbsEBERkTsrMFcEOx7V1+xwnh0iIiJya0pm58YCZdbsEBERkRoUmMqXivC+oWanWUXwk8fMDhEREbkzuZvKS2c9GkvO7LAbi4iIiNya3I114zw7zVizQ0RERGqgZHZuCHbk0VnFJWVOb5OzMdghIiJSMSWzo6s+2CkyW5zeJmdjsENERKRiSmbHYF2z41UpsyOEcHq7nInBDhERkYoVmCtGY+mtv/LlGZWLS8tQZmGwQ0RERG6opMwCc2l5N1UzfU2ZHQtUHuu4Ntg5cOAAxowZg4iICEiShM2bN1vtlySp2tdrr72mHNO2bdsq+5cuXerkOyEiImp8Ck3Xi49rKlAuswjVFym7NNgpKChA9+7dsXLlymr3Z2RkWL3Wrl0LSZIwYcIEq+OWLFliddysWbOc0XwiIqJGLb9iqQgPjQSDR/XBDgDkFat7FmWPmx/iOLGxsYiNja1xf1hYmNX7r776CnfffTduueUWq+2+vr5VjiUiImrqKi8CqpEkq31ajQSdVkJJmVCOUyu3qdnJysrC119/jSlTplTZt3TpUgQFBaFnz5547bXXUFpa+y/NZDLBaDRavYiIiNRGHoll8NBAI1XdL2d38s3q7sZyaWbHFh9++CF8fX0xfvx4q+2zZ89Gr169EBgYiEOHDiEhIQEZGRl48803azxXYmIiFi9e7OgmExERuVTlzI4kVY12vHRa5BWXoqBY3Zkdtwl21q5di0ceeQSenp5W2+fNm6f83K1bN+j1ekyfPh2JiYkwGAzVnishIcHqc0ajEZGRkY5pOBERkYtcD3aq78hRMjsq78Zyi2Dnu+++Q0pKCj799NObHhsTE4PS0lJcuHAB0dHR1R5jMBhqDISIiIjUIr9iNJbnDbMny+Th5wUq78Zyi5qdNWvWoHfv3ujevftNj01OToZGo0FISIgTWkZERNR4FVSq2amOnPEpNDOz4zD5+fk4f/688j4tLQ3JyckIDAxE69atAZR3MW3cuBFvvPFGlc8nJSXhyJEjuPvuu+Hr64ukpCTMnTsXf/nLX9C8eXOn3QcREVFjVGC+XrNTHXm72kdjuTTYOXbsGO6++27lvVxHM2nSJKxfvx4A8Mknn0AIgYcffrjK5w0GAz755BMsWrQIJpMJUVFRmDt3rlU9DhERUVMlTyqoryGz48Vgx/EGDx5808XHpk2bhmnTplW7r1evXjh8+LAjmkZEROT25JmR9draC5QLWbNDRERE7qioIti5cfZkGYMdIiIicmvFJeWLgBo8qplREICXUqDMYIeIiIjcUHGdMzvqrtlhsENERKRSSs1OjUPP2Y1FREREbkyp2bnJ0PMiBjtERETkjq53Y9U09Lx8uxwUqRWDHSIiIpUqqihQ9mQ3FhEREamRktmpYSFQuXvLXGpxWptcgcEOERGRSt1snh25e8tUWgaLpfZJft0Zgx0iIiKVkjM7njVldpRgxwLLTVY0cGcMdoiIiFTqZvPsyNvNpRaoOLHDYIeIiEiNhBCVZlCuPbNTahEwl6q3SJnBDhERkQqZKhUde+urX/e7cuGyHBipEYMdIiIiFSquNHdOTZmdyquhF6h4yQgGO0RERCokj8TSaiR4aKv/upckSQmE1Lw+FoMdIiIiFZK7pfRaDTTVL3oO4HrWp9DEbiwiIiJyI/J6VzoPCZJUc7Qjj8gqKmFmh4iIiNxIccXoKn0NXVgyuUhZzUtGMNghIiJSoWJzHYMdDwY7RERE5IbkzI6uhpFYMrkbq1jFK58z2CEiIlKhIvP1AuXayJmdImZ2iIiIyJ3ImRpdHWt2ipjZISIiInciBy/6OnZjMdghIiIityJndurajcWaHSIiInIrxXXO7LAbi4iIiNyQMoNyXbuxWKBMRERE7qTONTs6dmMRERGRG5KDl5pWPJdd78bi2lhERETkRuTMjuGmBcqcVJCIiIjckKkiUyMHMzXhaCwiIiJyS0rNju5mNTsVmZ1SBjsOceDAAYwZMwYRERGQJAmbN2+22h8XFwdJkqxeI0eOtDomOzsbjzzyCPz8/BAQEIApU6YgPz/fiXdBRETU+Nhas2NizY5jFBQUoHv37li5cmWNx4wcORIZGRnK61//+pfV/kceeQQ//fQTdu3aha1bt+LAgQOYNm2ao5tORETUqMlDyesc7JSqN9jxcOXFY2NjERsbW+sxBoMBYWFh1e47c+YMduzYgaNHj6JPnz4AgBUrVmDUqFF4/fXXERERYfc2ExERuQM5s+N505qd8v2mEguEEJAkyeFtc7ZGX7Ozb98+hISEIDo6GjNmzMC1a9eUfUlJSQgICFACHQAYNmwYNBoNjhw5UuM5TSYTjEaj1YuIiEhNlNFYN6vZUTI7ZbAIhzfLJRp1sDNy5Eh89NFH2L17N1555RXs378fsbGxKCsr/wVmZmYiJCTE6jMeHh4IDAxEZmZmjedNTEyEv7+/8oqMjHTofRARETlbsTIaq26TCprLLLAIdUY7Lu3GupmJEycqP3ft2hXdunVDu3btsG/fPgwdOrTe501ISMC8efOU90ajkQEPERGpyvXMTh27sUotKLNYoLvJvDzuyK3u6JZbbkGLFi1w/vx5AEBYWBguX75sdUxpaSmys7NrrPMByuuA/Pz8rF5ERERqYiqVa3bq1o0lBGAuVWdmx62CnYsXL+LatWsIDw8HAPTv3x85OTn44YcflGP27NkDi8WCmJgYVzWTiIjIpYQQSjeW500zO9dDgQJzqUPb5Sou7cbKz89XsjQAkJaWhuTkZAQGBiIwMBCLFy/GhAkTEBYWhtTUVMyfPx/t27fHiBEjAAC33norRo4cialTp2L16tUoKSnBzJkzMXHiRI7EIiKiJqvyMPKbjcby0Gqg1UgoswgUqnTlc5dmdo4dO4aePXuiZ8+eAIB58+ahZ8+eWLBgAbRaLU6dOoWxY8eiY8eOmDJlCnr37o3vvvsOBoNBOcfHH3+MTp06YejQoRg1ahQGDBiA999/31W3RERE5HJFlYKWm9XsANezO4XM7Njf4MGDIWqp/N65c+dNzxEYGIgNGzbYs1lERERuTV76QauRoNPefN4cg4cGheYyFJnVObGgW9XsEBER0c3JmR2dVqrTJIHyiKwilWZ2GOwQERGpjFycrK/jMPLr3Vis2SEiIiI3oKx4fpNh5zL5OPlzasNgh4iISGVMcrBjY2aHwQ4RERG5BTlo0dU5s1Nes1PMYIeIiIjcQX1rdhjsEBERkVuwNbNzPdjh0HMiIiJyA8U21uwoBcocjUVERETuwNZgR87sVF5mQk0Y7BAREamMHOwYWKAMgMEOERGR6tS/ZofBDhEREbkBudC4rpkdBjtERETkVmydQfn6pIKs2SEiIiI3YHvNjlygzMwOERERuYHro7G0dTr+eoEyMztERETkBpSaHZ2tQ8+Z2SEiIiI3IE8OaGs3lpnz7BAREZE7sLVmh5MKEhERkVuRR2N5etStZsdQcZyp1AIhhMPa5SoMdoiIiFRGyezUsWancjeWCmMdBjtERERqU1TPbixzqQUWFUY7DHaIiIhU5voMynUdel4R7JRZUGZhsENERESNnK3dWJUzQEUqXDKCwQ4REZGKWCxCGVXlpbOtQBm4PmxdTTzqctDbb79t84knT54MX19fmz9HRERE9Vd5+Hhdu7G0GglajYQyi1BlZqdOwc6cOXPQqlUraOs47fRvv/2Ge++9l8EOERGRk1VeudyzjpkdoLwrq9Bc1nSDHQA4duwYQkJC6nQsgxwiIiLXkIMVOVtTV3qtBoUoQ6EKu7HqVLOzcOFC+Pj41Pmkf//73xEYGFjvRhEREVH9XF8EVAMbYh2lmLlYhcFOnTI7CxcutOmkCQkJ9WoMERERNYyc2dF5SJAk2zI7lT+vJnUejdWnTx+sXr0aRqPRke0hIiKiBpDn2JGDl7oyVNT3NOlgp3v37pg/fz7Cw8Px6KOPYt++fQ5sFhEREdVH5W4sW8hz7TTpYGfNmjXIzMzEypUr8dtvv2Ho0KFo3749Xn75Zfz+++/1uviBAwcwZswYREREQJIkbN68WdlXUlKCZ555Bl27dkWzZs0QERGBxx57DJcuXbI6R9u2bSFJktVr6dKl9WoPERGRu1OCnTouFSFTurFUWLNj05Pw9vZGXFwc9u3bh7Nnz2LixIl477330LZtW4wePRqbNm2y6eIFBQXo3r07Vq5cWWVfYWEhjh8/jueffx7Hjx/Hpk2bkJKSgrFjx1Y5dsmSJcjIyFBes2bNsqkdREREaqHU7NjcjVVRoKzCzE6dh57fqF27dnjxxRfxwgsv4IsvvsD06dOxY8cOlJXV/SHFxsYiNja22n3+/v7YtWuX1bZ33nkHffv2RXp6Olq3bq1s9/X1RVhYWP1uhIiISEWUmh2bMztaq8+rSYOWi9i3bx/i4uIQFxeHsrIyTJ061V7tqlZubi4kSUJAQIDV9qVLlyIoKAg9e/bEa6+9htLS0lrPYzKZYDQarV5ERERqUFTfmh1mdq67ePEi1q9fj/Xr1+OXX37BXXfdhXfffRcPPvggvLy8HNFGAEBxcTGeeeYZPPzww/Dz81O2z549G7169UJgYCAOHTqEhIQEZGRk4M0336zxXImJiVi8eLHD2kpEROQqpvp2Y2kZ7OCzzz7D2rVrsXv3boSEhGDSpEl4/PHH0b59e0e2D0B5sfJDDz0EIQRWrVpltW/evHnKz926dYNer8f06dORmJgIg8FQ7fkSEhKsPmc0GhEZGemYxhMRETmRXGBsczeWhxzsqK8bq87Bzl/+8heMHj0aX375JUaNGgWNxjkLpsuBzq+//oo9e/ZYZXWqExMTg9LSUly4cAHR0dHVHmMwGGoMhIiIiNxZcWl5sGOwMdiRj5c/ryZ1DnYuXrxY57Wx7EUOdM6dO4e9e/ciKCjopp9JTk6GRqNxeluJiIgagyJzeWbG1m4svYdcoNyEg53KwcOlS5dw8OBBXL58GRaLdbpr9uzZdb54fn4+zp8/r7xPS0tDcnIyAgMDER4ejgceeADHjx/H1q1bUVZWhszMTABAYGAg9Ho9kpKScOTIEdx9993w9fVFUlIS5s6di7/85S9o3rx5ndtBRESkFkpmR1fPzE5T7saSrV+/HtOnT4der0dQUJDVuhuSJNkU7Bw7dgx333238l6uo5k0aRIWLVqELVu2AAB69Ohh9bm9e/di8ODBMBgM+OSTT7Bo0SKYTCZERUVh7ty5VvU4RERETYm8kKeto7H07Ma67vnnn8eCBQuQkJDQ4LqdwYMHQwhR4/7a9gFAr169cPjw4Qa1gYiISE0aXLOjwm4sm6OVwsJCTJw40WkFykRERFR38mgsQ0UNTl3JwY5Jhd1YNkcsU6ZMwcaNGx3RFiIiImoguebG1poduUDZVKq+YMfmbqzExETce++92LFjB7p27QqdTme1v7bJ/IiIiMix5BmU69uNZWLNTnmws3PnTmUOmxsLlImIiMh1rq96bls3llygbGZmB3jjjTewdu1axMXFOaA5RERE1BANz+yoL9ixuWbHYDDgzjvvdERbiIiIqIHkzI6nztYC5fLjzaUWWCy1j4Z2NzYHO3/961+xYsUKR7SFiIiIGkgpUK7n2ljmUgssN5n6xd3Y3I31/fffY8+ePdi6dStuu+22KgXKmzZtslvjiIiIyDZKZqeeQ88Fyufq8bFxUsLGzOZgJyAgAOPHj3dEW4iIiKgBLBah1NzYPvT8+vFF5jL4GHS1HO1ebA521q1b54h2EBERUQNVLi62Ndjx0EjQSIBFAIVmdQ0/V0+OioiIqIkrqrTUg63dWJIkKdmdIpUtGVGnYKdXr174448/6nzSAQMG4Pfff693o4iIiMh2cr2Oh0aCh8b2ue/kxUOLVJbZqVM3VnJyMk6ePInAwMA6nTQ5ORkmk6lBDSMiIiLbyBkZnVZTr4l+DTotUFzaNIMdABg6dOhNVyGXcSZlIiIi57s+e7IG9fkqNlRkdgpV1o1Vp2AnLS3N5hO3atXK5s8QERFR/RUrmR0JmnpldsqDneKmmNlp06aNo9tBREREDSRPKKi3cUJBmbyeVpMsUCYiIqLGT6610ddzQkBDUx6NRURERI1fcen1mp36kIMdOUOkFgx2iIiIVELO7OjqmdmRg6Ric6nd2tQYMNghIiJSieLShtXsKJmdUmZ2kJOTgw8++AAJCQnIzs4GABw/fpwTCRIREbmQPIpKp2lYgXKxymp2bF4b69SpUxg2bBj8/f1x4cIFTJ06FYGBgdi0aRPS09Px0UcfOaKdREREdBOV59mpD2UGZZUFOzY/jXnz5iEuLg7nzp2Dp6ensn3UqFE4cOCAXRtHREREdVfUwGBHnmfH1NQLlI8ePYrp06dX2d6yZUtkZmbapVFERERkO2WenfoOPdfKo7GaeGbHYDDAaDRW2X727FkEBwfbpVFERERkO3tldpp8sDN27FgsWbIEJSUlAMrXwUpPT8czzzyDCRMm2L2BREREVDemiiDFUO+anYoC5aY+GuuNN95Afn4+QkJCUFRUhEGDBqF9+/bw9fXFSy+95Ig2EhERUR00eFJBlWZ2bB6N5e/vj127duHgwYM4deoU8vPz0atXLwwbNswR7SMiIqI6kicV9GzgaCyTyjI7Ngc7sgEDBmDAgAH2bAsRERE1gFygXN8ZlK8vF9EEMztvv/12nU84e/bsejeGiIiI6k8uUPbUaev1eTnYaZKZnWXLllm9v3LlCgoLCxEQEACgfEZlb29vhISEMNghIiJykQZPKlgxg7Lagp06PY20tDTl9dJLL6FHjx44c+YMsrOzkZ2djTNnzqBXr1544YUXbLr4gQMHMGbMGERERECSJGzevNlqvxACCxYsQHh4OLy8vDBs2DCcO3fO6pjs7Gw88sgj8PPzQ0BAAKZMmYL8/Hyb2kFERKQGxXbK7JibYrBT2fPPP48VK1YgOjpa2RYdHY1ly5bhueees+lcBQUF6N69O1auXFnt/ldffRVvv/02Vq9ejSNHjqBZs2YYMWIEiouLlWMeeeQR/PTTT9i1axe2bt2KAwcOYNq0abbeFhERkduTa3bqPfRcpcGOzQXKGRkZKC2tuvR7WVkZsrKybDpXbGwsYmNjq90nhMDy5cvx3HPP4b777gMAfPTRRwgNDcXmzZsxceJEnDlzBjt27MDRo0fRp08fAMCKFSswatQovP7664iIiLDx7oiIiNyXXLNjaHDNThmEEJAkyW5tcyWbQ7+hQ4di+vTpOH78uLLthx9+wIwZM+w6/DwtLQ2ZmZlW5/T390dMTAySkpIAAElJSQgICFACHQAYNmwYNBoNjhw5UuO5TSYTjEaj1YuIiMjdKd1Y9Z1np6JmxyLUVbdj89NYu3YtwsLC0KdPHxgMBhgMBvTt2xehoaH44IMP7NYweZ2t0NBQq+2hoaHKvszMTISEhFjt9/DwQGBgYK3rdCUmJsLf3195RUZG2q3dRERErmCxCCVAaWg3FgAUmqv24rgrm7uxgoODsW3bNpw9exY///wzAKBTp07o2LGj3RvnKAkJCZg3b57y3mg0MuAhIiK3VjkTU99uLJ1WggRAACg0lyGwmX3a5mr1nlSwY8eODg1wwsLCAABZWVkIDw9XtmdlZaFHjx7KMZcvX7b6XGlpKbKzs5XPV0fOSBEREalFUaWJAOub2ZEkCXoPDUylFlVNLGhzsPP444/Xun/t2rX1bkxlUVFRCAsLw+7du5Xgxmg04siRI5gxYwYAoH///sjJycEPP/yA3r17AwD27NkDi8WCmJgYu7SDiIjIHcjBiYdGqvcMygCUYKfA3ISDnT/++MPqfUlJCU6fPo2cnBwMGTLEpnPl5+fj/Pnzyvu0tDQkJycjMDAQrVu3xpw5c/Diiy+iQ4cOiIqKwvPPP4+IiAiMGzcOAHDrrbdi5MiRmDp1KlavXo2SkhLMnDkTEydO5EgsIiJqUooqTSjYkDFUBg8N8nB9nS01sDnY+fLLL6tss1gsmDFjBtq1a2fTuY4dO4a7775beS/X0UyaNAnr16/H/PnzUVBQgGnTpiEnJwcDBgzAjh074OnpqXzm448/xsyZMzF06FBoNBpMmDDBpuUtiIiI1EDO7Oi0mgYNGZcXAy1qygXK1dFoNJg3bx4GDx6M+fPn1/lzgwcPhhCixv2SJGHJkiVYsmRJjccEBgZiw4YNNrWXiIhIbSovFaFpQGpHLm4uKmnCQ89rkpqaWu1kg0REROR411c8lxqW2VHhyuc2Z3YqD9kGymc6zsjIwNdff41JkybZrWFERERUd3KNjb4BxcnA9QkJm3TNzokTJ6zeazQaBAcH44033rjpSC0iIiJyjOLShq14LpM/X9SUMzt79+51RDuIiIioAeyV2dF7yDU76gl2bH4iQ4YMQU5OTpXtRqPR5qHnREREZB/FFTMo6xqY2VEWA23KBcr79u2D2Wyusr24uBjfffedXRpFREREtim2U2bH0JS7sU6dOqX8/N///tdqoc2ysjLs2LEDLVu2tG/riIiIqE6Uoed2Cnaa5GisHj16QJLKh7NV113l5eWFFStW2LVxREREVDdFlSYVbAi5ZsdU2gSDnbS0NAghcMstt+D7779HcHCwsk+v1yMkJARabf1WWSUiIqKGqbxcREMoo7HM6qnZqXOw06ZNGwDlS0MQERFR4yJ3O9V3xXOZUqDc1DI7W7ZsQWxsLHQ6HbZs2VLrsWPHjrVLw4iIiKju5KHnBh0LlG9Up2Bn3LhxyMzMREhIiLLieHUkSUJZmXoeDhERkbsosndmR0VDz+sU7FTuumI3FhERUeMjL9xp8GhY/axcoFysom4suy0ESkRERK4jz7PT0MyOPHS9yWV23n777TqfcPbs2fVuDBEREdWP3I3lqWtYZkeu+TGVNrFgZ9myZXU6mSRJDHaIiIhcoNBcCsAONTvaJjoaKy0tzdHtICIiogYolmt2mNmpokHhnxACQgh7tYWIiIjqSR567tXAoef6igmCzU092FmzZg26dOkCT09PeHp6okuXLvjggw/s3TYiIiKqo+tDz+2X2VFLQqPOMyjLFixYgDfffBOzZs1C//79AQBJSUmYO3cu0tPTsWTJErs3koiIiGomhKhUoGyf0VhlFgFzqaXB3WKNgc3BzqpVq/CPf/wDDz/8sLJt7Nix6NatG2bNmsVgh4iIyMkq19d4etj81W6l8tpahSVlqgh2bA7/SkpK0KdPnyrbe/fujdLSUrs0ioiIiOpOrtcBGr5cROVgp8isju91m5/Io48+ilWrVlXZ/v777+ORRx6xS6OIiIio7uQuLA+NBJ22YcGORpKg00oAgEKzOoaf1yvXtWbNGnzzzTfo168fAODIkSNIT0/HY489hnnz5inHvfnmm/ZpJREREdVIDnb0HhpIUsPPZ/DQoqSsVDWLgdoc7Jw+fRq9evUCAKSmpgIAWrRogRYtWuD06dPKcZI9njYRERHdlNyNpddqoLHD96/eQwOYgCKzOoaf2xzs7N271xHtICIionoqtntmp7wrrLCp1uwQERFR42LVjWWH88nBTnFTzewUFxdjxYoV2Lt3Ly5fvgyLxfpBHD9+3G6NIyIiopuTC4nLMzt26sYCUFiijsyOzcHOlClT8M033+CBBx5A3759WZtDRETkYko3VgNHYsk8K2ZhLm6qBcpbt27Ftm3bcOeddzqiPURERGSjokqZHXuQz1NUoo5uLJufSsuWLeHr6+uIthAREVE9FNk5s6NXanbU0Y1l81N544038Mwzz+DXX391RHuqaNu2LSRJqvKKj48HAAwePLjKvieffNIpbSMiImoMKhco24NSoKySlc9t7sbq06cPiouLccstt8Db2xs6nc5qf3Z2tt0aBwBHjx5FWdn1PsPTp0/jnnvuwYMPPqhsmzp1qtWaXN7e3nZtAxERUWNWbPdurPKanaKmOoPyww8/jN9//x0vv/wyQkNDHV6gHBwcbPV+6dKlaNeuHQYNGqRs8/b2RlhYmEPbQURE1FjZuxvremaniQY7hw4dQlJSErp37+6I9tTKbDbjn//8J+bNm2cVZH388cf45z//ibCwMIwZMwbPP/98rdkdk8kEk8mkvDcajQ5tNxERkSM5qhvLpJICZZuDnU6dOqGoqMgRbbmpzZs3IycnB3Fxccq2P//5z2jTpg0iIiJw6tQpPPPMM0hJScGmTZtqPE9iYiIWL17shBYTERE5nrysg8HOwU6TXRtr6dKleOqpp/DSSy+ha9euVWp2/Pz87Na4G61ZswaxsbGIiIhQtk2bNk35uWvXrggPD8fQoUORmpqKdu3aVXuehIQEqwVLjUYjIiMjHdZuIiIiR5LnwzFU1No0lDIaq6kGOyNHjgQADB061Gq7EAKSJFkVE9vTr7/+im+//bbWjA0AxMTEAADOnz9fY7BjMBhgMBjs3kYiIiJXKFKCHTsXKDfVYMdVC4GuW7cOISEhGD16dK3HJScnAwDCw8Od0CoiIiLXk0dNeepYs1Mdm4OdyqOgbnT69OkGNaYmFosF69atw6RJk+Dhcb3Jqamp2LBhA0aNGoWgoCCcOnUKc+fOxcCBA9GtWzeHtIWIiKixKbRzN5ZBZd1YDQ4B8/Ly8P7776Nv374OG6H17bffIj09HY8//rjVdr1ej2+//RbDhw9Hp06d8NRTT2HChAn497//7ZB2EBERNUbyPDsGe2d2muqkgrIDBw5gzZo1+OKLLxAREYHx48dj5cqV9mybYvjw4RBCVNkeGRmJ/fv3O+SaRERE7kKurfG0W4Fy+XmaZLCTmZmJ9evXY82aNTAajXjooYdgMpmwefNmdO7c2VFtJCIioloowY6dMjt6JbPTxLqxxowZg+joaJw6dQrLly/HpUuXsGLFCke2jYiIiOpALlC2d82OqdRSbc+Ku6lzZmf79u2YPXs2ZsyYgQ4dOjiyTURERFRHQggUVqxO7qW3T7Ajd4eZSiwoswh4aB27NJSj1Tmzc/DgQeTl5aF3796IiYnBO++8g6tXrzqybURERHQTplILLBXJFy+dnYId3fVurDKL+2d26hzs9OvXD//4xz+QkZGB6dOn45NPPkFERAQsFgt27dqFvLw8R7aTiIiIqlFYaWVyTzsFO3KGyCLUMfzc5kqmZs2a4fHHH8fBgwfx448/4qmnnsLSpUsREhKCsWPHOqKNREREVIMCU3kXlk4rQWe3Vc+vB00FpiYY7FQWHR2NV199FRcvXsS//vUve7WJiIiI6qio0oSCGjuV1mg1EvQVgVNBRT2QO7NLCKjVajFu3Dhs2bLFHqcjIiKiOpIzO546DSTJfoXEct1OvonBDhEREbmQXLOj12rsltkBAENF/U9+MYMdIiIicqFCZakIrV0zO/LIrsoF0O6KwQ4REZEbk+fYkScCtBc52GHNDhEREbmUPFrK3sGOvKhokx+NRURERK51PbNjnzl2ZMzsEBERUaNwvWbHvl/pnkrNDoMdIiIicqECB9XseLJAmYiIiBqDQpN9VzyXeVYET4Ws2SEiIiJXkjMvnvbuxqpYH6uohN1YRERE5EJyTY2ngwqU2Y1FRERELlXgqAJlD3noOTM7RERE5EJFFZkdORNjL3KBclGJxa7ndQUGO0RERG5MnvTPS++gYIfdWERERORKjqrZuZ7ZYbBDRERELiTX7Ng/s1MeIjCzQ0RERC4lByPeOg+7nleuASouZbBDRERELiKEUGZQ9tQ7ZgZlU0kZLBZh13M7G4MdIiIiN1VcYoGoiEMcNRqruMSCUot7j8hisENEROSmKi/S6Wn3YKc8RBBw/yJlBjtERERuSp7dWO+hgU5r36/0ymtt5Rcz2CEiIiIXqLziuUay77m1Ggn6ilmU800l9j25kzHYISIiclNyZsfgoYEk2TnawfUlI/LdfMkIBjtERERuqtAkBztau2d2gOtz98jXcVeNOthZtGgRJEmyenXq1EnZX1xcjPj4eAQFBcHHxwcTJkxAVlaWC1tMRETkPHI3lt5hmZ3yYIeZHQe77bbbkJGRobwOHjyo7Js7dy7+/e9/Y+PGjdi/fz8uXbqE8ePHu7C1REREzlNUqRvLEeQRXgVm9w527DvdogN4eHggLCysyvbc3FysWbMGGzZswJAhQwAA69atw6233orDhw+jX79+zm4qERGRU+VVZFzsPexcJndj5Re7d7DT6DM7586dQ0REBG655RY88sgjSE9PBwD88MMPKCkpwbBhw5RjO3XqhNatWyMpKanWc5pMJhiNRqsXERGRu5GDEHtPKCjzrgh28tiN5TgxMTFYv349duzYgVWrViEtLQ133XUX8vLykJmZCb1ej4CAAKvPhIaGIjMzs9bzJiYmwt/fX3lFRkY68C6IiIgcQx4SLk8AaG9ysOPuNTuNuhsrNjZW+blbt26IiYlBmzZt8Nlnn8HLy6ve501ISMC8efOU90ajkQEPERG5HTmz46huLG+9h9V13FWjzuzcKCAgAB07dsT58+cRFhYGs9mMnJwcq2OysrKqrfGpzGAwwM/Pz+pFRETkbuTuJTkDY29yzU6Bm2d23CrYyc/PR2pqKsLDw9G7d2/odDrs3r1b2Z+SkoL09HT079/fha0kIiJyDjnj4u2ozI6O3VgO97e//Q1jxoxBmzZtcOnSJSxcuBBarRYPP/ww/P39MWXKFMybNw+BgYHw8/PDrFmz0L9/f47EIiKiJkEOQrwMjvk6V7qxGOw4zsWLF/Hwww/j2rVrCA4OxoABA3D48GEEBwcDAJYtWwaNRoMJEybAZDJhxIgRePfdd13caiIiIueQg5BmDurG8lZJN1ajDnY++eSTWvd7enpi5cqVWLlypZNaRERE1HgoQ88dHeyYuVwEERERuUCektlxTO6Ca2MRERGRS8mZHUcFO3LNTmFJGYQQDrmGMzDYISIickOlZRYUlZRnXJp5OrYbq8hcCov7xjoMdoiIiNxRQaWuJcdldsqDnZIyoSw66o4Y7BAREbmhvIqlIjw0EvQOWvW88ppb8vXcEYMdIiIiN6TMsaPXQiNJDrmGh1ajBFLGIgY7RERE5ESV18VyVLADXJ9F2ejG62Mx2CEiInJD8rBzTw8NtBoHBjsVdTt5zOwQERGRMzl6QkGZPPycmR0iIiJyKrlmx9NBi4DKlMwOC5SJiIjImZSaHQeNxJJ5Kd1YzOwQERGRE+VW1NB4O2jFc1kzg9yNxcwOEREROZES7Di4G8tHDnaY2SEiIiJnkoOdZp6OzezIwU4uR2MRERGRM8nBh4+DloqQ+bAbi4iIiFxBDj58HFyz41OROcpjsENERETOpGR2HNyNJS8ymsd5doiIiMiZlGDHSZkdeV4fd8Rgh4iIyM0IIZSFOf08dQ69lhxM5ZtKIYRw6LUchcEOERGRmykqKUNJWXng4euk0ViFpjKYSy0OvZajMNghIiJyM/KcNxrp+nIOjiIHOwLuOyKLwQ4REZGbUSYU1HvAQ+vYr3K9hwZ6bfmq6jmFDHaIiIjICZQJBfVaaCTJ4deTl4zILjQ7/FqOwGCHiIjIzcjBjpdeC63GecFOLjM7RERE5AyVu7Gcwbci2PmDmR0iIiJyhuvBjmOLk2XN3Hx9LAY7REREbsbo5GBHnliQwQ4RERE5hdyd1MzBsyfL5IkLORqLiIiInOJaQXmw4+/l2NmTZX4V18kuYM0OEREROUF2fnnQ4eekYMffk8EOEREROZEcdAQ4eF0smb9XeXcZu7EcIDExEbfffjt8fX0REhKCcePGISUlxeqYwYMHQ5Ikq9eTTz7pohYTERE5ntKN5e3cbqzcImZ27G7//v2Ij4/H4cOHsWvXLpSUlGD48OEoKCiwOm7q1KnIyMhQXq+++qqLWkxERORYFotQCpQDvPROuaa/Euy458rnzinjrqcdO3ZYvV+/fj1CQkLwww8/YODAgcp2b29vhIWFObt5RERETmcsLkGZpTzgCHBSZkcOdopKylBgLoWPwTnXtZdGndm5UW5uLgAgMDDQavvHH3+MFi1aoEuXLkhISEBhYWGt5zGZTDAajVYvIiIidyB3YXnptPDUOW9SQXlViqt57teV1agzO5VZLBbMmTMHd955J7p06aJs//Of/4w2bdogIiICp06dwjPPPIOUlBRs2rSpxnMlJiZi8eLFzmg2ERGRXcnFyT6eHk5ZFwsANJIEP08dcopKcCWvGG1bNHPKde3FbYKd+Ph4nD59GgcPHrTaPm3aNOXnrl27Ijw8HEOHDkVqairatWtX7bkSEhIwb9485b3RaERkZKRjGk5ERGRH1yqGnftUyrY4g79XebBzNZ+ZHYeYOXMmtm7digMHDqBVq1a1HhsTEwMAOH/+fI3BjsFggMFgsHs7iYiIHE3O7Ph6ekCSnBftyHU7DHbsTAiBWbNm4csvv8S+ffsQFRV1088kJycDAMLDwx3cOiIiIufLLjABuL4SubNcn0XZ5NTr2kOjDnbi4+OxYcMGfPXVV/D19UVmZiYAwN/fH15eXkhNTcWGDRswatQoBAUF4dSpU5g7dy4GDhyIbt26ubj1RERE9netUs2OM8mZnWtuOItyow52Vq1aBaB84sDK1q1bh7i4OOj1enz77bdYvnw5CgoKEBkZiQkTJuC5555zQWuJiIgc70peeWbFWetiyeRh7lfzmNmxq5tNXBQZGYn9+/c7qTVERESul2UsBgAENXNu7WlQs/IJDC+7YbDjVvPsEBERNXVZxvJgI7CZc2ZPlgVWBFdX8xnsEBERkYMIIZBZkdkJ9nVusCNndq7lm91uyQgGO0RERG4ip7AE5lILAOd3Y8mZpDxTKQpMpU69dkMx2CEiInITWXnlWR0fgwe89c4tu/X19IBOWz6vT0ZusVOv3VAMdoiIiNxEZkWQEeCtc9pSETJJkpTszu85RU69dkMx2CEiInITl43Xh507O9gBrnedMbNDREREDiEXJ8tz3jhbkE95ZieTwQ4RERE5ghLseDl3JJYs0Lv8uvJcP+6CwQ4REZGbyKiolQly8hw7shY+5d1Yl3JZs0NEREQO8Gt2IQAgzN/TJdcPrbjupT8Y7BAREZGdlVkELmaXBxnhLgp2wv3Kr5uRW+xWEwsy2CEiInIDmcZimMss0EoSwvy8XNIGOaNUYC5TFiR1Bwx2iIiI3ED6tfIurCAfPTx1rvn69tRplZFgqVcLXNKG+mCwQ0RE5AbSs8uDixY+BnhoXff1LXehXWCwQ0RERPb0a0Vmx9kLgN4ovKILTW6PO2CwQ0RE5AbkkVghvq4pTpbJdTvp15jZISIiIjtKvZwPAIgIcE1xsqxlxfV/YTcWERER2UtJmQW/XCkPLtoGebu0LW1bNAMApF0tQFmZxaVtqSsGO0RERI3chasFMJdZ4OmhaRSZHZ1WgqnUgvNX8l3alrrycHUDiMg5hBAoLS1FWVmZq5tCTqDVauHh4QFJcv7K2GR/P2fmASjvwvLUaV3aFq1GQutAb6ReKcCPv+ciOszPpe2pCwY7RE2A2WxGRkYGCgvdZ/QENZy3tzfCw8Oh17t29A413E+XjADKgx1NIwhgb2nhg9QrBfjvJSPQ29WtuTkGO0QqZ7FYkJaWBq1Wi4iICOj1ev7XvsoJIWA2m3HlyhWkpaWhQ4cO0GhYteDOTqT/AQC4JbiZi1tSTq7bkTNOjR2DHSKVM5vNsFgsiIyMhLe3awsbyXm8vLyg0+nw66+/wmw2w9PTtcOVqf7KLAI//p4LAOgU5uvi1pTrEOIDADj9ey4sFgGNpnH/BxRDfaImgv9l3/Twd64OZzKMKDSXwdNDg1ta+Li6OQCA9iE+MHhoYCwuVQKxxoz/TyAiImrE/nP+KoDyAMNb79riZJlOq8Gt4eWFyd+du+Li1twcgx0iIqJG7GBFsHNrhF+jqrfr1sofAHD4l2wXt+TmGOwQUZMUFxeHcePG2eVcQggsWLAA4eHh8PLywrBhw3Du3Dm7nJuattyiEhypCCZ6RTZ3cWus9WgVAAA49ms2isylrm3MTTDYIaImpaysDBaLfWd9ffXVV/H2229j9erVOHLkCJo1a4YRI0aguLi4zucwm812bROpw67/ZsFcZkFEgCc6hjaO4mRZ+xAfBPsYUFxiwfbTma5uTq0Y7BBRozV48GDMnDkTM2fOhL+/P1q0aIHnn38eQgjlmD/++AOPPfYYmjdvDm9vb8TGxlplVdavX4+AgABs2bIFnTt3hsFgwOOPP44PP/wQX331FSRJgiRJ2LdvX7VtKCgowGOPPQYfHx+Eh4fjjTfewODBgzFnzhwA5Vmd5cuX47nnnsN9992Hbt264aOPPsKlS5ewefPmGu9t0aJF6NGjBz744ANERUUpo6VycnLwxBNPIDg4GH5+fhgyZAhOnjypfO7kyZO4++674evrCz8/P/Tu3RvHjh2r/0OmRu2zo78BAHq3bg69R+P6ypYkCQM7tgAAfHbsNxe3pnYcek7UBAkhUFTimpmUvXRam+oOPvzwQ0yZMgXff/89jh07hmnTpqF169aYOnUqgPLuqHPnzmHLli3w8/PDM888g1GjRuG///0vdDodAKCwsBCvvPIKPvjgAwQFBSE8PBxFRUUwGo1Yt24dACAwMLDa6z/99NPYv38/vvrqK4SEhODvf/87jh8/jh49egAA0tLSkJmZiWHDhimf8ff3R0xMDJKSkjBx4kQA5YFb27ZtsX79euW48+fP44svvsCmTZug1ZYXnj744IPw8vLC9u3b4e/vj/feew9Dhw7F2bNnERgYiEceeQQ9e/bEqlWroNVqkZycrNwnqcupizn4/kI2tJKEYbeGuro51RreOQybjv+Ow79k40xGLm4N93d1k6rFYIeoCSoqKUPnBTtdcu3/LhkBb33d//RERkZi2bJlkCQJ0dHR+PHHH7Fs2TJMnTpVCXL+85//4I477gAAfPzxx4iMjMTmzZvx4IMPAgBKSkrw7rvvonv37sp5vby8YDKZEBYWVuO18/PzsWbNGvzzn//E0KFDAZQHX61atVKOycwsT9+Hhlp/GYWGhir7AKB169YIDw+3OsZsNuOjjz5CcHAwAODgwYP4/vvvcfnyZRgMBgDA66+/js2bN+Pzzz/HtGnTkJ6ejqeffhqdOnUCAHTo0KHOz5LchxACidt+BgD0adscbYIax2SCN4oI8ELfqEAcScvGi1+fwT+nxDSqImpZ48qJNcDKlSvRtm1beHp6IiYmBt9//72rm0REdtCvXz+rP579+/fHuXPnUFZWhjNnzsDDwwMxMTHK/qCgIERHR+PMmTPKNr1ej27dutl87dTUVJjNZqvzBwYGIjo62uZzffTRR0hMTLTa1qZNGyXQAcq7qPLz8xEUFAQfHx/llZaWhtTUVADAvHnz8MQTT2DYsGFYunSpsp3UZc3BNCT9cg06rYQHe0dC24gn7Zt0R1toJQn/OX8Naw6mubo51VJFZufTTz/FvHnzsHr1asTExGD58uUYMWIEUlJSEBIS4urmETU6Xjot/rtkhMuu7fRrenk57L825cxQVlaWVeYmKytL6eqqSbNm1v+1np+fj/Dw8GrrhwICAgCU1/r8+c9/xtdff43t27dj4cKF+OSTT3D//fc36D6ocSgts2DVvlS8sessAGB8r5boENo4JhKsSWRzb0y6oy3W/icNL287g1KLwBMDouChbTz5FFUEO2+++SamTp2KyZMnAwBWr16Nr7/+GmvXrsX//u//urh1RI2PJEk2dSW50pEjR6zeHz58GB06dIBWq8Wtt96K0tJSHDlyROnGunbtGlJSUtC5c+daz6vX62+6Any7du2g0+lw5MgRtG7dGkB5QfTZs2cxaNAgAEBUVBTCwsKwe/duJbgxGo04cuQIZsyYYdO99urVC5mZmfDw8EDbtm1rPK5jx47o2LEj5s6di4cffhjr1q1jsOOmMnKLsD/lCgK8dTjxWw6+PpWBi38UAQCGdArBg70iG8XCnzczrkcELv5RiG/+m4Wl23/GhiPpuLdbOLq1CkCbIG/4e+kQ7GuAzkUBkHv8tauF2WzGDz/8gISEBGWbRqPBsGHDkJSUVO1nTCYTTCaT8t5oNDq0jaaSMhSYGvccBE2dudS+Q5HJftLT0zFv3jxMnz4dx48fx4oVK/DGG28AKK9Xue+++zB16lS899578PX1xf/+7/+iZcuWuO+++2o9b9u2bbFz506kpKQgKCgI/v7+VQp9fXx8MGXKFDz99NMICgpCSEgInn32WatlGCRJwpw5c/Diiy+iQ4cOiIqKwvPPP4+IiAireXwee+wxtGzZskpXVmXDhg1D//79MW7cOLz66qvo2LEjLl26hK+//hr3338/brvtNjz99NN44IEHEBUVhYsXL+Lo0aOYMGFCPZ4sudruM1mY8mHVkXS+nh4Y2z0CIzqHotQiUOom3x+T72iLcH9PbPzhItKzC/HuPusu1h1/vQudKmZddja3D3auXr2KsrKyaosDf/7552o/k5iYiMWLFzu8bV46LTw9NPDSa1Fq53k9yL40GgkGDw30Ho1jKna67rHHHkNRURH69u0LrVaLv/71r5g2bZqyf926dfjrX/+Ke++9F2azGQMHDsS2bdtuOkJp6tSp2LdvH/r06YP8/Hzs3bsXgwcPrnLca6+9hvz8fIwZMwa+vr546qmnkJtrvRbQ/PnzUVBQgGnTpiEnJwcDBgzAjh07rBbfTE9Pv+laVZIkYdu2bXj22WcxefJkXLlyBWFhYRg4cCBCQ0Oh1Wpx7do1PPbYY8jKykKLFi0wfvx4p/w9I/vrGxWIW8N9kWU0oYWPHhH+Xrg13Bd92jaHoeJvkbt9d9zTORR3tm+B5N/+wKmLRmTkFuFKngmF5jKXZXUAQBKVJ6xwQ5cuXULLli1x6NAh9O/fX9k+f/587N+/v0oKHKg+sxMZGYnc3Fz4+dk36rRYBMrc+xE3KR4aqVGOJGiI4uJipKWlWc3l4i4GDx6MHj16YPny5a5uipXG2q4bufPvvikxlZZ3p7pDd1V9WIQABKD30Nj976vRaIS/v/9Nv7/dPrPTokULaLVaZGVlWW3PysqqcUipwWBQhnU6mkYjQQN1/gMmIqKGMzCj7HCNp1S6nvR6PXr37o3du3cr2ywWC3bv3m2V6SEiIqKmye0zO0D5vBOTJk1Cnz590LdvXyxfvhwFBQXK6Cwick81LeHgao21XURUPVUEO3/6059w5coVLFiwAJmZmejRowd27NhRpWiZiIiImh5VBDsAlMUCiYiIiCpz+5odIqobNx94SfXA3zlROQY7RCpXeeVvalrk3zlXRaemTjXdWERUPa1Wi4CAAFy+fBkA4O3trbq5hMiaEAKFhYW4fPkyAgICoNVyaDM1bQx2iJoAec4pOeChpiEgIKDG+caImhIGO0RNgCRJCA8PR0hICEpKSlzdHHICnU7HjA5RBQY7RE2IVqvlFyARNTksUCYiIiJVY7BDREREqsZgh4iIiFSNNTu4PvGW0Wh0cUuIiIioruTv7ZtNoMlgB0BeXh4AIDIy0sUtISIiIlvl5eXB39+/xv2S4HzisFgsuHTpEnx9fe062ZrRaERkZCR+++03+Pn52e28asHnUzM+m9rx+dSMz6Z2fD61c7fnI4RAXl4eIiIioNHUXJnDzA4AjUaDVq1aOez8fn5+bvGPxlX4fGrGZ1M7Pp+a8dnUjs+ndu70fGrL6MhYoExERESqxmCHiIiIVI3BjgMZDAYsXLgQBoPB1U1plPh8asZnUzs+n5rx2dSOz6d2an0+LFAmIiIiVWNmh4iIiFSNwQ4RERGpGoMdIiIiUjUGO0RERKRqDHZslJiYiNtvvx2+vr4ICQnBuHHjkJKSYnVMcXEx4uPjERQUBB8fH0yYMAFZWVlWx6Snp2P06NHw9vZGSEgInn76aZSWljrzVurNVc/gwoULmDJlCqKiouDl5YV27dph4cKFMJvNDrnP+moM/0ZMJhN69OgBSZKQnJxsr1trMFc/m6+//hoxMTHw8vJC8+bNMW7cOHveXoO58vmcPXsW9913H1q0aAE/Pz8MGDAAe/futfs9OoK9ntvs2bPRu3dvGAwG9OjRw4l30HCuegbZ2dmYNWsWoqOj4eXlhdatW2P27NnIzc215+01nCCbjBgxQqxbt06cPn1aJCcni1GjRonWrVuL/Px85Zgnn3xSREZGit27d4tjx46Jfv36iTvuuEPZX1paKrp06SKGDRsmTpw4IbZt2yZatGghEhISXHFLNnPVM9i+fbuIi4sTO3fuFKmpqeKrr74SISEh4qmnnnLo/dqqMfwbmT17toiNjRUAxIkTJ+x9i/Xmymfz+eefi+bNm4tVq1aJlJQU8dNPP4lPP/3UYfdaH658Ph06dBCjRo0SJ0+eFGfPnhX/8z//I7y9vUVGRobD7tde7PHchBBi1qxZ4p133hGPPvqo6N69u5PvomFc9Qx+/PFHMX78eLFlyxZx/vx5sXv3btGhQwcxYcIEe99igzDYaaDLly8LAGL//v1CCCFycnKETqcTGzduVI45c+aMACCSkpKEEEJs27ZNaDQakZmZqRyzatUq4efnJ0wmk3NvwA5c+QxeffVVERUVZac7cQxnP59t27aJTp06iZ9++qnRBTs3ctazKSkpES1bthQffPCBA+/G/pz1fK5cuSIAiAMHDijbjEajACB27drliFtzqPo8t8oWLlzodsHOjVz5DD777DOh1+tFSUlJvT7vCOzGaiA5VRcYGAgA+OGHH1BSUoJhw4Ypx3Tq1AmtW7dGUlISACApKQldu3ZFaGiocsyIESNgNBrx008/ObH19uHKZ5Cbm6tct7Fy5vPJysrC1KlT8X//93/w9vZ2xO3YlbOezfHjx/H7779Do9GgZ8+eCA8PR2xsLE6fPu2oW7MLZz2foKAgREdH46OPPkJBQQFKS0vx3nvvISQkBL1793bU7TlMfZ6b2rjyGeTm5sLPzw8eHo1n+U0GOw1gsVgwZ84c3HnnnejSpQsAIDMzE3q9HgEBAVbHhoaGIjMzUzmm8h8ieb+8z5248hmcP38eK1aswPTp0xt4F47jzOcjhEBcXByefPJJ9OnTx853Yn/OfDa//PILAGDRokV47rnnsHXrVjRv3hyDBw9Gdna2PW/Lbpz5fCRJwrfffosTJ07A19cXnp6eePPNN7Fjxw40b97cznfmWPV9bmriymdw9epVvPDCC5g2bZrdzmkPjSfsckPx8fE4ffo0Dh486OqmuIyrnsHvv/+OkSNH4sEHH8TUqVOdem1bOPP5rFixAnl5eUhISHD4tezBmc/GYrEAAJ599llMmDABALBu3Tq0atUKGzdubJQBszOfjxAC8fHxCAkJwXfffQcvLy988MEHGDNmDI4ePYrw8HCHt8Fe+HfZdc/AaDRi9OjR6Ny5MxYtWuTUa98MMzv1NHPmTGzduhV79+5Fq1atlO1hYWEwm83IycmxOj4rKwthYWHKMTdWwMvv5WPcgauewaVLl3D33XfjjjvuwPvvv2+HO3EMZz+fPXv2ICkpCQaDAR4eHmjfvj0AoE+fPpg0aZK9bssunP1s5C/rzp07K9sMBgNuueUWpKenN/h+7M0V/3a2bt2KTz75BHfeeSd69eqFd999F15eXvjwww/teGeO1ZDnphauegZ5eXkYOXIkfH198eWXX0Kn0zX4nHbl6qIhd2OxWER8fLyIiIgQZ8+erbJfLgL7/PPPlW0///xztQWEWVlZyjHvvfee8PPzE8XFxY6/iQZy5TO4ePGi6NChg5g4caIoLS21413Zj6uez6+//ip+/PFH5bVz504BQHz++efit99+s/Nd1o+rnk1ubq4wGAxWBcpms1mEhISI9957z16312Cuej5btmwRGo1G5OXlWW3v2LGjeOmll+xxaw5lj+dWmTsWKLvyGeTm5op+/fqJQYMGiYKCgnrfgyMx2LHRjBkzhL+/v9i3b5/IyMhQXoWFhcoxTz75pGjdurXYs2ePOHbsmOjfv7/o37+/sl8eGjp8+HCRnJwsduzYIYKDg91m6LmznsGRI0dEdHS0uHjxohCiPNBp3769GDp0qLh48aLVtRsTVz2fG6WlpTW60ViufDZ//etfRcuWLcXOnTvFzz//LKZMmSJCQkJEdna2c26+Dlz1fK5cuSKCgoLE+PHjRXJyskhJSRF/+9vfhE6nE8nJyc57APVkj+cmhBDnzp0TJ06cENOnTxcdO3YUJ06cECdOnHCLUbLOegYXL14U0dHR4siRI0KI8kAnJiZGdO3aVZw/f97q2o3pP0gZ7NgIQLWvdevWKccUFRWJ//mf/xHNmzcX3t7e4v7776/yhXzhwgURGxsrvLy8RIsWLcRTTz3VqIbp1cZZz2Dv3r0CgEhLSxNCCLFu3boar92YuOr53KgxBjuufDZms1k89dRTIiQkRPj6+ophw4aJ06dPO/qWbeLK53P06FExfPhwERgYKHx9fUW/fv3Etm3bHH3LdmGv5zZo0KBqz1PT/8caE2c9A/nvyt69e4UQ1/8tNfbnJgkhRD16v4iIiIjcAguUiYiISNUY7BAREZGqMdghIiIiVWOwQ0RERKrGYIeIiIhUjcEOERERqRqDHSIiIlI1BjtE5HJxcXEYN26c06+7fv16SJIESZIwZ84cu523bdu2ynlvXIuIiJyPq54TkUNJklTr/oULF+Ktt96Cq+Y39fPzQ0pKCpo1a2a3cx49ehTfffedssI6EbkWgx0icqiMjAzl508//RQLFixASkqKss3Hxwc+Pj6uaBqA8mDM3itfBwcHIzAw0K7nJKL6YzcWETlUWFiY8vL391eCC/nl4+NTpRtr8ODBmDVrFubMmYPmzZsjNDQU//jHP1BQUIDJkyfD19cX7du3x/bt262udfr0acTGxsLHxwehoaF49NFHcfXqVZvbLEkSNm/ebLUtICAA69evBwCYzWbMnDkT4eHh8PT0RJs2bZCYmGjzdYjIORjsEFGj9OGHH6JFixb4/vvvMWvWLMyYMQMPPvgg7rjjDhw/fhzDhw/Ho48+isLCQgBATk4OhgwZgp49e+LYsWPYsWMHsrKy8NBDD9m9bW+//Ta2bNmCzz77DCkpKfj444/Rtm1bu1+HiOyD3VhE1Ch1794dzz33HAAgISEBS5cuRYsWLTB16lQAwIIFC7Bq1SqcOnUK/fr1wzvvvIOePXvi5ZdfVs6xdu1aREZG4uzZs+jYsaPd2paeno4OHTpgwIABkCQJbdq0sdu5icj+mNkhokapW7duys9arRZBQUHo2rWrsi00NBQAcPnyZQDAyZMnsXfvXqUGyMfHB506dQIApKam2rVtcXFxSE5ORnR0NGbPno1vvvnGrucnIvtiZoeIGiWdTmf1XpIkq23yKC+LxQIAyM/Px5gxY/DKK69UOVd4eHiD21NWVqb83KtXL6SlpWH79u349ttv8dBDD2HYsGH4/PPPG3wdIrI/BjtEpAq9evXCF198gbZt28LDo+F/2rKyspSfr1y5gvz8fKv9fn5++NOf/oQ//elPeOCBBzBy5EhkZ2dzFBZRI8RuLCJShfj4eGRnZ+Phhx/G0aNHkZqaip07d2Ly5MlWWZm6WrZsGQ4fPowzZ85gxowZAICUlBRcu3YNb775Jv71r3/h559/xtmzZ7Fx40aEhYUhICDAzndFRPbAYIeIVCEiIgL/+c9/UFZWhuHDh6Nr166YM2cOAgICoNHY/qdu5MiRmDhxIvr06YNWrVohPj4eK1euxOnTp+Hr64tXX30Vffr0we23344LFy5g27Zt9boOETmeJFw1bSkRkYutX78ec+bMqbKkgyRJ+PLLLxu0hMW+fftw9913448//mDGh8jF+J8hRNSk5ebmwsfHB88884zdznnbbbchNjbWbucjooZhgTIRNVkTJkzAgAEDAMCu2Zdt27ahpKQEQHkhMxG5FruxiIiISNXYjUVERESqxmCHiIiIVI3BDhEREakagx0iIiJSNQY7REREpGoMdoiIiEjVGOwQERGRqjHYISIiIlVjsENERESq9v+cg7taIM/RQAAAAABJRU5ErkJggg==", "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": "b30bda36", "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", "```{warning}\n", "The helper function `convert_hw_config_to_portclock_configs_spec` has been removed in version 0.18.0.\n", "```" ] }, { "cell_type": "code", "execution_count": 11, "id": "b8fdbf5f", "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": "00305041", "metadata": {}, "outputs": [], "source": [ "correct_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", " \"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", "}" ] }, { "cell_type": "markdown", "id": "d72ae115", "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": 13, "id": "d5db9316", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qcodes import Instrument\n", "\n", "Instrument.close_all()" ] }, { "cell_type": "code", "execution_count": 14, "id": "ee1625c4", "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', 'num_points']\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": "4183b4b6", "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": 15, "id": "6a85ba42", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'clocks': {'basic.01': nan, 'basic.12': nan, 'basic.ro': nan},\n", " 'compilation_passes': [{'compilation_func': 'quantify_scheduler.backends.circuit_to_device.compile_circuit_to_device_with_config_validation',\n", " 'name': 'circuit_to_device'},\n", " {'compilation_func': 'quantify_scheduler.backends.circuit_to_device.set_pulse_and_acquisition_clock',\n", " 'name': 'set_pulse_and_acquisition_clock'},\n", " {'compilation_func': 'quantify_scheduler.compilation._determine_absolute_timing',\n", " 'name': 'determine_absolute_timing'}],\n", " 'edges': {},\n", " 'elements': {'basic': {'H': {'factory_func': 'quantify_scheduler.operations.composite_factories.hadamard_as_y90z',\n", " 'factory_kwargs': {'qubit': 'basic'},\n", " 'gate_info_factory_kwargs': None},\n", " '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_transmon',\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': array([], dtype=float64),\n", " 'acq_weights_b': array([], dtype=float64),\n", " 'acq_weights_sampling_rate': None,\n", " 'clock': 'basic.ro',\n", " 'freq': None,\n", " 'num_points': None,\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_channel_override',\n", " 'acq_index',\n", " 'bin_mode',\n", " 'acq_protocol',\n", " 'feedback_trigger_label']},\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": "12838413", "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": 16, "id": "7a696477", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.backends.qblox.operations 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": "10fa6cf1", "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.20" }, "source_map": [ 6, 38, 92, 118, 149, 187, 254, 261, 272, 274, 290, 292, 317, 329, 347, 350, 376, 401, 427, 433, 444, 458, 497, 505, 511, 523 ] }, "nbformat": 4, "nbformat_minor": 5 }