02_images_3d.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><center>SimpleITK Tutorial</center></h1>\n",
    "\n",
    "# 3D Images with SimpleITK\n",
    "\n",
    "Author: José D. Tascón-Vidarte \\\n",
    "Email: jota@di.ku.dk \\\n",
    "University of Copenhagen\n",
    "\n",
    "Objectives:\n",
    "- Learn how to create images with SimpleITK\n",
    "- Reading images and show its properties\n",
    "- Plotting images with numpy and matplotlib\n",
    "\n",
    "The documentation of SimpleITK is available at https://itk.org/SimpleITKDoxygen100/html/index.html\n",
    "\n",
    "This tutorial is based on the Notebooks provided by the Insight Software Consortium. http://insightsoftwareconsortium.github.io/SimpleITK-Notebooks/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Cloning files\n",
    "\n",
    "Open the files to be used from github."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !rm -rf /content/registration_tutorial/\n",
    "# !git clone https://github.com/josetascon/registration_tutorial.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Libraries\n",
    "\n",
    "Import the libraries to be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install simpleitk           # install simpleitk in colabs\n",
    "\n",
    "import SimpleITK as sitk         # simpleitk library\n",
    "import os                        # os library, used to read files\n",
    "import sys                       # sys library, used to include local py files\n",
    "import numpy as np               # array and matrix library\n",
    "import matplotlib.pyplot as plt  # plot library\n",
    "\n",
    "from ipywidgets import interact, fixed # jupyter widgets libraries\n",
    "\n",
    "# sys.path.insert(0, '/content/registration_tutorial/') # local library path\n",
    "from local_utils import image_info, imshow_2d # local file local_utils.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Image Class\n",
    "\n",
    "The most important class in SimpleITK is the Image Class. Several algorithms (functions) use this class as an input parameter.\n",
    "\n",
    "The constructor of the image class is: sitk.Image(...)\n",
    "- A monochromatic 3D image is created with four inputs: width, height, depth, PixelIDValueEnum.\n",
    "- An RGB or any other multichannel image is created with the imputs: [width, height, depth] , PixelIDValueEnum, channels\n",
    "\n",
    "An example of this is:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_3D = sitk.Image(128, 128, 64, sitk.sitkInt16)\n",
    "image_3D_RGB = sitk.Image([64, 64, 64], sitk.sitkVectorUInt8,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more information of the Image Class see file [01_images_2d](01_images_2d.ipynb) of this tutorial.\n",
    "\n",
    "The image_info() created before can be called to summarize the information of an image. This function is stored in file [local_utils.py](./local_utils.py) and imported here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Image Information =====\n",
      "Pixel type: \t\t16-bit signed integer\n",
      "Pixel channels: \t1\n",
      "Dimensions: \t\t3\n",
      "Size: \t\t\t(128, 128, 64)\n",
      "Length (mm): \t\t(1.0, 1.0, 1.0)\n",
      "Total Elements: \t1048576\n",
      "\n",
      "\n",
      "===== Image Information =====\n",
      "Pixel type: \t\tvector of 8-bit unsigned integer\n",
      "Pixel channels: \t3\n",
      "Dimensions: \t\t3\n",
      "Size: \t\t\t(64, 64, 64)\n",
      "Length (mm): \t\t(1.0, 1.0, 1.0)\n",
      "Total Elements: \t262144\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(image_info(image_3D))\n",
    "print(image_info(image_3D_RGB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading a 3D Image\n",
    "\n",
    "The method to read images with SimpleITK is: <b>sitk.ReadImage(...)</b>\n",
    "\n",
    "SimpleITK support different image formats such as:\n",
    "- Raw format (.mhd or .mha)\n",
    "- NIFTI format (.nii)\n",
    "- DICOM series (.dcm)\n",
    "\n",
    "The images used here are found in the local folder [images/](./images/)\n",
    "\n",
    "Credits:\n",
    "* training_001_ct.mhd: http://www.insight-journal.org/rire/\n",
    "* mni_icbm152_t1_tal_nlin_asym_09a.nii: [http://www.bic.mni.mcgill.ca/](http://www.bic.mni.mcgill.ca/ServicesAtlases/ICBM152NLin2009)\n",
    "* Dicom Series: http://www.giveascan.org/\n",
    "\n",
    "\n",
    "\n",
    "### Example reading a Raw file. \n",
    "\n",
    "This format is also known as ITK MetaImage format. A example of reading one file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Image Information =====\n",
      "Pixel type: \t\t16-bit signed integer\n",
      "Pixel channels: \t1\n",
      "Dimensions: \t\t3\n",
      "Size: \t\t\t(512, 512, 29)\n",
      "Length (mm): \t\t(0.653595, 0.653595, 4.0)\n",
      "Total Elements: \t7602176\n",
      "\n"
     ]
    }
   ],
   "source": [
    "prefix = './images/'\n",
    "# prefix = \"/content/registration_tutorial/images/\"\n",
    "\n",
    "image_mhd = sitk.ReadImage(prefix + 'ct/training_001_ct.mhd') # http://www.insight-journal.org/rire/\n",
    "print(image_info(image_mhd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The format .mhd refers to the header of a raw image. This header contains information about the encoding of the data. If you open this file directly as a text file you can read the information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ObjectType = Image\n",
      "NDims = 3\n",
      "BinaryDataByteOrderMSB = True\n",
      "AnatomicalOrientation = LPH\n",
      "ElementSpacing = 0.653595 0.653595 4.000000\n",
      "DimSize = 512 512 29\n",
      "ElementType = MET_SHORT\n",
      "ElementDataFile = image.bin\n",
      "\n"
     ]
    }
   ],
   "source": [
    "file_mhd = open(prefix + 'ct/training_001_ct.mhd','r') # open the file as a regular text file\n",
    "print(file_mhd.read())                               # Detail the header content\n",
    "file_mhd.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The file has the information how the bytes of data are stored. This file refers to another file where the actual image information is saved. In this case to the file 'image.bin'. SimpleITK automaticaly read the file and identify the data in order to read the image.\n",
    "\n",
    "Another type of raw format is .mha. In this format the same file stores the header and also the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example reading a NIFTI file.\n",
    "\n",
    "The NIFTI image is downloaded from the dataset MNI-ICBM, and the template ICBM 2009a Nonlinear Asymmetric template. This data is part of a collection of MRI atlas templates for pediatric studies that represent the average anatomy for the age range of 4.5–18.5 years. The image to read is an MRI scan T1-weigthed image, mni_icbm152_t1_tal_nlin_asym_09a.nii:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Image Information =====\n",
      "Pixel type: \t\t32-bit float\n",
      "Pixel channels: \t1\n",
      "Dimensions: \t\t3\n",
      "Size: \t\t\t(197, 233, 189)\n",
      "Length (mm): \t\t(1.0, 1.0, 1.0)\n",
      "Total Elements: \t8675289\n",
      "\n"
     ]
    }
   ],
   "source": [
    "image_nii = sitk.ReadImage(prefix + 'mni_icbm152_t1_tal_nlin_asym_09a.nii')\n",
    "print(image_info(image_nii))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example reading DICOM series.\n",
    "\n",
    "Digital Imaging and Communications in Medicine (DICOM) is the standard for the communication and management of medical imaging information and related data. For a description see the [Wiki](https://en.wikipedia.org/wiki/DICOM). The typical format of DICOM files is .dcm. The DICOM files to read are from the dataset Give a Scan, study 4, series 3.\n",
    "\n",
    "Since, several files in a folder represent an image, it is necesary to read all the files. The following example show this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DICOM files: ./images/Series3/IMG00000/IMG00000, ... , ./images/Series3/IMG00000/IMG00055\n"
     ]
    }
   ],
   "source": [
    "path = prefix + 'Series3/IMG00000/'  # path where the dicom series files are.\n",
    "files = os.listdir(path)            # list with all dicom files\n",
    "files.sort()\n",
    "path_files = []\n",
    "for file in files:                   # create a list with path/files names\n",
    "    path_files.append(path+file)     # append the files names. The file name is path/file\n",
    "print('DICOM files: ' + path_files[0] + ', ... , ' + path_files[-1]) # print first and last file names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the list 'path_files' is used to read the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "===== Image Information =====\n",
      "Pixel type: \t\t32-bit signed integer\n",
      "Pixel channels: \t1\n",
      "Dimensions: \t\t3\n",
      "Size: \t\t\t(512, 512, 56)\n",
      "Length (mm): \t\t(0.666016, 0.666016, 5.0)\n",
      "Total Elements: \t14680064\n",
      "\n"
     ]
    }
   ],
   "source": [
    "image_dcm = sitk.ReadImage(path_files)\n",
    "print(image_info(image_dcm))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This format is not very handy since a single file is splitted in a series of files. In order to have a unique file is possible to write the image to a regular Raw or NIFTI format."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing a 3D Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SimpleITK also support image writing. The method to read images with SimpleITK is: sitk.WriteImage(...)\n",
    "\n",
    "As mentioned, the write nction is usefull to create a single file from the dicom series. This can be done with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "sitk.WriteImage(image_dcm, prefix + 'lungs_ct.nii')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, to use a single file in the Raw format we store the image with the extension .mha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "sitk.WriteImage(image_mhd, prefix + 'training_001_ct.mha')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Conversion \n",
    "\n",
    "A Numpy array can be obtained with SimpleITK. Similar to the example [01_images_2d](01_images_2d.ipynb) of this tutorial. \n",
    "\n",
    "A numpy array can be obtained back and forth with the functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "(56, 512, 512)\n",
      "14680064\n"
     ]
    }
   ],
   "source": [
    "image_npa = sitk.GetArrayFromImage(image_dcm)   # Get NumPy array from sitk.Image\n",
    "image_itk = sitk.GetImageFromArray(image_npa)   # Get sitk.Image from NumPy array\n",
    "\n",
    "print(image_npa.dtype)\n",
    "print(image_npa.shape)\n",
    "print(image_npa.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot 3D Images in 2D\n",
    "\n",
    "Transforming sitk.Image to NumPy also enable plotting with Matplotlib. Matplotlib provides an object-oriented API for embedding plots into applications. Considering that the images are in 3D, this enable 3 views typically used in medical imaging. These are the axial, sagital and coronal view. Some useful functions are declared to perform this.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set of functions to visualize a 3D image\n",
    "def imshow_axial(range_z, image_itk, flip = False):\n",
    "    # Scale the image with the pixel size and spacing in mm\n",
    "    spacing = image_itk.GetSpacing() # scale in mm\n",
    "    size = image_itk.GetSize()       # pixel width and height\n",
    "    extent = (0, np.ceil(spacing[0]*size[0]), np.ceil(spacing[1]*size[1]), 0) #image limits\n",
    "    \n",
    "    image_npa = sitk.GetArrayViewFromImage(image_itk) # get numpy array\n",
    "\n",
    "    # Create a figure with the axial\n",
    "    if flip:\n",
    "        plt.imshow(image_npa[-range_z,:,::-1], extent=extent, cmap=plt.cm.Greys_r)\n",
    "    else:\n",
    "        plt.imshow(image_npa[range_z,:,:], extent=extent, cmap=plt.cm.Greys_r)\n",
    "    plt.title('Axial image')\n",
    "    plt.axis('off')\n",
    "    plt.show() # Draw the axial image\n",
    "    return\n",
    "\n",
    "def imshow_sagital(range_y, image_itk, flip = False):#, image_itk):\n",
    "    # Scale the image with the pixel size and spacing in mm\n",
    "    spacing = image_itk.GetSpacing() # scale in mm\n",
    "    size = image_itk.GetSize()       # pixel width and height\n",
    "    extent = (0, np.ceil(spacing[1]*size[1]), np.ceil(spacing[2]*size[2]), 0) #image limits\n",
    "    \n",
    "    image_npa = sitk.GetArrayViewFromImage(image_itk) # get numpy array\n",
    "    \n",
    "    # Create a figure with the sagital\n",
    "    if flip:\n",
    "        plt.imshow(image_npa[::-1,:,-range_y], extent=extent, cmap=plt.cm.Greys_r)\n",
    "    else:\n",
    "        plt.imshow(image_npa[:,:,range_y], extent=extent, cmap=plt.cm.Greys_r)\n",
    "    plt.title('Sagital image')\n",
    "    plt.axis('off')\n",
    "    plt.show() # Draw the sagital image\n",
    "    return\n",
    "\n",
    "def imshow_coronal(range_x, image_itk, flip = False):#, image_itk):\n",
    "    # Scale the image with the pixel size and spacing in mm\n",
    "    spacing = image_itk.GetSpacing() # scale in mm\n",
    "    size = image_itk.GetSize()       # pixel width and height\n",
    "    extent = (0, np.ceil(spacing[0]*size[0]), np.ceil(spacing[2]*size[2]), 0) # image limits\n",
    "    \n",
    "    image_npa = sitk.GetArrayViewFromImage(image_itk) # get numpy array\n",
    "    \n",
    "    # Create a figure with the coronal\n",
    "    if flip:\n",
    "        plt.imshow(image_npa[::-1,-range_x,:], extent=extent, cmap=plt.cm.Greys_r)\n",
    "    else:\n",
    "        plt.imshow(image_npa[:,range_x,:], extent=extent, cmap=plt.cm.Greys_r)\n",
    "    plt.title('Coronal image')\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These functions can be used to display the loaded 3D images. Test each image by removing the comment line.\n",
    "\n",
    "<b>Note:</b> These functions are stored in a local file called [local_utils.py](./local_utils.py) for further usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "62ccb8d4e399490c9fa6e4b23074d980",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=27, description='range_z', max=55), Checkbox(value=False, description='f…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "af754bca546d4e0981f8f5d70ac9f584",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=255, description='range_y', max=511), Checkbox(value=False, description=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "887e72c8b1254cbd8a6dbbf21e461ec0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=255, description='range_x', max=511), Checkbox(value=False, description=…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# image = sitk.ReadImage(prefix + 'training_001_mr_T1.mha', sitk.sitkFloat32)\n",
    "# image = sitk.ReadImage(prefix + 'training_001_ct.mha', sitk.sitkFloat32)\n",
    "# image = sitk.ReadImage(prefix + 'mni_icbm152_t1_tal_nlin_asym_09a.nii', sitk.sitkFloat32)\n",
    "image = sitk.ReadImage(prefix + 'lungs_ct.nii', sitk.sitkFloat32)\n",
    "\n",
    "interact(imshow_axial, range_z =(0,image.GetSize()[2]-1), image_itk = fixed(image));\n",
    "interact(imshow_sagital, range_y =(0,image.GetSize()[1]-1), image_itk = fixed(image));\n",
    "interact(imshow_coronal, range_x =(0,image.GetSize()[0]-1), image_itk = fixed(image));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extracting a Slice from a 3D Image\n",
    "\n",
    "Voxel values can also be accesed with array index. This allows to easily extract slices from 3D images. The next example show this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQYAAAD8CAYAAACVSwr3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsnclvZFl2n08Eh5gYHJM5VCYqqwe05FEwvBQMeOO9ATcMD5AX3mhpNRowDBjwzpIBS5D3XjZasmFA1v+grQwPkOAJ7lZXV1dWZnIegnOEF+zv8nuHL8ggM7OKmckLECQj3nt3Ovec3/mdc+9rjEajuC/35b7cF5fmN92A+3Jf7svdK/eK4b7cl/tyqdwrhvtyX+7LpXKvGO7Lfbkvl8q9Yrgv9+W+XCr3iuG+3Jf7cqncK4b7cl/uy6Vyrxjuy325L5fKvWK4L/flvlwq0990AyIiGo3GffrlN1R++MMfxnA4fCfPbjbP7Y6f//u///vvpK77cn0ZjUaNSa9t3IWU6HvF8PWUH/zgB990E6LZbF5SRPfK4usp94rhvkREVRHULUiX/P1V1/s7/p70epfRaBSNRuPS//eK4t2Ue8XwkZU3UQBvs9Q9+yb11V1r5XGvMN6s3CuGj6Bc5RY0m804OzsrC2qSBVuHAsY9+zbI4ibXT6JM7pXEzcu9YviACwrhJlDfSuJNy7tGJDdFGL/3e79367o+tnKvGD6g8oMf/KAs7qmpqWsXzbtQCn5m5gVu84x3ec89khhf7hXDB1DeJILwLniEqampODs7i4hz5TCJkqpr0yRtG3ftTfp1ryAul3vF8B6XSRTCbRf+bYhAchGuQyxvWxm9SbTD390riItyrxjeszIpOnhT4m/S577p896kvMt6PnYlca8Y3pOSFcJNF8XXtVhvUjLSeBvI5m0ruY9VQdwrhjteskIwoTepL/62F8uk99+WfHzT8i7Coh+bgrhXDHe0XOcyvImlfNvlbbRl3D2TPutt5FbcI4iLcq8Y7li5LvfgXSuArzO3YNJnfdNu08e4weteMdyRgkKYBH7fRml83enNV10z6fVnZ2cxPT1dQp+TltuESG9TPuSkqXvF8A2X2+YgvMskoK/DLfkmUMC7cr8+RAVxE8Vwf1DLWy52G3LJnzWbzcpntxHoOtJtkuveRbltwtO47+v+vq7OSdowGo2unB/a9lu/9VvXPutDLfeI4S2V6zY1fZPE3VWf3yZt+iZRALsAk7RpkvaMc2EmRQ8fa6r1PWL4mstNXYdmsxnXKeRxgnuVlZ30ftrA/1NTU1e2dZIyrr5Go1G+G4du/PlwOLykFDJ6yNfXfX5VmyLi2vHP5S4ccvN1lnvE8IblLgrMTUnB2zzXZRwxaHfhJqjkTdrsFO43ybfIhPGHkPtwTz5+DeU2aczXQds3XRCT+tdZ4K9aRG9jX8bXHS6tSxjzsyIm4yKuqvd9VBD3rsQ7LjdBCXWwd9w1b2rZx5FqERcLIisAXIlxBuJdbNaa1D25aRvcx3EKYDgcXlIU17Wn7vu7iBTfZrlXDDcs+Ri1q0rd91f5877vqkVeV/DNr1M+de2q8+vfpFzn64/jSeqiNnVl3GLO/El+Tl2kw4piHJcxbkw/ZOVw70pMWDgw5Tbw+Ka5/L7muu3OwOY6P/9dZAve5nm08U2jM2+aBDbpPo+6666r433Iebh3Jd5ywTLcluWuu2+S6MJ1KCDiwjWwT31VvdcV7q/rz6Q5E9nyorgm9evH1TkOEVw1lr7/qmiHSx2qG1c35UPLebhXDNeUcXAxC/ltoHidQNfB3kkKFu26xXvd87l/kv5MEn6koBxy3W4Pf09NTZXF6b/H1Zs/u8nYXaUAJ1GOlEajET/84Q8nrveul3tXYky56U7IST972/D+fS/ZVaCgmID1IKfrSM13EdXJCi+7Rv7+Loc1712Jd1TqYPp10L0uoSjfNwkkf9PyNurIRuRttI/FlBcmdQ2HwxiNRnF6ehpTU1MxMzMzkdswKfKC6PW8uJ9GYo56cA+/31Zk6a6Ue8SQSiYZ68ptycTbFJ47jjh7G/W+i52L40i/urwJW167HHW5HVNTU9FsNuPk5GSiut9WH3I7J0WBdwk53Cc43bJM8kan25xg9K4Ete67Oss76b6Db7LkPIuzs7OxEQkQxunp6SXFOWm05+tU4ndFOdy7ErcoEEfZX8wlWzqXSSDuTe7L300SFcjtvk6JXce2R9x8X0FdqevzuFwNPs8RCc/NaDSK6enpCtJwf+rq9LMmKW7fJHOWkQ3lfcx3uFcMUX0V/FWMNGUc+z6pwOXFexUK8IEmbpOhf90iyuW2m7YibhZxuWox5j43Go1LB7Zgba+LPLg/+dlXRUe4d1J+ZBx3cN145X69b8rho1cMVgouk2YR5mKBu2rf/6SWzem9/tuClxfMTZHO2yxXjU1dn90u+lvXB+dX5L8nUYwZRdUpk6w8J1WItMPh2Loxfp+Uw0etGH7wgx9M5I+O+2wSOHmd5av7/6rrrwupXZcQNalSmrTcNu9iXDHx6OL8CqIADmNe1Tbuzws/j6sV702iOLTB7sw45fS+KIePVjG8yRufMjE2rrzNBVj3nEnckXFtqkMeETfnE24bpqtzLeyX1y3QOgtf195xrsRNkrbG8TmT9HMc2uHe90E5fJSKYdKJGaf1b5vlyP3XlauuuQl6iLjsWmSLnHdW3ibicttrUbB857Z5geaFNW4OpqamYnp6uuQ78PdN2pdzGCjXuScudbkruBc8/65nSX6UiuFNSrYo4yyay03Rwm2s0rj7M9Su23Y9iTK4LcN/1eLKbRunPOvyGNxmFALPOzs7K7kSXH9dAQHe9k3e/vuqyNZtN5N93eWjymMw0ThuciZJYiFacJOEozcRhpvce9VpSg4R8n12Ja7qN//nFOW69t00nyCTkXXHy9v6cwy93YlxbWG/xfHxcW29uX/M7Tg+xpGrqw6EqUvkssI6OzuL0WgU/+7f/bsrx+ltlZvkMUy/y4bctTIJnJ8kPHWVZRm3qMYJrcubhEFt8Qxd69qZIXlm6WdmZuLs7CxOT09rFzwLggVXl4U4qVLIYzLOUNHWzCtkpVCnsFEy09PTl/pU14ZxSqEO8Vw1pxnV0A7aeZfLR4MY3oTwedvWflJrGnGRl+9NRRH1C4+Fmq+xQNa1BeXgTMLZ2dkYDodxenpauZbvrXzGsfDXjUnd7/w8f8d4wE14TK4aY+61EuP7cWcvTHJmZJ1Su+r0qKue+3VkR96nRKdym52S/i5DSxbfmx44mov9YS9qW0sKi9lW9CqlMa5v464Fplup8IMPT5mdna1YYvqBv39dn2l3PrfBiz/vrqxr3zjl4PGrczNOT09vlTZet8vyKmR43XPetXK4VwwqbyM0NIkLMKmvfdWzgPA38c3fVtsjqvzE7OxsUQAsrJmZmXLd0dFRecb09LlH2mg0otVqFSIQd+Pw8DAODg4qCgCXhM/824vUOQJZaTSbzYJorjp1KUderuKZJlnk/oxn141hvsd1U7JiepfK4X6vhMpVfILDR1cdIuKwWi4WCgsHZRKlQHhtEkh+U7emrk35e8N0/rc1ZnF5PGZnZ0t72BLd6XSKoB8fH8fR0VEcHBzEyclJBWIzZicnJxU4b4XBQgGJ1CnMzAt4jNw3kF1dRGbceI3jmvJnuV11x+txD31FqXF/vvYulA8aMUziQtgd8GRZkCOqVuYm/ucklmdqaqr4+Pm7XMbB9JsqjOvcJxY8f09PT0er1YrDw8M4Ojoqn2dSzdl/42B+VkYmQFEKdS5IHfpyO8dt567jXd7GGGUOI7c7oxiTjigQjx/XvKvzI+9diRi/B6KuZDgdcREam0QwJn32uO8RjuuehwLxRqProPCkxQvL/jtKgZ/9/f1Li9auBL9NJBqVOeHKi8ZuxuHh4bUuGP/jtuTIyFVKpO77q+6lfZPwSeOUwbh7s4vBOLyLEOZHrxjyYStZK0fc7nTlbCWuEqyIel8WqO06cSOuItJYACiQ2dnZEpe/bRvr+uwFPRwOY2Zmprg6JycncXh4WPu8uoJyzYgsK4qIqrs2LgQ6ru0kOOGejLvnqhyJXCY5GCdHi7KimyTP5SpF/rb5hvs8hrjsB1IML7kuT/S4iRqnaOqg8rjvsB7+7OTkJGZnZ2vhLhbbrD8L6Ko2uq7rrhvH3tuNGA6HlXBmXalbHOPgvfuRxxvUMq6+PA+OkoB24CqMWq4ygkaKJE/VKRD6cx2CqLuGZ7tNfj3AbdHeuyh3h+14SwW0MK6YVLKA2qLw/bhttDnH3z4zn/laeAHfk0tGEREXlrAuKce/x5VJ02/d/hz2PD09jZOTk4l89DpyDwWcMy7zs3IbrgsfRtRnbZ6ensbZ2VlpM4w/P7g9dVus7Qrx7HHKJHNQlBxSztcgCyDAvJfDZPY3udnqg3IlbvIq+qvIvRx+qrN42V246rlXhdJcENrh8GILMMKd77W/fFV/6spV14IOTNpZYd2ExLvOlbkq9Xgc7Oe+cRxQ3bMiLkct7HJ4Lu1i1qU7O5V50hyWulcAGp3l+XWdbzNl+qPkGIwUruMHrvqs7j4nF9URSbflG+rut4XxdSzQiAsf/DroOWn/fA2KweWqDMOryriYvuuOGD9fdtnG9ZMxqQv7eaHnyI/zNK4rk4xvXXYqSq8uWmH3wd+PU5K/+7u/e207rysfLcdwldB64SEgkwh5nSD6WZCBXtC2ggiLibgMN7kun8qU/W7qzG0b14/b9A/IbyvGoqL+6xSb2577cZU7UdcuUrOx0rQFNOU20v66BZrrwnXDVcsL08hhXNvNN9SNBXWa0KU9VnjwS5YXj983Ybw/CMQwyZHvuYyztpPCfn/nMGLO5nPasomnjESyL26BzMy3SblJ0cJV1jnfR/15YdGGSRTDVX9nd83fZyVExqUzL80J8VmeM48tRgAFgzInwQrlMBqNroyGeAxcTx3nkRX5Va4piIYo0zg35U2jFB8lYshQPGvycfxCFtw6n7fOGpoomyQHwc+y1WeRQIyhSCCpRqNRWRhWDBS7OBZ+2uWEoTqCNPfNVt7KKo9hXZ+4N49V/py2zM7OlrGcnZ0th6u02+3KgStuS8R5eNcRpDq+wUlTVrT+nPEZDodxdHQUx8fHcXx8HIeHhyU0i8Lw88dFWZi3HCEx8VpH0DabzTg6OipK0XN1kxDr2yzvPWK4CXNrq3TdOQTjCjsYs396FZmJwExPT8fMzEzMzs5W/udvKxwWwzgEE3F596S3ShNN4PfR0VFh6lkQ3HMTbuY2JK77RZ9nZmai1WpFq9WKZrNZlEEeh7okKBATpU4Z8XlGLY4+8HwjI8jA09PTODg4KKndg8GgfG6FYlnKEQZIUivy6whLjEMmJenHm6CGj4Z8zAevZD89lzyJ49Ju61KiryPgEOpWqxW9Xi9arVZ0Op1ot9tlkft52eWgZMH2Z+P8WYfZ8ve2kBHnwnp8fHxJYQyHwzg+Pi7KxNDXP9mtsbvET7N5Ho6bnZ2N2dnZaLVaRSG2Wq2Ku5AX/nWuSo4W8Ixspa9KFsvFvIJTla2YUbpnZ2exvb1dEMVgMCiKwsrWzx43r7n+3FbcJPNYb6IcPhpXoo4IiohLC7qOfKqLq3ON4ZsZbT7DMszMzES73Y5OpxPz8/PRbrcLHPYiRdj5nd2JbIHrzkCIiBKJ4P+6MBclKz4vxE6nU+E+aCPxfwSR/73Zye4JSsCKD0TQbDYrY2GF4jqvclPqUsWtSBhHEpL8PO9UHZeQlrkOnsE8ZyRg5TYajeLg4CD29/djMBjEYDCIo6OjSvQoK9jrSEyu42/mm6zTr5OIfG8Rw2/91m9xb8Wa2rpa+D1h14WpLDhYEBRGq9WKdrsd8/PzsbCwEO12u9RjljovWib8piQp7TGKuUnI9Lr68v4L7qkrV5G0dX9bkOtQUR05WlfXVX3KvI8VQUYZdZZ5XL7CVXkKKEDGDXdje3s7dnd3CwrDTavL/syf1RG9FDgVy9RtUMNHgRhM1vF/9hHtDlhIczjL+QEQVXw/MzMTy8vL0e/3o9vtlkniZxzxmAXfiyV/V8dUU1BKpOj6b5fsUhmd1LWH/+tg77hU5AyLc5QlE8B1dY+D01e1k+9NOJrUzH2tm486xeR05Lo22C2x65RD3c1mM+bm5qLf7xeXY3t7O/b29mJ/fz8ODw8vhaI93yiyccl1IAeiJ19HeS8RA4Sj01vHQUVbc75jsCnEkflsZmYmFhcXY3FxMebm5qLT6VSEz6z2VQva5arFX3c991y3y9PPGqeg8nfjsvfyFupxpB7Pu0oBuH4v5KxcspLO41F337hn19Vb19+MDKxo/V3uc164dUoLIhk37ODgIF69ehVHR0dxdHRUUWC5ZPSSFReGCzm9KWr44BGDIwMRF5Obk3KIDXuvAkrEWpr70PpLS0uxsLAQEeeTPm5HYd5TP06gIi7vW8hkVya+QDx1z6LUWdcMT60k+cxIyQtrXKQm92ucZc7/1/n2+e9Jw3BefPlZdQvNSttcQeZ4cr/zond/J0Fpo9GohB7hIzqdTgwGg3j9+nUMBoPiZrjkubQByn2qS7F+2+W9Qww/+MEPChnjkq2HU15tKSIuNvdAmj18+LCgAyzCJIkuEVcnRFl4zT9YAdi9uW6RZH+ahZ+3N2flkLmW7AoZJmdXyvzDVUQh6A03JPMW7qfdKivWcS6Hw4DmkXyvyUfcgLzQcnt9vduXycms4MahlNxuFxuPnZ2dWFtbK6dbeazHoR/nN3g+b5Iq/UEjBkcIXLIVM8GY/ftmsxndbjcWFhZiaWkper1eREThJlyugqt+Nm3LyMHfIWzjLFCuK0NXvgMN1e3Mo02ZT8ECZfieQ2Jca4ORFY4VU44w8LzcjmxVs/Jw352p6AVO/flgGEcTTELWKRf6eXx8XKyvx8T8gZPGPEd5bj13/tx9A53OzMzEyspKdLvd2Nraiu3t7XIeZk6vz3JkWcBleVflvUIMcAv5kJK6xVvH5Dab5xl28/Pz8eTJk2i32xFRjRNn4o4FMC4iMI5IxNKg6bPVqdsg5GfWlWazWUkBZpE5AsN3KAIvRNrntnrsvNBplz/L/eQeFp3hdw6F5vHJIUyenz+3YnO76Kf75f57bOiH78uEZR5nK+arokBXuXr5WisgPtvb24uXL1/G/v5+Zc9Gvt/9tjw2GpNvsPpgEUNePHU+vX3XRqNRiMV2ux3Pnj2Lubm5ysaZq+Bmtj4IrksdZESo7B7kCff/WEVDRreB5ClKHeTPn9e5FfZb6Rt11N3D57ZSfpYVTob75k7GhTX9PzxRFn7qMNFsF8yKhjmyIjK6sZLw4srktRUlqMXj4GvcrnxNXdtyG+G1BoNBbG1txdraWslQrZNv9yv39W2W9wYxgBaA0pPuT2i1WrGyshIrKysxNzdX0cp1LHyG4C51fIIXgUsdz2BLla1AnngTpnWL3EJeZ339v5VonWKrs+BeeG6L+3d4eFjIOy8Sj1Ve4EYy2eXJi93PmkTpMW6uIytQ/89nJiAxKDlVPPv2Plinbo7riM86NICSw4VaX1+Pra2tQlIy1hl55oSuSQ6Q/WARQ8SFv+gFNY6warVa8fz585ifn49Go1HehQDrX8dGZwIos99Z83NeY74uw1e3dRzktnVzCjUCaUvmhKf8jOxiWMgjqsrD/rmfwfixmckoiH7Mz8/H2dlZSQs+PDysLJ46AnLc39mCuy3ZpfN9RnG4ehkJ0dfsOpizsWGoc524NvNW+TqPsdvpRW35oq7T09OYmZmJR48eRbfbjc3NzVhfX68oLRRSo9EoR/K/K8P+3ikGQ1ejBgZ7eno6lpeXY3V1NRYWFioDy3WZ8PL9EVXyrc7V8IJn9x1C4Bz7iItFnS1O9p0zMkBAs8VFIdT58Ia/2fXx374PCD87Oxtzc3MFCUDCEXt3iJjFxP2tVisajUb0+/2Siky6cB5vW39K5kZc6harlQOfYXEN7R0hqUMRRnAoh3a7XWSmjny07NWVOpeTeogAjXNfGduFhYVYXFyMfr8fm5ubsbOzU8jSjAjr0OrbKO+FK/HDH/6wkuyRX4lGmZqaioWFhfj2t79drmUyflnPpWfXaW+Th2pj+Zu2ZEHLltqLPTPICIjH33X43rwoMpFoNJGRTh1f0Ol0KtucR6NR2ViFRarL38/uScR5Pr8TyVhgvJDm8PAw9vb2Kpmouc91boX7S525TQ4nZg4hx/qzIvbCsuLJChfFYDnKbc/8kJGfn1uXRDWu8LzDw8NYW1uL9fX12lPBXa5LePrgXAmTZjlJhd+zs7OxuroaDx48iKmpqULgZIHOSIGS/dpsvQ3nPMkRUYTGuRE5tyD7xlY8FmoLW7ZKhvW5nVkR2NXIgvrgwYMYDAYlTJYJv8PDw0uIB2UAIvB9dS7Z8fFx2V796NGjiIjY3t4u76XIbpLnged4cbNQQGh2I3JWK22yW+Y59Fj7Xq6xe5Y3Vrnflj8/i3b6GveP/3NSXuaepqeno9vtxuPHj+Ps7Cy2trbK9XUu6tssdx4x5PMWPJhM+vz8fHzrW98q/n7er58XPSUPaLYyJrRycoknngWTLVd2G2hLboPRA78tZCiE7LfbsmdUMT09Hf1+vyCBTKR1u92S0ZmfQb2ZE8mZd1cp1+yaobzb7XYcHBzE0dFRpV63j89t3U30wQ/hOriNtvYQoq7Hp26bM7GiqkMPPJN6/b5JGxz6kMeIurLs1ikZKxu+Ozs7i93d3Xj9+nVsbW2NVQRXoYYPCjGYO0Ao+LzZbMby8nI8evQoZmdnK9uSs4XOBGFEdeGb2Ml1Z/+eZ/tgET8v+/510JlneNH6mPY6a1+naLyASHohJLu7u1uxdu5XViTjYLcXj88mpL6MGozu8vM4/AQrzBunjAZbrVY5RSlDeuaDNo1L8DGyZO7MCaFUj4+PK33yuNgN8P2cppU5jqs4DKPOzD/5+SZNLTe4a0tLSyXNfzAYvBNugXLnFYOthoW70WjEkydPYnV1Naanp8vgZUGg2CpkLe2QkuvNGpzvUQZ1PnfdAs4cgJUDn9kHpy4/PyMZYK0FmSzOwWAQe3t75Rpbw+FwGK1W6xJHYyTA/7TDR8obNaGwvaiMdqjX+z5oeyboIi4Szebm5mJhYSH29/djb2+v4jrUWeH8HPMdjE3mnEAThB3H7T/IRoZ6cVfx+x2xsMyYDLVhyjLIZ5nzyq5hr9eLhw8fxqtXrwpJnK99G+VOuxK4EWaBR6NRdDqdePjwYTx58mTiPQ3jSoZ0EfVxY/gDIwS1v3bBW0lQF4sjuxwcAmJISp4AzxyNRuUwEHMojMmTJ09id3c3jo+Py6L1IqGuR48exf7+fnmm+RC3keLYPuPj76knIxwWug8c4U3YtM/jYLTBWE9NTcWrV6/KQSVGAaAYxotFSHsIt+b9MsfHxxXF6jHmGsbN8zgOWeFa+Duj27ooRt1n42Qx/z89PR3Hx8fx1VdfxatXry4ph3HuxAfjSrAYPeDtdjtWV1fj4cOHl+BxxOWEoTq4lQUgx/kRTD6Dwafkxc5ntqi25rZ0Rh/D4bCcAoVQY402NzfLfRy55mPXjo6OCpxGeF68eBH7+/tFEczOzlZOVKIte3t7FVINAXfGXaPRuLQL0Ak33Md1jkbY1bKSBOKjaF23EYfPreS0pMPDwzg+Pq4oEvYeoHQY14ODg5I23263Y25urlIXCopQrOUCDsHzaDk0QmF+6IuNlK2/5TejGLsxlmWjCLcv4lxRt1qt+OSTT+Lg4CA2NzffOgF5pxUDAmBfb3V1NVZXVwuUo2RolrVsRPVYNooXb/bxIqpugy037TOstsIwwsHC52e32+2ygYu2tVqt2N/fL4sUf5L9/CcnJ5Xjzq2wtre3K0To2dlZQSHwIaPRqCgGv7CWuD3Q2Lv+vAFpHNzO5Bq5EZ1OJ6ampgrZCEGMUqQO7gVRoAw3NzfL+B0cHFSse3a7HIK1m8PZk55jR45Y9CgElIP7h+LJbiL3othRpnZlHGbFdSF7sU4BuF7kjHFCISIHz58/L4bkbZY760r883/+zyv+P0Tjt7/97WLlr4NcV6EHE1kUa28E7JftK9/bWvg7X4NgZVQBxG2329Fut0s+hhXf5uZmbG9vl5RYjjX3jkOjGfv01GFuoNVqxfLyciwsLBQY7QxQ//YYoARYENnHNxR2PoHHh3ZmrobnOqSIQuD8RBZY3cnMLp4TFruPnmcMFhYWotfrVd5RgULnuHg/MysHTrOmrSx880bcC7rLMmhXLUeZ7HrUlcwh8D99/OlPfxovX74s39dtrPogXIlsYRcXF+Pp06eXSMg6hBBRn7FYV7Kfx6JyGnBWCHmCeI4hucObCCmWm8NY8zsL1tfXi1I4PDysnB2YrYbZ9dFoVDmFimvxr/v9fuzv78fBwUHF3/aLVVEO9lft8nihs6hdJ5b2qoXrwuIFqezt7ZV+WxHyfPMyOSKAW2jUgx9OHfAa3W638BIkYXW73djZ2aksVEc1nAGZEWFENUkL5GLexLJmojPflxVJJocjLrgJ5o/5/uyzz6LdbseXX355bSLUJOXOKgYEsNfrFffBWjwTgEYAmRX3whqnSExk2TWwi1CHDiwwWFomH4tC6fV6BT4irCCCwWBQstuwnnXvkazb6YefHxEVgYb429raip2dnYqgG4ZDfLqtCGtO+TZSMpynMEcQfHl++HtnZ6eiZPb29kqY0hGTOveOdpiozfUMh+dnLjSbzRgMBjE7Oxv7+/vR7/djdnY2er1e5WTvfr8fOzs7ZYzx4z3H5hRM7HpM+DEh64Wa5w4Ukkn0OgU7jtzEBfrkk09idXU1fvrTn8abljvpSvzLf/kvo9frxePHj6Pb7Va2SWfEEHERKjKhSLHv6OsjqoMPVPxleyrW2L6p2WuEBUsVERWFYIXSarWi2+2WRcw7CUj24eBQW3Rbb0q24OMsMv1k8dO+HFWB5W6329FqtSrRAvrBj8fXEBplg+/LyUS4LFakjDv34a4dHh7GwcFBrZuY+R9b7mxBjcLyuMDh4MYR3u31euX4Ne/vMHHqkCtcCd9bVjKiof2frpurAAAgAElEQVTec2Kyu44LM4k9TrnWFZT84eFhbGxsxD/7Z/+s8v1770p873vfK29rgj2OuOy31gmaFYStjgc9TwbEnCMLTtjBd+b5Vhb2x6k3x9dHo1HMzc2VxY4fvbe3F7u7u+WNR7ZMedFbIdQpA7sHtvJEMui/lY0PQbVrYuVqX9qK0wqSZ7CgQUMmMxlrrsvtdjYi7c+hO9/r9tEWj01GNvSRRd5qtUr9KMNWqxWDwaCiWJCtTqdTmXvGEXel1WpV5IBCm3y4kBd9div4Pme+5tcS0jYneXHPzMxMPHjwIN6k3EnFAISuO2aNYrY8E4HjigXH/jLPM1lothlhcpsssEBLcwpWUktLSxERcXR0FPv7+/Hq1auiEOoOjLHFoi3OumTBWGAQFP8fESWTsI79tuWampoq78igH+x14Bon6xgxWWH4mRybnseV64zmTE5y/+zsbMmOtD/Ns6jTCsdK238zL4w3bsvOzk7ZhUvYOMN62um+kySGrKIg6JsRBPVDNjs6lhGB789ub+Z6MqqwG+xo1W3K1WdSfQPlRz/6UWUAnG1o7WirkGF+xOVzC7PyQFD42wvEVgj/z76m3Qbev+i2oUQg6IB3Ozs7lYM4CMnZWtAPC5SRhJWfkUC26h6PHKIdV+wf41ox7jmPI/vTKC/zK4w7Cuvs7KwgGLtctvYOdzK3+NPmiRgvchusxK2ojH54hucVDubVq1eFY3Dyk92EjCTM0Rip0a88J4wndbh//GTSl8Jn5KZ4jilwSvA8//E//seJ5r2u3DnEYB/MFr4ulJOJnJzSnCeBgiX0ojOc48ea32QPi8H+ulEGAs77KU5OTmJ3dze2t7dje3u7xPRpZ8S5dSRpyX2IuEy80S4r0Pn5+djZ2bm0W284PE8xxsclfs7itMuTkUImTzN3wz3MGYqr1WpV+AWTnY425AXM31hWb/JyyrIVZN2mOv62G0a9mRNgIbExicVrl9LPzW5UxIWC5mTy3D8jJoyJOTP6WMcfWA5z8fyxFkw+v0l04s4pBpM8EVEE1JZ1nOvAwHgirWRsAW2VPdHZ1SBU5ti/d1JaY0dUk1D6/X5BCl9++WUlXZn2swhg0KmfeoC1XgxuJ2O0u7tb2URmCzsYDCqQEwiM8oKQ63Q60Ww2C1qwUnTOQUZoWchnZ2dLCNBz4nvpV6vVKn/zDA4l8XiYR6JgQc1x1KEkpybTbsvMaDQqCO7o6Cj6/X7Mzc2Vw4Iz6WekQ120kTpQ8kYJlk367D0ytMfFSpv/bei4HuV5FTl5k3LnFIP9NOcS1JFumeHNiiPictKSkYKhYkYoERdH0IM+eIZRhSeDujx5u7u7sbGxUd5pmNFLxEXik60NihBr50WCYFN3zvkwfLWi8mJBKfFSlG63WxSCrzPXwsIFbWQ/3pYb5YDVMvqxsjDpSDk7O4t2u10xEnXIxREJ6vUic7stMxEXRKQX/cnJSTlU5vT0NB4+fFhBGEZF/sGqWw5BBbSDMaCNtCtHKMYpCNCfXSy7NnlM3rTcOcXgRYXQHR0dXdLaEdWtvpmIRPCYWC9qT4AnzWRPvs+Db4vNos0Rhenp6djb2ytn9+W3WXkCESDShSkIkhclioLivAja5oWXCULqZiHzpu65ublaLoI22FVyhiO/8/hFRDl8d2tr69KpW6enp+UYtWbz/Ei14+PjODg4uLS3w20xUQm/YOvNnHpBZ4TpRcvnVrIsdN5XavLVXEiWsYxqUPjmHqy8PGZ57P29S52ryfUR1TXxJuVOkY9/8Ad/UNGgZrTrBoFiqIrQ2/oCOU3g2Q9EgNhG6/tarVZlIVj4KLTTyqfRaMTLly/j5cuXsbu7e6n9jcZ5arSJN/LfCaUhQCsrKxUhxB2C1BsOzw9mtXI0B+BFZutIvwkNu5/0EQRRpwj8PPvmWLV2ux0rKyslP8KoZWpqqmR2npycxGAwqJCp5igyEnJbsvtn+cAV9Byz4HCf7AZQ4DdevXpVOTXJ9bDgDw4Oyi5Y+/xWSrieKPD8HMuzx9VotM5Nzpxa3Rj86Ec/ituUO4UYxg2WCayIKuTKfmcO/5jttVBbmTAREHMIsF0Et4Uf5wsYbo5Go9jf3y85/ybksDa4Jr7fbXPW4+vXr0vdWDSTcREXiUtZkGxBiC64X5z/aF7CSrCOR/GCdJ0QcEZtU1NTMTc3V/rA5yAhFp3nzfxInetoHsabvWgDi9Gcg8cP1p7w5PT0dDkYxjK2v79fDM3CwkLlXAqjKCM/0qH9vV0v+Bgn7dE3+sHuT48vKIY+Mmbmgmh3HrfblDulGByqylwBAwQ8i7i8gQirheA69GhBjri8nRUrElF/vFe2lCxwKx8U2s7OTiUN2VDfwjQYDIoAuw9Y6ZzMQ8ES2X9mm7Yto4UWREI7+dtKKFsgt4lnZEVsBJatN3119qpDimzXtjLLaNDFc4K82Nc2x8PzMwKyK4mCyIjDURbSqUlQ4/vp6emy9yTiYpGC+lyneRnzV8hoJkwzoUidKLycZzGOU8jG4yblTimGulBTRP2GEgQgFwTcbDCTbE1rK4dlY4KyBqY++A4EB1/Yi217ezvW19dL8hKTmbkN2m7L1mg0ypZjfP7BYFCuz75+o3EeWjSL73GIuAjnUR97MLiGNtb5yJlc9ALkelssLCFz6fMTuDf79pnT8RxQQDZEbqzscjvyORN+Vv6/LgPTnw+H5zsvX79+Hc3meUi42+2W64mo2HXjfxY9Y2H3lb8d6bHxyONj98kyVDcnyDOG67blTikGo4Rs8fjMm6jQqNnNgF3PWXe29hagiOrJzYafzWaz8A62xFgNC/zu7m5sbW3F/v7+JUVUR+zRJhOKWPzDw8Oyf8FHtPs6YCcHrGJJ4A1slRyPt68NsZuRQFbMXuD+XUduci9KyXNaR4rBzRwdHV1CUBH1vnSeM8tAfoN0NiRWonXtqVMS6+vr5e9Op1PhrnAR6UsmxR0e5xrabKOV25TJXKOwnIHLTlEfrvMm7sSdIR/JeKSYgPFnOenGflbEhaVCc0NuOU+97kBPKxCTkpmwpD25DXt7e7Gzs1PexkR7mXD8++y3YwV5Dt8ROrOCBPbCE4xG50e9nZ6eRr/fj8XFxcpWYpSKBSX76CRFWSlYQBlH99cW2WjLFt8LgZwMlwxxcY2yUrYiswtpmGyFR31WAnUuihdclgU/Bwh/cHAQ29vbsbW1Veqk/2S3spCRUermoB0bF4wFfWT+c1v5jvGzYatDwZZv+LIf//jHcdNyZxADCwAfzVqXhVXHKdRB0YiLHAS7BBz5VWcBTbzxP4ONNWOSsg8Jg83JvSY3mUjaSN5A3prMngbH5rEMXqi4G7ZonO7EApybm4uVlZX4i7/4i9JGn4bsMTs5OYmf//zn8fTp06JU7OMaoeR2eGH6c67nh5yGcdCWMaI9nkMSr2yVjRS4P1v+2dnZEm7c2Ngoz0Vm8Pn9PIoVkK314eFhbG5uRqvVin6/H51Op8gDBCaL3XNkxY7SciRoMBgUBZHl2RyGSWPzJcgM68bXjUOr15U7oxi8oOikhdha2ALGgDrJJ6MKT7AZ6YjLfAUKxQooKwX71GyZJtxGG7IfnP3IXq9Xie3Pzc3F2tpaJYmG9riv/i4jmeHwnElH4WCFs//qRYQLtLa2Fp988kmti2AB82d5jN0uk4osBNpvxey59Pjx2350RiRWZNnq457t7e1Fq9WKXq9Xjobj2HgjNOcouE/MOQr66Ogotre3iwJmVyUGxOjMijS7thm55UXOPf4uIip15OQtyF3+zrzTTcqdUQzZv3KIB2IPKO7BYsANQ23B8huDmQxDfpNx1rguhqsmmuAVaItJP+7jNwLMWYbkSXAegKGmx8WoY9x4RVSZbhZBJtgiLmApfSIJqdPpxMLCQnmuFwljaStry+T/vZiBtt1uNwaDQYnU5LnPYTsUE0qcdnoxcYZC7l9EFBLXSM1jyNiYNzJJy/Mg8Xzv/v5+QUFzc3NlQRMxyONmGaUOyGsrPeYwKwPGBQVt5WpZsOzXPeMm5U4pBgbYUN7f2/c3XPMgZe1c54JEXAig0UFekBSsEdqaieUoNrYX22J6kfT7/djd3S3PMwzkoJZGoxFzc3OXBD1boCws8A1WgK6bn263W3uYKtcdHh7Gixcv4uDgoLycNlv3iIuTpM212Fp7DPx9r9eLRqNRQnz2j0mAyuMYEQX9cMIS98zPz5fU5Tqr7z4Oh8PKBjX6ZJfQc+7DcU3ygmhOT09jZ2cnut1uQVmOUjl/BRmzi8jfPnXLc+d2m0sx9+H/s4KoQ9k3LXeGfHTnLVT+TUFx5DMQzABbibCoySq09rXr4QVtNyYiisVBqAaDQWVTlCfQbTg5OSlRirpCHbu7u9HpdCoJSI1Go2To5TahDOBkTJQhdFYcZPBBJjLmQOuIC4HnWvu8fG+3yL+NGrKgmnwlHwADgLJg4dpdYAyOjo4qCWHswfCbrDx/oDLGzPLFZ15UzCvykRdS5lPIQeHYdtpGH5kPo0yPC3JnS2/jRD+tTPiOa2nTOHfOpO24PIeryp1ADD/+8Y8rUDuzstlV8MBEXE5W8qT4c37bZzTB4zwKL/ZMNh4dHZUIhPc50CanXxNO3NvbK8+os7BHR0fRarUq7D3tdD6AMyLp+8HBQQUp2K3xuxMsSIzP0tJSCXWam4iIWFpauuQSZYQWUeU+so9uXoGzK4DcDjF6vvOBLI68mJS2O+Axyy6Xx8aLxwqN8aD+PMbuM/ccHBzE7u5uUSb0EU4KRIOC9aKt43yopy5xzq6cxxsXm3bZ3TNn84d/+Idxk3InFIM1IoOAQGLNUAh2D2xZI6puBP9z7zgIbu1tS8V9CAuTyQs+sq9sf5QQJMLL+xozKw9E5fANb7TiPvcruxKG47kt/i5zABHn+xiWl5eL8HqX4/Hxcezv70e73Y5+v1+eEVElzXK9mcfJEYrp6fP3aqKIMszlLEYOTDEnQsoy4+vFRt4Kbkq2+JkvoUCKRlRfFgOKzGFe/ua7w8PD+OKLL+Lp06clqsS7NNgMlufPqC7PZx5H0CDXuE24LibpuZexqyMvJy13RjHQEVwEBs6sLx1FO+fQln0v8wwWFBSAz0XIYbrMZXDcO/v19/b2Kv6hBz6nF2eFYyHh+UdHR2UjDvfU8Sv+zK5LJj0RPD7DRSGKgmVZW1srEJ7wGW4abooXOAvMTLoRnt0Aw2B/Dmm3v79f6R+IazAYlHuxjpC1XMt8M055v4TlimtMNAP9cQ95XR/3eB5s6anD28G3trbK0XA8L8uTXT3qyTs8jZzqFAHXeNu1lbDRruXC0amblDuhGBhIOulJz34U8JzF500ptpT8xjJFXF7E1q4RVV+SiebI906nU05hwuLBXQyH1fMpR6P6dFnDcNpQB6ctjBkR2EJkcot2YKkajfNDTJeXl2NxcbGk925ubl46xYm/bTkRJvz8169fl0Xf7/dLZibX0CZb82wVSW3mPReMDfPoxWBL6LGhDeY5bI2ZA5NvDjPjxjjvgGczP1mh1CmJiPO3f/3iF7+IR48exfLycsUNov+OZqEo7TKweJFnhyEzcqmTVRs/99Uu0k15hjuhGDJZZStkgotOm2uIqIZyuL8u0pAJHi+MDNGnpqbKKT7N5vl5Afv7+wXuZ3eGBUtughdYHaHmchXMQ1gfPXpUTmnC+jt8Z2UHkmJBr62tlfv8hiQWgREb/Ig5n+Pj4/jpT39a3os5MzMT+/v70ev1Ynl5Oebm5i757rlv/m52djba7XYl98NGgTnNcJv2ZARYxyE0Go14+PBheQkL27hdjKqs0LKirnNDaAuEbafTKePgMzBRREYoVsA2dFk2LBd2RZExKxsKyMvKzslck5Y7oRhMJrJQHc/ODLmzF4HN9rcyykBwgHP+3wXlggtDPWh9CLq6DD7ajr9uRr5u0rnHn3MtbbDFdYjL3EedJUA4uZ7zDhhbxnU4HJYDUvg/Q9GIiJ/97GeVMyWo//DwsERTrNSzT+7fVqRA45w/4LmzO8DnhtNO2WachsNhITnhJrKi4e+6OWAM3Kdc7A4eHx/H7u5u5YxKjwVyCppApnkGhGEeM48F7YQDMkqiL5xQhkJCeeUDgCYpd0IxGObZf8U385FoTAQCg2Chmbk/M8F+FyUKBIInRzkMldmNuLe3F2traxVi0dlzLKzMMNcpBeL23vrMdd1ut3ABLl9++WX5G+GiT1xr+AssJ/7OGNVlUlK3BZRnf/nll7GxsVHhTE5PT0sIlvclZJeCayOqKbwIMMpkNBpFu92uIDFvv19YWIjBYFAh3by3wwvPCO7k5CQ+//zzyoJnPplj+p9J5zpFYIXmPmG0cDPrcgcYM7tsERdJfN6KbiRr/ox24Sra+DhUb+VHG5wROWm5E3kMCKwHnQnzAKAU0PgR9WjDBJiFxb6dWVuELeLCRSAPHuXBse9e7IQRiV9TTJDRH1tBv0R1OLw4ooz4OLDfZzIicNk1Gg6H5Y3SmX3Hjzb5RJ/dVo6/NzpC6eYj1anj7OzipTIWYtfPdRny8jeZf3a7/PfMzEw8e/YsPvnkk+j3+5W9JXYp/NsckSF1xMX5DfSPPlHsVuZ7PVfuJ7+Pj48LKe10ZLttjAXK2Ml3Vqg+bZp2+W3bPM+IBLfRc8Sc1u1Yva7cCcSAoGKNEco8YJB6Ju4odf6yJ9jQyiSUXQpzENPTFy9FJRLhSIat7fHxceXdAp7QLGT874XiRW0/F+Fw0kxEFPfAr5WD0bcwI1AzMzPlpGiUq90ju27US1uNXDKpRvg2E6hetI4UeRH6pG1bOVtPzj4AXTEuVpDmWTIZ5/+NjDwvGZL7Xhsl+mB+gH7CfRFK5Z2Xdp8YB5PHOV+B/vjavL06ow3qODs7K/kUjKOVeB1PclW5E4qBTnpbsoU3IgpxxmBaiCKqA+5Jtd/pkl+dhoCgmbEqo9Eotra24vXr1yXE5usjLiwJC4Z3POSYutvApGYCzCiDvuBycHYC42FiEkX2xRdflIxAYursDl1aWopPPvmknEWZ4bnnoi7vIhOBo9Go0qY8Jyxw+mXFYitIG8jyhPA9OTmpHLvvaw3ZzbvYpXAKO9fm6IcXlrkIP8t+useAeWQc4Z8Ib/NMK+/sAjAePvofRYnbYATA+sD9xk0w+rDR4tqbljuhGGh43iEZEZVB94QwcL4ehYCF9QBTuManOzFZ5joQ6tPT05Kya0HPpKQXDJmIRjRGE3mhmCRicr0N3FYL4aTO3d3dODs7i8XFxeJHo0xQauSC0A8geYbK9rlPTk4qW52p28UW1/f7eZnI9KK00nBb6BNj4RyVqwg7Q2xcU6Mfcx4e35z7YZSKgjg5OSn8Tx4DP5PnIIM+ydrtc1v8zOz20ndkE6RBscub3RfWRI5cTFLuhGKIuIBbJkzcSb+Y5OTkpBy6aXcDK4kwWtuaa2ChmFegDUwiioj3TZJanK1FXRgsp6menZ1V3sNIycjj5OSkwqZ7bPI9TDqCxwYjhAlhY9yazfPMQF6R7rpzm3K77R7lUufrRlQJPD43Meq6PN/sP6DfPDvnNnhx1yEZ5tjFix0rbQOR++D5zi5WxOVj8yCyzW3lBYkyszXPSg/kYsWSI1AmMpkDt93t5f6blDuhGBB0x7AtbFwDNERLIrgR1dOJzOYy8V7A9iWzUPFi142NjWJxfGwaxYoGZGGBYuMPk+JoBoLvibf/H3EenYBLYFJJ/YW8NCRHiMlDIHTKAqI+kAS7LRkjWyqjloWFhcp+Cwp98SGp9AtFbbSAwvVv8z+Mhb+zNeYat9PyQz1WPl5IRj7c61OXskIbjUaXSDsrKubW9zHv7lvExVH9boNRltGiFQOuMwrIKCvzFnadzbNl5DppuROKIS9OOomAspgYMLQ9BFYdHLUPzESy6Lz7zSFDFrvhI8fE0U5+GwJ60WRLycKtI5JsDVAuzeZ5lICsPBJWHjx4EMvLy2WvxsbGRkREiWTQLlCJx81umfvtt3K5zYzn6en56+IXFhZie3u7ohy55+HDhxUSLvv0XOsF5/t9rxWLYXQdvOc5diHNCWRraUU1Gl28lt4nLbn/jJc/85gZrWDUHNnxfbTPxDKua95PYaK00Tjfro57YjcJI4AB4NkYM36zoSu7jdeVO6EYjBSsCW0l6CSHdljb2wc1044v6kWS/bSslHBFnA+foyN1BJKL28VPu92O+fn5GAwGJemGBWFlCEdhRAJvgHA4Fm9kZUVqi5E5loioZECanLWCZdHwujj7/rOzs/HkyZNYWFio+LJWmrb+GT1kItLnKmTk4XaCvqanp0sol7E+ODioKAo/g7+ZZ/M9rjdD8ohqlivuh5W820hbHHq3krScWemZF7FMmgMBVbDobRTN07lO7/q9SbkTisFa1byAoacF2FbHDK0tvi2Rw0vcR7GVIUkn4kJJ+VX1EdWcBIe4zAyDBFhQWPXBYBDT09MlJu+j6B1e8kKFb3j9+nVsb2+Xd1FEVN/UlUnKRqNROWfR7hWLMfvvVrAsAlyT5eXlePToUeFB5ufnSzvMB5ndt+KjT1aW2SLXuQfmf/h7fn4+VlZWSsLS/v5+iQLZrTOCMbzmeR4vu6EsTrtUHmNHANxeozPut2sbEZVsWu7LBwDZQGaZ9th6XVhuPY5Gojcpd0IxRFQ3OGXImE94jrh8si/+qf1QBhsUYMjtBeHQZET1oBUrBDPqXMf9vV4vTk9PL8X9WfS2MIeHh7G4uBjD4TD29vYq0Dlrdt9vKJx9Y55NabVa8eDBgzg+Po61tbWKINvSuB8ImXkN+IWZmZlYWVkpFsh1etF6fD1PJvfyouLavBDOzs7ik08+KYeiTE2dZ6SurKzE6en5a+RwcbxZjoXtfvB8Q/k6QtXyM47PsKGgv4wBdbvvRpAYPvfZuQvZnbVcmrRlrKyAqDePNWNxk3InFEOGnggui8H531xvggu4ZYbc/jQ/nIR0dnZWGajs2zI52fe0bwjxiUXtdrvl3QO0iciGT74G6h8cHMTi4mIlQcjsf7PZLJEMLxQLtMlMxsI+drvdLuTgixcvyj3Z/3dima2TfXtcMvMSoLzT09OifI3cLJweS8aa+hlTxp8U6MXFxVhdXY3Nzc2SvEWq+i9+8Yui8HhOnqu6XAVHBSxLdWhyfn6+KB0brLOzs5LExDP4Td2MkxGL3yZuxMI4Mb9e7FZOVgQeW4ozO7kGgwNJP2m5E4rB8Ms+vbUoEwpLW6ch7aePq8OCZOjMhGTm3PdERMUyGYHwbkZDRE++IT8hxPX19Uq6s5N4vGDpowWpLuRnkmk0GsXPfvazWFxcLG+2Mv/gBC/qIxWXwph6MWV/1S6U+2kobmWBkuGFtihpBPrw8LDwR8fHx/HixYsSLmYzGIeieAzyvKPgzLFY2bFgsuXnHiy5k+q8VR0DwHjThtnZ2VhYWChGjT5ZtmgLxqndbpdEMS92PzujCv53Hg2usA1I3VqYpNwJxYDQeKGiZT3APlU3a1MPvC2//Uvus0tiLc3/5id4BqRXRDU8Rv1eLNnCR1wsIAQKLY51pD+uz4s0w+xMUNGeDHOJXoBgIqKyC4/v7GPjOlBYFNyTCdcs8CZtGXO+Zz4hADMh2GxebHY6OTmJnZ2dymlPLGyPDwuAulFU+Sg0xpE2mU/xOE5NnZ9AvbW1VfIJvFhzu+3WtdvtWFxcjL29veI2ZjKSunhu5jC8HsjHMBFLGywPEdUolxHROGN5VbkTiiGi6vfTMWAqsMwnCnkxQPB5Yu2feXAMo81y4yNyrWFgxMXOQzR0RJXIy8LpcFan06nAV7T7zMxM7O3tXQq1RlzE0VkUto7+O0NSczAs9rwfP4foKDnhByFstVrx6NGjyunJJsMohtr8zm7PaHT+gh7Shw3vefu0D4alnXzOWQ4gKsYKbsCL3WNF8aLOcJvv7IpYtrK75WczTg8ePCiLGGVqeaPezA/wnYlTn0ztAurkXsum58Fu9XtJPloTMjHT09Ml/ORIhBFFdi1YmEyY8w/yZhtrbO88nJmZKVA1M812D3xYBvUgnNzT6XQKIYkw0R+gsUk6l3GEkZUbAoX/eHp6Gs+ePSt+Oucl2KJngabdXEOsHiUwMzMTq6urJf/fitXP8fii1LMfH3Fh1ZziTtv8LoherxcrKyvx8uXLsnBZaJwNeXR0FAcHB6VO2sQ4537aTWPeLQu0BVKYsfHcZ0vMdxERy8vL8fTp07ILl+36RqRGopZr+mjURr6NUQpKysogKxwr6zqEN0m5E4rBwmQkgMa0FXToxRNjVwKhMIlphtjPckQCJTM7Oxvz8/OxsbFRogyZo+B1d0yufVOewSvrzEZnqO9dchZmRyHoq7W/91UAOdkwtbu7G4PBIObm5uL4+Lgc0lK3MYp21b1DE6Fj/Am1ZWTHYmcuQASMmy00SWMOA3oeUXRPnz6NTqcTX3zxRaW9Xsy8cMZ8FAoEHsf7QjJ6sfw5O9Hug11WK2S7Jjyv1+sVlGElQv+Z0yyrrt/kpBWmUURGszzHcwBflDM0Jy13QjHQcBYawg60BU4Dr6217X/hGxuyM9j2zSOqBI2TStjhd3x8HN/5znfiq6++is8//7yQQ5klJsmG+kAbuAgU+/NMIG3IRKJRAVaD+qenp6PX65UDZGkTCnR/f78s7Ha7HU+ePInd3d1YX1+PiOrRX5B/ERduVSbq4EY40cqf58hERJStx6QG26LxHYSei+dneno6Xr58WcYEAZ+bm4uIC6XMtnOfC8Hp11awuDRe2Nna93q9omSuIq/reBPm6OnTp7G9vR1nZ2dlw5WJVddt1zMvbLvMNpb8z9+0wxv0fDAP8806uUm5E4rh+9//fvzxH/9xRTPnl4nUkT2ZRETz4ptHXCgdx+4RQisYsul4JjD8s88+i//6X/9r2fpLGjaLiCPeDceZcJ5taJhdhMXFxXn5H+MAACAASURBVPIae2C/y3A4jGfPnsWLFy/i6OgoFhcXiwLI7gHwEqHi2Hr66cWYfWUrKHMlHG1vdwXLD4LA7chHlyH8Jsoy72DkwDz6M9wauB3ntMDf0Gbq2tzcLM/h2ohqNMfjQL8M3eFCXJhLu6FcS7jWB+M45RojxxjY/TXq9HxGVM93dCTEYXH6wH3eQAZf8/3vf7+CQK8rd0IxRFzAJTps2Jq1puP+WFLDeBN/9uU88Qxm9vFMzO3v75cTlre3tyuEqAttabVaxepkIs858SzeTqcTDx8+LG3JKIPSbrdjdXU1BoNBeQsTgszzM9qIOBd2kIKjGr7Oqd8R1Y1FrVYrFhcXo9vtVtJwHRaGbyHeb0IMS+XtzygGxtGEoTkg5tMu4WAwKAvIB88wn/ATKGvaauPiDUcoj0ajUQ7lYYGjxOv8fvpu15YFzLhHRHktYUYnHnfahMKwwTI5ST0mpFkPRkA825vSblPujGKIqL5H0my8kUFm4M1JZIY+Ii5NMoOO9bdrYP+Qe9fX1+PZs2fx6tWrwjeYx4g4n3AW7HA4LHsbEB7cIdrp1+R9/vnnFWWDorJiXF9fLxZmbW2tMNKOHDgKQz9NyFlAnD9v/gahAg2srKzE6upqZT+Cw66MwczMTEm/RijdXysF+/KG2IbvKHIrhbwNnf/zfPszFr33JTgPIXMTZ2dnZTEDy01O026TzcxLt9st7UaJQYzSDxspK7589ieoEiXmzVnIlBW5yUj6b4Rym3JnFEMm+TJBhKB4koH/hlQmeKxtbV2yEDHhuBQ7Ozsl642J7Ha7ZRMRk43AsHBYPMC3ukkxH4L/S79tgZrNZiGzIs796v39/UpYzos/opo/gYIxn2F3zNaJ8UOBTE2dpx4vLy+XRc4YMuZGclhSxoGNbuYamA/qt5DTPs+JFZ2LXUKjAFvVjOgajUZ5KQynXXv8nDHoftX1mb5aLlE+NkKbm5sVpGqjZSQScUEAey7hClDCVgiMGWOMXDPHebzd3knLnVEMhlPW9LZWdNasLgPlWLOteY4mGCFkGMuzBoNBrK6uFkg6Go2i1+uV7dAMvkOl3jFpa2c47TbYhYm4CCthhRYWFipchw8Byecf2tK43zMzM8UntzBlwXdpNs+PpmPnZKPRKJu9rEjsUqCwefeGz5msGxPqbrfbYwlaRwU8ljkxK6dqG1bz/+HhYbx69apAfnMdjBPz6XA4xTKD22R01ul0ipvKc8ng9JjlPAkUILJrBQFi8XegLbssVo7IRU5bv+k+iYg7pBiYFCxPo9EoSiGnQT98+DAePnwYP/nJT2Jra6tYhIWFhej3+zE7OxtbW1vxxRdfVKwHgmZUEnERnrNvvrW1Ff1+PzY2NorbwdmJPIPFyDbpTJBagE2E5X0a/PiIe7L+IOLqyEvDybyRCESVXSojB6C0+ZZutxvPnz+PdrsdnU4n9vf3K6di2Wp5TiC9iNA8ePCgnDBtgoyCIGdOhXMSXEABvFWLPRL0qdvtRrfbjb29vYI8HeXgf2SJXAhbaRaf3U3zEUYWLGbGnrwKfHpcShRHRhUZ5vN3o9GIb3/72zE1NRVffvll7O3tFVlDBlHCIGPzbRRH3CyXNyl3RjH8xm/8RvzBH/xBRatjne0uDIfn7wucn5+P733ve/Hq1as4PT2N1dXV6Pf7RaksLy/HcDiMn/3sZxXrbOhqaMggghz8LoWICwFgfwR+eEQ1lGXFw3cWfk8WVtAhvaOjo5IpmZl1L2BDcSspu0t2Z7xJiXaYgY84PzXq008/jYjzaMn+/n4lzMZzDOOxhPSfF7oyDxklWUFk9GfI7d9Ywenp6VhfX69AbOphzIgKWDE7ksC4ODdgOKzml9hwGAXQDxPJMzMzMT8/X/Y7sIhpn5EEixkFTz9AEnNzc/Gd73ynvBz39evXRSHwThOUEmPnxKzsqlHH97///UmWYKXcifdKUMxgAw8NEZnI3d3d+OKLL+Lhw4fx/PnzWF1dje3t7TJ4EVHi7tm6eVAtLBRQy3A4LEoH5cHuTIgerDJcAcJrGJdDZhEXL7+ZmZmJubm5IoiDwaC8L9PIBOHC2tAnJt/KgXu63W5RcigAE6u0077up59+GjMzM9Hv9yscBXDbfaAu+7zD4TDm5+dLHb1er3ItbcX6mm+hLyYFcauM7HL/j46OyvsjR6NRzM3NVaIgERduAeFDE9y4KfmMTtpNW3Io0S5Mt9stbXQOgkO8tMMLlj6xwJeWliIiioJ5+PBhPH36NL71rW9Fv9+vjAs8jl0alAPzal7jpuXOIIaI8xNvDZMyOWVB8gtJDw4Oyt78g4ODAoWdT85AWUPb8llovSh2d3fLolxcXCwx8ogLX9iTzKIwm83zvMDw0UmZhbRbWVkp78i0pcNdYEwYn+np6bIRiz70er3o9/vFcuMC5Sw4k1TPnj2LbrdbkoSOjo4qG6lyRh/KirCYeQSShZ49exaff/55SbqKiEvjbcVvzgNBZzxRAhZ2u0RHR0clepOjTf7t1G3qoX+4QSx6E+D5HAr6/+jRo+h0OpfkBpkxx0Q7cAWdg4Mi+OKLL2J9fT329vZiaWkpFhcX4/Hjx/HTn/60KPk63sAyYYNSd1jxJOVOKQazvxYYFo01Ly8j6ff70Ww2S7iw2WzGz3/+83j8+HGZPO4BMprZHycwdSxvs9ksb4229cUy9Pv94uc6OkB8nPclHB4exsHBwaUstmazGXt7e7G9vV0ECWuC8JC3gfVgrCinp+evjwPJeD+H3RrGeTQaxYMHD2JpaamQeybAIAipx/3mfhOCJyfnL8LBcqIkIPhMJEdcWEy7GZl3sNLme7Iw9/f3KyQscoTVZh6dfs3YYYR8IG9ElP44/d6ujUlH0AL1oDS9I5QxtdvEnGBAer1etNvtePHiRSGAZ2dnC4EMmZl5A88NY2kCH5R703KnFIPjyx4AoJch8cnJSaytrcXOzk7s7e3F7u5uEdKlpaV4/fp1xfc2W2sf3dEMC2Yd94AfuLCwEFtbWxERFQJta2urwmyzcKenp4sPzPFuEfUhWQgnRynsQpi/4BoUE0k6WFAXBAbEwkLpdDqxurpayM+Iy8eUOXnH6Ceimjo9Go2KUkRQef0dbbMyBv2wAHl27h/oJyIqlpeM0Yi4lNsRUX2rk/kKxqLb7RaFzaYp7rPCy6FhDNPq6uql76jHiVCnp6eFnLTCMnL0QT8Yr16vFw8fPrx0dB33gx5YD8gh8jAcXiR73bQ08mR8E6XRaJRG/NEf/VFFG5pk44eFyiYhh8SwjMvLy/HZZ5/Fn/7pn5bB/2VdFbhvQs+KxAiCH8rx8XG8fPmyZBU6fZc2I3xYSVseClbUQks9dgFwm1jYvg4W3PUzdnYZfJZFxMUCe/ToUTx58qQoMEcgIqqJVu6rCVRbUUeQtre3Y3NzM9bW1iqp1B4Dz3XO6vN4gZyIyoxGo8o+Ce5BKfEiZBOx+e1mZvuz30+dOVLB8xcXF2N5efkSsjUqsGVnvDO3Aor81re+FRsbGyVxq9FoRL/fj4iI7e3tS2/SRumZG3GfqdPE42g0mjg8cacQQ8SFRXKij1l/L1IGwj4/k7S+vl55PRtCTOFanmnYj4AAt7GCTAZWDIRgK2brYWLTVpg++sg3L0YElUM+GBcELicxRVSPUbdVGQ6Hldg9QgPnwBj5NO0cpsOq40Z4XmxFQQNe+GSBem4Zb+8DwL+nTvfRCsikZ349np+doyFwD8iRxyz324vY25sZw8XFxVhcXCz7SHzeqPtvtGLDRH9RpN1ut2RKWgGYbHVKNM9mrBy+xkVxVOY25c4pBoQfYYbxd+goD35mZxGsr776KpaXl+P169dFqOr8W0M/2mABMzno0F632439/f0SG/e1JiXtppgM40xH+hER5c3VvCeT77y4gNAWetfFPV58bgfjC1xlTFEWGSEdHh4WJWzF0G63K9wBJYfTUKp2DVE21JU5HhQgfQEZZXfK7bQL4eLxy+SlsyZxfYx8KCjx2dnZWFpaKhyXkSZ/212iPUZtRqbM36tXr0p4nvHd2dkp7XNOBhsFURy0I/fpTbyBO6cYGEQGjAExdGbS7N8ymZm5nZ+fL5Y9kza2iBne0ga7MZ4Q3qvw8uXL2N3drbDNWD9PVsRFkg2LFRfBfWRHZL7fvj0nS8MvENnge4fZWMzOhkP4+v1+9Hq90q/Dw8MKUVhncRiT4fD8MBPGmvr4nzoh6XyEnX1knkn/8On5Oys9xop+ZSRo4+G2cH+WNepjjhh/zjPgcxTp4uJi5e1bBwcHJcfFWaYO0UKcmw/AEM3MzESn0ymolPubzWblNYxOfcYtok1nZ2eFU+Jzy91typ1TDAiOYR8WDkHlOysR7mPA+Z9z+/yaNbPvRgmeTAQV7e00VASp0+kUYizn6dvFqZtkh/zyW6zzHopM+LHggLGGwOZMqJv2OtY9PT0dz549K5mDCJb9avrB8xiXHAqkDIfneR0w9SwQzrjw4bksEgpttDIzOTs1NVUJ0XGdxzji4jUC9NeQuw5t0kejzqxk+azX65U0cb5HsZKDQr8cMuWEa663QpqamiqILLueRsqWT+YHFGcZISLiCNRtyp1KcIqI+Pt//+9XNLuFBYFhc05E9WRkCwQnEQ8Gg+j1ekVpkHJt2OeYs5FJ5iHsrqCUiFJk6+WJYuH6sE6Um6MHVizch1L0SUsgFifrGCVBznkc+Qw2/zvf+U7ZJIUbgTVjIbsvoBaz6l58zIMV0XA4LCE9K0bOVeA+h069c9EuTU4jd9gVTsZ8A/3PxKHHxMrT16FAzV11u91YWloq7pPdm9FoVHIZUPaOEnQ6nZJ4BW8E8YnBY/6YB9oFh4DC5hkgY8KRVtI86zd+4zeuWmpXljuHGCIuC6KtoSEikDtHGeynDQaDWFlZKX4uQmBYi/W1gsiuRMQFs2yOIiJiZWUlTk5OKucr2sLiS9M2npvJQ9piC8aipV6UWo7G8PyIyyf9eI/E1NRU/K2/9bcKUul2u/HFF18UeLuwsBDPnz+PjY2NYuGt9DwmRlYLCwsxPz8fP/nJT2J3d7fkl5ycnMTTp0/Lvdvb2xVexP026eiShZ6x8Fia3M2ul1GUUQhzaoVHffRveno65ufnY3l5OXq9XiFsmVOIW8+xw7coD6w4n+NSLi8vx89//vPSPrt8RmvIqLmKiCjuszN0MQJvUu4cYoi4yA4jSSYfRwYUOz09LYeqUrDkKAZ84fn5+SJ0nkTuBYXYT7RLw7VeYPPz8zE/Px/dbrfiexphYPmBpYaRTvlFIXBPxAUPYouMQqmzECgLC5FZ69nZ2fibf/NvFtJzcXExXr58WVE8CwsLMRqN4vHjx0XBUb/5CishiNR2ux0PHjyIs7Oz2N7erijo58+fx8OHD8s9Xjw+uyErOBZxdi0zJ0TOid0lW36nKkdcvJvBIT6QAIql1WrF3NxcdDqd6PV6sbi4WFyJZrNZ0tZBQyhbt5MwrA/A4Yd3ftB35MBylvMhjGRtYFCqno83KXdSMfy9v/f3CkyytmeQzSOwwCIun2SEFt3e3o65ubnKgRgIOosTiJgnz9fY5/QO0JWVlVhcXIxHjx7F4uJihZnGhUBhYfEI/2XNboucrRnKwb+tiBgXXAL6f3Z2FnNzc/Hrv/7r8emnn8b+/n7Mz8+X8BhjypmKm5ubcXR0FJ999lkZS6y8lROFhcOmK3YuMj6DwSBOT0/jL/2lv1QyLC3g5iMc7jUhydzxg6JwP61A/bdTyoHq9Ic5h/txpATikNfiZX4lu7ARVR7IcoYcoKDa7Xb0er2S0OZTye1GWQEiN/TZHAmF6//hP/yHN112lXInXYmIqFgS+/9MogUUoXDKqAX39PQ0Xr58GU+ePIlXr15VoCuDb2baLDsKyc89Pj6u7MUYDofxne98JzY3N6PVapXt2pubmxERlxaU2WcvCAukfVy+9x4PCouA+/3aczZj9Xq9+Lt/9+/Gy5cvY21tLR48eBDb29slO5RX7a2srMTCwkJsbGzE1tZWtNvtePToUWxsbBQEZ/8di/rJJ5/E69evC+cCInnx4kWJ+XOc/d/5O38n/vzP/zz+1//6X5e2jxOipi/Zpcgogf5b0TB/ZBtiufN5mJYP34sBQOE/e/YsVlZWyvZ+5I9wsWUkP9+GJcvugwcPYn19Pfb39yuoGAXIPd4/kknoupIjL7ctd1YxeNC9aOv8w4jqmfqZvGw0GiXDbW5uLra3t8v9ERfsc2a4LTx8jxVgwWHN1tfX4+HDh7GyshL/5//8n0K45Q1R7ocRjBl/BCv79LQpT765BpAMz3/w4EH87b/9t2NtbS0ODw+j1WrF0dFRfPXVVwXOWvlBiAGVHz9+HBFRdpqaYOz3+7G0tBTb29vlZK2Ic0KVkO1gMIh+vx/9fj92d3djZ2cn/vpf/+vRbDbjz/7szyp5CfSBtjgxC8VvmB1RPf3IYUl8exZ99t1tDKxY+LzT6cSv/MqvRLvdLm/zIurgcy6y8Yq4SM5jXkACRCtarVbZ08K1WXEZBeXf1FeHXuoU6m3KnUuJdvmjP/qj8rddBENtPrtqoJi0mZmZePjwYZyenpaFYV/dJJujACYUsxvS7/dLohPC/OTJk1hbW4v//b//d3nHA++YsKtCnWbxIy7CYLy4xH20ZRuNRgXCcx3k08zMTPz6r/96/OW//Jfjiy++iM3NzXKIzU9+8pNCDh4eHhYicH5+Pvr9foWoRZG+fv26HLwyHA7j6dOn5Yh0u03sXSH6w2vqV1ZWipWEw/iLv/iL+LM/+7PY29sr9dkCex5NLvIduReMS4bgzD3P9m5Du2p2Sfv9fjx//jy+/e1vl5PBcSlOT09jY2OjYsVBAK7XJCfyxJygJHlfBvfRp0woW+ZQSA7zYlwcyfjH//gf166z0fucEu1izevQkWFZRNUvN5TzNWjltbW1WFlZibm5uXLyEkLn58LIwwAb4gPXR6NRscJsxOEw0aWlpfjWt75VTpHKue60CQuA5cEyOJTF4rCFw+qRJGUyr91ux2effRbf+9734ic/+UkMBoNy/NirV69iaWmpsmMPsmo4HJZzJT22PsSExUcImDaY0IW1B8HMzMzExsZGnJ2dxaNHj2J7ezvW19fjV3/1V2NmZib+23/7b+U8TeeqZJeQBUZf3Wf8eK5DaUHunZ6eVshhK1qMRrfbjV/7tV+Lx48fF0UOX4KFRwYdmjRqNQlqeSK60ev1Yn19vdRP6BlFYr7ILpXT0S3jdQr0bZQ7rRgcG8fK5vAUCsCLxlA6ovoGq4ODg9jY2Ii5ubkYDs8PB3VSCJNhUir7paRGn52dlfc7PH78uCSrcKAs25m/+uqr+B//43+UDEUEyJbCp0w3GhenIhseD4fDkrLLAuJ9jljSXq8Xf+Nv/I34K3/lr8T//J//sygYdu/5FCCfMYBfPTU1VTmqbmdnp0LmRUQ59zCiml8A1M6+N/sxNjY2Yn5+Pubm5mJ9fT1evHgRn376afR6vfiTP/mTEiHwHCMDoI+IC+XE2FiJMaYsQAjQRqNR+sUzQDvtdjseP34cn376aSwtLcXBwUHlBcatVit2d3dLBCzLhiM23mOCO0aGYqvVirW1tTg4OKiQqN6Ex1xYGdNmE+6gBBPQvvZNy512JSIi/tN/+k+V0JsXf/bZf/msykDZ5TDEBCaPRqPY2dmpKJS6MBCW2/wDY9doNGJ+fr5EJNiSjbXsdrtxcnISL1++jBcvXsTLly+Lr+yEHgoKaji8OMKcxWyijLaRqvvd7343Pvvss3j58mWxMs1ms9QP7HYOBGiHg25h5jNDDuIigsH9h4eH5Zg7Ts2ampoqZKOFut1ux9bWVjx+/Djm5+fjxYsXcXZ2FgsLC9Fut+PP//zP4//9v/9XieKYCLbCMfnIIs0ktYk85swE8Pz8fCwsLMTjx4/jk08+KQuZOeEUrK2trco5k61Wq+IqRFw+ZxFlyqE5e3t7JZU9R3UcuTB/ZD6B/lkReKcriuKqpKYPxpWIiHIKkQk6a2hK1q4mpxB0X4s1bLfbZXeb4SVpp97mbEIp1wUUnpubqxyrdnJyEtvb29HtduPx48fR7/djfn4+Xr9+XYjJvBUZWJ6jIg6DojRarVZ897vfjU8//TQajUa8ePGi5EpgpSAc4UIQvpmZmej1emUvw/r6ellkJvWIXHBUmwlAFtHh4WFxq8jvIDxoyN7tdst4cD4kYc6/9tf+WqyursZ/+S//pSAxQ2bG3GFjkB4K064alt0GgZyDdrsdz58/j4WFheh0OkVxgiJ6vV5BfhsbG+U+OAvcD/8dcXEWAihnfn4+Njc3iwxmgtQKHyRq1wSXBR6INvg+y+fbKnceMfzhH/5hRFQHPOLCWkZU36bsjEYPsokmE5gRUc44xMJ5oLN7kokluwMR5yiBg2hxB4CyTDAuzM7OTjnGC0vFIsDiGUlQnEz08OHD6Pf7cXJyUnxgICqbgRgjNklFRIHQo9GoKDVbPPqJ28NiQXGcnV0cvGp0BvMOKXtwcFAUH3WgOFFI1Mnr9zY2NuLnP/95rK+vFwIWQhTlQm4ExRDbfxtVEsJlzDqdTjmJ3KQeiGBjY6NsFKsjtL3Ijeba7XbMz8+XRC9yGHI41iS6yWgjJCc1Udj347lhzq7KX7gJYrjziiHiXDnYL2fyKYaHXJehfsSFAsmDDdzEIo9Go8o7JSiZDEVQjCRoB/H7g4ODyqI3X8HkY62Ojo5K9iXJMLQfFMNuPDYqGUXY3QFVTU2db+F+8OBBSabBOm1vb196jZm5HNcdcbElPOJcAZsTsGvn5y0vLxeEwTP7/X4cHh4WhebEH8g45mNvby/W1tZia2urRC88H7SZeXBoG8SAkur3+yVzkfpQIFhm3pK9ublZds16Sz0LmntIZCJdGvdqZ2fnUkg0u4B1EQ3LqWWY+uxmgVjgyP7JP/knVy2jD8uViKj6YGjdiIsF70xItKwFmsG1QvAit8YHerOomQjqsc/L5DmlF8v4+vXrOD09jcXFxUJeOa+90WgUgsskmDMxbT2oH8Xl8wIgJJ1LYGVDWJKxgyQF5vOZrZn9WDZxka3Jdzkb0QJNv7766qsSIsa9YTs8G6lY0Ciko6OjODg4KH0h3XxnZ6co2vzCXuSE8YNwBRXQB6M7E3hELLa3t4uVbzaru2KNOC135LWQ9OQx9PXUifz5eyMG+uDoia9x3gd/kzfytsp7gRgiIn784x9HxMXRWk5ucmqxyUFrYTS/raEhHVYgIorl4NTkra2tyiGs9mPtqjicxMKZnZ0tm3DYaMXCNveRiVFbcucK5GQsLBbXmZNAkJ0gRDSGzUwWYI+b5uYSxG42m+UtU7aeVg58FnHu+vT7/aIUORptY2MjOp1OST5j3Ni34mgUz2bMBoNBUdpOhCO6wtx54xvEK64Wv3nv5s7OTmxubpZnOe0aBeD0eFwqL1zak9GFj6zLMmpZysQ5c0cqNPfDrVAm2Un5wbkSERE/+tGPyuR4QFkov3xOBbbZMvB9xOXwlpFDViizs7Px4MGDmJubi42NjcJOc1+2QIbghAYdYcD/5CTlvb29YiVsFegbi4H2kjXndGJbqBzmQ3hQJp5vj6MF1GPm8fLeAvMLnoPMpFtpLC0tFYW+u7tbLCyJRZ1Opygi7re74LG1hc1cgiMq/A8CQJHirpB74hBtjrzgnhLFgjPxXGXOIRfPI3PjRV+XxWuC3fLJs2wQ3rZieC9ciYjqKb/8z0BlH5DBs6BYYZjQs3a2sHHPYDCIX/ziF9Hr9eLZs2fRbDbLuyWsFOwaMOnO/mOvAagBroCNYpld90Kgf6enp+U0Yy9kFIgJ1TrWPidIZf/X0NbuWFak7BGhbtwDjyH1sRixyD7n0cf3Ed6MuAgTgpCw0tvb25fmH7YeK09xTgX3w9FERDl5OR+SY2XKs6enp2NlZaUkhfn9FpYBK+jMP/E3MudFb5cou7/MuxWwEYeV09ss7w1iiLhwJxy64cdbiyGBIi5vvDH8NYT2wvB3XqDT09PxV//qXy3Kwu8o9OR7oSIEWGv70wg+yo32IlgInhWO+5wXtF0IoyB8aaOsnBxj6O/25QVAlh7krC2a30Hh9pmoNSIz7M6ujBWZCVXntDAu5kkYJ+YLRYZy3draqoSI/XzPPc/tdDoxPz9fIjp2G4xe/cO4mJfAVTKqM+qkeLcobaDYnaSMRqP4B//gH0yyfD5MxBBx4XPll55GVI/28oKzv2uBYeJs8ZkkL3Zb8NPT0/jv//2/x8LCQnz3u9+N3d3d2N3djf39/UouAhreisbWAitlLsGbcajTBJStN/fWKT2UAKHObFGwQPzmOYazToAyCuh0OqUOJ1550Udcfj+nw3Qea7s5jJ+3vqPwrWQiouRvQLZSv5Uic3l6eloOA2ac4TmoywjKkP7BgwfFbdra2qq0gXGmeLHyPTLEWBvNmvBlTDxuPn/CY0w/jW7fRXmvEENExH/4D/+hYs0jLqeM5gNQEBaUgRGBtTzPsm/5y/ZVWPNG4/zt2o8ePYrp6ek4ODgoguPF4ZecIpARF2E2Z2T6XteHwFiB1fEB2eL6d7bKGY5bkRgCZ4QFHI+IcrirU7s9hm5XVtAWdAu+Fx6KPfNDERdp2G4PZCDFfIoRYg452z2ifa1WK5aWluLw8DB6vV68fPmyRFBQokZ5hvmMmQlLKxPzCsxDNnQoyExmM7ZGdv/oH/2jmLR8sIiBYouOwOUdZ1hAWyUWgi2voS3FE5gVJ0jg4OCg+MUcKc53g8GgwhpPTU2VsxTr9tfTtmxBx8Fb96VO8XmcKHYdrIgYByy7oTLXYEmBw9mFssKkjdxXp5TdTyt32uesS495xMUbqMiNqHPRjPKGw4tTuaknuw/UMRqNSkRjf38/ZmZmYm9vr5KgxXxmZOmt2M1ms3KCktO7QS0+pllfjAAAHYhJREFUXGh6+uJNXcjdOEVrxPgujfp7hxgizlGDfbSICyHzYvCCQ7i92HOWZPYV64TeCTirq6sl4xDB5pASJh8BIcMPIbErgCUzo+/fEVWoaosHJLXQ2rePiEr2Y/bxEdCMYugrY/z8+fNCvG1tbVVeDWfXjQU7HJ6/+drjbIHGTSDxC6VgfohiBeZiReA5dUSB8TbSYvH5vpmZmZKzwK7T58+fx//9v/+34hradalDJOY6svLMpCNzaRRFG+qUYl6r47ZXjysfPGIwj5Cz3yhAXwQbIUFIgc0Z7po0yoKQiSJgJ0k35CZwLQQZcfzd3d0iOIbWWMHsHtE2E6D4qyg7u0/mGSIuDgrlzIUcSgQKu66Iy6cjDYfn70B88uRJ/OIXv4iIakKNfWj3nQQq+osScM4HSs0Ig2faveIz+gX/UreI2Iru07XNOZgfcR28Z3NxcbFsPKPNVgbIgF0ioyyfL5kXM0rLKMqGC8Vhd8+osc79fRflvUQMEed5DRFRWWQUa+C8Y80T4wH2gFv7m1k2adZut2NhYaEk49inNdSMOJ9ckmgIdXrHn2Eyvy2wTvH29Rq/Cjnpey1QFCtDX5/dFvv7S0tL0Ww2Y2trq5CTvsYKk+IoAQrBXA3vxLBVNVGLojABOxwOixLEXXNfPY/ezpy5GqM16nfWJDkOjny45GdlQtgcwjiCEGXoeTTac3TLRmlqaurGaOGX9X3YiCHi4qUrJhMzWcZk279EsCIuDmR1dpxRiP14/scqeb8CR7gZehte27e0BTUqoX22gCbosjXNyiK7PL4/ohqCzC6KF3de8Hy+ublZITNdJ+iMOrOVz5aVz/KiMBnLwrbiph6eZe7AioNnWFEwTjYURkogC3IqrIQdvTG6oR4MgSMP5rycxu8kJ8bBx8F7XuiXxyij1ndV3lvEEHGBGsYtgMyAZ3/Og+5FlTW1T9Phd6PRiAcPHpRkHzYD8Z2jEk6fta9sq8Y92Wq7T7aMOeOyznJ7cVjZZaTkxZQhsBeRT5nKbeR+98/8B202fHdqsZWOF6/zItw/E3U+cCYbCxYsSp5TsVjkmady1KLRaFxyh5xsZoVt8jOPB9dFVNEfdXoejDxMFltZTpq3kMtHgRgiqluwKba2CGFmrlnoTkO2BTeE98Yh+7gzMzOxtrZ2qS0IGxbIiylDZhZHJsPsklgZZVhNH71T0NYx8ycmLa0gjG4oLDSnJ/szrKARhJWMSUyPp9vnSEUee9qQrTtKwIouowEjMNAAskHeCOONojGRazjPQuaZViomSvOZGlkumWNyWCyTFJPIlmPmgBT6r6O814ghoso1RFQ3ojDJWUhRCobm9rlt0U1E2l/3AqgTaOrNFtKIIlvlTCqhkDLkNn9hKGtBy2RVDgsaEttVcr1GD9nPBwnl/A76iI/NuGW0lvudXaKI+jM3MrrJDL/npw59ZSXCj6MpRhLmpLJbGVFFKFY2Rp+0CVcyu1FuuxUT7fU5Gr/5m78Zty03QQzvvWKIOD+vAauZXQT/nxWEk0aYFBazd7L5QFgrAVsJ+5yZBKOwGOE13F5fj5AhJA65UZetOFY0+/Z2bZxKTDtZJLTdi8U5AnxXB22z4mJMjWDyOLvPLAg+M0Jw3YbZhvYeOysEFunU1FTJEUBh+X7GibZYKeIuUBhr/o6oprDbIGW0atmgGBUwXlbUnPB1dnZ+huU//af/dNwSmKh8NK4ExVYls/D2Pb0IfK8Fygud/60AIL9sUSg51JQtJM+FlzDZhjBZoOhHtv65H0YQVnL5pGUrLZ7r2LqtYaPRqGQY5jMvrPAy8ceizKw8Spa/8+J3+61gIqrHtHGd3SQrnzprbvSFMoions6N2+h5ZZwdtvZc5EhEnVtkhepQM8+yktnb24uDg4NoNBrlnI3Nzc34/PPP4+ssHwRiiIj4z//5PxdBiIhKJhnW0oKfUUUWuuw68FkmC8eFoiIu2GhnQVoQWCQRUfIKLNSGz7SFRWhewtDV2YnU5wWYowNeDHwH5HXKb26vF6OtvIUcBeY9Ce4LbcubqbIS5zMftJL7Qzuz9aagiN1ft5fxMpfgcCvjnrdO+7AaCkiDdqBUITdJCqNPKCqOFiTK9eLFi3Ki9L/5N/9mrJxNWj46xBBx4Y86KmF/PFu4iLg0mRFVpMA1vs5a3wqlLuaMAPKyEnMYFjrzBBYorFjdZiiHwKzUsh9rJUc/EVC4FqOe4XBYkpcclYm4WHg5WpPngT54MURERUEYxZCKbfctuwq23NmY5f7STisWxob2en8C/YEwzlEX80RWOtkNMzrMbwQj4YokKpT30dFRbG9vl/Hc3t4u28Hdv6+7fDCIISLit3/7t6Pf78fy8nK02+0Ch7MvGnEBM1EkhokR9RuBKAi8/cHsP+Zj4WkDi4b7CdlltJLnxW4F3/m3hRTh9Z6G/Bz/72e4DxFVIpLiaw2Xs4X2PR7HzKNYgVtpOmKE5bXL47qy7+5FzTjk/BHutTJGyRgxuA25n0ZgZ2dnxU3kWvqNHHCeJ3sxms1mfPXVVzEYDOLo6KgyP9Tze7/3e/E2yk0QwwelGCIi/sW/+BfRbrdjcXExlpeXY3FxsUwaVtuLpW5h2/rkeDIWJxNqdaQX92fyEyRRx1NkEi7XgWtEm/mdr8n+fUYO47gH7nHfaZePJzP56HuuQmE5nGqr7j0COV+C6x15ycf0+bf77kUfEZWDWehXntvh8GJ3I321cnB9OW/DkScrBx+T32g0Ym9vL7a2tmJ/fz+Ojo4u5WLw97/9t/823lb5qBVDRMS/+lf/qgjQgwcPYn5+PrrdbiXDzAd1GMZGXOYgbGHMjKv9ZTE7441ryVXgWiykY/EmE030ZYLLC8WLwFaX63zYam4b45OTcoxYMmdA3VYOXjBuF3Xa789EYcTlMLPRhEOHViIoj9yOvEHN3ICVoBWgC212ODejE88FbXZejA/cBa3s7OyUfu3v75czRFFsdhvMRb1NpfDL9n58HIPL8fFxmdijo6N4+fJltFqtWFhYKGcL4tfaJ8Q/zwLMwkYoMnFp2MkbmSnD4bCcj0hdLFaTeREXAo7Q4GpQ7DLkQ1bcHqygoxJGKY4i2EoaHfAZ7XIbfX1GVxnF2OXwYTAUZ0VaEeV+m1CtOyAl80Lun5WfIyZO0rICImM1J4JRt0liPud6tuOb9H758mUFGeSMS8uB5+ubLB8kYoiI+Nf/+l+X9zmwcHkV28zMTDmQ1Qd/ZqtWB2Mt+FjovBHIBQVQR4JmljtnQPpZGcJGVDfvmBizoGfOIMN0I5kctcnkZW6TkQj3u6/UY7chQ+/MPVBs4Y0cXLd5I7tm5iHyeaDOCcnhWcbNJHZEdZt2/m5mZiaOjo4KRwDa297eLsfIZS6Iv+vGmzH63d/93ctC/Yblo3clKP/+3//7WF9fL++HMPSzkuj3++W4MKw0QmSGO/MTtkp1i9gbfDKDzzOICtiic4+VEMX1GznQN6cFWxAN6yk5JEddhvWZZGQxe8HaHzeSqXNR6rgbF9eV3S+7OXlcsmLGqufwMsrMz89ci8lHPoNU9HyfnZ2/aYqQLGdVbG9vVxLuuC+7Pi4oiunp6bfuQqiOe8VA+Z3f+Z1YWFiIbrdbzmj0q+giLt7NwP79RqNR0AQhpkwSRtRvX86WJqJq5RG8uqgF1xuFjGPAvZvRezmMIEwIOvyXiUMrD7sAlDpLXuc+ZFnKi9XJRvSd+x3Tt+Xmc9dhH98+uV0X6vOi9E5bxtEowBmLVmKgjMPDw/IiHL776quvKm/I8qLP8+5xRWkwHszz7//+78e7Kh89x+CytrYW6+vr5cSlR48eRaPRiM3NzXKI68nJSQwGg0poCSUxPT1d4vq4BUwof3MoaQ59RlTRggW33W6XaxBgLwyu80YvuzxGGOwYzCRfdiMMqW15TeqxKC3ILF4fRU/ijSM22bIzZvalPT5WClNTUxU3h4XHPSycPM70wUlkPlXbxC/nP5hkZPz5bTiPe0C7kIetrf/f3rkttXU0UbglUaBTMLJJnii3eYs8QFxG2H6AVCqpynvkPnd5nVRucsLGGIQA8V/4X8O3155t4ySAML2qKEDah9mHXtO9umfmVRweHsZisWhcZ0SzrJzCpxOx7queG3WLdcAn7zFEROzv70fEVfXb1tZWfPHFF2XuwL///jsWi0WD9flyy8VT1ZwWlVWmY2NjoyyWwliUE4r4oC1/Yag3eNytF9WFvYgrgdBDB/ac2ofb63wyTAq20ggUfnktgwyWwpvqMXTtMkqfWcpDE4FZBhcNXe9wj4aeA7M7CrW0P8mAz1r3gGRweXlZvMXVatVYnZxpU84ZoWene6vzktS8zfSibtJb+P85M5RwfPPNN61eTA9RS9Nvb2/H+fl5vH37Ng4ODkrIod734uKi0atpjQV5AHrJ5EFwXIAMhS8H4RV9MoquHqkLJAZ5AHp5laKVIKtFdPUSixDYg3L+RBdP6XHQQ9F9kWajUG0wGMRoNCr3Qve/VvshMByitsF74m3VfvrNEEKrZOva1a7JZBIREYvFIl6/fl1IgBkctXmxWJRrIEnxnAJFUZGP/uczvildgUhi6MCLFy9a8X/EVepNouSjR49id3e3uLeHh4etEY4yIvWsnOcv4t0LISOgm6gXxQfp6G/29K6URzSFMgqANF4Zk8IktVHXLDKIiMa6Dcz9qz1ec0DDdY9E7fRroAdFkmS4xu8YrnGcAc+l50YdR7ODn5+fl3UtV6tVmYhXvXS/34/JZBI7Oztxenpaagt0v3Q8PjPqFfKCqAnxOZLAqBNRXOb9/q8qGz+E1Bg6ILbWQ/cXXN7C0dFR/Pbbb8UT2N7ebo0uFNuLSHgMjZ9nYYsbBONxr2T0SsiIaBTB9Hq9Yug06svLqyHEIgOOWuRCsTw2z0VNhC+07h9BvYC6hFxpeRI0OHoc1CdInu72aztOAEvyEBn6pLyebhwOh/HkyZPY3NyMk5OTMgO0tmMmgSELMygkA10PSZv3Tm3lhC7ybJj1WEc8KI9B2Nvba/R8PvpND5Lqsvc4egGYraBXMRwOYzablUKqP//8s0y2QcPkj47vLwvPz0IcGR8XQ6mNI2BvSxLyXpFejM6j81Kt9/+5vzQcegFqB8OXiChjGDSrEkXVjY2Nsir2dDqNwWBQVv2SRxDRTLlyuXvpP3pei8UiDg4OyvqXTKtqen2RGDUQ6jpeWUpSUkiiNrE+hZPRikDPzs5uXFNwpMfwAXisqjhcGQaO3Wfuu9/vN1awlnFqQhTGnGdnZ/H777/HYDAoYufm5mZZ1Faxrg90cjHRe3cJakynydVlPKtjsX6C39Fl18S2XH9CxiFjXiwWZf0MVf/phVexmGJ59dqK0dmW8XgcOzs70e/3i+Kv+TJl5NPpNIbDYWxubsZff/0Vv/76ayNcUvsUnsjgVHU4GAzijz/+aGg2MvDlclkIQ+cTMUW019WgSChPhUIwNZiuEatcmVzPigvSrCMepMcQETGfzxs9HjMENEgKROxh6War56ZQyXhdpCHiefz4cYxGo2KYegGVGVGPI0NXulTehK/UtFqtSggkwhFRUNRTmDGdTos4OJvN4uTkJI6OjuLo6KglNGpV7tFoVAQ6GYcI8Pj4uKzYRJVe98XJTvdtOBwWUtIw5Ygok5WwKI0uP91ygd/x2tkBcF9eIzNArMzU/syY0JtQzx8RDQ+S16v/WSUb8d8OjrouUny8Jvb29lppQ/XILMKRpxDRHETlopigOJIvJf/2ugESiRsz41vt44ah9m9ubsbu7m6Mx+NYrVYlDasiIfXsy+Wy5OIjrkIg5vwJtY+G7d6IrpGio37T83Lj4fHo/TBEcCOm0KljkIR1b2jMvHckeHYOar+efa0y1D073hteE7fnOQaDQXz//fete3wbSGL4CDx//rwYIL0AH9/gxTB8Sdnra/+I9poAzCTU0n/0XviZv1w8HnP4q9WquPdbW1uxs7PTIDZ5E9I6aCRUz90gRQLahtfn1+qGo7Z3eWcUKbkfqxBJmjo+2+H3hTqRayy6Nh+dqXZReKQuoN7fr7EmZrOiU+cXmd22rkAkMXwk5vN5eSFYZKSeXy8oVeeIZuqwZsz6O6KdV3f32g1HqBkUsyNqq4cAbDu3oWvLHpdEQ5A4PMb3Y6tNNAy/Dj8Gz0edpHZ/SSaq9mRb1HNTc+H5+XxENvqcBOSdgARKiq48l87PxWqZwdA1/fDDD6137zaRxPAPoLDCX/KI9hgC6gx6aSgg0jPoMjoSBs/J+nyKmTwm9xdkDOxd3cXtcs+9Pd4Du14S0RxfQaPUdzyGQhmmNImaofJ+6zxOTvKQuB3JSfqAhsJ3pQd1Xby/zBJRbKaHxLZSCGaKWERxV+EDkcTwD/Hs2bOGIZEA3FOgEXsIwZSiticxeJUeDUMvlXpEgYTkBk2joLfAtql93kN7xWWtzbVzubvtRk2yIOnUwgI3fu7PBWgpDlJLoMjnhqt2Sj/hsyTZMEzgOficea0E9RHeO7Xxrj0F4WOIYX1GbawBfvzxxxYpuB7gIUJEW0DjyEf3ItwriWhOPKKyaQqLLmR1iZE6Nt186iOueXgBkV8X93EPiKGREweFNicjn8KM7dGxWMugyk0ZJ9uqeyNvic+AhumZgl6vV1KrfF6+jbJGyra4J8RzeYoyImI6na4NKXws0mPowHw+bxgfDVTw3kM9vrul7JVrrjK9lC6xsaZB8HvXHfiZk4h7GTqWPvfSZn1GA3Ktgb0r8/w8h4zRt5Hx+TgS5fvpyteupUba9CC6BqDxu67nwOfHUM3HkKi2YzAYxPb2drx8+dJfqTvHx3gMD7LA6Trwl0yf0aCoaksXcMXe41a6ye56drmkEdF4aeVi0x3u0jhcG2H7eUy2ma62jqM0rs9H6R6Dx/S6bhIOQy19ziyQrp8TvqqtXLCF98uv18vfa+3lvvJU2C5qGdpnOByWkERkqdG1T548idFo1NJQ7iPSY/gA5vN543/PwbtrGdFc0ZhuLusb3CUX9IKyzNrFs9ozo/Gojd4+F/TcQPS3by/DpYhJjcR7Ze7r1/Y+oc8Nl/dYXoVGrMpgfRSqe3F8Du6laX4GkoC24yhI7aP9+v1+TKfT2NnZidlsVtLbm5ub8dVXX7WezbrgYzyGJIZrQGEFxT2GB5wgVKlAvuzek0c0Bx3pu67woSZ4cUIQnqdLLCTcEGrn5Xa1EMbPVTsG2+xhDMlFIQOrJt0gI9qpXZKL9/L6TL+dKP1+cl8dm4Ogtra2yojM2WxWZvVS+HB5eRlffvll7fVZGyQx3ABcc6DBys0WtJ0X73S5snRXvWBIvbUbiRt/za2vaQrcx8MLHlft6zoW9QUXOwX/XPeDbfBUpuBk2CVyutclz0JEI9ADI9mRBHQvJAA/evQotre347PPPovZbNaYWFahxJs3b+Lw8DC+/vrryluzXkhiuEHs7e0VY5d3wCIovrQ0jIhmT0wX2HUCGYR/7sd0AhL8vNr2fWlO7cNJTbzM17ULHse9ihq4r3sE9GC4La9T1/a+6kt6IrUwg+SrHn80GsXu7m5Mp9N4/Phx0TB0LVpK7vj4OF69ehUHBwdxenoay+Uyvvvuu87rXTckMdwwnj9/Xo2V3e1nzxrRVtIlxPFlfp+BsXcfDK7mSPTiI/citF+tSEkGJGNj3C50eRjutvMcgsft+ltVghT4vC6kFoYx9vc20qPhcyAZjMfjmEwmMZlM4vPPPy+T/nK+BY0olTegWZ1OT08bZfJ3MRDq3yCJ4Rbw7bffltGQ/jK76l4T2SKaJcDutgu1+F6GpVSehyzuCfAZe4rOwwEnkVo7fD93xXk9LoQ6WZE4PUzyFKXDRUWdr9d7V6OhuTk1mlWkwLSr2sARpm/evImTk5MyAM3X/riPpBCRxHCr+Pnnn2MwGMTx8XEZgvz27dvyYnGkJkmiSxOIaKY6adzsWbWdG4275Z6y9EpHGl+t9+a+9HS6NAoaqAuHEU3RVGTiA6Jqmgd/y+g3NjZiOp3GeDwuM2lpvk15CV6gdHx8XJ7R69evY7FYFALgPaGwS2K/rwVLEUkMt45ffvml8b8MQkveaaq3xWIRZ2dnZQoyua3q9Wthh9cquCvPc/JvGpLcdhVg1eokdC6Rh7v6/K2sDDURTiBDwuiK75XJqYVAOp6yAdIBJpNJjMfjGAwGZZlBXYfXaMjgF4tFmd/h9PQ0Dg8PixYRcSXukrBJhhIjLy5uZnWo20QSwx3gp59+Kr2VDIq6AXtQuaOr1bt1LbVWpSYnOTs7K96GejsZI9fFjGhXREpAZMGTu+0u6rnLTp3BSUH71fQQJxkdg14KS5L7/X6Zim00GpV4X8bP2aXppejcIt6Li4uGDiAiFvlqkhe214ui9HkXqd3WhK03iSSGO8TLly+L2j2dTsvkr5qPUC6wKgxlKD7pSES7kIjahYYc66XX9GSaIk0eiKaK57Z0j2VYdOk9ZGB5tEhPBCiXW4VHXLVLv9XjShMRsXByV69aXK1WxbuS4cvol8tlnJycNGa7imjPg+HvNsmPng/34ZDry8vLT4IQhCSGO8azZ8+K8bBIJuJqPQr1hpo2rdfrlc/pSutF9tW5GUbII6GLX9MnXKATQbh4p+P46tQ1EZAeRS2bwYltVqvmuo8iLc0PKW9Jq0WL5DSnJr0gkon+5ngOQdtwYJqHC7X/+/3+WgyV/i+RxLAmePr0aUPEiqjPKyBjV28lr4KTtZ6fnzdW56aLLUOn4CZDFfxz9pBdNQ+uI9SMnKTDKdEkuir1F/GuHoArOS2Xy8ZszwK1AtddfPq5rvvqmgM9Hwq9ThifIiEISQxrBk1Xrx7XU4Q0xIioftclOno6MKI5p6QIQ95HrXd3rcDPx1CGBVDa1n+TkPxYXXUONFjXMngdfg9qugAN370BtsX1j/uYgvwYJDGsKUgQvV6zRJi6Qq0X13dy7fWC6xg1Q9Zxa/UIXrvg+7GdJCcfwuzbCsxCKFtRK/yS4fsAMG8v29dFILyHDK9c/PV7c9+zDddFEsOa4+nTp425CQT15F7d50Ya0Z4jwtV17s99hFq1pH6zWIkhT0RzbgkaP3P9rEugJ8PrZDtEDtqH+5EMaNhOBvrMr5diqrZRRuMuJ2a9CyQx3BPs7+83DNx7UqbV6FJH1A1ZoEFRH3DNQN+7QRHclsfR6lfslWtpTa70ze8ZYjDT0kWIbCv3j2jOMuXXw8/096ceMnQhieGeYX9/v9FrSthj6W5Xb+pGHtHOHtBVpxF+qCxZn7tr7+dxo9axmdWggXadU+cS+XRlDiKuVuRiFWXt2klUD5UQhCSGewwuguO9rxtJraf38Qu1mY5qIiNdej9n7fj+ee09osjp7j0FzVo45WFPV9m0Xye/i4gHox9cB0kMnwDkRdSUeS6J5zE/SYEGzN81/aBrG/bGwvsyJoLaplmXOHoz4mp0KEnBPQJ5TvzfDV/7eVYnCaGNJIZPCPIgSBAR3XMlsCd3faGW8fD4XZCh1YREz2h0EYv0BY2LqE3/FtGcT8K9gVom5H3Zi4ceLrwPSQyfMLRqFodOR9RThk4M+iyireC7sKfP3WPg9v6/jsH4n4TjBBBxVbTEwV1sn9DVjvQMro8khgcATVJLBT+iW3jsEvFIBC4Ceh1ArdQ6oultaB8Kl/zOtRO1scsrqYU+EekZ/BMkMTwwcD5KGpBceGoUFBm9p/ZQgMbJ96QmOron4V6Ni5A8F49by3jIc0jv4N8hiSEREe+moOPMyxHt4if3BNxwa1kKh9dJSF/gfAtdxOLk0+v1kgBuCEkMiSpUki1sbGzEcrlsTFQi1ETEmtjoWQR5Kj6HZa/X6ySLJILbQRJD4tqYz+dVT4HvBcnBPYmah0FvhNmUfr+f2sAd4t4RQyKRWC/kateJRKKFJIZEItFCEkMikWghiSGRSLSQxJBIJFpIYkgkEi0kMSQSiRaSGBKJRAtJDIlEooUkhkQi0UISQyKRaCGJIZFItJDEkEgkWkhiSCQSLSQxJBKJFpIYEolEC0kMiUSihSSGRCLRQhJDIpFoIYkhkUi0kMSQSCRaSGJIJBItJDEkEokW/gfgw822fw+8NgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "slide = image[:,:,14]\n",
    "imshow_2d(slide)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The slide can be save as a 2D image in a regular format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sitk.WriteImage(slide, prefix + 'slide.nii')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot in 3D\n",
    "\n",
    "The library ipyvolume is used to plot in 3D in a jupyter notebook.\n",
    "\n",
    "The function imshow_3d() is defined to plot a sitk.Image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install ipyvolume    # install ipyvolume in colabs\n",
    "\n",
    "import ipyvolume as ipv   # library to visualize 3D volumes.\n",
    "\n",
    "def imshow_3d(image_itk, controls = False):\n",
    "    # Function to show a 3D image with ipyvolume\n",
    "    # Input: sitk.Image\n",
    "    # Output: None\n",
    "    volume = sitk.GetArrayFromImage(image_itk) # get numpy array\n",
    "    \n",
    "    # Adjusting the proper scale of the image\n",
    "    spacing = image_itk.GetSpacing() # scale in mm\n",
    "    size = image_itk.GetSize()       # pixel width and height\n",
    "    extent = [[0, np.ceil(spacing[0]*size[0])],[0, np.ceil(spacing[1]*size[1])], \n",
    "              [0, np.ceil(spacing[2]*size[2])]] # image limits\n",
    "    mx = np.max(np.max(extent))\n",
    "    mn = np.min(np.min(extent))\n",
    "    \n",
    "    # Plot the volume\n",
    "    ipv.figure()\n",
    "    vshow = ipv.volshow(volume, extent = extent, controls = controls)\n",
    "    # vshow = ipv.volshow(volume, opacity=0.03, level_width=0.1, data_min=0, data_max=1)\n",
    "    ipv.xyzlim(mn, mx)\n",
    "    ipv.show()\n",
    "    return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Note:</b> This function is stored in a local file called [local_utils.py](./local_utils.py) for further usage.\n",
    "\n",
    "Now, the previous images can be plotted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03bf199aa6a1421a86c4c987dfa7e163",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Figure(camera=PerspectiveCamera(fov=46.0, position=(0.0, 0.0, 2.0), quaternion=(0.0, 0.0, 0.0, …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow_3d(image_nii)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "28c1ea773a014b0f923a82efbc5f0977",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(VBox(children=(HBox(children=(Label(value='levels:'), FloatSlider(value=0.1, max=1.0, step=0.00…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "imshow_3d(image_dcm, controls = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: The functions imshow_axial( ), imshow_sagital(), imshow_coronal and imshow_3d are stored in the local file utils.py"
   ]
  }
 ],
 "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}