diff --git a/seminar4/GroupAnalysis.ipynb b/seminar4/GroupAnalysis.ipynb new file mode 100644 index 0000000..4a2daf9 --- /dev/null +++ b/seminar4/GroupAnalysis.ipynb @@ -0,0 +1,1650 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Group Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We often want to generalize the results from our experiment to out of sample data. Here we will infer from the individual \n", + "subjects activation maps to one activation map for all subjects.\n", + "\n", + "To do this the following steps must be done:\n", + "\n", + "**1. Normalize the subjects data to a common space**\n", + "\n", + "**2. Build a second level GLM**\n", + "\n", + "**3. Hypothesis testing**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Group Analysis](https://s3.studylib.net/store/data/008208763_1-08a21265815c4e2c11a8b6effd90bfa3.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second level GLM has the form\n", + "$$ {\\beta}= {\\beta}_g X_g + {\\eta} $$\n", + "\n", + "where:\n", + "\n", + "$X_g$ - new design matrix\n", + "\n", + "${\\beta}$ - estimated from 1st level\n", + "\n", + "\n", + "Then we can find ${\\beta}_g$ and perform hypothesis testing on it\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Normalize data to MNI template\n", + "\n", + "\n", + "We will take the computed 1st-level contrasts from the previous experiment and normalize them into MNI-space. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preparation\n", + "\n", + "We first need to download the already computed deformation field. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "action summary:\n", + " get (notneeded: 8)\n" + ] + } + ], + "source": [ + "%%bash\n", + "datalad get -J 4 -d /data/ds000114 /data/ds000114/derivatives/fmriprep/sub-0[2345789]/anat/*h5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Alternatively: Prepare yourself\n", + "We're using the precomputed warp field from [fmriprep](http://fmriprep.readthedocs.io), as this step otherwise would take up too much time. If you're nonetheless interested in computing the warp parameters with ANTs yourself, without using [fmriprep](http://fmriprep.readthedocs.io), either check out the script [ANTS_registration.py](https://github.com/miykael/nipype_tutorial/blob/master/notebooks/scripts/ANTS_registration.py) or even quicker, use [RegistrationSynQuick](http://nipype.readthedocs.io/en/latest/interfaces/generated/interfaces.ants/registration.html#registrationsynquick), Nipype's implementation of `antsRegistrationSynQuick.sh`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Normalization with ANTs\n", + "\n", + "The normalization with ANTs requires that you first compute the transformation matrix that would bring the anatomical images of each subject into template space. Depending on your system this might take a few hours per subject. To facilitate this step, the transformation matrix is already computed for the T1 images.\n", + "\n", + "The data for it can be found under:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-02/anat/sub-02_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-03/anat/sub-03_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-04/anat/sub-04_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-05/anat/sub-05_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-06/anat/sub-06_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-07/anat/sub-07_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-08/anat/sub-08_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-09/anat/sub-09_t1w_space-mni152nlin2009casym_warp.h5\r\n", + "/data/ds000114/derivatives/fmriprep/sub-10/anat/sub-10_t1w_space-mni152nlin2009casym_warp.h5\r\n" + ] + } + ], + "source": [ + "!ls /data/ds000114/derivatives/fmriprep/sub-*/anat/*h5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Now, let's start with the ANTs normalization workflow!**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "First, we need to import all the modules we later want to use." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:53:34,705 nipype.utils WARNING:\n", + "\t A newer version (1.5.1) of nipy/nipype is available. You are using 1.5.0-rc1.post-dev\n" + ] + } + ], + "source": [ + "from os.path import join as opj\n", + "from nipype import Workflow, Node, MapNode\n", + "from nipype.interfaces.ants import ApplyTransforms\n", + "from nipype.interfaces.utility import IdentityInterface\n", + "from nipype.interfaces.io import SelectFiles, DataSink\n", + "from nipype.interfaces.fsl import Info\n", + "\n", + "\n", + "from nilearn import plotting\n", + "%matplotlib inline\n", + "from nipype.interfaces.spm import (OneSampleTTestDesign, EstimateModel,\n", + " EstimateContrast, Threshold)\n", + "\n", + "from nipype.algorithms.misc import Gunzip" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experiment parameters\n", + "\n", + " We will run the group analysis without subject ``sub-01``, ``sub-06`` and ``sub-10`` because they are left-handed.\n", + "\n", + "This is because all subjects were asked to use their dominant hand, either right or left. There were three subjects (``sub-01``, ``sub-06`` and ``sub-10``) that were left-handed.\n", + "\n", + "**Because of this, We will use only right-handed subjects for the following anlysis**." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_dir = '/output'\n", + "output_dir = 'datasink'\n", + "working_dir = 'workingdir'\n", + "\n", + "# list of subject identifiers (remember we use only right handed subjects)\n", + "subject_list = ['02', '03', '04', '05', '07', '08', '09']\n", + "\n", + "# task name\n", + "task_name = \"fingerfootlips\"\n", + "number_contrasts = 5 # number of contrast from 1stlevel\n", + "\n", + "\n", + "# Template to normalize to\n", + "template = '/data/ds000114/derivatives/fmriprep/mni_icbm152_nlin_asym_09c/1mm_T1.nii.gz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify Nodes\n", + "\n", + "Initiate ANTs interface" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply Transformation - applies the normalization matrix to contrast images\n", + "apply2con = MapNode(ApplyTransforms(args='--float',\n", + " input_image_type=3,\n", + " interpolation='BSpline',\n", + " invert_transform_flags=[False],\n", + " num_threads=1,\n", + " reference_image=template,\n", + " terminal_output='file'),\n", + " name='apply2con', iterfield=['input_image'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify input & output stream\n", + "\n", + "Specify where the input data can be found & where and how to save the output data." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Infosource - a function free node to iterate over the list of subject names\n", + "infosource = Node(IdentityInterface(fields=['subject_id']),\n", + " name=\"infosource\")\n", + "infosource.iterables = [('subject_id', subject_list)]\n", + "\n", + "# SelectFiles - to grab the data (alternativ to DataGrabber)\n", + "templates = {'con': opj(output_dir, '1stLevel',\n", + " 'sub-{subject_id}/', '???_00??.nii'),\n", + " 'transform': opj('/data/ds000114/derivatives/fmriprep/', 'sub-{subject_id}', 'anat',\n", + " 'sub-{subject_id}_t1w_space-mni152nlin2009casym_warp.h5')}\n", + "selectfiles = Node(SelectFiles(templates,\n", + " base_directory=experiment_dir,\n", + " sort_filelist=True),\n", + " name=\"selectfiles\")\n", + "\n", + "# Datasink - creates output folder for important outputs\n", + "datasink = Node(DataSink(base_directory=experiment_dir,\n", + " container=output_dir),\n", + " name=\"datasink\")\n", + "\n", + "# Use the following DataSink output substitutions\n", + "substitutions = [('_subject_id_', 'sub-')]\n", + "subjFolders = [('_apply2con%s/' % (i), '') for i in range(number_contrasts)] \n", + "substitutions.extend(subjFolders)\n", + "datasink.inputs.substitutions = substitutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify Workflow (ANTs)\n", + "\n", + "Create a workflow and connect the interface nodes and the I/O stream to each other." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Initiation of the ANTs normalization workflow\n", + "antsflow = Workflow(name='antsflow')\n", + "antsflow.base_dir = opj(experiment_dir, working_dir)\n", + "\n", + "# Connect up the ANTs normalization components\n", + "antsflow.connect([(infosource, selectfiles, [('subject_id', 'subject_id')]),\n", + " (selectfiles, apply2con, [('con', 'input_image'),\n", + " ('transform', 'transforms')]),\n", + " (apply2con, datasink, [('output_image', 'norm_ants.@con')]),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize the workflow\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:53:54,546 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/antsflow/graph.png (graph2use=colored, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create ANTs normalization graph\n", + "antsflow.write_graph(graph2use='colored', format='png', simple_form=True)\n", + "\n", + "# Visualize the graph\n", + "from IPython.display import Image\n", + "Image(filename=opj(antsflow.base_dir, 'antsflow', 'graph.png'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the Workflow\n", + "\n", + "Now that everything is ready, we can run the ANTs normalization workflow. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:49:19,858 nipype.workflow INFO:\n", + "\t Workflow antsflow settings: ['check', 'execution', 'logging', 'monitoring']\n", + "200920-23:49:19,881 nipype.workflow INFO:\n", + "\t Running in parallel.\n", + "200920-23:49:19,885 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:19,960 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_09/selectfiles\".\n", + "200920-23:49:19,961 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_08/selectfiles\".200920-23:49:19,962 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_05/selectfiles\".200920-23:49:19,962 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_07/selectfiles\".\n", + "\n", + "\n", + "200920-23:49:19,968 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:49:19,971 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200920-23:49:19,971 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:49:19,971 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "\n", + "200920-23:49:19,978 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".200920-23:49:19,978 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".200920-23:49:19,978 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".\n", + "200920-23:49:19,979 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".\n", + "\n", + "\n", + "200920-23:49:21,887 nipype.workflow INFO:\n", + "\t [Job 0] Completed (antsflow.selectfiles).\n", + "200920-23:49:21,891 nipype.workflow INFO:\n", + "\t [Job 3] Completed (antsflow.selectfiles).\n", + "200920-23:49:21,894 nipype.workflow INFO:\n", + "\t [Job 6] Completed (antsflow.selectfiles).\n", + "200920-23:49:21,897 nipype.workflow INFO:\n", + "\t [Job 9] Completed (antsflow.selectfiles).\n", + "200920-23:49:21,901 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:22,6 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_04/selectfiles\".200920-23:49:22,7 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_03/selectfiles\".\n", + "200920-23:49:22,8 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.selectfiles\" in \"/output/workingdir/antsflow/_subject_id_02/selectfiles\".\n", + "\n", + "200920-23:49:22,12 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:49:22,13 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200920-23:49:22,15 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:49:22,16 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".\n", + "\n", + "200920-23:49:22,23 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".200920-23:49:22,23 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.selectfiles\".\n", + "\n", + "200920-23:49:23,889 nipype.workflow INFO:\n", + "\t [Job 12] Completed (antsflow.selectfiles).\n", + "200920-23:49:23,893 nipype.workflow INFO:\n", + "\t [Job 15] Completed (antsflow.selectfiles).\n", + "200920-23:49:23,896 nipype.workflow INFO:\n", + "\t [Job 18] Completed (antsflow.selectfiles).\n", + "200920-23:49:23,901 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 27 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:23,995 nipype.workflow INFO:\n", + "\t [Job 21] Cached (_apply2con0).\n", + "200920-23:49:23,997 nipype.workflow INFO:\n", + "\t [Job 22] Cached (_apply2con1).\n", + "200920-23:49:24,0 nipype.workflow INFO:\n", + "\t [Job 23] Cached (_apply2con2).\n", + "200920-23:49:24,2 nipype.workflow INFO:\n", + "\t [Job 24] Cached (_apply2con3).\n", + "200920-23:49:25,893 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 38 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:25,970 nipype.workflow INFO:\n", + "\t [Job 25] Cached (_apply2con4).\n", + "200920-23:49:25,973 nipype.workflow INFO:\n", + "\t [Job 26] Cached (_apply2con5).\n", + "200920-23:49:25,975 nipype.workflow INFO:\n", + "\t [Job 27] Cached (_apply2con0).\n", + "200920-23:49:25,978 nipype.workflow INFO:\n", + "\t [Job 28] Cached (_apply2con1).\n", + "200920-23:49:27,895 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 35 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:27,967 nipype.workflow INFO:\n", + "\t [Job 1] Cached (antsflow.apply2con).\n", + "200920-23:49:27,970 nipype.workflow INFO:\n", + "\t [Job 29] Cached (_apply2con2).\n", + "200920-23:49:27,973 nipype.workflow INFO:\n", + "\t [Job 30] Cached (_apply2con3).\n", + "200920-23:49:27,975 nipype.workflow INFO:\n", + "\t [Job 31] Cached (_apply2con4).\n", + "200920-23:49:29,897 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 32 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:29,969 nipype.workflow INFO:\n", + "\t [Job 32] Cached (_apply2con5).\n", + "200920-23:49:29,972 nipype.workflow INFO:\n", + "\t [Job 33] Cached (_apply2con0).\n", + "200920-23:49:29,971 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_09/datasink\".\n", + "200920-23:49:29,975 nipype.workflow INFO:\n", + "\t [Job 34] Cached (_apply2con1).\n", + "200920-23:49:29,980 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:29,983 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_09/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-09/con_0001_trans.nii\n", + "200920-23:49:29,984 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_09/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-09/con_0002_trans.nii\n", + "200920-23:49:29,986 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_09/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-09/con_0003_trans.nii\n", + "200920-23:49:29,988 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_09/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-09/con_0004_trans.nii\n", + "200920-23:49:29,989 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_09/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-09/con_0005_trans.nii\n", + "200920-23:49:29,992 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_09/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-09/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:29,998 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:31,897 nipype.workflow INFO:\n", + "\t [Job 2] Completed (antsflow.datasink).\n", + "200920-23:49:31,901 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 29 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:31,973 nipype.workflow INFO:\n", + "\t [Job 4] Cached (antsflow.apply2con).\n", + "200920-23:49:31,976 nipype.workflow INFO:\n", + "\t [Job 35] Cached (_apply2con2).\n", + "200920-23:49:31,979 nipype.workflow INFO:\n", + "\t [Job 36] Cached (_apply2con3).\n", + "200920-23:49:31,981 nipype.workflow INFO:\n", + "\t [Job 37] Cached (_apply2con4).\n", + "200920-23:49:33,901 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 26 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:33,981 nipype.workflow INFO:\n", + "\t [Job 38] Cached (_apply2con5).\n", + "200920-23:49:33,982 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_08/datasink\".200920-23:49:33,984 nipype.workflow INFO:\n", + "\t [Job 39] Cached (_apply2con0).\n", + "\n", + "200920-23:49:33,988 nipype.workflow INFO:\n", + "\t [Job 40] Cached (_apply2con1).\n", + "200920-23:49:33,988 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:33,990 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_08/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-08/con_0001_trans.nii\n", + "200920-23:49:33,992 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_08/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-08/con_0002_trans.nii\n", + "200920-23:49:33,993 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/norm_ants/_subject_id_08/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-08/con_0003_trans.nii\n", + "200920-23:49:33,995 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_08/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-08/con_0004_trans.nii\n", + "200920-23:49:33,998 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_08/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-08/con_0005_trans.nii\n", + "200920-23:49:34,0 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_08/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-08/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:34,5 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:35,901 nipype.workflow INFO:\n", + "\t [Job 5] Completed (antsflow.datasink).\n", + "200920-23:49:35,906 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 23 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:35,978 nipype.workflow INFO:\n", + "\t [Job 7] Cached (antsflow.apply2con).\n", + "200920-23:49:35,981 nipype.workflow INFO:\n", + "\t [Job 41] Cached (_apply2con2).\n", + "200920-23:49:35,983 nipype.workflow INFO:\n", + "\t [Job 42] Cached (_apply2con3).\n", + "200920-23:49:35,985 nipype.workflow INFO:\n", + "\t [Job 43] Cached (_apply2con4).\n", + "200920-23:49:37,905 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 20 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:37,984 nipype.workflow INFO:\n", + "\t [Job 44] Cached (_apply2con5).\n", + "200920-23:49:37,985 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_07/datasink\".\n", + "200920-23:49:37,988 nipype.workflow INFO:\n", + "\t [Job 45] Cached (_apply2con0).\n", + "200920-23:49:37,991 nipype.workflow INFO:\n", + "\t [Job 46] Cached (_apply2con1).\n", + "200920-23:49:37,995 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:37,998 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_07/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-07/con_0001_trans.nii\n", + "200920-23:49:38,0 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_07/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-07/con_0002_trans.nii\n", + "200920-23:49:38,1 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_07/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-07/con_0003_trans.nii\n", + "200920-23:49:38,3 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_07/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-07/con_0004_trans.nii\n", + "200920-23:49:38,4 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_07/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-07/con_0005_trans.nii\n", + "200920-23:49:38,7 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_07/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-07/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:38,14 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:39,905 nipype.workflow INFO:\n", + "\t [Job 8] Completed (antsflow.datasink).\n", + "200920-23:49:39,910 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 17 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:39,988 nipype.workflow INFO:\n", + "\t [Job 10] Cached (antsflow.apply2con).\n", + "200920-23:49:39,991 nipype.workflow INFO:\n", + "\t [Job 47] Cached (_apply2con2).\n", + "200920-23:49:39,995 nipype.workflow INFO:\n", + "\t [Job 48] Cached (_apply2con3).\n", + "200920-23:49:39,998 nipype.workflow INFO:\n", + "\t [Job 49] Cached (_apply2con4).\n", + "200920-23:49:41,909 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 14 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:41,982 nipype.workflow INFO:\n", + "\t [Job 50] Cached (_apply2con5).\n", + "200920-23:49:41,983 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_05/datasink\".\n", + "200920-23:49:41,988 nipype.workflow INFO:\n", + "\t [Job 51] Cached (_apply2con0).\n", + "200920-23:49:41,991 nipype.workflow INFO:\n", + "\t [Job 52] Cached (_apply2con1).\n", + "200920-23:49:41,993 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:41,998 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_05/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-05/con_0001_trans.nii\n", + "200920-23:49:42,1 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_05/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-05/con_0002_trans.nii\n", + "200920-23:49:42,3 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_05/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-05/con_0003_trans.nii\n", + "200920-23:49:42,6 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_05/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-05/con_0004_trans.nii\n", + "200920-23:49:42,8 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_05/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-05/con_0005_trans.nii\n", + "200920-23:49:42,9 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_05/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-05/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:42,14 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:43,909 nipype.workflow INFO:\n", + "\t [Job 11] Completed (antsflow.datasink).\n", + "200920-23:49:43,914 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 11 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:43,986 nipype.workflow INFO:\n", + "\t [Job 13] Cached (antsflow.apply2con).\n", + "200920-23:49:43,989 nipype.workflow INFO:\n", + "\t [Job 53] Cached (_apply2con2).\n", + "200920-23:49:43,991 nipype.workflow INFO:\n", + "\t [Job 54] Cached (_apply2con3).\n", + "200920-23:49:43,994 nipype.workflow INFO:\n", + "\t [Job 55] Cached (_apply2con4).\n", + "200920-23:49:45,913 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 8 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:45,989 nipype.workflow INFO:\n", + "\t [Job 56] Cached (_apply2con5).\n", + "200920-23:49:45,989 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_04/datasink\".\n", + "200920-23:49:45,994 nipype.workflow INFO:\n", + "\t [Job 57] Cached (_apply2con0).\n", + "200920-23:49:45,998 nipype.workflow INFO:\n", + "\t [Job 58] Cached (_apply2con1).\n", + "200920-23:49:46,2 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:46,5 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_04/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-04/con_0001_trans.nii\n", + "200920-23:49:46,7 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_04/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-04/con_0002_trans.nii\n", + "200920-23:49:46,10 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_04/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-04/con_0003_trans.nii\n", + "200920-23:49:46,12 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_04/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-04/con_0004_trans.nii\n", + "200920-23:49:46,13 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_04/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-04/con_0005_trans.nii\n", + "200920-23:49:46,15 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_04/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-04/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:46,21 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:47,913 nipype.workflow INFO:\n", + "\t [Job 14] Completed (antsflow.datasink).\n", + "200920-23:49:47,918 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:47,992 nipype.workflow INFO:\n", + "\t [Job 16] Cached (antsflow.apply2con).\n", + "200920-23:49:47,995 nipype.workflow INFO:\n", + "\t [Job 59] Cached (_apply2con2).\n", + "200920-23:49:47,998 nipype.workflow INFO:\n", + "\t [Job 60] Cached (_apply2con3).\n", + "200920-23:49:48,2 nipype.workflow INFO:\n", + "\t [Job 61] Cached (_apply2con4).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:49:49,916 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 2 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:49,991 nipype.workflow INFO:\n", + "\t [Job 62] Cached (_apply2con5).\n", + "200920-23:49:49,991 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_03/datasink\".\n", + "200920-23:49:49,996 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:49,999 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_03/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-03/con_0001_trans.nii\n", + "200920-23:49:50,1 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_03/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-03/con_0002_trans.nii\n", + "200920-23:49:50,4 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_03/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-03/con_0003_trans.nii\n", + "200920-23:49:50,5 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_03/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-03/con_0004_trans.nii\n", + "200920-23:49:50,7 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_03/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-03/con_0005_trans.nii\n", + "200920-23:49:50,10 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_03/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-03/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:50,16 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:51,916 nipype.workflow INFO:\n", + "\t [Job 17] Completed (antsflow.datasink).\n", + "200920-23:49:51,919 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:49:51,989 nipype.workflow INFO:\n", + "\t [Job 19] Cached (antsflow.apply2con).\n", + "200920-23:49:53,997 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"antsflow.datasink\" in \"/output/workingdir/antsflow/_subject_id_02/datasink\".\n", + "200920-23:49:54,2 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:49:54,4 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_02/_apply2con0/con_0001_trans.nii -> /output/datasink/norm_ants/sub-02/con_0001_trans.nii\n", + "200920-23:49:54,6 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_02/_apply2con1/con_0002_trans.nii -> /output/datasink/norm_ants/sub-02/con_0002_trans.nii\n", + "200920-23:49:54,8 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_02/_apply2con2/con_0003_trans.nii -> /output/datasink/norm_ants/sub-02/con_0003_trans.nii\n", + "200920-23:49:54,10 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_02/_apply2con3/con_0004_trans.nii -> /output/datasink/norm_ants/sub-02/con_0004_trans.nii\n", + "200920-23:49:54,11 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_02/_apply2con4/con_0005_trans.nii -> /output/datasink/norm_ants/sub-02/con_0005_trans.nii\n", + "200920-23:49:54,13 nipype.interface INFO:\n", + "\t sub: /output/datasink/norm_ants/_subject_id_02/_apply2con5/ess_0006_trans.nii -> /output/datasink/norm_ants/sub-02/_apply2con5/ess_0006_trans.nii\n", + "200920-23:49:54,16 nipype.workflow INFO:\n", + "\t [Node] Finished \"antsflow.datasink\".\n", + "200920-23:49:55,920 nipype.workflow INFO:\n", + "\t [Job 20] Completed (antsflow.datasink).\n", + "200920-23:49:55,923 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 0 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "antsflow.run('MultiProc', plugin_args={'n_procs': 4})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize Results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn.plotting import plot_stat_map\n", + "%matplotlib inline\n", + "subject_id = '02'\n", + "anatimg = '/data/ds000114/derivatives/fmriprep/mni_icbm152_nlin_asym_09c/1mm_T1.nii.gz'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, let's chek the normalization of **anatomical** image:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(\n", + " f'/data/ds000114/derivatives/fmriprep/sub-{subject_id}/anat/sub-{subject_id}_t1w_space-mni152nlin2009casym_preproc.nii.gz',\n", + " title='anatomy - ANTs (normalized to ICBM152)', bg_img=anatimg,\n", + " threshold=200, display_mode='ortho', cut_coords=(-50, 0, -10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And what about the **contrast** images for **Foot > others**?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(\n", + " f'/output/datasink/norm_ants/sub-{subject_id}/con_0005_trans.nii', title='Foot > others - Normed',\n", + " bg_img=anatimg, threshold=2, vmax=5, display_mode='ortho', cut_coords=(-39, -37, 56))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from nilearn.plotting import plot_glass_brain\n", + "plot_glass_brain(\n", + " f'/output/datasink/norm_ants/sub-{subject_id}/con_0005_trans.nii', colorbar=True,\n", + " threshold=3, display_mode='lyrz', black_bg=True, vmax=6, title='contrast5 - ANTs')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2nd level analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After we normalized the subjects data into template space, we can now do the group analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_dir = '/output'\n", + "output_dir = 'datasink'\n", + "working_dir = 'workingdir'\n", + "\n", + "\n", + "# Which contrasts to use for the 2nd-level analysis\n", + "contrast_list = ['con_0001', 'con_0002', 'con_0003', 'con_0004', 'con_0005']\n", + "\n", + "mask = \"/data/ds000114/derivatives/fmriprep/mni_icbm152_nlin_asym_09c/1mm_brainmask.nii.gz\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/output/datasink/2ndLevel\r\n", + "├── con_0001\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "├── con_0002\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "├── con_0003\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "├── con_0004\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "└── con_0005\r\n", + " ├── con_0001.nii\r\n", + " ├── SPM.mat\r\n", + " ├── spmT_0001.nii\r\n", + " └── spmT_0001_thr.nii\r\n", + "\r\n", + "5 directories, 20 files\r\n" + ] + } + ], + "source": [ + "!tree /output/datasink/2ndLevel" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Gunzip - unzip the mask image\n", + "gunzip = Node(Gunzip(in_file=mask), name=\"gunzip\")\n", + "\n", + "# OneSampleTTestDesign - creates one sample T-Test Design\n", + "onesamplettestdes = Node(OneSampleTTestDesign(),\n", + " name=\"onesampttestdes\")\n", + "\n", + "# EstimateModel - estimates the model\n", + "level2estimate = Node(EstimateModel(estimation_method={'Classical': 1}),\n", + " name=\"level2estimate\")\n", + "\n", + "# EstimateContrast - estimates group contrast\n", + "level2conestimate = Node(EstimateContrast(group_contrast=True),\n", + " name=\"level2conestimate\")\n", + "cont1 = ['Group', 'T', ['mean'], [1]]\n", + "level2conestimate.inputs.contrasts = [cont1]\n", + "\n", + "# Threshold - thresholds contrasts, we use fdr correction\n", + "level2thresh = Node(Threshold(contrast_index=1,\n", + " use_topo_fdr=True,\n", + " use_fwe_correction=False,\n", + " extent_threshold=0,\n", + " height_threshold=0.005,\n", + " height_threshold_type='p-value',\n", + " extent_fdr_p_threshold=0.05),\n", + " name=\"level2thresh\")\n", + "\n", + "# Infosource - a function free node to iterate over the list of subject names\n", + "infosource = Node(IdentityInterface(fields=['contrast_id']),\n", + " name=\"infosource\")\n", + "infosource.iterables = [('contrast_id', contrast_list)]\n", + "\n", + "# SelectFiles - to grab the data\n", + "templates = {'cons': opj(output_dir, 'norm_ants', 'sub-*',\n", + " '{contrast_id}_trans.nii')}\n", + "selectfiles = Node(SelectFiles(templates,\n", + " base_directory=experiment_dir,\n", + " sort_filelist=True),\n", + " name=\"selectfiles\")\n", + "# Datasink - creates output folder for important outputs\n", + "datasink = Node(DataSink(base_directory=experiment_dir,\n", + " container=output_dir),\n", + " name=\"datasink\")\n", + "\n", + "# Use the following DataSink output substitutions\n", + "substitutions = [('_contrast_id_', '')]\n", + "datasink.inputs.substitutions = substitutions" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Initiation of the 2nd-level analysis workflow\n", + "l2analysis = Workflow(name='ants_l2analysis')\n", + "l2analysis.base_dir = opj(experiment_dir, working_dir)\n", + "\n", + "# Connect up the 2nd-level analysis components\n", + "l2analysis.connect([(infosource, selectfiles, [('contrast_id', 'contrast_id')]),\n", + " (selectfiles, onesamplettestdes, [('cons', 'in_files')]),\n", + " (gunzip, onesamplettestdes, [('out_file',\n", + " 'explicit_mask_file')]),\n", + " (onesamplettestdes, level2estimate, [('spm_mat_file',\n", + " 'spm_mat_file')]),\n", + " (level2estimate, level2conestimate, [('spm_mat_file',\n", + " 'spm_mat_file'),\n", + " ('beta_images',\n", + " 'beta_images'),\n", + " ('residual_image',\n", + " 'residual_image')]),\n", + " (level2conestimate, level2thresh, [('spm_mat_file',\n", + " 'spm_mat_file'),\n", + " ('spmT_images',\n", + " 'stat_image'),\n", + " ]),\n", + " (level2conestimate, datasink, [('spm_mat_file',\n", + " '2ndLevel.@spm_mat'),\n", + " ('spmT_images',\n", + " '2ndLevel.@T'),\n", + " ('con_images',\n", + " '2ndLevel.@con')]),\n", + " (level2thresh, datasink, [('thresholded_map',\n", + " '2ndLevel.@threshold')]),\n", + " ])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:54:37,367 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/ants_l2analysis/graph.png (graph2use=flat, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l2analysis.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "Image(filename='/output/workingdir/ants_l2analysis/graph_detailed.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:54:42,890 nipype.workflow INFO:\n", + "\t Workflow ants_l2analysis settings: ['check', 'execution', 'logging', 'monitoring']\n", + "200920-23:54:42,916 nipype.workflow INFO:\n", + "\t Running in parallel.\n", + "200920-23:54:42,921 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:54:43,32 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.selectfiles\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0004/selectfiles\".\n", + "200920-23:54:43,34 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.selectfiles\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0003/selectfiles\".\n", + "200920-23:54:43,44 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:54:43,46 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:54:43,49 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.selectfiles\".\n", + "200920-23:54:43,34 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.selectfiles\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0002/selectfiles\".\n", + "200920-23:54:43,53 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.selectfiles\".\n", + "200920-23:54:43,60 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:54:43,66 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.selectfiles\".\n", + "200920-23:54:43,32 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.selectfiles\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0005/selectfiles\".\n", + "200920-23:54:43,79 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:54:43,88 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.selectfiles\".\n", + "200920-23:54:44,923 nipype.workflow INFO:\n", + "\t [Job 0] Completed (ants_l2analysis.selectfiles).\n", + "200920-23:54:44,927 nipype.workflow INFO:\n", + "\t [Job 1] Completed (ants_l2analysis.selectfiles).\n", + "200920-23:54:44,930 nipype.workflow INFO:\n", + "\t [Job 2] Completed (ants_l2analysis.selectfiles).\n", + "200920-23:54:44,933 nipype.workflow INFO:\n", + "\t [Job 3] Completed (ants_l2analysis.selectfiles).\n", + "200920-23:54:44,936 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 2 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:54:45,34 nipype.workflow INFO:\n", + "\t [Job 5] Cached (ants_l2analysis.gunzip).\n", + "200920-23:54:45,35 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.selectfiles\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0001/selectfiles\".\n", + "200920-23:54:45,41 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:54:45,48 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.selectfiles\".\n", + "200920-23:54:46,926 nipype.workflow INFO:\n", + "\t [Job 4] Completed (ants_l2analysis.selectfiles).\n", + "200920-23:54:46,930 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:54:47,21 nipype.workflow INFO:\n", + "\t [Job 6] Cached (ants_l2analysis.onesampttestdes).\n", + "200920-23:54:47,25 nipype.workflow INFO:\n", + "\t [Job 11] Cached (ants_l2analysis.onesampttestdes).\n", + "200920-23:54:47,28 nipype.workflow INFO:\n", + "\t [Job 16] Cached (ants_l2analysis.onesampttestdes).\n", + "200920-23:54:47,32 nipype.workflow INFO:\n", + "\t [Job 21] Cached (ants_l2analysis.onesampttestdes).\n", + "200920-23:54:49,19 nipype.workflow INFO:\n", + "\t [Job 7] Cached (ants_l2analysis.level2estimate).\n", + "200920-23:54:49,22 nipype.workflow INFO:\n", + "\t [Job 12] Cached (ants_l2analysis.level2estimate).\n", + "200920-23:54:49,26 nipype.workflow INFO:\n", + "\t [Job 17] Cached (ants_l2analysis.level2estimate).\n", + "200920-23:54:49,28 nipype.workflow INFO:\n", + "\t [Job 22] Cached (ants_l2analysis.level2estimate).\n", + "200920-23:54:51,26 nipype.workflow INFO:\n", + "\t [Job 8] Cached (ants_l2analysis.level2conestimate).\n", + "200920-23:54:51,31 nipype.workflow INFO:\n", + "\t [Job 13] Cached (ants_l2analysis.level2conestimate).\n", + "200920-23:54:51,36 nipype.workflow INFO:\n", + "\t [Job 18] Cached (ants_l2analysis.level2conestimate).\n", + "200920-23:54:51,41 nipype.workflow INFO:\n", + "\t [Job 23] Cached (ants_l2analysis.level2conestimate).\n", + "200920-23:54:53,23 nipype.workflow INFO:\n", + "\t [Job 9] Cached (ants_l2analysis.level2thresh).\n", + "200920-23:54:53,27 nipype.workflow INFO:\n", + "\t [Job 14] Cached (ants_l2analysis.level2thresh).\n", + "200920-23:54:53,30 nipype.workflow INFO:\n", + "\t [Job 19] Cached (ants_l2analysis.level2thresh).\n", + "200920-23:54:53,33 nipype.workflow INFO:\n", + "\t [Job 24] Cached (ants_l2analysis.level2thresh).\n", + "200920-23:54:55,34 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.datasink\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0005/datasink\".\n", + "200920-23:54:55,37 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.datasink\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0004/datasink\".\n", + "\n", + "200920-23:54:55,42 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200920-23:54:55,44 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200920-23:54:55,44 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.datasink\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0003/datasink\".\n", + "\n", + "200920-23:54:55,45 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0004/SPM.mat -> /output/datasink/2ndLevel/con_0004/SPM.mat200920-23:54:55,46 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0005/SPM.mat -> /output/datasink/2ndLevel/con_0005/SPM.mat\n", + "\n", + "200920-23:54:55,47 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0004/spmT_0001.nii -> /output/datasink/2ndLevel/con_0004/spmT_0001.nii\n", + "200920-23:54:55,49 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200920-23:54:55,49 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0004/con_0001.nii -> /output/datasink/2ndLevel/con_0004/con_0001.nii\n", + "\n", + "200920-23:54:55,51 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0004/spmT_0001_thr.nii -> /output/datasink/2ndLevel/con_0004/spmT_0001_thr.nii200920-23:54:55,50 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0005/spmT_0001.nii -> /output/datasink/2ndLevel/con_0005/spmT_0001.nii\n", + "200920-23:54:55,52 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0003/SPM.mat -> /output/datasink/2ndLevel/con_0003/SPM.mat200920-23:54:55,52 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0005/con_0001.nii -> /output/datasink/2ndLevel/con_0005/con_0001.nii\n", + "\n", + "200920-23:54:55,53 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0003/spmT_0001.nii -> /output/datasink/2ndLevel/con_0003/spmT_0001.nii200920-23:54:55,54 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0005/spmT_0001_thr.nii -> /output/datasink/2ndLevel/con_0005/spmT_0001_thr.nii\n", + "\n", + "200920-23:54:55,55 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0003/con_0001.nii -> /output/datasink/2ndLevel/con_0003/con_0001.nii\n", + "200920-23:54:55,56 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.datasink\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0002/datasink\".\n", + "\n", + "200920-23:54:55,57 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0003/spmT_0001_thr.nii -> /output/datasink/2ndLevel/con_0003/spmT_0001_thr.nii\n", + "200920-23:54:55,61 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.datasink\".200920-23:54:55,61 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.datasink\".200920-23:54:55,62 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:54:55,59 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.datasink\".\n", + "\n", + "\n", + "200920-23:54:55,64 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0002/SPM.mat -> /output/datasink/2ndLevel/con_0002/SPM.mat\n", + "200920-23:54:55,66 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0002/spmT_0001.nii -> /output/datasink/2ndLevel/con_0002/spmT_0001.nii\n", + "200920-23:54:55,67 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0002/con_0001.nii -> /output/datasink/2ndLevel/con_0002/con_0001.nii\n", + "200920-23:54:55,68 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0002/spmT_0001_thr.nii -> /output/datasink/2ndLevel/con_0002/spmT_0001_thr.nii\n", + "200920-23:54:55,72 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.datasink\".\n", + "200920-23:54:56,935 nipype.workflow INFO:\n", + "\t [Job 10] Completed (ants_l2analysis.datasink).\n", + "200920-23:54:56,938 nipype.workflow INFO:\n", + "\t [Job 15] Completed (ants_l2analysis.datasink).\n", + "200920-23:54:56,940 nipype.workflow INFO:\n", + "\t [Job 20] Completed (ants_l2analysis.datasink).\n", + "200920-23:54:56,943 nipype.workflow INFO:\n", + "\t [Job 25] Completed (ants_l2analysis.datasink).\n", + "200920-23:54:56,946 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:54:57,34 nipype.workflow INFO:\n", + "\t [Job 26] Cached (ants_l2analysis.onesampttestdes).\n", + "200920-23:54:59,28 nipype.workflow INFO:\n", + "\t [Job 27] Cached (ants_l2analysis.level2estimate).\n", + "200920-23:55:01,29 nipype.workflow INFO:\n", + "\t [Job 28] Cached (ants_l2analysis.level2conestimate).\n", + "200920-23:55:03,29 nipype.workflow INFO:\n", + "\t [Job 29] Cached (ants_l2analysis.level2thresh).\n", + "200920-23:55:05,37 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"ants_l2analysis.datasink\" in \"/output/workingdir/ants_l2analysis/_contrast_id_con_0001/datasink\".\n", + "200920-23:55:05,46 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:55:05,49 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0001/SPM.mat -> /output/datasink/2ndLevel/con_0001/SPM.mat\n", + "200920-23:55:05,50 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0001/spmT_0001.nii -> /output/datasink/2ndLevel/con_0001/spmT_0001.nii\n", + "200920-23:55:05,52 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0001/con_0001.nii -> /output/datasink/2ndLevel/con_0001/con_0001.nii\n", + "200920-23:55:05,54 nipype.interface INFO:\n", + "\t sub: /output/datasink/2ndLevel/_contrast_id_con_0001/spmT_0001_thr.nii -> /output/datasink/2ndLevel/con_0001/spmT_0001_thr.nii\n", + "200920-23:55:05,60 nipype.workflow INFO:\n", + "\t [Node] Finished \"ants_l2analysis.datasink\".\n", + "200920-23:55:06,941 nipype.workflow INFO:\n", + "\t [Job 30] Completed (ants_l2analysis.datasink).\n", + "200920-23:55:06,946 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 0 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l2analysis.run('MultiProc', plugin_args={'n_procs': 4})" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "#!nipypecli crash /home/neuro/nipype_tutorial/lection/crash-20200721-181746-neuro-selectfiles.a5-607b7489-d773-4d9c-ae69-49eca16a30d1.pklz" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**Keep in mind, that the group analysis was only done on *`N=7`* subjects, and that we chose a voxel-wise threshold of *`p<0.005`*. Nonetheless, we corrected for multiple comparisons with a cluster-wise FDR threshold of *`p<0.05`*.**\n", + "\n", + "So let's first look at the contrast **average**:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's take a look at the files we produced" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/output/datasink/2ndLevel\r\n", + "├── con_0001\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "├── con_0002\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "├── con_0003\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "├── con_0004\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   └── spmT_0001_thr.nii\r\n", + "└── con_0005\r\n", + " ├── con_0001.nii\r\n", + " ├── SPM.mat\r\n", + " ├── spmT_0001.nii\r\n", + " └── spmT_0001_thr.nii\r\n", + "\r\n", + "5 directories, 20 files\r\n" + ] + } + ], + "source": [ + "!tree /output/datasink/2ndLevel" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "anatimg = '/data/ds000114/derivatives/fmriprep/mni_icbm152_nlin_asym_09c/1mm_T1.nii.gz'\n", + "plot_stat_map(\n", + " '/output/datasink/2ndLevel/con_0001/spmT_0001_thr.nii', title='ants', dim=1,\n", + " bg_img=anatimg, threshold=2, vmax=8, display_mode='y', cut_coords=(-45, -30, -15, 0, 15), cmap='viridis');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's see other contrast **Foot > others** using the glass brain plotting method." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from nilearn.plotting import plot_glass_brain\n", + "\n", + "plot_glass_brain(\n", + " '/output/datasink/2ndLevel/con_0005/spmT_0001_thr.nii', colorbar=True,\n", + " threshold=2, display_mode='lyrz', black_bg=True, vmax=10, title='Foot > others');\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiple comparison problem" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When we make statistical maps we set a threshold at a given confidence level $\\alpha$ and declare all voxels for which beta is above this this level as active.\n", + "Typically our $H_0$ is that the voxel is not active." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Hypothesis testing](https://media.springernature.com/lw685/springer-static/image/art%3A10.1038%2Fnmeth.2698/MediaObjects/41592_2013_Article_BFnmeth2698_Fig1_HTML.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The probability that a test will correctly reject $H_0$ is called the power of the test.\n", + "\n", + "\n", + "During fMRI experiments we perform test for each voxel, which means there will be many false active voxels.\n", + "There are many ways to deal with this problem.\n", + "\n", + "How to choose the threshold ? " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAC0CAYAAACJ8Y3MAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOy9eYwtV3Uu/p2xz9R9erq378S92Gb64V8c8sBMycNEHgixIIAJZGRIUAxIiTGySIKMjAigSAaJ8JSA8kSwyIMEAg7hkTDFBFAkgoNAUcAJEGNjfAf3PJ/uM9X7o/Pt/mr13lV1utvXdnKW1Opz6lTt2rX32mt9a9ircgAiDGlIQxrSkIY0pCENaUhDGtKQDkz5R7oDQxrSkIY0pCENaUhDGtKQhvRfhYYG1pCGNKQhDWlIQxrSkIY0pCEdEg0NrCENaUhDGtKQhjSkIQ1pSEM6JCoOcvL58+dx7Nixh6svQ0qgCxcu4Pjx4490N4Y0pCENaUhDGtKQhjSkISVQDgMUuYiiYT2MR5Jyudwj3YUhDWlIQxrSkIY0pCENaUgJNEwRHNKQhjSkIQ1pSEMa0pCGNKRDoqGBNaQhDWlIQxrSkIY0pCENaUiHREMDa0hDGtKQhjSkIQ1pSEMa0pAOiQ7FwPrEJz6BO+64Y8/x5z//+Xj5y19+GLfYF91///3I5XL47Gc/e+C2vvKVryCXy+E73/lO4nm33HILHv/4xyeec8cddyCXy+35++AHP3jgfg5pSEMa0pCGNKQhDWlIQ3rkaKAqgiH6xCc+gfn5ebzmNa85jOb+29CXv/xlVKtV9/3SSy99BHszpCENaUhDGtKQhjSkIQ3poJRoYDGyws8Xi1qtVszw+K9KV155JRqNRubzR0ZG3OcoihLnhBUfc7lcrPqjfudntpNUJdKem+W+Sf2w94uiKPYHAPl8PtZWiBd9bfuOhZ5pEApdkzSGvt90PEPXpLWV1G5SW4M8QxpvZOGJLPfU9tKuD/Up63wm8Z1P5mkfD0sOhsbNN6++tRdFEfL5fKzfvnOSvj+WKGvf7XmD8MSgsi0rads6t/1+H71eL8Zzek7SfQZZ00nn+fhjEDmVdC97j0HlXGh9Wxnom5ckvRO6V2gs0tapj7Lc3ze2WfSm7zl97Sr1+/3YNVbH2nZ9eib0nKFxf7SQj2cGvR7w4w5tcxCe2y89nG0fln6w+lX/Kx9eTHrTm96E173udYiiCP/6r/+K1772tdje3n7Y73vgFMHXvOY1+NSnPoWvfvWrTlG8/e1vj53zsY99DE94whMwNjaGF77whXjwwQfdb0zj++hHP4pXvepVGB8fx4te9CIAwOLiIm688UbMzMygUqnguc99Lr7xjW/E2v7Qhz6Eyy+/HNVqFdPT07jqqqvw3e9+N3bO5uYmbrzxRjSbTZw6dQq33Xbbnon+8pe/jGc961moVCqYmZnBG9/4Rqyvryc++/LyMn7lV34F9Xodx48fx7ve9a5Bh2/fFBL6+zlHQRqP+T6nteW7p+/apGNJRpTvmhD49YEIe36aQZnUvo9Cgtg3vlbwJN0vDejba/X7IMaCKl69Vg0P331D/bXnJPUlxIO+Pmg/9T4+cJ1EvvnPsoZ8NMh5obnR332fbTuW39LWTJY+Zpln3zWD3CPpekv7cYDs5/r9js0gbVvwPGjfsshAXz+T5nNQGR4ag6w86+N/329Wfofkts8wSQLUPhmUNAZJOiWL/rDPljZGvudL4rtB5U5WnksyCtO+70cGHDYdVCbZtvL5fKK+1Psk6fQs90o6nuTozNpW6DzfM4baO2y9+HDSiRMn8Du/8zt4xjOegZ/4iZ9AoVDAL/3SL12Ue2dKEUwapLe97W144IEHsLy8jD/5kz8BAJw6dcr9/o1vfAPnzp3De9/7XrRaLdx00034rd/6Lfzd3/1drJ1bbrkFL3vZy/BXf/VXKBQK2N7exjXXXIPl5WXcfvvtOHr0KD7wgQ/gmmuuwQ9+8AMcO3YMX/va1/D6178e73jHO/Cc5zwHq6ur+PrXv46VlZVY2295y1twww034JOf/CTuuusuvOMd78Dll1+OV7ziFQCAe+65Bz/3cz+Ha6+9Fp/61Kfw4x//GL/3e7+HH/7wh/j85z8ffPbXvva1+MpXvoL3ve99OHbsGN7znvfg3nvvRbGYLfPysssuw8LCAi677DK8+c1vxo033pjpOlLIWzsIsAopILtgQ+1muV+SMtH20/qW1EaoL77rrNLMCq6y9CGtP6Gx8Hm5+XkQ5ZrVW502XvY+of752rXHkpR6yPAM9cF3/6RzfPycdp9BjutzJJHvniGgbQFiGvkUe9L3JEoyUg+ifJM83T4+9PFbEhjOEmXxrQffGNn27PgNYvSxDUYKQuvRHhtEbvjaCzmYQvdL+hw6loUfBpWtesxnKCX1MSvvhuSsbSvtnCx8nvZcaX31XZ92nW8tZF0jvjZ9fQ7JlCRZkzbGPhkR4gOf/EiKIIVkSNK6D/XVd05Invn4KEn2+Z4lNDa2Ddu3JPl/GPyXRSdm5bmHm4rFIqrVKjqdDmq1Gs6dO3dx7pvlpCShcdlll2FychL9fh/Pfvaz9/y+urqKv/3bv8XExAQA4MKFC7j55pv3pAE++9nPxh//8R+77x/60Ifwne98B9/97nfxxCc+EQBwzTXX4MlPfjLe+9734vbbb8fdd9+NK664Ar//+7/vrnvxi1+8pw/Pe97z8N73vhcAcO211+Lzn/887rzzTmdgveMd78CZM2fwmc98BoVCAQAwOTmJV77ylfj617+O5zznOXva/O53v4tPf/rT+Mu//Eu88pWvBAD87M/+LE6fPo2xsbGE0QSOHz+OP/iDP8Azn/lM9Ho9/MVf/AVe//rXY3NzEzfffHPitUpZFkKS8LEKK9R2GmhR8glFS2mAO9SHpPaSniWpjbQ2feekKVHbn5AhbPuRphiyUNrzheZnEKXrG5usxm3ot5DgTupvEghMU5Q89yCCfxD+tOf7+pp0XQgU+NrL5XLo9/tBfsq6xtLmPO25k87xrYe0NRICH5aSntEe03NDRkloPYfG3z6zD6QeBuAI8UwWWZi17TT+2S+lzaH+th/Zlwa4Q9clHQudk8Zr+2nbnp/VORK6LuucJfGU/az3COmSrPIl7VyfMWOvS5tHnyGSdH7o+XyywTe+We6R5TO/h2RfqG9pz5b0jCEaBDekyfOLRefOncN73vMePPDAA2i1WvjiF7+IL33pSxfl3plSBA8irK+88kpnXAHAU5/6VADA2bNnY+ddf/31se9///d/j6c//em45JJL0O120e12AQBXXXUVvvnNbwIAnva0p+Hb3/42br75Znzta19Du9329uG6666LfX/qU58aS1O8++678dKXvtQZVwBwww03oFgs4h//8R+9bf7zP/8zgLhB12g0cO2113rPV3rBC16AW2+9Fddddx1e+MIX4iMf+Qhe8YpX4J3vfOeBc1QPU2FlMcR8bWdV8oMKgSztZD2PpJ4ePZbU/6yCKHR+FmOE99d+6HeG8/nfHtM/e13oGfYDZLJea8c569gOMgeh9u0YZm0vdJ6dl7TrB1GywN40J3tfeyzpnj6l7GvL92y+cdM9G7bNJMra7yzgyV7vM/5Cz2jvkwRALahLMpSz8q3vPllldhbezSJ3fW37rk8CxKF+JfXFJ8v0c9K4JvGm795K+5ELWda4T3foeUnjlSTfQ8/k63tobWch3/X2d98643P7rlXdqe2H7pG27rQfaWOV1Hd7f+VxX9+0/4OuzyRZHXqOtHND52c5L+3P9/yWsji1kubmkYxgjY+P4xd+4RdwySWX4MSJE6jX6/jVX/3VxGuue34NT79iJPiXlQ6limASjY+Px76Xy2UAwNbWVuz4zMxM7Pv8/Dz+6Z/+CaVSaU+bl112GYCdiNaHP/xhvP/978cf/dEfodFo4Nd+7ddw++23o16vJ/ZB73/+/Pk99y8UCpiamsLi4qL3uS5cuIDR0dE9xTiOHj3qPT+NXv7yl+MTn/gE7r///sRqglZopVEWpZwkKLNSFg+7/h76Let9syhT3/khhehTNlmiOowUZO2fPSfUH82HTgIBobZCniZVjEkA4bAF4iC8tN/rs86DgoRB7m8NnyTv5X4oZCikrYk0r2IaQEhrn8U0Bm0rzWPtuybp/BBA8ynzNLkXknm+vtnr0uYi1NcQ3yV5yG1bPtAa8mqHImaheVL+Ds1J1n7Z8fA9pz0nCdQm8VaWubbjNIihm8bDWSM4obkKtWPbSppnH++GnLV6jaauZp3vrPox1NfQ72nXDKKXeV7Suk3iM20nxDtpOmm/z55Vp/j6l9av/eqrtDaBw9eHh0XXXHMN7rvvPszPzwMA7rzzTjz3uc/FRz/60eA1C4s93P2F08HfC8d/kOneD7uBlZXsBE5OTuIZz3gGPvCBD+w5V6vpvfrVr8arX/1qzM3N4c4778TNN9+MsbEx/OEf/mHmex8/fhyzs7OxY71eDwsLC5icnPRec+zYMaytre1JdbTtDEr7BeZ6LCQ4DnLPQShpkWUxoAYFTVna2I/hlXbf/fTTKkQFDvqXZmDpGPv2d9h76WefgdXv94PAbVAadK6ytMc+Jd1j0PsO8oxJgEznMM2pkNRv33z7AG+oH1kVf6hvScDK1z/fvUIgO8Tz+t1+ztp33sPXPx9498kGfT7bvl6TJgt8azTLfGQxHnx8EeovgETwnAai7eeQgZama7IA6KRnTqOs+jLL7/vRTVmePwR+LW9qe1n1iO2/bxyz6MI02aL3HMS4zXo8iew1Noqe5bo0Pky7bhA85aOsMi1N/qXpvYtt3Nj7hjDEQfDEQemBBx7As5/9bFSrVbRaLVx99dUuCy5EESJ0ou6B730oBpaNCB0GXX311fjiF7+I06dPZ4oKHTlyBDfeeCPuvPNO3HPPPQPd61nPehb++q//Gu9+97tdmuCdd96JbreLn/mZn/Fec+WVVwIAPvOZz7g9WOvr6/jSl76UugfLR5/61KcwPT2NM2fOJJ6XZAiQBjEIfG34BP4gCz/NmPEdz+VyrmRxFgWQRQEdBqWBmEHv6wPTuVwOhUIhCLL5X9P9AH/VHyvofMaUfudfr9dzv/V6vaAhlmUcsoyBXp8GcA5yzN7T9j3Es1mUr70maX0w0ulbS6Hn1+hoVtCVRqFx45/v1QjksyzAygIwHx+FeCuXi0eEQ0ZrGqgNHU8y8JJov2BRn9EHerO2tR8jxZ7rMwqsvE/isRAf+qKbgwKrtOt88zTInPjazFp0JK19+6qE0L3T2mLf2F7oWS1P2f771s4g8tPHp5ZnD8vo8F3r4017X1JoDOw5+psdlyQ9Pghv+NaXr5+hcfWNcUi3+sbEJ9t8Y+k7xz5DmkMg7XmzPMfFpLvvvhuf/OQn8a1vfQvdbhff/va38ad/+qeJ10QAuuglnpOFDsXAespTnoK/+Zu/wac//WmcOnUKJ06cwIkTJw7U5qte9Sp88IMfxPOf/3zccsstuPTSS7GwsIC7774bx44dw80334zbbrsNi4uLeP7zn4/p6Wl8+9vfxle/+tWBolcAcOutt+Knfuqn8JKXvARveMMb8OCDD+J3f/d38YIXvMBb4AIALr/8crz4xS/GG97wBqyuruL48eO4/fbbUavVUu93ww034JnPfCauuOIK9Ho9fPzjH8fHP/5xvP/970/0zqhSSBMQPgoJqKRzrHIGkOn9AYwyah+TwPigizBJeST1b2RkJBWoJtGg4+0T8HbfFBA3lnTvFK8rFAooFArePVTW0FLeYJpIv993USoaU/zOc8hXxWLR/eb7OwwaBDSRsvKdGrEhxaP3y/pMSf1L6xtTo/V+SUBK++wDXVkpCYiybWCXh+x7cXx8ailkqCrv8TcrC6xTxQL2/Rjwvj5pu4OMZdZ3pWhWRVJfs6yhNPCilObYrFQqrh3bj9D3JNCZpb8+4zEEkm0b+l/XsI8vLH9kAcsHMQLsfWxffb/ZfiWBe20vi8OacxvqW1qhmyyGUui3pP5VKpVMhqVv7rIag4OekyRLQvImzQDzURLW4XGrm3zthvqRNme++ycZnfb4IDo2RI+0QeWjt7/97XteH5VEOxGsg7+z68DvwQKAN77xjbjuuuvwG7/xG7jyyitTrcMsVKlU8A//8A+49tprcdttt+G6667DTTfdhB/84Ad45jOfCWAninTPPffg9a9/PV7wghfgAx/4AN7+9rfjpptuGuhel19+OT73uc9hdnYWL3vZy3Drrbfil3/5l/HJT34y8bo77rgD1113Hd70pjfhN3/zN3H11Vdnqq//5Cc/GX/2Z3+GG264Ab/4i7+Ie+65Bx/5yEfw27/924nX2cIGQFwRDUpZr/Epzfvuuw+bm5tYW1vD+fPn8eEPfzi270375OufTwGFhEeoT0kC8L777sPVV1/t/e0gSjb0HL429bn4R0NJDSb+FQoFFItFFItFlMtlVCoV1Go11Ot191//Go0GGo0GRkdHMTo6GvvO/81m0x3nX6VSQaVSwcjIiPsrlUru3uyX7aOdx/0K0kHm2dIgfGf5dpD7+Z4t7XmTeM5nmGQFDgcdZ99x8iLn2ceD5MNyuYxSqeQ+j4yMoFKpuO+Wl/jH68hfbNuuAeWzJPmWVc75DNf9AA5SGs9pG2nAI+kZBgGXejyJ7wZxHmQZc32GNCPBzoFPdtrjVh7qf+WdYrHoPWZlakhPhp41bVxCz5L2nIN8J2Xhu8MwPiwlzantX5qODeEAn2601+9nraf1Re9t9YPPyMsyn/YetrCUfX4ri3jM58Tkb2njkWT023NC33l+Fr4blB6NRlcSRQB6iIJ/WSn3n235f8zFPZqs5DekR4aazaY3sqCUxTt6UGbf3t7Gfffdh9e97nW46667MDMzgy984Qv47Gc/i1tvvRVA3KNrBZv2VQ0l+0wh5ab/bXu5XG5P/5TSIlhZBXaaN0yPWQPLJ3TL5XIMGJTL5ZjB4zN0fEYPI1VaEZMpf4xcdbtd9Pt99Ho9dLtd9Ho9bG9vo9frOf7iORqF4PVJ0SwdgyxjmXaO/j4o36W1yX7qmuIz8H+I72y/k3gua78Oi3yAmMf1T/mH/EL+LBaL7rdSqYR+v+/e78dzLOkYWt7p9/uOp6Io8v7nufqdx3z3ClGIpwaJXJGy8BywO78+447/7Zrp9XoughcySCwPavv9fj+V73xRDtu3QcYlayQq6byQQ80+r28falKf+NnyYVqUS/UQv+t8JemK0LOHdF4a8bqtra3Mss435uyDTbnlOd1uN2j8JFWa5fFWqxXku0ql4gX3PuMiinajk0nn+MZzv2OcRtqHLHjpMDAV4OentPV2kPv42s/CdzYqbp8/tB6tXH800xVXlPCFv5sO/n781PlM7aSmCO5HKQ3p4aFKpeIAsQ8cWsXgo4N4w0PXPvTQQ/jCF76Apz3tabHzQ21YoRm6H/ubBJYsgMzyfCHhH+q3796+56Gy0OM0jhQ80Puq0YJKpRKLHIyMjMQ8tBb0KkgGdvggn8+7/zp+mh5I44ngDthRtq1Wyx1rt9vY3Nx0RpUaY9qegmjey6cAk+YxizEbmlcf3/mut30i8Aido2S9h/r9oIo1yxrI2r6vP8ojPuPcFwFQviOfklfZ10KhgF6vFzS0fMZVFO2kn9DQIq/xGPmq0+nErlO+5nE+m46jHYvQGFmyc5A2J2k8FzKu9FhWXkuSU0D2zf62Pz4jcFC5HALCvvbt9eQnfrfyzAL9kNFK0vvyv34OGe9pVfZ89/KNhfbDJyfSximLQZbEd0ky19ffJJkS4tm063xtaD9CPO0b69B6tPcPVfANXau6MomfBnmetO+D6IdB9GPI4BwU/6Q9u4/vfPzmM0oP2/C9mBQhQmeASFWIHjVVBIeUTtVqFd1u14ESu7dBwYf15O2HQsrA0smTJ/HCF74QX/7yl92x/QJqe05WwDKIgbSfPoWu8f23oJZAlN9pTDFKlc/nUavVkM/nUSqVXDoWDapSqRQzpnzvIqKxpJGrXC6HbreLcrkcM6iAXe85AW+pVHLvm2O0ot1uu+/dbtd9Z196vZ7zPhK8hHgkbYyTQFmIh318x3sleQO1P9bb5gMAoe8W2A1KSc87qHFl+6FgVY0p/V4oFLyGvZ7ncxCk7Qmzsoi8UalUnKFOo31rawudTscdJ1+pYUaeo7Hlm7NBgEYa4LPnKCXxnLYful8W0mcKRROytjmI8cjzs5xn58B3T9/YKv9Zo0oNK5+x5euT6jmVQ/xNwTR5hw5KPqt1Etn2k/gpCUz7vvt4L2QwKvn4ztcva9iFZMN+KOt1IYMpi9GaZGyFZLivDZ9xq22n8XmSEZK2ppJkStK90nRRmuG2Xz2UNA4hvku732PZuAIAREDvEB5haGA9hogApVAooNPpOKBCr29SRSOrKAhYkgRYmsL49Kc/jSiKMDo6irvuugu33XZbrK0slKQk0kgF6UEoTdBaz4zv/ryeYFQLUjBKwH0oun+FwLfRaMT2ozAMr2DEAi4aVlEUuSIKavCwP7yuWCzG+k/DiX3s9/tot9sxA4t//X7fRbVoiJGHLJi2Y5s2xrw2aeyVkvgu1OagAn8Qnjoo/5EsP++n/zbtT/lH90Hxr1arxaJVIyMj7loaWmq0R1EU+x7qgy/61G63YyC42+1iZGQE7XbbybOtra2YoU8ZRYOM11tnkn4OgQ8fsA3JS/s9K8/5rk06L8T3tm+2j4OA3axGlg/AJfFgFkPBGlA+vvQVWimVSnscVL5n0f+UTWpEaVqqjmdS9H0QB8cgc7IfOZHEd4PItCygWGlQp4C9l11Xdo36/tv72777fg+tH9/3rIaQ/s+KQ6zcyWJM2nOzrs1BaFAsRcoi73zjZx0Wj1WKkEMHB9frQwPrMUT1eh3tdhuFQgHlchndbtcZV7p/Rj13Kux8Qk7JCgUr5Ow1L3nJS3DXXXfhec97Hj72sY9henoaKysrsfPThKdPaSd5sfS6wwK2FnDZ+ySBHPunaXy+KEG5XEa1WnWRKhYDqFarMaDBPwCx6JSCg1KpFAMxBBc6775UHApAGn79fj8W5bLAd3t720UXCH55XCNhGlG1ADgL+PDxG9vLynd2TkOfswKNw+IxpdB4pIGMEMAF4oaVr3BFPp9HtVpFsViMFayoVCoxw16jpfpZ+VGNJ5Ia9CTds6fna/pfqVRCp9NxYHhzc9NFStvtdiyNkM4DGvcq5+y42UiXb/wHAahpPBeSrRZI6rEk2s81oXZCn7MYp0lj5dMXdi5s9J4y0lfcxxawAOA++8aV9+RxTWOmkUV5ZSP26oxkO9ag1/sMOuaHJTeyyLqk+4aMUvubzwg/CKjX/2n61fZLKcR7WfuVFG33PbvqS17P/qn+tONlMZZv71+a7kky1kPGTOh76Drtj71Wj+2H7yxWeixTBKATDQ2s/1Y0MTGB7e1trK+vx1K38vk8Op2OS7WxHl797zO0LPkMiaSF87WvfQ133HEH3vOe9+ClL32pa0PvqxQCi7ZvoeuT6CCKLSSwfMpHBbACCF91tFqt5lL+RkZGMDo66qr2MapQLpdj7TL9ToFtsViMpeh1Oh13Po0dBbG8RkEOQa0CDAJhgh8ahExJ7XQ62NraclEtGly5XM4BGPIj701FlEWx+H5L82ACfr5LAwZZhX+aNzGtb0l0ENCibegasUCWBhLnn1FS8iB/454rGlcaCVUj3SpQ7QPPIYhV0Kxl2MvlsuM3RqTIb4zEj4yMoNPpuMjp9vb2HvDM8bBRLR5PM0atQTDIfPh4Lo2S2s8KYg8CWOy8WVCbxdjTvoZkoz3HpkfT0Kf8odNJK5gCuzILiBtoAGLyjdF5W4iHz6vRdt3712q19uxLpVHuS70nhYxQSwdd377rs/Cdj5f1mM+o5v80PtyPoR/iN/s5iSzvZaU0Y8X+8bhNyU0aT9tP7avNJFE+C62ZECbScQjp0kHHM+u1SdjOtuHj4YPqykeKdgysgxdZTzSwHksD8t+BTp486fYtEHxsbm46g4t/PK5eOyosn7fFUkg4JQm5973vfbj//vvxkz/5k/iXf/mX2PVJgkOVVtJCT/PosH9KjBCRBqmCaYGk9jdkUCl4LZVKrhw6S6NzfwuBJttjOxTMvD/nmHO4ubnpxkm9sr55saliAGLRC1udsFQqAdg1zEqlUiwqyoplvV7PAeC1tTUHhMmTm5ubsb7Zlxbz2Szg8wG3LErdx3c6hrxe761tqqEcUhBZ1wDHzfKcFqUJtZsFuPjAgI0CELiWy2WMjo46niyXy7F0QBr2oRdcE2xyvum80X6oca6ksoZ9IojWZ+d+KzX0t7e33WeugVar5dYCHUxMKeR57F+aPLHrOjTOSXPh4zmfzAzx4aCGXRZeCfGd7ZOPsvZD592uV8obLanOeQ+lpdp0aDqayM/ArqNJx06jpfqMTHNWI0l5hIYWI6SUY5qWqnxni/mkgVxLWYyCLMYNKY3veE/luyxAXAG+5Ut7vo3eHFTHJkWalQbhUf2s/Onb96fH7Xnso+V7bZv8aA0sm81hz1MZZ9ezz6jMatxnJat/7dgphbAdyY6Nz6D2fX80UwSgd7FTBC9cuIBjx44d+KZDGpxWVlYwMjLiBBwFW61WQ6FQwPb2tgO73GtD76/mpgNh70Jokft+tzQ/P4+PfOQjeNvb3oaXv/zlsfv42vYt7qygOkRWQHzuc5+LfX/nO9+Jd77zncFrQ/ezgk6BqQLWUqmEarWKWq3mDCoCXXptAbg0QioY/lGRt9ttrK+vx/Y/aXEAPc/uJSCpx1eBdy6Xi6UsjoyMOJDDfpB/9Jk1YkXjkXy3vb2NcrmMdruNXC7n+k1laxVMyFjejwC2fBcCCmnkO9caHlmUko/n3va2t6U6CLIaV7xO90dpeh/T/kqlEsbGxty7qBhJ1TRAXq/PyJRjgk4aL2pgsb+aAsjP7BeAmBHX7XZjoJpySVMKeb5GInRvWLVaxfb2NvL5fAwYM8WQKawKbnzjmEZpc+GTdYPcZ9DfsoCsEN9ZygrmQzLbXm/3UmmFVOoofZ8aI+MqP2u12h7ga/lD01HJb0j83vwAACAASURBVBqdZ5+sAaB7sigry+Wy04mdTgetVisWNaWss2mFlGFZ95iExtknR7KQj+9CxrdP3viAu/YziwMgi7x797vfHVx7WUH3oI4t2zc1mJQ39ZiNrvIa3T9t//v6qbylus6mUmv6qs6FD2vp96w84jOMBx03H6XJOx9uZLuPJaNKKUIOnSh5r3EWygHhWoS+cKllXNchjyWe9lZopkV5O2aOq1fGCvV8Pu/SsCjELcgtl8uo1+sOCAPx/QKWFMRS6KoHzL4zyPabqXu6uKgQyuXynrxzHudvbIfKgALfbgAn0OAflcXGxoaLKuh+GbsY+GeNG51TS1neMl+tVmP3se36hId6eCx/WaUeEkpAMt/pu0OSFr9PQVHw6n9GrDh3ExMTqFarsTSsarUa6ycLCfBZ+v2+q6ZGQ7nVarn541wT5LItflfg6yudrXseAMSqGJLvGo2GA+cKXDQNx+63Iq9xv8zW1hZWVlZiEVaWf9e5tUDdNxc+oJCF7+gN9xkwlBe610J5kevYyrgsgDRN1iW9B8s+v/2ucph/+lJVn7yrVquxYioaKdDn0/nt9/tYW1uLefOBnXFXI5/jxP+aTsj21ZCjvFX5q0Yh+6BOFvt6AOWzjY0NZ9iT79bX12O8SaProF7ftHkl6fumssoqvhLBGvIW8Prazdq/QfjOkl2bCjJV9ypg1eg4jWKN6qvRpZEtXyRU+UpTmilL1FHlkxfUmUD8NRbkZ/K4Gurb29tOf/oiuLpW9gOA1TgLOWuiaCeClkaqR3S+QoY4+87x0HuqbPHJPMsrSbLYx3Mhwy+LDvbphqRz1VDX/1o4hTJU+dj3zkk1sPQe1simXOS4awVe/in/UMYpT1vjPaQbD0JJxvcgfJd2D/ufn33r/NFIT/6JEfzvz5wK/v68S+7N1E7mCNZBreCs1/jAvS5OTYnhfzWe6JVvNpsYGRnZA4B14VDgkqwy7/V6WFtbc4qbgtYuHk1NUQNLwa7tv6buEGgwAkIlxTQttsHn0zLHGp2oVCqo1WoulYx7ZqhQqHBCC1b7GvLYZCUfYNyvoEgSyvvhO9tG0n1Vadn3ApVKJdTrdYyMjKBSqaBaraLZbLoIgu4lsF4yAE65k8+4wT+KIrRaLbfXSec7SUAD2OOl84H3TqcTi4CUSiVsbW05UM7oh3VAUPkAuwqaxTFYGIPHtra29niKbYqEb43b8T8IKXCxwCvpvnqOD8AcNiV5dVWxq5Gve1dKpRKazaaTHZR39Xo9tteFKVWcxyjaTa2jXNvc3HQ8qe9FU1mXBuq1AqHKu3a7HYuoFYtFt34obxTcAHD9JZ91Oh3k8zuvOtje3nZ8BsCBY64Lym3fuGYBLoPOtW+t6fGsvBT67TD4T9vI+vw+o8/qYP4nD2oRFcoU1XHK1zaFnZFIjpvVsexHu912RrxWQyX1+7svx1bHXb1e37MPkHxTrVbR6XRQKBScnmcbus+QxlLIe+8z+rLywH7n2CfnbEQvTc76QL2vnUEpzRj1GcdZz9VjlDkqR6i7NY2aek91umZ0AOFXA/hII1eshmodo3TMq1xSPah8kqYb7XNbI12P2bZ8bYR+81Ga7Dxso/CRoAhAHw/zHiwfhTwRwOApPkkTYYWFeslsFSymYVUqFdTrdfefipzXaxQsl9t5G7kaVN1u16VmcWM/S1MrwGW/NP+f7apnyEbZVPiTNMWBCooevpGREfc8qqBoTNFA1PfLECjVajUHQNrtNlZXV12US5+XfWX/rWI4yEIJGVY+BZ92HyskKPCzgoVB+qykkUaCQxru1WoVU1NTzlAulUrufVZ8dp133R9H44lRHt1HZwUsQaZ6eslnCkxJVCAELmroUQEQwJCWl5eRz+edcd9oNFwqIJ+VRRJ4z1qt5oBst9tFo9FAvV53nuBWq4V6ve74bnNz0/GneoGVRw5TOCv/sc+6Pn385wMpF5t8PMg55XxS3tEo5neNENkqk5wreug7nQ5WV1ddNEjfdUY+49wCO3ylxSasPGXf7We790GNPspxrqGxsTHnFKNMVL6v1WoOIJOXtre3sbS05OQdI1oaiVP5rX0Oybn9Glf2OpUDSpyLrAD7MPRtqB37u4JpNahstErT/ygXmQ5tq6OSJzWNk05AHtO9m3QSqrFsQbrOG/umji1+V4AdRZHjKbY1OjoaKxDVbrcxNjbm5DNTtqk7qT/1fZTq+NK+JY23HeNBZV+SgR463/dbyPCza+Ow5LIP0NtnSTLoNCqs2El5VAunEGNRf/GvWq06maQGmMpLizO4Poi92A81mDSSrrKHeJM4bWNjI7bvT6Oq6lhIwmIhPvM5eg6T0oy+tHMe7RRFObQPIUVwX1UEQx4Z+1sa+SxsbYO/WYBBI0SNrPHx8Vi1tnq9vqefXBQUpgQZVNQKOMjoNg1GGZrtWW+WKlQNTStZwAfsbshttVrI5XZSyba3t1Gr1VyUhM/LCJnuAYqiyHn1oihy4JgFL3guQUgon9xnFPnmZhCynjwfoLHHfF5A+3+/ICPNAwMgBmi1aAUjhfV63e1z0YiCtgHsGjWtVgutVgsbGxsuQsV50D1LFPj67PSeciM3+2cBLAW8Pab8x0iTOgS00hb/1KM3MjKCo0ePOh5U8EuQpQVV9JiCHq3gpYroMAVxFuDh8/jpb1YehYCJjYIflCzY0nGmkU8gy/1+5XIZzWYzZvwC8dRCpnTSIKEMWF1djRlNjDQqkV9oENjxUFlo78txIu8SQJPXCc43NzeRz+/srdJIKp9X70tngaZVMxrMtdjv991+Ld2/qHOXBNjTwHGWebSGZhZwG6IkXTvItUlGoP6u59isD00BpI6hc4kRSXUEKumeFAAxI4aR0U6n43SWAk/riNE+6p4uTbunEUheyuV29qBy7So4J3+w/6xqubW15Z6beEGLsajByDEcZH4sDXKdb16TDJes/H3QdZB0XRbgnYQrtW3FhcqffCWFRqbU6a4VU+2eK1+/LX7TqCvbUOenFnjid2YkUb8S32mmCu+l2MynHx9uAyoLhZw+Pv3wWDO0IgAdXGQDK4tXBtid/LRcTW03RAo2KbTr9XrMuFKgy5Q7m3IQRVEsb7/X68UKCej+JWt4sC2NRLBvuVzOGTu8nwIjG73S3zhO1pPJPqing6CeYIpj0ev1YgCECkWBLQ0u9epwEds9PGnzRMPNCna7sHyLLKlNe8z3n+QT/mwniqKYARESAvpZhacKbh2vUqmERqOBWq0WK2RhK2IB8WhSFEVYXV110VGt+siUJt5XvW3aN01r4Ln2udjPKIoc39h21NurY0bQo9/ppWU7LGrBwipMQePz8nqWdqeB5jNANYKm+xdDnk3OowVrSbxjv/s8yz5QpPyQZsRrW1llXRb5yfnVFGgarDTwx8fH3WdGCnR+VR4x2rO0tOT297HaI/cqqRdeo/2+tNCkZ7NgXiNnVq7SoGKEln3Y2NhwfFYqlTA1NRVbBxwjtsXxYJSUspYpt1rshzIv1H+2bXVYmsFtDZMkIz9JFtpzQjyYxneDAu7QdeRDBbI0ilkdlUYWdTF/BxDTc+oAYsoUq0KqwaL7pADEwKfqTM6z8gX/U5bqe97YL/K46lBrQBJvdDod5yAlIN7a2nI6lfJRwXSWsfUd1/NpBIbmzBrtVgcPatyknW9/T9OxoWdMu19aH5Q3bcRKHXuaLs0/6i3VV+RrygQr+0P6Q/ka2OVzpqWSP1Su2v18pVLJZQ0Qm25sbOxJI7QZVAelpDkj3/kwnY5HiEKy8bFHOfQe7jLtlqzyDJ1jKWlRhybPCncuHApypscwNYZAQzcyKmOrQcX0v5WVlVg1KvWusS/WK8xjfFYaOBTS2neSLmj+XigUnNKgMmJ7CnAY2WDaC9MBmaZGgwrYNfi46b3dbru2WP1Nw+Zc7AS6PoFujZG0zwrSs4AS/ubb3OkjBW2+c3xCPMmDYoU3/zRHm8B2bGzMeWm1gIAFIRqdabfbWF5extbWFjY2Nly6id5f50jTAfV3NTDUW6tKgkBY9zxpVIrC31bWAuKKhX2hsZbL5bC1tYXFxUWUy2VsbGy41B+Oj6Z9sW+MvnKc1tfXUS6XHUjh/WhkJnnqfPPtM+p9v/t4I6ssUyDjk1dp14ba8vVX+Y9zyigAy6xrSrRWDPTxII1k8t7c3JzjSaZpqrFJ/lBD3wdebeQUgJtDADFgrMBDN8bzHBpY7MfGxobb/7K9ve3WAZ0a+g4l8nAURY7PqB/4LHx/G4utqJfZGtc6J1mAqm/OB/0txJP2OnWQhHjLtuvjuTTyAVh+tinSjUZjTzEV+8J0yjNNlWL0lA4mFlZR40v1kaar6jrkcRYKYb+Vdzn/lJ+UPxqdZ1q3ZpVoKhn3CHY6Hfec3Keo+7UoL+loCGEeTVPmf52jkHFs5yhJJqbNr6Uk3k2iJOMvy333cx8bsaIhrXvwKQ845+rgo57UTA91jnKO7FxxfoF4JWDFbZqab7FKv9+P7SXlumB2DPEaMSplKtdOLpfbs680RD7dN6gMYDu+NtL4yLb3WDOyIuBQqgge6EXDScpHBWGSYvC1Z40rFeqMGnC/h6ZtaSoh22c4v9/vu9QsbuSmt4DedipzKl8VukrcvA/slhZWwcKF43teKhx6QRTkAHFPCL9zUXGB9/v9WCoGAOexocDQgh4EIzZ9goqO91alFpoj3zzruUkLL8mDl5VCQCKpb/Z/yAizwFajpLVaDWNjYzGgp+OtgE8rN7ZaLSwsLMSKjXDuKXw538pHnFdg1xurKQ0a2dC9hgpkdK+A8o4CFEYwNJKk9yFpBU3yTT6fd+mruu/Cps2xMEGhUHD7z9bW1pxxpfcPpQumGck6v0oKUH3kS/ELgYRB10boexIPkwc5rywKQL5jqgv3yCkItvvsuG+EkVPuJ1XDRMGEVmEFEJMXCrTVCPPxHY01Al9+pyzTiASdU+wXeYGeXfZF96OOjo7G0nfVSUCAxVRp3VtBfuc462edT9/8++RJmrHkcwQlyUcLqrM4kUJtZnEgJLVl0wKZmq8pgRMTE7FUTqsvOS+cc3rpV1dXXZXUKIr2vPtM9Z99Hm3fhzF4P/KRRqRobOkzkH8ouwiUmVXC3xuNhivSwjWiPMrzcrm4s1KfI8loyjo3ynv2s46FdRTYdpJ4Ms1IG6TPByXbT86J4hiNTvGPWT7W6a5jRD1n15sveqR/GvXk9dTpNgNFf1dsQZ2t0Vwa8lwnjMjzPD6DFozKOg8+J5LKKD3P8k4W+aW/Ky/a/48VipBDJzqQeQQgg4GVZESFjoUMqtD5dgLVOzEyMhJLh6lWq5iZmXECkR5WhmQJmLSoAw2q5eVlFyVQQ0RTrzT9j+dwUeufelK5MCxDWs8dc235Xb12uveF9+cY2tSY9fV1rK6uur6srq46AVOtVvekTDLNgR5DVgtj9TgCMK2YSFIjwD7ffgGmHrOLO8QXvuMhL2Gob0m8TKGtKQXj4+Oo1+sO0I6Pj7uIFdsaGRlxipbRKc4PN7GyPzSu1QHA+6sSoBBW0ExS5aKpssqrjGCxwAmwmzNOBWGBNoDYu2AIchTQEOzScFtfX3fAq16vo1qtYnp6OuYM4T2pQLh/kg6O1dVVLC4u7tnkbtO4QgrCjmPoGp8s8ikQ234WXj8IqVOGALJarTqDtVKp4MiRI6jX687AIkhU/uCcc4/fxsaGSwkkD1Aekc85vxqxsvytv5E37fuNNALLiDuBp2YQqDzUtBeda3UAWGOe63J0dNRFT5TP6OQoFAo4duwYOp2Ok20E14ycsE3dm6XGRRoo8PGFPWbXTxY+sG3Zz6Q0T3Ka0eX7rnyoQFDTUrnWmQ4IYM8eY93Ht7CwENtvqoWjfGl96rBSPapGr8pJlWGaWqVRVP6PoghbW1vOucNnJJbQdMeJiQnHv+wffx8dHUWv18Po6KgzFFut1p49NbpXK0lWWaMoSadZg9LnuOQ4+XBYEjbz6d0sTtGsRlUSHrRrTfurjnOmqWu0mq8ZYeSKBcCUV3z3VZ3DiBGzS9ShSN5iO3aPM2W2yijFEuqgUjmqx3K5HUfU2tparCbA2tqa4y9G+211YeWHrIZMFl6z54UMLh+Ge6xTH49gkYsksoopacB9k6VRFwp3RmsajYbb3K1Ak4qVSrnb7WJ5eRmbm5vufVBcQEx1UAFMIUoDDYA7T9OfeC/1nnDBs+98DhVyatTZ9DGODxUAQTm9b8DevQ/qKeSzbm9vo1qtuj0WNv9cq3Kxb9wEzjZVMfCeIYWQNKeDHFcKCYc0b4zPAEzy9Om11oDWjfWjo6NoNpsO2JIXgN09WppD3W63MTc35/Z+2Opryh+a822BKrAbPVLwqcCNnl8FzZr+RwNJI7h8Vq1AqalkHAcF5cp7WigFQMyTxiIexWLRebq5P43ri0pFFVQ+n3cgReckTXH4AHAS6LTgwQdwQtdm8cBlVWz2Gv3TaL1GTulg8u0vJX8wWrWxsYG1tTVXUEUj4WqQ8ZloUPlSZ2iAKLglD+h42f0IHE/KMX7nOTr3eo0aV8CucUc5RV7t93cKWND50e/3nbHFtjR6RaCjKdN8FjokbCaBnSffdzvfer3PSA+1mwRQB/nNAulQv33fOY/kAVvUhynSNK44rrxW9RgN4+3tbczNzbnPjKyqQavgWZ1K+jnpPHVO2sICwG6KvcpJyjaeTwdkq9Vy8r/f77v9tvoaAfJNoVBAo9GIGaKUx0zzsrwVSoO3cxbiwSSHIq/3fU4CxCEaRLZm6U/ouew97XVqWHE904hi9LRSqWBiYsLpUGIdlatsn/im2+06PU1jhjqMctW394/jorIrn89jY2PDyVFmduiWDDoXLT+Tnzj3tVotZvABcA5LZsTw/pTPdr/1oHOj42+xlJ2bNPIZ8o9VetjLtIcWeprCsYPqs4Ltb2yXgpvGDT3jNK4INNToYdu9Xs+lwiwvL2Ntbc3tNQB2PWSq8DUUDCDmxaKHRKNNfAY1BCmAtX22qQUsCMh5X70XQeXCwkLMINRqf1zUWn45l8s5z8vW1hYqlQoajQYWFhYcAKnX605AcawYedDFvrm5GRMw2ncr3Pe7oJMWalpbPt5J4jnbZ+2D8p2NXHEMmQKjwlINsiiKnHGwtraGjY0NLC8vu7nxGUnaDxpWuneJ/bLpB+qV5XfyvwIPCm19aaaC7GKxiOnpabeGer2dqpWMdvT7/Vj6go3A6ZiR17m/ptPpYHFxEWNjY+6+k5OTThFQ8VkDa3R0NMbLPMdnXOpnXY867z5+8AHOkJyy5DPcD0LW6KcsscZVo9FwaamcE8oK9ocezZWVFRe1p7EPxF8yTQ8osPtOPfKOPruNmnKcyS9s2xpm5AWCbF/BICV1dul1/E6e4Dk0sligQ1/IfeTIEfdcPA9AzIBklTo+K/sIIAaE9bn5n31JAiZJ5/C8JLmZZiDZtux5vnXgI999uJ4BOBCr+rdSqaDZbMayRhidpjOQHnhGUdfX17G8vBybf8otzfhgGpfuO1W+zeVyLqXPRloJgslrTDlWQ4jGlzou7T5URp7K5bIzjlqtlsMejUYjFmnjtgKm6tKAJ9Bm37leNIKbhXzzGsJOPlkXatPHG0myUXlbKUsb+zXGeC3H0Vb+0333TA+s1WqON5itQccPeZT7UYmrtIIqC09QRlh8GHou9rPdbscyoVhsRwttcP3wmXRPNflR1xYdGKyOyr2DVn9SXtp1rX3NorfsNWlzbHkjJBuz3v/RRFGUu/h7sELCPwR6k0CubVcXk3pvGZIfHR11HnEyLLBbgY+lXZmatbS0FNtXoukpdvEQ4FKhsJABI2Vsm4JSvf7dbtcBcE2ViKLdyBWfTffDAECj0XAREuYD12q1mHHI61Q56IZKYNdw05LzAGLv7JiYmAAAt8DpAS4UCi56QCXCcDTH1zd3gy6YrMAhC/nubdN60sAO+6SCm6lXzWbTAVtV/hR+6vlkOqCmBKqgBXaNd+U3zeVXxa1GE0Ef590CbBrfNO51wzWBJxUH2yyXy5icnESj0XAghZ7m1dVVx+dUVPqsmorT7Xb3RMJyuZyrmMj3YTGipSDepjSOjY0B2Fmj5D11RGQ1bqwzIAsISGsrKw26HjQS6nMq0aHE6L3yhhq+7XYba2trWFpackV82H89X/cbaWoU+cKmyakjSY14OhV0f4tGNJl+rP1Qb68dX42WEbhyril71DmkcpRro9PpoFKpuLLaXFdsg4Y9X91B3mMfSRzXNCNJ5YvOfRJ/+cBtEijNaiztR5bqNRx7jgkzHzRKwP3O5BfylRrPBK0LCwvY2NhwaZnkU/KOdQRR5qrDRp1MvA9/V10NwMk9YDdNFtjVWzxfDSymh1I3Kx7gOZSL6+vrjt+pL9UBpcaf7jXlfXWd2ggtkM1ATnJM2998ziDl15CzI4lvs/DYQXW6tqNrVJ2QjAJx+4O+M1QzJahfuP7pcFpZWXFpqkxxB3b3rFpDRZ3limN9hq+ey3FmJJfra3NzM7ZneWxsDPl83hmKqu/I79wGQAOOPNVqtWJYhFgzCXvrGIcw/CCyJoQH92PcPdooAtC+GHuwgHBqQciCDS14X7vqQaV3gh6Jer2O0dFRTE5OOmBJTz8VPAX7Aw88gPX1dWxsbABArLqepuWxH9w8rsClWq3iiU98ovMsUJmTmZm7PTY2FotgzM7OOiXEBUHBStDBEvBcRLlcDhMTE25fDxdYpVLBiRMnsLi4iLNnz+7xDhPAMGoAwBmePG97exuzs7POw1atVrG5uenuRcXJxc02C4UC1tfXYylGfB+JFdBJXrI0Ya1CK6mtEIXat8rFGlkKiphuRQE+Pj4ei1qNjIxgbGwsllrJMWfUZ3FxEefPn3feTE2Bo0FCUoNK001ZHe7IkSOxAhGLi4uOn7nv5IorrnBKPooirKys4L777sPc3By2t7cxOjqKdrvtnAtMnaDRTB5kNax6ve6E+Pj4eCxl8KGHHsLa2pozHMnHut9M3w+j3m+m5tKTx/L25EWu23w+70Db2NiYS29Tz7eWtfUB3zQlwciLPUf5Jc0IJ6n8SOK/JNLIZC6Xi727j2D22LFjMUBLeRRFu++pWlhYiK1TGgsKlikLgR2g2Ww2UalUYvOlEUoFzASStVoNJ06ccP2Moghzc3OYnZ11xjRBAeedUcmJiQk3h7bIC8dTDc1+v+8cQYwqcF8j+0WZRUCjkSwWAqnX67H1FEU7KYOTk5MYHx93RVYKhcKeFHLKVpKVJ3rc8ocP1NrzlYesbNLrLG8eFoDVvlL/0rHJYirlchlHjx51zkZNCWS/NMOCDibu59VnZhETYDflU19tAeymr5IoU5SYvk4vP8+jbme0Xh0JCnx5L64z3WNDOZbL7RY44L6XXC6HpaUlLC4uupRBjgsdQ5yzyclJTExMxPZBct8f08g3NjZiTl4fL2ibygc+/cZz7dymOb0P4nyyFJK7Og9ZZaymf+peaGLCWq3mIkGWb2h0b29vuy0iNKjocNQUUpvmp7oe2DXS1eBSB7oaNHou14d9ts3NTTcexWLRyVQ+FzEHsSX7wjVD/V6r1dzre9bX1130VFMdQ0a8zk0S/yXNlQ/n+76n6dZHM0XIoR8dXOYObKLZhT2Id8MHdLlIGJliOgK9uAQa6ukl8+rLMhcWFmKhYS4IKmDeV0t5ckEBO4tzeno65uUkWAYQ8xpzwefz+di+B3025vjSSOGC9hkp2q+NjQ1EUeRC3ipotSIOF5RGtngevbm93m5peo7b6OioW8QEKuzD1tZW7H06AIKbdJPm2vKFVQyha0J842vDx4O2Dbv4eZ56GRk5aDabzrinEUqDiUqaY84I6crKijOu1GOu3iQa5GqIEAgyMkvDXAGjPufIyAiOHDniUun4XM1mE0960pPQ6/WwsLDg0qC63S6OHj2KEydOoNlsotfrYW1tDfPz81haWsLy8rJbZxqdIB+VSiWcOXMG7Xbbra3FxUUsLy/HPMjr6+t79pJpmka/v1Nshp+ZLtNsNt1csJS75QFGQbhGW61WIq8kzXtWReL7TQ20EJj23TeJKF8IIKhsGbVidNFGYnK5nCtksbS0FEtxIejUiCOBJTeBHz161Bm41lmjRgXnkgbf9PS06yvly8jICH70ox+5tBUa8QAwPT2NyclJB2Qpp9k/mzrti+AS7FJ2E6Sy35p+Q1mnxpJW+1RwTccDsAt4KMcZ2Wc/7Txn4bs0QOkDOkl8Yq/ZD/nkseo4Gq2MCLBIEo0tBbJqIDItlY4gfR5fuhYdKvo+O0a4dd61Mi9TnfnuQAWd+juNPabZamTWRm00UsVMGN1vo6n+5Fe+YoPODMomrbrJ56fuLpV2XqAN7Do+tNCVzo3PSPIB1v3Ov237IAaVj2xbg/A5iWPEseM2Da3eS0NEI66U0corjKTaghC8DzEn+6rZQCR1Ati0PepqyglNcwYQc7Cqc4X/oyhykV6+foevl9CqvIzQavZLo9Fw7/aj3ia/8E9TZQelpLkb1OFjHUWPFYqAi1NFMIl8g5xVafAzmYSCt1qtotlsOm83DRkKXTInlfbi4qIDujZ9gUUkKGj5Jm/1krAfrBxEAU9vLQUkgS8XPI2TWq2GmZkZXLhwAevr67Fw9fb2tgOKjBjY3G/d38W+aZoZPXaas1ss7hYi4MZHPo+m7FAItFotV0GRi5UgTuesVqsBiFcw5Dk0aql4snqktP1BwYUCFr0+tLiTFrNeq0YCFTyLp7DAhXpQ6fFqtVpYWVnBwsKCi+xZ44oGKfmIKUvk8Wq1iqNHj7qIGUEreZTGM73+uVzORZiAeNGJbreLarWK06dPO29dp9PB5OQknvjEJ6LZbLrxIHjK5XKYm5tznlhdW+yD8gPXxeLiIu699949BTwYlSAPE/wAcMBVU1y595DjksvtRLn0ZdkAnOJhaoSmSCuzWgAAIABJREFUYPj4xwKVEI8MYuCnXZeVLC9zzKlI6UyiQ4mAk0qda0/ToJeXlx1/qMdVC0tw/8j4+DjGx8dx/PhxZ8wyCvvjH/845gDiHhkCba2cyXNKpRJmZmawvb2NH//4x7EX+c7MzODMmTOo1WoOAGtZa03FYaqfjokW9OAzMW16dXXVRbS45pTXaFguLy87445RBwVVBDGNRmPPXLHqKrD3lQEHMartNT7w45OPFmiHwPgg/bDGFR2bnHM6fejM08gVx5hpxVyjGvlUeUY+1rLo/E/vPR1+mgJI+UsD/cEHH8Tq6qorJMHr9Z1BpVIJp06dclFaxQCUS0yhZjVDpjFTjzL1VPsP7Kbba1S9UCi4NUvwzXGgPGs2mygWiy6yV6lUYkaW8ph1GvqO6+++ubdGfkhOPpzGVShi4rsnj2kKKB2cmhJoXxLMdpn+zmqhuvdP09otz/Oe7IM6+vU4v2sKN3mI7RPrqTFPh5Ia7pTLnBs1xsjnAFxFRGZ02e0w2mdWgtbUWw0MhJyNIfljeU2v0/ny6eIsTqXHCkW4yHuwfODWLvRB2iDDE3hyUdGDy9QE9WoCcAKe+w5WVlacF5XAgJ5PGio0oOhZ4jEKOYJs3o97Rvi7pikBu54NMvOJEyfQ6/Vw/vx5rK2tueP0upZKJSeI+R4gPotGyGgMEtD3ejsvFJ6amnLAo9frYXl52aUgEIjoCzuB3UIYbFsXPI9NTU05DzeAWGokz9nc3HSCWtvn/GelQUFAWhshYZHkndMoC5V8vV5Hs9l0wFY99VSywM64zc3NYWVlJVYxiPfTPXmMSNAI554ugr0jR47sKVagxg29sVQeTHui91j5t9vtotlsYnJyEufPn0e5XMbJkycxNjYW85IWi0WMj4+j2+3i3LlzWFxcdPzO+9Mo5PMSaJAHv/OFCvKbW5j6qftd+hmNfRpS29vbzhPH9c1IKj1+IyMjzqGgDg9N2ahWqzFlRTCVZQ+BT0aFFEuSUebzIu+Xj1XmqXGv+604z/yNBhONEaZPspSvplfTAcQoZLVaxalTpzA1NYXJyUmMjY25yCGfk86X+fl5Zyir95hGn/adhlSxWMSRI0cwPz/vnApjY2M4c+aMi5oC8ZRFOqsoT3QfDx1IJ0+edNXZeO7o6CgWFxexsLDgHEWMJihoZ8ZCt9vF4uIitra2XJoi92yokchnYz+B3Xe2cXwoL338FYo+JPFHVt7RdtNk7qBOTWtc0bHJyFWj0YjJSXUIMmOE0Svdx6bOFeo2GhicIzoUeD9+9vWNvEZ+OHv2LBYXF106OwBnKDG1/vTp07GtAcrXBKAExHTSzs3NuQqomgVA4noiBmBkX/mN8t46jcfGxlxfGakgaSpXGji1vObjPR/PHFTv7gccZzWueFznW7cwMKrPVH1iLh0TyoKFhQVnZNFQtk6tkGGl6a/qIOD6UGcAeYuOGBYVUidrFEVunu0+ZmI7Na75HJRbm5ubLrhA/a+yno5djgUdFFyzdMpphM0a25avlELyzGdcJV2XdvzRTI9IkQt/R/yAJQRyVVHn8/nY+wyYNkVvmpbbVJA/NzfnIlckMrQyMvtH4KKADoDbvApgj9IhIwO70SsuCF3kuVzOvZtrZWUFa2tr7h5MQSGIGhkZcZ4vLUrBKlkEowBc2sORI0dw8uRJl84FAKOjo+69Vaxap/sItFwsn6Xf362+xUXOkrssb6zFB4Ad4bC2tubGcnt7O3MVpMOmEC+FvHr2PBWmNBqq1SrGx8ddRNK+P4M80Ol0sLKy4irtAfEUGALbfr8f2+dCMPGEJzwhNn+acqZGBY0rRiZ7vZ6LrjGiSqDA52F6QLPZxPz8vNtHRl5lARQWExgfH3ce1aWlpdg7hNg/AmiuN17bmayhUCtj/XtPwaX/cxH3339/7OWd6hXms5VKpRg463a7zsDSPR/kXYKURqPh5lYNRXqkQ8AhDRBYHklqizLHRs8s//na8oEfGuV0KHFvHR1KXI/0QHKtMg15aWkptjdE54sOFKYDTkxM4AlPeAKmpqbcHJNf2bd8Po/p6Wk3L4wusm+cG96LfEeeqNfrmJiYwIULF5DL5TA9PY1GoxFL5dI5VGeQrkmCB74WwaZkTk1NuWean58HAFfUg+tE2wEQi5x2Op1YlITnUO6pvOPLb9U5ZcFJEpBIMu4tL4ScBVloP8CZ9/XpXhZcGh0ddRF8TYcCEDOsqEs0VYu8QSNWnVa8F73y/E0dTcCul57yi/2dmppysoTv1srlcs7IPn36NE6cOOHmls9LWaPPnsvl3JpgZIRRD4J0pjbzeTgelLndbherq6uxval0UGk2ghpUAFyl31wutycdVcknQ6zRlGbYh673nWc/p8lRH0/79qimyWnFXYXCboEVRq7UuNLsJAAuCr+2tobZ2dlYGjH7p+mt6jDVPV48R52dvEazgtTIAeDmnNFS6kmuC93nxXZ1D5juf9VIGB2WdGLSaanvHtTiQMQH6+vrjr/ZBsfJ8kFofn2GecjZkzbHg57zaKNe9DCXaVdSIUVS4GGNKjWM9LsyPfe+aIEIvuCPSh6AS73a3NzE/Pw8zp8/v9N5TzocmZ4phoxIjY+P49SpU7EFMjc3h/n5eecZXl1ddQLZbizXCBar+3Hx9ft957393ve+59IBOp0Oms0mpqam3MZEPg+JwoAAgcbc7Owsut0uTp8+HdsIz4VF79jMzAwmJyfdngyGrulho1BiLi+9dkyr1AhOvV536Yw0OBgtZLEFRiJUwGcBClm8vFkWoU1j4zGf547/VUBS0R89etS910W9UypcWXZ9bm7OKVG2xWjN1tYWRkZGXDXImZkZZ1DTA6d53darRH5ligD387HMK6MbfE41rmiY9Ho9ty+QG4BprFSrVdc2PV/Hjh3D2bNnHVglERyop1DTca7/Bb73qoooGsPp06exvr6OxcVFLC4uuhcHE/i22233KgAF52fPnnWpQXyRLseVVd+OHTuGWq2GtbU11Go1zM7OunY0RTGkOCyoCoEKn2fPJ7N8IETJ8p+9P+eO0QHyBl8irO+5IsinovzRj37k1p0qbXUQMe10YmICo6OjGB8fx5EjR2LPp3xIBc8CK0w55npQD6pG9a2cPXLkCBYWFlCpVHDs2DG3PrnO1DnFtEEaaLovtdls4sSJE258NRqyvb3t9mOw4BFfS0FgfO7cOcen3IMTRTtFiNbX1zEyMoJLLrkkFrVl9S5G6yi3+aoPOjXYV8o5H3BVHvHpypDxZXnKB1B9RrsaymlgyTqNmK3BMR0dHXXpozQkqPeAHaNgeXkZ58+fd4Yr5Y/yF/UJ975FUeT0E9smuFSDhceA3SiYGvSUtY1GA5dffjl+8IMfYH5+Hqurq6hWq3jKU56CRqPhIqE2yqE8Beym0lJ3Azvp0NPT09jY2MDi4iJmZ2edo4tOS+ppOgoYVd7Y2MDCwgKmp6edTiF45zgz3Tafz2N1ddXxKauAkseUv3wAV5/Jx0e++U8DyMp3PqeAz3iy9/QZV/Zc+xzUNVyDzO4gJqQ+1nLmURS5DB7u/WMRJvK4yg5N89SMKN0CwL7kcrlYAZZ+v++MaDWMqKeY3USDijhEDTkbDee8Uhfzs40UE1usra05Pc4Kx0ePHsXIyEjM4U/DlEWPCoVCrLAVX7+j8+STNeSBLA4l20bo+tCxRzNFSzVEn3p6whn/N1M7A5dptyDG/hYSCjymwI2LiukCzDflwgLgIgTcuLi4uAhgN8zL/jCsT286wQEZcmJiIpa/CwATExOuz61WC6urq5iamnLg1HosNHXOPjsA5/FVD7NuslYhSnChYV27GDWqQPBAIc9xYdSEnkhWz2FEgUrS5rVrdS4CfgITnd9arebO4Tgp2Ejy5trx8fFSGtkF7OM/C2r1fM4DoykcJ91zpamjuml1cXER8/PzbvM+FTINln5/5z1PzWbTKQUaBhp91ZzxXC7n5kT7TmXOv16v53K+KXx9II6kaQ4k3lcjSZxTbsBmRETTX+3Yq0OEQprPQO8ZeY/9oAJkNFXXNYsr9Ho9V+iD0VMqL1tsRT3BHA+C/CSwG+KPrMI+q2Kwhpn9TfeeUD7RqUGgTwcLr2m3266aJI8T3NFbWygUUK/XcezYsdgLnmnMWP4HdmUP1zCBICNBBJGcd/aN/VJ+VsCi3mVNxSZw4Ltc+JwKQuidZfsqN7nmGN3gPpZer4eJiQk0Gg1nbDHCScOesop7hiYmJlxUhcCIQIcZFORxff+MGjRJ4CMJ8Nrfkwwuy1MhB0EWo41jzLFlJImGJY0CK0OiaGcP8srKitMrBJiUE2oo82XEvJ7OHE3FpMGkz6frhkCVDsVcLofoRV/DdL6NuY8+G8ViEaOjo1heXkav13NOGs4P+daOm6ahkc9JzFIA4F70uri46MaTMknBNMeAvMmIFnUl9zNzXxafhWm6zL6hM8K+f8lHIUyVpEsHBbZpfOXj0zSe1/PYtsokGhB8qTrXp00dZ3om0wFpWOmcUIfzGrZDJxHbBHb3ldOYZ4oyz+v3+zh37hwWFhbc/PBcLbzCrAF1kDMdWsdFU1e5bYNjQT5SjEYZSWzLAit01NFgtPNTKBTcNgb2QceJPGGxuk82pRlaabyVZA/8d6CB9mD5vHD8Le1aFZ4UxgRmNLC0HKx6tVjJbHl52YXYlbHIiDTYmJIwMTGBmZmZ2ItMucAo2FiemouWgpRKgx4CfWYqbY1E6P4FIP5CRcvQer7dA6PjSmWhYWpg951efI52u41KpYLp6WnUajXMz887bx7fzaQCCIDbF6NGHz3QvIdWtiFxTxbHPItHLI2nksgn3LU/PsGv/zXtU72JLOCgilz3wzFaSkNKjQMeq9VqOHPmjCtYQXDLcVaPGnmGwo57Pfgs9JISOAO7JYXJQ9Zg02fV8bQRRQKOfH6n0hKfnVWWKMDVU+kzDNkWf6dXlwKffWZRgpGRESwsLMQ25/KcKIqcglldXcXY2JhLF2J/GU1mOpoSFRLbVe+vj38sr9nr9HwfpYEY3z009YUGFvlPjSuuc/IF04ttAR+OPdOSKpUKJicnceTIESfH1IGloNKmvRCEUA6Vy2W3WToGbv9TYfvAP+/HdG6OJ9eKghwCEYJJu26V16zDiWCH8oZykM4S8stDDz3k9l5xvAnWu90uVlZW0Ov1MD097cZB56lU2nkZqPKH3TehPGINoJBhHzJ6BiEf/4aMLntMI9KcA+pKpgVqOiB5Q6uxMbrHNQrsrh0FyTxOw5xFVVRmkf/Iezp2PJcOl/wL/gaXlhZweXkWc6/7If65dSnm/9eT3NzSkCHfMaVV5aDqAfadn6Mocin6PJf7qbjumLHALBBmgqgRFUWRc1oyLZWZLdoHyknKPTqrqMdDvJUEVC04tvyQFF3SNtIMfm0z7ViILA5ktJxpqtxvR77Vtc8MicXFReeQVCNY9Zw6fqhHiQM1PQ/Y4UdWS52ZmYlhttOnT6NSqeDs2bOu0igAlyLLbIFms+kwYavVwkMPPRR7aTrli+IMYlf2RSOqlKHEWYz6M/LVbrdjmEOzeBhYUGcpMYU6y9P44KAGkc/x+d+NDqWKoDW+fBOjC0v3XHFR6UsMKRAYyuc7ebSCENukgGJpdy6AyclJtyeA/dIXntIzwFQ77rPRTeW68ZHlgBkuVnBH4hioQNSFoUUtAMSAhHrU1BvHcdOoHs+hgCKAyeVysRQxelGYrmW9j/peCAAu8qV9YflwGlU0ytI8IBZc6NiEeCnEN9ZwSrtejWLOH4EF9zQRYDhF/p9gk9Ep7nehQGPInTzIFKzHP/7xsZL6qsQ15VBBBAuS6PPY91gAcA4IBbMEDipQ1WNnjXgLujV1kAaXFkfQ/ut9le/4G88lUOK65vvd+D4uet4IjukRJj/V63U3xoy0kadZmEBfCsnf6VX08UaI/6zMSiOfARv63Rr5ChII+GlYMYJFI5JAnsCWxhWNBYJSGuJ8P9XJkycxOTkJAM6jq8+uz0zZo4Cb/3U/gkavNN3Gjq8CB+Ubkkaz2Ka+QiJLKWHrmKIBoLojn8+7/Rrnz5/H7Oys25uqe26jKHJ8xOqIfDb+pyHPezJ6rQBYHWs+vvAZVj5+VLJ86hsHq2cH4WHOE2WKvsiahgKfM5/Pu2qpfL/V9vZ2rMQ/sMNPmr5EA4TyyI4v5QjnXY05PqNG3XvXfRaPKy3h8aVFXFZq4LISMFP4Lkq/08WDb9kxXBj5VPnlG081pokx9Fl0rDhG1HV0CJMHrAzXCATHhb8zOs11SAeUylQdDwLhJP4IzbGlJD6054WMs/1QklNLcSDHwhazAOLp6nxvHfe4cw1bGQvsRpiI9crlsivwQ+OWBjJf7cM09enp6ZgjBYBLfW63287IKhQKzsA5efIkms2mk8+93k4RJ6YWqr5ULAns8C6xGZ2cmnHEcVS8xUgp9Sr3fKtTgk5UnUPKMVufwCeXQjgsdNwa8INiv//KdChFLgB/ioxdUPR0UcCPjY1heno6ttmVDKXvt5qbm3PXUphSONNaZ+oMSxMfPXoUlUolJmBt/i09COx7Pp9374ICdpUC7838c+6P0edjSokqYBpxa2trTuAqkNJ8c4146D0JSlR5aASNXjb9rVAo4LLLLsP6+rrblMzqW9z4SCFEw5LFLJguwnFitIORQVbMYWqZfbkjecIHbJU/NFLiE8LangX5PlBrgYdG7JgOyGp+NLLU2GaBhuXlZSwuLqLVajlFS+839/EdPXrUvZdKQQTnXnmCHnk1eOiNU0OJwpVVJlkAQXlYgQg9wBSI/GM6k55D3ueemHK57Pbt8aWYjJywL5a37RqnMmG/CXppMExMTODMmTOYnp52L6VlmhHTxbiWH3zwQSwtLWFsbMx5A+mI4Xhy7w2VF41f3a9k+UgpBIIB7HlGy4fkwTRjwF7LZ1SH0vT0tNvzSE+ktru5uYl77703tk6jKHLv4SkWi5icnMRznvMczMzMxEpoE/ixAARBoQIGTTdVI6pSqbioGHmaMsL3zHpM15GCAk0tZFof5V4+v1vIg84PGtSaGtjr9dxaUWfa5ORkrP3x8XFMTU3hSU96Eh544AHcc889bq8GgNg9lpaW3L4XOvc0CpfP71SNW1tbc04AgiqmSPucaeQra5Rb8ulJPT9pvK2sC5GuX0ZO9TURExMTsVRmyqlut4uFhQU88MADsbVFcMqowcjICI4fP74nFVodlJQRGslkNVA6ddTBRyN9ZGRkJ3JVnsOxwirG812s97ewGfWw0i+hlt92soM6nPKOz8H21JGlkVj+RoCrclv1MPmQvEYnbrvdxtzcnNPnjJJQflI2kccYbaBDVB3MXCulUsntycpiCCUZ44OQ5bmQXh7UOLPX63YIpubPzMy4ypUcA2LBdruN5eVlV6Kfhr6mzbNt8raWxz916pTbGkL5ROr3+xgfH8f6+rrLZCJm4Hu2aIgVi0U87nGPQ6/Xw+zsLDY3N9FsNnHppZfGKpOyL/n8TuGJbrfrZFexWHQONY3YAXBVKefn511ave7Z0r1adMZx3zOruLJYEnUNx5uBBwDuZcvMkvGl2IfmkHLOznUWWaTnPpKUz+fxzW9+E2fPnsWLXvSii3LPAxtYIc8KjQguVk64FlBgBEHzYunFWVtbc2WxeR3BKAE9UxC4gMhMWiJTwZP1vhP4WkNHjQIuOk3jIfNTCBM8awEDEj3OPK5eDR/zEvBwnHwphAS1FOBU+Hwmgjstd8xFpWCeHklGTpaXl929bESRgqRer7t7avhan8kaU1mFcBKP8fl8aTqWFMRx7rQksK2qBuwAh6WlJZdixLnl/BWLRRw9ehRHjx51nl9Gbei9oqJW3tM1oEqbApOKnTzFY1Q0yo96Lf/UyLKedTW0OCbMH2f7NJI1DUGNWZ1Ttsf/5CNGkghi+TztdhvT09N7onp0OJDP6bTg3OVyOxXp1HnASCr7SZ7muPvkj/KeVfbkpawKI8lg8ykpmxZIeUfeoRGi1zMtkHs4KfO4t6hcLmNqasoVt9GiFZpWOTY25kq5qxGg8k8dOipzGHUlb+s9lKeUz4Ddfam8n4JnyiDu8+KaZKRdo/P8z7FRoMFiB9wjwfGlTuC6OXXqFO6//34H2Fj8hwCffVtaWnLjouCPRF1iN6frHkrLHz5+SvoeIuUp67DytWV/twaWGlk08MmDmnrK/VY0rjjOuVzOGf10/JCv6bTK5/POQbWxseGKsDCyxfklgNV9RyqfSqUSxgubGM1voZLroRMBP+wCy/06znUm8FC3GdO9bIPyizKDziXe1zpMKL80XYxGPJ2pwK5hqLKWr65gQSJ1dhIQEzjrmiE2Ub1KoE0ngjrsLDawPGL5I0RJssq2NwhlMfhIqpMpD2kUaDl08gYLj1EnA3C8rMYzsY7KkTNnzmBqaio2hpqpEkVRLFqt+kmzWrS4iWZA0UGmet6Os+K5UqnkCq9x7WhqHw3w73//+27/MY133Q6iqduMqC4tLTlZ2+/3HXYkMZLK/qmj1zpPs/BH0jm2DZ+ueKTopptuwr/927+5tN2LQQd/VXGAfMKAe17ouaHHW9MI+DLX+fl5rKysuHAnFwatbs35LhaLaDabsTfCk3l0Q60aI9bw45+CYmv0qIHFPTT8ozfMejQZNVIlpkaCFaIawdI+qTClMKdCUc+MKh62UygUsLq6GpsLrUjGiN7m5mbs+fP5vPNy0iCjUuX1OsahUDE/K9izfJK0APksIY+aDzwrSNTSrzTudf5zuZwDBnzHCr259GBNTEzg2LFjTjBybrSiFME/n4nKknOvQpzPo8Y5DTQqXhorFKzWILcGj/KFGm1cDwCcx1nTD9W40xxwO296PwIRVtkiwNdUP/I7X3jM+SF4YT8ZWaO3L4oiV02UbVPp2Fx0lqxNyiu3/GL508ePaW2E7qUGizqUyDd0emj6Jvf8LS8vY35+3kX4GBFot9sYHR11UTxGTgkmdRy63a5bn3xPHmWnTVexjghN9bPFhsjP+vzanhrn7Ad5j+eogcPx4GsqVGbp/dT41xcrs78axeIaZMS/WCxiamoKxWIRy8vLrtwxz2c0CoADLtpeFEWu6IX+aVEYznka7/l4KwvQTTLsQ7+zT5xfGrN0NDF9SP9YLZZ7kYHdAgEA3Dqkg4AOp+npaZcNAMDp4XPnzrkKjhxDjpk6jyg/dF7z+TymCusYy20jjwhbUQHnuk0s9BqY647iwv/+/9Dv/ygGEsnPNOisk8gSDSCbMsUsAlZd0xfdsngBHaas7ssS2TQiaYzRmQXs6kYtvgLAOURUl2v15CQ+sTwRkl1JfJb1GvvdJ09DAFzxBI0rpkhzDNVI4V62paUlZ+wDu4W66GwplUpOp2sVPjqiOH5sm/PCcSY+Uge8Vq+26aO6z0sdT/l8PpbhpNdR/6sxqZiX48XKxj/84Q9dlWpuadB3urIfiuG4t5ROJmaH6RzQiNe983Qc2XnOaqzb87Pw6SNFJ0+exPXXX493vetdePOb33zR7jtwFUH9rIMb8hKr4FSwqy9i1XaZ+720tOS8mxTyBBv0mPEe1WoVx48fd6CYypgLWlMJqHCAXS+SGjTK+KrwKYzImDSw+Hw0sHRvFoGHekAVmFhwDMBtAlfjUz1aFozzGEEUhYkCZIbf1SPH1Aj1Xne73Vh6AhWC9erymSisKACtARUCFkkekBDfqTKw7et8AbtCjcqPaY8UxJoqEkU7aXXz8/POuCLI2tjYQLFYxNjYmEs5VT5hVFONE41KcE6sh16rNapRRD6gAKeBxTmikuZzcg7I20zXbLfbzmghgOXzaoSTxjOBLEu/sp92XKMowuf+ugXkcrjm+oK7F0GB3gPY8dZyTJn2F0WRS8fkemF1QkayCoWCS8lUA1P37xBI8d66vtJ4zMqsJL6yHrmkc60zhn1mWggNcwWFHI+lpSW3709TZDY3Nx3/MU2NHjgFLNzXxnZZ1VE9+nwWRt81WqV8r9EEywO+7wSrnBPyJqNGHBPyvu5PoQND50L5m2tDU6vZb65D8rPK02q1ivn5eRQKBeepnpubcwYYx0GdbgDcRngCOb7XSwEwf7PRdMsvPvmkeiTEm/ZalasqB5UXfXzI56De5YuEqf/IQwCwtrbmnJqcRzWuOp0OJicnXRn/er2O06dPu3eJ8Xmq1SqOHTuGfr/vXmhOR10+n3fFIQhkVb9SpubzeUwW1jGS66GPHNb6ZSz0GljsNvDQHf8DUbS9x0HF5+Vc+QwsjpOCbNWhLGfNvVf1eh1HjhzBxMSES6GlI2R1ddXdhwUF5ufnY45XptJrdJ7RPwLobnentL0CcxZRUgdGEiWBZPs5xHchnUqyMjHNIarXWYcnHU3cC00ZQazG4ipMdbaYBoAz0Ohk15fQ8x2KdPjRGUMnFJ02dBqwn2rgc/w1I4X4SjEej3EuNVLLZ6eu5TYLTc3meNEZ22w2MTs7i06n47YJcL+V6nfFthwz3pcyTp2yPgOLUWqVf3b+slCSUTYo1nu46H3vex/e8pa3uFfeXCw60HuwsnjXuLDI4PpyW3oUKAyZprWysuLSspiaRkaiYCawqtVqLm2GApa5unyXCb0N6qW0KTK6wNSg4HPoH8EDKZ/PO88XjSlVcOphVbKCnh4UjpNGyHRBq9fNGlkU+gqWOp0O6vW6qwBIo1RzzymIuN8IgAMnDC/TO6JRPKZ6+Raq8k3WRRZSDvq7PVfP4bxSqDLSqS+v5nhyLLkHjbxBQZ7L7bwl/eTJk678ugp7PjfBF1NLyBO8lwIABT0q4KxC5eZttmXTaLkmyDcUvtwEzHQszpWmmhKMj4+Pu/e40Lvvuw/Xw9/9zRaKmx2g38ff/98RPON/dt3vGm3lM/A5WRiEIHhpackVn6Gy49iz3PbKygpyuRxGR0cdmKKi0kgN14ymW2aJDPBuK36RAAAgAElEQVS7TzGk8aqPL9mWrlnKuHJ55+WqmprA8eG71vg6AKbpUZ7k83lMTU2hUCg43qpWq3vSPim/KBu5zumlVx6y0XdrYGmbfF4Fs7rOyXusrknAzeO6twWA8+ZS5mmKuDo+VOYT5ChYUnDOdlVO0sFAADsxMYHNzU1sbGy48ut0jrRaLSwsLKBYLDq+jKKdtCCmwGlUTt9BE+IXa4inAVjfbz59GiKVhZoFwWgR01MZTbJZEQsLC3uKquh+Kuqkcnnn3ZXT09POsaFtMbIwPT3tXthL/Uv5whRsLarC+S0UCihe+1eo53Z05VZUwGq/grVeBZv9cszpqTJTeZPRbfbJPiuvpezs93f2SrdaLWxubmJ9fR3VahXT09POscb1rO+kfOihhxyI11cFbG1tubEnyOXaXVtbc/oX2E1509R75S9N8w3Nu/0c4hOfLla+yWrI+ZwhPrL8yGg+I1eqT6lj1tbWsLi46IwrNfapa1m8TB2EdCblcrk9e+gpg8lf1MnEajYQAMRL99P5RxlIfUTnFWUF9ZeOJ2WINa40Y0AdrI1GwxXfKBQKroARo3o08HlvnRt9V6K+B5YyX58DgNPHfF67RrKQOn8sn4T452LT9ddfj9nZWXzrW9/CVVdddVHvPXCKYMhD51vcNk2GL8JkqJRKjtGf+fl5PPjgg8jlck6QAXAbGzW95rf+dBWdqIi5bh+rH/9JtzBoyHGfB/8I/lSo1ut1J2gZumUJW40A8T8Xl1bfU+8mQS4XHAUvDUmGu2kMaUiZ19LLrS9O5JjqPdSTD+yCcC5cFgjg/bjviOkNxeLOZnnmiXPzuBpZKysrKBQK7hloaHGzLgUIwRX7EgK6vgWsvJSkGNKIfVGBRo/t+Pj4nj53OjsvY56bm8Pc3JxLNaCB3u12cckll7iiFowUqIGm0Qjyh1bLA3bTRThHNCSq1arbdEpjj+PAzb+cDwpK5QFWHiL41NcYfP/738fGxgaOHDkCYCcqTC82vWJce7VazaVjsCAAo8M6J1EUIdeLEOVyQLmIqLBrQBEk0PuswIa8wzVz5MgR3Hvvvdjc3MTExAQAYHZ21vHk2NgYtre38eCDD2J5eRlHjx51nnPuQ5qcnHSR3kKh4PqtykPlk/5XOaUGrY/HkvhSr+d3XX8E5qOjo+4FpMo3wI7S/N73vofV1VXHX/l83r1PjO9Y031D+fzOnqxcbjf6yUg/eSuXy7koeD6fd9FqNcxJGkng/BGM2LHQPXdsg2t/fX0dFy5ccPdVIMF0KgIf8rPKf8oXjqlWtwTgwInuXdB5U2dDLpdzkZJLL70Ux48fRz6fx4ULF/Dggw/iwoULWFhYcCCNUYtWq4V8Pu9e2q0RaPI3Dbd8Pu8cavRoWwCqa94XZVLjIHR9yOjy8Tewm35MGTMyMoKJiQlMTU25dzBpf7a2tjA7O4sLFy442VksFrG+vo5isejeT1mpVDAzM+NSAG3WB40o7ner1Wo4efIk/v3f/x3z8/PY2NhwlR757PpCXhfhuPr/4InlC8gjwkp/BAv9Oua6Y1jsNrD+f/5/AHsj7EqUj+RjjRLwszql+v2dl8murq46R1OpVMKll17qUh913ebzefcuNUYOOP/Hjx93ESs15LlWNzc3XeokK9vRScz1T8cneW5zc3PPPjHlGZ1PHreUBH6T5FvWYyH9rM4a4o1Go+Eq+vHZaQCsr6/jP/7jP9yrZTgmfHbuHXzc4x6HqakpJy/7/T7Onj2LCxcuOFkI7Kbos3+aWky5pMYVDTYWfuJrU+iEYXSXjis6lJgJxOj3ysqKwx+MhHLPNmUY5RgxA/fxMbsln89jZmYmVqSD/Th37hw2NjbceyyVr2mE9ft9N86M9hEj1mo1F4Etl8uuyq8vZTBEKp+sHaBOsjT+uRj00z/903jxi1+Mn//5n3d6+c///M/x67/+6w/7vVMNLF3IaUBYyaaaMDXQli0F4MDu0tIScrmc27AIwAkpCuNOp4Pf+7NZHC2sYyMqoZTrovOKf0L+b692gozGgvUOaKqghnLV46eeeGU2TSXRtBXd+0EG1TQdGpP0RvF51SOq3loN7bIdYNdbp+lF7L96X6iwqMR4L4IsKh6tmEWQSsOAyoulTHmNRhsbjYZ7hxIBoO0bEE7D4m/874t+2fO0Pd851nOraVmqkOntmZubc6XEaSxRmdXrdTSbTUxOTjpeJHBUovAnyNBN8Tb9SIlzRU8x54LRDhrECnbJe7YCF71aCnqZDkWQrzySy+2mVHEdMprJNvmbpuJc9wtlfOGzOVz9c3xZcsk9twIlOiLUaFR+rVarDoDQo0mwynHhW+zV6cG5pcOAnnnyuI5lCHQoH2T1wIYAsOVLlXfkP25eBnbf1cM5Wl5edhXqNDWlVCq5aorNZhPj4+NOITJKyTnR/Ssa1eJ7zjg/6oyhnORc83qOr0++W3nF52HxHAIkRswJFNSpQQMLQExGEQhpRFgNJo0a+97DxP7xj44k7ptkdbdjx47F9nutrq46UMU1u7S05IwGymKez1Qutqf9s/xA8vGJj8+ykpWlIR6kQVgsFjE+Pu6KWgBxmc9ULI0ocR0SoNG5yX2R2oY6nHh/rg8a0ZSpBKxM9SUYVpnajorYikpY7APL/RoWug2s9aro/NXTAey+loFk0zTpMFVesGNMR6vKTwJq7onS9GyVgyQ6qoDd9DQ6lMjLHGM+I79TBnGM6RjhPVg2v9frOXmnOMM+TyiC4DPA0ngqxFu+Y2myU8eBcl4jTxpd4XsnaVxRJkZR5JzzdNIcOXIkluYKwKULqpwi1uOcq+wgJqWOoszm9hLKNFbd29racnpGI6XqXKfx0mq1nEOTEUk10qm3iE9Vpmr6NLdnqNOERjfHFYDbL8hxZgVuPnc+v7uXHthZI4yokcf4HGnzqvNrHT2WL0JOo4tNb33rW/HWt74VAHDVVVfhlltuuSjGFbCPCFZIGdgFqoCOglZfwqpehlarhbm5OSwvL7uUtCiK3KZ33dQNAI8rruDSUgmb/S1UcnPoREUsiuKkkmB0xabiEUyznxpZsCliajRZA4teYRpzVOxqYBEIEtQUi8VYdI0KhwtNx84H8Ni2ekipGNl/RmhUKLDkcKWy856ier3uIihcqEtLSw5UUDAQ5Gr1o1wu516YygiY3YeU5klLOu4DsGm8qIpQUwM1UkreIJBiSgyFNaNCTGGgoQPAeZ10HmhIENhSaNP7Tl7hM1IJq/LhMxCMclO19p8KWfdZaVrWyspK7IXS5AtGGzRCoQYP2+Z6YcqiNYp0nP8fe28eI1t23/d9762qXqurq/c3r9+bIWeGHJLDTRxZEhxJlhzLlB1ZCyQvArwlcOwksIEE8YLAMJA/4gSKkQBGYCBxGFveJEW2kpgybEu2FkpkHIaUOCaHM6JnfW/67d39eqnu6q7t5o96n1Pf+3u3+r2hY0Xm5ACN7q66yzm/89u387t+z2S9Tt+uiLriDF67AgQMSLNF8cYbzB5i4CO4vOsTkTPgDb1H3Iue3oscRI9jcPkzfbhDiXk5DrkiOByOW4/fuXMn0Znvwfr6ulZWVrS+vp6aCNDmfH9/P7UsRjDyt/MtVxgQokQ8yQIAhyMesk8M9tA7qJJWRYdDSWku4CDGjAtvhxdGaIwEgjfwOvf8RucXe+bpiMyV6B84h7Fx+fJlDYfDdGwAuDQYDHRwcJBkFDQiTY618PpGNwSreFjEwWm48yh8iyNGt+BD7mBiTdANyhWwPD8/T419aFUtKRlBly5dSs0diLbAPxzXXX5Kk0OloUeci55KWsUXwJniF/+Q3vqdP6G5vK+T0awOh/MqPv1dKorTEpyjUcHA4QB8WJfDErznNx58on1+hAe0hPzm3Th5iAIgz/M8T8ZslmXpeAXkMrIY+NVqtdL1GCIo7OCvd658HEdkFXwif3uUEXURrlY5TP276PDE2UmaKfzJjav9/f3E/51HbWxspHs5vy7OA12LvURGsQYMplK09AFuwgOhCyL0yNeYoeOwYr7wYBykp6enqX7To7zM0x0P6E3S5LwqnLl5nqeaUQzBdrv9kK7HERjoIJ1Op8Q/4Z3IG3RBUp4xEt+pEfQ4MnMarb4bxv/rXQTd882Ge0E9yi7XdDod7e7u6v79+zo/P1er1Uqh0MFgkHLH3bhYykeazRqarTX0XHamk2JPB/mkxgChDpMiFcCZs+dvS0oGFgIcQe8eVfcyMBfa3rpR1+12kzcBTxiMl7VjZGEEwWy41qNF0cBjvs4oPCKSZZlOT09TpOP8/FwnJydqNBpaW1vT+vp6UthIjcDw63a7KYWnKAodHx/r/v37qTMPQpb0EdK2vF6iSrm4SAGpGhcZWdF74soFcMdAIRKEMYBiSEocOIlyi1KM4cyA2TF8j9x481xxBLIbFb534CuC1Zu/eHclhiu65GT7OVYoP4TB8cTGXG2fv9eioABUeaN9uAc2Glislx9wMHr9PNIJrEejUTqfiDoEjKzNzc2Ea552RndLaN1z5R3PouLAXKfh10U4WfU38EC5Jeruh7NCm2dnZ8mh5Mo9dRrr6+u6dOmSNjY20kG6pHxw4Pq9e/e0srKScMQb1jC80UnEX4eJ05Arkgz39oOD1KyQguxw9VTJiHvAyvknz448zh1mOKqgLwY45QYZqX6ko3E/0YOFhQW12221Wi0dHBykqCGK0u7ubql+yRUXV0yoTWLf4rgoejVNMY33++dRqfXP+fGot6fVu2OBFPD9/f10ILPLzJmZmZTKv7Kykpo4MDwS7g4djBE3gMFBp3/nD9zrynD/F35UZw9wLu/3dT44L0VNo8PU5TrrkyaZIo6Djn8MUo2JGONIc+M+RoWAg9eB0s1NmrRjbzabOjo6KtW4An+e0Wq1kqJMqppnx8AHoQ2XqRc5jKaNiD8+LnpWFS+dZmi5/udyzbOEgP3BwUGSxxhkrJuo1/z8vFZXV0tpmzgNvIV7lmUl2Pl6kHHuUHdHO/PxVOgqPVGapB9CB2TyeORbmqTssq/Idfis6015nqeGKDwDwwzZPBqNUlYU52pxD7gHfE9PTxN+EP3DYYQTGVoh5f6dGEOOg/+2GFCf+cxn9JnPfOY37X2PNLCqlIqLiNoJC6/F6upqipp4NGEwGOjVV19NqYF0TOl0OlpcXNSVK1e0vr6ujY2NhMjdblc7g3+l1bynhXxG89mMWtl5UrAIBeP5gbk7wbgiwVxZHwoL95D64p5aL9QklxbmRw7s3NxcqSMVTB5G0263dfv2bZ2dnSUDh7bBbmRFj11RFKV0LFKuWAOeF3Lh8Q7V63U9+eSTWllZSev3aMrp6akuX76cWvWiqM/NzSWP+dnZmZ555pnEyIiGISwYwPxxvbr+2yN0VcoJ1zi+xbQsPK4cMOxd2Y6Pj9PBtw43Sbpy5UryOhJZBV8whl04uOLM3NxAwUMF3jjDLIpJ0wbOVKEOBUXShVcVLLkXT1y329Xc3JyeeOKJlM6DQklaKM9yhR/lAoPIFc64b654wPjdUPQ0CvdYo6RDSyjAq6urWl1dTXR/cHCgW7duqdPpJOO30+no1q1b6QwyItwrKyslJY9aLK8RckNumuH/KAWlCv48Nzo6UAiWlpa0vLwsaVL4X6vVtLOzoxs3bqT6RnLg+/2+VlZWtL29rRdeeKGUToeSSD3M/fv3df369XQ481N/+g1l2UAHoxktf+b7El17hzePVAML3u+GMQoINOYRGpQSjDmcLNBJs9nU6upqKVMB2JAOg1IT08pwSkhKDidozJ0N7vgCr6AzDPRXX31V73nPexL8oRGuw1n0/PPPa3d3V9euXdPp6WlKyel2u7p+/bqOj4/14Q9/uJSeWqvVdHx8XOLppLcy/yrl83GU4IsMMr6P/zsc6/V6SflaXV1N9ade3/Hyyy/r3r17iZ9hHNTrdW1tbWljY0Pvec97Uo0kc0F2R0OJz0h/cnpfWloqOTl97o4HUVHz9Ctw09OxpIly7lkvPIfrvV7PeQE4RL0TB4B7pA/YuBHtkS9wE3mAMfWhP3tDzdr4+n/6F7aTjLx7924pCs95YbTVhl8TpanX64lPeM2tG6NVeHHReNQ904yni/DSP3OjlBRp6qCRx85v3nrrreRcB97SWMeiZuvZZ59NaZMYs2TVeGRqcXExOa45ogLYeZo/Ed0o35BZyHCcs0TmMY49/ZQf9AXk8vb2dpJ/kpJuAm8lkomOKY0NxW63m5w/6AOencB8h8Oh5ufn1W63Va/Xde/ePXU6nRQxJZ357OxMOzs7WlhY0PLyctLparWaNjc3NTs7m2qAmasHEx4Hny7CpYv+fzeMx4pgVTF6mLr/7UTmRhYGD8SX53nygB4dHSUP9tzcXEpJu3TpUioO9zzv+fl53R0uaXd0V1tZpsNRT0fFYvI6RG8szAjGyYjE5Uqyr9MZPWlWFFh6xIvrWUdshuDNDqSx0G+326VOcu45niaUgatHbPDqYrRW5RCT+oCigIcDpEdhWFpaSofXSSp1aKNeCQNPmjAOlESvr6siqCgY4nXTFJFp9/h+AwuPXLE3MJuTk5OkIKH0DQYDXb58WfV6PaXaSUodoYiQkAbgxonP16NUjoPsrSub4BICF2PJo5CsE/xgn3y/JaWCWoSy53zPzMzoV34uV1Ef6ft+8OEIBr89CogCEefgxowLUn8Wa/U6MTx1/X4/CQDScTY2NhIusWekaoF/s7OzOjg4KKVX8N3c3LgVPAY2QpB5XGTUT2P4/l0VHUZlww0sDGR4ABEY1nXv3j0dHR2l+1CcWq2WNjY2tLW1lZqM8H5oGv7g9Uu9Xk81FVqtd7Qq6eB3/gNlv/T7S9Ek0lHAG97tSgb45WlQHkny3/Byruc5zvM8QotyME2pdnwqiiJFKN1wcDz0aBcKCpHpO3fu6ODgQM8//3xyAjjO4oADLnk+TqW9fv26Tk5OUuE50X3vqocRQYMDvNZExl35rlJIp0UOpvH6GDWp4n0uv+AN1Hi4xxreghODDpXOz3BmUvfnvMxrZuBPVQpU5AukqYJjVc6aaXvrz696F/vU6XSSwwr+yvVEhXwPYiTXlU6GyxMfPleXw15D9dW/clkf+fM7Wq11UuYOtE46Jus7OztLkWwUcKKlnL1FacE0x2UVnkQ4TYPj44z4XDdWq3DdHb+0ZCc9zmF/cnKSjCt39OCAxkmAoxpeCq93XuNRbmS9O0GgV7IFPIsqwsgd7u7UZr/BZ9IDo4zBQQn/kVSiGXcKeadC9Fd3KMUaR/Dc73vuL9zX8L9eLWUSsI75+fnkZAcW1F95OQN74PhVFbn7eoymd6Nhxfi6zsGKwI6C0hUOlF0nChQvb8PpiLS5uZnyv2GaeMHyPNfxaF4Ho7oaOtfBKNfpaJJD6kKD4R5dVxZ9XS44GJ6OIE0UWbxyrpRKSowQoesCCqaJh6Tf76faMg/9Vxmv/hnCyxkVDM/Td/DO0YWICEmWTdrUQ+zAinSdlZUVDYdDHR0dJUWx3++ndDTfK0/J83qfOHfHlyp8ehxll3X6cCYL00Apd+WH3OrDw0MdHR09VCRLjQrKWp6Pu7nh1azVaqkTHgzU02SAZZWRBUOH+bJ/RACybHIy/DQa43nAG0bP82LqLdc3Gg3l/aFG+cMKnKehYli5kVVl/PraomMFIeEd4IALab+kgbRaLa2srJRwkfzy4XCoGzduJHjjDDg6OkpF9xgZCwsLKU+ejk4eRYtKbRVc4xqdFt154t/7uqEDcA7FAuMAgwGlnSgK0bm5uTmtra2l9F3eB76fnp6mw0+lcrtyhOZaraOlvKt+va7r/+7f1vkv/fESXYDfUrmbFutxw5r3RxhgYLAeN2p5F3BxuuRe6MDXF/fAjTiP5lftFYYnhtbe3p7u3LmTYBuVfegEnGQt8IcbN26UeDrnk3mkGwOGlC/qa6rSXqvwpYrPOR5NM+an8Ud3jnhqIClB8BqUMtpfA+ssG2eFrKys6Ef+xrK+8mPLKWWN9xNJdsMFh0GkIzf03MMPzvhwQ5v7PX3Qa9y43h0WyDgMLOgP/MmySZODiD8xlTYqyi5n4765Ee1KMAptv9/XS3/lqvI81zf/pWsaFbl+/b9aU1EUif7hDYPBIOGY15VKSrVYODWdp1XxLNbnvCN+H2ER+eJF1ztvrHIION1DJ55lwf7hyNzb2ytlHrEXnHO6urqqra2tEr4Ab3dUMhdqDr17dOQdDk9wyGEHP/C99qYb8BTkr3/HOhzu0XHP+7xDKu/ByMHQzrJJ1Nj3CxhIY53z/H/9Jl26dJL0v2azmSLS8Dz+5zP2BLmE7ubOjQibiDO+7/G7KmfSu9HQekcGVpUHzb+TysXe3vrcvYCEXL1DHYWi5EF7Soh7pofDoc5GDZ0VNZ0WA50XNZ0VjVK+srfqdO+l5/ZWWef8zRo9d5xoAwpelTB0AePCiHngOSDFptfrpc430StY5R1yZdgZI3PEc4MihaKb53li2tQV4BmDEeGlybJxaHx5eTkVdrIeuj1C9DAolFwMFPbZ1xFh/TiEN42Jx7xpZ+ge5QAPJSWD8f79+2mtwMjP9nKl6+TkRHfv3tXMzPiwYhR3fjwyGxVu3zMYFkodjBe85u8qxwW/qxRXb4ziAsMjZoPBQEW9ru/65CRNjFQhaeKlYj89zamKkaLQRSMfGJOKi6HquAmuNRqN1MhDUlJKiIC2222tra3p1q1bqRXuaDRK6UCuODYa425eXEe3TJSYaTgWvb5V38W1R5qOTg8UUaIHvm/9/vi8NT/MmkGa5NraWoqgsI8YZdRUstcYmTMzMxoq00J+rku1UzUyaS7r68Xf8ZPKf/kPpb3leu73OgGG778LWBfs7D906F5i8Cl62cFRT61xvIs8D2XV6Tw6V8A13nd8fKzbt2+r2+3q6aefTjzBPdRE8Fhfp9NJRyLQSe74+LiU0ri3t5ccatwP3RO9BwbgXJUScpGjKeJdxNsq4ywaZeACPJC0OXj/aDRuR76/vy9pYqTD4/+Dv9vUWTFK3dpw3Lgh7wq2Ox743J1H3OPGld/nymc00mIdZRUc4Z2koHl7a8dDZDh4BtzcmeW8l+FOX+YND2cerC86nuBrc3NzOvyp3y5JunJlfMbdjRs3UkkAc/AI1urqaik9cXFxMXU3jGmTPqbJymmOpHiP703V8x4lo102wd+8UZM3iCJDpipLBh6IDIAfwhOQPfADPpcmNXFEmEnr9MgTMjzCyA1v1xu8uQhwgJ+6YejGXpU+yXBZ6LiEA9sbW/kzHXej/ocOc+nSpSRnpEnNGVE9zqTDkMfpTzOO4+PjUipuVbR0mnHl8In8/CL8+UYfX3eTi8j0ITAQns3zaIKkpNQfHBykVC3ya7vdbqq3ciSqMmj6RU29IldPuYZFXmI+EF+VMRiRU7o4dQNFlbMMfC7urXCYOLPhe4QOjBuvAgTLPRHGPqKXzRWP6O3zwu/5+Xlt/YmXNZcNdPQPfkeaN+mDhLpJnWE+eHDZx9FolJQST8GjNSnRrVqtVurmNA2+/t07NbJc6UPQuQcXPKzVxp2BqC2jy1lRFMlrw5ljniZCxOXo6Eh7e3uq1WrpkFuUCUlJaXX89yiQK5BxL6GJuO8OmxixqzJy2L88z0sHbMPsPvEduY6PJ4YoDgxXjKcpcPwdlQjHc+bpHkIXZDg9MLCIBPM8uiShiM/Ozmp9fT11F8WwoDkJxb3gJKmC8B2PLnv9UJWiGtc/zTvr3/nzPBoZa+iisb63tydpko7b6/W0tLSklZWV0rk4CGGiVoeHhyV4uuJbr9e1+zc/orP/+Lp6ea6FbKSFvK+5vK/zYpKyhVMFnIVGYnTA11ql5HqUxr2zXrAN7bsi4xENV0yi4eHw9Si781rwzI+7uHv3rvb399Vut3Xp0qWSAwhFDL7mqZaunHQ6He3v7yc6gd/t7u5qfn5ey8vLqckFBr03KPLahYhHUX5d5Am+6DPHPb533kdTKOdlRN8PDg5S6i0Oy/Pz87HjLxvqcLiQzmuLkSjnaR5ZBL4+T3ceOY3At3h+9M5P856zTlf4arVaOgzYG3mAy/7bn+W45bya73hXo9HQ+Sf/uWZ+6fcmvuRrdP4beYpndbA+mtWsra2lGlE3cg8PD1MzBxyxnkaIA/pxUgXj3xGX4nVVn1fhYnxXxG+PMBFFxXlOVIbaIyKprhdiMFPLubS0lJw47JnDHFh7Nsrs7KyazWaqC4VHEMVHV6pysDlPd/3RnTSSUr0XGVHx/ir483lMa0bucaYVDnzXa1yPlMpZO9xfFONDip944gn1+30tLi6q0+kkuOJ8PDg4KB16DB3Bx+Dh8D9/70WyscoeiPj0bjSyLjSwIvJE4EXFxT0vNHngcDiiR91uV7u7u6UD9+hyx5kxeOFcQPD8Xq+nWvbA+5kVmilG47OwHkROqrxizM89mJGp8jdIz2886tzjRBTTD6RJm9gq5dUZv6ftoCBjvEXhEhE4ekS83gXGe3p6qvPzczWbTa2trWmr/kX9zoW3tPNH3tBnTj6g87/7MZ2cnKSGDrwbwYDCure3l1KzRqORdnd3k1dnfX09GR2kFeJNdm9RXBOCOq6pas8YHs6PCi4eW86uAnfwMt+5c0c3b97UwcFB8jAeHR1peXlZa2trYwN0ayt5T4nCwLxu3rypo6Mjve9970vGI4YbwsQNDhRu1oQnNCqXFwkxT0PBceDt8ME94EHL+dPTU7355ptaWlpKKajgGj90S3TPbzTkfADnKiPLYeYHNHr903A4PmSTmrZnn302RaVIIXYPY7/f1/b2dqpDuH79elIsUBCzLNOTTz6Z0j3W1tZSRzjeiaHiY5oAmOYxRzl3Ael7jUew2Wym9GFPixkOh9rd3dXbb7+tu3fvppoM6O65555LHts8H9dpzP/wZ1UUNd38K5vpIGpXTKEHp2V0BrUAACAASURBVIHP/c0f1uwf/JKWHhTXZ//s+9VolD3+rVbrobUx3JsKbIChn5HmdXWejYDwJnXO62HgvdAVh9VGGvc98fTVOFe6F4J3h4eHunbtmi5fvqxnnnkmNR5AkYKvg+vIojzP1e121e12tbm5qfn5ee3t7Wl/fz99zwHKRVHoypUrWl1dVZZlqUYpy7LEA5ljTJ0DrjEiV3XNNJ4wzUmFUorc5FBh1koROwcsd7vdlEUxGo20srKip59+Wjs/8dEH+FWkZ3pEwnEQmmdfcCT5PIkscyi2G2szMzOJTztc3Hhzme/RKPhKrVZLTRB4Pp55p1dPe3IjnQ6Lw+EwzcM9/rOzs7o0s69DTaI70IhHUph3NLDgC16vNz8/r4985CNqtVp66623UgMLUqCvXbumXq+nD33oQyUDEN7mNOL8fxp+VOFXleHqP/6OKnzze/wa9hcDEV4IX0R3u3Pnjm7fvp3O3USe0rGSxiyrq6sJxt7N1w0tBrhPpI95wK9IGyeSG1MAnee4ge/8jjS6fr+vdrud+Fc00J3foG86TwUX/LgCHN3omshp4BadAzh1nT/iPONA8S9+8YtqNBo6Pj5OzqCiGDuVr1+/rtPTUz333HNJH8rzXIeHhw85T9mnKtyqwpeq/x0G77bxjmuwIiH6d9LEs4OR5OlkFNNxyKg0aT4gKVnvhEk9muIbdjyc18loVqv5mRrZSDPZxFMOI3Uh54TA3xFpfQ3u5fI6BWnitXVvpc/R06J8QKz+LpRwhEZ8lw9X9Nyj4e90jzGG3tLSkmZnZ/XMzF1dqTdVU0fN2pnuhxQbn597t5vNZooi0E0JZRklAzgtLCyo0+kkZuspM6x5miI7zeMWBQifR4PGDQk+h8HRXceZHvU+1AKR787eSkrCGgPh8PBQS0tLpcJtaoq8DsU9+45LfO+45vvr63KmD4NnDXyH1/z4+Fi7u7vq9XopvZO0Cz8fCy88EUf3kLny4Uw9KoVO/+wlNOzNVXyN4BZndcDsPe2D/4HfYDBQq9VK3l3SSYgqwPi93hKvOdEdhI7PZRqTvwjX4nUMNx7w1KLYAlMiUEdHR4mGiebR6ZEIQ71e18ofe0mr9Y5ORrN67s/d1Vf/m1UtLi6m/XH4+t7kea7+339BBw/gOz9flPhBdD5F/hGdNhhRnFPj6VY+4AfMDaeER3Y9mwH+Ar16dAqFy2Hrhi3zxaFElJmo5qVLl0q1Hq7seIoY+4tSDkwXFha0srKSDuokQkpznE6nk1q/41jhx73ryJ9pyuk7VTimyQTm4TgPf4In12q1FLmiphGZQ+3fxsZGmktMCYzyl7+j4sdwR6KnB/IdBql3VOM77o04GeUG31dlfLhR77y06h7vQudROXjS8XAuPdfnUpV54Jkq/gM/gAfSzIYjNuDZOJYODw9TlBTZg8GAQ89T3nztDuOLcMnhPU05noZz8R0OZ3AO2iZdD15wdHSU0qSHw/H5YdSj4iRAhjss/X1VtAMdu3FEWhw4VhX1iwYn31dlJWEse3YVfMXpvgqe0cmH48czPbIsS8+Hrj111aNqblzi5HOdoFarpY7cGJrAyZ21nMGK02NpaSnpFBiWzpun4ULVqMKfadd+I4/HMrBA6EcRrqcVQGggIEoTyjm5+HgYVldXkycYQqtSSIui0Nf+h/dr9T/rqJWfjdNhsn6JONzo8Lm7wHgcBADxogJIW173vMV0JJ7nnjGeGaMZHgKPc3AlygUMf3tqpL+P84E4sO7fmRvDsa9xeiUeGp6NJ5o5QLgrKytJOJPKidJFO3oEiHsR3UsamX8VE5q2B9NwzfeI93leO3+fnp7q4OCg1PEHL3q73dbGxkbqUuQhe/cW1evjFqbUL5AqKikZKu7xdQbsCkc0DNnfaOzzG8FA2h8KL3DtdruTWpTed2uhUWi2+TldunQppQgOBuP25/4MPILdbvehVMGYXuPz+/TfP9YP/sHl9D14h3fPlRX2hu+pIQIfeYand7iC4/VYGxsbunPnTkpboBYQIQ0deL1nVEQibJ2mIm25A8aH3+vGIO/yQnUEIoq5N/3AW7myspIixURkrtbONJf1pXxMpxjF0GWv11O3202NbFypcCcP/PVxRoQHvJOIE4q5K9kohHt7e+p2u0kBca9rp9NRvz8+n416klqtlo4ToHbC98cdSVG5Yg+4vt/v6+DgQHt7e3riiSdKaaeuuMfPnB7h8fCHZrOpdrtdqnnjqA4cg0RN6J6KB93bMjtu+bqqHHsX4dlFCow0qb3E0+/Rcgw9lFpSfzD+2u22tra2Ujt7eD6GsCuMcT0X8fJowLohQEq2G1dxTQx3/Dn9wNccRvBBjOLo5HLjnVGvj5sMueHp6bP6xT+gopgYh8zfI2TAzWWGO5nhZ8xrdnZWm5ubSQ+6e/duKbX/5OSkxJe5d35+PrUex5ERjSxf7zQDaZqhXvX/4zoIoCM/j9PPokSmcuYme0HjFeoFkQ1Eg5HHKPpRh/PhDcxi1oF/x3wjz5cmTk5wk71jtFqt1NKcfY8ptE4zzoPgx/5ODJnRaJRghu7ijdKANe/xORXFpJ7cneVbW1vJITs3N5ci1+jVOJE8nR5aQJaDf/Bw15Ecfv+/MTV9PNLAqiJWVxqlCcKy+VHBcS/t8fFxag/O4Y+kDLiC5IhaFJOWqIyd3qrmsr4u1cehcxDL5+mfgRwonl7k6kgTvRded8N83GMrTeoLuMc9qMwBARFrRBx+cS4O/6rhKVUo43ggiFhs/4cv61sXXpM0ftdXeuu6/xPfpuFwcqhfvNeNW85PoDsXDJB0MELaWZalvGv3glYJAH5P86DF66d9j0BEqQV/SPFASfRT2FFwn332Wa2traWDC4lu8XzvJkgYvdvtplQNScmIRGGObWirFHrp4SMCIj3xWUwhQNED//AEX3/1GdXO+1KWqXW5lbxWTocYOqRE0W2Jei3aOTOi8lMUhfKzfklwoVBi6KEMuZHC/GkL3Ww209rZLxcg4DX3z83NaWNjI83Ba2NiC228xXhQq5wpcU+m7dW0a/xv53f+g2Ci9g/DNs/zlBKMYd9qtXT5P7muRj5QIxuqkQ2VZyM1NP6bM40cHnNzc9rf358aLWf+DDdUXPD7tb5u9s27cbkzic88qrq0tJRShhnNZjOd7QIsUBIwTCLe8w5PCXalx5UI2jz3ej212+1SypYraB5BcMOYfXRetbS0lPjavXv3khJL3TAH70qTWhs3qjFgHF+iIlcF94vwjPsi34B/o9x6bQV46EcjMFgntX8owSh2UWHzPXBe5rIuRofYL85zi3W+09bsjkNkphv5KOsYIV4v4uezuSEU8d4V6NnZ2XQ0iaQSL4zRNXAp8hXwNSreHsWlvuX8/FwLCwva2NjQwcFBchSBN2Qk4IzguThLkc9V6YkXKbxVn1fxuov0jarncC16G9FqDtXFQMIpy7E04IUbYjQvwtkbYc+e+uB/l18YNNAH+DTNQKvCaXdSoBeyD7737pRwAz5GYKPjUpqcMeiRP2jZuwJHQ9Z5o6TSeviMVOHbt29rdnZWnU4nrYd5UI/lgRH2w/VIdwxFXeZRhtQ7watvxFGT9F9O+5LNjUCNTN8VXYiL+ha8EqPRSNevXy/lgUtjwD/33HPa3t7W8vJyQlo3QGCEMNfz83Pd++y8XvwnTWXfPvbGnzx/orMX10tGmSt9sXW0W/6+zmhMxU44btE7IXoUCoW+2Wzq5S8/oVs7s7p5bUZPXD1PAiAKgWhw+Rp8jtIkrbLT6aj2+35RJy9eKtUOHR4eanl5WR/7M/9S39P8DX14pq7/5eiKPvu//xHdePEDyUvRaEy6YPmBd+wL80Fh39/fL+WUo/Cur6+XGNfBwUGCu3vYq/BrmpHlTMkFOQN4tVqtVH/F2RmkyZyenmpvb083b95MQoxOPZ/4xCdSQTcCWlJSSOjEyLuB1XA4TEYOHfGAx2g0KnnRwY1oZLnx7Ya9rw/lldqqwWB8hpKkVNtIreP912eUd86UnfV02r2ste2TZBxjwKAMLi4uJoULw4sjA3zfY2SkVqvpA9+0mOA+GIzbC1PrRxc2V+SKotDx8bGOjo5Uq43P2VlZWUnte1Hu4nugS9/rw8NDHR4eJlgNh8MSf+F90VnAvvD8aOTy7ujhjDQXP/c0GPZjfX29pOjevn1bOzs7KYIKnW1ubuqH/9amPvq9x/rYt7+qmXygQrkGRV29oq56NlItG89l/puPNfyNp0q4QY0Mh6iyv1GgO3+rSrmKvI5rPELtzWpoie24ROYBtbZZlpUajiALoDXoqiiKhwx7n4fvmUfnqfW7f/++dnZ2dHp6qna7ndrbwwNPTk7Sff4s32vHAfAG3MbxxOHVnrFw+fLlUuoccoV0H+fbrvxG+CPPooyNfzv/c75IahUwxvjDyTAajXTnzh1dv369lBq4tLSkJ598Mh2uS7qe45BHzz067U5MVwDBsbg+9AL4Mop1lAduwA+H40YIRA1xSiDbbt++neqXoHOiHv6/e96jE9RhjIz3swgjrjhvQt57XSu47P+7cspnNF/whlk7OzsJ/shN9A03Opw+wMto7FTxK/+7yhirgomPKsXYjRXqO4m2c4A8kd5er6e9vT1dv349GVcY0FtbW9ra2tJTTz2ltbW1VBeMIxQ561E+eL4b0J5N4FE+8JT9X1hYSOeBOhw828QdZ+A1uIT+yBw9Pdz1uCpniOM6fJD58r61tbWUxeUGNo7SGC3zFEWf83A4VKvVUlEUKXpNXTlzRa8A7x2u4Fk0dKtwZxqOOI1HGftbfSwtLembv/mbp37/y7/8y4/1nH/tLoL87ZsNwvmm48l0716v19Pm5mby5tZqtVQg74IH5gsT8xTEz/7FJX37X5Zu/4/v0cLCMCkEjiSuTEjlegSpzHSmpS5gJNZqtaQU4t3M81wvfWFd+eCBxyvbUFHLdf+mlBdDZcPJe2HALsxiyoHDt8ryhzn1+30t55M6KqI1ROoOhwv6v7pP6eeGiyp+7vtUFGXPLso3IWpXpng/DGRpaUm7u7tJmUOROT09TYKU9vgufJzR8VyHeZXRPo2AoxHmnkKPfLK3XuDKXlFX5uF4FF9GNOwkJRh5u1xPjZKUajRgfjEa6SMaiy7IXbig1PAuNyhICVJRSKORssFQWW+g3/jSJX3gm24n5QF8YU10QSPdCeHh9RLT5uoCCY8rz2KvXbGla6MXOxPpxMHgPAEh5vswGo3UarW0u7ub+AJe7OFwqMXFxeRhxPABN1wBjDhYtS9x3U6HTovgmdcTOb8riiKllHEMAumZS0tLms37qmmk24O2OsM5nY0amvnH36ne7/0VHQ/nNZuP8THPyodHOkwwdGItRpUgcx7j9FUl8Nw5wn5i2KBcuMJAW2+p3EEOZRcFMxruKI3MqcoYiQM+hzGPkwFFANok/Xw4HJacea5E8bzo3ZYmRuydO3fSvURrSUUjBc5TejzC4fQcf1fR1EWKbdV+8i6UcfYFo9Wjh/DtwWCQsg7g4RiUXncRI4YOOzco4mBf3cseU5qq7mEv2A+PdkhKac40XGH98/Pzpagbyjj8AJqMcH0UfTguOh+IinPkl+4UcOcpw2UNLeaRp8yXM//a7Xaic9bq6YOOt1X4VPWZz3EajU3DxzhcR8jzPOEEjYukiTOYrAtkXb/fT4Y3jaakiW4GD/EafXAKZ2mkJeBMJAZ8dh2H9FTHuQgX/94NMeDB/rEOaouphcIo8nsc/t5K3lMRCVBURep8PyJfgG+5PgP+03QJWUS5Cs4unLjIY+QZGS7gmfPuKpzzOTqfe7ePx04RZEwTAu5B8LQtbxSAssE4Pz/X1tZWijiAaBgJIAkbBeGAQCgXn/2LUrt9WkJMb1PtDAcBzXNduWVE5I6eLD9Tajgc6td+fla1/vmDmyXValKeqcge/NQn+fJeFF01osERFcQsm9Q/9Pt9nY5mSlE6FNparaajn/pW9VKjkYdTPBEEvCumd8IwiqLQ4uKiFhYWksJPSgZdzjxFyjuIOSyriO9RTNznXHUtSo3XHnjuPrgE3Obm5rS1tZVgijeHdzCnaGQBL96FIYBHEjidnZ2VOgxVpW+54eXv8XngucVIOT09TU4I1o2HqshzZXkuaahsMFI+GOmVr1zWx17YTSH/PM9TqhfebfYPOkIRcUcDcEcQMEePCntXJDduESBEq/xcHjeIq56HkQWuoUB6wTBpk+Cfp1d4DvujFImqUcXnooHv3kvHf3iMe1+BLQLv//xLc2q1rmp9fT3VINQbddV+7rt1/MlfUr+oqZENNSoePgoi1ilgGMf5Ob5JKuGj05P/9ggg/PL8/DwdCo8iBC546i37D12hIKGExlbz0clV5WiKa+c5GK3wcTqXgrPwWjy0rvA4nXkNa57nad2SSq2lMeyJ6LiBEx1n7lmvUjamOdOYE/Cd5mgCB9xjj2IG3Hu9XuoSy3NZG23NSbWlHjCmm0XnAnsHfkgqydwosyLPrlJq44AveY0hdF6r1VIU7ODgoER7wN5rofyZUZHmc09jj0qxwx7F2ffK8a2Kl7izj2egM8Bvyb6gQyzzQSH2c9Y8i4Y9dlzzKPVFo8ph9E6Hy0UMCvg6EXycZ91uV8fHx0m/Q+eYm5tLjaaAF3uAnPIoUpx7FdyBNzqIX1NlvLici4YXekTkmR4okCalGmS5eKOjCGPWuLy8nJ6PcQqfmqYD+mfMkXn5b5erXnZDmQNzlZRSUtvtdto/9Hfmg4M6yo+L5Gc0Lr9ePPu3fVxoYD0OUBwBIDQv0PRIEkhJpGowGGh1dTVd52ktMFiG50yjxKBwYbzBiDAcuM/TD/jOUwVZB9dMM34YEEStVtOvfHqo/HgsxFSrqWjUpYY0qud6/uN3NBqNEtHNzCyWCIhnufJapfg4nKUJQQ+HQ+39+EdVFIOk0A0GgxSdicIeWLghgjKI8cG6PLc/y7J0Ts+NGzcSE/Sucd5kwoWA5/1OW5uPx8E59wzG8Di4hPHQ7XYTzIhe0QKW+1yxcwPTccHnTQpJo9FIChdpHxwi6WluvreeluXDlWAMZQw2nslcPA3t/PxcqudSvSYNhjxM2WjSEtYNM9IEYv3YYDBIDSOcXqoUQ3DJDXuPFHMvOEXaB/D16BXXohASlQJPgQnCq9PpJLoF9sPhsGTkxM5uXhD/uPhWpRz6+t2p4Kkcvnba+nLPYDBIqTTr6+upIx3KI8+q/6Nv18n5uWo//IW0Z7SSdhxkD7xmzfEtjpi2FpV6frvRQZMU9hLHGWenuBede/FOswfwGf6WJh0fGU7TcT6RX/rf4EFUujDwnZfDExkYat5NFS9vNBLBedKrSd3CWefZFZ6yGnHKR9UeXeQQ4DvnfXi9Ueo8RYhz1Bi9Xk+Li4vprCF4HNHx1NwhzNXxgt8ejfBUdxTVuL6Ia+xfNKDZT5wz1F95Nzr2N+K8R6tcJlQ5+rgmGrSPcrYxR3gWsPC9iff5/cgr8GZ5eTnV/XFG4GAwbgZGLZY3kopRDo8CR4PejREf05ybUZm/6HqHoeO/n+NF5gT1su5MYx2tVivtGfjsjg8M2+gkcsewD+aF/sKa3DEK7lbhnss1d/axx+zN0dGRWq1WmiNORho5VdVkMdBjiVC6kep05MON58j3/dkRTsgp3unnnjpPOz4+Tl1t5+bmdH5+nuQoztOox1U5kKYZXY8yyL5Rx2OnCE4TBvx2JQNmDRMAUVEkQFS82TwH5uMHj8YNxLpGoSOa1Ol01Ol0lOd5Kq6MaQ4QA4yJAWHxt6dJeIjZDZJf/CeFaid95Z2uspOuNNNQkedSLVNRy7W5/ZKkjZLnhedKZYUiRsycyVcxENbuHhYIHEKqem4Vo0UJl5QUBCckhO5oNErnd6BEcC8pJq6oVxlYcVQx9CoPYhVhupIRG6qAOxiO4GCWZVpeXi6dnQLT9WciLLzOzBmSVPbAw1jxKvK3MyGftytJ0sPdzTAyaAyAUcLcSHFEyI/qs8oaNaloqKjnkj0XmsPAybJMJycnJePDT5WfhmvRE+sprlwrTVrcsyYiV+yTCx+UGgxK2haDx+6MIEUGryhwJyruETEXWNHrHIXDRaPKEHZnkhtZbphDt0Sw3PBsNpupwUCMspPGwl6d/vQntLu7qzw/SgoDPMgNyFhvUmVgOV/jf1+P8yn+JwJMR1L48tLSkur1un7t823VzsZ7ceX5t9Jz/UBp9g4Dy/k4ipUra/6/K0OOB41GIzkz3Pvs0SYUWODhyraklHbrDTz4jPeAc6enpwmnvZaXNXgkJeLbv4nh/MNrfpC57BvnhbGXRVGkNuFEDYAXDUjiOjxC4/LYDUlJyRFXte5orEUlMjoP2RMchkRu3GCYm5tLzWPAK3eGQf/sjxtQEb/4XRVRJULsegj4RfZCxF9+835/Jp8BSw6GPjg4SHWDkpLDCb2JLpXIJndeeBTG4T2Nvz2K911kgPG54x94Q/09awT/2Ed4d5ZlyUj0M67goehKTpdxeAMGnx+46fuAQ8r1qaooKrzLz7yKshGesb+/n6Lj0B+GFmnrZGxEo5fh9YhVBjqfR93UHULgPfgadVmnX+BNuiayg1RBYMaRAL1eLxll0ZHGeJSu9m40qnw8toHlyOGAhlmCZHQ2cy8+RatsojT2HnKYqCsGeGalCdP2aECtNi6WPzk5SW0mvdXxwcGBTk9Ptba2lhhmREafN+txi597JOln/+59jeq5vuV3nCav6Fd/eUmN+8cq7h9qdHqqvLmorF6X6jUVjZqK+qRbmKSkBL704pakoT72wp2S5xul4Zd+PtOP/OhqKfUghoyzLEvtTYnewYiLokgEj4BknXg8PMWPsziGw2FSXtkvSendKOhbW1vJmANe5PhzaGOejxtPkENP6/dpBvqjFJFonPh+eXoMec2kINDlEM8g6ahPPvlkqmPCoHSBBIOp1+s6PDwsGT+uZBDto1uS45QbTw5PGF00rHwAX6I5zWYz4f/GxkYyVgaDcdvb8/Nzvf9jx/pX//Ky8pm6igcG/vs+vKPR6OH6ReplaLEf98I9YgirmIqAgFxeXk4KDEpcLN7FKFxcXEyRLDdWwUPqzfjbFT3SaZaXl7W/v6+joyNlWZYaMXir7MXFxaSkdbvdUrT2cYyrKqMqwggajB2wgB9RRxqAIABXVla0vr6e2ujzHHDHjbbRaJQ6KL766qsJf4laYoy5ku0KhuMf+8dzY8Qc/GTdPBf+s7KykubKAda/8I9Hatw/UXZ6JhWFbpxva7Qwo6c/sqOiGB8oT3aC4440KTqPCkHcB+7xuoFGo5Eisnj+SRN1pxMF9+12WwsLC4leJSWDnrRCDHUa/6ytrSU6vHz5cjqLLc/H3Q+ptaS+C1yA77HnDmsUlOgJnoZz0bHI/oAn4DvRKHCwKIpUV9HpdHR8fJycKGtra3r22We1sbGhoig0+we/pFo2Up6NdP9vfzx56jGQuc8jkOAaSrQrw+B0nHPc4xgtqookEa3BWUqtErVY9Xo98QnnXcvLy+l/nL2eyRHpuQrWvk/O0+FvOB28EVIVbvv+u/GF4n16eqp6va6rV69qNBrp7bff1snJSaq14nw3UunQPzBker2ejo6O0vOjYRWVevSbiwyviINVnzsPJKJNR0pSHqVxy/n9/X0dHh4mpxkOcBw28CT/X1KSee4Y97R/5DzyMDqjnR/G9TgeerZGr9fT7du3Sw1t+K4oinTcwfz8vFqtVtLDwAd3IN66dStlKbDuiAuuz/gcHR/R19h7T1d2eeYpieh6wB/DvVabHCdzdHSU8JDjLrrdbjo3tdVqaTQaJbxjXp5C7XN+HIflv0mn02/V8Y4PGpYeJjxnaF4Lw3UIMe4F0ZaWlkqeI5hZ/D/m4cJU6/W6jo+PU9vpRqORckzJLY9ecPduu0ds2siPusrmZ/R//8qCilqubFSocXSg4v6hhkdHDwCTS7VcAoEK6ejeCzq6J6kopELKikK1QV8qCr30qy0pyzRqjGu1VBTK+yM1TnsPvb9qbniz8GS4hw0lwtfrsIQA8cY60UNA7rl07yBKr3vCXQgDZ/AAQ889i+6VeRRRxu+jUHZhxv8o5O7pgSF5cwtXaMElVzQx3J2heNTRPfEOZw7LZr7uCY245v/7O4Czp/b5OSEeXYD5Kc80qudSJhXZZA2+Rj5DWcG45p3u8XJm6IqwKx3Ly8uJ5jBmPHKHIojQdWXIPYkon9wP048DHOR6byPuUWePpruC9Chcq8K5iHd85xEycD2mMGEIQZfNZrNkYDJfn7PjN583m011Oh3t7+9rbW0tRUqp7eLdVQ6wiGtu/Mf9dh6Cw4QI8Pz8fOpYN1Yss3HEvl5TNipU1Goq8nLkPcI+8mH2fxotTFOOaGoijekPx5qnZLZarQRvaJT34XDBAUSEql6v6/3/6TXt/PUPJqUO/OXsRu6HxzieEX2MacdV+HSRIR+dmXFPXS4i41zBckMAhQzjo91u6z1/+Bc0LHINlaumkWrZSLU/+iUd/MRvKxkFHknytEBP7wVvo9LIcEU18hT/zvkpB9aD/3SpdH6HTHLehNPBI5c+N+7z/XBe7rB3/SXun8tOV3JjJIl7o4x1/tTv91OaYLPZTLhYFOWmKsDB02/Z9+gAq8Kni/6OhqYP/z/uHz8YWkSl0DFwLHvauGe24Ex3vucROYefy3T4Hg48HPFxnnEtzMOdzrxjMBhUHmfgte3UodKcxHUq7u10OklOn56ePnTmW5WDJe4Bv4tiEhHzhh1V++N6HWvhGABPz5Qm2QPA0fUJdA6cRp5u73qEz3GaYc78qhxo75bxjgwsZyY+YEiehuFMijx3AE8+f5XnH4YRlUMP30PUvLPRaOjg4CARrbeUlcqHMcKo8PY50fka098PPLQ1aZx+NSxUHB5NjCtpnB5Yr6nIHhhLg5GKByDK1oqFPAAAIABJREFUCo2NrGGhvDeQRiNpOBpfNwbe+Ccf/65i5mmzHhhSpIzBePxsEdZIukhMw/GUCJg9MIaAUY7w0MJEgC9CDsIE1ggzF2zRu1L12/HLcSqOqGy4wewRu+jxIgJC3YHnrbMu8MHfi8BAafP1uIGHEodi6kLb6SUyGmdQDg/SLNhPPGZREOFpK4pC7/vwjl596YpUFMqK8lksDjcijHRe886P0Qi8SEHMsixFE4jioLByX6MxPigY/IzGC4qKdxEEzn6YpsMdIw2PHrjoPAS4ucFXhWOPGlHx8Pd4QwGPRkuTBh+swWHleOBGtStdOARYQ7PZ1GAwSO3eV1ZWND8/n6IsRTFJ5Y1CsEqJrRr+HUY40TJvoiCNa8I++tv29NJnl7lZo/m63vvBayqKcj0uMON3hKvDeho/8OuZA3QGvt2/fz/RKdEkbxfP3pD2g/JKugz7OdSku2q9Xi+dFQO9QTcMd4pEnjvNYH/cUSVroQne50a714949ImI3sLCgpbycVe2s6KhYTF5vkeiWRcKktfbsYZIc74+PvP0Kt9/5zPOd7JsnIKKw4R9ybIsGR/sIwqgP9fTj50W/PlxTpFWqq5BniD3uN73N8o13yue6/xgMBio9SOf0aVsoCeGC9r/k82UeoYThVQt8NFTQj3dMBoY02hrmoJehWtV1/m6PAUTWqOGSlKSB26Ieip3lo2dZKS7+48PPsPIwuhwHCIb46L98OfF53MEAP9jVLlxiAHjqX+8c3FxMekKHnVCvoJH8f08J/I63od8dNz0fWC4PCSFkWhv1NvRgSkVYA44MKAh9tWjwO7QiDhVxden/f1uGV9Xm/Yqq9U9Wa58gmxOEEVRJI+HM1IEJgyDZ5FGyMY6opDO5fVAIIekEjPw8y689mbaGI1GKno9qddTft4bdwfsDzTY2y9dl83MqKjVxh0ER5I0etDVTQ8iWIUy3oVBlQCXj9MKZ+oazZYbKzCHKiFGug4I7/nxFKGjXEcvAkRBLRvXQMjO0CIzmpmZKXnZPHTttVAIvirDx+fh86kSAI8arnS7IPUifRQzjy75tUVRJGOf9Edv7Y7CJZU9d0QXFhcXS52DohfT9zEO3x+UlpmZGW1ubiaY0orYnQEu8NmLIpPy4fj3K19+Qi9822GpAJ3roClvnDDNoxwVXmf0PAtco/EBz0P4xn0F5tQZgGtuaEVY4e3EceBRWI88uuIJ/kdFsIp/VY0qGPjzHM/BFdYa20WTyiWpVB8Ui/UjrPDQci8HF6+uriZlJc4twpnPq/bAYcIPvHtpaSm11nc8g9ePZuvKH8x388mXlWXNBOcqJSTCsYpOnFc4b/J5QvPAnQ6bGF+Li4sJJz3C7OlvpHjBL+Fd9//2x1WvTyINpKl5aqanf3MdMswdg1X4FGH+qOHXR+XWIxnQBanZ3tJcUukg15PRmAeejmZ1VjTUL2qa+2e/R83mxDgjfQ189OMGoiJc4kHGx6etzzuwxYESvra2VoKht8ZmDuwxNBZlHs/ze5wXSuWmVr4OhkcpqqJ003gJ++Tyz43SoijU+sF/qkuNQzWygfJ+kZphcfQJUQWMFOiSvY6NFHy9VWOaQjxtH6ruASbRwIKGgBFZSxhD0iSzxR2uNFipcg75HKLB4bIvy7LK8/Sc/0SjJqYAHh8fJ4PKYc4h76x3f38/6QPQPDoGjlbvwOoj/u/GFd/Bz+Ez4GyVQ4K/0cEw7oikAfsY3YbnAVOeD8/AWGRfwUtSYh8Hd6bJs3fbeKwuglUeEX67p5iNcGIjF5R0JDZ4ZWVFCwsLSYkcjUY6PDzUyclJQiaIFWVwYWGhlOPrXpHt7e2k2FCDwzMgbE/d8pQiSQ8JdJAuW5jX8OZtFYZcCQ6NGeWrbY1WmioatZLhlByDWaasyFRkxTjClY8/K/JMRT1XkWd69oPXkyKV5ysPKSVOIK4wUfy7srLykPIbFS1yt9vtdqqbil4fnoHygaDmucPhUMvLyzo8PExMZDgcpmJ+mBHG8+LiYhL4VQq8M8EqRSsKAn67AQ+uEfXJ8zy1UfX0saWlJbXb7RSpca82DNqjODBaj9bBUL2daVQ+HXeisVf1HYqme3HzPNfm5qaksnfXhSk1P1FJzYaFVJOKbNKV04W8w1GaNCDwur9oRHD9NAOIuQEbjwZXKZXdbldHR0dpn/wwU4SCO17cEUDEDIUPgXJ2dqZWq5W8v/CMqPBWCfCowPtnbrizLgwr8MC7OlL3R2F3lo29m9vb2+n8ISIg7/1TL+msqOv0p7+tVEsQFVRwk7Q99+J6qqJH+yQlJ0GVssTfkfbd6IPOWLPPZ3FxUR/42C298pXL0gPlgvm3222trq5WKp+8J/IrjDafB/c63nvHUgwtUhedxtywgi9E4wP+5xFExwFpch7W0tKSOp2ORqNRaqhEiiwRxsFgkPDAjTqHfZVxFWFUBTOXBY7f3tmxVqul5hbU1xKdW1lZSQ6VN//e7050NTMzo/mZGdUX6onGSX+jkynGbKxrgUeyR+wfPI93V+kRzusiD3NDCHwg3ZhIou/X0tKSNjc3Ux2xP8vTwGKkzOnFv2eu0RjLsqxEa9G48e65bgT5vnsUbCk/19ONXT3XqOlfZD3Nzb1PKysrOjw8THOkmyB4T4SIvaPjW1WaYJVMjTJ4mqIc8ZX7+UHuerSY1Dg6GtNqnn32FEJvbEQWDj/Oc9xIBQ+oywOeyA/HNR/uZHVD12vkiWR3u13V63W12+3StcPhMNUlOYygQU+HhD8tLS0lYwzadVz0iDDrzbIswaZUAqCH9TSMK1KjvXMtBiI6Eg01qNvjeR5hOz4+1tHRUaorZ22Li4uJbwKni3Ao4iDzvsgo+0Yd/1oRLGdWnqfpRBEFKpvu3emyLEseDwSVNGHaKPN4LlyJi3MiH5cUmsjcfESPgj+Le0etBdXOVjS8t6vCPW9ZprzVVLYwr1GjpqJmbWALjVP+eJ6kbKix4puPmxAUtUzPffjGA6KaSQzgcSz+iLDAwgk47g/feUc3mBvX4HFHiGdZlryW7BXeJgSo//g7XbF5HEOdeVetteqzGCmN4WuYD/NC8DFc+YpKOPPwejaMCE9H5PNp+8U1Lrj9enAzeoNd+YzX+9xmZ2eTI0Ea412RSUUt1wc/clN5Xk4r9Dmxn57u4lG0i9bDvKoMLZSrKvgw/06nk5oTjEajpPh6R0P3oOElhG+wj17nhEHmRrMrYc5rpu1XNOidjmIUjHf5b+AoqZQSvbCwkCKd1A9d/uO/ptm8r+P+XEoldFx22uB/HFFFMT6XDrymw6QrfE7X0/Yx4qTDJhrbfh/8vtFoKBsVyoYTQwlnB4a7pyB7/Ux8XhUvYD7srX/nirQbn9FB4OuPTgSXUawZ4xK6BJfhe3jQvbDd96kqsjBNsYhrjX/H69zgZL+95oj5e/czlHHmz/rjXjBfjCR4okcfPNUp4nzkB87bHAeQ9Y57vjboB7jyPtK8SZ3jHviypKQce9TcMwccl6eNiA+8n0FU03m0f+7dPZFJVbx9OBzq1s98v+Z+/8/oau2WGllN3/Xf9vUP/1Q5WwcnYYST88KIHw7XdzIu4hdRZrEX7ryGprxJissYxynwwM88BSeddqApp+mY9s1egSP+WRxVmSSuN7iRjgGF0xbD353xnqGAw08aO0Dh0RGW3Bf1N8dZ9GB3QjEcrh7Nc93Hn53necn4lZT2wJ/vUTB4APLIdXZgEHFn2oi0/m4aFxpYTnDTEKVK6YDxwyDwunIfRMM9CC4v0gNJ2ExP6aN9ZIzSuHIYFYNodMR1xvsZv/sPL+vn/1ahWlFocHdXGj1YR60m5Q8MqwAboleFf54VyjQxrj78TXdVq5U9qMvLyw8p11VMMypDcV/8Wl8f33udgLf8jLUw0uQ8Mq4nKoBSyJ55MbU0OezOPZtxHXFEIcLfVQaGG1kRF5lDTJtE2LmC4vn67rFiDVFJ8+EG/EXMo0rhuwgGUTGY9sxms5kYYpZlUlGoqOf6wMduleBTBbsqj6evCyHnf1d5dC+aI9f4c/FuIhQGg0GKgPqZRHgy3aAlXdNTlzz6JqkkFJhf9DRHeDvuuLHh3/t6ETgePaLeiHWCexhARFk8leV81ND+33i/Go1yATfRCGguFmezJviowyPujwtQhGq8hmf7u5wnumLkKTpf/vUN1c77ynoD7bzyXr3vE7fTc9wAIc0w1orENbkBwN66cyc6C1wRYs8vGu748/11+RRpmrXGlHc+d0PH/3acigr2RTzgImPM991bwzNvvPI4K71mBHnL/jlP5nnutPKUZIzlKOtRdquiVB7Bq1Lcfa+iXGbv2d/BYJCajHgaLtefn5/r4OAgGV5bW1vJkcFzHIbTaMCVf98flxmSSmeOOYy8wUl0uPhvx5+v/b3fp4M/9IvqFzX9wn8+cZJMU7R5ttf7OU5Pcxr7eqaNabgXjSvWm+d56fw05g6OwcslJQeZP5PsF2QY9OU1rXlersclUypm9YDTzLPKgK9S9IuiSE4hN2ShiVarVXJigiP8z/4T7WGvvI66it7d8HbYOv/zOfId+OOlN+BS1LH5m3RieFNRFKkTozen8lRDeB7RcX77fKfhE+uNkel34/i6IlgMJ0gndAjD63Mccdho33D39riRJU2YEu88OTlJBODCMDLeqKS6UlZlvLhXFMY8MzOjQXtOjfNFZXv3VTwwsIrBQMXJifLZGWWDeamWjQ0tiCm9dPxPUcvH9ViZ9O3f3ZPUTgQIIpMKxXwiYVYhNetxhoMy5QqxRyiAC4Ix5gw7YUSjJXmuDe4ozr6Prny68hT34p3imc8n4lvcY8e5WAwdDbT4riiEo3Ebr43Mu0oxj2twXI1RghgRdAMQONLR7fj4eNzgQoWefP8byrLFkgEZhfM0I97n6XvOiHvoNOPznAY3Ggu40g/uQ/OuAPneuKfUlUMXOr4GN85ixLGKJ/hc44h0CFwc14GNFzej+NO+2I2mvZ/87Q+8ieclfHVFNioMjrMxxdV5l88z0kE0KLkuKhCOfzheaB2dolNnTeXHZ8pOz5TNzei1X7ukD3zrrjqdjrIsKylGFLJHBc3xMOKWK9qOl/6Zw8YN6fg8cAh88BoqaRLd8i5io9Gkg55HcFypkcqdRD2FLCqske4vUmin3Qs83Qh3OiVlyuulMLB4t3ePzbKsZCzyLj/c1mVxHCj5KF8uhyMNP8pp5AOFvCgKHRwcaG9vLzlbccgScaDNNEo23+F4ivg+jf6lh3mcD3fEsdeRP/vvKplQVUd07cd/u27cuKHh8HZJVkZdiP3xWmfwMsqix9Edpo3Hudb5sRv7HlXxujkU/ah0R5lE/RnXe0TSZZKvG32HEQ2UqsyeuBaOojg7O0vrwolPlA1dKcpF5orBybri8D3kb3cCVPEH/vaulZG+nV9Hncb5qKcLkt5OJglzcX2d9cBnvMYu4lXE90hrF/G7b+Txjg0slCr+lqo9g369W9d+PYSJMQYhuEXuG4Nw9AJcFzAxnHrRhkYic4JwpKzVavqhP7Cs/+MnC9UPljW8dy9dNzo9VTbTUNZalB4c8FpgaMne/aAVe6HxdxCzE4RHXaIh4iMSjv8dmaqvEUL0tbFuCNKZOfDHCEZAw9ydqPx6GjJQdxWFbBX8q4i1au/8Op7pygw/UemWVGprG+fk8KjCHZ9rFGBxfq60RsYfnzdNCMTnwzxHo5FOTk5SpPBXf74mqfXgp0go54LID8SUlJhrXK/Pedq6EIQeUakSxJHZkspHy2F/b57nqaiWAm8UcwSKF+p6+qoruk4zrCN63HhmZPpRIPv8ozLmwh+YeO0fzyXySwSHtCIXUo5r0UngUUOPjsX3R5wDXxCYkTf6un2d0D3KOOmabvxB491uV698+Qk1TrvKzs6lfl9ZvSYNxu9g7f1+X61WKxnXwBlPP6lsHuX2/WDOHrVwnHKPeOR9jgc815tZkObH88Elb60vqeQ4cg+941zkpdEgjLCummvcGx/c6893g85xwRV44MiaUZLcQeFwdt7jvNKN0HhdxNcqBdadfVW8z9fp6/D3UcsDfh1ZF19PT9vc3EztzNmTOGd3YsBbquTONJnlsieuJfIZ5y0YfaTP8bkfeF0URcoQidEKp2GPXrkMjDrBOxkXXR/hgl7gdWeRJ7vsc10BWmw2m+lMQHgczinviOeRYvA/Ohii09zlm9NblTzOsizVTnKGnTsffMAjeWY0PKRq48rvv+jvqJuw/86HHVf8+kiT3EOEEB2OGk6clb1eLxm/XMvwCLVHZyPvi2OaMftuG49lYE1jPs5onOjwAHiLSa9JmJmZSV2NpMn5CAgRCLUoJi20XTBwECsMDkEbDSNncI6AURHh3hi58bX/4I+2VRTL+tkf31Txpa9OYNPrKz/rSbMNFTVJWU2qj5tYKMvKzS5GhVRMWqNHGFfN1efpSi6fO6N3pu7PHA6H2t/fLzG96J3wARzYT2+H22631Ww2tbu7mxQf9thTDCFMFDY3guKoIsTIGJ3pOCzAC99z5u84hxAArg4z4OuRiWgARlyKBorvH59XKbX+zsgcpYmhdVFHvYODA3311zdV3z0aH249Ux93oWyMDxBcXFxUURSpaBWlcXV1tXSGUJWi57TuEaUYCXMlJSqF4Fi/39etW7dKAiEaCigI8ITZ2dnUTACcgsFzsLOnnCGQfR7u+YwpOxGe04xlvzbSJM+GLpx+vEAZDzvNVaRJelGs43Cc5t3wO+dTvm+OL877omPKeVsUfFk29soeHh7q7bff1uc+9zm1221dvXpVH/rQh7S5uanT09NkGD3xxBM6Pz9XqzVp5jFWjDqSdtXrTZoRtdvtkmG2uLio27dv66tf/aquXbum4+Njfcd3fIeefvrpUk1uVJZ8OK5GozoqWhE3UeqQR6PR5KB05pjnkwYm4NHJyYmkcWv4o6OjZIiR1gqPcxz2MwMd7yOtRTycZlw5vwPvmCP8CuWo0+mUUgQ5HHp9fT3VhTj9VuFRNBBR/H3eUUY6nkUPfdxP6IToNTxAmnRyZZ6rq6taX19Pe+T82mVgjD65EiwpRSfdGdhoNB4yXqKyHA0/3kMZRJQB03AV54RHTznclqycPM9TuhrKNDWqOMeGw2Gp0dLc3JxOTk4e0s+qZGrVHB3Hov4Qv3M9DzrHyKKmyvkyMOMA+Hq9rieeeEKXL18uNdkCv11x591+7A7przgZ0TfjvkVDw3kta3MZLKmkY7reQCQLpw7PnpubU7PZTIZhpA+npaqoV5UTDB0GBxSHofM9hmZV9NRpeDAY6Pk//WV9y9ybevH8qj7958d8nlos5n52dqb9/X2dn5+nToE0jVpaWlK9Xtfi4mI60oJ5Oe1FnhFxv4r3vVvGYxlY0xQQBxjCCIXJr4nGS4x4udLqCocr+O4xliZpGt6lhblGIqlaT0T4qtB1XHtRFPq9f6Stf7qzIfV7UpZL9fqkDqs2/iGKVWRKKYMPHiBJ+oc/faTv//1LlZ4OXwdEzbt93hgdzJ05x3WQ50z0wBU5hylwJnoglRtB8B46BDojdg+ww/0io4o1fL0jeotjRMpD6hG+buj45/yOhrYzkchMqpS5i66rmoekUoSHbo9ei8j96SDAb7uvr/yTmTGePYicFnmm4+Nj1Wq1xBylseBYW1vTyspKqc7A1wiuOf3EfXPDPnqG/Ro8mBwC7jUh0LXzCTds+Zz98wi1G6HMH2HOnnuOfHQA5fmkODfu07QReQvvjwZ5vAe6xRjz71zpdtz1Z/pwfhr3JO5F3Kuq9bly4YojCujBwYEODg5069YtffCDH9THP/7xkmeTeoPV1dU0J+ff7v1lD2dmZvTiiy/qlVde0e7uboKbG98+32gI+nD54Wt1x0GVEgks5+fn1e12SweV+r1eV+INO6q89K7oOT5HY9nh9PXyPVdw+R1pCNxzvkS6E+lL/oyYahXhF2FadZ0ryO7Ai/yXa1HS+v2+ZmZm9Prrr2tvb09bW1u6evVq6loWebUrkXFgwLBXzHtubk7379/Xzs6Oer2etre3tbi4qF6vl5rD+DoZzB9e6TCP63PjIyrz/nyvdyYyQWtwnu0OJa7lep7Jvns6qtf7OM1fxOemyeU4oqxywyY6CN1AYt6S0rXtdltbW1upoyU6ntMzjjXgEhsbwTM86h+jeJHmoiOrqtauar1+lqEPeObJyYkODw8TP/RGRFVwdBhWwR+YRIcH93gkj8+cfsG9RqOh1/7n36b2f3Siuayf5iqpdOanRwCBb+ycDP9mD6Mjg7VVyZl3+/i6uwhKDxsDzmgJPbonmmtR4AaDQer659dBPLSg9UM0GVHBi8IreqSqFFwQxXOcq6JLPC8Zgu+5pKzbV9brjw8ObtTHZ1nV8/FPLVd760va2NjQv3r5KkBTNhyNo1hZpp/9qUN9/4+2K5nXNHhLk3SZuF4InmexNpi4Gxzc2+v10nUUj/oe8TyfEx4dmJQLGn5iHcKj1nSR0lHl/fA1+o/jZZXX1P9m7vEaF2rOvONcY7TQ51u1PxcJs6Io9NZbb+n1119Xp9PR4uKivvM7vzMZWT5XaXzOz9zcnL7UPlU2GKXGKR/86C3l+XOlRgmcKRMjJsAHYf7aa6/p6OhI9Xpdm5ubunz5cppfVOCraI//gd3p6WmKnnk73qIoUrMHopzA0rsYuWMBQc1njk/gvX/nBpU7ci4SqNG7GfeT6+LfbgC60ceaYvqIK+bD4TApKh5J9khr5A1RcfJ5co9HZyOeca/Pieva7XYq1B4MBrp3754ODg7UbDa1vb2t+fn5VOPjPD/CCNyCh/f7fV27dk2f//znE89BcLfb7Yfm5uuRVOLJPLfKIxyN1qpnsifNZrN0npWPaDAVRZFSnqVJ2o7XmLhSFdOWI/yrRpxj1XCHUqzzYu2uIOFkoO4CXHVDzSP7DjPn5zGCWjXvqjFtLVk2MWLBjbfeektvvvmm3njjDT333HN65pln0lpYu/MXH86fY13cSy+9pDfeeEP37t3TX/oH0j//7+aTwemNs6LSyN9R/kRFtmrN/jx/TjSWvKkNsCaS4O8gvdYNejeO3fB8HJxzWqlyJMf1uJyEtqDfPJ80SGGvPHoF7lAOsrGxUWqz7tFe3uNrhd8wSGtzQ97rtKIx6XzJ+Yjjetxf/h8MBungZ4cVPGg4HKrT6WgwGOjk5CTJNc8gqDLOpEnWVpWj39dEsxnn7c6bpHL0mTWAJ7/2P3231v/9r6To1MnJSXJExHT76OhieBqkR/Acdo/D5x7XoP9GGo80sKKgjwjjwto9LAxPGYAACMt3u910wCs58UVRlFIuIjIhMFxY+Fx8uJUP0bqX2JEqKmaRwTo8PvkHxmlWP/8zXeW9oVQUybAq8nEkAQT+4Edu6pWvXFY2KpSfD5T1h9KDtsY/+3dG+v4/ulaafzQkXIFBeYkEdZESD1xdkcDL50wfw8gP1XWizvM8pWJ5nQbvAJ7eKcyZWvR0XWRUxTVV4eA077Cvy+/3vGJnwjwb/JCq84p9/nzvKSvcD/OCKU3LEY/rfOWVV7Szs6M8z7W7u6vPfvaz+shHPqKrV6+WokvML89zfd+PNAPzfba0PuZdZQRDh6PRSNevX9fnPve5FMHY2NjQD/3QD5Xg7Ouuipj4NRj13uQG2KEs9Hq9JEDAZ5pgoMCz1igwo3EQhX/0ylcp41W0VrU/Vf+D1y6gfP2exuQ4efmPfV6HgwX1//4LpUJ8nBZFUZSiXZH+fT6RHnw/orFRZawBuyzLkiNseXlZGxsbunv3bklh/8xnPqOrV6/q6aef1hNPPJEaC1zkqUVp39nZ0euvv64333yzVGeb57lWV1eTE4EUG4+sMZz24NWRl0Q4RBj497Xa+CwdjKSYIubvzLKsVBRepVxHY9A9ve9UqbhIeXEPNj8Of5yF0QPtWQfxOd6FMiqoHmllHg77uL5okDncI60ha46OjrS8vKyFhQWdnZ3p2rVr2tvb0/z8fIp0YNAy92kp7ZKScdLr9XTt2jV94QtfSEbMp/7Mpp57bjalqjE/56E+/whbN2L47fQdcdbvjXzMHTCkPKN046D01PvIA533TIvsXSRf/ZpH4ajvteON/4AvVbIRA2ppaUnLy8sJtu4s8DOqeGdVVBJZ7mmBOOscF9jDqAf4iLjLnjCPw8ND7e/vJzpDByJzCv5NCmSEaZXsiXCNgQCXsdBtvMabjDmduXPY8WXvxz+q3/WXP6/7g0X9i/8iSx0EoUPP+Ir071lp7jgHflWyNI5Hff+NPB5pYFUJef88EglCEuKCOYKM5O7i5fbc+3q9ru3tbUkPCxY2FuEYDS/uiUKYzxmu/KD4eTG8D083ciTp9Xo6OTnRC9810Bc/21TeHUgjKcsKaVSoyCdh3pde3FI2GCk/Gyi7cVfD3b30/HxuTj/7qYF+4E8+8RBzd6YdUy6dwN1ojMzJ87fxAvmzyZtmwKhIFYRJRgWFFqT8795cBJEX4boArzKyqogvCuSq365sYMj4mWkOD+pFlpaWHnon6VFRiDF/GK93f8JLRwtXPose+kajoY2NjYfy9YEV+0F3NmgKr+78/Lze//736+Mf/3hSwiMdRmHucK4S7I1GQ7u7u/ryl7+sN954Y3zo7eD3qbe9otu7f09vv/227ty5o+3t7cqiYObNQZIY2HiGwZ1arZbOf4IPkAo5Go1SrRK0iLDKsnEjGOpZPLoTzxiiHoaGBa4IuIeXxgaRl1XhWcRDV/jdePYuWl7fCJ6An/CLa5/6hD7xp35FLz6ow8DQpKidmgRy/h0XfT+pmfJiciLQNAyJBqo7uFBSWJ/zwxdeeEGvvfaaXn311cRbBoOB3nzzTb3++uvK81zr6+u6dOmStre3tbKyUlKwzs/PdevWLe3s7OjGjRslnHeH1/b2tj784Q8nQx86jPVjEY8NCOboAAAgAElEQVShR+o96IIFvbInwJI9A1ecJ7RarVJ6s0dM3FigDgFZ5fQPHMELPwfJo6c+LuJ7cURFDWOclG6Gp5zRZGQ4HB/g2mq1UtRgNBqlaJbTR6QL3wveHaMkzstdIeY94E40msE/Di19+umn9eSTT2pnZ0dvv/22jo+P9TM/8zMpwnn58mV99KMfTWnPTmvA+fz8XPfv39eXvvQl3b17N9Vxrq+v69lnn9X29napVX2n00lNGiKdVxm5wMSdk1UGmGcIOF+OTgFPHaYbLPt5enqq2dnZUhOWeNwNc4/NmyI/i06G+H2UJb5mp1unR3QEHK04UxwPfN85S+rKlSvJYHZlHaOASFekDzJrqgY8Nu5HVWQO/PS1u76IvsceLi0tpfKK0WiUolWS1Ol0Uj16s9lUu91ONOeOj2hQ8y74iMPajUHgc/ny5QSfKvxELwHmzD/LJqnMWZapppH+wtqr0l+X/vv9p/WLf3ZStz43N6fT09NS7RyyGD2bg6ThGd78J+o1j6PfvVvGY6cITiNEBkjjioEbWo48GFnO+OOzGKQ5uQUNEToRVSF0jKy5h8AjV/5en2us13AEx4CRpGw0koaFNMqkohBPHI3GKYH5YKSsP9Rw/6C0zmI4UqaHGR3rqPIuMRf3wsXQLnvg8Gd9MVfZ1wjBuWHhhjKeQIqDoxD1PY4M4SLBFf/2tVZ9xt77j++pe3IQPHRv4roYaXM4ACvmxffAgEJQZ2guWGCQwPfw8FCtVit95gyJ341GIwlU9wCfnZ3p5Zdf1vHxsb73e783GY/MsUqoujB1fEVBvXbtml588UXduXMnweit7B8p350U3brhM22cnIwbHXAPkSdP34jM1r1+vmcwd+ibdAuHE/tedUwAz5LK5/bEvXQ6qcIvH9Poj3nwfjfcolELzKGp3/g736ssOy9Fa9wgd2XF9xbjpdvtqtvtJmHP941GI3Uja7VaD7XNZi+i0IMfo0yPRiOtrKxoeXlZ+/v7ad0oP5K0t7eng4MD3b59W08//bTW1tY0MzOjbrernZ0dvfXWWzo7O0vKn0cypbHCRD0g73cnV5WAdlzGkDg6Okpt1NkPDCxXUnzPq2jWaZtnOd7E/a4yJnAqnZ2dpXVNSzf3fXkn+Oi825u3OJ06TkiT1vS8I0bAps0trj8q8JHv8Fmkufh55AFOv0899ZQWFhb06quvpkj27du3dffuXe3t7Wl9fV2bm5va3NxMNTz379/XrVu3dPPmTd27dy/hLO+8cuWKnnrqqZKDl3ngBInrcEOeZ7GmuF9V3zHgi8DZozTO17yFPs27Isz8xw1ed8pN28eLFN1ofEV+Gz93XuXpahcZWMzTHQIOF+Sk82mHe6SjqEv4XlThp88duYahDh15mQj3zczM6MqVKyWDw/fAMzAiroBD0qRDK44AHDZeNoPuGenG8TXuK39XOUBcHyuKQofDhXTPh+Zu6BeKq4l/OW273HTZAcwu0uWm6XdVvOI3e3zyk5/UX/2rf1W1Wk2f+tSn9GM/9mO/Ke99RzVYVUjNcGLxv93gARnm5+fVarVKzSu4hg11AcJ1Lrgi8TCqjCknQPdS+DyzbJxWcHR0lLwzvD9a6ChCo9FIKjRO+xsMpSyTGmOQ3n37ed19W8qGI2kwelCvVVZW8+UljRrVsOJ97pGIhhEC1/OyndH4M2FosaDZjSw/YM4FsaRS0XFMT6kyomEWXgj7KNyKwsvnXnV/VBr9OdE4xmPabrcTo/WmHzzPccqNEkkl704sWAYOGHFuaNF4otVqPSQo2KOVlZWHUjmzLEtC6ebNm3rllVf0zDPPjM9ms0J2x/UIUwwemPXJyYm+8IUv6ODgoJR/zXqBgwtHhJ+/YzQapRoW8A+4sv9xX6MQjPgDvKA/5uIKCM9xYewGtZ8/FR0KVfjyKMYf94vhziSPAKG4RdrzaC4Cl2cSleDsIZ9XURSphs2j0XSGBNdxfKCgNZvNFPVjzdHw8/cvLCyoKIrkSX/yySeV57nu37+fng8f7nQ66vf72t/f18bGhpaWllJq8dHRkTqdjubm5tRqtZJS0el0JEmtVkvb29taW1vTcDhUs9nU/Px8wi83YJw2fZ8wNsG/TqeTshrY/263W0qL8/3DOeaGFnsSjQtXethf/9th6ffyM43vRaXjUUpulLUXKTpVimWV8uZz9flXydiqOcXBeqMsiGvzzAiny/Pzc62vr0uS7t69W/L6X7t2TTdu3NDc3Jy2t7f1vve9T8PhUC+//LJu3bqVZJenD9brdV25cqUUYY/6hUcHnP87X60ylKtgAIydTzqcMUi41r+D7+FwjqnH0IQbpK70xijT4yi004yrqu99f5mf81efnzTh6a5vkHUTdQveBV5EuonOzsfRJeK6gJHj3enpqSSl6DRRYJ8X+qcbhz5nd7RIExmKA5raY+DgByk7ncTfjsdV6/H99flCf+gf3HfzU89r+OdeUy3LtZCfl9Ieud/1ZV8j76iKylcZlszvt4JhJY338K/9tb+m7/me79HOzo6+8IUv6NOf/rReeeWVf+PvfmwDKzJtB54bPs6wuc4FWaPR0NLSUmIkbsR4apmnmFUp6VHwuhXvnzlTitEOt/h3d3f1xhtv6Pj4WFtbW3ryySfVarUeYpoob3Nzc+p2u2MDqj9QhoElSfV8/LnGxlfeG4wNLB95TcXlDX3/H1svGVYO7+gNwlvk0SWPirhCxfCUm7g3wAaijKF7ogkQIgzKBUWVUejMs0pwcd9FBFilWPgzopeZ+SJMXVljfZ1OR2dnZ6UuVeAL6T88B6bp+IKB5Z5XD/MPh0MdHBxoOByWOpRh2NC0JY6iKLS1taWjoyMdHh6W1uPG/Isvvqj79+/rgx/8oNrtdim6FGHp8GVd9+7d0yuvvJIU4IhzzhhJ+3Lv+LRBu2qHa4SPwwjBwv4Aa4wMOrcBf9JlXICDX0QeorBC+Yi1mlWeZtY+7bPId3xu8fmsx+nXlTXWg4GO4UK6j6cgsSba6PZ6vVJLceCLUYUCQ3TVlUjg4oqQK2aeSikp8cDbt2/ra1/7WuLb8GIOE261Wmo2m8k4bLfbunv3rmZnZ1N7+sFgoLm5Oa2srOjy5ctaW1tL6yRdzfc2GlkxcuBRpywbO8a8lgg69QiZy4foUAAvogPhIuPF99mVDJeBUfF9HOM+KtX+mT/XeSzw8Dn5unxN0DNyo0qeVxlHEQ5+X5VB4bzXDVFfu+8FfPj8/DxFRMF/og2j0UiHh4c6Pz9PNXRvv/12inw7LQ6Hw1K3W6KvzM8NmKhLSJPsFYdfXKMbFvwfHV0OV5R1nu8wgvZcDvm83JkSlV13IsU9cphXjUcZznGv3XkAzOOzIu5yLbTpDnPXE6rmVkWD09YQ6crlC+8jzV4aG/H7+/uan5/XpUuXtL6+Xkolj3qfr8n31OEMLz04ONDdu3dTWcLGxkaK4nlmxrQRjclHGcPgYuSV/v31wane22jqdDSb9Dp3ZDnflcr8kX32wEeExTQD/yJ+95sxvuVbvkWvvfaa3nzzTUnST/3UT+kHfuAHfmsZWJEZsfn+v3t6PC/WvYPUCoDIHjbHW+0GlntNpOlhx6pN9gGzjlGKLMt048YNffGLX9Tt27eV5+MDQ5vNppaWlioJIc/H4eFf/3xbtdFgbEyNRlKeS3mmIhv/ZEWhbFhI/YF0dl56Rv09V/Xv/YmtNDdfhxPrcDhpsz4zM5O8wi7YYpqA52pHRu3E6WlyvjbgXatNziDj+eyhG7LukY+MqGo/phFa/HzaPf65E7srGTF6WauND6je3d1Vno+jqCgm4AYM340shx/nccTCeBSD4+PjUmSISBPKXq/XKxlYwGc4HKrdbmtpaUmdTicpH/zA3Lrdrl5//XWdn5/r+eef1+rqasmA5JlVdHHr1i299NJLunXrVqq1g5lSR+L5/Sg4UUn04XUcR0dHSdGNA+MUI6EqUoHwoaEA7/VDKCWlubqC6EX9wK5K0Ym4E+cYhwsG53cR/6rw1GmM/1EW3fPLXrghEQ/ajA1DXPknMru+vl6KtMZag+j9jnMuiqK070SXNjc3tbGxkVLxPPK7srKiq1evpqYX7XZb733ve9Oc8AwvLi5qfn5em5ubJb4B33JaqoJ/Ff8H9tLDNSzSxPB2/uDGiadFutIdeTG4AU91vHWj3pVip5mLFMRIqz7ifa6Eu6JbZcRMg53jjRtbLqsfNbeo6EXDN8/zxPOYq+Odv5vIpfM8+FG73dbNmzcTTjudgV/QBcZT9MCvrKyU1uKGUYRHFX5xjUcbnD7RU6Blnu044TCCn9VqtZSy7riPAeB6VFR6fU5uuERD8CLcitdMU9wvMnri+yPdOG1hdKDjeWqhG1jTaOUiHYL7qowqHziz5ufnkww6OTnR22+/raIodOPGDV2+fFkf//jHU42Rpy1G46GKrtz59JWvfEWHh4fK81xPPfVUwhdvyOHDjZwqOXOR/utG4TRY5nmuw9FYNh+NJhG5SF/srcPZ+abT4TTaiTrJ/9dje3tbb7/9dvp/Z2dH3/qt3/qb8u53nCJYRYQR6OSmeqtOgD8/P58iDXgwPR0IAmREYnFE9AExuMBxYecMnPn0ej396q/+qr72ta8lpO/1ejo+Pi4dXurzB3F+7n/rqnY+VH7eT8ZVMTej0eKshvMNLbT+xfgMjpsfU/28r+K0OwH6U1fVu9x+LJgPh/8Pe+/6G2manvddb51YZLFYxeKpT+yew87sjkbaXe9KspWNozVky04s2I4FQ7YcGEECODGgJECM/AXJpwAGkg92EgRQEtuJEwu2pZXjtRM7PkSODK+saCxrNTujmemebnaTzSZZZFWRRdbhzYea38Orbr5kz9qwgmjyAATJqvfwHO7nvq/7+Ey0t7enhw8f6vDwUEtLS/rDf/gPz1m6YdjuigaYYxHL87zwbBEHDlFglEqlFDNMeIV0eQ4OcwGgIzdiZWVlDkQCIJm/64SZA4Ui2vP15LmuhEBTnk8xnU5T0vt0Ok2lw1Ec8ZqUSqW5SlWujNOgHfpJGVc8BrVaTV/60peunBPG6fCMzZUbSSkm+969eylMdXNzM80jgjjPZzH6Dx8+VLPZ1PLy8hzj88bzUWzeffddPXz4UOVyOXmQ3cNzeHiok5MTTSYTbW5uamFhQWdnZ2m/+nOZi1arlf6v1Wrqdrv68MMP56pLQV/sp2q1qlarlWibeQbc8y76xmcOihYWFpKCjILlvMatu/G8Ft/T1wHFKKj8f+gaHsd38J9obMC75wCYIhbsH0LdPMfP++ThoIyLHKRer5cOkYV2oTX3atMinbg3hz3gRgfCA9fX19NcjEYjvfnmmylpvd/v65d/+Zf1gz/4g1pdXdUXvvAFnZycaGlpSYuLi2mNMD64IcPDP4u8BhGAOaio1Wq6uLjQ8vKyDg8Pk3caxQHQwTx47h6Kuyv7eBWjZ2o8Huv4+Dh5Udm/rDXnOUXw6WNxmfQy4Eu7TskCoGKFdtqNhTwib/D3u/LpzykC1pJ0/K/9rFrlM9WysYbTqt77r7+cANji4qJarVbab9B4VOjhfz4v/X4/yTP4+P3799OaMt+8KyrZjMm92o1GQ7du3UrAmu/K5XI6/yoqWBFI8i728GAw0NHR0ZyRBx6zuLiojY2NdJ8r384/3YBMMal+v58UXecpzBc0HJVZ3h0N0RHgRtorMhxFXOff8wzmCH7q5eS5XpqPjPE55TmM373OkTa9L4y1SHGI++k62o3G0LOzM92+fVt5nuvp06c6Pj7W/v6+fu3Xfk0bGxva3t7W7du3tbq6Ohcl4XQD7sjzXB999JGePHmi/f19DYfDdN7X6uqqarWaBoNBKmjUbrdToTf6hDfe90ZUzp2WfG1d4Y6ed/q58Sd+SaUs15NxX8Pputrttp49e5bGhJxgvbwPPMONgUXKVaSFT7s2/7Jb0Xs/LQ/+F23flYIVNfebNG2aMxpJc4KtyOonaU7AxQXyzUZz8BWtcn5vBFcfffSRHj16NLdRAECUTvWqUrSf/8s9lVCuLkaz/KtKeaZkVUoqL/w9XVzMLLOvvPVQj//JHWU1S+KuVvSjv//q1Ps7nFkNh0P1ej0NBgN1u910KCNgoCheF0HmVa3iZuB6BHPMDUEYocBFqynNhXrcVFEgxjVhzq9jrtdtDlfcohfBrcuTyUSLi4vJgk7YEhXsut2uSqXZAYhuXXKQ6uN0JQ5GDdNcWVlJVlkfn59z5OvDeDmXhzF1u93k6UKhoApkpVLR8vJyss5yeKADfgftWZbNgR+UEbxNhCzgeeLoBF+XKIDd09VoNNJ6tNttvXjxQkdHR8lT7RXLuMcFM7TjoamMO1rlEOpulGFd3AgDrUcjS6TN+PdNTNd5nfcJgef8KtIMwDzLsqQscw/WcN5fFJ4RBWee5+r3++p2u2o0Gtrc3JwD077X4/z5GN2rH2kyKgjer06no729vaQsv//++3r48KGm06mazabG47FarVbyLEAf9MvnEHBQJJgdWPrY6ZeDgWq1mkr/e1XDOC4fUxEtxEqCWZalwiJudOH5DuwZp4OhSC/XWXWLAC6NZ3gecuQxTh+RHzrAdwWiCBwVKYBZlmn/az+vz9f21S7P+E130tA/+yTfVFLKCXRFvwi4O53zN0oVDZ6HAuL94HmEehUpj4SqcgQM46F4TlTai+SNzw0GIipWlkqldKQMSv54PE64IYbP+373Z7uyEvOYY398f/j6eKSDX+fzcR1fK8ID8X+fY//c9yyGpaJ96tff1IroL/Y7fl5Eq3G8jqPAUl4xb2NjQ5VKRXt7ezo+PtbR0ZEePXqk3d1ddTodfeUrX0nYwPtIhMvR0ZGeP3+ud955Z5YykmVaWlrS7du31Ww2E8+Fh4/HY52dnc2FKsZ++rxxv+Nel80+D75OHvkymUzULp+qXRqrlmUqZ5fnX3L/dZiL57qsc8zu7//NUlq+2/bkyRNtb2+n/+/du6enT5/+prz7RgUrMnxfYOnqBvAFdgbqlv/oIZEuLRRYu6MFMXoTENaen+LvjxZ3v59+VSoVvffee0kocx+x20XVDXle6WKclKtseCGNx1K5JIVNQpn0vFZRyUuNluZPuXemFJkMjJ0Kc+VyWd/+9rdTeWRAhDM833AIqqJwQJqHPgB6KantXhaACy52f5evVwQAcQMXtes2p4Nk2nWCwefQAQeH7W5ubiYBywGolG8/PDxM4N/PsfF+IUg9hKterydvEp4wVyjcMuXWOp8nlKClpSW1222dn5/r6dOnOjo6SmADxr2ysqJ79+5pY2NDJycnevLkicbjsRqNRhobVtHBYKBKpaK3335br776qs7OzvT48eM0Njx7zOOtW7c0Go1SaKzPQdGep9/j8Ti9a2VlJX1PMRufR2f8TuO+bu6d9XkCXMakY/c6uKLhQuGfh/b8+6io8Pd1z+I7SkITIoIXOfbbm1tKS6X5PNLpdJZjdXh4qFKppK2trQQk8Wy4FdRb5DO+t+C/DvBQCJxOx+OxOp2ORqOR3nvvvZR3uLy8rN3dXZ2enuqNN95Qu90u3PvwC4xgHobjfYsK7U0KVp7PjGKAFwxjnrTOu3wsDmpjdUHeN5lMktfb7437wRWW6DX0613J+jSApIjGIh8peo6vcdyzHuLt0QvXKZ5Hv/MbelA71Bdqe2qVJppK2i+d6fP/wXv6lf98O/Gnk5MTdTqdlBM1mcyK/rii6fTMz/LycsovjF79Xq83Bx6RzxhZlpeXNRwO50qwLy4uqt1uzxnZ6vV6Un6iEuP8yQstSLpCHx7qRnVYDpftdrvJyAANsN6E+jK2GBrscvQ6sBrlWqSRIlqJ+yY+r0gJvk7h9H3o+C3OZdHn1/UpGljiO4uUNldGfJ++7H0cqxK9vByw/vz5cw0GA52fn+v4+FjHx8c6PT3VxsaGbt++nSI7ptOput2udnZ2tLu7q8PDQw0GAy0sLKjZbGptbU3NZjP10fkBtOQRUj6vcRxFyqQrbD4+/nZ5yT3b1QPdryzrdHqhxidFLshtjLnc3qLhJhpvvI83zf//mwrYt771Lb3xxht65ZVXtLOzoz/6R/+ofvInf/I35d03KlhFAJbmwsavuc5S7Jq/ExzAHjcsFquXJdbjslxaWkphcN4vByTeFwcMz58/v+Jex+uDMhEZ3jf+Sl+VT6oGZqOx8tFIQnlZqCkbT6VPnkX1rLycKV+YCYCsWkvj8xCC+C42ERXEyCcol8v68MMP9dprr+m1116bAw0O1viNd4QwJeaoSEBjVfFQJUpCA2DyPE9njHjysSvFkSlHy/V1G83Bx3Utuqf9mUVWwOl0qkajoXa7nbxLWZalNcaLgzJDdTKe74ojOVhYW6vVqtbW1pK3U7o8C8oBjAPfImboa44iRiGA8/NzLSwsaHl5Wffv30/n2lSrVX3rW9/S3t5eUnQ4l8TPP5tOZyGSr7zyir785S/rwYMHGg6H6XqExfn5eTrXA69TBL7OaD1MYmlpKeUKEraIB6uo+pLH7QPaoaFoJMFT6PvUQwRjOI7TSVSM+HGAexPTj8LdlauoZEVllP07mUzU7/fV7/evFM0povUijxHzQ6gSFfnu3r2bznLyM2mix6JUujwknPHDFyOQjGOPSlmWzTw6nU4nKfhehevWrVtqtVpz52zFkDCexXpHzxCgKwJH5pPP2CsYyVzRR+lEyWIOfP2cdzEH0RB3cHCgw8PDFCoZwaErKT7G6L3yVsQDi0DzTfLXPRZFSpTfSz/dw+lKA0qO7xmeNxwOtVU91ivVfb1Zramazd67lA30bqWv1//0vj74MxtzHncHtJwLiJIbx+1eabyyfL6ysqKDgwMNh8NkCMrzXK1WS+12W9VqVb1eLxUGgt/hcfA8IHBCnGuXidAKc+UYIHqUFxYWdHx8rG63m7y1pBeUSiU1m820RqPRSCcnJzo7m6UJVCqVpBxCw/TdabFoTfnMQx59fxQp/7FF+ngZrfl98Dlf0yLe6/vE97b/ROUKTBH7Hek7rsd4PFav15sLPXQvJf3xKr2OEyeT2Xlx9+7d0/7+fipUdXFxoZ2dnZSi8frrr+v+/fs6OzvTd77zHT179ix5MsERa2trKTSVOYpzk+d5OvewaM4dx/Ac915H/hGfQaipt++pHkta1lKppqXsXBv/7ruq/CcVnZ+fX8FURYpUlBdFivvLFKmX0de/rDaZTPRTP/VT+lt/62+pXC7rp3/6p/Xtb3/7N+Xd31WIIK1ocqOCEwWpa9uuYOENgbn5mTLxHdJ8KWnfLLE6mytYEchWKpV0zgblfYs0d3//z/9MT6WzscrlTNl4OqsaeDHzYuXj8UypGo2VjaeanH9dtcYvpPdomktZNrumPuvn3/3fS/qxPzSdU64YizOPXq8384Lll2E2/X5fH3744dzhiX5f9Bg0Go256nc+R86sfL7Y1BR1wCp5fn6ewtJ4BlYQ1rFos/L/y5QsrovNAR7j8nCZIkCR5zNvnOccRVCJsFtdXZ2jlTg/WJ0YI1XVvBAKXiE8YK5AO4N0QOZWVhew9GkwGKTrNzc3E1AkvBWQSq6CW+/p/3vvvaeTkxO9/vrr2tzcnKs2x3lFW1tbqSJc9OiyXg7q+I79hJIFEMJLGM+sAnxKl9ZiwBDz7wpKEV3keT4XsuEKA3TlxSRuArs3taic8bcLTsbkCkrkixcXF+p2u6rVasnjB22yr64TXNPpLKxlMpno7OwshbjcunVLa2trczRG+LVbz6G3mHROY60iUC/iv9Anz7p161YCLsPhUGtra2q323OHPjvQiO+IY3UF0JUUgBjX8D+ACtpZWFhI3miXB9yL8S4qsT4XhIHxc3R0pPPz87n8QKc5/9/lnsvBON9FvK8I4Eb6cy+u3xP5lt8jzYfcZ9nlOWJ45LkeDzj9Oz8/1+T3/k1tVE50q3yqaracnr9ebqhdHmi/3LyyX1Fe3VgKn/K94+tdLs8KKvV6vYQJlpeX1Wq1Un4r19++fVutVksLCwt69dVXdXBwoNPTUx0cHGg8Hqe8USISms3mlZAsn0PmB/6eZdkV4OleUOa90Wjo5OTkipI1HA5Tnlee58loR3gwuXM8wxWQaCSN8jLSF/PustXHWLSni2jspla0T503O7aLYJ3fztuLjN7876GiUWGMhlPmttfrqdfrpflst9tXFJvIYxz3uHF6e3s7GZjpC/mjv/Ebv6FaraaTk5NUvZJn1mo1ra6u6vbt23OVIIvmMs555EeElUMzGP2Rp1F58vmP9JrnuR78xF/X7crl3l0pDbVUupB0+RzkQJFiFWWT86OIrW9qL/v+X2b75je/qW9+85u/6e/9VCGCRUAjXhOZv6Q5UO9AEmuqNMsh4XsHhQ6YoiB0y0mWZXOn2nsoQRTUWNPyPNev/MqvqF6vp9wVXPZYmkgen7NcDS+UV8sSVQPzXMqnyj+pEJg1psrLmRZXflFZVklV4Sqf0FW5taJscVF5lqk8HKfNUwTWIMadnR31er25A/3q9breffddtVotff/3f38SQFhGYigMHhHewfM998OrGrm3a2lpKQF2vqNCFOWmuZ97SPolHCqGhNGi0Ciiv8hUo/WsKBw0CsuNjY1k4YZWCKXDqh2TbV0R4JkbGxvJSkluF7TlTJDxuLUvgg/+d+9N3CulUknLy8tJwXv48KF6vZ4ODw91fHw8p6jAlHkHfcKrcXp6qg8//FAvXrxQp9NJAKRcLiewAjh3sOfM1PcX1wAKFhcXE4jhN4oXz4WBxz0O2IuKkq899DUcDjUYDNIYXfmFpuEvPsYoOCLwiAr8dXTKc6GZaJ2NRh28vN1uV/1+X41GI/Emzy/hGQ7iaJ5jNp3Okva3traSdxRl3On14uJCzWZT5+fnc/sQPuiAN+7D+OP7EVpg3m/duqWDg4PkzSUU0nlaLHscgUB8vuB2UbEAACAASURBVIP8crmcjAeEbXMvShBzVKvV1Gq1dHJyonfffTeVlUfJdHrw+x1MccA1IWXr6+vJszIYDFSr1ZKHmzlgjE5r1+XEFIFl/o60UASYMQr5OLje5R18ZjKZpP1F4amzs7MUAs7huzwPw0W/39eLFy+0nU1UVq6L/CpYbJdOVc9GWl6egTcvhoSiSv99X+Atc4AGv9va2lKv19POzo6WlpZ09+7dNPb19XWtrq7q7t27KdyPw4jBAdvb2+mIFUL9416PHhYwiNM3xyE0Go1khJtOpzo9PU0012g01Gg09Pz5cz1+/Fjb29uqVCqpaAdHaeCdKpVKqbIcfH00GiUeydpCV9B/0R6V5lMlioxR1xky4u/reF78PBo1+TvyCegJmiQyyWUzETnOZ+Bb7rWJshk6wpPf6/XSumAQLpVKqYiEGzpRuGOuuY+11Wrpy1/+sh4+fKgPP/wwHRye53kqhNHtdpNhjH5vb2/rtddem5uLqPRigMXjH+cYujs8PFS3253jgcx5vV5Xq9VKGIZ1P/v6X9XvWPxA9ypn6pRqWirNK2He7lXOtFM9Up5vSpo/s8yLAfl88/4ipbGI3pwebqKz3+rtn8uDRYuarCsGDsocvCCM/JyL68B1BNi+uP58J2Q2bZHgzvOZK/fg4EA7OzuJoLD84h0gf4XNUyqV9K//m4v63/7ixcwTVS4pr5SVVSpStaasNla2UFNeX9C0fulRSjli1U8Is1qTKhWplEnG0Iu8bMybx217vtnp6amePn2azldifhzc+3z4WkiXyooLZl8rt9QB0sk5wnvoIRQAQDZrBLQ3bc7YIvCNn3tzAXSdlYxzN7geKxBFH4oS213BcosWidKsi1vXfYyRyfJup81YQMWvjYIny7JU7np5eTnFiyN8eFY0KuR5rkajoY2NDa2trc0doM3ceagE4/f7oyBkrPSZOSqVSmq1WsnjAvj3XIMIbiQloec/5GN4uATGmaLGevPbhVoUdEV05GO56e9II1GgOu2y/1BaJ5NJ8v46b8FYgaGHexk38zEYDNKZV06j7h1yMAaYiTQWfzuf9fHcZGl2XkPeoL/bQ/lcSPu7o1xwpdrnHCDqVQGHw2GqvsaeAnjlea47d+6o1WolOsUb1e12k2Lr/J+qooR2uZKI0ouhi4IXkW9GeovyqUiRva75cx0ERqt+VOojvQNuUXwxPOFpid5FntHv92ehxtOadsezqp/l7FCdktQs1VRSScO8plF+eVg5lQPZwzcB96gc+vuJDICPYOQD/BHqTYRIr9dLeZn379/X+vr6lTB/n0P/YX95n5DdnnflYajQE+tNpIEbOpln50XIUvLNoDHPafaQu7hH/bMi7BPn+7p9FgFwEb1d9yx/N9fH76/zhDhviKkFfEYFVd7jhmXeR+40+z/LslSp1+U/7419cKWL9zj/K5fLunXrlvb391PhCpo7AVzedDqdK8bTOFexH3FNJSXDB3PiWAq+hwfL8/jq2Uit0vlLlStJqmWZGqXzufVg3B75EefFZc5NytJNfO2z1r7rHKy42eMmjhYXD6WA+AnNY+NAlB6SRGPRuZ8WQWIU1H6/9zXP81RAwMMDIXryHDjQ0JnRdKGi7JNHZ9LsrKvy7OyrbLGuyfKClte+pclkHlRXVv4vTfpfValWlaoV5eWy8tJ8EQH66JvPLVl+CCnWhoODA+3t7enBgweFXr4I3H0taO4BYOxFLmcEL+7v5eVlLS0tJUuLM5si5l0EWCPoiPdEcOdCxRXICGicueb5fA4Icx6tbA4I/R1ugeNwVVd2nX6lqxZr76evDVa0IsDqfadf0OZ0OlW9Xlen00kH58FoATYeJjYej7WysqJOp5MAAvsGOuL5/uN7s2hN/G8XAOQ60H9CWF3gRqFDeBtr4RW73BPNPFcqlbQ3nT4i83dvQgS5NP+/iN/52CMNRyWz6FmuZAFAAQnlclnLy8tpLxUdMgptUr5/d3c3eVBYH+YL7ywgwj20cQwRlMU9yXcoyjEiIM/ztM7lcnmu0Ab9LrKsF/GkqMD7PDtvGY1GqtfrKVySeWB+KXIhKR1Wy/fSzONAcnqv19Pm5mYqToNF2GUN+79arWppaSmtUQRYvhbuvSqijU8DPm4CL7EVKXbSJY/J8zyFcGKM8WR/8oBojAcDx0f/5T3pP5IG0wVd5GWtlfvqlIaqZ1P1pi2dTmtJCcF7D5/iuVH+098oK5wGO52O+v1+UvYODg7mwg557snJSVqjhYWFFALtc1M0n+wzPN+OIXwez8/P1Wg00ng89JS9Wa/X1W63k6LGOJ13s2eq1WqStW7kc7CL98zX1WmO5h6MOIeRPuLf183LdfdfxzfhET6vLvdcecIo6ziE7/yaqGCyrxg/54LyXjylUdYW4QHkd57nc+GI9BU+srS0pI2NDe3u7l4JDY4RBlk288pG5TTKC5RFnhExAY3+ouDDlxw/M69EYV3kVR1O69J4qLXySJvlxpW1pfWml7QWMUj0SsY9dB2Wi/NY1D6Liten8mAVEYxUPGEOEBzMw2QkpfN13I1LKwJDNy1ijEkv6pt7cc7OzvTkyRNNp9PE4Ljek1wRMHNWkVpZWS5l5UxZpaRsVJZqVWmhpmm9qsni7FkOvrPsE+9CrTJTrqoVqVJSXi3PMUgncgeUWB+n02li7ljKhsOhdnZ29OqrrxYqIA5YvD9R+YWxeUx+EeDxXBvANP11YeLrHpXwot83bUq/zhlvtJBd92zvh3/udFZ0vT8HSyPgDaHIoauExUSvD8+PDNrHch2Nx1h8mgNNnss6oJRQpAIwQn4AaxvnjucWKb70JYbDubcwzrMDtu+GGbvyi2UXpdH3JiDF++Jzxfy78cLfeZ2iGFsRAHG6iUInGjD4nHL2VBdDOcjzXOvr63N5GA7seR8KKBWsnj9/nuYfbwTgRVKaPy+d7Hu5SJly665fj/Li46N/CH73hPi4nb/5b//eldAoC6ICTTgbtMAcYDTAM4CX2umK96yvryvPZ0a29fX1FJ7ltE3foEFoEi+jN1e0AOxOj0V7yteiSMEo4gmRPvz9rozH8aJgoazgQaGsOEq9y1Gnm+l0qn/6n7V0fCz93j+zoW55Sd1KX43sQgfjZT3+s68oz/NUfRUFKwIx7y/g8vTrP6et6rEO/8YfmxsnsoV1ODs708HBQRoj4yQnEeWu0WikPcK1TpNxviKv9rWhwXPggQBwz/2TpGazqePj47m1iPSMgZIiRE5n3EMJ8egdjWvs+/M6HvYyoMv9n6YV8buieeNz8pBddp+fn8+djci+BT/wmY+ZeeT54/E4zRF9oQgKvIq978/lWp9r1sS9v773PK2C5h4lxg5/dqWpqKCV5+UxdsZBfhV94rnuseL9nguOcaH2d/6g3v/Rv6Rmaah2eaDvq51oIStpmueaaNb/UZ6rOy3p6aSlk2k9zTfzA98sSumIWOk6WV7E1z7L7bs+aDhuMt9UWGkgHhoTj7Z9enqaqqgQS839LhjjO/15ELpvHn7YVJ73ARj+xV/8RX388cepWhrMk4p/29vb+uIXv6jNzc0rYOx3/WiezheSlCxN77//fioVe3FxudkAuNPpVFqoKGsvK6+W9fU/eGnNpu8+X54H88orr+iDDz5IhS4ajUYC19PpVO+9955++Id/OMUEU36c5/rzi6wSjB9PTbyGDcdcMv5arab19fVUJhwm6NYZH8d1wJT1jGse19m/KxKa/IYpu3UGK75bzbxSoHTV2+ENQd1utxPtlkqltIa1Wk3Ly8spf8EbNOr7xJk0/7sg97AJXw/6Rw4ce+XOnTsqlUrJo3X37l01m009evQoHcTKGsWclLiXfK1oHgLJfHB/0bpF4RPH4uCjiBHTB0KBSqVSCpHr9/vK8zyVAff+OP0xNx6/7sLeafwmIOL73wVrfJ7zPB/j0tKS1tfXtbW1pcVPjmrgkOByuZyKpKCsLCwsJEMKNEwODQf+8v/S0lIKnUPRyrKZNbVarSbFBwDhOZ8OUNww4PPD/uX7WInUlSYUX9//cf8Wgdki+mHdAGP8T//ZB4xtPB5rb28vebY4mw1Qg3eNCnXNZlMbGxtzeQx4tDFOsEeOjo5SaDS810FuBJre/+g5jIDFlXF/3nUyL74HvsR6eYgP1+LVm0wmOjw8VKVS0erqago3djAFTZAzxN9UVfuNP/dWGse9P/W+Hv+5z0maVWlttVpJ2XavZ2xZlqWiIeuVEx2Ol+f4kBvq4K8PHjzQ06dPVS7PCjZBc7u7u5pMJup0OlpdXdXa2lqSfb7vo3eKfeIh927Q8P0+Go10enoqSemAegfGfE6hHhRXCon4/LoHeDqdan9/Xy9evEh5mexrz0NyJYj+u5LJekSDHd/52Byvxd+fpjl/d0+Mj41581xkeNTh4WGKXCIvFC+4K0K8w9M2WLezs7OknFJ8AmxZKs2qN6KQ4OlCVsNrUVCKaJT5Ho1GqRqlhyZ7414KZLEHfQwuL2KhHCoXT6dTnZ2dperA5K8T0nt0dKRWq5XyCeH34AZp5p3v/82fUF/SXqmk70jqfv1vqpzN+jz4S1+Zi0I4Pj7WZPLtOdxXVIGxyNAbMWSku+vo5rPYvisPFn8XbWIXNNFyBCFWKrPCDxz2mud5OsQRoUkM/E2LEt3n0YLNe7EOQUB7e3va2dlJRCxdVmwhZOKHfuiHUnKqM1pn+Hh7eJ8zGg91AsRLUinPNa1XNK2WU1zvdDqdi/V30AIYfv3115Xnub7zne8kawZMCYHG53wWLWD+t6+Zewzoe1RYYYisl4flsBmL4s15Z/yJ9BSVPW/+vGhZdJAbrXp+f57ncwe9en4P/XTlypXJaJEHkHhFKAAxoKzIIljEfKNAdNDvAtG/i59Ls8po+/v7CYhPp1O9ePEi0XRU0KC7qHBHQevg8bo++z0OIr2fzBXGCB+nKyzMX5GC6oqv00MRzXj/4xrEViQ04/fxnf5d0TujMYCcPTwFXONHIiDoeT55a35grofOAFC8+iJzFcdWJPDd6s1nHrbKs6JAjZ4ZV5xobsjgPvZS5EPwOL+WfvN85/WEMvM8nkVeFGGj/g43ZET69D2Ph4q9HAFEuVyeM4r5s4vosIjv8XnkU7HFdzuwvun7+H435uT5Zfj7ysrKFb7jFRYBbRiiRqNROs8OI8xMubqMaqAV5V5FPg5dv/jGj39CA6Ok2MS9hqGOnCz492QyOxYCQ4wfFeC04XKC/vkZRK688F7nCQByjIvQJnICecu9GB9RCHgfdIwihcGX/9l7MWTblWUfkxusfIyfBvD6utzkwbqJv7I23lfuYU/BU1CeBoOBLi4u0hEbrtzEPeHj5lo8lqzjyclJKuYjae4MS/BXlJ2+HvQVHsv74VXSZbRK/M5pnGJocQ2YD/iMG57dKM16jkajNAawnR8hg6eWPUafPeTU99Hy3/7dprCfzs2x5zgz/9wf+c11MtLpsYj/RSz2WWzftQcrNt/8RVYgGgpKu91OZTTzPE8Hu0EkbHrPI3GhLSnlmaDM+DvYTGw06fKw1w8++EBnZ2cpVAfmhsv5/v37Wl1d1c/9L8cqnY+lqTRpVPWH/sjKHANB66dRqQsQQH8B4Y3y71c2nmpaK+v7fttznZ1VEiMmvh+rSyTmVqulN954Q8PhMPUfALawsJByMzY3N+eYBv2ICooDBklzpZ3dosNzKKBB8qXTQAzP9DlygBeF2Kdt1ynz/rdfc92GPjs7SwwI0OCKoitY/EBfXmac63lOkRJSBMi5Jl4X+x3XHjoqUi4lJUU/hqZQDMErN3mfYl/43PdPUZifz8FNQNFB5/Pnz68IOp83V66iYcUVAM8pc69g0XpHWufZNwFiH1+cl6LvI8j1cfv/8Vw0+sJec2UCvuJ5dBEEMQaABgqM5xu5hTuCFp/XIqFYNCfXXee0GZUaB4hx7oveUTSPReCPkNyY/L60tJQ8DfCeOG8oD9PpNK0Jssatt07nsQ9FRg4+B0AVzXMRj3JlsuiZRXNO8/3qnzlohA48dA/+IM34N6F4KANOP4CzSqWiVqs1ZzRjPRcXF7W4uDjngS9S9rx/yF5kKN7ZIsMq/Wm1Wur3+zo9PU1HV3jhCwyBvL/IU4rFnzXB0x3nP/IO7wc0HfkP9EaJdldana9TUhzjnBspUbp8PelDNIrQ3BN9E197mVJ/3T0+B9CWv+86WYf3KSpI/X4/RQ55eFrc804L0Ug3Hs/OvTo/P09RUXi8eScVQpkvPEL0k5B5lKdyuax//PeXpFKmr/zQcRpTvV5PfMWN0TT2kLc4z/AWN1z4ukmXlV8JFazX67q4uEgVTTnrbWtra47vcR+N6IeivEpolDBL+kI/3NjvfePeIvq5TrG6jud91tpLFawiAVokKF2YSlcFEULNk2ohTsJZ2EQOSN36yeZzi7ZbM+OCwggB+k+ePEmHGrLpOG9gc3NTX/rSl/Rz//OxymcjZaPJrIjF9HKKYLKEiWFFQxAxJq6j2tRKNpLyXNvf81ClUjt9R2gBza0jriitrKzoC1/4Qkpyd5BcrVb1/PnzFNLIdw5OoyBnfrzKEhbcuKYoj86w+K6IqUd68TUrai40ipRyf2b8PtLYdQD47OwsnVXiTNY9YG6d9TX0JFN37xd5T4vmm7l1xuNeSh9/VNAjXUiX+REuwLMsS/kUjIUwmDyfJQVjZfM+upWQZ3p4V2xxDb0vfO9rMBwOdXx8fEVQF3kes+yyEqLTMOOPxRrYW05vUcl3UB9ptUgAREXU6aoINN6kkPkcOyhhLT1UM77PlXeucQXVreAcWOq8EtoqajzDxwnN+F51RdhBk3vl6TvPi3mY8KeiIkU+j3E/8Dlzyb707+BXzM3q6mqq/gpdYhUGgJGf4+fJRM9VpPEIMrw5D3ClykHKdeDCeUSUrdfRo1/jcrWor34v7yFChBA2Qv9QsvxZFxcX+sJ//FhfKZ1rmFf14Z+dhea5MQrFBr7F/DodOU243HJFwsEl4NH3/mQy0crKip49e6aTk5MEenmGn93nwD7Oh3siYp9clhStB/yJvemhfM7nMeZ5KCnPhx+WSrNqq36oOx6evb29K0a1orE4z72uRdx2U4vX+rvjnLkBxfvn97t3D4WdNAwM7Cg4Ti9O+8yDR4zkeZ72OEeDwGcI0S+Xy8lozl7kXRinCTnGG1QqlZRNpip3h/qVv7ukt//VmSEGrMg4YxoAeyDyp8j/oU94d6yWCH2xP7xw1eLiYjKkZ1mme/fuzWGTGBbLHnXZ6LLWI7Z8z7uhvYg+bsJnN31WhO0+K+2lClYRw/Hf122yIgsq5wS5lYJcKTaKa9s8zwW0K1WEDvghhK6R53me8lUGg0GyhGG9GAwGCXyWRj+if/T3pSyfnWUlXRKZu/dxU7PxDw8P5/KyYKT0Jc9zKZ8qG41Toi5J7ShahClC4HhJ2KB5PjuD6c0331S3202KGZ6Up0+f6nOf+1wKO3JFIK5LBK/+jhhXTeU8Z25u9ZEumaILUl+/IprxFoGsfxaBeWxFjIDmig9enul0mkJJoEEYilv9CQlx+qlUKin+/qY+RSHl+UBRsYhgyu/nWleW6SNA15W/drs99+xer5eeub+/n7y2PNNBf5xL37O+DzFUuMEjhnk4WOaoA87dQXj4fo7hXkXgAm+ipGTUePHixRVlyRUUp8ciEBJBbJEAuAmgMO9Fa+f3Qjs+z5PJJIF+n3f3oPpeYK2hR/JCvPogwt+9/t4n9ndUSH2fRpqIHleAAkYwV/qjQYJ1Zq9FT6qPl2c54GUdfX29lUqzPA+8o0RHwJ+5l8R6z6/ykGgUBc89iMCH/gOCfH3jHEX65e+bAEYRvysCrX59EW264dH3IYVv1tbW0nlpnCd3fHyss7OzZHzi+f1+f/bMLFddI9369x9q/799PQFZ5m1hYSHJPx+Dz4uPKypQLi8AxEVjpoDF/v5+kufIwa2trQRGY3ig85Vo0HLFyHNyYwSOR6vA072KJc+rVqvqdrs6OTmZqxhHUQsKjbTb7TQeaIy5nE6n+uCDD+be74Yw779f47iHdh3vKuJXRdcWfeb4wPd07JOH2fv+Pzk50WAwULvdnjsn1fuGbIG/uCJLPhfKFXOCcg7tex66K+vwyhiuPpvoTFnvVKXDY737jUWNbrdVX7k8M7Ner6vZbGppaUlHR0dzsgm+5XuPdSVKyJU6NxrRBw+Hjl4sco7BY7zT1x2jqoejRzyOIu8hglyHTIvY3vdLpI9IQ0WK+WdVuZI+pQfLBW4Ewf6de5KccbI5POwvy7K5hEeUipssSfzGE7aysjIXJugAlGpJlUpFe3t7+of/8B+q2WxexvFf/Ig65+fqlKU8r+oP/ETritb9137mRNlkqp//qwN97euXnpxut5sEE+DRG+9lLp7mP6vbSz+uwcEP6Pz8FyRprjACVl5XHBH65KtNp1N9/vOfV6fT0Te+8Q1Np5dVEB89eqT3339fX/ziF9NawGQ8VNI3NP87k8Eqh8XIrU++pqyzh885Q0TQMSYH9bw/etniGjvdFW1at3ohXGNxFZ4NzQFMUZDpN7HNPlce8sN1FDLxWO8iBcjpKFYT8nFyvdM84A8hADBGuCwuLmowGOijjz5K76T/WEJRblAOd3Z2dHp6mujHz3Bxa7T3zwWdg2Bfb54RPSysuYfruDBkTZlj5iLOidOAh7Di7Y6hsJFmXDGMdOVrUuTtKaJJv8dD+WgIRkAFwNNpqNlsJkUpz/M5qyFz7TSM8YVziw4ODnRwcKBWq6Vbt26lPbiysqKlpaUrJbJdeLdarTkPJevDNYAFDzlxWnb+RPGESqWibrercnlWch6DAjzMeYzPk+895y/0HWUGo4B/LykpcoQwj8djdTodnZ2d6cWLF+r1eqniKfuDn5WVlSvrHcfK/EDbrKdXf3PvnBtPohc68kensevAx3WKv3vK+J99iWfUFQTodmtra65w0+LiojqdTjI+7ezspL4DfB/9qZmh6f79+2q1WleUUcKe8Ba4Rzt6HSUlQyo0yHyw3rwfQyFyolKZVUSlBHue5+p2uzo6OtKdO3fSAcooS36vG6qgR8IEmV8vLw9teUiypGRkRGHy8+x4FvSys7OTcr3ZB8zX7du3k2LlhlSe74Ywl7leGc9b/D/SS8Q0kcYjv3xZiwYR7mXN4RHQiR/KnWWzA6g//PBD3blzR2tra8kY7X2MchSjGof+rq2tXeFLhOlhoGYPuhLC0TtUDgVvJjwwyTXZf6EcZfujR6r/oZlD4O2339YXv/hFDYdDPXvvc3qtk0uf3PPsnVx5qaR8oazv+x1HheuA8QZs5Z5e5w/M3cXFRSqqBe02Gg2Nx2M9ffpUpVJJKysrqaAPhjeiGjy1w0Mlu91uOuqD/Qa9uyLoc+jOkmhscD4Vx3ydMeCz1G5UsL4bC4crUtETRYMJw0Alqd1uazAYJE9O0ULAwFCuODAVpsMCspEAmtKMoD/66CMdHx/r9ddft3NnLrSxsTlX+YpnwUR/9+/L9Le/ORtjv99PeWJ7e3upr4PB4Mo8OAPiu73xX9N6+ScSU8XiQj4QYIFDFQFWtVpNKysriYGvra3pa1/7mvb393V8fJzm7uTkJMUk++alH9HbU0T8KFdemUya924QP+zWd18ff360okTLWVzrIgASr4uAFyZxnbUkz3M1m81UkpnxeglwqgJK89bCyEBQsMfj2TkZKA3OKCOockDk44uMy6/zeQKASkret1qtprfeeku3b99Wt9tVt9vV4eFhqrAF8H399de1urqaQDNWMUCO5wBFxQMmGwGdK1l+PfvflQM8BBSUiZ6kqLi7sunr4euNMoE1OM6z99VDK/198bqi5utepNiz1q6kROVT0lyCuxt/aNFiXySsnOY53iIaL3w9eS6C1fsOCPK1gjYB6NHa7+Pkep4D2K1UKrpz586cAS3Sio/HPZnucfS9xziK1oU+xvll/J5bA31EWvJx8mxX5Px50lVwFL0lN7UiABLX97rP/D6Xq85TfI0jDSFbfD74vlqtJoWTkMrRaKT9/f3E591oglwolUppX9Mf9+65zCnqWxEPARzHMeV5ns6jarVaOj8/V7fb1Wg00u3bt9VsNpP1fnFx8UpeD31jrV0BdSUv5j/5HDqwdGXSaYfQNX4kJaUQemRO8MDipfDm2IG9UuTZK+Jl14Hcl7Xr6Pc6hc1pjzl2vhf3Ld9jqNzf30/KkkdBxHdOp9OkGFEwKCpXTofgEucn/ixoACXGZVB2PtLUQqAl6fjg+/X22zW9/fbbkqSPP/5YpYtFZecjZecjaTqVskzTVkPTbN4w6byKKAQvsBX3KQZV58v1ej0dD5NlWcKD/X5fR0dHGg6H2traSs+hCAzjdZlAqkSkc+SSO1BcVrpRK373adp1tPlZaN9VkQtffGeUtCiQuA4mQfgGrvDz8/PkoVlYWEh5BRFcuEdncXExldvknQ5spfkcAixNb731lt5+++0U3kCLyYYw816vp+FwqO/7ysyy1OsNU//xDJF/Fd/rgsMZz+HJz2izvqmFhQUtLS2p1WolpY0iEjBTnueFP7AofM/3fE86LLLb7erjjz9OpUJjyJYn8kYhX6T8MKcuFF2RZbP7ehcBFN9UHgYQ++GWxNgi6I/9dHDtwj3SwMrKSspT4V0wQBeIgAKui+Fb9ANLD654HxN9dqHoTC7LMv3MX3yhH//JzpyC4Ne4skIfptNpeh8lo9fX1zUej5NVqtfrKctmh3TeunVLnU5nLlSl3+/r/PxcnU4nrYvTn4d0wHBjuJpbF1FYmR9XRvBaxTC4Inq7SQn35u9gPX3OmUvmvCjhvoi+iujM/4+gu6jf0Jx7oLLssopis9mcW+MYihHpx0EnSeHlcjnNKSEq0A7WXQePDpB9vqPw5294BXvHlRieh8UTHtjr9XR0dKRKyWBDKwAAIABJREFUpaLT01MtLi7OFSLxfeLvh6fHw6R97qT58OzIvzB20ChHvrGxkfJJ6/V6Cg10o5MrBJFG4KOec0pYmAM3358RRLg3J/I+p58iOvLPIo3Ee2PzYhFRweR/5C9VRyli4ePP8zzlAzlvRR7xLA/599DqyDOi58PXO86d81Bfj+XlZa2urmo0GunRo0eq1Wp65ZVXtLCwcMWj5KHM8DgatBGVaJcZPg9Zls3dD2+miiFj5wgJSWlO19bW5ng4tO8HVzvgjYYvnhUNSE6XRXmcRf/HFr+7SdF3vMX/Pl+uFEBvrjA7HcArnj17lnICnccyNjyFvV5Py8vLajQac0Zd+CH88SasQCMSAMzAeL71iyuqnRwoxjKUh2O99dZbyvNcu7u7Ojk5+SQ3P5cmE+liJNWqyqtl5ZX5qBz39iJ/ozJZhIf4Tf49NMw15D1S9KXX66W0kzy/jI5wWTWZTPTixYt0MDfRH07jXiTE18OxLPNaJMfjZ9fxvc9S++euIhiBBZ9FsOnXoLgsLy9Lugx/IWyj0Whc0fABlJ6fwHeADre2ehgaFtk333xTi4uLOj8/19HRUWJohHt5eB6CB48VCpULlnq9rjzPk7IRlbsiAoNA+/1+shhSIQbgcnZ2pqOjo8Q0XCgyNhRAQObKyopu3bolSYXC7TrgWrSxYX7Rs4KS689h/WLsd1SwnV6KQGx8Zux3/Nx/opWK58ewPLydWN2lS+CGS568DT8jwxVd/3Gg4cLYLaS+dg4k/vJf2Ff14XP93H9xonyxpkljQf/Gjy8lZgeQXFxcnAu18wag5h2bm5vqdDpJwHMOEuE+hBZWq1Xt7e1pMBgkT9bCwoIajcZc3krcu/5eQmIZL6EZRR5SFFEHU55E64LDhTDzH0E5c8Eau5cLIwDhR7QiT8R1StxNAKUIhMfxRiArKVUpXV1dVZZlc/mZvmc8gZ5cAYRzq9VSlmUJRLZaLT1//jydncL9eLCLmgu5KPgcyEqao3238HqoKp8TuoMBjbO5UKygAdY+8minbV93V5LdgEK/nXcQQnR8fKxarZZC4er1utrtdvL4YdSDp0OXRdbb6IkgHJy5g+ZcWfXvorf2ZWvC/0V/03z9orLlwN6NIq4gcS2eZbwJhGI6SL5165ZGo5GOj4+vnG3FPiVvmLnz4g5RXjjAdoXGgR7zAe2gaLi8dtDaarWSwgVdepgafXJl1+WQ8+44l/4dtBg9vj4+oj/4v16vq9VqXfHEw285/5N3uExzxT/yTDcIxbznSCc3/c3/NylkRf/TIk/1NaWfrlR7lAl01O/39fHHH2tlZWXuzEN4Wb/f13A4VLPZTAY17nflClnn6xcVKFdIwW1zYax5rrx7rNiys5HK5QU9f/780vjP1p7myqdTZdNceTnT9/2253Pz5kpgNAb90t9fUl4u6V/5XeepL8yb85FyeVaYBmM+e4v0mn6/r8PDQ02n07k5cl4+mczy9A8ODtL+QoGL+C+ut8uHIjqIcsX/jxjzs9g+9TlYESCz+V3QRe2X71i44XCow8PDJHixpBEjj8LgFriiDe4MDsIgyTYSDu/Y29tLB016+JMTUa1W09bWVrISUwqZKkUzT1ZPg8FA+/v7ajQaunv3rvb29uZOF8d660KlXq9rY2NDR0dHevz4se7du6dms6lGo6FOp5OSD4kxZ2NubGwkIEPp7Vj9ZWNjI8Xishk8/yWuG39HqzAhCwi2KHjcu8hcYLVkLr1Kn1u3igDpTc03K8/2je4KkivUACaYiCu8rA1eUJRaSpZ6n93bIF0m8hPj7yAKcOyCHcsb39VqtZnS1D/XeOfpbA4qFVVe2db/+rOZfuT3XSbEDodDPX78eG6dOL9mY2NjLpl7PB6nilr0F6DpCg7g4+nTpzo8PEweFca1vb2tTqeTcgAAMnl+6eXDoojxgedsbm4mYE+4ZZbNwnlXVlZSWWXW3WO9fZ1dGLo1bTqdqtvtzim1UaH13DWnITcCFDH7IuYflarrlBM3SCDQMdo4L9zd3U2hzZRp5l7WkPVxIQwY29raSmXIX7x4ocFgoI2NDT19+lTPnz9Xp9PR8vJy2oeEzfR6vWR5JxTJeTN80/cOtBWVXcYCcCQfiUNe4VWLi4vJoBHn28MKMSb4eN3q7V5lxg7IJcQVnsSz2u12Mt5tbW0lEJvnM6vus2fPEkihP+6ljTIHQ0qv19P+/r5OT0/nihC5osKY3PvnMiDS1stAR+R/NDcY8CzeGfsF/yMag/y/LJuF0nEA+fn5+VxVztFopHq9ru3tbWVZpv39/ZQD5bQDvWAMopCUzwXzifHK6YC97XPkCiEhVQDifr+fQugPDg4SLbnC4WdCQh9x3xb97/ze5ZX3z4tIgVk8CoF3sdfJEffiKoRxS0qGW4zKGGOQs8hTPBbunXbPLjzOvRGRvoqAL/NQZAyIPLCIXpmLqJQyh4uLi6koAwoGOWcojM+fP9fu7u6czHbesLi4qO3t7TTP5XI5heez9/CUIyfL5dmB1FSwjTIBHkDOaJ7n+v4fOtGv9O5IrmSVyip1e/qFvzTRdKmjvLqhPHtNpelYKtn8lDLl5avhx9AjUQzMzy/9wrLKZxfKRhP9o29WNVmq6Qd+6CTRBiF+HHLMUQjwXAxa4JHd3V19/PHHc7nk7Dfe7cope9yND0SRwd9cViAnHBdGeejzW0R/n9X2qRSsSKRuAfIJL/rt97hF3Z/juVMANQewDpKvU7hgitEimud5YtIeCuVlyV3g9/t9LS8vJwDuuV70+/j4WMvLy7p7964ajUYCtzBYVzwRep4H9OzZM+3v7+v27dsJ3DebTbVal4U2KpWKVlZWNB6Pk1LnBx16aECv10ugjr4UKVhx7oryNphjV9QcZDMmkpvdKxTnkmc5IIh0dNNGLFLWfV2xWnp5+Wjxk2YnunP9dDpNjIVKjNVqVUdHR2msPn7G5JZD8mCih4W5xvJLSN5oNLo8QHtsSut4PAs1+OR9p6en2t/f1/7+viQlgEgVqtXV1TmDAEoPoaUovJ1OZ44WuTbLMrXbbe3t7SUlBsX+3XffVbPZ1Nramjqdjs7PzxOzhZGjGHHS/PHxsQ4ODlSpVHT79u3CPIFGo5EEnwtW5pX1Ym3c8sd9CBXf2ySFQ7euUPuaOM3wmQNh70tc70irkf6kqyXVPcwSI8l0Ojv8mT3NO/AcsAfdi+neBUI9CQ0dDodqNBrpQHSKrhAKjKHEFVjmkzF7MQ43RMAX3ADF/87v4dXT6VR37txJoXjwIYCOtyLeHUEy70VJQGmleiFgwM/SGY/HKURGmoXwsncwLmANpwHeoQmndcY5Go10cnKSDBheCtr5jPc70p3//2mVq5c1l3sewSEpeX+8X36MCPwJRRoeiGHt4uIiyUrkJCFdu7u7WlpaSgoVDXDsAMznMe4lQLHLSef1bhjxMCb6RvVfP8MSQMj+iQY9B5g05J8rLtJ82gEyD6+y8yyXS16Eh/lgffC0QGPMf1EhKffauvEohqL6fnXl5jr5eh3NuVy7rkWjg89xNF6x9s7XHZu5FxMjHN+h+LhxN+4rVzRjzr4XJqGUP3TsPIZ7PDwzz3N98Xef6Vd3N2ehfybLsvPRJ2OQsnKmLJ/J7HyhqqxSVl6r6q0v70q65Ldu6AXzMqavfq2n//vvLik7PVcpmylnpVJJS0tLKVfLwyv9eYRgI3fgw71eT/1+Pxkj4KELCwvJk4osBZOghEVeFo04Th9xX0UaKqKzT0Njv1Xbp/ZgeYtgxK+JFhYH9wgtD8lzxsriRQ+NCwx/ty8cGw8G5QvuZT5h7ih7Tljlclm9Xk+VSiUJbIQTVdkQ+Pfv39fKyuwA4larNXf+is8XFqjV1dUUd10qlfTo0SOdnZ0lpj2dTtVut1M4EJbIg4ODZAVinugHcwz4IMHXFdYiTw7P8aIWeFmi8uzhFQ7+UFqxSjlgdaDrYNTpxN/jv6/bjEUbl3HGeXdlJ89neXiEs8Dku92ulpaWUtETFK9Ykt4BOTmArVYrGQIcwNL/fr+vbrebqg5ubm6q0WjM7rmYt5Dl1Yp++9f6+uCDmWJ1cHCg8Xis1dXV5B2hgMnq6mq6tVy+PP8C2j84ONBwONTGxka6DjA8mUy0uLioBw8e6Nd//dd1eno6Z03FKjgej1NS8WQyy8mhHDiAejQa6R/8H1V97YdnVrWnT58mqy17kDUm9AMgFJUQB1leIAEADDAG6ECT/X5/zjDgYaHuCYuKgdOgt2ixvU4YOHiLVlsH3owTZSfPZ8UgPMTJeZ4rWdAfClO3201z22g0EnBot9tp/QFwCFTfg35mFJW9XIF2morjRzlnDzBuAHqlUtHm5ubcs1hn5zdu7PG5ikY4vqfPnkdGVUaMI847er1eGsPKykoCuK4k+RqSw+qAEBnlRsJqtapms6l6va5+vz93kCc07HQVAWIEdi4vI0+LvNA/p/HsuCb0A0+JzyVebpQJz/dlLMgON155n9l/zAU0zPtQrE9OTtL7/FgLpzE3SrIeUS64HPN1I+IAGe4KFv11Dxl0ALCPoBXlkmcyx5VKZS5dgX2Mkh6LYzE2frvSBH8ul8vJyOvnaPkecKWLe3w9i2jG6apI1t5Ecy9rRde78gO/Z83otysYjiXceINykGVZCt2N0Q78diOPG4Z9n3q4IFjLD9COY3Bem+aw1VR2MWICZ56pLJOmU2WjiZSXlJc/Ua6qZU1Ls+qBed6bw03SpcPA6Y2/f9vvOtU7PyvpYqRSOdM//gdL+vE/vqTBYDA3r0V5ohj8eZdXx4Rf3rlzJ5WUh+6IqAHjgPu8Gio0XKTg8p3PZZSTNyn1/6KGpf8vtk+dg1UEQFyIw0iipcqvBRC6OxImjZXHGRCbh7ATNuN1PxCDl6V0AYfV0y3j9AeFBkLEFd3r9ZIiMR6P9fz5c21vb6vdbqfNgmWf8cTyn1hU6efm5qbOzs60t7eX8qdKpZIODw917969NG+j0Sgpbm7l8dh3GBgKWKVSSUoPm4ZWpGARPsJGdUuZWzF8c02n01Tww2nC5zwCUf8dGX2RUHjZ524pdVrjbwd8WLABBvSL381mM3ks3RXugr9Uuqz6hCIaPYXSLOfm+fPnGgwGydMF7ed5rmxoRVEaS8rrVe3uPkkhcOSwULSgVCrp+Pg47Q+q52Ed9dDEVquV8k1ckLlwJpmdsAGE2fb2tlZWVuYKDzAPrDXPm06nKp+2U/hCt9vVzs5OKt7CvLAGlJD3PEZftwgemC8scm6hJuzCi62w96RLsBZBrlv5fQ8U0Vbsi7foFSsy+rBulcrsnD5C6CaTiY6OjhKvwbgSjUxuSJGUkpg51mFlZUXHx8dzVvLFxcXkKa/Vajo+Pk7npeBZYk0dEMW5cEXVleFoMON6+B2gwO/zuWc++Mzn0OeOa+H/hIqSLwjIJocwGjfw8jkNedgVijuAzg1vPiaev7i4OEfPz549S+9krpgPeAd9j4Yfp6kiS7DPQxHtxXtc8WEv0y94FPdR6p8QO/aVh+cD5t0I6Z4k+BnGJWQfZ9RBf5VKRfv7+ymU1QHywsJCCk+OIUyOF9zjwRyPx+PkyYa3kE8H7bq8R9FxbOI05gVQ8vyySmyWZcnSjycYr53TuD/P184xkb8b+mPcXrgAwxXj43MMMv58B/JuwHSl2mkkGoJe1qKS78+N+w3acxpnzG7ghVYxauOx2djYSJ7qs7MzPXz4cM7T7Hlt/EY+Oc4AI5F/LM1SO87Pz9N5jD4PyBHfo5PJRJNOQ+XeuTSdKi+XpUpJcqxSzjRdqCgvZXr1zY9Ur9e1tramw8NsTsa48u3OAX6XSiXli1WV+kPp9FxlSX/lfzzQj/6BWuq/yz2noYij2Bu8a3V1VXfv3p2TVVRapDALdOh8v4hnM54ir3Cak2toK/b3s9g+dZl26arm6hssWpxcW/f/p9NpCktwKwYeI5Jq3cKVDgMuXSYWFyl89AWQCBhE2WBTIkgAj/1+P8VHY+GlD67gAJw///nPX2FmpVIpgSlAZq/XU7fbTUzXFcGtrS298847qlar6VyHPJ8d8NhsNpPllXe7BWJ5eTmBVneb+/j9fVLxwc9sslgti+sjIIAJTafTJIDiM2ODOfgaRQtpEa1FOvMf6bL6Y/RKoGQ6wIB5c70rHhxW6fkazmB8fWMiOM/3sJOdnR3t7+8nj9B0OiszK0n/9FtrqtpclRpLmtRmxoX79+8nUN3tdvX48eMkGMjNo88o0T4feT47jDruOX4AGwBJnxNyuzAMRGACaMQ6ViqVlE3ypATWajUdHR3p+fPnevXVV1NYBICPcAX2nAth+hmVi6hcwQ/cAON72cEV6+XWziK6il5dp9kIKvjclfOoXPFe1mppaSnlKLk3Cv6SZVkCbvTHjSb0fTweJ4UdD8Dy8nLicdAvSgFhxV6WH6/zyclJKvXLddCwh0tFLxqfObhir/mc+hxGD1W0+BfNI+PhPCtCISUlayyWWgxz7g0FBAOYPTTQc16YO/pA/+Gtvt94NqHjklLYYuSnTiM3tZcpWfFan1en2aj8+lw4/xoOhzo5OUmeP/aSNCvg4Uq6H2LKnCJHUWrx8vA+9gzRH9PpVDs7O9rd3U0KPkZVxsDediUqjtH5UJ7nyavEe5Ff0CHPcj7vShfXQD+ML+Y4lkolra6uqt1uz4Hb6OWFPngmSjmGLg/FBf+494W1m0xmhVrccARv9Qgeaf4stBhi6M3HzP/X0VW8L/4fDQUeQePyz42yrmC5d9QVXKKApJlCRNg5tOmeWu71Ijv0wZVs5CP5osiMIn4fHQTf+9sPNZlM9O1f3px5sEqzAhjZNJdySaVMtx78+ifFnUoJlzUajWT8jAbyIs+wJE2adWWTXNnJQNlwlpNVqSwl/Mr+YK14bswr5v8sy9RqtXT79u0r/AW+Wq/XU6G3GOnEOjqPjsYCpzXfB9fJUf/+Onr7rdy+Kw+WKzb+N8yFvxFwLmDZZIT2ALaWl5eVZVkCVH7StWv8FJkgbIrFxro+mUySouZWnyzL0jlS5KhIs8XHczEajVK5YayfFMSQZsm1Ozs7WllZ0Ve/+tVkCYSoT09P00GOLkDu3r2r0WiknZ0dnZycaHV1dW5cX/3qV/XBBx/ogw8+0CuvvKJyuaxut5vmiJjzfr8vaQaEvcw84LLT6STw4cCRohiefIvFrv87f0bNv/MH55LrPW/HGRiCm/Xt9/t6/PhxUhziJuQ66MKVZb/eAcB1lpn4Q5+wrtJPfwdhmYROEuaGUuqgSZoBDA/disppkSUPpulhlYPBQO+88046dd2ZoyR93/e/0K/m66rWqsorZU1WFvW9X+tKWpxTitvtdjpIkzk5PDxM8eQIHNz7WLCgPUlz4TnMWa1WSwUq8OYtLi7q1q1biZa4z/MdEE5YqiXpC7+zq/H40irImWyvvfZamkeqXXpzYewCm/9R/E5OTuZCYf0cGcoyM6bl5eW5s1AYL+DLgYDzDwfD3s9oCIiAA9oGILmXB6WmUqmo0+no7t27KUykXC4nZQErNvuL9a9Wq+msF2jalVzo+sGDB3N9Ym0AoSTYO0A+OpodgvnixYsU1rm+vp54s4Of6XSakqoxPFznifIwa0lz+4p9xroyxnioPGP8+OOPU2TB8vJyUiwZD2FaRUDOjQsUVKK0Ovk6Tue+tqwPURL0k+NDLi4ukveFiASKHHhIFHKQ3z5PjDXyuetaBDHSvCXZx0s/4HWNRkO9Xm9u3+7t7Wk4HOrevXtz9D4ej/X48WM1Gg1tbGxofX1dh4eHyvNZNcFaraYXL17MeSslJUOpg1We22631W639dFHHyXvoectxTnBmACduRfHrelgB1c6ovGQOfLk/ggOJSVwjAECj8bZ2ZneeOMNtdvtpNC7vMCTyvMqlYr6/b4WFxe1ubmpVquVjD4bGxtzxl33ItPvyWSik5MTnZycJKMV4yQ825UD9pPTQREdRZAd+e1Nxs3ID4to1emTMTo/Y48ghykSg6ylyIQ/73Of+5zW19f18ccfp6qp+/v72traSgo1zfEDNIO85xidWq2m+/fv6+zsTE+fPk1GA4wzsR4AFR4fPCinQ935fjwea39/X8+fz6q3UpCt3+/rtddeU6fTmTu6J8uyuWISvhbValU/9uMN1Wqr+tn/fl/lJ/vS8wPV6/euGBWj0dDxcalUSoeEv/baa9ra2krv9qgO7mUPInswzlGB0L3GKMHSpdfQx1BkTLqOv72M1/1WbZ/KgxV/S/OFJ6RLTdo/Y/LdrU48fLPZ1HR6eRYHxAQghygAa3ihfLO7hZLQERQnlDxAGfG4MCcP/6rVaup0OmmzkMOAcrK3t6fFxUXdv3+/UKACplAaHbBUq1VtbGzo2bNncxbgs7MzLS4u6tVXX9X777+v3d1dPXjwYK7KlXQJ/gFWNKwRVMRz4CrNhCYWa+LLAQjNZlNLpQtln+QXTKfTxMx8nfP8Mn8NwHpxcaGTk5O5Mx2i8s28R8bvjD0qTf53BBZF4Bf6cuDn73LQR+gaIBaahJ5Q1N3bWeQl9THw9//05/ckST/5J2YCgFwZ3gMd84wv/uCh3vkn6/reL+8py4Yql6uJyXlcNOAN4OdMlbEzN6w9oM49m7G/buFFEKK8YC31OavX6ymfzBk1/SJXwa2RsZ/R6nsd4IxKtnsk/IdxYlH2s398fPCTqES50nGdEuVzFtffFSzWwN/hYW2eV+aeAb4DvLnSz48rNgA23uehfDyf8ZZKpZSPAK9BqarVahqPx6ny6fr6ulZWVlKhCuYHXoYgZp6haeetBwcHWlhYSF41BLGvu881/WIfXlxcpOqWPKvZbOro6Cgd7bG9va2tra20LzwMPPKISEvIFOYEJYFr/Fr2LvTv3n3nc0UAHzpy4BujOj4NyLjO2ut7yvvLZ04b7nnEeyxJg8EghRx7SFClMitk0e/3tba2lpLpFxYWUpVb9pLzHebRPTR+niMhW9DEZDJJBgQ3lDGG6+bA3xvXzJUfvOxFdAH/iJ/neZ6Mu41GI9FJkZxyXgU/lGZhvJ1OR61WK/FfjL2MPRoaacPhUL1eL4XDOT9g7SJ9RuXJeW7saxEN0Ypk63W0V2RARcEsok1kixesQXGI73Gjbrvd1nA41M7OTiqmFEu1x3l0eXt+fp7yqqEtqjgTOcD+JtoozgGFbXimdFmKH0WRg4/5zo1arvwR+knqiVeWvLi40O/5I0v6O3++rTy7DI1146DTtvenVCqlCKu1tbVkvAN3xqgOjHZ48KVLHITMAse7c8TX2mkhyr6Xtf9fwQqNSfYNT2Nyo9s1Chv/G2F/cHCgjY2NOWWHewl98hDCpaWluYPUJCULO1YnYqexSLFxXJMnxMbdr97Hdrut3d3dVMhiYWFBT548Ublc1iuvvKJ6vZ6q1iHkB4OB2u12CgdjjrCoTqfTZIG9uLhIHjvG3mq19Morr+jhw4fa2dnRgwcPEtBHwHkxgnJ5lsRN6I8nzDtjxeKN9YTQCoRkc1rVYpYly3+pVJorY8+cMA7mnNBJhEEUViiu9AGG4VYRDynxjey0VfR/kYuf8UZrrjMYGL17pjx0IVoVCYVxOvd3SpcM/if++PqcIvTWW28lUIbihvJG397+0q7K5Rld45XkGSRxo1B7tTx/L8+iX77foiGiSBFujn+vphcVTaf/6IqS4+vUbrdTgv8/+MZEX/zXeundAIhWq6U7d+6kRHk3MNB8n8X3+ToCwFH0GGMEW3jH8GoUzYWHIPlzADGSrhiFbmq+v6KC5SDTQbwrfQAvL67A3uX50KCHbEiaU9Z87bkvKjB4EI+Pj1PVUgrhLC0taW1tLVnGX7x4IUl67bXXknBlbplr9hGeOnjT6empHj16lJ6JwsRY2QvwVIAFz8iyTLu7u+p2u6rVaqlflUolhYg+e/YsWfjv3LmjlZWVK95vAD/rA2jAI4BByr3nrIvTHpbtRqOhhYUFHR4eXqFhwtrhje5VdoDpPMnpx58V6YvfNxl3okLo4Md5H9eiNBDeR4lz99oT+kgpdCI7OKey1Wppb29PFxcXyfsXPf15nqdjHJgfPoeO3Lrv4YxxfPx2T5EDOujHPaoAU+iKfeP9cy8WfcCYgEIDRqBwBs+Oco5nUjH2/v37ifdicALwe0lsDxnDe4XX1vOgvT9x/H6/G74ibV1HP9fRHt87/fn+kHSFxqNCwfdgKNbZvTLO290ASet0OhoMBiktY3d3V1tbW4l/+F6K7+Y9KLc8G6+TjxdM5MbvqKyC1eI6+vfel+l0mtYTvkNBLZetKEe1Wk0/9u/NcvE5ZzJ6KOO6cP/Tp0/VaDS0vr6eMKjjZ1fq8c564Q9kledesn5ugPE5dhpy/HYdXUX6+Sy1l3qwXJHyz+LfDjzc3R+fdXFxof39/eRKl+bDydzzACGS3O2bwgthQPxYBAjnmBtopaLl5eW5Mxm435kpAogzQkql2RlBnDOFd0G6VPIonx2BHBtcmhVSOD4+Trk5ft5Uq9XSgwcP9OTJkwQI+v2+xuOx1tfXE9PlPreSubB15caFCEwDwXN8fCz9la+rvpEna3eWZXPWRNbUxwPgPzo6mkuu5vvYWFcXAJF587toAzptRWHOeIu8ZPTVrUn+LvoCjfJ8fgCRbpnz5vMSLXurq6tzRoNWq5UEKEyz0Wgko4GH5AEWEPx4OHyOPOfCFVXu8TWJIJQ5k6TScKxS/1zT1mXxFDd0+FxSZObH/q0L5Xk79Yd8DmfGUdHFasw6+XxCk36/pGT5Pjs7S+C+6F5JKSSviL6cNgAmnmN0HbgrouVIe77HeA7z5on/UTiRS3p6enrFs+ZC3vMXAIFFgIQ+8Czmut/va29vT0dHR+r1eppOp3NecPjh0tJSqt61u7urW7duJdovleZLBzMWaHMymZ2rxjuePXum7e3tBHgGQlmMAAAgAElEQVThs/AdDFzOEzjAc319PXlLP3j3gZRlevWND1N1yul05mXnLCu89160xtcJLxiA3sG+X+N0yXg9f9IrdSLXnOaKFCjnK96nlxmSXtZ8rWO4Do395h5PwL6Hv7O3PAcaxQIPwHA4TGHjjUYjFYbyc96cDqfTafLEuEcL5Yq83Z2dnTkFz4+8YP44UwvPKPvb6cfX0sfO4asYMmKOEOuJMr2xsTGnfNMPvMt4X8AmbhTBYMyzJKVKns1mU/1+Px2xQn89bwo8AqbwAg8Y+px2mQPnd9cZiBzcxs/428freC9+HpvzHEkpd93XEC8PtBiVh6ikIAcJ/d7Y2NDp6Wk6O7BUKqUz/2i+B+kTxW0o3ILxnT3OnBwdHaUKvRhlOG7EvZ3QBcWV3IjltCcpGYJOT08TH280GlpdXU0YMs/zNE72APQGToh5Vr7+zOXe3p56vZ7u3r2bvMLQByk1LsvJ/eXdKFgY6vM8T7ya8fv7nR5c3jlNFdHZZ7m9VMGKwFO6DCngbwQPYInNA5H4/Vgk6/W61tfXtbq6mvJBXIkCYHAgohMAwgFNHCYFIHYPiwskF6z1en0u0Z9nE4ePcvX6669LmlckqNI1GAzUbDYT03RG7gImz2eVEI+Pj3V8fKy1tTUtLy9rf38/gY5Op6NOp6Ptf+eX9CdbD3Wej/Rfdd/Wi/9uFnpGknC5XNbx8fEVIePMDAbs7l9p5vamZPTBwcGcq7per+vOnTtzQNyVT4RjrVZL53I5g3SLBnPp1ehoroiykaEhnhV/M/dsemhvPB4nRhZDvsjNIRYbZsZzHPA4TQBAEQTRk+VMg7w15g8DAmX9CatbXl7W5uZmEjS834UU9MJ8e74KwNuZmwsK7uVzD0tjXtib9L/f+ntqPv4BTZ58VSfL31Gj0dDR0VGaC/Yu6+iKN88DvOKJ8wqLLvR8/zDm09NTHR4e6vT0NNGqV9fz8vmj0ShVxQPoMu8rKyspTMMTorG+8xkGiqjoVavVNI6iFsEG98X4eLfK4s0h54UDXsmharfb2tzcTEUmPEG7XC4nsMs8ej4pv6PwzLIsAUsKV9TrdbXbba2uriZagO4Rsq1WS2dnZynJH55Gvl+5XNba2lqidcZRq9V0cnKiR48eJZp9/Pix2u12Cq2D3lHs2OfMFRX+yNX45f9zWdn5kiqTobKzC+38xqJULuuLf+zygFd4F/S8urqqra2twv1B2AxVA907B79k7aBB34d8Duigz6urqymM3OmbufX7I5CMCn9Ri4pDNCp5w6hIK5Uuq+MhL2KhlXq9ng5Cl5QMPfT14uJCq6urWltbkzTL/yyXy8lD7fyYPhE+5XvULfCnp6c6OjpK+cWRj7os40iKu3fvqt1ua21tTefn56lgFONDdiGXOMfv/Pw85fG88847c57GxcXFdAQGNOMl7P3YFOevrAd0wxwMBgNlWabbt29LmhnYNjY2tLCwoH6/r93d3SvrnOd5imyQlIoSALC/853vpGiXRqOR+Dmyz/cRcxcNW3GOvbniFfmbX+O/oweDhqIMJsSLiBzifE9yyeEjngrBHLuiQSjpG2+8oV/91V9NhnlSOEqlUsodcmMz89DtdjUajdRqtVLOnBtJjo+Ptbu7K0kJP7JmnAXp1YKRV8PhUAsLCzo5OUnGGPDGs2fP1O12VS6Xk6LMWVvdblf37t2bO58Q4xAh+H4UT5FXCL72wQcfpJzsZrOZKnXmeZ4wHUcPuBKOgohc9PwrZK2/z7EWWObTGoWgLedln0WF66UKVtx0EFy0krtgcQsP99HQpImJJ8zIn4dCQaIkDBJBWVSmk2fTPwSwA8S46F5QQ1JicORkLS8vpw3jHgQACkDQLQ2ExMRY6el0VtCDksEoZgB/7n3vz76tf/ynH+lr9br+ZPuf6T+dfI8kJTDiHhZXGhGsbPpo5fLKNAgXqkcxf6xDBPAe1oHy4II+WjN9XVzBcstHtJS59SyupzNPV3QdwETGBNMjTAirmFuyoFMEr+dmuCXHPR3Q+mAw0NHRUVJa2+12CuVEcUdwe5gSFll3y9Nv5haPLPPqc+ZjdK+FC1WApK8P1zMmSRq98aufeCVnQJP3Q194Nvw8GBfOHg5I6Nl0Op0rd4y1MXpb3QrvIZoYRzz81cdCCNpgMLjiSXCeAw9wembsfO6grohXxebj9gZ4c28jCsvZ2ZlarVZSVnu93lyRBPJbnNZRqHzPODB3HkY7OjrSo0ePdHx8nPiq80HoH4spOTZ4CViL/f399D37yz0iHlriIMwtuVjdvTAJABJD1MXFhQ4ODlStVvXPfmVL5eFY2XiibDpVNhxJh12NDw5Vbrd0cTF7NjQFeMNanGWZ7t69O8cHoqGOokQ+rx4K7TQZ6Yj/Meh4jo5f5x77SCNF4OI6WrtOqfd3sV6AIM9LhLexLvA55/P1en0u9NMVU97vBrjxeJzG7bI68l436kAPgOE8z1OFSOYZRd+VtXK5rK2tLb355ptqt9uq1Wrp8HU8I+TUMs/MPZ6khYUF7e7uzvFFQiHX19cLI2X8Wq53GevheBTaIU+VAlKEVJ+enqrb7V4xHMJXMaB5XlEs/OK5c/ST+YlGsyI6cXriu3hdVOZvokv/zn+jXDmfYv5iCBryCewVG7Tm+3d1dTVVFnQPEn13jAgdwo99PvkbgzHri+eVnFQqOTue8dyxqNRmWZZ4A8a9fr+flBM8yVQZxGiLRwnPnrci/IwyBl3hmY4GAI8s8bF79V2uddwTeZ+vp4dfX8fLYp9vosnPSrtRwXJB5YvoDJzvYPoen+pWawfQ5C5JlzHHPI8N6WVdAZwAFnfTQ+gOoHA18z1KFv3iMxoWuF6vp2azqU6nk6x1aPqM1T0inqjoVkuaA3OEDJZ1lCAEoisL71/c0vfWHqlVWtQf+A9/Xr/Q/7wOf/rNpIS5MOB9uI2Z41j4gn74+gBkmafR7/kbmv71H5k7QysmW56cnKjX612xZjj4Z974cfCIcHAFx62iN9EdzS0rCGjPeYseEayFMHz64vSGsHbGjycHBsmc93o9HRwcJGUI4Od5Xw5smRuPgW42m2o0GnMeM44o8LllPj1njM99XX0NfK58byD0oPloGKhUKklxkZQqe7rQ4nr3FiJwsixLiqdb1f3MO/oJ0HdPNN8jgOENzCnj6vf7Oj4+TvlXrnQ4D0IZ8Bw3vDDQkc/bTc2FFf/HcFpfk0ajkQoKUKkPKyLzNRqN1G6353LmokIVm6+x/97d3dXOzo5KpVKqfoYXij4x105LWZYlq2qlUtHh4aF2d3e1vb2tarWacqfc8wN9wBsYP8/jvEEHNbyP/uzv76vX62ltbU3ZNJ8d3lmpKMtzlbJMpfGKKouLmmy0VakM5uaXoioLCwva39/Xw4cPU2U85IHnqznvKQIBtMlkksKcirxL7N/19fW5ZxUpWlF5/zQ05i3SmzfGCIBxbwzyBPnpclG6DJWEP7pXj8+gP5RlrPDkQTuPpa8OpuJ8YPwjxNwPB445qj7vzWYznY15cnKSQkNdFjMegCfFEA4PD7WzszM3J3jayWtyAxZz7UYFVxoZBzTuZ38x5tXV1VTohTAxNxZCP/BaDG3ekI/R6Od5Ry7XmTOXM047keacf0W5WnRdkeIVFSlkgPMv+uMKr9Mu+8PpVlJKnfACE1tbWxqPx6m8ODwUAxGRAc7zybWi37zPvVjgDsKke73ZYcFe1l26jIzwOfHQTTCgy0DG4sYy+gzWPT8/T3jAMbMbiXjncDhMNE7eVqvVmsspY75R1N04hOHSI4s8YoR9zbMwTHmhDP/+OvpwmUR7mQHgt3L7VGXanRE583Vm6MDGlQYWhvtgVlgM+A6hQI4CFpHpdJqAHm5ULHBuxeEZDtKkq7HCfo8reyhJuOvZfK78QXhnZ2epkIY3LzjBRvJQO0IxvCKbe2WkWRjf/ripX7+o6XfUpe1yX3dqR3r0ybk2riQgFDv/9q+plE11+D98KSlZgHeEI8AoVvCB2Z2fn+vsL3xFWdadC5djzrnn+fPnKbQkMlwXkq78RtDvIYxx4/rvSIMOiB1UjMfjFMOOMuJWd4Q6jBEByzXl8ixu3xNYXYjzzslkkkqI48Wj/zBK6NaVOA+3AuRLl9X+JOng4CDtB85hwWM7mUzmlPwo/KN3zYEPn3EN/YDZ44k9PT1NeYeclQTYZOx+wLWvCfNYKpV0dHSUFM88zxOYivkEeKfdOIGBgvVzSyTCazwep7mKXkcHM7H6XTTyuMD8NIy/CIxA4zzfPY2EyR0cHOj27dspXMsVs+l0mniZ7+n43rh/isAsOSfkk0QvsN8PCHFvi8/R06dPVS6Xtb29Xeg9K5fLGgwGqRIh8zAYDHRycjJ3XIXPE7SKMgjo+uIPHMzJDf6erV9XeV5J9IZRwBXyFy9ezIFPtyxHJcfn1MEeQM1zYFyJKZVK6dgCZFSkHZ4ZLcH+znh9pKfreKDvZeaCz91wxZ7BA+zKA3KVfUGOpxsKXC6USqXkDWW/RfAX5WlR3x03AAA9LGswGKScK9re3p4+/vhjbW5uqt/v6/3331ee5ymUnuf2ej09efJER0dHiTaq1aqePXum3d3d1JdGo6FOp5OiDHwcLt8djxTNPeNAtvDOcrmccsrJGUJRcMMPnitkkHTptWFMGPX8WJHIv2gOon0Ninha5CGRvoq+93det678jVx3IyAKVsxxi3lYzCFKP3wSLHPr1q3kweFelIXT09PkkcLrKmnOcEq+IXzYw+grlYpardacFwmcKSlhvUajofF4rEajkULisyybCzNn/by8vtMVzwYbFpVid4MIhn8KqVBVemVlJXlLaeQzLiwsJPpjXpkDdwJgpEKmu7cWvuJe4pvo5zq6u06B/6y0T12m3RUs/849WdEq7td5A3gdHR3ptddem9O2eQcEAeDzE84BWq5cRU9E9CTl+WVsL/0i7G46nSbrFpZf8jU8bI45yPN8LsGasEi3RjmQdK8EoSrn5+cJcLn1UJKe/jef18OfOtRG+bF2JsvqTRaTcCcc7f8h711+JMuv+84TEZlZGfl+1aOruqurSZoUKUEPiLIMSwMI1E47r2R4MJCNgTYCvPDKi/kLvPNKm4ElzAiD8QBDY4TRxsCMvJAsm5AtUepuNptks9lVXfl+RGRkZuQr4s4i+fnF5566WdX0kC1SukAiM+Nx7+9xfud8z/ec3/kt/9Z7Md3+fgnS1nW0W+OY/qd/EXv/65cLWEVJo9RZaF4EgGenUZqFJT0Mg8Qm8wxWc9QlV8KxA2xW3d9rYkD5nCMgmUkx8+zXGVMUMOOLIcB4UQo2g1I2hfNMHDUfBolDhwNCygfyMjMzU5wxnFwiZZSMxcmvqqpsLHeZWBhgz0N2rADMTtXI0S6U/NzcXCl8gBxyjAGVMj2GjgBbDzCfEAdVVZX0HxhA9mTYGaGwB2sBQ4ocOcqSDf/R0VHs7e0Vp9psrsE3bcig2ped/6aIxW2XHQDfk3uQvtFqtcpG6qWlpVr0gIt9CUTDzcpbFvPV5FQaOOQIN3q6ieyImBzUib766KOPYn5+Pu7du/eCwzI1NRUHBwfx8ccf1/ZbHB8fx9OnT+O1116L5eXlmj5B/g8PD+PDDz8s6VVmNz1XOApOGcqEjoGox+U2m+N5Ys2ho/hBzmk3vzudTiEPkN8mYsjf4zXrt1cB4CYgmz/je3lNuj0+YLopFctz7awGdAJZFoDPs7Oz6Pf75VnOfLDdNz7I/fU4kSUxPT1d9nqRGdJq3Rzn8hd/8RcF+O7u7kZVVaXAEuTfxx9/HFtbW2X+3n777YiYEKw4mxSdyNEf2ky/MnGcnUY7yT76ha0Ow+Gw7Ks0eAbI028IM5MCjpKRemhi2rJtO90kLy8jZm4jlJp0TZP+9N+WOVe9BYNBcOUiZSYI/Rzsg9s5Ho9Lauf19XWx1eBA9A+kHeMG+eYsCbAiKdyMoUuus2ZcEIgDiy8uLmJ5ebnm3FBQgrYiD02kR8SkpL7nIQcnyNo6ODiIk5OTGg5bXFyM1dXVWkXFVmuyj9zPZU4ZA6c2QqK7ngJzQfTKttGyYT3VRB41yeLfxeuVEawMqHIhChQqivr8/LxETiwwBoOdzk0J4ffeey++8IUvlOp+gC0rEhh/lxyHGYBhG41GpVQ6LJEXJ4KG0BKx4nDg6+vr6PV6ZT/N0tJSAWkIIQ4cwMCHgQ4Gg5ibm6sZaytF9qSw6JaXl4sBI2UJAMQif/v3fj0OfutrMa7asfe//YP4zGduGNR+vx+bm5vxsH0Vc+0bp2Kxcx7z3/977p/+WTz9X34l+v1+zM7OxuzsbKyvr8f29nYZZzs9jAt7hlic9I1xPj09jffffz+2t7drbBrKzYCYcDRzxmddghbZyiC1iQFhwQO4DCacioais3OzsLAQH374Yezu7sbGxkZxjHEciLAArOjvzMxMSSeJuFGAlCBGmbrtOGARN8yQz+HAEBNV4T2YKSJJOFb9fr84QFV1cy7IT//0T9ecAYCu1wlANBdFMCvbarXiyZMn8c1vfrNEpNjHcn5+HsvLy4UBxCEnTZbXacfCwkIsLS3ViokApjFQyJdTKJgHWHbKfef9lYwx6ZOUBN/c3Izr6+tYXFysgRAu5tOsuZ19PtMkf/lCJkwm0B8TN5mlJIVjb28vnj59Gm+++WY5s451wpgw7zDW3iuV+8a82nGJiHjrrbdicXGxEE92tCKiRLYhAzDolLvHqHPY+sXFRfz1X/91PHnyJD7/+c+XuWi3b8q67+3tFZ2Fc8Y+m83NzWi1WrXCCe12O9599904ODgoMsqxENmmmL09Pj4usgf4hDgZjUbxMz/zM2UfmyO6TRGI0eimJDbpvXye9jm9hu8RKdvd3Y1vfvObJbXL4NbRNPSAnbY8b16b/ju/598mKQyunWaOTmNM19bWyiGkTsUii2JmZiZWVlZKpTaTK6enp+Xg4fn5+Xjrrbdie3u7VlnP1dlop+2+gVcGWZA3rVYrHjx4ELOzs7G1tVXTeycnJ+V/LgpdbGxsxPHxcezu7tb0WyZWO52bfVfs5crjajvHa5YJO160megsMon9G41GMRgMXgDynjv2bCM77FFlzy3r8e7duyV9uKqqWqoZsmzCzfLj62Xv3XbZvntMGAvGlsvRIKI5juhQkbLb7ZZ1B8HhOaOfpBRCrEOerq6uxng8LsQI+Gx6ejpee+21UvCiqqpilyCmuQeHsFMyfTAYlKi1K09TzGJ5ebkcXgxWfPjwYXHe2Pe+v79fsmWQiYgokSynVSMLOF2QnNfXN+cTHh8fF6LSkc2pqZuiTpzHarJ/eXm5VE0ES5gY6/V6cXp6WnS1SQcXTuG+YMfsxDf9RrZM+r2MSPq7dH3iMu0R9TQte7WZhbFhySwriiviRtiePn0ab7zxRgFv5+fnNYeO71nxOWoWEQU0O8c5M9Lj8Tj29/fLviMOBbQDh/ePogBMRdQrzwGEKFjBXhADHitjwIRZYhZzTg1yv/f/9/+ulsYSESVCMt3aj7n2RXRaVSy2h7HSOYvZ1lXMtq7i7H/489j/g18qYAtmg5QMIm45vB/x4nkf19fXcXJyEs+ePYsPPvigprAx3Hl8UH5OlwHcOdplw0j/mKucm+3Lyt2y5Xsw/sxjv9+P4XBY2/xPO90PG0aKYqDosmzTbvrnvG5IBj4L44vDydgyHufn58WgOFVhdnY2Hj9+HA8ePChrx/LAWJg1Nziw8uOzDx8+jIODg9ja2iqfdx54VVW1ogCMpfeddDqdYjycgmBQdRu7SroG9wZg2zg7jRLDTlEDgJ0jPSY1rKPsjPBzW/rwqy76gjx4bebIyWg0iqWlpRgMBmVeqRjqNvPbcwpIx7FwyifrBkef55KeRP4/c4Uh73a7JVpmXYNRjrhxaHZ3d+P4+LiM0dbWVrz55ps19nVubi4++9nPxtLSUjx//ryklD548KCAZUcCIBM2Nzdr0V+MuPexWG6IrHp/BYACZwhQhS4ej2+yDtbW1mpGvqqqEqkmouwIsZ1xyw7zQknkpaWlFxwHz6dTn0yyZRnyZfvGvQ3yvS6tZ7MzAUnC2C0sLMTs7GwBu3weW8V6XVxcLFGriElqFWn5kBgbGxsvRCjQe+g1Z5Dk6JnbbBkEWOf1HDEB705foq1Nlc2sm7l8bILXEusnYhJBQK94jiMm6f/ej4gNpV3Mvdc4DqcrxDFOEHH9fr/IIKSX92fxPebf42a9z7i63R6b2xyw28Bz/k6To+X3wDXsd8bZ6HQ6tS0HtDtHTrGl2GCqOUNY4FAtLi6WbQrMDTqBsWEvF/aUrAiTfTzD8uqMlJOTkxopzBwhA6TXoXNbrVZ5DnLg/U0+CqVpf5Mjm4wxhDJ9zMU32u2bPbeLi4tlT3M+d5Nn56wvp6bTDjutWVcZL2bfwHKaSZcfByfry1/+cvzn//yf4zd/8zfjq1/96qf23E9U5ILJzoyaQUHEZHM6DCrfzYrIQOGjjz6Kdrsd9+7dK2CN+yNg2TEz24QwEDHxfo2ISQTs5OQkqqqKjY2NUnnFYIsQfzaKTifjsxbk8/PzWFtbq52bAoPlSB6l3cnf51nO/4YBpG9+PhuCx+Nx3Lt3LxY7b8eDqX7Mtm9Awnp7GPc743jYOYh2jOP/vfr52h4bFm7Ol0exwLDQBxY9QPz58+eFPfT3rfQjJlWgbExRHhmUeJ6zYciOnB0FM8f+vtvEvRnnfr8fOzs7JephZgjZYp5JzzB4sGNopeL1YWeLMXf+tzefAj74v9frFfAISzczMxOPHz+ON998s/QjM+cGYW6bDZgBQUTEyspKfPazn43z8/M4OjoqLC8R4KOjo1oUDBn0uiPXnXszTl6rZm4Za9pNxJsxtzHKfeVv9m0SMXAE3Y6OHSecP7N5NgJNQMRz63ZbXtF3TiXJ91hZWYnNzc0YDAYxHA5jZWWlvGej4/G1TmLdZFDF3i6+S8lqzrMjPZiI+/X1dUmfMYgBhAMAAQ1E+J0ijOzz3W63G6+//nqsr6+Xwig+TsPAgT4BigGqgKVM8Hiu2u12TafjVOFIYUe8LzLipkACBAlz4+M7HMXLz2c+kKHBYFCq2OG4ZRnju04L85z6+kEc+yYQw2VnJctoRJQD7tknx3dwXCMmlRlJF7T9YuzR8exfRe5NDGCj8noyVqBdOGi2fdzbn21yyCImx2OQqeJ1ipwYK7CGmjAIz2kiDPkOusb3iYgX9I9fQ2+iUw14SWv1ods8m20AAGYTDplAshxkEGtg2+SA+cpEQb4Pn2lytjLZ7T12njvPL7aCLSCQQZBWRO+73e4LRWdmZ2fj/v370Wq1SsVb0txoB1iH++csBXCUyRRkDsIc++y1jUNPGyOiEILoUPQgbWF7gseaMQBjmHgmtZdgAXob3IJOQybv3LlT8Cw416mPRMYgn3i+j/3Bflv2nR6Y59hycZtMNb1+m4z9qK92ux3/6l/9q/j3//7ff+rP/sQRLCt6K3IzDxEToIPS8Of52wBnf38/Im4UPXmlGGDYME8Mgo3SR7B97lVElKIFLk3++uuvlxA9TBECzj3NugPObKjZvM5ZXAi/GRtHpVAu09PT5fwoxgFWmHFEedMH+ueI3PX1dSz946/FSucsHkwNYq19HYNxO2Zb45htTcVGZzYijuL/qSbpJESxWJgwGt7AiEFxVOX6+jo+/PDD2N/fL6lsdpJYkPzN+OWcfH7yXDbJV5aVbMAi6oeGAmrsAJsZQ5bOzs5ia2srlpaW4sGDB4WZYv7ZdGzFQ3qCnTEipZZ5G23SCQCDBnIoLpjjiChpJRz2iSxPTU3F48eP40tf+lJh2TD2dl6a1pjHy+mb/IzH43JuyzvvvFMcqtXV1YiIsm8IAwBZQB9wrph/Eyt5Xq3Uzb5TwAN2k/nMMsDrg8Gg5KKbmPBnLBPZ0fPFWm1Ks8ljmR2rpra5rwZDpG0Qnbx//37tGRFR9BxrD/CBgfembRwV9gLBhLbb7bJfBiDDvMOQn56elvcsG45e8Qz6s7CwUM5u8Zg6gsgZKh5775lirlZXV+PBgwfx7Nmzsn/OoMh7B9Eh1iVElSHheAbP5Nw5+tbv92Ntba0Wdc0kHc6+9ZVBNm3r9XpxdHRU0j7RqdwnO8Z+Peu7DIbdpibnJDPCfN9yiE5HHpBDwJcrjzGHOONmu5kTHCxfdq7tCBnItdvt2iHD1vfYCJM0vpBXrylHmzxeEZNzCjNZmJ0r6x/6ANnHM4xV3B47Z/yfiWZfkB0eE86dZCsDnwPHAL5pa6/XK4dC8xr4w8/NuIv+NDmkHrcmRyxfWb74HH3PRDfjhdyYoGDtQlweHx8X/AEpjrNvXAIBMzs7G4PBoOa4rq6uFjm2s2T97D3glguTpcgxfYFkwB7j4LKVgDMGDw8PS5ELZHYwGMTl5WXZt429bqos7XnKc2H8GRGxtLT0wn4rO+lsY2BrAQSk18XJyUmJ4iF/YFKea7xkWccORURNv+X5z/LT9Pff1PXP//k/j69+9avxS7/0S5/6sz9RFUEzOAxqTomLmDC6Lg/shelFi4BdXl7Gzs5Oie48evQoFhYWCtAFyHlxs1fIyo49RLBwHDrovNz9/f0CRihvmdtJPwA1y8vLZaEBrp2/zj3+63/9r/Hee+8VwMH+gfF4HH//7//9+Kmf+ql4/fXXa2cdLS8v19IRcHj4e2ZmJk5OTsr4tts3myfbrXEcj2Zjrz0fi61+fHGmXs1wttWKh//jX8Wf/k+LBbiTa0v/SMVkMQIySM/q9/uxv78fH3/8cQGjEfXN1TDjVm4RUZwS/zDGlimUECwe989g18qaz5B6CeAej8flPIx8Xg5Kmhz/+/fvx8/+7M8WI4aiYXwoMEE+PfPBHhM7+c6TbrVasbe3V4vqZMDP2JODPjU1Fffv34/l5eUy5gcHB/GVr67nqjYAACAASURBVHwlHj58WNgog1FAqyOurCkzs5mVjZik2lxfX8ejR4/izTffjG9961vxzjvvlKIG6+vrcXBwEL1eL4bDYRlTNhlfX1+XNB3viXMONz9ELJhjt4sfDut0H5hXDml85513yuGKMHBeu073YYwAvRmMOTL2KgNAu9ynpsgZaVWu0nn37t1444034lvf+lZ89NFHsbCwEMvLy8U5xBGHGQXsI4tTU1O1fW9seuZgSkDzeDyO9fX16HQ6pYwx87a8vBxvvPFGVNWkQAARDJjm/f39QlRQXnpmZiZ+6qd+Kr7whS8Ux8Vr3OvRRJDTf03GTE1NxRe+8IUYDoextbUVFxcXMRgManPAxnHWDDYCIor1w94txs8RFSq8ousZb+6Dzj07OysySUEC9Drzd3FxEZubm/H+++/H+fl5vPXWW3Hv3r1ComSHzVFjXvOabZI3O1EZ1ObLINkpu4wTepGxmJmZiUePHsW7774bT58+jc997nNRVTepktPT07G8vFyimkQt7UBxSKz7aCDmNtsZyfbEqcY4dcgK7/X7/Tg8PCyOoZ28rP8gEiKiRs7kseCz7BumuiVOgIlT+odMAUIB0d4P2US6IAscvwFQdqosaxhs4IJAnU4nnj9/Hu+//3783M/9XK3gAjbMc9DUX9vmPA63yZPlM8us58wywI/tSrvdLmu3CbvMzMzE+vp6nJ2dlTOtTk5OYn9/v2QvRUSRDXDLxsZGqRTIOm+1bvbgzc3Nxfe+973Y39+Pu3fv1g7/tgODDEKKO50YOVtaWop79+7FkydPiq58+vRpPHv2rDiDRPOfPn1aHBT6+iu/8itx//794lS988478eGHH5Y5RhctLS0VB9pHDrAVY3t7O4bDYVxf31QrfOONN2qyH3GTbUUlwzt37kS/3y/yZHIKpxAHC70wOzsbq6urZZ3jBDKH1ArIqe85gmt5y3Jmsug25/7TuB4+fBj/6B/9o/jKV77y4+tg+WIwWVwO52MAnSrl6zYGj1SUqqpKQYD5+flSOML7BBAGM6Sc8o5yXl1djfv37xcB9oLDmFZVVZSWq5bZmQQ0Ob0BAQPgjUaj2NzcjA8++KAoDR9OfHl5Gd/+9rfj0aNHBTAxDgaEDtviuDh8i5HpdDpxNroT46od59VMDMbduNvZj4X2pJJWRMRV1SmOxcHBQayvr9dYY292ZB7ZbN/r9WJvb69WEjUDhWxceY/fuYogfbRRstzcxgragWceeS450Dbo9MWOBuOIEmu1WrGzs1NkhLa5fKo3ilbVJIfeCgyFb3CVWR63B+OKo7CwsBAPHz4seyA4N2l6ejoePXpUDG/TmjO4Y9wsV/n9PD/0s9PpxOc///l4++23C3s6NTVVWLOdnZ0C6Dkkud1uF1DWJAOeDxwHrxvuwVhS5dLMLIzbYDCI7e3t6Pf7L1QytIwwf7D0TtUiuua5c1ub5O42+W4CzTmyxRx0Op1iTCmu4FL+tJ0fgxx+O30GEon/WQvWqegg5ot7r6ysxNraWvkObTg4OChRB/ZeGRxG1Kse0q6meTAAz2uaNQioZV6Gw2E56+j8/Dz+6P88iX/8Tx/UohmWJztxfpadDl5zqX4udDt7Imk3ZM3Z2VkZt6urq9je3o7BYFD2P9B+1gDzz5wgB0TZvO4Yi9uAhvVqkyzSVts0E0T59VarVSIne3t78eTJk0LiXV1dlWMOIBxwONGtPgbBa6QJxFserINMwNiGsj4hWKgMSkGAwWBQS9OjHcgQEU3GPactcs3NzcVwOIz9/f3odruxurpaI2OcfutxdoU1R8utEyxXnvesL9C1jDuVaJ1+SaXE4XBYdLDJMcvbbfKELvDrfs1yluczy2CTbFr35Sgv/zPfFKnwxWH0RHvQaZxpCJFnoqLdvtn7Ryl/0oyr6mbbxfz8fLERyDTbNUajUcEznCNFqXOIt9nZ2XjjjTfizTffjAcPHhQCYDgcRq/Xi/39/RewzMXFRTk0GEy3t7cX3W63YKyHDx/G9vZ2IZOqqioHq6+srMTdu3dLah9OjrEp5Bhr22sBJw1CL1cCraoqer1eIcsiJjiKccsl5LlMHOXIeNZDmVzKTpUdsL+p61//638d//Jf/svGiOGncb0yRdBGs+lCyCLqESyXLM8sSb4fC2o8Hsfh4WGtVDVRAwQMJWUmHQD32muvxfr6eqmSdHx8XPbTOFzvED5Msh0O2F3a5t+AE9oyOzsb7777bpycnNTOn6HP09PTsbOzE++991784i/+YmGdeZ6NIYvHzIEZw1JJ6P/6B3HZbsdRqxU7l5dx+d//37HeOYnp1ijOxndi+/penP0fvxyf/ezNHqqnT5+WVEzYuE6nUw5DZTHAhPT7/ej1ekUx0J/saDH/Xqgotpz37M/mKEaWE/4GWLGQrUR8P9pv58b3RkYB+4PBID766KM4Pz+P1dXVEuFDUaDkM6jDMYIpYgwXFhZKCJ+14DFivx4A+fT0tDBmbFo9Pz+Pw8PDuLq6ip//+Z+vOVGMeyYmMtFgWc0G1kpvNJqcFYYz//f+3t+L73znO3FwcFCIibm5uZJKuLe3F5ubm7G0tPTCIcm0h2ex9mDQiJYCih4/flwi0zhDGYRQHOLw8LBE0gzinN5mgGgnDUcZXUHf+Z1ZXjtVBhpZB2bHlfHNZAAO1srKSq16nYvcQEj5WU5dhUAgLRm9wXeyo0ElRtKiW61WqRJJlIvnjEajAhQuLi5KBIHxIZ3GTr7HKRMlXtdey6xT5pb7X11dxeHhYQE2p6en8Zu/9bjmqLJeTTA4/djtMpgdj+tpqLxHNIDPQbygE633Li4uYn9/P6rqppKn91Ygs4Bq+mWW3WP1sus2gGuShD42kQOQCl7//MCw7+/vx9nZWam46FLspLYhk3ZiMqiyfTM+sJNr2fB88V2TCsgn1d0oxoQ88YNN9l4oHwWB3NtmjcfjQirs7+/XzjhjDO1YIh+MKVErz4t/8r2sFzLANEnAvh3bp16vF1tbW2UuLBu+B21tcrYsS5noyOs3YzH3qcnBz6/zt4lodBNRVHQiz5ibmyspy54rdCL7G+kfBN7du3eLzsTJipikuk1NTZVsE+QYfQNJR/SfdrH+adN4PC6V9vb392Nzc7OQK3ZOmC/P+eXlZbz99ttxdHQUa2trtT3e7KlifGiP5cMy48i0bSSOXLfbjbW1tWi3b7JDqMpowg5bgQ3IuIAzvXCgGBMfOM/ad/TZ2xM+CVGU5e/Tun7nd34nfvu3fzsibjLQ/u2//bcREbGxsRG/8Ru/EdfX1/GHf/iHn0pbXhnBygwlA24wwXtm8XNKWdM+EN73b9gJGE0UkdtBqBblCLv48OHDUiWPSJAFpNvtFrBMe8n1RYDYT+X0CysoRyxga54/f14iXSwG+gRA+ta3vhX/8B/+w1o6GUrdAut0BMANvxFus9qj0Sj+8n/+9RqjdnPvq5ibmyvsD7nFLMpOp1MUFf08PDws5bLdTpTRbYvFABQHxYrVgIuxcXl1xtasiF8HMOfLbDsGzKlzKCyzkLRvb2+vODULCwtx7969Mq60gZQCzjVBUXtsVlZWCoheXFws7KOftbu7W0tfXV9fLwwU/drb24ujo6P43Oc+F1/60peKsfKYewyyAnPULjtcvgxeAULX19fxpS99qaTpkMpQVTdR3rt378bV1VXs7OzE6elp9Hq9WFxcjLt3774QRdzf34/t7e3Y398vG24BUsxNv98vjimM33g8Oeh1OBwWWWQfnB0Ks3kRk3L55NA7RdV7w3Lkw1cTUMlgJb/W9B2DtogojCXjcXJyUiLyZn+zsSWFCb3CflIbZjOItMVjzV6/VuumHPHKykohaXBc6MvBwUEcHx/XQCB6Y25urtFhyJGNprXL651OpzD3dpAODg5ibm4u1tfXyzlzRPlp49HRUQEARFwsx01zxtpzxoNTagGq3jPUarUKAAQIkXI4Pz9fKyfPHDHmlq1s07KM3QY2Msh9FdA1a2zH2cRLu90ux3Ts7OwUhwOAa4DM93N0hstjnQkHzzX62u1nzokc8FnmmfTZdrtd7JPlnIyWzKRHTDJQyDJA5wMwAbyOgDMGkDUmHk1mNjkXrPFMZPk9/rb9Ah9l+zgcDuP58+fR7/djdXW1Fg2ynqCNJkFMKjbpJuu7Jt2Xx/K2de4IH7rXDqgjqaw75oB5IHLS7XaLA8A49nq9cjQKzyUav7y8XIjvvN6np6cLZmM9U9HSjihYDwes1WqVlOCTk5P46KOPYnp6uuy35DB7y0weW/+/s7NTCFsiq+wdo/DFeDwu9zSugzhAv+F0Wr/euXOnEJtTU1OFCCdd2VH08Xhcirb5eCPWiXUZckkAwnt4ebb1uvFFlp08LnmMPi0n63d/93fjd3/3d194/fd///fjj/7ojz415yriFQ6WJzizts71NlsVMWHQzPCZ6UIxZTYsImp523jjBixmr5eWlso+q83NzZLPi/eP8sZxQXkiWAicz+RxO7jsKGTnbHd3t/ThNsA1MzNToheUKqX/jIuNpiNrHPLIONi5YvwxCN4ECcjc3t6O8/PzePPNN+Pk5CSOjo5qZy8ZiJCrm9mxJsfYitgGnbGzIjTDzd8Z/NNuy1KTM8CY2mDyGW+ytYOfDdV4PC4KnlKse3t7Jacax5m8Ziuo3O6zs7PY29srym9jY6NWLckhfNYNrLHHent7OxYXF+NLX/pS7eBCAzezby9TbE3v+XWUu+et2+3GT//0T8ef/dmfxdbWVslnd5sXFxfLWWDD4bCMHWD18vIytra2SsQJAJOfxf4XKsIBmplT0mjQARnYMQYen06nU5hsHFm+a3kDnFgP5etljpTXgZ1x/vb7yDz7Mh29dHTK6yxicowDDCZAyvKOfkC32mnhPfZ6EqmEUBmNRuUMtna7HYeHh3F4eFh0Bu2iMt/S0lJtDv0cLgN7dBqEB3NFig7jQrTz8PCwpA8dHBwU8sFnFiL/6HXPoQk40ox43wAC2fcagGjydzgHjDOYut1u2ctrYs3zj63JjkWTk3Wbk59lrwn45miqSb9Wq1XWnInFe/fuxfb2djx79iyePHlSyEf2YjnCl7MF7KjlfuUIIpfXOnNjneN5oI2APuaYeeM5sPc4GCYTHWmjzaR+j0aTglZkvJg8tYNK1V+cBesA/27SDVVVFXIn2yt/1g4RbTg4OIjNzc2oqqoUZvGYebsAevI2+ciy9ElAbRNYzt9HxzZFKCMmDpbtnlP+0AXdbjfm5+fL9oOrq6ui/3u9XimY4zE9Ojoq5zNSuZa5JfK1uLhYi1oTeTLmYM+SndSqujlvDYcGxwp80GQ/s0zgEI1GN+nuEAERUbI2cF4494rxopokdQfoG2uAOeDzVKMmMyQiio5nnnwsD/YaUoOjAWgfYwSGdJQYJ9RZOS+TNWPBjAn/rl6fKEWQvyOixkpk8IqiZ+F4E2BTLrdTDszMGlAxUQCOubm5+MxnPlMKTlAO+8mTJ/Hs2bPY3NyM119/PV577bVibFBQd+/eLSCCBcd7XPnMEOfRe8HNzs7GcDiM//Jf/kvN288XhmJ6ejr+6q/+Kn75l3+55PjzHRse7sGz2HRImy4uLuL4+LikTWDsDeTb7Xbs7e3F7u5uzMzMFKNaVTcs/+PHj2M8Hsf7779fKs/gPBi8ZhBrZYviYn6tcAEalFg1y8VlJ4h7NjGBdoq4NzIYETUQb8DjMbUC4XvIMEqKjfNcZiLdPl921ElnePbs2QtyT8SCex4dHb0QdZibm4tf+7Vfi/X19bL/wM5jRNQim06ddHvcZy47GYxFNvzD4TBee+21+NVf/dX4kz/5k3j+/HnJZUeuSCEC9KLkfUo8BUYyoLDs4ChW1U3hGeSsCYxmUAPBgpEEcLDOXDnUxSN8T+5n/eP3bBw8DzzDTi6A2+VzSVeqqqqkkT548CCurq7igw8+KGx9NlwYNkryMt5enyZXchozz2Ie5ufnSzrr4uJi7OzsRL6+853vlJQdxgC55sDgtbW1F9LQuACwEfFCWjhjcn19HXt7e/Gd73ynONde74eHh3F6ehp3796N119/vZSg5zN8JyKKHGbSzg4VgMPpWMiACTYiN1Th4jDmTqdTNuDPz8/H/fv3C7PuddBuT/YGIZcAFDtSTXrutsvyaX2Gfm2yl/zfbrdLNoaBDkcyvPvuu/Gf/tN/iq985StRVVUBYH4u64ZjTXj23NxcSdVi7eQsBUeFMmGG3OIsY1OGw2GRk4uLiyL33qPE963DDHC9ZcBrlhQyzl6bmpqK8/Pzsu0A+SUK74jM8fFxITpM7tr5NWlzfHwc29vbNefK82HiAWcOQoj9r0+ePInPfOYzNbkB82Dn7cAzHoxNjl5mxzA7w01OQ9P/1oXZ0WI/oyOoRLz7/X5Zv53OTWGdlZWVgg12d3fL/qtutxvX19exubkZi4uLxZmOiDg4OIijo6NYWVkpW0AooOH9vDjWVVWVrIt+vx8nJyfF6YC04vtkSWDHOIy3KWPnZWQJ2Ax9SMEeDiImy4U0wfPz83jw4EEp7uF7j0aj0g90GY7a1dVVPHv2rHwO3bu4uBiLi4u19QC2JStkdnY2Hj58WI4VwlaiSyFSIYBZR6xpO9foV69v29SML34cHK1/9s/+2af+zFemCFqheHAZNDOUEVEDPHbQzMpYSfg3SslsGs8lvMvp0xE3SvDo6CgWFxfjwYMHMR6PY2dnJ3Z2dsrmchQhVbXY3BcRBaTlaFV2dprGY2rqphIVC9UCxjjkz+/v75cDRJ0eaIDg8TEDwFi7ZDff5QDRiCjRsoODg1hZWYl79+7FwsJC7O/v18qPtts3+70AIKPRqBgSG+ccQchjYXDBdwysbRCthG28c46z58Jjm50tGxgbfcaPv5GnPKd+HsY5KwZ/1u0wEOIZ9JtxY+xwVOivz8Xg3o8fP475+fnaCexWXvyYefNY+F7IVna4MoHhvsLuUhZ2e3u7lBzmsxAnrHH2ScLaNhmi25g/K2GTDU1zT/utG/ie+2/WO9+be+R+33ZlOWgyEmb8mWeArj8L0Op2u7G5uRnPnj0rqaW8D7PKoeU4NBBCbqvBrdlcAGW32629h8PO85hvwAfn7nDQcMSESOv1etHr9WJtba2QaQanONfWqe77aHSzz2tvb68m9zg4HJBMtcilpaUC0JzGjJ2xg2u7w3h4HSPzrliHE+t58yZ2gD5R2JWVlQLK0GV2zjJBxj0tO5apl8lc08U8Nt3LpIP1gyNU2E421W9tbb0A5pg/bIHP9qEvV1dXtTPLsj4ejW4KChwfHxc7RSQe8g89QfshI7Af/BChsg2hMEIuXFVVVa3NOLy8z5pot9u1im6Mm8cTvUYRA9LP5ubmXkgP9Xco1JDTUVutSUTRxJjHYDQaxfHxcSwsLJSUa56DLuCztpvIHHKJrGTZsdw12a7cn/zbP00OP591MQYyg8AEvAbRyL4n9jxR2IQ0YvQKr5MhwYHmGxsbxblwXzxGVVWVPUURUYrX4MzPzc0V7GZ7bdIgj5NtgPvOPZrmh+/QFuxzxqKMKZ/3Pk6wb7vdLk4r0TLSa/kusuY5ddogqYPIrglLv2fb5qvp9SxXWf5u+//vwvXKCJYXVUS9YghGjtfMRFu4vNiyYGbwnNMVEADy4NlozCIhV/7evXuxsrJSHJmPPvooVldXY3V1tQAfwsauzpINFwvDxssg2u10xMhOD99jIXARrmVh2VDZabAzYIBHO6m6RTjc6S1spse5ohIj+xjI4YXVNkD284hE5sNjc/pgEaTvz3EOqxvIWAHwOveyk5UVW9MCxhjC8Bh8+bkZmCKrTZGLpn75alK0/M+zbUC5n8ED7Ha+n0u2Gjy6bXa881x47jxufJ/xYZzzWmU8O52bfYgfffRRLX+ePQ52HIkMZBn12DSt9abX8/sZHHgOeZ1oRS5uYVLDjG4eo5eBDY+p59JjZRnKpAGXo4/sBdnc3IzV1dV48803C/trY2fHys6rGUTuzTNz5IAUO557eHhY23uA40Qpbgij3d3dmv4bDoexs7MT7Xa7dtQDwJbzBs1cMx8UhDk4OIjt7e2iKz2HFN5An21vb9fSZQaDQa24BN9rAn45esucuAACbDA/gH9km7L1BwcHpSoZtoJoZUSUSFV24JEP7/2wXvpvvbJ8WrbsZGNXZmdna8TZyspKPHjwIL797W/HYDAo1fQAqjiaOJu03eQRZxSxNgxmXZgGQEm6l8fXjgERtE6nU9ONtMtydn19cxaR7Yefbd3GPNlJI2pEwR1ew6GmXThqfK6qqpIlk3UXYwTJQFvzZbY/E0D9fj/G43FsbGzE6upqbe8Xf+diI016ku80Yazbroy9rPOabIjvbRvFay5ugQwy92Q2QDatrKzE0dFR9Hq9ODs7K0VMkAsIAj7L671eL956661otVolg4JoTR4XMkNYG8ZbzIn3xBEY8LhaFzaNvd+zbfUeNBMVJmiwWSaeKZTmozE4TxGyCplDRh3dz8cJsA0Cgo2jaapqQoK3Wq0i4zi0jmB5vRujZFniXpbHLJ9/165XOlhm0yPqVa782m1RDn8eQ9r0HO6HwDhs6U2oTDJOF+VA2QzJ/oatra2aYHkDJrm7VviOpDSxCgbsdooyq4NQGtzZeWIDZlNEhfs7mkQbM2hjT1dEFCDGpuyZmZm4d+9eyeOlzDDV7ljwlBWFOefentMMZLxomqJXTXLgRdYEwL1w82f5TZvt0HvDNGPlNDr6Q/vyeGeH4Daw3XTxmbw+rJi5P3nM/NhYW7nCrANEGc8cHbJR5HeWE3/efbWz7H4atDCXMIQGX3ZsDRayM5LXSJYh6xaPaZPzmv+2cqc/dnhY42bbbiMG/NzbLrfTAJrXHf1wG63XABydTicGg0E8ffq0pGzQZkeIWNNOz+C302KZO+/r9HxGRCmN/OGHH0a7fVNEgP2g9+7di5mZmVpKpXXh1dVNqXKcCQw0DOrR0VHteIOqqgobTanjnZ2dODw8rIEB7oGDjKPJOV8AEJ5pZ8VONCDa8uz1jI7w/hvGmjQt5LqqqlLNjQIg3suD05cJott0n52rJp3yKjInfy+TUnzfjhXjZIdlPB6XYjXb29vx3e9+N372Z3+25tAgazzbbL4dRj6HPPN9HGTkhrQ8bJCdH9bv4eFhDIfDWFtbK31kvngODjCRTBfjoK0QjLSTvTrj8WT/EpEsPlsq8n5fxr3m3F4cw2z3mIesC9rtdmm/ZdG6kB/0wMLCQmxsbMTs7GwN8+RUWBMttokvk6km/el2Ncld/rxttEl12z07Ljg7pFiyx5G13ul0YmFhIZaWluLg4KAU/iFih069vr4ue5ogNHCAOTKB6ryOPJGGx/9EgLLTzkWUtYks9FhYr9w2zsiR98cjoxGTaBmOFPfEwSHLwOQmY0NqvnUgDpGfb1uEjma8GV/jBQpsgANpc0S96I1f85zfNk63+QR/l66XOlgZWDi1Ik9AxIQliJgMdE57gSUw8+f72XmCufG5BggGC4q8XtKVEMi33nqrthBY1C5PmZ8Po2ml5s2+jtTx2vLychweHpaxAWjQdgv+zMxMUbxOTzRznVlQR138fMp7k2LRak3C0LT/+Pi4pCQ+efKkzBHzRLUsmBMUI0au3W6XfQk2EMw7LLDPKeNiLJAhjAZtqAnh1OT8FcsOf/tC6SCTOJvei0bJ9HxyOWDKzmN2CiwzuT3+vCOadn69XniOHRPajqHhPtvb29Hr9eK11157wbBxMf6MFU583nuQnacM9LxmLcszMzOxs7MTm5ubZaxhy1DWrDtAlR0oR3E8Hk3OuaN8XE1z4TFttyepdMwB7YioAyXaHxEv7MOxMW66spPnMeR9rxPWIhFAdCXGzg5Wt9uN09PT+Pjjj6Pf78ev//qvl9x8AAXjy2vMtQsSLCwslLSrubm5Eommf4wXv7vdbnzjG98orCepVDs7O6UfrVarpFU7UvXs2bMSFV9ZWSlVsijHD2lEFU3WIRW52NfgNCL6+pd/+Zc1eWTecJqmp6dLFgJAhfN1rKfpN3oz7wNlnTAeTkfivdPT0/jzP//zODg4iHa7fetRBD5rzdE3gB0REacrWnd6bWTQmwmHJifLYJf7OsrGWJChQCXER48eRVVV8R//43+Mzc3N+IVf+IVyDEN2phwtj7jRVy44Mj09HQ8fPizkFVEcHKE7d+7EYDAojjTrZTQalXMWq6oqlS3zOuawe7I+eC/LCv3HaZ6bmytEKwf+oicjIpaWluL58+exsbFRK4fuA+stJ+hpryfmjP54DxEFG0iZpJAI9gl79b3vfa/sSfy5n/u5eO2110oaGP0wOPcRM7arlmdkJut69FWTvcvyyG/rjuxY+Yd+WcdTGdbFSoiUUmCh2+3GG2+8Uc6J2tvbi3a7Hffu3St7HF3lkTaPx+PaeY0+2NkOFudiMZdzc3Oxv79f5JX+EQny3l2Pkcehaa0aL6C3kUdHT8EkJycnMTU1VUgjcCdVMrkXWM5VX6kKi3yAZZkf1iFjsbOzE++//35sb2/Hz/zMz8TGxsYLmSxeL6Qaci9H/eiHiT5w220y5utl9vZv8/WJDho2gxERhRnywrbDYsDlCjhWjHwuP4ffjmJxf1eIibiZcDbG+syAqqqKQfazKefpxeh2wQ7ZqbFjRb8ACICKo6OjiHhRGWWng7QNcskBJv5xFMGgmcvAeGlpqcZGR0yAO4qdhRsRhZ1jjDhDwcq6aa6bGBuPrefJbFseMzsARGryHPj+XrC+HxE+KwozfIwH/bCBc9pIdpqaHKt8WVZsaLL887/Hle9nJrrdbsfR0VF8/PHHsbGxURx938/9i6g7qR4/Xm9yEHiNtWHwB/nBob48y/2inxjNPF42OFl+6Edul1/P456dM5x0WDbLmsfD7fYhw5koue3KbaRP/Jjdx7G6vr6uXEzcHwAAIABJREFU7ZdA5nk+9zTxgqMFSYHT4rHPKSvMA3sxccRcwMUy0WrdnC/FuWS0jTafnZ2VtWWixeskIoozQpEA5pY2YIxp58XFRRwdHRWnHJDk1BwcoCxHTnkZjUalwqczEQzcM6HAd00eMN/ZsadP7BM7Pj4uINbEVm6fbYOfyVg2EQivupqIJa+npn7yGfQrKXc4uRTwQPetrq7G7Oxs7OzsxDvvvBMXFxdx7969Rv3LhXNPNVvAF0Rinj/kt91uF8fIY4VcAJKRB/qCXJ6enpasjKyz3T6vyYjJmZHsAbMM0Latra3Y2NiIhYWFWpo/hBiA2HuWea5l3n3HHqJLeR64ZTyeHKr89OnTsv+RFF3Ll8EsawunF9nyMzwWWe5+UHDb5Hh5zJsIxfw+ZBil0NEn9IWxnZ2djcFgEGdnZ0XHIDtErRjzjB2QFTtFJriMv0x4MZ8cw+KI021j1jSGtql+DXlki4WjcUSTXQ2R9hAkYCynpqZifX29tN1Yy/rAdpw29Xq92NzcjMPDwxJc4LveWkHkjGipyWv3m98mzrOtz86V/7/N8frbfn3iIhe+7OXeppg98DhafA9g5NC7QRSC07QZ+ezsrDBeU1NTJY3JgBQDySbV+fn5woJa+TvKQDsMfhFog1YzHxFRSnDaQPA5G+Z2u132Q7HpnBzdMhnfX0iMbVVNztEyK+1F5QNyeX5VVSWVJyLKhvac7kD+MkbO5UtzlC8vHOYR5ZnlI8tDdh7pu8f2ZQ635zZiUtmQvGO+79QmgGLeAwXz3OQ45r66P9kZh12zcfE8GRAhj8h0dmIvLi7iu9/9bty9ezeePHlSFGBeI4yhv59TBDx+GCePWdO67XQ6sb29Hc+fP6+dj2bmNTuzXpteL57PDACaxvk20Jjb56MIzLIBXrKTCStuBys/r+nZfj0DXf6H6c4RdWTQ69Tve4wuLy/j2bNnMTU1FY8ePSrnvHjt4aSxJq1XAb2np6exurr6wnhF3Ox/4eBMgEcGz/SXtlqurZ+IHhE1JzLMPMMEV1VVDtf2+nbUlh+cFZ7r8Ym40V17e3vlf4pgcHktEfngdd8nO/2MP3t4Dw8PY3d3t6Ra5kgJYwpAQa8wL1zIg53kpuhVlrOmdmbwmmXS4+rPWc7dB84hWl5eLqXB6T8RnUycet5wsBgbHBGDPRwC1gAOGeMO0CZ9LNsYgKnPwMspuLaxmfgg1ZXz1Ky3nFZ1cnISBwcHhbDhAqwzvxC3tJ814r01dt7RmSYAkcuzs7PY2tqK3d3dOD4+Ltk2pAZyMQfGWdYh9CUTYPl6mX3LDqrtiQmvbL+znBl3eB20Wq1SVAKy12dAIbPLy8tlziiX3mpNomB2KLLTiHyAxXK/PHbolfF4XDIviNxjI7LD3HRPXst/5+/hxPgcx4gXt8xAXtAuMoZ4LnsZLQ9emzw7R8s5984VDU1IVlVV5odMJBPllgu3uWmu6ddteu4n0bk6GbTiT/54+tUffMX1SgcrCxPGxQJiI5yjTmbXMrC0IGVllR0VCyDRCZwqhMsO3HA4jOPj49jb24v5+fl4/Phx3L9/v4AUO1dWHHa+eI1+0T7SQCJuyoSurq7W8mP9PY8LxS0oW0q4PDurKIQcjTBr6jYfHR3F2dlZWdRN82CQyULDwaJfgCo7rDZgmcWws2CGyAvTzq6dWQNQM1C+spLDiGaG36mHtNtFTJA/mEUcTfcnG6omZ8/jTj+8Dmgb9zTogGQgtM8zIQ4uLy9jb28vvv71r0en04lHjx7VNgZbtv1cLp5teaWddmyRK/pBu7a3t+Odd94pVeQoT0y0azwel3PBsrOV54k28mwDITNfTZcBlA28HSzvx0TerTuaopp+Znawclvchvya++F9aQB8LoMwZM4MI20/PDwsOuXRo0cF0DGGGGnmzf3gb6IWGFHafX5+HgcHB/Hxxx/HwcFB7aBexi3n3JOKglzk/tMngKkdIwMXM85cThHkN3rVBtrEAbocMGw96og4gJk0cQoyeI3wPMszZwP2er0SuTXJx7yyviOi7GPFkfTad8EF663bQEZ2qJqAbbYlGfR6rft+dgZNCC0vLxfgh/wRiWK/i+/fJAeWR/QfzgsyYH1px4C1HBFlnmx3OHAaZzk7xtY3tuU8AyKW6BBzyfwR3eLIE5/5h52IiBqz72fZzmZ8hL3L+pd1c3h4WNLE2N7gs4doH/o94wLb7yYblWXHstek//J45vd8n2xL3D7G184+fWq32yVl1JkGnU4nVlZWSgooB8xbVk26WE+4GInnwvaXsbA9MpHs6NfLbETTeHjO83d4Fm2EJKDvtIMxov1OU6XtZONAfpD55HllzzHfOT8/j+3t7Tg5OSmHN+ctK8iZnSz3y/iaeaa92dHOY2F5avr9E3P9ENr7A0WwrCQjmks28jpKCQHygjH45hlWYE3P57cZQj5LTiuKilLFtJn0Ehse+uIoQU67ipgo9cPDw+j1eoUBRGmMx+NYWVmJdvum4hV5sv4ue9C8f4RzIJaWlspG8yyIbqcvjOpoNIrT09PY3d2tlUY1yKIvPjeoqqoas2/GnXY7jSeDaRSeDSvMpBnybBBRdk4XyorNV9OCtfHORtypSt5/hWIwuDQAetVloMjz7KB5nD1G/G1Zbbfbsb6+XlK8ABSDwSCurq5ic3MzLi4u4jd+4zdKxBMQwzzl+eVy1CO3y4aaPhnAfu1rXysglnM7zKxy1hfPwdnNjreVrseC72VHJM+BQYIVOWDHDpbzzU3y8CxHl/K9sxF42Txm/cR9nQLCPPM9n81jttTRmk6nUw7aHY/HcXZ2Fmtra/HgwYNCWHA2y2g0Kpv0OV/N/dve3i4OFPPf7/djf38/9vb2SgpjJlsAmzhzBo9ON0YOPcdeixh6+sfr6AZHQg1IDN4joranlDkCcO/u7pa14P2mVVWVA67RQbCyJiZY/xE3umJrayuGw2FJUWI/qp0Cr12qMproiYjSb++1zHotA3FfBs23OWQZxHnNZYbftg2HAWZ8amoqVldXS4lqopK9Xq+mH5AjR+pMlniN4YRR3ZYsgdFo9MIeNsu+ZYg58WHhBqVNY+f15r6Px+MXjpBw9Bc9QmSJ8tQuiEHaLnbZESPrPZNomQBjDpDZq6urcr7YnTt3yuHtljkT0R5Hp8o55Thft9mkps/ddg/LIDJmR8UYzuDbjmCWP2y+QftoNIqlpaVYWloqEe+9vb1iu511YidrOBwWvGEM4/436SlIcfSAK1u+bK01jU/TWPv7yAwyDfFD/yFP0RkRk33d1jnIqHUZhI7bic6/uLgo54a1Wjc1Anx4NWOLDDqa+DK5sIx6HLKTxXj/xF9VRGv0KThYXAyc97YANCOiBuwNjBACcm5hfa04rbC9sTuiznJyn7t375aa/ghOdi5wsGARIiZ5+Rh2s6xmZ7wwYMO+/vWvx2AwiM997nMlLQbvn75FTM6GqaqqpGRwloorGY7H49jd3Y3vfOc78eTJzQGDKHYrakCpXzNwWV1djS9/+ctlEcP8HR8f18CSD3r2OAOycMBI86FykxlZnumwMv2OqJemN9vEPJI2YUVB/+yMZYeKPgOkHSI3g4VDYFYdsOXfGVBmxdakZGC2s/GxsUWWnA7AWDtVJCLKXojRaFSKdDCW5+fn8Qd/8Afx4MGD+MVf/MV4/PhxAUiOgjAO2Vm0gqNdyH1V3aSPXl9fx7vvvhvf+MY34vT0NBYXF2N1dbXcfzSanDNycXER/X6/GD9v4PUzWJ92QprAnxnYJmfG+oQ1sbKyUisjy/dsHNnTaEfcDs5t0awfxChwb5f1hi1fWFgo4+NDJ8n1Zzw9J8jH7u5u7O/vl4Op0Su03WCFMUFXMNZOleHZrH2iPowDoNj6mn0ngDicOeflI9tmXSE1DEQxyOgKQDqyA0HlyPZ4PC4b3FmvEVHOdRqNbvZjsVmddhHl42/IA9ZGJjj421F/AzPrWiJUACTWgw+g5bB21rnl0HJ2GyDzuqANXBnA+HX6ZwZ/enq6OIrW2TDfU1NTsbGxUQoLMHbPnj0r+7FarVYpPmEAzVwB+Eejm7LRrtpHNBUbydpmTNl3xJxGRIls4Fzh7GKH0fuZuLE9o412bgeDQfR6vdpaYU/V8vJykQ3vO2T+7927V/Sz9+fw23qMvc6sL9ptm3Z6ehrPnj2L6+vr6Ha7sbKyEnfv3o319fXaPjZS6rBRyLILUBkXNMlFdhgsLy9zHniN595G5BmDsOYdBTdOwdaMRqMig9gb5gHZOjg4iIODg9jf34+nT5/G6upqvPbaa/HFL36x6LnRaBT9fr+WFYWeZN2ZfIu4sQvHx8dxeHhYos+j0ahkZDjVO+MPO2pNxIc/m3EDbULvgc+w92trazUbabLBKdpkRyFfzpRCB5ydnZW9fejHjY2NuH//fqysrNTwDmmabG9xRojXFOPq/hiTcTXpuNuIy5+kqzX+ETtYecHwNwYeRsWfBxiZNbbiAljDQETU05hQIs5xzhtpcWwcSSMtBKYW4AqomZ+fLwAkYsKO5AUBGMosGhGw4+PjWFtbqzF8EVGiEBTgMHNrlphFhBKlghiGABbaQm+FhhDjOMLORUQpu85i9KZROzxOcfT8uJwx97eR4/NmsCwfsHS8hnHgbyt+Pvsqds2AOTPL/h82yKVGLa8o+FarVU529z2ycuW+2dAYCBlQZmfB3+f+/I/zS/od8m7n8Pr6Oj7++OPi5H7mM58pm9UjJmyX1yltyYyUFSIA7O2334533303Tk9PY2pqqjCrPN+EAU7CcDiszdltjorn2ePl+eQ95ijLlnUFm6HNaNKXpntwb+sX5sVg+2WOVZODbecoM++O2ERMKuXRPjPPrBWAKnIUcUO+DAaDF0AMfQTIQJiYWKI96GUz87SBsUFX+7IjjvMHSHeEBYfPTnaOEjIGdtgB0Rhv2u/7uBQ6a9jR3qurm7OTGFvaY9BBmz1HeU5plx2vvP7z2rT+tf3DsTIY99pgbG+7MqhrInjy/xkQ8sO4AaQMxtG5pBzNzs4WsHd2dhYnJyextLRUIyLdHqezM2/0C6ep2+2WLA7WiR0OyAj6BKmHTYSEyulbTWOY16T1L+uBfYA4ynag5+bmSnTAthaiwQ4b7XUEz5kC1ktez1VVxcnJSezs7ESv1yvOJ+MFoYBjQB/AHTzDaZvcN+vSDP5vk7nsZGV5y/9bL2eZNFHktEjuA5ECJkEenNU0NzcXq6urcXl5WQ5sBoednJzE+vp6OYPP9tRjfXJyUo6ZYD5NPBHdBjsha9lZum3dWcY+ibOKHUX2qB2AXHMGIXYgIkpGUrt9U/V1fn6+fJ+9j9zbdmtzczN2d3drRXoYM58vZp0JWUcUK7fb/bc9N7Hxsus2XPcTdf0Q2vtSBysLs19D2UbUGXQrdIN6Kz4DcysiBAeQ76IAVh4wiAj2eHyzqa/T6ZSQe6/XK8qTMwCGw2FxGoj+oNQwlicnJ8UxY4GziGHl6L+9fsLWjMnV1VURXtIBMDQABcbg9PQ0nj9/HrOzsyWyAfPrjceMEWkdlHTm8GDmodvtxr1792onnfNM8oEZO+aRPmKYcc5yKpwNOfMIEDbAy8qgCYBZnpoMRH6mwaoNnRWeFS/PR6HYAJAHb/Ca5dX3fll7eIbXgB1ELoMMHF2nzZolBQjs7+/Hn/7pn8bp6Wl88YtfLIAhA++mNLicyoJh/+M//uP44IMPSjoVa8751bn6EZEKz60jdTwnp1w42miHJhssj5cjnE77bbVaJRLj/mIoiVQb6PI7z62NVAbDnud8NQFnxsPRVQy9S+vSHwC505bymsxyU1WT/SkRUc50cqTIxIeNNKD48vKyMOQGUY4g8V3PTZNDfBs4sxyzTukvrzNGZqBNJHnfhssUw36jo7ATGYwb4DKPBhEGGZY/ty9H7iyT6Dqi/k3AJzsGHsfb9Jxlrul3Br1NOgqZZ8w5g8/OLI5Qt9stZfsh5I6Pj0tlPcuy1z0OAL/pN2A5YpKlgaPjctiLi4s18HtyclJbr94j2+Rg2e77sn3gb/ah0H8A7Z07d0p0xXrPmOO2ubR8uz1N0auLi4vY2tqK58+fx3A4LKQHDpYJDcaN9Ueb3b9sp5rkxzJzm17LNt3P8Jpu+myWvSZ77gwGp3U7Qg7wJ2p/eXlzyDf3ub6+juPj43j77bdjY2OjpK3fuXOnjDN4iqMgGKMsY71er9yXDB8Tj032+lXOl8eH52bbwBpkHSLfETcFPnze33A4jNPT00KCdjo3laIdhTfxdHZ2FgcHB/Hee+8V0jYiSurp4uJiic46m6PVmqTJGn8w75Yry2aTA29ZuY3s4L2m8ftxvVpV9emmCNYe3qqzZjZYEZONrGazed/stAE5n2HxORUpG0Dypjkb4vDwMCIi1tbW4s6dO2VBASjn5uZienq6fI4Q6dnZWTkhO2KSxsjfMOQsRoBPZo4BUBZ++o3R6Xa7tU3xEVHCxyjtqqqK8uD8KoyDK9E4TfP6+qbiEoqbKNrdu3dLNIsoIGOHAaYfjK2dsJwawTxF1EvFG4R4geXFxWcMdLLRbgKvTa9ZqSFDKAzeG4/HRXlhxABFrVar5GEDPBlbs8IAi6xAbguRe204ZcIyTpvzBu7sZLGOpqamYjAYxNe+9rW4d+9eCfd7r18elzxf3W63ROy++93vxre+9a0y9nwvg0lkhJ/M4tM2ntkUyXO/3R4uzz3/e/yIlBN59NkgAEivuYioHcRIf/zTJKMZNLjdLwMr+TnIy9TUVFnvrpTGeTZeax5DxoP17bx660OnoZk4AEDiXEHWoJuIzLtaqCtqEtUGhNpRcSTCOs5OocfYpBt6ApnzmLJGfQ/2mLF3lUNr0WPMFyDf0UH+t1PhVDevYafWsS5pk/f8+RxHIg6Mk2XX8uDXskzd5lx9kitHe2k/softBFDZxnn8nd4+Ho/LWWoc8vzo0aNotSZpgYy/SQvklNedfm+yKCJqhwVHTA6DzdUmTYB4bprAWRNA9meJjvGaySOieNhj78/DIcQu2j6z/ri8bgH4jppubW3F9773vRgMBkUW5+bmCnlgGbK9hVRibt3XrJc8zhmT/aDyZn2Yr6yv/XmPhR1MPosjRTSGz+Bwzc7OxtLSUqysrJRz7rBPu7u70e/3C5Yjzc9Ouce91WpFv99/QX+xd97bRtwPZLnJ2eL/2xxTr0vbFXQszjXfHw6HsbOzU4hDHDEKoLGfEb1j56ff78fR0VE5wJ0z5cCvc3Nz5cxXnFifWWnikn6j802c34bH8pXXp8fp/4+u+xu/GgiMH/R6ZQQLIXfaQES8ULkEperIDIqX963k7DVHTCYlp7G0WjeHX8L2jMfjODg4KOdo8ANAPDw8jJ2dnXj06FEsLCyU+5LnPRgMSsoR/ej3+9Hv92N6+ubwxOnp6RgOh0XwFhcXYzgcRr/fL8YeNiZiUgmJ/VYoDyJXCwsLxWA77ZAcWEq1Eu2iugsgZX9/vywQqsKw3+js7Cz29/eLIeXnvffeK/tqMLQnJydxeHhY2A7SDpi3wWAQx8fHJefXJXaZJwwui7PVmhQtYP7s/DG3drBfpqizss5GxcbXTB5tZTwBnigw5gtlbIMKMMqKMT/bPwaTtB/wb2YcIsHOg0GaDXY2bPSVtfPVr341pqZuzsb4/Oc/H0+ePCmfu7q6im984xtx586dkrPOM99+++348MMP4+jo6AXD62d6T4sdr263W8YLg+biBB5H769scq6aHJY8tk6t7Xa7xahioKqqKuQBqcKkT9I+M8kZrFnuPIe+bnMKIyapb1lOkTOAFlUrudhvQGqS33P6ozc0s28EJnY4HMbR0VEcHBzUyBqcLx/QbqPvalGUgyetGR3NHlmnn/oAY49NHhcDFtYSfWCu6ZvTd6wLxuNx0Wt24igFzlqAoODMMKfxAR7YQ4NeZY1gy3AoHflCJxIRdEYBaxsHk3Q7QJ71nh35LOtN//tqWpsZyDndxz+kGFFsCVacKA5OJ+TawsJCISMBcicnJ/HBBx+UqpYbGxtlHBlr0qvW1taKg2bnyW3F9kAYtlqt2NnZKSW5Se2y49ukm3jd8pTtCJ91dDinRV1fX8e3v/3tWF9fj9XV1Zifny/RBciQq6urcralgSL9Yc1l/GL90+v14uOPP4533nmn7HeZmpqqYRnuFxFlzxDrCJ3rKDR9MmnNNTU1VduDaXl6lbxxNTllTc6GbSC/WVsAdWfpOGqCM42DbfJlbW2tVBOksqC3KkREcULsuDEXtMURbZy31dXVWhYTZIoxLe3MY/Uym2mChddYoyZN0atkYFxeXsbW1laZf5Mx2KwPP/ww3n777ZrMEwl22+7cuRMLCwulQvHc3Fw5sBlbBZnfbrdrKbGQUz5Llb54TfIs21PLln0Fk0pu50/UVUXED6FWxyeOYFmAzBjzXmbvEGAPtg1+E5g0gM7K3JtQYQTa7XYB1DyHDZAchnl+fl7AGPci7Ap7AvuGQgZYIpQwLbCpsL4IVFVNKhVGRFEiOFAox1ZrwtgChlgEKAQU6+XlZZycnJQDSFutVlFIsNf0/86dO9Hv928m9PuAeGNjoxgvSqQeHR2Vw4WZTxYYiosxMvDPLIbnMi+sJmCa550rOzD+rJ/VpNAi6lEDf89APQNNlJ73Exgg36Y0msbA7eV+jmpy4bjwGbNWtMfK2GvJ+e3cZ2trK87OzuLx48dFbim24DTWTufmIO6vf/3rxRkxc2+gwL2Ra9aH++xccK8Z7mUDlPVBE+BskgXuxRrkAiB6XDDmjupgXG9zsPys24CH5S3/dvTWoMqywvq1LDhyhZFzOqXvT3utZ3FOcKDOzs4iImpAAsAGYCQVFYPufjjqQLstjzgQMM8eT4CUdQDynMeVcTFbynvMr1Ne7dzRP6cre74NoJ2CubCwUIo0kIWAfnKlQ/rAeBM1M8M7NzdXxsBy6xQ6A1+Pi2XpZfKe/8/6yK/zWfQCY8LaIAPBxYqQP2TIEQbfH+f2+Pg4Njc3o9/vx8rKSqyvrxcS03uTB4NBrKysxPLyciFcbMdHo1HtsGnae3R0FCcnJ6XIiNeo//bYmJjNMmaZarI1WaY4E/Ly8jJWV1dLqfCISYn0JicGOQLwe89Uq9Uq6Y6Hh4extbUVBwcHZexzanPEJIOFtWOn4+rqqjhWkCIe1yYQm/udCaUmZ6vJkc92MMuq5dHOvdem59XkJTLEZ3ge+oGja/icsYhtTcaVtp3YqogoKaBVVZUz/JzVY4xqR9EYwLJlW+Lx8ppFf3pfX0T9bE72imPrGIMclSaa6mt+fr6GxSHyiVh5X1VVVbU+mbhjjqzPPS7ZVnBlUjI7n39brtaPOoJVHtSwMC1QXBms5EnxPSyUnhgMFakOrVarbBBEMHifDYGwH0SX7t69G+32TcUie//sk8IYdTqd4jBF1Deit9uTMuz0E3CDwFsJky/bbreLAVpZWSmHxDFm7kNWYjkt8fLyshTXQEn4fBcY18XFxcJGY0jZlzUcDkuuLnnKZsMYZ/Y35JPNMyjwvOW5tmMcMUk14m/u0SRf/H4Z0+EFz2Xl7bQ2p06ZdW5qA2PRZGwsm54z34N7AyQdpeN7yBNgLacQ+rM2vHZWfN/BYBAHBwexvLwc4/G47E2JiJqR3t7eLs68nWCnxSIHERNj5QiV22HCwZ/Pe554r8lYvQxcMuZ5TLLDxuV9hQacbiv3zAbzVaxak5NFn/LeTdpog91qtWqFOBhnR0NgNpvYQRt+EzRTU1PlaAjAK44GF+XHWcvoPQO0HDllnpDjrKshdwA8Zp8zaEPmnWJmueN+Bg84Wjnljz7iRPNjWQOwcC4hhQq4L/3KNofP4KThUBE5dETasu4Ivh2ADDz8d7Zz/ozXu7+TQa8/67bn75+fn5dMhOvr60LcoQeQCy7mnH7t7+9Hr9eLXq8XW1tbZc9WxCQNFznESfH5fjhipHsR6To7O4t+v1+IviYCNmKik53O6nFr0tnMMffCLud5IVUWBxT5ubi4KFsPrKMB7KRQHh0dFRLDdmV/fz9OTk5K9KWqqtohr9ZFEB6QF9fX1wWLsF/bpApynFOxPXZZfrLscb0MCL/MPnuumnBa0x40Oz22j7c5f0SrIbSzbrdtQldETCLoPItIN5ktrjIKyUIKMPcwDuTKBK7XMfKFrvMcuOIt7fJ+XF5jTWY9w/jhHGWs6XEjOwHdhd7KeDuinkbOPKHPkCPWNn3LJKV1qGUk67gsb6+ytz9WV1X96FMEmxR8Tn+6acuE1bFiy5VPLCAZvHAff5ZFQ8U9b0CNiOJkedKpnEJEhj0rTDALL6K+GZ5n2rCzId1CPzMzU0LUuY9EJmDmVldXC3NlkEIf2SOGUQOwwD567CKi9rxWq1WYoNnZ2VhbWysHbaKgAWC9Xq8cEEsb7AjCehs85bnh7wwkUHIG0W6zFU92Ony9DHhnOfQ8Gfw73YLnOtc4K3/fz2D5ZeAn98OKF+Y7K1sDIhtv1gFGClBihc2YXl9fl7RW3tva2ipG4fDwME5PT2N2drYAADZY04Ym1tMgC1kgDRV5ZGzZ88g4Achok9dKk8PAe36mZanpyqlQljPvD3NaSGbYPJdNYC1fef7zvGcw2gRAuGAYGUOKABiA8MzbZJxxsHNOiV8MN3oMx+jq6ubMHd43Y4qMOwITMSmu4QgPTuPU1FTZM2aH17rRslFVVW3/F7rLZfbppw05pJnHgbHzj9dpRNScK1KEGYccJXEqbET9AGTsjKNWJk88Jjla4jTPDH5zNNd/W0dkPcg8+LI8Wv4Ai/SbqDa6haIWlEjHCfCckpa7srJSCDd+KBTgfvV6vXIGG0DRskuKL/Yc5wpQZxKGe6L/fNlGMwYGx9aX/O95sQ7hGTh57FGNiDg6OqrtuUM/cxg1WSAmVbgf44nszMzMFKIJyBXUAAAgAElEQVQTuSUzJiJqUSvWMG2PiCLH6EzLjXVRk3OfwW92ZrJNsyxmWfPvbOPpA/0xYWuC2muG8WA+s8MRMdnfDZGMU5TXJaSNKx7zLG9dyPv52+12yXzifRcF81jZQaSdxnPIGDLntHpk0mNjwgsHy2nI3CdnhHlu6d9oNCol73GqcLSYE9tgxt9berAbFE6iHegJk3L033LQJG+2az+p16dS5CIvOL/usKwFIINVL1ID/GycI+pgFgFgfwXfgf1FaTOZpMZFRAGKKGHagGDduXOnpNnApKIwOp1OrXBExGTxd7vdsifKLDbtJlyLceGyk0R/KZXLhXHy4Yj010rZV7/fL/sNMIqU1eYQU5gx7mWHBGaOSk5N6Qe3yYD7ZrbP3/H40H4UX0TdQGRHiiuDa98vK0KUsS/LS2b7syOQ285nkFXk18DTrKrPG3MkAIcdwIHRREnC0nN/2gU4y87peDwu51JVVRX9fr+Un9/d3S0biqnKlAGwLzNmrGOigMgLihhjhFLm+yh0QHxWvhkc5NeyA8tnXsZ2ciFTbmOTs5MdmCZ5yld+pmUCPcYPQDUiCohgTRsg4HQBCJgTZMpzjw7EGCNnOTXajibthTihbaSLcTm6hJwxj96LlaOZTjE1+2mQzNowK+vxNFFnUov+OmILYDdDbrKu3W6Xva4AFafLNekb5Jp2u60ea16n7Xa0suPPe/TPTkEGtU0EwMv0bHbyLZf0CQfJJKRlAxtm3c9cuppgRBTbB/AkwmKngnacnp4WW2qycXZ2NhYXF4vzMRgMSioejmgTmIyImixbp+S1nZ1Zz0Wr1aoRXp6LdrtdwC6RXj7HXmtHegeDQQHx3Ie1m20Ddt1ppdgc70vimRCyVVUVW+V5t37mNcbaYLZJZjwmlps8Xk2y1vT5fJmYpky6MRs6DYeCH8YiO31NugT5MWnrtYvdRXdcXV2V/9lPbyeD9dvtdmtkNdgwp1NHTPZK23F3BN9rkwqVPMcRMjtl4AGICRc3Ai/YOUbGaB8yQ/EOno9eZ60yB55b1pePfomY2BbGIhNZTY5Tk0z9rbh+CP14ZZGLzFyYIYqoH3TI/wa6sIHcw4suM5X5WRh9mDT2JD169OgF5UVO9+npaamgxQZW2PWlpaVauH0wGJTc8unp6cL6k+pwcHAQ6+vrNUC9srJSqtosLS3VqnkBulZWVmppeCgUhJPDGEkfBCRUVVWcnaq62bx4fHxcWFXARUSUEvSuhBRxs0B2dnZq6SGj0ahU3qHv5+fnJRcep4wDkvPcM0f0E8VicOk59z4Hf85pZKQbWQH7WVkOM0D3nOBoo+woK+50QcsW37Mh8fwhU7k9VmIRUWObqHbnAhu0LeddU+mSs6VQ3N6InqstGczyuf39/Tg8PCzGvqqqODg4iOPj46JEWYMRE+eJ6CgbrnmmDRlrbjSa7CVE3pAppyiNRpMDtnHIXPAiRz0sXwYnGVDwGyeUsSX1lUi1jUmTg/UqZ6pJ1pvmHhDNnPNDhIf28XduD0QH+7T8DEe3ed2G0hFC9nxajwLeABGsQ0ftkTN0Ivn8PjiXPU/cD0IANtlr2REHxiRiUpHVxIZZZNqxuLhY2klqq5lx2m0dYFDNeuAgasC614+BuecRgJWdJObALC9rlMpedqbRGwCqTLLcFr3KoCdfto/IBuNsm8rzzTwzrt7Qz7hgXyIm9pvIiolCilssLy/H5eVlSVtHVpvS9klPx8GYmZkp5ac51JUoLjJlXcIckLXCZyAsTIjRJzu1JqNwKG2jIiZ6cHZ2tmTBdDqdcmYQ5IcLItAX6xnbY9IlHR213rZNMXngzxn4uwAWf1t/WJbQm9iujKOy3Pl6mVPf5HzxHd/PUSvIXBzq6enp4qwzl+xHHY/HhUwmMo99APOYbDZ5hE5pIjrBAGBEOwvMlUlPZIvS7qQTssawpbSl3W7X7Cb2bjQaFYL94cOHZUsAuBRbgIyQdmu9A/HD2uJ51lG5iFHWN+h29Kd1BDJGdNsZTMwNTh9RyNtSP3nebTa1SVZ+Yq6qihh9ClUE+Z0HyexOjgD4OyyOiHoUx0wAVwZe/EZIWq2bQ2J7vV5xlswmRkxABgADxRgRtYgSbQOYs1gMShw9QMhZHOz3oh8OP5sNdb/MrPp9lD9gAOa70+nEYDAo44WCtyHEueR1F+Zg7GEi+Twnig8Gg1IlzODsNsXqObOTcpshyUDX8w+bYxBhmWuSwyZmzc/AKcc4ozgBbnaOfA8UD21kzpuYZzNMjElm51ylB+NhUM4YwQ5HxAupg15bbg/Py1FX3sNgu22eS68Pt9WyioziuOIY0j6MSQZ5rVarlnZqEiav6TyueXzd7uyYIWfei9MUfWVMbgO1/txtcufPI//IrY0c4+3n2LkwGIS9tW6MmOwjQM9Yr/Is9AjPxwCaMW5KbcvRJPoF2EVemXcDb8s6uhSnrWlt0Cee5zQTZNDgB/BkEo92A8LM3jrNkL5xQDFj1eQkO/LicaWtWR+5zZ7rvBY91vm6zXny+5/kNcun59EAh3bY2ZqbmysRmojJ0Q8Z+GSCww4sv+fm5kr6ke0c96VtnN2I7PizThm1HHsdeH7cFzvM/Oa+liO3xxGTvN6QMY87bQJfYButI7B1WdfahtAv9hh6jTh65efSDxNxrEs7+xlwN8mI5SgTSy+Tx6bv56vJ5mJnIWqxIZARjBF6j3uPRqNagZTsEGZigc/YkXa/cMyI1hv72CZHRBlrvovsgBusXxypg0y1o0aWAXKAw44+dpVVr4U8rowLMoc8OvrKePB8yx1rM+NybH1E1HCai+Gg2zkWxTasyUbe9rrn5GVy9GN/3RIZ/kGuV+7ByozRzXNfPGfGQo+wmjXNxssGIofE898OU47H43LGAeWbSQux4oFxiKgLroGuy5R3OpO9EiwWFiqfsyHwwatWzCwK95MxoC8wHVzkELOwUahWyI4Mnp6e1gy+HTMUHeDL7ApADPafKoNNbH+TLGSFRvqlwXiTw40TxjjkcfHzclvcngzKszI2GMpG0MCB+XEOP7Kbc90NytwOgwfkyQ6LI7codrNLPv/FjLzlCcWeZQcCoGm+/Bza5yhDVVWlrcisZZe2Og2siT3zmFo+6XveMGwni+/ktWOQy73tuNqgIc/+yQ79beNjWWz6fNP3/JqdCeaO/kCi0GdHB006MZf+fHbYss4yeOY9jP38/HztHCsiKRFRHGNXlzL5Ql9oEww0bQVs5EiVZYznel2aePGxD44OZ6c1R3toJ/fhO1z0y2CJCxkH1DU5QNzPwNtOvHVG7mtOVcwyknV/dmpedmV94DFq+ox1GvvRIDtmZ2fL354zz5edH+7j9iNnJpdwkrmYKzPlZJA4BSoiiv0DIJoEQN5oh50op4oxp3wGm8d7tN1O9Wg0KuDYcuj5o61EYS0Ljl5B7nDZeeLycSAmHNAXJoGIPhK5chVBOxHWvVlGsgy9TL9lOfqkr3NlksJgnHVcVVUp7kA/rD9Za9b7YBZ0ZrbBkGmMueeFe/qIDEc4sw2HdCfrxeuLtWMHhqrUliH0mm0c80a2TrfbrRGhnG1lfUAxFOscY23G09tW7FBZzl/m4NBOolykCrN+so7yvNKGl1234bOfqKuKiPGnsAerabK8aL2Q/B0WAROZ2U3uZXaU+2Qwb8cOJwFAz+Ij1Mp3zQbjvAyHw1o7OfDPYJPPI+AoB4PpiDrDYGUZUU9VyIaSNrv8OsCGqBsLEEU8GAzi6uqqKAHv/8pVlvibvhAmJiRMvjyRq8z6+7IByA4RYMhgMjuCjAWXmUfLTWZCshPF7/G4fthzBnK0D7kz+DaYRgHTR6cu3ib3WTZpn1krH0zqiIEVvCONrdakfLKLneCoYMTz+BmIIv+MjcFilgk7NU7d9MW9HYXwd3mtCVRGRA2U5MOULVOe31z4oMmxcjshQZhbCATLSROhY+NvGXwVkGAsmxhgOz7IZHY6ARGsde5lx9fG2ZedODvy6BheR38gHwBiM6o5UouzD/Bpt9slKhoRNb3E3HJv6zrkOoN/yx3ry8QD8uZ1Bcixs4pe9OGvZmbv3LlTgFKWc987R+OanMPsMNj28Hn0ieeTe1reflDgal2XHTTrXX/f/WNucDLm5+fj8vIyut1usWWee/rsyDn3cZTLUQTrBTP7Hi/bbuzTeDwuRXIcteC+OZXPpAL9gvg04IyIIlOMTSZU0Rd22COi6GD0IVF6gDE2wmPg9QoZQb99LpvtP7oAsJ2dOy6AO5FCjnHJ0eVMUlqu/GNcYnySZc7y5vv6e/m7dq4YH4qCAdizHqQ9djhxTixjniPGmXXGXLqPyA16iLEE31jPWmaQq4hJYSzky4GDbH9wgiOiptf5Pu2OiOJItVqTaKbnywQcjphxV95P7jFinppIYc8tus4/zAtOFmuL97Kty06W37O8+Hdeiz9ZVxUxfrFq8Q96vdTBMngzOLGSQ6GYVbLxttdupclkosx4Rja+GeCNx+OSz83BiLOzs3H37t2yT4RFg8ID0LIJ04w3QAQW+PXXXy+h3SZAwgI/Pj6O4XAYi4uLpf1OsYiYgFPa3encpPydn5+XfV4oDwwMjuDz589jMBjE9vZ2cayyIAO2FhcXa983k0YIeGdnp+xZcd63HQDu7UVkgw7Y5VnMuav1AHhRPIAkGyhf2UlqWqQG3mbxPX5mY90HGFGzZ4Ays/YYvfF4XKpmtdv1inc5hcNsLIYQR8mAlpRQLkANwIa5bCrO4bx/718BXGfHEbDBXLBmrUyZV3+W50VEKfnKvPAZM7BER3mddY7hwTA5FZL7eEM9Y+o0r06nU+4DYMz9cLluA3mnVFh/8DxvMm8CDk1yx3jltRAxMbC+/BlXpkIXGXh5/TC2dp4se5Z7AA0yPT09HQsLCzVwh7FmXkknNAi004Fjz7g4Im7nzcDATqSBvmUNGWAuSSGzbmd+XU2LtUHJceQB2fKZVVy0mUOTq6oqe2ry/hXGGGBmR9ZA2jqM97wfBIDFZ7Ks8DnrvpcBFTsK+T7c2z++zIwvLCyU15mPTJbwfeTATpTtSdP/Bk/OFmDvBnPHXNrhdx8hvDqdyTEATt2yjDP21kHOJmBemT+nNBpYmhAhk8A2yhku6Dg70MZD/CwvLxfdBD6yU2sngTXN2COH3W63VEJmT5htn2XG6y3LgdtpebN9fBkRkF/z2JkcxVnONi+TG6x/2yuegZ5gzLMDnR0Jk5pclnvsALafy+matnGkNaKbWe8Rkz2K3pMYMSEisz0z+QU+XF1djYuLizg8PCzfbcpKMDliPW79ynhZb2MzbAeZJ+bB7bJup93gEdahnc1sM5qcrdvsaNN7PxFXFT/6PVgR9YV1dXVV0uiyQ5VzivluxEQAmEjvXzII4jtNjJ1BABfKPGJSXtX7XfgMQoLDhZCwSKh60+v14vr6upzrsby8/EKpUe/7OD8/L+WsrQTpL4bXY0H0aH5+vhbm5vOUguVgYM4RsaH1QhuPbyJcOD/Os2XTKYUAyCfPbFVmtzA8OWrh9x1tsaHhby6Pc2ZevWCbWBMbECsis81W5gYIduK58vdQSo5G5rbQ9ohJzjaRKo+NFaxll3t47NrtdnEmGGvWAKQEz2RekXOctczY8QzvV7Hse5ybDLKNnI22gUETAPMac/8wfnzGspFTbjHQfM8OsNdGlo98NYFRz03ExCG6DVzk9XDbswzkzNI6aslc5f0aZvodLcpgKCJq40OfDGZ4jZQw38/7kkwM4PR5Tec9LNzHaXm3saZ25g14TS5FRCl/zRryRm7aQLvotx16zwd6nn55zdJ+ohcGe3aIaLuBuYF91n0GRHa0DGZsdywrfL8JbGRny2CqyRHLazcDbX48znYkM4Bt6p/tMM+0k+H3GGu+47YitwZkRIkiJvaBNjAPdmC5D+1Ht+f1zv1suzLoN0ngecqRFMbM9gJdTTtNUIINTHwwjzmLwg687w0pYmKXz1gesuOexzx/vunKtjjf0+9lbMA4ZtkkgsXeK/ZBZXlFhzHHjv7kdWk9iXzZ4cUxzo4jY4i8Mw+sC/qR9/Ga8KEdfNYkLbLD58fjyV7riCiEPpgCm2YS1YSZiSnfp92eVBs2Bs721rLJmNL2nKnBGmN8kHmnPprgaiIifTW9R3uybP3kXNWPfg8Wl4EBiyGibnz9WSYV5tAT2+l0iqB58LMBt5PV5DDxGYw7TDZAFOGJaGZ7srHgu0SOqKx39+7diLhZDC5/3m5P0hDtCLIwDPrtiLAHiigJYBNDvbOzE71eLw4PD+Pk5KQ4jQBOFrMdG1KxstFjTAiV0w/aZYfDi9eAwD8Gd47sGWQajFvhW27MQmZWj8/z2yDbxpI5y8yMHYhsgM1SI5sGmjBDyA/PQM5RfP4hpdOMZ35uE+hyGz0mRP8Ya8uwgZEVZwYnfs1RH5yLpoiljSFj6vsgo3ymSeka2GXF2ul0CrvLuHrNALocJQWE2cB6fq0rmoB97osdWTv9t7FvBje5v37NPzzLKcrIGfLctCfIfbHOzDLjcfO6JPJj0GIdh+xWVVWcHMbTZJAPRbURdsSPNt7WTt8TnU47rcuYawB1JqqQJSJozDu2xdF0dB3z+yrHmXYyPpAbZqgtA3Ye7ZA0kRAeC+5tnWY7l+f/tvb6+xEvpl67XzyPNHOX9zcxkB0/OyJ2tAxoc/t8kY0CKUk77LSaMKFNluWIKNX7+E7OmDHGyLoWkGwHKEdG3Fd0Le/zHTtJlgGe6bGwc+1xsr5m7ZngQY+ip5yi6Aib58i6qUlu8tUkQ6+6bnO4bOf5nzYxx844cGQ+6wmvKebSY0M7+I4JKju/yCntsl5rtSb7zzMJaucKTJejc14jOEjoRGw1bfLc0HdXtyXLJSJKtMwywJj4f3QfetBVem0HmuaatruYmNvn+bRDihxax+X++R5Nn8l69mXO2Y/tVcWP3sFyOdcfl6vdbsfrr79eBNuCkA2XlaBBJZf75v1OKHgWJ4zHcDiMk5OTEiXg7A8riizEvq6ursr3iZg51ez09DT29vbKYYyj0eiFUtrOaadtMNcocEcTm8YEhWgghEIxK2/HESNkZsOOKWNoRenxz8DDLKUXL0qR8SLa+Td9dTqd+IVf+IXyvx0A/oZ9dEQ2M9kY1IjJ+DGGlMcej8flHI2qqorByptwM/HgtnoebQyQI4y5nX/niBsY2Zm+vr6u/R8xIVpQ1OPxuFakBYAE0PFeAu5vB6vdbhcQnlk59xfwlY2Ux4d70FY7tow/l6M/+eL8Hq5vfvObL3zmh31NT0/Hr/7qr9YAcwak2YGMqOtEO9yMPfMHWLAjz5iQsooMcX9ky3NtsG8AzH0B1aTZeN+r+5EJMEegDTqRY36qqqqB5QwguExQMT6Wf/SgCQSnifnKANcEUwY/2bmyrDbJ2g/76na78U/+yT+pPZOxcnq722wnyKA3O5RNAIxneCyZY0eu/P0M6Kyv+M39XLwgzx022/e0vkUX2J5iD3Naq8k9k7r01/00eRNRB68Z9Bvw0ifWJ789Ltk5NN7wleWNv5uIIafA/bdc/+E//If/pu9xzc3NxW/91m/VXmPMvc69VrNdg2jxuvWYmHDhHhET8un6+qYQ2vn5edk6gfxg65zBZEckoi5PEROM4y0v2PZWq1VLaXWquvGXC6/RVp4LgUFfWK98Jo+ZMbLvZyedexO9cmbB1NRUwSSZSMwEyyfxEz6pg/9jc/0QHKzmskrfvz4N5+r3fu/3oqqq+OxnP1te+/3f//24uLiIwWBQfuwwkGriCi9ms5yfD3OAouLHwjQ1NVXKZKOke71e7O/vx/b2duzu7sbW1lY5dwgnhlSbzIqyQPnfC42zB05OTuLw8DB2dnZie3s7tra2Ym9vr5RORwm4+IH7CWtNPxxdAcialWCBuv+wybxmhofv8j3/77mgTTllwJ9DCRiwZWDbxHz8MK9f+7Vfi7/+67+Oo6Oj2N/fj3/37/5dPHz4sLw/MzMT/+bf/Jvo9/uxtbUV/+Jf/Iva90ejUSwsLMTi4mIsLCyUsyI8foCHDDz4nUE+4waLZubVoNXMPgocZzbiRSNqhtHRXd/PUSDuTyopBoeCB3lO+D8bEu5tYIKsMV7z8/MxPz9fNnEjw5ZHp09aFg1OzLbxPacXcvCsnbaXydiPSu4ePHgQf/iHfxjPnz+PqqrizTffrL3/Ml2HEfaYGnh5fbHuff5Q3isY8eLBrFwea358n263W843Ii0P3QBQNWi1vvG5Pk2FYJwSY51l4GQ5+f/aO9cQva7qD//mkvtkYgwkrb2IeItWTMEvglKkFZsPLVK1FCFeQgnS9kNRC37xhi2I1UqpsflQhcS2otCCimDFv1RjbUVLtK2NiNRSi02saZPQXJrLzPw/hOfM8645k0zNJFbYC4Z53/Oes8/ea6+9Lr+1zj6WJ+5TAzQHbfDIjhBUHX364CwD1zuTwTE72azJviAOcnA8n3Qy/cXzysyly5zhH3NlvhMoOmhFVgzMeUzmG//7qhAMfNRsHCAbJe0g/vxxnt/1Q9BIZYifC2ZO6XN9dtGZEHhR599jrrq9ZjkNKHitIOvIq3lu+U2mAYUqg5Zjk4MA6EzImenqq6/Ob3/72xw8eLA34JqamsqBAwc6vXbXXXd1vxmcNhBYK1rMa3hoX8OAgdursoVfhj08evRot5Mv9tFBjwFryLoK+12Bacupd5omqDWoZyDJQI3tO4CCQXSvM9s0B561ygve1PVpObU/PFuG1G1Vvdl3fp3D/xmamsrUxMSsf3OlOZUInil6z3veMxBYmW699dZ84Qtf6P1tzZo1M0oGjKzb0CIwCKGVIs9IIJQLF5548SUlgLzY1M8KgH4dPXo0zz//fA4ePDiAtnthW+kNDw9nz5493TNVvOgX40MdMG8d9wOuRhBwII1WjI+PdwsYhUDmh3GPj493zhY8OHLkSNdvDJdLbWwUHbw5MwAfWdSUaBhpwRGvSml4eLjbcQjlUVG5+aKdO3fm8ssvz65du7Jw4cLcfPPN2bJlSz74wQ8mSb785S/nzW9+c17/+tfnnHPOyYMPPpidO3fm5z//edfGypUrO+SLcaLAjaRb1qz8+gITgk63ibLDGcDgo2StaKu8m7/12R8cW15wiNyCHIK0sqGKZRc5gLz+jJD5+SqudRmYDVYfeo6cQciDH3znd797xM4gvyNP/MYxyIbmTNHk5GQeeOCBfPWrX80jjzzSe87JdB1ZJq/bmrEbGRnpNrioxtcbDVle0U0GbOCV5YqNMpLBDBaACfK7YMGCLktp3cF19NebwPgck51IZB9H1Y47/HHpKwAcfUQ/+Xk4y6zBI2/eYxDJmTivs2Q608IYvQujEd/KhwrMnS6dSn85UHLZp59fs43hnBp40ha8oU3kArtgIKAeg3913dEnznc1Rt1UhHaQYXhOOSn6kyDFlSjcm/a9pXcFBZNp3W65s2030MW5zjjVbKb1Uw0k+M5GLXxOBp+rMTn4M4/mW8Yqvfjii7n99tuzdu3aXHrppb3nrFu3Lk899VTvb6w1+gjYiBz5PGfOHfQ6kLYcMPfWVUeOHBnw5V5++eUcOHBgIKDpAzLpI7oYvWp7Rpscc7ZtaGgoY2NjAzYTufE4q/72WmDua0BmG0cFinWfdVmfX+JnWf3fOoI2HcBZx/XZT9un/6nAynQ2tmm/6aab8u53vzsf+chHumN33HFHJiYmZqD8r4RGRkbyrW99K5/4xCfy+OOPv6JrUTxWrigrI91GnLxwkkHj54VgJck9qiPGQgEp83MLCHwV7pGRkRw4cKArj2IBYEjsABrJsuFKpnd643NV4CgTDAmK2kgi/XfKOUnnjNmBg59G2cwX86869Ci5ZLD2GuXRFywkZ0bmnn/++YHvExMTedOb3tR9//jHP56NGzdm37592bdvX+6666588pOfHAiw2PmRXfHsUCBryI4zOi5ZGRkZ6UoGHJDXebWxNMJcUXgUHjydLVhwEEPGx/PvUijLIg7IyYJfzyGgBse9BbSDNPjisi47T3YYIJw/znX5B2NwZqfuylh1gXmcnDm527JlS28gMRdyH0FQK7roIB+jbD4ZGWZO4QPtVV66MqDKI/oF8ms4KghDG0ZUK/+rnuQYY3DGBacAmXeQiGPjYMjAjlFg1m7NcJmnVT/TZzu8RsZtT17J3M6H3J1KfzE/fUER81FRaQMdto/W/abR0dHOyatr2oEJY7f9sDygQwDfuK7qBNq3I+j5pa0K7rnf5kmSAXtoGbdO5K+CHn2ZJcAl84L7VX66nVop4nOqkwvZ6TZ/6lwNDQ3Ni8z98pe/TJJce+21czq/kn0W1r39B3hkv8pzXYPSGrQ702W557gBIu6BHvRuuO4TPGXNG3S37rDNn5qa6t6fxf0tty5H5TeXv5oMVmDfKI+ezZ/t8wm8Lg1KOtMLmYd983cyOtNB/hmjqankFWSqZqNTpgvuueeerF+/PitWrEhyYgKuueaa3H333fn2t7+dvXv39v499thjJ23305/+dLZv354nnnii9/frr78+L7zwQh599NF86EMfGvht6dKlXanRsmXLMj4+3n1esmRJxsfHs3z58oyPj/e+jBiHw1ub1zI8BNQZLBzd5IRweTtvo2U2UD4ftARiISHkVan6nJGRka78x7/jVLr8j/Gy5euKFSs6nnBs+fLlM3aNcSBVjxm9TWame+1kJDPrk+1sWTE5kOX/mZK5Cy64IHv37s3hw4dz00035dZbb02SvOY1r8l55503cP1jjz2Wiy66aOB6lwXWUinm3w4kQQzjMgKP0XNQwjtQkFUrMNp2GRcy5qClZprsQFb033PLfOMk21hh8KE6pxXd9b3gEfLoshj46AxCLalxBrWOk3Mp8XWmB9mrhrGivdDU1NQZk7tT0cl0neesBkGeXxt080MpAgYAABWpSURBVM/r2XPHtQ5G7ZSaLHvMqefLlQMuv0auazkh5DXvdeG+4XzVMVmP1+ud2YBfDvqTQYTVOs1OUi1LtQNTEdo+R6IG8H0yl5y+jZ2r/rLjXcfOWrEz7rXCHNegwE69gxxn+GrAaf1BVrEGDDWLVZ+XoYSZ15BQAVKDefpPxsIbPtl5t+3378n0xhnVXuH01yoGy0H9bBtPHy0f3Id++M887uNnBSpnk7fkzPl1lbZv355du3bl/vvvn1EebdlhjpnHGlxUH8nX1mAB4pkq2wL7Hn0AHP+dxXE5Pm3VDFYyvREGuo9+cU+/UsTyihwZ1Dp8+PAAGM8ceS4dlLpMtr4eyf129so61bz1Pe3XeR17Dsy7vu9zCcRejXRWSgR3796d7du35+qrr853vvOdrF+/Pnv27MmOHTuyY8eO3HDDDa+44+eff34+9alP5V3velfv73fccUc++9nPZv/+/fnABz6QH/7wh9m9e3cefvjhJOnQTAhFmUw7g3YUEQx223PJh4UOJ9kIhAXPyo0A69ChQzNKIPid/zgElO2BeNSsR60jxolg4YK2eZEk6TZXANWYnJzsAgAWgjei4BjICv2BpyDc7p+d3D50ow8d9DnOqDGuqkT5fCZkLkmeffbZrFy5MitXrsymTZu6jQp4X8z+/fu7c/fv35/ly5cPXF8ziyC2RreNHBnp5I8SFqOzo6OjXbmbDbARO5cnWC6MQCGHk5OTnbwcOXJkICizrNnBctaWe1nhOuB30Ah6Zh4hn+4f93KZKsid144dlrqmfIw2cYLr2rMxqJkJy6qDwjMldyejU+m66vzxnay0x2ej6/HZ8bPznAxuUFKzGBU08BzVQCjJwLOgZGqd5XX/+ubG64bfOO55rgi214ufXUAfOsgCuQZgQ5/V4Ko62bYBdoQMFFWwyJ9PhuSertzNVX/Rj7peRkdPPMzO+Jj3vnPdTjJzq2oH7IzfzmV9JrBe68/MiwNaz1O1Q85CoEdqtpWxWe5qUDM1NbhpCraL6/vm1JkyZzn8bqXa/z6fwqCW25stuLJMVbmr37n35OTkWdF1l1xySX73u99l6dKlueWWW/LTn/40F1988UCpHGNwJYarGpw9d2bLMuHxVZDA8sNcGIDxvDmLw5b7+CkEVGyGQoCUTL9KBf3HfWmPRzFc3UK/Jiamd9vm3p5br0V44nUKXwgECVJrO+YTY69AiZ/DR+YMLlQfr+o92q9U/dWzSePj47nnnnty4YUXZnR0NN/4xjeydevWOVw5dSKLdZo0pwdetm3blg0bNiRJNmzYkLvvvnvON3jve9/bPeT45z//OUly++235ytf+Ur3PFKlP/7xj3nxxRczMTGRn/3sZ7n33nsHkF2yVaDi4+PjOffcc7N69eqcc845WbNmTVatWtVlb1atWpWxsbEuYzM2Nta9ZM7OKYLGYgEZ9+5X1bHZs2fPDKcmGXxGheN79+4dKHVg8ThYHB0d7TJQfB4bG+uMxsKFC7NixYq89rWvzbJlyzonYcmSJVm5cmUuuOCCXHjhhXnd616Xc889N6tWreqyV4wd5IKXftIOPGWDAH5zFrBuI1vRHCNEBFQ8pEnwR2klOzX6fPg23zJn2rt3b7Zt25Yf//jHGRkZ6XaIGx8f784ZHx/PSy+9NHAdAYMzn0bPPK9G1DiO4fAmLVZqoE/8r+/nAMkng4tMettrZ3TGxsaycuXKLtiuQbSfH/GzKd6ZyY63Ay7WjkEJK+5a143xWbp06cAx+Oj/GFYAAnhoxC6Z+QxVDU7dpvvbBxDw/0zKXR+dSte53A6ZcTA/PDzczRc8RS+OjY0NlGia+hBigzfOZlZHzSVMNftoIMVy0efsISt2NpgLjPro6GjGxsa6uVy2bNkMuUDeaJu+sL4cuDE2Z0TtyHhcPJ+UTOtzO2LOCrJure9rVma2YCU5Pbmbi/5Cv7iUCB4DsgH6MH/eVKL23UCSHV9XMeBkotsJbByU8r4g/o4ePTow9wYC+WNbbT7z6hPKtumTbYw3w3AgxRxxHuuHLbEZB/NtR9HAh4Fd1gBBJb8brIWHJubHwZmDLJfiO+NIH92vvoAU4vvpyNxc6De/+U2OHTuW/fv358Ybb8wb3vCGvO1tb+t+d+DLnCADnm+P1cGu7ZDtapUz2qtBCPy3PcJ2upLk+PHjOXjwYLcB2eHDhwdeTj06OtpVS7GREz4mz6by/lMyqLx3zYG07Sn9YXzeWRJbzPhZp/TRoFLls+3GyMhI97hA1aU1sEUnuLKlAlx9IJL7/N+gG264ITt37szFF1+c973vfbntttsGHseYlaZyokRwtr850pwCrB/96Ed55zvfmYsuuihXXHFF7r333iTJli1bBna/8h8OxkMPPdSVpL3jHe9Iklx22WX5+te/nl27dmXXrl1JkkceeSQf/ehH+8dalIQXlIUDB45SLu+mV4XCTDYyPDw8XdZSjYO3W6Vf7CTIdxaxkTkMiVEIIxYOWnCCHXhxnY27URc2LahtsBDtnKFAvDuhnXOcEvfBffLCNhLD4vM2p85UMA4UqRERO3ZnSuYqjY6OZs2aNRkfH8++ffvy3HPPZd26dd3v69aty5NPPjlwjRWys1JWInb87GxVlMcIL3JQDY6NqVEm7wRWy+rqDnILFizoAuhqjJmvijb7WRbuXZ1Kj2e2so1kcDcszrWzj7NcQQfzJhncqave2zJqZe85ow3PgXUCn8+03J2K6jqAF84UcJ4dNvPOhg/+m4fmk4MP5ts84l5967TOl/lesxQOCl2C7SDEjqfH5/HUrLrvjT7DealBu8ftTBR8qtlQEO4aKNZA0NlSO7mzBVOVv8npyd1c9Bf8YFy1FI6+OEDyMctddd7runJGuzr9DlgdzNl+uKwQ+1HL5Rw01cDWIKfLpXy9A0NkrWZJvSYMLNV1gYzYthm08rpxcFedTmfLvBanpqY3VTAPPQZTDQw9N6bTkbn/hKpuwz8hGLbNq+WeDkY8/uTEWq56rtpPjhnIRCeYP3WXR+sslzA6g9YHEjrINZDjfiOT+IbW3/ZJ+3gHD+gbuxYyrmorzPO+7Jfb6vPPvL783eu0L5jqC/DPJk1NTXWZ/LGxsW4X8Llcd9Z2ETxy5Ejuu+++fP/738/vf//7PPvss0mS6667Ltddd92cbwa95S1vGVDKu3fvzpVXXtnV9374wx/OAw88kEOHDuX9739/NmzYkCuvvLI732UdTKCNLiVOw8PDXZkKiwmEqDr99IeyQojFQqlBRQCpDYfslKJ8kwxsw+1UOI7vggUnXiq3ePHizkGAjh07NhDw2ajZaNaSgyTdBgWTk9PvWHAtMG2xkxJKnjSzHVcHFFYCfQuO8WGYrKj6jG41OvMtc1dddVWefPLJ/O1vf8uqVavyzW9+Mzt27MjevXuTJN/73vfy+c9/Po8++mjWrFmTTZs2ZePGjQNt2DmDrwsXLuxQ3urc85mABYIvftk22aQ+o+msjuUb44SDaKXOdXYuIe5DP1zCBdkoVOfFZXac4wyB7+2+cB3Gzg467TEml0MmgyWo7qtl0XLKNUbcvP5ou5aazLfcJekyjHxetGhRpzPmouuOHz/xPhbkiKDUAYPlge8O+B1QMR8OcqC+INbH6/lQzXTZCTLPveYdyLhPtZ997SbpNn0x2u/zkHv0PoESTpfXEbrOgdfExMRAOazXU3Ua+pwYf/fa7OPx6crdqfRX1bsug4RfOJFefzVo59yqayrVbFYlyrCsX+gPDnbNOsHLyn8HRMyh5YL7oV8MftkZJ9vAMZfWGgSo4Iz7zTgIGCgrc3BQ1yI8dVWI54TPtUKkL9hATj1Hszm4pytzBibIpDPmt7/97VmwYEGeeOKJLFmyJLfcckv++c9/5i9/+Ut3fZUNg9GWTZeS1/GwHi1HDqzgj20P97IOcnv8x2YZYDDfkRF4biDG8mifz/23H+gXCjsLar/BY4V/yBrv8eJ4BXiQdY/ZOraCT/W/eeDgzBlFaDYb8t+gzZs35yc/+Umee+65LF++PNdcc82c+/VKAqnZaM7btG/btq3X6fxP6N///veMY3v27Omekbrxxhvz3e9+N0NDQ3n66aezadOm/PrXv55xTUUCvBgs2JQ+wFgExSUToPg2opxvxLUqPd5tVdEOiLYOHz48EDm7NAEjhrKyYeM+VtpjY2OdcNuZ5Bo7tjWYsnBZGbPIUArw1uU0VVnVsdTFXx14KycHXRUZgeZT5s4777zcdtttWb16dV566aX86le/ylVXXdX9/qUvfSlbtmzJM888k8OHD+drX/vawA6CzIProa2goOr8m2pQYB5Vh78a8WQ6WHapHsCCA6nqyC1dunTAQFsOHSjTtoEIxkv5DM9+mSxHznDaOBgFNqBg55q23Ib5ZnDBaxjZrKgf1xq5dF+Saefe95tPuUumn/1Mkr/+9a/dOJO56TpQ1T7DwLqxc1adQxxH7tsXACSDO7XZIfe6h//OPNXzbKjpk+elBlaWd3/mXtXR7wvU+pxIt8GYKn8qKML9sAsuMeSefpbCxDj9uW8d18/Q6cjdqfTXyWQHp5Z+YTNdKuxg3XyvcsR9qoMLT2xvRkZGOvCQjJQdZGef0EfVcatgozNitEk/HVhaH9E3yGV6tSyaNVKv5zfm1Vk4dCa63uuMfttu9s0P56LDalbR1Odcz0anI3Mf+9jHBp5nefnll7N169Zs3Lgxa9asyZYtW3L++efn4MGDefjhh3PFFVfMsD3JdAUEvoqDHzvwXs++Hlmq8obut/+GvbDvSB9o0/eDCIIAVO1/EdRXPhv0Ru94DQDgGMy0znCQXOUU2YBv+Ljui9epA9TKP/sLXt+MwW1VoMbXV3o1BFqXX355/vSnP+XSSy/NG9/4xvziF7/IunXrZjz+Ueml7M3/Td132vefc4D1j3/8I4cOHcr9999/2jetVI3NJZdcctLzWQAucas7wiB4LiOwcFVk204FAl6RepQ314BM7d69u3u2pDrdExMn6op5ANmLHNQC4t440jWIYcx2ECsSTL/shGA8fQ8CQhsLMlxJBupt/XyDlX3NmPWhjPAOtNK/89kKwYtxPmVu8+bN2bx586y/Hz16NNdee+0pt5xlTH5+KckMg2seVNQTmYTsrFY018aAt8r7GSQ/VMv1XMcce6MLjDv3rWvCip/fKcNFHuibnf4KQsALnJS+IB+lb4PS52DQlgM2E/3hQX0DADUrUgP7Pud8vnVdnzMNnUrX1UC+ZqNqVpnjHiPyAgDlObPR5xj3sjH3GNCDVT854IfXzlSejD+WBfraVzbqvrp9lwcBBFhfww/kEbn3Peq4WQOTk5MDOhU+evzw2evA45tt3KbTkbtT6S87WAQQyeCaTzLDTi5evLjbmKfqezu0VX97ndnps4OZzNywwPNG3+xw0+8+gIDrOR/7b5mamJgYeNEw9hheONNlR9N6uAI5tIvMO/tGWzUYt90n8KoZRY/N46qgUB/vZ3Ns67HTkblt27Zl27Ztvb89+OCDWbt27Umv7wtk7Mz7mTT7al6/XmvO/Di4InB3Fsv2iSxj7Yv1irPkdQ3wv4LvVW49L/gQ6DnADMY4NDSURYsWDTxa4oCLtuvzhe5zX/Dv8Tn4c5uQAVl45TXh+fpvBlGVrr/++mzatCnJieftv/jFLyZJnnrqqTz99NNZu3Zt/vCHP5yVvswpwBoaGspnPvOZ/OAHPzhl5He2CBSSzyxIlNnBgwcHnNTkhJBRp+o6XAuXDbjvVZUA5x4/frzbHZCHEm2gQD78Ako/R8DzThgE+knfuffw8HCXKWPcvMeIF8Nyb+/UhsLnvQ44Y0Y7+A9aC6rIRiD0G8eFNuFldbhQHE6xu07eZZbOqHihvhplLhk0fFWpwFOUEbxGVpBDlKZRWnYRtAPH/Qh++bx48eIu0EFWkBMjf/TH8kwpKH2gjb4ta2nj2LFj3QPE/q3PIajlAvDF8umxObtiZM9BRJ+DboAB4wlKTF9cWgKPuLezMHaWXm1yh/H3BitJumfsjN5bfhxMMtZa/mxwhTYcRNtJTqYNP+WNyAzn1vIYB4deKw5mAJkcSDMWAALGTT8XLVrUyRH8oAQ7ma4s4DvtOvByAIfDZV1LGSbr1vfrc/4ZV3VwquNrqjw5k3JnYMb2jDFiQ3AkkSWXuNXnRk0GiZJ011TAhDaRjSqrSQY2EeA6A3EQ59vuuz3Gjey7mgJZooLE4/BOrxMTJ3Z54xEBAxroGgfvfkeid6u0LvJz1Mkg0MRx2vOcETC6bQde1fk1HyqPOfbf1HXmJf7CoUOHut+9fg0sYR/gJaDK1NRUp5uwcQYO3BY6wryjffriZ3vtMxqk8mZOyeC7F71mXEro+ffjBQCm6DvWnjO5bpfNLdgYxH5dDQ7r84Uea5U/eG//zP5bPSeZKWuePweYZ4PuvPPO3Hnnnd3nyy67LA899FBWr16dt771rfn73/9+VvqRzCHAWrp0af71r3/lmWeeyfr1689Gn05JLCwjRlZydmrrdQQ2dnKdTUD52zlgEaPQqiJ0QAHZKFs4+bPjgwD2ZbMsxDiRzgqAyvC9jr3vv5GVapjscNbfcLgr0sJnj62iHMyNz7NyM70aZS4ZDKz53od8Q/W7HXobS6N1OIzMvcv/OO7+1J2qcHRdNsduSJQRcNx138giBolyCDs5BOPIrB0lnDN4UY1iDWKSwa3h+8YHDwyE0L7XG3LldWwe1Wt9jenVKHcul7RxrCUfLi2G7ORa/ySDW5qb+jIvBmu4vwGgGmTwuwEG6zy3j9xwHHDHc2NZQm8hq8wjjg7n+ZlX60lnuJL+92LV9Q2P7YRZjzoTCE8qGSiosn425c6Ofg1anDHAKcMB9CY5Sf+D7EbEk0EQw+P1Z2QXneL35FUAxPesQKhBGLeNnqB/Pq8CqlWOAR4NnPn3auucFUEvW6c7gLctRabr+Lxmra8sb1Xv0a77WOcreXXouuojVMfca9z+GHNmQMP2B7uIfjMAxPV1jVZb7XlCRuEt5/r5dAdNBt9das+YKqjlc30vrymvV4+JoI8+OROHXLkCqY7ZPLH/hszVv2pH5kpnK7iqdPPNN2fr1q15/PHHMzQ0lM997nN54YUXztr9h5K8enJ7jRo1atSoUaNGjRo1avQ/THPapr1Ro0aNGjVq1KhRo0aNGp2aWoDVqFGjRo0aNWrUqFGjRvNELcBq1KhRo0aNGjVq1KhRo3miFmA1atSoUaNGjRo1atSo0TxRC7AaNWrUqFGjRo0aNWrUaJ6oBViNGjVq1KhRo0aNGjVqNE/UAqxGjRo1atSoUaNGjRo1midqAVajRo0aNWrUqFGjRo0azRO1AKtRo0aNGjVq1KhRo0aN5olagNWoUaNGjRo1atSoUaNG80T/D0pc+noWms38AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for tr in [2, 4, 5, 7]:\n", + " plot_stat_map(\n", + " '/output/datasink/2ndLevel/con_0001/spmT_0001.nii', title=f'threshold {tr}', dim=1,\n", + " bg_img=anatimg, threshold=tr, vmax=8, display_mode='y', cut_coords=(-45, -30, -15, 0, 15), cmap='viridis');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**FWER (family-wize error rate) methods**\n", + "\n", + "We control for any false positives $FP$:\n", + "$$FWER=P(FP \\geq 1)$$\n", + "$H_0$ is that there is no activation in any of the $V$ voxels.\n", + "\n", + "Control for type 1 errors(We wrongly have rejected the $H_0$). \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Bonferoni correction**. The threshold is adjusted as $\\alpha/V$.\n", + "\n", + "Decreases too much the probability of correctly rejecting $H_0$.\n", + " \n", + "The voxels are not completely independent." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Random field theory** estimates the number of independent statistical tests based upon the spatial correlation, or smoothness.\n", + "\n", + "The number of independent comparisons for smoothed data is:\n", + " $$V /FWHM^3 $$\n", + " \n", + "where \n", + "$FWHM$-full width at half maximum\n", + "\n", + " At a smoothness of 3 voxels, there would be 1 /27 as many independent comparisons. \n", + " \n", + "The Euler characteristic of the data give us estimation how many clusters of activity should be found by chance at a given statistical threshold\n", + " \n", + " \n", + "FWER methods often give too conservative threshold, oftentimes FDR gives a better threshold." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**FDR (False discovery rate)**\n", + "\n", + "Control for the false positives $FP$ among all declared positives $P$.\n", + "$$FDR=E(FP/P)$$\n", + "\n", + "\n", + "Let's take a look how the popular **Benjamini and Hochberg** FDR procedure work." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "np.random.seed(1)\n", + "#define a treshold level\n", + "level = 0.05\n", + "#here we simulate some data to work with\n", + "#how the treshold is affected by changing signal_to_noise? \n", + "n_points = 2000\n", + "signal_to_noise = 0.5\n", + "noise = np.random.uniform(size=int(n_points*(1-signal_to_noise)))\n", + "#signal = np.random.uniform(size=int(n_points*signal_to_noise), high=0.001)\n", + "signal = np.random.beta(a=0.1,b=8, size=int(n_points*signal_to_noise))\n", + "pvals = np.concatenate([noise, signal])\n", + "\n", + "#rank and sort the p values\n", + "pvals_sortind = np.argsort(pvals)\n", + "pvals_sorted = pvals[pvals_sortind]\n", + "n_samples = pvals.shape[0]\n", + "\n", + "# the active points are the ones with: p_valule < (rank/n_samples)*level\n", + "above_tresh = (np.arange(1,n_samples+1)*level/n_samples>pvals_sorted)\n", + "positive = np.cumsum(above_tresh[::-1])[::-1] #declare positive all points with rank less then the last postive\n", + "#Let't plot the result\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "cols = ['red' if p else 'green' for p in positive]\n", + "fig, ax = plt.subplots(figsize=(14,6))\n", + "\n", + "ax.scatter(range(n_samples), pvals_sorted, c=cols, marker='.')\n", + "ax.set_xlabel('ranks')\n", + "ax.set_ylabel('p values')\n", + "#lets add Bonferoni treshold for comparison\n", + "ax.plot([0, n_samples],[0, level], label='BH treshold')#Benjamini and Hochberg\n", + "plt.axhline(y=level/n_samples, color='black', ls='dashed', alpha = 0.5, label='Bonferoni treshold')\n", + "_ = ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "#import nibabel\n", + "#data = np.array(nibabel.load('/output/datasink/2ndLevel/con_0001/spmT_0001.nii').dataobj).flatten()\n", + "#plt.hist(data, bins=100)\n", + "#plt.gca().set_ylim([0, 200000])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Special thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/seminar4/IndividualAnalysis.ipynb b/seminar4/IndividualAnalysis.ipynb new file mode 100644 index 0000000..7ab41d5 --- /dev/null +++ b/seminar4/IndividualAnalysis.ipynb @@ -0,0 +1,2213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GLM: 1st-level Analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The objective in this example is to model the timecourse of each voxel. This will allow us to answer question regarding to the voxel response to different stimuli. \n", + "\n", + "We will model the activation at each voxel $y$ as a weighed sum of explanatory variables $x_{i}$ \n", + "and error term ${\\epsilon}$\n", + "\n", + "$${y} = {\\beta}_{0} + \\sum \\limits _{i=1} ^{N} x_{i}{\\beta}_{i} + {\\epsilon} $$\n", + "\n", + "or in matrix notation\n", + "\n", + "$$ y = {\\beta} X + {\\epsilon} $$\n", + "\n", + "which can be solved with Ordinary Least Squares regression.\n", + "\n", + "The parameters ${\\beta}$ represent the contribution of each variable to the voxel activation.\n", + "\n", + "The error terms are assumed to be independent and identically distributed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Design matrix](https://mri-q.com/uploads/3/4/5/7/34572113/9355842_orig.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The matrix 𝑋 is also called design matrix.It is up to the researcher which factors to include in the design matrix. The design matrix contains factors that a related to the hypothesis the researcher want to answer. Furthermore, sometimes in it are also included factors that are not related to the hypothesis, but are know sources of variability (nuisance factors).\n", + "\n", + "Now lets take a look how we take into account the delayed bold response.\n", + "The hemodynamic response function might look something like this:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np \n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def hrf(t):\n", + " return t ** 8.6 * np.exp(-t / 0.547)\n", + "\n", + "hrf_times = np.arange(0, 20, 0.1)\n", + "hrf_signal = hrf(hrf_times)\n", + "plt.plot(hrf_times, hrf_signal)\n", + "plt.xlabel('time')\n", + "plt.ylabel('BOLD signal')\n", + "_ = plt.title('HRF')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the design often we want to include variables, that indicate presence or absence of a stimuli.\n", + "Let's say we had the 3 stimuli during the timecourse" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "n_time_points = 40\n", + "\n", + "times = np.arange(0, n_time_points) \n", + "\n", + "neural_signal = np.zeros(n_time_points)\n", + "neural_signal[4:6] = 1 # A 3 second event\n", + "neural_signal[9:11] = 1\n", + "neural_signal[22:24] = 1\n", + "\n", + "plt.plot(times, neural_signal)\n", + "plt.xlabel('time (seconds)')\n", + "plt.ylabel('neural signal')\n", + "plt.ylim(0, 3.2)\n", + "_ = plt.title('Neural model for three impulses')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we have to convolve signal with our hrf function" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "hrf_times = np.arange(20)\n", + "hrf_signal = hrf(hrf_times)\n", + "bold_signal = np.convolve(neural_signal, hrf_signal)\n", + "\n", + "tailed_respose_times = np.arange(n_time_points + hrf_times.shape[0] - 1)\n", + "plt.plot(tailed_respose_times, bold_signal)\n", + "plt.xlabel('time (seconds)')\n", + "plt.ylabel('bold signal')\n", + "_ = plt.title('Convolved signals')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After that we can fit our fMRI data to the design Matrix and use GLM to for hypotesis testing.\n", + "We can evaluate whether a given factor $i$ has a considerable contribution by its coefficient ${\\beta}_{i}$.\n", + "With t-test we can evaluate whether ${\\beta}_{i}$ > 0. We can also test hypothesis of the form ${\\beta}_{i}$ > ${\\beta}_{j}$.\n", + "\n", + "The general form of the hypothesis tests which forms a **contrast** is:\n", + "$$\\sum \\limits _{i=1} ^{P} c_{i}{\\beta}_{i} > 0 $$\n", + "\n", + "Typical values for $c$ are 1 and -1.\n", + "Typically contrasts are express as:$ [c_{1}, c_{2}, ..., c_{N}]$.\n", + "\n", + "For example the contrast [1, 0] tests ${\\beta}_{1}$ > 0.\n", + "\n", + "This contrasts form a t-statistics (Recall that coefficient/std(coefficient) in OLS regression follow t-distribution with n-p-1 df).\n", + "\n", + "We can combine several contrasts and form F-statics. In the contexts of fMRI the F-tests help us answer questions like \"Is effect A or effect B or effect C, or any combination of them, significantly non-zero?\".\n", + "\n", + "Recall that F test is used for comparison between reduced model RF and full model FM:\n", + "$$ F = \\frac{(SSE(RM)-SSR(FM)) /(p+1-k))}{SSE(FM)/(n-p-1)} $$\n", + "\n", + "where the reduced model have k distinct parameters\n", + "\n", + "\n", + "Combining the test results from all voxels we get statistical map of brain activity.\n", + "Now that the theory out of our way we can see how it is done in Nipype.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1st Leval Analysis in Nipype" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " We will use the preprocessed files we got and run 1st-level analysis (individual analysis) for each subject. We will perform the following steps:\n", + "\n", + "1. Extract onset times of stimuli from TVA file\n", + "2. Specify the model (TR, high pass filter, onset times, etc.)\n", + "3. Specify contrasts to compute\n", + "4. Estimate contrasts" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:02,695 nipype.utils WARNING:\n", + "\t A newer version (1.5.1) of nipy/nipype is available. You are using 1.5.0-rc1.post-dev\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import os\n", + "\n", + "from nilearn import plotting\n", + "%matplotlib inline\n", + "\n", + "\n", + "from nipype.interfaces.spm import Level1Design, EstimateModel, EstimateContrast\n", + "from nipype.algorithms.modelgen import SpecifySPMModel\n", + "from nipype.interfaces.utility import Function, IdentityInterface\n", + "from nipype.interfaces.io import SelectFiles, DataSink\n", + "from nipype import Workflow, Node\n", + "from utils import list_files" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# specify paths\n", + "experiment_dir = '/output'\n", + "output_dir = 'datasink'\n", + "working_dir = 'workingdir'\n", + "\n", + "# list of subject identifiers\n", + "subject_list = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10']\n", + "# Repetition time(TR) of functional images\n", + "TR = 2.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare design matrix\n", + "Let's take a look how the stimuli onset and duration look like.This information is store in a ``tsv`` file. This file will help us build the design matrix.\n", + "\n", + "The three different conditions in the **fingerfootlips** task are:\n", + "- **finger**\n", + "- **foot**\n", + "- **lips**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
onsetdurationweighttrial_type
01015.01Finger
14015.01Foot
27015.01Lips
310015.01Finger
413015.01Foot
\n", + "
" + ], + "text/plain": [ + " onset duration weight trial_type\n", + "0 10 15.0 1 Finger\n", + "1 40 15.0 1 Foot\n", + "2 70 15.0 1 Lips\n", + "3 100 15.0 1 Finger\n", + "4 130 15.0 1 Foot" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trialinfo = pd.read_table('/data/ds000114/task-fingerfootlips_events.tsv')\n", + "trialinfo.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def subjectinfo(subject_id):\n", + " import pandas as pd\n", + " from nipype.interfaces.base import Bunch\n", + "\n", + " \n", + " trialinfo = pd.read_table('/data/ds000114/task-fingerfootlips_events.tsv')\n", + " trialinfo.head()\n", + " conditions = []\n", + " onsets = []\n", + " durations = []\n", + "\n", + " for group in trialinfo.groupby('trial_type'):\n", + " conditions.append(group[0])\n", + " onsets.append(list(group[1].onset - 10)) # subtracting 10s due to removing of 4 dummy scans\n", + " durations.append(group[1].duration.tolist())\n", + "\n", + " subject_info = [Bunch(conditions=conditions,\n", + " onsets=onsets,\n", + " durations=durations\n", + " )]\n", + "\n", + " return subject_info # this output will later be returned to infosource\n", + "\n", + "# Get Subject Info - get subject specific condition information\n", + "getsubjectinfo = Node(Function(input_names=['subject_id'],\n", + " output_names=['subject_info'],\n", + " function=subjectinfo),\n", + " name='getsubjectinfo')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initiate Nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# SpecifyModel - Generates SPM-specific Model\n", + "#Setup\n", + "#https://nipype.readthedocs.io/en/latest/api/generated/nipype.algorithms.modelgen.html#specifymodel\n", + "modelspec = Node(SpecifySPMModel(concatenate_runs=False,\n", + " input_units='secs',\n", + " output_units='secs',\n", + " time_repetition=TR,\n", + " high_pass_filter_cutoff=128),\n", + " name=\"modelspec\")\n", + "\n", + "# Level1Design - Generates an SPM design matrix\n", + "#https://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=59\n", + "#hrf- Name of basis function(canonical)\n", + "#'derivs': [1, 0]-Time derivatives : Time and Dispersion\n", + "\n", + "#model_serial_correlations-serial correlations using an autoregressive estimator (order 1)\n", + "\n", + "level1design = Node(Level1Design(bases={'hrf': {'derivs': [1, 0]}},\n", + " timing_units='secs',\n", + " interscan_interval=TR,\n", + " model_serial_correlations='AR(1)'),\n", + " name=\"level1design\")\n", + "\n", + "# EstimateModel - estimate the parameters of the model\n", + "#https://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=69\n", + "\n", + "level1estimate = Node(EstimateModel(estimation_method={'Classical': 1}),\n", + " name=\"level1estimate\")\n", + "\n", + "# EstimateContrast - estimates contrasts\n", + "level1conest = Node(EstimateContrast(), name=\"level1conest\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify contrasts\n", + "We are gona perform several T tests and one F test. Recall the general form of the hypothesis are\n", + "\n", + "$$\\sum \\limits _{i=1} ^{N} c_{i}{\\beta}_{i} > 0 $$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Condition names\n", + "condition_names = ['Finger', 'Foot', 'Lips']\n", + "\n", + "# Contrasts\n", + "# contrast = [, , , <[c1, c2, c3]>]\n", + "cont01 = ['average', 'T', condition_names, [1/3., 1/3., 1/3.]]\n", + "cont02 = ['Finger', 'T', condition_names, [1, 0, 0]]\n", + "cont03 = ['Foot', 'T', condition_names, [0, 1, 0]]\n", + "cont04 = ['Lips', 'T', condition_names, [0, 0, 1]]\n", + "cont05 = ['Foot > others', 'T', condition_names, [-0.5, 1, -0.5]]\n", + "cont06 = ['activation', 'F', [cont02, cont03, cont04]]\n", + "\n", + "contrast_list = [cont01, cont02, cont03, cont04, cont05, cont06]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify input & output stream\n", + "\n", + "Specify where the input data can be found & where and how to save the output data." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#Infosource - a function free node to iterate over the list of subject names\n", + "infosource = Node(IdentityInterface(fields=['subject_id',\n", + " 'contrasts'],\n", + " contrasts=contrast_list),\n", + " name=\"infosource\")\n", + "infosource.iterables = [('subject_id', subject_list)]\n", + "\n", + "# SelectFiles - to grab the data (alternativ to DataGrabber)\n", + "templates = {\n", + " 'func': 'datasink/preproc/sub-{subject_id}/task-{task_id}/fwhm-5_ssub-{subject_id}_ses-test_task-{task_id}_bold.nii',\n", + " 'mc_param': 'datasink/preproc/sub-{subject_id}/task-{task_id}/sub-{subject_id}_ses-test_task-{task_id}_bold.par',\n", + " 'outliers': 'datasink/preproc/sub-{subject_id}/task-{task_id}/art.sub-{subject_id}_ses-test_task-{task_id}_bold_outliers.txt'\n", + " }\n", + "selectfiles = Node(SelectFiles(templates,\n", + " base_directory=experiment_dir,\n", + " sort_filelist=True),\n", + " name=\"selectfiles\")\n", + "selectfiles.inputs.task_id = 'fingerfootlips'\n", + "\n", + "# Datasink - creates output folder for important outputs\n", + "datasink = Node(DataSink(base_directory=experiment_dir,\n", + " container=output_dir),\n", + " name=\"datasink\")\n", + "\n", + "# Use the following DataSink output substitutions\n", + "substitutions = [('_subject_id_', 'sub-')]\n", + "datasink.inputs.substitutions = substitutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify Workflow\n", + "\n", + "Create a workflow and **connect** the interface nodes and the I/O stream to each other." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Initiation of the 1st-level analysis workflow\n", + "l1analysis = Workflow(name='l1analysis')\n", + "l1analysis.base_dir = f'{experiment_dir}/{working_dir}'\n", + "\n", + "# Connect up the 1st-level analysis components\n", + "l1analysis.connect([(infosource, selectfiles, [('subject_id', 'subject_id')]),\n", + " (infosource, getsubjectinfo, [('subject_id',\n", + " 'subject_id')]),\n", + " (getsubjectinfo, modelspec, [('subject_info',\n", + " 'subject_info')]),\n", + " (infosource, level1conest, [('contrasts', 'contrasts')]),\n", + " (selectfiles, modelspec, [('func', 'functional_runs')]),\n", + " (selectfiles, modelspec, [('mc_param', 'realignment_parameters'),\n", + " ('outliers', 'outlier_files')]),\n", + " (modelspec, level1design, [('session_info',\n", + " 'session_info')]),\n", + " (level1design, level1estimate, [('spm_mat_file',\n", + " 'spm_mat_file')]),\n", + " (level1estimate, level1conest, [('spm_mat_file',\n", + " 'spm_mat_file'),\n", + " ('beta_images',\n", + " 'beta_images'),\n", + " ('residual_image',\n", + " 'residual_image')]),\n", + " (level1conest, datasink, [('spm_mat_file', '1stLevel.@spm_mat'),\n", + " ('spmT_images', '1stLevel.@T'),\n", + " ('con_images', '1stLevel.@con'),\n", + " ('spmF_images', '1stLevel.@F'),\n", + " ('ess_images', '1stLevel.@ess'),\n", + " ]),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize the workflow" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:03,250 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/l1analysis/graph.png (graph2use=colored, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnsAAAKZCAIAAABP2npJAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1wT5x8H8CfsnbACBAIylamILAUFRNEqbqRaxYWitmrHz9pqVbRqtVut1q3F2qrUSZ0gojgBBxI2BiFASAKSBAIZJPz+uDZFQEAgOcb3/eLFKzlufC/kySd399wdoampCQEAAABAwVTwLgAAAAAYECBxAQAAAGWAxAUAAACUQQ3vAgAAuCkrK3v48CHeVYA+TCqVmpmZBQcH411I3wCJC8AAlZeXFxwcXFlZiXchoM+rq6vT1dXFu4o+ABIXgIGooKAgJCTEwsLiypUrenp6eJcD+h6JRLJ69eqHDx82NDRIpVK8y+kb4DguAANOQUFBUFCQubn5kSNHIG5BF2Bxm5aW9sknn+BdS18C27gADCwQt6CbJBLJmjVr0tLSjh49Wltbi3c5fQls4wIwgEDcgm7C4vbx48dHjx4dNmwY3uX0MbCNC8AAEhQUxGQymUyml5cX3rWAvsrExOTIkSMQt10AiQvAAMLn8+fMmePn54d3IaCv+vPPP1VUVDw9PfEupE+CxAVgACEQCG5ubhMmTMC7ENBXpaamwhllXQbHcQEAAABlgMQFAAAAlAESFwAAAFAGSFwAAABAGSBxAQAAAGWAxAUAAACUARIXAAAAUAZIXABAzxCJRD///HNoaKiLi8vgwYMHDx6Md0U4y8rKmj9/fo/PdvC/enzOCKH58+dnZWUpYs4AQeICAFqbO3fu3Llz33WqPXv2/PrrrzNnznzy5MnRo0cVUVgfEh8fv3jx4gULFnR/Vi3+Hfn5+R2O02VRUVGLFi06e/Zs92cFWoNrTgEAWpLJZF2Y6urVqwihuXPnamtrBwQEtBkMA8Tdu3c3btz4448/hoaGdn4qbLO19evWmX9H63HeNrf2jRs3TigUrl271tzcfPTo0e80LegQJC4AoKXTp093YSrs4n9EIrGny+ljJBLJpk2bPD0933vvvR6ZYWf+HV37l7UpPDz8999/37x5c2JiopoaZERPgr3KAICe0bUt4/7nxo0bTCYzPDwc70K6bvLkyRUVFTdu3MC7kP4Gvr8AAN4g75Ij3yEpH5KSkrJ169ZHjx5pa2uPHDnyq6++IpFILcbBHixduvR///sfQqiqqmrPnj0pKSnV1dXGxsbBwcGrVq0yMTHBRq6trd27d++tW7fYbLa2tradnZ2np+fEiRM9PDywEdqfvJ1SWw9JTEz89ttvHz9+zOfz5SOIRKLffvvt6tWrr169kkqllpaWvr6+06dPl9+Krrq6eu/evcnJydXV1UZGRkFBQWvWrJEX0Kbk5GSEkJubW2de0tZDsAezZs3avn17m2O21sm5tehs9eOPP06aNAkhFBwcXFFR0Xxyd3d3bEWwEUBPgW1cAMAbWn+yy4f88MMP//vf/+7evTt+/PiEhIRdu3a1Hic/Pz8/P18et7Nmzbp9+/a3336blpa2a9eupKSkiIiIqqoqbOR169b99ttvCxYsSEtLu3///jfffMNgMCIiIrC/djh5O6W2HhIbG7tkyZLU1NTDhw9jQwQCwdy5cw8cOPDBBx8kJSU9fvx469at6enpkZGRzQtITEzcsWNHenr6Tz/9dO/evcjISCyz3yYnJwchRKFQOlPV215ALG7bHLO1Ts4tPz//xIkTCCFTU1MajSZP05UrVwYHBzefiaWlpXxFQA+CxAUAdNbs2bPt7e319fWXLl2KELp371774+/evZvJZK5du9bPz09XV9ff3/9///tfRUXF3r17sREeP36MEDIzM9PW1lZXV7e1td20aVPnJ38ny5cv9/T01NLSGj16NJYue/fupdFoH3/8cUREhImJiY6Ojo+Pz/fffy+fZO/evRUVFZ9++mlAQICOjs6IESPWr19fVlbWfk9sFouFEDIwMOhCkYrm7+8/ZMgQDodz5coV+cC4uLioqKjmo2HFYysCehAkLgCgs1xdXbEHZDIZIcThcNof//bt2wghPz8/+ZCRI0fKhyOEwsLCEEKrV68OCgrasGHDtWvXDA0N5RtbHU7+TrA9pc1hxylbdCd2cXGRF4DtH27eZdfb21s+/G2EQiFCSF1dvQtFKsHChQsRQtjGLkLo0aNHTU1N2AsrhxWPrQjoQZC4AIDO0tXVxR5gn8hNTU3tj//69WuEkKGhoXwI9ri6uhp7umPHjr1794aFhQkEgr/++uvjjz8eP358bm5uJyd/J9ra2i2GsNlshFA7B2WxBQUEBMgvOuHr64sQYjAY7SxIS0sLISSRSLpQpBJMnjzZ1NQ0Nzf30aNHCKHffvutxQYu+rd4bEVAD4LEBQAoirGxMUKopqZGPgR7jA3HjB8/fs+ePY8fPz516lRAQEBFRcWXX37Z+ckJBAJCqLGxEXtaW1vb+fKwrG1nSx0bIT09Pf9Nz58/b2e2ZmZmCKEWx3q7U2fPUldXnzdvHkLo+PHjDAbj+fPnU6ZMaTEOVjy2IqAHQeICABQlJCQEIfTw4UP5kAcPHsiHI4QGDx6MncWroqIyYsSIn3/+GSH08uXLTk6O/g1FbGsVISTfPu6M8ePHI4SSkpKaD3z+/Lm86xa2wxk72CyXkZEh71rVJhcXF4QQ1vv3nerEtsIbGxsbGhqwjenuaGduc+bM0dbWvnPnzrZt2yIiIlpvy5aXlyOEnJ2du1kDaAESFwCgKKtWraJQKN9///2jR48EAsGjR49++OEHCoXy0UcfycfZsGFDYWGhWCyuqqrCehEHBAR0fvJRo0YhhI4ePVpbW0un09/p8oSrVq1ydHTcvXv32bNnq6qq6uvr79279/nnn3/66afyEWxsbLZs2XLjxg0ulysQCG7fvv3FF1989tln7cw2ODgYIUSj0ZoP7Eyd2Nk7L168uH37tqenZ+dXpE3tzI1IJE6bNq2pqSk1NbXNa0Nil1Zu/s0G9AhCh0diAAD9hr6+/pdffjlr1qx2xml+1ibWh+hdh6BmZ6dUVVXJz2fFTqhdvXq1/NDp06dPz549m5aWxmKxtLW1LS0tJ06cuGDBAvkx1/YnRwjV1NRs3779/v37DQ0N/v7+mzZtCgoK6kxhmPr6+sOHD1+7dq2srExXV9fNzW3FihUjRoyQj8Dn8/fv35+YmFhZWUkikTw8PGJiYuRn67ZJIpGEhoZaWlr+8ccfna8TIUSj0TZs2FBSUjJ48OBdu3YNGjSoCy9++3OTKykpmTBhwsSJE3/88cfWqxAZGVlZWZmUlNS6/9eGDRsqKyvlvbVTU1Ojo6N5PF7v7Jvd20DiAjCAdCZxQfelpKQsX778xx9/7KkLPfY4mUw2evToX375pfW3h4SEhLVr1x44cED+naA5SNzugL3KAADQw4KCgrZs2bJ58+YWB4l7j5SUFAsLi9Zxm5iYGBsbGxsb22bcgm6CxAUAgJ4XGRl59OjR3377De9C3jB48ODnz5/z+fxffvllxYoVrUeIi4s7fvz4+++/r/zaBgK4rjIAACiEh4fHyZMn8a6ipcjISBKJNG/evDY7RvXCgvsTSFwAABgoBvJNi3sD2KsMAAAAKAMkLgAAAKAMkLgAAACAMkDiAgAAAMoAiQsAAAAoAyQuAAAAoAyQuAAAAIAyQOICAAAAygCJCwAAoIuEQiHeJfQlkLgAAAC6gk6nb926deTIkfr6+njX0jdA4gIAAHhnr169WrhwoZ2d3bVr1wgEAt7l9A2QuAAAAN7Nq1evoqKibG1tb9y4AXfG7TxIXAAAAO9AKBRC3HYN3DsIgIElKytLT09PEXNubGwUiUS6urqKmDnAyGQyFRU8t5RKS0tfvHgxfPhwiNsuIDQ1NeFdAwBASZydnfPy8vCuAvRtHh4eqampELddAHuVARhAcnNzm3pIY2Njamrq6tWrTU1NEUIuLi6bN29++fJlT80fX0uWLAkLC8O7ijY8fPgwMDCQQCBMnz49JycHlxoyMzMhbrsGEhcA8A6kUum9e/fWrFlDoVACAwOTkpJWrlxZWFiYnZ0dGxtrZ2eHd4H9nJ+f3927d2/evPnq1Ss3N7fZs2cXFxfjXRToLEhcAEDHZDIZFrSWlpZY0K5YsaKgoAALWgcHB7wLHFhCQ0MzMjJOnz799OnTIUOGxMTEsNlsvIsCHYPEBQC8VeugXb58eX5+Pha0jo6OeBc4cKmoqEREROTm5u7du/fy5cv29vZffPFFbW0t3nWB9kDiAgBakgetlZUVFrQxMTF5eXlY0Do5OeFdIPiHurr6smXLCgoKPv3003379g0ZMuTQoUONjY141wXaBokLAPiHPGipVCoWtMuWLcvNzcWCdvDgwXgXCNqmr6+/ZcuWoqKiGTNmrFq1ytPT8+bNm3gXBdoAiQsAQPK9xFjQLl26NDs7Gxs4ZMgQvKsDnWJmZrZ3714ajebs7BwWFjZu3DgajYZ3UeANkLgADFzyfk9ubm5xcXGTJ09OTU3FBrq4uOBdHegKR0fHs2fPJicnczgcT0/PmJgYDoeDd1HgH5C4AAw48i1aNze33377bdKkSampqXQ6fffu3QEBAXhXB3pAcHDw06dPjx49evny5cGDB+/atUssFuNdFIDEBWDAkB+OdXNzO3HixHvvvQdB24+pqKhERUUVFRWtXr06NjbW3d09Pj4e76IGOkhcAPo5+eFYNze348ePT5gwITU1tbi4GAtauM9a/6arqxsbG1tQUODr6xsZGRkaGvrixQu8ixq4IHEB6J+woHV2dnZzczt27FhYWFhqauqrV68gaAcgKpUaFxeXkpLC5XK9vLxWrVrF5XLxLmoggsQFoF+R93tyc3M7evTo+PHjU1NTS0pKIGjB6NGj09LSDh06dPbsWWdn599//70J7mSjXJC4APQH2F7iESNGuLm57du3LzAwEIIWtKaiorJo0aL8/PzZs2cvXLgwKCgIziBSJkhcAPow+V5iOzu7bdu2ubi4XL58mclkHjx4MCAgAN8bqYJei0Qi7d69Oz09XSwWe3p6rlmzBi4PqRzQIAHoe+Qbr7a2tl9//bWdnR0WtHFxceHh4WpqangXCPoAT0/P+/fvHz169I8//hgyZEhcXBzeFfV/kLgA9BmlpaXyoN26dSsELegm7Ayi/Pz8WbNmLVq0aOzYsXl5eXgX1Z9B4gLQ2zEYDCxoBw0atGXLFjs7u0uXLlVWVmJBq66ujneBoG8zMjLavXt3SkoKh8Px8PBYs2aNQCDAu6j+CRIXgF6qrKwMC1obGxt50LJYLAhaoAiBgYFPnjz55ptvjh07NnTo0MTERLwr6ocgcQHoXcrLy7Ggtba2jo2NhS1aoDTq6uqfffZZbm7u0KFDw8LClixZAqft9ixIXAB6haqqqri4uHHjxllbW69fv55CoTTfotXQ0MC7QDBQWFlZnTt37tKlSzdu3HB2dj537hzeFfUfkLgA4Km6uhrLVAsLixUrVmhpaR0/fpzD4Zw9exaCFuAoPDycRqNNmTIlIiIiPDy8oqIC74r6A0hcAHDw+vVrLGjNzc2XL1+OEDp69CibzU5ISIiKitLR0cG7QAAQiUQ6ePDgtWvXsrKy3NzcDh06hHdFfR4kLgDK037Q6urq4l0gAC2FhYXl5OQsW7ZsxYoV7733HoPBwLuiPgwSFwCFq6mpkQdtTEwMQujIkSMsFgsLWj09PbwLBKA9Ojo6O3fuvHv3bnFxsZub2+7du2UyGd5F9UmQuAAoCpfLbR208i1afX19vAsE4B2MGjXq2bNnn3zyydq1a8eMGZOfn493RX0PJC4APYzH42FBa2ZmtmzZMoTQ4cOH5Vu0ELSg79LS0oqNjX3w4AGfzx8+fPi+ffvg7kPvBC4LB0DPqK+vv3XrVnx8/Llz50QiUXBw8OHDh6dOnUokEvEuDYCeNGLEiIyMjK+//vrjjz++cuXKsWPHzM3N8S6qb4BtXAC6paGhAdt4JZPJ06dPp9PpO3bsYDKZiYmJUVFRELegX1JXV9+6dev9+/eLioo8PDwuXbqEd0V9AyQuAF3ROmi3b99eUVFx7969NWvWmJqa4l0gAArn4+Pz5MmT6dOnT5s2LSoqqq6uDu+KejvYqwzAOxAKhYmJifHx8RcuXGhoaPDz89u2bdv7779vZmaGd2kA4EBfX//gwYNhYWHLli3z8PA4efLkqFGj8C6q94JtXAA6JhQK5Vu006ZNo9Pp27ZtKysrw7ZoIW7BADdjxozs7GwXF5egoKAvvvhCIpHgXVEvBdu4ALyVSCS6efNmfHz8pUuX6urq/P39v/7669mzZ1tYWOBdGgC9i5mZWUJCwuHDhz/55JOUlJSTJ086OjriXVSvQ4C+3QC00DpoIyIiIiIiKBQK3qUBRaHT6ZGRkUKhEHvKYrEkEomVlRX2VE1N7dChQ97e3vgV2Gfk5OTMmzevqKjo+++/x86OA3KQuAD8QyqVPnz4MD4+/o8//qiqqvLy8po/fz4E7QBRUVFhZWXVzudhRkaGl5eXMkvqu0Qi0YYNG3766afp06cfPnzY0NAQ74p6C0hcMNDJg/bPP//kcDguLi4RERFRUVF2dnZ4lwaUavTo0ffv32/z+oW2trZ0Ol35JfVpycnJUVFRampqZ86c8fX1xbucXgF6ToEBSiqVYv2eKBRKYGBgUlLSypUrCwsLs7OzsfvA410gULb58+e3OVxDQ2PBggVKLqYfCAkJef78uaura0BAQGxsLFyKGcE2LhhoZDLZgwcP4uPjz5w5w2KxsC3aDz74AHp5gJqaGjMzszb72ebn5zs5OSm/pH6gqalpz549a9eunTBhwokTJ4yMjPCuCE+QuGBAkAft2bNnKysrsaCdO3cufIyC5sLDw69fv97Y2CgfQiAQ3N3dMzMzcayqH0hLS4uMjJRKpadPnx45ciTe5eAG9iqDvqfzZ/vJZDJs17GVlRW26zgmJiYvLw/bdQxxC1r44IMPpFJp8yFqamqwS7n7fHx80tPT3dzcgoKC9u7di3c5uIFtXNCXyGSy7du3b9++/cWLF+3kpXyL9q+//qqoqMC2aN9///0hQ4Yos1rQ59TX15uYmDQ0NMiHEAiE0tJS+WlCoDuampp27NixefPm999//9ChQzo6OnhXpGyQuKDPqKmp+eCDD27cuEEgEDZu3Lh58+bW42RnZ8fHx588eZJOp9vZ2WG9jl1cXJRfLeijPvjgg/j4eGw/ioqKir+//7179/Auql9JSUmJjIw0MjI6f/68s7Mz3uUoFexVBn3D8+fPhw4dmpSUJJPJpFJpXFxc879ie4kdHBzc3Nzi4uImT56cmpr68uXLnTt3QtyCdzJ37lz5YQsCgRAVFYVvPf1PUFBQRkaGgYGBn5/fhQsX8C5HqWAbF/QBJ0+eXLp0qVQqbd6lJSsri0AgxMfHnzp1qqioaNCgQVOmTImIiAgICMCxVNDXSSQSU1NTHo+HEFJVVWWxWMbGxngX1Q8JhcKVK1eeOHEC21+lojIgNv8gcUGvJhKJ1q5du3fvXgLhjfeqhoaGnp7e69ev7e3tZ8+eHRER4enpiWOdoD9ZsWLFsWPHpFJpWFjYlStX8C6nPzt48ODq1asnTpx48uRJfX19vMtROEhc0HuVlZVNmzYtMzOz+aatnImJyfXr1+HCe6DH3b17d8yYMQQC4ffff587dy7e5fRzDx48mDlzpqmp6aVLl2xtbfEuR7Hg3kG9UW1tLZYxXC63qalJKpXy+XzsT01NTVwut82pZDIZtiusTVpaWtra2m3+SVtbW0tLC3usqamJdSDU0dHR1NRECBkYGKiqqnZjbbro9u3bs2bNkr8UrVVVVamrqyu5KtB3SSSSuro6oVDY0NAgEAjEYjH6t4nJx8EaUVNTk6GhYV1dnVQqjY+P19fXV1N746OSRCIRCAQ1NTV9fX2sZenq6mpoaCh7lfqFkSNHZmRkTJs2zdvb++zZsyEhIXhXpECwjdszuFwun8/n8/k8Hq+hoaGmpkYsFgsEgrq6OrFYzOVyRSJRfX19bW2tRCLhcmvkTxsbG7ExEUL19Q0ikQjvVXkrQ0MSQgj7lEEIGRjoq6trEIlELS0tbW0dAwMDDQ0NAwMDLL+JRKKGhoa+vr6Ojo62tjaRSDQ0NDQwMMBGa39BTU1N33777fr16xFC7VwZTkNDY+3atdu2bevRtQR9g1Ao5HA4lZWV1dXVPB6P2wyPx+Nya7CBQqGQx+NJpVIu961fRnuQgYG+qqqqoaGhpqYGkUgikUjYbzkikUgkEo2MjCwsLMhk8tu+BA9AQqEwOjr6zJkz27ZtW7duHd7lKAokbtvq6+urq6urq6urqqqqqqqwVs3n82tqang8Hp/P4/P5PB6Xz6/l8/ltNmZNTQ0dHS09PR0NDXUSSU9DQ11XV0tPT1tdXc3QUP/fpzrq6mpqaqr6+joIIU1NdR0dLYSQrq62hoY6QsjAQFdVVYVAIJBIevI5y//amr6+jppa29ujfL5AKm07vXi8OnmwNTSIhEIxQqi2tr6xUYoQ4nJrm5qapFIZny9ACInFEoFAiE0lFktqa+uxSXg8wZtP6ySSRj6/rvXitLW1sOglEonYR5L8KZFI1NXVPXLkSEZGxlv+M2+wsbF59epVZ8YEfQ6PxysrKyspKWEwGEwmk8PhMJlMDofN4bCZzEo+v1Y+poqKComk/++PHpGoSyLpkUj6RKKulpYmiaSnqqpKJOqqq6vp6elgrUxHR0tTUx0hhLXB5sslEnWb9+Jpamrict94G0ul0n/bQqNA0CAUihsaRAJBA/b+b2yUcrm1IpGEy63l8QRcbi2Xi/2u43JrebxarFlh9PR0zc3NyWSyqSnZ3NzczMzMzMzM2tra2trayspqoF0Qsamp6euvv46NjV2+fPmePXta7FfoHwZi4nK5XCaTyWazy8vL2Ww2FqhVVVXV1VXV/xIK/9vWVFFRMTYmkUh6Bga6hob6RKKugYGugYEukaiH/SYSdUkkffkQHR1NEqn/dwHopIYGUX29kMer43LreLw6Pl/A5wvkD2pqanm8Oj6/ns+v5/HqeLw6Duc1FvmdoaqqmpWV5ejo2C8b5wDB5XILCwuLioqKiorKysoYjNLS0hIGo0yeqUSivqWlqampobm5IZlsaGpqaG5ubGZmZGpKMjc3NjEhYV9Y+4q6uobXr3lMZjWbXcPh1DCZ1RxODYfDxYYwmVWvX//zDV5XV8fa2ppKpVKp1lQq1c7OztHR0dHRsX/3nT537lxUVNSYMWPOnDnT//pS9c/E5XA4DAajvLycxWJVVFT8G66sioqKyspKeZqqqamSycYmJiRjYwMTE6KJCdHIyMDYmNjix8jIAN/VGWgaGkTV1Tzsp6qK1+wxl8Wqef2aX1NTW1lZVV//z83DCQQCmWxKJpMtLS3NzMwtLCywzQVLS0srKytLS0s4wNZLSCSSvLy8/Pz8wsLCwsLCgoL8goICDqcKIaSurjZoEIVKNaNSyTY25lZWZCsrsrW1mbW1ed8K1O6rrxeWlFQyGKyyMnZpKYvBYDEYbAaDXVxcLhKJEUJGRoaOjo5OToOdnJwcHR2dnJxcXFywXhf9Q1pa2pQpU8hk8t9//21tbY13OT2pDyeuWCwuKyurqKhgMpl0Op1Op1dUlDOZFYWFRfJvx1pamoaGBhSKiYWFMYViYmFhgv02NNSnUExsbCxUVQfESWD9klAofv2az2RWVVRUYb9ravhMZnVFRTWTWVVaypTvvjM0JNnZ2VlYUCgUip2dnZ2dnYWFBYVCsbW1JRAI+K5F/1ZTU5Odnf3kyZOcnJzs7KynT581NAgRQhYWpq6utnZ2FDs7Szs7iouL7eDBNm87IALkampqs7PpOTnFdHo5nV5BpzNzcugNDUI1NTVra6qLi6uXl5erq6uLi4uLi0uffm+XlZVNnjyZzWYnJCT0p/MR+kbi1tTUyPc7FRYWFhUVFhcXs1hs7K/a2lo2NhZUKplKJVtbm/372MzKiowdFgUDkFQqY7Nf/7uJwCopqSwtxbYVWCxWNTaOtrbWoEGDHBwcHBwcHR0dHRwcHBwcrK2tcemb3T9UV1c//sej9PT0169rEEJWVmbu7vYeHvYeHg7u7g6DB1u/rSMCeFcSSePLl+UvXhS9eFGYlUXPynpZXFyOECISDYYPH+7n5+/r6+vr62tubo53pe+strY2MjIyNTX1jz/+CA8Px7ucntHrElcoFObk5OTl5WH7nYqKCouKiqqrXyOE1NXVbG0tHRysHB2t7OwsbWzMqVQzKtXM1JSEd9WgLxEKxaWlldjOuuLiiqKisqKissJCRk0NHyGkoaFha2vj6Ojk6OiERbGbm5uFhQXeVfdSTU1NWVlZqampWMoWFBQihJycbHx9Xby9XTw8HDw8HAwN+9vRuN6MzxdkZb3MyipKS8t5/DgnL++VTCYbNMjaz2+kr6/vqFGjhg8f3le+U0okkpiYmLi4uF9//XXp0qV4l9MDcE7cxsbG0tLS7OzsnJyc7OzsJ0/S8/MLpVKpuroalWpuZ0eB/U5AaWpqaun08n/315XT6czsbDqTyUEIkUhEe3t7+V47d3d3MzMzvOvFU0VFxf3795OSkq5c+bu8vEJfX9fDw8HLa3BAwNCgIC/4Etx71NbWZ2YWPnmSd//+i5SUZxzOaz09XT8/v9DQcaGhocOHD+/9O5+3/Gvjxo1419Jdyk7curq6p0+fpqenP3nyJDublpeXLxaLVVVVHRyobm52bm52rq62bm72jo5UCFfQG3A43KysouzsYhrtJY1Gz84u5vFqEUKWlhRXV9ehQ4d5e3v7+PjY2NjgXanCiUSipKSkS5cuJSUlFhe/0tHRDgwcNnasV0jICE9PpwFyXdy+jkZ7eetWxq1bGXfuPOPz6ywtLUJDx4eHh0+cOLE33zvv+PHjy5Yti4mJ2bNnT59+pyk8cSUSCY1GS0tLS0tLS09Py8nJlUqlZmbGXl5D3N3t3NzsXV3tXFxssXPjAD+8s0QAACAASURBVOj9Sksrs7OLsRh+9qwwJ4culUrJZFMfHx9vbx8sgPvT+RsCgeDq1avnz5+/evVKbW2dt7fLhAl+ISEj/P3d4HBs39XYKE1Pz7l1K+PmzbQHD15oamqEhYXNmDFz8uTJJFJv3EVx8eLFOXPmTJw48Y8//pBfI6/PUUji1tfXP3jwIDk5+c6dlGfPnjU0CPX1db28hnh7O/v4uHh7u9jY9L3D+AC0SSBoePo0Pz09Ny0tJz09l04vQwjZ29uNHDkqJCQkODi4j27+SqXS69evHzt29Nq1a2KxZPRoz+nTx0yfPsbKiox3aaCHsdk1Fy/eOX/+zu3bGQgRQkPHLl68JDw8vLedVpeSkjJt2rThw4dfvHjRwKBPnrTZY4krFosfP36cnJycnHzr8eM0kUjk5GQTHDzcz8/N29vZ2XlQn94VAEAnVVVx09Nz09KyU1MzHzzIamgQ2tvbBgePxdK3T3QZLSkpOXbs2PHjx8rKyseMGT5vXtjUqaNNTHrjdg/oWVxu7d9/3//jj5s3bz42NjZasGBhdHS0k5MT3nX959mzZxMnTqRSqdevX++Le5K6m7hVVVUXL148f/7cnTt36usbbGwowcGeISEjQkJGWFqa9lSVAPRFQqH40SNacnJGcvKTtLRsiaTRxcU5PHzKrFmzvLy8emGPlUePHm3b9vW1a9fJZKMFCyYuWTLF0ZGKd1EABwwG69ixhGPHrjAYlUFBY9av3xAaGop3Uf8oKioKDQ01MDBITEzscx0Yu5i4TCbzwoUL5879defOXQ0N9QkT/N57b2RwsJe9vWWPlwhAP1BX13DvXmZSUtqFC3fp9DIbG+qMGbNmzpzp7+/fG3b/PHjwYOvWLTdu3Bw1auhnn82ZPDmgxdWGwQAkk8lu3Hj8889nbt58NGrUyE2bNo8fPx7vohBCqLS0NDQ0VEVFJSkpycrKCu9y3sG7JW5tbe2ff/558mTcgwcPdXS0Jk0aNXNm0HvvjdTVhTtgANBZT5/mnz9/+9y5lLy8VxSKRUTE7OjoaDc3N1yKKSgoWLXqo5s3E0eNGrp585Jx43xwKQP0Zg8fZm3deuz69Yf+/n6//LJv+PDheFeEWCzWuHHj+Hz+rVu37O3t8S6nszr75TonJ2fp0qUUisWaNattbPTPn9/J4Vw/ffrriIixAzZuCQQ/7AfvQrpLKBR/9dUBe/uZamoje2SN0tNzgoNX9khtzSn0BQ8OXpmenqOIObc2fPjgbduW5+aeptH+iImZfOXKeXd395Ej/f/444+33QxYERobG3ft2jV0qAeHw0hK2nvv3sFeErfKb1mnTyf6+i42NBzX5qKVXE93mo+C3sb+/u7Xrv308OERdXWRr6/v+vXrhUJhjy/lnZiZmaWkpJDJ5ODg4MLCQnyL6byOEzc9PX3KlHA3N7f792/t2LG8ouLv33+PnTp1tJZW7+rGpnxNTY86M1pgYExgYIyii+nOsjZvPrx9+4nFi8P5/OQbN3Z3s4YjRy6PH79mzZrIbs4HtVqdNl/wnnp5V6+ePW7c6sOHL3V/Vp3n6mq3adOSgoKzt279QqXqLVgQ5ejo8Msvv2A3S1eonJwcPz/f2NjNmzYtTks7Onast6KX2HmdbFk9JS7u6pw5G42Nic+fnxQKU8+d24ljPS2az7u+vRX6Nvbzc0tJ2b9nz6f79u319ByWnp6uiKV0npGR0Y0bNygUypgxY3Jzc/EtppPaS9ySkpI5c+b4+vpWVZVevPgtjXZq1aqIvnjBNny3RGUyWTu3Ve+at61R15Z15kwiQmjFihk6Olrjx/t25/Pl2rWHy5Z9c+DAumnTxnR+qu6sTutxuvbvnj49aN++tTExO69de/iu03YTgUAICRlx5sy2goL48HCfzz9f6+LiHB8fr7glXr9+3d/fT11d8vx53JdfLhggV5t52xvjxx//RAj98MMaGxtzTU31GTOClBz5cq2bz7u2aEW/jQkEwooVM2i0U9bWhqNHB54+fVoRS+k8Q0PDxMREOzu7sWPHFhQU4FtMZ7z1OO6xY8c++eRjc3OjXbtWvtOnZy+ENTNFtCLFzVmZy1VVHSmTybo/N7FY4uAwy9ra7N69Q+80YedXpzNjdufF8fePrqioKir6C8d+Q6WllV99dfD3369Pmzb1wIGDZHIPn/969erV6dOnv/9+6KFDX/baK88oomW9bZ46OmMaGkRi8b12/ulKaOldbj6tKeFtLJXKPv98788/nzl+/HhUVJSCltJJAoFg4sSJdDr9zp07vfyYbhvbuFKpdMWKFdHR0QsXTnzx4ve+HregQz21CX7u3G0GgzV3bliPzA0Xc+eGlZZWnjt3G8carK3N4+I2p6YezMp66uk57Pnz5z04cxqNFhExa968sBMnNvbauFWyhgYRQgj3vtk92HyU8DZWVVX54Yc169bNX7Jkyd27dxW3oM7Q1dVNSEiwtLQMDg6m0+n4FtO+lonb1NQ0d+6c33+PS0j4fvfuT3Fvk9nZ9Pfe+0RPL9jAICQsbE1OTnHrXgxsds2KFd9aWYVraARYWk5etuybyspq+V/lY2JTRUfvwJ7yeHWffPKznd0MLa1AY+PxI0cu/d//9qSl5TQfuflS2uk9UVpaOX36OiJxrJ5e8KRJn+bmvmp/qvYLRggJheKdO+M8PaN0dYO0tAKHDIlcvnzXo0e09teonZoZDNbUqWv19YPNzCbOm7e5upr3ttfniy/2YU8rK6tjYnZiRVpZhS9fvovFet3Gf6iZy5dTEUIjRji3s/ptDunk6rTWybnJR8N+Tp9OxMYZNGhai8m9vZ3lK4KvUaM80tKOOjpaBAcH9dQxKqlUOnfunOHDBx88+IVCzwZuv3GhTjSB1hTXapoPb/7TnXo6fAVa60zzQZ1rmEp7G2/fvnzy5FHz5n1QX1+v6GW1j0gk3rhxw8zMLDg4uLi4GN9i2tFyr/JPP/20bt3niYl7x4zxxKsmuZcvy0eMWKijo3nyZKyPj2tmZuG6db/cv/8CNdu9w2K99vVdLBSK4+I2jxzp8exZ/vz5sSoqKk+f/kYi/XPIuc09QtOmfX7p0t2ff/4kOnqKurpacXHFl1/+euFCiny01lO9bUhYmN/69Qs8PQenpWXPmxcrEomfPo0bNMiizak6LLi2tj4k5MP8/JIff/w4PDxAV1c7IyN35cpvc3NftVNb+xV+8EHYhg2LKBSTL7/c/+uv5xcunHT8+MZ2pqqsrPbxWSyVSk+ejPX2dsHWS1NT/fHjY2ZmRm/7fw0ZEpmfX1JZebX5OJ1/GTu/Ol2Y261b6aGhqywsTF69uiC/GvCRI5cvXbqbkPC9fDQms4pCmTxkiE1u7pm3raYyiUSSsWM/4nDqX7zI0tTU7ObcTp06tXDhguzsP52crHukvLdpv3F1oc3i0mraGdJhPR1+vLTWmebTyYapzLcxm13j4DBr8+Ytn332maKX1aHq6uqQkBCBQJCSktI7z9N9YxtXIBBs377tyy8X9Ia4RQjFxh7mcmt37fooJGSEnp72qFEe69cvbDHO5s2HS0oqd+xYMX68r56edmDgsJ9++ri4uOK77061P/Pbt58ghCwtTXV1tTU01AcPtvnll/91rc7ly6ePHu2pr68zdqz3zp0ra2pqY2OPvG3kDguOjT2ckZH79dcx0dFTzMyM9PS0g4KGnzq1tWu1YZYunebsPIhI1Pv88/kIoZs3H7c//qZNhxgMFvbKy9erpKRy8+bD7UxVXs5GCMk/NHuVsWO9hw51ZDKr5Bu4CKE9e8606FNtaGiAECov5yi7vrfQ1FQ/c2ZbaWnpiRMnuj+3P/44FR4eqOi4RR01ri60WVxaTTs6rKcLHy+daT6dbJjKfBuTyYbz5084dep3JSyrQ8bGxomJiZqamuPHj6+qqsK7nDa8kbhpaWnV1a9XrJiBVzUtJCamIYRCQkbIh4wc6d5inISEVITQxIn+8iGjR3vKh7dj5sxghFBExHpr66nR0TvOnr1lYkLsWs+IwMBh8sehoT6o3UjrsOC//rqNEGpx+NzT06k7vTaGDx+MPaBQTBBCTGYHe/D+/vs+evOVx9br77/vtTNVfb0IIaSh0UuvVfTJJ+8jhH766Z/elcnJGTJZU2joG2fFYMXX1+N8rmFzlpamU6eOvnbtavdn9eTJk+Bgr+7Pp0PtN64utFlcWk07OqynCx8vnWk+nWyYSn4bBwd7ZWa+kEgkyllc+8hkcmJiolAofO+992pra/Eup6U3EpfNZqupqZLJhnhV00JVFRchZGJClA9p/QWQza5BCFEok+XHPExMwhBCL1+Wtz/zY8e+Ondu58yZwXV19UePXo6M3ODoGPH8eVf6lxsb/1chdsF3DqfmbSN3WDCTWYUQMjfvyYt06+v/c+dLbIdqhxcaw+pv/spj64UV/zY6OpoIIbFYeddweCdz5oy3sDB5/rwgOTkDIbR7d8sNXPRv8To6veteYJaWJiwWq/vz4fF4RKJu9+fTofYbVxfaLC6tph0d1tOFj5fONJ9ONkwlv40NDfVlMlnviTcKhZKYmMhgMKZNmyYSifAu5w1vJK6Tk1Njo/Tp03y8qmkBezNVVf3XzQfL4OawoxevXyc2NT1q/iMQpHQ4/xkzgv7665uqqht37x4IC/MrLa1ctGib/K9Y1xKJ5J8GwOPVvW0+zf+EVWhq+tZvLR0WjI2AfYLgBfvW1fqVb//bmKUlGSHE5b7R8Dr/Miqahob6Rx/NQgj9+OOfdHr5w4dZ8+ZNaDFOTQ0fIdTbbsLx+HHO4MFDuj8fCoVSUlLZ/fl0RjuNqwtttre1ms6sQvsfL6212Xxa6GTDVPLbmE6v0NHRNjTsLZtqCCF7e/sbN248ffr0/fffl0qleJfznzcSd9iwYV5ewzduPNTjV2zomvHjfRFCt279d2UTrNtUc9h+pJSUJ80HpqY+9/ePlj/FvutJJI319ULsqyhCiEDwKytjI4RUVFQCA4edObMNIZSb+18nN+z7srwNP3v21u+nDx/S5I+TktLklbepw4Kx/VEXL95pPsKjRzRf38Xtr1EPCg8PRG++8th6YcPfxtPTCSHU4jO9My9jz65OO3NbvnyGjo7W1asPVq/+MTp6qrZ2y75IWPHDhvWi25Ndvfrg/v3M6OjojkftSGjouPPn7yjiltgttN+4OtNmW+htrabDejr8eGmtzebTQicbppLfxufPp4wdO7a33QvLw8PjwoUL169f//DDD/Gu5T9vJC6BQNi795fbt5+uW7dPCc2yQ7Gx0SSS/hdf7EtOzsBuvXLw4IXW4zg6Uj/88Pu//kqurubV1tb//fe9hQu/3rnzv1fZw8MBIZSWlpOQcM/f/78jwdHRO7Kz6SKRhMV6vWvXSYRQWNh/HfGxa8x+990pHq8uL6/kyJG3Xjjtm29+e/Agq66uITk548svfzU01I+NfetnR4cFx8ZGu7nZb9p06PDhSyzW67q6hhs3HkVFbdmxY0WHa9RTtmxZamNjjr3ytbX12HrZ2Ji3s14IofDwAIRQRsYbp7J05mXs2dVpZ25GRgYLFrzX1NR048ajlStntp42PT0XITRlSntfLJQpM7Nw3rzYBQsWBAQEdH9uy5cvz8ws+Ouv5O7PqkPtNK7OtNkWelur6cwqtP/x0lqbzaeFTjZMZb6N7959dv36w5Ure1GqyQUFBZ0+ffro0aOxsbF41/KPNq45derUqYULF86dO/7XXz/H/YBWdjZ97dq9d+8+V1EhjBkzfPfuT+ztZ6qoqEilD+Tj1NTUbtt27MKFO2VlbCMjAx8fl/XrF/r5/XcnloyM3OjoHYWFDA8Ph99+24T11bx//8Xhw5fu3HlaXs7R0dEaNMhi9uyxH3/8vnyVq6q4a9b8lJj4uL5eFBLitW/fWmvrqdifsB4Q8vPksrP//OSTnx88eNHUhEaPHvbDD2ucnQfJl976TIMOC66ra9i1Ky4+Prm4uEJfX8fLa8hXXy1q3j+rzTVqft5eiwo7OQS9ef7D5s2HExJS2ewaMtlw8uSArVuXtXNqEEJILJbY288cNMgiNfWgfGCHL2PPrs7b5iZXWMgYMiRy9uyxf/75detV8PePLitjv3x5Tn4GEY6uXLk/d+5mb2+fv/++oqXVMy1x6dKlFy789eTJCRsb8x6ZYZs6bFztN4E2/629qtV0WE+Hr0BrrZtPm8vtTMNU2tu4uprn5bXQ3X14QsLfCl1Qdxw+fDgmJua3336bP38+3rW85SqP169fnzPnfTKZdPTo+oCAocov620qKqosLSeTyYYs1jW8a+kUqVSmpjZSXV1NLG6vl2+/ceXK/fDw//3559eRkb3l/tUtyGQyK6sp58/vbP5hjTl16sb8+bEJCd9PmjQKl9rkuNzazz/fd+TIpaioqEOHDmlo9NhdQ+rr60eNGikQ1KSk7Mc6roPeo0eaj9LexlxubWjo6tevG9LS0k1MevV76Ysvvvjxxx+vX78eEhKCbyVt38lgwoQJNFq2nd2Q0aOXz569oaioTMllyREIfs2XfvfuM4SQcs5w6A4CwQ+7rhN2GRpHRyreFSnJpEmjDhxYt3z5rhZH1HqPK1ceUKnk1nF74ULKypXf/vrr5/jGrVgs2b37jINDxMWL986cOXPixIkejFuEkI6Ozo0bN9XUdPz9l2Zm9pl7nA0Q3W8+SnsbFxWVjRy5jM2uTUq61cvjFiH0zTffzJo1KyIiIj8f537Bb713kKWl5bVr1y9dukSjlQ8ZEvn++xvx6sP84Yff0enlAkHDrVvp69btMzDQjY1diksl72T37jO1tfU//3waIfThh7PwLkd5li2bduPGbmzFew8Cwe/RI1pNTe2WLUc2bFjUeoTdu88kJu6NiZmu/NowPF7drl0nbW1nfvHF/iVLlhUUFEZERChiQWQy+f79B46Ozn5+0bGxR+TdyEFv0M3mo4S3cVNT06FDF728FmpqGty//8DOzk5xy+opBALh6NGjgwcPnjhxIpvNxrOSDntISaXS+Pj4b7/d9ezZc39/j2XLps6ePVZpx3dv3Urfv//c/fsvqqt5hob6wcFeW7YsGzLERjlL77I//7y5ffuJoiKGrS1l5cpZH300q7d15BtosENixsbEjz6KaL//l/Klp+ccOnTx9OkkFRXVmJjlH3/8MYVCUfRCGxsb9+3bt2HDegcHq6NH13t59cDZR6DfKy6uWLr0mzt3nn322Wdbtmzp/pVHlYnNZvv5+VEolKSkpJ7qGPGuOk5cudu3bx88ePDixQuamhqTJo2cOTN44kR/3LtWAdBHPX9ecP58yrlzKTk5dDc316VLly1YsIBIJHY8Zc/Jz89fsmRxWlraggWT1q9fYGur8KQHfRSTWfXdd6cOHLjg6Oh4/PiJ4cOH411RV+Tm5o4cOXLatGnHjx/HpYB3SFwMh8M5c+bMuXN/pabe09TUmDDBb+bMoMmTAwwMlHEtGwD6tKamprS0nPPnU86du/3yZRmVajVjxszZs2ePHDkSr5JkMtmJEye2b9/GYDDmz5+4YcNCOztLvIoBvVBFRdWuXXGHD182NDT8/PN1K1euVFfHvyd/lyUmJk6cOPHnn3/+6KOPlL/0d05cOQ6Hc+HChfPnzyUn31ZRIYwaNTQkxCs42MvHx0VNTbVnqwSgT2MwWMnJGcnJT27dyigvZ9vb282cOWvmzJne3t695HBDY2Pj77//vn37tlevXk2fHhQdPSU01FtF5a39PMBAkJr6/MiRy2fP3jIxMVm37ovo6Gi8dsb2rG3btm3dujUxMXHMGGXf/b3riStXU1Pz999/JyYmJiffKi+v0NPTGT3aMyTEKyRkxNChDtBowcDEZtfcvv0kOTnj9u2nhYWlWlqa/v7+ISFjw8PDhw7tRWfcNdfY2HjmzJkDB369d+++ra3l4sWTFy2a3NuueQkUjcPhxsVdPXLkcl7eKy+v4cuWxSxYsKBvHbJtX1NTU2Rk5N27dzMyMpR8U78eSNzm8vPzb9++nZycnJJym8OpMjQ08PFx9fFx9vZ28fZ2Vtp1xgFQPpFI8vx5QXp6Tnp6bnp6Xl5esaqqqrf3iJCQsSEhIf7+/tra2njX2Fm5ublHjhyJi/utpoYbHOw1Y0bQ1Kmj4fzd/q2qinv5cur58ymJiWna2tpz536wdOlST89ecefWHldXV+fn56ehoXH//n1lNsweTly5pqamrKysO3fupKWlpaenFRQUNjU1Uanm3t7OPj4u3t7OXl5DiEQ9RSwaAOWQSmV5ea/S03PT03PS0nIzMwskkkYSiejt7e3j4zty5MjAwEB9/d54t+BOEolEly9fjo+Pv3btan19g5+f+/Tpo2fMCIIDvf1JWRn74sU758/fuXv3mbq62rhx42bNipg1a5aOjg7epSlWQUGBj4/PrFmzjhx56+3Me5yiEreF2trazMzMJ0+ePHmScf/+PTr9FULIwsLU1dXWxWWQq6udi4vt8OGDoecz6M0qKqpycoqzs+k5OcXZ2a+eP88XCBrU1dUdHR0CAgJHjRrl5eXl7Ozc/46kCIXCe/fuJSQknDlzmsVi29lZhYaOCA31DgkZ0fxWlaCvEAgaHj6kJSWlJSU9efo0V1tbKyRkbERExLRp0wwMDPCuTnkSEhKmTp2qzAtAKilxWygvL3/69CmNRsvKysrOpuXl5YvFYlVVVQcHqru7vaurraurrYMD1cHBSn5jVwCUSSqVlZZWFhWV5eeXZGW9pNHo2dnFPF4tQsjSkuLq6uru7uHq6jps2DA3N7c+3XXznTQ2Nt69ezcpKenWraQnT542NTUNGzY4NHTEmDGevr6ukL69GZ8vSEvLuXPn6a1bT9LTs6VS2dChHmPHhoaGhgYHB/enw7Tv5LPPPjt48GBGRsaQIco4JR2fxG1BIpEUFhbSaDQajZadnf3iRWZx8SvspoZmZsaOjlRHRysHByssgx0crOBMJNCDGhulpaWVhYWMoqKyoqKywkJGUVF5cXG5WCxBCBkZGbq5ubm6unl4eLi6urq5ufWq+4DiiMvlpqSk3Lp169atpNzcPISQk5ONr6+Lr6+rn5+bh4eDuroa3jUOaFKpLDub/vhx9qNHtMePc3Jzi2UymZ2d7dixoWPHjg0JCTE1hT5xSCKRjB49WiAQPH78WAkHdHtF4rYmFovpdHpRUVFhYWFRUVFRUWFRUVFpKaOxsREhRCYb2dtbWVuTqVQza2tzGxtzKtWMSiVjd7AHoE0ikaS0tJLBYDEYrFevmAwGm8Fgv3rFLC4ux650aGxs5ODg4ODg6ODg4Ojo6ODg4ODgYGwM3f06VlVV9fgfjx4/fszj8bW1tYYNc/LwsB861NHd3d7d3R76bShaXV0DjfbyxYuiFy+KsrLoT5/m1dXV6+npjhgxws/P39fX19fX18LCAu8yex06nT58+PAFCxbs3r1b0cvqpYnbJolEUlxcjMVwcXFxaWkpg1FaWlrKZnOwEXR0tG1sLKhUMhbGVKoZmWxIoZiamRmRyYZwlvBAwOPVMZnVbPbr8nIOi/W6pKSytLQSC9fKyipsHG1tLWtrqrW1NZVqY2Nj4/AvI6P27kUIOkkmk+Xn5z9+/DgjIyMr60VWVlZNDRchNGiQpbu7nbu7vYuLraMj1dGRamjYh7uV4Y7Hq8N2zOTkFNNo9BcvXtLpZU1NTfr6em5urh4ew7y8vHx9fV1dXVVV4aOvA/Hx8ZGRkefPn582bZpCF9SXEvdthEJhSUkJg8FgMBglJSWlpaWlpSUMBqOsrKy+vgEbR0VFhUw2IpONKBRjMzMjCwtjc3NjMzMjCsXE2JiI/cBOsN6Px6urquJVVXHZ7JrKymoms4rNrikv57DZXCazqrKyuqFBiI2pqqpKJptaW1tTqdYYGxsbKpVKpVLJZDK+azHQlJaWZmVlZWVlZWZm0mhZBQWFYrEYIWRsTMKOGTk5WTs6Uu3sKFSqGZxD2BqHw2UwWHR6eWEho7CQUVhYVlBQyma/RgipqanZ2dl6eAz18PBwd3f38PCwtbXtJZdV6VuWLl16/vz5zMxMhZ6h2x8Stx11dXUVFRUsFovJZFZWVrJYrIqKCjabVVFRzmKx2WwOdrQYY2CgZ2pqaGxMNDY2MDEhypPY2JhoakoiEvVIJD0iUc/AQBeyuWfx+QIer47PF/B4gupq3suX5Y2Nja9f8zmcmupqfnU1v7qaV13Nq6qqaWz87/+lr69naUkhk80oFEszMzNzc3MLCwsymWxpaUkmk8lkcv/rM9w/SKXS0tLSwn8VFOQXFha+elWCHTPS1NSgUs2pVDKVSv73gJGZpaWpqSnJ1NRQVbV//k+bmpo4HC6HU1NRUcVgsEpLWdi+mbIyTkkJE/seqaqqam1NdXR0dHBwdHR0dHJycnR0HDRo0MDpuKdQ9fX1Xl5e1tbW169fV9xXln6euO2TyWRsNru6GQ6H8+/Dqn9/v66uft3iVdLW1sKi18BAl0TSIxJ1scfYQH19HT09bQ0NdRJJX1NTXUdHq8VTvNZXcaRSGZ8vaGgQCYUiPl8gFjfKn/J4Amwgny+oqanFYpXPr8eG8Pl1NTX8FnPDkpJEItrY2AwePMTExMS4GRMTExMTEzKZ3IcuKAE6JJFISktLy8rKsN1UDAajrIxRUvKqtJRRW1uHjUMgEExNDU1NDclkQwsLYyyDTU1Jhob6JJK+/Dsx1tDwXR05iaSRy63jcmt5vDout66mhs/l1mE7aTicGharhsWq4XBqOJwa+bd/HR3tf/fHWFOp1EGDBlGpVCsrq0GDBvXszZJBC0+fPvXz89u7d29MTIyCFjGgE7eTmpqaqqureTwel8vl8Xj8f2GP/x2IDefx+bV8Pl8gqMf2m7VJX19XXV2NRNLX1NTQ0dFECOnr62CHmbEjW6qqKlh/bHlC6+hoaWr+19i0tDS09xrxCwAAIABJREFUtdvoza+iokIkttGRWySS1NcL21w1Lreu+RAs/7AEbT5hfb1QJJIghPj8eqlUio0gFIobGoR8vqD5roIWSCSilpaWgYGBgYEBiUQiEkkGbzI0NCQSidhjIpFobGzMZDIvX7588uTJJ0+eWFpazpw5MyIiYtSoUbCvbGDicrlMJpPD4VRWVrLZbA6Hw2KxWCwWh8Nms9lVVVXYceLmtLW1sAzW1dXS1dXW0FAzMNBVVVUxNNTH2oi6upqe3j9nHpJIes3fWi0aV+u2w+XWYp+a9fVCkUhcW1vf2CjlcmtlsiYut66xUVpbW9/QIOJy67hcfut2RyQaGBsbm5mZmZqakslm5ubmpqampqamFhYWpqam5ubm0FkPR+vXr9+zZ09mZqa9vb0i5g+Jq0A1NTVisVggENTV1YnFYi6XKxQKGxoa+Hy+WCzm8/kNDQ1CoRAhxOVym5qaZDIZj8dDCInFYoGgDiEkH6Gurrb5ncP5fH6bIScUCuUHMptTUVEhEts+sV1PT6/5XikDA31VVTUCgUAikRBCampq+voGCCEtLS1sm1JXV1dDQwMbQVNTU0dHR19fX0NDg0gkYuMYGBhoamrq6+vr6Oh08yS/7Ozs+Pj4s2fP5ubmWllZzZgxA6IXtAn74iv/LX8gEAjq6+tFIlFubu7Lly9dXJylUimfzxeLRQJBPUIIe9p8VnV1AolEIn+qqqpqYPBGDy95k9HW1tLS0saeFhW9NDU19fT0VFdX19PT09HRIRKJJBIJ+y1/AKeW9XIikcjb25tIJN65c0cRh6UgcUEfgEXvmTNn8vLyqFTq9OnTIXrBO1m3bt3169czMzM7OX50dHRZWdn169c7Of7EiRNNTU3j4uK6WiDoLZ4/f+7j4/PDDz+sWrWqx2feP7shgH7G1dU1NjY2NzeXRqMtXrz4xo0bgYGBgwYNWrNmzb179+BbI+jQs2fPFHpR/mHDhj1//lxx8wdKM2zYsC+//PKLL74oKirq8ZlD4oK+BIvevLw8Go22aNGia9euBQYG2traYtGLd3Wg98rMzFRo4g4dOjQ3Nxc7BgT6uq+++srBwWHlypU9PmdIXNAnYdFbUFBAo9EWLlx49epViF7wNmw2m81mu7u7K24RHh4ejY2NBQUFilsEUBp1dfX9+/cnJSWdPXu2Z+cMiQv6Nix6setyL1iw4MqVK4GBgXZ2dhC9QA4LQicnJ8Utwt7eXlVVtbCwUHGLAMo0atSoRYsWrVmzBuvN2lMgcUE/gUVvUVERjUaLior6+++/AwMD5QeA8a4O4KmgoEBXV9fSUoG39dXU1LS2toZt3P7ku+++k0qlmzdv7sF5QuKC/ka+1ZuamhoaGnr48GEXFxf5AWC8qwM4KCwsdHBwUHTPdkdHR9jG7U+MjIx27Njxyy+/PHv2rKfmCYkL+icVFZWAgIDdu3czGAwseg8dOuTs7IxFb35+Pt4FAuWh0+kODg6KXoqjo+PLly8VvRSgTEuWLPHz81uxYoVMJuuRGULign5OHr1lZWVY9B48eHDIkCHyvld4FwgUjsFgUKlURS/F0tKyrKxM0UsBykQgEPbv35+RkXHq1KkemSEkLhgo5NFbXl6ORe+BAwcGDx4s3wuNd4FAUcrKyhR6EBdjZWVVXl4OZ4f3Mx4eHgsXLvzyyy/r6+u7PzdIXDDgtI7eX3/91cnJCYte2DHYz8hkssrKSiUkrqWlpUgkqqqqUvSCgJJt3bqVy+Xu3bu3+7OCxAUDl6qqKha9FRUVWPTu37/fwcEBi146nY53gaAHsNlsiURCoVAUvSAs1MvLyxW9IKBkFArl008/3blzZ/e/TkHiAvBf9DKZzNTU1ICAgJ9//tne3n7EiBFYHuNdIOg67FOSTCYrekGmpqYIoerqakUvCCjf559/rqWltW3btm7OBxIXgP9g0Xvw4EEWi3X58mUXF5dNmzZRqVR5HuNdIHhnr1+/RggZGRkpekEkEklVVRUSt1/S09PbtGnT/v37u3mxZUhcANqgqakZHh4eFxfHZrMvXrxoZ2e3adMmKysrLHorKyvxLhB0FhaBSrhNnoqKColEwgIe9D9Lly61t7ePjY3tzkwgcQFojzx6WSwWFr0bN260tLTEopfFYuFdIOhATU0NdgtnJSzLyMgItnH7KzU1tY0bN54+fbo7pxRC4gLQKVpaWi22er/66it59LLZbLwLBG0TCAR6enrKWZaurm5DQ4NylgWULzIy0sHBYdeuXV2eAyQuAO+mefReuHDBzs5uw4YNFAoFi14Oh4N3geANYrFYXV1dOcvS0NAQi8XKWRZQPlVV1XXr1p08ebK4uLhrc4DEBaCLtLW1sejlcDjy6LWwsMCiF87L7CXEYrFydikjSNwBYN68eVZWVt99913XJofEBaC75NGLbfVSKJR169ZZWVlhA3v2bl/gXSkzcdXV1SUSiXKWBXChrq7++eefHzt2rGsnXkPiAtBjdHR0wsPDz549W1lZeejQIYTQ0qVLzczMsOjl8/l4FzgQSSQS2KsMetCiRYtMTU2///77LkwLiQtAzyORSFFRUQkJCSwWq3X01tbW4l3gAKLkbVxI3H5PU1Pzk08+OXr0aBe+Q0PiAqBA8uitrKw8ePAgQig6OppMJmPRW1dXh3eB/Z9EIoHjuKBnLV68WCaTxcXFveuEkLgAKIOhoSFELy6U2VcZtnEHCBKJNG/evD179rzrraIgcQFQKiMjIyx6mUzmgQMHEEJLliyRR69AIMC7wP5GycdxoefUALFq1aqioqKkpKR3mgoSFwB8GBsby7d6W0dvj9yMEyCENDQ0RCKRcpYlEomUtgcb4MvV1XX06NH79u17p6kgcQHAmTx6mUzmr7/+KhQKFy1aRKFQsIGwl7KbdHV1lbbnQCAQ6OrqKmdZAHcffvhhQkLCO10NAxIXgN7CxMQkKioqMTGxpKRky5YtdDp96tSpZmZmEL3dAYkLFGT69OkWFhaHDx/u/CSQuAD0OlZWVmvWrLl3715JSUlsbCwWvebm5lj0wpHCd6LMxK2vr4fEHTjU1NTmz59/6tQpmUzWyUkgcQHovahUKha9r1692rx5M0RvF8A2LlCc+fPnl5aWpqamdnJ8SFwA+gBra2sseouLizdt2tQiehsbG/EusPfS09ODxAUK4uLiMmzYsFOnTnVyfEhcAPoSGxubFtE7ZcoUiN526OrqikQi5bwyAoFAR0dHCQsCvccHH3xw9uxZoVDYmZEhcQHok+TRS6fTN27ciEWvhYUFFr1SqRTvAnsLbKOzsrLy6dOn8fHxO3fuTEhI6KmZ3717d/v27adPn05PT3/9+jVs4w5Ac+fOrauru3r1amdGJrzrJTMAAL1TcXHx2bNn4+LicnJyLC0tZ86cGRERMWrUKAKBgHdpyvby5ct79+69fPny5cuXmZmZRUVF2Cm52EsxefLky5cvt5iETqdHRkbKt1RYLJZEIrGyssKeqqmpHTp0yNvbu8VUH3300f79+wkEAtZ3RkNDw8bGxtPT08HBwc7OztfX183NTaFrCnqDcePGGRgYnDt3ruNRmwAA/QuNRtu8ebOzszNCyMrKavXq1ampqTKZDO+6lCc4OJhAIGhqaqqotNyNp6GhERsb23qS8vLy9r+aZGRktJ7qyJEjqqqqLcZUUVHR1NQkEAgODg6KX1eAv2PHjmlpadXW1nY4JuxVBqC/cXV1jY2NzcnJodFoS5YsuXnzZmBgoHwvdNMA2K21YsUKhJBIJGp92oZYLB4xYkTrSSgUSkBAQOuExtja2np5ebUePmLEiNY78GUymUgkUlFR+fDDD7tSPehrJk+eLBaLO3PFR0hcAPotLHpzc3NpNNrixYuvX78eGBg4aNCgfh+9s2bNcnFxab31iWkzOxFC8+fPb3O4hobGggUL2vyTq6vr2y7raGhoGBMT04liQZ9namrq4+Nz5cqVDseExAWg/8OiNz8/n0ajLVq06Nq1a4GBgba2tlj04l1dzyMQCNu3b2+z+5i5ubm5uXmbU82aNavNkBaLxXPmzGlzEjU1NXd399bDVVVVt27dqq2t/S5Vgz5s0qRJV65c6fBbLCQuAAMIFr0FBQU0Gm3hwoVXr17tr9E7derU4cOHq6mpNR+ooqLi5+f3tkkMDQ3DwsJaTEIgEDw8PJycnN42lb+/f4vNXAKBQCaTFy9e3NXaQd8zadIkJpP57Nn/2bvzsKau9A/gJyH7HrIACWEJKEsQF0BBREWr1rq0orZqrUsHl9aOth07dvtVWztV2+m0znSx1dplujhTl9atVau44IqoIIsihCVAIJB9IQkk+f1xbWRCoIBAAN/Pw+OTnHtyz5vU8vXenHvu9Y67QeIC8CDCovfOnTsFBQVLly49cuRIWlqaVCpdt25dbm5uJ3ditVr78+0F3377bY/LcAkEQtv5xq09+eSTHkfGBAKhvVPKmISEBI9RcDjc5s2byWRy10sGA9WIESOCg4MPHz7ccTe4OggAgBBChYWF//73v7/99tuamprY2Nj58+c/8cQT2ITn9ixevPjEiRMHDhwYO3Zsn9XZJSkpKVevXm2diMeOHZs6dWp7/S0WC5/Pb2pqcrfgcLiqqir3ZUJtFRQUtD6xjMPhJBJJaWlpn92UF/QTq1atunHjxuXLlzvq1MuzpgEAA4nD4Th37tzatWtFIhFCKDY2duPGjcXFxW17ms1mKpWKw+H8/Py2b9/e96V2hsf0URwO19jY2PFLFi1a5A5LPB6fmpracX+Hw9H6+1o8Hv/NN9/03DsAA8b+/fvxeLxOp+ugD5xVBgDcg8fjx40bt337doVCce7cuYceeujzzz+PiYlxz71y9zxy5IjVanW5XA6H4/nnn1+wYEE/PMM8efLkcePGub+aFYvFPB6v45csWrTIfYsIHA63ZMmSjvvj8fj4+Hj349DQ0PamWYHBLS0tzeVyXbx4sYM+kLgAAC/c0VtdXY1F72effRYdHe3+Avg///mPe2Yv9g/84cOHFxUV+bbstrZu3YqdVe542pTb1KlT2Wy2++ncuXP/8CXuyVMul2vLli0ec6/AA4LP50dGRl64cKGDPpC4AICOtI7e48ePjx079qOPPho6dOjPP//c+vvR5ubmysrKxMTEH3/80YfVtpWamjp58mQikUggELyufeGBSCQuXLiQRCL5+flNmzbtD4+J0e+Tp/B4fFRU1Pz583uiajAgpaamnj9/voMOkLgAgE7x8/ObMmXKzp076+rqXnnllbZXu7a0tFit1scff3zt2rX96t692GGu3W7veKKy28KFC+12u9PpfPLJJzvTPzEx0el0Op3Od955p71Vq8CDIDU19fLlyx3cqArOfgAAuoZAIBQXF/v5+bX9zeJyuRBCn3zySW5u7r59+9pba6JXWSwW7L4FRqPRfT45JSXl4sWLeDz+9OnT7f1CNBgM2D8jXC4Xl8s1mUwOhwM7ZMfj8a1PNbeGx+OZTCaVShWLxRKJpKysDIfDufsTiUQGg9FL7xT0N6mpqWazOS8vr711zeDqIABA15hMJh6PZ7fbO+hDJBK5XG4nLxzS6XSG31ksFq1W29zcbDKZzGaz3W5v81Rjt9vNZjP2tKWlxWg0IoRsNpvF0vSHY/kKhULGpjTT6XQSiUQgEJhMJo1GI5PJHA6XSCS2esrxeEqlUlksFpvNZrFYXC7X128FtMvlcgmFwv/7v/9bu3at1w5wjAsA6JpDhw51HLcIoebmZpVKNX78+OXLlw8fPlyv1xsMBp1Op9PpDAa9wWAwGPQGg1Gv1+v1hrYvJ5GIdDqVTqeSSEQul0kkEhgMKo1GJpNJ4eEMIpHAZNJoNAqZTMLhEIfDRAhhfdDdbCMjhOh0ColERAixWHQ/v7sne8lkEo1G8VozmUxsb5PVam9qsrWzyebe5HIhnc6IEGppcRiNltZbzWar3d6MEDIYzA6H025vNpubsEatVtvU1NLQ0GSx2Gw2u05nam5uMRrNTU02q9XLoCwWk/U7NpvNYrG5XK77Ka8VPp/PYrHa/Y8EehoOh0tMTLx69Wp7HSBxAQBdoFKpPGZj4vF4PB7f+qJD9yaHw7F79xcCgT+bzWCzGWw2ncNhiET06OhQFovOZjNYLDqbTedwmO6nNBoZS9B+hUIhUSje71iAUO9Wq9ebLBarwWA2GMx6vVmnM+r1Juzp740aubzSYLAYDGadzqjR6LFoxxCJRH9/rjuC/f39eTyeQCAQCoVCoVAsFmMP4OvnniKTyc6cOdPeVjirDAC4x+FwKJXKysrK+vr62tpalUpVW1tbX19XV1enVCpVqgb3lCgymSQU+vP5HD6fzeOxeDw29uPvf+8xn89ms+FbzL5mNFrUan1jo06t1qvVerXaoFbrNRrsgUGt1jc06FQqTVOTFevv5+cnFAoCAwOCgkRCYQAWw0FBQUFBQRKJRCQSwfpZnffFF1+sXbvWaDR6/UcMJC4AD6KmpialUimXy+VyeW1trVKplMvL5HK5QlHtzlQKhSwSCYKCeCIRPyiIhz3mclkiET8oiB8Y6A8HRgNaU5NNqWysrW3Uao3Yg9+fmpTKxqoqZUvL3enoXC5HKpVKpRFBQUEikUgqlWIPwsPDcTicb99Ff3Px4sWxY8eWl5eHhYW13QqJC8Bg5nQ6FQpF6f8oqaioNJnurg/F43EkkgCJRBgaGiiRCCWSgJCQwJCQgIAAf+xLUPBgamlxqFTaykqlQqFSKOqrquqqquqxxyqVButDpVLCwsIiIiKGDBkaGRkZGRkZERERGhr6IK8BYjAYOBzO4cOHH3nkkbZbIXEBGDyUSmVhYWFJScnv4XpHLi/HLpVhs5mRkcGRkcGRkeLwcJFEEiCRBISGBrY3VwiA9lit9qqqOoWiXqFQVVQo79xRlJZWl5ZWazR6hBCRSAwLC4mMHBIZOWTIkCFDhw6NiYkJCQnxddV9Jzg4eN26dS+99FLbTZC4AAxUOp2urKyssLAwNze3qKiwoKCgrq4eIcThMCMigqVSkVQqkkrFUqlYKhWFh4vgBCDoVVqtUS6vkctr5PJaubxGLlfK5bVyuQIhxGIxhwwZEhsrk8lksbGxMplMKpX6ut7eMm3aNLFYvHv37rabIHEBGDBKS0tzcnKuXr2an5/XKl9ZMplUJguLi4uQycLj4iKEQrhkE/QXGo2hoKCsqKj85s2yoqKKmzfL1GodQojP58XFxQ0bFp+YmJiUlBQVFTVopgWsXbv22rVr2dnZbTdB4gLQfymVypy7ruTk5Gg0WiKREBcXOXLkkNjY8Lg4qUwmDQ4W+rpMALqgrk5dWCgvKJAXFsrz8sry8kpsNjuLxUxMTExKGj169OikpCSJROLrMrtv27Ztn332mVwub7sJEheA/uXWrVtZWVlZWVkXL16orq7B4XBDh4YmJUUnJcUmJcWMGDEUW94BgMHBbm/Ozy/NySnOySnKyblVXFzucDgCAwPGjBmTnj4pPT192LBhA+sLkW+++WbVqlUWi6Vt2ZC4APheWVlZ1l2nlMo6JpM+fvzIcePik5JiEhNj4JJW8OAwmZquXbuVk1N8/nz+mTPXNRq9QMCfMGEClr4xMTG+LvCPnThxYurUqRqNpu2SnJC4APhGS0vL6dOn9+3bd/TokaoqBY1GGTduRHr6qPT0hISEaALBz9cFAuBjTqczL680Kys3Kyv3zJnrRqM5KCjw4YenZ2RkTJkyhUzupyd7CgsL4+LiCgsLY2NjPTZB4gLQp2w224kTJ/bv3//zzz9pNNqRI6Nnzx43eXLimDEyuP4VgPa0tDhyc2+dOnX14MHsy5cLmEzGjBkzMzIypk+fTqfTfV3d/9BoNDwe78SJEw899JDHJkhcAPqC0+nMysr68ssvDx06aDSakpOHZWRMyMiYKJWKfV0aAANMTU3DgQOn9+8/c/bsdRKJOH369OXLn54+fbqfX784M+RyuWg02ueff/7UU095bBoks7EB6Ld0Ot22bduGDIl86KGH5PKbf/vbSoXi4IULn69f/+TgiFscLhn76dWX+FxOTlF6+rN9OeLA+mDT05/NySnqm7HEYsFzz80/deojpfLIP//5ol5fPXv27NDQkE2bNqlUqr6poQM4HC4gIKCurq7tJkhcAHqLSqX6y1/+EhIi2bLlb7Nnjyko+P7Chc+fe26+WCzwdWk9yeW61Acv8a1duw5Onbpu3bon+nLQgfXBrl37+JQpa3fu/LkvBxUIOJmZs3/77V937uxdsmTKJ5/8Myws9JlnnqmqqurLMtpiMBgWi6VtOyQuAD3ParVu3rw5MjJiz55v33hjeVXVTx988LxMNmgX2Rncfvnl4sqVW3bs2PDYYxN8XUv/NWfOxI8/fmnVqq2//HKx70ePiBC/884zlZU//f3vfz527FBU1NANGzYYDF5uvdw3KBRKU1NT23b4HheAHpaTk7N06ZKamuq//nXxCy8seBAWLsZOY3bpAKsbL/EJu705MnJeSEhAdvbnfT/6gPtgU1Iya2sbS0v3Eok+u5mB3d786af7N2/+ksFgffHF7smTJ/d9DWlpaaNGjdq+fbtHOxzjAtCTvvnmm3HjxonFrJs3v33ttWUPQtwObvv2ZSkU9YsWTfN1IQPDokXTqqrq9u3L8mENJBJx3boniov3JCZGTpkyZdOmTX1fA4VCsVqtbdshcQHoMbt27Vq2bNmLLy44fnx7SEigb4txT6KprW2cO/dlJjOdx5u6dOlber2pokI5e/Z6FmtSYOAjy5Zt1umMrV9YV6detWprcPAsEmlccPCs1au31ddrWncoLJQ/8sgLDEY6mz15zpwNVVVeZoioVNpnnnkX24lYPHPlyi11deoOqtXrTS+88KFUmkGhpPF4U8eOXbF+/T+vXCnyeC9FReUPP/w8izWJwUifMePF4uKKLg1qtdq3bv1m5MgldPpECiUtOvqJ1au3XbpU0EFhBw+eQwglJt5beGFgfbCtd8tiTZo2bV1RUXnbCVYd79bdX6Gof/TRl5jM9ICA6YsXb1Sr9R5jJSXFuD803xIIOHv3vvP++2s3b9789ttv9/HoVCrV61ll5AIA9ITc3FwSibRxY6bLdamf/GD/jy9e/HBR0R6d7rc1a+YhhGbMSJ0zZyLW8swzGQihFSsedb9EqTwikQSIRPyTJz8yGE799tu/AgN5oaGBdXVHsQ6lpfs4HCbWwWjMOnPm02nTkn//ZXJ3J3V1R0NDAwMC/I8d2240Zp09uyM0NDA8XKTVnvCozf300UfHI4Q+/PAFkynLZjt369Z/5syZ2LoD1n/s2GHZ2Z8bjVlYYVwus7z8QCcHNRhOJSbGMJm0nTtfras7ajRmZWV9EhMT1nqUtj9RUaEIIffbH3AfrMdus7M/T02N7/Zun3xyWus3uGzZDI+Pq7b2MEIoOjrU53/53T87dmzA4XDHjh3ry98G8+fPnzdvXtt2OMYFoGds2rQxMTFm48Y/+boQT5mZj8bEhLHZjFdfXYYQOnLk/Lp1T7RuOXr0grvzG298rlDUb9v23KRJiUwmbfLkpK1bn62srNu4cSfWYdOmnTqdEevAYFDHjx+5evUcjxE3btxZWVn3zjvPTJ06hsGgpqWN+OCD58vLa99777v2iszKykUIicUCOp1KIhGjokI/+mh9226vv/50amo8g0HFCtNqjZs27erkoJs27bx6tXjz5lWZmbMDAvwZDOrEiaO+++6tjj+9mhoVQojDYQ7QD9Zjt6mp8Vht3dvtihWPYW/wr399CiF0/Phljw5cLgshVFPT0F49fW/VqjmPPTbhtdde7ctB2zvGhcQFoAe0tLQcP37imWfm9MMl10eNisIeBAb6e7SIRHyEUG1to7vz4cPnEUKTJiW6Wx56aDRC6PDhu7ceO3HiikeHceOGe4x46NA5hND06SnulvHjR7rbvZo7Nx0hNH/+qyEhj2ZmvvPf/57k89muNtN/xo4d5lGY+5f+Hw66d28WQshjvvHIkUPbjtKaxWJDCJFIXuYBDYgPtu1uW3+GXd2txxtUKj1PaGMflMXi5StMH1qzZu7Vq7l9eakukUhsaWlp2+6z6WQADCZ6vd5ms2G/hvobJpOGPXDff9SjxdXqgoWGBi1CiM9nu1v4fA5CSKXSYk8bG3VeO7SGdRaJZnq0l5XVtFfk7t2vz5w57vvvj506dfWLLw5+8cXBkJDAn39+d8SIoa27tb6pAzYuVnBnBlUqGxFCgYG89mrwikYjm0xNdnsLmey5BueA+GDb7rbt8Xrnd+t+g9iKpK42l7rY7S0Iof42YVAsFiKE6urqhEIf39oSjnEB6AE8Ho/P57ln+gxc2N3sGxvvzYjBfmW773KPxUDrDnq9yWMnAQH+CCGN5oTHN2pm8+kOhs7ImLh375bGxmNnz+6YNi25qqpu+XLPCS+tp+pghQkE3E4OinXAcrfzsF/WHnOgusFXH2zb3WLj3udu26PVGhBC/W2Nl8uXCwgEQmRkpK8LgcQFoIf86U+ZH374H/chywA1a1YaQujkyRx3y2+/XXG3I4SmTh3j0eHiRc+5vtiZ29Onc1s3njt3IyUls71xcbjk6moVQgiPx6eljfjPf95GCBUXl3t0O38+36MwrJ7ODIqduP7ppzOtO1y6VDBmzNPtVYUQGjlyKEKostLLtOEu8dUH23a3rT/Dbu+2PdgH5XFmwrdMpqYtW/795JNP0mg0X9cCiQtAD9mwYQOTycnIeNlgMPu6lu57880VoaGBL7/88alTV41Gy6lTV1955dPQ0MBNm+7+8t20KZPDYWIdTKamCxdubtnytcdONm3KHDJEsmbN3/fuPaVW641Gy+HD2cuWbd66dU0HQ2dmvlNYKLfZmuvrNdu2/Rsh5J6s67Zjx/7s7DyTqQkrjMtlti6s40E3bcqMi4t4443Pd+78ub5eYzI1HTuDz032AAAgAElEQVR2acmSN99555kOqpo1axxC6OrV4s5+gu3w1Qfrsdvs7LzPPjtw/7ttT05OMUJo9uy0rr6wl9hszQsX/p9OZ+n7C4S8gjWnAOgxxcXFkydPEgiYBw5s9fldClpfbYlNDupMC0Kovl6zcePOQ4fOqVRaoZA7c+a4t95aiZ14xBQWyl966V9nz97A4dDYsfEffPC8TLbQYydarfHtt3cfOHCmulrl788aPTr21VeXJSfHtVfb+fP5O3f+fObMtZqaBhqNEhYW9Pjjk59//t6KXdhLyssP/PnP7585c83pdI0fP+L999dhl/d0ZlCEkMnUtG3bNz/+eKq8vJbJpCUkRL/++vK0tBEdfIx2e3NExNywsKBz5z4biB9s693i8bgJE0Zt3/5CRMRcPB7vcNybSt3V3XodCCGUkpJZXa0qK9vXH249WVenfvzx1wsKyo8e/SU5uU/v7pCZmVldXf3rr796tEPiAtCTqqqqHn10dmnpnW3b1qxePcc9pwbcJx8uXnjkyPlZs9b/8MPmJ57wvN3pQFRb2ygWzxQKufX1v/Tsnr/77thTT206dOjvM2ak9uyeu8rlcn3//fF16z7gcPwPHjzU9s7wva29xIVfBwD0pJCQkMuXr6xd+/y6dR+MGLGk9RWZYICaMSN1x44Nq1dv8/gOeKDA4ZJLS6vdT8+evY4QSk9P6NlRDhw4/eyz73766V99Hrdnz15PSVmxZMmbCxY8mZeX3/dx2wFIXAB6GIlE+tvf/lZQUBAZGTdjxosJCct++OF4S4vD13WB7lu58rFjx7Z/+OEeXxfSTWvWvCeX15jNTSdP5mzY8DGLRd+0aUXPDrF9+39OnPjXqlWeq3b0GafT+fPPZ9PSVk+Y8AyTGXD16tWPPvqITqf7qh6v4KwyAL0oNzf33Xe37du3PzCQt3z5jD/9aXZYWJCvixp42vvWEHTGyZM5n3yy7/z5fLVaz+Uy09MT3nxzZXR0qK/r6jFKZeOXXx7+4ovD5eU1M2Y88tJLfx0/frxvS4LvcQHwmfLy8p07d3711Zf19aqxY+MzMiZkZKSHhvr4VgcADGhKZeNPP53dv//06dO5LBZryZKlq1atio6O9nVdCEHiAuBzLS0tR48e3bt37+HDh7RaXUJCDBa9g+loA4DeVl5ee+DAmf37T1+8eJNGo06fPn3evPmzZ8+mUPrRQleQuAD0F83NzadOndq/f/9PPx1QqRqiosImT05IT0+YOHFU24X9AAA6nfHs2RunTl3NyrqWn3+Hy+XMmjU7IyNj6tSpVCrV19V5AYkLQL/jcDjOnz9/9OjRrKxTubnXnE7nsGFD0tNHTpqUOGHCyNZrCAPwoMHW68jKyj11Kvf69dsulys+flh6+qTp06dPnDiRSPT99b4dgMQFoF8zGAxnzpzJysrKyjqVn38Th8PFxUUkJUUnJcUmJcXGxUmJRLjvCBjMHA5ncXF5Tk5xTk5RTs6tvLyS5uaW2NiYSZMmp6enT5gwgcfr2l0ofAgSF4ABQ61Wnzlz5uLFizk5V3Jzc00mM5VKGTFiKBbAiYkxQ4dKYG0NMAiUldXk5BRhEXv9+m2TyUKlUkaOHJmUNDo5OXnixImBgQNygiEkLgADlVwuz87Ozs3Nzc29mpuba7XaSCRiZKREJguPjQ1PSIiWycLDw0X98Na8ALSm1RoLC+VFReWFhfLc3JL8/DtGo9nPzy8qamhCQmJCQkJCQkJSUhKZTPZ1pfcLEheAwcBut+fl5eXl5RUVFRUU3CwoKFAq6xBCHA5LJpPKZGFxcRFRUSGRkcEhIYEEgp+v6wUPKKfTqVCoSksVd+4obt4sKywsLyiQq9XYzXp58fHxsbGyuLi4+Pj4ESNG9M/ZT/ejvcSFb4YAGEhIJFJSUlJSUpK7RaPRFBQUFBYW3rx5s6iocO/eMxqNFiFEJBLCw8WRkcGRkeLISElkZHBkZHBYWBB8Hwx6lsPhrKxUlpZWl5XVlJYqSktr7typlsurbTY7QojNZslksri4xIyMpTKZbNiwYT6/LbwPwTEuAIONWq0uLS0tKysrLS29c+dOaemd0tLSxkY1QohA8AsNFYWFBUkkgtDQIIlEKJEESCQBoaGB7rv0AOCV1WqvqqpTKOoVClVlpVKhUCkUqooKZUVFrd3ejBDicjmRkZGRkUMiW3kw8xWOcQF4UPB4PB6PN2bMmNaNer2+9HeVlZUKRdWVK+crKyvNZgvWgc/nSiQBEokwNDRAIgkIDOQFBfEDA/0DAngCAVwl/KDQaAx1der6ek1tbWN9vaaqqq6qql6hUCkU9fX1aqwPlUoJDQ2RSCQSSWxq6nQsWSMiIgbQXGJfgWNcAB5oGo1GoVBUVVVVVVUpFAqFQlFZWVFVVVVfr7Lb7VgfIpEgFPqLRIKAAG5AgL9IxBcKuSKRICDAn8dj83hsHo8Fc6f7P5fLpdEY1Gq9Wq1XqbQ1NQ0qlbauTq1Uqn9/qsFOBSOECASCUCgIDQ2VSEIkEklISEhoaKhEIpFIJAKBwLdvpP+DY1wAgBf+/v7+/v7Dhw9vu6mxsbG+vr6+vr62tlalUmF/VlbWXr5cqlI1qFQNrTvzeBx3+vr7s7DHfD6bz+fweGw2m8Fm0zkcJotFh/lcPcvpdOr1Zp3OaDCY9XqTWq1Xqw0NDVosWdVqg1pt+P2xrvUhlr8/NzAwMCAgQCSSREQkiESigICAgIAAkUgkFAofzLPBvQ0SFwDgHZ/P5/P5MpnM69bm5maVSqX+XWNjo/qexpISOfYIm8bVGo1GYbEYLBadxaJzOAw2m449ZrMZLBadyaQxGFQikcDlskgkAp1OpdOpJBKBy2URiQQGY7BNasVYLFabrVmnMzY3txiNFuypXm+y25uNRovJ1GQwmN0/Wq3RYLD8/tRkMlk89sZms/h8Ho/H5/F4PF6oVMpzEwgE7geD4CKcAQcSFwDQHUQiUSwWi8Xijrs5HA6NRqPX6/V6vU6nM/wvnU6n1+vr6vQlJQqDQW8wGA0Gg9lscZ/QbotOp5JIxNYBjEUyQojFovn5+SGEuFwmQsjPD89i0RFCZDKp9bwwAsGPyaR53TmLRffz8zw97nIhnc7otb/Z3GS3t7ifNjXZrFYbQshkampubkEI6fUmp9Plcrl0OhNCqKXFYTRaEEIWi81ms/8eseb23iyRSGQw6AwGg8VislhsFovFYvlLpRGs/8VmszkcDvaAx+MRCPCLvZ+C/zAAgF7k5+cnEAi68c2fVqttbm42mUxms9lut2u1WrvdbjabTSaT3W7X6XQ2m81isSCEjEZjS0sL9hKEkMPhkMv1CCG73W42VyCEmpqarFare88Wi8Vms7Ud0eFwGAzek5XBoHtdyJdIJDIY95a/JpFI2C3QaTQadgTJZLIIBAIOh8LDI3A4HB6PZ7PZCCEqlUqhUFgsFolEYrFY2FM2m00ikZhMJvZyDocDq5oMMpC4AID+iMvlIoR8+G0il8vdtm3bypUrfVUAGHxgeiEAAHhBJpO9HgoD0G2QuAAA4AWZTG59LhqA+weJCwAAXlAoFDjGBT0LEhcAALyAs8qgx0HiAgCAF5C4oMdB4gIAgBcUCgW+xwU9CxIXAAC8gGNc0OMgcQEAwAtIXNDjIHEBAMALOKsMehwkLgAAeAHHuKDHQeICAIAXkLigx0HiAgCAF3BWGfQ4SFwAAPACjnFBj4PEBQAALyBxQY+DxAUAAC9gXWXQ4yBxAQDAC7h3EOhxkLgAAOAFnFUGPQ4SFwAAvIDEBT0OEhcAALyAq4NAj4PEBQAAL+AYF/Q4SFwAAPCCTCbb7XaXy+XrQsDgAYkLAABeUCgUl8tlt9t9XQgYPCBxAQDACzKZjBCCE8ugB0HiAgCAF1jiwuQp0IMgcQEAwAs4xgU9DhIXAAC8oFAoCBIX9ChIXAAA8ALOKoMeB4kLAABewFll0OMgcQEAwAs4qwx6HCQuAAB4AWeVQY+DxAUAAC/grDLocZC4AADgBZxVBj2O4OsCAACgvzhw4MAPP/ygVqsdDofFYiGRSGvXrn3uuecQQiaTKTAwsLi4GIfD+bpMMFBB4gIAwF03b9788ccfW7coFAr34+DgYIhbcD/grDIAANy1dOnS9jKVSCQuWLCgj+sBgwwkLgAA3BUaGjphwgQ/P7+2m5qbm+fMmdP3JYHBBBIXAADuWbFihdPpbNseGhoqk8n6vh4wmEDiAgDAPRkZGQwGw6ORRCItXLjQJ/WAwQQSFwAA7qFQKIsXLyYSia0b7XY7nFIG9w8SFwAA/sfy5cubm5tbtwiFwqSkJF/VAwYNSFwAAPgfSUlJsbGx7knLJBLp8ccfh+uCwP2DxAUAAE+ZmZnuGctwShn0FEhcAADwtGTJEvdBLYvFGj9+vG/rAYMDJC4AAHji8XiPPPIIgUAgEokZGRkEAizPB3oAJC4AAHixYsWKlpaWlpYWOKUMegr8ww0AMMjZbDaLxYIQ0mq1CCGLxYLdEcjlcul0uvb6O51OFotltVqNRiO22LKfnx+LxWrbn0qlYjcaQghxOBwcDkej0chkcnv9wQMLEhcA0K8ZDAbt74xGo8ViMRgM2AOz2azT6SwWi8Vi0et1JpPJYrGYTCaHw2EwGBBCBoPR4XDcZwGLFy++zz0wmQwCgUAikeh0OpFIYDCYbDabRqPRaHQOh0On02k0GpPJZLFYNBqNRqNxuVwmk8n9HZzTHjTgPyQAwAeam5sbGhoaGhrq6upUKlVDQ4NGo/k9WN0PtBqN1iMy/fz8WCw6k0mn0Sh0OoXNZtBoZBqNLJUyaTQBjUZhseg4HOJwmAghOp1KIhGIRAKDQUMIsdl0PB5PoZCoVDK2NyaTTiB4rqKMx+PYbM9lpxBCVqu9qcnL7XINBjNWpMuFdDojQshkampubmlubjGZLAghvd7sdDqbmmxWq91ms1ssVp3OZLFYLZYGubzCbLZaLFaj0WIwmC2WJovF6rF/JpOBRa+/vz+X6+9OYj6fHxAQIBAIhEJhYGBg26WyQH8DiQsA6BUGg0GhUCgUipqampqamoaGBpVKVVenxIK2sVHt7kkmkwQCrr8/m8tl+vszRSKmTBbJ5bK4XCaXy/T3Z7kfs1h0EonYwaC9ikIhUSiktu1cLrNnB9LpjAaDWas1arVGrdaAPdBoDNjj6mrlzZtGrdagUmn1eqP7VVQqRSAQBAUFCQQCgUAYFBQkFAqDg4ODg4MlEklgYCAeDxN3fAwSFwDQfXa7vbKysry8vLq6+vd8rVYoqhSKaoPhbhjQ6dTg4ACBgCMUcuPihAJBlFDIDQzkCYVcgYATGMjzekD5IONwmBwOMyQk8A972mzNDQ3a+npNfb2m1QNdbe2t3NzzDQ3aurpGl8uFECISiUFBgRKJRCIJEYvFEokkJCREIpFIpVJ/f//ef08AIUhcAEAnWa3W2tpauVxeWFhYVFQkl5fJ5fKqKkVLSwtCiEIhi0SCoCCeSMSfOTMxKOhhkYgvlYqDgvhBQTxYsKmXkMnE4GBhcLCwvQ52e3Njo16pbJTLa2prG5XKRrm89tKlWwcONFZWKrGT4VwuRyqVSqUR0lZCQ0O93rUQ3A9IXACAFzU1NUVFRVi4FhYWlJSUYOeB/fz8goMDIiLEERGihx56RCoVRUQEh4eLevzMKugRJBJRJOKLRPyEhGiPTXZ7s0KhKiurLiurKSurlstrf/klr6xMYTY3IYTIZLJUGh4bK4uNjZXJZLGxsVFRUSSSl5PqoPMgcQEASKvV5ubmFhQUYPlaVFSk0+kRQgKBf1ycdMSI0IULx0ZEBEdEiMPCgnz4TSroQSQSMSJCHBEh9mivq1NjGVxSUnXrVuV///vvsjJFS4uDQCBERITHxQ2LiYmNi4sbMWLEkCFD4LvhLsFhp/gBAA8Ug8GQn5+fe1dOcfFtl8vF5bJiY8NlsvDY2HCZTCqThQcF8X1dKfC95uYWhaK+sLC8qKi8sFBeVFRZWFhmtdqYTEZ8fHxCQmJCQkJCQkJMTAwEMCYzM7O6uvrXX3/1aIfEBeCB4HA48vPzz549e+HChatXc+TycoSQWByQkBCVkBCVkBCdkBAdGMjzdZlgYLDZmvPz7+Tm3srNvXX16u3CwrLm5hYWizlq1KjRo8ekpaWlpaWx2Wxfl+kzkLgAPHBaWlpyc3PPnj179uyZ7OxsnU7v788eO3ZYYmI0FrFwCAt6hNVqz88vxQL44sWC4uJyPB4fHz9swoSJEyZMGDduHJ//YP1Ng8QF4EFRWVl5+PDhw4cPZWdnm0xmodA/LW34hAmjJkwYGRcnhfN+oLc1NOjOnbtx5sy1M2du3LxZ6nK5ZLLYhx+ePmPGjHHjxj0IS2hB4gIwmDmdzitXrhw6dOjw4UP5+TeZTPq0acmTJyeMHz8yNjbc19WBB5dWa8zOzjt9OvfIkYu3b1dwuZzp0x+ZNWvWtGnTuFyur6vrLZC4AAxOOTk5X3311d69P6pUDeHh4pkzx86alTZhwkiYUQz6mzt3FIcOZR8+fP7cuesI4SZMGL9kydK5c+fS6XRfl9bDIHEBGFRUKtW333775Ze7CwoKY2LCFy+eNnt2WlxchK/rAuCP6XTGX3+99OOPpw4fzqZQKPPnP758+fLU1FRf19VjIHEBGCTOnTv3wQf/OHz4CI1GeeKJycuXz0xOjvN1UQB0R2Oj7rvvjn355ZG8vJKoqKHPPPPsn/70p0FwS4b2EhfmUAAwYPz6669jx6aMHz++vl6+e/drtbWHPvvs5d6IWxwuGfvp8T13Y1Cn0/nVV0eCg2d1sh6fFN8bcnKK0tOf9WEB6enP5uQU9eoQfD5n3bonbtz4Jjf368mTh7322iuhoSGbNm3CbrY4+EDiAjAA5OXlTZ48afr06TweITv78/PnP1+8+GEajdJLw7lcl3ppz10d9PjxyyNHLtm9+1BNTcP97Oc+paWtSktb1eO77cCuXQenTl23bt0TfTmoh7VrH58yZe3OnT/3wVijRkV9/PFLlZU/rVs375///CAyMuLjjz++/3sb9zeQuAD0a3a7/dVXX01KSmpqUmdnf37o0N9TU+N9XVTfWbv2H2++ueLs2R2+LcPpdDqdzj4b7pdfLq5cuWXHjg2PPTahzwZta86ciR9//NKqVVt/+eVi34zI47HfeONPpaV7ly17+MUXXxg7NqWwsLBvhu4b8D0uAP1XbW3tvHlzCwpubt367OrVc/ryUlrsrGwfH+y2HbSlxYHdMb5L9fik+J5itzdHRs4LCQnIzv7c17UghFBKSmZtbWNp6V4isU+voy0qKs/M3JKXd2fXri8WLlzYl0PfP/geF4ABRqFQpKWNa2ysvXhx57PPzn0wV67A4vaBsm9flkJRv2jRNF8XcteiRdOqqur27cvq43FjY8PPndvx5z/PW7Ro0XvvvdfHo/eSB/H/YQD6P5PJ9NBDk1ks0sWLO2Uyqa/LQQghlUr7zDPvBgfPIpHGicUzV67cUlenxja5JyvhcMmrV2/DGqurVR6TmDrYw/0oLJQ/8sgLDEY6mz15zpwNVVV1XSoeIaTXm1544UOpNINCSePxpo4du2L9+n9euVLk8e68DspiTZo2bV1RUblHN/dThaL+0UdfYjLTAwKmL168Ua3Wd/x2Dh48hxBKTIzpanlFReUPP/w8izWJwUifMePF4uIK9x7cfWprG+fOfZnJTOfxpi5d+pZeb6qoUM6evZ7FmhQY+MiyZZt1OqNHPUlJMe6q+pifH37r1jXvvffnDRs27N27t+8L6HGQuAD0R6+99ppG03j06Ps8Xr9YDr6+XjN69PIDB07v3v26RnNiz563jx+/PHbsCuwXtMt1KSNjIkLo5ZeX7NixAXtJcLBw8+ZVy5bNwM7udryHbisrqxk3blVe3p2DB9+rqTn8wgsLVq7c2qXiEUJLl7714Yd71q17Qq0+rlQe+fLL1+Xy2jFjnsa2tj073XrQ2tojb7zxp5Urt3h0dj945ZVPtm5dU119aO7c9O++O7Z+/T87fkfXr5cghEJDA90tnSxvxYp3/u//nq6tPfLzz+9eu3Y7NXVFRYXSo8+GDR+9/fbq6upDCxdO/eabo08+ufHFF7dv2/acQnEwI2Pi118f+etfP/KoB6vk+vXbHZfde9avf3L16oxVq1aq1T3w7zPfgsQFoN/RarW7du18883M/nOngY0bd1ZW1r3zzjNTp45hMKhpaSM++OD58vLa9977Duvw8stLEEKffrrfYDBjLU1Nto8++vGllxZ3cg/ds2nTTp3OuG3bc5MmJTIY1PHjR65ePaerxWdl5SKExGIBnU4lkYhRUaEffbS+84Ompsa/+uqy9jqvWPFYTEwYm83461+fQggdP36543dUU6NCCHE4THdLJ8t7/fWnU1PjGQzq5MlJW7c+q9UaN23a5dEnM/NRrBis4CNHzq9b90TrlqNHL3i8hMtlIYQ6P1e8N7z77nMul2P37t0+rKFHQOIC0O9cuXLFYmlauHCqrwu559Chcwih6dNT3C3jx490tyOEkpJi09MT9HrTp5/ux1q+/PJwcnKce1XnP9xD95w4cQUhNGlSortl3LjhXS1+7tx0hND8+a+GhDyamfnOf/97ks9ndzDxqu2gY8cOa6/zqFFR2AORiI8QUir/4EDNYrEhhEike9OUOlle6xoeemg08pbu7mICA/29lldb2+jxEqwSi8Xacdm9isGgzpo1LivrlA9r6BGQuAD0O2q1mkQicjj9aOUdlUqLEBKJZrq/EeTzpyGEyspq3H2ww9wPP9xjszU7HM733/9+w4anurSHbmhs1CGE+Px75975fE5Xi9+9+/V9+7bOnZtuMlm++OLgE0+8NmTI/Bs3Sjo/aOtDUg9MJg17gK10/YeXh9BoZISQ3d7ibulkeWz2vb8w2IfQ0KBtrxj3RDyPlrblYZX03sXfnSQUchsbPf81MOBA4gLQ70ilUru9+fbtKl8Xck9AgD9CSKM54XJdav1jNp9295k6dczIkUPr6tRff33kxx9PBgcLU1KGdWkP3YBFS2PjvelIer2pG8VnZEzcu3dLY+Oxs2d3TJuWXFVVt3z5250fFMvgHiEWCxFCHl9vd6a81nOysHoEgh64OY9Wa0AIicWC+9/V/cjPL5NKB/yy4ZC4APQ7o0ePDg8P+/DDPb4u5B5sKYbTp3NbN547dyMlJbN1y4YNSxBC77337bZt/259gNv5PXTV1KljEEInT+a4Wy5eLOhq8ThccnW1CiGEx+PT0kb85z9vI4SKi8s7P+j58/n38y5aGzlyKEKosvLejOtOlte6ht9+u+Ku8z5hlYwYMfT+d9VtBQVlv/12ZcGCBT6soUtwOJzXJVMgcQHod/B4/ObNb3/++U9Hjpz3dS13bdqUOWSIZM2av+/de0qt1huNlsOHs5ct27x165rW3ebNmxQRIS4trXY4HI88MrYbe+hGYRwO8+WXPz516qrJ1HThws0tW77uRvGZme8UFspttub6es22bf9GCE2b1u7KzB6DZmfnffbZgft5F63NmjUOIXT1anHrxs6Ut2PH/uzsPJOp6dSpq6+88imXy9y06b7+NYPJySlGCM2enXb/u+oek6npqafeGjNm9KxZs3xVQ1f5+fl5XaIS1pwCoJ/KzMz8/vvvDhzY2sGv/l7S+tpT9wwdrdb49tu7Dxw4U12t8vdnjR4d++qry9reR2HHjv3PPPPut9+++eSTnms4dLwHr4N6tLfdihAqLJS/9NK/zp69gcOhsWPjP/jgeZlsYZeKP38+f+fOn8+cuVZT00CjUcLCgh5/fPLzzy/Avrz0Wph7UDweN2HCqO3bX4iImIvH4x2OC+29nfbeoAe7vTkiYm5YWNC5c591pjz3nsvLD/z5z++fOXPN6XSNHz/i/ffXxcSEdb6Y9spLScmsrlaVle3zyR2XDQbz7Nkv3b5dc+HCxfDw8L4voHvWrFlTWFh4+vRpj3ZIXAD6KYfD8fTTT3///Xdbtjz7l78swuFwvq4ItKu2tlEsnikUcuvrf7n/vR05cn7WrPU//LD5iSce6kz/3lvV8rvvjj311KZDh/4+Y4YPbl5bUFA2b95rBoP1xInfZDJZ3xfQbWvXrr1+/fq5c57z8OGsMgD9lJ+f39dff71167ZXXvl0woRnb92q9HVF4B4cLrm0tNr99OzZ6wih9PSEHtn5jBmpO3ZsWL16208/nemRHXbPgQOnn3323U8//Wvfx63d3vzWW18kJi4XCMS5udcGVtyi9s8qQ+IC0K/95S9/yc3NtVr94uOfXLVqq1I54C+QGDTWrHlPLq8xm5tOnszZsOFjFou+adOKntr5ypWPHTu23bez57Zv/8+JE/9atcpzRZFe5XK5fvzxZGzsoq1b//3mm2+dPn0mKCioLwvoEfA9LgADmMPh+OqrrzZufEOr1T799MwXX1wYHi7ydVEPtJMncz75ZN/58/lqtZ7LZaanJ7z55sro6NC+r6STXw/3f3Z78/ffH3/vve9u365csmTJm2++KZFIfF1UN23YsOHUqVM5OTke7ZC4AAwYTU1Nu3btev/9v9fU1Dz8cMry5TNnzkz1yXwWAHpQcXHFV18d+fe/f21s1C1atGjDhg0xMTF//LJ+7JVXXjl27Ni1a9c82uGsMgADBpVK/fOf/3znTum3335nt1Pnz39VLJ79/PMf5OXd8XVpAHSZXm/67LMDKSkrYmMX7NlzOjNzdVlZ2VdffTXQ4xbBWWUABh+FQvHNN9989dWXpaVlw4YNmTUrdfbstKSkmAfzTrpgoKirUx8+fP7w4fPYss8ZGXOXLVs2adKkwfT3duPGjfv27Sso8FyMBRIXgIHN5XJlZ2f/+OOPhw4drKioFAp5M2eOnTkzderUMXQ61dfVAXDXjRslhw+fP3gw++rVIgqFPHny5McemzNv3jw2u/ll7UMAACAASURBVF/cj7JnvfXWWz/88ENxcbFHOyQuAIPHzZs3Dx8+fOjQwcuXr5BIxDFjZBMmjBw/fkRKyjCfr0QPHkDFxRVnz14/dy7v9OlrNTUqkShoxoyZs2bNmjx5Mo1G83V1vehvf/vb119/XVLiebcJSFwABiGVSvXLL79kZWWdPXumvLyCSCQkJcnGjx8+fvzI1NR4Fovu6wLB4OR0OgsK5GfOXMeCtr5ezWDQx44dO378hGnTpiUkJDwgC7ls2bJl165dZWVlHu2QuAAMckqlMjs7Ozs7+/z5c9eu3XC5XEFB/ISEaOwnNTXe35/l6xrBAFZb25ibeys391Zu7u0LF/I1Gj2DQU9OTk5NHTdu3Ljx48eTSCRf19jX3n333U8//bS83PNuE5C4ADxA6uvrL1y4kJube/VqTm5ubmOjGo/HR0eHJSREJSREDxsWERcXIRT2wC3ewGBlszUXF5cXFZVfu3Y7N/f2tWu3DQYTkUiMi4tNTBydkJAwZsyYYcOG+fn5+bpSX3r//fe3b99eVeV5w01IXAAeXJWVlbm5uVevXs3NvZqbm6tWaxBCPB5HJpPGxobJZOExMWEymTQwkOfrSoFvWK324uKK4uLywsLy4uKKggK5XF7jcDiIRKJMFpuQkJiQkJCYmBgfH08mk31dbD/y4YcfvvfeezU1NR7tBJ9UAwDoD0JDQ0NDQzMyMrCnSqWyqKioqKiosLCwsLDwv//N0mi0CCF/f3Z0dFhEhCgiQhwREYz9CYfCg4zVapfLa8rKasrKqsvKasrKau7cqS4vv5uvQ4cOiY2VLVo0QSaTxcbGDh06lEiEpVfa1d71uJC4AIC7goKCgoKCJk+e7G6pr68vLCwsKiq6fft2WVnplStny8sr7HY7QojJpEdESCIiRFKpKDxcJJEIJZIAsVjA53N89w7AH7Na7dXVqpqahqqquqqq+rKyarm8tqyspqZGhZ3yDAwMiIiQRkQMSUl5OCYmRiaTRUZGQr52CSQuAKDLAgICAgICJk2a5G5xOp0KhaKsrEwul5eVlZWVlZ08WVhRcQQ7GkYIUamU4GChWCxwZ7BEEiAS8QMC/AUCLpkMv7j7QmOjTqXS1tdrFIp6LF8VCpVCoaqpaWho0GB9yGSyRBIslUpjY8fMmhUhlUojIiIiIiLodJjKfr8gcQEAPQCPx2PnolvHMELIYrFUVVXV1NRUV1f//kCRl5dbXV3tDmOEEIfDDAzkCwScgABuYCBPIOAIhdzAQJ5Q6M/lMrlcJpfLglTumE5n1GqNWq1RpdKqVJqGBp1S2djQoFOptEqluqFB19CgaW5uwTqTyeTgYJFYHBwSEiqTpYrF4pCQELFYLBaLAwMDfftGBjFIXABAL6LRaNHR0dHR0W03NTU11dTUqFSqhoaGurq6+vp67EFenrKhIb++vl6r1bXuT6dTuVwWl8vicplcLgOLYSyPGQwanU5hsxk0GoVGo3A4DDqdSqNRmMwBuZyC3d5sNlt1OqPFYrVYrHq92WxuslisRqPFHatarUGrNbV6bGg93ZVCIQsEgsDAQKFQGBQUPXJkoFAoxFoCAgIEAkFAQIAP3+ADi0AgtLS0eGnv+1IAAA8UKpUaGRkZGRnZXge73d7Q0KDRaLTeqFSa27fLtVqNVqszm80mk9nrTphMOo1GodOpHA4Th0MMBo1I9CMSCQwGFSHEZtPxeDyVSqZQSHg8ns1mtHohjUDwvJSFRqO0PdTWao1txzUYzA6HE3tstdqammwuF9LpjAghs7nJbm9pbm4xmZoQQnq92el0ms3WpiabwWAyGs0tLV4Og4hEIoNB53A4XC6Hy/Xncv3DwqQjR3LbEggELBZcS90fQeICAPopEomEnefsZH+9Xm+xWCwWi06nM5vNZrPZZDK1bkQIGQwGh8Nhs9ksFovL5aqo0CKEzOY6u93e0tJiNN7NTpfLhfVvM4TB6XR6NDIY9LYTiKhUKoVCcb8R7EtQDoeDw+GoVCqFwiKT8UIhGyHEZDIJBAKVSqXRaGw2m8Fg0Gg0BoPBZrNpNBqNRuNwOAwGA+YoDQIEAqG5udlLe9+XAgAA94PNZvfl8vf+/v7vvPPO6tWr+2xEMNARiUSXy+VwODxWAhk8d0cCAIDeQKfTzWbvp7IB8IpAICCE2p5YhsQFAICOQOKCroLEBQCA7oDEBV0FiQsAAN0BiQu6ChIXAAC6AxIXdBUkLgAAdAckLugqSFwAAOgOSFzQVZC4AADQHZC4oKsgcQEAoDsgcUFXQeICAEB3QOKCrsKW6my70CMkLgAAdAQSF3QVHOMCAEB3QOKCrsKWU257MwxIXAAA6AgkLugq7B7GOBzOox0SFwAAOkKn061Wq8Ph5V62AHgFiQsAAN2B3fLWYrH4uhAwYEDiAgBAd2CJCyeWQedB4gIAQHdA4oKugsQFAIDugMQFXQWJCwAA3QGJC7oKS9y2IHEBAKAjkLigq+x2O0KIRCJ5tEPiAgBARyBxQVfZbDaEEIVC8WiHxAUAgI6QyWQCgQCJCzrParUiSFwAAOgGGo0GiQs6DzvGJZPJHu2QuAAA8AdgoUfQJXCMCwAA3USn02HNKdB5NpsNh8PBzCkAAOgyOMYFXWK1WslkMlyPCwAAXQaJC7rEZDIxGIy27ZC4AADwByBxQZeo1Woej9e2HRIXAAD+ACQu6BKtVuvv79+2HRIXAAD+ACQu6BKNRgOJCwAA3QGJC7pEo9Fwudy27ZC4AADwByBxQZe0d4xL6PtSAACgn7Nara+99ppKpbJarQ0NDXK5XKfTSSQSm83W1NRksVh27dq1fPlyX5cJ+qn2jnEhcQEAwJPNZvvoo4+am5tb33bNaDS6H4tEIl/UBQaG2traoKCgtu1wVhkAADyx2ex58+YRCN6PSahU6sSJE/u2IjBgGAwGnU4XGhradhMkLgAAeLFy5crm5ua27X5+fo888kjbReoBwFRUVCCEQkJC2m6CxAUAAC8mTJgwZMiQtgv1IYQeffTRvq8HDBSVlZUIIYlE0nYTJC4AAHi3atUqPN7zl6TL5Zo+fbpP6gEDQmVlJY/HYzKZbTdB4gIAgHfLli3zSFwcDjd69Gg+n++rkkD/V1lZ6fVLXASJCwAA7eHxePPmzSMSie4WAoGQkZHhw5JA/1dRUQGJCwAAXeYxf6q5uXn27Nk+rAf0f/n5+cOGDfO6CRIXAADaNXHixMjISPf8qZCQkKioKN+WBPozs9lcWlo6fPhwr1shcQEAoCPu+VMkEmn+/Pm+Lgf0a/n5+U6nc8SIEV63QuICAEBHli9fjiWu3W6fNWuWr8sB/dqNGzdYLFZ4eLjXrZC4AADQER6PN2fOHIQQk8lMTU31dTmgX8vLyxs+fLjXy7gRrKsMAHhAWK3WpqYmhJDBYHA4HA6Hw2AwYJtaWlpar5ncGtY5JiYGIRQfH3/gwAH3JiaT6XUZSCKRyGAwsMdkMplGo7k74/F4Npvdo28L9C83btwYPXp0e1txrdfpBgCAfsXpdOr1eq1Wq9Pp9Hq92WxuamrS6XQ2m81sNhsMBpvNZjQaTSaTzWbT63UWi8Vms2m1WoSQyWTCbkWg0+l9/T48UShkKpWKEGKxWH5+fjQalUymcLlcCoVCpdLYbDaFQqHT6Uwmk0KhMJlMOp1OoVDYbDaTyWSz2Ww2m8PhYHsA/YfVauVyuZ9++umyZcu8doBjXABAX9NoNI2/U6vVjY2NWq1Wr9fr9XqdTvv7nwadTmc0mtq+nMNhkskkOp3KZNIoFBKTSaPTKWQyUSplUig8KpXMZjPweDyNRiGTiVh/HA4RiQQGg4YQotMpJBIRh8NxOAz3PrGXtB2LQiFRqV6WUHa5XDqdl9oQQmZzk91+94Kipiab1WpHCOn1JqfT1dzcYjJZEEJmsxXro9UasZdYrXa93tTUZLNaNZWVVTZbs9ncZDRarFa70WhuvU83EonE4dxNXzabzeX6t3rM5fF4AQEBfD6fx+Px+XwSifSH/13AfTp//rzVak1PT2+vAyQuAKAn2Ww2pVJZU1OjVCpra2uxWFWpVI2NDY2NDY2NarVa09LS4u7PYND4fA6Hw+RwGGw2nc9nRkSIOZxoNpvB4TCwPzkcJtaBTqdSKP0iOXA4HJfrZRk/hFB77fcJy3iTyaLTmfR6k05n1OvNOp1RrzdhLVqtpqpKkZ+PPTY0NuqcTqf75SwWUyDgCwRCHo/H5wv4fL5AIAgKCgoMDBSLxUFBQV7voA665NSpU5GRke0tf4HgrDIAoBvq6uoqKytra2tramrq6uqqq6vr6pQ1NdVKZZ1arcH64HC4gAAen8/h89lCIYfPd/+w+XyOUMjl8dh8PqefJOjg43K51Gp9Y6O+sVHX2KhTq/X19ZrfW/SNjXqVSlNXp7ZabVh/CoUsEolEIlFQkOj3B0FisVgikYSEhMC9kjojJSVl+PDhO3bsaK8DJC4AoF1arVYul8vl8traWqVSKZeXyeVlJSV33Cd7KRSySCQICuKJRHypVBQUxBeJ+NifEkkAkQhn0fq7piabUtlYW9v4v39qamsbq6qU2DlwhBCXy5FKpVJphFQqDQoKEolEUqk0KirKPUcMGI1GHo/33XffdXDRNiQuAAAhhOrr62/dulVSUlJSUnL79q2SktsVFVU2mw0hRCD4BQcHhIYGhoUFYT+hoYGhoYFisRD7ohQMViqVtqqqrrKyrrKyrqKitqKirqKirrJSaTDc/SdXUFBgZGTk0KFRQ4cOHTp0aHR0tFQqfTC/Mz506NCjjz5aX18vEAja6wOJC8ADp6WlpaSkpKCgoKSk5NatWyUlt0tKSvR6A0KIyaQPHRo6dGhwVFRIeLgIy1exWOjnB9fug3u0WmNFhbKyUllRobxzR1FSoigpUSgUdS6Xi0AghIWFREVFR0fHYBkcHx/P4XB8XXKvW7du3ZkzZ27cuNFBH0hcAAY/vV5/8+bNoqKiwsLC3Nyc69dvWCxNBIJfSEiQVCqSSkWxseEymVQqFYWHi9q7eB+AjtntzdXVqsLC8qKicrm8prCwoqCgTK83IoSCggJlMllsrCwhISEhISE6OtrPz8/X9fYkp9MZEhKyYsWKjRs3dtANEheAQUij0Vy6dOnSpUu5ubn5+XnV1TUIIYHAf/jwIfHx0vj4yPj4ITJZOIkE54RB71Io6vPzS/PzS/PySvPzS0tKqhwOB41GjYuTjRgxasyYMcnJyTExMQP933lZWVmTJk0qKirCFktpDyQuAIOBw+EoLCy8ePHixYsXL126WFJyx+VyRUWFJSZGxcdHDh8+JD4+MigI7qMOfMxqtRcUlOXl3cnPL71xo/Tq1SKLxcrhsJOTk5OTU5KTk5OTkwfislyrV6++cuXKtWvXOu4GiQvAQOVyuW7cuHHixInffjtx6dIlo9HEYNBGj5alpMhSUoYlJ8fxeAPvNxd4oLS0OG7cKLl0qeDSpcILF26Wl9fg8fiYmOiJE9OnTp2anp7OZPbKxc09q6WlRSwWv/jiixs2bOi4JyQuAANMbW3tiRMnjh8//ttvJ1SqBqGQ99BDiWlpw1NShsXFRcAUJzBw1dWpL10quHDh5smTV2/cKMHj8SkpyVOnTpsyZUpiYmK//er36NGjM2fOlMvlYWFhHfeExAVgYLh169aePXv2799382YBhUJOTY2fOnX0lCljRowYMtC/AwOgrYYG3W+/XTlx4srx41dqalT+/tyHH56+YMGCadOm9berj5YuXXrnzp0LFy78YU9IXAD6tYqKij179uzZ80NeXr5IJJw/P3369JS0tBE0GsXXpQHQR4qKyo8fv7x//5nz5/PYbNacORkLFiyYNGlSfzjq1Wq1Eolk27Zta9as+cPOkLgA9EcWi+X777/fvfuLS5cu+/uz581LX7BgyvjxI7yutg/AA6K6WvXf/57cs+dETk6RUChYsGDhs88+GxUV5cOS3n333bfffru6uprFYv1hZ/i/F4D+pba2dv369cHB4ueeWyOVco4c+YdSeXjHjg0TJ47qpbjF4ZKxn97YeVcHdTqdX311JDh4Vh/XM6Dl5BSlpz/rwwLS05/NySnqg4GCg4UvvrjwypXdd+7sXbt27uHD+2NiYqZMeejYsWN9MHpbDodjx44dmZmZnYlbBIkLQP9RX1//3HPPRURIf/jhm5deWqhQHPz2203Tp6f09urELtelXt1/5wc9fvzyyJFLdu8+VFPT0Mf1pKWtSktb1ceD9ohduw5Onbpu3bonfFjD2rWPT5mydufOn/tsxMjI4NdeW3bnzn8PHfo7Hm9++OGHx4wZffz48T4rAPPTTz9VVlZ25nwyBhIXAN9zOBz/+Mc/oqKG/vzz3vffXyuX73/llaUCweBfGM/D2rX/ePPNFWfPtnvrlfvX3tG80+lsfW+7vi+ge3755eLKlVt27Njw2GMTemqf3TBnzsSPP35p1aqtv/xysS/HxePxM2akHjv24ZUru4VC8rRp0x59dHZ5eXmfFbB9+/aZM2dGRER0sj98jwuAj1VVVS1e/GROTs5LLz358stLfDIlCsuAPj7YbTtoS4uDQPDr1Xp88k57qQC7vTkycl5ISEB29uf3v7f7l5KSWVvbWFq611f3jDp5Mmfdug8VCtXHH3+yePHi3h7u+vXro0aNOnny5KRJkzr5EjjGBcCXCgoKUlKSGxtrLl3a9dZbKx/wGchY3IJO2rcvS6GoX7Romq8LuWvRomlVVXX79mX5qoDJk5OuX//6hReeWLp06bp163r7ePKDDz6Ii4tLT0/v/EsgcQHwmdu3b48blxoXF5qTs3v48CG+Lud/qFTaZ555Nzh4Fok0TiyeuXLllro6NbbJPekJh0tevXob1lhdrfKYDNXBHnqpMISQXm964YUPpdIMCiWNx5s6duyK9ev/eeVKkbvy1m8hM/Mdj3fk3o+7pba2ce7cl5nMdB5v6tKlb+n1pooK5ezZ61msSYGBjyxbtlmnM7Yu77ffcmbPXs/lTqFQ0kaNWrJnz4nWW9sroHsf18GD5xBCiYn3FvL9w7eP/RQVlT/88PMs1iQGI33GjBeLiyvu/40jhJKSYtxV+QqRSNi0KfPrr9/45JOPX3/99d4bqLi4+Pvvv3/55Ze7dDU8nFUGwDccDseoUSNpNHTmzCc+v6OAx6nO+nrNmDFPW632b77ZOHZs/PX/Z+++45q6+j+AHxIIWYQEEvYOIEORqYLgwmJx1RZbleIsjmor2tpatXXVKmqHbfXRVqvVVuuqWldFrVpBRZaCAgIyIoQRAhlACJm/P26b8gPEgIQQ+L5fvPqKl3vP+V4eHz6ee88990HB7NkbcThcVtZhOt0MIRQT88mZM7c++WTOtm3/TZHdsuVQcXHFoUOfadNC+047qUfjhc1Om/bxH3/c3rVrZXz8VBMT49LSyjVr9p49e0vT1PNabr8d2xIX9+ratfPs7Jjr1u3bs+f0pEkjCQSTL75YYmfHXLPmf3v3nlm48LUff1zT+qhp00bv379GIpHGx2+9di3typVdEyaM6KQjLX9c7Xl5zSgo4FRXX7a2tsC2aHn6YWFDdux4f+hQj/v3H8fFbWxpkWVlHXFxsX2ZE0cIVVXx7ewme3k55+efeF7NvebgwQvx8VuvXbsWGRmpi/ZjYmIKCwuzs7O79AQBjHEB0I9z587l5uYdObJe73Hb3oYN+zmc6q1b342KGk6lkiIi/L/5ZkVpaeXOnUexHT75ZA5CaO/eM2JxE7alubll9+5TH30Up2ULOirs5s1MhJC9PYtCIREIJoMGOe/evepleoyPf83b28XcnLp27TyE0KVLdxISZrTecvly25WGvvlmBZNJd3Ky+e67DxFCX3zx88ufV4e4XB5CqHUka3n6n366YORIPyqVFBkZkpi4VCBo2LjxwMufOINBQwj1/jzzDi1YMGXixLDNmzfpovHMzMyzZ89u3bq1qw/sQeICoB9Xr16NiPD38HDUdyEduHAhGSEUHR2q2TJqVIBmO0IoJMRn7Nggkahx794z2JZDhy6OGDHYx8dVyxZ0VFhMzFiE0JtvrnVyei0+fuvJk38xmeYvM00pMPCf1RVsbCzabLGzYyKEKiv5rfdXq1M1g0Xsf9y8vBdPne3ej0siaUEIEQj/TVPS8vTDwoZoPo8fPwwhdPXq/Tb7dPXENZVIJNJOau5N8fFTU1LuSCSSHm95zZo1ISEhkydP7uqB+plRBgCora3V/C7ra3g8AULIzq7tL5TiYq7m8yefzLl5M3PXruMrVsw0NsZ/9dWxX3/d2KUWdFHYwYOfTp4cfuxY0o0bGT/9dP6nn847Odn88ccOf3/P7vVoZkbGPmhGM222tL4xJxQ27Njx69mztyoqeI2NzdjGujrRy59Xh8hk08bGZplMYWr6z2USLU/f3Jyq+cxk0hFCtbWCNo136cQxMpkCIdR3Zv/Z2FiqVCo+n+/k5NSDzd6+ffvatWs3btzoxnrmkLgA6Ie7u/v586fUanUffA+BtbUFl1tbX3+NwXjuTcSoqOEBAZ4PHhQePnyJRqM4OFiFhg7pUgs6KuyNN8a88cYYlUp1507OF1/8nJSUOn/+lgcPjvRgGc/z1lvrrl1L27AhfvnytywsaKjVVKnOde/HZW9vVVDAEQobNPdxkXanX1cn0rzJkc8XIoRYLIb2/T6PQCBGCNnbs16+qR6RlVVAJpPs7e17ttlPPvlkwoQJXZqirAFXlQHQjzlz5hQWck6duqHvQjqALadw61Zm643JyQ9DQ+Nbb1m9eg5CaOfOX7dv/2X16tndaKHHCzMyGlFRwUMI4XC4iAj/Eye2IITy8/+7rouNwORyhUQiZTJ7+LmaO3dyEEIffhiLxW1Li7z9Ph0W0L0fV0CAJ0KIw6nWbHnh6beuE3P9ehpCKCpquLYn+XxYJd2+nNCzGhubv/76+OzZc3r2bQcnT55MTU394osvunc4JC4A+jF48OBFixYtXpz4+HGxvmtpa+PGeA8Px2XLvjx9+kZdnaihQXLxYsq8eZ8nJv6/1eymTx/HZts/fVqhVConTgzrRgu6KCw+fmtubklLi7ympn779l8QQq2nCvv5uSOE0tLyLlxIaT0o7xEREf4IoW3bDguFDfX14rVr/9d+nw4L6N6Pa8qUcIRQRkZ+642dnz5m374zKSnZjY3NN25krFmzl8Ew27jxpf4lhElPz0cITZ0a8fJNvSSFQjl//udicfNnn33Wg802NDR88MEH77zzTlBQUPdagKeDANAbqVT66qsTHj3K/uOPHeHhQ/VVRusrn5pZNgJBw5YtB8+e/buigmdhQRs2zGft2nkjRgxuc+y+fWfefXfHr79uevvttuPFzlvosFPU0WXYNhN/Om/2zp2c/fv/+PvvLC63lkwmurjYvvVW5IoVMzU3FzMy8uPjtxYVlfv5uR8+vN7T06nDYrq3hccTrFr1XVJSqlDY6Onp9NlnC2bMWNfmLDosQPsfeGsymZzNjnFxsU1O/kHL08dqLi09+/77X/39d5ZKpR41yv+rrxK8vV3a//y1P3FMaGh8RQWvuPh3/U6/b2xsnj1747Vr6ZcuXR49uicXv0xISDh69OiTJ0+YTGb3WoDEBUCfmpub33479sKFC+vXv/PJJ3P0tTweMFCXLt2ZMmXVb799PmPGeG32190il0ePJs2evfHChS8nTRrZ441r7/793NmzNwmFknPn/ggLC3vxAVrLyckJCgrav3//vHnzut0IXFUGQJ9IJNLvv5/5+utvtm074ucXd+WK3tb7BYZo0qSR+/atXrJk+7lzf+uxjLNnby1dumPv3o/1GLfV1XXvvPNFWNhCNzev7Oycno1blUq1ePHi0NDQuXPnvkw7kLgA6JmRkdH777+fm5vn4xMQHb0iPHxxUhLkLtDWokXTkpK+3bXruB5r+PbbE9eufb948et66b2ykr9y5S42e/q1aw+OHTt25UqSra1tz3axd+/ejIyM3bt3v+STBXBVGYA+5O7du59/vvnKlSQ/P49ly2Li4l7tO083AkP3vPuvhuv+/dzvvz91+vQNJpP50UcfL1q0iEQi9XgvNTU1Xl5e77777tatW1+8d6cgcQHoczIzM7///vsTJ46bmhKmTRs1c+Yr48eHwHt1AMAUF3OPH7924sRfjx4VBQYGLFv23ttvv21qaqqj7l5//fXs7OzHjx+TyeSXbAoSF4A+is/n//rrrydOHL9/P83Skh4TM2bmzFdGjfLv6lKuAPQP5eU1J0/+deLE9fT0PCsr1vTpb8bFxYWGhr74yJdw4MCBxYsXX79+vXtLXrQBiQtAX1dWVnb8+PETJ44/fJhtY8OcMGF4VNSw8eOHWVn1wDpBAPRlcrkiNfXx1av3r15Ny8jINzenvf76GzNnzhw3blzPLm3RoZKSEn9//2XLlm3btq1HGoTEBcBgPHny5MyZM1evJt29e0+hUPj7D3rllZCoqGEjRw4lEgn6rg6AHlNY+OzatbSrV9Nu3sxsaGhyc3N95ZWoyZMnR0VFEQi99FddoVBERES0tLSkpqb2VKeQuAAYnsbGxps3b167du3q1aSCgkIymRQS4h0aOjg0dMiIEYNh7AsMjkwmf/CgMDX1cWrq4zt3HpWXV9NoZmPHjo2KmhAVFeXu7t77JW3YsGHHjh3p6emDB3e2DkmXQOICYNg4HM5ff/11586d1NR7+flP1Go1m+0YGjp4+HCfsDC/IUPYsKoG6Ju43NrU1Mf37j1KTc3NzHwilbZYWDBGjBgxYkTo2LFjR4wYYWyst7+6d+/eHT169Lfffrt06dIebBYSF4D+o6GhITs7+86dOykpyffu3aurqzcxMfbwcPL1dfXxcQ0K8goJ8baxsdR3mWAgUiiUBQWcvLzS3NzSzMwnmZkFVVW1eDx+0CDPoKDg8PDwkSNHent794WJgY2NzoVRrgAAIABJREFUjYGBgW5ubn/++WfPvtoLEheA/kmlUj158iQrKysnJ+fhwwc5OTk1NTyEkL29tZ8fe+hQdz8/d09PJ09PJ817TwHoKUqlisOpKiwsz80tyc4uyskpzssrkcsVpqYEX1+foUMD/Pz8hg4dGhwcbGbWk+9z7BGzZ89OSkrKycmxsbHp2ZYhcQEYKGpqarKzs7Ozs3NycrKzHz55UiCXyxFCdnZWgwY5eXo6eno6DRrk5Onp5OpqB4//Au3x+cKCgmcFBZzCwmeFheWFheVPn5a3tMgQQra2Nn5+fv7+AX5+fn5+fl5eXnq8VqyN3bt3JyQkXLp06dVXX+3xxiFxARigFApFaWlpQUFBQUFBYWFhYWFBQUFBVVU1QsjExNjNzcHNzc7FxcbZ2dbZ2cbFxdbZ2cbWtpuvTAH9g0QiLS2tLCur4nCqOZzqsrKqsrLqp0/L6+tFCCEymeTp6eHp6eXp6Tlo0CBPT09PT086na7vqrvg3r17Y8aMWb9+/bp163TRPiQuAOA/YrG4qKiosLCwsLCwpKSEwykrKyvjcisVCgVCiEg0dXa2dXGxdXa2dna2cXCwsrNj2dkxbW2ZDEafuzYIuqelRV5dXcfl1mL/5XCqOJzqsrJqDqeqtlaA7WNhwXBxcXZ2dnFxcXV3d8fC1dHRsWfvevaympqaoKCgwMDAc+fO6eh2MiQuAOAFFApFRUUFB4vff5RyOJzKyqqWlhZsHxKJaGfHsrW1tLOztLVl2tuzbGws7e1ZVlYMJpPOZNLhMnXfIRI18ngCPl9YU1NfUcHD/ltdXV9RUVtTU19bW6/Z08qK5ejo6OLiiqWrRh+8+fqS5HL5+PHjq6qq0tLSdDcuh8QFAHQfn8+vrq7mcrnV1dUVFRU1NTUVFRU1NdUVFRXV1TUymUyzJ4NBY7Gw9DVnMs1ZLLqVlYWlJQ3LYzqdSqebmZtTYSmPblOr1UJho1DYIBI1CgQNWKby+UI+X8TnC2tqBNiHujqhTCbXHMViMW1srO3tHWxsbB0cHKytrVv/t9eWm9C75cuXHzx4MDU1tQefvm0PEhcAoCu1tbW1tbV1dXV8Pp/H49XW1vL/Ucvj1fD5dXw+v7lZ2voQU1MCFr3m5lQ6/Z8vzR9JJFMajUKhkExNTeh0MyKRQCKZ0ulmpqYmFErPvzRGLxQKZUODpKmpuaVFLhQ2NDe3SKUyobBBKpVJJFKhsEEobBSJsK8mobBRJGr6948NrdvB4XBMpiWTybS0tGQyWVZWViwWi8lkYlusra2ZTOaAytROHDt27O233z58+PCcOXN02hEkLgBAn5qamvh8vlAoFP2r9WeBQCAUCrDNIpFYIpGIxQ3Pa8rMjEIkmpqZkSkUEoFgjMfjaTQyQohEMsWGzubmFBwOZ2yMxx6IolBIBIKJ5nAajYLHd3D3jk43a393sqlJ2nqkqNHQIFEolJo/CoUNarVaLlc0NjYjhBobm+VyBTYYRQi1tMglEilCSChsbGmRNTU1NzQ0tT68NVNTUzKZRKfT6XRzc3O6uTnd3Nwc+wOG/i/sM5PJNOi7qr0mJycnNDR08eLFX3/9ta77gsQFABgYiUQilUqFQmFzczP2QSqVSiQSkUjU0tLS2NjY0NCgUCjkcnljYyNCqKmpSSaTqdVqoVCAEGppaZFIJAih4uISPB5vbk5DCKlUKpFI1L4vhULR0NDYfjuBQKBQOniO2dTUFHunm0Kh4PFq2WxXIpGEx+NpNBpCiEQiEYkkhJC5uTkOhzM2NsZuiNJoNCKRSKVSqVQqkUik0WgUCsXU1JROp5NIJCKRyGDAyp06UVVVFRoa6uLicv369V54bAkSFwAwQLm6usbHx2v/HAiNRvvmm2/eeecdbXYWi8V0Ov3cuXNTp059iRqBDjU3N48dO5bP59+7d4/FYvVCj/pfTwsAAHqfUCjkcDgBAQE6ap9Go7m5uT18+FBH7YOXpFKpYmNjnz59evny5d6JW4RQn177AwAAdOTBgwdqtVp3iYsQ8vf3z87O1l374GWsWLEiKSnp+vXrnp6evdYpjHEBAANRbm6upaWlra2t7roYMmRIbm6u7toH3fb555/v2bPnyJEjYWFhvdkvJC4AYCAqKioaNGiQTrvw8PAoKSnBFq8Gfcfu3bs3bNiwZ8+e6dOn93LXkLgAgIGosLDQw8NDp114enrK5XIOh6PTXkCXHDlyJCEhYdu2bUuWLOn93iFxAQADUVFRUS8kLkKosLBQp70A7Z06dWrBggVr1qxZvXq1XgqAxAUADDhKpZLD4bDZbJ32QqPRrKysiouLddoL0NLx48djY2OXLVu2ZcsWfdUAiQsAGHCqqqoUCoWjo6OuO3JwcOByubruBbzQ8ePHZ8+evWjRol27dumxDEhcAMCAg6Wgg4ODrjuyt7evqKjQdS+gc8eOHYuLi1u5cuWePXv0u/IlJC4AYMCpqKjA4XA6fTQIA2NcvduzZ8/s2bPXrl27Y8cOfdcCiQsAGHiqqqqYTGYvvDbH3t4eEldf1Gr1Z5999v7772/dunXz5s36LgchWHMKADAA8fn83lnYj8lk8vn8XugItKFUKpctW3bgwIEffvhh4cKF+i7nH5C4AIABp66uztLSshc6srS0FIlESqUSj8f3QncA09zcPGvWrGvXrp09e3bKlCn6Luc/kLgAgAGnvr7ewsKiFzqysLBQqVRCobB3Ah4ghKqqql577bXi4uJr16718iKOLwT3cQEAA45AIOidN85iQVtXV9cLfQGEUE5OzogRIwQCwZ07d/pa3CJIXADAANTU1IS9Cl7XKBQKQkgikfRCX+DSpUvh4eGenp5paWleXl76LqcDkLgAgAFHJpOZmJj0QkdYLzKZrBf6GshUKtWmTZumTp0aFxf3559/9s4FjG6A+7gAgAFHJpP1wqNBCCGsF3h9kE4JBIK4uLjr16/v3r373Xff1Xc5nYHEBQAMOL2cuDDG1Z2HDx/GxMS0tLTcunUrNDRU3+W8AFxVBgAMOHBVuX84ePBgWFiYs7NzVlZW349bBIkLABiAei1xYYyrI2KxeNasWQsXLly+fPnVq1etrKz0XZFW4KoyAGDAkcvlvXNVGca4upCRkTFr1iyxWHzx4sXo6Gh9l9MFMMYFAAw4vXYfF4/H43A4mDnVU5RKZWJiYlhYGJvNzsnJMay4RTDGBQAMQHK53Ni4l377EQgEGOP2iOLi4rlz52ZkZGzduvXDDz/U73v3ugfGuACAAafXUlCtVstkMlNT017oq387cuSIv7+/SCS6d+/eqlWrDDFuESQuAGAAolAoTU1NvdCRVCpVqVTYylOge8rLy6OjoxcsWLB8+fLMzMyAgAB9V9R9cFUZADDg9FriYr1A4naPSqX63//+t3btWjs7u5SUlBEjRui7opcFY1wAwIADidv3FRUVRUZGrly5cunSpQ8fPuwHcYsgcQEAAxCVSoXE7bOam5s/++yzwYMHSySSrKysxMREIpGo76J6BlxVBgAMODDG7bMuXLiQkJBQV1e3Y8eO9957D4/H67uingRjXADAgAOJ2wdVVFS89dZbU6dO9fX1ffz4cUJCQj+LWwRjXADAAEShUOrq6rhcbnFxcXFx8bNnz+bMmePq6tojje/Zs0cul7PZbDabLRAIECTui4jF4sTExF27drm6ut64cWPs2LH6rkhXjNRqtb5rAAAAnbt161ZeXl5xcXFRUVFmZiaPx1MoFAghHA6nUqmOHj0aGxvb5pCDBw/u2rVL80vy6dOnLBbL3Nwc+6O1tXVSUlL7cZilpaVQKFSpVAghIyMjEonk7+/v5eWFZfD48eMtLS11e6qGQy6X//jjj5s2bVIqlZ9++ul7773XO+td6wuMcQEA/R+fz4+MjDQyMsLj8XK5vPVIA4vGDp/ylEgkjx49ar2lvLy8vLwc+ywSiXC4Dm7MBQQE3LhxA/usVqslEsndu3fT0tJwOJxMJvvss882b97cU+dl0K5fv75y5crCwsJ58+Zt2bKFxWLpuyKdg/u4AID+j8lkvv7661jmtb+wRyKRBg0a1P6oGTNmPO9WIoFAmDt3bocrHw0fPrz9os0KhUImkxkbGy9YsKBbZ9CvpKenjxkzJioqytvbOz8//4cffhgIcYsgcQEAA8TmzZuVSmWH3woMDOxwtMpisUaPHt1h6MpkspkzZ3bYWnBwcIdLSJqYmLzzzjsuLi5dKLrfwW6ZDx8+XCaTJScnnzx50s3NTd9F9R5IXADAgODj4zNjxoz2twkJBEInqyvMnj27w8ku3t7evr6+HR4SHBz8vPkx69at07re/qa8vPy9997z8PDIyMg4d+7c3bt3R44cqe+iehskLgBgoOhwmKtQKIKCgp53yBtvvNH+LUMmJiZz58593iGOjo4WFhbtD1myZImjo2MXS+4PysrKFi9e7O7ufvHixe+//z4nJ2fq1Kn6Lko/IHEBAAOFu7v7nDlz2gxzVSpVcHDw8w6h0WjR0dFtQlehUMyYMaOTjoYNG9bmFq+RkdHq1au7VbUBKysrS0hI8PLySkpK2rFjx5MnTxYtWtRr70nsgyBxAQADyMaNG9tc8qVQKO7u7p0cEhcX13pkbGRkNGzYsM5vx7aZPGViYrJ8+XJ7e/tuFm2ASkpKFi9e7OHhceHChe+++66oqCghIaHfLNbYbZC4AIABxNnZecGCBa2HucHBwZ2/bHXy5MlkMlnzRxwON2fOnM57CQoKamlp0fwRj8d/9NFH3S25D1EoFAUFBZ3vk5ubGxsb6+HhkZycfOjQoaKiokWLFvXvp2y1B4kLABhYNmzYoIlYU1PTF76UhkgkxsTEtM6M6dOnd35ISEiI5rOJickHH3xgZWXV3Xr7CpFIFBUVNXjw4IqKig53SElJmTJlypAhQ3Jycg4dOvTo0aO4uLj+t1Ljy4DEBQAMLHZ2dosXL8YSVCaTdTJtSiM2NlYulyOE8Hh8ZGTkC+PTxsZG84ApgUD48MMPX7pqPSsrKxs+fHhKSgpC6Oeff279LalU+tNPPw0ZMiQiIqKpqemPP/7IycmZM2cOZG17kLgAgAFnzZo12AO4arVam8SNjIzEph+r1eq4uDhtuhgxYoSRkZGxsfFHH33UfuqyYUlLSwsODi4pKZHL5QqF4ocffsAW6uLxeNu3b3d3d1+6dKm3t3dqauqNGzemTJnS4cPNAEHiAgAGIFtb2/feew8hRKPRtHmBgbGx8axZs7AP06ZN06aLkJAQtVpNJBITEhJeslr9Onv27KhRo0QiETbKRwhVVFQcOXIkISHBxcXlq6++iouLKy4uPnny5PDhw/Vbat83cGdpAwAGoJaWFolEghCaOXPm7t27vb29s7KyEEJqtVooFHayv42NDUIoMDDwypUrCCE8Hk+j0drvTyKRsBm5dDodIbRkyRKpVCoQCJ63fx/37bffrly5EiHUeoK3sbHxwoULPT09v/3227i4OBKJpL8CDQy8OwgAYDDEYrHgXw0NDRKJRCwWYx+ampqEQqFEIpFIJCKRsLGxUSKRNDY2KpVKsViMEBKLG563ymNvMjOjGhsbEwgECoViYmJMpZqZm5uTyWQymUKn0ykUCplMNjMzo9FoZDKZTCYzGAwzMzPGv3rtYValUvn+++/v3bu3w+/i8fjKysp+MB2sl0HiAgD0TC6X19bW1tbWVldX83i82tra+vr6f4NV80FQXy9oE5l4PJ5Go5iZUchkIoVCNDenksmmZLIpnW5GJhPJZCKNRjEyQnS6GUKIQiERCMYmJsZUKhkhZG5OweFwRCKBRDLFWjMzoxgbt53sg8MZmZtT29cslcqam1vabxeLm7Ai1WokFDYghBobm+VyhVyuaGyUIIREoiaVStXc3CKVylpaZBKJVChslEikEolUJGpqapJKJNKGBolY3CSRNEsk0jbtm5lRsei1sLBgMCw0ScxkMq2trVkslpWVlY2NDZXaQc3aa2xsnD59+vXr15/3bxRjY+OdO3euWLHiZXoZgCBxAQA6JxaLsffccblcLpdbW1vL4/Gqq6uwoOXz6zR7mpoSWCyGhYU5g2FmYWHGYGBfNOyDhQVN85lGoxAI/f8pT6GwQSxuEggaBIIGgUCMfaivF//7uRHbzuMJRKIGzVEkEpHFYtna2rJYLBbLytbW1srKysHBwcHBwdHR0cbGppPJTVwud8KECYWFhZobt+0ZGRmx2eyioqIePtv+DhIXANAzZDIZh8MpLS2tqKj4N18rysuflZdXiMX/hAGFQnJwsGax6FZWDBsbCxaLYWXFsLGxtLJisFh0GxvLDgeUQBstLfLaWkFNTX1NTX2rD0IeT1hVVVdbK6iu5mO/8E1MTGxtbRwdHR0dnezt7R0dHZ2cnBwdHd3c3IqLiydOnCgQtL2c0KF79+698Glm0BokLgCgy6RSaWVlZUlJSW5ubl5eXklJcUlJybNn5QqFAiFEJJra2bFsbS3t7Jhubna2tkw7O6abm72tLdPW1rLzBZ6A7shkcj5fVFXFLynhVlbyq6r4JSWVlZV1VVV8DqcKi1gjo+eGAolEwuPxZmZmOByOwWAQCIS9e/cOGzasd0/CsEHiAgBegMvl5uXlYeGam/u4sLAQuw6Mx+MdHKzZbHs2247NdnBzs2OzHVxd7RgMM32XDLpGJpOXl/OKiytu3coqLq6orRVyufyKihrsRrKpqambm6uPj6+Pj4+vr6+Pj8+gQYNaLxwNtASJCwD4fwQCQWZm5uPHj7F8zcvLEwpFCCEWy2LwYDdvb2dvbxc224HNtndxsR0Id1IHsurquuJibnFxRWHhsydPOI8flxYXlysUSmNjYzbbdfDgId7ePoMHD/b39/fw8ICFL14IEheAgU4sFufk5GT+Iz0/v0CtVjMYNB8fV19fVx8fV19fN19fV1tbpr4rBfonlyvKy2tyc0vz8kpzc0vy8ji5ucVSaYuZGdXPzy8oKDgoKCgoKMjb2xsCuD1IXAAGHKVSmZOTc/v27bt372ZkpJeUlCKE7O2tg4IGBQUNCgryCgrysrGx1HeZwDC0tMhzcooyM59kZj7JyCjIzS2WyxU0mllgYOCwYcMjIiIiIiLMzc31XWafAIkLwICgUCgyMzNv3759+/bfKSkpQqHIwsI8LGxIcLAXFrEwhAU9QiqV5eQ8xQL43r3H+fmlOBzOz2/I6NFjRo8eHR4ezmQO3L9pkLgA9GccDufixYsXL15ISUlpbGyysrKIiBg6enTg6NEBgwe7wXU/oGu1tcLk5Id//531998PHz16qlarfX19Xn01etKkSeHh4b22hFYfAYkLQH+jUqnS0tIuXLhw8eKFnJxHZmaUCRNGREYGjRoV4OPz4lX7AdARgaAhJSX71q3MS5fuFRSUMRj06OiJU6ZMmTBhAoPB0Hd1vQESF4D+Iz09/eeffz59+hSPV+vqaj95ctiUKRGjRwfAjGLQ1xQVlV+4kHLx4p3k5AcIGY0ePWrOnLkxMTEUCkXfpekQJC4ABo/H4/3666+HDh18/DjX29s1Lm7C1KkRgwez9V0XAC8mFDZcuZJ66tSNixdTiETim2++NX/+/JEjR+q7Lp2AxAXAgCUnJ3/zzdcXL14ik4kzZkTOnz95xIjB+i4KgO7g84VHjyYdOnQpO7tw0CDPd99d+s4777zkKxn6Gpg3AYBBunLlSlhY6KhRo2pqSg4eXFdZeeGHHz7RRdwaGY3Avnq85W50qlKpfv75koPDlF6uR+/S0/PGjl2qxwLGjl2anp6n0y6YTHpCwoyHD49kZh6OjByybt0aZ2enjRs3Yi9b7B8gcQEwMNnZ2ZGR46Kjoy0tjVNSfrxz58e4uFfJZKKOulOrU3XUclc7vXr1fkDAnIMHL3C5tb1fkh4dOHA+KiohIWGGHmtYvvytV15Zvn//H73QV2DgoD17PuJwziUkTP/uu2/c3dl79uzpC+82fnmQuAAYDJlMtnbt2pCQkObmupSUHy9c+HLkSD99F9V7li//etOmhbdv79N3IS+rS9cM/vzz3qJF2/btWz1t2midVtW5118fs2fPR4sXJ/75573e6dHS0nz9+neePj09b96rH3ywMiwsNDc3t3e61h24jwuAYaisrJw+Pebx40eJiUuXLHm9Nx+lxeKhlwe77TtVKJTYG+P1Uk8P0r5+mUzu7j7dyck6JeVH3df1YqGh8ZWV/KdPT5uY9OpztHl5pfHx27Kziw4c+GnWrFm92XXPgjEuAAagvLw8IiKcz6+8d2//0qUxA3PlCixuB5Tff79ZXl4TGztB34X8IzZ2wrNn1b//frOX+/XxcU1O3vf++9NjY2N37tzZy733oIH4/1sADEtjY+P48ZE0GuHevf2+vm76LgchhHg8wbvv7nBwmEIghNvbT160aFt1dR32Lc2kJyOjEUuWbMc2VlTw2kyG6qSFlyGVyhITjwQEzKFQxhCJEV5eM5Ys2Z6a+lizQ3V13eLFiVi/Dg5TlizZXlNTr/mupsjy8prXXvvIzGystXV0XNyGujqRlqePEBKJGleu3OXm9gaRGGFpGRUWtnDVqu/S0vI0XbTuKz5+ayenc/58MkIoONhb+8axr7y80ldfXUGjjaNSx06a9EF+fln7c6ys5MfEfGJmNtbSMmru3M0iUWNZWdXUqatotHE2NhPnzftcKGxoU09IiLemql6Gx+MSE5ft3Pn+6tWrT58+3fsF9Ai4qgxAX5eQkHDs2C85Ob/oa+njNldBa2rqhw9fIJXKjhzZEBbm9+BBwezZG3E4XFbWYTrdDCEUE/PJmTO3PvlkzrZt/02v3bLlUHFxxaFDn2nTQvtOO6lHo6FBMm7csoICztdfr5gyJZxCIWVk5C9duiM/vwzbubq6btiwBUql8pdfNoaE+KSl5cbFbTQ1Nbl//6C1tUXrxt9+e8K6dfPt7Jhr1vxv794z8+ZNwirXpvhp0z7+44/bu3atjI+famJiXFpauWbN3rNnb2kK1v6qspfXjIICTnX1ZU15WjYeFjZkx473hw71uH//cVzcxpYWWVbWERcX29b7xMW9unbtPDs75rp1+/bsOT1p0kgCweSLL5Zoznrhwtd+/HFN63qqqvh2dpO9vJzz80+8sHgdWbp054kTNwoLiywtDe9lGzDGBaBPEwgEBw7s37Qpvu+8aWDDhv0cTvXWre9GRQ2nUkkREf7ffLOitLRy586j2A6ffDIHIbR37xmxuAnb0tzcsnv3qY8+itOyhe7ZuHF/Rkb+558vjo+fam1tQaWSxowJPHp0s2aH9et/LC+v2b79vXHjgs3MyJGRIYmJSzmc6g0b9rdpauHCad7eLubm1I8/no0Qunr1vvanf/NmJkLI3p5FoZAIBJNBg5x3717VvTPicnkIIc2/QrRv/NNPF4wc6UelkrBzFAgaNm480Gaf+PjXsHNcu3YeQujSpTsJCTNab7l8+W6bQxgMGkJIv3PFd+x4T61WHjx4UI81dBskLgB9WlpamkTSPGtWlL4L+c+FC8kIoejoUM2WUaMCNNsRQiEhPmPHBolEjXv3nsG2HDp0ccSIwZpVnV/YQvecPn0TIdRmTm9AgKdm/Hfx4h2E0LhxwZrvjh8/DCF08WJKm6YCAwdhH+zsmAihqqr/Lhq/sPiYmLEIoTffXOvk9Fp8/NaTJ/9iMs27N89LImlBCBEI/01T0rLxsLAhbc6x9T8a2pyjjY1Fh2ddWclvcwhWiUQi7ca59BQqlTRlSvjNmzf0WEO3QeIC0KfV1dURCCZ0eh9aeYfHEyCE7Owma+4IMpkTEELFxVzNPtgwd9eu4y0tcqVS9dVXx1avnt2lFrqhqoqPEOrkzb61tQKEEJP537tamUy6pp7WzMzI2AdsSerWd99eWPzBg5/+/ntiTMzYxkbJTz+dnzFjnYfHmw8fFnbjjMhkU4SQTKbQbNGycXPz//7CYOeInXuH56iZiNdmS/t7jlglunv4W0tWVgw+v+2/BgwCJC4AfZqbm5tMJi8oeKbvQv6D3VOsr7+mVqe2/mpquqXZJypqeECAZ3V13eHDl06d+svBwSo0dEiXWuh2YVjudsjKioEQ4vP/mwbF5ws127vUS+fFv/HGmNOnt/H5Sbdv75swYcSzZ9Xz52/p8vkgZG9vhRBqM4NJm8ZbT/XCzpHF6oGX8wgEYoSQvT3r5Zt6GTk5xW5uBrlsOCQuAH3asGHDXF1ddu06ru9C/oNdtr11K7P1xuTkh6Gh8a23rF49ByG0c+ev27f/0nqAq30LXYVdcT137u/WG1NTHw8fvgD7PGVKBELor7/SNd+9fj1Ns11LLyzeyGhERQUPIYTD4SIi/E+c2IIQys8v1eyMjRHlcoVEIsXGx88TEOCJEOJwqjVbXtg45s6dnDbnGBU1XPtzfB6sEn9/z5dvqtsePy6+fj1t5syZeqyh2yBxAejTcDjc559v+fHHc5cu3dF3Lf/YuDHew8Nx2bIvT5++UVcnamiQXLyYMm/e54mJy1rvNn36ODbb/unTCqVSOXFiWDda6EZhgwez16//cf/+P2pq6hsbm5OSUufM2bR167vYDps2LXR2tvnkkz03bmQ0NEhu3MhYs2avs7PNxo1dSHptio+P35qbW9LSIq+pqd++/ReE0IQJ/y0y5efnjhBKS8u7cCGl9dC/vSlTwhFCGRn5rTd23jhm374zKSnZjY3N2DkyGGZdOsfnSU/PRwhNndqFf6D0rMbG5tmzNw8fPmzKlCn6quFlwNNBABiA+Pj4Y8eOnj2b2P53q661Xo9QM0NHIGjYsuXg2bN/V1TwLCxow4b5rF07r/17FPbtO/Puuzt+/XXT22+3Hcl13kKHnbbZ3v67CKHGxubt24+cOnWjtLTSzIwcFOT16afzIyL8NTvU1NRv2LD/woVkHk9gZcWYPDl88+ZFbR4Nat1yN07/zp2c/fv/+PvvLC6MNoAwAAAgAElEQVS3lkwmurjYvvVW5IoVMzW3PzMy8uPjtxYVlfv5uR8+vN7T0wk9h0wmZ7NjXFxsk5N/0LJxrODS0rPvv//V339nqVTqUaP8v/oqwdvbRftzfN7PPzQ0vqKCV1z8u17euCwWN02d+lFBAffu3Xuurq69X8DLg8QFwAAolcoFCxYcO3Z027alH34Ya2RkpO+KQC+5dOnOlCmrfvvt8xkzxmuzv+6WwDx6NGn27I0XLnw5aZIeXl77+HHx9OnrxGLptWvXfX19e7+AHgFXlQEwAHg8/vDhw4mJ29es2Tt69NInTzj6rgj0kkmTRu7bt3rJku1t7k/3srNnby1dumPv3o97P25lMvnmzT8FB89nsewzM7MMN24RJC4ABuTDDz/MzMyUSvF+fm8vXpzYyaRc0J8sWjQtKelb/c6e+/bbE9eufb948eu92alarT516i8fn9jExF82bdp869bftra2vVlAj4OrygAYGKVS+fPPP2/YsF4gECxYMPmDD2a5utrpuyjQJzzv/qvBkcnkx45d3bnzaEEBZ86cOZs2bXJ0dNR3UT0AEhcAg9Tc3HzgwIGvvvqSy+W++mro/PmTJ08eqZf5LAD0oPz8sp9/vvTLL1f4fGFsbOzq1au9vb1ffJiBgMQFwIDJ5fIzZ84cPPjT9et/WViYv/121Pz5k4cO9dB3XQB0jUjUePz4tZ9/vpya+sjJyXHu3HkLFy7sH+Pa1iBxAegPysvLjxw58vPPh54+LR4yxGPKlJFTp0aEhHgPzDfpAkNRXV138eKdixfvYMs+v/FGzLx588aNG9df/95C4gLQf6jV6pSUlFOnTl24cL6sjGNlZTl5ctjkySOjooZTKCR9VwfAPx4+LLx48c758ykZGXlEomlkZOS0aa9Pnz7d3Nz8xQcbMkhcAPqnR48eXbx48cKF8/fvpxEIJsOH+44eHTBqlH9o6BC9r0QPBqD8/LLbtx8kJ2ffupXF5fLs7GwnTZo8ZcqUyMhIMpms7+p6CSQuAP0cj8f7888/b968efv236WlZSYmxiEhvqNGDR01KmDkSD8ajaLvAkH/pFKpHj8u+fvvB1jQ1tTUUamUsLCwUaNGT5gwISgoaAAu5AKJC8AAUlVVlZKSkpKScudOclbWQ7VabWvLDArywr5GjvSzsKDpu0ZgwCor+ZmZTzIzn2RmFty9m1NfL6JSKSNGjBg5Mjw8PHzUqFEEAkHfNeoTJC4AA1RNTc3du3czMzMzMtIzMzP5/DocDufl5RIUNCgoyGvIEPbgwewuvcYODDQtLfL8/NK8vNKsrILMzIKsrAKxuNHExGTwYJ/g4GFBQUHDhw8fMmQIHo/Xd6V9BSQuAAAhhDgcTmZmZkZGRmZmRmZmZl1dPULI0pLu6+vm4+Pi6+vq7e3i6+vWyfveQf8mlcry88vy80tzc0vz88sePy4pKeEqlUoTExNfX5+goOCgoKDg4GA/Pz9TU1N9F9tHQeICADpQVVWVl5eXl5eXm5ubl5ebm5tbXy9ACFlYmHt5ubDZdmy2PZvtgP0XhsL9jFQqKynhFhdzi4sriou5xcXcoqKK0tJ/8tXT08PHx9fHx8fX19fHx8fT09PEBJZe0QokLgBAKzU1Nbm5uXl5eQUFBcXFT0tKSkpLy2QyGULIzIzCZjuy2XZubnaurnaOjlaOjtb29iwmk67vqkFnpFJZRQWPy6199qz62bOa4uKKkpLK4mIul8vDosHGxprNdmOzPdzd3b29vX19fd3d3SFfuw0SFwDQTSqVqry8vLi4uKSkpPgfT8vKyrDRMEKIRCI6OFjZ27M0GezoaG1nx7S2tmCxGKam8Iu7N/D5Qh5PUFNTX15eg+VreTmvvJzH5dbW1tZj+5iamjo6Ori5ubHZ7mw2283Njc1ms9lsCgWmsvckSFwAQA+TSCTPnj3jcrkVFRX/figvLy+vqKjQhDFCiE43s7Fhslh0a2uGjY0li0W3smLY2FhaWVkwGGYMhhmDQYNU7pxQ2CAQNAgEDTyegMerr60VVlXxa2uFPJ6gqqqutlZYW1svlyuwnU1NTR0c7OztHZycnB0cHOzt7Z2cnOzt7e3t7W1sbPR7IgMEJC4AoPc0NzdzuVwej1dbW1tdXV1TU/Pvh+ra2tqamhqBQNh6fwqFxGDQGAwag2HGYFCxGMbymEolUyhEc3MqmUwkk4l0OpVCIZHJRDMzg1xOQSaTNzVJhcIGiUQqkUhFoqampmaJRNrQINHEqkAgFggaW30Wt/4FTiSaslgsGxsbKysrKytr7AO2xdramsViWVtb6/EEAYLEBQD0KTKZrLa2tr6+XtCx+n//K2xqampsbOqwETMzCplMpFBIdLqZkRGiUskmJngTE2MqlYQQMjen4HA4EsmUSCTgcDhzc2qrA8nGxm0fZSGTie2H2gJBQ/t+xeImpVKFfZZKW5qbW9RqJBQ2IISampplMoVcrmhsbEYIiURNKpWqqUna3NwiFjc2NDQpFMr2DZqYmFCpFDqdzmDQGQwLBsOC8RwsFotGg2ep+zpIXACAAROJRBKJRCKRCIXCo0eP7t2794cffpDJZJqNCCGxWKxUKltaWiQSiVqtFgoFCKGmpqbi4hITE2PNoyxqtRrbv10XYpVK1WYjlUppP4GIRCIRif+soGlkZFRTw3N1dbGysjIyMiKRSEQiCYfDYUsHm5mZGRsbk0gkMplsbm5OpVKPHTuWnZ39+++/UygUMplMp9OpVCrMUepnIHEBAP1EUFCQn5/foUOHtNzf1dU1Pj5+3bp1Wu5Po9G++eabd955R5udxWIxnU4/d+7c1KlTtdn/0aNHfn5+ycnJ4eHhWtYDDE7/fCMSAGCgycnJycrK0jIOEUJCoZDD4QQEBOioHhqN5ubmlp2dreX+Q4YMCQwMPHjwoI7qAX0BJC4AoD84cOCAp6fnyJEjtdz/wYMHarXa399fdyX5+/trn7gIoQULFpw8ebKhoYM7xKB/gMQFABg8tVp95syZuLg47V9Hk5uby2Qy7ezsdFfVkCFDHj16pP3+M2fOlEqlV65c0V1JQL8gcQEABu/hw4dcLnfSpEnaH1JYWOjp6am7khBCnp6epaWlcrlcy/0tLS1HjBhx+fJlnVYF9AgSFwBg8C5dumRra9ulm7JFRUUeHh66Kwkh5OHhIZfLnz17pv0hkyZNunz5cvup0aB/gMQFABi8S5cuTZw4sUtvOO+dxMU60v6QSZMm8Xi8zMxMnRUF9AkSFwBg2IRCYXp6enR0tPaHKBQKDofj7u6uu6oQQubm5lZWVl1KXD8/PwcHh6SkJN1VBfQIEhcAYNjS09OVSmVYWJj2h1RVVSkUCicnJ91VhXFwcOByuV06JCwsLC0tTUf1AP2CxAUAGLa0tDQnJydbW1vtD8FS0N7eXmdF/cPe3r6riRsSEgKJ219B4gIADFt6evqwYcO6dAiXy8XhcL3wwpzuJW5NTU15ebmOSgJ6BIkLADBs6enpISEhXTqksrKSxWIRCAQdlaRhZ2fX1cQNDg42NjaGYW6/BIkLADBgAoGgsrJy6NChXTqKx+NZWVnpqKTWrKysamtru3QIhUJhs9mPHz/WUUlAjyBxAQAGrLi4GCHEZrO7dJRAILCwsNBNRf+PhYWFSCRSKjt4E18n3NzcSktLdVQS0CNIXACAASstLcXj8V2ddSwQCBgMho5Kas3CwkKlUolEoi4d5ebmVlJSoqOSgB5B4gIADFhJSYmDg0NX78jW19f32hgX665LR7m6ukLi9kuQuAAAA1ZaWurq6trVo8RiMfZmeF2j0+kIoQ5fdN8JNptdWVnZ3Nysm6KA3kDiAgAMGI/H69KTuJimpiYymayLetogkUgIoa5mp7W1tVqtrqur001RQG8gcQEABkwoFHZjtNrc3Ixloa51L3GxM+rqyBj0fZC4AAADJhQKsSu3XdLHExc7o67OtwJ9HyQuAMCAiUSi7o1xiUSiLuppg0Ag4PH47o1xIXH7H0hcAIABE4vFNBqtq0cpFApjY2Nd1NMeHo9XKBRdOoRMJuPxeLFYrKOSgL5A4gIADJharcbh+tvvMexFv2q1Wt+FgB7W3/6mAgAGFBwO19UVnQyCSqXC4/H6rgL0MEhcAIABw+PxKpVK31V0xsjIqKujVbVarVarIXH7H0hcAIABw+Px3RjjdiMFXwZ2lVh72BlB4vY/kLgAAANGIBBkMllXjzI1NW1padFFPW2oVCqZTNbVedFyuRwhZGJiopuigN5A4gIADJilpWU31mYikUi9s4aiVCpVq9VdffaXz+cjhJhMpm6KAnoDiQsAMGAsFqurL6BFCJFIJKlUqot62sB66eoYl8fjIUjc/ggSFwBgwPpl4mJnxGKxdFIT0B9IXACAAete4pqZmTU0NOiinjawXrq6RkdtbS2BQDAzM9NNUUBvIHEBAAbM1ta2oqKiq0cxGIyuvrO2ewQCAfp3nWTtcblcW1vbrs5wBn0fJC4AwIB5enpWVlZ2dUFEBoOBZaGuYb0wGIwuHVVQUODp6ambioA+9dLKogAAoAteXl5qtbqwsDA4OBjb0tTURKFQOjlEJpOp1eqSkpKvv/66qKgoPz+/tLT0u+++e+2119rsefDgwV27dmme3JXL5Zs2bdq1axf2R2tr66SkpPZPzQ4dOlStVvv4+Hh4eNTV1eHxeKlUSqVSOylJqVTK5XLN7d6CggLN6YD+BBIXAGDA3NzcTE1N8/PzW1pazp07d+LECT6fLxKJ2jzMqlQq16xZ8+DBgydPnlRWVmLLVK1du9bIyAib3NThQ70SieTRo0ett5SXl5eXl2OfRSJRh0s6V1dX83i83NxcbHUOlUrFYrGoVCqbzfb19U1ISBg2bFibQ9auXfvtt99GRUVNnz598uTJBQUFb7/99kv8VEAfBYkLADBULS0tN27coFKp7777blNTk2Y1jPZ3QOVy+f79+9u84731IhiBgYHt258xY8aKFSs6XNOKQCDMnTu3w1utISEhly9fVqlUrZefbGxszM7Ozs7OHjt2bPvEbW5uVigUly9fvnTpEkIIj8c/efKkvLzc0dGx858AMCxwHxcAYHjOnDkzY8YMS0vLiRMnisXipqYm9O84FY/Ht38TH5FIXLt27fPWTaRSqW5ubu23s1is0aNHd3iUTCabOXNmh60FBwcTCIT2242MjOzt7efMmdP+W0Qi0djYGBsQq1QqhUKxd+9eZ2fnoUOHbt26tbq6usOOgMGBxAUAGBgul/vmm2+ePn0aC1psTUSNDtMOIfT+++8zmcwOR6UBAQHPmxg8e/bsDldg9vb29vX17fCQwMDADpeQNDIy2rp1a4fltXlgV61WK5VKtVr96NGjdevWff311x12BAwOJC4AwMDY29tjt2A7/K6pqWmH24lE4vr169sfRSAQhg8f/ry+3njjjfYjZhMTk7lz5z7vkA4vUONwOGdn59jY2C7VjMPhbGxsPv744+f1BQwLJC4AwPBs2rQpPDy8w7X+n5deCKGFCxfa29u3me6kUCgCAgKedwiNRouOjm4TugqFYsaMGc87xMHBwcLCos1GtVq9Y8eO9uGNIRKJz3uX0enTp2G5x34DEhcAYHhwONyJEydoNFr72cKdJK6Jicnnn3/eJttUKlWHo1KNuLi41pOnjIyMhg0b5uLi0skhQUFBrQfTeDx+8ODBMTExz9u/w8TF4XDbtm0bOXJkJx0BwwKJCwAwSNbW1idPnmy/vfNFjOPi4tzd3VvnNIlE6ny5icmTJ5PJZM0fcThch7OfWgsJCWl9v1apVG7fvr2TNaTaJ66JiUlkZOSqVas67wgYFkhcAIChGjdu3OrVq9vMJe781Xh4PH7r1q2t483Pz6/Dx2o1iERiTExM6yvY06dP77ywwMBAzQO+xsbGw4cPj46O7ryL1o8S4fF4CwuLY8eOwUKP/QwkLgDAgG3evHnYsGGt4/CFL+qJiYnx9/fHcrrzaVMasbGx2IxoPB4fGRlpZWXV+f6BgYGaUFcoFImJiZ3v3yZx1Wo13L7tlyBxAQAGzNjY+OTJkxQKRTNO7XyJR4SQkZHRF198gd2a7XzalEZkZCQ2GUqtVsfFxb1wfxcXF+zNP8bGxpGRkWPGjOl8/9b/SsDhcFu3bg0PD39hL8DgQOICAAybg4PDsWPHNGPK1vdcnyc6Ojo0NBSHw6lUKm0S19jYeNasWdiHadOmvXB/IyMjrFmlUrlt27YX7q9JXOz27UcfffTCQ4AhglUeAQAGLzo6+uOPP/7yyy+VSmXn93E1duzYERERQSAQPDw8BAJBU1OTTCbDXvXT3Nzc+n31SqVSLBbb2NgghAIDA69cuWJqato6142MjLD38ZHJZFNTUzqdjl2svn379tSpU0NCQl5YDFYzDodjMBhHjx7t/L4yMFxGz3sIDAAADIhCoQgPD79///6cOXN27tzJ4/Fqamrq6uoEbdULBPVCoUgikdTV1cnlCp1WRaOZWVpakkgkBoNhYWHBYFgw/j9LS0t7e3sulxsWFobD4a5duzZu3DidlgT0CBIXAGB4ZDIZh8MpKyvjcDgVFRVVVVVVVZXl5eU5OY8QQq1nIVlYmDMYNAbDjMEwYzCo2Gc63YxCIcrlSgLBxN6eSaWSyWSiqamJuTkVhzMyMTGmUv/fpWk6ndp62nBTU7NM9l9Uy+WKxkYJQqipSSqTyQWCBrlcIRI1FhdXsFgMobChublFIGiorxcLBA0CQaNAgH0QS6X/bzFIKyvWkCFDbG3trK2tHRwcnJycXFxcXFxc2q+nAQwUJC4AoE8TiURPnjzJy8srKSkpKysrLS0pKyurqqrGYpVKJTs62tjYWNjZWVpbWxgbG9vbs4YMYVtbW1hbW1hamuu7/M40N7fU1gq43NqamvqbNzPNzanV1XVVVXXV1fWVlfyqqlrs9zONZubs7Ozi4uLq6ubi4uLt7e3l5eXs7AzPDhkcSFwAQB9SX1//4MGDgoKCvLy8J0/y8/PzKyurEEIkEpHNdnBxsXFxscW+nJ1tXFxsmUy6vkvWlZYWOYdTVVZWVVZWxeFUl5VVlZVVFxdX1NTUIYTIZNKgQYO8vLx9fHy8vLyGDBni4eEBN4D7OEhcAIA+CQSC3NzczH+k5+cXqNVqOt2MzXbw8XHx9XVzc7Pz8XH18nLB4yFOEEJIJGp8+rSipISbm1ual1eam1tWUFCmVCqpVMqgQYN8fHyDgoKCgoJCQkI6WfAS6AUkLgCgVymVyuzs7OTk5OTk5Hv37mJDWBcXu8DAQdhXQICnjY2lvss0JFKp7PHj4qysgqysgqyswkePnkqlLUSiaWBgYHh4RERExMiRIxkMhr7LBJC4AADdUyqV9+/fv3XrVkpK8p07d8TiBgsL85Ej/UaO9AsK8goK8mIwzPRdY/+hUCjz8kqzsgpSUx8nJ2fn55caGRn5+nqPGjUmIiIiMjISVrPSF0hcAICu8Pn8mzdvXr9+/fz5P6qra2xsmMHBXuHhQ8ePDwkI8ISbjr1DLG5KS8u7fj0tJeVRRkaeXK4ICPAfP/6VyZMnY48k6bvAAQQSFwDQw4qKio4fP37+/B9ZWQ9MTIxHjQp49dURkyaFDRrkrO/SBrqGBsm1a2l//nn3ypX7FRU1Vlas6OiJb775ZlRUVIcvGwY9CxIXANAzKisrT548+dtvx9LS0m1smNOmjYqODo2MDKZQtFoECvSy7OyiP/+8d+HCnXv3ciwsGG+++VZsbOzIkSNh1Ks7kLgAgJeiVCrPnz+/d+//bty4SaWSX399dGxs1LhxwTC12FBwONW//Xb1t9+u5eQUOTk5LljwzuLFi7FVLUHPgsQFAHSTQCD46aef9uzZ/exZeXR02IIFkydODCMSCS8+EvRJubklv/565aefLohETW+99dby5cu1WRQaaA8SFwDQZXV1dVu2bNm//0c8Hjdv3sT33nvTw8NR30WBniGVyn777ep33516+LAgLCz0iy+2vvBtg0BLkLgAgC5obm7+9ttvExO3EYkma9bMWbBgipnZi9+OBwzR7dsPtm49nJSUOnFi9PbtOwYPHqzvigweJC4AQFtnzpxJSFguFAo+/DB21aq3qVSYEtX/Xb+evnr1nuzsogULFnz55Zc0Gk3fFRkwmNoAAHixpqamhQsXxsTEREUFPn16euPGeB3FrZHRCOxLF433gpevPz09b+zYpd07duzYpenped3uukPjx4dkZBw6cmT9+fNnAgL8U1NTe7b9AQUSFwDwAg8fPgwMDDh37vezZ7f/9NM6a2sdvjxOre5Dv9AjIhZHRCzu0iEvWf+BA+ejohISEmZ0r4Dly9965ZXl+/f/8TI1tGdkZBQbOyE7+5dBg2wjIiK++OILuDjaPcb6LgAA0KfdvHlz2rTXgoIG3bz5jZ1dH10dEBtT9nhat37Pbi/48897ixZt++23z6dNG929Al5/fYxE0jJ79kYHB6vo6NCeLc/a2uLSpa++//7UqlUbS0pKfvzxRzwe37Nd9HtwHxcA8FyZmZljxoyeNCnsyJH1BEIvrUnUjfjUUeJ2T/eKkcnk7u7TnZysU1J+fMkCQkPjKyv5T5+eNjHRyZjq8uW706evnT9/wZ49e3TRfj8GV5UBAB0TCoWvvz4tLGzIL79s6LW4HbB+//1meXlNbOyEl28qNnbCs2fVv/9+8+Wb6tDEiWG//rpx3759hw4d0lEX/RUkLgCgY2vWrFEoWo4d26SjoRImN7dk4sSVVOpYc/PI119f/exZdft9rl9Pnzp1FYPxCpEYERg45/jxa62/q5mmhE1Zio/fquWBIlHjypW73NzeIBIjLC2jwsIWrlr1XVpaXuvWWs+B0mwpL6957bWPzMzGWltHx8VtqKsTPe/sgoPnaY6aOfPTTn4O588nI4SCg73bd9d6t+rqusWLEx0cphAI4Q4OU5Ys2V5TU9+mqZAQb02DOvLGG2NWrpy5cuWKuro63fXS/0DiAgA6UF1dfejQwc2bF1pamuuul+Jibnj44uzsovPnd3K5F1eunLloUWL73V555X08Hl9UdKqw8BSTSZ8167OkpP+u2Wqu36rVqWp16oEDa7U8cO7czbt2HU9ImFFXd7Wq6tKhQ5+WlFQOH76gTbPtO1qz5n+JicsqKi7ExIw9ejRp1arvnneCFy9+NXgwe/Xq2Wp16vHjWzr5UTx4UIgQcnb+b23F9gVUV9cNG7bg4sWUI0c21NVdPXx4/R9/3B4+fEGb0MUaefCgoJPuXt6mTQsJBOPvv/9ep730M5C4AIAOnD9/3tgYHxf3qk572bhxv1DYsH37e+PGBVOppFGjApYseb3DPb/5ZgWTSXdysvnuuw8RQl988bOWXXRy4M2bmQghe3sWhUIiEEwGDXLevXuVNm0uXDjN29vF3Jz68cezEUJXr97vcDcOpzoiYvGsWa8kJi57YZtcLg8hRKd39p7g9et/LC+vwX5cZmbkyMiQxMSlHE71hg37W+/GYNAQQlxurTbn0m0UCmn27AmnT5/SaS/9DCQuAKAD2dnZQUHeul4k+dq1NITQuHHBmi3h4UPb76ZWp7q42GKfseUk8/JKtWm/8wNjYsYihN58c62T02vx8VtPnvyLyTTXZsZTYOAg7AM2ebuqqoMrqwUFnIiIxVZWjLVr52lTqkTSghAiEDq7gH/x4h30/39c48cPQwhdvJjSejesEYlEqk2/LyM8fGheXr5MJtN1R/0GJC4AoANisdjcnKLrXvh8IUKIyfzvwjWTSW+zj1DYsHbtXm/vGWZmY42MRhgbhyGEOrl1qv2BBw9++vvviTExYxsbJT/9dH7GjHUeHm8+fFj4wpY1C1tiE8o6fOJj7NhldXWiu3cfHTuW9MIGEUJksilCSCZTdLJPba0AdfTj4vEErXfDGiGTidr0+zLMzalqtVosFuu6o34DEhcA0AEbG5tnz2p03QsWGHz+fykoEjW22eett9Zt23Z4xoxXOJw/sDu1WjauzYFvvDHm9OltfH7S7dv7JkwY8exZ9fz5nd1t1d7333+IXaNetuzLigreC/e3t7dCCAmFDZ3sY2XFQP//x4X9kwXbriEQiBFC9vas7tTdFRxOtampqYWFDldE6WcgcQEAHRg9evSjR0/Ly3UbulFRwxFCf/2Vrtly797jNvvcuZODEPrww1gLCxpCqKVF3r4dbDwnlyskEimTOUHLA42MRmBZiMPhIiL8T5zYghDKz9fqevULxcSMnT9/8muvjRIKG+bP//yFKx8EBHgihDicDqZqa0yZEoH+/4/r+vU0zXYNrBF/f8/u1q6tS5fujBoVAW+w1x78pAAAHYiKirKzs92581ed9rJxYzydbvbJJ3tu3MhobGy+e/fRtm2H2+wTEeGPENq27bBQ2FBfL1679n/t2/Hzc0cIpaXlXbiQEho6RPsD4+O35uaWtLTIa2rqt2//BSE0YUJPLun8449rWCz69evp3313svM9p0wJRwhlZOR3ss+mTQudnW2wH1dDg+TGjYw1a/Y6O9ts3Bjferf09HyE0NSpEc9ppmc8ecI5d+72ggXv6LSXfgbWnAIAdOzgwYOLFi26det/Hc5m6im5uSUfffT97dsPjYxQWJjfN9+s8PWdhX0Luw7M4wlWrfouKSlVKGz09HT67LMFM2asa70DQigjIz8+fmtRUbmfn/vhw+s9PZ20OfDOnZz9+//4++8sLreWTCa6uNi+9VbkihUzsRFz6wdhsf212UKnj9dcGD91auubb/73qBJCKD39UOsnbluTyeRsdoyLi21y8g/YlvaNI4Rqauo3bNh/4UIyjyewsmJMnhy+efOiNitdh4bGV1Twiot/1926JQqFcvTod6VSfFpaOqz1qD1IXABAx9Rq9bT/a+/+Y5q88ziAfxk/WoS2PIDQInatDiicUu3BokPcFiGGH/LjPG5uyrlEMN148YUAAArQSURBVMNkLCbq3dwf03NodEu2zOxHdMu27BSUuXk6BwLuFCoCGXTuRikYaLErUBhtaUulUNr7ozmug1GkQgv4fv1h+jzP5/n4RfPwzvOj3ycnu6Hh9p07Z1etWuHp4Sx9167d3rbtQGnpsRdeSHG5yblz1/Pzj1y9+k5GRtIcjs2RzWYrKDh+4cKNhoZGvDR3VnBVGQB+n5eX17lz57lc/rPP7mtt7fL0cJa+jIykjz/+2yuvnLx8+ZZrHb755ua+fac++ujQ/MWtxTK+Z0/Jl19WXrxYjridLZzjAoAzRqMxNzensbHhnXde3bs3x9PDWfqamqSHDp2+efMjF/Z97rmiU6deffrpuDkfld39+335+f/44Ye2r766lJaWNk9/yxKGxAWAGVgslrfeeuvYsWO5uc+dOfN3+6O/8Li5dOnfhYUnOJwV58+XCoXzeGt/CcNVZQCYgY+Pz5EjRyorK+vrpfHxuz799Mr4uFtfHAueJZXKs7MP5eUd3rnzr83NLYhblyFxAeChpKam/vTTf7Kz/1xU9LZQmH/1qnjmfWCRU6kGCguPx8fv6u7WVVVVnT59mk6f96msljAkLgA8rNDQ0A8++ODnn3+OjV2XnX1w48bCsrLqsTFnExPCItXWpigqOhUd/Zfq6h8/++yzlhZJSorrT1CDHe7jAoArGhsb33771OXL/2KzQ4qK/rR3b87y5ZOnRIZFx2q1VlTcef/98urqxqeeWl1c/FphYSGNRvP0uJYIJC4AuK67u/vDDz/85JOzJpNp27ZNL76Ymp6eRKPN18QLMH+kUnlpadX589VyuSo1NaW4+LW0tDTM4Di3kLgA8KhMJlNpaem5c/+8dauWyQzMzd380ktbn3/+j97e+H290HV395WVVZeWVt+92xEZuWLHjhf37NkjEAg8Pa6lCYkLAHOmp6envLy8vPxiff0dimJu2ZKQkpKYmbnJ/h5ZWCDGx60//thx9ar4229vt7TIgoJYmZnb8vLy0tPTMWXjvELiAsDcu3fv3pUrVyoqvqurE1ssloSEuPT0DSkpTyckxOKas6fI5T23bkkqKxuqqhq1Wv3q1fy0tIyMjIwtW7b4+uI/xR2QuAAwj4xGY01NTUVFRUXFd0rlL3Q6LTExbvNmYVKSMCkpnsmc95feP86sVmtrq7y2ViIW362ru6tS9dPptM2bN6elpaenp0dHz/vr/GASJC4AuElnZ6dYLK6trb19W9ze3uHt7b1mzeqEBIFIFCMSxQiFUf7+eCb2UXV1qZqbZS0t7S0tHU1NrTqdgclkJCUlbdqUnJycnJiYiC/UehASFwA8QK1Wi8Xi+vr6lpZmiUQyNKT38fEWCPgiUfT69dFxcXyB4Ekul+3pYS50BoNJJlPIZN13795raemQSNp1OoO3t7dAEC0SJSQmJiYnJ69duxZ3ZxcIJC4AeJjNZuvs7JRIJM3NzRJJi0QiGRj4lRASGLgsJuZJgYAbF8ePiXkyOprL43EYjGWeHq9nWCzjv/zS39Wlam+/L5XKZbLu9vb7SmUfIYRGo8XFxa5fL7ITCoXLlj2m/0oLHBIXABacwcFBmUzW1tYmk8na2qQymUyh6LZarYSQkJAgHo/D47H5/Agej8PjcbhcdlgYNemt7IuXyTTS0/NrX9+gXN4jl/coFL0KRZ9C0atU9lks44QQigqKiYmJi/uDQCAQCASxsbF8Ph9nsYsCEhcAFoGRkZGuri65XK5QKOx/KhRyhUIxOKixF/j6+oSFBXM4oWx2MJsdHBGxPCyMCglhURSDopgUxQgOZlIUw7NTOhiND7RavVZr0GoNGs2QVmvo79f29Q2q1RqV6tf+fq1K1W80muzFNBqNy13J5/N5PD6Px+PxeHw+n8/nh4eHe/BHgEeBxAWARcxgMCiVSrVa3dPT09/fr1Kp1Gp1X19vb29Pf/+ARqMdHx93rGexGBTFCA5m0Wi+AQH0wEB/X18fimL4+voEBvoHBPj7+fkSQpYtozt+i2nSolZrcOw5sajTGcbGLAaDyWQaMZvHhoaGx8Ysev3w8PCIVqvXavWjo2OOOzIYgaGhoRwOJywsfMWKFWFhYREREWw2m81mczgcDoeDKZ+WGCQuACxler1eo9Fof0uj0ZjN5uHhYaPRODo6qtNpR0dHh4eHjUaD/cUMer3eMaoNBqPF8v8XNjAYgT4+Pg6LDPsik8nw86MxmUx/f3863Z/FYvn5+TEYjICAAIqiKIoKDg6mHOBbsI8bJC4AAIA74JIFAACAOyBxAQAA3AGJCwAA4A5IXAAAAHdA4gIAALgDEhfgYXn9z6T1Vqv1888/j4yMnLrJbaYbGwAsHD4zlwAAIYQQm802NdKqqqoOHjzIYrFUKpVHRmX3u2N7RMnJyYSQurq6uW0L8NjCOS7AIykuLj569Ghtba2nBzL3rFarfSpjAJgTmAEDYBbs55GOR43FYrHPNzR1k8fHBgALCs5xAR6J42x/AABOIHEB5l1NTU1WVhZFUXQ6XSQSlZWVOW6deOhJqVRmZ2czGIzw8PBdu3YNDg4+fJNJvH5ropjH4008YDU0NLR///5Vq1bR6fSQkJBnnnnmwIEDTU1NkzpM9HReDwAzswHAQ3Ny1DjflJOTMzAw0N3dnZqaSgiprKycuu/OnTulUqlOpysqKiKEvPzyyy40mVisqakhhHA4HLPZPLHy7NmzmZmZ9s/Z2dmEkPfee89oNJrNZplMlpub69hhUsMZ6wHAORwtALPgcuLK5XL757a2NkJIcnLy1H1v3rxpX5TL5YSQiIgIF5o4rhEKhYSQL774YmLN2rVrq6ur7Z+ZTCYhpLy8fGKr/XHr6RrOWA8AzuGqMsC8s9lsPB7P/jkqKooQIpVKp5aJRCL7h4iICEJIb2+vC00c7d+/nxDy7rvv2he///57q9WakpJiX9y+fTshJC8vj8vlFhQUXLx4MTQ01Db9g1ezrQeAyTwb+ACLi5OjZrpNWq329ddfFwgEgYGB0x16M65xrYnZbOZwOISQGzdu2Gy2rKysM2fOOBZcunRp+/btFEXZ9+VyuRKJxElD5/UA4BwSF2AWXEhc+z3XN998c3BwcLrKGde41sRms5WUlBBCMjIyOjs7ly9fbjKZpo5wfHy8trZ269athJB169bN+BNNVw8AzuH7uACz4OQ7r9NtCggIMJlMer2ewWAQQsxmM51On1Q5dd9Ja1xrQgjRaDQrV6588OBBenp6fHz88ePHHeuVSmVkZKR9cWhoKCgoiEajjYyM/G7DGesBwDncxwWYX/a5Ek+cOKHT6TQazeHDh93ZJDg4ePfu3Tab7fr16/v27Zu0taCgoLW11Ww2q9XqkydPEkLsZ67TmW09APyGh86tARaf6Q4c54eVWq3Oz88PCwvz8/Nbs2bNhQsXJpVN3XHqGheaTOjo6HjiiSd27Ngxab1YLN69ezePx/P19WWxWEKhsKSkZHh4eLqGzusBYEa4qgywxFmt1sjIyK+//nrDhg2eHgvAYw1XlQGWuGvXrq1cuRJxC+BxSFyApcnLy6uhoUGr1R49evSNN97w9HAAAIkLsHRt3LgxKioqMzMzKyvL02MBALytDwAAwC1wjgsAAOAOSFwAAAB3QOICAAC4AxIXAADAHZC4AAAA7oDEBQAAcAckLgAAgDsgcQEAANwBiQsAAOAOSFwAAAB3+C9stVQnXE/WVQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Save the 1st-level analysis graph as png\n", + "l1analysis.write_graph(graph2use='colored', format='png', simple_form=True)\n", + "\n", + "# Visualize the graph\n", + "from IPython.display import Image\n", + "Image(filename=f'{l1analysis.base_dir}/l1analysis/graph.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:03,738 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/l1analysis/graph.png (graph2use=flat, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show detailed workflow\n", + "l1analysis.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "Image(filename=f'{l1analysis.base_dir}/l1analysis/graph_detailed.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the Workflow\n", + "\n", + "Run the 1st-level analysis workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:03,780 nipype.workflow INFO:\n", + "\t Workflow l1analysis settings: ['check', 'execution', 'logging', 'monitoring']\n", + "200920-23:38:03,828 nipype.workflow INFO:\n", + "\t Running in parallel.\n", + "200920-23:38:03,834 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 20 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:38:03,919 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_10/getsubjectinfo\".\n", + "200920-23:38:03,921 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_09/getsubjectinfo\".200920-23:38:03,921 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_10/selectfiles\".\n", + "\n", + "200920-23:38:03,926 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200920-23:38:03,931 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")200920-23:38:03,931 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "\n", + "200920-23:38:03,939 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:03,943 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "200920-23:38:03,948 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "200920-23:38:03,922 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_09/selectfiles\".\n", + "200920-23:38:03,964 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:38:03,972 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:05,836 nipype.workflow INFO:\n", + "\t [Job 0] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:05,839 nipype.workflow INFO:\n", + "\t [Job 1] Completed (l1analysis.selectfiles).\n", + "200920-23:38:05,843 nipype.workflow INFO:\n", + "\t [Job 7] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:05,845 nipype.workflow INFO:\n", + "\t [Job 8] Completed (l1analysis.selectfiles).\n", + "200920-23:38:05,848 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 18 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:38:05,920 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_09/modelspec\".200920-23:38:05,920 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_10/modelspec\".\n", + "200920-23:38:05,922 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_08/getsubjectinfo\".\n", + "200920-23:38:05,925 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_08/selectfiles\".\n", + "200920-23:38:05,933 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "\n", + "200920-23:38:05,937 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:38:05,938 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "200920-23:38:05,940 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "200920-23:38:05,941 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:05,945 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "200920-23:38:05,969 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:05,973 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:07,838 nipype.workflow INFO:\n", + "\t [Job 2] Completed (l1analysis.modelspec).\n", + "200920-23:38:07,841 nipype.workflow INFO:\n", + "\t [Job 9] Completed (l1analysis.modelspec).\n", + "200920-23:38:07,845 nipype.workflow INFO:\n", + "\t [Job 14] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:07,849 nipype.workflow INFO:\n", + "\t [Job 15] Completed (l1analysis.selectfiles).\n", + "200920-23:38:07,854 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 17 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:38:07,934 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_10/level1design\".\n", + "200920-23:38:07,936 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_07/getsubjectinfo\".200920-23:38:07,935 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_09/level1design\".\n", + "200920-23:38:07,936 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_08/modelspec\".\n", + "\n", + "200920-23:38:07,965 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200920-23:38:07,970 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")200920-23:38:07,978 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "\n", + "200920-23:38:07,985 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/algorithms/modelgen.py:491: UserWarning: loadtxt: Empty input file: \"/output/workingdir/l1analysis/_subject_id_08/modelspec/art.sub-08_ses-test_task-fingerfootlips_bold_outliers.txt\"\n", + " outindices = np.loadtxt(filename, dtype=int)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:07,998 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:08,1 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:38:09,839 nipype.workflow INFO:\n", + "\t [Job 16] Completed (l1analysis.modelspec).\n", + "200920-23:38:09,841 nipype.workflow INFO:\n", + "\t [Job 21] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:09,847 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 14 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:09,905 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_08/level1design\".\n", + "200920-23:38:09,906 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_07/selectfiles\".\n", + "200920-23:38:09,911 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:38:09,916 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:09,937 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:38:11,842 nipype.workflow INFO:\n", + "\t [Job 22] Completed (l1analysis.selectfiles).\n", + "200920-23:38:11,844 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:11,902 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_07/modelspec\".\n", + "200920-23:38:11,908 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/algorithms/modelgen.py:491: UserWarning: loadtxt: Empty input file: \"/output/workingdir/l1analysis/_subject_id_07/modelspec/art.sub-07_ses-test_task-fingerfootlips_bold_outliers.txt\"\n", + " outindices = np.loadtxt(filename, dtype=int)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:11,925 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:13,844 nipype.workflow INFO:\n", + "\t [Job 23] Completed (l1analysis.modelspec).\n", + "200920-23:38:13,849 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:13,911 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_07/level1design\".\n", + "200920-23:38:13,946 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:38:15,846 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 12 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:16,530 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:16,559 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:17,847 nipype.workflow INFO:\n", + "\t [Job 3] Completed (l1analysis.level1design).\n", + "200920-23:38:17,849 nipype.workflow INFO:\n", + "\t [Job 10] Completed (l1analysis.level1design).\n", + "200920-23:38:17,856 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 14 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:17,916 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_10/level1estimate\".\n", + "200920-23:38:17,917 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_09/level1estimate\".\n", + "200920-23:38:17,923 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:17,929 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:18,448 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:19,848 nipype.workflow INFO:\n", + "\t [Job 17] Completed (l1analysis.level1design).\n", + "200920-23:38:19,853 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1design\n", + "200920-23:38:19,912 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_08/level1estimate\".\n", + "200920-23:38:19,919 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:21,852 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 12 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1design\n", + "200920-23:38:22,425 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:23,852 nipype.workflow INFO:\n", + "\t [Job 24] Completed (l1analysis.level1design).\n", + "200920-23:38:23,855 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:38:23,927 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_07/level1estimate\".\n", + "200920-23:38:23,938 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:25,854 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 12 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:38:27,642 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:38:27,856 nipype.workflow INFO:\n", + "\t [Job 4] Completed (l1analysis.level1estimate).\n", + "200920-23:38:27,860 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:38:27,875 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:38:27,926 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_10/level1conest\".\n", + "200920-23:38:27,946 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:38:29,858 nipype.workflow INFO:\n", + "\t [Job 11] Completed (l1analysis.level1estimate).\n", + "200920-23:38:29,864 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:38:29,905 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:38:29,925 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_09/level1conest\".\n", + "200920-23:38:29,945 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:38:31,860 nipype.workflow INFO:\n", + "\t [Job 18] Completed (l1analysis.level1estimate).\n", + "200920-23:38:31,863 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 13 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1estimate\n", + "200920-23:38:31,938 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_08/level1conest\".\n", + "200920-23:38:31,951 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:38:33,859 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:38:33,864 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 12 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1estimate\n", + "200920-23:38:35,430 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:38:35,863 nipype.workflow INFO:\n", + "\t [Job 25] Completed (l1analysis.level1estimate).\n", + "200920-23:38:35,866 nipype.workflow INFO:\n", + "\t [Job 5] Completed (l1analysis.level1conest).\n", + "200920-23:38:35,872 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 14 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + "200920-23:38:35,933 nipype.workflow INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_10/datasink\".200920-23:38:35,934 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_07/level1conest\".\n", + "\n", + "200920-23:38:35,944 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:38:35,946 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/SPM.mat -> /output/datasink/1stLevel/sub-10/SPM.mat\n", + "200920-23:38:35,949 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmT_0001.nii -> /output/datasink/1stLevel/sub-10/spmT_0001.nii\n", + "200920-23:38:35,951 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmT_0002.nii -> /output/datasink/1stLevel/sub-10/spmT_0002.nii\n", + "200920-23:38:35,954 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")200920-23:38:35,955 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmT_0003.nii -> /output/datasink/1stLevel/sub-10/spmT_0003.nii\n", + "\n", + "200920-23:38:35,959 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmT_0004.nii -> /output/datasink/1stLevel/sub-10/spmT_0004.nii\n", + "200920-23:38:35,963 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmT_0005.nii -> /output/datasink/1stLevel/sub-10/spmT_0005.nii\n", + "200920-23:38:35,964 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmF_0006.nii -> /output/datasink/1stLevel/sub-10/spmF_0006.nii\n", + "200920-23:38:35,966 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/con_0001.nii -> /output/datasink/1stLevel/sub-10/con_0001.nii\n", + "200920-23:38:35,968 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/con_0002.nii -> /output/datasink/1stLevel/sub-10/con_0002.nii\n", + "200920-23:38:35,970 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/con_0003.nii -> /output/datasink/1stLevel/sub-10/con_0003.nii\n", + "200920-23:38:35,972 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/con_0004.nii -> /output/datasink/1stLevel/sub-10/con_0004.nii\n", + "200920-23:38:35,974 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/con_0005.nii -> /output/datasink/1stLevel/sub-10/con_0005.nii\n", + "200920-23:38:35,976 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/ess_0006.nii -> /output/datasink/1stLevel/sub-10/ess_0006.nii\n", + "200920-23:38:35,978 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/spmF_0006.nii -> /output/datasink/1stLevel/sub-10/spmF_0006.nii\n", + "200920-23:38:35,980 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_10/ess_0006.nii -> /output/datasink/1stLevel/sub-10/ess_0006.nii\n", + "200920-23:38:35,985 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:38:37,327 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:38:37,867 nipype.workflow INFO:\n", + "\t [Job 12] Completed (l1analysis.level1conest).\n", + "200920-23:38:37,870 nipype.workflow INFO:\n", + "\t [Job 6] Completed (l1analysis.datasink).\n", + "200920-23:38:37,875 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 13 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + "200920-23:38:37,936 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_06/getsubjectinfo\".200920-23:38:37,936 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_09/datasink\".\n", + "\n", + "200920-23:38:37,944 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200920-23:38:37,949 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:38:37,950 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/SPM.mat -> /output/datasink/1stLevel/sub-09/SPM.mat\n", + "200920-23:38:37,952 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmT_0001.nii -> /output/datasink/1stLevel/sub-09/spmT_0001.nii\n", + "200920-23:38:37,954 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmT_0002.nii -> /output/datasink/1stLevel/sub-09/spmT_0002.nii200920-23:38:37,955 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "\n", + "200920-23:38:37,957 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmT_0003.nii -> /output/datasink/1stLevel/sub-09/spmT_0003.nii\n", + "200920-23:38:37,960 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmT_0004.nii -> /output/datasink/1stLevel/sub-09/spmT_0004.nii\n", + "200920-23:38:37,962 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmT_0005.nii -> /output/datasink/1stLevel/sub-09/spmT_0005.nii\n", + "200920-23:38:37,964 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmF_0006.nii -> /output/datasink/1stLevel/sub-09/spmF_0006.nii\n", + "200920-23:38:37,966 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/con_0001.nii -> /output/datasink/1stLevel/sub-09/con_0001.nii\n", + "200920-23:38:37,967 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/con_0002.nii -> /output/datasink/1stLevel/sub-09/con_0002.nii\n", + "200920-23:38:37,969 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/con_0003.nii -> /output/datasink/1stLevel/sub-09/con_0003.nii\n", + "200920-23:38:37,970 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/con_0004.nii -> /output/datasink/1stLevel/sub-09/con_0004.nii\n", + "200920-23:38:37,972 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/con_0005.nii -> /output/datasink/1stLevel/sub-09/con_0005.nii\n", + "200920-23:38:37,973 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/ess_0006.nii -> /output/datasink/1stLevel/sub-09/ess_0006.nii\n", + "200920-23:38:37,974 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/spmF_0006.nii -> /output/datasink/1stLevel/sub-09/spmF_0006.nii\n", + "200920-23:38:37,976 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_09/ess_0006.nii -> /output/datasink/1stLevel/sub-09/ess_0006.nii\n", + "200920-23:38:37,981 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:38:39,317 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:38:39,869 nipype.workflow INFO:\n", + "\t [Job 19] Completed (l1analysis.level1conest).\n", + "200920-23:38:39,872 nipype.workflow INFO:\n", + "\t [Job 13] Completed (l1analysis.datasink).\n", + "200920-23:38:39,875 nipype.workflow INFO:\n", + "\t [Job 28] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:39,880 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 12 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + "200920-23:38:39,940 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_08/datasink\".200920-23:38:39,941 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_06/selectfiles\".200920-23:38:39,941 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_05/getsubjectinfo\".\n", + "\n", + "\n", + "200920-23:38:39,948 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")200920-23:38:39,948 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200920-23:38:39,948 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "\n", + "\n", + "200920-23:38:39,952 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/SPM.mat -> /output/datasink/1stLevel/sub-08/SPM.mat\n", + "200920-23:38:39,954 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:39,956 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmT_0001.nii -> /output/datasink/1stLevel/sub-08/spmT_0001.nii\n", + "200920-23:38:39,959 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmT_0002.nii -> /output/datasink/1stLevel/sub-08/spmT_0002.nii\n", + "200920-23:38:39,961 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmT_0003.nii -> /output/datasink/1stLevel/sub-08/spmT_0003.nii200920-23:38:39,961 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "\n", + "200920-23:38:39,963 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmT_0004.nii -> /output/datasink/1stLevel/sub-08/spmT_0004.nii\n", + "200920-23:38:39,964 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmT_0005.nii -> /output/datasink/1stLevel/sub-08/spmT_0005.nii\n", + "200920-23:38:39,965 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmF_0006.nii -> /output/datasink/1stLevel/sub-08/spmF_0006.nii\n", + "200920-23:38:39,966 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/con_0001.nii -> /output/datasink/1stLevel/sub-08/con_0001.nii\n", + "200920-23:38:39,968 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/con_0002.nii -> /output/datasink/1stLevel/sub-08/con_0002.nii\n", + "200920-23:38:39,969 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/con_0003.nii -> /output/datasink/1stLevel/sub-08/con_0003.nii\n", + "200920-23:38:39,971 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/con_0004.nii -> /output/datasink/1stLevel/sub-08/con_0004.nii\n", + "200920-23:38:39,973 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/con_0005.nii -> /output/datasink/1stLevel/sub-08/con_0005.nii\n", + "200920-23:38:39,975 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/ess_0006.nii -> /output/datasink/1stLevel/sub-08/ess_0006.nii\n", + "200920-23:38:39,977 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/spmF_0006.nii -> /output/datasink/1stLevel/sub-08/spmF_0006.nii\n", + "200920-23:38:39,978 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_08/ess_0006.nii -> /output/datasink/1stLevel/sub-08/ess_0006.nii\n", + "200920-23:38:39,982 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:38:41,871 nipype.workflow INFO:\n", + "\t [Job 20] Completed (l1analysis.datasink).\n", + "200920-23:38:41,874 nipype.workflow INFO:\n", + "\t [Job 29] Completed (l1analysis.selectfiles).\n", + "200920-23:38:41,876 nipype.workflow INFO:\n", + "\t [Job 35] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:41,879 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 10 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + "200920-23:38:41,938 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_06/modelspec\".200920-23:38:41,939 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_04/getsubjectinfo\".200920-23:38:41,939 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_05/selectfiles\".\n", + "\n", + "\n", + "200920-23:38:41,943 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")200920-23:38:41,944 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "\n", + "200920-23:38:41,947 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:41,949 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/algorithms/modelgen.py:491: UserWarning: loadtxt: Empty input file: \"/output/workingdir/l1analysis/_subject_id_06/modelspec/art.sub-06_ses-test_task-fingerfootlips_bold_outliers.txt\"\n", + " outindices = np.loadtxt(filename, dtype=int)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:41,963 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "200920-23:38:41,965 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:43,322 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:38:43,873 nipype.workflow INFO:\n", + "\t [Job 26] Completed (l1analysis.level1conest).\n", + "200920-23:38:43,876 nipype.workflow INFO:\n", + "\t [Job 30] Completed (l1analysis.modelspec).\n", + "200920-23:38:43,880 nipype.workflow INFO:\n", + "\t [Job 36] Completed (l1analysis.selectfiles).\n", + "200920-23:38:43,883 nipype.workflow INFO:\n", + "\t [Job 42] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:43,886 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:38:43,960 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_07/datasink\".200920-23:38:43,961 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_05/modelspec\".\n", + "200920-23:38:43,961 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_06/level1design\".\n", + "\n", + "200920-23:38:43,963 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_04/selectfiles\".\n", + "200920-23:38:43,967 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:38:43,969 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:38:43,971 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/SPM.mat -> /output/datasink/1stLevel/sub-07/SPM.mat\n", + "200920-23:38:43,975 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmT_0001.nii -> /output/datasink/1stLevel/sub-07/spmT_0001.nii200920-23:38:43,975 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "\n", + "200920-23:38:43,976 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmT_0002.nii -> /output/datasink/1stLevel/sub-07/spmT_0002.nii200920-23:38:43,977 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "\n", + "200920-23:38:43,979 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmT_0003.nii -> /output/datasink/1stLevel/sub-07/spmT_0003.nii\n", + "200920-23:38:43,980 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmT_0004.nii -> /output/datasink/1stLevel/sub-07/spmT_0004.nii\n", + "200920-23:38:43,982 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmT_0005.nii -> /output/datasink/1stLevel/sub-07/spmT_0005.nii\n", + "200920-23:38:43,983 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmF_0006.nii -> /output/datasink/1stLevel/sub-07/spmF_0006.nii\n", + "200920-23:38:43,985 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/con_0001.nii -> /output/datasink/1stLevel/sub-07/con_0001.nii\n", + "200920-23:38:43,987 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/con_0002.nii -> /output/datasink/1stLevel/sub-07/con_0002.nii\n", + "200920-23:38:43,989 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/con_0003.nii -> /output/datasink/1stLevel/sub-07/con_0003.nii\n", + "200920-23:38:43,990 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/con_0004.nii -> /output/datasink/1stLevel/sub-07/con_0004.nii\n", + "200920-23:38:43,992 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/con_0005.nii -> /output/datasink/1stLevel/sub-07/con_0005.nii\n", + "200920-23:38:43,994 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/ess_0006.nii -> /output/datasink/1stLevel/sub-07/ess_0006.nii\n", + "200920-23:38:43,996 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/spmF_0006.nii -> /output/datasink/1stLevel/sub-07/spmF_0006.nii\n", + "200920-23:38:43,997 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")200920-23:38:43,997 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_07/ess_0006.nii -> /output/datasink/1stLevel/sub-07/ess_0006.nii\n", + "200920-23:38:43,998 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "\n", + "200920-23:38:44,2 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:38:45,874 nipype.workflow INFO:\n", + "\t [Job 27] Completed (l1analysis.datasink).\n", + "200920-23:38:45,876 nipype.workflow INFO:\n", + "\t [Job 37] Completed (l1analysis.modelspec).\n", + "200920-23:38:45,878 nipype.workflow INFO:\n", + "\t [Job 43] Completed (l1analysis.selectfiles).\n", + "200920-23:38:45,882 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 8 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + "200920-23:38:45,958 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_04/modelspec\".200920-23:38:45,958 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_05/level1design\".\n", + "200920-23:38:45,959 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_03/getsubjectinfo\".\n", + "\n", + "200920-23:38:45,963 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200920-23:38:45,965 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "200920-23:38:45,978 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".\n", + "200920-23:38:45,991 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:45,999 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:38:47,876 nipype.workflow INFO:\n", + "\t [Job 44] Completed (l1analysis.modelspec).\n", + "200920-23:38:47,879 nipype.workflow INFO:\n", + "\t [Job 49] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:38:47,884 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 6 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:47,944 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_03/selectfiles\".200920-23:38:47,944 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_04/level1design\".\n", + "\n", + "200920-23:38:47,948 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:38:47,954 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:38:47,985 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:38:49,877 nipype.workflow INFO:\n", + "\t [Job 50] Completed (l1analysis.selectfiles).\n", + "200920-23:38:49,881 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:38:49,941 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_03/modelspec\".\n", + "200920-23:38:49,950 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "200920-23:38:49,969 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:38:51,32 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:51,880 nipype.workflow INFO:\n", + "\t [Job 31] Completed (l1analysis.level1design).\n", + "200920-23:38:51,884 nipype.workflow INFO:\n", + "\t [Job 51] Completed (l1analysis.modelspec).\n", + "200920-23:38:51,890 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 6 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:38:51,952 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_06/level1estimate\".200920-23:38:51,952 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_03/level1design\".\n", + "\n", + "200920-23:38:51,960 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:51,998 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:38:52,957 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:53,881 nipype.workflow INFO:\n", + "\t [Job 38] Completed (l1analysis.level1design).\n", + "200920-23:38:53,884 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1design\n", + "200920-23:38:53,944 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_05/level1estimate\".\n", + "200920-23:38:53,954 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:55,96 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:55,884 nipype.workflow INFO:\n", + "\t [Job 45] Completed (l1analysis.level1design).\n", + "200920-23:38:55,887 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1design\n", + " * l1analysis.level1estimate\n", + "200920-23:38:55,951 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_04/level1estimate\".\n", + "200920-23:38:55,957 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:38:57,888 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 4 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1design\n", + " * l1analysis.level1estimate\n", + "200920-23:38:59,59 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:38:59,888 nipype.workflow INFO:\n", + "\t [Job 52] Completed (l1analysis.level1design).\n", + "200920-23:38:59,891 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:38:59,966 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_03/level1estimate\".\n", + "200920-23:38:59,978 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:39:01,892 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 4 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:39:02,67 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:39:03,893 nipype.workflow INFO:\n", + "\t [Job 32] Completed (l1analysis.level1estimate).\n", + "200920-23:39:03,897 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:39:03,962 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_06/level1conest\".\n", + "200920-23:39:03,979 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:39:04,107 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:39:05,896 nipype.workflow INFO:\n", + "\t [Job 39] Completed (l1analysis.level1estimate).\n", + "200920-23:39:05,901 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:39:05,964 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_05/level1conest\".\n", + "200920-23:39:05,986 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:39:06,116 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:39:07,896 nipype.workflow INFO:\n", + "\t [Job 46] Completed (l1analysis.level1estimate).\n", + "200920-23:39:07,900 nipype.workflow INFO:\n", + "\t [MultiProc] Running 3 tasks, and 5 jobs ready. Free memory (GB): 55.94/56.54, Free processors: 1/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1estimate\n", + "200920-23:39:07,972 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_04/level1conest\".\n", + "200920-23:39:07,994 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:39:09,900 nipype.workflow INFO:\n", + "\t [MultiProc] Running 4 tasks, and 4 jobs ready. Free memory (GB): 55.74/56.54, Free processors: 0/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1estimate\n", + "200920-23:39:10,99 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:39:11,454 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:39:11,901 nipype.workflow INFO:\n", + "\t [Job 53] Completed (l1analysis.level1estimate).\n", + "200920-23:39:11,904 nipype.workflow INFO:\n", + "\t [Job 33] Completed (l1analysis.level1conest).\n", + "200920-23:39:11,909 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 6 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + "200920-23:39:11,969 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_06/datasink\".200920-23:39:11,969 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_03/level1conest\".\n", + "\n", + "200920-23:39:11,980 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:39:11,984 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/SPM.mat -> /output/datasink/1stLevel/sub-06/SPM.mat\n", + "200920-23:39:11,986 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmT_0001.nii -> /output/datasink/1stLevel/sub-06/spmT_0001.nii\n", + "200920-23:39:11,988 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmT_0002.nii -> /output/datasink/1stLevel/sub-06/spmT_0002.nii\n", + "200920-23:39:11,990 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")200920-23:39:11,990 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmT_0003.nii -> /output/datasink/1stLevel/sub-06/spmT_0003.nii\n", + "\n", + "200920-23:39:11,993 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmT_0004.nii -> /output/datasink/1stLevel/sub-06/spmT_0004.nii\n", + "200920-23:39:11,994 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmT_0005.nii -> /output/datasink/1stLevel/sub-06/spmT_0005.nii\n", + "200920-23:39:11,996 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmF_0006.nii -> /output/datasink/1stLevel/sub-06/spmF_0006.nii\n", + "200920-23:39:11,998 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/con_0001.nii -> /output/datasink/1stLevel/sub-06/con_0001.nii\n", + "200920-23:39:12,0 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/con_0002.nii -> /output/datasink/1stLevel/sub-06/con_0002.nii\n", + "200920-23:39:12,2 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/con_0003.nii -> /output/datasink/1stLevel/sub-06/con_0003.nii\n", + "200920-23:39:12,7 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/con_0004.nii -> /output/datasink/1stLevel/sub-06/con_0004.nii\n", + "200920-23:39:12,9 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/con_0005.nii -> /output/datasink/1stLevel/sub-06/con_0005.nii\n", + "200920-23:39:12,10 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/ess_0006.nii -> /output/datasink/1stLevel/sub-06/ess_0006.nii\n", + "200920-23:39:12,13 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/spmF_0006.nii -> /output/datasink/1stLevel/sub-06/spmF_0006.nii\n", + "200920-23:39:12,15 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_06/ess_0006.nii -> /output/datasink/1stLevel/sub-06/ess_0006.nii\n", + "200920-23:39:12,20 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:39:13,460 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:39:13,902 nipype.workflow INFO:\n", + "\t [Job 40] Completed (l1analysis.level1conest).\n", + "200920-23:39:13,904 nipype.workflow INFO:\n", + "\t [Job 34] Completed (l1analysis.datasink).\n", + "200920-23:39:13,908 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 5 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + "200920-23:39:13,968 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_02/getsubjectinfo\".\n", + "200920-23:39:13,968 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_05/datasink\".\n", + "200920-23:39:13,971 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200920-23:39:13,982 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".200920-23:39:13,983 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "\n", + "200920-23:39:13,985 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/SPM.mat -> /output/datasink/1stLevel/sub-05/SPM.mat\n", + "200920-23:39:13,986 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmT_0001.nii -> /output/datasink/1stLevel/sub-05/spmT_0001.nii\n", + "200920-23:39:13,988 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmT_0002.nii -> /output/datasink/1stLevel/sub-05/spmT_0002.nii\n", + "200920-23:39:13,989 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmT_0003.nii -> /output/datasink/1stLevel/sub-05/spmT_0003.nii\n", + "200920-23:39:13,991 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmT_0004.nii -> /output/datasink/1stLevel/sub-05/spmT_0004.nii\n", + "200920-23:39:13,994 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmT_0005.nii -> /output/datasink/1stLevel/sub-05/spmT_0005.nii\n", + "200920-23:39:13,996 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmF_0006.nii -> /output/datasink/1stLevel/sub-05/spmF_0006.nii\n", + "200920-23:39:13,998 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/con_0001.nii -> /output/datasink/1stLevel/sub-05/con_0001.nii\n", + "200920-23:39:14,0 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/con_0002.nii -> /output/datasink/1stLevel/sub-05/con_0002.nii\n", + "200920-23:39:14,2 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/con_0003.nii -> /output/datasink/1stLevel/sub-05/con_0003.nii\n", + "200920-23:39:14,3 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/con_0004.nii -> /output/datasink/1stLevel/sub-05/con_0004.nii\n", + "200920-23:39:14,12 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/con_0005.nii -> /output/datasink/1stLevel/sub-05/con_0005.nii\n", + "200920-23:39:14,13 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/ess_0006.nii -> /output/datasink/1stLevel/sub-05/ess_0006.nii\n", + "200920-23:39:14,15 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/spmF_0006.nii -> /output/datasink/1stLevel/sub-05/spmF_0006.nii\n", + "200920-23:39:14,17 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_05/ess_0006.nii -> /output/datasink/1stLevel/sub-05/ess_0006.nii\n", + "200920-23:39:14,22 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:39:15,299 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:39:15,905 nipype.workflow INFO:\n", + "\t [Job 47] Completed (l1analysis.level1conest).\n", + "200920-23:39:15,908 nipype.workflow INFO:\n", + "\t [Job 41] Completed (l1analysis.datasink).\n", + "200920-23:39:15,911 nipype.workflow INFO:\n", + "\t [Job 56] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:39:15,915 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 4 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + "200920-23:39:15,976 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_02/selectfiles\".200920-23:39:15,975 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_04/datasink\".\n", + "200920-23:39:15,976 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.getsubjectinfo\" in \"/output/workingdir/l1analysis/_subject_id_01/getsubjectinfo\".\n", + "\n", + "200920-23:39:15,983 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:39:15,983 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200920-23:39:15,985 nipype.workflow INFO:\n", + "\t [Node] Running \"getsubjectinfo\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "\n", + "200920-23:39:15,986 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/SPM.mat -> /output/datasink/1stLevel/sub-04/SPM.mat\n", + "200920-23:39:15,989 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmT_0001.nii -> /output/datasink/1stLevel/sub-04/spmT_0001.nii\n", + "200920-23:39:15,991 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".200920-23:39:15,991 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmT_0002.nii -> /output/datasink/1stLevel/sub-04/spmT_0002.nii\n", + "\n", + "200920-23:39:15,993 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmT_0003.nii -> /output/datasink/1stLevel/sub-04/spmT_0003.nii\n", + "200920-23:39:15,995 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmT_0004.nii -> /output/datasink/1stLevel/sub-04/spmT_0004.nii\n", + "200920-23:39:15,996 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.getsubjectinfo\".200920-23:39:15,996 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmT_0005.nii -> /output/datasink/1stLevel/sub-04/spmT_0005.nii\n", + "\n", + "200920-23:39:15,998 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmF_0006.nii -> /output/datasink/1stLevel/sub-04/spmF_0006.nii\n", + "200920-23:39:15,999 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/con_0001.nii -> /output/datasink/1stLevel/sub-04/con_0001.nii\n", + "200920-23:39:16,3 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/1stLevel/_subject_id_04/con_0002.nii -> /output/datasink/1stLevel/sub-04/con_0002.nii\n", + "200920-23:39:16,5 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/con_0003.nii -> /output/datasink/1stLevel/sub-04/con_0003.nii\n", + "200920-23:39:16,7 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/con_0004.nii -> /output/datasink/1stLevel/sub-04/con_0004.nii\n", + "200920-23:39:16,8 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/con_0005.nii -> /output/datasink/1stLevel/sub-04/con_0005.nii\n", + "200920-23:39:16,10 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/ess_0006.nii -> /output/datasink/1stLevel/sub-04/ess_0006.nii\n", + "200920-23:39:16,12 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/spmF_0006.nii -> /output/datasink/1stLevel/sub-04/spmF_0006.nii\n", + "200920-23:39:16,14 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_04/ess_0006.nii -> /output/datasink/1stLevel/sub-04/ess_0006.nii\n", + "200920-23:39:16,20 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:39:17,907 nipype.workflow INFO:\n", + "\t [Job 48] Completed (l1analysis.datasink).\n", + "200920-23:39:17,910 nipype.workflow INFO:\n", + "\t [Job 57] Completed (l1analysis.selectfiles).\n", + "200920-23:39:17,912 nipype.workflow INFO:\n", + "\t [Job 63] Completed (l1analysis.getsubjectinfo).\n", + "200920-23:39:17,917 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 2 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + "200920-23:39:17,975 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_02/modelspec\".\n", + "200920-23:39:17,976 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.selectfiles\" in \"/output/workingdir/l1analysis/_subject_id_01/selectfiles\".\n", + "200920-23:39:17,980 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200920-23:39:17,983 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")\n", + "200920-23:39:17,987 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.selectfiles\".\n", + "200920-23:39:17,999 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".\n", + "200920-23:39:19,284 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:39:19,909 nipype.workflow INFO:\n", + "\t [Job 54] Completed (l1analysis.level1conest).\n", + "200920-23:39:19,912 nipype.workflow INFO:\n", + "\t [Job 58] Completed (l1analysis.modelspec).\n", + "200920-23:39:19,916 nipype.workflow INFO:\n", + "\t [Job 64] Completed (l1analysis.selectfiles).\n", + "200920-23:39:19,919 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:39:19,994 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_03/datasink\".\n", + "200920-23:39:19,996 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_02/level1design\".200920-23:39:19,997 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.modelspec\" in \"/output/workingdir/l1analysis/_subject_id_01/modelspec\".\n", + "\n", + "200920-23:39:20,7 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:39:20,9 nipype.workflow INFO:\n", + "\t [Node] Running \"modelspec\" (\"nipype.algorithms.modelgen.SpecifySPMModel\")200920-23:39:20,10 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/SPM.mat -> /output/datasink/1stLevel/sub-03/SPM.mat\n", + "\n", + "200920-23:39:20,11 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmT_0001.nii -> /output/datasink/1stLevel/sub-03/spmT_0001.nii\n", + "200920-23:39:20,13 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmT_0002.nii -> /output/datasink/1stLevel/sub-03/spmT_0002.nii\n", + "200920-23:39:20,14 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmT_0003.nii -> /output/datasink/1stLevel/sub-03/spmT_0003.nii\n", + "200920-23:39:20,16 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmT_0004.nii -> /output/datasink/1stLevel/sub-03/spmT_0004.nii\n", + "200920-23:39:20,17 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmT_0005.nii -> /output/datasink/1stLevel/sub-03/spmT_0005.nii\n", + "200920-23:39:20,19 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmF_0006.nii -> /output/datasink/1stLevel/sub-03/spmF_0006.nii\n", + "200920-23:39:20,23 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/con_0001.nii -> /output/datasink/1stLevel/sub-03/con_0001.nii\n", + "200920-23:39:20,25 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/con_0002.nii -> /output/datasink/1stLevel/sub-03/con_0002.nii\n", + "200920-23:39:20,26 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/con_0003.nii -> /output/datasink/1stLevel/sub-03/con_0003.nii\n", + "200920-23:39:20,28 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/con_0004.nii -> /output/datasink/1stLevel/sub-03/con_0004.nii\n", + "200920-23:39:20,30 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/con_0005.nii -> /output/datasink/1stLevel/sub-03/con_0005.nii\n", + "200920-23:39:20,31 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/ess_0006.nii -> /output/datasink/1stLevel/sub-03/ess_0006.nii200920-23:39:20,33 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.modelspec\".200920-23:39:20,33 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "\n", + "\n", + "200920-23:39:20,35 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/spmF_0006.nii -> /output/datasink/1stLevel/sub-03/spmF_0006.nii\n", + "200920-23:39:20,36 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_03/ess_0006.nii -> /output/datasink/1stLevel/sub-03/ess_0006.nii\n", + "200920-23:39:20,41 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:39:21,911 nipype.workflow INFO:\n", + "\t [Job 55] Completed (l1analysis.datasink).\n", + "200920-23:39:21,914 nipype.workflow INFO:\n", + "\t [Job 65] Completed (l1analysis.modelspec).\n", + "200920-23:39:21,918 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + "200920-23:39:21,976 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1design\" in \"/output/workingdir/l1analysis/_subject_id_01/level1design\".\n", + "200920-23:39:22,10 nipype.workflow INFO:\n", + "\t [Node] Running \"level1design\" (\"nipype.interfaces.spm.model.Level1Design\")\n", + "200920-23:39:23,915 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 0 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + " * l1analysis.level1design\n", + "200920-23:39:26,990 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:39:27,917 nipype.workflow INFO:\n", + "\t [Job 59] Completed (l1analysis.level1design).\n", + "200920-23:39:27,922 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1design\n", + "200920-23:39:27,981 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_02/level1estimate\".\n", + "200920-23:39:27,986 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:39:28,778 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1design\".\n", + "200920-23:39:29,919 nipype.workflow INFO:\n", + "\t [Job 66] Completed (l1analysis.level1design).\n", + "200920-23:39:29,924 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + "200920-23:39:29,986 nipype.workflow INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t [Node] Setting-up \"l1analysis.level1estimate\" in \"/output/workingdir/l1analysis/_subject_id_01/level1estimate\".\n", + "200920-23:39:29,993 nipype.workflow INFO:\n", + "\t [Node] Running \"level1estimate\" (\"nipype.interfaces.spm.model.EstimateModel\")\n", + "200920-23:39:31,923 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 0 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + " * l1analysis.level1estimate\n", + "200920-23:39:37,794 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:39:37,926 nipype.workflow INFO:\n", + "\t [Job 60] Completed (l1analysis.level1estimate).\n", + "200920-23:39:37,931 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1estimate\n", + "200920-23:39:37,994 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_02/level1conest\".\n", + "200920-23:39:38,10 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:39:39,526 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1estimate\".\n", + "200920-23:39:39,928 nipype.workflow INFO:\n", + "\t [Job 67] Completed (l1analysis.level1estimate).\n", + "200920-23:39:39,933 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + "200920-23:39:39,994 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.level1conest\" in \"/output/workingdir/l1analysis/_subject_id_01/level1conest\".\n", + "200920-23:39:40,12 nipype.workflow INFO:\n", + "\t [Node] Running \"level1conest\" (\"nipype.interfaces.spm.model.EstimateContrast\")\n", + "200920-23:39:41,932 nipype.workflow INFO:\n", + "\t [MultiProc] Running 2 tasks, and 0 jobs ready. Free memory (GB): 56.14/56.54, Free processors: 2/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + " * l1analysis.level1conest\n", + "200920-23:39:45,302 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:39:45,934 nipype.workflow INFO:\n", + "\t [Job 61] Completed (l1analysis.level1conest).\n", + "200920-23:39:45,939 nipype.workflow INFO:\n", + "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 56.34/56.54, Free processors: 3/4.\n", + " Currently running:\n", + " * l1analysis.level1conest\n", + "200920-23:39:46,1 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_02/datasink\".\n", + "200920-23:39:46,11 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:39:46,13 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/SPM.mat -> /output/datasink/1stLevel/sub-02/SPM.mat\n", + "200920-23:39:46,15 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmT_0001.nii -> /output/datasink/1stLevel/sub-02/spmT_0001.nii\n", + "200920-23:39:46,16 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmT_0002.nii -> /output/datasink/1stLevel/sub-02/spmT_0002.nii\n", + "200920-23:39:46,17 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmT_0003.nii -> /output/datasink/1stLevel/sub-02/spmT_0003.nii\n", + "200920-23:39:46,19 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmT_0004.nii -> /output/datasink/1stLevel/sub-02/spmT_0004.nii\n", + "200920-23:39:46,20 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmT_0005.nii -> /output/datasink/1stLevel/sub-02/spmT_0005.nii\n", + "200920-23:39:46,21 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmF_0006.nii -> /output/datasink/1stLevel/sub-02/spmF_0006.nii\n", + "200920-23:39:46,22 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/con_0001.nii -> /output/datasink/1stLevel/sub-02/con_0001.nii\n", + "200920-23:39:46,24 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/con_0002.nii -> /output/datasink/1stLevel/sub-02/con_0002.nii\n", + "200920-23:39:46,25 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/con_0003.nii -> /output/datasink/1stLevel/sub-02/con_0003.nii\n", + "200920-23:39:46,27 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/con_0004.nii -> /output/datasink/1stLevel/sub-02/con_0004.nii\n", + "200920-23:39:46,31 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/con_0005.nii -> /output/datasink/1stLevel/sub-02/con_0005.nii\n", + "200920-23:39:46,33 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/ess_0006.nii -> /output/datasink/1stLevel/sub-02/ess_0006.nii\n", + "200920-23:39:46,34 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/spmF_0006.nii -> /output/datasink/1stLevel/sub-02/spmF_0006.nii\n", + "200920-23:39:46,36 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_02/ess_0006.nii -> /output/datasink/1stLevel/sub-02/ess_0006.nii\n", + "200920-23:39:46,39 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:39:47,211 nipype.workflow INFO:\n", + "\t [Node] Finished \"l1analysis.level1conest\".\n", + "200920-23:39:47,937 nipype.workflow INFO:\n", + "\t [Job 68] Completed (l1analysis.level1conest).\n", + "200920-23:39:47,940 nipype.workflow INFO:\n", + "\t [Job 62] Completed (l1analysis.datasink).\n", + "200920-23:39:47,945 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200920-23:39:48,19 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"l1analysis.datasink\" in \"/output/workingdir/l1analysis/_subject_id_01/datasink\".\n", + "200920-23:39:48,32 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200920-23:39:48,34 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/SPM.mat -> /output/datasink/1stLevel/sub-01/SPM.mat\n", + "200920-23:39:48,36 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmT_0001.nii -> /output/datasink/1stLevel/sub-01/spmT_0001.nii\n", + "200920-23:39:48,39 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmT_0002.nii -> /output/datasink/1stLevel/sub-01/spmT_0002.nii\n", + "200920-23:39:48,40 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmT_0003.nii -> /output/datasink/1stLevel/sub-01/spmT_0003.nii\n", + "200920-23:39:48,43 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmT_0004.nii -> /output/datasink/1stLevel/sub-01/spmT_0004.nii\n", + "200920-23:39:48,45 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmT_0005.nii -> /output/datasink/1stLevel/sub-01/spmT_0005.nii\n", + "200920-23:39:48,46 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmF_0006.nii -> /output/datasink/1stLevel/sub-01/spmF_0006.nii\n", + "200920-23:39:48,48 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/con_0001.nii -> /output/datasink/1stLevel/sub-01/con_0001.nii\n", + "200920-23:39:48,51 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/con_0002.nii -> /output/datasink/1stLevel/sub-01/con_0002.nii\n", + "200920-23:39:48,54 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/con_0003.nii -> /output/datasink/1stLevel/sub-01/con_0003.nii\n", + "200920-23:39:48,56 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/con_0004.nii -> /output/datasink/1stLevel/sub-01/con_0004.nii\n", + "200920-23:39:48,59 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/con_0005.nii -> /output/datasink/1stLevel/sub-01/con_0005.nii\n", + "200920-23:39:48,62 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/ess_0006.nii -> /output/datasink/1stLevel/sub-01/ess_0006.nii\n", + "200920-23:39:48,65 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/spmF_0006.nii -> /output/datasink/1stLevel/sub-01/spmF_0006.nii\n", + "200920-23:39:48,68 nipype.interface INFO:\n", + "\t sub: /output/datasink/1stLevel/_subject_id_01/ess_0006.nii -> /output/datasink/1stLevel/sub-01/ess_0006.nii\n", + "200920-23:39:48,75 nipype.workflow INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t [Node] Finished \"l1analysis.datasink\".\n", + "200920-23:39:49,939 nipype.workflow INFO:\n", + "\t [Job 69] Completed (l1analysis.datasink).\n", + "200920-23:39:49,943 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 0 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "l1analysis.run('MultiProc', plugin_args={'n_procs': 4})" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "#Crashs information is stored in .pklz files\n", + "# In case of a crash use the following command\n", + "#!nipypecli crash " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inspect output\n", + "\n", + "Let's check the structure of the output folder, to see if we have everything we wanted to save. You should one image for each subject and contrast (``con_*.nii`` for T-contrasts and ``ess_*.nii`` for F-contrasts)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/output/datasink/1stLevel\r\n", + "├── sub-01\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-02\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-03\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-04\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-05\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-06\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-07\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-08\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "├── sub-09\r\n", + "│   ├── con_0001.nii\r\n", + "│   ├── con_0002.nii\r\n", + "│   ├── con_0003.nii\r\n", + "│   ├── con_0004.nii\r\n", + "│   ├── con_0005.nii\r\n", + "│   ├── ess_0006.nii\r\n", + "│   ├── spmF_0006.nii\r\n", + "│   ├── SPM.mat\r\n", + "│   ├── spmT_0001.nii\r\n", + "│   ├── spmT_0002.nii\r\n", + "│   ├── spmT_0003.nii\r\n", + "│   ├── spmT_0004.nii\r\n", + "│   └── spmT_0005.nii\r\n", + "└── sub-10\r\n", + " ├── con_0001.nii\r\n", + " ├── con_0002.nii\r\n", + " ├── con_0003.nii\r\n", + " ├── con_0004.nii\r\n", + " ├── con_0005.nii\r\n", + " ├── ess_0006.nii\r\n", + " ├── spmF_0006.nii\r\n", + " ├── SPM.mat\r\n", + " ├── spmT_0001.nii\r\n", + " ├── spmT_0002.nii\r\n", + " ├── spmT_0003.nii\r\n", + " ├── spmT_0004.nii\r\n", + " └── spmT_0005.nii\r\n", + "\r\n", + "10 directories, 130 files\r\n" + ] + } + ], + "source": [ + "!tree /output/datasink/1stLevel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize results\n", + "\n", + "Let's look at the contrasts of one subject that we've just computed. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn.plotting import plot_stat_map\n", + "\n", + "#Reminder the tests were \n", + "test_to_number = {\n", + " 1: 'average',\n", + " 2: 'Finger',\n", + " 3: 'Foot',\n", + " 4: 'Lips',\n", + " 5: 'Foot > others',\n", + " 6: 'activation'\n", + " }\n", + "subject_id = '01'\n", + "anatimg = f'/data/ds000114/derivatives/fmriprep/sub-{subject_id}/anat/sub-{subject_id}_t1w_preproc.nii.gz'" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "subject_id = '05'\n", + " \n", + "anatimg = f'/data/ds000114/derivatives/fmriprep/sub-{subject_id}/anat/sub-{subject_id}_t1w_preproc.nii.gz'\n", + "for contrast_id in range(1, 6):\n", + " plot_stat_map(\n", + " f'/output/datasink/1stLevel/sub-{subject_id}/spmT_000{contrast_id}.nii', title=test_to_number[contrast_id],\n", + " bg_img=anatimg, threshold=3, display_mode='y', cut_coords=(-5, 0, 5, 10, 15), dim=-1);" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "contrast_id = 6\n", + "subject_id = '09'\n", + "\n", + "plot_stat_map(\n", + " f'/output/datasink/1stLevel/sub-{subject_id}/spmF_000{contrast_id}.nii', title=test_to_number[contrast_id],\n", + " bg_img=anatimg, threshold=3, display_mode='y', cut_coords=(-5, 0, 5, 10, 15), dim=-1);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Sources:**\n", + "\n", + "\n", + "[General Linear Model for Neuroimaging](https://www.fmrib.ox.ac.uk/primers/appendices/glm.pdf)\n", + "\n", + "[Convolution](https://practical-neuroimaging.github.io/on_convolution.html)\n", + "\n", + "[General Linear Model (GLM)](http://mriquestions.com/general-linear-model.html)\n", + "\n", + "\n", + "**Special thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/seminar4/Introduction.ipynb b/seminar4/Introduction.ipynb new file mode 100644 index 0000000..1672ec4 --- /dev/null +++ b/seminar4/Introduction.ipynb @@ -0,0 +1,412 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# fMRI data preprocessing - Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adasegroup/NEUROML2020/blob/seminar4/seminar-4/Introduction.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "fMRI scans are saved in dicom format. For scientific analysis of brain images the nifty format (.nii files) are often used.\n", + "The conversion from dicom to nifty can be done with [dcm2niix](https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#Introduction) \n", + "\n", + "Many file are generated during fMRI sessions. These can arranged in many ways, thus a standard is needed how to arrange them. \n", + "Commonly used standard is [Brain Imaging Data Structure (BIDS)](https://bids.neuroimaging.io/).\n", + "\n", + "You can use [HeuDiConv](https://heudiconv.readthedocs.io/en/latest/) or [Dcm2Bids](https://cbedetti.github.io/Dcm2Bids/tutorial/) to automate the conversion from dicom to BIDS.\n", + "\n", + "![DICOM TO BIDS](https://www.incf.org/sites/default/files/articles/bids_standard-2.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's download the data we will be working with." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "action summary:\n", + " get (notneeded: 31)\n" + ] + } + ], + "source": [ + "%%bash\n", + "datalad get -J 4 -d /data/ds000114 \\\n", + " /data/ds000114/derivatives/fmriprep/sub-*/anat/*preproc.nii.gz \\\n", + " /data/ds000114/sub-*/ses-test/func/*fingerfootlips*" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ses-retest/\n", + " dwi/\n", + " sub-01_ses-retest_dwi.nii.gz\n", + " anat/\n", + " sub-01_ses-retest_T1w.nii.gz\n", + " func/\n", + " sub-01_ses-retest_task-overtverbgeneration_bold.nii.gz\n", + " sub-01_ses-retest_task-covertverbgeneration_bold.nii.gz\n", + " sub-01_ses-retest_task-linebisection_bold.nii.gz\n", + " sub-01_ses-retest_task-fingerfootlips_bold.nii.gz\n", + " sub-01_ses-retest_task-overtwordrepetition_bold.nii.gz\n", + " sub-01_ses-retest_task-linebisection_events.tsv\n" + ] + } + ], + "source": [ + "from utils import list_files\n", + "# The data is already in BIDS format\n", + "# The subjects peformed 5 tasks. We will focus on fingerfootlips task\n", + "list_files('/data/ds000114/sub-01/ses-retest')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz float32 [256, 156, 256] 1.00x1.30x1.00 sform\n", + "sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz int16 [ 64, 64, 30, 184] 4.00x4.00x4.00x2.50 sform\n", + "\n" + ] + } + ], + "source": [ + "%%bash\n", + "cd /data/ds000114/\n", + "nib-ls derivatives/fmriprep/sub-01/*/*t1w_preproc.nii.gz sub-01/ses-test/f*/*fingerfootlips*.nii.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With nibabel we can load a file and inspect its properties." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "import nibabel\n", + "from nilearn import plotting\n", + "import numpy as np\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", + "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anatomical dimensionality is 3 and fmri is 4\n", + "Anatomical voxelization:(256, 156, 256) fMRI voxelization:(64, 64, 30, 184)\n" + ] + } + ], + "source": [ + "print(f'Anatomical dimensionality is {anat.ndim} and fmri is {fmri.ndim}')\n", + "#The anatomical image have higher resolution then the fmri\n", + "print(f'Anatomical voxelization:{anat.shape} fMRI voxelization:{fmri.shape}')\n", + "#the data can be accessed as\n", + "data = np.array(anat.dataobj)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'EchoTime': 0.05,\n", + " 'FlipAngle': 90,\n", + " 'RepetitionTime': 2.5,\n", + " 'SliceTiming': [0.0,\n", + " 1.2499999999999998,\n", + " 0.08333333333333333,\n", + " 1.333333333333333,\n", + " 0.16666666666666666,\n", + " 1.4166666666666663,\n", + " 0.25,\n", + " 1.4999999999999996,\n", + " 0.3333333333333333,\n", + " 1.5833333333333328,\n", + " 0.41666666666666663,\n", + " 1.666666666666666,\n", + " 0.5,\n", + " 1.7499999999999993,\n", + " 0.5833333333333333,\n", + " 1.8333333333333326,\n", + " 0.6666666666666666,\n", + " 1.9166666666666659,\n", + " 0.75,\n", + " 1.9999999999999991,\n", + " 0.8333333333333333,\n", + " 2.083333333333332,\n", + " 0.9166666666666666,\n", + " 2.1666666666666656,\n", + " 1.0,\n", + " 2.249999999999999,\n", + " 1.0833333333333333,\n", + " 2.333333333333332,\n", + " 1.1666666666666665,\n", + " 2.416666666666665],\n", + " 'TaskName': 'finger_foot_lips'}" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "\n", + "#metadata is located in json files\n", + "with open('/data/ds000114/task-fingerfootlips_bold.json', 'rt') as fp:\n", + " task_info = json.load(fp)\n", + "task_info" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "30" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(task_info['SliceTiming'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction Nipype" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Why nipype?**\n", + "\n", + "Nipype allows to build preprocessing pipelines from different softwares, and it is computationally efficient. There are some helpful ready to use pipleines written with Nipype like [fmriprep](https://fmriprep.org/en/stable/index.html). To use fmriprep the data have to be in valid BIDS format. The user have to supply only the path to the data setup the [parametars](https://fmriprep.org/en/stable/usage.html#command-line-arguments). \n", + "\n", + "In Nipype, interfaces are python modules that allow you to use various external packages (e.g. FSL, SPM or FreeSurfer), even if they themselves are written in another programming language than python. Such an interface knows what sort of options an external program has and how to execute it.\n", + "\n", + "![Nipype architecture](https://raw.github.com/satra/intro2nipype/master/images/arch.png)\n", + "\n", + "In Nipype, a node is an object that executes a certain function. This function can be anything from a Nipype interface to a user-specified function or an external script. Each node consists of a name, an interface category and at least one input field, and at least one output field.\n", + "\n", + "\n", + "Once you connect multiple nodes to each other, you create a directed graph. In Nipype we call such graphs either workflows or pipelines. Directed connections can only be established from an output field of a node to an input field of another node." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200920-23:36:10,141 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"a_x_b\" in \"/tmp/tmpr129nt7r/a_x_b\".\n", + "200920-23:36:10,144 nipype.workflow INFO:\n", + "\t [Node] Running \"a_x_b\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200920-23:36:10,152 nipype.workflow INFO:\n", + "\t [Node] Finished \"a_x_b\".\n" + ] + }, + { + "data": { + "text/plain": [ + "\n", + "multiply_result = 6" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nipype import Node, Function, Workflow\n", + "from IPython.display import Image, clear_output\n", + "\n", + "\n", + "def multiply(a, b):\n", + " return a * b\n", + "\n", + "#Create a Node that multiplies 2 numbers\n", + "mul = Node(Function(input_names=['a', 'b'],\n", + " output_names=['multiply_result'],\n", + " function=multiply), \n", + " name='a_x_b')\n", + "\n", + "mul.inputs.a = 2\n", + "mul.inputs.b = 3\n", + "\n", + "result = mul.run()\n", + "result.outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Create a Node that adds 2 numbers\n", + "def add(a, b):\n", + " return a + b\n", + "\n", + "\n", + "\n", + "adder = Node(Function(input_names=['a', 'b'],\n", + " output_names=['add'],\n", + " function=add), \n", + " name='a_plus_b')\n", + "adder.inputs.b = 10\n", + "\n", + "#Create a workflow \n", + "wf = Workflow('hello')\n", + "# connect the nodes \n", + "wf.connect(mul, 'multiply_result', adder, 'a')\n", + "#visualize the graph\n", + "wf.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "clear_output()\n", + "Image(filename='graph_detailed.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[\n", + " multiply_result = 6,\n", + " \n", + " add = 16]" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#run the graph\n", + "eg = wf.run()\n", + "clear_output()#don't print the pipeline steps during exection\n", + "#chek the results\n", + "eg = list(eg.nodes())\n", + "nodes_outputs = [node.result.outputs for node in eg]\n", + "nodes_outputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Dataset:**\n", + "[A test-retest fMRI dataset for motor, language and spatial attention functions](https://openneuro.org/datasets/ds000114/versions/1.0.1)\n", + "\n", + "**Thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/seminar4/README.md b/seminar4/README.md new file mode 100644 index 0000000..f2c9aca --- /dev/null +++ b/seminar4/README.md @@ -0,0 +1,17 @@ +# seminar-4 + +# GLM + + +1.First follow the instruction for geting the docker image: + +https://miykael.github.io/nipype_tutorial/notebooks/introduction_docker.html + +2.Clone this repository. + +3.Run the container and mount the folder: + +docker run -it --rm -p 8888:8888 -v /path_to_seminar-4:/home/neuro/nipype_tutorial/notebooks/seminar miykael/nipype_tutorial jupyter notebook + +#### Dataset: +* A test-retest fMRI dataset for motor, language and spatial attention functions https://www.openfmri.org/dataset/ds000114/ diff --git a/seminar4/__pycache__/utils.cpython-36.pyc b/seminar4/__pycache__/utils.cpython-36.pyc new file mode 100644 index 0000000..2919844 Binary files /dev/null and b/seminar4/__pycache__/utils.cpython-36.pyc differ diff --git a/seminar4/graph.dot b/seminar4/graph.dot new file mode 100644 index 0000000..6ae7f64 --- /dev/null +++ b/seminar4/graph.dot @@ -0,0 +1,5 @@ +strict digraph { +"a_x_b (utility)"; +"a_plus_b (utility)"; +"a_x_b (utility)" -> "a_plus_b (utility)"; +} diff --git a/seminar4/graph.png b/seminar4/graph.png new file mode 100644 index 0000000..ca6fa89 Binary files /dev/null and b/seminar4/graph.png differ diff --git a/seminar4/graph_detailed.dot b/seminar4/graph_detailed.dot new file mode 100644 index 0000000..1552ce1 --- /dev/null +++ b/seminar4/graph_detailed.dot @@ -0,0 +1,6 @@ +digraph structs { +node [shape=record]; +helloa_x_b [label="{IN}|{ a_x_b | utility | }|{OUT| multiply_result}"]; +helloa_plus_b [label="{IN| a}|{ a_plus_b | utility | }|{OUT}"]; +helloa_x_b:outmultiplyresult:e -> helloa_plus_b:ina:w; +} \ No newline at end of file diff --git a/seminar4/graph_detailed.png b/seminar4/graph_detailed.png new file mode 100644 index 0000000..88427e0 Binary files /dev/null and b/seminar4/graph_detailed.png differ diff --git a/seminar4/hello/d3.js b/seminar4/hello/d3.js new file mode 100644 index 0000000..e1ddb03 --- /dev/null +++ b/seminar4/hello/d3.js @@ -0,0 +1,9255 @@ +!function() { + var d3 = { + version: "3.4.8" + }; + if (!Date.now) Date.now = function() { + return +new Date(); + }; + var d3_arraySlice = [].slice, d3_array = function(list) { + return d3_arraySlice.call(list); + }; + var d3_document = document, d3_documentElement = d3_document.documentElement, d3_window = window; + try { + d3_array(d3_documentElement.childNodes)[0].nodeType; + } catch (e) { + d3_array = function(list) { + var i = list.length, array = new Array(i); + while (i--) array[i] = list[i]; + return array; + }; + } + try { + d3_document.createElement("div").style.setProperty("opacity", 0, ""); + } catch (error) { + var d3_element_prototype = d3_window.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = d3_window.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty; + d3_element_prototype.setAttribute = function(name, value) { + d3_element_setAttribute.call(this, name, value + ""); + }; + d3_element_prototype.setAttributeNS = function(space, local, value) { + d3_element_setAttributeNS.call(this, space, local, value + ""); + }; + d3_style_prototype.setProperty = function(name, value, priority) { + d3_style_setProperty.call(this, name, value + "", priority); + }; + } + d3.ascending = d3_ascending; + function d3_ascending(a, b) { + return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; + } + d3.descending = function(a, b) { + return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; + }; + d3.min = function(array, f) { + var i = -1, n = array.length, a, b; + if (arguments.length === 1) { + while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined; + while (++i < n) if ((b = array[i]) != null && a > b) a = b; + } else { + while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined; + while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b; + } + return a; + }; + d3.max = function(array, f) { + var i = -1, n = array.length, a, b; + if (arguments.length === 1) { + while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined; + while (++i < n) if ((b = array[i]) != null && b > a) a = b; + } else { + while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined; + while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b; + } + return a; + }; + d3.extent = function(array, f) { + var i = -1, n = array.length, a, b, c; + if (arguments.length === 1) { + while (++i < n && !((a = c = array[i]) != null && a <= a)) a = c = undefined; + while (++i < n) if ((b = array[i]) != null) { + if (a > b) a = b; + if (c < b) c = b; + } + } else { + while (++i < n && !((a = c = f.call(array, array[i], i)) != null && a <= a)) a = undefined; + while (++i < n) if ((b = f.call(array, array[i], i)) != null) { + if (a > b) a = b; + if (c < b) c = b; + } + } + return [ a, c ]; + }; + d3.sum = function(array, f) { + var s = 0, n = array.length, a, i = -1; + if (arguments.length === 1) { + while (++i < n) if (!isNaN(a = +array[i])) s += a; + } else { + while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a; + } + return s; + }; + function d3_number(x) { + return x != null && !isNaN(x); + } + d3.mean = function(array, f) { + var s = 0, n = array.length, a, i = -1, j = n; + if (arguments.length === 1) { + while (++i < n) if (d3_number(a = array[i])) s += a; else --j; + } else { + while (++i < n) if (d3_number(a = f.call(array, array[i], i))) s += a; else --j; + } + return j ? s / j : undefined; + }; + d3.quantile = function(values, p) { + var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h; + return e ? v + e * (values[h] - v) : v; + }; + d3.median = function(array, f) { + if (arguments.length > 1) array = array.map(f); + array = array.filter(d3_number); + return array.length ? d3.quantile(array.sort(d3_ascending), .5) : undefined; + }; + function d3_bisector(compare) { + return { + left: function(a, x, lo, hi) { + if (arguments.length < 3) lo = 0; + if (arguments.length < 4) hi = a.length; + while (lo < hi) { + var mid = lo + hi >>> 1; + if (compare(a[mid], x) < 0) lo = mid + 1; else hi = mid; + } + return lo; + }, + right: function(a, x, lo, hi) { + if (arguments.length < 3) lo = 0; + if (arguments.length < 4) hi = a.length; + while (lo < hi) { + var mid = lo + hi >>> 1; + if (compare(a[mid], x) > 0) hi = mid; else lo = mid + 1; + } + return lo; + } + }; + } + var d3_bisect = d3_bisector(d3_ascending); + d3.bisectLeft = d3_bisect.left; + d3.bisect = d3.bisectRight = d3_bisect.right; + d3.bisector = function(f) { + return d3_bisector(f.length === 1 ? function(d, x) { + return d3_ascending(f(d), x); + } : f); + }; + d3.shuffle = function(array) { + var m = array.length, t, i; + while (m) { + i = Math.random() * m-- | 0; + t = array[m], array[m] = array[i], array[i] = t; + } + return array; + }; + d3.permute = function(array, indexes) { + var i = indexes.length, permutes = new Array(i); + while (i--) permutes[i] = array[indexes[i]]; + return permutes; + }; + d3.pairs = function(array) { + var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n); + while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ]; + return pairs; + }; + d3.zip = function() { + if (!(n = arguments.length)) return []; + for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) { + for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) { + zip[j] = arguments[j][i]; + } + } + return zips; + }; + function d3_zipLength(d) { + return d.length; + } + d3.transpose = function(matrix) { + return d3.zip.apply(d3, matrix); + }; + d3.keys = function(map) { + var keys = []; + for (var key in map) keys.push(key); + return keys; + }; + d3.values = function(map) { + var values = []; + for (var key in map) values.push(map[key]); + return values; + }; + d3.entries = function(map) { + var entries = []; + for (var key in map) entries.push({ + key: key, + value: map[key] + }); + return entries; + }; + d3.merge = function(arrays) { + var n = arrays.length, m, i = -1, j = 0, merged, array; + while (++i < n) j += arrays[i].length; + merged = new Array(j); + while (--n >= 0) { + array = arrays[n]; + m = array.length; + while (--m >= 0) { + merged[--j] = array[m]; + } + } + return merged; + }; + var abs = Math.abs; + d3.range = function(start, stop, step) { + if (arguments.length < 3) { + step = 1; + if (arguments.length < 2) { + stop = start; + start = 0; + } + } + if ((stop - start) / step === Infinity) throw new Error("infinite range"); + var range = [], k = d3_range_integerScale(abs(step)), i = -1, j; + start *= k, stop *= k, step *= k; + if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k); + return range; + }; + function d3_range_integerScale(x) { + var k = 1; + while (x * k % 1) k *= 10; + return k; + } + function d3_class(ctor, properties) { + try { + for (var key in properties) { + Object.defineProperty(ctor.prototype, key, { + value: properties[key], + enumerable: false + }); + } + } catch (e) { + ctor.prototype = properties; + } + } + d3.map = function(object) { + var map = new d3_Map(); + if (object instanceof d3_Map) object.forEach(function(key, value) { + map.set(key, value); + }); else for (var key in object) map.set(key, object[key]); + return map; + }; + function d3_Map() {} + d3_class(d3_Map, { + has: d3_map_has, + get: function(key) { + return this[d3_map_prefix + key]; + }, + set: function(key, value) { + return this[d3_map_prefix + key] = value; + }, + remove: d3_map_remove, + keys: d3_map_keys, + values: function() { + var values = []; + this.forEach(function(key, value) { + values.push(value); + }); + return values; + }, + entries: function() { + var entries = []; + this.forEach(function(key, value) { + entries.push({ + key: key, + value: value + }); + }); + return entries; + }, + size: d3_map_size, + empty: d3_map_empty, + forEach: function(f) { + for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) f.call(this, key.substring(1), this[key]); + } + }); + var d3_map_prefix = "\x00", d3_map_prefixCode = d3_map_prefix.charCodeAt(0); + function d3_map_has(key) { + return d3_map_prefix + key in this; + } + function d3_map_remove(key) { + key = d3_map_prefix + key; + return key in this && delete this[key]; + } + function d3_map_keys() { + var keys = []; + this.forEach(function(key) { + keys.push(key); + }); + return keys; + } + function d3_map_size() { + var size = 0; + for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) ++size; + return size; + } + function d3_map_empty() { + for (var key in this) if (key.charCodeAt(0) === d3_map_prefixCode) return false; + return true; + } + d3.nest = function() { + var nest = {}, keys = [], sortKeys = [], sortValues, rollup; + function map(mapType, array, depth) { + if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array; + var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values; + while (++i < n) { + if (values = valuesByKey.get(keyValue = key(object = array[i]))) { + values.push(object); + } else { + valuesByKey.set(keyValue, [ object ]); + } + } + if (mapType) { + object = mapType(); + setter = function(keyValue, values) { + object.set(keyValue, map(mapType, values, depth)); + }; + } else { + object = {}; + setter = function(keyValue, values) { + object[keyValue] = map(mapType, values, depth); + }; + } + valuesByKey.forEach(setter); + return object; + } + function entries(map, depth) { + if (depth >= keys.length) return map; + var array = [], sortKey = sortKeys[depth++]; + map.forEach(function(key, keyMap) { + array.push({ + key: key, + values: entries(keyMap, depth) + }); + }); + return sortKey ? array.sort(function(a, b) { + return sortKey(a.key, b.key); + }) : array; + } + nest.map = function(array, mapType) { + return map(mapType, array, 0); + }; + nest.entries = function(array) { + return entries(map(d3.map, array, 0), 0); + }; + nest.key = function(d) { + keys.push(d); + return nest; + }; + nest.sortKeys = function(order) { + sortKeys[keys.length - 1] = order; + return nest; + }; + nest.sortValues = function(order) { + sortValues = order; + return nest; + }; + nest.rollup = function(f) { + rollup = f; + return nest; + }; + return nest; + }; + d3.set = function(array) { + var set = new d3_Set(); + if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]); + return set; + }; + function d3_Set() {} + d3_class(d3_Set, { + has: d3_map_has, + add: function(value) { + this[d3_map_prefix + value] = true; + return value; + }, + remove: function(value) { + value = d3_map_prefix + value; + return value in this && delete this[value]; + }, + values: d3_map_keys, + size: d3_map_size, + empty: d3_map_empty, + forEach: function(f) { + for (var value in this) if (value.charCodeAt(0) === d3_map_prefixCode) f.call(this, value.substring(1)); + } + }); + d3.behavior = {}; + d3.rebind = function(target, source) { + var i = 1, n = arguments.length, method; + while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]); + return target; + }; + function d3_rebind(target, source, method) { + return function() { + var value = method.apply(source, arguments); + return value === source ? target : value; + }; + } + function d3_vendorSymbol(object, name) { + if (name in object) return name; + name = name.charAt(0).toUpperCase() + name.substring(1); + for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) { + var prefixName = d3_vendorPrefixes[i] + name; + if (prefixName in object) return prefixName; + } + } + var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ]; + function d3_noop() {} + d3.dispatch = function() { + var dispatch = new d3_dispatch(), i = -1, n = arguments.length; + while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); + return dispatch; + }; + function d3_dispatch() {} + d3_dispatch.prototype.on = function(type, listener) { + var i = type.indexOf("."), name = ""; + if (i >= 0) { + name = type.substring(i + 1); + type = type.substring(0, i); + } + if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener); + if (arguments.length === 2) { + if (listener == null) for (type in this) { + if (this.hasOwnProperty(type)) this[type].on(name, null); + } + return this; + } + }; + function d3_dispatch_event(dispatch) { + var listeners = [], listenerByName = new d3_Map(); + function event() { + var z = listeners, i = -1, n = z.length, l; + while (++i < n) if (l = z[i].on) l.apply(this, arguments); + return dispatch; + } + event.on = function(name, listener) { + var l = listenerByName.get(name), i; + if (arguments.length < 2) return l && l.on; + if (l) { + l.on = null; + listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1)); + listenerByName.remove(name); + } + if (listener) listeners.push(listenerByName.set(name, { + on: listener + })); + return dispatch; + }; + return event; + } + d3.event = null; + function d3_eventPreventDefault() { + d3.event.preventDefault(); + } + function d3_eventSource() { + var e = d3.event, s; + while (s = e.sourceEvent) e = s; + return e; + } + function d3_eventDispatch(target) { + var dispatch = new d3_dispatch(), i = 0, n = arguments.length; + while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); + dispatch.of = function(thiz, argumentz) { + return function(e1) { + try { + var e0 = e1.sourceEvent = d3.event; + e1.target = target; + d3.event = e1; + dispatch[e1.type].apply(thiz, argumentz); + } finally { + d3.event = e0; + } + }; + }; + return dispatch; + } + d3.requote = function(s) { + return s.replace(d3_requote_re, "\\$&"); + }; + var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; + var d3_subclass = {}.__proto__ ? function(object, prototype) { + object.__proto__ = prototype; + } : function(object, prototype) { + for (var property in prototype) object[property] = prototype[property]; + }; + function d3_selection(groups) { + d3_subclass(groups, d3_selectionPrototype); + return groups; + } + var d3_select = function(s, n) { + return n.querySelector(s); + }, d3_selectAll = function(s, n) { + return n.querySelectorAll(s); + }, d3_selectMatcher = d3_documentElement[d3_vendorSymbol(d3_documentElement, "matchesSelector")], d3_selectMatches = function(n, s) { + return d3_selectMatcher.call(n, s); + }; + if (typeof Sizzle === "function") { + d3_select = function(s, n) { + return Sizzle(s, n)[0] || null; + }; + d3_selectAll = Sizzle; + d3_selectMatches = Sizzle.matchesSelector; + } + d3.selection = function() { + return d3_selectionRoot; + }; + var d3_selectionPrototype = d3.selection.prototype = []; + d3_selectionPrototype.select = function(selector) { + var subgroups = [], subgroup, subnode, group, node; + selector = d3_selection_selector(selector); + for (var j = -1, m = this.length; ++j < m; ) { + subgroups.push(subgroup = []); + subgroup.parentNode = (group = this[j]).parentNode; + for (var i = -1, n = group.length; ++i < n; ) { + if (node = group[i]) { + subgroup.push(subnode = selector.call(node, node.__data__, i, j)); + if (subnode && "__data__" in node) subnode.__data__ = node.__data__; + } else { + subgroup.push(null); + } + } + } + return d3_selection(subgroups); + }; + function d3_selection_selector(selector) { + return typeof selector === "function" ? selector : function() { + return d3_select(selector, this); + }; + } + d3_selectionPrototype.selectAll = function(selector) { + var subgroups = [], subgroup, node; + selector = d3_selection_selectorAll(selector); + for (var j = -1, m = this.length; ++j < m; ) { + for (var group = this[j], i = -1, n = group.length; ++i < n; ) { + if (node = group[i]) { + subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j))); + subgroup.parentNode = node; + } + } + } + return d3_selection(subgroups); + }; + function d3_selection_selectorAll(selector) { + return typeof selector === "function" ? selector : function() { + return d3_selectAll(selector, this); + }; + } + var d3_nsPrefix = { + svg: "http://www.w3.org/2000/svg", + xhtml: "http://www.w3.org/1999/xhtml", + xlink: "http://www.w3.org/1999/xlink", + xml: "http://www.w3.org/XML/1998/namespace", + xmlns: "http://www.w3.org/2000/xmlns/" + }; + d3.ns = { + prefix: d3_nsPrefix, + qualify: function(name) { + var i = name.indexOf(":"), prefix = name; + if (i >= 0) { + prefix = name.substring(0, i); + name = name.substring(i + 1); + } + return d3_nsPrefix.hasOwnProperty(prefix) ? { + space: d3_nsPrefix[prefix], + local: name + } : name; + } + }; + d3_selectionPrototype.attr = function(name, value) { + if (arguments.length < 2) { + if (typeof name === "string") { + var node = this.node(); + name = d3.ns.qualify(name); + return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name); + } + for (value in name) this.each(d3_selection_attr(value, name[value])); + return this; + } + return this.each(d3_selection_attr(name, value)); + }; + function d3_selection_attr(name, value) { + name = d3.ns.qualify(name); + function attrNull() { + this.removeAttribute(name); + } + function attrNullNS() { + this.removeAttributeNS(name.space, name.local); + } + function attrConstant() { + this.setAttribute(name, value); + } + function attrConstantNS() { + this.setAttributeNS(name.space, name.local, value); + } + function attrFunction() { + var x = value.apply(this, arguments); + if (x == null) this.removeAttribute(name); else this.setAttribute(name, x); + } + function attrFunctionNS() { + var x = value.apply(this, arguments); + if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x); + } + return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant; + } + function d3_collapse(s) { + return s.trim().replace(/\s+/g, " "); + } + d3_selectionPrototype.classed = function(name, value) { + if (arguments.length < 2) { + if (typeof name === "string") { + var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1; + if (value = node.classList) { + while (++i < n) if (!value.contains(name[i])) return false; + } else { + value = node.getAttribute("class"); + while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false; + } + return true; + } + for (value in name) this.each(d3_selection_classed(value, name[value])); + return this; + } + return this.each(d3_selection_classed(name, value)); + }; + function d3_selection_classedRe(name) { + return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g"); + } + function d3_selection_classes(name) { + return name.trim().split(/^|\s+/); + } + function d3_selection_classed(name, value) { + name = d3_selection_classes(name).map(d3_selection_classedName); + var n = name.length; + function classedConstant() { + var i = -1; + while (++i < n) name[i](this, value); + } + function classedFunction() { + var i = -1, x = value.apply(this, arguments); + while (++i < n) name[i](this, x); + } + return typeof value === "function" ? classedFunction : classedConstant; + } + function d3_selection_classedName(name) { + var re = d3_selection_classedRe(name); + return function(node, value) { + if (c = node.classList) return value ? c.add(name) : c.remove(name); + var c = node.getAttribute("class") || ""; + if (value) { + re.lastIndex = 0; + if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name)); + } else { + node.setAttribute("class", d3_collapse(c.replace(re, " "))); + } + }; + } + d3_selectionPrototype.style = function(name, value, priority) { + var n = arguments.length; + if (n < 3) { + if (typeof name !== "string") { + if (n < 2) value = ""; + for (priority in name) this.each(d3_selection_style(priority, name[priority], value)); + return this; + } + if (n < 2) return d3_window.getComputedStyle(this.node(), null).getPropertyValue(name); + priority = ""; + } + return this.each(d3_selection_style(name, value, priority)); + }; + function d3_selection_style(name, value, priority) { + function styleNull() { + this.style.removeProperty(name); + } + function styleConstant() { + this.style.setProperty(name, value, priority); + } + function styleFunction() { + var x = value.apply(this, arguments); + if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority); + } + return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant; + } + d3_selectionPrototype.property = function(name, value) { + if (arguments.length < 2) { + if (typeof name === "string") return this.node()[name]; + for (value in name) this.each(d3_selection_property(value, name[value])); + return this; + } + return this.each(d3_selection_property(name, value)); + }; + function d3_selection_property(name, value) { + function propertyNull() { + delete this[name]; + } + function propertyConstant() { + this[name] = value; + } + function propertyFunction() { + var x = value.apply(this, arguments); + if (x == null) delete this[name]; else this[name] = x; + } + return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant; + } + d3_selectionPrototype.text = function(value) { + return arguments.length ? this.each(typeof value === "function" ? function() { + var v = value.apply(this, arguments); + this.textContent = v == null ? "" : v; + } : value == null ? function() { + this.textContent = ""; + } : function() { + this.textContent = value; + }) : this.node().textContent; + }; + d3_selectionPrototype.html = function(value) { + return arguments.length ? this.each(typeof value === "function" ? function() { + var v = value.apply(this, arguments); + this.innerHTML = v == null ? "" : v; + } : value == null ? function() { + this.innerHTML = ""; + } : function() { + this.innerHTML = value; + }) : this.node().innerHTML; + }; + d3_selectionPrototype.append = function(name) { + name = d3_selection_creator(name); + return this.select(function() { + return this.appendChild(name.apply(this, arguments)); + }); + }; + function d3_selection_creator(name) { + return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? function() { + return this.ownerDocument.createElementNS(name.space, name.local); + } : function() { + return this.ownerDocument.createElementNS(this.namespaceURI, name); + }; + } + d3_selectionPrototype.insert = function(name, before) { + name = d3_selection_creator(name); + before = d3_selection_selector(before); + return this.select(function() { + return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null); + }); + }; + d3_selectionPrototype.remove = function() { + return this.each(function() { + var parent = this.parentNode; + if (parent) parent.removeChild(this); + }); + }; + d3_selectionPrototype.data = function(value, key) { + var i = -1, n = this.length, group, node; + if (!arguments.length) { + value = new Array(n = (group = this[0]).length); + while (++i < n) { + if (node = group[i]) { + value[i] = node.__data__; + } + } + return value; + } + function bind(group, groupData) { + var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData; + if (key) { + var nodeByKeyValue = new d3_Map(), dataByKeyValue = new d3_Map(), keyValues = [], keyValue; + for (i = -1; ++i < n; ) { + keyValue = key.call(node = group[i], node.__data__, i); + if (nodeByKeyValue.has(keyValue)) { + exitNodes[i] = node; + } else { + nodeByKeyValue.set(keyValue, node); + } + keyValues.push(keyValue); + } + for (i = -1; ++i < m; ) { + keyValue = key.call(groupData, nodeData = groupData[i], i); + if (node = nodeByKeyValue.get(keyValue)) { + updateNodes[i] = node; + node.__data__ = nodeData; + } else if (!dataByKeyValue.has(keyValue)) { + enterNodes[i] = d3_selection_dataNode(nodeData); + } + dataByKeyValue.set(keyValue, nodeData); + nodeByKeyValue.remove(keyValue); + } + for (i = -1; ++i < n; ) { + if (nodeByKeyValue.has(keyValues[i])) { + exitNodes[i] = group[i]; + } + } + } else { + for (i = -1; ++i < n0; ) { + node = group[i]; + nodeData = groupData[i]; + if (node) { + node.__data__ = nodeData; + updateNodes[i] = node; + } else { + enterNodes[i] = d3_selection_dataNode(nodeData); + } + } + for (;i < m; ++i) { + enterNodes[i] = d3_selection_dataNode(groupData[i]); + } + for (;i < n; ++i) { + exitNodes[i] = group[i]; + } + } + enterNodes.update = updateNodes; + enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode; + enter.push(enterNodes); + update.push(updateNodes); + exit.push(exitNodes); + } + var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]); + if (typeof value === "function") { + while (++i < n) { + bind(group = this[i], value.call(group, group.parentNode.__data__, i)); + } + } else { + while (++i < n) { + bind(group = this[i], value); + } + } + update.enter = function() { + return enter; + }; + update.exit = function() { + return exit; + }; + return update; + }; + function d3_selection_dataNode(data) { + return { + __data__: data + }; + } + d3_selectionPrototype.datum = function(value) { + return arguments.length ? this.property("__data__", value) : this.property("__data__"); + }; + d3_selectionPrototype.filter = function(filter) { + var subgroups = [], subgroup, group, node; + if (typeof filter !== "function") filter = d3_selection_filter(filter); + for (var j = 0, m = this.length; j < m; j++) { + subgroups.push(subgroup = []); + subgroup.parentNode = (group = this[j]).parentNode; + for (var i = 0, n = group.length; i < n; i++) { + if ((node = group[i]) && filter.call(node, node.__data__, i, j)) { + subgroup.push(node); + } + } + } + return d3_selection(subgroups); + }; + function d3_selection_filter(selector) { + return function() { + return d3_selectMatches(this, selector); + }; + } + d3_selectionPrototype.order = function() { + for (var j = -1, m = this.length; ++j < m; ) { + for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) { + if (node = group[i]) { + if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); + next = node; + } + } + } + return this; + }; + d3_selectionPrototype.sort = function(comparator) { + comparator = d3_selection_sortComparator.apply(this, arguments); + for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator); + return this.order(); + }; + function d3_selection_sortComparator(comparator) { + if (!arguments.length) comparator = d3_ascending; + return function(a, b) { + return a && b ? comparator(a.__data__, b.__data__) : !a - !b; + }; + } + d3_selectionPrototype.each = function(callback) { + return d3_selection_each(this, function(node, i, j) { + callback.call(node, node.__data__, i, j); + }); + }; + function d3_selection_each(groups, callback) { + for (var j = 0, m = groups.length; j < m; j++) { + for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) { + if (node = group[i]) callback(node, i, j); + } + } + return groups; + } + d3_selectionPrototype.call = function(callback) { + var args = d3_array(arguments); + callback.apply(args[0] = this, args); + return this; + }; + d3_selectionPrototype.empty = function() { + return !this.node(); + }; + d3_selectionPrototype.node = function() { + for (var j = 0, m = this.length; j < m; j++) { + for (var group = this[j], i = 0, n = group.length; i < n; i++) { + var node = group[i]; + if (node) return node; + } + } + return null; + }; + d3_selectionPrototype.size = function() { + var n = 0; + this.each(function() { + ++n; + }); + return n; + }; + function d3_selection_enter(selection) { + d3_subclass(selection, d3_selection_enterPrototype); + return selection; + } + var d3_selection_enterPrototype = []; + d3.selection.enter = d3_selection_enter; + d3.selection.enter.prototype = d3_selection_enterPrototype; + d3_selection_enterPrototype.append = d3_selectionPrototype.append; + d3_selection_enterPrototype.empty = d3_selectionPrototype.empty; + d3_selection_enterPrototype.node = d3_selectionPrototype.node; + d3_selection_enterPrototype.call = d3_selectionPrototype.call; + d3_selection_enterPrototype.size = d3_selectionPrototype.size; + d3_selection_enterPrototype.select = function(selector) { + var subgroups = [], subgroup, subnode, upgroup, group, node; + for (var j = -1, m = this.length; ++j < m; ) { + upgroup = (group = this[j]).update; + subgroups.push(subgroup = []); + subgroup.parentNode = group.parentNode; + for (var i = -1, n = group.length; ++i < n; ) { + if (node = group[i]) { + subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j)); + subnode.__data__ = node.__data__; + } else { + subgroup.push(null); + } + } + } + return d3_selection(subgroups); + }; + d3_selection_enterPrototype.insert = function(name, before) { + if (arguments.length < 2) before = d3_selection_enterInsertBefore(this); + return d3_selectionPrototype.insert.call(this, name, before); + }; + function d3_selection_enterInsertBefore(enter) { + var i0, j0; + return function(d, i, j) { + var group = enter[j].update, n = group.length, node; + if (j != j0) j0 = j, i0 = 0; + if (i >= i0) i0 = i + 1; + while (!(node = group[i0]) && ++i0 < n) ; + return node; + }; + } + d3_selectionPrototype.transition = function() { + var id = d3_transitionInheritId || ++d3_transitionId, subgroups = [], subgroup, node, transition = d3_transitionInherit || { + time: Date.now(), + ease: d3_ease_cubicInOut, + delay: 0, + duration: 250 + }; + for (var j = -1, m = this.length; ++j < m; ) { + subgroups.push(subgroup = []); + for (var group = this[j], i = -1, n = group.length; ++i < n; ) { + if (node = group[i]) d3_transitionNode(node, i, id, transition); + subgroup.push(node); + } + } + return d3_transition(subgroups, id); + }; + d3_selectionPrototype.interrupt = function() { + return this.each(d3_selection_interrupt); + }; + function d3_selection_interrupt() { + var lock = this.__transition__; + if (lock) ++lock.active; + } + d3.select = function(node) { + var group = [ typeof node === "string" ? d3_select(node, d3_document) : node ]; + group.parentNode = d3_documentElement; + return d3_selection([ group ]); + }; + d3.selectAll = function(nodes) { + var group = d3_array(typeof nodes === "string" ? d3_selectAll(nodes, d3_document) : nodes); + group.parentNode = d3_documentElement; + return d3_selection([ group ]); + }; + var d3_selectionRoot = d3.select(d3_documentElement); + d3_selectionPrototype.on = function(type, listener, capture) { + var n = arguments.length; + if (n < 3) { + if (typeof type !== "string") { + if (n < 2) listener = false; + for (capture in type) this.each(d3_selection_on(capture, type[capture], listener)); + return this; + } + if (n < 2) return (n = this.node()["__on" + type]) && n._; + capture = false; + } + return this.each(d3_selection_on(type, listener, capture)); + }; + function d3_selection_on(type, listener, capture) { + var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener; + if (i > 0) type = type.substring(0, i); + var filter = d3_selection_onFilters.get(type); + if (filter) type = filter, wrap = d3_selection_onFilter; + function onRemove() { + var l = this[name]; + if (l) { + this.removeEventListener(type, l, l.$); + delete this[name]; + } + } + function onAdd() { + var l = wrap(listener, d3_array(arguments)); + onRemove.call(this); + this.addEventListener(type, this[name] = l, l.$ = capture); + l._ = listener; + } + function removeAll() { + var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match; + for (var name in this) { + if (match = name.match(re)) { + var l = this[name]; + this.removeEventListener(match[1], l, l.$); + delete this[name]; + } + } + } + return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll; + } + var d3_selection_onFilters = d3.map({ + mouseenter: "mouseover", + mouseleave: "mouseout" + }); + d3_selection_onFilters.forEach(function(k) { + if ("on" + k in d3_document) d3_selection_onFilters.remove(k); + }); + function d3_selection_onListener(listener, argumentz) { + return function(e) { + var o = d3.event; + d3.event = e; + argumentz[0] = this.__data__; + try { + listener.apply(this, argumentz); + } finally { + d3.event = o; + } + }; + } + function d3_selection_onFilter(listener, argumentz) { + var l = d3_selection_onListener(listener, argumentz); + return function(e) { + var target = this, related = e.relatedTarget; + if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) { + l.call(target, e); + } + }; + } + var d3_event_dragSelect = "onselectstart" in d3_document ? null : d3_vendorSymbol(d3_documentElement.style, "userSelect"), d3_event_dragId = 0; + function d3_event_dragSuppress() { + var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault); + if (d3_event_dragSelect) { + var style = d3_documentElement.style, select = style[d3_event_dragSelect]; + style[d3_event_dragSelect] = "none"; + } + return function(suppressClick) { + w.on(name, null); + if (d3_event_dragSelect) style[d3_event_dragSelect] = select; + if (suppressClick) { + function off() { + w.on(click, null); + } + w.on(click, function() { + d3_eventPreventDefault(); + off(); + }, true); + setTimeout(off, 0); + } + }; + } + d3.mouse = function(container) { + return d3_mousePoint(container, d3_eventSource()); + }; + function d3_mousePoint(container, e) { + if (e.changedTouches) e = e.changedTouches[0]; + var svg = container.ownerSVGElement || container; + if (svg.createSVGPoint) { + var point = svg.createSVGPoint(); + point.x = e.clientX, point.y = e.clientY; + point = point.matrixTransform(container.getScreenCTM().inverse()); + return [ point.x, point.y ]; + } + var rect = container.getBoundingClientRect(); + return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ]; + } + d3.touches = function(container, touches) { + if (arguments.length < 2) touches = d3_eventSource().touches; + return touches ? d3_array(touches).map(function(touch) { + var point = d3_mousePoint(container, touch); + point.identifier = touch.identifier; + return point; + }) : []; + }; + d3.behavior.drag = function() { + var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_behavior_dragMouseSubject, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_behavior_dragTouchSubject, "touchmove", "touchend"); + function drag() { + this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart); + } + function dragstart(id, position, subject, move, end) { + return function() { + var that = this, target = d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject()).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(), position0 = position(parent, dragId); + if (origin) { + dragOffset = origin.apply(that, arguments); + dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ]; + } else { + dragOffset = [ 0, 0 ]; + } + dispatch({ + type: "dragstart" + }); + function moved() { + var position1 = position(parent, dragId), dx, dy; + if (!position1) return; + dx = position1[0] - position0[0]; + dy = position1[1] - position0[1]; + dragged |= dx | dy; + position0 = position1; + dispatch({ + type: "drag", + x: position1[0] + dragOffset[0], + y: position1[1] + dragOffset[1], + dx: dx, + dy: dy + }); + } + function ended() { + if (!position(parent, dragId)) return; + dragSubject.on(move + dragName, null).on(end + dragName, null); + dragRestore(dragged && d3.event.target === target); + dispatch({ + type: "dragend" + }); + } + }; + } + drag.origin = function(x) { + if (!arguments.length) return origin; + origin = x; + return drag; + }; + return d3.rebind(drag, event, "on"); + }; + function d3_behavior_dragTouchId() { + return d3.event.changedTouches[0].identifier; + } + function d3_behavior_dragTouchSubject() { + return d3.event.target; + } + function d3_behavior_dragMouseSubject() { + return d3_window; + } + var π = Math.PI, τ = 2 * π, halfπ = π / 2, ε = 1e-6, ε2 = ε * ε, d3_radians = π / 180, d3_degrees = 180 / π; + function d3_sgn(x) { + return x > 0 ? 1 : x < 0 ? -1 : 0; + } + function d3_cross2d(a, b, c) { + return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); + } + function d3_acos(x) { + return x > 1 ? 0 : x < -1 ? π : Math.acos(x); + } + function d3_asin(x) { + return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x); + } + function d3_sinh(x) { + return ((x = Math.exp(x)) - 1 / x) / 2; + } + function d3_cosh(x) { + return ((x = Math.exp(x)) + 1 / x) / 2; + } + function d3_tanh(x) { + return ((x = Math.exp(2 * x)) - 1) / (x + 1); + } + function d3_haversin(x) { + return (x = Math.sin(x / 2)) * x; + } + var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4; + d3.interpolateZoom = function(p0, p1) { + var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2]; + var dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1), dr = r1 - r0, S = (dr || Math.log(w1 / w0)) / ρ; + function interpolate(t) { + var s = t * S; + if (dr) { + var coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0)); + return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ]; + } + return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * s) ]; + } + interpolate.duration = S * 1e3; + return interpolate; + }; + d3.behavior.zoom = function() { + var view = { + x: 0, + y: 0, + k: 1 + }, translate0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1; + function zoom(g) { + g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on(mousemove, mousewheelreset).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted); + } + zoom.event = function(g) { + g.each(function() { + var dispatch = event.of(this, arguments), view1 = view; + if (d3_transitionInheritId) { + d3.select(this).transition().each("start.zoom", function() { + view = this.__chart__ || { + x: 0, + y: 0, + k: 1 + }; + zoomstarted(dispatch); + }).tween("zoom:zoom", function() { + var dx = size[0], dy = size[1], cx = dx / 2, cy = dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]); + return function(t) { + var l = i(t), k = dx / l[2]; + this.__chart__ = view = { + x: cx - l[0] * k, + y: cy - l[1] * k, + k: k + }; + zoomed(dispatch); + }; + }).each("end.zoom", function() { + zoomended(dispatch); + }); + } else { + this.__chart__ = view; + zoomstarted(dispatch); + zoomed(dispatch); + zoomended(dispatch); + } + }); + }; + zoom.translate = function(_) { + if (!arguments.length) return [ view.x, view.y ]; + view = { + x: +_[0], + y: +_[1], + k: view.k + }; + rescale(); + return zoom; + }; + zoom.scale = function(_) { + if (!arguments.length) return view.k; + view = { + x: view.x, + y: view.y, + k: +_ + }; + rescale(); + return zoom; + }; + zoom.scaleExtent = function(_) { + if (!arguments.length) return scaleExtent; + scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ]; + return zoom; + }; + zoom.center = function(_) { + if (!arguments.length) return center; + center = _ && [ +_[0], +_[1] ]; + return zoom; + }; + zoom.size = function(_) { + if (!arguments.length) return size; + size = _ && [ +_[0], +_[1] ]; + return zoom; + }; + zoom.x = function(z) { + if (!arguments.length) return x1; + x1 = z; + x0 = z.copy(); + view = { + x: 0, + y: 0, + k: 1 + }; + return zoom; + }; + zoom.y = function(z) { + if (!arguments.length) return y1; + y1 = z; + y0 = z.copy(); + view = { + x: 0, + y: 0, + k: 1 + }; + return zoom; + }; + function location(p) { + return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ]; + } + function point(l) { + return [ l[0] * view.k + view.x, l[1] * view.k + view.y ]; + } + function scaleTo(s) { + view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s)); + } + function translateTo(p, l) { + l = point(l); + view.x += p[0] - l[0]; + view.y += p[1] - l[1]; + } + function rescale() { + if (x1) x1.domain(x0.range().map(function(x) { + return (x - view.x) / view.k; + }).map(x0.invert)); + if (y1) y1.domain(y0.range().map(function(y) { + return (y - view.y) / view.k; + }).map(y0.invert)); + } + function zoomstarted(dispatch) { + dispatch({ + type: "zoomstart" + }); + } + function zoomed(dispatch) { + rescale(); + dispatch({ + type: "zoom", + scale: view.k, + translate: [ view.x, view.y ] + }); + } + function zoomended(dispatch) { + dispatch({ + type: "zoomend" + }); + } + function mousedowned() { + var that = this, target = d3.event.target, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(); + d3_selection_interrupt.call(that); + zoomstarted(dispatch); + function moved() { + dragged = 1; + translateTo(d3.mouse(that), location0); + zoomed(dispatch); + } + function ended() { + subject.on(mousemove, d3_window === that ? mousewheelreset : null).on(mouseup, null); + dragRestore(dragged && d3.event.target === target); + zoomended(dispatch); + } + } + function touchstarted() { + var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that).on(mousedown, null).on(touchstart, started), dragRestore = d3_event_dragSuppress(); + d3_selection_interrupt.call(that); + started(); + zoomstarted(dispatch); + function relocate() { + var touches = d3.touches(that); + scale0 = view.k; + touches.forEach(function(t) { + if (t.identifier in locations0) locations0[t.identifier] = location(t); + }); + return touches; + } + function started() { + var target = d3.event.target; + d3.select(target).on(touchmove, moved).on(touchend, ended); + targets.push(target); + var changed = d3.event.changedTouches; + for (var i = 0, n = changed.length; i < n; ++i) { + locations0[changed[i].identifier] = null; + } + var touches = relocate(), now = Date.now(); + if (touches.length === 1) { + if (now - touchtime < 500) { + var p = touches[0], l = locations0[p.identifier]; + scaleTo(view.k * 2); + translateTo(p, l); + d3_eventPreventDefault(); + zoomed(dispatch); + } + touchtime = now; + } else if (touches.length > 1) { + var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1]; + distance0 = dx * dx + dy * dy; + } + } + function moved() { + var touches = d3.touches(that), p0, l0, p1, l1; + for (var i = 0, n = touches.length; i < n; ++i, l1 = null) { + p1 = touches[i]; + if (l1 = locations0[p1.identifier]) { + if (l0) break; + p0 = p1, l0 = l1; + } + } + if (l1) { + var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0); + p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ]; + l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ]; + scaleTo(scale1 * scale0); + } + touchtime = null; + translateTo(p0, l0); + zoomed(dispatch); + } + function ended() { + if (d3.event.touches.length) { + var changed = d3.event.changedTouches; + for (var i = 0, n = changed.length; i < n; ++i) { + delete locations0[changed[i].identifier]; + } + for (var identifier in locations0) { + return void relocate(); + } + } + d3.selectAll(targets).on(zoomName, null); + subject.on(mousedown, mousedowned).on(touchstart, touchstarted); + dragRestore(); + zoomended(dispatch); + } + } + function mousewheeled() { + var dispatch = event.of(this, arguments); + if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this), + zoomstarted(dispatch); + mousewheelTimer = setTimeout(function() { + mousewheelTimer = null; + zoomended(dispatch); + }, 50); + d3_eventPreventDefault(); + var point = center || d3.mouse(this); + if (!translate0) translate0 = location(point); + scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k); + translateTo(point, translate0); + zoomed(dispatch); + } + function mousewheelreset() { + translate0 = null; + } + function dblclicked() { + var dispatch = event.of(this, arguments), p = d3.mouse(this), l = location(p), k = Math.log(view.k) / Math.LN2; + zoomstarted(dispatch); + scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1)); + translateTo(p, l); + zoomed(dispatch); + zoomended(dispatch); + } + return d3.rebind(zoom, event, "on"); + }; + var d3_behavior_zoomInfinity = [ 0, Infinity ]; + var d3_behavior_zoomDelta, d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() { + return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1); + }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() { + return d3.event.wheelDelta; + }, "mousewheel") : (d3_behavior_zoomDelta = function() { + return -d3.event.detail; + }, "MozMousePixelScroll"); + function d3_Color() {} + d3_Color.prototype.toString = function() { + return this.rgb() + ""; + }; + d3.hsl = function(h, s, l) { + return arguments.length === 1 ? h instanceof d3_Hsl ? d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : d3_hsl(+h, +s, +l); + }; + function d3_hsl(h, s, l) { + return new d3_Hsl(h, s, l); + } + function d3_Hsl(h, s, l) { + this.h = h; + this.s = s; + this.l = l; + } + var d3_hslPrototype = d3_Hsl.prototype = new d3_Color(); + d3_hslPrototype.brighter = function(k) { + k = Math.pow(.7, arguments.length ? k : 1); + return d3_hsl(this.h, this.s, this.l / k); + }; + d3_hslPrototype.darker = function(k) { + k = Math.pow(.7, arguments.length ? k : 1); + return d3_hsl(this.h, this.s, k * this.l); + }; + d3_hslPrototype.rgb = function() { + return d3_hsl_rgb(this.h, this.s, this.l); + }; + function d3_hsl_rgb(h, s, l) { + var m1, m2; + h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h; + s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s; + l = l < 0 ? 0 : l > 1 ? 1 : l; + m2 = l <= .5 ? l * (1 + s) : l + s - l * s; + m1 = 2 * l - m2; + function v(h) { + if (h > 360) h -= 360; else if (h < 0) h += 360; + if (h < 60) return m1 + (m2 - m1) * h / 60; + if (h < 180) return m2; + if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60; + return m1; + } + function vv(h) { + return Math.round(v(h) * 255); + } + return d3_rgb(vv(h + 120), vv(h), vv(h - 120)); + } + d3.hcl = function(h, c, l) { + return arguments.length === 1 ? h instanceof d3_Hcl ? d3_hcl(h.h, h.c, h.l) : h instanceof d3_Lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : d3_hcl(+h, +c, +l); + }; + function d3_hcl(h, c, l) { + return new d3_Hcl(h, c, l); + } + function d3_Hcl(h, c, l) { + this.h = h; + this.c = c; + this.l = l; + } + var d3_hclPrototype = d3_Hcl.prototype = new d3_Color(); + d3_hclPrototype.brighter = function(k) { + return d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1))); + }; + d3_hclPrototype.darker = function(k) { + return d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1))); + }; + d3_hclPrototype.rgb = function() { + return d3_hcl_lab(this.h, this.c, this.l).rgb(); + }; + function d3_hcl_lab(h, c, l) { + if (isNaN(h)) h = 0; + if (isNaN(c)) c = 0; + return d3_lab(l, Math.cos(h *= d3_radians) * c, Math.sin(h) * c); + } + d3.lab = function(l, a, b) { + return arguments.length === 1 ? l instanceof d3_Lab ? d3_lab(l.l, l.a, l.b) : l instanceof d3_Hcl ? d3_hcl_lab(l.l, l.c, l.h) : d3_rgb_lab((l = d3.rgb(l)).r, l.g, l.b) : d3_lab(+l, +a, +b); + }; + function d3_lab(l, a, b) { + return new d3_Lab(l, a, b); + } + function d3_Lab(l, a, b) { + this.l = l; + this.a = a; + this.b = b; + } + var d3_lab_K = 18; + var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883; + var d3_labPrototype = d3_Lab.prototype = new d3_Color(); + d3_labPrototype.brighter = function(k) { + return d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); + }; + d3_labPrototype.darker = function(k) { + return d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); + }; + d3_labPrototype.rgb = function() { + return d3_lab_rgb(this.l, this.a, this.b); + }; + function d3_lab_rgb(l, a, b) { + var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200; + x = d3_lab_xyz(x) * d3_lab_X; + y = d3_lab_xyz(y) * d3_lab_Y; + z = d3_lab_xyz(z) * d3_lab_Z; + return d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z)); + } + function d3_lab_hcl(l, a, b) { + return l > 0 ? d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : d3_hcl(NaN, NaN, l); + } + function d3_lab_xyz(x) { + return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037; + } + function d3_xyz_lab(x) { + return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29; + } + function d3_xyz_rgb(r) { + return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055)); + } + d3.rgb = function(r, g, b) { + return arguments.length === 1 ? r instanceof d3_Rgb ? d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : d3_rgb(~~r, ~~g, ~~b); + }; + function d3_rgbNumber(value) { + return d3_rgb(value >> 16, value >> 8 & 255, value & 255); + } + function d3_rgbString(value) { + return d3_rgbNumber(value) + ""; + } + function d3_rgb(r, g, b) { + return new d3_Rgb(r, g, b); + } + function d3_Rgb(r, g, b) { + this.r = r; + this.g = g; + this.b = b; + } + var d3_rgbPrototype = d3_Rgb.prototype = new d3_Color(); + d3_rgbPrototype.brighter = function(k) { + k = Math.pow(.7, arguments.length ? k : 1); + var r = this.r, g = this.g, b = this.b, i = 30; + if (!r && !g && !b) return d3_rgb(i, i, i); + if (r && r < i) r = i; + if (g && g < i) g = i; + if (b && b < i) b = i; + return d3_rgb(Math.min(255, ~~(r / k)), Math.min(255, ~~(g / k)), Math.min(255, ~~(b / k))); + }; + d3_rgbPrototype.darker = function(k) { + k = Math.pow(.7, arguments.length ? k : 1); + return d3_rgb(~~(k * this.r), ~~(k * this.g), ~~(k * this.b)); + }; + d3_rgbPrototype.hsl = function() { + return d3_rgb_hsl(this.r, this.g, this.b); + }; + d3_rgbPrototype.toString = function() { + return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b); + }; + function d3_rgb_hex(v) { + return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16); + } + function d3_rgb_parse(format, rgb, hsl) { + var r = 0, g = 0, b = 0, m1, m2, color; + m1 = /([a-z]+)\((.*)\)/i.exec(format); + if (m1) { + m2 = m1[2].split(","); + switch (m1[1]) { + case "hsl": + { + return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100); + } + + case "rgb": + { + return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2])); + } + } + } + if (color = d3_rgb_names.get(format)) return rgb(color.r, color.g, color.b); + if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.substring(1), 16))) { + if (format.length === 4) { + r = (color & 3840) >> 4; + r = r >> 4 | r; + g = color & 240; + g = g >> 4 | g; + b = color & 15; + b = b << 4 | b; + } else if (format.length === 7) { + r = (color & 16711680) >> 16; + g = (color & 65280) >> 8; + b = color & 255; + } + } + return rgb(r, g, b); + } + function d3_rgb_hsl(r, g, b) { + var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2; + if (d) { + s = l < .5 ? d / (max + min) : d / (2 - max - min); + if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4; + h *= 60; + } else { + h = NaN; + s = l > 0 && l < 1 ? 0 : h; + } + return d3_hsl(h, s, l); + } + function d3_rgb_lab(r, g, b) { + r = d3_rgb_xyz(r); + g = d3_rgb_xyz(g); + b = d3_rgb_xyz(b); + var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z); + return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z)); + } + function d3_rgb_xyz(r) { + return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4); + } + function d3_rgb_parseNumber(c) { + var f = parseFloat(c); + return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f; + } + var d3_rgb_names = d3.map({ + aliceblue: 15792383, + antiquewhite: 16444375, + aqua: 65535, + aquamarine: 8388564, + azure: 15794175, + beige: 16119260, + bisque: 16770244, + black: 0, + blanchedalmond: 16772045, + blue: 255, + blueviolet: 9055202, + brown: 10824234, + burlywood: 14596231, + cadetblue: 6266528, + chartreuse: 8388352, + chocolate: 13789470, + coral: 16744272, + cornflowerblue: 6591981, + cornsilk: 16775388, + crimson: 14423100, + cyan: 65535, + darkblue: 139, + darkcyan: 35723, + darkgoldenrod: 12092939, + darkgray: 11119017, + darkgreen: 25600, + darkgrey: 11119017, + darkkhaki: 12433259, + darkmagenta: 9109643, + darkolivegreen: 5597999, + darkorange: 16747520, + darkorchid: 10040012, + darkred: 9109504, + darksalmon: 15308410, + darkseagreen: 9419919, + darkslateblue: 4734347, + darkslategray: 3100495, + darkslategrey: 3100495, + darkturquoise: 52945, + darkviolet: 9699539, + deeppink: 16716947, + deepskyblue: 49151, + dimgray: 6908265, + dimgrey: 6908265, + dodgerblue: 2003199, + firebrick: 11674146, + floralwhite: 16775920, + forestgreen: 2263842, + fuchsia: 16711935, + gainsboro: 14474460, + ghostwhite: 16316671, + gold: 16766720, + goldenrod: 14329120, + gray: 8421504, + green: 32768, + greenyellow: 11403055, + grey: 8421504, + honeydew: 15794160, + hotpink: 16738740, + indianred: 13458524, + indigo: 4915330, + ivory: 16777200, + khaki: 15787660, + lavender: 15132410, + lavenderblush: 16773365, + lawngreen: 8190976, + lemonchiffon: 16775885, + lightblue: 11393254, + lightcoral: 15761536, + lightcyan: 14745599, + lightgoldenrodyellow: 16448210, + lightgray: 13882323, + lightgreen: 9498256, + lightgrey: 13882323, + lightpink: 16758465, + lightsalmon: 16752762, + lightseagreen: 2142890, + lightskyblue: 8900346, + lightslategray: 7833753, + lightslategrey: 7833753, + lightsteelblue: 11584734, + lightyellow: 16777184, + lime: 65280, + limegreen: 3329330, + linen: 16445670, + magenta: 16711935, + maroon: 8388608, + mediumaquamarine: 6737322, + mediumblue: 205, + mediumorchid: 12211667, + mediumpurple: 9662683, + mediumseagreen: 3978097, + mediumslateblue: 8087790, + mediumspringgreen: 64154, + mediumturquoise: 4772300, + mediumvioletred: 13047173, + midnightblue: 1644912, + mintcream: 16121850, + mistyrose: 16770273, + moccasin: 16770229, + navajowhite: 16768685, + navy: 128, + oldlace: 16643558, + olive: 8421376, + olivedrab: 7048739, + orange: 16753920, + orangered: 16729344, + orchid: 14315734, + palegoldenrod: 15657130, + palegreen: 10025880, + paleturquoise: 11529966, + palevioletred: 14381203, + papayawhip: 16773077, + peachpuff: 16767673, + peru: 13468991, + pink: 16761035, + plum: 14524637, + powderblue: 11591910, + purple: 8388736, + red: 16711680, + rosybrown: 12357519, + royalblue: 4286945, + saddlebrown: 9127187, + salmon: 16416882, + sandybrown: 16032864, + seagreen: 3050327, + seashell: 16774638, + sienna: 10506797, + silver: 12632256, + skyblue: 8900331, + slateblue: 6970061, + slategray: 7372944, + slategrey: 7372944, + snow: 16775930, + springgreen: 65407, + steelblue: 4620980, + tan: 13808780, + teal: 32896, + thistle: 14204888, + tomato: 16737095, + turquoise: 4251856, + violet: 15631086, + wheat: 16113331, + white: 16777215, + whitesmoke: 16119285, + yellow: 16776960, + yellowgreen: 10145074 + }); + d3_rgb_names.forEach(function(key, value) { + d3_rgb_names.set(key, d3_rgbNumber(value)); + }); + function d3_functor(v) { + return typeof v === "function" ? v : function() { + return v; + }; + } + d3.functor = d3_functor; + function d3_identity(d) { + return d; + } + d3.xhr = d3_xhrType(d3_identity); + function d3_xhrType(response) { + return function(url, mimeType, callback) { + if (arguments.length === 2 && typeof mimeType === "function") callback = mimeType, + mimeType = null; + return d3_xhr(url, mimeType, response, callback); + }; + } + function d3_xhr(url, mimeType, response, callback) { + var xhr = {}, dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest(), responseType = null; + if (d3_window.XDomainRequest && !("withCredentials" in request) && /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest(); + "onload" in request ? request.onload = request.onerror = respond : request.onreadystatechange = function() { + request.readyState > 3 && respond(); + }; + function respond() { + var status = request.status, result; + if (!status && request.responseText || status >= 200 && status < 300 || status === 304) { + try { + result = response.call(xhr, request); + } catch (e) { + dispatch.error.call(xhr, e); + return; + } + dispatch.load.call(xhr, result); + } else { + dispatch.error.call(xhr, request); + } + } + request.onprogress = function(event) { + var o = d3.event; + d3.event = event; + try { + dispatch.progress.call(xhr, request); + } finally { + d3.event = o; + } + }; + xhr.header = function(name, value) { + name = (name + "").toLowerCase(); + if (arguments.length < 2) return headers[name]; + if (value == null) delete headers[name]; else headers[name] = value + ""; + return xhr; + }; + xhr.mimeType = function(value) { + if (!arguments.length) return mimeType; + mimeType = value == null ? null : value + ""; + return xhr; + }; + xhr.responseType = function(value) { + if (!arguments.length) return responseType; + responseType = value; + return xhr; + }; + xhr.response = function(value) { + response = value; + return xhr; + }; + [ "get", "post" ].forEach(function(method) { + xhr[method] = function() { + return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments))); + }; + }); + xhr.send = function(method, data, callback) { + if (arguments.length === 2 && typeof data === "function") callback = data, data = null; + request.open(method, url, true); + if (mimeType != null && !("accept" in headers)) headers["accept"] = mimeType + ",*/*"; + if (request.setRequestHeader) for (var name in headers) request.setRequestHeader(name, headers[name]); + if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType); + if (responseType != null) request.responseType = responseType; + if (callback != null) xhr.on("error", callback).on("load", function(request) { + callback(null, request); + }); + dispatch.beforesend.call(xhr, request); + request.send(data == null ? null : data); + return xhr; + }; + xhr.abort = function() { + request.abort(); + return xhr; + }; + d3.rebind(xhr, dispatch, "on"); + return callback == null ? xhr : xhr.get(d3_xhr_fixCallback(callback)); + } + function d3_xhr_fixCallback(callback) { + return callback.length === 1 ? function(error, request) { + callback(error == null ? request : null); + } : callback; + } + d3.dsv = function(delimiter, mimeType) { + var reFormat = new RegExp('["' + delimiter + "\n]"), delimiterCode = delimiter.charCodeAt(0); + function dsv(url, row, callback) { + if (arguments.length < 3) callback = row, row = null; + var xhr = d3_xhr(url, mimeType, row == null ? response : typedResponse(row), callback); + xhr.row = function(_) { + return arguments.length ? xhr.response((row = _) == null ? response : typedResponse(_)) : row; + }; + return xhr; + } + function response(request) { + return dsv.parse(request.responseText); + } + function typedResponse(f) { + return function(request) { + return dsv.parse(request.responseText, f); + }; + } + dsv.parse = function(text, f) { + var o; + return dsv.parseRows(text, function(row, i) { + if (o) return o(row, i - 1); + var a = new Function("d", "return {" + row.map(function(name, i) { + return JSON.stringify(name) + ": d[" + i + "]"; + }).join(",") + "}"); + o = f ? function(row, i) { + return f(a(row), i); + } : a; + }); + }; + dsv.parseRows = function(text, f) { + var EOL = {}, EOF = {}, rows = [], N = text.length, I = 0, n = 0, t, eol; + function token() { + if (I >= N) return EOF; + if (eol) return eol = false, EOL; + var j = I; + if (text.charCodeAt(j) === 34) { + var i = j; + while (i++ < N) { + if (text.charCodeAt(i) === 34) { + if (text.charCodeAt(i + 1) !== 34) break; + ++i; + } + } + I = i + 2; + var c = text.charCodeAt(i + 1); + if (c === 13) { + eol = true; + if (text.charCodeAt(i + 2) === 10) ++I; + } else if (c === 10) { + eol = true; + } + return text.substring(j + 1, i).replace(/""/g, '"'); + } + while (I < N) { + var c = text.charCodeAt(I++), k = 1; + if (c === 10) eol = true; else if (c === 13) { + eol = true; + if (text.charCodeAt(I) === 10) ++I, ++k; + } else if (c !== delimiterCode) continue; + return text.substring(j, I - k); + } + return text.substring(j); + } + while ((t = token()) !== EOF) { + var a = []; + while (t !== EOL && t !== EOF) { + a.push(t); + t = token(); + } + if (f && !(a = f(a, n++))) continue; + rows.push(a); + } + return rows; + }; + dsv.format = function(rows) { + if (Array.isArray(rows[0])) return dsv.formatRows(rows); + var fieldSet = new d3_Set(), fields = []; + rows.forEach(function(row) { + for (var field in row) { + if (!fieldSet.has(field)) { + fields.push(fieldSet.add(field)); + } + } + }); + return [ fields.map(formatValue).join(delimiter) ].concat(rows.map(function(row) { + return fields.map(function(field) { + return formatValue(row[field]); + }).join(delimiter); + })).join("\n"); + }; + dsv.formatRows = function(rows) { + return rows.map(formatRow).join("\n"); + }; + function formatRow(row) { + return row.map(formatValue).join(delimiter); + } + function formatValue(text) { + return reFormat.test(text) ? '"' + text.replace(/\"/g, '""') + '"' : text; + } + return dsv; + }; + d3.csv = d3.dsv(",", "text/csv"); + d3.tsv = d3.dsv(" ", "text/tab-separated-values"); + d3.touch = function(container, touches, identifier) { + if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches; + if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) { + if ((touch = touches[i]).identifier === identifier) { + return d3_mousePoint(container, touch); + } + } + }; + var d3_timer_queueHead, d3_timer_queueTail, d3_timer_interval, d3_timer_timeout, d3_timer_active, d3_timer_frame = d3_window[d3_vendorSymbol(d3_window, "requestAnimationFrame")] || function(callback) { + setTimeout(callback, 17); + }; + d3.timer = function(callback, delay, then) { + var n = arguments.length; + if (n < 2) delay = 0; + if (n < 3) then = Date.now(); + var time = then + delay, timer = { + c: callback, + t: time, + f: false, + n: null + }; + if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer; + d3_timer_queueTail = timer; + if (!d3_timer_interval) { + d3_timer_timeout = clearTimeout(d3_timer_timeout); + d3_timer_interval = 1; + d3_timer_frame(d3_timer_step); + } + }; + function d3_timer_step() { + var now = d3_timer_mark(), delay = d3_timer_sweep() - now; + if (delay > 24) { + if (isFinite(delay)) { + clearTimeout(d3_timer_timeout); + d3_timer_timeout = setTimeout(d3_timer_step, delay); + } + d3_timer_interval = 0; + } else { + d3_timer_interval = 1; + d3_timer_frame(d3_timer_step); + } + } + d3.timer.flush = function() { + d3_timer_mark(); + d3_timer_sweep(); + }; + function d3_timer_mark() { + var now = Date.now(); + d3_timer_active = d3_timer_queueHead; + while (d3_timer_active) { + if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t); + d3_timer_active = d3_timer_active.n; + } + return now; + } + function d3_timer_sweep() { + var t0, t1 = d3_timer_queueHead, time = Infinity; + while (t1) { + if (t1.f) { + t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n; + } else { + if (t1.t < time) time = t1.t; + t1 = (t0 = t1).n; + } + } + d3_timer_queueTail = t0; + return time; + } + function d3_format_precision(x, p) { + return p - (x ? Math.ceil(Math.log(x) / Math.LN10) : 1); + } + d3.round = function(x, n) { + return n ? Math.round(x * (n = Math.pow(10, n))) / n : Math.round(x); + }; + var d3_formatPrefixes = [ "y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y" ].map(d3_formatPrefix); + d3.formatPrefix = function(value, precision) { + var i = 0; + if (value) { + if (value < 0) value *= -1; + if (precision) value = d3.round(value, d3_format_precision(value, precision)); + i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10); + i = Math.max(-24, Math.min(24, Math.floor((i - 1) / 3) * 3)); + } + return d3_formatPrefixes[8 + i / 3]; + }; + function d3_formatPrefix(d, i) { + var k = Math.pow(10, abs(8 - i) * 3); + return { + scale: i > 8 ? function(d) { + return d / k; + } : function(d) { + return d * k; + }, + symbol: d + }; + } + function d3_locale_numberFormat(locale) { + var locale_decimal = locale.decimal, locale_thousands = locale.thousands, locale_grouping = locale.grouping, locale_currency = locale.currency, formatGroup = locale_grouping ? function(value) { + var i = value.length, t = [], j = 0, g = locale_grouping[0]; + while (i > 0 && g > 0) { + t.push(value.substring(i -= g, i + g)); + g = locale_grouping[j = (j + 1) % locale_grouping.length]; + } + return t.reverse().join(locale_thousands); + } : d3_identity; + return function(specifier) { + var match = d3_format_re.exec(specifier), fill = match[1] || " ", align = match[2] || ">", sign = match[3] || "", symbol = match[4] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, prefix = "", suffix = "", integer = false; + if (precision) precision = +precision.substring(1); + if (zfill || fill === "0" && align === "=") { + zfill = fill = "0"; + align = "="; + if (comma) width -= Math.floor((width - 1) / 4); + } + switch (type) { + case "n": + comma = true; + type = "g"; + break; + + case "%": + scale = 100; + suffix = "%"; + type = "f"; + break; + + case "p": + scale = 100; + suffix = "%"; + type = "r"; + break; + + case "b": + case "o": + case "x": + case "X": + if (symbol === "#") prefix = "0" + type.toLowerCase(); + + case "c": + case "d": + integer = true; + precision = 0; + break; + + case "s": + scale = -1; + type = "r"; + break; + } + if (symbol === "$") prefix = locale_currency[0], suffix = locale_currency[1]; + if (type == "r" && !precision) type = "g"; + if (precision != null) { + if (type == "g") precision = Math.max(1, Math.min(21, precision)); else if (type == "e" || type == "f") precision = Math.max(0, Math.min(20, precision)); + } + type = d3_format_types.get(type) || d3_format_typeDefault; + var zcomma = zfill && comma; + return function(value) { + var fullSuffix = suffix; + if (integer && value % 1) return ""; + var negative = value < 0 || value === 0 && 1 / value < 0 ? (value = -value, "-") : sign; + if (scale < 0) { + var unit = d3.formatPrefix(value, precision); + value = unit.scale(value); + fullSuffix = unit.symbol + suffix; + } else { + value *= scale; + } + value = type(value, precision); + var i = value.lastIndexOf("."), before = i < 0 ? value : value.substring(0, i), after = i < 0 ? "" : locale_decimal + value.substring(i + 1); + if (!zfill && comma) before = formatGroup(before); + var length = prefix.length + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : ""; + if (zcomma) before = formatGroup(padding + before); + negative += prefix; + value = before + after; + return (align === "<" ? negative + value + padding : align === ">" ? padding + negative + value : align === "^" ? padding.substring(0, length >>= 1) + negative + value + padding.substring(length) : negative + (zcomma ? value : padding + value)) + fullSuffix; + }; + }; + } + var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i; + var d3_format_types = d3.map({ + b: function(x) { + return x.toString(2); + }, + c: function(x) { + return String.fromCharCode(x); + }, + o: function(x) { + return x.toString(8); + }, + x: function(x) { + return x.toString(16); + }, + X: function(x) { + return x.toString(16).toUpperCase(); + }, + g: function(x, p) { + return x.toPrecision(p); + }, + e: function(x, p) { + return x.toExponential(p); + }, + f: function(x, p) { + return x.toFixed(p); + }, + r: function(x, p) { + return (x = d3.round(x, d3_format_precision(x, p))).toFixed(Math.max(0, Math.min(20, d3_format_precision(x * (1 + 1e-15), p)))); + } + }); + function d3_format_typeDefault(x) { + return x + ""; + } + var d3_time = d3.time = {}, d3_date = Date; + function d3_date_utc() { + this._ = new Date(arguments.length > 1 ? Date.UTC.apply(this, arguments) : arguments[0]); + } + d3_date_utc.prototype = { + getDate: function() { + return this._.getUTCDate(); + }, + getDay: function() { + return this._.getUTCDay(); + }, + getFullYear: function() { + return this._.getUTCFullYear(); + }, + getHours: function() { + return this._.getUTCHours(); + }, + getMilliseconds: function() { + return this._.getUTCMilliseconds(); + }, + getMinutes: function() { + return this._.getUTCMinutes(); + }, + getMonth: function() { + return this._.getUTCMonth(); + }, + getSeconds: function() { + return this._.getUTCSeconds(); + }, + getTime: function() { + return this._.getTime(); + }, + getTimezoneOffset: function() { + return 0; + }, + valueOf: function() { + return this._.valueOf(); + }, + setDate: function() { + d3_time_prototype.setUTCDate.apply(this._, arguments); + }, + setDay: function() { + d3_time_prototype.setUTCDay.apply(this._, arguments); + }, + setFullYear: function() { + d3_time_prototype.setUTCFullYear.apply(this._, arguments); + }, + setHours: function() { + d3_time_prototype.setUTCHours.apply(this._, arguments); + }, + setMilliseconds: function() { + d3_time_prototype.setUTCMilliseconds.apply(this._, arguments); + }, + setMinutes: function() { + d3_time_prototype.setUTCMinutes.apply(this._, arguments); + }, + setMonth: function() { + d3_time_prototype.setUTCMonth.apply(this._, arguments); + }, + setSeconds: function() { + d3_time_prototype.setUTCSeconds.apply(this._, arguments); + }, + setTime: function() { + d3_time_prototype.setTime.apply(this._, arguments); + } + }; + var d3_time_prototype = Date.prototype; + function d3_time_interval(local, step, number) { + function round(date) { + var d0 = local(date), d1 = offset(d0, 1); + return date - d0 < d1 - date ? d0 : d1; + } + function ceil(date) { + step(date = local(new d3_date(date - 1)), 1); + return date; + } + function offset(date, k) { + step(date = new d3_date(+date), k); + return date; + } + function range(t0, t1, dt) { + var time = ceil(t0), times = []; + if (dt > 1) { + while (time < t1) { + if (!(number(time) % dt)) times.push(new Date(+time)); + step(time, 1); + } + } else { + while (time < t1) times.push(new Date(+time)), step(time, 1); + } + return times; + } + function range_utc(t0, t1, dt) { + try { + d3_date = d3_date_utc; + var utc = new d3_date_utc(); + utc._ = t0; + return range(utc, t1, dt); + } finally { + d3_date = Date; + } + } + local.floor = local; + local.round = round; + local.ceil = ceil; + local.offset = offset; + local.range = range; + var utc = local.utc = d3_time_interval_utc(local); + utc.floor = utc; + utc.round = d3_time_interval_utc(round); + utc.ceil = d3_time_interval_utc(ceil); + utc.offset = d3_time_interval_utc(offset); + utc.range = range_utc; + return local; + } + function d3_time_interval_utc(method) { + return function(date, k) { + try { + d3_date = d3_date_utc; + var utc = new d3_date_utc(); + utc._ = date; + return method(utc, k)._; + } finally { + d3_date = Date; + } + }; + } + d3_time.year = d3_time_interval(function(date) { + date = d3_time.day(date); + date.setMonth(0, 1); + return date; + }, function(date, offset) { + date.setFullYear(date.getFullYear() + offset); + }, function(date) { + return date.getFullYear(); + }); + d3_time.years = d3_time.year.range; + d3_time.years.utc = d3_time.year.utc.range; + d3_time.day = d3_time_interval(function(date) { + var day = new d3_date(2e3, 0); + day.setFullYear(date.getFullYear(), date.getMonth(), date.getDate()); + return day; + }, function(date, offset) { + date.setDate(date.getDate() + offset); + }, function(date) { + return date.getDate() - 1; + }); + d3_time.days = d3_time.day.range; + d3_time.days.utc = d3_time.day.utc.range; + d3_time.dayOfYear = function(date) { + var year = d3_time.year(date); + return Math.floor((date - year - (date.getTimezoneOffset() - year.getTimezoneOffset()) * 6e4) / 864e5); + }; + [ "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ].forEach(function(day, i) { + i = 7 - i; + var interval = d3_time[day] = d3_time_interval(function(date) { + (date = d3_time.day(date)).setDate(date.getDate() - (date.getDay() + i) % 7); + return date; + }, function(date, offset) { + date.setDate(date.getDate() + Math.floor(offset) * 7); + }, function(date) { + var day = d3_time.year(date).getDay(); + return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7) - (day !== i); + }); + d3_time[day + "s"] = interval.range; + d3_time[day + "s"].utc = interval.utc.range; + d3_time[day + "OfYear"] = function(date) { + var day = d3_time.year(date).getDay(); + return Math.floor((d3_time.dayOfYear(date) + (day + i) % 7) / 7); + }; + }); + d3_time.week = d3_time.sunday; + d3_time.weeks = d3_time.sunday.range; + d3_time.weeks.utc = d3_time.sunday.utc.range; + d3_time.weekOfYear = d3_time.sundayOfYear; + function d3_locale_timeFormat(locale) { + var locale_dateTime = locale.dateTime, locale_date = locale.date, locale_time = locale.time, locale_periods = locale.periods, locale_days = locale.days, locale_shortDays = locale.shortDays, locale_months = locale.months, locale_shortMonths = locale.shortMonths; + function d3_time_format(template) { + var n = template.length; + function format(date) { + var string = [], i = -1, j = 0, c, p, f; + while (++i < n) { + if (template.charCodeAt(i) === 37) { + string.push(template.substring(j, i)); + if ((p = d3_time_formatPads[c = template.charAt(++i)]) != null) c = template.charAt(++i); + if (f = d3_time_formats[c]) c = f(date, p == null ? c === "e" ? " " : "0" : p); + string.push(c); + j = i + 1; + } + } + string.push(template.substring(j, i)); + return string.join(""); + } + format.parse = function(string) { + var d = { + y: 1900, + m: 0, + d: 1, + H: 0, + M: 0, + S: 0, + L: 0, + Z: null + }, i = d3_time_parse(d, template, string, 0); + if (i != string.length) return null; + if ("p" in d) d.H = d.H % 12 + d.p * 12; + var localZ = d.Z != null && d3_date !== d3_date_utc, date = new (localZ ? d3_date_utc : d3_date)(); + if ("j" in d) date.setFullYear(d.y, 0, d.j); else if ("w" in d && ("W" in d || "U" in d)) { + date.setFullYear(d.y, 0, 1); + date.setFullYear(d.y, 0, "W" in d ? (d.w + 6) % 7 + d.W * 7 - (date.getDay() + 5) % 7 : d.w + d.U * 7 - (date.getDay() + 6) % 7); + } else date.setFullYear(d.y, d.m, d.d); + date.setHours(d.H + Math.floor(d.Z / 100), d.M + d.Z % 100, d.S, d.L); + return localZ ? date._ : date; + }; + format.toString = function() { + return template; + }; + return format; + } + function d3_time_parse(date, template, string, j) { + var c, p, t, i = 0, n = template.length, m = string.length; + while (i < n) { + if (j >= m) return -1; + c = template.charCodeAt(i++); + if (c === 37) { + t = template.charAt(i++); + p = d3_time_parsers[t in d3_time_formatPads ? template.charAt(i++) : t]; + if (!p || (j = p(date, string, j)) < 0) return -1; + } else if (c != string.charCodeAt(j++)) { + return -1; + } + } + return j; + } + d3_time_format.utc = function(template) { + var local = d3_time_format(template); + function format(date) { + try { + d3_date = d3_date_utc; + var utc = new d3_date(); + utc._ = date; + return local(utc); + } finally { + d3_date = Date; + } + } + format.parse = function(string) { + try { + d3_date = d3_date_utc; + var date = local.parse(string); + return date && date._; + } finally { + d3_date = Date; + } + }; + format.toString = local.toString; + return format; + }; + d3_time_format.multi = d3_time_format.utc.multi = d3_time_formatMulti; + var d3_time_periodLookup = d3.map(), d3_time_dayRe = d3_time_formatRe(locale_days), d3_time_dayLookup = d3_time_formatLookup(locale_days), d3_time_dayAbbrevRe = d3_time_formatRe(locale_shortDays), d3_time_dayAbbrevLookup = d3_time_formatLookup(locale_shortDays), d3_time_monthRe = d3_time_formatRe(locale_months), d3_time_monthLookup = d3_time_formatLookup(locale_months), d3_time_monthAbbrevRe = d3_time_formatRe(locale_shortMonths), d3_time_monthAbbrevLookup = d3_time_formatLookup(locale_shortMonths); + locale_periods.forEach(function(p, i) { + d3_time_periodLookup.set(p.toLowerCase(), i); + }); + var d3_time_formats = { + a: function(d) { + return locale_shortDays[d.getDay()]; + }, + A: function(d) { + return locale_days[d.getDay()]; + }, + b: function(d) { + return locale_shortMonths[d.getMonth()]; + }, + B: function(d) { + return locale_months[d.getMonth()]; + }, + c: d3_time_format(locale_dateTime), + d: function(d, p) { + return d3_time_formatPad(d.getDate(), p, 2); + }, + e: function(d, p) { + return d3_time_formatPad(d.getDate(), p, 2); + }, + H: function(d, p) { + return d3_time_formatPad(d.getHours(), p, 2); + }, + I: function(d, p) { + return d3_time_formatPad(d.getHours() % 12 || 12, p, 2); + }, + j: function(d, p) { + return d3_time_formatPad(1 + d3_time.dayOfYear(d), p, 3); + }, + L: function(d, p) { + return d3_time_formatPad(d.getMilliseconds(), p, 3); + }, + m: function(d, p) { + return d3_time_formatPad(d.getMonth() + 1, p, 2); + }, + M: function(d, p) { + return d3_time_formatPad(d.getMinutes(), p, 2); + }, + p: function(d) { + return locale_periods[+(d.getHours() >= 12)]; + }, + S: function(d, p) { + return d3_time_formatPad(d.getSeconds(), p, 2); + }, + U: function(d, p) { + return d3_time_formatPad(d3_time.sundayOfYear(d), p, 2); + }, + w: function(d) { + return d.getDay(); + }, + W: function(d, p) { + return d3_time_formatPad(d3_time.mondayOfYear(d), p, 2); + }, + x: d3_time_format(locale_date), + X: d3_time_format(locale_time), + y: function(d, p) { + return d3_time_formatPad(d.getFullYear() % 100, p, 2); + }, + Y: function(d, p) { + return d3_time_formatPad(d.getFullYear() % 1e4, p, 4); + }, + Z: d3_time_zone, + "%": function() { + return "%"; + } + }; + var d3_time_parsers = { + a: d3_time_parseWeekdayAbbrev, + A: d3_time_parseWeekday, + b: d3_time_parseMonthAbbrev, + B: d3_time_parseMonth, + c: d3_time_parseLocaleFull, + d: d3_time_parseDay, + e: d3_time_parseDay, + H: d3_time_parseHour24, + I: d3_time_parseHour24, + j: d3_time_parseDayOfYear, + L: d3_time_parseMilliseconds, + m: d3_time_parseMonthNumber, + M: d3_time_parseMinutes, + p: d3_time_parseAmPm, + S: d3_time_parseSeconds, + U: d3_time_parseWeekNumberSunday, + w: d3_time_parseWeekdayNumber, + W: d3_time_parseWeekNumberMonday, + x: d3_time_parseLocaleDate, + X: d3_time_parseLocaleTime, + y: d3_time_parseYear, + Y: d3_time_parseFullYear, + Z: d3_time_parseZone, + "%": d3_time_parseLiteralPercent + }; + function d3_time_parseWeekdayAbbrev(date, string, i) { + d3_time_dayAbbrevRe.lastIndex = 0; + var n = d3_time_dayAbbrevRe.exec(string.substring(i)); + return n ? (date.w = d3_time_dayAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + function d3_time_parseWeekday(date, string, i) { + d3_time_dayRe.lastIndex = 0; + var n = d3_time_dayRe.exec(string.substring(i)); + return n ? (date.w = d3_time_dayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + function d3_time_parseMonthAbbrev(date, string, i) { + d3_time_monthAbbrevRe.lastIndex = 0; + var n = d3_time_monthAbbrevRe.exec(string.substring(i)); + return n ? (date.m = d3_time_monthAbbrevLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + function d3_time_parseMonth(date, string, i) { + d3_time_monthRe.lastIndex = 0; + var n = d3_time_monthRe.exec(string.substring(i)); + return n ? (date.m = d3_time_monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1; + } + function d3_time_parseLocaleFull(date, string, i) { + return d3_time_parse(date, d3_time_formats.c.toString(), string, i); + } + function d3_time_parseLocaleDate(date, string, i) { + return d3_time_parse(date, d3_time_formats.x.toString(), string, i); + } + function d3_time_parseLocaleTime(date, string, i) { + return d3_time_parse(date, d3_time_formats.X.toString(), string, i); + } + function d3_time_parseAmPm(date, string, i) { + var n = d3_time_periodLookup.get(string.substring(i, i += 2).toLowerCase()); + return n == null ? -1 : (date.p = n, i); + } + return d3_time_format; + } + var d3_time_formatPads = { + "-": "", + _: " ", + "0": "0" + }, d3_time_numberRe = /^\s*\d+/, d3_time_percentRe = /^%/; + function d3_time_formatPad(value, fill, width) { + var sign = value < 0 ? "-" : "", string = (sign ? -value : value) + "", length = string.length; + return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string); + } + function d3_time_formatRe(names) { + return new RegExp("^(?:" + names.map(d3.requote).join("|") + ")", "i"); + } + function d3_time_formatLookup(names) { + var map = new d3_Map(), i = -1, n = names.length; + while (++i < n) map.set(names[i].toLowerCase(), i); + return map; + } + function d3_time_parseWeekdayNumber(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 1)); + return n ? (date.w = +n[0], i + n[0].length) : -1; + } + function d3_time_parseWeekNumberSunday(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i)); + return n ? (date.U = +n[0], i + n[0].length) : -1; + } + function d3_time_parseWeekNumberMonday(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i)); + return n ? (date.W = +n[0], i + n[0].length) : -1; + } + function d3_time_parseFullYear(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 4)); + return n ? (date.y = +n[0], i + n[0].length) : -1; + } + function d3_time_parseYear(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 2)); + return n ? (date.y = d3_time_expandYear(+n[0]), i + n[0].length) : -1; + } + function d3_time_parseZone(date, string, i) { + return /^[+-]\d{4}$/.test(string = string.substring(i, i + 5)) ? (date.Z = -string, + i + 5) : -1; + } + function d3_time_expandYear(d) { + return d + (d > 68 ? 1900 : 2e3); + } + function d3_time_parseMonthNumber(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 2)); + return n ? (date.m = n[0] - 1, i + n[0].length) : -1; + } + function d3_time_parseDay(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 2)); + return n ? (date.d = +n[0], i + n[0].length) : -1; + } + function d3_time_parseDayOfYear(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 3)); + return n ? (date.j = +n[0], i + n[0].length) : -1; + } + function d3_time_parseHour24(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 2)); + return n ? (date.H = +n[0], i + n[0].length) : -1; + } + function d3_time_parseMinutes(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 2)); + return n ? (date.M = +n[0], i + n[0].length) : -1; + } + function d3_time_parseSeconds(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 2)); + return n ? (date.S = +n[0], i + n[0].length) : -1; + } + function d3_time_parseMilliseconds(date, string, i) { + d3_time_numberRe.lastIndex = 0; + var n = d3_time_numberRe.exec(string.substring(i, i + 3)); + return n ? (date.L = +n[0], i + n[0].length) : -1; + } + function d3_time_zone(d) { + var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = ~~(abs(z) / 60), zm = abs(z) % 60; + return zs + d3_time_formatPad(zh, "0", 2) + d3_time_formatPad(zm, "0", 2); + } + function d3_time_parseLiteralPercent(date, string, i) { + d3_time_percentRe.lastIndex = 0; + var n = d3_time_percentRe.exec(string.substring(i, i + 1)); + return n ? i + n[0].length : -1; + } + function d3_time_formatMulti(formats) { + var n = formats.length, i = -1; + while (++i < n) formats[i][0] = this(formats[i][0]); + return function(date) { + var i = 0, f = formats[i]; + while (!f[1](date)) f = formats[++i]; + return f[0](date); + }; + } + d3.locale = function(locale) { + return { + numberFormat: d3_locale_numberFormat(locale), + timeFormat: d3_locale_timeFormat(locale) + }; + }; + var d3_locale_enUS = d3.locale({ + decimal: ".", + thousands: ",", + grouping: [ 3 ], + currency: [ "$", "" ], + dateTime: "%a %b %e %X %Y", + date: "%m/%d/%Y", + time: "%H:%M:%S", + periods: [ "AM", "PM" ], + days: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ], + shortDays: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ], + months: [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ], + shortMonths: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ] + }); + d3.format = d3_locale_enUS.numberFormat; + d3.geo = {}; + function d3_adder() {} + d3_adder.prototype = { + s: 0, + t: 0, + add: function(y) { + d3_adderSum(y, this.t, d3_adderTemp); + d3_adderSum(d3_adderTemp.s, this.s, this); + if (this.s) this.t += d3_adderTemp.t; else this.s = d3_adderTemp.t; + }, + reset: function() { + this.s = this.t = 0; + }, + valueOf: function() { + return this.s; + } + }; + var d3_adderTemp = new d3_adder(); + function d3_adderSum(a, b, o) { + var x = o.s = a + b, bv = x - a, av = x - bv; + o.t = a - av + (b - bv); + } + d3.geo.stream = function(object, listener) { + if (object && d3_geo_streamObjectType.hasOwnProperty(object.type)) { + d3_geo_streamObjectType[object.type](object, listener); + } else { + d3_geo_streamGeometry(object, listener); + } + }; + function d3_geo_streamGeometry(geometry, listener) { + if (geometry && d3_geo_streamGeometryType.hasOwnProperty(geometry.type)) { + d3_geo_streamGeometryType[geometry.type](geometry, listener); + } + } + var d3_geo_streamObjectType = { + Feature: function(feature, listener) { + d3_geo_streamGeometry(feature.geometry, listener); + }, + FeatureCollection: function(object, listener) { + var features = object.features, i = -1, n = features.length; + while (++i < n) d3_geo_streamGeometry(features[i].geometry, listener); + } + }; + var d3_geo_streamGeometryType = { + Sphere: function(object, listener) { + listener.sphere(); + }, + Point: function(object, listener) { + object = object.coordinates; + listener.point(object[0], object[1], object[2]); + }, + MultiPoint: function(object, listener) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]); + }, + LineString: function(object, listener) { + d3_geo_streamLine(object.coordinates, listener, 0); + }, + MultiLineString: function(object, listener) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) d3_geo_streamLine(coordinates[i], listener, 0); + }, + Polygon: function(object, listener) { + d3_geo_streamPolygon(object.coordinates, listener); + }, + MultiPolygon: function(object, listener) { + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) d3_geo_streamPolygon(coordinates[i], listener); + }, + GeometryCollection: function(object, listener) { + var geometries = object.geometries, i = -1, n = geometries.length; + while (++i < n) d3_geo_streamGeometry(geometries[i], listener); + } + }; + function d3_geo_streamLine(coordinates, listener, closed) { + var i = -1, n = coordinates.length - closed, coordinate; + listener.lineStart(); + while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]); + listener.lineEnd(); + } + function d3_geo_streamPolygon(coordinates, listener) { + var i = -1, n = coordinates.length; + listener.polygonStart(); + while (++i < n) d3_geo_streamLine(coordinates[i], listener, 1); + listener.polygonEnd(); + } + d3.geo.area = function(object) { + d3_geo_areaSum = 0; + d3.geo.stream(object, d3_geo_area); + return d3_geo_areaSum; + }; + var d3_geo_areaSum, d3_geo_areaRingSum = new d3_adder(); + var d3_geo_area = { + sphere: function() { + d3_geo_areaSum += 4 * π; + }, + point: d3_noop, + lineStart: d3_noop, + lineEnd: d3_noop, + polygonStart: function() { + d3_geo_areaRingSum.reset(); + d3_geo_area.lineStart = d3_geo_areaRingStart; + }, + polygonEnd: function() { + var area = 2 * d3_geo_areaRingSum; + d3_geo_areaSum += area < 0 ? 4 * π + area : area; + d3_geo_area.lineStart = d3_geo_area.lineEnd = d3_geo_area.point = d3_noop; + } + }; + function d3_geo_areaRingStart() { + var λ00, φ00, λ0, cosφ0, sinφ0; + d3_geo_area.point = function(λ, φ) { + d3_geo_area.point = nextPoint; + λ0 = (λ00 = λ) * d3_radians, cosφ0 = Math.cos(φ = (φ00 = φ) * d3_radians / 2 + π / 4), + sinφ0 = Math.sin(φ); + }; + function nextPoint(λ, φ) { + λ *= d3_radians; + φ = φ * d3_radians / 2 + π / 4; + var dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, cosφ = Math.cos(φ), sinφ = Math.sin(φ), k = sinφ0 * sinφ, u = cosφ0 * cosφ + k * Math.cos(adλ), v = k * sdλ * Math.sin(adλ); + d3_geo_areaRingSum.add(Math.atan2(v, u)); + λ0 = λ, cosφ0 = cosφ, sinφ0 = sinφ; + } + d3_geo_area.lineEnd = function() { + nextPoint(λ00, φ00); + }; + } + function d3_geo_cartesian(spherical) { + var λ = spherical[0], φ = spherical[1], cosφ = Math.cos(φ); + return [ cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ) ]; + } + function d3_geo_cartesianDot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + } + function d3_geo_cartesianCross(a, b) { + return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ]; + } + function d3_geo_cartesianAdd(a, b) { + a[0] += b[0]; + a[1] += b[1]; + a[2] += b[2]; + } + function d3_geo_cartesianScale(vector, k) { + return [ vector[0] * k, vector[1] * k, vector[2] * k ]; + } + function d3_geo_cartesianNormalize(d) { + var l = Math.sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); + d[0] /= l; + d[1] /= l; + d[2] /= l; + } + function d3_geo_spherical(cartesian) { + return [ Math.atan2(cartesian[1], cartesian[0]), d3_asin(cartesian[2]) ]; + } + function d3_geo_sphericalEqual(a, b) { + return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε; + } + d3.geo.bounds = function() { + var λ0, φ0, λ1, φ1, λ_, λ__, φ__, p0, dλSum, ranges, range; + var bound = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function() { + bound.point = ringPoint; + bound.lineStart = ringStart; + bound.lineEnd = ringEnd; + dλSum = 0; + d3_geo_area.polygonStart(); + }, + polygonEnd: function() { + d3_geo_area.polygonEnd(); + bound.point = point; + bound.lineStart = lineStart; + bound.lineEnd = lineEnd; + if (d3_geo_areaRingSum < 0) λ0 = -(λ1 = 180), φ0 = -(φ1 = 90); else if (dλSum > ε) φ1 = 90; else if (dλSum < -ε) φ0 = -90; + range[0] = λ0, range[1] = λ1; + } + }; + function point(λ, φ) { + ranges.push(range = [ λ0 = λ, λ1 = λ ]); + if (φ < φ0) φ0 = φ; + if (φ > φ1) φ1 = φ; + } + function linePoint(λ, φ) { + var p = d3_geo_cartesian([ λ * d3_radians, φ * d3_radians ]); + if (p0) { + var normal = d3_geo_cartesianCross(p0, p), equatorial = [ normal[1], -normal[0], 0 ], inflection = d3_geo_cartesianCross(equatorial, normal); + d3_geo_cartesianNormalize(inflection); + inflection = d3_geo_spherical(inflection); + var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, antimeridian = abs(dλ) > 180; + if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) { + var φi = inflection[1] * d3_degrees; + if (φi > φ1) φ1 = φi; + } else if (λi = (λi + 360) % 360 - 180, antimeridian ^ (s * λ_ < λi && λi < s * λ)) { + var φi = -inflection[1] * d3_degrees; + if (φi < φ0) φ0 = φi; + } else { + if (φ < φ0) φ0 = φ; + if (φ > φ1) φ1 = φ; + } + if (antimeridian) { + if (λ < λ_) { + if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ; + } else { + if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ; + } + } else { + if (λ1 >= λ0) { + if (λ < λ0) λ0 = λ; + if (λ > λ1) λ1 = λ; + } else { + if (λ > λ_) { + if (angle(λ0, λ) > angle(λ0, λ1)) λ1 = λ; + } else { + if (angle(λ, λ1) > angle(λ0, λ1)) λ0 = λ; + } + } + } + } else { + point(λ, φ); + } + p0 = p, λ_ = λ; + } + function lineStart() { + bound.point = linePoint; + } + function lineEnd() { + range[0] = λ0, range[1] = λ1; + bound.point = point; + p0 = null; + } + function ringPoint(λ, φ) { + if (p0) { + var dλ = λ - λ_; + dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ; + } else λ__ = λ, φ__ = φ; + d3_geo_area.point(λ, φ); + linePoint(λ, φ); + } + function ringStart() { + d3_geo_area.lineStart(); + } + function ringEnd() { + ringPoint(λ__, φ__); + d3_geo_area.lineEnd(); + if (abs(dλSum) > ε) λ0 = -(λ1 = 180); + range[0] = λ0, range[1] = λ1; + p0 = null; + } + function angle(λ0, λ1) { + return (λ1 -= λ0) < 0 ? λ1 + 360 : λ1; + } + function compareRanges(a, b) { + return a[0] - b[0]; + } + function withinRange(x, range) { + return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x; + } + return function(feature) { + φ1 = λ1 = -(λ0 = φ0 = Infinity); + ranges = []; + d3.geo.stream(feature, bound); + var n = ranges.length; + if (n) { + ranges.sort(compareRanges); + for (var i = 1, a = ranges[0], b, merged = [ a ]; i < n; ++i) { + b = ranges[i]; + if (withinRange(b[0], a) || withinRange(b[1], a)) { + if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1]; + if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0]; + } else { + merged.push(a = b); + } + } + var best = -Infinity, dλ; + for (var n = merged.length - 1, i = 0, a = merged[n], b; i <= n; a = b, ++i) { + b = merged[i]; + if ((dλ = angle(a[1], b[0])) > best) best = dλ, λ0 = b[0], λ1 = a[1]; + } + } + ranges = range = null; + return λ0 === Infinity || φ0 === Infinity ? [ [ NaN, NaN ], [ NaN, NaN ] ] : [ [ λ0, φ0 ], [ λ1, φ1 ] ]; + }; + }(); + d3.geo.centroid = function(object) { + d3_geo_centroidW0 = d3_geo_centroidW1 = d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0; + d3.geo.stream(object, d3_geo_centroid); + var x = d3_geo_centroidX2, y = d3_geo_centroidY2, z = d3_geo_centroidZ2, m = x * x + y * y + z * z; + if (m < ε2) { + x = d3_geo_centroidX1, y = d3_geo_centroidY1, z = d3_geo_centroidZ1; + if (d3_geo_centroidW1 < ε) x = d3_geo_centroidX0, y = d3_geo_centroidY0, z = d3_geo_centroidZ0; + m = x * x + y * y + z * z; + if (m < ε2) return [ NaN, NaN ]; + } + return [ Math.atan2(y, x) * d3_degrees, d3_asin(z / Math.sqrt(m)) * d3_degrees ]; + }; + var d3_geo_centroidW0, d3_geo_centroidW1, d3_geo_centroidX0, d3_geo_centroidY0, d3_geo_centroidZ0, d3_geo_centroidX1, d3_geo_centroidY1, d3_geo_centroidZ1, d3_geo_centroidX2, d3_geo_centroidY2, d3_geo_centroidZ2; + var d3_geo_centroid = { + sphere: d3_noop, + point: d3_geo_centroidPoint, + lineStart: d3_geo_centroidLineStart, + lineEnd: d3_geo_centroidLineEnd, + polygonStart: function() { + d3_geo_centroid.lineStart = d3_geo_centroidRingStart; + }, + polygonEnd: function() { + d3_geo_centroid.lineStart = d3_geo_centroidLineStart; + } + }; + function d3_geo_centroidPoint(λ, φ) { + λ *= d3_radians; + var cosφ = Math.cos(φ *= d3_radians); + d3_geo_centroidPointXYZ(cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ)); + } + function d3_geo_centroidPointXYZ(x, y, z) { + ++d3_geo_centroidW0; + d3_geo_centroidX0 += (x - d3_geo_centroidX0) / d3_geo_centroidW0; + d3_geo_centroidY0 += (y - d3_geo_centroidY0) / d3_geo_centroidW0; + d3_geo_centroidZ0 += (z - d3_geo_centroidZ0) / d3_geo_centroidW0; + } + function d3_geo_centroidLineStart() { + var x0, y0, z0; + d3_geo_centroid.point = function(λ, φ) { + λ *= d3_radians; + var cosφ = Math.cos(φ *= d3_radians); + x0 = cosφ * Math.cos(λ); + y0 = cosφ * Math.sin(λ); + z0 = Math.sin(φ); + d3_geo_centroid.point = nextPoint; + d3_geo_centroidPointXYZ(x0, y0, z0); + }; + function nextPoint(λ, φ) { + λ *= d3_radians; + var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), w = Math.atan2(Math.sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z); + d3_geo_centroidW1 += w; + d3_geo_centroidX1 += w * (x0 + (x0 = x)); + d3_geo_centroidY1 += w * (y0 + (y0 = y)); + d3_geo_centroidZ1 += w * (z0 + (z0 = z)); + d3_geo_centroidPointXYZ(x0, y0, z0); + } + } + function d3_geo_centroidLineEnd() { + d3_geo_centroid.point = d3_geo_centroidPoint; + } + function d3_geo_centroidRingStart() { + var λ00, φ00, x0, y0, z0; + d3_geo_centroid.point = function(λ, φ) { + λ00 = λ, φ00 = φ; + d3_geo_centroid.point = nextPoint; + λ *= d3_radians; + var cosφ = Math.cos(φ *= d3_radians); + x0 = cosφ * Math.cos(λ); + y0 = cosφ * Math.sin(λ); + z0 = Math.sin(φ); + d3_geo_centroidPointXYZ(x0, y0, z0); + }; + d3_geo_centroid.lineEnd = function() { + nextPoint(λ00, φ00); + d3_geo_centroid.lineEnd = d3_geo_centroidLineEnd; + d3_geo_centroid.point = d3_geo_centroidPoint; + }; + function nextPoint(λ, φ) { + λ *= d3_radians; + var cosφ = Math.cos(φ *= d3_radians), x = cosφ * Math.cos(λ), y = cosφ * Math.sin(λ), z = Math.sin(φ), cx = y0 * z - z0 * y, cy = z0 * x - x0 * z, cz = x0 * y - y0 * x, m = Math.sqrt(cx * cx + cy * cy + cz * cz), u = x0 * x + y0 * y + z0 * z, v = m && -d3_acos(u) / m, w = Math.atan2(m, u); + d3_geo_centroidX2 += v * cx; + d3_geo_centroidY2 += v * cy; + d3_geo_centroidZ2 += v * cz; + d3_geo_centroidW1 += w; + d3_geo_centroidX1 += w * (x0 + (x0 = x)); + d3_geo_centroidY1 += w * (y0 + (y0 = y)); + d3_geo_centroidZ1 += w * (z0 + (z0 = z)); + d3_geo_centroidPointXYZ(x0, y0, z0); + } + } + function d3_true() { + return true; + } + function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) { + var subject = [], clip = []; + segments.forEach(function(segment) { + if ((n = segment.length - 1) <= 0) return; + var n, p0 = segment[0], p1 = segment[n]; + if (d3_geo_sphericalEqual(p0, p1)) { + listener.lineStart(); + for (var i = 0; i < n; ++i) listener.point((p0 = segment[i])[0], p0[1]); + listener.lineEnd(); + return; + } + var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), b = new d3_geo_clipPolygonIntersection(p0, null, a, false); + a.o = b; + subject.push(a); + clip.push(b); + a = new d3_geo_clipPolygonIntersection(p1, segment, null, false); + b = new d3_geo_clipPolygonIntersection(p1, null, a, true); + a.o = b; + subject.push(a); + clip.push(b); + }); + clip.sort(compare); + d3_geo_clipPolygonLinkCircular(subject); + d3_geo_clipPolygonLinkCircular(clip); + if (!subject.length) return; + for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) { + clip[i].e = entry = !entry; + } + var start = subject[0], points, point; + while (1) { + var current = start, isSubject = true; + while (current.v) if ((current = current.n) === start) return; + points = current.z; + listener.lineStart(); + do { + current.v = current.o.v = true; + if (current.e) { + if (isSubject) { + for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]); + } else { + interpolate(current.x, current.n.x, 1, listener); + } + current = current.n; + } else { + if (isSubject) { + points = current.p.z; + for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]); + } else { + interpolate(current.x, current.p.x, -1, listener); + } + current = current.p; + } + current = current.o; + points = current.z; + isSubject = !isSubject; + } while (!current.v); + listener.lineEnd(); + } + } + function d3_geo_clipPolygonLinkCircular(array) { + if (!(n = array.length)) return; + var n, i = 0, a = array[0], b; + while (++i < n) { + a.n = b = array[i]; + b.p = a; + a = b; + } + a.n = b = array[0]; + b.p = a; + } + function d3_geo_clipPolygonIntersection(point, points, other, entry) { + this.x = point; + this.z = points; + this.o = other; + this.e = entry; + this.v = false; + this.n = this.p = null; + } + function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) { + return function(rotate, listener) { + var line = clipLine(listener), rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]); + var clip = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function() { + clip.point = pointRing; + clip.lineStart = ringStart; + clip.lineEnd = ringEnd; + segments = []; + polygon = []; + }, + polygonEnd: function() { + clip.point = point; + clip.lineStart = lineStart; + clip.lineEnd = lineEnd; + segments = d3.merge(segments); + var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon); + if (segments.length) { + if (!polygonStarted) listener.polygonStart(), polygonStarted = true; + d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener); + } else if (clipStartInside) { + if (!polygonStarted) listener.polygonStart(), polygonStarted = true; + listener.lineStart(); + interpolate(null, null, 1, listener); + listener.lineEnd(); + } + if (polygonStarted) listener.polygonEnd(), polygonStarted = false; + segments = polygon = null; + }, + sphere: function() { + listener.polygonStart(); + listener.lineStart(); + interpolate(null, null, 1, listener); + listener.lineEnd(); + listener.polygonEnd(); + } + }; + function point(λ, φ) { + var point = rotate(λ, φ); + if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ); + } + function pointLine(λ, φ) { + var point = rotate(λ, φ); + line.point(point[0], point[1]); + } + function lineStart() { + clip.point = pointLine; + line.lineStart(); + } + function lineEnd() { + clip.point = point; + line.lineEnd(); + } + var segments; + var buffer = d3_geo_clipBufferListener(), ringListener = clipLine(buffer), polygonStarted = false, polygon, ring; + function pointRing(λ, φ) { + ring.push([ λ, φ ]); + var point = rotate(λ, φ); + ringListener.point(point[0], point[1]); + } + function ringStart() { + ringListener.lineStart(); + ring = []; + } + function ringEnd() { + pointRing(ring[0][0], ring[0][1]); + ringListener.lineEnd(); + var clean = ringListener.clean(), ringSegments = buffer.buffer(), segment, n = ringSegments.length; + ring.pop(); + polygon.push(ring); + ring = null; + if (!n) return; + if (clean & 1) { + segment = ringSegments[0]; + var n = segment.length - 1, i = -1, point; + if (n > 0) { + if (!polygonStarted) listener.polygonStart(), polygonStarted = true; + listener.lineStart(); + while (++i < n) listener.point((point = segment[i])[0], point[1]); + listener.lineEnd(); + } + return; + } + if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift())); + segments.push(ringSegments.filter(d3_geo_clipSegmentLength1)); + } + return clip; + }; + } + function d3_geo_clipSegmentLength1(segment) { + return segment.length > 1; + } + function d3_geo_clipBufferListener() { + var lines = [], line; + return { + lineStart: function() { + lines.push(line = []); + }, + point: function(λ, φ) { + line.push([ λ, φ ]); + }, + lineEnd: d3_noop, + buffer: function() { + var buffer = lines; + lines = []; + line = null; + return buffer; + }, + rejoin: function() { + if (lines.length > 1) lines.push(lines.pop().concat(lines.shift())); + } + }; + } + function d3_geo_clipSort(a, b) { + return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]); + } + function d3_geo_pointInPolygon(point, polygon) { + var meridian = point[0], parallel = point[1], meridianNormal = [ Math.sin(meridian), -Math.cos(meridian), 0 ], polarAngle = 0, winding = 0; + d3_geo_areaRingSum.reset(); + for (var i = 0, n = polygon.length; i < n; ++i) { + var ring = polygon[i], m = ring.length; + if (!m) continue; + var point0 = ring[0], λ0 = point0[0], φ0 = point0[1] / 2 + π / 4, sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), j = 1; + while (true) { + if (j === m) j = 0; + point = ring[j]; + var λ = point[0], φ = point[1] / 2 + π / 4, sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, sdλ = dλ >= 0 ? 1 : -1, adλ = sdλ * dλ, antimeridian = adλ > π, k = sinφ0 * sinφ; + d3_geo_areaRingSum.add(Math.atan2(k * sdλ * Math.sin(adλ), cosφ0 * cosφ + k * Math.cos(adλ))); + polarAngle += antimeridian ? dλ + sdλ * τ : dλ; + if (antimeridian ^ λ0 >= meridian ^ λ >= meridian) { + var arc = d3_geo_cartesianCross(d3_geo_cartesian(point0), d3_geo_cartesian(point)); + d3_geo_cartesianNormalize(arc); + var intersection = d3_geo_cartesianCross(meridianNormal, arc); + d3_geo_cartesianNormalize(intersection); + var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]); + if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) { + winding += antimeridian ^ dλ >= 0 ? 1 : -1; + } + } + if (!j++) break; + λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point; + } + } + return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < 0) ^ winding & 1; + } + var d3_geo_clipAntimeridian = d3_geo_clip(d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, [ -π, -π / 2 ]); + function d3_geo_clipAntimeridianLine(listener) { + var λ0 = NaN, φ0 = NaN, sλ0 = NaN, clean; + return { + lineStart: function() { + listener.lineStart(); + clean = 1; + }, + point: function(λ1, φ1) { + var sλ1 = λ1 > 0 ? π : -π, dλ = abs(λ1 - λ0); + if (abs(dλ - π) < ε) { + listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ); + listener.point(sλ0, φ0); + listener.lineEnd(); + listener.lineStart(); + listener.point(sλ1, φ0); + listener.point(λ1, φ0); + clean = 0; + } else if (sλ0 !== sλ1 && dλ >= π) { + if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε; + if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε; + φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1); + listener.point(sλ0, φ0); + listener.lineEnd(); + listener.lineStart(); + listener.point(sλ1, φ0); + clean = 0; + } + listener.point(λ0 = λ1, φ0 = φ1); + sλ0 = sλ1; + }, + lineEnd: function() { + listener.lineEnd(); + λ0 = φ0 = NaN; + }, + clean: function() { + return 2 - clean; + } + }; + } + function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) { + var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1); + return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) : (φ0 + φ1) / 2; + } + function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) { + var φ; + if (from == null) { + φ = direction * halfπ; + listener.point(-π, φ); + listener.point(0, φ); + listener.point(π, φ); + listener.point(π, 0); + listener.point(π, -φ); + listener.point(0, -φ); + listener.point(-π, -φ); + listener.point(-π, 0); + listener.point(-π, φ); + } else if (abs(from[0] - to[0]) > ε) { + var s = from[0] < to[0] ? π : -π; + φ = direction * s / 2; + listener.point(-s, φ); + listener.point(0, φ); + listener.point(s, φ); + } else { + listener.point(to[0], to[1]); + } + } + function d3_geo_clipCircle(radius) { + var cr = Math.cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > ε, interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians); + return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [ 0, -radius ] : [ -π, radius - π ]); + function visible(λ, φ) { + return Math.cos(λ) * Math.cos(φ) > cr; + } + function clipLine(listener) { + var point0, c0, v0, v00, clean; + return { + lineStart: function() { + v00 = v0 = false; + clean = 1; + }, + point: function(λ, φ) { + var point1 = [ λ, φ ], point2, v = visible(λ, φ), c = smallRadius ? v ? 0 : code(λ, φ) : v ? code(λ + (λ < 0 ? π : -π), φ) : 0; + if (!point0 && (v00 = v0 = v)) listener.lineStart(); + if (v !== v0) { + point2 = intersect(point0, point1); + if (d3_geo_sphericalEqual(point0, point2) || d3_geo_sphericalEqual(point1, point2)) { + point1[0] += ε; + point1[1] += ε; + v = visible(point1[0], point1[1]); + } + } + if (v !== v0) { + clean = 0; + if (v) { + listener.lineStart(); + point2 = intersect(point1, point0); + listener.point(point2[0], point2[1]); + } else { + point2 = intersect(point0, point1); + listener.point(point2[0], point2[1]); + listener.lineEnd(); + } + point0 = point2; + } else if (notHemisphere && point0 && smallRadius ^ v) { + var t; + if (!(c & c0) && (t = intersect(point1, point0, true))) { + clean = 0; + if (smallRadius) { + listener.lineStart(); + listener.point(t[0][0], t[0][1]); + listener.point(t[1][0], t[1][1]); + listener.lineEnd(); + } else { + listener.point(t[1][0], t[1][1]); + listener.lineEnd(); + listener.lineStart(); + listener.point(t[0][0], t[0][1]); + } + } + } + if (v && (!point0 || !d3_geo_sphericalEqual(point0, point1))) { + listener.point(point1[0], point1[1]); + } + point0 = point1, v0 = v, c0 = c; + }, + lineEnd: function() { + if (v0) listener.lineEnd(); + point0 = null; + }, + clean: function() { + return clean | (v00 && v0) << 1; + } + }; + } + function intersect(a, b, two) { + var pa = d3_geo_cartesian(a), pb = d3_geo_cartesian(b); + var n1 = [ 1, 0, 0 ], n2 = d3_geo_cartesianCross(pa, pb), n2n2 = d3_geo_cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2; + if (!determinant) return !two && a; + var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = d3_geo_cartesianCross(n1, n2), A = d3_geo_cartesianScale(n1, c1), B = d3_geo_cartesianScale(n2, c2); + d3_geo_cartesianAdd(A, B); + var u = n1xn2, w = d3_geo_cartesianDot(A, u), uu = d3_geo_cartesianDot(u, u), t2 = w * w - uu * (d3_geo_cartesianDot(A, A) - 1); + if (t2 < 0) return; + var t = Math.sqrt(t2), q = d3_geo_cartesianScale(u, (-w - t) / uu); + d3_geo_cartesianAdd(q, A); + q = d3_geo_spherical(q); + if (!two) return q; + var λ0 = a[0], λ1 = b[0], φ0 = a[1], φ1 = b[1], z; + if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z; + var δλ = λ1 - λ0, polar = abs(δλ - π) < ε, meridian = polar || δλ < ε; + if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z; + if (meridian ? polar ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) { + var q1 = d3_geo_cartesianScale(u, (-w + t) / uu); + d3_geo_cartesianAdd(q1, A); + return [ q, d3_geo_spherical(q1) ]; + } + } + function code(λ, φ) { + var r = smallRadius ? radius : π - radius, code = 0; + if (λ < -r) code |= 1; else if (λ > r) code |= 2; + if (φ < -r) code |= 4; else if (φ > r) code |= 8; + return code; + } + } + function d3_geom_clipLine(x0, y0, x1, y1) { + return function(line) { + var a = line.a, b = line.b, ax = a.x, ay = a.y, bx = b.x, by = b.y, t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r; + r = x0 - ax; + if (!dx && r > 0) return; + r /= dx; + if (dx < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dx > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + r = x1 - ax; + if (!dx && r < 0) return; + r /= dx; + if (dx < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dx > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + r = y0 - ay; + if (!dy && r > 0) return; + r /= dy; + if (dy < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dy > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + r = y1 - ay; + if (!dy && r < 0) return; + r /= dy; + if (dy < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dy > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + if (t0 > 0) line.a = { + x: ax + t0 * dx, + y: ay + t0 * dy + }; + if (t1 < 1) line.b = { + x: ax + t1 * dx, + y: ay + t1 * dy + }; + return line; + }; + } + var d3_geo_clipExtentMAX = 1e9; + d3.geo.clipExtent = function() { + var x0, y0, x1, y1, stream, clip, clipExtent = { + stream: function(output) { + if (stream) stream.valid = false; + stream = clip(output); + stream.valid = true; + return stream; + }, + extent: function(_) { + if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ]; + clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]); + if (stream) stream.valid = false, stream = null; + return clipExtent; + } + }; + return clipExtent.extent([ [ 0, 0 ], [ 960, 500 ] ]); + }; + function d3_geo_clipExtent(x0, y0, x1, y1) { + return function(listener) { + var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring; + var clip = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function() { + listener = bufferListener; + segments = []; + polygon = []; + clean = true; + }, + polygonEnd: function() { + listener = listener_; + segments = d3.merge(segments); + var clipStartInside = insidePolygon([ x0, y1 ]), inside = clean && clipStartInside, visible = segments.length; + if (inside || visible) { + listener.polygonStart(); + if (inside) { + listener.lineStart(); + interpolate(null, null, 1, listener); + listener.lineEnd(); + } + if (visible) { + d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener); + } + listener.polygonEnd(); + } + segments = polygon = ring = null; + } + }; + function insidePolygon(p) { + var wn = 0, n = polygon.length, y = p[1]; + for (var i = 0; i < n; ++i) { + for (var j = 1, v = polygon[i], m = v.length, a = v[0], b; j < m; ++j) { + b = v[j]; + if (a[1] <= y) { + if (b[1] > y && d3_cross2d(a, b, p) > 0) ++wn; + } else { + if (b[1] <= y && d3_cross2d(a, b, p) < 0) --wn; + } + a = b; + } + } + return wn !== 0; + } + function interpolate(from, to, direction, listener) { + var a = 0, a1 = 0; + if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoints(from, to) < 0 ^ direction > 0) { + do { + listener.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0); + } while ((a = (a + direction + 4) % 4) !== a1); + } else { + listener.point(to[0], to[1]); + } + } + function pointVisible(x, y) { + return x0 <= x && x <= x1 && y0 <= y && y <= y1; + } + function point(x, y) { + if (pointVisible(x, y)) listener.point(x, y); + } + var x__, y__, v__, x_, y_, v_, first, clean; + function lineStart() { + clip.point = linePoint; + if (polygon) polygon.push(ring = []); + first = true; + v_ = false; + x_ = y_ = NaN; + } + function lineEnd() { + if (segments) { + linePoint(x__, y__); + if (v__ && v_) bufferListener.rejoin(); + segments.push(bufferListener.buffer()); + } + clip.point = point; + if (v_) listener.lineEnd(); + } + function linePoint(x, y) { + x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x)); + y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y)); + var v = pointVisible(x, y); + if (polygon) ring.push([ x, y ]); + if (first) { + x__ = x, y__ = y, v__ = v; + first = false; + if (v) { + listener.lineStart(); + listener.point(x, y); + } + } else { + if (v && v_) listener.point(x, y); else { + var l = { + a: { + x: x_, + y: y_ + }, + b: { + x: x, + y: y + } + }; + if (clipLine(l)) { + if (!v_) { + listener.lineStart(); + listener.point(l.a.x, l.a.y); + } + listener.point(l.b.x, l.b.y); + if (!v) listener.lineEnd(); + clean = false; + } else if (v) { + listener.lineStart(); + listener.point(x, y); + clean = false; + } + } + } + x_ = x, y_ = y, v_ = v; + } + return clip; + }; + function corner(p, direction) { + return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2; + } + function compare(a, b) { + return comparePoints(a.x, b.x); + } + function comparePoints(a, b) { + var ca = corner(a, 1), cb = corner(b, 1); + return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0]; + } + } + function d3_geo_compose(a, b) { + function compose(x, y) { + return x = a(x, y), b(x[0], x[1]); + } + if (a.invert && b.invert) compose.invert = function(x, y) { + return x = b.invert(x, y), x && a.invert(x[0], x[1]); + }; + return compose; + } + function d3_geo_conic(projectAt) { + var φ0 = 0, φ1 = π / 3, m = d3_geo_projectionMutator(projectAt), p = m(φ0, φ1); + p.parallels = function(_) { + if (!arguments.length) return [ φ0 / π * 180, φ1 / π * 180 ]; + return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180); + }; + return p; + } + function d3_geo_conicEqualArea(φ0, φ1) { + var sinφ0 = Math.sin(φ0), n = (sinφ0 + Math.sin(φ1)) / 2, C = 1 + sinφ0 * (2 * n - sinφ0), ρ0 = Math.sqrt(C) / n; + function forward(λ, φ) { + var ρ = Math.sqrt(C - 2 * n * Math.sin(φ)) / n; + return [ ρ * Math.sin(λ *= n), ρ0 - ρ * Math.cos(λ) ]; + } + forward.invert = function(x, y) { + var ρ0_y = ρ0 - y; + return [ Math.atan2(x, ρ0_y) / n, d3_asin((C - (x * x + ρ0_y * ρ0_y) * n * n) / (2 * n)) ]; + }; + return forward; + } + (d3.geo.conicEqualArea = function() { + return d3_geo_conic(d3_geo_conicEqualArea); + }).raw = d3_geo_conicEqualArea; + d3.geo.albers = function() { + return d3.geo.conicEqualArea().rotate([ 96, 0 ]).center([ -.6, 38.7 ]).parallels([ 29.5, 45.5 ]).scale(1070); + }; + d3.geo.albersUsa = function() { + var lower48 = d3.geo.albers(); + var alaska = d3.geo.conicEqualArea().rotate([ 154, 0 ]).center([ -2, 58.5 ]).parallels([ 55, 65 ]); + var hawaii = d3.geo.conicEqualArea().rotate([ 157, 0 ]).center([ -3, 19.9 ]).parallels([ 8, 18 ]); + var point, pointStream = { + point: function(x, y) { + point = [ x, y ]; + } + }, lower48Point, alaskaPoint, hawaiiPoint; + function albersUsa(coordinates) { + var x = coordinates[0], y = coordinates[1]; + point = null; + (lower48Point(x, y), point) || (alaskaPoint(x, y), point) || hawaiiPoint(x, y); + return point; + } + albersUsa.invert = function(coordinates) { + var k = lower48.scale(), t = lower48.translate(), x = (coordinates[0] - t[0]) / k, y = (coordinates[1] - t[1]) / k; + return (y >= .12 && y < .234 && x >= -.425 && x < -.214 ? alaska : y >= .166 && y < .234 && x >= -.214 && x < -.115 ? hawaii : lower48).invert(coordinates); + }; + albersUsa.stream = function(stream) { + var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream); + return { + point: function(x, y) { + lower48Stream.point(x, y); + alaskaStream.point(x, y); + hawaiiStream.point(x, y); + }, + sphere: function() { + lower48Stream.sphere(); + alaskaStream.sphere(); + hawaiiStream.sphere(); + }, + lineStart: function() { + lower48Stream.lineStart(); + alaskaStream.lineStart(); + hawaiiStream.lineStart(); + }, + lineEnd: function() { + lower48Stream.lineEnd(); + alaskaStream.lineEnd(); + hawaiiStream.lineEnd(); + }, + polygonStart: function() { + lower48Stream.polygonStart(); + alaskaStream.polygonStart(); + hawaiiStream.polygonStart(); + }, + polygonEnd: function() { + lower48Stream.polygonEnd(); + alaskaStream.polygonEnd(); + hawaiiStream.polygonEnd(); + } + }; + }; + albersUsa.precision = function(_) { + if (!arguments.length) return lower48.precision(); + lower48.precision(_); + alaska.precision(_); + hawaii.precision(_); + return albersUsa; + }; + albersUsa.scale = function(_) { + if (!arguments.length) return lower48.scale(); + lower48.scale(_); + alaska.scale(_ * .35); + hawaii.scale(_); + return albersUsa.translate(lower48.translate()); + }; + albersUsa.translate = function(_) { + if (!arguments.length) return lower48.translate(); + var k = lower48.scale(), x = +_[0], y = +_[1]; + lower48Point = lower48.translate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point; + alaskaPoint = alaska.translate([ x - .307 * k, y + .201 * k ]).clipExtent([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point; + hawaiiPoint = hawaii.translate([ x - .205 * k, y + .212 * k ]).clipExtent([ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point; + return albersUsa; + }; + return albersUsa.scale(1070); + }; + var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = { + point: d3_noop, + lineStart: d3_noop, + lineEnd: d3_noop, + polygonStart: function() { + d3_geo_pathAreaPolygon = 0; + d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart; + }, + polygonEnd: function() { + d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop; + d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2); + } + }; + function d3_geo_pathAreaRingStart() { + var x00, y00, x0, y0; + d3_geo_pathArea.point = function(x, y) { + d3_geo_pathArea.point = nextPoint; + x00 = x0 = x, y00 = y0 = y; + }; + function nextPoint(x, y) { + d3_geo_pathAreaPolygon += y0 * x - x0 * y; + x0 = x, y0 = y; + } + d3_geo_pathArea.lineEnd = function() { + nextPoint(x00, y00); + }; + } + var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1; + var d3_geo_pathBounds = { + point: d3_geo_pathBoundsPoint, + lineStart: d3_noop, + lineEnd: d3_noop, + polygonStart: d3_noop, + polygonEnd: d3_noop + }; + function d3_geo_pathBoundsPoint(x, y) { + if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x; + if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x; + if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y; + if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y; + } + function d3_geo_pathBuffer() { + var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = []; + var stream = { + point: point, + lineStart: function() { + stream.point = pointLineStart; + }, + lineEnd: lineEnd, + polygonStart: function() { + stream.lineEnd = lineEndPolygon; + }, + polygonEnd: function() { + stream.lineEnd = lineEnd; + stream.point = point; + }, + pointRadius: function(_) { + pointCircle = d3_geo_pathBufferCircle(_); + return stream; + }, + result: function() { + if (buffer.length) { + var result = buffer.join(""); + buffer = []; + return result; + } + } + }; + function point(x, y) { + buffer.push("M", x, ",", y, pointCircle); + } + function pointLineStart(x, y) { + buffer.push("M", x, ",", y); + stream.point = pointLine; + } + function pointLine(x, y) { + buffer.push("L", x, ",", y); + } + function lineEnd() { + stream.point = point; + } + function lineEndPolygon() { + buffer.push("Z"); + } + return stream; + } + function d3_geo_pathBufferCircle(radius) { + return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius + "z"; + } + var d3_geo_pathCentroid = { + point: d3_geo_pathCentroidPoint, + lineStart: d3_geo_pathCentroidLineStart, + lineEnd: d3_geo_pathCentroidLineEnd, + polygonStart: function() { + d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart; + }, + polygonEnd: function() { + d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint; + d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart; + d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd; + } + }; + function d3_geo_pathCentroidPoint(x, y) { + d3_geo_centroidX0 += x; + d3_geo_centroidY0 += y; + ++d3_geo_centroidZ0; + } + function d3_geo_pathCentroidLineStart() { + var x0, y0; + d3_geo_pathCentroid.point = function(x, y) { + d3_geo_pathCentroid.point = nextPoint; + d3_geo_pathCentroidPoint(x0 = x, y0 = y); + }; + function nextPoint(x, y) { + var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy); + d3_geo_centroidX1 += z * (x0 + x) / 2; + d3_geo_centroidY1 += z * (y0 + y) / 2; + d3_geo_centroidZ1 += z; + d3_geo_pathCentroidPoint(x0 = x, y0 = y); + } + } + function d3_geo_pathCentroidLineEnd() { + d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint; + } + function d3_geo_pathCentroidRingStart() { + var x00, y00, x0, y0; + d3_geo_pathCentroid.point = function(x, y) { + d3_geo_pathCentroid.point = nextPoint; + d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y); + }; + function nextPoint(x, y) { + var dx = x - x0, dy = y - y0, z = Math.sqrt(dx * dx + dy * dy); + d3_geo_centroidX1 += z * (x0 + x) / 2; + d3_geo_centroidY1 += z * (y0 + y) / 2; + d3_geo_centroidZ1 += z; + z = y0 * x - x0 * y; + d3_geo_centroidX2 += z * (x0 + x); + d3_geo_centroidY2 += z * (y0 + y); + d3_geo_centroidZ2 += z * 3; + d3_geo_pathCentroidPoint(x0 = x, y0 = y); + } + d3_geo_pathCentroid.lineEnd = function() { + nextPoint(x00, y00); + }; + } + function d3_geo_pathContext(context) { + var pointRadius = 4.5; + var stream = { + point: point, + lineStart: function() { + stream.point = pointLineStart; + }, + lineEnd: lineEnd, + polygonStart: function() { + stream.lineEnd = lineEndPolygon; + }, + polygonEnd: function() { + stream.lineEnd = lineEnd; + stream.point = point; + }, + pointRadius: function(_) { + pointRadius = _; + return stream; + }, + result: d3_noop + }; + function point(x, y) { + context.moveTo(x, y); + context.arc(x, y, pointRadius, 0, τ); + } + function pointLineStart(x, y) { + context.moveTo(x, y); + stream.point = pointLine; + } + function pointLine(x, y) { + context.lineTo(x, y); + } + function lineEnd() { + stream.point = point; + } + function lineEndPolygon() { + context.closePath(); + } + return stream; + } + function d3_geo_resample(project) { + var δ2 = .5, cosMinDistance = Math.cos(30 * d3_radians), maxDepth = 16; + function resample(stream) { + return (maxDepth ? resampleRecursive : resampleNone)(stream); + } + function resampleNone(stream) { + return d3_geo_transformPoint(stream, function(x, y) { + x = project(x, y); + stream.point(x[0], x[1]); + }); + } + function resampleRecursive(stream) { + var λ00, φ00, x00, y00, a00, b00, c00, λ0, x0, y0, a0, b0, c0; + var resample = { + point: point, + lineStart: lineStart, + lineEnd: lineEnd, + polygonStart: function() { + stream.polygonStart(); + resample.lineStart = ringStart; + }, + polygonEnd: function() { + stream.polygonEnd(); + resample.lineStart = lineStart; + } + }; + function point(x, y) { + x = project(x, y); + stream.point(x[0], x[1]); + } + function lineStart() { + x0 = NaN; + resample.point = linePoint; + stream.lineStart(); + } + function linePoint(λ, φ) { + var c = d3_geo_cartesian([ λ, φ ]), p = project(λ, φ); + resampleLineTo(x0, y0, λ0, a0, b0, c0, x0 = p[0], y0 = p[1], λ0 = λ, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream); + stream.point(x0, y0); + } + function lineEnd() { + resample.point = point; + stream.lineEnd(); + } + function ringStart() { + lineStart(); + resample.point = ringPoint; + resample.lineEnd = ringEnd; + } + function ringPoint(λ, φ) { + linePoint(λ00 = λ, φ00 = φ), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0; + resample.point = linePoint; + } + function ringEnd() { + resampleLineTo(x0, y0, λ0, a0, b0, c0, x00, y00, λ00, a00, b00, c00, maxDepth, stream); + resample.lineEnd = lineEnd; + lineEnd(); + } + return resample; + } + function resampleLineTo(x0, y0, λ0, a0, b0, c0, x1, y1, λ1, a1, b1, c1, depth, stream) { + var dx = x1 - x0, dy = y1 - y0, d2 = dx * dx + dy * dy; + if (d2 > 4 * δ2 && depth--) { + var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), λ2 = abs(abs(c) - 1) < ε || abs(λ0 - λ1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], dx2 = x2 - x0, dy2 = y2 - y0, dz = dy * dx2 - dx * dy2; + if (dz * dz / d2 > δ2 || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { + resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream); + stream.point(x2, y2); + resampleLineTo(x2, y2, λ2, a, b, c, x1, y1, λ1, a1, b1, c1, depth, stream); + } + } + } + resample.precision = function(_) { + if (!arguments.length) return Math.sqrt(δ2); + maxDepth = (δ2 = _ * _) > 0 && 16; + return resample; + }; + return resample; + } + d3.geo.path = function() { + var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream; + function path(object) { + if (object) { + if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments)); + if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream); + d3.geo.stream(object, cacheStream); + } + return contextStream.result(); + } + path.area = function(object) { + d3_geo_pathAreaSum = 0; + d3.geo.stream(object, projectStream(d3_geo_pathArea)); + return d3_geo_pathAreaSum; + }; + path.centroid = function(object) { + d3_geo_centroidX0 = d3_geo_centroidY0 = d3_geo_centroidZ0 = d3_geo_centroidX1 = d3_geo_centroidY1 = d3_geo_centroidZ1 = d3_geo_centroidX2 = d3_geo_centroidY2 = d3_geo_centroidZ2 = 0; + d3.geo.stream(object, projectStream(d3_geo_pathCentroid)); + return d3_geo_centroidZ2 ? [ d3_geo_centroidX2 / d3_geo_centroidZ2, d3_geo_centroidY2 / d3_geo_centroidZ2 ] : d3_geo_centroidZ1 ? [ d3_geo_centroidX1 / d3_geo_centroidZ1, d3_geo_centroidY1 / d3_geo_centroidZ1 ] : d3_geo_centroidZ0 ? [ d3_geo_centroidX0 / d3_geo_centroidZ0, d3_geo_centroidY0 / d3_geo_centroidZ0 ] : [ NaN, NaN ]; + }; + path.bounds = function(object) { + d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity); + d3.geo.stream(object, projectStream(d3_geo_pathBounds)); + return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ]; + }; + path.projection = function(_) { + if (!arguments.length) return projection; + projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity; + return reset(); + }; + path.context = function(_) { + if (!arguments.length) return context; + contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_); + if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius); + return reset(); + }; + path.pointRadius = function(_) { + if (!arguments.length) return pointRadius; + pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_); + return path; + }; + function reset() { + cacheStream = null; + return path; + } + return path.projection(d3.geo.albersUsa()).context(null); + }; + function d3_geo_pathProjectStream(project) { + var resample = d3_geo_resample(function(x, y) { + return project([ x * d3_degrees, y * d3_degrees ]); + }); + return function(stream) { + return d3_geo_projectionRadians(resample(stream)); + }; + } + d3.geo.transform = function(methods) { + return { + stream: function(stream) { + var transform = new d3_geo_transform(stream); + for (var k in methods) transform[k] = methods[k]; + return transform; + } + }; + }; + function d3_geo_transform(stream) { + this.stream = stream; + } + d3_geo_transform.prototype = { + point: function(x, y) { + this.stream.point(x, y); + }, + sphere: function() { + this.stream.sphere(); + }, + lineStart: function() { + this.stream.lineStart(); + }, + lineEnd: function() { + this.stream.lineEnd(); + }, + polygonStart: function() { + this.stream.polygonStart(); + }, + polygonEnd: function() { + this.stream.polygonEnd(); + } + }; + function d3_geo_transformPoint(stream, point) { + return { + point: point, + sphere: function() { + stream.sphere(); + }, + lineStart: function() { + stream.lineStart(); + }, + lineEnd: function() { + stream.lineEnd(); + }, + polygonStart: function() { + stream.polygonStart(); + }, + polygonEnd: function() { + stream.polygonEnd(); + } + }; + } + d3.geo.projection = d3_geo_projection; + d3.geo.projectionMutator = d3_geo_projectionMutator; + function d3_geo_projection(project) { + return d3_geo_projectionMutator(function() { + return project; + })(); + } + function d3_geo_projectionMutator(projectAt) { + var project, rotate, projectRotate, projectResample = d3_geo_resample(function(x, y) { + x = project(x, y); + return [ x[0] * k + δx, δy - x[1] * k ]; + }), k = 150, x = 480, y = 250, λ = 0, φ = 0, δλ = 0, δφ = 0, δγ = 0, δx, δy, preclip = d3_geo_clipAntimeridian, postclip = d3_identity, clipAngle = null, clipExtent = null, stream; + function projection(point) { + point = projectRotate(point[0] * d3_radians, point[1] * d3_radians); + return [ point[0] * k + δx, δy - point[1] * k ]; + } + function invert(point) { + point = projectRotate.invert((point[0] - δx) / k, (δy - point[1]) / k); + return point && [ point[0] * d3_degrees, point[1] * d3_degrees ]; + } + projection.stream = function(output) { + if (stream) stream.valid = false; + stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output)))); + stream.valid = true; + return stream; + }; + projection.clipAngle = function(_) { + if (!arguments.length) return clipAngle; + preclip = _ == null ? (clipAngle = _, d3_geo_clipAntimeridian) : d3_geo_clipCircle((clipAngle = +_) * d3_radians); + return invalidate(); + }; + projection.clipExtent = function(_) { + if (!arguments.length) return clipExtent; + clipExtent = _; + postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity; + return invalidate(); + }; + projection.scale = function(_) { + if (!arguments.length) return k; + k = +_; + return reset(); + }; + projection.translate = function(_) { + if (!arguments.length) return [ x, y ]; + x = +_[0]; + y = +_[1]; + return reset(); + }; + projection.center = function(_) { + if (!arguments.length) return [ λ * d3_degrees, φ * d3_degrees ]; + λ = _[0] % 360 * d3_radians; + φ = _[1] % 360 * d3_radians; + return reset(); + }; + projection.rotate = function(_) { + if (!arguments.length) return [ δλ * d3_degrees, δφ * d3_degrees, δγ * d3_degrees ]; + δλ = _[0] % 360 * d3_radians; + δφ = _[1] % 360 * d3_radians; + δγ = _.length > 2 ? _[2] % 360 * d3_radians : 0; + return reset(); + }; + d3.rebind(projection, projectResample, "precision"); + function reset() { + projectRotate = d3_geo_compose(rotate = d3_geo_rotation(δλ, δφ, δγ), project); + var center = project(λ, φ); + δx = x - center[0] * k; + δy = y + center[1] * k; + return invalidate(); + } + function invalidate() { + if (stream) stream.valid = false, stream = null; + return projection; + } + return function() { + project = projectAt.apply(this, arguments); + projection.invert = project.invert && invert; + return reset(); + }; + } + function d3_geo_projectionRadians(stream) { + return d3_geo_transformPoint(stream, function(x, y) { + stream.point(x * d3_radians, y * d3_radians); + }); + } + function d3_geo_equirectangular(λ, φ) { + return [ λ, φ ]; + } + (d3.geo.equirectangular = function() { + return d3_geo_projection(d3_geo_equirectangular); + }).raw = d3_geo_equirectangular.invert = d3_geo_equirectangular; + d3.geo.rotation = function(rotate) { + rotate = d3_geo_rotation(rotate[0] % 360 * d3_radians, rotate[1] * d3_radians, rotate.length > 2 ? rotate[2] * d3_radians : 0); + function forward(coordinates) { + coordinates = rotate(coordinates[0] * d3_radians, coordinates[1] * d3_radians); + return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates; + } + forward.invert = function(coordinates) { + coordinates = rotate.invert(coordinates[0] * d3_radians, coordinates[1] * d3_radians); + return coordinates[0] *= d3_degrees, coordinates[1] *= d3_degrees, coordinates; + }; + return forward; + }; + function d3_geo_identityRotation(λ, φ) { + return [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ]; + } + d3_geo_identityRotation.invert = d3_geo_equirectangular; + function d3_geo_rotation(δλ, δφ, δγ) { + return δλ ? δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ) : δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) : d3_geo_identityRotation; + } + function d3_geo_forwardRotationλ(δλ) { + return function(λ, φ) { + return λ += δλ, [ λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ ]; + }; + } + function d3_geo_rotationλ(δλ) { + var rotation = d3_geo_forwardRotationλ(δλ); + rotation.invert = d3_geo_forwardRotationλ(-δλ); + return rotation; + } + function d3_geo_rotationφγ(δφ, δγ) { + var cosδφ = Math.cos(δφ), sinδφ = Math.sin(δφ), cosδγ = Math.cos(δγ), sinδγ = Math.sin(δγ); + function rotation(λ, φ) { + var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδφ + x * sinδφ; + return [ Math.atan2(y * cosδγ - k * sinδγ, x * cosδφ - z * sinδφ), d3_asin(k * cosδγ + y * sinδγ) ]; + } + rotation.invert = function(λ, φ) { + var cosφ = Math.cos(φ), x = Math.cos(λ) * cosφ, y = Math.sin(λ) * cosφ, z = Math.sin(φ), k = z * cosδγ - y * sinδγ; + return [ Math.atan2(y * cosδγ + z * sinδγ, x * cosδφ + k * sinδφ), d3_asin(k * cosδφ - x * sinδφ) ]; + }; + return rotation; + } + d3.geo.circle = function() { + var origin = [ 0, 0 ], angle, precision = 6, interpolate; + function circle() { + var center = typeof origin === "function" ? origin.apply(this, arguments) : origin, rotate = d3_geo_rotation(-center[0] * d3_radians, -center[1] * d3_radians, 0).invert, ring = []; + interpolate(null, null, 1, { + point: function(x, y) { + ring.push(x = rotate(x, y)); + x[0] *= d3_degrees, x[1] *= d3_degrees; + } + }); + return { + type: "Polygon", + coordinates: [ ring ] + }; + } + circle.origin = function(x) { + if (!arguments.length) return origin; + origin = x; + return circle; + }; + circle.angle = function(x) { + if (!arguments.length) return angle; + interpolate = d3_geo_circleInterpolate((angle = +x) * d3_radians, precision * d3_radians); + return circle; + }; + circle.precision = function(_) { + if (!arguments.length) return precision; + interpolate = d3_geo_circleInterpolate(angle * d3_radians, (precision = +_) * d3_radians); + return circle; + }; + return circle.angle(90); + }; + function d3_geo_circleInterpolate(radius, precision) { + var cr = Math.cos(radius), sr = Math.sin(radius); + return function(from, to, direction, listener) { + var step = direction * precision; + if (from != null) { + from = d3_geo_circleAngle(cr, from); + to = d3_geo_circleAngle(cr, to); + if (direction > 0 ? from < to : from > to) from += direction * τ; + } else { + from = radius + direction * τ; + to = radius - .5 * step; + } + for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) { + listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), -sr * Math.sin(t) ]))[0], point[1]); + } + }; + } + function d3_geo_circleAngle(cr, point) { + var a = d3_geo_cartesian(point); + a[0] -= cr; + d3_geo_cartesianNormalize(a); + var angle = d3_acos(-a[1]); + return ((-a[2] < 0 ? -angle : angle) + 2 * Math.PI - ε) % (2 * Math.PI); + } + d3.geo.distance = function(a, b) { + var Δλ = (b[0] - a[0]) * d3_radians, φ0 = a[1] * d3_radians, φ1 = b[1] * d3_radians, sinΔλ = Math.sin(Δλ), cosΔλ = Math.cos(Δλ), sinφ0 = Math.sin(φ0), cosφ0 = Math.cos(φ0), sinφ1 = Math.sin(φ1), cosφ1 = Math.cos(φ1), t; + return Math.atan2(Math.sqrt((t = cosφ1 * sinΔλ) * t + (t = cosφ0 * sinφ1 - sinφ0 * cosφ1 * cosΔλ) * t), sinφ0 * sinφ1 + cosφ0 * cosφ1 * cosΔλ); + }; + d3.geo.graticule = function() { + var x1, x0, X1, X0, y1, y0, Y1, Y0, dx = 10, dy = dx, DX = 90, DY = 360, x, y, X, Y, precision = 2.5; + function graticule() { + return { + type: "MultiLineString", + coordinates: lines() + }; + } + function lines() { + return d3.range(Math.ceil(X0 / DX) * DX, X1, DX).map(X).concat(d3.range(Math.ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(d3.range(Math.ceil(x0 / dx) * dx, x1, dx).filter(function(x) { + return abs(x % DX) > ε; + }).map(x)).concat(d3.range(Math.ceil(y0 / dy) * dy, y1, dy).filter(function(y) { + return abs(y % DY) > ε; + }).map(y)); + } + graticule.lines = function() { + return lines().map(function(coordinates) { + return { + type: "LineString", + coordinates: coordinates + }; + }); + }; + graticule.outline = function() { + return { + type: "Polygon", + coordinates: [ X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1)) ] + }; + }; + graticule.extent = function(_) { + if (!arguments.length) return graticule.minorExtent(); + return graticule.majorExtent(_).minorExtent(_); + }; + graticule.majorExtent = function(_) { + if (!arguments.length) return [ [ X0, Y0 ], [ X1, Y1 ] ]; + X0 = +_[0][0], X1 = +_[1][0]; + Y0 = +_[0][1], Y1 = +_[1][1]; + if (X0 > X1) _ = X0, X0 = X1, X1 = _; + if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _; + return graticule.precision(precision); + }; + graticule.minorExtent = function(_) { + if (!arguments.length) return [ [ x0, y0 ], [ x1, y1 ] ]; + x0 = +_[0][0], x1 = +_[1][0]; + y0 = +_[0][1], y1 = +_[1][1]; + if (x0 > x1) _ = x0, x0 = x1, x1 = _; + if (y0 > y1) _ = y0, y0 = y1, y1 = _; + return graticule.precision(precision); + }; + graticule.step = function(_) { + if (!arguments.length) return graticule.minorStep(); + return graticule.majorStep(_).minorStep(_); + }; + graticule.majorStep = function(_) { + if (!arguments.length) return [ DX, DY ]; + DX = +_[0], DY = +_[1]; + return graticule; + }; + graticule.minorStep = function(_) { + if (!arguments.length) return [ dx, dy ]; + dx = +_[0], dy = +_[1]; + return graticule; + }; + graticule.precision = function(_) { + if (!arguments.length) return precision; + precision = +_; + x = d3_geo_graticuleX(y0, y1, 90); + y = d3_geo_graticuleY(x0, x1, precision); + X = d3_geo_graticuleX(Y0, Y1, 90); + Y = d3_geo_graticuleY(X0, X1, precision); + return graticule; + }; + return graticule.majorExtent([ [ -180, -90 + ε ], [ 180, 90 - ε ] ]).minorExtent([ [ -180, -80 - ε ], [ 180, 80 + ε ] ]); + }; + function d3_geo_graticuleX(y0, y1, dy) { + var y = d3.range(y0, y1 - ε, dy).concat(y1); + return function(x) { + return y.map(function(y) { + return [ x, y ]; + }); + }; + } + function d3_geo_graticuleY(x0, x1, dx) { + var x = d3.range(x0, x1 - ε, dx).concat(x1); + return function(y) { + return x.map(function(x) { + return [ x, y ]; + }); + }; + } + function d3_source(d) { + return d.source; + } + function d3_target(d) { + return d.target; + } + d3.geo.greatArc = function() { + var source = d3_source, source_, target = d3_target, target_; + function greatArc() { + return { + type: "LineString", + coordinates: [ source_ || source.apply(this, arguments), target_ || target.apply(this, arguments) ] + }; + } + greatArc.distance = function() { + return d3.geo.distance(source_ || source.apply(this, arguments), target_ || target.apply(this, arguments)); + }; + greatArc.source = function(_) { + if (!arguments.length) return source; + source = _, source_ = typeof _ === "function" ? null : _; + return greatArc; + }; + greatArc.target = function(_) { + if (!arguments.length) return target; + target = _, target_ = typeof _ === "function" ? null : _; + return greatArc; + }; + greatArc.precision = function() { + return arguments.length ? greatArc : 0; + }; + return greatArc; + }; + d3.geo.interpolate = function(source, target) { + return d3_geo_interpolate(source[0] * d3_radians, source[1] * d3_radians, target[0] * d3_radians, target[1] * d3_radians); + }; + function d3_geo_interpolate(x0, y0, x1, y1) { + var cy0 = Math.cos(y0), sy0 = Math.sin(y0), cy1 = Math.cos(y1), sy1 = Math.sin(y1), kx0 = cy0 * Math.cos(x0), ky0 = cy0 * Math.sin(x0), kx1 = cy1 * Math.cos(x1), ky1 = cy1 * Math.sin(x1), d = 2 * Math.asin(Math.sqrt(d3_haversin(y1 - y0) + cy0 * cy1 * d3_haversin(x1 - x0))), k = 1 / Math.sin(d); + var interpolate = d ? function(t) { + var B = Math.sin(t *= d) * k, A = Math.sin(d - t) * k, x = A * kx0 + B * kx1, y = A * ky0 + B * ky1, z = A * sy0 + B * sy1; + return [ Math.atan2(y, x) * d3_degrees, Math.atan2(z, Math.sqrt(x * x + y * y)) * d3_degrees ]; + } : function() { + return [ x0 * d3_degrees, y0 * d3_degrees ]; + }; + interpolate.distance = d; + return interpolate; + } + d3.geo.length = function(object) { + d3_geo_lengthSum = 0; + d3.geo.stream(object, d3_geo_length); + return d3_geo_lengthSum; + }; + var d3_geo_lengthSum; + var d3_geo_length = { + sphere: d3_noop, + point: d3_noop, + lineStart: d3_geo_lengthLineStart, + lineEnd: d3_noop, + polygonStart: d3_noop, + polygonEnd: d3_noop + }; + function d3_geo_lengthLineStart() { + var λ0, sinφ0, cosφ0; + d3_geo_length.point = function(λ, φ) { + λ0 = λ * d3_radians, sinφ0 = Math.sin(φ *= d3_radians), cosφ0 = Math.cos(φ); + d3_geo_length.point = nextPoint; + }; + d3_geo_length.lineEnd = function() { + d3_geo_length.point = d3_geo_length.lineEnd = d3_noop; + }; + function nextPoint(λ, φ) { + var sinφ = Math.sin(φ *= d3_radians), cosφ = Math.cos(φ), t = abs((λ *= d3_radians) - λ0), cosΔλ = Math.cos(t); + d3_geo_lengthSum += Math.atan2(Math.sqrt((t = cosφ * Math.sin(t)) * t + (t = cosφ0 * sinφ - sinφ0 * cosφ * cosΔλ) * t), sinφ0 * sinφ + cosφ0 * cosφ * cosΔλ); + λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ; + } + } + function d3_geo_azimuthal(scale, angle) { + function azimuthal(λ, φ) { + var cosλ = Math.cos(λ), cosφ = Math.cos(φ), k = scale(cosλ * cosφ); + return [ k * cosφ * Math.sin(λ), k * Math.sin(φ) ]; + } + azimuthal.invert = function(x, y) { + var ρ = Math.sqrt(x * x + y * y), c = angle(ρ), sinc = Math.sin(c), cosc = Math.cos(c); + return [ Math.atan2(x * sinc, ρ * cosc), Math.asin(ρ && y * sinc / ρ) ]; + }; + return azimuthal; + } + var d3_geo_azimuthalEqualArea = d3_geo_azimuthal(function(cosλcosφ) { + return Math.sqrt(2 / (1 + cosλcosφ)); + }, function(ρ) { + return 2 * Math.asin(ρ / 2); + }); + (d3.geo.azimuthalEqualArea = function() { + return d3_geo_projection(d3_geo_azimuthalEqualArea); + }).raw = d3_geo_azimuthalEqualArea; + var d3_geo_azimuthalEquidistant = d3_geo_azimuthal(function(cosλcosφ) { + var c = Math.acos(cosλcosφ); + return c && c / Math.sin(c); + }, d3_identity); + (d3.geo.azimuthalEquidistant = function() { + return d3_geo_projection(d3_geo_azimuthalEquidistant); + }).raw = d3_geo_azimuthalEquidistant; + function d3_geo_conicConformal(φ0, φ1) { + var cosφ0 = Math.cos(φ0), t = function(φ) { + return Math.tan(π / 4 + φ / 2); + }, n = φ0 === φ1 ? Math.sin(φ0) : Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)), F = cosφ0 * Math.pow(t(φ0), n) / n; + if (!n) return d3_geo_mercator; + function forward(λ, φ) { + if (F > 0) { + if (φ < -halfπ + ε) φ = -halfπ + ε; + } else { + if (φ > halfπ - ε) φ = halfπ - ε; + } + var ρ = F / Math.pow(t(φ), n); + return [ ρ * Math.sin(n * λ), F - ρ * Math.cos(n * λ) ]; + } + forward.invert = function(x, y) { + var ρ0_y = F - y, ρ = d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y); + return [ Math.atan2(x, ρ0_y) / n, 2 * Math.atan(Math.pow(F / ρ, 1 / n)) - halfπ ]; + }; + return forward; + } + (d3.geo.conicConformal = function() { + return d3_geo_conic(d3_geo_conicConformal); + }).raw = d3_geo_conicConformal; + function d3_geo_conicEquidistant(φ0, φ1) { + var cosφ0 = Math.cos(φ0), n = φ0 === φ1 ? Math.sin(φ0) : (cosφ0 - Math.cos(φ1)) / (φ1 - φ0), G = cosφ0 / n + φ0; + if (abs(n) < ε) return d3_geo_equirectangular; + function forward(λ, φ) { + var ρ = G - φ; + return [ ρ * Math.sin(n * λ), G - ρ * Math.cos(n * λ) ]; + } + forward.invert = function(x, y) { + var ρ0_y = G - y; + return [ Math.atan2(x, ρ0_y) / n, G - d3_sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y) ]; + }; + return forward; + } + (d3.geo.conicEquidistant = function() { + return d3_geo_conic(d3_geo_conicEquidistant); + }).raw = d3_geo_conicEquidistant; + var d3_geo_gnomonic = d3_geo_azimuthal(function(cosλcosφ) { + return 1 / cosλcosφ; + }, Math.atan); + (d3.geo.gnomonic = function() { + return d3_geo_projection(d3_geo_gnomonic); + }).raw = d3_geo_gnomonic; + function d3_geo_mercator(λ, φ) { + return [ λ, Math.log(Math.tan(π / 4 + φ / 2)) ]; + } + d3_geo_mercator.invert = function(x, y) { + return [ x, 2 * Math.atan(Math.exp(y)) - halfπ ]; + }; + function d3_geo_mercatorProjection(project) { + var m = d3_geo_projection(project), scale = m.scale, translate = m.translate, clipExtent = m.clipExtent, clipAuto; + m.scale = function() { + var v = scale.apply(m, arguments); + return v === m ? clipAuto ? m.clipExtent(null) : m : v; + }; + m.translate = function() { + var v = translate.apply(m, arguments); + return v === m ? clipAuto ? m.clipExtent(null) : m : v; + }; + m.clipExtent = function(_) { + var v = clipExtent.apply(m, arguments); + if (v === m) { + if (clipAuto = _ == null) { + var k = π * scale(), t = translate(); + clipExtent([ [ t[0] - k, t[1] - k ], [ t[0] + k, t[1] + k ] ]); + } + } else if (clipAuto) { + v = null; + } + return v; + }; + return m.clipExtent(null); + } + (d3.geo.mercator = function() { + return d3_geo_mercatorProjection(d3_geo_mercator); + }).raw = d3_geo_mercator; + var d3_geo_orthographic = d3_geo_azimuthal(function() { + return 1; + }, Math.asin); + (d3.geo.orthographic = function() { + return d3_geo_projection(d3_geo_orthographic); + }).raw = d3_geo_orthographic; + var d3_geo_stereographic = d3_geo_azimuthal(function(cosλcosφ) { + return 1 / (1 + cosλcosφ); + }, function(ρ) { + return 2 * Math.atan(ρ); + }); + (d3.geo.stereographic = function() { + return d3_geo_projection(d3_geo_stereographic); + }).raw = d3_geo_stereographic; + function d3_geo_transverseMercator(λ, φ) { + return [ Math.log(Math.tan(π / 4 + φ / 2)), -λ ]; + } + d3_geo_transverseMercator.invert = function(x, y) { + return [ -y, 2 * Math.atan(Math.exp(x)) - halfπ ]; + }; + (d3.geo.transverseMercator = function() { + var projection = d3_geo_mercatorProjection(d3_geo_transverseMercator), center = projection.center, rotate = projection.rotate; + projection.center = function(_) { + return _ ? center([ -_[1], _[0] ]) : (_ = center(), [ -_[1], _[0] ]); + }; + projection.rotate = function(_) { + return _ ? rotate([ _[0], _[1], _.length > 2 ? _[2] + 90 : 90 ]) : (_ = rotate(), + [ _[0], _[1], _[2] - 90 ]); + }; + return projection.rotate([ 0, 0 ]); + }).raw = d3_geo_transverseMercator; + d3.geom = {}; + function d3_geom_pointX(d) { + return d[0]; + } + function d3_geom_pointY(d) { + return d[1]; + } + d3.geom.hull = function(vertices) { + var x = d3_geom_pointX, y = d3_geom_pointY; + if (arguments.length) return hull(vertices); + function hull(data) { + if (data.length < 3) return []; + var fx = d3_functor(x), fy = d3_functor(y), i, n = data.length, points = [], flippedPoints = []; + for (i = 0; i < n; i++) { + points.push([ +fx.call(this, data[i], i), +fy.call(this, data[i], i), i ]); + } + points.sort(d3_geom_hullOrder); + for (i = 0; i < n; i++) flippedPoints.push([ points[i][0], -points[i][1] ]); + var upper = d3_geom_hullUpper(points), lower = d3_geom_hullUpper(flippedPoints); + var skipLeft = lower[0] === upper[0], skipRight = lower[lower.length - 1] === upper[upper.length - 1], polygon = []; + for (i = upper.length - 1; i >= 0; --i) polygon.push(data[points[upper[i]][2]]); + for (i = +skipLeft; i < lower.length - skipRight; ++i) polygon.push(data[points[lower[i]][2]]); + return polygon; + } + hull.x = function(_) { + return arguments.length ? (x = _, hull) : x; + }; + hull.y = function(_) { + return arguments.length ? (y = _, hull) : y; + }; + return hull; + }; + function d3_geom_hullUpper(points) { + var n = points.length, hull = [ 0, 1 ], hs = 2; + for (var i = 2; i < n; i++) { + while (hs > 1 && d3_cross2d(points[hull[hs - 2]], points[hull[hs - 1]], points[i]) <= 0) --hs; + hull[hs++] = i; + } + return hull.slice(0, hs); + } + function d3_geom_hullOrder(a, b) { + return a[0] - b[0] || a[1] - b[1]; + } + d3.geom.polygon = function(coordinates) { + d3_subclass(coordinates, d3_geom_polygonPrototype); + return coordinates; + }; + var d3_geom_polygonPrototype = d3.geom.polygon.prototype = []; + d3_geom_polygonPrototype.area = function() { + var i = -1, n = this.length, a, b = this[n - 1], area = 0; + while (++i < n) { + a = b; + b = this[i]; + area += a[1] * b[0] - a[0] * b[1]; + } + return area * .5; + }; + d3_geom_polygonPrototype.centroid = function(k) { + var i = -1, n = this.length, x = 0, y = 0, a, b = this[n - 1], c; + if (!arguments.length) k = -1 / (6 * this.area()); + while (++i < n) { + a = b; + b = this[i]; + c = a[0] * b[1] - b[0] * a[1]; + x += (a[0] + b[0]) * c; + y += (a[1] + b[1]) * c; + } + return [ x * k, y * k ]; + }; + d3_geom_polygonPrototype.clip = function(subject) { + var input, closed = d3_geom_polygonClosed(subject), i = -1, n = this.length - d3_geom_polygonClosed(this), j, m, a = this[n - 1], b, c, d; + while (++i < n) { + input = subject.slice(); + subject.length = 0; + b = this[i]; + c = input[(m = input.length - closed) - 1]; + j = -1; + while (++j < m) { + d = input[j]; + if (d3_geom_polygonInside(d, a, b)) { + if (!d3_geom_polygonInside(c, a, b)) { + subject.push(d3_geom_polygonIntersect(c, d, a, b)); + } + subject.push(d); + } else if (d3_geom_polygonInside(c, a, b)) { + subject.push(d3_geom_polygonIntersect(c, d, a, b)); + } + c = d; + } + if (closed) subject.push(subject[0]); + a = b; + } + return subject; + }; + function d3_geom_polygonInside(p, a, b) { + return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]); + } + function d3_geom_polygonIntersect(c, d, a, b) { + var x1 = c[0], x3 = a[0], x21 = d[0] - x1, x43 = b[0] - x3, y1 = c[1], y3 = a[1], y21 = d[1] - y1, y43 = b[1] - y3, ua = (x43 * (y1 - y3) - y43 * (x1 - x3)) / (y43 * x21 - x43 * y21); + return [ x1 + ua * x21, y1 + ua * y21 ]; + } + function d3_geom_polygonClosed(coordinates) { + var a = coordinates[0], b = coordinates[coordinates.length - 1]; + return !(a[0] - b[0] || a[1] - b[1]); + } + var d3_geom_voronoiEdges, d3_geom_voronoiCells, d3_geom_voronoiBeaches, d3_geom_voronoiBeachPool = [], d3_geom_voronoiFirstCircle, d3_geom_voronoiCircles, d3_geom_voronoiCirclePool = []; + function d3_geom_voronoiBeach() { + d3_geom_voronoiRedBlackNode(this); + this.edge = this.site = this.circle = null; + } + function d3_geom_voronoiCreateBeach(site) { + var beach = d3_geom_voronoiBeachPool.pop() || new d3_geom_voronoiBeach(); + beach.site = site; + return beach; + } + function d3_geom_voronoiDetachBeach(beach) { + d3_geom_voronoiDetachCircle(beach); + d3_geom_voronoiBeaches.remove(beach); + d3_geom_voronoiBeachPool.push(beach); + d3_geom_voronoiRedBlackNode(beach); + } + function d3_geom_voronoiRemoveBeach(beach) { + var circle = beach.circle, x = circle.x, y = circle.cy, vertex = { + x: x, + y: y + }, previous = beach.P, next = beach.N, disappearing = [ beach ]; + d3_geom_voronoiDetachBeach(beach); + var lArc = previous; + while (lArc.circle && abs(x - lArc.circle.x) < ε && abs(y - lArc.circle.cy) < ε) { + previous = lArc.P; + disappearing.unshift(lArc); + d3_geom_voronoiDetachBeach(lArc); + lArc = previous; + } + disappearing.unshift(lArc); + d3_geom_voronoiDetachCircle(lArc); + var rArc = next; + while (rArc.circle && abs(x - rArc.circle.x) < ε && abs(y - rArc.circle.cy) < ε) { + next = rArc.N; + disappearing.push(rArc); + d3_geom_voronoiDetachBeach(rArc); + rArc = next; + } + disappearing.push(rArc); + d3_geom_voronoiDetachCircle(rArc); + var nArcs = disappearing.length, iArc; + for (iArc = 1; iArc < nArcs; ++iArc) { + rArc = disappearing[iArc]; + lArc = disappearing[iArc - 1]; + d3_geom_voronoiSetEdgeEnd(rArc.edge, lArc.site, rArc.site, vertex); + } + lArc = disappearing[0]; + rArc = disappearing[nArcs - 1]; + rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, rArc.site, null, vertex); + d3_geom_voronoiAttachCircle(lArc); + d3_geom_voronoiAttachCircle(rArc); + } + function d3_geom_voronoiAddBeach(site) { + var x = site.x, directrix = site.y, lArc, rArc, dxl, dxr, node = d3_geom_voronoiBeaches._; + while (node) { + dxl = d3_geom_voronoiLeftBreakPoint(node, directrix) - x; + if (dxl > ε) node = node.L; else { + dxr = x - d3_geom_voronoiRightBreakPoint(node, directrix); + if (dxr > ε) { + if (!node.R) { + lArc = node; + break; + } + node = node.R; + } else { + if (dxl > -ε) { + lArc = node.P; + rArc = node; + } else if (dxr > -ε) { + lArc = node; + rArc = node.N; + } else { + lArc = rArc = node; + } + break; + } + } + } + var newArc = d3_geom_voronoiCreateBeach(site); + d3_geom_voronoiBeaches.insert(lArc, newArc); + if (!lArc && !rArc) return; + if (lArc === rArc) { + d3_geom_voronoiDetachCircle(lArc); + rArc = d3_geom_voronoiCreateBeach(lArc.site); + d3_geom_voronoiBeaches.insert(newArc, rArc); + newArc.edge = rArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site); + d3_geom_voronoiAttachCircle(lArc); + d3_geom_voronoiAttachCircle(rArc); + return; + } + if (!rArc) { + newArc.edge = d3_geom_voronoiCreateEdge(lArc.site, newArc.site); + return; + } + d3_geom_voronoiDetachCircle(lArc); + d3_geom_voronoiDetachCircle(rArc); + var lSite = lArc.site, ax = lSite.x, ay = lSite.y, bx = site.x - ax, by = site.y - ay, rSite = rArc.site, cx = rSite.x - ax, cy = rSite.y - ay, d = 2 * (bx * cy - by * cx), hb = bx * bx + by * by, hc = cx * cx + cy * cy, vertex = { + x: (cy * hb - by * hc) / d + ax, + y: (bx * hc - cx * hb) / d + ay + }; + d3_geom_voronoiSetEdgeEnd(rArc.edge, lSite, rSite, vertex); + newArc.edge = d3_geom_voronoiCreateEdge(lSite, site, null, vertex); + rArc.edge = d3_geom_voronoiCreateEdge(site, rSite, null, vertex); + d3_geom_voronoiAttachCircle(lArc); + d3_geom_voronoiAttachCircle(rArc); + } + function d3_geom_voronoiLeftBreakPoint(arc, directrix) { + var site = arc.site, rfocx = site.x, rfocy = site.y, pby2 = rfocy - directrix; + if (!pby2) return rfocx; + var lArc = arc.P; + if (!lArc) return -Infinity; + site = lArc.site; + var lfocx = site.x, lfocy = site.y, plby2 = lfocy - directrix; + if (!plby2) return lfocx; + var hl = lfocx - rfocx, aby2 = 1 / pby2 - 1 / plby2, b = hl / plby2; + if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx; + return (rfocx + lfocx) / 2; + } + function d3_geom_voronoiRightBreakPoint(arc, directrix) { + var rArc = arc.N; + if (rArc) return d3_geom_voronoiLeftBreakPoint(rArc, directrix); + var site = arc.site; + return site.y === directrix ? site.x : Infinity; + } + function d3_geom_voronoiCell(site) { + this.site = site; + this.edges = []; + } + d3_geom_voronoiCell.prototype.prepare = function() { + var halfEdges = this.edges, iHalfEdge = halfEdges.length, edge; + while (iHalfEdge--) { + edge = halfEdges[iHalfEdge].edge; + if (!edge.b || !edge.a) halfEdges.splice(iHalfEdge, 1); + } + halfEdges.sort(d3_geom_voronoiHalfEdgeOrder); + return halfEdges.length; + }; + function d3_geom_voronoiCloseCells(extent) { + var x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], x2, y2, x3, y3, cells = d3_geom_voronoiCells, iCell = cells.length, cell, iHalfEdge, halfEdges, nHalfEdges, start, end; + while (iCell--) { + cell = cells[iCell]; + if (!cell || !cell.prepare()) continue; + halfEdges = cell.edges; + nHalfEdges = halfEdges.length; + iHalfEdge = 0; + while (iHalfEdge < nHalfEdges) { + end = halfEdges[iHalfEdge].end(), x3 = end.x, y3 = end.y; + start = halfEdges[++iHalfEdge % nHalfEdges].start(), x2 = start.x, y2 = start.y; + if (abs(x3 - x2) > ε || abs(y3 - y2) > ε) { + halfEdges.splice(iHalfEdge, 0, new d3_geom_voronoiHalfEdge(d3_geom_voronoiCreateBorderEdge(cell.site, end, abs(x3 - x0) < ε && y1 - y3 > ε ? { + x: x0, + y: abs(x2 - x0) < ε ? y2 : y1 + } : abs(y3 - y1) < ε && x1 - x3 > ε ? { + x: abs(y2 - y1) < ε ? x2 : x1, + y: y1 + } : abs(x3 - x1) < ε && y3 - y0 > ε ? { + x: x1, + y: abs(x2 - x1) < ε ? y2 : y0 + } : abs(y3 - y0) < ε && x3 - x0 > ε ? { + x: abs(y2 - y0) < ε ? x2 : x0, + y: y0 + } : null), cell.site, null)); + ++nHalfEdges; + } + } + } + } + function d3_geom_voronoiHalfEdgeOrder(a, b) { + return b.angle - a.angle; + } + function d3_geom_voronoiCircle() { + d3_geom_voronoiRedBlackNode(this); + this.x = this.y = this.arc = this.site = this.cy = null; + } + function d3_geom_voronoiAttachCircle(arc) { + var lArc = arc.P, rArc = arc.N; + if (!lArc || !rArc) return; + var lSite = lArc.site, cSite = arc.site, rSite = rArc.site; + if (lSite === rSite) return; + var bx = cSite.x, by = cSite.y, ax = lSite.x - bx, ay = lSite.y - by, cx = rSite.x - bx, cy = rSite.y - by; + var d = 2 * (ax * cy - ay * cx); + if (d >= -ε2) return; + var ha = ax * ax + ay * ay, hc = cx * cx + cy * cy, x = (cy * ha - ay * hc) / d, y = (ax * hc - cx * ha) / d, cy = y + by; + var circle = d3_geom_voronoiCirclePool.pop() || new d3_geom_voronoiCircle(); + circle.arc = arc; + circle.site = cSite; + circle.x = x + bx; + circle.y = cy + Math.sqrt(x * x + y * y); + circle.cy = cy; + arc.circle = circle; + var before = null, node = d3_geom_voronoiCircles._; + while (node) { + if (circle.y < node.y || circle.y === node.y && circle.x <= node.x) { + if (node.L) node = node.L; else { + before = node.P; + break; + } + } else { + if (node.R) node = node.R; else { + before = node; + break; + } + } + } + d3_geom_voronoiCircles.insert(before, circle); + if (!before) d3_geom_voronoiFirstCircle = circle; + } + function d3_geom_voronoiDetachCircle(arc) { + var circle = arc.circle; + if (circle) { + if (!circle.P) d3_geom_voronoiFirstCircle = circle.N; + d3_geom_voronoiCircles.remove(circle); + d3_geom_voronoiCirclePool.push(circle); + d3_geom_voronoiRedBlackNode(circle); + arc.circle = null; + } + } + function d3_geom_voronoiClipEdges(extent) { + var edges = d3_geom_voronoiEdges, clip = d3_geom_clipLine(extent[0][0], extent[0][1], extent[1][0], extent[1][1]), i = edges.length, e; + while (i--) { + e = edges[i]; + if (!d3_geom_voronoiConnectEdge(e, extent) || !clip(e) || abs(e.a.x - e.b.x) < ε && abs(e.a.y - e.b.y) < ε) { + e.a = e.b = null; + edges.splice(i, 1); + } + } + } + function d3_geom_voronoiConnectEdge(edge, extent) { + var vb = edge.b; + if (vb) return true; + var va = edge.a, x0 = extent[0][0], x1 = extent[1][0], y0 = extent[0][1], y1 = extent[1][1], lSite = edge.l, rSite = edge.r, lx = lSite.x, ly = lSite.y, rx = rSite.x, ry = rSite.y, fx = (lx + rx) / 2, fy = (ly + ry) / 2, fm, fb; + if (ry === ly) { + if (fx < x0 || fx >= x1) return; + if (lx > rx) { + if (!va) va = { + x: fx, + y: y0 + }; else if (va.y >= y1) return; + vb = { + x: fx, + y: y1 + }; + } else { + if (!va) va = { + x: fx, + y: y1 + }; else if (va.y < y0) return; + vb = { + x: fx, + y: y0 + }; + } + } else { + fm = (lx - rx) / (ry - ly); + fb = fy - fm * fx; + if (fm < -1 || fm > 1) { + if (lx > rx) { + if (!va) va = { + x: (y0 - fb) / fm, + y: y0 + }; else if (va.y >= y1) return; + vb = { + x: (y1 - fb) / fm, + y: y1 + }; + } else { + if (!va) va = { + x: (y1 - fb) / fm, + y: y1 + }; else if (va.y < y0) return; + vb = { + x: (y0 - fb) / fm, + y: y0 + }; + } + } else { + if (ly < ry) { + if (!va) va = { + x: x0, + y: fm * x0 + fb + }; else if (va.x >= x1) return; + vb = { + x: x1, + y: fm * x1 + fb + }; + } else { + if (!va) va = { + x: x1, + y: fm * x1 + fb + }; else if (va.x < x0) return; + vb = { + x: x0, + y: fm * x0 + fb + }; + } + } + } + edge.a = va; + edge.b = vb; + return true; + } + function d3_geom_voronoiEdge(lSite, rSite) { + this.l = lSite; + this.r = rSite; + this.a = this.b = null; + } + function d3_geom_voronoiCreateEdge(lSite, rSite, va, vb) { + var edge = new d3_geom_voronoiEdge(lSite, rSite); + d3_geom_voronoiEdges.push(edge); + if (va) d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, va); + if (vb) d3_geom_voronoiSetEdgeEnd(edge, rSite, lSite, vb); + d3_geom_voronoiCells[lSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, lSite, rSite)); + d3_geom_voronoiCells[rSite.i].edges.push(new d3_geom_voronoiHalfEdge(edge, rSite, lSite)); + return edge; + } + function d3_geom_voronoiCreateBorderEdge(lSite, va, vb) { + var edge = new d3_geom_voronoiEdge(lSite, null); + edge.a = va; + edge.b = vb; + d3_geom_voronoiEdges.push(edge); + return edge; + } + function d3_geom_voronoiSetEdgeEnd(edge, lSite, rSite, vertex) { + if (!edge.a && !edge.b) { + edge.a = vertex; + edge.l = lSite; + edge.r = rSite; + } else if (edge.l === rSite) { + edge.b = vertex; + } else { + edge.a = vertex; + } + } + function d3_geom_voronoiHalfEdge(edge, lSite, rSite) { + var va = edge.a, vb = edge.b; + this.edge = edge; + this.site = lSite; + this.angle = rSite ? Math.atan2(rSite.y - lSite.y, rSite.x - lSite.x) : edge.l === lSite ? Math.atan2(vb.x - va.x, va.y - vb.y) : Math.atan2(va.x - vb.x, vb.y - va.y); + } + d3_geom_voronoiHalfEdge.prototype = { + start: function() { + return this.edge.l === this.site ? this.edge.a : this.edge.b; + }, + end: function() { + return this.edge.l === this.site ? this.edge.b : this.edge.a; + } + }; + function d3_geom_voronoiRedBlackTree() { + this._ = null; + } + function d3_geom_voronoiRedBlackNode(node) { + node.U = node.C = node.L = node.R = node.P = node.N = null; + } + d3_geom_voronoiRedBlackTree.prototype = { + insert: function(after, node) { + var parent, grandpa, uncle; + if (after) { + node.P = after; + node.N = after.N; + if (after.N) after.N.P = node; + after.N = node; + if (after.R) { + after = after.R; + while (after.L) after = after.L; + after.L = node; + } else { + after.R = node; + } + parent = after; + } else if (this._) { + after = d3_geom_voronoiRedBlackFirst(this._); + node.P = null; + node.N = after; + after.P = after.L = node; + parent = after; + } else { + node.P = node.N = null; + this._ = node; + parent = null; + } + node.L = node.R = null; + node.U = parent; + node.C = true; + after = node; + while (parent && parent.C) { + grandpa = parent.U; + if (parent === grandpa.L) { + uncle = grandpa.R; + if (uncle && uncle.C) { + parent.C = uncle.C = false; + grandpa.C = true; + after = grandpa; + } else { + if (after === parent.R) { + d3_geom_voronoiRedBlackRotateLeft(this, parent); + after = parent; + parent = after.U; + } + parent.C = false; + grandpa.C = true; + d3_geom_voronoiRedBlackRotateRight(this, grandpa); + } + } else { + uncle = grandpa.L; + if (uncle && uncle.C) { + parent.C = uncle.C = false; + grandpa.C = true; + after = grandpa; + } else { + if (after === parent.L) { + d3_geom_voronoiRedBlackRotateRight(this, parent); + after = parent; + parent = after.U; + } + parent.C = false; + grandpa.C = true; + d3_geom_voronoiRedBlackRotateLeft(this, grandpa); + } + } + parent = after.U; + } + this._.C = false; + }, + remove: function(node) { + if (node.N) node.N.P = node.P; + if (node.P) node.P.N = node.N; + node.N = node.P = null; + var parent = node.U, sibling, left = node.L, right = node.R, next, red; + if (!left) next = right; else if (!right) next = left; else next = d3_geom_voronoiRedBlackFirst(right); + if (parent) { + if (parent.L === node) parent.L = next; else parent.R = next; + } else { + this._ = next; + } + if (left && right) { + red = next.C; + next.C = node.C; + next.L = left; + left.U = next; + if (next !== right) { + parent = next.U; + next.U = node.U; + node = next.R; + parent.L = node; + next.R = right; + right.U = next; + } else { + next.U = parent; + parent = next; + node = next.R; + } + } else { + red = node.C; + node = next; + } + if (node) node.U = parent; + if (red) return; + if (node && node.C) { + node.C = false; + return; + } + do { + if (node === this._) break; + if (node === parent.L) { + sibling = parent.R; + if (sibling.C) { + sibling.C = false; + parent.C = true; + d3_geom_voronoiRedBlackRotateLeft(this, parent); + sibling = parent.R; + } + if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) { + if (!sibling.R || !sibling.R.C) { + sibling.L.C = false; + sibling.C = true; + d3_geom_voronoiRedBlackRotateRight(this, sibling); + sibling = parent.R; + } + sibling.C = parent.C; + parent.C = sibling.R.C = false; + d3_geom_voronoiRedBlackRotateLeft(this, parent); + node = this._; + break; + } + } else { + sibling = parent.L; + if (sibling.C) { + sibling.C = false; + parent.C = true; + d3_geom_voronoiRedBlackRotateRight(this, parent); + sibling = parent.L; + } + if (sibling.L && sibling.L.C || sibling.R && sibling.R.C) { + if (!sibling.L || !sibling.L.C) { + sibling.R.C = false; + sibling.C = true; + d3_geom_voronoiRedBlackRotateLeft(this, sibling); + sibling = parent.L; + } + sibling.C = parent.C; + parent.C = sibling.L.C = false; + d3_geom_voronoiRedBlackRotateRight(this, parent); + node = this._; + break; + } + } + sibling.C = true; + node = parent; + parent = parent.U; + } while (!node.C); + if (node) node.C = false; + } + }; + function d3_geom_voronoiRedBlackRotateLeft(tree, node) { + var p = node, q = node.R, parent = p.U; + if (parent) { + if (parent.L === p) parent.L = q; else parent.R = q; + } else { + tree._ = q; + } + q.U = parent; + p.U = q; + p.R = q.L; + if (p.R) p.R.U = p; + q.L = p; + } + function d3_geom_voronoiRedBlackRotateRight(tree, node) { + var p = node, q = node.L, parent = p.U; + if (parent) { + if (parent.L === p) parent.L = q; else parent.R = q; + } else { + tree._ = q; + } + q.U = parent; + p.U = q; + p.L = q.R; + if (p.L) p.L.U = p; + q.R = p; + } + function d3_geom_voronoiRedBlackFirst(node) { + while (node.L) node = node.L; + return node; + } + function d3_geom_voronoi(sites, bbox) { + var site = sites.sort(d3_geom_voronoiVertexOrder).pop(), x0, y0, circle; + d3_geom_voronoiEdges = []; + d3_geom_voronoiCells = new Array(sites.length); + d3_geom_voronoiBeaches = new d3_geom_voronoiRedBlackTree(); + d3_geom_voronoiCircles = new d3_geom_voronoiRedBlackTree(); + while (true) { + circle = d3_geom_voronoiFirstCircle; + if (site && (!circle || site.y < circle.y || site.y === circle.y && site.x < circle.x)) { + if (site.x !== x0 || site.y !== y0) { + d3_geom_voronoiCells[site.i] = new d3_geom_voronoiCell(site); + d3_geom_voronoiAddBeach(site); + x0 = site.x, y0 = site.y; + } + site = sites.pop(); + } else if (circle) { + d3_geom_voronoiRemoveBeach(circle.arc); + } else { + break; + } + } + if (bbox) d3_geom_voronoiClipEdges(bbox), d3_geom_voronoiCloseCells(bbox); + var diagram = { + cells: d3_geom_voronoiCells, + edges: d3_geom_voronoiEdges + }; + d3_geom_voronoiBeaches = d3_geom_voronoiCircles = d3_geom_voronoiEdges = d3_geom_voronoiCells = null; + return diagram; + } + function d3_geom_voronoiVertexOrder(a, b) { + return b.y - a.y || b.x - a.x; + } + d3.geom.voronoi = function(points) { + var x = d3_geom_pointX, y = d3_geom_pointY, fx = x, fy = y, clipExtent = d3_geom_voronoiClipExtent; + if (points) return voronoi(points); + function voronoi(data) { + var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[1][1]; + d3_geom_voronoi(sites(data), clipExtent).cells.forEach(function(cell, i) { + var edges = cell.edges, site = cell.site, polygon = polygons[i] = edges.length ? edges.map(function(e) { + var s = e.start(); + return [ s.x, s.y ]; + }) : site.x >= x0 && site.x <= x1 && site.y >= y0 && site.y <= y1 ? [ [ x0, y1 ], [ x1, y1 ], [ x1, y0 ], [ x0, y0 ] ] : []; + polygon.point = data[i]; + }); + return polygons; + } + function sites(data) { + return data.map(function(d, i) { + return { + x: Math.round(fx(d, i) / ε) * ε, + y: Math.round(fy(d, i) / ε) * ε, + i: i + }; + }); + } + voronoi.links = function(data) { + return d3_geom_voronoi(sites(data)).edges.filter(function(edge) { + return edge.l && edge.r; + }).map(function(edge) { + return { + source: data[edge.l.i], + target: data[edge.r.i] + }; + }); + }; + voronoi.triangles = function(data) { + var triangles = []; + d3_geom_voronoi(sites(data)).cells.forEach(function(cell, i) { + var site = cell.site, edges = cell.edges.sort(d3_geom_voronoiHalfEdgeOrder), j = -1, m = edges.length, e0, s0, e1 = edges[m - 1].edge, s1 = e1.l === site ? e1.r : e1.l; + while (++j < m) { + e0 = e1; + s0 = s1; + e1 = edges[j].edge; + s1 = e1.l === site ? e1.r : e1.l; + if (i < s0.i && i < s1.i && d3_geom_voronoiTriangleArea(site, s0, s1) < 0) { + triangles.push([ data[i], data[s0.i], data[s1.i] ]); + } + } + }); + return triangles; + }; + voronoi.x = function(_) { + return arguments.length ? (fx = d3_functor(x = _), voronoi) : x; + }; + voronoi.y = function(_) { + return arguments.length ? (fy = d3_functor(y = _), voronoi) : y; + }; + voronoi.clipExtent = function(_) { + if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent; + clipExtent = _ == null ? d3_geom_voronoiClipExtent : _; + return voronoi; + }; + voronoi.size = function(_) { + if (!arguments.length) return clipExtent === d3_geom_voronoiClipExtent ? null : clipExtent && clipExtent[1]; + return voronoi.clipExtent(_ && [ [ 0, 0 ], _ ]); + }; + return voronoi; + }; + var d3_geom_voronoiClipExtent = [ [ -1e6, -1e6 ], [ 1e6, 1e6 ] ]; + function d3_geom_voronoiTriangleArea(a, b, c) { + return (a.x - c.x) * (b.y - a.y) - (a.x - b.x) * (c.y - a.y); + } + d3.geom.delaunay = function(vertices) { + return d3.geom.voronoi().triangles(vertices); + }; + d3.geom.quadtree = function(points, x1, y1, x2, y2) { + var x = d3_geom_pointX, y = d3_geom_pointY, compat; + if (compat = arguments.length) { + x = d3_geom_quadtreeCompatX; + y = d3_geom_quadtreeCompatY; + if (compat === 3) { + y2 = y1; + x2 = x1; + y1 = x1 = 0; + } + return quadtree(points); + } + function quadtree(data) { + var d, fx = d3_functor(x), fy = d3_functor(y), xs, ys, i, n, x1_, y1_, x2_, y2_; + if (x1 != null) { + x1_ = x1, y1_ = y1, x2_ = x2, y2_ = y2; + } else { + x2_ = y2_ = -(x1_ = y1_ = Infinity); + xs = [], ys = []; + n = data.length; + if (compat) for (i = 0; i < n; ++i) { + d = data[i]; + if (d.x < x1_) x1_ = d.x; + if (d.y < y1_) y1_ = d.y; + if (d.x > x2_) x2_ = d.x; + if (d.y > y2_) y2_ = d.y; + xs.push(d.x); + ys.push(d.y); + } else for (i = 0; i < n; ++i) { + var x_ = +fx(d = data[i], i), y_ = +fy(d, i); + if (x_ < x1_) x1_ = x_; + if (y_ < y1_) y1_ = y_; + if (x_ > x2_) x2_ = x_; + if (y_ > y2_) y2_ = y_; + xs.push(x_); + ys.push(y_); + } + } + var dx = x2_ - x1_, dy = y2_ - y1_; + if (dx > dy) y2_ = y1_ + dx; else x2_ = x1_ + dy; + function insert(n, d, x, y, x1, y1, x2, y2) { + if (isNaN(x) || isNaN(y)) return; + if (n.leaf) { + var nx = n.x, ny = n.y; + if (nx != null) { + if (abs(nx - x) + abs(ny - y) < .01) { + insertChild(n, d, x, y, x1, y1, x2, y2); + } else { + var nPoint = n.point; + n.x = n.y = n.point = null; + insertChild(n, nPoint, nx, ny, x1, y1, x2, y2); + insertChild(n, d, x, y, x1, y1, x2, y2); + } + } else { + n.x = x, n.y = y, n.point = d; + } + } else { + insertChild(n, d, x, y, x1, y1, x2, y2); + } + } + function insertChild(n, d, x, y, x1, y1, x2, y2) { + var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, right = x >= sx, bottom = y >= sy, i = (bottom << 1) + right; + n.leaf = false; + n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode()); + if (right) x1 = sx; else x2 = sx; + if (bottom) y1 = sy; else y2 = sy; + insert(n, d, x, y, x1, y1, x2, y2); + } + var root = d3_geom_quadtreeNode(); + root.add = function(d) { + insert(root, d, +fx(d, ++i), +fy(d, i), x1_, y1_, x2_, y2_); + }; + root.visit = function(f) { + d3_geom_quadtreeVisit(f, root, x1_, y1_, x2_, y2_); + }; + i = -1; + if (x1 == null) { + while (++i < n) { + insert(root, data[i], xs[i], ys[i], x1_, y1_, x2_, y2_); + } + --i; + } else data.forEach(root.add); + xs = ys = data = d = null; + return root; + } + quadtree.x = function(_) { + return arguments.length ? (x = _, quadtree) : x; + }; + quadtree.y = function(_) { + return arguments.length ? (y = _, quadtree) : y; + }; + quadtree.extent = function(_) { + if (!arguments.length) return x1 == null ? null : [ [ x1, y1 ], [ x2, y2 ] ]; + if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = +_[0][0], y1 = +_[0][1], x2 = +_[1][0], + y2 = +_[1][1]; + return quadtree; + }; + quadtree.size = function(_) { + if (!arguments.length) return x1 == null ? null : [ x2 - x1, y2 - y1 ]; + if (_ == null) x1 = y1 = x2 = y2 = null; else x1 = y1 = 0, x2 = +_[0], y2 = +_[1]; + return quadtree; + }; + return quadtree; + }; + function d3_geom_quadtreeCompatX(d) { + return d.x; + } + function d3_geom_quadtreeCompatY(d) { + return d.y; + } + function d3_geom_quadtreeNode() { + return { + leaf: true, + nodes: [], + point: null, + x: null, + y: null + }; + } + function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) { + if (!f(node, x1, y1, x2, y2)) { + var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes; + if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy); + if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy); + if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2); + if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2); + } + } + d3.interpolateRgb = d3_interpolateRgb; + function d3_interpolateRgb(a, b) { + a = d3.rgb(a); + b = d3.rgb(b); + var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab; + return function(t) { + return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t)); + }; + } + d3.interpolateObject = d3_interpolateObject; + function d3_interpolateObject(a, b) { + var i = {}, c = {}, k; + for (k in a) { + if (k in b) { + i[k] = d3_interpolate(a[k], b[k]); + } else { + c[k] = a[k]; + } + } + for (k in b) { + if (!(k in a)) { + c[k] = b[k]; + } + } + return function(t) { + for (k in i) c[k] = i[k](t); + return c; + }; + } + d3.interpolateNumber = d3_interpolateNumber; + function d3_interpolateNumber(a, b) { + b -= a = +a; + return function(t) { + return a + b * t; + }; + } + d3.interpolateString = d3_interpolateString; + function d3_interpolateString(a, b) { + var bi = d3_interpolate_numberA.lastIndex = d3_interpolate_numberB.lastIndex = 0, am, bm, bs, i = -1, s = [], q = []; + a = a + "", b = b + ""; + while ((am = d3_interpolate_numberA.exec(a)) && (bm = d3_interpolate_numberB.exec(b))) { + if ((bs = bm.index) > bi) { + bs = b.substring(bi, bs); + if (s[i]) s[i] += bs; else s[++i] = bs; + } + if ((am = am[0]) === (bm = bm[0])) { + if (s[i]) s[i] += bm; else s[++i] = bm; + } else { + s[++i] = null; + q.push({ + i: i, + x: d3_interpolateNumber(am, bm) + }); + } + bi = d3_interpolate_numberB.lastIndex; + } + if (bi < b.length) { + bs = b.substring(bi); + if (s[i]) s[i] += bs; else s[++i] = bs; + } + return s.length < 2 ? q[0] ? (b = q[0].x, function(t) { + return b(t) + ""; + }) : function() { + return b; + } : (b = q.length, function(t) { + for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); + return s.join(""); + }); + } + var d3_interpolate_numberA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, d3_interpolate_numberB = new RegExp(d3_interpolate_numberA.source, "g"); + d3.interpolate = d3_interpolate; + function d3_interpolate(a, b) { + var i = d3.interpolators.length, f; + while (--i >= 0 && !(f = d3.interpolators[i](a, b))) ; + return f; + } + d3.interpolators = [ function(a, b) { + var t = typeof b; + return (t === "string" ? d3_rgb_names.has(b) || /^(#|rgb\(|hsl\()/.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_Color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b); + } ]; + d3.interpolateArray = d3_interpolateArray; + function d3_interpolateArray(a, b) { + var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i; + for (i = 0; i < n0; ++i) x.push(d3_interpolate(a[i], b[i])); + for (;i < na; ++i) c[i] = a[i]; + for (;i < nb; ++i) c[i] = b[i]; + return function(t) { + for (i = 0; i < n0; ++i) c[i] = x[i](t); + return c; + }; + } + var d3_ease_default = function() { + return d3_identity; + }; + var d3_ease = d3.map({ + linear: d3_ease_default, + poly: d3_ease_poly, + quad: function() { + return d3_ease_quad; + }, + cubic: function() { + return d3_ease_cubic; + }, + sin: function() { + return d3_ease_sin; + }, + exp: function() { + return d3_ease_exp; + }, + circle: function() { + return d3_ease_circle; + }, + elastic: d3_ease_elastic, + back: d3_ease_back, + bounce: function() { + return d3_ease_bounce; + } + }); + var d3_ease_mode = d3.map({ + "in": d3_identity, + out: d3_ease_reverse, + "in-out": d3_ease_reflect, + "out-in": function(f) { + return d3_ease_reflect(d3_ease_reverse(f)); + } + }); + d3.ease = function(name) { + var i = name.indexOf("-"), t = i >= 0 ? name.substring(0, i) : name, m = i >= 0 ? name.substring(i + 1) : "in"; + t = d3_ease.get(t) || d3_ease_default; + m = d3_ease_mode.get(m) || d3_identity; + return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1)))); + }; + function d3_ease_clamp(f) { + return function(t) { + return t <= 0 ? 0 : t >= 1 ? 1 : f(t); + }; + } + function d3_ease_reverse(f) { + return function(t) { + return 1 - f(1 - t); + }; + } + function d3_ease_reflect(f) { + return function(t) { + return .5 * (t < .5 ? f(2 * t) : 2 - f(2 - 2 * t)); + }; + } + function d3_ease_quad(t) { + return t * t; + } + function d3_ease_cubic(t) { + return t * t * t; + } + function d3_ease_cubicInOut(t) { + if (t <= 0) return 0; + if (t >= 1) return 1; + var t2 = t * t, t3 = t2 * t; + return 4 * (t < .5 ? t3 : 3 * (t - t2) + t3 - .75); + } + function d3_ease_poly(e) { + return function(t) { + return Math.pow(t, e); + }; + } + function d3_ease_sin(t) { + return 1 - Math.cos(t * halfπ); + } + function d3_ease_exp(t) { + return Math.pow(2, 10 * (t - 1)); + } + function d3_ease_circle(t) { + return 1 - Math.sqrt(1 - t * t); + } + function d3_ease_elastic(a, p) { + var s; + if (arguments.length < 2) p = .45; + if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4; + return function(t) { + return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p); + }; + } + function d3_ease_back(s) { + if (!s) s = 1.70158; + return function(t) { + return t * t * ((s + 1) * t - s); + }; + } + function d3_ease_bounce(t) { + return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375; + } + d3.interpolateHcl = d3_interpolateHcl; + function d3_interpolateHcl(a, b) { + a = d3.hcl(a); + b = d3.hcl(b); + var ah = a.h, ac = a.c, al = a.l, bh = b.h - ah, bc = b.c - ac, bl = b.l - al; + if (isNaN(bc)) bc = 0, ac = isNaN(ac) ? b.c : ac; + if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360; + return function(t) { + return d3_hcl_lab(ah + bh * t, ac + bc * t, al + bl * t) + ""; + }; + } + d3.interpolateHsl = d3_interpolateHsl; + function d3_interpolateHsl(a, b) { + a = d3.hsl(a); + b = d3.hsl(b); + var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al; + if (isNaN(bs)) bs = 0, as = isNaN(as) ? b.s : as; + if (isNaN(bh)) bh = 0, ah = isNaN(ah) ? b.h : ah; else if (bh > 180) bh -= 360; else if (bh < -180) bh += 360; + return function(t) { + return d3_hsl_rgb(ah + bh * t, as + bs * t, al + bl * t) + ""; + }; + } + d3.interpolateLab = d3_interpolateLab; + function d3_interpolateLab(a, b) { + a = d3.lab(a); + b = d3.lab(b); + var al = a.l, aa = a.a, ab = a.b, bl = b.l - al, ba = b.a - aa, bb = b.b - ab; + return function(t) { + return d3_lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + ""; + }; + } + d3.interpolateRound = d3_interpolateRound; + function d3_interpolateRound(a, b) { + b -= a; + return function(t) { + return Math.round(a + b * t); + }; + } + d3.transform = function(string) { + var g = d3_document.createElementNS(d3.ns.prefix.svg, "g"); + return (d3.transform = function(string) { + if (string != null) { + g.setAttribute("transform", string); + var t = g.transform.baseVal.consolidate(); + } + return new d3_transform(t ? t.matrix : d3_transformIdentity); + })(string); + }; + function d3_transform(m) { + var r0 = [ m.a, m.b ], r1 = [ m.c, m.d ], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0; + if (r0[0] * r1[1] < r1[0] * r0[1]) { + r0[0] *= -1; + r0[1] *= -1; + kx *= -1; + kz *= -1; + } + this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_degrees; + this.translate = [ m.e, m.f ]; + this.scale = [ kx, ky ]; + this.skew = ky ? Math.atan2(kz, ky) * d3_degrees : 0; + } + d3_transform.prototype.toString = function() { + return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")"; + }; + function d3_transformDot(a, b) { + return a[0] * b[0] + a[1] * b[1]; + } + function d3_transformNormalize(a) { + var k = Math.sqrt(d3_transformDot(a, a)); + if (k) { + a[0] /= k; + a[1] /= k; + } + return k; + } + function d3_transformCombine(a, b, k) { + a[0] += k * b[0]; + a[1] += k * b[1]; + return a; + } + var d3_transformIdentity = { + a: 1, + b: 0, + c: 0, + d: 1, + e: 0, + f: 0 + }; + d3.interpolateTransform = d3_interpolateTransform; + function d3_interpolateTransform(a, b) { + var s = [], q = [], n, A = d3.transform(a), B = d3.transform(b), ta = A.translate, tb = B.translate, ra = A.rotate, rb = B.rotate, wa = A.skew, wb = B.skew, ka = A.scale, kb = B.scale; + if (ta[0] != tb[0] || ta[1] != tb[1]) { + s.push("translate(", null, ",", null, ")"); + q.push({ + i: 1, + x: d3_interpolateNumber(ta[0], tb[0]) + }, { + i: 3, + x: d3_interpolateNumber(ta[1], tb[1]) + }); + } else if (tb[0] || tb[1]) { + s.push("translate(" + tb + ")"); + } else { + s.push(""); + } + if (ra != rb) { + if (ra - rb > 180) rb += 360; else if (rb - ra > 180) ra += 360; + q.push({ + i: s.push(s.pop() + "rotate(", null, ")") - 2, + x: d3_interpolateNumber(ra, rb) + }); + } else if (rb) { + s.push(s.pop() + "rotate(" + rb + ")"); + } + if (wa != wb) { + q.push({ + i: s.push(s.pop() + "skewX(", null, ")") - 2, + x: d3_interpolateNumber(wa, wb) + }); + } else if (wb) { + s.push(s.pop() + "skewX(" + wb + ")"); + } + if (ka[0] != kb[0] || ka[1] != kb[1]) { + n = s.push(s.pop() + "scale(", null, ",", null, ")"); + q.push({ + i: n - 4, + x: d3_interpolateNumber(ka[0], kb[0]) + }, { + i: n - 2, + x: d3_interpolateNumber(ka[1], kb[1]) + }); + } else if (kb[0] != 1 || kb[1] != 1) { + s.push(s.pop() + "scale(" + kb + ")"); + } + n = q.length; + return function(t) { + var i = -1, o; + while (++i < n) s[(o = q[i]).i] = o.x(t); + return s.join(""); + }; + } + function d3_uninterpolateNumber(a, b) { + b = b - (a = +a) ? 1 / (b - a) : 0; + return function(x) { + return (x - a) * b; + }; + } + function d3_uninterpolateClamp(a, b) { + b = b - (a = +a) ? 1 / (b - a) : 0; + return function(x) { + return Math.max(0, Math.min(1, (x - a) * b)); + }; + } + d3.layout = {}; + d3.layout.bundle = function() { + return function(links) { + var paths = [], i = -1, n = links.length; + while (++i < n) paths.push(d3_layout_bundlePath(links[i])); + return paths; + }; + }; + function d3_layout_bundlePath(link) { + var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [ start ]; + while (start !== lca) { + start = start.parent; + points.push(start); + } + var k = points.length; + while (end !== lca) { + points.splice(k, 0, end); + end = end.parent; + } + return points; + } + function d3_layout_bundleAncestors(node) { + var ancestors = [], parent = node.parent; + while (parent != null) { + ancestors.push(node); + node = parent; + parent = parent.parent; + } + ancestors.push(node); + return ancestors; + } + function d3_layout_bundleLeastCommonAncestor(a, b) { + if (a === b) return a; + var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null; + while (aNode === bNode) { + sharedNode = aNode; + aNode = aNodes.pop(); + bNode = bNodes.pop(); + } + return sharedNode; + } + d3.layout.chord = function() { + var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords; + function relayout() { + var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j; + chords = []; + groups = []; + k = 0, i = -1; + while (++i < n) { + x = 0, j = -1; + while (++j < n) { + x += matrix[i][j]; + } + groupSums.push(x); + subgroupIndex.push(d3.range(n)); + k += x; + } + if (sortGroups) { + groupIndex.sort(function(a, b) { + return sortGroups(groupSums[a], groupSums[b]); + }); + } + if (sortSubgroups) { + subgroupIndex.forEach(function(d, i) { + d.sort(function(a, b) { + return sortSubgroups(matrix[i][a], matrix[i][b]); + }); + }); + } + k = (τ - padding * n) / k; + x = 0, i = -1; + while (++i < n) { + x0 = x, j = -1; + while (++j < n) { + var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k; + subgroups[di + "-" + dj] = { + index: di, + subindex: dj, + startAngle: a0, + endAngle: a1, + value: v + }; + } + groups[di] = { + index: di, + startAngle: x0, + endAngle: x, + value: (x - x0) / k + }; + x += padding; + } + i = -1; + while (++i < n) { + j = i - 1; + while (++j < n) { + var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i]; + if (source.value || target.value) { + chords.push(source.value < target.value ? { + source: target, + target: source + } : { + source: source, + target: target + }); + } + } + } + if (sortChords) resort(); + } + function resort() { + chords.sort(function(a, b) { + return sortChords((a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2); + }); + } + chord.matrix = function(x) { + if (!arguments.length) return matrix; + n = (matrix = x) && matrix.length; + chords = groups = null; + return chord; + }; + chord.padding = function(x) { + if (!arguments.length) return padding; + padding = x; + chords = groups = null; + return chord; + }; + chord.sortGroups = function(x) { + if (!arguments.length) return sortGroups; + sortGroups = x; + chords = groups = null; + return chord; + }; + chord.sortSubgroups = function(x) { + if (!arguments.length) return sortSubgroups; + sortSubgroups = x; + chords = null; + return chord; + }; + chord.sortChords = function(x) { + if (!arguments.length) return sortChords; + sortChords = x; + if (chords) resort(); + return chord; + }; + chord.chords = function() { + if (!chords) relayout(); + return chords; + }; + chord.groups = function() { + if (!groups) relayout(); + return groups; + }; + return chord; + }; + d3.layout.force = function() { + var force = {}, event = d3.dispatch("start", "tick", "end"), size = [ 1, 1 ], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, chargeDistance2 = d3_layout_forceChargeDistance2, gravity = .1, theta2 = .64, nodes = [], links = [], distances, strengths, charges; + function repulse(node) { + return function(quad, x1, _, x2) { + if (quad.point !== node) { + var dx = quad.cx - node.x, dy = quad.cy - node.y, dw = x2 - x1, dn = dx * dx + dy * dy; + if (dw * dw / theta2 < dn) { + if (dn < chargeDistance2) { + var k = quad.charge / dn; + node.px -= dx * k; + node.py -= dy * k; + } + return true; + } + if (quad.point && dn && dn < chargeDistance2) { + var k = quad.pointCharge / dn; + node.px -= dx * k; + node.py -= dy * k; + } + } + return !quad.charge; + }; + } + force.tick = function() { + if ((alpha *= .99) < .005) { + event.end({ + type: "end", + alpha: alpha = 0 + }); + return true; + } + var n = nodes.length, m = links.length, q, i, o, s, t, l, k, x, y; + for (i = 0; i < m; ++i) { + o = links[i]; + s = o.source; + t = o.target; + x = t.x - s.x; + y = t.y - s.y; + if (l = x * x + y * y) { + l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l; + x *= l; + y *= l; + t.x -= x * (k = s.weight / (t.weight + s.weight)); + t.y -= y * k; + s.x += x * (k = 1 - k); + s.y += y * k; + } + } + if (k = alpha * gravity) { + x = size[0] / 2; + y = size[1] / 2; + i = -1; + if (k) while (++i < n) { + o = nodes[i]; + o.x += (x - o.x) * k; + o.y += (y - o.y) * k; + } + } + if (charge) { + d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges); + i = -1; + while (++i < n) { + if (!(o = nodes[i]).fixed) { + q.visit(repulse(o)); + } + } + } + i = -1; + while (++i < n) { + o = nodes[i]; + if (o.fixed) { + o.x = o.px; + o.y = o.py; + } else { + o.x -= (o.px - (o.px = o.x)) * friction; + o.y -= (o.py - (o.py = o.y)) * friction; + } + } + event.tick({ + type: "tick", + alpha: alpha + }); + }; + force.nodes = function(x) { + if (!arguments.length) return nodes; + nodes = x; + return force; + }; + force.links = function(x) { + if (!arguments.length) return links; + links = x; + return force; + }; + force.size = function(x) { + if (!arguments.length) return size; + size = x; + return force; + }; + force.linkDistance = function(x) { + if (!arguments.length) return linkDistance; + linkDistance = typeof x === "function" ? x : +x; + return force; + }; + force.distance = force.linkDistance; + force.linkStrength = function(x) { + if (!arguments.length) return linkStrength; + linkStrength = typeof x === "function" ? x : +x; + return force; + }; + force.friction = function(x) { + if (!arguments.length) return friction; + friction = +x; + return force; + }; + force.charge = function(x) { + if (!arguments.length) return charge; + charge = typeof x === "function" ? x : +x; + return force; + }; + force.chargeDistance = function(x) { + if (!arguments.length) return Math.sqrt(chargeDistance2); + chargeDistance2 = x * x; + return force; + }; + force.gravity = function(x) { + if (!arguments.length) return gravity; + gravity = +x; + return force; + }; + force.theta = function(x) { + if (!arguments.length) return Math.sqrt(theta2); + theta2 = x * x; + return force; + }; + force.alpha = function(x) { + if (!arguments.length) return alpha; + x = +x; + if (alpha) { + if (x > 0) alpha = x; else alpha = 0; + } else if (x > 0) { + event.start({ + type: "start", + alpha: alpha = x + }); + d3.timer(force.tick); + } + return force; + }; + force.start = function() { + var i, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o; + for (i = 0; i < n; ++i) { + (o = nodes[i]).index = i; + o.weight = 0; + } + for (i = 0; i < m; ++i) { + o = links[i]; + if (typeof o.source == "number") o.source = nodes[o.source]; + if (typeof o.target == "number") o.target = nodes[o.target]; + ++o.source.weight; + ++o.target.weight; + } + for (i = 0; i < n; ++i) { + o = nodes[i]; + if (isNaN(o.x)) o.x = position("x", w); + if (isNaN(o.y)) o.y = position("y", h); + if (isNaN(o.px)) o.px = o.x; + if (isNaN(o.py)) o.py = o.y; + } + distances = []; + if (typeof linkDistance === "function") for (i = 0; i < m; ++i) distances[i] = +linkDistance.call(this, links[i], i); else for (i = 0; i < m; ++i) distances[i] = linkDistance; + strengths = []; + if (typeof linkStrength === "function") for (i = 0; i < m; ++i) strengths[i] = +linkStrength.call(this, links[i], i); else for (i = 0; i < m; ++i) strengths[i] = linkStrength; + charges = []; + if (typeof charge === "function") for (i = 0; i < n; ++i) charges[i] = +charge.call(this, nodes[i], i); else for (i = 0; i < n; ++i) charges[i] = charge; + function position(dimension, size) { + if (!neighbors) { + neighbors = new Array(n); + for (j = 0; j < n; ++j) { + neighbors[j] = []; + } + for (j = 0; j < m; ++j) { + var o = links[j]; + neighbors[o.source.index].push(o.target); + neighbors[o.target.index].push(o.source); + } + } + var candidates = neighbors[i], j = -1, m = candidates.length, x; + while (++j < m) if (!isNaN(x = candidates[j][dimension])) return x; + return Math.random() * size; + } + return force.resume(); + }; + force.resume = function() { + return force.alpha(.1); + }; + force.stop = function() { + return force.alpha(0); + }; + force.drag = function() { + if (!drag) drag = d3.behavior.drag().origin(d3_identity).on("dragstart.force", d3_layout_forceDragstart).on("drag.force", dragmove).on("dragend.force", d3_layout_forceDragend); + if (!arguments.length) return drag; + this.on("mouseover.force", d3_layout_forceMouseover).on("mouseout.force", d3_layout_forceMouseout).call(drag); + }; + function dragmove(d) { + d.px = d3.event.x, d.py = d3.event.y; + force.resume(); + } + return d3.rebind(force, event, "on"); + }; + function d3_layout_forceDragstart(d) { + d.fixed |= 2; + } + function d3_layout_forceDragend(d) { + d.fixed &= ~6; + } + function d3_layout_forceMouseover(d) { + d.fixed |= 4; + d.px = d.x, d.py = d.y; + } + function d3_layout_forceMouseout(d) { + d.fixed &= ~4; + } + function d3_layout_forceAccumulate(quad, alpha, charges) { + var cx = 0, cy = 0; + quad.charge = 0; + if (!quad.leaf) { + var nodes = quad.nodes, n = nodes.length, i = -1, c; + while (++i < n) { + c = nodes[i]; + if (c == null) continue; + d3_layout_forceAccumulate(c, alpha, charges); + quad.charge += c.charge; + cx += c.charge * c.cx; + cy += c.charge * c.cy; + } + } + if (quad.point) { + if (!quad.leaf) { + quad.point.x += Math.random() - .5; + quad.point.y += Math.random() - .5; + } + var k = alpha * charges[quad.point.index]; + quad.charge += quad.pointCharge = k; + cx += k * quad.point.x; + cy += k * quad.point.y; + } + quad.cx = cx / quad.charge; + quad.cy = cy / quad.charge; + } + var d3_layout_forceLinkDistance = 20, d3_layout_forceLinkStrength = 1, d3_layout_forceChargeDistance2 = Infinity; + d3.layout.hierarchy = function() { + var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue; + function hierarchy(root) { + var stack = [ root ], nodes = [], node; + root.depth = 0; + while ((node = stack.pop()) != null) { + nodes.push(node); + if ((childs = children.call(hierarchy, node, node.depth)) && (n = childs.length)) { + var n, childs, child; + while (--n >= 0) { + stack.push(child = childs[n]); + child.parent = node; + child.depth = node.depth + 1; + } + if (value) node.value = 0; + node.children = childs; + } else { + if (value) node.value = +value.call(hierarchy, node, node.depth) || 0; + delete node.children; + } + } + d3_layout_hierarchyVisitAfter(root, function(node) { + var childs, parent; + if (sort && (childs = node.children)) childs.sort(sort); + if (value && (parent = node.parent)) parent.value += node.value; + }); + return nodes; + } + hierarchy.sort = function(x) { + if (!arguments.length) return sort; + sort = x; + return hierarchy; + }; + hierarchy.children = function(x) { + if (!arguments.length) return children; + children = x; + return hierarchy; + }; + hierarchy.value = function(x) { + if (!arguments.length) return value; + value = x; + return hierarchy; + }; + hierarchy.revalue = function(root) { + if (value) { + d3_layout_hierarchyVisitBefore(root, function(node) { + if (node.children) node.value = 0; + }); + d3_layout_hierarchyVisitAfter(root, function(node) { + var parent; + if (!node.children) node.value = +value.call(hierarchy, node, node.depth) || 0; + if (parent = node.parent) parent.value += node.value; + }); + } + return root; + }; + return hierarchy; + }; + function d3_layout_hierarchyRebind(object, hierarchy) { + d3.rebind(object, hierarchy, "sort", "children", "value"); + object.nodes = object; + object.links = d3_layout_hierarchyLinks; + return object; + } + function d3_layout_hierarchyVisitBefore(node, callback) { + var nodes = [ node ]; + while ((node = nodes.pop()) != null) { + callback(node); + if ((children = node.children) && (n = children.length)) { + var n, children; + while (--n >= 0) nodes.push(children[n]); + } + } + } + function d3_layout_hierarchyVisitAfter(node, callback) { + var nodes = [ node ], nodes2 = []; + while ((node = nodes.pop()) != null) { + nodes2.push(node); + if ((children = node.children) && (n = children.length)) { + var i = -1, n, children; + while (++i < n) nodes.push(children[i]); + } + } + while ((node = nodes2.pop()) != null) { + callback(node); + } + } + function d3_layout_hierarchyChildren(d) { + return d.children; + } + function d3_layout_hierarchyValue(d) { + return d.value; + } + function d3_layout_hierarchySort(a, b) { + return b.value - a.value; + } + function d3_layout_hierarchyLinks(nodes) { + return d3.merge(nodes.map(function(parent) { + return (parent.children || []).map(function(child) { + return { + source: parent, + target: child + }; + }); + })); + } + d3.layout.partition = function() { + var hierarchy = d3.layout.hierarchy(), size = [ 1, 1 ]; + function position(node, x, dx, dy) { + var children = node.children; + node.x = x; + node.y = node.depth * dy; + node.dx = dx; + node.dy = dy; + if (children && (n = children.length)) { + var i = -1, n, c, d; + dx = node.value ? dx / node.value : 0; + while (++i < n) { + position(c = children[i], x, d = c.value * dx, dy); + x += d; + } + } + } + function depth(node) { + var children = node.children, d = 0; + if (children && (n = children.length)) { + var i = -1, n; + while (++i < n) d = Math.max(d, depth(children[i])); + } + return 1 + d; + } + function partition(d, i) { + var nodes = hierarchy.call(this, d, i); + position(nodes[0], 0, size[0], size[1] / depth(nodes[0])); + return nodes; + } + partition.size = function(x) { + if (!arguments.length) return size; + size = x; + return partition; + }; + return d3_layout_hierarchyRebind(partition, hierarchy); + }; + d3.layout.pie = function() { + var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = τ; + function pie(data) { + var values = data.map(function(d, i) { + return +value.call(pie, d, i); + }); + var a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle); + var k = ((typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - a) / d3.sum(values); + var index = d3.range(data.length); + if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) { + return values[j] - values[i]; + } : function(i, j) { + return sort(data[i], data[j]); + }); + var arcs = []; + index.forEach(function(i) { + var d; + arcs[i] = { + data: data[i], + value: d = values[i], + startAngle: a, + endAngle: a += d * k + }; + }); + return arcs; + } + pie.value = function(x) { + if (!arguments.length) return value; + value = x; + return pie; + }; + pie.sort = function(x) { + if (!arguments.length) return sort; + sort = x; + return pie; + }; + pie.startAngle = function(x) { + if (!arguments.length) return startAngle; + startAngle = x; + return pie; + }; + pie.endAngle = function(x) { + if (!arguments.length) return endAngle; + endAngle = x; + return pie; + }; + return pie; + }; + var d3_layout_pieSortByValue = {}; + d3.layout.stack = function() { + var values = d3_identity, order = d3_layout_stackOrderDefault, offset = d3_layout_stackOffsetZero, out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY; + function stack(data, index) { + var series = data.map(function(d, i) { + return values.call(stack, d, i); + }); + var points = series.map(function(d) { + return d.map(function(v, i) { + return [ x.call(stack, v, i), y.call(stack, v, i) ]; + }); + }); + var orders = order.call(stack, points, index); + series = d3.permute(series, orders); + points = d3.permute(points, orders); + var offsets = offset.call(stack, points, index); + var n = series.length, m = series[0].length, i, j, o; + for (j = 0; j < m; ++j) { + out.call(stack, series[0][j], o = offsets[j], points[0][j][1]); + for (i = 1; i < n; ++i) { + out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]); + } + } + return data; + } + stack.values = function(x) { + if (!arguments.length) return values; + values = x; + return stack; + }; + stack.order = function(x) { + if (!arguments.length) return order; + order = typeof x === "function" ? x : d3_layout_stackOrders.get(x) || d3_layout_stackOrderDefault; + return stack; + }; + stack.offset = function(x) { + if (!arguments.length) return offset; + offset = typeof x === "function" ? x : d3_layout_stackOffsets.get(x) || d3_layout_stackOffsetZero; + return stack; + }; + stack.x = function(z) { + if (!arguments.length) return x; + x = z; + return stack; + }; + stack.y = function(z) { + if (!arguments.length) return y; + y = z; + return stack; + }; + stack.out = function(z) { + if (!arguments.length) return out; + out = z; + return stack; + }; + return stack; + }; + function d3_layout_stackX(d) { + return d.x; + } + function d3_layout_stackY(d) { + return d.y; + } + function d3_layout_stackOut(d, y0, y) { + d.y0 = y0; + d.y = y; + } + var d3_layout_stackOrders = d3.map({ + "inside-out": function(data) { + var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) { + return max[a] - max[b]; + }), top = 0, bottom = 0, tops = [], bottoms = []; + for (i = 0; i < n; ++i) { + j = index[i]; + if (top < bottom) { + top += sums[j]; + tops.push(j); + } else { + bottom += sums[j]; + bottoms.push(j); + } + } + return bottoms.reverse().concat(tops); + }, + reverse: function(data) { + return d3.range(data.length).reverse(); + }, + "default": d3_layout_stackOrderDefault + }); + var d3_layout_stackOffsets = d3.map({ + silhouette: function(data) { + var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = []; + for (j = 0; j < m; ++j) { + for (i = 0, o = 0; i < n; i++) o += data[i][j][1]; + if (o > max) max = o; + sums.push(o); + } + for (j = 0; j < m; ++j) { + y0[j] = (max - sums[j]) / 2; + } + return y0; + }, + wiggle: function(data) { + var n = data.length, x = data[0], m = x.length, i, j, k, s1, s2, s3, dx, o, o0, y0 = []; + y0[0] = o = o0 = 0; + for (j = 1; j < m; ++j) { + for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1]; + for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) { + for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) { + s3 += (data[k][j][1] - data[k][j - 1][1]) / dx; + } + s2 += s3 * data[i][j][1]; + } + y0[j] = o -= s1 ? s2 / s1 * dx : 0; + if (o < o0) o0 = o; + } + for (j = 0; j < m; ++j) y0[j] -= o0; + return y0; + }, + expand: function(data) { + var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = []; + for (j = 0; j < m; ++j) { + for (i = 0, o = 0; i < n; i++) o += data[i][j][1]; + if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k; + } + for (j = 0; j < m; ++j) y0[j] = 0; + return y0; + }, + zero: d3_layout_stackOffsetZero + }); + function d3_layout_stackOrderDefault(data) { + return d3.range(data.length); + } + function d3_layout_stackOffsetZero(data) { + var j = -1, m = data[0].length, y0 = []; + while (++j < m) y0[j] = 0; + return y0; + } + function d3_layout_stackMaxIndex(array) { + var i = 1, j = 0, v = array[0][1], k, n = array.length; + for (;i < n; ++i) { + if ((k = array[i][1]) > v) { + j = i; + v = k; + } + } + return j; + } + function d3_layout_stackReduceSum(d) { + return d.reduce(d3_layout_stackSum, 0); + } + function d3_layout_stackSum(p, d) { + return p + d[1]; + } + d3.layout.histogram = function() { + var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges; + function histogram(data, i) { + var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x; + while (++i < m) { + bin = bins[i] = []; + bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]); + bin.y = 0; + } + if (m > 0) { + i = -1; + while (++i < n) { + x = values[i]; + if (x >= range[0] && x <= range[1]) { + bin = bins[d3.bisect(thresholds, x, 1, m) - 1]; + bin.y += k; + bin.push(data[i]); + } + } + } + return bins; + } + histogram.value = function(x) { + if (!arguments.length) return valuer; + valuer = x; + return histogram; + }; + histogram.range = function(x) { + if (!arguments.length) return ranger; + ranger = d3_functor(x); + return histogram; + }; + histogram.bins = function(x) { + if (!arguments.length) return binner; + binner = typeof x === "number" ? function(range) { + return d3_layout_histogramBinFixed(range, x); + } : d3_functor(x); + return histogram; + }; + histogram.frequency = function(x) { + if (!arguments.length) return frequency; + frequency = !!x; + return histogram; + }; + return histogram; + }; + function d3_layout_histogramBinSturges(range, values) { + return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1)); + } + function d3_layout_histogramBinFixed(range, n) { + var x = -1, b = +range[0], m = (range[1] - b) / n, f = []; + while (++x <= n) f[x] = m * x + b; + return f; + } + function d3_layout_histogramRange(values) { + return [ d3.min(values), d3.max(values) ]; + } + d3.layout.pack = function() { + var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), padding = 0, size = [ 1, 1 ], radius; + function pack(d, i) { + var nodes = hierarchy.call(this, d, i), root = nodes[0], w = size[0], h = size[1], r = radius == null ? Math.sqrt : typeof radius === "function" ? radius : function() { + return radius; + }; + root.x = root.y = 0; + d3_layout_hierarchyVisitAfter(root, function(d) { + d.r = +r(d.value); + }); + d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings); + if (padding) { + var dr = padding * (radius ? 1 : Math.max(2 * root.r / w, 2 * root.r / h)) / 2; + d3_layout_hierarchyVisitAfter(root, function(d) { + d.r += dr; + }); + d3_layout_hierarchyVisitAfter(root, d3_layout_packSiblings); + d3_layout_hierarchyVisitAfter(root, function(d) { + d.r -= dr; + }); + } + d3_layout_packTransform(root, w / 2, h / 2, radius ? 1 : 1 / Math.max(2 * root.r / w, 2 * root.r / h)); + return nodes; + } + pack.size = function(_) { + if (!arguments.length) return size; + size = _; + return pack; + }; + pack.radius = function(_) { + if (!arguments.length) return radius; + radius = _ == null || typeof _ === "function" ? _ : +_; + return pack; + }; + pack.padding = function(_) { + if (!arguments.length) return padding; + padding = +_; + return pack; + }; + return d3_layout_hierarchyRebind(pack, hierarchy); + }; + function d3_layout_packSort(a, b) { + return a.value - b.value; + } + function d3_layout_packInsert(a, b) { + var c = a._pack_next; + a._pack_next = b; + b._pack_prev = a; + b._pack_next = c; + c._pack_prev = b; + } + function d3_layout_packSplice(a, b) { + a._pack_next = b; + b._pack_prev = a; + } + function d3_layout_packIntersects(a, b) { + var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r; + return .999 * dr * dr > dx * dx + dy * dy; + } + function d3_layout_packSiblings(node) { + if (!(nodes = node.children) || !(n = nodes.length)) return; + var nodes, xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, a, b, c, i, j, k, n; + function bound(node) { + xMin = Math.min(node.x - node.r, xMin); + xMax = Math.max(node.x + node.r, xMax); + yMin = Math.min(node.y - node.r, yMin); + yMax = Math.max(node.y + node.r, yMax); + } + nodes.forEach(d3_layout_packLink); + a = nodes[0]; + a.x = -a.r; + a.y = 0; + bound(a); + if (n > 1) { + b = nodes[1]; + b.x = b.r; + b.y = 0; + bound(b); + if (n > 2) { + c = nodes[2]; + d3_layout_packPlace(a, b, c); + bound(c); + d3_layout_packInsert(a, c); + a._pack_prev = c; + d3_layout_packInsert(c, b); + b = a._pack_next; + for (i = 3; i < n; i++) { + d3_layout_packPlace(a, b, c = nodes[i]); + var isect = 0, s1 = 1, s2 = 1; + for (j = b._pack_next; j !== b; j = j._pack_next, s1++) { + if (d3_layout_packIntersects(j, c)) { + isect = 1; + break; + } + } + if (isect == 1) { + for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) { + if (d3_layout_packIntersects(k, c)) { + break; + } + } + } + if (isect) { + if (s1 < s2 || s1 == s2 && b.r < a.r) d3_layout_packSplice(a, b = j); else d3_layout_packSplice(a = k, b); + i--; + } else { + d3_layout_packInsert(a, c); + b = c; + bound(c); + } + } + } + } + var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0; + for (i = 0; i < n; i++) { + c = nodes[i]; + c.x -= cx; + c.y -= cy; + cr = Math.max(cr, c.r + Math.sqrt(c.x * c.x + c.y * c.y)); + } + node.r = cr; + nodes.forEach(d3_layout_packUnlink); + } + function d3_layout_packLink(node) { + node._pack_next = node._pack_prev = node; + } + function d3_layout_packUnlink(node) { + delete node._pack_next; + delete node._pack_prev; + } + function d3_layout_packTransform(node, x, y, k) { + var children = node.children; + node.x = x += k * node.x; + node.y = y += k * node.y; + node.r *= k; + if (children) { + var i = -1, n = children.length; + while (++i < n) d3_layout_packTransform(children[i], x, y, k); + } + } + function d3_layout_packPlace(a, b, c) { + var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y; + if (db && (dx || dy)) { + var da = b.r + c.r, dc = dx * dx + dy * dy; + da *= da; + db *= db; + var x = .5 + (db - da) / (2 * dc), y = Math.sqrt(Math.max(0, 2 * da * (db + dc) - (db -= dc) * db - da * da)) / (2 * dc); + c.x = a.x + x * dx + y * dy; + c.y = a.y + x * dy - y * dx; + } else { + c.x = a.x + db; + c.y = a.y; + } + } + d3.layout.tree = function() { + var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = null; + function tree(d, i) { + var nodes = hierarchy.call(this, d, i), root0 = nodes[0], root1 = wrapTree(root0); + d3_layout_hierarchyVisitAfter(root1, firstWalk), root1.parent.m = -root1.z; + d3_layout_hierarchyVisitBefore(root1, secondWalk); + if (nodeSize) d3_layout_hierarchyVisitBefore(root0, sizeNode); else { + var left = root0, right = root0, bottom = root0; + d3_layout_hierarchyVisitBefore(root0, function(node) { + if (node.x < left.x) left = node; + if (node.x > right.x) right = node; + if (node.depth > bottom.depth) bottom = node; + }); + var tx = separation(left, right) / 2 - left.x, kx = size[0] / (right.x + separation(right, left) / 2 + tx), ky = size[1] / (bottom.depth || 1); + d3_layout_hierarchyVisitBefore(root0, function(node) { + node.x = (node.x + tx) * kx; + node.y = node.depth * ky; + }); + } + return nodes; + } + function wrapTree(root0) { + var root1 = { + A: null, + children: [ root0 ] + }, queue = [ root1 ], node1; + while ((node1 = queue.pop()) != null) { + for (var children = node1.children, child, i = 0, n = children.length; i < n; ++i) { + queue.push((children[i] = child = { + _: children[i], + parent: node1, + children: (child = children[i].children) && child.slice() || [], + A: null, + a: null, + z: 0, + m: 0, + c: 0, + s: 0, + t: null, + i: i + }).a = child); + } + } + return root1.children[0]; + } + function firstWalk(v) { + var children = v.children, siblings = v.parent.children, w = v.i ? siblings[v.i - 1] : null; + if (children.length) { + d3_layout_treeShift(v); + var midpoint = (children[0].z + children[children.length - 1].z) / 2; + if (w) { + v.z = w.z + separation(v._, w._); + v.m = v.z - midpoint; + } else { + v.z = midpoint; + } + } else if (w) { + v.z = w.z + separation(v._, w._); + } + v.parent.A = apportion(v, w, v.parent.A || siblings[0]); + } + function secondWalk(v) { + v._.x = v.z + v.parent.m; + v.m += v.parent.m; + } + function apportion(v, w, ancestor) { + if (w) { + var vip = v, vop = v, vim = w, vom = vip.parent.children[0], sip = vip.m, sop = vop.m, sim = vim.m, som = vom.m, shift; + while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) { + vom = d3_layout_treeLeft(vom); + vop = d3_layout_treeRight(vop); + vop.a = v; + shift = vim.z + sim - vip.z - sip + separation(vim._, vip._); + if (shift > 0) { + d3_layout_treeMove(d3_layout_treeAncestor(vim, v, ancestor), v, shift); + sip += shift; + sop += shift; + } + sim += vim.m; + sip += vip.m; + som += vom.m; + sop += vop.m; + } + if (vim && !d3_layout_treeRight(vop)) { + vop.t = vim; + vop.m += sim - sop; + } + if (vip && !d3_layout_treeLeft(vom)) { + vom.t = vip; + vom.m += sip - som; + ancestor = v; + } + } + return ancestor; + } + function sizeNode(node) { + node.x *= size[0]; + node.y = node.depth * size[1]; + } + tree.separation = function(x) { + if (!arguments.length) return separation; + separation = x; + return tree; + }; + tree.size = function(x) { + if (!arguments.length) return nodeSize ? null : size; + nodeSize = (size = x) == null ? sizeNode : null; + return tree; + }; + tree.nodeSize = function(x) { + if (!arguments.length) return nodeSize ? size : null; + nodeSize = (size = x) == null ? null : sizeNode; + return tree; + }; + return d3_layout_hierarchyRebind(tree, hierarchy); + }; + function d3_layout_treeSeparation(a, b) { + return a.parent == b.parent ? 1 : 2; + } + function d3_layout_treeLeft(v) { + var children = v.children; + return children.length ? children[0] : v.t; + } + function d3_layout_treeRight(v) { + var children = v.children, n; + return (n = children.length) ? children[n - 1] : v.t; + } + function d3_layout_treeMove(wm, wp, shift) { + var change = shift / (wp.i - wm.i); + wp.c -= change; + wp.s += shift; + wm.c += change; + wp.z += shift; + wp.m += shift; + } + function d3_layout_treeShift(v) { + var shift = 0, change = 0, children = v.children, i = children.length, w; + while (--i >= 0) { + w = children[i]; + w.z += shift; + w.m += shift; + shift += w.s + (change += w.c); + } + } + function d3_layout_treeAncestor(vim, v, ancestor) { + return vim.a.parent === v.parent ? vim.a : ancestor; + } + d3.layout.cluster = function() { + var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [ 1, 1 ], nodeSize = false; + function cluster(d, i) { + var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0; + d3_layout_hierarchyVisitAfter(root, function(node) { + var children = node.children; + if (children && children.length) { + node.x = d3_layout_clusterX(children); + node.y = d3_layout_clusterY(children); + } else { + node.x = previousNode ? x += separation(node, previousNode) : 0; + node.y = 0; + previousNode = node; + } + }); + var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2; + d3_layout_hierarchyVisitAfter(root, nodeSize ? function(node) { + node.x = (node.x - root.x) * size[0]; + node.y = (root.y - node.y) * size[1]; + } : function(node) { + node.x = (node.x - x0) / (x1 - x0) * size[0]; + node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1]; + }); + return nodes; + } + cluster.separation = function(x) { + if (!arguments.length) return separation; + separation = x; + return cluster; + }; + cluster.size = function(x) { + if (!arguments.length) return nodeSize ? null : size; + nodeSize = (size = x) == null; + return cluster; + }; + cluster.nodeSize = function(x) { + if (!arguments.length) return nodeSize ? size : null; + nodeSize = (size = x) != null; + return cluster; + }; + return d3_layout_hierarchyRebind(cluster, hierarchy); + }; + function d3_layout_clusterY(children) { + return 1 + d3.max(children, function(child) { + return child.y; + }); + } + function d3_layout_clusterX(children) { + return children.reduce(function(x, child) { + return x + child.x; + }, 0) / children.length; + } + function d3_layout_clusterLeft(node) { + var children = node.children; + return children && children.length ? d3_layout_clusterLeft(children[0]) : node; + } + function d3_layout_clusterRight(node) { + var children = node.children, n; + return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node; + } + d3.layout.treemap = function() { + var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [ 1, 1 ], padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, mode = "squarify", ratio = .5 * (1 + Math.sqrt(5)); + function scale(children, k) { + var i = -1, n = children.length, child, area; + while (++i < n) { + area = (child = children[i]).value * (k < 0 ? 0 : k); + child.area = isNaN(area) || area <= 0 ? 0 : area; + } + } + function squarify(node) { + var children = node.children; + if (children && children.length) { + var rect = pad(node), row = [], remaining = children.slice(), child, best = Infinity, score, u = mode === "slice" ? rect.dx : mode === "dice" ? rect.dy : mode === "slice-dice" ? node.depth & 1 ? rect.dy : rect.dx : Math.min(rect.dx, rect.dy), n; + scale(remaining, rect.dx * rect.dy / node.value); + row.area = 0; + while ((n = remaining.length) > 0) { + row.push(child = remaining[n - 1]); + row.area += child.area; + if (mode !== "squarify" || (score = worst(row, u)) <= best) { + remaining.pop(); + best = score; + } else { + row.area -= row.pop().area; + position(row, u, rect, false); + u = Math.min(rect.dx, rect.dy); + row.length = row.area = 0; + best = Infinity; + } + } + if (row.length) { + position(row, u, rect, true); + row.length = row.area = 0; + } + children.forEach(squarify); + } + } + function stickify(node) { + var children = node.children; + if (children && children.length) { + var rect = pad(node), remaining = children.slice(), child, row = []; + scale(remaining, rect.dx * rect.dy / node.value); + row.area = 0; + while (child = remaining.pop()) { + row.push(child); + row.area += child.area; + if (child.z != null) { + position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length); + row.length = row.area = 0; + } + } + children.forEach(stickify); + } + } + function worst(row, u) { + var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length; + while (++i < n) { + if (!(r = row[i].area)) continue; + if (r < rmin) rmin = r; + if (r > rmax) rmax = r; + } + s *= s; + u *= u; + return s ? Math.max(u * rmax * ratio / s, s / (u * rmin * ratio)) : Infinity; + } + function position(row, u, rect, flush) { + var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o; + if (u == rect.dx) { + if (flush || v > rect.dy) v = rect.dy; + while (++i < n) { + o = row[i]; + o.x = x; + o.y = y; + o.dy = v; + x += o.dx = Math.min(rect.x + rect.dx - x, v ? round(o.area / v) : 0); + } + o.z = true; + o.dx += rect.x + rect.dx - x; + rect.y += v; + rect.dy -= v; + } else { + if (flush || v > rect.dx) v = rect.dx; + while (++i < n) { + o = row[i]; + o.x = x; + o.y = y; + o.dx = v; + y += o.dy = Math.min(rect.y + rect.dy - y, v ? round(o.area / v) : 0); + } + o.z = false; + o.dy += rect.y + rect.dy - y; + rect.x += v; + rect.dx -= v; + } + } + function treemap(d) { + var nodes = stickies || hierarchy(d), root = nodes[0]; + root.x = 0; + root.y = 0; + root.dx = size[0]; + root.dy = size[1]; + if (stickies) hierarchy.revalue(root); + scale([ root ], root.dx * root.dy / root.value); + (stickies ? stickify : squarify)(root); + if (sticky) stickies = nodes; + return nodes; + } + treemap.size = function(x) { + if (!arguments.length) return size; + size = x; + return treemap; + }; + treemap.padding = function(x) { + if (!arguments.length) return padding; + function padFunction(node) { + var p = x.call(treemap, node, node.depth); + return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [ p, p, p, p ] : p); + } + function padConstant(node) { + return d3_layout_treemapPad(node, x); + } + var type; + pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [ x, x, x, x ], + padConstant) : padConstant; + return treemap; + }; + treemap.round = function(x) { + if (!arguments.length) return round != Number; + round = x ? Math.round : Number; + return treemap; + }; + treemap.sticky = function(x) { + if (!arguments.length) return sticky; + sticky = x; + stickies = null; + return treemap; + }; + treemap.ratio = function(x) { + if (!arguments.length) return ratio; + ratio = x; + return treemap; + }; + treemap.mode = function(x) { + if (!arguments.length) return mode; + mode = x + ""; + return treemap; + }; + return d3_layout_hierarchyRebind(treemap, hierarchy); + }; + function d3_layout_treemapPadNull(node) { + return { + x: node.x, + y: node.y, + dx: node.dx, + dy: node.dy + }; + } + function d3_layout_treemapPad(node, padding) { + var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2]; + if (dx < 0) { + x += dx / 2; + dx = 0; + } + if (dy < 0) { + y += dy / 2; + dy = 0; + } + return { + x: x, + y: y, + dx: dx, + dy: dy + }; + } + d3.random = { + normal: function(µ, σ) { + var n = arguments.length; + if (n < 2) σ = 1; + if (n < 1) µ = 0; + return function() { + var x, y, r; + do { + x = Math.random() * 2 - 1; + y = Math.random() * 2 - 1; + r = x * x + y * y; + } while (!r || r > 1); + return µ + σ * x * Math.sqrt(-2 * Math.log(r) / r); + }; + }, + logNormal: function() { + var random = d3.random.normal.apply(d3, arguments); + return function() { + return Math.exp(random()); + }; + }, + bates: function(m) { + var random = d3.random.irwinHall(m); + return function() { + return random() / m; + }; + }, + irwinHall: function(m) { + return function() { + for (var s = 0, j = 0; j < m; j++) s += Math.random(); + return s; + }; + } + }; + d3.scale = {}; + function d3_scaleExtent(domain) { + var start = domain[0], stop = domain[domain.length - 1]; + return start < stop ? [ start, stop ] : [ stop, start ]; + } + function d3_scaleRange(scale) { + return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range()); + } + function d3_scale_bilinear(domain, range, uninterpolate, interpolate) { + var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]); + return function(x) { + return i(u(x)); + }; + } + function d3_scale_nice(domain, nice) { + var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx; + if (x1 < x0) { + dx = i0, i0 = i1, i1 = dx; + dx = x0, x0 = x1, x1 = dx; + } + domain[i0] = nice.floor(x0); + domain[i1] = nice.ceil(x1); + return domain; + } + function d3_scale_niceStep(step) { + return step ? { + floor: function(x) { + return Math.floor(x / step) * step; + }, + ceil: function(x) { + return Math.ceil(x / step) * step; + } + } : d3_scale_niceIdentity; + } + var d3_scale_niceIdentity = { + floor: d3_identity, + ceil: d3_identity + }; + function d3_scale_polylinear(domain, range, uninterpolate, interpolate) { + var u = [], i = [], j = 0, k = Math.min(domain.length, range.length) - 1; + if (domain[k] < domain[0]) { + domain = domain.slice().reverse(); + range = range.slice().reverse(); + } + while (++j <= k) { + u.push(uninterpolate(domain[j - 1], domain[j])); + i.push(interpolate(range[j - 1], range[j])); + } + return function(x) { + var j = d3.bisect(domain, x, 1, k) - 1; + return i[j](u[j](x)); + }; + } + d3.scale.linear = function() { + return d3_scale_linear([ 0, 1 ], [ 0, 1 ], d3_interpolate, false); + }; + function d3_scale_linear(domain, range, interpolate, clamp) { + var output, input; + function rescale() { + var linear = Math.min(domain.length, range.length) > 2 ? d3_scale_polylinear : d3_scale_bilinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber; + output = linear(domain, range, uninterpolate, interpolate); + input = linear(range, domain, uninterpolate, d3_interpolate); + return scale; + } + function scale(x) { + return output(x); + } + scale.invert = function(y) { + return input(y); + }; + scale.domain = function(x) { + if (!arguments.length) return domain; + domain = x.map(Number); + return rescale(); + }; + scale.range = function(x) { + if (!arguments.length) return range; + range = x; + return rescale(); + }; + scale.rangeRound = function(x) { + return scale.range(x).interpolate(d3_interpolateRound); + }; + scale.clamp = function(x) { + if (!arguments.length) return clamp; + clamp = x; + return rescale(); + }; + scale.interpolate = function(x) { + if (!arguments.length) return interpolate; + interpolate = x; + return rescale(); + }; + scale.ticks = function(m) { + return d3_scale_linearTicks(domain, m); + }; + scale.tickFormat = function(m, format) { + return d3_scale_linearTickFormat(domain, m, format); + }; + scale.nice = function(m) { + d3_scale_linearNice(domain, m); + return rescale(); + }; + scale.copy = function() { + return d3_scale_linear(domain, range, interpolate, clamp); + }; + return rescale(); + } + function d3_scale_linearRebind(scale, linear) { + return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp"); + } + function d3_scale_linearNice(domain, m) { + return d3_scale_nice(domain, d3_scale_niceStep(d3_scale_linearTickRange(domain, m)[2])); + } + function d3_scale_linearTickRange(domain, m) { + if (m == null) m = 10; + var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step; + if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2; + extent[0] = Math.ceil(extent[0] / step) * step; + extent[1] = Math.floor(extent[1] / step) * step + step * .5; + extent[2] = step; + return extent; + } + function d3_scale_linearTicks(domain, m) { + return d3.range.apply(d3, d3_scale_linearTickRange(domain, m)); + } + function d3_scale_linearTickFormat(domain, m, format) { + var range = d3_scale_linearTickRange(domain, m); + if (format) { + var match = d3_format_re.exec(format); + match.shift(); + if (match[8] === "s") { + var prefix = d3.formatPrefix(Math.max(abs(range[0]), abs(range[1]))); + if (!match[7]) match[7] = "." + d3_scale_linearPrecision(prefix.scale(range[2])); + match[8] = "f"; + format = d3.format(match.join("")); + return function(d) { + return format(prefix.scale(d)) + prefix.symbol; + }; + } + if (!match[7]) match[7] = "." + d3_scale_linearFormatPrecision(match[8], range); + format = match.join(""); + } else { + format = ",." + d3_scale_linearPrecision(range[2]) + "f"; + } + return d3.format(format); + } + var d3_scale_linearFormatSignificant = { + s: 1, + g: 1, + p: 1, + r: 1, + e: 1 + }; + function d3_scale_linearPrecision(value) { + return -Math.floor(Math.log(value) / Math.LN10 + .01); + } + function d3_scale_linearFormatPrecision(type, range) { + var p = d3_scale_linearPrecision(range[2]); + return type in d3_scale_linearFormatSignificant ? Math.abs(p - d3_scale_linearPrecision(Math.max(abs(range[0]), abs(range[1])))) + +(type !== "e") : p - (type === "%") * 2; + } + d3.scale.log = function() { + return d3_scale_log(d3.scale.linear().domain([ 0, 1 ]), 10, true, [ 1, 10 ]); + }; + function d3_scale_log(linear, base, positive, domain) { + function log(x) { + return (positive ? Math.log(x < 0 ? 0 : x) : -Math.log(x > 0 ? 0 : -x)) / Math.log(base); + } + function pow(x) { + return positive ? Math.pow(base, x) : -Math.pow(base, -x); + } + function scale(x) { + return linear(log(x)); + } + scale.invert = function(x) { + return pow(linear.invert(x)); + }; + scale.domain = function(x) { + if (!arguments.length) return domain; + positive = x[0] >= 0; + linear.domain((domain = x.map(Number)).map(log)); + return scale; + }; + scale.base = function(_) { + if (!arguments.length) return base; + base = +_; + linear.domain(domain.map(log)); + return scale; + }; + scale.nice = function() { + var niced = d3_scale_nice(domain.map(log), positive ? Math : d3_scale_logNiceNegative); + linear.domain(niced); + domain = niced.map(pow); + return scale; + }; + scale.ticks = function() { + var extent = d3_scaleExtent(domain), ticks = [], u = extent[0], v = extent[1], i = Math.floor(log(u)), j = Math.ceil(log(v)), n = base % 1 ? 2 : base; + if (isFinite(j - i)) { + if (positive) { + for (;i < j; i++) for (var k = 1; k < n; k++) ticks.push(pow(i) * k); + ticks.push(pow(i)); + } else { + ticks.push(pow(i)); + for (;i++ < j; ) for (var k = n - 1; k > 0; k--) ticks.push(pow(i) * k); + } + for (i = 0; ticks[i] < u; i++) {} + for (j = ticks.length; ticks[j - 1] > v; j--) {} + ticks = ticks.slice(i, j); + } + return ticks; + }; + scale.tickFormat = function(n, format) { + if (!arguments.length) return d3_scale_logFormat; + if (arguments.length < 2) format = d3_scale_logFormat; else if (typeof format !== "function") format = d3.format(format); + var k = Math.max(.1, n / scale.ticks().length), f = positive ? (e = 1e-12, Math.ceil) : (e = -1e-12, + Math.floor), e; + return function(d) { + return d / pow(f(log(d) + e)) <= k ? format(d) : ""; + }; + }; + scale.copy = function() { + return d3_scale_log(linear.copy(), base, positive, domain); + }; + return d3_scale_linearRebind(scale, linear); + } + var d3_scale_logFormat = d3.format(".0e"), d3_scale_logNiceNegative = { + floor: function(x) { + return -Math.ceil(-x); + }, + ceil: function(x) { + return -Math.floor(-x); + } + }; + d3.scale.pow = function() { + return d3_scale_pow(d3.scale.linear(), 1, [ 0, 1 ]); + }; + function d3_scale_pow(linear, exponent, domain) { + var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent); + function scale(x) { + return linear(powp(x)); + } + scale.invert = function(x) { + return powb(linear.invert(x)); + }; + scale.domain = function(x) { + if (!arguments.length) return domain; + linear.domain((domain = x.map(Number)).map(powp)); + return scale; + }; + scale.ticks = function(m) { + return d3_scale_linearTicks(domain, m); + }; + scale.tickFormat = function(m, format) { + return d3_scale_linearTickFormat(domain, m, format); + }; + scale.nice = function(m) { + return scale.domain(d3_scale_linearNice(domain, m)); + }; + scale.exponent = function(x) { + if (!arguments.length) return exponent; + powp = d3_scale_powPow(exponent = x); + powb = d3_scale_powPow(1 / exponent); + linear.domain(domain.map(powp)); + return scale; + }; + scale.copy = function() { + return d3_scale_pow(linear.copy(), exponent, domain); + }; + return d3_scale_linearRebind(scale, linear); + } + function d3_scale_powPow(e) { + return function(x) { + return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e); + }; + } + d3.scale.sqrt = function() { + return d3.scale.pow().exponent(.5); + }; + d3.scale.ordinal = function() { + return d3_scale_ordinal([], { + t: "range", + a: [ [] ] + }); + }; + function d3_scale_ordinal(domain, ranger) { + var index, range, rangeBand; + function scale(x) { + return range[((index.get(x) || (ranger.t === "range" ? index.set(x, domain.push(x)) : NaN)) - 1) % range.length]; + } + function steps(start, step) { + return d3.range(domain.length).map(function(i) { + return start + step * i; + }); + } + scale.domain = function(x) { + if (!arguments.length) return domain; + domain = []; + index = new d3_Map(); + var i = -1, n = x.length, xi; + while (++i < n) if (!index.has(xi = x[i])) index.set(xi, domain.push(xi)); + return scale[ranger.t].apply(scale, ranger.a); + }; + scale.range = function(x) { + if (!arguments.length) return range; + range = x; + rangeBand = 0; + ranger = { + t: "range", + a: arguments + }; + return scale; + }; + scale.rangePoints = function(x, padding) { + if (arguments.length < 2) padding = 0; + var start = x[0], stop = x[1], step = (stop - start) / (Math.max(1, domain.length - 1) + padding); + range = steps(domain.length < 2 ? (start + stop) / 2 : start + step * padding / 2, step); + rangeBand = 0; + ranger = { + t: "rangePoints", + a: arguments + }; + return scale; + }; + scale.rangeBands = function(x, padding, outerPadding) { + if (arguments.length < 2) padding = 0; + if (arguments.length < 3) outerPadding = padding; + var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = (stop - start) / (domain.length - padding + 2 * outerPadding); + range = steps(start + step * outerPadding, step); + if (reverse) range.reverse(); + rangeBand = step * (1 - padding); + ranger = { + t: "rangeBands", + a: arguments + }; + return scale; + }; + scale.rangeRoundBands = function(x, padding, outerPadding) { + if (arguments.length < 2) padding = 0; + if (arguments.length < 3) outerPadding = padding; + var reverse = x[1] < x[0], start = x[reverse - 0], stop = x[1 - reverse], step = Math.floor((stop - start) / (domain.length - padding + 2 * outerPadding)), error = stop - start - (domain.length - padding) * step; + range = steps(start + Math.round(error / 2), step); + if (reverse) range.reverse(); + rangeBand = Math.round(step * (1 - padding)); + ranger = { + t: "rangeRoundBands", + a: arguments + }; + return scale; + }; + scale.rangeBand = function() { + return rangeBand; + }; + scale.rangeExtent = function() { + return d3_scaleExtent(ranger.a[0]); + }; + scale.copy = function() { + return d3_scale_ordinal(domain, ranger); + }; + return scale.domain(domain); + } + d3.scale.category10 = function() { + return d3.scale.ordinal().range(d3_category10); + }; + d3.scale.category20 = function() { + return d3.scale.ordinal().range(d3_category20); + }; + d3.scale.category20b = function() { + return d3.scale.ordinal().range(d3_category20b); + }; + d3.scale.category20c = function() { + return d3.scale.ordinal().range(d3_category20c); + }; + var d3_category10 = [ 2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175 ].map(d3_rgbString); + var d3_category20 = [ 2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725 ].map(d3_rgbString); + var d3_category20b = [ 3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654 ].map(d3_rgbString); + var d3_category20c = [ 3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081 ].map(d3_rgbString); + d3.scale.quantile = function() { + return d3_scale_quantile([], []); + }; + function d3_scale_quantile(domain, range) { + var thresholds; + function rescale() { + var k = 0, q = range.length; + thresholds = []; + while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q); + return scale; + } + function scale(x) { + if (!isNaN(x = +x)) return range[d3.bisect(thresholds, x)]; + } + scale.domain = function(x) { + if (!arguments.length) return domain; + domain = x.filter(d3_number).sort(d3_ascending); + return rescale(); + }; + scale.range = function(x) { + if (!arguments.length) return range; + range = x; + return rescale(); + }; + scale.quantiles = function() { + return thresholds; + }; + scale.invertExtent = function(y) { + y = range.indexOf(y); + return y < 0 ? [ NaN, NaN ] : [ y > 0 ? thresholds[y - 1] : domain[0], y < thresholds.length ? thresholds[y] : domain[domain.length - 1] ]; + }; + scale.copy = function() { + return d3_scale_quantile(domain, range); + }; + return rescale(); + } + d3.scale.quantize = function() { + return d3_scale_quantize(0, 1, [ 0, 1 ]); + }; + function d3_scale_quantize(x0, x1, range) { + var kx, i; + function scale(x) { + return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))]; + } + function rescale() { + kx = range.length / (x1 - x0); + i = range.length - 1; + return scale; + } + scale.domain = function(x) { + if (!arguments.length) return [ x0, x1 ]; + x0 = +x[0]; + x1 = +x[x.length - 1]; + return rescale(); + }; + scale.range = function(x) { + if (!arguments.length) return range; + range = x; + return rescale(); + }; + scale.invertExtent = function(y) { + y = range.indexOf(y); + y = y < 0 ? NaN : y / kx + x0; + return [ y, y + 1 / kx ]; + }; + scale.copy = function() { + return d3_scale_quantize(x0, x1, range); + }; + return rescale(); + } + d3.scale.threshold = function() { + return d3_scale_threshold([ .5 ], [ 0, 1 ]); + }; + function d3_scale_threshold(domain, range) { + function scale(x) { + if (x <= x) return range[d3.bisect(domain, x)]; + } + scale.domain = function(_) { + if (!arguments.length) return domain; + domain = _; + return scale; + }; + scale.range = function(_) { + if (!arguments.length) return range; + range = _; + return scale; + }; + scale.invertExtent = function(y) { + y = range.indexOf(y); + return [ domain[y - 1], domain[y] ]; + }; + scale.copy = function() { + return d3_scale_threshold(domain, range); + }; + return scale; + } + d3.scale.identity = function() { + return d3_scale_identity([ 0, 1 ]); + }; + function d3_scale_identity(domain) { + function identity(x) { + return +x; + } + identity.invert = identity; + identity.domain = identity.range = function(x) { + if (!arguments.length) return domain; + domain = x.map(identity); + return identity; + }; + identity.ticks = function(m) { + return d3_scale_linearTicks(domain, m); + }; + identity.tickFormat = function(m, format) { + return d3_scale_linearTickFormat(domain, m, format); + }; + identity.copy = function() { + return d3_scale_identity(domain); + }; + return identity; + } + d3.svg = {}; + d3.svg.arc = function() { + var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle; + function arc() { + var r0 = innerRadius.apply(this, arguments), r1 = outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) + d3_svg_arcOffset, a1 = endAngle.apply(this, arguments) + d3_svg_arcOffset, da = (a1 < a0 && (da = a0, + a0 = a1, a1 = da), a1 - a0), df = da < π ? "0" : "1", c0 = Math.cos(a0), s0 = Math.sin(a0), c1 = Math.cos(a1), s1 = Math.sin(a1); + return da >= d3_svg_arcMax ? r0 ? "M0," + r1 + "A" + r1 + "," + r1 + " 0 1,1 0," + -r1 + "A" + r1 + "," + r1 + " 0 1,1 0," + r1 + "M0," + r0 + "A" + r0 + "," + r0 + " 0 1,0 0," + -r0 + "A" + r0 + "," + r0 + " 0 1,0 0," + r0 + "Z" : "M0," + r1 + "A" + r1 + "," + r1 + " 0 1,1 0," + -r1 + "A" + r1 + "," + r1 + " 0 1,1 0," + r1 + "Z" : r0 ? "M" + r1 * c0 + "," + r1 * s0 + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1 + "L" + r0 * c1 + "," + r0 * s1 + "A" + r0 + "," + r0 + " 0 " + df + ",0 " + r0 * c0 + "," + r0 * s0 + "Z" : "M" + r1 * c0 + "," + r1 * s0 + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1 + "L0,0" + "Z"; + } + arc.innerRadius = function(v) { + if (!arguments.length) return innerRadius; + innerRadius = d3_functor(v); + return arc; + }; + arc.outerRadius = function(v) { + if (!arguments.length) return outerRadius; + outerRadius = d3_functor(v); + return arc; + }; + arc.startAngle = function(v) { + if (!arguments.length) return startAngle; + startAngle = d3_functor(v); + return arc; + }; + arc.endAngle = function(v) { + if (!arguments.length) return endAngle; + endAngle = d3_functor(v); + return arc; + }; + arc.centroid = function() { + var r = (innerRadius.apply(this, arguments) + outerRadius.apply(this, arguments)) / 2, a = (startAngle.apply(this, arguments) + endAngle.apply(this, arguments)) / 2 + d3_svg_arcOffset; + return [ Math.cos(a) * r, Math.sin(a) * r ]; + }; + return arc; + }; + var d3_svg_arcOffset = -halfπ, d3_svg_arcMax = τ - ε; + function d3_svg_arcInnerRadius(d) { + return d.innerRadius; + } + function d3_svg_arcOuterRadius(d) { + return d.outerRadius; + } + function d3_svg_arcStartAngle(d) { + return d.startAngle; + } + function d3_svg_arcEndAngle(d) { + return d.endAngle; + } + function d3_svg_line(projection) { + var x = d3_geom_pointX, y = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, tension = .7; + function line(data) { + var segments = [], points = [], i = -1, n = data.length, d, fx = d3_functor(x), fy = d3_functor(y); + function segment() { + segments.push("M", interpolate(projection(points), tension)); + } + while (++i < n) { + if (defined.call(this, d = data[i], i)) { + points.push([ +fx.call(this, d, i), +fy.call(this, d, i) ]); + } else if (points.length) { + segment(); + points = []; + } + } + if (points.length) segment(); + return segments.length ? segments.join("") : null; + } + line.x = function(_) { + if (!arguments.length) return x; + x = _; + return line; + }; + line.y = function(_) { + if (!arguments.length) return y; + y = _; + return line; + }; + line.defined = function(_) { + if (!arguments.length) return defined; + defined = _; + return line; + }; + line.interpolate = function(_) { + if (!arguments.length) return interpolateKey; + if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key; + return line; + }; + line.tension = function(_) { + if (!arguments.length) return tension; + tension = _; + return line; + }; + return line; + } + d3.svg.line = function() { + return d3_svg_line(d3_identity); + }; + var d3_svg_lineInterpolators = d3.map({ + linear: d3_svg_lineLinear, + "linear-closed": d3_svg_lineLinearClosed, + step: d3_svg_lineStep, + "step-before": d3_svg_lineStepBefore, + "step-after": d3_svg_lineStepAfter, + basis: d3_svg_lineBasis, + "basis-open": d3_svg_lineBasisOpen, + "basis-closed": d3_svg_lineBasisClosed, + bundle: d3_svg_lineBundle, + cardinal: d3_svg_lineCardinal, + "cardinal-open": d3_svg_lineCardinalOpen, + "cardinal-closed": d3_svg_lineCardinalClosed, + monotone: d3_svg_lineMonotone + }); + d3_svg_lineInterpolators.forEach(function(key, value) { + value.key = key; + value.closed = /-closed$/.test(key); + }); + function d3_svg_lineLinear(points) { + return points.join("L"); + } + function d3_svg_lineLinearClosed(points) { + return d3_svg_lineLinear(points) + "Z"; + } + function d3_svg_lineStep(points) { + var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ]; + while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]); + if (n > 1) path.push("H", p[0]); + return path.join(""); + } + function d3_svg_lineStepBefore(points) { + var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ]; + while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]); + return path.join(""); + } + function d3_svg_lineStepAfter(points) { + var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ]; + while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]); + return path.join(""); + } + function d3_svg_lineCardinalOpen(points, tension) { + return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, points.length - 1), d3_svg_lineCardinalTangents(points, tension)); + } + function d3_svg_lineCardinalClosed(points, tension) { + return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), + points), d3_svg_lineCardinalTangents([ points[points.length - 2] ].concat(points, [ points[1] ]), tension)); + } + function d3_svg_lineCardinal(points, tension) { + return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension)); + } + function d3_svg_lineHermite(points, tangents) { + if (tangents.length < 1 || points.length != tangents.length && points.length != tangents.length + 2) { + return d3_svg_lineLinear(points); + } + var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1; + if (quad) { + path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1]; + p0 = points[1]; + pi = 2; + } + if (tangents.length > 1) { + t = tangents[1]; + p = points[pi]; + pi++; + path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1]; + for (var i = 2; i < tangents.length; i++, pi++) { + p = points[pi]; + t = tangents[i]; + path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1]; + } + } + if (quad) { + var lp = points[pi]; + path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1]; + } + return path; + } + function d3_svg_lineCardinalTangents(points, tension) { + var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length; + while (++i < n) { + p0 = p1; + p1 = p2; + p2 = points[i]; + tangents.push([ a * (p2[0] - p0[0]), a * (p2[1] - p0[1]) ]); + } + return tangents; + } + function d3_svg_lineBasis(points) { + if (points.length < 3) return d3_svg_lineLinear(points); + var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ]; + points.push(points[n - 1]); + while (++i <= n) { + pi = points[i]; + px.shift(); + px.push(pi[0]); + py.shift(); + py.push(pi[1]); + d3_svg_lineBasisBezier(path, px, py); + } + points.pop(); + path.push("L", pi); + return path.join(""); + } + function d3_svg_lineBasisOpen(points) { + if (points.length < 4) return d3_svg_lineLinear(points); + var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ]; + while (++i < 3) { + pi = points[i]; + px.push(pi[0]); + py.push(pi[1]); + } + path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)); + --i; + while (++i < n) { + pi = points[i]; + px.shift(); + px.push(pi[0]); + py.shift(); + py.push(pi[1]); + d3_svg_lineBasisBezier(path, px, py); + } + return path.join(""); + } + function d3_svg_lineBasisClosed(points) { + var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = []; + while (++i < 4) { + pi = points[i % n]; + px.push(pi[0]); + py.push(pi[1]); + } + path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ]; + --i; + while (++i < m) { + pi = points[i % n]; + px.shift(); + px.push(pi[0]); + py.shift(); + py.push(pi[1]); + d3_svg_lineBasisBezier(path, px, py); + } + return path.join(""); + } + function d3_svg_lineBundle(points, tension) { + var n = points.length - 1; + if (n) { + var x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t; + while (++i <= n) { + p = points[i]; + t = i / n; + p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx); + p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy); + } + } + return d3_svg_lineBasis(points); + } + function d3_svg_lineDot4(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; + } + var d3_svg_lineBasisBezier1 = [ 0, 2 / 3, 1 / 3, 0 ], d3_svg_lineBasisBezier2 = [ 0, 1 / 3, 2 / 3, 0 ], d3_svg_lineBasisBezier3 = [ 0, 1 / 6, 2 / 3, 1 / 6 ]; + function d3_svg_lineBasisBezier(path, x, y) { + path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y)); + } + function d3_svg_lineSlope(p0, p1) { + return (p1[1] - p0[1]) / (p1[0] - p0[0]); + } + function d3_svg_lineFiniteDifferences(points) { + var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1); + while (++i < j) { + m[i] = (d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]))) / 2; + } + m[i] = d; + return m; + } + function d3_svg_lineMonotoneTangents(points) { + var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1; + while (++i < j) { + d = d3_svg_lineSlope(points[i], points[i + 1]); + if (abs(d) < ε) { + m[i] = m[i + 1] = 0; + } else { + a = m[i] / d; + b = m[i + 1] / d; + s = a * a + b * b; + if (s > 9) { + s = d * 3 / Math.sqrt(s); + m[i] = s * a; + m[i + 1] = s * b; + } + } + } + i = -1; + while (++i <= j) { + s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i])); + tangents.push([ s || 0, m[i] * s || 0 ]); + } + return tangents; + } + function d3_svg_lineMonotone(points) { + return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points)); + } + d3.svg.line.radial = function() { + var line = d3_svg_line(d3_svg_lineRadial); + line.radius = line.x, delete line.x; + line.angle = line.y, delete line.y; + return line; + }; + function d3_svg_lineRadial(points) { + var point, i = -1, n = points.length, r, a; + while (++i < n) { + point = points[i]; + r = point[0]; + a = point[1] + d3_svg_arcOffset; + point[0] = r * Math.cos(a); + point[1] = r * Math.sin(a); + } + return points; + } + function d3_svg_area(projection) { + var x0 = d3_geom_pointX, x1 = d3_geom_pointX, y0 = 0, y1 = d3_geom_pointY, defined = d3_true, interpolate = d3_svg_lineLinear, interpolateKey = interpolate.key, interpolateReverse = interpolate, L = "L", tension = .7; + function area(data) { + var segments = [], points0 = [], points1 = [], i = -1, n = data.length, d, fx0 = d3_functor(x0), fy0 = d3_functor(y0), fx1 = x0 === x1 ? function() { + return x; + } : d3_functor(x1), fy1 = y0 === y1 ? function() { + return y; + } : d3_functor(y1), x, y; + function segment() { + segments.push("M", interpolate(projection(points1), tension), L, interpolateReverse(projection(points0.reverse()), tension), "Z"); + } + while (++i < n) { + if (defined.call(this, d = data[i], i)) { + points0.push([ x = +fx0.call(this, d, i), y = +fy0.call(this, d, i) ]); + points1.push([ +fx1.call(this, d, i), +fy1.call(this, d, i) ]); + } else if (points0.length) { + segment(); + points0 = []; + points1 = []; + } + } + if (points0.length) segment(); + return segments.length ? segments.join("") : null; + } + area.x = function(_) { + if (!arguments.length) return x1; + x0 = x1 = _; + return area; + }; + area.x0 = function(_) { + if (!arguments.length) return x0; + x0 = _; + return area; + }; + area.x1 = function(_) { + if (!arguments.length) return x1; + x1 = _; + return area; + }; + area.y = function(_) { + if (!arguments.length) return y1; + y0 = y1 = _; + return area; + }; + area.y0 = function(_) { + if (!arguments.length) return y0; + y0 = _; + return area; + }; + area.y1 = function(_) { + if (!arguments.length) return y1; + y1 = _; + return area; + }; + area.defined = function(_) { + if (!arguments.length) return defined; + defined = _; + return area; + }; + area.interpolate = function(_) { + if (!arguments.length) return interpolateKey; + if (typeof _ === "function") interpolateKey = interpolate = _; else interpolateKey = (interpolate = d3_svg_lineInterpolators.get(_) || d3_svg_lineLinear).key; + interpolateReverse = interpolate.reverse || interpolate; + L = interpolate.closed ? "M" : "L"; + return area; + }; + area.tension = function(_) { + if (!arguments.length) return tension; + tension = _; + return area; + }; + return area; + } + d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter; + d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore; + d3.svg.area = function() { + return d3_svg_area(d3_identity); + }; + d3.svg.area.radial = function() { + var area = d3_svg_area(d3_svg_lineRadial); + area.radius = area.x, delete area.x; + area.innerRadius = area.x0, delete area.x0; + area.outerRadius = area.x1, delete area.x1; + area.angle = area.y, delete area.y; + area.startAngle = area.y0, delete area.y0; + area.endAngle = area.y1, delete area.y1; + return area; + }; + d3.svg.chord = function() { + var source = d3_source, target = d3_target, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle; + function chord(d, i) { + var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i); + return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z"; + } + function subgroup(self, f, d, i) { + var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) + d3_svg_arcOffset, a1 = endAngle.call(self, subgroup, i) + d3_svg_arcOffset; + return { + r: r, + a0: a0, + a1: a1, + p0: [ r * Math.cos(a0), r * Math.sin(a0) ], + p1: [ r * Math.cos(a1), r * Math.sin(a1) ] + }; + } + function equals(a, b) { + return a.a0 == b.a0 && a.a1 == b.a1; + } + function arc(r, p, a) { + return "A" + r + "," + r + " 0 " + +(a > π) + ",1 " + p; + } + function curve(r0, p0, r1, p1) { + return "Q 0,0 " + p1; + } + chord.radius = function(v) { + if (!arguments.length) return radius; + radius = d3_functor(v); + return chord; + }; + chord.source = function(v) { + if (!arguments.length) return source; + source = d3_functor(v); + return chord; + }; + chord.target = function(v) { + if (!arguments.length) return target; + target = d3_functor(v); + return chord; + }; + chord.startAngle = function(v) { + if (!arguments.length) return startAngle; + startAngle = d3_functor(v); + return chord; + }; + chord.endAngle = function(v) { + if (!arguments.length) return endAngle; + endAngle = d3_functor(v); + return chord; + }; + return chord; + }; + function d3_svg_chordRadius(d) { + return d.radius; + } + d3.svg.diagonal = function() { + var source = d3_source, target = d3_target, projection = d3_svg_diagonalProjection; + function diagonal(d, i) { + var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [ p0, { + x: p0.x, + y: m + }, { + x: p3.x, + y: m + }, p3 ]; + p = p.map(projection); + return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3]; + } + diagonal.source = function(x) { + if (!arguments.length) return source; + source = d3_functor(x); + return diagonal; + }; + diagonal.target = function(x) { + if (!arguments.length) return target; + target = d3_functor(x); + return diagonal; + }; + diagonal.projection = function(x) { + if (!arguments.length) return projection; + projection = x; + return diagonal; + }; + return diagonal; + }; + function d3_svg_diagonalProjection(d) { + return [ d.x, d.y ]; + } + d3.svg.diagonal.radial = function() { + var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection; + diagonal.projection = function(x) { + return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection; + }; + return diagonal; + }; + function d3_svg_diagonalRadialProjection(projection) { + return function() { + var d = projection.apply(this, arguments), r = d[0], a = d[1] + d3_svg_arcOffset; + return [ r * Math.cos(a), r * Math.sin(a) ]; + }; + } + d3.svg.symbol = function() { + var type = d3_svg_symbolType, size = d3_svg_symbolSize; + function symbol(d, i) { + return (d3_svg_symbols.get(type.call(this, d, i)) || d3_svg_symbolCircle)(size.call(this, d, i)); + } + symbol.type = function(x) { + if (!arguments.length) return type; + type = d3_functor(x); + return symbol; + }; + symbol.size = function(x) { + if (!arguments.length) return size; + size = d3_functor(x); + return symbol; + }; + return symbol; + }; + function d3_svg_symbolSize() { + return 64; + } + function d3_svg_symbolType() { + return "circle"; + } + function d3_svg_symbolCircle(size) { + var r = Math.sqrt(size / π); + return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + -r + "A" + r + "," + r + " 0 1,1 0," + r + "Z"; + } + var d3_svg_symbols = d3.map({ + circle: d3_svg_symbolCircle, + cross: function(size) { + var r = Math.sqrt(size / 5) / 2; + return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z"; + }, + diamond: function(size) { + var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30; + return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z"; + }, + square: function(size) { + var r = Math.sqrt(size) / 2; + return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z"; + }, + "triangle-down": function(size) { + var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2; + return "M0," + ry + "L" + rx + "," + -ry + " " + -rx + "," + -ry + "Z"; + }, + "triangle-up": function(size) { + var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2; + return "M0," + -ry + "L" + rx + "," + ry + " " + -rx + "," + ry + "Z"; + } + }); + d3.svg.symbolTypes = d3_svg_symbols.keys(); + var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * d3_radians); + function d3_transition(groups, id) { + d3_subclass(groups, d3_transitionPrototype); + groups.id = id; + return groups; + } + var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId, d3_transitionInherit; + d3_transitionPrototype.call = d3_selectionPrototype.call; + d3_transitionPrototype.empty = d3_selectionPrototype.empty; + d3_transitionPrototype.node = d3_selectionPrototype.node; + d3_transitionPrototype.size = d3_selectionPrototype.size; + d3.transition = function(selection) { + return arguments.length ? d3_transitionInheritId ? selection.transition() : selection : d3_selectionRoot.transition(); + }; + d3.transition.prototype = d3_transitionPrototype; + d3_transitionPrototype.select = function(selector) { + var id = this.id, subgroups = [], subgroup, subnode, node; + selector = d3_selection_selector(selector); + for (var j = -1, m = this.length; ++j < m; ) { + subgroups.push(subgroup = []); + for (var group = this[j], i = -1, n = group.length; ++i < n; ) { + if ((node = group[i]) && (subnode = selector.call(node, node.__data__, i, j))) { + if ("__data__" in node) subnode.__data__ = node.__data__; + d3_transitionNode(subnode, i, id, node.__transition__[id]); + subgroup.push(subnode); + } else { + subgroup.push(null); + } + } + } + return d3_transition(subgroups, id); + }; + d3_transitionPrototype.selectAll = function(selector) { + var id = this.id, subgroups = [], subgroup, subnodes, node, subnode, transition; + selector = d3_selection_selectorAll(selector); + for (var j = -1, m = this.length; ++j < m; ) { + for (var group = this[j], i = -1, n = group.length; ++i < n; ) { + if (node = group[i]) { + transition = node.__transition__[id]; + subnodes = selector.call(node, node.__data__, i, j); + subgroups.push(subgroup = []); + for (var k = -1, o = subnodes.length; ++k < o; ) { + if (subnode = subnodes[k]) d3_transitionNode(subnode, k, id, transition); + subgroup.push(subnode); + } + } + } + } + return d3_transition(subgroups, id); + }; + d3_transitionPrototype.filter = function(filter) { + var subgroups = [], subgroup, group, node; + if (typeof filter !== "function") filter = d3_selection_filter(filter); + for (var j = 0, m = this.length; j < m; j++) { + subgroups.push(subgroup = []); + for (var group = this[j], i = 0, n = group.length; i < n; i++) { + if ((node = group[i]) && filter.call(node, node.__data__, i, j)) { + subgroup.push(node); + } + } + } + return d3_transition(subgroups, this.id); + }; + d3_transitionPrototype.tween = function(name, tween) { + var id = this.id; + if (arguments.length < 2) return this.node().__transition__[id].tween.get(name); + return d3_selection_each(this, tween == null ? function(node) { + node.__transition__[id].tween.remove(name); + } : function(node) { + node.__transition__[id].tween.set(name, tween); + }); + }; + function d3_transition_tween(groups, name, value, tween) { + var id = groups.id; + return d3_selection_each(groups, typeof value === "function" ? function(node, i, j) { + node.__transition__[id].tween.set(name, tween(value.call(node, node.__data__, i, j))); + } : (value = tween(value), function(node) { + node.__transition__[id].tween.set(name, value); + })); + } + d3_transitionPrototype.attr = function(nameNS, value) { + if (arguments.length < 2) { + for (value in nameNS) this.attr(value, nameNS[value]); + return this; + } + var interpolate = nameNS == "transform" ? d3_interpolateTransform : d3_interpolate, name = d3.ns.qualify(nameNS); + function attrNull() { + this.removeAttribute(name); + } + function attrNullNS() { + this.removeAttributeNS(name.space, name.local); + } + function attrTween(b) { + return b == null ? attrNull : (b += "", function() { + var a = this.getAttribute(name), i; + return a !== b && (i = interpolate(a, b), function(t) { + this.setAttribute(name, i(t)); + }); + }); + } + function attrTweenNS(b) { + return b == null ? attrNullNS : (b += "", function() { + var a = this.getAttributeNS(name.space, name.local), i; + return a !== b && (i = interpolate(a, b), function(t) { + this.setAttributeNS(name.space, name.local, i(t)); + }); + }); + } + return d3_transition_tween(this, "attr." + nameNS, value, name.local ? attrTweenNS : attrTween); + }; + d3_transitionPrototype.attrTween = function(nameNS, tween) { + var name = d3.ns.qualify(nameNS); + function attrTween(d, i) { + var f = tween.call(this, d, i, this.getAttribute(name)); + return f && function(t) { + this.setAttribute(name, f(t)); + }; + } + function attrTweenNS(d, i) { + var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local)); + return f && function(t) { + this.setAttributeNS(name.space, name.local, f(t)); + }; + } + return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween); + }; + d3_transitionPrototype.style = function(name, value, priority) { + var n = arguments.length; + if (n < 3) { + if (typeof name !== "string") { + if (n < 2) value = ""; + for (priority in name) this.style(priority, name[priority], value); + return this; + } + priority = ""; + } + function styleNull() { + this.style.removeProperty(name); + } + function styleString(b) { + return b == null ? styleNull : (b += "", function() { + var a = d3_window.getComputedStyle(this, null).getPropertyValue(name), i; + return a !== b && (i = d3_interpolate(a, b), function(t) { + this.style.setProperty(name, i(t), priority); + }); + }); + } + return d3_transition_tween(this, "style." + name, value, styleString); + }; + d3_transitionPrototype.styleTween = function(name, tween, priority) { + if (arguments.length < 3) priority = ""; + function styleTween(d, i) { + var f = tween.call(this, d, i, d3_window.getComputedStyle(this, null).getPropertyValue(name)); + return f && function(t) { + this.style.setProperty(name, f(t), priority); + }; + } + return this.tween("style." + name, styleTween); + }; + d3_transitionPrototype.text = function(value) { + return d3_transition_tween(this, "text", value, d3_transition_text); + }; + function d3_transition_text(b) { + if (b == null) b = ""; + return function() { + this.textContent = b; + }; + } + d3_transitionPrototype.remove = function() { + return this.each("end.transition", function() { + var p; + if (this.__transition__.count < 2 && (p = this.parentNode)) p.removeChild(this); + }); + }; + d3_transitionPrototype.ease = function(value) { + var id = this.id; + if (arguments.length < 1) return this.node().__transition__[id].ease; + if (typeof value !== "function") value = d3.ease.apply(d3, arguments); + return d3_selection_each(this, function(node) { + node.__transition__[id].ease = value; + }); + }; + d3_transitionPrototype.delay = function(value) { + var id = this.id; + if (arguments.length < 1) return this.node().__transition__[id].delay; + return d3_selection_each(this, typeof value === "function" ? function(node, i, j) { + node.__transition__[id].delay = +value.call(node, node.__data__, i, j); + } : (value = +value, function(node) { + node.__transition__[id].delay = value; + })); + }; + d3_transitionPrototype.duration = function(value) { + var id = this.id; + if (arguments.length < 1) return this.node().__transition__[id].duration; + return d3_selection_each(this, typeof value === "function" ? function(node, i, j) { + node.__transition__[id].duration = Math.max(1, value.call(node, node.__data__, i, j)); + } : (value = Math.max(1, value), function(node) { + node.__transition__[id].duration = value; + })); + }; + d3_transitionPrototype.each = function(type, listener) { + var id = this.id; + if (arguments.length < 2) { + var inherit = d3_transitionInherit, inheritId = d3_transitionInheritId; + d3_transitionInheritId = id; + d3_selection_each(this, function(node, i, j) { + d3_transitionInherit = node.__transition__[id]; + type.call(node, node.__data__, i, j); + }); + d3_transitionInherit = inherit; + d3_transitionInheritId = inheritId; + } else { + d3_selection_each(this, function(node) { + var transition = node.__transition__[id]; + (transition.event || (transition.event = d3.dispatch("start", "end"))).on(type, listener); + }); + } + return this; + }; + d3_transitionPrototype.transition = function() { + var id0 = this.id, id1 = ++d3_transitionId, subgroups = [], subgroup, group, node, transition; + for (var j = 0, m = this.length; j < m; j++) { + subgroups.push(subgroup = []); + for (var group = this[j], i = 0, n = group.length; i < n; i++) { + if (node = group[i]) { + transition = Object.create(node.__transition__[id0]); + transition.delay += transition.duration; + d3_transitionNode(node, i, id1, transition); + } + subgroup.push(node); + } + } + return d3_transition(subgroups, id1); + }; + function d3_transitionNode(node, i, id, inherit) { + var lock = node.__transition__ || (node.__transition__ = { + active: 0, + count: 0 + }), transition = lock[id]; + if (!transition) { + var time = inherit.time; + transition = lock[id] = { + tween: new d3_Map(), + time: time, + ease: inherit.ease, + delay: inherit.delay, + duration: inherit.duration + }; + ++lock.count; + d3.timer(function(elapsed) { + var d = node.__data__, ease = transition.ease, delay = transition.delay, duration = transition.duration, timer = d3_timer_active, tweened = []; + timer.t = delay + time; + if (delay <= elapsed) return start(elapsed - delay); + timer.c = start; + function start(elapsed) { + if (lock.active > id) return stop(); + lock.active = id; + transition.event && transition.event.start.call(node, d, i); + transition.tween.forEach(function(key, value) { + if (value = value.call(node, d, i)) { + tweened.push(value); + } + }); + d3.timer(function() { + timer.c = tick(elapsed || 1) ? d3_true : tick; + return 1; + }, 0, time); + } + function tick(elapsed) { + if (lock.active !== id) return stop(); + var t = elapsed / duration, e = ease(t), n = tweened.length; + while (n > 0) { + tweened[--n].call(node, e); + } + if (t >= 1) { + transition.event && transition.event.end.call(node, d, i); + return stop(); + } + } + function stop() { + if (--lock.count) delete lock[id]; else delete node.__transition__; + return 1; + } + }, 0, time); + } + } + d3.svg.axis = function() { + var scale = d3.scale.linear(), orient = d3_svg_axisDefaultOrient, innerTickSize = 6, outerTickSize = 6, tickPadding = 3, tickArguments_ = [ 10 ], tickValues = null, tickFormat_; + function axis(g) { + g.each(function() { + var g = d3.select(this); + var scale0 = this.__chart__ || scale, scale1 = this.__chart__ = scale.copy(); + var ticks = tickValues == null ? scale1.ticks ? scale1.ticks.apply(scale1, tickArguments_) : scale1.domain() : tickValues, tickFormat = tickFormat_ == null ? scale1.tickFormat ? scale1.tickFormat.apply(scale1, tickArguments_) : d3_identity : tickFormat_, tick = g.selectAll(".tick").data(ticks, scale1), tickEnter = tick.enter().insert("g", ".domain").attr("class", "tick").style("opacity", ε), tickExit = d3.transition(tick.exit()).style("opacity", ε).remove(), tickUpdate = d3.transition(tick.order()).style("opacity", 1), tickTransform; + var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"), + d3.transition(path)); + tickEnter.append("line"); + tickEnter.append("text"); + var lineEnter = tickEnter.select("line"), lineUpdate = tickUpdate.select("line"), text = tick.select("text").text(tickFormat), textEnter = tickEnter.select("text"), textUpdate = tickUpdate.select("text"); + switch (orient) { + case "bottom": + { + tickTransform = d3_svg_axisX; + lineEnter.attr("y2", innerTickSize); + textEnter.attr("y", Math.max(innerTickSize, 0) + tickPadding); + lineUpdate.attr("x2", 0).attr("y2", innerTickSize); + textUpdate.attr("x", 0).attr("y", Math.max(innerTickSize, 0) + tickPadding); + text.attr("dy", ".71em").style("text-anchor", "middle"); + pathUpdate.attr("d", "M" + range[0] + "," + outerTickSize + "V0H" + range[1] + "V" + outerTickSize); + break; + } + + case "top": + { + tickTransform = d3_svg_axisX; + lineEnter.attr("y2", -innerTickSize); + textEnter.attr("y", -(Math.max(innerTickSize, 0) + tickPadding)); + lineUpdate.attr("x2", 0).attr("y2", -innerTickSize); + textUpdate.attr("x", 0).attr("y", -(Math.max(innerTickSize, 0) + tickPadding)); + text.attr("dy", "0em").style("text-anchor", "middle"); + pathUpdate.attr("d", "M" + range[0] + "," + -outerTickSize + "V0H" + range[1] + "V" + -outerTickSize); + break; + } + + case "left": + { + tickTransform = d3_svg_axisY; + lineEnter.attr("x2", -innerTickSize); + textEnter.attr("x", -(Math.max(innerTickSize, 0) + tickPadding)); + lineUpdate.attr("x2", -innerTickSize).attr("y2", 0); + textUpdate.attr("x", -(Math.max(innerTickSize, 0) + tickPadding)).attr("y", 0); + text.attr("dy", ".32em").style("text-anchor", "end"); + pathUpdate.attr("d", "M" + -outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + -outerTickSize); + break; + } + + case "right": + { + tickTransform = d3_svg_axisY; + lineEnter.attr("x2", innerTickSize); + textEnter.attr("x", Math.max(innerTickSize, 0) + tickPadding); + lineUpdate.attr("x2", innerTickSize).attr("y2", 0); + textUpdate.attr("x", Math.max(innerTickSize, 0) + tickPadding).attr("y", 0); + text.attr("dy", ".32em").style("text-anchor", "start"); + pathUpdate.attr("d", "M" + outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + outerTickSize); + break; + } + } + if (scale1.rangeBand) { + var x = scale1, dx = x.rangeBand() / 2; + scale0 = scale1 = function(d) { + return x(d) + dx; + }; + } else if (scale0.rangeBand) { + scale0 = scale1; + } else { + tickExit.call(tickTransform, scale1); + } + tickEnter.call(tickTransform, scale0); + tickUpdate.call(tickTransform, scale1); + }); + } + axis.scale = function(x) { + if (!arguments.length) return scale; + scale = x; + return axis; + }; + axis.orient = function(x) { + if (!arguments.length) return orient; + orient = x in d3_svg_axisOrients ? x + "" : d3_svg_axisDefaultOrient; + return axis; + }; + axis.ticks = function() { + if (!arguments.length) return tickArguments_; + tickArguments_ = arguments; + return axis; + }; + axis.tickValues = function(x) { + if (!arguments.length) return tickValues; + tickValues = x; + return axis; + }; + axis.tickFormat = function(x) { + if (!arguments.length) return tickFormat_; + tickFormat_ = x; + return axis; + }; + axis.tickSize = function(x) { + var n = arguments.length; + if (!n) return innerTickSize; + innerTickSize = +x; + outerTickSize = +arguments[n - 1]; + return axis; + }; + axis.innerTickSize = function(x) { + if (!arguments.length) return innerTickSize; + innerTickSize = +x; + return axis; + }; + axis.outerTickSize = function(x) { + if (!arguments.length) return outerTickSize; + outerTickSize = +x; + return axis; + }; + axis.tickPadding = function(x) { + if (!arguments.length) return tickPadding; + tickPadding = +x; + return axis; + }; + axis.tickSubdivide = function() { + return arguments.length && axis; + }; + return axis; + }; + var d3_svg_axisDefaultOrient = "bottom", d3_svg_axisOrients = { + top: 1, + right: 1, + bottom: 1, + left: 1 + }; + function d3_svg_axisX(selection, x) { + selection.attr("transform", function(d) { + return "translate(" + x(d) + ",0)"; + }); + } + function d3_svg_axisY(selection, y) { + selection.attr("transform", function(d) { + return "translate(0," + y(d) + ")"; + }); + } + d3.svg.brush = function() { + var event = d3_eventDispatch(brush, "brushstart", "brush", "brushend"), x = null, y = null, xExtent = [ 0, 0 ], yExtent = [ 0, 0 ], xExtentDomain, yExtentDomain, xClamp = true, yClamp = true, resizes = d3_svg_brushResizes[0]; + function brush(g) { + g.each(function() { + var g = d3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", brushstart).on("touchstart.brush", brushstart); + var background = g.selectAll(".background").data([ 0 ]); + background.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair"); + g.selectAll(".extent").data([ 0 ]).enter().append("rect").attr("class", "extent").style("cursor", "move"); + var resize = g.selectAll(".resize").data(resizes, d3_identity); + resize.exit().remove(); + resize.enter().append("g").attr("class", function(d) { + return "resize " + d; + }).style("cursor", function(d) { + return d3_svg_brushCursor[d]; + }).append("rect").attr("x", function(d) { + return /[ew]$/.test(d) ? -3 : null; + }).attr("y", function(d) { + return /^[ns]/.test(d) ? -3 : null; + }).attr("width", 6).attr("height", 6).style("visibility", "hidden"); + resize.style("display", brush.empty() ? "none" : null); + var gUpdate = d3.transition(g), backgroundUpdate = d3.transition(background), range; + if (x) { + range = d3_scaleRange(x); + backgroundUpdate.attr("x", range[0]).attr("width", range[1] - range[0]); + redrawX(gUpdate); + } + if (y) { + range = d3_scaleRange(y); + backgroundUpdate.attr("y", range[0]).attr("height", range[1] - range[0]); + redrawY(gUpdate); + } + redraw(gUpdate); + }); + } + brush.event = function(g) { + g.each(function() { + var event_ = event.of(this, arguments), extent1 = { + x: xExtent, + y: yExtent, + i: xExtentDomain, + j: yExtentDomain + }, extent0 = this.__chart__ || extent1; + this.__chart__ = extent1; + if (d3_transitionInheritId) { + d3.select(this).transition().each("start.brush", function() { + xExtentDomain = extent0.i; + yExtentDomain = extent0.j; + xExtent = extent0.x; + yExtent = extent0.y; + event_({ + type: "brushstart" + }); + }).tween("brush:brush", function() { + var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y); + xExtentDomain = yExtentDomain = null; + return function(t) { + xExtent = extent1.x = xi(t); + yExtent = extent1.y = yi(t); + event_({ + type: "brush", + mode: "resize" + }); + }; + }).each("end.brush", function() { + xExtentDomain = extent1.i; + yExtentDomain = extent1.j; + event_({ + type: "brush", + mode: "resize" + }); + event_({ + type: "brushend" + }); + }); + } else { + event_({ + type: "brushstart" + }); + event_({ + type: "brush", + mode: "resize" + }); + event_({ + type: "brushend" + }); + } + }); + }; + function redraw(g) { + g.selectAll(".resize").attr("transform", function(d) { + return "translate(" + xExtent[+/e$/.test(d)] + "," + yExtent[+/^s/.test(d)] + ")"; + }); + } + function redrawX(g) { + g.select(".extent").attr("x", xExtent[0]); + g.selectAll(".extent,.n>rect,.s>rect").attr("width", xExtent[1] - xExtent[0]); + } + function redrawY(g) { + g.select(".extent").attr("y", yExtent[0]); + g.selectAll(".extent,.e>rect,.w>rect").attr("height", yExtent[1] - yExtent[0]); + } + function brushstart() { + var target = this, eventTarget = d3.select(d3.event.target), event_ = event.of(target, arguments), g = d3.select(target), resizing = eventTarget.datum(), resizingX = !/^(n|s)$/.test(resizing) && x, resizingY = !/^(e|w)$/.test(resizing) && y, dragging = eventTarget.classed("extent"), dragRestore = d3_event_dragSuppress(), center, origin = d3.mouse(target), offset; + var w = d3.select(d3_window).on("keydown.brush", keydown).on("keyup.brush", keyup); + if (d3.event.changedTouches) { + w.on("touchmove.brush", brushmove).on("touchend.brush", brushend); + } else { + w.on("mousemove.brush", brushmove).on("mouseup.brush", brushend); + } + g.interrupt().selectAll("*").interrupt(); + if (dragging) { + origin[0] = xExtent[0] - origin[0]; + origin[1] = yExtent[0] - origin[1]; + } else if (resizing) { + var ex = +/w$/.test(resizing), ey = +/^n/.test(resizing); + offset = [ xExtent[1 - ex] - origin[0], yExtent[1 - ey] - origin[1] ]; + origin[0] = xExtent[ex]; + origin[1] = yExtent[ey]; + } else if (d3.event.altKey) center = origin.slice(); + g.style("pointer-events", "none").selectAll(".resize").style("display", null); + d3.select("body").style("cursor", eventTarget.style("cursor")); + event_({ + type: "brushstart" + }); + brushmove(); + function keydown() { + if (d3.event.keyCode == 32) { + if (!dragging) { + center = null; + origin[0] -= xExtent[1]; + origin[1] -= yExtent[1]; + dragging = 2; + } + d3_eventPreventDefault(); + } + } + function keyup() { + if (d3.event.keyCode == 32 && dragging == 2) { + origin[0] += xExtent[1]; + origin[1] += yExtent[1]; + dragging = 0; + d3_eventPreventDefault(); + } + } + function brushmove() { + var point = d3.mouse(target), moved = false; + if (offset) { + point[0] += offset[0]; + point[1] += offset[1]; + } + if (!dragging) { + if (d3.event.altKey) { + if (!center) center = [ (xExtent[0] + xExtent[1]) / 2, (yExtent[0] + yExtent[1]) / 2 ]; + origin[0] = xExtent[+(point[0] < center[0])]; + origin[1] = yExtent[+(point[1] < center[1])]; + } else center = null; + } + if (resizingX && move1(point, x, 0)) { + redrawX(g); + moved = true; + } + if (resizingY && move1(point, y, 1)) { + redrawY(g); + moved = true; + } + if (moved) { + redraw(g); + event_({ + type: "brush", + mode: dragging ? "move" : "resize" + }); + } + } + function move1(point, scale, i) { + var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], position = origin[i], extent = i ? yExtent : xExtent, size = extent[1] - extent[0], min, max; + if (dragging) { + r0 -= position; + r1 -= size + position; + } + min = (i ? yClamp : xClamp) ? Math.max(r0, Math.min(r1, point[i])) : point[i]; + if (dragging) { + max = (min += position) + size; + } else { + if (center) position = Math.max(r0, Math.min(r1, 2 * center[i] - min)); + if (position < min) { + max = min; + min = position; + } else { + max = position; + } + } + if (extent[0] != min || extent[1] != max) { + if (i) yExtentDomain = null; else xExtentDomain = null; + extent[0] = min; + extent[1] = max; + return true; + } + } + function brushend() { + brushmove(); + g.style("pointer-events", "all").selectAll(".resize").style("display", brush.empty() ? "none" : null); + d3.select("body").style("cursor", null); + w.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null); + dragRestore(); + event_({ + type: "brushend" + }); + } + } + brush.x = function(z) { + if (!arguments.length) return x; + x = z; + resizes = d3_svg_brushResizes[!x << 1 | !y]; + return brush; + }; + brush.y = function(z) { + if (!arguments.length) return y; + y = z; + resizes = d3_svg_brushResizes[!x << 1 | !y]; + return brush; + }; + brush.clamp = function(z) { + if (!arguments.length) return x && y ? [ xClamp, yClamp ] : x ? xClamp : y ? yClamp : null; + if (x && y) xClamp = !!z[0], yClamp = !!z[1]; else if (x) xClamp = !!z; else if (y) yClamp = !!z; + return brush; + }; + brush.extent = function(z) { + var x0, x1, y0, y1, t; + if (!arguments.length) { + if (x) { + if (xExtentDomain) { + x0 = xExtentDomain[0], x1 = xExtentDomain[1]; + } else { + x0 = xExtent[0], x1 = xExtent[1]; + if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1); + if (x1 < x0) t = x0, x0 = x1, x1 = t; + } + } + if (y) { + if (yExtentDomain) { + y0 = yExtentDomain[0], y1 = yExtentDomain[1]; + } else { + y0 = yExtent[0], y1 = yExtent[1]; + if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1); + if (y1 < y0) t = y0, y0 = y1, y1 = t; + } + } + return x && y ? [ [ x0, y0 ], [ x1, y1 ] ] : x ? [ x0, x1 ] : y && [ y0, y1 ]; + } + if (x) { + x0 = z[0], x1 = z[1]; + if (y) x0 = x0[0], x1 = x1[0]; + xExtentDomain = [ x0, x1 ]; + if (x.invert) x0 = x(x0), x1 = x(x1); + if (x1 < x0) t = x0, x0 = x1, x1 = t; + if (x0 != xExtent[0] || x1 != xExtent[1]) xExtent = [ x0, x1 ]; + } + if (y) { + y0 = z[0], y1 = z[1]; + if (x) y0 = y0[1], y1 = y1[1]; + yExtentDomain = [ y0, y1 ]; + if (y.invert) y0 = y(y0), y1 = y(y1); + if (y1 < y0) t = y0, y0 = y1, y1 = t; + if (y0 != yExtent[0] || y1 != yExtent[1]) yExtent = [ y0, y1 ]; + } + return brush; + }; + brush.clear = function() { + if (!brush.empty()) { + xExtent = [ 0, 0 ], yExtent = [ 0, 0 ]; + xExtentDomain = yExtentDomain = null; + } + return brush; + }; + brush.empty = function() { + return !!x && xExtent[0] == xExtent[1] || !!y && yExtent[0] == yExtent[1]; + }; + return d3.rebind(brush, event, "on"); + }; + var d3_svg_brushCursor = { + n: "ns-resize", + e: "ew-resize", + s: "ns-resize", + w: "ew-resize", + nw: "nwse-resize", + ne: "nesw-resize", + se: "nwse-resize", + sw: "nesw-resize" + }; + var d3_svg_brushResizes = [ [ "n", "e", "s", "w", "nw", "ne", "se", "sw" ], [ "e", "w" ], [ "n", "s" ], [] ]; + var d3_time_format = d3_time.format = d3_locale_enUS.timeFormat; + var d3_time_formatUtc = d3_time_format.utc; + var d3_time_formatIso = d3_time_formatUtc("%Y-%m-%dT%H:%M:%S.%LZ"); + d3_time_format.iso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z") ? d3_time_formatIsoNative : d3_time_formatIso; + function d3_time_formatIsoNative(date) { + return date.toISOString(); + } + d3_time_formatIsoNative.parse = function(string) { + var date = new Date(string); + return isNaN(date) ? null : date; + }; + d3_time_formatIsoNative.toString = d3_time_formatIso.toString; + d3_time.second = d3_time_interval(function(date) { + return new d3_date(Math.floor(date / 1e3) * 1e3); + }, function(date, offset) { + date.setTime(date.getTime() + Math.floor(offset) * 1e3); + }, function(date) { + return date.getSeconds(); + }); + d3_time.seconds = d3_time.second.range; + d3_time.seconds.utc = d3_time.second.utc.range; + d3_time.minute = d3_time_interval(function(date) { + return new d3_date(Math.floor(date / 6e4) * 6e4); + }, function(date, offset) { + date.setTime(date.getTime() + Math.floor(offset) * 6e4); + }, function(date) { + return date.getMinutes(); + }); + d3_time.minutes = d3_time.minute.range; + d3_time.minutes.utc = d3_time.minute.utc.range; + d3_time.hour = d3_time_interval(function(date) { + var timezone = date.getTimezoneOffset() / 60; + return new d3_date((Math.floor(date / 36e5 - timezone) + timezone) * 36e5); + }, function(date, offset) { + date.setTime(date.getTime() + Math.floor(offset) * 36e5); + }, function(date) { + return date.getHours(); + }); + d3_time.hours = d3_time.hour.range; + d3_time.hours.utc = d3_time.hour.utc.range; + d3_time.month = d3_time_interval(function(date) { + date = d3_time.day(date); + date.setDate(1); + return date; + }, function(date, offset) { + date.setMonth(date.getMonth() + offset); + }, function(date) { + return date.getMonth(); + }); + d3_time.months = d3_time.month.range; + d3_time.months.utc = d3_time.month.utc.range; + function d3_time_scale(linear, methods, format) { + function scale(x) { + return linear(x); + } + scale.invert = function(x) { + return d3_time_scaleDate(linear.invert(x)); + }; + scale.domain = function(x) { + if (!arguments.length) return linear.domain().map(d3_time_scaleDate); + linear.domain(x); + return scale; + }; + function tickMethod(extent, count) { + var span = extent[1] - extent[0], target = span / count, i = d3.bisect(d3_time_scaleSteps, target); + return i == d3_time_scaleSteps.length ? [ methods.year, d3_scale_linearTickRange(extent.map(function(d) { + return d / 31536e6; + }), count)[2] ] : !i ? [ d3_time_scaleMilliseconds, d3_scale_linearTickRange(extent, count)[2] ] : methods[target / d3_time_scaleSteps[i - 1] < d3_time_scaleSteps[i] / target ? i - 1 : i]; + } + scale.nice = function(interval, skip) { + var domain = scale.domain(), extent = d3_scaleExtent(domain), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" && tickMethod(extent, interval); + if (method) interval = method[0], skip = method[1]; + function skipped(date) { + return !isNaN(date) && !interval.range(date, d3_time_scaleDate(+date + 1), skip).length; + } + return scale.domain(d3_scale_nice(domain, skip > 1 ? { + floor: function(date) { + while (skipped(date = interval.floor(date))) date = d3_time_scaleDate(date - 1); + return date; + }, + ceil: function(date) { + while (skipped(date = interval.ceil(date))) date = d3_time_scaleDate(+date + 1); + return date; + } + } : interval)); + }; + scale.ticks = function(interval, skip) { + var extent = d3_scaleExtent(scale.domain()), method = interval == null ? tickMethod(extent, 10) : typeof interval === "number" ? tickMethod(extent, interval) : !interval.range && [ { + range: interval + }, skip ]; + if (method) interval = method[0], skip = method[1]; + return interval.range(extent[0], d3_time_scaleDate(+extent[1] + 1), skip < 1 ? 1 : skip); + }; + scale.tickFormat = function() { + return format; + }; + scale.copy = function() { + return d3_time_scale(linear.copy(), methods, format); + }; + return d3_scale_linearRebind(scale, linear); + } + function d3_time_scaleDate(t) { + return new Date(t); + } + var d3_time_scaleSteps = [ 1e3, 5e3, 15e3, 3e4, 6e4, 3e5, 9e5, 18e5, 36e5, 108e5, 216e5, 432e5, 864e5, 1728e5, 6048e5, 2592e6, 7776e6, 31536e6 ]; + var d3_time_scaleLocalMethods = [ [ d3_time.second, 1 ], [ d3_time.second, 5 ], [ d3_time.second, 15 ], [ d3_time.second, 30 ], [ d3_time.minute, 1 ], [ d3_time.minute, 5 ], [ d3_time.minute, 15 ], [ d3_time.minute, 30 ], [ d3_time.hour, 1 ], [ d3_time.hour, 3 ], [ d3_time.hour, 6 ], [ d3_time.hour, 12 ], [ d3_time.day, 1 ], [ d3_time.day, 2 ], [ d3_time.week, 1 ], [ d3_time.month, 1 ], [ d3_time.month, 3 ], [ d3_time.year, 1 ] ]; + var d3_time_scaleLocalFormat = d3_time_format.multi([ [ ".%L", function(d) { + return d.getMilliseconds(); + } ], [ ":%S", function(d) { + return d.getSeconds(); + } ], [ "%I:%M", function(d) { + return d.getMinutes(); + } ], [ "%I %p", function(d) { + return d.getHours(); + } ], [ "%a %d", function(d) { + return d.getDay() && d.getDate() != 1; + } ], [ "%b %d", function(d) { + return d.getDate() != 1; + } ], [ "%B", function(d) { + return d.getMonth(); + } ], [ "%Y", d3_true ] ]); + var d3_time_scaleMilliseconds = { + range: function(start, stop, step) { + return d3.range(Math.ceil(start / step) * step, +stop, step).map(d3_time_scaleDate); + }, + floor: d3_identity, + ceil: d3_identity + }; + d3_time_scaleLocalMethods.year = d3_time.year; + d3_time.scale = function() { + return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat); + }; + var d3_time_scaleUtcMethods = d3_time_scaleLocalMethods.map(function(m) { + return [ m[0].utc, m[1] ]; + }); + var d3_time_scaleUtcFormat = d3_time_formatUtc.multi([ [ ".%L", function(d) { + return d.getUTCMilliseconds(); + } ], [ ":%S", function(d) { + return d.getUTCSeconds(); + } ], [ "%I:%M", function(d) { + return d.getUTCMinutes(); + } ], [ "%I %p", function(d) { + return d.getUTCHours(); + } ], [ "%a %d", function(d) { + return d.getUTCDay() && d.getUTCDate() != 1; + } ], [ "%b %d", function(d) { + return d.getUTCDate() != 1; + } ], [ "%B", function(d) { + return d.getUTCMonth(); + } ], [ "%Y", d3_true ] ]); + d3_time_scaleUtcMethods.year = d3_time.year.utc; + d3_time.scale.utc = function() { + return d3_time_scale(d3.scale.linear(), d3_time_scaleUtcMethods, d3_time_scaleUtcFormat); + }; + d3.text = d3_xhrType(function(request) { + return request.responseText; + }); + d3.json = function(url, callback) { + return d3_xhr(url, "application/json", d3_json, callback); + }; + function d3_json(request) { + return JSON.parse(request.responseText); + } + d3.html = function(url, callback) { + return d3_xhr(url, "text/html", d3_html, callback); + }; + function d3_html(request) { + var range = d3_document.createRange(); + range.selectNode(d3_document.body); + return range.createContextualFragment(request.responseText); + } + d3.xml = d3_xhrType(function(request) { + return request.responseXML; + }); + if (typeof define === "function" && define.amd) { + define(d3); + } else if (typeof module === "object" && module.exports) { + module.exports = d3; + } else { + this.d3 = d3; + } +}(); diff --git a/seminar4/hello/graph.json b/seminar4/hello/graph.json new file mode 100644 index 0000000..629cb59 --- /dev/null +++ b/seminar4/hello/graph.json @@ -0,0 +1,16 @@ +[ + { + "group": 1, + "imports": [], + "name": "0_a_x_b", + "size": 1 + }, + { + "group": 1, + "imports": [ + "0_a_x_b" + ], + "name": "1_a_plus_b", + "size": 1 + } +] \ No newline at end of file diff --git a/seminar4/hello/graph1.json b/seminar4/hello/graph1.json new file mode 100644 index 0000000..5abcd16 --- /dev/null +++ b/seminar4/hello/graph1.json @@ -0,0 +1,34 @@ +{ + "groups": [ + { + "name": "Group_00001", + "procs": [ + 0, + 1 + ], + "total": 2 + } + ], + "links": [ + { + "source": 0, + "target": 1, + "value": 1 + } + ], + "maxN": 2, + "nodes": [ + { + "group": 1, + "name": "0_a_x_b", + "report": "/tmp/tmpwd77m2ma/a_x_b/_report/report.rst", + "result": "/tmp/tmpwd77m2ma/a_x_b/result_a_x_b.pklz" + }, + { + "group": 1, + "name": "1_a_plus_b", + "report": "/tmp/tmp84s7w8vu/hello/a_plus_b/_report/report.rst", + "result": "/tmp/tmp84s7w8vu/hello/a_plus_b/result_a_plus_b.pklz" + } + ] +} \ No newline at end of file diff --git a/seminar4/hello/index.html b/seminar4/hello/index.html new file mode 100644 index 0000000..3fb66b4 --- /dev/null +++ b/seminar4/hello/index.html @@ -0,0 +1,264 @@ + + + + + + + + +

+ Flare imports
+ hierarchical edge bundling +

+
tension: +
+ + + + + diff --git a/seminar4/preprocessing.ipynb b/seminar4/preprocessing.ipynb new file mode 100644 index 0000000..66160dd --- /dev/null +++ b/seminar4/preprocessing.ipynb @@ -0,0 +1,2630 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# fMRI data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adasegroup/NEUROML2020/blob/seminar4/seminar-4/preprocessing.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "fMRI scans are saved in dicom format. For scientific analysis of brain images the nifty format (.nii files) are often used.\n", + "The conversion from dicom to nifty can be done with [dcm2niix](https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#Introduction) \n", + "\n", + "Many file are generated during fMRI sessions. These can arranged in many ways, thus a standard is needed how to arrange them. \n", + "Commonly used standard is [Brain Imaging Data Structure (BIDS)](https://bids.neuroimaging.io/).\n", + "\n", + "You can use [HeuDiConv](https://heudiconv.readthedocs.io/en/latest/) or [Dcm2Bids](https://cbedetti.github.io/Dcm2Bids/tutorial/) to automate the conversion from dicom to BIDS.\n", + "\n", + "![DICOM TO BIDS](https://www.incf.org/sites/default/files/articles/bids_standard-2.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's download the data we will be working with." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "action summary:\n", + " get (notneeded: 31)\n" + ] + } + ], + "source": [ + "%%bash\n", + "datalad get -J 4 -d /data/ds000114 \\\n", + " /data/ds000114/derivatives/fmriprep/sub-*/anat/*preproc.nii.gz \\\n", + " /data/ds000114/sub-*/ses-test/func/*fingerfootlips*" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ses-retest/\n", + " dwi/\n", + " sub-01_ses-retest_dwi.nii.gz\n", + " anat/\n", + " sub-01_ses-retest_T1w.nii.gz\n", + " func/\n", + " sub-01_ses-retest_task-overtverbgeneration_bold.nii.gz\n", + " sub-01_ses-retest_task-covertverbgeneration_bold.nii.gz\n", + " sub-01_ses-retest_task-linebisection_bold.nii.gz\n", + " sub-01_ses-retest_task-fingerfootlips_bold.nii.gz\n", + " sub-01_ses-retest_task-overtwordrepetition_bold.nii.gz\n", + " sub-01_ses-retest_task-linebisection_events.tsv\n" + ] + } + ], + "source": [ + "from utils import list_files\n", + "# The data is already in BIDS format\n", + "# The subjects peformed 5 tasks. We will focus on fingerfootlips task\n", + "list_files('/data/ds000114/sub-01/ses-retest')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz float32 [256, 156, 256] 1.00x1.30x1.00 sform\n", + "sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz int16 [ 64, 64, 30, 184] 4.00x4.00x4.00x2.50 sform\n", + "\n" + ] + } + ], + "source": [ + "%%bash\n", + "cd /data/ds000114/\n", + "nib-ls derivatives/fmriprep/sub-01/*/*t1w_preproc.nii.gz sub-01/ses-test/f*/*fingerfootlips*.nii.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With nibabel we can load a file and inspect its properties." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import nibabel\n", + "from nilearn import plotting\n", + "import numpy as np\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", + "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " object, endian='<'\n", + "sizeof_hdr : 348\n", + "data_type : b''\n", + "db_name : b''\n", + "extents : 0\n", + "session_error : 0\n", + "regular : b'r'\n", + "dim_info : 0\n", + "dim : [ 3 256 156 256 1 1 1 1]\n", + "intent_p1 : 0.0\n", + "intent_p2 : 0.0\n", + "intent_p3 : 0.0\n", + "intent_code : none\n", + "datatype : float32\n", + "bitpix : 32\n", + "slice_start : 0\n", + "pixdim : [1. 1. 1.2994729 1. 0. 0. 0.\n", + " 0. ]\n", + "vox_offset : 0.0\n", + "scl_slope : nan\n", + "scl_inter : nan\n", + "slice_end : 0\n", + "slice_code : unknown\n", + "xyzt_units : 2\n", + "cal_max : 0.0\n", + "cal_min : 0.0\n", + "slice_duration : 0.0\n", + "toffset : 0.0\n", + "glmax : 0\n", + "glmin : 0\n", + "descrip : b''\n", + "aux_file : b''\n", + "qform_code : aligned\n", + "sform_code : scanner\n", + "quatern_b : 0.013521198\n", + "quatern_c : 0.004525696\n", + "quatern_d : 0.019705506\n", + "qoffset_x : -127.31702\n", + "qoffset_y : -80.335\n", + "qoffset_z : -138.21323\n", + "srow_x : [ 9.9918246e-01 -5.1039357e-02 9.5815985e-03 -1.2731702e+02]\n", + "srow_y : [ 3.9521739e-02 1.2979885e+00 -2.6856035e-02 -8.0334999e+01]\n", + "srow_z : [-8.5158302e-03 3.5362244e-02 9.9959338e-01 -1.3821323e+02]\n", + "intent_name : b''\n", + "magic : b'n+1'\n" + ] + } + ], + "source": [ + "print(anat.header)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anatomical dimensionality is 3 and fmri is 4\n", + "Anatomical voxelization:(256, 156, 256) fMRI voxelization:(64, 64, 30, 184)\n" + ] + } + ], + "source": [ + "print(f'Anatomical dimensionality is {anat.ndim} and fmri is {fmri.ndim}')\n", + "#The anatomical image have higher resolution then the fmri\n", + "print(f'Anatomical voxelization:{anat.shape} fMRI voxelization:{fmri.shape}')\n", + "#the data can be accessed as\n", + "data = np.array(anat.dataobj)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'EchoTime': 0.05,\n", + " 'FlipAngle': 90,\n", + " 'RepetitionTime': 2.5,\n", + " 'SliceTiming': [0.0,\n", + " 1.2499999999999998,\n", + " 0.08333333333333333,\n", + " 1.333333333333333,\n", + " 0.16666666666666666,\n", + " 1.4166666666666663,\n", + " 0.25,\n", + " 1.4999999999999996,\n", + " 0.3333333333333333,\n", + " 1.5833333333333328,\n", + " 0.41666666666666663,\n", + " 1.666666666666666,\n", + " 0.5,\n", + " 1.7499999999999993,\n", + " 0.5833333333333333,\n", + " 1.8333333333333326,\n", + " 0.6666666666666666,\n", + " 1.9166666666666659,\n", + " 0.75,\n", + " 1.9999999999999991,\n", + " 0.8333333333333333,\n", + " 2.083333333333332,\n", + " 0.9166666666666666,\n", + " 2.1666666666666656,\n", + " 1.0,\n", + " 2.249999999999999,\n", + " 1.0833333333333333,\n", + " 2.333333333333332,\n", + " 1.1666666666666665,\n", + " 2.416666666666665],\n", + " 'TaskName': 'finger_foot_lips'}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "\n", + "#metadata is located in json files\n", + "with open('/data/ds000114/task-fingerfootlips_bold.json', 'rt') as fp:\n", + " task_info = json.load(fp)\n", + "task_info" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "30" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(task_info['SliceTiming'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction Nipype" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Why nipype?**\n", + "\n", + "Nipype allows to build preprocessing pipelines from different softwares, and it is computationally efficient. There are some helpful ready to use pipleines written with Nipype like [fmriprep](https://fmriprep.org/en/stable/index.html). To use fmriprep the data have to be in valid BIDS format. The user have to supply only the path to the data setup the [parametars](https://fmriprep.org/en/stable/usage.html#command-line-arguments). \n", + "\n", + "In Nipype, interfaces are python modules that allow you to use various external packages (e.g. FSL, SPM or FreeSurfer), even if they themselves are written in another programming language than python. Such an interface knows what sort of options an external program has and how to execute it.\n", + "\n", + "![Nipype architecture](https://raw.github.com/satra/intro2nipype/master/images/arch.png)\n", + "\n", + "In Nipype, a node is an object that executes a certain function. This function can be anything from a Nipype interface to a user-specified function or an external script. Each node consists of a name, an interface category and at least one input field, and at least one output field.\n", + "\n", + "\n", + "Once you connect multiple nodes to each other, you create a directed graph. In Nipype we call such graphs either workflows or pipelines. Directed connections can only be established from an output field of a node to an input field of another node." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200921-08:13:41,623 nipype.utils WARNING:\n", + "\t A newer version (1.5.1) of nipy/nipype is available. You are using 1.5.0-rc1.post-dev\n", + "200921-08:13:41,629 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"a_x_b\" in \"/tmp/tmpwd77m2ma/a_x_b\".\n", + "200921-08:13:41,632 nipype.workflow INFO:\n", + "\t [Node] Running \"a_x_b\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "200921-08:13:41,638 nipype.workflow INFO:\n", + "\t [Node] Finished \"a_x_b\".\n" + ] + }, + { + "data": { + "text/plain": [ + "\n", + "multiply_result = 6" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nipype import Node, Function, Workflow\n", + "from IPython.display import Image, clear_output\n", + "\n", + "\n", + "def multiply(a, b):\n", + " return a * b\n", + "\n", + "#Create a Node that multiplies 2 numbers\n", + "mul = Node(Function(input_names=['a', 'b'],\n", + " output_names=['multiply_result'],\n", + " function=multiply), \n", + " name='a_x_b')\n", + "\n", + "mul.inputs.a = 2\n", + "mul.inputs.b = 3\n", + "\n", + "result = mul.run()\n", + "result.outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgcAAAD1CAIAAABLBsFXAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3deVgT1/oH8JMoiKwXCJsCRS3S6q24VhDBp1W0ilARAmLF2Iosbpja3udxqVfqY7G1FcG2WhUXCi1rK6LeooitgiDUSq0iYhVEFBWF5IrYGCC/P+Z3k5RADNkmCd/PX8mZM2feiZI3Z87MOQyRSEQAAAAIIYQw6Q4AAAB0CLICAABIICsAAIAEsgIAAEgMlH5TX1+/bt26zs5OuqIB6D+cnZ137NhBdxQA3f2tr1BRUZGZmUlXKN2UlZWVlZXRHYWW5OTk3Llzh+4oQHvu3LmTlJREdxQAPRgoW5Sdna39OGSFhYURnQlG0xgMBpfLpU4Z+oPs7Ozw8HC6owDoAcYVAABAAlkBAAAkkBUAAEACWQEAACR6GG2GPmEwGNQLzCgFAAYAfQVVIRkAgCFBVgAAAAlkBQAAkEBWAAAACQPJCkVFRUFBQdbW1iYmJuPHj1d83g6GFKpk27Zt3UoU1NDQEBwcbGVlZW5uHhAQcO3atb6dAwCADjCQrODv7z9gwIAbN27U1tayWKyIiIjCwkJFdhSJRHv37iWEDBo0qKKighAyb948e3v7s2fP9nUYOTo6msvlNjY25ufn//bbbz4+PvX19X0/FQAAOhlIViCEJCUlsVgsV1fXlJQUQsjWrVsV3HHZsmVxcXECgWD+/PnV1dWBgYGfffaZr69vXwOIjY318/OzsLCYPn36tm3bWltbN2/e3NdGAADoZSBZQSQSubm5Ua/d3d0JIdXV1Yrvnpyc7Ofnd/fu3bFjx7LZbA6Ho0QM0olkxowZhJCTJ08q0Y5eO378+Ntvv+3o6GhsbOzo6BgYGHjkyBHpCgwZ8re+kHbPD8DwGUJW4PF469evf/XVVy0sLBgMxsCBAwkhjx8/VrwFIyOj7OzswYMHd3Z2RkZGKheGra2t+DWLxSKENDc3K9eUPhIKhYsWLXrnnXfefPPNysrKtra2ysrK6dOnczickJCQZ8+eUdVEIpH40pz0624l3V7I7iW7LwCohSFkhbCwsMTExPDw8Nu3byv9ZbFz584BAwZ0dXWFhoY+ffpUiRb4fL749aNHjwghdnZ2SrSjp1atWpWdnV1UVBQfH+/i4mJsbOzi4rJmzZqTJ08ePXo0Ojqa7gABQCGGkBVKS0sJIWvXrrWxsSGECASCvrZw+PDh3Nzc6urq0aNHV1dXx8TEKBGG9BpBRUVFhJCZM2cq0Y4+unDhwjfffLNkyZKJEyd22zR58uTFixenp6efO3eur82+MMGjuwCgdoaQFagL+omJiTwer6WlZf369X3a/ezZs//6178KCgpcXFxycnLMzMwyMjJ2797d1zASExPPnz/f1tZWXFy8bt06a2vr/jPavGfPHkJIaGhoj1vZbDYhZN++fVqNCQCUYghZIS0tLTIyMjU11cHBYdq0aZMnT6bKFRmKZDAY06ZNe/jw4caNG6uqqkaNGkVdPlq+fLmCI5niart3705ISHBycgoKCho7dmxpaal4ANzgUf2A1157rcetY8aMIf/r0gGAjjOEOVPt7e3T0tKkSxRf6lJ2tLOvR5feRcGHJAzPvXv3yN/H26VR5U1NTVqNCQCUYgh9BdBxVHcKd5EC6AVkBVADJycnQkhLS0uPW6k7soYMGSIuYTKZhJDOzk7Zyp2dndRWAKCF4f/5qfgMFB6hUgQ14H/58uUet1Llfn5+4hILCwvy93t5xVpbWy0tLTUSJQAowPCzgkguTe/eT8TGxhJC8vLyetyak5MjrkPx8PAghFy5ckW28pUrV0aOHKmRKAFAAYafFUALvLy8YmJiDh48+Ouvv3bbdOHChbS0tJiYmEmTJokLAwMDCSEHDx6UbSo1NTUgIECj0QKAHMgKoB67du1is9n+/v4pKSmNjY1CobCxsTE5OXnWrFnh4eG7du2SrhwfHz9q1KhDhw6tWLHiypUrAoFAIBD88ccfcXFxlZWVa9asoessAABZAdTDyMgoIyMjPT29qKhowoQJZmZm48ePP3XqVHp6enp6upGRkXRlCwuLsrKyhISEiooKHx8fMzMzOzs7DodjZ2d34cIF2XEF6VEcjOgAaJQhPK8AuiMgIEDB6z+WlpabNm3atGmTIpUxhAOgNegrAACAhE73FXJycnCtAABAm3Q6K3h7e3O5XLqj0AbFp+gAANAonc4Kzs7O1HSbAACgHRhXAAAACWQFAACQQFYAAAAJZAUAAJBQJiv0NnWo+K2zs3Nzc7P8vVQNXDN0PDwAAE1TJitITxfa4+u7d+9GRER0mz1fvFWnZhv19fWlZoGm9BhYtzoAAAZMI1eQHB0dT58+reBkBtrRWw+gq6urq6tL/r6yddCfAABDpZGskJWVNXDgwMTExGPHjmmifTUqLS194SrzitQBADAMGskKfn5+n3zyiUgkioyMrKur08QhAABAEzR1D9KHH34YHBzM4/FCQkL++usvDR2F9DQ+3GOJ9KaoqKjeairYvmxr3cbSMzMzqTpubm643AQAekSDd6YePHjw5ZdfvnTp0sqVKzV3FNnxYTkl1ED3/v37e6vZp/alWxOJREVFRYQQJycngUCwYMECqs7GjRvnzp2rO6PrAADyaXAeJCsrq7y8PC8vr9TUVB8fn3fffVdzx9IF06dP9/T0/P333zMzMxcvXkwVpqSk7NixQ5Hdy8vL0aXoP8rLy+kOAaAX0mvTZ2VlkRetX99tIfsey6XfHjp0iBAyePDgS5cuyW6Vg81ms9ls5SJRpESVfXtrjTrZsWPHUm9Pnz49evRoxU8B+htF/m8AaJnGn23mcDjR0dHPnj0LDQ3l8XiaPhy9IiIinJycqqqqiouLCSHJycnx8fEK7puVlUX3fwbQHuoXGIAO0saMFykpKRMmTLh58yaHw9FE+9SFF6FQSL3l8/maOIoijI2NqUGUHTt23Lp1q6ysbNGiRXQFAwCgBG1khUGDBuXm5lpbWx89elQT7Ts6OhJCmpqaqLeXLl2SrWNqakoIEQqF7e3tLBZLxSPKaS02NtbU1PTEiROrV6+OiooaPHiwiscCANAmLc2O5+bmlp6erqHRVH9/f0LI9u3b+Xx+TU2N+BYjaWPGjCGEVFRUFBQUeHt7q3hEOa3Z2NhwOByRSFRYWLh8+XIVDwQAoG2y1zpfeEm0t0bktEzZuHGjIu1TFB9tbm5uXrhwoZ2dnZmZWWBgYENDg2wMlZWVnp6epqamXl5e169flw1Y8ZLeWhOrra1lMpkLFixQ8Eypo2BcoV/p050dANqkzJ2pol7umemtXGzLli1btmxR4ojysVisjIwM+ZFMnDixqqqqW6FsNUVKemtNbMSIEQ4ODoqPMwMA6A6sr6B+x48fd3Fx8fLyojsQAIA+Q1ZQGwaDUV5e3trampCQsGHDBrrDAQBQBrKCOnl7e7u7u8+dOzcoKIjuWAAAlKHBGS/6mxcOqwAA6D70FQAAQAJZAQAAJJAVAABAAlkBAAAkdHq0ubGxMScnh+4oDJ94JhINDZhrun0tM7DTAehGp7NCWVlZWVkZ3VEYPpFIpPgUVb6+voSQc+fOaah93WdgpwPQjU5fQVJwHiQDQPcn3YPelpvu6urq6urSfjw6Dqtzg8HQ6b4C6KDS0lK6QwAADdLpvgIAAGgZsoLeYPzPvXv3QkJCLCwsbG1tORwOn8+vr68PCgqytLR0dHRcsmSJ9Eqo4r3klPR4LOnKUVFRL2yturr6rbfesrS0NDc3DwgIuHbt2gtPhJKZmUmVu7m5KXgdRrzvzZs358+fb21tLb3jw4cP4+LinJ2djY2Nhw4dGh0dff/+ffG+fD6fy+UOHz7cxMTE1tZ2ypQpH3zwQUVFhSY+LgC9JH11W6fmfFd8fQUDQBRbX4H6J1u0aFF1dTWPx1uxYgUhJCAgIDg4mCqJi4sjhCxbtkx2L9VL5NecMmVKSUnJkydPioqKHB0dra2t6+rqeturqKiIEOLk5CQQCMSF+/btmzt37gs/BOkG/f39S0tL29vbT5w4QbV///79l156ycHBobCw8MmTJ2fPnn3ppZeGDRvW2tpK7fj2228TQnbu3NnW1iYQCGpqaoKDg6VjU+/H1Rud+lsDkIasoBP6lBV+/vln6u3du3e7ldy5c4cQMnToUNm9VC+RX/PEiRPikkOHDhFCqDXpetvL09OTEHL48GFxyWuvvXbq1Knezr3HMM6cOdOtPCYmhhCSmpoqLvnhhx8IIevXr6feWlpaEkJycnLEFaiP8YUn2NcS+XTqbw1AGq4g6Z/x48dTL6gFq6VLhgwZQgi5d++e9qOaMmWK+PWMGTMIISdPnpRTn8vlEkKSkpKot8XFxV1dXdSOinv99de7lRQUFBBCZs+eLS7x8/MTlxNCQkJCCCFsNtvV1TUqKio7O5vFYonouw0sLCzM3NzcxsbGw8PjjTfeWLp0aUpKyvnz5zs7O+kKCfo5ZAX9Y2FhQb1gMpk9ltDyHWdlZSV+zWKxCCHNzc1y6kdERDg5OVVVVRUXFxNCkpOTlVi9ztTUtFvJw4cPCSFDhgwRjwdQwdy8eZOqcODAgby8vJCQkLa2ttTU1PDwcHd3dzkr62kal8vdtWvXtm3bFi1a9MorrzQ0NHz88cc+Pj4ODg5Lliy5cOECXYFB/yXdcdCpXi2uIPVYjfT9UgY1Fvr8+XPqrXgsuq/tyK/56NEjcUljYyMhxMnJSX5rW7duJYQEBATcvHnTzs6uvb29l/PuQW/hDR06lBDS0tLywhY6OzvPnj07a9YsQsjYsWPF5er9uHoj/2+tpqbm888/p7qA06ZN++233xRvGUBF6CsYPupCU1NTE/X20qVLiuxF/QwXCoXt7e3Uz235pJ9joAaTZ86cKX+X2NhYU1PTEydOrF69OioqavDgwYoEJt+8efMIIT///LN04blz57y9vanXDAaDSlpMJtPX15f6dpa+Y0o7H5d8Hh4ea9euvXjx4rlz54RC4aRJkz755BORTj7tCIYHWcHw+fv7E0K2b9/O5/Nramr279+vyF5jxowhhFRUVBQUFIi/UuXYs2dPSUlJW1tbcXHxunXrrK2tN2/eLH8XGxsbakS6sLBw+fLlikT1Qps3b3Z3d1+xYkVubu7jx4+fPHly7NixJUuWbNu2TVwnKirq6tWrAoHgwYMHn376KSGE6jFQtPNxKWjq1KklJSVffPFFQkLCe++9h6fKQRukOw64gkQXosAVJNl/NUVKRCJRc3PzwoUL7ezszMzMAgMDGxoaFNmrsrLS09PT1NTUy8vr+vXrcmpSb+vq6ubOnWthYWFmZjZ79uzq6mo5kYvV1tYymcwFCxb09eOS02ZLS8v7778/bNgwIyMjBweHwMDAsrIy8daSkhIOh+Pm5mZkZGRlZeXp6bl169anT59q4uOSo69/az/99JOJicn777+v+C4AykFW0AmKZAWd1eNXs4I6OzudnJykv7X7CSX+1r777jsGg1FQUKChkAAouIIEdDp+/LiLi4uXlxfdgeiBiIiIiIgILpf7/PlzumMBQ4asADRgMBjl5eWtra0JCQkbNmygOxy9kZiY2NDQ8P3339MdCBgyZAVQifQUQH3a0dvb293dfe7cuUFBQbJtyqGeuPWTq6trcHDw3r176Q4EDBlm0gaViJS6XVL+Xsq12U8sXLgwODj44cOH9vb2dMcChgl9BQB98sYbbzCZzG4PZACoEbICgD6xsLBwd3f/448/6A4EDBayAoCeeeWVV/7880+6owCDhawAoGccHR0fPHhAdxRgsJAVAPSMubn506dP6Y4CDBayAoCeEQqFxsbGdEcBBgtZAUDPPH/+HFkBNAdZAUDPPH/+3MjIiO4owGAhKwDomZaWFumV7wDUC1kBQM/8+eefI0aMoDsKMFjICgB6pq6uDlkBNAdZAUCf3L9//8mTJ8gKoDk9zI4XFham/ThklZWVEZ0JRguSkpJyc3PpjgK05M6dO8rteP36dULIyy+/rNZwACT+lhVef/31BQsWdHZ20hWNNDUufqv72Gw23SGAVrm4uCj3P7y8vNzJycnZ2VntIQFQGJi1GECPBAcHM5nMvLw8ugMBg4VxBQB9Ul5e3q+60aB9yAoAeqOuru7+/ftY5ho0ClkBQG/88ssvJiYmEyZMoDsQMGTICgB648SJE9OmTRs8eDDdgYAhQ1YA0A8dHR2nTp2aPXs23YGAgUNWANAP58+f5/F4c+bMoTsQMHDICgD64T//+c/w4cPd3d3pDgQMHLICgH7Iz88PCgqiOwowfMgKAHrg999/v3btWv+ZAAZohKwAoAeys7NdXFzwpAJoAbICgB7IyckJDw9nMBh0BwKGD1kBQNddvHjxxo0b4eHhdAcC/QKyAoCuy8zMHD58OB5pBu1AVgDQaR0dHRkZGYsXL8blI9AOZAUAnXb8+PH79+9HRkbSHQj0F1hfAUCnzZs3r62traioiO5AoL9AXwFAdz148ODEiRPvvvsu3YFAP4KsAKC7vv32W1NT0/nz59MdCPQjyAoAOkokEu3bt++dd97B1NmgTQPpDgAAenb69Ona2trc3Fy6A4H+BaPNADoqNDT0wYMH586dozsQ6F/QVwDQRU1NTUePHj148CDdgUC/g3EFAF20b98+KyurkJAQugOBfgdZAUDndHR07Nu377333jMxMaE7Fuh3kBUAdE5OTk5TU1NsbCzdgUB/hNFmAJ3j5eXl6uqanZ1NdyDQH6GvAKBbSktLL1y4wOVy6Q4E+in0FQB0S2ho6O3btysrK+kOBPop3JkKoENu376dn5+fnp5OdyDQf+EKEoAOSU5OdnBwwMRHQCNkBQBd8eTJkwMHDsTHxxsZGdEdC/RfyAoAuiI1NVUoFC5dupTuQKBfw2gzgE7o7Oz08PCYPXv2rl276I4F+jX0FQB0Qn5+/q1bt1auXEl3INDfoa8AoBN8fX1tbGzy8/PpDgT6O9yZCkC/ysrKkpKS4uJiugMBQF8BQAew2ez6+no8uQa6AH0FAJrdunXrxx9//O677+gOBIAQ9BUAaLd8+fKffvqptrZ24ED8SgP64R4kADo1NzcfOnRo7dq1SAmgI5AVAOj05ZdfDh48eMmSJXQHAvD/kBUAaNPe3v7111+vWrXKzMyM7lgA/h+yAgBtUlNT29vbV6xYQXcgABIYbQagBzXFxVtvvfXll1/SHQuABPoKAPTIycmpr69fs2YN3YEA/A36CgD0mDhx4ogRI7KysugOBOBvcDMcAA2KioouXrw4f/78nJwcumOB/m7SpElubm7it+grANBg1qxZVVVVDx8+pDsQALJgwYLvv/9e/BZ9BQBtu3z58qlTp6ZOnTpt2rTs7Gy6wyGEEAaDkZWVFRYWRncg+of60HTk31EJYWFhnZ2d0iUYbQbQts8++2z06NGOjo50BwLQA2QFAK1qbGzMzs7+8MMP6Q4EoGfICgBa9cUXXzg4OCxYsIDuQAB6hqwAoD2tra379+/ncrnGxsZ0xwLQM2QFAO35+uuvmUzm0qVL6Q4EoFe4BwlASwQCwVdffbV8+XIrKyu6Y9FRDAaDeqG1O+a1f0Tdh74CgJYcPny4paVl1apVdAeiu7T/1YxkIAtZAUAburq6du7cGRkZOWTIELpjAZAHV5AAtCE/P7+mpiY3N5fuQABeAH0FAG34/PPPg4KCRo0aRXcgAC+ArACgceXl5efPn1+7di3dgaiqqKgoKCjI2traxMRk/PjxmZmZiu/L+J/q6uq33nrL0tLS3Nw8ICDg2rVriuwlp4TP53O53OHDh5uYmNja2k6ZMuWDDz6oqKjo06k1NDQEBwdbWVkpEpVhQ1YA0LiUlJRx48b5+vrSHYiq/P39BwwYcOPGjdraWhaLFRERUVhYqOC+4nHdZcuWffTRR/fu3cvPz//tt998fHzq6+tfuJecEg6Hs3Pnzvj4+MePHzc1NR08ePDWrVuTJ09W9KwIIYRER0dzudzGxkZFojJsyAoAmtXU1JSXlxcfH6/c7gwZ3cqdnZ2bm5vl76XSCfxdUlISi8VydXVNSUkhhGzdurWvLWzcuNHHx8fc3Hz69Onbtm1rbW3dvHmzKiGdOXOGEDJ06FAzMzNjY2MPDw8llreLjY318/OzsLBQV1T6C1kBQLN2795tZWUVHh6u3O4ikUj867jH13fv3o2IiOg27aV4q/QuqhOJROKJ+N3d3Qkh1dXVfW1kypQp4tczZswghJw8eVKVqEJCQgghbDbb1dU1KioqOzubxWL19ayle3JqiUp/ISsAaJBAINi7d29sbKyJiYmGDuHo6Hj69OlNmzZpqH0xHo+3fv36V1991cLCgsFgDBw4kBDy+PHjvrYj/RAfi8UihMj2dfrkwIEDeXl5ISEhbW1tqamp4eHh7u7uVVVVfWrE1tZWvVHpL2QFAA3KzMxsaWmJiYnR3CGysrIGDhyYmJh47NgxzR2FEBIWFpaYmBgeHn779m1VuiDSieTRo0eEEDs7Ozn1qStgQqGQesvn82XrzJ8/Pzc399GjR2fPnp01a1ZDQ8O7777bp6ikm1UkKgOGrACgQV999RWbzR46dKjmDuHn5/fJJ5+IRKLIyMi6ujrNHai0tJQQsnbtWhsbG0KIQCBQpR1KUVERIWTmzJly6lMLUTQ1NVFvL1261K0Cg8FobGwkhDCZTF9fX2op7L7eRFRWVtanqAwYsgKAppSWllZWVmphiosPP/wwODiYx+OFhIT89ddfGjoKdeU9MTGRx+O1tLSsX79euXb27NlTUlLS1tZWXFy8bt06a2tr+eO6/v7+hJDt27fz+fyampr9+/fL1omKirp69apAIHjw4MGnn35KCJk1a1afokpMTDx//rziURkyEQBoRnh4+IQJE3rbymaz2Wy2gk319tcqLuTxeC+//DIhZOnSpbJbFWk/KytLfp0HDx5ERkba29sbGxv/85//pH6S9+lrhKpcV1c3d+5cCwsLMzOz2bNnV1dXd6vQrc3m5uaFCxfa2dmZmZkFBgY2NDR0q1NSUsLhcNzc3IyMjKysrDw9Pbdu3fr06VPFQyKEXL16debMmebm5rJRydenf0cdJBs/ZrwA0Ih79+798MMPBw4c0M7hrKys8vLyvLy8UlNTfXx8+npVXRH29vZpaWnSJcqt8+zm5lZQUNDjJlFPYxUsFisjI0NONR8fHx8fHyUi6daU4s9eGDZcQQLQiK+//tra2prNZmvtiGPGjNm9ezchZMWKFX29AwdADFkBQP0EAsG+ffvi4uIGDRqkzeNyOJzo6Ohnz56FhobyeDxtHhoMBrICgPodOXKkpaUlOjpa+4dOSUmZMGHCzZs3ORyONo8r+wx2t4erpZ/K1p2oQBayAoD67d+/f86cObQspTBo0KDc3Fxra+ujR49q87jyhzS7VdCdqEAWsgKAmtXV1RUXF9O4OLObm1t6ejp+C4NykBUA1OzAgQP29vazZ89WS2uyM+J1e93jxZA5c+Zs2LBBLQFAf4OsAKBOnZ2dhw8ffu+994yMjNTSYG/XPV54MWTLli24SAJKQFYAUKdTp041NjZq4nEBAO3AU2wA6pSRkeHt7U09ZqxfkpKSsKy0EsrKyry9vemOQp3QVwBQm/b29iNHjkRERNAdCIDy0FcAUJujR4/+9ddf2nyeWY24XK5yM1j0c4b3oaGvAKA233333YwZMxwcHOgOBEB5yAoA6tHa2lpYWIjLR6DvkBUA1OP48eMikSgoKIjuQABUgqwAoB5Hjx594403/vGPf9AdCIBKkBUA1EAgEBQWFqKjoAkGNpnd8ePH3377bUdHR2NjY0dHx8DAwCNHjkhXkD+Ln/z5/tQyCSCyAoAanDlz5r///W9AQADdgRgCX19fajVQSo9PaHeroxeEQuGiRYveeeedN998s7Kysq2trbKycvr06RwOJyQk5NmzZ1Q12SfYpRvpNtsg6WnaQRVnAMSdqQBqcOzYsXHjxrm5udEdiD6hfsbKfnN1dXW9cF/ZOr21pjtWrVqVnZ19/vz5iRMnUiUuLi5r1qzx9vaeOnVqdHT0t99+S2+EFPQVANSguLi4r8vHQ29KS0tLS0tVr6NTLly48M033yxZskScEsQmT568ePHi9PT0c+fO9bXZF2ZBJdIksgKAqpqbm2tqaqZNm0Z3IKC79uzZQwgJDQ3tcSv15OO+ffu0GlMvkBUAVPXLL78wmUwDmwxHFbLjnD2WSG+KiorqraaC7cu21m3QNTMzk6rj5uam/eFrqh/w2muv9bh1zJgxhBAd6f1gXAFAVWfPnh03bpyVlRXdgegKkUjU7TtXTonsaOoLv68VbE0kEp0+fXrGjBlOTk719fXGxsZU+caNG/Pz8wsKCvp8Yiq4d+8eIcTW1rbHrVR5U1OTNkPqDfoKAKoqKSnRu/th+onp06d7eno2NTWJOwqEkJSUlPj4eBqjksX4+9LW9EJWAFBJR0dHdXX1+PHjldg3JydHidvPNUHtH4vu4HK5hJCkpCTqbXFxcVdX14wZM7QchpOTEyGkpaWlx62PHj0ihEgv9M1kMgkhnZ2dspU7OzuprRqCK0gAKvnzzz8FAsGoUaOU2Nfb25v6zqKd4U38KRYREbFu3bqqqqri4uI333wzOTmZlo6Cr6/vrVu3Ll++7OjoKLv18uXLhBA/Pz9xiYWFBZ/P5/P5NjY23Sq3trZaWlpqLlRkBQCVVFdXM5lMDw8PJfZ1dnbW02m3X4jBYIhEIqFQSK1Uyufz6YrE2Nh45cqVGzZs2LFjh5ubW1lZmfTVJK2JjY09fPhwXl7ezJkzZbfm5ORQdcQlHh4eFRUVV65ckU4VlCtXrowcOVJzoeIKEoBKrl69OmzYMDMzM7oD0S3UL2Lx8OmlS5dk65iamhJChEJhe3s7i8VS8YhyWouNjTU1NT1x4sTq1aujoqIGDx6s4rGU4OXlFRMTc/DgwV9//bXbpgsXLqSlpRevnnkAAAWSSURBVMXExEyaNElcGBgYSAg5ePCgbFOpqakafYoeWQFAJbdv3x4xYgTdUegcf39/Qsj27dv5fH5NTc3+/ftl61C3Y1ZUVBQUFKh+X6+c1mxsbDgcjkgkKiwsXL58uYoHUtquXbvYbLa/v39KSkpjY6NQKGxsbExOTp41a1Z4ePiuXbukK8fHx48aNerQoUMrVqy4cuWKQCAQCAR//PFHXFxcZWXlmjVrNBioCABUMH/+/PDwcCV2ZLPZbDZb7fEohxCSlZWlxgabm5sXLlxoZ2dnZmYWGBjY0NAg+51TWVnp6elpamrq5eV1/fp1cSTdaipS0ltrYrW1tUwmc8GCBWo8R0pf/x2PHTsWGBhob29vZGRkZ2cXEBBQUFDQY00+n5+QkDBx4kRLS8sBAwZYWFiMGzfuo48+4vF4spWV/m6XjR/jCgAq4fP56CvIYrFYGRkZ0iWy31wTJ06sqqrqVihbTZGS3loTGzFihIODgy7ckBoQEKDg9R9LS8tNmzZt2rRJkco9fibKwRUkAJXw+XysqaD7jh8/7uLi4uXlRXcgegBZAUAlz549o2X0EhTBYDDKy8tbW1sTEhI2bNhAdzj6AVkBQCWDBg0SCAR0RwG98vb2dnd3nzt3LtZEUhDGFQBUYmVlxePx6I4CeqbGq+39B/oKACpxcXGRvsEGQN8hKwCoZOTIkVevXqU7CgC1QVYAUMmkSZNu376tI3MgA6gOWQFAJVOnTjUzM9PyZP0AmoOsAKASU1PTgICAQ4cOiUt+/PHHXbt2KbIkPYAOQlYAUFV8fHxZWdnPP/9Mvf3oo49Wr17t4+Nz69YtWuPqm/DwcLpXedBL1HSnhgR3pgKoasqUKbNnz165cuXFixf5fH51dTUh5Ndffx09enRycvKyZcsY+rCsDZfLxdLTShCv52MwkBUA1OCrr74aO3ZsXFwcNVcoIaSjo6OjoyM2NjY7O/vQoUPOzs70RvhCXl5ehrrYg0YZXl8BV5AA1GDYsGHff/99Wlraxx9/PHCg5MeWSCQ6e/bsq6++unfvXhrDA1AcsgKAesyZMycvL6+urk4oFEqXC4XCtra22NjY0NBQanle1RUVFQUFBVlbW5uYmIwfP56WxcXAUCErAKjNyJEje5sTSSQSHT161MPDIz8/X/UD+fv7Dxgw4MaNG7W1tSwWKyIiorCwUPVmAQiyAoAanTp1SvryUTdCoZDH482bN2/RokVPnjxR8VhJSUksFsvV1TUlJYUQsnXrVhUbBKAgKwCoTWFhofzp2KiHGDIyMkaNGvX06VOlDyQSidzc3KjX7u7uhBDqxicA1eEeJAD16OjoOHPmTFdXl7GxMYPB6Orq6ujokE4SRkZGVlZW1tbWdnZ2Tk5Oz549U+5APB7vs88++/HHHxsbG9va2qjCx48fq+EcAJAVANSFyWRGRER0dHTY2NjY2tra2tra2NiwWCzqha2trZmZmXT9sLAw5Q4UFhZ26tSpf//736tXr7axsSGE6MXzEKAvkBUA1IPJZKampmrhQKWlpYSQtWvXWlhYEEKw5g+oF8YVAPSMr68vISQxMZHH47W0tKxfv57uiMCgICsA6Jm0tLTIyMjU1FQHB4dp06ZNnjyZKsd1JFALXEEC0DP29vZpaWnSJUoPUQDIQl8BAAAkkBUAAEACWQEAACSQFQAAQAJZAQAAJJAVAABAAlkBAAAkkBUAAEACWQEAACSQFQAAQAJZAQAAJJAVAABAAlkBAAAkkBUAAEACWQEAACSQFQAAQAKr7gDQ5s6dOzk5OXRH8f/Ky8uxmpsSGhsbCSG68+/YV3fu3HFxcZEuYYhEIrqiAejP3n///aSkJLqjACBcLnfHjh3it8gKAAAggXEFAACQQFYAAAAJZAUAAJBAVgAAAIn/A0gDILfg52h3AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Create a Node that adds 2 numbers\n", + "def add(a, b):\n", + " return a + b\n", + "\n", + "\n", + "\n", + "adder = Node(Function(input_names=['a', 'b'],\n", + " output_names=['add'],\n", + " function=add), \n", + " name='a_plus_b')\n", + "adder.inputs.b = 10\n", + "\n", + "#Create a workflow \n", + "wf = Workflow('hello')\n", + "# connect the nodes \n", + "wf.connect(mul, 'multiply_result', adder, 'a')\n", + "#visualize the graph\n", + "wf.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "clear_output()\n", + "Image(filename='graph_detailed.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[\n", + " multiply_result = 6,\n", + " \n", + " add = 16]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#run the graph\n", + "eg = wf.run()\n", + "clear_output()#don't print the pipeline steps during exection\n", + "#chek the results\n", + "eg = list(eg.nodes())\n", + "nodes_outputs = [node.result.outputs for node in eg]\n", + "nodes_outputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Preprocessing\n", + "\n", + "\n", + "In this workflow we will conduct the following steps:\n", + "\n", + "**1. Coregistration of functional images to anatomical images (according to FSL's FEAT pipeline)**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Co-registrationis the process of spatial alignment of 2 images. The target image is also called reference volume. The goodness of alignment is evaluated with a cost function.\n", + "\n", + "We have to move the fmri series from fmri native space:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_ = plotting.plot_anat(nibabel.nifti1.Nifti1Image(fmri.get_data()[:,:,:,1], affine=fmri.affine), cut_coords=(0,0,0), title='fmri slice')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " to native anatomical space:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_ = plotting.plot_anat(anat, cut_coords=(0,0,0), title='Anatomical image')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**2. Motion correction of functional images with FSL's MCFLIRT**\n", + "\n", + " The images are aligned with rigid transformation - rotations, translations, reflections.\n", + " Then spatial interpolation is done, so as there was no movements.\n", + "\n", + "![Rigit transformation](https://www.researchgate.net/profile/Olivier_Serres/publication/43808029/figure/fig4/AS:304436623757316@1449594755197/Rigid-body-transformation-scale-1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " **3. Slice Timing correction**\n", + " \n", + " The brain slices are not acquired at the same time. Therefore, interpolation is done between the nearest timepoints\n", + "![Slice Order](https://www.mccauslandcenter.sc.edu/crnl/sites/sc.edu.crnl/files/slice_order_1.jpg)\n", + "\n", + "[Slice timing corretion in python](https://matthew-brett.github.io/teaching/slice_timing.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**4. Smoothing of coregistered functional images with FWHM set to 5/10 mm**\n", + "\n", + "**5. Artifact Detection in functional images (to detect outlier volumes)**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**So, let's start!**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports\n", + "\n", + "First, let's import all the modules we later will be needing." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn import plotting\n", + "%matplotlib inline\n", + "from os.path import join as opj\n", + "import os\n", + "import json\n", + "from nipype.interfaces.fsl import (BET, ExtractROI, FAST, FLIRT, ImageMaths,\n", + " MCFLIRT, SliceTimer, Threshold)\n", + "from nipype.interfaces.spm import Smooth\n", + "from nipype.interfaces.utility import IdentityInterface\n", + "from nipype.interfaces.io import SelectFiles, DataSink\n", + "from nipype.algorithms.rapidart import ArtifactDetect\n", + "from nipype import Workflow, Node" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experiment parameters\n", + "\n", + "It's always a good idea to specify all parameters that might change between experiments at the beginning of your script. We will use one functional image for fingerfootlips task for ten subjects." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "experiment_dir = '/output'\n", + "output_dir = 'datasink'\n", + "working_dir = 'workingdir'\n", + "\n", + "# list of subject identifiers\n", + "subject_list = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10']\n", + "\n", + "# list of session identifiers\n", + "task_list = ['fingerfootlips']\n", + "\n", + "# Smoothing widths to apply\n", + "fwhm = [5, 10]\n", + "\n", + "# TR of functional images(time from the application of an excitation pulse to the application of the next pulse)\n", + "\n", + "with open('/data/ds000114/task-fingerfootlips_bold.json', 'rt') as fp:\n", + " task_info = json.load(fp)\n", + "TR = task_info['RepetitionTime']\n", + "\n", + "# Isometric resample of functional images to voxel size (in mm)\n", + "iso_size = 4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify Nodes for the main workflow\n", + "\n", + "Initiate all the different interfaces (represented as nodes) that you want to use in your workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# ExtractROI - skip dummy scans\n", + "#t_min - Minimum index for t-dimension\n", + "#t_size - Size of ROI in t-dimension\n", + "extract = Node(ExtractROI(t_min=4, t_size=-1, output_type='NIFTI'),\n", + " name=\"extract\")\n", + "\n", + "#MCFLIRT - motion correction\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/MCFLIRT\n", + "#mean_vol- volumes are averaged to create a new template\n", + "#normcorr cost - https://www.fmrib.ox.ac.uk/datasets/techrep/tr02mj1/tr02mj1/node4.html\n", + "#sinc interpolation - https://math.stackexchange.com/questions/1372632/how-does-sinc-interpolation-work\n", + "mcflirt = Node(MCFLIRT(mean_vol=True,\n", + " save_plots=True,\n", + " output_type='NIFTI'),\n", + " name=\"mcflirt\")\n", + "\n", + "#SliceTimer - correct for slice wise acquisition\n", + "#https://poc.vl-e.nl/distribution/manual/fsl-3.2/slicetimer/index.html\n", + "#more on https://matthew-brett.github.io/teaching/slice_timing.html\n", + "#interleaved = -odd\n", + "#top to bottom = --down\n", + "#normcorr loss\n", + "slicetimer = Node(SliceTimer(index_dir=False,\n", + " interleaved=True,\n", + " output_type='NIFTI',\n", + " time_repetition=TR),\n", + " name=\"slicetimer\")\n", + "\n", + "#Smooth - image smoothing\n", + "#spm_smooth for 3D Gaussian smoothing\n", + "smooth = Node(Smooth(), name=\"smooth\")\n", + "smooth.iterables = (\"fwhm\", fwhm)\n", + "\n", + "# Artifact Detection - determines outliers in functional images via intensity and motion paramters\n", + "#http://web.mit.edu/swg/art/art.pdf\n", + "#norm_threshold - Threshold to use to detect motion-related outliers when composite motion is being used\n", + "#zintensity_threshold - Intensity Z-threshold use to detection images that deviate from the mean\n", + "#spm_global like calculation to determine the brain mask\n", + "#parameter_source - Source of movement parameters\n", + "#use_differences - Use differences between successive motion (first element) and\n", + "#intensity parameter (second element) estimates in order to determine outliers.\n", + "\n", + "art = Node(ArtifactDetect(norm_threshold=2,\n", + " zintensity_threshold=3,\n", + " mask_type='spm_global',\n", + " parameter_source='FSL',\n", + " use_differences=[True, False],\n", + " plot_type='svg'),\n", + " name=\"art\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coregistration Workflow\n", + "\n", + "Initiate a workflow that coregistrates the functional images to the anatomical image (according to FSL's FEAT pipeline)." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# BET - Skullstrip anatomical Image\n", + "#https://www.fmrib.ox.ac.uk/datasets/techrep/tr00ss2/tr00ss2.pdf\n", + "\n", + "bet_anat = Node(BET(frac=0.5,\n", + " robust=True,\n", + " output_type='NIFTI_GZ'),\n", + " name=\"bet_anat\")\n", + "\n", + "# FAST - Image Segmentation\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FAST\n", + "#http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.200.3832&rep=rep1&type=pdf\n", + "\n", + "segmentation = Node(FAST(output_type='NIFTI_GZ'),\n", + " name=\"segmentation\", mem_gb=4)\n", + "\n", + "# Select WM segmentation file from segmentation output\n", + "def get_wm(files):\n", + " return files[-1]\n", + "\n", + "# Threshold - Threshold WM probability image\n", + "threshold = Node(Threshold(thresh=0.5,\n", + " args='-bin',\n", + " output_type='NIFTI_GZ'),\n", + " name=\"threshold\")\n", + "\n", + "# FLIRT - pre-alignment of functional images to anatomical images\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FLIRT\n", + "coreg_pre = Node(FLIRT(dof=6, output_type='NIFTI_GZ'),\n", + " name=\"coreg_pre\")\n", + "\n", + "# FLIRT - coregistration of functional images to anatomical images with BBR(uses the segmentation)\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FLIRT_BBR\n", + "coreg_bbr = Node(FLIRT(dof=6,\n", + " cost='bbr',\n", + " schedule=opj(os.getenv('FSLDIR'),\n", + " 'etc/flirtsch/bbr.sch'),\n", + " output_type='NIFTI_GZ'),\n", + " name=\"coreg_bbr\")\n", + "\n", + "# Apply coregistration warp to functional images\n", + "#apply_isoxfm-apply transformation supplied by in_matrix_file\n", + "applywarp = Node(FLIRT(interp='spline',\n", + " apply_isoxfm=iso_size,\n", + " output_type='NIFTI'),\n", + " name=\"applywarp\")\n", + "\n", + "# Apply coregistration wrap to mean file\n", + "applywarp_mean = Node(FLIRT(interp='spline',\n", + " apply_isoxfm=iso_size,\n", + " output_type='NIFTI_GZ'),\n", + " name=\"applywarp_mean\")\n", + "\n", + "# Create a coregistration workflow\n", + "coregwf = Workflow(name='coregwf')\n", + "coregwf.base_dir = opj(experiment_dir, working_dir)\n", + "\n", + "# Connect all components of the coregistration workflow\n", + "coregwf.connect([(bet_anat, segmentation, [('out_file', 'in_files')]),\n", + " (segmentation, threshold, [(('partial_volume_files', get_wm),\n", + " 'in_file')]),\n", + " (bet_anat, coreg_pre, [('out_file', 'reference')]),\n", + " (threshold, coreg_bbr, [('out_file', 'wm_seg')]),\n", + " (coreg_pre, coreg_bbr, [('out_matrix_file', 'in_matrix_file')]),\n", + " (coreg_bbr, applywarp, [('out_matrix_file', 'in_matrix_file')]),\n", + " (bet_anat, applywarp, [('out_file', 'reference')]),\n", + " (coreg_bbr, applywarp_mean, [('out_matrix_file', 'in_matrix_file')]),\n", + " (bet_anat, applywarp_mean, [('out_file', 'reference')]),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify input & output stream\n", + "\n", + "Specify where the input data can be found & where and how to save the output data." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Infosource - a function free node to iterate over the list of subject names\n", + "infosource = Node(IdentityInterface(fields=['subject_id', 'task_name']),\n", + " name=\"infosource\")\n", + "infosource.iterables = [('subject_id', subject_list),\n", + " ('task_name', task_list)]\n", + "\n", + "# SelectFiles - to grab the data \n", + "anat_file = opj('derivatives', 'fmriprep', 'sub-{subject_id}', 'anat', 'sub-{subject_id}_t1w_preproc.nii.gz')\n", + "func_file = opj('sub-{subject_id}', 'ses-test', 'func',\n", + " 'sub-{subject_id}_ses-test_task-{task_name}_bold.nii.gz')\n", + "\n", + "templates = {'anat': anat_file,\n", + " 'func': func_file}\n", + "selectfiles = Node(SelectFiles(templates,\n", + " base_directory='/data/ds000114'),\n", + " name=\"selectfiles\")\n", + "\n", + "# Datasink - creates output folder for important outputs\n", + "datasink = Node(DataSink(base_directory=experiment_dir,\n", + " container=output_dir),\n", + " name=\"datasink\")\n", + "\n", + "## Use the following DataSink output substitutions\n", + "substitutions = [('_subject_id_', 'sub-'),\n", + " ('_task_name_', '/task-'),\n", + " ('_fwhm_', 'fwhm-'),\n", + " ('_roi', ''),\n", + " ('_mcf', ''),\n", + " ('_st', ''),\n", + " ('_flirt', ''),\n", + " ('.nii_mean_reg', '_mean'),\n", + " ('.nii.par', '.par'),\n", + " ]\n", + "subjFolders = [('fwhm-%s/' % f, 'fwhm-%s_' % f) for f in fwhm]\n", + "substitutions.extend(subjFolders)\n", + "datasink.inputs.substitutions = substitutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify Workflow\n", + "\n", + "Create a workflow and connect the interface nodes and the I/O stream to each other." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a preprocessing workflow\n", + "preproc = Workflow(name='preproc')\n", + "preproc.base_dir = opj(experiment_dir, working_dir)\n", + "\n", + "# Connect all components of the preprocessing workflow\n", + "preproc.connect([(infosource, selectfiles, [('subject_id', 'subject_id'),\n", + " ('task_name', 'task_name')]),\n", + " (selectfiles, extract, [('func', 'in_file')]),\n", + " (extract, mcflirt, [('roi_file', 'in_file')]),\n", + " (mcflirt, slicetimer, [('out_file', 'in_file')]),\n", + "\n", + " (selectfiles, coregwf, [('anat', 'bet_anat.in_file'),\n", + " ('anat', 'coreg_bbr.reference')]),\n", + " (mcflirt, coregwf, [('mean_img', 'coreg_pre.in_file'),\n", + " ('mean_img', 'coreg_bbr.in_file'),\n", + " ('mean_img', 'applywarp_mean.in_file')]),\n", + " (slicetimer, coregwf, [('slice_time_corrected_file', 'applywarp.in_file')]),\n", + " \n", + " (coregwf, smooth, [('applywarp.out_file', 'in_files')]),\n", + "\n", + " (mcflirt, datasink, [('par_file', 'preproc.@par')]),\n", + " (smooth, datasink, [('smoothed_files', 'preproc.@smooth')]),\n", + " (coregwf, datasink, [('applywarp_mean.out_file', 'preproc.@mean')]),\n", + "\n", + " (coregwf, art, [('applywarp.out_file', 'realigned_files')]),\n", + " (mcflirt, art, [('par_file', 'realignment_parameters')]),\n", + "\n", + " (coregwf, datasink, [('coreg_bbr.out_matrix_file', 'preproc.@mat_file'),\n", + " ('bet_anat.out_file', 'preproc.@brain')]),\n", + " (art, datasink, [('outlier_files', 'preproc.@outlier_files'),\n", + " ('plot_files', 'preproc.@plot_files')]),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize the workflow\n", + "\n", + "It always helps to visualize your workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200921-08:13:47,400 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/preproc/graph.png (graph2use=colored, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create preproc output graph\n", + "preproc.write_graph(graph2use='colored', format='png', simple_form=True)\n", + "\n", + "# Visualize the graph\n", + "from IPython.display import Image\n", + "Image(filename=opj(preproc.base_dir, 'preproc', 'graph.png'))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200921-08:13:47,944 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/preproc/graph.png (graph2use=flat, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjkAAAXnCAYAAAAeoRs+AAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzde1xUdf7H8feAEApECgjeXZPUzdW1i3es1cQ072BCZejvQYi5rVrmbm2PpEc/Fdc1Sf1tlqKbKwUKlkq2oplpXkC3rCTTUhNRRAFxvSGo8/ujZdaR2wwCx4HX8/GYx2/mnM/5nvc5M2P7mw/nfE1ms9ksAAAAAAAAAAAAx7LUyegEAAAAAAAAAAAAVUGTAwAAAAAAAAAAOCSaHAAAAAAAAAAAwCHR5AAAAAAAAAAAAA6pgdEBUD9Mnz5dmZmZRscAACvNmzdXbGys0TEAAAAAAABQRSaz2Ww2OgTqPmdnZ3Xv3l2tWrUyOopdsrKytHv3boWEhMhkMhkdBzVoz549unHjhnr37m10FNSSku/3tWvX5OzsbHQcAAAAAAAA2G8pTQ7UCmdnZ8XHxys0NNToKHZJTk5WSEgIP4LWA2FhYSoqKlJycrLRUVBL+H4DAAAAAAA4vKXMyQEAAAAAAAAAABwSTQ4AAAAAAAAAAOCQaHIAAAAAAAAAAACHRJMDAAAAAAAAAAA4JJocwB2ssLBQr732mu699141aNBAJpNJJpPJ6Fi4g3zyyScaMWKE/P395erqKn9/fw0bNkwff/xxqdqSz8+tD1vr7HkAAAAAAAAAtYEmB1ADAgMDFRgYeNvjzJw5U7NmzdL//M//6N///rc2bdpUDelQFxQXF+uZZ57R008/rf79+2vv3r26ePGi9u7dqwEDBig8PFzBwcG6cuWKZRuz2Syz2Vzu67KWl/W8vHHKGw8AAAAAAACoKQ2MDgDURTdu3KiWcRITEyVJkyZNUqNGjRQUFMSPyJAkvfDCC1q9erV27dqlhx56yLK8VatWmjp1qnr16qW+ffsqMjJS//jHPwxMCgAAAAAAANQcruQAasDOnTu1c+fO2x7nxIkTkqQmTZrc9lioO9LS0vTuu+9q/PjxVg2Om/Xo0UPPPvusVq1apR07dtz2Pu1prtGIAwAAAAAAQG2hyQHcwarrihDULUuWLJEkhYSEVFg3ZswYSdLSpUtrPBMAAAAAAABgBJocQDUrb/Llm5efOHFCI0aMkKenp/z8/PTMM88oLy+vVP2t2/7pT3+yLDt9+rQmTpyoli1bytXVVS1btlRUVJRycnKsxjl//rymTZumdu3ayc3NTd7e3urdu7emT5+u9PR0q1pbx7TlGMtbfuTIEY0ePVqNGzcuVVtYWKiYmBh169ZN7u7ucnNzU8eOHRUVFaU9e/ZYjXnmzBlNmjTJkrVFixaKjIzU6dOny3xf6pKSKzN+85vfVFjXpUsXSaqWq4oAAAAAAACAOxFNDqCalXernpuXv/LKK4qJiVFWVpaCg4MVHx+v6dOnl1tfMqFzTEyMpF+aEd27d1dKSopWrlypvLw8vf/++1q3bp169Ohh1ZQIDw9XbGyspkyZory8PGVnZ2vFihU6evSoevToYamzZ0xbjrG85ZMmTdL06dN16tQpbdy40bL8woULCgwM1OzZszV58mQdPXpUubm5WrJkibZv365evXpZanNyctS9e3d99NFHWr58ufLz85WQkKDU1FT17t1bBQUFZeaoK06dOiVJ8vb2rrCuZH12dnaNZwIAAAAAAACMQJMDMMBzzz2nTp06ycvLSzNmzJAkpaam2rz966+/rhMnTmju3Lnq37+/PD09NWDAAMXExOj48eOaOXOmpfbzzz+XJLVo0ULu7u5ydXVVhw4dtHjx4iqPeTteffVV9e7dWw0bNtTgwYMtDZDo6Gjt27dPb775piIiIuTn5ycPDw89+uijio+Ptxpj5syZOn78uGbPnq2goCB5eHgoMDBQCxYs0LFjxzRv3rxqyeroSq6SufXKGgAAAAAAAKCuoMkBGOCBBx6wPG/evLkk+/7aPiUlRZLUv39/q+WPPfaY1XpJCg4OlvTL/AytW7dWRESEVq9eLR8fH6srLOwZ83Z07969zOVJSUmSpJEjR5Za161bN6usGzZskCQNHjzYqq5fv35W6+uqZs2aSZLy8/MrrMvNzZX0389YCSenX/7pv379ernbXr9+3VIHAAAAAAAA3Kn4BQswgKenp+W5q6urpPJv9VSWs2fPSpJ8fHyslpe8PnPmjGXZ8uXLlZycrODgYF28eFFxcXEaO3asAgICtH///iqNeTsaNWpU5vKSJo+/v3+lY5Rkad68udV8HyVZjxw5Ui1Z71SBgYGSpG+//bbCupL1Jc2fEiWfv/Pnz5e77blz53T33XffTkwAAAAAAACgxtHkABxQ06ZNJf33L/VLlLwuWV9i9OjRSkpKUm5urrZv365BgwYpMzNTEyZMqPKYJbdAKi4utiyr6Efzyvj5+Umy7YqWktr8/HzLfCU3Py5dulTlHI4gKipKkpScnFxh3Zo1a6zqS3To0EGSdODAgXK3PXDggO67777biQkAAAAAAADUOJocgAMaNmyYJOmzzz6zWr5lyxar9dIvzYisrCxJv9ymKDAwUImJiZKkgwcPVmlM6b9XXNzclPj666+reET/va3Wxx9/XGrdnj17rCZJL7ml1bZt20rV7tixw2qS8rqoZ8+emjhxolasWKF9+/aVWZOWlqaVK1dq4sSJevjhh63WlbyXK1asKHcfcXFxeuKJJ6ovNAAAAAAAAFADaHIADuiNN95QmzZt9Kc//Ulbt27VhQsXtHXrVr3yyitq06aNoqOjreojIiKUkZGhq1evKicnR3PnzpUkDRo0qMpjDhw4UJI0b948nT9/Xj/88IOWLVtW5WOKjo5W586d9frrr2vp0qXKycnRxYsXtWnTJj377LOaPXu2VW1AQIAmT56spKQk5eXl6cKFC0pJSdH48eMVExNT5RyOYtGiRRozZowGDhyohQsXKisrS8XFxcrKytLbb7+tQYMGaezYsVq0aFGpbadMmaJf//rX+vvf/67JkyfrwIEDunr1qq5evarvvvtOkyZN0t69ezV16lQDjgwAAAAAAACwHU0OoJqV3Mapup/f/NrPz09paWkaNmyYxo0bpyZNmmjcuHEaNmyY0tLSLLdzkqQvv/xS/v7+Gjp0qDw9PdWhQwdt3LhRs2bN0ocfflilMSVp/vz5euqpp5SYmKgWLVpoxowZmjNnjt3HUuKee+7R7t27NWXKFM2fP1+tW7dW27Zt9dZbbykuLk4DBgyw1Pr4+CgtLU1hYWGaMWOGmjVrpoCAAL333nuKj4/XI488Umr8usbFxUXx8fFatWqVtmzZogcffFDu7u564IEHtHnzZq1atUqrVq2Si4tLqW09PT21e/duvfHGG0pPT1efPn3k7u4uX19fhYeHy9fXV2lpaeXOyXHre1jeewoAAAAAAADUNJPZntmOgSpydnZWfHy8QkNDjY5il+TkZIWEhOjatWtydnY2Og5qUFhYmIqKiiqd5wJ1B99vAAAAAAAAh7eUKzkAAAAAAAAAAIBDoskBAAAAAAAAAAAcEk0OAAAAAAAAAADgkGhyAAAAAAAAAAAAh0STAwAAAAAAAAAAOCSaHAAAAAAAAAAAwCHR5AAAAAAAAAAAAA6JJgcAAAAAAAAAAHBINDkAAAAAAAAAAIBDamB0AMARNGjAV6U+MJlMMplMRscAAAAAAAAAYCN+uQVskJCQICcnLnyqy95++21du3ZNL730ktFRUEvS0tI0f/58o2MAAAAAAADgNtDkAGwQEhIiZ2dno2OgBq1du1ZFRUUaM2aM0VFQS2hcAgAAAAAAOD5+4QEAAAAAAAAAAA6JJgcAAAAAAAAAAHBINDkAAAAAAAAAAIBDoskBAAAAAAAAAAAcEk0O3JFMJlOZj7LWt2zZUmfPnrV5HFSMc3Xn4L0oG+cFAAAAAAAAJWhy4I5kNptlNptten3y5EmFhYXp+vXrFY5z6xiQAgMDFRgYaLWsonNUVj1qTlU+r476HtmTm+8xAAAAAAAAStDkgMPz9/fXZ599ptdff93oKHecyv7a/caNG7px44bN45VXz1/V3znsfU9vV3W997WdGwAAAAAAAHVDA6MDALcrMTFRAwYM0Jw5c9SrVy8NHTrU6EgOY+fOnTVaj9rnqO+Ro+YGAAAAAACAsbiSAw6vX79+mj17tsxms8aNG6djx44ZHQkAAAAAAAAAUAtocqBOePnllzVq1CgVFBQoODhYhYWFRkeqduVNtlzR8ltrIiIiKt2uKvsvbz9lTfyekJBgqW/btm2duNXV+fPnNW3aNLVr105ubm7y9vZW7969NX36dKWnp1vq7H0Pb5aZmalRo0bJy8tLHh4eeuKJJ3Tw4EGbxzlz5owmTZqkli1bytXVVS1atFBkZKROnz5dqrawsFAxMTHq1q2b3N3d5ebmpo4dOyoqKkp79uyx2t+t+775M2arinJnZGRoyJAh8vDwkJeXl0aNGqXMzEy79wEAAAAAAIC6iSYH6owVK1aoffv2+vrrr/X73//e6DjVrrzJlm1ZXjLp+rJlyyrd7nb2f+t+zGaztmzZIklq1qyZrl69qtDQUEv9a6+9pqFDhzr8RNLh4eGKjY3VlClTlJeXp+zsbK1YsUJHjx5Vjx49LHX2voc3i4yM1LRp05SVlaV169bpq6++Up8+ffTzzz9XOk5OTo66d++ujz76SMuXL1d+fr4SEhKUmpqq3r17q6CgwFJ74cIFBQYGavbs2Zo8ebKOHj2q3NxcLVmyRNu3b1evXr3K3F9ZnzFblZf7yJEj6tu3r7755hutX79eJ0+e1LRp0xQZGWn3PgAAAAAAAFA30eRAneHl5aXk5GQ1bNhQcXFxWrFihdGRIGnAgAHq2rWrsrOzra7ikKSFCxdqypQpBiWrPp9//rkkqUWLFnJ3d5erq6s6dOigxYsXV9s+oqKi1K9fP3l6emrAgAGKiYnRuXPnFB0dXem2M2fO1PHjxzV79mwFBQXJw8NDgYGBWrBggY4dO6Z58+ZZaqOjo7Vv3z69+eabioiIkJ+fnzw8PPToo48qPj6+2o7HFtHR0SooKNDcuXPVv39/eXh4qF+/foqKiqrVHAAAAAAAALhz0eRAndKlSxe98847kqTJkydr//79BieCJE2bNk2StGDBAsuyrVu36saNG3rssceMilVtgoODJUljxoxR69atFRERodWrV8vHx6farlIJDAy0el1y3lJTUyvddsOGDZKkwYMHWy3v16+f1XpJSkpKkiSNHDmy1DjdunWr1atuNm/eLEnq37+/1fK+fftW+75iY2M1fvx4TZw4Ua+99pr+7//+T59++qlOnTpV7fsCAAAAAABA9aHJgTonPDxckZGRunLlikJCQqxuxQNjhIWFqVmzZtq/f7+2bt0qSXr77bfrxFUckrR8+XIlJycrODhYFy9eVFxcnMaOHauAgIBqa7R5e3tbvfbx8ZEknT17ttJtz5w5I0lq3ry51fwXJWMcOXLEUpudnS1J8vf3r5bctyM3N1fSf4+1xK2vq8vZs2d19OhRbdiwQdHR0RoyZIhatGihFi1aKCIiQikpKbp+/XqN7BsAAAAAAABVQ5MDddLChQv14IMP6siRIwoPDzc6TrUpmZi5uLjYsuz8+fNGxbGZq6urZZ6Ut956S0ePHtXu3bv1zDPPGJys+owePVpJSUnKzc3V9u3bNWjQIGVmZmrChAlWdVV9D2+tKWkA+Pr6Vrqtn5+fJCk/P98yd8bNj0uXLpWqLWl2GKmkmVFyrCVq4jM/depUffLJJ9q8ebO++eYbnT17VufOndPWrVv1/PPPKyMjQyNGjNC9996rRYsWWb1/AAAAAAAAMA5NDtRJd911l5KSktS4cWOtX7/e6DjVpuSv62/+Afrrr78ut75Ro0aSfvlB/fLlyzX2F/C27CcqKkqNGjXSxo0b9Yc//EERERFq2LBhjeSpbSaTSVlZWZIkJycnBQYGKjExUZJ08OBBq1p738MSu3fvtnpdMqF7UFBQpduW3Hpq27Ztpdbt2LHDajLxkltvffzxx6Vq9+zZYzWRulSzn7GSY/vss8+slt96LmrKPffco9/97nf685//rN27d+vQoUMaNWqUZsyYod/+9rfcDg8AAAAAAOAOQJMDdVbbtm21atUqy1/O1wUDBw6UJM2bN0/nz5/XDz/8oGXLlpVb36VLF0lSenq6NmzYYPVjdnWyZT9NmjRReHi4zGazNm3apOeff75GshglIiJCGRkZunr1qnJycjR37lxJ0qBBg6zq7H0PS8yZM0e7du3SxYsXtXXrVr3yyitq3LixTROPR0dHKyAgQJMnT1ZSUpLy8vJ04cIFpaSkaPz48YqJibGq7dy5s15//XUtXbpUOTk5unjxojZt2qRnn31Ws2fPthq7Jj9j0dHRuueee/SnP/1JW7du1cWLF7Vr1y7NmTOn2vZhj/bt22vBggXKyMiQn5+fevXqZZnDBAAAAAAAAAYxA7XAycnJ/OGHH9pcL6nMR0Xry/Paa69VuL4iSUlJZknma9euVWn76nb27FnzU089Zfb19TW7u7ubhw0bZs7MzCz3POzdu9fctWtXc6NGjcw9e/Y0Hzp0yLLO1nNb2fLK9nOzw4cPm52cnMyhoaHVcTqqVWhoqHn06NFV2vbLL780h4eHm9u2bWt2cXExe3l5mbt27WqeNWuW+dKlS1a19ryHNy/LyMgwBwUFmT08PMzu7u7mwYMHm7///vtSWcr7PuTn55tffPFF869+9Suzi4uL2c/Pzzxs2DDz7t27S9VeuHDB/Nprr5k7dOhgdnV1NXt7e5uDgoLM27dvL1Vr63tfkYo+WwcOHDAPHjzY7O7ubvbw8DAHBQWZMzIybPruV+Z2vt/Xrl0zv/DCC2YXFxfz+vXrq5wBAAAAAAAAt+U9k9lsNtdM+wT4L2dnZ8XHxys0NNToKHZJTk5WSEiIrl27JmdnZ6PjOLwbN26oZcuWWrt2rXr27Gl0HCthYWEqKipScnKy0VGq7Pr162rQoIFcXFxUVFRkdJw73u1+v81msyIjI7VmzRp99dVXateuXQ2kBAAAAAAAQAWWcrsqALXmk08+UatWre64BocjM5lMysvLkySdPn1akhQQEGBkpHrDZDJp0aJFatOmjV544QWj4wAAAAAAANRLNDkA1CiTyaQ9e/bo3LlzeuONN/TnP//Z6Eh1zttvv60LFy4oNjZWkjR58mSDE9Ufbm5uio2N1caNG7Vjxw6j4wAAAAAAANQ7NDkA1LhevXopICBAQ4cO1fDhw42OU6d88MEHWrt2rXx9fZWSkqKFCxdq0qRJRseSyWSy6VEX/O53v1PPnj31t7/9zegoAAAAAAAA9U4DowMAqNuY9qdmhYWFKSwszOgYpdS3933ChAmaOnWqrly5ooYNGxodBwAAAAAAoN7gSg4AAG7TkCFDdOXKFW5ZBQAAAAAAUMtocgAAcJtatmyp1q1b66uvvjI6CgAAAAAAQL1CkwMAgGpw//3364cffjA6BgAAAAAAQL1CkwMAgGrQokULnTp1yugYAAAAAAAA9QoTjwM2SEpKkpMTPcG67MSJE7p27ZrWrFljdBTUkrS0tGodz9vbW/v376/WMQEAAAAAAFAxmhyADUJDQ42OgFpgMpn05JNPGh0DDur69etydnY2OgYAAAAAAEC9QpMDsMG1a9f48bKOCwsLU1FRkZKTk42OglqSnJyskJCQahuvuLhYrq6u1TYeAAAAAAAAKsf9dwAAqAZFRUU0OQAAAAAAAGoZTQ4AAKrBpUuX5ObmZnQMAAAAAACAeoUmBwAA1eDYsWNq06aN0TEAAAAAAADqFZocAABUg59++kn33nuv0TEAAAAAAADqFZocAADcpsuXL+v06dNq37690VEAAAAAAADqlQZGBwAA2M5kMlmem81mA5PgZkeOHJHZbFa7du2MjgIAAAAAAFCvcCUHADgQGht3pn379snNzU333Xef0VEAAAAAAADqFZocAHAbTCaT1dUVqJ/27Nmjhx56SK6urkZHAQAAAAAAqFdocgAAcJt2796tXr16GR0DAAAAAACg3qHJAQDAbbhw4YK+//57mhwAAAAAAAAGoMkBAFV0822qSm5bFRERYVWzZcsWDR8+XI0bN5abm5seeOABJSQklBrr/PnzmjZtmtq1ayc3Nzd5e3urd+/emj59utLT0yvM8dBDD1n2bzKZFBoaWqVjKXmcOHFCI0aMkKenp/z8/PTMM88oLy+v1Da2HtvNY586dUrBwcHy9PSUt7e3wsPDdf78ef38888aPny47r77bvn7+2v8+PEqKCgoNdaZM2c0adIktWzZUq6urmrRooUiIyN1+vRpu4+5uuzevVvXr19Xjx49DMsAAAAAAABQX9HkAIAqunkScLPZLLPZrGXLllnVDBw4UM7Ozvrxxx91+PBh+fj4KCwsTJs2bbKqCw8PV2xsrKZMmaK8vDxlZ2drxYoVOnr0aKU/nqekpKhz58764x//KLPZXGajwZ5jeeWVVxQTE6OsrCwFBwcrPj5e06dPL7WNrcd289h//OMf9b//+7/KyspSWFiYVq5cqaefflovvvii5s6dqxMnTmj06NF6//33NWPGDKtxcnJy1L17d3300Udavny58vPzlZCQoNTUVPXu3bvMpkht+Oc//6nOnTurefPmhuwfAAAAAACgPqPJAQA1bMGCBfLx8VHr1q21cOFCSdKsWbOsaj7//HNJUosWLeTu7i5XV1d16NBBixcvrnDs48ePKzAwUGFhYYqJiamWvM8995w6deokLy8vS6MhNTW1zFpbju1mERERlrFfffVVSdInn3yiKVOmlFq+ceNGq21nzpyp48ePa/bs2QoKCpKHh4cCAwO1YMECHTt2TPPmzbvtY6+KjRs3asiQIYbsGwAAAAAAoL6jyQEANchsNqtt27aW1wEBAZKk77//3qouODhYkjRmzBi1bt1aERERWr16tXx8fKyuhLjZoUOHFBgYqKZNm1oaA9XhgQcesDwvuTohOzu7VJ2tx1be2P7+/hXu89SpU1bbbtiwQZI0ePBgq+X9+vWzWl8VYWFh8vLyko+Pj7p166aQkBC9+eablltRlefYsWM6dOhQqUwAAAAAAACoHTQ5AKCGFBQU6NVXX1WnTp3k6ekpk8mkBg0aSFKpOS6WL1+u5ORkBQcH6+LFi4qLi9PYsWMVEBCg/fv3lzn+7373O+Xl5WnXrl364IMPqi23p6en5bmrq6sklWq02HNs5Y3t5ORU4fJb93nmzBlJvzRBbp7nw8fHR5J05MgR2w/yFlOmTNH8+fP15ptv6vHHH5fJZNLSpUvVu3dvtWvXTvPmzVNhYWGp7VJSUnT33XerT58+Vd43AAAAAAAAqo4mBwDUkCeffFJz5szR2LFjdfz4ccu8HeUZPXq0kpKSlJubq+3bt2vQoEHKzMzUhAkTyqxftGiR5XZWkydPVlZWVo0cR1nsPbbq4OfnJ0nKz8+37O/mx6VLl6o8ds+ePRUREaFJkyZpzpw5WrNmjTIzM3Xw4EHLVR3dunXTN998Y7XdJ598ooEDB8rFxeW2jg0AAAAAAABVQ5MDAG5Do0aNJEnFxcW6fPmy5aoCSdq5c6ck6aWXXlKTJk0kSVevXi1zHJPJZGlSODk5KTAwUImJiZKkgwcPlrlNcHCwJkyYoBEjRqigoEATJkyo8UZDCXuOrbqMHDlSkrRt27ZS63bs2KFevXpV+z47duyo+fPnKyMjQ/7+/urfv7+l0ZGXl6etW7dabjUGAAAAAACA2keTAwBuQ5cuXSRJ6enp2rBhg9UP7YGBgZKkOXPmqKCgQPn5+RXOnREREaGMjAxdvXpVOTk5mjt3riRp0KBBFWZ477335Ovrqy1btlgm/65p9h5bdYiOjlZAQIAmT56spKQk5eXl6cKFC0pJSdH48eOrbeL1srRq1UqffvqpunTporCwMBUWFmrt2rVycXHRsGHDamy/AAAAAAAAqBhNDgC4DYsWLVLXrl0VFBSk2NhYzZ8/37Ju5cqVGjdunOLi4uTn56dHHnlEPXr0sKw3mUyW519++aX8/f01dOhQeXp6qkOHDtq4caNmzZqlDz/80FJ3zz33WG2flJQkPz8/nT17VpI0depUmUwm7du3z67juDmLLc/tObbqeu7j46O0tDSFhYVpxowZatasmQICAvTee+8pPj5ejzzyiF3HbC83Nzf94x//UGZmppYuXarExEQNGTJEHh4eNbpfAAAAAAAAlM9krq17m6Bec3Z2Vnx8vEJDQ42OYpfk5GSFhITo2rVrcnZ2NjoOalBYWJiKioqUnJxsdBTUkqp+v59//nlt3bpVR44c0YcffqiQkJAaTAkAAAAAAIAKLOVKDgAA7DBy5EgdOnRIrq6uGjJkiNFxAAAAAAAA6jWaHAAA2OHhhx+WJPXs2dMy8TwAAAAAAACM0cDoAACAmnHzfBYV4a6F9jl16pQk6aGHHjI4CQAAAAAAAGhyAEAdRfOiZqxYsUJOTk761a9+ZXQUAAAAAACAeo/bVQEAYKNr164pPj5eLi4ucnFxMToOAAAAAABAvceVHAAA2GjDhg06c+aMbty4IV9fX6PjAAAAAAAA1HtcyQEAgI3i4uLUq1cvSVKzZs0MTgMAAAAAAACaHAAA2CAzM1P//Oc/1atXLzk7O+v+++83OhIAAAAAAEC9x+2qUGvefvttrV271ugYdsnKypIkhYaGymQyGZwGNWnPnj26ceOGnnzySaOjoJaUfL9t9c4776hp06ZycXFRhw4d1KhRoxpKBgAAAAAAAFuZzGaz2egQqPumT5+uzMxMo2MAgJXmzZsrNja20rqioiK1bt1aUVFR2rt3rxo3bqxVq1bVQkIAAAAAAABUYClNDgAAKpGQkKBx48bp6NGjevjhhzV9+nRNnz7d6FgAAAAAAAD13VLm5AAAoBJLlizRsGHDlJ+fr5ycHPXv39/oSAAAAAAAABBzcgAAUKH9+/friy++0ObNm5WamiofHx/99u96MBoAACAASURBVLe/NToWAAAAAAAAJHElBwAAFViwYIE6d+6sAQMGKDU1VUFBQXJy4j+fAAAAAAAAdwJ+pQEAoBxnzpzR6tWr9eKLL+rKlSv68ssvFRQUZHQsAAAAAAAA/AdNDgAAyrFo0SLdfffdCgsL06effqri4mI9/vjjRscCAAAAAADAf9DkAACgDFevXtXSpUv1/PPPy83NTQkJCXr00Ufl5+dndDQAAAAAAAD8B00OAADKsHLlShUUFGjixIm6dOmSPv30U40dO9boWAAAAAAAALgJTQ4AAMqwePFiPf300/L399e6detUVFSk0aNHGx0LAAAAAAAAN2lgdAAAAO40mzZt0rfffquVK1dKkhITE/XYY4/J29vb4GQAAAAAAAC4GVdyAABwiwULFuixxx5T165d9e9//1upqancqgoAAAAAAOAOxJUcAADc5NChQ0pNTVVKSookae3atTKbzRoxYoTByQAAAAAAAHArruQAAOAm8+fPV/v27fX4449L+uVWVY8//rjuueceg5MBAAAAAADgVjQ5AAD4j7Nnz2rVqlWaOnWqnJyclJ+fr61bt3KrKgAAAAAAgDsUTQ4AAP5j8eLFatiwocLDwyVJycnJcnZ21tChQw1OBgAAAAAAgLLQ5AAAQNLly5f1t7/9TS+88ILc3d0lSQkJCXriiSfk6elpcDoAAAAAAACUhYnHAQCQtHz5cl2+fFmTJ0+WJGVnZ+uLL77Q6tWrDU4GAAAAAACA8nAlBwCg3rt+/bpiY2M1YcIE+fr6SvplwnF3d3cNHjzY4HQAAAAAAAAoD00OAEC9t2bNGv3888+aOnWqZVlCQoJGjRqlhg0bGpgMAAAAAAAAFaHJAQCo9xYsWKDg4GC1b99eknTs2DGlp6crNDTU4GQAAAAAAACoCHNyAADqtc8++0zp6elauHChZVlCQoK8vb01YMAAA5MBAAAAAACgMiaz2Ww2OgQAAEZ5/PHHVVRUpK1bt1qWdenSRX379tXf/vY3A5MBAAAAAACgEku5kgMAUG999913Sk1N1SeffGJZ9sMPP+i7777T4sWLDUwGAAAAAAAAWzAnBwCg3vrLX/6i+++/X48//rhlWXx8vJo3b66+ffsamAwAAAAAAAC24EoOAEC9lJWVpcTERC1btkwmk8myPDExUWFhYXJy4u8AAAAAAAAA7nT8ggMAqJfeeustNW3aVKGhoZZlX331lX788UeNHTvWwGQAAAAAAACwFU0OAEC9c+7cOS1btkzTpk2Tq6urZfm6devUunVrPfTQQwamAwAAAAAAgK1ocgAA6p133nlHJpNJERERVsvXr1+v4cOHW92+CgAAAAAAAHcumhwAgHrl6tWrWrx4sZ5//nl5eXlZlmdmZuqbb77RsGHDDEwHAAAAAAAAe9DkAADUK++//77y8/P1wgsvWC3fsGGD3N3d9cgjjxiUDAAAAAAAAPaiyQEAqDfMZrNiY2P1zDPPqHnz5lbrNmzYoMGDB+uuu+4yKB0AAAAAAADsRZMDAFBvfPzxx/rhhx/04osvWi0vLCzUF198oSFDhhiUDAAAAAAAAFVBkwMAUG/89a9/1bBhw/TrX//aanlaWpoKCwv16KOPGhMMAAAAAAAAVdLA6AAAANSGL7/8Urt27dKOHTtKrdu2bZtatWqltm3b1n4wAAAAAAAAVBlXcgAA6oV58+ape/fu6tu3b6l1X3zxhfr3729AKgAAAAAAANwOruQAANR5hw4dUkpKipKTk0utKyoqUlpamsaNG2dAMgAAAAAAANwOruQAANR58+bNU/v27TV8+PBS69LT03X58mU98sgjBiQDAAAAAADA7eBKDgBAnZaTk6NVq1Zp4cKFcnIq3dvfv3+/mjRponbt2hmQDgAAAAAAALeDKzkAAHXaO++8I09Pz3JvR/Xdd9/pN7/5TS2nAgAAAAAAQHWgyQEAqLOKi4u1bNkyRUZGqmHDhmXWHDhwQJ07d67lZAAAAAAAAKgONDkAAHVWYmKicnJyFBUVVeZ6s9ms77//nis5AAAAAAAAHBRNDgBAnbVo0SKNHj1arVq1KnN9ZmamCgoKaHIAAAAAAAA4KJocAIA6ac+ePUpPT9cLL7xQbs3hw4clSR07dqytWAAAAAAAAKhGNDkAAHXSokWL1K1bN/Xt27fcmqysLLm7u6tJkya1mAwAAAAAAADVpYHRAQAAqG7Z2dlKSkrSu+++W2HdqVOn1Lx581pKBQAAAAAAgOrGlRwAgDpnyZIl8vLyUmhoaIV1+fn58vHxqaVUAAAAAAAAqG40OQAAdUpRUZHee+89TZw4UW5ubhXWXrhwQR4eHrWUDAAAAAAAANWN21UBAOqUxMRE5ebmauLEiZXWXrx4UYWFhVqzZk0tJAOAmuXs7KwhQ4ZU2uAFAAAAgLqEJgcAoE5ZvHixQkJC1LJly0prz507p507d2rHjh21kAwAat6aNWsUEhJidAwAAAAAqDU0OQAAdca//vUvpaena/78+TbVnzt3TmazWR9++GGl83eg7ggLC1NRUZGSk5ONjoJq5uzsrPj4+Hr7fXZ2dta1a9eMjgEAAAAAtYo5OQAAdcayZcvUsWNH9enTx6b6c+fO1XAiAAAAAAAA1CSaHACAOuHKlStKSEjQc889J5PJZNM2+fn5NZwKAAAAAAAANYkmBwCgTkhMTNTly5c1btw4m+rNZrPOnz9fw6kAAAAAAABQk2hyAADqhLi4OI0cOVK+vr421WdnZ6u4uLiGUwEAAAAAAKAmMfE4AMDhHTp0SDt37tQ///lPm7c5fPiwJNl8aysAAAAAAADcebiSAwDg8OLj49WsWTMNGDDA5m0OHz4sT0/PGkxlDJPJVOajrPUtW7bU2bNnbR4H1etOPbcJCQnq0aOHGjduXGHGOzV/VX3yyScaMWKE/P395erqKn9/fw0bNkwff/xxqdrKvmeV1dnzAAAAAABUjCYHAMDhJSQkKCwsTM7OzjZv8+OPP+q+++6rwVTGMJvNMpvNNr0+efKkwsLCdP369QrHuXUMVI878ZyuXLlSYWFh8vb21v79+1VYWKjk5OQya+/E/FVRXFysZ555Rk8//bT69++vvXv36uLFi9q7d68GDBig8PBwBQcH68qVK5ZtKvuelbW8rOfljcN3DgAAAABsR5MDAODQ0tLS9OOPPyosLMyu7Q4fPlwnmxz28Pf312effabXX3/d6CioJZVdHfDWW29JkubPn682bdrorrvu0ujRo+v0D+4vvPCCVq9erS1btmjKlClq1aqVXF1d1apVK02dOlWpqalav369IiMjjY4KAAAAACgDTQ4AgEP74IMPFBAQoAcffNCu7TIyMtShQ4caSuUYEhMT1aBBA82ZM0cpKSlGx8EdoGSumvbt2xucpHakpaXp3Xff1fjx4/XQQw+VWdOjRw89++yzWrVqlXbs2HHb+7SnYVSXm0sAAAAAUF1ocgAAHNb169e1evVqPf3003Ztl5eXp6NHj6p79+41lMwx9OvXT7Nnz5bZbNa4ceN07NgxoyPBYCW3ZHJxcTE4Se1YsmSJJCkkJKTCujFjxkiSli5dWuOZAAAAAAD2ockBAHBYO3fu1OnTpxUaGmrXdnv27JGket/kkKSXX35Zo0aNUkFBgYKDg1VYWGh0pDvS+fPnNW3aNLVr105ubm7y9vZW7969NX36dKWnp1vVnjlzRpMmTVLLli3l6uqqFi1aKDIyUqdPn7Z5f/aMUVhYqJiYGHXr1k3u7u5yc3NTx44dFRUVZfmsSypzAvqIiIgK11d1Emxb89tzXmtCyZUZv/nNbyqs69Kli6Rf/s0BAAAAANxZaHIAABzWunXr1KlTJ7tvO5WWlqaAgAB5e3vXUDLHsmLFCrVv315ff/21fv/73xsd544UHh6u2NhYTZkyRXl5ecrOztaKFSt09OhR9ejRw1KXk5Oj7t2766OPPtLy5cuVn5+vhIQEpaamqnfv3iooKKh0X/aMceHCBQUGBmr27NmaPHmyjh49qtzcXC1ZskTbt29Xr169LLVlTXC9bNmyCtdXZQJse/Lbel5ryqlTpySp0n8LStZnZ2fXeCYAAAAAgH1ocgAAHNaGDRs0fPhwu7fbs2dPrfyA6ii8vLyUnJyshg0bKi4uTitWrDA60h3n888/lyS1aNFC7u7ucnV1VYcOHbR48WKrupkzZ+r48eOaPXu2goKC5OHhocDAQC1YsEDHjh3TvHnzKt2XPWNER0dr3759evPNNxURESE/Pz95eHjo0UcfVXx8fPWeBBvZk9/W82q0kqtY7LmaBQAAAABQO2hyAAAcUkZGhn788UeNGDHCru1u3LihvXv3cquqW3Tp0kXvvPOOJGny5Mnav3+/wYnuLMHBwZJ+mZuhdevWioiI0OrVq+Xj42N1pcOGDRskSYMHD7bavl+/flbrK2LPGElJSZKkkSNHlhqnW7duhkxcbU9+W89rTWnWrJkkKT8/v8K63NxcSVLz5s2tljs5/fI/pa9fv17uttevX7fUAQAAAACqH/8fFwDAIa1fv15Nmza1+4qMr776SgUFBXrkkUdqKJnjCg8PV2RkpK5cuaKQkBCbbq1UXyxfvlzJyckKDg7WxYsXFRcXp7FjxyogIMCqIXTmzBlJv/wYfvNcFj4+PpKkI0eOVLove8YouX2Sv79/9RxoNbAnv63ntaYEBgZKkr799tsK60rWlzRqSnh6ekr6ZW6R8pw7d05333337cQEAAAAAFSAJgcAwCFt3rxZgwcPtvsvpLds2SI/Pz917ty5hpI5toULF+rBBx/UkSNHFB4ebnScO8ro0aOVlJSk3Nxcbd++XYMGDVJmZqYmTJhgqfHz85P0y5UBt85rYTabdenSpUr3Y88YJbV30lwR9p4DW85rTYmKipIkJScnV1i3Zs0aq/oSJfMBHThwoNxtDxw4oPvuu+92YgIAAAAAKkCTAwDgcIqKipSWlqZHH33U7m23bNmixx57jHvrl+Ouu+5SUlKSGjdurPXr1xsd545hMpmUlZUl6ZdbFAUGBioxMVGSdPDgQUtdyW2jtm3bVmqMHTt2WE0EXh57xii53dPHH39cqrasuWcaNWokSSouLtbly5ctV1dUJ3vy23pea0rPnj01ceJErVixQvv27SuzJi0tTStXrtTEiRP18MMPW60bNmyYJFU4j01cXJyeeOKJ6gsNAAAAALBCkwMA4HDS0tJ0+fLlUreOqUxhYaF27dqlxx57rIaS1Q1t27bVqlWraATdIiIiQhkZGbp69apycnI0d+5cSdKgQYMsNdHR0QoICNDkyZOVlJSkvLw8XbhwQSkpKRo/frxiYmIq3Y89Y0RHR6tz5856/fXXtXTpUuXk5OjixYvatGmTnn32Wc2ePdtq7C5dukiS0tPTtWHDBpuaLvay9xzYcl5r0qJFizRmzBgNHDhQCxcuVFZWloqLi5WVlaW3335bgwYN0tixY7Vo0aJS206ZMkW//vWv9fe//12TJ0/WgQMHdPXqVV29elXfffedJk2apL1792rq1Km1ciwAAAAAUB/R5AAAOJzt27erZcuWateund3bXblyRQMGDKihZMYrmf/Alte3rrvZkCFD9Oc//7lmwzqQL7/8Uv7+/ho6dKg8PT3VoUMHbdy4UbNmzdKHH35oqfPx8VFaWprCwsI0Y8YMNWvWTAEBAXrvvfcUHx9vNRfMre9LVca45557tHv3bk2ZMkXz589X69at1bZtW7311luKi4sr9VlftGiRunbtqqCgIMXGxmr+/PmV5rH3uT35bT2vNcnFxUXx8fFatWqVtmzZogcffFDu7u564IEHtHnzZq1atUqrVq2Si4tLqW09PT21e/duvfHGG0pPT1efPn3k7u4uX19fhYeHy9fXV2lpaeXOyVHZ9xUAAAAAUDmT2Ww2Gx0CAAB7DBo0SD4+PoqPj7druxdffFGbNm1SRkaGZZmzs7Pi4+MVGhpa3TFxhwoLC1NRUVGl8zDA8dT373N9P34AAAAA9dJSruQAADicr776qtRcA7bYsGGDRowYUQOJAAAAAAAAYASaHAAAh5KTk6Pc3Fzdf//9dm333Xff6aeffqLJAQAAAAAAUIfQ5AAAOJTvv/9ekuxucqxbt05+fn56+OGHayIWAAAAAAAADECTAwDgUDIyMtS4cWP5+/vbtd369es1YsQIOTnxnz4AAAAAAIC6gl96AAAO5fDhw+rUqZNd25w8eVL79u3T8OHDaygVAAAAAAAAjECTAwDgUPLy8uTr62vXNklJSfL09NSAAQNqKBUAAAAAAACMQJMDAOBQzp8/Ly8vL7u2WbNmjUaOHCk3N7caSgUAAAAAAAAj0OQAADiU8+fP65577rG5/uTJk9q9e7fGjBlTg6kAAAAAAABghAZGBwAAwB4XLlyQh4eHzfVr1qzR3XffrYEDB5Zb8/bbb2vt2rXVEQ8OYM+ePTKbzXryySeNjoJqZjab6/X32Ww2Gx0BAAAAAGodV3IAAByKs7Ozbty4YXN9UlKShg0bprvuuqsGUwEAAAAAAMAIXMkBAHAo7u7uunTpkk21mZmZ2rVrl1555ZUK66ZMmaLQ0NDqiAcHEBYWpqKiIq1evdroKKhmzs7O9fr77OzsbHQEAAAAAKh1XMkBAHAozZs3V1ZWlk21H3zwgRo3blzhraoAAAAAAADguGhyAAAcStu2bfXTTz/ZVPvhhx9q7NixcnV1reFUAAAAAAAAMAJNDgCAQ3nwwQf1/fffV3rLqoMHD+rbb79VWFhYLSUDAAAAAABAbaPJAQBwKH379pXZbNZnn31WYV18fLxatWqlPn361FIyAAAAAAAA1DaaHAAAh9KsWTP16tVLCQkJVstPnjypY8eOWV4nJiYqNDRUTk6O9586k8lkeeC/OC8AAAAAAOBWjvfLDwCg3ouMjFRSUpJOnDhhWRYREaGOHTsqNjZWu3bt0k8//eSwt6oym812bxMYGKjAwMAaSFOz7MldlfNSnzjqZwAAAAAAgNtBkwMA4HDCwsLUqlUrvfzyy5KkoqIibdu2TUVFRXrppZcUEhKie++9V926dTM4ae25ceOGbty4UWv7q64rKmo7d13GuXRsXKUEAAAAAFXTwOgAAADYy8XFRYsXL9aQIUM0dOhQtWzZUoWFhZJ++aH39OnTatCggd577z0999xz9eKHw507dxodoUocNfediHMJAAAAAKiPuJIDAOCQBg8erJdfflnPPfeclixZIldXV8s6s9ms4uJiRUVFadCgQTp58qSBSQEAAAAAAFBTaHIAABxWTEyMnnrqKa1du1ZFRUWl1pvNZm3btk0dO3bUqlWrqn3/58+f17Rp09SuXTu5ubnJ29tbvXv31vTp05Wenm6pK2/CbFsm0s7MzNSoUaPk5eUlDw8PPfHEEzp48KDN45w5c0aTJk1Sy5Yt5erqqhYtWigyMlKnT58uVVtYWKiYmBh169ZN7u7ucnNzU8eOHRUVFaU9e/ZY7e/WfUdERFR+wm5RUe6MjAwNGTJEHh4e8vLy0qhRo5SZmWn3PuqLis7l6dOnNXHiRMtnoGXLloqKilJOTo4BSe88W7Zs0fDhw9W4cWO5ubnpgQceUEJCQqm6m8/xiRMnNGLECHl6esrPz0/PPPOM8vLybmvsW/dTle8UAAAAANRHNDkAAA7LyclJ8+bN0/Xr18utKS4u1qVLlzRu3DiFhISU+UNkVYWHhys2NlZTpkxRXl6esrOztWLFCh09elQ9evSw1JU3YbYtE2lHRkZq2rRpysrK0rp16/TVV1+pT58++vnnnysdJycnR927d9dHH32k5cuXKz8/XwkJCUpNTVXv3r1VUFBgqb1w4YICAwM1e/ZsTZ48WUePHlVubq6WLFmi7du3q1evXmXuz2w2y2w2a9myZZUei63Hf+TIEfXt21fffPON1q9fr5MnT2ratGmKjIy0ex/1RXnn8vTp0+revbtSUlK0cuVK5eXl6f3339e6devUo0cPGh2SBg4cKGdnZ/344486fPiwfHx8FBYWpk2bNlnV3XyOX3nlFcXExCgrK0vBwcGKj4/X9OnTq2Xs2/lOAQAAAEB9RJMDAODQtm7dWmmzoGT9+vXr1aFDB23YsKFa9v35559Lklq0aCF3d3e5urqqQ4cOWrx4cbWML0lRUVHq16+fPD09NWDAAMXExOjcuXOKjo6udNuZM2fq+PHjmj17toKCguTh4aHAwEAtWLBAx44d07x58yy10dHR2rdvn958801FRETIz89PHh4eevTRRxUfH19tx2OL6OhoFRQUaO7cuerfv788PDzUr18/RUVF1WqOuuD111/XiRMnLOfy5s/R8ePHNXPmTKMj3hEWLFggHx8ftW7dWgsXLpQkzZo1q9z65557Tp06dZKXl5dmzJghSUpNTa2WsQEAAAAA9qHJAQBwaJs3b1aDBg1sqi0uLlZ+fr6GDx+uiRMn6sqVK7e17+DgYEnSmDFj1Lp1a0VERGj16tXy8fGx6SoNWwQGBlq9fuyxxySV/4PqzUqaOYMHD7Za3q9fP6v1kpSUlCRJGjlyZKlxunXrVm3HY4vNmzdLkvr372+1vG/fvrWWoa5ISUmRVPpclnyOStbXZ2azWW3btrW8DggIkCR9//335W7zwAMPWJ43b95ckpSdnV0tY1eHvXv36tVXX9W7776rTZs2acuWLfrXv/6ln376yeoKLgAAAACoC2z7VQgAgDvUxo0bVVxcXGq5i4uLnJycZDabdf36dcstrUp+rI+Li9Ozzz57W/tevny5hg4dqg8++EBbt25VXFyc4uLi1Lp1a61bt06//e1vb2t8SfL29rZ67ePjI0k6e/ZspdueOXNG0n9/hL3VkSNHLM9LfqD19/evUs7qlJubK+m/x1ri1teoXMnnpLxzWfIZqa8KCgr0l7/8RR999JGysrJ08eJFy7qKbm3n6elpee7q6iqp9C3Dqjp2dVi9erX++te/lrve2dlZ3t7eatmypdq0aaM2bdqobdu26tSpk7p06XJH/DsAAAAAALaiyQEAcFjXrl1TQUGBXF1d1ahRIxUUFOjBBx9UmzZt5OvrK29vbzVp0qTc/2vrFSAVGT16tEaPHq0bN25o586dmjVrljZt2qQJEybo66+/ttSZTCaZzWYVFxfLxcVF0i8Tl1fm/Pnz8vLysrwuaQD4+vpWuq2fn59Onjyp/Px8NW7cuNLarKwsZWdnW/3luRF8fHyUk5Oj3NxcqwaNLecL1po2bapTp06VOpcln6OmTZsaFe2O8OSTT2rz5s2aOXOm/vCHP6hJkyaSVOYE7nfS2JWZN2+eZs6cqW+//VZffvml1q5dq7S0NPXs2VOTJk2Sq6urcnNzlZmZqePHj2vXrl364IMPLE0vX19fde3aVd27d1efPn3Up08fq3+HAAAAAOBOwu2qAAAOq0GDBrpw4YKuXr2qp556Sl27dtW+ffuUnJysJUuWaNasWXrppZc0fvx4DR8+XH369FGnTp3UtGnTamlwmEwmZWVlSfplEvTAwEAlJiZKkg4ePGhVW/KX0Tff0ubmJkh5du/ebfV6y5YtkqSgoKBKty259dS2bdtKrduxY4fVZOIlt976+OOPS9Xu2bPHaiJ1SWrUqJH0/+zdd1RU1/428GfovUgHG4lYiYK9xB5FY+wS0ahoMBIl9m78GXNzrTcaS0xMEDWJFbBFYuzxKkZFY4kCxgKIovTe23n/8DIvQ5OBgTMzPJ+1Zjlz5px9noOMzp7v7L3xegqw7OxshY6yKLm2CxcuyGwv+7OgNxs+fDiA8j/Lkt+jkucbqqtXrwIAFi5cKC1C5OXlidK2ol9TRkZG6NmzJ5YsWYLr168jODgYWVlZmDlzJuLi4vDZZ59h48aNOHz4MG7cuIG4uDgkJCTg/PnzWLFiBRo3boyjR49i2LBhsLCwgIuLC5YuXYorV65IR8YREREREREpAxY5iIhI5RUXF+PYsWPSD+rr0/Tp0xEaGoq8vDzExcVhw4YNAAA3NzeZ/QYNGgTg9Tes09LS8PDhQ+zateuN7a9btw5//vknMjMzcfHiRSxfvhzm5ubVWnh89erVcHJygo+PDwIDA5GUlISMjAwEBQVh6tSpWL9+vcy+zs7OWLVqFXx9fREXF4fMzEycOXMGU6ZMwdq1a2Xabt++PQAgJCQEJ0+elCmY1Nbq1athZmaGZcuW4eLFi8jMzMSff/6JdevWKewcDcWXX36JZs2aSX+WGRkZ0t+jZs2aVev3SJ2VrHmzbt06pKamIjk5GStWrBCl7bp8TQFAr1698Ndff2H58uVYuHAhZs6cWa5YYWlpiYEDB2LevHnYs2cPwsPDERcXh4CAAPTr1w/Hjh1Dnz59YGNjgylTpuD3339nwYOIiIiIiMQnEBERqbhLly4JAISwsDC5j9XQ0BAOHjxYo/MGBwcLnp6eQvPmzQVtbW3B1NRU6NChg7BmzRohKytLZt+EhARh4sSJgpWVlWBoaCgMHz5ciI6OFgBIbyVKbwsNDRUGDx4sGBkZCYaGhsLQoUMrvM6ybZRITk4WFixYIDg6Ogra2tqCjY2NMHz4cOHatWvl9s3IyBBWrlwptGrVStDR0REsLCyEwYMHC5cvXy63782bN4UOHToIBgYGQvfu3YV//vlH7p9f6essm/3BgwfC0KFDBUNDQ8HIyEgYPHiwEBoaWun+8vDw8BDGjBlT4+OVUVU/y9jYWMHb21uwt7cXtLS0BHt7e2HGjBlCbGysSGnrjryv57i4OGHy5MmCtbW1oKOjIzg7OwuHDx9+4+uyOtvlaVsQFPOaqu71nzhxQtDX1xfGjBkj5ObmynWOhw8fCv/5z3+Enj17ChKJRLC1tRXmzZsn3L9/X+68RERERERECvCjRBDKrJJIRESkYubOnYvz588jNDRU7mM1NTWxf/9+eHh41EGy+lFUVAQtWCD1OAAAIABJREFULS1oa2sjPz9f7DhKb8KECcjPz8eRI0fEjkIKpg6v59qQ5/qDg4MxfPhwDBkyBAcOHKjRWiFPnz7Fvn378Msvv+Dp06cYMGAA5syZg+HDh0NDgwPGiYiIiIioXviy90FERCrv999/x4gRI8SOUa8kEgmSkpIAALGxsQAAJycnMSMRkQp59913ceLECRw9erTG05a9/fbb+OKLL/D48WP8/vvv0NXVxZgxY9CyZUvs2bMHhYWFig1NRERERERUARY5iIhIpT179gyPHz+WrnnRkGzduhUZGRnYsmULAMDHx0fkRESkSvr06YPvvvsOX331Ffbv31/jdiQSCYYMGYJTp04hPDwc/fr1g7e3N1q3bo29e/dy3Q4iIiIiIqpTLHIQEZFKO3v2LAwMDNCrVy+xo9SrAwcO4OjRo7CyskJQUBC2bduGmTNnih0LEomkWjciUg5eXl6YN28eZs6cicjIyFq317JlS+zatQv//PMP+vXrhxkzZqBz5864dOlS7cMSERERERFVgEUOIiJSaefOnUPfvn2hq6srdpR6NWHCBDx48AC5ubkIDw/H7NmzlaJ4IAhCtW5EpDzWrVsHR0dHTJ48WWGjLhwdHbFr1y78/fffsLOzQ//+/eHu7o4XL14opH0iIiIiIqISLHIQEZFKu3z5MgYMGCB2DCIilaWrq4uff/4ZN2/exObNmxXaduvWrXHq1Cn89ttvuHfvHpydneHr68tiJxERERERKQyLHEREpLKio6MRFxeHrl27ih2FiEildejQAV988QVWrVqFqKgohbf//vvv4969e5gxYwZmzpyJ9957D8+fP1f4eYiIiIiIqOFhkYOIiFTWX3/9BQ0NDbi4uIgdhYhI5S1evBjNmjXD4sWL66R9fX19bNy4EdeuXUNsbCxcXFxw4sSJOjkXERERERE1HCxyEBGRyvrrr7/QsmVLmJiYiB2FiEjlaWtrY9OmTQgMDKzThcK7dOmCmzdvYvTo0Rg9ejTmzp2LgoKCOjsfERERERGpNxY5iIhIZT148AAdOnQQOwYRkdoYNmwYhgwZgvnz5ytsEfKKGBgYYNeuXdi3bx92796NQYMGITExsc7OR0RERERE6ksicNU/IiJSUZ07d8bAgQOxYcOGGrehoaHBBXAbIIlEwr93NdTQ/14lEgkOHDgADw+PWrUTHh6Od955B7/88gsmTJigoHSV+/vvvzFy5EhIJBKcOHEC77zzTp2fk4iIiIiI1IavltgJiIiIaurly5ews7OrVRsSiQRz5sxBr169FJSKlN3WrVtRWFiIhQsXih2FFMzDw6NBv55rW9wo0aZNG4wfPx5fffUVxo8fDw2Nuh383b59e4SEhGDcuHHo3bs3Tpw4gb59+9bpOYmIiIiISH2wyEFERCqpqKgI8fHxsLe3r3Vb3bt3h7u7uwJSkSo4evQo8vPz+Xeuhjw8PBr061lRRQ4AWLlyJZydnXHkyJF6+XlaWVnh3LlzmDJlCtzc3LBv3z6MGzeuzs9LRERERESqj2tyEBGRSsrNzUVRURGMjIzEjkJEpHbatGkDd3d3fPnllyguLq6Xc+ro6GD//v34+OOP4eHhgX379tXLeYmIiIiISLVxJAcREakkAwMDaGhoICsrS+woRERqaeXKlejQoQOCgoIwYsSIejmnpqYmvvvuO5iYmGDq1KkAgEmTJtXLuYmIiIiISDWxyEFERCpJIpHAwMAAmZmZYkchIlJLzs7OGDJkCLZt21ZvRY4S69evhyAImDp1KjQ0NDBx4sR6PT8REREREakOTldFREQqy9zcHElJSdLH9+7dEzENEZH6mT17Ni5cuID79+/X+7k3bNiAefPmwdPTE7/99lu9n5+IiIiIiFQDixxERKSynJ2dcffuXQDAf//7X7i4uMDd3R0ZGRkiJ1MsiUQivRGRYuXm5mLlypV4++23oaWlxddaGW5ubmjdujW+++47Uc7/n//8B56ennB3d0dwcLAoGYiIiIiISLmxyEFERCqrT58+OHv2LAoLC3H48GFoaWnhxIkTcHFxQWhoqNjxFEYQBLEjEKmtL774AmvWrMHHH3+M9PR0nDlzRuxISkUikWDWrFn4+eefkZycLMr5d+7ciffeew+jRo3CkydP6j0DEREREREpNxY5iIhIZX344YdISkrCsWPHEBAQgMLCQhQUFCA6OhodO3bE7t276+S8/KY3kfo4fPgwAGDmzJkwMDDA4MGDWVgsY+rUqdDU1MQvv/wiyvm1tLRw+PBhODo6YvTo0VyLiYiIiIiIZLDIQUREKuutt96Cu7s7Fi1ahMTEROn2wsJC5Ofnw8vLC5MnT0ZOTo6IKYlImT1//hwA0KhRI5GTKC9jY2OMHz8efn5+omXQ19fH0aNHER8fj8mTJ7MQRUREREREUixyEBGRStu4cSMSExOhra1d4fOHDh1Ct27dEBkZWc/JiEgVFBcXix1BJUybNg3379/H7du3RcvQpEkTHD16FKdOncKGDRtEy0FERERERMqFRQ4iIlJpjRs3hr6+PgoKCip8vrCwEA8fPoSrqyt+//33Wp+v9DRVJdNWTZ8+XWaf8+fPY8SIETA3N4eenh46duyIQ4cOlWsrLS0N8+fPx1tvvQU9PT1YWFigZ8+eWLRoEUJCQqrM0blzZ5kFyT08PGp0LSW358+fY+TIkTA2NoaNjQ0mTZqEpKSkcsdU99pKt/3y5UuMHTsWxsbGsLCwgKenJ9LS0hAVFYURI0bAxMQEtra2mDp1KlJTU8u1FR8fj5kzZ6Jx48bQ0dGBg4MDZsyYgdjYWLmvmai0il7Py5Ytk3lcdmq66myv7uspNzcX69evh6urKwwNDaGnp4fWrVvj008/xfXr1+vgimuuZ8+eaN26Nfbs2SNqjl69emHjxo34/PPPFfJvOhERERERqT4WOYiISKUFBwdX+OFhaQUFBcjIyMCwYcOwbNkyFBUV1fh8padIEQQBgiBg165dMvsMGjQImpqaePz4MR49egRLS0tMmDCh3ILGnp6e2LJlC+bOnYukpCS8evUKe/bsQUREBLp161ZljqCgIDg7O2Pp0qUQBKHCQoM817J8+XKsX78eL168wNixY7F//34sWrSo3DHVvbbSbS9duhT//ve/8eLFC0yYMAE///wzPvroIyxYsAAbNmzA8+fPMWbMGPz0009YsmSJTDtxcXHo2rUrjh07ht27dyM5ORmHDh3C2bNn0bNnzwqLIkTVVdHref369eWeq+yYyrZX5/WUkZGB3r17Y+3atfDx8UFERAQSExOxc+dOXL58GT169Kjt5Smcp6cnDhw4gLy8PFFzzJ07F56envjoo4/w9OlTUbMQEREREZESEIiIiFTY7NmzBR0dHQFAtW6amprCu+++K7x69UoQBEHQ0NAQDh48KNc5S9qq6vnIyEjp4/DwcAGA0Lt3b5n9TExMBABCQECAzPaYmJhy7Zc+Z1RUlNCiRQthzZo1cuWuLCsA4dKlS9JtkZGRAgDB3t6+wv2rc22VtV1ybWW3P3/+XAAgODg4yLTh7e0tABD8/Pxkth89elQAIKxYsULua/bw8BDGjBkj93Gk/BT9eq7suTdtr87racGCBQIAYcuWLeXauX37dpX/xlSmJtcvj5iYGEFTU1Pw9/evs3NUV3Z2tuDq6ip069ZNKCgoEDsOERERERGJ50eO5CAiIpVVXFyMw4cPIz8/v9rHFBUVITg4GC4uLoiIiKiTXIIgoHnz5tLHTk5OAICwsDCZ/caOHQsAcHd3R9OmTTF9+nT4+/vD0tKy0m+L//PPP+jduzesra2xYsUKhWXu2LGj9L69vT0A4NWrV+X2q+61Vda2ra1tled8+fKlzLEnT54EAAwdOlRme58+fWSeJ1Im1Xk9BQYGAgBGjRpV7nhXV9daLax948YN+Pj44JdffkFOTk6N2ynL3t4eAwYMqNHIMUXT19fHgQMH8Pfff0tH3xARERERUcOkJXYAIiKimsrOzoaenh7MzMxgaGgo3a6vrw89PT3pYzMzM2hqagIANDU1YWFhAU1NzXJz6itCamoqNm7ciGPHjuHFixfIzMyUPld2Wq3du3fjgw8+wIEDB3Dx4kX4+fnBz88PTZs2xYkTJ+Di4lKu/f79+yMtLQ3Pnz/HgQMHMHHiRIXkNjY2lt7X0dEBUH5aHnmurbK2NTQ0qtxe9pzx8fEA/v8HxWVxqhpSRtV5PZUUPUoX/hTpwYMH8PPzw7p163D69Gk0bdpUIe1++OGHmD17NtLT02FiYqKQNmuqdevWWLt2LRYvXgw3Nzd06dJF1DxERERERCQOiVCbr4kRERGpOE1NTezfv1+uhbtLiiMV/Rc6ePBgnDt3Dl988QXmzJmDRo0avfEY4PWolKtXr2LNmjU4c+YMXFxccOfOnXLnDAwMRHp6Oj7++GOYmZnh/v37aNy4cbWzV/daKtou77UpYnvjxo0RExOD5ORkmJub1+AKy5swYQLy8/Nx5MgRhbRHykPRr2cNDQ0IgoD8/Hxoa2sDANLS0mBmZlbhMfL8bjdp0gQvXrxAZGSkzOio2ih7/TExMRg6dCisrKxw4cIFhZwjJSUFtra22L17Nz766COFtFkbxcXFeO+99xAbG4vbt2/LFLiJiIiIiKhB8OV0VURERHIyMDAA8HpB8+zsbFhaWkqfu3r1KgBg4cKF0iJAZYv0SiQSvHjxAsDrD1N79+6Nw4cPAwDCw8MrPGbs2LGYNm0aRo4cidTUVEybNq1W09rIQ55rU5SSqXwuXbpU7rkrV64o5eLMpD5KRlmUnmqqdPGxNkqmqzt+/Hi5565fv45u3brV+hwODg7Ytm0bLl68iEePHtW6PQAwNzfHwIED4e/vr5D2aktDQwO7d+9GTEwMVq1aJXYcIiIiIiISAYscREREcmrfvj0AICQkBCdPnpT5oL13794AgHXr1iE1NRXJyclVrp0xffp0hIaGIi8vD3FxcdiwYQMAwM3NrcoMP/74I6ysrHD+/Hls27attpdULfJemyKsXr0aTk5O8PHxQWBgIJKSkpCRkYGgoCBMnTqVc/FTnRo0aBAA4D//+Q/S0tLw8OFD7Nq1SyFtr169Gs7Ozli1ahV8fX0RFxeHzMxMnDlzBlOmTMHatWsVcp5evXpBW1sbd+/eVUh7wOspq06fPo2UlBSFtVkbzZs3x+bNm7Fp0yYEBweLHYeIiIiIiOoZixxERERy2r59Ozp06IDBgwdjy5Yt2LRpk/S5n3/+GZMnT4afnx9sbGzQt29fmW9kl14HJDg4GLa2tvjggw9gbGyMVq1a4dSpU1izZg0OHjwo3a9kapyS4wMDA2FjY4OEhAQAwLx58yCRSHDr1i25rqN0lurcl+faFHXf0tISN27cwIQJE7BkyRLY2dnByckJP/74I/bv34++ffvKdc1EpZX9vSu7Ts+mTZswceJEHD58GA4ODliyZAnWrVtX6fHy3DczM8O1a9cwd+5cbNq0CU2bNpV+WO/n54eBAwcq5Bq1tbWhr68vs4ZObZWMsDp58qTC2qwtLy8vDB06FJ988gny8/PFjkNERERERPWIa3IQEVGDVpM5/Em1cU0O9dXQX88VXX9eXh4MDAxw5MgRaXFCEYYMGQIjIyMEBgYqrM3aio6ORps2bbB69WosXrxY7DhERERERFQ/uCYHEREREZG6unPnDoqLi9G6dWuFtjt8+HCcOXMGubm5Cm23Npo2bYolS5bgX//6F2JiYsSOQ0RERERE9YRFDiIiIiIiNXX27Fk0btxY4UWOUaNGISsrC3/88YdC262tZcuWwc7OjiM5iIiIiIgaEBY5iIiI1EjJugJvuhFRw/Dbb7/Bzc1N4e06ODjAxcVFqdblAABdXV18/fXXOHjwoNIVYIiIiIiIqG6wyEFERKRGBEGo1o2I1N/NmzcREhKCKVOm1En7I0aMwIkTJ5Tu35QRI0Zg2LBh+Oyzz1BQUCB2HCIiIiIiqmMschARERERqaGvv/4anTp1Qp8+feqk/REjRuDly5e4c+dOnbRfG1u2bEFERAR++OEHsaMQEREREVEdY5GDiIiIiEjN3LlzB0eOHMGiRYvq7Byurq6ws7PD6dOn6+wcNdWiRQvMmjUL//rXv5CRkSF2HCIiIiIiqkMschARERERqZHi4mLMmjULPXr0wPjx4+vsPBKJBIMGDcLZs2fr7By1sXz5cuTl5WHr1q1iRyEiIiIiojrEIgcRERERkRr55ptvcPv2bezcuRMSiaROz+Xm5oY///wT6enpdXqemrC0tMTChQvx9ddfIykpSew4RERERERUR7TEDkBERCS2GzduQFNTU+wYVE+eP3+OwsJCBAQEiB2FFEwQBFy/fr3Bvp4FQcC9e/fw9ddfY82aNWjXrl2dn3Pw4MEoKirCpUuXMGLEiDo/n7wWLFiA7777Dhs2bMDGjRvFjkNERERERHVAIgiCIHYIIiIisTRr1gzR0dFixyAiqjUNDQ3o6+tj3Lhx2Lt3b72dt1OnTujevTt27NhRb+eUx9atW7Fs2TI8evQITZo0ETsOEREREREpli+LHEREREREKu6PP/7A6NGj0a1bN/z666/Q1dWtt3OvWLECAQEBePz4cb2dUx55eXlo1aoV3Nzc8MMPP4gdh4iIiIiIFMuXa3IQEREREamw48eP4/3338eAAQNw4sSJei1wAK/X5Xjy5AkiIiLq9bzVpauri1WrVmHPnj0cuUdEREREpIZY5CAiIiIiUlF79uyBu7s7vLy8EBgYCD09vXrP0KNHDxgYGODSpUv1fu7qmjx5Muzt7fH111+LHYWIiIiIiBSMRQ4iIiIiIhUjCAJWr14NLy8vrF69Gt9++y00NMR5a6+jo4MePXrgjz/+EOX81aGtrY2FCxfC19cXr169EjsOEREREREpEIscREREREQqJDU1FaNHj8aaNWvg6+uLzz//XOxI6NevHy5evCh2jCp98sknMDc3x/bt28WOQkRERERECsQiBxERERGRirhz5w46d+6MW7du4Y8//oCXl5fYkQAA/fv3x8uXL/HkyROxo1RKT08Ps2fPxo4dO5Camip2HCIiIiIiUhAWOYiIiIiIVMDPP/+MXr16oUmTJrh16xbeffddsSNJde3aFYaGhko9ZRUA+Pj4QFNTEzt27BA7ChERERERKQiLHERERERESiwtLQ2TJk3CtGnTsHjxYpw/fx62trZix5Khra2NXr16KfXi4wBgYmICHx8fbN26FdnZ2WLHISIiIiIiBWCRg4iIiIhISf36669o164dzp07h1OnTuHLL7+Epqam2LEq1K9fP6UvcgDAnDlzkJmZiZ9++knsKEREREREpAAschARERERKZn4+HhMmTIFI0eORM+ePfHgwQO4ubmJHatK7777Ll6+fIlnz56JHaVKVlZWmDRpEr755hsUFxeLHYeIiIiIiGqJRQ4iIiIiIiUSEBCAdu3a4cKFCzh+/Dj8/f1hZWUldqw36ty5M3R0dHDt2jWxo7zRvHnz8OTJE5w+fVrsKEREREREVEsSQRAEsUMQkWpKSUlBfn4+srKykJWVhfz8fABAZmYmCgoKAAAZGRkoLCwEAKSnp6OoqKjS9krvW8Lc3FzmsZmZGSQSifSxiYmJzLQdRkZG0NbWlj42NDSEjo6OzPM6OjowMzOT93KJiIjq1J07d7Bo0SJcunQJn332GdasWQMjIyOxY8mlS5cu6NmzJ7Zu3Sp2lDdyc3ODIAg4e/as2FGIiIiIiKjmfLXETkBE9S85ORnx8fFIS0tDamoqUlNTkZaWhpSUFJnHJX/m5eUhNTUV+fn5yMzMlCloyKNsAaIsbW1tmQ9zioqKkJ6eLn1cXFyMtLQ0uc9bGV1dXRgYGMDY2Bg6OjowNTWtcJuenh709fUr3GZiYgJtbW2YmprK3EoXVoiIiKry7NkzrFy5EgcOHECXLl1w9epVdO/eXexYNdKjRw+VGMkBvB7N8f777+Pvv/9G+/btxY5DREREREQ1xJEcRGoiOTkZMTExiI6OxqtXrxAXF4eEhAQkJiYiLi4O8fHx0scloyxKaGhowNTUFObm5jAzM4OZmRlMTU2l90tGPujo6MDIyEg6OqL0Nn19fejp6QEADAwMoKurC6D8SApFS0lJkXmcmpqK0v+slR09kp6ejvz8fKSnpyM3Nxc5OTlIT09HQUEB0tLSqtyWkZGB/Px8aeEnOzu70lx6enrlCh/m5uYwMTGR2Vb6ccnPu2QbCyVEROotJSUFa9euxbfffgsHBwesXbsW7u7uMiMWVc3Bgwfh6emJ1NRUGBgYiB2nSoIgoF27dujVqxd8fX3FjkNERERERDXjyyIHkQooLCxEdHQ0nj59isjISMTExODZs2eIiYnBixcvEB0dLfOBu7GxMWxtbWFlZQVLS0tYW1vDxsZG+tjGxgbW1tYyH6pTzWRkZKCgoEA66iUtLQ3p6enS+6VvpfcpvV9mZmaFbevr60uLIxYWFmjUqJHMnyW3stv19fXr+adARETySE9Px/fff4+NGzdCQ0MD//d//4dPP/1ULYrbUVFRcHR0xJUrV/Duu++KHeeNdu7cifnz5yM6Olol1j0hIiIiIqJyWOQgUhYFBQWIiIjAkydP8PjxYzx9+hRPnz7FkydPEBUVJR19YWpqisaNG6Np06ZwcHCo8L6qzd/d0BUVFVVYBCm5paSkICkpCcnJyTJ/JiUllRvJArwujpQtflhaWlZaKLGysoKFhYUIV05E1LDExsZi69at+P7771FcXIzPPvsMS5cuhampqdjRFMre3h7z58/H4sWLxY7yRtnZ2WjcuDGWLl2KpUuXih2HiIiIiIjkxyIHkRhevnyJsLAwhIaG4q+//kJYWBjCwsKQk5MD4PVi22+99ValN6LScnJykJKSgpSUFLx69QovX76UPq7sFhsbi7L//Jubm8POzg7m5uYwNzeHvb19pY9tbW2hoaEh0hUTEamWiIgIbN26Fb6+vjAyMsKsWbMwZ84cNGrUSOxodWLMmDEAgKNHj4qcpHrmzp2LoKAgPH78mP+3ERERERGpHhY5iOpSUVERQkNDcfPmTYSEhODevXsICwtDRkYGAKBZs2Zo164d3nnnHTg7O6Nt27ZwcnKCsbGxyMlJ3eXm5iI5ORmJiYmIj4+XWbOlZA2XxMREJCQkIC4urtyC7zo6OtLpz0pPjWZlZQVbW1uZ+7a2tpxCi4gaHEEQ8Mcff2DHjh04fvw43n77bSxcuBCenp7SNazU1caNG7F582bExsaKHaVawsPD0a5dO5w5cwaDBg0SOw4REREREcmHRQ4iRYqIiJAWNG7evInbt28jKysLhoaGcHV1haurK5ydneHs7Ix27dqp3fQUpL7y8/OlRZDY2Fjp/fj4eJlF7ksel11nxNjYGPb29rC2tpYWPqytreHg4CAthtjZ2cHa2hra2toiXSURUe29evUKe/fuhZ+fH54+fYoePXpgwYIFGDNmTIMZJXDlyhX06dMHkZGRaN68udhxqqVPnz6wtrZGYGCg2FGIiIiIiEg+LHIQ1UZYWBguXbqES5cu4b///S/i4+OhpaUFZ2dndO3aFV27dkWXLl3Qtm1baGlpiR2XqN7k5uYiISEBr169QlxcHOLi4vDq1SvEx8fLbHv58iWysrJkjrW0tISNjQ1sbGykhQ87OzvptpJiiZWVVYP5wJCIlFtRURFOnz6NXbt2ISgoCCYmJpg8eTKmT58OZ2dnsePVu5ycHJiZmWHv3r2YMGGC2HGqZf/+/Zg6dSqePXsGe3t7seMQEREREVH1schBJI/w8HBpQePSpUuIi4uDiYkJ+vTpg379+qFHjx5wdXXl1DxEcsjOzsarV68QGxuL+Ph4vHz5EvHx8YiNjZVui4mJQUJCAnJzc6XHaWpqwtraGtbW1m8cJaKu894TkXgEQcD169cREBCAgIAAxMTEoF+/fpg+fTrGjBmj9lNSvUmXLl3Qo0cPbNu2Tewo1ZKXl4cmTZpgzpw5WLlypdhxiIiIiIio+ljkIKpKTk4OLly4gKCgIAQFBSEmJgZGRkbo3bs3+vXrh379+qFTp07Q1NQUOypRg5CamiodEVJSDCk9SuTly5fS6bMKCwulx+nq6soUQ0qPEim9zd7eHoaGhiJeIREps9KFjcDAQDx//hytW7eGu7s7pkyZghYtWogdUWnMmTMH165dw82bN8WOUm2LFi2Cv78/IiMj+d6OiIiIiEh1sMhBVFZMTIy0qHHhwgXk5uaiU6dO+OCDD+Dm5obOnTtz6ikiJScIgnRB9ZLpsUoXRkpGjiQkJCA+Pl7mWENDw3LTY1lZWcHOzk46SqSkMKKrqyvSFRJRfcnLy0NwcDCCgoJw5MgRmcKGu7s73nnnHbEjKqWDBw/C09MTqampMDAwEDtOtTx9+hROTk44efIkhg0bJnYcIiIiIiKqHhY5iAAgOjoaBw8ehL+/P+7cuQMDAwO89957+OCDDzBs2DDY2dmJHZGI6khBQUG56bFKT5lVepRIRkaGzLGNGjUqV/ioqBhibW3N9UOIVEhERAROnz6N06dP4+LFi8jKykLbtm0xduxYFjaqKSoqCo6Ojrh8+TJ69+4tdpxqGzhwIAwNDfHrr7+KHYWIiIiIiKqHRQ5quJKTkxEQEID9+/cjODgYjRo1wrhx4zBy5Ej079+/wc+lTUTl5eTkSAsfCQkJ0umxShZRL73tTeuHVFQMsbW1hbm5uYhXSNQwpaSk4OrVqzh79ixOnz6Nx48fw8TEBAMHDoSbmxuGDBmCZs2aiR1T5djY2GD58uWYN2+e2FGqzd/fHxMnTsTTp0/5d05EREREpBpY5KCGJTc3FydOnMCBAwdw+vRpaGlpYeTIkZg4cSLc3Nygra0tdkQiUhNpaWnl1gqpzvohenp6sLKygoODQ4WLqZfepipTwBB0O30xAAAgAElEQVQpm6ioKAQHB+Pq1asIDg5GWFgYBEGAi4uLtKjRs2dPvi+opcGDB8Pe3h579+4VO0q1FRQUoFmzZvjkk0/w5Zdfih2HiIiIiIjejEUOahiioqKwc+dO+Pn5ITU1FYMGDcLEiRMxatQoGBkZiR2PiBqw0uuHVFQMKVlTJC4uDomJiTLHGhkZVVoMsbKygqWlpXQbCyLUUGVkZODu3bu4ffs2rl27huDgYMTExEBHRwedO3dGr1690Lt3b/Ts2RMWFhZix1UrS5cuxZkzZ3D37l2xo8hl+fLl+Omnn/Ds2TMWuoiIiIiIlB+LHKS+iouLce7cOezYsQO//fYb7Ozs4O3tjU8++QS2trZixyMiklt+fn65wkfpxdRLb8vKypI51sDAQFoMsbS0hJWVFWxsbGBtbQ0rKytYWVnB1tZWep8f7JEqSklJwe3bt3H79m3cuXMHt2/fxuPHj1FcXAwLCwt069ZNWtTo0qULp6asYyWLj6enp6vUzzoyMhItWrTAkSNHMGrUKLHjEBERERFR1VjkIPWTmZmJXbt24bvvvsOTJ0/Qv39/zJo1CyNHjoSWlpbY8YiI6kV2djYSEhIQGxuLhIQEJCYmyowIKf1cQkIC8vPzZY5v1KiRtABiaWkJOzs76f2S7RYWFtKbKn2ASaovOTkZ4eHhCA8Px8OHDxEWFobw8HBERUUBAOzs7NCxY0e4urqiY8eO6NixI9dXEMHDhw/Rpk0b/PXXX+jYsaPYceQyZMgQSCQS/P7772JHISIiIiKiqrHIQeojIyMD3377LTZv3oy8vDxMmTIFPj4+aNOmjdjRiIiUXmpqqnSNkMTERMTGxiI+Ph6JiYmIj49HbGystDiSkJCAsm8fDA0NYWFhIR0lUroAUnIr+xyn0KKqpKWlITIyUnp79OgR/vnnH4SGhiIhIQHA6ynbWrVqhTZt2qBNmzZwcXGBq6sr7OzsRE5PwOtRtaamptiyZQu8vLzEjiOX48ePY+zYsXjy5AkcHR3FjkNERERERJVjkYNUX1paGrZt24YtW7agsLAQc+bMwbx58zivNhFRHREEAYmJiUhKSip3S0xMlD5Xdp+ioiKZdvT19WWKICUFEDMzM5iZmcHU1BTm5ubSxyXbzMzMoKOjI9LVkyIUFhYiPj4eMTExiI2NRXR0NCIjIxEVFSUtaqSkpAAAJBIJ7Ozs4OTkhNatW6N169Zo27YtWrVqhaZNm0IikYh8NVSVHj16oHPnzti+fbvYUeRSWFiIZs2awcvLC//617/EjkNERERERJVjkYNUV1paGjZv3oxt27YBAObOnYu5c+fC3Nxc5GRERFSRlJSUKosjCQkJSE5ORmpqqsytIgYGBtKCR9kCSMnN3NxcZpupqSkMDAxgbGwMIyMjrjuiYLm5ueWKXSUjgUqKGSV/xsXFobi4WHpso0aN4OjoKL01b95c5j6nQ1Nds2bNwv3793HlyhWxo8ht+fLl2LdvH6KioqCpqSl2HCIiIiIiqhiLHKR6iouL4efnh5UrV6KwsBDz58/H7NmzYWpqKnY0IiKqA6ULHmlpaZU+Lvtcya30h+mlaWpqwsTEBEZGRtDT04OJiQkMDQ2hr69f4X09PT2YmprK3DcwMICuri5MTEykH4IaGhpKR5ro6+sr9Qf0ubm5yMnJkf5Zcj89PR0ZGRnIzMxERkYGUlNTkZGRIbMtJSVFplBVdrF7iUQCCwsLWFtbw87ODvb29uX+tLW1hYODA/T19UX6CVBd+/HHH7Fw4UKkpaVBQ0ND7DhyiYiIQIsWLRAUFIT3339f7DhERERERFQxFjlItVy5cgVz587FgwcPMGvWLHzxxRccuUFERFVKT0+XFkFycnKQnp6OrKws6f3MzEzpB/tV3c/JyZF+yF9QUCB3Dl1dXek6JNra2jAyMgLw/4stJWrz/5ogCOVGv2RnZyMvLw8AkJ+fj6ysLOTl5SE7O/uN7WlpacHY2Bjm5ubSETDGxsbSbY0aNYKlpWWFa7BYWFhwKilCSEgIunXrhkePHsHJyUnsOHLr168fLCwscOTIEbGjEBERERFRxXy1xE5AVB3R0dFYsmQJ/P39MWjQINy7d48LihMRUbWYmJjIFBEUobCwUKbgkZqaKl2MPT09Xbr+SOmCSMkoCQAyRYaCggJkZmYCAIqKipCenl6rbKampjLfmC9dXCkpWpQUWUr+1NHRgaGhoXTfkoIGR1hQbbVv3x5aWlq4c+eOShY5vLy88PHHHyM2Nha2trZixyEiIiIiogpwJAcpteLiYmzduhUrV66Eg4MDNm3ahOHDh4sdi4iIiIiqydnZGSNGjMDatWvFjiK3nJwcODg4YPny5Vi8eLHYcYiIiIiIqDxf1ZoYlxqUqKgoDBgwAEuXLsXy5cvx4MEDFjiIiIiIVIyrqyvu3r0rdowa0dfXx4QJE7Br1y7wu2FERERERMqJRQ5SSgEBAejYsSMSExNx7do1rFy5UrqIKxERERGpDhcXF9y+fVvsGDXm7e2NR48eITg4WOwoRERERERUARY5SKnExsZi+PDh8PDwwPTp0/HXX3+hU6dOYsciIiIiohpycXFBXFwcYmNjxY5SI+3bt0fHjh3h5+cndhQiIiIiIqoAixykNP7880+4urriwYMHuHjxIjZu3AhdXV2xYxERERFRLbi4uAAA7ty5I3KSmvPy8oK/vz9SU1PFjkJERERERGWwyEFKwdfXF/3790fXrl1x79499O3bV+xIRERERKQAFhYWaNq0Ke7duyd2lBr76KOPIJFIcOjQIbGjEBERERFRGSxykKgKCwuxbNkyeHt7Y/78+Th27BhMTEzEjkVERERECtSuXTuEhYWJHaPGTE1NMXbsWE5ZRURERESkhFjkINEkJSXBzc0NO3bsgL+/P9avXw8NDf5KEhEREambtm3bqnSRA3g9ZdWtW7dw9+5dsaMQEREREVEp/ESZRBEdHY1u3bohMjISV69exbhx48SORERERER1pE2bNggPD0dxcbHYUWqsT58+cHJy4mgOIiIiIiIlwyIH1buIiAj06dMHRkZGuH79Otq3by92JCIiIiKqQ23btkV2djaePXsmdpQak0gk8PLywr59+5CdnS12HCIiIiIi+h8WOahePXr0CH379kWjRo1w/vx5WFtbix2JiIiIiOpYu3btIJFI1GLKqpycHAQEBIgdhYiIiIiI/odFDqo3Dx8+RP/+/WFra4vz58/D0tJS7EhEREREVA9MTEzg4OCA0NBQsaPUiqWlJUaMGIEffvhB7ChERERERPQ/LHJQvQgLC0Pfvn3x9ttv4+LFi2jUqJHYkYiIiIioHrVt2xbh4eFix6g1b29vXLt2jQuQExEREREpCS2xA5D6e/XqFQYOHIiEhATEx8fDxMRE7EhEVM/s7e3x4sULSCQSsaMQEZFI2rZtiz///FPsGLU2YMAAtGzZEn5+fti+fbvYcVRWs2bNEB0dLXYMIlIDmpqauHDhAvr27St2FCIiEgmLHFSnsrOzMWrUKACAIAg4dOgQNDQ4gEgeW7duRWFhIRYuXCh2FLU3fvx4zJkzB7169RI7ilq5ceMGNm3ahOLiYmhqaoodh4iIRNKmTRvs2rULgiCodNFbIpFg+vTpWLNmDdavXw9DQ0OxI6mkFy9eYN68eejZs6fYUVRKyfsq9quUG/sV9Wv8+PF49eqV2DGIiEhELHJQnSkqKsLEiRMRERGB1atX47PPPsO4ceP4Iaecjh49ivz8fLi7u4sdRe15eHige/fu/FkrGDvgREQEvB7JkZmZiefPn6Np06Zix6mVadOm4f/+7//g7++PadOmiR1HZXXr1o3vu+RU8r6K/Srlxn5F/fLw8BA7AhERiYyfPFGdWbRoEc6dO4fffvsNtra2YschIiIiIhG1a9cOwOu12lSdpaUlRo8eje+//17sKEREREREDR6LHFQnjh07hq1bt8LX1xddu3YVOw4RERERiczc3By2trYIDQ0VO4pC+Pj44ObNmwgJCRE7ChERERFRg8YiBylcdHQ0pk+fjhkzZmDixIlixyEiIiIiJdG2bVuEh4eLHUMh3n33XXTq1Anffvut2FGIiIiIiBo0FjlIoQoKCuDh4QEHBwd88803YschIiIiIiXSrl07tZiuqsTMmTNx+PBhxMXFiR2FiIiIiKjBYpGDFOrzzz/HgwcPEBgYCH19fbHjEBEREZESadOmDUJDQyEIgthRFGLixIkwNjbGrl27xI5CVCmJRCK9EREREakjFjlIYUJCQrB582Zs3rwZLVu2FDsOERERESmZtm3bIj09HS9fvhQ7ikLo6+vj448/xnfffYeCggKx4xBVSF2KikRERESVYZGDFCI/Px9eXl7o27cvvLy8xI5DdUiZvwWmzNmIiIjo9XRVANRm8XHg9QLkcXFxOHHihNhRiEShbu/B1e16iIiIGgIWOUghvvrqK0RERODHH3/kG0IiIiIiqpClpSWsrKzUZvFxAGjWrBmGDRuG7du3ix2FiIiIiKhBYpGDau3+/fvYsGED1q9fj7ffflvsOERERESkxJycnPDkyROxYyjU/PnzcfnyZVy/fl3sKEREREREDQ6LHFRrCxYsQIcOHeDj4yN2FColPj4eM2fOROPGjaGjowMHBwfMmDEDsbGx0n1KL0JYegTO+vXrK9xe9r5EIsH06dMrbO/p06cYM2YMzM3Ny7Vz/vx5jBgxAubm5tDT00PHjh1x6NChCq8jNzcX69evh6urKwwNDaGnp4fWrVvj008/lfkg4U3ZiIiISDk4OTnh8ePHYsdQqH79+qFbt2745ptvxI5CVKXo6GiMHj0apqamMDIywrBhwyocWVWdvgSg2Pfg1e0jlO5zPH/+HCNHjoSxsTFsbGwwadIkJCUl1aptRV0PERER1R8WOahWfv31V5w/fx6bN2+GhgZ/nZRFXFwcunbtimPHjmH37t1ITk7GoUOHcPbsWfTs2ROpqakAXi9C+OOPPwIAdHV1ERISAgAYNWoUrK2tcfnyZZmFCsveFwQBu3btqvD5mTNnYtGiRXj58iVOnTolk2/QoEHQ1NTE48eP8ejRI1haWmLChAk4c+aMzH4ZGRno3bs31q5dCx8fH0RERCAxMRE7d+7E5cuX0aNHj2pnIyIiIuXQokULtRvJAQDz5s3DkSNH8PTpU7GjEFVqxowZmD9/Pl68eIETJ07g9u3b6NWrF6KioqT7VLcvASj2PXh1+wilz7l8+XKsX78eL168wNixY7F//34sWrRIIW2zT0FERKRCBKIays/PF1q2bCmMHz/+jfsGBgYKAITCwsJ6SPYagApvFT3v4OAgxMfHV7ud+uTh4SGMGTNGrmO8vb0FAIKfn5/M9qNHjwoAhBUrVshsnzlzpvTnEBoaKrRo0ULYu3dvhW2/6WdQ8vwff/xR5T6RkZHSx+Hh4QIAoXfv3jL7LViwQAAgbNmypVwbt2/fLpejtn8/GhoawsGDB2t8vDyCgoKEESNGCDY2NoK2trZgY2MjfPDBB8KxY8fK7fum3+U37SfPrS6I8fonIiLldejQIUFTU1PIy8sTO4pCFRYWCm+99ZYwZ84csaOohPp83yUI6tM3qOn7qpKsZd9r7t27VwAgeHp6SrfJ25dQ1M+hun2E0ue8dOmSdFtkZKQAQLC3t1dI27VR37/fgtCw+hdlifHzJiIipfIjv3pPNbZjxw5ER0dj/fr1YkepkPC/b95U53FMTAwmTJiAoqKiKtsp24ayOnnyJABg6NChMtv79Okj83yJrVu3ok+fPoiJiYGLiwvc3d3h6elZqwxdu3at9DlBENC8eXPpYycnJwBAWFiYzH6BgYEAXo8sKcvV1VUl/i7KKigowKRJk/DRRx9hwIABuHnzJjIzM3Hz5k0MHDgQnp6eGDt2LHJycqTHvOl3uaLtFd2vrB1V+b0mIiL14OTkhKKiIplvjqsDTU1NzJ49G7t27apwuhwSV0PuG5TWu3dvmcfvvfceAODs2bPSbfL2JRSlun2E0jp27Ci9b29vDwB49eqVQtpWFexfEBERcboqqqHMzEysWbMGc+fOlXmzqKpsbW1x4cIFrFq1SuwoChEfHw/g9Rv90nPWWlpaAkC5aRS0tbXh7+8PfX19FBUVYfLkybXOYGBgUOH21NRUrFixAm3atIGxsTEkEgm0tLQAoNwHAiUdFFtb21rnURazZ8+Gv78/zp8/j7lz56JJkybQ0dFBkyZNMG/ePJw9exa//vorZsyYIXZUIiKiOtGiRQsAULt1OQDgk08+gb6+Pn744Qexo1AtqFvfoDQLCwuZxyX9g4SEBOk2efsSiiBPH6E0Y2Nj6X0dHR0AKPfhek3bVhXsXxAREbHIQTW0Y8cO5ObmYuHChWJHUYjDhw9DS0sL69atQ1BQkNhxas3GxgYAkJycXO7bNIIgICsrq9wxW7ZsgaamJoqLizFu3LgK91GEDz/8EOvWrcP48ePx7NmzKr/lU3IdFX0bSxXduHEDP/zwA6ZOnYrOnTtXuE+3bt0wZcoU7Nu3D1euXKn1OeX5BhW/bUVERPXBxMQE1tbWarkuh6GhIT755BNs375d5lvTpFrUrW9QWlpamszjxMREAICVlZV0W036ErUlTx9BmdoWG/sXREREr7HIQXLLysrC5s2bMXv2bJk3w6qsT58+WLt2LQRBwOTJkxEZGSl2pFopmd7p0qVL5Z67cuWKzILdAPDTTz8hMDAQYWFhaNeuHcLCwuDt7V1h2yUjNAoKCpCdnS39Rld1Xb16FQCwcOFCNGrUCACQl5dX4b5jx44FABw/frzcc9evX0e3bt0Umq2u7dy5EwAwbty4Kvdzd3cHAPj6+tZ5JiIiIjE4OTmp5UgO4PV7nMzMTI7mUGHq1jco7dq1azKPz58/DwAYPHiwdJu8fQlFvAeXp49Q120re5+iNPYviIiIXmORg+T2/fffIysrC/Pnzxc7ikItXrwYo0ePRmpqKsaOHYvc3FyxI9XY6tWr4eTkBB8fHwQGBiIpKQkZGRkICgrC1KlTZdZRuXz5MpYsWYKTJ0+iSZMmCAgIgKGhIfbv34/vv/++XNvt27cHAISEhODkyZPlOjlvUjIP8Lp165Camork5GSsWLGi0utwdnbGqlWr4Ovri7i4OGRmZuLMmTOYMmUK1q5dq9Bsda3km1PvvPNOlfuVXEdJh4yIiEjdqHORw9LSEt7e3tiwYQOys7PFjkM1pE59g9LWrVuHP//8E5mZmbh48SKWL18Oc3NzrF69WrqPPH0JQDHvweXpI9R128repyiN/QsiIqL/qcFq5dSA5eTkCDY2NsKSJUvkOi4wMFAAIBQWFtZRssoBEKr6VS/9XGpqqtCiRQsBgODl5VXpfvXJw8NDGDNmjNzHJScnCwsWLBAcHR0FbW1twcbGRhg+fLhw7do16T4lPxsAwtixY4U7d+7IbKvoZ3fz5k2hQ4cOgoGBgdC9e3fhn3/+qbC9yn7ucXFxwuTJkwVra2tBR0dHcHZ2Fg4fPlzpMRkZGcLKlSuFVq1aCTo6OoKFhYUwePBg4fLly+XaripbdWhoaAgHDx6U6xh56OvrCwCEvLy8KvfLzc0VAAj6+voy29/0u1x6vzc9X5+/z2K+/omISDn9+9//Ft566y2xY9SZ2NhYwcDAQNiyZYvYUZRWXb/vqoyq9w1q8r6q9Pvs0NBQYfDgwYKRkZFgaGgoDB06VAgLCyt3THX6EiVq+x5cEOTrI1TW36hsu7z9D0VcT339fjfU/kVZYv17QkRESuNHiSBwkkSqvr1798Lb2xvPnj2TazHoI0eOYNy4cSgsLISmpmYdJixPIpEAqHw+UIlEIvPc33//je7duyMnJwe7d+/GtGnTKtyvvkyYMAH5+fk4cuRIvZ+7odHU1MT+/fvh4eFRJ+0bGBggJycHeXl50oURK5Kfnw9dXV0YGBjIzHn8pt/l0vtVtU9121EUMV//RESknPz9/TFx4kRkZ2dX+X+iKlu4cCEOHDiAiIgI6Ovrix1H6dT1+67KqHrfgO+rVEN9/X431P5FWWL9e0JERErDl9NVkVx27NgBd3d3uQocqqZ9+/bSaZp8fHxw9+5dkRORurCzswPwehHHqpQsAGlvby+zXUPj9T/ZRUVFlR5bVFQk3Y+IiEhZOTk5oaioSK3WOihryZIlSE9P5xz4Ko59A1Jm7F8QERG9xv+pqNquXbuGW7duwcfHR+wodc7T0xMzZsxATk4Oxo0bh9TUVLEjkRoomQ/477//rnK/kuf79Okjs93Y2BgAkJaWVumxKSkpMDExqU1MIiKiOufk5AQAarsuBwDY2NjA29sb69evR05OjthxqBbYNyBlxf4FERHRayxyULXt2LEDrq6uSr3wmiJt27YNnTp1wtOnT+Hp6Sl2HFIDn376KQC8ceqxgIAAmf1LtGrVCgDw4MGDSo998OABWrZsWZuYREREdc7IyAg2NjZ48uSJ2FHq1JIlS5CWloZvv/1W7ChUS+wbyE8ikVTrRjXH/gUREdFrLHJQtSQlJSEwMBCfffaZ2FHqja6uLgIDA2Fubo5ff/1V7DikBrp37w5vb2/s2bMHt27dqnCfGzdu4Oeff4a3tze6dOki89zw4cMBAHv27Kn0HH5+fhg2bJjiQhMREdURJycntR7JAQC2trZYtGgR1q5dK50uhlQT+wbyEwShWjeqOfYviIiIXmORg6olICAAmpqa+PDDD8WOUq+aN2+Offv28RtGpDDbt2+Hu7s7Bg0ahG3btuHFixcoKCjAixcvsHXrVri5uWH8+PHYvn17uWPnzp2Ltm3bYu/evfDx8cGDBw+Ql5eHvLw83L9/HzNnzsTNmzcxb948Ea6MiIhIPk5OTmo/kgMAFi9eDH19fXz11VdiR6FaYt+AlBH7F0RERCxyUDUdPHgQI0aMgJGRkdhRqq3s8OeqHlc1VPr999/H559/XrdhqcHQ1tbG/v37sW/fPpw/fx6dOnWCoaEhOnbsiHPnzmHfvn3Yt28ftLW1yx1rbGyMa9eu4csvv0RISAh69eoFQ0NDWFlZwdPTE1ZWVrhx40alc+a+6TVBRERUn1q0aKH2IzmA11NzrV69Gt9//z0ePXokdpwGi30DUlfsXxAREQFaYgcg5ff8+XMEBwfj+PHjYkeRy5uGPsszNPqrr77it+9IoYYNG1ajYd8mJiZYtWoVVq1aJfexnA6AiIiUiZOTE549e4a8vDzo6uqKHadOeXl5Yfv27Vi+fPkb586nusG+Aak79i+IiKgh40gOeqMDBw7A1NQUbm5uYkchIiIiIjXh5OSE4uJiREZGih2lzmlqamLDhg04evQorly5InYcIiIiIiK1wpEc9EZHjx7F2LFjoaOjI3aUBismJgYBAQFixyAiIiJSGEdHRwBAVFQUWrduLXKauvf+++9j4MCBWLhwIa5fvw4NDX7fjGouMDCQv0NERERE/8MiB1UpMTERt27dwrJly8SO0qCFhIQ0uEXfxcD5Y4mIiOqPqakpzMzMEBUVJXaUerNlyxZ07NgRO3bswOzZs8WOQyrMw8ND7AhUBfYriIiI6heLHFSls2fPQkNDAwMGDBA7SoM2evRozt9cDzQ1NcWOQERE1KA4Ojo2qCKHs7MzFi9ejM8//xyjR49G48aNxY5EKqqwsJDvXZUY/26IiIjqF8e3UpXOnDmDXr16wdTUVOwoRERERKRmmjdv3qCKHACwatUqODg44NNPPxU7ChERERGRWmCRgyolCALOnj3LBceJiIiIqE40xCKHrq4udu7ciVOnTuHYsWNixyEiIiIiUnksclClHj9+jNjYWE5VRURERER1onnz5oiMjBQ7Rr3r27cvpkyZAh8fH6Smpoodh4iIiIhIpbHIQZUKCQmBjo4OXFxcxI5CRERERGrI0dER8fHxyMrKEjtKvdu0aRMKCwuxfPlysaMQEREREak0FjmoUjdv3kSHDh2gq6srdhQiIiIiUkPNmzcHADx79kzcICKwsLDAt99+ix9++AEnTpwQOw4RERERkcpikYMqFRISgq5du4odg5RMbm4uVq5cibfffhtaWlqQSCSQSCTVPr5kf3mOISIiIvVUUuRoaOtylPjwww8xbdo0TJs2DdHR0WLHIVI49h2IiIioPrDIQRUqKirCvXv30LlzZ7GjkJL54osvsGbNGnz88cdIT0/HmTNn5DpeEIQ6SkZERESqxtjYGBYWFg1yXY4S27Ztg62tLSZNmoSioiKx4xApFPsOREREVB9Y5KAKxcTEICcnB61atRI7CimZw4cPAwBmzpwJAwMDDB48mJ0PIiIiqjFHR8cGO5IDAAwNDeHv749bt25hzZo1YschUij2HYiIiKg+sMhBFSr5Np2jo+P/Y+++w6K43r+PvwGBSAtYQIqKKBoVey8YUaOiYsFubEnsRo2xRU0sURPRLyamGDWKHXtsiIpgxahgLLEriEQEQQQN0ss8f+RhfyFWFJgF7td17SXM7p7z2c1MmJl75hyVkwhtc+/ePQBKlSqlchIhhBBCFAX29vbFusgB4OTkxKJFi5g7dy5Hjx5VO44QeUaOHYQQQghREKTIIZ7r7t27lCxZEisrK7WjCC2TlZWldgQhhBBCFCHF/U6ObGPHjsXNzY0hQ4YQHR2tdhwh8oQcOwghhBCiIEiRQzxXWFgYFStWlAneRA7/Xh+yJwD84osvAHjy5AkTJ07EwcGBd955h9KlS9O8eXMmT55MUFCQWpGFEEIIoeUqVqxYrOfkyKajo8OaNWswNDTE3d2d1NRUtSMJ8Vbk2EEIIYQQBaWE2gGEdoqOjsbGxkbtGELLKIqiOVj571i6Q4YMYc+ePXz//fcMGzYMfX19wsLCmD59Ok2aNJGxd4UQQgjxXJUqVeLRo0ckJCRgamqqdhxVWVhY4OPjQ9OmTRkxYgTr1q1TO5IQb6kvaR0AACAASURBVEyOHYQQQghRUKTIIZ4rKSkJY2PjPG+3X79+cndILp05c4aGDRuqHeOVssePtrW11aw71apV46effmLXrl1qRsuVpUuX8ttvv6kdo0iJiIhQO4IQQggtZm9vD/wzXGqtWrXUDaMFqlWrxsaNG+nWrRvVqlVjxowZakfKN7LflXtFZb+qqBw7vIys3wVHimJCCCFkuCrxXElJSZQsWVLtGKIQ6dmzJwC9e/emQoUKDBs2jG3btlGmTBnZ6RRCCCHEC1WqVAkdHR2Zl+NfOnfuzM8//8yXX36Jl5eX2nGEyHNy7CCEEEKIvCR3cojnSkpKwtLSMs/b3bJlC3p6enneblHWv39/0tLS1I7xSl5eXnTp0gVvb2+OHDnC6tWrWb16NRUqVGDPnj3UrVtX7YivZcKECfTr10/tGEXKzp076dWrl9oxhBBCaKmSJUtiaWkp83L8x8iRIwkPD2fUqFFYWVnRuXNntSPlOdnvyr2isl9VVI4dXkbW74Ij5xiEEELInRziudLS0tDX11c7hihk3N3d2bFjB7GxsZw4cYIOHTrw119/8dFHH6kdTQghhBBazN7envDwcLVjaJ0FCxYwcOBAevXqxeHDh9WOI0SekmMHIYQQQuQVKXKI53r33Xf5+++/1Y4hChEdHR3NGMG6uro4OzuzdetWAK5fv65mNCGEEEJoOXt7exmu6jl0dHRYtWoVvXr1olu3bhw5ckTtSELkCTl2EEIIIURekiKHeK5SpUoRFxendgxRyAwbNoyrV6+SmppKdHQ0Hh4eAHTo0EHlZEIIIYTQZuXLl+fevXtqx9BKurq6rF27lq5du9K1a1cOHTqkdiQh8oQcOwghhBAir0iRQzyXFDnE8+jo6OT4+d+/BwYGUq5cObp06YKpqSnVqlXD19eXBQsWsHnz5he2IYQQQghhZ2cnRY6X0NPTY9OmTfTr14+uXbuyZcsWtSMJ8Upy7CCEEEKIgiITj4vnKlOmDDExMWrHEFpGUZQXPteiRQtatGjxVm0IIYQQoniys7MjJiaGtLQ0DAwM1I6jlfT09Pj1118xMzPjww8/JCYmhvHjx6sdS4gXkmMHIYQQQhQUKXKI56pZsyYRERE8evSI0qVLqx1HCCGEEEIUYeXLlycrK4vIyEjs7e3VjqO1dHR0WLJkCVZWVkycOJHr16/zww8/oK+vr3Y0IYQQQgghVCPDVYnnatCgAYqicOHCBbWjCCGEEEKIIs7Ozg5Ahqx6TdOmTWPHjh1s2LCBjh07Ehsbq3YkIYQQQgghVCNFDvFclpaW2Nra8scff6gdRQghhBBCFHHlypXDwMCAiIgItaMUGj169CAwMJDQ0FDq1atHYGCg2pGEEEIIIYRQhRQ5xAs1adKEkydPqh1DCCGEEEIUcbq6ulhbW8udHLlUt25dzp8/T/369XFxcWHhwoVkZWWpHUsIIYQQQogCJUUO8UJdu3bF39+fv//+W+0oQgghhBCiiLOzs5M7Od5AqVKl2L17Nx4eHsyePRtnZ2du3bqldiwhhBBCCCEKjBQ5xAt17doVXV1dNm/erHYUIYQQQghRxJUvX16KHG9IR0eHzz//nHPnzpGSkkLdunXx9PQkIyND7WhCCCGEEELkOylyiBeysLCgX79+/Pjjj3LbuxBCCCGEyFd2dnYyXNVbqlWrFmfPnmXGjBnMnDmTunXrEhAQoHYsIYQQQggh8pUUOcRLTZkyhRs3bjxzN0fXrl2ZN29ekSx+bNmyhSZNmmBhYYGOjo7m8V8ve04INck6LIQQojCS4aryRokSJfjyyy+5evUqDg4OtGvXjp49e3L9+nW1oxVKsl8lRE6yTQghhNBGJdQOILRb9erVGTJkCFOnTqVz586Ym5tz7do19u3bh4+PD8eOHWPLli2ULVs2X/p3dnYGKLAJ0NevX8+QIUNwdXXl4sWLlCtXjv3799OzZ89nXqsoSoHtsAUFBdGnT58C6as4UxRF7Qhvvc5r6zoshBBCvIqdnR3R0dGkpqZiaGiodpxCr3Llyuzdu5cDBw4wZcoUatWqxYABA5g1axZVqlRRO94bkWOD/9OvXz/Zj9Ni2nBckR+0eZsQQghRvMmdHOKVFi9eTFZWFqNGjUJRFHbs2IG+vj6KonDy5EmcnJwIDAzMl76zsrIK9G6RJUuWAODp6UnFihUxNDTE3d29yO6kCu3ztuu8rMNCCCEKq/Lly6MoCpGRkWpHKVJcXV35888/Wb9+PWfPnqV69er079+foKAgtaPlmhwbCPFm8uqOCtkmhBBCaCu5k0O8UqlSpdiwYQOurq7MmzePLVu2kJ6eDkB6ejqPHj3i/fff56uvvmLWrFno6uZd7ezUqVN51tbruHXrFoDWXd3WuHFjtm3bpnaMIk9PT0/tCG+9zmvrOiyEEEK8ip2dHQARERFUqlRJ5TRFi66uLgMGDKBPnz5s3bqVJUuW0KRJE1q0aMGYMWPo0aMHJUuWzHW7Tk5OWFlZMXnyZDp27JjvV23LscH/2bJli1bsu4rnK6r/bbR5mxBCCFG8yZ0c4rW0a9eOn376iTlz5jwznm9mZiZZWVnMmzcPNzc34uPjVUr59pKTkwHQ19dXOYkQb0bWYSGEEIVVuXLl0NfXl8nH81GJEiX48MMP+eOPPzh+/DiWlpYMGTIEa2trhg8fTmBg4GvfKZGVlcX169c5duwYnTp1okqVKvzyyy8kJibm86coOLJfJUROsk0IIYTQVlLkEK9t5MiR9OnThxIlnn8DUFZWFn5+ftSsWZMzZ868dX8vmqjs38vv3btHt27dMDU1xcrKioEDB/Lo0aM37u95fbzJhGkxMTGMHj0aOzs7DAwMsLW1ZcSIETx48OCNsgnt9O91IzQ0FHd39xwT8GV78OABI0eO1KwPdnZ2jBo1iujo6Be296Z5nteWrMNCCCEKA11dXWxsbGTy8QLSqlUrfvvtNyIiIpg9ezZBQUE4OztjY2PD8OHD8fHx0ZzQfJ74+Pgcw0eFhYUxbtw4LC0tmTBhAuHh4XmaV44NRFH3tscML1v+39cMGzYs1/lkmxBCCKHNpMghcuXmzZtkZma+8PmMjAwePnxIq1atWLp06Vv19aJxPf+9fPr06SxcuJCIiAh69uzJpk2bmDx58lv3pyhKjkduREdH07hxY3bt2oWXlxdxcXFs2bIFPz8/mjdvzuPHj98on9A+/143Ro8ezeTJk4mMjMTX11ez/MGDBzRu3BgfHx/Wr1/Po0ePWLduHXv27KFJkyY5DlredixbWYeFEEIUdnZ2dlLkKGBWVlZMnDiRS5cucfnyZcaPH8+ff/5J165dsbCwoFWrVsyaNQt/f38SEhI07/tv8UBRFDIzM0lKSuKXX36hUqVKdOrUCX9//zzJKccGoijLi2OG11mevQ6vWrUq1xllmxBCCKHVFCFe07179xQdHR0FeK2Hjo6O0q1bN+Xx48fKjh07FEDJyMjIVZ/Zbb1o+bFjxzTLwsLCFECxsbF548/4qv5eZ/nIkSMVQFm9enWO5b/99psCKDNmzMhVpn79+inu7u65eo94M7q6usrmzZtz9Z7sdeDo0aPPfX748OEKoGzYsCHH8rVr1yqAMnLkyOe296a0cR1+0+1fCCFE8dO3b1+le/fuascQiqJERkYq69atUz7++GOlcuXKCqDo6uoqjo6OSu/evZVRo0a98nhAX19fAZTatWsr69atU9LS0jTtv81+14uWF4djA9mvKhxyu37n1TFDbpfnljZuE4ryZv8/EUIIUaSslInHxWvbuXMnenp6ZGRkvNbrFUVhz549NGjQgHHjxuVLpvr162t+trGxASAqKipf+npd+/btA8DV1TXH8latWmmeX7BgQYHnEvmrcePGz13u4+MDQJs2bXIsb9euXY7ntUl+rcMRERGEhYVRvnx5Kleu/PZBhRBCFDnly5fn2LFjascQgLW1NYMHD2bw4MEA3L9/n+DgYC5cuMDFixc5evToK9tIT08H4MqVKwwdOpQpU6YwceJEJk6cmC+Z5dhAvI2UlBTmz5/P5s2bCQ8P14xgoLzl3davozAeM7yp/NwmvvvuO1atWkXp0qWpWLEiRkZGvPPOO8A/cxKZmJhgbm6OoaGh5mFsbIy5uTnm5uaYmZlpht3S09PDzMwMAwMDjI2N3/TjCiGEKCBS5BCv7eDBg69d4Pi30NBQAgIC8iERmJqaan42MDAACmYn9GViYmKA/zuw+q/Q0NCCjCMKiJGR0XOXP3z4EIAyZcrkWJ79e/b6ok3yax0OCgqiT58+ANSoUYNJkybx8ccfv1lIIYQQRZKdnZ1MPK6lbG1tsbW1pXv37gCsXbuWYcOGvXQo22xZWVno6ekRExPDzJkzcXZ2zpeMcmwg3sbs2bNZtGgR8+fPZ+LEiQQGBtKhQ4cC6bswHjO8qfzcJpYtW0ZISAgAJ0+efON2nkdPTw89PT0MDQ0xMDDAxMSEkiVLYmpqirm5OaamppQqVQp9fX3MzMwwNDTEyMgIExMT9PX1MTc3x8LCAgsLC83P5ubm6Onp5WlOIYQorqTIIV7bkiVL+PjjjzV/pAHeffdddHV10dHRwdzcHPjnConsA4zsP+w7d+7UXLFR1FlZWXH//n3i4uKwsLBQO45QmaWlJZGRkcTGxubYkY+NjdU8r23yax12d3cnOjqakJAQNm7cyIgRIzh27Bjr1q1748nWhRBCFC22trY8fPiQ9PR0zf6m0E6xsbHo6em9sMihp6eHjo4OGRkZlClTBhcXF9q1a0eXLl1eeHKzKJJjg8Jj69atwD9z7RkZGdG+ffsCK5Ll9phBR0cHRVFy/L/yyZMnBZL1beXnNnH79m2uXbvGoUOHNAUPGxsbNm7cSFZWFlFRUSQlJZGamkpSUhJPnjwhOjqa6Oho4uPjefz4MU+fPuXp06ckJSWRkpKiaVtRFHR1dTVzDz158uSZi0D19PQwMDBAT09Pc54kKysLRVFITEx87vpkZmb2TOHjecWQfy8rW7YsZcuWzdPvTgghCjspcojXVr16dapXr652DK3XvXt3fv75Z44dO0aPHj1yPHfy5EmmTp3K6dOnVUonCpqbmxsrVqwgICCAQYMGaZZnT8Lp5uamVrQXys912NLSEktLS5o3b07Pnj1xdXWlfv36fPbZZ3kRXQghRCFnbW1NVlYW0dHR2NnZqR1HvMSjR49yXKSgo6ODvr4+aWlpGBkZ0bRpU9q3b0+7du1o0KCBiknVJccGhUf2XWSlSpUq8L5ze8xQrlw5oqKiiIqKokKFCgBcuHDhhe0bGRmRlJREeno66enpVKhQQVNAKWj5vU3UqFGDGjVqMHHiRDw8PPjiiy/4+eef2bFjR67bSktL46+//uLu3buEhYVx9+5dbt26xbVr17h9+zbwT2GjYsWK2NvbY21tjbGxMQYGBsTGxhIWFkZoaKjmuy5RogS2trbY2NhgZWVFqVKlMDU1xdjYmBIlSvD48WPi4+N5+PAht27dIj4+nvj4eOLi4khNTX0mn4WFBdbW1tjY2OT418LCQvOzra2t5oJUIYQoyqTIIUQemzNnDn5+fowdO5bMzExcXFwwMDDg+PHjTJgwAS8vL7UjigI0d+5cDh48yBdffIGtrS2NGjUiODiY6dOnU7FiRebMmaN2xGcU1Drctm1bpk6dysKFCxk9ejSGhoZ50q4QQojC69/zKEiRQ7s9evSItLQ0APT19WnevDkdO3akXbt21K9fH11dXZUTagc5Nig8srKyVOs7t8cMH3zwAevXr2fx4sXMnz+fqKgoVq1a9cL2a9euzZkzZwgKCiIiIoJmzZrl8yd6sYLcJqZNm8aePXvYvXs3iYmJuZ5bw8DAgCpVqlClSpVnnktPTyckJIQrV67wxx9/cO7cOfbv38/jx48pWbIkTZs2pWPHjrz//vvUqFGDiIgIQkNDCQkJITQ0lNDQUIKDg7l//z7wTyHKycmJOnXq0LFjRxo0aEC9evU0x0hJSUmaokdMTAyRkZGaf6Ojo4mKiuL8+fPExMRohj/LZmpqio2NDZaWlpoCi5WVFXZ2dtjb22Nvb4+tra0MnSWEKNxUm/NcFCs7duxQACUjI+O13wPkeLzpcjX6i4uLUz7//HOlUqVKir6+vmJlZaW4ubkpp0+fznWufv36Ke7u7rl+n8g9XV1dZfPmza/9+v+uAy9a7x48eKCMHDlSsbGxUUqUKKHY2NgoI0aMUB48ePDS9nJLW9fhl23/9+7dUwDl0KFDuW5XCCFE0ZOcnKwAyp49e9SOIl5h//79yvTp0xU/Pz8lKSkp1+9/2/2uN12uRn8FtV/1upKTk5Vvv/1WqVu3rmJkZKQYGhoq1apVU0aOHPlMpqioKGXEiBGKra2toq+vr9ja2iojR4586X5sSEiI0qNHD8Xc3PyZ7yM6OloZNWqUpj0bGxtl+PDhSlRU1DM5r1y5ori6uirGxsaKqamp0r59e+Xq1avPfM///e737dunaePHH39UAOXq1auaZRs2bHhlG4Aybdq0N/6Oc7t+K8rrHzMoiqI8fPhQGTBggFK2bFnF2NhYcXNzU/76668XroPBwcFKnTp1FCMjI6Vp06bKzZs3c/2ZtHWbUJSXf9+BgYEKoCxZsuSN2s6NrKws5ebNm8rq1auVIUOGKJUqVVIAzX+jZcuWKWFhYTnek5SUpJw7d05ZvXq1MmHCBKV169aKhYWFAiiGhoZK06ZNlQkTJiibN29W7t+//1o5UlNTlXv37ilBQUHK3r17lV9//VWZO3euMnbsWKVHjx5K8+bNFQcHB8XQ0FDz30dfX1+pVKmS4uLiogwdOlSZM2eOsm7dOuXYsWPK3bt3lfT09Hz4xoQQIs+s1FEUlWdiE8XCzp076dWrFxkZGXJ1QC7179+ftLQ0du7cqXaUIk9PT49NmzbRr18/taMUKa/a/itUqMDYsWOZNm2aCumEEEJoGwsLC7799ltGjRqldhSRj2S/68287XFVQkICbdq04ebNmyxZsgQ3NzeMjY05d+4cY8aM4fr165p5Ax48eEDjxo3JzMxkw4YNNGrUiKCgIAYOHIihoSFnz57FyspK03b28GUffPABc+bMoV69ehw7doxOnTqhKArR0dE0adKElJQU1q9fT/Pmzblw4QKDBg1CV1eX8+fPa4bVCQ0NpWHDhhgZGbFhwwYaN27MpUuXmDZtGqdOnQJyTirfrVs39u7dy/fff8+ECRM0yxs3bkxwcDBffPEF3377rWb5hg0b2LZtW455I7Pz58UpElm/C9arvm89PT26dOnCnj17CjgZhIeHc+jQIQ4cOIC/vz9Pnz6lXr169OnTh969e1O5cuXnvu/27ducOXOGs2fPcubMGf7880/S09OpVq0arVu3xsXFBRcXl7ea41FRFKKiorh79y53794lPDz8mX+z5yUpUaIEdnZ2mqG5/v1wcHDQDJsmhBAq+VWGqxJCCKEqGxubZ26pFkIIUXxZW1sTFRWldgwhiqQ5c+Zw7tw5vv/+e4YNG6ZZ3rp1azZt2kT9+vU1y2bNmsW9e/fYsGEDbdq0Af4ZbnThwoUMHTqU2bNns3z58mf6mDFjBs2bNwfA1dVVUzSYPXs24eHhrF69mvbt2wPg7OzMd999h7u7O4sXL2bBggWanI8fP+bHH3/U9N2iRQtmzJhB586dn+lz6NCh7N27lzVr1miKHDdv3uTy5csAbNq0iW+++UZTyFi7di1jxox5i29SFCaGhoaqzUFSsWJFRowYwYgRI0hLS+PEiRNs27YNT09Ppk+fTsOGDRk6dCgDBgzIMRG7o6Mjjo6OmjlakpKS+P333wkMDOTUqVOsWbOGtLQ0atSogZubG126dKFFixY55kp6FR0dHWxsbLCxsdFss/8VHx/PnTt3uHPnDpGRkURFRXHnzh18fHy4desWCQkJwD/fceXKlalZsyYODg7UqFGDmjVrUr16dYyMjN7iGxRCiNcjRQ4hhBCqyp6kVAghhIB/it9S5BAif2RPvty9e/dnnqtXr16Ouxh8fHwANEWGbO3atcvx/H81btz4ucuz75pwdXXNsbxVq1aa57OLHIcPH35u3y86EdulSxfKlCnDpUuXuHjxInXr1mXdunWMGzeObdu2ER4ezrFjx3BxcSE8PJw///zzmcm8RdGlo6NDenq62jEwMDCgXbt2tGvXjmXLlnHkyBG8vb2ZNm0akydPxt3dnREjRvD+++8/814jIyPNe+Gfu7ICAgLw9fVlw4YNeHh4YGNjg7u7O71796Zly5Z5MjeShYUFDRo0oEGDBs99/sGDB4SEhHDjxg1u3rzJ9evX2bFjB3fv3iUzMxM9PT3s7e157733qF69OtWqVdP8XLp06bfOJ4QQ2aTIIYq0172KQUZtE9qqOKzDsbGxsoMrhBBCQ+7kEPmlOOxXvUr2tlWuXLlXvjb7TtsyZcrkWJ79e0xMzHPf96KrtrNfb2Nj89znQ0NDNT9nX3X/376zh7P6L319ffr378+PP/7I2rVrWbJkCRs3buTAgQMYGBiwYMECNmzYgIuLC+vWraNfv34YGBg8t63ipLhsE6mpqZQtW1btGDmUKFGC9u3b0759e3744Qe2bt3K6tWrad26NfXq1eOzzz576XpqampK9+7d6d69O4qicOHCBfbt28f27dv56aefsLGxoWfPngwYMICmTZvm2+coV64c5cqVo2XLljmWp6amcuvWrRzFj6NHj7J8+XKePn0K/LN9/7v4Ubt2bWrXrp1jGDwhhHhdb1/WFUKLKYryWg8htFVRX4ezsrKIiIjA1tZW7ShCCCG0hBQ5RH4p6vtVryP75OHrbGPZY/3/d5if7N9zOxdAdt9xcXHP/d4TExM1r80ubryo7+cZMmQIAN7e3vj5+VG2bFlq1qzJ4MGDgX/uYklKSmLdunUMHTo0V9mLquKwTTx58oTMzEwqVaqkdpQXMjMzY/jw4Zw5c4agoCDee+89hg0bhr29Pd999x1JSUkvfb+Ojg7169dn9uzZXLlyhStXrjB8+HD8/f1p1qwZNWvWxNPT84WFyfxgaGhIrVq16N27N19++SWbNm3i3LlzJCQkEB4ejp+fH7NmzaJWrVqEhobi6elJ+/btNUWT9u3bM2XKFDZs2MClS5fkzn8hxCtJkUMIIYRqbty4wdOnT3OM/yyEEKJ4kyKHEPmnZ8+eAOzevfuZ586cOUOTJk00v2cP5xQQEJDjdf7+/jmef13ZQ2QdO3bsmedOnjxJs2bNNL9nz9nx376zJx1/ngYNGuDk5MTDhw8ZNWqUprhRtWpVmjRpQkJCAp9//jlGRkYvHHpHFD2//fYb8M+QZoVBo0aN8Pb25s6dO/Tv358vv/wSBwcHPD09X1nsyFazZk3mzJnDtWvXOHv2LM7OzsybNw87Ozt69erF8ePH8/lTvFyFChX44IMPGDduHMuWLSMgIIDIyEgePnyIv78/U6dOxcbGhoCAAIYNG0bdunUxMTGhbt26fPzxx/z888+cPXuW5ORkVT+HEEK7SJFDCCGEak6dOoWRkRFOTk5qRxFCCKElrK2tiY6OJjMzU+0oQhQ5c+bMwcnJiVmzZvHrr78SHR3N06dPOXToEIMHD+abb77RvHbu3LlUrFiRL774giNHjpCQkMCRI0eYPn06FStWZM6cObnu29HRkbFjx7Jjxw4ePXpEQkICPj4+DB06lIULF+Z4rbm5uabvp0+fEhgYyIoVK17aR/bdHPfv32fAgAGa5dkFjxUrVshdHMXMrl270NHRoW3btmpHyRU7Ozs8PT0JDw9n1KhRfP311zg6OrJy5cpc/X1s3Lgxy5cvJyoqCi8vL6KiojRDYnl5eZGSkpKPnyJ3ypQpQ9u2bfn8889Zu3Yt58+f5+nTp1y+fJm1a9fywQcfcPfuXWbOnEnTpk0xMzOjbt26fPLJJyxbtoyzZ8+Smpqq9scQQqhEihxCCCFU4+vrS5s2bWRMZCGEEBrW1tZkZmZq5gMQQuQdc3NzTp8+zYQJE/D09KRChQrY29uzZMkSVq9eneNEsJWVFWfPnsXNzY1BgwZRqlQpBg0ahJubG2fPns0xbv6/53bQ0dF57lwPZcqU4ezZs/Tv35+pU6dibW2tOWm7adOmHJMtOzg4EBgYSJ06dejatSs2NjZ4eHjw008/AbxwQuWBAwdSokQJOnbsmGMOhuy5DUqUKMHAgQOfed/r5BeF08mTJ6lQoQL6+vpqR3kjZcqUYc6cOdy6dQs3NzfGjh1Lw4YNOXr0aK7aKVmyJAMHDuTUqVMEBwfj5OTE6NGjqVixIh4eHiQkJOTTJ3g7+vr6ODk5MWDAABYvXsyRI0d4/Pgx9+/f57fffqN79+7ExMQwe/ZsmjZtiomJCTVr1mTkyJGsX7+eq1evFvoh14QQr0cmHhdCCKGK+Ph4/Pz8+P7779WOIoQQQotkT0ocFRX1WpMjCyFyx8TEhHnz5jFv3rxXvtbKyorly5ezfPnyl77udU8iWlhY4Onpiaen5ytfW7NmTXx9fXMsi4yMBJ6dkDxbuXLlSE9Pf2Z5qVKlXnqFt5wELZrOnTvH48ePNXfyFGbZ2+L48eOZMmUKbdq0YeDAgXh6euZ6fpyGDRuyYcMGFi9ezNKlS/nmm29YtGgR48aNY/z48ZQqVSqfPkXesbGxwcbGRjNsnqIohISEcPbsWc6ePcuZM2dYs2YN6enpWFlZ0aRJE5o2bUrz5s1p3LgxJUuWVPkTCCHymtzJIYQQQhVr1qxBT0+Pvn37qh1FCCGEFrG2tgZeb2JkIUTRpaOjQ0hISI5lJ06cAMDFxUWNSKKQmTRpErq6usydO1ftKHmmRo0a7N+/n927d3P8+HHee+89Vq1a9UaFunLlyvHtt98SERHB1KlT+fHHHzVD1GnrnR0voqOjg6OjIwMHDuTHH38kODiYxMREzp0760858wAAIABJREFUx/Tp03n33XfZuHEjrVu3xszMjIYNGzJhwgS2b99ObGys2vGFEHlAihxCCCEKnKIorFixgsGDB2NmZqZ2HCGEEFrExMQEExMTKXIIIRg7dix37twhMTGRgIAApk2bhpmZWa7nAxHFT1JSEqdOnaJp06aYm5urHSfPdevWjWvXrvHRRx8xatQoOnXqpLnTKbdMTU2ZNm0ad+/eZfLkySxbtoxq1aqxYsUKMjIy8jh5wdHX16dBgwZMmDBBM3TVX3/9xdq1a2nUqBEBAQH07dsXKysratWqxZgxY/D29pb9DyEKKSlyCCGEKHCHDx/m1q1bjBo1Su0oQgghtJC1tfUbn6wRQhQN/v7+mJiY0Lx5c8zNzenfvz9Nmzbl7NmzvPfee2rHE1ruyy+/JDMzM8eE9kWNiYkJnp6enDx5ktDQUGrVqsXWrVvfuD1TU1Nmz55NaGgovXv3Zvz48dSuXRt/f/88TK2u8uXL8+GHH/LLL79w5coVnjx5wqFDh+jZsye3b9/m448/xsbGhsqVKzNy5Ei500OIQkSKHEIIIQqUoih8/fXXtGnTBicnJ7XjCCGE0EI2NjZyJaUQxVzbtm3ZuXMnDx48ID09nZiYGLZu3SoFDvFKKSkp/PLLL9jY2ODs7Kx2nHzXrFkzLly4QN++fenfvz8jRowgJSXljdsrW7YsS5cu5fr161SrVo0PPviA3r1789dff+Vhau1gampKu3btmDNnDocPH+bRo0ccOHCAXr16ceHCBfr374+VlRV169bl888/x8fHp9AN5SVEcSFFDiGEEAVq06ZNnD59Gg8PD7WjCCGE0FLW1tZS5BBCCPFGhgwZQkpKCitXrlQ7SoExNjZm2bJl7Nmzhx07dtCsWbNn5rTJLQcHB3bt2oWvry+XLl2ievXqLFq0qFAPYfUqxsbGdOzYEQ8PD4KCgnj8+DGHDh2iY8eOnDhxgm7dumFhYUHDhg354osvCAwMJCsrS+3YQgikyCGEEKIAJSUlMXPmTIYPH07Dhg3VjiOEEEJLSZFDCCHEmwgLC2PHjh00atSIzp07qx2nwLm5ufHHH39QokQJGjZsiK+v71u36erqyuXLl5k+fTqzZs2iWbNmXL58OQ/Saj8TExPatWvHwoULOXfuHA8ePGD9+vXUrFmTdevW4ezsjLW1NQMHDmTjxo1ER0erHVmIYkuKHEIIIQrMvHnzSEhIYN68eWpHEUIIocWkyCGEEOJNdOvWDYCdO3eqnEQ9lSpVIjAwEHd3d7p27cqSJUveuk1DQ0O+/PJLLly4oCmgfP3116Snp+dB4sKjbNmyDBgwgHXr1hEZGcmFCxf4/PPPiYqK4pNPPsHa2ppGjRoxd+5c/vjjDxRFUTuyEMWGFDmEEEIUiJMnT7J48WK++eYbypYtq3YcIYQQWsza2poHDx7IyQEhhBCvbeHChVy+fJlhw4ZRvnx5teOoytDQEC8vLzw8PJg6dSqffPJJnhQkqlevzqlTp/jxxx9ZvHgxzZs35/bt23mQuPDR0dGhbt26TJs2jYCAAOLi4ti7dy8NGjRg1apVNGzYEDs7O0aMGMHevXtJSkpSO7IQRZoUOYQQQhSIQYMG0aVLF0aOHKl2FCGEEFrO2tqatLQ04uLi1I4ihBCiELhz5w4zZ86kQoUKrFixQu04WmPSpEns2bOHbdu20b17dxITE9+6TV1dXUaMGEFwcDCZmZk0aNCgWM1/8iLGxsZ06dKF5cuXc+/ePc6fP8+oUaO4dOkSPXr0oEyZMnTu3JmVK1cSExOjdlwhihwdRS6PEgVgz549dO/eXe0YQgiV6Ojo4OjoyOnTpylVqpTacYQQQmi5y5cvU7t2ba5evUqNGjXUjiPygaGhIWlpaWrHEEIUEYaGhiiKQkhISLG/i+N5zp07R+fOnalYsSL79+/PszvrU1NTmT59Ot9//z39+/dnxYoVmJiY5EnbRUl0dDQ+Pj74+Pjg5+dHamoqLVq0wN3dHXd3d1lnhXh7v0qRQxSI1NRUfH19ycjIUDuKEKIApaens2jRIsLCwggODqZq1apqRxJCCFEIxMTEYGVlxdGjR2ndurXacUQ+CAwMlHlXhBBvLTk5mXHjxpGQkMDhw4dp27at2pG01q1bt+jQoQNGRkYEBARQrly5PGv70KFDDBo0CEtLS3bu3Em1atXyrO2iJjk5GX9/f7Zv387evXt58uQJNWrUoHfv3vTt25fq1aurHVGIwkiKHEIIIfJHWloavXr14sSJExw+fJhGjRqpHUkIIUQhkZmZiaGhId7e3vTp00ftOEIIIbRQUlISjo6OREVF8euvv/LJJ5+oHUnr3b9/nzZt2qCrq8uRI0ewtrbO07Z79erF1atX8fLyolevXnnWdlGVmZnJ6dOn2b59O9u2bePBgweagseHH36Io6Oj2hGFKCx+lTk5hBBC5LnMzEwGDRrE8ePH8fPzkwKHEEKIXNHT06N06dJER0erHUUIIYQWevr0Ke+99x6RkZH89NNPUuB4Tba2thw7dgwdHR1at27N/fv387zt/v3706dPH7766ivkuuqX09PTo2XLlixdupSIiAgCAgJo2bIlP/30E9WqVaNZs2YsXbqUyMhItaMKofWkyCGEECJPZWZmMnDgQPbv38++ffto3Lix2pGEEEIUQpaWljx8+FDtGEIIIbRMVFQUjo6O3Lt3j0WLFjFmzBi1IxUq1tbWHD16lBIlStC+fXvi4uLyrG1DQ0NWrFjBr7/+yqJFi+jXrx/Jycl51n5RpqenR5s2bVixYgVRUVHs37+fqlWrMmvWLMqXL4+LiwsrVqwgPj5e7ahCaCUZrqqQe/LkCQ8ePODhw4c8fPiQqKgo4uLiePr0KQkJCaSkpJCQkMDTp09JT09/aVvvvvsuenp6mJubo6enh5mZGRYWFpQqVYpSpUppfi5TpgxWVlbo6+sX0KcUQhQW2Xdw7N27F19fX1q1aqV2JCGEEIVU27ZtcXR0ZPny5WpHEUIIoSWuXbuGs7MzcXFxLFiwgBkzZqgdqdCKjIykRYsWWFpacuTIEYyNjfO0/VOnTtG9e3cqV67Mnj17sLKyytP2i4uUlBQOHDjAli1b8PHxITMzEzc3NwYPHkzHjh3l3JwQ/5A5ObRdeno6N27cIDQ0lDt37uR43L17l9TU1ByvL1OmDKVLl8bExARTU1MMDQ0xMzPD2NgYAwODl/b1+PFjFEUhPj6erKwsnjx5QlxcHPHx8Tx+/DjHa3V0dLCyssLa2hpbW1vNvw4ODlSqVIlKlSphY2ODjo5Onn8nQgjtlJGRwUcffcTOnTvx8fGhTZs2akcSQghRiA0YMIDk5GR27dqldhQhhBBawMfHh759+5KUlMS8efP48ssv1Y5U6IWEhNCyZUsaNmzI7t27KVGiRJ62f/PmTbp06UJGRgYHDhzgvffey9P2i5vk5GR8fHxYuXIlAQEBWFhY0KtXLwYNGkTLli3VjieEmqTIoU3i4+O5cOECly5d0jyuXbtGWloa8M8thQ4ODjg4OFC5cmUqVaqEpaUl1tbWlC1blrJly+ZbBTcrK4u4uDji4uKIjY0lKiqK+/fvExUVRWRkJJGRkURERBAWFqYpvLzzzjvY29vj4OBA9erVqVatGtWrV6d69eqULl06X3IKIdSRkpJCv3798Pf3Z9euXXzwwQdqRxJCCFHIffbZZwQHB3Pq1Cm1owghhFBRZmYmX331FQsXLkRRFGbNmsXcuXPVjlVknDt3DhcXF7p168aGDRvy/GLV2NhYunbtSkhICL6+vjRs2DBP2y+u7t69y4YNG9iwYQO3b9+mVq1aDB06lEGDBlG2bFm14wlR0KTIoabw8HBOnjxJYGAggYGBXLt2DUVRsLS0pE6dOtStW5c6depQq1YtHB0dKVmypNqRX0lRFCIjI7lz5w5hYWHcuXOHkJAQbt68yY0bN3j69CkAZcuWpWbNmtSpU4f69etTr149qlevnudXDQgh8l9CQgLdunXj4sWL+Pj40Lx5c7UjCSGEKAIWLFjA2rVruX37ttpRhBBCqCQqKooPP/yQwMBAMjIymDt3Ll999ZXasYqcI0eO0KlTJyZMmICHh0eet5+UlESvXr04ceIEv/32G+3bt8/zPoqz33//nfXr17NlyxaSk5Pp3r07w4cPp02bNujqynTMoliQIkdBio+P59ChQ/j6+nL06FEiIiIwMDCgYcOGtGzZUnOLoLW1tdpR881ff/3FjRs3uHHjBlevXuXChQtcvnyZlJQU3nnnHWrXrk29evWoX78+9evXp1atWhgaGqodWwjxAo8ePcLV1ZV79+5x6NAhateurXYkIYQQRcSqVauYNGkST548UTuKEEIIFWzdupWxY8eio6NDbGws8+fPZ+bMmWrHKrK8vb0ZNGgQ//vf/5g4cWKet5+ens6QIUP47bff8Pb2xt3dPc/7KO5SUlLYt2+fZjgrW1tbPvzwQ8aMGUOFChXUjidEfpIiR367evUq+/fvZ//+/fz+++8AtGzZkrZt29KqVSsaNWpUKO7QyE8ZGRlcu3aN8+fPc+HCBc6fP8+lS5dISEhAX1+fGjVqUK9ePerVq0fTpk2pX7++3PEhhBa4f/8+7du3Jzk5GT8/P6pUqaJ2JCGEEEXI3r176datG0lJScV+f1kIIYqTx48fM378eDZu3Ejjxo0JCgpiyZIlfPbZZ2pHK/KWLFnClClT8PHxwdXVNc/bz8rKYvz48axYsYJNmzbRp0+fPO9D/OPatWusWrWK9evX8+TJEzp37szo0aNp3769zJ8riiIpcuSHW7du4e3tzebNm7l16xaWlpa4urrSqVMn2rdvj7m5udoRtV5WVha3b9/WFD0uXLjAH3/8QXx8PMbGxjRu3JiWLVvSvHlzmjdvjpmZmdqRhShWbty4gaurK0ZGRvj5+WFra6t2JCGEEEXMmTNnaNasGXfv3qVixYpqxxFCCJHPFEVh48aNTJkyBX19fd5//328vb354Ycf+PTTT9WOV2x88skn7Nq1i6CgoHy7kG3GjBksWrSItWvXMnDgwHzpQ/wjNTWVXbt2sXLlSo4ePYqjoyNjxoxh6NChcn5SFCVS5MgrUVFRbN26FW9vb4KDg7GxsaFv37707duXRo0ayRh4eUBRFG7cuMGpU6cIDAzk1KlThISEoKenh5OTk6bo4ezsTPny5dWOK0SR5e/vT+/evalevTr79u2jdOnSakcSQghRBIWFheHg4EBQUBCNGjVSO44QQoh8dPnyZcaOHcupU6cYPnw4ycnJbNq0ieXLlzNs2DC14xUrKSkpODs7k5qayunTpzE2Ns6XfmbOnImHhwdeXl4MHjw4X/oQOd26dQsvLy9WrFhBSkoKvXv3ZtKkSdSpU0ftaEK8LSlyvA1FUfDz82PZsmXs378fU1NT3N3dGTBgAK1bt0ZPT0/tiEXegwcP+P333zVFjwsXLpCenk758uVp2bIlrVq1om3btjg6OqodVYgiYfny5YwbN47evXvj5eXFO++8o3YkIYQQRVRSUhLGxsb4+PjQuXNnteMIIYTIBw8fPmTevHn88ssv1K9fH09PTzw8PDhy5AhbtmzBzc1N7YjF0l9//UXDhg1p27Ytmzdvzrd+pk6dypIlS/D29pahqwrQ33//zbp161i2bBk3btzA2dmZcePG4e7uLucyRWElRY43ER8fz5o1a1i+fDm3b9/GxcWF0aNH4+bmJif8VJaUlERQUBAnT57UFD+ePn1K+fLladu2reZRlCd3FyI/ZGZmMmnSJH744QfmzJnDV199JeN4CiGEyHcmJib8+OOPfPTRR2pHEUIIkYcSExP57rvvWLx4McbGxnz99dd0796dbt26cePGDfbu3UuLFi3UjlmsBQQE0LFjRxYtWpQvE5FnmzhxIj///DO7d++mU6dO+daPeJaiKAQEBPDTTz+xb98+KlasyPjx4/nkk08wNTVVO54QuSFFjty4ffs2ixcvZtOmTejp6TFo0CDGjh1LjRo11I4mXiA9PZ2zZ88SEBBAQEAAZ8+eJS0tjRo1atC2bVvatGlD69atZRxCIV7i77//pn///hw9epQ1a9bQt29ftSMJIYQoJhwcHBgxYgRffPGF2lGEEELkgZSUFFavXs2CBQt4+vQpU6ZM4fPPPyc6OpqOHTuSmZnJwYMHZTQGLbFo0SJmzJiBr68v7du3z5c+FEVh5MiRbNy4EV9fX1q3bp0v/YiXu3PnDkuXLmX16tXo6ury0UcfMWnSJCpUqKB2NCFehxQ5Xsfly5f59ttv2bZtGw4ODkyYMIHBgwdLVbMQSkxM5OTJk5qix6VLl9DR0aFBgwaauzxatmyJoaGh2lGF0ArXr1+nV69exMXFsWfPHho3bqx2JCGEEMVI06ZNadGiBZ6enmpHEUII8RYSExNZsWIF//vf/4iPj2fEiBF8+eWXlC1blpMnT9K7d2/Kly+Pj48PVlZWascV/5+iKPTp04cTJ05w8eLFfBsVIzMzkwEDBnDw4EH8/f1lLi4VxcXFsWLFCn766ScePnyombejfv36akcT4mWkyPEywcHBLFiwgL179+Lk5MT06dPp06ePjE9XhDx69IijR49qih63b9/G2NgYFxcXOnbsSIcOHahSpYraMYVQxcaNGxk9ejS1atVi69atlC9fXu1IQgghiplu3bphZmbGhg0b1I4ihBDiDcTGxrJ8+XJ++OEHkpKSGDVqFJMmTdKcLF+5ciWffvopPXr0wMvLK98muRZvLiEhgXr16uHo6Iivr2++DVuclpZG9+7dOXfuHL///ruci1FZWloae/bs4X//+x9BQUG0aNGCadOmyTw5QltJkeN5rl69ytSpU/H19aVRo0bMnDmTrl27yvjzxUB4eDgHDx7k0KFDBAQE8Pfff1OlShU6dOhAx44dcXFxkZ0uUeSlpKQwYcIEfv31Vz777DM8PDzQ19dXO5YQQohiaPjw4YSHh+Pn56d2FFEA0tLSSEhI4MmTJzx+/BhFUUhLSyMxMfGF7zExMUFfXx9dXV3effddTE1NMTY2xsjIqACTCyH+68qVKyxdupRNmzZRsmRJRo8ezWeffUaZMmWAf445Ro8ezfr165k/fz5ffPGFnHPRYufOnaN58+YsWbKETz/9NN/6SU5Opm3btkRHR/P777/LXT1aIjAwEA8PD3x8fDTFji5dusg2K7SJFDn+7cGDB8yaNQsvLy/q1KnDN998Q4cOHdSOJVSSnp7O77//zqFDhzh48CAXL17EwMCAli1bau7yqFWrltoxhchTISEh9OnTh7CwMLy8vOjRo4fakYQQQhRjM2fOZP/+/Vy8eFHtKOINZWVlERERQWhoKOHh4URFRREdHU1MTAyRkZHExMQQGxtLQkICKSkpedZvdtHj3XffpUyZMpQpU4bSpUtrHtbW1tjY2GBnZ0e5cuXkRJoQeSAtLY29e/eyYsUKAgICqFatGhMmTGDQoEE5Lha8f/8+7u7u3Lx5E29vb5lsupCYM2cOHh4eBAUF5eu5kNjYWFq0aIGZmRlHjx7FxMQk3/oSuXPq1CkWLlzI/v37cXJyYvLkyQwYMIASJUqoHU0IKXLAP2NDenp6snjxYiwsLJg/fz4DBw5EV1dX7WhCi0RHR2sKHocPHyY2NhY7OztcXV3p1KkT7dq1kz++olDz9vZmzJgxVK5cmW3btlG5cmW1IwkhhCjmli5dioeHB5GRkWpHEa+QmprK1atXuXTpEleuXOHmzZuEhoYSFhZGamoqACVLlqRcuXJYW1tjaWmJjY0NlpaWlC1bFlNTU83D3NwcMzMz9PT00NPTw8zM7IX9PnnyhKysLDIzM/n777/5+++/SUxMJDExkSdPnvDkyRMePnzIo0ePiI2N5dGjRzx69Ij79++TkJCgacfAwABra2scHByoUqUKlStXzvF4WQYhirvr16+zevVq1q9fT1xcHB06dGDcuHF06NDhmSu9/fz8GDx4MBYWFuzevZtq1aqplFrkVkZGBs7OzqSmpnLmzBkMDAzyra/bt2/TvHlzmjZtyu7du2XYeC1z8eJFvv32W3bs2IGjoyNfffUV/fv3l/OoQk1S5NiyZQuTJk3i6dOnTJs2jYkTJ1KyZEm1Ywktl5WVxblz5zh48CC+vr4EBwejr6+Ps7MznTp1onPnzlStWlXtmEK8lpiYGEaPHs2uXbv49NNPWbRoEe+8847asYQQQgi8vb0ZOnQoqampMiSCFsnIyOD8+fOcOnWK4OBg/vzzT27evElGRgbvvPMOTk5OVK1aNUeRoEqVKpQrV07t6DkkJiZy7949oqKiiIiI4P79+9y5c4eQkBBCQ0OJiIggKysLAEtLyxyfpXLlylStWpUaNWrIhU6iWHr48CHbtm1j06ZNnD59Gnt7ez766CM++uij587ll5aWxsyZM/H09KRPnz6sXLlSioeF0J07d6hbty5jxoxh4cKF+drXmTNncHFxYdy4cSxatChf+xJv5tatWyxYsIBNmzZRtWpVZs+eTe/evaXYIdRQfIscYWFhjB07loMHDzJs2DDmz5+PpaWl2rFEIfXw4UMOHjzI/v378fPzIz4+nipVqmgKHq1atZKTxkIr7dy5k9GjR2NkZISXlxdt2rRRO5IQQgih4efnR4cOHYiPj8fc3FztOMVWcnIyJ0+eJDAwkMDAQIKCgkhMTKRMmTI0adKE2rVrU6dOHWrXrk3VqlWLzBW3qamphIWFERoaqil8ZP979+5d0tLS0NHRoVKlStSqVQsnJydq166tKfLI8B2iqElISGDv3r14e3vj5+fHO++8Q7du3Rg8eDDt2rV74YnN27dvM2DAAG7cuMEPP/zARx99VMDJRV5atWoVI0eO5PDhw/l+/Lhx40YGDRqEl5eXrDdaLCwsjIULF7J69WqqVavGtGnT+PDDD4vM/oAoFIpfkSMjI4PvvvuOOXPmYG9vz4oVK2jZsqXasUQRkpGRwenTp/H19cXX15c///wTY2Nj2rZtS6dOnejUqdNzr2wRoiDFxcUxbtw4vL29GTZsGJ6ennIllRBCCK1z/vx5GjRowO3bt6lSpYracYqVmzdvcvDgQQ4cOMCJEydITk7G0dGRFi1a0LJlS1q0aEG1atWK7R02mZmZ3L17lz///JMrV65w+fJlLl++TEhICBkZGRgYGFCjRg2cnJyoVasWtWrVok6dOtjY2KgdXYhciYmJ4eDBg2zfvp3Dhw+TkZGBi4sLgwYNwt3d/ZV3Mq1bt45PP/2UqlWr4u3tLcNTFRE9evTg/PnzXL58Od+PIydNmsSyZcs4ceIEjRo1yte+xNu5fv06c+fOZfv27dSqVYu5c+fSrVs3tWOJ4qF4FTmCg4MZPnw4N2/eZMaMGUybNi1fxxAUAuDevXuagkdAQACJiYk4OTnh6uqKq6srLVu2RF9fX+2Yohjx9vZm8uTJ6OjosGrVKlxdXdWOJIQQQjxXeHg49vb2nDlzhiZNmqgdp0hTFIXff/+dbdu2sW/fPsLCwrCwsOCDDz6gY8eOdOjQQU7Qv4bU1FSuXbvG5cuXuXLliqYIcv/+fQBsbGxo2LBhjkfZsmVVTi3E/1EUhQsXLrB371727dvHhQsXMDY2pkOHDri5udGlSxdKly79ynaioqIYM2YMe/bsYeLEiXzzzTcYGhoWwCcQBSE2NpYaNWrQu3dvfv7553ztKzMzEzc3Ny5dukRwcLD8LSoErly5wty5c9m5cydNmzbFw8MDZ2dntWOJoq14FDkyMjJYsGAB8+fPx9nZmeXLl8t8CUIVKSkpnDhxggMHDnDgwAFu3ryJqakp7dq10xQ97Ozs1I4piqhr164xduxYTpw4wSeffIKHhwcWFhZqxxJCCCFeKDExERMTE3x8fOjcubPacYqk4OBgtm7dyvbt2/nrr7+oXr067u7uuLq60rRpUxlqIo/Ex8dz/vx5zp07p3ncvXsXgIoVKz5T+JDh2URBSklJ4dixY5rCRkREBHZ2dnTp0oVu3brh4uLy2gUKRVHw8vJi8uTJlCpVipUrV9K2bdt8/gRCDRs3bmTIkCEcP34830dIiY+Pp3HjxlhaWnL06FG5YLmQuHLlCtOnT8fHx4d27drxv//9jzp16qgdSxRNRb/IER4ezqBBgwgODmbOnDlMmTJFJsARWiMsLIzDhw/j7+/PwYMHSUhIwMHBgS5duuDm5karVq3kj7d4a0lJSSxatIhvv/2WmjVr8vPPP9OsWTO1YwkhhBCvxcjIiF9++YUhQ4aoHaXIiIqKYs2aNaxZs4aQkBCqVKlC37596dOnD7Vr11Y7XrERGxubo+jxxx9/EBERAUCVKlVo0qQJzZo1o2XLljg5OUnBSeSZjIwMLl26hL+/P/7+/gQGBpKSkkKNGjU0d2u0aNEi18PRhYWFMWLECI4ePcr48eOZP38+RkZG+fQphDbo0qULISEhXLp0Kd/v1Llx4wZNmjRhwIAB/PLLL/nal8hb/v7+TJs2jYsXL9KzZ088PDyoVKmS2rFE0VK0ixzr169n3Lhx2Nvb4+3tTc2aNdWOJMQLpaSkcPz4cc1dHrdu3cLMzCzHXR62trZqxxSFSFZWFlu2bGHq1KkkJSWxYMECRo4cKYVeIYQQhUr58uWZOHEin3/+udpRCrWsrCz8/PxYuXIlPj4+mJmZMWjQIAYOHEiDBg3Ujif+vwcPHmiKHqdPn+bMmTP8/fffmJqa0qRJE5o3b06zZs1o1qwZ7777rtpxRSGRnJzMmTNnOH78OMeOHePs2bOkpKRgb2/P+++/T+vWrWnbtu0bzx2ZlpbGDz/8oJn7dPXq1TLEYDERHh6Ok5MTU6dO5auvvsr3/vbs2YO7uzvLli1j5MiR+d6fyDvZ5ye++uorIiMjGT9+PDNnzpS5QUVeKZpFjsePHzNy5Ei2b9/OZ599xrfffisfab1yAAAgAElEQVRjP4pCJzQ0lAMHDuDr68uxY8dITk6mdu3amoJHixYtKFGihNoxhZby9fVl5syZ/D/27jyu5vz///+tKEm7pWQZUqSoUYnKvs5QlpKdjLEOhplBeM/CDGaY8bNlbGM3xr6MsZsZWxRCVNaESbJMi6SkOr8/5tv5iLJ2zqvlcb1cXpfO8jrP5/1V1Dmvx+v5fJ4/f56PPvqI77//XuZ7FkIIUSQ1aNCADh06MG3aNKWjFEnJycksXryYhQsXcuPGDZo1a8aQIUPw8/PDwMBA6XjiFbKysoiKiiI4OJjjx49z/PhxoqOj0dXVxcHBAS8vL3Xhw87OTum4opC4f/8+p0+fJiQkRF3UePLkCTY2NuqiRvPmzXnvvffeua8//viDL774gn/++YfAwEAmTpwosxGUMD/99BNffvklZ86cwcHBQeP9TZ48menTp3PgwAGaN2+u8f5EwcrIyGDRokV8++23lC5dmu+++46BAwfKaEXxropfkePChQv4+vqSmprKqlWraNu2rdKRhHhnaWlp6lEeu3fv5tq1a5iamuYa5SGLbwmA4OBgJk6cyNGjR+ncuTNTp06lXr16SscSQggh3lrbtm2xsbFh8eLFSkcpUu7cucOcOXNYvHgxKpWKjz/+mCFDhmBvb690NPGO7t69y4kTJwgODubEiROcPn2aJ0+eUKlSJTw8PPDy8sLDwwM3NzcpZJUAiYmJhIWF5Zr67ObNmwDY2dnRtGlTWrRoQYsWLd56pEZeLl68yGeffca+ffvo3r07M2fOLJCiiSh6srKyaNSoEYaGhhw+fPiNpzl7UyqVCl9fX0JCQjh37hyWlpYa7U9oRmJiIjNmzGD27NnUqlWL/+//+//44IMPlI4liq7iVeRYv349gwYNwsXFhY0bN2JlZaV0JCE04tq1a+qCx+HDh0lLS8PZ2Vld8PD09JRRHiXM6dOnmTJlCn/88QctWrRg+vTpsu6GEEKIYqFnz548ffqULVu2KB2lSLh8+TI//fQTa9aswdzcnNGjRzNs2DBZyLoYe/LkCWFhYbkKH/Hx8ejr6+Pq6pqr8FG5cmWl44p3kJyczNmzZ3MVNa5duwb8N7Xf8wvYW1hYFHiGu3fvMm3aNBYtWkS9evWYM2cOzZo1K/B+RNESHh5Ow4YNCQoKYsiQIRrv79GjR7i6ulKzZk12794tUzIXYVeuXOHLL79k06ZNeHt7M2fOHGrVqqV0LFH0FI8iR2ZmJuPHj2f27Nl8+umn/PTTT+jp6SkdSwitSEtL49ChQ+zevZs9e/YQHR2NsbExzZs3p3Xr1rRu3Zp69epp/GoKoX0qlYr9+/czc+ZM/vrrL9zc3Jg6dSrt27dXOpoQQghRYEaOHElERASHDh1SOkqhdvPmTSZPnsyaNWuoVasWY8eOpX///jJtbwl1/fp1jh8/ri58REREkJWVRc2aNdXTW3l5eVG/fn2ZIqQQSk5O5tq1a0RGRhIVFaX+GhMTg0qlwszMDEdHR5o0aYKXlxcNGzbU+EWeDx48YObMmfz888+YmJjw7bffMnDgQDm5LNTGjRvHL7/8wqVLl7QyuuL06dN4eXkxbdo0xo4dq/H+hGbt2bOHzz//nJiYGMaOHcv//vc/ypYtq3QsUXQU/SLHvXv36NGjBydPnmTJkiX06dNH6UhCKOrq1ascOHCAP//8k0OHDpGQkIClpSWtWrWidevWtGnTRoYRF3GZmZls3LiRmTNnEh4eTtu2bRk/fjxt2rRROpoQQghR4CZPnszmzZuJiIhQOkqhdPfuXaZPn86iRYuoVq0a3377LT179pQTjyKXlJQUQkJC1IWPkJAQkpOTZUFzhT148IBLly4RFRWVq5gRFxcHgJGREfb29jg6OuLg4ICDgwPvv/8+VatW1VrGhIQEZs2axbx58zA0NGTChAkMGzZMTj6KF6SmpmJvb0+7du1YtmyZVvqcMWMGX331FUeOHKFx48Za6VNoztOnT1mwYAHffPMN5cuXZ+7cufj4+CgdSxQNRbvIERkZSYcOHShdujRbt27F2dlZ6UhCFCpZWVmcPXuWP//8kz///JNjx46RlpaGra2tepRHy5YtqVChgtJRxWuIi4tj5cqVLFmyhNu3b+Pv78+4ceNo0KCB0tGEEEIIjZk/fz7Tpk0jPj5e6SiFSkpKCjNmzGDu3LmYmJjw5ZdfMmjQIBnRLl5LdnY2kZGR6sXMjx8/zrVr12RB8wKWmZnJrVu3uH79+gvbtWvXSE5OBqBMmTLUqlVLXczI+Vq3bl3FCpaxsbEEBQWxcOFC9PX1GTduHCNGjKBcuXKK5BFFw2+//Ubfvn05ceIE7u7uGu8vOzubDz74gOjoaM6ePYuJiYnG+xSad+fOHQIDA1m7di0dO3Zk/vz51KhRQ+lYonArukWOQ4cO0bVrV+rXr8/27ds1MtekEMVNeno6x48fVxc9Tp8+jUqlwsnJiaZNm9KkSROaNGkii5gXIllZWezdu5elS5eya9cuTE1N6d+/P6NGjaJmzZpKxxNCCCE0bt26dQwYMIAnT57I9Jv8N13lb7/9xrhx40hLSyMwMJBRo0ZhaGiodDRRxL3Oguaenp64urrKgub/z5MnT7h9+za3b9/mn3/+ITY2Nlch4+bNm2RmZgJgampKrVq1sLGxwcbGRn3bzs6uUI20P3nyJLNnz2bLli1UrFiRUaNGMWLECIyNjZWOJoqIFi1akJqaSmhoqFaKdPfu3cPZ2ZlmzZqxYcMGjfcntOfw4cN88sknxMTEMH78eCZOnCjTcIr8FM0ix2+//cZHH31E586dWbVqlbzBEuItJSUlcejQIQ4dOsSxY8cIDw8nMzMTGxsbmjRpQtOmTfHy8sLe3l5OKmhZZGQkGzZsYMWKFdy+fZsWLVowePBgfH195Y+6EEKIEmX//v20b9+exMTEEr94dmRkJCNHjuTIkSN8/PHHTJ8+XUbkCo0p6QuaP3z4kNjYWG7fvk1cXBy3bt0iLi6O2NhYYmNjiYuL4969e+r99fT0sLa2pmbNmnkWM8qXL6/g0bxcRkYG27dvZ968eQQHB+Pi4sKYMWPo0aMH+vr6SscTRUxERAQNGjTgl19+ISAgQCt97tu3jw4dOrBs2TIGDBiglT6FdmRkZPDTTz8xbdo0qlevztKlS2nSpInSsUThU/SKHDNnzmTChAl89tln/PjjjzLXrBAF6NGjR5w4cYJjx45x7NgxQkNDSU1NpWLFinh6etKsWTO8vLxwcXGRqRA0ICoqik2bNrFx40aioqKoUqUKffv2ZdCgQdja2iodTwghhFDEmTNncHV15dq1a9SqVUvpOIpISUlh8uTJzJ8/H2dnZxYsWKCVaUCEeN7169fVBY/g4GAiIyPJysrCxsYm14Lm9erVK5QLmicmJhIXF0diYiJ37tzJ83ZiYiKxsbE8fPhQ/boyZcpQpUoVKleujLW1tfqrjY2N+vZ7771XKI/5Zc6fP8/y5cv59ddfSUxMxMfHhzFjxtC8eXOlo4kibvjw4Wzbto3Lly9rbZ2fcePGsXDhQk6fPo29vb1W+hTac+PGDYYPH87+/fsZPnw433//vYwwE88qOkWOrKwsPv30UxYtWsTs2bP59NNPlY4kRLGXmZlJWFgYwcHBHD16lODgYO7fv4+hoSHOzs64urri4uKCq6srDg4OlC5dWunIRUpmZiYnT55k7969bN26lcjISKytrenWrRv+/v54enpKIVcIIUSJd/PmTWrUqEFISAiNGjVSOo7WHTx4kI8//pjU1FSmT5/OoEGD5P2BKDQePnz4woLmDx8+xMjICBcXF9zc3GjYsCFubm4FdtFOcnKyuhjx/JaQkJDn4w8ePFCvf5HDwMCAChUqYGlpiaWlJRUrVqRixYpYWVmpb1erVg1ra+tiNT32gwcP1CPGw8LCsLW1ZcCAAQQEBGh1QXNRvCUkJFC7dm0GDhzIzJkztdLn06dPadasmXqqrLJly2qlX6FdmzZtYsSIEejp6REUFETXrl2VjiQKh6JR5MjMzKRfv37s2LGDtWvX4uvrq3QkIUqsS5cucfz4ccLCwggLC+P8+fOkpaVhYGCAk5NTrsJHvXr1ZMTHc27cuMH+/fvZt28ff/31F0lJSdSoUQMfHx/8/f3x8vKSExdCCCHEM1JTUzEyMuKPP/6gY8eOSsfRmkePHjFu3DgWL15Mt27dWLBgARUrVlQ6lhAvlZWVRWRkJCEhIZw6dYrQ0FAuXrxIZmYmJiYm1K1bFzs7O2xtbbGysqJMmTI8evSIR48ekZSUREpKivr+w4cPSU5OzvVYUlJSnv2amppibm6Oubk5FhYW6tvPPlapUqVchYyStEBxXFwc27ZtY8uWLRw5cgQDAwO6devGwIEDadq0qUxNLDQiKCiIL774gvPnz1OnTh2t9BkdHY2LiwsfffQRc+bM0UqfQvsSEhKYOHEiS5Yswd/fX94jCSgKRY6MjAx69erFvn372LlzJy1btlQ6khDiGZmZmVy8eJGwsDDOnDlDWFgY4eHhpKamoq+vj5OTEy4uLjg5OVG3bl0cHBywsrJSOrZWZGZmcu7cOUJCQtRXuMXExFCuXDlatGhB+/btadeundbe8AkhhBBFlaGhIYsWLaJ///5KR9GKQ4cOMXDgQFJSUggKCqJHjx5KRxKF0MOHD8nKylLfT0lJUS9yndf9R48e8fTpU/X91NRUMjIyXmgvPT2dtLQ0srOz1aMfXvVcZmYmSUlJZGRkkJqayuPHj3ny5Mkrj0FHRwd9fX3KlSuHmZkZlSpVokKFChgbG2NsbIyZmRlGRkbqzczMLFdBI2eTi4RyU6lUXLhwgX379rF9+3ZCQkIwNDSkY8eO+Pn50aFDB8qVK6d0TFHMZWZm4uLiQrVq1di1a5fW+l29ejUfffQRf/31l0y9Vsz98ccfDB8+nCdPnrBgwQL8/f2VjiSUU7iLHE+ePKFbt24cOXKEXbt2ycIyQhQRWVlZXL58WV34OHPmDBERESQkJABgbm6Og4MDDg4O1K5dm1q1alGrVi1sbW0xNDRUOP3befjwIVFRUVy4cIGoqCj1SJfHjx9jampK48aN8fDwUC/mLouHCyGEEK+vWrVqfPbZZ3z++edKR9GoJ0+eEBgYyLx58+jUqROLFy/G0tJS6VivJSkpCZVKxdOnT3n06FGu554/uf7sCfIcaWlppKen59lmjpwT6M/Lq8+85Jygf5Xn8+blVSfx8zrGN+0nOTmZ7Oxs9f3nixoFzcjICD09PXXRAf573w5Qrlw59PX183wu53Xm5ubo6elhZGRE2bJlMTAwwMTEBD09PUxNTSlTpgyGhoYYGRnx5MkToqOjOX36NKdPn+bs2bNER0eTlZWFoaEhjo6OODs7U79+ferXr4+zs3OxmjJKE+Lj4zlw4IB6i4+Pp3z58urCRrt27TAwMFA6pihh/v77b1q1asX+/ftp27at1vr18/PjzJkznD9/XtZtKOYePnzIuHHjWLp0Kb169SIoKEj990mUKIW3yJGWlkbXrl0JDQ1l7969JXL+XSGKm7t37xIZGcmlS5eIjIzk4sWLXL16ldu3b6s/wFauXBlbW1tq1KhB1apVqVy5MtWrV8fa2pqqVatiaWmp2JVa9+/f5+bNm9y8eZMbN25w8+ZNrl69SlRUFLdu3QL++wBYt25dnJ2d8fDwoHHjxtStW1euLhNCCCHeQYMGDejQoQPTpk1TOorGXL9+nR49enDlyhWCgoLo16/fO7WXnp6unvInKSmJR48ekZKSwuPHj9Un1xMTE8nMzCQlJUVdAMjrOfi/E/LPnrzPqzBRkIyNjXOt+VaqVKl8pxgyNTV95fstXV3d11oA99kT+fkpXbr0K0+cmZiYvHQh6lf1k1M8yJFTaMjvvqGhYa4LaXIKDfndNzAwKFRz1j9+/JioqCjCw8O5cOECFy5cIDw8nH///ReAKlWqUL9+fZycnLC3t8817VVJk5WVRUREhHodlNDQUC5fvoyenh6enp60bduWdu3a4eLiIp9DhOJ8fHy4desWZ8+e1dq/x/j4eBwdHdUnvUXxt3//fj7++GMyMzNZunQp3t7eSkcS2lU4ixypqan4+Phw/vx59u/fj4uLi9KRhBAalJ6eTnR0dK7t5s2bxMbGEhcXx71799T76ujoUKFCBcqXL0/58uXVtytUqEDZsmUpW7as+koxIyOjFz7sPSvnCrycofqpqamkpqby77//8u+///LgwQP+/fdf7t+/T3x8vPrKP11dXaysrKhZsyY2NjY4ODjg6OiIo6MjNWvWlDlthRBCiALWpk0batWqxeLFi5WOohHbtm1j4MCB1KhRg40bN2JnZwf8dyV/zvuRhISEfL/mrFmQkpJCYmLiK0cI5BQPzM3N1Sfrc05455w4NzU1pXTp0uqiwLPvqXKukMy5Mh/+74R+XoWE50+uA5iZmeV6z/Q6hQVRMt25c0dd8Mgpfly+fFn93tzIyAhbW9sXNjs7O6ytrRVO/+6Sk5OJjIwkIiKCiIgIzp8/T1hYGI8ePcLY2JiGDRvi4eGBp6cnzZs3l/9HotC5dOkS9evXZ9myZVqddvLXX3+lX79+7Nu3T6ujSIRykpKSCAwMZOnSpQwePJhZs2ZhZGSkdCyhHYWvyJGWlsaHH37IxYsXOXDgAE5OTkpHEkIoLD09ndu3bxMXF0dcXFyuAsSzBYm0tDTS0tJITk4mPT09z+kM8pLzYT6nKJJTQHm2kGJlZUW1atV47733qF69eq6r5oQQQgihWT169CArK4vNmzcrHeWdpaamcvv2be7evcutW7dYunQphw8fpnbt2lSvXp34+Hju3bvHv//++8LURHp6epQvXx4LC4tcX3PWLzAyMsLc3Fx9+9l1DXIeK6pTgwrxvNjYWK5du5bnlvM5wNDQkFq1avHee+9RpUoVrK2tqVatmnqUeMWKFalQoYLiox3u3r3LjRs3iImJ4caNG+rbly5dUo8YNzY2xtHRkfr16+Pu7q4eMf6y0UJCFBaDBw9mz549XLlyRat/h2TaqpJpw4YNjBgxAnNzc9asWUPjxo2VjiQ0r3AVOZ4+fYqvry/Hjx/n8OHD1KtXT+lIQogi7mVzF+d1VaEQQgghCp/hw4dz5coV/vzzT6WjvNLDhw+JiYnh+vXrxMTE5Npu3rz5wkUYOjo6VK9enXr16mFpaUmVKlWoVKnSCxdd5BQzhBCvdufOHa5evaoeJf7PP/+oR4nfunWLx48fq/fV1dWlQoUK6oJHxYoVMTU1zVU8NDMzyzX9WM5oplKlSqGjo5NrgXf4b+HvpKQkHj9+THp6uvp2SkoKDx484N69e8THx3P//n3u37+vHnlVunRpqlatSo0aNahRowb29vbUq1cPR0dHatSooZ1vnhAaEBcXR+3atfn6668ZP3681vq9f/8+jo6O+Pv7s2DBAq31K5R3584dPv74Yw4cOMCUKVOYMGGC4gVtoVGFp8iRnZ1N37592bFjB/v378fLy0vpSEIIIYQQQohCYNKkSezdu5czZ84oHQWAzMxMoqOjuXDhAhEREVy8eFFd1MhZPwD+W2vMxsaGmjVrUrNmTapXr46VlRXJycmMHTsWMzMztm3bhr29vYJHI0TJk5SUxO3bt7l//z53797l/v37PHjwQP01OTmZlJQUHj58qP6alJTEm54+yZlO18zMTL3oesWKFalYsSJWVlbq29bW1tSoUYNq1arlWodGiOLkq6++IigoiGvXrlG+fHmt9btu3Tr69u3L3r17adeundb6FcpTqVTMmzePwMBAPD09WbNmDVWqVFE6ltCMwlPk+Oyzz/j555/5/fffad++vdJxhBBCCCGEEIXEjz/+yIIFC7hx44bW+7516xbnz58nMjKSCxcuEBkZycWLF3ny5AmlSpXCxsaGevXq5Spm5Gx5jRjdvHkzAQEBNGnShA0bNmBmZqb1YxJCvL3s7GySk5OB/2ajyMrKyvP/es5oDyHEfx49eoStrS19+vRh1qxZWu27W7duhIWFybRVJVRkZCQ9e/YkPj6e5cuX4+Pjo3QkUfAKR5Fj4sSJ/Pjjj6xfv55u3bopHUcIIYQQQghRiPzyyy988cUX6hOLmpKZmcnly5cJDg7m2LFjHD16VF1YqVy5Mo6Ojjg4OKi/NmjQ4LUX+VWpVMycOZNJkyYxaNAggoKC0NPT0+DRCCGEEIXLggUL+Pzzz4mKiqJWrVpa6/f+/fvUq1cPPz8/fv75Z631KwqPtLQ0JkyYwLx58+jXrx+LFi2SdcqKF+WLHD/++COBgYGsXLmS/v37KxlFCCGEEEIIUQht3bqVbt26kZGRUaBTuSQkJHDs2DGCg4M5fvw4p0+fJj09nYoVK+Lh4YGnpyeenp44OztjYmLy1v2kp6czcOBANm3axLx58xg+fHiBHYMQQghRVGRmZuLk5ESDBg349ddftdr3+vXr6d27N3v27JEZZEqwdevWMXz4cGxtbdm8eTM1a9ZUOpIoGMoWOTZt2kT37t15//33sbOzUyqGEKKE8fPzo0ePHkrHEEIIIcRr+vvvv2nVqhX379+nQoUKb93OgwcPOHLkCIcPH+bw4cNcuHABAAcHB3VBw8PDg9q1axdUdFJSUujSpQtnzpxh06ZNtGnTpsDaFkIIIYqazZs30717d86dO4eTk5NW+/b19SU8PJyIiAjKli2r1b5F4XHt2jW6devGrVu3WL16Nd7e3kpHEu9OuSLH2bNnadq0KY8fP6ZRo0ZUq1ZNiRhFVmxsLCdOnKBbt27o6OgoHadYCQkJITs7G09PT6WjCA0ICQmhYcOGbNmyRekoQgghhHhN586do0GDBly5cuWNLo66d+8eoaGhBAcHc/DgQc6ePYuOjg516tShSZMmtGnThlatWmlsAdSEhAQ6duxITEwMe/fu5f3339dIP0IIIURRoVKpcHd3p3r16lr/XH7nzh3q1q3LyJEjmTp1qlb7FoVLeno6n376Kb/88gujRo1i1qxZBTpaWGidMkWO+Ph43N3dsbe3588//+TXX3+lZ8+e2o5RpG3ZsoVu3bqRmZlJqVKllI5TrPTq1YuMjAw5CV5Myc9XCCGEKHpu3rxJjRo1CA0Nxd3dPd/97t69y8mTJ9VFjTNnzqCrq5urqNG6dWssLCw0nvnOnTu0b9+elJQU9u/fLyPXhRBCiP9n+/bt+Pr6cubMGa1fADBv3jzGjRvH2bNncXBw0GrfovBZvXo1w4cPp2HDhqxfvx4rKyulI4m3s1RX2z2mp6fTtWtXypYty4YNG7TdvRBCCCGEEKKIySlKJCYm5no8Pj6eTZs2MXr0aNzc3KhcuTJdu3bl4MGDeHl5sWHDBu7fv09kZCSLFy/G399fKwWO69ev06RJE7Kysjh69KgUOIQQQohndOnSBTc3N6ZMmaL1vkeOHEmDBg0YNmwYCi9TLAqB/v37c/ToUW7duoWbmxsnTpxQOpJ4S1ofhzN48GCioqI4fvw45ubm2u5eCCGEEEIIUcQYGRlRunRpwsPDuXnzJidOnODYsWNcu3YNPT093N3dad++PdOmTcPLywsjIyPFsoaHh9O2bVtsbW35448/tFJUEUIIIYqar776is6dO3Pq1CkaNmyotX51dXVZsGABjRo1YuXKlXz00Uda61sUTi4uLoSFhdGvXz9atmzJokWLGDBggNKxxBvSapFj7ty5rF+/nt27d+Po6KjNroUQQgghhBBFyMOHDwkJCeHEiROcOHGCrKwsAgMDMTIyomHDhvTq1YtmzZrh6emJoaGh0nEBuHDhAm3atMHZ2ZkdO3ZQrlw5pSMJIYQQhZK3tzeurq5MnTqVHTt2aLVvV1dXPvnkE8aNG4e3tzcVK1bUav+i8DE3N2fnzp1MmTKFgQMHcuLECYKCgtDT01M6mnhNWityREZGMnHiRCZPnkzbtm211a0QQgghhBCiCIiLiyM4OJhjx44RHBzM2bNnyc7OpnLlyjRp0oQKFSrQpUsXgoKC0NfXVzruCy5fvky7du2wt7dn+/btUuAQQgghXkJHR4cvv/ySrl27cvHiRerWravV/qdNm8bWrVsJDAxk+fLlWu1bFE46OjpMnjyZunXrMnDgQG7cuMH69etlJqIiQitrcqSnp9O7d29cXV2ZMGGCNroUosTYtWsXnTt3xsrKCn19faysrPDx8WH79u0v7Kujo5Pn9rr7vckmhBBCCJGfx48fc+zYMebOnUv37t2pVKkSVapUoU+fPgQHB+Pl5cWKFSu4ceMGcXFxbNy4ERsbG0xMTAplgePKlSu0bNkSGxsbdu/ereh0WUIIIURR0alTJ+zt7Zk1a5bW+zY2Nmb27NmsXLmSv//+W+v9i8KrR48eBAcHc/nyZdzd3YmKilI6kngNWilyfPHFF9y6dYu1a9dSqlQpbXQpRLH39OlT+vbtS58+fWjVqhWnTp3i0aNHnDp1itatWxMQEICfnx9paWnq16hUqlwLaz1/P6/H87qdXzv5tSeEEEKIkiszM5Pz58+zfPlyPvnkE9zc3DA1NaVp06b8+OOPAEycOJETJ07w6NEjTp8+zdy5c+nfvz/vvfeeuh1zc/MXFh4vDK5evUrLli2pUaMGe/fuxdjYWOlIQgghRJGgo6PDmDFjWLt2LXfu3NF6//7+/nTs2JHhw4fz5MkTrfcvCq/333+fkJAQKlWqhKenJ/v371c6kngFjRc59uzZw8KFC/n5559zfUgRQrybUaNGsXHjRg4ePMjo0aOpVq0a+vr6VKtWjTFjxrB//35+//13hgwZonRUIYQQQpQQWVlZREVFsXr1aj799FM8PT0xMTHB2dmZUaNGER4ejpeXF2vWrOHmzZvExsayceNGPvvsMxo3bvzSURrm5uYkJCRo8Whe7fr167Rq1YqqVauyZ88eKXAIIYQQbyggIABzc3Pmz4B4NwIAACAASURBVJ+vSP/z5s3jn3/+Ye7cuYr0LwovKysr/vrrLzp16oS3tzfLli1TOpJ4CY2uyXHnzh0CAgIICAigV69emuxKiBIlNDSUxYsXM3jwYNzc3PLcp1GjRvTv35/ly5czZMgQmjZt+k59vskIDRnNIYQQQpQMcXFxhIWFqbfg4GASExPR09PDzs4OV1dXevTogaurKw0bNqRMmTJv3ZeFhQUREREFmP7d3L9/nw8++ICKFSuyb98+TE1NlY4khBBCFDllypThk08+Yfbs2UyaNEnrUz7WrFmTcePGMXXqVPr160flypW12r8o3MqUKcOqVauwsbFh8ODBnD9/ntmzZ6Orq5XJkcQb0OhPZOTIkRgbGzNv3jxNdiNEibNo0SIAunXr9tL9/P39AVi6dKnGMwkhhBCi+FKpVERHR7Nx40bGjx9Pq1atMDMzo0qVKvj5+fH7779TuXJlfvjhB8LCwkhNTSUyMpLVq1czevRomjRp8k4FDihc01WlpaXRuXNnMjMz2b17N2ZmZkpHEkIIIYqsTz75hIyMDFasWKFI/4GBgVhYWPDVV18p0r8o3HIWJF+xYgULFy6kZ8+epKenKx1LPEdjIzn27NnD1q1b2bVrlwzbFpw9e5ZZs2Zx7Ngx4uPjc811KFf9v7mjR48CUL9+/Zfu5+TkBEBwcLDGMwkhhBCieHj69ClXrlxRj86Iiori3LlzPHjwgFKlSlGnTh1cXV3p3Lkzrq6uuLq6UrZsWY3nKixFjqysLHr37s2VK1cIDg7GyspK6UhCCCFEkVa+fHl69+7NwoULGTlyJDo6Olrtv2zZskyfPp1+/foxbNiwfGfMECVbQEAAVatWxc/Pj9atW7Njxw4qVKigdCzx/2ikyPH48WNGjBhB79696dChgya6EEXI4cOHadeuHba2tqxYsQIXFxdMTU3z/aOVM61Szol88aK4uDjgvzcCL5PzvBILeAkhhBCi8IuLiyM8PJzw8HDOnTtHeHg4V69eJSsrCyMjI+rVq4ezszN+fn44Ozvj5OREuXLlFMlaGNbkUKlUDB06lH379nHw4EHq1KmjaB4hhBCiuBgxYgRLly7l8OHDtGjRQuv99+rVi4ULFzJmzBiOHj2q9UKLKBpat27N0aNH6dixI82bN2ffvn1UrVpV6VgCDRU5vvnmGxISEvjxxx810bwoYr788ksyMjJYsGDBa/2hys7Ofuu+cv4IyeiQ/+R8P+SPsxBCCFGyZWZmcvnyZaKiooiMjCQsLIzTp08THx8PQOXKlXF0dKRdu3ZMnDgRV1dX7O3tKVWqlMLJ/4+5uTmpqalkZGS8dIFyTfrmm29YuXIlmzdvxtPTU5EMQgghRHHk7OxMo0aNWLhwoSJFDh0dHebMmYO7uztbtmx55fTgouSqX78+J06coH379jRp0oT9+/dTu3ZtpWOVeAVe5Lhw4QJz584lKCgIa2vrgm5eFEFnzpwBwMXF5bX2l6mVXq1y5cpcv36dhISEl06R8ODBA4AX/i/q6uqSnZ1NVlZWvicvsrKyZCElIYQQoojJzMzk1q1bREZGqgsaUVFRREVFkZaWlmtB8DFjxuDg4ECjRo2oVKmS0tFfycLCAoCkpCRF8q5bt46pU6cyZMgQnj59yqZNm7SeQQghhChsSpUqRYcOHTAwMHjntoYPH87gwYOJi4tT5Jyiq6srffr04fPPP6dDhw4YGhpqPYMoGqpUqcLRo0fx9vbGw8OD3bt306hRI6VjlWgFWuTIzs5m6NChuLi4MGjQoIJsWhRhjx8/BsDExEThJMVH06ZNuX79OufPn39pkeP8+fMANGvWLNfjxsbGJCcnk5ycrD5h8LzExET5mQkhhBCFVGZmJtHR0URERHDx4kUiIiKIiori8uXLZGRkoKuri42NjXp0xueff079+vWxt7dHT09P6fhvxdzcHICEhAStFzmuX7/O8OHDqVOnDosXL2bx4sVa7V8IIYQozDZt2lQgIx969uzJuHHjWLFiBf/73/8KINmb+/7777G3t2fOnDlMmjRJkQyiaDA3N2f//v1069aNNm3asG3bNtq0aaN0rBKrQC/TXrNmDadOnWLp0qVyBXghpKOjo97i4uLw8/PD2NiY8uXLExAQQHJyMjdu3KBTp06YmJhgZWXFgAEDSEpKeqGt9PR0fvjhBxo0aEC5cuUwMDDA3t6eYcOGERISkqvPvPp/nYz5PR4dHY2vry/m5ua59s2rr+JabBs2bBgAW7Zseel+OVcY5uyfI2f+6IiIiHxfGxERIcPthBBCCIU9ffqUS5cusXXrVqZNm0avXr1wdnamXLly2Nvb0717d1auXElaWhodO3Zk2bJlhIWF8ejRI65evcr27duZPn06vXv3pn79+kW2wAFgamoKQHJystb7Hjx4MDVr1sTJyQlfX19UKpVsGto2b94M/FfIUzqLbMVvk39fsslW8Juuri6ZmZkF8ve2TJky9O/fn6VLl77TVObvokqVKowfP57vv/9evR6qEPkpV64cO3bsoGPHjnh7e7/yPJ3QnAKrRKSnp/P111/z8ccfU79+/YJqVhQgler/1qkIDAxk6tSpxMbG0qtXL1avXq0ekjdjxgz++ecffH19WbVqFePHj8/VTkpKCk2bNmX69OmMGDGC69ev8+DBAxYtWsSRI0fw8PDIs89n/wi+Tsb8Hh8+fDhjx44lLi6O3bt3v7SvX3755TW+M0VP48aNGTp0KCtWrOD06dN57hMaGsrq1asZOnQoDRs2zPWcj48PACtWrMi3j2XLltGxY8eCCy2EEEKIfCUmJhIWFsbq1auZMGEC3bt3x83NDRMTE+rWrYufnx8LFizgwYMHtGjRgvnz53P06FGSk5O5du0aO3bs4Pvvv6dv3764uLhQtmxZpQ+pwClV5Ni9ezd//fUXCxYskAu5hBBCCA0bOHAgN2/e5PDhw4plGDt2LBYWFkyePFmxDKLo0NfX59dff2XAgAH07NmTdevWKR2pRCqw6armz5/P/fv3+fLLLwuqSaFBgwYNom7dugBMmjSJBQsWsGvXLg4dOpTr8YULF+YqJABMnjyZ06dPM2fOnFwjJVq0aMGvv/762mtvvK1JkyapF3r88MMPX1o0Kc7mz59PSkoKbdu2ZcqUKfj6+mJpacndu3fZsmUL33zzDT169GD+/PkvvHb06NH89ttvrFy5EkNDQ4YPH46dnR0AV65c4eeff+bUqVMsWLBA24clhBBCFFtPnz4lOjqaixcvcuXKFS5fvsylS5e4fPkyCQkJwH9Xg9WuXZs6derg7e3N2LFj1ffLlSun8BEoy8TEBF1dXa0WOVQqFRMnTqRLly54eXkRFBSktb6FEEKIksjBwQE3NzdWrVpFy5YtFclQtmxZJk+ezODBg/n888+xt7dXJIcoOkqVKsXChQsxMTGhf//+ZGZm0r9/f6VjlSgFUuRISkpixowZfP7551StWrUgmhQa9mwh4tk1HZ59PGeRp+eH5+UM8e3SpcsL7TZo0EDjRQd3d3eNtl9U6Onp8euvv7Jr1y4WL17MtGnTSExMxMzMDHd3d9auXYu3t3eerzU2NubEiRPMmTOHnTt3snbtWlJTUzE0NMTW1hZvb29CQ0PzXZMjr+nEIP+ROEIIIURJkZGRwY0bN4iOjubatWvqr1euXCEmJobMzEx0dHSoVq0aderUwcXFhT59+qgLGdWqVXvp1J4lmY6OjnpdMW3Zv38/58+fZ82aNVrrUwghhCjpAgICmDBhAkFBQRgZGSmSoX///vz44498++23cmW+eC06OjrMnDmTsmXLMmDAAFJTUxk+fLjSsUqMAilyzJgxg+zsbL744ouCaE5ogbGxsfr2s8Pu83r8+RPXd+7cAXjpgteaZGhoqEi/hVXHjh3falopExMTvv76a77++us3fq0UM4QQQpRkjx49Ijo6OteWU9D4559/yMrKAqBChQrUqlWLWrVq0adPH+rUqUOdOnWoXbt2iR+V8bZMTU21WuSYM2cOrVu3xsnJSWt9CiGEECVd7969GTt2LFu3blXsavhSpUrx7bff0r17d8aNG0eDBg0UySGKnilTpmBoaMiIESPIzs5mxIgRSkcqEd65yBEXF8e8efOYOnUq5ubmBZFJFHKWlpbExsZy584datSooXQcIYQQQogCl5iYyPXr1/PcYmJi1AV/c3NzbGxssLGxwc3NDQcHBxwdHalVqxZmZmYKH0Xxo80ix9WrV9m3bx/bt2/XSn9CCCGE+I+FhQUdOnRg1apVik754+fnR8OGDfn666/ZuXOnYjlE0RMYGAjAqFGjyM7OZtSoUQonKv7eucjx7bffUrFiRT755JOCyKNx+Q3/z/mg+uzzVapU4ezZs1SsWPG12ikpV7f7+fkxd+5ctm/fzpgxY3I9FxISwujRowkNDVUkm6GhIY8fP+bp06c8ffqU6tWr8+DBA0WyCCGEEKJwy6uQERkZSWRkJElJScB/00NWq1ZNXcho06aN+nadOnUUm0KhpNJmkWPNmjVYWVm91YhZIYQQQrybgIAAfH19uXXrFtWrV1ckg46ODt9++y0ffPABhw8fpnnz5orkEEVTYGAgWVlZjB49Gl1dXRnRoWHvVOS4c+cOK1euZN68eZQpU6agMmnU88WM5wsTzz5/+/ZtevXqxb59+yhVqlS++5WU4kaOyZMn8+eff/L1119Trlw5OnXqRLly5QgODmbUqFEsXLhQsWxOTk6EhIRw8uRJYmNj8fDwUCyLEEIIIZSVlpZGTEyMert+/bp6aqnr16+Tnp4O/LfYd860Uh4eHvTr1099v3r16i+8DxTK0WaRY/369fTu3Vt+/kK8paZNmwJw9OhRhZMIIYqiDh06YGZmxqZNmxSdHr99+/a0bNmSL7/8Un6fiTc2adIkdHV1GTVqFGXLlmXgwIFKRyq23qnIMWfOHMzMzIrtavFWVlbqk/nTpk1TOs47e3b0ybPFmTd93MzMjBMnTjBjxgxmzZrFyJEjMTY2xtXVlWXLlqnfzBZkn88/DnmPnJk/fz6DBg2iXbt2ODk5sWrVqtf75gghhBCiyMnIyODWrVvcuHFDXcjIuX3jxg3i4+PV+1aoUAEbGxtsbW3x8/NTFzFsbW0VW2dMvDkzMzP1KBtNOnHiBFevXqVPnz4a70sIbXrZZ6mCbis7O/ud+xBClFx6enp07txZ8SIHwA8//EDjxo3Zt28f7du3VzSLKHomTJhAWloagwcPxsDAgN69eysdqVh66yLHw4cPWbx4MZMmTcLAwKAgMxUaGzZsoHXr1nz//fd4eHjg7e2tdKR3kt+bzzd9HMDIyIjvvvuO7777Tit9vu6bcDc3N86dO/da+wohhBCi8HvZ2hg3b95UL/JtYGCAtbU1NjY2ODk50aVLF/W0Ura2tpiamip8JKIgmJqacvv2bY33s23bNmrXri2LjArxDoKDg5WOIIQo4vz9/enYsSM3btxQdE1Yd3d3vL29mTRpEu3atct3Knwh8jNlyhTS09Pp378/enp6+Pv7Kx2p2HnrIsfPP/+MSqViyJAhBZmnUGnWrBnTp09n/Pjx9OvXjzNnzlCzZk2lYwkhhBBCFBt5FTHi4uK4c+cOFy9e5PHjxwDo6+tTtWrVF9bGqFy5MtbW1tSsWVM+cJYA2pquaseOHXTq1Enj/QghhBAif23atMHc3JzNmzczduxYRbN8++23uLi4sHv3blmvS7yVH374gZSUFPr27Uu5cuXo0KGD0pGKFd23edGTJ0+YN28ew4cPx8zMrKAzFSrjxo2ja9euJCUl4efnp567WQghhBBCvFpqaioXLlxgx44dzJ49m1GjRuHt7Y2joyOGhoZYWFjg5uZGnz59WLJkCdHR0VhaWtK1a1eWLFlCcHAwcXFxPHnyhOjoaA4cOMDixYsJDAzE39+fJk2aYGNjIwWOEkIbRY5r165x5coVfHx8NNqPKDjJycl89tln2NjYYGBgQPny5fH09GTs2LGcPHky17737t1j+PDhVK1aFX19fapUqcKQIUNyTW+XIzIykg4dOmBkZISJiQnt27cnKioKHR0d9Zbj2cfi4uLw8/PD2NiY8uXLExAQQHJyMjdu3KBTp06YmJhgZWXFgAED8px+7XUzPtvnP//8Q+fOnTE2NsbS0pK+ffvy77//vrD/868dNGhQrn0OHjxIp06dMDc3x8DAABcXF9avX/9Cxle1ldf3KEd8fDxDhw5VH1/VqlUZNmwYd+/efafjE0IUP89OWaW0999/nw8//JCpU6cqHUUUUTo6OgQFBdGzZ0/8/f05cuSI0pGKlbcaybFy5UoSEhL49NNPCzpPobRixQouXLjA2bNnGTlyJL/88ovSkYQQQgghCgWVSsXt27fznVLq2ZNWOdNJ1axZE1dXV2rWrEmNGjWoWbMmVatWlQWexStpo8ixc+dOLCws8PT01Gg/ouAEBASwY8cO5syZw6BBg9DT0yMmJoaJEyfSqFEj9dS3d+/epVGjRqSnp7N69Wo8PT05e/Ys/fr14+DBg5w5c0Z9EV90dDRNmjTB0NCQ33//HXd3d8LDw3PNZPDslLoqlUp9Qj8wMJCpU6eyfPly/ve//7FgwQL+/fdf9PX1mTFjBtbW1kycOJGFCxeir6/PkiVL1O28ScZn+5w4cSI//PBDrrb19PRYsWJFnhnzmw64bdu2dOnShatXr/L48WMGDRpEr169MDc3zzUP/avaevb5Z8XHx+Pu7k5WVhZr1qyhYcOGnDx5kr59+7J3715CQ0OxtLR8q+MTQhRP/v7+rFixguvXr2NjY6Nolq+++goPDw+OHDlCs2bNFM0iiiZdXV2WL19OamoqnTp14siRIzg5OSkdq3hQvQVHR0fVxx9//DYvfYGurq7qt99+K5C23gSgetnhP/9ceHi4qmzZsipAtXz58nz305bNmzerAFVmZqYi/RdnPXv2VPn6+iodQ2iI/HyFEOLNpaenq6Kjo1UHDhxQLV68WBUYGKjy9/dXubq6qsqVK6d+X6Wvr6+ysbFRtWnTRjVkyBDVDz/8oNq4caPq9OnTqocPHyp9GKIYWLdunap06dIa7cPb2zvf9wqF5X1Ezv+557e8nq9SpYrq3r17r92O0t7mc46JiYkKUG3atCnX47dv3851TEOHDlUBqmXLluXab+vWrSpANWnSJPVjffv2VQGqNWvW5Np3165d+X6vch4/dOjQCxmef/yff/5R/3ye9SYZ8+szJiZGBaisra3zzZgfQBUTE6O+f/HiRRWgatq06Vu19fzzgwcPzvP7unLlShWgGjp06Dsd36vI52jt+eOPP1SdOnVSWVpaqvT09FSWlpYqb29v1bZt217Y91W/016135tsouBp+rxeRkaGyszMTDV79myN9fEmmjVrpvrggw+UjiGKuCdPnqjatm2rsra2zvV3V7y1JW88kiM4OJjIyEhWrlz5pi8t0pycnFi4cCEDBgxgxIgRNGjQgPfff1/pWEJDtm3bJtNeFGNdu3ZVOoIQQhQ6L1vgOyYmRn2lrrm5ea51MYYMGaK+X6NGDXR132o2VCFei6mpKZmZmTx+/BhDQ8MCbz8rK4tjx47x3XffFXjbBSnn/2N+V9I/+/zt27fp1asX+/bte2G01LP7Pd9GUeLn58eKFSvw9/enWrVqtGvXjnbt2tGlS5dcx7Vz504APvzww1yvz7kad+fOnUybNg2AAwcOANCqVatc+77OCB8XFxf1bSsrqzwft7a2BiAuLi7Xa98kY3595rR9586dV2Z93vP/Duzs7ACIiop647by8scffwAvfl/btGmT6/nnFdTxCc17+vQpH330EX/88QdTpkwhKCgIS0tL7t69y5YtWwgICKBNmzasXbuWsmXLAq/+nZYjr99Zef3+yq8d+YxfNOnp6fHBBx+wc+dOxowZo3QcJk6cyIcffsjp06dxc3NTOo4oovT19dm8eTMtWrSgbdu2BAcHU6lSJaVjFWlvXOT45ZdfcHJyKpH/kQMCAjh+/DhLliyhW7dunD59WulIQkPc3d354osvlI4hNGDu3Lny5lYIUWLFxsZy5coVrl69ytWrV9W3Y2JiePLkCQAGBgbqooWDgwPe3t7q+zY2NuoTEkIowdTUFICkpCSNFDnOnDlDUlLSCydgizIrKyv+/PNPvv766zxPjhcHy5cvx9vbm3Xr1vHXX3+xbNkyli1bRvXq1dmxY4f64rR79+4B/3eS/HnR0dHq2w8ePACgQoUKufZ5nTUpjY2N1befLfzm9fjzJ2HfJGN+ferr6+fZ9qskJSUxc+ZMtm3bRmxsLI8ePVI/V1DrX9y/fx948fuacz/n+J9XEMcntGPUqFFs3LiR48eP5zpvVK1aNcaMGYOHhwdNmjRhyJAhrFmzRsGkoijx8fFRr2Ok9NrAH3zwAa6ursyYMaNQrBUiii4TExN27dqFp6cnPj4+/PXXX5QrV07pWEXWGxU5kpOT2bRpEzNnztRUnkJv3rx5hIWFERYWRkBAgNJxhIZUqVIFf39/pWMIDdi6dSsZGRlKxxBCCI158OABV69e5fLly+piRk5B4/Hjx8B/b6hr166NnZ0d3bt3p1atWuoiRn4n1oQoDHKKHMnJyRr5t3rs2DEqVqxI3bp1C7xtpWzYsIHWrVvz/fff4+Hhgbe3t9KRNMLX1xdfX1+ys7MJDg5m2rRp7Nu3j48++oizZ88CYGlpye3bt0lISMDc3Pyl7VWoUIG7d+/y4MGDXP/WcoofmvImGQta9+7dOXDgAN988w2ffvopFhYWQMFe/V6pUiXi4uLy/b7KVaxFW2hoKIsXL2bw4MH5XhjbqFEj+vfvz/LlyxkyZAhNmzZ9pz7fpNglhbGiq0OHDgDs27ePHj16KJzmv7WXevbsSWRkJI6OjkrHEUVY5cqVOXDgAF5eXvTo0YPt27dTuvRbLaFd4r3RfALr1q0jOzubXr16aSpPoVemTBk2b96Mubk5v//+u9JxhBBCCFECqVQqbty4wZ49e/jpp58YNGgQHh4eWFhYULFiRTw9PRk2bBi///47WVlZtG/fnnnz5nH48GHi4+NJTk7m1KlTrFu3jilTptC/f3+aNGkiBQ5R6OVcvampxcfDwsJwc3MrVqM+mzVrxvTp01GpVPTr14+YmBilIxU4HR0dYmNjgf9GSDRt2pQNGzYAcPHiRfV+Xbp0AeDQoUMvtHH06FE8PDzU99u1awfAn3/+mWu/4ODgAs3+vDfJ+DZyRkA9ffqUx48f5xpRkXNsX3zxhbrAkTPK703byo+Pjw/w4vf14MGDuZ4XRdOiRYsA6Nat20v3y7mgcOnSpRrPJIoHMzMzvLy81FP6Kc3Pzw97e3t++uknpaOIYsDW1pbt27fz999/M2LECKXjFFlvVBr65Zdf6N69u9avKClsatSowdq1a/H29pYrAYQQQgihMVlZWcTExBAVFaXeLl68yMWLF0lNTQX+u/rHwcEBNzc3+vXrh52dHXZ2dlSvXl3WxxDFzrMjOTQhLCzslSfniqJx48Zx4sQJtm3bhp+fH8ePH8fAwEDpWAVq0KBBzJo1C1tbW5KSkpg7dy4A7du3V+8zefJk9u/fz4gRI8jKyqJly5bo6+tz+PBhRo8ezfLly3Ptu3PnTiZMmECVKlVwd3fn3LlzLF68WKPH8SYZ34aTkxMhISGcPHmS2NjYXEWTpk2bsm/fPr7//nvGjx9Pdnb2S6c4e1lb+ZkyZQp79+5Vf18bNmzIqVOnmDhxIu+99x6TJ09+p+MTyjp69CgA9evXf+l+Tk5OgOaLhqJ48fHxYdq0aWRmZip+pbuuri5jx45l6NChTJs2TS4UEu/Mw8ODdevW4evrS506dfj888+VjlTkvPYn37CwMM6cOcOgQYM0mUfjdHR0cl2Z9bL7zz/3rA4dOvC///1Ps2GFEEIIUWLExcWxZ88efvjhB3r37k2DBg0wMjLCzs6Ozp07s2jRIu7du0ezZs2YM2cOwcHBJCYmEhcXx8GDB5k/fz6ffPIJbdu2lQXARbFlZGREqVKlNFLkePToEVeuXMm1wHFxsmLFCmxtbTl79iwjR45UOk6BOnbsGFZWVnh7e2NsbEydOnXYvXs306ZN47ffflPvV6FCBUJDQ+nVqxfjx4+ncuXK2NnZsWTJEn799VeaN2+u3tfGxoZjx47h7OxMp06dsLa2ZsaMGQQFBQG88Dv2+c+Ub3v7TTK+adsA8+fPx9nZmXbt2jFnzhxmzZqlfm716tX069ePZcuWYWlpSfPmzWnUqNFbtZVfBktLS0JDQ/Hx8aFfv35YWFjQr18/fHx8CA0NxdLS8p2OTygrLi4OgPLly790v5znZfF48SZ8fHxISEjg+PHjSkcBoHfv3lhYWGi8+C1Kjs6dO/PDDz8wbtw4mT3oLbx26XPDhg3UqlWLJk2aaDKPxr1q5MWbjMz47rvv+O677941khBCCCFKkKdPn3Lx4kXCw8NzbTmLsVavXh0nJyfat2/PmDFjcHBwoG7duhgZGSmcXAjl6ejoYGxsrJEix7lz58jOzsbV1bXA2y4MTE1N2bJlC40bN2bZsmV4eXnx0UcfKR2rQHh5eeHl5fVa+5qbmzNr1qxcJ+Tz4+joyO7du3M9lnMS9/mpmfL7HPmmj79Jxrdp283NjXPnzuX5XKVKlVi9evULj3fv3v2N23pZBktLSxYtWqSe2ig/b3N8omh49sJSIV6XnZ0dtra27Nu3j2bNmikdhzJlyjBo0CAWLVrEpEmTKFOmjNKRRDEwbtw4oqOj6dOnD8HBweqRb+LVXrvIsXXr1mI5dFsIIYQQQlOSk5MJCwvLVcyIiooiIyODMmXK4OjoiLOzM97e3jg5OfH++++X+GlBhXgVMzMzjRQ5wsLCKF++PNWrVy/wtgsLJycnFi5cyIABAxgxYgQNGjTg/fffVzpWoaWj/I6jCwAAIABJREFUo8PVq1extbVVP3bkyBEAWrZsqVQsIQqtypUrc/36dRISErCyssp3v5yF5p+f4kdXV5fs7GyysrIoVapUnq/NysqS0aolWJs2bTh48OBLp9LTpk8++YSZM2eyefNm+vTpo3QcUUzMnz+fq1ev0qlTpxdGOYr8vVaR4+zZs0RHR+Pr66vpPEKIIqZp06bA/82/KoQQJVVmZiaXL18mLCyM4OBgjh07xqVLl8jOzsbc3BwHBweaNWvGZ599hqOjI/Xq1ZMrvoR4C8bGxqSkpBR4u2fOnCm2ozieFRAQwPHjx1myZAndunXj9OnTSkcq1EaMGMHChQuxtLQkJCSEwMBATExMZO0IIfLQtGlTrl+/zvnz519a5Dh//jzAC1fj54zUS05OxsLCIs/XJiYmYmJiUnChRZHStm1bli5dSkJCQr7/RrTJ2tqaLl26MH/+fClyiAKjp6fHpk2baNy4Md7e3hw+fBhDQ0OlYxV6r1Xk2Lp1K1WrVqVhw4aaziPeUM+ePWWIZwELCQnBzc1N6RhFRnZ2ttIRhBBC67Kzs7l06RKnTp3i5MmTnDp1ivDwcDIyMjA3N8fd3R1fX1/c3d1p2LDhSz/oCyHejCaLHD4+PgXebmE0b948wsLCCAsLIyAgQOk4hdbBgwf5+eef8fT05N9//8Xc3JyWLVsyZcoU7O3tlY4nRKEzbNgwVq1axZYtW2jXrl2++23atEm9/7Pq1KnDyZMniYiIyHc6ooiICGrXrl1woUWR0qpVKwD+/vtv/Pz8FE7zn1GjRtGsWTNOnTol501FgbGwsGDnzp14eHgwbNiwPKeTFLm9dpHDz89PTqYLIV4QHBysdAQhhNC4pKQkjh07RnBwMKGhoYSFhfHw4UMMDAxo0KABHh4ejB49moYNG2JnZyfvmYTQIGNjYx4+fFigbaanp3Pp0iW++uqrAm23sCpTpgybN2/GxcVFFrZ8idatW9O6dWulYwhRZDRu3JihQ4eyfPlyBg8enOfFg6GhoaxevZqhQ4e+cELYx8eHkydPsmLFinyLHMuWLaNjx44ayS8KPzMzM9zc3Dhw4EChKXI0bdoUV1dXgoKCWLVqldJxRDFSp04dNm7cyAcffIC7uzsjR45UOlKh9soix5UrV4iKinrlomBCGevXr893rkrxdnr16kVGRobSMYQQQigoPj6eo0ePcvToUY4cOcKFCxdQqVTY29vTqFEj/P39cXd3x8nJCT09PaXjClGiaGIkx40bN8jMzKROnToF2m5hVqNGDdauXYu3t7cs5CyEKDDz588nJSWFtm3bMmXKFHx9fbG0tOTu3bts2bLl/2fvvsOauv4/gL/DCAIBQaaAggNxUBcKCOIGtYpVtChaR11Irfqtbd0K1qpQ66q27gEunFRR60BEERX166hC6wIRkD2Uocg4vz/8JV8iAQkkuQE+r+fJ88DN5Zx30Fxy7+eec+Dr64vRo0dj06ZNFX52zpw5OHToEPbu3QstLS34+PjA2toawIdrU3/88Qdu376N33//XdEviygRV1dX7N+/n+sYYnx8fDBz5kz88ssvtH4CkakBAwbAz88Pc+fORceOHSstABPgk6s1hYSEwNjYGE5OTorIQ0idxOPxRI9Xr15h5MiR0NHRgYGBASZOnIjXr1/jxYsXGDZsGHR1dWFqaopJkyYhNze3Qlvp6enw8fGBhYUF+Hw+zM3NMX36dKSmplbYNywsDMOGDYO+vj4aNWqErl27Ijg4uMp8iYmJ+OKLL6CjowMTExN89dVXyMrKqvXrltfvIyYmBp9//jkEAgF0dXUxcOBAxMbGVto3IYTUxKtXr3D06FHMmTMH3bp1g5mZGby8vHDp0iU4ODggODgYaWlpiI2NxZ49e+Dj4wM7OzsqcBDCAXkUOeLi4gAALVq0kGm78vLxZ6Cqvq/q89Lnn3+OxYsXyzcsIaRBUVdXx4EDB7B//36EhYXBzs4O2tra6Nq1Ky5evIj9+/dj//79Ej9D6ejo4MaNG1i+fDlu3boFZ2dnaGtrw8jICBMnToSRkRGio6MrXZPjU8dGUj+4ubnhxYsXor/dymDs2LEQCATYs2cP11FIPbR48WIMGzYMnp6eSE5O5jqO0vrkSI7w8HC4urrSaAFCqsAYE314mj9/Pn7++Wfs3r0bixcvxu+//46srCzw+XwEBATAzMwMCxcuxJYtW8Dn87F9+3ZRO2lpaXBwcMC7d+8QFBQEJycn3Lt3D+PHj0dYWBju3r0LPT090f6urq4YPnw4nj59isLCQkydOhVeXl7Q19fHwIEDJeZbuHAh/P39xXKoq6vX6I9x+Xbl8ft4/vw5evbsCS0tLZw6dQr29vZ48OABpk+fLtYXIYRI68WLF7hw4QKuXLmCq1evIikpCRoaGrC3t8egQYPw888/w9nZGTo6OlxHJYR8REdHB0+fPpVpm3FxcTA0NKwzi9l+6vOPNJ+PVqxYgRUrVtQ2EiGEiBkyZEiNppXS1dXFsmXLsGzZMql/ls4NGwYHBwdoaWnhypUraNmyJddxAACampoYN24c9uzZg/nz51NxjcgUj8fDnj17RDMKREREgM/ncx1L6VQ5kqOkpAQ3btxA7969FZWHkDpv6tSpaNeuHRo3boxFixYBAM6cOYM5c+ZU2H727Fmxn/X19UVCQgJWrVoFNzc3CAQCuLi4YP369YiPj8eaNWsq9Ld+/XoYGhqiefPm+O233wAAK1eurDTftGnTRDnmzZsHALhw4YJMXrsktfl9+Pn5ITc3FwEBAejXrx8EAgGcnZ1F+9fGokWL4OXlBW9vb8ybNw8//fQT9uzZg7t376KwsLDW7RNClEthYSHOnj2LOXPmoG3btmjRogXmzp2LrKwszJgxA1evXkVubi6uXr2Kn3/+GYMGDaICByFKSh4jOeLj4+vMKA5CCCGkIePz+bC3t0dkZCTXUcRMnDgRT548wc2bN7mOQuohHR0dhISEICYmBj/88APXcZRSlSM5bt++jby8PCpyECKFrl27ir42NTWVuN3MzAzAh+lRygsNDQUADB48WGy7cM690NBQsQLGx3eqCOcrjY2NrVY+YY6UlJRK96+t2vw+Ll68CADo16+f2HZZTJ+3cePGTxYzVFVVoaOjA3Nzc3z22WdwdHTEoEGDYG1tDRWVT872RwjhWFxcHMLCwhAaGoqwsDC8e/cOLVu2xNChQ7F582a4uLhAQ0OD65iEECnJq8ihLHeDkg/GjBlDd8ISmUtKSuI6AiFEBnr16oUDBw5wHUNM165d0bFjRwQGBqJHjx5cxyH1kI2NDXbs2IExY8agZ8+e8PT05DqSUqmyyHHlyhU0bdoUbdq0UVQeQuq88nf+lr8QLmn7x0WK9PR0AP+76P+x58+fi77Ozc3FL7/8gpCQECQlJSE/P1/0XFVrbJTPIRzeJs9hvbX5fWRmZgIADA0NxbaXn7KrpgoKCpCcnIy0tDSkp6fjzZs3iI+PR2xsLB4/foxXr14hOzsbubm5yM3NRUxMjGi9E1VVVVhYWKBnz5746quv0KtXL2hpadU6EyGkdrKyshAeHo6wsDD89ddfSExMhIGBAfr164eNGzfi888/h4WFBdcxCSG1JK81OT6+yYQQQgghysnFxQU//fQTkpKSlOrz/YQJE7BixQqsW7eOrhEQufD09MSVK1cwdepUdO7cma7Zl/PJIgeN4iBEcUxMTJCcnIzs7Gzo6+tXua+npycuXrwIX19fzJ49G02aNAGAenXHm6GhIdLS0pCZmSlW+BEWP2rL3Nwc5ubmVe6TmZmJ8PBwnDt3DidOnEBBQQGaNGmCzMxMHDhwAAcOHICqqio6dOiAr7/+GmPHjoWxsbFM8hFCPu3ly5c4d+4cQkNDce7cOTDG0LlzZ4wdOxYDBgxAnz59oKb2ySXICCF1CE1X1TAEBwfTupBE5o4fP45Ro0ZxHYMQUktOTk7g8/m4du0axowZw3UckfHjx2PhwoU4efIkvLy8uI5D6ql169bhxo0bGDduHKKiomh9jv9X6XwrJSUliIqKoiIHIQo0fPhwAEBERESF5yIjI8WGPEZFRQEAvv/+e1GBo6ioSP4hFcjNzQ0AcOnSJbHtwteuCIaGhvD09MTu3buRkpKCP/74A8bGxnj79i28vLywaNEitG3bFg8fPsTcuXPRtGlT9OvXD0ePHkVJSYnCchLSkDx+/BirV69G9+7dYWlpiXnz5qFx48Y4dOgQsrKycOfOHfj7+2PAgAFU4CCkHtLR0cG7d+9QXFwsk/YyMzPx5s0bmq6KEEIIqSO0tLTQtWtXpVuXw9jYGIMGDUJgYCDXUUg9pqGhgSNHjuDx48cyWbO2vqi0yBETE4O8vDz07NlTkXkIadD8/PxgbW2NmTNn4tixY8jKykJeXh5Onz6NSZMmwd/fX7Svi4sLAGD16tXIzc1FdnZ2vTu4+fn5QU9PDwsWLEB4eDjy8/Nx7do1bNu2jZM8mpqamDZtGv7++28EBQUhPDwcR44cweHDhxEfH4/vv/8eAoEAERERGD16NKysrLBhwwaZ321KSEMUExMDPz8/dOvWDW3btsXatWvRrl07nDp1Cmlpadi/fz9GjRqFxo0bcx2VECJnwikvy0/VWRsvX74EAFhaWsqkPUIIIYTIX69evXD16lWuY1QwceJEXLx4EYmJiVxHIfVY69atsWnTJqxbtw6nTp3iOo5SqLTI8ejRI/D5fNjY2CgyDyF1UvkpomrztaGhIaKjo+Hl5YV58+ahadOmsLa2xvbt23HgwAGxkVVBQUEYP348du3aBRMTE/Tu3RsODg4yyVFdsnrdlX3dsmVLXLt2DZ06dcKwYcNgZmaGgIAAbN68GQA4W/ybx+Nh3LhxuH//vmjkRn5+PtasWYP09HTs27cPNjY2SElJwfz589G8eXMEBATg/fv3nOQlpC4qKytDVFQUfvjhB7Rs2RK2trbYs2cPevbsiYiICKSlpSEoKAju7u60eDghDYywyCGrmwiEa6KZmJjIpD1CCCGEyF+PHj0QGxuLN2/ecB1FjLu7O/T19XHw4EGuo5B6buLEiRg/fjy+/vpr0U07DVmVIzlsbGygrq6uyDyE1EmMMbFHTbcDgL6+PtauXYu4uDi8f/8eqampOHXqFBwdHcX2MzY2RlBQENLS0lBUVISHDx/C09NTZjkU+bqrytGhQwecPXsW+fn5ePPmDUJDQ9GoUSMAFRckVzRTU1P89ddfaNeuHfr374+nT59CQ0MD48aNQ0xMDHbt2gVDQ0MUFBRgyZIl6NSpU4Wptwgh4h4/fiwa1dazZ0+cOHEC7u7uiIyMxIsXL7Bhwwb07t2b5mknpAGTdZEjMzMTfD5f1C4hhBBClJ+DgwPKyspw584drqOI4fP5GDFiBI4fP851FNIA/P777zAyMsKUKVNqdF2vPqlyJIetra0is5A66t27d1iyZAlatWoFNTU18Hg8qUYFCPevTwtmE9nh8Xh49uyZ2DbhkNS+fftyEUmMtrY2Tp8+jWbNmmHChAkoKysD8GGUyaRJk/D06VMsXboUPB4PmZmZcHV1xbfffouCggKOkxOiPHJycrBlyxY4OTmhbdu22LVrFzw9PfHw4UPExcVh48aN6NmzJ/2dIIQAkH2RIyMjA0ZGRnSMIUqHzrMIIaRyTZs2RbNmzRAdHc11lApGjhyJO3fuICEhgesopJ4TCAQ4ePAgrly5Ipr1pKGqciRHhw4dFJmF1FG+vr5YuXIlJk+ejDdv3uD8+fNS/XxDrzSST5s5cybi4uJQUFCAS5cuYf78+dDV1YWfnx/X0QB8+KOyb98+3Lt3r8IfFS0tLSxduhTR0dEwNjaGpqYmAgMD0aVLF8TGxnKUmBDulZaWIiwsDBMmTICFhQXmzp0LCwsLnDp1CvHx8Vi9ejXdbEEIkUjWRY6srCzOR4cSIgmdZxFCSNUcHByUssjRv39/6OnpISQkhOsopAHo2rUrFi1ahHnz5iEmJobrOJyRWOQoLCzEixcvqMhBquXw4cMAAB8fH2hpacHNzY0+UNdh5e/4quqhKGFhYRAIBHBycoKenh68vLzg6OiI6OhotG3bVmE5PqVt27aYP38+li5dKnEh1C5duuDOnTuYNGkSCgoKUFxcjB49euDMmTMcpCWEOzExMViwYAHMzc3h6uqK2NhYrF+/Hunp6Thy5Ajc3d2hpqbGdUxCiBLT0dEBj8eTWZHjzZs30NXVlUlbhMgSnWcRQkjV7O3tlbLIoa6ujiFDhtCUVURhlixZgo4dO2LChAkoLi7mOg4nJBY5/vnnH5SVlVGRg1RLYmIiAKBJkyYcJyGy8PH6GJU9FKV///44fvw4UlNTUVxcjPT0dBw+fFipChxC3333HUpKShAcHCzxeU1NTfz+++/YsWMHkpKSYGpqimHDhmH79u0KTkqIYuXk5GDDhg3o2LEjbG1tcfz4cXzzzTeIj4/HnTt3MH36dJoLnxBSbSoqKtDS0pLZQqMFBQXQ1taWSVuEyBKdZxFCSNUcHByQmpqqlIsue3h44Pr163j16hXXUUgDoKamhsDAQPzzzz9YvXo113E4IbHIkZycDABo1qyZQsOQukm4BgEhDZ2enh48PDywY8eOKvebMmUKDh8+jJcvX6J9+/aYMWMGtm3bpqCUhCjOrVu3MHnyZJibm2Pp0qVwdHTEtWvX8OTJEyxbtgxWVlZcRySE1FE6OjoyG8mRn58PgUAgk7YIkSU6zyKEkKrZ2dlBTU1NKUdzDBo0CJqamjh58iTXUUgD0bZtW6xevRorVqzArVu3uI6jcBKLHJmZmdDR0UGjRo0UnYfUMeWnLRJOY7RgwQIAwOvXr/Hdd9+hZcuWaNSoEQwMDODk5IQffvihQb7ZSMMwduxY3Lp1CxkZGVXu5+Hhgb/++gvPnj1D9+7d4ePjg8DAQAWlJER+CgoKsGPHDtjZ2cHBwQH//e9/sXbtWiQnJ2P79u1wdnamBVAJIbUmyyJHQUEBtLS0ZNIWIbJC51mEEPJp2traaNu2Le7evct1lAo0NTUxePBgnDhxgusopAGZPXs2evfujcmTJ+P9+/dcx1EoiUWOjIwMWnyPVEv5aYuE0xj5+/sDACZOnIgNGzZgzpw5yMrKQkpKCvbs2YO4uDg4ODhwFZkQuXJwcACPx8OdO3c+uW+fPn1w5MgR3L17Fy4uLpg+fToiIyMVkJIQ2UtJSYGfnx8sLS0xa9YstGrVChcvXsSDBw/g4+ND890TQmRKlkWOoqIiaGhoyKQtQmSFzrMIIaR6unTpgvv373MdQ6IRI0YgIiICubm5XEchDQSPx8OuXbuQkJDQ4KatqnQkBxU5SG1dvnwZAGBubg5tbW3w+XzY2Nhg8+bNHCcjRH6aNGmCFi1a4Pbt29Xa393dHZs3b0ZkZCQ6d+4MDw8PJCQkyDklIbJz8+ZNjBkzBs2bN8eOHTvw3XffISkpCUeOHMGAAQO4jkcIqad0dXVlVuQoKyuDiorE0yJClBKdZxFCyP907txZKUdyAMDAgQNRVlYmOm4TogiWlpb46aefsGrVKsTExHAdR2HUJG3MyMiAkZGRwkLcvHkTqqqqCuuvPlDG+QY/NnLkSOzZswdffvklmjVrBjc3N7i5uWH48OEKXbi6JpKTk3H06FGuYxA5SExMhImJiVz7aNeuHeLi4qq9v7e3N/7991/s3LkTZmZmGD9+PCIiIuiCC1FaZWVlOHHiBH799VdER0ejW7du2LNnDzw9PcHn87mORwhpALS1tZGfny+TthhjUv3NDQkJoWn3CKfq8nmWslBTk3gphBBSA1z/TezcuTPS09ORkpKCpk2bcprlYwYGBujatSsuXryIESNGcB2HNCBz5szB0aNHMWXKFERFRTWI6+4S/7JnZWXBwMBAIQEYY9i4cSM2btyokP6I4uzevRtDhw7FwYMHER4ejl27dmHXrl1o3rw5Tp48ic6dO3MdsVK3bt2Cp6cn1zGInMj7w4W+vj5ycnKk+plffvkFN2/eRFZWFm7fvo01a9Zg/vz5ckpISM0UFRUhKCgIa9aswfPnzzF8+HBERkaiZ8+eXEcjhDQw2traKCgokElb0o7ksLe3x/fffy+TvklF0dHRWLt2LdcxlFpdPs9SFsHBwXRDESEyMmbMGE7779KlC3g8Hu7du6d0RQ4AcHNzw+HDh7mOQRoYFRUVbNu2Dd26dcOWLVvw7bffch1J7iQWOQoKCmBhYaGQADweDwcPHuT8oFjXHD9+HKNGjeI6xid5eHjAw8MDZWVliIqKwsqVK3H+/Hl8/fXXuHfvHtfxKjVixAgcP36c6xhEDry8vOS++JKenp7UU06pq6tj3759sLOzQ/fu3eHr64uRI0eidevWckpJSPXl5+dj165d+PXXX5Geno7Ro0fj5MmTaNeuHdfRCCENlLa2NlJTU2XSlqqqKkpLS6u9v7m5Ob788kuZ9E0qogvP1VNXz7OUxahRoxrEXa2EKALX1/P09fXRvHlz3L9/H59//jmnWSRxdXXFqlWrEBcXh5YtW3IdhzQgn332GebNm4cFCxZgyJAhaNGiBdeR5EriJ0jGGOfDzUjdx+PxkJSUBODDyYqLi4uoev3PP/9wGY0QudLS0sLbt2+l/rnWrVtj3bp1uH79Opo3b053iRLO5ebmwtfXF82aNcPSpUsxevRoxMXFISgoiAochBBOCQQCmY3k0NLSQmFhoUzaIkQR6DyLEELEdenSRWkLvE5OThAIBLhw4QLXUUgDtGTJEjRr1gyzZs3iOorcUZGDyNXUqVMRExODoqIipKWlISAgAMCHxZcIqa8KCgqgra1do5+dPHkynJ2doaKiglOnTuHixYsyTkfIp+Xm5sLPzw9WVlbYtGkTvvvuOyQkJODXX3+Fubk51/EIIUSma3LU9OYEQrhE51mEEPI/nTp1wt9//811DIn4fD569+5N5/aEExoaGti6dSvOnj2LkydPch1HriQWOTQ0NFBUVKToLKQOKl8M4/F4Yt9fu3YNpqamGDp0KHR0dGBjY4OzZ89i5cqVOHToUKVtEFLX5efnQyAQ1OhneTweNm7ciOfPn+Ozzz6Dn5+fbMMRUoW8vDwEBASgZcuWWLduHWbMmIG4uDgsW7YM+vr6XMcjhBARWa7JQSM5iDKi8yxCCKm+9u3b4/nz53j37h3XUSRydXVFeHg4SkpKuI5CGqDevXvDy8sLs2fPrtefeSWuyaGrq4u8vDxFZyF1EGOs0uecnZ3h7OxcqzYIqYvy8vJqXOQAgM6dO2PGjBkIDg7Gw4cPcfnyZfTt21eGCQkRV1hYiN9++w2//PILGGP47rvvMGfOHDRu3JjraIQQIpEsixx6enp48uSJTNoiRFboPIsQQqqvQ4cOKC0txZMnT9CxY0eu41QwYMAA/Oc//8GDBw9gZ2fHdRzSAK1duxZt27bFL7/8Um9vppU4kkNXVxdv3rxRdBZCCKkXEhMTYWFhUas2Fi9ejMLCQlhbW8Pf319GyQgRV1xcjG3btsHa2horV67Et99+ixcvXmDZsmVU4CCEKDVZFjlMTExktog5IYQQQhSvTZs2UFdXR0xMDNdRJGrfvj309fVx48YNrqOQBsrU1BRLly6Fv78/nj59ynUcuZBY5DA1NUVKSoqisxBClFhwcDAcHBygr68vGjIvadh7Vc81FHFxcWjRokWt2jA1NYW3tzcyMzNx8eJFPHv2TEbpCPlwZ+fRo0dha2uLWbNmYejQoXj69Cl++uknKm4QQuoEWa7JYWJigrS0NJm0RQghhBDFU1dXR+vWrREbG8t1FIl4PB66d++O6OhorqOQBmzOnDlo06YNvv/+e66jyIXEIkezZs3w8uVLRWchhCipoKAgeHl5wcDAAPfv38e7d+9w/Phxifs29GHxeXl5yMrKqnWRAwDmzZuHoqIi6OnpYdeuXTJIRwgQGRkJe3t7jBkzBvb29nj8+DG2bdsGU1NTrqMRQki1aWtro7i4GMXFxbVuy9TUFAUFBWLT9b558wZlZWW1bpsQQgghitGhQwelHckBAD169KCRHIRTampq+P3333H69GmcPn2a6zgyJ7HI0bx5c+Tk5OD169eKzkMIkSFZjahYt24dgA9z+FlaWkJDQwMeHh4NvqAhiXBO71atWtW6LVNTU3z99dfg8XgIDAykiy2kVuLj4+Hp6YlevXqhSZMmuH//Pvbt2yeTghwhhCiacO0rWYzmaNmyJQCIRk0ePHgQZmZm2LBhQ63bJoQQQohitG/fXmlHcgCAo6Mjnj9/TqNHCadcXFzg6emJuXPnyuRmIWUiscjx2WefAQD+/vtvhYYhhCgn4YX71q1bc5xE+d25cwc6OjqwtraWSXszZ85ETk4OUlJScP36dZm0SRqWgoIC+Pn5oX379njw4AGOHDmC8+fPi/7WE0JIXaStrQ0AMlmXo1WrVtDQ0MCDBw8wdepUjBs3DgUFBdi/f3+t2yaEEEKIYnTo0AHPnj1DUVER11EkcnR0hIqKCm7dusV1FNLA+fv7IzExEVu2bOE6ikxVOl2VoaEh7t27p+g8hBAl9PbtWwAf5rkkVbt9+zbs7OygoiLx8Cq1du3aoU+fPhAIBJVOEUaIJIwx7N69G61atcKmTZsQEBCAR48e4csvv+Q6GiGE1Josixxqampo1qwZfvzxR+zdu1e0/f79+0hKSqp1+4QQQgiRvzZt2qC0tBRxcXFcR5FIT08PNjY2uHnzJtdRSANnZWWFWbNmwc/PD9nZ2VzHkZlKr8LZ2dnRgjiEKEBqaiq8vb1hYWEBPp8PCwsLzJgxo8IQxsoW9K5q+8f7TJ06Vep8ktr5+FFd6enp8PHxEb1Wc3NzTJ8+HampqVLnUlZ37txB9+7dZdrmzJkzUVBQgBMnTsi0XVJ/3bt3D87OzvD29oanpyeePn2K2bNnU6GSEFJvyLI3YFBfAAAgAElEQVTIERQUhMTEROTm5qK0tFS0XVVVFadOnap1+4QQQgiRP2tra/B4PDx9+pTrKJVydHSkIgdRCosWLYKqqioCAgK4jiIzlRY5+vbti0uXLtGc+4TIUWpqKuzt7XH69GkEBQUhKysLgYGBOHnyJBwcHMQKHZW9F6uznTEGxhh27twpdUZJ7Qgf0khLS4O9vT1CQkKwe/duZGdnIzg4GBcuXICTkxNyc3OlzqZs8vLyEBMTg27dusm03S+++AKNGzfGy5cvER8fL9O2Sf2Sm5uLOXPmoHv37iguLsb169fx22+/oUmTJlxHI4QQmRIWOWqzJsfbt28xa9YsTJw4Ee/fv0dJSYnY82VlZTh27FitchJCCCFEMbS1tdG0aVOlLnJ07tyZlgYgSkFPTw9LlizBhg0b8Pz5c67jyESlRY4BAwYgLS0NDx48UGQeQhqUZcuWITExEQEBAejXrx90dHTQv39/+Pv7IyEhAb6+vlxHlBlfX18kJCRg1apVcHNzg0AggIuLC9avX4/4+HisWbOG64i1dvXqVZSWlqJ3794ybVdNTQ2jR4+GiooKwsPDZdo2qR8YYwgKCkLbtm0RHByMnTt34tatWzIfVUQIIcpCuPB4TUdyJCYmomPHjti6dSsAyTeNlJWV4erVq3X2Rozg4GA4ODhAX1+/yhG4NRmdSwipX5T1OKCsueSBjtmyYW1trdRFDltbW2RmZtLi40QpfPPNN7C0tMSyZcu4jiITlRY5unbtCisrKxw+fFiReQhpUE6fPg0A6Nevn9j2AQMGiD1fH4SGhgIABg8eLLa9V69eYs8ryq1btxAeHo579+4hOTlZJm2Gh4fD1tYWJiYmMmmvvHHjxqGsrAwhISEyb5vUbXFxcXBzc8PXX38NNzc3xMTEYNKkSXTiQwip17S0tMDj8Wpc5MjOzkZqauonj5WMMZw5c6ZGfZTn4uICFxeXWrdTXUFBQfDy8oKBgQHu37+Pd+/eVbq2l7KO3FdTU6t0qlR60KOmj1GjRnH9X1suanuMUdbjgLLmkrX6cMxWFm3atFH6IgcAPHr0iOMkhHxYd3f16tU4dOgQ7ty5w3WcWlOr7AkejwcvLy/s378fK1eulNkiuoSQ/8nIyAAAGBoaim0Xfp+enq7wTPIifC1mZmYSn1f08Lj169cjODhY9L2JiQkcHR3Ru3dvjBs3DsbGxlK3GR4eXqFgJSs9e/ZE48aNcePGDbm0T+qekpISrF+/Hr6+vmjdujVu3LgBe3t7rmMRQohCqKiooFGjRjUucnTq1AlPnz7F1KlTcebMGfB4PIkXjlRUVHD8+HGMGzeuVnnLyspq9fPSWrduHQBg7dq1sLS0BAB4eHjUqYtjwcHBdA5KZC46Ohpr167lOobUeLwPBdnK3sOKPsYQ2aoPx2xlYW1tjb/++ovrGJUyNjaGkZERHj16hP79+3MdhxB4eHjA0dERS5Yswblz57iOUyuVFjkAYOLEiQgICMCff/4JDw8PRWUipMEwNjbGq1evkJmZKXbxPzMzU/R8ecIT8OLiYtECwq9fv1Zc4FowMTFBcnIysrOzoa+vz3Uc7N+/H5s3b0ZOTg6Sk5Nx584d3Lx5EytWrMCCBQvwxRdfYMGCBejatWu12ktPT8fff/+N5cuXyyUvj8dDnz59cPLkSeTm5kJPT08u/ZC64eHDh5g6dSru3buHuXPn4qeffgKfz+c6FiGEKJS2tnat1uQwNTXF6dOncfToUUyZMgXv3r1DcXGx2D4lJSU4d+4c3r17h0aNGtW4r6ioqBr/bE08efIEANC6dWuF9itLo0aNgqqqKtcxSD1TXwtnij7GENmqD8dsZWFtbY3k5GQUFBSI1u9SNra2toiJieE6BiEAPlxr+umnn+Dq6oqrV6+KZlupi6r8C29jY4Nhw4bB399fUXkIaVDc3d0BAJcuXRLbHhYWJva8kKmpKQAgJSVFtO3evXuVtq+lpQUAKC4uRmFhYYURI4o0fPhwAEBERESF5yIjI9GjRw+F5lFVVYWBgQFat26N3r174/vvv8fRo0fx6tUr7Ny5Ey9fvoS9vT1mz55drUJSaGgoNDQ05Ho3hvAuUkVP7UWUR1FRERYvXgw7Ozvw+Xz8/fff8Pf3pwIHIaRB0tbWrvFIjvK+/PJLPHr0CM7OzhIvgL59+1b02ayuePv2LQCIboohhBCivOiYLTvW1tZgjCE+Pp7rKJXq0KEDTVdFlMqAAQPQp08fLFmyhOsotVLlSA4AWLRoERwcHBASEoIRI0YoIhORwrFjx+rt3ShcSUxMlMuaCpIsX74c586dw4IFC2Bubo7u3bvj9u3bWLhwISwtLeHn5ye2v6urK4KCgrBmzRr8/PPPSElJwc6dOyttv2PHjrh58yZu3bqFpKQkhRcSyvPz88OFCxcwc+ZMlJaWom/fvuDz+bhy5QrmzJmD3bt3c5atvEaNGmH8+PH46quvEBQUhB9//BGnT5/GmTNn0K5du0p/LjQ0FP3795fr3SLDhw8Hj8fDqVOnMH78eLn1Q5TTvXv3MGHCBCQkJGDDhg2YMWMGHf8JIQ2aQCCQSZEDAJo3b47w8HDs2LED//nPf1BSUiIa1aGuro6QkBAMHTq0Rm0Lp5kBxKeaKb/95cuX+PbbbxEeHg4tLS24urpi48aNMDAwqFV/5b8ur7pToKSnp8PX1xehoaFIT0+HkZERhgwZgp9++kl08w3wYWSxn58fTp48iVevXkFbWxs2NjZwcnKCp6cnTadI6rTy76OYmBjMnTsX169fR1lZGXr37o1ff/21wnlCWFgYfvvtN0RGRuLt27do37495s2bhzFjxlTa9rNnz/Djjz/i8uXLyM3NBfDhvSrpPT1lyhTReWBlxxhpctTGx8cZb29vbN26FQCQlJSEZs2aVciXmpoKX19fnDlzBunp6TA2NsbQoUOxfPnyap2LV+e4Wtn25ORkzJo1CxcuXACfz8fQoUPx22+/IScnB7Nnz0ZERAS0tLQwaNAgbNiwocII+uoeF6uLjtmyZWVlBQB48eKFaP0LZdOhQwcEBgZWeH8TwqWff/4ZPXv2lOs07HLHquGrr75izZo1Y/n5+dXZXSoqKirs0KFDMm+3vjt27BgDQA85PUaMGKGwf8vU1FTm7e3NzMzMmJqaGjMzM2PTp09nqampFfbNyMhgY8eOZUZGRkxbW5u5u7uzly9fimUv7/bt26xTp05MS0uLOTo6ssePH0ud7+PfTU23M8ZYdnY2mzt3LmvRogVTV1dnJiYmzN3dnd24cUPqXDU1ZswY5uHhUe39MzIymLOzM2vSpAm7cuWKxH0KCwuZtrY22759u6xiVsrQ0JA1a9ZM7v0Q5VFcXMz8/f0Zn89nTk5O7OnTp1xHIoQQpWBvb8/mzp0r83bj4+OZi4sLU1FREX2eady4MSspKZH6c4SQpM9F5bePGzeOxcbGstzcXObj48MAsEmTJtX4NXyqv+psT01NZZaWlszExISdP3+e5eXlsatXrzJLS0vWokULlpOTI9r3iy++YADYhg0bWH5+PisqKmL//vsvGzFihMT+qiI8zykpKZHq5wipjpr+/xK+R5ycnNi1a9dYXl4eCwsLY6ampkxfX5/Fx8dX2H/48OEsIyODJSQkMFdXVwaAnTt3rtK2XV1dWVRUFCssLGRnz56VeI71qXyStkuboyY8PDwYALZgwYIKz61YsULseJaSksKaNWvGzMzM2KVLl9ibN29Ev0tLS8sK58GyOJ6V3/7VV1+JjrczZ85kANiQIUPYiBEjKhyHp02bJtaGNMdFadTlYzZjynddz9DQkG3atInrGJW6cuUKA8CSkpK4jkKIGDc3N+bk5MR1jJraXq2jV2pqKtPT02PffPONzBMo28GwrqAP//JT05NXUjfU5N/37du3bNSoUUwgELD79+9XeD40NJTxeDyWnJwsq5iV6t27N1NRUWFv376Ve1+EezExMaxbt26sUaNGzN/fn5WWlnIdiRBClEafPn2Yj4+PXNouLS1l69evZ3w+X1TsuHr1qtyKHBEREaJt8fHxDAAzMzOrcX5ZXDDz9vZmANiuXbvEtp84cYIBYIsWLRJt09XVZQDY0aNHxfZNTk6mIgdRKrUtcpw9e1Zs+969exkANnHixAr7ly98/PPPPwwAc3FxqbTty5cvf7J/aZ+vSY6auHXrlqgg/Pr1a9H2wsJCZmJiwmJiYkTbpk2bxgCwffv2ibUh/F16e3tX+7XVZHv5463wGPXx9sTERAaAmZubi7UhzXFRGnX5mM2Y8l3Xs7OzYz/88APXMSqVkJDAALCoqCiuoxAi5vbt24zH47G//vqL6yg1sb1a81yYmJhgx44d2LJlCw4dOlTpfsLFkuuj4OBgODg4QF9fHzweT/T4WFXPEULqpkaNGuHQoUNwcHDA559/juTkZLHnjx07BkdHR7HF4+XF2dkZZWVluHHjhtz7ItxhjGHt2rWws7ODqqoq7t+/j/nz59P0VIQQUo6mpqZoHnNZU1FRwX/+8x88fPgQdnZ2AICTJ0/KpS8A6Nq1q+hr4eeJ8muwcUG4BtjgwYPFtgsXpCy/RtjIkSMBfFjfpHnz5pg6dSqOHDkCQ0PDak+zQuq+d+/eYcmSJWjVqhXU1NTq5Xmxk5OT2PcDBgwAAFy4cEFsO2NMNG0O8GGdAACIjY2ttG15TBFUkxw10b17d/Tt2xevX7/Gli1bRNv37NkDR0dHtG/fXrTt9OnTAFBhOhTh71L4vLyUP96Wn8JJ0nH41atXYj8rzXFR0ZThmB0dHY2ZM2di9erVnC6sbWVlhYSEBM76/xRzc3Ooq6srdUbSMHXr1g1Dhw7FsmXLuI5SI9W+WjJq1CjMnj0bU6ZMQXh4eIXnz5w5AxMTE8yaNQtv3ryRaciPubi4wMXFRa59lBcUFAQvLy8YGBjg/v37ePfuHY4fPy5xX/oQT0j9pKamhqNHj0IgEODrr78WbS8qKsKff/6J0aNHKyRH+/btwePxcPnyZYX0RxQvNTUVgwYNwsKFC7F06VJcu3YNNjY2XMcihBClo6mpicLCQrn20aZNG9y4cQMbNmxA9+7d5daPjo6O6Gs+nw+A+/OK9PR0AB8u9pW/kcvQ0BAA8Pz5c9G+u3fvxvHjxzFy5Ejk5+dj165dGD16NKytrXH//n1O8hPF8/X1xcqVKzF58mS8efMG58+f5zqSzDVu3Fjse+H7ISMjQ7QtNzcXixYtQrt27aCjowMejwc1tQ/LoWZlZVXatpaWlkyz1jRHTS1YsAAAsGHDBhQVFaG0tBRr167F/PnzxfYT/q6Evzsh4ffCY4+8lD/elr+BSNL2j4/D0hwXFU1ZjtkxMTH4448/YGtri0GDBiE1NbVW7dWEpaUlXrx4ofB+q0tVVRUWFhZKnZE0XL6+vrh9+3aF4n1dINUtoWvXrsXw4cMxbNiwChfYrl69Ch6Ph61bt8La2honTpyQadDyysrKUFZWJrf2P7Zu3ToAH16/paUlNDQ04OHhwfmJByE1Vf5DT1UPIk5fXx/79+9HeHg4Dhw4AAA4d+4c8vLyMGrUKIVkaNq0KRhjuHjxokL6I4p18eJFdO3aFU+ePEFERAQWLVokOhklhBAiTktLS24jOcpTVVXFnDlzFHZDg7IQLv6bnZ0NxliFx8eLvnt4eODYsWPIzMzE1atXMXDgQLx8+VLs5hBSvx0+fBgA4OPjAy0tLbi5udW7c+aPiwPC2SyMjIxE2zw9PbF69WqMHj0aCQkJoveMoik6h5ubG7p06YLU1FQEBgbi6NGjsLCwQI8ePcT2MzY2BlBxJhDh98LnP0V4vlpcXCza9vr16xrnrw5pj4uKpAzHbAcHB0RERODly5e4fPkyXrx4gZ49eyI3N7dWr01ayl7kAD5kpJEcRBnZ2dnB1dUV/v7+XEeRmlRFDlVVVQQFBWHo0KEYOHAg/vjjD9FzERERKC0tRUlJCTIzMzFy5EgMHjxYLm/aqKgoREVFybzdyjx58gQA0Lp1a4X1SYg8SfrQI+lBKurevTu8vb0xd+5c5Obm4siRI3B2doa5ublC+m/atCkA4L///a9CLuwQxSgqKsKCBQswaNAg9OzZE/fu3aswHQIhhBBx8pyuigDDhw8H8OE872ORkZFiFy55PB6SkpIAfLgD2sXFRXTB+59//pF/WKIUEhMTAQBNmjThOIn8fHwdIiwsDMCHC/wf7/P999+LfhdFRUW16lc4yqO4uBiFhYUVRkFUlVWWOT5FOGpjzZo1CAgIqDCKAwDc3d0BAJcuXRLbLvxdCp//FOFUU+Wn9rt37570oaUgzXFR0ZTpmM3j8dCnTx9cu3YN79+/x48//ljrNqVhZWWFjIwMTotOn0JFDqLMFi5ciMuXL+P69etcR5GK1JN7q6mp4dChQ1i6dClmzZqFUaNG4cWLF2J/TISjLC5dugQbGxsEBASgpKREdqkVTHjypK6uznESQogyWLlyJYqLi7Fu3TqcOnUKnp6eCutbWOQoLi7G3bt3FdYvkZ/Hjx/DwcEBW7ZsQWBgII4cOQI9PT2uYxFCiNKjIod8+fn5wdraGjNnzsSxY8eQlZWFvLw8nD59GpMmTapwh9/UqVMRExODoqIipKWlISAgAAAwcOBALuITDihytgWubN26FdeuXUN+fj7Cw8OxcOFC6Ovrw8/PT7SPcGrt1atXIzc3F9nZ2Vi0aFGt+u3YsSMA4NatWwgNDa3WxXR55PiUUaNGoVWrVnj27BlKS0vx+eefV9hn+fLlsLS0xIIFCxAeHo68vDzR79LS0lLsd1kVV1dXAB8KKq9fv8a///6LnTt3yvLlVCDtcVGRlPGYbWhoiKVLl+LAgQPIycmRWbufYmlpCQB4+fKlwvqUlpWVldKPNiENV9++feHk5IRffvmF6yjSqc2y5RcvXmQtW7ZkRkZGDEClDxUVFda+fXt28+bNCm2oqKiwQ4cOVbvP8u1Wtv3ly5ds2LBhTCAQMGNjYzZu3DiWmZlZo9dY1euSlKP8z3wsLS2NzZgxg5mbmzN1dXVmZmbGpk2bxlJSUqTOdezYMQaAlZSU1Oh1kcqNGTOGeXh4cB2DyIms/n0XL17MBAIB4/P5LCMjQwbJqk9LS4vp6uqy9evXK7RfInvBwcFMR0eH2dvbs+fPn3MdhxBC6pQFCxawLl26KLTPmnyOqOzcQdrtXPSXnZ3N5s6dy1q0aMHU1dWZiYkJc3d3Zzdu3BDb79q1a2zixInMysqKqaurs8aNG7NOnTqxlStXsoKCAqny14XznLdv37LVq1ezzp07My0tLaahocFsbGyYt7d3hd9NSkoKmz59uugc0NzcnHl7e7PU1FSx/cr/Gzx79oyNGDGC6enpVfh3keac8tGjR2zw4MFMW1ub6ejoMDc3NxYTE1Ph3/vj/wOhoaGiNjZt2sQAsJiYGNG2ffv2fbINAGz+/Pm1/2XLWE3/fwlfU3x8PBs6dCjT0dFh2trabPDgwSw2NlZs37S0NDZ+/HhmbGzM+Hw+s7W1ZYcPH67W+6+y9/zt27dZp06dmJaWFnN0dGSPHz+utA1Z5KiNLVu2MABs//79le6TmprKvL29mZmZGVNTU2NmZmZs+vTpVb4vPs6VkZHBxo4dy4yMjJi2tjZzd3dnL1++lMnxTxbHxeqq68dsxqq+rpeVlcUAsL/++kvqdmsqIyODAWBhYWEK61Nau3fvZlpaWlzHIKRSf/75J+PxeOzhw4dcR6mu7bX768UYKygoYD4+PkxdXb3KQoCamhrj8Xhs2rRp7PXr16Kfl7bIwVjlRQTh9nHjxrHY2FiWm5vLfHx8GAA2adKkGr9GaYsZkranpqYyS0tLZmJiws6fP8/y8vLY1atXmaWlJWvRogXLycmRKlNd+PBfV1GRo36T1b9veno6U1FRYZ07d5ZBKum0bNmS2djYsLFjxyq8byIbxcXFbP78+QwAmz59OisqKuI6EiGE1DnLly9nbdu2VWif9DlR/pT9POfNmzesW7duTEdHh+3YsYOlpqayvLw8dvnyZdauXTux88CUlBTWrFkzZmZmxi5dusTevHnDwsLCmKmpKbO0tKz0gq6rqyuLiopihYWF7OzZs6I2pTmnfPbsGdPT0xP1nZeXx65du8acnZ0lnq8OGzaMAWAbNmwQ2969e3cGgC1YsEBse1BQEBs6dKjE/MqstkUOQkhFn7quZ2ZmxtatW6ewPGVlZaxRo0YsMDBQYX1K68yZMwwAy8vL4zoKIRKVlZUxW1tbNn78eK6jVNd2qaer+piWlhbS0tI+OTS1pKQEjDHs2bMHrVq1QlBQUG27rtS0adPQrl07NG7cGPPmzQMAzleF9/X1RUJCAlatWgU3NzcIBAK4uLhg/fr1iI+Px5o1azjNRwiRTkFBAcrKyjiZ59PQ0BAGBga4deuWwvsmtZeYmIhevXrhjz/+wKFDh7Bt2zbw+XyuYxFCSJ1D01URLvj5+eHOnTtYsWIFpk6dChMTEwgEAvTp0wcHDhwQ23fZsmVITExEQEAA+vXrBx0dHfTv3x/+/v5ISEiAr6+vxD4WLVoEJycnaGpqYvDgwaK18qQ5p/Tz80Nubq6ob4FAAGdn50qnK5o0aRIAYM+ePaJtjx8/xsOHDwEABw4cEFuzb+/evaKfIYSQqmhpaeHdu3cK64/H46Fp06ZITk5WWJ/SEq6rk5mZyXESQiTj8XiYN28eDh06VGemVlOTRSORkZEoLS2t1r7ChcknTpyIkydPyqL7Crp27Sr62szMDID4YlRcCA0NBQAMHjxYbHuvXr1Ez69cuVLhuYhkt27dUug6C0Rxbt68iW7dutW6nb1790JfXx9Pnz7FkydP0KZNGxmkqx5NTU3o6Ojgxo0byMrKgoGBgcL6JrVz5swZTJgwAebm5rh9+zZsbGy4jkQIIXWWpqYmCgsLuY5BGphjx44B+N8iv+V16dJFrBBw+vRpAEC/fv3E9hswYIDY8x+zt7eXuF2ac8qLFy9K7NvJyUli20OHDoWhoSEePHiA+/fvo3PnzggMDMSsWbNw5MgRJCQkICIiAn379kVCQgL+/vvvai8QTQhp2N6/fw81NZlcfqw2c3NzvHr1SqF9SkNY5MjKyoKVlRW3YQiphJeXFxYvXozNmzfj119/5TrOJ9V6JEdCQgIyMjIkPqempgY+nw8ejyfapqqqCiMjI9jZ2YkKELKmo6Mj+lp4d2z5D5tcSE9PB/Ch6MLj8UQP4YHt+fPnXMYjhEiBMYZ9+/ZhypQpaNq0KYKDgxXav6amJnR1dcEYw507dxTaN6kZxhhWrFiBYcOGwd3dHTdv3qQCByGE1JKWllaDGclR/vyhqgeRP+HNc6ampp/cV3ieLDznExJ+LzxH/JiWlpbE7dKcUwrvDv64bz09PYltq6urw8vLC8CHm3nKysqwf/9+TJw4EV999RUAYN++fQCAwMBAjBkzpsGMRC3/3mpI7zM67tQc/e7+hzGG1NRUuV3/q4y5ublSj+QQ3qhIIzmIMlNTU8M333yDXbt2IT8/n+s4n1TrUuqjR4/EvtfT04OFhQWsrKzQokULNGvWTPSwtLSEqampWAX3jz/+qG2EOsHExATJycnIzs6Gvr4+13HIJ9jb2+PIkSNcxyBy4OXlhffv39eqjcuXLyMuLg4TJkxAfn4+zp49i2XLlsko4adpamqCMQYrKyvcunULAwcOVFjfRHr5+fmYNGkSTp48iVWrVmH+/PlcRyKEkHqhIU1XxfUNW+R/TExMkJSUhJSUlE/efWtsbIxXr14hMzNT7AKf8KKWsbGx1H1X95zS0NAQaWlplfYtycSJE7Fp0yYcPHgQgwYNgpGRETp06IAJEyZg5cqVOHbsGDZv3ozAwMAGda7UUN9/DfV1ywL97v7n6dOneP/+PaytrRXar5mZGaKiohTapzQaN24MPp9PRQ6i9Ly9vfHzzz8jMDAQM2fO5DpOlWo9ksPV1RVXr17Fv//+i8LCQuTk5ODhw4cIDQ3Fb7/9hh9//BFjxoyBs7MzLCwsFD5ETVkIhzNHRERUeC4yMhI9evRQcCJCSE3t3bsX9vb2+Oyzz9CvXz/cuXMHubm5CutfeFGne/fuuH37tsL6JdJ7/vw5evTogStXruD8+fNU4CCEEBnS1NREaWlprW9eIEQaI0eOBAD8+eefFZ67efMmHBwcRN8Lp3O6dOmS2H5hYWFiz1eXNOeUbm5uEvuu6qKfnZ0dbG1tkZGRgRkzZmDChAkAgDZt2sDBwQF5eXmYO3cutLS0YGdnJ1V2QkjDdPPmTWhoaKBTp04K7VfZp6sCPozmyMrK4joGIVXS19fH2LFjsXHjxk+ux821Whc5+Hw+XFxcYGNjA01NTVlkqpf8/PxgbW2NmTNn4tixY8jKykJeXh5Onz6NSZMmwd/fn+uIhJBqyM/PR0hICCZOnAjgwzzHjDFERkYqLIOwyGFvb09FDiV25coV9OjRA2pqarh9+3aFObEJIYTUjnBKn4YymoMoBz8/P9ja2mLZsmXYsWMH0tLSkJ+fj/Pnz2PChAlYtWqVaN/ly5fD0tISCxYsQHh4OPLy8hAeHo6FCxfC0tISfn5+Uvdd3XNKPz8/6OnpifrOz8/HtWvXsG3btir7EH7GTU5OxtixY0XbhQWPbdu20YLjhJBqu3jxIhwdHaGhoaHQfps2bYq0tDSlHlVjaGhIRQ5SJ8yZMwfPnj3DuXPnuI5SpVoXORStsvkwpf1a0f0ZGhoiOjoaXl5emDdvHpo2bQpra2ts374dBw4cQO/evaXORghRvMOHD6OkpEQ0Z7GBgQFsbW1x5coVhWUQLrTapUsXpKamIjU1VWF9k+rZsGED+vfvD1dXV1y/fp0WkyOEEDkQ3mBFi48TRdLT08ONGzcwZ84crF27Fs2bN4eVlRXWrVuHXbt2oX///qJ9TUxMED9H+mwAACAASURBVB0dDXd3d4wfPx5NmjTB+PHj4e7ujujoaJiYmIj2/fg8UtK5qzTnlC1btsS1a9fQqVMnDBs2DGZmZggICMDmzZsBACoqki8FfPXVV1BTUxNNVyUkXINDTU1NtEZHedXJTwhpWIqLi3Hu3DkMGTJE4X0bGhqiuLgYr1+/Vnjf1aWrq6vU+QgR6tChA/r374+NGzdyHaVKdW7uqMqqsNJu56I/fX19rF27FmvXrq1VJkIId3bs2IERI0aIzYNsZ2eHe/fuKSyDpqYm3r17h44dOwL4sDZSdRa/JPJXUlKC2bNnY9u2bVi9ejXmzZvHdSRCCKm3hEUOGslBFE0gEGDFihVYsWLFJ/c1MTHB1q1bsXXr1ir3q+55qzTnlB06dMDZs2fFtgmnb/l4QXIhU1NTFBcXV9jepEkTFBUVVdqXMt8tTQjhxsmTJ5GTkwNPT0+F911+YW89PT2F918djRo1qvK4SogymTNnDoYNG4Z//vkH7dq14zqORHVuJAchhBvBwcFwcHCAvr6+6O4sSXdoVfVcXff3338jOjoa3t7eYts7deqEBw8eKCxHWVkZeDwejIyMYGxsjIcPHyqsb1K5vLw8DB8+HEFBQTh+/DgVOAghRM6oyEFI1Xg8Hp49eya27erVqwCAvn37chGJENKA/PHHHxgyZAgsLS0V3rewkKvMC3s3atSIPsOQOuPzzz9HixYtPjntJZeoyEEI+aSgoCB4eXnBwMAA9+/fx7t373D8+HGJ+9bnu7i2bNkCGxsb9OrVS2x7586dkZWVhaSkJIXkKC0thZrah4F4tra2iImJUUi/pHJJSUno1asX7t69i4iICNHCoIQQQuRHuCYHTVdFSOVmzpyJuLg4FBQU4NKlS5g/fz50dXWlXg+EEEKk8e+//yIiIgI+Pj6c9C8scijzmhfCGRoIqQtUVFQwZcoUBAYGKm1xrkEWOcrfaV7VgxDywbp16wAAa9euhaWlJTQ0NODh4VGvCxofy8/Px8GDB+Ht7V3h+GBrawsAiI2NVUiWkpISqKqqAgA+++wzGsnBsejoaHTr1g1lZWW4efMmunXrxnUkQghpEGgkByFVCwsLg0AggJOTE/T09ODl5QVHR0dER0ejbdu2XMcjhNRjmzZtQsuWLeHm5sZJ/9ra2tDU1KSRHITI0OTJk1FQUIATJ05wHUWiBlnkYIxV60EI+eDJkycAgNatW3OchDsHDx5EUVGRxIUWDQwMoKurixcvXigki6SRHGVlZQrpm4gLCQlBnz59YG9vj6ioKDRv3pzrSIQQ0mBQkYOQqvXv3x/Hjx9HamoqiouLkZ6ejsOHD1OBgxAiV0+ePMHOnTsxb948qKhwd9nR0NBQ6YscNJKD1CWmpqYYOnQoduzYwXUUiRpkkYMQIh3hxQN1dXWOk3Bn+/bt8PT0hJGRkcTnLS0tkZCQoJAs5Udy2NraoqCgQGEFFvI/W7duxZdffokpU6YgJCQEAoGA60iEENKgCKeroiIHIYQQojx++OEHtG7dGpMnT+Y0h6GhoVJPV0UjOUhdNG3aNFy5cgX//PMP11EqoCIHIRwpPzVabGwsBg0aBF1dXQgEAgwZMkTiASMsLAzDhg2Dvr4+GjVqhK5duyI4OLjKtp8/fw4PDw+xBcOlzSmp3ZpM7Zaeng4fHx9YWFiAz+fD3Nwc06dPR2pqqlSZFO3OnTv473//W2HB8fKsrKw4G8nB4/FoyioFCwgIwDfffIMlS5Zg8+bNoqITIYQQxVFXV4eamhpdICCEEEKURHh4OEJDQ7F+/XrROStXlH0kh4aGBt6/f891DEKkMnDgQFhZWWH37t1cR6mAihyEcKT8lGjTpk3D0qVL8erVK5w8eRJ3796Fs7NzhYvmrq6uUFVVxdOnT/HkyRMYGhrCy8sL58+fr7RtHx8f/PDDD3j16hXOnj1bq5y1mdItLS0N9vb2CAkJwe7du5GdnY3g4GBcuHABTk5OyM3NlTqbomzbtg3t2rWDk5NTpfs0b94ciYmJCslTfiSHQCCAlZUVHj16pJC+G7rS0lJ4e3tj8eLF2LZtGy3aSQghHOPz+TTVAyGEEKIECgsLMWvWLLi7u3O2Fkd5yl7kKCsr43Q6L0JqQkVFBZMnT8bevXtRVFTEdRwx9G4iRAksWbIEzs7OEAgE6N+/P/z9/ZGTkyPxAur69ethaGiI5s2b47fffgMArFy5stK2Fy1aBCcnJ2hqamLw4MGcrTfj6+uLhIQErFq1Cm5ubhAIBHBxccH69esRHx+PNWvWcJLrU/Ly8nD48GH4+PhUOWpFkUNhS0pKxO6K+eyzz6jIoQCFhYUYPnw49u/fj5MnT2LatGlcRyKEkAavUaNGSneCRQghhDRE3377LVJSUkTXKbhGRQ5C5GPy5MnIycnB6dOnuY4ihtuxY4QQAKgwQmDAgAEAgAsXLoht/7hAYW1tDQCIjY2ttG17e3tZRKy10NBQAMDgwYPFtvfq1Uv0fFXFGq7s378fJSUlEhccL8/AwADZ2dkKyZSfnw8dHR3R9x06dFC6Py71TW5uLoYOHYrHjx/j0qVLcHR05DoSIYQQfJjqQdEjOZKSknD06FGF9tmQREdHAwCOHTtGF3+IzNH/L0JkjzGG69evY+/evQgJCYGVlRXXkQB8OEdX5jU5qMhB6ipzc3P069cP+/fvx8iRI7mOI0JFDkKUQOPGjcW+NzQ0BABkZGSItuXm5uKXX35BSEgIkpKSkJ+fL3quqj/cwkU5uZaeng4AMDMzk/j88+fPFRkHo0ePRnx8PKZOnYrp06dXut+2bdswevRo6OvrV9me8AMUY0zqdU+klZ+fj6ZNm4q+b9euHdatW1dhhAeRjfT0dAwaNAgZGRmIjIxE27ZtuY5ECCHk/yl6JIeFhQWCg4Ph6empsD4bqjFjxnAdgdRj9P+LENlRUVHBzp07MXfuXHzxxRdcxxExMDBQ6pEcpaWlVOQgddb48eMxdepUZGZmiq5hco3eTYQogY+LFMI/xEZGRqJtnp6eWL16NUaPHo2EhIQarYvBJRMTEwBAdnZ2hbU9GGMoKChQaJ7CwkI8fPgQ3t7eGDRokMR9rl+/jgcPHsDHx+eT7TVp0gTFxcUKeR0FBQUQCASi79u1a4eioiKFLXzekKSkpKB///7IyclBREQEFTgIIUTJKHokx5o1ayR+jqEHPehBD3rQoyE+Xrx4gaZNm6J79+5YvXq1wv4eV4dwSumysjKuo0hUVlYmWmuTkLrGw8MDfD5fqUY3U5GDECUQFRUl9n1YWBgAiC3WJdzn+++/R5MmTQCgTs1BPXz4cABAREREheciIyPRo0cPheYJDQ3F27dvMWLECJw/fx53796tsM/WrVvRuXPnak35JRwxU1hYKPOsH8vPzxcrcrRt2xY8Hq/KacuI9F68eAEXFxeUlpbi2rVraNWqFdeRCCGEfITW5CCEEEK4kZmZiUGDBkFfXx9//h979x0Wxdn9DfxLFaSjgg1EFFCwg8ao2EvUWLF3xRpbotFY8uQRTWKJ5jGxVzQW7A3FEmvsIEUBUZoKqCBV6XXeP/KDV5TOzs4C3891cQVmZ+77DIbd2T1zn3PmDNTU1KQOKZ+aNWsiOzsbCQkJUodSIJaroopMS0sLgwYNwoEDB6QOJQ//mogUwPbt23Hnzh0kJSXh+vXrWLp0KQwMDPI1Hre3twcArF69GgkJCYiLi8OyZcskirj0VqxYAQsLC8yePRsnTpxAbGwsEhMTcf78eUyaNAlr1qyRJC4nJycAwKlTp/Jtj42NxfHjx/HNN9+UaJxq1aoBgFzuJv00yaGtrQ0TExMEBASIPndVERAQgE6dOkFfXx///PMP6tWrJ3VIRERUgGrVqjHJQUREJGcpKSkYOHAg0tPTceXKlWLLO0sht4SOopasYrkqqujGjx+P+/fvIzAwUOpQADDJQaQQtm7dirVr16Ju3boYOHAgWrVqhbt37+Zr2PXXX39h/Pjx2LNnD4yNjdGlSxd88cUXeY9/3Afi0+/L0yOiqHFL833NmjXx8OFDjB49GosXL0adOnVgYWGBnTt34tChQ+jSpUuZYyyP3FJhn/6OnJ2doaamVuJ6vRoaGgCkSXIAgLW1NZMcMuLt7Q17e3s0atQI169fV5j6kkRE9DkNDQ25Nx4nIiKqyjIzM+Hg4IDg4GBcvHgxX79IRVKjRg0A/5bMVkQpKSkK00OVqCx69eqFevXqwcXFRepQALDxOJFCMDMzg6ura5H7GBkZ4a+//vpse0GNLwVBdr06ChurtNsBwMDAABs2bMCGDRtkEpss3L9/H0pKSmjevHneNkEQsGvXLkycOBE6OjolGkfqJEfTpk0/K3tGpefl5YVevXrBzs4Op0+f5kUnEZGC40oOIiIi+cnOzsb48eNx9+5d3LhxA1ZWVlKHVKjc98zy7v9ZUsnJydDV1ZU6DKIyU1ZWxsiRI3Hw4EH897//lTocruQgoqrtzJkzEAQBlpaWeduuXr2KwMBAzJgxo8Tj5NYfzcjIkHmMH8vIyEB6evpnyZemTZvi6dOnMk1wVTXe3t7o3bs37OzscObMGSY4iIgqAK7kICIiko/s7GxMmDAB586dw5kzZ2Brayt1SEXS0tICoLhJjoJuXiSqaEaNGoXg4OAC+9zKG5McRFRlvX79Gh4eHqhRowZatmyZt3379u2wt7dHs2bNSjxWbnJB7JqaueW1cpfe5mratCmSkpLw+vVrUeevrLy9vdGrVy/Y2trizJkz0NTUlDokIiIqAa7kICIiEl92djYmT56M06dP49y5c+jevbvUIRVLXV0dampqTHIQiaht27YwNzfHyZMnpQ6FSQ4iqRTWu0Jec5fkq7Lbv39/3vK63PN9+/YtXF1dMWvWrFKNlZOTA0D8f8vcpmmf9omwtrYGADx9+lTU+Ssjb29v9OzZkwkOIqIKiCs5iIiIxJWTk4MpU6bg2LFjOH78OHr27Cl1SCVWvXp1hU1yJCcn5602IarIBg8ejBMnTkgdBpMcRFIRBCHfl5RzF/ZVmWVnZ2PTpk3Izs7GpEmT8rbv3LkTenp6GDp0aKnGy01yiL2So7Akh6GhIYyNjZnkKCUPDw90794d7dq1w9mzZ5ngICKqYLiSg4iISDy5CY6jR4/i5MmT6N+/v9QhlYqWlpbCJjm4koMqCwcHBwQGBsLX11fSOJjkIKIq6ezZs4iKioKtrS3atm0L4N/Ex549ezBlyhRUq1atVOPJq1xVTEwMlJWVYWBg8NljNjY28Pf3F3X+ysTHxwd9+vRB+/btcfr06bzm8UREVHFwJQcREZE4MjIyMHbsWLi4uFTIBAeg2EkOruSgyuLLL7+EiYmJ5CWrmOQgoippzZo1AIDFixfnbbt06RIiIiIwderUUo+XlZUFAFBRUZFNgIWIiYmBoaFhgfMwyVFygYGB6Nu3L1q3bo1Tp04xwUFEVEFxJQcREZHsJScnY9CgQTh//jzOnz9fIRMcgOKWqxIEAQkJCQXevEhU0SgpKSlEySomOYioyvnw4QM8PDxgZmaGYcOG5W3ftWsXunbtCgsLi1KPmZKSAuDfiygxRUdHf1aqKpeNjQ38/Pwqfamx8goODka3bt3QsGFDlqgiIqrguJKDiIhItuLi4tCrVy94e3vjn3/+Qa9evaQOqcwUdSVHfHw8srKyCn1vT1TRODg4wN/fHwEBAZLFwCQHEVU5uasdNm/enFdeKjIyEm5ubpg2bVqZxkxNTQUgfpIjNja20AuhZs2aITExEeHh4aLGUJGFh4ejV69eMDIywoULF1gDlYioguNKDiIiItl59eoVOnTogMjISNy+fRutW7eWOqRyUdQkR26vzVq1akkcCZFsdOrUCcbGxjhz5oxkMTDJQURVSlZWFiIjI9GoUSP069cvb/vevXuhq6uLIUOGlGlceSU5YmJiikxyKCkpwc/PT9QYKqqoqCj07t0bOjo6uHr1KpcGExFVAlzJQUREJBvu7u748ssvoampiXv37pWpwoGiUdQkR3R0NABwJQdVGioqKujXrx/Onz8vWQyqks2cG4CqKkaPHo3Ro0dLHUqFpKoq+T9hpaWkpCR1CCSiTZs25X0vCAKcnZ0xfvz4MvdmyE1yiN3bISYmBqampgU+pqenh3r16sHPzy9fAof+/b11794dAPD333+jRo0aEkdERESywJUcRERE5efi4gJHR0d07doVR44cga6urtQhyYSWlhYSExOlDuMzuSs5mOSgyqR///7466+/irw5V0ySf0J+7do1vH37VuowiKgKyMzMxOTJk1GjRg307ds3b/u1a9cQHBxcpobjuRITE6GpqSl64jEmJgZt2rQp9HE2H/9cUlIS+vXrh9TUVNy+fRvGxsZSh0RERDLClRxERERlJwgC1q1bh6VLl2LatGnYsmVLpbqZVktLC5GRkVKH8Zno6Gjo6OigWrVqUodCJDN9+vSBqqoqLl26hHHjxsl9fsmfuTp16iR1CERURcybNw8ZGRlYvXp1vu27d+9Ghw4dYGNjU+axi2oILksxMTFFrkJo1qwZbt68KXocFUVmZiaGDRuGly9f4vbt26hXr57UIRERkQypq6sjIyND6jCIiIgqnOTkZEyYMAHnzp3Dpk2bMHv2bKlDkjlFLVcVExPDfhxU6Whra6NTp064cOGCJEkO9uQgoirh2bNn2Lp1K/T09PI92cbGxuLMmTNlbjj+8TjySnIUNY+NjQ2ePn2K7Oxs0WNRdDk5ORg/fjzu3buHixcvwsrKSuqQiIhIxlRVVZGZmSl1GERERBXKs2fP0KFDB9y6dQt///13pUxwAP8mOZKSkqQO4zPv3r1jkoMqpf79++Py5cvIysqS+9xMchBRpZeVlYVJkyZBRUUFM2fOhIqKSt5j+/fvh4aGBoYPH16uOeSR5EhNTUVKSkqR8zRr1gypqal48eKFqLFUBAsXLsTp06dx4sQJ2NraSh0OERGJQE1NTZI3UURERBXVvn37YGdnB21tbXh5eaFr165ShyQaRV3JER4eDhMTE6nDIJK5gQMHIj4+Hvfv35f73ExyEFGlt2rVKnh7e+f15PjY7t27MWbMGGhpaZVrjuLKSMlCdHQ0gKKbk1lbW0NFRQWPHz8WNRZFt3LlSvz55584ePAgevfuLXU4REQkEjU1NQiCwBWMRERExUhNTcX06dMxZcoUODo64saNGzA1NZU6LFEpapIjIiIC9evXlzoMIplr1KgRLCwscOHCBbnPLXlPDiIiMd27dw+//vorGjZsiEaNGuUrWfTw4UMEBATgr7/+Kvc8MTExaNGiRbnHKW4OoOgkh5aWFqysrODp6QkHBwdR41FUO3bswIoVK7Bt27Zyr9AhIiLFpqamBuDfHkwfr9QkooonLi4OCQkJ+PDhAzIyMvDhwwekpqYiLS0t3345OTlISUmBtrY2gH+vf9XV1aGiogIDA4O8L11dXSlOg0gheXp6Yty4cYiJicGFCxfQt29fqUOSC01NTaSnp0sdxmfCw8P5XpUqrf79++PixYtYs2aNXOdlkoOIKq3IyEgMHz4cHTp0wO3bt7F169Z8jx84cABNmzaFnZ1dueeSx0qOkiQ5AMDW1haenp6ixqKozp8/j9mzZ2PFihWYMWOG1OEQEZHIPk5yaGhoSBwNERUkMTERISEhCA8Px6tXrxAeHo7w8HC8fv0aMTExiI2NRUxMTKlWZKmrqyMjI6PIfT5Nenz8ZWRkBFNTU9SvXx8mJiZo0KABqlevXt5TJVI4GRkZ+Pnnn7F69WrY29vj6tWrqFevntRhyY2ysrLClbXMyspCZGQky1VRpdWzZ0/88ccfiIqKgrGxsdzmZZKDiCqlzMxMDB8+HFpaWjAyMkKzZs3Qo0ePfI8fPXoUCxculMl8xTUEl4XY2FioqqpCT0+vyP3atGmDn3/+WdRYFJGXlxdGjx6NiRMn4qeffpI6HCIikgNV1X/fzrD5OJH0UlNT4ePjg8ePHyMgIAABAQF49uwZwsPD8/apVatWXmKhefPmqFmzJmrUqIGaNWuiVq1aeSsw1NTUoKenBw0NDWhqahY5b2JiIrKyspCZmYn4+Pi8r4SEhHw/534FBATg5s2bePXqFVJSUvLGMTQ0RP369WFqagoTExOYmJjA1NQUlpaWsLCwgL6+vmi/OyIx+Pj4YOLEiQgJCcH//vc/zJ49G0pKSlKHJVeqqqoKV9LyzZs3yM7OZrkqqrQ6d+4MVVVV3Lx5EyNHjpTbvExyEFGlIwgCpk6dCh8fHxw+fBhDhw6Fs7Nzvgs6Nzc3xMbGYtSoUTKZLy4uTvQkR1RUFIyMjIq9MLW1tUVsbCzCwsIqfY3VXC9fvkT//v3Rtm1bbNu2TepwiIhITnJXcijaXZpElZ0gCHj69Cnu3LmDR48ewcPDA/7+/sjKyoK+vj6srKxgbW2Nnj17omnTprC0tISpqWmxCYuy0NHRyfveyMioVMfGxcUhIiICYWFhCA8PR0REBMLDw+Hv74/Lly8jIiIib8WIkZERmjRpAktLy7wvKysrmJubQ11dXabnRFQe6enpWL16NX799Vd8+eWXePz4MRo1aiR1WJJQUVFRuCRHREQEAHAlB1VaOjo6sLOzw7Vr15jkICIqj+XLl8PFxQXnzp3Dzp070bRpU4wePTrfPgcOHEDXrl1hZmZW7vni4+ORlZUllyRHSZb6tW7dGsrKyvD09KwSSY4PHz5g4MCBqFmzJk6dOsU3mUREVcjH5aqISFyBgYG4ceMGbty4gZs3byIqKgo6OjqwtbVFr169sHTpUtjZ2VWoD1MNDQ1haGhYaG+97OxsvHz5EkFBQXj27BkCAwMRGBiYlwARBAGqqqowMzODtbU1mjdvjhYtWqBFixawsLBgryCSOzc3N8yfPx9v377F+vXrMWfOHCgrK0sdlmQUNcmhoqKC2rVrSx0KkWh69OiBw4cPy3VOJjmIqFL57bffsGbNGuzduxeGhoY4c+YMXF1d873BiI+Px/nz52V2x39Je2WUV2RkZImSHNra2rC0tISnpyeGDBkiakxSy8zMxNChQxEbG4sHDx6wjAARURXDJAeReLKysvDPP//A1dUV586dQ2hoKLS1tWFvb4+FCxeiW7duaN26daX+IF9FRQWNGjVCo0aN8NVXX+V7LCUlJS/pERgYCD8/P5w+fRpr165FVlYWNDQ0YGNjg+bNm+dLfpR2tQlRSbx48QLffvstzp07hxEjRmDDhg0sh4R//4ZzcnIgCILClOoKCQmBqalpXslNosqoR48e+Pnnn/HixQs0bNhQLnPyL4qIKo1169ZhyZIl2LhxIyZMmAB7e3t06tQJ/fv3z7ffsWPHoKSkhKFDh8pk3sjISAClXx5fWqVp2tSmTRt4eXmJGo/UBEGAo6Mj3N3dcfv2bS73JSKqgtiTg0i2MjIycOnSJRw5cgQXL15EQkICbGxsMHLkSHz99ddo164dP5j7P9WrV0erVq3QqlWrfNvT09Ph7++PJ0+ewNfXF0+ePIGbmxvevXsHAKhduzbatGkDOzs72Nraws7ODnXr1pXiFKgS+PDhA9avX4/169fDzMwMV69ezdeLsqrLfb7Kzs5WmOeukJCQCrXijagsOnToAC0tLVy/fh2Ojo5ymVMx/sKJiMpBEAQsWbIEv/32GzZv3oxvvvkGO3bsgLu7O9zd3T/b/8CBAxgyZEixDbxLKiwsDOrq6qIvN42Kiip0Kf2nbG1tsWbNGlHjkZqTkxOOHDmCCxcuoGXLllKHQ0REEuBKDiLZuH//Pg4dOoQjR44gPj4e9vb2+O9//4uBAwfC3Nxc6vAqlGrVqqFNmzZo06ZNvu1RUVHw9fWFj48PPD094eLiglWrVkEQBNSpUycv4ZH7X5ayoaKkpaVh69atWL16NbKysuDk5IRvv/0273WR/pW70kzRkhxWVlZSh0EkKnV1dXTo0AHXrl1jkoOIqCTS09MxefJknDx5Evv378f48eMRFRWFpUuX4ttvv0Xr1q3z7f/y5Uvcu3cPy5cvl1kMYWFhMDExEb3WaWlXckRHRyMiIqJSLlM+efIkVq5ciS1btqBXr15Sh0NERBJh43GisouPj8fevXuxY8cOBAUFwdraGgsXLsTYsWOrRF83eTM2NoaxsTF69uyZt+39+/fw9PSEp6cnHj16hAMHDmDFihUAgHr16uUlPXITHyx1RVlZWdi/fz+cnJwQGxuLuXPnYvHixTA0NJQ6NIX0cZJDUYSEhKBfv35Sh0Ekuu7du+OPP/6Q23xMchBRhRUWFoZhw4YhMDAQbm5uectyv/nmG+jq6ua9QfjY/v37UatWLZl+MB4WFib6G0FBEPDu3btSJTlym49XtiSHt7c3Jk6ciLlz52LWrFlSh0NERBLiSg6i0vPx8cGWLVtw+PBhqKqqYsKECThy5MhnKw9IfHp6eujevTu6d++ety0+Pj5f4sPZ2Rk//fQTAMDExCTfag9bW1vR+wKSYkhNTYWzszM2bNiA8PBwODo64j//+Q9LnRUjN8mhKDdDpKen4/Xr1yxXRVWCvb09li5dKrcSbUxyEFGFdP78eUyePBl16tSBh4cHLCwsAAC7du3CmTNncOXKFWhpaX123KFDhzB69GiZLlWVR5IjLi4OmZmZJU5y6OrqwsLCAu7u7hg0aJCoscnT27dvMXDgQHTo0AEbNmyQOhwiIpIYkxxEJefm5oY1a9bg9u3bsLGxwfr16zFu3Djo6OhIHRp9xMDAAD179sy34iM2NjZf4mPXrl348ccfAQANGjT4LPHBu/orj7i4OGzZsgWbNm1CYmIiJk2ahEWLFrGMXAl93JNDEYSGhiInJ4dJDqoS7OzsoKGhgbt37zLJQUT0qaSkJCxcuBA7d+7EpEmTsHnz5rxkxvPnz/Hdd99h8eLFBTZb8/LyQlBQEMaMGSPTmMLCAb72CAAAIABJREFUwmBnZyfTMT8VFRUFACVOcgBAx44dcffuXbFCkrvU1FQMHjwYWlpaOHbsmMLUVCUiIumw8ThR0XJycnD27Fn8/PPP8Pb2Rv/+/XH9+nV069ZN6tCoFGrUqIHevXujd+/eeduio6PzJT62bduG8PBwAIC5uXm+xEebNm2gr68vVfhUBj4+PtixYwcOHjwINTU1fPPNN5g7d26p3g+S4pWrCgkJAQAmqahKyO1RdffuXUyYMEH0+fgJERFVCIIg4MSJE/j+++/x4cMHHDp0KF+yIikpCcOGDYONjQ1WrlxZ4BgnTpyAiYkJ2rZtK9PYwsPDRV/JUdYkh4uLCzIyMqCuri5WaHIhCAIcHR0RHByMBw8e8E0aEREBYE8OosIIgoBjx45h1apVCAgIwJAhQ7B79+7P+tVRxVWrVi189dVX+Oqrr/K2RUVF5SU9PD098ccff+DNmzdQUlJC48aN8632aNOmDXR1dSU8A/pUSkoKjh49ih07duDhw4ewsrLCqlWr4OjoyBVXZaRoSY7AwEDUqVOH/55UZXTs2BFubm5ymYtJDiJSeJ6enpg/fz7u37+PsWPHYv369fma7uV+AP727Vt4eHjkfeDxqVOnTmHEiBFQUlKSWWzx8fH48OGD6EmOyMhIqKqqokaNGiU+pmPHjkhNTYW3tze++OILEaMT36pVq3DixAlcunQprzQZERERy1URfe7WrVtYtGgRPD09MWrUKBw9ehQ2NjZSh0VyYGxsjH79+uVravzmzZt8iY/ffvsNUVFRUFZWhoWFRb4VH61bt4a2traEZ1D1ZGdn48aNGzhy5AhOnjyJlJQUDB06FGvWrEGXLl1k+t61KlK0JIefnx+fj6lK6dixI9avX4+4uDjRSykyyUFECuvp06dYvXo1Dh8+DHt7e3h6eqJVq1af7ffLL7/g1KlT+Pvvv9GwYcMCx3r8+DGeP3+Offv2yTTGV69eAYBcVnLUqlULysrKJT7G0tIStWrVwt27dyt0ksPV1RVOTk7YvHlzvqaMRERETHIQ/X9Pnz7FkiVL4Orqit69e8PLywstW7aUOiySWN26dVG3bl0MGDAgb1tERERe0uPRo0dYvXo1oqOjoaysjCZNmuQlPVq2bIkWLVrAwMBAwjOofHJycnDv3j0cPXoUx48fR1RUFGxtbfHjjz9iwoQJqFWrltQhVhqK1njc398fX375pdRhEMlNx44dAQAPHjzIl4AXA5McRKRwHjx4gDVr1sDV1RVNmjTBkSNHMHz48AL3PXDgAH766Sds2bIFXbt2LXTMEydOoH79+jL/sD8sLAwAYGJiItNxPxUVFVXq+qtKSkro0KED7ty5gwULFogUmbgCAwMxfvx4jBs3DrNmzZI6HCIiUjDsyUEEvH//Hj/++CO2b9+OZs2a4cqVK+jVq5fUYZECq1+/PurXr4/BgwfnbXv16lW+xIeTkxPi4uIA/HtDV/PmzdGiRQu0bNkSzZs3h6WlJXvklUJCQgIuX74MNzc3XLx4EdHR0bC2tsbs2bMxcuRIWFpaSh1ipaRIjccFQUBAQACmTp0qdShEclOzZk1YWlri7t27THIQUdWQkZGBs2fPYsuWLbh16xbat2+PU6dOYcCAAYWuXrh58yamTZuGH374odgPwM+cOYOhQ4fKfLlvWFgYatWqldf8XCxlSXIAQJcuXfDzzz8jJyenVKtAFEFiYiKGDh2Kpk2bYufOnVKHQ0RECogrOaiqO3bsGL799ltkZWVh165dmDBhQoW75iPF0KBBAzRo0AAODg5528LDw+Hr64snT57g8ePHOHfuHH777TdkZWVBQ0MD1tbWaNGiBZo1a4amTZvCysoKZmZmeXfPV2XJycl48OABbt++jRs3buDevXsAgA4dOmDhwoX4+uuvWbZIDhSpXNWrV6+QmJiIZs2aSR0KkVx16NAh7zlQTExyEJGkAgICsHv3bhw4cABxcXHo168fbt68iS5duhR5nL+/P4YMGYIhQ4bgl19+KXLfV69ewc/PDxs3bpRl6AD+TXKIvYoD+DfJUbt27VIf1717dyxYsAA+Pj5o06aNCJGJQxAETJkyBTExMbh06RKqVasmdUhERKSAlJSUoKKiojBlKIjkJTQ0FLNnz8bly5cxZcoUrFu3TvRa11T1mJiYwMTEJN/dtxkZGfD3989Lfjx58gSXL1/G27dvAQDVqlVD48aN0aRJE1haWsLKygpNmjSBlZUV9PX1pToVUeXk5CA4OBje3t7w8PDAnTt34OnpiaysLJibm6Nz58745ptv0Lt3b5b+krPcmxwFQZA4kn/7cQBA06ZNJY6ESL7atWuHEydOiH7zLZMcRCR37969w7Fjx3D48GHcv38fDRs2xLx58zB58mTUq1ev2OPfvHmDvn37omXLlti3b1+xT5Jnz56Frq4u7O3tZXUKeYKDg9G4cWOZj/upqKioMt3x0aJFCxgbG+PatWsVKsmxatUqnD17FlevXkX9+vWlDoeIiBSYmpoaV3JQlSEIAjZt2oQlS5bA3Nwct27dEuUal6gw6urqaN26NVq3bp1v+4cPH/D8+XM8f/4cz549w/Pnz3HhwgX8/vvvSE9PBwAYGRmhcePGeckTExMTmJmZ5X1fs2ZNKU6pVMLDwxEUFITAwEAEBATAx8cHPj4++PDhA1RVVWFtbY1OnTph/vz56Ny5c4ne35J4cq8PFKG0mr+/P0xMTCptso+oMLa2tkhMTERwcLCopfmk/ysnoirhw4cPOH36NFxcXHD16lVUr14dgwcPhpOTE3r06FHibG5CQgL69OkDPT09nDlzpkR3+F+4cAF9+vSBurp6eU/jM8+fP8+3pFsskZGRZSpXpaSkhC5duuD69etYtGiRCJHJ3pUrV7By5Ups2rQJnTt3ljocIiJScExyUFURERGByZMn4+bNm1i+fDmWL1+eV7KNSGq6urpo27Yt2rZtm297Tk4OXr16lZcAefHiBcLCwnDz5k2Eh4cjKioqb19NTc28pEe9evVQo0YNGBoaokaNGnnf537VqFED1atXl1n8SUlJiI+PR1xcHGJjYxEREYHw8HC8efMG4eHhCAsLQ1BQEFJSUgAA+vr6sLS0RKtWrTBmzBi0adMGzZs3h4aGhsxiovLLXempCM+V/v7+LFFGVVKLFi2gpqaGR48eMclBRBVTWloa/v77bxw/fhynTp1CWloaunXrhr1792Lo0KHQ1tYu1XgZGRkYNmwY4uPjce/evRLdAZGUlIRbt26J0tMhJycHoaGhcmkSFx0dDSMjozIdm1uyKiMjQ5REjywFBwdj5MiRmDhxIhuNExFRiTDJQVXBkSNH8M0338DIyAh3795Fu3btpA6JqESUlZXRsGFDNGzYEF999dVnj6elpSEsLCwvkZD79ebNG/j5+eUlHRISEj47VkNDA4aGhtDQ0IC2tjbU1NRQrVq1IpMfKSkpSE9PR2pqKtLS0pCcnIz4+HhkZGR8Nnb9+vVRt25dmJqaol+/fmjcuDEsLS1haWlZ5vdmJF+KtpKjW7duUodBJHfVqlWDjY0NPD09MWbMGNHmkf6vnIgqlaysLPz9999wcXHB2bNnkZycjC5dumDjxo0YOnRomWsF5+TkYOzYsXj06BFu3boFU1PTEh139epVZGZmom/fvmWatygvX75EWlqa6EmO9+/fIyMjo8wX0j179kRKSgru3buHrl27yjY4GUpNTcWwYcPQuHFjbNmyRepwiIioglBVVWVPDqq0kpKSMHPmTBw+fBjffPMN1q1bJ9O714mkpqGhkZc4KEpOTg7i4uLykh6538fFxeUlKzIyMpCWlobU1NRCx9HU1ISGhkbef7W0tGBgYABDQ0MYGBjAwMAANWrUqBCls6h4udcHUic5cnJyEBAQgDlz5kgaB5FUbG1t4enpKeocTHIQUbnl5OTg3r17OH78OI4ePYqoqChYW1tj2bJlmDBhAurUqVPuORYsWIDz58/jypUraNmyZYmPu3LlCmxtbVGrVq1yx/Cp58+fA4DoSY7o6GgAKPOFdqNGjWBpaQk3NzeFTnLMmTMHYWFhePToEZd5ExFRiXElB1VWz549g4ODA6Kjo3Hx4kX06dNH6pCIJKOsrIyaNWsy+UCloihJjtDQUKSmppapzyZRZWBra4vjx4+L2nxcvJbmRFTpRUVFYe3atWjcuDHs7e1x9epVzJw5E4GBgfD398cPP/wgkwTH2rVrsXnzZhw6dKjUjRWvXr2KXr16lTuGggQGBsLY2Fj0xmExMTEAUK5ETf/+/XHhwgVZhSRzhw4dgrOzM/bu3Qtzc3OpwyEiogqESQ6qjM6dO4f27dtDU1MT7u7uTHAQEZWBoiQ5/Pz8oKSkhCZNmkgaB5FU7Ozs8OHDBwQHB4s2B5McRFQqgiDg2rVrGDFiBExMTLBu3ToMHjwYfn5+8Pf3x4oVK2BhYSGz+U6fPo1ly5bllbsqjdzmcD169JBZPB8LDAyUWz8OoOwrOQCgX79+ePr0KUJDQ2UVlsz4+vpi+vTp+OGHHzB48GCpwyEiogqGSQ6qTLKysrBkyRIMHjwYI0eOxL1792BmZiZ1WEREFVLu9YHUjcf9/f1hZmYGHR0dSeMgkkrz5s2hpqYmaskqJjmIqEQEQYCrqyvatWuHnj17IjQ0FJs3b0Z4eDh+//132NjYyHzOx48fY8KECZg8eXKZalf+/fff0NDQwJdffinz2IB/y1VZWVmJMvbHYmJioKWlBU1NzTKP0blzZ+jo6ODSpUsyjKz8EhMTMWLECLRt2xarVq2SOhwiIqqAmOSgyiIxMRGDBg3CH3/8gd27d2PHjh1QV1eXOiwiogpLUVZy+Pv7i/KZCVFFoaGhgSZNmuDx48eizcEkBxEVKTs7G4cPH0bz5s0xePBgNGzYEN7e3nj06BGmT58uWuPD+Ph4DB48GO3atcO2bdvKNMa1a9dgb29fruRAUeS5kqO8PUXU1dXRq1cvnD9/XkZRycaUKVMQHx+Pw4cPS37hSUREFRMbj1NlEBERgc6dO8Pb2xt37tzBlClTpA6JiKjCy8rKgpKSElRUVCSNg0kOIqBZs2bw9/cXbXwmOYioUG5ubrCxscGECRPQqlUr+Pn54dixY2jVqpWo8wqCAEdHR2RmZuLIkSNlXlp669YtdO/eXcbR/SslJQWvX7+WS5IjNjZWJg32Bg0ahKtXryI+Pl4GUZXfH3/8gdOnT8PFxQV169aVOhwiIqqguJKDKjp3d3fY2dkhOzsbDx48gK2trdQhERFVCllZWZLfTJeRkYHnz5+z6ThVeTY2NkxyEJF8vXjxAoMGDUL//v3RsmVLPHv2DAcPHkTTpk3lMv///vc/uLq6wsXFpcwrGF6+fIk3b96gY8eOMo7uX4GBgcjJyZFLuaro6GiZJDkGDhwIZWVluLq6yiCq8vH09MTixYvh5OSEbt26SR0OERFVYExyUEV28uRJdO3aFba2trh79y5MTU2lDomIqNJQhCSHn58f0tPT0aZNG0njIJKajY0NXr58icTERFHGZ5KDiPKkpqZi7dq1aN68OZ49e4ZLly7h6NGjaNy4sdxi8PPzw7Jly7By5UrY29uXeZz79+9DTU1NtDvhAgMDoaqqCnNzc1HG/5isVnLo6+ujZ8+eOH78uAyiKrukpCSMHTsWHTp0wJIlSySNhYiIKj41NTWWq6IKaefOnRgxYgQcHR1x7tw5NqQlIpKxzMxMyZuOe3l5oXr16nK5QZJIkTVr1gyCICAgIECU8ZnkICIAwMOHD9GyZUv88ssvcHJygp+fH/r06SPXGLKysjB58mS0bt0aixcvLtdY9+/fR6tWrUTrGRIQEABzc3O5NIOMj4+HoaGhTMYaPnw4rly5ImnJqlmzZiEuLg6HDh2SvDYqERFVfKqqqlzJQRXO5s2bMXPmTCxatAibNm3iNRERkQgUYSWHp6cnWrduzed5qvLMzc2hpaUFPz8/UcZnkoOoisvOzoaTkxM6deoEc3NzBAQEYOHChZLc7bB69Wr4+/tj37595b4AuHfvHr788ksZRfY5X19fudXUTEhIgL6+vkzGGjRoEABI1oDc2dkZhw4dwt69e9mHg4iIZILlqqiiWbt2LebNm4f169djzZo1UodDRFRpKUqSg72WiABlZWU0adJEtL4cTHIQVWGxsbHo27cv1qxZg99//x0XL15EvXr1JIklNDQUv/76K5ycnMq9jDMtLQ1PnjxB+/btZRTd53x9fdG8eXPRxv9YQkIC9PT0ZDKWvr4+evXqhSNHjshkvNIICgrC/Pnz8f333+Prr7+W+/xERFQ5MclBFYUgCFi0aBGWL1+OnTt3YsGCBVKHRERUqUmd5MjKyoKvry/7cRD9n2bNmom2kkPadCYRSebx48cYNGgQBEHA7du3YWdnJ2k8CxcuRMOGDfHtt9+Weyw/Pz9kZmaKdrdEWloaQkJC5JrkkNVKDgAYP348xo0bh7dv36JOnToyG7co6enpGDlyJKysrPDzzz/LZU4iIqoamOSgimL+/PnYvn07Dh48iFGjRkkdDhFRpZeZmSlpksPf3x9paWlcyUH0f2xsbHD16lVRxuZKDqIq6PLly7C3t0fDhg3h6ekpeYLj+vXrOHPmDH7//XeZlMny9fWFpqYmGjVqJIPoPvf06VNkZ2fLpVxVdnY2kpKSZJrkGDRoEHR0dHDw4EGZjVmchQsXIigoCIcOHZJLHxMiIqo62HicKoIffvgB27Ztg4uLCxMcRERykpWVJWnjcU9PT1SvXh1NmjSRLAYiRWJhYYE3b94gOTlZ5mMzyUFUxezbtw8DBgzA4MGDcfnyZdSsWVPSeARBwMKFCzFw4EB89dVXMhnT19cXNjY2ojX28vX1hYaGBho3bizK+B9LSEiAIAgyTXJoaGhg1KhR2Ldvn8zGLIqrqyu2bt2K3bt3w9LSUi5zEhFR1aGiosIkByk0JycnrF+/Hs7OznBwcJA6HCKiKiM5ORlaWlqSze/p6YmWLVtK3heESFFYWFhAEASEhITIfGwmOYiqkB07dsDR0RGLFi3C/v37FeKO+tOnT+Px48dYtWqVzMZ88uQJWrRoIbPxPuXr6wtra2vRkigfS0hIAACZJjkAYOLEiXj69Cnc3d1lOu6noqOjMW3aNEyaNAkjR44UdS4iIiIiRbNx40Y4OTlh69atGDdunNThEBFVKVInOby8vFiqiugjjRo1grKyMoKDg2U+NpMcRFXE5s2bMWvWLKxcuRK//PILlJSUpA4JgiBg5cqVGDZsmEyTEr6+vqKWkpJ303FA9kmOL774AtbW1nB2dpbpuJ+aMmUKqlevjo0bN4o6DxERVV1KSkoQBEHqMIg+s3XrVixYsAAbN27EjBkzpA6HiKjKkTLJkZ2djSdPnrDpONFHNDQ0UK9ePSY5iKhs9u3bh3nz5mHNmjVYvny51OHkOXPmDHx9ffGf//xHZmO+f/8e7969E7XmpZ+fn1z6cQDAhw8fAAB6enoyH3vatGk4dOhQ3hyytm3bNri5ucHZ2Rm6urqizEFERKQIN24QferkyZOYO3cufvnlF8ybN0/qcIiIqiQpkxxPnz5FSkoKV3IQfcLCwoJJDiIqPVdXV0ybNg3Lly/H4sWLpQ4nnw0bNmDQoEEyXRXx4sULAEDDhg1lNubH4uLi8ObNG7mt5EhKSgIAaGtry3xsR0dHKCkpidKbIzg4GIsXL8ayZcvQpUsXmY9PRET0Ma7kIEXi7u6OCRMmYOrUqVi6dKnU4RARVVlSJjk8PT2hoaGBpk2bSjI/kaJq3LgxkxxEVDoPHjzAiBEj4OjoKNOeF7Lg4+ODu3fvyvzOtlevXkFJSQmmpqYyHTeXr68vAMhtJUdKSgqUlZVRrVo1mY+to6ODsWPHYtOmTcjJyZHZuFlZWRg3bhwsLS1lukqHiIioICxXRYokJCQEAwYMQLdu3bBlyxapwyEiqtKSk5NFuWGwJLy8vNCyZUuoqalJMj+RomrcuDGCgoJkPi6THESVVEREBIYOHYoePXoo5BuszZs3w9raWuZ3+b98+RJGRkaoXr26TMfN5evrCwMDA9SrV0+U8T+VkpIi2rkAwNy5cxESEoLLly/LbMwVK1bA19cXhw8fVojm9kREVLmxXBUpipiYGPTr1w+mpqY4evQoVFVVpQ6JiKhKk3olB0tVEX3OwsICr1+/RmpqqkzHZZKDqBJKTU3FkCFDYGBggMOHD0NFRUXqkPJJSEiAi4sL5syZI/MPJl69egUzMzOZjvkxeTYdB8RPcjRt2hQ9evTApk2bZDLe3bt3sWbNGqxfvx5WVlYyGZOIiKg4XMlBUktNTcWAAQOQlZWF8+fPS/ahGhER/X9JSUmSPB9nZ2fj8ePHbDpOVIDGjRtDEASEhobKdFzeWkJUCc2cOROhoaFwd3dXyIbP+/fvh4qKCsaNGyfzsV+9eoUGDRrIfNxcT548gZ2dnWjjfyolJQWampqizjFnzhwMHToUoaGhMDc3L/M4mZmZmDZtGkxNTXHjxg3cuHFDhlESEVFlVrduXWzcuLFMx7JcFSmC6dOnw9fXF/b29pg7d67U4RBRFeDg4ICRI0dKHYZCk2olx7Nnz5CcnMwkB1EBcsvLh4eHw8bGRmbjciUHUSWzbds2HDx4EAcPHkSjRo2kDqdAzs7OGDNmDHR0dGQ+dlhYmGj9OLKzs/HkyRO5XqiIvZIDAL7++mvUq1cPe/bsKdc4GzduxMuXL/Hq1SuEh4fLKDqSSkREBI4fP84PDiuhBw8e4N69e1KHQZQnIiICf/zxB7Kzs8t0PMtVkdT+/PNPHD58GHZ2dnn926h0Tpw4wevHCo7XF/L14MEDHDt2TOowFJ5USY6HDx9CU1NTbr08iSoSXV1d6OrqIiwsTKbjciUHUSXi7u6O7777Dv/973/Rt29fqcMp0IMHD/D48WPs2rVLlPHDw8NhYmIiytgBAQFISUlB69atRRm/IKmpqaInOVRUVDBp0iTs2rULTk5OZaofHRsbi1WrVmHJkiVwcnLC/PnzMWrUKBGiJXk5efIkhg0bhiNHjihcyTsqn9GjRyMjI4NvjElh5D7flAcTsiSV+/fvY9GiRVi5ciX8/PxQo0YNPr+WgYqKCq8fKzheX8hX7u+biiZVksPDwwO2trZsOk5UCFNTU5nf3MCVHESVRFxcHEaOHInOnTtj+fLlUodTqN27d6N58+Zo27atzMdOT0/Hu3fvREtyeHl5QV1dHdbW1qKMXxB5rOQAgAkTJiAyMhK3b98u0/GbN2+GmpoaFixYIOPIiIiIisZyVSSVyMhIODg4oG/fvli2bJnU4RAR0UcEQUBqaqokSQ53d3dRPvMgqixMTEyY5CCiz+Xk5GDMmDEQBAEuLi4Ke9d1UlISjh07hmnTpoky/uvXryEIgmhJDm9vb7Ro0QLq6uqijF8QefTkAP5t/GRjY4OzZ8+W+tiUlBRs2bIFc+bMgba2tgjRERERFY7lqkgKgiDA0dER1atXx/79+/n/IRGRgklLS0N2drbc36OmpaXB19eXSQ6iIpiamsq8XBWTHESVwPLly3Hr1i2cPHkSNWrUkDqcQrm4uCAzMxNjx44VZfzcLLCYSQ55Nw7LzMyU2xLXgQMH4sKFC6U+7tChQ0hKSsKcOXNEiIqIiKh4XMlB8rZ9+3ZcunQJzs7O0NPTkzocIiL6RHJyMgDIfSWHl5cXMjMz0a5dO7nOS1SRcCUHEX3G1dUVa9euxZYtW2Brayt1OEXas2cPHBwcYGhoKMr44eHhUFdXR61atWQ+tiAI8PHxkWs/jtx55XVnYPfu3REcHIzXr1+X6rjcf1cxfu9ERETFYbkqkrfQ0FAsXrwYy5Ytg729vdThEBFRAaRKcri7u8PQ0BDm5uZynZeoIslNcsjyGp5JDqIKLDg4GBMmTMC0adMwZcoUqcMpkp+fHx4+fAhHR0fR5ggPD0f9+vWhrCz7p7bg4GC8f/9ekiSHGOdTkPbt20NVVRUPHjwo8TH+/v54+PAhJk+eLGJk8qGkpFTgV0GP169fH9HR0SUeh4iIxMPnWZKn7OxsjB07FpaWlvjPf/4jdThUiIpyHSZmnKUdu6L8zohKSqokh4eHB7744gv+LREVwdTUNK+vrqwwyUFUQaWmpmLEiBEwMzPDxo0bpQ6nWLt27YK5uTm6du0q2hzh4eGilqpSUVFB8+bNRRm/MDk5OXK7ONLW1oaNjQ3c3d1LfMy+ffvQsGFDUf9d5UUQhHx3ERT18+vXrzF69GhkZ2cXOc6nYxARkTj4XEvysmXLFnh5eeGvv/6Sa582Kp2K8pwgZpylHbui/M6ISio3yVG9enW5zuvh4cFSVUTFqFevHgCUupJIUZjkIKqgZs2ahVevXuHUqVNyaUxdHunp6Th8+DCmTp0q6gf2Yic5rK2t5X6BJM9yVQDQrFkz+Pv7l3j/kydPYsyYMXJbbaIoateujWvXruGnn36SOhQioiqP5apIXiIjI/HTTz9h8eLFsLGxkTqcKo+rDoioKAkJCQAAfX19uc0ZFxeH4OBgNh0nKoaxsTEAcCUHUVW3efNmHDhwAIcOHULDhg2lDqdYJ0+eREJCAiZOnCjqPGImOby8vOReqgqQb7kqALC2ti5xkuPRo0d48eIFHBwcRI5K8Rw9ehSqqqpYvXo1zp8/L3U4RERVGpMcJC/z5s2Dvr4+lixZInUoRERUjLi4OKioqEBXV1duc3p4eEAQBCY5iIqhq6sLTU1NREVFyWxMJjmIKpgHDx5g4cKFcHJywldffSV1OCWyZ88e9O/fH3Xr1hV1HrFXckiR5JBnuSoAsLS0RFhYGLKysord99SpUzAzM0OrVq3kEJli6dy5M3799VcIgoDx48fjxYsXUodERFRl8U5ukofLly/j+PHj2LJli9zruxMRUenFxcVBX19frjfdLufcAAAgAElEQVQNuru7w8zMDEZGRnKbk6iiMjIy4koOoqrq3bt3GD58OHr37o1ly5ZJHU6JvHjxAjdv3sTUqVNFnSc5ORlxcXGoX7++zMcODw9HdHQ02rRpI/OxiyPvclW1a9dGTk5OiV5ozpw5g6FDh1bZD5cWLVqEIUOGICEhAQ4ODkhLS5M6JIWQlpaGNWvWoHXr1tDS0oKGhgaaNGmCmTNnftbUPjIyEjNmzED9+vWhrq6O+vXrY+bMmZ/dzfFxI8yQkBAMHToUBgYGn5WpePfuHWbNmpU3Xr169TB9+nRERkZ+Fqe/vz/69esHbW1t6Orqok+fPnj69Gm5mm5+fOzTp0/x1VdfQVdXF9ra2ujfvz8CAgJEPy+iqoorOUhMmZmZmDdvHoYPH47+/ftLHQ4hf3Iz93WzsPcb4eHhGDRoEHR0dGBsbIxx48YhNjb2s/Fk+Zr8/v17fPfddzA3N4eGhgZq1KiBDh064Pvvvy+0/11J4gRKfv1UlI+vg/T09DBkyBCEhYWV+HiiiiAuLg6GhoZynZP9OIhKzsjIiCs5iKqi7OxsjBs3DioqKti3b1+F6YGwe/duGBsbi77qJCgoCABgYWEh87G9vb2hpKQkyYoFKZIcAIr98DQ8PBwBAQFV/o2+s7MzGjduDG9vb8yZM0fqcCSXmJgIe3t7/Prrr5g9ezZCQ0MRExOD7du3459//sGXX36Zt29kZCTatWuH8+fP46+//kJsbCz279+Ps2fP4osvvsh3sfPxh5ezZs3C999/jzdv3sDNzS1ve1RUFNq1a4fTp09j7969iIuLw5EjR3DlyhV06NAhryYvAISEhKBTp054/Pgxzp07hzdv3uCnn37C9OnTC5yzpD4+Ztq0afjPf/6DN2/e4OzZs/Dy8kLHjh3x8uVL0c6LqKpiuSoS286dO/Hy5UusXr1a6lDo/3z8Ny8IAgRBwO7duwvcd+nSpVizZg0iIiIwYsQIHDp0CN9//32h48niNXnixInYuHEj5s+fj9jYWLx9+xbOzs4IDQ3FF198UeY4S3P9VJhPr4Nev36N7777Lt91EFFlEB8fL/ckx6NHj1iqiqiEjI2NZbqSAwIRVQg//PCDoKmpKXh7e0sdSollZmYKdevWFX788UfR5zp+/LigrKwspKWlyXzs5cuXC02aNJH5uCUxatQoYciQIXKbLzExUQAguLm5Fbnfjh07BC0trQJ/38rKyoKLi4tYIYoOgFDUy+Onjz1+/FjQ1NQUAAh79+4tdL+K5sSJEwIAISsrq8THLFiwQAAgbNy48bPHvLy88v1Opk2bJgAQDhw4kG+/ffv2CQCEGTNm5Nue++9y48aNAueeMWOGAEDYs2dPvu2nTp0SAAjLli3L2zZu3LgC575w4UKx//7FyT3+07+h3POaOHGiaOdVUqNGjRKGDh1a6uOIxFKW55uPzZgxQ+jRo4eMoyL6V2JiolC7dm1hwYIFxe7L59eyK8v1Y0mu2QAIN2/ezNsWEREhABDq1q1b6P6yeE3W1dUVAAjHjx/Pt+/r168/i7k0cZb1+uljhV0HnT59ulzXQfz/X774+y7e5MmThb59+8ptvpcvXwoAhFu3bsltTqKKzNHRUejdu7eshttZMW4FJ6rizp8/j3Xr1mHr1q0Vqv/BhQsX8PbtW0yaNEn0uYKCgtCgQQNUq1ZN5mN7eHhIdjeGhoaGXMsgaWtrQ0tLq9iVHJcvX0a3bt1E+X1XNC1atMC2bdsAALNnz4aPj4/EEUnnxIkTAIDBgwd/9ljr1q3z3SWZ27C9e/fu+fbr2bNnvsc/Vdjyb1dXVwBA3759823v3LlzvscB4O+//y5w7g4dOhQ4dll8OlbueV25cqXA/WVxXlQ6Fy5cwKBBg1C7dm2oq6ujdu3aGDBgAM6cOfPZvh+XMSmqpFlh+5Xmi8pG4EoOEsm6deuQlpamsKVii3su+Xhb/fr1ER0dXeJxKouPS87WqVMHAPD27dtC95fFa7KDgwMAYPjw4TA1NcXUqVNx7Ngx1KxZs9Dnq5LEWdbrp48Vdh3UqVOnYo9VRHw9p8LIu1yVh4cHVFRUJClzTVQRsScHURUTHh6OyZMnY/LkyXJJFsjSnj170KNHDzRq1Ej0uYKCgtC4cWOZjysIAjw9PSVLclSvXh2pqalynbO4JYPZ2dm4du0a+vTpI8eoFNvEiRMxffp0pKamYtiwYVW2hFDuG/HcsmdFyf2QpWbNmvm25/5c2P+D1atXL3B77v5169bN9wYzd7yQkJC8fWNiYgqcW19fv9i4S0pPTy/fz7lzFfbhkizOi0omMzMT48aNw9ixY9G9e3d4eHggKSkJHh4e6NGjByZOnAgHB4d8z73C/5VCKezngrYX9H1h4xQ2HpUMy1WRWKKiovC///0PS5YsQY0aNaQOp0DFPT99/PPr168xevRoZGdnFzlOZXtO0tHRyfs+t+RvUecni9fkvXv34uTJk3BwcEBSUhL27NmDkSNHwsLCotAbYkoSZ1mvnz5W2HXQpz8rOr6eU3HkXa7Kw8MD1tbW0NbWltucRBUZe3IQVSGZmZkYNWoUateujU2bNkkdTqlERkbi4sWLcHR0lMt8QUFBovTjCAkJQWxsrGRJDk1NTbknObS0tJCSklLo448fP8b79+/RrVs3OUal+P7880/Y2toiJCQEEydOlDocSRgbGwMo+u7IXEZGRgD+/xvtXLk/5z5e2rnj4uI+e6MpCAKSk5Pz9s19E1/Y3LLwaaPQ3LFr1apVqnFKc15UMnPnzsWxY8dw9epVzJ8/HyYmJlBXV4eJiQm+/fZbXLlyBefOnWNt8gqEd8ySWDZs2ABtbW3MmzdP6lBkonbt2rh27Rp++uknqUOpkEr7mjx06FCcOHECMTEx+Oeff9CnTx+EhYVh8uTJZY5BFtdPhV0HvX//vsxxSYGv51Qcea/kcHd3Z9NxolIwMjKS6XtwJjmIFNiiRYvw5MkTHDt2rNA7ihTVnj17oKenV2DZGjGItZLDw8MDampqaNmypczHLgkpkhzFlcj6559/YGhoiKZNm8oxKsVXrVo1nDhxAgYGBjh37pzU4UgitzRDQeUBHjx4kK/R5oABAwAA165dy7ff1atX8z1eUrnPNTdv3vzssdu3b+dret67d+8C5757926p5izKp2Plnlfu3CVVmvOi4j18+BA7duzApEmTYGdnV+A+X3zxBSZMmICDBw/i9u3b5Z6zNHd08u7PsuPvjmQtLi4O27dvx4IFC6CpqSl1ODJx9OhRqKqqYvXq1SUqa6Toct8fZWZmIiUlRfSVCKV5TVZSUkJERASAf1dl2Nvb4+jRowCAgICAMscgi+unwq6D7t+/X+a45I2v51QScXFxMDAwkMtcOTk58PLyYtNxolLQ19dHZmamzG7cY5KDSEG5urrizz//xNatWyvch8mCIGDfvn0YP348NDQ0RJ8vKSkJUVFRoqzk8PDwQPPmzSV7c6uISY7bt2+jU6dOecvo6f8zMzPDwYMHq+xdxStWrECzZs3w008/YdeuXYiKikJSUhIuX76MCRMm4Ndff83b18nJCQ0aNMCSJUtw/fp1JCYm4vr161i6dCkaNGiAFStWlHpuCwsLzJ49GydOnEBsbCwSExNx/vx5TJo0CWvWrMm3r76+ft7cSUlJuHPnDnbs2CGrXwW2b9+OO3fuICkpKe+8DAwMRD0vKt727dsBAMOGDStyv+HDhwMAdu3aJXpMVH4sV0Vi+OOPP6CmpoaZM2dKHYrMdO7cGb/++isEQcD48ePx4sULqUMqlxYtWgD49+5pV1dX0RP/pX1Nnjp1Kvz9/ZGeno6oqCisXbsWAMpV8lUW108FXQfdu3cPq1evLnNc8sbXcyoJeSY5AgIC8OHDB67kICqF3HLRsir3zU+oiBTQq1evMGnSJMyYMQPjx4+XOpxSu379OoKDg+XWQyQoKAgARElyuLu7S3o3hhRJjmrVqhWa5BAEAXfu3IG9vb1cY5KHwhp1FvRzUQ0F+/Xrh+XLl4sbrILS19fH/fv3MX/+fGzYsAGmpqYwMzPD77//ntejJ5exsTEePnyIAQMGYPz48TA0NMT48eMxYMAAPHz4MK8kBIAi/11y1axZEw8fPsTo0aOxePFi1KlTBxYWFti5cycOHTqELl265O1rbm6OO3fuoGXLlhg4cCDq1q2LtWvXYvPmzQAgkwTe1q1bsXbtWtStWxcDBw5Eq1atcPfuXZiZmYl2XlS83Ds5mzdvXuR+uR+cyXJ1D4mnqiaWSTwfPnzApk2bMH/+/Hx9EiqDRYsWYciQIUhISICDg0ORN7Youk2bNqFly5bo3bs3Nm7ciA0bNuQ99ulrbGm/L+9r8p07d1C7dm18/fXX0NHRgZWVFdzc3PDLL7/AxcWlzLGV5/op16fXQXXq1IGTkxO2bdtW4P6KiK/nVJyUlBSkpaXJrVyVu7s7NDQ00KxZM7nMR1QZyDrJoSqTUYhIZtLT0+Hg4ID69evj999/lzqcMtm9ezfat28vtxJPQUFBUFFRQcOGDWU6bnZ2Nnx8fMpVN7e8FG0lx8uXL/Hu3Tu0b99erjHJQ3F3AZfmLuFVq1Zh1apV5Q2pQtLW1i7x+RsbG2P79u15d+MVpqS/ewMDA2zYsCHfhxyFsbGxgZubW75tb968ASCbxptmZmZwdXUtch8xzouKlvtvXFwD4dzHS9JfhhQDV3KQLO3atQtZWVmYO3eu1KGIwtnZGb6+vvD29sacOXOwe/duqUMqEzs7u0KbeBf2nFDa7Z8q6Wtyx44d0bFjx2LHK0s8srh+Kug6qLhjFAlfz6k4cXFxACC3JIeHhwfatGkDNTU1ucxHVBlwJQdRJffdd98hMDAQx44dq5D1f2NjY3H69Gm5NRwH/k1ymJqaQl1dXabj+vn5ITk5WdIlp1IkOdTV1ZGRkVHgY97e3lBWVkarVq3kGhORrCkpKSE4ODjftn/++QcA0K1bNylCIgXy8aotUnwsV0WyJAhCXq1/eZU5kTc9PT2cPHkSmpqa2LNnD5ydnaUOiUgUfD2vuuSd5GDTcaLS09PTA8AkB1GldOzYMWzbtg3bt2+HlZWV1OGUyV9//QU1NTWMHDlSbnMGBQWJ1o+jevXqkvZE0dPTQ2pqaqFJBzEU9WGRj48PGjduDG1tbbnFQySW2bNnIzQ0FMnJybh27Rp++OEH6OrqlrpvBlUcderUAfD/3/gWJiYmBgBQt27dfNtzS5llZ2cXemx2djZ7FskZkxwkS25ubggKCsKMGTOkDkVULVq0yCtPNHv27EJXRBApIr6eU3HkmeRIT0+Hn58fm44TlZKWlhbU1dWZ5CCqbIKCgjBt2jTMmzcPY8aMkTqcMtuzZw/GjBkj1/rFz58/FyUp5OHhAVtbW6iqSlfZr1atWhAEAdHR0XKbU1lZGTk5OQU+5uPjg9atW8stFiKxXL16Fdra2ujQoQP09fUxevRotG/fHg8fPkSTJk3y9suty13cV+6+Hx9Hiie3n9CTJ0+K3C/38c6dO+fbnvva9v79+0KPjY+Ph66ubnnCpFLi3xvJ0pYtW9CzZ0/Y2NhIHYroJk6ciOnTpyM1NRXDhg2T2YcMRGLj6zkVJz4+HgDksiLP29sb6enpXMlBVAZ6enpMchBVJmlpaRg5ciSsrKywbt06qcMpszt37sDf3x/Tpk2T25yCIMDf31+UBl8eHh6S342R2zwwKipKbnMWleTw9vZmqSqqFHr06IGTJ08iMjISmZmZePfuHY4ePZovwQH8+xxTkq+C9iXFM3PmTADAyZMni9zv+PHj+fbPlZtQ9/PzK/RYPz8/WFpalidMKgP+zZEshIaG4vLly5g1a5bUocjNn3/+CVtbW4SEhGDixIlSh0NUInw9p+LExcVBR0dHLj0yPDw8YGhoiEaNGok+F1Flo6+vX2TCuTSY5CBSAHPmzMGLFy9w9OhRVKtWTepwymzXrl1o0eL/sXfncVFV///AXwMzgGxCIrKKiGTugjuEqShG4oZakppLKtpiH81MrdTcW7T8WF9NQ1FUXFBLpDQhFcUBVHABN0BkHxCRRYFhmfP7wx98RFFhuHfuzPB+Ph7zKO/ceZ/3bJcz933POd3Ru3dvlbV57949lJSUcF7kKC8vV4shp5aWlgCAvLw8lbX5oiLHgwcPkJmZSUUOQojG6t+/P/z9/bFz505cunSp3n1iYmKwe/du+Pv7P/c3YOTIkQDw0vnrAwICMGLECO6SJq9E01URruzatQtWVlYYNWqU0KmojL6+PkJCQmBubo5jx44JnQ4hDUJ/z8mrPHz4UGXrKtVcHEkjSwlpPCpyEKJFgoODsWPHDuzYsQOOjo5Cp6O0oqIihISEPHeVDN8SEhIgEonQuXNnTuPGx8ejsrJSpQWb+piamqJFixYqLXKIxWJUVlY+tz0+Ph4AqMhBCNFomzdvxoQJEzBs2DD897//RWZmJiorK5GZmYlNmzZh+PDheO+997B58+bnHvvZZ5+hc+fOCAwMxMcff4yEhATI5XLI5XJcv34dc+fOxcWLF/Gf//xHgGfWfCkUCpo3nXAiODgYfn5+gk5VKoR27dphz549dIKOaBT6e05eRiaTwcrKSiVtxcbGCn5xJCGaytDQEKWlpZzEol8DhAjo5s2bmDVrFhYsWICxY8cKnU6TBAUFgTEGPz8/lbabkJAAe3t7mJmZcRpXKpXCwsJCLYactm7dWqVFDgMDA8jl8ue2x8fHw9raWmWdRUII4YNEIsHevXuxZ88ehIeHo1evXjAyMoKrqytOnTqFPXv2YM+ePfVOb2BiYgKpVIpvv/0WsbGxcHd3h5GREVq3bo2pU6eidevWiImJeeEc3k+v4VLfv4lyqquroaurK3QaRMNFR0cjKSkJkyZNEjqVRnnVceXZtaNedMx555138NVXX/GbLCEcor/n5GVUVeQoKipCUlISFTkIUVKLFi1QVlbGSazmdYkKIWqkvLwcfn5+6Nq1K9atWyd0Ok0WEBCAiRMncl5seJWEhAR069aN87hSqRQDBgxQi86qpaWlyosc5eXlz22/cuUKjeIghGiNESNGKDUNhampKZYtW4Zly5Y1+rE0pRI/qMhBuLB371506tQJLi4uQqfSKK86rjTmuLNq1SqsWrWqqSkRolL095zURyaTqeSCxYsXL0KhUFCRgxAltWjRgkZyEKLpvvzyS6SkpGD37t0qWQyLTzExMbhy5YpKFxyvkZCQwMui49HR0RgwYADncZUhRJGjvpEc169fR48ePVSWByGEENIQCoWCihykSaqrq3Hw4EGNG8VBCCGkfjKZDNbW1ry3ExsbC3t7e5W0RYg2MjQ0pJEchGiyv//+G5s3b0ZQUBBef/11odNpsu3bt6NTp04qLwpUVVXh9u3bWLhwIadxMzIykJmZqVZFDplMprL26hvJwRhDSkoKnJ2dX/n4mmnLVD11GeFHc5uXvLnQ9CkSCXladXU1rclBmiQ6Ohp5eXkYP3680Kk0W9R/1A7UvyDqIicnB23atOG9nYsXL6Jv3768t0OItmrRogXu37/PSSw6c0GIiuXm5mL69On44IMPtOJqsUePHuHgwYNYvXq1ytu+c+cO5HI559NVSaVS6OrqCr7oeA0bGxtcunRJZe2ZmZmhoKCgzra8vDyUlpbC0dHxlY8XiUSYN28e3N3d+UqRqEBMTAw2bNiA/fv308lDLbNp0ya1mIqPEK7QdFWkqcLCwtC+fXt07NhR6FSaLeo/aj7qXxB1UVFRgYcPH6pkTY6LFy/i008/5b0dQrQVrclBiIZSKBSYPHkyjI2N8d///lfodDixd+9eVFZWYvLkySpvOyEhAbq6upz/II2Ojkb37t1hbGzMaVxlOTo64t69eyprz87ODjk5Oaiqqqq9ij81NbU2l4bo378/JkyYwFuOhH81hY3x48fTyUMtc+TIEVRUVAidBiGcoSIHaaq//voLPj4+QqfR7FH/UbNR/4KoC5lMBsYY70WOnJwcZGVl0UgOQpqA1uQgREN99913OHv2LPbu3QtTU1Oh0+HE9u3bMX78eLz22msqbzshIQHOzs5o0aIFp3GlUin69+/PacymcHR0xKNHj5Cfn6+S9uzs7FBdXV1niqzU1FSIxWLY2dmpJAdCCCGkoajIQZoiOzsb165dwzvvvCN0KoQQQjhQ8zuW7yLHxYsXIRKJ4Orqyms7hGgzLkdyUJGDEBW5dOkSVqxYgXXr1qFfv35Cp8OJa9eu4fLly4IsOF7TPteLjsvlcsTHx6vNehzA/0ZP1Iym4JutrS0AIDMzE8CTk0cXLlxA27ZtaX0GQgghaoeKHKQpTpw4gRYtWuCtt94SOhVCCCEcqCly8L0mR1xcHJydndGyZUte2yFEmxkaGtJIDkI0yaNHjzBp0iQMGjQI8+fPFzodzmzduhUdO3aEh4eHIO1fvnwZvXr14jRmXFwc5HK5WhU57O3tIZFIkJycrJL2bGxsIJFIcPfuXQDA999/j19++YXzETOEEEIIF6jIQZoiKioKffv2hYGBgdCpEEII4YBMJkPLli1haGjIazuXL1+mURyENJG+vj7kcjknsajIQYgKzJkzB4WFhQgMDNSaBXzLysoQHByMWbNmCbLAXF5eHjIzMzkvckilUlhYWMDJyYnTuE0hkUjg5OSEW7duqay9Hj16IDY2Frm5ubWLyt+8eRNnzpxRSQ6EEEJIQ1GRgzSFVCpVq4tbCCGENE1OTo5KFh2Pi4uDi4sL7+0Qos10dHRQXV3NTSxOohBCXmjXrl3Yt28fAgICYG1tLXQ6nNm/fz9KS0sxZcoUQdq/fPkyAHDeqYiOjsaAAQMEKdy8TOfOnXHjxg2Vtefm5obTp0/j66+/RmVlJQCAMYYRI0bg2rVrKstDE+zfvx/9+vWDubk5RCJR7e1ZL7uP8Ku8vBxff/01nJycIBaLG/0+0HtHiHqjIgdRVmFhIW7fvk1FDtIk1M8gRL3k5ubyfu4lNzcX2dnZnF90SUhzIxaLqchBiCZISUnBvHnzsGDBAvj4+AidDqe2b9+OsWPHwtLSUpD2L1++jHbt2sHCwoLTuOq26HgNVRc5xowZg2vXrmHHjh11ihwVFRUYNmxY7Xod6sbDw0Ol06ft3r0bfn5+aNWqFa5cuYLy8nIcPny43n0ZYyrLi9S1fPlyrFmzBjNmzEBxcTFOnjzZqMfTe0eIeqMiB1GWVCoFY0wt+35Ec1A/gxD1IpPJeB/JcfnyZYhEIhrJQUgT6erqUpGDEHVXWVmJSZMmoUOHDli7dq3Q6XDq5s2bkEqlgi04DvCzHkd2djYyMzPV8mq+zp07IykpCRUVFSppb+DAgejevftzJ42qqqpQUFCAYcOGoaioSCW5NIZCoYBCoVBZexs3bgQAbNiwAQ4ODtDX14evry/9WFUzBw4cAADMnTsXhoaG8PLyoveIEC1CRQ6irKtXr6Jt27Zo3bq10KkQDUb9DELUiyqKHHFxcWjXrh1ee+01XtshRNtRkYMQDfD1118jMTERwcHB0NPTEzodTm3duhXt27fH4MGDBcuBjyJHVFQUdHV10adPH07jcqFnz56orKxEQkKCStr7+++/ce3atdpRHE+rqqpCSkoKRo8erbKiS0NFRUUhKipKZe3duXMHANChQweVtUkaLyMjAwDoRwghWoqKHERZSUlJeP3114VOg2g46mcQol5ycnLQpk0bXtuIi4ujRccJ4QAVOQhRc1FRUdiwYQM2btyodT+cysvLsWfPHsyaNUuwRdTz8/ORkZHBeZEjOjoa3bp1g7GxMadxudCxY0eYmJjUrkXCp6qqKnz++ecvPWFUWVmJ8+fPY86cObzno87KysoAPFmsnagvVY7uIYSonkKhoCIHUcqdO3fg7OwsdBpEw1E/gxD1kpubq5KRHDRVFSFNR0UOQtRYaWkppk+fDk9PT8ycOVPodDh3+PBhlJSUYNq0aYLlcOnSJQDcLzoulUrVcqoqANDR0UGPHj1UUuTYunUrkpOTX/mHprq6GoGBgVi5ciXvOTXEixZtfHp7RkYGRo8eDRMTE7Rp0waTJ0/GgwcPlG6vvjaUWTwyLy8Pc+fOhZ2dHfT09GBra4vZs2dDJpMplRv5n/rep8WLFwMAioqKMH/+fLRv3x4GBgZo1aoV3NzcsHDhQsTGxgqVMiGkkSoqKrRu1CxRDSpykKaifgYh6qWwsBBlZWW8FjkePHiAtLQ0GslBCAe4LHKIOYlCCKm1cOFC3L9/H//++2+jTnJqiu3bt8PHx4f3KyNeJi4ujvP5k+VyOeLj4zF37lzOYnKtV69eKpmKadu2bWCMQU9PD1VVVS+9Oo0xhhUrVsDBwQFTp07lPbeXYYzV+517evuSJUuwfv162NjYYMmSJdiyZQskEgl27tzZpPaenXe5Md/93Nxc9OvXD+Xl5di9ezfc3NwQHx+PKVOmIDw8HHFxcTAzM2t0fuSJl71PU6dOxZ9//omff/4ZM2fOhEQiQWpqKpYsWYJ+/frRfNqEaAgqchBlPHr0CHl5eTTlJGkS6mcQol5qLhKztrbmrY24uDgA3F90SUhzREUOQtRUREQEtm7din379sHOzk7odDiXkpKCyMhIHD9+XNA8+FiPIz4+HuXl5Wo7kgMA+vbti//7v/9DaWkpDA0NeWvn5MmTkEqluH79Oq5du4aIiIjaRcbFYjF0dXUhl8tr92eM4cMPP4StrS2GDh3KW15cmDVrFjp16gQAWLRoEbZs2YJ//vlH0JyWL1+OtLQ0BAQEwMvLCwDg4eGBn376Cb6+vvjhhx+wZs0aQXPUVqdPnwYA2NrawsjICMCTqeF++eUXHD16VMjUeJeVlYVDhw4JnQYhAICYmJgmPb6iooKmDSSNVlBQAACwsLDgNC4dX0mN5tjPoM+/6mRkZPC+7oQmSktLAwC0bduWt+C8DMEAACAASURBVDbi4uJgZ2cn6IWfhGgLsVgMxhgUCkWTp8SnIgchHCkqKsKMGTMwZswYTJw4Ueh0eLFt2zbY2tpi+PDhguZx+fJlzJo1i9OYUqkUrVq1gpOTE6dxuTRw4EBUVlYiJiaG10Xfra2t4evrC19fXwDA/PnzER0djU2bNuHq1au4fv064uLicO3aNZSUlAB4MnXVmDFjcO3aNd7y4sLTQ4ptbGwAPFmYTkihoaEAAG9v7zrbBw4cWHs/FTn4MW7cOOzcuRMTJkyAvb09vLy84OXlhTFjxmj91ZWxsbF49913hU6DEE7QSA6ijMLCQgDgfLQkHV+Vo40j4JtjP4M+/6o1duxYoVNQO+np6TA2Noa5uTlvbdCi44Rwj4u/i1TkIIQjn376KcrLy7F161ahU+FFVVUVgoKCMGvWLEEX98zOzkZaWhrnIy6io6MxYMAAtf6BZWdnh3bt2iEyMpLXIsezHj16BFNTU/Tt2xd9+/atc19mZmbtiI+kpCS1fv0AwMTEpPb/a06ICf0jMy8vD8D/ii7PSklJUWU6zcqOHTvg4+ODffv24d9//0VAQAACAgLQtm1b/Pnnn+jZs6fQKfJm7NixOHz4sNBpEALgyXpf48ePV/rxlZWVNJKDNFrNKNWWLVtyGpeOr8oR8vcFX5pjP4M+/6rj5+eHiooKodNQO+np6XBwcOC1jbi4OEyaNInXNgghjUcLjxPCgWPHjiEoKAhbt26FpaWl0Onw4tixY8jNzcWMGTMEzSMqKgq6urrPnWxvKnVedPxpHh4eOHfunErbfPToEYyNjeu9z87ODt7e3vjyyy/x+++/w9HRUaW5aYOaYeYFBQVgjD13e/z4scAZajdfX1+EhIQgPz8fkZGRGD58ONLT0zF9+nShUyOENBCN5CDKKC4uBgCYmpoKnAnRZtTPIES1+C5yFBcXIyUlhUZyEKKGqMhBSBPl5+dj9uzZmDFjhlYPF/39998xbNgw3q+KeBWpVIpu3bq98KS7MrKzs5GRkaERRY5BgwZBKpWivLxcZW0+evSodh5hwr0xY8YAAM6cOfPcfefOndOIz6WmEolEyMzMBADo6OjAw8MDBw4cAADcvHlTyNQIIY1ARQ6ijJqRAwqFQuBMiLaifgYhqpeWlsb7ehyMMSpyEKKGqMhBSBPNnTsXEokEGzZsEDoV3mRmZuKff/7BzJkzhU4FUqkUbm5unMa8cOECdHV10adPH07j8sHLywtlZWWIjIxUWZvl5eUwMDBQWXvNzYoVK+Ds7IyPP/4YISEhePDgAUpKSnD8+HFMmzYN69evFzpFrTZz5kwkJiZCLpcjNzcX3333HQAIvvYQIaThaOFxooyaCzhoxCThE/UzCFGt9PR03osclpaWsLOz460NQohyqMhBSBMEBQXh8OHDCAgI4HzRQnUSEBAAc3NzjBw5UtA85HI54uPjOb+ynY/RIXyxs7NDly5dcPLkSZW1qVAoNGKe5KfXA2nK/6u6PQsLC8TExMDPzw+LFi2CtbU1nJ2dsW3bNuzduxdvvfVWo3Mj//Ps6/70v8+fPw8rKyv4+PjAxMQEHTt2xF9//YU1a9YgODj4hTEIIeqlsrKSRnKQRjM0NAQAlJaWCpwJ0WTUzyBEfSgUCmRlZfFe5OjVqxdv8QkhyqOFxwlRUnZ2Nv7zn/9g3rx58PLyEjod3igUCuzcuRPTp0+Hvr6+oLlcvnwZcrmct0XHNcXbb7+NsLAwlY0eUigUGvGD60ULiDd2uxDtmZubY8OGDVo9IkwoL3vd3d3d4e7u3qQYhBDh0XRVRBk1F7eUlJQInAnRZNTPIER95OTkoKKigtcptuPj4zF69Gje4hNClEcjOQhR0ocffggLCwusXbtW6FR49c8//yAtLU0tFseTSqWwtLSEk5MTZzErKioQFxeH/v37cxaTb97e3rh58ybu3r2rkvYYY9DRoT8XhBBC1BMVOYgy7O3toaOjo7L+FCGEEH6lpaUBAG8jOeRyOe7cuYMePXrwEp8Q0jR01ooQJezZswf//PMPAgMDa4e6a6uAgAAMHDgQnTp1EjoVSKVSzkdcxMfHo7y8XKNGcgwcOBCtW7dGSEiIStrTlJEchBBCmp/q6mooFApak4M0mqGhIRwcHHDjxg2hUyGEEMKB9PR0iMVi2NjY8BL/5s2bqKqqQteuXXmJTwhpGipyENJIBQUF+Pzzz/HRRx9p1IlxZeTn5yM0NBQffvih0KkA4GdaKalUilatWqFDhw6cxuWTWCzG6NGjcejQIZW0p6enh4qKCpW0JbSauZRfdSOEEKIeav4+0UgOoowuXbpQkYMQQrREeno6bG1tIRbzMzN/QkIC9PT04OzszEt8QkjTUJGDkEb6/PPPoauri1WrVgmdCu927twJAwMDjB8/XuhUkJaWhqysLF7W4+jfv7/GnbgeP348Ll26pJIpFoyMjJrNopyMsQbdCCGEqAe5XA4Agq8bRjRTt27dcOnSJaHTIIQQwoH09HReFx1PSEjAG2+8QRdWEKKmqMhBSCOcPXsWu3btwq+//gozMzOh0+Hdzp07MXnyZLWYkuv8+fPQ09ND7969OY0bFRWFN998k9OYqjBkyBC89tprKhnNYWRkhMePH/PeDiGEENJYZWVlAIAWLVoInAnRRCNGjMCdO3eQmJgodCqEEEKaKC0tjddFxxMSEmiqKkLUGBU5CGkguVyOOXPm4J133sHYsWOFTod3kZGRuHnzptpMVXX27Fn06dOH04JLWloaMjMz4e7uzllMVZFIJJg4cSJ27tzJ+8gCQ0PDZjOSgxBCiGap+fukDhdkEM3j5uYGe3t7la1zRgghhD98j+S4fv06FTkIUWNU5CCkgVatWoWsrCxs3bpV6FRUIiAgAL1794aLi4vQqQB4UuR46623OI0ZFRUFiUSCXr16cRpXVaZPn47bt28jOjqa13ZatmyJwsJCXtsghBBClFEzkoOKHEQZIpEIY8aMwcGDB2k6SkII0XB8FjmKi4uRkZFBRQ5C1BgVOQhpgISEBPzwww9Yu3Yt7OzshE6Hd0VFRQgJCcHMmTOFTgUAIJPJcOfOHV6KHK6urhp7YqR3797o0aMHdu7cyWs71tbWyM7O5rUNQgghRBk1IzlouiqirBkzZuDmzZv466+/6mzfvHkzDh48KFBWhBBCGqO4uBiFhYW8FTkSEhLAGEO3bt14iU8IaTqx0AkQou4UCgXmzJmDHj16YO7cuUKnoxJ79uwBYwzvvfee0KkAeDKKQywWc77oeFRUFDw9PTmNqWrTpk3D8uXLsWHDBpiYmPDShrW1NWQyGRQKBXR0GlYbj46Ohq6uLi/5ENWIiYkBAISEhDT4fSeaISMjA23atBE6DSKg/fv346effsKdO3fqjNR79kp2kUj0wvvUBY3kIE3Vs2dP+Pj4YOnSpRg+fDjEYjEePXqEhQsXoqKiAufOncOGDRu0bqFZdTwOUP9Rs2l7/0IdvzPkf9LS0gCAtzU5rl+/DmNjY17X/CCENA0VOQh5ha1btyImJgaxsbHNptMdEBCA9957T20WV4+MjISrqyunJ/FLSkqQkJCAZcuWcRZTCFOnTsU333yDnTt3Yt68eby0YWNjg8rKShQUFMDCwuKV+zPGsGnTJmzatImXfIhqTZw4UegUCA+aw9pSmsTDwwMAcO7cOd7b2r17N6ZOnQpvb29cuXIFVlZWCAsLw7hx457blzFW52SNOqI1OQgXNmzYgG7duuHHH3/E4sWLERoaiqqqKgDAli1bEB0djT/++AO2tra8tK/KYwCgnscB6j9qB23tX6jjd4bUde/ePYhEIl5HcnTt2pXeW0LUGF2aSchLyGQyfPXVV1i4cKHarE3Bt/j4eMTHx6vNVFUAP+txREdHo7q6mvPRIapmbm6ODz74AD///DOqq6t5acPe3h7Ak45jjdTUVGRkZNS7v0gkQnBwMBhjdNPgW80irFVVVYLnQjdubxMnTlS7H2gikUjtcmooLnJXKBRQKBQcZfRyGzduBPDkpK6DgwP09fXh6+sLxjTzatOakRwGBgYCZ0I0mbOzM9asWYNvvvkGZ8+eRXBwcO0oxurqaly9ehVdu3bFqVOneGlflccAQD2PA9R/1PybNvcv1PE7Q+pKSkqCtbU1jI2NeYmfkJBAU1URouaoyEHIS3zyyScwMzPD119/LXQqKhMYGAhnZ2e4ubkJnQoAID8/Hzdu3OBlPQ4nJydYW1tzGlcI//nPf5CWlobjx4/zEt/R0REtWrRAYmIiAODw4cPo0qULJk2axEt7hBDS3ERFRSEqKkolbd25cwcA0KFDB5W0x7eysjLo6elBLKYB6qRpFixYAF9fX4waNQp///137UgOAKisrERxcTHefvttrFixgvOChCqPAYD2HQcI4Rt9Z9RfcnIyr+9PYmIiLTpOiJqjIgchLxAaGorDhw9j27ZtMDIyEjodlaioqEBwcDCmT5+uNlfhREZGQkdHB+7u7pzGjYqK4jymUJydneHt7Y0ff/yRl/i6urro1KkTrl+/jq+++goTJkxAeXk5zp8/j8zMTF7aJIQQwo+akQ8SiUTgTLhRWlpKU1URTohEIgQFBWHw4MH1FjFqRlusWrUKI0eOrDMnv6bRtuMAIXyj74z6S05OhrOzMy+xc3JycP/+fSpyEKLmqMhBSD3Ky8sxf/58+Pn5YdiwYUKnozKhoaF48OABJk+eLHQqtSIjI9GjRw9O1weprq5GbGys2oxW4cLSpUtx/vx5/Pvvv7zE79ixI/bt24f169fXDkkXi8XYv38/L+0RQtSPTCaDv78/7OzsoKenBzs7O8yZMwe5ubl19quZGuLZYvnLtj+7jzJTJj4dPzs7G+PGjYOJiQlatWqFqVOnoqioCPfu3cOoUaNgamoKKysrTJs2rd4TleHh4Rg1ahTMzc1hYGAAV1fXeo93r8r96ZxSUlLg6+sLc3PzOq9Dfa/L09ue3r5+/foXvo4NfY1e1EZjY+bl5WHu3Lm1nwdbW1vMnj0bMpms0Xk1RVlZGRU5CGf09PRQWVn50u+CQqHAqVOn4OLiguvXrze5zYYcMzMyMjB69GiYmJigTZs2mDx5Mh48eKB0e/W1ocnHAaLZNKF/UV9b9J1RL0lJSXBycuIldkJCAgBQkYMQNUdFDkLq8eOPPyInJwfr168XOhWVCgwMxLBhw2rXYFAHZ86c4XyqqmvXrqG4uFhrRnIAgJubG4YOHcrLQuq3b99GTEwM8vPz61zZWFVVhd27d3PeHiFE/chkMvTt2xfHjx/H7t278eDBA+zatQt//vkn+vXrV+dExIvmp27I9poi6u+//97oHJ+O8+WXX2L16tXIzMyEn58fdu/ejUmTJmHBggX47rvvkJGRAV9fX+zatQuLFi16LtawYcOgq6uLpKQk3LlzBxYWFvDz88PJkycblfvT98+dOxcLFy5EdnY2/vrrr3r3eXrbtm3bAAD6+vqIjY0FAIwZMwaWlpaIjIxUah7w+vKtuTVGbm4u+vbti6NHj2LHjh0oKCjA/v378c8//8DNzU2lV7iXlpaiRYsWKmuPaLfi4mKcOnXqleucVVZWIjMzE7169cLOnTub1GZDjo1LlizB+vXrkZmZiXHjxmHv3r1YuHBhk9vTluMA0Vya1r+g74x6ksvlyMjI4G0kx/Xr19G6dWtYWlryEp8QwhFGCKkjIyODGRkZsbVr1wqdikrJZDImkUhYcHCw0KnUun//PtPR0WGhoaGcxt28eTMzMzNj1dXVnMYVWlRUFAPAIiIiOIsZGhrKjIyMmEQiYQDqvSUmJtZ5jI6Ojlp9johyQkJCGABWVVUldCqEYxMnTmS+vr6NesysWbMYABYUFFRne2BgIAPA/P3962yvOT48q7HbG6smzpkzZ2q3ZWVl1bs9IyODAWC2trb1xklNTa39982bNxkA5uHh0ejca+4/ffr0K/d51ty5c2tzTExMZB06dGCBgYEvjNMQXLw3/v7+DAALCAios/3IkSMMAFu6dGmjcmrK8WbZsmWsW7dujX4cIfUJDAxkOjo6L+zzvOg2a9YsJpfLlTq+Mvbq79/Tx67U1FQGgNnY2Cj9PNXxOED9R83XHPoXTdnO9XdG2eONNqrpp8XHx/MSf8aMGczT05OX2IQ0dxyed9hGIzkIecYXX3wBKysrzJ8/X+hUVGr37t0wNDTE6NGjhU6lVnh4OHR0dDBw4EBO4164cAEDBgyAjo52HQLd3NwwbNgwfPXVV0pd4fuslStXYtSoUSgrK0NlZWW9+0gkErWcsqq8vBxff/01nJycIBaLlZ7ahRBVU9fP7vHjxwEAQ4YMqbN96NChde5XF66urrX/b2VlVe92GxsbAEB2dvZzj2eMoV27drX/rrky8MaNG0rn1Ldv30Y/ZtOmTRg4cCCysrLQs2dPTJgwAVOnTlU6B66EhoYCALy9vetsr/l7XXO/MqZMmQJbW1t4enoiMDDwlX/PioqKYGpqqnR7hDztyJEjYIxBX1//uZtYLIZEIqlzq+lLbt++HV988QVvedV37MrJyeGtvYbg8zhA+KVOfQ1N6180BZ/fmZYtW+KNN97Ahx9+iKioKOWT1FBJSUkAwNt0VdevX6epqgjRAGKhEyBEnZw/fx4HDhzAn3/+CQMDA6HTUamgoCC8//77ajXlQ0REBPr168f5yYuoqCjMnj2b05jq4vvvv0fv3r0RHByM999/v0mx/v77bwCod/HNGpWVldi1axe+/fZbtTgRW2P58uX4/vvvsXr1asyfPx/nz5/H8OHDhU6LkFdS18/u/fv3AQAWFhZ1ttf8Oy8vT+U5vYyJiUnt/z9d0K5v+7Mn0QsLC/H999/j6NGjyMzMxKNHj2rvU3YOfABKrRshkUhw8OBBODo6Qi6XY8qUKUq3z6Wa97vmZOuzUlJSlI49e/Zs9OnTB9HR0ZgzZw5OnTqFvXv3vnD/4uJitGzZUun2CHna7Nmz0bVr13r7nqamptDV1a2zzcDAoLbv3Lt3byxdupSXvJ4+dunp6QF48RQ9qsLncYDwS536GprWv2gKPr8z//3vf5GWloawsDB4eHjgo48+ws8//wyxuHmc8ktOToa1tXWdYyVXFAoFbty4obXnDwjRJs3jiEdIAygUCnz66ad4++23MXLkSKHTUanY2Fhcv35dqTlK+RQREYEPPviA05hZWVlIT0/XqkXHn9azZ09MnToVX375JUaPHg0jIyOlY507dw6//vorFi9ejKqqKlRVVdW7X3p6Oi5evKjUVcp8OXDgAIAnc+AbGhrCy8tL8JMBhDSEun52LS0tkZ2djfz8/Do/zvPz82vvf5pIJAJjDJWVlZBIJACeXHGvCd59912cOnUKy5cvx7x58/Daa68BgGCF3J9//hm6urpQKBQYP348YmNjm3Rs50KbNm2QlZWFgoICmJubcxrbw8MDHh4emDdvHk6fPg1PT09Mnz699qreZ9FIDsKlESNGYMSIEUKnoRH4PA4QfqlTX6M59S/4/M7UjPJctmwZjhw5gg8++ABGRkb47rvvOG1HXSUnJ6NDhw68xE5NTcXjx49pJAchGkC75mohpAl27dqFhIQEbNiwQehUVC4wMBCdO3dWq5PUKSkpSE1NhaenJ6dxz58/D7FYjD59+nAaV52sWbMGRUVF2LhxY5PiiMVifPbZZ7hx40btEPL6pviSSCQIDg5uUltcy8jIAIDak5OEaAp1/ezWFP8jIiLqbA8PD69zf42aKaKenk4lPj7+hfFrRjlUVlaitLT0uSs6ValmmofPP/+89n2Qy+Uv3J/P3Hft2oWQkBDcuHEDXbp0wY0bN+Dv789ZfGWNGTMGAHDmzJnn7jt37hwGDBjASTuDBw9G165d622nBo3kIEQYqjoOEO6pU1+jOfUvVPWd8fX1xebNm/Hjjz/WTuOk7ZKSkngrciQmJkIkEqFLly68xCeEcIeKHIQAKCsrw/LlyzF79mx06tRJ6HRUqry8HPv378e0adOETqWO8PBwGBkZcV54iYqKQs+ePWFsbMxpXHViZWWFpUuXYt26dUhOTm5yPEdHR5w8eRLHjh1D69atnxv2XFlZiaCgIFRXVze5La68bIotQtSZun52v/32Wzg4OGDx4sX4999/UVJSgn///RdLliyBg4MDVqxYUWf/YcOGAQB++OEHFBUV4datWy8dLdi9e3cAT0YWhoaGCnpyzMPDAwCwbt06FBYWoqCg4KVT0PCVe2RkJBYtWoTQ0FDY29vj0KFDMDIywt69e7FlyxZO2lDWihUr4OzsjI8//hghISF48OABSkpKcPz4cUybNg3r16/nrC0zMzMUFxe/8H4ayUGIMFR5HCDcUqe+RnPqX6jyOzN16lQ4ODhgx44dnMVUZ3yO5Lh16xZsbW15mQqLEMKxpi5dTog2WLlyJTM2NmY5OTlCp6Jy+/fvZ2KxmGVnZwudSh0TJkxg77zzDudxe/XqxT777DPO46qbyspK5uLiwt566y2mUCg4i1tYWMg+/fRTpqOjw3R1dRmA2tupU6cYY4zp6Oiw4ODgBsd8OkZycjIbO3YsMzMzq91WIzc3l82ZM4fZ2toyiUTCbGxs2KxZs5773j4dr+b25ZdfNikO13mlp6ezUaNGMWNjY2ZpackmTZrE8vPzn3ttysrK2Lp161jPnj2ZoaEh09fXZx07dmT+/v5MKpXW2beheTRUSEgIA8CqqqqUevyrNOa55eTksNmzZ9c+N1tbW+bv789kMlmd/bh+zxhjLCEhgXl7ezMjIyNmYmLCvLy8WGJiYp22nm0bAAsNDa2NsXnzZgaAJSYm1m4LCgp6ZYxnP7tcmThxIvP19W3042QyGfP392c2NjZMLBYzGxsbNnv27OfeB8YYu3//Pnv//fdZ69atmZGRERs5ciRLT09/7jnXuHjxIuvRowczNDRk/fv3Z7dv3250fs++dspuz83NZVOmTGGWlpZMT0+Pde3alR04cECp3Ot7TxuS99P/HjduHIuPj29QLFW9RowxVlBQwBYsWMAcHR2ZRCJhbdq0YSNHjnzu+9sQLzvedOjQga1cufKFj+3YsSNbtWpVo9skhA/KHF+5/F6quj0ujwON7T82BPU1VNvXoP7Fy7czxu135lWvt7+/Pxs4cGCj42oauVzOdHV12cGDB3mJ/+GHH7IhQ4bwEpsQwul5h21U5CDNXm5uLjM1NWWrV68WOhVBDB8+nPn4+AidRh3V1dXMwsKCbdiwgdO4jx49YmKxmLcOkLqJj49nYrGYbdu2jfPYly9fZt27d68tdIjFYjZ9+nTGmHI/Umt+BAwbNoxFRUWx0tJS9tdff9X+MJDJZMzBwYG1adOGnTx5kpWUlLDIyEjm4ODAHB0d2cOHD+uN9yxl43Cd16RJk9iNGzdYYWEhmzt3LgPApk2bVmff4uJi1rt3b2ZiYsK2b9/OZDIZKykpYadPn2adOnWq8/wam0dD8FnkaMxzy8nJYfb29szGxoZFRESw4uJiFh4ezqysrJiDg8MLTz5w8Z4lJyczMzOz2rZLSkrY+fPnmbu7e72fsVGjRjEA7Oeff66zvU+fPgwAW7x4cZ3tu3fvfu74q+xJq8ZQ9iQEIXx50fGmoKCAiUSiOifynmVlZcU2bdrEd4qENAgdX5XHdZGD+hpPqLKvQZ9/1XrV6/3TTz8xGxsbFWYkjJs3bzIALC4ujpf4b775Jps7dy4vsQkhVOQghFP+/v7M1taWPX78WOhUVC4zM5Pp6uqykJAQoVOp4/LlywwAu3LlCqdxIyIiGACWkZHBaVx19vnnnzMzMzNennNFRQVbt24d09fXZwCYkZERKysra1KR4/Tp0/Xe7+/vzwCwgICAOtuPHDnCALClS5fWG4+rOFzndebMmdptqampDMBzP0IWLFhQ749YxhiLi4ur8/wam0dD8FnkaMxzmzVrFgPAgoKC6uwXGBjIADB/f/8627l8zyZPnlxv22FhYfV+xmpi9OjRo3bbrVu3mIGBAQPA7O3t64ysGjJkyHPHXypykOboRcebgwcPMrFYzB48ePDCxxoaGrLAwEC+UySkQej4qjyuixzU13hClX0N+vyr1qte799++42Zm5urMCNhhIaGMgCsuLiYl/itW7eu9zhCCOEGl0UOWpODNGu3b99GQEAAVq9eXbsoWXOye/dutGzZEj4+PkKnUkd4eDgsLS1r51DlSlRUFNq1awc7OztO46qzlStXwsrKCpMnT+Z8zQyJRILFixfjxo0bGDp0KB4/foxz5841KeaL1mAJDQ0FAHh7e9fZPnDgwDr3v4qycbjOy9XVtfb/bWxsANRdQBEAQkJCAPxvkcKnubi4gDHW5DyE0pjndvz4cQDAkCFD6uw3dOjQOvc/i4v37NSpU/W27ebmVm9sHx8fWFhY4OrVq7hy5QqAJwtHf/rpp3BwcEBGRkbtYpNpaWm4du3acwtqEkL+588//4Sbm9sLF8etqqpCaWkprclBCHkO9TWor9HcPX78uFmc40hKSoKVlRUva2Y8fPgQ9+/fR8eOHTmPTQjhHhU5SLO2fPlyODk5YcqUKUKnIojdu3dj0qRJ0NfXFzqVOk6ePIlhw4ZBJBJxGjcqKuqFPxi0laGhIQ4ePIjY2FisXbuWlzbat2+PU6dO4ezZs7UL9irrRR3xvLw8AE8KAiKRqPZmYWEBAEhJSWlQfGXjcJ3X051wPT09AKjzYxv4X9HDysqKt+cllMY8t/v37wNA7XOpUfPvmuf+LC7es/z8/HrbNjMzqze2RCKBn58fACAwMBAKhQJ79uzB1KlTMXnyZABAUFAQgCcnJCZOnFj7/pP6Pf0evezWnGnra1RcXIyjR49i4sSJL90HABU5SLOnrceBpqC+BvU1XqY5fGdkMhksLS2FToN3fC46fvv2bQCgIgchGoKKHKTZun79Og4dOoS1FLnu3wAAIABJREFUa9dCV1dX6HRU7sKFC7h16xamT58udCp1PH78GFFRURg+fDincRUKBaKjo+Hu7s5pXE3QrVs3rF+/HitXrkRUVBRv7QwcOBAGBga8xG7Tpg0AoKCgAIyx526PHz9WaRy+4tUX+9kRHqrOgw+NeW41P85qTgLUqPl3Y3+8Nea1qjnh8KK26zN16lQAwL59+/DPP/+gdevW6NKlCz744AMAT64sLS0txa5duzBt2rRG5d4c1fce1XdrzrT1NTp48CAUCsVLixwvOjlISHOjrceBpqC+BvU1XqY5fGeuXbuGzp07C50G7/gucujr66Nt27a8xCeEcIuKHKTZWrp0KVxcXDB27FihUxHEzp070bVrV7i4uAidSh2nT59GRUVF7fBwriQkJKCoqKhZFjkA4NNPP4W3tzf8/Pwgk8mETqfRaqYaqBl+/7Rz585hwIABKo3DV7ynjRs3DgDwxx9/PHdfdHQ0+vXrp5I8+NCY51YzxUJERESd/cLDw+vc31CNea28vLzqbftlxcJevXqha9euuH//PubMmVN7wuH1119Hv379UFJSggULFsDQ0BC9evVqVO6ENCeBgYEYM2YMzM3NX7hPzdXSrVu3VlVahBANQX0N6ms0ZwqFApcuXWoW7//Nmzfxxhtv8BL7zp07cHZ2bpYXxRKikZRdzYMQTRYTE8NEIhE7ceKE0KkIorS0lJmamrKNGzcKncpzPvnkE+bi4sJ53C1btjBTU1NeFlHWFEVFRaxz585swIABrLy8nLd2mrLw+Ivcv3+fOTs7M2tra3bo0CGWn5/PiouLWWhoKGvfvn2dhbxfFo+rOFzHq2/7w4cPWdeuXZmJiQnbtm0bk8lkrKSkhJ04cYI5Ozuz8PBwpfNoCD4XHm/Mc5PJZMzBwYHZ2NiwiIgIVlxczCIiIpi1tTVzcHBgMpmsTmwu37OUlBRmZmZW23ZJSQk7d+4c8/b2fmk7P/zwAwPAxGIxy8vLq93+66+/1j7uxx9/rPexr8qfC7QwKFE3zx5v7ty506B+2uHDh5lIJGIVFRWqSJOQV6Ljq/K4Xnic+hqq72vQ51+1XvZ6x8bGMgDsypUrKs5KtYqKiphIJGKhoaG8xB83bhwbN24cL7EJIU9wufA4FTlIszRkyBDm7u4udBqCOXDgANPV1X2uw64OnJ2d2eLFizmPO3nyZObl5cV5XE1z69YtZmZmxj744APe2mjsj9SaH1pP3+pTUFDAFixYwBwdHZlEImFt2rRhI0eOZFKptFHxuIrT1Hiv2s4YYyUlJezrr79mHTt2ZHp6eqxVq1bMy8uLRUZGKp1HQ/FZ5GCscc9NJpMxf39/ZmNjw8RiMbOxsWGzZ89+4UkHrt4zxhhLSEhg3t7ezMjIiJmYmDAfHx+WkpLCADAdHZ164+fk5DCxWMx8fHzqbH/w4AHT09NjYrG43uNvQ/NvKjoJQdTNs8ebpUuXMltb21cef7Zs2cLMzc1VkSIhDULHV+VxXeRgjPoaqu5r0OdftV72ei9btozZ2dkxhUKh4qxUSyqVMgAsJSWFl/jdunVjS5Ys4SU2IeQJLoscIsY0fKJBQhrp7NmzGDRoEM6ePYuBAwcKnY4gxo4di7KyMpw4cULoVOpITU1F+/btcfr0aQwaNIjT2O3bt8fUqVOxfPlyTuNqorCwMIwaNQrff/89Pv/8c87j6+rqYu/evS+dR52ov8OHD2P8+PGoqqqiIdrPyM7Ohq2tLSwtLZGbmyt0Oo3m5+eHiooKHD58WOhUCAFQ93gjEonQrl07TJkyBWvWrHnp41auXIl9+/bh1q1bKsqUkJej46vyqP9Ylyb2Nejzr1over0ZY3B2dsaYMWPw448/CpSdagQEBGDevHkoKSmBjg63s/EzxmBsbIxffvlF7dYxJUSbcHjeYTutyUGandWrV2PQoEHNtsBRWFiIv//+G35+fkKn8pwTJ07AyMiI8/UDZDIZUlNTm+16HM8aMWIEfvjhB3zxxRfYs2eP0OkQotZEIhGSk5PrbIuMjAQADB48WIiUCNFq4eHhyMjIwJQpU1657/379xu9IDAhhKgb6msQLkVERCAlJaVZLDp/48YNdOrUifMCB/DkHEJpaSnat2/PeWxCCD+oyEGalZiYGISHh+Orr74SOhXBhISEQCQS1S6Ip05OnjwJT09P6Ovrcxo3KioKurq6dRYYbO4WLFiARYsWYdq0aThy5IjQ6RCi1j7++GPcvXsXjx8/RkREBL788kuYmppixYoVQqdGiNbZu3cv3NzcGrSIaF5eHhU5CCFagfoahCsbN27E4MGD0bVrV6FT4V1iYiK6dOnCS+y7d+8CAJycnHiJTwjhHhU5SLOyevVq9OvXD0OHDhU6FcEEBwdj5MiRaNmypdCp1FFVVYUzZ85g+PDhnMe+cOECunXrBhMTE85ja7J169Zh2rRpmDJlCs6fPy90OoSopfDwcBgbG8PNzQ1mZmbw8/ND//79ERMT06CTsISQhqusrERoaCgmTJjQoP3z8vLQunVrnrMihBB+UV+DcOXKlSs4ceIEL1MSqyM+ixwpKSnQ19eHjY0NL/EJIdwTC50AIapy9epVhIWF4dixY0KnIpicnBycPXsWhw4dEjqV55w/fx5FRUW8FDmkUinc3Nw4j6vpRCIRfvvtNzx8+BDvvPMOjh8/3myncSPkRTw9PeHp6Sl0GoQ0C6dPn8bDhw8xevToBu0vk8nw1ltv8ZwVIYTwi/oahCuLFi1Cnz598M477widCu+Ki4uRlZWFzp078xL/7t27cHR05GUqLEIIP+jbSpqNNWvWoEePHhgxYoTQqQgmODgYRkZG8Pb2FjqV54SFheGNN97gfDioXC5HXFwc5+t8aAtdXV0cOHAAo0ePhre3N06dOiV0SoQQQpqpo0ePonfv3nB0dHzlvowxpKWlNWhfQgghRNsdP34cp06dwg8//ACRSCR0OrxLTEwEY4zX6apoPQ5CNAsVOUizkJKSgiNHjmDJkiXN4g/+iwQHB2PChAkwMDAQOpXnHD9+nJcC1OXLlyGXy6nI8RJisRiBgYGYMGECRo4ciT///FPolAghhDRDx48fb/AojuzsbJSVldEJCEIIIc1eaWkp5s2bh0mTJjWbkfmJiYkwNDSEg4MDL/Hv3r1L63EQomGoyEGahZ9++gn29vbw9fUVOhXBJCcn49KlS/Dz8xM6leekpqbi1q1bvBQ5Lly4AEtLS+qgvIKuri527NiByZMn491330VgYKDQKRFCCGlmcnJyMGTIkAbtm5KSAgBU5CCEENLszZs3D8XFxdi4caPQqajMjRs30LlzZ96mk0pJSaE+BiEahtbkIFqvoKAAgYGBWLt2LcTi5vuR37NnD6ytrTFo0CChU3nO8ePHYWpqCnd3d85j03ocDaejo4Pt27fD0tISM2bMQEpKClauXNmsRz8RQghRHT09PfTq1atB+969excGBgawtrbmOStCCCFEfe3duxc7duzA0aNHYWlpKXQ6KsPnouOlpaXIzc2lIgchGqb5nvElzcaWLVsgkUgwY8YMoVMR1P79+zFx4kTo6uoKncpzwsLC4OXlBT09Pc5jx8TEYN68eZzH1VYikQhr166Fs7Mz/P39cevWLezevRstWrRoVJxNmzbhyJEjPGVJVCEzMxMAMHHiRCp0aZno6GgoFAq8++67QqdCCID/HW+cnJygr6/foMekpqaiffv2tCAoUTsxMTF0fFUCY4z6jxqO+heqFR0djfbt22PmzJmYP39+g6d71BaJiYnw9PTkJfbdu3fBGKPZIAjRMFTkIFpNLpfj119/hb+/P4yNjYVORzCXLl3C7du3ERQUJHQqz3n8+DHOnj2LLVu2cB773r17yMrKovU4lDB9+nTY29tj/Pjx8PT0xKFDh2Bra9ugx86fPx/p6ek8Z0j4ZmdnhwkTJgidBuFB//79hU6BkDrs7OzwxhtvNOqKSZpGgqij8ePHo7q6Wug0NNL48eOFToE0EfUvVOuNN95AdHQ0hg8fju+//17odFSquLgY2dnZvI3kSE1NhUgkgqOjIy/xCSH8oCIH0Wr79+9Hfn4+PvnkE6FTEVRwcDCcnJzQu3dvoVN5Tnh4OCoqKuDt7c157AsXLkAikTR46gtS19ChQyGVSuHr6wtXV1fs378fgwcPfuXjfvzxRxVkRwghRJt4eHg06mRCXFxcs15rjaincePGYdy4cUKnQQjRclKpFO+88w4GDBiAffv2qeVsDXxKTEwEY4y3Ise9e/fQunVrGBoa8hKfEMIPGt9NtNqvv/6K8ePHw87OTuhUBKNQKHDgwAFMnjxZLaecCQsLQ+/evdGmTRvOY0ulUri4uFDnpAk6deqEixcvYtCgQRg2bBhWrFgBhUIhdFqEEEK0TFpaGhwcHBq076NHj3D79m26iIEQQkizExkZieHDh+PNN9/En3/+2Sx/6yYmJsLIyAht27blJX56ejpvsQkh/KEiB9Fa8fHxuHjxIj766COhUxHUmTNnkJWVpZZzozLG8Pfff2PEiBG8xJdKpTRVFQeMjY1x4MAB/N///R/Wrl2LMWPGoLCwUOi0CCGEaInKykpkZ2c3uMgRFxcHhUKhliNUCSGEEL4cO3YMb7/9Nnx8fHDkyBEYGBgInZIgEhMT0blzZ97W5aIiByGaiYocRGtt3rwZnTt3hru7u9CpCCo4OBi9evVC586dhU7lOVevXkVmZiYvRY7S0lJcvXqVihwcmj17NiIiInDp0iX07dsX169fFzolQgghWiAjIwPV1dVo165dg/a/dOkSLC0tYW9vz29ihBBCiBpgjGH16tUYO3Yspk6diqCgIEgkEqHTEkxiYiJvU1UBT4ocDb3wghCiPqjIQbRSYWEhDhw4gE8++UQtp2hSlYqKChw5cgR+fn5Cp1Kv48ePw8rKCq6urpzHjo2NRVVVFdzc3DiP3Zx5eHjUnlwaMGAAduzYIXRKhBBCNNy9e/cAoMFFjrNnz+LNN9/kLyFCCCFETTx69AgTJkzAt99+i7Vr12LLli3Nbg2OZ8XHx8PFxYW3+GlpaXQhBSEaiBYeJ1pp586d0NHRwaRJk4RORVAnTpxAYWEh3nvvPaFTqVdYWBhGjBjBSyHqwoULsLGxoc4JD2xsbHD69Gl8/fXXmDVrFk6cOIHffvsN5ubmQqdGCFEjcrkcubm5yM/PR35+PgoKCvDgwYPa/5aVleHhw4eQy+UoLS1FUVER5HI5Hj169FysysrK2isWJRIJjI2NAQCGhoZo0aIFWrZsCXNzc7Rs2bL29tprr8HOzg5t2rSBnZ0djIyMVPr8ScPdu3cPhoaGsLCweOW+1dXVOHfuHFauXKmCzAghhBDh3L59G+PGjUN+fj7+/fdfeHh4CJ2S4DIyMpCfn4+ePXvyEr+iogK5ubk0XRUhGoiKHEQrbdu2DZMnT4apqanQqQgqJCQEAwYMUMuF1/Pz83Hx4kUsWrSIl/hSqZSu8uSRRCLBd999By8vL3zwwQfo0aMHgoKC8NZbbwmdGiFEBeRyOe7du1d7S0tLQ1ZWFmQyGbKzsyGTyZCfn1/nMbq6umjVqhVee+01tGrVCi1atIC5uTlMTU1hZWUFU1NT6Ovrw8TE5KVtl5eXo6ysDMCTqxvLyspQVFSEu3fvorCwEEVFRSgqKkJBQQGqqqpqH2dkZAQ7OzvY2dnByckJHTp0gJOTU+3/UxFEOGlpaWjXrl2DLnq4cuUKHj58iMGDB6sgM0IIIUT1GGPYvHkzlixZgi5duuDixYt08d7/Fx8fD5FIhB49evASPyMjAwqFgoochGggKnIQrXPhwgXcunULe/fuFToVQVVWVuL48eP45ptvhE6lXn///Td0dXUxdOhQzmMzxhATE4OlS5dyHpvU5enpiWvXrmHmzJnw9PTE4sWLsWLFCojF9OeFEE1XXV2Ne/fu4ebNm7h58yZu3bqF27dvIzU1FTk5OWCMAQBMTU3h4OAAe3t72Nraol+/frWjJ9q0aQMLCwtYWFjAzMxMpfkzxpCbm4vc3FxkZWUhNzcXmZmZyMjIQHJyMk6cOIHMzEwoFAoAgJ2dHbp3747u3bujZ8+e6N69O15//fVmPyWEKiQnJ6NDhw4N2vfkyZOwsrJSy7XGCCGEkKZKS0vDjBkzEBkZic8//xwrV66Enp6e0Gmpjfj4eLRv3x4tW7bkJX56ejoAUJGDEA1EZ6GI1tm5cye6du3KyzoPmiQiIgIPHz7EmDFjhE6lXmFhYRg4cOArr9hVRlJSEu7fv0+LjqtIq1atcPToUfz2229YsGABwsPDsWfPngafsCKECEsul9cWMG7cuIFbt27V3uRyOYAnBYA33ngDLi4uGDduHNq1a1d7U9ep6kQiEaysrGBlZfXCq/3kcjnu3r2LlJQU3Lx5E1evXkVYWBg2bNiAyspKtGjRAt27d0f//v3h7u4ONzc32NraqviZaL+kpKQGT8Hxxx9/YOTIkc16zTVCCCHaR6FQYNu2bVi0aBHatm2L6Oho9OrVS+i01M6VK1d4XY8jMzMT+vr6sLS05K0NQgg/qMhBtEpZWRlCQkKwbNkyoVMR3OHDh9G7d284OjoKncpzqqqqcPLkSSxfvpyX+BcuXIC+vj5v83SS+vn7+2PgwIGYNGkSevTogVWrVuGzzz6jq6AJUSO5ubmIi4urvV29ehX37t1DdXU1xGIx2rdvj86dO8Pb2xvz589H586d0bFjR62d/lFfXx+dOnVCp06d4OPjU7u9oqICiYmJuHr1KuLi4nDu3Dn8+uuvqKqqQtu2bfHmm2/Czc0Nw4YNw+uvvy7gM9AOycnJmDZt2iv3y87OxqVLl3jrPxBCCCFCOHfuHD777DNcv34d8+fPx8qVK2FgYCB0WmopPj4es2fP5i1+dnY2rK2t6WIKQjQQFTmIVgkJCcGjR4/g5+cndCqCqq6uxrFjxzB//nyhU6lXVFQUCgsLMWLECF7iS6VS9OnTB/r6+rzEJy/WqVMnxMTEYN26dViyZAkOHTqEgIAAmlaEEAFkZmbWKWjExcUhKysLAODg4ABXV1dMnTq19iS/s7MzTYfw/+np6cHFxQUuLi61J98fP36M2NhYREVFQSqV4quvvsInn3wCR0dHeHl5wcvLC56enrxNn6CtHjx4gIcPH8LZ2fmV+x45cgRGRkbw9PRUQWaEEEIIv7KysrBkyRLs2bMHgwcPRlxcHLp16yZ0Wmrr4cOHSE9P53UkR05ODqytrXmLTwjhDxU5iFbZuXMnfHx8YGVlJXQqgoqMjEReXh7Gjh0rdCr1CgsLg5OTU4NOaChDKpXi7bff5iU2eTWJRIJly5bB19cXH374IVxdXfHNN99g0aJFkEgkQqdHiFbKy8uDVCpFbGxsbUEjLy8PIpEITk5OcHV1xaeffgpXV1e4urqiVatWQqescYyMjDB48ODaBa+rqqoQExODkydP4p9//sHvv/8OkUiEAQMGYPTo0bXTepGXS05OBoAGTXEYFBSEsWPH0tWthBBCNFpeXh42bNiAX375BTY2Njh69ChGjx4tdFpqLz4+HowxXmdsyM7Oho2NDW/xCSH8oSIH0Rrp6ek4e/Ysjhw5InQqgjt8+DC6deuGjh07Cp1Kvf766y+MHDmSl9jFxcW4ceMGvv32W17ik4br2rUrLly4gI0bN2L58uUICQnBjh07eL3yhpDmoLq6GomJibUjCqRSKZKTk6Gjo4OOHTvC1dUVX375JVxdXeHi4kIjC3giFovh7u4Od3d3rFy5EgUFBQgPD8dff/2FtWvXYuHChejVqxfGjRuHcePG0bRWL5CcnAw9Pb1XLvCZlJSEixcvYvXq1SrKjBBCCOGWTCbDDz/8gN9++w1GRkZYuXIlPvnkE5qBoIHi4+NhaWnJ60iLnJwcmvaaEA1FRQ6iNQ4cOICWLVvC29tb6FQExRjDH3/8gZkzZwqdSr3u3r2LxMREbNq0iZf40dHRqK6upkXH1YSuri6++OILjB49GjNnzkTfvn0xd+5crFy5EmZmZkKnR4hGKCwsRHR0NKRSKS5cuICYmBiUlJTAxMQE/fr1w/vvv48BAwagf//+9L0S0GuvvYZ3330X7777LiorK3H69GkcPnwYP/30E5YuXYpu3bphypQpmDx5Mk2D8JSkpCQ4Ojq+cv2mgIAA2NjYYMiQISrKjBBCCOFGWloafvrpJ2zbtg1mZmZYtWoV/P39YWhoKHRqGuXKlStwdXXltY3s7Oxmf06JEE2lI3QChHDlwIED8PX1bfbziV+6dAlZWVlqO1VVaGgoTE1N4eHhwUv8CxcuoH379s1+yjJ18/rrr+PMmTPYunUr9u/fj44dOyIwMBCMMaFTI0TtZGZmYu/evfD390fXrl3RqlUreHt7Y9++fbC2tsb333+Pq1ev4uHDhzh16hS+/fZbvP3221TgUCMSiQReXl747bffkJOTg9OnT+PNN9/EunXr0LZtW4wcORKHDx9GRUWF0KkKLiUl5ZVTVZWWluL333/HRx999MpiCCGEEKIOGGMIDw/H2LFj4eTkhMOHD+O7775DSkoK5s+fTwUOJcTHx/M+K4BMJqPpqgjRUFTkIFohJSUFcXFxeO+994RORXDHjh1D27Zt0b17d6FTqVdYWBjefvtt3opRUqmURnGoKR0dHXz44Ye4ffs2JkyYgJkzZ8Ld3R3x8fFCp0aIoFJSUhAYGIhp06bByckJ9vb2mDFjBhITE+Hj44MjR44gNzcXSUlJ2L17N+bMmYPu3bvTyV4Noauri0GDBuH//h97dx4XZb32D/zDDsIAAyKyJ+a+LyyyqOGuoaX2pJVbEVpW2nParI7L0dTqsVLrZIt6Mj2pR46lkBsCgrK54YrsouzrwAz7Mr8//M0kAirIzD0Dn/frxQvmnpv7umaymeG+7u91/fOfyMnJwa+//oq6ujq8+OKLcHBwwIoVK3Dz5k2h0xRMSkrKI2d0/etf/0JlZSUCAwPVlBUREVH7lJeX47vvvsOgQYMwadIklJSU4LfffkN6ejrefvttmJiYCJ2iVqqqqkJSUpJKixwSiQSVlZVccUukpdiuijqF/fv3o3v37sphoF3Z0aNH4e/vDx0dHaFTaUYmkyEyMhI//vijSo7f2NiI8+fPY/369So5PnUMsViMb7/9FgEBAXjrrbfg5uaGpUuXYt26dejevbvQ6RGpXGJiIiIjIxEZGYkzZ84gOzsbJiYm8PDwwIIFCzB27Fh4enryCr9OyNjYGPPmzcO8efOQlZWFPXv2YPfu3di+fTsmTpyId955B9OnT4eubte5Dik1NRWvvPJKq/fL5XJs374dCxYs4HuEgEpLSx+5j1QqRX19/SP3MzAwgJmZmfK2sbExT/oRkVarq6vDiRMnsHfvXhw5cgQ6Ojp4+eWXsX//fo29+FDbXLt2DfX19SotcuTn5wMAu0IQaSkWOahTOHDgAF544QXo63ftf9J3797F1atX8fnnnwudSotOnDiBuro6TJ06VSXHv3nzJkpLS+Hl5aWS41PHGj58OKKiovDrr7/io48+wt69e/HBBx9g5cqVMDU1FTo9og6TmJiI8PBwhIeHIzIyEgUFBTAzM4OXlxeWLVuGcePGwd3dnUMnuxhHR0d8/PHH+Oijj3D8+HFs27YNM2fORO/evbF8+XK8+uqrMDc3FzpNlZJIJCguLn5ou6qQkBAkJSXh4MGDasxMO1VUVEAikUAikaCsrKzJz+Xl5ZDJZKirq0NZWRkaGxtRWlqKhoYGlJeXo7a2FhUVFaiqqkJ1dTUqKipQW1uL8vJyNDQ0qPVxdOvWrcnroUgkUn7GVxREFPso7rO0tISenh4sLCyURRQjIyN069atxX2NjY1hZmYGCwuLJscnInpccrkcsbGx+Pe//439+/ejuLgYvr6+2Lp1K1544QW2Ee1gly9fhkgkgqurq8piFBYWAgBsbGxUFoOIVIef5kjrJSUl4dq1a9i2bZvQqQju6NGjMDU1xbhx44ROpUXBwcHw9PREjx49VHL86OhomJqaYsiQISo5PnU8HR0dLFy4EHPmzMHXX3+NL774At999x1Wr16N1157DQYGBkKnSNRmqampCA8PR0REBMLDw5GbmwuRSARfX1+899578PX1xejRo3lSjQDca+U3ffp0TJ8+HUlJSdi2bRv+/ve/Y/Xq1Xj99dfx3nvvddq2CSkpKQDw0HZVX3/9NSZNmtRl39vz8/ORk5OD7Oxs5ObmoqCgAIWFhSgqKkJhYSHy8/OVt1ua8WJgYAALCwuYm5s3Ocmvq6sLS0tLGBoawtXVFYaGhjA1NW21iGBhYfHIFUaKYzxKdXU1qqqqlLcVBRWFB1eESCQS5QwvRRHm/oJNQ0MDMjIyUF9fD6lUipqaGlRWVjbb92EURQ9zc3OYm5vDzMwMpqamMDc3h4WFBUxNTWFmZgaRSARLS0vlbQsLC1haWsLCwgJisfixnici0l41NTUIDw/HH3/8gSNHjiAnJwcDBgzAu+++i5dffhkuLi5Cp9hpJSQkYNiwYSp9jS0uLgYAWFlZqSwGEakO/7omrff777/D2tpaZYOstUlwcDAmT54MY2NjoVNpprGxEceOHcOKFStUFiMmJgbu7u48caiFTE1N8emnn2Lp0qX47LPPsGLFCnz11Vf47LPPMHfuXI1sv0akcOfOHYSHhyMsLAzh4eG4e/cuunXrBm9vb7z99tt45plnWNSgx9KvXz9899132LhxI37++Wd89dVX+Oc//4mAgAB88MEHcHJyEjrFDpWSkgJ9fX04Ozu3eH9UVBTCwsIQFham5szUo7a2FpmZmUhPT0d6ejoyMjJw9+5dZGVlITs7Gzk5OaipqVHuLxKJ0LNnT9jY2KB79+5wcnKCm5sbunfvju7du8PKygqWlpbKk+6Kk/F0j6IgIpFIUFVVBZlMBqm8gTvCAAAgAElEQVRUirKyMlRUVLR6+86dO5DJZKioqFDeL5PJmvy3uZ+iMHJ/AUTxXfHzg/+dLC0tYWVlBbFYzPcKIg2Tm5uL0NBQHD16FMePH4dMJsPIkSOxdOlSzJo1C8OGDRM6xS7h8uXLcHd3V2mMoqIiiEQijTyfQkSPxk9QpPWOHDmCmTNndvkBrBUVFQgPD8f3338vdCotio+PR35+Pp599lmVxYiNjcXzzz+vsuOT6tnY2OCbb77BihUr8Pe//x3z5s3DsGHD8Mknn+D555/n1ZGkEXJycpqs1EhLS4OxsTE8PT0REBAAPz8/uLu7w9DQUOhUSUtZWFjgb3/7G5YvX46dO3fiiy++wI8//ohFixbho48+UmmrBnVKTU1Fr169Wl21t3r1avj4+Gj1zDW5XI7MzEzcunULN27cwK1bt5CamoqMjAxkZWUpW0GJxWK4urrC2dkZI0aMwLPPPgt7e3s4OTnBzs4OTk5OnNPzhCwsLAB03BW6ipUkitZgpaWlyp/v3674np2d3aSN2P0rVO5nbm6uLHhYWVk1+bp/24P3898HUccoLS1FREQEwsLCcPr0aSQmJsLQ0BDjxo3D5s2b4e/v3+kuOtB0DQ0NuHbtGgIDA1Uap7i4GNbW1iqNQUSqwyIHabWCggLExcXh/fffFzoVwZ06dQq1tbWYNm2a0Km0KCQkBM7OziprNyGRSJCcnAxPT0+VHJ/Uq1evXti7dy/ef/99rF+/Hv/zP/+D/v37Y9WqVZg3bx6vciS1ys3NRUREhPIrOTkZhoaGcHd3x0svvYRnnnkGY8aM4VVf1OGMjY2xfPlyvP7669izZw82bdqE3bt3Y9GiRVi3bh0cHByETvGJpKamttqq6uzZs8r/57RFUVERLl26hEuXLuHatWu4desWbt26hcrKSgCAnZ0dBgwYgH79+mHatGlwdXVFr1694OrqCrFYLHD21FYGBgbKVTTtVV5erix4lJSUoLS0FCUlJcovxe3U1NQm28rLy5sdy8jI6JHFkNZ+JurK0tPTERMTg9jYWERHR+PKlSsAgBEjRsDf3x9ff/01fH19WUgU0PXr11FZWanylRzFxcVP9JpORMLiWSLSakePHoWhoSEmTZokdCqCCwkJgbu7O2xtbYVOpUXBwcHw9/dX2fHj4+PR2NgINzc3lcUg9Rs2bBgOHTqEmzdvYtOmTViyZAnWrl2Ljz76CAsXLuSV8qQSeXl5iIiIwJkzZxAREYFbt27BwMAAbm5umDt3LsaPHw9vb2/+sUtqY2hoiICAACxevBj79u3DmjVr8Ntvv2HlypX48MMPtXZAeUpKCjw8PFq879NPP8XEiRM1ds5YYWEhYmNjcenSJVy+fBmXLl3C3bt3AQBOTk4YMmQI/Pz88Oabb2LgwIEYMGAAh9BSM4oZIK21bGtNfX19s6JISz8XFBTg1q1bTe5raZB8a6tDHnZbLBY3GRBPpA3y8/Nx9epVXLhwAbGxsYiNjUVBQQEMDAwwYsQI+Pj44NNPP8X48eNZfNYgsbGxEIlEGDBggErjFBUVcSUHkRZjkYO02pEjRzBx4kT2GwZw8uRJvPrqq0Kn0aKcnBxcuXIFmzZtUlmM+Ph4uLi4dNrhrF3dwIED8euvv2Lt2rX4/PPPsXz5cqxbtw5vvvkmXn/9dV5xQ0+koKCgyUqNxMRE6OvrY/To0Xjuuecwfvx4+Pj48L2GBKevr49FixbhxRdfxLfffotNmzbhxx9/xN///ncsW7ZM6wq/KSkpePnll5ttDw0NxZkzZ3Du3DkBsmrZrVu3EB0djbNnzyI6OhpJSUnQ0dGBq6srRo4ciTfffBMjRozAyJEjYWNjI3S61Mnp6+ujR48e6NGjR5t/t7y8vEkxpLi4uMUCyfXr15vcVqxIup+pqelDCyLW1tYtbheJRB3xNBC1qra2FsnJybh69SquXLmi/MrLywMAODo6wtPTEx9++CE8PDwwatQorsjVYHFxcRg9erTKW5RzJQeRdtORt9QIlEgLVFdXw9raGt988w1ef/11odMRVGJiIgYOHIiYmBiNbNe0Y8cOvPfeeygqKlLZh8eZM2fCxMQEBw4cUMnxSbPcvXsX27Ztw86dO1FVVYWXXnoJb7/9NoYPHy50aqQFCgsLlas0wsPDkZiYCD09PYwaNQrjx4/HuHHj4OvrCzMzM6FTJXqo0tJSbNq0Cdu3b4eDgwM2b96MuXPnCp3WY5FIJBCLxTh27BimTp3a5L6xY8fC1NQUx44dEyg74Pbt2zh58iROnjyJyMhIFBYWolu3bnBzc4OPjw+8vLzg5eXF1RnUZVRXVz909UhLt0tKSiCRSJody8DA4LHmjLR0m/PZ6H65ublITk5GUlISkpOTkZiYiKSkJNy+fRsNDQ0wMDDAwIEDMWzYMAwdOhTDhg3D8OHDeSJbywwaNAgzZ85U6UWTAODj44NRo0Zh69atKo1DRH8JCgrC3LlzUV9f/6SFzJ+4koO0VlRUFCorK5v9YdwVnThxAmKxWGNbNQUHB2PSpEkqvTomPj6es1m6ECcnJ3z55ZdYu3Yt9u7di+3bt2PXrl0YO3Ys3n77bcyaNavVQbbU9RQVFSEyMlJZ1Lhx4wZ0dXUxcuRIzJgxA19++SV8fX15ZSlpHbFYjC+++AJvvfUWPv30U/zP//wPJk2ahO3bt6Nv375Cp/dQKSkpANBsJseff/6JqKgoxMbGqjWfiooKhIWFKQsbycnJMDU1xfjx47Fq1Sp4e3tjxIgRfG+hLsvY2Bj29vawt7dv0+81NjY+shhy/+yR+++rq6trdjxzc3NYWlrCwsIClpaWyq/7b9//s1gsbnKbc920R3V1NfLy8pCdnY3MzExkZmbi9u3bTb5XV1cDAEQiEfr164d+/fph8eLFyp/79++vdascqSmpVIpbt27hs88+U3ksDh4n0m58hyetderUKQwcOBBOTk5CpyK4kydPYuLEiSpfvtkeVVVVCA8PV+nVELdv30Z+fn6rfb2p8zI1NcXSpUsRGBiIsLAwbN++HS+++CJsbGzw8ssvY8mSJRg8eLDQaZKa5eXl4dy5c8rCxrVr16Crq4vhw4djypQp2LRpE8aOHau1cwyIHuTs7Iw9e/Zg6dKlePPNNzF06FC8//77+Pjjj2FiYiJ0ei1KSUmBvr5+s1kE69atw8yZM9Xynl5SUoKjR4/i8OHDOHnyJKqrqzF8+HDMnj0bkydPhre3N0+OET0hXV1dWFtbt+vEoVQqbbZyRDGovaysrMnPmZmZTW6XlZW1eExTU1NYWlrCzMwMIpEIlpaWEIlEEIlEzbaZmZnBzMwMFhYWsLCwUN5vZmbGVVztJJPJUFRUhIKCAhQXF6OoqAjFxcUoLCxEdna2sqiRm5uL4uJi5e8ZGBjA0dERTz31FFxcXDBmzBj06tULLi4uePrpp+Hg4CDgoyJVUszeVPXQceDehVFc5UOkvVjkIK118uRJDhzHvX6jkZGR+Oabb4ROpUWhoaGoqqrCtGnTVBYjLi4Oenp6GDFihMpikGbT0dHBhAkTMGHCBGRmZuKXX37BL7/8gq+++gqjR4/GokWL8NJLL8HKykroVKmDyeVy3Lx5E+fOnVN+paWlQU9PD0OHDsWECROwYcMG+Pr68oQEdXre3t64ePEivv32W6xZswZ79+7F1q1bMXPmTKFTayY1NRW9evVqsjLijz/+wPnz53Hx4kWVxS0qKsKhQ4fw3//+FxEREdDV1cWECROwfft2+Pv7t2vGARGphqL40NbB7MC9zwcSiQSlpaXNCiISiQQymQwymQylpaXKYsqdO3cglUqV90ul0hZnkdyfn6GhISwsLGBoaAhTU1OYmpoqt+nr6z/2fQBgYmKiXPluYGDQpG3m/UOwRSKRSlekSCQSyOVySKVS1NfXo7KyEjU1NaipqUFlZSXq6+shlUrR2NioLCZJJBLU1NSgrKwM5eXlyue7vLxcua24uBg1NTVNYhkZGcHa2hrdu3eHo6Mj7O3t4e7uDltbWzg6Oiq/29nZaeQFfaR6cXFxcHZ2bvMqsrZSrDpjkYNIe3EmB2ml/Px82NnZ4ejRo5gxY4bQ6Qjq9OnTmDhxIjIzM9v1B4CqLVu2DJcuXUJ8fLzKYvztb39DWFgYLl++rLIYpH3kcjkiIyOxe/duHDp0CPX19Zg+fTrmzp2LZ599llfxa6mqqipcuHABZ8+exblz5xAdHY3S0lKYmZnB3d1d2St/zJgx/G9MXVpubi7+9re/4bfffsOsWbPw/fffw87OTui0lBYuXIji4mKEhIQot40ePRouLi4ICgrq0Fh1dXU4duwY/vWvfyEkJAQGBgaYNm0aZs+ejRkzZvC1gohapTiRX15eDqlU2qw4UldXB4lEgtraWlRUVCgLAmVlZaivr0dZWZmyOFBRUYHa2lpIJBLU19ejvLz8ifMzNjbukBV7isJGW+jp6SlfP8ViMYyMjGBubq5sKWZpaQlzc3NYWFjA3NxcuaLH2toaPXr0QPfu3Tn/jB5p1qxZMDIywsGDB1Uap6SkBNbW1ggNDcWECRNUGouI/sKZHNTlnTp1CgYGBhg3bpzQqQju5MmT6N+/v0YWOORyOUJCQhAQEKDSOHFxcWxVRc3o6Ohg3LhxGDduHLZv345Dhw7hwIEDWLx4MXR1dTFp0iTMnTsXM2fObHJ1HGmW1NRUXLhwAefPn0dMTAwuXryI2tpa2Nvbw9vbG2vWrIG3tzeGDx/OPttE97Gzs8O///1vBAQEIDAwEIMGDcK2bdvwyiuvCJ0agHvtqu5vPREREYGLFy/in//8Z4fFuHHjBnbt2oV9+/ahsLAQ48ePx88//4w5c+agW7duHRaHiDovXV1diMVilX1WrK6uRlVVFYB7rZwUc0gUhREAaGhoaFIQKSsrQ2NjIwAoCycdQfEYzc3NoaenBzMzMxgYGKBbt24wMjKCkZERunXr1myVCZEqxcXFqWX2ZlFREQBwJQeRFuPZANJKoaGh8PLy4ocr3CtyTJ48Weg0WnT16lVkZWWpdLVNfX09EhIS8Oqrr6osBmk/kUiEJUuWYMmSJSgtLcWRI0dw6NAhLF26FK+//jqeeeYZTJ06FVOnTsWAAQOETrfLys7Oxvnz53H+/HllYaO0tBT6+voYPHgwPD098eabb8Lb2xu9evUSOl0ireDn54crV67go48+wsKFC/Gf//wHO3bsEHxVR2pqKl5++WXl7a+//ho+Pj5P3HNbLpfj9OnT2Lp1K0JCQuDo6IjFixcjMDAQrq6uT5o2EVGHMjY2Vrao4kU3RE2pc/amosjBweNE2otFDtJKEREReO2114ROQ3DFxcW4evUq/vGPfwidSouOHTsGGxsbjBw5UmUxrl27hoqKCq7koMcmFouxaNEiLFq0COXl5QgODsaRI0ewYcMG/O///i+cnZ0xZcoUTJkyBRMmTOAcBxUpKipSFjIU33Nzc6Grq4u+ffvCzc0Na9euhZubG4YPH66xw5OJtIGpqSm2b9+OuXPn4tVXX8XgwYOxdetWwVZ1SCQSFBUV4emnnwZwb1VHcHAw/vOf/7T7mBUVFfjll1+wdetWpKSkYPLkyTh27BgmT54MHR2djkqdiIiI1CQuLg4GBgYqPZ+goBh0zyIHkfZikYO0zt27d5GZmYmxY8cKnYrgIiMjAQA+Pj4CZ9KyEydOYOrUqdDV1VVZjLi4OIhEIvTv319lMajzMjc3x0svvYSXXnoJDQ0NuHDhAo4fP44TJ05g165d0NHRwdChQ5VzHnx8fODg4CB02lpFJpPh5s2buHbtGm7cuIHr16/j+vXryM3NBQC4uLjAzc0NK1euhJubG0aNGsX++EQqMm7cOFy9elW5qiMoKAg///yz2v+gT01NBQBlkWPr1q1wdnbGrFmz2nwsmUyG7du34//+7/9QVVWFBQsW4Pfff+eqPCIiIi0XFxeHIUOGqKXFZFlZGYyMjHhhFZEWY5GDtE5ERAQMDQ3h5uYmdCqCO3PmDIYNG6aRS5ulUimio6Oxa9culcaJj4+Hm5vbkw4oIoKenh48PDzg4eGBNWvWoLS0FGFhYYiKikJ0dDT++c9/or6+Hi4uLvDx8VGuMBg+fDgsLCyETl9wtbW1SExMxI0bN5oUNG7fvg25XI5u3bphwIABGDJkCCZPnowhQ4Zg5MiRsLGxETp1oi5Fsapjzpw5WLhwIYYPH469e/eqdc5ZWloa9PT04OLiAolEgl9++QXr169v03t5dXU1duzYgU2bNqGqqgrvvvsu3nnnHV6BSURE1Emoc/ZmeXk5L7Qi0nIscpDWiYqKgpubGwdG4l6RY/z48UKn0aLTp0+jvr4ekyZNUmmc8+fPq3TmB3VdYrEYc+bMwZw5cwDca4USFxeHs2fPIjo6Ghs2bEBRURF0dHTQq1cvjBgxAsOHD8fgwYPRr18/uLq6wsjISOBH0bFqamqQmZmJ1NRUpKSkIDU1Vfl1+/Zt1NfXw8DAAP369cOgQYPw2muvYdCgQRg8eDBcXV1VuqqLiNpm/PjxSEhIwGuvvYYJEybgk08+werVq9Vy0UB6ejqcnZ1hYGCAgwcPoqGhAUuWLHms321oaMDOnTuxfv16lJSUYPny5fjggw84KJSIiKgTqaurw+XLlxEYGKiWeFKpFCKRSC2xiEg1WOQgrRMZGYnZs2cLnYbgysrKcO3aNaxZs0boVFp0/PhxjB49Gj169FBZjMrKSiQmJmLt2rUqi0GkYGpqCj8/P/j5+Sm3ZWVl4fLly0hISEBCQgJ2796N9PR0APdWhjg7O6NPnz54+umn0adPHzg6OsLe3h5OTk7o2bMnDAwMhHo4zVRUVCA3Nxf5+fkoKChQtga8e/cu7ty5gzt37iAvLw9yuRwA0KNHD+Xj8vLyQt++fTFo0CD069dPox4XEbXOysoKhw8fxnfffYf33nsP4eHh2LdvH5ycnFQaNz09Hb179wYA/PLLL3juuecea0VcbGwsli9fjmvXrmHZsmVYtWqV4APUiYiIqONduXIFVVVValvJwSIHkfZjkYO0SmFhIZKTk+Hr6yt0KoKLjIxEY2Ojxs7jOHnyJBYsWKDSGJcvX0ZDQwNGjRql0jhErXF0dISjoyP8/f2V2yorK5WrHFJSUpCSkoJr167h8OHDyM/PR2NjIwBAR0cHtra2sLOzg42NDcRiMaysrCAWi5U/i0Qi6OvrQyQSQU9PD+bm5tDV1VWeDCwvL0dDQ0OTnBobG1FWVtbse3l5OSQSCSQSCUpLS5XfCwoKkJeXh4qKiibHsbW1hbOzM5ycnDBmzBjMnz8fzs7OeOqpp9C7d28u5ybqRJYvXw4fHx/Mnz8fw4cPx65du9o1H+NxpaWloU+fPkhLS0NMTAxWr1790P1LSkqwbt06fPfdd/Dx8cHly5cxaNAgleVHREREwoqLi4OlpSX69u2rlngschBpPxY5SKucPXsWOjo68PLyEjoVwZ05cwaDBw/WyPYMiYmJyMjIwJQpU1Qa58KFC7CysoKLi4tK4xC1Rbdu3TBs2DAMGzas2X319fXIy8vD3bt3kZOTg+zsbOTk5KCoqAilpaW4desWSktLlV/l5eVPnI+iOGJubg5LS0tYWlpCLBajR48e6Nu3L2xsbGBnZ4cePXqgZ8+e6NmzJ2xsbGBoaPjEsYlIewwbNgznz5/HO++8g+effx4ffvghNmzYoJL2Venp6ZgyZQqCgoLQvXt3TJw4sdV99+zZg3fffRcmJibYu3cv5s2b1+H5EBERkWZRzN5UV7vb8vJyFjmItByLHKRV4uPj0b9/fw75xb0ihzqHhLbF8ePHIRaL4e7urtI4Fy9exOjRo6Gjo6PSOEQdRV9fX7n643HV19dDKpWioaFBuXLj/uKHWCxusr+Ojg4sLS2brPggInocpqam2LlzJ3x8fPDmm2/i8uXL+Pe//w0rK6sOi1FbW4usrCy4urriq6++wsyZM1sspEgkEixbtgwHDx7EO++8g/Xr1/PkAxERURcRFRWFhQsXqi0eV3IQaT8WOUirnD9/Hm5ubkKnIbiKigokJCTg/fffFzqVFp04cQKTJk2Cvr5qX2IuXryo0nYaRJpAX19fWcjQxJVbRNT5LFmyBMOHD8fs2bMxYsQI/Pe//+2w1pC3b99GQ0MDLCwsEB8fj1WrVjXbJyYmBq+88goqKioQHByM6dOnd0hsIiIi0nzZ2dnIyMjA2LFj1RZTKpWqfCYZEamWetZ9EXUAuVyOixcvssiBeyf36+vrMWbMGKFTaaaqqgqRkZEqb1VVWVmJpKQkzuMgIiJSgREjRuD8+fPo06cPfHx8sGfPng45bnp6OoB7czkMDQ0xadIk5X1yuRxr166Fr68vhg4diuvXr7PAQURE1MWcOXMGBgYG8PT0VFtMruQg0n4scpDWSEpKgkQiUXkLJG0QFxcHOzs7jbzSICIiAtXV1Sovcly6dIlDx4mIiFSoe/fuOHbsGAIDA7F48WJ8+OGHaGhoeKJjpqenw8rKCrGxsfDy8oKJiQmAexdJvPjii9i0aRO+/fZbHD58mKvXiIiIuqCoqCiMHj0a3bp1U1tMFjmItB/bVZHWiI+Ph6GhIYYOHSp0KoKLi4uDh4eH0Gm06Pjx4xg6dCgcHBxUGufixYscOk5ERKRiBgYG2Lp1K0aNGoWlS5ciKSkJ+/btg6mpabuOl56ejt69eyMsLAzLli0DAOTm5uK5555Damoqjh8/jmeeeaYjHwIRERFpkaioKDz77LNqjckiB5H240oO0hoXLlzA0KFDYWRkJHQqgouLi9PYFS3Hjx/H1KlTVR6HQ8eJiIjUZ+HChYiIiEBMTAy8vb2RlZXVruOkpaXBxsYGWVlZ8PPzw9WrV+Hu7o6ysjLExcWxwEFERNSFlZSUIDExEb6+vmqNW15eziIHkZZjkYO0RkJCAlsT4d7VjllZWRq5kiMjIwPJyckqb1UF3Ct68d8DERGR+nh4eCAmJgY1NTXw9PTElStX2nyM9PR06Ovrw9DQEPr6+vDz80OfPn0QExODp59+WgVZExERkbaIjIwEAHh7e6s1rkwmY5GDSMuxyEFaQS6X49q1a2xVhXurOHR1dTF69GihU2nm2LFjMDU1hZeXl0rjyGQyJCcns8hBRESkZq6urjh37hx69+4NX19fHD9+vE2/n5GRgYqKCvTp0wfTp0/HoEGDcPToUYjFYhVlTERERNoiKioKQ4cOhaWlpdpiVldXo66uDubm5mqLSUQdj0UO0gp37tyBRCJhkQP3ihwDBgzQyDfgEydOYOLEiSpvKXb58mU0NDRoZKGHiIios7OyssLJkyfh7+8Pf39//Pjjj4/1ewUFBZBKpcjMzERaWhoGDBiAkJCQds/3ICIios4lMjJS7a2qpFIpAMDMzEytcYmoY3HwOGmFq1evQkdHB4MHDxY6FcFduHBBI+dx1NbWIiwsDF988YXKY128eBHW1tYcOk5ERCQQIyMj7N27F87Ozli2bBmqq6vxzjvvPPR30tLSlN/t7e0RGBiIY8eOqSNdIiIilbC1tcXYsWOFTqNTkMlkSEhIwAcffKDWuJWVlQCAbt26qTUuEXUsFjlIK1y9ehUuLi5qXbKoqa5cuQJ/f3+h02gmPj4eMpkMkyZNUnmshIQEjBw5UuVxiIiIqHU6OjrYtGkTrK2tsXLlSpiZmeHVV19tdf/09HTo6uqisbER2dnZWLBggRqzJSIi6nh6enqora2Fri4bpTypc+fOob6+Hj4+PmqNW1VVBQAwMTFRa1wi6lgscpBW4DyOe3Jzc1FYWKiRz0VYWBicnJzUMjQ0ISEBkydPVnkcIiIierT33nsPUqkUgYGBGDhwIDw9PVvc78yZM2hsbFTerq+vh56enrrSpC4iKCgIc+fO5b+vTmj+/Pmora1FUFCQ0KkQAfjr9UYulwudSqcQFRWFvn37ws7OTq1xWeQg6hxYaiatcP36dQwZMkToNAR39epVANDI5yI8PBx+fn4qj1NXV4fExEQMGzZM5bGIiIjo8axduxZTpkzBK6+8AplM1uI+p0+fhomJCUQikZqzIyIiIk0XGRkpSOuv6upqACxyEGk7FjlI4zU0NCA1NRUDBw4UOhXBXb16FQ4ODrC2thY6lSaqq6sRGxuLZ555RuWxEhMTUVtbyyIHERGRBtHR0cGPP/6IoqIibNu2rdn9ioHjYrEYDg4OAmRIREREmqqmpgbnz59X+9Bx4K+VHMbGxmqPTUQdh0UO0ngZGRmoqalBv379hE5FcJratis6OhrV1dUYP368ymNduXIFRkZG/PdARESkYRwcHPDWW2/hq6++QkVFRZP7Dh8+jMbGRhgZGam9DQURERFptri4OFRXVwuykoPtqog6BxY5SOMlJSUBAPr06SNwJsK7evWqRhY5wsPD0bt3b7i4uKg81pUrVzBw4EAYGBioPBYRERG1zYoVK1BZWYn9+/c32f7bb79BV1cXMpmMRQ4iIiJqIioqCo6OjnjqqafUHlvRroorOYi0G4scpPFu3boFe3t7mJubC52KoBSzKDRxHkdYWJha5nEA94ocbFVFRESkmWxsbDB58mQcPnxYua28vByhoaFoaGhAaWkpbG1tBcyQiIiINI1Q8ziAeys5DA0NoaenJ0h8IuoYLHKQxktKSmJrIgDJycmora3VuCKHTCbD+fPn1TKPA7i3moVFDiIiIs313HPPITQ0VNn+4ezZs2hoaAAA1NfXw8bGRsj0NIaOjk6LXy3d7+joiMLCwsc+DhERkbaorq7G2bNnMWHCBEHiV1VVsVUVUSfAIgdpPBY57klKSoKuri769u0rdCpNREdHo66uTi3zOHJzc1FQUMAiBxERkQbz9vZGTU0Nrl+/DgA4c+YMHBwcoKt770+PHj16CJmexpDL5ZDL5Y91Ozs7G/Pnz1cWi1o7zoPHIBx1Q8oAACAASURBVCIi0nTnzp1DZWWl2rpDPKiqqoqtqog6ARY5SOOlpKRo3Il9IaSkpMDJyUnj3nzPnj2L3r17q6W/9pUrVwBA41azEBER0V969+4NMzMz5fv2mTNn4OTkBEtLS5iYmMDCwkLgDLVPz549cfr0aaxevVroVIiIiDpUaGgo+vXrJ8g8DuDeShKu5CDSfixykEarqqpCXl4eXF1dhU5FcCkpKRo5fD06Ohre3t5qiXXlyhU4Ojqie/fuaolHREREbaerq4tevXohMzMTMpkMly5dgkgkgpmZGVxcXNhOqR0OHDgAfX19bNq0CcHBwUKnQ0RE1GFOnTqFiRMnChaf7aqIOgcWOUijZWRkQC6Xo1evXkKnIjhNLHI0NDQgPj5erUUOtqoiIiLSfDY2NigsLFS2tZTL5dDX1+dnunYaO3YsNm7cCLlcjgULFiAjI0PolIiIiJ5YcXExLl++jEmTJgmWA4scRJ0Dixyk0RR/wAm1bFGTaGKR48qVK5BKpfDy8lJbPBY5iIiINJ+lpSUkEgni4+PRq1cv5OXloaGhgZ/pnsD777+P559/HhKJBHPmzEF1dbXQKRERET2RsLAw6OrqqmXGZ2uqq6s1ri04EbUdixyk0TIyMmBtbQ1zc3OhUxFURUUF8vLyNK7Ice7cOVhaWmLgwIEqj1VbW4vk5GQMHTpU5bGIiIioY1y+fBkjRozAnTt3IJPJ4OLiInRKWm337t14+umncfnyZbz11ltCp0NERPRETp06BTc3N0HndbHIQdQ5sMhBGi0jI4NtDXBvFYdcLte4Ikd0dDTGjBkDXV3Vv5QkJyejvr5eLQUVIiIiejJyuRw6Ojq4cuUK+vXrh7KyMkgkEq7keEIWFhYICgqCiYkJdu7cid27dwudEhERUbuFhoYK2qoKAGpqamBkZCRoDkT05FjkII3GIsc9qamp0NPT07jn4ty5c2qbx5GYmAg9PT2NK/QQERFRc1KpFEZGRkhPT4etrS2Ae7O8nJ2dBc5M+w0dOhTff/89AGD58uVISEgQOCMiIqK2S0tLQ0ZGhqBDxwGu5CDqLFjkII12+/ZtXvEHIDMzE/b29jA0NBQ6FaWsrCzcvXsXY8aMUUu8xMREuLq68sMHERGRFigtLVUOHDczM1Nud3R0FDCrzmPRokUIDAxEVVUV5s6dC4lEInRKREREbXLq1CmIRCJ4enoKmgdXchB1DixykEa7e/cur/gDkJOTA3t7e6HTaCI+Ph66urpwc3NTS7zExEQMGDBALbGIiIjoyRQUFKCyshKWlpaoqKiAubk59PT0YGdnJ3Rqnca2bdswatQopKWlYdGiRUKnQ1pMR0dH+aWK/YmIWhIaGopx48bBwMBA0Dy4koOoc2CRgzRWTU0NiouL4eDgIHQqgsvOzta45+HixYvo168fRCKRWuKxyEFERKQdqqurkZ2djYqKCgwfPhx37tyBhYUF7OzsoK+vL3R6nYaRkREOHToEsViMI0eOCJ0OaTG5XK7S/YmIHtTQ0IDw8HDBW1UBXMlB1FmwyEEaKycnB3K5XONO7gshOztb41ZyXLx4EaNGjVJLrMbGRiQnJ7PIQUREpAXS0tLQ2NiIoqIiDB48GNnZ2TA0NGSrKhV46qmnsHfvXl5RT0REWuXixYsoKSkRfOg4wJUcRJ0FixyksbKzswGARQ5oZruqS5cuqa3IkZGRgaqqKhY5iIiItEBqaip0dHSQlZWFPn36IDc3FwDncTzowXY/D7v9sNZA06dPxyeffKLaZImIiDrQqVOnYG9vrxF/43MlB1HnwCIHaazs7Gzo6enB1tZW6FQEl5ubq1HFnszMTBQWFqqtyJGYmAgdHR3069dPLfGIiIio/VJTU9GzZ08UFhaib9++yM3NRW1tLYscD5DL5S1+Pez+1qxfv54thIiISGuEhoZi0qRJGrESkSs5iDoHFjlIY+Xk5MDW1rbL924uLi5GVVWVRhU5Ll68CF1dXQwfPlwt8W7evAkHBwdYWFioJR4RERG1X1JSknIFqqLIIZPJNOqzDNGDqqursXnzZowYMQKmpqYwNjZG//79sWzZMsTGxjbZNy8vD0uXLoWjo6OyFduyZcuQn5/fZL/7B3SnpaVh9uzZEIvFzVbmFBQU4I033lAez8HBAYGBgcjLy2uW540bNzB9+nSYmZnB3NwcU6ZMwc2bNztsGPidO3fw/PPPw8LCAmZmZpgxYwYSExOfaP/HfR6IqGuoqKhATEwMJkyYIHQqALiSg6izYJGDNJYmDtsWQk5ODgBoVLsqDh0nIiKi1ly6dAk2NjYwNDSEtbU1pFIpysvL4eTkJHRqRC2SSqXw9fXFxo0bsXz5cqSnp6OoqAg7duxAZGQkxowZo9w3Ly8P7u7uCA4Oxp49e1BcXIxffvkFf/zxBzw8PJoUOu5fXfPGG2/gvffeQ05ODv7880/l9vz8fLi7u+Pw4cPYtWsXSkpKsH//fpw8eRJeXl6QSCTKfdPS0uDj44MrV67gyJEjyMnJwerVqxEYGNhizPYIDAzEu+++i6ysLPzxxx+4dOkSvL29cfv27Xbv/zjPAxF1HadPn0ZdXR0mT54sdCoA7hW5WeQg0n4scpDGysvLQ8+ePYVOQ3CFhYUAgB49egicyV/UOXQcYJGDiIhIW9TX1+PGjRswNjZG7969UVBQAABoaGhguyrSWGvXrsWFCxewfv16BAQEwNbWFmZmZhg/fjz27dvXZN/Vq1fj7t27+Pzzz+Hn5weRSIQJEyZg8+bNyMzMxJo1a1qM8fHHH8PLywsmJiaYNm2a8sT/mjVrkJmZiY0bN2Ly5MkwMzODr68vvv76a2RkZODLL79skqdEIlHGNjMzg7e3Nz7++OMOey6WLVuGsWPHNnlcpaWlWLt2bYfs39rzQERdR3BwMNzd3TWmNXlNTQ3bVRF1AixykMYqKCjQmDc9IZWUlEBHRweWlpZCp6J09epVtbWqAoBbt26xyEFERKQFEhMTUV1djerqamWrKgUWOUhTHTp0CADw3HPPNbtvxIgRTU7EBwcHAwD8/Pya7Ddx4sQm9z/I3d29xe1Hjx4FAEybNq3J9rFjxza5H7g3qLel2F5eXi0euz18fX2b3FY8rpMnT3bI/q09D0TUNcjlcvz555+YMWOG0KkosV0VUefAIgdprIKCAo1avSAUiUQCkUgEPT09oVMBcC+f3NxcDBw4UC3x8vPzUVZWhr59+6olHhEREbVfQkICjIyMUFBQgD59+iA3Nxe6urrQ1dWFnZ2d0OkRtUhRjHucVeSKVdbdu3dvsl1xW7F66UHdunVrcbtif3t7+yazKxTHS0tLU+5bVFTUYuyOvBjK2tq6yW1FLMXjftL9W3seiKhruHTpErKzszWqyFFZWQkTExOh0yCiJ8QiB2mswsJC2NjYCJ2G4EpLSyEWi4VOQ+nGjRsAoLYiR3p6OgCgd+/eaolHRERE7ZeQkIDBgwcjMzMTvXr1Qm5uLszMzJQzOog0kWL1+P0rj1qjuAhLUXBQUNxu60VaitglJSWQy+XNvioqKpT7KgoIrcXuCGVlZS0eu7W/y9q6PxF1bSEhIbC3t1drZ4iHqa+vR319PQuwRJ0AixykkeRyOYqKivjhGPdWTmhSq6rExESYmprC2dlZLfHS0tJgYGDAFhdERERa4NKlSxgyZAiKi4vh7OyM3NxcdOvWjXPWSKPNmTMHAPD77783uy82NhYeHh7K2/7+/gDuDc69X2hoaJP7H5eiRVZERESz+6KiopoMPVcM6X0w9rlz59oU82FiYmKa3FY8rtYGBLd1fyLq2kJCQuDv7w8dHR2hUwEAVFVVAQBXchB1AixykEYqKytDbW0t21VBM4scAwYMUNuHkvT0dDz11FMa066LiIiIWiaXy3HlyhU4OTkBgLLIYWBgwCIHabS1a9di8ODBWL16NX766Sfk5+dDJpPhxIkTWLhwITZu3Kjcd926dXBxccFHH32EsLAwSKVShIWFYdWqVXBxcWl14PbDYvfp0wfLly/HoUOHUFxcDKlUiuDgYCxevBibN29usq+lpaUytkwmw9mzZ/HDDz901FOBTZs2ITo6GjKZTPm4xGJxq4+rrfvTkwsJCcGsWbPQs2dPGBoaomfPnvD392+xSHd/C7T7vx53v7Z8ET1KQUEBLly4oFGtqljkIOo89IVOgKglit60XMlxr12VJhU5bt68qbZWVQCQkZEBV1fXDjteUFAQDhw40GHHIyIi6mz09PSwceNG9OrVq02/l5GRgdLSUlhZWQEAXFxcHjrrYN68eTwxRh0uKyurzb9jaWmJmJgYfP7559iyZQveeustiEQijBo1Cjt37mwyXNvW1hZxcXFYs2YNFixYoJwj6O/vj3/84x/K9lMAmvz7Vvx8/xBz4F4Lqri4OGzYsAEffPABsrKyYGVlBXd3d+zbtw+enp7KfV1dXXH27Fm8//77mDlzJnR1dTFu3Dh8++236N27N3R123cN4/15fv/993j33XcRHR0NuVyOsWPHYsuWLXjqqac6ZP/Wngd6tLq6OixZsgTBwcFYt24dvv32W9ja2iI/Px9BQUFYtGgRJk6ciL179ypP2Cqe50c97/fv19LPCq0dh6/l9DiCg4NhaGgIPz8/oVNRqqysBMB5QUSdAYscpJHYy/UvEomkyR9LQktMTMS4cePUFi89PR2DBg3qsOMdOnQI0dHR8PLy6rBjdhWHDh2Ch4eH8gpd6hyysrIQExODuXPn8g9UIgIAHDhwALNmzWpzkSMhIQF6enrQ09ODubk5LCwskJubi7q6Oq7kII1nZmaG9evXY/369Y/c19bWFjt27MCOHTseut/jnsgXi8XYsmULtmzZ8sh9Bw0ahD///LPJtpycHADNB5I/rgfzPHHihEr3p/Z5++23cfDgQURHR2P06NHK7U5OTli5ciXGjBkDHx8fBAYG4tdffxUwU6KWhYSEwM/PD6ampkKnosSVHESdB4scpJGKi4sBANbW1gJnIjypVIqnn35a6DQAADKZDHfu3MGAAQPUFjM9PR3PPvtshx7Tw8MDBw8e7NBjdgV6enpYsWIF5s2bJ3Qq1IGCgoIwd+5c7N+/n23hiAgA2v1akJSUBGdnZ+Tn58POzg47d+5Ebm4uGhoaWixy8HWHVEHxvtZZ6ejoICUlpcnfB5GRkQCAZ555Rqi0SMXi4uLwww8/4PXXX29S4Lifh4cHFi5ciF27diEwMLDJCqT2aEtxioUsepTa2lqcOnWqSQs+TcAiB1HnwZkcpJFKS0thYmICY2NjoVMRXG1tLQwNDYVOAwCQnJwMuVyO/v37qyVedXU1cnJy0Lt3b7XEIyIiovZLT09H7969ceHCBaSnpyMgIAClpaWQyWRcyUHUgZYvX4709HRUVFTg9OnT+PDDD2Fubs45GJ2YYtXQowp4L7zwAgDgp59+UnlORG0REREBqVSK6dOnC51KE4oiB9tVEWk/FjlII2nasG0haVKR4/bt29DR0YGLi4ta4mVkZKCxsbFDZ3IQERGRaqSlpaG+vh4nT55EfX099PX1IZfLW13JQURtFxoaCjMzM3h5ecHS0hLz58+Hp6cn4uLimlyIxGHRnUtUVBQAYMiQIQ/db+jQoQCAc+fOqTwnorYICQnBkCFDmszr0QRcyUHUebBdFWkkTRu2LaS6ujoYGBgInQYAIDMzEz179lTbCpv09HQAaHNPcCIiIlIvuVyOS5cuoaysTLmtvr5e+TOLHEQdY8KECZgwYcIj92P7oM5FMXflUe2cFffn5uaqPCeitvjzzz+VK400iWLwOIscRNqPKzlII5WVlUEsFgudhkbQtCKHulZxAPeKHN27d4eFhYXaYhIREVHbVFdX46WXXoJUKm11HxY5iIhUT7E6h6t0SJMkJiYiNTUVM2bMEDqVZqqqqqCrqwsjIyOhUyGiJ8QiB2kktqv6iya1q7pz545aixwZGRlsVdUFsGUCEZH2ys3NhZeXFw4dOoTGxsYW99HT0+Pnug60f/9+eHh4QCwWP/Q9lO+vRJ2HnZ0dAKCkpOSh+xUVFQEA7O3tm2zX1b136qehoaHV321oaFDuR9SRgoODYWVlBU9PT6FTaaaqqoqrOIg6Cb6DkUZiu6q/dOWVHHfv3oWzs7Pa4pEwHtZOwdfXF76+vmrM5uE0LR8iIiHdunULI0eOxPXr15u0pnpQQ0MDCgoK1JiZ+qj7fWHPnj2YP38+rK2tkZCQgOrqagQFBbW4L9sVEXUeiteZq1evPnQ/xf1jx45tsl0kEgFAk5aCDyotLYW5ufmTpEnUopCQEEybNg16enpCp9JMRUUFTE1NhU6DiDoAixykkbiS4y+atJIjMzNTrUWH3Nxc5VVL1DU1Nja2emWwKjzqild150NEpMmSk5OVVw0/jI6ODvbt26eGjNRP3e8LX331FQBgy5YtcHFxgZGREWbPns2CBlEnt2zZMgBotaip8J///KfJ/gr9+vUDAFy/fr3V371+/Tr69u37JGkSNZOfn4+zZ8/i+eefFzqVFkkkErbHJuokWOQgjSSTyZRXm3R19fX10NfXFzoNVFRUoLi4WK0rOXJzc9nDu4s7d+4czp07J3QaSpqWDxGRkGbOnImbN2/Cz88PAFptcyKXy7Fjxw51pqY26n5fSE5OBgA8/fTTaotJRMLz9PTE0qVLsXv3bly4cKHFfeLi4rBnzx4sXboUbm5uTe7z9/cHAOzevbvVGDt37tTImQmk3Q4fPgwjIyNMnTpV6FRaVFZWxiIHUSfBIgdppMrKSnTr1k3oNDSCnp7eQ3unqsudO3cAQK0rOfLy8riSg4iISIP16dMHx48fx5EjR+Dg4NBqoSM5ORnnz59Xc3adT1VVFQBoTCtTIlKf7du344UXXsCkSZOwbds2ZGVloa6uDllZWdi6dSumTJmCF198Edu3b2/2uytWrMDAgQPxr3/9C8uXL8f169dRU1ODmpoaXLt2DW+88QbOnz+PlStXCvDIqDMLCgrCjBkzNLYlFIscRJ0HixykkVjk+IuBgQHq6uqETgP5+fkAoLaVFeXl5aisrGSRQ4uVlZXh3XffhaurK4yNjWFtbQ0vLy+89957iI+Pf+TvP2xganV1NTZv3owRI0bA1NQUxsbG6N+/P5YtW4bY2Ngm+xYUFOCNN96Ao6MjDA0N4eDggMDAQOTl5TWL92DsgICAR+Zz//acnBzMmTMHIpEI1tbWWLRoEcrKynD79m3MnDkT5ubm6NmzJxYvXgyJRNLscbUlV8VXWloaZs+e3WQALRGRuvn7+yM1NRXPPPMMdHV1m7XaNDQ0xK5duwTKTjUe533h7t27mDVrFkQiEWxtbfHKK6+guLi43fFaitGeAeOP+35DRJrDwMAA+/btw969exEaGopRo0bB1NQUI0eOxKlTp7B3717s3bu3xSKoSCRCTEwM1q1bh/j4eHh7e8PU1BQ2NjZYtGgRbGxsEBcX1+pMjgdfY/iZkx5HcXExIiIiMGfOHKFTaRWLHESdh/A9cIhaUFlZCRMTE6HT0AiaUuQoKSmBjo4OxGKxWuLl5uYCUF9RhTreokWL8Mcff+Cbb75BQEAADAwMkJGRgVWrVsHDw+OR/cPlcnmLfzxJpVL4+fkhKSkJX331Ffz9/WFqaooLFy7gzTffxA8//KA8dn5+Pjw8PFBdXY09e/bAy8sLly9fxoIFCxAaGopLly4p5//cH6+l3FrL5/7tH374ITZs2IBdu3bhk08+wXfffYfi4mIYGhri888/h729PVatWoXvv/8ehoaG+PHHH5XHaW+ub7zxBtauXYt9+/YhIiIC06dPf+R/GyIiVTA0NISjoyPGjx8POzu7JnM4amtr8euvv2LLli0CZtixHud9YdWqVdi8eXOT138DA4OHtox5nHgPvk+15WRjW95viEjzzJgxo11tpczNzbF69WqsXr26zb/LuT/UHr///jv09fU1+u+TsrIyXlhJ1ElwJQdpJK7k+IsmFTlEIpHa2iMoriTkBw7tFR4eDgBwcHCAqakpDA0N0a9fP3z77bdPdNy1a9fiwoULWL9+PQICAmBrawszMzOMHz++2WDbNWvWIDMzExs3bsTkyZNhZmYGX19ffP3118jIyMCXX375RLk8KCAgAAMGDICFhQU+/vhjAEBISAhWrFjRbPuff/7ZIbl+/PHH8PLygomJCaZNm8Y/QolIUPn5+XBxccHevXtha2sLHR0dZQuriooKHD58WOAM1ev1119Xvv5/8MEHAICTJ08KmpO63xuJiKhrCgoKwtSpUzV63ipXchB1HixykEaqqqpikeP/MzQ0RG1trdBpoLi4GNbW1mqLl5ubCz09PXTv3l1tMVXlUS0l7t/m6OiIwsLCxz6OJlMsS37hhRfg7OyMgIAAHDx4EN27d3+iE/GHDh0CADz33HPN7hsxYkSTYx89ehQAMG3atCb7jR07tsn9HWXkyJHKn+9fhXT/dnt7ewBATk5Ok99tb67u7u5PkDF1JiEhIZg1axZ69uwJQ0ND9OzZE/7+/vj999+b7fu4rW5a268tX9S1FBYWwsbGBsC91RtyuRwBAQEwMzMDAPz0009Cpqd2Lb3+K1arCkXd741ERNT1SCQSnD59WqNbVQEschB1JixykMaprq5GQ0MDixz/nyat5FBnkSMvLw89evSAnp6e2mKqilwub3Li/WG3s7OzMX/+/BaHzd+/34PH0ES7du1CUFAQ5syZA5lMhp07d+LFF19Enz59kJCQ0O7jtqWVWUFBAYB7J5buP+mqKJ6lpaW1O4+W3H+V0v3Dd1va/uB/v/bmytdKqqurwyuvvIKXX34Zfn5+OH/+PGQyGc6fP48JEyZg0aJFmDNnjnJgMfDo16WWtrf0c2vH0YbXKFKN+y+KkMlkAIBXX30V6enpWLJkCTIyMoRMT+3uf/1XzCkR+v8Ndb83EhFR13PkyBEAaFdrNXVikYOo82CRgzROZWUlAJ64U9CkIoeVlZXa4uXl5XXJVlU9e/bE6dOn29UrVxPNnj0bhw4dQlFRESIjIzFlyhTcuXMHS5YsafcxbW1tATzelbCKfUtKSpqdfJXL5aioqGh3Hh1Nm3IlzfL222/j4MGDCA0NxYoVK+Dk5ARDQ0M4OTlh5cqVOHnyJI4cOYLAwEChU6UuQHFRRG1trfLzi7W1NWxsbLBr1y5kZmYKnCHx/YaIiFQtKCgIkydPVttMz/ZikYOo82CRgzQOixxNaVKRQ93tqrri0PEDBw5AX18fmzZtQnBwsNDpPBEdHR1kZWUBuLd6wdfXFwcOHAAAJCYmtvu4iiXPLbXgiY2NhYeHh/K2oqVVREREs32joqIwZsyYJtsUrzt1dXWorKxUa7u0tuZKBABxcXH44YcfsHjxYowePbrFfTw8PLBw4ULs3bsXUVFRTxyzLVehC33FOqlXXV0dpFIprKysIJVKlds7Q+vJzoTvN0REpEpSqRQnT57U+FZVDQ0NqKioYJGDqJNgkYM0DoscTZmamirbPQippKRErVdhFBcXK3t6dyVjx47Fxo0bIZfLsWDBAq1v6xEQEIAbN26gpqYG+fn5+PzzzwEAU6ZMafcx165di8GDB2P16tX46aefkJ+fD5lMhhMnTmDhwoXYuHFjk3379OmD5cuX49ChQyguLoZUKkVwcDAWL16MzZs3Nzn20KFDAQDx8fE4evSoWk/0tDVXIgDYsWMHAGDu3LkP3e+FF14A0PXmIZB6KVYGWFtbKz+76Onp8eSBhuH7DRERqVJwcDAaGhowc+ZMoVN5qPLycsjlcn5OIeok9IVOgOhBLHI0JRaLIZFIhE4DMplMOTRUHaRSKVxdXdUWT5O8//77iImJweHDhzFnzhxER0fD2NhY6LTa7OzZs/jpp5/w7LPPIjs7G926dcNTTz2Fzz77DCtXrlTu9+AQdsWV361tt7S0RExMDD7//HNs2bIFb731FkQiEUaNGoWdO3fC19dX+Xvdu3dHXFwcNmzYgA8++ABZWVmwsrKCu7s79u3bB09PzyY5b9++HQEBAZg8eTKGDh2KX375pd15tnV7W3J98BgAr5jvqhQrM4YMGfLQ/RQFvHPnzqk8J+q6iouLAdxrT6VYyWFpadlpB9B31Ou/uuO19b1RW82bN6/T/tvrqmJjY1tdtUhEmiMoKAh+fn5qbXfdHiUlJQCg8S21iOjxsMhBGkfRB5hFjnssLS1x+/ZtodNAXV0dDAwM1BZP3UUVTbN7925cu3YNly9fxltvvYWff/5Z6JTazNvbG97e3o/cr7WTPA87+WNmZob169dj/fr1jzy+WCzGli1bsGXLlkfuO3r06FaHorc1z/Y8rsfNlQUNUsjJyQGAR7YTVNz/OLNsiNpLcbLAysoKd+7cUf7cWXXk67+647XlvZGIiOhxVVZW4vjx4/j666+FTuWRFJ+L7e3tBc6EiDoCixykcbiSoymxWNzqSVd1UneRQyqVwtTUVG3xNI2FhQWCgoLg6emJnTt3wtvb+4mGdRNR16a4mplXNZMqKVZyWFlZISUlBcCjC3BEqrJ//37o6ekJnQZ1oPnz56O2tlboNP4fe3ceF1XZ/4//NeyrgSC74oYGepdbqChYmnCb4gKaoiBkKBKZZYZFfl1uN6xQqbxdEUFIVNRbUcstCeWjmLmUkpq4BLLJvig4MNfvD34zMTAsM8zMmRnez8eDh3jmcF2vMwyH4bzPdV2EkFacOnUKNTU1mDJlCtdR2pSXlwctLa1OOU02IZqI1uQgKoeKHOLMzMxQWlrKdQwaycGB1157Ddu2bQMAhIWFqUSxixCiWmxtbQH8cwd9S4qKigA0v1NNS6vhrWB9fX2LX1tfXy/aj5DWFBcXw8TEBPr6+qirqwNAi44TQgghncnhw4fh4eEBKysrrqO0KS8vD926dYOODt3/TYgmoL9Yicp5/vw5AyuuXAAAIABJREFUtLS0oK+vz3UUlaAqa3K8fPmSihwcCAwMxIIFC/DixQtMnz5dJV4LhBDVIVyD5vfff291P+HjHh4eYttNTU0BAOXl5S1+bWlpKbp06dKRmKSTKC0tFU1PJSxy0EiO1vF4vHZ9EEIIIaquqqoKKSkpmDlzJtdR2iU/P190wxAhRP1RkYOonOfPn9MojkbMzMxQVlbG+Rz8yhzJwRhDdXU1FTn+f99++y2GDh2KrKwsBAYGch2HEKJCFi5cCKDhrrnWHDp0SGx/of79+wMAbt++3eLX3r59G/369etITNJJlJeX45VXXgHQ8L4BoCJHWxhj7foghBBCVN3hw4fB5/Mxffp0rqO0S15eHhU5CNEgVOQgKoeKHOLMzc1RX1+PyspKTnMos8jx/PlzCAQC0R3GnZ2+vj6Sk5Nhbm6O48ePcx2HEKJCRowYgZCQEMTGxuLatWsS98nIyEB8fDxCQkLwxhtviD3m7e0NAIiNjW2xj5iYGEycOFF+oYnGqqioEI36EY7kMDMz4zISIYQQQpQkMTEREydOVJsbHGgkByGahYocROW8fPmSpqpqxNzcHEDb860rmjKLHMKCDo3k+EfPnj2RkJBAU1YQQpr57rvvMGPGDIwfPx7ffvstcnJywOfzkZOTg+joaHh5eWHmzJn47rvvmn3t4sWL4eLigr179yIsLAy3b99GbW0tamtr8ccffyA0NBS//vorPv74Yw6OjKibiooK0UgOYZFD+H9CCCGEaK7c3Fz8/PPPmDNnDtdR2i0vLw82NjZcxyCEyAkVOYjKqa+vh7a2NtcxVIZwkdjc3FyOkyhPVVUVAM0pcjSdT7u1/7c29/Y777yDL7/8UrFhCSFqR1dXF4mJiUhISMC5c+cwdOhQGBsbY8iQITh79iwSEhKQkJAgsVBtamqKy5cvY/Xq1bh69SpGjRoFY2NjdOvWDYGBgejWrRsyMjJaXJOjrfMb6Vwaj+QQCAQAQOu5EEIIIZ3ADz/8ABMTE7zzzjtcR2k3mq6KEM2iw3UAQpqiIoc4Ozs7aGtrIycnh9MchoaGePHihVL6qq6uBgAYGxsrpT9Fa2subWnm2l6zZg3WrFnT0UiEEA00ceJEmaaV6tKlC1asWIEVK1ZI/bW0VgBprKKiAr169QIA0Xs5TfldTgghhJCWJSQkYObMmTA0NOQ6SrvU1dWhqKiIRnIQokFoJAdROVTkEKetrQ1ra2s8ffqU0xxGRkZ4/vy5UvoS3v2ppUWnKEIIIURdNB7JISyA0RSkhBBCiGbLzMzErVu31GqqqoKCAggEAhrJQYgGoZEcROVQkaM5BwcHlShyKGskB1FNjDH4+fnBz8+P6yiEEEJUUEVFBUxNTQE0vJ8D0Op6Xjo69KcIIYQQou7i4+PRo0cPjB49muso7Zafnw8ANJKDEA1Cf1kQlUNFjuYcHBw4n65KmSM5iGri8Xj46KOPMGrUKK6jEDnKyMhAVFQU1zEIIRpA0pocurq6qK+vx48//oi9e/eKFcqTkpJo1CaRO/q9RgghyiMQCPDDDz8gICBArX6nP3r0CFpaWnBwcOA6CiFETqjIQVQOFTmas7e3x40bNzjNQCM5CACMGDECM2bM4DoGkSN1+mOEEKLaGhc5+Hw+ACAuLg5z5sxBYWEheDwebG1t8eabbwIApk+fTu/5iNzR7zVCCFGe1NRUZGdnY/bs2VxHkUpWVha6d+9O02oSokHoHSBROQKBgP7gbcLe3r5TjeQQ/nFKC9oSQggh6kEgEKCqqgqGhoY4dOgQNm7cCKBhtEZhYSGAhnXGamtruYxJCCGEEDlKTEzE0KFDMWDAAK6jSCUrKwt9+vThOgYhRI5oJAdROfX19XQHVhPCNTkEAgFnz40yixwGBgYAgJqaGqX0RwghhJCOefjwIRhjeP/998UKGXV1daLPBQIBjQolhBBCNERNTQ2OHDmCFStWcB1Fag8ePICTkxPXMQghckRXkonKoemqmnN0dASfz0dubi5nGYyNjVFZWamUvoyMjACA1gAhhBBC1MT58+cBAC9evIBAIBCtydEYFTkIIYQQzXHs2DFUVlaKrbelLmgkByGah4ocROVQkaO5fv36AQDu37/PWQYbGxvk5+crpS9DQ0MAoAshhBBCiJp45513AKDN93B0AwMh7VdTU4Ply5ejT58+0NHRAY/HA4/Ha/fXC/eX5msIIaS9EhIS8Pbbb8PGxobrKFJ58eIFcnJyqMhBiIahIgdROVTkaM7KygpmZmacFjlsbW2VNpKERnIQRaILBoQQIn/CGxMGDRoEXV3dFvej3+2aJykpCcOHD4e5uXmrvyPp96f0Vq5ciXXr1mHevHmoqKjA6dOnpfp6Wt+OEKIoBQUFOH36NPz9/bmOIrW7d+9CIBDAxcWF6yiEEDmiIgdROVTkkKxfv364d+8eZ/3b2dnh2bNn4PP5Cu/L0NAQenp6KC8vV3hfpPOhCwaEECJ/wuLF9u3b4eDg0OIaYh0pcri7u8Pd3V3mr+8slPk8xcfHw8/PDxYWFrh58yZqampw+PBhifvS70/pHThwAAAQGhoKIyMjeHp60vNICFEJsbGxMDIygo+PD9dRpHbnzh3o6uqib9++XEchhMgRFTmIyqEih2T9+/fnvMghEAhQUFCg8L54PB4sLCzw7NkzhfdFOh+6YEAIIfInHMlhY2ODc+fOQVdXV+Id+x2ZirKltT40iTxGOijzedq0aRMAICoqCo6OjtDX14ePjw/9XpWT7OxsAEDXrl05TkIIIf9gjGHPnj2YO3euaBYGdZKZmYn+/fu3OvKUEKJ+dLgOQEhTVOSQrH///khPT+esf1tbWwBAXl4eHBwcFN6fpaUlioqKFN4P6XzoggEhhMifsHhhaGgIBwcHjB8/HidPnmy2X01Njcx9cPk+SJ0o83kSTqVKd8MqhqYX9Qgh6un8+fP466+/cPDgQa6jyOTOnTsYMGAA1zEIIXJGIzmIyqEih2T9+/fH48ePO3RxoCPs7OzA4/GUti4HFTmIotAFA0IIkb/GRQ4AMDc3x+uvv97ifkQzCL+fdDes/DUe0SMc4fP5558DAMrLy/HJJ5+gd+/eMDAwgIWFBdzc3LB06VJcvXqVq8iEkE5i165dcHNzw6BBg7iOIhMqchCimajIQVQOFTkk69evHwQCAR4+fMhJ//r6+jA3N0deXp5S+rO2tlZaX6TzoAsGhBCiGMKL3QYGBgCA2tpa9OnTB19++aXY+hy1tbUytd/SotWNt2dnZ2PKlCkwNTWFtbU1/P39UVxc3OH+cnNz4evrC1NTU1hYWCAwMBDl5eV4/PgxJk+ejC5dusDGxgZBQUEoKytr1ta5c+cwefJkmJubw8DAAEOGDEFSUpLEPpv2HxwcLDFTVlYWfHx8xBb7bul5aryt8fbIyMgOLQbeWh/StllYWIjQ0FA4ODhAT08P9vb2WLBgAfLz86XOpSkaT/nFGANjDJGRkQCAwMBAbNmyBYsXL0ZxcTHy8vIQGxuLhw8fYvjw4VxFJoR0AkVFRTh27Bjmz5/PdRSZVFRU4NGjR/jXv/7FdRRCiJxRkYOoHCpySObk5AQtLS3cvXuXswx2dnZ4+vSpUvrq1asXHj16pJS+SOdBFwwIIUQxXrx4AX19fVFBo7a2Fvr6+lizZg3effdd6OjoiLbLoqU1Hhpv/+KLLxAZGYmcnBz4+voiMTERS5cu7XB/y5Ytw9q1a5GTkwM/Pz/Ex8djzpw5WLJkCTZu3Ijs7Gz4+PggLi4O4eHhzdoaP348tLW18ddff+H+/fuwtLSEn58fTp8+3WKfwt9Ru3fvlvh4aGgoli5ditzcXJw6dUriPo237dy5E0DDTSvCwv3UqVNhZWWFtLQ0mdbQkJRX+CGNgoICuLq64ujRo9izZw9KSkqQlJSEM2fOwM3NTWLhqLO7cOECAMDe3h7GxsbQ09ND//798f3333OcjBCi6fbs2QMDAwO8++67XEeRyW+//QaBQIBhw4ZxHYUQIme0JgdROQKBQOyOP9LA0NAQvXv3xh9//AEfHx9OMvTt21c097Ki9e7dW2GjVp4+fYpDhw4ppG2ivppeMAAgumBw9OhRLqMpRXJyMp17CSEye/nyJfT09ET/r62tRdeuXcHj8bBnzx48ePAA165dk7nI0R7z58+Hs7MzACA8PBzbtm3DmTNnOtxucHCwqN2IiAhs3boVJ0+eRGpqqtj2bdu2iRUcGtu8eTMsLS0BAN9++y2cnZ2xbt06eHl5yZQpIiICbm5uAIAJEya0WViYP38+bty4gW3btsHHxwdnzpzBlClT8NVXX8Hd3V2mDPKycuVKPHnyBDExMfD09AQAuLu7Y/PmzfDx8cHXX3+NdevWcZpR1fj6+iI2NhYzZsxA9+7d4enpCU9PT0ydOlXjF32n9/FElWRkZHAdQakYY4iJiUFAQIBaLjgOANeuXYO1tbVS1hklhCgXFTmISpJlyHxnMHjwYNy4cYOz/gcMGIBjx44ppa/evXujqqoKhYWFsLKykmvbV69eVds7T7ik6T+XnfmCAQDMmjWL6wiEEBUhy/mez+eLRmsA/4zkABpu1Dh58iSGDBmC3NxchZ1ThwwZIvrczs4OAOQy9WXjdm1sbFrtT9LaZU2P18nJCQCQmZkpcyZXV1epvyY6Ohp37txBWloaBg0ahKVLlyIwMFDmDPKSkpICoKFY05iHh4focSpyiNuzZw8mTZqEH374AT///DNiYmIQExODHj164NixY2o7T3570Pt4Qrhz4cIF3L9/HwcOHOA6isyuXbuGN954g+sYhBAFoFs2CVEjgwcPxvXr1znr38XFBffu3QOfz1d4X/369QMA3Lt3T+5tT5s2rdm0CvTR9oemFzn27NmDw4cPw9fXF1VVVYiJicHMmTPh5OSEmzdvch1P4erq6jh/jdEHfdCHanzIcr6vq6sTW3y6rq5OrOhhZWWFs2fPYsmSJQr7fWJqair6XDiqhLGOF1Qat9t4xJuk7U37KysrQ0REBJydnWFqagoejyd6XmRdLwSATHfQ6urq4uDBgzA0NER9fT0CAgJk7l+eCgsLATQUihqv5yEc+ZKVlcVlPJXl4+OD5ORkFBUVIS0tDV5eXvj777/x3nvvcR1Noeh9PH2o0kdycjLXPxJKtWvXLowYMUKtC6nXrl2jqaoI0VBU5CBEjQwZMgTZ2dl49uwZJ/27uLiAz+fjwYMHCu/LwcEB3bp147SoQzqfznrBgBBCOqppUYMx1mwKPGdnZ3zzzTfKjsapd999Fxs2bMDMmTPx5MkT0YUxrmzZsgXa2toQCASYPn06qqurOcsiZG1tDQAoKSmReBFRFTKqGh6Ph5ycHAANBTZ3d3fRndV//vknl9EIIRqquLgYR48exYIFC7iOIrOSkhI8evQIQ4cO5ToKIUQBqMhBiBoZPHgwAHB2V/mrr74KbW3tDk2vIA2up+cinQtdMCCEENk1LXIIBAKNHwHYHunp6QCATz/9FF27dgXQ+uLrwhEafD4fz58/F41mkIe4uDgkJycjMzMTAwYMQGZmJkJCQuTWvqymTp0KAEhNTW322MWLFzFy5EglJ1IPwcHBuHPnDmpra1FQUICNGzcCgMzrvBBCSGtiY2PVesFxoOF3CgD6vUKIhqIiByFqxMrKCvb29pyNbjAwMEDv3r1x584dpfQ3ZMgQ/Pbbb0rpixCALhgQQoisJI3koCIHRIt6b9iwAWVlZSgpKUFERESL+7/22msAGtYdSElJkduFmLS0NISHhyMlJQXdu3fHoUOHYGxsjMTERGzbtk0ufchq1apVcHJyQlhYGJKTk1FcXIzKykqcOHECQUFBiIyM5DQfVxr//Ain8BK6dOkSbGxsMGnSJJiamqJ///44deoU1q1bh/3797fYBiGEyGrPnj3w9/eHsbEx11FkdvHiRQwcOBAWFhZcRyGEKAAVOQhRM0OGDOF0dIOLi4vSRnKMGDECmZmZKCoqUkp/RPPRBQNCCFEMRRc5Wjr3Svu5svuLj49HQEAAYmJiYG1tjTFjxmD48OEtZvvuu+/w+uuvw9PTE1u2bEFUVFSLfUg6Lkk5eDwexowZg8LCQixfvhw3b96Ei4uLaBqoDz74gNPnyNLSEhkZGfDz80N4eDhsbW3h5OSEnTt3IjExEWPGjJE6myaQNHWX0KhRo7B37148evQIL1++RFlZGW7evImIiAix9Vpa+npCCJFGamoq/vzzT7z//vtcR+mQtLQ0eHh4cB2DEKIgOm3vQghRJYMHD0ZSUhJn/Q8YMADHjx9XSl9jx46FtrY2zp8/j5kzZyqlT6LZWvsDf9SoURg1alSH2iCEkM6q6cLj8i5ytHTulXa7svuzsrJCfHx8s+0tTfcxbNiwFqclbc8xSdqnvdukJc/vibm5OaKiosSKOoQQQlTD9u3bMXz4cNH02eqoqqoKN27cwKeffsp1FEKIgtBIDkLUzODBg/HgwQNUVlZy0v+gQYNw9+5dVFVVKbwvU1NTuLq64uzZswrvixBCCCGyazqSgxBCCCHqLycnB0eOHMHixYu5jtIh6enpqKurE00jSQjRPFTkIETNvPHGGxAIBMjIyOCkf3d3d9TV1Smtfy8vL5w6dQr19fVK6Y8QQggh0qurq4O2trbo/7q6uqirq+MwESGEEEI6Kjo6GlZWVpg+fTrXUTrkwoUL6NevH+zs7LiOQghRECpyEKJm7O3t0atXL1y6dImT/m1sbNC7d2+l9e/n54f8/HycO3dOKf0RQgghRHpNp6fS09NDbW0th4maE65j0dZHZ0bPESGEEKGqqirs3r0bixYtEpuSUh2dOnUKEyZM4DoGIUSBqMhBiBoaPXo00tPTO0X/ffv2xYgRIyTOZ00IIYQQ1aClpSW25oK+vj5evnzJYaLmJC3k3Nrizp0RPUeEEEKEYmNj8fLlSwQHB3MdpUNycnJw+/ZtKnIQouGoyEGIGho9ejQuX74MPp/PSf+jRo3C5cuXlTYNRVBQEI4ePYpnz54ppT9CCCGESEdLSwsCgUD0fz09PZUrchBCCCGkfQQCAb799lsEBQXBwsKC6zgd8uOPP8LAwAAeHh5cRyGEKBAVOQhRQ+7u7qiursbNmzc56X/06NGoqqrCrVu3lNKfv78/TE1NsXnzZqX0RwghhBDp8Hi8ZkUOVZuuihBCCCHtc/z4cWRlZWHRokVcR+mwH3/8EePGjYOhoSHXUQghCkRFDkLU0Kuvvopu3bpxti6Hs7OzUvs3MjLCkiVL8N133zUbzUF3iRJCCCHcazpdlYGBAWpqajhMRAghhBBZbd68GRMnTsSrr77KdZQOefnyJc6fP09TVRHSCVCRgxA1xOPx4ObmxlmRg8fjYeTIkUrtPywsDIaGhli5cqXY9uHDh2Ps2LEoLS1VWhZCCCGEiGs6XVWXLl1QXl7OYSJCCCGEyOL69etIS0vDJ598wnWUDjt79iwqKyvh7e3NdRRCiILpcB2AECKb0aNH46uvvgJjDDwej5P+v/nmGwgEAmhpKb5eamJigi1btsDf3x++vr4YN24cfvvtN9y8eRPa2toYNmwYfvrpJzg5OSk8i7IkJSVh8+bNuH//PsrKykTbmy742fj7r+jFQK9cuQJtbW2F9kGUKyMjQ2FtK/O1SYiyyev1rYrnelk0na7K3Ny8zRsQkpOTlfIegnQuivy9RgghncHmzZsxcOBAvPXWW1xH6bBDhw5hxIgR6N69O9dRCCEKRkUOQtTU6NGj8dlnn+Gvv/5Cv379lN7/O++8g/DwcGRkZGDkyJFK6XP27NlISkrCwoULkZGRgT179kBXVxd8Ph9///03hg0bhqNHj2Ls2LFy79vd3R0AcPHiRbm3LUl8fDwCAwMxYcIE3Lx5EzY2Njh58iR8fX2b7ausQhdjDNHR0YiOjlZ4X0QztPbaVPbPlLyoa24if/I496riuV5WPB5PrPhibm4uVrQBgOrqahgYGIj+P2vWLKXlI4QQQkjbcnNzcfDgQezYsUOl33e0B5/PR0pKCpYvX851FEKIEtCtU4SoqaFDh8LExAQXLlzgpP8BAwbAyckJx48fV2q/O3fuBJ/Px5QpU5CQkAA+nw8AqKurQ1VVFTw9PbF161a59ysQCMTuUFW0TZs2AQCioqLg6OgIfX19+Pj4cHr3Lo/Hw/79+8EYow8N+khOTubk9aTsn6n24vF4rf5Bp6q5SXNtfS9VgSqe62XVdLoq4UgOxhhSU1MxZ84cdO3aVXTMQMPvbq7PgfSheR9c/V4jhBBNsHXrVpiZmWnEjQhnz55FaWkpfHx8uI5CCFECKnIQoqZ0dXXx5ptv4syZM5xl8Pb2xrFjx5Tap42NDU6dOoUbN26gsrJS7DGBQID6+np8+OGH+Oijj1BfXy+3ftPT05Geni639tpy//59AEDfvn2V1ichyqTsnyl5UdfcRDVp0rleW1u72e/duro69OzZE2+99RaSk5NRX1+PwsJCjhISQgghpDUvXrzAzp07ERYWJjbyUl0dOnQIrq6ucHR05DoKIUQJqMhBiBrz9PTEuXPnRKMZlG3y5Mn4888/RRdplMXFxQWDBg1qdR7v//73v5gwYYLaLnr64sULAA3FLEIIIZpJk871enp6ePnyJc6dOwdfX1/Mnz8f9fX1+PvvvwEAL1++hJaWluiYCSGEEKJa9u7di6qqKoSEhHAdpcNqampw7NgxzJgxg+sohBAloSIHIWrMy8sLFRUVuHr1Kif9jx49GpaWlkhJSVFqv0+fPsXly5dbHalRX1+PCxcuYPjw4Xj8+HGH+hNOedJ02pPG27OzszFlyhSYmprC2toa/v7+KC4ulrk/SX20lKM1hYWFCA0NhYODA/T09GBvb48FCxYgPz9fpmyEAEB5eTk++eQT9O7dGwYGBrCwsICbmxuWLl3arvNRa6/lmpoaREZGYvDgwTA2NoaBgQFeffVVLFy4EFeuXBHbV96vb0k/e8HBwW3mbrw9NzcXvr6+MDU1hYWFBQIDA1FeXo7Hjx9j8uTJ6NKlC2xsbBAUFNRsvQJFHBMg3XOan5+PkJAQUf8ODg5YuHAhCgoKWjzmrKws+Pj4wNzcXOz5ac8+0h5ze4+lre+ltP3euXMH77zzDkxMTPDKK69g2rRpoov3stK0c/2TJ0/w9OlTjB8/HsePH0d9fT3q6urE9mGMUZGDEEIIUUF8Ph9fffUV5s2bB2tra67jdNjRo0dRWVmJ2bNncx2FEKIsjBAVM2vWLObj48N1DLXRq1cvtmLFCs76DwgIYB4eHkrtc/369UxHR4cBaPNDV1eXmZmZsV9++YUxJvvrS9heS9vnzJnDMjMzWVlZGQsNDWUAWFBQkMzH2FZ/7dmen5/PHB0dmbW1NTt9+jSrrKxkaWlpzNHRkfXq1YuVlpZKlUlLS4vt379fugMhKi85OZkBYHV1de3+milTpjAAbMuWLayqqorV1tayu3fvsmnTpjV7HUrzmq2oqGDDhg1jpqambNeuXSw/P59VVlayCxcuMGdnZ7H95f36bitve4/H399fdC4ICwtjANjEiRPZtGnTmp0j5s+fL9aGIo5Jmuc0Ly+Pde/endnZ2bHz58+ziooKdu7cOWZjY8McHR1Zfn6+xGMeP348S09PZ8+fP2enTp0Sa7OtfaQ5ZmmOpbXvlbT9PnjwgJmZmYmel8rKSvbLL78wLy+vNl8vbVHFcz1jsp3vly1b1ubvZB6Px/z8/GQ67xDSXvT60lz0dyJRNZp0vtm1axfT1dVljx494jqKXIwfP555e3tzHYMQ0gY5nkd3UpGDqBx68yqdBQsWsOHDh3PWf3JyMtPW1mbPnj1TSn8CgYD17NmzXQUO4YeWlhbT1dVliYmJCitypKamirY9evSIAWB2dnYyH6c8LnyFhIQwACwmJkZs+5EjRxgAFhERIVUmKnJoJlneVHTp0oUBYIcOHRLb/vTp0w4VOZYsWSIqnjR1/fp1sf3l/fpuK29bj0s6Fwifj6bbs7OzGQBmb28v1oYijkma53T+/PkMANu3b5/Yfnv37mUAWEhIiMRjvnDhQov9t7WPNMcszbE07ruj/fr7+0t8Xo4ePaoSRQ5FvG5kOd8nJCQwbW3tNn8nT5kyRaMuChHVQ68vzUV/JxJVoynnm7q6Oubk5MQWLFjAdRS5yM7OZtra2uzIkSNcRyGEtEGeRQ6arooQNefp6Ylr166hpKSEk/69vLygo6ODkydPKqW/6upqiVO8tEYgEIDP58Pf3x/Pnj1TSK4hQ4aIPrezswMA5OXlKaSv9hJOIzZhwgSx7R4eHmKPEyItX19fAMCMGTPQo0cPBAcH4+DBg7C0tARjTOZ2k5OTAQBTp05t9tjgwYPF2lbV13fjc4GNjY3E7cJzRG5urtjXKuKYpHlOT5w4AQAYO3as2H5vv/222ONNubq6tpmjpX2kOWZpjqUt0vR79uxZAM2fl9GjR7e7P0VS5M+CoaEhunbtChcXF0yfPh3ffPMNHj16JHFfAwMD1NfX47PPPmt1zayqqiqZ86iympoaLF++HH369IGOjo7UU44RQgghXNm3bx8eP36Mzz//nOsochEbGwszMzNMnDiR6yiEECWiIgcham7cuHHg8Xg4f/48J/2bmJjA09MTBw4cUFp/paWlYIyBz+ejpKQEJSUlyMnJQVZWFrKysnDt2jVcu3YN//d//4ezZ8/i7NmzOHLkCJKTk9G1a1eF5DI1NRV9rqenBwAdutgrD4WFhQAaLqg2nuPd0tISAJCVlcVlPKLG9uzZg8OHD8PX1xdVVVWIiYnBzJkz4eTkhJs3b8rcrrAw2Lg40BJVfX03Phc0vtAraXvTc4Qijkma51RYBBb2JyT8vzBfU0ZGRm223dI+0hyzNMfSFmn6LSoqAtDy88I1Rf4sxMTEIDIyEtOnTwdjDBs2bECfPn3NZepnAAAgAElEQVQwa9asZmuSGBgYAABWrlyJ6dOnQ0dHR2Kbz58/lzmPKlu5ciXWrVuHefPmoaKiAqdPn+Y6EiGEENKm+vp6REZGwt/fH7169eI6TocxxhAXF4e5c+eK/i4nhHQOkv/6IISoDTMzM7i6uuL06dOYMWMGJxnmzJkDf39/5Ofny+XiU3vp6OjA3NwcAET/tuXQoUOtLliuSaytrfH06VOUlJS0+/khpL18fHzg4+MDgUCA9PR0rFu3DqdPn8Z7772HGzduyNSmtbU1cnJykJeXh549e7a5r6a9vhVxTNI8p1ZWVsjNzUVRUZFotAnwz0V+KysruWRqmq+9xyzNscizX0tLSxQUFDR7XsrLyzuUQV4U+bPQdLFOPp+PlJQUfPnllxg2bBiOHz+OESNGAPinyFFbW4u9e/fi4cOHuHXrFvh8vlgbmlrkEN7sERoaCiMjI3h6enJ+s0Nn11Khjai3adOmcR2BEI2SlJSEBw8e4Pjx41xHkYuffvoJDx8+RHBwMNdRCCFKRu/8CNEAXl5e2LVrFxhjnEyNMGXKFBgbGyMpKQkff/yx0vsnkk2dOhVbt25Fampqsz8IL168iPDwcFy+fJmjdESd8Xg8ZGdnw8HBAVpaWnB3d8eBAwdgZmaGP//8U+Z2fX19ER0djf/973/NziVXrlzB4sWLkZGRAUBxr28jIyM8f/4cfD4ffD4fPXr0EF3kVzRFHJM0z6m3tzd27NiB8+fPIyAgQLTfuXPnRI/LmzTHLM2xAK1/L6Xp19PTE/v27Wv2vKjK+VOZ53pdXV34+PjAy8sLs2bNwuTJk3H9+nU4ODiIihw1NTXo2rUrfvzxRwwdOhS5ubmoq6sTtaGpRY7s7GwAUNiIUSK9pKSkVqdOI+onOjqapoEjRI4EAgEiIyMxe/Zs9OvXj+s4chEdHY23334bLi4uXEchhChbR1f1IETeaEE56QkXXP311185y/Dee++xoUOHctZ/eylq4fH2bldmf8+ePWNOTk7M1taWHTp0iBUVFbGKigqWkpLCevfuLbYQcnvQwuOaSZaFvgAwLy8vdvv2bVZTU8Py8/PZF198wQCwyZMnN9u3va/Z0tJSNnDgQGZqasp27tzJ8vPzWWVlJfvpp5+Yk5MTO3funGhfeb++hUaMGMEAsEuXLrGkpCQ2adIkmY9H2u2KOCZpntP8/Hzm6OjI7Ozs2Pnz51lFRQU7f/48s7W1ZY6Ojiw/P79dxybNPtIcszTHwljr30tp+s3KymJmZmai56WyspKlp6czDw8PjTzXM9a+831lZSVzcnJiAQEBjDHGfvvtNwaAZWVlifbJzMxkJiYmTEtLS5TdwcFBYxZqbayjrwUiP5r4+iIN6O9EomrU/Xxz4MABpqWlxW7fvs11FLm4d+8e09LSYidOnOA6CiGkneS58Di9Eycqh968yqZXr14sIiKCs/5//vlnBoDdunWLswztIcvrS3jhoukFDGm3c9FfSUkJW7JkCevVqxfT1dVl1tbWzNvbm12+fFnqXFTk0EyyvKm4dOkSCwwMZD179mS6urrslVdeYa+//jpbt24dq66uFu0ny2u2srKSLV++nPXv35/p6ekxCwsL5unpydLS0prlkOfrW+jXX39lr7/+OjMyMmIjRoxg9+7dk/l4uP6ZFZLmOc3Pz2chISHMzs6O6ejoMDs7O7ZgwYIWCxytnevas4+0xyzNsbT2vZS239u3b7MJEyYwY2NjZmJiwjw9PdmdO3c08lzPWPvP9wkJCUxHR4fl5+ez+/fvMwDsxo0bYvtcuHCB6ejoiHJbWlpyflGo8fP44MEDNm3aNGZmZtbsuS0oKGALFy5k9vb2TFdXl9nZ2bH58+ezvLy8FtsTfixbtqxD7cg7199//80mT57MTExMmJWVFZszZw4rKipq9ty8ePGCbdiwgQ0aNIgZGRkxfX191r9/fxYSEtLs9dTeHMrG9euLKA79nUhUjTqfbwQCAXvttdfYrFmzuI4iNx988AHr27cvq6+v5zoKIaSdqMhBNBq9eZXN4sWLmYuLC2f9CwQC5uTkxBYtWsRZhvag15fsqMihmdT5jzNCiGK093xfXV3NDA0N2Z49e1hhYSEDwC5cuNBsv507d4outpuYmKjEeUeYZ/z48Sw9PZ09f/6cnTp1SlRMEI5ssra2ZqdPn2aVlZUsLS2NOTo6sl69erHS0lKJ7TUlazvyzjVnzhyWmZnJysrKWGhoKAPAgoKCxPatqKhgw4YNY6ampmzXrl2i0VIXLlxgzs7OYscnbQ5lUoXXF1EMeh9PVI06n28OHz7MeDwe+/3337mOIhelpaXMxMSERUdHcx2FECIFeRY5aJJSQjTEtGnTkJmZiXv37nHSP4/HQ3BwMOLj4zV2vm1CCCGE/MPIyAiDBg3CjRs3YGZmBgAoKytrtt/8+fMRHh4OoGFhclUSEREBNzc3GBoaYsKECaLFwleuXIknT55g/fr18PT0hImJCdzd3bF582Y8evQIX3/9dbval7UdeeeaP38+nJ2d8corr4i+F2fOnBHbZ9WqVbh27RrWrFmD4OBgWFtbw8TEBG+++SYSExPlclyEENIRSUlJGD58OMzNzcHj8UQfTbX2GGmwYcMG+Pr64l//+hfXUeRi165d4PF4CAoK4joKIYQjVOQgREOMHj0a3bp1w//+9z/OMsybNw81NTU4dOgQZxkIIYQQojx9+/bFw4cPoaurC2NjY4lFDqDhYsrUqVMhEAhEF+xVgaurq8TtKSkpAIAJEyaIbffw8BB7vC2ytiPvXEOGDBF9bmdnBwDIy8sT2yc5ORlAw2L2TQ0ePFjs+yav54cQot7c3d3h7u6ulL7i4+Ph5+cHCwsL3Lx5EzU1NTh8+LDEfVXp94wqSklJwW+//YYvv/yS6yhyUVNTg82bNyM0NBRdunThOg4hhCNU5CBEQ2hra8Pb2xtHjx7lLIOlpSWmTJmCHTt2cJZBVTW+m6i1D0KIfGniz54mHpOm6Izfm1deeQUVFRUAADMzsxaLHFpaWti/fz/S0tJU6jkwMjKSuL2wsBBAQ0Gg8ffO0tISAJCVldWu9mVtR965TE1NRZ/r6ekBaH4RUFj0sLGxUdhxEaJp1Pm8Lo/sAoEAAoFATolat2nTJgBAVFQUHB0doa+vDx8fHypoSEkgEODLL7/EtGnTMGjQIK7jyMXOnTtRWlqKjz/+mOsohBAOUZGDEA0ydepUXL16FTk5OZxl+PDDD3H58mVkZGRwlkEVMcba9UEIkS9N/NnTxGPSFJ3xe1NfXw8dHR0ArRc5AMDAwABubm7KitYh1tbWAICSkhKJ38Pq6mqltqOo9iS13XSEh7JzEELUR3p6OtLT05XS1/379wE0jCAksktISEBmZibWrFnDdRS5qK2txddff42FCxfC1taW6ziEEA5RkYMQDSKcE5nLKQLc3d3xxhtv4Ntvv+UsAyGEEEKUo7y8XLQeh5mZGcrLyzlOJB/CKZtSU1ObPXbx4kWMHDlSqe0oqr3GfH19AUDi1KdXrlzB8OHDlZKDEEIkefHiBQBAV1eX4yTq6+XLl1i9ejXee+89uLi4cB1HLmJjY/Hs2TMsXbqU6yiEEI5RkYMQDaKvrw8vLy9Op6wCGkZzHDp0iNMRJYQQQghRvLKyMrzyyisAGqauam0khzpZtWoVnJycEBYWhuTkZBQXF6OyshInTpxAUFAQIiMjldqOotpr2vbAgQOxYsUK7Nq1CwUFBaiqqsLp06cxd+5crF+/Xik5CJG3/Px8hISEwMHBAXp6enBwcMDChQtRUFAgtl9L0wq2tr3pPsHBwVLna9x+bm4ufH19YWpqCgsLCwQGBqK8vByPHz/G5MmT0aVLF9jY2CAoKEji+fbcuXOYPHkyzM3NYWBggCFDhiApKUlin61lb5wpKysLPj4+Yot9t/S8tDQ9Y2RkZIembWytD2nbLCwsRGhoqOj1YG9vjwULFiA/P1/qXOrmv//9L3Jzc7FixQquo8gFn8/HV199hffffx/29vZcxyGEcIyKHIRomGnTpiE1NRXFxcWcZZg5cya6du2K7du3c5aBEEIIIYpXUlICc3NzAEDXrl1RVFTEcaK2SbpY1pSlpSUyMjLg5+eH8PBw2NrawsnJCTt37kRiYiLGjBnTrvbk1Y482mvrczMzM1y+fBmLFy9GVFQUevTogZ49e2LTpk2IiYnBuHHjZMpBCJfy8/Ph6uqKEydOID4+HsXFxYiLi8OxY8cwfPhwsUJHS9MJtme7cKq23bt3S52xcTvLli3D2rVrkZOTAz8/P8THx2POnDlYsmQJNm7ciOzsbPj4+CAuLg7h4eHN2ho/fjy0tbXx119/4f79+7C0tISfnx9Onz4tVfbGj4eGhmLp0qXIzc3FqVOnJO7TeNvOnTsBNNyAd/XqVQANo7+srKyQlpYm07SNkvLKMgVkQUEBXF1dcfToUezZswclJSVISkrCmTNn4ObmpjGFekmqqqqwYcMGfPTRR+jevTvXceRi9+7dePr0qcSfBUJIJ8QIUTGzZs1iPj4+XMdQW1VVVczY2Jht27aN0xz/+c9/mLm5OauoqOA0R1P0+pKdlpYW279/P9cxiJwlJyczAKyuro7rKIQQFSHN+d7CwoJ9//33jDHGwsPD2dChQ9v8GjrvEEWi15fmkuV9/Pz58xkAtm/fPrHte/fuZQBYSEiI2HYATNJlEmm3S0vYTmpqqmjb06dPJW7Pzs5mAJi9vb3Edh49eiT6/59//skAMHd3d6mzCx+/cOFCm/s0FRoaKsp4584d1rdvX7Z3794W22kPeXxvQkJCGAAWExMjtv3IkSMMAIuIiJAqkzqdb5YvX87MzMxYcXEx11HkorKyktnY2LCPP/6Y6yiEkA6Q43l0J43kIETDGBsbw9vbG/v37+c0x4cffoi6ujoazUEIIYRoqGfPnqG4uBivvvoqAMDOzg65ubkcpyKEkH+cOHECADB27Fix7W+//bbY46piyJAhos9tbGwkbrezswMAiedbxhh69uwp+r+TkxMAIDMzU+ZMrq6uUn9NdHQ0PDw88PTpUwwaNAgzZsxAYGCgzBnkRbh25YQJE8S2e3h4iD2uabKzs7Fp0yZERESga9euXMeRi6ioKFRXV+OLL77gOgohREVQkYMQDTR79mxcvHgRjx8/5iyDubk5Fi5ciKioKNEicYQQQgjRHHfv3gUA9O/fH0DDhbeCggLU1dVxGYsQQkSePXsGoGGKtcaE/y8sLFR6ptaYmpqKPtfS0mp1O2syVVNZWRkiIiLg7OwMU1NT8Hg86OjoAECHpjI2MjKS+mt0dXVx8OBBGBoaor6+HgEBATL3L0/C77ednZ3Yeh7C10NWVpbMbZuYmIDH40FLSwvGxsYYOXIk7ty5I5fcHfXFF1/AxsYGH330EddR5OLZs2fYtGkTPv/8c1hZWXEdhxCiIqjIQYgG+ve//42uXbviwIEDnOb49NNPUVFRgbi4OE5zEEIIIUT+/vzzT5iamooW+7Szs4NAIOgUi7cSQtSD8AJo0/WChP9veoFUuE4Nn88XbSsvL1dkRLl59913sWHDBsycORNPnjyRac0KedqyZQu0tbUhEAgwffp0VFdXc5ZFyNraGkDDelKsydoejLEOZQwLC8OwYcNgb2+P+vp6XLlyBQMHDkSfPn1QWloqr0OQ2vXr17F//3589dVX0NfX5yyHPK1evRomJiZYvHgx11EIISqEihyEaCBdXV1Mnz6d8ymrrK2tERgYiI0bN+Lly5ecZiGEEEKIfF2/fh2DBg0SXRQUFjtoyipCiKrw9vYGAJw/f15s+7lz58QeFxJOEZWXlyfaduPGjRbbF45y4PP5eP78ebMRI8qUnp4OoOFGM+GURLW1tS3ur8jscXFxSE5ORmZmJgYMGIDMzEyEhITIrX1ZTZ06FQCQmpra7LGLFy9i5MiRMre9ceNG/Prrr8jOzkZNTQ0yMzPh5OSEhw8fwsrKirNRHR9//DFGjBgBHx8fTvqXt7/++gs7d+7EqlWrYGxszHUcQogKoSIHIRrKz88Pt27dwu3btznN8cUXXyAvLw979uzhNAchhBBC5Ov69evN5onn8XhU5CCEqIzVq1fD0dERn3/+OX7++WdUVlbi559/xhdffAFHR0esWrVKbP/x48cDAL7++muUl5fj7t272L17d4vtv/baawCAq1evIiUlpUMXyTvK3d0dALBhwwaUlZWhpKQEERERLe6vqOxpaWkIDw9HSkoKunfvjkOHDsHY2BiJiYnYtm2bXPqQ1apVq+Dk5ISwsDAkJyejuLgYlZWVOHHiBIKCghAZGSm3vpydnXH//n1ER0ejrq4OgwcPRkVFhdzab4+DBw8iPT0dW7ZsEd2QoO4+/vhj9O/fH++99x7XUQghKoaKHIRoKA8PD/Ts2RNJSUmc5ujRoweCg4OxZs0aWpuDEEII0RB1dXX4448/MHjwYNE2PT09WFhY4OnTpxwmI4RwoaamBsuXL0efPn2go6MjWuuAa9bW1sjIyIC3tzcCAgLQtWtXBAQEwNvbGxkZGaLpi4SioqIwe/ZsHDhwAPb29ggPD8eGDRtEjzc9pu+++w6vv/46PD09sWXLFkRFRUmdsXGbHfk8Pj4eAQEBiImJgbW1NcaMGYPhw4fLlL1pH5K+l5Jy8Hg8jBkzBoWFhVi+fDlu3rwJFxcX0TRQH3zwgUyvC3k9R5aWlsjIyICfnx/Cw8Nha2sLJycn7Ny5E4mJiRgzZozU2dry0UcfYdWqVeDz+aJClDI8f/4c4eHhCAgIwBtvvKG0fhXp2LFjOHXqFL799lvRejOEECJEZwVCNBSPx8O7776LhIQErFmzhtM/Mr788kvExsZi165dGrPYGSGEENKZZWZmoqamRmwkBwD06tWrQwu3EkLU08qVK/HVV19h7dq1+OSTT3Dp0iV4eXlxHQtAQ6Fj+/bt2L59e5v7WlpaIjExsdn2lta2GDZsGG7evNmhfC21Le12KysrxMfHN9v+7rvvSty/teztWctD0j7t3SYteT1HAGBubo6oqCiZClKyWrlyJTZv3ozff/8djx49Qq9evRTe59q1a1FaWipWpFNnL168wCeffILZs2fjrbfe4joOIUQF0UgOQjSYn58fnjx5gsuXL3Oaw9bWFgsXLsSGDRtUYsE5QgghhHTMb7/9BkNDQzg7O4ttd3Z2xp9//slRKkIIVw4cOAAACA0NhZGRETw9PTld9JoQVSNcJHvhwoUK7+uvv/7Cpk2bsHbtWtja2iq8P2WIjIxEUVERvvrqK66jEEJUFI3kIESDDRo0CAMHDsS+ffvg5ubGaZbPP/8cu3fvRlRUFFasWMFployMjBbvaCItY4whOjoaR44c4ToKkaOcnBwAwKxZs1RiWglCCPfac2Hyxo0beP3115tNF+Hs7IxffvmlXf3QeYcogvD3GlGu7OxsABAteE0IETd27Fj85z//waVLlxTe1+LFi9GvXz+EhoYqvC9lePjwoWikmL29PddxCCEqikZyEKLhgoKCsH//fjx//pzTHN26dcOyZcvw9ddfIz8/n7Mc06dP57zgo66mT5+O7t27cx2DyJmDgwNmzJhBFxoJISIzZ84Um8ddkqaLjgu5uLjg77//RlVVlWhbbm4u8vLy5J6TEKI6BAIB1xFUinAdi7Y+OrPO9hw5OTkBaFgro6ioSGH9HDx4ED/99BN27NihMetWLFq0CL1796aprwkhrdKMMx4hpEVBQUH48ssvkZycjLlz53Ka5ZNPPsH27duxevVqbNu2jZMMvr6+8PX15aRvQgghRBMIBALcunULQUFBzR5zdnYGYwz37t1D3759ERkZiU2bNmHcuHE4deqU2L5JSUnQ1tZWUmrSWRw+fBjTp09XWPs1NTXYsmULDhw4gPv376O+vh49e/bEm2++iaCgIIwYMUK0b35+PlauXImTJ0+isLAQVlZWmDRpElavXi224HXjC7kPHjzAZ599hgsXLqCsrAzAP6OrCgsLsXLlSqSkpKCwsBDdunXDxIkT8Z///Ac2NjZiOe/cuYPPPvsMaWlp0NLSwsiRI7F582YMGDBAtA9jrNlF5JSUFEyaNAkA8P3332PRokW4c+cOXFxcAAAJCQkICAhosQ3h58uWLUNkZKQMz7BmoKm62tbZnqMuXbqIPj9y5AgWLFgg9z4qKiqwZMkSvPfeexg5cqTc2+dCQkICfvrpJ6SmpkJXV5frOIQQFUYjOQjRcBYWFvD29kZMTAzXUWBoaIjVq1dj165duHPnDtdxCCGEECKDe/fuoaqqSuJIjt69e8PAwABbtmxBz5498c033+Dly5cdXpiXEFVQWVkJd3d3rF+/HmFhYXj48CGKioqwfft2pKWliV1UzM/Ph6urK06cOIH4+HgUFxcjLi4Ox44dw/Dhw1FQUCDat/HF3tDQUCxduhS5ublihcGCggK4urri6NGj2LNnD0pKSpCUlIQzZ87Azc1NVBABgKysLIwePRq3bt3C8ePHkZubixUrVohdVBX2yRjD5MmTAQBbtmwRFTgAiBax3rdvn2ibv78/4uPjMWnSJLE2GrfLGOvUBQ5CJHn58qXo8ydPniikj88//xy1tbUa8/NXVFSEJUuWICwsDO7u7lzHIYSoOCpyENIJvP/++0hLS8Pdu3e5joK5c+diwIABWLp0KddRCCGEECKD69evQ09PT+yOcKFTp07BwMAAP/zwA8rKylBXVweg4YJvZWWlsqMSIlerVq3CtWvXsGbNGgQHB8Pa2homJiZ48803kZiYKLbvihUrkJ2djY0bN2Ls2LEwNTXFuHHjEBkZiSdPnmDlypUS+4iIiICbmxsMDQ0xYcIEUQFh5cqVePLkCdavXw9PT0+YmJjA3d0dmzdvxqNHj/D111+L5SwrKxP1bWJiglGjRiEiIkJin8JRWbGxsaJt9+7dwx9//AEASExMFCtk7N27V+JILkJIyxpPH/3s2TO5t3/lyhXs2LED0dHR6Natm9zb50JoaCiMjIywbt06rqMQQtQAFTkI6QQ8PT3h6OiIvXv3ch0F2tra2Lp1K06fPo3Dhw9zHYcQQgghUrpx4wYGDhwIfX190bYrV65g5MiRmDx5MioqKprNz88YU4mbLQjpiOTkZADA1KlTmz02ePBgsULAiRMnADQsNtzY22+/LfZ4U66urhK3p6SkAAAmTJggtt3Dw0PscQA4e/asxL5bWpdu0qRJsLS0xK1bt0SjruLi4rBo0SI4OjoiOzsbqampABruQP/999/h7e0tsS1CiGSPHz8G0DClm7zXy6ytrcX7778PLy8vzJ49W65tc+X48eM4fPgwduzYAVNTU67jEELUABU5COkEtLS0EBQUhL1794LP53MdB6NHj8bcuXPx8ccfiy1MSgghhBDV13TR8Q8//BAjR47EtWvXAEhegFhbW5umqiRqLy8vDwCarX8hifBObUtLS7Htwv8XFhZK/DojIyOJ24X729nZiS3KLGwvKytLtK9wUeOmfZuZmUlsW1dXF35+fgAaRmkIBAIkJCQgMDAQ/v7+AP6ZsiouLg6zZs2Cnp6exLYIIZJlZWXBwMAAjLFmP5sdtXbtWjx58gRbt26Va7tcKSkpQUhICObNmwcvLy+u4xBC1AQVOQjpJN5//30UFRXh5MmTXEcBAERFReHFixdYs2YN11EIIYQQIoWbN29i0KBBov/36tULPB5PNDWVJFTkIJpAuFi4sNjRGisrKwD/FByEhP8XPi5t3yUlJaJ1Lxp/VFdXi/YVXkBtqW9JAgMDAQA//PADzpw5g27dumHAgAGYO3cugIZRLM+fP0dcXBxNVUWIDO7cuYOePXsCAGxtbeXW7q1bt7Bx40Zs2LABvXr1klu7XFq0aBG0tLTwzTffcB2FEKJGqMhBSCfRvXt3jBs3TiUWIAcaFkRfs2YNNm3ahN9//53rOIQQQghph+LiYpSWlqJ///6ibZ9++iliY2Ohra0NLS3Jf17w+XzR/P6EqCtfX18AwP/+979mj125cgXDhw8X/V84ndP58+fF9jt37pzY4+0lnCJLOG1UYxcvXhRb9NzT01Ni3+np6S22P3ToUAwcOBDPnj3DwoULRcWNfv36Yfjw4aisrMSSJUtgZGSEoUOHSpWdENLw8ycsQsirGFFbW4u5c+di5MiRCAsLk0ubXEtISMD+/fuxc+fOFkefEUKIJFTkIKQTef/99/Hjjz8iOzub6ygAgJCQEAwdOhRhYWFicxgTQgghRDUJp8Tp3bu32PbAwED8+OOP0NfXh7a2drOvY4zRTQ1E7a1atQoDBw7EihUrsGvXLhQUFKCqqgqnT5/G3LlzsX79etG+q1evhqOjIz7//HP8/PPPqKysxM8//4wvvvgCjo6OWLVqldR9Ozk5ISwsDMnJySguLkZlZSVOnDiBoKAgREZGiu1rZmYm6ruqqgqXLl3Cjh07Wu1DOJrj6dOnYvP6CwseO3bsoFEchMigtrYW169fF03nOH78eLm0u2LFCmRlZSEmJqbFmwzUyaNHjxAWFoaPPvoIEydO5DoOIUTNqP9ZkBDSblOmTIG5uTni4uK4jgKgYa2QrVu34vLly0hISOA6DiGEEELa8PDhQ+jo6KB79+7NHhs/fjxSU1PRpUsX6OjoNHs8Pz8flZWVyohJiEKYmZnh8uXLWLx4MaKiotCjRw/07NkTmzZtQkxMDMaNGyfa19raGhkZGfD29kZAQAC6du2KgIAAeHt7IyMjQzT9FNCwEHHjzxv/X8jS0hIZGRnw8/NDeHg4bG1t4eTkhJ07dyIxMRFjxowR7du7d29cunQJr7/+OiZPngw7Ozts3LgR33//PQC0eDHU398fOjo6+Pe//41u3bqJtgvX4NDR0RGt0dFYe/IT0pn93//9H2pqalBcXAx9fX2Ym5vLpc2oqChER+2UWigAACAASURBVEejb9++ckjJrbq6Ovj7+6N79+7YsGED13EIIWqo+V8fhBCNpa+vj3nz5mHbtm1YtmwZdHV1uY6EoUOHIiQkBJ999hkmTZoklzd8hBBCCFGMhw8fokePHi2+h3B1dcWvv/6KcePGITc3F3w+X/QYYwx3795VVlRCFMLExARr1qxp17py1tbW2L59O7Zv397qfu0d0Wxubo6oqChERUW1ue+AAQNw6tQpsW25ubkAmi9ILmRjYyP2MyvUtWtX1NbWttgXjcgmpHXHjx+Hi4sLnjx5IlbglFV1dTWCgoLw9ttvY968eXJIyL21a9fit99+w9WrV2FoaMh1HEKIGqKRHIR0Mh988AEKCgpw7NgxrqOIbNiwAVpaWvh//+//cR2FEEIIIa3Iy8uDvb19q/v06dMHV65cQf/+/cWKIeqw+LjwLnThx4kTJ0SPff/99+DxeMjMzBRtS0hIENu/aRu5ubnw9fWFqakpLCwsEBgYiPLycjx+/BiTJ09Gly5dYGNjg6CgIJSVlcmUuby8HJ988gl69+4NAwMDWFhYwM3NDUuXLsXVq1fF9i0sLERoaCgcHBygp6cHe3t7LFiwAPn5+c3avXPnDt555x2YmJigS5cu8PLyQmZmZrPjJaqJx+PhwYMHYtvS0tIAAG+99RYXkQjptE6ePAkvLy8UFRXBw8Ojw+199NFHKC0txd69ezXiXHz16lWsX78e33zzDV577TWu4xBC1BQVOQjpZBwdHTFx4kTRcHVV0KVLF0RGRmL79u2tLohICCGEEG5VVVXB1NS0zf1sbGxw+fJleHh4iKauUociB2MMkydPBgBs2bIFkyZNEj0WHx8PANi3b59om7+/P+Lj4zFp0iTR3eyN72pftmwZ1q5di5ycHPj5+SE+Ph5z5szBkiVLsHHjRmRnZ8PHxwdxcXEIDw+XKXNgYCC2bNmCxYsXo7i4GHl5eYiNjcXDhw/FFsIuKCiAq6srjh49ij179qCkpARJSUk4c+YM3NzcxIosWVlZGD16NG7duoXjx48jNzcXK1aswIIFC8SeK6LawsLC8PDhQ1RXV+P8+fNYtmwZunTpIvV6IIQQ2f3xxx/466+/IBAIwBhDcHBwh9o7ePAgYmNjsXv3btjY2MgpJXdKSkowc+ZMjB8/XmMWTyeEcIOKHIR0Qh9++CF++eUXlVoAdO7cufj3v/+NgIAAmq+bEEIIUVFVVVUwMTFp174mJiY4efIkpk6dCi0tLbx8+VKl3nu0RLiwcmxsrGjbvXv38McffwAAEhMTxS7w7927t8XFmIODg+Hs7IxXXnkFERERABru6F28eHGz7U2nFmqvCxcuAADs7e1hbGwMPT099O/fv9kNLStXrsSTJ0+wfv16eHp6wsTEBO7u7ti8eTMePXqEr7/+WrTvqlWrUFZWho0bN2Ls2LEwMTHBqFGjRFmJ6jt37hxMTEzg5uYGMzMz+Pn5YcSIEcjIyMCrr77KdTxCOo3ExEQ4OjoiIyMDurq6YuvnSCsrKwvz58/H4sWLMWXKFDmm5AZjDPPmzUNdXZ3GjEohhHCHihyEdEJvv/02Xn31Vfz3v//lOoqYXbt2oaKiAsuWLeM6CiGEEEIkkKbIATSsB3bgwAF8+OGHACAqFKiySZMmwdLSErdu3cLNmzcBAHFxcVi0aBEcHR2RnZ2N1NRUAMCTJ0/w+++/w9vbW2JbQ4YMEX3e+I7bxtvt7OwA/LNegrR8fX0BADNmzECPHj0QHByMgwcPwtLSUqwYk5KSAgCYMGGC2NcLp04RPg4AZ8+eBQCMHTtWbF83NzeZMhLlGzduHA4fPoz8/Hzw+XwUFhbiwIEDVOAgRIkEAgF++OEH+Pv749q1a2LnfmnV1tbi3XffhZOTEyIjI+WYkjvr16/HqVOnkJSUhG7dunEdhxCi5qjIQUgnxOPx8MEHH2Dfvn0oKSnhOo6Ira0tdu3ahe3bt+PHH3/kOg4hhBBCmqiuroaRkZFUX6OlpYXo6GhERkbCwMBAQcnkR1dXF35+/x97dx4f093+f/w12feFLCQSu9hVkloSa621tG5bitZa1aKroqje6q5+W6W47bSUamsLVUtbu4ioWqJFiJIgIWSRZbJOkpnfH35z7oQg2sTJcj0fj/OYJWdmrgkSc97nc11DgHurNPR6PRs2bGDEiBG8/PLLwP9aVq1bt46XXnoJCwuLIp+rYGsvExOTR97/d9s/rVmzhuDgYAYMGEB6ejpff/01QUFB1K9fXwlp4N48DrgXqhScq2EcQn316lVl38TERODBAdVOTk5/q0YhhKiMDh06RExMDKampuTl5TF58uS//VxTpkzhypUrbNy4EUtLyxKsUh2HDh3i3//+N/PnzycwMFDtcoQQFYCEHEJUUiNHjsTMzIx169apXUoh//rXvxg8eDCvvvpqmQpghBBCCAFmZmbk5+f/rcdOnTqVqKioEq6odIwYMQKA77//nr179+Lq6kqTJk0YPnw4AFu3biUzM5N169Y9tFXV09S/f3+2bt1KYmIiISEh9OjRgxs3bjBq1ChlH3d3d+Be/3ODwfDAlpGRoexrDDeMYYfR/beFEEI83KpVqwgICGDr1q1YWVkpK++e1HfffcfixYtZuXIl9erVK+Eqn77bt28zbNgwBgwYwJtvvql2OUKICkJCDiEqKXt7e1555RWWLl2KXq9Xu5xCVqxYgYmJCW+//bbapQghhBCiABsbm0IHwysqPz8/mjZtSkJCAq+//roSbjRo0IDWrVuj1Wp57733sLGxwc/PT9VaNRoNsbGxwL1VIe3bt2fTpk0AXLx4UdmvX79+AEqrrYKOHj1K27Ztldvdu3cH4MCBA4X2O3bsWInWLoQQFdWdO3f48ccfGTBgABcvXnygVWBx/fHHH7z22mtMmjSJl156qYSrfPry8vIYPHgw9vb2rF69Wu1yhBAViIQcQlRiEyZMICoqil9++UXtUgpxcnLi66+/5rvvvmPLli1qlyOEEEKI/8/V1VVpe1TRGVdz3Lx5k6FDhyr3GwOPlStXlolVHHBvwPmFCxfIycnhzp07fP755wD06NFD2WfWrFnUr1+fCRMmsHXrVpKSktBqtezatYuRI0cW6vE+a9YsnJyc+OCDDzh48CDp6emEhoaycuXKp/7ehBCiPPr666+xs7NTZhz997//feLnuHv3Lv3796dt27b83//9X0mXqIpJkyYRHh7O9u3bcXBwULscIUQFIiGHEJVYo0aNeO6551i6dKnapTyge/fujBkzhvHjx3P79m21yxFCCCEEUKNGDWXVQEX38ssvY2ZmRs+ePQsNRDXO4DAzM1NmdBSk0WhK5HpxhYaGUq1aNfr06YO9vT0+Pj7s2bOHOXPm8MMPPyj7ubi4cOLECYYMGcKUKVOoXr069evXZ9WqVXz33Xd07NhR2bdOnTqEhobSokULXnjhBTw8PPj8889ZsmQJUHi+iBBCiMJycnJYsmQJI0aMYP/+/bRo0YIaNWo80XMYVzzo9Xo2btyImZlZKVX79Hz11VcsXryYNWvW0LhxY7XLEUJUMOX/p6QQ4h9588036d+/P5GRkfj4+KhdTiELFy7k8OHDjBs3jh07dqhdjhBCCFHp1a9fnytXrpCbm4u5ubna5ZSqatWqkZub+8D9VapUIScn56GPe9gA8Se9v7gCAwOLPbTV2dmZ+fPnM3/+/Mfu26RJE/bs2VPovlu3bgEPDiQXQgjxP+vXr+fu3bvExMSQl5fHwoULn/g53nzzTY4fP05oaGiF+JkbGhrKxIkT+eijjxg0aJDa5QghKiA5BUeISq5v3774+Pjw5Zdfql3KA2xtbfnqq6/YtWsXa9asUbscIYQQotLz9fUlOzubCxcuqF2KKGUajYYrV64Uui8kJASAzp07q1GSEEKUeQaDgQULFjB48GC2b99O06ZNC62UK465c+eyatUqNmzYQMuWLUup0qfn2rVrDBgwgF69evHRRx+pXY4QooKSkEOISs7ExIS33nqLdevWlcm2UB07dmTKlCm8+eabnDt3Tu1yhBBCiEqtUaNGODs7c+jQIbVLEU+BcX5bRkYGBw4cYOrUqTg4ODBr1iy1SxNCiDLpxx9/5NKlS9y8eZP8/Hy+/fbbJ3r81q1bmTZtGvPnz+df//pXKVX59KSnpyttD7/99ltpdyiEKDXy00UIwciRI3F2dmbZsmVql1Kk//znP/j7+zNgwADS0tLULkcIIYSotExNTXn++efZuXOn2qVUaBqNplhbadq/fz92dnYEBATg5OTEkCFDaNOmDSdOnKBhw4al+tpCCFFezZs3j06dOnHo0CECAgJ45plniv3YsLAwhg8fzvjx43nnnXdKscqnQ6/XM2zYMOLj49mxYwe2trZqlySEqMAk5BBCYGVlxeuvv87SpUtJT09Xu5wHmJmZsXnzZtLT0xk7dqza5QghhBCV2oABAwgJCSE6OlrtUiosg8FQrK00denSheDgYG7fvk1ubi7x8fFs2rRJAg4hhHiIkJAQwsLCuHjxIqampmzfvr3Yj/3zzz/p27cvXbt2/VszPMqiadOm8euvv7Jt2za8vb3VLkcIUcFJyCGEAO4NNsvJyeGbb75Ru5Qiubu789133xEcHFxmV5wIIYQQlcELL7xA9erV5fexEEIIUcCcOXOoWbMmt2/fZvr06bi5uRXrcVeuXKFnz540atSIH374AVNT01KutPQtX76cL774glWrVhEQEKB2OUKISkBCDiEEAFWqVGHEiBF8+eWX5OXlqV1OkTp37szMmTN57733OHXqlNrlCCGEEJWSmZkZb7/9NsuXLyc2NlbtcoQQQgjVhYaGsnfvXmJiYvDy8uLjjz8u1uNiYmLo1q0b3t7e/PzzzxWipdPu3bt56623mD17NsOHD1e7HCFEJSEhhxBCMWnSJG7cuPFEy2qftpkzZ9KpUycGDBhAUlKS2uUIIYQQldKbb76Ju7s7kydPVrsUIYQQQnUzZ87EwsICjUbDwYMHi/WY2NhYnnvuORwdHfn555+xt7cv5SpL36lTpwgKCmLEiBF8+OGHapcjhKhEJOQQQijq1KlDv379+OKLL9Qu5aFMTEz4/vvv0Wg0jBw5stT7UQshhBDiQZaWlixZsoRNmzaxfv16tcsRQgghVLN3714OHz6MTqfjv//9L/Xq1XvsY6Kjo+nYsSOWlpbs3bsXZ2fnp1Bp6YqKiqJPnz506NCBFStWqF2OEKKSkZBDCFHI1KlTOXnyJCEhIWqX8lBVqlRh48aN7N27l/nz56tdjhBCCFEpPf/887z//vuMHz+e3377Te1yhBBCCFWMHTsWgN69ezN+/PjH7h8ZGUmHDh1wdHTk0KFDxZ7dUZYlJSXRq1cvatSowebNmzEzM1O7JCFEJSM/dYQQhTz77LO0a9eOefPm0aFDB7XLeag2bdowZ84cpk+fTtu2bQkMDFS7JCGEEKLSmTNnDpGRkTz//PMcOHAAX1/fxz7GeOBDDoCI0iR/vyoujUajdglCKDQaDTdv3qRWrVrs2rXrsfufO3eObt26UadOHfbs2YOTk9NTqLJ0ZWVl0bdvX3Q6Hbt27cLOzk7tkoQQlZD8z08I8YD333+f/v37c+HCBZo0aaJ2OQ81adIkQkNDGThwICdOnMDb21vtkoQQQohKxdzcnM2bN/Piiy/SuXNngoOD6dq16yMf07NnT7Zt20ZeXt5TqlIIIYQoeSEhISxZsgQLCwsiIiIeu/+ePXsYMmQIvr6+7Ny5s0KEAdnZ2fTr14/Lly8TGhpKtWrV1C5JCFFJaQzS0F6UMUOGDEGn0xEcHKx2KZWWwWCgefPm+Pr6sm7dOrXLeSStVkv79u3Jzc0lLCwMR0dHtUsSQgghKh2dTseYMWPYuHEjy5YtU1p3CCGEEBXRt99+y4gRIzAYDJw4cYJWrVo9cv9FixYxadIkBg8ezJo1a7CysnpKlZYenU7HgAEDOHr0KPv378ff31/tkoQQ5UxwcDADBw4kLy8PU1PTf/JUq2UmhxDiARqNhilTpvD9998THR2tdjmPZG9vz+7du0lNTeWll16Ss0KFEEIIFVhYWLB+/XpmzJjBuHHjmDVrltolCSGEEKVi6dKljBgxArjXBeFRAUdOTg6jR49m0qRJzJkzh++//75CBBy5ubkMGjSIo0ePsnfvXgk4hBCqk5BDCFGkoUOHUrNmTebNm6d2KY/l6elJcHAwR44cYcKECcgCNSGEEOLp02g0zJo1i6+++oo5c+YwatQocnNz1S5LCCGEKDGffvopEydOxMrKCk9Pz0eG+teuXVNaOf70009MnTr16RVainJzcwkKCuLw4cP88ssvj13FIoQQT4OEHEKIIpmamvLee++xZs0a4uLi1C7nsVq3bs2mTZtYu3Yt77zzjtrlCCGEEJXW6NGj2b59O1u2bOHFF18kPT1d7ZKEEEKIf2zgwIHMmDEDNzc3srOz+eqrr7C1tS1y3w0bNvDMM8+QlpbG8ePH6dWr11OutnSkpaXRp08f9u/fz549e2jTpo3aJQkhBCAhhxDiEUaPHo2zszOLFi1Su5Ri6du3Lz/88ANLly5l9uzZapcjhBBCVFp9+vTh0KFDnDlzhrZt23L16lW1SxJCCCH+loyMDJo1a0ZwcDBt27YlPz+f119/nR49ejywb2pqKq+88grDhw8nKCiI33//ncaNG6tQdcm7desWnTp14s8//+TQoUMEBgaqXZIQQigk5BBCPJSVlRVvv/02y5YtIzk5We1yimXAgAEsX76cWbNm8fnnn6tdjhBCCFFpPfvss5w+fRobGxtatWrF3r171S5JCCGEeCIXLlzAw8ODCxcuMGXKFADc3NyYO3fuA/vu27ePZs2acfDgQX755RdWrlyJjY3N0y65VJw/f562bduSk5PDb7/9hp+fn9olCSFEIRJyCCEeafz48ZiZmbF06VK1Sym2sWPHsnjxYqZNm8bMmTPVLkcIIYSotDw9PTly5AgvvPACvXr1khMQhBBClBtffPEFLVq0ICsrix07dqDVajl//jzbtm3Dzs5O2S8mJobBgwfTvXt32rRpw59//kn37t1VrLxk7dq1i8DAQOrUqcOxY8eoWbOm2iUJIcQDzNQuQAhRttnb2zNhwgQWLlzIO++8U+g/c2XZhAkTcHJyYuTIkdy9e5fFixdjYiK5rhBCCPG0WVlZsXbtWpo2bcrUqVM5d+4cq1evxtraWu3ShBAlQKfTkZiYqGzx8fEkJyeTlpZGWloa6enpZGRkKLfz8/MByM/PJy0trdBzOTg4YGpqCtybEejg4ICjoyP29vbY2dlhb2+Ps7Mzbm5uuLq6Ur16ddzd3eXniShRSUlJdO3albNnz+Lh4UFISAg7duxg5cqVbNmyhYYNGwL3BnAvW7aMmTNn4ubmxq5du+jdu7fK1ZccnU7HtGnTWLBgAaNGjWL58uVYWFioXZYQQhRJQg4hxGO98847LFy4kK+//pq3335b7XKKbdiwYZibm/Pyyy+TnZ3NihUrMDc3V7ssIYQQolKaNGkSzZs356WXXqJ9+/Zs3ryZOnXqqF2WEOIRcnJyiI6OJioqipiYGG7dusWNGzeIi4sjNjaWmzdvkpKSUugxpqamODs74+DggIODA7a2ttja2uLo6Ej16tULHSR1dnYu9NiCLXLz8vLQarVcv36d9PR0tFot6enp3L1794FwxN7enho1alC7dm3q1KlTaKtXr56EIKLYNmzYwKuvvopOp2P48OGsXbuWjRs3MnnyZObNm0f//v0B2LNnD++++y6xsbHMmDGDSZMmYWlpqXL1JefGjRsMGTKE8PBwVq5cydixY9UuSQghHklCDiHEY1WtWpUxY8Ywb9483njjjXJ19sbgwYOxs7MjKCiI2NhYtmzZgoODg9plCSGEEJVSt27d+P333xk4cCC+vr6sWrWKwYMHq12WEJVafn4+0dHRXLhwgYiICC5fvkxUVBRRUVHcvHkTg8EAgJOTE56ennh5eeHh4UHr1q3x8PDA3d0dFxeXQltpy8nJIT4+nps3b5KQkMDt27eJjY0lKiqKM2fOEBwcTFxcHHAvdKlXrx7NmzenefPmNGvWjObNm1O7du1Sr1OUH3fu3GHw4MGEhITg6OjI3r176dChAxs3bmTkyJG89957vPvuuxw4cICPPvqIsLAwBg4cyL59+/D29la7/BL13XffMXHiRGrWrEl4eDg+Pj5qlySEEI8lIYcQoljef/99li9fzoYNGxg9erTa5TyRXr16cezYMfr06UNgYCC7du2SPqJCCCGESurWrcvx48d5//33CQoK4sCBAyxcuFDOtBailN0fZhgvL168SHZ2NhqNhpo1a+Lj40OTJk3o27dvoRURZelEIUtLS7y8vPDy8nroPllZWVy9epWLFy9y7tw5zp07x9q1a4mOjsZgMODi4kKbNm1o06YNAQEBPPvss+WmNa8oObm5ucycOZP58+eTl5dH79692bp1K1ZWVqxZs4bXXnuNt99+mxdffJEuXbpw8OBBunbtyokTJ2jVqpXa5Zeoq1evMn78ePbv38/48eP54osvsLKyUrssIYQoFo3BeFqGEGXEkCFD0Ol0BAcHq12KuM+YMWM4cuQIkZGRSq/c8uTGjRv06dOHpKQktm3bRuvWrdUuSQghhKjUtm3bxquvvoqnpyebNm2icePGapckRIWg1WoJDw/n1KlTnDlzpsgwo1GjRjRt2rTQZWU4yJ+ens65c+c4ceIEx48f5/jx48TExGBqakrz5s3p0qUL3bp1o3379hK+VnB79uxh1KhRxMfH4+rqysaNG3nuuecwGAzMnDmTTz/9lKFDh3L79m0OHDhAly5dmD17NgEBAWqXXqLy8vJYunQpM2bMoE6dOqxcuZK2bduqXZYQohIIDg5m4MCB5OXl/dPjjKsl5BBljoQcZdfVq1fx8fHhhx9+YNCgQWqX87ekpaUxZMgQDhw4wOLFi6W3qBBCCKGy69evM2TIEP744w8WLVrEq6++qnZJQpQrGRkZnD17llOnTnH69GlOnTpFZGQker0eNzc3fH19adasGY0bN6ZJkyaVJsx4ErGxsRw/fpzQ0FD27dvHxYsXsbKyon379nTr1o2ePXvSrFkztcsUJeS3335j/PjxhIeHY25uzowZM/jwww8xNTUlNTWV4cOHs2fPHlxdXYmLi6NLly7MnDmTjh07ql16idLr9WzevJlZs2YRExPDRx99xHvvvSdzLIUQT42EHKJCk5CjbBs8eDCXL18mPDwcjUajdjl/i8FgYO7cuUyfPp1hw4axcuVKOUtLCCGEUFFeXh4ffvghX3zxBT179mTVqlV4enoWua9eryc1NZXk5GRSU1MLbVlZWaSkpJCdnU1WVhapqalkZ2eTkZGBVqslLy9PGWycm5tLeno6AJmZmeTk5ACQmpqKXq8v8fdob2+Pmdm9bsG2trbKjDNra2ulHYilpSU2NjYAmJubKweiTU1NcXBwwMTEBEdHR+Uxjo6OWFpaYmdnh52dHRYWFjg5OWFlZYW1tTUODg5YWlpib29f4u9HqCM3N5fw8HBOnjzJqVOnOHXqFBcvXiQ/P5+qVavi5+eHv78//v7++Pn5VbhZAU9LbGwse/fuZd++fezfv5/ExETq1avHgAEDGDBgAP7+/uX2s1BlduzYMd59911OnjwJQJcuXdiwYQPVqlUDYPv27YwaNQqtVou5uTmvvPIKb731VoULuAwGAzt27OCjjz4iIiKCoUOHMnv2bGrVqqV2aUKISkZCDlGhSchRtv3xxx+0bNmS3bt38/zzz6tdzj+yY8cOhg8fTsOGDdm4caMMHxRCCCFUkJSURFxcHAkJCYSEhLB06VK0Wi2BgYG4uLgQHx9PYmIid+/eJTU1VQkm7mdtbY2NjQ2Ojo7KQX5HR0fMzMywtrbG1tYWuBcwmJiYkJubi62tLXq9HoPBUCh0MIYRRbGwsCjWWa7G17O2tsbU1JSsrCzlw5sxcIF7rXNyc3OBwmGLMagB0Ol0ZGRkkJeXh1arVfZLTk5WvvY4NjY2WFpa4uzsjIWFBba2tjg5OWFvb4+Dg4Ny6ejoiKOjIw4ODg+9X87yfXpSUlIICwsjLCyM0NBQTp48SWZmJk5OTvj6+iqBhr+/v/xftpTo9XpOnDhBcHAw27ZtIzo6Gm9vb/r3709QUBBt2rRRu0TxGEeOHGHq1KmcOHECgCZNmrB8+XLat29PRkYGmzZtYs6cOURFRWFpacl7773HpEmTqFq1qsqVl6ycnBw2bdrEokWLCA8PZ+DAgXz88cc0atRI7dKEEJWUhByiQpOQo+zr1asX6enphISEqF3KPxYZGcngwYO5fv06K1euJCgoSO2ShBBCiAojPj6eqKgorl27RlxcHDExMcTFxREbG0tcXBw3b94kOztb2d/ExAQnJyfy8vJIS0vDyckJHx8fZUWDRqNBr9eTl5dHTk4Oubm5Shig1+tJS0sDKPaBfzUUXKHh7OwM/G+Vh3GFhnEfjUaDk5MTlpaWSihha2uLra0tdnZ2ODk5YWNjg62tLWZmZlhYWJCbm4tGoyErK4u0tDR0Oh1paWlKMJKSkoJOpyM9PZ3U1FTS0tLQarWkpaWRlpamrIpJS0tTwpf7WVlZKSFIwfDD0dERZ2fnx26WlpZP7ftd3ly9epVjx44RFhbGsWPHiIiIQK/X4+PjQ0BAAO3atSMgIAAfHx9ZSaCSM2fOsG3bNoKDg7l06RKNGjVi5MiRvPzyy3h4eKhdnvj/srOz+eGHH5g3bx4REREANG7cmCVLltCxY0dCQkJYt24dmzZtIjs7GzMzM0aNGsXixYuV0LuiiImJYcWKFaxevZqUlBT69+/PBx98wDPPPKN2aUKISk5CDlGhSchR9h09epQOHTpw9OhR2rVrp3Y5/1hOTg5Tpkxh7cfVmgAAIABJREFU8eLFvPzyyyxfvlw5+1IIIYQQD5efn09UVBSRkZFERUURFRVFdHQ00dHRREVFKUGDqakpTk5OygF7c3Nz9Ho9Op2OzMxMMjIySE1NJT8//4HX0Gg0uLi44OXlpRzgt7e3x9HRUbnt4OAA/C80MDMzU1o0GVd1QOE2UY6OjpiYmCgtoIorJSWFx32EMrbUgv+1v8rIyECn05GTk0NmZib5+flKKPO4fbKyssjMzCQ1NVVZyfGoEMcYjtjZ2WFjY6MEIgXDEeNmDCbuv8/JyUkJjrRaLSkpKQ+EIgXvN15PTk4utBlXphRkY2NTrDDE2dmZqlWrUrVqVVxdXXFycir2n1N5YDAYOH/+PIcOHSIkJIRjx45x+/ZtLC0t8fPzIzAwkMDAQAICAnB1dVW7XFGEkydPsm7dOr7//nvS0tLo2bMnI0eO5IUXXqhwB8rLi+joaFasWMGKFStIT09Hr9dTv359vvjiC6pWrcr27dsJDg7m+vXr2NjYkJWVRb9+/Vi8ePFD2ySWR8nJyezcuZMtW7bw66+/UqVKFUaOHMmECRPw8vJSuzwhhAAk5BAVnIQc5UP79u1xcHBg9+7dapdSYn788UfGjBmDm5sb69ato1WrVmqXJIQQQpQJWVlZXLp0iUuXLhEREUFkZCQXL17k8uXL6HQ6AOXMfgsLC/Lz88nMzCQ5OVlpywT3Dm5Xr16datWq4e7ujoeHB25ublStWpUqVaoom/G2mZkZ06dPZ+nSpbRp04Zly5bRvHlztb4NZU5ycrISeBiDh4yMDDIzM0lJSSE9PZ3MzEzS09NJSUkhMzNTCSOMm3G+SVGM7b+KCkCMmzGIKPjnVrVqVSVYMv49+Dvb/QGJmZmZEnoU3FxdXalatSouLi5Ffr0srXiIiIjg8OHDHDp0iCNHjpCQkICTkxPt27dXVmn4+/src1pE+ZCdnc1PP/3EN998w969e3Fzc+ONN95g3LhxuLm5qV1ehZeVlcWuXbtYt24de/bswdzcHJ1Oh7+/P7169SIuLo4dO3YQHx9PjRo10Gg0xMTE0KdPHz755BNatGih9lsoEZcvX+bAgQPs2LGDAwcOYG5uTu/evQkKCpLgTQhRJknIISo0CTnKhz179tC7d29Onz6Nr6+v2uWUmJiYGEaPHs3hw4eZMmUK//73v+U/g0IIISqV5ORkwsPDC22RkZHk5+djamqqDLvW6XSkpKQoqy+sra2pVasWNWvWxNvbu9Clm5sbnp6eSpumJ3XmzBkmTJjAqVOnmDhxIh9//LGyekOUjPuDj+Levnv3LikpKQ88n7W19QPBR8Ht/kDLeFlw3kdmZiZJSUkkJiaSkJBAUlLSA1tiYqKyJSUlPbDCRaPRPDQAcXFxUe6//+v/8IO24vLly0qocfjwYW7fvo29vT0dOnSgc+fOdOrUiWeeeabEXk+oLyYmhmXLlrF69WrS09MZMmQIb731Fi1btlS7tAolPz+fw4cPs2HDBrZu3UpmZqbSss/Pzw97e3t+//130tPTeeaZZ6hRowYRERFcvXqV5557jk8++YS2bduq/Tb+tvz8fC5fvsypU6c4fPgw+/fv58aNG9jb29OtWzcGDRpEnz59/vbvXSGEeBok5BAVmoQc5Yefnx/169dn48aNapdSogwGA6tXr+b999/H29ubdevW4efnp3ZZQgghRInLzs7m9OnThIWF8dtvv3H69GmuX78O/G9QdcFh2A4ODjRo0ID69evToEEDfHx8qFevHrVq1Sr1djp6vZ41a9bwwQcfYGFhwbx58xg6dGipvqYoHr1eT1JSEnfv3lUuC143XhqDCOPXixoi7+DggKurK66urkoI4eLigru7e6Hbbm5uuLq6Km3JjLKzsx8agNy/JSQkkJiYiFarfaAOZ2fnhwYgDwtHzM3NiY6O5tChQ8p28+ZNbG1tadeunRJq+Pn5PXK4vagYsrKy2LBhA//97385f/48HTp0YNq0afTs2VPt0sqt/Px8jh8/zvbt2/nhhx+Ii4vDwcEBrVaLpaUlVlZWpKSkYGtrS8eOHWnYsCG3b9/mp59+wmAwMHToUMaPH1+uZlHo9Xpu3LjBX3/9xZUrV7h48SLh4eGcPXuW9PR0LC0tadWqFV27dqVr1660atVKfr4IIcoNCTlEhSYhR/mxadMmhg0bRkREBA0aNFC7nBJ37do1Ro8ezdGjRxk/fjxz5syRM2GEEEKUa3fu3OH48eOEhoZy7NgxTp8+TW5uLlZWVpiampKZmYnBYMDe3p7mzZvTvHlzWrRoQaNGjfDx8cHd3V3tt0BSUhLTp0/nq6++onXr1sydO7dCzAirjHJycooMQ+Lj45UAwriKIz4+nsTERDIzMws9h5WV1QPBh/G2q6srbm5uhcIRFxeXB9pX6XS6hwYgDwtHilq9YmJigl6vx8TEhCpVquDl5YWPjw9NmjShevXqD4QiLi4umJiYlOr3WJQNBw4cYN68efzyyy+0bt2amTNn0qtXrzLVSq2sSk9P59dff2Xnzp3s3r2bxMREbG1t0el05ObmotFo0Gg0+Pv7061bN2rWrMmlS5eUuRuNGzdm3LhxjBgx4pHzl4wzkYozdwnuzZoq7orCtLQ0ZdVjXl6eEqxmZ2eTmpqqbHfv3uXOnTvcvn2bW7ducefOHW7cuKGcaODs7EyDBg1o2bIlfn5++Pr60qxZs0Ir4IQQojyRkENUaBJylB/5+fk0btyYDh06sHr1arXLKRV6vZ7ly5czY8YMXFxcWL58Od26dVO7LCGEEKJYMjIyOHLkCPv27WPXrl1cuXIFjUaDlZUVOTk56PV63NzcCAgIoGXLlkqwUbt27TJ/8O306dNMmTKFgwcP8uKLL/Lpp5/SuHFjtcsSpSwzM5PExMRHBiHGLT4+/oF5IyYmJoUCj6KCEDc3t0L3FWxdeuvWLQ4dOsTBgwc5ePAg165dw9zcnAYNGlCnTh2qVauGtbU1KSkphVaTJCQkKIPmC7p/RYjx0jirpuD9Li4uVKlSpdS/x6L0nDx5kv/85z/s2rULX19fZs6cyQsvvFDmf94+TQaDgYiICA4ePMhPP/3EkSNHyM/Px9LSUvm9pdFo8PT0pEePHjz//PPY2tpy6NAhtm/fzl9//UXNmjVp3749Pj4+mJiYKD8v4uLiSEtLIy0tjdzcXFJTU8nJyXkgPH3azMzMcHR0xNnZGXd390Izq2rWrEmDBg2oV68eLi4uqtYphBAlTUIOUaFJyFG+fPXVV4wfP54rV67g7e2tdjml5tatW7z11lsEBwczbNgwvvzySxkiKIQQoswxGAycOXOGvXv3smvXLn7//Xfy8vIwNzcnNzcXc3NzWrZsSUBAAG3atKFt27bl/vf3L7/8wgcffMD58+cZNWoUH3/8MR4eHmqXJcqI3NzcQsHHnTt3Ct0uKhzJy8sr9BzW1tZYWFig0+nIysrCxMQEDw8PGjVqhK+vL61bt1YOSLq6uj505a9xxYhxhYjx9QveLriKJDEx8YEZI6ampg+sBjGGNUUFJq6urjK/pgwKDw/nP//5Dz/++CMtW7Zk7ty5dOnSRe2yVBMZGcnWrVv5+eefOXv2LBkZGcrKKCNLS0v8/f0ZNmwYQUFBhIWFsXXrVn766SeSk5NxcHDAysoKrVZLVlYWcG+ll6enJ+7u7ri6ulK9enUcHR1xdHRUggULCwtsbW2VFo2Ojo7FWmFVsJXj49jZ2SmrLTQaDU5OTsp7cnR0lG4BQohKS0IOUaFJyFG+5ObmUq9ePfr378+CBQvULqfU7dy5k4kTJ5Kamsq///1vJk6cKMuDhRBCqCovL48jR46wefNmgoODSUpKwszMTAk3WrduTc+ePXnuuefw8/MrdFZ6RaHX69mwYQMzZ84kISGBsWPHMnnyZGrUqFHsx6empioHuUTllZiYyK5du9i/fz9hYWFER0djYmKCp6cn1apVw8HBARMTk0JhhPGAqpGxhVZxVokYt4fJzs4uFH4YB7AXbKV1//3Z2dmFnsPCwqLIoe8Fh78Xdb+NjU2pfI/F//z5559Mnz6d3bt306tXL+bOnUuTJk3ULqvU5Obmcv78efbs2UNYWBgRERHcunULnU4HoKw0NDExISMjAwcHB/r06cPo0aNp2rQpP/30E+vWreP3338nNzdXeV5nZ2f8/f3x9fWlQYMG1K1bl7p16+Lp6SmrZIQQogyTkENUaBJylD8LFizgww8/5Nq1a6U+dLQsyMzMZO7cuXz++ed4e3uzYMECevXqpXZZQgghKpGsrCz27dvHd999x+7du8nIyFAO5DRp0oS+ffvSpUsXAgICsLa2VrXWlJQUtFptoS05ORmtVkt2djZarRaDwaDMODD2Ljf2R8/OziYrK4vc3FzS09OVQML43AU/zhgMBtLS0gqd/ftPWFtbY2Vlpdy2srIq9P20tLQsdCC44G0TExPljGBHR8dCZ+86OzsXunRyckKj0Sj7Ozg4KP3eTU1Nsbe3x8rK6oEh2+KfS05OJiQkRBkUfu7cOUxMTGjZsqUyKLx9+/aP/N5nZGQUe5VIfHz8A/M8jKszHtdCq+C8kUeFlcZ6jDUUDEWMQ98LDodPSkpS/k0VZGVlpYQgDwtGnJycitxk8PGTOXjwIJMnT+aPP/5g9OjRfPzxx1SvXl3tsv6Wu3fvEh0dzbVr17hy5Qrh4eFcvHiR69evk5aWpvzMNjU1xcnJCWdnZ0xNTYmNjSUjIwMfHx/69OlDr169aNKkCZs3b2blypVEREQoj61WrRo9e/akb9+++Pv7l/sViUIIUVlJyCEqNAk5yp/MzExq1arF66+/zuzZs9Uu56mJiorivffeY8eOHfTr14/PP/+8Qg5gF0IIUTYYDAbCwsJYtGgRP/30k9Imw8LCgk6dOjFkyBD69OlTaj278/LySEhI4M6dO8TFxZGQkPDA0GjjdvfuXZKTk4ucQWBkbC1iZ2enBAGAcqDf2N7DGCyYmZlhb29fKCwwhgAFmZqaYmNjw5EjR/jxxx9JTEwkICCAfv364eXl9dB6bGxs0Ol0hVoVpaenFzpb2Bi8POx2wfYlxuGyxsv8/HwlgElNTVUuCwY8xWFvb4+1tTV2dnY4ODhgbW2Nra0tjo6OWFtbY2Njg5OTE9bW1lhbW+Ps7Kzc7+joqLRlcXBwwMnJqditWSqKtLQ0JdQ4fPgwZ8+eBaBFixZ06tSJzp0706FDh0cOKP6nCrbQelgQcv99xqHFRg4ODri7uz82HCkYUjxKfn7+A+HH/YHI/V97WDgC99rzPCwAKbg5OjoqB7qN99nZ2VXKFVV6vZ7vv/+eGTNmkJSUxLRp05g8eXKZWX2Xn5/PnTt3uHXrFnFxcdy8eZPbt29z8+ZN4uLiiIqK4vr160XOtzA1NcXT05P69evj7u5Ofn4+Z8+eJTIyEktLSzp27Ejv3r3p3bs3np6ebN26lcWLF3Pq1Cn0ej0mJia0aNGCsWPH8sILL+Dp6anCd0AIIURJk5BDVGgScpRPs2fP5ssvv+T69eul+qGwLNq7dy/vvvsuf/31F6+99hofffSRzOsQQghRYm7cuMGKFSv4+uuviY+PB+4d6H7hhRd46aWX6NKlyz9erZGUlERMTAwxMTFcv36d2NhYbt68WSjQiI+PL7RqwsrKSjl4WvDSeGC1SpUq2Nvb4+zsjL29faHNGFKUtvz8fDZu3Mj//d//ERERQZcuXZg4cSJ9+vT5px+kSoVxSLbx0rhSxTgcNz09nbS0NLKyssjIyCA1NZWsrCwyMzNJSUkhKyuLrKwskpOTycrKIjs7u9D1h7G3t8fBwaHQZjwA7ejoWOTXnJycCt1XVlsbpaenc/ToUQ4fPsyhQ4c4c+YMer2epk2b0rlzZyXUKOsDve+f1VHUypGCw9jvb6FlYmLyQGuqR/37Nd5na2v7yLqMIV1ycjIpKSmkpqaSkpJS7O1hQai5ubkSlNja2mJnZ/dEt21tbZWfNSYmJk/tZ05JyM7OZsGCBcyZMwcvLy+WL19Op06dSvQ1jN9745aamlpoNkxR82ISEhIKrZKzsrLCwsICg8FAdna2Egi7ubnRpEkTnn32WWrUqEFOTg7R0dEcOXKECxcuYGZmhr+/P506daJTp060a9cOW1tbrl69ypIlS1i9erUyi6ZRo0ZMmDCBoUOHKivfhBBCVBwScogKTUKO8ik1NZWaNWsyffp0pkyZonY5T51eryc4OJjJkyeTmJjIxIkTmTFjhrSVEEII8bfo9Xp+/PFHZs+ezZ9//onBYMDc3Jzu3bvz5ptv0rVr1yf6IJCZmcnVq1e5cuUKV65c4erVq0RFRREbG/vAmbcuLi54eXkpw1o9PDyUga3u7u64ubnh4eFRrn7HGQwGDhw4wKpVq9i2bRvu7u6MHTuWiRMnltrKl7LGeDA6MzOTjIwM0tLSlIPSBQ90Gq8X/FrB+7VabZHPb2Zm9tAAxMHBQQlMHve1f9o/PzMzkzNnznDs2DH2799PSEgIOp2OOnXq0LVrVwIDA+nSpUuFPxM8IyOj0OqqgqusCl6///b9hwfub1lVcBVGwdUXD1ul8Tj3hyQpKSmkp6crm/F2RkZGkbeTk5OV6/cPab/f/S3k7r8s2CKuqEvjarL7FXXwvaj5Pg97vLElX0FarZb4+Hi++eYbfvvtN9q2bUv//v0LDZE3tvCD/606S05OVu43rixLS0sjMzOz0L/nolhaWuLs7IydnZ2yek6v16PT6cjIyFDaDMK9FYR169alQYMG1K9fn/r161OrVi1ycnI4d+4cJ06c4MSJE9y5cwczMzNatmyphBr3t3/79ddfmTdvHgcOHECj0WBmZsaQIUP44IMPaNiw4cP+OIUQQlQAEnKICk1CjvJrypQprF+/nujoaNX7f6slIyODBQsWMHfuXOzs7JgyZQrjxo2rtN8PIYQQT0ar1bJo0SIWLFjA3bt30Wg0NG/enLfffptBgwZhZ2f3yMfHxsYSERHB+fPniYiI4K+//uLKlSvcunULuDfUtUaNGtStW5c6derg7e2Nt7c3Xl5e1KhRg5o1a1b431l//fUXy5YtY+3ateh0OgYNGsTw4cPp3LlzpWrb9HcZD0qnpqYWCj/uD0ce9jXjGeQF24IVZFxVYgw9HrU5Ozuj0Wi4evUqFy5c4NSpU5w6dQqdTkeDBg2U9lOdOnWiWrVqT/k7Vf4YDIYH2lHd37qqYBhRcCuqRZGxtVxRYYjxPhsbmyJXYDg6OmJjY6O0Yiuu5ORkJfAwHpg3toq7v4Xc/ZfGcOBxlwUZH/s0aDQarK2tlfCkYOs+Y6ji5OSEubk59vb22NjYYG5ujqWlpRIe6vV6cnJylJVhxn+rxtV6xnZ7Go2GatWqUbNmTby8vPD29qZWrVpKoGFlZcX58+c5e/Ysf/zxh9J6Kj8/Hy8vL1q3bk2bNm1o3bo1fn5+Rf5eCQsLY+rUqYSGhip1Tp8+nTfeeKNcrbwRQgjx90nIISo0CTnKrzt37lC7dm3mz5/PG2+8oXY5qoqPj+ezzz5j5cqVODg4KGFHWW3lIIQQQl3Xrl1j2rRpBAcHk5ubi7W1NSNGjGDGjBnUqFHjgf21Wi1nz54lPDycCxcuKJtxtoO7uztNmzalfv361KtXj3r16lG3bl3q1atXaJB2ZZaens63337L2rVrOXnyJF5eXrzyyiu88sorcvbwU5CZmVloBYmxzVHB+4o6mJ6QkEBycnKRB9Xh3soDZ2fnRw7FftgBd2NrI/HkdDrdQ1tSPSwYSUlJKbRC41GHJuzt7ZV5Ms7OzkogUjAgsbS0VGb5WFtbK+2UbG1ti5zpY1zFYW9vj5mZWZGrL/6utLS0B+aoFLViA+615jIxMVHm+2RlZaHRaLC0tFQek56eztKlS9m2bRs+Pj68/PLLmJiYPLCqxRhEPWoukouLS6FVecaVetWqVVOC7xo1amBhYUFKSgqRkZFcunSJiIgI/vjjD/744w9u374NQI0aNWjRogUtWrTA39+f1q1b4+Hh8cjvTUREBLNmzWLr1q1YWFig0Wh49913mTJlioQbQghRyUjIISo0CTnKtzfeeINff/2Vy5cvY2ZmpnY5qktISGDp0qUsWLAAS0tLxo8fz3vvvVdoqbkQQojK68aNG7zxxhv8/PPPGAwGPDw8mDFjBmPGjFEOtmm1WsLDwzl9+rSyXb58Gb1eT9WqVWnatCmNGzemWbNmNG7cmKZNm1K1alWV31n5cvHiRdavX8+GDRuIjY2ldevWDB48mH/961/Url1b7fIqrZycHM6cOUNYWBihoaGEhYURHx+PlZUVzz77LH5+fjRt2pS6desqK0z+6SyIgi23ijM0+/4WXJVxYHZJMbZS02q1pKamKqsxjMGX8XZqaiparZaMjAwyMzOVllU6nU4JF4y3HzePpiiWlpaPPDGpOGGIMVwBCgU4BcMP4yqSJ2VcleHi4kL16tWVsMfZ2ZkqVaoUuix43cXFBTc3N8zNzQs9X05ODteuXSMqKopLly4RGRlJZGQkFy9e5M6dO8C98LBhw4Y0b95cCTWeeeaZJ/pdk56ezowZM1iyZAkODg6kpqYycuRI5syZQ/Xq1Z/4+yCEEKL8k5BDVGgScpRv0dHRNGjQgLVr1/Lyyy+rXU6ZkZiYyJIlS1iwYAEWFhZMmDBBwg4hhKjEbt68ydixY/nll18wGAw8++yzLFiwgMDAQGJjYzl69CjHjh0jJCSECxcuoNfrcXV1xc/PD19fX/z8/PDz86NmzZpqv5UKRa/Xc+DAATZs2MDOnTtJTk7mmWeeoV+/fvzrX/+iefPmapdYYeXl5Sktp06ePMmpU6f4888/yc3NxdXVlYCAANq1a0dgYCB+fn5YWFj8o9fT6/XFWmnwsO3+tkVGVlZWhWaN3D+DxDjI/WHzSYwhiyhZxrkSxtZVcK+1FdybLajX65WWVI8LRoyPexTjcwHKShFAWWkChcMSKysrpaVTwZDFOIDduALFzs6O/Px8PvroI+bPn8/zzz/P6tWrHxkS5OTkcOvWLWJjY4mOjiYqKoro6Gjl+q1bt5QQxt3dnUaNGuHj44OPj49yvWbNmv9oldPBgwcZNWoUd+/eBe4FNKtWraJbt25/+zmFEEKUfxJyiApNQo7y75VXXiE8PJw///xTlvzfR8IOIYSo3JKSknj99dfZtm0ber2eZs2aMXv2bBISEjh69ChHjx7l2rVrmJmZ4efnR2BgIIGBgfj7++Pt7a12+ZVKbm4uhw8fZvv27ezYsYNbt25Rp04dunfvTteuXencuTNVqlRRu8xySa/Xc+nSJWWGxqlTpzh79ixZWVnY2NjQsmVL/P398ff3p1WrVjRo0EDtkh+Ql5f30DZb97fcun82ScH5JA/7OG5cJVJUAFLw/oLX7/+atKar2A4ePMjo0aNJSUnh9ddfx8fHh5iYGG7dusXNmzeJiYkhLi6O+Ph45TFWVlbUrl27yK1OnTpPNP+kOPLz8/n444/59NNP8fLy4vr164wdO5Z58+YVOYRdCCFE5SIhh6jQJOQo/y5cuEDz5s3ZvHkzAwYMULucMikhIYH58+ezdOlSrK2tGT9+PG+88Qbu7u5qlyaEEKIU6PV6pk+fzvz588nLy6NOnTr4+/sTHh7OX3/9hZ2dHW3btqVdu3a0a9eO1q1bK61OhPoMBgMnTpxg586d7N+/n9OnT2MwGPD19VUCj9atW5f4AcKKIDExkfPnz3Px4kXOnz/P+fPnCQ8PR6vVYmlpSfPmzXn22WeVUKNRo0aVquWpVqt96PD2ooKT+79mbONUFAsLC2WIt62tLdbW1jg4OGBnZ6esOLGzs8Pa2hp7e3vs7e2xtrbGzs4OBwcHrK2tsbW1LXTdOMdClIzc3FzlzzM5OVm5fv9lcnIyiYmJyoDw27dvPzDw3MzMjLp16+Lh4UGNGjWoUaMG1atXx9vbGw8PDzw9PR87L6MkabVahgwZwv79+3F3dyclJYV169bRr1+/p1aDEEKIsk1CDlGhSchRMQwcOJCrV69y5swZpW+seFBiYiKLFi1ixYoVaLVahg0bxjvvvEOzZs3ULk0IIUQJ2bdvHy+99BJ3797F0tISvV5Pfn4+zzzzDD169KB79+4EBgY+0CddlF3JyckcPnyY/fv3s3//fi5fvoyJiQkNGzakTZs2yta4ceN/+oGt3Lh79y7nz58nIiKCCxcuEBERwfnz55WzyJ2cnJSZMb6+vvj7+9O8eXP5e18C8vPzlVUj9wcgxqHemZmZZGVlKbMuMjMz0Wq1aLVaZbB1WloaWVlZDw1NjIytk+6/BHB2di7ysqj9C17Cg7MwCrZwApRh4kb3z8awtbUt1MasqOHfT8I49Fuv15Oamgr8rw2Vsf0V/K99VWZmJjk5OeTl5SkBRFpaGjqdrtCfT8EAo6hB5Mb3en9rM1dXV1xdXZVZHMbb7u7u/P7774wfPx4vLy82b96Mj4/P337fJeHatWv07t2bO3fukJeXR+3atQkODqZOnTqq1iWEEKJskZBDVGgSclQMZ8+exdfXl507d9K7d2+1yynzcnJy2LRpE1988QXnz58nMDCQt99+m/79+1eagyNCCFHRhIaGMmzYMG7cuAHcOyA3YMAAevToQbdu3XBzc1O5QlFSbt++zW+//aZsp06dIiMjAysrKxo3bkyTJk1o2rQpTZs2pUmTJuVylopOpyMmJobr168rW3R0NNevXycyMpLbt28D99osNWrUiKZNmyqhRuPGjfH09FT5HYgnYTwAn5mZSUpKCllZWWRlZZGcnKwcxDfOtzBeGsOA+y+NQ+Hvv4Tizbco6xwcHDA1NVVCmYKhj52dHZaWlkpQUTC4uP96wa//nZkz165dIygoiIiICFasWMGwYcNK+q0Wy5UrV3juuefQaDTcunWLIUOGsGLFikcOcxdCCFHQQNaSAAAgAElEQVQ5ScghKjQJOSqOvn37kpCQwG+//aZ2KeVKaGgon3/+Obt376Zu3bpMnDiRV199VdqWCCFEORAVFcX69etZtWoVcXFxANSuXZvFixfTo0ePStWGpzLLy8tT2jJduHCBc+fOERERQWxsLHDvDPVatWoV6odfq1YtqlWrhpubG9WrV3+q/erT0tK4c+cOCQkJJCYmcvv2bSXIuHbtGteuXSMuLg69Xg/cO8u8du3a1KxZk5o1a1KvXj0lzPDy8npqdYuKxbgSwigjIwOdTqfcLjjMu6jbWq2WvLy8Qs9pXEnydxRcWWJ8HuPqETMzszI5U0Kn0zF16lQWLVrEq6++yqJFiwqthiltly9fpnPnzlhYWHDjxg0mT57MZ5999tReXwghRPkiIYeo0CTkqDhOnDhBmzZt2LdvH127dlW7nHLnr7/+YsmSJXz11VeYm5szYsQI3n//fTl4IIQQZUx6ejrBwcGsXbuWkJAQzM3N0el0ODo6sm/fPp599lm1SxRlRHJyMhEREVy5coXo6OhC261bt5QQAe4FIcZ2NE5OTtja2irzEezt7ZXArKiDuAXPlDe+rk6nU1oXpaWlKbMgEhMTCx1YhnurMby9valVqxa1atVSwgzjJquQhCjbduzYwahRo6hVqxY7dux4Kp8f4uLiCAgIQK/XExMTw2effcaUKVNK/XWFEEKUXxJyiApNQo6KpXv37uh0Og4fPqx2KeVWQkICa9asYcmSJcTFxdG5c2dee+01aWUlhBAqCwsL46uvvmLLli3k5ubSqlUrTp48SXZ2Nn369OHHH3+Un9Oi2HQ6XaGhwgkJCcpmnKOQnp6OVqtVWgHl5uaSnp5e5PMVnHXg4OCApaUl9vb2ODs7Y29vr4Qlxh7/7u7uyvWCcw+EEOVTVFQU/fr1Iz4+nuDgYAIDA0vttdLS0ujYsSMxMTEkJyezbNkyxo0bV2qvJ4QQomKQkENUaBJyVCxhYWEEBgYSEhJC+/bt1S6nXMvJyWHLli2sXr2akJAQatWqxZgxYxg9ejQeHh5qlyeEEJVCbm4uW7ZsYeHChZw8eRJfX19GjhzJ6dOnWbduHba2tmzZsoXnn39e7VKFEEJUcunp6QwfPpzdu3ezbNkyxowZU+KvYTAY6N+/PwcPHkSr1bJ27VpGjBhR4q8jhBCi4inJkMOkpIoSQoiiBAQE0KFDBz755BO1Syn3LC0tefnllzly5AiRkZEEBQWxePFivLy86NatG1u2bHmgD7EQQoiSkZqayqJFi6hXrx6vvPIK7u7u7Nu3jxMnTrBhwwbWrVuHv78/d+7ckYBDCCFEmWBnZ0dwcDCzZ89m7NixjBs3rtAck5Iwb948du7cSXp6Op9//rkEHEIIIVQhIYcQotR9+OGH7N27l7CwMLVLqTAaNGjAZ599RkxMDBs3bgQgKCgIb29vPvjgA6Kjo1WuUAghKoaEhATef/99PD09mTVrFkFBQURHR7Nz506aNWuGt7c3v//+O6+88gonT57E1tZW7ZKFEEIIhUajYerUqfzwww9s2LCB3r17k5ycXCLPfeLECaZNm4ZGo+H1119n8uTJJfK8QgghxJOSkEMIUeq6detGQEAAn332mdqlVDgWFhYMGjSIffv2cfnyZYYPH866deuoV68evXr1Ijg4mOzsbLXLFEKIcic5OZkPP/yQOnXqsGHDBj755BNiYmKYO3cu3t7ehIaGUqtWLe7cucPy5ctZv3692iULIYQQDxUUFMTRo0e5ePEi7du3JzY29h89X3Z2NkOHDkWj0TBo0CAWL15cQpUKIYQQT05CDiHEUzFt2jR27tzJ6dOn1S6lwqpXrx6fffYZN27cYPPmzej1eoKCgqhevTpjxozh4MGD6PV6tcsUQogyTavVMnv2bOrUqcOKFSuYOXMmV69e5Z133sHOzg6An3/+mU6dOqHRaDh27Bivv/66ylULIYQQj+fr68uJEycwMzOjVatW/PHHH3/7uaZPn861a9do3rw533zzDSYmcnhJCCGEeuS3kBDiqejTpw9+fn6ymuMpMDc3Z8CAAfzyyy/cuHGDWbNmERkZSZcuXfDy8uLtt98mNDRU7TKFEKLM2blzJ02bNmXevHmMGzeOq1evMmXKlEItqH7++Wf69u2LjY0NV65coU2bNipWLIQQQjwZDw8PDh8+TP369enUqRMhISFP/BwREREsXLgQW1tbduzYgYWFRSlUKoQQQhSfhBxCiKdm2rRpBAcHc/78ebVLqTQ8PDyUUOPixYuMHTuWn3/+mfbt29O4cWNmzZrFlStX1C5TCCFUdfnyZXr27MmLL75Ix44duXLlCp999hmOjo6F9tuzZw99+vTB1taWS5cu4eHhoVLFQgghxN/n5OTE3r176dGjB927d2fTpk1P9PiBAwdiMBjYsmULNWrUKKUqhRBCiOKTkEMI8dT079+fpk2bymoOlTRs2FBZ1XHs2DGee+45li5dSoMGDWjXrh3Lly8nKSlJ7TKFEOKpycjIYMqUKTRt2pTExESOHz/O+vXrcXNze2Dfbdu20bdvX+zt7fnrr78k4BBCCFGuWVpa8v333zN27FiGDh3K0qVLi/W4hQsXcvHiRUaMGEGPHj1KuUohhBCieDQGg8GgdhFCFDRkyBB0Oh3BwcFqlyJKwffff8/w4cOJiIigQYMGapdT6eXn53Po0CHWr1/P9u3bycrKok2bNgwaNIhBgwbJQTwhRIV15MgRxowZw927d5kzZw6vvfYapqamRe57/Phx2rdvj5mZGT169MDS0vIpVyuEEEIUn6mpKZ9++im1a9cu1v6fffYZ06dPZ/ny5YwbN+6h+xkMBuzt7TEYDPTq1QuNRlNSJQshhChlHh4eLFy4UO0yCgkODmbgwIHk5eU99LNYMa2WlRxCiKcqKCiIunXr8vnnn6tdiuDeB6CuXbuyfv164uLi+Pbbb6levTrTp0/Hy8uLDh06sHDhQm7cuKF2qUIIUSKysrL44IMPeO655/Dx8eHcuXO88cYbD/1P9fXr1+ncuTNmZmbk5uYSHx//lCsWlcXWrVuJiYlRuwwhSoX8/X66Nm3axIkTJ4q9//9j776jorj+NoA/u7BUQUAUBBRRsYElxogNk9giChbsBTWxYDfRxFgSFY0RY4kaNYldEhUVY4y9FzQqmmiMGEWxgSgoCKKIlL3vH77sD6RIWXaW3edzzh5hZvbOs8O6X5g7c++UKVMwe/ZsjBkzBjt37sx3u+XLl+PFixd4+fIloqOj1RGVKBd+XuiH6OhobN++Hbz2XjOio6OxdOlSZGZmSh2l1PBODtI6vJND923cuBHDhw/HjRs3Cn11EWlWamoqDh8+jO3bt2P37t1ITExEvXr10KtXL/Tt2xd16tSROiIRUZGdPn0an3zyCR4/foz58+djxIgRBW7//PlzODs7IykpCWfPnkWzZs2wadMm9O3bV0OJSZ8YGBjw/UU6i+9vzSru8R4xYgR27NiB8PBw2Nvb51pfs2ZNREVFISMjgz9PKjX8vNAParyCnwpBW4837+QgojJt4MCBcHFxwbfffit1FMqHiYkJfHx8EBQUhCdPniA0NBTt2rXDzz//jLp168LNzQ1TpkzB6dOnpY5KRPRWKSkpmDJlCt5//324urri6tWrb+3gEEKgcePGePr0KTZt2oT33ntPQ2mJiIik8f3338PKygrjxo3LtS4+Ph63b99mPSQiIq3ETg4i0jgDAwNMmTIFGzduxJ07d6SOQ29hYGCAVq1aYenSpYiOjsbRo0fx4Ycf4pdffoGnpydcXV3x6aef4vDhw3j16pXUcYmIcjhz5gzq16+PNWvW4JdffsHevXvh6Oj41ud169YNN2/eREBAAPr06aOBpERERNIyNzfHkiVLsGPHDly9ejXHul27dkEIge7du0uUjoiIKH/s5CAiSQwaNAjVqlXDvHnzpI5CRWBgYIA2bdpg+fLliIqKwp9//omePXvi2LFj6NChA2xtbeHr64s1a9bg4cOHUsclIj2Wnp6Or7/+Gu+//z7q1q2Lq1evon///oV67k8//YQ//vgDXl5e+Prrr0s5KRERkfbw9vaGm5sbFi5cmGN5SEgIAKB58+ZSxCIiIioQOzmISBJZd3Ns2LCBd3OUUXK5HM2bN8e8efNw5coVPHr0CCtWrIChoSEmTpwIBwcH1bBWR44cQUZGhtSRiUhP3LlzBx9++CEWLVqERYsWYffu3XmOLZ6XK1euYMyYMbC3t8fu3btLOSkREZF2kclk8Pf3x86dO5GWlqZafvbsWchkMjRo0EDCdERERHljJwcRScbPzw9VqlRBYGCg1FFIDezs7DBo0CBs27YNsbGx2Lt3L95//30EBwejffv2cHR0xJAhQ7B9+3YkJSVJHZeIdFRQUBAaNGiAZ8+e4fz585gwYQJkMlmhnpuamooPP/wQMpkMp06d0qpJ+bSFTCbL85HXeicnJzx+/LjQ7RARkXbw8fHBs2fPcPLkSQDAzZs3kZiYiCpVqqBcuXISp9MOrIdERNqFnRxEJBmFQoGpU6di/fr1uHv3rtRxSI1MTU3RqVMnrFy5Enfv3kVkZCSmTZuGBw8eYMCAAahQoQKaNGmiussj+1ViRETF8eTJE3Tt2hWffPIJxo0bh7/++gv169cvUhteXl5ISEjAzz//DFdX11JKWrYJISCEKNT3Dx48QL9+/ZCZmVlgO2+2QURE0nJ2doarqyv+/PNPAMCff/4JuVyOZs2aSZxMe7AeEhFpF3ZyEJGkBg8eDCcnJ8yfP1/qKFSKqlevjgkTJuDw4cOIjY3F5s2b0bhxY2zduhXt27eHra0tunTpgmXLluG///6TOi4RlTGhoaF455138M8//+D48eP49ttvoVAoitTGihUrcOLECfj4+GDo0KGllFS/2Nvb4+jRo5gxY4bUUYiIqIjq16+P8PBwAK+HqlIoFGjcuLHEqcom1kMiotLHTg4iklTW3Rxr167l3Rx6wtraGr1798aqVatw584dREZGYuHChTAxMUFAQADq1asHe3t71TbR0dFSRyYiLSWEwNKlS9G2bVs0btwYf//9Nzw9PYvczv379/HZZ5/B0tISmzdvLoWk+mnr1q0wNDTEvHnzsGfPHqnjEBFREdSuXRs3b94EAFy8eBGvXr2Cm5ubxKnKJtZDIqLSx04OIpLckCFD4OTkhO+++07qKCSB6tWrY8SIEdi2bRvi4uJw7tw5jBs3DnFxcRg3bhyqVq2Khg0bYtKkSdi7dy+ePXsmdWQi0gKPHz9G586d8fnnn2POnDn4/fffYWNjU+R2lEolOnfujPT0dGzatIljjatR69at8e2330IIAT8/P9y5c0fqSEREVEgVKlRAfHw8lEolrl27BgCoWbOmxKnKJtZDIqLSx04OIpKcQqHAlClTsHbtWty7d0/qOCQhAwMDeHh4YPr06Thx4gQSEhKwd+9etG3bFocPH4aPjw9sbGzQpEkTTJw4Ebt27UJCQoLUsYlIw06ePIlGjRohPDwcp06dwpdfflnsiTrnzp2L8PBw+Pj4wNvbW81J6YsvvkD37t2RmJiIHj16IDU1VepIVAo4YS6R7rGyskJiYiJu3ryJly9fQi6Xo1q1alLHKrNYD/UD6yGRdNjJQURa4eOPP4aDgwPv5qAczM3N4eXlhcWLF+PKlSuIjY3Fzp070a5dO5w6dQq+vr6oUKECatSoAX9/fwQFBSEqKkrq2ERUSoQQ+O6779C2bVs0b94cV65cQfPmzYvd3n///YeAgACYm5tjw4YN6gtKOaxfvx41a9bEpUuXMHbsWKnjUCngRLlEukkmk+Hff/+FXC6Ho6MjTExMpI5UprEe6j7WQyLpsJODiLSCQqHAl19+ibVr13IOBspXxYoV4ePjg8DAQFy8eBGJiYk4fPgwevXqhfDwcAwfPhxVq1ZFjRo1MGjQIKxatYpzvRDpiOfPn6NPnz6YPn06FixYgJCQEJQvX77Y7SmVSvTv3x+ZmZn46aefijXUFRVO+fLlsWPHDpiammLt2rVYv3691JGIiOgtMjMzYWhoiH///ReWlpZwdXWVOlKZx3pIRFR62MlBRFpj6NChqFy5MubPny91FCojLCws0K5dOwQGBuL06dN48uQJ9u3bh969eyMyMhJjx46Fi4sLatSoAT8/P6xcuRKXL19GZmam1NGJqAhu3bqFFi1a4Pjx4zhw4AA+++yzEre5bNkyXLlyBQ0aNED//v3VkJIK0qBBA/z4448AgDFjxuDy5csSJyIiooIkJSXB0tIS169fh0Kh4HwcasJ6SERUOtjJQURaQ6FQYPLkyVi9ejXv5qBisbCwgJeXF+bNm4czZ87g6dOnOHz4MPz8/BAXF4epU6finXfegZWVFdq2bYuvv/4a+/bt47weRFps//79aNq0KQwNDXHhwgW0bdu2xG3euXMHU6dOhVKpxIoVKzhusoYMHjwYI0aMwMuXL9GzZ08kJiZKHYmIiPLx+PFj2NraIiIiAmlpaahRo4bUkXQG6yERkfqxk4OItMonn3yCSpUqITAwUOoopAPMzc3Rrl07zJo1CwcPHkRSUhIiIyOxYsUK1KxZE7/99hu8vb1V83oMGjQIS5cuxV9//QWlUil1fCK9JoTAt99+C29vb3Tt2hV//vmn2iY8HT9+PIQQ6NmzJ1q1aqWWNqlwli1bhnfffReRkZEYPHiw1HHKvCNHjqBLly6wtraGiYkJGjdujODg4FzbZZ8I9dq1a+jYsSMsLS1Rrlw5dO7cGf/991+Jts9L9jayHtmzVatWLc9tZDIZ9uzZo9pu+fLlqhxZfv311zwndy3O8YiMjISvry+sra1ztKeOY/C24xITE4MePXrAwsICFSpUwODBg5GUlIS7d++iS5cusLS0hL29PYYMGZLnSdC4uDiMGjUKTk5OMDIygqOjI0aMGIFHjx7l2rY4xyYqKgpdu3aFhYUF7OzsMHDgQMTHxxfrdVPZExMTAzs7O9y6dQvJycns5FAz1kP1Yj0se/WQSO0EkZbp27ev8PX1lToGSejHH38URkZG4s6dO1JHIT3w+PFj8ccff4ipU6eK999/X5iZmQkAwsrKSnh5eYkZM2aI3bt3i4cPH0odlUhvpKamCj8/P2FoaCh++OEHtba9f/9+AUAYGhqKmzdvFum5crlcbNmyRa15yioAoqA/JQpad+fOHWFtbf3WNvRNcd5fAES3bt3E48ePxb1790T79u0FAHHgwIE8twUgWrRoIU6fPi2Sk5PFkSNHhL29vbC2ts71e1dxt8/uyJEjAoCoXLmyePXqVY51q1evFt7e3qrvu3TpIgCIJUuW5NjuvffeEwDElClTciwPCgrK8fziHo/27duLM2fOiJSUFLFv374cr6Gox6CwstodOHCguHbtmkhMTBRjxowRAETnzp1F9+7dVctHjRolAIjhw4fnaOPRo0fC2dlZ2NnZiYMHD4rk5GRx6tQp4ezsLFxcXMTTp09LfGwGDBiQK8eQIUOK9Zr5+alZ6jjeTZo0EcOHD1e9Hy5evKjW9nUF66H6sR7qRz0MCQkRAERGRkaRn0tFp63HW425VvFTlLQOOzkoLS1NVK9eXYwYMULqKKSH0tPTxYULF8SyZctE//79haurq5DJZAKAqFKlivD19RXffvutOHLkSK4TCERUck+ePBHvv/++sLCwELt371Zr2ykpKcLFxUWYmpqKTz/9tMjP50md/ynJSR0hhNi7d6/qs5VeK+5JnewnFv777z8BQHh6eua5LQCxb9++HMs3bNggAIjBgwerZfs3NWzYUAAQGzduzLG8fv364vDhw6rvf/vtNwFANGzYULXs+vXrwsTERFWDlUqlal2bNm1ESEhIiY/H8ePHc60r7jEorKx2T5w4oVr24MGDPJdHRUUJAMLR0TFHG/7+/gKAWLt2bY7lWcdx2rRpufZZ1GOTPcedO3cEAOHg4FCs18zPT80q6fFWKpXC0tJSfPbZZ6r3Q0xMjNra1yWsh+rHeqgf9VBbT7rrKm093uzkIJ3GTg4SQog1a9YIhUIhIiMjpY5CJJKSkkRoaKhYsmSJ8PPzE/Xq1VP9ole5cmXh7e0tAgMDRWhoqHjx4oXUcYnKrIiICFGrVi3h4uIirl69qvb2AwIChLGxsTA2NhYPHjwo8vN5Uud/f+S++ShofX6++uorntTJRh3vr4yMDAFAVKhQIde6rJ9HYmJijuXR0dGqeqaO7d+UdQKkUaNGqmVHjx4Vbm5uObZLS0sTtra2AoC4dOmSEEKIqVOnii+++EI4OzsLAOLYsWNCCCHu3r0rbG1tc10NW5zjUVDdLuoxKKysdp89e6ZalpmZWeBymUyWow0HB4dcJ56FeN1RDEDUr1+/wAyFOTbZc7x69SrPHIXFz0/NKunxznqPT5o0SZiZmQlDQ8McJ6D482Q9LE2sh/pRD7X1pLuu0tbjrc5ODs7JQURaaciQIahevTq++eYbqaMQwdLSEq1atcKECRMQFBSE8PBwPHz4EH/88QeGDRuGzMxMLFy4EJ6enihfvjwaNWqEoUOHYvny5Th9+jSSk5OlfglEWu/IkSNo2rQpbG1tce7cObi5uam1/bi4OCxcuBBmZmYYNmwYHBwc1Nq+vhBC5PkoaH1+5syZU+B6KlhiYiKmTZuGunXrwsLCAjKZDIaGhgBQ4LwJ5cuXz/G9ra0tgNeTDKtj+zf169cPlStXxuXLl3Hs2DEAwNKlSzFhwoQc2ykUCvTr1w8AsGHDBiiVSvz6668YPHgwBg4cCAD45ZdfAAAbN25E3759YWRkpHp+cY+HmZnZW19DSY9BfiwsLFRfy+XyApe/+X8lLi4OAODg4JBjvPSsbJGRkapti3tssufIOtb8P6sfbty4AQBIS0uDlZUV7O3tYWBgIHEq7cJ6qD1YD8t+PSRSB3ZyEJFWMjAwwPTp0xEUFKT6JZtIm9jb28PHxwezZ8/Gvn378PjxY9y+fRubNm1C+/btce/ePcycOROenp6wsrJCrVq10KdPHwQGBuLAgQN5TgpKpK82b96Mzp07o1OnTjh69CgqVaqk9n3MmTMHcrkcz58/x+eff6729ok0rXfv3pg3bx769OmDe/fuvfUkWpY3T3A8efIEAFCxYkW1bP8mIyMjjB07FgCwePFi3L59G2fPnlWdqMkua/LdzZs349ChQ6hYsSLc3NwwaNAgAEBISAhSUlKwceNGDBkyJMdzi3s8CqOkx6A02NnZAQASEhLyPJn64sUL1baleWxIN12+fBkVK1bE48ePYWpqCkdHR6kjEeWL9XBIjufqWz0kysJODiLSWv3790etWrUwZ84cqaMQFYqLiwt69+6NBQsW4MiRI4iPj8eDBw/w+++/Y+jQoTA2NsYvv/yCTp06oXLlyrCxscl1h4hSqZT6ZRBp1PLly+Hn54eRI0fil19+gYmJidr3cffuXaxevRomJibw8/NDtWrV1L4PIk07c+YMAGDSpEmwsbEBALx69arQz8ty5MgRAECHDh3Usn1eRo4cCTMzM+zbtw/jx4/HsGHDYGpqmmu7d999F+7u7nj8+DFGjhypOplTq1YteHh4IDk5GRMnToSZmRnefffdPHMW9XgUhjqOgbp169YNAHDixIlc60JDQ9G8eXPV96V5bLTZ3r170bVrV9jb28PIyEh1gcrvv/+ea9vsd8NkfxR2u6I8yoKwsDA0bdoU9+7dg1wuZycHaTXWQ/2uh0XF2qDDSjrgFZG6cU4Oym7Lli1CLpeLK1euSB2FSG3i4+PFkSNHxIIFC8SAAQNEvXr1hIGBgQAgLCwsRIsWLYS/v79Yvny5OHHihIiPj5c6MpHaKZVKMXPmTCGTycTMmTNLdV/9+/cXlStXFgYGBiIiIqLY7XAMcipNRX1/ffTRRwKAmDp1qnj69KmIj48XEydOzHcs8KzlXl5eIjQ0VCQnJ4ujR4+KypUrC2tr6xwTlJZk+/yMGjVKABCGhoYiKioq3+0WLFig2i4uLk61fMWKFap9LFy4UG3HoyBFPQaFVdRMeS1//PixcHV1FZUrVxbbt28XT548Ec+ePRO7d+8W1atXzzFpuLqOTWGOWX40+fmZlpYmBgwYIMqXLy+WLFki7t+/L169eiXu378vvv/+e2FpaSl8fX1FSkpKrucW9jVm36aox1ATSnq8XVxcREBAgHBwcBAuLi5i3Lhxam2fqCCsh6/pej3U9BwR+l4b9GFODnZykNZhJwdll5mZKRo2bCh69+4tdRSiUpWSkiLOnTsnfvrpJzF69GjRunVrYW1trfpFyMHBQXTo0EF8/vnnYsOGDeLixYt5/gJGVBZkZGSI4cOHCwMDA7FmzZpS3dc///wj5HK5cHd3F126dClRWzypQ6WpqO+v2NhY4efnJypVqiSMjIyEu7u72Lp1a76T3GYtu3PnjvD29hYWFhbC3NxceHl5iWvXruVqvyjbZ99nfn+oR0RECLlcLvr27Vvg63r48KEwNDQU3t7eOZbHx8cLIyMjYWhoKB49elSi4/Fm3vwyF/WYFUZ++y3qciGESEhIEBMnThQuLi5CoVAIOzs74ePjI86ePau2Y1OYHIWhyc9Pf39/oVAoxIULF/Jcf+7cOWFoaCgGDhyYa50unMgSomTHOy4uTgAQu3fvFnK5XFSqVEnMmzdPbe0TvQ3r4Wu6Xg81fdJd32uDPnRyyITgYJykXfr164e0tDTs2LFD6iikJXbs2IFevXrh0qVLaNiwodRxiDQqOjoa4eHhuHLlCq5evYqrV6/i2rVrSE1NhYGBAWrUqIH69eujfv36cHd3h5ubG2rUqAGFQiF1dKI8paWloV+/fjhw4AC2b9+OTp06ler+OnbsiJiYGFy9ehV79uwp0f4MDAywadMm9O3bV40JiV4r7fdX1lAIhf3zr6jbv41SqYSTkxN+++03NKmQYl8AACAASURBVGvWTC1tljZ1HwN9pqnPz/Pnz6NZs2YYPnw4Vq1ale92Q4cOxbp163Dq1Cl4enqqlhf2Zy6TyQrcRur3TkmO9759++Dt7Y3z58+jadOmMDIywpo1a+Dn56eW9onehvVQ+5TGZ9qOHTvQs2dPZGRkwMDAQG3t5oW1QbPHuyjUmGu1obpCERGVFl9fXzRp0gSzZs3Czp07pY5DpFFOTk5wcnLCRx99lGN5TEwM/vrrL1y7dg3h4eHYtm0b5syZg8zMTBgaGqJq1aqoV68e3NzcUL16ddSrVw+NGjVCuXLlJHolRK/HA+7ZsydOnTqFgwcPolWrVqW6v6z99OjRA0lJSbn+HxGR5uzduxdVqlQpMyd0qGz66aefAAA9e/YscLtevXph3bp1WL16dY4TWQScPXsWNWvWREpKCoDXFyfY29tLnIpId7Aeah5rg35gJwcRaT2ZTIavv/4aXbp0UU2CR6TvHBwc4ODgAB8fH9Wyly9f4vr167h+/TrCw8Nx/fp17N69Gzdv3kR6ejrkcjmqVauGOnXqoF69eqp/69atCysrKwlfDemDV69eoVevXggNDcXBgwc18ofd9OnT0a5dOxw/fhyff/65Vl21RKQPZDIZzp49i9q1ayMgIAAzZsyQOhLpuNDQUABA/fr1C9yuQYMGAHJPokvAuXPn0Lx5czx8+BAGBgbIzMyEra2t1LGIyjTWQ2mxNugHdnIQUZng4+MDDw8PzJ49G3v27JE6DpFWMjU1xTvvvIN33nknx/L09HRERkbi2rVrqg6QY8eOYeXKlaqr9CpXrow6derA1dUVtWrVUj2qV6/Ooa+oxFJSUtC1a1dcvHgRhw4d0khndVhYGE6fPo1p06bh1KlT+OSTT0p9n0TaKmt4hKyvCzPcQlG2L0jz5s1RoUIFjB07Fl26dCl2O5pWlGOQfduCcNir0hcTEwMAqFChQoHbZa1/+PBhqWcqS5RKJS5cuIB58+bh0aNHsLKyQnx8PDs5SGewHhadOo+BVFgb9AM7OYiozJg1axa8vLxw7tw53tpJVAQKhQJ16tRBnTp1ciwXQuDu3buqjo+IiAhERERgz549ql8EDQ0NUa1aNdSqVQu1a9dWdYK4urqiSpUqhT6xQ/orJSUFnTp1Qnh4OI4fP45GjRppZL/z5s3De++9h7CwMHh7e8POzk4j+yXSRkU9IaGuExhl8URIlqJkL8uvU19l/f7C32NyCg8PR1JSEpo3b46tW7fC0tKSnRykU1gPi64sZy8q1oayjZ0cRFRmdOzYEZ6enpgxYwYOHTokdRyiMk8mk8HFxQUuLi7w8vLKsS45ORk3b95EREQEbt68iRs3buD06dNYv349EhMTAby+cySrw8PV1RU1atRA9erVUaNGDTg5OUEul0vxskiLvHr1Ct27d1d1cLi7u2tkvxEREfjjjz+wdu1aDB8+HJs3b1ZLu0II9OvXD/369VNLe0TZ8Q9qopKrXLkybt++jYSEhALnkXjy5AmA18N/ZieXy6FUKpGZmZnvEIeZmZk6+zvOX3/9BVNTU7i7u2PZsmUwNzeHubk5TE1Nc2zHekilifWQ1I21QT+wk4OIypRZs2ahbdu2OHnyJN5//32p4xDpLAsLCzRu3BiNGzfOte7x48e4ceOGqgMkIiICe/fuRWRkJF68eAEAMDY2houLC2rUqJHr4eLiAmNjY02/JNKwzMxM+Pn54dy5czh69KjGOjgAYOHChahWrRqeP38OIyMjdOrUSS3tymQyjB8/Hi1btlRLe0TZ9e3bV+oIRGWep6cnbt++jStXrhR4IuvKlSsAgNatW+dYbmFhgaSkJCQlJcHGxibP5z59+hSWlpbqC61F/vnnH7i7u8PQ0BD//vsvoqKi8hzehfWQShPrIakba4N+YCcHEZUpbdq0Qdu2bTF9+nScPn1a6jhEeqlixYqoWLEiWrVqlWvdo0ePcPv2bURGRqoeFy5cQHBwMOLi4gC8vhLGyclJdddH9erV4ezsjGrVqsHFxQWVK1fmFVxlnBACI0aMwN69e7F//340adJEY/uOi4vDr7/+isWLF2Pr1q3o0qULzM3N1dZ+s2bN0KtXL7W1R5SFJ3WISm7kyJHYuHEjduzYgQ4dOuS73fbt21XbZ1e7dm2EhYXh6tWruU5yZbl69Spq1aqlvtBa5N9//4W7uzumTJmCixcvAkC+Q1WxHlJpYT0kdWNt0A/s5CCiMmfevHnw8PDA3r170blzZ6njEFE29vb2sLe3R4sWLXKtS05ORmRkZK5OkBMnTiAqKgppaWkAXt8FktXpkfV4sxOEtJcQAqNHj8amTZuwe/fufP8QKC3Lli2DmZkZOnTogLFjx6r+WCEiIt3XrFkz+Pv7Y926dRg+fHieneznz59HUFAQ/P398d577+VY5+Pjg7CwMKxfvz7f+rV27Vqd/Rvkn3/+QWRkJKKiogC8vmPj5cuXEqciIioZ1gb9wE4OIipz3nvvPXTt2hVTp06Fl5cXxz0kKiMsLCzQqFGjPCeeViqVePDgAe7du4c7d+7g7t27uHv3Lm7duoUjR44gKioK6enpAAATExNVp0fVqlXh5OQEZ2dnVKlSRfUwMTHR9Muj/xcQEIA1a9YgJCQE7du31+i+U1JS8NNPP2H8+PE4dOgQzMzM0LFjR41mICIiaf3www9ITk5G+/btERAQAF9fX9jZ2SE2NhY7duzAzJkz0adPH/zwww+5njthwgRs2bIFGzZsgJmZGUaNGgVXV1cAr+d7WrlyJS5cuIAVK1Zo+mWVugMHDuDFixdITExEZmYmgNcXLsTFxSEtLQ1GRkYSJyQiKj7WBt3HTg4iKpMCAwPh7u6OrVu3csI7Ih0gl8tVHRR5DYOVmZmJmJgY3L17N0cnyO3bt3Hq1Cncv38/x5WGdnZ2cHJyQpUqVVC1atUcHSDOzs6wt7fPd9I4Kr61a9ciICAAK1euRNeuXTW+/19++QUpKSkYPXo0/P398cEHH+SaLJWIiHSbQqHApk2bsHfvXvz888+YO3cunj59CisrKzRt2hS//vorvL2983yuhYUFzp49iyVLlmD37t349ddf8eLFC5iZmaFmzZrw9vbG+fPn8x13/c3hNrO+F0Ko90WqUUZGBubMmYM5c+ZAJpNBqVTmWn/q1Cm0a9dOooRERCXH2qD72MlBRGVS7dq10b9/f0yfPh09evTglUVEOs7AwEDVSeHp6ZnnNk+fPkVMTAwePnyI27dvq76+du0a9uzZg/v37yMjI0O1vbW1NSpXrgwHB4d8/3V2dmZnSCHt378fI0eOxIwZMzBq1ChJMqxbtw6+vr6wtrbGiRMnMGPGDElyEBGR9Dp37lysoUMsLS0xY8aMYtWQsnbCKjo6Gr169cKFCxcghMgzv4GBAXbu3MlODiLSCawNuoudHERUZs2ePRu1a9fG+vXr4e/vL3UcIpKYtbU1rK2t4ebmluf6jIwMxMTE4P79+4iKisKjR48QFRWF2NhY3Lt3D2FhYYiOjsaLFy9Uz1EoFKhUqRKcnJxUd4fY29vD0dER9vb2quV2dnaaepla6e+//0bv3r3Ru3dvzJo1S5IM165dQ1hYGL799ltcunQJCQkJPCGjRYKDg/H9998jIiICiYmJquVv/tGX/Uo3/kFIRFS6pk+fjnPnzhW4TWZmJkJCQrB8+fJcVyNT0bEeEhGVDnZyEFGZ5ezsjOHDhyMgIAB+fn4wMzOTOhIRaTFDQ0NUrVoVVatWLXC758+fIzo6GrGxsbn+vXr1Ko4cOYIHDx7k6gzJ6gTJ/m+VKlVQqVIl1b8VK1bUuXmEoqOj4e3tjWbNmmHDhg2SnQBZv349nJ2d8eGHH+K7776DnZ0d6tWrJ0kWbZd1N1RoaKhG9hcUFITBgwfDy8sLly9fhr29Pfbu3YsePXrk2lYIwZNoREQasmzZMhgZGWHNmjWQy+W5hqrKEhcXh7CwMHh4eGg4YeliPSQi0h3s5CCiMm3GjBnYuHEjVqxYgS+++ELqOESkA8qVK4c6deqgTp06BW738uVLPHz4UDUsVvZ/b9y4gePHjyMmJibHVXrA64nTs4bEyrr7xNraOtcyBwcHODk5afVwfKmpqfD19YWVlRV27NgBhUIhSY6MjAxs2rQJI0aMgFwux7Fjx9CuXbs8Tw48ffoU1tbWEqTUHvmdxCotixcvBgAsWrQIzs7OAABfX19emZqHpUuX4rfffpM6BpHa8f+7dipfvjxWr14NX19fDBkyBE+fPkV6enqu7YyMjLBz506d6+RgPdRerIe6Lzo6WuoIpGPYyUFEZVrFihUxbtw4zJs3D8OGDdP7E1dEpDmmpqaoXr06qlevXuB2z549w4MHDxAbG4vY2Fg8fvwYT548wZMnT/D48WNERUXh77//Vi3LzMzM8XwrKyvVXSC2trawtbWFnZ0dbG1tVcuyr9fkRNtjxozBjRs3cO7cuXwn2tOEffv24dGjRxg0aBCEEDh//jzmz5+fa7uzZ8+iZcuWaNKkCT7++GP06dMHNjY2EiSW1pkzZzS6v4iICABAzZo1NbpfIiIqHC8vL9y4cQNffPEF1qxZA5lMluPEe1paGoKDgxEYGChhSvVjPSQi0h3s5CCiMm/y5Mn46aefsHjxYsyZM0fqOEREOVhaWsLS0hJ169Yt1PZZnR1ZnSBxcXE5OkaioqJw8eJF1fevXr3K8Xxzc3NVh4eVlZXqzpCsr7P/++ayotyJsXjxYmzYsAF//PFHoV9baVm/fj3atGmD6tWr49atW3j27BkaN26ca7vExEQIIXDx4kX8/fffGD9+PDp27IjBgwfD29sbJiYmEqTXfS9fvgQAye70KUsmTJiAvn37Sh2DSO0MDAykjkBvYWVlhdWrV6Nbt27o1asXUlNTc3R03Lt3D9euXeNQkCXAelh4rIe6b8eOHejZs6fUMUiHsJODiMq88uXLY/LkyZgzZw7Gjh2r9xMAE1HZlnW3RmElJyfnukMkLi4OCQkJSExMxNOnT3H79m3V11n/5jVEg7m5eb4dItn/vXfvHmbPno1x48ahbt26iI+Ph5mZmUbvIskSHx+Pffv2Yd26dQCAy5cvw8DAAO7u7rm2zbpLRgih+vrAgQPYu3cvTE1N4evri8GDB6NNmzY6N3dKlvwmMs2+/P79+xg7diyOHTsGMzMztG/fHkuXLkWFChVKtL/8xhYv7DAdcXFxmDlzJnbv3o24uDhUrFgRnTt3xuzZs2Fvb1/kbERElFvnzp3h5eWFsLAwREdHq+7qUCgU+P3333Wmk4P1kIhIt7CTg4h0wvjx47F8+XLMmzcPS5YskToOEZHGWFhYwMLCoshDHzx79kzV6fFmB0j2fxMSEnD79u0cy1NSUgC8Hi956dKlqjZlMhmsrKxgbm4OMzMzVTYzMzOYm5vDysoKZmZmMDMzQ/ny5VGuXDmYmprCwsIClpaWqnXW1tYwMzODsbExLC0tC7wCePPmzTAxMUH37t0BvO7kqF27NszMzHJt++ZQYMDr+TwAICUlBdu2bcOvv/4KOzs79OnTB0OGDME777xTpOOq7fKbyDT78qlTpyIwMBAODg6YOnUqfvzxRygUCqxfv75E+3vz5E1RJlSNjY2Fh4cHUlNTERQUhBYtWuDSpUvw8/PDkSNH8Pfff8PKyqrI+YiIKLeXL1/i3XffRXR0NCwsLPDy5Uukp6dj69atmDZtmtTx1IL1kIhIt7CTg4h0gqmpKaZNm4ZPP/0UEyZMgIuLi9SRiIi0WtYwWlkTXxaGUqlEhw4dcPfuXRw8eBAZGRl4/vw5kpKSkJKSgpSUFCQmJuLFixdISUlBcnIynj17plp3584d1dfPnj3D8+fPkZKSgufPn7913yYmJjA1NYVcLkf58uVVryEyMhImJibo2rUr5HI5/v33XygUCgwbNgwGBgY5nve2CQ7T0tIAvD6B8OOPP2LZsmVwd3fH0KFDMWrUqEIfp7Ju+PDhqiHIJk+ejB9//BGHDh2SNNPMmTNx7949rF27Fh06dAAAeHp64vvvv4evry8WLFiAuXPnSpqRiEhXJCUlwcnJCQBw8uRJBAQE4Pfff8e///6L+/fvS5xOc1gPiYjKDnZyEJHOGDZsGBYtWoQ5c+aohi0hIiL1CQgIwOnTp3H27FnUqFFDrW3n1VGSlpammkcjJSUFr169Qnp6uqpTJDY2Fv/++y9atGgBZ2dnZGRk4MyZM6hevTru37+f43kZGRl49OhRofOkp6cDAK5evYpJkybBw8NDra9Xm2Wfz8TBwQEA8PDhQ6niAAB2794N4PXkuNm1bt1atZ4ndYiI1CMpKUl10Vi1atWwc+dOBAcH49NPP9WrTg7WQyKisoOdHESkMxQKBWbPno1BgwZh0qRJcHNzkzoSEZHOOHHiBObOnYsffvihVIZwKl++vOoOjcLasmUL5HI5goODYWVlBSEENm3ahMmTJ2PgwIG5tt+2bRv69OlTYJsymQyGhoZIT09HrVq10K9fPwwePFiv7hC0sLBQfW1kZASg8OOEl5a4uDgA/zvJ9KbIyEhNxiEi0mlJSUmqz/+s+bb69u2rdxNBsx4SEZUdujmjIhHprX79+qFRo0aYMmWK1FGIiHTGkydP0L9/f/j6+mrVsE1//PEHWrdurRp7+smTJ3j16hUcHR3z3F6pVOY77rVCoQAAuLq6Ytq0abh58yZu3LiBWbNm6VUHh7ays7MDACQkJEAIkevx4sULiRMSEemOpKQkmJiYAPhffSTtwHpIRJQ3dnIQkU6RyWRYuHAh9uzZg6NHj0odh4hIJ4wePRqGhoZYvXq11FFU0tPTceDAAfj4+KiWPXjwAAAK7OTIztDw9U3NdevWRUBAAG7duqXq2CjqRO5Uurp16wbg9R1FbwoNDUXz5s01nIiISDcplUo8f/4cxsbGkMlkkMt52kibsB4SEeWNw1URkc754IMP0LFjR3zxxRe4ePEifzEnIiqBzZs3IyQkBPv27SvycFKl6eTJk0hMTESXLl1Uy2JiYgDkP4SDUqlUDTPh6uqKgQMHok+fPqhdu3bpB6YSmTVrFg4dOoQxY8YgMzMTH374IYyMjHDy5ElMmDCBc3EREanJs2fPIISAsbGx6mIA0h6sh0REeWPFIiKd9N133+Gdd97Btm3b9G7sWCIidXn48CHGjRuH0aNHo2PHjlLHyWH37t2oX79+jqGk4uLiYG5ujnLlyuX5nDZt2mDevHnw9vaGu7u7pqJqlezDdclkMlWnT1GXa3p/tra2OH/+PL755htMnjwZ0dHRsLGxQdOmTbFp0yY0a9asSLmIiChvSUlJAF7PQaHLnRysh0REukV3KxYR6bX69evDz88P06ZNQ/fu3WFsbCx1JCKiMmf48OGwsrJCYGCg1FFy2bt3b65JxNPT01UTg+bFwcFB7+dsyu+kTFGXS7E/a2trLFq0CIsWLSpRJiIiyl9WJ4exsTEMDAwkTlN6WA+JiHQLx3AhIp31zTffIDY2Fj/++KPUUYiIypxff/0V+/fvx8aNG/O9M0IqUVFRiIyMRLt27XIsVyqVHKKQiJCamoqvvvoKNWrUgKGhIWQyWY6rot8ma/uiPIdIV+jLnRxEmsKaRKQZ/CuQiHSWo6Mjxo0bh9mzZyMhIUHqOEREZUZCQgImTZqEkSNHolWrVlLHyeXEiRMwMjKCh4dHjuXs5CAiAJg5cybmzp2LTz75BM+ePcPBgweL9PySXrFNVJZldXIoFAp2chCpAWsSkWbwr0Ai0mlTpkyBXC7HggULpI5CRFRmTJ48GXK5HHPnzpU6Sp5OnjwJDw8PmJmZ5VjOTg7NyH5FYUEPIqls3boVADBq1CiYmZmhQ4cOPElEVEiJiYkwNDSEXC5nJ8dbsB5SYbAmEWkG/wokIp1mZWWF6dOnY8mSJbh//77UcYiItF5oaCjWrVuHZcuWwcrKSuo4eTp9+jRat26da7mhoSHS09MlSKRfhBCFehBJJSoqCgBgY2MjcRKisuf58+ewtLSEUqnU6Tk51IH1kAqDNYlIM9jJQUQ6b8yYMXB0dMTMmTOljkJEpNXS0tLg7+8PLy8v9OrVS+o4eUpKSkJERASaNWuWa13lypXx9OlTvHz5UoJkRKQtlEql1BGIyqzU1FSYmJjwwgEiNWFNItIMdnIQkc4zMjLCnDlzEBQUhEuXLkkdh4hIa61YsQJ37tzB8uXLpY6SrwsXLkAIgXfffTfXOicnJwgh8ODBAwmSEZE2yD40TNZQMVOmTAHwupP0s88+Q/Xq1WFiYoIKFSqgRYsW+PzzzxEWFiZVZCKtkpaWBiMjI5iamvKiAaISYk0i0hx2chCRXujbty+aNm2KadOmSR2FiEgrJSQk4JtvvsGkSZPg4uIidZx8XbhwAVWqVEHlypVzrXNycgIAREdHazoWEWmJ7EPDZA0VExgYCAAYPHgwlixZggkTJiA+Ph4PHz7E+vXrcfv2bXh4eEgVmUirZHVymJiYIDU1Veo4RGUaaxKR5rCTg4j0gkwmQ2BgIA4cOIDDhw9LHYeISOt8/fXXUCgUmDx5stRRCnTp0iU0btw4z3UVK1aEsbGxauxjIqLsjh8/DgBwdHSEubk5jIyMULt2ba2+e41I09LT01V3cqSnpyMjI0PqSEQ6iTWJSL0MpQ5ARKQp77//Pjp37owvv/wSbdu2hVzOfl4iIgD477//sGrVKqxatQqWlpZSxynQ1atX0bNnzzzXyWQyuLq64urVq6W2/3PnznEiVqIyqkePHli/fj169eqFKlWqoEOHDujQoQO6devGyYE1gJ+fZUP24aqA13N0lCtXLtd2/HkSlQxr0mshISE8N6MB58+flzpCqWMnBxHplQULFqBhw4ZYv349hg4dKnUcIiKtMGnSJDRo0ACDBw+WOkqB0tPTcevWLdStWzffbTw8PHDhwoVS2b8QAkuXLsXSpUtLpX3Sb9nH7abSsW7dOnh7e2Pz5s04duwY1q5di7Vr16Jq1arYtWsXGjVqJHVEncXPT80qyedJWloaFAoFTExMAOTdycGfJ5UmfamHrEmv9e3bV+oIpCPYVUZaSZ96rUmz6tatC39/f0ybNg3Pnj2TOg4RkeRCQ0Oxf/9+zJ8/X+uvooqIiEB6ejrc3Nzy3aZly5Y4d+4cUlJS1L5/mUyGLVu2qMZU5oMPdT705aSO1Hx9fRESEoInT57g1KlT+Oijj3D//n18/PHHUkfTafz8LDufJ2/eyZE1+fjLly+xa9cunDlzhj9PPkr1oU/1kDUJyMjIkPw9pw+PkJAQqX/UeVLn/3ft/kuW9JK5uTlevHghdQzSYbNnz0ZmZqZqwi8iIn329ddfo3Xr1mjXrp3UUd7q+vXrkMvlqFWrVr7bdO7cGa9evcLRo0c1mIyIygKZTIbo6GgAgFwuh6enJ7Zu3Qrg9bB9RJS7kyMkJAQ9evSAjY0NunXrhlmzZkkbkEhHsCYRQXWRnVKpLHlbJW6BSM3Kly/PK+ypVFlbW+Prr7/GokWLcOvWLanjEBFJZv/+/Th58mSZ6fS9e/cuHBwcVENo5KVSpUrw8PBAcHCwBpMRUVkxbNgwhIeH49WrV4iNjcX8+fMBAB999JHEyYi0Q3JyMmJjYzFx4kQYGhpi0qRJ+OOPP5CamgoAMDY2ljghke5gTSJ9lzW3U2ZmZonbYicHaZ1KlSohJiZG6hik48aMGQNXV1dMmzZN6ihERJIQQmDWrFnw8fFB8+bNpY5TKFFRUahatepbt/v444/x22+/ISEhQQOpiEibZB/2QCaT5fj+9OnTsLe3h7e3NywsLFC7dm3s27cPc+fOxZYtW/Jtg0gfXL58Ga1atUJwcDDCw8Nx6tQp1TAyGRkZqu2y7vAgordjTSIqmDo7OTjxOGmdOnXqICoqCsnJybCwsJA6DukoQ0NDzJ8/H97e3jh16hRat24tdSQiIo3atWsXLly4gEuXLkkdpdDu3btXqE6Ovn374ssvv8QPP/yAmTNnaiAZEWkLIfKf269ly5Zo2bJlidog0lWxsbH4888/Ve//7B0bWeRyOe/kICoC1iSigmV1cuRVc4qKd3KQ1nFzc4MQAteuXZM6Cum4zp07o2PHjvj000/VMv4fEVFZ8t1336Fbt25o2LCh1FEK7cGDB3B0dHzrdhYWFvjss8+wZMkSxMfHayAZERFR2fbRRx9h7NixBV4pzk4OIiJSJw5XRTqtRo0asLOzw8mTJ6WOQnpg8eLFuHr1KjZu3Ch1FCIijTly5AjOnj2LL774QuooRRIfHw9bW9tCbTthwgSYmZnl+RqjoqJw9epVdcejMiQ4OBgeHh6wtrZWDR+R14m9gtYREemaRYsWwdLSUjUR7JtkMhk7OXQM6yERScnQ8PUgU+zkIJ0kk8nw4Ycf4ujRo1JHIT1Qt25djBgxAlOnTuWE90SkN+bNm4d27dqVmbk4siQkJMDa2rpQ21paWmLZsmXYsGEDdu/enWPd6NGj0bBhQwQEBKjl1uiCeHp6wtPTs1T3oQs0eZyCgoLQr18/VKhQAZcvX0Zqaip27NiR57YcIoKI9IlCoYC7uzsMDQ3z7OgoSScH62HhsB4SkT7hnRyk89q3b4/Q0FCedCaNmD17NjIyMvDdd99JHYWIqNSFhYXh2LFjmDp1qtRRiiQzMxPPnj2DjY1NoZ/To0cPDB06FH5+fvjvv/8AAOnp6Th69CiUSiXmzJmD9957D9evXy+t2FAqlTo/JKI6ruzU5HFavHgxgNdXLDs7O8PY2Bi+vr48gUNEhNdX1bZv3z7Pz0SZTAYTE5Nitct6WDish0SkT9jJQTqve/fuUCqV+V5FQKRONjY2mD59OhYtWoS7d+9KHYeIqFTNnz8fHh4eaNOmjdRRiuTFixdQKpWwsLAo0vOWL18Od3d3tG3bFjdu3MDZs2fx8uVLAK9/mQ4PD0eDgUjFDwAAIABJREFUBg0wf/78UjmpcObMGZw5c0bt7eoaTR6niIgIAEDNmjU1sj8iorKmWrVq+Oyzz1Qnn7Ir7p0crIeFw3pIRPokq6akpqaWuC12cpBWsra2hre3N3755Repo5CeGDt2LJydnTFlyhSpoxARlZq7d+9i165dmDRpktRRiixrWCmFQlGk5xkbG2Pfvn1wcXGBp6cnVq1aBSMjI9X69PR0pKenY9q0aWjTpg2ioqLUmpu0T1YnV1HfS0RE+kAul0OpVCIwMBBNmjTJ9VnJOTl0B+shEUnN1NQUwP8+j0qCnRyktT7++GOcOHEC165dkzoK6QGFQoEFCxZg69atCA0NlToOEVGpWLp0KZycnNC9e3epoxRZeno6gP9NTlcUlpaWOHToENq2bYvt27cjLS0t1zZKpRJnz55F3bp1sWrVqhLnBfKfpDP78qioKHTt2hUWFhaws7PDwIEDER8fX+L9xcTEoEePHrCwsECFChUwePBgJCUl4e7du+jSpQssLS1hb2+PIUOGIDExMVdbR44cQZcuXWBtbQ0TExM0btwYwcHBee7zzf0PGzYsz0yRkZHw9fXNMblpfscp+7LsywMDA0s0+WlB+yhqm3FxcRg1ahScnJxgZGQER0dHjBgxAo8ePSpyLiIibZHVyaFQKLB9+3aYm5ur5ucQQhSrk4P1kPWQiCgvZmZmAICUlJQSt8VODtJanTp1Qp06dVTjRBKVNh8fH7Rv3x6ffvqpWsYDJCLSJsnJyVi/fj3Gjh1brI4CqWV9Lhc3u7m5OVauXFngRONpaWl48eIFRo4cCV9fXzx58qRY+8qS35jW2ZdPnToVgYGBiI6ORo8ePbBp0yZ8/vnnJd7fl19+iW+++QbR0dHo168fgoKCMGDAAEycOBHz589HVFQUfH19sXHjRkyePDlXW+3bt4eBgQFu3ryJiIgI2Nraol+/fjh48GC++xRCQAiBNWvW5Ll+1KhR+PzzzxETE4N9+/bluU32ZVmdTcbGxggLCwMAdOvWDZUqVcKpU6eKNWZ4XnmzHkURGxuLpk2bYufOnVi3bh0SEhIQHByMQ4cOoUWLFnmeKCMiKguyOjkAoEqVKti0aZPqM7K4nRysh6yHRER5UWcnBwSRFvv555+FsbGxiImJkToK6YmIiAhhbGwsVq5cKXUUIiK1+v7774WZmZmIj4+XOkqxxMbGCgDi+PHjxW4jODhYyGQyAeCtD4VCIWxsbMSuXbtUz5fL5WLLli1F2mdWe/ktP3HihGrZnTt3BADh4OBQ7NeYV7sPHjzIc3lUVJQAIBwdHfNs586dO6rv//vvPwFAeHp65rvPt2Uq6GeXXxujRo1SZQwPDxc1a9YUGzZsyLedwnjbz6Qwy/39/QUAsXbt2hzLf/vtNwFATJs2rci5ivP+Iior+P7WrJIc748++kgMHTo0x7LJkycLAwMDIZfLxapVq1gPWQ9VWA+puEJCQgQAkZGRIXUUvaCtxzs5OVkAEHv37i1pU6t4JwdptUGDBqFixYqYM2eO1FFIT7i6umL8+PGYPn06Hj9+LHUcIiK1EEJg5cqV+Pjjj2FjYyN1nGLJusqnJOO1Hj58uNB3gqSnp+Pp06fo2rUrRowYoZZxYvPSuHFj1dcODg4AgIcPH6q1XXt7+wL3FxMTk+v5QghUq1ZN9b2rqysAlGgY0aZNmxb5OUuXLkXr1q3x4MEDNGrUCL169cLgwYOLnUFddu/eDQDw8vLKsbx169Y51hMRlTXZ7+TIMnfuXDRp0gRKpbLU5uRgPSwY6yER6SIzMzPIZDIOV0W6z8TEBLNmzcLq1atx/fp1qeOQnpgxYwbMzMwwbdo0qaMQEanFsWPHcPPmTYwcOVLqKMWmjluZ9+zZo5rbI4tcLoeRkRGMjY1hZGSkGncc+N9QDuvWrcPff/9d7P0WxMLCQvV11oToohjDThTUbvbXlNfyN/eXmJiIadOmoW7durCwsIBMJlN1DhV3fHTgfz/DolAoFNi2bRtMTU2RmZkJPz+/Yu9fneLi4gC8PjGWffxyW1tbAEBkZKSU8YiIis3AwCDX0I6GhoYICQmBk5MTnJ2dS2W/rIcFYz0kIl0kl8thYmKilk6OsjcgM+mdIUOGYNGiRfjqq68QEhIidRzSA+XKlcPChQsxYMAADB06FM2aNZM6EhFRiaxatQotW7aEu7u71FGKTS6Xw9zcHM+ePSvW81NTUyGTyWBtbQ0rKytUqFABtra2qFixImxsbGBtbQ0bG5t8vzYwMFDzK9JevXv3xuHDhzFz5kyMHz9edfdPcSY2VYclS5bAwMAASqUSPXv2RFhYGMzNzSXJksXOzg4PHjxAQkICrK2tJc1CRKROxsbGePXqVa7lTk5OiIqKkiCRdFgP3471kIhKyszMTC13zfNODtJ6BgYGWLRoEXbs2IEDBw5IHYf0RN++ffHBBx9g7NixnISciMq0J0+eYNeuXRgxYoTUUUqscuXKxR66wsTEBA8fPkRCQgJu376NCxcuYP/+/QgKCsKSJUswc+ZMjBs3DgMGDECnTp3QrFkz1KpVCxUrVtSrDg4AOHPmDABg0qRJqhM6eZ3wypJ1RWp6ejpSUlJUV2+qw8aNGxESEoJr167Bzc0N165dg7+/v9raL65u3boBAE6cOJFrXWhoKJo3b67hRERE6mFqalpqQzSWNayHb8d6SEQlVa5cOSQnJ5e4Hd7JQWWCl5cXevbsiZEjRyI8PFzyqxVIP/zwww9o1KgR1q5dqxMnB4lIP61duxampqbo2bOn1FFKzMHBIc/xskm9PD09cfDgQcybNw+TJ0+GUqnE3Llz892+QYMGOHfuHMLCwhAdHa22ExqnTp3C5MmTcfLkSVSpUgXbt2/He++9h02bNqFly5YYNWqUWvZTHLNmzcKhQ4cwZswYZGZm4sMPP4SRkRFOnjyJCRMmYN26dcVq99y5c3rXqUZE2sXU1BSxsbFSx9AKrIdvx3pIxXX+/HmpI5CWsLKyQlJSUskbKunU5USaEh0dLSwtLcWXX34pdRTSIxMnThQ2Njbi8ePHUkchIiqWWrVqifHjx0sdQy369u0runbtKtn+5XK52LJlS6G3B5DjUdzlmt5fbGys8PPzE5UqVRJGRkbC3d1dbN26Nd9sFy5cEA0bNhRmZmaiWbNm4saNG/nuI6/Xldf67N/36NFDXLp0qVBtaeoYCSFEQkKCmDhxonBxcREKhULY2dkJHx8fcfbs2SLnEkIImUyW52vkgw9deMhksiJ9flLJFLVeZTd+/HjRqlUrtbb/5vuhuMs1vT/WQ9ZDPkr/kZGRUaz3CRVNSEiI1h7v1q1bi7Fjx5a0mVW8k4PKDEdHRyxYsACjR4+Gj48PWrZsKXUk0gOzZs1CcHAwvvrqK/z0009SxyEiKpKwsDBERERgy5YtUkdRi1q1amHbtm1Sxyg0kc+EqUVdrun9VapUCUFBQbmW9+7dO8/tmzRpgsuXLxdpH2/bprDLikqdPxNra2ssWrQIixYtKnEu4PUY75s3b0bfvn3V0h6RNuEV2WVHaQxXxXrIelgUrIf6YceOHTpxpzmVnLru5OCcHFSmjBgxAl5eXvDz81PLeG1Eb2NhYYHvvvsOq1evRlhYmNRxiIiKZNOmTahTpw4aN24sdRS1cHNzw61bt5Camip1FCIiIgBAcHAwPDw8YG1tDZlMpnq8qaB12oRzchARlZyu1YbSZGVlhcTExBK3w04OKnNWr16N5ORkjBs3TuoopCcGDBiA1q1bY8yYMVAqlVLHISIqlMzMTGzbtg39+/eXOorauLu7IyMjA9evX5c6ChEREYKCgtCvXz9UqFABly9fRmpqKnbs2JHntuq4+l4TzM3N8eLFC6ljEBGVWbpYG0pT+fLl2clB+sne3h4bNmxAUFAQ1q5dK3Uc0hPLly/HP//8g/Xr10sdhYioUI4ePYpHjx7p1K3+tWrVgoWFBc6dOyd1FI3JfnVXQQ99xmNEREWlrs+FxYsXAwAWLVoEZ2dnGBsbw9fXt0yftLK2tsbTp0+ljpELP+vfjseIqGRYG6TBOzlIr3Xu3BlTpkzB2LFj8ffff0sdh/SAm5sbRo8ejS+//BLx8fFSxyEieqtNmzahWbNmcHV1lTqK2hgaGqJVq1Y4fvy41FE0RghRqIc+4zEiIqlEREQAAGrWrClxEvWxtrZGcnIyMjIypI6SAz/r347HiEg76GJtKE3ly5fnnByk32bPno1mzZqhd+/eSEhIkDoO6YGAgAAoFAp89dVXUkchIipQamoqdu3apVNDVWX54IMPcOLECf6RTkREksuau0KhUEicRH2sra0hhFDLVbVERPpIF2tDabKxsVHLxcTs5KAyy9DQEMHBwUhPT0fPnj2Rnp4udSTSceXLl8eiRYuwatUqnDlzRuo4RET52rVrF168eIHevXtLHUXtOnTogLi4OJw/f17qKEREVIoePXoEf39/ODk5wcjICE5OThg5ciRiY2NzbJffMDwFLX9zm2HDhhU5X17tFHdYoLi4OIwaNUr1Wh0dHTFixAg8evSoyLlKysbGBgC0csgqIiLWBmlqQ2mqVKkSXrx4gZSUlBK1w04OKtPs7Oywb98+/PXXXxg5cqTUcUgP9O/fH506dYK/vz/S0tKkjkNElKfNmzejXbt2sLOzkzqK2jVq1Aj16tVDcHCw1FGIiKiUPHr0CE2bNsWePXsQFBSE+Ph4bNy4Ebt27YKHh0eOk1n53dlXmOVZw/esWbOmyBnzaqc4wwHFxsaiadOm2LlzJ9atW4eEhAQEBwfj0KFDaNGihcbvqLC2tgYAjpZARFqHtUG62lCaKlasCOB1p05JsJODyjw3Nzds3LgRGzZswMKFC6WOQ3pg+fLluHv3Lt9vRKSVnj59ioMHD2LAgAFSRyk1vXr1wrZt25CZmSl1FCIiKgUzZsxAVFQU5s+fjzZt2sDCwgJt27ZFYGAg7t27h5kzZ/4fe3ceV1P+/wH8ddtTt4V2JUmJkDURwhSiMGPfwswgy1czZhhL1FgzGLsxtpFt7FsYSioiW5aU0GJtj/a0f35/zO/euVd7qnO7vZ+Px33Qved8zqvbqU+d9/l8PlxHrDUeHh548+YN1qxZg4EDB0JVVRV9+vTBpk2b8OrVK6xfv75e8whGcqSmptbrcQkhpDLUN3DXN9QlHR0dAEBKSsoXtSNXG2EI4dqIESOwceNGzJ8/H82aNcO0adO4jkSkmLGxMZYvX47ly5fjm2++gYWFBdeRCCFE6MSJE5CVlcWIESO4jlJnJk2ahJUrV+Ls2bMYNWpUvR57y5YtOHPmTL0ekzQOtM4MIf+5ePEiAGDAgAFiz9vb24u9Lg18fHwAAI6OjmLP9+3bV/j66tWra9T23bt38ddff0FHRwedOnWCo6MjlJWVK9xHVVUVGhoaeP/+fYXbUX9I6gr1h6Q81DfUTt8wbtw4REVFwdDQEBMmTMDYsWO/LOwXopEchHzmhx9+wNKlSzF9+nScPHmS6zhEys2fPx/t2rWDq6sr/RJGCJEoJ0+ehJOTE1RVVbmOUmdat26N4cOH47fffuM6CiGEkDoguJtTS0tL7HnBx196IUSSCD4XAwMDsTnbBZ9rTEzMF7UfFRWFs2fPYsyYMdDV1cWff/5Z6T5GRkZ49+7dFx2XEEJqG/UNtdM3ZGdnIyoqChcvXsS4ceOgpKTE6SgYFRUVNGnShEZyECJq5cqVyM7OxqRJk6CmpoZBgwZxHYlIKTk5Ofz555/o2bMnDh06BBcXF64jEUIIMjIycOPGDRw8eJDrKHXu559/hq2tLYKCgmBnZ1dvx3Vzc8O4cePq7Xik8ZCVleU6AuFAXl4eVq1ahb///htv3rwRTsPX2G+i0dHRQXx8PFJTU2FgYCB8XjCFkmBqCwEejwfGGAoLCyEvLw/g3z6xIdDV1UVcXBw+fvwoXA+jtvTo0QP+/v4A/r1gtmPHDsyZMwe5ubn48ccfy91PtMhRUFCAEydO4Ny5c9i3bx/U1dUBUH9I6g71h9yR9D6J+obaITriZf/+/Vi9ejVWrFiBS5cu4cGDB7V6rKrS1tamkRyEfO7333/HhAkT8M033+D27dtcxyFSrHv37pg9ezbmz5//xRVnQgipDZcuXQIADB48mOMkda9Xr15wcHDA/PnzUVJSwnUcQgipEQ8PD6xevRrffvstMjMzcfXqVa4jSQRnZ2cAEF6gF7h27ZrY6wJ6enoAgISEBOFzjx49Krf9Jk2aAAAKCwuRm5tb6q7g+iSYXjIwMLDUazdv3kTPnj1r5Tg6Ojr49ddfhY+0tLRytzUyMsKrV6+wbt06GBkZwcXFBadPn8bz589rJQshRDJJep9EfcO/arNv+PbbbxETEwM3NzeEhoZi5MiRtdJudeno6FCRg5DP8Xg87N69G/3798ewYcPw7NkzriMRKbZ69WooKytjwYIFXEchhBCcP38ednZ20NDQ4DpKvdiyZQuePn2K/fv3cx2FEEJq5Pjx4wCAWbNmoUmTJhg4cKDE3DHLpV9//RXGxsZYtGgRrl+/jqysLFy/fh2LFy+GsbExPD09xbZ3cHAAAKxfvx4ZGRl4/vw59u7dW277HTt2BADcu3cPPj4+tXaxqCY8PT1hZmaGOXPm4NSpU/jw4QOysrJw8eJFTJ06FV5eXrV6vDlz5iAzMxN3794t8/XY2Fi8evUKISEhcHd3R3JysvCclKapYAghpUl6n0R9Q931DZs3b4ajoyPOnDmDO3fu1GrbVWFgYID4+PgvaoOKHEQqycvL48SJE2jXrh0GDRqE2NhYriMRKcXn87Fr1y54e3sL7x4ghBAuFBYWwtfXF8OHD+c6Sr1p27Yt5s6di19++QVv3rzhOg4hhFSbYEqgpk2bcpxEsujq6uLu3btwdnbG5MmT0bRpU0yePBnOzs64e/cudHV1xbbfuHEjJkyYgOPHj6N58+ZYuHAh1q5dK3ydx+OJbb9t2zZYWVlh4MCB2Lx5MzZu3FjtjKJtfsn/tbS0cPfuXYwfPx4LFy6Evr4+zMzMsHv3bhw5cqTWp2TU0NCAtrZ2qfncQ0NDMXHiRJibmyMgIABFRUUoKioSvi4rK0uj1wmRcpLeJ1HfUHd9AwCcPn0asrKycHNzq/W2K2NkZIT3799/URu0JgeRWk2aNIGPjw+++uor9O3bF9euXYOFhQXXsYgUGjp0KEaMGIFZs2YhLCwMysrKXEcihDRCAQEBSE9Ph5OTE9dR6tWaNWtw/fp1jBkzBjdv3oSCggLXkQghpMpour3y6erqYteuXdi1a1el22ppaeHIkSOlni/vDuRu3brh8ePHX5SvvLar+zwAaGpqYuPGjTW6oFYTBQUFUFRUFH68ZMkSrF27FvLy8iguLhbOwy9KTk6OihyESLmG0CdR31B3lJWVYWtry8nU/82bNxdOvVxTNJKDSDV1dXX4+/ujZcuWsLOzw5MnT7iORKTUzp07kZqaitWrV3MdhRDSSJ0/fx6dOnVCy5YtuY5Sr5SUlPD3338jIiICP/zwA9dxGpS8vDy4u7vD1NQUcnJy4PF4pe5oI6S25OXlwcvLC507d4aKigqUlJRgYWEBV1fXUtMiJCYmYubMmTA0NISCggIMDQ3h6uqKpKQkse0E5yyPx0NMTAy++eYbaGpqljqXk5OTMWvWLGF7zZs3x4wZM5CYmFgqZ0REBIYMGQJVVVWoqalh0KBBePbsmdixPj82j8cTW8Rz+/bt4PF4YtPmHj58uMw2Pv9cFi1a9AXvMiGVy8nJQWZmJrS1tYXPDRkyBAoKCmUWNwQYY1I7XRX1h40P9UnUJ5GyDRkyBEVFRXj69Gm9HtfQ0BBxcXFfVmhjhDQCOTk5zMHBgWloaLCQkBCu4xAptW3bNiYnJ8ceP37MdRRCSCNTUlLCjIyMmIeHB9dROHP69GkmKyvLFi9eXGfHkJGRYX///XedtV/fFi5cyACwVatWsZycHHb16lVGfx5wR9rOL1GZmZmsW7dujM/nsz179rDExESWlZXFAgICWNu2bcXOu4SEBGZkZMQMDAyYv78/y8zMZNeuXWN6enrM2NiYJSYmirUNgAFgDg4O7NatWyw3N5ddvnxZ2GZiYiIzNjZmurq67OrVqywrK4vduHGDGRsbMxMTE5aWliZsKzo6mmloaAiPnZWVxYKDg5mtra3wOKKGDRvGALDNmzeLPd+9e3cGgC1atEjs+YMHDzInJ6cy80s7aT6/JVFF73dwcDADwF6/fi32vK+vL5OTk2M8Hk94Xoo+ZGRk2OTJkyttvyGi/lCy1PX5RX3Sv7juk06dOsUAsKKiono5XmNX1ff7yZMnZZ5HdS0wMJABYAkJCTVtYjf91CaNRl5eHhsxYgRTUVFh/v7+XMchUqi4uJj16NGD9ejRgzpqQki9Cg0NZQBYaGgo11E45e3tzWRkZNjSpUtZSUlJmdskJiayVatWseTk5Gq3L20XdYyNjRkA9uHDB66jECZ955eo+fPnl/sH88OHD8UuqEyfPp0BYIcOHRLb7sCBAwwAmzlzptjzggsyAQEBZR575syZDADbt2+f2PNnzpxhANiSJUuEz02aNKnMY1+6dKnMCz+CNqysrITPPX/+nCkpKTEAzMjISOxn0YABA9ipU6fKzC/tGsr5XdbF/bIekq6i9/u3335j2traZfaTZ86cYTIyMuV+3g4ODpW23xBRfyhZ6vr8oj7pX1z3SQ2pyCENfUNV3+/4+HgGgC1btqyekv0rOjqaAWD379+vaRO7aboq0mgoKiri+PHjcHR0hLOzM3x9fbmORKSMjIwMDhw4gCdPnmDDhg1cxyGENCLnz59H8+bN0blzZ66jcMrFxQV79+7F+vXrMWbMGOTk5JTa5sKFC3B3d4eJiQl+++035OXlcZBUMkj64pJEepw6dQoAMGLEiFKvde7cWWw+asEUGwMGDBDbzt7eXuz1z1lbW5f5vI+PDwDA0dFR7Pm+ffuKvQ4Afn5+ZR67V69eZbbt5OQELS0tPHnyRDiHt7e3N/73v//B2NgY7969Q2BgIADgzZs3CAsLg7Ozc5ltEcnAGKvSoyG7evUqBg4cWOZ0TF9//TX++uuvcqdqio+Pr+t4nKD+sHGhPon6pOpqDH2DgGB9w+zs7Ho9bvPmzcHj8b5o8XEqcpBGRUFBAceOHcOYMWPg7OyMM2fOcB2JSBkLCwt4eHjAw8MDERERXMchhDQSFy5cwIgRI2j+aADTpk2Dn58fAgMDYWNjg3v37om9Hh4eDnl5eeTk5GDJkiUwNTXF8ePHpeYPk+poCItLEumQkJAAANDT06t0W8HCxlpaWmLPCz4ub02AJk2alPm8YHsDAwOx+ccF7cXExAi3TU1NLfPYGhoaZbYtLy+P8ePHAwAOHDiAkpISHD58GFOmTMGkSZMAAIcOHQLw74WmcePGCS8eEMKF9PR0BAcHY9CgQeVu4+Ligq1bt5b5muB7RNpQf9i4UJ9EfRIpn+C809XVrdfjKikpQUtLi4ochFSHrKws9u3bh2nTpmHcuHH466+/uI5EpMyCBQtgZWUFFxcXFBYWch2HECLl3r9/jydPntCdWCL69u2L+/fvQ1dXF7169YKbmxvS09MBAKGhocKfzcXFxUhMTMT48ePRpUsX3Lx5k8vYFartxSwrW1yyOu3Udi7B4927dxg+fDj4fD50dXUxadIkfPjwodR7U53FQ6uz2CepPYI/lAUXliqio6MDoPTFVMHHgtere+yPHz+Wedel6IgvwYWk8o5dlilTpgAAjh49Cl9fX2hra8PS0hIuLi4A/r1jODc3F97e3pg6dWq1shNS206dOgUej4dhw4ZVuN3cuXOxYsWKUjdPpKWl1WW8KqH+kPrDL0V9EvVJpHyvX78G8O9C4PVNsPh4jdV0oitCGrqSkhLm7u7OeDwec3d3L3fubkJqIjIykikpKTEvLy+uoxBCpNzevXuZkpISy83N5TqKxCkpKWEHDhxgzZo1Y2pqamzRokVMTU2tzDl0ZWVlGQA2ZMgQFh0dXWZ7XM9BLshaG4tZirb3uZq2U9u5Jk6cyJ49e8bS09PZrFmzGAA2depUsW2rs3hodXPUN67Pr7rk5ubGALBNmzaVei0kJIRZW1sLPxbMV37w4EGx7QTzn7u6uoo9X955LDBnzhwGgJ05c6bUazdu3GA2NjbCjydPnlzmsc+dO1fhcdq3b88AMGNjY7E53nv06CGcs719+/Zl7ltZfmkhzee3JCrv/e7Xrx8bNWpUldtZuHBhqYXIMzMzOf96Un9I/eGXoD5JMvqkhrQmhzSo6vvt7u7OALBnz57VU7L/DBs2jE2cOLGmu9PC44T89ddfTF5eno0ePZp9+vSJ6zhEiqxdu5YpKiqyp0+fch2FECLFxo4dywYNGsR1DImWkZHBvLy8mLa2dqULBsrLyzNZWVk2b968Un/kS8pFndpYzFK0vdpqp7ZzBQYGCp979eoVA8AMDAzEtq3O4qHVzVHfuD6/6lJaWhpr37494/P5bPfu3cKLb1euXGFmZmbs2rVrwm0FF98MDAyYv78/y8zMZP7+/kxfX58ZGxuzxMREsbYruyCTkpLCzMzMmL6+Pjt58iRLTU1lmZmZzMfHh7Vq1UrsPIuJiWEaGhrCY2dlZbGbN28yR0fHCo+zfv16BoDJycmx5ORk4fM7duwQ7rdhw4Yy96UiB6kLZb3fcXFxTFZWlp09e7bK7ZSUlLCZM2eKLUYeExPD+deT+kPqD78E9UmS0SdRkaN+VfX97t+/P5ORkeHk6zJ79mxmZ2dX092pyEEIY4xdu3aNqaurs169erGUlBSu4xApUVxczGxtbVmXLl1YQUEB13EIIVKouLiYaWtrs40bN3IdpUG4cOFCpUUO0WKHmpoa8/LyYvn5+Ywx7i/SCbLl5OSU+bqBgQEDwOLj48WeT03Ra2X2AAAgAElEQVRNZQBYhw4dymyvttqp7VyZmZnC5/Lz8xkAxuPxxLZt0aIFA8Bev35d5rG/JEd94/r8qmtZWVnM3d2dtWnThikoKLBmzZqxgQMHshs3bpTaNjExkc2cOZMZGBgwOTk5ZmBgwGbMmFHuxSTRR1k+fvzI5s+fz0xMTJi8vDzT1dVlzs7OLCQkpNS24eHhzNHRkamoqDA+n8+cnJxYTEwMA8BkZGTKbD8hIYHJyckxJycnsec/fPjAFBQUmJycXKns1ckvDaT9/JY0Zb3fv/32G9PU1GR5eXnVaqu4uJiNGzdOOKIjJCSE868n9YfUH34p6pO475OoyFG/qvp+a2lpMT09vXpKJW716tXM1NS0prvv5jHWCFdZJKQMERERGDp0KOTl5XH58mWYmZlxHYlIgefPn6Nz587w8PAQm9uVEEJqw/3792FtbY2nT5+iffv2XMeReBs3bsTixYurvV6Sqakp/Pz80Lp1axw5cgTjxo2ro4QVE8zpXd6v7/Ly8igqKip3/yZNmojN9Vxee7XVTm23V9bzCgoKKCwsRF5eHhQVFcs9Rk1y1DdZWVlOzy9Svvj4eDRv3hw6OjpISkriOk6DROd3/Srr/e7UqROsra2xe/fuardXWFiIr7/+GpcuXcKFCxcwYsQI6g+r0U5tt0f9YeMmLX3S6dOnMWrUKBQVFUFWVpbrOFKvKu93UlIS9PT0MHr0aJw4caKeEwKHDh3C9OnT8enTp1JrQlXBHlp4nJD/Z2lpiZCQEKirq6Nnz54IDg7mOhKRAhYWFvD09ISnpyfCw8O5jkMIkTJXr16Fnp4eLC0tuY7SIISHh5d74QH496KBgoICZGRkhB8bGBigTZs29RXxi1RnMcv6aKeu2iur7aosHlqXOYj04PF4iI6OFnvuxo0bAID+/ftzEYmQL/b48WM8efJEuPhwdcnLy+PUqVP48ccfG8RNFdQfcpeD1C7qk0h9Onz4MABg2rRpnBzf0NAQ+fn5SE1NrdH+VOQgRIS+vj4CAwNhY2ODQYMG4ezZs1xHIlJgwYIF6NatG1xcXKp99zAhhFTEz88PgwcPrsmdLo1SaGgoioqKwOPxIC8vL3zfZGRk0KJFCzg5OeGnn36Ct7c3QkNDkZ2djbi4OFy6dAkmJiYcp6/ciBEjAACBgYGlXrt58yZ69uxZr+3UVXuiRo4cCQA4d+5cqdfu3LmDHj161EsOIl3mzJmD2NhY5OTkwN/fH7/88gvU1NTg6enJdTRCauTgwYMwMTGBra1tjdtQUlLC77//Tv1hDdqpq/ZEUX8ovahPIvVl7969kJeXx1dffcXJ8Y2MjAAAb9++rVkDNZ3oihBpVlRUxGbNmsVkZGSYp6cnKykp4ToSaeAiIyOZkpISW7NmDddRCCFSIjMzk8nLy7MjR45wHaXBsLW1Za1atWLffPMNW7ZsGfv777/Z48ePqzw/uaTMQV6e6ixmWVF7tdVObbdX1vPVWTy0ujnqG9fnF/nXtWvX2DfffMN0dXWZnJwc09bWZmPGjGGRkZFcR2vQ6PyuX6Lvd2FhIdPT02Oenp510j4XqD+k/rCxkOY+idbkqF+Vvd9JSUmMx+Mxe3v7ek72n4KCAiYrK8tOnDhRk91p4XFCKvLnn38yBQUFNnToUJaWlsZ1HNLAeXl5MUVFRRYWFsZ1FEKIFDh//jyTkZFhSUlJXEdpNLj8o1twQUP0UZaqLmZZWXu11c6XtlfZ84xVb/HQ6iz2Wd/oog6RZnR+1y/R99vHx4fxeDwWHR1dJ+3XN+oPqT8k0oGKHPWrsvd73rx5DADz9/ev52TiWrZsydauXVuTXWnhcUIqc/v2bYwaNQqqqqo4e/YszXtOaqy4uBi2trYoLi7G7du3IS8vz3UkQkgDNnfuXNy5cwcPHjzgOkqjQQthkrpE5xeRZnR+1y/R93vChAl4//69cB7/2m6fkNpG51fjQAuP16+K3u+ioiJoaGhAWVkZycnJnE6FbG9vDxMTE+zZs6e6u9LC44RUplevXnjw4AG0tLTQs2dPnDlzhutIpIGSlZXFgQMH8OzZM3h4eHAdhxDSwPn6+mLgwIFcxyCEEEKIhMrPz8elS5cwZswYrqMQQgiRUHv37kVOTg4WLlzI+VqPpqamiImJqdG+VOQgpAoMDAwQEBCAcePGYdSoUVi0aBFKSkq4jkUaIAsLC2zcuBHr1q1DQEAA13EIIQ3U69evERUVBQcHB66jEEIIIURC+fv7IysrC8OHD+c6CiGEEAlUXFyMpUuXQllZGfPmzeM6DhU5CKkPioqK2L17N3bt2oVNmzbB2dkZ6enpXMciDZCrqyucnJzg4uKCjx8/ch2HENIA+fn5QUVFBba2tlxHIYQQQoiEOnfuHLp27QojIyOuoxBCCJFAmzdvxsePH7F48WIoKipyHQempqZ4//498vPzq70vFTkIqaYZM2YgICAAjx49Qs+ePREZGcl1JNIA7du3D8XFxZg5cybXUQghDVBAQAB69+4NBQUFrqMQQgghRAIxxuDj44MRI0ZwHYUQQogEys3NxfLly6GhoYHFixdzHQfAv0WOkpISvHr1qtr7UpGDkBoQrNOhqakJa2trHDx4kOtIpIHR0tLCgQMHcPr0aRw6dIjrOISQBiYoKAj9+/fnOgYhhBBCJFRUVBQSExOpyEEIIaRMU6dORW5uLnbu3Ak5OTmu4wAAWrduDQA1mrKKihyE1JCBgQFu3LiBn376CdOmTYOLiwtycnK4jkUakIEDB2LevHmYPXs2oqKiuI5DCGkgIiMjER8fT0UOQgghhJQrIiICRkZGsLS05DoKIYQQCXP//n2cOnUK3bt3x/jx47mOI6SqqgptbW0qchBS3+Tk5ODp6YmrV6/C19cX3bp1Q1hYGNexSAOybt06mJqaYurUqSguLuY6DiGkAQgICACfz0eXLl24jkIIIYQQCfXy5Utau4sQQkgpBQUFGDRoEOTk5HDhwgWu45TSunVrKnIQwhV7e3s8ePAAWlpa6NGjB7Zs2cJ1JNJAKCoq4siRI3j06BFWr17NdRxCSAMQEBCAvn37SsyQYkIIIYRInujoaNjY2HAdgxBCiIRxcnJCWloa9u7dCz09Pa7jlGJqakpFDkK4ZGhoiICAAPzyyy+YP38+Jk+ejOzsbK5jkQbA0tISa9euxcqVKxESEsJ1HEKIBGOM0XochBBCCKlUdnY2TVVFCCFEjIeHB/z8/DB8+HC4uLhwHadMNS1y8BhjrA7yENKo+fv7Y9KkSVBTU8OJEydgZWXFdSQi4RhjcHZ2RmRkJB49egQ1NTWuIxFCJFBYWBisrKwQGhpK01VxQFFREQUFBVzHIIQQQqrk1atXaNmyZa23S/0hIYQ0PDIyMmCMwdzcHJGRkeDxeFxHKtOhQ4cwffp05OTkQFZWtqq77aEiByF1JC4uDhMnTsS9e/ewadMmzJw5k+tIRMIlJyejY8eOcHR0xF9//cV1HEKIBNqyZQs8PT2RmppanV/4SC0JDg5GQkIC1zEIIYSQCt29exebN29GXl5enUxvSf0hIYQ0LMHBwdi2bRuaNm2Kt2/fokmTJlxHKtft27dha2uL169fw9jYuKq77aHJnAmpI82bN4e/vz88PT0xe/ZsXLlyBbt374a2tjbX0YiE0tHRwe7duzF8+HA4ODhgwoQJXEcihEiYgIAA9OvXjwocHOnduzfXEQghhJBKxcfHQ1tbu87W76L+kBBCGo49e/Zg27Zt0NDQwPPnzyW6wAEAZmZmAICoqKjqFDloTQ5C6pKsrCxWrlyJ4OBgPH36FO3bt4ePjw/XsYgEGzZsGObNm4cZM2bg2bNnXMchhEiQkpIS3Lhxg9bjIIQQQkiFkpOToaury3UMQgghHCouLsbcuXMxY8YMNG3aFC9evICWlhbXsSqlra2Npk2b4uXLl9Xaj4ochNSDnj174uHDhxgxYgSGDx+OmTNnIicnh+tYREJt2LABVlZWGDNmDJ0nhBChR48eIS0tjYochBBCCKlQUlISFTkIIaQRe/nyJXr16oWdO3dCT08PERERDWpmGTMzM0RFRVVrHypyEFJP1NTU8Oeff+LEiRM4deoUunXrhtDQUK5jEQkkLy+PY8eOISkpCdOnT+c6DiFEQgQGBkJLSwvt27fnOgohhBBCJBgVOQghpHEqLCwU3jgbHh4OQ0NDhIaGNrg+wdzcnEZyECLpRo0ahYiICJiYmMDGxgaenp4oLi7mOhaRMEZGRvD29sbx48exb98+ruMQQiRAYGAg7OzswOPxuI5CCCGEEAlGRQ5CCGl8rl69io4dO8Ld3R1aWlrQ1NREUFAQDAwMuI5WbWZmZlTkIKQh0NPTw6VLl7BhwwZ4eXmhd+/eiI6O5joWkTBDhgzBL7/8grlz5+Lhw4dcxyGEcKikpATBwcGws7PjOgohhBBCJFxSUhJ0dHS4jkEIIaQehISEYODAgRg8eDBatWqFli1bQlZWFoGBgTAxMeE6Xo2Ym5vj1atXKCgoqPI+cnWYhxBSAR6PBzc3N9jb22PSpEno2rUr1q9fjxkzZnAdjUiQlStX4v79+xg7diwePHgAdXV1riMRQjjw5MkTpKenU5GDEEIIIZWihcelU1FREZKTk5GQkICEhAQkJibiw4cPyMzMRHZ2NrKyspCdnY20tDThPoWFhcjOzhZ+rK6uDhkZGcjIyAj/r66uDk1NTaipqUFdXR3q6upo2rQpDAwMoKOjAx0dHcjJ0eVDQiTNjRs34OXlhX/++Qe2trY4fvw4li5dCllZWQQHB8PQ0JDriDVmbm6O4uJixMbGwsLCokr70E8pQjhmaWmJkJAQLFmyBK6urrhy5Qr++OMP+qWUAABkZWVx+PBhdO7cGVOmTMHZs2dpqhpCGqGgoCA0bdqU1uMghBBCSIUyMjKQl5dHf082UDk5OXj+/Dmio6MRHR2NqKgoREVFITY2FsnJySgpKRFuq6amBi0tLfD5fKiqqoLP54PP58PExET4NyOPx4OGhoZwH0EBRFD8KCwsRExMDNLT05GRkYGMjAxkZmYiPz9fLJeOjg60tbXRsmVLtGjRAsbGxmjRogVatGgBU1NT6Onp1cO7QwgpLCzEmTNnsHHjRty/fx+2tra4evUqWrVqha+++goaGhrw9fVt8H2Aubk5eDweXr58SUUOQhoSJSUl/P7773BycsL3338PS0tLbNu2DePHj+c6GpEAurq6OHr0KOzt7bFt2zbMmzeP60iEkHoWFBSEPn36QEaGZholhBBCSPmSkpIAoMFf4GoM0tPTERoaikePHgkfL1++RHFxMeTk5NCyZUu0bt0aXbp0wdixY2FgYAA9PT3o6+tDX18fTZo0qbNs2dnZiIuLQ0pKCpKSkpCQkICkpCS8efMGERERuHz5MuLi4lBUVAQA4PP5MDMzg7m5OczMzNCmTRtYWlqiXbt2UFBQqLOchDQWkZGR8Pb2xoEDB5CSkoIhQ4YgODgYtra2iIiIQN++fWFoaIgrV66gadOmXMf9YioqKjAwMKjWuhxU5CBEggwYMADh4eFYsWIFJk2ahCNHjuDPP/9E8+bNuY5GONavXz94enri559/Rrdu3dCrVy+uIxFC6gljDMHBwVi8eDHXUQghhBAi4ajIIbmSkpJw8+ZN3LhxA0FBQQgPD0dJSQn09PTQpUsXfPPNN+jSpQs6duwIY2NjyMvLc5ZVVVUVbdq0QZs2bcrdpri4GPHx8YiJicHLly8RFRWFly9f4uTJk4iNjUVBQQHk5eXRtm1bdOzYER07dkSnTp3QsWNHOj8JqYKMjAwcP34cBw8exK1bt2BoaIipU6di5syZwrU2rl+/jpEjR6Jjx47w8fGBmpoax6lrj5mZGaKioqq8PY8xxuowDyGkhoKDg/Htt98iJSUF69ato7U6CEpKSjB06FBERETg4cOH0NLS4joSIaQehIeHo0OHDnjw4AG6du3KdRxCCCGESLBTp05hzJgxyM/P5/QiOfl3DY2bN2/Cx8cHV65cQWRkJGRlZdGpUyf07dsXdnZ2sLa2hr6+PtdRa11hYSFevHiBsLAwPHnyBE+ePEFYWBgSEhIA/FuEEy16dO3aFRYWFjQ1M2n0MjIycOXKFZw9exbnz5+HjIwMRo4ciWnTpqFfv35i3yMHDhzAjBkzMHLkSBw4cACKioocJq99M2fOxMuXLxEQEFCVzfdQkYMQCZabm4sVK1Zg/fr1GDx4MHbv3k2jOhq51NRUdOnSBR06dICPjw9NXUNII7Bjxw4sWbIEHz9+hKysLNdxCCGEECLBduzYAU9PT6SkpHAdpVHKyMjAP//8gwsXLuDKlStIS0tD27Zt4eTkhH79+qF3795Sdad1daWkpAgLH2FhYQgLC0NERAQKCgqgqamJHj16wMbGBjY2NujRo4fYeiKESKt3797hwoULOH/+PIKCglBSUoLevXtj/PjxGDduXKmfGYwxLF++HKtXr8bixYuxatUqqSwQbtiwAZs2bUJcXFxVNqciByENAY3qIKLu3LmDfv364ccff8TatWu5jkMIqWNjxoxBTk4OLl26xHUUQgghhEg4Dw8PnD59GuHh4VxHaTSKi4sREBCAgwcP4syZM8jLy4ONjQ2cnZ0xbNgwtG3bluuIEq2oqAgvXrzArVu3EBwcjNDQUERGRoIxhlatWsHW1hZdu3ZF165d0aNHDxqhRBq8oqIiPHz4UFgQffjwIfh8PgYPHoxhw4ZhyJAh5a6rkZ+fj++//x7Hjh3Dtm3b4OrqWs/p68+FCxcwYsQIZGRkgM/nV7Y5FTkIaSg+ffqEX3/9lUZ1EADAoUOHMGXKFBw+fBgTJkzgOg4hpA4ZGBjghx9+wMKFC7mOQgghhBAJ5+rqiqioKPj7+3MdRerdv38f3t7eOH78OD58+IA+ffpg8uTJGDlyJDQ1NbmO16AlJyfjzp07uHPnDkJCQvDgwQNkZ2eDz+fDxsYGdnZ26NevH7p3704LmxOJV1xcjOfPn+PWrVu4du0arl27hrS0NOjo6GDQoEEYPXo0Bg4cWOl0U3FxcRg9ejSePXuGU6dOwd7evp4+A248f/4cbdu2xcOHD9G5c+fKNqciByENTWBgIL777jukp6dj8+bNmDx5MteRCEd+/PFH7Nq1Czdu3ED37t25jkMIqQMvXryAhYUFQkJCYGNjw3UcQgghhEi4r7/+GsrKyjh69CjXUaRSfn4+Tpw4ge3bt+PevXto27YtJk2ahIkTJ8LY2JjreFKruLgY4eHhCAkJwa1btxAQEIC4uDg0adIEvXr1EhY9rK2tqehBOFdYWIiwsDAEBQUhICAAN2/eREZGBnR0dNCvXz/hozqjvAIDAzFu3Dg0bdoUp0+fbhQjxAoKCqCiooLDhw9j7NixlW1ORQ5CGqKcnBwsXrwYO3bswFdffYVdu3ahVatWXMci9ay4uBjDhg3D48ePcf/+fRgYGHAdiRBSy3bv3o358+cjLS2NhuYTQgghpFK9evWCtbU1Nm/ezHUUqZKYmAhvb29s27YNiYmJcHR0hJubm9TfSS3J4uPjhXfG+/r64vXr11BWVkaXLl3Qu3dv2Nvbo3fv3lBSUuI6KpFy8fHxCA0NFU659ujRI+Tm5kJbWxs9evQQno9dunSp9toZjDFs3boVCxYswJAhQ+Dt7Q11dfU6+kwkj5mZGVxcXLBs2bLKNqUiByEN2cOHDzF9+nRERkZi4cKFWLJkCd210MikpaWhR48e0NLSQkBAQKXDGwkhDcvEiRORkpICX19frqMQQgghpAEwNTXF999/j8WLF3MdRSrExsZi7dq1OHjwIDQ1NTFjxgy4urrSDWYSKCYmBkFBQQgMDERgYCDevXsHZWVl9O3bFwMHDoSDgwM6dOjAdUzSgJWUlODVq1fCG03v37+P0NBQZGRkQEFBAZ06dUL37t2Fj7Zt237RguBZWVmYNm0azp8/Dy8vL8yfP18qFxivyNChQ9GsWTMcPHiwsk2pyEFIQ1dYWIjff/8dnp6eMDc3x549e2Btbc11LFKPXrx4gR49emD48OHw9vbmOg4hpBYZGRlh5syZcHd35zoKIQ1Keno6qvtnTnZ2NgoLC6u1T15eHj59+gRlZeVq3SnapEmTat2YoKKiQjeyEEKqRFVVFVu3bsW3337LdZQG7eXLl1izZg2OHDkCY2NjLFmyBBMnTqSbyhqQ2NhYBAQEwM/PD/7+/khNTYW+vj4cHBwwcOBA2NvbQ1dXl+uYRELFx8cjPDwcT58+RUREBJ4+fYrIyEjk5ORAVlYWFhYWYgUNKyurWv1dLSQkBC4uLsjOzsaxY8dgZ2dXa203JD/++CNCQkJw586dyjalIgch0iImJgaurq64fv06vv/+e2zcuBGqqqpcxyL15OrVqxg6dCh+//13zJs3j+s4hJBaEBMTg9atW+PmzZvo3bs313FII8AYQ3p6OoD/igSZmZkoLi4WFgByc3ORn58vvLgP/Ds/eW5urrCdjIwMlJSUAPh3Lt2cnBzha4L2KnutsLAQ2dnZVXqNiFNQUICKiorYc2UVVdTU1CArKyv8mMfjQUNDQ2wbeXn5Ur9PllXQUVVVLTWlnoaGhtjdhqLbiGb8/Lh8Ph9ycnIAAEVFRTRp0gQAICMjIzY9g+h2hJB/5eTkQFVVFRcvXsTQoUO5jtMgRUdHw8PDA8ePH4eZmRmWLFmC8ePH08+bBq6kpAQPHz6Er68v/Pz8cPv2bRQWFsLKykpY9KCprRqfoqIivH79GtHR0YiOjsazZ88QERGB8PBwfPz4EQCgq6uLDh06oH379rC0tESHDh1gaWlZZ9fbCgsLsWLFCnh5ecHBwQH79++Hnp5enRyrIdi5cyfc3d2FX48KUJGDEGnCGMOhQ4cwf/588Pl8/PHHHxg8eDDXsUg98fLygru7O3x8fODo6Mh1HELIF9q/fz/mzJmDtLQ0+oOLCOXk5CArKwtZWVnIzMxEeno6cnNzkZeXh/T0dOTl5SE3NxeZmZnIz89HVlYWcnJykJ+fL3z906dPyMjIQH5+PrKzs1FcXIzMzMxq5RC9SC0nJwc+ny98TfRitqysLNTU1Kr0muhohYpe+/xid1lEL45X1efHrCoNDQ1hcagqRItJVVFSUoKMjIwqby8oRIkSLRIJpKWliX1cVFSErKwssedEi1kCZY14+XzkTFnnlGiGT58+IS8vr8qfU2WUlJSgrKwMoPT5IVrMEd1O9Oster6InqOampoAxIs9ogUjdXV1yMjIiLUlegxBIaasAhIhdSE2Nhampqa4f/8+unXrxnWcBiUtLQ2rVq3C9u3bYWpqiuXLl2PMmDGQkZHhOhqpAzk5OQgMDBQWPSIjI4VTWwmKHu3bt290UwNJo88LGVFRUYiKikJ0dDRev34t/J1GS0sLbdq0EStkdOjQAVpaWvWWNTIyEpMnT0ZkZCQ2bNgAV1fXRn8OXrt2DQ4ODkhOToa2tnZFm1KRgxBplJSUhAULFuDQoUMYPXo0tm/fDh0dHa5jkTrGGMOkSZNw5coV3L17F61bt+Y6EiHkC0yZMgXv3r3D9evXuY5Caklubi7S0tLKfWRmZooVL7Kzs0sVNCr61V1TU1N4sVZNTQ0KCgpQU1MTXpQVfZ3P50NRURFqampiF2AFd98LLgwLLvgK2hC9gEtIbfi8uCI6Eki0YPP5dqLfD6LbfT7SR7SYk5OTg4KCAgDiI4lEiy6CYoxocUl0tFJNpjUTJVogFC3eCb73RIuGgu8/0X0EhRfBvqLbC4ougtE2osUXwfe04GcAFV6kU0hICHr16oW3b9/CyMiI6zgNQmFhIXbu3ImVK1dCRkYGv/76K6ZPn04jNxqZd+/ewc/PD76+vsKprfT09IRreTg4ONDUVhLq06dPeP36Nd6+fYt3797h7du3ePPmDd68eYN3797h3bt3YoWM1q1bw8zMDGZmZmjdurXwIehfuVBcXIzt27dj8eLF6NChAw4dOgRzc3PO8kiSt2/fwtjYGMHBwbC1ta1oUypyECLNLl++jNmzZyMjIwPr1q3D9OnTG30VWNrl5eWhb9++yMrKwp07dyq905UQIrlatmyJadOmwcPDg+so5DOMMaSmpgofKSkpSE5ORkpKClJTU/HhwwekpaUhPT1drIjx+d31wL93hWtqakJTUxNqamrg8/lQU1ODhoYG+Hw++Hw+VFVVK3xORUWF5ggnhAOCAopoYUW04CIo2IiObBEdHZOVlYWioiKx0T2ixRdBwUWwj2jhRbCvaAHm89E5VVVWMUVQdBEUOCsqpoiOnhGMXimrmCI4jujImM+PQ77MuXPn8PXXX+PTp080CrQKrly5Ajc3N7x9+xZubm5YsmRJjUb0EelSUlKCR48eCUd53Lp1C4WFhejYsaOw6NGnTx/6HqsHqampSEpKQnx8PBISEpCYmIj4+HhhAePt27dISUkRbs/n89GiRQsYGxujRYsWaNGiBUxMTISFDEks7oeGhsLV1RVhYWFYvHgx3N3dqcgqgjEGVVVVbN++HdOmTatoUypyECLtcnNzsWLFCmzYsAG2trbYuXMnLC0tuY5F6tC7d+9gbW2Nbt264dy5c2LzbRNCGoZ3796hRYsWCAgIQL9+/biO0ygUFRUhOTkZcXFxwj+gEhISkJycjKSkJLGiRmpqqvBOc4GmTZtCW1sbWlpaaNasmbBwUdmDLuoRQmqbYMSKaPFFMPJFUIQRLbxUVEwRjFwRLb4IiillHUdQ2KnplGRlFVMEI8iqWkwRjHKpqJhS1iiXso7T0OzevRu//PJLjQtejUVycjLmz5+PI0eOYNSoUVi/fj1atmzJdSwioXJychAUFCQsejx79gzKysro06ePsOjRoUMHuqG0ijIzM8V+t05JSUFcXBySkpLw/v174e/jSUlJYjcIKSoqQldXF4aGhjA0NBQWMVq2bIIGljsAACAASURBVCn8P5ejMaorMzMTy5Ytw44dO9CrVy/s2rUL7dq14zqWRLKyssLQoUOxZs2aijajIgchjcX9+/cxa9YshIWF4aeffoK7u3upRSmJ9Lh79y4GDBiAyZMnY9euXVzHIYRU08GDBzF9+nSkpaVVe10BUlpaWhrevn2Lt2/f4v3790hMTCyzmCFauNDQ0ICBgQF0dHSgo6MjLGBoaWlBW1sburq6wo+1tLTojitCCClDRcUU0REsVSmmiE5Z9nkxpazjCEa5VHcdHFGCYkpFU4aVVUypaMqwsoopVZmarCpWrlyJI0eO4Pnz5zX6fKUdYwze3t74+eefoaKigh07dsDJyYnrWKSBef/+vXBqq2vXrgmnthKs5dGYprYSjFoWHb38+c1BghHPgo8F00YKqKiowNDQELq6ujAwMICenp7wX319fejr60NPTw/NmjXj6LOsfSdPnsSPP/6IvLw8/Pbbb5g2bRoVySowevRoMMZw6tSpijajIgchjUlJSQkOHz6M+fPnQ0lJCWvWrIGLiwvXsUgduXTpEkaMGAFPT08sXbqU6ziEkGr4/vvv8fLlS9y4cYPrKBKPMYaEhAThXLyCeXjfvn2L169f482bN2Lz+GtqakJfXx8GBgbCP5wE/xf9l9adIIQQ6VNWMeXzUS4VFVMqmjKsrKJNRaNpqku0mFLe+isvXrzAp0+f0L9/f2Expawpw8oqpohOGSZoX7RII7omk6Bg05DExsZixowZCAwMxJw5c7Bq1SrhqCFCakowtZWg6NGQprYSrP2WnZ2NzMxMZGRkiH0sKFp8XsgQLWiURfQmIMHNQTo6OmLPid5A1Jh+5759+zYWLFiAkJAQuLi4YMOGDfW6sHlDtXTpUly8eBFPnjypaDMqchDSGAkWJj98+DCGDh2KrVu3wsTEhOtYpA7s3r0brq6u2L9/P6ZOncp1HEJIFZmZmWHcuHFYuXIl11EkQnFxMd6+fYvo6GhERUUhKioKL1++RFRUFN68eSO8I0xOTg7NmzcvNXRdMC9vy5YtG9UfUoQQQiRXWcWU6q6/8vmUYdeuXUNBQQF69uxZ7anJakJ0NIpg6jDgv2IK8F8RRbRII1pQEYx+EZ2qTFC8AcQLKqLtihZdRPcVbVOwz99//425c+fCxMQEe/bsgbW1dY0/Z0IqIjq1la+vLyIjI79oaivB97ag0JqRkYH8/HxkZ2cLv//T0tKEhdvs7Gzk5+cjIyMDeXl5yM3NRXp6OrKysoQFjKysrAqntFNUVBSu+6apqVnuv+W91tAKoPXh5cuXWLx4Mc6cOYN+/frht99+Q/fu3bmO1WAcOHAAs2fPRk5OTkXfO1TkIKQxu3HjBmbPno3Y2FgsXLgQixYtksg7DMiXWbJkCTZs2AAfHx8MGjSI6ziEkEokJCTAwMAAvr6+cHBw4DpOvfr48SPCw8MRGRkpLGi8fPkSsbGxwrtemzZtCjMzM5iZmcHc3BwmJibCgoaBgQFNG0UIIaTR6tu3Lzp27Ijt27dXe1/B6BPRESmiI14EF1SB/0aliBZqRNdhERRTRAssgsIK8F/hpjrHqg2ihRHRUSpA6cJIWcWUz/f5fERLWeu5iI6aEShrCjLB6BmBz48FiBeSBESzVnZc8t+5B6DUVHaihUTgv++JsrYVPV8/3xb4rxCZlZWF6OhoxMTEIC4uDnl5eVBSUoKmpiaaNm0KBQUFyMjICPcXFCdFv18qo6mpKfx68/l8KCgoQF1dHcrKymjSpAnU1dWhpqYGVVVV8Pl8qKqqQlNTU/h/Pp8PPp8PDQ0NqKqqVnl6PFK59+/fY82aNdi7dy/Mzc3h5eVFU+TVQFBQEPr164eEhATo6emVt9ke+iuQkEasb9++ePToEXbu3Illy5bhyJEj2LZtGwYPHsx1NFKLVq9ejfj4eIwePRpBQUHo3Lkz15EIIRUIDAyEnJwcbGxsuI5SZ3JzcxEZGYmnT58iIiICYWFhiIiIQFxcHIB/Lxq0bt0aZmZmGDlyJMzNzYWFDWmaj5cQQgipTUlJSTVeC0AwygL494YCSSQY8QKIF0JELzgLRqdERERg7dq1yM/Px5w5c2BlZSU2VVhZ+wgIijQAxPb59OkTUlNTAZS+6A1AbHoygbKmJxNtXxKIFnIqU501YpSVlat8of5znxcRquPzYkVd+LwIJTr6CBAvgMnKygpvyuHxeMI1KyIjI1FSUgIdHR2YmZnBwsICFhYWUFNTE458EhxH8DVSU1ODoqIi+Hy+2IgoIlmio6Oxbt06HDx4ELq6uvjjjz8wdepUGuVSQ8bGxgCA169fV1TkABU5CGnk5OXl4ebmhlGjRmHx4sVwdHSEk5MTdu7cCSMjI67jkVrA4/GwZ88exMfHY+jQoQgJCRF2EoQQyRMUFIRu3bpJzTzRHz58wL1793D//n08efIEYWFhiI2NRUlJCZSUlNCuXTtYWlriq6++QocOHdC+fXvqfwghhJAa+JIiR0MgOkpCMA3W5xhjWLt2LTw8PDB48GDs27cPOjo69RWxRsqaNqysi/yihR0B0cKPKNERC5Wp6miZsgo75RGM4qlOUeRzfD6/xiN0y1s35vPCgOgIms+nPfu8cPH5aJsv9fnUVvv27RNObWVvbw9LS0t06dKFRik3IOHh4Vi7di2OHz8OExMT7NixAy4uLjQ65gsZGhpCTk4Or1+/rvBGQJquihAi5uLFi5g3bx4+fPiAX3/9FXPnzqVOVUpkZmbCzs4O+fn5CA4Oltg7tAhp7Nq2bYvhw4fDy8uL6yjVlpubi0ePHgmLGvfu3UNMTAwAwMTEBF26dEH79u3Rvn17dOjQAa1bt6Y7mgghhJBakJ+fD2VlZZw9exbDhw/nOg4nsrKyMGXKFFy8eBHr16/HvHnzqrz2ASFce//+PXx9feHn54eAgAAkJSWBz+ejT58+sLOzg52dHbp27UrXZyRMcXExfHx88Mcff8DPzw/t27fHokWLMHbsWPo7pxaZmJhg5syZWLRoUXmb0JochJDScnNzsWbNGmzYsAGtW7fGli1b8NVXX3Edi9SC+Ph49OzZE8bGxvD19aU1WAiRMMnJydDT08OlS5fg6OjIdZxKJSYmIjAwEEFBQbhz5w7Cw8NRVFQEbW1tdO/eHdbW1ujevTu6d+8ObW1truMSQgghUuvt27cwNjZGSEiIVE95WZ4XL17g66+/xsePH3Hy5En06dOH60iEfJHIyEjh79mBgYHCokfv3r3Rr18/KnpwLCEhAXv37sXu3bsRHx+PQYMGYfbs2Rg6dCgVV+tA//79YWFhgT/++KO8TajIQQgpX3R0NJYsWYKTJ0/CyckJW7duhYmJCdexyBd69uwZevfuDXt7exw7dqxWh9wSQr7MyZMnMX78eHz8+LHUYpOSIDU1FYGBgQgMDERAQACePXsGOTk5WFtbo2fPnsLCBvUVhBBCSP26f/8+rK2tERsb2+j6YR8fH0yePBlt2rTB6dOnYWhoyHUkQmqdaNEjKCgIiYmJ4PP5sLW1Rc+ePWFjY4MePXqITetGatenT5/g4+ODo0eP4vLly9DQ0MC0adMwc+ZMtGrViut4Um3atGlITEzEP//8U94mVOQghFTu2rVrcHNzw6tXrzBv3jy4u7uLLUxHGp6AgAAMHjwYs2fPxqZNm7iOQwj5f3PmzBFO8yQJ8vPzERAQgCtXriAgIABPnz6FjIwMunbtin79+qF///7o3bs39QmEEEIIxy5dugQnJydkZ2dDRUWF6zj1ZvXq1Vi2bBm+/fZb7NixgxZiJo1GZGQkgoKCcPPmTYSEhODVq1eQkZFBu3btYGNjg169esHGxgYWFhY0suALFBYWws/PD3///TfOnz+P3Nxc2NvbY/LkyRg1ahT9zKknnp6eOH78OCIjI8vbhIochJCqKSwsxM6dO7F8+XKoqalh9erVcHFx4ToW+QLHjh3DxIkTsXTpUqxYsYLrOIQQAO3atYOzszPWrVvHWYaMjAxcvnwZ586dw5UrV5CVlQUrKysMGDAA/fv3R9++fSVylAkhhBDSmO3fvx9ubm7IysriOkq9KCoqwpw5c7Bv3z5s3rwZc+fO5ToSIZxKTEzEnTt3EBISgpCQEISGhiI3NxeampqwsbERPrp06QItLS2u40q0Dx8+4OrVq7h48SKuXr2KtLQ02NjYYMKECRgzZgx0dHS4jtjoHDhwALNnz0ZOTk55RTsqchBCqichIQGenp7Yu3cv7OzssGXLFnTo0IHrWKSGDhw4gO+++w6rVq3C4sWLuY5DSKMmWI/j8uXLGDx4cL0eOy4uDhcuXMC5c+cQGBgIxhjs7OwwYsQIDBs2DEZGRvWahxBCCCHVs3btWuzduxcxMTFcR6lzOTk5GDduHK5fv46jR4822oXWCalIUVERHj9+jJCQEGHx49WrVwCA5s2bo2PHjrCyskKnTp3QsWNHmJubN9qFsgsKCvDgwQMEBATg8uXLuHv3LmRkZNCnTx84Ojpi5MiRjW4aQEkTGBiI/v37IyEhAXp6emVtQkUOQkjN3L9/H/PmzcODBw/w7bffYs2aNWjWrBnXsUgNbN++Hf/73/+wfv16/Pzzz1zHIaTROnbsGCZPnoyPHz+Cz+fX+fHy8/Nx4cIFHDx4EP/88w8UFRUxYMAAODs7Y8SIEXSHEiGEENKA/PDDD7h37x5u377NdZQ6lZKSAicnJ8TGxsLHx6dRLrJOSE0lJyfjyZMnePz4MZ48eYKwsDA8f/4chYWFUFZWhqWlJTp16gQrKytYWVnBwsIC2traXMeudRkZGbh79y6Cg4Nx48YN3Lt3D58+fYK+vj4cHR0xZMgQODg40Oh1CfLq1Su0atUKISEh5f3c3yNX36EIIdKhe/fuuHXrFg4fPowFCxbg1KlTWL58OebOndtoq/8N1dy5c1FUVIT58+dDVVUVrq6uXEcipFEKCAhA9+7d67zA8fDhQ+zfvx9Hjx5FVlYWhgwZgtOnT2PQoEFQUlKq02MTQgghpG4kJSVBV1eX6xh1KiYmBoMHD0ZJSQlu374NMzMzriMR0qDo6OjAwcEBDg4OwucKCgoQERGBJ0+eCAsfZ86cwcePHwEAampqMDU1RatWrWBqair2MDIykujrP4WFhXjz5o3w8xL8KxjRYmZmBltbW0yZMgW9e/emnykSzMjICHJycnj9+nW5xW0qchBCakxGRgYuLi5wdnaGh4cHfv75Zxw5cgSbN29Gr169uI5HquGHH35Aeno65syZA1VVVUyaNInrSIQ0OgEBARg9enSdtJ2TkwNvb2/s2bMHjx8/Rps2bbBo0SK4uLiUN9yXEEIIIQ1IUlISzM3NuY5RZ168eIEBAwbAwMAAFy9elPqCDiH1RUFBAZ07d0bnzp3Fnn///j1evnyJmJgY4cPPzw+7du1CZmamcF9jY2OYmprC2NgYenp60NXVhYGBAXR0dKCvrw9NTU2oq6vXSfYPHz4gKSkJKSkpiI+PR1xcnDBrbGws3rx5g6KiIsjIyMDU1BSdOnXCd999BysrK3Tt2hX6+vp1kovUPjk5OTRv3hxv3rwpf5t6zEMIkVKamprYunUrZsyYATc3N/Tu3Rtjx46Fl5cXjI2NuY5HqsjT0xP5+fmYOnUq5OXlMXbsWK4jEdJoxMfHIyoqCv369avVdpOTk7F9+3bs3LkTubm5GDduHLZv3w5bW9taPQ4hhBBCuJWUlIQ+ffpwHaNOREREwN7eHq1atcLly5fr7IIpIeQ/hoaGMDQ0xIABA0q9lpKSIlb8iImJwYsXL3Dz5k0kJCQgLS1NbHsejwdNTU1oaGgI/+XxeODz+ZCTk4OioiKaNGlS6jiZmZkoLi5Gbm4ucnJykJWVhczMTOTk5CA1NRUFBQXCbWVlZaGnpyccZWJnZ4dWrVqhdevWaNeuHVRUVGr/TSL1ytDQEHFxceW+TkUOQkitad++Pfz9/XHt2jX88MMPMDc3h6urK1auXElzGTYQa9euRWFhISZPnowmTZrA2dmZ60iENArXr1+HgoJCrY2C+/jxI7Zu3YpNmzZBQUEB33//Pdzc3OhuJUIIIURKJScnS+V6WmFhYbC3t0fbtm1x8eLFelm3jBBSMW1tbWhra5c7bVB+fj6Sk5OFBY/09HThQ/AxYwzZ2dkoLCxERkYGEhMTS7UjKH40a9YMLVq0gJqaGtTU1KCiogItLS3hyBFtbW3o6OiAx+PV9adOOKSvr4+EhIRyX6ciByGk1tnb2+PRo0f466+/sHTpUhw9ehTu7u60XkcDsX79emRlZWHUqFE4d+4cHB0duY5EiNQLCAiAtbX1F99hlJeXh02bNmHdunVQUFCAh4cHZs2aBWVl5VpKSgghhBBJk5+fjw8fPqB58+ZcR6lVjx8/hoODA9q1a4dLly5BVVWV60iEkCpQVFSEkZERjIyMuI5CpIi+vj4ePnxY7usy9ZiFENKIyMvLY8aMGXjx4gW+++47LFy4EB07dsSVK1e4jkYqwePx8Mcff2DUqFEYNWoUgoKCuI5EiNQLDAxE//79v6iNCxcuoH379lizZg1++uknxMbGYv78+VTgIIQQQqRcfHw8GGMwMDDgOkqtCQ0NxYABA9ClSxdcuXKFChyEENLI6enplTniR4CKHISQOtW0aVN4eXkhLCwMlpaWcHR0hIODA549e8Z1NFIBGRkZeHt7Y9CgQRg2bBhCQkK4jkSI1Hr37h1iY2NrXORIT0+Hi4sLhg8fjrZt2yI8PBzLli2jiwGEEEJIIxEfHw8AUlPkiIyMxODBg9GjRw+cP3+ebtgghBBS6XRVVOQghNSLNm3a4MSJE/Dz80NycjI6deoENzc3pKencx2NlENOTg7Hjh2DnZ0dBg0ahJs3b3IdiRCpdP36dSgqKpY7p21F/vnnH1hYWCAwMBC+vr7w8fGBsbFxHaQkhBBCiKSKj4+HjIwMdHV1uY7yxd6/fw9HR0e0bt0ap06dgpKSEteRCCGESAB9fX3k5uYiMzOzzNepyEEIqVeC9Tr27t2LY8eOwdTUFFu2bEFR0f+xd+9xMeX/H8Bf0z3dJCmFyCV3NlaWYl1DTXSj3GLXlhbbsnYt+13ydf/+dq3YXRtr2bAryiLsolxKSC6hXNKFVCrRVen6+f3hO31LMzUzzXRm6v18PObx0Dmfc87rzJzPmWM+53w+lVxHI0JoaGggNDQUEydOxKRJkxAeHs51JEJanAsXLuCDDz6Q6C5FxhjWrVsHR0dHjB8/Hvfu3cOECRPkmJIQQgghiiozMxMdOnSAuro611Ga5MWLF5gwYQL09fVx+vTpJo9VRgghpOUwNjYGAOTm5gqdT40chJBmp6Kigrlz5+LRo0eYP38+vvrqKwwePBh///0319GIEOrq6ggODoarqyscHR0RFhbGdSRCWhRJx+OoqKiAp6cn1q9fj+3bt+PAgQMwMDCQY0JCCCGEKLLnz58rfVdVhYWFmDRpEioqKnD27FkYGhpyHYkQQogCadeuHQDg1atXQudTIwchhDNt27bFd999h4SEBPTq1QtTpkzB+PHjcevWLa6jkXeoqqpi79698PT0hJubG44dO8Z1JEJahJSUFDx9+lTsRo7S0lI4Ozvj9OnT+Oeff7Bo0SI5JySEEEKIosvMzFTqRo7S0lLw+XxkZWXh3LlzMDU15ToSIYQQBdNYI4dac4YhhBBhevTogaNHjyImJgZffvklhg4dCjc3N2zevBmWlpZcxyP/paqqit9++w1t2rTBjBkzEBQUhBkzZnAdixCldv78ebRp0wbDhg1rtGxlZSWcnJwQGRkJOzs77Ny5Ezt37myGlIQQQgiRhqqqKjZu3Ihu3brJdTuZmZno3r27XLchT0uWLMHNmzdha2uLFStWcB2HEEJaJDMzM2zbto3rGFLT19eHmpoaPclBCFF8NjY2iIyMxPHjx3H79m306dOHBidXMDweDz/++COWLFmCWbNmYdeuXVxHIkSpnTlzBh9++CE0NTUbLMcYw4IFCxAVFYXy8nLqwoGQVu7atWu4cuUK1zHIf9HnQUQJDg5GTEyM3LeTmZmJjh07yn078nDw4EH89ttvsLa2Rnx8PNdxWrT09HQcOXIEjDGuo7QK9H4TRZKeno6AgABUVVVxHUVqPB4PhoaGePnypdD59CQHIUTh8Pl8TJo0CXv37sXq1atx4MABfPXVV/Dz84OWlhbX8Vo9Ho+H7777DsbGxli4cCHy8vLojitCpFBVVYXz58/j22+/bbTsxo0b8ccff+Crr77Chg0bcOjQIaiqqjZDSkKIIvL09ER5eTkOHz7MdRQC+jyIaM31Xa2s3VUVFBRg6dKlWLRoEXJzc2FsbEz1SI5CQ0Ph5uZG15HNhN5vokgEx6Oya9euHfLy8oTOoyc5CCEKSV1dHd7e3khKSsKSJUuwdu1aWFlZISgoiO6EUBArVqzAjz/+iFWrVsHPz48+F0IkFBsbi1evXsHe3r7BcmfPnsWaNWuwdetWvPfee82UjhBCCCHKoKSkBAUFBUrZyLFx40ZUVlZi7dq1XEchhBCiBHR1dfH69Wuh86iRgxCi0HR1deHv74/ExERMmjQJH330EWxsbHDx4kWuoxEAn376Kfbt24eff/4ZCxcuVOpHHwlpbmfOnEGnTp3Qp08fkWXS0tLg4eGB2bNnY/Hixc2YjhBCCCHKICMjAwCUrpEjOzsb27dvx+rVq2sGkyWEEEIaoq2tjZKSEqHzqJGDEKIUOnXqhMDAQNy9excmJiYYM2YMJkyYgHv37nEdrdWbM2cOQkNDsX//fri6uor8wiGE1HXu3LkGn+Korq7GvHnzYGpqSgOME0IIIUSozMxMAMrXyPHzzz9DT08PPj4+XEchhBCiJNq0aUONHISQlqFv374ICwvDP//8g5ycHFhbW8PX1xfPnz/nOlqr5uTkhAsXLuDKlSsYM2YMXrx4wXUkQhRaYWEhrl+/jokTJ4os89133+HKlSv4448/oK2t3YzpCCGEEKIsMjMzoaamBmNjY66jiK2srAyBgYHw9fWlaxxCCCFi09bWRmlpqdB51MhBCFFK9vb2uH37Nnbt2oVTp06hZ8+e+Oabb1BQUMB1tFbLxsYGV69exatXr/DBBx/g8ePHXEciRGGFh4ejuroa48aNEzo/OTkZ/v7+8Pf3x+DBg5s5HeECj8cT+hI2v1OnTiIbkxtaByGENObUqVOYOnUqTE1NoaGhAVNTU/D5fBw7dqxe2cbOW42Vk+RFRMvMzISJiYlSDWwcEhKCV69ewdfXl+sohAAAnW8IURL0JAchpEVSUVHB/PnzkZSUhK1bt+LXX3+FpaUltmzZIrJll8hX9+7dERUVhbZt28LOzg43b97kOhIhCunkyZMYPnw4jIyMhM739fVF9+7d8cUXXzRzMsIVxhgYY2L9nZGRAU9PT6HjINUu9+46CCFElIqKCsyePRuzZs3C2LFjERsbi+LiYsTGxmLcuHHw8vKCq6trnWvsxs5bwqYL+7eo9dA5TDyZmZlK11XV/v37MWnSJJiamnIdhRAAoHMNIUqCxuQghLRoGhoa8Pb2RnJyMr766its2LABvXr1wq5du1BZWcl1vFbH1NQUFy9ehLW1NUaPHi30zj9CWrPq6mr8/fffcHBwEDo/JCQEERER2LVrF9TV1Zs5HVEGpqamiIiIwOrVq7mOQohc0V21zWfJkiU4fPgwwsPD4efnh86dO0NDQwOdO3fG559/jrNnz+LEiRPw9vbmOip5R1paGiwsLLiOIbbs7GxERERgzpw5XEchrQx9pxCi/FRUVEQ2SlIjByGkxdDV1cWKFSuQnJyMWbNm4bPPPsOAAQNw5MgRujOjmenq6uLEiROYN28eXFxc4O/vz3UkQhRGbGwssrKy4OjoWG9eeXk5Vq5ciVmzZuGDDz7gIB1RBsHBwVBTU8OmTZtw8uRJruMQQpRcTEwMAgMDMW/ePAwdOlRoGRsbG8ydOxcHDhxAVFRUk7cpybU5Xcc3LC0tDV26dOE6htiCg4Oho6MDPp/PdRRCCCEtCDVyEEJaHGNjY2zevBmPHj3CqFGj4OHhgeHDh+P8+fNcR2tV1NTU8OOPP+KHH37AunXrsGDBAlRUVHAdixDOnTp1Cl26dMGAAQPqzfvpp5+QkZGBDRs2cJCMKItRo0Zh48aNYIxhzpw5SE1N5ToSIUSJ/fLLLwAANze3Bsu5u7sDAHbv3i33TER8aWlp6Ny5M9cxxHbs2DE4ODhAS0uL6yiEEEKUED3JQQhpdSwsLBAYGIg7d+7AwsIC48aNw4QJE3Dr1i2uo7Uqfn5+OHnyJI4cOYKxY8ciNzeX60iEcOrkyZNC714sKSnB5s2b8dlnnynVjxWEG19++SWcnZ2Rn58PV1dXvHnzhutIhCA8PBxOTk4wNDSElpYWrK2tcejQoXrlag/wmpycDBcXFxgaGtbpSqR2lyKC6QsWLGi2fWlNBE9mCGt8r23gwIEAgOjoaLlnIuIpKytDdna20jzJkZ+fj8uXL8PJyYnrKERMBQUFWLp0KSwtLaGlpQUjIyOMGDECy5cvx/Xr12vK1T6vZ2ZmwtXVFXp6ejAyMoKXlxcKCgrw5MkTODk5QV9fH6amppg3bx7y8/PrbTMrKws+Pj7o1KkTNDQ00KlTJyxcuBDZ2dlSl5XkO+XZs2eYOnUq9PT0YGJigtmzZ+Ply5fSvoWEEBlqqMs5auQghLR4/fv3x+HDh3H58mWUlpZi6NChmD59OpKSkriO1mpMnjwZly5dwpMnT2Bra4uHDx9yHYkQTmRmZiIuLk7oeBy//PILXr9+jWXLlnGQjCijvXv3okePHrh9+zYWL17MdRxCMGHCBKiqquLx48dITExE+/bt4enpiTNnztQpV/sOPF9fXyxfvhyZmZk4ffq00DKCAah//fVX+e9EK5SZmQkAMDIyarCcYP7zNZVdMQAAIABJREFU58/lnomIJz09HYwxpWnkOHXqFHg8HiZNmsR1FCImLy8vbNu2DX5+fnj58iWeP3+OvXv3IiUlBTY2NjXlap+zV6xYgfXr1yM9PR2enp4ICgrCrFmzsGzZMmzZsgXPnj2Di4sLfv/9d3z11Vd1tpeVlYVhw4bh5MmTCAoKwsuXL/H777/j+PHjsLGxqdN4IUlZSb5TVq5cic2bNyM9PR3Tp0/HwYMHsXz58ia/l4QQ+aJGDkJIqzFy5EhERUUhODgYd+7cQb9+/bBkyRJkZWVxHa1VGDx4MGJiYtC2bVsMHz6c+pEnrVJYWBjatGmDMWPG1JleXl6O77//HgsXLkSHDh04SkeUjYGBAUJDQ6GtrY09e/Zg7969XEciBD/88APat2+PLl26YPv27QDQYBd8q1atwogRI6CtrY3JkyfT+AsKTNhTNoRbaWlpAKA0jRxnzpyBra0tDAwMuI5CxHThwgUAgLm5OXR0dKChoQErKyv8+OOPIpdZsGAB+vTpAwMDA6xatQrA2wYuPz+/etNrN24DwOrVq/Hs2TNs2bIFY8eOhZ6eHsaNG4fNmzfj6dOnWLNmjVRlJfHJJ5/U5Pz6668BAGfPnpVqXYQQ2aqurhZ5HUKNHISQVoXH48Hd3R0JCQnYvn07jh49ih49emDlypV49eoV1/FaPDMzM1y6dAnu7u5wcnLC119/jerqaq5jEdJsjh8/Dnt7+3r9UAcHByMnJweff/45R8mIsho4cCB27twJAFi0aBHi4uI4TkRaM8YYunbtWvN3z549AQD3798XucywYcPkHYs0omPHjgDQ6LWwoMtRMzOzOtNVVN7+rFBVVSVy2aqqqppyRHbS0tKgpaUFY2NjrqOI5cKFCxg7dizXMRpUu9ul2i9h8zt16oQXL16IvR5l5OrqCuDtmDxdunTBggULcPjwYbRv315ko7S1tXXNv01NTYVOF5xHBE+SCQhuhHv3OBk/fnyd+ZKWlUTtnILzIz3BJr1Tp05h6tSpMDU1hYaGBkxNTcHn83Hs2LF6ZRurf42Vk+RFlFNJSQnatGkjdB5dZRBCWiU1NTX4+PggNTUVW7duxd69e2FhYYGvv/4aBQUFXMdr0TQ1NbF792788ssv+OGHHzB16lR6z0mrUFxcjAsXLmDq1Kn15v34449wdXVFp06dOEhGlJ2Xlxe8vb1RWloKNzc3of1bEyJv+fn5WLVqFfr06QM9PT3weDyoqakBQIN9mYv6jyppPnZ2dgCAu3fvNlhOMH/UqFF1puvp6QFAg9dzeXl50NfXb0pMIkRaWhq6dOmiFD/YJSYmIj09vd7TrIpG0JWROH9nZGTA09NTaANf7XLvrkOZ/PbbbwgNDYWrqyuKi4uxZ88ezJgxAz179hR5Y4XgnACgTuOmsOnvvi+CRqP27dvXmS74OycnR6qykhAnJ2lcRUUFZs+ejVmzZmHs2LGIjY1FcXExYmNjMW7cOHh5ecHV1RWlpaU1yzRW/4RNF/ZvUetR5rpI3iopKYGOjo7QedTIQQhp1TQ0NODt7Y2kpCT861//QmBgILp3744tW7bU+bIlsuft7Y1z587h+vXrsLW1RWJiIteRCJGr06dPo6KiAlOmTKkz/datW7h+/ToWLVrEUTLSEmzfvh1DhgxBcnIyvLy8uI5DWqHp06dj06ZNmDFjBp4+fUo/JCiRhQsXAgBCQ0MbLHfkyJE65QWsrKwAAPHx8SKXjY+PR69evZoSkwjx7Nkzpemq6uLFi9DV1cX777/PdRSZMTU1RUREBFavXs11FLlycXFBSEgIcnNzERkZCXt7e6SlpWH+/Pky35ag21bBk2MCgr9rd+sqSVnS/JYsWYLDhw8jPDwcfn5+6Ny5MzQ0NNC5c2d8/vnnOHv2LE6cOAFvb2+uoxIl8vr1a2rkIISQhujq6mLFihVITk7G4sWLsWHDBnTt2hVbtmxBWVkZ1/FarFGjRuHGjRvQ1tbG+++/j5CQEK4jESI3x48fh52dXb27zfbv34/u3bvD1taWo2SkJdDU1ERISAgMDQ1x4sQJruOQVig6OhoA8MUXX6Bdu3YA0ORrKMFTHhUVFSgpKal3/iSyMXz4cPj4+GDv3r24ceOG0DIxMTEICgqCj49PvR+p+Xw+ADQ4LtCePXvg4OAgu9AEwP+e5FAGMTExGDZsGNTV1bmOIjPBwcFQU1PDpk2bWux4gzweD+np6QDePtVgZ2eH4OBgAMCDBw9kvj3B+SQiIqLO9PDw8DrzJS0L0HdKc4qJiUFgYCDmzZuHoUOHCi1jY2ODuXPn4sCBA4iKimryNiW5sYJuwlBe1F0VIYSIqV27dvD390dycjLmz58Pf39/WFlZYdeuXQ32M0yk17lzZ1y5cgW+vr5wd3eHj48PysvLuY5FiExVVFTg77//rtdVVWVlJf7880/MmTNHKbqaIIqta9euOHDgAB1LhBOCLo82bdqE/Px8vHr1qmZgWWkNHDgQAHD9+nWEhYXhgw8+aHJOItyOHTvg7u6OCRMmYPv27UhPT0dFRQXS09MREBAAe3t7zJgxAzt27Ki3rJ+fH/r27Yt9+/Zh0aJFiI+PR1lZGcrKynDv3j34+voiNjaWxp2Sg7S0NHTu3JnrGGK5ceOGyB87ldWoUaOwceNGMMYwZ84cpKamch1JLhYsWICEhASUlZUhOzsbW7ZsAQDY29vLfFtr166t6Ub6/PnzKCoqwvnz57Fy5UpYWFjA399fqrIAfac0p19++QUA4Obm1mA5d3d3AMDu3bvlnom0DNRdFSGESMjY2BibN29GYmIi7O3tsWjRIgwYMABHjhyhVn85UFNTw+bNm3H06FEEBwdj5MiRLfY/CaR1unTpEvLy8uo1ckRGRiI7OxszZ87kKBlRFKIGNhX2d0MDJk6ZMgXffPONfMMSIkRQUBDmzJmDPXv2wMTEBKNHj4aNjU3N/HeP59r/FnU879ixA4MGDcLEiROxbds2fP/99/LbgVZOXV0dBw8exIEDBxAeHo4hQ4ZAR0cH1tbWOHfuHA4cOIADBw4IvQtfT08PV69exdq1a3H9+nWMHDkSOjo6MDY2hpeXF4yNjRETEyNyTI7Gzn9ENGXprurNmzd48OBBnQGdW4ovv/wSzs7OyM/Ph6urK968ecN1JJm6fPkyTE1N4ejoCD09PVhZWeH06dPYsGED/vzzz5pyDZ3jJfm3iYkJYmJiwOfzMWfOHLRr1w5z5swBn89HTEwMTExMpCoLNPydImlO0jDBkxkDBgxosJyg4UnwNCghjcnPz4eBgYHQeTxGv9YRQkijUlNTsXnzZuzZswd9+/bFt99+W3PXAZGthw8fws3NDdnZ2di3bx91bUBahCVLliAqKqreAI2fffYZLly4gHv37om1ntDQULi5uaGyshKqqqryiEoIUQKenp4oLy9vdAwF0jzo8yCiqKqq4uDBg/Dw8JD5ul++fIn27dvj3LlzGD9+vMzXL0vXr1+HjY0NHj9+jB49eggto2j1SPCDtqifzHg8Xs28goICDB06FElJSfj444/x66+/Ci3HNbqObF6t+f1u06YNSktLUVZWBg0NDZHlysrKoKWlBW1tbZSUlNRMb6z+1S7XUBlx19MatJTjsU2bNti5c6ewMQh305MchBAihm7duiEwMBA3b95E165dMX36dNjZ2eHSpUtcR2txevfujZiYGEyZMgV8Ph+ff/45jYtClBpjDMePH6/3FAcAhIWFwcnJiYNUhBBCCFFmaWlpAKAUT3LcvHkT+vr66N69O9dR5MLAwAChoaHQ1tbGnj17GhyfhhDyP7WfUiakMYWFhSgtLa33lJYANXIQQogEBg0ahBMnTuDatWto27YtPvzwQ9ja2uLixYtcR2tRdHR08PvvvyM4OBi///47hgwZIvad7oQomlu3buHZs2f1GjlSUlLw5MkTufRnTAghhJCWLS0tDTweTynG5Lh16xasra1b9A+ZAwcOxM6dOwEAixYtqvf0LiGtSceOHQEAr169arBcbm4uAMDMzKzOdBWVtz9XNzQualVVVU050jrk5OQAADp06CB0Ph0NhBAiBRsbG4SFhSEqKgqampoYM2YMJkyYgOvXr3MdrUVxd3dHXFwcDAwMYGNjg4CAAK4jESKx48ePw9zcHO+9916d6ZGRkdDU1MSwYcM4SkYIIYQQZZWUlISOHTtCW1ub6yiNunnzJoYMGcJ1DLnz8vKCt7c3SktL4ebmhvz8fK4jEcIJOzs7AMDdu3cbLCeYP2rUqDrT9fT0ALztCk6UvLw8kWM9kZYpOzsbADVyEEKIXNja2iIiIgJRUVGoqKiAjY0NJkyYgNjYWK6jtRgWFha4ePEilixZgmXLlmH69Ol4+fIl17EIEdvx48fh4uJS7+7F6Oho2NjYQEtLi6NkhBBCCFFWycnJIse3UCTl5eVISEhokYOOC7N9+3YMGTIEycnJwvqMJ6RVWLhwIQA0OsbOkSNH6pQXsLKyAgDEx8eLXDY+Ph69evVqSkyiZHJycsDj8WBsbCx0PjVyEEKIDAi6rDp37hwKCwsxbNgwTJgwATdv3uQ6Wougrq6OLVu24MyZM7h69SoGDBiA06dPcx2LkEY9efIEd+/eFToeR1xcXKu4q5EQQgghspecnKwUY1wkJiaivLwcAwcO5DpKs9DU1ERISAgMDQ1x4sQJruMQwonhw4fDx8cHe/fuxY0bN4SWiYmJQVBQEHx8fPD+++/Xmcfn8wGgwfFt9uzZAwcHB9mFJgovJSUFHTt2hKamptD51MhBCCEyNH78eMTExODcuXPIz8/H+++/Dz6fj9u3b3MdrUUYP3484uPjwefz4eDggLlz56KoqIjrWISIdOLECbRt27beI9jV1dV48OABBgwYwFEyQgghhCgzZWnkSElJAQB069aN4yTNp2vXrjhw4ECLHoOEkMbs2LED7u7umDBhArZv34709HRUVFQgPT0dAQEBsLe3x4wZM7Bjx456y/r5+aFv377Yt28fFi1ahPj4eJSVlaGsrAz37t2Dr68vYmNj8fnnn3OwZ4QrSUlJDT7BSI0chBAiB+PHj0dsbCzOnj2LzMxMDB06FHw+H3fu3OE6mtIzMDBAYGAgQkJC8Pfff2PgwIE08DtRWCdOnMCkSZOgrq5eZ3p6ejpev36N3r17c5SMEEIIIcqqsrISaWlpStHIkZqaChMTE+jo6HAdRSw8Hq9O40RDf787r7YpU6bgm2++kW9YQhSYuro6Dh48iAMHDiA8PBxDhgyBjo4OrK2tce7cORw4cAAHDhyo9/8k4O2YHFevXsXatWtx/fp1jBw5Ejo6OjA2NoaXlxeMjY0RExMjckyOxuoxUU5JSUno2bOnyPnUyEEIIXI0fvx43LhxA8eOHUN6ejqsra0xffp0JCYmch1N6bm6uuLevXvo378/xo0bh88//xyvX7/mOhYhNQoLCxEVFVXzuHVtGRkZAIBOnTo1dyxCCCGEKLmnT5+ioqJCaRo5LC0tuY4hNsaY0FdD80VZt25dg/MJaQ0cHBxw4sQJZGdno7y8HDk5OTh58iQcHR0bXE5fXx+rV69GbGwsCgoKUFlZicLCQty6dQv//ve/YWBgIHLZxuoxUU70JAchhHCMx+OBz+fj5s2bOHToEO7evYs+ffpg+vTpePz4MdfxlJqpqSnCwsKwZ88eBAUFYcCAATh37hzXsQgBAPzzzz+oqqqCvb19vXnPnz+HiooKTE1NOUhGCCGEEGWWnJwMAEox8Hhqamqr6qqKEEKI7JWVleHZs2cNfu+pNWMeQghp1VRUVODu7g4XFxccOHAA69atQ79+/TB37lysWrVKqe5wUjTz5s3D5MmT8eWXX2LixIlwd3fHzp07YWRkxHU00oqdPHkStra2Qo/DoqIiaGlpCX08WxxqanQJR0hrR10vKBb6PIgw8jomkpKS0LZtWxgaGspl/bKUkpKCqVOnch2D1ELXkYQQZZOYmIiqqipYWVmJLENnNkIIaWaqqqrw8vLCzJkzsX//fmzYsAFBQUGYPXs2vvnmG6V47FwRmZiYICgoCNOmTcPixYsxYMAA7NixA66urlxHI61QVVUV/v77b6xYsULo/PLycmhoaEi9/kOHDkFFhR7IJaS1CggIQGVlJb744guuoxDQ50FE8/DwkMt6k5OTleIpDgB48uQJPcmhYOg6snnExMTg+++/5zoGIS3CzZs3oaWl1eCYltTIQQghHFFXV8dHH32EefPmITQ0FP/617/Qq1cvuLq6Yv369ejVqxfXEZWSi4sLxowZg+XLl8Pd3R1TpkzBjh076D9XpFnFxsYiNzcXU6ZMEVmmKf3Curm5QVVVVerlCSHK7ejRoygvL4e7uzvXUQjo8yCitfZGjpycHBQXF9MT6wqGriObBzUkESI7N2/exODBgxvsCYFqHCGEcEzQjdWDBw/qjdnx6NEjruMpJUNDQ+zZsweXLl3C06dP0a9fP/j7+6OsrIzraKSVOHv2LMzNzdG3b1+h8w0NDVFYWIiqqqpmTkYIIYQQZZecnKwUT3+npqYCALp27cptEEIIIUrt5s2bsLa2brAMNXIQQoiCEDR23L9/H4cOHcK9e/fQt29fTJ8+HQ8fPuQ6nlKys7PD7du3sWnTJmzduhX9+/fHmTNnuI5FWoFz584JHXBcwMjICIwxvHz5EgAQERGB7du3N1c8QgghhCgpxhhSUlKUopEjMzMTAGBubs5xEkIIIcqqqqoKd+/exZAhQxosR40chBCiYASNHQkJCTWNHf369aPGDimpqanBz8+v5n2cNGkSPDw8kJaWxnU00kIVFRUhJiYGEyZMEFlGMGDa/fv3UVBQAA8PD/j5+SEoKKi5YhJCCCFECT1//hwlJSVK0ciRm5sLAwODJo1DRgghpHV7+PAhXr9+TU9yEEKIsqrd2HHs2DE8fvwY/fr1A5/PR1xcHNfxlI6FhQWOHTuGsLAw3Lp1C71798aaNWtQUlLCdTTSwly4cAFVVVUYN26cyDJmZmZo37494uLi8M0336CgoAAAsGDBAsTGxjZXVEIIIYQomaSkJABQijE5Xrx4AWNjY65jEEIIUWKRkZHQ19dH//79GyxHjRyEEKLgVFRUwOfzcfPmTRw7dgwZGRkYMmQI+Hw+bt++zXU8pePo6IiEhARs2rQJAQEB6NmzJ3bt2oXq6mquo5EWIjw8HIMHD270P/UffvghgoODsXPnTlRUVAB42wWFg4MDMjIymiMqEQOPx6t5tRSy2qdDhw7BxsYGhoaGDa6zJb6HRP7ouJEfZXtv6VxTV1JSEtq0aYOOHTtyHaVRL1++RPv27bmOQQghRImFh4dj9OjRUFNTa7AcNXIQQoiSEDR23LhxA4cOHcLTp08xdOhQzJgxA3fv3uU6nlJRV1eHn58fHj16hClTpsDX1xe2tra4du0a19FICxAZGYkxY8Y0Wm7atGm4c+cOVFT+dzlWWVmJ/Px8ODs7o6ysTJ4xiZgYYyLn2dnZwc7OrhnTyEZD+ySuoKAgeHp6wsjICHFxcXjz5g1CQ0Pltj3SMkhSZ+i4kR9lOq/Ruaa+Bw8ewMrKSikac/Ly8mBoaMh1DEIIIUqquroakZGRGDt2bKNlqZGDEEKUjKAbq7i4OBw+fBiPHj3C4MGDMW3aNNy4cYPreErFxMQEu3fvxo0bN6ChoYERI0bA1dUVjx494joaUVKFhYWIj4/HyJEjGy2bk5ODsrIyVFZW1pleUVGB27dvw9vbW14xiYxUV1e32qfAtm7dCgD4/vvvYWFhAU1NTbi4uLSaHxmJdBS1zrTEu/+l3SdF+4zoXFPfw4cP0adPH65jiKW4uBi6urpcxyCEEKKkbt++jdzc3Aa7ghagRg5CCFFSKioqcHV1RVxcHM6ePYusrCy8//77sLW1xfnz57mOp1Tee+89XLx4EWfPnkVKSgr69u2LuXPnIjMzk+toRMlcvXoVVVVV+OCDDxosl5WVhW+//VbkD0mVlZXYv38/fv75Z3nEJDISHR2N6OhormNwIjExEYBy9AlPFEdrrjPKQtE+IzrX1Pfw4UP07t2b6xhief36NXR0dLiOQQghRElFRESgQ4cOjY7HAVAjByGEtAjjx4/HtWvXEBUVBS0tLYwbNw62trYICwvjOppSGT9+PG7cuIE9e/bg4sWL6NWrF7799tuaQaEJacyVK1fQo0cPmJqaNlhu8eLFKC8vb7AMYwyfffYZLly4IMuIhMhEaWkpgLfd/xFCiLzQuaausrIyPHnyhBo5CCGEtApnzpzBuHHjxHo6lRo5CCGkBbG1tUV4eDiioqJgaGgIJycnjBw5EmFhYa36sX5JqKqqYt68eUhMTMSaNWvw008/oVu3bli/fj2Kioq4jkcUXHR0dKNdVZ0/fx6hoaE1g403xtXVFU+fPpVFPKVVezDZ5ORkuLi41BmAViAnJwe+vr7o1KkTNDQ0YG5uDm9vb2RlZdVbZ3h4OJycnGBoaAgtLS1YW1vj0KFDUmV6V0JCAqZMmQJdXV3o6+vD3t4e9+/fF7pM7WnPnj3D1KlToaenBxMTE8yePRsvX76st35J9rN2FgMDAzg7OyMtLU3s/RS178LySzPor7j7UlBQgKVLl8LS0hJaWlowMjLCiBEjsHz5cly/fr1J+9NaiFuPxK0btdd3//59TJo0Cfr6+tDV1YWDgwMePHggsvy7JD1Opckoap+FHc8LFixo/A2VgaysLPj4+NQc/506dcLChQuRnZ0tcj/Enf5uGXH2qaHPSNy6Ku5xJg4619SXmJiIyspKpWnkKCkpgba2NtcxCEfErU9N+T7JzMyEq6sr9PT0YGRkBC8vLxQUFODJkydwcnKCvr4+TE1NMW/ePOTn5zf3W0AIaYLc3FxERkbC2dlZvAUYIYSQFuvWrVvM3d2d8Xg8NnDgQPb777+zyspKrmMplaKiIrZ582bWtm1b1q5dO7ZmzRqWn5/PdSyigKqrq5mBgQH7+eefGyx3584dNmnSJGZgYMAAMFVVVaapqckACH2pqamx/v37s9evX7OQkBAGoFXWY8H7MWHCBBYdHc1KSkrY6dOnmeByNisri1lYWDATExN25swZVlRUxCIjI5mFhQXr1q0by8vLq7e+adOmsRcvXrCnT5+yCRMmMADsn3/+EbltcaYnJSWxtm3bMjMzMxYREcGKiorY5cuX2ciRIxtdz6xZs9j9+/dZfn4+8/X1ZQDYvHnz6pSVZD+FZbl06RKzt7cXmUVckrwnoqZLsi9Tp05lANi2bdtYcXExKysrYw8fPmTOzs5N2g9l5eHhwVxcXCRerrF6JCgjad0YMWIEu3z5MisqKmLh4eHM1NSUGRoastTUVKHla5PmOJUmY2P73JTjSJrP4/nz56xz5841+11YWFjz3llYWLCsrCyh+/EuSadLs5w059fG3nNxKfu5RkVFhf35558SLyfK4cOHmaqqKistLZXZOuXJ2tqaff3112KVlfa8RsTX3NeRktQnab9PZs+eXXPttGjRIgaAOTg4MGdn53rXVJ988kmz7LdAa75uJ4pHGY/HXbt2MW1tbVZUVCRWcR5jdGsvIYS0dHfv3sV3332HP/74A71798ZXX32FWbNmQVVVletoSiMvLw9bt25FQEAAtLS08OWXX+LTTz+lR/BJjbS0NFhYWODy5ctiDTwOvL0j89q1a7h27RoiIyPx8OFDVFVVQUNDA1VVVaiqqgLwdgweNzc3uLu7w93dHZWVla2u/gru2L1w4QI+/PDDevMXLlyIwMBA7NmzBx999FHN9L/++gsuLi5YtWoVNmzYUGd9qamp6Nq1K4D/DeRqZ2eHyMhIodt+97JZ2PQ5c+bgwIED2L9/P2bPnl0z/fTp03BwcGhwPRcvXsTo0aMBAE+ePEG3bt1gZmaGjIwMqfZTVJZjx47V3BEl7X8FJHlPRE2XZF8MDAxQWFiII0eOwM3NraZsZmYmzM3NW93Tip6enigvL0doaKhEyzVWjwRlJK0bp0+fxuTJk2um//7775g3bx68vLywb9++euXFqTMNHafSZGxsn4VtR1zSfB7e3t7YvXt3vf0WvHc+Pj745ZdfGs0o6XRplpPm/Ao0/J6LS9nPNaqqqjh48CA8PDwkWk6UdevWISgoCI8fP5bJ+uTtvffew+TJk7Fx48ZGy3p6eiI1NRVffPFFMyRrnWJiYvD9998323WkJPVJ2u+T2tdOgvW+Oz09PR2dO3eGubk50tPT5bOzQoSGhsLNzQ2HDh2Cigp1pEO41dz1XxYmTZoEHR0dca+vdre+254IIaQVi4+PZ3PmzGFqamrM0tKSBQYGsoqKCq5jKZWXL1+yNWvWMAMDA2ZkZMTWrFnDXr58yXUsogAEd6k25XgoLi5mFy9eZJs2bWJ8Pp+1a9euzlMdH330kdLdgSMrgvfg9evXQuebmZkxACwzM7PO9NzcXAaADRgwoMH1V1ZWMgDMyMhI5LbFmW5iYsIAsIyMjDrT8/LyGl1PYWFhzbSysjIGgPF4PKn3U1SWFy9eKMSTHJLsy/z582vW0blzZ/bxxx+z4OBgVlZWJvU+KLOmPskhqh4JI07dePcJx/T0dAaAdezYUWj52mRxnIqTsaF9bmp9kObz6Nixo9D9Frx35ubmYmWUdLo0y0l6fpXmOJNFTlnkl/W5RvAkx4IFC5i/vz+7cOECq66ulmpdjDE2c+ZM5ujoKPXyzW3QoEFs1apVYpX18PBgPB6vznUPveTzaq7rSEnqk6CcpN8nta+dqqqqGpz+7jWVvAnunKcXvRTppSz/j8zLy2MaGhrs4MGD4i6yi5oSCSGkFenXrx+CgoIQHx8POzs7LFq0CFZWVti1a1ejgyCTt9q1awd/f38kJydj8eLF2LFjBywsLODn59esdwYRxZOQkAAzMzO0a9dO6nXo6Ohg9OjR+Prrr3HixAnhO56PAAAgAElEQVS8fPkSKSkpOHjwID777DMYGhrKMLFyatOmjdDpOTk5AAAzM7M6fTW3b98eAJCcnFxTNj8/H6tWrUKfPn2gp6cHHo8HNTU1ABA6BoYkcnNzAaBmuwJt27ZtdFk9Pb2af2toaABAvbuGJdlPUVne/ZsrkuzLb7/9htDQULi6uqK4uBh79uzBjBkz0LNnT8TFxXGSX5mJqkfS1g0DA4M6fws+wxcvXjSaRdLjVNqMovaZK4L3RtR+C+qHIpCkrtamKO+5IpxrMjIy8Oeff2LMmDHo3bt3vSeOxPXw4UOlGY9DQJKxU5ydncEYo5ecXiEhIXL8pOuTpj5J+n1S+9qp9tMSwqa/e03VXCorKzn/7OlFr+au/011/Phx8Hg8ODo6ir0MNXIQQkgrZGVlhX379iEpKQmOjo7w8/NDly5d4O/vj4KCAq7jKQUjIyP4+/vjyZMnWLNmDUJCQtCjRw8sXLgQSUlJXMcjHEhISEC/fv1kvt5u3bph5syZCAgIwAcffCDz9bcUJiYmAIBXr14JvbB//fp1Tdnp06dj06ZNmDFjBp4+fVpTRhYE/xkX/HAr8O7f0pJkP0VlUZTzvCT7AgAuLi4ICQmpGYTQ3t4eaWlpmD9/PhfxWyRp68a7jQuCY87Y2LjRZSU9TuVZf5tThw4dAIg+VwjmCwh+KK6oqKiZ1lx1WdK6qmgU4Vxz+vRpPHz4EAkJCejfvz/Gjh1bpzsycTDGkJiYqFSNHJqamigrK+M6BuGQpPWpKd8nhJCWY+/evXBwcIC+vr7Yy1AjByGEtGIWFhYICAjA48ePMXPmTHz33Xfo3r07/P39m3w3c2uhp6eH5cuXIyUlBQEBAQgPD4eVlRWmTZuGixcvch2PNKMHDx7IpZGDiGfatGkAILTeRUVF1Wkgio6OBgB88cUXNU/eyOpHmIkTJwIAIiIi6kwXbLOpJNlPUVmuXr0qkyxNJcm+8Hi8mqflVFRUYGdnh+DgYABv6x6RDWnrxrvHd3h4OID/HYMNkfQ4lUf9FTxxUFFRgZKSkmZ52onP5wOov9+C904wX8DU1BQA8Pz585ppt2/fFrl+We6TJHVVESnSuaZv374IDQ3F6tWrsXjxYvzzzz9iL/vs2TMUFxejT58+Tc7RXNq0aYOSkhKuYxCOSFOfmvJ9QghpGR49eoTIyEh4e3tLtiAjhBBC/qugoIBt3ryZGRkZMR0dHfbZZ5+xtLQ0rmMplaqqKnbixAk2fvx4BoANHjyYBQYGstLSUq6jETnr2LEj27Ztm1y3IejbV1n6UpUl/LcfWVFevHjBevbsyTp27MiOHDnCcnNzWWFhIQsLC2OWlpbs4sWLNWXt7e0ZALZy5UqWl5fHXr58yZYtWyZyG5JMT05OZm3btmVmZmYsIiKCFRUVsaioKDZ58mSZrF+S/RSWJTo6mo0aNarR97Mxzb0vAJi9vT2Lj49nb968YVlZWWzlypUMAHNycpJ6P5RVU8fkEEXaujF58mQWFRXFioqKWEREBOvYsSMzNDRkqampjW5f0uNUVvW3tuHDhzMA7PLly+zQoUMSj3kgzeeRlZXFLCwsava7sLCw5r2zsLBgWVlZdcrPnTuXAWCLFy9m+fn57MGDB2zWrFki96+xfZJXXW1o3dJQ9nONYEwOYWbNmsU6deok9tgl//zzDwPAcnNzJc7BFQcHB+bl5SVWWWnPa0R8zX0dKUl9ksX3iTTT5ak1X7cTxaNMx+OyZctYt27dWFVVlSSL7aJGDkIIIfUUFxezbdu2sc6dOzN1dXU2Z84cdv/+fa5jKZ3Y2Fg2c+ZMpq6uzjp27Mj+/e9/s+fPn3Mdi8hBVVUVU1NTE/lDhqwo08WpLAn+Y1r7JcyrV69qLorV1dWZiYkJ4/P57OrVq3XKZWdnszlz5rAOHTowDQ0N1r9/fxYcHCx0/aK221Ce+Ph4NnnyZKajo8P09PSYo6MjS05OZgCYiopKg/smzvrF3c93s+jq6rKJEyeyhISERt/LhkiaWRb7cvnyZebl5cW6du3K1NXVmYGBARs0aBDbsGGDTAY3VjbS/BgoTj2SpG7UXmdqaipzdHRkenp6TEdHh02ePLnedYO4daax47Qp9VfU8R4bG8sGDRrE2rRpw4YPH84ePXok0Xsr7Y+zWVlZzMfHh5mZmTE1NTVmZmbGvL296zVwMPb2h/qZM2cyY2NjpqOjw/h8PktLSxO5bw3tkzzrqrjvuThawrmmoUaOrKwspq+vzzZu3CjWurZt28Y6dOggcQYuzZgxg7m6uopVlho55K+5ryMlqU+y+D6R5twgT631up0oJmU5Ht+8ecOMjY3Zhg0bJF10F48xJezAlBBCSLMoLy/HoUOHsGnTJiQmJmLKlCn49ttvMWzYMK6jKZX09HT89NNP2L17NwoLC+Hs7AxfX1+MHj1aosEYieLKycmBiYkJLly4gA8//FBu2wkNDYWbmxsqKyuhqqoqt+0Q2cvMzIS5uTk6dOiA7OxsruMQJefp6Yny8nKEhoZymkPwHdba/0upKJ8HUTyqqqo4ePAgPDw8hM5fsWIFgoODkZKSUmfQZGF8fX1x//59XLp0SR5R5WLJkiW4e/euWJmpHsmfIl9HtsTvE0V+v0nroyzH48GDBzFv3jw8ffoUZmZmkiy6m8bkIIQQIpKGhgbmzp2LhIQEHDt2DDk5ObCxsYGtrS3CwsK4jqc0OnXqhE2bNiEjIwMHDx7Eq1evMGbMGPTu3RtbtmzBq1evuI5ImigrKwvA//pMJ60bj8dDUlJSnWmRkZEAgDFjxnARiRBCiAKaP38+nj59KtY4bg8fPlSq8TiAt4O+C66RCCGEkMb8/PPPmDp1qqQNHABo4HFCCCFiUFFRAZ/PR0xMDKKiomBoaAgnJydYW1sjKCgIVVVVXEdUCpqamnB3d8e5c+dw69YtjB49GuvWrUOXLl0wf/58REVFtai7l1oTwZ351MhBBBYtWoSUlBS8fv0aERERWLFiBfT19eHv7891NEIIIQqid+/e6N+/v1gDkD948AC9e/duhlSyQ40chBBCxBUZGYkrV65g6dKlUi1PjRyEEEIkIniK4+bNm+jfvz/mz5+PQYMGISgoCBUVFVzHUxrvvfcedu3ahYyMDGzevBl37tzBqFGj0KtXL2zYsAHp6elcRyQSKCoqAgDo6+tznIQogvDwcOjq6mLEiBFo27YtPD09MXz4cMTExCjsD1Q8Hk+sFyECtY8HOjaIuOhcU9+HH37Y6JMcL168QHZ2NgYMGNA8oWTE3NwchYWFKCwsBPC2K6Lg4GBkZmZynIwoEvo+IYQAwKZNmzBq1CiMHDlSquWpkYMQQohUBE9x3LlzB9bW1vj444/Rs2dPBAQEoKSkhOt4SsPAwACLFy/GrVu3EBcXhylTpmDbtm3o2rUrJk+ejODgYJSWlnIdkxAigXHjxiE0NBRZWVmoqKhATk4OgoODFbaBA3j7w5M4L0IE6Ngg0qBzTX0jR47E7du3UV5eLrLM3bt3AUDpGjmsrKwAAI8ePUJeXh6cnJzg4eGB//znPxwnI4qkNdd/Qshbd+7cwZkzZ7By5Uqp10GNHIQQQpqkf//+CAoKQlJSEqZOnYpVq1aha9eu8Pf3R15eHtfxlMqgQYMQEBCAjIwMBAcHQ1VVFbNmzYKJiQnmzp2Lv//+G5WVlVzHJIQQQgghMtK3b19UVlbi8ePHIsvcu3cPxsbG6NChQzMma7pu3bpBW1sbYWFh6N+/P86cOQMAOHz4MP2YTQghpMaGDRswcOBA2NvbS70OauQghBAiExYWFggICMCTJ0/w6aefYvv27bCwsICfnx89ki4hDQ0NuLq64uTJk8jJycF3332HlJQUODg41DR4hIeH038OCSGEEEKUnJWVFVRVVfHgwQORZeLj4zFw4MBmTCUbPB4PFhYW2LBhA7Kzs2u6tn3+/Dlu377NcTpCCCGKIDExEUePHsWqVaua1GUdNXIQQgiRKWNjY/j7++Pp06dYt24dQkJC0K1bN8ydOxeJiYlcx1M67dq1g7e3Ny5fvoykpCQsW7YMN2/exIQJE9C1a1csXboUUVFRqK6u5joqIYQQQgiRkKamJkxMTBocj+3evXvo379/M6ZquoKCAri6uiIxMRHV1dWoqqqqmaehoYFjx45xmI4QQoii+Pbbb9GzZ0+4uro2aT3UyEEIIUQu9PT04Ofnh5SUFOzevRvXrl1Dnz59wOfzcfPmTa7jKSVLS0t88803SEhIQFxcHObMmYMzZ85g1KhRMDc3h6+vL8LDw6lLKw5oaGgAAMrKyjhOQgghhBBlY2JigpycHKHzqqurcf/+faUajyM2Nhb9+/fHyZMnhd6IU15ejuDgYA6SEUIIUSQxMTE4cuQItmzZAlVV1SatS01GmQghhBChNDU1MXfuXMyePRunTp2Cv78/hg4divHjx2Pt2rUYMWIE1xGV0qBBgzBo0CCsX78e9+/fx9GjRxEaGopffvkFRkZGcHBwgKOjIyZOnAgDAwOu47Z4HTt2BPC2+wVLS0u5by8kJAQqKnSvCiGt1bNnz1BZWYkjR45wHYWAPg/SdB06dBDZyJGamori4mKleZIjOjoao0ePBmOswSeNExMTkZSUhB49ejRjOtk4dOgQfvjhByQmJiI/P79m+rtdydbudkWRupml68jmERMTw3UEhcVF3ZDVNpW9/iua5cuXw87ODk5OTk1eFzVyEEIIaRYqKirg8/lwdHTEyZMnsXnzZowcORIjR47EihUr4Ojo2KT+F1uzvn37om/fvvjXv/6FlJQUHD16FGFhYfD09ISKigrs7Ozg6OgIR0dH9OzZk+u4LZK5uTkAID09vVkaOTw8POS+DUKIYuPxeJg+fTrXMch/0edBhBH32lZHRwevX78WOi8+Ph48Hg99+/aVZTS56d27N8aOHYvw8HDweDyRP+6pqanh2LFjWL58eZO2Z2dnBwCIiopq0nrEFRQUBC8vL0yePBlxcXEwNTXFqVOnhHazwhhTyP/f0HUk4RoXdUMW22wJ9V+RhIaGIjo6WmYNgtR0SwghpFnxeDzw+XxER0cjKioKhoaGmDp1KgYPHoygoCDqaqmJLC0tsXz5cly6dAk5OTn4/fffYWJigvXr16NXr16wsrLC559/jlOnTqG4uJjruC1Ghw4doK6ujoyMjGbZXmVlJRhj9KIXvVrpy8PDA87OzpznoBd9HvRq+CXuD1za2tooLS0VOu/evXvo1q0b9PT0ZHkpITdGRkY4e/YsgoODoaurW9Ol57uqqqpk8vRTdXV1s45Nt3XrVgDA999/DwsLC2hqasLFxQWMKc+d2nQd2TyvkJAQrj9qTvF4vBb3I39LqP+KoqKiAitXroSnpyfef/99mayTGjkIIYRwxtbWFmFhYbhx4wasrKwwf/589O3bF7/++iuNbSAD7dq1g6enJ/744w/k5OTg0qVLmDZtGi5evAg+nw8jIyOMHj0a69evR0xMTJ0BIYlkVFRUYGpq2myNHIQQQghpObS0tBps5FCm8TgE3N3dce/ePYwYMUJo10iMMcTGxuL58+dN2k50dDSio6ObtA5JJCYmAoBSdrNFCGkaqv+y89NPPyEtLQ0bNmyQ2TqpkYMQQgjnrK2tcfjwYTx+/BiTJ0/GkiVL0KVLF/j7++PVq1dcx2sRVFVVMWrUKGzZsgVxcXHIysrC3r17YWlpicDAQAwfPhzGxsZwdnbGtm3bcOvWLWr0kJC5uTmePXvGdQxCCCGEKJmqqiqRA67Gx8crZSMHAFhYWOD8+fPYuXMntLW1oa6uXme+iooKwsLCOEonHUFj1Lv7Qghp+aj+y8azZ8+wevVqfPnll+jatavM1kuNHIQQQhSGpaUlAgIC8OTJE/j6+mLHjh2wsLCAj49PzV0TRDY6dOiAmTNnYu/evXj27Bnu378Pf39/MMawfv16DBkyBEZGRnB0dMR//vMfXLt2jboSa0S/fv1w9+5drmMQQgghRMmUl5dDU1Oz3vSysjI8fvxYaQYdF4bH48Hb2xv379/H8OHD6zzV0dQufQTd4bzbJU7t6c+ePcPUqVOhp6cHExMTzJ49Gy9fvpR6e8K2ISpHQ3JycuDr64tOnTpBQ0MD5ubm8Pb2RlZWVp1yBQUFWLp0KSwtLaGlpQUjIyOMGDECy5cvx/Xr16XaD6K4xP28ax9zmZmZcHV1hZ6eHoyMjODl5YWCggI8efIETk5O0NfXh6mpKebNm1dnoGyBrKws+Pj41ByLnTp1wsKFC5GdnS11WWF1ZcGCBUL3Wdw6Km6dAYCEhARMmTIFurq6MDAwgLOzM9LS0kS/8WKg+i87S5YsgampKb755hvZrpgRQgghCqqoqIht27aNdenShamoqDBHR0d29epVrmO1eNXV1ezevXvsxx9/ZNOnT2empqYMANPR0WGjR49mK1asYH/99Rd7/vw511EVyo8//sjatm3Lqqur5baNkJAQBoBVVlbKbRuEEMXn4eHBXFxcuI5B/os+DyKKiooK+/PPPxst5+rqymbMmFFvelxcHAPAEhIS5BGv2VVXV7PAwECmra3N1NXVGQCmrq7OCgoKpK5HAJiwn7YE02fNmsXu37/P8vPzma+vLwPA5s2bJ/U+NLY9caZnZWUxCwsLZmJiws6cOcOKiopYZGQks7CwYN26dWN5eXk1ZadOncoAsG3btrHi4mJWVlbGHj58yJydnYVuryF0Hdm8pHm/Jfm8BcfW7Nmza47xRYsWMQDMwcGBOTs71zv2P/nkkzrreP78OevcuTMzMzNjERERrLCwkIWHhzNTU1NmYWHBsrKypCpbO58owuro4sWLhdZRSepMUlISa9u2bU3OoqIidunSJWZvb99opsZQ/W+6kJAQxuPxWHh4uKxXvYsaOQghhCi8qqoqduLECTZs2DAGgI0cOZKdOHFCrj8mk7oePnzIfv31V/bxxx+zfv36MRUVFQaAWVhYMA8PD7Zt2zYWHR3NiouLuY7KmatXrzIA7OHDh3LbhqJcnBJCuEU/qisW+jyIKOI2cvD5fDZ37tx60/fv3880NDRYeXm5POJxJjExsea6HgD7888/5dbIcfHixZppqampDAAzMzOTOrssfuT08fFhANiePXvqTD969CgDwFatWlUzTV9fnwFgR44cqVM2IyNDaX/kbC2keb8l+byFHeOCcu9Of/bsGQPAzM3N66zjk08+YQDY/v3760zft28fA8B8fHykKls7nyjCcqanpwuto5LUmdmzZwvN+ddffylEI0drrv8FBQXM3NyczZ8/Xx6r30XdVRFCCFF4Kioq4PP5iImJQVRUFAwNDTF16lRYWVkhICAAb9684Tpii2dlZYWPP/4Yv/76K+Lj41FQUICoqCgsXboUVVVV2LBhA0aOHAkDAwN0794dfD4f/v7+CAsLk7pLAGUzdOhQ6Onp4eLFi1xHURjSPL5NCCFENhTxHHzo0CHY2NjA0NCwwXyKmF2eysrKoKGhUW96fHw8evfu3eL6f+/ZsyeuXLmC//u//4OGhgbCw8Plti1ra+uaf5uZmQFAkwc7byrBOCSTJ0+uM33UqFF15gOAq6srgLcDuXfp0gULFizA4cOH0b59ezDGmikxaS7SfN61j3FTU1Oh0wXHfmZmZp1lT548CQAYO3Zsnenjx4+vM1/SspKonbNjx44A6tdRSerMuXPnhOa0tbWVKp+sKUL9nzt3Ljp37oxJkyZh3759KC8vl3pdkvj6669RVlaGLVu2yGX91MhBCCFEqdja2iIsLAxxcXEYM2YMvv76a3Tt2pUGKW9murq6sLW1hZ+fHw4fPoycnBwkJyfj0KFDmDFjBioqKvDzzz/DyckJHTp0gJWVFdzd3bF27VqEhITg0aNHLW5gczU1NYwcORIXLlzgOorCaOji287ODnZ2ds2YhhBCWhdF+wE0KCgInp6eMDIyQlxcHN68eYPQ0FChZRUtu7yJGpPj3r17SjvoeGNUVVWxfPly3L9/X/b9steip6dX829BQxLXx1dOTg6Atz88127Qa9++PQAgOTm5puxvv/2G0NBQuLq6ori4GHv27MGMGTPQs2dPxMXFcZKfyI80n3ftY7z2mDfCpr977L948QIAao49AcHfgmNV0rKSECenJHUmNze3wZxcU4T6v2DBAixbtgx6enrw9fXFiBEj8OTJkybtV2POnz+PwMBAbNu2DcbGxnLZBjVyEEIIUUoDBw5EYGAgUlNTsXDhQmzfvh0WFhbw8/Nr8qBiRDqWlpZwc3PDxo0b8c8//yAnJwdPnz5FaGgoPDw8UF1djYMHD8LDwwO9e/eGrq4urK2tMXfuXGzZsgXHjh3DgwcPmu1OEnmwt7fH2bNnUVFRwXUUhVddXY3q6mquYyik1nT3MpfofSZEPLKqK1u3bgUAfP/997CwsICmpiZcXFw4/8FZEZSWlkJLS6ve9Hv37in1oOPi6N69O7p168Z1jGZlYmICAHj16hUYY/Ver1+/rlPexcUFISEhyM3NRWRkJOzt7ZGWlob58+dzEZ/IWXN+3h06dADwv4YBAcHfgvmSlpU1SeqMoLHg3ZwFBQVyyycJRaj/o0aNwtKlS3HkyBEkJCSgqqoKfD6/3rZlJS8vD/Pnz8e0adMwa9YsuWwDoEYOQgghSs7U1BT+/v54+vQp1q9fj7/++gvdunUDn8/H9evXuY7X6nXp0gXTpk3D2rVrERoaisTERBQVFeHGjRsIDAzE+PHjkZubi507d8LFxQV9+/aFjo4OevbsCQcHByxbtgy//PILzp8/jydPnqCyspLrXWrQtGnTkJeXh0uXLjVYzsPDA59++imuXLnSTMkUT3R0NKKjo7mOQQghpJkkJiYCAHr06MFxEsWTk5NT787W/Px8pKent9gnOVqzadOmAYDQLk6joqLwwQcf1PzN4/GQnp4O4O1d7nZ2dggODgYAPHjwQP5hSbNq7s+bz+cDACIiIupMF3QhJ5gvaVkAaNOmDQCgoqICJSUlTXqSQpI6M3HiRKE5r169KvX2ZUnR6r+lpSXCwsKQnp6On376SSbrfNfChQtRXV2N3bt3y2X9NeQx0gchhBDClfL/Z+++w6K43reB35SluHRBqkGIIDZsWLE3REGxgBp7AY2o+DUmtiQajcYSC4mVYMWuMVFAURFUQDS2gCAiFkC6CMuytAX2vH/kZX+ioIDALPB8rmsvYXbmzM2UdXeenXPEYnbmzBlmY2NDg5Q3MPn5+ezff/9lZ86cYevXr2dTp05l3bt3Z5qamtJB23g8HjM3N2dDhgxhc+bMYT///DM7fvw4u337NktKSpKJgRQ7derEvv7664/Ow+fzpYO3t2zZkq1du5Y9f/78k23LwoBx1YXPHOCvKaJtVj8a8namga5liyzvj9o4zmvrXKluOw35HC1T1YHH+Xw+O3jwYLlpwcHBDABLSkqqq3gypa4GHq/q9Ppc35s3b5iFhQUzNDRkZ8+eZZmZmUwoFDJfX19mbm5ebiBmAMzOzo5FRUWxwsJClpaWxlauXMkAsNGjR1cre0N8H9mQ1WR7V2d/18axmJaWxkxNTZmRkRG7fv06EwqF7Pr168zQ0JCZmpqytLS0Gs3LGGO9evViAFhoaCg7deoUc3BwqHHO6pwzL168YFpaWtKcubm5LCwsjPXv35/O/48cj0uXLmUWFhbVarMq9u3bx+Tl5dn169drve33eDXsdwyEEELIR4SEhDAHBwcmJyfHrK2t2f79+1lBQQHXsUgNpKens/DwcHby5Em2ceNG5urqyoYOHcq+/PJLxuPxpG8gFRQUmLGxMevduzcbP3488/DwYFu3bmXHjx9nN2/eZE+ePGGZmZl1mnXTpk1MR0eHFRYWVjqPioqKNDMApqioyAAwa2trtnPnTpaRkVHhcjX9sFT2eP78ORs7dizT0tL64E13eno6mz9/PjM2NmY8Ho8ZGRkxV1dXlpqa+kGb165dY46OjkxLS4spKyuzLl26VHoRp6I39+9mel9UVBSzt7dnfD6fqaurs+HDh7Po6OgKl3l3WmJiIhs9ejRTU1NjLVq0YFOmTPlgX787f3JyMhs3bhxTU1NjOjo6bPr06UwgELBXr14xR0dHpq6uzvT19dmMGTNYdnb2Bzmrur0+J2PZY86cORVu2495d/no6GhmZ2fH1NXVGZ/PZyNHjmRPnjz5YJmq7teqHlM1aY+L/VLZdq5JW5VtD4FAwJYsWcLMzMyYsrIy09HRYb1792bffPMNu3v37kf2ZMVk+aJ6U1Rf+6Mm53Vlr7WpqanMzc1NenwbGxuzefPmfXCRqi5ekyp7VDV7Vc/N2j7vaqIqRY68vDwGgPn6+pabvmPHDta8efO6jCdTanIeVXYMVXc6F+vLyspiS5cuZWZmZozH4zF9fX3m6OjIwsPDy80XGhrKZsyYwVq1asV4PB7T1NRknTp1Yhs2bGB5eXnVyk9FjvpVk+1d1f1dm8diWloamzdvHjMyMmKKiorMyMiIubm5ffD/QXXnvXfvHuvUqRNr1qwZ69WrF4uNjf2snFU9Zxgr/3lCTU3to58nqqqxn/9XrlxhACr9HFoTcXFxTE1Nja1evbrW2vwIKnIQQghp/P799182bdo0xuPxmIGBAVuzZg3LysriOhapJSUlJSwxMVH6LaHt27ezJUuWMGdnZ9anTx9mYmIiLSKUPZSUlJixsTHr0qULs7e3Z9OnT2fLli1jv/zyC/Py8mJnz55l169fZ48ePWLx8fFMKBRWOU9qaipTVFRkZ86cqXQeJSWlCi/wyMnJMQUFBaaoqMjs7e3ZkSNHWH5+vnS5mn44LWt/2LBhLCwsjOXn57NLly5J33CXfTNLX1+fXblyheXm5rJbt24xU1NTZmZm9sHFZADMycmJvXnzhiUkJLBhw4YxACwgIKDSdVdl+vPnzz/45lVoaGvsWscAACAASURBVCiztbX9ZDtTpkxhT548YQKBgH399dcMAJs5c2al80+dOlU6v7u7OwPARo0axcaOHftBO66uruXaqMn2qknGz1XWTp8+fVhoaCjLzc1lgYGBzMDAgGlra7NXr159MH9192tlx1RN2+Niv1Skpm1Vtj3GjBnDALCdO3cykUjEioqK2NOnT9nYsWNrtK+pyCFb6nN/1OS8fv8YS01NZS1btiz3bdyyNir6Nm5tvyZ9zvTqnJu1fd7VRFWKHK9evWIAPii8zJw5kw0dOrQu48kUel2re1TkqF+0vYks+dTxmJCQwABUWDSqicLCQtalSxfWo0cPJhaLa6XNT6AiByGEkKYjJSWFrVmzhmlpaTF1dXW2ePFilpiYyHUsUg9KS0tZamoqi4yMZFevXmU+Pj5s+/btbPny5WzmzJls1KhRrEePHszc3LzcN7DfffB4PKarq8vMzc1Zly5dWN++fdmIESOYs7Mzmzt3LluyZAn7/vvv2aZNm1j79u2ZlZUV8/HxYWfOnGF+fn7s2rVr7Pbt2+z+/ftMQUGhwnW8+1BUVGRycnJMTU2NTZs2jV27do2dPXv2s4ocwcHBFT4/b948BoAdOHCg3PTz588zAGzVqlUftPfuhbSYmBgGgPXr16/SdVdl+tSpUxkA5uPjU266v7//J9t599busgtGRkZGVZo/OTm5wumvX79mAJixsXG5NmqyvWqS8XOVtXPp0qVy0w8fPswAsBkzZnwwf3X3a2XHVE3b42K/VKSmbVW2PTQ0NBgAdvbs2XLTy/7G6qKLgbKFiyJHdc7r948xV1fXCl9ry9qYN2/eJ9v4nOyfM70652Ztn3c1UZUix927dxkA9vLly3LTO3fuzJYtW1aX8WQKva7VPbroXr9oexNZ8qnj8c2bNwwACwoKqpX1zZkzh2lqalapS+Za4iXHGGMghBBCmhChUIhDhw7h119/RXp6OpycnPDdd9/BxsaG62hERkgkEmRnZyMrKwtZWVnSn3NyciAUCpGTkwORSCR9CAQC6c95eXnIzs5GdnY2FBUVKxwsXU5ODjV5C+bo6AhfX1+UlJRAQUGhysvJyckBAPLy8qSDAL7L2NgYKSkpSElJgaGhoXT627dvoauri44dOyIyMrLS9ktLS6GoqIjmzZsjMzOzwnW///dWNN3AwADp6elITk6GkZGRdLpAIIC2tvZH2xEKhVBXVwcAiMViKCsrQ05ODhKJ5JPzSyQS6fasaPr77VR3e9U04+e+TS9rRyAQQFNTUzo9OTkZJiYmMDQ0REpKSqXLV2W/VnZM1bQ9LvZLRdu5pm1Vtj1mz56NQ4cOAQBatmyJ4cOHY/jw4XBycoKSktInt937Jk+eDLFYjD///LPay5LaV5/7o7rndUXHuZGREVJTUz94rS1rw9jYWDrQaWVtfE72qvx/UNn06pybtX3e1YSCggKOHz+OGTNmgM/nQ0VFBebm5rC0tESvXr0wdOhQxMTEwMHBASKRCHw+H8B/A/Wqq6vD29sbU6dOrZesXKPXtbr3559/YsKECdV+H0lqhrY3kSWfOh7j4+NhZmaGu3fvokePHp+1rj179mDhwoU4d+4cxo0b91ltVcMfVOQghBDSZInFYpw6dQpbtmxBdHQ0bG1tsXz5cjg4OEg/WBNSE4wxtG/fHn369IG3tzdEIhGKi4uRm5uL4uJitG7dukrt8Hg8FBcXw8DAAFOnToW5uTkWLFhQ4yJHZW/7eDxehcWYMs2aNUNeXh6A/y6sbdmyBX/99ReSkpIgEonKzfs5F68UFRVRWlqKoqKiDy5A1cbFsdqaXp3tVZtZqquydoqKiqCiogJFRUUUFxcDqL39WqYuj5PKptfWfqnttsqcP38eJ06cQFBQELKzswEAX3zxBS5cuIDOnTtXulxF6GKgbOGiyFGV87qy+cuO7/dfa8va4PF4EIvFn1xnbWWvy/O8Ns+7migrcsjJySEnJwf5+fl48eIFYmNjER4eDpFIBCsrK7x8+RJFRUXS5SIiItC5c2c8fvwYHTp0qPOcsoCr17WqvudvDJfO6KJ7/aLtLfvo/P8/4eHh6NOnD+Lj42Fqalrj9YSHh2PgwIFYvXo1fvzxx8+JXF1/yNfn2gghhBBZoqSkhOnTpyMqKgohISHQ1tbG6NGj0aVLFxw9erTcRQJCqkNOTg5Lly6Fj48PEhMToaamBm1tbXzxxReffNPI4/EAAHp6evj6668REhKClJQUbN26FS1atKiTvPr6+gCArKwsMMY+eLx7wcjFxQW//PILJk6ciISEBOk8tUFXVxcAPviW//u/c60620sWvH37ttzvZdtTT09POq2292tdHieVqc39Uhf7eNy4cTh37hwyMzNx69Yt2NnZITExEbNmzap2W4RU5byuTNn/JZW91tbV/zW1obrnpqycdxMnToSbmxuWLFmC33//HVevXkVWVhauXLkCiUQCsViMKVOmID8/H8B/RQ5lZWW0adOmXnM2RRUdRxU9CCGND53//yciIgLq6upo2bJljdtITU3FhAkTMGLECHz//fe1mK5qqMhBCCGEAOjbty98fX3x8OFDWFtbY86cOTA1NcXatWshEAi4jkcaoBkzZsDY2BgbN24sN720tPSDeSsqbKSnp8PT0xN9+/at8zuLnJycAAA3btz44LmQkBD07t1b+ntYWBgA4JtvvoGOjg4AlPv26ecYPnw4AOD69evlppetU1ZUZ3vVRFl3R8XFxcjPz5cWf2rq/e0XGBgI4P+297vz1NZ+rcvjpDLV3S8f2861vY/l5OSk3f/Iy8ujX79+OH36NAAgJiamWm0RAlTtvK6Mo6MjgA9fa8vaKHu+TG2/Jn2O6pybsn7e8Xg8DB8+HLa2tujatSuuXr0KR0dHFBUVISIiAh06dJC+PyCEEELq0r1799C1a1fIy9esVFBcXAwXFxeoq6vj6NGjNW7ns3xy2A5CCCGkCXr58iVbtGgR4/P5TEtLi61YsYKlpKRwHYs0MN7e3kxJSancYKJ5eXkMAJOXl2cAmK6uLlu0aBELCQlhpaWlH22vpgMY4hODxr5584ZZWFgwQ0NDdvbsWZaZmcmEQiHz9fVl5ubm5QZ9trOzYwDYypUrWXZ2Nnv79i1bunRprQwo++LFC6alpcWMjIzY9evXWW5uLgsJCWH29va10n5tTa/O9qrJOnv16sUAsNDQUHbq1Cnm4ODwwTxVUda+vb09CwkJYbm5uez69evM0NCQaWtrlxsUvLb2a223V5f75WPbubb28bvP29nZsaioKFZYWMjS0tLYypUrGQA2evToSperDA3QK1u4GHi8Kuf1u/O/Ky0tjZmamkpfa4VCobQNU1NTlpaWVm7+2n5N+pzp1Tk3a/u8q4mqDDw+ePBg5urqyiIjI5m6ujpbuXIlGzx4MJs9e3a9ZJQV9LpW92gg7PpF25vIko8djxKJhBkbG7Offvqpxu3Pnj2baWhosJiYmM+J+Tm8qMhBCCGEfEROTg7buXMnMzY2ZkpKSszZ2ZmFh4dzHYs0EGKxmLVp04a5uLhIp5WUlLCBAwcyd3d3dvPmzU8WNt5Vkw9LZReJ3n1UJCsriy1dupSZmZkxHo/H9PX1maOj4wfHe3p6Ops2bRpr0aIFU1JSYh06dGCnT5+usP3K1vuxPFFRUcze3p7x+Xymrq7OHBwc2IsXL6SFoY/9bfU1vTrbqyZt37t3j3Xq1Ik1a9aM9erVi8XGxrKaKGv71atXzMHBgamrqzM+n8/s7e3ZkydPys37Ofu1omOqLo+T2tgvjH16O9d0H1e0PUJDQ9mMGTNYq1atGI/HY5qamqxTp05sw4YNLC8v74P5P4UuBsoWLoocVTmvP3ZcpqWlsXnz5jEjIyOmqKjIjIyMmJub2wcFDsZq5zWJi/O8ts+7mqhKkcPc3Jz9/PPPjDHGdu/ezZSUlJiOjg7z9PSsj4gyg17X6h5ddK9ftL2JLPnY8Xj//n0GgN27d69Gbf/0009MQUGB+fr6fm7Mz+FFA48TQgghVVA2SPm2bdsQGRkJW1tbeHh4YNy4cTSQHPkoX19fjB49Grdu3UK/fv0+q62mOoBhSkoKjI2N0aJFC6Snp3Mdp8GorcGCieyhgcdliywMPE5kU9nA45MmTarweYlEAlVVVRw8eBBTpkxBUVERTExMkJmZiZs3b6J///71nJg79LpW95rq+0iu0PYmsuRjx6OHhwcuX76M2NjYaneTfPz4cUybNg2//fYbFi5cWJuRq4sGHieEEEKqomyQ8oiICISEhMDIyAiTJ0+GpaUlNm/eTON2kEo5OjpiyJAhWLp0aYXjcZDy5OTk8Pz583LTbt26BQAYNGgQF5EIIYSQOpGSkgKxWAxTU1MAgLKyMqytrQEAHTt25DIaIYSQJqCgoADHjx/HzJkzq13gCAoKwuzZs7F69WquCxwAaOBxQgghpNr69u2LM2fO4OnTp3BwcMD69ethamoKDw8PJCQkcB2PyCBPT09ERkZiz549XEdpENzd3fHy5Uvk5eXh+vXrWL58OTQ0NLB27VquoxFCCCG1Jj4+HgDQqlUr6TRVVVUoKChAW1ubm1CEEEKajMOHD0MkEmH27NnVWu7hw4cYM2YMJkyYgHXr1tVRuuqhIgchhBBSQ61bt4anpyeSk5Oxbt06/PXXXzA3N4ejoyMCAwO5jkdkSPv27fHtt99i9erVSEpK4jqOTAsMDISamhr69OkDLS0tTJ48Gb169cLdu3dhZWXFdTxOycnJVelRNu+7yxFCGj5ZO6+r85pEKhYfHw8lJSUYGhpKp2VlZaG0tBRisZjDZIQQQhq7oqIibNu2DdOnT4eBgUGVl3v16hVGjRqF7t2749ChQzLzfz0VOQghhJDPpKmpCQ8PD7x48QKnTp3C27dvMWzYMNjY2ODo0aMoLi7mOiKRAd9//z0MDAywYMECrqPItCFDhuDPP/9EWloaiouLkZGRgdOnTzf5AgfwXx/8VXlUNC8hpOGTtfO6Oq9JpGKxsbFo3bp1uf7Ry+7uoC4uCSGE1KXt27cjJSUFq1evrvIy6enpsLe3h6GhIS5cuAAlJaU6TFg9VOQghBBCagmPx4OzszNu376N+/fvo127dpgzZw5MTU2xdu1aZGVlcR2RcEhFRQUHDhzApUuX4O3tzXUcQgghhHDs2bNnaNOmjfR3kUiEtLQ0AICioiJXsQghhDRyaWlp2LRpE1auXCkdF+pTMjMzMXToUEgkEly6dAnq6up1nLJ6qMhBCCGE1IFu3brh6NGjePbsGaZPn47ffvsNpqammDdvHmJiYriORzjSr18/LFu2DEuWLEFcXBzXcQghhBDCodjYWFhaWkp/j4iIAGMM6urq4PF4HCYjhBDSmC1btgxaWlr45ptvqjR/Tk4O7O3tIRQKcfXq1Wp1b1VfqMhBCCGE1CEzMzNs2rQJCQkJ2LZtG27cuIEOHTpg2LBh8PX1pW4cmqCffvoJrVu3xowZM6grM0IIIaSJYowhLi6u3J0c//77L1RUVGBiYsJhMkIIIY2Zn58fTpw4AU9PTzRr1uyT8wuFQgwfPhxpaWkIDg5Gq1at6j5kDVCRgxBCCKkH6urqcHNzQ0xMDP7++28AwOjRo9G1a1d4eXmhsLCQ44SkvigrK+PMmTOIioqqVv+nhBBCCGk8Xr9+jfz8/HJFjoiICPD5fHTq1InDZIQQQhqr169fY9asWZgxYwacnJw+OX9+fj4cHR2RkJCAa9euwdzcvB5S1gx18kgIIYTUI3l5eTg6OsLR0REPHz7Ezp07sXDhQvz444+YP38+Fi5cCF1dXa5jkjpmaWmJ/fv3Y8qUKejTp0+V3mC+a9KkSZCTk6ujdIQQWXfnzh1IJBK4uLhwHYWA9gep3Mfu2I2NjQWAD4ocRUVF6NKlS51nk0V3796l86gOJSUlAaD3kfWFtjeRJWXHo5OTE/T19fH7779/cpmCggI4ODggJiYGwcHBsLKyquuYn0WOUT8ZhBBCCKfS0tKwb98+7Nq1CyKRCC4uLvjuu+/QoUMHrqOROjZnzhz8/fffuHv3Llq3bv3J+RMTE7FixQqUlJTUQzpCCCGEfA4FBQVs3LgRZmZmHzy3a9curFmzBm/fvgUAlJSUQENDAwUFBbh69SqGDRtW33E59eeff+L06dOf1QZjDEVFRRCLxSgtLUVJSQkkEglKS0ul/5aWlkrnl5eXLzfAu5ycHBQVFcHj8aCgoCD9WVFREfLy1BEKIaThKi0txf3791FUVIQ7d+58ssspoVAIJycnREZGIigoCNbW1vUTtOb+oCIHIYQQIiMKCwtx5swZbN68GU+ePIGtrS2WL18OBwcH+vZPI1VQUIABAwZAJBIhPDwcmpqaXEcihBBCSD1YtGgRHj58iLCwMAD/jcfRpUsXyMnJISMjg+7sfUdpaSmSk5ORmJiIV69eISEhAQkJCUhOTsbbt2/x9u1bvHnzBkKh8KPtKCsrl+t/XiQSVXl8NDU1Nejp6UFfXx+6urrQ1dWFnp4eDAwMYGJigpYtW8LU1BQGBgZUECGEyJTCwkKMHTsW//zzDwIDAz95t2BqaipGjhyJ9PR0XL58uaF0oUhFDkIIIUTWSCQSBAUFwdPTE/7+/mjdujXc3d3h6upapYHBSMOSmpqKHj16oF27dvD39y/3jUJCCCGENE6DBw+GhYUF9u/fDwDYv38/Fi9eDCsrK0RERHCcjhvFxcWIjY1FdHQ0IiMjER0djaioKCQmJkqLEUpKSvjiiy9gamqKli1bonnz5mjevDn09PSkPzdv3hyqqqrQ0NCAgoICmjVrBmVl5U+uv6SkBLm5ucjJyUF+fj7y8/MhEAiQl5eHrKwspKen482bN3jz5g0yMzORkZGBtLQ0pKWlSe8Q4fF40qKHmZkZLCwsYGFhgdatW8PCwgLq6up1ug0JIeRdRUVFGDt2LO7cuYNr166hW7duH53/5cuXsLOzA2MMAQEBVeptQEZQkYMQQgiRZREREdizZw98fHygpKSEGTNm4Ntvv4WJiQnX0UgtevjwIfr16wdXV1fs3LmT6ziEEEIIqWMtWrTA999/j8WLFwMAZs+ejdOnT2PhwoXYvHkzx+nqnkQiQUxMDMLDwxEWFoYHDx7g6dOnKC4uBo/Hg4WFBTp06ICOHTviyy+/xBdffAEzMzMYGhrK3B3OJSUlSElJQWJiIhISEvD69Wu8fv0aL1++RFxcHBISEqRdjRoYGMDS0hJWVlbo2LGj9G9s3rw5x38FIaSxEYvFGDduHMLCwnDt2jXY2Nh8dP7AwEBMnjwZX375Jfz8/BraHYVU5CCEEEIagoyMDBw6dAi//fYbMjMzMWbMGHzzzTfo2bMn19FILTl9+jQmT56M33//He7u7lzHIYQQQkgdyczMhJ6eHgIDAzFkyBAAgKWlJeLi4nD9+nUMHjyY44S1TywWIywsDKGhoQgPD0d4eDgEAgHU1NTQvXt39OzZE9bW1mjfvj2srKygpKTEdeRaIxaL8erVKzx79gxxcXGIi4vDkydP8PjxY2RnZwMADA0NpQWPLl26oGvXrmjTpg0UFBQ4Tk8IaYjEYjEmTJiAW7du4erVq+jRo0el80okEvz8889Yt24dXFxc8Mcff4DP59dj2lpBRQ5CCCGkISksLMTx48exc+dOREVFYdCgQViyZAkcHByo/99GYNOmTVi9ejV8fHzw1VdfcR2HEEIIIXUgODgYgwcPRmpqKgwMDCAUCqGlpQVlZWUIBIIqda3UELx69QoBAQEICAhAUFAQRCIRWrVqBVtbW/Tq1Qu2trbo2LFjk+6qMzk5GVFRUXj8+HG5f8ViMfh8Pjp37oxu3bqha9eu6NatG9q1a0fv+QkhH1VcXAxnZ2cEBwfjypUr6NWrV6XzZmZmYtq0aQgODsbmzZvh4eFRj0lr1R9N938SQgghpAFSUVHBnDlzMGfOHISGhmLz5s1wcnKCmZkZ3Nzc4OrqCh0dHa5jkhpasWIFsrOzMXPmTGhqamLUqFFcRyKEEEJILYuKioKOjg4MDAwAAP/88w8YYxg4cGCDLnBIJBKEhYXh/PnzuHz5MmJjY6GmpoYhQ4Zg69atsLe3h6mpKdcxZYqxsTGMjY1hZ2cnnSYWixEVFYWHDx/iwYMHuHPnDry8vFBYWAgNDQ306NEDvXr1kj6oqytCSJnCwkJMmjQJQUFBnyxwnD9/HgsXLoSysjJCQkLQvXv3ekxa++hODkIIIaSBi42Nxe+//46jR4+CMYZp06Zh4cKFaNeuHdfRSA0wxjBv3jwcO3YMAQEB6N+/P9eRCCGEEFKL5s+fj5iYGNy8eRMA8P3332PDhg04deoUJk6cyHG66vvnn39w+vRpnDlzBklJSWjXrh1GjRqFESNGoG/fvo2q6ymulJSUICoqCuHh4bhz5w7u3r2LZ8+egTEGS0tL9O7dGwMHDkT//v1hbm7OdVxCCAeEQiHGjBmDiIgI+Pv7o3fv3hXOl56ejoULF+LPP//EzJkzsW3bNmhra9dz2lpH3VURQgghjUVubi5OnjwJT09PPHnyBLa2tvDw8MDYsWObdDcADVFpaSkmTpyIwMBABAQEfPQbOIQQQghpWPr16wdra2vs3r0bANC+fXvExsZKx6hoCJ48eYLjx4/j1KlTePnyJSwsLDBx4kRMmjQJ7du35zpek/D27VvcvXsXd+7cQWhoKO7cuYOCggK0bNkSAwcOxIABAzBgwAC0bt2a66iEkDqWnp4Oe3t7pKenIyAgAB07dvxgHolEgiNHjmDZsmXQ0NCAl5cXhg0bxkHaOkFFDkIIIaSxkUgkCAoKgqenJ/z9/akrqwaqqKgIzs7OuHnzJvz9/dG3b1+uIxFCCCGkFujo6GD9+vVwd3eHWCxGs2bN0LVrV/zzzz9cR/sosViMCxcuwMvLC9evX4exsTHGjRsHZ2dn2NraQk5OjuuITVpJSQkiIiIQGBiI0NBQ3Lp1C0KhEAYGBujXrx9sbW3Rt29fdO3alfYVIY1IfHw87OzsUFxcjKtXr1ZY2AwKCsKyZcvw+PFjuLu7Y8OGDQ1xcPGPoSIHIYQQ0pg9f/4c3t7e2L9/PwoLC+Hs7IzvvvsOHTp04DoaqYLi4mJMnjwZly9fxoULFzB06FCuIxFCCCHkMyQmJsLU1BQhISHo27cvzp8/j/Hjx2Pv3r2YP38+1/Eq9OrVK+zfvx+HDh1CVlYWHB0dMX/+fAwdOpQGwZZhYrEY9+7dw40bN3Dz5k3cvn0beXl5MDQ0lN7pMWTIELrTg5AGLCoqCnZ2dtDX18fly5ehr69f7vnY2Fj88MMPOHv2LIYOHYpt27bB2tqao7R1ioochBBCSFNAXVk1XKWlpZg1axbOnDmDs2fPwtHRketIhBBCCKkhPz8/jB49GllZWdDS0oKdnR0CAwMhEomgqqrKdbxybty4ga1btyIgIACGhoZwdXXF3LlzYWxszHU0UgPFxcW4d+8ebt68iZs3byIsLAwikQjm5uaws7ODnZ0dBg8eDHV1da6jEkKq4Pbt23BwcIC1tTUuXLgATU1N6XNRUVHYsmULTp48CUtLS2zZsgWjRo3iMG2d+4NK7oQQQkgToK6uDjc3Nzx+/BjXrl2DtrY2Jk6ciDZt2mDz5s3IysriOiKphIKCAg4dOoSJEyfC2dkZZ8+e5ToSIYQQQmooIiICpqam0NLSAgCEh4ejdevWMlPgYIzB19cXffr0waBBg5Cfn49z584hPj4ea9asoQJHA8bj8dCnTx+sXLkSAQEByM7Oxs2bNzF58mTcu3cP48aNQ/PmzTFw4EBs3LgRDx48gEQi4To2IaQCJ0+exNChQ9G/f38EBARICxx3796Fk5MTrK2t8ejRIxw+fBiPHz9u7AUOAAAVOQghhJAmRF5eHkOHDoWvry+ePXsGZ2dnbNq0CcbGxpg+fTqioqK4jkgqUFbomD9/PiZNmoQdO3ZwHYkQQgghNfD48WNpVyExMTHIzc3FuHHjOE7135huvr6+6N69O0aPHg0+n4+wsDAEBwfTnb+NlKKiIvr374+ff/4Z9+7dQ3p6Oo4fP442bdpg3759sLGxgb6+PlxcXODl5YWkpCSuIxPS5DHGsHnzZkyZMgXTpk3DuXPnoKCggDNnzmDQoEHo1asX0tLS8NdffyEyMhJTpkxpMt0KUndVhBBCSBNXWVdW48aNg4KCAtfxyHs8PT2xdOlSLFy4EDt27Ggyb1oJIYSQxqBdu3YYP3481q9fj2nTpuHYsWNITk6GkZERJ3kkEgl8fHywbt06JCYmwsXFBStWrEDHjh05yUNkA2MMkZGRuHLlCq5evYrQ0FCIxWJ06tQJdnZ2GDlyJPr06UPFL0LqkUgkwrRp03Dp0iXs3bsXQ4cOhZeXFw4cOIA3b95g1KhR8PDwwODBg7mOygUak4MQQggh/5FIJAgKCoKnpyf8/f1hZmYGNzc3uLq6QkdHh+t45B2nTp3CzJkzMWbMGBw9ehTKyspcRyKEEELIJxQUFEBDQwMnTpyAs7MzmjdvDmVlZaSkpHCS58qVK1i+fDmio6Mxc+ZMrFy5Eubm5pxkIbItLy8PN2/eREBAAK5cuYJnz55BR0cHdnZ2cHR0hJ2dHX1eIKQOJSQkYMyYMUhOTsbXX3+N+/fv4+rVq9DT08OcOXPg5uaGL774guuYXKIiByGEEEI+9Pz5c3h7e8PLywsFBQVwdnbGd999hw4dOnAdjfx/N27cwNixY9G2bVv8+eefMDQ05DoSIYQQQj7i/v376N69O54+fQqJRIJ27dphwYIF2L17d73miI6OxooVK+Dn54ehQ4di27Zt0i60CKmKly9fIjAwEL6+vrh69SpKS0vRuXNnODg4wNHREd26deM6IiGNxs2bN+Hk5AQAKCoqQklJCYYPH44ZM2bAyckJPB6P44QygYochBBCTFCChQAAIABJREFUCKkcdWUl2+Li4uDk5ASBQIDz58+jZ8+eXEcihBBCSCUOHjyIhQsXIjc3F7NmzYKPjw/i4uLQunXrell/YmIiVq9ejRMnTsDGxgZbt25F//7962XdpPHKycnB1atX4efnh8uXL+PNmzcwNzfHqFGj4ODggAEDBtBdx4RUk0AgwOXLl7Ft2zY8ePAAcnJy6N27N6ZOnQoXFxc0b96c64iyhoochBBCCPm0sq6svLy8cP78eZiamlJXVjIiNzcX06ZNQ0BAAPbu3YtZs2ZxHYkQQgghFfjf//6HsLAw/PPPP9DR0YGioiIyMjLqfL0lJSXw9PTEmjVrYGBggI0bN8LZ2RlycnJ1vm7StEgkEty9exd+fn7w9/dHREQE1NTUMHz4cGnRo0WLFlzHJEQmPXnyRFowvHXrFkpKSgAAI0aMwJ49e9CqVStuA8o2KnIQQgghpHqoKyvZU1paitWrV2PLli1YsmQJtmzZQgNBEkIIITJmyJAhMDc3x4IFC9C1a1e4urrCy8urTtd5584dzJ8/H7GxsVixYgVWrFjRKL5VLxQKkZeXh7y8POTk5CA3N1f6u0AggEgkgkgkKvd72fMAUFhYiIKCAml7AoEAZZfH3n8uOzu7WtlUVFSgqqpa6fPa2toAAHl5eWhqagIAFBUVoa6uDgBQUlICn8//oC1VVVWoqKhAXV0dioqK0NLSgoKCAjQ1NaXLlM2jpqYGHo8HTU1NKCoqStdT3xITE+Hv7w8/Pz8EBQVBLBajd+/eGD16NMaMGYM2bdpwkosQWfDixQsEBwcjKCgIwcHBSEtLg7a2Nrp3745Hjx5BUVERp06dojvuqoaKHIQQQgipGerKSvacOnUKc+fORefOnXHy5Em0bNmS60iEEEII+f/09PTwww8/4P79+/Dx8UFkZCQ6duxYJ+vKycnBjz/+iN27d6Nv377Yu3cv2rZtWyfrqg1v375FRkYGMjMzkZGRgfT0dLx58wZv3rxBRkYGMjIypL9nZmaisktZcnJy0NLSgpqaGpo1awY1NTVoaWmBz+eDz+dLCwk8Hg9qamrS5coKBxU9p6GhUeX3towxCASCSp+XSCTIyckB8N8dNrm5uQAAsVhcYQEmPz8fRUVFAACRSITi4mIIhUKUlJRAIBCUa+NTyv4uDQ0N8Pl8NGvWrNy2UVNTg6ampvQ5TU1NqKuro1mzZuDz+dDW1kazZs2grq4ODQ0NaGhoVGm9ZQoKChAYGAg/Pz/4+voiNTUV5ubm0nE8Bg4cSF/SIY1WUVERHj58iLt37+LOnTu4ffs2Xr9+DT6fD1tbWwwePBgDBw7E7du3sWLFCvTr1w/Hjh2DgYEB19EbCipyEEIIIeTzMMZw/fp16spKRjx9+hQuLi5ISUnBkSNHMGrUKK4jEUIIIU1ecnIyTExMEBQUhLFjx0JeXh5ZWVl1sq4zZ87Aw8MDjDFs27YNU6ZMqZP1VEVpaSlSU1ORkJCAhIQEJCYm4vXr10hMTERiYqK0cFHWLUsZXV1d6OnpQU9PDy1atIC+vj709PSk08suxvP5fOnF+LKL801RWWEkLy8PYrG4wkJIUVER8vPzIRAIkJ+fj/z8fOldMPn5+dK7Xsp+FgqFyM3N/WDfvEtbW1ta8Hj3oampCU1NzQqf09bWBp/PR2xsLG7cuAF/f3/ExcVBT08PDg4OGD16NIYPH95k9yVp+MRiMaKjoxEREYF///0Xd+/exaNHj1BUVARdXV307NkTvXr1wsCBA9GjRw8oKSkhMzMTs2fPxuXLl7F+/XosX76cuhSsHipyEEIIIaT2xMbGYteuXThy5AgYY5g2bRoWLVok098cbIwKCgqwZMkS/PHHH1i0aBF+/fVX8Hg8rmMRQgghTdbly5cxcuRIXL58Gfb29pgxYwYOHz5cq+vIycmBu7s7Tpw4AVdXV2zatEnaNVJdkkgkSExMxPPnzxEXF1fu8erVK4jFYgD/3UlgbGyMli1bolWrVjAxMYG+vj50dXWhr68v/VlPT4++0S9Dyu4yEQgEyMvLg0gkglAoRE5ODgQCAYRC4QcPgUCAnJycctPK7lR5H4/HA5/Ph7y8PIqKipCXlwcFBQUYGhqidevW6NixI4yNjT9aNKnO3TaE1JbS0lIkJCQgNjYW0dHRiIyMREREBGJiYlBcXAxVVVV06NABPXr0kBY2LCwsPmjn3LlzcHd3h4qKCk6cOAFbW1sO/poGj4ochBBCCKl9QqEQhw8fxq5du/D8+XMMHDgQ7u7uGDNmDH1orUeHDx+Gu7s7OnfujGPHjsHMzIzrSIQQQkiTtHnzZuzatQsDBgzA8ePHERYWhj59+tRa++Hh4Zg2bRpyc3Nx4MABODg41Frb70pJSUFUVBQeP36M6OhoREVF4cmTJ9IL2FpaWrCwsICFhQUsLS1hYWEBU1NTmJqawtDQkC5EN2GlpaUQCoXIzs6usDBSVjTJyMjA06dPER8fj/T0dJSWlkJZWRny8vIoLi6u9M6Ssq643r2bREtLS1oceb9IoqWlBS0trXLT6O4R8j6JRILk5GTEx8fj1atXiIuLQ2xsrPRR1p2ckZEROnbsiM6dO6Nz586wtrZGmzZtPvqal5GRgWXLlsHHxwfOzs7Yt28f9YRQc1TkIIQQQkjdebcrq7/++gu6urqYMWMG3N3dabyIehIdHY2vvvoKr169wo4dOzBnzhyuIxFCCCFNztSpU/H27Vvcvn1bOi6DvLz8Z7crFovxww8/4Ndff8WYMWPg5eUFXV3dWkj8X0Hj3r17uH//vvSRmZkJANDX10eHDh2kj3bt2sHS0rLW1k0I8N+YJNeuXcPFixfh5+eHjIwMfPnllxg+fDj69u0LCwuLcneMvH/3SHZ2doXPVzaOCY/HK1cgeb84Uvbz+910vVtgKRsAnjQMmZmZSE1NxevXr5GamoqkpCQkJSUhPj4e8fHxSExMlN6NpqysDHNzc7Rt2xZt2rRBmzZtpD9rampWa72nT5/GokWLoKqqij/++APDhw+viz+vKaEiByGEEELqR0pKCry8vLBnzx5kZWXB3t4eHh4eGDJkCPU3WseKi4uxYcMG/Pzzzxg2bBgOHDgAIyMjrmMRQgghTUbnzp1hZWWF06dPw8XFBadPn/7sNqOjozF16lQ8f/4cO3fu/KwvMpSUlODRo0cICQnBrVu3cO/ePaSkpEBOTg4WFhbo3r07bGxs0KlTJ3Ts2JGKGaTeSSQS3LlzBxcuXMDFixfx9OlT6OrqYtSoURg9ejTs7OzA5/Or1FbZAPE5OTkfFEbKpr3bFdf7hZKyZUtLSytsX0FBoVwBhM/nV/h72dgyqqqq0NLSgrKyMpo1awYNDQ0oKSlBQ0MDqqqqUFFRgaamZq0URhszoVCIt2/fIjMzE1lZWXj79q3033d/zsrKQkZGBtLS0lBYWChdns/no2XLljAyMkKrVq3QqlUrmJmZSR+Ghoaf/bk1PT0dCxYswF9//QVXV1ds3boVGhoan/unEypyEEIIIaS+FRUV4eLFi/Dy8kJgYCDatGmDr7/+GnPmzIGamhrX8Rq1W7duYcaMGcjPz4eXlxfGjBnDdSRCCCGk0SspKYGamhpsbGwQFhaGS5cuwd7e/rPaPH78ONzc3NChQwccO3aswn7eP6a0tBR3795FcHAwQkJCEBYWBpFIBF1dXfTt2xe9e/eGjY0NunXrVu1vKBNSH16+fAlfX1/4+fnh5s2bUFBQQN++feHg4IAJEybA2Ni4zjOUDdCel5cnHcRdJBJJfy977v3fy8Y1Kfu9oKAA2dnZn1wfj8eTFkmUlJSgra0NJSUlaaFERUVFWmABAHV1dSgqKkrnAf7rUk5OTk46v7y8fLlz/N3l31XZ9HeXz8/Pl3bf9K7Kpufl5Unvkigb+6Vs3pycHJSUlCAnJwdFRUXIz8+HSCRCcXExBAIBiouLkZubi4KCAmnhori4uFz7ioqKaN68OXR0dD74V1dXF0ZGRtKHiYlJnRYbSkpKcPDgQaxatQpqamrw9vbG0KFD62x9TRAVOQghhBDCnYcPH2L//v04fvw45OXlMXnyZCxatAgdOnTgOlqjJRQK8e2338LLywvOzs7YvXs39PT0uI5FCCGENFqxsbGwsrKCmpoaxGIxcnJyoKKiUqO2xGIxli5dij179mDp0qXYtGlTlcc7S0tLQ0BAAC5fvoxr164hOzsbJiYm6N+/P/r164f+/fujbdu2dIctaXDevHkDPz8/XLx4EVevXkVBQQFsbGzg6OiIUaNGoUuXLg3iuC67mJ+bm4uioiIIhUIUFBSgsLAQAoEAYrEYIpEIIpEIYrEYAoEAhYWFKCgokBYAiouLIRKJAAA5OTmQSCTSecruYAHKFxhkSVnxRUNDAzweD5qamtI7XNTU1MDj8aCtrQ1FRUWoq6tDVVW1wgJG8+bNZeYOiaCgICxevBjPnz/HN998g1WrVlX5riNSZVTkIIQQQgj3cnJycPr0aezcuRMxMTGwtbWFh4cHnJycwOPxuI7XKPn5+eHrr79GUVERPD09MXnyZK4jEUIIIY3S+fPn4ezsDIlEAjs7OwQEBNSoneTkZLi4uODx48c4cOAAnJ2dP7lMdHQ0zp07hwsXLuDff/+FsrIy+vfvD3t7e9jb26NNmzY1ykKIrCooKMD169fh6+sLf39/JCcnw9jYGKNGjYKDgwOGDBlCA4y/492iCABpQeR9ZQWY95XdgQGg3B0j76rK9LKiRWOSmJiIZcuW4ezZs3BwcMCOHTvQunVrrmM1VlTkIIQQQojskEgkCAoKkg5Urqenh+nTp2PhwoUwMTHhOl6jIxQK8cMPP2DXrl0YMWIE9u3bRwPCE0IIIbVs/fr12L59O3JycuDj44MpU6ZUu41bt27BxcUF2traOH/+PNq2bVvpvJGRkTh37hzOnTuHmJgYGBkZwcnJCaNGjcLAgQPpAi9pMhhjePToEfz8/ODn54f79+9DRUUFgwcPlt7lQZ8xSG0TiUTYvn07Nm/eDBMTE+zYsQMjR47kOlZjR0UOQgghhMim5ORk/PHHH9i9ezeEQiHGjBkDNzc3Gqi8Dty8eROurq5IT0/HL7/8gnnz5kFBQYHrWIQQQkijMGnSJPj6+qKgoADp6enV7iZyx44d+O677zB69GgcPny4wm87p6enw8fHB4cOHcKTJ09gYmKC8ePHY8KECejTpw8NWEwI/uuyzc/PD/7+/rh27Rry8vLQpUsXjBo1Co6OjrCxsaFzhdRYQUEB9u7di02bNqGoqAirVq3C//73PygpKXEdrSmgIgchhBBCZNv7A5VbWVlh/vz5NFB5LSsoKMBPP/2E7du3w9raGnv27EGPHj24jkUIIYQ0eFZWVoiNjYWlpSViY2OrvFxJSQkWLlwIb29vbNy4Ed9++225L3qUlJTg8uXLOHjwIPz9/cHn8zF58mRMmzYNvXr1oi+FEPIRhYWFuHHjhrRbq4SEBOjr68POzg4jRozAsGHDoKury3VM0gCIxWJ4e3tjw4YNyMnJwcKFC/Hdd99BR0eH62hNCRU5CCGEENJwPHjwAF5eXjh27BgUFRUxadIkGqi8lj179gyLFi3CtWvXMHXqVGzbto0GJieEEEJqqKSkBKqqqigtLcW3336LzZs3V2k5kUiEiRMn4saNGzhx4gTGjBkjfU4oFOLQoUPYvn07EhMT0a1bN7i5uWHKlCk0mC0hNRQZGQl/f39cuXIFt2/fRmlpKbp16yYtevTs2ROKiopcxyQypLi4GD4+Pli/fj1SU1Mxb948rFq1Cvr6+lxHa4qoyEEIIYSQhicnJweHDx/Gb7/9hpcvX0oHKh87dix9+KglJ0+exLJly1BUVIRNmzZh9uzZdPs+IYQQUk0xMTFo164dACAoKAiDBg365DKpqalwdHREfHw8Lly4AFtbWwDAy5cv4enpiYMHD0JeXh5z586Fu7s7zM3N6/RvIKSpycvLQ3h4OHx9fXHx4kXEx8eDz+ejd+/ecHBwgJOTE0xNTbmOSTiSm5uLgwcPYvv27UhNTcWkSZPw008/wczMjOtoTRkVOQghhBDScL07UPn58+fRokULGqi8FuXl5WHr1q345Zdf0KFDB2zfvh0DBgzgOhYhhBDSYJw9exYuLi7g8XjIzc2FsrLyR+ePjo7GyJEjoaqqikuXLsHc3BzPnj3D2rVrcebMGZiYmGDx4sWYO3cuNDQ06umvIKRpi42NRUBAAK5cuYKbN28iPz8f7dq1w4gRI2BnZ4f+/ftDRUWF65ikjsXHx+O3336Dt7c3AGDu3Lnw8PCggpdsoCIHIYQQQhqHly9fwsvLCwcOHCg3UPnQoUO5jtbgRUdH45tvvsGVK1cwfvx4bN68GV9++SXXsQghhBCZt2TJEnh6eqJbt264f//+R+cNCgrC+PHj0aFDB1y4cAEikQjr1q3DkSNHYGFhgR9//BETJkygu1YJ4VBhYSFCQkJw5coVBAQEIDo6GqqqqujVqxcGDhyIQYMGoWfPnjTYdCNy+/ZteHp64vz58zA0NMTixYvh6uoKTU1NrqOR//MH9TlACCGEkEbB3NwcmzZtQlJSEo4dO4aUlBQMGzYMbdu2haenJ/Ly8riO2GC1b98eAQEBuHbtGp49e4a2bdvCw8MDAoGA62iEEEKITLt9+zYAfPJLF3/99Rfs7e0xfPhwnD17FuvWrYOlpSWCgoLg7e2Nx48fY9KkSVTgIIRjKioqGDZsGH799VdERUUhMTERu3fvRsuWLeHt7Y3+/ftDW1sbw4YNw4YNGxAWFobi4mKuY5NqSktLw9atW9GuXTvY2trixYsXOHLkCF68eIFly5ZRgUMG0Z0chBBCCGm0KhqofPHixWjfvj3X0RqskpIS7Nu3D2vXroW8vDx++OEHzJs3j76tRgghhFRAS0sLOTk5uHjxIhwdHSuc5+TJk5g+fTpcXV3RvXt3rFixAnJycvjxxx8xd+5c+j+WkAbkxYsXuHHjBm7cuIHg4GAkJyeDz+fD1tYWAwcOxMCBA9G9e3cqWMqg4uJi+Pv74+DBg7h8+TLU1NTw1VdfYdasWbCxseE6Hvk46q6KEEIIIY2fQCDAkSNH4OnpiVevXtFA5bUgOzsbGzZswO7du2FoaIh169bhq6++osHJCSGEkP+vpKQESkpKYIwhLS0N+vr6H8xz+PBhzJ07F1999RVevnyJ8PBwTJkyBTt27EDz5s05SE0IqU1xcXHSoseNGzeQkpICNTU19O3bF/369YOtrS1sbGzA5/O5jtokFRcXIzg4GOfPn8f58+fx9u1bDBkyBLNmzcLYsWNprJWGg4ochBBCCGk6JBIJ/P39sWfPHly9ehUmJiaYN28eZs+eDQMDA67jNUhJSUlYv349Dh48CEtLS6xduxbOzs5cxyKEEEI49+LFC7Ru3RqampoVdvG4b98+uLu7o0+fPrhz5w5sbGywZ88edOnShYO0hJD6EBsbKy14hIaGIikpCYqKirC2tkafPn3Qq1cv9O7dG+bm5lxHbbQKCgpw9epVnD9/Hr6+vsjOzkbXrl0xfvx4TJ06FV988QXXEUn1UZGDEEIIIU3T8+fPsXfvXhw+fBi5ublwcnLC/PnzMWjQIMjJyXEdr8GJiYnB6tWr8ffff8PW1hYbN25Ev379uI5FCCGEcMbHxwfTp0/HgAEDcOPGjXLP7dy5E0uXLoWJiQkyMzOxZcsWLFiwgO6IJKSJef36NW7fvo3w8HDcuXMHDx8+RHFxMfT09GBjYwMbGxt069YNNjY2MDY25jpugxUTE4OgoCAEBgbi2rVrKCgoQO/evTFu3DiMGzcOrVq14joi+TxU5CCEEEJI01ZUVISLFy/Cy8sLgYGBsLCwwJw5czBnzhzo6upyHa/BuXv3LlauXIng4GAMGTIEa9euRd++fbmORQghhNS7RYsWYdeuXVi3bh1++OEH6fRNmzZh1apVUFJSQtu2bXH8+HG0a9eOw6SEEFlRUFCABw8e4N69e7h//z7u37+PuLg4MMZgaGiIbt26oXPnzrC2toa1tTVat24NBQUFrmPLnKSkJGlR4/r160hJSYGGhgYGDBgAe3t7ODk5wdDQkOuYpPZQkYMQQgghpMzTp09x+PBheHl5IT8/H6NHj4abmxuGDh3KdbQGJzQ0FGvXrsX169dha2uL9evXY9CgQVzHIoQQQupN//79ERISUm7Q8V9//RXffvst5OTksGjRImzZsgXKysocJyWEyLKcnBw8fPhQWvSIjIxEXFwcSktLoaqqivbt28Pa2hodO3ZE27ZtYWlpCVNT0yZzZ5hQKMT9+/fxzz//4N69e7h37x5ev34NFRUV9O7dG0OGDMGQIUNgY2ND4zE2XlTkIIQQQgh5X2FhIc6cOQNPT088fPgQVlZWmDlzJlxdXaGjo8N1vAYlODgYa9asQUhICIYPH441a9agT58+XMcihBBC6pyJiQmSk5MRGxsLS0tL7Nq1C4sWLYKSkhJOnTqFsWPHch2RENJAFRQU4MmTJ4iMjMTjx48RGRmJqKgopKenAwBUVFRgaWmJNm3awNLSEpaWljAzM4OpqSmMjY0b5N0fRUVFiI2NlT5iYmLw6NEjxMbGQiKRwNjYGD169ED37t3Rs2dP9O7dG6qqqlzHJvWDihyEEEIIIR/z4MEDeHl54fjx4ygtLYWzszOWLFmCrl27ch2tQQkNDcWaNWsQFBQEW1tbLF++HA4ODjT+CSGEkEZLXV0deXl5KCoqwt69e+Hh4QENDQ3cuHGDBhcnhNSJ7OxsPHv2DDExMXj27BliY2Px9OlTvHjxAkVFRQAARUVFmJiYwNTUVPrQ09ODoaEhDAwM0KJFCxgZGUFNTa1es+fn5yMxMREpKSlISkpCUlISkpOT8erVK8TGxiIhIQGlpaVQUFBAq1atYGVlhU6dOkkLG0ZGRvWal8gUKnIQQgghhFSFUCjEqVOnsHv3bkRGRqJbt25wc3PDlClTwOfzuY7XYISGhmLz5s3w9/eHtbU1li5diilTpjTIb5MRQgghH8Pj8cDj8bB9+3YsWLAA+vr6ePjwIfUDTwipd4wxpKamIj4+HgkJCeUer1+/RkZGBt68eYN3LxM3a9YMzZs3h4aGBjQ0NKCpqQkNDQ1oaWlBU1MT8vLyUFVVhYqKCgBASUmp3Oei7Oxs6c+5ubkoKSlBQUEBBAIBcnJyIBAIpD+/ffsWubm50vlVVFRgYmICIyMjtGrVSnpHipWVFSwsLKibP/I+KnIQQgghhFRX2d0dPj4+4PF4mDRpEtzd3WFtbc11tAYjIiIC27Ztw4kTJ9CqVSssWrQI8+fPpw8shBBCGg15eXloaGhAKBSiRYsWePbsGTQ0NLiORQghFSopKUFGRgbS09ORmpqKjIwMZGVlIScnB0KhsNy/AoEAjDGIRCIUFxcD+K/L34KCAml7ZYUQ4L+CibKyMlRUVKCpqQktLa1yDx0dHejr66Nly5YwMjKCnp4eJ9uANFhU5CCEEEIIqSmBQIAjR47g999/x4sXL6R3d0ybNo36f62iFy9e4LfffsP+/fuhra2NefPmYfHixTT2CSGEkAavrEvG5s2b4/nz59DS0uI4ESGEENIoUZGDEEIIIeRzSSQSBAUFwcvLC3///Tf4fD5cXFzg4eGBdu3acR2vQUhMTISnpye8vb3BGMPcuXPh4eEBU1NTrqMRQggh1RYYGIhhw4ZBQUEB3t7e1LUlIYSQGtHX10f//v25jiHrqMhBCCGEEFKbUlNTcfToUezduxevX7/G4MGD4ebmBicnJ/B4PK7jybzc3FwcPHgQ27dvR1JSEkaOHIlVq1ahd+/eXEcjhBBCqiQuLg7t27eXduFCCCGE1NT/Y+/Ow6qq2v6Bfw8zgiKCDOcwixM4lJBmomVxHAPnWVBT0TK1/FU4NNhjJqSlNrwqPk6goeBMmgQOCZolaiagqMyzyCyCTOv3Ry/nFQEVBQ/D93Nd5xLWXnute++D077PWreqqipKS0sVW39RrZjkICIiImoMD6/uOHjwIIyMjODu7o53332XqxOeQllZGQIDA/Hdd9/h0qVLGDBgAN577z2MHz8eGhoayg6PiIioVvfv34dMJkNBQQEqKysxceJE7Nu3T9lhEVEdDhw4gPHjx6O8vByqqqrKDoce0drfn9Z+/fWwlSkgIiIiokagoqICZ2dnBAQEIDExEYsXL8aePXtgY2MDuVyOwMBAVFRUKDvMJktdXR1Tp05FREQETp8+DVNTU8yYMQPm5uZYsWIFkpKSlB0iERFRNUIIvPLKK8jPz4dcLgfwb+FdIiIialxMchARERE1MplMBk9PT8TGxmLv3r0AgEmTJsHS0hJLly5FSkqKkiNs2t544w0EBgYiOTkZS5YsgZ+fH6ytrZksIiKiJmXatGmIjo7Ghx9+iNLSUgBgLQ4iIqIXgEkOIiIiohdEQ0MDEyZMQEhICGJiYjB9+nRs27YNnTp1wsSJExEaGgruJFo3ExMTeHp6Ij4+HocPHwbwb7KoW7du8Pb2RnZ2tpIjJCKi1mr79u3w9/fHq6++im+//RZxcXEAmOQgIiJ6EZjkICIiIlKCzp07w8vLCykpKdi9ezdyc3Mhl8vRtWtXeHt74+7du8oOsclSVVWFi4sLQkJCcP36dYwbNw7e3t6QyWSYOHEizp8/r+wQiYioFQkLC4OHhwd0dHRw7NgxVFRUIC0tDQDQvn17JUdHRETU8jHJQURERKREmpqaitUd0dHRGDt2LLy9vWFmZqZY3UF169q1K7y8vJCYmIjvv/8eMTExGDBgABwdHeHj44P79+8rO0QiImrB4uLiMHLkSFRUVGDXrl3o0KEDYmNjUVZWBgAwMDBQcoREREQtH5McRERERE1E9+7dqz2wv337NuRyOezs7Lgd0xO0bdsWHh4euHr1Kk6fPg0bGxvXc1ucAAAgAElEQVS8//77sLCwwKJFi3D58mVlh0hERC3M/fv3MXr0aJSWlmLs2LEYN24cAODatWuQSCQA/v0wAzVtEomk1ldtx83MzJCVlfXU4xAR0YvBJAcRERFRE1P1wP7y5cu4cOEC+vfvj1WrVsHCwgIzZ87EuXPnlB1ik/bGG28gICAACQkJWLJkCYKDg+Hg4IDevXtjw4YNuHPnjrJDJCKiFmDBggW4desWtLW18T//8z+K9vPnz0NXVxcAoKLCxy5NnRCiWk20x32fmpqKKVOmoKKi4rHjPDoGERE1Lv5tS0RERNSE9evXD9u2bUN6ejrWr1+PyMhIODk5KYpt1/VpQgKkUimWL1+OmJgYRERE4I033sCqVasglUohl8sRGBiI0tJSZYdJRETN0MaNG+Hr6wshBD7//HMYGxsrjp07d44rOFooExMTnDx5Ep9//rmyQyEioocwyUFERETUDFSt7oiIiEBkZCRGjx4Nb29vmJubK2p38BODdXNwcMDGjRuRmpoKf39/aGlpYcqUKTAxMcG8efO4nRURET218+fP45NPPkHfvn1hYGCA+fPnK44VFxfjypUr/Du5hdq3bx/U1NSwZs0a/PLLL8oOh4iI/heTHERERETNjL29Pby8vJCWlgY/Pz/k5uZCLpeja9eu8Pb25nZMj6GlpYUJEyYgKCgIiYmJ8PT0xKlTp+Dg4AB7e3vePyIieqyMjAxMmDABr7/+Oq5cuYIvvvgC2traiuMXL15EaWkpiouLlRglNZZBgwbh66+/hhACbm5uiI+PV3ZIREQEJjmIiIiImq2qB/YhISGIjo7G2LFjsXbtWsXqjqCgoFr3jKZ/yWQyeHp64ubNm/j999/Rt29ffPXVVzA3N8f48eMRFBTE7ayIiEihrKwMEyZMgK6uLgwNDSGVSjFz5sxqfcLDwyGTyZjkaME+/vhjjBkzBnl5eRg3bhxKSkqUHRIRUavHJAcRERFRC9C9e3d4eXkhJSUFu3fvRm5uLkaNGgUrKyssXboUycnJyg6xyZJIJBg0aBB27NiBO3fuYPfu3cjPz8eoUaNgbGwMd3d3BAUFoaysTNmhEhGREn3wwQe4evUqfvjhBwQEBGDVqlXQ0NCo1ufcuXPo06cPhBCQSCRKipQa244dO2Bra4srV67g/fffV3Y4REStHpMcRERERC3Iw6s7rl+/jmnTpmHbtm2wtrZWFNsuLy9XdphNlra2tuL+JSYmYuXKlYiLi8OoUaNgamoKd3d3hIaGorKyUtmhEhHRC7R//35s2rQJ27dvx8mTJ2FqaorJkydX6yOEwIULF2BlZaWcIOmF0dPTw4EDB6CtrY1t27Zhx44dyg6JiKhVY5KDiIiIqIXq2rWrYnWHv78/AGDSpEmK1R2JiYlKjrBpMzc3x+LFixEeHo64uDh89tlniIqKglwuh6WlpeIYi8sSEbVsycnJmDdvHubPnw9XV1fs3LkTc+fOhaqqarV+UVFRyMnJgaamppIipRepV69e2LRpEwBgwYIF+Pvvv5UcERFR68UkBxEREVELp6mpqVidcOPGDUyfPh07duyAjY0NV3c8JSsrKyxevBiXLl1CZGQkZs+ejRMnTmDgwIGwtrZWJDyIiKhlKS8vx5QpU2Bqaop169bhwIEDyMnJwezZs2v0/e2336Cvr4+0tDQA4HZVrcCMGTPg4eGB4uJijB8/Hnl5ecoOiYioVWKSg4iIiKgV6dKlC7y8vJCcnIy9e/cC+Hd1h4WFBZYuXYr4+HglR9j02dvbY+XKlYiJiUFkZCRmzpyJY8eOYeDAgdWOERFR8/fll1/i0qVL+Pnnn9GmTRts2bIFLi4ukMlkNfoGBwdj6NChuHbtGhMcrcj3338PBwcHxMbGYsaMGcoOh4ioVWKSg4iIiKgV0tDQUKzuuHnzJjw8PPDzzz/D1tZWsbqDhbafrCqpcevWLYSFheHNN9/E5s2b0a1bNzg4OGDVqlW4du2assMkIqJncPbsWaxZswbr169Hr169EBMTg7Nnz2LevHk1+hYXFyMsLAxDhw5FfHw8OnTooISISRk0NTWxf/9+6Ovr4+jRo8oOh4ioVWKSg4iIiKiVs7W1xcqVKxEfH4/g4GDo6+tjypQpitUdsbGxyg6xyZNIJHBycsIPP/yA1NRUhIaGom/fvti0aRN69eoFW1tbfPTRRwgPD2fRciKiZiA3Nxdubm5wdXXF/PnzAQCHDh2CkZER5HJ5jf6nT59GSUkJHB0dce/ePRYfb2WsrKywe/duruAhIlISJjmIiIiICACgqqoKZ2dnBAQEIDExER988AH27t2LLl26QC6Xw9fXF8XFxcoOs8lTVVXFW2+9hU2bNiEtLQ2RkZGYPn06fv31VwwcOBBGRkZwd3dHYGAgioqKlB0uERE9QgiBWbNmobKyElu3blW0Hz9+HMOHD4eKSs1HKcHBwejZsyeysrIAAD169Hhh8dLzkUgk1ZITj/v+0WMPGzFiBFasWNG4wRIRUa2Y5CAiIiKiGmQyGTw9PREXF6dY3TF79mzIZDLMmzcPkZGRyg6x2aja0ioqKgqxsbH47LPPEBcXh0mTJsHIyAguLi7w9fVlsVIioiZi06ZN+OWXX/Dzzz/DwMAAwL8rO/744w+MGDGi1nOCg4MxbNgw/PPPP1BRUUGvXr1eZMj0HIQQtb4ed7wuq1ateuxxIiJqHExyEBEREVGdVFRUqq3u8PT0xG+//YaePXvC0dERPj4+uH//vrLDbDZsbGywePFihIeHIzMzE5s2bQIAzJ07F4aGhnBycsLGjRuRkpKi5EiJiFqn2NhYfPLJJ1i2bBkGDhyoaA8ODgaAWreqSkhIQExMDIYOHYrz58+jsrISnTp1emExExERtXZMchARERHRU5FKpfD09MTt27fxyy+/wMzMDAsWLICFhQU+/PBDru6op44dO8Ld3R1BQUHIzMyEr68vpFIpPv30U1hYWKBfv3746quvcOnSJX4qlIjoBaisrMTs2bPRqVMnfPbZZ9WOHT9+HE5OTmjfvn2N806cOAEdHR0MGDAAf/zxB4B/610RERHRi8EkBxERERHVi6qqKkaOHInDhw8jMTERH374IYKCgtCzZ0+8+uqr8PHxQUFBgbLDbFbat2+PqVOnIiAgAFlZWQgKCkLv3r2xefNmODo6QiqV4p133kFgYCC3tSIiaiTff/89zp07h+3bt0NDQ6PasbNnz8LZ2bnW844ePQq5XI6ioiKkpKRATU0NnTt3fhEhExEREZjkICIiIqLnIJVKsWLFCty+fRsRERHo3bs3lixZAmNjY0ycOBGhoaFchVBPWlpaGDlyJHx8fJCSkoLY2FgsXboUycnJmD59OgwNDeHo6IiVK1dylQcRUQOJi4vDZ599hk8//RQODg7Vjt29exeJiYl45ZVXapxXWFiIU6dOYcyYMfjrr78ghEDnzp1rJEmIiIio8TDJQUREREQNwsHBAVu2bEFqaio2btyItLQ0yOVydOvWDStXrkRycrKyQ2yWqup4hISEICcnB4cOHYKDgwP++9//wtHRESYmJnB3d0dgYCDy8/OVHS4RUbNTWVmJmTNnolOnTli+fHmN43///TcA4OWXX65x7NixYygvL8eIESNw8eJFtGnTBn369Gn0mImIiOj/MMlBRERERA1KT08PHh4eCA8PR2RkJMaMGYOffvoJ1tbWkMvlCAwMRFlZmbLDbJZ0dHTg4uKCLVu2ICUlBZGRkViyZAnS09MxdepURfFyb29vXLp0SdnhEhE1C+vXr8eFCxewfft2qKur1zh+69YtdOjQAR07dqxx7MiRI3j99ddhaGiI8PBwAEDPnj0bPWYiIiL6P0xyEBEREVGjsbe3h5eXF1JSUuDv7w8AmDRpEiwtLbF06VLcvn1byRE2b/b29vD09ERISAjS09Oxc+dOWFpaYu3atXB0dISNjQ3mz5+PwMBAZGdnKztcIqImJyYmBp999hk+//zzOldgxMfHw8rKqkb7gwcPcPz4cYwePRrl5eU4f/48iouL0atXr0aOmoiIiB7GJAcRERERNTpNTU1MmDABISEhSEpKwuLFi7Fv3z507twZjo6O8PHxQVFRkbLDbNYMDQ0xbdo07NmzB5mZmTh//jymT5+Of/75B1OnToWRkREcHBwUSZHi4mJlh0xEpFSVlZV45513YGdnh6VLl9bZLz09HTKZrEb7qVOnUFhYiFGjRuHKlSu4d+8ehBBcyUFERPSCqSk7ACIiIiJqXczMzODp6YmPP/4Yp06dgo+PDxYuXIiPP/4YkydPhpubG5ycnJQdZrOmqqqK/v37o3///vjPf/6DoqIi/PHHHwgNDUVoaCjWrl0LVVVV9O7dG87OznB2dsbrr79e6zYtREQt1ZYtW3Dx4kVcunQJamp1Px7Jz89H+/bta7QfOXIEffr0gYWFBQIDA6GrqwsNDQ2YmZkp+mzcuBEHDx5slPiJ6PmlpKQoOwQiagBcyUFERERESqGiogJnZ2cEBAQgIyMDa9euxZ9//omBAwfC3t4e3t7euHv3rrLDbBF0dHTg7OwMLy8vREREID09HT///DMcHBzg7+8PuVyODh06QC6XK+p5CCGUHTYRUaPJzMzEihUrsGTJkieuvLh37x50dHSqtVVWVuLo0aMYNWoUACAsLAwdO3bkKg4iIiIlkAj+74WIiIiImpBLly7Bx8cH/v7+KC0thaurK9zc3DBixAioqqoqO7wWKTo6GqGhoTh58iTOnDmDgoICWFhY4K233oKzszPefPNNmJiYKDtMIqIGM2XKFJw/fx7R0dE1EhiPGjJkCKysrODj46NoCwsLw6BBgxAZGYlu3brByMgIOjo6GDduHNavXw/g31V1e/bsweTJkxv1Wojo2R04cADjx49HeXn5c/87UyKRKL5ujY9bG+P6G/L9aY5a+/XXw1au5CAiIiKiJsXBwQFbtmxBZmYm/Pz8kJubi1GjRsHKygpLly5FfHy8skNscezs7LBo0SIcOXIEOTk5iIiIwHvvvYfk5GS88847MDU1RadOneDu7g4fHx++B0TUrP3222/Yu3cvfvzxxycmOACgTZs2uH//vuL7hIQE7N69Gz179oS9vT0iIiKQk5OD9PR0vPrqq40ZOhE1Yc05sTFw4EAMHDjwucZoztdPzR+THERERETUJGlrayuKlV+/fh3Tpk3Djh07YGtrC7lcDl9fXxbPbgSqqqrVCpRnZ2fjxIkTmDx5MuLj47Fw4ULY2NigU6dOmDVrFnbu3MmkBxE1Gw8ePMCiRYswfvx4uLi4PNU5xsbGyMjIAPDv/v09e/bErl27MHHiRADAiRMn0LFjR5SXl6Nfv36NFjsRtQ4SiaTaqogXobKyEpWVlS90TqKGxCQHERERETV5Xbt2hZeXF9LS0hAcHAx9fX3Mnj0bMpkM8+bNw9WrV5UdYoulo6ODoUOHYvXq1QgLC0NeXh7CwsLg4eGBlJQUvPfee7CxsYFUKsXEiROxceNG1vQgoiZr1apVSEtLU2wp9TQ6deqE2NhYAMDs2bNRXFyMBw8eoLCwEAAQHBwMGxsbGBkZwcrKqjHCJiJqVOfOncO5c+eUHQbRM2OSg4iIiIiaDVVVVUWx8sTERHh6euLkyZN46aWX4OjoCB8fH8VDJ2oc2tracHJyUqz0KCgoQEREBBYvXozi4mJ88cUXcHR0hKmpKVxcXBSFzPnpQCJStps3b2LdunX46quvYGZm9tTn9ezZE4mJidi4cSNCQkJQUVEBAFi3bh1+/fVXXLx4ESoqKlzFQUREpCRMchARERFRsySVSuHp6Ynbt28jIiICDg4O+PDDD2FkZISJEyciNDSUqwleADU1NcX2VkFBQcjKysL58+fx4YcforKyEl9//TUcHR1hYmKCMWPGYO3atTh37hxKSkqUHToRtSJCCMydOxc9evTAggUL6nXuwIEDoaamhmXLllVrl0gkmDRpEoQQSE5OZpKDGlTVlkUvetsiejpRUVEYMWIEdHV1oaenhzFjxiApKanO/qGhoXB1dYW+vj60tLTQp08f7N27t0a/h9/vqvd/zpw5zzRWfn4+PvzwQ9jY2EBLSwsGBgZ47bXX8NFHH+Gvv/6qMc+jP2sPtycnJ2PUqFFo27YtjI2NMX36dGRnZz/xPjk6OlYbZ/LkyU88h+hZMMlBRERERM1eVbHylJQUrF27Frdv34ZcLoednR3WrVuHzMxMZYfYaqirq6N///7w9PTEsWPHkJOTg4sXL2Lp0qWQSCT47rvv4OTkBD09PfTv3x9LlizBgQMHkJaWpuzQiagF8/f3R3h4ODZv3gxVVdV6naurq4vBgwejvLy8WvK8oqICRUVFaNOmDVJSUpjkoBoyMjKwevVqDBgwAEZGRtDS0oKlpSVcXFzg7++P8vLyOs9tCh/UaIhi1C1RbGwsnJyccPXqVRw9ehSpqan48MMP4eHhUec5crkcqqqquHXrFm7evAlDQ0NMmTIFwcHB1fo9/L4LISCEwH//+99nGmvGjBnYsGEDFi9ejOzsbKSnp2PHjh2Ii4ur9udVXT9rD7cvW7YMXl5eSElJwbhx47Bnzx589NFHT7xXv/zyC3r06AFPT08IIWpNxhA1BCY5iIiIiKjF0NfXx/vvv4/Lly8jMjISo0aNgre3N2QyGeRyOQIDA1FaWqrsMFsVVVVVODo6YsmSJTh48CDS09ORmpqK3bt3o2/fvvjrr78wdepUyGQySKVSxRZX4eHhfK+IqEEUFxdj2bJleOedd+Do6Fjv8/38/BASEoKysrIaxyorK3Hv3j1IJJJnGptarm+//Ra2trbw9fXFhAkTEBYWhtzcXPz1119YsGAB9u/fj379+iE6OlrZodaJxahrt3LlSuTl5cHb2xtvvvkmdHV1MWjQIMyfP/+x561fvx6GhoawsLDA999/DwBYvXr1M8XwNGOdPn0aACCTyaCjowMNDQ107doVP/74Y73nmzt3Lrp37w49PT188sknAIDffvvtseckJiZi4MCBmDJlCry8vOo9J1F9SERTSA0TERERETWS4uJiHDp0CDt27MCpU6dgaGiIadOmYdasWejZs6eywyMARUVFuHLlCs6dO4fw8HD88ccfyM7Oho6ODl566SU4ODjAyckJgwcPhqGhobLDJaJmZuXKlfjuu+8QExMDU1PTep2bkZGBrl27orCw8ImfrA8ODsaQIUMU36uqqmLPnj3cnqUVevfdd7F582YsWLAA69atg5aWVq39jh49ioULFyIkJARdunSpcbxq+yA+ums8Bw4cwPjx41FeXv7Uq7xMTEyQmZmJ1NRUSKVSRfvdu3fRsWNHAE9+zyoqKqCmpgYDAwPcvXu32rH6vu91jfXOO+9gx44dAABzc3MMGTIEQ4YMwejRo6GhofFUc1a1FxQUoG3btgCA0tJSaGpqQiKR1EiCVfW/ceMG5HI5zM3Nn6ug+bO8Py1Ja7/+etjKlRxERERE1KJpa2tj6tSpCAkJQVJSEpYsWYKgoCD06tUL9vb28Pb2RlZWlrLDbNV0dHQUxcyDgoJw584dXLt2Dd999x1sbW1x4sQJTJw4EUZGRrC3t8fs2bOxZcsWXLlypdZPVhMRVUlNTcW6devw6aef1jvBAQDz5s1DUVHREx82Vu01z6336IcffsDmzZvh5uaGH3/8sc4EBwC4urpiw4YNGDNmDP8+a0aqEgmPfvCirg9i5OXlYfny5ejevTvatm0LiUQCNTU1AHiquhbPOtb27dtx4MABjBs3Dvfu3cO2bdswadIkdO7cGX///Xe95q1KcABQJEge9+fi4MGDkZ2djfPnz+Pnn3+u11xEz4JJDiIiIiJqNWQyGTw9PXHr1i1ERETAyckJq1evhrm5OVxcXBAYGPjY/bHpxVBRUUGPHj3g4eGBnTt3IiYmBnfu3MHhw4fh4uKCuLg4fPzxx+jTpw/09PQwYMAAfPDBB/j5559x69YtZYdPRE3IJ598AmNjYyxevPiZzk9OTkZFRQVUVFSgolL3IxQhBO7du6f4xG1z9HBx4OjoaAwbNgzt2rWDrq4uRo4cievXr9fZPzY2FmPHjoW+vn6NAsZ37tzBu+++CzMzM2hoaEAmk8HDwwMZGRkvZP6MjAzMmzdPMb+ZmRnmz59fa72ukpISeHl54eWXX4aOjg60tLTQrVs3zJ8/HxcuXHjiPczOzsaKFStgbGyMTZs2KdpXrlwJPT092Nra4vfff68W45gxY9ClSxfs3r27znGTkpIwZswY6OnpPff9qE8B7MYqRt3cVSUzHl2BkZ+fX2v/iRMnYs2aNZg0aRISExMVtTaeRX3HGjt2LPbv34+7d+/i7NmzGDp0KJKSkjBr1qxnmv9p/fDDD4ptsRYsWICUlJRGnY8IgoiIiIioFbt//74ICAgQzs7OQiKRCFNTU7Fo0SJx9epVZYdGTxAbGyt27dolFi1aJAYMGCC0tLQEANGuXTsxYMAAsWjRIhEQECDS09OVHSoRKcEff/whJBKJOHTo0HONk5GRIfz8/IS6urro2LGjACAkEokAUOOlqqoqli5dKoQQQkVFRfj7+zfEpbwwVdfx2muvifDwcFFYWChCQ0OFiYmJ0NfXF/Hx8bX2l8vl4ty5c+L+/fvi+PHjoupxU0ZGhrC0tBTGxsYiODhYFBYWirNnzwpLS0thbW0tcnNzG3X+9PR0YW5uLqRSqTh58qQoKChQjGdpaSkyMjIUYxUUFAhHR0fRtm1bsXXrVpGRkSEKCwvF6dOnRffu3cXTPELz8vISAMRHH32kaDt8+LAAIEaNGiUyMzOFh4eHIu4qx44dE0OGDKnz/Rg6dKj4/fffq8X/LPejqs/o0aNFVlaWSExMFHK5XAAQJ06cqHP+utqnTZsmoqOjRV5ennj33XcFADFz5swn3qemZP/+/QKAKC8vf+pz3NzcBADh6+tbrf3XX3+t9Z61adNGABAFBQWKtpKSkjrvb1X/0tJSUVRUJAwMDJ5pLAAiOTm5WlteXp4AIDQ1NWv0fdx7/azto0aNEgCEs7OzqKysrNH/SZ7l/WlJWvv114MPkxxERERERP8rKSlJeHl5CWtrawFAODg4iA0bNojs7Gxlh0ZPobS0VERGRootW7YINzc3YWdnJ1RUVAQAYWpqKt5++23xxRdfiKNHj/I9JWrhKisrxYABA8TgwYMbZLyAgAChqqoqMjIyRFJSknj//feFRCIRbdu2VSQ31NXVFQmQoKCgZp3kOH78eLX2nTt3CgBixowZtfY/ffp0rePNmzdPABDbtm2r1n7w4EEBQCxfvrxR5587d64AIPz8/Godb968eYq2JUuWCABiw4YNNca5fPnyUyU5Bg0aJACI8PBwRduwYcMEABEWFiaEEOLSpUs1HgRnZWVVe5D96PU9mqh71vtR1efh5Mj169cFADFw4MA656+r/cyZM4q2+Ph4AUBIpdI6526KnuUhcmxsrGjfvr0ieVZYWCjOnTuneP8fvWdDhw4VAMSyZctEbm6uyM7OVvy81XZ/X331VcXP0d69e8Xbb7/9TGNVJcgiIyNFSUmJyMjIEMuWLRMAhKura42+jZHkyMzMVCSHa/u99SSt/SF/a7/+emCSg4iIiIjoURUVFSIsLEx4eHgIHR0doaWlJSZMmCCOHj3K/2Q0M7m5ueK3334TX331lRg1apQwNTVVPJC0t7cXbm5uYv369eLMmTMiPz9f2eESUQPx9fUVqqqqDbYqb9y4cUIulyu+nzp1qnj99deFk5OTmDRpkti+fbuYPn26MDIyEgCEkZFRs05y5OXlVWtPSUlRJIxr619UVFTreFKpVAAQaWlp1drv3r0rAIiePXs26vxVf+anpqbWOp5MJlO0WVhYCAAiISGh1rGeRtX7//Cn56vuQdWqlaKiohoPgh88eCDU1dVrjFfV7+7du7XGX9/7UZvy8nIB4LFJlrraH15N8ODBA0WSrzl51ofIkZGRYvjw4UJHR0fo6uqKIUOGiKioKMW9efRBv5ubmzAyMhIaGhqiR48eYt++fbX2FUKIixcvit69e4s2bdqIV199VcTExDzTWOHh4WLGjBnCyspKqKurCz09PdG7d2+xevXqaj8jD5/78Pn1bdfT06vWHhgYWKMvAHHx4sWnvs+t/SF/a7/+evCRCPGMm8AREREREbUC+fn5OHLkCPz8/BAaGgozMzNMmzYNc+fORadOnZQdHj2DlJQU/PXXX4iIiMDly5dx+fJlZGVlQSKRoFOnTujTpw/69OmDl19+GX369KmzkCgRNU3FxcXo0qULRowYgS1btjz3eIWFhTA2NsYPP/yA2bNno6ysDMbGxli+fDk+++wz+Pj4wM3NTdH/9u3buHv3LgYMGIA9e/Zg8uTJzx3Di1JVf+HRR0UPHjyAlpYW1NTUqhXIrqt/FXV19cfWKGnTpg2Kiooaff4HDx4oiiU/PJ66ujpKS0sB/FtMuaysDCUlJdDU1Kwz5sepGqO0tBTq6uoAAE1NTZSWlqKsrExRIPrRuOPj4+Hk5ITU1NRq4zX0/cjLy8M333yDQ4cOISUlBffu3at2/NHz6hqvvu1N2YEDBxS1dFRVVZUdDj2itb8/rf3662ErC48TERERET2Gnp4e3N3dERISguvXr2PatGnYtWsXbG1t4ejoCB8fnxoPCahpMzMzw9ixY/H111/jxIkTuHPnDlJTU3HkyBHMmTMHmpqa8PX1xbBhw9CxY0dIpVK4uLhg5cqVCAwMRFRUlLIvgYge4/vvv0deXh5WrVrVIOMdPXoU5eXlGD16NADg1KlTyM3NhUwmQ0lJCQYNGlStv62tLV599dUGmVtZHi0eXVVguWPHjvUax9jYGACQk5OjKJD88OvhBEdjzG9kZFTt/EfHqzr+cKzp6en1muNh7du3B/BvYqxKVaK86t8K9+/fr3He6dOn8bKTvCgAACAASURBVMYbb9Q57qMFrZ/1fjRkAWwioqaESQ4iIiIioqfUrVs3eHl5ISUlBSEhIbCxscHChQshk8ng7u6O0NBQPixopqoSGZ6envD19UVUVBQyMzNx4sQJLFq0CNra2ti9ezcmTZqEHj16wNjYGMOHD8fy5cuxf/9+3L59G5WVlcq+DKJWr+qT6kuWLKn2APt57Nu3D3K5HAYGBgCAQ4cOwcHBATdu3IC1tTUsLS0bZJ6m5Ny5c9W+Dw0NBQAMGTKkXuNUJYbOnDlT41hYWBj69+/fqPO7uLgAAE6ePFnreFXHAWDcuHEAgMOHD9cY58KFC+jXr98T5+vcuTMAICYmRtHWq1cvAEBkZCQA4Pr169XOKSgowPr16/HJJ5/UOe4ff/xRa/z1vR9V9/X//b//hw4dOgD4d1UIEVGz90J3xyIiIiIiamFycnLEli1bRJ8+fQQA0aVLF/HFF19UK+pJLUdBQYEICwsTGzZsEG5ubsLBwUFoaGgIAEJDQ0PY2dkJNzc3sWHDBhESEiLu3Lmj7JCJWpVly5YJAwODBquxk5ubKzQ1NYWvr68Q4t+aTaampuKrr74S/fv3Fx4eHnWe25xrcgwfPlyEhYWJwsJCcfLkSWFqair09fVr/N0G1F6zoUpWVpbo3LmzMDU1FYGBgeLu3buioKBABAUFCRsbm2qFqxtj/oyMDGFpaakoEF1QUKAYz9LSUmRkZCj65ubmih49eoi2bdsKHx8fkZGRIQoLC8WJEydE586dRWho6BPn/vLLLwUA8eWXXyraDh8+rCj0nJmZKTw8PBTnnj9/Xrz++ut1/pxU9Rs0aJA4d+7cc9+P+hbAbqj2pow1D5q21v7+tPbrrwcWHiciIiIiaiiRkZHC09NTdOzYUaioqAhnZ2exa9euehUApeanqKhI/Pnnn8LHx0csXLhQvP7660JfX1/xsMfS0lK4uLiI5cuXi3379onr16/zP6tEjSAtLU3o6OiIdevWNdiY27ZtE1paWopC2OfOnRMAxIULF4SampoIDAys89zmnOSIj48Xb7/9tmjbtq3Q0dERw4cPF9HR0bX2ffhVm5ycHLFkyRJhbW0t1NXVhbGxsXBxcRF//PHHC5k/IyNDzJs3T0ilUqGmpiakUqnw8PColuCoUlhYKD799FPRtWtXoaGhIQwMDMSQIUPE2bNn64z1YWlpaUJbW1vIZDJRXFysaP/8889Fu3btRKdOncSZM2eErq6u6Natm3j//ffFrVu3ao374euKiooSQ4YMEbq6us91P+pTtLquserb3tTxIXLT1trfn9Z+/fXAwuNERERERA2ttLQUwcHB8PPzw+HDh9GmTRtMmjQJbm5ucHJyUnZ49IKkpaUhOjoaUVFRuHTpEqKjoxEZGYkHDx5AXV0dnTt3hoODA+zt7WFnZ4e+ffsq9oQnovpbsGABDh8+jNu3b0NbW7tBxhw6dCh0dHRw8OBBAMDHH3+MI0eOwMvLCxMnTsSdO3cU2/48SlVVtcUUHm8t8zeENWvWYPny5ViwYAF+/PFHZYdDT8DCzk1ba39/Wvv118NWNWVHQERERETU0mhoaMDFxQUuLi5IT09HQEAAtm/fDh8fH3Tv3h0zZszAzJkz+UC7hZNKpZBKpXB2dla0lZSUIDo6GlevXsW1a9fwzz//4Ndff1UUkZXJZLC3t1ckPnr06IHu3btDT09PWZdB1CwkJCTgv//9L3766acGS3BkZWXh1KlT2L17t6Lt6NGjGDt2LEJCQuDo6FhngoNar6VLl+LatWv46aefoKWlhTVr1kBdXb1Gv7KyMqxbtw7Lli1TQpRERC0LkxxERERERI3I1NQUixcvxuLFi3Hp0iX4+vpi7dq1WLFiBQYPHgwPDw+MHj261gcg1PJoaWmhT58+6NOnT7X29PR0/PPPP/jnn38QHR2N8PBwbN26Fffu3QMAmJubw87Orkbyo127dsq4DKIm59NPP4WVlRVmzpzZYGPu378fGhoaePvttwEA165dw82bNzFmzBhMnToVU6dObbC5qOWQSCTYs2cPbG1t4e3tjV9//RULFy6EXC6HmZkZCgsLcfr0aaxatQoWFhYoLy+HmhofzxERPQ/+KUpERERE9II4ODjAwcEBXl5eOHDgAHbu3InJkyfD0NAQU6dOxYwZM/DSSy8pO0xSAlNTU5iammLo0KHV2h/e8io6Ohp//vknfHx8FMkPfX192NnZVdv2qnfv3mjbtq0yLoNIKa5duwZ/f3/s3bu3QR8W79u3D66urtDR0QEAHDx4EFKpFIaGhoiLi4NcLm+wuZqCqq2iqr5+0VtGKXv+hiSRSPCf//wHs2bNgo+PD7Zs2YKlS5eiuLgYRkZG6NevH9asWYORI0cqO1QiohaBNTmIiIiIiJQoMTERu3btgp+fH27fvo2ePXtixowZmDZtGkxMTJQdHjVBQggkJCQgKipKkfyIiorC9evXcf/+fQCApaUlunfvjm7duqFbt27o0qULunfvzp8papFGjx6N5ORkREREVHtQ/jzS0tJgbm6O/fv3Y8yYMQAAe3t7yOVydOvWDZ988gmys7MfuwqvOdbkIGptWPOgaWvt709rv/56YE0OIiIiIiJlsrS0xOeff47PP/9csZ2Vl5cXPvnkE7z55ptwc3PDuHHjFJ8kJpJIJLC2toa1tbViGx0AqKysVCQ/oqOjcf36dZw/fx47d+5EXl4eAEBPTw9du3ZVJD+qvra1tYWGhoayLonomUVFRSEoKAiHDx9usAQHABw6dAg6OjoYPnw4ACi2ktu6dSvWrVuHN954g9sMEhERNRFMchARERERNRFV21l98803+O233+Dn54c5c+Zg0aJFcHV1hbu7O956660GfZBHLYeKigpsbGxgY2MDFxeXasdyc3MRFxenSIDExcVh9+7diImJQUVFBdTU1GBhYaE4v6r+R9X3RE3Vl19+iZ49e1ZL+DWE/fv3Y+TIkdDS0gIABAQEwNzcHA4ODggNDYW3t3eDzkdERETPjkkOIiIiIqImRlNTEy4uLnBxcUFOTg7279+PLVu2QC6Xw8LCAlOmTMGcOXNga2ur7FCpmdDX11ck0R5WUlKCmJgYxev69euIiIjAnj17UFRUBAAwMDBA586dFS9bW1vFr+3bt1fG5RABAG7cuIEDBw5g3759DZr8vXv3LsLDw+Hv769oCwgIwMSJExEWFobCwkLFCg8iIiJSPiY5iIiIiIiasA4dOsDDwwMeHh6IioqCn58fdu3aBW9vbzg4OMDNzQ1ubm7o0KGDskOlZkhLSwu9e/dG7969axxLSkpCTEwMbt68iZs3b+LWrVu4cOECEhISUFZWBgAwNDSsMwGip6f3oi+HWpnVq1eja9euGDt2bIOOe+jQIairqysSGZcvX8atW7cwceJE+Pv7o0ePHrCysmrQOYmIiOjZMclBRERERNRM2Nvbw8vLC6tXr8bp06fh6+uL5cuXY+nSpXBxcYGbmxuGDx8ONTX+M5+en4WFBSwsLCCXy6u1l5eXIyEhAbdv38atW7cUr/PnzyMhIQHl5eUAgI4dO9ZIgNja2sLGxgb6+vrKuCRqQeLi4rB3717s3LkTKioqDTr2wYMHMWzYMEUtpICAAFhbW+OVV16Bm5ubohA5ERERNQ0SIYRQdhBERERERPRs8vPzceTIEfj5+eHkyZMwNTXF+PHjMXPmTLz88svKDo9amfLyciQlJSEuLq7GKyoqCiUlJQD+XUEilUoVNT8eftnZ2UFbW1vJV0JN3Zw5c3DmzBncuHGjQRO7eXl5MDY2xrZt2zB9+nQAgK2tLcaPHw8PDw906tQJv//+OwYNGvTEsVRUVMBHLkTNQ3l5OVRVVZUdBj3iwIEDGD9+fKt9f1r79dfDVn7Ei4iIiIioGdPT04O7uzvc3d2RlJQEf39/bN26Fd9//z3s7Ozg7u6OWbNmwcjISNmhUiugpqZWZ7HysrIyJCYm1kh+REREICAgAHl5eQAAVVVVmJubw8bGBtbW1tUSINbW1ujYseOLvixqYpKTk+Hn54dNmzY1+Mq1oKAgCCEwcuRIAMDFixcRGxuLiRMnIigoCHp6eujfv/9TjSWRSLBo0SIMGDCgQWMkoobz559/4ttvv1V2GET0nJjkICIiIiJqISwsLODp6YmPP/4Y58+fh5+fH1avXo0VK1Zg8ODBcHNzw4QJE/gpeVIKdXV1xZZVtcnJyUFcXBzi4+OrJUFOnz6N5ORkRR2Qtm3bwtraGpaWlrC2toaFhQUsLS1haWkJCwsLGBsbv8jLIiXw8vKCsbGxYqVFQzp8+DDeeustxZZq+/btQ6dOndCnTx8sXboUw4YNg7q6+lOP9+qrr2LChAkNHicRNYyG3u6OiJSDSQ4iIiIiohZGRUUFTk5OcHJywsaNGxEUFARfX1/Mnj0bixcvxsSJE+Hm5oYBAwZAIpEoO1wiAECHDh3QoUMHODo61jhWXl6O5ORkReIjPj4eSUlJuHTpEg4cOID09HRUVlYCALS1tWFlZVUj+WFlZQVLS0tIpVJu+dCMZWZmYvv27fj222+hoaHRoGOXlZXh5MmT+PrrrwEAQgjs378f06ZNQ2FhIc6ePQsfH58GnZOIiIieH5McREREREQtmJaWFiZMmIAJEyYgLS0NgYGB2LFjB3x8fNCtWzdMmjQJM2bMgLW1tbJDJaqTmpoarK2tYW1tjbfeeqvG8dLSUqSkpCAxMRGJiYlISEhAYmIibt26hdDQUKSkpKC0tBTAvytKzMzMFEkQCwsLyGQymJubK77u0KHDi75Eeko//fQT2rZti1mzZjX42GfPnkV+fj6GDRsGALhw4QISExMxceJEHD9+HOXl5RgxYkSDz0tERETPh0kOIiIiIqJWQiqVYvHixVi8eDGioqIUe9qvWrUK/fv3h7u7O6ZOnQpdXV1lh0pULxoaGnXWAgGAyspKpKenIyEhAQkJCUhKSkJiYqJiNUhKSgry8/MV/du0aQMLCwuYmZlBJpPB0tJS8XVVe/v27V/U5dH/KikpgY+PD957771G2Xbv2LFjsLOzU/wc+fv7o1u3bujduzfWrFmD119/HYaGhg0+LxERET0fJjmIiIiIiFohe3t7eHl54T//+Q+Cg4Ph5+eHhQsX4oMPPsDbb78NNzc3jBgxgtv6UIugoqICmUwGmUxWZxHowsJCJCcnIzk5GampqYqvU1JScPHiRSQnJ6OwsFDRX1dXV5HwkEqlMDMzg4mJSbVfjYyM6lW/gR5v165dyMvLw/z58xtl/OPHj8PV1RXAv4mxAwcOYP78+Xjw4AF+/fVXrF69ulHmJSIioufDJAcRERERUSumoaEBFxcXuLi44O7du/D394evry9cXV1haWkJNzc3uLm5oUuXLsoOlahRtW3bFnZ2drCzs6uzT35+PlJSUpCUlITU1FTF12lpaYiIiEB6ejqys7MV/SUSCYyNjWFqagqZTAZTU1NIpdJqL1NTUxgbG7P47RMIIbBx40ZMnz4dJiYmDT5+XFwcYmJiFNtRnTp1CmlpaZg0aRJCQ0NRWFiIUaNGNfi8RM3B3r17sX79ety8eRN5eXmKdiFEtX4P1/l69BgRUWNikoOIiIiIiAAAhoaGWLhwIRYuXIgbN25g79692LVrF7766ivY2dnB3d0dM2fOhLGxsbJDJVIKPT096Onpwd7evs4+JSUlSE9PR1paWrVXeno6YmNjER4ejtTUVBQUFCjOUVNTg5GREUxMTGBiYgIjIyNF8sPIyAhSqRRGRkYwNjZutfVCjh07huvXr2Pv3r2NMv4vv/yCdu3aKVb67Nu3Dw4ODujSpQu++eYb9O3bF+bm5o0yNzV9GRkZ2LZtG44fP45bt26hoKAAxsbG6NWrF6ZOnYoJEyZATa1lPmLz9fXFjBkzMHz4cPz9998wMTHBsWPHMG7cuBp9hRDVEh1ERC+KRDC1SkREREREdaioqMCpU6ewe/duHDx4EA8ePMDQoUMxffp0uLq6Nsq++EStwf3795GSkoLMzEwkJycjMzMTGRkZyMjIQFZWFtLS0nDnzh3cuXMHFRUVivM0NTXRsWPHaokPU1NTGBkZKb43NDRUvFrKg9c333wTmpqa+PXXXxtl/BEjRkBHRweBgYEoKyuDqakpPD098f7778PCwgIfffQRPD096zWmqqoq9uzZg8mTJzdKzPRifPvtt/jiiy8gk8nw7rvvYvjw4bCwsEBBQQGuXLmCrVu3IiEhAX5+fo9dCfaiVSUbnvex30svvYSrV68iOjoa3bt3f2HzvigHDhzA+PHjUV5ezi06m6DW/v609uuvh60t4187RERERETUKFRVVSGXyyGXy7FlyxaEhITAz88Pbm5uUFNTU9TvGD58eIt5mEr0IrRp0wZdunR54lZwlZWVyMrKwp07d5Ceno7MzEzcuXMHaWlpyMrKQlJSEv766y/cuXMHWVlZqKysrHa+gYEBOnbsqEh6VCVDqr7v2LGjIjFiYGAALS2txrzsZ/LPP//gzJkzCA4ObpTxKyoqcP78eaxZswYAcOLECeTk5GDChAlwd3fH3bt3cebMGdjb22Po0KGss9KKvPvuu9i8eTMWLFiAdevWVfv9oa2tjWHDhmHYsGE4evQohg8fjpCQkBa3vePNmzcBALa2tkqOhIiobvxfCBERERERPRUtLS1F/Y6cnBzs378fvr6+GDVqFKRSKcaNG4cZM2agT58+yg6VqMVQUVGBsbExjI2N0bNnzyf2Ly4uVmyXlZubq3g9vIVWVFQU0tPTkZKSgtLS0mrna2lpQV9f/6leVTVFDAwMoKmp2Vi3AOvWrYO9vT2cnZ0bZfyrV68iPz8fAwcOBPBv/YEBAwbAysoK0dHRAIDQ0FCcOHECenp6cHd3x/Tp09G3b99GiYeahh9++AGbN2+Gm5sbfvzxx8f2dXV1RUVFBcaMGYO///67RSXCiouLAaBFXRMRtTysbEZERERERPXWoUMHeHh4IDw8HNHR0ZgzZw6OHTsGBwcH2NvbY+XKlUhISFB2mEStjra2NmxsbODk5AQXFxe4u7tj8eLF8PLygq+vL4KCghAeHo7Y2Fg8ePAAubm5iImJQXh4OI4cOYJNmzbho48+wujRo9GzZ09oa2sjNTUVZ8+exY4dO7BixQrMmDEDrq6ucHR0hEwmg5aWFtq1awcLCwv06tULgwYNgouLC9zc3PD+++/j008/xbp167B161YEBgYiNDQUFy9exK1bt5CVlVUj0fKwjIwM7Nu3D0uWLGm0vf7DwsKgr68POzs73L9/H0ePHsWkSZMghEBiYiIkEgnKy8sB/Ft8fsuWLejXrx9kMhmWLl2K27dvN0pcz0oikShe0dHRGDZsGNq1awddXV2MHDkS169fr7N/bGwsxo4dC319fUVblTt37uDdd9+FmZkZNDQ0IJPJ4OHhgYyMjBcyf0ZGBubNm6eY38zMDPPnz0dmZmaNe1BSUgIvLy+8/PLL0NHRgZaWFrp164b58+fjwoULT7yH2dnZWLFiBYyNjbFp0yZF+8qVK6GnpwdbW1v8/vvv1WIcM2YMunTpgt27d9d5fWlpaRg3bhzatm0LAwMDzJgxA/n5+UhISICrqyvatWsHExMTzJw5s1qB7yqhoaFwdXWFvr4+tLS00KdPn1rr1Dx836rmnjNnzhOv+2nGefT1tJ7254eI6FmwJgcRERERETWYS5cuwdfXF/7+/sjOzkb//v3h7u6OyZMno127dsoOj4gawIMHD5CTk4OcnBxkZ2crvs7Ly1O88vPzq/368Ne10dDQgK6uLtq3bw9dXV3FKy0tDbdu3cLs2bPRvn17tGvXDnp6etDR0UGbNm2gp6cHTU1NtGnTBrq6ulBXV4e+vj7U1dWhq6v7VNczYcIEPHjwAEePHkVAQACmTp2K1NRUJCUloW/fvlBRUamxDVgVNTU1lJeXo3fv3pg1axamTp2Kjh07AlBuTY6qh8+vvfYavvnmG/Tu3Rt//vknpk+fjgcPHuDy5cuwsrKq0V8ul2PlypV4+eWXcebMGYwYMQJCCGRmZqJfv34oKSmBr68vXnvtNVy5cgVubm5QUVHB5cuX0b59+0abPyMjA3379kVFRQX8/Pzwyiuv4K+//sL06dOhqamJP//8E8bGxgCAwsJCvPnmm4iJicF3330HFxcX6OjoICIiAu+99x6uX7/+xHoR3t7eWLp0KT766COsXbsWAHDkyBGMHj0ao0aNgo+PDz777DP4+PgA+L/6E8ePH8fGjRtrbK1WdX3Tp0/H8uXLIZVKsWLFCvz0008YOXIkNDQ0sHr1akilUixbtgybNm3C3LlzFeM/PM7o0aOxdetW3L9/H3PmzEFISAhOnDiBoUOH1jrn8z72q2uc+rTX9+fnRWLNg6attb8/rf3662ErBBERERERUQMrKSkRR48eFW5ubqJNmzZCS0tLvP322yIgIECUlpYqOzwiUqKcnBwRHx8vrly5Is6cOSMOHz4sdu/eLbZs2SK8vLzEp59+Kj744AMxZ84coaOjI6ysrISTk5N4+eWXhY2NjTA0NBRaWloCwBNf2traQl9fX1haWgpbW1vh4OAgHBwcxFtvvSWcnZ2Fi4uL0NLSEr169RIeHh7C2tpamJubC09PT/Haa68JLS0tIZFInjiPRCIRqqqqQk1NTbi6uooTJ04IFRUV4e/vr5R7XBXX8ePHq7Xv3LlTABAzZsyotf/p06drHW/evHkCgNi2bVu19oMHDwoAYvny5Y06/9y5cwUA4efnV+t48+bNU7QtWbJEABAbNmyoMc7ly5cF8ORHYYMGDRIARHh4uKJt2LBhAoAICwsTQghx6dIlRdxVsrKyhIGBQY3xqvqdOXNG0Zaamlpre3JysgAgZDJZrePEx8crvr9+/boAIAYOHFjnnM+rrnHq017fn58Xaf/+/QKAKC8vV1oMVLfW/v609uuvBx+u5CAiIiIiokaVl5eHo0ePws/PDydPnoS+vj7Gjx8PNzc3DBgwoNG2oCGi5u3YsWNwcXHBjRs3ai3mLIRAXl4eSktLUVRUhKKiIpSWliI3NxdlZWW4d+8e7t+/jwcPHiAvLw9lZWUoLCxEZWUl8vPzAfy7BdLRo0fxxhtvQCKR4OzZs7CwsECHDh0QGRkJbW1t5OfnP/Wn4SUSCYQQMDc3R2pqqtJXcuTl5UFPT0/RnpqaCjMzM5iamiItLa1G/6KiIrRp06bGeDKZTFHTxdTUVNGenZ0NQ0ND9OzZE//880+jzS+VSpGeno7U1FRIpdIa48lkMqSkpAAALC0tkZSUhISEBFhaWj7N7arB2NgYd+7cQXJyMszMzKrdg9zcXLRv3x7379+Hjo4OgP9btVBaWgpdXd0aW7BVXV9BQQHatm0LAKisrFR8Mru2dolEUucKoioVFRVQU1ODgYEB7t69W+ucz/vYryFWctT35+dF4iflm7bW/v609uuvh60sPE5ERERERI2qffv2cHd3h7u7O5KTk/Hzzz9jx44d8PHxQdeuXTF58mRMnz4dtra2yg6ViJqQLVu2YPDgwbUmOIB/H6bq6+s/1xx79uxBcHAwgoODcfDgQYSFheHChQvIzs6GnZ0d+vfvjzNnzjx2DFVVVQghoKamBmdnZ0yaNAljx46t9nBfWR6NwdDQEACQlZVVa//aEgzAv/UUAFRLMDwsNja2Ueev6l91/qPjVcUHAOnp6QAAExOTWsd6Grm5uQCg2AILgCKJULUNWm2xpqamKrYrq01VIgMAVFRUHtv+aPIgLy8P33zzDQ4dOoSUlBTcu3dPcSw7O/vJF6VEz/rzQ0T0tFh4nIiIiIiIXhhzc3N4enrixo0biIyMxOjRo7F582Z07twZjo6O2LhxY50Pv4io9UhOTsbx48cxb968Rp0nOjoanTt3hoaGBgIDAzF48GAYGRnh4MGDMDIyqjNRoaqqChUVFairq2PIkCHYsWMH7t69i2PHjsHd3f2p64E0tkcfflc9qH/cg/jaVD3sz8nJgRCixquoqKhR5zcyMqp2/qPjVR1/ONaqZMezqKoPUfj/2bvzsKqq/X/g78MUiqAICjKKhROmIiZOkBkipAc0wKEEbRA0btLgzSkN7/eXYGXp1RIxLVHDAUyFLARHwBlNQwQNzAQ8IIgCIsiwfn/0nHNFQEE554C8X8+zn69n7bXX57P3PnGf7/6cvVZJiaJNXlCRFxfKysrqHHfo0CGMGjXqieM+yqRJkxASEoLJkyfj2rVrimvfGjzp94eIqLFY5CAiIiIiIrWws7NDaGgocnJyEB8fj759++LTTz+FpaUlpFIpIiIi6n2IRETPvvXr18PY2BgTJkxQapz09HT07t0bd+/eRVxcHHx8fAAAP//8MyZMmFBruiANDQ1oaGhAS0sLY8eORUREBAoLC7Fv3z74+fnV+jV+S5GcnFzrc0JCAgDA1dW1SePI70N9b7UkJiZi2LBhSo0vlUoBAAcOHKh3PPl+APDy8gIA7N69u844J06cgKOj42Pj2draAgAyMjIUbf379wcApKamAgAuXbpU65ji4mJ88803+OSTTx47/pOQX8uPP/4YnTt3BgBUVFQ02F/+pkllZSXKysrqvAWjSk/6/SEiaiwWOYiIiIiISK00NTXh4uKCiIgI5OfnY/PmzQCAd955B+bm5vDz80NCQkKr+cUqET2dqqoqbNy4Ee+88w50dHSUGuvSpUvo06cPYmJiUFFRgQkTJuDvv//G2bNnaxU5NDU1MWbMGGzcuFHxxsabb77ZIgsbDwoLC0NSUhJKS0tx8OBBLFiwAIaGhggODm7SOMHBwbC1tUVgYCCioqJQWFiIkpISxMbGYsaMGQgNDVVq/KVLl8La2hrz58/HwYMHUVJSohjP2tq61njBwcHo168flixZgvXr1yMvLw+lpaWIi4uDn58fli1bVmtsiURSePAE9AAAIABJREFUZ22osWPHAgDi4+MVbbNmzQIAfPnll8jPz0d4eLhi3/Hjx+Hh4YFFixZhwIABTTq3xnJycgIAhISE4Pbt27h16xYWLlzYYH95UebUqVOIiYlRayHhSb8/RESNprI1zomIiIiIiJogJydHrFy5Ujg4OAgAwtLSUsyZM0f8/vvv6k6NiJQoOjpaaGhoiKysLKXGuX//vtDR0RFbt24Vr7/+unB1dRVCCLFixQrRqVMnUVFRIRISEsT3338vCgsLmzy+hoaGiIyMbO60GwWAACCuXr0qxo8fL/T19YWenp5wd3cXaWlp9fZ9cKvPrVu3xEcffSRsbGyEtra2MDExEVKpVBw/flwl8WUymQgICBBmZmZCS0tLmJmZCX9/fyGTyer0LSkpEZ9++qno1auX0NHREUZGRsLV1VUcPXq0wVwflJubK9q1ayfMzc3FvXv3FO1LliwRBgYG4vnnnxeHDx8WHTp0EL179xb/+te/xJUrV+rNu6Fza2p7Xl6e8PX1FV27dhU6OjqiX79+Yvv27Q1et9OnT4sBAwaI9u3bi6FDh4qMjIx683uU5spdiKZ9f1QpKiqq3u8gt5a1VVVVqfV7oi7y72dbPf8mCJcIwZ9DERERERFRy3bhwgVs3rwZkZGRyMnJwUsvvYRp06Zh8uTJtRaGJaLWz83NDRoaGti3b59S46Snp6NPnz5ITk6Gq6srVq5ciXfffReOjo6ws7PDxo0bn2p8TU1NbN26FVOmTGmmjBtP/maCuh75qDt+cwgJCcHChQsRGBiINWvWqDsdUpLo6Gh4e3tj27ZttRaDp5bh5MmTWLFiBaqqqqCpqanudFRO/v1sq+ffBOu11J0BERERERHR4/Tv3x9ffvklli9fjmPHjmHz5s1YvHgxPvzwQwwbNgx+fn6YMmUKDAwM1J0qET2F3NxcJCQkYNu2bUqPdeXKFcX/raiogKenJ/7++2+cPn0aS5cuVXp8atnmz5+PP/74A99++y10dXUREhICbW3tOv0qKyvx1VdfYcGCBWrIkpqLt7c3HyK3QCw8UWPxm0JERERERK2GhoYGRo4ciXXr1kEmk+Gnn36CkZER3n//fZiammLSpEnYvXv3IxdjJaKWa+vWrTAwMKi1kLSy3LhxAx07dsTevXsxevRodOnSBdu2bUOnTp0wevRopcenlk0ikWDr1q1YvHgxVq9ejYEDByIsLAyZmZmoqKhAQUEBdu7cCQcHByQnJ6OqqkrdKRMRtVkschARERERUavUrl07TJ48GXv27EFeXh7CwsJw7949+Pj4wNTUFH5+foiJieGDJ6JWZMuWLZg8eTKee+45pccqKCiAkZERfvvtN3h7ewMAduzYAS8vL6UveK5MDy6i/fCC2m0hfnOSSCT4z3/+g/T0dHh4eGDdunVwcHCAgYEB7O3tsX37doSEhCA2NhZaWq1jshT5QuuP24iIWpPW8ReYiIiIiIjoETp16gQ/Pz/4+fkhJycHUVFR2LlzJzw8PGBmZgZvb2/4+PhgxIgRfHhD1EKdO3cOFy5cwNq1a1US786dO5BIJCgvL4dUKkVWVhbOnj2LkJAQlcRXFnWvg6Hu+MpgY2ODkJCQVv/dAJ7N+0NExDc5iIiIiIjomWJubo6goCAkJSXh6tWrmDNnDn777Tc4OTmhR48emD9/PjIyMtSdJhE9ZPPmzXjhhRcwbNgwlcSrqqpCSUkJHB0dYWpqiu3bt8PIyAivvPKKSuITERFR82CRg4iIiIiInlndu3fHvHnzkJGRgdTUVEyePBkRERHo3bs37OzssHz5cuTm5qo7TaI2r6qqCpGRkfD19VXZ21bV1dUoKipSrP+xY8cOeHt7t5pph4iIiOgfLHIQEREREVGbYGdnh9DQUGRnZyMxMREuLi746quvYGlpiZEjR2LVqlUoKChQd5pEbVJcXBzy8vIwbdo0lcUsKChAZWUlPDw8cPnyZfz++++YNGmSyuITERFR82CRg4iIiIiI2hQNDQ1FUSM7Oxu7d+9Gjx49sGjRIlhYWEAqlSIiIgJ3795Vd6pEbcbmzZsxcuRI9OjRQ2Uxc3JyoK2tDTs7O+zYsQMmJiZwdnZWWXwiIiJqHnwHk4iIiIiI2qznnnsOUqkUUqkUq1evxp49e7Bz5068++67mD17NsaNGwdfX1+4ublBW1tb3ekSPZOKi4uxd+9erFq1SqVxL1++DA2Nf377KZ+qSlNTs1ljnDhxotnHJKLmc/LkSXWnQETNgEUOIiIiIiIiAB07doSfnx/8/PxQWFiI6OhoREREwNPTE4aGhvD29oavry9GjBihsjUDiNqCmJgYVFVVwdvbW2UxMzMzFevxHDt2DH/88QfWrFnTrDGEEFi1apXKizdERERtDaerIiIiIiIieoiRkRH8/f2RlJSEv/76C0uWLMGpU6fg5OSE7t27IygoCOfOnVN3mkTPhKioKLi4uMDQ0FBlMffs2aOIt27dOpiammLEiBHNGkMikSAyMhJCCG7cuLXQLSoqqln/uyci9WCRg4iIiIiI6BGsrKwURY3U1FS89dZbiI2NxaBBg2BnZ4fg4GBkZWWpO02iVqmsrAz79++Hl5eXSuPGxsbitddeg5WVFX777TdMmjSJ00oRERG1UixyEBERERERNZK8qHHlyhUkJibCxcUFa9euha2trWIx8/z8fHWnSdRqxMbGoqKiAh4eHiqLeffuXRw7dgyvvfYahg4divz8fEyaNEll8YmIiKh5schBRERERETURBoaGoqixvXr1/Hzzz/D0tISCxcuhKWlJcaPH48tW7aguLhY3akStWjR0dEYNWoUunTporKYR44cwf379zF69Ghoaf2zVGnnzp1VFp+IiIiaF4scRERERERET0FHRwceHh6IjIxEXl4eNmzYAIlEgnfeeQcmJibw8vLCzp07UVZWpu5UiVqU8vJy/Prrryqfqio+Ph4vvvgiTE1Nce7cOXTu3BnffPONSnMgIiKi5sMiBxERERERUTPp0KEDpk2bhpiYGOTl5WHdunW4f/8+3nzzTRgbG0MqlSIiIoIFDyIAv/76K+7evYsJEyaoNG58fDzGjBmDc+fO4dKlSwgICEBERATS09NVmgcRERE1DxY5iIiIiIiIlKBTp07w8/NDTEwMZDIZwsLCAABvv/02zMzMFPsqKyvVnCmRekRHR2PkyJHo1q2bymLm5+cjLS0Nr776KrZv3w4bGxssXboU/fv3x9tvv43q6uo6x8THx+O7777jf6tEREQtFIscRERERERESta5c2dFUePatWtYunQpsrKy4OnpCRMTE8W+qqoqdadKpBL3799HbGwsXn/9dZXGTUpKgkQiwfDhwxEVFYVJkyZBW1sbP/zwA86dO4f333+/zjFffvklAgMD0atXL+zZs0el+VLrJJPJ8Pnnn2PEiBHo2rUrdHV1YW1tDalUisjISP6tJyJqZixyEBERERERqZC5uTmCgoKQlJSEv/76C5999hmysrLg4eGBbt26ISAgAElJSRBCqDtVIqU5evQo7ty5o/KpqpKTk9G/f3+kp6cjMzMTkydPBgDY2dlh+/btWL9+PebOnYuamhrFMefOnQMAXLt2DRMmTICzs7OijehhK1aswAsvvICIiAj4+PggMTERRUVFOHXqFAIDAxEVFQVHR0ekpaWpO1UiomcGixxERERERERqYmVlpSh4ZGVlYe7cuUhMTISTkxOsra0V+1jwoGfNvn37YGdnB2tra5XGTUpKwogRI7B9+3b07NkT9vb2in0eHh7YtGkT1qxZA3d3d9y8eROFhYUoKCgAAEXh4/jx43BwcIC3tzf+/vtvleZPLdvs2bMxd+5czJgxA+fPn8cHH3yAXr16oV27djAxMYGbmxuio6Px2Wefwd3dHZcvX1Z3ykREzwQWOYiIiIiIiFoAGxsbzJs3D2lpaUhNTcXbb7+NX3/9FU5OTrCxsUFQUBBSUlLUnSZRs/j111/x2muvqTTmvXv3cO7cOQwbNgzR0dGKtzge9MYbb+D48eO4cuUKevXqhQULFtTpU1VVBSEE9u7di549e2L+/PkoKSlRxSlQC7Z69WqEhYXB19cXa9asga6uboN9PTw8sHLlSkycOJFrvRARNQMWOYiIiIiIiFoYOzs7BAcH4/Lly0hNTcWMGTMQGxuLwYMHK/ZlZGSoO02iJ3L16lWkp6fD3d1dpXEvXLiAyspKaGho4O+//663yAEA9vb2OH/+PN577z1s2rQJWlpa9farrKxERUWFYnqi8PDwehcub+kkEoliS0tLg5ubGwwMDNChQweMGzcOly5darB/ZmYmXn/9dRgaGira5PLz8zF79mxYWFhAR0cH5ubm8Pf3h0wmU0l8mUyGgIAARXwLCwvMmjULeXl5da5BeXk5QkNDYW9vDz09Pejq6qJ3796YNWsWTpw48dhrWFhYiEWLFsHExARr165VtAcHB6Njx4544YUXcOTIkVo5Tpw4ET179sSWLVsaPL/c3Fx4eXlBX18fRkZGmD59Ou7cuYO//voLHh4eMDAwgKmpKWbMmIHbt2/Xyaux9wAAEhIS4OHhAUNDQ+jq6mLQoEHYtm1bnX4P5nf9+nV4enpCX18fJiYmmDZtGgoLCx97vYiImp0gIiIiIiKiFq+6ulokJiaKOXPmCFNTUwFA9O3bV3z22Wfizz//VHd6RI22Zs0aoa+vLyoqKlQad+3atcLAwEC89957ol+/fo06Ztq0aUJbW1sAeOQmkUiERCIRL774ojh8+LAQQggNDQ0RGRmpzFNqNvLzGD58uEhKShIlJSUiISFBmJqaCkNDQ3H16tV6+48ZM0YkJyeLsrIysW/fPiF/zCSTyYS1tbUwMTERcXFxoqSkRBw9elRYW1sLGxsbUVRUpNT4N27cEJaWlsLMzEwcOHBAFBcXK8aztrYWMplMMVZxcbEYPHiw0NfXF+vXrxcymUyUlJSIQ4cOiT59+ojGPDoLDQ0VAMTcuXMVbbt37xYAhKenp8jLyxP+/v6KvOV++eUX4erq2uD9mDZtmkhLSxO3b98WgYGBAoAYN26cmDhxoqJ99uzZAoCYOXNmrTGe5B5MmDBB3Lx5U1y7dk2MGTNGABC//fZbg/m9+eabdfKYMWPGY69XSxIVFSUAiKqqKnWnQvVo6/enrZ9/E4SzyEFERERERNTKPFjw6Nq1q6LgERoaKnJyctSdHtEjyR/Sqpq/v79wdnYW3bp1E//3f//XqGMGDhz42AJHfdvkyZNbZZFj3759tdp//PFHAUBMnz693v6HDh2qd7yAgAABQGzYsKFW+65duwQAsXDhQqXGnzlzpgAgNm/eXO94AQEBiraPPvpIABArV66sM87Zs2cbVeRwdnYWAERSUpKizc3NTQAQiYmJQgghUlJS6hQ5bt68KYyMjOqMJ+8nL5gJIUROTk697devXxcAhLm5ea0xnuQePFhMunTpkgAgnJycGpXf1atXBQBhZmZW7zVqqfgQuWVr6/enrZ9/E4RzuioiIiIiIqJWRkNDAyNHjsSqVauQm5uL+Ph4ODg4YNmyZbC0tFTsq29aFiJ1qqiowJEjR1Q+VRUAnD9/HkZGRrhx4wYmTZr02P41NTVIT09/ZB8tLS3o6OgoPuvo6KBPnz4wNjZ+6nzVYfjw4bU+u7i4AAD2799fb/8hQ4bU2x4TEwMAde6zs7Nzrf3Kih8bGwsAGD16dL3jyfcDQFRUFABgwoQJdcaxt7eHEKLeGA+Sf0+sra0VbRcuXAAA9OvXDwDQu3fvOscZGBiguLi4wXEHDRqk+LepqWm97WZmZgCA3NzcWsc29R4IIdC9e3fFZ1tbWwBAWlpao/KT53Hjxo0G+xMRKUv9E0sSERERERFRq6CpqQkXFxe4uLjg3r172LdvH7Zt24YFCxbg3//+N1599VVMnjwZnp6eMDQ0VHe61MYdPnwYpaWlGDt2rMpjX758Gdra2hg0aBB69uz52P6ZmZkoLy8HAMW6HFVVVQCA9u3bo2fPnhg0aBB69+6Nvn37ok+fPujevTs0NP75PemDazO0Fh07dqz1WV6suXnzZr3927dvX297fn4+gP89+H5YZmamUuPL+z9cbJJ/lucH/O+h/INFhKYqKioCAJiYmCjaCgoKAAAdOnRoMNecnBx06dKlwXH19fUV/5Z/rxpqf7gY05R7cPv2bXzxxRf4+eefkZ2djdLSUsW+R62x8WAe8mJfY4pCRETNjW9yEBERERERPSPatWsHLy8v7Ny5E/n5+fjxxx+hra2NWbNmwdTUFOPGjcMPP/ygeCBHpGq//vor+vfvDysrK5XGLSwsRFFREf74448GFxx/mBACFhYWGDFiBN599118/fXXiI+PR3Z2Nu7evYtz585hw4YN+Pe//41x48ahR48etR5Et0YPP9CWP6h/1IP4+sgf9t+6dQtCiDrb3bt3lRq/a9eutY5/eDz5/gdzfZo3EDp16gQAKCkpUbTJCyrygkFZWVmd4w4dOoRRo0Y9cdxHaco9mDRpEkJCQjB58mRcu3ZN0YeIqLVo3f/rS0RERERERPXq0KED3njjDezduxe3bt1CVFQUjIyM8P7776NLly6KKa0e/EUzkbIlJCTA1dVV5XH//PNPAEBxcXGjpqoCgJ49e+L69etISkrC2rVr8f7778PFxQXm5ubKTFWtkpOTa31OSEgAgCbfM/nUT4cPH66zLzExEcOGDVNqfKlUCgA4cOBAvePJ9wOAl5cXAGD37t11xjlx4gQcHR0fG08+tVNGRoairX///gCA1NRUAMClS5dqHVNcXIxvvvkGn3zyyWPHfxJNuQfy6/7xxx+jc+fOAP6ZWo6IqLVgkYOIiIiIiOgZ1759e0ilUkRERCA/Px8///wzevTogUWLFsHMzIwFD1KJmzdvIi0tTWm/XH+Uq1evQkNDAy+99FKtdQeotrCwMCQlJaG0tBQHDx7EggULYGhoiODg4CaNExwcDFtbWwQGBiIqKgqFhYUoKSlBbGwsZsyYgdDQUKXGX7p0KaytrTF//nwcPHgQJSUlivGsra1rjRccHIx+/fphyZIlWL9+PfLy8lBaWoq4uDj4+flh2bJltcaWSCSQSCS12uTTr8XHxyvaZs2aBQD48ssvkZ+fj/DwcMW+48ePw8PDA4sWLcKAAQOadG6N1ZR74OTkBAAICQnB7du3cevWLSxcuFApeRERKQOLHERERERERG0ICx6kLkePHoWGhgZGjBih8tg5OTkA0Oi3ONqq7777DsuXL4eZmRk8PDwwcOBAJCcn1yoMPfiAv74H/sA/UzWdPHkSU6dOxSeffIJu3brB1tYW4eHh2Lp1K15++WWlxjcxMcHJkychlUrh6+uLzp07w9fXF1KpFCdPnqy1dkanTp1w/PhxBAUFYcWKFbCyskL37t3x9ddfY8OGDXj11Vcfe91mzpyJdu3aITw8XLGOi6enJ5YsWYLDhw9j+PDheOONN9ChQwf07t0bP/30E77//ntMmTKlzlgPn9+T/rsp9yAiIgK+vr7YsGEDTExM8PLLL9d6g+Vp8iAiUgWJ4CR7REREREREbV5ZWRkOHDiAnTt3YteuXSgvL8fQoUPh4+ODKVOm1HooSPQk5syZg+TkZKSkpKg89htvvIHIyEhkZWXBxsZGJTE1NTWxdevWeh9ktzTyh9LqekSk7vjNISQkBAsXLkRgYCDWrFmj7nSokaKjo+Ht7Y2qqipoamqqOx16SFu/P239/JtgPd/kICIiIiIioke+4WFubq54wyMvL0/dqVIrdfTo0QZ/wa9sv//+O/T19VVW4KC2Z/78+Zg6dSq+/fZbzJ07F5WVlfX2q6ysREhIiIqzo2eRk5OTYqoxqt8vv/wCT09PmJqaQkdHB6amppBKpfWuwSN/M+zhrbH9mrJR82ORg4iIiIiIiGp5sOBx8+ZNRcHj008/ZcGDnkhRURH++OMPODs7qzx2dXU1rl69CktLS5XHprZDIpFg69atWLx4MVavXo2BAwciLCwMmZmZqKioQEFBAXbu3AkHBwckJyejqqpK3SlTK1dTU4Oamhp1p9EiVVZWYtq0aXjzzTcxevRonD59GqWlpTh9+jReffVVTJ8+HV5eXrh3757iGCFErbfJHv5cX3t9/25onIbGo+bBIgcRERERERE1qF27dvW+4cGCBzVFYmIihBAYOXKkymMfOXIE5eXlMDMzU3ns1kDdaymoO35zkkgk+M9//oP09HR4eHhg3bp1cHBwgIGBAezt7bF9+3aEhIQgNjYWWlpa6k6XWrnk5GQkJyerO40W6f3338eOHTuQkJCAoKAgWFpaQkdHB5aWlvjggw+wf/9+7N27F/7+/upOlZoJixxERERERETUKI0teMhkMnWnSi3MkSNH0K9fPxgbG6s8dnR0NAwNDdG+fXuVx24N1P0rY3XHVwYbGxuEhITg3LlzuH37NioqKnD9+nVERUVh3Lhx6k6P6Jl28uRJrFu3DjNmzMDgwYPr7ePo6Ag/Pz9s2bIFiYmJTx2zKX+7npW/cy0NixxERERERETUZI8qeFhYWLDgQbUcOXJELetx1NTUYPfu3ejevTuqq6tVHp+ISBketb6DTCZDQEAALCwsoKOjAwsLC8yaNavNvHEZFhYGAPD29n5kPx8fHwDA+vXrlZ4TKR+LHERERERERPRUWPCgRykrK8P58+fVMlXV8ePHkZubCzs7O9y+fVvl8YmIlKGhtwFkMhmGDBmC2NhYREREoLCwEJs2bcKePXvg6OjYJgod8jczXnzxxUf269+/PwBwyq9nBIscRERERERE1GwaKngsXry4VsEjOztb3amSipw9exZVVVUYMmSIymNHR0ejZ8+eePHFF5GTk6Py+EREqrRkyRJcv34dy5cvx+jRo6Gvr49XX30VoaGhuHbtGj777DN1p6h0ubm5AAAjI6NH9pPvv3HjhtJzIuVjkYOIiIiIiIiU4sGCh0wmQ2RkJCwtLbF48WJYWVlh2LBh+PLLL5GVlaXuVEmJUlJS0LlzZ3Tv3l2lcYUQ2LVrF3x8fGBmZobc3FzOhU5Ez7TY2FgAwOjRo2u1u7i41NpPUEz1Vd+UX9T6aKk7ASIiIiIiInr2tW/fHj4+PvDx8UFFRQUSExMRExODFStW4JNPPkHfvn3h4+MDqVQKBwcHdadLzSglJQUvvfSSyh8knTlzBteuXYOXlxfKy8tx//59ZGVl4fnnn1dZDqtWrcKuXbtUFo+ImuZZe6vw5s2bAABjY+Na7fLP+fn5Ks9J1bp164asrCzcunULpqamDfYrKCgAAJiZmdVq19DQQE1NDaqrq6GpqVnvsdXV1dDQ4LsDLQnvBhEREREREanUc889BxcXF6xatQo5OTlITEyEi4sLvv/+ewwePBg9evRAUFAQkpKS+Mv7Z8CZM2fUUriKjo5G9+7dMXDgQAwaNAi6uro4duyYyvMgIlKVrl27AvjfA3w5+Wf5/meZk5MTAODChQuP7Cff7+zsXKtdX18fAHDnzp0Gjy0qKoKBgcHTpEnNjG9yEBERERERkdpoampi5MiRGDlyJL755hucO3cOMTExiIyMxH//+19YWlrC3d0d48ePh7u7O7S0+P/GtialpaXIyMhQS5Fj9+7d8Pb2hkQiwXPPPQcHBwckJyfD19dXZTkEBQVhypQpKotHRE0THR0Nb29vdafRbKRSKdatW4cDBw7U+luXkJCg2P+smzVrFjZt2oTo6Gi4uro22G/nzp2K/g/q1asXTp06hdTU1DoFELnU1FT07Nmz+ZKmp8Y3OYiIiIiIiKhF0NDQgIODA4KDg5GRkYHU1FS8/fbbSElJgYeHB0xNTeHn54eYmBjcv39f3elSI6SkpKCmpgaDBw9Wadzz588jIyMDXl5eirZXX30VsbGxqK6uVmkuRESqsnTpUlhbW2P+/Pk4ePAgSkpKcPDgQSxYsADW1tYIDg5Wd4pKN3ToUAQEBOCHH37AmTNn6u1z8uRJREREICAgAC+99FKtffJC0A8//NBgjA0bNmDcuHHNlzQ9NRY5iIiIiIiIqEWys7NDcHAwzpw5g8zMTCxevBhZWVnw9PSEiYkJJk2ahIiICJSWlqo7VWpASkoKunTpAisrK5XG/fnnn2Fubg5HR0dF24wZM3Djxg389ttvKs2FiKi5PbjG0YP/NjExwcmTJyGVSuHr64vOnTvD19cXUqkUJ0+ehImJiTrSVbnVq1fDx8cHY8aMwX//+19kZ2ejsrIS2dnZWLVqFcaOHYvJkydj9erVdY4NCgpC37598eOPPyIwMBCpqamoqKhARUUF/vjjD8yePRunT5/GBx98oIYzo4awyEFEREREREQt3oPrdPz1118IDg5GUVER3nnnHXTt2hVSqRQRERGPnEObVE++6Liq7dmzBxMmTKj18M/GxgajRo3CunXrVJ4PEVFzEkLU2h5kYmKCsLAw5OTkoLKyEjk5OVi3bl2bKXAAgLa2NrZu3YotW7YgISEBDg4O0NPTw6BBgxAfH48tW7Zgy5Yt0NbWrnOsvr4+jh8/jqVLl+LUqVMYMWIE9PT00KVLF0yfPh1dunTByZMnG1yTQyKR1ClCPfiZlIOTmRIREREREVGrYmVlhaCgIAQFBaGgoAD79u3Dzp07MXPmTPj7+8PJyQnjx4/HlClT2tRDnZbo/Pnz8PT0VGnM69ev4/z58wgNDa2z76OPPoJUKsWRI0fw8ssvqzQvIiJSrXHjxj3RtFIGBgZYsmQJlixZ0uRjHy46kWrwTQ4iIiIiIiJqtYyNjRXrdMhkMoSHh8PQ0BCLFi2Cubk5Ro4ciVWrViEnJ0fdqbY5VVVV+PPPP9G3b1+Vxo2JiYGenl69RYxx48bB3d0dgYGBqKysVGleRI0l/+V3a/n197Zt2+Do6AhDQ8NH5t7azouIWg8WOYiIiIiIiOiZYGhoCD80PvW3AAAgAElEQVQ/P+zYsQM3btzAli1bYGZmhk8//RRWVlYYOXIkVqxYgT///FPdqbYJWVlZqKioQO/evVUaNyYmBmPHjoWurm69+1euXInMzEzMnz9fpXmR6slkMnz++ecYMWIEunbtCl1dXVhbW0MqlSIyMhJVVVXqTrFej/oluJOTE5ycnFSYzaNFRERg6tSpMDIywu+//47y8nJER0fX25e/cCciZWGRg4iIiIiIiJ45+vr6mDJlCnbs2IH8/Hzs2rULzz//PJYtWwZbW1v069cPixYtwqlTp/jgTUnS09MhkUjQq1cvlcW8e/cuDh8+DKlU2mAfW1tbbNq0CStXrsSaNWtUlhup1ooVK/DCCy8gIiICPj4+SExMRFFREU6dOoXAwEBERUXB0dERaWlpasnvSd9oqKmpQU1NjRIyejJff/01gH+ut7W1NZ577jm8/vrr/LtKRCrFNTmIiIiIiIjomdauXTt4enrC09MT1dXVOH78OGJjYxEdHY1ly5ahS5cucHNzg4+PD1xdXfHcc8+pO+VnQnp6OiwsLNChQweVxYyLi8P9+/fh5ub2yH6TJk3Cn3/+iQ8++ADV1dUICgpqsO+AAQNgb2+PxYsX4/nnn2/ulEkJZs+ejbCwMAQGBuKrr76q9VZPu3bt4ObmBjc3N+zduxfu7u6Ij49Hz5491Zhx4yUnJ6s7hVouX74MAHjhhRfUnAkRtWV8k4OIiIiIiIjaDE1NTYwcORKhoaFIT09HamoqPv74Y2RlZcHT0xOdO3eGVCpFeHg48vPz1Z1uq5aenq7yqap++eUXDB06tFELzi9cuBCff/45Pv74Y8yYMQPl5eV1+hQUFODChQvYvHkzevbsienTp+PKlSvKSJ2ayerVqxEWFgZfX1+sWbOmwWnLAMDDwwMrV67ExIkTuUbLE7p37x4AQFtbW82ZEFFbxiIHERERERERtVl2dnaYN28ekpKSIJPJsHbtWgDA+++/DzMzM4wcORLLly9X/FqZGk8dRY74+Hi4u7s3uv+8efPwyy+/YO/evejVqxciIiJqTbPz119/AfjfFEGRkZHo1asXvL29kZ6e3qy5P7goc1paGtzc3GBgYIAOHTpg3LhxuHTpUoP9MzMz8frrr9da+FkuPz8fs2fPhoWFBXR0dGBubg5/f3/IZDKVxJfJZAgICFDEt7CwwKxZs5CXl1fnGpSXlyM0NBT29vbQ09ODrq4uevfujVmzZuHEiROPvYaFhYVYtGgRTExMFP8tA0BwcDA6duyIF154AUeOHKmV48SJE9GzZ09s2bKlzniNzb2hBbUf1f5wn3ffffex5/eohbuf5D4/6r41Rn3n8fDWWI3N/86dO/jwww/Ro0cP6OrqwsjICMOHD8fcuXNx6tSpJuVPRM8QQURERERERES1lJaWir179wpfX1/RqVMnAUD07dtXzJs3TyQmJoqamhp1p9jide7cWXz77bcqi/fHH38IAOLkyZNNPvb69evC19dXaGhoiOHDh4vdu3eL+/fvi507dwqJRCIA1Nq0tbWFRCIRXl5eIi0trd4xNTQ0RGRkZJPykI8/fPhwkZSUJEpKSkRCQoIwNTUVhoaG4urVq/X2HzNmjEhOThZlZWVi3759Qv64RyaTCWtra2FiYiLi4uJESUmJOHr0qLC2thY2NjaiqKhIqfFv3LghLC0thZmZmThw4IAoLi5WjGdtbS1kMplirOLiYjF48GChr68v1q9fL2QymSgpKRGHDh0Sffr0EY15hBUaGioAiLlz5yradu/eLQAIT09PkZeXJ/z9/RV5y/3yyy/C1dW11lhNyf3Ba/GwprY/yXFPep8bum9N0Rzn3ZT8PT09BQCxcuVKUVpaKioqKkR6erqYOHHiE+UfFRUlAIiqqqomH0vK19bvT1s//yYIZ5GDiIiIiIiI6BGqqqpEYmKimDNnjrC0tBQAhJWVlfD39xd79+4VFRUV6k6xxZHJZAKAOHDggMpirlixQhgaGj7Vw6AzZ84INzc3oaGhIbp27SqcnJyEjo5OnSKHfNPR0RESiUS89tpr4ty5c7XGepoix759+2q1//jjjwKAmD59er39Dx06VO94AQEBAoDYsGFDrfZdu3YJAGLhwoVKjT9z5kwBQGzevLne8QICAhRtH330keLh9cPOnj3bqAfYzs7OAoBISkpStLm5uQkAIjExUQghREpKSp0H7Tdv3hRGRkZPnLsQ6i1yPOl9bui+NUVznHdT8jcwMBAAxM6dO2v1zcnJYZHjGdTW709bP/8mCOd0VURERERERESPIF/HY9WqVfj777+RmpqK9957DxcvXoSnpydMTU0xadIkRERE4M6dO+pOt0XIzMwEoNrFiOPi4uDq6gpNTc0nHsPBwQG//vor/vrrL7z//vvIyMioNX3Vw+7fvw8hBBISEjBo0CCMGzcO586de+L4csOHD6/12cXFBQCwf//+evsPGTKk3vaYmBgAqDOFl7Ozc639yoofGxsLABg9enS948n3A0BUVBQAYMKECXXGsbe3f+R9kJNPIWZtba1ou3DhAgCgX79+AFDvFGoGBgYoLi5+4tzV7Unvc0P3TdWakr+XlxcAwMfHB1ZWVnj33XexY8cOGBsbN+o7QkTPJhY5iIiIiIiIiJrgwXU8rl69itDQUNy7dw/vvvsujI2NFQWR7OxsdaeqNtevX4empibMzMxUEq+8vByJiYlwdXVtlvEsLS3x6aef4qWXXmrUgtTyYsevv/4KBwcHTJs27anid+zYsdZnY2NjAMDNmzfr7d++fft62/Pz8wEAZmZmtdZJkI8nL0YpK768v/z4h8eT5wcAN27cAACYmprWO1ZjFBUVAUCthecLCgoAAB06dGgw15ycHHTp0uWJc1e3J73PDd03VWtK/hs3bkR0dDS8vLxQWlqKDRs2YPLkybC1tcXvv/+ulvyJSP1Y5CAiIiIiIiJ6QtbW1vD390dMTAxu3LiBDRs2wNTUFIsWLYKVlRUcHR2xbNkyXLx4Ud2pqlR2dja6desGLS0tlcQ7evQo7t27hzFjxjTruFeuXGlUP21tbQCAEALdunWDvr7+U8UtLCys9Vn+oP7hB/GPI3/Yf+vWLQgh6mx3795VavyuXbvWOv7h8eT7H8xVXux4Ep06dQIAlJSUKNrkD8pLS0sBAGVlZXWOO3ToEEaNGvXEuQP/W4T7waKYqt7setL73FI0Nf/XX38dUVFRKCgowNGjRzF27Fj8/fffeOutt9SRPhG1ACxyEBERERERETUDIyMj+Pn5KR6+7d+/H0OHDsV3332Hfv36wcbGBgEBAdi5c6figeuzKjs7GxYWFiqLl5CQgL59+8LS0rJZx71+/XqdNi0tLcWUWO3atYOjoyNmz56NHTt2IC8vDzk5OVi7du1TxU1OTq71OSEhAQCa/KaKfOqnw4cP19mXmJiIYcOGKTW+VCoFABw4cKDe8eT7gf9NQ7R79+4645w4cQKOjo6PjWdrawsAyMjIULT1798fAJCamgoAuHTpUq1jiouL8c033+CTTz554tyB/72B8mCR5lFTl8nfoqisrERZWVmdN0aa4knvc0vRlPwlEoniLTkNDQ04OTlh+/btAOreWyJqQ1S6BAgRERERERFRG1NdXS2OHz8uFi1aJAYOHCgACD09PeHp6SnCw8NFdna2ulNsdt7e3sLHx0dl8YYMGSICAwObdczCwkIBQGhoaAgAQlNTU/Tp00cEBASIjRs3iosXL4rq6uoGj3+ahcfd3d1FYmKiKCkpEQcOHBDdunUThoaG4urVq/X2b8jNmzeFra2t6Natm9i5c6coKCgQxcXFIiYmRvTo0UMcPnxYqfFlMpmwtrYWZmZm4sCBA6K4uFgxnrW1tZDJZIq+RUVFol+/fkJfX1+Eh4cLmUwmSkpKxG+//SZsbW1FQkLCY2MvXbpUABBLly5VtO3evVsAEB4eHiIvL0/4+/srjj127Jh4+eWX671PTcldCCH8/PwEAPGvf/1L3L59W1y6dEm8+eabDV6joUOHKhZJ37Ztmxg/fnyjrm197U96n5tDU/JsjvwBiLFjx4rU1FRRXl4uZDKZWLBggeIeNxUXdm7Z2vr9aevn3wThLHIQERERERERqVBeXp7YtGmT8PHxEQYGBgKA6Nu3r5g3b56Ij48XlZWV6k7xqQ0dOlR8+OGHKolVUlIitLW1xfbt25t13IqKCvGvf/1LLF++XBw+fFiUlpY26finKXJcvXpVjB8/Xujr6ws9PT3h7u4u0tLS6u374FafW7duiY8++kjY2NgIbW1tYWJiIqRSqTh+/LhK4stkMhEQECDMzMyElpaWMDMzE/7+/nWKBEL8cy8//fRT0atXL6GjoyOMjIyEq6urOHr0aIO5Pig3N1e0a9dOmJubi3v37inalyxZIgwMDMTzzz8vDh8+LDp06CB69+4t/vWvf4krV67Um3dTc79586Z44403RJcuXYSenp6QSqXi77//bvD6nD59WgwYMEC0b99eDB06VGRkZDR4bR/XLkTj73Nj71tjNDXP5sg/KSlJTJ8+XXTv3l1oa2uLjh07igEDBojPP/9c3L17t8nnwIfILVtbvz9t/fybIFwihBBNefODiIiIiIiIiJpHeXk5kpKSkJCQgN27dyMjIwNGRkYYPXo0xo8fDw8PD8U6A62JpaUlPvjgA3z88cdKjxUXFwc3Nzfk5OSobKHzxtDU1MTWrVsxZcqURh8jX9dBXY9q1B2/OYSEhGDhwoUIDAzEmjVr1J0OtXDR0dHw9vZGVVWVYho6ajna+v1p6+ffBOu5JgcRERERERGRmujq6sLFxQWhoaFIT09HZmYmFi9ejKKiIrz77rswNjbGyJEjsXz5cqSkpKg73Uaprq6GTCZr9vUxGnL06FH07NmzRRU4SH3mz5+PqVOn4ttvv8XcuXNrLQT+oMrKSoSEhKg4OyIiUgYWOYiIiIiIiIhaiB49eiAoKAjx8fHIy8tDZGQk7OzssHLlSgwePBg9evRAQEAAYmJiUFFRoe506yWTyVBVVQVzc3OVxDty5AhefvlllcSilk8ikWDr1q1YvHgxVq9ejYEDByIsLAyZmZmoqKhAQUEBdu7cCQcHByQnJ6OqqkrdKRMR0VNikYOIiIiIiIioBTI0NISPjw/WrVuHnJwcnDlzBn5+fkhJSYGnpyc6d+6MMWPGYNWqVcjJyVF3ugoFBQUAgC5duig91r1793D69Gk4OTkpPZayyaeKevjfbSV+c5JIJPjPf/6D9PR0eHh4YN26dXBwcICBgQHs7e2xfft2hISEIDY2FlpaWupOt0WRSCSN2oiIWhL+JSciIiIiIiJq4TQ0NODg4AAHBwcEBwcjLy8PcXFxiI2NxeLFi/HBBx+gb9++kEqlGD9+PIYPHw4NDfX8rvHOnTsAgI4dOyo91rlz53D//n2MGDFC6bGUTd3rYKg7vjLY2NggJCSE01I1wbP4PSCiZx/f5CAiIiIiIiJqZUxMTODn54cdO3ZAJpMhJiYGzs7O+Omnn+Dk5AQzMzPMmDEDP/30E27evKnS3IqLiwEABgYGSo91+vRpdO7cGTY2NkqPRURERC0T3+QgIiIiIiIiasXat2+P8ePHY/z48QCA8+fPY9++fYiLi8OMGTNQXV0Ne3t7jB07Fq6urhg+fDi0tbWVls+dO3egra2Ndu3aKS2GXEpKCl566SVOn0NERNSG8U0OIiIiIiIiomfIgAEDsGDBAhw+fBi3b99GXFwcXFxcEBcXh1GjRqFTp04YM2YMli9fjpSUlGaPf+fOHZVMVQUAZ86cgYODg0piERERUcvENzmIiIiIiIiInlHt27eHi4sLXFxcAABZWVlISEhAQkICQkNDMX/+fPTo0UPRZ8yYMejUqdNTxVRVkaO0tBQZGRkschAREbVxfJODiIiIiIiIqI3o0aMH/P39sWPHDhQUFODMmTPw9/fHxYsXMWXKFBgbG2Pw4MGYP38+kpKSUFNT0+QYqipypKSkoKamBoMHD1Z6LCIiImq5+CYHERERERERURukqakJBwcHODg4YN68eSgoKMChQ4eQkJCAn376CcuXL4exsTFeeeUVuLi4wN3dHZaWlo8dV1VFjj/++ANGRkawsrJSeqwnIYTA1KlTMXXqVHWnQkRE9ExjkYOIiIiIiIiIYGxsDB8fH/j4+AD439RWMTExCAoKQkBAgGJqq/Hjx2PMmDHQ1dWtM87du3ehp6en9HzT09PRu3dvpcd5UhKJBHPmzMGIESPUnQoRNeDkyZNYsWKFutMgoqfEIgcRERERERER1SGf2srf3x9lZWU4fPgw4uLisH//foSHh6N9+/ZwdnbGK6+8glGjRsHBwQGampqoqamBhobyZ8fOyMho0UUOABg6dKiiaERELY8q/lYRkfKxyEFEREREREREj9S+fXu89tpreO211wAA165dw/79+3HgwAF8/fXXmDdvHgwMDODs7Izc3FwYGBgovdiRkZEBV1dXpY1PRERErQOLHERERERERETUJNbW1pg5cyZmzpwJ4H9TWyUkJODixYuoqKhAp06d4OjoCBcXF7i4uMDe3r7Zih53795FdnY2evXq1SzjERERUevFd7KIiIiIiIiI6KnIp7basWMHvLy8MGbMGHz11VcwNDTEF198gcGDB8PU1BRSqRTLly9HSkoKhBBPHO/y5csQQrDIQURERCxyEBEREREREVHzEUJAT09PUfTIz89Hamoq/t//+39o164dQkNDMXjwYHTr1g2TJk1CeHg4Ll682KQYV69ehUQigY2NjZLOgoiIiFoLTldFRERERERERM1GCAGJRKL4rKmpCTs7O9jZ2cHf3x9VVVU4c+YMDh06hEOHDuHDDz9EWVkZLC0t8corr2D06NF4+eWX0b179wZjyGQyGBkZQUdHRwVnRERERC0ZixxERERERERE1KweLHI8TEtLC0OHDsXQoUOxYMECVFVV4fz584o1PWbNmoXy8nJ069YNDg4OGDlyJEaMGIEhQ4Yoihp5eXkwMTFR1ekQKYVMJsOGDRuwb98+XLlyBcXFxTAxMUH//v3xxhtvwMfHB1pafHRHRPQ4/EtJRERERERERM1GIpGgpqam0f21tLTg4OAABwcHzJs3D+Xl5Th16hSSkpJw7NgxLF++HEVFRejQoQOGDh2KESNGICUlBcbGxko8CyLlWrFiBT777DOYm5tj9uzZcHd3h5WVFYqLi3Hu3DmsX78eX331FTZv3oy+ffuqO91n3pQpUx5ZnCX1yM7OVncK1EqwyEFEREREREREzcbAwAD5+flPfLyuri6cnZ3h7OwMAKipqUFaWhqSk5ORnJyMzZs3IysrCxKJBAMHDoSjoyMcHR0xZMgQ9OnTB5qams11KsjLy8PUqVPh4+OD6dOno3379s02NrVds2fPRlhYGAIDA/HVV19BV1dXsa9du3Zwc3ODm5sb9u7dC3d3d8THx6Nnz55qzJiIqGVjkYOIiIiIiIiImk3Hjh1x+/btZhtPQ0MD/fr1Q79+/RAQEAAAGDJkCLp06YLevXvj1KlT2LJlC8rKyqCvr4/BgwfXKnyYmZk9cey0tDQcOnQIR44cwYIFCzBnzhwEBgZyqix6YqtXr0ZYWBh8fX2xZs2aR/b18PBAdXU1Jk6ciN9//x3a2toqyrLt2bZtW7MWSKl5REdHw9vbW91pUCugoe4EiIiIiIiIiOjZ0dxFjvpUVVVh4MCBWLFiBRITE3Hnzh2cPXsWX3zxBbp3746YmBh4eXnB3NwcFhYWkEqlWLx4MXbt2oWsrKxGx5HJZIrpt+7cuYPQ0FBYWFjA19cXFy9eVOIZtjwSiUSxpaWlwc3NDQYGBujQoQPGjRuHS5cuNdg/MzMTr7/+OgwNDRVtcvn5+Zg9ezYsLCygo6MDc3Nz+Pv7QyaTqSS+TCZDQECAIr6FhQVmzZqFvLy8OtegvLwcoaGhsLe3h56eHnR1ddG7d2/MmjULJ06ceOw1LCwsxKJFi2BiYoK1a9cq2oODg9GxY0e88MILOHLkSK0cJ06ciJ49e2LLli1PdT0AICEhAR4eHjA0NISuri4GDRqEbdu21enX2GtHRNRSsMhBRERERERERM2mU6dOuHPnjlJjVFVV1frVtZaWFuzt7TFr1ixs3LgRqampKCoqwoEDBzBnzhx06NABUVFRmDRpEp5//nl06tQJo0aNwocffogff/wRp0+fRklJSZ04+fn5tX49X1lZiaqqKmzfvh0vvvgiRo8ejZiYGKWea0shhFD8e+bMmVi8eDFyc3OxZ88enD17FiNGjMBff/1Vb//Zs2dj7ty5yM3Nxb59+xTteXl5GDJkCH7++Wds3LgRt27dwrZt27B//34MHz68VrFMGfFlMhmGDBmC2NhYREREoLCwEJs2bcKePXvg6OhYq9BRUlICJycnLFu2DIGBgcjKykJBQQHCwsJw9OhRDBs27LHX8Pvvv0dJSQl8fX2hp6cHANizZw+WLl2KV155BceOHcNPP/1U57iZM2fWKUY09XoAwJgxY6CpqYkrV67g8uXLMDY2xtSpUxEXF9fg2A1dOyKiFkUQERERERERETWTrVu3Ci0tLaXG6Nu3rwgODm7ycaWlpeLYsWPiu+++EzNnzhSDBw8Wurq6AoAAIKysrISrq6v44IMPxLp168Rbb70lnnvuOcX+hzctLS0BQNjZ2YlNmzaJ+/fvK2JpaGiIyMjI5jxttZOf9759+2q1//jjjwKAmD59er39Dx06VO94AQEBAoDYsGFDrfZdu3YJAGLhwoVKjT9z5kwBQGzevLne8QICAhRtH330kQAgVq5cWWecs2fPisY8YnN2dhYARFJSkqLNzc1NABCJiYlCCCFSUlIUecvdvHlTGBkZ1RnvSa7H1atXFZ8vXbokAAgnJ6cGx27o2j0roqKiBABRVVWl7lSoHm39/rT182+CcK7JQURERERERETNpmPHjqiqqsLdu3cVv1ZvblVVVdDSavojDT09PQwbNqzOr+5zc3ORlpaGixcvIi0tDadPn8bGjRuhr6+P6urqR+YBAJcuXcKMGTMwd+5cvPfeewgKCmpybq3J8OHDa312cXEBAOzfv7/e/kOGDKm3Xf4WjLu7e612+aLzMTEx+Pzzz5UWPzY2FgAwevToeseT7weAqKgoAMCECRPqjGNvb1/r7YeGpKenAwCsra0VbRcuXAAA9OvXDwDQu3fvOscZGBiguLi4wXEbez0eztHW1hbAP2vPNKSha0dE1JKwyEFEREREREREzaZTp04AgDt37iityFFdXd2siwSbmZnBzMxM8XBYzs3NDTk5OY89vqamBgBw8+ZNLF26FBs2bGi23Fqijh071vpsbGwM4J/zr0/79u3rbc/PzweABheHz8zMVGp8eX/58Q+PJ88PAG7cuAEAMDU1rXesxigqKgKAWgvXFxQUAAA6dOjQYK45OTno0qVLg+M25nrcvn0bX3zxBX7++WdkZ2ejtLRUsa+wsLDBsRu6dkRELQnX5CAiIiIiIiKiZmNoaAjg0Q9On5aOjg4qKiqUNr5cQw/NH6Stra1YkNnW1hZz5szBDz/8oPTc1Onheyt/UP+oB/H1kT/sv3XrFoQQdba7d+8qNX7Xrl1rHf/wePL9D+YqL3Y8CXkB8MH1X+QFCXnRoaysrM5xhw4dwqhRoxoctzHXY9KkSQgJCcHkyZNx7do1xTUmInoWsMhBRERERERERM1GPhXPtWvXlBaja9eutX5lrywymaxOm46ODjQ0/nmcYm5ujrfeegs//vgjrl+/jsuXL2PVqlV13gh51iQnJ9f6nJCQAABwdXVt0jjyqZ8OHz5cZ19iYmKDi3k3V3ypVAoAOHDgQL3jyfcDgJeXFwBg9+7ddcY5ceIEHB0dHxtPPj1URkaGoq1///4AgNTUVAD/TH32oOLiYnzzzTf45JNPGhy3MddD3ufjjz9G586dAUAlhUIiIlVgkYOIiIiIiIiImo2enh66dOmCq1evKi1G165dG/WWxdO6desWJBKJoqhhYWEBX19fbN68Gbm5ucjOzsa6devg5+cHc3NzpefTUoSFhSEpKQmlpaU4ePAgFixYAENDQwQHBzdpnODgYNja2iIwMBBRUVEoLCxESUkJYmNjMWPGDISGhio1/tKlS2FtbY358+fj4MGDKCkpUYxnbW1da7zg4GD069cPS5Yswfr165GXl4fS0lLExcXBz88Py5YtqzW2/O2eB40dOxYAEB8fr2ibNWsWAODLL79Efn4+wsPDFfuOHz8ODw8PLFq0CAMGDGjwPBpzPZycnAAAISEhuH37Nm7duoWFCxc26XoREbVULHIQERERERERUbPq0aOH0oscqniTY/To0fD19cXGjRtx7do1XL9+Hd9//z3eeOMNdOvWTenxW6rv/n979x5cZX3ncfxzciMxF0ij5CqHUCJYQWAoojgVV0uEhQRIsMK2FNQaYMFWmXhDpcKWDbszFihYIRa0aAoUIky1FKdkSUkiFy9Vlkasi0Qw4QCBYAIxkDTf/cPNWUISyIGcnIS8XzPPTPjleb7f7/N7zuSP35fz/H79a/3Hf/yH4uLilJqaqsGDB6uoqEi9e/d2n3PhAn9zC/7SN69q2rNnj6ZMmaInn3xSsbGxSkpKUnZ2tnJycjRy5Eiv5o+OjtaePXuUkpKiqVOn6lvf+pamTp2qlJQU7dmzp9HeGT169NCuXbv0s5/9TC+++KJ69eql3r1765e//KVWr16te++997Lz9sgjjygkJETZ2dmqqamRJI0fP17z589Xfn6+RowYoX/5l39RWFiY+vfvr9/97nf6zW9+o8mTJ18ybmvmY+3atZo6dapWr16t6OhojRw5stG3Ty6er8vNHQB0JA7jBXwAAAAAAKANTZkyRTU1Ndq8ebNX4i9YsEAbNmxQcXGxV+K3BX9/f+Xk5J9n1MoAAB/XSURBVFx2gbozaVjs9tVSkq/zt4WsrCzNmzdPs2fP1ooVK64q1rUwH76Wm5urSZMmqa6uTv7+/r4uBxfp6s+nq9+/B17hmxwAAAAAAKBNJSYm6vPPP/da/F69eumLL75QfX2913IA3vD0009rypQpeumll5SZmana2tpmz6utrVVWVlY7VwcAnRNNDgAAAAAA0KYSExO9+rqq73znO6qurlZJSYnXcgDe4HA4lJOTo+eff17Lly/X4MGDtXLlSh08eFDnzp1TeXm5Nm7cqKFDh6qoqEh1dXW+LhkAOjyaHAAAAAAAoE316dNHVVVVOnnypFfi33LLLfL399df//pXr8RHUy3t2dBV8rclh8OhhQsX6sCBA0pNTdWqVas0dOhQRUREaMiQIdqwYYOysrL09ttvKyAgoMUYzf0MAF1R838pAQAAAAAArlD//v0lSf/93/+tu+++u83jh4WFadCgQSosLFR6enqbx0dTvt73wdf5vSExMVFZWVlX9Fqqa3E+AOBK8U0OAAAAAADQpuLj4xUXF6f33nvPaznuuusu/dd//ZfX4gMAgM6BJgcAAAAAAGhzw4YN82qTY+zYsdq3b59XNzgHAAAdH00OAAAAAADQ5rzd5Bg5cqQiIyOVm5vrtRwAAKDjo8kBAAAAAADa3LBhw1RSUqLjx497JX5gYKAmT56s7Oxs9icAAKALY+NxAAAAAADQ5oYNGyaHw6H33ntPY8eO9UqOmTNn6uWXX9b27ds1atQor+S4Grt375a/v7+vywDQgj179vi6BABtgCYHAAAAAABoc5GRkerbt69Xmxy33nqrRo0apYULF3a4JoeZadmyZVq2bJmvSwEA4JrG66oAAAAAAIBXDB8+XEVFRV7N8cILL6iwsFBbt271ah5PORwOrVu3TmbGwcHRQY9Nmzb5+k8FgDZAkwMAAAAAAHjFvffeq8LCQlVXV3stx4gRI3T//fdrzpw5Xs0DAAA6JpocAAAAAADAK0aPHq1z586poKDAq3mWLl2qU6dO6cknn/RqHgAA0PHQ5AAAAAAAAF4RExOjAQMG6J133vFqnri4OK1atUq//vWvtWHDBq/mAgAAHQtNDgAAAAAA4DXjxo3T5s2bZWZezfPAAw9ozpw5evDBB1VYWOjVXAAAoOOgyQEAAAAAALwmPT1dJSUl+vDDD72ea8mSJRo9erRSU1O1d+9er+cDAAC+R5MDAAAAAAB4zdChQ9WnTx/l5uZ6PZe/v79+97vf6c4779Q999yjP/3pT17PCVwNh8PhPjqK9evXa/jw4YqMjLxkfR2xdgBdE00OAAAAAADgVenp6Vq3bp3q6+u9nis4OFibN2/WD37wA6WkpGjhwoXtkhfXDpfLpUWLFunOO+9Uz549FRwcLKfTqZSUFK1bt051dXVtlsvbr3Hz1Nq1azVlyhRFRUXpo48+Uk1NTYsNyo5WO4CuiyYHAAAAAADwqmnTpqmkpET5+fntki8gIEBr1qzRsmXL9O///u+6++679cknn7RLbnRuL774ovr27au1a9fq/vvvV0FBgSoqKrR3717Nnj1bmzZt0vDhw1VcXOzrUhtpq29U/PKXv5T0zTw4nU5169ZNaWlpNDQAdGg0OQAAAAAAgFfdcsstuu222/Tqq6+2a97Zs2dr9+7d+vrrrzV48GA99dRTOnnyZKuv37dvn8LDw5WRkdHhFrXR9mbNmqXMzExNnz5dH3/8sR577DH169dPISEhio6O1ujRo5Wbm6uf//znGjNmjP7+97/7uuQ213BPffv29XElANB6NDkAAAAAAIDXPfTQQ8rNzfWoydAWBg8erN27d+vFF1/Uq6++qj59+ujZZ5/Vl19+edlr/+d//kdnzpzRa6+9pgEDBuiee+7Rtm3b+F/t16Dly5dr5cqVmjp1qlasWKHg4OAWz01NTdXSpUs1ceJE1dbWtmOV3vf1119LkgIDA31cCQC0Hk0OAAAAAADgdVOnTlVISIhWrVrV7rn9/f01Z84cff7553rqqae0evVqJSYmKj09XVu2bFFNTU2z1504cUKBgYGqra2VmamgoEBjxoxR7969tWzZMp09e7ad76SpCzd/Li4u1ujRoxUREaGwsDCNHTu2yWu6Ljz/4MGDSktLa7TBdIPjx49r1qxZSkhIUFBQkOLj45WRkSGXy9Uu+V0ul2bMmOHOn5CQoJkzZ+rYsWNN5qCmpkaLFy/WkCFDFBoaquDgYPXv318zZ87U7t27LzuHJ0+e1LPPPqvo6Gi9/PLL7vEXXnhB3bt3V9++ffWXv/ylUY0TJ07UTTfdpDfeeOOq5uNSWjsHF85bQ+6f/OQnrc5zqTgXH63V2s/PV199pccff1x9+vRRcHCwoqKiNGLECGVmZmrv3r0e3wOALsoAAAAAAADawRNPPGFxcXF27tw5n9Zx7tw5y8nJsZEjR5qfn59FRETY5MmTbfXq1fbFF1+4z/vFL35h3bp1M0mNDofDYf7+/hYaGmo//elP7fDhw01y+Pn52bp169rlfhrqGjFihBUWFlpVVZVt377dYmJiLDIy0g4dOtTs+aNGjbKioiKrrq62rVu3WsMykcvlMqfTadHR0fbOO+9YVVWV7dy505xOpyUmJlpFRYVX8x89etRuvPFGi4uLs7y8PKusrHTHczqd5nK53LEqKyvtu9/9roWHh9srr7xiLpfLqqqqbMeOHXbzzTdba5a+Fi9ebJIsMzPTPbZlyxaTZOPHj7djx45ZRkaGu+4Gf/zjHy05ObnNnseFPJmDlmJciZbieDLuyedn/PjxJsmWLl1qZ86csXPnztmBAwds4sSJbXI/l7Np0yaTZHV1dV7PBc919efT1e/fA9k0OQAAAAAAQLsoKSmxgIAAW7t2ra9LcSstLbVly5ZZcnKyhYSEmCRzOp2Wnp5ud911lwUFBTVpclx4BAYGmr+/v6WlpVlRUZE7ri+aHFu3bm00/tprr5kkmzZtWrPn79ixo9l4M2bMMEm2evXqRuNvvvmmSbJ58+Z5Nf8jjzxikuz1119vNt6MGTPcY3PnznUvkl/sww8/bNVC+V133WWSrLCw0D02evRok2QFBQVmZvbBBx80WdA/ceKERUVFNYl3pfNxIU/moKUYV6ItmhyefH4iIiJMkm3cuLHRuaWlpTQ50OWfT1e/fw9kO8x4kSQAAAAAAGgf06ZN065du1RcXKyAgABfl9NITU2N3n33Xe3atUvvv/++9u7dK5fLpfr6+steGxAQoLq6Ot12222aP3++UlNTlZOTo8mTJ3u97obXCJ0+fVrdu3d3j5eWliohIUGxsbEqKytrcv7Zs2d13XXXNYkXHx+vsrIylZWVKTY21j1+8uRJXX/99Ro4cKD27dvntfxxcXE6evSoSktLFRcX1yRefHy8e08Vp9Opw4cPq6SkRE6nszXT1UR0dLSOHz+uI0eOKCEhodEcVFRUqEePHqqurlZoaKgkufdkOX/+vMLCwnT+/PlG8a50Pi5covNkDlqKcSVaiuPJuCefn4ceekivvvqqJOnGG29UcnKykpOTNWHCBAUFBV3VvbRGbm6uJk2apLq6Ovn7+3s9HzzT1Z9PV79/D7zCnhwAAAAAAKDdPP/88zp06JDWr1/v61KaCA4O1j333KNnn31Wmzdv1sCBA1vV4JCkuro6+fn5ae/evZoxY4aXK23ehQvqknT99ddL+mZvkeY012CQvtlPQfpmof3C/Rga4h08eNCr+RvOb7j+4ngN9UnS0aNHJUkxMTHNxmqNiooKSd80OxqUl5dLksLCwlqstbS0VDfccEOLcT2djwt5MgcdjSefnzVr1ig3N1fp6ek6c+aMVq9erQceeEBJSUn66KOPfFI/gM6HJgcAAAAAAGg3ffv21Q9/+EMtXLiwyf+A72gaFtBbEhgYKIfDIT8/Pw0cOFBPPPGE/vznP7fYBPC2kydPNvp3w0L9pRbim9Ow2H/q1CmZWZOjpQ3X2yp/z549G11/cbyG319Y6+We1aX06NFDklRVVeUea1iQP3PmjCSpurq6yXU7duzQ3Xff3WLcq5kPT+ago/H085OWlqZNmzapvLxcO3fu1H333afDhw/rwQcf9EX5ADohmhwAAAAAAKBd/du//ZtKS0u1YsUKX5dySRcvMPv7+8vP75ullPj4eD344IPasGGDysvLtW/fPi1evFjf//731a1bN1+Uq6Kiokb/3r59uyQpOTnZozgTJkyQJOXn5zf5XUFBge644w6v5k9JSZEk5eXlNRuv4feSlJ6eLknasmVLkzi7d+/W8OHDL5svKSlJkvTpp5+6x2699VZJ0v79+yVJn3zySaNrKisrtWTJEj355JMtxr2a+fBkDqT//6ZJbW2tqqurm3wDpD158vlxOBzu1275+fnpe9/7njZs2CCp6ZwDQIvaexcQAAAAAACA5557ziIiIszlcvm6lBaFhoaaw+EwSXbDDTfY1KlT7be//a2VlpZe9lpfbDw+ZswYKygosKqqKsvLy7PY2FiLjIy0Q4cONXt+S06cOGFJSUkWGxtrGzdutPLycqusrLS33nrL+vTpY/n5+V7N73K5zOl0WlxcnOXl5VllZaU7ntPpbPSZqaiosAEDBlh4eLhlZ2eby+Wyqqoq27ZtmyUlJdn27dsvm3vBggUmyRYsWOAe27Jli0my1NRUO3bsmGVkZLivfffdd23kyJEtPt+2mA9P5sDM7Pbbb3dvnr5+/XobN25ci/N7KS09G0/GPfn8SLL77rvP9u/fbzU1NeZyueyZZ55xz723sbFzx9bVn09Xv38PZNPkAAAAAAAA7a6qqsri4uLs4Ycf9nUpLVq0aJH96le/sr/97W8eX+uLJsehQ4ds3LhxFh4ebqGhoTZmzBgrLi5u9twLj+acOnXK5s6da4mJiRYYGGjR0dGWkpJiu3btapf8LpfLZsyYYXFxcRYQEGBxcXGWkZHRbFOsqqrKnnvuOevXr58FBQVZVFSUJScn286dO1us9UJlZWUWEhJi8fHx9vXXX7vH58+fbxEREfbtb3/b8vPzLSwszPr3729z5syxzz77rNm6r3Y+rnQO3nvvPRs0aJBdd911dvvtt9unn37aYn2Xq/viWjwdN2v956ewsNCmTZtmvXv3tsDAQOvevbsNGjTIFi1aZGfPnvX4HjzFInLH1tWfT1e/fw9kO8zMru67IAAAAAAAAJ576623NH78eG3bts3jVxp1dP7+/srJydHkyZO9nsvhcEiSfLXE4+v8bSErK0vz5s3T7Nmzr/o1atfCfHQVubm5mjRpkurq6uTv7+/rcnCRrv58uvr9e+AV9uQAAAAAAAA+kZKSorS0NGVkZLg3eAZ84emnn9aUKVP00ksvKTMzU7W1tc2eV1tbq6ysrHauDgBwKTQ5AAAAAACAz6xYsUJnzpzRY4895utS0IU5HA7l5OTo+eef1/LlyzV48GCtXLlSBw8e1Llz51ReXq6NGzdq6NChKioqUl1dna9LBgD8H5ocAAAAAADAZ2JiYvTb3/5Wa9as0RtvvOHrcjqdhlcjXfxzV8nflhwOhxYuXKgDBw4oNTVVq1at0tChQxUREaEhQ4Zow4YNysrK0ttvv62AgIAWYzT3s684HI5WHQDQmTX/FxkAAAAAAKCdjB07Vj/96U/1r//6rxo2bJj69evn65I6DV/v++Dr/N6QmJiorKysK3otVUebj45WDwB4A9/kAAAAAAAAPvef//mfuuWWW5SSkqJTp075uhwAANBJ0OQAAAAAAAA+FxQUpM2bN+vcuXOaMGGCzp8/7+uSAABAJ0CTAwAAAAAAdAgxMTH6wx/+oL/+9a966KGHVF9f7+uSAABAB8eeHAAAAAAAoMMYNGiQtmzZonHjxikwMFBr1qxhY2QAANAimhwAAAAAAKBDuffee7Vx40alpaUpLCxMv/rVrzplo2PZsmV68803fV0GgBZ8+eWXvi4BQBvgdVUAAAAAAKDDGTdunNavX6/s7Gz9+Mc/Vm1tra9LAgAAHRDf5AAAAAAAAB1SWlqa3n77baWlpen06dNav369QkNDfV1Wq/3sZz/T5MmTfV0GgBbk5uZq0qRJvi4DwFXimxwAAAAAAKDDGjVqlPLy8rRnzx7dcccd+vzzz31dEgAA6EBocgAAAAAAgA7ttttu0/vvv6/AwEANGzZM77zzjq9LAgAAHQRNDgAAAAAA0OH16tVLhYWF+ud//meNGTNGjz/+uGpqanxdFgAA8DGaHAAAAAAAoFMICQnR66+/rtdee01r1qzRsGHD9OGHH/q6LAAA4EM0OQAAAAAAQKfy4x//WB9//LGioqJ022236dFHH9Xp06d9XRaA/+NwONwHAHgbTQ4AAAAAANDp9O7dWzt27NBvfvMb/f73v1f//v2VnZ2t2tpaX5eGa5zL5dKiRYt05513qmfPngoODpbT6VRKSorWrVunuro6X5foc2bm6xIAdCE0OQAAAAAAQKfkcDg0ffp0HThwQPfff78effRRfec731FOTo7q6+t9XR6uQS+++KL69u2rtWvX6v7771dBQYEqKiq0d+9ezZ49W5s2bdLw4cNVXFzs61K9jm9qAOgoaHIAAAAAAIBOLTIyUsuXL9dnn32me+65R9OnT1dSUpKWLVums2fPXnHcf/zjH9q1axcNE0iSZs2apczMTE2fPl0ff/yxHnvsMfXr108hISGKjo7W6NGjlZubq5///OcaM2aM/v73v/u6ZADoEmhyAAAAAACAa0KvXr20atUq/e1vf9OoUaP0zDPPqFevXnriiSe0f/9+j+Pl5eVpxIgR6t27t5YsWaKvvvrKC1WjM1i+fLlWrlypqVOnasWKFQoODm7x3NTUVC1dulQTJ07k9WkA0A5ocgAAAAAAgGvKTTfdpJUrV+rw4cOaO3euNm3apIEDB2ro0KFatmyZDh8+3Ko4x48fl5+fn44cOaInnnhCsbGxevTRR/XZZ595+Q7azoUbQBcXF2v06NGKiIhQWFiYxo4dq08++aTF8w8ePKi0tDRFRkY2eTXR8ePHNWvWLCUkJCgoKEjx8fHKyMiQy+Vql/wul0szZsxw509ISNDMmTN17NixJnNQU1OjxYsXa8iQIQoNDVVwcLD69++vmTNnavfu3Zedw5MnT+rZZ59VdHS0Xn75Zff4Cy+8oO7du6tv3776y1/+0qjGiRMn6qabbtIbb7zRKNZXX32lxx9/XH369FFwcLCioqI0YsQIZWZmau/evc3OQ1lZmdLT0xUeHq6oqChNmzZNX331lUpKSpSamqqIiAjFxMRo+vTpOn36dJP6PZmr1p574bNoqPMnP/lJs/N35MgRjR8/XuHh4YqOjtaPfvQjnTx58rLzDgCtZgAAAAAAANew+vp6y8/Pt+nTp1t4eLhJsiFDhtj8+fNt165dVltb2+x1S5YssaCgIJPkPoKCgszhcNg//dM/2R/+8Aerr69v9lo/Pz9bt26dN2+r1RpqHzFihBUWFlpVVZVt377dYmJiLDIy0g4dOtTs+aNGjbKioiKrrq62rVu3WsMyksvlMqfTadHR0fbOO+9YVVWV7dy505xOpyUmJlpFRYVX8x89etRuvPFGi4uLs7y8PKusrHTHczqd5nK53LEqKyvtu9/9roWHh9srr7xiLpfLqqqqbMeOHXbzzTdba5bGFi9ebJIsMzPTPbZlyxaTZOPHj7djx45ZRkaGu+4Gf/zjHy05OblRrPHjx5skW7p0qZ05c8bOnTtnBw4csIkTJzappSHej370IysuLrbTp0/b7NmzTZKNHTvWJk6c6B6fNWuWSbJHHnmkUQxP5sqTcy+sryUNv//hD3/ornPOnDkmyaZPn37ZeW8PmzZtMklWV1fn61LQjK7+fLr6/XsgmyYHAAAAAADoMmpqauxPf/qTzZo1yxISEkyShYaG2ve//31bsGCBbdu2zY4ePWpmZs8995x169atUZOj4QgICDBJ1rt3b/eC9YU6YpNj69atjcZfe+01k2TTpk1r9vwdO3Y0G2/GjBkmyVavXt1o/M033zRJNm/ePK/mf+SRR0ySvf76683GmzFjhnts7ty57qbCxT788MNWNTnuuusuk2SFhYXusdGjR5skKygoMDOzDz74oMmi/4kTJywqKqpRrIiICJNkGzdubDReWlraYpMjPz+/yXkXjx85csQkWXx8fKMYnsyVJ+deWF9Lmqvzyy+/NEkWFxfX4nXtiUXkjq2rP5+ufv8eyHaYmV3BF0AAAAAAAAA6vU8++UQFBQXu44svvpAk9ezZU9/61rd08ODBS+6r4HA45Ofnp+DgYD388MOaO3eunE6n/P39lZOTo8mTJ7fXrVyyRkk6ffq0unfv7h4vLS1VQkKCYmNjVVZW1uT8s2fP6rrrrmsSLz4+XmVlZSorK1NsbKx7/OTJk7r++us1cOBA7du3z2v54+LidPToUZWWliouLq5JvPj4eH355ZeSJKfTqcOHD6ukpEROp7M109VEdHS0jh8/riNHjighIaHRHFRUVKhHjx6qrq5WaGioJKlhqe38+fMKCwvT+fPn3bEeeughvfrqq5KkG2+8UcnJyUpOTtaECRMUFBTUKG/DPFRWVio8PFySVF9fL39//xbHHQ6H6uvrr2iuPDn3wvpaWlq8VP0X1+krubm5mjRpkurq6tzzio6jqz+frn7/HniFPTkAAAAAAECXdfPNNysjI0Ovv/66SkpKVF5eru3bt+upp55SSEiI6urqLnm9mekf//iHzp49qxUrVqhPnz6aPn16+xTvoQsbDJJ0/fXXS5JOnDjR7PnNNRikb/bjkL5ZFL9w74iGeAcPHvRq/obzG66/OF5DfZJ09OhRSVJMTEyzsVqjoqJC0jfNjgbl5eWSpLCwsBZrLS0t1Q033NBobM2aNcrNzVV6errOnDmj1atX64EHHlBSUpI++uijZvM3NAgkyc/P75LjFzccPJkrT871RGvqBICrQZMDAAAAAADg/0RFRenee+/V3Llz1b1791YtxjocDgUEBKi+vl4RERHq1q1bO1TquYs3e25YqL94If5yGhb7T506JTNrcpw9e9ar+Xv27Nno+ovjNfz+wlobmh1XokePHpKkqqoq91jDwv+ZM2ckSdXV1U2u27Fjh+6+++4m42lpadq0aZPKy8u1c+dO3XfffTp8+LAefPDBK66xJZ7MlSfnAkBHQpMDAAAAAACgGZf6n+sNjYygoCCNHDlSv/jFL/T+++/r5MmTWrVqVXuV6JGioqJG/96+fbskKTk52aM4EyZMkCTl5+c3+V1BQYHuuOMOr+ZPSUmRJOXl5TUbr+H3kpSeni5J2rJlS5M4u3fv1vDhwy+bLykpSZL06aefusduvfVWSdL+/fslffPaswtVVlZqyZIlevLJJxuNOxwO9yuf/Pz89L3vfU8bNmxoNkZb8GSuPDlX+v9vr9TW1qq6urrJN0AAoN34ZCsQAAAAAACADi4mJsa9eXJgYKA5HA5zOBw2YMAAe+qpp+zPf/6zff31181e2xE3Hh8zZowVFBRYVVWV5eXlWWxsrEVGRtqhQ4eaPb8lJ06csKSkJIuNjbWNGzdaeXm5VVZW2ltvvWV9+vRptNG0N/K7XC5zOp0WFxdneXl5VllZ6Y7ndDrN5XK5z62oqLABAwZYeHi4ZWdnm8vlsqqqKtu2bZslJSXZ9u3bL5t7wYIFJskWLFjgHtuyZYtJstTUVDt27JhlZGS4r3333Xdt5MiRzT5/SXbffffZ/v37raamxlwulz3zzDPuWK2ZB0/GPZkrT841M7v99tvdG7KvX7/exo0bd1X1+wIbO3dsXf35dPX790B2x/iLAgAAAAAA0MF0797dJFlMTIw9/PDDtm7dOjt+/Hirru2ITY5Dhw7ZuHHjLDw83EJDQ23MmDFWXFzc7LkXHs05deqUzZ071xITEy0wMNCio6MtJSXFdu3a1S75XS6XzZgxw+Li4iwgIMDi4uIsIyOjyUK8mVlVVZU999xz1q9fPwsKCrKoqChLTk62nTt3tljrhcrKyiwkJMTi4+MbNbXmz59vERER9u1vf9vy8/MtLCzM+vfvb3PmzLHPPvus2boLCwtt2rRp1rt3bwsMDLTu3bvboEGDbNGiRXb27NkW5+FKxz2dK0/Ofe+992zQoEF23XXX2e23326ffvrpVdXpCywid2xd/fl09fv3QLbDjJ1+AAAAAAAALrZnzx716NFD/fr18/haf39/5eTkaPLkyV6ozDMOh0OS7zZ79nX+tpCVlaV58+Zp9uzZWrFiha/LQRvJzc3VpEmTVFdXJ39/f1+Xg4t09efT1e/fA6+wJwcAAAAAAEAzhg8ffkUNDlx7nn76aU2ZMkUvvfSSMjMzVVtb2+x5tbW1ysrKaufqAKBro8kBAAAAAAAAXILD4VBOTo6ef/55LV++XIMHD9bKlSt18OBBnTt3TuXl5dq4caOGDh2qoqIi1dXV+bpkAOgyaHIAAAAAAABcoxpeFXXxz10lf1tyOBxauHChDhw4oNTUVK1atUpDhw5VRESEhgwZog0bNigrK0tvv/22AgICfF0uAHQZ/MUFAAAAAAC4Rvl6Hwxf5/eGxMREZWVl8VoqAOgg+CYHAAAAAAAAAADolGhyAAAAAAAAAACATokmBwAAAAAAAAAA6JRocgAAAAAAAAAAgE6JJgcAAAAAAAAAAOiUHGZmvi4CAAAAAADgWtKtWzedP3/e12UAADoxf39/nT9/Xn5+fFfhEl4J8HUFAAAAAAAA15q8vDwdPXrU12UAADqx6OhoGhytwDc5AAAAAAAAAABAZ/QKbSAAAAAAAAAAANAp0eQAAAAAAAAAAACdEk0OAAAAAAAAAADQKQVI2ujrIgAAAAAAAAAAADz0wf8Cvf4Q7VYAKY4AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize the detailed graph\n", + "preproc.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "Image(filename=opj(preproc.base_dir, 'preproc', 'graph_detailed.png'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the Workflow\n", + "\n", + "Now that everything is ready, we can run the preprocessing workflow. Change ``n_procs`` to the number of jobs/cores you want to use. **Note** that if you're using a Docker container and FLIRT fails to run without any good reason, you might need to change memory settings in the Docker preferences (6 GB should be enough for this workflow)." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200921-08:13:48,38 nipype.workflow INFO:\n", + "\t Workflow preproc settings: ['check', 'execution', 'logging', 'monitoring']\n", + "200921-08:13:48,141 nipype.workflow INFO:\n", + "\t Running in parallel.\n", + "200921-08:13:48,149 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:13:48,226 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_10_task_name_fingerfootlips/selectfiles\".200921-08:13:48,227 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_09_task_name_fingerfootlips/selectfiles\".\n", + "200921-08:13:48,228 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_08_task_name_fingerfootlips/selectfiles\".\n", + "\n", + "200921-08:13:48,236 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:13:48,238 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:13:48,239 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200921-08:13:48,241 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "\n", + "200921-08:13:48,243 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:13:48,246 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:13:48,229 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_07_task_name_fingerfootlips/selectfiles\".\n", + "200921-08:13:48,260 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:13:48,267 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:13:50,151 nipype.workflow INFO:\n", + "\t [Job 0] Completed (preproc.selectfiles).\n", + "200921-08:13:50,156 nipype.workflow INFO:\n", + "\t [Job 16] Completed (preproc.selectfiles).\n", + "200921-08:13:50,159 nipype.workflow INFO:\n", + "\t [Job 32] Completed (preproc.selectfiles).\n", + "200921-08:13:50,161 nipype.workflow INFO:\n", + "\t [Job 48] Completed (preproc.selectfiles).\n", + "200921-08:13:50,165 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 14 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:13:50,235 nipype.workflow INFO:\n", + "\t [Job 1] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:13:50,239 nipype.workflow INFO:\n", + "\t [Job 4] Cached (preproc.extract).\n", + "200921-08:13:50,242 nipype.workflow INFO:\n", + "\t [Job 17] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:13:50,245 nipype.workflow INFO:\n", + "\t [Job 20] Cached (preproc.extract).\n", + "200921-08:13:52,226 nipype.workflow INFO:\n", + "\t [Job 2] Cached (preproc.coregwf.segmentation).\n", + "200921-08:13:52,230 nipype.workflow INFO:\n", + "\t [Job 5] Cached (preproc.mcflirt).\n", + "200921-08:13:52,234 nipype.workflow INFO:\n", + "\t [Job 18] Cached (preproc.coregwf.segmentation).\n", + "200921-08:13:52,237 nipype.workflow INFO:\n", + "\t [Job 21] Cached (preproc.mcflirt).\n", + "200921-08:13:54,157 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 16 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:13:54,232 nipype.workflow INFO:\n", + "\t [Job 3] Cached (preproc.coregwf.threshold).\n", + "200921-08:13:54,237 nipype.workflow INFO:\n", + "\t [Job 6] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:13:54,240 nipype.workflow INFO:\n", + "\t [Job 9] Cached (preproc.slicetimer).\n", + "200921-08:13:54,244 nipype.workflow INFO:\n", + "\t [Job 19] Cached (preproc.coregwf.threshold).\n", + "200921-08:13:56,158 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 13 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:13:56,223 nipype.workflow INFO:\n", + "\t [Job 7] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:13:56,227 nipype.workflow INFO:\n", + "\t [Job 22] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:13:56,230 nipype.workflow INFO:\n", + "\t [Job 25] Cached (preproc.slicetimer).\n", + "200921-08:13:56,232 nipype.workflow INFO:\n", + "\t [Job 33] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:13:58,232 nipype.workflow INFO:\n", + "\t [Job 8] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:13:58,236 nipype.workflow INFO:\n", + "\t [Job 10] Cached (preproc.coregwf.applywarp).\n", + "200921-08:13:58,241 nipype.workflow INFO:\n", + "\t [Job 23] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:13:58,245 nipype.workflow INFO:\n", + "\t [Job 34] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:00,163 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 15 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:00,235 nipype.workflow INFO:\n", + "\t [Job 11] Cached (preproc.smooth).\n", + "200921-08:14:00,239 nipype.workflow INFO:\n", + "\t [Job 12] Cached (preproc.smooth).\n", + "200921-08:14:00,244 nipype.workflow INFO:\n", + "\t [Job 13] Cached (preproc.art).\n", + "200921-08:14:00,248 nipype.workflow INFO:\n", + "\t [Job 24] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:02,165 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 13 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:02,245 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:02,253 nipype.workflow INFO:\n", + "\t [Job 26] Cached (preproc.coregwf.applywarp).\n", + "200921-08:14:02,253 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_5/datasink\".\n", + "200921-08:14:02,257 nipype.workflow INFO:\n", + "\t [Job 35] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:02,256 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:14:02,259 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:02,261 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-10/task-fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:02,261 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "\n", + "200921-08:14:02,262 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-10/task-fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold.svg\n", + "200921-08:14:02,263 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:02,264 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_t1w_preproc_brain.nii.gz\n", + "200921-08:14:02,265 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-10/task-fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:02,266 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:02,268 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-10/task-fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold.svg200921-08:14:02,268 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:14:02,270 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_10/ssub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-10/task-fingerfootlips/fwhm-10_ssub-10_ses-test_task-fingerfootlips_bold.nii200921-08:14:02,270 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_t1w_preproc_brain.nii.gz\n", + "\n", + "200921-08:14:02,274 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".200921-08:14:02,275 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:02,277 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:02,280 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_5/ssub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-10/task-fingerfootlips/fwhm-5_ssub-10_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:02,284 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:04,165 nipype.workflow INFO:\n", + "\t [Job 14] Completed (preproc.datasink).\n", + "200921-08:14:04,169 nipype.workflow INFO:\n", + "\t [Job 15] Completed (preproc.datasink).\n", + "200921-08:14:04,175 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 12 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:04,244 nipype.workflow INFO:\n", + "\t [Job 27] Cached (preproc.smooth).\n", + "200921-08:14:04,248 nipype.workflow INFO:\n", + "\t [Job 28] Cached (preproc.smooth).\n", + "200921-08:14:04,252 nipype.workflow INFO:\n", + "\t [Job 29] Cached (preproc.art).\n", + "200921-08:14:04,255 nipype.workflow INFO:\n", + "\t [Job 36] Cached (preproc.extract).\n", + "200921-08:14:06,170 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 11 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:06,250 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:06,258 nipype.workflow INFO:\n", + "\t [Job 37] Cached (preproc.mcflirt).\n", + "200921-08:14:06,259 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:14:06,260 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:06,261 nipype.workflow INFO:\n", + "\t [Job 49] Cached (preproc.coregwf.bet_anat).\n", + "\n", + "\n", + "200921-08:14:06,262 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:06,264 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-09/task-fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:06,265 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-09/task-fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold.svg\n", + "200921-08:14:06,267 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_t1w_preproc_brain.nii.gz\n", + "200921-08:14:06,268 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:06,270 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:06,270 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:14:06,272 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_10/ssub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-09/task-fingerfootlips/fwhm-10_ssub-09_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:06,273 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:06,275 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:06,276 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-09/task-fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:06,279 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-09/task-fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold.svg\n", + "200921-08:14:06,281 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_t1w_preproc_brain.nii.gz\n", + "200921-08:14:06,283 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:06,284 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:06,286 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_5/ssub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-09/task-fingerfootlips/fwhm-5_ssub-09_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:06,290 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:08,168 nipype.workflow INFO:\n", + "\t [Job 30] Completed (preproc.datasink).\n", + "200921-08:14:08,171 nipype.workflow INFO:\n", + "\t [Job 31] Completed (preproc.datasink).\n", + "200921-08:14:08,177 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:08,247 nipype.workflow INFO:\n", + "\t [Job 38] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:08,251 nipype.workflow INFO:\n", + "\t [Job 41] Cached (preproc.slicetimer).\n", + "200921-08:14:08,254 nipype.workflow INFO:\n", + "\t [Job 50] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:08,257 nipype.workflow INFO:\n", + "\t [Job 52] Cached (preproc.extract).\n", + "200921-08:14:10,172 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:10,244 nipype.workflow INFO:\n", + "\t [Job 39] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:14:10,248 nipype.workflow INFO:\n", + "\t [Job 51] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:10,251 nipype.workflow INFO:\n", + "\t [Job 53] Cached (preproc.mcflirt).\n", + "200921-08:14:10,255 nipype.workflow INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_06_task_name_fingerfootlips/selectfiles\".\n", + "200921-08:14:10,259 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:14:10,264 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:14:12,172 nipype.workflow INFO:\n", + "\t [Job 64] Completed (preproc.selectfiles).\n", + "200921-08:14:12,178 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 11 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:12,255 nipype.workflow INFO:\n", + "\t [Job 40] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:12,259 nipype.workflow INFO:\n", + "\t [Job 42] Cached (preproc.coregwf.applywarp).\n", + "200921-08:14:12,263 nipype.workflow INFO:\n", + "\t [Job 54] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:12,266 nipype.workflow INFO:\n", + "\t [Job 57] Cached (preproc.slicetimer).\n", + "200921-08:14:14,245 nipype.workflow INFO:\n", + "\t [Job 43] Cached (preproc.smooth).\n", + "200921-08:14:14,249 nipype.workflow INFO:\n", + "\t [Job 44] Cached (preproc.smooth).\n", + "200921-08:14:14,252 nipype.workflow INFO:\n", + "\t [Job 45] Cached (preproc.art).\n", + "200921-08:14:14,257 nipype.workflow INFO:\n", + "\t [Job 55] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:14:16,246 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:16,253 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:14:16,254 nipype.workflow INFO:\n", + "\t [Job 56] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:16,254 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "\n", + "200921-08:14:16,258 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:16,260 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:16,261 nipype.workflow INFO:\n", + "\t [Job 58] Cached (preproc.coregwf.applywarp).\n", + "\n", + "200921-08:14:16,261 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-08/task-fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:16,264 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-08/task-fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold.svg200921-08:14:16,264 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold.par\n", + "\n", + "200921-08:14:16,266 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_t1w_preproc_brain.nii.gz200921-08:14:16,266 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-08/task-fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "\n", + "200921-08:14:16,268 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:16,268 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-08/task-fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold.svg200921-08:14:16,270 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:14:16,271 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_t1w_preproc_brain.nii.gz\n", + "200921-08:14:16,272 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_10/ssub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-08/task-fingerfootlips/fwhm-10_ssub-08_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:16,274 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:16,275 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:16,277 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".200921-08:14:16,277 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_5/ssub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-08/task-fingerfootlips/fwhm-5_ssub-08_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:14:16,282 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:18,178 nipype.workflow INFO:\n", + "\t [Job 46] Completed (preproc.datasink).\n", + "200921-08:14:18,181 nipype.workflow INFO:\n", + "\t [Job 47] Completed (preproc.datasink).\n", + "200921-08:14:18,188 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:18,258 nipype.workflow INFO:\n", + "\t [Job 59] Cached (preproc.smooth).\n", + "200921-08:14:18,262 nipype.workflow INFO:\n", + "\t [Job 60] Cached (preproc.smooth).\n", + "200921-08:14:18,266 nipype.workflow INFO:\n", + "\t [Job 61] Cached (preproc.art).\n", + "200921-08:14:18,270 nipype.workflow INFO:\n", + "\t [Job 65] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:14:20,182 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:20,260 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:20,268 nipype.workflow INFO:\n", + "\t [Job 66] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:20,269 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:14:20,272 nipype.workflow INFO:\n", + "\t [Job 68] Cached (preproc.extract).\n", + "\n", + "200921-08:14:20,273 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:14:20,276 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:20,278 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-07/task-fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:20,280 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:20,281 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-07/task-fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:14:20,283 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:20,283 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_t1w_preproc_brain.nii.gz200921-08:14:20,284 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-07/task-fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "\n", + "200921-08:14:20,286 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-07/task-fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold.svg200921-08:14:20,286 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:20,288 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_t1w_preproc_brain.nii.gz\n", + "200921-08:14:20,290 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:20,291 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:20,289 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:14:20,293 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_10/ssub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-07/task-fingerfootlips/fwhm-10_ssub-07_ses-test_task-fingerfootlips_bold.nii200921-08:14:20,294 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_5/ssub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-07/task-fingerfootlips/fwhm-5_ssub-07_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:14:20,298 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".200921-08:14:20,298 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "\n", + "200921-08:14:22,182 nipype.workflow INFO:\n", + "\t [Job 62] Completed (preproc.datasink).\n", + "200921-08:14:22,185 nipype.workflow INFO:\n", + "\t [Job 63] Completed (preproc.datasink).\n", + "200921-08:14:22,190 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:22,260 nipype.workflow INFO:\n", + "\t [Job 67] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:22,264 nipype.workflow INFO:\n", + "\t [Job 69] Cached (preproc.mcflirt).\n", + "200921-08:14:22,268 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_05_task_name_fingerfootlips/selectfiles\".200921-08:14:22,270 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_04_task_name_fingerfootlips/selectfiles\".\n", + "\n", + "200921-08:14:22,275 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200921-08:14:22,277 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "\n", + "200921-08:14:22,282 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:14:22,284 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:14:24,184 nipype.workflow INFO:\n", + "\t [Job 80] Completed (preproc.selectfiles).\n", + "200921-08:14:24,187 nipype.workflow INFO:\n", + "\t [Job 96] Completed (preproc.selectfiles).\n", + "200921-08:14:24,192 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:24,262 nipype.workflow INFO:\n", + "\t [Job 70] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:24,265 nipype.workflow INFO:\n", + "\t [Job 73] Cached (preproc.slicetimer).\n", + "200921-08:14:24,268 nipype.workflow INFO:\n", + "\t [Job 81] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:14:24,271 nipype.workflow INFO:\n", + "\t [Job 84] Cached (preproc.extract).\n", + "200921-08:14:26,186 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 8 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:26,256 nipype.workflow INFO:\n", + "\t [Job 71] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:14:26,260 nipype.workflow INFO:\n", + "\t [Job 82] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:26,262 nipype.workflow INFO:\n", + "\t [Job 85] Cached (preproc.mcflirt).\n", + "200921-08:14:26,264 nipype.workflow INFO:\n", + "\t [Job 97] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:14:28,190 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:28,265 nipype.workflow INFO:\n", + "\t [Job 72] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:28,269 nipype.workflow INFO:\n", + "\t [Job 74] Cached (preproc.coregwf.applywarp).\n", + "200921-08:14:28,273 nipype.workflow INFO:\n", + "\t [Job 83] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:28,276 nipype.workflow INFO:\n", + "\t [Job 86] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:30,262 nipype.workflow INFO:\n", + "\t [Job 75] Cached (preproc.smooth).\n", + "200921-08:14:30,265 nipype.workflow INFO:\n", + "\t [Job 76] Cached (preproc.smooth).\n", + "200921-08:14:30,269 nipype.workflow INFO:\n", + "\t [Job 77] Cached (preproc.art).\n", + "200921-08:14:30,274 nipype.workflow INFO:\n", + "\t [Job 87] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:14:32,194 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:32,273 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:32,281 nipype.workflow INFO:\n", + "\t [Job 88] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:32,281 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_5/datasink\".\n", + "200921-08:14:32,284 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:14:32,288 nipype.workflow INFO:\n", + "\t [Job 89] Cached (preproc.slicetimer).\n", + "200921-08:14:32,288 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:32,289 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-06/task-fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:32,290 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:32,291 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-06/task-fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:14:32,293 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_t1w_preproc_brain.nii.gz\n", + "200921-08:14:32,293 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold.par200921-08:14:32,294 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:32,296 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:32,296 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-06/task-fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "\n", + "200921-08:14:32,298 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_10/ssub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-06/task-fingerfootlips/fwhm-10_ssub-06_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:32,299 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-06/task-fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold.svg\n", + "200921-08:14:32,301 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_t1w_preproc_brain.nii.gz\n", + "200921-08:14:32,304 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:32,305 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".200921-08:14:32,306 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:14:32,308 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_5/ssub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-06/task-fingerfootlips/fwhm-5_ssub-06_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:32,312 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:34,194 nipype.workflow INFO:\n", + "\t [Job 78] Completed (preproc.datasink).\n", + "200921-08:14:34,197 nipype.workflow INFO:\n", + "\t [Job 79] Completed (preproc.datasink).\n", + "200921-08:14:34,202 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:34,274 nipype.workflow INFO:\n", + "\t [Job 90] Cached (preproc.coregwf.applywarp).\n", + "200921-08:14:34,277 nipype.workflow INFO:\n", + "\t [Job 98] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:34,280 nipype.workflow INFO:\n", + "\t [Job 100] Cached (preproc.extract).\n", + "200921-08:14:34,285 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_03_task_name_fingerfootlips/selectfiles\".\n", + "200921-08:14:34,291 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:14:34,299 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:14:36,194 nipype.workflow INFO:\n", + "\t [Job 112] Completed (preproc.selectfiles).\n", + "200921-08:14:36,197 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:36,261 nipype.workflow INFO:\n", + "\t [Job 91] Cached (preproc.smooth).\n", + "200921-08:14:36,264 nipype.workflow INFO:\n", + "\t [Job 92] Cached (preproc.smooth).\n", + "200921-08:14:36,271 nipype.workflow INFO:\n", + "\t [Job 93] Cached (preproc.art).\n", + "200921-08:14:36,274 nipype.workflow INFO:\n", + "\t [Job 99] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:38,200 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:38,281 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:38,288 nipype.workflow INFO:\n", + "\t [Job 101] Cached (preproc.mcflirt).\n", + "200921-08:14:38,288 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_5/datasink\".\n", + "200921-08:14:38,289 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:38,292 nipype.workflow INFO:\n", + "\t [Job 113] Cached (preproc.coregwf.bet_anat).\n", + "\n", + "200921-08:14:38,292 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:38,295 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-05/task-fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:38,295 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "\n", + "200921-08:14:38,297 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-05/task-fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold.svg\n", + "200921-08:14:38,300 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold.par200921-08:14:38,300 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_t1w_preproc_brain.nii.gz\n", + "\n", + "200921-08:14:38,302 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.mat200921-08:14:38,303 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-05/task-fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "\n", + "200921-08:14:38,305 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:38,306 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-05/task-fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:14:38,307 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_10/ssub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-05/task-fingerfootlips/fwhm-10_ssub-05_ses-test_task-fingerfootlips_bold.nii200921-08:14:38,308 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_t1w_preproc_brain.nii.gz\n", + "\n", + "200921-08:14:38,310 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:38,312 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:38,314 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_5/ssub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-05/task-fingerfootlips/fwhm-5_ssub-05_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:14:38,315 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:38,318 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:40,200 nipype.workflow INFO:\n", + "\t [Job 94] Completed (preproc.datasink).\n", + "200921-08:14:40,203 nipype.workflow INFO:\n", + "\t [Job 95] Completed (preproc.datasink).\n", + "200921-08:14:40,208 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:40,278 nipype.workflow INFO:\n", + "\t [Job 102] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:40,281 nipype.workflow INFO:\n", + "\t [Job 105] Cached (preproc.slicetimer).\n", + "200921-08:14:40,284 nipype.workflow INFO:\n", + "\t [Job 114] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:40,287 nipype.workflow INFO:\n", + "\t [Job 116] Cached (preproc.extract).\n", + "200921-08:14:42,203 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:42,274 nipype.workflow INFO:\n", + "\t [Job 103] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:14:42,278 nipype.workflow INFO:\n", + "\t [Job 115] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:42,281 nipype.workflow INFO:\n", + "\t [Job 117] Cached (preproc.mcflirt).\n", + "200921-08:14:42,284 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_02_task_name_fingerfootlips/selectfiles\".\n", + "200921-08:14:42,291 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:14:42,299 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:14:44,201 nipype.workflow INFO:\n", + "\t [Job 128] Completed (preproc.selectfiles).\n", + "200921-08:14:44,207 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:44,283 nipype.workflow INFO:\n", + "\t [Job 104] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:44,291 nipype.workflow INFO:\n", + "\t [Job 106] Cached (preproc.coregwf.applywarp).\n", + "200921-08:14:44,294 nipype.workflow INFO:\n", + "\t [Job 118] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:44,297 nipype.workflow INFO:\n", + "\t [Job 121] Cached (preproc.slicetimer).\n", + "200921-08:14:46,267 nipype.workflow INFO:\n", + "\t [Job 107] Cached (preproc.smooth).\n", + "200921-08:14:46,269 nipype.workflow INFO:\n", + "\t [Job 108] Cached (preproc.smooth).\n", + "200921-08:14:46,273 nipype.workflow INFO:\n", + "\t [Job 109] Cached (preproc.art).\n", + "200921-08:14:46,277 nipype.workflow INFO:\n", + "\t [Job 119] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:14:48,283 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:48,291 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_5/datasink\".\n", + "200921-08:14:48,294 nipype.workflow INFO:\n", + "\t [Job 120] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:14:48,294 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:14:48,297 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:14:48,299 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:48,300 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-04/task-fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:48,302 nipype.workflow INFO:\n", + "\t [Job 122] Cached (preproc.coregwf.applywarp).\n", + "200921-08:14:48,301 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:14:48,302 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-04/task-fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:14:48,303 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-04/task-fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:48,306 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_t1w_preproc_brain.nii.gz200921-08:14:48,307 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-04/task-fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold.svg\n", + "200921-08:14:48,309 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:48,310 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_t1w_preproc_brain.nii.gz\n", + "200921-08:14:48,311 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:48,312 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:48,315 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:48,315 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_10/ssub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-04/task-fingerfootlips/fwhm-10_ssub-04_ses-test_task-fingerfootlips_bold.nii200921-08:14:48,317 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_5/ssub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-04/task-fingerfootlips/fwhm-5_ssub-04_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:14:48,321 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:48,323 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:50,207 nipype.workflow INFO:\n", + "\t [Job 110] Completed (preproc.datasink).\n", + "200921-08:14:50,211 nipype.workflow INFO:\n", + "\t [Job 111] Completed (preproc.datasink).\n", + "200921-08:14:50,215 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:50,285 nipype.workflow INFO:\n", + "\t [Job 123] Cached (preproc.smooth).\n", + "200921-08:14:50,288 nipype.workflow INFO:\n", + "\t [Job 124] Cached (preproc.smooth).\n", + "200921-08:14:50,292 nipype.workflow INFO:\n", + "\t [Job 125] Cached (preproc.art).\n", + "200921-08:14:50,295 nipype.workflow INFO:\n", + "\t [Job 129] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:14:52,212 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:52,289 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:14:52,296 nipype.workflow INFO:\n", + "\t [Job 130] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:52,297 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_5/datasink\".\n", + "200921-08:14:52,299 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:14:52,302 nipype.workflow INFO:\n", + "\t [Job 132] Cached (preproc.extract).\n", + "200921-08:14:52,308 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:52,302 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold.par\n", + "\n", + "200921-08:14:52,310 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-03/task-fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:14:52,312 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-03/task-fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold.svg200921-08:14:52,312 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold.par\n", + "\n", + "200921-08:14:52,314 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-03/task-fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:52,314 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_t1w_preproc_brain.nii.gz\n", + "\n", + "200921-08:14:52,316 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-03/task-fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold.svg200921-08:14:52,317 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:14:52,319 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_t1w_preproc_brain.nii.gz200921-08:14:52,319 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:52,321 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_10/ssub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-03/task-fingerfootlips/fwhm-10_ssub-03_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:14:52,323 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:14:52,324 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:14:52,326 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".200921-08:14:52,326 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_5/ssub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-03/task-fingerfootlips/fwhm-5_ssub-03_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:14:52,331 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:14:54,212 nipype.workflow INFO:\n", + "\t [Job 126] Completed (preproc.datasink).\n", + "200921-08:14:54,215 nipype.workflow INFO:\n", + "\t [Job 127] Completed (preproc.datasink).\n", + "200921-08:14:54,220 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:54,297 nipype.workflow INFO:\n", + "\t [Job 131] Cached (preproc.coregwf.threshold).\n", + "200921-08:14:54,302 nipype.workflow INFO:\n", + "\t [Job 133] Cached (preproc.mcflirt).\n", + "200921-08:14:54,307 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_01_task_name_fingerfootlips/selectfiles\".\n", + "200921-08:14:54,312 nipype.workflow INFO:\n", + "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", + "200921-08:14:54,316 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.selectfiles\".\n", + "200921-08:14:56,213 nipype.workflow INFO:\n", + "\t [Job 144] Completed (preproc.selectfiles).\n", + "200921-08:14:56,218 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 4 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:56,287 nipype.workflow INFO:\n", + "\t [Job 134] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:14:56,291 nipype.workflow INFO:\n", + "\t [Job 137] Cached (preproc.slicetimer).\n", + "200921-08:14:56,294 nipype.workflow INFO:\n", + "\t [Job 145] Cached (preproc.coregwf.bet_anat).\n", + "200921-08:14:56,299 nipype.workflow INFO:\n", + "\t [Job 148] Cached (preproc.extract).\n", + "200921-08:14:58,215 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:14:58,285 nipype.workflow INFO:\n", + "\t [Job 135] Cached (preproc.coregwf.coreg_bbr).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "200921-08:14:58,289 nipype.workflow INFO:\n", + "\t [Job 146] Cached (preproc.coregwf.segmentation).\n", + "200921-08:14:58,292 nipype.workflow INFO:\n", + "\t [Job 149] Cached (preproc.mcflirt).\n", + "200921-08:15:00,219 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:15:00,297 nipype.workflow INFO:\n", + "\t [Job 136] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:15:00,301 nipype.workflow INFO:\n", + "\t [Job 138] Cached (preproc.coregwf.applywarp).\n", + "200921-08:15:00,304 nipype.workflow INFO:\n", + "\t [Job 147] Cached (preproc.coregwf.threshold).\n", + "200921-08:15:00,308 nipype.workflow INFO:\n", + "\t [Job 150] Cached (preproc.coregwf.coreg_pre).\n", + "200921-08:15:02,287 nipype.workflow INFO:\n", + "\t [Job 139] Cached (preproc.smooth).\n", + "200921-08:15:02,292 nipype.workflow INFO:\n", + "\t [Job 140] Cached (preproc.smooth).\n", + "200921-08:15:02,300 nipype.workflow INFO:\n", + "\t [Job 141] Cached (preproc.art).\n", + "200921-08:15:02,307 nipype.workflow INFO:\n", + "\t [Job 151] Cached (preproc.coregwf.coreg_bbr).\n", + "200921-08:15:04,222 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 4 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:15:04,303 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:15:04,310 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_5/datasink\".\n", + "200921-08:15:04,313 nipype.workflow INFO:\n", + "\t [Job 152] Cached (preproc.coregwf.applywarp_mean).\n", + "200921-08:15:04,315 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:15:04,316 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "200921-08:15:04,318 nipype.workflow INFO:\n", + "\t [Job 153] Cached (preproc.slicetimer).\n", + "\n", + "200921-08:15:04,319 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold.par200921-08:15:04,319 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold.par\n", + "\n", + "200921-08:15:04,321 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-02/task-fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:15:04,322 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-02/task-fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:15:04,323 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-02/task-fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:15:04,325 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_t1w_preproc_brain.nii.gz200921-08:15:04,325 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-02/task-fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:15:04,327 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.mat200921-08:15:04,327 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_t1w_preproc_brain.nii.gz\n", + "200921-08:15:04,329 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:15:04,331 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.mat200921-08:15:04,332 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_5/ssub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-02/task-fingerfootlips/fwhm-5_ssub-02_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:15:04,334 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:15:04,336 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_10/ssub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-02/task-fingerfootlips/fwhm-10_ssub-02_ses-test_task-fingerfootlips_bold.nii\n", + "200921-08:15:04,338 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:15:04,341 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:15:06,220 nipype.workflow INFO:\n", + "\t [Job 142] Completed (preproc.datasink).\n", + "200921-08:15:06,222 nipype.workflow INFO:\n", + "\t [Job 143] Completed (preproc.datasink).\n", + "200921-08:15:06,226 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:15:06,290 nipype.workflow INFO:\n", + "\t [Job 154] Cached (preproc.coregwf.applywarp).\n", + "200921-08:15:08,226 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:15:08,297 nipype.workflow INFO:\n", + "\t [Job 155] Cached (preproc.smooth).\n", + "200921-08:15:08,300 nipype.workflow INFO:\n", + "\t [Job 156] Cached (preproc.smooth).\n", + "200921-08:15:08,304 nipype.workflow INFO:\n", + "\t [Job 157] Cached (preproc.art).\n", + "200921-08:15:10,224 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 2 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", + "200921-08:15:10,298 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_10/datasink\".\n", + "200921-08:15:10,309 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:15:10,309 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "\n", + "200921-08:15:10,312 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold.par\n", + "200921-08:15:10,316 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-01/task-fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:15:10,317 nipype.workflow INFO:\n", + "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", + "\n", + "200921-08:15:10,319 nipype.interface INFO:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-01/task-fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold.svg200921-08:15:10,320 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold.par\n", + "\n", + "200921-08:15:10,322 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-01/task-fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt\n", + "200921-08:15:10,323 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_t1w_preproc_brain.nii.gz200921-08:15:10,323 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-01/task-fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold.svg\n", + "\n", + "200921-08:15:10,325 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.mat\n", + "200921-08:15:10,326 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_t1w_preproc_brain.nii.gz200921-08:15:10,327 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "\n", + "200921-08:15:10,328 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_10/ssub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-01/task-fingerfootlips/fwhm-10_ssub-01_ses-test_task-fingerfootlips_bold.nii200921-08:15:10,329 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.mat\n", + "\n", + "200921-08:15:10,331 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", + "200921-08:15:10,333 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".200921-08:15:10,333 nipype.interface INFO:\n", + "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_5/ssub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-01/task-fingerfootlips/fwhm-5_ssub-01_ses-test_task-fingerfootlips_bold.nii\n", + "\n", + "200921-08:15:10,337 nipype.workflow INFO:\n", + "\t [Node] Finished \"preproc.datasink\".\n", + "200921-08:15:12,225 nipype.workflow INFO:\n", + "\t [Job 158] Completed (preproc.datasink).\n", + "200921-08:15:12,229 nipype.workflow INFO:\n", + "\t [Job 159] Completed (preproc.datasink).\n", + "200921-08:15:12,234 nipype.workflow INFO:\n", + "\t [MultiProc] Running 0 tasks, and 0 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "preproc.run('MultiProc', plugin_args={'n_procs': 4})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inspect output\n", + "\n", + "Let's check the structure of the output folder, to see if we have everything we wanted to save." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/output/datasink/preproc/sub-01/task-fingerfootlips\r\n", + "├── art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt\r\n", + "├── fwhm-10_ssub-01_ses-test_task-fingerfootlips_bold.nii\r\n", + "├── fwhm-5_ssub-01_ses-test_task-fingerfootlips_bold.nii\r\n", + "├── plot.sub-01_ses-test_task-fingerfootlips_bold.svg\r\n", + "├── sub-01_ses-test_task-fingerfootlips_bold_mean.mat\r\n", + "├── sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz\r\n", + "├── sub-01_ses-test_task-fingerfootlips_bold.par\r\n", + "└── sub-01_t1w_preproc_brain.nii.gz\r\n", + "\r\n", + "0 directories, 8 files\r\n" + ] + } + ], + "source": [ + "!tree /output/datasink/preproc/sub-01/task-fingerfootlips" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize results\n", + "\n", + "Let's check the effect of the different smoothing kernels." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn import image, plotting\n", + "out_path = '/output/datasink/preproc/sub-01/task-fingerfootlips'" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAADJCAYAAAAHFcoVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2de6xU5fn910FBRRQFURFRBG+gIiLVIveaSqs1aaReG6MmNk2T/tE0NU3amib1j/bfNtX6l9jU+I2tTVONaI0V5aCIWm+AV/CCIngHLfVCy/794W/tWXPOOjNzbpw9h/VJThje2fvd7977mf3Os+Z5nrcDQIEQQgghVI4RQz2AEEIIIXgySYcQQggVJZN0CCGEUFH2bfTm1q1bceSRR+6psYQBZtu2bZg4ceJQDyOEEEIf6UCDwLGiSExZu9PR0THUQwghhNBHIneHEEIIFSWTdAghhFBRMkmHEEIIFaXPk/SvfvUrTJo0CSNGjMDVV1/d6/0feughdHR0YP369X0dwpDy97//Haeddhr2339/zJgxA3fcccdQDymEEMIwo0+T9JNPPolf/vKX+OEPf4hHHnkE119//UCPq9KsXr0ay5Ytw5IlS3DvvffiggsuwOWXX477779/qIcWQghhGNGn6O7bbrsNV155JXbs2IGDDz64Twd+6KGHsGTJEqxbtw6nnnpqn/oYKpYuXYpdu3bhwQcfLNvOP/98fPzxx1i9evUQjqw7ie4OIYT2pdee9NVXX40rr7wSADB27Fh0dHTglltuQUdHBx599NFyu8svvxwdHR147rnnyrYLL7wQ3/3ud+v6e//993HxxRdjzJgxmDp1Km666aZux5szZw7uuecezJgxA6NHj8YFF1yADz/8EBs3bsSSJUtw4IEHYs6cOXXHGiw+//xzrFy5Epdcckld+2WXXYY1a9Zgx44dAIBbb70VHR0deOqpp7B48WKMHj0as2bNwlNPPYWdO3fimmuuwdixYzF16lT83//9X11fixcvxne+8x0sX74cxx13HMaMGYMrr7wSn3/+OR5//HGcddZZGDNmDBYvXozNmzcP+jmHEEIYOoqe/hwbN24sfvGLXxQAigcffLBYs2ZNsWPHjmLSpEnFb37zm3K7SZMmFfvvv3/x+9//viiKoti9e3dx6KGHFn/4wx+KoiiKlStXFgCK448/vrjhhhuK+++/v7jmmmsKAMXatWvLfq666qpiwoQJxezZs4u//vWvxZ/+9KfikEMOKZYtW1aceeaZxc0331ysWLGiOP3004vp06cXu3fvtuMmu3btavrXqI8NGzYUAIqVK1fWtT/++OMFgOLxxx8viqIoli9fXgAoTj311HKMM2fOLI477rji0ksvLX72s58V999/f3HZZZcV++67b/Hmm2+WfS1atKiYNGlSsWjRouLuu+8ubrzxxmLUqFHF9773vWLmzJnFbbfdVvztb38rJk+eXCxdurTh+Ta6v/nLX/7yl7/K//X8Zk9wAvrkk0/Ktssuu6y44IILiqIoik2bNhUjRowofvCDHxSXXnppURRF8eyzzxYAivXr1xdFUZukr7/++rKPL774ojjssMOKn/70p2XbVVddVeyzzz7Fxo0by7brrruuAFD88Y9/LNvuueeeAkDx/PPP93vSWr58eY/7r169ugBQPP3003Xtr7zySgGg+Mc//lF3jW699dZuY7zmmmvKtu3btxf77rtvcdNNN5VtixYtKsaOHVts3769bLv44osLAMXDDz9ctt14440FgGLnzp39Ot/85S9/+ctfNf8algXtDQsWLMDPf/5z7N69G6tWrcLMmTNx4YUX4tprrwUArFq1CuPGjcOMGTPq9jvvvPPK1yNHjsQJJ5yAt956q26bKVOmYNq0aeX/jz/+eADA1772tW5tW7ZswfTp03sc5xNPPNH0XI477rim23T9rbf4/7/fd20/99xzu41Rxz127FhMmDABW7Zsqdtvzpw5GDt2bN2+o0aNwvz587v19/bbb5evQwghDB8GbJJeuHAhtm/fjvXr16OzsxMLFizAvHnzsG3bNrz66qvo7OzE/Pnzu01ihxxySN3/R40ahc8++6zpNl3b2dZ1367MmjWr6bnss88+Pb536KGHAgC2b99e187/dx2rG2Nfz/mggw7CiBEj6tqA5uccQgihPRmwSfqUU07BuHHj0NnZiVWrVuHXv/41Dj74YMycOROdnZ3o7OzEj3/844E6XJ8ZOXJk022WL1/eY+73tGnTMHLkSLz44otYtGhR2f7iiy9ixIgROPHEEwdqqAPCAQccMNRDCGHI+fTTT4d6CCH0iQGbpDs6OjBv3jz8+c9/xsaNG7Fw4UIAX3rYt9xyC7Zu3YoFCxYM1OH6TH/l7v322w9LlizBX/7yF3z/+98v2++44w7MnTu3TqIOIYQQ+sOATdLAlxPyddddh5NOOgmHH344gC9/q/7d736H0aNHY/bs2QN5uD4xZ86cfvdx/fXXY/HixfjRj36Eb3/721ixYgVWrFiB++67bwBGGEIIIXzJgNbupqdML1rbzj777Jak5nZg/vz5uPPOO/HAAw9g6dKluOuuu3D77bfXBcGFEEII/SXrSQ9zRo8ePdRDCGHIyW/SoV3JKlghhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUhpP0tm3b9tQ4wiCQ+xdCCO1Nwzzp1H0OIQwHkicd2pXI3SGEEEJFGdDa3SGEUEWiCoaq05PaE086hBBCqCiZpEMIIYSKkkk6hBBCqCiZpEMIIYSKksCxEEIIoZfss88+LW3HJZ93797dp+PEkw4hhBAqSibpEEIIoaJE7g4hhNAyI0eOLF93dHT0uJ2+97///Q9ATfpttm9v0D6rSH/PM550CCGEUFHiSYcQQi9pNWhooGjkjaknOWJEze/iPs7T1O30daO+GfjkvGE3BtevC56quic81MSTDiGEECpKJukQQgihokTuDiHslaiE3EjyHSqaBRy597WtkdytsnOrcnOjfpws7saibXuLzN3f86yeZYYQQggBQDzpMAxp9s11oFI/wvCBNlNV23Dj4+ueVIBG59TM8x0I9BiNxt/TPq32PdyJJx1CCCFUlEzSIYQQQkWJ3B2GHa1KantCMquqfBraCxd41fW9ntqbBYn11kb78rlpFDjWLNhtb5K2HfGkQwghhIoSTxp73qMajscbLPriibpqUNqPSxvpz7icl8Bj/Pe//7X7DMRxB4KBugZhcHFBYs5TdmllrQZotZry1SwgzB2jkZ01Uwf6ki42nIgnHUIIIVSUTNIhhBBCRem13O1y8tpd9upL5SEn8zSr7NOVZsXwGwVbOAmo3aUgN/6BOqdm19XRqGKT7jtq1CgA9Uv4ff755y0do9FxFXffufyfQptqdUnAvlS1Gip7a/fnTH9oZIuKy39277ufYWjHAHDAAQd064Ov3TNy165d3bbTsThbdeNsJOv3dE5VJ0tVhhBCCMOUXnvSg7Fo92DjlmVr9o2s2XJsZL/99itf77vvl5fzP//5T9k2duxYAMDo0aPLtvfffx9A/bdP593x22ez60wPbv/99y/b9Jw//fRTAMAXX3zRsJ+hxp1nf4NGWvVAHG4f3mO9vhyj3k937/iafWg/zt50O95jtbdDDjkEQL297dy5s9t2HIt6Mzyejvmzzz4D4L2sZufr6E9qj7tv7jPbLs+gwcBVCnPBWnrf+RyaPXt22Uav+bXXXivbtm/fDqA+CHPMmDEA6u2SY/j3v/9dttF+1AZ5DB3Ljh07APjnUk/P51af38OJeNIhhBBCRckkHUIIIVSUYZ0nTWnEyYsu0EFxshElGwA4+eSTAQAzZ87s1vcrr7xStlFeOuyww8q2LVu2AKiXfjhGSkAAsHnzZgDAhx9+WLY5WdzJjgcddFD5muNWGXNvkouAvuWKNgqo0WvOnxP0ftIWdF9K1mpHfF+3o6yo95B2dPDBB5dtRx55ZLfzYMCa/vRBGXvbtm1lG+XMjz76qFubSpfcVyVJnqdK4LTfvuSjN3q/2T0aznbcl0pc2kab4s8iQO0+6XaUtGl3QO3eqq3yvqt98Pqr/fK1PndpvyqBk/fee6/bMXoKHNsbf96IJx1CCCFUlGHtSYcQQrvh1LJGAZAuuAuo94IJ1TSqJtrnhAkTyrbJkycDAMaPH1+2UdH7+OOPyzYGLTIYFqgFLzqVQ73riRMndmt79913AdQrN3p+ropaq+mw7cqwm6SdYaux0Eh7klN4czUamwZ7xhlnlG0LFiwAABx66KFlGw1szpw5ZRvlRI3APfvss+vGosdVmXLDhg0AgPvuu69sc1K5i3j85JNPur2vxr63rNvaqGxhMwmc100lOu5DWRmoXVeV/Hgf1Y4oVetPH5MmTQIAHHHEEWUbZXHXn9obx8WHIgAceOCB3bYj+iDlzyq0WaBmU5S4AeDtt98GAGzdurVse+uttwDU/wzDfdQGXXlW4j5zzWyt1RoGIQwnYvUhhBBCRekA0OPXVyeXNFtYYKhwY2kkjeg3fq0URS/nrLPOKtsWL14MoD6Qh16werT0VHQ7ehMaEEavSCUd7kNPCKgFVNCbAYCXXnoJAPDMM8+UbfSGmuUWKoNZ3Wsg6UuedCMPTnF263LqXV6o3jt6vE4u1PtJ22LQIVDzpNXjZt96DL5WpYWetF4jfmY1wIzn4WzQqUzqwTMojv8CNTVn/fr1Zdu6desA1IId9XjumirOk271XjeqZNWMqj/LnB07pUdth3UZgNq1UdWHcjilZgA45phj6v4FakGJGnTG55uqdC4okc8ttS2Oyyktam/PPvssAGDjxo1lm8vbdypk1eXuZraqnzElnnQIIYRQUYbdb9IhhDAccNXWtI2qiSp3qqDQa1ZFlG2HH3542XbSSScBAI466qhu22nfVIo0bY9BZKoYTZ06FUC9t0slSJUUl5JIz1xjIDT2gfuoykAPtYreM9D/cbX1JO2Cv1S65o3UQBhesHHjxpVtZ555Zvl61qxZAOoDeWj4Kj/SOJ287vJH3eILmmtLCUmjLmnkHBNQk+EppwLAmjVrANQCeoB6adPRqqxXVcNvRKvnph903h8nmalMxYel3s8pU6YAABYuXFi2HXvssQDqpUg+5DQQjfdYH2h8rWNRyb3r+FUm476ay8rtXK6zyqOufCwf1rodPzt8GAPAOeecA6AmVwLAypUrAQBvvPFG2dZoDWT93FT9wRvCniJydwghhFBR2tqTbuZpuEpcDI74+te/XrbNmzevfM3UFZV0mD6l3hO9IfXSGQCh3hPRfV3VH45VPQwew3ly6l3Tq2bwDgB0dnaWrxnU4QJ4mi1q0Z/AnKGi2SIwznPjPdFzd/eErxlYAwBLliwBUEvLA2rqi0p5LoCLHq9eZ/WqiZMGuZ3aoAsI4/VQSdKlW/EYOhaOT7fjtVI7ZwCcppfxs3bXXXeVbS+//HK3Y7hlPVtdJnS40Gp1Mc1bnjFjBoD64C4XqKjpeLQPtSMGkakEzn1cXrOmk1JRZDAhUJOn9fPF8Wu6oEtxPP744wHUq4L/+te/ytduucxWK9u1K/GkQwghhIrS1p50CCEMB9QLpKLh1BB6mgAwf/58APUpTOphMujL1fHX7ejJanpfoxTNZsWhdDzE1YBnf7ov1ZeLLrqobFNv/oknngDgY4HaJa20t7TlJO3yB12OMCU1lXG++c1vAqjPg9bAG7ceLw1C5XOX48cPgLZpAA+h0bkKYNrGMbg1f12eNyVHoF7C5zqxmzZtKtsYqOaC74aDYTfC5VXSVtzCK3qtGQGrP5fQltTOKHfrvh988AGAermQY9GHl8uj52u1LY7VPRQdKllzfPoA5DH0oU77UAme8rRWKyNORv3qV79atjGHVvNqXe6r+zlmOMrcITQjcncIIYRQUdrGk3apMRqM5dJl6C1oihW/3auH6ypKqdfRqHKZejEu+Iiv9RhuuTYer1lNbhfIxTbt97TTTitfT58+HQDw8MMPl21r164FUO+9cH89T77fl2pQQ0WzOt1UK1RFYJuTGDV/9Fvf+hYAYNmyZWUbU6s0IEyrMnU9hgt4VKnRpSk5+ya6L4/hKlO5gDTNq3UBOOxPFR560voZ4edJ64NzO03fOvHEEwHUpxo6VYfo58bJrcMR97zhs27atGllG6Vhvf+uEpc+o1xlNd4nzUdmmp32x/f1njDAVhfdoK04W9WxuPRDqkOaIjt37tzyNSsuqvrJ8ahC1erStHuC/ipA8aRDCCGEitI2nnQIIQw3XDogvWaNSWBVMFXImALXU81qerJOuVEFhd6rpp1S3VB1juNRD5lqinq+TAnTNQdc6lQjxcjFTwDA0UcfDQB45ZVXyjamnWmNchfQ1ogqq4NtM0m7ABKXh6cGdMoppwCoRUECNQNS2UXzCLm/yuHO2Nmmkjv71BtOKcrJ3RpkQ/nPVY/Sc3LF93lczVF1hey5RCZQk2aff/75bn27nxHaNXfaBYm5QEBnU6wkxmBDfa2LafD661q+vJ/64HByMo/nZGcX1KU0CqDUHGa+dj9ZuChfZ+d6Hnxf83P5WoPO3nnnnW79LVq0CED9+XIpVpUree7NJi9XCyGE4UTk7hBCCKGitI0n7ZbjU2+BHqh6M6zIo7mF7Ee/3btv4+pNNgpEUs+BHpVbWs3JKeop8Vxcqovigo94PVSaalRtDQBOP/10APWVfej9qYffjsE6ruKYCw7Ua0jvTK8hveYrrriibKPcpteNtqeerbtPfO2CZ/R+Oc+cx3Dnpraqr7ui50YP2UmNzlbVa3a154mO2Z0blaVzzz23bGOKoC6/6uyuypJkX3H2SflWz/0rX/kKgPogRqaLqo3p9eezSW3CqTS8t2q/DBJTdcOlKfJ4qixxXFpdzFU6c0oh29x2QK0m/quvvtqtb50PXOprI6oUaNaVeNIhhBBCRWkbTzqEENqZRt6aqiv0aDXGhCuOORVGU7A03Y3eqHqqTJXSdCvuo8dj35pW6BRMeuuq+nGZSfXCqeKoB899NMaA59eTKnjyyScDqF9tje/rdWCbUyOHykN29cZbofKTdCO5WG8KbwbzoIGaYWtgGLdzucxAzbA0upC4QB0N9KJhaI6sC1yiDKT98VycNKVG3Ehq1OvhZEfthwtEaAAP5W79IPE4LsiqHeC56MIDvMf68OK9OO+888q2b3zjGwDqpV7u64KX9N7xHusx3Fq4buEBvnYVuPTeuMhV9u3yrtWm3ZKbXcep/bg2HR/lRc1/dgt78KGv58GfYbSCGR/0bsGTqsiQIewJIneHEEIIFaXynjRxBdVVyqBHe8IJJ5RtTMFSr4LbuX2Bmkeg3+BdJTGXDsJ9tT/KN+r10ANR74nj6alYftc29WLo3WmbBl7Qk2HQk47f5Uuq18Q+XQpOVT0aF1TnvFcXkHLttdeWbVwOlKlEQO2eqbLg0qOceuHup8vndPs2CkRTO6In26xCnFMYeK3UJtimfbiqfHzfBafp54G5s+6auhrk7jwGSslptqTpQNCsX3fdaFuqCh5xxBEA6uvD83Pvqukpbqlb1pHXfTTXmUqc2rmrFU8b0EAtSuruGaUKCl+7RTfUtlQVZBCwqlsMPNTtXBDvUKXr9fc5GU86hBBCqCht40mHEEK74bwop6hoMBZ/t1cFkF6ubudULldoyMVP6Lhc0Rl69uqZu1RDjqGnGB9Cz1hVOp6Li4HRc3e1yVUB4rhUPeQ+qjKRniq0VZW2nKRpJE7KYPQfUFtYQ28UDdYF0QC1D1AjaRKoySkq/bBvt0CFwvdV4qLxNtuXxqfjcx9MVwpQoSSlEZiOdjDirui580Ggkivvtz5sTj31VAD1y30SldFYOlGvqatS564rx6APTdqh2iMfuu5h4hZQUBnPBac1yp3W68Ix6GIJjPjV4Ev2pw9Kl3fNAEqNEN6wYQMAYPPmzWUbz5fBYtqPq37mJN0QhiuRu0MIIYSKUnlP2gVe0JtwHqJ+G2cuoMogDIrRftUDcilH9CzU26E3pFIMPQv1Pl3lG3rB6oW7QDTnObBvbaO36JbN1H62bdtWtq1btw5A/dKCLs2nHb0WV9Pd2ZEG0rGmtMv3VImR/ai3yevlgsnU86V3qMfgPuptcjtVWnhv9d6wTT1l3i9tc/mybmlOVy+byoEqAwza0Qp2vC76+Xv99dcB1NeH58IILtCo1TS/dqp+53BLger9on3o/ec1bxaAqrggU5dayvc1fY75zy7lT8fPfZutdcDt9PiuVryzQacUqe2xUp1eB/csblfiSYcQQggVpfKedAghDAdc6iLVEFWs6DmqN8n3NQ6A22lcgVNp3PvNloekx6oevlv5j56vi59xy2aqV+xSR+ldu/MAavEhGnu0atUqAMB7771XtjVKX20377ptJmlnsHpzaQRvvPFG2fbcc88BqM//c+Xu3BJ5KjW5POlGlcncggdO4tL+2I8aJyVTPXe3HKaT/VXadItHUD5TKZfSZrNo0arjokHVVnju8+bNK9vOOOMMAPUydqOfVVRa4/t6Tygxq32wb/2JgQ9QXTjBSb0uN/nNN98EUG/LbqEZBsXpYjC0S72/tA8XOas/lfA8mLurY1i/fn3Z9sgjjwCo5bECNUnVBX26Wggul7nd5e4QekPk7hBCCKGiVN6TbpR6ot+o6WGOHz++bHNF3V0lGpfj57xc9Tr42lWU0uOxso9KNkxrccXm9bhueUJ6SOpd06vrKS3LLYc3bdo0AMDChQvLtvvuuw9AvTfpKl3tSfoiTaknzYAWtYsLL7wQAHD22WeXbS4Ih+euATVs03HRPlwqn46F11/7e+GFFwAAmzZtKtsY0KYLHjCdSe8rgyBdRT31uKkusapa1/ETesPqNW/ZsqWuX6C2IAODwICaavXkk0+WbQwcU2WGn0mXAtks4M9JmI3k1qqi50HFRW2H56zPFqpcbglHVcPcfXV9OylarzVtSoNR2Y+rJOZysd2907HwuG4Z2Z7Gz3Fr5TWqUFr73dWmd0tjksHMne5vhcZ40iGEEEJFqbwnHUIIwwn1pOmxOm/SpWiqoqGxCK5vpzgSF7PiCtFoHAvVD1UFqZKo+uZSCOlNaoCc284plG55Tm2jQsRCOYAPfOM5NVMFGy0pOhRUapJuVVLljdYbScnjnHPOKdsocaphN5KpgdqHRt/nzdU2vlZj5/E0aOexxx4DUL9+69KlSwHUfzAZmagfAMpYel34QXHyTE/LGPJ66XVg8NTcuXPLNkqVlNa0Tyc1VjVKUsfF6zl9+vSyjddfH0oMwnL9qJzMB4p++Cn5aa4or5suW0pb0TV/J0+eDKCWt67bqW1RduYSo0BtsQG1S47VlXN0Ub4aTEapX3Od+fDVY3CRDJW7mQutQXFuuU5eF5dDq/br5G62VdXuQhgMIneHEEIIFaVSnrT7huy8a+dN8rUGUTCwRr0efrvXtCv1OugxqOfrlhN0gV7cTvtmf+qdsm/1qFzAGs9Jj+uCN+i5q1fULFjOeWtMvVHPsR3RABJem5kzZ5ZtVBG0EhalQ71GvO5Tp07t1p96yK4KXNf3gNq1VnmPy2FqzXDalqtwp3ZJr1VTpmh7rna3fg7Yt9oqX2sbryW9Z6Cm+ug14D4uYNHV31Y7d8F4xC2R2e6etKsGqNec6o+mjvK17svrr3biglubPVfd9XcBYcQt2avPKAZGupQ/VxVRbZWvdbtmy5U6dcZJ6Y5GQV2DFUDWW+JJhxBCCBWlUp50CCEMV5zXxtfqSXM7VVdcrEwj9U37bJZyRPXIpUw59UXh++o1czvniTqlRT1ptqknrfA6aBqjq11ONcIFrzVLSRss+nqMyk/SjeQNZ0AaAMSlKnU7Bndpm5aTYz8q31AeVWOi7KnyqJNdli1b1m1fftBUQqQ0r3mQxH149APDD6PK1G7NVx0r87dfeumlso0yq5NPe3oQVJ3Zs2cDqJesaQO6wIaTUvkB1wcj5V/N/SX6AOL90SUeaTN673g/aWNA7QGj15xlEDWKlss9aqAXA8vUjlx/vP86Fm6ndsmcaZXZGSCn18BFEtMG1RbdzyyNommrFmkbwp4mcncIIYRQUSrvSYcQQrvhZFS2qaLF1y6XuVnwJ5WZnpaTpdLh1gNwi3yoEtcoeNRVNlT1je+75SsVt7CHq9rY07KVPfWnx3MSfU/7DDZ9rTlfqUm6kYyqN4oGoTeMMp9Kk8zjVAOhQeoF0983nGTNPl0Epm7XaDEN3U6P1xXNZXWSH6PX9YNJKVJ/m9FzdtIsx0rZE6iXUkk7SdsOZxcbN24EUG8/tAv3MHFrgisuZ5729c4775RtlMrd74puURa99m5NaG7nysvqvXRSNG1Gz81Fd/NhrQuAcHLQfWl7ar+NorFdZobi8vLdQ67d7TOEZlRqkg4hhD1FFSZ4fqlyS1VqbABh7ArgY030C6D7Qs/39QuqSyHkl1bnhSv8MqUBWgwi0+vLL3RuLO7LqKvXrfu4L3F6TtxfYzPcSnKN0v+qQqUm6VaDReiJqmHQUFnoH6gZuUYKch89hho+b5rmNTvDdiXy6NGoZ+MWAHAF7WlAzmBVemJutRo7vSY1PvXW6S3rB86dp1tGsB2XqlSeeeYZAMCcOXPKNuacasAg76MqCzx3tQ/eE1UtnITIZRy1P1d+kffMreWr94s50VoK0uX8OyWI/bh76QIQXe60e2i6amAu/7bZvo2kYaUKk2oIe5oEjoUQQggVpVKedAghDAdarWDllunU+ARCdUvfa5TipmjfrhY/1TlV7DhWlbjdcqDsp5mqwuO6a+DOycX1aLtb+leD11Qh7MpQKTJ9XQ5zyCfpVi+YOyk1Ghqay39Ww6V8pyUNNRF/ypQpAOpvOBcy0DKeNBItQUkpVOV1Gr6On+N2kYoqcXLcKnEy4EfbXnvtNQB+gQegZuQuJ1alzVbLCLYTvJ8qWTO4ya0p7n4z03vC66WBWQyq0t+/aIda2tFFnGp+NHGLZPDeamAWf5546623yjbaha4IRJtxa7K7srBqO7zvLijOFeXQh7+LXG518mr3n1lCGCiGfJIOIYS9Cf3Swi8j6nT1XygAAAzzSURBVFzwi45+6WObyzDpqdAQv+TpFx62uWwCV7vbrUOg/XEfdUxctTAew43VXQ/3pVDHoMyYMQNAfS1+ruinzowLOqtywBgZ8km61YvkpAINHNu0aRMAn3Pn8ux6qnjEimUM/AFqHvmJJ55YtnEN08MPP7xsa2QELlBGPyhsUw/eec0MhtPIT1ac0g+UjoHXyQWE6QfA5Sg6j6av+X5DAdOtVq9eXbbRK1Ulg/dYlxklbolSXcjFBUhRbtP77tQL3htXac55qurV8zxef/31so32qwFr7mHOMaudsD+XB+vuuYuwdeMf6Aeh9tdsDCG0O7HwEEIIoaIMuScdQgh7K1RSmhWkcTIw4xNUXXExLU6edusB6L6M2XExKwrbXK62Kp0uzsKpM1R9XPyEjluVpwkTJgCoX5CEqbjtIGc3oy0naV74Zotb0OjcmrRO+gNqxqn70MDUMHhsGghQM1i3/rOTLrWNxqn5t5Qs3RrC/BeofZB6Mmy3aIgbl6uO5vprJ8N/4403ANRX/nrhhRe6bUepV3++4OIY+jMHX+vPEgzg0ocqr6+2ud8DuZ1K77xPKrPTLvW+8ze4V199tWyjrbgHs+KCFnncVoO2mq3z2ypun1Z/UmknWwyhL7TlJB1CCO1Gq1kT3E6/fDHu5IQTTui2nRYu0uh/F3/DL4oa3MUvRM4Lb5b+RG9Zv1S5KmouDof9uBQxRfvh/pou5orh0HHR2BH27YLPqkzbTNIuhUm9TremKIOAnPH1BI1g8uTJZRtTsJjOA9SM3HkkLu/PRSu6Mnb6oXVBRS7Nq1nFplZrIw9WoM9QwnNXG3j66afr3gNq10MD8iZOnAig/sFIT1tlQKIPE752EbqN8mABX1/erdvLNuc1O9VE4futVhJzNKsQ1mjfZh53qxXH2imIMYS+kMCxEEIIoaK0jScdQgjtjFvIwq0LQFnWKW2qwnA7VWtUMeI+KoG7NEsnY/O1ysXcV1NCWYxHVRPGT6jy4eRnV63MqYcuJVSVRMZ9qArm0g7dmgntoBq29STd7AJrVTHCG6Q3SuVCBllpgA4NRnOnXYk8GpN+UGiIzaoquRxaVjPTPFgaYqtrtQK9lyKHE+5+uyIKfK33lQ9T/c2P+fj6oOVDUB9yfJhqhKsLWnTwpxu9r87e+IDUqma0C1cHoFnwX39solF/7mcFfchSwtcxcyLQNvdZ6m2wWwjtRltP0iGE0G60Gi/ivEANeuIXMu3DlbrV+AT3RYf7uHre+mWK22nBKDokWjKZ49F9Gy0xqWNx3q561XxfnZS1a9cCANavX99tH/dF3HnSVa5C1q9Jukr1nJ234GgWHEUD3Lx5c9nGtBZNhWLFsWnTppVtTNlRI6aX5Yrgu5QuVsgCaqlC6sm5ZRGb3YeqGV1P9OacWoX9qEfrHnhEP9SsQqbVyqjO6NKXrqKbS4Wi0uIiZnV8bqlKl7fqUuv4YFSJ06XbDdZnt9XPn47ZSaY8NxcQ2izXNoThRALHQgghhIoSuTuEEPYg6v0zjkGDo6iqaCDUunXrANQWkwC8eqj9UFVx6Z8u91hXinNj5T4qbVMR0f54XG1jwJhTS5yy5OJ6tG9VrV5++WUA9QWLxo8fD8DniDeL16ga/Zqk+1NlaKAZqIvMc3G/46gR0OicjO0WaVDDcHmwDJRRCdat/dpo/daerkFvl54c6KCzVqMpB8OO+CDQvhsFcOn4KFnrzw2MJGUAGVC7TxpsOHfuXAC1HHs9nka48gHp5GkXLKbw5xJd7pKyuFttqNlyk729/s1+W21kl/oQ5mTkonjdb4XtWv0uhL4QTzqEsNezJx0OV0DGfdnQteq59OLll19eth1zzDEA6r8cur4160C/HBGXicAvSa5oz5FHHlm+5vVSZ4XHc9fSfVHUtDJ+8XRfZLVPHRcdHFfAR8fgKo41yr4ZaPqa+tXrSXpv+RarXoyrKkYvSw2DhupK27k0FHc8l3bjIjaroF60A7zWGszXW/SeMKBQSzY66NE+8cQTZZuzIxfE5u67W8iAba1+DlsN6upPNbBm9eGdV+/yat1npNUUthCGEwkcCyGEECpK5O4QQhhinNqgbY899hgA4J///GfZdskllwCoj5lQBYIysVvoQtUIKn+qAPK1Kh5Ue1yNeqceumJNijuuW4lPY3x4TTRVdcOGDQDq69q76m7tujZBJukecAn2igvqadUIGgVyuWCcVAyrTj8M+tNVeJxMvGXLFgC1pTKbjavZfe9tW19o1ab44NMJwa1d3OqxGn1u8rNO2NvJJB1CCEOMy+DQil380nfzzTeXbUcddRQA4JRTTinbtK62C+qit6nrnLuCP/RutY1VvpwXrmOlB69VwZxny+OqJ90oFgGoBYw988wzZRsD57Q8rktta9dYhkzSPdCX4JlW923E3uIhtyutBi/xoaUPuUYMVPBXf2jVbnnug1kvu1G5xnxGwt5EAsdCCCGEihJPOoQQhgi3CAbVFw22ojLz7LPPlm233347AOCGG24o27QaGPfXwCsXEMb4GlWHXF34Aw88sO49oCY/ay6zq0LmUkfZn8I8blWgdAwMEmMgnfajcULMt9bj8XpUeTENRybpAWSg5bgEzVSP3krCg8lQ28dgHr+3OdFDfS1CGCwySYcQwh6kWbaGC6jilxWtGPboo48CANasWVO2nXvuueVrBoepx0oPWut0M8CrWQCXlq7t2p9DMyDoVWvRHlYV0+NyzOr9a4rZihUrANRXWWNZXB0zj61ePz1pl5ZVZTJJDyD5Nh9IbKF/5PqF8CUJHAshhBAqSjzpEELYAzSqee4CuTT3mJK0Bmixfvytt95atumqaxMnTgRQLxezTxcQpnI2JWFXXUwXt3C52JSQP/roo7LN5V3zXFQW57j0ejzwwAPl67Vr1wKol8O5jy7K4RYI2ZOLaQwk8aRDCCGEihJPOoSwV9KftbT7e7yuaPoQg6vU66QHrN41Vw978MEHy7bf/va35euf/OQnAOq9Tu6j/fB99V7pGR999NHd9n3vvfe6jZUpT4BfDpPesnrcbllKri64atWqsu3OO+8sX9PbV+/b3Ttup9kBPHY86RBCCCEMCJmkQwghhIoSuTuEEIYYlWxdBTAGd2lOMSVfzT1WaZjy9RVXXFG2MbBM86TZpx5v586dAGoSN1ALwlKpnMFYKnFr1bOux1BZn7nOuuwkc747OzvLtq1bt5av+ROAyuYMQNOcaF6TKlUX6+tPKvGkQwghhIrSAaDHrxcaDBBCCMMVejmu0tZQoZ4fPUgNmHJreKtHy31OOumksu2iiy4CAJx//vll27HHHtvt2PReXQrTBx98ULbdfffdAIB33323bKPnPn78+LKN+6xfv75su/feewEAzz//fNnGVDM9d1UPXCoXvWZNIRtqr7kZrlKbq+gGxJMOIYQQKksm6RBCCKGiRO4OIez1VFHuVijfqtzN/GKXYw3UJFV9f9y4cQCAY445pmybNm0aAGDWrFll21FHHdVtXwaTPffcc2XbU0891e24J598MgBg6tSpZduLL74IAHjkkUfKNlYk02vulrlUuZsytx5PJXnC+1lV2TtydwghhDAMiCcdQtjrqaIn7VJ2dHx8PqvX6Tw0Ta1impJuR09Vl7Rk3+q5E1YFA2qetgZy0XtVb5cBbc2W5NT0rq7b6fF68jqrCM9ZzyOedAghhDAMyCQdQgghVJTI3SGEvZ4qyt1KI+lbl6/U8VMGd1W3du3aVbZRQnYSrLseLhhL25y86/pzfVPu1n0195vjrmpAmCNydwghhDBMSe3uEEKoIM08UaJesdtfA7PodTuV1HnXLhVKA9FcQBiPoR4+93EBa9ofvUnnabpz63rs4Ug86RBCCKGiZJIOIYQQKkrk7hBCqDitVtBy72vVMLcMJmVpzVFmmwtEc1K0Surcp1nOtpO23T5O9q+SxN1Mmu8v8aRDCCGEihJPOoQQKkQjz9G959p62qdRupVu1+g4LmhL06TCwBJPOoQQQqgomaRDCCGEihK5O4QQ+sFgBw6FvZt40iGEEEJFiScdQtjrYQBUvOJQNeJJhxBCCBUlk3QIIYRQUSJ3hxCGPT0tAxhC1YknHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUDgDFUA8ihBBCCN2JJx1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlP8Hpf4p/72PsCIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotting.plot_epi(opj(out_path, 'sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz'),\n", + " title=\"fwhm = 0mm\", display_mode='ortho', annotate=False, draw_cross=False, cmap='gray');" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAADJCAYAAAAHFcoVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2dW6wdZf3+n13aAqUnSgstpdJCoVCgQNtYoKUUTDQRuVICRgmQ6IXxwiti4iEmaoh3GiPVKwrRxARjNCFo5EKBJiKKVaAghxakB1qgQgErJ+38L37/Z9az9n72zFprr733rL2fT7LT1XfN4Z2Zd80732e+hyEABUIIIYTQOGZMdgdCCCGE4MkkHUIIITSUTNIhhBBCQ5lZ9eWhQ4ewdOnSiepL6DOHDx/GsmXLJrsbIYQQemQIFY5jRRGfskFnaGhosrsQQgihRyJ3hxBCCA0lk3QIIYTQUDJJhxBCCA2l50n629/+NpYvX44ZM2bgtttu63r9hx56CENDQ9i9e3evXZg0brvtNgwNDY34e/bZZye7ayGEEKYQld7do/H444/jW9/6Fu68805s27YNp59+er/71XguuOAC7Nixo61t5cqVk9OZEEIIU5KeJmlajF/+8pcxf/78vnZoUDjllFNwxRVXTHY3QgghTGG6lrtvu+023HLLLQCABQsWYGhoCHfffTeGhobwxz/+sVzus5/9LIaGhvDkk0+WbTfccAM+97nPtW3vyJEjuPHGGzF37lycc8452L59+4j9bdy4EQ888ADWrl2LOXPm4Prrr8cbb7yBPXv24Nprr8Upp5yCjRs3tu1rsrnnnnswNDSEXbt2Ydu2bZgzZw4uu+wy7Nq1C8eOHcPtt9+OBQsW4JxzzsHPf/7ztnW3bduGz3zmM9ixYwdWrVqFuXPn4pZbbsH777+PP//5z/joRz+KuXPnYtu2bdi3b98kHWEIIYSJoBjtz7Fnz57iG9/4RgGg+P3vf188+uijxVtvvVUsX768+N73vlcut3z58uKkk04qfvSjHxVFURTHjx8vTj311OLHP/5xURRF8Yc//KEAUKxevbr4zne+Uzz44IPF7bffXgAoHnvssXI7t956a7FkyZJi/fr1xS9/+cvipz/9abFw4cLi05/+dLFhw4biJz/5SfGb3/ymuPTSS4sLL7ywOH78uO03+fDDD2v/6rZx6623FieffHIxb968Yvbs2cXmzZuLhx56qG2ZHTt2FACKiy++uOzjunXrilWrVhU33XRT8bWvfa148MEHi5tvvrmYOXNmsX///nLda665pli+fHlxzTXXFPfff39x1113FbNnzy6++MUvFuvWrSt+9rOfFb/61a+KFStWFJ/4xCcq+1p1ffOXv/zlL3+N/xv9y9HgBPTOO++UbTfffHNx/fXXF0VRFHv37i1mzJhRfOlLXypuuummoiiK4oknnigAFLt37y6KojVJf/Ob3yy38cEHHxSLFy8uvvrVr7ZNiCeccEKxZ8+esu2OO+4oABT33ntv2fbAAw8UAIpnnnlmzJPWjh07Krfxgx/8oNi+fXvx0EMPFb/4xS+KK664opg1a1bbwwXP0T333DOij7fffnvZdvTo0WLmzJnF9u3by7ZrrrmmWLBgQXH06NGy7cYbbywAFA8//HDZdtdddxUAimPHjo3pePOXv/zlL3/N/OvpnbTj6quvxte//nUcP34cjzzyCNatW4cbbrgBX/jCFwAAjzzyCBYtWoS1a9e2rffxj3+8/Dxr1iycd955OHDgQNsyK1euxLnnnlv+f/Xq1QCA6667bkTbwYMHceGFF47az7/85S+1x7Jq1arK77/yla+0/f/666/H2rVrceedd+LXv/5123cf+9jHKvu9YMECLFmyBAcPHmxbb+PGjViwYEHburNnz8aWLVtGbO+VV14pP4cQQpg69G2S3rp1K44ePYrdu3dj586duPrqq7F582YcPnwYL774Inbu3IktW7aMSFO5cOHCtv/Pnj0b7733Xu0yw9vZNnzd4Vx22WW1x3LCCSfULqOcfPLJ+OQnP4n7779/xHeuj70e87x58zBjxoy2NqD+mEMIIQwmfUtmctFFF2HRokXYuXMnHnnkEWzduhXz58/HunXrsHPnznLinmxmzZpV+3fvvff2tO3kyQ4hhNBP+mZJDw0NYfPmzbjvvvuwZ88ebN26FcD/Wdh33303Dh061IhJuh9y93Deffdd/Pa3v8WGDRt67VYIIYQwgr5N0sD/Tch33HEH1qxZUyY4ufrqq/HDH/4Qc+bMwfr16/u5u57YuHHjmNZ/66238KlPfQqf//znsXr1ahw5cgTf//73cfDgQdx333196mUIIYTQ50maljKtaG3btGkTZs2a1c/dTQonnngilixZgu9+97t47bXXcNJJJ+HKK6/Eww8/POYHgBBCCEFJPekpTt6ThxDC4JIqWCGEEEJDySQdQgghNJRM0iGEEEJDySQdQgghNJRM0iGEEEJDySQdQgghNJTKSfrw4cMT1Y8wDuT6hRDCYFMZJx1CCCGEySNydwghhNBQMkmHEEIIDSWTdAghhNBQMkmHEEIIDSWTdAghhNBQMkmHEEIIDaWv9aRDCCGE6cAJJ5wwoq2qvPPx48d72k8s6RBCCKGhZJIOIYQQGkrk7hBCCB0za9asyu+HhoZGtFEGdnKwa3PbGI0qiblfsD91+6o69l6JJR1CCCE0lFjSIYTQJc5paDzp1LLU5fhZ22jV1S03fHn9rG1unar96rp0pOrGanb96mX9XnHHNN7Ekg4hhBAaSibpEEIIoaGkVGUIYVrSqeQ72jqTQZW8PNr3Y9mPk7u73cZodOtM1jQ67SOXS5x0CCGEMMWI41gIIVQw2dbzaHRq/SvdWn9joS60qspRrVMrfDoQSzqEEEJoKJmkQwghhIYSuTtMOSKVhX4yWTG5ipO265zISC/jvdPj7MdvyR3TaA5r0/G3G0s6hBBCaCixpDG+T8f9ftKcjk+S3TJjRvWzZ1Xoh6NufHB/uhzDLf73v/91tI8QOmE8w630d1P3GyIc53W/parvJzpPdxOUkW6IJR1CCCE0lEzSIYQQQkPpWu7uxXGh3/RLpnTLVSWHd+s4WcjJKU4KHYtE1I1k0+n+JotOj7MXnCNKt/GldeODxRZ0LPz3v/8dsVxVcQO3v7r9dpoVysn7nbY5un1dMOhMtrNYXR+6uQ4cq1pucubMmSP24V7huP1wnPNfoLpwhm6Dr4ImehyNZ1a28SCWdAghhNBQxmRJV7WNJ91aQGrh1D3duacjrs8nTgA45ZRTAADz5s0r2/iU+sEHH5RtXEfXfe+99wAAH3744Yi+aNu77747os09pbr+OavObacJVF1P7edYnljHMka1LKGeY+IsS2eJsM1ZMboPfu+WO+mkk8o2/Ty8L7pfXn8dlxyD77///og2XY7Wjl4HtjmnuH6FAA1qPufxopfzynV0bJ188skAgNNOO21EG68/0LpX1N0b3djiWNH98rOOI97fdL/uvlSnHk02naquvRJLOoQQQmgomaRDCCGEhjIhcdL9ksC63QflRSd31+1fZc05c+YAAE4//fSy7dxzzwUAnHXWWWUbJZ1///vfZRv3o32glKRyIWWet99+u2zbv38/AODVV18t244dOzZi3Sq5Vfvl1qnDyaf9kJ2bJFeNBs/b7NmzyzZK0HounZMYx49K1pSn9RUJP8+dO7ds46sUypC6ri43f/78Ef3jfrWN/Tt69GjZ9sYbb4xo49jTMfjWW2+NaPvPf/4DoF0qr3p9UidddyptVzm7TUU6zZznnBiB1hg48cQTyzaOKTfe+K+i2+OY1+vOe5m2uX7peCS8T+oY5NjS8dRpUY6pSizpEEIIoaEk41gIIRgmO/SqzmGKbWqlOvVFVTVa1c6ZbOHChWXbqaee2rYNoGUtU83Tz6oe0hFM1SYqSrpf7oNKJQC8/vrrAIB33nmnbNPtDJIS1y+6nqQnOqVat/vopV6pG8Tq/Uhp+8ILLyzbzj//fADAggULyjZ6OOqg4sBWz2oOVB2w7A89HgFg7969AIDdu3eXbS+//DKAlgyp6zj5XHHHXCcdjpc3f9NSnbobo3tdQrTPvAGpXEg5Udt4U9LXJkuXLgUALFq0qGzjjVFfufBGrDIlb266HG+4ul/2VW+k/Ex5EWiNI5W2X3vtNQDAK6+8UrYdOnSo7V+gJZ/r9qpSorrr7yTOuvj2pF0NU53I3SGEEEJDmRC5eyyWUrfWnUsSXycR0cIBWo5gajWvXbsWALBs2bKyjdaOy7TjrBiNBXQWAa0xlZy4D7XqX3rpJQDAc889V7bRwUwlIrXcxyspfadxmnXbmyzqMizxs4vV1nHGa6ZOhGeeeWbbd0DrOuo4Wrx4MYB2yc/FIXO/6gTkpEuOGRdDrcuxX3oc3J/GvNK6ViucjoxUeoDWeOT4BFrSpapDVQ5mddnZhn83nahyxnKOiIDP0cBxpveU5cuXt/0LtNQelc95HfU+Q9XlzTffLNs4VvQ6uax8/Kzqy4svvggA2LNnz4h96DabpMQl41gIIYQwTYnjWAghGKqs+Yncv/ZBFUD6MVCNAdqVG1rBag1T5VO/iI985CMA2pWgKscxtaQZPvWvf/2rbKPFXZfVkNa1qpG0+l1Yli7b9Cxk/WSgJ2kXH6iSHtGLx0HKgQkAF198cfmZMjflSqA18HXbLoUicZKODkRK0TqI3YBmXy+66KKybeXKlSP69/TTTwNoSUUAcPjw4fKziz0kYynYUEdTfzQuXWK36T4ZowwA5513HgDg8ssvL9tWrFgBoP2mSSdDvfFxeyptc0zpmGEfnLOhLsdrra873Gsfl6KU40PHCSV1dVjjDf7ss88u29asWQMA+Mc//lG2PfHEEwDaZXFKl+7YlKqiMINQAziEfhG5O4QQQmgoA2NJO4vPWawOtQJWr14NANi0aVPZdumll5afGRLjHGpciIguR2tMnXtoCajFQtQKdzIO19Ht0QpT65/S1JIlS8q2p556qvx84MABAO3OP2rJDMc5SjXJUWOsOEvaFQBwxUw4llatWlW2bdiwoe1foDWO1CGMaHYmWr7OScwpRS5zk15L5+xWVYDFOT7q9XXWNddVJyX+rtQJk8qB9pkOZhpCSKt/umeWIlWOpSpTU73QNr0mVOJU9WGbho6eccYZbf/q96r6cIyq/EyHMd0v5XAdW1zXjVWF3zOkD2i/b7Hdhd5N1XC8WNIhhBBCQxkYSzqEEKYqdUl0aAFTsQCA9evXA2hX0FSxowKnIaFUdtRC5vfaxu049UWVEe5DFSMqHqoUUj1y/i66D4YnXnLJJWWbhmBxm5r1jPSrrG3TaNQkPZY60UQvDgcQnXiAliSpg0CzPbntuIxIlB/1R+EGNuUb5/Cj26sq0uAkIt0vYx7pwAS0S+Q8Po09ZCapupR7VW11NOmH0ksmMa7jXpdcddVVZRtvlupIRYlR98sbi5MB3XVw8q977eDGVt01co6WVQ5cbqy6GsJ6s+b5UE9dytwaO+3qqlflQmjSuAphvIncHUIIITSUCbWk+xU6UWVJaxsdIdTJitamOk6oVerCbhxO+qHlq9YJrQ61rp21Q8vCWfDOqUjbuD912tHYSLbrcdJ60UxBw/un/e9FSmqC809VTu6q8qZAy4JmnnYA2Lp1KwBg8+bNZRvjS51VWldS1Ckj/N4597nzp2PLZXbq1MmxyvnSWdLqAOdy1HPbGi7IPPjqfETHRpeVz/WpLv52EHFOgnpdGcqnDos8lxrm58a53qP4Wdu4nKobxCkeqqDQqUuvCbetY9UpRs4x040ZlfipANY5S1Y5xg4asaRDCCGEhtKod9IhhDCdcOGAVFXUkYuWpWYFo9+DqmbOknbV1HTbXEctZJekiZaqS0TjcsU7S9r5VDh1SJ3dNNc9w8006xmP04VP1iVmGgQmZJLud2nDKilMHVcok1x22WVlG53I1BnIxTXrIK0aYO4H4PrtJE5d1xXicBKRO2b2XyVTPQ/8EesgpkylGaIobdXFq46FyXL+cfKvc9bSmwPjUK+77rqyjTK3Oonx/LrMXy520113xTkqOmnQ4aRSjkuXV0CX4+e6ffA49XfDNifbM2Zct637pYx68ODBEdtzfZ6q8bAhOCJ3hxBCCA1lIOVuPoW7LF7qPEVLSB1/XLiV4p7gqxx+1Jpgv5wFVFfukNaOy+HsMkC5dUez0JwUxYT4hw4dKtuc40i/LemJsKDrJD9nqfIcqrRGq3nbtm1lG511FF6zujznTtqsylHtst657elyzpLm9y5US3H9c+s62ZOfncTpcoHr/o8cOQKgPR6WoVqDKlF2inMc5DnSTGHM2a+qBNdx9wL93l13beM6zpHVZaRTXNgp13X54/V+6e6N7nxoHDjLaep9yzla8vNUcCCLJR1CCCE0lIG0pEMIYSrgqpFR+VLVj1X7XJ5utYpVNaN1q2oEQ+U0BM6FajkVZPjyum+1mqmI6D54fM5vx21bLXO1pOlTpImZ6Mej23aho5Pty6DnrZswwoGZpOskTA4WyiFAS5pUiYgXUgeVxns6mcQ57bgygVWZmPSicN91Uqj7AXCgOYcaJ2Fpu94I+KPX1wOMQXQlDQcJV5jAxYjrsfFGcOWVV5ZtW7ZsAdCSGoHWedW0hBw/eo1d3HAVuhw/u5uK+x04KbouZtSNCV53lSRdXC37oH2mxOlisbV/PCbdLycjzV1Ax0b9LU116TsEx+DdgUMIIYRpwkBb0vpkzSdzzchzwQUXAGjltgZa0oiGOrlE8M4Cqst+xO24GEOF36ulRKujznJ1IUzOMlSVgeFYGl5Ey1FD0dx5ddm5mm7ROEcabaNlqdYhw/Wuvfbasm3dunUA2iVEWtCuzKharG4cufKQ3I7L3uWyKjmnLnc9qhzDdDtqNbtQPWdxOwue403HHVHZk2FWzDIGtHJ7142rpo+7TnGKnAuFU5WLcdIq/Trp2IUa1o03l3fd9XX48rodvcb8jeg+XJ75qnudfqcOdDwPmmWNTmSu7oGTmPs1jiZqPMaSDiGEEBrKwFjSIYQw1XAhc676GtVAtSqJs4p1O87fQZVEWtpO2dM2FwbIdXV7TkVylrSqOMOXc/m8gZbfAp3m3Lra//H0qZmoxEwDPUnrgOTFUDnIOUe98cYbANodf5wM6Aaiy1BVJ4G7gV3lEORiop0jVF32KBcbqfut+iENesYx533qbl56w2Ms/TnnnFO28UZQV7aU59U5IzoHRLfcaK9fiLtpOqrkU3cttX90/nJFEPR4KYuq3MpXAip78vPhw4fLtmeffRYA8M9//rNsY5y0FntxcdfDjzGE6UDk7hBCCKGhNN6SdqUGnQOAk12cZUDLysXU6X5cHmbnCOFkKrViXTiNW444ecnhcjM760n7oFYOM46pouAs6UHEOc/oMdFBSkOrmJ1OpTWXy5znstOwPbWaef71OnA77lqrs5Yb8y6W1WXC42cXludUB4WhUO541SGTfaATGAC8/PLLAIDnnnuubHvhhRcAtFvXLq7WxZFOluOYC5UcC065c2VO9TdM6VudGDm26mKBXeEMHZcusyF/I87xyoWTuvHhyrTqcjzmTsvIar907HF86/iZiHtYHMdCCCGEaU7jLekQQphK1IUKuYRFXE4VkirlDmhZvM6SduUmVYV0oXfOkmZfdXtO4XH5tdlXF5Y1WhIb9ueMM84o2+g7Qn8j7UOdf80ghPUN9CTtZBd1PnnllVcAtMt8XMfFper3zoHLDTAnrbpsT7ouB5qTtl1Mow4uHktdWjmXZUqPidtRL0n2y/3QB2EwEycd6s2NWem0hKlK30SlW+IcvZy8N3z/QOu8aiEJ1sV18coK9+GyfLm+6PboTKmxpdyHkxp1bPF1iBZf0VckhMf09NNPl227du0C0JK4AeD1118H0JLRtf9uTA/6q5cQxkrk7hBCCKGhjJsl3a8nYFcm0jk40TLQ2EJ+70Ja6pxB1CpyzhHOanLhPpRg1AJirJ9a+M7BrMoadjKOc04DfIgWrUlmZQNazjzMCqXHMqgZx4jKY5s2bQLQbkkzG5s6n9DCc8er19NZubwWdVnlWJJRxxZDwzRErCoczzkT6XK0fF1pV1diUK1m52DI3xpDp4DWmHniiSfKtr179wJolyGdo1xVGU7Fhe+x/+NZkrBf9zIXtulCKquc5tx3o5UgdWOwKre7W1f7xbHl1D439l3mOieVu9zzo8HzpcVH+Fmz2HE7TkrvV6GNiYqTjiUdQgghNJSBficdQgiDhst57lCljRak83EYzfp01ndVMp66GgZVCXpcLnvFqVtOWahTLbis1iGgr4UrtenWdeejyQzMJO1Opl5cXijWGwVaMogrUzjaxXGSiBuwrgAHMzHpuk4uZH90QFJadTHdupyTVtnn0QpsuO3w3Jx99tkj2piwXvfn5PVeBvhE/ChcSkEtvHLJJZcAaM9ER9lZnbp43rTwAKVlJ/+72FMXK6qOYZS0X3311bKNkrueK25Pb050+tObU1UaRO0L96ETBmVujlmgJWnz/Ghf9GZMJ839+/eXbVzHZbVzN3oX7+3O8yDcWEPoF5G7QwghhIYybpZ0v7P0uG2r1UCLSa0UtqljTVXSeaBlNddlF3POLlXJ4Z1Tl7OyXDaiuvzgRPunITguH7nLMkQL32Vj65ezxUSgYXjnnnsugFZubqDlNKfnkKFQepwukxvbnGOhiz11Up6GvXF76gjD7aiESKtU+6yhV1V9drGnDIHS46Da89prr5VtdCbUDGF0BNMwKpc1zOXfZv+dM5NSZTUPqiVdlT1Rrw2vnTrBUs1xTmJ6/kb7XIU7184B0Tn9uXuT215VeF1dxjH3G1J1lPc6XW4i6hBMFLGkQwghhIYyMO+kQwihn3Sq9vVbFXQ1B1wWMvU/oBrYjZOVS0TUqfValZ3Lbc85bdWFxVX13ymK2l53HnjsbrlBU2IGZpJ2F00lD36vchvlOx1ADpW7KSHqAHOFB3ihnQysUiMzWTlZXONROZh0X07udh6KlKFcakFFj4nyJDNA6XZc0RBlkAb56tWrAbRnFFu8eDGAdonRFcRw5SE5plysqJO7dYzy+rhCBvpKxjlX0clNJWZ+plQ/2vY4jvR4ef3VoZHb00xrznGMn3Vd97txEqeL3e12PLnfUghTlcjdIYQQQkMZGEs6hBCmAnWlJR1Oph7+HeBVt7rSrVSMVPVx9QWcEuRKo7LN1URwIXVVMc3DcUVF2H+XMc1J+JOVPbHXfTU+Lah7B8EL5OonawrC559/HkB7ekWuqwNDvWSrAvtdNRn9wbEP2i+VHYdvT+Vu927KHSd/DM7LV49dZUeXhID9Z3wr0JI7nWzbr8E80e+F3Dh078pcv5xnu6s37mLmXUpaV6ilygvVedvq6xzK0nU1eocfD9CSqlUq52eV1Lmc8yR3N0o3AXWa7rOOSNthOhJLOoQwLZmskBx92HBWpKsVwHVcLmpFH5Jczn6u77ajljTX0b463xxnrTvDxIV08aHRGWCj4cJhGZ7msrc5ZWHQaPwk7dLY8YKrQxif9Pft21e20VLV2GnnjKWD08XBVsURusxf2i9XWtKVr3Q/1ippxzmBOac5oHUe9EdPC89ll3LKwqBCxzg9JuckxnOn543L6fjgtdDz72I3ed1dPL677nWOfrRu1YGLlrRawzxOPV6XzY6fdTmOE1dkpK6AQpXnb128bLcMUrGXEMbKYD5ahBBCCNOAxlvSIYQwFajKxFUXo1ylqo0mgbt1nJ+La3Mx1lX9dw5mur1OFY9OQz5128zWxxLAQEsVHLRiGo6BmaTdexwnIWvcL+XAunSYmn6PF1ydzU477TQA7YOA0qYrCuAc2uockpwES/lR5UzK0xrLyjSOKoU65ygXD67SJvc36BK3wmPRwhkcI3o+mEpUXwkQdxPUmwmTTuhrDudx6pwgXfpQN2b4ysbF/Ov44HFqwQ6OFVdXvSolJ+Bf67gbOKlzgBsvR8QQpioDM0mHEMJUoO7hhtQ5PTlfCP3s/HlcIijnrOXyxzvjouoh0zmEuWN3EQGj+R24Y166dCkA4MwzzyzbDhw4AKDdCHHRBlXURSVMlGU+MAU23AnRwUJLSC1M99TOgaYDQ2P8mNnpjDPOKNtoYep2lixZAqDdCicubtF5SdZ5edJCUguZFpIWPKBlqBaVs/CdhTSWzE+DAEPMdu3aVbYxVE1vIrwZ6Vig16imZ2Sblq90qgpvDnVOYu6m6WoH04LWscVxSWkPAA4ePAig3SGQfXGhZIqLI61yEqtz4JqKRTJCmGjiOBZCCCE0lMjdIYQwATj1wMUZU71QqZbKVzcKRJWs7vwsnM+K+mi40qMuzzw/u1BUxflDuIQ/TkpX5Ynqp5Z7dWpUt+F/TfF3mJBJ2sljY8E5WTGO1DmTuQvl6ijrOjqIKW12Wt+17v2FS4fHY9FsT5TuVe6mrK9yJpfTH3XdgKyKa+00DnUQJMv9+/cDaHcce+GFFwD4msvqHMh3XWvWrBnRphK4e3/nssoR5/XqxpHeqHjT1DhuOgxq1ji26X47fRfX7Xu3sVz/untBL+8NQ5iKxJIOIYQO6bfBUZWsSf1r+HDmUg7rw6F7wHZZyNxyzhqu8ydwVfmqKp25B+O6POIu7MyFkLk+ON+cQUuGM6GTdC8nxDk9uWxJLrzEDSBnYaqc4gYnB4FKNi4HuBt0pC62kP1XecllgOJnd+x1x1lHp+ExgzCwCW94mtecyoTLk66hdzyHZ599dtnmHAGrwpQUJ20S5zjoQvTcDUb3W3VzraNbq7kXj1cXhubOaafW/yCNxRB6IY5jIYQQQkOJ3B1CCJOEU1yoNqhaRrXEOVE56Ve34xQjxYWlElUPqdipckNZWkMX62KdiVMeuT0X4qjLqjTP1wKayIrnzvkC9YuJqujX+Em6KiazznOvSo5z1VgAX/aRA0adirRoB+FgqhucTu7mfvU9FGOiGfsK+OxivXh+dsugyoruRuUkYSfD8locOnSobOMYWLhw4Yh9uSxvDidju3dn7nWIc3h0r2H6Vf6xajud5kJwk4T2me9W9d39wnAAAAj5SURBVHj5qqeqDOjwPoQwFWn8JB1CCE2h32E5Vb4GaknTF8VZhqPl/XYPng4XlkXDxOUC135xHY126DZ5TV22NbWkiRozjNZ46aWXyjb69oynJT1RjGmSnsg4sl4ymHXqCOMsWrWkHfzRMCQHaMXr6aByltLw74DWoFOr+eWXXwbQnoeZIVrqKNfvfMiOQbde6py1nBMWw9yeffbZso3W8ooVK8o2Sn26PY4Bra1bVRDBjWmXx11D9Lg/F4+q46OqWEId3d5cO8XdhFW2dWU93X4HtUZwCJ2SER5CCCE0lMjdIYTQIf2Ik3a+NC7jGP1PAGDfvn0A2pPUUKVRBcLlgK+rasf1VbLu1FeCKpI6jlWFf9YV03DheA5VlHhu9Hxx205p6SU81TEQBTa67WS/EwCMB7y4KheycAUrqwDe0YtFN3SwOzhwVMpjkQR1UuK29YfZqXNSv0sBTrTE3a/9VTnVuR+rXne+8tB3cJTA+R4M8FV/KIefddZZZRtvZHpTdd6q7LPGzLMPenOi86CrcuTeJY7llUXdb9fdDKvOuctr4Ap7uO01JV1jCBNBLOkQQphAnHXqvtdKd0899RQAYPPmzWXb+eefP2Ib7mGvLsmOC+VyWchcxTZXOrLKB0K351Li0qdCLXP9zGPRin8MvXK14J0jXdUD4GjrTqYfTteT9FTwlgPqn8adLKOZv2hl0bkLaA0mdeSpKgmo54+WklrNHHT6I6vKxDTI12M0xnpMziGsCv0B84ai14S50/W6E73ZUHXRpP9V1qa7ubq+qAXqstSxzYV59fLbdWO1Kkd9p1auS0FZF2bpct6HMNWJ41gIIYTQUCJ3hxBCl/QSElq1HacYaMKiv//97wCAxx9/vGxbtmwZgPbqfCoNU9FTpcUVnnA+FUTVIZeIxqkqLlkT1RJXYEP3Qdlc5XM9JiqOGqpKP5661whVoapN9nOYtpN0N4n7XWlMV4Kw3xd6KsrXg4Q7/67CD9HxQY9TlsrsZV/dfN8tY3Ec6zRJxlj60qmzW34jYaozbSfpEELolV4eyKtSHLswJH0Q3Lt3LwDgd7/7Xdl25plnAgCuuOKKsk0tUOeExW278pbOQlbLl9awe0DVB7YqPxD3UOWsdW1TC5lOYppgiKFXroRmv5y/eqn4VrWNbtbNJN1H8lQfSL9iMZuCk2PH8xirnNNG61cIU5E4joUQQggNJZZ0CCF0yFj8TrqtFKayMuOC1XFs1apVAICVK1eWbZTAgfZyj4Qyt8tw5spcuqQ4ql64EprcjiotrpAIpXm3X5XZNYEPZW6Vu+kf5Mp4Kp0mgmoamaRDCI1jIorGhDAIZJIOIUxL+hVG1Q/qapvTCtT81H/6058AAOvWrSvbFi9eXH5mzXvdDkOYtM1Z11U5tDutTOa258phapvzd9B0zH/9618BtIdgEXWa4zbrsq05qtLPTsZDY95JhxBCCA0lk3QIIYTQUCJ3hxBCBeMphTt5l23OaUvl2+effx4A8OCDD5Zty5cvLz9TBmdJS8AXyeA2VcZ2kjXXUcmXTmeu6IaLxdbl2C9tY30ElfXVWe7JJ59sW06PSZ3F2C89X936OTTldUgs6RBCCKGhxJIOIYRJRi1pWrRqYTorlrm9H3300bJNHcdoWa5evbpsY/YxV/PepTrWbGW0jLWvLgTLOYmxL3pMRK1iptF97LHHyradO3eWn1m+U88D96NtLjvaWJy+JjPKIJZ0CCGE0FAySYcQQggNJXJ3CGHa06TYWEq0LjuXOkdRamapRqC9AAe/v/baa8u2tWvXAvCZyXTblL7rcrYzE5q2LVy4EEC7VM5j0uxhrBTHfwHgmWeeAQD87W9/K9tYXARoSe7aV54ndXxzxT3GQpXj2HiPj1jSIYQQQkMZApC8eyGEaU23NbLryk0O/66T7QzHhT9pOUluW52jdJ2lS5cCaM9IdtVVVwEALr/88rJtxYoVANpDtWiVqnVKBy/NAMaQKGYyA4A1a9YAaHdie/vttwEAL7zwQtm2e/fuEW10DKNTHNAeykUnMZd7XJdz5TQngqrrrd91U0EulnQIIYTQUDJJhxBCCA0lcncIYdrTqdw9WZmn2C+Vu/lZpVMnfc+dO7dsW7ZsGYD28pbMUqbOZKeddhqAdgetY8eOAQD27NlTtrFkpDpqUT5ftGhR2fb6668DaGVJA1oObyptO4cvjbfmMelxUuaeLIlbidwdQgghTCNiSYcQpj1Nt6S5X7Vs6UzmSj0O/zx8O5r5iyUt58+fX7YxjMo5kx05cqRse/PNN0fsg6FXrkSmhmA5q5nrjHaeaYHqup1a0P0IlXIOg50SSzqEEEKYYmSSDiGEEBpK5O4QwrSnH3HSdcuNBW5Ht0eZ2zlWjbYOcbK4ruvKP5L333+//Owka+6vU+nd9dmVwwRaknuncnG/s4FF7g4hhBBCSXJ3hxDCGHDWHxlLxrE6aI3pPnR7zlJ1FrLrP7etGceqrHnFOX9VWY7dlJjsxgId3oeqfU+WQ2AnxJIOIYQQGkom6RBCCKGhRO4OIYQ+MNGSKaXabiR1Jxe7ohVsc/K5o875yxUDYV+0jZ/rjqnfDmFj2d54ZzqLJR1CCCE0lIRghRCmPWMJwSL9su46tcjH0gdd1zl6uW27c8P9sYxl6D+xpEMIIYSGkkk6hBBCaChxHAshhP9PVWas0ZZrQonEMHWJJR1CCCE0lDiOhRBCCA0llnQIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA0lk3QIIYTQUDJJhxBCCA3l/wGBfPNPVZPwqQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotting.plot_epi(image.mean_img(opj(out_path, 'fwhm-5_ssub-01_ses-test_task-fingerfootlips_bold.nii')),\n", + " title=\"fwhm = 5mm\", display_mode='ortho', annotate=False, draw_cross=False, cmap='gray');" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotting.plot_epi(image.mean_img(opj(out_path, 'fwhm-10_ssub-01_ses-test_task-fingerfootlips_bold.nii')),\n", + " title=\"fwhm = 10mm\", display_mode='ortho', annotate=False, draw_cross=False, cmap='gray');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's investigate the motion parameters. How much did the subject move and turn in the scanner?" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "par = np.loadtxt('/output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold.par')\n", + "fig, axes = plt.subplots(2, 1, figsize=(15, 5))\n", + "axes[0].set_ylabel('rotation (radians)')\n", + "axes[0].plot(par[0:, :3])\n", + "axes[1].plot(par[0:, 3:])\n", + "axes[1].set_xlabel('time (TR)')\n", + "axes[1].set_ylabel('translation (mm)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There seems to be a rather drastic motion around volume 102. Let's check if the outliers detection algorithm was able to pick this up." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outliers were detected at volumes: [ 59. 102.]\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "outlier_ids = np.loadtxt('/output/datasink/preproc/sub-01/task-fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt')\n", + "print('Outliers were detected at volumes: %s' % outlier_ids)\n", + "\n", + "from IPython.display import SVG\n", + "SVG(filename='/output/datasink/preproc/sub-01/task-fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold.svg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternative for motion artifacts detection [ICA-based Automatic Removal Of Motion Artifact](https://nipype.readthedocs.io/en/0.13.1/interfaces/generated/interfaces.fsl/ICA_AROMA.html)\n", + "\n", + "\n", + "**Dataset:**\n", + "[A test-retest fMRI dataset for motor, language and spatial attention functions](https://openneuro.org/datasets/ds000114/versions/1.0.1)\n", + "\n", + "**Special thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/seminar4/utils.py b/seminar4/utils.py new file mode 100644 index 0000000..f668d10 --- /dev/null +++ b/seminar4/utils.py @@ -0,0 +1,10 @@ +import os + +def list_files(startpath): + for root, dirs, files in os.walk(startpath): + level = root.replace(startpath, '').count(os.sep) + indent = ' ' * 4 * (level) + print('{}{}/'.format(indent, os.path.basename(root))) + subindent = ' ' * 4 * (level + 1) + for f in files: + print('{}{}'.format(subindent, f)) \ No newline at end of file