From dcd0537466b9a34471cd5b6e9def79888be0b9e2 Mon Sep 17 00:00:00 2001 From: ethan-r-hansen Date: Tue, 16 Jan 2024 14:16:49 -0800 Subject: [PATCH] Added dpg11 pulser example notebook, which provided an outline for working with the dpg11 and an example for running the dpg11 code. I will update this in the future to include pulsed odmr, and also to go into more depth about using the dpg11, and how it may differ from the other pulsers. Fixes Add DPG11 Pulser and Example Notebook #138 --- examples/dpg11_pulser_examples.ipynb | 214 +++++++++++++++++++++++++++ 1 file changed, 214 insertions(+) create mode 100644 examples/dpg11_pulser_examples.ipynb diff --git a/examples/dpg11_pulser_examples.ipynb b/examples/dpg11_pulser_examples.ipynb new file mode 100644 index 00000000..88f563be --- /dev/null +++ b/examples/dpg11_pulser_examples.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DPG11 Pulser Driver Example\n", + "----------------------------------\n", + "In this document, I will outline how to use the dpg11 as a pulser for the qt3utils cwodmr program (for now, I will add pulsed odmr and other measurements in the future). There is existing documentation for the qt3utils cwodmr program, hence I will just focus on the dpg11 driver.\n", + "\n", + "## DPG11 Driver\n", + "The dpg11 python driver is availble in the dpg11_pylib library. I will make this library pip installable in the future, but for now, you can find it on the github page [here](https://github.com/UW-Quantum-Defect-Lab/dpg11_lib). To install it, simply clone the repository and run `python setup.py install` from the root directory. This will install the dpg11 library to your python site-packages directory.\n", + "\n", + "If you are interested in the dpg11 driver, I would recommend looking at the github library page, as it has more detailed documentation. \n", + "\n", + "The major details are not important. To be able to control the dpg11, you must install the wavepond gui, which I have also included in the github repository. To initialize the dpg11 driver object, you must provide the full path to the wavepond gui. Folders will be created to save waveforms and scripts. Again, more information will be found on the github page for this.\n", + "\n", + "## DPG11 Pulser\n", + "To integrate the dpg11 with the existing qt3utils code, I have created a new pulser class called 'DPG11Pulser'. This class is located in the qt3utils package (qt3utils/pulsers/dpg11.py). This class is a subclass of the existing 'Pulser' class, and hence has all the same methods and attributes. The only difference is that the 'DPG11Pulser' class uses the dpg11 driver to control the pulser, rather than the existing 'PulseBlaster' class. This contains basic functions such as start, stop, and reset which will be used for all pulsers in most experiments.\n", + "\n", + "## DPG11 CWODMR Pulser\n", + "Then, there is another subclass called DPG11CWODMRPulser which has all of the functionality for running CWODMR. Similar classes for but more functionality for experiments such as Rabi, Ramsey, and pulsed ODMR will be added in the future.\n", + "\n", + "The main function utilized for the CWODMR experiment is the program_pulser_state function, which creates and loads the pulse sequences for the clock, rf, AOM, and trigger signals that will be loop continuously for the duration of the measurment. This only loads the waveforms. They will be ran when the start function is called in the actual cwodmr code. I will go over this.\n", + "\n", + "## Extra functionality\n", + "Within the dpg11_pylib, I have included a subpackage called visualiziation which contains a few functions for visualizing the waveforms that are created. This is not necessary, but I have found it useful for debugging. \n", + "\n", + "The main module in that subpackage, called plotting, has two very useful functions: plot_waveforms and plot_dpg11_wavefiles. plot_waveforms will plot digital signals of 0's and 1's from a list or array. plot_dpg11_wavefiles will plot the waveforms that are created by the dpg11 driver. This is useful for debugging, as you can see if the waveforms are being created correctly. I will use this one in the example. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we must import all of the relevant packages." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import dpg11 pulser code\n", + "from dpg11 import DPG11CWODMRPulser\n", + "# Import dpg11 driver and visualization modules\n", + "from dpg11_pylib import driver, visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we must create the dpg11 driver object, making sure to provide the full path to the wavpond gui folder. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Get the driver path\n", + "driver_path = \"/Users/ethanhansen/Dropbox/35share/Python/Ethan/Libraries/dpg11_git/dpg11_lib/testing/app\"\n", + "\n", + "# create the dpg11 dev object. This will be passed to the pulser object.\n", + "dev = driver.DPG11Device(driver_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should now check the driver path and make sure the script, wavefile, and multi_wavefiles folders have been created.\n", + "\n", + "Now, you want to create the dpg11 pulser object, where you must provide the dpg11 driver object as an argument. Additionally, you must provide the channel numbers for the AOM, rf, clock, and trigger signals. The waveforms will be output to the respective channels on the DPG11 device, so make sure the connections are right. You must also provide the rf_pulse_duration in seconds (the duration to have the rf pulse on for. It will then be off for the same amount of time, and loop after that), the clock_period in seconds (the period of the clock signal), and the trigger_width in seconds (the width of the trigger signal).\n", + "\n", + "It should be noted that the dpg11 requires waveforms that are modulous 64 in length, hence the overall cycle length (which is 2*rf_pulse_duration) must be modulous 64. To acheive this, this rf_pulse_duration is adjusted in the code to be modulous 64 length given the sample rate. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the pulse object\n", + "# Here you could set any pulse paramters that you want, but I am using the defaults for now.\n", + "cwodmr_pulser = DPG11CWODMRPulser(dev)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, run the program_pulser_state function to initialize the waveforms. Again, this only loads the waveforms. They will be ran when the start function is called." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reset :)\n" + ] + } + ], + "source": [ + "# initialize the waveforms\n", + "cwodmr_pulser.program_pulser_state()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we will plot the wavefile to make sure that things look okay." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0UAAAFfCAYAAACBVWdhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABgYUlEQVR4nO3dfXRdZZk3/u8+SZqXNid9CQn01SJvQgsqFISiiPC02CJQZkZGEBBYWLCAo4i1vDxl4YwO/tSiLkSQGRT1Af2NYsvvqQwwFBhEoJRCKVjkpdDaQEqS5qRp0+Yk+/79kTmRkKTZ1519733tvb+ftVgzNt+97+va1zk5vXtydjxjjAEREREREVFG5eIugIiIiIiIKE7cFBERERERUaZxU0RERERERJnGTREREREREWUaN0VERERERJRp3BQREREREVGmcVNERERERESZVh53AcPxfR9NTU2ora2F53lxl0NERERERDExxmDnzp2YPHkycrnw39dRuylqamrCtGnT4i6DiIiIiIiU2Lp1K6ZOnRr6edVuimprawEAmzdvxsSJE0fM+76PrVu3Ytq0aYF2j9J8FGtoyxeLRTz44IOYN28eKioqYq8nizNL+gzSMLOszUDjzDiDcPM2x3AG8eYBziDuvPT6a+wh6fm2tjbMnDmzf48QNrWbotKPzNXW1iKfz4+Y930fDQ0NyOfzgQchyUexhrZ8sVhETU0N8vl84G/AmurXWFPWZpCGmWVtBhpnxhmEm7c5hjOINw9wBnHnpddfYw9JzxeLRQBw9rEazxhjnJx5lDo6OlBXV4eWlhZMmjQp7nIyqVgsYvXq1ViwYEHgbwAULs4gfpxB/DiD+HEG8eMM4sXrH7/W1lbU19ejUCgEesNESu07RSW7e31U9/SOmDPGoKOjA/l8PtAOUpqPYg1t+WKvj73wsLvXR4UX/wyyOLOkzyANM8vaDDTOrNjrQ/Kvd8YYFAoF1NXVBa4nS3nbYyS09Zz0vA1tPSQ9b0NbD0nPu6Z+U/SJJ15Bbuy4uMvIrqrpWPbYn+OuIts4g/hxBrGbOaYRCwL+YIMxBu3t7aJNWpbytsdIaOs56Xkb2npIet6Gth6SnneNv6eIiIjU25yrQpev8qe9iYgoBdS/U3TZwfsjP2Hku8/B91HZ2oy9kxqBIB9alOajWENZ3uvtwcTnn0Lbhz8GUxbgoaKsfpU1ZW0GKZhZ5magbGZF3+AHf94arA4iIiJL6jdF+fJyTK0aM2LOGB/I54HqMfC8kV+Upfko1lCX78nBwGBy5Rh45SM/VLTVr7GmrM0gFTPL2Ay0zWxvrx+ohvcbN072Y9dZy9se4/L8zIdPWw9Jz9vQ1kPS8y6p3xQF5Xk5oG6Cs3wUa2jLS2msX1tNWZtBGmYmpa3+NMxMKpfLob6+nvmQj3F5fubDp62HpOdtaOsh6XnXUvOZImN8mMKOvn+BdJCPYg1teSmN9WurKWszSMPMpLTVn4aZSfm+j5aWFvh+sPNnLW97jIS2npOet6Gth6TnbWjrIel511KzKYIB0LUbge/bKs1HsYa2vJTG+rXVlLUZpGFmUtrqT8PMLHR2djLv4BiX52c+fNp6SHrehrYekp53KT2bIiIiIiIiIgvcFBERERERUaalZ1PkecC42r7/6yIfxRra8lIa69dWU9ZmkIaZSWmrPw0zE/I8D+PHjw/8ywCzlrc9RkJbz0nP29DWQ9LzNrT1kPS8aym6+5wHjMs7y0exhra8lMb6tdWUtRmkYWZS2upPw8ykSi+0zId7jMvzMx8+bT0kPW9DWw9Jz7uWmneKjPFh2lpkdz8S5KNYQ1teSmP92mrK2gzSMDMpbfWnYWZSvu+jublZdAekLOVtj5HQ1nPS8za09ZD0vA1tPSQ971pqNkUwALr3yu5+JMlHsYa2vJTG+rXVlLUZpGFmUtrqT8PMLHR1dTHv4BiX52c+fNp6SHrehrYekp53KT2bIiIiIiIiIguhbYr+/Oc/48ADDwzrdERERERERJEIbVPU3d2Nt956K6zTyXkekB8vu/uRJB/FGtryUhrr11ZT1maQhplJaas/DTMT8jwPkyZNEt0BKUt522MktPWc9LwNbT0kPW9DWw9Jz7sW+O5zX/3qV/f59XfffXfUxYyG53lAzVhn+SjW0JaX0li/tpqyNoM0zExKW/1pmJmU53mora1lPuRjXJ6f+fBp6yHpeRvaekh63rXA7xT94Ac/wGOPPYb169cP+d+mTZtc1jki4/swLc0wAe9gIc1HsYa2vJTG+rXVlLUZpGFmUtrqT8PMpHzfx7Zt20R3QMpS3vYYCW09Jz1vQ1sPSc/b0NZD0vOuBX6n6KCDDsJXvvIVfP7znx/y688//zyOPvro0Aqz0tPjNh/FGtryUhrr11ZT1maQhplJaas/DTMTKhaLzDs4xuX5mQ+fth6SnrehrYek510K/E7RMcccg3Xr1g37dc/zYIzD+6sSERERERE5EPidou9973vYu3fvsF8/6qij1Lz9RUREREREFFTgTdH+++/vso7R8zxgwiTZ3Y8k+SjW0JaX0li/tpqyNoM0zExKW/1pmJmQ53lobGwU3QEpS3nbYyS09Zz0vA1tPSQ9b0NbD0nPuxZ4U6Sd53lAZZWzfBRraMtLaaxfW01Zm0EaZialrf40zEzK8zxUV1czH/IxLs/PfPi09ZD0vA1tPSQ971pov6cobsb3YZqbZHc/EuSjWENbXkpj/dpqytoM0jAzKW31p2FmUr7v46233hLdASlLedtjJLT1nPS8DW09JD1vQ1sPSc+7lppNEQBAeqMHmxtDuF5DW15KY/3aasraDNIwMylt9adhZkLSG/9kLW97jMvzMx8+bT0kPW9DWw9Jz7uUrk0RERERERGREDdFRERERESUaaFtilauXIm77747rNPJeR5Q3yC7+5EkH8Ua2vJSGuvXVlPWZpCGmUlpqz8NMxPyPA+TJ08W3QEpS3nbYyS09Zz0vA1tPSQ9b0NbD0nPuxbapmjp0qW46KKLwjqdmOd5QK5MNAhJPoo1tOWlNNavraaszSANM5PSVn8aZibleR7Ky8tF9WQpb3uMhLaek563oa2HpOdtaOsh6XnXQtsUbdq0Cb29vWGdTsz4PrD9bdHdjyT5KNbQlpfSWL+2mrI2gzTMTEpb/WmYmZTv+9iyZYvoDkhZytseI6Gt56TnbWjrIel5G9p6SHreNX6miIiIiIiIMs3ql7e2t7fjmWeewfbt2wft7i644IJQCiMiIiIiIoqCeFN0//3347zzzkNnZyfy+fyAnwP0PI+bIiIiIiIiShTPCH9r0iGHHIIFCxbgW9/6FmpqalzVhY6ODtTV1eHHL2/G1P3qAx1jfB9eLvhPBErzUayhKW96emCefgzecSfBKw+2f9ZUv9aasjaDpM8sizPQNLO9vT6WPv8GAOC5kz6EuqrKQOf3fR85QT1Zy0uPKRaLWL16NRYsWICKigonNTG/b5xBvHmb6++6pqzlW1tbUV9fj0KhgHw+H3iNoMSfKdq2bRuuuuoqpxsiG8YYwO8N/Jtxpfko1tCWl9JYv7aasjaDNMxMSlv9aZiZlDEGPT09onqylLc9RkJbz0nP29DWQ9LzNrT1kPS8a+JN0fz58/Hss8+6qGV0jAFatvf9Xxf5KNbQlpfSWL+2mrI2gzTMTEpb/WmYmZAxBk1NTaIX5izlbY+R0NZz0vM2tPWQ9LwNbT0kPe9aoJ8FWbVqVf//v3DhQlxzzTV4+eWXMXv27EFvIZ5xxhnhVkhERERERORQoE3RWWedNejPbrrppkF/5nlerL+riIiIiIiISCrQpkjLL1UakfQ34tr8Bl3Xa2jLS2msX1tNWZtBGmYmpa3+NMxMSPob0rOWtz3G5fmZD5+2HpKet6Gth6TnXRLffS4qNnefo3DZ3HWLwsUZxI8ziJft3ecoXLZ33qLwcAbx4vWPn5q7zz3yyCM4/PDD0dHRMehrhUIBRxxxBB5//PFQi5MwxsDs3SP6cJckH8Ua2vJSGuvXVlPWZpCGmUlpqz8NM5MyxqCrq0tUT5bytsdIaOs56Xkb2npIet6Gth6Snnct8KbolltuwaWXXjrkzqyurg6LFy/GihUrQi1OxBhgR6vs7keSfBRraMtLaaxfW01Zm0EaZialrf40zEzIGIPm5mbRC3OW8rbHSGjrOel5G9p6SHrehrYekp53LfCm6IUXXsBpp5027NfnzZuHdevWhVIUERERERFRVAJvipqbm/f5M5Tl5eV49913QymKiIiIiIgoKoE3RVOmTMHGjRuH/fqGDRtwwAEHhFKUNemHoG0+NO16DW15KY31a6spazNIw8yktNWfhpkJST8InbW87TEuz898+LT1kPS8DW09JD3vUuC7z1155ZV49NFHsXbtWlRVVQ34WldXF4499licfPLJ+OEPfxhKYbz7XPx41634cQbx4wzixbvP6cA7b8WPM4gXr3/81Nx97vrrr0dbWxsOOeQQfOc738HKlSuxcuVK3HzzzTj00EPR1taG6667LvQCgzLGwOzeJfpwlyQfxRra8lIa69dWU9ZmkIaZSWmrPw0zkzLGYOfOnaJ6spS3PUZCW89Jz9vQ1kPS8za09ZD0vGuBN0WNjY148sknMWvWLCxbtgyLFi3CokWLcO2112LWrFl44okn0NjY6LLWfTMG6GiX3f1Iko9iDW15KY31a6spazNIw8yktNWfhpkJGWPQ2toqemHOUt72GAltPSc9b0NbD0nP29DWQ9Lzrol+FmTGjBlYvXo1duzYgddeew3GGBx88MGYMGGCq/qIiIiIiIicsvoB+QkTJmDOnDlh10JERERERBS5wD8+p54HYExl3/91kY9iDW15KY31a6spazNIw8yktNWfhplZqK6uZt7BMS7Pz3z4tPWQ9LwNbT0kPe9S4LvPRY13n4sf77oVP84gfpxBvHj3OR145634cQbx4vWPn5q7z2lnjIHp7BB9uEuSj2INbXkpjfVrqylrM0jDzKS01Z+GmUkZY9De3i6qJ0t522MktPWc9LwNbT0kPW9DWw9Jz7uWmk0RjAE6d8rufiTJR7GGtryUxvq11ZS1GaRhZlLa6k/DzIS0vZBry9seI6Gt56TnbWjrIel5G9p6SHretfRsioiIiIiIiCxwU0RERERERJmWnk2RB6C6Rnb3I0k+ijW05aU01q+tpqzNIA0zk9JWfxpmZmHcuHHMOzjG5fmZD5+2HpKet6Gth6TnXUrNrZQ8LwfUBf8lstJ8FGtoy0tprF9bTVmbQRpmJqWt/jTMTCqXy6G+PvhdS7OWtz3G5fmZD5+2HpKet6Gth6TnXUvNO0XG+DCFHTDGd5KPYg1teSmN9WurKWszSMPMpLTVn4aZSfm+j5aWFvh+sPNnLW97jIS2npOet6Gth6TnbWjrIel511KzKYIB0LW77/+6yEexhra8lMb6tdWUtRmkYWZS2upPw8wsdHZ2Mu/gGJfnZz582npIet6Gth6SnncpNT8+R0RE6dbV66Oip3fEnG8MunyD3b0+cv7IO6+s5W2OKfb62AsPu3t9VHicQdR5gDOIOy+9/hp7SHp+d6/bd5Q8o+Xm4O9TKBQwfvx4fO+ZDZhSP2nEvPF94N1mYL9GeLmR3wCT5qNYQ12+pwfm2T/CO2YuvPKR98/a6tdYU9ZmkIqZZWwG2ma2t9fH8g1vBqqDiIjSy9+9C1vOPw3t7e2oq6sL/fxq3ylqbW0FAFx97JExV0JERERERBq0trZma1M0ceJEAMCWLVsCNz5nzhysXbs28BrSfBRraMp3dHRg2rRp2Lp1K/L5fOz12OQ11pS1GSR9ZlmcgbaZcQbh56XHcAbx5zmDePM21991TVnLFwoFTJ8+vX+PEDa1m6Lc//xIRV1dXeAHX1lZmeiBKs1HsYa2PADk83k1M8jizIBkzyANMwOyNQONMwM4gzDztsdwBvHlSziD+PKA7PpHUVPW8sDf9ghhS8/d5wAsWbLEaT6KNbTlpTTWr62mrM0gDTOT0lZ/GmYmpe0aacvbHuPy/MyHT1sPSc/b0NZD0vMuqb3RQkdHB+rq6lAoFKz+JYVGjzOIH2cQP84gfpxB/DiD+HEG8eL1j5/rGah9p6iyshLLly9HZWVl3KVkFmcQP84gfpxB/DiD+HEG8eMM4sXrHz/XM1D7ThEREREREVEU1L5TREREREREFAVuioiIiIiIKNO4KSIiIiIiokzjpoiIiIiIiDKNmyIiIiIiIso0boqIiIiIiCjTyuMuYDi+76OpqQm1tbXwPC/ucoiIiIiIKCbGGOzcuROTJ09GLhf++zpqN0VNTU2YNm1a3GUQEREREZESW7duxdSpU0M/r9pNUW1tLQBg8+bNmDhx4oh53/exdetWTJs2LdDuUZqPYg1t+WKxiAcffBDz5s1DRUVF7PVkcWZJn0EaZpa1GWicGWcQbt7mGM4g3jzAGcSdl15/jT0kPd/W1oaZM2f27xHCpnZTVPqRudraWuTz+RHzvu+joaEB+Xw+8CAk+SjW0JYvFouoqalBPp8P/A1YU/0aa8raDNIws6zNQOPMOINw8zbHcAbx5gHOIO689Ppr7CHp+WKxCADOPlbjGWOMkzOPUkdHB+rq6tDS0oJJkybFXU4mFYtFrF69GgsWLAj8DYDCxRnEjzOIH2cQP84gfpxBvHj949fa2or6+noUCoVAb5hIqX2nqF+xCyjuHjFmjEGh0IG6unygHaQ0H8Ua2vIo9qDM7+6bAYqx15PFmSV9BmmYWdZmoHFmnEG4eatjOINY8wA4g5jz0usfRU1Zy/dde3fUv1NUuPkw5KvL4i6HiIiIiIhi0tHVi7qlm5y9U8TfU0RERERERJmm/sfniid+FWiYPGLO9w22tvdi2vgy5HIjvwUnzUexhrZ8sdfgP1/uwvzDq1FRFn89WZxZ0meQhpllbQYaZ8YZhJu3OYYziDcPcAZx56XXX2MPic7v7UBxVy+A80c8ry31myKUjQHKK0fOGYOxNT5QkQOC/FyiNB/FGtrynkFvrrfv+gf5BqCtfo01ZW0GaZhZ1magcWacQbh5m2M4g3jzAGcQd156/aOoKUv53jFAee/I5xwF/ZuigHKeh/pxwT97JM1HsYa2vJTG+rXVlLUZpGFmUtrqT8PMpLRdI21522Ncnp/58GnrIel5G9p6SHretdR8psg3Bi2dvfAD3jdCmo9iDW15KY31a6spazNIw8yktNWfhplJabtG2vK2x0ho6znpeRvaekh63oa2HpKedy01myIYoHOvDwS9rtJ8FGtoy0tprF9bTVmbQRpmJqWt/jTMTErbNdKWtz1GQlvPSc/b0NZD0vM2tPWQ9Lxj6dkUERERERERWeCmiIiIiIiIMi01myLPA8ZX54LfxEWYj2INbXkpjfVrqylrM0jDzKS01Z+GmUlpu0ba8rbHSGjrOel5G9p6SHrehrYekp53LTV3n/M8D+Nrgt/BQpqPYg1teSmN9WurKWszSMPMpLTVn4aZSWm7Rtrytse4PD/z4dPWQ9LzNrT1kPS8a6l5p8g3Bs0dPaI7XkjyUayhLS+lsX5tNWVtBmmYmZS2+tMwMylt10hb3vYYCW09Jz1vQ1sPSc/b0NZD0vOupWZTBAN0FY3ojheifBRraMtLaaxfW01Zm0EaZialrf40zExK2zXSlrc9RkJbz0nP29DWQ9LzNrT1kPS8Y6JN0QsvvIB//ud/xo9//GO0tLQM+FpHRwcuvvjiUIsjIiIiIiJyLfCm6MEHH8Sxxx6Le++9FzfffDMOO+wwrFmzpv/rXV1d+PnPf+6kSCIiIiIiIlcCb4puvPFGfO1rX8PGjRvx5ptv4utf/zrOOOMMPPDAAy7rC8zzgEljy0R3vJDko1hDW15KY/3aasraDNIwMylt9adhZlLarpG2vO0xEtp6TnrehrYekp63oa2HpOddC3z3uZdeegm/+MUvAPTdLeLrX/86pk6dir//+7/Hvffeizlz5jgrMgjP81BbFfyqSvNRrKEtL6Wxfm01ZW0GaZiZlLb60zAzKW3XSFve9hiX52c+fNp6SHrehrYekp53LfA7RZWVlWhvbx/wZ+eeey7uvPNOnHPOObjvvvvCrk3ENwbb2mV3vJDko1hDW15KY/3aasraDNIwMylt9adhZlLarpG2vO0xEtp6TnrehrYekp63oa2HpOddC/xO0Yc//GGsWbMGRx999IA//8d//EcYY3DhhReGXpyIAYq9/3MHiyCbTmk+ijW05aU01q+tpqzNIA0zk9JWfxpmJqXtGmnL2x4joa3npOdtaOsh6Xkb2npIet6xwJuiyy+/HI8//viQX/vc5z4HYwx++tOfhlYYERERERFRFAJvihYtWoRFixYN+/Vzzz0X5557bihFERERERERRSU1v7zV84DGWtkdLyT5KNbQlpfSWL+2mrI2gzTMTEpb/WmYmZS2a6Qtb3uMhLaek563oa2HpOdtaOsh6XnXAr9TpJ3neageE/yqSvNRrKEtL6Wxfm01ZW0GaZiZlLb60zAzKW3XSFve9hiX52c+fNp6SHrehrYekp53LTXvFPm+wVttRfi+cZKPYg1teSmN9WurKWszSMPMpLTVn4aZSWm7RtrytsdIaOs56Xkb2npIet6Gth6SnnctNZsiAJDe0c/mDoCu19CWl9JYv7aasjaDNMxMSlv9aZiZlLZrpC1ve4zL8zMfPm09JD1vQ1sPSc+7lKpNERERERERkVRom6KVK1fi7rvvDut0REREREREkQhtU7R06VJcdNFFYZ1OzPOAyXXlojteSPJRrKEtL6Wxfm01ZW0GaZiZlLb60zAzKW3XSFve9hgJbT0nPW9DWw9Jz9vQ1kPS866FtinatGkTent7wzqdmOd5KM/1/V8X+SjW0JaX0li/tpqyNoM0zExKW/1pmJmUtmukLW97jIS2npOet6Gth6TnbWjrIel511LzmSLfN9iyo0d0xwtJPoo1tOWlNNavraaszSANM5PSVn8aZial7Rppy9seI6Gt56TnbWjrIel5G9p6SHreNavfU9Te3o5nnnkG27dvh+/7A752wQUXhFIYERERERFRFMSbovvvvx/nnXceOjs7kc/nB7zl5XkeN0VERERERJQo4h+fu/rqq3HxxRejs7MT7e3t2LFjR/9/bW1tLmokIiIiIiJyxjNG9muTxo4dixdffBEHHnigq5oAAB0dHairq0PLUz/DpMYpgY7xfYNcLviHtaT5KNbQlC/2GqzeuBsLZtWgoizYMZrq11pT1maQ9JllcQbaZsYZhJ+XHsMZxJ/nDOLN21x/1zVlKr+3gNZdvag/+hwUCgXk8/nAawQlfqdo/vz5ePbZZ0MvZLSMMejx+/6vi3wUa2jLS2msX1tNWZtBGmYmpa3+NMxMSts10pa3PUZCW89Jz9vQ1kPS8za09ZD0vGuBNkWrVq3q/2/hwoW45pprcOONN+K3v/3tgK+tWrXKdb3DMgZoKvQg6HWV5qNYQ1teSmP92mrK2gzSMDMpbfWnYWZS2q6RtrztMRLaek563oa2HpKet6Gth6TnXQt0o4Wzzjpr0J/ddNNNg/7M87xYf1cRERERERGRVKBN0ftvu01ERERERJQWqfnlrQAg/YW4Nr9A1/Ua2vJSGuvXVlPWZpCGmUlpqz8NM5PSdo205W2PcXl+5sOnrYek521o6yHpeZcC333ukUcewRVXXIGnnnpq0B0fCoUCTjjhBNx22234xCc+EUphNnefo3DZ3mmFwsMZxI8ziB9nED/OIH6cQbx4/WOm6e5zt9xyCy699NIhi6irq8PixYuxYsWKUIuTMMagq9sX3fFCko9iDW15KY31a6spazNIw8yktNWfhplJabtG2vK2x0ho6znpeRvaekh63oa2HpKedy3wpuiFF17AaaedNuzX582bh3Xr1oVSlA1jgOadvaI7XkjyUayhLS+lsX5tNWVtBmmYmZS2+tMwMylt10hb3vYYCW09Jz1vQ1sPSc/b0NZD0vOuBd4UNTc3o6KiYtivl5eX49133w2lKCIiIiIioqgE3hRNmTIFGzduHPbrGzZswAEHHBBKUURERERERFEJvClasGABbrjhBuzZs2fQ17q6urB8+XKcfvrpoRYn4qHvg29BP/smzUexhra8lMb6tdWUtRmkYWZS2upPw8yktF0jbXnbYyS09Zz0vA1tPSQ9b0NbD0nPOxb47nPNzc346Ec/irKyMlxxxRU49NBDAQCbNm3Crbfeit7eXjz33HNobGwMpTDefS5+vNNK/DiD+HEG8eMM4scZxI8ziBevf8w03X2usbERTz75JGbNmoVly5Zh0aJFWLRoEa699lrMmjULTzzxRGgbIhvGGOzcI7vjhSQfxRra8lIa69dWU9ZmkIaZSWmrPw0zk9J2jbTlbY+R0NZz0vM2tPWQ9LwNbT0kPe+a6Je3zpgxA6tXr0ZLSwuefvppPPXUU2hpacHq1asxc+ZMVzUGYgzQukt2xwtJPoo1tOWlNNavraaszSANM5PSVn8aZial7Rppy9seI6Gt56TnbWjrIel5G9p6SHretXKbgyZMmIA5c+aEXQsREREREVHkRO8UERERERERpU16NkUeUF0hu+OFKB/FGtryUhrr11ZT1maQhplJaas/DTOT0naNtOVtj5HQ1nPS8za09ZD0vA1tPSQ975jVj89plPM8NOaDtyPNR7GGtryUxvq11ZS1GaRhZlLa6k/DzKS0XSNtedtjXJ6f+fBp6yHpeRvaekh63rXUvFNkjEH77l7RHS8k+SjW0JaX0li/tpqyNoM0zExKW/1pmJmUtmukLW97jIS2npOet6Gth6TnbWjrIel511K0KQLau3zRHS8k+SjW0JaX0li/tpqyNoM0zExKW/1pmJmUtmukLW97jIS2npOet6Gth6TnbWjrIel511KzKSIiIiIiIrLBTREREREREWVaejZFHjCuMie644UoH8Ua2vJSGuvXVlPWZpCGmUlpqz8NM5PSdo205W2PkdDWc9LzNrT1kPS8DW09JD3vmJ5bPoxSzvNQP67MWT6KNbTlpTTWr62mrM0gDTOT0lZ/GmYmpe0aacvbHuPy/MyHT1sPSc/b0NZD0vOupeadIt8YtHT2wg/4aS1pPoo1tOWlNNavraaszSANM5PSVn8aZial7Rppy9seI6Gt56TnbWjrIel5G9p6SHretdRsimCAzr0+EPS6SvNRrKEtL6Wxfm01ZW0GaZiZlLb60zAzKW3XSFve9hgJbT0nPW9DWw9Jz9vQ1kPS846lZ1NERERERERkQe1nikq/yGlnoQ0VXs+Ied8AO3eWoaOnF7kAH9iS5qNYQ1u+2Avs3l2Dju0tqAjwI5/a6tdYU9ZmkIaZZW0GGmfGGYSbtzmGM4g3D3AGceel1z+KmjKV7y1iZ7EKwN/2CGFTuylqbW0FAMyc/9WYKyEiIiIiIg1aW1tRV1cX+nnVboomTpwIANiyZUvgxufMmYO1a9cGXkOaj2INTfmOjg5MmzYNW7duRT6fj70em7zGmrI2g6TPLIsz0DYzziD8vPQYziD+PGcQb97m+ruuKWv5QqGA6dOn9+8RwqZ2U5TL9X3cqa6uLvCDr6ysTPRAleajWENbHgDy+byaGWRxZkCyZ5CGmQHZmoHGmQGcQZh522M4g/jyJZxBfHlAdv2jqClreeBve4SwpepGC0uWLHGaj2INbXkpjfVrqylrM0jDzKS01Z+GmUlpu0ba8rbHuDw/8+HT1kPS8za09ZD0vEuecfVppVHq6OhAXV0dCoWC1b+k0OhxBvHjDOLHGcSPM4gfZxA/ziBevP7xcz0Dte8UVVZWYvny5aisrIy7lMziDOLHGcSPM4gfZxA/ziB+nEG8eP3j53oGat8pIiIiIiIiioLad4qIiIiIiIiiwE0RERERERFlGjdFRERERESUadwUERERERFRpnFTREREREREmVYedwHD8X0fTU1NqK2thed5cZdDREREREQxMcZg586dmDx5MnK58N/XUbspampqwrRp0+Iug4iIiIiIlNi6dSumTp0a+nnVbopqa2sBAJs3b8bEiRNHzPu+j61bt2LatGmBdo/SfBRraMsXi0U8+OCDmDdvHioqKmKvJ4szS/oM0jCzrM1A48w4g3DzNsdwBvHmAc4g7rz0+mvsIen5trY2zJw5s3+PEDa1m6LSj8zV1tYin8+PmPd9Hw0NDcjn84EHIclHsYa2fLFYRE1NDfL5fOBvwJrq11hT1maQhpllbQYaZ8YZhJu3OYYziDcPcAZx56XXX2MPSc8Xi0UAcPaxGs8YY5yceZQ6OjpQV1eHlpYWTJo0Ke5yMqlYLGL16tVYsGBB4G8AFC7OIH6cQfw4g/hxBvHjDOLF6x+/1tZW1NfXo1AoBHrDRErtO0VSxhgUCgXU1dUBAHpM14j5jo4O5PP5IXec5V71oD9/7xrD7VKNMf1rj7TGUMfu6ujG+PHjA+fD6nmofoOIq1/P8wasva9jJD1rm/Fw6+4rk/R+XT+upT0X/R74XjeKfhfgFwPVr+l57HrGpWNc9ryvGSThca1hxqWcbc9FvwcGwf8NVUPPaZpxUGnqWduMh1t3pFySe9Y246I/8jUfjVRtitrb21FbW4vf//UivLPn+WAHbh/6j/ev+jDOnv7zAUMqrTHcg88Yg99tuXDw2sOsMZQJ3mE4J38PysrKRsyG2fP+VUfh7Ol3i74xhNHveO8wnFP7K5SXj/yvLu+9/gDwuy0X4J09LwRbaMie9c94xHWHM2S/R2LRtLsHvEUdRb+SGb+3pr7H9Rd0zPhQ4K43vxmsDsT5PI5nxgAwwfsQzsn/H3c9DzODob53aXsehznjxqojcfa0nyOX+9u6I/Vbygz5PVPQ85jp02HMgkBZ169PUc34s7X/B+XlI/9VyfWMgwhjxs6fx8PUk4QZj7juviT07yDaZtzV2RtsfUup+z1FPWaP7IE6jHf2PB/oXwEGrt016rV3mE0o+ruF646+53f2vIDOnneE646+33azCW3dm8TH9a0d8C/Lw4hzxnv9ncJ1w5jxBnT0bBGuG86M3+3eID6ur+fkzrirt1W4bjgz3lF8Xbju6PsFgB3mz+gxe4Rrh/O9S/49M5wZd/a8LVx39P0279mA1u4/i48L43tmd82W2Ga81+8QrhvOjDt6tgrXDWfG2/fKZxXGjON8Hsu/Z4Yz4/bia8J1+fdMG31/z5R+zwzn9Smo1LxTNJTj97sc1WX1Q3/RB9qbgfGNGLA17DXdeKz55lGvfVLjUpSZMUOuMZTw1v0ayrzqob84RM/vXdfHyD8aNJwTG67EGIy36rcXPdbrAv9zrb0xQ39xhJ5Hva7ljI2x7/kTDV9BeW7c0F8cccb2657Q8CVUYZJVv/4o+gXinPE18Pwq/OUJ4JATgZH+4Tasnk9s+DLG5Ib5eekR+jWjeB4fv9/lqPbqA8/4/WuPxr5m7Pdi0AwGrmv/0diTGq9GmamxfFzbX+u5DVeiMjd+6C86/F4NxPn6ZP88Nsb+X4g/3vAVVGCc3ffqUVzrExq+hKrcMJ+JTu2Mr0GZVzX0F0fqeRTPpxMbvowxyNs9j0f7PXO4v2f2nVzn30FG+z3Tqxn6iw5nfOx+FwNVEwFcaH2OkaRqUzRu3MC/KFbkqlBdXjdk1vgGteN8VJXn4OX+9pZdj79XtMZwqsryKMOYIdcYykjrBq2nIjcOlWVD1zhUz7brvl9FrgZVubxVv5Kf5B3q+leV5VGeqxwyb9Ozthm/X0VuHKoEj+uw+q3walBV5n7GQ9UU14zH5PIo86qQM3tQVVaFsvJonsdjcmNF37tCm3GuUjTjIGsHrWlfM+6FGTSD8HquxRhvrOXzOPgje/CMa2KZMRDf61Ncz+OK3Djr16fRzLjCqw51xhJxzXhMLo8xZUP/w6zb79VjR/F3EPs7mVXkKoedMZCOv4MM/ntmbah/zwzab7lXCTPcP6qEJDWbolwuh/r6+sBvCXo5D+MmyH5et7RGUDZrlNaR1OOyZwnb8wf5ixcw8Pr3+m5q0jZjKa39Bp3xe2ty9biW9mxLy/M4qhn3rSV7Lkt/hCN4HVE9j930G8Vj2vXrgbaeo3p90vJ6PJo1kvq4juL1yebcGntO6uuTa6n5TJHv+2hpaYHvB3tL0PgGnTt6YQLmB64R7G/kNmuU1pHV465nCdvzB81Lr79NTdpmLKW1X7vnmZvHtc3jyIaW53FUM+5bS1qTm+9F0T2P3fQbxWPa9euBtp6je33S8Xo8mjWS+riO4vVJSmvPSX19ci01myIA6OzsDJw1APbukv9UZRRrSGiqx/b8kryk39K5pTVpuqZSWvvV9jyTPo5c09RvVI9p1zOIpufgR2iase0aUpp6TsOMpTjjoMc53BRBZ88SmmbsWqo2RURERERERFLcFBERERERUaalZlPked7//IbeoHmgOp8LnB+4RrCDbNYorSOrJ+h57eoJyr7foDnZ9bepSduMpfT2K8m6fVzbPI5saHkeRzXj0rGymuRryM6v43msbcY2a0hp69m6XyUzthHda7KberQ9j20kvWdtM3YthZui4IOuyeeELyLu1ygdp6meoLT1a1OTthlLpaFf1zXp3RTp6Hc03ye0zEDb41rbjG3WkNLWc9JnbCPpPWubsY2k96xtxq6lZlPk+z6am5tFd8joaJHffa5vjeB3BZGuUVpHVo+7niVszy+5S4nk+tvUpG3GUlr7tXueuXlc2zyObGh5Hkc14761pDW5u/NZNM9jN/1G8Zh2/XqgrefoXp90vB6PZo2kPq6jeH2S0tpzUl+fXEvNpggAurq6AmcNgOIe+R07olhDQlM9tueX5CX9ls4trUnTNZXS2q+255n0ceSapn6jeky7nkE0PQc/QtOMbdeQ0tRzGmYsxRkHPc7t3ec09iyhacauiTZFd955Jy688ELcddddAIBf//rX+NCHPoQDDzwQy5cvd1IgERERERGRS+VBg7fccguuv/56zJ8/H9dddx2ampqwYsUKfOUrX0Fvby++973vYcqUKfjiF7/osl4iIiIiIqJQBd4U3X777bjjjjtw7rnnYv369Tj22GPxk5/8BJdccgkAYMqUKbjtttti2xR5nodJkyaJ7pAxdoL87nN9awS/K4h0jdI6snqCnteunqDs+w2ae8/1D/jerLQmbTOW0tuvJOv2cS3t2ZaW53FUMy4dK6tJvobs/Dqex9pmbLOGlLaerftVMmMb0b0mu6lH2/PYRtJ71jZj1wL/+Nxbb72FE088EQDwkY98BGVlZfjYxz7W//WTTjoJr7/+evgVBuR5Hmpra0WDrhorv/uc6zVKx2mqJyht/drUpG3GUmno13VNNo8jG1pmEOX3CS0z0Pa41jZjmzWktPWc9BnbSHrP2mZsI+k9a5uxa4E3RTU1Ndi1a1f//95vv/0wbty4AZmenp7wKhPyfR/btm0T3SGjvVl+97m+NYLfFUS6RmkdWT3uepaw7zf4XUok19+mJm0zltLbr83zzM3j2uZxZEPL8ziqGfetJa3J3Z3PND2Ptc3YZg0pbT3b9iuvR8fr8WjWcPU81jpjV9+HAM09J/d7l0uBN0WHHXYYNmzY0P+/t27dihkzZvT/702bNuEDH/hAqMVJFYvFwFkDoLcov2NHFGtIaKpHW7+AXU2arqlUWvp1XZP0ceSapn41ztj1+bV974riMZ21nu37DX6EtsccZyw50g29PQenacauBf5M0c0334yxY8cO+/UtW7Zg8eLFoRRFREREREQUlcCborlz5+7z61/60pdGXQwREREREVHUUvPLWz3PQ2Njo+gOGbX1ZaI7dvxtjeB3BZGuUVpHVk/Q89rVE5R9v0FzsutvU5O2GUvp7VeSdfu4tnkc2dDyPI5qxqVjZTXJ15CdX8fzWNuMbdaQ0tazdb9KZmwjutdkN/Voex7bSHrP2mbsWqo2RdXV1aJBj6nyhC8i7tcoHaepnqC09WtTk7YZS6WhX9c12TyObGiZQZTfJ7TMQNvjWtuMbdaQ0tZz0mdsI+k9a5uxjaT3rG3GrqVmU+T7Pt566y3BXVMM2pp6xHfF6lsj6F075GuU1pHV465nCft+g9+lRHL9bWrSNmMpvf3aPM/cPK5tHkc2tDyPo5px6VhZTe7ufKbpeaxtxjZrSGnr2bZfo2TGNqJ7TU72jF2+FiS9Z20zdi01myIAMEb6zU7nGqLza6tHWb+AvCZt11QqDf26rsnmceSStn41ztj1+bV974riMZ21npPer42k96zxmkolvWdtM3YpVZsiIiIiIiIiqdA2RStXrsTdd98d1umIiIiIiIgiEdqmaOnSpbjooovCOp2Y53mYPHmy6A4ZdY3yu8/1rRH8riDSNUrryOoJel67eoKy7zdoTnb9bWrSNmMpvf1Ksm4f1zaPIxtansdRzbh0rKwm+Rqy8+t4Hmubsc0aUtp6tu5XyYxtRPea7KYebc9jG0nvWduMXQttU7Rp0yb09vaGdToxz/NQXl4uGnSuTH5XLNdrlI7TVE9Q2vq1qUnbjKXS0K/rmmweRza0zCDK7xNaZqDtca1txjZrSGnrOekztpH0nrXN2EbSe9Y2Y9dS85ki3/exZcsW0R0ydjT1iu+K1bdG8LuCSNcorSOrx13PEvb9Br9LieT629SkbcZSevu1eZ65eVzbPI5saHkeRzXj0rGymtzd+UzT81jbjG3WkNLWs22/krvPaXo9Hs0arp7HWmfs+u5zSe5Z24xdK7c5qL29Hc888wy2b98+qJELLrgglMKIiIiIiIiiIN4U3X///TjvvPPQ2dmJfD4/4C0vz/O4KSIiIiIiokQR//jc1VdfjYsvvhidnZ1ob2/Hjh07+v9ra2tzUSMREREREZEz4k3Rtm3bcNVVV6GmpsZFPdZyuRymT5+OXC7Yh7VyOQ8TJpcFzg9cI9hls1mjtI6sHnc9S9j3G7R+2fW3qUnbjKX09mvzPHPzuLZ5HNnQ8jyOasalY2U1ufpepOt5rG3GNmtIaevZtl9PyYxtRPeanOwZu3wtSHrP2mbsmriK+fPn49lnn3VRy6gYY9DT0xP4N+MaY+D3yn6TbhRrlI7TVE9Q2vq1qUnbjKXS0K/rmmweRza0zCDK7xNaZqDtca1txjZrSGnrOekztpH0nrXN2EbSe9Y2Y9cCbYpWrVrV/9/ChQtxzTXX4MYbb8Rvf/vbAV9btWqV63qHZYxBU1MTgl5XY4BCc2/g/MA1gg5bvkZpHVk9Qc9rV09Q9v0Gzcmuv01N2mYspbdfSdbt49rmcWRDy/M4qhmXjpXVJF9Ddn4dz2NtM7ZZQ0pbz9b9Kpmxjehek93Uo+15bCPpPWubsWuBbrRw1llnDfqzm266adCfeZ4X6+8qIiIiIiIikgq0KdJy/3AiIiIiIqKw6fhkU0jEv9HXovso1hCdX1s9yvoF5DVpu6ZSaejXdU1afnt2ibZ+Nc7Y9fm1fe+K4jGdtZ6T3q+NpPes8ZpKJb1nbTN2KXDpjzzyCA4//HB0dHQM+lqhUMARRxyBxx9/PNTiJHK5HGbMmCG6Q8bEyeXiu2L1rRH8riDSNUrryOpx17OEfb/B71Iiuf42NWmbsZTefm2eZ24e1zaPIxtansdRzbh0rKwmd3c+0/Q81jZjmzWktPVs26/k7nOaXo9Hs4ar57HWGbu++1ySe9Y2Y9cCV3HLLbfg0ksvRT6fH/S1uro6LF68GCtWrAi1OAljDLq6ukQfHuveY4QfTHW/Ruk4TfUEpa1fm5q0zVgqDf26rsnmcWRDywyi/D6hZQbaHtfaZmyzhpS2npM+YxtJ71nbjG0kvWdtM3Yt8KbohRdewGmnnTbs1+fNm4d169aFUpQNYwyam5tFd8jY2SK/+1zfGsHvCiJdo7SOrJ6g57WrJyj7foPmZNffpiZtM5bS268k6/ZxbfM4sqHleRzVjEvHymqSryE7v47nsbYZ26whpa1n636VzNhGdK/JburR9jy2kfSetc3YtcCboubmZlRUVAz79fLycrz77ruhFEVERERERBSVwJuiKVOmYOPGjcN+fcOGDTjggANCKYqIiIiIiCgqgTdFCxYswA033IA9e/YM+lpXVxeWL1+O008/PdTipPb1Ttb7eQDKKjxIP+IYxRoSmurR1i9gV5OmayqVln5d1yR9HLmmqV+NM3Z9fm3fu6J4TGetZ/t+gx+h7THHGUuOdENvz8FpmrFrgX5PEQBcf/31+N3vfodDDjkEV1xxBQ499FAAwKZNm3Drrbeit7cX1113nbNCR5LL5TBlyhQU/d2B8l7Ow/jGMqs1grJZo7SOpB6XPUvY9xv8LiWl698b8FdnSWvSNmMpvf3K7j7n8nEt7dmWludxVDPuW0v2XA7as7wOXc9jbTO2WUNKW8+2/XqOHtOur/9o1nD1PNY6Y5d3ANTbc3K/d7kU+G9mjY2NePLJJzFr1iwsW7YMixYtwqJFi3Dttddi1qxZeOKJJ9DY2Oiy1n0yxmDnzp2iD4/t2eULP5jqfo3ScZrqCUpbvzY1aZuxVBr6dV2TzePIhpYZRPl9QssMtD2utc3YZg0pbT0nfcY2kt6zthnbSHrP2mbsmuifq2fMmIHVq1ejpaUFTz/9NJ566im0tLRg9erVmDlzpqsaAzHGoLW1VXSHjF07fNEdO/62RvC7gkjXKK0jqyfoee3qCcq+36A52fW3qUnbjKX09ivJun1c2zyObGh5Hkc149Kxsprka8jOr+N5rG3GNmtIaevZul8lM7YR3Wuym3q0PY9tJL1nbTN2LfCPz73XhAkTMGfOnLBrISIiIiIiipyOXyFLREREREQUk1RtiqqrqwNnPQAVVfI7dkSxhoSmemzPL8lL+i2dW1qTpmsqpbVfbc8z6ePINU39RvWYdj2DaHoOfoSmGduuIaWp5zTMWIozDnqc27vPaexZQtOMXbP68TmNcrkcGhsbRXfIyNfL7z4nuZmEzRqldST1uOxZwvb8krv7lK6/5O5zkpq0zVhKa79BZ/zemlw9rqU929LyPI5qxn1ryZ7LLu8+F83z2E2/UTymXb8eaOs5qtcnLa/Ho1kjqY/rKF6fbM6tseekvj65lpp3iowxaG9vF314bHeH/O5zrtcoHaepnqC09WtTk7YZS6WhX9c12TyObGiZQZTfJ7TMQNvjWtuMbdaQ0tZz0mdsI+k9a5uxjaT3rG3GrqVwUxQ0D3R1yO8+J3twyNcorSOrJ+h57eoJyr7foDmbF35ZTdpmLKW3X0nW7eNa76Yo6Hl1zrh0rKwm+Rqy8+t4Hmubsc0aUtp6tu5XyYxtRPea7KYebc9jG0nvWduMXUvNpoiIiIiIiMgGN0VERERERJRpqdoUjRs3LnDWA1A5Vn7HjijWkNBUj+35JXlJv6VzS2vSdE2ltPar7XkmfRy5pqnfqB7TrmcQTc/Bj9A0Y9s1pDT1nIYZS3HGQY9ze/c5jT1LaJqxa6m6+1x9fb3oDhnjJsjvPldfXx84b7NGaR1JPS57lrA9v+TuPqXrL7n7nKQmbTOW0tqv9O5zLh/X0p5taXkeRzXjvrVkz2WXd5+L5nnspt8oHtOuXw+09RzV65OW1+PRrJHUx3UUr08259bYc1Jfn1xLzTtFvu+jpaUFvh/ww2O+QeeOXpiA+YFrBPsbuc0apXVk9bjrWcL2/EHz0utvU5O2GUtp7dfueebmcW3zOLKh5Xkc1Yz71pLW5OZ7UXTPYzf9RvGYdv16oK3n6F6fdLwej2aNpD6uo3h9ktLac1Jfn1xLzaYIADo7OwNnDYC9uwykT4Uo1pDQVI/t+SV5Sb+lc0tr0nRNpbT2q+15Jn0cuaap36ge065nEE3PwY/QNGPbNaQ09ZyGGUtxxkGPc7gpgs6eJTTN2DX1Pz5X9LsCvW3n+wY9Zg+Kfleoaw+3Rm6In5gMa+0evwtFf+S3H8PuucffM+BaF/0e+F533/n94qB8aOuaveIZ92JPKGvHO+ORey7NoMe4mXFk/Qac8ftrCkNsMzZ7Yvne9f51o+q3dK6cP/KPoriYsef97d/40j/jvaIZA2H23IWiP/JfHcJ/feqK6XuXjhkD0b0mx/U81v76FPbrcd854/w7SBzP4/hen4JQuykq3bP8zpdPRdU4wc9Ltv3t/22v2oGe8sqhz+8DhZ2A1w6857UUPX43ujp7AQA/fuETI64xnB3trSjDmCHXGMp71/3JxpNHXmCYegqFVlTkht4wDNXze9e9a+OiwQdNAX688cYRS2hvb0NVzrPq99ebLhnx/AO87/rvaG9FeW7MkNGReo5rxj996bSRFyiZArz+0t/+Z3uhDZVlg18QgZH7vfulc4ZeI0C/7VU70J0rt+r3/33l8pEX2EdNcc24UGiF51dh924PO9p3oWyE75jvXfffX/rMyAsMU097oQ17yob+cYKR+v3lS+ePeP7htFftQDFXFXjG71/7Jy+eNPIBw9S0rxn39mDQDN677m0bPjni+YdTKLSiHHusHtc/f/nvR15gmHra29uwt3zov3iONON7Xh7me2aAfoHRfe+646VPBVtkiJpG8zy+/cV5I55/OIVCG8Z4Rat+f/Hy50ZeYJh62qt2oFheMWRspH5/8+dhvmcGfE0e1d9BRvE8LhRaUZ6rGjI2Us93bjx9xPMPp73QikrPt+r3//z5wpEXKHn/63HVDvSUD90voPfvILdvtH8ej+rvmS+dPeL5h9NRtRNeZ9/f6V39XiPPaPmNSe/zxhtv4IMf/GDcZRARERERkRKvv/46DjzwwNDPq/adookTJwIAtmzZgrq6ukDHzJkzB2vXrg28hjQfxRqa8h0dHZg2bRq2bt2KfD4fez02eY01ZW0GSZ9ZFmegbWacQfh56TGcQfx5ziDevM31d11T1vKFQgHTp0/v3yOETe2mqHS7wLq6usAPvrKyMtEDVZqPYg1teQDI5/NqZpDFmQHJnkEaZgZkawYaZwZwBmHmbY/hDOLLl3AG8eUB2fWPoqas5QF3v9YkVXefW7JkidN8FGtoy0tprF9bTVmbQRpmJqWt/jTMTErbNdKWtz3G5fmZD5+2HpKet6Gth6TnXVL7maKOjg7U1dWhUChY/UsKjR5nED/OIH6cQfw4g/hxBvHjDOLF6x8/1zNQ+05RZWUlli9fjsrKoe8eR+5xBvHjDOLHGcSPM4gfZxA/ziBevP7xcz0Dte8UERERERERRUHtO0VERERERERR4KaIiIiIiIgyjZsiIiIiIiLKNG6KiIiIiIgo07gpIiIiIiKiTCuPu4Dh+L6PpqYm1NbWwvO8uMshIiIiIqKYGGOwc+dOTJ48Gblc+O/rqN0UNTU1Ydq0aXGXQURERERESmzduhVTp04N/bxqN0W1tbUAgM2bN2PixIkj5n3fx9atWzFt2rRAu0dpPoo1tOWLxSIefPBBzJs3DxUVFbHXk8WZJX0GaZhZ1magcWacQbh5m2M4g3jzAGcQd156/TX2kPR8W1sbZs6c2b9HCJvaTVHpR+Zqa2uRz+dHzPu+j4aGBuTz+cCDkOSjWENbvlgsoqamBvl8PvA3YE31a6wpazNIw8yyNgONM+MMws3bHMMZxJsHOIO489Lrr7GHpOeLxSIAOPtYjWeMMU7OPEodHR2oq6tDS0sLJk2aFHc5mVQsFrF69WosWLAg8DcAChdnED/OIH6cQfw4g/hxBvHi9Y9fa2sr6uvrUSgUAr1hIqX+7nPde02g//bu8fFuczv27vGd5N97jO/7gWo3xqC9vR1B953a8lIa69dWU9ZmkIaZSWmrPw0zk9J2jbTlbY+R0NZz0vM2tPWQ9LwNbT0kPe+a2h+fK/nx1T6qxuwNmK4C0C04uzTfd8zUg4u44LoxI759Vxp2Pp8P9FaftryUxvq11ZS1GaRhZlLa6k/DzKS0XSNtedtjJLT1nPS8DW09JD1vQ1sPSc+7pv6dIo3++qrBrg4du1oiIiIiIhod9e8UzT0DGD9+5DKN8dHVuw3VZVPgeSPv9aR5AOgp+njst30/OtfdBaAu0GFERERERKSY+k1R1VhgfH2QTQ5Q2T0O1WNyATdFsjwAFLvl7w6NGzcu0XkpjfVrqylrM0jDzKS01Z+GmUlpu0ba8rbHuDw/8+HT1kPS8za09ZD0vEvqN0VBeV4ONZXB71InzZeOAXoD53O5HOrr6xObl9JYv7aasjaDNMxMSlv9aZiZlLZrpC1ve4zL8zMfPm09JD1vQ1sPSc+7lprPFBnjY/feVhgT9M5wsnzpGAnf99HS0hL4bnXa8lIa69dWU9ZmkIaZSWmrPw0zk9J2jbTlbY+R0NZz0vM2tPWQ9LwNbT0kPe9aajZFANDd0+k0b6OzU7aGtryUxvq11ZS1GaRhZlLa6k/DzKS0XSNtedtjXJ6f+fBp6yHpeRvaekh63qVUbYqIiIiIiIikuCkiIiIiIqJMS9GmyENVRR2AoL/8SZqHMAt4nofx48cH/oVU2vJSGuvXVlPWZpCGmUlpqz8NM5PSdo205W2PkdDWc9LzNrT1kPS8DW09JD3vWoruPuehasx4Z/nSMdL8+PGymjTlpTTWr62mrM0gDTOT0lZ/GmYmpe0aacvbHuPy/MyHT1sPSc/b0NZD0vOupeadImN8dO5pFt19TpIvHSPh+z6am5tFd+HQlJfSWL+2mrI2gzTMTEpb/WmYmZS2a6Qtb3uMhLaek563oa2HpOdtaOsh6XnXUrMpAoCe3j1O8za6uroSnZfSWL+2mrI2gzTMTEpb/WmYmZS2a6Qtb3uMy/MzHz5tPSQ9b0NbD0nPuzTqTdGjjz6qqiEiIiIiIiKJUW+K5s2bhzfffDOEUoiIiIiIiKIX+EYLH/3oR4f8856eHvzd3/0dqqqqAADPPfdcOJWJeageMxEQ3H1Olocw2/cBskmTJonuwqEpL6Wxfm01ZW0GaZiZlLb60zAzKW3XSFve9hgJbT0nPW9DWw9Jz9vQ1kPS864F3hS9+OKLOPXUU/Gxj32s/8+MMXjhhRdw8skno6GhwUmBQXmeh8qKWmf50jHSfG2trCZNeSmN9WurKWszSMPMpLTVn4aZSWm7Rtrytse4PD/z4dPWQ9LzNrT1kPS8a4F/fO7RRx/Fq6++Ct/3ccMNN2D58uW48cYbkcvlsGTJEixfvhzLly93Wes+GeNjZ1eT6O5zknzpGAnf97Ft2zbRXTg05aU01q+tpqzNIA0zk9JWfxpmJqXtGmnL2x4joa3npOdtaOsh6Xkb2npIet61wJuiuXPnYt26dfjLX/6CE044Aa+//rrLuqz0+kWneRvFomwNbXkpjfVrqylrM0jDzKS01Z+GmUlpu0ba8rbHuDw/8+HT1kPS8za09ZD0vEuiGy3U1dXhnnvuweLFi3HiiSfijjvuUPNzgERERERERDYCf6bovS666CKceOKJOO+889DT0xN2TURERERERJGx2hQBwMEHH4ynnnoKO3fuRD6fD7MmSx7GVjVAcvc5WR7CbN8HyBobG0V34dCUl9JYv7aasjaDNMxMSlv9aZiZlLZrpC1ve4yEtp6TnrehrYek521o6yHpedesN0UAkMvlUFdXF1Yto+J5HirKqp3lS8dI89XVspo05aU01q+tpqzNIA0zk9JWfxpmJqXtGmnL2x7j8vzMh09bD0nP29DWQ9Lzro36l7dqYYyPwu4torvPSfKlYyR838dbb70luguHpryUxvq11ZS1GaRhZlLa6k/DzKS0XSNtedtjJLT1nPS8DW09JD1vQ1sPSc+7lppNEdD3e5Nc5m24rklbzxrr11ZT1maQhplJaas/DTOT0naNtOVtj3F5fubDp62HpOdtaOsh6XmXUrUpIiIiIiIikuKmiIiIiIiIMi20TdHKlStx9913h3U6Cx5qqw+A5O5zsjyE2b4PkE2ePFl0Fw5NeSmN9WurKWszSMPMpLTVn4aZSWm7RtrytsdIaOs56Xkb2npIet6Gth6SnncttE3R0qVLcdFFF4V1OjHP85DzykWDkORLx0hrKi+X1aQpL6Wxfm01ZW0GaZiZlLb60zAzKW3XSFve9hgJbT0nPW9DWw9Jz9vQ1kPS866FtinatGkTent7wzqdWN/d5LYK7z4XPF86RsL3fWzZskV0Fw5NeSmN9WurKWszSMPMpLTVn4aZSWm7RtrytsdIaOs56Xkb2npIet6Gth6SnneNnykiIiIiIqJMs/rlre3t7XjmmWewffv2Qbu7Cy64IJTCiIiIiIiIoiDeFN1///0477zz0NnZiXw+P+DnAD3P46aIiIiIiIgSxTPC35p0yCGHYMGCBfjWt76FmpoaV3Who6MDdXV1WLOyGfsfUB/oGGN8eF7wnwiU5nuKBitvLwIALr95DCbuP/Kxvu8jlwu+hqZ8sVjE6tWrsWDBAlRUVMRej01eY01Zm0HSZ5bFGWibGWcQfl56DGcQf54ziDdvc/1d15S1fGtrK+rr61EoFJDP5wOvEZT4M0Xbtm3DVVdd5XRDZMMYA9/0BP7NuNJ86RhpTT09spo05aU01q+tpqzNIA0zk9JWfxpmJqXtGmnL2x4joa3npOdtaOsh6Xkb2npIet418aZo/vz5ePbZZ13UMkoGO7veBhD0wkrzEGb7ht3U1CR6cGjKS2msX1tNWZtBGmYmpa3+NMxMSts10pa3PUZCW89Jz9vQ1kPS8za09ZD0vGuBPlO0atWq/v9/4cKFuOaaa/Dyyy9j9uzZg95CPOOMM8KtkIiIiIiIyKFAm6Kzzjpr0J/ddNNNg/7M87xYf1cRERERERGRVKBNkZZfqjQS6W/EjeI36LquSVvPGuvXVlPWZpCGmUlpqz8NM5PSdo205W2PcXl+5sOnrYek521o6yHpeZfEd5+Lis3d51yzuftcktneaYXCwxnEjzOIH2cQP84gfpxBvHj946fm7nOPPPIIDj/8cHR0dAz6WqFQwBFHHIHHH3881OIkjDEo9naJPtwlyZeOkdbU1SWrSVNeSmP92mrK2gzSMDMpbfWnYWZS2q6RtrztMRLaek563oa2HpKet6Gth6TnXQu8Kbrllltw6aWXDrkzq6urw+LFi7FixYpQi5Mx2LVnOyR3n5PlIcz2Dbu5uVn04NCUl9JYv7aasjaDNMxMSlv9aZiZlLZrpC1ve4yEtp6TnrehrYek521o6yHpedcCb4peeOEFnHbaacN+fd68eVi3bl0oRREREREREUUl8Kaoubl5nz9DWV5ejnfffTeUooiIiIiIiKISeFM0ZcoUbNy4cdivb9iwAQcccEAoRdkqy8k++CbN25B+GE9bXkpj/dpqytoM0jAzKW31p2FmUtqukba87TEuz898+LT1kPS8DW09JD3vUuC7z1155ZV49NFHsXbtWlRVVQ34WldXF4499licfPLJ+OEPfxhKYbz7XPx4p5X4cQbx4wzixxnEjzOIH2cQL17/+Km5+9z111+PtrY2HHLIIfjOd76DlStXYuXKlbj55ptx6KGHoq2tDdddd13oBQZljMHe4k7Rh7sk+dIx0pp27pTVpCkvpbF+bTVlbQZpmJmUtvrTMDMpbddIW972GAltPSc9b0NbD0nP29DWQ9LzrgXeFDU2NuLJJ5/ErFmzsGzZMixatAiLFi3Ctddei1mzZuGJJ55AY2Ojy1pHYNDV3QbJ3edkeQizfcNubW0VPTg05aU01q+tpqzNIA0zk9JWfxpmJqXtGmnL2x4joa3npOdtaOsh6Xkb2npIet61ckl4xowZWL16NXbs2IHXXnsNxhgcfPDBmDBhgqv6iIiIiIiInBJtikomTJiAOXPmhF0LERERERFR5FJ1p4DysqqRQ6PI26iurk50Xkpj/dpqytoM0jAzKW31p2FmUtqukba87TEuz898+LT1kPS8DW09JD3vktU7RRp5Xg7jqoJ/pkmaLx0D9AbO53I50eestOWlNNavraaszSANM5PSVn8aZial7Rppy9se4/L8zIdPWw9Jz9vQ1kPS866l5p0iYwz2dLeLPtwlyZeOkdbU3i6rSVNeSmP92mrK2gzSMDMpbfWnYWZS2q6RtrztMRLaek563oa2HpKet6Gth6TnXUvNpggw2FMsAIK7z8nyEGb1PZiy9iKosaaszSANM5PSVn8aZial7Rppy9seI6Gt56TnbWjrIel5G9p6SHretRRtioiIiIiIiOS4KSIiIiIiokxL1aZoTPk4p3kb48bJ1tCWl9JYv7aasjaDNMxMSlv9aZiZlLZrpC1ve4zL8zMfPm09JD1vQ1sPSc+7lKq7z9VUTnKWLx0jvftcfX19YvNSGuvXVlPWZpCGmUlpqz8NM5PSdo205W2PcXl+5sOnrYek521o6yHpeddS806RMT52722FMb6TfOkYCd/30dLSAt8Pdpy2vJTG+rXVlLUZpGFmUtrqT8PMpLRdI21522MktPWc9LwNbT0kPW9DWw9Jz7uWmk0RAHT3dDrN2+jslK2hLS+lsX5tNWVtBmmYmZS2+tMwMylt10hb3vYYl+dnPnzaekh63oa2HpKedyk1Pz4XtWI30L1337cQ9H2Dnm4P3XsNcrmRbzeoLV8sGvg9Zejea2D8+OuR5jXWlLUZpGFmWZuBxplxBuHmbY7hDOLNA5xB3Hnp9dfYQ9LzI/29e7Q8o+Xm4O9TKBQwfvx4/H/3vIbGxpE/+2OMj46uvyJfPfV/PvsTbh4AisVerL4r+GeKiIiIiIho9PYWd+L/+e1BaG9vR11dXejnV/tOUWtrKwDg9M8dFHMlRERERESkQWtra7Y2RRMnTgQAbNmyJXDjc+bMwdq1awOvIc1HsYamfEdHB6ZNm4atW7cin8/HXo9NXmNNWZtB0meWxRlomxlnEH5eegxnEH+eM4g3b3P9XdeUtXyhUMD06dP79whhU7spyuX6fqStrq4u8IOvrKxM9ECV5qNYQ1seAPL5vJoZZHFmQLJnkIaZAdmagcaZAZxBmHnbYziD+PIlnEF8eUB2/aOoKWt54G97hLCl6u5zS5YscZqPYg1teSmN9WurKWszSMPMpLTVn4aZSWm7Rtrytse4PD/z4dPWQ9LzNrT1kPS8S2pvtNDR0YG6ujoUCgWrf0mh0eMM4scZxI8ziB9nED/OIH6cQbx4/ePnegZq3ymqrKzE8uXLUVlZGXcpmcUZxI8ziB9nED/OIH6cQfw4g3jx+sfP9QzUvlNEREREREQUBbXvFBEREREREUWBmyIiIiIiIso0boqIiIiIiCjTuCkiIiIiIqJM46aIiIiIiIgyTe2m6NZbb8UHPvABVFVV4bjjjsMzzzwTd0mptW3bNnz+85/HpEmTUF1djdmzZ+PZZ58dMnvZZZfB8zzccsst0RaZIo8//jg+85nPYPLkyfA8D7///e/7v1YsFrF06VLMnj0bY8eOxeTJk3HBBRegqalpwDn+8pe/4Mwzz0R9fT3y+TxOPPFErFmzJuJOkmtfMwCA5uZmfOELX8DkyZNRU1OD0047Da+++mr/19va2nDllVfi0EMPRXV1NaZPn46rrroKhUIh4k6S69vf/jbmzJmD2tpaNDQ04KyzzsIrr7wyIPPJT34SnucN+O+yyy4bdK6f/exnOPLII1FVVYWGhgZVvwxQs9tuuw1HHnkk8vk88vk8jj/+ePzhD38AEPwxvmXLFixcuBA1NTVoaGjANddcg56enjjaSZx9XX8AeOedd3D++edj//33x9ixY/HRj34Uv/3tb4c81969e/HhD38Ynufh+eefj6iD9PnXf/1XeJ6Hf/qnfxr0NWMMPv3pTw/5mrF27VqccsopGD9+PCZMmID58+fjhRdeiKbohLvxxhsHfZ8/7LDD+r9+xx134JOf/CTy+Tw8z0N7e/uA4998801ccsklmDlzJqqrq/HBD34Qy5cvR3d3t7gWlZuiX//61/jqV7+K5cuX47nnnsNRRx2F+fPnY/v27XGXljo7duzA3LlzUVFRgT/84Q94+eWX8b3vfQ8TJkwYlL3vvvvw1FNPYfLkyTFUmh67du3CUUcdhVtvvXXQ13bv3o3nnnsON9xwA5577jn87ne/wyuvvIIzzjhjQO70009HT08PHnnkEaxbtw5HHXUUTj/9dLzzzjtRtZFo+5qBMQZnnXUW3njjDaxcuRLr16/HjBkzcOqpp2LXrl0AgKamJjQ1NeG73/0uNm7ciJ/97Gd44IEHcMkll0TdSmI99thjWLJkCZ566ik89NBDKBaLmDdvXv81Lrn00kvx9ttv9//3ne98Z8DXv//97+O6667DN77xDbz00kt4+OGHMX/+/ChbSaypU6fiX//1X7Fu3To8++yz+NSnPoUzzzwTL730UqDHeG9vLxYuXIju7m48+eST+PnPf46f/exn+N//+3/H2FVy7Ov6A8AFF1yAV155BatWrcKLL76Is88+G5/97Gexfv36Qef6+te/ztfmUVq7di1uv/12HHnkkUN+/ZZbboHneYP+vLOzE6eddhqmT5+Op59+Gk888QRqa2sxf/58FItF12WnwhFHHDHg+/wTTzzR/7Xdu3fjtNNOw7XXXjvksZs2bYLv+7j99tvx0ksvYcWKFfjJT34ybH6fjELHHnusWbJkSf//7u3tNZMnTzbf/va3Y6wqnZYuXWpOPPHEEXN//etfzZQpU8zGjRvNjBkzzIoVK9wXlwEAzH333bfPzDPPPGMAmLfeessYY8y7775rAJjHH3+8P9PR0WEAmIceeshluan0/hm88sorBoDZuHFj/5/19vaa/fbbz/z0pz8d9jy/+c1vzJgxY0yxWHRZbmpt377dADCPPfZY/5+ddNJJ5stf/vKwx7S1tZnq6mrz8MMPR1BhNkyYMMHceeedQ37t/Y/x1atXm1wuZ955553+zG233Wby+bzZu3dvJPWmzXuv/9ixY83dd9894OsTJ04c9H1o9erV5rDDDjMvvfSSAWDWr18fVbmpsXPnTnPwwQebhx56aMjvO+vXrzdTpkwxb7/99qDXjLVr1xoAZsuWLf1/tmHDBgPAvPrqqxF1kFzLly83Rx111Ii5NWvWGABmx44dI2a/853vmJkzZ4prUfdOUXd3N9atW4dTTz21/89yuRxOPfVU/OlPf4qxsnRatWoVjjnmGPzDP/wDGhoa8JGPfAQ//elPB2R838f555+Pa665BkcccURMlWZXoVCA53kYP348AGDSpEk49NBDcffdd2PXrl3o6enB7bffjoaGBhx99NHxFpsCe/fuBQBUVVX1/1kul0NlZeWAf716v0KhgHw+j/Lycuc1plHpx7ImTpw44M9/9atfob6+HrNmzcKyZcuwe/fu/q899NBD8H0f27Ztw4c+9CFMnToVn/3sZ7F169ZIa0+D3t5e3Hvvvdi1axeOP/74ITPvf4z/6U9/wuzZs9HY2NifmT9/Pjo6Ovrf7aBghrr+J5xwAn7961+jra0Nvu/j3nvvxZ49e/DJT36y/7jm5mZceuml+MUvfoGampqYqk++JUuWYOHChQP+7lmye/dunHvuubj11lux//77D/r6oYceikmTJuHf/u3f0N3dja6uLvzbv/0bPvShD+EDH/hABNUn36uvvorJkyfjwAMPxHnnnYctW7aM6nyFQmHQa0kQ6jZFLS0t6O3tHfBNFgAaGxv5o0EOvPHGG7jttttw8MEH4z//8z9x+eWX46qrrsLPf/7z/szNN9+M8vJyXHXVVTFWmk179uzB0qVL8bnPfQ75fB4A4HkeHn74Yaxfvx61tbWoqqrC97//fTzwwAND/tgjyRx22GGYPn06li1bhh07dqC7uxs333wz/vrXv+Ltt98e8piWlhZ885vfxBe/+MWIq00H3/fxT//0T5g7dy5mzZrV/+fnnnsufvnLX2LNmjVYtmwZfvGLX+Dzn/98/9ffeOMN+L6Pb33rW7jlllvwH//xH2hra8P/+l//y+rnybPoxRdfxLhx41BZWYnLLrsM9913Hw4//PBBuaEe4++8886Qr9Wlr9HI9nX9f/Ob36BYLGLSpEmorKzE4sWLcd999+Gggw4C0Pejvl/4whdw2WWX4ZhjjomzjUS799578dxzz+Hb3/72kF//yle+ghNOOAFnnnnmkF+vra3Fo48+il/+8peorq7GuHHj8MADD+APf/gD/5EsgOOOO67/x3Nvu+02bN68GR//+Mexc+dOq/O99tpr+NGPfoTFixeLj+W0Ms73fRxzzDH41re+BQD4yEc+go0bN+InP/kJLrzwQqxbtw4/+MEP8Nxzzw35s7TkTrFYxGc/+1kYY3Dbbbf1/7kxBkuWLEFDQwP++7//G9XV1bjzzjvxmc98BmvXrsUBBxwQY9XJV1FRgd/97ne45JJLMHHiRJSVleHUU0/Fpz/9aRhjBuU7OjqwcOFCHH744bjxxhujLzgFlixZgo0bNw56J+69fwGfPXs2DjjgAJxyyil4/fXX8cEPfhC+76NYLOKHP/wh5s2bBwC45557sP/++2PNmjX8bFEAhx56KJ5//nkUCgX8x3/8By688EI89thjAzZGfIy7s6/rf8MNN6C9vR0PP/ww6uvr8fvf/x6f/exn8d///d+YPXs2fvSjH2Hnzp1YtmxZ3G0k1tatW/HlL38ZDz300ICfDihZtWoVHnnkkSE/x1XS1dWFSy65BHPnzsU999yD3t5efPe738XChQuxdu1aVFdXu2wh8T796U/3//9HHnkkjjvuOMyYMQO/+c1vxJ/T3bZtG0477TT8wz/8Ay699FJ5MeIfuHNs7969pqysbNDnLC644AJzxhlnxFNUik2fPt1ccsklA/7sxz/+sZk8ebIxxpgVK1YYz/NMWVlZ/38ATC6XMzNmzIih4nTBMJ8p6u7uNmeddZY58sgjTUtLy4CvPfzwwyaXy5lCoTDgzw866CB+7s7CcDMwxpj29nazfft2Y0zfZx2/9KUvDfh6R0eHOf74480pp5xiurq6XJeaSkuWLDFTp041b7zxxojZzs5OA8A88MADxhhj/v3f/90AMFu3bh2Qa2hoMHfccYeTetPulFNOMV/84hf7//e+HuM33HDDoM8CvPHGGwaAee6556IoN3VK1/+1114b9NnG0tcXL15sjDHmzDPPNLlcbtDrc1lZmbngggviKD9x7rvvvv5r9t5rWPp7zxVXXDHs34FOOukkY4wxd955p2loaDC9vb395927d6+pqakx99xzT0ydJdsxxxxjvvGNbwz4s5E+U7Rt2zZz8MEHm/PPP3/ALCTUvVM0ZswYHH300fiv//ovnHXWWQD63s34r//6L1xxxRXxFpdCc+fOHXQb3L/85S+YMWMGAOD8888f9DO28+fPx/nnn4+LLroosjqzpPQO0auvvoo1a9Zg0qRJA75e+kxFLjfwp19zuRx834+sziyoq6sD0Pfzzs8++yy++c1v9n+to6MD8+fPR2VlJVatWjXkvzLS8IwxuPLKK3Hffffh0UcfxcyZM0c8pnSr4dK7oXPnzgUAvPLKK5g6dSqAvltJt7S09H8PIxnf9/s/VzfSY/z444/Hv/zLv2D79u1oaGgA0Pc5r3w+P+SP4NHIStd/uO/zZWVl/d/nf/jDH+Kf//mf+7/W1NSE+fPn49e//jWOO+646IpOsFNOOQUvvvjigD+76KKLcNhhh2Hp0qWor68f9GNYs2fPxooVK/CZz3wGQN9rci6XG/DTNKX/zddkuc7OTrz++us4//zzAx+zbds2nHzyyTj66KNx1113DXreBGa1lXLs3nvvNZWVleZnP/uZefnll80Xv/hFM378+AF3uKFwPPPMM6a8vNz8y7/8i3n11VfNr371K1NTU2N++ctfDnsM7z43Ojt37jTr168369evNwDM97//fbN+/Xrz1ltvme7ubnPGGWeYqVOnmueff968/fbb/f+V7ub07rvvmkmTJpmzzz7bPP/88+aVV14xX/va10xFRYV5/vnnY+4uGfY1A2P67rK1Zs0a8/rrr5vf//73ZsaMGebss8/uP75QKJjjjjvOzJ4927z22msD5tTT0xNXW4ly+eWXm7q6OvPoo48OuH67d+82xhjz2muvmZtuusk8++yzZvPmzWblypXmwAMPNJ/4xCcGnOfMM880RxxxhPnjH/9oXnzxRXP66aebww8/3HR3d8fRVqJ84xvfMI899pjZvHmz2bBhg/nGN75hPM8zDz74YKDHeE9Pj5k1a5aZN2+eef75580DDzxg9ttvP7Ns2bKYO0uGfV3/7u5uc9BBB5mPf/zj5umnnzavvfaa+e53v2s8zzP/9//+3yHPt3nzZt59LgQj3fUS7/vpgj//+c+msrLSXH755ebll182GzduNJ///OdNXV2daWpqcl9wwl199dXm0UcfNZs3bzZ//OMfzamnnmrq6+v7f0rj7bffNuvXrzc//elP+++8u379etPa2mqM6bs78kEHHWROOeUU89e//nXA9yoplZsiY4z50Y9+ZKZPn27GjBljjj32WPPUU0/FXVJq3X///WbWrFmmsrLSHHbYYSP+2Ak3RaNTegv4/f9deOGF/S9qQ/23Zs2a/nOsXbvWzJs3z0ycONHU1taaj33sY2b16tXxNZUw+5qBMcb84Ac/MFOnTjUVFRVm+vTp5vrrrx9wi+HhjgdgNm/eHE9TCTPc9bvrrruMMcZs2bLFfOITnzATJ040lZWV5qCDDjLXXHPNoB8bLRQK5uKLLzbjx483EydONIsWLRpwa1wa3sUXX2xmzJhhxowZY/bbbz9zyimnmAcffNAYE/wx/uabb5pPf/rTprq62tTX15urr76at6UPaF/X3xhj/vKXv5izzz7bNDQ0mJqaGnPkkUcOukX3e3FTFA7ppsgYYx588EEzd+5cU1dXZyZMmGA+9alPmT/96U9uC02Jc845xxxwwAFmzJgxZsqUKeacc84xr732Wv/Xly9fvs/XirvuumvY71VSnjFDfHKYiIiIiIgoI9TdkpuIiIiIiChK3BQREREREVGmcVNERERERESZxk0RERERERFlGjdFRERERESUadwUERERERFRpnFTREREREREmcZNERERERERZRo3RURERERElGncFBERERERUaZxU0RERERERJn2/wPYnoTwRNZRUAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the wavefile\n", + "# First, get the path to the wavefile from the cwodmr_pulser object\n", + "path = dev.directory + \"/\" + cwodmr_pulser.wavefile_name\n", + "# Now plot the wavefile, but only channels 1 - 4\n", + "visualization.plot_dpg11_wavefile(path,\n", + " plot_channels=[1, 2, 3, 4],\n", + " grid_spacing=[64, 8])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that the waveforms are loaded, and look good, we can start the pulser. This will start the waveforms that were loaded in the previous step. And we should see this same output on the data generator." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Start the pulse sequence, which will just run on a loop until you stop it.\n", + "cwodmr_pulser.start()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, when we want to stop it, we can run the stop function. This will stop the data generator from outputing anything." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Stop the output for the pulser to stop the looping.\n", + "cwodmr_pulser.stop()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "DPG11_Lib", + "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.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}