{
 "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 sys\n",
    "# sys.path.append('../qick/qick_lib/')\n",
    "from qick import *\n",
    "\n",
    "# from test_phase import *\n",
    "\n",
    "# import numpy as np\n",
    "\n",
    "# import matplotlib.pyplot as plt\n",
    "# from numpy.fft import fft, fftshift\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "QICK configuration:\n",
      "\n",
      "\tBoard: ZCU216\n",
      "\n",
      "\tGlobal clocks (MHz): tProcessor 349.997, RF reference 245.760\n",
      "\n",
      "\t4 signal generator channels:\n",
      "\t0:\taxis_signal_gen_v6 - tProc output 0, envelope memory 65536 samples\n",
      "\t\tDAC tile 2, ch 0, 32-bit DDS, fabric=614.400 MHz, fs=9830.400 MHz\n",
      "\t1:\taxis_signal_gen_v6 - tProc output 1, envelope memory 65536 samples\n",
      "\t\tDAC tile 2, ch 1, 32-bit DDS, fabric=614.400 MHz, fs=9830.400 MHz\n",
      "\t2:\taxis_signal_gen_v6 - tProc output 2, envelope memory 65536 samples\n",
      "\t\tDAC tile 2, ch 2, 32-bit DDS, fabric=614.400 MHz, fs=9830.400 MHz\n",
      "\t3:\taxis_signal_gen_v6 - tProc output 3, envelope memory 65536 samples\n",
      "\t\tDAC tile 2, ch 3, 32-bit DDS, fabric=614.400 MHz, fs=9830.400 MHz\n",
      "\n",
      "\t2 readout channels:\n",
      "\t0:\taxis_readout_v3 - controlled by tProc output 4\n",
      "\t\tADC tile 2, ch 0, 32-bit DDS, fabric=614.400 MHz, fs=2457.600 MHz\n",
      "\t\tmaxlen 1024 (avg) 1024 (decimated), trigger bit 4, tProc input 0\n",
      "\t1:\taxis_readout_v2 - controlled by PYNQ\n",
      "\t\tADC tile 2, ch 2, 32-bit DDS, fabric=307.200 MHz, fs=2457.600 MHz\n",
      "\t\tmaxlen 1024 (avg) 1024 (decimated), trigger bit 5, tProc input 1\n",
      "\n",
      "\t4 DACs:\n",
      "\t\tDAC tile 2, ch 0 is 0_230, on JHC3\n",
      "\t\tDAC tile 2, ch 1 is 1_230, on JHC4\n",
      "\t\tDAC tile 2, ch 2 is 2_230, on JHC3\n",
      "\t\tDAC tile 2, ch 3 is 3_230, on JHC4\n",
      "\n",
      "\t2 ADCs:\n",
      "\t\tADC tile 2, ch 0 is 0_226, on JHC7\n",
      "\t\tADC tile 2, ch 2 is 2_226, on JHC7\n",
      "\n",
      "\t4 digital output pins (tProc output 7):\n",
      "\t0:\tPMOD0_0_LS\n",
      "\t1:\tPMOD0_1_LS\n",
      "\t2:\tPMOD0_2_LS\n",
      "\t3:\tPMOD0_3_LS\n",
      "\n",
      "\ttProc: program memory 1024 words, data memory 1024 words\n",
      "\t\texternal start pin: PMOD1_0_LS\n"
     ]
    }
   ],
   "source": [
    "# Load bitstream with custom overlay\n",
    "soc = QickSoc('./test_phase.bit', ignore_version=True, force_init_clks=False)\n",
    "\n",
    "soccfg = soc\n",
    "print(soccfg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findPeak(x,y,xmin=-1,xmax=-1):\n",
    "    if xmin == -1:\n",
    "        xmin = np.min(x)        \n",
    "    if xmax == -1:\n",
    "        xmax = np.max(x)        \n",
    "\n",
    "    imin = np.argwhere(x <= xmin)\n",
    "    imin = imin[-1].item()\n",
    "    imax = np.argwhere(x >= xmax)\n",
    "    imax = imax[0].item()\n",
    "\n",
    "    # Find max.\n",
    "    idxmax = np.argmax(y[imin:imax]) + imin\n",
    "\n",
    "    # x, y.\n",
    "    Xmax = x[idxmax].item()\n",
    "    Ymax = y[idxmax].item()\n",
    "\n",
    "    return Xmax, Ymax "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The readout control works very much like the generator control.\n",
    "\n",
    "The readout is technically only configured during the window defined by the length and mode; however, it seems that the configuration remains active after the end of the window.\n",
    "Practically speaking, best practice in most cases should be to use `mode='oneshot'` (this is default, so you can omit it) and a very short length.\n",
    "\n",
    "You of course need to ensure that the readout config you need is applied before your readout gets used. If you have a complicated setup and this is in doubt, you should test.\n",
    "\n",
    "For correct phase-reset synchronization, all phase resets should be sent on the same tProc clock tick."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "// Program\n",
      "\n",
      "        regwi 2, $22, 436906667;                //freq = 1747626668\n",
      "        bitwi 2, $22, $22 << 2;\n",
      "        regwi 2, $26, 524291;                   //mode | outsel = 0b01000 | length = 3 \n",
      "        regwi 0, $22, 436906667;                //freq = 436906667\n",
      "        regwi 0, $25, 30000;                    //gain = 30000\n",
      "        regwi 1, $22, 436906667;                //freq = 436906667\n",
      "        regwi 1, $25, 30000;                    //gain = 30000\n",
      "        synci 200;\n",
      "        regwi 0, $15, 0;\n",
      "        regwi 0, $14, 0;\n",
      "LOOP_J: regwi 0, $23, 0;                        //phase = 0\n",
      "        regwi 0, $26, 1638500;                  //stdysel | mode | outsel = 0b11001 | length = 100 \n",
      "        regwi 1, $23, 0;                        //phase = 0\n",
      "        regwi 1, $26, 852068;                   //stdysel | mode | outsel = 0b01101 | length = 100 \n",
      "        regwi 0, $31, 17;                       //out = 0b0000000000010001\n",
      "        seti 7, 0, $31, 0;                      //ch =0 out = $31 @t = 0\n",
      "        seti 7, 0, $0, 10;                      //ch =0 out = 0 @t = 0\n",
      "        regwi 0, $27, 0;                        //t = 0\n",
      "        set 0, 0, $22, $23, $0, $25, $26, $27;  //ch = 0, pulse @t = $27\n",
      "        regwi 2, $27, 0;                        //t = 0\n",
      "        set 4, 2, $22, $0, $26, $0, $0, $27;    //ch = 0, pulse @t = $27\n",
      "        mathi 0, $15, $15 + 1;\n",
      "        memwi 0, $15, 1;\n",
      "        loopnz 0, $14, @LOOP_J;\n",
      "        end ;\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c82dced1dca84630ae5e8b7fd727e65a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class PhaseExample(AveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg=self.cfg   \n",
    "        res_ch0 = cfg[\"res_ch0\"]\n",
    "        res_ch1 = cfg[\"res_ch1\"]\n",
    "\n",
    "        # set the nyquist zone\n",
    "        self.declare_gen(ch=cfg[\"res_ch0\"], nqz=1)\n",
    "        self.declare_gen(ch=cfg[\"res_ch1\"], 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",
    "            if self.soccfg['readouts'][ch]['tproc_ctrl'] is None:\n",
    "                self.declare_readout(ch=ch, length=cfg[\"readout_length\"],\n",
    "                                     freq=cfg[\"pulse_freq\"], gen_ch=cfg[\"res_ch0\"])\n",
    "            else:\n",
    "                self.declare_readout(ch=ch, length=cfg[\"readout_length\"])\n",
    "                freq_ro = self.freq2reg_adc(cfg[\"pulse_freq\"],ro_ch=ch,gen_ch=cfg['res_ch0'])\n",
    "                self.set_readout_registers(ch=ch, freq=freq_ro, length=3,\n",
    "                                           mode='oneshot', outsel='product', phrst=1)\n",
    "\n",
    "\n",
    "\n",
    "        # convert frequency to DAC frequency (ensuring it is an available ADC frequency)\n",
    "        freq = self.freq2reg(cfg[\"pulse_freq\"],gen_ch=res_ch0)\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_ch0, name=\"measure0\", sigma=sigma, length=sigma*5)\n",
    "            self.add_gauss(ch=res_ch1, name=\"measure1\", sigma=sigma, length=sigma*5)\n",
    "            \n",
    "        if style == \"const\":\n",
    "            self.default_pulse_registers(ch=res_ch0, style=style, freq=freq, gain=gain, length=cfg[\"length\"])\n",
    "            self.default_pulse_registers(ch=res_ch1, style=style, freq=freq, gain=gain, 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_ch0, style=style, freq=freq, gain=gain, \n",
    "                                         waveform=\"measure0\", length=cfg[\"length\"])\n",
    "            self.default_pulse_registers(ch=res_ch1, style=style, freq=freq, gain=gain, \n",
    "                                         waveform=\"measure1\", length=cfg[\"length\"])\n",
    "        elif style == \"arb\":\n",
    "            self.default_pulse_registers(ch=res_ch0, style=style, freq=freq, gain=gain, \n",
    "                                         waveform=\"measure0\")\n",
    "            self.default_pulse_registers(ch=res_ch1, style=style, freq=freq, gain=gain, \n",
    "                                         waveform=\"measure1\")\n",
    "        \n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "    \n",
    "    def body(self):\n",
    "        phase = self.deg2reg(self.cfg[\"pulse_phase\"], gen_ch=self.cfg[\"res_ch1\"])\n",
    "        self.set_pulse_registers(ch=self.cfg[\"res_ch0\"], phase=0, phrst=1,mode=\"oneshot\")\n",
    "        self.set_pulse_registers(ch=self.cfg[\"res_ch1\"], phase=0, phrst=0, mode=\"periodic\")\n",
    "        \n",
    "        self.measure(pulse_ch=self.cfg[\"res_ch0\"], \n",
    "                     adcs=self.ro_chs,\n",
    "                     pins=[0], \n",
    "                     adc_trig_offset=self.cfg[\"adc_trig_offset\"],\n",
    "                     t=0,\n",
    "                     wait=False)\n",
    "        \n",
    "        # Configure readout v3.\n",
    "        for ch in self.cfg[\"ro_chs\"]:\n",
    "            if self.soccfg['readouts'][ch]['tproc_ctrl'] is not None:\n",
    "                self.readout(ch=ch, t=0)\n",
    "\n",
    "        \n",
    "config={\"res_ch0\":0, # --Fixed\n",
    "        \"res_ch1\":2, # --Fixed\n",
    "        \"ro_chs\":[0], # --Fixed\n",
    "        \"reps\":1, # --Fixed\n",
    "        \"pulse_style\": \"const\", # --Fixed\n",
    "        \"length\":100, # [Clock ticks]\n",
    "        \"pulse_gain\":30000, # [DAC units]\n",
    "        \"pulse_freq\": 1000, # [MHz]\n",
    "        \"pulse_phase\": 0,\n",
    "        \"readout_length\":500, # [Clock ticks]\n",
    "        \"adc_trig_offset\": 0, # [Clock ticks]\n",
    "        \"relax_delay\":0.0, # --us\n",
    "        \"soft_avgs\":1\n",
    "       }\n",
    "\n",
    "prog = PhaseExample(soccfg, config)\n",
    "\n",
    "print(prog)\n",
    "\n",
    "# load this program into the soc's tproc\n",
    "iq_list = prog.acquire_decimated(soc, load_pulses=True, progress=True, debug=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phase: 0.9979788072401709\n",
      "F1: 0.000, Y1: 110.057\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzcAAAJBCAYAAAB73UuyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAXEQAAFxEByibzPwAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd3iUVdrH8e9JCKGHUFWKSC8iqCgIUsVCUZEiCCiIrm3VfVdcUbGwLiprL4t1RUSK0pSqKC4qIApSBOmIVGkhEJLQUs77xzOTzExmkpkQSSbz+1zXXDNznnOe50wCmbnnPsVYaxEREREREQl3UYXdARERERERkYKg4EZERERERIoFBTciIiIiIlIsKLgREREREZFiQcGNiIiIiIgUCwpuRERERESkWFBwIyIiIiIixYKCGxERERERKRYU3IiIiIiISLGg4EZERERERIoFBTciIiIiIlIsKLgREREREZFiQcGNiIiIiIgUCwpuRERERESkWFBwIyIiIiIixYKCGxGRCGKMiTfGnDTGWNetQWH3SYoHY8ylxph7jTH/NcasMsacdv0b21bYfRORyFGisDsgIiJn1SAg1uP5MOCxQuqLFC+zgBqF3QkRiWzK3IiIRJY7XPdvuu6HGGOiC6szUqycBlYDHwB/BSYXbndEJBIpcyMiEiGMMZcALYGjwCNAD6Au0A2YW4hdk+KhgbU2w/3EGHNeYXZGRCKTMjciIpHDnbX51Fp7EvjYp9yLMSbWGJPomjdxX24nNsbc7ap31BhTys/xBsaYscaYTcaYFGPMcWPMRmPMq8aYmgHOeafnnA1jzFXGmFnGmH3GmAxjzH896p5vjLnfGDPfGLPFGJPqus561zVq5dF/Y4y5wxjzozEm2RiT5Hp8p+v4RFdf/pvLOUJ+ja52TV3zVLYaY064bruNMcuMMc8aYxrl1veiwjOwEREpLMrciIhEAFfAMdD1dILH/VNAT2NMdWvtAc821tpTxpipwN3ArcBbuVxisOt+mitw8rz2PTjD4NzvOacACzR23W43xvSx1n6TS/8fAl4CDE7myfeD9CSgncfzo0AFoKnrNtQY091au8zPuUsAU4C+7pfuan8Z0NoY0yGX131Gr9EYcx3OXJWSrqI0IBWo6bq1AU4Ao/Pqg4iIKHMjIhIp+gAVgW3W2h8ArLXbgSU4H8hvDdDOHQi1CbSymjHmArIDiwk+x/oCbwOZwLPA+UBpoAxO0DETiANmGGMCTUY/D3gBGAfUstbGu87xvEeddcAIoAlQ2lUnFrgC+Nr12qcaYzwXU3B7lOzA5kWgirW2ElAJeBIncOseoG/5fo3GGONqVxL4ArjQWlvS1fcyQHPgn8CuQNcWERFvCm5ERCKDe+jZBJ/yCT7HvbgCIfdSvoECoME4GZXfcYIlwBnWRvbCBX+x1j5hrd1ls2201vYB5uF8+P97gPOXBmZYa++01u5x9SvDWvubRz/vtda+YK3d5M4cWWvTrbU/4gQm63EyITd5ntgYUw4nKAJ411r7iLU20dU+yVo7GngOiPfXsTN8jecCdVyPh1hr13u8nhPW2l+ttaOstb6/szwZY/Z4LPcd6m1hqNcTESkqFNyIiBRzxpi6QCecYVIf+xyeijPsqbExpm2AU0x03Q92ZRt8uYekTbTWWo/ynsA5wB9+ruvJfezaXOo8n8uxXFlr04EFrqdX+hzuBpTD+dk8G+AULwInAxw7k9eY5LouOIFOQToIHMjnLbGA+yIictZozo2ISPE3DCez8r21dofnAWvtMWPM58Atrno/+Gk/AXgacA8/88zOtAYaetTz5A4kqgD7/MdFQPZ8k/MDHE8BfgnU2KMvHXAyUG1w9lsp66ea78T+S1z3v1trd/s7r7U2yRizGmeIm698v0Zrbaox5lugM/C1MeZtYD6w2lqbFuhEwbDWXpJ3LRGR4keZGxGRYswYEwUMcT0NNLzpI9d9f9cwLS/W2t+Bpa6nvkPT3M+XWWt9d6J3LwVcEqiey8095KtMgP4l+GSEcjDGvAx8B9yGE2yVAo6QnY1IdVX1DXiquu7/yO38wN4A5Wf6GofhzBeqhhNA/gQkG2MWG2MeNsb4HQ4nIiL+KbgRESneriU7W/Fff3MsgC9dx8sBNwc4j3tY1c3uSfnGmBigv6vcX+Dk3hx0rrXWBHELNJog1yWGjTHdgIdcT98ELgRirbWVrLXnWGvPIXtejG9qxf081+DJTzu3M3qNrkxaS5x5QW8Cq3BGVVyJMxxuqzGmYx59ExERFw1LExEp3vwuFJCLYTirkvmaCryOs+rY9cB0nPkqVXB2pp/qp81+133zEPsQqgGu+3nW2gcD1DknQPlB131eG04GOn7Gr9Fam4mzWtoXAMaYCsANOPOMagJTjDG1XXOHgmKMWZVLn/PyvbU2UJArIlKkKXMjIlJMGWOq4nxIBmep4/K53C531WtnjGnsey5r7VFgjuvprT73c90rjPlwD2U73xjT5gxeSl7cG3Su9nfQNTSvc4C2q1z3dQNt9OkKNi4O0L7AX6O19pi1diLwF1fRuUCzEE9TjdyHyeV2q3SGL0FEpNAouBERKb5uBWJwVuWaY61NyeW2AtjkajcswPncQ8+6GWPq42RwPMt9zcKZ7wLwhjGmdG6dNcbk90N1kuu+RYDjfyXwYgVf4ixYYIDHAtQZjjOHx598v0ZjTMnc6uKsYueW69A8X9bamkEOk/N36xrKtUREihIFNyIixZc7SJllrT0dRP1prvvbjDH+hi1/CRzCCZim4GySeRhnha8crLXHgftx5rNcBiwxxlzjmqsDOMtUG2PuMcasAO4Koo/+uOcMXW+MedwYU9Z17nhjzBPAq65++utjMs7cFoB7jTHPuyfxG2MqGGMex9nI88if8Bo7GGPWGGP+zxjT2JVhwjjaAWNd9XYCG0L7kZx9xpgyxpgq7hvO/kQAUZ7lxpjKhdlPESneFNyIiBRDriFS7qFM03Kr68FdrzrQw/ega87HFNfTVq77T3JbtthaOx0YipOFuARnv5njxpgEY8xJ4Dfgbdf58prUH8iHZC9h/SzOamOJQALwL5wNNN/Ppf1zwOeux48CCa72ia7zfYRrPgx+9rs5w9fYAif42gicNMYk4MxhWoLz+zsKDHTNyynqHscJft039yIPF/iUH/DbWkSkACi4EREpntwLCSQBXwXTwFq7DudDtmd7X75D0AINSfM87wSgPk4Q8TPOMLCKOIHCapxVwq4CXg6mn37OfxroihPIbAXcwdaPwN1AL3IZ1uUK2vrgZFVW4AQpJVx9HWatvd3VX3CCjYJ6jctwVpt7B2fuz2EgztVmDTAGaGKt9bf3kIiI+GHy2DpAREQkormGi+3Bmdg/0Fo7JY8mIiJSSJS5ERERyd1QnMAmDfhf4XZFRERyo+BGREQinjHmU2NMb9dEeHfZOa4FBd52FX1ordV8ERGRIkzD0kREJOIZY1KAsq6nx3GyNHEeVb4DelprU85230REJHgKbkREJOIZY4YC1+Fs1lkNJ9A5gjOx/xPgY9fCAyIiUoQpuBERERERkWJBc25ERERERKRYUHAjIiIiIiLFgoIbEREREREpFhTciIiIiIhIsaDgRkREREREioUShd0ByR9jzH6gDLC7sPsiIiIiIlJAagHHrbXn5KexloIOU8aYY7GxseXr1atX2F0RERERESkQv/32G6dOnUq21lbIT3tlbsLX7nr16jVdv359YfdDRERERKRANGvWjA0bNuR7ZJLm3IiIiIiISLGg4EZERERERIoFBTciIiIiIlIsKLgREREREZFiQcGNiIiIiIgUCwpuRERERESkWFBwIyIiIiIixYL2uREREZFiyVqLNisXKTzGGIwxZ/WaCm5ERESkWLDWkpyczLFjxzh+/DgZGRmF3SWRiFeyZEnKly9P5cqViY6O/tOvp+BGREREwl5mZib79+8nKSmpsLsiIh5Onz7N4cOHSU1NpXbt2n96gKPgRkRERMJeUlJSVmBTqVIlypcvT2xs7FkfEiMi2TIzM0lNTeXAgQOcPHmSw4cPU61atT/1mgpuREREJOwdOXIEgGrVqlG5cuVC7o2IAERFRREXFwfAH3/8QXJy8p8e3Gi1NBEREQlr1lpOnToFQIUKFQq5NyLiq2zZsoAzRO3PXuRDwY2IiIiENc8PS2djwrKIhCYqKjvkUHAjIiIiIiISBAU3IiIiIiJSLCi4ERERERGRYkHBjYiInH0phyD91J97jb0rYfUkOH08u+zrp+G9TrDtmz/32nk5ngirPoZDmwu3H1LsFcYO8Xn59ttvMcYwdOjQwu5Kvv373//O+tkuW7Ys17rueu5bTEwMVapUoXnz5gwdOpQZM2aQnp6e5zVTU1N59dVX6dy5M9WrV6dkyZLEx8dzxRVX8NRTT7Fr166QXkNmZiavvfYazZs3p3Tp0lStWpV+/fqxYcOGkM5T1GgpaBERObt++QQ+vxfKVIa7voW4mnm3yUiD6Jjgr5GwFT64BjLTYfu30Od92PMzLH3NOT7rr/D3DRAV4Du+/b/CuqnQrDec1zL46wZr+u1Ov0pVhL8uh/LVC/4aBe3ITjiRCOddXNg9ESl0EydOzHr88ccfc8UVV+TZZsiQIYATVCQlJbFlyxYmTJjARx99RP369Zk0aRKXX36537Y//vgjvXv3Zt++fZQpU4Y2bdpQvXp1kpKSWLFiBT/++CMvvPACc+fOpWvXrnn2xVpL//79mT59OhUrVqRHjx4kJCQwY8YM5s2bx6JFi2jdunWQP42iRZkbERE5uxa/DDYTUg/BgsezyzMznSDGU9pJ+OBaGFMbfvk0+Gus/dQJbMAJUhK3e2drkvfBvtX+2x7+Df7bFZa+DpP7O30oCEd2wulUOJXsBDYAJ4/Csje962VmFFxW68QROLbvzM9zYAO83sLJeq2edObnEwljq1ev5tdff+Wcc87BGMPUqVNJS0vLs9348eMZP348EyZMYNasWWzcuJGtW7dy8803s23bNjp37syaNWtytFu7di1dunRh3759jBgxgoMHD/LNN98wefJk5s2bx/79+5kxYwY1a9Zkz549Qb2GDz/8kOnTp9OgQQM2bdrE9OnT+fbbb5k2bRonTpxg0KBBQWWTiiIFNyIicvZkZkDCluznG2Y5wcOOpfB8TXjzEjiwPvv4momw+0dIOw7zHgr+Ont+9n6+/H04vM27bPMXfvqXCbMfhPQTzvOU/c71g3VoM/zwH0jam11mLXz5GLx+EbzSBLYs8G6zfpZz3eOJMOdv8FwNp96B9U5QMeFG+GKE87PzPOf6z2DZW5B2wn9f9v0CLzV0rrt6ov86wZo2FHAt3zrrvjM7l0iY+/jjjwG4++67ad++PYcPH2b+/Pn5Ole9evX49NNPueOOOzh+/DjDhg3zOm6tZfDgwZw4cYJRo0YxZsyYrD1j3KKioujduzcrV66kVatWQV335ZdfBuCFF16gevXszHGfPn244YYb+O2335g1a1a+XlNhU3AjIiJnz5EdOcvWTIJ5wyEtFY7ugk9vhZPHnGPrZmTXO50CqQk52x9PhA97wKvNYdN8J/uze7l3ndUTYZdPkOIvuNn+P9i5xLvst0XO/eHfYNHzzlwef06lOIHIVyPh/S5wMskp/+oJ+PEt5/HJJO9sFUDSLtjypdN25XgnsDp+2Gnz+T1Oluend2DNZNfPIRU+GeQEHAseg3kPO+WHNsNn9ziZrj0r4ad3IeO0c5v1V/h9sf9+ByNBc4MiwQMPPIAxhnfeeSdgnWbNmmGMYcuW7C8p5s2bx7Bhw2jSpAkVKlSgbNmytGjRgueeey5rc9VgDB06FGMM3377rd/jxhjq1Knj99iSJUu46aabqFatGrGxsdSpU4cHH3yQQ4cOBX39YGRkZDBlyhQABg8ezODBgwHvYWr58fLLL1O2bFlWr17NkiXZf4MWLFjAunXrqFmzJiNHjsz1HHFxcVx44YV5Xuv3339nw4YNlC5dmh49euQ43rdvXwDmzJkT4qsoGhTciIjI2XPg15xl8x6CQxuznyf+BuN7wP9Gw64fvOvu+dmZT7NnpZPtAFg4yglIknbBp4Phf/9yAiVPp445x337sv07J8j537PwTnuY2Cdn/7YvcrIjH90A342BCb0g9bBzLDPT6VPqYSdASXYNAUvZD9+/CLtXwLL/eJ8v5UDOa3xyC+xf6122eqKTfXFb+rpz/79nYfO87PI1E2FURRh7Ofwyxck0fXY3bP3K+3zzHnIyPr6shWVjYdb9/oNPiRiDBg0CYNIk/0MP16xZw4YNG7jsssto2LBhVvkdd9zBtGnTiIuL47rrrqN9+/bs3r2bkSNH0r17dzIyMvyer6C88cYbdOjQgTlz5lC/fn1uuOEGSpcuzZtvvknr1q3Zt68Ahma6fP311+zfv5/WrVtTv359+vXrR2xsLHPmzOHo0aP5Pm9cXBzdunUDYNGiRVnl8+Y5/9f79etHiRIFM1X+l1+cvysXXnghMTE55zJecsklXvXCjRYUEBGRs8dzyFlu9q/N+WEf4Ic3YOcPgIUqDaFuZ1g1Ifu4zcgOAoIx4Ya86+xb6wQqx1xj2U8dgw2fQ6thMOMOWD8TomMhw+cb6h/edG4F5fBWJ9hZ62/ukc1Z11fCFvhjtbMggOfqWTsWZ2eTjh+GW6YUWJclvLRp04Z69eqxdOlSdu7cyfnnn+91fPJkJ3voDoLc3nnnHa6++mqv4VLJyckMHDiQuXPnMmnSJG677bY/pc8//vgjf//736lduzazZ8/moosuApzhXKNHj+app57iwQcfZNq0aQVyPfeQNHfGxj0Zf+bMmUyfPp0777wz3+du2bIl06dPZ+PG7C97Vq925ga6A46C4F5VrWZN/4u5uMtDXX2tqFDmRkREzh7P4KbJ9VChhvfxKo1yb79zKVkf5BO2wPJ3yfHB3lOpivnppQ/rLILgad10J8BZP9N57hvYBKuCz4eLqo0hrnbg+h9cA8f9DM0L1vud4e12cMLjG+Ylr2U/3py/eQPhwFpL0om0sLpZf5m2P9nAgQOx1mYNvfL8+X3yySdER0fTv39/r2O9evXKMQ+kfPnyvPrqqwB/6tyNMWPGkJmZyXvvvZcV2IAzhO2JJ57g4osvZubMmSQknMH/G5eUlBQ+//xzSpQowYABA7LK3YGOO/DJrypVqgBw5MiRrLLDh50scdWqVc/o3J5SUlIAKFOmjN/j7t+lu164UeZGRETOHs9haRcNgBvHOvu9bF0ADa6Fi/rDf6+CoztDO6+JgpqXwe6fsstKlIIBk5whbp5aDnLm+eSl3f9lLx3ta9cPOYfMeYop4yyC4NbiFqdviduzy2IrQP8JMK6bExxd0AH6jIPvX4Dl7/k/b7rHym3nX+lc449VUPNyuP51ZwU632xUVInsleMADq53hq+1udd5nhlgRaQ9K2Hvz9C8n8+BorVnSrCOnUynxT+/yrtiEfLL09cQVzqEJdALwKBBg/jXv/7F5MmTefTRR7PKFy9ezO7du7nmmms455xzcrTbunUr8+fPZ9u2baSmppKZmZkVnG3d6ieTWAAyMzP55ptvKF++PFdddVWO48YY2rVrx+rVq1m5ciXXXnvtGV1vxowZHD9+nJ49e2YFIgA9evSgUqVKLF682G/GK1jun5fnvkR/RoDr7zrFiYIbERE5O04f957TUb0plIqDtvc7N7f7lsGeFU4W45cpzmpq37/oDDnzVPMyp17F2s4H+3NbwmvNnYUHADo8DOe3c44fdQ2vqNIQerziDM866Nqorm5nGDwDnqmUfe5araHjI052Jph5KE1vhI1znT52eszJSs172AlaWg6CS4fC5/d5BzeX3wU1LoV7f3Dm6pzfFqKiod5V2cFNyfLOXkCLRjuro3lq1ss579FdUKmuM9TMWqjXBX77X3a93u87++p4OrQp+7HN9D42bziUPwe+e8FZjMB3IYbSBZENk6KqUaNGXHrppaxcuZJ169bRvHlzIPCQNGstDz/8MK+++mrAD+LJycl/Sl8PHz6clV3Iaz5KQWRufIekuZUsWZJ+/frx7rvvMmnSJB5//HF/zfPk7mOlStl/i6pUqcLmzZsLdGGE8uXLA86moP64y8uVK1dg1zybFNyIiEj+Wes9fyM3nkFCVAxUDPDtZsmyULeT8/jKv7uuk+EEOG6t7oAeL0PSHqhwnhMUgBPkzP8H1L4Crrjf6Vunx51NQyvVhYFTIaYUdP0nTOnvDIvr8bLT/rp/w5cjnPO0+z+nHze96ywykJkB1z3vZIM+v5esoXDRsXDDG9BigBNkHNvnBF1RUTDMZzW2Jj1h7SfO4/pdnSAIoEp95+bW8Fpofa+zKlvXUc6xG99yVlpzBy0lSjsBVHQMVK6X3dYYGDTdWQTh9++hWjO4sLczT2nF+9n1Ejy+SffN3Kz4r/dz99A7t9LxSPE2aNAgVq5cyeTJk3n++edJS0tj+vTplC5dmptuusmr7qeffsorr7xCzZo1ee2117jiiiuoWrUqMTExnD59mtjY2ALJPmRmZuYocy9UUL58eXr37p1r+/xmU9z27t2bNdH/pZde4s03vefTHTx4EHBWTctvcOPe46Zp06ZZZS1btmTp0qWsWrUqR1CVX7VrO0NfA+2J4y531ws3Cm5ERCR/diyBabdDxVowcBqUrZyzTvJ++HkcnNvCO0MQXyc7IAlGp8fh4EbYNNcJKFoNcz7IV6zlXa95X+fmqeUt2YFAiVinrOE18Pg+wEJMaaes9d0Qf74TwNTr7JTVbgPDNzsBgDtjcV5LZ8nmU8lOEFTVtWpUxdrOLZDGPZ0syvFEJ+MSHeAt2BjoNsa7rGQZGDzTmXP02/+c4Kh8zqFBgPNzrd/Vubn1eMl5LTPucJ7nFtzkpUDmMZ19FUqV4JenrynsboSkQqnC+Zg2YMAA/vGPfzB58mSee+45FixYwOHDh+nfv3/Wt/5un33mZBTffvttevbs6XVs+/bthKJkyZKA/7keu3fvzlFWpUoVYmNjiYmJYfz48SFdK1STJk3KCrB+/vnngPU2btzIypUrufTSS0M6f1JSEl9++SUAnTt3zirv0aMHY8eOZdq0abzwwgsFsmJaixYtAPj1119JS0vLsWLaqlWrALzmMIUTBTciIpI/P/wHUg86tzkPOvNbkvZAuepOIAEw/2HYOAcwznwaN89sQzCiouDmj53ljSvWdoa0hSLWz/CKmFLez42BRt3yblutCXT7d2jXd5//optDb+fZvs6Vzi0/zm+b/Tj1oLOoQOmKzr45oSgVl7/rFzJjzFmfvxKuzj33XDp37szChQtZunRpwCFpkD35vVatWjmOTZ06NeTrAl576Lh99VXO+VIlSpSgU6dOLFiwgO+//54OHTqEdL1QuPexmTdvHt27d/dbZ+TIkTz33HNMnDgx5OBm+PDhpKamctlll3HFFVdklV933XU0a9aM9evX8+yzz/L0008HPMexY8fYvXs3zZo1y/VaF1xwAU2aNGHjxo3MmzePXr16eR2fPn06QI5gNVxotTQREcmfLR7DrjbNhdkPwKvN4O22cOwPZ8jaRvcmcDZ7SBY4Q8RCFRUFja4LPbARR/lzoaRHoHZ4m3Pvb2PU3ETpe9FI4A5k3nvvPWbPnk2lSpW47rrrctRz73fz3nvveQ0/W7x4MS+++GKO+rnp2LEj4GSB3KuEgZNJePLJJ/22efzxx4mKimLIkCFem1+6/fHHH4wdOzZHuTEGYww7duzIs19r1qxh3bp1VK5cmauvvjpgvVtuuQWAKVOmBL23z/bt2+nfvz8ffPABZcuW5YMPPsjRz4kTJ1KqVClGjRrFY489lmOujLWW2bNn06pVK1asWBHUdR966CEAHnnkkawhdQAzZ85k9uzZXHDBBTmCnnCh4EZERPIntoL3c/d+Mwlb4L1OsC6XfSXyE9zImTEGqjTIfp6wxdmE9PjhwG38OvvLE8vZ17t3b0qVKsXHH39MamoqN998s98NHx988EHKli3LW2+9xYUXXsgtt9xChw4d6NixI/fcc09I1+zcuTMdO3Zk27ZtNG3alN69e9O+fXvatGnDrbfe6rdNhw4deP3119m9ezft27enRYsW9O3bl549e9K8eXNq167NyJEjvdp4zt/x95p8uRcS6Nu3b671L7zwQpo1a8aBAwf4+uuvcxwfOnQoQ4cO5bbbbqNXr140bdqU+vXrM3XqVBo0aMC3336btYCDp5YtW7Jw4UKqV6/OmDFjqFatGl27dmXQoEH07NmTc889lxtvvJHdu3f7zaD5M2zYMG666Sa2bt1K48aN6devH507d6Zv376UKlWKiRMnBvWzKYoU3IiISOgyM7JXJfMn5QDM/Evg4wpuCkdlj+Dm0GY4eTTnKnR5KYS9V+Tsq1ChAtdff33W84EDB/qt17BhQ1asWMH1119PQkICs2fPJiUlhXfffTfkzI0xhlmzZnHPPfdgjGH+/PkcOXKEN954I9dz3X///fz0008MGjSII0eOMHv2bJYtW0ZUVBT33HNPjn12fvnlFwC6dOlCjRo1/J0yS0ZGRtaeP5572wTiruNvz5uPPvqIjz76iClTprB48WKio6O57bbbmDFjBhs2bKBVq1YBz9uuXTu2bdvGSy+9xGWXXcbatWuZOnUqS5cupU6dOjz99NNs3brV75LY/kRFRTFt2jRefvllzjvvPObOncu6deu46aab+Pnnn2nbtm3eJymiTGFsECVnzhizvmnTpk3Xrw9yt28RkYKUfABebpj/9n/7xVlUQM6u7150lpUGZ8W1LiPhqydCO0e9LnDrZ3nXO4syMzPZvHkz4CxlHBWl724lsFdeeYXhw4ezZMkS2rVrV9jdiQih/B9t1qwZGzZs2GCtzX3yUAD63y8iIqFLPZh3nUCiYqBCzYLriwSveR+IdlakIv1E6IENKHMjYW/RokVcc801CmyKKQU3IiISupQDgY9d86yzz0wglesHXgZZ/lyV6jr74PjOlwqJghsJb3PmzGHBggWF3Q35kyi4ERGR0KXkkrk5twU0zLmqEuDsIdM5fxvcSQGp29EJcEqUzl97ZW5EpF8qjG4AACAASURBVAhTcCMiIqHLLXNzTvOcwc2FfeDiW+HeH6DpDX9u3yRvtVtD+4fy19bm3CleRKSoUHAjIiKh88zcXDTA2bgToG4nZ2PIao2h7QMQGwedR0LfcXDjf0LfvFP+PJcMKeweiIgUOA16FhGR0HlmbirXc4aa7V4ODTw2uLtmNFz9L2d/FSl6yleH+lfDtpz7ceRKw9JEpAhT5kZERELnmbkpVw3iz4eL+jlZG08KbIq2Xm9D455QKZSMmoIbESm6FNyIiEjovIKb6oXXDzkz5arCgEkwYHLwbZS5EZEiTMGNiIiEznNYWrlqhdcPKRhlq4RQWcGNiBRdCm5ERCQ0KYfg5NHs5xVqFF5fpGCUrQLtH4ZScXnXVeZGRIowBTciIhKafWuyH5c7B8qfU3h9kYJz1ZMwYmcQFRXciEjRpeBGRERC88fq7MfnXVx4/ZCCZwz0/TD3OsrciEgRpqWgRUQkNApuiremN0K/8ZCR5mzGumMJHN0JXz7qqqDgRkSKLgU3IiISGgU3xVtUNDS7Kft54+6wbnr2c2VuRKQI07A0EREJ3rF9kLwv+/l5LQuvL1JIFNyEo4SEBJ588kkuvvhiKlasSJkyZahfvz533XUXv/76a2F3LyBjDHXq1CnsbuTbTz/9hDEGYwzPP/98rnU7deqUVdcYQ3R0NPHx8dSvX58+ffowduxYkpKS8rymtZapU6fSp08fatWqRalSpShfvjzNmjXj3nvvZfny5SG/jrlz59KxY0fi4uKoUKECHTt2ZO7cuSGf52xQcCMiIsFL/C37cbnqWgY6UnhuxqrMTdhZuHAhDRo0YPTo0ezdu5eOHTvSs2dPYmJieP/992nZsiVjxowp7G4WSx9//LHfx7m59tprGTJkCLfeeitdunShUqVKzJkzh/vvv59atWoxfvz4gG0PHDhAu3bt6N+/P7NmzeK8887jxhtvpGvXrqSlpfHOO+/QunVr/vWvfwX9Gt544w2uv/56fvjhB9q2bUuXLl1YsWIF119/PW+88UbQ5zlbNCxNRESCl5me/TimdOH1Q84yj+BGmZuwsmLFCnr06EFaWhrPP/88Dz/8MCVKZH/8mz9/PoMHD+axxx6jTJkyPPjgg4XY2+IlLS2NTz/9FGMM1atXZ+PGjaxatYpLLrkk13aPPvoonTp18ipLSkri1VdfZfTo0dx+++2kpaXxl7/8xatOSkoKnTp1YtOmTfTo0YO33nqL2rVre9X5+eefeeSRR/jtt98IxpYtWxg+fDixsbEsWrSIK664Iqu8bdu2DB8+nG7dutGgQYOgznc2KHMjIiLBs5nZj43eQiKGMjdhyVrLkCFDOH36NM888wyPPvqoV2AD0L17dz7//HOMMYwYMYJdu3YVUm+Lny+++IKEhAQ6dOjAXXfdBQSfvfEVFxfHqFGjsrI2Dz74IAcOHPCq89hjj7Fp0ya6du3KrFmzcgQ2AK1atWLhwoXcfffdQV339ddfJz09nXvuuScrsAFo2LAhI0eOJD09vchlb/TOJCIiwfP6YGsCVpPiRpmbcPTFF1+wceNGatSowYgRIwLW69ChA/369ePkyZO89dZbeZ53xowZGGMYMGBAwDr33Xcfxhjef//9rLI1a9bwyCOPcOmll1K1alViY2OpW7cu9913H3/88UfQr2v8+PEYYxg1apTf4+65Kzt27MhxbMeOHdx9993UqVOH2NhYqlatSt++fVm7dm3Q1w+WO5AZPHgwgwcPBmDKlClkZGTk+5yDBw/myiuv5OTJk14/28TERD744APAGUYWHR0d8BxRUVFegUpu3PNq+vbtm+NYv379AJgzZ07Q/T8bwjK4McaUMcb0MsZ8YIxZa4w5ZoxJNcb8Yox5yhhTzk+bUcYYm8st4GBTY0xbY8x8Y0yiMSbFGLPcGDMkjz7WNMaMM8b8YYw5aYzZYox5xhhTqiB+BiIihcPjg61RcBMxlLkJS/PnzwecD6ExMTG51h04cKBXm9z07NmTuLg4Zs+eTUpKSo7j6enpTJs2jZIlS3p9KB4zZgyvvPIKGRkZtGvXju7du2Ot5e2336ZVq1YhBTj5sWTJElq0aMF7771HuXLluOGGG2jQoAEzZ86kTZs2LFq0qMCulZSUxNy5c4mNjaVv3740aNCAyy+/nAMHDvD111+f0bndQaVnfxctWsSJEye4+OKLadKkyRmd3+3o0aNZmbyLL865MmbNmjWpUqUKO3fuDGqhg7MlXOfcDATc4ep64EugAtAW+CdwizGmo7X2oJ+2S4FtfspX+ruQMeYmYBpOIPg9kABcBYw3xrSw1j7kp009YBlQFfgVWAy0Ap4EuhpjOltrTwX5WkVEig7PD7YalhZBikHmxlo4WXQ+gAWlVNwZfYmwZs0aAC699NI867rrrF+/nvT09BzD1zzFxsbSp08fxo0bx2effcatt97qdfyrr74iISGBXr16ER8fn1V+11138eqrr3LuuedmlWVmZjJ69GiefvppnnjiCcaNGxfSawzWsWPH6NevHydOnGDatGleQdfChQvp0aMHt956K9u3b6dkyZJnfL2pU6dy8uRJ+vTpQ8WKFQEn67J8+XImTpzIddddl+9zt2zprFK5cePGrLLVq50l+vOazxMKd2ATHx9P2bJl/dapWbMmCQkJ7Nq1i+bNmxfYtc9EuAY3p4G3gVettVvdhcaYc4F5wMXAazhBkK//WmvHB3MRY0w88CEQDfSx1s50lVcHlgB/N8bMsdb6hvrjcAKbN6y1f3O1KQFMBW4CHgeeDu6liogUIRqWFpm8MjeF140zcjIJ/n1+YfciNCN2QumK+W5++PBhAKpVy3tVw6pVqwJOsJGYmJhnm0GDBjFu3DgmTZqUI7iZPHlyVh1PXbp0yXGeqKgonnrqKd577z1mzZqVZz/za9y4cezfv5/HHnssxxCrrl27ct999/Haa68xd+5cevfufcbX8xyS5jZgwAAeeughPvvsM1JSUihXLsdAo6BUqVIFgCNHjmSVuX/X7t9jQXBn5cqUKROwjjvo8ZfBKyxh+bWbtXaCtfY+z8DGVb4P+KvraW9jzJmG3ncCccAsd2Djus4B4BHXU6/MjTHmMqADcNCjDtbadOBeIA14wBiTe35YRKRI0rC0yFQMMjcRyLq+jLBBDCX0rBPMnJBOnTpRo0YNFi5cyMGD2QNljh8/zqxZs6hQoQI9e/bM0e7w4cN8+OGHDB8+nDvuuIOhQ4cydOhQ0tLSSExMJDExMZiXFjL3ULBevXr5PX7llVcCzupyZ2rHjh0sWbKESpUq0b1796zyqlWrcu2113L8+HE+++yzfJ/f/bsyHn+Dg/kdF8R1AtUpSsI1c5ObX1z3sUBlYF8udfPi/l853c+xecBJnGFmpay1J33azPEdematPWCMWQx0AdoB355B30REzj6tlhaZNOcmLFWpUoXNmzd7BR+BHDp0CHAyKZ5DyQKJiopiwIABvPzyy3z66ac88MADAFnzcG6//XZKlfKeZjxlyhTuuuuuXL/lT05OplKlSnleP1TuxQVat26da72EhIQzvtbEiROx1nLzzTfnGOI2ePBg5s2bx8cff5wj4xUsdx89f07ubI7791gQypcvD0BqamrAOsePHwfIdxbqz1Acg5u6rvs0wF/438UY0xIoBewBvrDW+p1vA1zkul/le8Bae9oY8yvOXJpGZAdVLQK18Sjv4qr3beCXISJSBGlYWoQqBpmbUnHOMK9wUirujJq3aNGCpUuXsnLlyjw/SK9c6XwUqlevXo6gJJBBgwbx8ssvM3ny5KzgJtCQtJ07dzJ06FCstbz22mv06NGDGjVqULq0s19W27ZtWbZsWYFkAjIzM3OUubNR/fr1y3WYVV7BTzAmTpwIwDfffJOVEXI7depU1rF9+/Z5zT8KlnsuVdOmTbPK3PNwVq0K9PEzdO6lpI8cOUJqaqrfeTd79uzxqlsUFMfg5m+u+y8DTNr3/d/9L2PMDGCotTbrqwRjTAXAPdB1T4Br7cEJbmqTHdzU9jgWqI1nvVwZY9YHOFQvmPYiIgVLw9IiUnHI3BhzRvNXwlG3bt146623mD59Oi+++GKuK6a5gxLPYVR5ca/M9eOPP7J9+3bi4+NZsGAB5557Lp07d/aqO3/+fE6fPs3w4cP529/+luNc27dvD/q67mxIoAzQ7t27c5TVrFmTzZs388QTT3DRRRf5aVUwli9fzubNmwHYunUrW7du9VsvMzOTyZMnM3z48JCv8cknnwB4/Yy7dOlCqVKlWL16NZs2baJx48b56L23ihUrUrt2bXbt2sXq1atzBGp79uwhISGB2rVrExd3ZoF4QSpWYwqMMd2BO3CyNk/6HN4GPAw0A8oBtYBBwF6gD+C7q5Jnfu14gEu683Sedd2PQ2kjIhIevIalKbiJHMUgcxOBunfvTqNGjdi7dy///ve/A9b7/vvvmT59OiVLluSvf/1rwHr+uDM0kydPZtq0aZw+fZpbbrmFqCjvj5juye+1atXye33fDSlz4852bNmyJcexzZs3+92ItGvXrgB8/vnnQV8nP9wLCfzjH//AWuv39tVXXwHZGZ5QTJw4kaVLl1KmTBnuvPPOrPJKlSoxbNgwAB544IFc501Za/nxxx+Dul6PHj0AmD495wyNadOmAfidW1WoAv3gw+0GNMEZhmaBv4XQ7lyc5Z0t0NajvIarzAIlArSd5Dp+i0fZVlfZVQHa/MV1/N0zfL3rmzZtakVEzqr1s6x9uoJze/vKwu6NnC2bv8z+vb95WWH3JoeMjAy7YcMGu2HDBpuRkVHY3SlSli1bZmNiYqwxxo4ZM8amp6d7HZ8/f76Nj4+3gB07dmzI59++fbsFbOPGjW3Hjh0tYFeuXJmj3rRp0yxgW7VqZVNSUrLK9+zZY5s0aeL+vGV///13r3aAPf/8873KkpOTbZkyZWyJEiXszz//nFV+8OBB265dO7/nSkxMtFWrVrWxsbF23LhxNjMz0+ucKSkp9qOPPrK7d+/2Kne/pg8//DDPn0VaWpqtWrWqBeyqVasC1ktPT7fVqlWzgF23bl2Oay1atChHm6NHj9pRo0bZ6OhoC9hx48blqHPs2DHboEEDC9iePXvaXbt25aizZs0a27VrVztkyJA8X4+11m7atMlGR0fb2NhYu2zZsqzyLVu22MqVK9vo6Gi7adOmPM8Tyv/Rpk2bWmC9zedn5GKRuTHG1MTZ6yYeeMVa+3qwba2zwtqHrqfXehxK9ngcaHCmu9wzL+pu539BcP9tRETChIalRSZlbsJVmzZtmD17NhUqVODRRx/lvPPOo1evXvTv35+mTZvSvXt3UlJSeOaZZ7jvvvtCPv8FF1xA27Zt2bRpE9999x2NGzf2u9fKDTfcQLNmzfj555+pX78+ffv2pWfPnjRs2JD4+Hjatm0b9DXLlSvHww8/THp6OldeeSXdunWjW7duNGzYEGstV1xxRY428fHxfPbZZ5QtW5Zhw4ZxwQUX0LNnT/r06cNll11G9erVGTJkSI4FBdzzd/LaBBXgiy++4NChQzRq1Mjvppdu0dHRWctR+8vejBkzJmsVub59+9KmTRuqVavGqFGjKFu2LBMmTOD222/P0a58+fJ89913XH755cydO5cLLriANm3aMGDAAHr37k2TJk1o2bIlCxcupEGDBnm+HoBGjRrx4osvcurUKdq3b0/37t3p1asXLVq04PDhw7z44os0atQoqHOdNfmNiorKDagCbMT5azsOMPk4x12u9u/5lB91lTcN0G6F63gLj7LPXWX3BWjzIiFmlwKcR5kbETn7fp2Z/Q3+ux0Luzdytmz5Kvv3/salhd2bHJS5ydvBgwftyJEjbYsWLWz58uWzshuA/fzzz8/o3GPHjs061zPPPBOwXmJior333nttnTp1bGxsrK1bt64dMWKETU1NzcpaBJO5sdbazMxM++KLL9r69evbmJgYW7NmTTt8+PBcz2WttXv37rXDhw+3jRs3tqVLl7blypWzDRs2tP3797effvqpPXXqVFbdjIwMGx8fb+Pj4+3Ro0fz/Dn069fPAvbpp5/Os+7ixYstYGvWrJn1b9bdb/ctKirKxsXF2bp169revXvbsWPH2qSkpDzPnZGRYadMmWJ79epla9SoYUuWLGnLli1rmzZtau+9916vbFewZs+ebdu3b2/LlStny5UrZ6+88ko7a9asoNufzcyNsTZ8v4ExxpQH/oczqX8mcLO1Nu/F2XOeZwQwBmdT0Ic8yr/D2bPmVmvtRJ82McAxnK+zKlrXUtDGmH8CTwEfWGvvxIcx5huc1dK62Jybf4bS5/VNmzZtun59oPUGRET+BL/OhOmubwzPuwTuyvefMQknWxfCpD7O48r14YFAi4wWjszMzKxJ3I0aNcox30P8Gz58OK+88gqNGjVi6dKlVK5cubC7VKSsWrWKSy+9lNGjRzNy5MjC7k5YC+X/aLNmzdiwYcMGa22z/FwrbP/3G2NigVk4gc0CnHkv+QlsDHCT66nvX+t5rvu+5NQTZznpb2z2Hjeeba539dHzWtWB9kASsCTUvoqIFD4NS4tIXqPSwvdLUfH20ksvMXDgQDZv3kzPnj2z9iwRx6JFi6hcuTIPPvhgYXdFQhCWwY0xJhqYAnQGFgO9rbWnc6lfxRhzm59goxzwNtAa2A/4bhf7X5zszI3GmN4e7aoBL7ievuLZwFq7HFgKVAP+7dGmBPAWEAO8aa1NC/oFi4gUFZ4fbLWJZwTRnJviyBjD+PHjGTNmDNdeey0rVqwo7C4VKcOHDychISFrM0sJD+G6z839ZGdbEoC3jP9vEB+21ibgLLv8EfCmMWYjsAtnD5tLgMo4c2v6Wmu9vrKw1iYaY4YBU4HprmFqCUBXV/s3rLXf+Lnu7cAy4G/GmC7ABuAynA1GfwKeze8LFxEpVF7f2itzEzGKwz434ldMTAwjRowo7G6IFJhwDW7iPR7fFLAWjMIJRg7jZFHaAPWBlkAG8DswHmeuzV5/J7DWzjDGdACecLUvibOAwVhr7YcB2mw1xlwMPANc5+rjbmA08JzPMDYRkTCizE1kUuZGRMJDWAY31tpROIFLsPWTgUfP4HpLgW4httmNk8ERESk+tIlnZFLmRkTChL52ExGR4GlYWoRS5kZEwoOCGxERCYGGpUUkr8xN4XUjEM95t+5NF0Wk6PDceibAPPkCo3cmEREJnoalRaiinbkxxlCihDPS/uRJTWsVKWpOnToFQHR0tIIbEREpQjTfIjKFwZwb93K9R44cIZw3KBcpjpKTkwEoW7bsn36tsFxQQEREColX5kbfj0WOop25AYiLi+PIkSOkpKSwZ88e4uPjKVWqVK47oYvInysjI4Njx46RmJgIcFb2DFJwIyIiIfCcc6NhaREjDDI3pUuXpkaNGuzdu5eUlBRSUlIKu0si4qFixYoKbkREpIjRamkRquhnbgAqVKhATEwMSUlJJCcnk56eXthdEol4sbGxxMfHExcX96fPtwEFNyIiEgoNS4tMYZC5cStdujSlS5fmnHPOwVqr+TcihcgYc1YCGk8KbkREJAQalhaZwiNz46swPliJSOHS124iIhI8DUuLTGGUuRGRyKbgRkREgme1iWdkCs/MjYhEHr0ziYhICDQsLSIpcyMiYULBjYiIBE/D0iKUMjciEh4U3IiISPC0Wlpk8optFNyISNGldyYREQmBhqVFJmVuRCQ8KLgREZHg6Vv7yKQ5NyISJhTciIhI8DQsLUIpcyMi4UHvTCIiEgINS4tIXpmbwuuGiEheFNyIiEjwtFpahFLmRkTCg4IbEREJnoalRSbNuRGRMKF3JhERCYGGpUUmZW5EJDwouBERkeBpWFpkUuZGRMKEghsREQme5wdbDUuLIMrciEh40DuTiIiEQMPSIpIyNyISJhTciIhI8DQsLUIpcyMi4UHBjYiIBE+rpUUmZW5EJEzonUlEREKgYWmRSZkbEQkPCm5ERCR4GpYWmZS5EZEwoeBGRESC5zUsTcFN5FDmRkTCg4IbEREJgYalRSRlbkQkTCi4ERGR4GlYmihzIyJFmIIbEREJnlZLi0zK3IhImNA7k4iIhEDD0iKT5tyISHhQcCMiIsHzzNxoWFrkUCArImFCwY2IiATPc0iShqVFEJ/gRkPTRKSI0juTiIjkj77Njxy+v2sFNyJSRCm4ERGR4GlYWoTy/V0ruBGRoknBjYiIBE/D0iKTMjciEib0ziQiIiHQammRSZkbEQkPCm5ERCR4GpYWmZS5EZEwoeBGRESCZ5W5iUzK3IhIeFBwIyIiIVBwE5GUuRGRMKHgRkREguc5LE0LCkQQZW5EJDzonUlERILn9Y29MjcRQ5kbEQkTCm5ERCQEGpYWmZS5EZHwoOBGRESCp2FpkUmZGxEJE3pnEhGR4GlYWoRS5kZEwoOCGxERCYGGpUUkZW5EJEwouBERkeB57XOjt5DIpeBGRIomvTOJiEjwNCwtMvkGsp5zr0REihAFNyIiEgINS4tIGpYmImFCwY2IiARPq6VFKAWyIhIewvKdyRhTxhjTyxjzgTFmrTHmmDEm1RjzizHmKWNMuVza3maMWW6MSTHGJBpj5htj2uZxvbaueomudsuNMUPyaFPTGDPOGPOHMeakMWaLMeYZY0yp/L5uEZFCp2FpkUmZGxEJE2EZ3AADgc+AYTiv4UtgMXAB8E9ghTGmmm8jY8wrwEfAhcBCYDlwNfC9MeYmfxdylX8PXAesdV2rATDedT5/beoBq4DbgcPALCAaeBL4nzEmNl+vWkSk0HkOSyu8XsjZpqWgRSQ8hGtwcxp4G2horb3QWnuztfY6oBGwGmgMvObZwBjTBfg7TrDRwlrby9WmA5ABfGiMifdpEw98iBOY9LXWdrLW9nWdfxvwd2NMZz/9GwdUBd6w1ja31vZ39e0z4Arg8QL5KYiInG0alhaZlLkRkTARlu9M1toJ1tr7rLVbfcr3AX91Pe1tjCnpcXi46360Zztr7TLgHSAOJxPk6U5X+Sxr7UyPNgeAR1xPH/JsYIy5DCdgOuhRB2ttOnAvkAY8YIyJCf4Vi4gUERqWFqGUuRGR8BCWwU0efnHdxwKVAVzzXK5ylU/308Zddr1Pec9c2swDTgJdfebRuNvMsdae8mzgCooWA/FAu9xfhohIUaTV0iKSMjciEiaKY3BT13WfBiS6HjfGCXYOWWv3+GmzynV/kU/5RT7Hs1hrTwO/AqVwhpy5tQjUxqe8RYDjIiJFl4alRShlbkQkPBTHd6a/ue6/9Mic1Hbd+wtssNamAkeBeGNMeQBjTAWgYm7tPMpre5Tleq0AbUREwoOGpUUmZW5EJEyUKOwOFCRjTHfgDpyszZMeh9xLQx/PpXkqTjBTDkj2aJNbu1Sf8wdzLX9tAjLGrA9wqF4w7UVECpaGpUUmZW5EJDwUm8yNMaYJMBHnL/A/rLW/eB523ef219j3L3cw79r+6uR1LX0aEJHw5fmNvYalRQ5lbkQkTBSLzI0xpibO/jPxwCvW2td9qiS77svmcpoyrvsUnzbuY8eCaBPMtfy1Ccha28xfuSuj0zSYc4iIFBgNS4tQytyISHgI+6/djDFVgK9x5rB8CDzsp9ou133NAOcoizMk7ai1NhnAWnsMSMqtnUf5Lo+yXK8VoI2ISJjQsLSIpMyNiISJsA5uXJP/v8BZDW0m8Bdr/f7F3QycAqq6sjy+LnHdr/Up/8XnuOe1Y4ALXefdHEybPK4lIlLkZWZmZD1evuNIIfZEzi5lbkQkPIRtcGOMiQVmAa2ABcAt1toMf3WttSeA/7me9vVTxV0216d8Xi5teuIsA/2NtfaknzbXu/ro2efqQHucjNASf30VESnKDh7L/nM3d93+QuyJnFXK3IhImAjL4MYYEw1MATrjbIrZ27XvTG5ecd0/YYxp4HGuK4C7cebUfODT5r+u8huNMb092lQDXvA5LwDW2uXAUqAa8G+PNiWAt4AY4E1rbVrer1REpGg5eTr7T5fVnJvIkWMIooIbESmawnVBgfuBm1yPE4C3jP+x3w9baxMArLULjTGv4+yDs8YY8zVQErgaJ8gbZK1N9GxsrU00xgwDpgLTjTHfua7XFWeOzhvW2m/8XPd2YBnwN2NMF2ADcBnOBqM/Ac/m+5WLiBSiKI8/tQpuIpgyNyJSRIVrcBPv8fimgLVgFE4wAoC19v+MMWtwgqOrcfbD+QYYba31O0zMWjvDGNMBeAJogxMQbQTGWms/DNBmqzHmYuAZ4DpXH3cDo4HnfIaxiYiEDc9wRsFNpDFkZ2wU3IhI0RSWwY21dhRO4JKftuOB8SG2WQp0C7HNbpwMjohIsRFtMrMeK7iJMMZkZ2yUuRGRIios59yIiEjh8HzTyMSQnpEZsK4UNwpmRaToU3AjIiJBMz5zbk6lK7iJGF6/fGVuRKRoUnAjIiJBi/KYa2FBwU1E8Z5xJSJSFCm4ERGRoEUZz+DGcFrBTeRQ5kZEwoCCGxERCZrvammn0v3unSzFkjI3IlL0KbgREZHgWY/V0qzm3EQUZW5EJAwouBERkeB5fKjN1LC0CKPMjYgUfQpuREQkBN5zbjQsLYIocyMiYUDBjYiIBM14DktDq6VFFmVuRKToU3AjIiJBs9YzcxOl4CaSKHMjImFAwY2IiITAZ5+bNAU3kUOZGxEp+hTciIhI0Iz12ecmQ8FNxFDmRkTCgIIbEREJgfdqaafStKBA5FDmRkSKPgU3IiISPOu7WpoyNxHDK7ZRcCMiRZOCGxERCZ7Xamna5yayKHMjIkWfghsREQmBMjcRS3NuRCQMKLgREZEQ+KyWFgGbeJ44ncGve5PYciCZzMzs1//H0RN8+es+TpwO7Wew9+gJFqzfz8k/cb7Shj+OcesHP/HsvA1efc6PjEzLkq0JZHidRsGNiBRNJQq7AyIiEj7Mq6otPwAAIABJREFUWRqWlnQijS/W7WNn4nHqVC5Dv0trERVl8m4YgvSMTJ6avZ79SSd5okcT6lYtR0am5Z9z1rN5fzJP9mxKdJSh/7vLOHYyHYC7O9blsW5NSDqRxk1vLeXAsVPUrVKWyX9pQ4low3PzNrJkWwKDWp/Pg1fVx7iyHUdST1OxTAyHkk9x43+WkpByirb1KjPxjtZERRn2JZ3gp+2JdG5cjbjSMVl9PHYyjW0HU6gVX4aq5WNJz8hk9e6jVCsfS+1KZTDGsPNwKm9/+xuXX1CJ3pfUBGDEjLWs25vE4q0JtKhVkZ4XnZfvn9P7i7cz5otNrIxNp7L7V6DYRkSKKAU3IiISPOuzWppHcJN8Mo1vNh7k4toVOb9yWb/Nf9iWwMSfdtKj+Xn0uOhcAFbvOsL7i7dTK74MvS+pyfo/knhm7gaOHk/LapeRCQNb1yb1VDqvf7OVI6mnubppdepUKUvdKmWxwIL1+/l17zGuaVad6Sv3EFsiihHXNaZUTLTfvkxfuYfJP+0CYPuhFOY92J6FGw8wYdlOAB6duZaG1cpnBTYAE37Yyd+7NmT+un0cOHbKaZuQynWvf48Bjrj6/OrCLXy75SC3XF6beWv38d2WQ3RuVJValcqQkOK0++G3w8z+5Q/aN6jCjf9ZysHkU9SqVJrP72tH5XKxvPLVZv6zaBuZFqKjDINa12bvkRN8s+kgAI3PKc+EOy5n6Icr+D0hlU9W7KZyuVjOqVCKdXuTsvr84dIdtK1XhW82HuDyCyoF/N0EMuaLTYATzGZTdCMiRZOCGxERyRffzM2IGWuZv24/FUqV4IfHrqJcrPdbTEam5YEpqzmcepovft3POXFtufT8eB6a+gu/J6QC8O732/1ea8H6/fS9tCb3TFzJ4q0JAExbuSfreJQB9+ird777Lau8RJRhZI+mZGZaxv+wgxNpGdzerg5lSpbg+62HsurtOHycMV9sYv0f2UHBr3uP8eveY179OJGWwYodicxas9er3DMQc1u96yirdx3Ner5o86EcdcZ8sYmFG+M5mOwEPLsTT3DvxFW8OfBi3ly0LSuWzMi0WUGX26b9ydz63+VZPzuA5+dvpEPDql711u1NYuD7P7JpfzIlo6P4543NuOXy2jn6khfvUWkKbkSkaNKcGxERCZrnsDQnc+PMG7HWMn/dfgCOnUxn/tp9OdruOJzK4dTTrvrw0NQ1/HYoxevDeSCrdh7hxQWbsgIbX4Gmlby/+HcSU0/z1rfbeGbuBl5csJk7xv/MybQMftmd5FX30593s/6PY/5P5GHsom38uD0xz3rB2H/sJHN9flbLdyTy7LyNQcUPmw8kez3ftD+Z93wCxNPpmWza79Q7nZHJYzPXsXrXkXz0VpkbESn6FNyIiEgIPD/UZg9LSzmV7lUrw88n803/z959x7lVnfkf/zxX0sx4+tge1xn3XgEXbBMIxZQECAECpCzwC+kbsqmbTXZTNiF1N5UsIZsCpCdAQkLNQmihGzDGuOCCjXubsT29STq/P6QZSxrNjAxTJO73/Xr5Jenee3SvZjw6evSc85x9yR/Ed9Q2c9Z3H+3xTOcvGEsgPs+moS3Mzx7bnrS/JD+zwQffvX8TNz5yLJvz1LZaPvKb59lztCXpuPZwNKPqb30FNp9cOYN3Lqnm9JmVDOthSNyIorxen+POF/d23Z8ztrTPazpef994IKPjEoseJA1LU+ZGRLKUhqWJiMhxSC4F3TksrXNYVaegd2wi/W3P72LO2DJe3t93ViTR2xaOY9fhZtbuTs6w5AU9nv/CSkoKQuw63Mxvnt5BSUGQlo4INzz8Srfn+W18Xk2idEPEevOxM6fxo4e2dtt+xszKbs91wcKxTK0sBmJB35Gmdj746+fZuC/2+i9cOI5vXDyPM77zaNf8m5KCIG+aNpL71u3vdo5PrJzOtb9/odfiDUV5AZqOo2rbpv0NfR8EXZk2SM3VKLgRkeykzI2IiGSu27C02OMD9a1JhzXFMzlfvnM937j3Za6+eRV3JWQjMnHKtJEsnji82/YzZlZSUhCrKFY9vJDPv3U21545nSsWH/88kp5ctqiKhVVlFOUFePOMSq49cxorZ4/u2l9SEORbl8zn2+9Y0K3t5IQJ+8X5QaqHF/KDK05g8cQKLjlpPN+8ZD4lBSG+cfE8QgFjeFEev7h6CZctrur2XAUhj9NmVDJ3XO/Zm69fPJ+RxflJ2667aG6Px3cOU4tGHQ+/fJCnXqnt2heNOn7z9A5ueWI7e44cy24pcyMiuUCZGxERyZi51EU8Y9mCg/XJmZuGeIWxzuFVkajj1drmrv03vuckvnzn+qSMz2WLqrqKBJw6fSTF+UGWTh7OTU8kD0c7v4eyxhNGFLKgqqxbpqfr2g2uXDax28T8ZVOGJw01K84Pct3b53WrsnbDe07kpd11BDxj1phShuWlH3KWrmT1zDEl3P6RFUnbzpk7htVfPBvPjKL8YFcWJ9EZM0dREAowf3xZUnGC8eXDkobVnTt3DBv31/O/jx6bb3PZ4mpuefJVXjnUfU7T7iMtNLaFuXPNXv79jpcAuPm9Szhj5ihuefJVvnr3hm5tVC1NRHKBMjciIvKaOEgYlpacuWloC1OXpoJYp3njy3jHouRMxRcvnMOVyyZy6vSRfOmCOQCcOWsUp04f2XXMiKI8zpo1qsfn/d7lJ/CupdV897KFXBAvNd11znFlfOjNU0mMPRZWlXHdRfOSjjtz1qi05aPzgwEWTxrOiRMqkgKb+ePLuu5ftqh79qU3JQUhiuJzh1IzLwBXLZ8EwIThhUnbv3HJ/K77Vy+fyLC8ANecMpnh8bk8nzp7RldQ1JNN+xu6AhuA6+7a0FVVLh1VSxORXKDMjYiIHIfEYWlewrC05KxDfUsH22vTV0Erzg9SVTGMD5w6hT+t3s2B+jbOmTOa0oIQ1709OdDIC3r86pqlrN55lGe217Jy9uiuYCCdaaOK+eYlsaFijW3hpEpkp80YyfjyYVx7xjRueOQVTp0+kuvfdSIl+UFGFOV1zS95y7wxx/HzgK9eNJdrbnmWwrwgnzpnxnG1TZWaRVo2JTYs76ITxvODv2+hsS3M6TMrefOMSn5+1WL21bVw2eJqAEaXFvDov57OgfrWrjk/88aX8Zc1x4YDLqwu58VdsQxQ6rybbTVNPLWtlp2Hm0lHmRsRyQUKbkREJGOW8o19ew9zbo40t7Ohh7LKiydVYGZUFOVx17VvYv2+elZMHdHzOc1YNLGCRRMrjutaF09KPv7U6bH1Xz51zkyuPXM6ecFjgxc+fc5Mrrt7A8umDOfsOaM5HidOqGDVf6wkYJZ2SNrxeO8pk7uCm59euQiz2PNVluTzxw8tY/XOo5w/P5aRWpnmOksKQl3zkQAuW1TNTx7dRk1jG+9cUo0ZXcFNuoppv0tTfKGT5tyISC5QcCMiIplLKCjgMOpaOvj4H17otlbL/60/wP+tT19u+AOnTum6P6q0gFGlBQNyqbPGlDJ9VDFbDjYyeWQRJ004FuwkBjYA7z55ApcvriIYeG2jtUOvsV2qc+eO4d5/ORXPi11/ornjypg7rudhZumUFYa4/5OnsflAA4snVvC7VceCl4dePtjt+Hte6r4+UXoKbkQkOym4ERGR1yTqjH11rfx1TeZV0MaXD+s1S9OfAp7x2/efzKObD3Hq9MpuAU2q1xrY9Lc5fVRGO17Di/JYNiX2Mz99xihgfZ9tCkIeZ8wclVSa2jk7to6nMjcikqWy451cRERygqWsc3M8ivOD3PCek7qGWg2GUaUFXLa4mjFlA5MdyjUTRhQyb3zfwdMpU0eyZFJyGW6tcyMiuUCZGxERyVzSsLTM3fbh5ZxQXd5vw7fktXvLvLGs29P7gqpnzBrFrDElSds050ZEcoF6GRERyVhi5iaaYRcSWxemRIFNlnjr/LH0VffgzFmjug2PU7U0EckF6mlEROQ4HP+H2n8+fWpSBS8ZWpNHFvGtSxewcvYovn3pfLZ+/S1885L5zB5bimfw/jdNZlz5MArzgvzruTO72mmdGxHJBRqWJiIiGUssBZ34Tf7Dnzmd7TWNXHPLc0nH/+GDy7oms0v2uHxxNZfH18cBeNfSCbxr6QScc0lzoj56xjRKC4J88a/rlbkRkZyg4EZERI5D4rC02IfdMaUFTB5ZxMThhd2OHquJ/DklXbGHzipzyXNuBuuKRESOj4aliYhI5tJkbhZWx9ZeSbeA5egBWsNGBk/QS/dRQdGNiGQnBTciIpKxdKWgF1aX93h8QSgw4NckAysYiP2eVS1NRHKBghsREcmYpRmW9raF44bqcmQQdFa505wbEckFCm5ERCRzSd/YGze8+ySqKrrPtZE3jqDXmblJoMyNiGQpBTciIpIx49ginufMHcP5C8YO4dXIYFDmRkRyiYIbERE5DgkfatNU1ppaWdR1f+XsUYNxQTLANOdGRHKJghsREclc0qi07l3Idy8/gZHFeVRVDONrb58/eNclA6azWlpyOKPgRkSyk9a5ERGRjCUOS4PumZsTqst58nNnEfQsbWloyT2hQOfvUZkbEcl+Cm5ERCRjidXSLO36J8cWfZQ3hqDm3IhIDlEPJCIimXO9z7mRNx5VSxORXKLgRkREMpaYufEU3PiCqqWJSC5RcCMiIhlLDG6cuhBfOFYtLYEyNyKSpdQziYhI5hI+1FqaamnyxhPylLkRkdyhnklERDJmSevcDN11yODROjcikksU3IiIyHFQ5sZv0g5LU+ZGRLKUeiYREcmYl/ihtodS0PLGEur6PStzIyLZTz2TiIhkJuUDrYql+UPaYWkiIlkqZ4MbM1tkZp8zsz+b2R4zc2bW2svx/xk/pqd/3+ql7Qozu9fMDptZo5mtMrOr+7i+KjO7ycz2mlmrmW02s6+aWcHred0iIkOm27f1gSG5DBlcx0pBJ1DmRkSyVHCoL+B1+CJw0Wto9wSwNc3259MdbGYXA7cRCwT/AdQAZwG3mNlC59yn0rSZCjwFVALrgMeAxfFrXmlmZzjn2l7DtYuIDKHUzI2+yfeDY4t4qlqaiGS/XA5ungJeBJ6N/9ufYbufO+duyeRAM6sAbib29eSlzrk/x7ePBh4HPmlmdznnHk5pehOxwOZ659zH422CwK3AxcC/A1/O8HpFRLKDiyY/VmzjC4F0wY0yNyKSpXJ2WJpz7tvOuS875+52zh0YoNO8HygD/toZ2MTPfQD4bPxhUubGzJYApwEHE47BORcGPgJ0AB8zs9AAXbOIyMBInXPjaViaH5gZoYCpWpqI5IScDW4GyQXx29vT7LsHaCU2zCxxHk1nm7tSh57Fg6LHgArglH6+VhGRAZYS3Ch14xtBz1PmRkRygh+DmzPN7Adm9hMz+4KZLerl2AXx29WpO5xz7cTm0xQAMxN2LeypTcr2hT3sFxHJTt2GpSm48YtgwDTnRkRyQi7PuXmtrkx5fJ2Z/Qn4f865xs6NZlYKlMcf7u7huXYTKxQwgdj8H+L3+2qTeFyvzGx9D7umZtJeRKTfdCsFrWFpfhEKeJAY2ypzIyJZyk+Zm63AZ4C5QDFQDbwH2ANcCvw65fjihPvNPTxnU5pjO+8fTxsRkeyXkrlRtTT/CHrK3IhIbvBN5sY595uUTU3A78zsYeAl4O1mtsI592R8fya9drpjOrf19M5/XJ8GnHNz0z5JLKMz53ieS0Tk9UktKKDgxi9CAQ/nEufcRHs+WERkCPkpc5OWc24fsXLPAOcm7GpIuF/YQ/PO7Y0J2zrbFR1HGxGR7Jc6FMl834X4RjBgRFVQQERygHqmmC3x27GdG5xz9UBd/GFVD+06t+9M2LYzZV8mbUREsp+GpflWbFhaIgU3IpKdFNzEVMRvU7MpnUUCTkptEF+nZh7QBmzKpE3K9rXHf5kiIkMp9QOtuhC/CAVUClpEcoPveyaLffV4cfzh8ym774nfviNN0wuIlYF+0DnXmqbNhWaWn3Ku0cCpxDJCj7+e6xYRGXTdFvFU5sYvVApaRHKFL4IbMxtpZlelCTaKgRuBk4H9wB0pTX8O1AMXmdklCe1GAf8Vf/i9xAbOuVXAE8Ao4NsJbYLAj4EQ8CPnXEc/vDQRkcHTrRS0ghu/CHopHxeUuRGRLJWz1dLM7Hzgiymb88zs6YTH1znn7iFWdvmXwI/MbCOx+S7lxIaIjQCOAu9wziWVb3bOHTaza4BbgdvN7FGgBlgZb3+9c+7BNJf3XuAp4ONmdiawAVgCTAGeAb7+2l+5iMhQSc3caJ0bvwgpcyMiOSJngxugkljGJZGlbKuM39YSy6IsA6YBJwARYDtwC/B959yedCdxzv3JzE4DvhBvnwdsBG5wzt3cQ5stZnYi8FXgPGLD3nYBXwO+kTKMTUQkNzhNKferoKc5NyKSG3I2uHHO3UIsMMnk2Abgc6/jXE8AbznONruIZXBERN4YUqqleSoF7RuxOTciItlPPZOIiGQo5eNt6jwMecNStTQRyRXqmUREJDMpH2iVufGP2Do3mnMjItlv0IelmdkDwFTAOeemDvb5RUTkNUoZloaKpflGLHOTQJkbEclSQzHnpgqYhL72ERHJMaqW5lda50ZEcsVQBDdXAYVDcF4REXk9un1br9SNX8TWudGcGxHJfoMe3Djnnh3sc4qISD9QtTTfCnWrlqbgRkSyk3omERHJUOqwNGVu/KLbsDRlbkQkSym4ERGRzCR8oI06Q7GNf3RbxFOZGxHJUv06LM3MbjqOw51z7n39eX4RERlACcPSHGCac+Mb3YalKXMjIlmqv+fc/L8Mjon1ibFbBTciIjkoiocptvGNYOoinsrciEiW6u/g5owetntANXAucAXwfeCufj63iIgMpIRv6x1gim58I+QpcyMiuaFfgxvn3KN9HPIrM7sPuAm4sz/PLSIiAyxpWJrm3PiJMjcikisGvaCAc+43wHrgPwf73CIi8nokZm5Mw9J8JBgwtM6NiOSCoaqWtgVYPETnFhGR18IlBzeeohvfCKYOS1PmRkSy1KAHN2bmAQuAaF/HiohIFkkZlib+4ZnWuRGR3DBowY2ZFZrZCcDvgelAX/NzREQkqySsc6PMja90C26UuRGRLNXf69xEMjkMOAT8a3+eW0REBpjTnBu/8iwlnFFsIyJZqr9LQe+i57e8dmAfsYzNDc65g/18bhERGUgpi3gqc+MfnqfMjYjkhv4uBT2pP59PRESySUrmZgivRAaXac6NiOSIoaqWJiIiuabbsDSFN34RMFVLE5HcoOBGREQyk1ItTbGNf8QWbFXmRkSyX3/PuemTmY0FQgDOuZ2DfX4REXmtVC3Nr1QtTURyxaAHN8BDwAxi74xDcX4REXktUoelDeGlyODyPEtO1ihzIyJZaiiGpVn8n4bEiYjkkqTgBjy9i/tGrBS0Mjcikv0GPXPinJs12OcUEZH+kBjceMrd+Ei3YWnK3IhIltL3biIikpmUdW405cY/LHURT2VuRCRLKbgREZHMqBS0bwVSF/FU5kZEslS/D0uzWG/3HuAiYDpQAmnHLjjn3NT+Pr+IiAyU1GppQ3gpMqg8rXMjIjmiX4MbM8sD7gHOJH1AA/HRDP15XhERGQSp69zordw3tM6NiOSK/h6W9mngLOBuYlmbXxMLZvKB2cB/Ak3AfzvnNCRORCSXpAxLU+bGP0zr3IhIjujvYWlXAIeBdzvnmswsCuCc6wA2AV81s4eBh81sk3Pupn4+v4iIDJiE4MaZcvA+EkgdlqbMjYhkqf7OnkwDVjnnmuKPowBmFug8wDn3GPAE8M/9fG4RERlIKdXSPBUU8A3P0zo3IpIb+ju4iQD1CY87g5zKlOP2ADP7+dwiIjKQUqulDeGlyODqNixNmRsRyVL9HdzsASYkPN4av12WctwCoLGfzy0iIgMqpVqaJt34RvdqaSIi2am/g5ungblmNiz++N747Q/N7C1mNt/MfkSsuMAz/XxuEREZSN2qpYlfBJS5EZEc0d/BzZ+AZuBsAOfcVuAHQDWxCmprgI/Gj/m3fj63iIgMJJd4V4t4+olnmnMjIrmhX6ulOefuAcambPu0mT0LvB2oADYD1zvntvTnuUVEZKClzLlRbOMb3QJZZW5EJEv1dynotJxzfwD+MBjnEhGRAZIyLE3V0vwj4GmdGxHJDVpIU0REMpNULU3L3PhJt2FpytyISJZScCMiIhlKrJbmKXPjI9atWpqCGxHJTgpuREQkMymLeCq28Q9lbkQkVyi4ERGRzCQNS/MU3PiI5tyISK5QcCMiIhlKnXOj6MYvui3iqcyNiGQpBTciIpKZ1Gpp6kF8w7TOjYjkCHVNIiKSGZdYUMCUufGRWPEIzbkRkeyn4EZERDKUvIinp9jGN2JzbhIpuBGR7KTgRkREMqNqab6lamkikisU3IiISGa6VUtTdOMXWudGRHKFghsRETlusWpp4hexamnK3IhI9lNwIyIimUmtlqbMjW8EUoMbZW5EJEspuBERkcykVktTbOMbsVLQxzhlbkQkSym4ERGRDKVWS1N04xeel5y5UXAjItkqZ4MbM1tkZp8zsz+b2R4zc2bWmkG7q8xslZk1mtlhM7vXzFb00WZF/LjD8XarzOzqPtpUmdlNZrbXzFrNbLOZfdXMCo73tYqIZAMXjRy7rxk3vhLQOjcikiOCQ30Br8MXgYuOp4GZfQ/4JNAC3A8UAGcD55jZZc65O9K0uRi4jVgg+A+gBjgLuMXMFjrnPpWmzVTgKaASWAc8BiyOX/NKMzvDOdd2PNcuIjLUnDsW0jgMTwvd+IanYWkikiNyNnNDLHj4KnAhMKavg83sTGKBTS2w0Dn3dufcecBpQAS42cwqUtpUADcDAeAdzrnTnXPvAGYBW4FPmtkZaU53E7HA5nrn3Hzn3BXATOAOYDnw76/lBYuIDCWXWFDAmXI3PmJmOKeCAiKS/XI2uHHOfds592Xn3N3OuQMZNPl0/PZrzrktCc/zFPAToAy4JqXN++Pb/+qc+3NCmwPAZ+MPkzI3ZraEWMB0MOEYnHNh4CNAB/AxMwtlcM0iIlnDJa1zg+bc+EjqIp4uGu3laBGRoZOzwc3xiM9zOSv+8PY0h3RuuzBl+wW9tLkHaCU2zCxxHk1nm7tSh57Fg6LHgArglMyuXkQkOyRmblQtzV8CXvIink6ZGxHJUr4IbogNI8sHDjnndqfZvzp+uyBl+4KU/V2cc+3E5tMUEBty1mlhT21Sti/sYb+ISHaKJq9zo+DGP8xULU1EcoNfgpsJ8dt0gQ3OuSbgKFBhZiUAZlYKlPfWLmH7hIRtvZ6rhzYiIlkv8fOsw9CsG/9IHZamamkikq1yuVra8SiO3zb3ckwTsWCmGGhIaNNbu6aU58/kXOna9MjM1vewa2om7UVE+k9y5kbF0vzDM1O1NBHJCX7J3ByrXtr3MT09zqRNJufSxwERyUnRbsPS9HbmFwEveZ0bBTcikq38krlpiN8W9XJMYfy2MaVN5776DNpkcq50bXrknJubbns8ozMnk+cQEekX3aqlDd2lyOCybsPSVC1NRLKTXzI3O+O3Vel2mlkRsSFpR51zDQDOuXqgrrd2Cdt3Jmzr9Vw9tBERyXqJ39ZH8TTnxkc0LE1EcoVfgptNQBtQaWbpgo6T4rdrU7a/mLK/S3ydmnnx592USZs+ziUikt0SF/EEzC89iMSDGy3iKSLZzxddk3OuBXgo/vAdaQ7p3HZ3yvZ7emlzAbEy0A8651rTtLnQzPITG5jZaOBUYhmhxzO7ehGR7OBcypybIbwWGVyxamnHuKiCGxHJTr4IbuK+F7/9gplN79xoZsuBDxGbU/OLlDY/j2+/yMwuSWgzCvivlOcFwDm3CngCGAV8O6FNEPgxEAJ+5Jzr6IfXJCIyaFzSnBvDU0EB3zAzkhc2UnAjItkpZwsKmNn5wBdTNueZ2dMJj69zzt0D4Jz7u5n9EPg4sMbMHgDygLOJBXnvcc4dTnwy59xhM7sGuBW43cweBWqAlcTm6FzvnHswzeW9F3gK+LiZnQlsAJYAU4BngK+/jpcuIjIkumVuFNv4jKqliUj2y9ngBqgETk7ZZinbKhN3Ouc+YWZrgGuJBTUdwIPA15xzaYeJOef+ZGanAV8AlhELiDYCNzjnbu6hzRYzOxH4KnAecDGwC/ga8I2UYWwiIrlBmRtfs4RJVgpuRCRb5Wxw45y7BbhlMNo5554A3nKcbXYRy+CIiLwhJFdLU2DjN66XRyIi2cJPc25EROT1SKmWpsyNvyQt2qrMjYhkKQU3IiKSEc258bvEOTdaxFNEspOCGxERyYxLvKs5N77jKXMjItlPwY2IiGTERSPH7mudG98xVFBARLKfghsREcmII7lamhI3PpO0zI2GpYlIdlJwIyIimUmplmaKbnwm4SODMjcikqUU3IiISGaSvq1XYOM7CcGsUyloEclSCm5ERCQjyfMsFNz4jkpBi0gOUHAjIiKZSfhA6zQkzXe0zo2I5AIFNyIikpHUdW7Eb1QtTUSyn4IbERHJjIal+ZolfWJQcCMi2UnBjYiIZMSlVEsTv1G1NBHJfgpuREQkM4nV0jTnxndM1dJEJAcouBERkYyoWprPqaCAiOQABTciIpIZFRTwNUPBjYhkPwU3IiKSkcRqaVFT9+E7SUMRFdyISHZS7yQiIhmxaKTrvlP34T+Jc26UuRGRLKXeSUREMqJ1bvxNi3iKSC5QcCMiIplJGpYWGMILkaFgSUMRFdyISHZScCMiIplJGpamzI2vKXMjIllKwY2IiGQoIXODMje+o8yNiOQABTciIpKZaMKcGy3i6TuacyMiuUDBjYiIZMZpWJqfmUpBi0gOUHAjIiKZSfi2XsPSfEiloEUkByi4ERGRzCRUS0PD0nxHw9JEJBcouBERkcwkVkszdR9+o2FpIpIL1DuJiEhmEte5UffhO0nhMZKWAAAgAElEQVTr3ChzIyJZSr2TiIhkxiVWS1P34TvK3IhIDlDvJCIimUkMbtR9+I6hOTcikv3UO4mISGac5tz4mebciEguUO8kIiKZSfi2XpkbH9KcGxHJAeqdREQkM0mZG5WC9pvkX7mCGxHJTgpuREQkI5ZUUECLePqNqqWJSC5QcCMiIplJKiigzI3fmLJ1IpIDFNyIiEhmEoIbdR8+ZKqWJiLZT72TiIhkJnERT1VL8x1VSxORXKDeSUREMmJaxNPXvITfuSlzIyJZSr2TiIhkJrFamubc+I8yNyKSAxTciIhIRlQtzd80LE1EcoGCGxERyUxiQQENS/MfFRQQkRyg3klERDKTVC1Nw9L8xvOUuRGR7KfgRkREMpNULU3D0nxHi3iKSA5QcCMiIhlJnnOjzI3faBFPEckFCm5ERCQjScGNug/f8RKGIpqGpYlIllLvJCIiGVJBAV/TsDQRyQHqnUREJCMW1SKefqZS0CKSC9Q7iYhIhrTOjZ8puBGRXKDgRkREMpM050aTy/0msRS0aViaiGQpBTciIpKRxIICpmFp/pP0O1dwIyLZSb2TiIhkxJLWuVH34TcqBS0iuUC9k4iIZCgxc6M5N36TFNxoWJqIZCkFNyIikhEt4ulv5h37yKB1bkQkWym4ERGRjCQHN8rc+I2qpYlILvBVcGNmj5iZ6+XfeT20u8rMVplZo5kdNrN7zWxFH+daET/ucLzdKjO7emBemYjIIEiqluar7kPQsDQRyQ3Bob6AIfInoDHN9j2pG8zse8AngRbgfqAAOBs4x8wuc87dkabNxcBtxILHfwA1wFnALWa20Dn3qf56ISIigyW5WpqGpfmNl/A717A0EclWfg1uPuOce7Wvg8zsTGKBTS2w3Dm3Jb59OfAIcLOZPeKcO5LQpgK4GQgAlzrn/hzfPhp4HPikmd3lnHu4f1+SiMjAssRFPD0NS/Mblf8WkVygd6refTp++7XOwAbAOfcU8BOgDLgmpc3749v/2hnYxNscAD4bf6jMjYjknsShSMrc+I4pcyMiOUDBTQ/MrIDYUDKA29Mc0rntwpTtF/TS5h6gFVgZf34RkZzhuUjXfYcyN35jnubciEj28+uwtPeZ2QhiizZsBv7inNuZcswsIB845JzbneY5VsdvF6RsX5Cyv4tzrt3M1gGLgZnAi6/x+kVEhkBitTR9N+Y3icPSlLkRkWzl1+DmCymPv2Nm1znnrkvYNiF+my6wwTnXZGZHgQozK3HONZhZKVDeW7v49sXx5+8zuDGz9T3smtpXWxGR/mQaluZrKgUtIrnAb1+9/QO4klhgUEgse/IfQBj4qpl9POHY4vhtcy/P15RybHHCvp7apbYREckJljAszbTOje8kV0sTEclOvsrcOOe+lLJpM/ANM3sO+D/gK2b2U+dcC8feu3v7eir1/T2T9/vj6hOcc3PTPkksozPneJ5LROT1SByK5Dy/fTcmlvQ7V+ZGRLKTeifAOXc/8ByxKmfL4psb4rdFvTQtjN92rpnTkGZfX21ERHJC4jo3mnPjP1rEU0RygXqnYzpLPY+N33YWGKhKd7CZFRGbX3PUOdcA4JyrB+p6a5ewPbWAgYhIVksMbtR9+E/iUERPmRsRyVLqnY6piN92ZlQ2AW1ApZmlC1ROit+uTdn+Ysr+LmYWAubFn3fT67paEZFBlriIJ5pz4z8JC7cakV4OFBEZOgpuADOrBE6NP1wNEJ9381B82zvSNOvcdnfK9nt6aXMBUAA86Jxrfc0XLCIy2JxLLv+ramm+Y96xabqBpCyeiEj28E1wY2bLzOwMS65liZlNAu4gNrfmzpQ1bb4Xv/2CmU1PaLMc+BBQD/wi5VQ/j2+/yMwuSWgzCvivlOcVEckNqR9mPWVufCeQENwocyMiWcpP1dJmATcD+8xsM7Cf2PyXRcSyKeuBDyQ2cM793cx+CHwcWGNmDwB5wNnEAsP3OOcOp7Q5bGbXALcCt5vZo0ANsJLYHJ3rnXMPDtzLFBEZAKnBjQoK+E9C5sYjCtEoqGqeiGQZPwU3zwA3AicTK6F8CrE1Z9YAtwE3xoeiJXHOfcLM1gDXEgtqOoAHga855x5PdyLn3J/M7DRii4UuIxYQbQRucM7d3N8vTERkwEWTv6l3/kn8S1zisDQAXAQfDQARkRzhm+DGObcR+OfX2PYW4JbjbPME8JbXcj4RkayjYWmSmqWJhiEQGpprERHpgb5yERGRvnUblqaCAn5jqYFMVPNuRCT7KLgREZG+ueQPsqZS0L7TbVhaNDw0FyIi0gsFNyIi0reUzI3TRHLfsUBKQKvMjYhkIfVOIiLSN5eyIr0yN75jXuqwNGVuRCT7KLgREZG+pXxLH1Dmxnc0LE1EcoF6JxER6VvKsDQv4JtimxLXfViaghsRyT4KbkREpG8pwU0g9YOuvOGZ5xF2CR8bFNyISBZScCMiIn1LqZbmBdR9+E3AjEjixwYVFBCRLKTeSURE+paauUmdfyFveJ4ZERIydk7BjYhkHwU3IiLSt27D0tR9+I1nEEbD0kQku6l3EhGRviUMQYo4I6TgxncsNXOj4EZEspB6JxER6VvCOjcRPAKeDeHFyFAIeJaSudGwNBHJPgpuRESkbwnD0hweQQU3vuMZytyISNZTcCMiIn1LmDwexZS58SEzI6zgRkSynIIbERHpW0LmJqLMjS8FPCOidW5EJMspuBERkb4lBDdRjKAKCvhObFia5tyISHZT7yQiIn1L+CDrNCzNl7qtc6PgRkSykIIbERHpm4al+Z5nqdXSNCxNRLKPghsREelb0rA0lYL2o7yg1rkRkeyn4EZERPqWVAraCHrqPvwmPxhIytw4BTcikoXUO4mISN9Sh6UFlLnxm7ygl5S5CYc7hvBqRETSU3AjIiJ9iyavc6M5N/6TH/SS1rkJdyi4EZHso+BGRET6pjk3vpcX9IgmrHMTDmtYmohkHwU3IiLSt8TgxmnOjR/lBbykOTcRDUsTkSyk3klERPrmEoelKXPjR8GAR9SODUsrf/AzcNN50Hx4CK9KRCSZghsREelbSkGBkAoK+FJicAPAzqfggS8OzcWIiKSh4EZERPrm3LG7mDI3PuVSgxuAtbcO/oWIiPRAwY2IiPStW7U0dR9+5CyYZqPrvk1EZIiodxIRkb6lDEtT5safnJcmc4OCGxHJHgpuRESkTy1t7V33nRbx9K30mZto920iIkNEwY2IiPTq/hs/zbA7ru56rEU8fSxd5kbBjYhkEQU3IiLSo5qD+zjnwM+TtkXwNOfGr9IOSxMRyR7qnUREpEctR/Z12+YwAhqW5k9emmFpIiJZRMGNiIj0yEW6r0KvYWk+puBGRLKcghsREelRpKO1+zZVS/OvnoKbX74NNt49uNciIpKGghsREelRuLWx27YoHiHNufEl62nOzfZH4Y/vgTSZPhGRwaTeSUREehRpaeq2TXNufKyvYWmt9YNzHSIiPVBwIyIiPYq0NXTf5jzNufEpC4R6P6D16OBciIhIDxTciIhIj1xbumFppjk3PuX1VQq6tW5wLkREpAcKbkREpEeuPf2wNGVu/MkCfQ1LU3AjIkNLwY2IiPQoXXATtQBmCm78SMGNiGQ7BTciItJdax3c928s2Pw/3XY5FNj4ldfXnJvbrobfvxuaagfngkREUii4ERGRblof+m945idp9zlT1+FXXl+ZG4BN98CDXxn4ixERSUM9lIiIdFOw6kc97lNw4199Zm46rf7lwF6IiEgP1EOJiPhZNAoHN0K4/TgaqevwKy+YQeYmnb99Hq4/Edb9uX8vSEQkhXooERE/+8uH4cfL4GdnQkcLtDVAS+9rlShz41+BTDM3cCxg3v4YPP1jOLwN7vnUwFyYiEjca/wKRkREclZrHfz1Wji6E/atiW078BJ8fQwE8mDiil6bK7jxr0Cwj3VuEj38dWg6BGt+e2xbyxEIt0Ewv/8vTkQEBTciIr7jnrsF23hn+p2Rdtj2SO9PoODGtwLB48jcPPGD9Nsb9kHFpH65HhGRVOqhRER8puXpn7+u9k5dh28d17C0ntTve/3PISLSA/VQIiI+U9PiXt8TKHPjW8eVuelJw97X/xwiIj1QDyUi4ifRCKMj+1/fc3jqOvwqGFLmRkSym3ooERE/ObqDfDp63P21jvfwp8iben0KZ8cxqVzeUI5nWNqmaBUfaE9THa1emRsRGTgqKCAi4iPRg5uSvtX6YfhinovO5KPBv3LAVfDryNmEIwH+ED6T3+R9k3xLFwjZYF2uZJlMMzd/iazgR+GLecWN513t/8EXgr9hrrcDgHDdHn34EJEBo/eXAWJmBcDngXcBE4DDwN+ALznndg/ltYmIfzXt2UBJ/P7DkYV8P3wZAGsDi6hrORbIPOtmsd9VMNEOdn8SzbnxrWAGc24eZCmf6Li26/FT0bncEjmX//Z+CkBzzS5KB+wKRcTv1EMNgHhg8yDwJaAY+CuwC3gvsNrMpg7h5YmIj7Xu29h1/xU3DoDi/CD/+NczuPVDyzlxQvmxY8lL/ySehqX5VTDY93eiZ82fyG/ffzL/tGwCv//AMl791vlUjpvctd9pzo2IDCBlbgbGvwMrgKeAc5xzjQBm9ingu8BNwJuH7vL8ad2eOp7ZfphLTxpPeWEezjk6Io68oGJ88Y/AoQ1d97e68UwaUchnz5tFWWGIpZOHc+Wyibyw8ygAbfTwLb0yN74VCvUQ8CYqquSUaSM5ZdrIrk1VE6bAodj9wrZDEI2qMIWIDAgFN/3MzELAx+IPP9oZ2AA4575nZlcDp5nZIufc80NykT60r66Fd/30aRrawvx+1U5+ec1Srvz5M+w+2sJ3L1vIhQvHDfUligy89mbK6l/uelgx7WQeee8ZSYeMLx/WdV/BjaTqc85NsABW/Eu3zTOmz4R4jxeig47GQ4RKRw/AFYqI3ym46X9vAsqBV5xzL6TZfzuwALiQrrd6SbT7SDPXP7iFuePKuHrFpB6Pc87x8KaDFOUFOXnKCPbXtXLLk6/S0NrB9FHFXLFkAsPyYsNnbntuNw1tYQC2HmzklG891PU8H/v9C3REosweW8qM0SWEo1Fe2l3HvPFlFISSh9/UNrZREApQlN/9T6e1I8KLu44yZ1wpJQWhrms0633ydUNrB5v2N7Cgqpy8oEdjW5jWjggji/N7fN0A963bz23P7SIcdcwbX8Y/LZuY9MG0vzjn+PPqPeyra+GdSyew7VATE4YXMqasgJd21/Hgywd467wxzBhdAs/dBDuegOqTYf5luNY6XPNRvKoTY0928GUI5sPwyWnPs35vPev31lGYF2TJpOGMKSvo2l6YF2BKZXGv1/rk1hrqW9o5pzqKt+a3ULUYpp3V4/Ft4QjOQUEoQCTqONzUTmXJsZ+7cy42dT71dxiNwO7noKwKysZn+qNke00T1z+4hdljS3j/m6ZwuLmdhzYeZH5VGbPHpp+F8PS2Wh7dfIhTpo7kp49twznH504dwdzGJ2HKGVBejXOOLQcb2bC3nqmVxcwfHoGWI7iSMbx0sIMJwwspL8yDvasJuAgATS6fwNg53c43viIhuHE9BTcaluZXod6Cmzd9CuZfBqVju+2aN6WaRldAsbUCsP6ZB5l+2uXd3kvbw1Fe3H2UgGfMG5VPHh1QUHbsAOfgH9+BTfcQXf4xvPmXdjuXcw4XdXieHfvbjUZg59NQsxlmnAulKV9ohdvguZvBRWHpByEQhD2roagSyqvTv95wO7godR0BHC72N9aL1o4ILW1hKqwBVziie9/gHG7z37A9z0NrPZSMgVnnQ+VMNu+v57GXNrO3rZA3TSnllOZHaD6wlbxTPkJh+Whoa4BohH3t+Ty2pYaTJw9n4oiiXq8n7evZ92Ls91dWlf6YSAccWAdeiI4RM2lsd1QU5cUv30E0gjXXQsnorr7KzGIV8tb8DqqWwJQ3E45E2XG4mUjUUV1R2NVXp//B1cHzt0BeESy6pueMX/Ph2DHB9H0nQM2+HRTnBygoH9f9eQ5vg53PwNQzoXhU7P+a58Xf75+FislQkhCQJ2YfnSNat4f7dxkjS4axeNJwNh9o4O8bD7BkTIAl08ZDsPf/H3UtHdy/fj/bapq49KTxTBtVkrT/YH0rdz27hVC0hUtPO4m8oMeda/ZS29TGuPJhLJk0nMe31HBCdSlTK0IQyAMvwOYDDXz/gc1sr4n13Z9YOYM549L0N+3N8Nh3oW43nPkfUD6h1+vNZgpu+t/C+O3qHvavTjku9zz5o1hHQOyPsbEtwtiyAjwDCofT4hWx9VAT++tacS7KsPYjBD2wokqaw47ZY0oYm9fCgYMH2V3XRnXVBEbltYN5tBcM56b7NtHa0Mr2F+rZvHcE00cVU9fSgWfGb188wp7WYVy5YhJ7apt44sUNhAmwf9ZUnt9Zx+GmdgzHZmvhl/+IUFU1kYPNUTbvOMoFvXzZ/NDtT/EwjlJrppBWjlLMP/JamTpuJJvrgxxtaGQ49RzqKKA4EOWcWRUsnjuTmuYILe0R9te38uCL2wm01PJUAIrKR7CjKY/GtggrppSzfHSEMUVGXYfH0/uiNB85wKTyPAIB45GtdexqLyFMgDFl+bTUH6GMBk6ZVskpC2bS0d5CR1MdhQV5rD6cxx1ra3AtRyilidnx66/bVsxPnvB4x9wyFs6cAi1HINxGNFjAmoOObTt30hooZkZlAYtGewS8QKzTbmuAjua0P5OIBQgUV/L0+ld4cWMtbeTx0wcbaWIY1V4NHQUj+X3DCVwRfJhRj90P1nSs8bo/wX2fxYjV1Xqq9DyKaGFB/aNEMfbO+zClp3+CkqICVu8Ps3ZvA7c/v5vwvnV8LHgHs2wXWxnOr8e/l8PRYq7Y918U2mEOhvJpK6ri5Ynv5q7meczedjNTI6/QcvInGX3wMSZu/yPjrTbpdbSOOoGC6hOJlFWzuXgpB1bfQ6RmK3tbQ4TDERZ6r1DqtbIlMpbHo/MpHTEWm3wKj285xL8038gZ3gsE8guJTDmT3xW+hw17jvKhI99hUssGInisLT2d8mlLmXTS2Vh+CZSMYWdTiFUbNlO86c9MYi9TItsIRtr485FTKG5u4+jaZn7ySJBQtJVRkf3k2XaOhNopGjOdozMvZ/XWPUwYWcy+3Tt4cU8j90ZXcOMjYwgSZpm3kVE7fwxWR52V8uHC7xFtb2Jm82oqrY7Z3nPgxWqWOIz26HRu5kQmnHwxJ7StonPC3wvRaVSP6N7BjSkt6Lp/lB6CSWVufCvU2we0RVdDxaS0uwrygjxftJhFzY8DMOPxT3D1w/uZcsKb+fDcMMPX/4rGo4f4y8Ex/LpxMWcFXmBm6PcEA47t867l7oILGVFeztv2X0/pi78AoOP2D/Kr/1vFO0OPUdy4HRs5g6N5ozm0cxPjo/tot3zWj7uE1pkXceJTH2d4604Aol4IG7sQi38Ibu/oIG/vqmMXe2Q7eEF4+sc484hUL8cLFbArOJEtoVlEQ0VM33UrE2sexyPCK9Hp/G/kAk4aEWH6nBPYuPMgZ9b9mYnhV8nPyyNaMpY7A2fzrVencoP9N0u9l1nDTP5Wehmnn3U+yxfOgSOvcvSPH6F8/5NJP7foQ1/noZK3UX50He/zNgNQ92whedZMHvDkM/ezq3wplzb+DouGOegmURkt5ucsYeLZ/8wJEyqobWqnojCP+pYOamoPMbLmWUZ07GNXS4jR4f1UBpuhuZZxNU9QEGmEUCGs/Ao017J7z06+v62aRgo41dbypvBTTLLYOllNlLArOpL6fI/d487hif1B/l/bbxnFYQC2MoEt0bE8WHQBX+n4PsXh2Pa7Kz/El2tXMqt1Nf8avJUnA5VMOf9TrGsZwd3PvkzZ2OmcPqqRV3bu5tVDDfxn+AeUtMfHNEbCNFS9mdpNj/HCkWG0FIzmzLL9FGx/gLJtd2E4mspn0VJcRVNhNb+snc2Roil86vQJbLr/p6zc/3MADuZV8ZXgv3DvkSqqKwp51/BNfHDvFwlE27t+9hEL0hYopjAcG6bbHCjlxmk/4Z0jtlHy3P9Q3H6AvcNmsu+tt7D4lf/BW/MbznbGc24mD+WP5utNFzKJfVwZ+jGRoCOw4qNsHTafdS88zZzoFqaOG4mt+Bje3uepW38/z26vZWS4hfl2mF89+RZGLv8nLizeyKRADWv2NrNv7YNcbasIWpR9T47if0NX8ljDGE70trLRefx79CSWexs4OfRrsBpcqIitI07n7r0lhMIjWG71jKup5Y4dExn39jMINOylpvYQh6KldDQfZcHeWylpeAWA+m2rcO9/iLLyip7/3rOYdUbW0j/M7HvAJ4HvO+e6Ffg3s4XAGmC1c25RBs+3voddU+fMmZO/fn1PuwfQN6uhrX7wzytvSB0uwCtuHHvcSE7x1lGQtvRw7mgnyPORGZzobem319LhAmx146m2g13ffB+vqDM8O/Z+/2N3KZd95sakTFWnSZ+7B4DJto8H8z6T1A7g/vIrOOcTP31N1yE5bv9L8JMe1kH6zJbYN949eObhOzn50SsH6MJyU8QZr3iTmOR2x7JU/ejW8Jv5XeQs2gixxY3nLG813w79jPLEL6KGSGIWb6i1uDyGWXvfB/pMhwuwseJMRrz5A4w/8dxBPffcuXPZsGHDBufc3NfSXl+/9b/OrzrTfx0OTSnH5ZSD9a20hSNDfRnyBhKyCLO8XZwVeCHnAxuAPMIsD2zo19cSsgizvZ2v68NAaoBy6hnnpw1sAH521WKmVBax3Y3lne1f4JnorOQDNCzNv7xeBnyEeh8We+KbzudlJvXv9eS4gDlmuO1Jgc2z0Rn8OryS/e71fWt+efBR/pL/Je7L/zxbC67if/N+kBWBDZA1gQ2gwKYHIYuw4OgDvLD2paG+lOOmYWn9r3MQbU8pseNa/a6nqDWe0ek+YH6AdUQdf2lbQkGaNwOPKCOop9DaCHhGUV4QzzOaAyV0RCGv7Qht4SgADW4YRyghRJgRVk+jG4aHo9y66i9w1BVTTyHxWQ8YjgoaKLGWrmMOuxICRCmzJgKeMb58GMOL8qgLh9jbEiTQepiQRemIRHEOJowoxMzYX9dK0DPGlRcAhhmEI1H2NHkcieQzJthMTbQQr6OFskAb+fl5tIYqGBZt5FBTlD2NUUZYA0ZsTk3QM4J5+ZSNHE9rxMhrO0whrTS2halrCbMvXEQTwyiihTJrotaVdU3WHlcYZZTXwJGm2DUVFJawsSEfw1FpdbS5EEcpJkSYSqsjSIRmG8ZhV8oJEyqoKsunte4gL++v51BbiHJr4KgrppkCimmh1JrwikYSaK+noR2OUEKQCCOtjkY3jEaGdf2ME+XTwQiro84VURyIUF0apN4rZnxeC0TDFB7eSDDaSjhQyAFXRrmrJxAM8aWCz7Gnto5/C91GeYExoW0LAE3BCtaMfyfBA2tZ2LKq5w//w4YTmXMxzevupqTtQNfm3RMvYVXgBE7d9RMqO9KvcN5AIXvcSKo4yI/DF7HWTWGm7WK81XBu4FnGWy0dhNg5+kxGu1qKDq2mZuRSfnV0AZMjr7I0fxfjWjbhEft/2upC/CxyPjvcaD4ZvL1ryFu7V8Bt4/6NAi9MYc1LjGtcx0JvW7friRDgfu9U9rYP47zAKsZbLQcYzp7ieTR0GKFQHpMmT2d9pJr7X9zOxwJ3MME7xF43nF0u9g347MBeSl1ypnR7dDSF1sZoO5p8wuplrA/O4l82zefV6Chm2U7Oz1vNNd69FLhjfzeRQD7zl61M//MHzp4zmrPnjObCHz3Oqj2zuTl8HifnHStEoCpXPtZbYBvsPbjJCwV4ccGXqHzx41TQmBRwv+rG8HJgJktsAyMih3B4bHATyHftTPOS/943RqsZPizA6LZXAXgqOoffh88gz8KM4ghHrJzlS5cyd/cfmXzw73g4InjcN/WL3Nm2CLY/TEnC30OxtTDddhMgyjsC/yBkyV/gRZ2x1k1hjxvBSaGdlNDEEW84j5ZfTOjoNq4I3wlAI8MIO49ya2JHYCJ/CJzPzsYgXw79ilEJf6s1rpTN0SpmB3ZTwbG/7cOumB/mfZDiRZfz0KYavrnvIN8u+CUX8mjXMS2lk3m8fjTPBU7k85Ebu7Y/G1pETeVy5no7qd57LxYN9/h7CBNkgzeNMV4dRwIj2W5VNLdHeKB1NuOthi+EfgvAIVdKBY0ELfZ+WFc4kbqpb+M+t5w7XtjNfwX/lwX2StJzPxBdwp5oBWeF1lHtjv3eOizELSUf5OT2VSxofbbbNXW4QLefe6cmCjgYLWOydyDt/leiY6mhjF3eeCa5vRS7RtYynTHuEKcFkj+Yt7sAv4i8lQ8G7iaQ8oXPLjeKz3e8DwDLK6Ld8jil40kW2jaWeRuTFjQ+4Ibjhg1nTOvWpOeodSWMsIZu17jbjaTRDaPCGtgWjc33WuptJGCOo66I+yJLaaaA08a0M73mwa529W4Y66OT8SzKdjeORWddRmvROMru/QgT4j/fSNkErOkQXjj2f3qvN47Ptl7NaI6wPLCB+RVhpretwwJ5vBqcRN3RI4y2IxxxJRwJDGdkoBkz47n2CTwcPI2r8h/h1Oa/d13DklMHN2vTHzQsrZ/197C0Xs6zfs6cOXOGYlja2294gjW7Ym/UK6aO4Lx5Y7jtud28tKeOEUV5/MtZ07liSXW3yfgAq3ce4bq7N1CUF+TdJ0/g3Llj2F7TxPq9dfz0H9t4taaJK5ZMYGF1GR//w5q05x9ZnE9tUxvOQdAzvnXpAkIB4/QZoygrzGz17NfroZcP8MTWWlbOHs3yqSP6PH7X4Wa+ed9Gahra+dxbZzFzdAm/X7WTglCAyxZXkR8McLC+leFFeQQ847O3r+W253dTWhBk2qhiVsdL804cUcjtH17ByOI8og4C3rGgpCMS5dbndvHwywcJBTzawlHKh4W4cvlETndfSwEAABfbSURBVJxQQWtHhB8+uIWdh5uZMLyQdXvqeGxLDQBXLK7mvPlj2HKggRd31VGUH2BhdTnhiGNUST4rpo7s/rMNt0HDfigdH5t8G42AeThgR20zY8oKYv8HWuth3xoYdxLkxxKWLhrlQM0hth2oY1LwMON23wtHdsQmmy58JxSNjE1uXPtHeOUhmPJmWPy+2OTg1jpYe2ts3sfwKbg/vR9rriEaLIAPPUF7+WR21TRQUTKMl/c18L5fPktbOMpFc0fwjSWNFI2dfawIQCQMgSDOuWM/z4b9sOqnkF9K/czLuXtbmE376xlb0MHFLX9idHgvnPJxGBubNuec484X93LPC68ytbKY8/PWUN26ibLCPJj3DiKj5vLo5oNsO9jA5MAhlpx4AqWF3T8ErttTx1+f30HToVeZOmMu9607QElBkG9fPIv8vc/x3KonGDF+Kie8+e387oUafvnEdq6dtJsLS7eAF4JlH4HC4QDsrG3myVdqaOmI8Nb5Yxndvpvor9+OV7cLN3wqdtYXYe7Fff6/7fxbP9NbzU153+na/sDIqzj72h/12V7egGpfgR+dlH7ff9b12Twaddy7bh8Vw4KcMsbBgXW0FVcRqpyOF/Bif5P1u6GoksMdIQ43tTGmIEzxzodh1c9ozR/B0dO/wZhCB8/+DMaewM6xb+Hjt67hhZ1HmTuulG9fuoB54+NFCBoPwf4XoXwijJwOwNHmdl7cXUddSweFoQDzq8oozAvwyydfpezIOhZENnDUqyB/3tuYPaaQGx/azGO7O7hq+USuWJJmkvX+deCiHCyczkObDvGmKaVUjSzvKoayYeN6zjnwc8oL8zlQdS73dyzkvPnjGF4Y5B9/u5W2vRsoG1XFqBPfyuSqKjzPiEYdOw43M7Y0n4J9q6DxAMx+G3iBY+9X//f52ET7hVfAW78Dgfh7dEcLPH0j7rlfQN0eLPG71gnL4cLroXJGt5fx3KuH+fq9G1kR2MjZk0KEp55DfUM9S2v/QnHpcDjpqq7J+g2tHUSijvJ8D6JhouvvgNIqbNIpsS8zg17svfqv18YmqJ9zHUyKD2c8tBl2PRMb3j7zLRwMjuOetXuoPVLH5UsnMaF1EwyrgKM7YMeTsPBdNEeM0E0rCXXU0zj1AoredTMWboFIB/WBMjwziuPFKaLR2Ot9tbaJ8XlNHDxcR/OGvzGx7lkKlr2frcWLKDi4hqqWl6G0CpproGgU+ytXsOFAEydWV3QVSahtbOOOF/bw/Lb9XO3uosrt42B7PmPO+zTjqqbQ8dwv2fzkX6lvamHLjA+w9LTz+Lfb1+Id2cb35mxhQl4Tf6mbxpe3TKWxLcwlJ47nKxfNZUdtM421uyk+upkn2qexu9GYOaaEdy+dgNd2FNb9Gcqq2Fy0iL+8VMOWg41csbialXNiBQ1amxvZsfoBJs44gYJRk6GjFWo2gXm0VMzihke2sfNwM1evmMSiickZwIMNrWzc18CIojzmjitNW/SotWYHzz1xP4H9a1n+gR8O+hdar3dYmoKbfmZmnwC+D9zmnLs8zf7zgbuBvzjn+v500fN5hiy4uevFvRxsaOO8eWO6qnM559hX18rI4vzXtW5MtLPCDbDlQAMv7DpKJOo4a/Yobn9+N+PLh3HRCeNZv7eOe1/ax7IpIzh1emW/vK5s4pyjtqmd0oIQeUGP7TVNPLv9MOfOG0PZsP4L4F7eX0/Qs25VWXJKzRZ46bZYVaGx3et07DrcTG1TOwuryvqsXPeG1tES+7BRPLp79bceXPaTJ3n21SOc6q3l13nf6tr+QOV7OfujPxioK5VsdmQH/HBB+n0ZBDcDxTnHof/f3p1HSVbVBxz//mZfGDYZkHUGcABFUEQCKIroJETBBBEhiwE8SIwaRVEQlxgWTaIecDkETTQRoidxQcREDC7gKJshgMKBI6tRkUUYcBgEZgF++ePdZmraqu7qobqr+9b3c849r/u+e9+73b/u6vr1fe++h1ezcMHswfo9zxz59/nJJ2HtI00CtvE2sNmiiRtbr628Bx6+u/lH2RSL8aq1T7DysbVs2bJgizp7usmNl6X13vVl2+FfW0/V3zABYxkX7Z4JExFs04NliKe1zEQs2WoBS7Za96b7LS971lMf777NJuy+zSbUKiLWWwp6xy3ms+MWY1zWswu7PbP98sNTyhZL4KD3ddy9/ebz2H7zeRM4oElq5txR74kYbkb5b93aYX8qwsvSBtdI99z0UUQM5hvH0d7kT5sGsxfAov0nZjzjaeOt2y4zPhXMmTm97dUsGh/+heq9K4CHgJ0jYq82+48o229O3JAkaexmTG/eOK1JkxsVkzS5kaQh/oXqscxcA5xdPj07Ip76d3tEnEjzAM/LM/N376iTpElk5vTmT8Sa4ZP8rpY2uExuJE1yvkqNjw8BS4EXAbdFxGXAImBf4AHgDX0cmyR1ZYdyOZ+Xpekp00xsJU1u/oUaB5m5CjgIOIPmeTeHAYuB84C9MvP2zr0laXJ4x9IlLJgzgzWsv4hFhn86BlanmZt9/2pixyFJHThzM04y8zHgg6VI0pSz6bxZXHHKy7n15pvgwnX1LrI5wIbP3GzzAtjjCHj+n/dnPJI0jMmNJKmjjefMZJdthz3LKZ/sz2DUf8NnbnZ9Jez/1v6MRZLa8NoCSdKIZs5cf4ndkZ5+rsoNX0zCSxQlTTK+KkmSRjRr9uz1Po98ok8jUd8NX0zCBQYkTTImN5KkEU135kadOHMjaZLxVUmSNLLp66+W5syNnmJyI2mS8VVJkjSyiPU/TWduVPhAV0mTjMmNJGlMpjlzoyHO3EiaZHxVkiSNSTxpcqNi4S79HoEkrcfkRpI0Jl6WNuAOORNmzIVdD4GdDur3aCRpPT7EU5I0Ji4oMOD2eWNTJGkScuZGkjQmC2b1ewSSJLVnciNJGpNdtpjb7yFIktSWyY0kaUxm77B3v4cgSVJbJjeSpNEd+W8wcz5stw/sfUy/RyNJUlsuKCBJGt1z/rgpkiRNYs7cSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSapCZGa/x6ANEBErZ8+evWDnnXfu91AkSZKknrjjjjtYvXr1w5m58Yb0N7mZoiLiXmAecGefhjCUVd3Rp/Orf4z94DL2g8vYDy5jP7j6FfvtgUcz85kb0tnkRhskIm4CyMzd+z0WTSxjP7iM/eAy9oPL2A+uqRp777mRJEmSVAWTG0mSJElVMLmRJEmSVAWTG0mSJElVMLmRJEmSVAVXS5MkSZJUBWduJEmSJFXB5EaSJElSFUxuJEmSJFXB5EaSJElSFUxuJEmSJFXB5EaSJElSFUxuJEmSJFXB5EZdi4g5EXFaRNwaEasi4u6I+NeI2K7fY1N3ImLviDglIi6IiLsiIiNiVRf9jo6IqyPitxHxYER8KyJeNEqfF5V2D5Z+V0fEMb37atStiJgXEYdFxL9ExA0RsTIiHomI6yPigxGx0Qh9jX0FIuLE8nt/W0Q8FBGrI+IXEXFeROw+Qj/jX5GI2Dwi7iuv/TeP0tbYT3ERsazEulP5ww79pnbsM9NiGbUAc4ArgATuBr4M/E/5/D5g536P0dJVHC8sMWstq0bpc1Zp92jpfzGwFngceE2HPq8p+58ElgHnA78pxzmr39+HQSvAG1vifSPwlRLHlaXup8CWxr7eAiwHHiuv2xeUckuJy2rglca//gKcW2KTwM0jtDP2FZQShyyxOLdN2aPG2Pf9G2+ZGgU4vfyQXgls1FJ/Yqn/Qb/HaOkqju8BTgMOBbZilOQGeHlpsxxY0lK/f3lDtALYbFifzUp9Aoe31G8F3FbqD+r392KQCnA0cE5rDEv91sB1JSb/buzrLcCLgTlt6t9c4nIXMN3411uAV5QY/BMjJDfGvp7CuuRmcZftq4h937/xlslfgJmsy8D3arP/+rJv736P1TLm2I6W3FxU2ryjzb5Pln3vGlZ/Uqm/sE2f15R9/9Xvr93yVEz2H/o5AGYZ+8ErLW9AnmP86yzA3BLnm4AloyQ3xr6SsgHJTRWx954bdeMAYFPgjsz8cZv955ftqyduSBpvETGH5j99sC7GrTrF/dAR+lxE8yZ6aTm++u/6sp0NPAOM/QB6omzXgPGv1N8CO9PM1K3t1MjYD66aYm9yo248r2yv67D/umHtVIfdaN7w3p+Zv2qzfyjuew6r33PY/qdk5hqaez7mALv2aJx6enYq27XAg+VjYz8gIuJomnjcCvysVBv/ikTEnsC7gM9n5g9HaW7s63RcRJwTEWdHxNsjYoc2baqJvcmNujH0S9Duh721vt0vi6auEeOemY9Qrr+NiAUAEbExzSxfx3748zLZnFC2F2fm6vKxsa9URJwUEedGxFcj4kbgPJpFYv4sM58szYx/JSJiGvBZmnid3EUXY1+nD9DM2r2V5vKy2yPib4a1qSb2JjfqxtAysY922P/IsHaqw2hxh9+NfevPgD8vk1xEvAo4jmbWpvUPnbGv18HAMcARwO7AnTSJzbUtbYx/Pd4G/B5wUmY+0EV7Y1+XHwJ/QXNJ4jya2ZP306xsdnpEnNDStprYm9yoG1G2Ocp+1WW0uLe26fR5N33UBxHxbOCLNPE4KTOvb91dtsa+Mpm5NDODZoWjl9IsB70sIt7f0sz4VyAitgc+RLOa6bndditbY1+BzPxgZn4xM3+WmY9l5q2Z+XfAYaXJaRExt3xcTexNbtSNh8t2fof988r2txMwFk2c0eIOvxv7h9vsG62PJlg0D969mOYN7lmZ+clhTYx95TJzRWZeBrwKuBY4IyL2KbuNfx3OAWbRXI7ULWM/ADLzO8A1wCbAfqW6mtib3Kgbvyzb7Trs325YO9VhxLhHxHyaa21XZObDAJm5EnhopH7489JXEbEF8F2a658/D7y7TTNjPyAycy3NQ5mDdasgGf86HEpzqdCny5Pql0XEMuBLZf8OLfVDlwwZ+8FxW9luXbbVxN7kRt0YulzlBR32D9XfMAFj0cS5heahXQvLf/qH6xT3jj8vETETeG457i09Gqe6VG4C/W+aVXEuAI7P8jCCYYz9YFletgvL1vjXY1PgwGFl37JvbkvdjFJn7AfHZmU7NKNSTexNbtSNK2gy850jYq82+48o229O3JA03jLzMeDS8ukRbZp0ivtFI/Q5lGZJyEsyc9XTHqS6FhGzgW8ALwS+DfxpZj7Rrq2xHzgHlu0dYPxrkZnRrgA7lia3tNSvKH2M/QCIiIXAS8qn10FlsZ/IJ4Zapm6huSkxaRKd+S31J5b6y/o9RssGxTWBVSPsX1raLAeWtNTvT/NgroeAzYf12bzUJ3B4S/2WrHsS+iv6/bUPUgGm08zUJM3qOfO66GPsKyk0b2KOAmYMq59Js5rWEzSXL21v/OsvwOISi5s77Df2FRSae2kOAqJN/C8vMflGjbGPMgBpROXJsstoprPvAS4DFpXPHwD2y8zb+zZAdSUiDmH9JX/3pXnhubql7ozMvKilzydonoXyKM29GrOA36eZ+T0yM7/W5jyvBb5Ccx3/D2heKJfSXCLxqcw8YXgfjZ+y3OcnyqdfB1Z2aPruzBy6RMnYVyIijqW5v2o5zeIBDwBbAHvQXG+/CjgmM78yrJ/xr1BELAb+j2bmZrcObYz9FNfye38PzUN676W5/2VvmtmUm4CXZ+Z9w/pN/dj3O7O0TJ1Cc33u6cDtNNdP3gucS8t/+yyTuwDH0iQzI5VjO/S7hma9+hU0K20dMMq5Xkxzf8dvSr9rgDf0+3swiAU4tYu4J7DY2NdXaC5D+jDNf2vvBtbQXGd/I/Ap4Fkj9DX+lRVGmbkx9nUU4Nk0K+ZdC9xH8zyzFcBVNFfdzK019s7cSJIkSaqCCwpIkiRJqoLJjSRJkqQqmNxIkiRJqoLJjSRJkqQqmNxIkiRJqoLJjSRJkqQqmNxIkiRJqoLJjSRJkqQqmNxIkiRJqoLJjSRJkqQqmNxIkiRJqoLJjSRpXETE/Ih4Z0R8PyJ+HRFrIuI3EXFVRJweETsMa39qRGREHDvB4zy3nPdlE3CuZeVci5/GMSZsvJI01czo9wAkSfWJiP2AC4CtgUeBHwG/BjYB9gH2A06OiEMz83t9G2iPRUQCv8jMxf0eiyQNIpMbSVJPRcSewKXAXOAjwBmZ+UjL/mnAYcBHge36Msj+ORqYB9zV74FIUo1MbiRJPRMRAXyRJrE5NTNPG94mM58ELoiIS4DtJ3iIfZWZv+z3GCSpZt5zI0nqpYOBPYBfAR8eqWFmPpSZN3Zz0Ih4RkR8LCJui4hVEfFgRFwcEX8wQp8tIuLvI+LGiHgkIlZExE8i4sMR8YwuzjkrIs4v97d8NSJmjdD22HJJGsCi0meoLGtp1/Gem/Eab0TMjIg3RcTVEbE8Ih6NiJ9HxDcj4k9GO64kTSXO3EiSeumQsv1qZj7eiwNGxLbAD4GdgF8CFwILgaXAwRFxYmZ+fFif5wDfAbYF7gEuBqYDuwLvA74LLBvhnBsBXy/n+BzwpjLj1MntwHnAMcAjwPkt+27u4mscz/F+ATgKWA5cSXMP1LbAS4CNgC+NNj5JmipMbiRJvbRX2V7Xw2N+hiax+QJwXGauBYiIA4BvAx+LiEsy84ZSPwP4Gs0b+DOB9w71Kfv3Au7vdLKI2Bz4FrAv8NHMfM9oA8zMy4HLI+IYYHlmHtvtFzee4y0zREcB/wu8NDNXteybCzy/23FK0lTgZWmSpF4aunyq45vxsYiInYBDgZXA21vf9JeE4jM0Mxxvael2OLAbcANwcmuf0u/HmfmrDufbFriMJlE4pZvEpgfGc7xblu2VrYlNOe5jmXlVL74ASZosTG4kSb0UPT7eAWX7rcxc0Wb/F8r2JS11S8v2s6NcSjbcEuAKmkTjLzPzI2Ma6YYbz/HeTHOZ3Bsi4vhu7t2RpKnM5EaS1EvLy3Zhj463Tdn+vMP+ofptWuqGVmC7Y4znOgdYRHNZ2GfH2PfpGLfxZuZK4Hiav/f/DNwfET+NiHPKs4gkqSomN5KkXvpJ2b6gx8fNUerb7e/Up5Mvlz7vjIhdx9i3F8ZlvJn5HzT3LB1Ps9DB5sCbgasi4qMbOFZJmpRMbiRJvXRR2b6u3Cj/dN1dtjt22L+4bO9pqbuzbJ81xnN9Dngr8Ezg+xGxyxj7b6hxH29m3p+Zn8vMI0v7V9Lcx3RSWalNkqpgciNJ6qWLgZuA7YD3j9QwIjaOiN1HOd7lZXtIRGzaZv/ry/aylrrvle0by0NFu5aZnwb+GtgauDQixppwrGXsK5FO6HizcTHrEtHnjuWckjSZmdxIknomM5Mm4VgFnFoeSjm/tU00/gi4BthnlOP9jOZN+ALgkxExs+U4+9NcXvUEzf0nQy4AbgWeB/zD8BmkiHh+RGw3wjn/ETiBZmnmS8uKbd26G9iqQyLWybiNNyL2iojDW79vpX4zmhXWoHl2kCRVwefcSJJ6KjN/EhFLaZ7dcgrw9oi4Cvg1sAnwQmArmgTozo4HWudNNDMzRwMHlmMtBF5Gswz0u4aecVPO/3hEvJbmwZcnA6+PiCtp/ubtCjwbOAhou7xyOcanImIa8HGahOHAzPxFF2P9T+BtwHXlnKuAWzLzYyOcazzHu4gmDg9FxDXAvcCmNKvLbQx8PTN/1MXXJUlTgjM3kqSey8wraO4heTfNAyT3BI4EXkyzwtlpwJLMvKSLY91FM8NzJvA4zXNh9gYuAQ7OzLPa9LmR5gGVZ9Ishfxq4EBgNfAhmmfKjHbeT5TxL6K5p2WH0foA7wXOpklMjgKOAw7p4lzjNd4fAR8ArqVJlF5Hk1zeABxDExNJqkY0VxBIkiRJ0tTmzI0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSaqCyY0kSZKkKpjcSJIkSarC/wMZ2Pr4Pf5GewAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from numpy.fft import fft, fftshift\n",
    "\n",
    "# Plot results.\n",
    "plt.figure(1,dpi=150)\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()\n",
    "\n",
    "# Phase.\n",
    "i0 = 220\n",
    "i1 = 280\n",
    "iMean = iq[0][i0:i1].mean()\n",
    "qMean = iq[1][i0:i1].mean()\n",
    "ai = np.abs(iMean + 1j*qMean)\n",
    "fi = np.angle(iMean + 1j*qMean)\n",
    "print(\"Phase: {}\".format(fi))\n",
    "\n",
    "fs = soc.adcs['20']['fs']/4\n",
    "x = iq[0] + 1j*iq[1]\n",
    "w = np.hanning(len(x))\n",
    "xw = x*w\n",
    "F = (np.arange(len(x))/len(x)-0.5)*fs\n",
    "Y = fftshift(fft(xw))\n",
    "Y = 20*np.log10(abs(Y))\n",
    "\n",
    "[F1,Y1] = findPeak(F,Y);\n",
    "\n",
    "plt.figure(2,dpi=150)\n",
    "plt.plot(F,Y)\n",
    "plt.plot(F1,Y1,'r*');\n",
    "plt.title(\"Spectrum\");\n",
    "plt.xlabel(\"F [MHz]\");\n",
    "\n",
    "print(\"F1: {:.3f}, Y1: {:.3f}\".format(F1,Y1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5f87954e8254b8dbc79238c9cc88019",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1 [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 SingleGenLoopbackProgram(AveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg = self.cfg\n",
    "        style = cfg['style']\n",
    "        \n",
    "        for iCh, ch in enumerate([cfg[\"res_ch\"]]):  # configure the readout lengths and downconversion frequencies\n",
    "            length_gen = self.us2cycles(cfg['length'], gen_ch=ch)\n",
    "            self.declare_gen(ch=ch, nqz=1, ro_ch=cfg[\"ro_ch\"])\n",
    "            self.default_pulse_registers(ch=ch, \n",
    "                         freq=self.freq2reg(cfg[\"pulse_freq\"],gen_ch=ch,ro_ch=cfg[\"ro_ch\"]),\n",
    "                         gain=cfg['pulse_gain'],\n",
    "                         phase=0)\n",
    "            if style == \"const\":\n",
    "                self.set_pulse_registers(ch=ch, style=style, length=length_gen)\n",
    "            elif style == \"arb\":\n",
    "                self.add_gauss(ch=ch, name=\"measure\", sigma=length_gen/5, length=length_gen)\n",
    "                self.set_pulse_registers(ch=ch, style=style, waveform=\"measure\")\n",
    "            elif style == \"flat_top\":\n",
    "                self.add_gauss(ch=ch, name=\"measure\", sigma=length_gen/25, length=int(0.2*length_gen))\n",
    "                self.set_pulse_registers(ch=ch, style=style, waveform=\"measure\", length=int(0.8*length_gen))\n",
    "\n",
    "        for iCh, ch in enumerate([cfg[\"ro_ch\"]]):  # configure the readout lengths and downconversion frequencies\n",
    "            length_ro = soccfg.us2cycles(cfg['length']+cfg['readout_padding'], ro_ch=ch)\n",
    "            self.declare_readout(ch=ch, length=length_ro)\n",
    "            freq_ro = self.freq2reg_adc(cfg[\"pulse_freq\"],ro_ch=ch,gen_ch=cfg['res_ch'])\n",
    "            self.set_readout_registers(ch=ch, freq=freq_ro, length=5)\n",
    "\n",
    "\n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "\n",
    "    def body(self):\n",
    "#         # Configure readout v3.\n",
    "        for ch in [self.cfg[\"ro_ch\"]]:\n",
    "            if self.soccfg['readouts'][ch]['tproc_ctrl'] is not None:\n",
    "                self.readout(ch=ch, t=0)\n",
    "                \n",
    "        self.measure(pulse_ch=self.cfg[\"res_ch\"],\n",
    "                     t=0,\n",
    "                     adcs=self.ro_chs,\n",
    "                     pins=[0], \n",
    "                     adc_trig_offset=self.us2cycles(self.cfg[\"adc_trig_offset\"]-0.5*self.cfg['readout_padding']),\n",
    "                     wait=True,\n",
    "                     syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n",
    "\n",
    "config={\"res_ch\":0, # --Fixed\n",
    "        \"ro_ch\":0, # --Fixed\n",
    "        'adc_trig_offset': 0.33,\n",
    "        'readout_padding': 0.2,\n",
    "        'relax_delay': 1,\n",
    "        \"pulse_gain\":3000, # [DAC units]\n",
    "        \"pulse_freq\": 500, # [MHz]\n",
    "#         'style': 'arb',\n",
    "        'style': 'const',\n",
    "#         'style': 'flat_top',\n",
    "        'length': 1, # [us]\n",
    "        'reps': 1,\n",
    "        'soft_avgs': 1\n",
    "       }\n",
    "\n",
    "# config['readout_padding'] = 0.1\n",
    "prog = SingleGenLoopbackProgram(soccfg, config)\n",
    "# print(prog)\n",
    "\n",
    "iq_list = prog.acquire_decimated(soc, progress=True)\n",
    "# Plot results.\n",
    "def plot_decimated(iq_list, soccfg, config, plot_iq=True):\n",
    "#     fig, axs = plt.subplots(2,1,figsize=(10,10))\n",
    "    t = soccfg.cycles2us(np.arange(len(iq_list[0][0])), ro_ch=config['ro_ch'])\n",
    "\n",
    "    for ii, iq in enumerate(iq_list):\n",
    "#         plot = axs[ii]\n",
    "        if plot_iq:\n",
    "            plt.plot(t, iq[0], label=\"I value, ADC %d\"%(config['ro_ch']))\n",
    "            plt.plot(t, iq[1], label=\"Q value, ADC %d\"%(config['ro_ch']))\n",
    "            plt.plot(t, np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_ch']))\n",
    "        else:\n",
    "            plt.plot(t, iq[0], label=\"input value, ADC %d\"%(config['ro_ch']))\n",
    "        plt.ylabel(\"a.u.\")\n",
    "        plt.xlabel(\"Time [us]\")\n",
    "        plt.title(\"Averages = \" + str(config[\"soft_avgs\"]))\n",
    "        plt.legend()\n",
    "plot_decimated(iq_list, soccfg, config, plot_iq=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cab742f87389497a8c044336acbf47c6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/40100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xffff732f95e0>]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD4CAYAAAAHHSreAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3dd3iV9f3/8ec7J5OQBEIYgQCBsIcMw3YgoqIibkWpG60oFmtba7+2rrZff9rWr9W6wD2QqlRBHEhRsCigbAgjhB1GwkpYIZDk8/sjRxtJAgkkuU9OXo/rysU597nPfV65Lw4v7vW5zTmHiIhISSFeBxARkcCjchARkVJUDiIiUorKQURESlE5iIhIKaFeB6gqCQkJLjk52esYIiK1ysKFC3c55xofOz1oyiE5OZkFCxZ4HUNEpFYxs01lTdduJRERKUXlICIipagcRESkFJWDiIiUonIQEZFSVA4iIlKKykFEREqp8+WwdEsOz8/KoLBIQ5eLiPygzpfDJ8u38+Tna7h+wjx25B72Oo6ISECo8+Xwuws78dere7Biay4j/jGHZZk5XkcSEfFcnS8HM+Oq05P4112DCPOFcM1Lc/ls+XavY4mIeKrOl8MPOjaLYcrYQXRJjOXuiYt4b8EWryOJiHhG5VBCQv0I3h7dj0HtErj/g2W8NXej15FERDyhcjhGvfBQXr4plaGdm/CHKWm8MmeD15FERGqcyqEMEaE+nh91OsO6NuOP01by5OerKSgs8jqWiEiNUTmUIzw0hGev78W1qS15ftY6rn5pLiu25nodS0SkRqgcjiPMF8ITV53G30f2ZOOugwx/dg5XvvAt/1qUyeGjhV7HExGpNuZccFwZnJqa6qrzTnC5eUd5f8EWJs7fzPpdB2lQL4yrT0/i+n6taZMQXW2fKyJSncxsoXMutdR0lUPlOOeYu24378zfzPS0HRQUOYZ0asKfLutG8wZR1f75IiJVSeVQDbL3H+af323hxdnriAr3MeHGVHq1alijGURETkV55RDQxxzMrLOZvWhmH5jZGK/zHKtJTCT3nNueKWPPoF54KCPHz9PV1SISFCpcDmbmM7PFZjbtZD/MzF41s2wzW1HGa8PMbI2ZZZjZAwDOuVXOuTuBa4BSzRYo2jWpz4d3DaRr81jGvLOIp75YQ94RHbAWkdqrMlsO44BVZb1gZk3MLOaYae3KmPV1YFgZ7/cBzwEXAl2A68ysi/+1EcAcYGYlsta4RvUjmHh7f67o3YJnvsxgyN9mMXlhJkUaClxEaqEKlYOZJQEXAy+XM8vZwBQzi/TPfzvwzLEzOee+BvaU8f6+QIZzbr1z7ggwCbjU/56pzrmBwKhysl1iZuNzc72/BiEyzMdT1/TkvZ8PoHFMBL96fymXPvcNyzO9zyYiUhkV3XJ4GrgfKPMyYefc+8DnwCQzGwXcSvGuoIpqAZQc6S4TaGFmg83sGTN7Cfi0nM/+2Dl3R1xcXCU+rnr1bRPPR3cN4ulre7Jzfz5XvvAt//x+s9exREQqLPREM5jZcCDbObfQzAaXN59z7kkzmwS8AKQ45w5UIoeVvUg3C5hVieUEjJAQ47JeLTirQ2N+8e5ifjt5Ocsyc3n4kq6Ehwb0eQAiIhXachgEjDCzjRTv7hliZm8fO5OZnQl0Az4EHq5kjkygZYnnScC2Si4jIMVHh/PGrX35+dlteWf+Zq5+8Vu+Tt+pYxEiEtAqdZ2Df8vh18654cdM7wW8S/FxiQ3A28B659zvy1hGMjDNOdetxLRQIB04F9gKfA9c75xLq2g2L65zqKzPlm/n9x+tYPfBIyTUj2BgSiMGpjTizA6NaaEL6ETEA+Vd53DC3UoVVA+42jm3zv9hNwE3lxHiXWAwkGBmmcDDzrlXnHMFZjYWmA74gFcrUwy1xYXdExnSuQkzVmYxY2UW367bzdSlxRtIw7o248GLO9Myvp7HKUVEdIW0p5xzZGQf4OOl25jwnw0UOcez1/Xi/K7NvI4mInVErbxCOtiZGe2bxnDf+R358tdn0ymx+CK6KUu2eh1NROo4lUOASIyL4p3R/Uht3ZD73lvKv1dmeR1JROowlUMAqR8Ryis396Fb81junriI+et3ex1JROoolUOAqR8Rymu39KVlfD1Gv7FAd58TEU+oHAJQfHQ4b93Wl9ioMK544Vt+8/5SPl2+nY27DhIsJxCISGCrqlNZpYolxkXx4V0D+cv0NXyetoP3F2YC0DYhmhsGtOb6fq2ICPV5nFJEgpVOZa0FjhYWkbZtHyu25vKvRZks2pxDcqN6/GF4F4Z0aoJZWaOPiIicmO4EF0Rmp+/k0Y/TWL/zID1aNuDi7s0Y2rkpbRvX9zqaiNQyKocgc7SwiEnfb+GdeZtYvWM/ACmNo7llUBuuOj2JyDDtchKRE1M5BLHMvYf4cnU2kxdtZemWHJrERPDQJV0Yflpzr6OJSIDTFdJBLKlhPW4ckMxHdw3kndH9SIyLZOzExTwzc63X0USkllI5BBEzY1C7BD4YM5ArerXgqRnpzNCV1iJyElQOQSjMF8LjV3anS2IsD0xexs79+V5HEpFaRuUQpCJCfTw9sif78wt4bNpKr+OISC2jcghiHZrGcOfZKXy8dBvfbdjjdRwRqUVUDkFuzNkpNI+L5OGpaRwpKPI6jojUEiqHIBcV7uPhEV1ZtX0fj01LwzlHYZFj8sJM7nxrIde8OJfHPl5J5t5DXkcVkQCisZXqgAu6NuPnZ7flpdnrWbIlh70Hj7I1J4+khlEkxkXy1ryNvDl3I5f3asG4oe1JaqhblYrUdSqHOuKBYZ1oFhvJtGXb6ZwYxR+Gd+aCrs0wM7bl5DHhP+uZOH8zU5Zs48YBrbn7nHY0jA73OraIeERXSMuPtufm8X8z0vlgYSbREaGMPacdt57RhjCf9j6KBCtdIS0nlBgXxZNX9eCzcWfRJzmexz9bzSXPzmHR5r1eRxORGqZykFI6Novh1Zv7MOHGVHIOHeXKF77l4Skr2H/4qNfRRKSGqBykXOd1acqM+87ipgHJvDlvE9e+NI/DRwu9jiUiNUDlIMcVExnGIyO6MuGGVFZu36errUXqCJWDVMjQLk0ZMziFifM380XaDq/jiEg1C+hyMLPOZvaimX1gZmO8zlPX3XdeBzo2jeHRj1eSd0S7l0SC2QnLwcwizew7M1tqZmlm9ujJfpiZvWpm2Wa2oozXhpnZGjPLMLMHAJxzq5xzdwLXAKVOtZKaFeYL4bFLu7I1J49nv9S9IkSCWUW2HPKBIc65HkBPYJiZ9S85g5k1MbOYY6a1K2NZrwPDjp1oZj7gOeBCoAtwnZl18b82ApgDzKxAVqlm/do24sreSbw4ex1z1+3+yWsH8ws0PLhIkDjhFdKu+Cq5A/6nYf6fY6+cOxsYY2YXOecOm9ntwOXARccs62szSy7jY/oCGc659QBmNgm4FFjpnJsKTDWzT4CJFf3FpPo8MqILi7fs5fY3F3DTwNbkHSliwaY9pG3bR2GRo0fLBow5u+2PV2CLSO1ToWMOZuYzsyVANjDDOTe/5OvOufeBz4FJZjYKuJXiXUEV1QLYUuJ5JtDCzAab2TNm9hLwaTnZLjGz8bm5uZX4ODkVMZFhTBzdn9OS4njuq3VM/G4T9cJ93DU4hQcu7ETOoSPc+fYifjFpCQfzC7yOKyInoVLDZ5hZA+BD4B7nXFnHDSZRvLWQ4pzbWc4ykoFpzrluJaZdDVzgnBvtf34D0Nc5d09Fs2n4DG8cKSgixCC0xBAbhUWOF2ev429frKFNQjQv/ux02jeNOc5SRMQrVTJ8hnMuB5hF2ccNzgS6UVweD1cyXybQssTzJGBbJZchHggPDflJMQD4Qoy7z2nH26P7kZt3lEuf+4YpS7Z6lFBETkZFzlZq7N9iwMyigKHA6mPm6QVMoPg4wS1AvJn9qRI5vgfam1kbMwsHRgJTK/F+CUADUxL45Bdn0rV5LOMmLeHeSYtZvHkvwTLYo0gwq8iWQyLwlZkto/gf8RnOuWnHzFMPuNo5t845VwTcBGw6dkFm9i4wF+hoZplmdhuAc64AGAtMB1YB7znn0k72l5LA0TQ2kom39+fuc1L4PG0Hlz//LWf95Ste+2aDSkIkgGnIbqkxuXlH+SJtB+8vzOS7DXv45dAOjBva3utYInWahuwWz8VFhXF1aksm3d6fK3q14O8z01m4ScOBiwQilYPUuJAQ47HLutE4JoI/Tlup3UsiAUjlIJ6oHxHKfed1YMmWHGatKfOsZxHxkMpBPHN5rySax0Xywqx1XkcRkWOoHMQz4aEhjD6zLd9t3MOCjXu8jiMiJagcxFMj+7YkPjqcv32R/pNjD845pqft4JU5G1i4SddGiNS0Ew68J1Kd6oWHMu7c9jw8NY2Plmzl8l5JfLdhD3/+dBVLt+T8OF+Plg34x3W9aBlfz8O0InWHrnMQzx0tLGLUhPks2ryXlMb1WZO1n2axkfzq/A6c3bExM1dl8/inq/CFGM9d35uB7RK8jiwSNMq7zkHlIAEh59ARnpmZwZqsfQxMSeDWQW2ICvf9+PqGXQe5480FrN91kEcu6cINA5K9CysSRFQOUusdyC9g3LuLmbk6m1sHteHBizvjC9H9IkROha6QllqvfkQo429M5dZBbXj1mw0MfWo2L8xaR3rWfh2wFqli2nKQWunT5dt5dc4GFviH30iMi+SX53XgmtSWJ3iniJRU3paDzlaSWumi7olc1D2RrTl5zFm7k/cXZHL/B8s4mF/ALYPaeB1PpNbTbiWp1Vo0iOLaPq34588HcH6Xpvz5k1Ws3rHP61gitZ7KQYKCL8R44srTiIsK47eTl1NYFBy7S0W8onKQoNEwOpyHLunC0i05vDV3o9dxRGo1lYMElRE9mnNWh8b89Yt0svYd9jqOSK2lcpCgYmb88dKuHCks4qEpK3SKq8hJUjlI0GndKJpfn9+B6WlZ/L/PV3sdR6RW0qmsEpRuP7Mtm/cc4qXZ68k9dJTfXdSZuKgwr2OJ1BoqBwlKZsajI7oRHRHKhK/X8+XqbB67tBvDujXzOppIraDdShK0fCHG7y7szJS7z6BR/QjufHshD09ZQZFOcxU5IZWDBL3uSXFMHTuI285owxtzN3H/5GUqCJET0G4lqRPCfCH8/uLOxESG8vS/19IgKozfD+/idSyRgKVykDrDzBh3bntyDh3l5TkbaBYXyegz2/5knhVbc3n2y7UcOlLIFb1bcHmvJI/SinhL5SB1ipnxh+FdyN5/mD99sooG9cK56vQknHO8M38zj328kugIH/HR4fzyn0s5dKSQUf1aex1bpMapHKTO8YUYT13Tk315C/j1+0uZsmQr+w8XsGRLDme2T+DZ63pRPyKU0W8u4NGPV5LaOp6OzWK8ji1So3RAWuqkyDAfL9+Uyi+HdmBbTh77Dh/l8Su68+atfWlQL5xQXwh/vboHsZGhjJu0mPyCQq8ji9Qo3exH5DhmrsritjcWcN95HfjFue29jiNS5XSbUJGTcG7npgw/LZFnZq7l6/SdXscRqTEqB5ETePyK7rRvGsOYtxeyePNer+OI1AiVg8gJxESG8fotfWhUP4LrJszjjW83arRXCXoqB5EKaBobyeQxA+nbphEPT03jwY9WUFBY5HUskWqjchCpoMYxEbx+cx/GDE5h4vzN/PythRw+qrOYJDipHEQqISTE+O2wTvzxsm7MXJ3Nnz9Z5XUkkWqhi+BETsIN/VuzefdBJvxnA4PaNWJYt0SvI4lUKW05iJyk31zQie4t4nhoSpp2L0nQUTmInKTw0BAevLgz2fvzeWf+Zq/jiFQplYPIKejfthEDUxrxwqwMDh0p8DqOSJVROYicovvO68CuA0d4a+6mE85bqJsMSS2hchA5RanJ8ZzVoTEvzl5X7tbDxl0HufalubR/8FOunzCPrH2HazilSOUEdDmYWWcze9HMPjCzMV7nESnPL4a0Y++ho0xetLXUazmHjnDt+LmsydrPjQOSWbolhxH/mMPqHfs8SCpSMScsBzNraWZfmdkqM0szs3En+2Fm9qqZZZvZijJeG2Zma8wsw8weAHDOrXLO3QlcA5QaNVAkUJzeuiE9WjZg/NfrSp259NCUNHYfOMLbt/XjkRFdmXzXQABue30Bew4e8SKuyAlVZMuhAPiVc64z0B+428x+cvNdM2tiZjHHTGtXxrJeB4YdO9HMfMBzwIVAF+C6Hz7DzEYAc4CZFcgq4gkz4/4LOrJlTx6vzNnw4/Rpy7Yxdek2xp3bnm4t4gDo1CyWCTemsvNAPmMnLtIwHBKQTlgOzrntzrlF/sf7gVVAi2NmOxuYYmaRAGZ2O/BMGcv6GthTxsf0BTKcc+udc0eAScCl/vdMdc4NBEaVlc/MLjGz8bm5uSf6VUSq1aB2CZzfpSnPfZXB1pw8Mvce4vcfraBHywaMGZzyk3lPS2rA/17enW/X7ebxz1Z7lFikfJU65mBmyUAvYH7J6c6594HPgUlmNgq4leJdQRXVAthS4nkm0MLMBpvZM2b2EvBpWW90zn3snLsjLi6uEh8nUj0evLgzIWZc8uwcLnvuWwqLHE9f25NQX+mv2lWnJ3HzwGRembOBfy3K9CCtSPkqPHyGmdUHJgP3OudKHUlzzj1pZpOAF4AU59yBSuSwMqY559wsYFYlliPiqdaNonl7dD/+/u90fCEh3HVOCm0Sosud/8GLO7Nq+z5+96/ldGkeS6dmsTWYVqR8FdpyMLMwiovhHefcv8qZ50ygG/Ah8HAlc2QCLUs8TwK2VXIZIgGhZ8sGvHZLX16+KZXerRoed94wXwjPjepN/YhQ7v9gmY4/SMCoyNlKBrwCrHLOPVXOPL2ACRQfJ7gFiDezP1Uix/dAezNrY2bhwEhgaiXeL1JrJdSP4NFLu7IsM/cnB7NFvFSRLYdBwA3AEDNb4v+56Jh56gFXO+fWOeeKgJuAUpeLmtm7wFygo5llmtltAM65AmAsMJ3iA97vOefSTvq3EqllLu6eyHldmvLUjHTW76zMHlmR6mHBcrvD1NRUt2DBAq9jiJy0rH2HGfrUbPomx/PKzX28jiN1hJktdM6Vuo4soK+QFqlLmsZGMmZwCjNXZ7NgY1lnfIvUHJWDSAC5ZWAbmsRE8MTnqwmWrXqpnVQOIgEkKtzHPee25/uNe5m1ZqfXcaQOUzmIBJiRfVrSulE9nvh8NUXHGeJ73+GjLN68l4P5uo+EVD3dQ1okwIT5QrjvvA6Mm7SEKUu3cnmvpJ+8Xljk+PvMtbw2ZwP78wuoHxHKtX1a8svzOlA/Ql9pqRrachAJQJec1pzTkuL407RV7DqQ/+P0gsIi7ntvCc/MXMuZHRJ49rpeDO3chNe+2cCoCfPYq1FepYqoHEQCUEiI8dere7A/v4AHJi+jsMhxML+AMe8sYsqSbfzmgo48P+p0LunRnKdH9uKlG1JZtWM/V780l+25eV7HlyCg6xxEAtgrczbwx2kr6dQshoNHCti6N4+Hhnfh5kFtSs07b/1uRr+xgMS4SD64cyBx9cI8SCy1ja5zEKmFbh2UzP9d24PoiFCaxkTyxq19yywGgP5tGzH+xtPZuPsgd7y1gPyCwjLnE6kIbTmIBJkpS7YybtISLunRnL9f25OQkLIGPRYpVt6Wg05tEAkyl/Zswbacwzzx+WpSGkdz79AOXkeSWki7lUSC0J1nt+WKXi149ssMlmfqLolSeSoHkSBkZjxyaVca1gvjj9NWaigOqTSVg0iQio0M496hHfhu4x6+WJnldRypZVQOIkFsZJ+WpDSO5skTDMUhciyVg0gQC/WFcM+Q9qzbeZCv12ogP6k4lYNIkLuoeyKNYyJ47ZuNXkeRWkTlIBLkwkND+Fm/1sxO30lGtm5BKhWjchCpA67v14pwXwhvzt3odRSpJVQOInVA45gILunRnA8WZpKbd7Tc+ZxzfL9xD5MXZjI7fSf7D5c/rwQ3XSEtUkfcMiiZyYsyeX/BFkaf2bbU62uz9vP7j1Ywf8N/718dFxXG7We24aaBycREaiC/ukRbDiJ1RLcWcfRNjue1bzZy+OhPB+Vbs2M/V704l/Ss/fzxsm58+auzefu2fqS2bshfv0jnzCe/4rmvMkq9T4KXykGkDrn3vPZszcnjxdnrfpyWti2X6ybMIzIshKljz+CG/q1p27g+Z7RP4JWb+zB17CB6t2rIX6avYfizc0jbpuE46gKVg0gdMjAlgRE9mvOPLzOYnraDbzJ2cd34eUSGhvDPOwbQMr5eqfecltSAV2/uw5u39mVf3lEue+4b3vt+iwfppSZpyG6ROib30FGufulb0rOKT2ttGR/FxNH9yyyGY+05eIRxkxbzTcYuXr+lL2d1aFzdcaWalTdkt8pBpA46mF/AZyt2EOYzBndsQlxUxQ82H8wv4MoXvmXr3jw+u/dMkhqeuFQkcOlOcCLyo+iIUK46PYlLe7aoVDH88N4JN6ZSUOR49OOV1ZRQvKZyEJFKaxlfj7FD2jFjZRYLN+31Oo5UA5WDiJyUWwYl0yg6nKf/ne51FKkGKgcROSn1wkO58+wU/rN2F99v3HPiN0itonIQkZP2s/6tSagfwf/N0NZDsFE5iMhJiwr3MWZwCt+u28289bu9jiNVSOUgIqdkVL9WNImJ4KkZ6bpXdRBROYjIKYkM83H3Oe34bsMe5q7T1kOwUDmIyCm7tk9LmsVGaushiKgcROSURYb5uHtIOxZs2svsdN2rOhioHESkSlyTmkRyo3o8+OEK9lXwJkHOObbn5pG17zBHCoqqOaFUhm72IyJVIiLUx1PX9uTqF+fyh49W8PS1PTGzMufdfSCft+Zt4oOFmWTuzQOKbyx0z5B23DCgNRGhvpqMLmVQOYhIlendqiHjzm3PUzPSaRQdwf9c1IlQ3393UBw+Wshbczfx/KwMcvOO0ic5np+f1RYzY3raDv70ySremreJl29MpX3TGA9/E1E5iEiVumdIO/YcPMKr32wgbVsu1/drRXx0OF+n7+STZdvZlnuYM9ol8IfhXejY7L8F8LP+rZmdvpPfvL+U6ybMZ9Id/WjXRAXhFQ3ZLSLVYvLCTB6Zmsb+/AIAwn0hpCY3ZOw57RjYLqHc92VkH2Dk+HlEhYfw2bizqB+h/8NWJ93PQURqXEFhEWuzD7D30BG6JsYRV69iw4N/t2EP146fy8g+rXj8iu7VnLJu0/0cRKTGhfpC6JwYy8CUhAoXA0DfNvHccWZb3v1uM1+tzq7GhFIelYOIBKRfnteBjk1juH/yMg74d01JzVE5iEhAigzz8f+u7M7O/fm88p8NXsepc1QOIhKwerVqyEXdm/HC7Aw27T7odZw6ReUgIgHtoeFdCQsJ4YHJyzVuUw1SOYhIQGsWF8n/XNyZuet3M+n7LV7HqTNUDiIS8Eb2acmAto34309WsSP3sNdx6gSVg4gEPDPj8Su6c7SoiAc/1O6lmqByEJFaITkhmt9c0ImZq7N5ZY7OXqpuui5dRGqNWwYmM3/9bv70ySoOHy3k7nPalTvyq5walYOI1BohIcZzo3rz2w+W8dcv0lm+NZdR/VozMKURob4Q8gsKSd9xgK/X7iQ9az9rsw4QHx3OuZ2bcOXpScRGVvwq7bpOYyuJSK1TVOT4x1cZTPh6PfvzC4iJDKVJTASZe/PI9980qEWDKNo2jiZr32HSsw7QOTGWiaP70TA63OP0gUUD74lI0Dl8tJBZa3YyJ2Mnuw8coWlsJH2S4+nVqgHNG0T9ON9Xa7L5+VsLad+kPh/cOZCocN1M6AcqBxGp075cncWtry/g5oHJPDKiq9dxAoZGZRWROm1Ip6bcOKA1b87dyNqs/V7HCXgqBxGpM+4d2oHo8FCe+HyN11ECnspBROqM+Ohw7hycwr9XZTF//W6v4wQ0lYOI1Cm3DmpDs9hIHv9sta60Pg6Vg4jUKVHhPu47rwNLtuTw2YodXscJWCoHEalzrjw9iQ5N6/Pk56s54r8uQn5K5SAidY4vxHjgwk5s3H2Id+Zv8jpOQFI5iEiddE7HJpzRLoGnvkgv8y5zzjlyDh2ps8cldBGciNRZm3YfZPizc8DBfed3IDYyjE27D/KfjF2szTrAgfwCosN9tIyvx/DTEhmQkkDvVg0oLHLs2HeYzL15NImJILlRNCEhtXMAQF0hLSJShi17DnHfe0v4fuPeH6eltm5ItxZxJMZFsmPfYdK27eO7DXsAiArzkXe08CfLSGoYxeu39KVdk/o1mr0qqBxERMrhnGPdzoOYQXy98DIH59uem8fcdbtJ27aP6IhQYiND6dA0hu25efxl+hoiQn18MGYAiXFRZXxC4FI5iIhUkxVbcxk5fh7dW8Qx8fZ+teoeExpbSUSkmnRrEcdvLujI3PW7+WpNdpUuOzfvKLl5R6t0mRWhchARqQLX9W1FcqN6PP7pagoKq+baiQ8XZzLg8Zn0+fO/ebWGb42qchARqQLhoSH8dlgn1mYf4L0Fmae8vC9XZ/Gr95bSqVkM/drE89i0lXy5OqsKklaMykFEpIoM69aMvsnx/O2LNew7fPK7gjL3HuKX/1xKp2axvDO6P6/e3IfWjerx1+npNXbdhcpBRKSKmBl/GN6FPYeO8NyXGSe1jCMFRYyduJjCIsfzo3oTFe4jzBfCXYNTWLl9Hws27T3xQqqAykFEpAp1T4rjyt5JvPrNBjbuKn3l9Yk88flqlmzJ4cmrTiM5IfrH6Zf0aE5MRCjvzt9clXHLpXIQEaliv7mgI5GhPn4xaTGHj7lg7nimp+3glTkbuGlAay7qnviT1+qFh3Jpr+Z8snw7uYeq/+wllYOISBVrGhvJ367pwbLMXB6YvKxCBbFiay6/fn8ppyXF8T8Xdy5znpF9WpFfUMRHS7ZWdeRSArIczKyzmb1oZh+Y2Riv84iIVNb5XZvxq/M68NGSbZz7t9l8tnw7hUVlH0zevPsQP3tlPrGRYTw/qjcRob4y5+vWIo6UxtH8e1X1n7VUY+VgZq+aWbaZrThm+jAzW2NmGWb2AIBzbpVz7k7gGqDUlXsiIrXBPee2593b+1M/IpQx7yxiwOMzee6rDFZszcU5h3OOT5Zt59J1+DQAAAcTSURBVIoXvqWoyPH26H4kNax33GUO6dSE+ev3cDC/oFqz19jwGWZ2FnAAeNM5180/zQekA+cBmcD3wHXOuZVmNgJ4APiHc27iiZav4TNEJFAVFBYxPS2LV7/ZwEL/2UYxkaE4BwfyC+icGMvT1/akY7OYEy7r24xdXP/yfCbcmMp5XZqecrbyhs8IPeUlV5Bz7mszSz5mcl8gwzm3HsDMJgGXAiudc1OBqWb2CVBmOZjZHcAdAK1ataqm5CIipybUF8LFpyVy8WmJ7D6Qz4yVWSzNLN566N26IVf2TsJXwSG/U5PjiQ738dWa7Coph3IzV9uSK6YFsKXE80ygn5kNBq4AIoBPy3uzc248MB6KtxyqL6aISNVoVD+CkX1bMbLvyb0/PDSEM9onMGt1Ns65ahvkz+tyKOu3cs65WcCsmo0iIlI7nNOxCdPTskjPOlChXVEnw+uzlTKBliWeJwHbPMoiIlIrDO7YBKDKR4Atyety+B5ob2ZtzCwcGAlM9TiTiEhAaxYXSefEWL5aHQTlYGbvAnOBjmaWaWa3OecKgLHAdGAV8J5zLq2mMomI1FZntGvE4s05lboCuzJq8myl68qZ/inHOegsIiKl9W/biAn/2cDizTkMSGlU5cv3ereSiIichNTkeMxg/obd1bJ8lYOISC0UFxVGl8RY5q1XOYiISAn921bfcQeVg4hILdWvTTz5BUUs3ZJT5ctWOYiI1FJ928RzTsfGhPqq/ippr6+QFhGRk9SgXjiv3XKS43CcQK3fcjCzS8xsfG5urtdRRESCRq0vB+fcx865O+Li4ryOIiISNGp9OYiISNVTOYiISCkqBxERKUXlICIipagcRESkFJWDiIiUYs4Fx62XzWwnsOk4syQAu2ooTmUoV+UoV+UoV+XUxVytnXONj50YNOVwIma2wDmX6nWOYylX5ShX5ShX5SjXf2m3koiIlKJyEBGRUupSOYz3OkA5lKtylKtylKtylMuvzhxzEBGRiqtLWw4iIlJBKgcRESkl6MvBzIaZ2RozyzCzBzz4/I1mttzMlpjZAv+0eDObYWZr/X82LDH/7/xZ15jZBVWY41UzyzazFSWmVTqHmZ3u/30yzOwZMzulW1CVk+sRM9vqX2dLzOwiD3K1NLOvzGyVmaWZ2Tj/dE/X2XFyebrOzCzSzL4zs6X+XI/6p3u9vsrL5fnfMf8yfWa22Mym+Z97/p38kXMuaH8AH7AOaAuEA0uBLjWcYSOQcMy0J4EH/I8fAJ7wP+7izxgBtPFn91VRjrOA3sCKU8kBfAcMAAz4DLiwGnI9Avy6jHlrMlci0Nv/OAZI93++p+vsOLk8XWf+ZdT3Pw4D5gP9A2B9lZfL879j/mXeB0wEpgXKd/KHn2DfcugLZDjn1jvnjgCTgEs9zgTFGd7wP34DuKzE9EnOuXzn3AYgg+Lf4ZQ5574G9pxKDjNLBGKdc3Nd8d/KN0u8pypzlacmc213zi3yP94PrAJa4PE6O06u8tRULuecO+B/Gub/cXi/vsrLVZ4a+ztmZknAxcDLx3y+p9/JHwR7ObQAtpR4nsnxv0jVwQFfmNlCM7vDP62pc247FH/ZgSb+6TWdt7I5Wvgf10S+sWa2zL/b6YdNa09ymVky0Ivi/3UGzDo7Jhd4vM78u0iWANnADOdcQKyvcnKB93/HngbuB4pKTPN8ff0g2MuhrH1vNX3u7iDnXG/gQuBuMzvrOPMGQl4oP0dN5XsBSAF6AtuBv3mVy8zqA5OBe51z+443a01mKyOX5+vMOVfonOsJJFH8v9pux5nd61yeri8zGw5kO+cWVvQtNZGrpGAvh0ygZYnnScC2mgzgnNvm/zMb+JDi3URZ/s1B/H9m+2ev6byVzZHpf1yt+ZxzWf4vdBEwgf/uWqvRXGYWRvE/wO845/7ln+z5OisrV6CsM3+WHGAWMIwAWF9l5QqA9TUIGGFmGyne3T3EzN4mgNZXsJfD90B7M2tjZuHASGBqTX24mUWbWcwPj4HzgRX+DDf5Z7sJmOJ/PBUYaWYRZtYGaE/xwabqUqkc/s3c/WbW339GxI0l3lNlfvhy+F1O8Tqr0Vz+5bwCrHLOPVXiJU/XWXm5vF5nZtbYzBr4H0cBQ4HVeL++yszl9fpyzv3OOZfknEum+N+lL51zPyOQvpNVcVQ7kH+Aiyg+o2Md8GANf3Zbis8wWAqk/fD5QCNgJrDW/2d8ifc86M+6hio668C/3Hcp3nw+SvH/Nm47mRxAKsVfpHXAP/BfZV/Fud4ClgPL/F+KRA9ynUHx5vkyYIn/5yKv19lxcnm6zoDTgMX+z18BPHSyf9drKJfnf8dKLHcw/z1byfPv5A8/Gj5DRERKCfbdSiIichJUDiIiUorKQURESlE5iIhIKSoHEREpReUgIiKlqBxERKSU/w+FoQuA/enD6AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "class SweepProgram(RAveragerProgram):\n",
    "    def initialize(self):\n",
    "        cfg = self.cfg\n",
    "        style = cfg['style']\n",
    "        \n",
    "        self.ro_rp=self.ch_page_ro(cfg[\"ro_ch\"])     # get register page for ro_ch\n",
    "        self.ro_freq=self.sreg_ro(cfg[\"ro_ch\"], \"freq\")   #Get gain register for ro_ch\n",
    "        \n",
    "        self.gen_rp=self.ch_page(cfg[\"res_ch\"])     # get register page for res_ch\n",
    "        self.gen_freq=self.sreg(cfg[\"res_ch\"], \"freq\")   #Get gain register for res_ch\n",
    "\n",
    "        \n",
    "        for iCh, ch in enumerate([cfg[\"res_ch\"]]):  # configure the readout lengths and downconversion frequencies\n",
    "            length_gen = self.us2cycles(cfg['length'], gen_ch=ch)\n",
    "            self.declare_gen(ch=ch, nqz=1, ro_ch=cfg[\"ro_ch\"])\n",
    "            self.default_pulse_registers(ch=ch, \n",
    "                         freq=cfg['start'],\n",
    "                         gain=cfg['pulse_gain'],\n",
    "                         phase=0)\n",
    "            if style == \"const\":\n",
    "                self.set_pulse_registers(ch=ch, style=style, length=length_gen)\n",
    "            elif style == \"arb\":\n",
    "                self.add_gauss(ch=ch, name=\"measure\", sigma=length_gen/5, length=length_gen)\n",
    "                self.set_pulse_registers(ch=ch, style=style, waveform=\"measure\")\n",
    "            elif style == \"flat_top\":\n",
    "                self.add_gauss(ch=ch, name=\"measure\", sigma=length_gen/25, length=int(0.2*length_gen))\n",
    "                self.set_pulse_registers(ch=ch, style=style, waveform=\"measure\", length=int(0.8*length_gen))\n",
    "\n",
    "        for iCh, ch in enumerate([cfg[\"ro_ch\"]]):  # configure the readout lengths and downconversion frequencies\n",
    "            length_ro = soccfg.us2cycles(cfg['length']+cfg['readout_padding'], ro_ch=ch)\n",
    "            self.declare_readout(ch=ch, length=length_ro)\n",
    "#             freq_ro = self.freq2reg_adc(cfg[\"pulse_freq\"],ro_ch=ch,gen_ch=cfg['res_ch'])\n",
    "            self.set_readout_registers(ch=ch, freq=cfg['start']*4, length=5)\n",
    "\n",
    "\n",
    "        self.synci(200)  # give processor some time to configure pulses\n",
    "\n",
    "    def body(self):\n",
    "#         # Configure readout v3.\n",
    "        for ch in [self.cfg[\"ro_ch\"]]:\n",
    "            if self.soccfg['readouts'][ch]['tproc_ctrl'] is not None:\n",
    "                self.readout(ch=ch, t=0)\n",
    "                \n",
    "        self.measure(pulse_ch=self.cfg[\"res_ch\"],\n",
    "                     t=0,\n",
    "                     adcs=self.ro_chs,\n",
    "                     pins=[0], \n",
    "                     adc_trig_offset=self.us2cycles(self.cfg[\"adc_trig_offset\"]-0.5*self.cfg['readout_padding']),\n",
    "                     wait=True,\n",
    "                     syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n",
    "\n",
    "    def update(self):\n",
    "        self.mathi(self.ro_rp, self.ro_freq, self.ro_freq, '+', self.cfg[\"step\"]*4) # update RO freq\n",
    "        self.mathi(self.gen_rp, self.gen_freq, self.gen_freq, '+', self.cfg[\"step\"]) # update gen freq\n",
    "\n",
    "config={\"res_ch\":0, # --Fixed\n",
    "        \"ro_ch\":0, # --Fixed\n",
    "        'adc_trig_offset': 0.33,\n",
    "        'readout_padding': 0.2,\n",
    "        'relax_delay': 1,\n",
    "        \"pulse_gain\":30000, # [DAC units]\n",
    "        \"pulse_freq\": 500, # [MHz]\n",
    "#         'style': 'arb',\n",
    "        'style': 'const',\n",
    "#         'style': 'flat_top',\n",
    "        'length': 10, # [us]\n",
    "        'soft_avgs': 1,\n",
    "        'reps': 100,\n",
    "        \"expts\": 401,\n",
    "        \"start\":prog.freq2reg(f=100,ro_ch=0,gen_ch=0), # [DAC units]\n",
    "        \"step\":prog.freq2reg(f=10,ro_ch=0,gen_ch=0) # [DAC units]\n",
    "       }\n",
    "\n",
    "# the start and step must both be scaled by 4 between the gen and RO.\n",
    "\n",
    "# config['readout_padding'] = 0.1\n",
    "prog = SweepProgram(soccfg, config)\n",
    "# print(prog)\n",
    "\n",
    "expt_pts, di, dq = prog.acquire(soc, progress=True)\n",
    "\n",
    "freqs = soccfg.reg2freq(expt_pts, gen_ch=0)\n",
    "plt.semilogy(freqs, np.abs((di+1j*dq)[0,0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "174762668\n",
      "43690667\n"
     ]
    }
   ],
   "source": [
    "print(prog.freq2reg_adc(f=100,ro_ch=0,gen_ch=0))\n",
    "print(prog.freq2reg(f=100,ro_ch=0,gen_ch=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}