{ "cells": [ { "cell_type": "markdown", "id": "c31eaca8", "metadata": {}, "source": [ "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`Conditional Reset.ipynb`\n", "\n", "```\n", "\n", "(sec-tutorial-conditional-reset)=\n", "\n", "# Tutorial: Conditional Reset\n", "\n", "In this tutorial, we show how to perform a conditional reset using the [conditional control flow framework](sec-control-flow). A conditional reset consists of measuring the state of a qubit, and then:\n", "- sending a pulse to rotate the qubit to the ground state in case the qubit is found to be in an excited state\n", "- not sending any pulse if the qubit is found to be in the ground state\n", "\n", "This conditional reset is potentially much faster than an idle qubit reset (i.e. waiting for a time {math}`\\gg \\tau_1`).\n", "Quantify discriminates between excited and ground state at the `Measure` operation using a [thresholded acquisition](thresholded_acquisition_explanation), and uses a default {math}`\\pi` pulse to set the qubit to its ground state.\n", "In this tutorial, we demonstrate conditional reset using a Qblox cluster that contains a readout module (`QRM_RF`), responsible for the measurement of the qubit, and a control module (`QCM_RF`), responsible for conditionally sending out the {math}`\\pi` pulse.\n", "\n", "To run a conditional reset, we perform the following steps:\n", "\n", "1. Set up the quantum device, dummy hardware, and hardware configuration.\n", "2. Configure thresholded acquisition parameters to separate the {math}`|0\\rangle` and {math}`|1\\rangle` states.\n", "3. Verify that these parameters are set correctly.\n", "4. Run a conditional reset.\n", "\n", "\n", "```{note}\n", "Currently, the conditional reset is only implemented for the Qblox hardware.\n", "```\n", "\n", "(cond_reset_initial_setup)=\n", "\n", "## Initial Setup\n", "\n", "We follow here the same setup as in the {ref}`sec-tutorial-experiment` tutorial.\n", "\n", "First, we define a single transmon qubit as an element ({{ BasicTransmonElement }}) of the {{ QuantumDevice }} and populate the parameters with some reasonable values:\n", "\n", "```{seealso}\n", "If you want to learn more about how to set up the {{ QuantumDevice }} and hardware configuration, please see our other tutorials, in particular {ref}`sec-tutorial-experiment` and {ref}`sec-tutorial-compiling`.\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "id": "e7d5a8d5", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "\"\"\"Disable transparent backgrounds for analysis figures to make them look nicer\n", "in both dark and bright mode on the website.\"\"\"\n", "\n", "from quantify_core.analysis import base_analysis as ba\n", "\n", "ba.settings[\"mpl_transparent_background\"] = False" ] }, { "cell_type": "code", "execution_count": 2, "id": "016a0d68", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "import tempfile\n", "\n", "from quantify_core.data import handling as dh\n", "from quantify_core.measurement.control import MeasurementControl\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "\n", "# Create a temporary directory for this tutorial\n", "temp_dir = tempfile.mkdtemp()\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir(temp_dir)\n", "\n", "# Device parameters\n", "ACQ_DELAY = 100e-9\n", "FREQ_01 = 4e9\n", "READOUT_AMP = 0.1\n", "READOUT_FREQ = 4.3e9\n", "PI_PULSE_AMP = 0.15\n", "LO_FREQ_QUBIT = 3.9e9\n", "LO_FREQ_READOUT = 4.5e9\n", "\n", "single_qubit_device = QuantumDevice(\"single_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "single_qubit_device.add_element(q0)\n", "\n", "# Assign device parameters to transmon element\n", "q0.measure.pulse_amp(READOUT_AMP)\n", "q0.clock_freqs.readout(READOUT_FREQ)\n", "q0.clock_freqs.f01(FREQ_01)\n", "q0.measure.acq_delay(ACQ_DELAY)\n", "q0.rxy.amp180(PI_PULSE_AMP)" ] }, { "cell_type": "markdown", "id": "40c5b7c3", "metadata": {}, "source": [ "Next, we connect to a dummy {{ Cluster }}. If you are connecting to an actual cluster, you would provide the\n", " `identifier` argument (the IP address, device name or serial number) instead\n", " of the `dummy_cfg` argument." ] }, { "cell_type": "code", "execution_count": 3, "id": "316421aa", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)" ] }, { "cell_type": "markdown", "id": "88dd22cb", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "09ef617b", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "hardware_cfg = {\n", " \"version\": \"0.2\",\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " 1: {\"instrument_type\": \"QRM_RF\"},\n", " 2: {\"instrument_type\": \"QCM_RF\"},\n", " },\n", " \"ref\": \"internal\",\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\"lo_freq\": LO_FREQ_READOUT},\n", " \"q0:mw-q0.01\": {\"lo_freq\": LO_FREQ_QUBIT},\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " (f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"),\n", " (f\"{cluster.name}.module1.complex_input_0\", \"q0:res\"),\n", " (f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"),\n", " ]\n", " },\n", "}\n", "\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "99392659", "metadata": {}, "source": [ "(cond_reset_create_schedule)=\n", "\n", "## Readout Calibration\n", "\n", "To discriminate between the ground state and the excited state with {{ ConditionalReset }}, we first need to configure the {{ ThresholdedAcquisition }} parameters `acq_threshold` and `acq_rotation` (see [Tutorial: Acquisitions](thresholded_acquisition_explanation)). We do so by preparing a qubit in either its ground state or its excited state, performing a measurement, and repeating this process 500 times. In the measured IQ plane we expect to find all data points clustered in two distinct groups that correspond to the two different states, and the `acq_threshold` and `acq_rotation` parameters define the line between the two groups. \n", "\n", "We run this calibration using {{ MeasurementControl }} and a predefined {{ Schedule }} called {{ readout_calibration_sched }}:" ] }, { "cell_type": "code", "execution_count": 5, "id": "12201b51", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) + imag * np.sin(angle) > -threshold:\n", " thres = 0\n", " else:\n", " thres = 1\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "# Means and standard deviations\n", "x0, xs0 = -2.7, 2.5\n", "y0, ys0 = 2.9, 2.5\n", "x1, xs1 = -14, 2.5\n", "y1, ys1 = 1.9, 2.5\n", "\n", "# Number of points per data cluster\n", "n_points = 500\n", "\n", "# Generate random samples\n", "x0_samples = np.random.normal(x0, xs0, n_points)\n", "y0_samples = np.random.normal(y0, ys0, n_points)\n", "x1_samples = np.random.normal(x1, xs1, n_points)\n", "y1_samples = np.random.normal(y1, ys1, n_points)\n", "\n", "# interleave the random samples such that we get\n", "# x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", "# y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", "x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", "y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", "states = np.array([0, 1] * 500)\n", "\n", "# prepare cluster with dummy data that will be returned \n", "# after retrieving acquisitions.\n", "cluster.delete_dummy_binned_acquisition_data(1)\n", "cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), 0, 0)\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 6, "id": "e2d59091", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:769: RuntimeWarning: Number of instructions (16012) compiled for 'seq0' of QRMRFCompiler 'cluster_module1' exceeds the maximum supported number of instructions in Q1ASM programs for QRMRFCompiler (12288).\n", " warnings.warn(\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 24kB\n",
       "Dimensions:  (dim_0: 1000)\n",
       "Coordinates:\n",
       "    x0       (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 8kB -0.002381 -0.008006 ... -0.00109 -0.01301\n",
       "    y1       (dim_0) float64 8kB 0.001892 0.005193 ... 0.002183 0.0004188\n",
       "Attributes:\n",
       "    tuid:                             20250723-152148-682-4b0bfb\n",
       "    name:                             Readout Calibration\n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 24kB\n", "Dimensions: (dim_0: 1000)\n", "Coordinates:\n", " x0 (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 8kB -0.002381 -0.008006 ... -0.00109 -0.01301\n", " y1 (dim_0) float64 8kB 0.001892 0.005193 ... 0.002183 0.0004188\n", "Attributes:\n", " tuid: 20250723-152148-682-4b0bfb\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": prepared_states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=200,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "b6848e06", "metadata": {}, "source": [ "```{seealso}\n", "More information on configuring {{ MeasurementControl }} can be found in the\n", "[user guide](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control)\n", "of `quantify-core`, and in the tutorials [Running and Experiment](sec-tutorial-experiment) and [ScheduleGettable](sec-schedulegettable-2dsweep-usage)\n", "```\n", "\n", "To determine the qubit threshold parameters, we use the {{ ReadoutCalibrationAnalysis }}:" ] }, { "cell_type": "code", "execution_count": 7, "id": "ce301dde", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from quantify_core.analysis.readout_calibration_analysis import (\n", " ReadoutCalibrationAnalysis,\n", ")\n", "\n", "analysis = ReadoutCalibrationAnalysis(dataset)\n", "analysis.run()\n", "analysis.display_figs_mpl()" ] }, { "cell_type": "markdown", "id": "ba9cbe1c", "metadata": {}, "source": [ "The image above shows that the measured IQ points are clustered in two groups as expected. We can now fit a line between the two groups and from there obtain the `acq_threshold` and the `acq_rotation` parameters, that we add to the qubit configuration:" ] }, { "cell_type": "code", "execution_count": 8, "id": "4e0430ff", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "fit_results = analysis.fit_results[\"linear_discriminator\"].params\n", "acq_threshold = fit_results[\"acq_threshold\"].value\n", "acq_rotation = (np.rad2deg(fit_results[\"acq_rotation_rad\"].value)) % 360\n", "\n", "q0.measure.acq_threshold(acq_threshold)\n", "q0.measure.acq_rotation(acq_rotation)" ] }, { "cell_type": "markdown", "id": "fc94aabe", "metadata": {}, "source": [ "## Verifying parameters\n", "\n", "We can quickly verify that the qubit parameters are set correctly by running again the {{ readout_calibration_sched }} schedule with `\"ThresholdedAcquisition\"` as acquisition protocol. If the calibration was done correctly, we expect that when the state is prepared in the {math}`|0\\rangle` state or {math}`|1\\rangle` state, the thresholded acquisition will return 0 or 1 respectively. The results are then verified using a confusion matrix:" ] }, { "cell_type": "code", "execution_count": 9, "id": "e66562f7", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(\n", " float(re), float(im), acq_rotation, acq_threshold\n", " )\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 10, "id": "11abfb4e", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:769: RuntimeWarning: Number of instructions (16012) compiled for 'seq0' of QRMRFCompiler 'cluster_module1' exceeds the maximum supported number of instructions in Q1ASM programs for QRMRFCompiler (12288).\n", " warnings.warn(\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfsAAAHHCAYAAAC4M/EEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEAElEQVR4nO3deVxU5f4H8M8My7DOIMoiyqa5QO4bTmouoWToT9NyvYpelxaolDSz3E1JzT1M29y9mWV21XLD0K6iormguItCIaAoDKAsMuf3h3FqRJNhZhhmzuft67wu85znnPM9c7Uv3+c85xyZIAgCiIiIyGrJzR0AERERmRaTPRERkZVjsiciIrJyTPZERERWjsmeiIjIyjHZExERWTkmeyIiIivHZE9ERGTlmOyJiIisHJM90SMuX76MHj16QKVSQSaTYdu2bUbd//Xr1yGTybBmzRqj7teSdenSBV26dDF3GERWi8meqqWrV6/itddeQ7169eDg4AClUokOHTpg6dKluH//vkmPHRERgaSkJMyZMwfr169HmzZtTHq8qjRixAjIZDIolcrHfo+XL1+GTCaDTCbDJ598ovf+09PTMWPGDJw6dcoI0RKRsdiaOwCiR+3cuROvvvoqFAoFhg8fjiZNmqC4uBj/+9//MHHiRJw7dw6ff/65SY59//59JCQk4MMPP0RUVJRJjuHv74/79+/Dzs7OJPt/GltbW9y7dw/bt2/HgAEDdNZt3LgRDg4OKCwsrNS+09PTMXPmTAQEBKBFixYV3m7Pnj2VOh4RVQyTPVUrKSkpGDRoEPz9/bF//37Url1bXBcZGYkrV65g586dJjv+rVu3AABubm4mO4ZMJoODg4PJ9v80CoUCHTp0wH/+859yyX7Tpk0IDw/H999/XyWx3Lt3D05OTrC3t6+S4xFJFYfxqVqZP38+8vPz8dVXX+kk+jLPPPMM3nnnHfHzgwcPMHv2bNSvXx8KhQIBAQH44IMPUFRUpLNdQEAAevXqhf/9739o164dHBwcUK9ePaxbt07sM2PGDPj7+wMAJk6cCJlMhoCAAAAPh7/Lfv67GTNmQCaT6bTt3bsXHTt2hJubG1xcXNCoUSN88MEH4vonXbPfv38/OnXqBGdnZ7i5uaFPnz44f/78Y4935coVjBgxAm5ublCpVBg5ciTu3bv35C/2EUOGDMHPP/+MnJwcsS0xMRGXL1/GkCFDyvW/c+cOJkyYgKZNm8LFxQVKpRI9e/bE6dOnxT7x8fFo27YtAGDkyJHi5YCy8+zSpQuaNGmCEydO4Pnnn4eTk5P4vTx6zT4iIgIODg7lzj8sLAw1atRAenp6hc+ViJjsqZrZvn076tWrh+eee65C/UePHo1p06ahVatWWLx4MTp37oyYmBgMGjSoXN8rV67glVdeQffu3bFw4ULUqFEDI0aMwLlz5wAA/fr1w+LFiwEAgwcPxvr167FkyRK94j937hx69eqFoqIizJo1CwsXLsT//d//4dChQ/+43b59+xAWFoasrCzMmDED0dHROHz4MDp06IDr16+X6z9gwADk5eUhJiYGAwYMwJo1azBz5swKx9mvXz/IZDJs3bpVbNu0aRMaN26MVq1alet/7do1bNu2Db169cKiRYswceJEJCUloXPnzmLiDQoKwqxZswAAY8eOxfr167F+/Xo8//zz4n6ys7PRs2dPtGjRAkuWLEHXrl0fG9/SpUvh4eGBiIgIlJaWAgBWrVqFPXv2YPny5fDx8anwuRIRAIGomsjNzRUACH369KlQ/1OnTgkAhNGjR+u0T5gwQQAg7N+/X2zz9/cXAAgHDx4U27KysgSFQiG8++67YltKSooAQFiwYIHOPiMiIgR/f/9yMUyfPl34+z+jxYsXCwCEW7duPTHusmOsXr1abGvRooXg6ekpZGdni22nT58W5HK5MHz48HLH+/e//62zz5dfflmoWbPmE4/59/NwdnYWBEEQXnnlFeGFF14QBEEQSktLBW9vb2HmzJmP/Q4KCwuF0tLScuehUCiEWbNmiW2JiYnlzq1M586dBQDCypUrH7uuc+fOOm27d+8WAAgfffSRcO3aNcHFxUXo27fvU8+RiMpjZU/VhkajAQC4urpWqP9PP/0EAIiOjtZpf/fddwGg3LX94OBgdOrUSfzs4eGBRo0a4dq1a5WO+VFl1/p//PFHaLXaCm1z8+ZNnDp1CiNGjIC7u7vY3qxZM3Tv3l08z797/fXXdT536tQJ2dnZ4ndYEUOGDEF8fDwyMjKwf/9+ZGRkPHYIH3h4nV8uf/ifi9LSUmRnZ4uXKH777bcKH1OhUGDkyJEV6tujRw+89tprmDVrFvr16wcHBwesWrWqwscior8w2VO1oVQqAQB5eXkV6n/jxg3I5XI888wzOu3e3t5wc3PDjRs3dNr9/PzK7aNGjRq4e/duJSMub+DAgejQoQNGjx4NLy8vDBo0CN9+++0/Jv6yOBs1alRuXVBQEG7fvo2CggKd9kfPpUaNGgCg17m89NJLcHV1xebNm7Fx40a0bdu23HdZRqvVYvHixWjQoAEUCgVq1aoFDw8PnDlzBrm5uRU+Zp06dfSajPfJJ5/A3d0dp06dwrJly+Dp6VnhbYnoL0z2VG0olUr4+Pjg7Nmzem336AS5J7GxsXlsuyAIlT5G2fXkMo6Ojjh48CD27duHYcOG4cyZMxg4cCC6d+9erq8hDDmXMgqFAv369cPatWvxww8/PLGqB4C5c+ciOjoazz//PDZs2IDdu3dj7969ePbZZys8ggE8/H70cfLkSWRlZQEAkpKS9NqWiP7CZE/VSq9evXD16lUkJCQ8ta+/vz+0Wi0uX76s056ZmYmcnBxxZr0x1KhRQ2fmeplHRw8AQC6X44UXXsCiRYuQnJyMOXPmYP/+/fjll18eu++yOC9evFhu3YULF1CrVi04OzsbdgJPMGTIEJw8eRJ5eXmPndRY5rvvvkPXrl3x1VdfYdCgQejRowdCQ0PLfScV/cWrIgoKCjBy5EgEBwdj7NixmD9/PhITE422fyIpYbKnauW9996Ds7MzRo8ejczMzHLrr169iqVLlwJ4OAwNoNyM+UWLFgEAwsPDjRZX/fr1kZubizNnzohtN2/exA8//KDT786dO+W2LXu4zKO3A5apXbs2WrRogbVr1+okz7Nnz2LPnj3ieZpC165dMXv2bHz66afw9vZ+Yj8bG5tyowZbtmzBH3/8odNW9kvJ434x0tekSZOQmpqKtWvXYtGiRQgICEBERMQTv0ciejI+VIeqlfr162PTpk0YOHAggoKCdJ6gd/jwYWzZsgUjRowAADRv3hwRERH4/PPPkZOTg86dO+PYsWNYu3Yt+vbt+8Tbuipj0KBBmDRpEl5++WW8/fbbuHfvHj777DM0bNhQZ4LarFmzcPDgQYSHh8Pf3x9ZWVlYsWIF6tati44dOz5x/wsWLEDPnj2hVqsxatQo3L9/H8uXL4dKpcKMGTOMdh6PksvlmDJlylP79erVC7NmzcLIkSPx3HPPISkpCRs3bkS9evV0+tWvXx9ubm5YuXIlXF1d4ezsjJCQEAQGBuoV1/79+7FixQpMnz5dvBVw9erV6NKlC6ZOnYr58+frtT8iyTPz3QBEj3Xp0iVhzJgxQkBAgGBvby+4uroKHTp0EJYvXy4UFhaK/UpKSoSZM2cKgYGBgp2dneDr6ytMnjxZp48gPLz1Ljw8vNxxHr3l60m33gmCIOzZs0do0qSJYG9vLzRq1EjYsGFDuVvv4uLihD59+gg+Pj6Cvb294OPjIwwePFi4dOlSuWM8envavn37hA4dOgiOjo6CUqkUevfuLSQnJ+v0KTveo7f2rV69WgAgpKSkPPE7FQTdW++e5Em33r377rtC7dq1BUdHR6FDhw5CQkLCY2+Z+/HHH4Xg4GDB1tZW5zw7d+4sPPvss4895t/3o9FoBH9/f6FVq1ZCSUmJTr/x48cLcrlcSEhI+MdzICJdMkHQY0YPERERWRxesyciIrJyTPZERERWjsmeiIjIyjHZExERmUDZWyr/vjRu3FhcX1hYiMjISNSsWRMuLi7o379/uVuOU1NTER4eDicnJ3h6emLixIl48OCB3rHw1jsiIiITefbZZ7Fv3z7xs63tX2l3/Pjx2LlzJ7Zs2QKVSoWoqCj069dPfEtmaWkpwsPD4e3tjcOHD+PmzZsYPnw47OzsMHfuXL3i4Gx8IiIiE5gxYwa2bduGU6dOlVuXm5sLDw8PbNq0Ca+88gqAh0/MDAoKQkJCAtq3b4+ff/4ZvXr1Qnp6Ory8vAAAK1euxKRJk3Dr1i293jNh0ZW9VqtFeno6XF1djfqYTiIiqhqCICAvLw8+Pj7imxVNobCwEMXFxQbvRxCEcvlGoVBAoVA8tv/ly5fh4+MDBwcHqNVqxMTEwM/PDydOnEBJSQlCQ0PFvo0bN4afn5+Y7BMSEtC0aVMx0QNAWFgY3njjDZw7dw4tW7ascNwWnezT09Ph6+tr7jCIiMhAaWlpqFu3rkn2XVhYCEfXmsCDewbvy8XFBfn5+Tpt06dPf+yTLkNCQrBmzRo0atQIN2/exMyZM9GpUyecPXsWGRkZsLe3F1+LXcbLywsZGRkAgIyMDJ1EX7a+bJ0+LDrZl7333D44AjKbig9nEFmS1PhPzB0CkcnkaTR4JtBX/O+5KRQXFwMP7kERHAEYkitKi5GfvBZpaWniK7kBPLGq79mzp/hzs2bNEBISAn9/f3z77bd6vwHSUBad7MuGUmQ29kz2ZLX+/h8VImtVJZdibR0MyhWC7OFlBqVSWal/l25ubmjYsCGuXLmC7t27o7i4GDk5OTrVfWZmpvhSKm9vbxw7dkxnH2Wz9f/pxVWPw1vviIhIGmQAZDIDFsMOn5+fj6tXr6J27dpo3bo17OzsEBcXJ66/ePEiUlNToVarAQBqtRpJSUnIysoS++zduxdKpRLBwcF6HduiK3siIqIKk8kfLoZsr4cJEyagd+/e8Pf3R3p6OqZPnw4bGxsMHjwYKpUKo0aNQnR0NNzd3aFUKvHWW29BrVajffv2AIAePXogODgYw4YNw/z585GRkYEpU6YgMjLyiZcOnoTJnoiIyAR+//13DB48GNnZ2fDw8EDHjh1x5MgReHh4AAAWL14MuVyO/v37o6ioCGFhYVixYoW4vY2NDXbs2IE33ngDarUazs7OiIiIwKxZs/SOxaLvs9doNFCpVFA0HcNr9mS17iZ+au4QiExGo9HAq6YKubm5JpufIuaKlm9CZqNfRfx3QmkRik6uMGmspsLKnoiIpKGKh/GrE8uNnIiIiCqElT0REUlD2ax6Q7a3UEz2REQkEQYO41vwYLjlRk5EREQVwsqeiIikgcP4REREVo6z8YmIiMhasbInIiJp4DA+ERGRlZPwMD6TPRERSYOEK3vL/TWFiIiIKoSVPRERSQOH8YmIiKycTGZgsucwPhEREVVTrOyJiEga5LKHiyHbWygmeyIikgYJX7O33MiJiIioQljZExGRNEj4PnsmeyIikgYO4xMREZG1YmVPRETSwGF8IiIiKyfhYXwmeyIikgYJV/aW+2sKERERVQgreyIikgYO4xMREVk5DuMTERGRtWJlT0REEmHgML4F18dM9kREJA0cxiciIiJrxcqeiIikQSYzcDa+5Vb2TPZERCQNEr71znIjJyIiogphZU9ERNIg4Ql6TPZERCQNEh7GZ7InIiJpkHBlb7m/phAREVGFsLInIiJp4DA+ERGRleMwPhEREVkrVvZERCQJMpkMMolW9kz2REQkCVJO9hzGJyIisnKs7ImISBpkfy6GbG+hmOyJiEgSOIxPREREVouVPRERSYKUK3smeyIikgQmeyIiIisn5WTPa/ZERERWjpU9ERFJA2+9IyIism4cxiciIiKrxcqeiIgk4eEbbg2p7I0XS1VjsiciIkmQwcBhfAvO9hzGJyIisnKs7ImISBKkPEGPyZ6IiKRBwrfecRifiIjIyrGyJyIiaTBwGF/gMD4REVH1Zug1e8Nm8psXkz0REUmClJM9r9kTERGZ2McffwyZTIZx48aJbYWFhYiMjETNmjXh4uKC/v37IzMzU2e71NRUhIeHw8nJCZ6enpg4cSIePHig9/GZ7ImISBpkRlgqITExEatWrUKzZs102sePH4/t27djy5YtOHDgANLT09GvXz9xfWlpKcLDw1FcXIzDhw9j7dq1WLNmDaZNm6Z3DEz2REQkCWXD+IYs+srPz8fQoUPxxRdfoEaNGmJ7bm4uvvrqKyxatAjdunVD69atsXr1ahw+fBhHjhwBAOzZswfJycnYsGEDWrRogZ49e2L27NmIjY1FcXGxXnEw2RMREelBo9HoLEVFRU/sGxkZifDwcISGhuq0nzhxAiUlJTrtjRs3hp+fHxISEgAACQkJaNq0Kby8vMQ+YWFh0Gg0OHfunF4xM9kTEZEkGKuy9/X1hUqlEpeYmJjHHu+bb77Bb7/99tj1GRkZsLe3h5ubm067l5cXMjIyxD5/T/Rl68vW6YOz8YmISBKMNRs/LS0NSqVSbFcoFOX6pqWl4Z133sHevXvh4OBQ6WMaCyt7IiIiPSiVSp3lccn+xIkTyMrKQqtWrWBrawtbW1scOHAAy5Ytg62tLby8vFBcXIycnByd7TIzM+Ht7Q0A8Pb2Ljc7v+xzWZ+KYrInIiJJqMoJei+88AKSkpJw6tQpcWnTpg2GDh0q/mxnZ4e4uDhxm4sXLyI1NRVqtRoAoFarkZSUhKysLLHP3r17oVQqERwcrNe5cxifiIikoQpfhOPq6oomTZrotDk7O6NmzZpi+6hRoxAdHQ13d3colUq89dZbUKvVaN++PQCgR48eCA4OxrBhwzB//nxkZGRgypQpiIyMfOxowj9hsiciIjKDxYsXQy6Xo3///igqKkJYWBhWrFghrrexscGOHTvwxhtvQK1Ww9nZGREREZg1a5bex2KyJyIiSTD343Lj4+N1Pjs4OCA2NhaxsbFP3Mbf3x8//fSTQccFmOyJiEgizJ3szYnJnoiIJEHKyZ6z8YmIiKwcK3siIpKGKpyNX90w2RMRkSRwGJ+IiIisFit7iZs05iW8P/YlnbZL1zMQ8upHAACFvS0+GtcP/bq3hr29LfYfOY8J8zbj1p08sX9drxpY+P5AdGzTEAX3ivDNzqOYGftflJZqq/RciAz1xbcHsHxDHLKyNWjSoA7mTXwVrZ8NMHdYZCSs7M0sNjYWAQEBcHBwQEhICI4dO2bukCTl/NV0NHpxsrj0HL1YXDd3fH+82KkJRkz+Cr1eWwLvWiqsnz9aXC+Xy7B5yRuws7NF2KiFeHPmegzuFYIPXgs3x6kQVdrWPScwZckPmDS6J+LXT0KTBnXQ/61YnV9sybLJYODjci34or3Zk/3mzZsRHR2N6dOn47fffkPz5s0RFham8yxgMq0HpVpkZeeJy53cAgCA0tkB/+qjxoeLt+LX45dw+kIaomZtQEjz+mjTJAAA0K19EBoFeuO1aWtx9tIf2Hc4GXNX7sToV5+Hna2NGc+KSD8rNu3H8L7PYej/qdG4Xm0smjwITg722PDfBHOHRmQwsyf7RYsWYcyYMRg5ciSCg4OxcuVKODk54euvvzZ3aJJRz9cDyT/NwcltM/D57AjU9aoBAGge5Ad7O1vEH7so9r18IxNpN++gbdNAAEDbpoFIvpquU/3EHTkPpYsjGterXbUnQlRJxSUPcOpCGrq0ayS2yeVydG7XCIlJKWaMjIypKl+EU92YNdkXFxfjxIkTCA0NFdvkcjlCQ0ORkMDfpqvCiXPXETlzA159OxbvfrwZ/j418dMX4+HipIBXTSWKikugyb+vs03WHQ28aj58l7NnTSWysnWHOW9lawAAXrWUILIE2Tn5KC3VwsPdVafdw12JrD//PpMVkBlhsVBmnaB3+/ZtlJaWwsvLS6fdy8sLFy5cKNe/qKgIRUVF4meNhv8IDbXvcLL487kr6Th+9jqSts9C39BWKCwqMWNkRERkLGYfxtdHTEwMVCqVuPj6+po7JKujyb+PK6lZqOfrgcxsDRT2dlC6OOr08XRXIvPPaicrWwPPmo9UQ39W/Zm3+csYWYaabi6wsZGXm4x3644GnjU5QmUtOIxvJrVq1YKNjQ0yMzN12jMzM+Ht7V2u/+TJk5GbmysuaWlpVRWqZDg72iOwTi1k3M7F6fOpKC55gM5t/7qO+Yy/J3xru4vXMROTUhBc3we1ariIfbqGNIYm/z4upmRUefxElWFvZ4sWjX1xIPGv+SlarRYHEy+J81PI8jHZm4m9vT1at26NuLg4sU2r1SIuLg5qtbpcf4VCAaVSqbOQYWa98zKea/UMfGu7o12zQKxfMBalWi2+330CmoJCbPgxAXPG90PH1g3QvLEvYqf9C8fOXMPxs9cBAPuPnMfFlAysnBmBJg3qoFv7IHz4ei98ueUgiksemPfkiPTw5pBuWLftMP6z4wgupmQg+uPNKLhfhKG925s7NDISmczwxVKZ/aE60dHRiIiIQJs2bdCuXTssWbIEBQUFGDlypLlDk4Q6nm748qORcFc54fbdfBw9fQ3dRy5Edk4+AOCDxd9DKwhYN2+0zkN1ymi1AgaN/wwL3x+E3V+/i3v3i/Cfnccwd9VOc50SUaX069Eat3PyMXfVTmRl56Fpwzr4blkkh/HJKsgEQRDMHcSnn36KBQsWICMjAy1atMCyZcsQEhLy1O00Gg1UKhUUTcdAZmNfBZESVb27iZ+aOwQik9FoNPCqqUJubq7JRmvLckW9t76DXOFc6f1oiwpwbfkrJo3VVMxe2QNAVFQUoqKizB0GERFZM0OH4i14GN+iZuMTERGR/qpFZU9ERGRqUn4RDpM9ERFJgqEz6i0413MYn4iIyNqxsiciIkmQy2WQyytfngsGbGtuTPZERCQJHMYnIiIiq8XKnoiIJIGz8YmIiKyclIfxmeyJiEgSpFzZ85o9ERGRlWNlT0REkiDlyp7JnoiIJEHK1+w5jE9ERGTlWNkTEZEkyGDgML4Fv+OWyZ6IiCSBw/hERERktVjZExGRJHA2PhERkZXjMD4RERFZLVb2REQkCRzGJyIisnJSHsZnsiciIkmQcmXPa/ZERERWjpU9ERFJg4HD+Bb8AD0meyIikgYO4xMREZHVYmVPRESSwNn4REREVo7D+ERERGS1WNkTEZEkcBifiIjIynEYn4iIiKwWK3siIpIEKVf2TPZERCQJvGZfSYWFhXBwcDBWLERERCYj5cpe72v2Wq0Ws2fPRp06deDi4oJr164BAKZOnYqvvvrK6AESERGRYfRO9h999BHWrFmD+fPnw97eXmxv0qQJvvzyS6MGR0REZCxlw/iGLJZK72S/bt06fP755xg6dChsbGzE9ubNm+PChQtGDY6IiMhYyobxDVksld7J/o8//sAzzzxTrl2r1aKkpMQoQREREZHx6J3sg4OD8euvv5Zr/+6779CyZUujBEVERGRsMhg4jG/uEzCA3rPxp02bhoiICPzxxx/QarXYunUrLl68iHXr1mHHjh2miJGIiMhgcpkMcgOG4g3Z1tz0ruz79OmD7du3Y9++fXB2dsa0adNw/vx5bN++Hd27dzdFjERERGSASt1n36lTJ+zdu9fYsRAREZmMlB+qo3dlX69ePWRnZ5drz8nJQb169YwSFBERkbFxNr4erl+/jtLS0nLtRUVF+OOPP4wSFBERkbHJZYYv+vjss8/QrFkzKJVKKJVKqNVq/Pzzz+L6wsJCREZGombNmnBxcUH//v2RmZmps4/U1FSEh4fDyckJnp6emDhxIh48eKD3uVd4GP+///2v+PPu3buhUqnEz6WlpYiLi0NAQIDeARAREVmjunXr4uOPP0aDBg0gCALWrl2LPn364OTJk3j22Wcxfvx47Ny5E1u2bIFKpUJUVBT69euHQ4cOAXiYW8PDw+Ht7Y3Dhw/j5s2bGD58OOzs7DB37ly9YpEJgiBUpKNc/nAQQCaT4dFN7OzsEBAQgIULF6JXr156BWAIjUYDlUoFRdMxkNnYP30DIgt0N/FTc4dAZDIajQZeNVXIzc2FUqk02TFUKhVCF8XBztGl0vspuZ+PfdEvGBSru7s7FixYgFdeeQUeHh7YtGkTXnnlFQDAhQsXEBQUhISEBLRv3x4///wzevXqhfT0dHh5eQEAVq5ciUmTJuHWrVs6T7F9mgoP42u1Wmi1Wvj5+SErK0v8rNVqUVRUhIsXL1ZpoiciItKHsR6Xq9FodJaioqKnHru0tBTffPMNCgoKoFarceLECZSUlCA0NFTs07hxY/j5+SEhIQEAkJCQgKZNm4qJHgDCwsKg0Whw7tw5vc5d72v2KSkpqFWrlr6bERERWQVfX1+oVCpxiYmJeWLfpKQkuLi4QKFQ4PXXX8cPP/yA4OBgZGRkwN7eHm5ubjr9vby8kJGRAQDIyMjQSfRl68vW6aNSt94VFBTgwIEDSE1NRXFxsc66t99+uzK7JCIiMinZn38M2R4A0tLSdIbxFQrFE7dp1KgRTp06hdzcXHz33XeIiIjAgQMHKh1DZemd7E+ePImXXnoJ9+7dQ0FBAdzd3XH79m1xpiCTPRERVUeVmVH/6PYAxNn1FWFvby++T6Z169ZITEzE0qVLMXDgQBQXFyMnJ0enus/MzIS3tzcAwNvbG8eOHdPZX9ls/bI+FY5dr94Axo8fj969e+Pu3btwdHTEkSNHcOPGDbRu3RqffPKJvrsjIiKSjLJ5bq1bt4adnR3i4uLEdRcvXkRqairUajUAQK1WIykpCVlZWWKfvXv3QqlUIjg4WK/j6l3Znzp1CqtWrYJcLoeNjQ2KiopQr149zJ8/HxEREejXr5++uyQiIjI5Qx+Mo++2kydPRs+ePeHn54e8vDxs2rQJ8fHx4u3ro0aNQnR0NNzd3aFUKvHWW29BrVajffv2AIAePXogODgYw4YNw/z585GRkYEpU6YgMjLyHy8dPI7eyd7Ozk68Dc/T0xOpqakICgqCSqVCWlqavrsjIiKqElX9uNysrCwMHz4cN2/ehEqlQrNmzbB7927xPTKLFy+GXC5H//79UVRUhLCwMKxYsULc3sbGBjt27MAbb7wBtVoNZ2dnREREYNasWXrHrneyb9myJRITE9GgQQN07twZ06ZNw+3bt7F+/Xo0adJE7wCIiIis0VdfffWP6x0cHBAbG4vY2Ngn9vH398dPP/1kcCx6X7OfO3cuateuDQCYM2cOatSogTfeeAO3bt3CqlWrDA6IiIjIFMpecWvIYqn0ruzbtGkj/uzp6Yldu3YZNSAiIiJT4Fvv9NCtWzfk5OSUa9doNOjWrZsxYiIiIjI6vvVOD/Hx8eUepAM8fHvPr7/+apSgiIiIyHgqPIx/5swZ8efk5GSdR/WVlpZi165dqFOnjnGjIyIiMhIpD+NXONm3aNFCHMZ43HC9o6Mjli9fbtTgiIiIjMXQSXaSmKCXkpICQRBQr149HDt2DB4eHuI6e3t7eHp6wsbGxiRBEhERUeVVONn7+/sDePioPyIiIksj+3MxZHtLVeEJepcuXSr3QP64uDh07doV7dq1w9y5c40eHBERkbFwNn4FTJo0CTt27BA/p6SkoHfv3rC3t4darUZMTAyWLFliihiJiIjIABUexj9+/Djee+898fPGjRvRsGFD7N69GwDQrFkzLF++HOPGjTN6kERERIYy1ituLVGFK/vbt2+jbt264udffvkFvXv3Fj936dIF169fN2pwRERExsJh/Apwd3fHzZs3ATycpHf8+HHxNXwAUFxcDEEQjB8hERERGaTCyb5Lly6YPXs20tLSsGTJEmi1WnTp0kVcn5ycjICAABOESEREZBxlD9apzGLJKnzNfs6cOejevTv8/f1hY2ODZcuWwdnZWVy/fv16PhufiIiqLUOH4i15GL/CyT4gIADnz5/HuXPn4OHhAR8fH531M2fO1LmmT0REVJ1IeYKeXq+4tbW1RfPmzR+77kntREREZF56v8+eiIjIEnEYn4iIyMrxcblERERktVjZExGRJPAVt09x5syZCu+wWbNmlQ6GiIjIVAy9X96Cc33Fkn2LFi0gk8kgCMJTJyiUlpYaJTAiIiIyjgpds09JScG1a9eQkpKC77//HoGBgVixYgVOnjyJkydPYsWKFahfvz6+//57U8dLRERUKVJ+Nn6FKnt/f3/x51dffRXLli3DSy+9JLY1a9YMvr6+mDp1Kvr27Wv0IImIiAwl5WF8vWfjJyUlITAwsFx7YGAgkpOTjRIUERERGY/eyT4oKAgxMTEoLi4W24qLixETE4OgoCCjBkdERGQsZbPxDVksld633q1cuRK9e/dG3bp1xZn3Z86cgUwmw/bt240eIBERkTFIeRhf72Tfrl07XLt2DRs3bsSFCxcAAAMHDsSQIUN03oJHRERUnfBxuXpydnbG2LFjjR0LERERmUClHpe7fv16dOzYET4+Prhx4wYAYPHixfjxxx+NGhwREZGxyI2wWCq9Y//ss88QHR2Nnj174u7du+JDdGrUqIElS5YYOz4iIiKjkPJ99non++XLl+OLL77Ahx9+CFvbv64CtGnTBklJSUYNjoiIiAyn9zX7lJQUtGzZsly7QqFAQUGBUYIiIiIyNpkMkEt0Nr7elX1gYCBOnTpVrn3Xrl28z56IiKotuczwxVLpXdlHR0cjMjIShYWFEAQBx44dw3/+8x/ExMTgyy+/NEWMREREZAC9k/3o0aPh6OiIKVOm4N69exgyZAh8fHywdOlSDBo0yBQxEhERGYz32VfQgwcPsGnTJoSFhWHo0KG4d+8e8vPz4enpaar4iIiIjMLQoXhLHsbX65q9ra0tXn/9dRQWFgIAnJycmOiJiIiqOb0n6LVr1w4nT540RSxEREQmU/ZsfEMWS6X3Nfs333wT7777Ln7//Xe0bt263PPwy16OQ0REVJ0Y+uY6Sb31rmwS3ttvvy22yWQyCIIAmUwmPlGPiIioOjH0kbeW/LjcSj1Uh4iIiCyH3sne39/fFHEQERGZFN9nXwnJyclITU1FcXGxTvv//d//GRwUERGRsclh4DV7WG621zvZX7t2DS+//DKSkpLEa/XAXw8b4DV7IiKi6kXv+QbvvPMOAgMDkZWVBScnJ5w7dw4HDx5EmzZtEB8fb4IQiYiIDMdb7/SQkJCA/fv3o1atWpDL5ZDL5ejYsSNiYmLw9ttv8x58IiKqlvgEPT2UlpbC1dUVAFCrVi2kp6cDeDhx7+LFi8aNjoiIiAymd2XfpEkTnD59GoGBgQgJCcH8+fNhb2+Pzz//HPXq1TNFjERERAZ7+D57Q16EY8RgqpjeyX7KlCkoKCgAAMyaNQu9evVCp06dULNmTWzevNnoARIRERkDb73TQ1hYmPjzM888gwsXLuDOnTuoUaOGRb/+j4iIyFpV+j57AEhLSwMA+Pr6GiUYIiIiU+EEPT08ePAAU6dOhUqlQkBAAAICAqBSqTBlyhSUlJSYIkYiIiKDyYzwx1LpXdm/9dZb2Lp1K+bPnw+1Wg3g4e14M2bMQHZ2Nj777DOjB0lERGQoKVf2eif7TZs24ZtvvkHPnj3FtmbNmsHX1xeDBw9msiciIqpm9E72CoUCAQEB5doDAwNhb29vjJiIiIiMTsqVvd7X7KOiojB79mwUFRWJbUVFRZgzZw6ioqKMGhwREZGxyGQygxdLpXdlf/LkScTFxaFu3bpo3rw5AOD06dMoLi7GCy+8gH79+ol9t27darxIiYiIqFL0TvZubm7o37+/ThtvvSMioupOysP4eif71atXmyIOIiIik5LyE/T0vmYPPLzXft++fVi1ahXy8vIAAOnp6cjPzzdqcERERGQ4vSv7Gzdu4MUXX0RqaiqKiorQvXt3uLq6Yt68eSgqKsLKlStNEScREZFB5DKZQS/CMWRbc9O7sn/nnXfQpk0b3L17F46OjmL7yy+/jLi4OKMGR0REZCxl1+wNWfQRExODtm3bwtXVFZ6enujbt2+5V8EXFhYiMjISNWvWhIuLC/r374/MzEydPqmpqQgPD4eTkxM8PT0xceJEPHjwQL9z1y904Ndff8WUKVPK3VMfEBCAP/74Q9/dERERWaUDBw4gMjISR44cwd69e1FSUoIePXqIb44FgPHjx2P79u3YsmULDhw4gPT0dJ272kpLSxEeHo7i4mIcPnwYa9euxZo1azBt2jS9YtF7GF+r1aK0tLRc+++//w5XV1d9d0dERFQ1DJygp++j8Xft2qXzec2aNfD09MSJEyfw/PPPIzc3F1999RU2bdqEbt26AXg4CT4oKAhHjhxB+/btsWfPHiQnJ2Pfvn3w8vJCixYtMHv2bEyaNAkzZsyo8MPs9K7se/TogSVLloifZTIZ8vPzMX36dLz00kv67o6IiKhKyCEzeAEAjUajs/z9IXP/JDc3FwDg7u4OADhx4gRKSkoQGhoq9mncuDH8/PyQkJAA4OG7Z5o2bQovLy+xT1hYGDQaDc6dO6fHuevpk08+waFDhxAcHIzCwkIMGTJEHMKfN2+evrsjIiKqEmW33hmyAA+fLaNSqcQlJibmqcfWarUYN24cOnTogCZNmgAAMjIyYG9vDzc3N52+Xl5eyMjIEPv8PdGXrS9bV1F6D+P7+vri9OnT2Lx5M06fPo38/HyMGjUKQ4cO1ZmwR0REZI3S0tKgVCrFzwqF4qnbREZG4uzZs/jf//5nytCeSK9kX1JSgsaNG2PHjh0YOnQohg4daqq4iIiIjMpYT9BTKpU6yf5poqKisGPHDhw8eBB169YV2729vVFcXIycnByd6j4zMxPe3t5in2PHjunsr2y2flmfCsVe4Z4A7OzsUFhYqM8mRERE1ULZffaGLPoQBAFRUVH44YcfsH//fgQGBuqsb926Nezs7HRuW7948SJSU1OhVqsBAGq1GklJScjKyhL77N27F0qlEsHBwRU/d70ix8OhiHnz5ul9jx8REZGUREZGYsOGDdi0aRNcXV2RkZGBjIwM3L9/HwCgUqkwatQoREdH45dffsGJEycwcuRIqNVqtG/fHsDDSfHBwcEYNmwYTp8+jd27d2PKlCmIjIys0OWDMnpfs09MTERcXBz27NmDpk2bwtnZWWc933RHRETVUVU/G/+zzz4DAHTp0kWnffXq1RgxYgQAYPHixZDL5ejfvz+KiooQFhaGFStWiH1tbGywY8cOvPHGG1Cr1XB2dkZERARmzZqlVyxGeesdERFRdSeHgY/L1fNGe0EQntrHwcEBsbGxiI2NfWIff39//PTTT3od+1F86x0REZGVq/A1e61Wi3nz5qFDhw5o27Yt3n//ffG6AxERUXVnrPvsLVGFk/2cOXPwwQcfwMXFBXXq1MHSpUsRGRlpytiIiIiMRm6ExVJVOPZ169ZhxYoV2L17N7Zt24bt27dj48aN0Gq1poyPiIiIDFThZJ+amqrz7PvQ0FDIZDKkp6ebJDAiIiJjkslkBi+WqsIT9B48eAAHBwedNjs7O5SUlBg9KCIiImOTQe8X15Xb3lJVONkLgoARI0bo3MRfWFiI119/Xedee95nT0RE1VFlnoL36PaWqsLJPiIiolzbv/71L6MGQ0RERMZX4WTP++uJiMjSWW5tbhi9H6pDRERkiar6cbnViSXfNkhEREQVwMqeiIgkwdDb5yRx6x0REZElM/QpeJY8FG7JsRMREVEFsLInIiJJ4DA+ERGRlZPyE/Q4jE9ERGTlWNkTEZEkcBifiIjIykl5Nj6TPRERSYKUK3tL/kWFiIiIKoCVPRERSYKUZ+Mz2RMRkSTwRThERERktVjZExGRJMghg9yAwXhDtjU3JnsiIpIEDuMTERGR1WJlT0REkiD7848h21sqJnsiIpIEDuMTERGR1WJlT0REkiAzcDY+h/GJiIiqOSkP4zPZExGRJEg52fOaPRERkZVjZU9ERJLAW++IiIisnFz2cDFke0vFYXwiIiIrx8qeiIgkgcP4REREVo6z8YmIiMhqsbInIiJJkMGwoXgLLuyZ7ImISBo4G5+IiIisFit7iZs05iW8P/YlnbZL1zMQ8upHAACFvS0+GtcP/bq3hr29LfYfOY8J8zbj1p08sX9drxpY+P5AdGzTEAX3ivDNzqOYGftflJZqq/RciAz1xbcHsHxDHLKyNWjSoA7mTXwVrZ8NMHdYZCRSno1v1sr+4MGD6N27N3x8fCCTybBt2zZzhiNZ56+mo9GLk8Wl5+jF4rq54/vjxU5NMGLyV+j12hJ411Jh/fzR4nq5XIbNS96AnZ0twkYtxJsz12NwrxB88Fq4OU6FqNK27jmBKUt+wKTRPRG/fhKaNKiD/m/F6vxiS5atbDa+IYulMmuyLygoQPPmzREbG2vOMCTvQakWWdl54nIntwAAoHR2wL/6qPHh4q349fglnL6QhqhZGxDSvD7aNAkAAHRrH4RGgd54bdpanL30B/YdTsbclTsx+tXnYWdrY8azItLPik37Mbzvcxj6f2o0rlcbiyYPgpODPTb8N8HcoZGRyIywWCqzJvuePXvio48+wssvv2zOMCSvnq8Hkn+ag5PbZuDz2RGo61UDANA8yA/2draIP3ZR7Hv5RibSbt5B26aBAIC2TQORfDVdp/qJO3IeShdHNK5Xu2pPhKiSikse4NSFNHRp10hsk8vl6NyuERKTUswYGZFxWNQ1+6KiIhQVFYmfNRqNGaOxDifOXUfkzA24ciMTXrVUmDSmJ376YjyeGzQHXjWVKCougSb/vs42WXc08KqpBAB41lQiK1t3mPNW9sP/X7xqKZF0qWrOg8gQ2Tn5KC3VwsPdVafdw12Jy9czzRQVGZscMsgNGIuXW3Btb1HJPiYmBjNnzjR3GFZl3+Fk8edzV9Jx/Ox1JG2fhb6hrVBYVGLGyIiIjMvQoXjLTfUWduvd5MmTkZubKy5paWnmDsnqaPLv40pqFur5eiAzWwOFvR2ULo46fTzdlcj8s3rPytbAs+Yj1dCfVX/mbY68kGWo6eYCGxt5ucl4t+5o4Pnn32ciS2ZRyV6hUECpVOosZFzOjvYIrFMLGbdzcfp8KopLHqBz27+uYz7j7wnf2u7idczEpBQE1/dBrRouYp+uIY2hyb+PiykZVR4/UWXY29miRWNfHEj8a36KVqvFwcRL4vwUsgISnqFnUcP4ZHyz3nkZu35NQtrNO6jtocL7Y8NRqtXi+90noCkoxIYfEzBnfD/c1RQgr6AQ8ye+imNnruH42esAgP1HzuNiSgZWzozAjOXb4FlTiQ9f74UvtxxEcckD854ckR7eHNINb85cj5ZBfmj1bAA++88vKLhfhKG925s7NDISKd9nb9Zkn5+fjytXroifU1JScOrUKbi7u8PPz8+MkUlHHU83fPnRSLirnHD7bj6Onr6G7iMXIjsnHwDwweLvoRUErJs3WuehOmW0WgGDxn+Ghe8Pwu6v38W9+0X4z85jmLtqp7lOiahS+vVojds5+Zi7aieysvPQtGEdfLcsksP4ZBVkgiAI5jp4fHw8unbtWq49IiICa9aseer2Go0GKpUKiqZjILOxN0GEROZ3N/FTc4dAZDIajQZeNVXIzc012aXZslwRdyoVLq6VP0Z+ngYvtPAzaaymYtbKvkuXLjDj7xpERCQhnI1PREREVosT9IiISBokXNoz2RMRkSRwNj4REZGVM/TNdXzrHREREVVbrOyJiEgSJHzJnsmeiIgkQsLZnsP4REREVo7JnoiIJEFmhD/6OHjwIHr37g0fHx/IZDJs27ZNZ70gCJg2bRpq164NR0dHhIaG4vLlyzp97ty5g6FDh0KpVMLNzQ2jRo1Cfn6+3ufOZE9ERJJQNhvfkEUfBQUFaN68OWJjYx+7fv78+Vi2bBlWrlyJo0ePwtnZGWFhYSgsLBT7DB06FOfOncPevXuxY8cOHDx4EGPHjtX73HnNnoiIyAR69uyJnj17PnadIAhYsmQJpkyZgj59+gAA1q1bBy8vL2zbtg2DBg3C+fPnsWvXLiQmJqJNmzYAgOXLl+Oll17CJ598Ah8fnwrHwsqeiIgkwVivs9doNDpLUVGR3rGkpKQgIyMDoaGhYptKpUJISAgSEhIAAAkJCXBzcxMTPQCEhoZCLpfj6NGjeh2PyZ6IiKTBSNne19cXKpVKXGJiYvQOJSMjAwDg5eWl0+7l5SWuy8jIgKenp856W1tbuLu7i30qisP4REREekhLS9N5xa1CoTBjNBXDyp6IiCTBWLPxlUqlzlKZZO/t7Q0AyMzM1GnPzMwU13l7eyMrK0tn/YMHD3Dnzh2xT0Ux2RMRkSRU9Wz8fxIYGAhvb2/ExcWJbRqNBkePHoVarQYAqNVq5OTk4MSJE2Kf/fv3Q6vVIiQkRK/jcRifiIgkoaofoJefn48rV66In1NSUnDq1Cm4u7vDz88P48aNw0cffYQGDRogMDAQU6dOhY+PD/r27QsACAoKwosvvogxY8Zg5cqVKCkpQVRUFAYNGqTXTHyAyZ6IiMgkjh8/jq5du4qfo6OjAQARERFYs2YN3nvvPRQUFGDs2LHIyclBx44dsWvXLjg4OIjbbNy4EVFRUXjhhRcgl8vRv39/LFu2TO9YZIIgCIafknloNBqoVCoomo6BzMbe3OEQmcTdxE/NHQKRyWg0GnjVVCE3N1dn0puxj6FSqZBw/g+4uFb+GPl5GqiD6pg0VlNhZU9ERJJQmUfePrq9peIEPSIiIivHyp6IiCTB0Bn1xpyNX9WY7ImISBIk/Dp7DuMTERFZO1b2REQkDRIu7ZnsiYhIEjgbn4iIiKwWK3siIpIEzsYnIiKychK+ZM9kT0REEiHhbM9r9kRERFaOlT0REUmClGfjM9kTEZE0GDhBz4JzPYfxiYiIrB0reyIikgQJz89jsiciIomQcLbnMD4REZGVY2VPRESSwNn4REREVk7Kj8vlMD4REZGVY2VPRESSIOH5eUz2REQkERLO9kz2REQkCVKeoMdr9kRERFaOlT0REUmCDAbOxjdaJFWPyZ6IiCRBwpfsOYxPRERk7VjZExGRJEj5oTpM9kREJBHSHcjnMD4REZGVY2VPRESSwGF8IiIiKyfdQXwO4xMREVk9VvZERCQJHMYnIiKyclJ+Nj6TPRERSYOEL9rzmj0REZGVY2VPRESSIOHCnsmeiIikQcoT9DiMT0REZOVY2RMRkSRwNj4REZG1k/BFew7jExERWTlW9kREJAkSLuyZ7ImISBo4G5+IiIisFit7IiKSCMNm41vyQD6TPRERSQKH8YmIiMhqMdkTERFZOQ7jExGRJEh5GJ/JnoiIJEHKj8vlMD4REZGVY2VPRESSwGF8IiIiKyflx+VyGJ+IiMjKsbInIiJpkHBpz2RPRESSwNn4REREZLVY2RMRkSRwNj4REZGVk/Alew7jExGRRMiMsFRCbGwsAgIC4ODggJCQEBw7dsyw86gEJnsiIiIT2bx5M6KjozF9+nT89ttvaN68OcLCwpCVlVWlcTDZExGRJMiM8EdfixYtwpgxYzBy5EgEBwdj5cqVcHJywtdff22CM3wyJnsiIpKEsgl6hiz6KC4uxokTJxAaGiq2yeVyhIaGIiEhwchn988seoKeIAgP/7e02MyREJmORqMxdwhEJpP359/vsv+em5Kh/5bKtn90PwqFAgqFolz/27dvo7S0FF5eXjrtXl5euHDhgkGx6Muik31eXh4AoDh5rZkjITIdr5pfmDsEIpPLy8uDSqUyyb7t7e3h7e2NBoG+Bu/LxcUFvr66+5k+fTpmzJhh8L5NyaKTvY+PD9LS0uDq6gqZJd8AaUE0Gg18fX2RlpYGpVJp7nCIjIp/v6ueIAjIy8uDj4+PyY7h4OCAlJQUFBcbPgosCEK5fPO4qh4AatWqBRsbG2RmZuq0Z2Zmwtvb2+BY9GHRyV4ul6Nu3brmDkOSlEol/2NIVot/v6uWqSr6v3NwcICDg4PJj/N39vb2aN26NeLi4tC3b18AgFarRVxcHKKioqo0FotO9kRERNVZdHQ0IiIi0KZNG7Rr1w5LlixBQUEBRo4cWaVxMNkTERGZyMCBA3Hr1i1MmzYNGRkZaNGiBXbt2lVu0p6pMdmTXhQKBaZPn/7Ea1RElox/v8kUoqKiqnzY/lEyoSrudyAiIiKz4UN1iIiIrByTPRERkZVjsiciIrJyTPZERERWjsmeKqw6vJOZyBQOHjyI3r17w8fHBzKZDNu2bTN3SERGxWRPFVJd3slMZAoFBQVo3rw5YmNjzR0KkUnw1juqkJCQELRt2xaffvopgIePfPT19cVbb72F999/38zRERmPTCbDDz/8ID7elMgasLKnp6pO72QmIiL9MdnTU/3TO5kzMjLMFBUREVUUkz0REZGVY7Knp6pO72QmIiL9MdnTU/39ncxlyt7JrFarzRgZERFVBN96RxVSXd7JTGQK+fn5uHLlivg5JSUFp06dgru7O/z8/MwYGZFx8NY7qrBPP/0UCxYsEN/JvGzZMoSEhJg7LCKDxcfHo2vXruXaIyIisGbNmqoPiMjImOyJiIisHK/ZExERWTkmeyIiIivHZE9ERGTlmOyJiIisHJM9ERGRlWOyJyIisnJM9kRERFaOyZ7ISnTp0gXjxo0zdxhEVA0x2ZPVGDFiBGQyGV5//fVy6yIjIyGTyTBixIiqD6yaKC0txccff4zGjRvD0dER7u7uCAkJwZdffin2qewvDCNGjEDfvn2NFywRGRWTPVkVX19ffPPNN7h//77YVlhYiE2bNlnEM86Li4tNtu+ZM2di8eLFmD17NpKTk/HLL79g7NixyMnJMdkxiah6YLInq9KqVSv4+vpi69atYtvWrVvh5+eHli1b6vTVarWIiYlBYGAgHB0d0bx5c3z33Xfi+tLSUowaNUpc36hRIyxdulRnH/Hx8WjXrh2cnZ3h5uaGDh064MaNGwAeX+2OGzcOXbp0ET936dIFUVFRGDduHGrVqoWwsDAAwNmzZ9GzZ0+4uLjAy8sLw4YNw+3bt8XtCgoKMHz4cLi4uKB27dpYuHDhU7+b//73v3jzzTfx6quvIjAwEM2bN8eoUaMwYcIEMd4DBw5g6dKlkMlkkMlkuH79+lO/hxkzZmDt2rX48ccfxe3i4+MBAGlpaRgwYADc3Nzg7u6OPn364Pr160+NlYiMi8merM6///1vrF69Wvz89ddfP/btfDExMVi3bh1WrlyJc+fOYfz48fjXv/6FAwcOAHj4y0DdunWxZcsWJCcnY9q0afjggw/w7bffAgAePHiAvn37onPnzjhz5gwSEhIwduxYyGQyveJdu3Yt7O3tcejQIaxcuRI5OTno1q0bWrZsiePHj2PXrl3IzMzEgAEDxG0mTpyIAwcO4Mcff8SePXsQHx+P33777R+P4+3tjf379+PWrVuPXb906VKo1WqMGTMGN2/exM2bN+Hr6/vU72HChAkYMGAAXnzxRXG75557DiUlJQgLC4Orqyt+/fVXHDp0CC4uLnjxxRdNOoJBRI8hEFmJiIgIoU+fPkJWVpagUCiE69evC9evXxccHByEW7duCX369BEiIiIEQRCEwsJCwcnJSTh8+LDOPkaNGiUMHjz4iceIjIwU+vfvLwiCIGRnZwsAhPj4+H+M5+/eeecdoXPnzuLnzp07Cy1bttTpM3v2bKFHjx46bWlpaQIA4eLFi0JeXp5gb28vfPvtt+L67OxswdHRUXjnnXeeGPu5c+eEoKAgQS6XC02bNhVee+014aefftLp07lz53/cR5m/fw9POtf169cLjRo1ErRardhWVFQkODo6Crt3737qMYjIePg+e7I6Hh4eCA8Px5o1ayAIAsLDw1GrVi2dPleuXMG9e/fQvXt3nfbi4mKd4f7Y2Fh8/fXXSE1Nxf3791FcXIwWLVoAANzd3TFixAiEhYWhe/fuCA0NxYABA1C7dm294m3durXO59OnT+OXX36Bi4tLub5Xr14V4/j764Xd3d3RqFGjfzxOcHAwzp49ixMnTuDQoUM4ePAgevfujREjRuhM0nucf/oenuT06dO4cuUKXF1dddoLCwtx9erVf9yWiIyLyZ6s0r///W9ERUUBeJioHpWfnw8A2LlzJ+rUqaOzTqFQAAC++eYbTJgwAQsXLoRarYarqysWLFiAo0ePin1Xr16Nt99+G7t27cLmzZsxZcoU7N27F+3bt4dcLofwyBukS0pKysXi7OxcLrbevXtj3rx55frWrl0bV65cqchX8FhyuRxt27ZF27ZtMW7cOGzYsAHDhg3Dhx9+iMDAwMduU5Hv4XHy8/PRunVrbNy4sdw6Dw+PSp8DEemPyZ6sUtl1YZlMJk56+7vg4GAoFAqkpqaic+fOj93HoUOH8Nxzz+HNN98U2x5XkbZs2RItW7bE5MmToVarsWnTJrRv3x4eHh44e/asTt9Tp07Bzs7uH2Nv1aoVvv/+ewQEBMDWtvw/0fr168POzg5Hjx4V7zC4e/cuLl269MRzeZLg4GAADyf8AYC9vT1KS0t1+lTke3jcdq1atcLmzZvh6ekJpVKpV1xEZFycoEdWycbGBufPn0dycjJsbGzKrXd1dcWECRMwfvx4rF27FlevXsVvv/2G5cuXY+3atQCABg0a4Pjx49i9ezcuXbqEqVOnIjExUdxHSkoKJk+ejISEBNy4cQN79uzB5cuXERQUBADo1q0bjh8/jnXr1uHy5cuYPn16ueT/OJGRkbhz5w4GDx6MxMREXL16Fbt378bIkSNRWloKFxcXjBo1ChMnTsT+/ftx9uxZjBgxAnL5P/9zfuWVV7B48WIcPXoUN27cQHx8PCIjI9GwYUM0btwYABAQEICjR4/i+vXruH37NrRa7VO/h7Ltzpw5g4sXL+L27dsoKSnB0KFDUatWLfTp0we//vorUlJSEB8fj7fffhu///77U78HIjIeJnuyWkql8h8rytmzZ2Pq1KmIiYlBUFAQXnzxRezcuVMczn7ttdfQr18/DBw4ECEhIcjOztapbp2cnHDhwgX0798fDRs2xNixYxEZGYnXXnsNABAWFoapU6fivffeQ9u2bZGXl4fhw4c/NW4fHx8cOnQIpaWl6NGjB5o2bYpx48bBzc1NTOgLFixAp06d0Lt3b4SGhqJjx47lrv0/KiwsDNu3b0fv3r3RsGFDREREoHHjxtizZ484gjBhwgTY2NggODgYHh4eSE1Nfer3AABjxoxBo0aN0KZNG3h4eODQoUNwcnLCwYMH4efnh379+iEoKAijRo1CYWEhK32iKiYTHr2oSERERFaFlT0REZGVY7InIiKyckz2REREVo7JnoiIyMox2RMREVk5JnsiIiIrx2RPRERk5ZjsiYiIrByTPRERkZVjsiciIrJyTPZERERWjsmeiIjIyv0/NakhtTD8SPMAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import ConfusionMatrixDisplay\n", "import matplotlib.pyplot as plt\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\n", " \"qubit\": \"q0\",\n", " \"prepared_states\": prepared_states,\n", " \"acq_protocol\": \"ThresholdedAcquisition\",\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=200,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "dataset = measurement_control.run(\"Readout Calibration Verification\")\n", "\n", "prepared_states = dataset.x0.values\n", "measured_states = dataset.y0.values\n", "\n", "ConfusionMatrixDisplay.from_predictions(\n", " prepared_states, measured_states, cmap=\"Blues\", normalize=None\n", ")\n", "plt.title(\"Confusion Matrix\")\n", "plt.xlabel(\"Measured State\")\n", "plt.ylabel(\"Prepared State\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "0a7a7185", "metadata": {}, "source": [ "As expected, the threshold that we set did a good job of discriminating the qubit states (the discrimination is not perfect because the data points belonging to the two states slightly overlap).\n", "\n", "## Conditional Reset\n", "\n", "The conditional reset is implemented in Quantify as a gate. When we have a single {{ Reset }} at the beginning of a schedule, we simply replace the {{ Reset }} gate with the {{ ConditionalReset }} gate, for example\n", "\n", "```{code-block} python\n", "schedule = Schedule()\n", "#schedule.add(Reset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q0\"))\n", "...\n", "```\n", "\n", "In other cases, however, we need to pass extra arguments to {{ ConditionalReset }} that we illustrate below.\n", "\n", "### Example: Modifying the T1 schedule\n", "\n", "In this example, we use the schedule function {{ t1_sched }} using the {{ ConditionalReset }} instead of the standard {{ Reset }}. When using multiple consecutive {{ ConditionalReset }} on the same qubit, we need to increment the `acq_index` for each one, similar to when adding multiple {{ Measure }} to the schedule. We also need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "7ef924de", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit, acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_index=i, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_index=i,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "2cdeeda0", "metadata": {}, "source": [ "#### Running the T1 schedule using MeasurementControl\n", "\n", "The dataset returned by {{ MeasurementControl }} will in this case have four rows of data, which are: \n", "- `y0`: contains the data establishing whether a qubit was reset or not\n", "- `y1`: contains the actual (thresholded) measurement\n", "- `y2` and `y3`: filled with NaNs (currently {{ MeasurementControl }} expects {{ ScheduleGettable }} to return IQ values)\n", "\n", "Below we run {{ MeasurementControl }} again as before" ] }, { "cell_type": "code", "execution_count": 12, "id": "8c4c0b06", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "## generate dummy data for a fictitious T1 experiment\n", "\n", "import numpy as np\n", "\n", "tau = 1e-5\n", "runs = 1024\n", "times = np.array(list(np.linspace(start=1.6e-7, stop=4.976e-5, num=125)))\n", "num_samples = len(times)\n", "\n", "random_initial_states = np.mean(\n", " np.random.choice([0, 1], num_samples * runs).reshape(num_samples, runs), axis=1\n", ")\n", "\n", "\n", "def generate_random_numbers(times, tau, runs):\n", " times = np.array(times)\n", "\n", " probabilities = np.exp(-times / tau)\n", "\n", " random_results = np.random.rand(runs, len(times)) < probabilities\n", " average_results = random_results.mean(axis=0)\n", "\n", " return average_results\n", "\n", "\n", "average_T1_data = generate_random_numbers(times, tau, runs)\n", "\n", "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=f\"0\",\n", " data=[\n", " DummyBinnedAcquisitionData(data=(0, 0), thres=x, avg_cnt=0)\n", " for x in random_initial_states\n", " ],\n", ")\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=f\"1\",\n", " data=[\n", " DummyBinnedAcquisitionData(data=(0, 0), thres=x, avg_cnt=0)\n", " for x in average_T1_data\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 13, "id": "4d898459", "metadata": {}, "outputs": [], "source": [ "single_qubit_device.cfg_sched_repetitions(1024) # run and average 1024 times\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = np.array(list(np.linspace(start=1.6e-7, stop=4.976e-5, num=125)))\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"qubit\": \"q0\", \"times\": times},\n", " batched=True,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)\n", "\n", "dataset = measurement_control.run(\"t1\")" ] }, { "cell_type": "code", "execution_count": 14, "id": "711fe326", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "# we need to temporarily patch the dataset because I don't understand how to\n", "# pass average thresholds to DummyBinnedAcquisitionData such that\n", "# ScheduleGettable returns floats instead of ints\n", "dataset.y0.values = random_initial_states\n", "dataset.y1.values = average_T1_data" ] }, { "cell_type": "markdown", "id": "ae2bca75", "metadata": {}, "source": [ "Above we also passed `num_channels=2` to the {{ ScheduleGettable }} so that it knows to expect measurements on the same qubit, but separate acquisition channels.\n", "\n", "We now plot the contents of this dataset:" ] }, { "cell_type": "code", "execution_count": 15, "id": "23a4f0ba", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkbUlEQVR4nO3dd1xV9f8H8Ne9F+5l7z1kiHuAouI203KlqWmmlqtsOTJaWuZqqA3D0jQtR31/hWZpQ9OU3FsRRQURQUGQvTfce35/IDdvgN6LFw5cXs/H4z4ece45577vNbkvP1MiCIIAIiIiIgMhFbsAIiIiIn1iuCEiIiKDwnBDREREBoXhhoiIiAwKww0REREZFIYbIiIiMigMN0RERGRQGG6IiIjIoDDcEBERkUFhuCFqBm7evAmJRIItW7aIXcp9eXt7Y9q0aWKX0eQsWbIEEolE7DKIGg2GGyItSCQSrR6HDh0CAKxbtw7jx49HixYtIJFIdPrCPnTokMY9ZTIZnJycMG7cOERFRdXPG2xAJ06cwJIlS5CTkyN2KWpbtmy575/rqVOnxC7RIHz88cfYtWuX2GVQM2AkdgFETcEPP/yg8fP333+P/fv3Vzverl07AMDKlSuRn5+PHj164M6dO3V6zblz56J79+4oLy/HpUuXsH79ehw6dAiXL1+Gi4tL3d5II3DixAksXboU06ZNg42NjcZz165dg1Qq3r+5li1bBh8fn2rH/fz8RKhGewsXLsT8+fPFLuOBPv74Y4wbNw6jR48WuxQycAw3RFp49tlnNX4+deoU9u/fX+14lcOHD6tbbSwsLOr0mv369cO4cePUP7dp0wavvPIKvv/+e7z99tt1umdjp1AoRH39YcOGoVu3bqLWoIvCwkKYm5vDyMgIRkb8dU5Uhd1SRPXAy8tL72Mg+vXrBwC4ceOGxvGkpCTMmDEDzs7OUCgU6NChAzZt2vTA+126dAnTpk2Dr68vTExM4OLighkzZiAzM1N9TnFxMdq2bYu2bduiuLhYfTwrKwuurq7o3bs3lEql1vdbsmQJ3nrrLQCAj4+Putvn5s2bAGoecxMXF4fx48fDzs4OZmZm6NmzJ3bv3q1xTlVX3vbt2/HRRx/Bw8MDJiYmGDRoEGJjYx/4WWhr8eLFkEqlCAsL0zj+4osvQi6X4+LFixr1bNu2De+++y5cXFxgbm6OUaNGITExsdp9T58+jaFDh8La2hpmZmYYMGAAjh8/rnFO1biaq1evYtKkSbC1tUXfvn01nruXRCLB7Nmz8fPPP6N9+/YwNTVFr169EBkZCQD45ptv4OfnBxMTEzzyyCPqP4O61hUbG6tujbO2tsb06dNRVFSkUU9hYSG2bt2q/nPn+CqqL4z6RE1E1ZePra2t+lhqaip69uyp/iJzdHTEX3/9heeffx55eXmYN29erffbv38/4uLiMH36dLi4uODKlSvYsGEDrly5glOnTkEikcDU1BRbt25Fnz598N5772HVqlUAgFmzZiE3NxdbtmyBTCbT+n5jx45FTEwMfvrpJ3zxxRdwcHAAADg6OtZYY2pqKnr37o2ioiLMnTsX9vb22Lp1K0aNGoUdO3ZgzJgxGuevWLECUqkUb775JnJzc/HJJ59g8uTJOH36tFafcW5uLjIyMjSOSSQS2NvbA6js/vnjjz/w/PPPIzIyEpaWlti3bx82btyIDz74AP7+/hrXfvTRR5BIJHjnnXeQlpaGkJAQDB48GBERETA1NQUA/PPPPxg2bBgCAwPV4Wnz5s149NFHcfToUfTo0UPjnuPHj0erVq3w8ccfQxCE+76fo0eP4vfff8esWbMAAMuXL8cTTzyBt99+G19//TVeffVVZGdn45NPPsGMGTPwzz//qK/Vta6nn34aPj4+WL58OcLDw/Htt9/CyckJK1euBFDZtfvCCy+gR48eePHFFwEALVu21OrPhUhnAhHpbNasWYK2f33Mzc2FqVOnan3vgwcPCgCETZs2Cenp6UJycrKwd+9ewc/PT5BIJMKZM2fU5z7//POCq6urkJGRoXGPZ555RrC2thaKiooEQRCE+Ph4AYCwefNm9TlVz93rp59+EgAIR44c0Ti+YMECQSqVCkeOHBF+/vlnAYAQEhKicY629/v0008FAEJ8fHy18728vDQ+q3nz5gkAhKNHj6qP5efnCz4+PoK3t7egVCo1PrN27doJpaWl6nNXr14tABAiIyOrvda9Nm/eLACo8aFQKDTOjYyMFORyufDCCy8I2dnZgru7u9CtWzehvLxcfU5VPe7u7kJeXp76+Pbt2wUAwurVqwVBEASVSiW0atVKGDJkiKBSqTQ+Sx8fH+Gxxx5TH1u8eLEAQJg4cWK1+queu1dV7fd+zt98840AQHBxcdGoa8GCBRp/JnWpa8aMGRqvP2bMGMHe3l7jmK5/F4jqit1SRI3UjBkz4OjoCDc3NwwdOhS5ubn44Ycf0L17dwCAIAj45ZdfMHLkSAiCgIyMDPVjyJAhyM3NRXh4eK33r2o5AICSkhJkZGSgZ8+eAFDtuiVLlqBDhw6YOnUqXn31VQwYMABz586t8/20tWfPHvTo0UPd/QIAFhYWePHFF3Hz5k1cvXpV4/zp06dDLperf67qyouLi9Pq9dauXYv9+/drPP766y+Nczp27IilS5fi22+/xZAhQ5CRkYGtW7fWOOZlypQpsLS0VP88btw4uLq6Ys+ePQCAiIgIXL9+HZMmTUJmZqb6z6+wsBCDBg3CkSNHoFKpNO758ssva/VeAGDQoEHw9vZW/xwUFAQAeOqppzTqqjpe9Tnpo65+/fohMzMTeXl5WtdLpC/sliJqpBYtWoR+/fqhoKAAO3fuRGhoqMZMovT0dOTk5GDDhg3YsGFDjfdIS0ur9f5ZWVlYunQpQkNDq52Xm5ur8bNcLsemTZvQvXt3mJiYYPPmzdXGeOhyP23dunVL/cV7r6pZabdu3ULHjh3Vx1u0aKFxXlUXXnZ2tlav16NHD60GFL/11lsIDQ3FmTNn8PHHH6N9+/Y1nteqVSuNnyUSCfz8/NRdjNevXwcATJ06tdbXys3N1eiKrGk2V23++3lYW1sDADw9PWs8XvU51aWu+332VlZWWtdMpA8MN0SNVKdOnTB48GAAwOjRo1FUVISZM2eib9++8PT0VP/L+dlnn631S6hz58613v/pp5/GiRMn8NZbbyEgIAAWFhZQqVQYOnRotX+VA8C+ffsAVLbKXL9+vdqXrK73qw9V43/+S3jA2BRdxcXFqQNA1QDduqj6XD799FMEBATUeM5/Z9vd20L2ILV9Hg/6nOpSV0N99kTaYLghaiJWrFiBnTt34qOPPsL69evh6OgIS0tLKJVKdQjSVnZ2NsLCwrB06VIsWrRIfbzqC/u/Ll26hGXLlmH69OmIiIjACy+8gMjISI1/8Wt7P11mkXl5eeHatWvVjkdHR6ufb2gqlQrTpk2DlZUV5s2bp167ZezYsdXO/e/7FwQBsbGx6tBZNaDWyspK5z/D+lRfdXEVZWooHHND1ES0bNkSTz31FLZs2YKUlBTIZDI89dRT+OWXX3D58uVq56enp9d6r6p/Zf/3X9UhISHVzi0vL8e0adPg5uaG1atXY8uWLUhNTcXrr79ep/uZm5sDgFYrFA8fPhxnzpzByZMn1ccKCwuxYcMGeHt719odVJ9WrVqFEydOYMOGDfjggw/Qu3dvvPLKK9VmWQGViz3m5+erf96xYwfu3LmDYcOGAQACAwPRsmVLfPbZZygoKKh2/f3+DOtTfdVlbm7eqFamJsPFlhuievDHH3+o1zypWmH4ww8/BACMGjXqvt1F9/PWW29h+/btCAkJwYoVK7BixQocPHgQQUFBmDlzJtq3b4+srCyEh4fjwIEDyMrKqvE+VlZW6N+/Pz755BOUl5fD3d0df//9N+Lj46ud++GHHyIiIgJhYWGwtLRE586dsWjRIixcuBDjxo3D8OHDdbpfYGAgAOC9997DM888A2NjY4wcOVIdeu41f/58/PTTTxg2bBjmzp0LOzs7bN26FfHx8fjll1/0vprxX3/9pW4Vulfv3r3h6+uLqKgovP/++5g2bRpGjhwJoHLrhoCAALz66qvYvn27xnV2dnbo27cvpk+fjtTUVISEhMDPzw8zZ84EAEilUnz77bcYNmwYOnTogOnTp8Pd3R1JSUk4ePAgrKys8Mcff+j1PWqjvuoKDAzEgQMHsGrVKri5ucHHx6fGMVVED028iVpETdeDpoJPnTq11qnF907HrknVNOKff/65xucfeeQRwcrKSsjJyREEQRBSU1OFWbNmCZ6enoKxsbHg4uIiDBo0SNiwYYP6mpqmgt++fVsYM2aMYGNjI1hbWwvjx48XkpOTBQDC4sWLBUEQhPPnzwtGRkbCnDlzNGqoqKgQunfvLri5uQnZ2dla36/KBx98ILi7uwtSqVRjCvJ/p4ILgiDcuHFDGDdunGBjYyOYmJgIPXr0EP7880+tPrOa3ndN7jcVvOr6qvfs4eGh/uyrVE0537Ztm0Y9P/30k7BgwQLByclJMDU1FUaMGCHcunWr2utfuHBBGDt2rGBvby8oFArBy8tLePrpp4WwsDD1OVVTrtPT06tdX9tU8FmzZtX4eXz66adafX4PU1fVZ3rvVPTo6Gihf//+gqmpqQCA08Kp3kgEgaO9iIj06dChQxg4cCB+/vlnjS00iKhhcMwNERERGRSGGyIiIjIoDDdERERkUDjmhoiIiAwKW26IiIjIoDDcEBERkUFplov4qVQqJCcnw9LSksuBExERNRGCICA/Px9ubm73XcSzWYab5OTkarviEhERUdOQmJgIDw+PWp9vluHG0tISQOWHY2VlJXI1REREpI28vDx4enqqv8dr0yzDTVVXlJWVFcMNERFRE/OgISUcUExEREQGheGGiIiIDArDDRERERkUhhsiIiIyKAw3REREZFAYboiIiMigiB5ujhw5gpEjR8LNzQ0SiQS7du164DWHDh1C165doVAo4Ofnhy1bttR7nURERNQ0iB5uCgsL4e/vj7Vr12p1fnx8PEaMGIGBAwciIiIC8+bNwwsvvIB9+/bVc6VERETUFIi+iN+wYcMwbNgwrc9fv349fHx88PnnnwMA2rVrh2PHjuGLL77AkCFD6qtMIiIiaiJEb7nR1cmTJzF48GCNY0OGDMHJkydrvaa0tBR5eXkaDyIiIjJMTS7cpKSkwNnZWeOYs7Mz8vLyUFxcXOM1y5cvh7W1tfrBTTOJiIgMV5MLN3WxYMEC5Obmqh+JiYlil0RERET1RPQxN7pycXFBamqqxrHU1FRYWVnB1NS0xmsUCgUUCkW911ahVCEmtQBe9mYwVzS5j5aIiMggNLmWm169eiEsLEzj2P79+9GrVy+RKvrX6K+PY/iXR3E6PlPsUoiIiJot0cNNQUEBIiIiEBERAaByqndERAQSEhIAVHYpTZkyRX3+yy+/jLi4OLz99tuIjo7G119/je3bt+P1118Xo3wNbV2sAAAXEnLELYSIiKgZEz3cnDt3Dl26dEGXLl0AAMHBwejSpQsWLVoEALhz54466ACAj48Pdu/ejf3798Pf3x+ff/45vv3220YxDbxLCxsADDdERERikgiCIIhdREPLy8uDtbU1cnNzYWVlpbf7Xk3Ow/Avj8JCYYSLix+HTCrR272JiIiaO22/v0VvuTEkrZ0tYCaXoaC0AjfSC8Quh4iIqFliuNEjI5kUnT2sAQAXErJFroaIiKh5YrjRsy4tbAFw3A0REZFYGG70rIunDQCGGyIiIrEw3OhZwN0ZUzFp+cgvKRe3GCIiomaI4UbPnCxN4GFrCkEALt3OFbscIiKiZofhph78O+6Gg4qJiIgaGsNNPeC4GyIiIvEw3NQD9UrFiTlohmskEhERiYrhph60d7OCXCZFVmEZErKKxC6HiIioWWG4qQcKIxk6uHMTTSIiIjEw3NSTLp4cVExERCQGhpt6cu+4GyIiImo4DDf1pCrcXEnOQ2ZBqbjFEBERNSMMN/XEw9YMnT2soVQJ2HkhSexyiIiImg2Gm3o0obsnACD0bCKnhBMRETUQhpt6NMrfDabGMsSmFSCcA4uJiIgaBMNNPbI0McaIzq4AgNAziSJXQ0RE1Dww3NSzZ+52Tf156Q53CSciImoADDf1LNDLFi0dzVFcrsQfF++IXQ4REZHBY7ipZxKJBM90bwEA2HY2QeRqiIiIDB/DTQMY09UdxjIJLt7OxdXkPLHLISIiMmgMNw3AwUKBx9o7AwC2n+PAYiIiovrEcNNAxgdWDSxORoVSJXI1REREhovhpoH0beUAO3M5MgrKcOJGptjlEBERGSyGmwZiLJNiRKfKNW92RXA7BiIiovrCcNOAngxwAwDsu5yCknKlyNUQEREZJoabBtS1hS3cbUxRWKZEWFSa2OUQEREZJIabBiSVSjDqbusNu6aIiIjqB8NNA6vqmjp0LQ25RdyOgYiISN8YbhpYWxcrtHWxRLlSwF+XuR0DERGRvjHciKCqa+q3iGSRKyEiIjI8DDciGNm5Mtycis/EndxikashIiIyLAw3IvC0M0M3L1sIAvA7W2+IiIj0iuFGJGO6ugMAfg1PgiAIIldDRERkOBhuRPJEJzfIZVJcS83H1TvcKZyIiEhfGG5EYm1mjEHtnAAAO8O55g0REZG+MNyIaEyXyq6p3y5yp3AiIiJ9YbgR0SNtnGBrZoz0/FIc507hREREesFwIyK5kRQj/Sunhe8Mvy1yNURERIaB4UZkVV1Te6+koKC0QuRqiIiImj6GG5EFeNrAx8EcJeUq7L2cInY5RERETR7DjcgkEgnG3m292XmBXVNEREQPi+GmEajaa+p0XBYK2TVFRET0UBhuGgEve3O425iiQiXg/K1sscshIiJq0hhuGokgXzsAwOl4TgknIiJ6GAw3jURPX3sAwKm4LJErISIiatoYbhqJXnfDzaXbOSgq47gbIiKiumK4aSQ8bE3hZm2CcqWA8Fs5YpdDRETUZDHcNBISieSerimOuyEiIqorhptGhIOKiYiIHh7DTSNS1XITkZiD4jKlyNUQERE1TQw3jUgLOzO4WFWOu7mQwPVuiIiI6oLhphGpHHdT2TXFcTdERER1w3DTyKgHFcdzvRsiIqK6YLhpZIKqxt0k5KCknONuiIiIdMVw08h425vB2UqBMqUK4Rx3Q0REpLNGEW7Wrl0Lb29vmJiYICgoCGfOnLnv+SEhIWjTpg1MTU3h6emJ119/HSUlJQ1Ubf2SSCQI8uFWDERERHUlerjZtm0bgoODsXjxYoSHh8Pf3x9DhgxBWlpajef/+OOPmD9/PhYvXoyoqCh899132LZtG959990Grrz+VK13c5bjboiIiHQmerhZtWoVZs6cienTp6N9+/ZYv349zMzMsGnTphrPP3HiBPr06YNJkybB29sbjz/+OCZOnPjA1p6mpKrlJjwhG6UVHHdDRESkC1HDTVlZGc6fP4/Bgwerj0mlUgwePBgnT56s8ZrevXvj/Pnz6jATFxeHPXv2YPjw4bW+TmlpKfLy8jQejVlLR3PYm8tRWqFC5O1cscshIiJqUkQNNxkZGVAqlXB2dtY47uzsjJSUlBqvmTRpEpYtW4a+ffvC2NgYLVu2xCOPPHLfbqnly5fD2tpa/fD09NTr+9A3iUSCHj5VWzGwa4qIiEgXondL6erQoUP4+OOP8fXXXyM8PBy//vordu/ejQ8++KDWaxYsWIDc3Fz1IzExsQErrpuqcHOG4YaIiEgnRmK+uIODA2QyGVJTUzWOp6amwsXFpcZr3n//fTz33HN44YUXAACdOnVCYWEhXnzxRbz33nuQSqvnNYVCAYVCof83UI+qws25m1moUKpgJGtyOZSIiEgUon5jyuVyBAYGIiwsTH1MpVIhLCwMvXr1qvGaoqKiagFGJpMBAARBqL9iG1hbFytYmRihsEyJq3ca9xghIiKixkT05oDg4GBs3LgRW7duRVRUFF555RUUFhZi+vTpAIApU6ZgwYIF6vNHjhyJdevWITQ0FPHx8di/fz/ef/99jBw5Uh1yDIFMKkF3b3ZNERER6UrUbikAmDBhAtLT07Fo0SKkpKQgICAAe/fuVQ8yTkhI0GipWbhwISQSCRYuXIikpCQ4Ojpi5MiR+Oijj8R6C/Wmh48dwqLTcDo+Cy/08xW7HCIioiZBIhhSX46W8vLyYG1tjdzcXFhZWYldTq0uJGRjzNcnYGNmjPCFj0EqlYhdEhERkWi0/f4WvVuKatfR3RpmchlyisoRk5YvdjlERERNAsNNI2YskyLQyxYAx90QERFpi+GmkevhzcX8iIiIdMFw08jdu5hfMxweRUREpDOGm0bO39MGcpkU6fmlbL0hIiLSAsNNI2diLMOYLu4AgHd+uYTC0gqRKyIiImrcGG6agPeeaAc3axPcyizCir+ixS6HiIioUWO4aQKsTIzx6Xh/AMAPp27h6PV0kSsiIiJqvBhumog+fg6Y2ssLAPDWz5eQW1wuckVERESNE8NNEzJ/WDv4OJgjJa8EK/6KErscIiKiRonhpgkxlcvw0ZiOAIA/Lt5BhVIlckVERESND8NNE9PTxx7WpsYoKK3ApaRcscshIiJqdBhumhipVIJevvYAgBOxGSJXQ0RE1Pgw3DRBffzuhpsbmSJXQkRE1Pgw3DRBvf0cAADnbmWjpFwpcjVERESNC8NNE+TrYA5nKwXKKlQIv5UtdjlERESNCsNNEySRSNCnZWXrzfEbHHdDRER0L4abJqpXy8pxN8djOe6GiIjoXgw3TVSfu+NuLt3OQV4JVysmIiKqwnDTRLnZmMLHwRwqATgTlyV2OURERI0Gw00TVtU1xSnhRERE/6pTuPnhhx/Qp08fuLm54datWwCAkJAQ/Pbbb3otju6valDxCQ4qJiIiUtM53Kxbtw7BwcEYPnw4cnJyoFRWrrNiY2ODkJAQfddH99HT1w4AEJ2Sj4yCUpGrISIiahx0DjdfffUVNm7ciPfeew8ymUx9vFu3boiMjNRrcXR/9hYKtHO1AgC88r/z+PZoHGJS8yEIgsiVERERicdI1wvi4+PRpUuXascVCgUKCwv1UhRpb3SAG6Lu5OHszWycvZkN7I5CZw9r/PJKbxjLOKSKiIiaH52//Xx8fBAREVHt+N69e9GuXTt91EQ6eGlAS/z9en8sHNEO/Vs7QiaV4NLtXMSk5otdGhERkSh0brkJDg7GrFmzUFJSAkEQcObMGfz0009Yvnw5vv322/qokR6gtbMlWjtb4oV+vnh6/UmcuZmFayn56OBmLXZpREREDU7ncPPCCy/A1NQUCxcuRFFRESZNmgQ3NzesXr0azzzzTH3USDpo42KpDjdERETNkc7hBgAmT56MyZMno6ioCAUFBXByctJ3XVRHbV0tAVTOoCIiImqOdB5z8+ijjyInJwcAYGZmpg42eXl5ePTRR/VaHOmurUtluGHLDRERNVc6h5tDhw6hrKys2vGSkhIcPXpUL0VR3bV2rgw3KXklyC3inlNERNT8aN0tdenSJfV/X716FSkpKeqflUol9u7dC3d3d/1WRzqzNDGGu40pknKKEZ2ShyBfe7FLIiIialBah5uAgABIJBJIJJIau59MTU3x1Vdf6bU4qpu2LpZ3w00+ww0RETU7Woeb+Ph4CIIAX19fnDlzBo6Ojurn5HI5nJycNFYsJvG0cbFEWHQaBxUTEVGzpHW48fLyAgCoVKp6K4b0o416UHGeyJUQERE1vDpNBQcqx90kJCRUG1w8atSohy6KHk5bl8r9pmJSCyAIAiQSicgVERERNRydw01cXBzGjBmDyMhISCQS9SaNVV+gVbuEk3h8Hc1hLJOgoLQCt7OL4WlnJnZJREREDUbnqeCvvfYafHx8kJaWBjMzM1y5cgVHjhxBt27dcOjQoXookXRlLJOipaMFAK53Q0REzY/O4ebkyZNYtmwZHBwcIJVKIZVK0bdvXyxfvhxz586tjxqpDtSL+XEDTSIiamZ0DjdKpRKWlpVfnA4ODkhOTgZQOeD42rVr+q2O6qzN3XE3nDFFRETNjc5jbjp27IiLFy/Cx8cHQUFB+OSTTyCXy7Fhwwb4+vrWR41UB205Y4qIiJopncPNwoULUVhYCABYtmwZnnjiCfTr1w/29vYIDQ3Ve4FUN1XTwePSC1FaoYTCiGsQERFR86BzuBkyZIj6v/38/BAdHY2srCzY2tpyynEj4mptAksTI+SXVOBGWiHau1mJXRIREVGD0HnMzYwZM5CfrzmOw87ODkVFRZgxY4beCqOHI5FI7hlUzK4pIiJqPnQON1u3bkVxcXG148XFxfj+++/1UhTpR1XX1JGYDFxOykVqXgkqlFxhmoiIDJvW3VJ5eXkQBAGCICA/Px8mJibq55RKJfbs2QMnJ6d6KZLqpmql4p0XkrDzQhIAwFwuw//N7IkATxsRKyMiIqo/WocbGxsb9a7grVu3rva8RCLB0qVL9VocPZyRnd1wKi4TcemFSC8oRWZBKQrLlHh/12X8NqsPpFKOkSIiIsOjdbg5ePAgBEHAo48+il9++QV2dnbq5+RyOby8vODm5lYvRVLdWJsZY82kruqf0/NLMfCzQ4hMysUv4bcxvpuniNURERHVD63DzYABAwAA8fHxaNGiBWdGNUGOlgrMedQPy/+Kxif7rmFYJ1dYKOq8dyoREVGjpPOA4qioKBw/flz989q1axEQEIBJkyYhOztbr8WR/k3r4w0vezOk55fi64OxYpdDRESkdzqHm7feegt5eZVTiyMjIxEcHIzhw4cjPj4ewcHBei+Q9EthJMN7w9sBAL49Go+EzCKRKyIiItIvncNNfHw82rdvDwD45ZdfMHLkSHz88cdYu3Yt/vrrL70XSPr3WHtn9PVzQJlShY/3RIldDhERkV7pHG7kcjmKiir/tX/gwAE8/vjjACoX8qtq0aHGTSKRYOETla03+66moLC0QuSKiIiI9Efn0aR9+/ZFcHAw+vTpgzNnzmDbtm0AgJiYGHh4eOi9QKofbV2s4GAhR0ZBGW6kF6Czh43YJREREemFzi03a9asgZGREXbs2IF169bB3d0dAPDXX39h6NChei+Q6o+fkwUA4HpqgciVEBER6Y/OLTctWrTAn3/+We34F198oZeCqOH4OVngVFwWYtMZboiIyHDo3HJDhqOVU+XeU2y5ISIiQ9Iows3atWvh7e0NExMTBAUF4cyZM/c9PycnB7NmzYKrqysUCgVat26NPXv2NFC1hqPV3W6p2LT8B5xJRETUdIi+PO22bdsQHByM9evXIygoCCEhIRgyZAiuXbtW40acZWVleOyxx+Dk5IQdO3bA3d0dt27dgo2NTcMX38T5OVeGm4SsIpSUK2FiLBO5IiIioocnerhZtWoVZs6cienTpwMA1q9fj927d2PTpk2YP39+tfM3bdqErKwsnDhxAsbGxgAAb2/vhizZYDhaKGBlYoS8kgrEZxSinauV2CURERE9NFG7pcrKynD+/HkMHjxYfUwqlWLw4ME4efJkjdf8/vvv6NWrF2bNmgVnZ2d07NgRH3/8MZRKZa2vU1pairy8PI0HVa5308r57ribNI67ISIiw1CncHPnzh1s2LABo0ePxrx58/DPP//cN1zUJiMjA0qlEs7OzhrHnZ2dkZKSUuM1cXFx2LFjB5RKJfbs2YP3338fn3/+OT788MNaX2f58uWwtrZWPzw9uRt2FfW4m1SOuyEiIsOgdbiJjIzERx99hO7du8PHxwfbtm1D3759UV5ejmnTpsHR0RGTJ0/Gtm3b6rVlRKVSwcnJCRs2bEBgYCAmTJiA9957D+vXr6/1mgULFiA3N1f9SExMrLf6mhr1WjdsuSEiIgOh1ZibL774AkuWLMGwYcMwb948DB8+HLa2turn165di/DwcPz+++9YuXIlpk6dipKSkgfe18HBATKZDKmpqRrHU1NT4eLiUuM1rq6uMDY2hkz27+DXdu3aISUlBWVlZZDL5dWuUSgUUCgU2rzVZsdPPWOK4YaIiAyDVi03kydPRkZGBkJDQzF58mSNYFOla9euWLJkCcLDwxEbG6vVi8vlcgQGBiIsLEx9TKVSISwsDL169arxmj59+iA2NhYqlUp9LCYmBq6urjUGG7q/qjE38RmFKFeqHnA2ERFR46dVuHFyclLPTNKGLntMBQcHY+PGjdi6dSuioqLwyiuvoLCwUD17asqUKViwYIH6/FdeeQVZWVl47bXXEBMTg927d+Pjjz/GrFmztH5N+pebtQnM5TJUqATcyiwUuxwiIqKHprep4NnZ2fjjjz8wZcoUna6bMGEC0tPTsWjRIqSkpCAgIAB79+5VDzJOSEiAVPpvBvP09MS+ffvw+uuvo3PnznB3d8drr72Gd955R19vpVmRSCTwc7LAxdu5uJ5aAL+7qxYTERE1VRJBEAR93OjixYvo2rVrnWZNNbS8vDxYW1sjNzcXVlZc2yV4ewR+DU/CG4+1xpxBrcQuh4iIqEbafn9r3XLzoBlQ+fmcStxUqfeY4qBiIiIyAFqHGxsbG0gkklqfFwThvs9T49WK08GJiMiAaB1uLC0t8d577yEoKKjG569fv46XXnpJb4VRw2l1d4+pG+kFUKoEyKQMqURE1HRpHW66du0KABgwYECNz9vY2EBPw3eogXnYmkFhJEVphQq3s4vgZW8udklERER1pvUKxZMmTYKJiUmtz7u4uGDx4sV6KYoalkwqga/j3a6pVHZNERFR06a32VJNCWdLVTf3pwv4/WIyhndyQa+WDgAAVysTDG7v/IAriYiIGobeZ0uRYWvjYglcBPZEpmBP5L+blv40syd6tbQXsTIiIiLdMNwQAGBCd08kZBYht7gcABCTmo+4jEIcupbGcENERE2KVuFGKpXWaZr34sWLsWjRIp2vo4bnYKHAynGd1T//FpGE10IjcCw2Q8SqiIiIdKdVuImPj6/TzW1sbOp0HYmv991xN1eS85BZUAp7C+6qTkRETYNW4cbLy6u+66BGxtFSgbYulohOyceJG5kY6e8mdklERERa0XoqODU/ff0qW2+Os2uKiIiaEIYbqlXfVpXh5uj1DC7QSERETQbDDdWqh48djGUSJOUUIyGrSOxyiIiItMJwQ7UykxuhawtbAJWtN0RERE2BVuHGzs4OGRmVX24zZsxAfn5+vRZFjQfH3RARUVOjVbgpKytDXl4eAGDr1q0oKSmp16Ko8agad3PiRiaUKo67ISKixk+rqeC9evXC6NGjERgYCEEQMHfuXJiamtZ47qZNm/RaIImrk7s1LE2MkFtcjivJuejsYSN2SURERPelVcvN//73PwwfPhwFBQWQSCTIzc1FdnZ2jQ8yLEYyKXr5Vm6/wHE3RETUFGjVcuPs7IwVK1YAAHx8fPDDDz/A3p77DTUXfVs54O+rqTh2PQOzBvqJXQ4REdF96TxbKj4+nsGmmenfyhEAcDo+E4mcEk5ERI1cnaaCHz58GCNHjoSfnx/8/PwwatQoHD16VN+1USPh7WCO/q0doRKA747VbZ8xIiKihqJzuPnf//6HwYMHw8zMDHPnzlUPLh40aBB+/PHH+qiRGoGX+vsCALadTUR2YZnI1RAREdVOIui4rn67du3w4osv4vXXX9c4vmrVKmzcuBFRUVF6LbA+5OXlwdraGrm5ubCyshK7nCZBEASM+PIYrt7Jw5uPt8bsR1uJXRIRETUz2n5/69xyExcXh5EjR1Y7PmrUKMTHs8vCUEkkErw0oLL1ZsuJWygpV4pcERERUc10Djeenp4ICwurdvzAgQPw9PTUS1HUOA3v5Ao3axNkFJRi54UkscshIiKqkVZTwe/1xhtvYO7cuYiIiEDv3r0BAMePH8eWLVuwevVqvRdIjYexTIoZfX3w4e4obDwahwndPCGVSsQui4iISIPO4eaVV16Bi4sLPv/8c2zfvh1A5Ticbdu24cknn9R7gdS4PNOjBVaHXUdceiEORKXi8Q4uYpdERESkQecBxYaAA4ofzsq90Vh36Abaulhi99x+kLH1hoiIGkC9DSgmeqm/L6xMjBCdks+xN0RE1Ogw3JDObMzk6m0YPv/7GmdOERFRo8JwQ3Uytbc33G1McSe3BJuP3xS7HCIiIjWGG6oTE2MZ3ni8NQDg60OxXLWYiIgaDZ3DzcGDB+ujDmqCRge4o52rFfJLKrDmYKzY5RAREQGoQ7gZOnQoWrZsiQ8//BCJiYn1URM1EVKpBO8ObwsA+P7kTSTlFItcERERUR3CTVJSEmbPno0dO3bA19cXQ4YMwfbt21FWxm6J5qhfK0f08rVHuVLAJu4YTkREjYDO4cbBwQGvv/46IiIicPr0abRu3Rqvvvoq3NzcMHfuXFy8eLE+6qRGrGrPqdAzCcgtLhe5GiIiau4eakBx165dsWDBAsyePRsFBQXYtGkTAgMD0a9fP1y5ckVfNVIjN6C1I9o4W6KwTIkfTyeIXQ4RETVzdQo35eXl2LFjB4YPHw4vLy/s27cPa9asQWpqKmJjY+Hl5YXx48fru1ZqpCQSCWb2r2y92Xw8HqUVXPeGiIjEo3O4mTNnDlxdXfHSSy+hdevWuHDhAk6ePIkXXngB5ubm8Pb2xmeffYbo6Oj6qJcaqVH+bnC2UiAtvxS/RySLXQ4RETVjOoebq1ev4quvvkJycjJCQkLQsWPHauc4ODhwyngzIzeSYnofHwDAxqNxaIZblhERUSOhc7hZvHgxxo8fD4VCoXG8oqICR44cAQAYGRlhwIAB+qmQmoxJQS1goTBCTGoBDsWk13hOSbmS3VZERFSvdA43AwcORFZWVrXjubm5GDhwoF6KoqbJysQYz3T3BACsO3ijWutNSbkSI786hoGfHkJRWYUYJRIRUTOgc7gRBAESiaTa8czMTJibm+ulKGq6nu/nA7mRFGduZuHgtTSN5zYdj8f1tAIk55bg/K1skSokIiJDZ6TtiWPHjgVQOTNm2rRpGt1SSqUSly5dQu/evfVfITUprtammN7HG98cjsPyPdHo38oRRjIpsgrLsO7gDfV5Z+Kz0K+Vo4iVEhGRodI63FhbWwOobLmxtLSEqamp+jm5XI6ePXti5syZ+q+QmpxXH/HDtrOJuJ5WgF/Cb2NC9xb46p/ryC+tgJFUggqVgNPx1bs2iYiI9EHrcLN582YAgLe3N9588012QVGtrE2NMXugHz7cHYVV+2Pg72mD/526BQBYPLI93v/tCiISc1BSroSJsUzkaomIyNDUabYUgw09yHO9vOBha4rUvFI8s+EUypUC+rd2xLM9veBgoUBZhQqXbueKXSYRERkgrVpuunbtirCwMNja2qJLly41DiiuEh4errfiqOlSGMnw1pA2eC00AjlF5ZBIgPlD20IikSDIxw67I+/gTHwmevjYiV0qEREZGK3CzZNPPqkeQDx69Oj6rIcMyMjObvj2aDwik3IxtosH2rtZAQB63A03p+OzMFvkGomIyPBIhGa4lGxeXh6sra2Rm5sLKysrscsxaAmZRdgRfhvP9/WBtakxACA6JQ9DQ47CTC7DxcWPw1j2UPu3EhFRM6Ht9ze/VahetbA3Q/BjrdXBBgBaO1nC2tQYRWVKXEnOE7E6IiIyRFp1S9na2t53nM29alq9mOheUqkE3b3tcCAqFWfiMxHgaSN2SUREZEC0CjchISH1XAY1N0E+VeEmCy/2byl2OUREZEC0CjdTp06t7zqomQnyrZwldSY+CyqVAKlUu5ZBIiKiB9Eq3OTl5akH7uTl3X+MBAfokjbau1rBXC5DXkkFrqXmo50r/78hIiL90HrMzZ07d+Dk5AQbG5sax99UbaipVCr1XiQZHiOZFIHedjgSk47TcZkMN0REpDdahZt//vkHdnaV3QgHDx7UexFr167Fp59+ipSUFPj7++Orr75Cjx49HnhdaGgoJk6ciCeffBK7du3Se11Uv4J8KsPNqv0xuJFeiLFd3RHgWXN4JiIi0pbo69xs27YNU6ZMwfr16xEUFISQkBD8/PPPuHbtGpycnGq97ubNm+jbty98fX1hZ2enU7jhOjeNQ0JmESZuPIWknGL1sbYulvh+Rg84WZmIWBkRETVG2n5/1yncZGdn47vvvkNUVBQAoH379pg+fbq6dUcXQUFB6N69O9asWQMAUKlU8PT0xJw5czB//vwar1Eqlejfvz9mzJiBo0ePIicnh+GmiVKqBByPzcDOC0nYezkFxeVKvDTAFwuGtRO7NCIiamTqbRG/I0eOwNvbG19++SWys7ORnZ2NL7/8Ej4+Pjhy5IhO9yorK8P58+cxePDgfwuSSjF48GCcPHmy1uuWLVsGJycnPP/881q9TmlpKfLy8jQe1DjIpBL0b+2ILyYEYNXT/gCAPyKSoVI1u4WziYhIT7Qac3OvWbNmYcKECVi3bh1kMhmAypaUV199FbNmzUJkZKTW98rIyIBSqYSzs7PGcWdnZ0RHR9d4zbFjx/Ddd98hIiJC69dZvnw5li5dqvX5JI6BbZ1gqTBCcm4Jzt3K5qaaRERUJzq33MTGxuKNN95QBxsAkMlkCA4ORmxsrF6L+6/8/Hw899xz2LhxIxwcHLS+bsGCBcjNzVU/EhMT67FKqisTYxmGdnQBAPwWkSRyNURE1FTp3HLTtWtXREVFoU2bNhrHo6Ki4O/vr9O9HBwcIJPJkJqaqnE8NTUVLi4u1c6/ceMGbt68iZEjR6qPqVQqAICRkRGuXbuGli2rr3arUCjUu5pT4/ZkgDt+Pn8buyPvYPHIDpAbcfszIiLSjVbh5tKlS+r/njt3Ll577TXExsaiZ8+eAIBTp05h7dq1WLFihU4vLpfLERgYiLCwMIwePRpAZVgJCwvD7Nmzq53ftm3bat1eCxcuRH5+PlavXg1PT0+dXp8an14t7eFgoUBGQSmOXk/HoHbOD76IiIjoHlrNlpJKpZBIJHjQqXVZxG/btm2YOnUqvvnmG/To0QMhISHYvn07oqOj4ezsjClTpsDd3R3Lly+v8fpp06ZxtpSBWfrHFWw+fhOj/N3w5cQuYpdDRESNhLbf31q13MTHx+utsP+aMGEC0tPTsWjRIqSkpCAgIAB79+5VDzJOSEiAVMquieZkdIA7Nh+/if1XU1FYWgFzhc69p0RE1IyJvoifGNhy07gJgoCBnx3CzcwihEwIwOgu7mKXREREjYBeW25qcvXqVSQkJKCsrEzj+KhRo+p6SyIAld2bowLc8WXYdfx8PhEj/d0g467hRESkJZ3DTVxcHMaMGYPIyEiNcThV+wFx40zShycD3PBl2HUcj83EsNVHsGBYOzzSxpH7ThER0QPpPJjltddeg4+PD9LS0mBmZoYrV67gyJEj6NatGw4dOlQPJVJz1NLRAiuf6gRrU2PEpBZg+pazmPztacRnFIpdGhERNXI6h5uTJ09i2bJlcHBwgFQqhVQqRd++fbF8+XLMnTu3PmqkZmpC9xY48tZAvNjfF3KZFCduZGLSxlNIvmejTSIiov/SOdwolUpYWloCqFyELzk5GQDg5eWFa9eu6bc6avaszYzx7vB2CHtjAPycLHAntwTPfXca2YVlD76YiIiaJZ3DTceOHXHx4kUAlTt6f/LJJzh+/DiWLVsGX19fvRdIBACedmb4fkYPuFqb4EZ6IaZvOYuisgqxyyIiokZI53CzcOFC9ZYHy5YtQ3x8PPr164c9e/bgyy+/1HuBRFXcbEzx/YwesDEzRkRiDl7+XziU3D2ciIj+Qy/r3GRlZcHW1rbJzGThOjdNW3hCNiZvPI3iciW2TO+OR9o4iV0SERE1AG2/vx9q6d/ExEQkJibCzs6uyQQbavq6trBV7x5+6XauyNUQEVFjo3O4qaiowPvvvw9ra2t4e3vD29sb1tbWWLhwIcrLy+ujRqJqOrhVJvbLSQw3RESkSedF/ObMmYNff/0Vn3zyCXr16gWgcnr4kiVLkJmZiXXr1um9SKL/6uhuDQC4kpwnciVERNTY6BxufvzxR4SGhmLYsGHqY507d4anpycmTpzIcEMNov3dlpuknGJkFZbBzlwuckVERNRY6NwtpVAo4O3tXe24j48P5HJ+wVDDsDIxhre9GQDgSjK7poiI6F86h5vZs2fjgw8+QGlpqfpYaWkpPvroI8yePVuvxRHdT4e7XVOXk9g1RURE/9KqW2rs2LEaPx84cAAeHh7w9/cHAFy8eBFlZWUYNGiQ/iskqkVHN2vsvnQHl9lyQ0RE99Aq3FhbW2v8/NRTT2n87Onpqb+KiLTU0b1y3M0VzpgiIqJ7aBVuNm/eXN91EOmsg1tl6L6ZWYS8knJYmRjXeF5haQVKK1QcdExE1EzUeRG/9PR0HDt2DMeOHUN6ero+ayLSip25HO42pgCAq7VMCRcEAZO+PY1uH+7Hl2HXuV0DEVEzoHO4KSwsxIwZM+Dq6or+/fujf//+cHNzw/PPP4+ioqL6qJGoVlWL+dW23k14Qg4uJuZAJQCr9sdg8renkJJb0pAlEhFRA9M53AQHB+Pw4cP4448/kJOTg5ycHPz22284fPgw3njjjfqokahW6sX8ahl3s/PCbQBAe1crmMllOBWXhWGrj+BEbEaD1UhERA1L53Dzyy+/4LvvvsOwYcNgZWUFKysrDB8+HBs3bsSOHTvqo0aiWlUNKq5pxlRZhQp/XroDAFgwvC3+nNMXHdyskF1Ujjd+vggVu6iIiAySzuGmqKgIzs7O1Y47OTmxW4oaXMe7g4pj0wpQXKbUeO7gtTTkFJXD2UqB3i0d4OtogR0v94aliRHu5JbgzM0sMUomIqJ6pnO46dWrFxYvXoySkn/HLRQXF2Pp0qXqvaaIGoqTlQkcLRVQCUBUiua4m1/DK7ukRge4Qyat3LXeVC7DsLs7iv8WkdywxRIRUYPQOdyEhITg+PHj8PDwwKBBgzBo0CB4enrixIkTWL16dX3USHRfHd2qr3eTU1SGf6LTAABjurprnP9kQOXPeyLvoKxC1UBVEhFRQ9F548xOnTrh+vXr+L//+z9ER0cDACZOnIjJkyfD1NRU7wUSPUhHd2scvJausQ3Dn5fuoFwpoJ2rFdq6WGmc39PXHk6WCqTll+JwTDoea1+9m5WIiJouncJNeXk52rZtiz///BMzZ86sr5qIdFK1mN/hmHQcjklH/1YO6i6pp/7TagMAMqkEI/3d8N2xePwWkcRwQ0RkYHTqljI2NtYYa0PUGHTztoWZXIaUvBJM3XQGQ0KOIDwhB1IJMMrfrcZrngyoPH4gKhUFpRUNWS4REdUzncfczJo1CytXrkRFBb8QqHFwsFDg79f7Y3ofb5jJZYhJLQAA9G3lCCcrkxqv6eRuDV8Hc5SUq7D/akpDlktERPVMIgiCTot9jBkzBmFhYbCwsECnTp1gbm6u8fyvv/6q1wLrQ15eHqytrZGbmwsrK6sHX0BNRk5RGf7vdAKOx2ZgwbB26ORhXeu5IQdiEHLgOga0dsTWGT0asEoiIqoLbb+/dR5QbGNjU21XcKLGwsZMjlkD/TBroN8Dz30ywB0hB67jWGwGMgpK4WChaIAKiYiovukcbrhDOBkKHwdz+HtY4+LtXKw+cB3LnuwAiUQidllERPSQtB5zo1KpsHLlSvTp0wfdu3fH/PnzUVxcXJ+1EdW7V++28Pxw6ha+PnRD5GqIiEgftA43H330Ed59911YWFjA3d0dq1evxqxZs+qzNqJ6N6SDCxY90R4A8Om+awg9kyByRURE9LC0HlDcqlUrvPnmm3jppZcAAAcOHMCIESNQXFwMqVTnSVei4oBi+q9P9kbj60M3IJUAS5/sCB/7yoHyUikQ4GkDM7nOPbhERKRn2n5/ax1uFAoFYmNj4enpqT5mYmKC2NhYeHh4PHzFDYjhhv5LEATM/yUS284lVnuuj589/vd8EMfjEBGJTO+zpSoqKmBiorlmiLGxMcrLy+teJVEjIZFI8NGYjrAyNcLR6xnq43EZhTgem4ltZxPxTI8WIlZIRETa0jrcCIKAadOmQaH4d7psSUkJXn75ZY21bprCOjdENTGSSfHeiPYax749GocPd0fhoz1RGNjWCc61LApIRESNh9bhZurUqdWOPfvss3othqixmdbbG79fTMal27lY/NsVrH8uUOySiIjoAXReodgQcMwN6eJqch5GrTmGCpWA9c92xdCOrmKXRETULGn7/d20pjkRiaC9mxVeGuALAHj/tyvIKSoTuSIiIrofhhsiLcx5tBV8Hc2Rnl+Kmd+fQ0m5UuN5lUpA5O1clFYoa7kDERE1FIYbIi2YGMvw9eSusDQxwtmb2Zj94wVUKFUAgLT8EkzdfAYj1xzD8j3RIldKREQMN0Raautihe+mdofCSIoDUal4d2ckDsekY/jqo+rp47siklB+N/QQEZE4GG6IdNDDxw5rJnWFVAJsP3cbUzedQUZBGdq6WMLWzBg5ReU4FZcpdplERM0aww2Rjh5r74zlYzupf362ZwvsmtVHPYtqT+QdsUojIiLosM4NEf1rQvcWcLcxg5FMgp6+9gCAEZ1c8dOZBOy7kooPnlTBSMZ/OxARiYG/fYnqqG8rB3WwAYCevnawM5cjq7AMp+OzRKyMiKh5Y7gh0hMjmRRDOjgDAHaza4qISDQMN0R6NOzuuJt9l1PUU8WJiKhhMdwQ6VGvlvawMTNGZmEZzrBriohIFAw3RHpkLJNiSHsXAMCey9p1Tf1xMRlrD8ZCpWp227wREdULhhsiPRvWqTLc7L2c8sAF/baeuIk5P13Ap/uu4Z/otIYoj4jI4DHcEOlZHz8HWJsaI6OgDH1W/IOP90QhOiWv2nnfn7yJxb9fUf/845mEhiyTiMhgSQRBaHZt4dpumU5UV79fTMai3y4jp6hcfaylozn6tXLEgNaOiM8oxLI/rwIAnurqgV/Cb0MiAY6+PRAetmZilU1E1Khp+/3NRfyI6sEofzcM7eCCg9fS8Gv4bfwTnYYb6YW4kV6ILSduqs97qb8v5g9ri5S8YhyPzcS2s4l44/E24hVORGQAGG6I6oncSIohHVwwpIMLcovLcSI2A0euZ+BITDqScorx8oCWeGdoG0gkEkwO8sLx2EyEnk3E3EGtYMzVjYmI6ozhhqgBWJsaY1gnVwzr5ApBEFBQWgFLE2P184+1d4ajpQLp+aU4cDUVwzq5ilgtEVHT1ij+ebh27Vp4e3vDxMQEQUFBOHPmTK3nbty4Ef369YOtrS1sbW0xePDg+55P1NhIJBKNYANUTiF/upsHAA4sJiJ6WKKHm23btiE4OBiLFy9GeHg4/P39MWTIEKSl1Twt9tChQ5g4cSIOHjyIkydPwtPTE48//jiSkpIauHIi/Xqme4vKQcXXM3Azo1DscoiImizRZ0sFBQWhe/fuWLNmDQBApVLB09MTc+bMwfz58x94vVKphK2tLdasWYMpU6Zo9ZqcLUWN1bTNZ3DoWjpe6u+LBcPbaTwnCAJe+V84MgtL8f2MIJjKZSJVSUQkDm2/v0VtuSkrK8P58+cxePBg9TGpVIrBgwfj5MmTWt2jqKgI5eXlsLOzq/Wc0tJS5OXlaTyIGqNJPVoAAHZFJOG//+64nlaAvVdScPZmNn44dVOE6oiImgZRw01GRgaUSiWcnZ01jjs7OyMlJUWre7zzzjtwc3PTCEj/tXz5clhbW6sfnp6eD1U3UX0Z0MYR5nIZUvNKcTlJM4SHRf3bVbvu0A3kl5T/93IiIkIjGHPzMFasWIHQ0FDs3LkTJiYmtZ63YMEC5Obmqh+JiYkNWCWR9hRGMvRr5QgA2B+VqvHcwbvbM0glQHZROTYdu9nQ5RERNQmihhsHBwfIZDKkpmr+Ek9NTYWLi8t9r/3ss8+wYsUK/P333+jcufN9z1UoFLCystJ4EDVWg9tXtmQeuPrv34ucojKcu1W5y/g7Q9sCADYejUN2YVnDF0hE1MiJGm7kcjkCAwMRFhamPqZSqRAWFoZevXrVet0nn3yCDz74AHv37kW3bt0aolSiBjOwjSOkEuDqnTwk5RQDAA7HpEMlAG1dLDGzny/auVqhoLQC64/cELlaIqLGR/RuqeDgYGzcuBFbt25FVFQUXnnlFRQWFmL69OkAgClTpmDBggXq81euXIn3338fmzZtgre3N1JSUpCSkoKCggKx3gKRXtlbKBDoZQsACLvbNVW1Y/jAtk6QSiV48/HWACp3FU/LKxGnUCKiRkr0cDNhwgR89tlnWLRoEQICAhAREYG9e/eqBxknJCTgzp076vPXrVuHsrIyjBs3Dq6ururHZ599JtZbINK7Qe3udk1FpaFCqcKha+mVx9s6AQAebeuELi1sUFKuwqr9MaLVSUTUGIm+zo0YuM4NNXaxaQUYvOowjGUSbHiuG6ZvOQsbM2OcX/gYZFIJAOB0XCYmbDgFANjwXCAe73D/cWpERE1dk1jnhohq1tLRHD4O5ihXCvhw91UAwCOtHdXBBgCCfO0xs58PAODtXy7hTm6xKLUSETU2DDdEjZBEIsHgdpVdUDfSK7diGHi3S+pebw1pi07u1sgpKsdroRFQqppdQywRUTUMN0SNVNW4GwCQSSUY0Nqx2jlyIym+mtgF5nIZzsRnYc0/sQ1ZIhFRo2QkdgFEVLNuXrawNjVGbnE5AlvYwsZMXuN53g7m+HBMR7y+7SK+OBCDH07dgoOFHI6WCpjJZZCgsivLSCbBC/18EeBp04Dvgoio4THcEDVSRjIphnV0QejZRAzrdP/BwmO6eOBiYi62nLiJjIJSZBSUIjolv9p5525mY9/r/WFtalxfZRMRiY6zpThbihqxgtIKnLqRiUfvrm/zIOn5pUjNK0FGQSnS80tRUqFSP/fd0TjczCzC2K7uWPV0QD1WTURUP7T9/mbLDVEjZqEwUm/HoA1HSwUcLRU1Ptfe1RLj15/Er+FJGNLBBUM4dZyIDBQHFBM1E4Fednixf0sAwLu/RiKjoFTkioiI6gfDDVEz8vpjrdDWxRKZhWV4b2ckmmGvNBE1Aww3RM2IwkiGz5/2h7FMgn1XUvHq/4Ujt6hc7LKIiPSK4YaomengZo2PRneCsUyCvy6nYPiXR3H+VhYEQUDUnTxsOHIDwdsi8NOZBOQWM/gQUdPD2VKcLUXN1KXbOZjz0wXcyiyCTCqBnbkc6fma43DkRlI81t4ZE7p5on8NiwgSETUkbb+/GW4YbqgZyy8px/u7LmNXRDIAwNRYhp6+dmjraoWwqFTEpBaoz328vTOWPdkRLtYmYpVLRM0cw819MNwQ/UsQBFxIzEFJuRKBXrZQGMnUx68k5+Hnc4n4v9MJqFAJsFQYYf7wtpjYvYVW6+4QEekTw819MNwQ6SY6JQ/zf4lERGIOAGBiD08sH9tZ3KKIqNnR9vubA4qJ6IHauljhl1d6Y+GIdgCA7educ50cImq0GG6ISCsyaeXGm509rKFUCfjjYrLYJRER1Yjhhoh0MqaLOwBg54UkkSshIqoZww0R6WSkvxtkUgku3c5FbFrBgy8gImpgDDdEpBMHCwUeubvmzc4Lt9XHi8oq8OTa43j080PIKiwTqzwiIoYbItLdmK6VXVO7LiRDpaqccLnsj6u4mJiDuPRCvL3jIvetIiLRMNwQkc4Gt3OGpcIISTnFOB2fhT8vJSP0bCIkEkAuk+JAVBq2nLgpdplE1Ewx3BCRzkyMZRjeyRUAsP7wDSz4NRIA8OojLfHe3eniy/dE40pybp1fgy0/RFRXDDdEVCdVXVOHY9KRX1KBLi1sMG9wa0zp5YXB7ZxRplRhzk8XUFRWofO93/z5Irp+sB+Rt+sejoio+WK4IaI66eFtB3cbUwCApYkRvnymC4xlUkgkEnw6rjNcrEwQl16I5747g4t3VzbWxrHrGdhx/jayi8rx8v/OI5uDk4lIRww3RFQnUqkErzzSEpYKI3w23h+edmbq52zN5Vj9TABMjKU4fysbT649jjk/XcC1lHzEpObjRGwGfr+YjLh0zankFUoVlv15pfL+EiAppxivbYuAUsUuKiLSHveW4t5SRA9FEARIJDVvopmUU4zP/76GnReSUNNvGmOZBOsmB2Jwe2cAwA8nb+L9367AxswY658NxLTNZ1BSrsLcR/0Q/Hib+nwbRNQEcG8pImoQtQUbAHC3McWqpwPw55y+6NfKAVIJYGNmDD8nC/g5WaBcKeCV/zuPsKhU5BaVY9X+GABA8GOt0dPXHsvHdgIAfPlPLA5cTW2Q90NETR9bbthyQ9RgVCoBUmllGKpQqvBaaAR2R96BXCZFdx9bHI/NRGtnC+yZ2w9Gssp/ey3+7TK2nrwFY5kE7wxtixl9fNT3AIArybkoKVch0MtWlPdERA1H2+9vowasiYiauXtDiZFMipBnAqASBPx1OQXHYzMBAO8/0V4dbADgvRHtkV5Qij2RKfhwdxSOxWbgs/H+iLydi2+O3MCpuCwAwPaXeqGHj13DviEiapTYcsOWGyJRlStVmPPjBey9koLH2ztjw5Ru1c4RBAH/dzoBy/68irIKFYykElT8Z5BxD287bHup5327yYioadP2+5vhhuGGSHQVShUuJObA38MGcqPahwJGp+Rh9o8XEJtWAAuFESb28MSwTq54ZsMplFWosHVGDwy4u++VNpQqATIpwxBRU8Fwcx8MN0RNV3GZEifjMtDN2w5WJsYAgA//vIpvj8Wjk7s1fp/dp9bWmwsJ2Th4LR3Rd/IQlZKHpOxiPNrWCSue6gwHC0VDvg0iqgOGm/tguCEyLJkFpej/yUEUlimx/tmuGNrRVeP53KJyLP8rCqFnE2u83tFSgZAJAejj59AQ5RJRHXEqOBE1G/YWCszo6wMA+PzvGPWif4Ig4K/IOxj8xWF1sBnRyRWLnmiPH2cG4ddXe6O1swXS80vx7Hen8cneaJRVqER7H0SkH2y5YcsNkUHILS5H/08OIre4HEM7uCC3uBzRKXnILioHAPg6mmPF2M7VZlQVlymx7M+r+OlMAgCgjbMlVjzVCV1acGo5UWPDbqn7YLghMkxfH4rFJ3uvaRyTG0nxUn9fzBroBxNjWa3X7om8g4W7LiOrsAwSCTC1lzfeGtIG5gqumEHUWDDc3AfDDZFhKilX4tN916ASBLRztUJ7Vyv4OVncN9TcK6uwDB/uvopfw5MAAG1dLPHnnL4a6+4QkXgYbu6D4YaI7udITDrmhl5ATlE5vpzYBaP83TSev51dhIjEHAR62cLV2lSkKomaH65QTERUR/1bO2JGHx+s2h+DDUduYGRnV/X08pJyJSZtPI2ErCIAQGtnC/Rr5YhxgR5o58p/LBE1BmxrJSKqwbM9vWBiLMXlpDycvJGpPv7dsXgkZBVBYSSFVALEpBbgu2PxeHLtcfx9JUXr+2cUlOLo9XTsupCE0gplfbwFomaLLTdERDWwM5fj6W6e+P7kLWw4Gofefg5IzSvB2oOxAIAVT3XCwDZOOB6biZ/OJOBYbAZe/t95rBjbGU9396zxnpdu52DtwViEJ+QgPb9UfXz/VVd8NbGLxt5bRFR3bLkhIqrF8319IJUAh66l41pKPj7Zew1FZUoEeNrgSX932JjJMaKzK7ZM747xgR5QCcDbv1zCukM31GvtAEBiVhHm/nQBo9Ycx74rqUjPL4VEAvg4mMNYJsHuyDsIORCjdV0qlYCPdl/F539fQzMcNkn0QGy5ISKqhZe9OYZ2dMGeyBQs+PUSwhNyAACLR7avtsP5J+M6w85Cjm8Ox2Hl3mh8si8a9uZyOFgoEJdeiDKlChIJMCbAHZN7eqGtiyXMFUb4+Vwi3tpxCV/+E4uWThZ4MsAdSpWA/VdT8FtEMkZ3cceQDi4adf3v9C1sPBoPAJBJJZg3uHWd36NKJUC4ex8iQ8FwQ0R0HzP7+WJPZIo62Izt4l7jAn8SiQQLhrWDo4UCn/19DSXlKmQUlCGjoAwA0MfPHguGtUNHd2uN68Z380RsegG+ORyHt3ZcQnxGIX6LSEZ8RiEAICwqDT+/3Av+njYAgOScYqz8K1p9fciB6/B1tKg2o0sbKpWAGVvP4mpyHtY/F4iuXLiQDASngnMqOBE9wNPrT+LMzSyYGstw8M1H4GJtct/zlSoBWYVlSM8vRUZBKaxMjeHvYV3rhp4qlYCX/3cef19NVR+zNjWGu40prt7Jg7uNKf6Y0xe2ZsZ4fus5/BOdhkAvWwR42uC7Y/GQG0mx7cWeNYauxKwifPXPdbR1sVJvUVFl+7lEvL3jEgDAUmGE75/vwZWZqVHjVHAiIj15e2gbvPy/cLz+WKsHBhugsovH0VIBR0vtdhqXSiUIeSYAz285h5S8EjzX0wsTuntCKQgY9dUx3MwswmuhF/BUVw/8E50GuUyKlU91go+DBW5mFCIsOg0zvz+Pdc92RRdPGxjJpFCqBGw+Ho/P/45BcXnlbCw3G1MM7VjZxVVQWoFP91Wu5uxgIUdGQRmmfHcGP7wQhIC7rURETRVbbthyQ0SNWHRKHsasPYHiciVkUgmUKgHBj7XG3EGtAFSGlHHrTiA6JR8AYGVihD5+DkjOKcbF27kAAGcrBVLzSmFtaow9r/WDu40pVu6NxrpDN+DjYI6dr/bGi9+fx5mbWbA0McKCYe3gbmsKBws5PGzMYG1mLNr7fxgl5UoojKS1tphR08MViu+D4YaImpLfIpLwWmgEgMqNPf+Y0xdyo38nu97JLcbHe6Jx+Foa8koq1MctTYzw7vB2GNvVHU+vP4mLt3PR3dsWK5/qjKEhR1GmVOHbKd0wuL0zCksrMG3zGZy9ma3x2sYyCT4c3RETurfQ2/sRBAFlShUURtpti1EX525mYdLG0xjS0QUhEwI4YNpAMNzcB8MNETU1n/99DdvPJWLjlG7o7GFT4zlKlYBLt3NwJCYDJRVKTOvtDWerym60W5mFGPHlMRSUVsDOXI6swjL0a+WA72f0ULdsFJRWYPWBGESn5CM9vxTp+aXILCyDkVSC72f0QG8/B/VrxablY9X+GHT3tsOUXt5ah4e0vBLM+jEcV5Pz8PnT/hja0fXhPpgaCIKAMV+fQERiDgBgYo8W+HhMR7bgGACGm/tguCGi5ujeFiCZVIK/XuuH1s6WtZ4vCAJe3xaBXRHJsDIxwq5ZfeDraIGD0WmY+9MF5JdWthL5e1hj+djOaO9W+fs0o6AUp+IyYS6v7CKramWKvJ2Lmd9XjisCAKkE+GhMJ0zsob9WIQA4cDUVL3x/DnIjKSqUKqgEYM6jfnjj8TZ6fR1qeBxQTEREGp4McMex6xn4+fxtTOnldd9gA1ROb1/xVGckZBUhPCEHz289h7Fd3LHqQAwEAejkbo2bmYW4eDsXo9YcwxOdXRGbXoDLSXnqe9iaGWOUvxu8Hcyxcm80SspVaOlojs4eNth5IQkLfo1EVmEZXn2kZY0tK4IgoLhcCTO5dl9XKpWAz/6uHCg9o48PWtiZ4d2dkfjqn1jYm8sxrY/PA+5AhoAtN2y5IaJmRKkScO5mFgK9bGEk026R+oyCUjy55jiScorVxyb28MTSUR2RXVSGxb9dwd7/7KvV1sUSmXenw99rYBtHrJ7YBZYKI3z+dwzW3N3OYmwXd8wd1AreDuYAKkPK7xeT8em+a0jKKYa7jSnauVqhnaslRnR2RVuXmn93/3ExGXN+ugBLhRGOvjMQNmZyfBl2Hav2V64AvXBEOzzf14ddVE0Uu6Xug+GGiEg311Ly8dS6yllb749oh6m9vTUCwv6rqThxIwOdPazRx88BTpYmqFCqcPxGJn4Nv40jMemY0L0F3hrSRmN8zqZj8Vj251UAgEQCDO3ggsc7OOO7Y/EaLUD3kkklmNnPF/MGt4KJ8b+DkiuUKjz+xRHEZRRqzCgTBAHL/ryKzcdvAgDGBXrgozEd6zygubRCWa+Doal2DDf3wXBDRKS7lNwSlFYo4WVvrtf7nr2Zha8PxuLgtXSN4xYKI7zySEuMC/RAfEYhou/k4ej1DIRFpwEAvOzNsOzJjmjtbAEA2Hc5BUv+uAo7czmOvD0QFop/u7IEQcDm4zfx4e6rUAlAoJct1j8bqPVaRFX3+Ozva9h4JB6vDW6FWQP9NJ7PKCjFsj+uwsveDDP7+8LKRHMKfVmFCipB0AhkpBuGm/tguCEianxiUvOx4UgcTsdnYmAbJ8wd1AoOFtXDx99XUrDotyvqgcn/9d7wdpjZ37fG547EpGP2j+HIK6mA3EiKIB879GvlgF6+DhAgIKOgcpaYibEMQzu6qFtoBEHAyr3XsP7wDfW9vpzYRb3tRUFpBSZuOIXIpMq1hWzNjDF3UCtMCmqB8Fs52HnhNvZEpsBYJsEn4/zxWHvnh/qs6qqwtAIKI6nWXZKNDcPNfTDcEBE1bfkl5fhk7zX8Gn4b5cp/v8bauVlh24s979s6EpdegFf/L1y98GFtPGxN8daQNhjZ2Q2f/X0NXx+qDDY9fOxwJj4LciMpQl/siQ5uVpix5SyOx2bCzlwOWzNj3Eiv3BtMbiRFWYWq2r2n9fbG/GFt1XVWKFVIyilWb9mRXlAGWzNj9GnpAFtzuVafiVIlIDIpF/EZBejfyhH2/wmGO87fxns7IyGXSdHbzx79WjliQGtHeNqZaXX/xqBJhZu1a9fi008/RUpKCvz9/fHVV1+hR48etZ7/888/4/3338fNmzfRqlUrrFy5EsOHD9f69RhuiIiaN0EQcCO9AEdiMnD0ejrO38qGqVwGR0sFHCwUiLqTh9S8ysHQHramuJ1dOZh6ycj2eK6XN1764TwORKXCwUKOAE8bHIhKg7lchp9e7In2rlbYfu42Vu2PQUZBKSwVRhjeyRWju7gjLCoV3x6r3NG9nasVOrpZISolDzGpBTWGIIkE6OxujZ4t7QEBSL/bslRaroK9ReWu83bmcsSmFeBYbAZyi8sBVLYcLRzRHmO7ukMlAMv3RKlf979eHtCy2lio/1KpBGQVlcHa1BjGIrb6NJlws23bNkyZMgXr169HUFAQQkJC8PPPP+PatWtwcnKqdv6JEyfQv39/LF++HE888QR+/PFHrFy5EuHh4ejYsaNWr8lwQ0RE91NUVoFNx+Kx7tANFJZV7s216In26s1HC0sr8NQ9214YyyTYPK0H+rb6d6HDwtIKXE8rQFsXS42WpIPRaXjj54vIKizTeE2FkRTOViZwsJDD3kKBxKyiB7Yu/ZeliRFszeRIyCoCAPRr5QCpRILDMZXjmeY+6odH2znj2PV0HI5JV69IPaitE0KeCYDlf8YJ3UgvwM7wJOy8kKSeLWdrZgwHCwXMFEaoikNSSeXSAP1aOaJnS3uN8U761GTCTVBQELp37441a9YAAFQqFTw9PTFnzhzMnz+/2vkTJkxAYWEh/vzzT/Wxnj17IiAgAOvXr9fqNRluiIhIGxkFpfj+xE20dLLAkwHuGs8l5RRj9NrjyCgoxZfPdMHIu+NvtJGaV4ItJ27CWCZFe1dLtHO1gqetGaT/aT1JzSvB0esZOH8rG2ZyGRwsFHCwkMPEWIaswjJkFFR2YzlZmqB/a0f4e1hDALDhSBxWh11XtwaZGEvx2Xh/PNFZs8ZdF5Lw9i+XUFahQisnC7w3oh1uZxcjOiUPEYk5tc5Yux8jqQRdvWzx+uDW6NXSXufr76dJhJuysjKYmZlhx44dGD16tPr41KlTkZOTg99++63aNS1atEBwcDDmzZunPrZ48WLs2rULFy9e1Op1GW6IiEgfcovLkV1Ypl6fpzGJSy/Akj+uIiW3GKueDkBHd+saz7uYmIOZ359D2n/WJAIqp90/0toRY7q6Y1BbZxSXK9Vbc5Tc3W0eAIrKlTgTn4mj1zNwK7Oy1Wjbiz0R5CtOuBF1heKMjAwolUo4O2uOGnd2dkZ0dHSN16SkpNR4fkpKSo3nA0BpaSlKS//9Q8vL0z2JEhER/Ze1qTGsTRvnrum+jhb4fkbt41er+Hva4I85ffH2jkuISc1Ha2dL9YKJffwcNGasmcplsDOXo41L9dWtq2aO3cosxNHrGejSwlZ/b0ZHzWL7heXLl2Pp0qVil0FERNQoOVuZYKsWQUgbXvbmel8LSVeiTnR3cHCATCZDamqqxvHU1FS4uLjUeI2Li4tO5wPAggULkJubq34kJiY+fPFERETUKIkabuRyOQIDAxEWFqY+plKpEBYWhl69etV4Ta9evTTOB4D9+/fXej4AKBQKWFlZaTyIiIjIMIneLRUcHIypU6eiW7du6NGjB0JCQlBYWIjp06cDAKZMmQJ3d3csX74cAPDaa69hwIAB+PzzzzFixAiEhobi3Llz2LBhg5hvg4iIiBoJ0cPNhAkTkJ6ejkWLFiElJQUBAQHYu3evetBwQkICpNJ/G5h69+6NH3/8EQsXLsS7776LVq1aYdeuXVqvcUNERESGTfR1bsTAqeBERERNj7bf301z5ywiIiKiWjDcEBERkUFhuCEiIiKDwnBDREREBoXhhoiIiAwKww0REREZFIYbIiIiMigMN0RERGRQGG6IiIjIoIi+/YIYqhZlzsvLE7kSIiIi0lbV9/aDNldoluEmPz8fAODp6SlyJURERKSr/Px8WFtb1/p8s9xbSqVSITk5GZaWlpBIJHq5Z15eHjw9PZGYmMj9quoZP+uGw8+64fCzbjj8rBtGfXzOgiAgPz8fbm5uGptq/1ezbLmRSqXw8PCol3tbWVnxL0sD4WfdcPhZNxx+1g2Hn3XD0PfnfL8WmyocUExEREQGheGGiIiIDArDjZ4oFAosXrwYCoVC7FIMHj/rhsPPuuHws244/Kwbhpifc7McUExERESGiy03REREZFAYboiIiMigMNwQERGRQWG4ISIiIoPCcKMHa9euhbe3N0xMTBAUFIQzZ86IXZJBOnLkCEaOHAk3NzdIJBLs2rVL7JIM0vLly9G9e3dYWlrCyckJo0ePxrVr18QuyyCtW7cOnTt3Vi9y1qtXL/z1119il9UsrFixAhKJBPPmzRO7FIOzZMkSSCQSjUfbtm0btAaGm4e0bds2BAcHY/HixQgPD4e/vz+GDBmCtLQ0sUszOIWFhfD398fatWvFLsWgHT58GLNmzcKpU6ewf/9+lJeX4/HHH0dhYaHYpRkcDw8PrFixAufPn8e5c+fw6KOP4sknn8SVK1fELs2gnT17Ft988w06d+4sdikGq0OHDrhz5476cezYsQZ9fU4Ff0hBQUHo3r071qxZA6By3ypPT0/MmTMH8+fPF7k6wyWRSLBz506MHj1a7FIMXnp6OpycnHD48GH0799f7HIMnp2dHT799FM8//zzYpdikAoKCtC1a1d8/fXX+PDDDxEQEICQkBCxyzIoS5Yswa5duxARESFaDWy5eQhlZWU4f/48Bg8erD4mlUoxePBgnDx5UsTKiPQnNzcXQOWXLtUfpVKJ0NBQFBYWolevXmKXY7BmzZqFESNGaPzeJv27fv063Nzc4Ovri8mTJyMhIaFBX79ZbpypLxkZGVAqlXB2dtY47uzsjOjoaJGqItIflUqFefPmoU+fPujYsaPY5RikyMhI9OrVCyUlJbCwsMDOnTvRvn17scsySKGhoQgPD8fZs2fFLsWgBQUFYcuWLWjTpg3u3LmDpUuXol+/frh8+TIsLS0bpAaGGyKq1axZs3D58uUG7y9vTtq0aYOIiAjk5uZix44dmDp1Kg4fPsyAo2eJiYl47bXXsH//fpiYmIhdjkEbNmyY+r87d+6MoKAgeHl5Yfv27Q3W3cpw8xAcHBwgk8mQmpqqcTw1NRUuLi4iVUWkH7Nnz8aff/6JI0eOwMPDQ+xyDJZcLoefnx8AIDAwEGfPnsXq1avxzTffiFyZYTl//jzS0tLQtWtX9TGlUokjR45gzZo1KC0thUwmE7FCw2VjY4PWrVsjNja2wV6TY24eglwuR2BgIMLCwtTHVCoVwsLC2GdOTZYgCJg9ezZ27tyJf/75Bz4+PmKX1KyoVCqUlpaKXYbBGTRoECIjIxEREaF+dOvWDZMnT0ZERASDTT0qKCjAjRs34Orq2mCvyZabhxQcHIypU6eiW7du6NGjB0JCQlBYWIjp06eLXZrBKSgo0Ej+8fHxiIiIgJ2dHVq0aCFiZYZl1qxZ+PHHH/Hbb7/B0tISKSkpAABra2uYmpqKXJ1hWbBgAYYNG4YWLVogPz8fP/74Iw4dOoR9+/aJXZrBsbS0rDZuzNzcHPb29hxPpmdvvvkmRo4cCS8vLyQnJ2Px4sWQyWSYOHFig9XAcPOQJkyYgPT0dCxatAgpKSkICAjA3r17qw0ypod37tw5DBw4UP1zcHAwAGDq1KnYsmWLSFUZnnXr1gEAHnnkEY3jmzdvxrRp0xq+IAOWlpaGKVOm4M6dO7C2tkbnzp2xb98+PPbYY2KXRlRnt2/fxsSJE5GZmQlHR0f07dsXp06dgqOjY4PVwHVuiIiIyKBwzA0REREZFIYbIiIiMigMN0RERGRQGG6IiIjIoDDcEBERkUFhuCEiIiKDwnBDREREBoXhhohEdejQIUgkEuTk5DT4a0skEkgkEtjY2Gh1flWtEokEo0ePrtfaiBqLI0eOYOTIkXBzc4NEIsGuXbvq9fWWLFmi/ntW9Wjbtq1O92C4IaIG88gjj2DevHkax3r37q1eoVcMmzdvRkxMjFbnVtX69NNP13NVRI1HYWEh/P39sXbt2gZ7zQ4dOuDOnTvqx7Fjx3S6ntsvEJGo5HI5XFxcRHt9GxsbODk5aXVuVa2mpqbc3JKajWHDhmHYsGG1Pl9aWor33nsPP/30E3JyctCxY0esXLmy2hYuujAyMnqo3wtsuSGiBjFt2jQcPnwYq1evVjc137x5s1q31JYtW2BjY4M///wTbdq0gZmZGcaNG4eioiJs3boV3t7esLW1xdy5c6FUKtX3Ly0txZtvvgl3d3eYm5sjKCgIhw4d0rnOixcvYuDAgbC0tISVlRUCAwNx7tw5PX0KRIZn9uzZOHnyJEJDQ3Hp0iWMHz8eQ4cOxfXr1+t8z+vXr8PNzQ2+vr6YPHkyEhISdLqeLTdE1CBWr16NmJgYdOzYEcuWLQMAODo64ubNm9XOLSoqwpdffonQ0FDk5+dj7NixGDNmDGxsbLBnzx7ExcXhqaeeQp8+fTBhwgQAlb9gr169itDQULi5uWHnzp0YOnQoIiMj0apVK63rnDx5Mrp06YJ169ZBJpMhIiICxsbGevkMiAxNQkICNm/ejISEBLi5uQGo3BV879692Lx5Mz7++GOd7xkUFIQtW7agTZs2uHPnDpYuXYp+/frh8uXLsLS01OoeDDdE1CCsra0hl8thZmb2wObm8vJyrFu3Di1btgQAjBs3Dj/88ANSU1NhYWGB9u3bY+DAgTh48CAmTJig11+wCQkJeOutt9QDGHUJRkTNTWRkJJRKJVq3bq1xvLS0FPb29gCA6OhotGvX7r73eeedd7BixQoA0OgC69y5M4KCguDl5YXt27fj+eef16ouhhsianTMzMzUwQYAnJ2d4e3tDQsLC41jaWlpALT7Baut4OBgvPDCC/jhhx8wePBgjB8/XqMWIvpXQUEBZDIZzp8/D5lMpvFc1d9XX19fREVF3fc+9/t7amNjg9atWyM2NlbruhhuiKjR+W83kEQiqfGYSqUCoN0vWG0tWbIEkyZNwu7du/HXX39h8eLFCA0NxZgxY+rwTogMW5cuXaBUKpGWloZ+/frVeI5cLtd5Kve9CgoKcOPGDTz33HNaX8NwQ0QNRi6XawwC1hdtfsHqonXr1mjdujVef/11TJw4EZs3b2a4oWaroKBAo9UkPj4eERERsLOzQ+vWrTF58mRMmTIFn3/+Obp06YL09HSEhYWhc+fOGDFihM6v9+abb2LkyJHw8vJCcnIyFi9eDJlMhokTJ2p9D86WIqIG4+3tjdOnT+PmzZvIyMhQt7w8rHt/wf7666+Ij4/HmTNnsHz5cuzevVvr+xQXF2P27Nk4dOgQbt26hePHj+Ps2bMPHC9AZMjOnTuHLl26oEuXLgAqu267dOmCRYsWAahcK2rKlCl444030KZNG4wePRpnz55FixYt6vR6t2/fxsSJE9GmTRs8/fTTsLe3x6lTp+Do6Kj1PdhyQ0QN5s0338TUqVPRvn17FBcXIz4+Xm/33rx5Mz788EO88cYbSEpKgoODA3r27IknnnhC63vIZDJkZmZiypQpSE1NhYODA8aOHYulS5fqrU6ipuaRRx6BIAi1Pm9sbIylS5fq7e9JaGjoQ99DItyvYiIiAyaRSLBz506dt1KYNm0acnJy6n0ZeiKqG3ZLEVGzNnHiRHh4eGh17tGjR2FhYYH/+7//q+eqiOhhsOWGiJqtqkGSMpkMPj4+Dzy/uLgYSUlJACpnYYm5bQQR1Y7hhoiIiAwKu6WIiIjIoDDcEBERkUFhuCEiIiKDwnBDREREBoXhhoiIiAwKww0REREZFIYbIiIiMigMN0RERGRQGG6IiIjIoPw/M3D2zfzo7KcAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(dataset.x0, np.abs(dataset.y1))\n", "plt.xlabel(\"time [s]\")\n", "plt.ylabel('Probability of |1⟩ state')\n", "plt.title('T1 Relaxation Experiment')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "bbc08e74", "metadata": {}, "source": [ "```{note}\n", "Often, we can use an `Analysis` class on datasets to visualize the data and extract relevant parameters such as {{ T1Analysis }}\n", "```\n", "\n", "### Note on Execution Order\n", "\n", "Parallel {{ ConditionalReset }} operations are not supported. For example, compiling the following schedule will raise a {{ RuntimeError }}:\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"), ref_pt=\"start\")\n", "```\n", "\n", "and will have to be scheduled sequentially,\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"))\n", "```\n", "\n", "\n", "## Closing Remarks\n", "\n", "You can find more technical information and explanations of the different limitations in our [reference guide](sec-qblox-conditional-playback)." ] } ], "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.23" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 255, 287, 297, 305, 309, 318, 325, 345, 386, 407, 458, 471, 527, 553, 562, 568, 574 ] }, "nbformat": 4, "nbformat_minor": 5 }