qick_demos/00_Send_receive_pulse.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "try {\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n",
       "} catch (e) {};\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "# Import the QICK drivers and auxiliary libraries\n",
    "from qick import *\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "QICK configuration:\n",
      "\n",
      "\tBoard: ZCU111\n",
      "\n",
      "\tSoftware version: 0.2.181\n",
      "\tFirmware timestamp: Wed Aug 16 13:39:03 2023\n",
      "\n",
      "\tGlobal clocks (MHz): tProcessor 384.000, RF reference 204.800\n",
      "\n",
      "\t7 signal generator channels:\n",
      "\t0:\taxis_signal_gen_v6 - tProc output 1, envelope memory 65536 samples\n",
      "\t\tDAC tile 0, blk 0, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\t1:\taxis_signal_gen_v6 - tProc output 2, envelope memory 65536 samples\n",
      "\t\tDAC tile 0, blk 1, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\t2:\taxis_signal_gen_v6 - tProc output 3, envelope memory 65536 samples\n",
      "\t\tDAC tile 0, blk 2, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\t3:\taxis_signal_gen_v6 - tProc output 4, envelope memory 65536 samples\n",
      "\t\tDAC tile 1, blk 0, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\t4:\taxis_signal_gen_v6 - tProc output 5, envelope memory 65536 samples\n",
      "\t\tDAC tile 1, blk 1, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\t5:\taxis_signal_gen_v6 - tProc output 6, envelope memory 65536 samples\n",
      "\t\tDAC tile 1, blk 2, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\t6:\taxis_signal_gen_v6 - tProc output 7, envelope memory 65536 samples\n",
      "\t\tDAC tile 1, blk 3, 32-bit DDS, fabric=384.000 MHz, f_dds=6144.000 MHz\n",
      "\n",
      "\t2 readout channels:\n",
      "\t0:\taxis_readout_v2 - controlled by PYNQ\n",
      "\t\tADC tile 0, blk 0, 32-bit DDS, fabric=512.000 MHz, fs=4096.000 MHz\n",
      "\t\tmaxlen 16384 (avg) 1024 (decimated)\n",
      "\t\ttriggered by output 0, pin 14, feedback to tProc input 0\n",
      "\t1:\taxis_readout_v2 - controlled by PYNQ\n",
      "\t\tADC tile 0, blk 1, 32-bit DDS, fabric=512.000 MHz, fs=4096.000 MHz\n",
      "\t\tmaxlen 16384 (avg) 1024 (decimated)\n",
      "\t\ttriggered by output 0, pin 15, feedback to tProc input 1\n",
      "\n",
      "\t7 DACs:\n",
      "\t\tDAC tile 0, blk 0 is DAC228_T0_CH0 or RF board output 0\n",
      "\t\tDAC tile 0, blk 1 is DAC228_T0_CH1 or RF board output 1\n",
      "\t\tDAC tile 0, blk 2 is DAC228_T0_CH2 or RF board output 2\n",
      "\t\tDAC tile 1, blk 0 is DAC229_T1_CH0 or RF board output 4\n",
      "\t\tDAC tile 1, blk 1 is DAC229_T1_CH1 or RF board output 5\n",
      "\t\tDAC tile 1, blk 2 is DAC229_T1_CH2 or RF board output 6\n",
      "\t\tDAC tile 1, blk 3 is DAC229_T1_CH3 or RF board output 7\n",
      "\n",
      "\t2 ADCs:\n",
      "\t\tADC tile 0, blk 0 is ADC224_T0_CH0 or RF board AC input 0\n",
      "\t\tADC tile 0, blk 1 is ADC224_T0_CH1 or RF board AC input 1\n",
      "\n",
      "\t8 digital output pins:\n",
      "\t0:\tPMOD0_0_LS (output 0, pin 0)\n",
      "\t1:\tPMOD0_1_LS (output 0, pin 1)\n",
      "\t2:\tPMOD0_2_LS (output 0, pin 2)\n",
      "\t3:\tPMOD0_3_LS (output 0, pin 3)\n",
      "\t4:\tPMOD0_4_LS (output 0, pin 4)\n",
      "\t5:\tPMOD0_5_LS (output 0, pin 5)\n",
      "\t6:\tPMOD0_6_LS (output 0, pin 6)\n",
      "\t7:\tPMOD0_7_LS (output 0, pin 7)\n",
      "\n",
      "\ttProc axis_tproc64x32_x8: program memory 8192 words, data memory 4096 words\n",
      "\t\texternal start pin: PMOD1_0_LS\n",
      "\n",
      "\tDDR4 memory buffer: 1073741824 samples, 256 samples/transfer\n",
      "\t\twired to readouts [0, 1], triggered by output 0, pin 8\n",
      "\n",
      "\tMR buffer: 8192 samples, wired to readouts [0, 1], triggered by output 0, pin 9\n"
     ]
    }
   ],
   "source": [
    "# Load bitstream with custom overlay\n",
    "soc = QickSoc()\n",
    "# Since we're running locally on the QICK, we don't need a separate QickConfig object.\n",
    "# If running remotely, you could generate a QickConfig from the QickSoc:\n",
    "#     soccfg = QickConfig(soc.get_cfg())\n",
    "# or save the config to file, and load it later:\n",
    "#     with open(\"qick_config.json\", \"w\") as f:\n",
    "#         f.write(soc.dump_cfg())\n",
    "#     soccfg = QickConfig(\"qick_config.json\")\n",
    "soccfg = soc\n",
    "print(soccfg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hardware Configuration\n",
    "\n",
    "You should cable the board in loopback, connecting one DAC to one ADC. You can set appropriate generator and readout numbers in the cell below, which will be used in `res_ch` and `ro_chs` entries in the program dictionaries below.\n",
    "\n",
    "For example, for a ZCU111 you might connect DAC229_T1_CH3 to ADC224_T0_CH0 (these are the labels on the XM500 balun board). The DAC and ADC lists tell you that these are DAC tile 1, block 3, and ADC tile 0, block 0. The generator and readout lists tell you that these are driven by generator 6 and readout 0, and your QICK programs will reference those IDs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "GEN_CH = 6\n",
    "RO_CH = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Things to know when writing programs\n",
    "\n",
    "### How to avoid timing problems\n",
    "Timed instructions are executed in two steps: first when the control core of the tProcessor pushes the instruction into the timed queue, and second when the instruction pops off the timed queue. This is described in more detail [here](https://qick-docs.readthedocs.io/en/latest/cheatsheet.html#timing).\n",
    "* The control core executes all instructions in order and (except wait/waiti) as quickly as possible. If you have a non-timed instruction with external effects, it will generally execute before the timed instructions before and after it. Specifically, programs (like the [`AveragerProgram`](https://qick-docs.readthedocs.io/en/latest/_modules/qick/averager_program.html#AveragerProgram.make_program) framework we're using here) typically use memwi to update a data counter, and then read that counter to know how many data samples to get from the buffers - if the memwi happens before the readout is triggered or completed, you will read invalid data.\n",
    "* If the instruction is pushed later than the specified time, it will execute later than specified - this can lead to variations in the relative timing of pulses and readout windows. You are responsible for keeping the control core running ahead of the instruction times.\n",
    "\n",
    "Things you should do in your programs:\n",
    "* Your initialization should contain a synci instruction which gives the tProcessor time to get ahead of the clock.\n",
    "* Put a [`sync_all()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.sync_all) somewhere in your loop body, probably at the end. This ensures that you don't have pulses or readouts that exceed the loop length.\n",
    "* Put a waiti instruction after the last readout in your loop body, to make sure the tProcessor doesn't prematurely update the data counter.\n",
    "* Follow the waiti with a sync that exceeds the waiti, to allow the tProcessor to get ahead of the clock.\n",
    "\n",
    "The last three points are automatically addressed if the last timed instruction in your loop body is a [`measure()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.measure) instruction that specifies `wait=True` and a nonzero `syncdelay`.\n",
    "\n",
    "### How to ensure frequency matching\n",
    "DACs and ADCs have different frequency units, and the frequencies used in the two systems must be exactly equal. If they are not, there will be a small difference between the upconversion and downconversion frequencies - this will manifest as a sliding phase, and so you will not see a consistent phase between acquisitions.\n",
    "\n",
    "There are two ways to ensure frequency matching:\n",
    "* When converting a frequency to an integer value (often with [`freq2reg()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.QickConfig.freq2reg) or [`declare_readout()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.AbsQickProgram.declare_readout)), specify not only the channel you are configuring, but the channel you want to be frequency-matched to.\n",
    "* Before doing any conversion, round the frequency to the closest frequency that is valid on both channels using [`soccfg.adcfreq(f, gen_ch, ro_ch)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.QickConfig.adcfreq).\n",
    "\n",
    "Frequency-matching makes your frequency resolution worse, since the smallest possible frequency step is now the LCM of the two channels' frequency steps. Usually this doesn't matter - O(10 Hz) resolution is ample for most applications - but you can disable frequency-matching by specifying None as the other channel.\n",
    "\n",
    "You may have a DAC channel that does not itself drive any ADC channels, but needs to be phase-locked to a DAC channel that does. In this case you will want to frequency-match both DAC channels to that ADC, otherwise you will have a sliding phase between the two DAC channels.\n",
    "\n",
    "Since all DAC and ADC channels are the same in the standard QICK firmware, it's OK to just use ch 0 for the matched channel. But it's a good habit to do this consistently correctly, and that is the approach here.\n",
    "\n",
    "### Clocks and durations\n",
    "Time durations are generally specified in units of clock cycles. The relevant clocks are the tProcessor clock and the fabric clocks of the DACs and ADCs. In general these can all be different (and can even vary among DACs or ADCs).\n",
    "\n",
    "For convenience, the [`us2cycles()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.QickConfig.us2cycles) and [`cycles2us()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.QickConfig.cycles2us) methods will convert between floating-point times and integer cycles. You should be careful to specify which clock you are using, and set the appropriate parameter in `us2cycles()`:\n",
    "* Pulse parameters (the `length` parameter to [`set_pulse_registers()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.set_pulse_registers), the `length` and `sigma` parameters to `add_gauss`) use the DAC clock and you should specify `gen_ch`.\n",
    "* Readout parameters (the `length` parameter to [`declare_readout()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.AbsQickProgram.declare_readout)) use the ADC clock and you should specify `ro_ch`.\n",
    "* All other values will use the tProc clock. This includes sync and wait commands, and any sort of delay (`t`, `adc_trig_offset`). Don't use a channel ID parameter.\n",
    "\n",
    "### How to play pulses\n",
    "There are three steps to playing a pulse:\n",
    "\n",
    "#### Loading a waveform\n",
    "(You skip this step for rectangular \"const\" pulses, which have no envelope.)\n",
    "\n",
    "Each signal generator has an internal waveform memory, which stores the I/Q data for the pulse envelope. Multiple waveforms can be stored in the same signal generator, and a single waveform can be used for different pulses (e.g. a Gaussian waveform can be used for Gaussian pulses and the ramp-up/ramp-down of flat-top pulses with different flat-top duration, each with its own gain and carrier frequency).\n",
    "\n",
    "[`add_pulse(ch, name, idata, qdata)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.AbsQickProgram.add_pulse) writes an arbitrary waveform to the specified channel's waveform memory. \n",
    "[`add_gauss(ch, name, length, sigma)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.AbsQickProgram.add_gauss), [`add_triangle(ch, name, length)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.AbsQickProgram.add_triangle), and [`add_DRAG(ch, name, length, sigma, delta, alpha)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.qick_asm.html#qick.qick_asm.AbsQickProgram.add_DRAG) write commonly-used standard pulse waveforms, with duration units of fabric clock cycles. The name is used in the next step.\n",
    "\n",
    "#### Setting registers\n",
    "There are a lot of parameters that need to be specified when playing a pulse - more than can be specified inline in a tProcessor instruction. So all the parameters must be written to registers first, and when we fire the pulse we just tell the tProcessor which registers to read.\n",
    "\n",
    "[`set_pulse_registers()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.set_pulse_registers) writes the settings for a pulse to registers. All arguments to this method must be integers in the native units of the signal generator. This can happen immediately before you fire the pulse, but if a signal generator is only used for one type of pulse you will save time for the tProcessor by setting registers in initialization, before the program loop. If you have some parameters that change from pulse to pulse, and some that never change, you can write the fixed parameters in initialization using [`default_pulse_registers()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.default_pulse_registers) and the varying parameters in the body with `set_pulse_registers()`.\n",
    "\n",
    "If you want to modify pulse parameters on the fly (for example, you might want to sweep the frequency of the qubit drive pulse), you will set the registers in two steps (you can see an example in the demo 02_Sweeping_variables):\n",
    "* First, use set_pulse_registers() to write initial values for all parameters. You could do this in initialization, or right before the following step.\n",
    "* Second, overwrite the register(s) you want to update. You need to get the page and address of the register using [`ch_page(ch)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.ch_page) and [`sreg(ch, name)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.sreg). Then you can use assembly instructions to change the value of that register.\n",
    "\n",
    "#### Firing the pulse\n",
    "[`pulse(ch, t)`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.pulse) fires a pulse on the specified channel at the specified time, using whatever values are loaded in the registers.\n",
    "\n",
    "Often you will want to trigger the readout at the same time: [`measure()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.measure) is a wrapper around [`trigger()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.asm_v1.html#qick.asm_v1.QickProgram.trigger) and `pulse()`, and that's what is used in this demo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LoopbackProgram(AveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg=self.cfg   \n",
    "        res_ch = cfg[\"res_ch\"]\n",
    "\n",
    "        # set the nyquist zone\n",
    "        self.declare_gen(ch=cfg[\"res_ch\"], nqz=1)\n",
    "        \n",
    "        # configure the readout lengths and downconversion frequencies (ensuring it is an available DAC frequency)\n",
    "        for ch in cfg[\"ro_chs\"]:\n",
    "            self.declare_readout(ch=ch, length=self.cfg[\"readout_length\"],\n",
    "                                 freq=self.cfg[\"pulse_freq\"], gen_ch=cfg[\"res_ch\"])\n",
    "\n",
    "        # convert frequency to DAC frequency (ensuring it is an available ADC frequency)\n",
    "        freq = self.freq2reg(cfg[\"pulse_freq\"],gen_ch=res_ch, ro_ch=cfg[\"ro_chs\"][0])\n",
    "        phase = self.deg2reg(cfg[\"res_phase\"], gen_ch=res_ch)\n",
    "        gain = cfg[\"pulse_gain\"]\n",
    "        self.default_pulse_registers(ch=res_ch, freq=freq, phase=phase, gain=gain)\n",
    "\n",
    "        style=self.cfg[\"pulse_style\"]\n",
    "\n",
    "        if style in [\"flat_top\",\"arb\"]:\n",
    "            sigma = cfg[\"sigma\"]\n",
    "            self.add_gauss(ch=res_ch, name=\"measure\", sigma=sigma, length=sigma*5)\n",
    "            \n",
    "        if style == \"const\":\n",
    "            self.set_pulse_registers(ch=res_ch, style=style, length=cfg[\"length\"])\n",
    "        elif style == \"flat_top\":\n",
    "            # The first half of the waveform ramps up the pulse, the second half ramps down the pulse\n",
    "            self.set_pulse_registers(ch=res_ch, style=style, waveform=\"measure\", length=cfg[\"length\"])\n",
    "        elif style == \"arb\":\n",
    "            self.set_pulse_registers(ch=res_ch, style=style, waveform=\"measure\")\n",
    "        \n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "    \n",
    "    def body(self):\n",
    "        # fire the pulse\n",
    "        # trigger all declared ADCs\n",
    "        # pulse PMOD0_0 for a scope trigger\n",
    "        # pause the tProc until readout is done\n",
    "        # increment the time counter to give some time before the next measurement\n",
    "        # (the syncdelay also lets the tProc get back ahead of the clock)\n",
    "        self.measure(pulse_ch=self.cfg[\"res_ch\"], \n",
    "                     adcs=self.ro_chs,\n",
    "                     pins=[0], \n",
    "                     adc_trig_offset=self.cfg[\"adc_trig_offset\"],\n",
    "                     wait=True,\n",
    "                     syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n",
    "        \n",
    "        # equivalent to the following:\n",
    "#         self.trigger(adcs=self.ro_chs,\n",
    "#                      pins=[0], \n",
    "#                      adc_trig_offset=self.cfg[\"adc_trig_offset\"])\n",
    "#         self.pulse(ch=self.cfg[\"res_ch\"])\n",
    "#         self.wait_all()\n",
    "#         self.sync_all(self.us2cycles(self.cfg[\"relax_delay\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Send/receive a pulse with <code> pulse_style </code> = <code> const </code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d9eb72baa7314ea0a30704c01aedede4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":1, # --Fixed\n",
    "        \"relax_delay\":1.0, # --us\n",
    "        \"res_phase\":0, # --degrees\n",
    "        \"pulse_style\": \"const\", # --Fixed\n",
    "        \n",
    "        \"length\":20, # [Clock ticks]\n",
    "        # Try varying length from 10-100 clock ticks\n",
    "        \n",
    "        \"readout_length\":100, # [Clock ticks]\n",
    "        # Try varying readout_length from 50-1000 clock ticks\n",
    "\n",
    "        \"pulse_gain\":3000, # [DAC units]\n",
    "        # Try varying pulse_gain from 500 to 30000 DAC units\n",
    "\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        # In this program the signal is up and downconverted digitally so you won't see any frequency\n",
    "        # components in the I/Q traces below. But since the signal gain depends on frequency, \n",
    "        # if you lower pulse_freq you will see an increased gain.\n",
    "\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        # Try varying adc_trig_offset from 100 to 220 clock ticks\n",
    "\n",
    "        \"soft_avgs\":100\n",
    "        # Try varying soft_avgs from 1 to 200 averages\n",
    "\n",
    "       }\n",
    "\n",
    "###################\n",
    "# Try it yourself !\n",
    "###################\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "iq_list = prog.acquire_decimated(soc, progress=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEWCAYAAACNJFuYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXxU5d3//9fnzJ6NsIQ1sgi4gYCIikvdcK+W1lrFWrWtdlNr6/dua+mm7a29a73veveu1da27oriVm1/1YqIRa0buCAgCApCkCWE7JnMcs7n98dMYjABA1lOMvN5Ph55JHPOmZlPlsl7rutc57pEVTHGGGPacvwuwBhjTN9j4WCMMaYdCwdjjDHtWDgYY4xpx8LBGGNMOxYOxhhj2rFwMMYY046Fg+k3ROQ5EakWkYjftfRFIjJZRP4pIttFpN0FTCIySEQeE5FGEflARL74sf2zRGSViDSJyCIRGdN71Zu+xsLB9AsiMhb4FKDAZ3roOYI98bi9KAXMBy7Zxf7fA0lgGHABcKuITAIQkSHAo8BPgUHAEuDBni7Y9F0WDqa/uAh4GbgTuLhlo4jMFJEtIhJos+1zIrIs+7UjIj8UkfdEpEpE5ovIoOy+sSKiInKJiGwAns1ufyj7mLUisrjlH2h232AR+ZuI1InIayJynYi80Gb/ASKyQER2iMhqETm3zb4zRGSliNSLyCYR+V53/oBUdbWq/gVY8fF9IlIIfB74qao2qOoLwBPAhdlDzgZWqOpDqtoMXAtMFZEDurNG039YOJj+4iLgvuzHqSIyDEBVXwYagRPbHPtF4P7s11cCnwWOA0YC1WTeQbd1HHAgcGr29pPARGAo8Hr2OVv8Pvt8w8mEVNugKgQWZJ97KHA+cEubcPkL8A1VLQYmkw2jjxORY0SkZjcfx+z2J9Wx/QBXVd9ts+0toKW2SdnbAKhqI/Bem/0mz/T3ZrTJA9l/hmOA+aq6XUTeIxMAN2UPmUfmH/ECESkGzgBa3pV/A7hCVSuyj3UtsEFELmzzFNdm/xkCoKq3t3nua4FqERkANJB59z1ZVZuAlSJyF3B89vAzgfWqekf29usi8ghwDpl38yngIBF5S1WryQRVO9l39aV78CPqjCKg9mPbaoHiNvsrd7Pf5BlrOZj+4GLgaVXdnr19P23esWdvn509UX028LqqfpDdNwZ4rOVdN/AO4JLpd2+xseULEQmIyK+y3VB1wPrsriFAGZk3VBs7um/2uY5o+y6fTN/+8Oz+z5MJrg9E5F8icuQe/yT2XgNQ8rFtJUB9J/ebPGMtB9OniUgMOBcIiMiW7OYIUCoiU1X1LVVdKSIfAKezc5cSZP55f1VVX+zgscdmv2w7sueLwGzgJDLBMIDMO3wh8846DZQDLd0z+3zsuf6lqid39L2o6mvAbBEJAVeQOXm8z8ePE5FPkena2pXTVfX53ezvyLtAUEQmquqa7LapfHR+YgXtu8jG08H5C5MfrOVg+rrPknmnfxAwLftxIPA8mfMQLe4nc37hWOChNtv/AFzfMixTRMpEZPZunq8YSABVQAHwy5YdquqSGdFzrYgUZE/Wtq3h78B+InKhiISyH4eJyIEiEhaRC0RkgKqmgLrs99WOqj6vqkW7+egwGCQjCoSzt6Mtw36z3WaPAr8QkUIROZpMCN6TvftjwGQR+Xz2MX4GLFPVVbv5WZkcZuFg+rqLgTtUdYOqbmn5AG4GLmgz/HQemb7/Z9t0PwH8lsyonKdFpJ7MiKcjdvN8dwMfAJuAldnj27qCTGtiC5l/rPPIhAmqWg+cAswBPswecwOZlg5kRgatz3ZXfRP40h78HDpjDBDno3f7cWB1m/2XATFgW7bub6nqimztlWS6va4n01I6Ivt9mDwlttiPMXtPRG4AhqvqxZ94sDH9iLUcjNkD2esYpmS7cA4nc8HZY37XZUx3sxPSxuyZYjJdMiPJdM/8D/C4rxUZ0wOsW8kYY0w71q1kjDGmnZzoVhoyZIiOHTvW7zKMMaZfWbp06XZVLetoX06Ew9ixY1myZInfZRhjTL+SvXi0Q9atZIwxph0LB2OMMe1YOBhjjGknJ845GGN6RyqVoqKigubmZr9LMXsgGo1SXl5OKBTq9H0sHIwxnVZRUUFxcTFjx45FRPwux3SCqlJVVUVFRQXjxo3r9P2sW8kY02nNzc0MHjzYgqEfEREGDx68x609CwdjzB6xYOh/9uZ3ZuFgjGm1o3kHT617yu8yTB9g4WDyQm2iliufvZKtjVv9LqVPu3flvXx/8fepTXx8uem+o6ioqE89Tkdmz57NkUfuvArstddey6hRo5g2bRoTJ07k7LPPZuXKla37U6kUP/zhD5k4cSKTJ0/m8MMP58kn2y8IuG7dOo444ggmTpzIeeedRzKZ7JHvwcLB5IVVO1axaOMinly3u9U3zfKNmUXmdjRW+lxJ/1VTU8Prr79OTU0N69at22nfVVddxZtvvsmaNWs477zzOPHEE6mszPysf/rTn7J582aWL1/O8uXL+dvf/kZ9ffslvK+++mquuuoq1qxZw8CBA/nLX/7SI9+HhYPJC02V7wDwwtq/+VxJ3+Wpx/LatQBU17zvczV75uqrr+aWW25pvX3ttdfyP//zPzQ0NDBr1iymT5/OwQcfzOOPt59d/bnnnuPMM89svX3FFVdw5513ArB06VKOO+44Dj30UE499VQ2b978ibU88sgjnHXWWcyZM4cHHnhgl8edd955nHLKKdx///00NTXxpz/9id/97ndEIpmFA4cNG8a55567031UlWeffZZzzjkHgIsvvpi//vWvn1jT3rChrCYvxBu2AfB67RqaUk0UhAp8rqjv2VC3gXpNA1BdX/GJx//8bytY+WFdt9Zw0MgSrjlr0h7fb86cOXz3u9/lsssuA2D+/Pk89dRTRKNRHnvsMUpKSti+fTszZ87kM5/5TKdO0KZSKb797W/z+OOPU1ZWxoMPPsiPf/xjbr/99t3eb968eVxzzTUMGzaMc845h7lz5+7y2OnTp7Nq1SrWrl3L6NGjKSkp2e1jV1VVUVpaSjCY+dddXl7Opk2bPvF72RsWDiYvNKUy/8RSKK9teY3j9jnO54r6nre3fDR5ZU3jFh8r2XOHHHII27Zt48MPP6SyspKBAwcyevRoUqkUP/rRj1i8eDGO47Bp0ya2bt3K8OHDP/ExV69ezfLlyzn55JMBcF2XESNG7PY+W7duZe3atRxzzDGICMFgkOXLlzN58uQOj9/T9XQ6Or6nRo9ZOJi8EE82ABBU5YX3/2Hh0IHlG58n4nkkHIfqpm2fePzevMPvSeeccw4PP/wwW7ZsYc6cOQDcd999VFZWsnTpUkKhEGPHjm033j8YDOJ5Xuvtlv2qyqRJk3jppZc6XcODDz5IdXV168VmdXV1PPDAA1x33XUdHv/GG28wY8YMJkyYwIYNG6ivr6e4uHiXjz9kyBBqampIp9MEg0EqKioYOXJkp+vbE3bOweSFplQjAIfHm3lx04tdeqx4Os72+HZSXmqn7apK2kt36t2gqpLyUjSmGtnSuIU11Wt4c9ubLKtcxoqqFazesZq11WtZV7uOjXUb2dywme3x7dQmakm6H41OaU438271uyz8YCFvbnuTtJfe6+9redVyJiWTxDyP6qaqvX4cv7T08T/88MOtffK1tbUMHTqUUCjEokWL+OCD9jNUjxkzhpUrV5JIJKitrWXhwoUA7L///lRWVraGQyqVYsWKFQDcfPPN3Hzzze0ea968eTz11FOsX7+e9evXs3Tp0l2ed3jkkUd4+umnOf/88ykoKOCSSy7hyiuvbB19tHnzZu69996d7iMinHDCCTz88MMA3HXXXcyePXtvflyfyFoOJi/EU00EVTneDfLLVC0b6jYwumT0Tsd46vHAqgeYOWIm+5bu2+4x1lav5YHVD/C39/5GU7oJgKJQESEnRLPbTDwdbz026AQJSrC1yS8IiuJ6Lp56pHXv/4m3PH4sGKM+ufNoluJQMYePOJwLDryAw4Yf1unHS7kpVjVXcr4XZovrUZPsu0NZd2XSpEnU19czatSo1u6fCy64gLPOOosZM2Ywbdo0DjjggHb322effTj33HOZMmUKEydO5JBDDgEgHA7z8MMPc+WVV1JbW0s6nea73/0ukyZNYtWqVRx99NE7Pc769evZsGEDM2fObN02btw4SkpKeOWVVwC46aabuPfee2lsbGTy5Mk8++yzlJVl1tq57rrr+MlPfsJBBx1ENBqlsLCQX/ziF+3qveGGG5gzZw4/+clPOOSQQ7jkkku65wf4MTmxhvSMGTPUFvsxu/Nfj5zN32tX8cCgYzij9iXmzvgBX5x04U7H3LT0Jm5ffjtDY0O5/9P3M6xwGABNqSbmPj+XZzc+S9gJc1rpgUwOFFEbCFCDksYjhhD1lIB6pFHSKK4qKoICCgTEQcQhIA5BhCBCWJViN01xKkFhqhkVwRWHdPazK0LacUgjpERIitIsAZochyZHKPWUsYkE+zTsoCIS5eVYlMWNG6hN1vPHk//IjOEzWr+/9bXreWnzS1Q3V7OjeQdjS8bypYO+BMCKqhXM+fscbgyN446mtQwuGMYtX1zU7uf4zjvvcOCBB/bY76m/OPPMM3n00UcJh8N+l9JpHf3uRGSpqs7o6HhrOZi80OQ2E1PY54DZjH5hMS++/4+dwuHhdx/m9uW3c7IX5cVENVcuupI7T7uTlJfi8mcuZ1nlMi4r3J857y9l4Hs9MBw2VAix0szXXhrcFHgueKns12kyEdOBYBQG7cvkuk2c1lxLteNw0biJXPnst7nz9LuYWDqR+avnc+OSG0m4CQBiwRjxdJxpQ6cxechklldkuk4mjzycge+tp8aNd/xcBoC///3vfpfQ4ywcTF6IuwkKEBj7KY5ekOCv1e+QcBNEAhFe3PQi1718Hce4QX694V1ejMX4tpfmB4t/wNbGraypfpcbq2o55YNFcMCZMOMrMGIaxHdAY1XmH3ekGCJFEIgACupl/rmr1+ZDQd3MZycIgSAEwlAwGEKxT/4mPA/cJCQboLkWmmugYAgM2AccJ/N8W5YxcNlD/HHJH7hwzL58c8E3mTR4Es9VPMfR4TJ+Ur2D4YkmEqkdnDFiMP+79Df86ZS/sHzTvxnouowaczwD1z3Bei/R478T07f1eDiIyO3AmcA2VZ2c3XYjcBaQBN4DvqKqNdl9c4FLABe4UlX/2dM1mtzX5CaJ4UC0hGOKxjFPKznhwRNIuAmSXpIDCPPfFesJnns3x73wv3yvZj038hwRCfJ/26r4VGwkfPV5KN3noweNlcKg9ucmeozjgBOFUBQKh3SwPwAjD4GRhzAyEOQPr97CxaPH8MKm5/leIsyF65bi7P9pKCojmE7y9XVP8Ct5jZc2v8TymneZnEgiI6dRGiygxu1/J6RN9+qNlsOdwM3A3W22LQDmqmpaRG4A5gJXi8hBwBxgEjASeEZE9lNVtxfqNDks7qWISQCAI8efxpff+D3NEw8jpkJJ9QY++/4SCs/6HRw0G/aZyYV/nkWsLsF+jduZOnAifOkxKBzs83exB076ORMbq3hg+QO4gRDjgkXwpUdgwkmZ/ap84Y513ONu5MZXb+C9VC2nBAdApIiB4WIam6tIuknCgf7Tp266V4+Hg6ouFpGxH9v2dJubLwPnZL+eDTygqglgnYisBQ4HOj/Q2JgOxDXFIMn8uYf2O4P/ePZ6ePWR7F6BWT+DQzInZykehlzwEF/4y6kwdApcMB+iA/wpfG+JwFm/ZbSXgkQ9nPm/UDxsp/3hU67j8gfO4keBzFQZkwbuB0BppBSaoaa5mqGFwzp6dJMH+sI5h68CD2a/HkUmLFpUZLe1IyJfB74OMHr06I4OMaZVk7qMcrL9+sMnwzcWZ/roCwZl+vwjH7vwaOiB8N1lme1OoPcL7g6BIJx92673l8/gjH1O5va6V1kbDjG5/BgABsWGQC1U12+ycMhjvl4EJyI/BtLAfS2bOjiswyEaqnqbqs5Q1Rkt44SN2ZW4ehQ4bdbPHTEVRk2HgWPbB0OLWGn/DYZOCpx0DddV1fD/dlQzaOyxAJQWDAWgum6jn6XtUkVFBbNnz2bixInsu+++XHHFFSQSXT+Bvn79+l1Oc9Edpk6dyvnnn7/Tti9/+cuMGzeOqVOnst9++3HRRRftNFdSQ0MD3/jGNxg/fjyTJk3i2GOPbb1moq2lS5dy8MEHM2HCBK688so9npajI76Fg4hcTOZE9QX60XdSAbQ540c58GFv12ZyTxNKLBDxu4y+Z/B4Jh1yCV9JR6EsMwZ+YFFmOoaa+p6Z0K0rVJWzzz6bz372s6xZs4Y1a9YQj8f5wQ9+4Hdpu/XOO+/geR6LFy+msbFxp3033ngjb731FqtXr+aQQw7hhBNOaL1K+tJLL2XQoEGsWbOGFStWcOedd7J9+/Z2j/+tb32L2267rfVn8tRTXV+wyZdwEJHTgKuBz6hqU5tdTwBzRCQiIuOAicCrftRocktcLBx26eT/hCvfyHRDAaUl5QDsaOh7k+89++yzRKNRvvKVrwAQCAS46aabuPvuu2loaNjp2PPOO49//OMfrbe//OUv88gjj7B+/Xo+9alPMX36dKZPn86///3vds9z5513csUVV7TePvPMM3nuuecAePrppznyyCOZPn06X/jCF9o9b0fuv/9+LrzwQk455RSeeOKJDo8REa666iqGDx/Ok08+yXvvvccrr7zCddddh+Nk/lXvu+++fPrTn97pfps3b6auro4jjzwSEeGiiy7qlmm8e2Mo6zzgeGCIiFQA15AZnRQBFmSnF3hZVb+pqitEZD6wkkx30+U2Usl0VcpLkRKhINiJawnykePs1LU2YEDmHF5N/BMW/Hnyh7Dl7e6tZfjBcPqvdrl7xYoVHHrooTttKykpYezYsaxdu5Zp06a1bp8zZw4PPvggZ5xxBslkkoULF3LrrbeiqixYsIBoNMqaNWs4//zz6ewMC9u3b+e6667jmWeeobCwkBtuuIHf/OY3/OxnP9vt/R588EEWLFjA6tWrufnmm9t1L7XVMo23iDBt2jQCgd13bW7atIny8vLW2901jXdvjFbq6Kewy6WLVPV64Pqeq8jkm5YZWWNBW8OhM4JFQxngulQ3V/tdSjuq2uEU1R31sZ9++ulceeWVJBIJnnrqKY499lhisRi1tbVcccUVvPnmmwQCAd59991OP//LL7/MypUrW+dVSiaT7ZYD/bjXXnuNsrIyxowZQ3l5OV/96leprq5m4MCBu/we90RPTePdF0YrGdOj4vHMP7mCUKHPlfQTkRIGevrJk+/t5h1+T5k0aRKPPPLITtvq6urYunUr+++//07bo9Eoxx9/PP/85z958MEHW9+t33TTTQwbNoy33noLz/OIRqPtnmd303iffPLJzJs3r9M1z5s3j1WrVjF27NjWeh955BEuvfTSDo9/4403mDVrFpMmTWqtsaVbqSPl5eVUVHy0OFN3TeNtU3abnNcU3wFALGzh0CkilOJQnfrkvvTeNmvWLJqamrj77sw1ta7r8h//8R9cccUVxGLtuw3nzJnDHXfcwfPPP8+pp54KZKbxHjFiBI7jcM899+C67Xuux44dy5tvvonneWzcuJFXX82c+pw5cyYvvvgia9dmllNtampqbXnMnTuXxx57bKfH8TyPhx56iGXLlrVO4/344493GC6qyv/93/+xefNmTjvtNMaPH8+MGTO45pprWlsHa9asabfU6YgRIyguLubll19GVbn77ru7ZRpvCweT8+LNLeFQ5HMl/UephKh2mz/5wF4mIjz22GM8/PDDTJw4kcGDB+M4Dj/+8Y87PP6UU05h8eLFnHTSSa0zqF522WXcddddzJw5k3fffZfCwvZvGo4++mjGjRvHwQcfzPe+9z2mT58OQFlZGXfeeSfnn38+U6ZMYebMmaxatQqAt99+u90Kc4sXL2bUqFGMGvXR5VrHHnssK1eubF2P+vvf/37rUNbXXnuNRYsWtdb65z//mS1btjBhwgQOPvhgvva1r3XYKrj11lu59NJLmTBhAuPHj+f000/f0x9te6ra7z8OPfRQNWZXlqycr5PvnKwvvfQbv0vpN352x0w98Y4p7bavXLnSh2p27cUXX9TRo0frkiVL/C5FTznlFL9L2K2OfnfAEt3F/1U752ByXlNzDQCxyO4XbzcfKQ0VUp1q2OUJ4L7iqKOO6nB1Nz/885+5NUeodSuZnBdPZE6sFkQ6Hh1i2hsYLiEl0Jhq/OSDTU6ycDA5r6llKGt/mzzPR6XRTJBWx23q7nxl4WByXjy7znIsZi2HzhoUy8xXVtNH51cyPc/CweS8pmzXSEGsgwVyTIdKs7Ox9tXJ90zPs3AwOS+eakJUiUat5dBZA4szQy+rG2zey3xl4WByXjwdJ6aK2EVwnVZakpkcuaZxm8+V9A3pdJohQ4Ywd+7cnbYff/zx7L///kyZMoUDDjiAK664gpqamtb9W7ZsYc6cOYwfP56DDjqIM844o8PpOp566in2339/JkyYwK9+1ftXnnfEwsHkvKZ0nJiSmWDOdEpRSTlBVarj7aeHzkdPP/00+++/P/Pnz283l9F9993HsmXLWLZsGZFIpPXqZFXlc5/7HMcffzzvvfceK1eu5Je//CVbt27d6f6u63L55Zfz5JNPsnLlSubNm8fKlSt77XvbFXu1mJwXdxPYfKx7RgoGM9B1qUn0rcn31q9fzwEHHMCll17K5MmTueCCC3jmmWc4+uijmThxYus0F6+++ipHHXUUhxxyCEcddRSrV68GMtNdnHvuuUyZMoXzzjuPI444olMzss6bN4/vfOc7jB49mpdffrnDY8LhML/+9a/ZsGEDb731FosWLSIUCvHNb36z9Zhp06bxqU99aqf7vfrqq0yYMIF9992XcDjMnDlz2k2R4Qe7CM7kvCYvQYHa+6A9Ei6g1IMd2ZFeHbnh1RtYtWNVtz7tAYMO4OrDr97tMWvXruWhhx7itttu47DDDuP+++/nhRde4IknnuCXv/wlf/3rXznggANYvHgxwWCQZ555hh/96Ec88sgj3HLLLQwcOJBly5axfPnynab43pV4PM7ChQv54x//SE1NDfPmzdvlTKyBQICpU6eyatUqtm7d2m568Y5s2rSJffb5aI2z8vLyDld76232ijE5L+6miIn9qe+pgRKgJt33LoJrmfPIcRwmTZrErFmzEBEOPvhg1q9fD2Qm1/vCF77A5MmTueqqq1ixYgUAL7zwAnPmzAFg8uTJTJky5ROf7+9//zsnnHACBQUFfP7zn+exxx7rcLK+Fh/vdvokHR3fF65Kt5aDyXlxTVEg9qe+pwY6EVa7u16b+ZPe4feUSOSjFf0cx2m97TgO6XQagJ/+9KeccMIJPPbYY6xfv57jjz8e2PN/3JDpUnrxxRdbp9yuqqpi0aJFnHTSSe2OdV2Xt99+mwMPPJAhQ4bw8MMPf+Ljl5eXs3HjR0OGu2vK7a6yt1Mm5zWpS8yxcNhTpYEY1Zryu4y9Ultb2zoT6p133tm6/ZhjjmH+/PkArFy5krff/mglu4suuqj1nEWLuro6XnjhBTZs2NA65fbvf//7DqfcTqVSzJ07l3322YcpU6Zw4oknkkgk+NOf/tR6zGuvvca//vWvne532GGHsWbNGtatW0cymeSBBx7gM5/5TJd/Bl1l4WByXlxdYk7Y7zL6nYGhIupQ0l7a71L22A9+8APmzp3L0UcfvVMX0GWXXUZlZSVTpkzhhhtuYMqUKQwYkJlWZdmyZYwYMWKnx3n00Uc58cQTd2qtzJ49myeeeIJEItOquuCCC5gyZQqTJ0+msbGx9WRyy/TiCxYsYPz48UyaNIlrr722XasgGAxy8803c+qpp3LggQdy7rnnMmnSpB75ueyRXU3X2l0fwO3ANmB5m22DgAXAmuzngW32zQXWAquBUzvzHDZlt9mdY2+frD+/90S/y+h37n34XJ1852Stile1butrU3bvqXQ6rfF4XFVV165dq2PGjNFEIqG1tbV6zjnn+Fxdz9rTKbt7o+VwJ3Dax7b9EFioqhOBhdnbiMhBwBxgUvY+t4jI7lfXNuYTxFFiwfZLQZrdK8leUd6QXUkvFzQ1NXHMMccwdepUPve5z3HrrbcSDocpKSnhoYce8ru8PqXHO2JVdbGIjP3Y5tnA8dmv7wKeA67Obn9AVRPAOhFZCxwOvNTTdZrc5KlHs0BBwMJhT4Uime6WZOM2GDjB52q6R3FxcaeuazD+nXMYpqqbAbKfh2a3jwLazvRVkd3Wjoh8XUSWiMiSysrKHi3W9F/NySZUhFjILoPbU+HssqqJxM7XOuhejPgx/tqb31lfOyHd0eDeDr8rVb1NVWeo6oyysrIeLsv0V/HsFb6xoM2rtKci2a64VJsFf6LRKFVVVRYQ/YiqUlVVRTS6Z61nv8b3bRWREaq6WURGkDlhDZmWwj5tjisHbFpIs9eamjKL1RSELBz2VDiYaW0lU02t28rLy6moqMBa6/1LNBqlvLx8j+7jVzg8AVwM/Cr7+fE22+8Xkd8AI4GJwKsdPoIxnRBvzpxMjWW7SEznhbJdcYk24RAKhRg3bpxfJZle1OPhICLzyJx8HiIiFcA1ZEJhvohcAmwAvgCgqitEZD6wEkgDl6vqrq9TN+YTNDVnpk8uiBT7XEn/EwkWAJBMx32uxPihN0Yrnb+LXbN2cfz1wPU9V5HJJ/HmWgBi4RKfK+l/wtmuuFS62edKjB/62glpY7pVPFkHQCw7LNN0XjicaTkkrOWQlywcTE5rSmTCocCWCN1jLS2HpLUc8pKFg8lp8ex6BDELhz3WGg67mZnV5C4LB5PTmrJj9AsKBvtcSf/TchFcKm3hkI8sHExOi2fDIRYb5HMl/U84O8IrYS2HvGThYHJaPB0npEowYqOV9lQwWICokvQsHPKRhYPJaU3pOAWegmOT++4pCUUJq5Jyk36XYnxg4WByWtxNYFPu7SUnQFgh4fbP1eBM11g4mJzW5CYosD/zvRYGkp6FQz6yV43JaXEvScz+zPeahUP+sleNyWlxL0XMFhPcaxEVC7s1EQYAACAASURBVIc8ZeFgclqTpilw/Jp8uP8LISS9tN9lGB9YOJicFlePmBPyu4x+KyxC0iZGzksWDianNeERcyJ+l9FvRXAsHPKUhYPJaXGUgkDY7zL6rZAELBzylIWDyWlxgVjArnTYW2GxlkO+snAwOSuVTpIWoSBk4bC3IhIgqZ7fZRgfWDiYnNXUsn50drlLs+dCTpAk6ncZxge+hoOIXCUiK0RkuYjME5GoiAwSkQUisib72SbiN3sl3lQFQCy7LoHZc2EJkMRaDvnIt3AQkVHAlcAMVZ0MBIA5wA+Bhao6EViYvW3MHmtpORSEinyupP+KOCFs2r385He3UhCIiUgQKAA+BGYDd2X33wV81qfaTD8Xb64GIBaxcNhbYetWylu+hYOqbgL+G9gAbAZqVfVpYJiqbs4esxkY2tH9ReTrIrJERJZUVlb2VtmmH2lqrgWgIFLqcyX9V8gJkRS/qzB+8LNbaSCZVsI4YCRQKCJf6uz9VfU2VZ2hqjPKysp6qkzTj8UTmXCI2UI/ey3ihEmKoGqth3zjZ7fSScA6Va1U1RTwKHAUsFVERgBkP2/zsUbTjyVSDQBEwxYOeyucvYAwZZPv5R0/w2EDMFNECkREgFnAO8ATwMXZYy4GHvepPtPPNaeaAIhk10I2ey4cyEw9kkw2+VyJ6W2+TVepqq+IyMPA60AaeAO4DSgC5ovIJWQC5At+1Wj6t2S6GYBI2Iay7q2WlkMiVU9RzM7d5BNf5zJW1WuAaz62OUGmFWFMlyTScQDCYWs57K2WlkMq2ehzJaa3+T2U1Zgek0wnAIhYOOy1cLClW6nB50pMb7NwMDkr4Wa6lcI2WmmvhbOTFiZT1nLINxYOJmcl3CSOKkGbW2mvhYNRABIWDnnHwsHkrKSbJKKKBGwN6b3VEg6plI1WyjcWDiZnJbwktsxP14Szra6khUPesXAwOSvppYiozf3QFeHsWhgJC4e8Y+FgclbCSxHBwqErwqFsyyE7LNjkDwsHk7OSXtrCoYtawiGVvaDQ5A8LB5OzEl6asP2Jd0k4u1BSwloOecdeOSZnJTRNROxPvCtawiFpLYe8Y68ck7OS6hK2cOiScHZeqqSb8LkS09vslWNyVrN6RMSuceiKlqlHLBzyj4WDyVlJPCLi69yS/V4onFli1cIh/1g4mJyVwCPsWDh0RTBUgKiSdJN+l2J6mYWDyVlJlIgT8ruMfk2CESIWDnnJwsHkrAQQtnDoGhFCQNKzcMg3Fg4mZyWBSMBmV+qqsELSTftdhullvoaDiJSKyMMiskpE3hGRI0VkkIgsEJE12c8D/azR9E+qSkI+WubS7L0I1nLIR363HH4LPKWqBwBTgXeAHwILVXUisDB725g9knYTeCJEHAuHrgojJNVaDvlmr8NBRP7elScWkRLgWOAvAKqaVNUaYDZwV/awu4DPduV5TH5KJuoBiGSXuTR7L4SQ9Cwc8k1XWg5f6+Jz7wtUAneIyBsi8mcRKQSGqepmgOznoR3dWUS+LiJLRGRJZWVlF0sxuSaRzIRDOBD1uZL+L4JDwnP9LsP0sr0Oh5Z/4F0QBKYDt6rqIUAje9CFpKq3qeoMVZ1RVlbWxVJMrmlpOUSDFg5dFRaHFBYO+aZTVwiJyDpAP75dVfftwnNXABWq+kr29sNkwmGriIxQ1c0iMgLY1oXnMHkqkWwAPlrm0uy9EA4JtXDIN529fHRGm6+jwBeAQV15YlXdIiIbRWR/VV0NzAJWZj8uBn6V/fx4V57H5KdEKhMOkewyl2bvRZwA9XZCOu90KhxUtepjm/5XRF4AftbF5/82cJ+IhIH3ga+Q6eqaLyKXABvIBJExeySZbAQgEoz5XEn/FyZAUm0oa77pbLfS9DY3HTItieKuPrmqvsnOrZIWs7r62Ca/Nacy4dCykpnZeyEnSNLz/C7D9LLOdiv9T5uv08A64NzuL8eY7pHMhkPEwqHLIk6QZPtTjibHdbZb6YSeLsSY7pRINQEQDhX5XEn/FxYLh3zUlYvgpn/yUcb4I5HOhEMkbC2Hrgo7IeyMQ/7pykVw3+q2KozpZslUHICItRy6LBwIkRS/qzC9rdMroWQnwJtIZigrwD09UpEx3SDhNgMQDls4dFXYCZMUQVURsZTIF50drXQp8B2gHHgTmAm8BJzYc6UZs/eS6Uw4tKyBbPZeOJBZEyPlJgnbXFV5o7PdSt8BDgM+yJ6cPoTMvEjG9EmJbDiEIxYOXRUOZAIhmb2w0OSHzoZDs6o2A4hIRFVXAfv3XFnGdE3CTQAQjpT4XEn/1xIOiYSFQz7p7DmHChEpBf4KLBCRauDDnivLmK5JukmCqgRtbqUuawmHVPbaEZMfOnudw+eyX14rIouAAcBTPVaVMV2U8JKEVcFOoHZZy+SFyaS1HPJJp0crtVDVf/VEIcZ0p6SbxE6ddo+WcEhYOOQVv5cJNaZHJLwUEbVWQ3f46IR0k8+VmN5k4WByUsJLEcHCoTu0THueSls45BMLB5OTEl6asIVDtwiFst1K1nLIKxYOJiclNE1E7M+7O7RMe27dSvnFXj0mJyXVJSwBv8vICZFgIfDRVecmP1g4mJyUUNdaDt0kHMqsppe0cw55xV49Jicl1SMiezxS23QglJ280FoO+cX3cBCRgIi8ISJ/z94eJCILRGRN9vNAv2s0/U8Cj7CFQ7doWU0vmZ2SxOQH38OBzKR+77S5/UNgoapOBBZmbxuzR5KqRBwLh+4QDmUmL7SWQ37xNRxEpBz4NPDnNptnA3dlv74L+Gxv12X6v4QoYSfkdxk5IRzJnpC2lkNe8bvl8L/ADwCvzbZhqroZIPt5aEd3FJGvi8gSEVlSWWmzh5udJYCIhUO3aFmH28Ihv/gWDiJyJrBNVZfuzf1V9TZVnaGqM8rKyrq5OtPfJQUiAQuH7hAMF+GoknRTfpdiepGfnbJHA58RkTPILD1aIiL3AltFZISqbhaREcA2H2s0/ZB6HgkRwo5NvdctAkHCqiTdpN+VmF7kW8tBVeeqarmqjgXmAM+q6peAJ4CLs4ddDDzuU4mmn0ql4wBEAhYO3SUMJD0Lh3zi9zmHjvwKOFlE1gAnZ28b02mJRB0A4UDY50pyR1gh6Vm3Uj7pE2P9VPU54Lns11XALD/rMf1bIlkPQDR7Za/pujBi4ZBn+mLLwZguSSQy4RAO2BKh3SUTDmm/yzC9yMLB5JxEKrNiWSRoLYfuEkZIqut3GaYXWTiYnNOy1nHEupW6TRiHhLUc8oqFg8k5LS2HsLUcuk1YHFLWcsgrFg4m5ySTjcBHE8aZrguLY91KecbCweScluUsw6FCnyvJHWEJkNhplhuT6ywcTM5JpLIXwVnLodtEJEBKLRzyiYWDyTktK5ZFsovUmK4LOUGSqN9lmF5k4WByTiK77kDYwqHbhCVIwsIhr1g4mJyTbJlbKVzscyW5I+IESVk45BULB5NzEunMugNhC4duE3JC2LR7+cXCweSchJvpVrKWQ/cJO2ES4ncVpjdZOJic07JiWThi4dBdwoEQKRFUrWspX1g4mJyTcJOEVHFsJbhuE8lOf57Knuw3uc/CweSchJsgYm9wu1XIyYRDy4y3JvdZOJick/BSFg7dLBzMTH+ezM5bZXKfhYPJOUkvhS0Q2r1au5Wy81aZ3OdbOIjIPiKySETeEZEVIvKd7PZBIrJARNZkPw/0q0bTPyW8FGFsaE13CmVnuG2ZDt3kPj9bDmngP1T1QGAmcLmIHAT8EFioqhOBhdnbxnRaQl0iYo3i7tSyql4ibS2HfOHbK0hVN6vq69mv64F3gFHAbOCu7GF3AZ/1p0LTXyW9NBHrMe1WsezCSU2JOp8rMb2lT7yCRGQscAjwCjBMVTdDJkCAof5VZvqjhLqEJeB3GTllVNFIACrqN/pciektvoeDiBQBjwDfVdVOvy0Rka+LyBIRWVJZWdlzBZp+J6kuEQuHbrXP4AMQVT6oed/vUkwv8TUcRCREJhjuU9VHs5u3isiI7P4RwLaO7quqt6nqDFWdUVZW1jsFm34hgWcth24WLh7FyLTL+oYKv0sxvcTP0UoC/AV4R1V/02bXE8DF2a8vBh7v7dpM/5ZEiThBv8vILYVDGJtK8UHzdr8rMb3Ez1fQ0cCFwNsi8mZ224+AXwHzReQSYAPwBZ/qM/1UQpWwY1NndKtAiLEEeTNVi6qSeW9ncplv4aCqL8AuB6PP6s1aTG5JiLUcesKYQCGNmmR7fDtlBdaVm+t8PyFtTHdLApHsXECm+4yJZK5HXV+33t9CTK+wcDA5JyGZKaZN9xobGw7AB3Uf+FyJ6Q0WDianuG6alAgRx2ZX6m7Di8sJq1o45AkLB5NTWub+CQctHLqbUzyM0akU62ve87sU0wssHExOSWand4hm5wIy3ahwKGNTaT6oXed3JaYXWDiYnJJIZhajsZZDDygayphUio2Nm0l7ab+rMT3MwsHklES2WykSiPlcSQ4qLGNMKk1aXTY3bPa7GtPDLBxMTmk55xAJWrdStysaythUCrDhrPnAwsHklEQq260UKvC5khyUbTmADWfNBxYOJqckU00ARIIWDt0uEGJgpJRiCVrLIQ/YHAMmpySyaxyHQ3bOoSdI0VDGYi2HfGAtB5NTEulsyyFc5HMlOaqwjLGuXQiXDywcTE5p7VYKFfpcSY4qGsqYRDObGzcTT8cB8NTzuSjTEywcTL+0ZfPrLPz3r9ttT6SbAQhby6FnFA1jTDxz0v8bC77BqQ+dzPS7pvLc63/0uTDT3SwcTL90zYLL+O6ae3hxzd922r6iNjO1Q3HBED/Kyn2FZUxrqGVk4Qia081Miw1jeDrN75b9Ac9z/a7OdCMLB9PvrH5/Af/WRoKq/Odr/0VTtivprcq3uG/HW5ydDDCkbJLPVeaooqEMd13+Oes25p81nxuiE7i8uoZ3Jc2iJb/3uzrTjSwcTL9zx6s3UuB53NQobErVc8ubt9CcbuYni3/IUDfN9yacA7ZSWc8oHJr53FCZ+bxpKacXjmG0q/xx5Z2oaod3S6WaUM/OTfQnFg6mz/HcNNu3r2b12if59+u3saHildZ9m6tW81Tzh3w+Ws7xky/knLp67ll5D99f/H3WN1Twi8oqiqec72P1Oa4ouwJcw1bwXNj0BsExR/O1UbN4R1IsXnrrTofH49X8+W9f5rh7D+eb9xxJXV2FD0WbvdFnw0FEThOR1SKyVkR+6Hc9pnesePcJzr77UE74/87hnBd/wDfe/h2fe+YS/vbSDQDc88IvALjw8O/DQZ/lquoaBgeiPLfxOc51Ixw58EAYPN7PbyG3FQ3LfG7cBtvfhWQ9jDqUTx9/HaNc5Q/L/0LaTbF63ULue+pyzpz3KX67Yyn7S5RXtZELHzmDjRUv+/s9mE7pkxfBiUgA+D1wMlABvCYiT6jqyu58nrSXJuEmKOzksEfXc6lL1lEQKiASsFk/u1MqleC2p77Bn6qWMFjh6iFHM6yknNJYGX9Y9gd+9O69rKh5j8eql3GaFjBi/EkAlJRN4vpkkIfKp/EfLz1I8sSf8+H2RsYOsaGsPaIw03L4+7/f4uCaFGMARs0gFCnmayOP59qt/2LmPYeQyHbrTZEQN0y9khnTvsJrb/yZ7755E19ccCn/b+xsZky+gPIhByLWBdgn9clwAA4H1qrq+wAi8gAwG+jWcHhp4woue+5LFEoJw7SQUWml2aunSuJsd1w8cQhKmEAgRrO4NLmNKB6CMNgpZpQbZKAHDg4BAjQ7QXYEHGrFJY0SJUSMABF1CHpK0PNQlIYANDoeKXEJEyAqDiHPJZmuJ+k2kSZFRB0KCBIlhEcAFyGtDik8Unik8XAcCDkBgo6QFJdGTdFImogEKJEYhU4RARXUS+BpgrSmSKlLSj1cEdSJ4DpRPPnYesvZbmNPIY1LWjOjUIqIMIAwJZ7ieo0ktYm0JglJmLBTSCBQSIN61HlJGkkgmiJACkfTiHgIIKIEJEDACRMMRElriia3mXpSNAqc7JVwwuTfEisaTWlBiNKCMJcVz2L4c3O4b9tLIHBgbDbLN9Wy37BiEuPP5Mh//4oyJlKgyrH/HEzFP55j0feOZ8xgC4huFwgRDw5gx7ZNvLR9IyMjxYQGTwDgM8ddz1sPnUmAMCWh/diRPpRU8WE8Xxnj3Vc2UBA+nW+PGcS9667hZxuegA1PMNhzGBIoJilBmjVIQpWUpklrCkEo1hgDJEKx46CSJCVJUqRJuR5JT/E8iGmQmISISoB4MEmNNFNHkmJClHgRom6YtEISjyQeOGk0kCaFS1gCxCRM1IkQIoSjDgEckm4jjW49ddpMs3ikgZRAECEmEcJOERqIkcQlSRJFiUqQGEGiKjiuIq6H43oE8AioiyOK54QgGMZzgjQDcU9JqAteCsdLEfTShIEIASI4pIIh4oEAyYBDmADFGqDYg7Tn0aAu9Z7L+KID+O/zftvtv+q+Gg6jgI1tblcAR7Q9QES+DnwdYPTo0Xv1JOHN7/GtHfVsCjWwPhRiZTBIAQ6lqTDD3SJKvHpiUkXKEQo8j4GuR6ErxAPK+lAD60Jh3nECpAXSAhHXY3DSY4zrElKlwXFocBx2OEJKhBSZd0ilaZchrkeBKgkRmkVICRR4UOBF8DRC0nFpdFJUSwIRRVACKCFVChRCCrgAigeUeEK5J0Q8QR2XpkAtVQGHZoSQKqIBguoQ0gCiDlFSxKQWD1ARJHsiUUVQoOXUYViVcHbfjkCA7YEA7zkOBZ5mQy9AkySo1lriCoWeMtDzGON5hFQBh6RESWmAtCd4OAQlRUhqQFxCCuKFcd0CmhoP4tG6c3n03W3Atp1+VwX8iEvKbiQdaOQXWw7GfeMFAMZJGYsiMGHDQ7wpBzFz2sHMX1LBc6srufgoC4fulnY9tqSL2a8oztD0h7zUPJY3nn2PkliQRasrefn9H5FMZ/56hhSFgW1sb0i2eYQIAf6TA6NLKC98HY1V4AW2EkAJAEFVItmPlAhVAYftgQBbxKFAPYo8jwIv0x8ugCdKozjUOw7bRShrdtk/7VHqKnUBoTLosD3gEFCIqFKsSiythDwhqA5pURKOR6Mj1ErmdZoUIeophW6Aweko4oURdTKvGydOLFBHs1NDWjJ/7wVe5vUZdxwaRYg7mcdoFiGN4EnmQ4GAqwRcxUEJK5Ro5jXtkHlPlsYh4QgNImwXIZZ2KUwqparERagMOLzrOASBQs+jyFMKapp75HfdV8Oho3bmTsMgVPU24DaAGTNmdDxE4hMccfBxHFFzPgyfAiOmwpD9ILDzjyTZUE3dmhfxajZC0w5oqsIrHoGWH0Fg1DQikRjigCMCbhKt3Yiz4wNINSLREpxYCU60hFC0CAlnJoPThkqaa7aQbKwlFSwgFSwiHS6lqGw0JYVRAo60fI94SuvtjtQ2pVhbWU91Y4rGZJqGRJqCcIChhUFGBOoIhCLEgyUkXMFTbW3ChwMOJcEUA+rXEG7aRkvICBAKhggEgpkfeToBbvbFXTgkM1qlaBgUDNp5RJDn4TZUEnCbP7pP0bDMfbLHpVyPzTXN1DWnSKRdkk31pCSEJ0E0W9O3QwGiIYe0q9TEU9Q0JYmGAkzbp5RhJZ8HN81FDSleeq+KDTuaKCueTP1LB1Jc8w5TT7+EaYdP5eX3d/D8mkouPmrs3vxZmN1YuGobJW4Jk6I7KK79gHfLzuemZ94FYN+yQr50xBgOHzeIqfsMYHhJFBEh5Xpsb0gQT7p4qqQ9Je2eQNL1SKY9IgEYGahhcPJDgona7N+LQCAM0QEQHYAbLmJHMsjmuEM8Lew/vJjSgmyLVxXUQ9VjS32Kd7bUs6GqibFDCpk0cgBlhSHw0pkPdfECMTbWJli1JXMxX3E4QHEgRTTgEQkIoaAgkRLUCaAKnmZaKK4qAkSDDrH69Ti1H+Amm0g3N5F206QiA0mGSiFWStngwRSXDEBCheB8dGrXcz3q6muI126nyElSSDOO2wwFQ6BkBERKdn5dpZpJVFfQVLURdcJIYRlO4RAKoyGCXhLS8czPqQfIroae+UlEjgSuVdVTs7fnAqjqf3V0/IwZM3TJkiW9WKHpU176PTx7PXx3GRQO4cePvc1f39jEGz87hXCwz4656Jcuvv1VLqj4Oad4mZabd948Xg4dzqiBMevG64dEZKmqzuhoX1995bwGTBSRcSISBuYAT/hck+mrjvgWfPftTCsFOHa/MhqTLq9vqPa5sNyycUcTi9dUUja8vHWbs89hHDVhiAVDDuqT4aCqaeAK4J/AO8B8VV3hb1Wmz3IcKBzcevOo8YMJOMLidyt9LCr3zHt1A44IE8btm9lQOvqj6x5MzumT4QCgqv9Q1f1UdbyqXu93Pab/KI6GmD66lMVrLBy6SzLtMX/JRk48YCjFg0dmNo7qsDfC5Ig+Gw7GdMWxE8tYvqmOqoaE36XkhBfXbmd7Q5IvHj4airJTaIw61N+iTI+ycDA56dj9Mt0dL6zd7nMlueGNjTU4AjP3HZwZ3Vd2AOx3mt9lmR5k4WBy0uRRAygtCPEvO+/QLZZvqmXi0GJi4UBmyOXlr8CQCX6XZXqQhYPJSQFHOGbCEJ5fs32XM4WazlFVllXUMnnUAL9LMb3IwsHkrGP3K6OyPsHqrfV+l9Kvba1LsL0hwcGjSvwuxfQiCweTs47cNzO89dV1O3yupH97e1MtAAeXl/pcielNFg4mZ5UPjDFyQJRXLBy65O2KzMnog0ZYyyGfWDiYnCUiHDZuEK+u22HnHbrg7bYno03esHAwOe3wcYOorE/wQVWT36X0S6rK25vq7GR0HrJwMDntiHGDADvvsLe21DWzvSHBlHILh3xj4WBy2viyIgYVhu28w156uyJzMtpaDvnHwsHkNBHh8LGDeHV9ld+l9Etvb6q1k9F5ysLB5LzDxw1i4444m2vjfpfS77ydXY7VTkbnHwsHk/MOt/MOe0VVWb7JrozOVxYOJucdOKKEokjQwmEPba5tZntDkoMtHPKShYPJeQFHmDF24C7DIeV6vVxR35FIu8x/bSO/eXo129tMb+55yrxXNwB2MjpfBf0uwJjecPi4Qfx69WruefkDHIF40mXl5jqWVdTyXmUDE8qKOH3ycE6ZNJzaeIrX1u/gjQ01pD2PAbEQA2JhhpdEGTO4gDGDCxhUGMYRIeAIybTHjqYk1Y1JqhqTVNZn5iJqSrjEwgGioQDF0SCjSmOMLI0xvCRKOOgQCgiewoc1cSqq42ypa269WE9ECDpCMJD53JzyaEq6NKdcBsRCDB8QZVhJFIDGRJqGRJrqpiRVDUmqGhJsqWvmw5pmPqyJ05BIt/4cBheGOWzcIGbuO5j65hR/eWEdW+syoXDHv9fz/07ej6MnDOFHj77Nkg+qOenAYUy1Yax5SXLhytEZM2bokiVL/C7D9GHLN9Vy5u9e2GnbkKIwU8tLmTismDc2VPPa+h142ZeDCOw/rJjCSJDaeIqapiTbG5Kdfr6iSJCCcIBE2iOeckmme691UhINMrQk2hpGJdEgSGZfRXWcV97f0dpKOGr8YL553HhGlkb5+d9W8vya7a2Pcc1Zkzh7+ihEpNdqN71LRJaqaodL+vkSDiJyI3AWkATeA76iqjXZfXOBSwAXuFJV//lJj2fhYDqjsj5B0vUIOUIo4FBaENrpH9/2hgT/Wl3J4KIw08cMpCQa2un+zSmXjTua+KCqidp4ClcVz1NCAYdBRWEGFYQZVBhmSFGk3eieeNJlU02cTTVxttU1k3K1tTtrxIAo5QMLGDEgSiAgqGZOBrueks5+RIMOBeEgkaBDbTzF5tpmttY1g2SCqDAcZFBh5vnDwd33Fqsq729vJO0q+w8v3mn7P1ds5eX3q7js+PEMzbZMTO7qi+FwCvCsqqZF5AYAVb1aRA4C5gGHAyOBZ4D9VNXd3eNZOBhjzJ7bXTj4ckJaVZ9W1ZaO0JeB8uzXs4EHVDWhquuAtWSCwhhjTC/qC6OVvgo8mf16FLCxzb6K7LZ2ROTrIrJERJZUVtpSkMYY0516bLSSiDwDDO9g149V9fHsMT8G0sB9LXfr4PgO+71U9TbgNsh0K3W5YGOMMa16LBxU9aTd7ReRi4EzgVn60YmPCmCfNoeVAx/2TIXGGGN2xZduJRE5Dbga+Iyqtp1o/wlgjohERGQcMBF41Y8ajTEmn/l1EdzNQARYkB1K+LKqflNVV4jIfGAlme6myz9ppJIxxpju50s4qOqE3ey7Hri+F8sxxhjzMX1htJIx/3979x9qd13Hcfz58t5qTgldltmspuEyM3JZZCbV0mjT6Md/VoL9IAisVArZlKKgIEKkiJbJ1jZraKSmIjIW2jASpGVzP9qWP9JlrLZ+0C8hN3r1x+czOJ3vPdu53Xvuse/39YDLPefz/fV53XP3fe/7Ped+PhHxHNOK4TMkHQCemsEuTgL+OEvd+X/RxczQzdzJ3B3Tzf1K2y+eakErisNMSdoy6K8E26qLmaGbuZO5O2Yzd24rRUREQ4pDREQ0pDgUN427A2PQxczQzdzJ3B2zljvvOUREREOuHCIioiHFISIiGjpdHCQtk7RH0mOSVoy7P6Mg6eWSfiJpl6Sdkq6s7Qsk/VjSo/X7iePu6yhImpD0S0n31Oetzi3pBEm3SdpdX/O3tD0zgKSr6+/3Dkm3SJrXxtySvitpv6QdPW0Dc0paWc9veyS9ezrH6mxxkDQBfAtYDpwFfLDORNc2h4DP2n4NcB5wRc25ArjP9hnAffV5G10J7Op53vbc3wA22j4TeD0le6szS1oIfAZ4o+2zgQngUtqZex2wrK9typz13/mlwGvrNqvqeW8onS0OlBnmHrP9hO1ngVspM9G1iu19th+uj/9OOVkspGRdX1dbD7x/PD0cHUmnApcAq3uaW5tb0guBtwFrAGw/W+dmb23mHpPAsZImgfmUof5bl9v2pHg6gwAABClJREFUA8Cf+5oH5ZzRzJpdLg5DzzrXFpIWAUuAh4CTbe+DUkCAl4yvZyPzdeAa4N89bW3OfTpwAFhbb6WtlnQc7c6M7d8B1wN7gX3AX21vouW5ewzKOaNzXJeLw9CzzrWBpOOB24GrbP9t3P0ZNUnvAfbb/sW4+zKHJoE3AN+2vQT4J+24lXJE9R77+4DTgJcBx0m6bLy9ek6Y0Tmuy8WhM7POSXoepTBssH1Hbf6DpFPq8lOA/ePq34i8FXivpCcptwzfKen7tDv308DTth+qz2+jFIs2Zwa4CPiN7QO2DwJ3AOfT/tyHDco5o3Ncl4vDz4EzJJ0m6fmUN27uHnOfZp3KbEprgF22b+hZdDdweX18OXDXXPdtlGyvtH2q7UWU1/Z+25fR4ty2fw/8VtKra9OFlImzWpu52gucJ2l+/X2/kPLeWttzHzYo58xm1rTd2S/gYuDXwOPAdePuz4gyXkC5lNwGbK1fFwMvonyy4dH6fcG4+zrCn8E7gHvq41bnBs4BttTX+07gxLZnrrm/BOwGdgDfo8w02brcwC2U91UOUq4MPn6knMB19fy2B1g+nWNl+IyIiGjo8m2liIgYIMUhIiIaUhwiIqIhxSEiIhpSHCIioiHFITpL0ksl3SrpcUm/knSvpMWSFvWOejnNfT4p6aSjrHNt3/MHj7L+ZkmzMml8xLBSHKKT6h9L/QjYbPtVts8CrgVOnoPD/1dxsH3+HBwzYlpSHKKrlgIHbd94uMH2Vts/7V2pzguwVtL2Opjd0to+Ien62r5N0qf7tjtW0kZJn+hr/ypl9NCtkjbUtn/0LL+m7vORum7vtsdIWi/py/X46+r8BdslXT1bP5gIKAN1RXTR2cAwg/JdAWD7dZLOBDZJWgx8lDLQ2xLbhyQt6NnmeMp4Tjfbvrl3Z7ZXSPqU7XP6DyRpOWW45TfbfqZvn5PABmCH7a9IOhdY6DJ/AZJOGDJ3xFBy5RBxZBdQhmPA9m7gKWAxZbC3G20fqst6x9i/C1jbXxiGcFHd7pkp9vkdamGoz58ATpf0TUnLgNaPtBtzK8UhumoncO4Q60017PHh9kFjz/wMWF7f15iOI+3zQWCppHkAtv9CmeltM+XqZvWA7SL+JykO0VX3Ay/ofU9A0pskvb1vvQeAD9fli4FXUAYx2wR8ss48Rt8toC8AfwJWDTj2wTqMer9NwMckzZ9in2uAe4EfSpqsn4g6xvbtwOcpQ3NHzJoUh+gklxEnPwC8q36UdSfwRZrj3a8CJiRtB34AfMT2vyj/U98LbJP0CPChvu2uAuZJ+toUh7+pbrehr08bKcMsb5G0Ffhc3/IbgIcpt7kWApvreuuAldOIH3FUGZU1IiIacuUQERENKQ4REdGQ4hAREQ0pDhER0ZDiEBERDSkOERHRkOIQEREN/wF8HvelByLGdAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results.\n",
    "plt.figure(1)\n",
    "for ii, iq in enumerate(iq_list):\n",
    "    plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n",
    "plt.ylabel(\"a.u.\")\n",
    "plt.xlabel(\"Clock ticks\")\n",
    "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rep-to-rep consistency\n",
    "In this notebook we mostly use decimated readout (we acquire a full waveform, not just a single accumulated value). To avoid exhausting the waveform buffer, we usually run with reps=1 (the tProcessor program only fires+reads one pulse, and we run the program `soft_avgs` times).\n",
    "\n",
    "However, it's important to check that if you run a tProcessor loop with reps>1, the pulse looks the same in each iteration of the loop. So let's do a decimated readout with multiple reps; the 1024-sample buffer will allow for 10 reps of 100 samples each.\n",
    "\n",
    "Try changing the relax_delay to 0. You will see that the first rep appears in the same place, but the others are delayed by a bit because the tProcessor didn't have enough time between waiting for the measurement in one rep and firing the pulse in the next rep."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c8a13d25df5b47969837f8268700f42a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":10, # --Fixed\n",
    "        \"relax_delay\":1.0, # --us\n",
    "        \"res_phase\":0, # --degrees\n",
    "        \"pulse_style\": \"const\", # --Fixed\n",
    "        \n",
    "        \"length\":20, # [Clock ticks]\n",
    "        # Try varying length from 10-100 clock ticks\n",
    "        \n",
    "        \"readout_length\":100, # [Clock ticks]\n",
    "        # Try varying readout_length from 50-1000 clock ticks\n",
    "\n",
    "        \"pulse_gain\":3000, # [DAC units]\n",
    "        # Try varying pulse_gain from 500 to 30000 DAC units\n",
    "\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        # In this program the signal is up and downconverted digitally so you won't see any frequency\n",
    "        # components in the I/Q traces below. But since the signal gain depends on frequency, \n",
    "        # if you lower pulse_freq you will see an increased gain.\n",
    "\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        # Try varying adc_trig_offset from 100 to 220 clock ticks\n",
    "\n",
    "        \"soft_avgs\":100\n",
    "        # Try varying soft_avgs from 1 to 200 averages\n",
    "\n",
    "       }\n",
    "\n",
    "###################\n",
    "# Try it yourself !\n",
    "###################\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "iq_list = prog.acquire_decimated(soc, progress=True)\n",
    "\n",
    "plt.figure(1)\n",
    "for ii, iq in enumerate(iq_list[0]):\n",
    "#     plt.plot(iq[0], label=\"I value, rep %d\"%(ii))\n",
    "#     plt.plot(iq[1], label=\"Q value, rep %d\"%(ii))\n",
    "    plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, rep %d\"%(ii))\n",
    "plt.ylabel(\"a.u.\")\n",
    "plt.xlabel(\"Clock ticks\")\n",
    "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "plt.legend();\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple triggers\n",
    "You can send multiple triggers inside a loop. The output data arrays will gain a dimension, corresponding to the trigger number.\n",
    "\n",
    "Let's check the rep-to-rep consistency as well as the consistency between the first and second trigger."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "675c216fa9ea45d99f8a73617ad122cb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class DoubleTriggerProgram(AveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg=self.cfg   \n",
    "        res_ch = cfg[\"res_ch\"]\n",
    "\n",
    "        # set the nyquist zone\n",
    "        self.declare_gen(ch=cfg[\"res_ch\"], nqz=1)\n",
    "        \n",
    "        # configure the readout lengths and downconversion frequencies (ensuring it is an available DAC frequency)\n",
    "        for ch in cfg[\"ro_chs\"]:\n",
    "            self.declare_readout(ch=ch, length=self.cfg[\"readout_length\"],\n",
    "                                 freq=self.cfg[\"pulse_freq\"], gen_ch=cfg[\"res_ch\"])\n",
    "\n",
    "        # convert frequency to DAC frequency (ensuring it is an available ADC frequency)\n",
    "        freq = self.freq2reg(cfg[\"pulse_freq\"],gen_ch=res_ch, ro_ch=cfg[\"ro_chs\"][0])\n",
    "        phase = self.deg2reg(cfg[\"res_phase\"], gen_ch=res_ch)\n",
    "        gain = cfg[\"pulse_gain\"]\n",
    "        self.default_pulse_registers(ch=res_ch, freq=freq, phase=phase, gain=gain)\n",
    "\n",
    "        style=self.cfg[\"pulse_style\"]\n",
    "\n",
    "        if style in [\"flat_top\",\"arb\"]:\n",
    "            sigma = cfg[\"sigma\"]\n",
    "            self.add_gauss(ch=res_ch, name=\"measure\", sigma=sigma, length=sigma*5)\n",
    "            \n",
    "        if style == \"const\":\n",
    "            self.set_pulse_registers(ch=res_ch, style=style, length=cfg[\"length\"])\n",
    "        elif style == \"flat_top\":\n",
    "            # The first half of the waveform ramps up the pulse, the second half ramps down the pulse\n",
    "            self.set_pulse_registers(ch=res_ch, style=style, waveform=\"measure\", length=cfg[\"length\"])\n",
    "        elif style == \"arb\":\n",
    "            self.set_pulse_registers(ch=res_ch, style=style, waveform=\"measure\")\n",
    "        \n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "    \n",
    "    def body(self):\n",
    "        # fire the same pulse+trigger twice, with 100 tProc clock ticks in between\n",
    "        # with the first ADC trigger, pulse PMOD0_0 for a scope trigger\n",
    "        # after the second pulse, pause the tProc until readout is done\n",
    "        # and increment the time counter to give some time before the next measurement\n",
    "        # (the syncdelay also lets the tProc get back ahead of the clock)\n",
    "        self.measure(pulse_ch=self.cfg[\"res_ch\"], \n",
    "                     adcs=self.ro_chs,\n",
    "                     pins=[0], \n",
    "                     adc_trig_offset=self.cfg[\"adc_trig_offset\"],\n",
    "                     syncdelay=100)\n",
    "        self.measure(pulse_ch=self.cfg[\"res_ch\"], \n",
    "                     adcs=self.ro_chs,\n",
    "                     adc_trig_offset=self.cfg[\"adc_trig_offset\"],\n",
    "                     wait=True,\n",
    "                     syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n",
    "\n",
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":5, # --Fixed\n",
    "        \"relax_delay\":1.0, # --us\n",
    "        \"res_phase\":0, # --degrees\n",
    "        \"pulse_style\": \"const\", # --Fixed\n",
    "        \n",
    "        \"length\":20, # [Clock ticks]\n",
    "        # Try varying length from 10-100 clock ticks\n",
    "        \n",
    "        \"readout_length\":100, # [Clock ticks]\n",
    "        # Try varying readout_length from 50-1000 clock ticks\n",
    "\n",
    "        \"pulse_gain\":3000, # [DAC units]\n",
    "        # Try varying pulse_gain from 500 to 30000 DAC units\n",
    "\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        # In this program the signal is up and downconverted digitally so you won't see any frequency\n",
    "        # components in the I/Q traces below. But since the signal gain depends on frequency, \n",
    "        # if you lower pulse_freq you will see an increased gain.\n",
    "\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        # Try varying adc_trig_offset from 100 to 220 clock ticks\n",
    "\n",
    "        \"soft_avgs\":100\n",
    "        # Try varying soft_avgs from 1 to 200 averages\n",
    "       }\n",
    "\n",
    "prog = DoubleTriggerProgram(soccfg, config)\n",
    "iq_list = prog.acquire_decimated(soc)\n",
    "\n",
    "plt.figure(1)\n",
    "for rep in range(config['reps']):\n",
    "    for trig in range(2):\n",
    "        plt.plot(np.abs(iq_list[0][rep][trig][0]+1j*iq_list[0][rep][trig][1]), label=\"mag, rep %d trig %d\"%(rep, trig))\n",
    "plt.ylabel(\"a.u.\")\n",
    "plt.xlabel(\"Clock ticks\")\n",
    "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple pulses\n",
    "\n",
    "Here's an example of playing multiple pulses from the same generator, with a 90-degree shift in the carrier phase between the two pulses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "acdbeb9c2db744f8835fb9462d0bb012",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class DoublePulseProgram(AveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg=self.cfg   \n",
    "        res_ch = cfg[\"res_ch\"]\n",
    "\n",
    "        # set the nyquist zone\n",
    "        self.declare_gen(ch=cfg[\"res_ch\"], nqz=1)\n",
    "        \n",
    "        # configure the readout lengths and downconversion frequencies (ensuring it is an available DAC frequency)\n",
    "        for ch in cfg[\"ro_chs\"]:\n",
    "            self.declare_readout(ch=ch, length=self.cfg[\"readout_length\"],\n",
    "                                 freq=self.cfg[\"pulse_freq\"], gen_ch=cfg[\"res_ch\"])\n",
    "\n",
    "        # convert frequency to DAC frequency (ensuring it is an available ADC frequency)\n",
    "        freq = self.freq2reg(cfg[\"pulse_freq\"],gen_ch=res_ch, ro_ch=cfg[\"ro_chs\"][0])\n",
    "        gain = cfg[\"pulse_gain\"]\n",
    "\n",
    "        style=self.cfg[\"pulse_style\"]\n",
    "\n",
    "        if style in [\"flat_top\",\"arb\"]:\n",
    "            sigma = cfg[\"sigma\"]\n",
    "            self.add_gauss(ch=res_ch, name=\"measure\", sigma=sigma, length=sigma*5)\n",
    "            \n",
    "        if style == \"const\":\n",
    "            self.default_pulse_registers(ch=res_ch, style=style, freq=freq, gain=gain, \n",
    "                                         length=cfg[\"length\"])\n",
    "        elif style == \"flat_top\":\n",
    "            # The first half of the waveform ramps up the pulse, the second half ramps down the pulse\n",
    "            self.default_pulse_registers(ch=res_ch, style=style, freq=freq, gain=gain, \n",
    "                                         waveform=\"measure\", length=cfg[\"length\"])\n",
    "        elif style == \"arb\":\n",
    "            self.default_pulse_registers(ch=res_ch, style=style, freq=freq, gain=gain, \n",
    "                                         waveform=\"measure\")\n",
    "        \n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "    \n",
    "    def body(self):\n",
    "        phase1 = self.deg2reg(self.cfg[\"res_phase\"], gen_ch=self.cfg[\"res_ch\"])\n",
    "        phase2 = self.deg2reg(self.cfg[\"res_phase\"]+90, gen_ch=self.cfg[\"res_ch\"])\n",
    "        # fire a single trigger, but two pulses offset by 200 tProc clock ticks\n",
    "        # with the first ADC trigger, pulse PMOD0_0 for a scope trigger\n",
    "        # after the full sequence is set up, pause the tProc until readout is done\n",
    "        # and increment the time counter to give some time before the next measurement\n",
    "        # (the syncdelay also lets the tProc get back ahead of the clock)\n",
    "        self.trigger(adcs=self.ro_chs,\n",
    "                     pins=[0], \n",
    "                     adc_trig_offset=self.cfg[\"adc_trig_offset\"])\n",
    "        self.set_pulse_registers(ch=self.cfg[\"res_ch\"], phase=phase1)\n",
    "        self.pulse(ch=self.cfg[\"res_ch\"], t=0)\n",
    "        self.set_pulse_registers(ch=self.cfg[\"res_ch\"], phase=phase2)\n",
    "        self.pulse(ch=self.cfg[\"res_ch\"], t=200)\n",
    "        self.wait_all()\n",
    "        self.sync_all(self.us2cycles(self.cfg[\"relax_delay\"]))\n",
    "\n",
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":1, # --Fixed\n",
    "        \"relax_delay\":1.0, # --us\n",
    "        \"res_phase\":0, # --degrees\n",
    "        \"pulse_style\": \"const\", # --Fixed\n",
    "        \n",
    "        \"length\":20, # [Clock ticks]\n",
    "        # Try varying length from 10-100 clock ticks\n",
    "        \n",
    "        \"readout_length\":400, # [Clock ticks]\n",
    "        # Try varying readout_length from 50-1000 clock ticks\n",
    "\n",
    "        \"pulse_gain\":3000, # [DAC units]\n",
    "        # Try varying pulse_gain from 500 to 30000 DAC units\n",
    "\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        # In this program the signal is up and downconverted digitally so you won't see any frequency\n",
    "        # components in the I/Q traces below. But since the signal gain depends on frequency, \n",
    "        # if you lower pulse_freq you will see an increased gain.\n",
    "\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        # Try varying adc_trig_offset from 100 to 220 clock ticks\n",
    "\n",
    "        \"soft_avgs\":100\n",
    "        # Try varying soft_avgs from 1 to 200 averages\n",
    "       }\n",
    "\n",
    "prog = DoublePulseProgram(soccfg, config)\n",
    "# print(prog.acquire(soc))\n",
    "# print(prog.di_buf)\n",
    "iq_list = prog.acquire_decimated(soc)\n",
    "\n",
    "plt.figure(1)\n",
    "for ii, iq in enumerate(iq_list):\n",
    "    plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n",
    "plt.ylabel(\"a.u.\")\n",
    "plt.xlabel(\"Clock ticks\")\n",
    "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Send/receive a pulse with <code> pulse_style </code> = <code> flat_top </code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "14479439043247898bc0051b3e3f0ee9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":1, # --Fixed\n",
    "        \"relax_delay\":1.0, # --us\n",
    "        \"res_phase\":0, # --degrees\n",
    "        \"pulse_style\": \"flat_top\", # --Fixed\n",
    "        \"length\": 50, # [Clock ticks]\n",
    "        # Try varying  length from 10-100 clock ticks\n",
    "        \"sigma\": 30, # [Clock ticks]\n",
    "        # Try varying sigma from 10-50 clock ticks\n",
    "        \n",
    "        \"readout_length\":300, # [Clock ticks]\n",
    "        # Try varying readout_length from 50-1000 clock ticks\n",
    "\n",
    "        \"pulse_gain\":5000, # [DAC units]\n",
    "        # Try varying pulse_gain from 500 to 30000 DAC units\n",
    "\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        # In this program the signal is up and downconverted digitally so you won't see any frequency\n",
    "        # components in the I/Q traces below. But since the signal gain depends on frequency, \n",
    "        # if you lower pulse_freq you will see an increased gain.\n",
    "\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        # Try varying adc_trig_offset from 100 to 220 clock ticks\n",
    "\n",
    "        \"soft_avgs\":100\n",
    "        # Try varying soft_avgs from 1 to 200 averages\n",
    "\n",
    "       }\n",
    "\n",
    "###################\n",
    "# Try it yourself !\n",
    "###################\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "iq_list = prog.acquire_decimated(soc, progress=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results.\n",
    "plt.figure(1)\n",
    "for ii, iq in enumerate(iq_list):\n",
    "    plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n",
    "plt.ylabel(\"a.u.\")\n",
    "plt.xlabel(\"Clock ticks\")\n",
    "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Send/receive a pulse with <code> pulse_style </code> = <code> arb </code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c33a75388d704ef089015917194c1e56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":1, # --Fixed\n",
    "        \"relax_delay\":1.0, # --us\n",
    "        \"res_phase\":0, # --degrees\n",
    "        \"pulse_style\": \"arb\", # --Fixed\n",
    "        \n",
    "        \"sigma\": 30, # [Clock ticks]\n",
    "        # Try varying sigma from 10-50 clock ticks\n",
    "        \n",
    "        \"readout_length\":300, # [Clock ticks]\n",
    "        # Try varying readout_length from 50-1000 clock ticks\n",
    "\n",
    "        \"pulse_gain\":5000, # [DAC units]\n",
    "        # Try varying pulse_gain from 500 to 30000 DAC units\n",
    "\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        # In this program the signal is up and downconverted digitally so you won't see any frequency\n",
    "        # components in the I/Q traces below. But since the signal gain depends on frequency, \n",
    "        # if you lower pulse_freq you will see an increased gain.\n",
    "\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        # Try varying adc_trig_offset from 100 to 220 clock ticks\n",
    "\n",
    "        \"soft_avgs\":100\n",
    "        # Try varying soft_avgs from 1 to 200 averages\n",
    "\n",
    "       }\n",
    "\n",
    "###################\n",
    "# Try it yourself !\n",
    "###################\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "iq_list = prog.acquire_decimated(soc, progress=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results.\n",
    "plt.figure(1)\n",
    "for ii, iq in enumerate(iq_list):\n",
    "    plt.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_chs'][ii]))\n",
    "    plt.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_chs'][ii]))\n",
    "plt.ylabel(\"a.u.\")\n",
    "plt.xlabel(\"Clock ticks\")\n",
    "plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare the two main ways of acquiring data: [`acquire_decimated()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.averager_program.html#qick.averager_program.AveragerProgram.acquire_decimated) and [`acquire()`](https://qick-docs.readthedocs.io/en/latest/_autosummary/qick.averager_program.html#qick.averager_program.AveragerProgram.acquire)\n",
    "\n",
    "In the previous two demonstrations we used `acquire_decimated()` which uses the QICK decimated buffer (acquiring a whole time trace of data for every measurement shot. The QICK accumulated buffer is used in `acquire()`, which acquires a single I/Q data point per measurement shot- the average of the I/Q values in the decimated buffer. In qubit experiments we will be mainly using `acquire()` since for every shot we only need one I/Q value to assess the state of the qubit. So let's verify that `acquire_decimated()` and `acquire()` produce similar results (to within +/- 1 DAC units)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "668d23616268437ca519d7986ec3af23",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# First, lets collect the results with the decimated buffer as we did before.\n",
    "config={\"res_ch\":GEN_CH, # --Fixed\n",
    "        \"ro_chs\":[RO_CH], # --Fixed\n",
    "        \"reps\":1, # --Fixed\n",
    "        \"relax_delay\":1, # --Fixed\n",
    "        \"res_phase\":0, # --Fixed\n",
    "        \"pulse_style\": \"const\", # --Fixed\n",
    "        \"length\":20, # [Clock ticks]        \n",
    "        \"readout_length\":200, # [Clock ticks]\n",
    "        \"pulse_gain\":10000, # [DAC units]\n",
    "        \"pulse_freq\": 250, # [MHz]\n",
    "        \"adc_trig_offset\": 100, # [Clock ticks]\n",
    "        \"soft_avgs\":100\n",
    "       }\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "iq_list = prog.acquire_decimated(soc, progress=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I value; ADC 0; Decimated buffer:  -7.609349999999999\n",
      "Q value; ADC 0; Decimated buffer:  55.115199999999994\n"
     ]
    }
   ],
   "source": [
    "print(\"I value; ADC 0; Decimated buffer: \",  np.mean(iq_list[0][0]))\n",
    "print(\"Q value; ADC 0; Decimated buffer: \", np.mean(iq_list[0][1]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now, lets collect the results with the accumulated buffer. \n",
    "config[\"reps\"] = 100; # Set reps equal to soft_avgs in the prior acquisition method\n",
    "\n",
    "prog =LoopbackProgram(soccfg, config)\n",
    "avgi, avgq = prog.acquire(soc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I value; ADC 0; Accumulated buffer:  [-7.6069565]\n",
      "Q value; ADC 0; Accumulated buffer:  [55.103993]\n"
     ]
    }
   ],
   "source": [
    "print(\"I value; ADC 0; Accumulated buffer: \", avgi[0])\n",
    "print(\"Q value; ADC 0; Accumulated buffer: \", avgq[0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing the program\n",
    "It's sometimes useful to print the program in ASM format, to get a feeling for what's going on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "// Program\n",
      "\n",
      "        regwi 4, $11, 174762666;                //freq = 174762666\n",
      "        regwi 4, $12, 0;                        //phase = 0\n",
      "        regwi 4, $14, 10000;                    //gain = 10000\n",
      "        regwi 4, $15, 589844;                   //phrst| stdysel | mode | | outsel = 0b01001 | length = 20 \n",
      "        synci 200;\n",
      "        regwi 0, $15, 0;\n",
      "        regwi 0, $14, 99;\n",
      "LOOP_J: regwi 0, $31, 16385;                    //out = 0b0100000000000001\n",
      "        seti 0, 0, $31, 100;                    //ch =0 out = $31 @t = 0\n",
      "        seti 0, 0, $0, 110;                     //ch =0 out = 0 @t = 0\n",
      "        regwi 4, $16, 0;                        //t = 0\n",
      "        set 7, 4, $11, $12, $0, $14, $15, $16;  //ch = 6, pulse @t = $16\n",
      "        waiti 0, 250;\n",
      "        synci 634;\n",
      "        mathi 0, $15, $15 + 1;\n",
      "        memwi 0, $15, 1;\n",
      "        loopnz 0, $14, @LOOP_J;\n",
      "        end ;\n"
     ]
    }
   ],
   "source": [
    "print(prog)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}