{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Introduction \nThe RSNA-MICCAI Brain Tumor Radiogenomic Classification competition is a multi-class classification problem where the goal is to predict the subtype of brain tumor present in a given MRI scan based on radiomic features. There are three classes: LGG (low-grade glioma), HGG (high-grade glioma), and WT (hemangioblastoma).\n\nThe dataset you will be working with consists of MRI scans from the National Cancer Institute (NCI) and The Cancer Imaging Archive (TCIA) datasets. The images are provided in DICOM format and are accompanied by a CSV file containing radiomic features extracted from the images.\n\nHere's the competition [link](https://www.kaggle.com/competitions/rsna-miccai-brain-tumor-radiogenomic-classification/data?select=train_labels.csv)","metadata":{}},{"cell_type":"markdown","source":"### The exact mpMRI scans included are:\n* Fluid Attenuated Inversion Recovery (FLAIR)\n* T1-weighted pre-contrast (T1w)\n* T1-weighted post-contrast (T1Gd)\n* T2-weighted (T2)","metadata":{}},{"cell_type":"markdown","source":"# Necessary imports","metadata":{}},{"cell_type":"code","source":"import os\nimport json\nimport glob\nimport random\nimport collections\n\nimport numpy as np\nimport pandas as pd\nimport pydicom\nfrom pydicom.pixel_data_handlers.util import apply_voi_lut\nimport cv2\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nfrom sklearn.model_selection import StratifiedKFold\nimport tensorflow as tf \n","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:15.972883Z","iopub.execute_input":"2023-01-15T17:35:15.973229Z","iopub.status.idle":"2023-01-15T17:35:23.698474Z","shell.execute_reply.started":"2023-01-15T17:35:15.973132Z","shell.execute_reply":"2023-01-15T17:35:23.697418Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Reading Data","metadata":{}},{"cell_type":"code","source":"path= \"../input/rsna-miccai-brain-tumor-radiogenomic-classification/\"\ntrain_sample_path = '../input/rsna-miccai-brain-tumor-radiogenomic-classification/train'\ntrain_data = pd.read_csv(path+'train_labels.csv')\nsamp_subm = pd.read_csv(path+'sample_submission.csv')","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:23.700624Z","iopub.execute_input":"2023-01-15T17:35:23.701317Z","iopub.status.idle":"2023-01-15T17:35:23.725559Z","shell.execute_reply.started":"2023-01-15T17:35:23.701275Z","shell.execute_reply":"2023-01-15T17:35:23.724713Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print('Samples train:', len(train_data))\nprint('Samples test:', len(samp_subm))","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:23.726998Z","iopub.execute_input":"2023-01-15T17:35:23.727374Z","iopub.status.idle":"2023-01-15T17:35:23.734239Z","shell.execute_reply.started":"2023-01-15T17:35:23.727339Z","shell.execute_reply":"2023-01-15T17:35:23.733192Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_data.head()","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:23.737041Z","iopub.execute_input":"2023-01-15T17:35:23.737950Z","iopub.status.idle":"2023-01-15T17:35:23.755663Z","shell.execute_reply.started":"2023-01-15T17:35:23.737899Z","shell.execute_reply":"2023-01-15T17:35:23.754832Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(5, 5))\nsns.countplot(data=train_data, x=\"MGMT_value\");","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:23.756910Z","iopub.execute_input":"2023-01-15T17:35:23.757414Z","iopub.status.idle":"2023-01-15T17:35:24.021047Z","shell.execute_reply.started":"2023-01-15T17:35:23.757380Z","shell.execute_reply":"2023-01-15T17:35:24.019989Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Read Dicom Files","metadata":{}},{"cell_type":"markdown","source":"### What is DICOM (Digital imaging and communications in ) : \nDICOM is the standard for the communication and management of medical imaging information and related data. DICOM is most commonly used for storing and transmitting medical images enabling the integration of medical imaging devices such as scanners, servers, workstations, printers, network hardware, and picture archiving and communication systems (PACS) from multiple manufacturers. It has been widely adopted by hospitals and is making inroads into smaller applications such as dentists' and doctors' offices.\n\nDICOM groups information into data sets. For example, a file of a chest x-ray image may contain the patient ID within the file, so that the image can never be separated from this information by mistake. This is similar to the way that image formats such as JPEG can also have embedded tags to identify and otherwise describe the image. ","metadata":{}},{"cell_type":"markdown","source":"To read dicom image we use the function **read_file** or **dcmread** from the library **pydicom**. And to get the pixel array we use dicom.pixel_array. \n\n**Code :** \n\n dicom = pydicom.read_file(path)\n \n data = dicom.pixel_array\n \n For more infos about pydicom check this [link](https://pydicom.github.io/pydicom/0.9/pydicom_user_guide.html)","metadata":{}},{"cell_type":"markdown","source":"### Data structure  \n```\nTraining/Validation/Testing\n│\n└─── 00000\n│   │\n│   └─── FLAIR\n│   │   │ Image-1.dcm\n│   │   │ Image-2.dcm\n│   │   │ ...\n│   └─── T1w\n│   │   │ Image-1.dcm\n│   │   │ Image-2.dcm\n│   │   │ ...\n│   └─── T1wCE\n│   │   │ Image-1.dcm\n│   │   │ Image-2.dcm\n│   │   │ ...\n│   └─── T2w\n│   │   │ Image-1.dcm\n│   │   │ Image-2.dcm\n│   │   │ .....\n└─── 00001\n│   │ ...\n└─── 00002\n│   │ ...\n```","metadata":{}},{"cell_type":"code","source":"#Extract folder id of the first train sample\nfolder = str(train_data.loc[0, 'BraTS21ID']).zfill(5)\nfolder","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.025269Z","iopub.execute_input":"2023-01-15T17:35:24.028155Z","iopub.status.idle":"2023-01-15T17:35:24.038632Z","shell.execute_reply.started":"2023-01-15T17:35:24.028109Z","shell.execute_reply":"2023-01-15T17:35:24.037384Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#Folders content\nos.listdir(path+'train/'+folder)","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.040530Z","iopub.execute_input":"2023-01-15T17:35:24.041394Z","iopub.status.idle":"2023-01-15T17:35:24.066634Z","shell.execute_reply.started":"2023-01-15T17:35:24.041356Z","shell.execute_reply":"2023-01-15T17:35:24.065628Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print('Number of FLAIR images:', len(os.listdir(path+'train/'+folder+'/'+'FLAIR')))\nprint('Number of T1w images:', len(os.listdir(path+'train/'+folder+'/'+'T1w')))\nprint('Number of T1wCE images:', len(os.listdir(path+'train/'+folder+'/'+'T1wCE')))\nprint('Number of T2w images:', len(os.listdir(path+'train/'+folder+'/'+'T2w')))","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.068223Z","iopub.execute_input":"2023-01-15T17:35:24.069014Z","iopub.status.idle":"2023-01-15T17:35:24.591268Z","shell.execute_reply.started":"2023-01-15T17:35:24.068960Z","shell.execute_reply":"2023-01-15T17:35:24.590186Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#path_file = \"/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/train/00000/FLAIR/Image-101.dcm\"\npath = '/kaggle/input/rsna-miccai-brain-tumor-radiogenomic-classification/'\npath_file = ''.join([path, 'train/', folder, '/', 'FLAIR/'])\nimage = os.listdir(path_file)[4]\ndata_file = pydicom.dcmread(path_file+image)\nimg = data_file.pixel_array","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.592656Z","iopub.execute_input":"2023-01-15T17:35:24.594115Z","iopub.status.idle":"2023-01-15T17:35:24.614174Z","shell.execute_reply.started":"2023-01-15T17:35:24.594076Z","shell.execute_reply":"2023-01-15T17:35:24.613323Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"img.shape","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.618730Z","iopub.execute_input":"2023-01-15T17:35:24.619038Z","iopub.status.idle":"2023-01-15T17:35:24.625701Z","shell.execute_reply.started":"2023-01-15T17:35:24.619000Z","shell.execute_reply":"2023-01-15T17:35:24.624600Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.imshow(img, cmap=\"gray\")\nplt.axis(\"off\")\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.627357Z","iopub.execute_input":"2023-01-15T17:35:24.627846Z","iopub.status.idle":"2023-01-15T17:35:24.768226Z","shell.execute_reply.started":"2023-01-15T17:35:24.627807Z","shell.execute_reply":"2023-01-15T17:35:24.766761Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Plot examples","metadata":{}},{"cell_type":"markdown","source":"We will define a function called **plot_examples(row, cat)** that takes two arguments, row and cat (category). The function is used to display a grid of five images (DICOM) from a specific folder in a directory\n\nWe start by defining the folder path, by concatenating the path, \"train/\", the folder name (folder), \"/\", and the cat to get the folder path where the images are located.\n\nThen we load all the images in the folder using os.listdir(path_file) and then create a subplots of 1 row and 5 columns using plt.subplots, so that the images can be displayed in a grid.\n\nThen for each number from 0 to 4 (5 numbers), it loads the DICOM image using the dicom.dcmread(path_file+images[num]) and get the pixel_array from the image. The pixel_array is then plotted using the imshow() function, with a grayscale colormap.","metadata":{}},{"cell_type":"code","source":"def plot_examples(row , cat): \n    folder = str(train_data.loc[row, 'BraTS21ID']).zfill(5)\n    path_file = ''.join([path, 'train/', folder, '/', cat, '/'])\n    images = os.listdir(path_file)\n    \n    fig, axs = plt.subplots(1, 5, figsize=(30, 30))\n    fig.subplots_adjust(hspace = .2, wspace=.2)\n    axs = axs.ravel()\n    \n    for num in range(5):\n        data_file = pydicom.dcmread(path_file+images[num])\n        img = data_file.pixel_array\n        axs[num].imshow(img, cmap='gray')\n        axs[num].set_title(cat+' '+images[num])\n        axs[num].set_xticklabels([])\n        axs[num].set_yticklabels([])","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.769957Z","iopub.execute_input":"2023-01-15T17:35:24.770636Z","iopub.status.idle":"2023-01-15T17:35:24.782448Z","shell.execute_reply.started":"2023-01-15T17:35:24.770600Z","shell.execute_reply":"2023-01-15T17:35:24.781273Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Flair Images","metadata":{}},{"cell_type":"code","source":"plot_examples(row = 0, cat = 'FLAIR')","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:24.786789Z","iopub.execute_input":"2023-01-15T17:35:24.787611Z","iopub.status.idle":"2023-01-15T17:35:25.703574Z","shell.execute_reply.started":"2023-01-15T17:35:24.787572Z","shell.execute_reply":"2023-01-15T17:35:25.702593Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### T1w Images","metadata":{}},{"cell_type":"code","source":"plot_examples(row = 0, cat = 'T1w')","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:25.704595Z","iopub.execute_input":"2023-01-15T17:35:25.704962Z","iopub.status.idle":"2023-01-15T17:35:26.564881Z","shell.execute_reply.started":"2023-01-15T17:35:25.704928Z","shell.execute_reply":"2023-01-15T17:35:26.563871Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### T2w Images","metadata":{}},{"cell_type":"code","source":"plot_examples(row = 0, cat = 'T2w')","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:26.566337Z","iopub.execute_input":"2023-01-15T17:35:26.567403Z","iopub.status.idle":"2023-01-15T17:35:27.402696Z","shell.execute_reply.started":"2023-01-15T17:35:26.567364Z","shell.execute_reply":"2023-01-15T17:35:27.401709Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### T1wCE Images","metadata":{}},{"cell_type":"code","source":"plot_examples(row = 0, cat = 'T1wCE')","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:27.404426Z","iopub.execute_input":"2023-01-15T17:35:27.405153Z","iopub.status.idle":"2023-01-15T17:35:28.221577Z","shell.execute_reply.started":"2023-01-15T17:35:27.405112Z","shell.execute_reply":"2023-01-15T17:35:28.218514Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Load_dicom\nWe apply normalization on the data by:\n* substracting the minimum value of the data to all of its elements.\n* dividing the data by the maximum value of the data\n\nThe overall effect of these operations is to convert the image data from its original DICOM format into a standard 8-bit grayscale image that can be easily displayed and processed with common image processing libraries.","metadata":{}},{"cell_type":"code","source":"# In this function we'll load the image and apply normalization\ndef load_dicom(path):\n    dicom = pydicom.read_file(path)\n    data = dicom.pixel_array\n    data = data - np.min(data)\n    if np.max(data) != 0:\n        data = data / np.max(data)\n    data = (data * 255).astype(np.uint8)\n    return data","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:28.223693Z","iopub.execute_input":"2023-01-15T17:35:28.224779Z","iopub.status.idle":"2023-01-15T17:35:28.231149Z","shell.execute_reply.started":"2023-01-15T17:35:28.224712Z","shell.execute_reply":"2023-01-15T17:35:28.230283Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"str(\"aaaa\").zfill(5)","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:28.232616Z","iopub.execute_input":"2023-01-15T17:35:28.233285Z","iopub.status.idle":"2023-01-15T17:35:28.243297Z","shell.execute_reply.started":"2023-01-15T17:35:28.233188Z","shell.execute_reply":"2023-01-15T17:35:28.242301Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### visualize_sample","metadata":{}},{"cell_type":"markdown","source":"The function  **visualize_sample(brats21id, slice_i, mgmt_value, types=(\"FLAIR\", \"T1w\", \"T1wCE\", \"T2w\"))**  takes three arguments: brats21id, slice_i, and mgmt_value, and an optional argument types which is a tuple of strings representing the types of medical images to be displayed.\n\nIt is used to visualize a sample our data (DICOM images) in a specific patient folder.","metadata":{}},{"cell_type":"code","source":"# following function took from: https://www.kaggle.com/ihelon/brain-tumor-eda-with-animations-and-modeling?scriptVersionId=68202876&cellId=11\ndef visualize_sample(\n    brats21id, \n    slice_i,\n    mgmt_value,\n    types=(\"FLAIR\", \"T1w\", \"T1wCE\", \"T2w\")\n):\n    plt.figure(figsize=(16, 5))\n    patient_path = os.path.join(\n        \"../input/rsna-miccai-brain-tumor-radiogenomic-classification/train/\", \n        str(brats21id).zfill(5),\n    )\n    for i, t in enumerate(types, 1):\n        t_paths = sorted(\n            glob.glob(os.path.join(patient_path, t, \"*\")), \n            key=lambda x: int(x[:-4].split(\"-\")[-1]),\n        )\n        data = load_dicom(t_paths[int(len(t_paths) * slice_i)])\n        plt.subplot(1, 4, i)\n        plt.imshow(data, cmap=\"gray\")\n        plt.title(f\"{t}\", fontsize=16)\n        plt.axis(\"off\")\n\n    plt.suptitle(f\"MGMT_value: {mgmt_value}\", fontsize=16)\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:28.244572Z","iopub.execute_input":"2023-01-15T17:35:28.246217Z","iopub.status.idle":"2023-01-15T17:35:28.255236Z","shell.execute_reply.started":"2023-01-15T17:35:28.246183Z","shell.execute_reply":"2023-01-15T17:35:28.254289Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for i in random.sample(range(train_data.shape[0]), 5):\n    _brats21id = train_data.iloc[i][\"BraTS21ID\"]\n    _mgmt_value = train_data.iloc[i][\"MGMT_value\"]\n    visualize_sample(brats21id=_brats21id, mgmt_value=_mgmt_value, slice_i=0.5)\n","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:28.256727Z","iopub.execute_input":"2023-01-15T17:35:28.257129Z","iopub.status.idle":"2023-01-15T17:35:31.741936Z","shell.execute_reply.started":"2023-01-15T17:35:28.257096Z","shell.execute_reply":"2023-01-15T17:35:31.741012Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Data Loader\n\n**Note**: For each study, we will pick **5** middle dicom or image samples at cetain interval from each of the four series (`FLAIR`, `T1w`, `T1Gd`, `T2`) for our 3D model input, e.g `input_shape: (None, height, weights, 5*4, 1)`. So, for picking 5 samples from each series, the depth would be `4 * 5` or `20` for each patient id or study id. However, we probabely need to find some better technique to pick samples from each of these four series though. For now, we're doing kinde of random stuff. For example: check the following illustration; for the 3D model the input size would be : `height, width, 12, 1`. \n\n![image.png](attachment:c2f6cff4-ed63-4c6b-9353-6df218fe7e89.png)","metadata":{},"attachments":{"c2f6cff4-ed63-4c6b-9353-6df218fe7e89.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAvIAAAChCAYAAAClHls8AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAOcZSURBVHhe7N0HtHVXVf/9Y++9996lqChVKWmkEAhJIBJaKEFBECIBG4N/EBzoMNIEaUKkhCSUBBIIBAmhg4A0EbH33nt/Xz+bfMPy8JR773PPufc+z55jrLH2XmWuueb8rbnmXnvfcz/q//tfWsw000wzzTTTTDPNNNNMe4o++tp8pplmmmmmmWaaaaaZZtpDNAfyM80000wzzTTTTDPNtAdpDuRnmmmmmWaaaaaZZpppD9IcyM8000wzzTTTTDPNNNMepDmQn2mmmWaaaaaZZppppj1IcyA/00wzzTTTTDPNNNNMe5Dmn5/cJXTNNdcsLrzwwmvvdhd9/Md//OLTP/3TFx/1UR+1+Nu//dvFf/3Xf11bs3vp6U9/+rVXM80000wzzTTTTIcnzYH8LqGnPOUpiwc84AHX3u08Cdo/6ZM+afH5n//5i8/8zM+c0sd93Mct/u3f/m3x53/+54s/+ZM/WfzLv/zLAnx2I4RmWO89uuUtb7l4/etff+3d7qKP/uiPnvBvXZTQp3zKp0zl6O/+7u8W//qv/7prsPe2t71t8V3f9V3X3s20TgofhwvBv/TZn/3Zi//5n/9Z/NM//dPiP/7jP6brVdMb3/jGxc1vfvNr72baSdpNuP7ET/zExZd+6Zcurn/96y9uc5vbTHHJxRdfvPjd3/3dxX/+539e22p303btFXMgv0toNwTyFuknfMInTAH853zO5yw+9VM/dfFZn/VZ06IQyN/73veeFo5g5S1vecv0FuGv/uqvpgV1vetdb7p+9atfPQU0Ow2rGdZ7j3ZjIG89fMZnfMa0JryVcv+xH/ux01r5mI/5mCm4Qe7/+7//e/FHf/RH0xsr15Jrb7F2Ao9zIL9ztNcCeTiGZ3gNq8pgX7DOx3/e533eFLwL4t27/vu///up/b//+7+vLHiaA/ndQ7sF13zw+eefvzjppJMWX/EVXzHhVlzy27/924sXvOAFi4suumjx13/91xM288O7kbZrX5gD+V1C6wzkLUafywhOOGSLQsAuGHfNgQtYBPM3uMENpkXwl3/5l4ujjjpqOpHnwDn93//935+C+W/91m9d3PjGN56cuUDGU/Hll1++o0/FM6z3Hu22QN5a+Mqv/MrFF37hF04n760V1ElkufVQgj3JevjHf/zHKdj553/+58Xv/M7vTGtnXTQH8jtHuy2QJ4+DGT4dRhH/r5x/h2tvlmAUXu0H3/iN3zgF73z/P/zDP0z1fLp6+4f1YK+wBrydhXH7A/7awb9rgdSh7AVzIL97aKdwDXveBt32trddfMd3fMfi27/92xdf93VfN/lZ2IPHyy67bPHLv/zL170V/eZv/ubF0UcfPcksvhLk//Ef//H0NcFuiQ+2S445kN8ltI5AHqAB/ku+5EuuC0o48c/93M9d3POe95yAz+HmhEFDnT5eV33ap33aVP43f/M3U3DDiX/gAx+Yrm0SSJsPfvCDi0c84hHTqy4BED76cfiH4tA3QzOs9x7tpkBeAPJlX/Zl05qAaWvA+oFhqQCoa/WSNQF7ckmdjUWQYwN53/veNwU26qwFgf2qsDoH8jtH7L4TBLewhcjQ/Rd90RdNgZAEfx4w1QmQnLq7FxDBKlxXLoB3H5711Q7u7SHaGUe5BMtyAb16a8cJvrdSHgC2gvc5kN89tGpc4+8Q0Sm7w0GHhDCpzGe+n/zJnzwlsQuc8XHiDO0F6Q4X+VX1kj3l67/+6xfPeMYzJhzC8B/8wR9MQT0Ma2NMGN+JmGG7xpwD+V1Cqw7kBdSCco4ceAXfTuABmLM95phjpnYcLoBz0AITi8IiEohw/J3O4GNBIW2VO8Vx/e53v3vx3ve+dzrx+eqv/uopgHnXu941gVadjWDVNMN679FuCeRh2MOu9VEQPwYsNhYbgrXj3nWBjaSdpI81ox3SRsDUJuQTtLe//e2Lv/iLv5jqtpvmQH7niP3XTQU7/C7/B4uu+fBwCo9IvTJYVNapJuLr8TIH7ZRr4x6WBePaK4PxsS2ecniW8CcDrOPzp3/6p9NesRmaA/ndQ6vENXx87dd+7eLRj370FMT7nBdWYOp1r3vd4oorrrjugBGW4Y4vViYe8a38m970pimGUQ93Yh5+HIYcQFoT6nx2oz9c4f+Od7xjOmRZR2wykrlsB82B/C6hVQXyHC1Ae2It8Ab4M844Y1oonDznbBEBt4UD7BywvhywhwABjQCeI46nNvp60uXULRon8xaDNvio9+38lVdeufit3/qt6dMbT86rphnWe492IpAvAEEcO6w7ifegC89wDNucv6S9zcOJI/xLBTg2hIIb9040rSv93Ats5D0cq7cJCebf+ta3TtfbSXMgv3O0yoBnXwRzHj7hN6wqE3TDXdgtuUfwCP9wC6uwyX/XH76Vu0awjyf8w7u62uCLV3l7C6x7OHCNHOzgs1GaA/ndQ2y73YTnd37nd04xic93xSriDp/t9lbfm3/xQ2/2wxmCQ7HMl3/5ly9+8zd/87q/0YNZ8Qh8ehuknZjkC77gC6ZPc8Q6eCL4F5u8//3vX2swT87toPl35A9T4oidkAP3F3/xF09g5lgFKHe5y12mwBy4e6Xq2gLgYDleBPj4WEw+rfmzP/uzyWFbHICvjzr9OXeBvqdeTlvK6Vt4FpU+npxnmmmnCRbh2NrwB9y+hfdNsBOh3lxZB9YNZ9vGoZ9yD7IwrWwMdqwZ60F5dQVRbS76u7Z+rEN/sGUT8/nDTDNtlGARtmAPjv0xNnyFuQL4EYNy/bqGYwmPSPv4SI1T0IGvgMp+4hrmBfaVFbC3JpThYy/AB849xKqb6cgm/s/B4rnnnjt93tsnMhdccMHixS9+8eLqq6+eTuJ9CgM/HaKERViTlAvKxR0wVgwjvhHXwCisSvyzk/t3vvOdU7ziBB92rQlY34s0B/KHGQGjk3cBu89aPM0CJ+B7GvUHIhy3oNzputf6cskiyBlr73MYvLQXpMv9sVSfG+TI8beYLBp88SlYkThxi8kY6meaaSfI2oBLD7hf9VVftfiar/ma6UH3m77pm6Yg3qmOeutEkKE9gmFYtxkoGwMcZOOwHgpckGv12utno8HDvTprSb/WIRnOPvvsaezkVD/TTMsEV4JhQQ8cewiFXdgbU7gMR3LY0l99eJUrLyji00fswT8My1EYDqv166TeHuLeONrph2eYhn1vvTws6z/TkUew4Yc0nvOc5yxe8pKXLL77u7/7ur+l8Mt3Am338FTwDlNwiGCpLwXw6jASzuBSPWxpD5fhGh8n8RKcwiN8aoMHH70Xad4pDiMCSq9XPeFy7pw0AmpOX7nXSgJtgTnwWgSCknHB+BTGaaWg3VOuPpyvBWJhqLeAem2FhzGQRVGgr9zisTid3AvmXc8006rJWgjbJb/A4Y+nPMz6ltgpJmzbEOBXgnMYlsb+NgXrBZ5d4y+XKisoql9tCnK0GwMibY1p3XmlK6j3NsDnMHe6050W3/It3zK1mWmmCMb4ZThxqi0Y9mDqwCUMjziENziER+Xq1UnKC3QEMAIZWOx+rEP4hVm+31rpfuTV+kHKJffJ1howD3xmOnKIP+SHzzrrrOlnIm9605tO2BWPhD3XfKZA271cXAKHsISH3EHMLW5xiyne4FuRGEU5nw7zcFad6/jhkY9GxnMNm3uR5kD+MCEg5BgtEsAFegloOfqTTz55+s5QAAPMTs+BlnPloLWR3HsSlm50oxtNr56cGHoQ6FReQO67XovFeD0AGNfi4NzHV1wWSbLs1YUy094gmPOJgQdaD7OCdr884yfLepCFTziGX47fvdyGAK8cfhsHgunawXKbALwbTxlcKy+IwsN9bXuzpV6d9vomi/R7v/d70wmrkypr78QTT5z+bsDbNXxmOnKJj4Zd/lbwC5twJ4U1eCohWJPc93DpXu4+HLrHE57DN1zmq7WV9G3daG+99BCsffX4LRMZlCcrktuPpJkOf4ITnxG+/OUvXzzqUY+aHkY7SRdT+Cbe30OITxCMw0h4RTCpXMzh4MObKD6ef4UtOPOpJJ8ZLpXhg4dr7fhzD8HKwj8chs29RnMgfxhQYOdUnXgLuJUBKufvCdWrewEOwFs4FoM+gF4gwjH3B3ocssWizmLD270AHz9/SPeHf/iH1z0NC3xagHj17VkbSQvKIpppplUQzHLq3/Zt3zZ96y6Yh3+5T2hsHBy2NQD7sAmXrmHTvcS5w7qHUZhWpw3nL4f3AhvXkvXURmIDcV87cknjWOpaC8qsL+u1zw08aBvPw/ftbne76VOKvbrJzLR1YnPBCgzDEDzxyfxtfj//HY04CeMFNfpLsKePHFbxsD84zDEO7CuP1LsP5xI+MIp36yfeUW0la8mYZG4dWIvSjO3Dm9jXm8Yf/uEfng4F3Ysr/O2dn4z0qzG+hb/00ksXv/qrvzrhjY+EETGJPrAJb/rCkhjDgWK+XVvrwh+8OrRxeMPft2ZQ2EP4OfyEezysM2PuRZoD+T1OwOuUxtMkgOZc/SMEr+f9EZ1/X8wx+7wF+AXy2nDYgFuQwck6NXfPOfsFEfw8BAgsOGMPCeosHIvJwuHALbYWDGePv1/B8Zfg2lg0gpXZYc+03QS7Ah2fosCq72/dWxcCY87aAyenXuCB4FXKsbsuIBFcaOseyaWCcYQPTGsP89YSfEsFM3L12srjg6yfAiN1NhIbirXSxuOkynzucIc7TBvOTEcOwZHPv2CaT4YJGIUlGBQI8ev5XP4bBt271l872BqDeASD6sKjftq0Fxij4NtDrX2hh1vj4oOvNq71iZfUWK0H15Unj3v9rSHjznT4El96r3vda/LD/i6PXxMfwAO/7G0kfIkzlLsOL/qKNxzK8IHwg2BH4uu9fdVOrIG/P5j1Jhau4gOHcG5t4A/HePpbQvz13as0B/J7mDjib/iGb5gCFs4wxyyo9+0ZgAOqMk++nLJrQYrgBriBXrDtJ8H6WTALAuARh+7agvGPFSw6G4Vgo8CCUxbIK7NYnMQbyziu8RSg+D7ZuDPNtF3kNeqtb33r6bRH0A5zBSRj8K4M3iVYLvCGZalNQTuYl9enOlRwJBWkGMvmAud4IesM/9aO9trUD+82JPfak1NKTqSNEyvz8JNp2s50+FN+nF938CKQVgY/sAE/rvlZSXBSCndSfcJqWJPgHK6k1o36MKhegKRc0NMfH/Lh3nzBpnUUr/Bdaix560eb1pRcnfUzB/KHL7GtN4tiBDiBDf808pnPfObiSU960uLJT37y4td//dcnbMGZPPxpK7j3N0T8oLpwDUtO6v0dH34wBU/Wg7imQxYkJ4d+CG79YyhxkbXlwUKf2u81mgP5PUwCZ04X2AtavIKXAF5QAaBO4jlhIOWw5RaMb8wA2omfkx/flbn2YGARCY5ueMMbTm386278nBo61efgfc9boMLZW6iebC3CXs1aTB4mfPerj3uLbaaZDpVg1IMs3MIl/MEjfFkT6gtQYJSDLxhBymAUVgXhnWIq18YfdTsd0kdfvFH84dzGIFmHcpuCddKGgZekjzJ9SiMPZF22NoxFbuvFeuxk3nXtZzp8CTYk2IMF+IIHGCkpE5wohxu4k+AY5qIwGHUvaQ/bcCtHAnX+2hsuewrSFl/t7Sf+FX6BlTUEk9Zb2CbfiPOw37VkXvrYrzyEz3T4Ef/ry4Cf+ZmfmeKF/qjVz0lK/KsDRDn8wRmMOCTUF+YE8vlocQvcwA8sCuKdvru2FvTBwzj4wnXrQR0852f10canPH6n3v7hYAjvvUbzjrDHCbg5UqC00R9//PFTAG5RqONo5Zwo8Lq2aDyN6uek3JMo5wzAHggEDzYHDh24gZ9jN8Zv/MZvLN7znvdM38lbONp6oLDA8La5CKr0SQa8BPO3utWtpm+X2xxmmmmrBKsCANjj+AUEcFZwAuvKJGXWgc1AYGQtjEEH8nDaZqGtnyezLgTzrpXji5ex8Tdu68p1D9Vwb7OxvtpE6qO9Nq7H8urk+urn2pzIKtDxhu17vud7prWkbqbDl/jV8FHAC19y+BGMhA33krb6aC9HrsNXWEOwzGeXCsjV8+uw6OGxf2VfEISHcm9ajQGnBUv6aNf+oa0y1+NDR/iX9LP3WDPJNtPhQezvJP4HfuAHppiA7dmZXx3xCj/wpw6uYQhu4LJPemFKeesgfPHn+PGP/qmUmAXOHO684Q1vmPprB1tdi3HwQbCtXEwk+IfxvfgJ4xH1n12PPfbYa692FwEVIAmSc6obMQvQ5xTlwAyE+pY4bGAtSKhM3oIAZHlONtImBy25Jp8FZ2F5ygZ+/CwQddpYKPpaZOaFZw8Iv/IrvzL9u+V3v/vd08axKjL+THuLNvKfXQsGvN1xepLjVQaL8OdaO+sK9q0nGJfgGFbbMOAEDn1epm2nNa57iHWNtJe0aU3or37Ecjwla6xNLExaP9aMhAcyZuuzNW29qNfOHGrnj8z91rI8nvui+T+77hyx01YJVny32yk1vCH+FOEd/hoHBiX4hwkYhz2pNuUFTfWpnxzWrKfWTnX4qdOvMawN6ww/vMk9jhU28XAtj/CyPpS1Hn3mIChbxvT8n113D2XfjZDDvvPOO296q4/4X/7dP2LyuZh4IT+J4Dk/WTlfyH/6LNdBCx76Cf7VwxH8aAezru0NvjDw37KtGe3Cd3gLn/lW160z/H2BAOurpmWsb5WOqEB+MyBcJQFSoOMMbdiCBk+Rvot04iHQdWq+m83j56K81nKi4pW/p2Gyk9n8LDYnnRaLRSoI8lOWfn7KX6krXxUdQbDeFPlFF9jarQRH/UILp8sJc6gSmzoZ59CVj4HBTtDDHvawaQ2jZBl9DHzbYAQ7bR7aKSe/pB6Nm4tr5daLa5uQhGrzvve9b9qovC2gj33RkRTIj3rfS0RuwQv/yK7sDBf7818F73Ah0PfwKhDZzrUgaPIAgOCwMeG2hMggkVU7fZpH5Lp1HGWrca50gO+v/dqvTWt8pDmQXyxOO+206T+d7gby5p88p5xyyuJ617vetM/7B05Pe9rTplPwAuBsv9sI/m52s5tdh93xwVYZLHuo9NZp1TSulUOhOZBfMQFGJLgVqPhDof7w05OpP+TgvO5xj3ssbnKTm0yg8kRoo/ZqH6A8iWorUO6XYHbadH7midyCCfJ4craxkNliMF/ykp2TdirvxOWiiy6aHPYqF/kRBOtN0U4H8tagB1f2sTZs5gUHAgH4t0ZQ5XAi6WPjd8ri7zu87XGtDl9plZhapoc85CHXBWHmkn8hZ/KUxnoymlcBmP4FTMqdDLV+mk94lhcAWX/qr7zyymmNLdMcyO9uIrO/KfJfhdncPbv6XtepoBTBhkMfewZseDjkb+HBH/rxwT3sHSrxEeQJm+EXKQuDyqsjU7iFYaSd9vYz86qP9q2Z1rh7D672B989j3OZA/mdDeTZxkOjP7b3IxpiF35aOZsLev10pL+Z4JP5b1iFbQG+4J492Xm7MHooBIMCeRTOxTFkg1X15tQbsFVSfv1QaQ7kV0BtwgJXY9rsfdd6wgknTP/oxaIYT2EE6F453fa2t52cmSdcgMohApt7gQ6HKAh++tOfPr2i0j8+ALlO8imQ+ZGpBeB00Km7IMUcbTDKLRKO20J//vOff91fma+KjiBYb4p2MpC3LnwOA88cPayP2O1BVz3MKIctbZAy7STlHhrNxcOiYEhff4S3vxPq7ab73ve+05s0OCcbInNBT2XItXK5+ZiDNSPp05wRfnQlaccPmK9r7cK2e9f+WOtlL3vZR2yScyC/fhrlYGeYFtAo5xP5enaFG/Uear2JZUf2U8bWDm/4Tn/DpJ/+/SqYdmwvaa8vzDvgsXfAiz5bJd8akzEcy8Mcck2O8IzI0TW51JHTXPoMQjnSX3tjNB8y04XcA6q13ZhzIL++QJ49YPO7v/u7pzftrv0zSbbhe9jSJ33etGsroBf0shF7hQm455MdSPqDUvb2kGbfL67RbsTVusi4/taI7yWXfai3vMrk/jbkUNbQRmm75j8H8ttEAMHROiUBDKAH2L4R95fbd7/73SeQ9PSHyGSx+B1Vf8wGSBaQhYCHp0IbOyfYt7bKBMuXXHLJ5Oj18e05Hr1qXQdZlMhcWhTmZ0Mho3k3/xy7+2c961nTqcsqoXcEwXpTtFOBPGwItD3Q2hTaGOACPsKIdq7l1gbMyKVsqg7ZVOBIIO+TNGvGuuCUrT2BkDarovvd737Tw7p5JJ8cdV9Zc0OuJXXWNVnl5mru5mGda9PaMg9t0lVt6dPJ7bOf/ezpc5uR5kB+tcTubOqh1De5bIbYhh9kP2XqYFQZW4dtSds+vVIOE9qwNx/qHvU3H/YWdq8Nnqg9R50ye4gAy35QAL1REjSH6frKk0V5WE7vxkXmE65dI7KSSVJXn/goU4cHXZJb8Nd4cyC/2kCeDXzOKHjnLwTnDhv5Vva4+uqrp5+HFLewpcS+7OczG218VVAMkG+CWddwnJ29rfc2Vazjsxz+WuyizWZxulUit/+tY/2Qz+ESP+5g0noxP3M3n1VTGD9U+vB3HzNtmQBDkOLnugQUgA3gXkP572ICfM48IAOK11D9fJdTGo6YMwMuAPJ9PPADlo1aX+0EJ16jC+q/7/u+b/pHMf7zo1MUi7Hf910HWXhSDrpFTm4kp4s2Hm1y+DMdGWRtwICfHvOLRQJP60Eg7w1TAUNtEZy4lmAIZuQFO+4FNTYKPz/pt4T9gR6eTjeN5VeW/LFVWFwFGY+M5JUia8I6tvFZv9aswMpDrPVuLRTkkE+wV1DoWo6v+aI2Tak11rhtmDbg2s+0eqJ/WPbPmuCM/2Y7SVDgFF4wBCMdalgHsM9e+o+BOptbD9rjBd8wrU+YQAUX8KIcX/iwJwiQ7C94ai9A6W3AZkj7Eky17krhrPqxDMGnh2kPL/YuMpJX0m6Uxzogv3LX5jfWz7RaEkc4kHjNa14z/Z67z3v5UHaAUzGKN/9w5RQeZu336vk3du7ghP3YUcr+YhZ1xTXw6NMc8ZKHNfh2GOl+nQSzcEdmuLRm4E65a2V7iWbPfwjE8ByuANoTJlBwrv5BzTnnnLO4973vPeUCbQ667x71e8tb3jIB2WIBeE68zZ8jz8G1aeOL9NfOghIUaGNh9R16ZesgCxbgjUcmr4M9YSv3loFuXJeTjzNY1xuDmXaW2FwwI9DxSwI2jYJ3m7v6nGeOtYQq106uj3Ug4VESHPl2WODjQdo1Z2xD8k/M9F8FkSPeBWTWreDdWymvlW2EXikL5JV5i+XNmfVqnq1vc+ML8DRXpD4dIbmkj3Jzx9vac7olqJxp9cQGMAdrgnZ2KwAvl2BdW5hgX2XZmE+UerBjaxhiV+XayrXVl9/n5/Ea9wbXSK6NgMu+4l5/exOZNkNkDnfjGiRH1+rIIBlLkFZwJ3izp/H15IFP/ZqzviPpnw70x781MNPqSBD90z/904tHPvKR00MpO/me/ad+6qcWj3rUoxaXXnrpFGfwM+zCTrDEr8Ilm8Ek3BUIw3yfjeGnD5Kr146dwzL89zZ1nQRjEoJRnwuZB9nQXsPfHMhvkRjaKbt/A8xZAoVAwvdkxx133HRvswbeo446anrqtCg4O4tBXyd0HLZF4jQFkCwE7ZS3CCwaTtG9cXsq5lgBD0/jVF9QsWoyFhlaoAI1SSDFMXSvDdLO94+c/LpknGlnCGY7HYd1awO2wwLcwgAMlWwYMBJVpo+kP4fv2vpqU9DGerGupAIGZU4ljT/y3U5a5kse677TyIJusgv6yK5OgN83zfqkj9a8a7zHNVZ5bfHVnj9w7Y/R6H2m1RJseThlT9dsC4N0L7GXe+WCJe1gMTuyVXzgA14Qn862bB5fbWsf4TGuAakHAnUl9eTBy/1GCe/6mUfylNQpi6fxjU0GJ7H2I/NQL4fREpnwMMaIZW3l+Fqv9tTNyDzTxohOfbt+5plnLp74xCcujj766Ml23hq+8pWvXDz3uc+dPjFx74+u/bEqe7JNeOLXYRo2tHN4l58TlNv7tUetB+PCN3+HrAt7guTrhXUf7pEPDo1Pdoms5oT47r1EcyC/SeJcAc9JnyABGADYiWO/OgMkgMlJlQDZSYVyG692QGQROLXMwXkyVOZ3hPvkBsh8o+ZeOwuCw8O3gJ5MZPNQ0CJaB1nkfVfmtMlCFkxZFBZ7T+/ktTiSd6bDl+AYHq0JJ5dt3AUFNnS4gQUJjhFsh40wrE9JHSxZS/XJISvTXzttlBmrtQmL2qyC8C01N+MnFxnJSxZrlFzWi4De6amHdPfRsl7MW5/GwE89GufuM6N5bW0/0S0982tOG+GJHbNDWOZ7XbMbe6oPu+wXrxGjeFoj9oJwgthRW7ZF2i6X4eMeqbNXCJDChFyyT1mP2m+GyIPCV3nXzUk7uJerM45x6Yhc5iSAox/7n7bhuT7aST6xICs9Nv5M20NsIsh+9KMfvXjCE56wOPHEEyedO1C46qqrFq94xSum0+lO39nMz0t3Uq2M/RzO+YyYfeFcGTyzGyzjgdhYUmcc/bWHeZ9ZOuSxluATdtdJI5ZR+CWf1DrcKzQH8psgC8H3uE7XOXQAtgkD9C1ucYsJkMosBOTE3R/ucPKcG7BKAnX3fsHGyRwwtcHr61QDFRCr9+17zo8cFpkHgr5PE0BbYMrW5QA5W8n4gvhkt/Bz2slCdg8itZ/p8CR2tkY86No0BCgFLZLr8RMS+LA+4Nm1MmuDI3Uv5XClyuXWgmSTQK6rt55sKtaQa2vN95nbSY1vE0ge8ksezj08mGftEFnpwb11YJ041RLQ+zTN+lCnnXq6cU8n+EbmiLRTbq3N62r7iM7hpsBS0OFwBbaVwyvbSGzG5znQyB76Syi8wq8y9ewpWQv2ErYLu/UZy4wjlxobH/3xgSlywZv7xlaujbek9oeNUGstvLXu4Lz5NncpOZujfq1zMqULcmmjD16VF+Bp6xPVVb5BO1JJbPKYxzxmCtjFKuIEePUlwIUXXri47LLLps/02AaFo/AmZyc490f04hjBeL6X7fw9IJ7j76/DAnxr7zpb841k4p+9fXG9TgrD5mN+YZtscvPdSzQH8psgQQnnZPNl6EAqQABGgOjVIjBwnH4q8vGPf/ziVa961RTY4+HUxAMAELv3KsvC0depGj4XX3zxNIa2yi0U1xxcOfDZwNVz2BwgR7ku4rSNDfxeD/cHfelAcs9paCNY8fRv8cx0+BAsWgvwLoD32UEBtPUiwXdBLKcOwz3YqsvJw3yBBMwoa4ySOu0kfbuH/cqNZXwPE5Jr35B7Q2RMckj4bZVaa8lUIGMs8yeDREb3NkbzlBA5zVHiU5zQC+rlfAC+eErxQtoj5enMmtLe/GY6NGI/vtThiABYMM/PKw87bJD+EbsXqEruEdu4DqdhBeHhnn/kK+FCnYSvPQSvyntYk7THm0zWkhw+tG096aO/MarbCGmrb7KP1L265pqcyoxVwqd51y8Zwq12ru0f5ke39AH/Mx060a8g2Sn8Xe961ylWsT+LOfyghl+68gst4TlMwrJTdz8awK/DPXsWb/jlM36eb9VeAO+PYq9//etPAb727KvcCb1rtkXKHHDyda4d8MHwOqmgnVzLRKZ9le9m+r+rdKZ9Uk7JUyTjA7LrY445Zvqc5tRTT50cPgfEIWmD5ADqNB2I/Va8/4YK5BYKB8bRCfL9YRxnx0H7hg24EUApBzzj2rD1I1MLT46f04x1EhlKwM85+B1v39W9+c1vnpyEQJ78XtGZo5z8M+1Nsg4KgOUCHCffsMexO7EsiFevvbZsHm7jUVAEu8rgJGy04cO/pB+Sa6e+a1TgIimvDm9r0wZmPCerfmbNqZSf4rSOt0pkXd4MjNuDtnWJtBOYNJdxE5Fca6PcRmnte9C33tW1xvkKD0V0hZTpJ+FjTLqfaWuU7eCZjukaPsIy/LCBtIxdBIPZkm2yv3q82Qgms5l692G/9VKfyo1hPPxhJPyMwTy76x9pKyFjk1nbjVJt9Y26bq2Ndcu8G1u75o30kZSZvznSszJ7iODyPe95z/QwO9OhE737/zR8nthE6g+Q5Q7fYClcsQlbqPcAq5/EVwro2VUd/+TwwcEN7OHhoI7/Esz3YGl87Y2LPzKGP/h/17veNf1spZ+fFBesk0YMS6jrvXjQOAfyByGO3KtVgOXkOUuvzfujVkG3e0DtG3aO1z2w+wO0448/fvoHBPoIKNQBOtBwXk7lBRuAb3E4CbrxjW88OTgOX1sPCZyfBWNhtBEESPlWfqHgUIg8dEJ+156wfeNPD679Mo9Ph1x76u/zgZn2FsGXgN1przdGnLprPyPWyaVTGI4f/uAfNjl1iQOH65IABI5hBm4FGXLrQY7CNT7aIfVdWytRa66NIx7au5dsQh42rD/tyOzBw6lTf6OyWTKH5iEVoDXuuJHZHKx1iU74ETq1fgqy9MVPTk+9zUoHkrZ8kjk2lnrJvTnRxUwbJ7qECw+hfryAP4MXZezDD7OX5LrEFmysP52zRUF2QUsYiNhpzNlUv5GXezk79yCBvzZ4ZW+p/smmn/ELpGAPkYcf3gjhJ+EdLcs7zqm2yuT1U470Vec+Pq7J7KFJcm/f8JvlTnvHsWfaGtEpHPPLfAMMCNwvueSSxdOe9rTFM5/5zOlnJ/kmOKHz/Kg1INh+znOeMx0+6s9O2R3OPAh0AGksuHMqD2fx8wBqj8ATDyS3B3RgITYQN6yTyIvCGfmsNffJuZdoDuQPQIzLmQOwAIVz5Cw9oQpcGBwYbc4ACdAcv+/OBLD6AawNWbKBOxEEIg5NDuT+OYEg3CLi3OTGRcZwr10bTKcvOeqCJWP7fICc6yBzNz/j+aMVv87Tb9oL9uhI8O4/T/q7AKcss4PeWwRTHkYlJy1e03J4AkYYhHlBPQy4z6HDZQ90vr20PjzEwYBruWC1Td7GAM9tFHCCVw5XO2vBfe07FRXguK+963DWvWTdkFUAneP29y7WjHWpvvE2Qo1BrhJSbjz8yYjoxFpBNlZBo9fSHij4Ce3aRMmAhz4e+iX3jWe+9G2M/Eh9bnjDG05rb6aNEX/q23e/w+/ABvX3DewRdtiF3pVJcFeqvrZs4V6dnF3Yno+WRhwjds62cjZVhti5tYWXscnhvj74SOqsV0mf1ox1Jlhyv1HCz3jyZEru5jeuu+ZSv7FMm0iZBO/WYr8hro8xxrnPtHWizzve8Y6LF73oRYtTTjnluhjBybdTcG/73PPT+SV2cqDIF7KR/27Kf/M/Hq58FovwZiM88nthQSzEz2dLvNWLXVo79VcPJ0g9HusictGJeZIFFs27NxR7jbb8n139d06/k74bCBgEGIILoAEwQYRrTk3wDTROtxhPIFEQIe0G8vrr+7//+68LisjONJ6WLRByKkPKLUDJIhtfBVl8L3zhC6cn5S2adsPkU6EWJxskFx17kLH4/YQV2S0cfy/ggWYdtOq5H4jgkP53G8GRAFKQ0skwe1k7glt2ZCe5ExI25Ox3mvgZ8hUYwJoEV8q6Npc2CFTAgFo/2vAP6vgF87VZwQudeOjom9GD0UMe8pCPkMk935Jc9Icv30OvAkebJVkkMozrOTnlyvHgDwT7NrpwzZau8w2SMbWxxvwWtE/cVvmfXR/72Mdee7Xz9CM/8iPXXh2Y6IuO6EpAAVdSgU52hBvtXLObe1jRh97bS9jKfXbDX9JOjrJPtqu9JCAni7F9guk6Xig+yuBqXI/JiYdr8kna6uOanPDnm2T9N0L2ovZMshqz9WAclEzK8U3e8uaqfXOSEN7KkPWgj88y7WUeppd95078Z1d/uOmTj50m+uOv2cT36h7S3/ve904/FenzVTbeC+SfYxbXwAy55VLrhe/1oBFOVkV06osHub3Pg403cfzvq1/96mldr4taJ4dKh0Ug77TaTykJgjmInElAASBGy/E4JeY0ODjfdNvYt0uhW6Vjjz12cec733n6dtfDB+dMVjICeg8nFoB6ZYDXH8apF9Cbx+WXXz59d6//KskrNwvQRkfn9Cu3eQgi/JyVTcBioe/+wEWbVet7J+25mwJ5OLEmbJhOHJw+s1cneuzjWnBpg7VOJKcqXnP7XnWdjm1fdJ/73Gc6sTEXRL7I3MxDKrBSX6DQKY96ddaEtWLe9CCpC7vWm6CC/cYH5H3RQx/60CnXF5+uyVFZfgdfehaQIzKYj8CFrNolo0Q+eW1GXnLl6aO5useDHf2jF38wv8pAnhy7mUZsIDq0Np0Ap3P+i/9kb58K0C8bdSoZNlzTLxviAxvevPqmm620OVQSrBkj2YwBv5IxjdPDnjb2NXVkVAd3HVCZlzaSte2XRjbqk3wymi9If62dKOwh/p5c6ao+zUPfys2DDvUhMz7a9LZOO3UjHUmBPF2wKX/tc1y64rPvdKc7TQ9tPegIOF/+8pdPh2PZfNR/Ot8t5C29uSDYlPhAmEpeie9d9X5Dx/6+0aGWt3HeWigji6AeLtdF5r4dtGcCeU4hUUeRORz/SdXTKgdgEWgLFG1+OSDXUv0ZTIDp04+dDljucIc7LM4+++zpu+PmgDjITla6Vi+ZC+dXcOIkzpychNvEV336/brXvW6Sk57pm/7I4Y2Hk3j/xbJF69pGaTEnp7ZbhN9BaVV8N0K7JZBnF587cf4epqwVZU4gBQFttAIGyeddPoeCLSfyNrJf+qVfmt7yqNe2DWKdmwQ/41SqtSsvwRZSbh1I5rWcrJvkbg5o9BdIbq05GfI3HjC6P3rYwx425WGNPPjCNjlgHW86V0ZWbRpDP7ZoDtoWyKnDq3k2P3W1R/hmV23MEw8/KecbWBvoqohcO0nmad50ItGr+SujE8E4n9Q/3upvOjxU0W26dC3BuH4ovJjjqPPa0nUn3F7Hk0Vybayt0K1udavrdCr4JifCF5by+bWRk8O8zZP849j66WP9e8skSDKvg5FAng7xN1fzR/CHjImaszHhuXryJKeyeOApGLU/kEOd9eUaD3vxvuhwDuTpqN9fhyfjCjLZ3z9P9FbUHs//+bRRcO/7dvuLvvmabEKPrmHBgaWHzd1AN7vZzSastKYczJhvDyEwg8i76j98Nb7Pma0Ne7U/uoU9eqTvA/n87absdqi0qwP5DO4PTX2DzdhOpT2tBmK5E2qn8ZwJwOc8mpp7IOJMtBfEtAFoB/QWixNmjpgzd0Kg37robne72+LHf/zHJ6fLKZOXnGTj6Mwd8NSRSyK/hZszFSibhz84WUcg75SHbHRKPrKSwRzIapEKAj0keVhiO/YhF/npuAW83bRdC2QrtJOBvI2Sjm0I1o5Ajo3oWjDgu2zrh33gJtv5GwZryB+zwj9bOW20mXkIY0u8BfjqOVu2XZX9Rrrvfe87YSqbwv143TwQedRVjlwrb91UL9emds1FDstOu9761rdOPmJfdO655048Sngi13wTHaOCIpQMvWnzPXbyS67xqT1expescbySV531xi5OmfWJv7dyP/dzP3dYBvLGhUHfV8Oz63yl1/P2A/rK7vlT5e6VC8zpUju2skZgXjt1xtBO0o4ts0E6lsIMfFpf1onxrJ0C8Y2Sv71q3OYDH8aQyKBcGylskMPep717dXL1qHtvRO1vByMP/3Sgv9R48UbhtJxe+BhUn9qzj3nYxz1U2Qvo1LXATRtzo7d90eEWyNOHB0r2doBnv6BviR922u4fQLIpHUb6+Vuld7zjHZOt3auHORhmh/BNn2ziAU6Qap34fITf5tf2p+tVEfuRF1bhg/0lsrsvxoEJDyCrJHjz0Ay79jwy8RutOXhTtg4y9+2gD+08u4xa/H4Rxh9qUDqn7VWI7widHHIMTg/9sZhTLaDNOVMOQ+RolHOynK0gRl8LCR/OXXJ92mmnTUHDXe5yl+lTlzbHdRFZLTAbig26UzsymItFK29+gV+ZeZujuepPH6smY3EY5CMH+diCjsvVk9dTbm0EHoiNZzp0Yn9/HG1tnHXWWYtzzjln2iBg2EmPJKiXOCv6hxXXEhspY5vwpo/15ttGv7bkj5j9N2L3Tox8yube2lk12YgECZLgaDlgCVdkh0mpAENq/ci7bp5SPqJ+1pJ58S98xf4ID+MifJLFuhw3gsau3tps3JHUNRc84q9948jxVsZXaO9zNevLOOzJtsu8DxdiI77aK3F4pgeHFwJUBwSwTEd0h+ghjGtLX8rc46UdvfFV+PH5/BIM1M61tuFF0k+Zeom9yCGg0t9axE/bjVL+mzz4Gdee1UNsOFqWxZyMS159wkFju2++lR2I8KLD8NheU3l18gJIqbHlxrfH2sOPPvro6aDKr7fZx+lGzueQB591B5Y7QWzAbzpR96bz53/+56evCeyVAlp68xZw/OUXfdifnsUDgnC2oDO+6XrXu97UL5tkX+1dOwD1JsobWTrm0+jfYc86CX7JA6PZHLmHSyk8rYvoViDv4YgNHGJ5qOIL9hrtqkCegS1uDsArJA4AWAG4DZxT6UnVdSdbQIw4EkYBVADnHF1LBTDaA4wFob1yiQNmRMnTqz8sEdCsg9p4zIsezNVphQVtvuanjdQiMH+LU32vhgqO08cqqU2n4IEO6Y4M5OSc1HFI9K2MHWqj/0yHRvQvqDnhhBMW97znPSfMct5ezVo7kvUgKM8usJG9OLOIjeBOWWuhjcB3mpyc4N3POPqUzf9PEODjv0qCcQmeyNcJ1Ijx1sW4TiRERwU5kvVVUhe5Vm/udACr9Dm2GWkcp7HLBdbK9a2MvyE/Mk6bl7r6mldrWhkZlVtDcms8vuaUv/KQo03kgGN/cu9VojMBif1BcGN+dAjLiK6QcmXsqA+iO3rN5vrVPmwJ4ttLtNHXvbZSZbAhKVvGVXbWVhA7rq+DUXOJL5md0NoD8Gtc1whWyA0TrpFrCc7G4Lu5boRgT3/9kql5j3iXkkE7e6U22rrn+/kdb4Wcxqt3EODvwARQ6szzSCEn8N6SOWShCyfPl1566RTQy31KQ/fZjQ6dZAv26ZW+EXvQmwdXdnWfT9BOPzhUpl2YUQbj+MnXSckzJv6q2ME8pOa4ajIOnbCBT4TJ0tvqveg7d420AAdcFrxggRNkbMBusXNQberqcmCUXpDOQIDsRI1D0TaAuwcc9/qp0z7w5IzVu8YTANdBZOE8AYr85Mghc5TqLXCyKu/XNXzq4CSoBx2kf3NaJbU4BS306d61byC9FSCnpIw+6ZWNyZd+zXOmrREdWic2SqeU8E/fcCJnD3jvJ1QF9a0lttBejlofSBnbaOuavQRObMfZ9W/UBfk2mtNPP31at/HabmpNJg85zQ3mmiu8hyV1lSE5nOpvLpJr7dXhYY25xltKNx5S9je3+OPd2OHderSW1eFfmXHpuj6Ssc1FGZ7WcYFUhEfrTR88yMhONh925iOMKfdGT9u9TOyQXzc/37zDMEoPbEkXYYMe2UCd/vma6tMh3WqjTKIzfpTf0gapj/QxjjLX+JGphwX88FEuoWy6UTJX/MbcGNae/SzcSPBgD/AJn4CODOP40jh/cuu/EdLHGO1J8InSl9x88zHqe4tMh/y/BxB/J+UE2eccPjUir7/f8mtnPll7+9vfPunocCeB4cMf/vAp8Sf8gM83/EH6RRddNP3gBl1cddVVk86zMTtI7E/ndM3W+rN/mBt9HVvDinLtS9rgqdzhhAfidVPyktGaDo9yWE/OdVBjwyydu+/NB533ieleoV0RyFOc1z2e1v1Bh2CB0Z0y25gYFwC0Ux443QPt6LgAHnGAnL6AQxADOOoDfH1ySnJGxBfgtZdcr4OMzRlyigG6xSenB4sXtbHZwOnKtT69XjYX+loHGZfM5KTHNkQPGE6SOHFtLBQnnM3HopGUZbOZNk5s7ie0PPQKqMMB/baxwgzdw7l1Ai/0DRt0njPVT32Oq3VgvSjTjqO1CVlLNiZ8wqDXtWQR4Btru4ms5IH/NjDz7H5MsIXCo3vzkdznJyTX4dGBQWtPWTkdCiCdIC7TuMbIaHybLPzjJdcfb2shvQrqtUVkyrfhkbxkay7q9JPUWWNypI/+7GQsAZR/5OIbW7z3IsGbPwCEKwm+fYrhLVN7QPNOd5Lr7IuHstHW9aVHusVDmTUgR9rVho61YyvX+MO89vQtV5Y8owzKrEH5Rgm/knHGgD48jHIp047PhzfXPufhV/Uz7/Qk34wsSB/jGI8O4Ms9PvGMb3oK9/qYh/Xgj2x9MvLIRz5ycf755y9e8pKXTJ+P2N8PV6IXduOfn//8509/GO+fzzkB9ispv/iLv3jdL7Tky/wndH+P5B7Rt8M69hTL4Em/qAMG35T30K+feIcfDpdhRa6vU39jwse6ifzkal2Sm1/05YGHPHLSmXarJmslMp79k1zWlDXkc1K/FGR/2wu0KwJ5jtpfNQOhAIFCGVXiuNyXBBwAKwGF9m2KDMKB50hzdMtkgSBt8UBABeAApkyyeAp8Vk1t+OZswcmTn0wt1GQhG/ABnTZOXS14mwfH3hxXSYL03piQj63kSLk/rrJAK6dLehbIcOKSMhu0BTzTxkgw7RS+V9bWDYfD/gUt1oJNlL5hgQ3UwXxBDtxIdG9j0B++2AeG2IzD18amHF+8lMEg3Blf4OUTHJ/faLudhJ91DyvksSkhclgT1gqZC5DVq5Nct5mpMyfzoIuSOWsLj9rg6d619QWfPiUiw76o9nTWCY9x3Hu49tlLMloPbcbkMkY2YxO83Jtna115m5s8X2XMxpasfX+A7BTUqeheJFjsW1X4gknYpvv2AEQP9OOe7tIfbKdPVBs5HMnZhr7YRJ3y+BgPb23US7Wla7gnS7zSffKwW0ESPKnbKOEhkX+cV+OTST05rAVvwwSH8InaP+ofD/fk3uie0Lj6mZMx00VrK+zKySXVj3z61MY+4TfPncIL8tUfzkQHPh+67LLLpiCejXpb4Y/Q/SxzD/b0BPMwRVd8Nv3Qu3rBvj9+FZyzB4I9/uiWt7zl5E+QMfXhrxw6FBCna3UIf3/Eyzetm8gAJ+YFq+SDS7LDKlmtmVXjw7h0SQ4J8TEemmCV/hws+3sGv25Dtt1Oq49QD0ICCH+wwYFyFJwN5TJmzkB5oGR4RgB6RgcMPACYc9Mu0KpDDAH8OV/AMQ4eOSebY2M2lsUlULKx6LNKwt+8yEUm8+yhhCxklUuVlQIauZ3I2cib+yrJGGwgCSIELAIIr1GdFEgcmMCl4JHjoWt9zYPu5XRN/pkOTE7D/TycPzgVQMO9FK5bH9YTndKzBFNydtCGo9debt1YQ5I6xEaSfkjO+doAJIGkMjYVzAvi+/5VELadtjSf1m8PFuZrjPyAdSPBmnmqk1sfruXkFYRUhh990JXPhkZ9SdoKJgVKvuf1dwIjwS68e/vkVIk+8ZSThb6sRwE8uXrQkPCWXJMrP2de2TIiK9nwpgs6aBxJe3LY9K09J3vmuNfIvLz9MFfymytbK2cjZZI5Z9twEDa0g2l2rS49lcKApB6G86HGNqZy9dGIG23J5toYrkvk0E77zVLyoXEcZfF2zQfYM8kJP+ZtvvrQi3wkMqrfaJCkv3H0I0NyldJ9KT3LJToUaAqG6MEe4JOarehkrxEb+Y+qTtz9l2V6dwrfA77DrfSQ3rQR7LMpX+OeTemWX/D5lAC8vyngl73R8Ktx4pOCdvx9ouPX9/DIlxdTILbjI/irdVKYDDPkyQ+qq5x86yC4NjY56M0vKXlrRDeC+vzBSSedtDjjjDMmv2INVr7baMcCeUpxsujpB3gps02YchkVFWQDcBt4J3PA6rr2FpEywMCHoQKLNngh9a4LALQlj7bKA5WyTjtWbcAcJlnJY57IPVmqoydyCxJca2vOcnqykAXQ6yC6I4MAhaMS0PgdVqcNAnvOh969OfAwJO/TDCcMvtNzTcdsslsXyW4g9ufo73rXu04/Dyfg6RMXTkZufRTEWAuu6ZQNwpTyAp7WlACe8/JAUB/2KADNxq5tAAWkCE9JX4GutwQeNMizXdQY5B1zc4FBsppza998rRXkvqSPtdSaohPX6uiBXuqDCp7yK/Q0UmuPzsiBFz50oS0dWRd0xq+0EdCjtUGvZLVWBOLa46mtvDHyRRLZksd8jKmfNTf232sEjx5M+QI6TO/NNX9P12HeNSyEY/fa6VN5tqR3+pL4ySj764OcmrKJsvxRtkBsoQ5v9cnW2Mq0r854GyVt9Qt3ruPTfJTzpR4wnSCStzpEPvKHBeXkdU3GjVJ6059c7tNfc1ImGVOZtmFcQrAImzB/JJB9zS/fsZk9mn34AJ+0vPa1r510kf9Jd/wAX+4fgvnxgNvf/vbToQicq6dDJ8UejPwtlDIxgL3WA4DPz+Ai22hvXMQeiH8KE+r4nHVSmJSThYzmISmTyKRuHWScYqj8Mb/AbuT0zxAdiLCVN18PfvCDp58bvsc97rGte9t20doDeYoSwAGqVxe+reUAKBOwOQC5e0p2zcgASKnKOG3K1E9yr1/3EkADSRud/gzVtTrX+GmDB2JQdcnCYbqWVk3GILc80CeLcmWCKPOwENRbqOZrcTr1cBq/rsVAb8nllNbpY8E7mXIiZDUHOvatqxNbDk9g754j4pD8fYTPrGw4+M70IaI7QbKfcPOfOjl9gaKHIkEjPdNZpwbWWJupFLlWp13leMOYjYB9pDCVg+NgYU5iF/hie+3wksjjodwf33odaTOzdraDyCd1HZHFfMhMfolMta+t9R7BIrzK8w2uEZ2kD3zMqcCwupGMywZwbO7eTGirnb4+N6Iba8Nmbhz1ZHZNr3TcgxG9Su5tMuRrHniarzL1+uJrM/dHhdY/vpKHsr1C6UqQwidky3z4SO7DN73KtUs32UkZm2d39RLSjn9i17BSX/zQyCdKnhJ+2uhD5vi1VyE2HbF3MGo+xpfwSw7JNf9IVwh2EHnUk8l4MNKclTshd01n8oMRfiPpY+zGcZ3u1LlWh79A0/g+pXFqDMeC13XtSTtJcMAX8APiCuvUb77/wi/8wvRHreMnNXREZ5IHWHp6wQteMH164yBOXGRPpOswxLc6wFGGrH9r31vubIQXnwSHEhuFH3xgMnysk4xHluaO3IdXe4s3+tWtmugbJo3PX9K1XxXix5WxE/z6NMrbFZ+F+UzSfqvdaIfdQGuNlgTfftbR9/ByDoYy2rQ4L7mnTQEE8HEOnKRrjouSgcEiQZyfxQAoOYsWSGAFaH1qgwfCM8AbN1DJc1Jt0pzVKsmYOX5j00WUo5TUy1ugiJx0SU/rpDEIknNebMc2ZCSPnE61Jad7NjMnSZsCIhs5XHgl6TViG9CRTjZHpzScNH3BhsBdojt5Za2VEh2ro3NrLSyxl7XALsgaqC2McayCQ2tO0la9tcAurTVlPUQY27UA3s/H+t3oMHooBD/wjsje3FybE5nH+aLWcespMk84Dbvj+oc1/eV44Yu/cSQBZ/yRdnhrw8HTi3pJezr306DwPP5utnp2I5txrRebste6cvqme35R4gs9JHvj5Rt4yb2Nz3rDT/CQ/f28HDvt9rVDb+QWmFr/9EXm9Eo3bMNO2TJ7Vi8fy+m9eY/36l3j59pGTa9woJ029EgGdncNA2SMtHEf1lxXz2ZwhT9+1ocy1xul5iE1NzK7rsy4ZIRFcpJJ0k6dXFIHk3xH65Ke1R2M8IHP+OGfjpTJa1e9McwdlsmJ9EnfhzPRw41udKMpYH/yk588+UJ6sE5f85rXTGt6jDvSJd15gykuetOb3jR9dgOXgka/Ne8P1rVjS33VWfPGgzu6FcTDsGvkzV6+2Di1ZU+46d5hGmxky1VT45bMvYSUrYvoxVqlDw/Gfkeev6XvDiO9RfXGy2dR7Mc2b3jDGyZ7sq0HLQG9mGVdOjwQrS2QB1abGWfi9Snw2aQoFEgZkgOgJHW9ns6pIs4oR1vgSumMYKFQKF4MJeHXZl09ytHkhLRtkcUjB+RpzVgtlFURmcwbkUFqY5Gbs8UgJ7cyORkLumyKZF0XsR39y3ui5lg4HCeG9JpTYV9zMod0bg7qmpdrOPHw5JReUG+hqD9SiV4E8b6FZFt6FCDQNZ3TPWzDD52qp3NrpSDfvWv6pXv9W2etDdc5erwqx98a0g8PvNgI4dG6knLMUicXPgciuwez1vFmyfiS+TVO5eZL5vCFqjcP8plLqbmZrzqp+eGjr3HUm7u27lFrLxp9DZKboz50I1kH1oSAO/n0S/dsIfGF2VQ768qvzwju9deW3m2+ToMkJ/7Wh03Z5xb+G6Xk+qyzzpp0stvI3ODYWyUPpvYEc6NrOmEfiY4ktmGj9Bke9aldfNlmtI8y7WorZyPYhHX1kjI5+0ojDvRB7tOnMRtPfXJJ8WJPttwM6YuSNV2QRyKze1gKE8qtSzpNfvdkTU5Y0o+cGyH6lVA6xQfhQ068jW0c9Yh8/nmjP8JMBgS37g9X8vdBj370o6dfqDFX69knri984Qun03W6zBZ0R1/8hHULJ/7zOZtqo46O+Q12Q9lem/y6MrzK2R1/Y4kFxC18Bazz2caTtNNeGbnX5SOMKZHRHMlNnnTh4KF9ZR0Ujn2y5G8NBPH8rVN3f5NgLY/rXFt92FYb39Srt8f1T712kj7s9VZIgOdzGq+GnNZxcJzzaFxKUU5ZlMIxKUMpUp8CR/cck3uLwZMo8OPRJqk/fiX3OTgJ6JNBvT5t7JJ7KRnIuSoK3MZIJ3QgOKe/ypDFDPxkNuf3vve902/ReoIUDKyL2KEghN7HxJmQrXmYG3nZJsdWUo4X3dO3+XrYE6T4pMSpJgd0JBI9CM44Xrp0OsD5+FSDfq2B8E7HSMBOh/TOOXLmymCMvulaHyl7wZPNQr121olTUrk6/OCOHdQr04/98YFP5VJko3jSk540pZ/8yZ+c/mEVx2eczRBcJBcdtA4Q+cZ1g1xrT7bm2nrWVh/X5EfmMvKGx/yAds3N/MfPhRqvHGljEzU+G9kcJHYji3LtjZGcbCuw7fMSPJTxg+zvD3H5AfYokdlcpGzH1oJ7D8K7cb3QobkI3gUZknmyA10JVPK99DLqX6qs8uylTh7VFlUup3P6ol/rgc4kZbVJn/QHJ3IpfdfOXEZ5lGmPwo98M9Rak0vGKyk3phNDvzrC58M3PTTX+knays2TjxCo2B9qeyBq7HJzK6HmX0oPDnB8UuNzEnsC2fSHy92Ix+0guhDIeXg2X1gWxL/sZS+bTnPpBg7U8UPasyU/Au/sqI92sIiPh3Q+m89lA33ok27p0RcN2vHv4h99+YnipmxnTOQa73DMZtYIjFqP6yDjGZds8sg1P0BuMdy6yNytH7q3j9IhWegMltksP5LNyE6H9KmuHxjgTzzA8r3a7gStPJA3aU9bgnibEcXZ0CiKkiiE4pTJGZRiKJXyJMrRj0PimAJr4AgYjCAVXOCPAo8xS7UlnzHkEjKOOu0YC7/GWBXhb3w5uaV0kn4KLujiXe961+QsrrjiiunfPftW1maozbqIjiVOhq7aGNMpW3FInIzgRllkQWRDubbKxnlrr79Afi98KrDdRI8+UYF317AoiPeQROdO5ZwewEOYRnSa0y6nO7aCD+3HtZdDC2PZg81swtYju6JxzRjTRsIRwp5glVx4GlfSl+28YfG7vD/4gz84/cEQ/hslPMlqXMkakfB3r87cWrPqzIHMNkP3KIfcpqaf+3jojw99oMrxlJPZZzL6oPSaPMZUJji1QdpY3dOhMfHJJ+mnvX5k1FYfG7xUwI4XWWs/ys5e7OYakb257sbgCRa8yrYPWNf0m08nt/nANv3n68Kpts3HPOkSpXd5c0/H8nROf60PfNhFjq/+qLHUkSncu05GbUrJFQ4kDykepLZyoIKf1JzwQ+6V04lg+f3vf//kC8ynduZJjjH4c+0B0SdZAg598TkY4RMPNOq263SO6LFr4ziFzj540SF+hyPREWyEVW/QfH7BJ9IBrKZHRE/WNNt1Wq+MfvqMl27ZSZswqwwvD2NsD1/qYMI41kw6Jwe+SK5cIodxRp8oLoPzVZP5kKG1U6zioM4BhnXvfl3E73iQSn+IXsJqusoOyZ4uER26tr6c0vvchm/bCfqQNVdEJgqcwCKYA0TAohxKCYgo5wmwlKOcokuIU3Ji1UaQIlsIeKBAkwEaz9hkkBo3h6Stdvgoa/G1IBh5XJDbTQGneZDX4lw+qWq+nv4EOP4bnO+3yG4x6LcuMr5El2QSeHBEckEgG3Fa9GmBcBjZqLmQO33bEMaNyFzU6Se4aSM/Ukgw5r/w0S0sCNxtlHRuU2Z3D3BOfjh2zmnEO3Id5mEcnwIlZfTMNkhQLjBUN9oke6jTFyln32wmqefU4FD/5NDGXGBBH9+Tev3eA/nByLyMCzN4RvoqI68UpqTqCySk1lXrjFx0i/TNLxhLX/XmjfB0782ioDtSL+HbNRnNzVzN22dFgnRjsoHUetAmbBsTH3IqV68sm+KtbzIKFppDds6POeWyBncLkZ3fTj9y8wwT9gf+3xx602Qu4Ri5Nlc6CZOSsuzoHulLb9W51ofe3SeH8mxPp3Ll2tAt+7FlWGgc/bILeRpXf2vT+Jsl/BqjPKxKxqIzuXFc87VsbV7aIA9Ern26xB/bg2FGv41Qc5F3nSzmmv7lxu1Bhw9Yrjcncq56/9wpolNvw/lkuHUa761JmKIDMQs7WOf2bSfqyhG9SnCGvM3wBo+9lNOdtnRHl2wrmDeWMawJKSy2Zvjy4qbWEJvgiR++rmFH+aqJ/OHPeOZrLv6OwN7loWad+KAT4yVXdoDnbJNe6bR2dC6132gjsb9DNm+cYX3dtNJAHlg4b5sYZZh8QCvnADhKCqQs4K9OYCCp67RKe/fajEFHwNQPUXrAUVbSr0WWkdwjfAM7Sg58WiirInO3WZDBXKIWL3nJEogEEz654MgBR906P6tBHIVxsxNiH3Yin/mkM/Oj22xNx+YmZQtzyxajTV0XGLWpKsfzcCZ6Mnf6oWsnMRw0+4cHgZA1xjGO+hrXQ3qGZ/aAl/QteGkdScrwVqa96+7JoD08Sq45sMq1Iw8esMjexnOtznzYDzYEGTa4jWwk5E22EvkrS57um6vUPJtfOkhPckmZRBa6gy1JXT5Be/MjMxr7hkVt6mctsI31UGAutc7xog/tlNFRspmzPDlaS+bgQQkWxtNs82RrJDcHsuwGIj98mq/rbODaPOlCrt7Dh/vsrK35SNqbK5/XvNkmO6qvLf6Sa3Xp0xjaK8c7/NA9nWmXzO7DpvZ0L4CCd+3dwz87hDtBmLdkrjdLxjIuavzmJg8zYYgO6MJnFj1cWofmLXhX5jMcMm+W0rVxS8qyG0rH2QmRMZklctKpPyi0FpQdTmSuTpXpwLpke7poPWaLM888c3GHO9xh2rPpge9LV/Qj7/M7NnZoqT47jHrDv3XRWJJruKyOTMaHI/2V1da1MWFDn1WT8cKP8c2ZfE6yYZQM68QGOVBrni6k1qBEvuRG+pSQebiuvbXHz0vrxvnKRqMQwTfQUlQASwkmDqjqKMvEKVIbpL22Oa/AqEwbgKdITk2bDCDPeXB0Tnr6vXIKxkuddo3HYIFbaoz4aWe8ZF8FkbngxsYv2eSNrc780Th/TtxnJ3Jytwmui+jGRibZ1OiQvGzSRkuHzSG7VK+c7m2E5uPa3PCRd42P9v5o0h9PSj7VEFCll8ONzJnTZ0+6dRovmIZnRJfw7FMFeihQol86ab0gNoAPBD90WpmgBH+JDegc6cs+2rCLsW1U3hDJ9VOm3lh4xhsu8OOkycneMKLeNZz6RAXekXkciNjeA4yxyYI3/2Cs/EDzHeehXDv39THvfVEYbb1rF3/X9IqUcdjLZGx9UXqzfvk/61Nybf5kbYzkdC93n60i7bUlv7XC1nCQrdWZH3JNz/jJd5roxCmk1+fmTqZsmE3SnbmYUw/rPShqQyeSdtlUP/MtR/J0mB6V9XbCNbzRoTHoyXjsY2x9yIhnyT1ZnLT6dAKuzSHCQ9JXe/Pcih/GI2o++CH3rsncnkhmQaI/mrSWtFHHN9K5nyJ+1ateNf2G+WawkC0kunGa3N6ijJzJA7OCQbqxPulAnXKy6kdOP1xw//vff/qDUHya114nnz7653zeino77lQWhSG6cErvF0/8Go3PYf2kod8oVy8uoWP4ojO+znX/eyJdjilcG8O99TD6N3y1qVzCy7pIJn3l/nZC/brImBIc+Rsqv5tvzj5LgZd1ET2QgSx0RY+tY/iUa0NP9JYPSm+u06m+SJ298fTTT18cffTRk58xxjpoZavJJHwv2GZtkhKiCE6T4QImpbnnoFISh1LAhwIl5ThtKODVDp/G5NgEOJ6UBQyS4M/JhfbGwVMfhshY7rsmQ8mYZF4l0Qen1yaG0g0yRzKQO5lsKjZ287Sxc5jmSJfrIJusTU2QichobPqTzEkitzrX7NlGSl52NOcxwCmZp75sot7m5DMFfwzkd18Fuv5Zg3v1q7bROgmGnWKFR859tL/X9wLpPtmwbuiRDvWR0jsnZLPlZATEUdjCX2AESzBn7bUWskXrFS/X7MeO+GuvzIYvWGVj9lDuhMq42hsPX3U2MP83AG8yk31/9oMTY5lvD41y8o56IQtextXWvBC51ZkPGuelrXbK9NUOhvGUmy9e1dMTzKPGlUvxr69xzTts4u3aXCTXeJqP9jaQdIS0xx9fMpYq11+ub74iuylr/jtF5uygQWBJFxK5sgXdmru8+UvwwxfCNj2p014dfbmHN9ej/pVL6aR++HsrxPfzN9rSnWv20Ua9tUFnjYFP/JU5ECKXedC1Nq7VtU+571OqzRI5s2O2lBufjHJED+RH1oCTXOvAHsBn8B2+o/d/RfgJbTZD5mAMa5n9HC5Zr3TFz2QntuF7jUs2dqVT/dSR3TqlH+381+fHPOYx0880CnToby+TA5RTTz11+pxQcO53x/kHGKIP84dvuYD5gx/84GQLbfgdeoEnetAehpQjZeyvLdvyQXi1vrWHN+TemPIo7Opr/HAsje3G63WQ8SRztX+Ti38nI0yti1rf2SibwbA6spBRUobIrT0bySVrtnvtPMh5w4CfhzyfkEr+t4q1sypayUqiEAtZEM/hmmwGNOFy5YHUNUXk7FMmsCtPyfgyvEUkaPX9vad93xJ72ucsBHf+4ZRymwg5+kcaHIrxKVqA0aIaDaJOjrTljCygVZJx6AKocqTj3HPq2rkno3r/Dc6DCr2o43SBbx3Upx5OZwWK5E+P5C1H7GleEkAXwNscCtQk5eoLTNXTgTTyoB9tbBoe0jgFgT7d7HWiAzju9J2ty9k2vQg+6J1DopOwywZwFHZ9fyg5MVOvrXVJn/SaI7MW2FOOVzak09aDdtorw4OMeMCixIYCJoGGcjL4lt/4yvBkO+2sSSeK2mV/18ukfXixEfIX5i6FuRLCg7zpQPkoPxkk89e/+WpLl8pdI3PsoUEfjlofpF259lL4o2NylPCR01EbhDLjNb6+eJExUi+h5qeda20l9fGLBA30s5NEBwJAczN3csvJK6cvOjVf80n/7G0u1rdAB9bd0535yrXDL1vma4wVFrPFqD+BrQcxJ6hyPoz+tYdPeiSbcZC+5PDQ6ftXe4y9BsbjH7ayRfOUNkvpo3mFBXyzdzo0Z+vfibs50JWTcT9+4CcN4b+5b4boCW85305n9kryNDd6snatWeXJpI9ra5U+yUBGfsKDvoehG9zgBtN/p+5hZC8SXT/oQQ+adOChyQk6G7BX9qOHfBeM0A0dwRr8wBK99Ka5wwdJW/d4soX+yl1LrvM56uJfuXvjWDdhGalH4Yts4XiVRBdSGIYD9360w/oWt9gP+Ix1ELsYnw7ois7oWnJPJ/RHHm2l1mCkjX7ZQz/88LDXesDjX7RjZ/8zgC9ZBa0kkDdhJ+PAbpIWM5CZpElJJm7C6kZgqtM/BebQXQv4nHQo00ZQLoDz3y7lTiKMGWg4Cu2MHajHJ+JArZ4cypWRUz3D2LRtiLVdFZm7sQQNKIdNH9271s48BLAeZMw5h2luAiZ19VslAapxyclZOxkKvDYAYKZT+lSvjIz6sK8F3CZNXomd2My1NnirN0dlLTIJaauPheKhjkNQtlfJvGwOHj7Nnd1hAkZdSzZPDy1054+FYJWOx0TvcCuIltjGGqIn+qRbOlVmTLbJVpLxpJwcolf9kDbd0797bcmX3eLt3kbXQ4c6G0g2c4Jpk4dlD+h4jIQvWeGaL4Ah61HCTz1Z6UFOFjzkdNdpFlmU1S6cNHdtwhfersnqXgBPnz0MIeV0I2mLtzIpPo0RjtONnIz1xzPZ5ORD2mgv17+Nl27hIF0lJ9KOL8FnJ4ktyUUOesj2zR1u6Cl70H+6VaedeQoaw6qkXH16RmFUmTG0y29IcBMfQab7/I97dXjGl3ySa+PBKiwJlGEBZshN3uyvvWu6N1f9NkNk1i8sNafGwF8dXcmVu/ZG1Lf5fi3lla985fQQRzZ9zFe/zZB+xjcPDzvm3N9ktH+qMwZdd1pPhzBp3hKsOkgTC5BVvdwaErT5o3f99yIdd9xx02ELHHgzbl7ZDIb4Kg9+xx577PRrXX2ZEE74OjrzxpLt8FAn0Wv7JH5S/Fsn8sri2VpTL0fWgLr64C3lF+0L+K+DyEQWGPdgaO+iK+vPZzb+07/D1/zYKilfLLke9QTfrTG6IW9+qPajL5LIbE3oyy7u5a1PPzPq8GBVsdnKAnkCo8ADZKPCIsalEA5Hm8BssgzMgXIIOVxtnBp2GgyMgVZuPES5+hlPzgjqLDy5tniR1ViSMoYkr2tGYQR9Vg32dGJ8iyuHCQzI+OSlgzYe86I7ARJn2yajr/JVE+fkyVrgKaVjtrFQ5Zw2J1VAqUwbMpoTOc3HgnbffOkjm7g2dzl7GUe/2ihLN95OCHL3KpkTrIflsCrw6EHWtQdWDy3qBcnWgWtrB+mTI1EHK9YkPdNXybpT14avfxsB3Yb71qix8W2c1hleyFgSe9jUySugMzZ8xi97OYnivH0e5sFcULAv7JLFWHSAl/GaozlJ1ro2eGtPRrLkmNvErBf3CJZsapysdq0zfd1rL4djr0wFSVFzIUvOXJk8qgw/OR2j7smfrY2lPBshY+ezyEU3eJqr+9rhUVInT76doOwBS2Q0r9YrIrtEbyOlK/Jr35zxkkv44SM3Dqos/vL6FcRL7uFYjnf2MF64jgdZlMOLU1ffnPNfMMV/JSNiJ8l89YNRe9dmaHz4amx2bx2HmfRjzumWzK2P1noHAu6b00aotsaUGlNC7mHVevY2gK/Pjq0x8tGHtSVQvfTSSxdPeMITFi9+8YsXfuXl1a9+9aRD/oENNyPfThPc0DNb+2QGPsy3RE8wAmc+dTI/vhDmzFO9Nyb+fsFe72GpgFp/mMoHuJa61l+Oh/auyRP+UbaCm/wXvmwpR9orFy/gs2oi25jozJzJb32aL5yefPLJ06coyldJdENvbJRfkFwrR3SYPUvJT75R53SIJ0xIdFt/ddo2nnW53fNbibYI72S2CaCcJGI0E9GOIhiydjkCgYqAjCMS2DAyx2zxC+A5CE+zFoTc6z8BjTEl/C0m5QLIN77xjdMfnPi5vhxNY2mbYcgmUTrg28DRdit+meiHTGQgP7nSX+Axf0CjR0DJ0dKHhaGPduo51uVNcrvJqQpgJqOcjOYBzMZPbhsLmwreUDaQkDbaujdv+nfdYhiv6Yo99DEGGeT60I8Ad6+SOdID7MJ4mDRH8/Lg1E+ZCXqVCy7gQaJ3ukV0RR90r2/BC/0ivCU2sTFZZ+qNH77iJ5GDDelaHT7K3HcSF2988COjOnLqY/2RK7yYi1fL3i51eqfvMmlfnx4QzA0v4+ZDXBsrTCBzoEtrpE0XfuStGboxF4QPbJlLduBH+tm3qLniIy1TfgWxq7EE5QWBxjXX7ILaSPQzlo1WIGTs/FtETjxG36pMfzLvFJEJptjAPMjcnKTsGHbM2XV1UXNCleM1JuVjwhcf47lOR+XJYDxtpGRg8/oj40vwI9gSsLpvXDbUPqyNgYDN2lrVbqMEF4J564RNW3fuJTaVG5cM5tAcyW699QBRIG8P9aC8leBh1G/6loyPlzx5lSsjr2vy05v901tiP5v7lre8ZXH55ZdPn/7QJx/mbZz1z09Yw5vR104Q+Zy0H3/88dODne/i6SGbIDk9mPPVV1+9eMlLXrL4wAc+MLVB2aEHNyms0RsM8cfsq679LlujeOgzjp294qmvOvf6wqlcfw9iytdFrclkIyc5+Fi6FMvRG/36hR/raRVkXF9w8FFkgVPrxKdO9h84tKaNb69xEGUtw6s+dEhuepXj17XcejCP5imXtDN/69N4+GwXfcz/+1+69npT1D8kWibCmbxJMZxrwhcYKEcmSIEcEIUpBzrgVkahFrc6PClQOWdnU8WPsgSxyrThyIzRK3APE36X1X9EE8zrZ8yUGsAzRgume5uuE3m8gG2V5FWb7/rJYAGTzfzIQY9tEPRDFnUCOHPy74Itgvoi/cyDnvFaBfXHmOShK/YJ+E5XgdU1mchTsKgP2czHNbltUniYk3vtzJFdm4M+7IWUaee+jUTCU/re7/3eqd1O0BOf+MQtf59sjsjGy+bIPK0DQa914DpnTPd0wDmYt3K6QXK6F3x36qGNfpK27CKxXdfqyI+v9ohutWEPfCRyaVsf9lKuLd7a6uNeHTuxcyeEsKu+wJvN9YHlcb15y4Kv+eiXneXWg7nRiTptmnf6IJu5kEHeHMivjIOmIzyidKONAI4vIT+/E/lvfvghYxoHJWO6UZesgnM4xzcZ06sxk1c7gTvfZkx98WJnbZob3nipU4YnXfpDR/6kV/qroPPOO+/aq/9L5IJVvoBOzadED+rJ2zyUj7ZC8u7Ls20JqcNTQnJ12lfmOptIXVeHh7KSsuU+I9WmfmzXPFszAlR28QC23H9/5EEWHlsrkrkkB3Lv2thw4z4cI2XpVBuyWR/wrZ/7+uyPvB3je8xFWwmRA0/88bFe80fGr5181J1rhJ9xrW0Jn/YEfKxD2O1h2Rz0v9e97jXFA+ukpz/96VOgu0z0cu65505zdqKujfnSy+hz+DjBH/v35UB6ya9H6YgOzZkuJOX5F3bFV32kj/vKuh/bpfvRJmzA95Ld/TrIejAHRDZ6MjfXHurEaORzoIPgIpzUbrtkpR++i73w9qB70kknTf7SGuS3YJA83hj7O0T/vVfw70c2Cvb1pdfkSv/pHI3X9C7pUzx3zjnnXFt7aPRhVGwDAbfgzh+besqmKJuWyVj4JsE5oRSgXDvKFWQDMz7KXOtvIdjIvIoRVBfE5+jwVe71uNN5ySsvAYHPOrSXjEfRxqJEToNCyScpT/HxNCajrhrwAOvkzQJzbb6CWokOegVXoEsmwRbd0AGdAb/ECZiX5L7TW8EhfW8XkZEsAE1m8lisToPYj64l7cjS2PSsHRvqq1wZe9K5PNnZyNy0V+YeT+PiK9DBx/ijnvYq0QUM9gmNeVkXbEwHbRR0oC2nQwcFhxKs0is+dEdvrrXPJkgb1+qk6sITysbq6VkiA/vip97aIqN75epR4+CVrOzX2m8cG7k69rb5cZ71RbVHxkfJrA7uyNF85PSB6NCYNtbqyNvpZg8B5MYrXKVHY9C3a/2TA6nTLzmqc538yowpx9e41my+xTjZFC9tldtktSdj+oeJbJ+s1SmLhzHoZJR1HUQGNuztabpRLkfpCqUbKf1J2pToRv/luahTrm9zH9uMfOkoPUrhWPvGjQeZG9M1bMAIjMIRHJubpA0ii7HwVgbLeNqPluU+EPXQJvHvHdTACsyYA7nVwzfZyJ/vswYR2ZrLuPYE6P4mxY8+qDsQmUcpO5g/Pvw7LBqbbLC23Kd561sezhF99YBsju7x9vduTka97c3fx2OniRwepMlFZm8akg3u/aMn8Y+DByf2gj++jC60oxe2oLdw17X5Izpyz87saCw2RLWPF5J3n82NIYXj2qHWAN+C17rI/OBXIqfx4UZyL0YRRMMwfJP9zne+8+KHfuiHpgen+93vftPBifJDJXrkY62Hs88+e3Gf+9xnWhf0IQYTJ/m1Ju0c5JKPfb3V9i2/T38cFOp32mmnTX8H4WFAvXXhocUhJp/BNtknG7hnXzJsF23bibzJeloxIYuPwuWAFZBzNCYETMoFneoClwlSABBTrDZ4qeM0OLjAqF5ieE6hxAFSkj42tVGZ+EXKkHLy45XCOVVGZUiOctUEKOTJMXLMnHfBvPnQTbozT+3k2pkXvXEwrjkci4PTFcTTc33T3aGSJ1TOl1zsQmb3bTDsgmCADek4IiMdczjmra154mEhCQbw0EdbyYZqDvjBB54S+7A1Hdk86eChD33otSOtnw7lRN48ORW/jNEmxr6IUzdfeqGD7ElvBRr0pQwffd2HbbpWjtiMU3WPD0fLBhK7jOtGnfHaUOLVAwL9q0++7K2dvDGN03hkCi+I/bTHwwbpm+T6+cUQPBGZtUP8iX7JqT2++Q5zpBNtyKvM/JKhTTK5zFMfbfCW6B6222jplgzIT4o1Lh6u5c0vuYyvD53iPfKiA/XKXcOw8Yytnjx4OeF2um4eSH32axzX5g57vuX3B3nrOpE3Pj8jSDQ/6ze8pZvaKWMLSdvu5bUxZ9hxXZ90Kh9T9lMX3sZrvLWJd2kcE7nOfurdV09OuuWD1EUj1rVVLwi1ht70pjdNdtooCRKMkQz4yvE1filcsDOseHNjn4Kj1qE2zYFsyRwvhx3yfZE9vLVs37CXsKe50Tes8jnWBjnwUd7aHHVXqrz5kE+Z1JrTX27NGs/bXAGRn6r0gL9O2teJvD364Q9/+CSXfcabcPNGdCD+8Qew1qpAkO70MS844OvM3XyRuWeD9MMfxTMfEB7lCI+ocnlY1N8Y+kajnK7FBmKNsc0qiW9AfILxYdU83Nu7lFkz/gCWXJK/v7AX8IvI4TC5fV2xP+xuhOiKnxInsAms+43/V7ziFdP4+DsIJqNkrB5+swHiY336yM7q4JY+rWF8BfT8L5vCgISX8dnb+n3EIx5xLbdDow9LdQhkEpxXv2EORG00SJkJMJzUAjZBwBMIUIB+yuUUqLwNjmEZWn/89HOtLIUzDIdmM+RkjE82PPEng+tIf0pNJm0BStI/Z7UOAmif1/gkheMEDmV0welK5leQZT5k882xewvFggAcduBsgJ5DVC6g5ww5ack9HR4K4UdGfOT0x9nHNztZKMCtjYR6ODI/iQ3kbRwBXxkboWyFrxxvi8drYw7fQjdXaa8SByCQN6+CALhlf8GtdZBOpPCK3NMNHbumH/fsoiynrQ4PuGmdupZ6ONRGnTI82C9bkg1ZM+wNZ90bp80Ij2yI2Ky+ysIE/tY5fFvH+klRY+Mppw+UU6wt/iV9zJdM+hlDX231Mz6/Yo2br2tBkXv+w0M8p+6ejDDmlapf2jDnxsMP7+YruVZXG+OZH326p0M6oyfzFTDYEOTWtLbkyydZq0574qs82+ifb8u+ZF7XH7FFHr5929pDnbQvSk5zMMfxGqXL9InUN5fqtFMfLtyzU22UL7fJPgg/yX3t5NWhxpL4JKfFTgX5GjzZL6zry9c65aMLv1LBPpshfgtuJRiRYM2aaRyUfo2pjzp+g4zKYKO5NF/3+OAx6mFfRH4ni/YQ/fgEazOMwhc7s1lrKfvFd7RZuq5sHNt1ZXyFtcfXuTa35rHTRHc+sRDneMsviGtOyJoVdMIz2/Alb3vb26ZPe+3pTm4F+fjoE66Qe/Oly9aHe3m6oQf5qDukHF7wzU/qg8rDiuQaTpx+N/46iNzwDKvmJhfvOLDyAGvvJr9yD0m+mfdZkr8z8CMDHor9KhOc8TP2SHPdCtHLa1/72sm/8/seyPzak8Np4xmfvHwrnJOlHznQl13YFz75Zn//4B98icXsz+pg2B7CtuZ3wgknTG+ayC156Nuq/PuiQ14lwCBw9DqJoUwSGE2AQxF4UoZyRgIk9fpxUm1cQKYNBTKWPsr1p2zGD5ja4gW8+OmTY1XGobuXqx+BTS7tlbs2RovGffIrY8j6rpps7BYXYAAIXco5U0E6fSVfMiLzlJLfCYC+HLtrPATHUkFXny9YSPS1VWIneqJnvLM/WY2XvembHtM1XCB2tNmxcWT+fa+sXnvJNTLv8KXceOEA2YDMfS8SO3qKFwywGx2YH5uZEz06fVOGWh+IHttM8Qn39CaxCTtJ2nE2HCc9WmuwLqDFB3+2hB9OHz998CETHtmHTAUb7DHKYEy2UkYWybU6/fBBymHCSYj5mXt1UfMgs/GaCxrxhC+SmxuiC3KYV7gxT+P5DE+AQpfqtYVdMtC5jdu69ICsztqxIbvGqzHkxjcX18ty5MPIMdoiHRnfPOiHHPgYw7geIMwbf7zUx9c1vlJj21BsIu7XQebgn5/YB4yfrGTM1ummpB1yrU5CcvMe9ScZY+TjOv0J/mAXWQ/pMd6IjkcMjOO6Tx65Ntq6bkw8ndq99KUvnT4HyQb1R3wP7AgSBATG2Aw1boT/ckL4GlPeGPqpxyNf0JybkzJt5Aci6x7uzMW8k8lcjede7h4/1+0tbD9SMrJTNiwpH++rJ6v1YpzKdpLsRw984AMXZ5xxxvSA5hd4BG/pNbtZc1deeeUUeF500UXTCa8f2YAZQb1g1ENQeEq3cryslfAUT9fllaXT9KIc6cu2fLl27tO7crjwkOZbcH4Nj3WR/aK/0yCL8b1p9faCTA5IfJJNbr5QO3NG5unenuWU3mGth2nBsdw8N0tkEHR7KMuW6V5Mqh6ekQdZdsyHW/+Cfz7HHiJ50MVPX9fq5AJ8fsMDsJjLZzn078GFXbaLDimQp2Abm4CQoVDAS7kBnSECjglwEtoCnSCA8arDF7jHzS+j4gvwnLhgg+PQRz0eghLjKDMuXjYGCbmPR9ejrMoYkSG6XxeZp/ka33XjtzGSuYALqJXZPAQd6kY96y+5phs5nbFTTteTIXBZTFsBFVniSQb24Mw80SInVM0pm5Aze0nmys6us0XzhhGy6st+yrVrXvgopx98jc9Z2Nj3GpkLe/jezhzM0dzoVi6opGM64BQ4DWtE4OKa3jnq1stI6YpOXcOPe9fWC/3Dk2v6Taf0Dyc29cZundK3dYuH8ZITJtgUn9qxqXZy5eTWzj2Z3HPO+nGagqCR9JGSXz8k79q88SGLdgg/8mqjXL3+yPzND/admJmnhxaYpf8eYvIx9G9+dKy9++RH8R3LUPK2riVzp2syjWs2Iht92+ycxFtjeGijT/ql2/q618bas+loty7yoOHh0+ZGx3RGltZ6WEPK6DEddU3H8JSvKyH1pfgYx4maTdIf9koCJRuz9Y8vWyJ89CWH8u7TGxtI9CqP1GsrZzM6tUbNt/7a4wEPfLGN21rciv7xbN7pTaKzfemSrpB5CobkdC9phx/ZkBzmOj2kv/0R/nyEoDN9mac54aMebwkp40P4AOumcqQv2SuTN49IWbhofnhau8p3ksjDJzsFpgOn7rAQTuRhgA91eivY146+zE2dE12ntNaye1hT11q2z2U3pEx9CcnTfRjQzvj5cX5mpHSpnE2tMXZy3xzWQe3lbGps+vArRk7d7WdksYbCZfNErYfWgLa9GfKGzCEC3W2U8PP3C3Tvj2y9NaETh9HWkHp1ZG08exLb+uTm4osvnn55qQd27SUyZxey5/PtGTCRf0Ivf/nL/88B5qHShzzlFskkbXqEtQhNogXJychNiCIk9fqoUw7oNkv9LY7K2uhSpITvskHjJS+wN4b++kp4A7Jyecm9ZEwJGVsSTFh02hlzX0QGYxrbPF1Lh0JkNb4coOX0wEEYw72nPKeWQOzemHRg45fIZT4tVPzMcySgtaDpy4m/zUlAs7+57o/SgdQmArTj502ch/G1JWd5GDAmGc0XlsJRdlU32kt7PLK9VJ2+nBnb7SWiP9/gOel1Im8ubEcn5mrO5lZOxwI2ATz9wisHARvpQhrt6R5e2KUHJ3x6bY4fnBlTnTWkfWsDZjhj9uCA1GlHPvloS/VyJGcr9WSXtz6R8bSHFfL4fMgm2LhIf7zNoXLXdOQeBvCWyKItvpJ1oMw6ck1ewQasCX68AWoTSGfGU2bO+iLlfJV1godXwqMsyRdeI2XkwjPd0p1kvvSgDC84MC6ZfGMrMNQvDGiDH9KnMrzw1s4f+LPnuoh85PTwYLNqrulCXlJOZkk78pLfvbk3H+Q6qk182NGbFEEp3MIz+8IQ39ibFnV0Exb1jZIT78ZE2tCt5Dofqi08WG/8i7IwRnYPu3DrYUYdjAlM+MXmeTDSJpnM17W+4Vu5+9rI1fEdTjTh2VoK86j5ILLSj/pRF8tEf95S0Wd7qEQX6SUZyUM2c7anwC0Mq0vHIynXN/nd1zaelac/5TtF9Gt/JF/+Jr3nP8wbBhDd8LH0ob177d3rmy7pDdGnev2bZ3roOvvtj/AO53L2bezkIKNPwxxYeGvgYe5gfLeT2JIcZJOsWWtUEC2g978F+C3z1g6Rv4TIK5mTRM98jrnxzRslOvWHtH7i0p5Gnt7MWuMeOLRpfbu2Dnza4+dErX97mBjMeiMfe5IpeZMR6Ss5eLC/6WOvbV7bQZuL3AYyOZshJbomNCU3KcCU2hAl1xaAdhTkmtFMMp6U6t4146MUhK/x9AN+ZcZQjh9e3euvXjme8kDO6VMmasG495ToqcsGwYkZF79lMrYxLG715ZK6rRC5bOyBfdyYlJOdjMArCcC0M0/AoxebBx0rQ+ZvfnSvnpx0jxeiR0DmjPrZpc2QvsYwZw7CJ0DGtoFaoP7pRwEa0Mu1JQvsuE5vFoZ78muH8DZPi8zrLDbUhtzmFJY4BRusjdQrzPC0F4geOJSf/dmfnV4tmp8UnuklCtfmTK8cCkywMf2aN0xI+tKfHI7ZXD0dqdffgwAsefDCyymHe+2MxS76JotxYU15OMXX+Nqxh6S9ZHzyqoc983KPv3rjk8fYeJGDM+Xklm3YOtU/vWijnA5hEXY8zJIFbtRJ5NYHkR3+4Ic8qLUFR/qae3aIjGuzELSaoxPoSJ3UfOXG7N7cyWhM/KV0oB1+AhaBgbebTuLpedSffOTZvYSPecmdUGuzLjI+O/bznHSWnHRunlL4UW4+4as06ltufvJs0b2+bG9MPOkSX9cSGdR7sHXa5z6d45H+UHpF8vEa6YOnPpL7fLE2ymDOCb0ghM9T53W/B70b3OAGU2JT9jeXAxGeZIIXmGhfkcMD/GiDD1+tjTc2DgDSA1/uOpklpM5nCeQ7GGmjH1mML3efLtynO4ldjGn96Es2MlanbdQc5Qg/bZNT++ZtTbuu7U4Q/EiIHHyHnC7Y3r/dP+qoo6b9kz3Mwxwi1/wGu/BN9U+n7DK2z461GfWM5Pp177o+ZKpvdUgZHduf8dOeXpWvi9jTugybcvIq4/etnWuuuWa6pw+ywVLtpHGeEtLGp4T0z4duhIxvz/Hw+6AHPWj62wf2sf8pt8b5UmMYLzsYh0+By+TTRls6N0fJOg23Uny0t+9aJ+a5nbTlQB4ROsOYTHllSEBKaMqxSXOwFoa+HLxySnIfuV/OJWBMWYFVbnEwvrGNlfOmvIBAHjwoWFtlxraByxnJaxKnETYJZKEKUBm58RC+8ZYaV1K+FYonY5NHYCbhz/B05ZrsUjrhPAALiAXyHL4ypL72eNNB83ev3rzoU4Cy2VN5PMyZbHiSD4jZSfDdybx5CM7Mo3lqS26yGjPsSPj1ihwvbWHHQxY7FbTiZ/H1mo4jMM5eIHbwRzD3v//9F2eeeeakCw6f/hC70Al79qbFnCUYCY90Y+MUuAqmPESxiTbq6JpOORD1HBUd0aG1iQ/sGBsOBCR06vMAa6TAHR88JTK2abGdcZLXvPTBx7jkRuqkqPv64UsepxbWn/Gi2hpLO/WStau/ZK3yA8hDHR2Qk+z6mov+2pGdTtXrqzwMwnE52aXw2j0eyhpbGgmvyuMlkBN02UzZSxtyCN69hRHsqTcHdUi/ZEN4GVfemOblmlwXXHDBZOd1E31LZJGTgW3Yny+G2da1NsicyMw+knvzKh/nKtF/CdFNNoI5yXU604cckj7xK1VGd9qnz+VrVN/aw4314iTc3wXYM5wMamMtsbV6ybr2YGata68u/suULpoDfJgXojfl8NF+J9EvPAlk6NynrmSgCzxK41wPRuyUfpBx6itvbNfpBrE9P61vdSMflP71J2NyVl4f6xwvJ8fud4ro0rpsnVm/bATPfKR/Msmn3v72t1+ceuqp0wOcmAFG2I5tnOhL1rm56m+u9CxXJpl7+pSMJ1XfNd755fSoPLuk1/oj5WS3Z8KV/UK+Lmqe7Ooakc18mxf8wDBdw7V26UNZ99oiefOkE9+fuz8Y4fG85z1v8ZSnPGXx3Oc+d/pchl6Uh9d0yNdL9Jf84rPleeTX7Cvas491qk7f5LbHOeDEYzvp4Kv6AGSzpPwCAsKaHJBLlGKCTpUFdq6ByQSBmNFM0j3Qpwx88JMivFrQAJyikXYU5x6PsS1SHsCNQ6FSxtGHPOrIn5GAw6cnvom14TJQ82yD6qGhpG4rJLAShNkUBKachNNKQRe+9Emu+JPVNdnNgWycDnnH0z99WhTaIf1cK3NtTnTTgwC9bJSMwSHAAIfmdEpQYgMDavK498cdNpmcB7nYke2NTWZOTz3ZBPHmTy/a4GNjJBtdGM9iENDBlrbKtqr/dZIHQ3/B7iTH3ATO1khBRxtpOGdLfawddkYj9mCADTkjeoAhjpoOrU+5MZwmaAc7bA3XAgx/dHTjG994evUqIKBD/fCyRo2hX7iAG9fkQ+pau0h/MmcLdeHUfPFjfzl7wwr7a8OnLNuQDpBxtSETXcGBsrBAH9Xhayy8wjmZ8wGS69a6OjK3LsiGzM21/vqkP1hVNsraNRkbE7/6mCM/4jMMp7YCPDbwAG3daUMO7fWLkgdf8rJ9YyiXX3XVVdPD7yjPqomcbEfuxmUDPgv+Su0R7JUvQuaafvZH+NZeO8kayFdIxmc7eHSdHrXhE+s3kvtRf8Ypua9sua8yfUqt2/7Wgm3NCY7DFNsK7vhG68taHu0bKZPgsjFHuZTTt5R8Hs4Fu4JNcthDeihXT+cdDNH9RojerB3yh7n02hpBySupIxPbk8PYKDlHcp9ex3mOeqZbcvNTrf+dIPPPz9CHdSu5Ruo8xPnnUK75Ub8x7k2M/c+eJ4A3H345fyrhnW7cG2PUQZRussHow8ghKcsuSHvlyqwR93Di4ahA09pYFyUHmcyn+cuVqWtesNtc8nPLpN6c9Ef62L9OPvnkaQ22N+2L9LvjHe84+V9xljVkTYoxyCFWsdfCOvtZb671k5KpsRF5zAsGzAdvD+70TBY+u1jFFx/W1HbSln9H3h8XAW8bEXCYIDKpJqvcYuTIbGIMxamr5yw6baSUAnv36iiQ4kZDUlYpRRov4+vf2Nq4x6OHDgpVVj91SJ1NZ9lQEqVnEHxGA24X4Q0snG1BCvkLxMjtXjs6BDikPZnbUJF7MtOz3Fzk+rse7aStMn3pnK3kleuzP/I78ngY22tbG4gF4F5QSVb/IIPDMDe86E5uDH3JYq4WkkCHHK4luLKQLDBymQ9dmDOs2LSc0Dv5J+tIW4T1ttC+fkeeLhDscRSSDdObEGvEnGyCNq/WBl3Cnbm5pwd6oVtBG2zQJ0cEHznKTrTpF9EbeeT02GZkfPz1Ix+7GZMNyIS3sazRsCPHtxxOXEswhpdyPMwJX3ysG20RexXosLly/XwnaaNZJhhSbwy8zIWelIVTY+FZubnxI0i9fmSBQ/Wu40dWfMitj/aSa23oVr8wq8x9a1SqDx20JksIL8nYdIsXHsmI0ieZWq+VwYQy1BiNy97+8Mr1SPe9732nAG9V9NjHPnbCU/6EPcOUudGrMnNA6UBZubk1x1LtXZePbVzr21oZ6+USn+MPFAXP7TfK6Uw79/RF18h1/JXhP8qO1CFtJbjQlj3DkHklSwkpwy+dwE42jpzmqsvuUnIhmIUfa5KvMC98yOHNgEDN6aIx2MXDOx/JZ2qvH9zgeSDim8iGd+3dkyPMIbn5K2/OysJmpLw2UfVydSi+yowXbyfd/NI6qd+RJwO/K3ahD+uWj/IA1/yRN5B8Mlu0BuxRfDT/+fa3v33Cqz7mB3/6usaTzVxLKF3KK8tXKKseHmBmbOcapW/3xoIBGDKez7Ho1N4BR6sm6xAuyEGP6c2czCGsy9Wl2+bUXMaycnOic3ETPYpJ7WX0zm6wxC4RXj6J8gBmz/DHsg6zxBJ0ZS1ZMx249HYZH7qOh+vkkkvJTQaHdXBiXVqHPcSNtF1xyodX1iaJEk2610gpOBDJgZUCTQ545BRHKQzIASrTD5gYGlGIMjzxkbqnTA4JH2X4kEFAxHkxKCduvEBODikjRPqneHIChLGNBxCuWzxONCxEMjfH7STz8WkPMJGVjshbwEdGsqa3NkqJTnLqtTF/gbW+9KAd0ta8Jfo2rjJ9OkHwSzZ+Isk32zYXJwrGXCbyCcSMbQyLhgPTFpDxdUpvDG3o0KIAaHMkk37GpXv96Nxc8RLIW5DsqY7M5h3e6CqHupuJTswh/cKqJ3aJfdjBQheQIXhmO7rRVxs6c+9/APgPgpyw9jYIT/jsbcOhZzhVR982HRtMDxZ4eRhgO/pkI7YIE8r9wRrH1s9g4mHNadt6YaeS9UA2Mhqze+3YB1lf5JLiBXPGs27Z22mW+S4TubKx69ZmvifMmIdx6QLf2itXZu7y1rm+cEVe/BsDr/qnm/po4x6mzSn9sSHdj75pJPfGSV/V11eOl2t88arcmPKuyUbGdOr3j92vm9iPXswH0b31SscSW0rK6Fl7bcvTZbpwX1n3dEKn5hrRYZgxPn4oHcMHDNugrQn32tBfvLXLFo1Jh65RvPSjb9eRfkjZ2Md9fCTX2o7tyWv9+9RCwNA6R+TTr7HwdV/gQxfImjQv7ZXxqd6emadgRjAPP9rRm/5k0YddxrnsiwR81rJ56+Nh0NppfmGRTGRs/ghmK6u863QqL+HRnLOH1PozD/U7ReSgC7Iib8sdWo1rUx2ctBb9qonPJ9qffPKprjmjbLcv0ibduR7xw8bydB8/eXoLc67zla4l43orZB/i333WaU/Rd5VkD7EnkZNMyWkOdBnG3Svnm2HV2mh9j/N1XXtrCs7ZxR+b+wQXP/i315mf/XckPsU4DiP9jZr5a3enO91p2l/9Go74w7pKHjLzZWRKDnWS/hI/R26n8dq8853v/IhDvVXQIZ3I+y6ZwzQRCpUo3f24OE2oBa6cISlEW3UADehAltEQhYz8tJXw0UcdI7Z5cO7KXDOiftrVV51ELkbBR7l77bRXH4g4L3w4R/Xaa9OC0He7iEMXmHRywjmTSxBtbM7E2AGbjHK6JIfgAXg5PtfN0TwkAJPoS46P6zGYSU9IXUGfZPNhI/yjY445Zrr3yjDe7Czhg5+F1avW+mprXPoks37kIa9ygafAVp3A0KkGR+DafOk+J+l6X7TTJ/JsSG/sajPsYVNeQJnt6MX8Bec9vLBHtqIXc4cB+oFJZP7GgRFOuXWgDD99YUd/uWS9kgl28FcHV+nVtby1gQ88saFxk5ttkXZ4hDe4NT7e2rAdHq7NE2+nHcbBXyKL3Pr16tFJ2EhO5PEzlv6ctj70OOJGIpv7ZNIHaVdC+KhHrW08peaEtDM23iM/OnFNbrl783NNR8mg3lwbS15Sl130i58xYb/1jsxZO6SNNabMRuFULXuMtOoT+Z/4iZ+4Tj4EfzAXttSV059r9slGUbpB5hY1T3xrr29t8B39zcgHeYjgT52qwS770FPt9EnnyuXxpntjZiskH3GL9EeVScq0jXdtI3zJ3kOOdnzrGFDJ6xd+6JAvEXwIMKwjfcOoe8ESXuatj4OWDhH0Re21+yN+Sl+21Nf49MP/IPeoscmpvWsYTQfLc9emvpUri7pe7u8zCH5xneREni/z3bXx2ck68+tM9Jz8bBmezU0iO3+QXdQ1F/Xmmb60bU0g99GoG4QPftYXe2hL3+PaT4bG0abxkL4egMmiTjun5Xjwu81ru8kJuPVHjlFX6YYumke5enrJL0vK5Che1j/ecnPSn174UHbgJ/EZ17/g3Se/J5544vRgQwf2GQ844lo/muEQEmU3/ODAvo6X8viRA2ln/TgI9ROVB/vxgR0/kUccEWAFkgxE8Ba0TY0DymCMUHASURCi7JRD+VLANoa6DCUxvvEEGZ56BA36KDOGoIkjMibenKdrPPRtLPfaM1LBq1xgQc7GaX7aybeT8AaAnCigAKHFZW5yjlRSTmfkNy/y0LN+I6jSlzz521z1k7fBonRb//jhLSCw0dDTSAJqAagFYLMgizm4dyovWTB+o7XTfY7EBkOvnqJ9p2Y+xiKXsdqkySLp402BsdhYYBtudhuZh/n7/tzTvY3XmxUOgz7alGy6gl5YczrPmdBLdkJsF245Fp+feNChD39gdbe73W1x+umnT2MpYwN84J4usz+e9AY/yvAbsdBYdNr6Quqtc3i0sekLS/prH0bc1xY+zU0f89FPPZ8gZ/d8AHkEFmTwKpMzXcYYMoax6Qt/ssNlwZAclpXX1lj4aqfcNdnNjc8wbmsq2VrX+uOjT+uD3Mr1J4N61/RqjvxPPhEf+tF+mfRD6tOzdmSQj/qtv9z41oQ+2hjT3z3s1Dog36gT8qP0n+xkpUfJvJC65m9O+JTqS6/mBkdy7ZHcGOwK8/SNLzw1Dr78inb+cYyN2/rTVp1x5NIoi/J0rGwcs3YSvmMaiSyVjX0kuqgPeWGXP4D5ZEmOZNBWP3JpZ87q06c6fhj+/d2Nb4VrYww+AS4lfkIbPnp/RO+tYcErvwNr7KCOHFJ4lbOPnLxR1+XppPkjspMR1S4d4Z3+doIcePg8iw/jL/x0YJ9x0rtye+LRRx+9OOWUUxbHHXfc5Hv5GnOQUPY0j+wltmB7RKfaoHSTfpB+xqRzbV0bAxZggP7So37aN7a2KB3aa9jKvmt88khwYW/OVyobZThU8pmJ/Zsc5oB3+wU9SvDb3NOfOUnJpI96ZebuHtFNOq5PfFwbR+xQe2+yxRD46mN8usGDrcliPP3sS9YQPkgfZXRVWfptXHO0v1S+atryibzfK5ZyCCkxwSksR2PiFOOeYlsI2gIVEGdAdZShnXt9MyrSJx4Sh0NhNnintjZThnBPmeRSzwlxNO5HcBsLCATL+jAcOZFyvIyhn7Z44NX420WCVwGvOQvCjGGhkqHTZwFHOpbUSRwu+eicnqX0lg6at1xf1/LKo2yB1LmvjFzA3km4kwqLowWYLdUhi0Mfv0SiXp3PQMiG/Ac8p/leMetjvmRps+JIbXIwxukoZx+nTXRCR/ujnTyRd5pDLz5P4bA9UFr0dGDu9E5n5mWO5kpXcAdfbBr+tdUXriUPdAKUHgA4FDoyDkeMJxxYXxLsSnSFZ2uQHuU5IrYzrvGSL0emzkbOfuxpDq1t9sJDH/3ZEV/zQPhYQ+RTTzYOVDkdaae/ubCrsdh2fB3pZ8K0SQfGojey4SelL7nUPMgp6a9eIiO5peSkYzLpi8zVtTkifeLpmj6ypTWmfZuRsdJJKfmyKdLH+N1rk1zKtDVGcqrXxz1yanSg17brOJG3wVmXzYGuk4+slaN0i9SNvim96Kud67GePtO3e22U0XcYd89eTp49GJPNg7PX3E7ZfHICY/onW7pVZjwJXt2PuEl2/dTpmz3xkKPwUn3kXjJWNkxPcuvTmwOkXeS6dtaPN5V+qs+pcPNA+V628Nat/w1ChvBpLuYh8SN8yL7IutRGn3HvRMkjdS1PD1IyjbKrb+zSWEa2keKl3D7T24R1ER/uAcbBAv8sgPfJBvzARYdTfabCf5HRv953D4/0wB9ng/RhL5OzXz7XPMOalE6RazpC+ukDZ7XDJ30ZU3INEyjdahfW5WRjX5iCBQ8hAm6n5+qMY77bQT5zoyv7ADyRgfzWLx+lnP+U+PbWMN3z8+aDwo2UTuTNOZ25bq6osayP9sJ+FMIhG1/BRt50iWvx05eerTV7Fl2TD1/ySfimd9d0rR8b+0UjsdmBaLvilC0H8r4F89+pOIuct2QSUkBUFhCVUwrl6CMwpQDKVQ842riWkLY2arzGcu0oVNIPaEsWkTEDIsdsLHX6GVM9Il+Bv3HIgmevKccAqAWhT3l8DpWA2VMxGfqeDLgATdAg0KAL8gOca3PyKQIH42TOSS2Z1JkPRyTo63MFuqATZE6jDlybn3mqG50KUq8dmQSm5HNaoSzQa2PRSRaNsXoIcbKjLednLoIQAb4F7A2Ia87QQkHmYOM2D3ZLJo7H5zoWoXH3RzsZyL/whS+c1gVnn9zpzwI3Xw7K3AtI6Q9uYc+89JGbe8GFzQQe2NP81WljDLpiG8GAYFsfPI0ZD23YkyzGqr8ybaX4wYFy/Tx8yTn6cKheHm6QvtrFQx08K0smmBCM6+/efIxLL3Bi/Wnj70XwQd5omId+2uoLg8Ylg0TWdJ187pMDaYMPHtrQh3aSa2W1Q3jpXx/l7ENvbEAGdfizIR76SMq0Hfnor7xrPN3jISUf0rd50AN7JYt2NhwPwrXfF606kH/Uox51nZ6bj3xZ92NC2pgTO8vdS9VVP+qPP8EPqaObdK2cn6Z/Qaw3f9aWNcPv+aM2GIa1dJ0eUbJ1Ty761qa9x5i1Ue5eam01V3UoniON99Xjp6/xPJS7HseTx5N+jaWtOvqRq5er72HfnuGen7H2tNVXW0FJ6zDeI/FPSP/GT86ocUso3Yx1+qPsJI+XXEJy/bQvVe60eycCefLc5ja3mfYkdraH2Y/IZG72V9/Mi4UkAaCTbnMUDPc2Vhv7Fn7mzRb4sQEdI3WwtuyD0olPJ9lF0M2O+qN4xCf9u8cDT2XGxEc/dXIYaR81rwJsMvLDHbSIG/A4FPKfVMnCz4sBXNOrteqk3mEeGyvnV+1jHsA9SEkOxQTc9iA80lPzMueIrOlDOR1p59q8JP4ED33FMmz2ute9bvpU0T7Kb9KzPmRySGYdWTN4qcPH/u3Bjcz0Ta/9HDZbHYx2RSB/4YUXTkoTgLXBo4BuwqOiAUSy6QVkyuCAESBp26LXBx8bgzKEd8bBI57GbnykPYeHZ+DFO9kCszYSYlyEd0ZkVMAhZ3MkrzGNET9tD4WA2BOrcQGAjvAkG7nc04P5cAo2JQ8bNqvmRU6yaSdx2II/DsdCBUKgtYDNPXCbF/7mk57MMzukf0mdMnw5K30BnUwcDWB7EOHQjKst3nJ96YrzsLFqaxEL9o1r8ToJ0M5DijJjthD1FeD5+wzzPxDtZCDvt2nZ0/zCBRwJ7unIomcrid3YQkJ0jfRzbc42kB422Zxe6R9WOBd98aEjtuCA2UN7fNgSr8Zki9bAiP3WqvpsDSuCVnydkLRG8NPO2PgbBz8ywWj31g1Z+IhkYm/1bAmT5sDu6vTR1oNdNubsyQIHcGF++CLzLiV3yb3ykfAxz3RSv67ppTJt4lFOX3jYtG0q6dd4+tanteUe6eu+ctRY7iX36d01nUv5Om2Mzz/49pI+D0SrDuQf+chHTvKbIxnJTEZl6bN5VYdcm2PJvba1R3JYqJxO3WvvPn+lr/ElGIJRQQ8M8nXwAkfkCxcjZVckx8ca8SAAh/yp8uRPdrKwCXuMvLUd+eGP9HMt7xrJ6YqMfEby1Zf9lcFNfVG66D7e+qW7fD7+gg1zS25BlICf7MtEj/FDzVsaxzVWunetjKx8RDqKh/rm4nokbfM98sZA+juR95CzThLIk8Ovu8CDOdKJoBa2+Dm2L8GZRN8Oz/g4fh6OvAnShu+3X2qX/tIbskcIaLWDPXpkO7n5a2vtj33SM6LbbOFaX/XkRerYHe+RB1ntJ+Ymt38bhy06FUfupa3QXe9612kO5mhfLO4jO1nI2QFVwbKx2yv1g0sxAr/r3nxgyv5Bz+pdq+MfJH2NNeJZXKSNcdUbSzxrPTggKW6hD/w9SPZ2y1rgV9hfvT54sZs6n746kGLvjdCuCOQvu+yy6ZqBCtY4icBnYgHNNcUDMoVqpz1julbXZkBh6uT1dY3klQtutNMXje3UMxB+gVouaafOeECuLTndu8aT/AzUIm5c/ckMHC205MF3qwQoTpPwkSw4YKEbRG/qOWTJYrDgbdQ2Lk+vgG8zIDPZyG1RcBzmRz5zZCun/67x17Y5WEiCRWObq3kCMz3iIQE650RGC8s4+nIQ8dDeOHTYw4XxncRzFj6X8KRtMfheTbBmMdC9MYxNBsEKO3ud7GRNfwvlYLreyUD+cY973GSjAoEelDgZupLMk/4lWDSfsIRGnLIRO3JAcjpjU/WcLF0jdjIWm9BRtsQDv3i2ttgv+chE7+ynvjXMftaIBKPukXrjap9tJfNpozMu/saSOEDBhTbpwimL19EctmCGDDCsnTdNeMKJ/sroEfb1ReqbP7nNMbnwQu6Tz7VEZm2RnO6qxzs7KHNff+X0/+Y3v3lac+7jY0x8ulZOpsZURidIP2Xu5Sj+yU53+LG/jcE6cApvszhYEI9WHcifd955k6x8hITMRxkbyxE9ZC9zNTe5uboedUJfqHbK6GVsRyedFtKNOjlMWSP8BB+lPPuRgc3jLy8ZY0zZu/uukVwfZeNc8A/rSLmUDvRxrV99UbrywGzdqtNvHFdb/clfH22QvDlo3xjKzMO9dQU/9ml7AzmtfT7cOl0m+wh++o5zTI7ksv84fJKHUT6PP+mAiV60TffNJ2q+0oiZxiCfQJ4/XScJ5AV1dCZwpEuBontzNB/4I1/yNz+JLvT3llxgrD1d8cd8N9IO4VNfvxR3xhlnTL9Db7/n39mpH4BIX6gcZR880rl7vlgfa8bbAX8/YS78OF9qndhTtB/lwdvc1MvJ7nMt+8q+MHMwuvvd7z75er5dwt9hnwMReiJDP9NonzAuPYkJyJps5sT/SnyONZ/PFczj6x7G1RuLn1beQZH1YA9BrvlSOqIrtna4qNyaPP744ydf4+d9OyDjYxCbkgse6EU8vJHYZKRdEcj7tMakgS3gmBxF5rwpTsqRBjLk2uJlOI6FM3CvXtuchvIAxyCMBGwU7zrHi/R1TRZtpeqU6ZfDkJTpTxbtKmthLfOVq9NHEuyYL3nxNd5WyIYL6BaXeQG05No4Xkd5vWM8+jCe4Ed7OUCrc08+iw2QyQP05k1OZdog98Y1J+0tHGMBvLEtME+cQK2uJBBnMwGWh4h0YCz9BXxksgAtrpK+FgId4+EJXLBmUeFlDnTfJqDcpqC9BSJ4MpdsciDayUD+/PPPn7BqPmxFtyOe2vTolR7NlV1GPMGjPlLX+nEudICn9jZ/m7P1ow2+dCiYcdKiD/3BkfHCQA+Bcv3JRQ45PtqRV1v3xoS5krGVGyv5xvUMQ2ynjB6s3+R2P2IXP2Npazz3No03velNExZgXz2ZzNPYZDW2ckTuUlgey2sXRvGSq3NN/tEfdC/pK8WnT7tstHSnv/WlLX+Eh3vzaVyk3PiRe6lr/FG8esByTw/WokB+5HEgWkcgj2CMvmCpYJGMsBD+5eZHJ+xLT+yfHdwLlJTxGzCCn6CSns2DPozTwyT+eOLPV3lzBXtsz9/gTa+j7SP98KqODGGbjO7HHC3bUh28tgchbZZtqizbkmHkg7RjX0GHuuSS4yuvXZh03TiVNQaqrf545bv5AURuf7zJXyxTgTweeJYnU2VsSu/WNtvZn+iCj88PIWVsgfTJDvjFq4SMQed48PuCQH5unSSQNzbf4yEiG8AHjJovfXZQQnZtwvaoIzqXBIDmFAbqM85bUNjpLp3ZJ72dHPulH2Nll3i4j8iFtFUvqbc+BeZ0ag+2ZpQ3R+1d44usM77bPb+M7CXjWAcjn+GaT0G5n+f0T+zgvgMqeiUjudtHzJGs5HEv2OcHO8ykE7LBOh9hDNiWpys8+RJxCR/iM2T7TusatVaMS9f4+zlkf2PjW3e+xYETfRmT7mDAfuwg0kGjuWyWdkUg7ynFSSrgUkCAzsA5txwNxQWqwCjntF3rLwVM/ZXrayFQmoUBiAycoVxLrpUZPxkCBh6VJ09ykL8ASn+GGtuUUDzir/04vj76b5YApm/HzNXrORuUcYEOaMmozHy0k9Jpc2+xpzf9BVX6ATonTX/qARFfwRGA56A8efZg1UKTOBWOmx3IcNZZZ028jMFWdGCcNlhjqCNPG1721Q4f9TZ/JxAWEJltBC9+8YunYMl4TiB9TkOW9H4w2slA/glPeML02Qh5OWGOh03NG9FV9qN3ToYdOHF64uwk7eiDbRHb2jzwpUfrxoM0p0K3YcFYbOUaj/CQ7rSHAzbO6YWf8mSFAU7WePBBXmNph1/t2LEx2FUbuJXgoVMP8iDjwos5wQIcwR1yTzZ48EDi+0jjkhM1Nt0Y39jIPXmNp4326rUtKbeOWq9kjoe+2pCdXOasXFm2UO6zFhuZnxgjF+rBRbsCJuMYA+GhrxzFt6QOyckhjRubez5BcLFRWlcgT362sqE60XKCatMrWFDGvwn0BOVyQSvZlAtcXMOKAFwOD+yAt7nTZxt2mJKQcnh3T1/+NsUBg7aITpVnb9cSYvsxwYU24SL7IP2zp3q2hrHqUfX6orGuMVDjI3IKFOhGvbrGVefeeEjZKH9zQ+OY8SAjmcIVO8GTe/6VXpeJDege/mAYj8aIN7msAQn2tcHb98Hu8yn4kN146vUnpzp8lEvZCiWvPYffuNe97jVhaJ0kkDd/v3jEF9MZnDkd55Mka5Gc5pFt6YH+tEd0nr6bc3VIe5TPsgc4GLUe7Hmvec1rJj2kt2ys7VgmtV7yba2RdMwuHrrYpkMyp+Kd9Ev6SeEtuyP2Mx97Dh/PNhslsrGxXOBrT3RNLhiUwjrMmY9re52HB3WvfOUrp2/PBfT2CHr0tsPa0d49fZq//cUc0wnZzZvc9mYxB57qyND8+SX7HRzjjWd2gQM82ZdePRCYC52O+N0M7XggD2ROhywwEx2VwQAlClZGIe61RYBiw6NcgFIPJNrEQ9uAjo+nX4tJOcUpY3T98cv40qhYso11knsJfzLo7zpZk9e9/ijZ5QEd1VeursWzGfIE6HMXfPQHJvIBJBDRjc1NfeUcDflQQZF2crKoS37JT2VxEAImziJn21y0LciX24QBXnBPBo6AXBaRtmefffaUA7OFYhG4x7NAzXW6IXd6sZDZ00YgWHfK6QSZPcno93qdwDs1sqDw3wztZCDvd+TNjcPhhG3QTiTMSxBTsCKAZwfX9EtHORcpnNKloJ2z49jokA29JuXk4KD1ALeIjfSHBwlvfLQTPJEBaYPYKdtlp2RhK+VkDx/alOBVvXLtOXhOz9yU5XThTYpv8zW35GFnQRnyCwo2GnX6jbKGaTzcI7qBUQRHyWksCcEiXqP8ZOCL5OpaS1JyyslmrjYT8/FLDPorbx760Dc5+CX8yKe/uuaOxhw//eTauGZX/JE16LMyc9worSuQR+SE59ve9rbT5klOyTqwBvhtuU2vzVcg6YTLtdxrdmXqfUoAd5I+/A7dZ4PRPvCinq6tpTvf+c7TtQCFLpG2bO++dSWFnfQsx7N6bd3L2UYeDpUnR3zG9tHYXkLKGgP26KDTzgjuYBEOyG4culXe3BFeylBjlJSbc4nuUHzoDq+R+PxkM7Y1D4/utZXH2zrjV8wBL7K0XtVrp2920Jeu1NEnfupGec1VnTWk704E8s94xjOmgzVBK3ng1wO8uKdAkrzmo57cET9Ah/BvruaoDX/g2tz0k8KBHD96k/OhgvgxSNQONW5902cywAy9daCQ/utDfkEoLCiHPXLVXztjKNNeIj/Ciy7oxTp1vxGCkexpz7ffG9ueIpfoVG7s9Ga98yvG9Meo+Xgymwd8KiNjh0UesPRzGCSxB/n1E7Pi5UE/PxLm5PZVPos/ojt+iM0lB4oe4PgVDwT+zi9/bfyt0HbFKR/yPlsgxrZgKcJE5MoCi/vqKInjQBTMmJTYhskJyykd2OOjr4QoGchzengAh7FysIyIgABvfSTtSuQo54TkLQRkXH2NRW48pWRSl9FLyrXBqyc3PDdDjYMfuTgCADZ/mxvgmDM9Gb9FqK1EBrorIFQfuGxuNonkSv70oCzHK5EjmxXQO+Vywmas+GqjHydrDLoxroVDDvgQSHilxe6cks3aP0qwkDl+i9DCtihe//rXL5761KcufuzHfmx6at7rRHd3uctdpj/0EczTA93AOd14unfPGaVT+kdsQLdsyk7026kmWwpy2SOdsz8HZm3QNWeFJxvpbww5mRCb66NNzggvpJyd3Qu+rE/YIYsy9fqPaxwfyT0asaWPueCJj2tOl+05y2RD+qcTbU8++eSpvTHD28gT0ZV+8tZD5Uh7etVHQmSmN/6ErsxRe23l5tK85NYePRlTWaRMe/LKS+kJaR/PfF885OO9du5tOuSyNujDq1sbyG4k84Rl36J69S0AEfRY4wJx86Dn5m6O+uRrKmM36wLWw625u29vkJD2iN3oCC91ZKDLfsGrhNgxfCIySGzevfqwNOJG7r62456jruuoMRsjft3DkTLyk3XUS2Tc5m7dWv+utQlfI6/GV0YmSVnzae6uBU18s8MAOh6JHfDUXlBTgE6/5DC2tZlscvsDv+RNH7tpz95SemdT1ByVaZe8xtTGmPzYZk58V0H8l7mSEY7ZadShcm0Ef+ZMdnPhM/lp37r7ZNQhnf1cW7hp3tnL3I2DrHt+UVv80l16kuBImeReO2X5ker0VVbMlZ9Xxu/6hRaxhfHx0Ucb9fFA4bZcvWQPcr8R8o+1YA3e7e3GdC04NmexjsMKejQufCLz4fucxvMh6pKVntklPMNLh12tK1iiH2uHjx59qPmke/GK/Znd5LCIf7/6JzlU4t8cMvbZ56innaRDCuRTLEW6D5iuKSnDSy1UZcCSY2cojt5prHqGjJcEePGnbP0p2NOYOiAFBDlwKZPwRcZlyPI2eslY8hZr4xgjWeTK1Me7FDVvfPSRNkvpyzjG5Bx7KCC7DY4TpTuApTPzRuRjBzqlB23IhB+Z9LfRjrrQxzVyb0yJDtGoE7k26Sri2PWxIQjmXWsjT5edXJDP06xA3sZARnxHcm8O7Kt+LxM9+HfPEiflrQPMdEKSczVn5dkle8GQa+VwINEjJ+NnzXzSxjHRldMVJw3WUK9J8aV7OXuwhXL8KpeUhRdtELnI6cGLo4c7eERkDadIO/f4srF5kZu8KFmamw2KbvTBK3yoR+Zt45Pjx/m7Vi+RUa4PwhsfuFFODm2ab/NqbPUIzguWyWAMqXp8s5G2OW2bnzJk3OamX3M1nuDImK6TMczjU463lA0qE5x6I2UTcxIlqdttxI7evHhQdU03y3hC5qt+WSfaKXevLt1I+NBrduu69vTEF8KajZoM6juJZxdtjSdPJnzCUikbysc61/qRxXiwgnfyjHylqHL9rT955a7xEWT0uZT5NBa+1pwgOSzAIh8iwXq6a8zydCehZKBbZHxkfMm67uEoYgN9WqvxttbJ4z7+2rkWOFlL7FFApZycEtJXGRmUGaf5GkedU17Bmfk2xk4QvQjQzc986S+Zk1t5ZXRoXq7N3aEU/3nqqadOb4js3+xmTuaLnzze/IVrNqFLfzuGJxtku8ZG4UtSBp9RWMUve2tj7OQ2L2XGcx0fbUZ+tc8WtWVj683PcwrAlR+I/MKdtvThpyid6OtnbdCXtcDm5E6OyBoR7ylrfNfatt8kv/v2O3rUDy7V04V+rs0PL2Wwxz49SOArRuFH5OymLN8m0VsPXaOsO0VbDuQpg4JSiER5yDWQyikX2Ck7xzCCnhIEOk59Uf2UZyxjIQYCeP0YV+ACBBwdo1E4ZRtPXzn5tM/oDKAs3u7lyWmsHIvxyGqjaANB+mo3psq10a/Ft1HCXzIf4wvSBG2CGn8E66TJOPgLmp2A2ED10V55ciHy4yGZA71os9w2fdMNe9aOPqRsiMimPtKfzRtLPw8ezQUp08+rKUEQW8XvcCYBqP+82gMZe6UbBGucF4cIf+7pWn0OPPvRrzZsxXn2xz/6wL1gHh/4x9OJBx1nH3iEJbjxQAfzbSqNO9qbjZyoeugSTPgkixx4GRdfawgP92RVhxd8GEOZewlf9Xjg79ocrXs6gQ/zI496QYy2+o0PqxIytvb6kUFuHKQ/PbUOkHvrsbHVuadX43Pi5klPzU8fcyAT/uRwwiOwVobkrR98yZA/1FedOaTn2qvTxj19hQF9kdNIuveA5lRbEM9mu5HC9viwVYrCYeXmHOazk3K6oRN6YIdlqq08vRnf3sGOyvkxOV6oMY3P5hLe7rVxLZfUwYBr9aPtyISvpE/yVYb0KSF91YV/hI81K0jw9zOCPe0QzPcGwhoI32zPNwsa0pk+8UTJo8x1smtrTPpG6UKda2Oa90jaS6i54iOnH/0QPVnHbI8fOdlFX3XakSMeaOxPDnzJZn50IvDSZ6epzyDTF5yRnbzuJXKar2CPTdVJiO28mfJHnWwsVjFP/MIYojc2Zlfl+OEVP8Fl+7x7uh31LId5/fF3LZFNe+Poi3cyp//IvXbJ3vxKiJz6GtO1fYYvNFa/sCNOEa8Ya5mcYF9wwQXTQ6u2DqJ6WwGDzav1SWb+2T0ZzA+RMXy4Nj4daD++HWK7fLrDKGO/6lWvuo4Pyg7mw0ZO3T0o41nMh9Jl+on0Wy7bKfpIb7lBMokAh4ChRPEpXM4Yypu0voylnZwyGTPgjO1HI2pr8wdsvAUsFlHgBy4OwSKSArUy9TZj923MyhhQP4sJz+QhI2ApIw/5JMZ3r01tySpHzVGZ+o2SRWgu5ooX5wiUvjvn3M3VU77v0bXj6OmG/OaXMzWuTY1OyK48J9A4xrBItNXHItLWfAUrnA6d1FZgZ1zfBhsrau50qY+2xsMvcrpy+eWXT5/T4Gmcw53gwx/whTF2KpBmT/agJ+0KwOEShSn2YWPX6ukd9mCwNYWHDcffVvhpMQ97sOIPsgT3yEbAwWrHscEGu7KLdcAeMICne32vueaaSXb8OF0y5Jy1F1CoT55whK+2xoCFNhtzas24lwsA9LeW1YfJnLec3owVdpNTrj1eckm5e3W1wzd+ZMRPaj5koOPaaK+fpD39hmeffvn1AmtkmfDDl27I4h4/RJbGHO2uDOmTj2Iz68zrW7rc7WQObXZ0RqfNPZ2YP0q/9alt12zgHmmjPRug9GoM13Aq4MvH0Z9614iNwmLyxN+18UZZwwaKBzIe0g7O2S7cqhvHRHiMfSSkDZlg2SeSDqG8pucbao/U8eeCCSfT6vkH8w3b2odxRKfGMQd5GK5euTKJDtwne/XKmz9SJjW3+uNPX9rWxjh4NR6y/ls32iBjpnv9JTzTv7lbA6M+dpI8ZPmDRzogK7nJi0b9kzd9ys2FnvSBQfMSSOKTHpXDQzZVx8bq8PFAI6jsc1o8+Ul5csQP9fZAHb3Dqn5kIAv7wm22MCYZshsbjL4pHBlDG3JmF+X4qGtfgln8JXL6cQKB8Eh4qBPH2F8uueSSxdVXXz3FBD470t53630uqsyBUPM1vvmQN51LZBCf9Bbfp11O//0QgQMoB4gvetGLFj7hYc/mkS7c62c+5s8uxjc2meiuPruZthzIo8CIRgUHAGUUVpn76hiHkgCo+pKyHCZSpj2ASYIThlYmgOTwXGuXw5RygkBrDLLkQDh/ztKi0R8gtJVL6gtE5PjiYfxxI8IzucZkjBZH9wciOqEPTpCeUHpQpg7ABFcWBJls+P4YlAxkF4ST3eIwJ+31IwNgusavxUoXya9ckGleTgEB37dggnC/j+oP7QRvyYbMSXv6dYLoqZvT8qBBFp97ePjwmpA92OdIIDqFG47D3DnlAvHWhJxd6J1d1OU05WHZPf3mmOXq6wcj8MG+nJjAm1Njgxw8+2Y3tsdPPdnICEfszcEKJLXpX427blx8najo3wkVIg9ZYZAscGGtVIfwMSdzx8+8lDkNx8d6MycPIu4l7UbMuMdXMkZ6JI+kbbn+y2tPf0m/+sdPn+ZBlmTVn5/wgKN8JDzwQ/oWmOmDzBGfUV7tyUyfglE28KaK/v0KmABPv71A9OvkK52al3maP9uO/kvb9K5csNFDVDaStxb01yd9ZSM+iM9mC+0r1y4d57tRfOVI+/jJ2S0bucfHNdLHtVx5Y8jDKHmVeUiGf2XmBodkIYdAx1sWexX/2BpqnEhb+LNvlcKzFBkP7/RJbnNMHjonAz3TY/fqtTdnfewV1p9PHjzomxfCC2+knT5IPXkQvu7JpUw7KVzzd8YZbeoats2xPnTgXr6bcE83V1xxxWQv84Q7uErmSB39ZBPzpBvXDm78wSxfm370VTfquLmrV+YaZvgdwbz9nI7Y0Xj4shseAl+B661udavp8zJ+2z+x4ke1bR2Oe01jSskxrsnaScq1yd4SCpNhyTXbwyxd4dX8kL8X8ImRk3g6slYcbp122mnTXPDo71vcd4DUmGG3pC7ZETzRk6DeXF1f8r8PC+ISMi5T8uONh5jKuOIWPpjeyaJ+tPdupS0H8iYILAxtwiabYVFASRHalBgCWBjHgtFn5INaGPV3D0yMp62Tec7HJmHcFpB2ySFvvBaXpNzikixOwON4OhXQV7nc+MbEwwLL2SgzphSoXJNNAAWIAiFycvI5VnzwXCb9tQuY5gyc2gNmMpgPnQGoAABPJzwCbQEjIJpfQXlj0ZNFioyhzkLF23X6MX9Bt9f6nmY5Moszu4ykr3l5tW0z4FAsCEGeRWE+xiDDbnLSqyYOTXDMETtd8ybDae4rXvGK6WdbBSL0jLIRvOXM5QWUeCkbbQkX6iRldEzfHKNTDX90Zm32iUvrQlu59vjDvQ2DPIILdmY7uIUhsquzLtQ7xVeOJ5msD4m8+sKDMciHP9mRPrClT/OT8DEv/bSBMdfa6svZj9iTl7THC5kTPvjpD+eutUtGCeGtPTJGOiaPnOy1dy3t7yE0udThYxOJtzI8xrwxbDLw4C2Vh116FfwU0OwVstbDpUT2MCZlX/hTN+oeKefXlLvuHumnbTbWn37g1QOTev3Sl3buG4O+2S7MjXxK7MIm2VlSVj0yn/JkbU58n+DJAzT7d4BiXfHRTnX5ZPgpkNcGBvZF7UP1D494m88oQ3pU5r46OpfI1lpSZ/5hWu4eD4di+Qz94onogH7k6TQ9hmfJdfetJeNE+ri3lunC/Nw3jgOC/elkJ4nvs8+Sly8yx/SJ6ITOS8rhwv7v75jOPPPMqY21bb76w45DSP5anRQ/xP8iOtfHuDChjXjHm16BvN84Z2P280aWv4ctvoT+PUDkA42ByMg3GlsSE5DXnORhp3WoXE5m4+MTjtxL+Gd/19rrj3f+ATkgetnLXra48MILp9jCHnTcccdN8xOzeCDxSYy3x/BozzF/Y+JLLrybj5SMxlZPH3Rv/i996UunQ5LwOhK5tU1+baxPbwh8UtrfocClpM1upy3//CSAC/QYLKWgQMOYo7HlFI8Yl+I5PcoWcBRkIjy0B5gAEimrHh+AiC9SjjfjMEYLSBvOwpgWKAMlk3rGx1fwaQz3eHOG5mIs12TBVz/tA7trybWyAgq6Qcpd45XM49wEw15JCZjU42Xj0s7iBnYPHoIFC1sAYOEqA0J8LG6vk8wheejBXPCIX+AnizbGU8bR+u6tB5pR7/uiBz3oQRO/7Ek28pOVTE4x6VpAy4Gvk3by5yf9jjxnYHP0m9p0RKdeK/bPPUbHFM7l7CWxR+VslL0qD7vlHoxhDsZgiS06ZQiLPczBgjHYDVbCuISXsdiLnMaCBWtHX1gxJkxJ2sAVucxpnEfXxnGtzFzIpi/5wjr+xnaPbH50Zp3CODKuhOjNmHibu3mbn+vmIKVfZBz9lakjQ/rWRtnYju8gqz861XaZPLjipZ21SIbGj9/I3wZmTTh9ty7obZW06p+fvPjii6ecDdiCztKd3Lwj9XSV/dSX6ovozr1y7aV0CIf0rG2+FMVDX9fwHD7DAf3rFy+EN1JXWXIg1xKexpOj7Mru9hM6dhLqQdr6ZmeYhekOrDyAaH8gEpSRKX2Uuh/Lk717lL66JycdWKN8O3nCvHbk0tZBEL2ai7b2Y+XN07W562uNk0P5qDe5gDe+SD9tzBtfa5kerCmEDz0Z+0C62anfkbeHkZ9dyZdN6UIa7cHOTpT9JO2JJ5447eXsaZ/2MEeX9cFDDBEm44fCWXbKhnRnb+1AxVpgJ9gzroCYX7EGHMT41FJwzx50L1cnkcsasQ+4tl/gAcOu2U+fbJtsZC3HD5HPdfz1kfhxSRk/h6e3d4J1e8vRRx89Jf39Pdkxxxwz8fUG3xoyv/gjejOfUS/L8mnjoQZ/Dwz1XSbjsCk90idf7NoawdMYxj/Yet0O2q445ZD+IZRvjxgLKFrgARPJlUkMytjKciCBksIBGGlbgAnw2inTBg91GVEKUNoq17666pUzLocBoO5RjghPC4JxG7/goPGSo2BFuaRcIq88efDVzoItgPa0aPEIngQxcnIDDJBbTBascY2FH11xfGT3mYSFBmicLvmNYSy8PcmSWz91OQoyCXLcA6vgjuzKjZ2djOFTHU5BOhh5ohac+g+/F1100eLZz3729DNRPsnxBO67YkE9B79u2slA3u/Iwza7e53IRjk29qdrTqkHLpiEA3aVs0uYktjXvRxlX3zUxztiWziCBWtTm6hrOGYXvMhBHrLhA6tITjYUJslGTuQavmFUkK+cXGEfb3XGUqc/Mq5NqDWmD11JyvSBP7qwmQro8TJec5ZL5MWfrLVBrlG6VN/cyWbM6uTJ51o79eYOvzaWfZHTI+2sG7LTgXGsKff604/5Oo210XqoXccGgVYdyPP/9JcPQvSRfrsek/bZIf13n13pUF1l2iDl7M2XhXftwkKJ7skjqY/Xclm2r75xUOPGk21hk/9k1+ZWkOfNJRzywfoKBPCFK3vcRg4y2Cp96Ju8aJRFfTTeNydlcvdkw0Mb8rqWo+T00KzMPmPdecvAF/AjyVLQiLe3zLDfg4e9iF6sA6fN1nRyGx/+jSFvn7YutJfjcSDaqUBegGdu9mrBsUDePKPmyH/6/wknnXTSpDt99KUHWLEPmrf2EuzI6bbPF7VTRjfwDTfu6UZ7uTrl8E2X9Mc30iF8sbkvAfzPEvZCAmd/VMpubOO6P06F3XwnW/ZpjqQNG2tDPpQ85JAbr3LUPZubj/nZf+jhAQ94wCQvfHl77xMbMolFyIqHE3EHYGRSp1/8rD3l6QaFcbk56ONNBN34gQB1+yLlbAn7dGk+6Z6u24PXQbsikL/kkkuuMyoFU6TrDOu+PCVRuOTJ3JOqwNSrSY6SQRgfAQIlxwNPde5zLsqklK68/sqMQy4g0A6IAH5sb1wLFWALegAGeJuPXBkKRD2MNB7+5qefPsZpQ9EOKCUbkJxsxgZizsGnMEBIXv31wwsfY3BkHKkFJ6BvPogslQMh3sbkYPDSv0SvNpb0SB5tjWURCczJg8/BSHvfz1s0ApUWRYmM6XrdtNOBfKfOHrDYpRMVG72NkNOU0xHHzxlzWPTOHuEmh951a4he3bMj24XZ6sJitlVfnVTwbUxt4c49bLaJu9dP+3HdIdfwp157MrJ5ZFxt8FBuHPKGLQ48mbTDHz/jWofawJMHQ/20K2mLf3kpPslKpnRXuXu8k9V8wmr8asNm1gP77IvIanPydwba0x1d2kj4N8GLvr655Otar+uiVQfyj3vc46ZAxHzpzNzL2Ztu3dPvqGNJXXYbKf3vq16/cK4NG8OxXJlce31LY5k+kXuEpza1a7zK9FEGkwIb47CpckGSTyisdYG8oMrcBULext3oRjea8C+o43fVHYjshfQ0yi0fcW/cEmpezQc13+qkcV5dGys7KXfNlnL7kXXHZ8GxsbVXxlcpN2dvH5zo04Fy8yzAtH6U28OUJ/NmaacCefskP+UnhO2l5mw+iA5L1r1PQ+jNZ5T+1sVnr+btrV26oDtE3/UV++Qz5HSs3N6ARjtLqL5IP/rG20GgN/L2nOwFr/yzcdiUjQSwbMe32cPNEz/BvXnCuv1ATOSAUT/l1hq+Dn3IJ+ZQLr5aXn9h0pzY3lsKOHGYATPti/jpw1/6GoB8/CS8y+lUG3EKnj3Iq0fK4sE3sAP+vhY5ECWjRE/Jm47XRdsVp3zU/wq+Jcmf9axnLe5973tPChSMUqDghIJTSKy1kSiseg8CjNLraUCUtJFGB6MvQFA2wkNbbZSpq21g06ZAQTugsJg4VfyA0PjaA6Jr1GLTBk+yuAZUgGwOKLmVGTNZnboZz0LAV13ySV0HHk+HdOg3VvEyliDGhtHrMXMAcnXmxTn4o1SBkSdwi4KTUc/54J0TVmdD148sThiV66u9DYS8TtbVCUo2QuSa6SPJBi9wQ7DldSt9w4p/jOGU2beO/lkUYgdOjg3gJ8cIm+4FA+7Djmv2DYvhzrVy177Rl3Pi+of1Ngs5PvDgXltt8HAPa60tzj7skY2jJ4dcH+Ork1DrMuzjZ1NTDtPGsLGoxyO5bUruYR6WraOnPe1pEw+YTh/GQ+lDWSlMGjM5ENmaW+tYe1iXrI3mpZ8HUxuczU7bfRG9ImuVLOSzqbMzfdGVTQef5Fon+SSIf10VmRvfQz8wTJ/ZW6JvabSRe7pG6aR+2RUpy77pn17hMT6odnJtlS/3i5SHh6ix5fEY+cECnEoCHQGMoCMfqi258DAv/NndiaNAXpDlTaVPLPTDc3/kocB4eMISzOInx785JyOiD6SMzNqq09b8YRs+8V3WR7LgoR5mYbX5qB/1hS/+2is/0Fy2kxwU0c06yacpbCZQffjDHz7tn37MwSfFaMQLXcMH/dKLcjl/4r+f88EwwMezRXaU8xfG4GPpHQ88+ZZO6zsEsj/gCxva4WXdsRV5Bd3eIMKeP35lJ3zk/oeLz5jxglO4xLMxtfOg6o9SyUOGcKEtvmIn1/yzfubHl2rj3lxgyN4H6xE/7qeYzbH5G0Nw762+hx/fptMxXZGVTMYyX7ERHNs36dn8tYNHcuJpLTqQFUt5iKKrA1E22Gmit+2gQw7kEcfliRkQbLiMEGGfwhnFNeEtCIGub5qAoUWRk3BfP0pnSKCNd3WBCOXs5DlCbdR3YiCQwBuQ+pwgmYyrf3Ig41UvqU9W9+SSu28BS3RChvihrtNDvAFW+7vd7W5TGbkBsTHxNSfBO3klOvNUbTHaXPyDBe0EIGxh8XCAnnzJod5GZPyctIcpf3BnDmTCT75Ral4z/V8aA3mUviV2hi0O6XnPe95kHyce7CZpE3Y5XNcCJvewIIeZ+LIXu4clZRybII5ztsbg3LjaGTtZtMc/3HZvDPf4WF8SR9lbJuThEF/rCW/rflw75DBHfOCrzUi5tuYMx8bSXt7cyWHTgOEnP/nJk4M2lvLkluMt1xdf5VFrRxtJfWuXH4iPdWROZKVv18a2cZHXw8X+CI8jmegPxuDdpk7H6ZueCyLSk7KScoSHpG/YU4/keCFtXI86774ULwlZE8kST3XxcK28PuO42sAP7JLL/MyHH3Vg5VteBynmEa7MQa6foMYJKUw5hfRjBPx8Y++LPPCTWRt6wMP6te6kZTI3SR8ySMYzF7Ig8qlvPbiO6tseCvtOawVCPsM4kqlAnh4Fof7DNL30fyToGIWZ8MNuYdjb11NOOWWynQDTH2Daw/VnY230E6i6V8cO8Rej8LPK+Kx8MJuGJX7Lfn/CCSdMD+2dsDuc45dh1gOE31Dv1N+4fKq59XBhTO3xEWC7h33Bs7jAWA4/7VH6qLN38ZHtU5KHD/fKYYl8fuTBGyqUDNrAt0947Ad8ruBff9f2Br++Y93AqBjH57r1JTMd4SvuJKMHAO3p60DEPjB/ONGHd75DIJthGx7lAojEsVBaTgUBRBspQ6qrj7YBSBuGZVR1AAEoLRzGymDKqzcmfvjktCrHFxCMLQcGC4PsDNsCajHmHJXpo75x8ZaUqXNNNrIaTy4h9eXa4Nk85PFp7EDW2MlfSh+CIU+xgv6eai1G8xSkFzAJouqHt7lzChYpmVwLXMgw0/bTiBO4Zh+Y8zDsFaCAwIOmerZmnygcIliAF+1chzlUmRyuOXf2buxwryycGUu9FOGnXjv1OWmOtF9bwEcfctkoBDmoOSqHz8aV42vO5m7sxkH5j9aghwOY9UkKHNdOX2tPXgAeno0rIbJp17iSNsrGNlK6Vo4nf8Mn2CgdHMy0f6IzdoPfHnrSpwcvuGEDelcusRd/xYau1WVT5WGRzRDbu8YHxa/+eOqjfLRpZZL7xnFd23JlpdrFCykPc+QRwHgDbY75VRR/8gpinIBa14Jx/cLe/iisNnd8yWhs48QjuQuG0lFrW+5eW/etdclatTaVJTdyv1w204dsQo907QHO/poNpIh9HLg4LPNAdtZZZy3uec97TkE6H+lzK0G9h7sOD+PD37Cj8uxsXOtJgCoOgi182NC1XGB9k5vcZBrHm14PAt4Uwal6vuzKK6+cPjUR7IoFzMO6sfcL+Nnc2PEVDIsHXIsp/EE7H2zfkutnHAdVfXaIv3F9YugASSxhLt46m5++ZIJZc5OsE+UelvSjO9/vIzr2VoF/t47ckxOF7XRlfTmw9Met+/tRgiOBtiWQB0jGlYAkY1E4gylnLL/Y4A8/ACCFMwwQMTKjA1Wn5X0SwvkAIGMDs5whA6BxpMaM8GNsIHBtYwYoMgKrRSJY8ITpSVPwADja2VT0wR8PcspHB28svAt2jB/g6ESf+knqq5O6B2hzxE850l4ZPeCJj/kai07JRk8WqOTNBt04KXLSS+e+udfOnPGy6Hxy4bt2pwPeiliEFsORugB2itiFDfwkl//+Z22wdXhhZ3iANZiwmbORfuFHWxgqacv5IYG8NaKPvmwPN0hf19YBfvKuC1jw0W7kLxkTlvB2zcnK8ctZu5crk/AyvjUF680JNbaknXVpA4LffkEJka25GEeeLuTxdG1MeURuVFny4TfKaWx8lZE3GWc6MNGdk0ABCYIN2KXfMIRcZyfBJJwj9fnZcBjhw16S6wiP8JBvjT951EXKUThR3315Sb1cG/2Mi7dkLHOEY74W9rXrwQR+R572EgGOh2BBijkeiMyv+eovkLNX8s/05bSSTMllbPriK8gjVx51jZeU/vQ3H/dyctv75OaSvmb6EKUn+hc800/6VC4ecbJ897vffXG/+91vCtj9ag1cwgAbvvCFL5ziDUG+X2uxdxcrsKPkAZHNlEuNA5OtCzgQF9nv/ZDCueeeO/2RLZ8swb1g+6qrrpruHbx4EPAjFmSxxxjHGoWvfKlxzYfv1VZM1K9rwZ84wTzgGUa0zaeTHR8yau8BVju68bAgntLGfOik9Rpp40BLPKJO3OKNgn4ePnz372CFTrxJ8HDkUAk/8/RJMFno50ilQ/pjV0FIBGxOZWzUgII4B6c1gmSGZwQLwYJwSgFoglNGlRgCELXN4IAbAJQXLHCKHFcAdi8FSPxaFIhsjI2fMYEOUPDGx2JELVBJu/gZUwJIeZRsxmvxSWSqL1KvXFm5OgvBAqeP/rpcsiDIa+G1gPFvg8IvHSind+CmH/0tTq/zBIgWgSCFDixKyUL15Gw+W6Wd/IPS3Uz9setGiN2c9LC/wACxMbsiNmZL1BqAP7k6OMBDDtPsqa+27tUhG4f24VN/43QNM9pLrhFe+IZ7SXtrxRj4IZiDY3211z956AH2bCY2jvoXeLhvPfEXMA/7AkP/4lw/68J8koE+yNy6S34JL/OSq5OQe2MlmzWlDC9y4mtMJ01y9wejIx3/55133rVXH/KbdNsfbAoK03m67p6/YjPl7ulaHbvgAVfy+GoraSvVN37aw1K+ESlXHzbk4aGykZKlfo3beJFr+OXfBSAwa1zt0Zibl/Un+BfM88f2nP2RU1s+gIzmQ0/urRvrgB+nX0GcB1zttLE3kKt1SB51kfmwh3IyNc/mrN4ebZ3icc4550yB3pFM/bErHfnED/mEjL75J7qkcwcmPkXxTbr4Bha157skn64KUAXXdCwYpm/+mF3jw97iJsF2eBN/iJW8/RG86sdfSa7tGTe/+c0nLJILJvhP2MZXME0WMsEh28IivwlXxgyn4TafLW7jB7Uxx3ykcfEJQ+OelD+GQfKQwSm5sT18OHBUPq4BPMiijXhEcugrsCc/vdEZneNNDnOgUzKSZbNEP494xCOuvTs8aNsCeQQMgEjpnBZDABdHYzMWsAAnYMkl4OAMGTPnmpPhfCRtckz45exySlH9AAuo2hAAi0wcMFAqBzygslDIxXGpFziTVxv8tJPibcwWn7IWXWMiYzYf5XLyuq69ewuSjszfH/95qkfkQgLvPpEgkwVLH8AbLzJZbBaC9urJAfAWTA8reJBdHfmNyZEcCs2B/L5po4E8+8EmfMGfzV6ZezkbwggbZ2e2ZEf41CYcyfVjZ/jR1+YPNx7w5GyPTxQ+JaTOdeX4wVNkXIR/qTUCk+EJH+PbCJof+cggue9Nk3GUmYO2+pCb/myEyvkO7YzfJkJGlKzdGxe+m6c6SVn4b1xtbHw2BhuGh1v+i3wboTmQ/3Agj+jYpwNO0fgdtqBn9pJcwwFbjTYKd2xT0qZ+9ZWPVJlxlm1WHylSZnz8rR84cK2s9og8Y8JbHZnCKczCjeC3uWgHY9rKJeUwqw2fq8/+yB6gLZn4c7zl9pIens0VH2N5GNYWb+3kSB1ZWxOtG7Lrb67pQm5fseZa63Mg/+FAHtGbAJP+fcrilFtg7eTY75+LH2BJ0OwXa7xhdaotVqFv/eGArt17IOPf2EUZG1o3xx577NSWXewFkjr2Fk+xIWJXNiaTAFmMQDbXfpPd/5MR4N/0pjedfH8xgT7Gx0eZsZWhEft8IIwjGIN1/awZfOqL9DN2uJfUmwOsC8K19dBxu9vdbtKfrzKMqy1+HpDgjf8Vp+lvTPq0HyijAz7FOPYZcyArfW2W6O9wC+Q//Ni+TcRAQNqnKpyLMmnZceYAS0gZ48i10762KGApAzZGBzL88dAH4LSRM3wnGb5f8/DAcXGM3g5IeGrLYcoDmDEDqj54Ngd1xsSfvHLjq5PURa7jJeVgLXRJnVR/bQrAjUfmdNS8tFNHLnKbg7kos3icLFr8QG9BWRDu6cqi4Yy0nWnnKPs6neG04YJ92FmOcoowwM6wOAbB+vTQiFornDFMcqD6aIvwktzL62fMyvWztsiAnzIJ5lByI31cS2FXcMwJ609u2HRaJZEHb47YOGRF+msHm/rYCAUniGzaJo+2xkWtM+O2zrTVTq5MSi/W6qhj68LG4hSo8WbaGtG3kzQ2FFA4YWQXtgpbUlhDrpWFQ5St2K0+2bD7kfCwTiTt3KOxbX3lkjZyWOJDYZf85II/PpZM9Y8vuRyYwAvSDh99k9k90r4EW9ociLSjOwE9GfgEwZm9Srl13/7n3jjw3Fo1dmM016h789SuNSCNMs+0b7KHOl12EiyOECz3vTtd+vu0Cy64YPq01T5L3xI88b9syE/nQ7MT7PmDTb8Ww9b62Ps9RPBLEh/Fn7M1fsUAbPec5zxn+v31glsk/vKtu7UoyPe77R44fKLS3kFm/MK4smR0jzdMGFcsh6ex1ZPZdWu2ezhSbx3Sk2/s8UHaeli0N2hnDHrxMOQXieDa+MiYgnp6tG7IaX5iJbII7Mkz++sP07b8as2BiJGd0PjDB3/FzYgME5Db/IkBXJwhUOgXyApmgA2oBaGIwYEBsLVDgKMfvozPyWmDAqjxgUCddpIg2Bjk0j9ZyGFcC0c/QOyJVptkx0M7uf7aI9fKtcMvYHu48N2ZHHk15z+l4kUususj+GkMiQwWOv7m1ZgWvuDH4sGT4+kJtr74aG+xkd04h0J4zvSRtPyrNfsjtvCA6V95O3WGKbikV/aFPWRTd+0UKIJVWJKHK7l+bA4/1lq4rg/e8BJ+wyNyHc8IfvFB+hoDjowTttVbEzBnYxuxrg5OjakN/Dr9dlLUT6Jav+SBRw//MOw3ynPUfs0JT/ccPl6tCWPEA29JXXNNRvKoU6atuQvGfIfveiuE15FM9Lwv4u9PO+20KRAV4BRghK8INtiJjeQS27BnGDSGPularp8yNmU7uTJt4TKfiK/2YUF9qbLK8cNDH+S+Nskp4a2NJPCCKZ9GwqZ1p578KNnwII/gw99kKdsX+XZaO8mY5kK2xksWJLdm5MqNnZx8BT26byzX7RvaKo+/ufpMwfpF9lhr80imfrVmJLrli/ku2Hbq7R9B+XzVd9r8F30ifsonMT6DGm3FBjBTG6f53sSzwfnnnz8dwrFNdlmmsKCvoFwMAXuCdWtOHHDNNddMQS8ebIyfcVuHYgoPo+IxcsGkgN+1fvYOFFbIAWPujW1PcS/OoBNfNQjCxWN8qm/kl2W3vzmwsma0M4Y4zt8UkJnP96tAHT62N9GZsUYyr+WyzZA1ulWfv1vpwzv2iigAAA9inJyiVBmDUXBPZpyhe3UAhiwAi6VyoHJdAlQgkQM3x5lDR3Ig0AYIPSF68uOI++kiT5IWpmAjwBnLPOJlLLIrC3BjGwA1D3Mwd2XqjC3p46nSQ0GknbmRXZv+oINT1p4OjItXchhTW/fakNXrWIvWfbIZGyWvcQ81iJ/p0Ijd2JwzdsIDT2xiHXCeOU22Rcr0CXvZlT2Vq7c+Su5hUPvWkuQhTrIh4WGdwBZnH0bJoC5Zyo2rL777yiVjWb9OY3sFrR4PwYUxJFht7DYZcnsAuvzyy6/bdCLyWAthX0Lxw98c0ovkGpG7PsayWQngbRz0N9P2kiDBr0jwp+GYPWALuWaTbOkaqR/thpb7lbQpofqyZ1iCCaRN9VJ4rn/8WlfV4yVPTjxKsCboQOpaQ+pGP209NH9r3XrQZl+kDR7x0c+awU+Z9QK/Au6CHWNYX6i1Tufk1r51Zl7q8w/NUy4Ze6YDEz3Rp2DbH4L6z8Y+pXHyTcd0WGIDbyX99KKffvTfzrUTtPLz7CM+6W8TxBoOMcIlHvwpn8dusBAG+W4/NenbfCfa+vjM+alPfepk29NPP33xwAc+cHGPe9xjagcfsOIw1ect7uGqg1VvFvoZcOMaQ1IHX8ZzQGN8JH7g2/1Sjj+4JYeHEf7UgwX5l0kAr5zvxYd+yNQ/iKIT+4ZxJDhG5FmmfZUd6bTyQJ6xALbPbBgRMBmyBFSdIgAQYBbU6C/XhxMDQjwAVlv91WsPdAEOaMo5aMbH1zUecjzIpNxC4midJgmgPSl7SvXkbQxtjIMnOfGQCmCAHRBdk6vxG1veNT4WvjwyRn9NnvOOlJFTOZ6NqVw7zgBvJ8EemMhFFzPtXoIRNpJzoDlR9ixgjdgW/mBKm9ZImLRGkDrXNnqOUIKb+LoPQ3Jj2Jg8zHKmHLQxkDGMC5faJVfOVh5Oq5O0d9/8XOPZepBcC3yc/BWcKDMfr5L9slJyRPjgjS+Kp/m3ptLHMqU7PsJpkVfRcut/pu0n9nBQ4lthJ71hLpu6Zk/4QmF5tOlyHu7DZTmMda9ta6CAF77y8fGX3GsHA7Aohw/95CVttEVkDtOSchiW+lYeRskgIbKZr1z7ZN0X6aON5JqcSHtlZKFLY7Sum7MxrG9r0HV8ujbH+JkDolepdTjTxoi+6d8BoM9p/J0bYic2omsBqwQX5Q7vPAQ46feZjlNoQb5fXsn/IxiRUHhF+ItRbn3rWy+OP/74KQDv4RAufNbj236n4h6mr7jiiunAwlr0z6L0gWmxjgcAgf1RRx01/V57DyKReAae4MOc4F1cwe/7PNJ46vC1ZnyhIQ4x932Rz4fEVMg4+hrTb8OT16Fqa81YYiHYnWljtPJAHggFC8Du6YvRGBy4Oy0IXJ5WPcVKQMvgHGzAZnxBBJ7uGVyurYWAtKkeOPCvLX7AApAWAUAK2gXsPnHwV9WVF6RzevgDrnuOkgyeSL0qkksAro+6MagxNnlaJHh5sDH3ZQJc4zRWgYt78qknD97GMjcnAnTKMXgqV+/Vl8U10+4leHGK0TfskjIOVAr/sNMmLnfvutypoAA8bHPasAHvrQN1kjKEt3L49VrUaQlMFbxoC0f4kMVm4YFW7h4uc7Lxdq9Obg3KjWFdwqI+YVt75Zw+DJNHH7L3D1dGwoc88uajPX3YUPXXp4TGNvRiLD7IWqEvdTOtlthG8CKgDtNwwbehEddd8/dsGK6QPiUYLsFUacSGduFlGRthwjhSY5JVUh+PeKORh/Z4aGcMa5fP7TM2WLOOGksfvJWNAdsymRN5pYIofRtHuTZ0qUwiP77kNGdtwjs5G08ZGZB21qE1r56NjDPT5ohe6Vi8gtiazWCHvUZMu0bso14ePsJc9tEX6asOKeOn/bSl03P99PGAwJ6wp94fwD7+8Y+fDioE6P7eQlzz4Ac/eNpv/CfmH/3RH13c5z73mQJ5+4eHCQ8XxieXZI36FSXxjHHELGI0a9l8+VFfLnhggCHxnHb7I3PxuZL9LlwbTz9j8832CeX0Y37pbKaD08oDeaAQEACZa4B0X9BSDjDAKGAVWAMnQ2vPuByTgJkDAoR4SUAHTBZMQAScHGwLpQWmThsn2D5rAC5Big1eYCHl2PQhS+AqGGljMkYbifrGl4wp11+9a3wthhZopFw7uhFgyc1LGT5kA3R8LCgnXc9//vOnV3cC+De84Q1T+f/f3p0A21GVeQA/IOtglbKDsoMxCLI4YSdBWUQJi4GAECI1MFPA6EACjoJWjYM4yhriiCgEQtAZ1iAhBhQwAdkEyRAgrIOJEIRiC5sECZZy5/0698vcxJft5b2Xe2++f9Wp7j5bn779/77zP6dP9zW7anlQGkHzw/d/hwwZUnEUN3SseBUC2n13zyPgeDjb4FZwmqOV7riRW/IIIUqCT2xAXlzj7MMOnFd9wXll8BDPgY2xD+3B4+ClcxIZwXP8CzFh37VJt3XOsC/t0B5tN9DXAXWGuA5B/vAJ2jl/vPP5nbTPYN4yOY+1zYbFeRO9A/fVGlyc9rQQp9wX9w7ct8Zt3B/HwadGuLfyiA9+CuGHleGfg7PBYyHKNO5Lb6wr6gk70X5CWXtxFa/EawfOK+e6BG2WXz7psZXPli0Iyi8I6nB9yipnX/5oo3h5gvfa65rVzw7DHp1Hee3WJnn9Lq6NryDevVPlCVjaRNfBd1srz3e6J9Fng9/VPRPcCwHci4B99899c28D4iOf8t5ZIOD1+2PHjq3EtKVr+nvlcMQsti/VaBNtIB9dc9hhh1X81Db/TExj4QsBrz4azISmcva1H0/YqYke8XiGg/jvfLa4xb/K49wLA65Zvuxa8BBcs8lbv5PzuQZ14yeBH79XYtHoFSHv8UssG0F4y1cIe8cI4uYis5spfzgviPhwoNLcYHFEgfLKSIdGB4eU9tWPhOpSRh6EUY/4yIuYHJw8yKYs0RKzK/JqQ5yPYXisFaI+iChop/MoI81WO5CX4I7rCzhHnEfQFsccMlIT65dcckn1lvro0aOr4LGUWUxtkY9Ra7/zJ5obwUPcce84VpzBRdyzxS9xOIMDMQBs5A5e6ajFCeoNZ6hOccFNx8HP4BloB/6zUYPlmH0P+wJ58ZFIsEwOz+KrAvhni7POESHEhDrYawTnEuTxZEogKG655Zaqnvmh7a5TO+NYveLYNKhLnDZoI1vwj3+C9ak6Eb9joveBJ35/9w8Xwz+5jxC+UZAO4bPlEcSzhYC0KIcDjXYjSJM/yjuWTx68ti8eZ2zlFcJXRxzIj7f4jOu4FnBN0mwbzwXqiutRjp3aLgjqdU558Fhd9hvPyVb4/Pg9BL+nurVPOSGuBdRjXx0GtZbRWRYSfUei6wgf6NORvtRkEpLw5UNpHQLaPg7hWnAouAU4bIbbfQzORMArdRDfJjmsQ6cfCGgvtbrvyks/+OCDq3959fEEa+PVeemll5Zx48ZVM97y4oCyeKRNhD3+qpNf5zvpMnWKc20GEZbi0HG0G83Dfzt2jfimb1gYfK7cwMJyHz7ZAMJv53dwftfuGCedN3xEYvHQ40IedKAeAREmIQbcfKRCbIgOGdkD4SClIVZAPBIKiGB0yjiIosjHmarbOdQRzlm68vKaJeLYpWuPNsZsBSI5RmTEZlTa5lrU6Vh5bQtH7xziHDuXOpQJo1UGtEt6I7TBNRBsAlJzutbREe3Wv5lptyV65NFmdSG/tqZTbg3giVkMjjVecAreu4dCDOrwQsAXcbgUPA7OsCd5Ix5wONYsyoMnzic4lhcfG+0q+Okc8oA47XWsndIinzoEdQcPDTbssxvtJao4fVBPtJ+96EzYEyc/ZsyYSmBImx/KKOu80rVDYLsQduB3YDP33ntv9YTKb+sc2qKOxLKB357P8gUb/tJgEe/cUxzGEVvH0m3d5+Ba3HfxQiD21aUOfpdft436bcUBLvDveOJ8ztXYtwQ3cQnfHfPh+KMuZUCeaBeIt68NtmHLsR9cNVCOOjoDHjuXc2qT8toRNttYF7GorrAFeV0LIekzgwSW62RfBJ3lC2Zw+YQUSd2HGAzxZ/369Zv7BRdrz4cOHVotaRk2bFi1pMX9abxfwU1+0ntBjbyKdKLZE1PLWLzLoKx7777SCDiw4447Vi+4uufyKetFV/8iq07r+M8555y595+vNSGojzDhQTjTZpa+mGD1dJZIxxNp8tAXrkual2SteSfwcfO6666rBoYLA17jY/Rhfq/w32wytBcbkJ5YMvT45yeRioMjho0ajegQws3icMMIjDqRgrPiSEE6IJR6Gp18jCClyadzcB5EkMfW+i2jYY/y1e2c0jh0TtUxw1CfdjAOdahT3faRVvsIFEbihY1ol7IMQJuVV6/rdA5x6rfVdvtIzJCMrOVvhL909jKK+gCpY+bEtarb+bQtbpmtert4C5cay+q8zY5FfX4SP3yajCNkEz47h9scG+ftPrMBAW9t3We2w4lz/hw4buEJngN+6cjlxxd89jjW4NI5Q0TYx2n8toW4l3ip3sgf3BWnXfZt5bOVz1ZwTnbnOtSLy0IIJdfIrtiA5RY6Etdnxlxnoe7O4BvLfIY2ujYdgrqcQxk2Ebbld1dnb2B55z9uLAlwBX+t1eVD8RPcxxCuwTvbgHi/tRDnlB58iXKNwFc8kKYPIBSCF+rBfXahDfgTnI+gbhzXL2kPO9NOAfc6a4c61KWcgKuOI105vp+ddAa2SwwSUzHY0E9pJ6iPnUUa+9F+9YLfkO3Fi+smuOJ3WxIQjPn5yb/9/GRncP/5cn90ZHbbBIL3fA455JDqpVQ+yaSb39QykuAZ/gQ33beYnRaki7PcxTp27VDWfcQ/n6rWB4wfP77Kqw7xdAI/SIMcc8wxlV7xYj+eGHDgsnYZbGgT38wP89meKFh+aMDtPUEz+urHoeAX7mkz2xGcB5cNQqzNXxi0D/CW7Wu3tuK032RJObo0cD3ssp3Q40I+4MZxSISLGQPOCIGQwUjSyJOjRWQ32M2V349uX7wfH3EQUx7ChqNDLpcRl4I0MSOofsfKaoO6QqzIH8TkAO2r37mII/tGoNIRXvsYKzIyPOVdD6NDSOnSHKsjZnLUKzCsqGd+uM5Yr6wOZbXBVnubkXhdpE7bY3G+I4+TOII/XjyKAS7u4If7jlPgmBPFdZ08x42vyhMYOGVf5y1dGt4RL87jZSfOU93Bz+C8dAGCp+pyb9UB9sWBdoBjNiRoH35qM6Euv3bgszqkOa+62Y2OzmNhHQ9hY5C8MC55aUvHFedSzm+lPjbKTuL65ektLO/89/svKZQx6RLflXbP/I44yQfiS/hMaOSgIF5ccDQQ9z3S1SdOHyNf+HzpUS7e1QhfroygfIhxAw/9EyGlfXisHuXkcwxRpzT7bFf/w16ireyWyGavncG52Q0RzT61Vf322RafEnXG76VufZTzmvSRvrR9RQr5xRfyQBDjNEHvnhHD1qqboPERCv7J/ReCf3Fv+bHwn+4luN8EvFlx95TAxkV8k2Zy0QQNP4oTkaY8XYUb+++/f+XzvXfEJ+sLoj9wbZ4Q0Eae1rjXuOR69THqd27fxuef8U2fhmPq0G7tNRjw3hFuRtsXBGXCXuRVZ/QlvQ3XurQ20mzoNSEf8CMiodGhDtzNZQAEjRss6JyNIBHRjddEDhlhxCMAwct4OExEZhiC+tUZ5IrHquF8bd1E5QgZ50Bu5+EEnZux2Oe8GYY4eThM55Im3og5jED74vzyBFmVldeMo9G583eGL3/5y+Wiiy6qHyVaGYsj5AO46tFovPSKh/iCv7iCiziEc/geg15OWDonzZkSRLiOdzjNIatDuvYYKDQKd1y1df4QL7GvDbbBYXnZoOCcttLiONpqq63Soo322YP6dFjx+TWz8DopAxH1LAw6NYh8ttoU+4sq31NYkCBbXhD3oCvADX9i410MQgdHIPy3oP7YBgdjHxxL588FvMVpXLQvNPI1/LJt5GETZhPxXJtMHsnfWC76IRwW71zRXmmEnDZJi3LysFnQRnGe5prhNIiVb37oB8Fv4Lyd5ekM6pe/u8A29c/LM5ZEyANuCPiAC3h1+umnV2n8hCV/9A7gAr8e9xlXQDn888TKC7R4Qqzzq+A+C8ry6fyietWPazis78Abs+omTOMFf3pHXj7XvvsrXSDalRX0MZ4M0TOun5C3r//AeZpIe7XJeQ2CFwfqMUBI9Ax6XcgDMiJ8iAvkQSbCWJqZa6NaaUhLoIgHjppI0QFwruHwkCyct7hYu6ZuBoOk4iM/MqpfGgP0MyCstBA6hLc0L4rIrx0MBcIAtEtZxFZG/cqDtBAu4dQXhBTy7YMlEfJgVubUU0+tOnqcjcFfCO0YOMpnAEtw4DW+4awZNAIhOhCcJS4Av5UjrNlcdDjqZSu2ziNfiBUB2ELYyvz2A3ivvDbrHMRruxlztq2N8muj4CUrv4vOxLsfXnhaHPfjCZz6Es0FfFsaEC0mdQgS/MZzPApeRWj060LwU5o2BP/wVByeg74juK7O4K4BpTLicN959Sn4Gv2GvOqO/kHdER+clS7NebQv4p2DveB8nEdeM/L2iTO2EHYUiPKJZY8lFfLzA+cI1/jTJvyhJ2J5Df+MI45xhE8noAnw+FKMmXgTgLiiPH7idnCd/YTA9qTHgJTvxW8TPtaxS3M+g2U8N7Gjv+CnQb/gXAL+4TtbEKTpT5xPO3xcQ3ujf5J/cTmbQr5nsUyEfIATREaz8R4phlMmSpBFOsIjazhnxEJ4DjhI6hI4WHltjXwRVhryc7TqZlzqlAcRwxHHTxBbddtnHBw04jMQhuf8SL/LLrtUadpp4CFvdCQhjMCjKO1cFFLItw+WVMjjIWfv777xBl/w0lZarFPkUIkeDtFAFhdxkOM2kMQ1+Thg5SOOfeko5IUQKfKE8BHEA+7jMvuJIC+EKBJnP+rUSWgHu2J7OhK25/ErIa4+duSYgPf1BdezOEgh35zAoaWFQaanmt4R0gd4soQjuM/f4pcQPhlHbRu5h1vyC+JjECsvexDEQwhs3LMfx/ohNhA2YSs4l3TnALwP2wFbbRMXbY46ou6Il0/b2IjZUeJKfQHnSjQHllbIA07gN99lhj38Nh7E0iUz2jhgmZeJQktdiGa+MzgnP84Ev/EkJnfi2HnEmTjE7Vh+Kd6W71UPPuoTaCQcxEt5tYvGAfrGEmKDbG1nR9b+33DDDYv1BLUzpJDvWSxTIR9AMOt4OVNOnDgmCjhWIhzpwzk7lpcTR3TNZzC24oLYApIiZxA+nLV8CB3CJQSFdgjyiFPW1qfTtEs5hsHoCC/kZxT+wTDWWXYVKeTbB0sq5AGHOVxbDt1ym7ADwsDgFY8Jci9WxbKusBFcDx6zFWU4fmJBffIQNDiP+yE2xNvH7RBJ6tIOxyFA5JVHXh2PNPvy2+pEDBx0EGyBjRD0559/ftVuHZM0bYzOa3GRQr45gSPdARzEbwNOL3uql8ggPnDOcXBXAHwM/gVPbeVXH0Te4G1wnF3oO3DRFheVCVvAd3mBrcTTVmnKBrQp8qqDvapTXjYoTbucQzlBmrYbsLhG9h1Ymv4j0b3oDiHfCPfc5Abt4kn+7rvvXvlI95/f5x/NqPsqXTytEfCF/5aH/8QhPBSk4wwe6gf0DfxwlMUx5fQVdApu4mjYCr9K48gbdQZMBikXy4k9TTBI4NO7ghTyPYumEPKAsILmRJMQlEMkmJE58nhRiogJpyw/ctqKC+GBmN6oJsJjOYLRJ9IrJ69yiMyJO586nIPzlkc9OhR/aCCfNM7d4y+CzbmQnBE6T1eRQr590BUhPz/wLEAomCUhiG09fjXDQ/SwDXxmH8Fl+XGXgNBR2OIp4LzANnCeo8f7cO6NebSBPUQ+++oSpAmR1zlDsOiIdCJmls4888yqzqirK0gh35xo5OjSQl18PeHge9wmTMxO4m+cJzgZxyE8cF4AtoCL0vAt0vhxPI8y6iJs+HK8lVc5diIfvssT/YBzRr3yS5PX+aSFSJIG0lyP84ZtqSds1HkbhRR01T4S3Y/uFvIBXMEt/hpHTAjSMkQ+n2npCv7FO4P4hyN4ZjacmMcXPBToGvn1Dbhl7bt09YizRMbMOm7GqgH5HdM1eKgc/ioXIWwMf2Nfvq4ihXzPYt5vdi1DcGKI2+jMOD5k5MwRD6kBme0jMoIzCMZhn/PkcJEunC+yhpOOrQDyESoMS33Ob1SrLeqU3xahtSOeGOhkJk2aVCZOnFgtrRGXSHQX8DACO+CY8Z44tsYW73wX2Iw7W5DGVnAX3zl/szB4ibv4HIKFXXDmYQPiw1nLF45cOTbFLrTBOQT1C8rZOqeOgK2o15MvcRMmTKjqBOdNJBYE/MBjL9D5YzD/OsnvesRvdjCAn8FRnBQAX/nx4LpjvA1OCsDfKyNPpEcZwbG6w/ZAuvrEg8Fz9BVRTr1RpyCvuKhD+WhHtJUIkzex/AAf6Ai+2UDOnyPFP1pbQgm4w6/zrfwqXpkJ569NIHp6Ra/wvzEQNMGDW552mkhRFs/oIfk9xd1rr70qezIpEhObwUftYhfBccdC8FhINC+aRsgvCIhkpBpOkXNHaARnEEEy+RAepCOoYzM8SOzlVCNfIkMaggv2Bc4awhlLI4wYkPN6DIbwAfmcPwYVDCeR6CngIOC5TsCfHo0aNapce+211YujXozixDl2nGUz9vFa2UYnTZzjPITdsCFbHA/7IWoEIMzxXR712YaQx3+2wiadx76BhiVpicSSAJ8IGh87MFFi4sRMnqdQZhfxEf/wNjjrOAQ0TooTpOOzeHbQ6OPDHoLLtvKHHxcHUa+y8psVJcDkU4cyAu5Hu6JuW0GbQpDJI7Ax9cqXWH7Bd3raz1+aoPH+kI9rmC239Eo6f41/tAYfj4PAFvCKbybKvWdCp+AbTgbnY8ky/rEjX8WxbEZeg1Kait5JtC6aZmnNokBYeBnKSNJjKI+eOPaYMQyHGk4XEJojd4zE4ZwZgHyESYxGwTbSfL2As3Zeo19Gdccdd/TYzHsurWkfdMfSmsVFOGvCwHIbg1afscNlDpqN4HAMQnEZx9mGgOuOQ/DIqz4Cw7F6DQp0KPLIKy1EiX0djHJsUydz4403Vn/HrUx3IJfWNCeCUz0J/t0sok9V4qUljJ5OhTgWZ3ZbW2JGHi9DODsOXgvSxBPY9kNoh/BhM4K6QF5peC5fTB6pS73apx7x0kF62FPYS/xWYTfKW+pgUB4Qn2gO9NTSmgUhfCsO2lpahoN4QmwT6niErziEo0Cj8Lu+ZsZHqseMvIEAraIuWskAgE3w/+oi7OXju8Xz8TFA6Ank0pqeRcsIeQinjIhm1xGXULEuzKgTiZEdeeOykJmDZRjKMgIjWALFrA+nG3+rHM6bsXDMjEh+QsIyBjNF6u8JpJBvH/SmkJ8f1s17h8QMixdm4/EpwRFCJwQJG2mM1znYhthgR/YNauWPmXo2I8ijE/A5SeJKfi9+ezoQM5vdgRTyzYkQpz0NnLR0wFpfggUPY2kC/uGwPLiJg/w3/mkfjooX7OsDIl5oFPLS2ID65JcP//l8wbnkty9efm2xlSaEXcinLfEbRV1RRr5HHnlkrvgH5RLNgd4W8gE8iYArAh6FqMcd+3gqnjDHV/onjmPZjLJ8N4HOHvDWli+3NdFCC9kS9o1c7G6kkO9ZtJSQbwQym6En5JFWRx+CHpCac0dSBJWH8xSHvIzCKNU2BgEhYsJRK2vWxAuzOg5xPYUU8u2DZSnkowPg8E844YTqcStbISwMVs3uhCBxHDP0IYRwXIhjNhBCnp1IYz86B++GeFLlUbB9dcYAoTuRQr45gWu9BefCYxM4vvqBt7gYggSHw4fb4qB0vhznpZt9jLpAHn1C+Hv1C2xHPQJIkw+/9SXyKytdfnYiTVts5ZdGbLE1+SHaaHKJzcjfiO62m0TXsayEfGfApeAOjtjiHJ7iGFvgmwl6QV5x22yzTbWMxlJLX5wxEemJVixVxmV+nM/G055ECvmeRcsK+QAiB7HN1vi8E4Efa7/C6Tq2H84c4TlSaYjP+XLC8iC1R1PEiS/S6Ch6Gink2wfLUsg3gujZZ599KmfthSoC6KSTTqo6BgPbcP6Evzg85+CjgwCiQ3lb8fa96O2bwh7N6gR6GinkmxMhiHsb+Mrf8/Ph60F7QnTz69G1Edvi+HU8V17e4L0ykVe8/gDEB6Q71j8I9pVlE6B+8eK0x/+MmBm96aabqtlO0L8QUvodeedHtCGx7NFMQh7wSgibs23cJ9xjUibEPd570ZXPxkHvTLEBXI2ZeJzsDaSQ71m0vJBvBKJzzmbp/XGOEE7eZZqBDAcqH4R4R2ojVW+LE+9mGkPo9wZSyLcPmkXIc/B4jsM4TnSceOKJ1T/+ec+EPcRMD+ceAkicYJ/zZwtePNQhWEITayt7CynkmxMhJJYVnJ/PJ1xC2HuBL4Q4sWLWkegW9AX6BANYfl6csvHRg3jyFKJcCMEO8uovQoizj+gfHLM1Akp9+hDiSZ2RpzF/Z1hYWqJ30WxCvhHBe0LdNniFf3y8YIImeAziQsALBD1u9xZSyPcs2krINwKpOW4zjxw75+0LNkQ+Q/BlDWKEeOecbc06WkKD5L3tVFPItw+aRch3Bu+D9O/fv5qd33zzzatZQ1wneOLPowgR4t3sIQHP8YedLAukkG9OLGshPz+0J9rE/4cQDxAzeEQA8fOEjXz4zg7E27dVDzFE4OsXHLMNEz76DTbBbiJIV06wZNMTXTa1JOjtPiexYDSzkG8EfsbEi0DY430McHHWvgGqgWVvPEHtDCnkexZdFvK+THHGGWfUj5ofSB1kb3S+Zlc4eyFGr8sCRxxxRPnmN79ZP0q0MgYOHDj3m8DNCDPxREps2QHuEyiEDHFjIEKINIO48Gk2f+SWaC74M5t2AjsgjAS8ZweEObswCAiRJC36je6El8QTzYEjjzyyWlrbKsDVeDKFn7iKuzH4NLjszRn4+TFu3Lhq4ijRM+iykE8kEolEIpFIJBLLDnMW/yUSiUQikUgkEomWQgr5RCKRSCQSiUSiBZFCPpFIJBKJRCKRaEGkkE8kEolEIpFIJFoQKeQTiUQikUgkEokWRAr5RCKRSCQSiUSiBZFCPpFIJBKJRCKRaEGkkE8kEolEIpFIJFoQKeQTiUQikUgkEokWRAr5RCKRSCQSiUSiBbFCrQP1/baCyxp86OAybfr0stFGG9VjSxl8+GHl2GOPLacMP6XMmPFcuWHcz+opneOLRxxZHn/88fLrO+8o66yzTj22lNNP+0Z5+n+fLj8bd3158cUXy5Cjji5rrLFGlbbCCqVsssmm5Ywz/r2st/56VVwi0Qq4+667y9lnn1Ptv/baa+Xll14uW2/dt6yw4opl7bXXLhdf8uPy5ptvlstHX15GXza6DBs+rAw/ZXiVP5FoRRw95OgOTr9V7T869dGywYYblHXXXbc6HjToC+W4444rUx56qPzwwh+WSRMnlV/fdUfZcsstq/SugF1d9MOLyiOPPFJmz36vdHQX5e86+o4fX/yjqq85+qihZbvtt5uTuY6bf3FTfS+R6D388pe3VLyHV155pbz+2uvl430/3qFxVigf+ciG5Uc//lG5+qqry6233lb1C+/MmlX6DxhQvvMfZ1ZlEr0EQr4d8f7779cO/cKhta9/7bR6zLwYPmx4bVBH+sLwwgsv1A743AG1wwcfXps4cVI9dg5O+/rptUGHHFqdZ8aMGbWNPrJxPaVWmzVrVlV/x0CiSk8kWhE//clPa9t/cvvan/70p3rMHIwYcUFt5Mjv1/r22bo28oKR9dhEovWx6cab1S6++JL60RzMnj27tv9++9cmT55c+flp06bVU5YcHQPj2uc/9/naKcNPqc2cObMeW6t1iPtqe+edd87TlyQSzYILf3Bhbfdd96i999579Zg5uH7s9bUXX3yx2rcd0H9A7cr/vrI6TvQOcmnNQnDN1deUrbfeuhx40IHlijFj6rGLhpn5YcOHl/vv/201+5JItBOGDTu5DB8+rKy4YrqPRPtj1VVXLRNunlD69etXj+k6zjrr7OoJ8fkjzq+ecAXWWmut+l4i0Vo49LBDywYbbFDt2x500EFlxPkXVMeJ3kH2xAvAX/7yl+qx0oBPDyj77LNPmfzA/5Tnn3+hnrpoPP7YY2XbT25bPvzhD9djEon2wAc+8IH63ryYOfO18rEt+5RZs2ZVx3/+859Lv0/tVC688MLqGMaNG1ctZUgkWgkrr7xyfW9eXD/2Z2WH7Xas+gt49dVXy1ZbfKxMmTKlOoZ/PO6fyqhRo6r9SZMmla/8y1dyEJxoG1hm04hZs94pO++yU3n1lVdLn60+Xt55550q/r333iuf2vHvy2WXXlYdw7XXXleOPfa4+lGiq2h7b3L77beXIUcNmRuee+65esrC8dZbb3UQ8ZWy2267VWvjzZ7cc/fd9dTOcdutt1XhkktGlZEXjCznnXduWWmlleqpiUR7Y5111i57dQx877rrrur4icefqET/1VddU2bPnl3ef//9MubyK8p+++1XpScSrY6ddu5X9RUvv/xydXzNNdeWXXfbtdw0Yc6adrx/7NHHyuDBg8uMGTPKG6+/UbbffvsqbWFo7LMuGJGzm4nWwBtvvFFuveXWarC67nrrll123bncd999VdrDDz9cVl9t9Y5B7aWVqP/rX/9aRnVopQMHDqzSE11H2wv5vffeu1x19VVzwyabbFJPWTjMxu//+c9VIn6VVVYpx/zDl8qdd84RKAvCxIkTq/Dd73y3fGbvz5RPbPOJekoisXxg5513nvty1K9+NbGc8M/Hl9r7tTJ9+vQOJ/9mefrpp8see+5RpScSrY4NN9ywGqw+9eRTlTgZOWJkOeHE4yvxDkRM3637VktniPrFRWOfdepXT63HJhLNjW/927cq3bPttttWxzvssEO5tEO4w803/aLqD2a/+241qPX0atrvpnUMhneq0hNdRz7f6wSWBIw4b0R5vMMZDx0ytAp3/fqucsftd8xdNtAZzj3v3CpMfvCBDvJeViZPnlxPSSSWD/Qf0L88+8yMapbSDMzBBx1cDj9icJk06fbywvPPV2soN99883ruRKK1YZLn9G+cVh54YHJ59tlnqyewu+y8S1mxQ9zPnDmzXHH5FWXP+sB1q622qmYpH3ro4eo4kWgXeNr6/ZHfr55MnT/ivHpsKfvut2/5/fRnquU1TzzxRBk48MDyxaO+WO65595qcmeLLbYoH/3oR+u5E11FCvlOMG3atIp4l11+Wbny6ivnhk0327TcfPMv6rkWjPXXX78cf+Lx5efjf16PSSSWDxDpH/zgGuXJJ56sZirXWXedDiF/RHl06tRy3/33l5OHnZTLzRJthUGHDipTpjxY7r3nN+V7Z3+vrLLqKmW33XYt428cX6b//vdl7332rvKxhz333LP84D9/UC0rSCTaBWPHjq3Wu5919lllzTXXrMeW0qdPn7LSyiuV3z39u7L22mtVYejQL5UpDz5YHvjt5HLaN76+wHeuEouP5VrIc6az3p41T6jVauWeu+8pH/rQh8p66837DXhOeMzlY6rR56Kw7777lp/+5L8WK28i0S5YbbXVylFDjiqXjxlT9uw/ZyZy4403Kq+88mp5aMqUXB+faDt4f+qPf3y7/PaB+8vgwYdVcZ5MnXP2uWWzzTad55vz3z7zjA4B80A55kvHlGeeeabqc95+++3y1FNPzdNXzN8vZT+SaFZM+PmEcu7Z55Xx428s66+3/hzOzpqjpVZfffVy0MEHlctGjy57fXqvKv+mm25Spk2b3sH5J7M/6CYs10J+6iNTy5579J8nIKA/N/j2d874my8LHDDwgPLSiy/NfQt7YejT52NlrY7R59SpU+sxicTygcOPOLxMvG1i9X5KwJrJ6R3Om2NPJNoN2233yfL6a2/Uj0rp27dveffdd8uBBx5Yj5kDs5W/uf/eyjZOPunkqs8Z0H+vctVVV8/zqeL5+6U//OEP9ZREornwr1/9WvWS62f3238uXz+772erOBg0aFC5ecLNZffd///dKDP1L730cn69qZvQtv/smkgkEolEIpFItDNyOJRIJBKJRCKRSLQgUsgnEolEIpFIJBItiBTyiUQikUgkEolECyKFfCKRSCQSiUQi0YJIIZ9IJBKJRCKRSLQgUsgnEolEIpFIJBItiBTyiUQikUgkEolECyKFfCKRSCQSiUQi0YJIIZ9IJBKJRCKRSLQgUsgnEolEIpFIJBItiBTyiUQikUgkEolECyKFfCKRSCQSiUQi0YJIIZ9IJBKJRCKRSLQgUsgnEolEIpFIJBItiBTyiUQikUgkEolECyKFfCKRSCQSiUQi0YJIIZ9IJBKJRCKRSLQgUsgnEolEIpFIJBIth1L+D5w802y1X4gDAAAAAElFTkSuQmCC"}}},{"cell_type":"markdown","source":"We are using a stratified cross-validation approach to split the dataset into k-folds and assigns the index of the fold to the 'fold' column of each validation split and we group the dataframe by 'fold' and 'MGMT_value'","metadata":{}},{"cell_type":"code","source":"skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n\nfor index, (train_index, val_index) in enumerate(skf.split(X=train_data.index, \n                                                           y=train_data.MGMT_value)):\n    train_data.loc[val_index, 'fold'] = index\n    \nprint(train_data.groupby(['fold', train_data.MGMT_value]).size())","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:31.743445Z","iopub.execute_input":"2023-01-15T17:35:31.744059Z","iopub.status.idle":"2023-01-15T17:35:31.763715Z","shell.execute_reply.started":"2023-01-15T17:35:31.744022Z","shell.execute_reply":"2023-01-15T17:35:31.762850Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We are defining a custom data generator for loading and preprocessing our dataset. The generator is a sub-class of the tf.keras.utils.Sequence class, which is a convenient way to create custom data generators for use with TensorFlow's fit_generator function.\n\nThe generator is designed to load images from a specified directory (dicom_path) and read their pixel data using the pydicom.read_file() function.\n\nThe generator loads 15 slices of each image, where each slice is taken from 3 intervals between the start and end indices of the image. The image is then read and resized to 512x512, and the resulting array is appended to the channel list.\n\nThe generator has two additional methods, one to slice images, and the other to remove black borders.\n\nThe __len__() method returns the number of data points, which is the number of rows in the dataframe\nThe __getitem__() method is called for each index and returns the features and labels of the image with this specific index.\n\nThe read_dicom_xray() method is the same function read_dicom we defnied earlier.\n\nIn addition, this code defines some parameters at the top of the script, such as input_height, input_width, input_depth, batch_size, and fold which are used to configure the data generator and the training process.","metadata":{}},{"cell_type":"code","source":"# params \nAUTO = tf.data.AUTOTUNE\ninput_height = 312\ninput_width = 312\ninput_depth = 4\nbatch_size = 3\nfold = 0\n\n# data loader \nclass BrainTumorGenerator(tf.keras.utils.Sequence):\n    def __init__(self, dicom_path, data, is_train=True):\n        self.is_train = is_train # to control training/validation/inference part         \n        self.data = data\n        self.dicom_path = dicom_path\n        self.label = self.data['MGMT_value']\n  \n    def __len__(self):\n        return self.data['BraTS21ID'].shape[0]\n    \n    def __getitem__(self, index):\n        patient_ids = f\"{self.dicom_path}/{str(self.data['BraTS21ID'][index]).zfill(5)}/\"\n   \n        channel = []\n        for t in (\"FLAIR\", \"T1w\", \"T1wCE\", \"T2w\"): \n            t_paths = sorted(\n                glob.glob(os.path.join(patient_ids, t, \"*\")), \n                key=lambda x: int(x[:-4].split(\"-\")[-1]),\n            )\n            \n            # pick 15 slices \n            K = 15\n            # computing strt, and end index \n            strt_idx = (len(t_paths) // 2) - (K // 2)\n            end_idx = (len(t_paths) // 2) + (K // 2)\n            # slicing extracting elements with 3 intervals \n            r = t_paths[strt_idx + 3: end_idx + 3: 3]\n    \n            # removing black borders \n            # and add multi-modal features maps / channel depth\n            threshold = 0\n            for i in r:\n                image = self.read_dicom_xray(i)\n                temp_image = image\n                \n                rows = np.where(np.max(temp_image, 0) > threshold)[0]\n                if rows.size:\n                    cols = np.where(np.max(temp_image, 1) > threshold)[0]\n                    image = image[cols[0]: cols[-1] + 1, rows[0]: rows[-1] + 1]\n                else:\n                    image = image[:1, :1]\n                \n                channel.append(cv2.resize(image, (input_height, input_width)))\n                break # remove it for r-times frames for each series\n                    \n        if self.is_train:\n            return np.array(channel).T, self.label.iloc[index,]\n        else:\n            return np.array(channel).T\n    \n    # this is the same function load_dicom(path) explained in the Read Dicom Files chapter \n    def read_dicom_xray(self, path):\n        data = pydicom.read_file(path).pixel_array\n        data = data - np.min(data)\n        data = data / np.max(data)\n        data = (data * 255).astype(np.uint8)\n        return data","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:31.765265Z","iopub.execute_input":"2023-01-15T17:35:31.765597Z","iopub.status.idle":"2023-01-15T17:35:32.702717Z","shell.execute_reply.started":"2023-01-15T17:35:31.765563Z","shell.execute_reply":"2023-01-15T17:35:32.701707Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"This code defines a function called fold_generator(fold) which takes one argument, fold. The function's purpose is to generate the training and validation data for a given fold of the data.\n\nThe first thing the function does is to split the data into two dataframes: train_labels and val_labels using the df dataframe. The train_labels dataframe contains the rows where the \"fold\" column is not equal to the input fold, while the val_labels dataframe contains the rows where the \"fold\" column is equal to the input fold.\n\nOnce the data is splitted into the two dataframes, the function creates two instances of the BrainTumorGenerator class. The first instance is created with the train_labels dataframe and the path train_sample_path, and it's used as the training data generator. The second instance is created with the val_labels dataframe and the path train_sample_path, and it's used as the validation data generator.\n\nFinally, the function returns a tuple that contains both the training generator and the validation generator.\n\nSo this function is used to generate two generators, one for the train set and the other for the validation set. It takes the fold number and use the data from the dataframe to select the training and validation sets.\n\nIt is using the indexes of the training and validation set to select which elements of the df dataframe should be used for each generator. The data is loaded using the BrainTumorGenerator class that was defined earlier, which takes care of loading the data, preprocessing it and returning it in a format ready for training","metadata":{}},{"cell_type":"code","source":"def fold_generator(fold):\n    # for way one - data generator\n    train_labels = train_data[train_data.fold != fold].reset_index(drop=True)\n    val_labels = train_data[train_data.fold == fold].reset_index(drop=True)\n    \n    return (\n        BrainTumorGenerator(train_sample_path, train_labels),\n        BrainTumorGenerator(train_sample_path, val_labels)\n    )\n\n# first fold \ntrain_gen, val_gen = fold_generator(fold)","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:32.707378Z","iopub.execute_input":"2023-01-15T17:35:32.709730Z","iopub.status.idle":"2023-01-15T17:35:32.720971Z","shell.execute_reply.started":"2023-01-15T17:35:32.709690Z","shell.execute_reply":"2023-01-15T17:35:32.719571Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Preprocessing","metadata":{}},{"cell_type":"markdown","source":"### What is tensorflow addons ? \nTensorFlow Addons is a collection of community-contributed extensions for TensorFlow, which are not part of the official TensorFlow distribution but are useful for specific tasks. These addons provide additional functionality such as new layers, loss functions, metrics, and more. They are built on top of the TensorFlow library, and are designed to be easy to use and integrate with existing TensorFlow code.\n\nSome examples of functionality provided by TensorFlow Addons include:\n\n* RAdam optimizer\n* Mish activation function\n* SpectralNormalization layer\n* LAMB optimizer\n* Lookahead optimizer\n* Self-Attention layer\n* Sparsemax activation function\n* etc.\nTensorFlow Addons are not officially supported by TensorFlow, but they are maintained by the community and are considered to be of high quality. They are available on Github, and can be installed using pip.\n\nIt's worth noting that not all the functionality provided in TensorFlow Addons are in the official TensorFlow releases or the API's are not stable, and the API can change in future releases. \n\nFor more infos you can check this [link](https://www.tensorflow.org/addons/api_docs/python/tfa)","metadata":{}},{"cell_type":"code","source":"# augmentations for train set\nimport tensorflow_addons as tfa\nfrom tensorflow.keras.layers.experimental.preprocessing import (RandomFlip,\n                                                                RandomRotation, \n                                                                RandomTranslation)\n\n#  keras augmentation layers \naugmentation_layers = tf.keras.Sequential(\n    [\n        RandomRotation(factor=0.01),\n        RandomTranslation(height_factor=0.0, width_factor=0.1),\n    ],\n    name='keras_augment_layers'\n)\n\n\n# manual preprocessing with more augmentation \ndef preprocessing_image(img, augment=True):   \n    img = tf.cast(img, tf.float32) / 255.0\n\n    # only true for train set \n    if augment:\n        # augment each slices \n        splitted_img = tf.split(img, input_depth, axis=-1)\n\n        augment_img = []\n        for each_img in splitted_img:\n            img = tf.repeat(each_img, repeats=3, axis=-1)\n            img = tf.image.random_flip_left_right(img)\n            img = tf.image.random_saturation(img, 0.9, 1.3)\n            img = tf.image.random_contrast(img, 0.8, 1.2)\n            img = tf.image.random_brightness(img, 0.2)\n            img, _, _ = tf.split(img, 3, axis=-1)\n            img = tfa.image.random_cutout(tf.expand_dims(img, 0),\n                                          mask_size=(20, 20), \n                                          constant_values=0)\n            augment_img.append(img)\n            \n        img = tf.concat(augment_img, axis=-1)\n    img = tf.reshape(img, [input_height, input_width, input_depth])\n    return img","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:32.728106Z","iopub.execute_input":"2023-01-15T17:35:32.730955Z","iopub.status.idle":"2023-01-15T17:35:36.657819Z","shell.execute_reply.started":"2023-01-15T17:35:32.730920Z","shell.execute_reply":"2023-01-15T17:35:36.656055Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Data generator ","metadata":{}},{"cell_type":"markdown","source":"The **get_data_generator** function that takes in a data argument (which is TensorFlow dataset [ created earlier ]), along with several other parameters. This function is used for creating a generator for the input data, which is used for training or testing a model. The generator will be used to provide the model with a stream of data in the form of batches.\n\nThe function first checks whether the repeat parameter is set to True, if yes it will repeat the dataset.\n\nThen it will check whether the shuffle parameter is set to True, if yes it will shuffle the dataset with a buffer size of batch_size * 10.\n\nThen it applies a map function on the dataset, it applies preprocessing_image function on the data and labels.\n\nThen the data is batched with a batch_size, and drop_remainder=is_train, which means if is_train is true, it will drop the remaining samples if they don't fit in the last batch.\n\nThen it will check whether the shuffle parameter is set to True, if yes it will apply a map function on the dataset, it applies augmentation_layers function on the data and labels.\n\nThen it will check whether the modeling_in parameter is set to 3D or 2D: \n* If it's 3D it will map a function on the dataset, which adds an extra dimension to the data, so the last dimension will be 1. And it will prefetch the dataset for AUTO. \n* If it's 2D it will only prefetch the dataset for AUTO. \n* Else it will raise an error message that \"volume is not set either 2D or 3D\"\n\nFinally, the function returns the modified dataset, which can be used as an input data generator for a TensorFlow model. \n\n**Note** : prefetch explained (source chatGPT) : \n\ntf.data.Dataset.prefetch() is a method available in TensorFlow's tf.data API, which is used to asynchronously prefetch elements from the input dataset. When the prefetch transformation is called on a dataset, it will start loading the next element from the dataset in the background while the current element is being processed. This can improve performance by reducing the time spent waiting for data to be loaded, especially when the time to load the data is significant compared to the time to process it.\n\nThe prefetch() method takes an argument, which is the number of elements to prefetch. In this case, the argument passed is AUTO which means the prefetch buffer will be filled with enough elements to keep the accelerator busy, but will not necessarily be filled to capacity.","metadata":{}},{"cell_type":"code","source":"def get_data_generator(data, is_train=False, modeling_in='3D',\n                       shuffle=True, augment=False, \n                       repeat=True, batch_size=32):\n    if repeat: \n        data = data.repeat()\n    \n    if shuffle:\n        data = data.shuffle(batch_size * 10)\n        \n    data = data.map(lambda x, y: (preprocessing_image(x, augment), y),\n                    num_parallel_calls=AUTO)\n    data = data.batch(batch_size, drop_remainder=is_train)\n    \n    if shuffle:\n        data = data.map(lambda x, y: (augmentation_layers(x), y), \n                        num_parallel_calls=AUTO) \n    \n    if modeling_in == '3D':\n        data = data.map(lambda x, y: (tf.expand_dims(x, axis=-1), y),\n                        num_parallel_calls=AUTO)\n        data = data.prefetch(AUTO)\n        return data \n    elif modeling_in == '2D':\n        data = data.prefetch(AUTO)\n        return data \n    else:\n        raise ValueError('volume is not set either 2D or 3D')","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:36.659426Z","iopub.execute_input":"2023-01-15T17:35:36.659804Z","iopub.status.idle":"2023-01-15T17:35:36.668387Z","shell.execute_reply.started":"2023-01-15T17:35:36.659766Z","shell.execute_reply":"2023-01-15T17:35:36.667079Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Train Set (2D)","metadata":{}},{"cell_type":"code","source":"train_gen.data.shape","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:36.670625Z","iopub.execute_input":"2023-01-15T17:35:36.671032Z","iopub.status.idle":"2023-01-15T17:35:36.685396Z","shell.execute_reply.started":"2023-01-15T17:35:36.670995Z","shell.execute_reply":"2023-01-15T17:35:36.684204Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# wrapping sequence generator to tf.data API \ntrain_data = tf.data.Dataset.from_generator(\n    lambda: map(tuple, train_gen),\n    (tf.float32, tf.float32),\n    (\n        tf.TensorShape([input_height, input_width, input_depth]),\n        tf.TensorShape([]),\n    ),\n)\n\n# generate train sets \ntrain_generator = get_data_generator(train_data, \n                                     is_train=True, repeat=False, \n                                     shuffle=True, modeling_in='2D', \n                                     augment=True, batch_size=batch_size)\n\n\n# visualization \nx, y = next(iter(train_generator))\nprint(x.shape, y.shape)  \nplt.figure(figsize=(35, 15))\nfor i in range(input_depth):\n    plt.subplot(1, input_depth, i + 1)\n    plt.imshow(x[1 ,:, :, i], cmap=\"gray\")\n    plt.axis(\"off\")\n    plt.title(y[1].numpy())","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:36.686728Z","iopub.execute_input":"2023-01-15T17:35:36.687191Z","iopub.status.idle":"2023-01-15T17:35:54.407261Z","shell.execute_reply.started":"2023-01-15T17:35:36.687157Z","shell.execute_reply":"2023-01-15T17:35:54.406250Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_generator","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:54.418169Z","iopub.execute_input":"2023-01-15T17:35:54.420029Z","iopub.status.idle":"2023-01-15T17:35:54.431992Z","shell.execute_reply.started":"2023-01-15T17:35:54.419991Z","shell.execute_reply":"2023-01-15T17:35:54.430745Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Validation Set (2D)","metadata":{}},{"cell_type":"code","source":"# wrapping sequence generator to tf.data API \nval_data = tf.data.Dataset.from_generator(\n    lambda: map(tuple, val_gen),\n    (tf.float32, tf.float32),\n    (\n        tf.TensorShape([input_height, input_width, input_depth]),\n        tf.TensorShape([]),\n    ),\n)\n\n# generate validation sets \nvalid_generator = get_data_generator(val_data, is_train=True, \n                                     shuffle=False, repeat=False,\n                                     modeling_in='2D', augment=False, \n                                     batch_size=batch_size)\n\n# visualization \nx, y = next(iter(valid_generator))\nprint(x.shape, y.shape)  \nplt.figure(figsize=(35, 15))\nfor i in range(input_depth):\n    plt.subplot(1, input_depth, i + 1)\n    plt.imshow(x[0 ,:, :, i], cmap=\"gray\")\n    plt.axis(\"off\")\n    plt.title(y[0].numpy())","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:54.434574Z","iopub.execute_input":"2023-01-15T17:35:54.436078Z","iopub.status.idle":"2023-01-15T17:35:56.752628Z","shell.execute_reply.started":"2023-01-15T17:35:54.435696Z","shell.execute_reply":"2023-01-15T17:35:56.751719Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Pre-trained model for 2D dataset","metadata":{}},{"cell_type":"code","source":"from tensorflow.keras import Input, Model \nfrom tensorflow.keras.layers import Conv2D, GlobalAveragePooling2D, Dense\nfrom tensorflow.keras.applications import *\n\npre_wg = '../input/keras-pretrained-imagenet-weights/densenet121_imagenet_1000_no_top.h5'\n\ninput_dim = (input_height, input_width, input_depth)\ninput_tensor = Input(input_dim, name='input2d')\nefnet = DenseNet121(weights=pre_wg, \n                       include_top = False, \n                       input_shape=(input_height, input_width, 3))\nmapping3feat = Conv2D(3, (3, 3), padding='same', use_bias=False)(input_tensor)\n\noutput = efnet(mapping3feat)\noutput = GlobalAveragePooling2D()(output)\noutput = Dense(1, activation='sigmoid')(output)\n\ntf.keras.backend.clear_session()\nmodel = Model(input_tensor, output)\nmodel.summary()","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:35:56.754210Z","iopub.execute_input":"2023-01-15T17:35:56.754810Z","iopub.status.idle":"2023-01-15T17:36:00.913960Z","shell.execute_reply.started":"2023-01-15T17:35:56.754773Z","shell.execute_reply":"2023-01-15T17:36:00.912880Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from tensorflow import keras \nfrom tensorflow.keras.optimizers import Adam, SGD, RMSprop\nfrom tensorflow_addons.optimizers import RectifiedAdam, Lookahead\n\n# compiling \nmodel.compile(\n    loss=tf.keras.losses.BinaryCrossentropy(from_logits=False),\n    optimizer=Adam(learning_rate=1e-3),\n    metrics=[tf.keras.metrics.AUC(), \n             tf.keras.metrics.BinaryAccuracy(name='bacc')],\n)\n\n# define callbacks.\ncheckpoint_cb = keras.callbacks.ModelCheckpoint(\n    \"model.h5\", monitor='val_auc', \n    mode='max', save_best_only=True\n)\n\n\n# fitting the model \nepochs = 5\nmodel.fit(\n    train_generator, \n    epochs=epochs,\n    validation_data=valid_generator, \n    callbacks=[checkpoint_cb]  \n)","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:36:00.915358Z","iopub.execute_input":"2023-01-15T17:36:00.915933Z","iopub.status.idle":"2023-01-15T17:43:10.318320Z","shell.execute_reply.started":"2023-01-15T17:36:00.915896Z","shell.execute_reply":"2023-01-15T17:43:10.317232Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### InceptionV3 architechture with imagenet weights","metadata":{}},{"cell_type":"markdown","source":"# Train set (3D)","metadata":{}},{"cell_type":"code","source":"# wrapping sequence generator to tf.data API \ntrain_data = tf.data.Dataset.from_generator(\n    lambda: map(tuple, train_gen),\n    (tf.float32, tf.float32),\n    (\n        tf.TensorShape([input_height, input_width, input_depth]),\n        tf.TensorShape([]),\n    ),\n)\n\n# generate train sets \ntrain_generator = get_data_generator(train_data, \n                                     is_train=True, repeat=False, \n                                     shuffle=True, modeling_in='3D', \n                                     augment=True, batch_size=batch_size)\n\n\n# visualization \nx, y = next(iter(train_generator))\nprint(x.shape, y.shape)  \nplt.figure(figsize=(35, 15))\nfor i in range(input_depth):\n    plt.subplot(1, input_depth, i + 1)\n    plt.imshow(x[1 ,:, :, i], cmap=\"gray\")\n    plt.axis(\"off\")\n    plt.title(y[1].numpy())","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:44:28.234960Z","iopub.execute_input":"2023-01-15T17:44:28.235377Z","iopub.status.idle":"2023-01-15T17:44:31.324203Z","shell.execute_reply.started":"2023-01-15T17:44:28.235343Z","shell.execute_reply":"2023-01-15T17:44:31.322934Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Validation set (3D)","metadata":{}},{"cell_type":"code","source":"# wrapping sequence generator to tf.data API \nval_data = tf.data.Dataset.from_generator(\n    lambda: map(tuple, val_gen),\n    (tf.float32, tf.float32),\n    (\n        tf.TensorShape([input_height, input_width, input_depth]),\n        tf.TensorShape([]),\n    ),\n)\n\n# generate validation sets \nvalid_generator = get_data_generator(val_data, is_train=True, \n                                     shuffle=False, repeat=False,\n                                     modeling_in='3D', augment=False, \n                                     batch_size=batch_size)\n\n\n# visualization \nx, y = next(iter(valid_generator))\nprint(x.shape, y.shape)  \nplt.figure(figsize=(35, 15))\nfor i in range(input_depth):\n    plt.subplot(1, input_depth, i + 1)\n    plt.imshow(x[0 ,:, :, i], cmap=\"gray\")\n    plt.axis(\"off\")\n    plt.title(y[0].numpy())","metadata":{"execution":{"iopub.status.busy":"2023-01-15T17:44:31.326472Z","iopub.execute_input":"2023-01-15T17:44:31.326974Z","iopub.status.idle":"2023-01-15T17:44:32.227191Z","shell.execute_reply.started":"2023-01-15T17:44:31.326938Z","shell.execute_reply":"2023-01-15T17:44:32.226267Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"**Note**\nTraining on the 3D dataset will come on the next update.","metadata":{}},{"cell_type":"markdown","source":"### VGG66 architecture with weights of imagenet","metadata":{}}]}