05_aml-pipeline.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#all_slow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the model on an Azure AML cluster\n",
    "The Detectron model was developed on an Azure virtual machine (VM) but we decided to port it to an [Azure Machine Learning (AML) Workspace](https://docs.microsoft.com/en-us/azure/machine-learning/concept-workspace) so that it could run on an [AML cluster](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-create-attach-compute-cluster?tabs=python).  Clusters can be started and stopped easily, as well as scaled up and down in size, and can be easily incorporated into [Azure pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/?view=azure-devops); see `00_azure_notes.ipynb` for comments about the differences between AML workspaces and VMs.  \n",
    "\n",
    "The most flexible and powerful method for controlling a workspace and cluster is the AML Python SDK, which is called [azureml-sdk](https://docs.microsoft.com/en-us/python/api/overview/azure/ml/?view=azure-ml-py).  In addition to learning the new package, the required steps are:\n",
    "1. Install the `azureml-sdk` on your local machine (wherever you want to run it from).  On a Mac, the installation can be difficult.\n",
    "2. Copy images, annotations and model to the workspace blobstore;\n",
    "3. Containerize your environment.  For a customized environment, this is not particularly easy and requires you to get familiar with Docker;\n",
    "4. Upload your Docker container to a special AML workspace Docker repository;\n",
    "5. Upload your data to an AML workspace blobstore;\n",
    "6. Convert your operating script into a .py file (if you haven't already)\n",
    "7. Write an `azureml-sdk` script to initialize a cluster, call your operating script, and start the run.\n",
    "8. Figure out how to find results in the AML workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check core SDK version number\n",
    "import azureml.core\n",
    "from azureml.core import Workspace, Datastore, Dataset, Environment, Experiment, Model\n",
    "from azureml.core.run import Run\n",
    "from azureml.core.runconfig import RunConfiguration\n",
    "from azureml.core.compute import ComputeTarget, AmlCompute, RemoteCompute, ComputeTarget\n",
    "from azureml.core.compute_target import ComputeTargetException\n",
    "from azureml.train.estimator import Estimator\n",
    "from azureml.core.conda_dependencies import CondaDependencies\n",
    "from azureml.core.authentication import InteractiveLoginAuthentication\n",
    "from azureml.data.datapath import DataPath\n",
    "\n",
    "#Other stuff\n",
    "import os\n",
    "import glob\n",
    "import shutil\n",
    "from pathlib import Path\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "%matplotlib inline\n",
    "print(\"SDK version:\", azureml.core.VERSION)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reminders: \n",
    "#### Detectron2 version issues\n",
    "Each version of Detectron2 requires a specific version of CUDA.  If you plan on developing on a VM and then transferring the model to an AML cluster, make sure that the CUDA versions are the same, or it won't work.\n",
    "\n",
    "**Differences between versions of Detectron2:**  \n",
    "- This (older) version of Detectron2 uses an image augmentation class called TransformGen, which has been renamed to Augmentation in the newer version.\n",
    "\n",
    "#### General\n",
    "- You should be on your local machine to run `azureml-sdk`. \n",
    "- **Don't edit .py files in the /runfiles directory.**  This library was generated with the `nbdev` package.  `nbdev` makes it easy to write code in Jupyter notebooks and then export it to .py files.  All of the .py files in the `runfiles/trident_dev` folder were generated from notebooks in the `/nbs` folder.  \n",
    "Edit the notebooks instead.\n",
    "- `nbdev_build_lib` will regenerate the `.py` files and put them into `/trident_dev/runfiles/trident_dev`; i.e., \n",
    "    - the directory (package) is named for the project\n",
    "    - it puts the directory inside `/runfiles` so they are included when I run a Docker container with AML. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List your credentials\n",
    "It saves a lot of time to fill these out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlsubscription = '<subscription>'\n",
    "mlresourcegroup = '<resource_group>'\n",
    "mlworkspace = '<workspace_name>'\n",
    "mlstorage = '<workspace_storage_account>'\n",
    "mlcontainerregistry = <workspace_docker_container_registry>' #A single-word name \n",
    "full_mlcontainerregistry = '<name.azurecr.io>' \n",
    "mlkeyvault = '<workspace_keyvault>' #if used\n",
    "aad_tenant = '<active_directory_tenant>'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Log in\n",
    "interactive_auth = InteractiveLoginAuthentication(tenant_id = aad_tenant)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Move data to blob storage (if needed)\n",
    "Before the model will run, we need a number of things to be in the AML workspace blobstore:\n",
    "1. Training and validation images\n",
    "2. Training and validation annotations\n",
    "3. A file that tells the model how to split them between training and validation sets (for Detectron2, it's just a text file). \n",
    "4. The model file (weights, optimizer state, etc., usually as a .pkl file)\n",
    "\n",
    "See the bottom of `04_tile_training_images.ipynb` for one way to move files from a VM to an AML workspace blobstore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create or get a workspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a workspace from a config file\n",
    "# from azureml.core.workspace import Workspace\n",
    "# ws = Workspace.from_config()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Get an existing workspace\n",
    "ws = Workspace.get(mlworkspace, auth=interactive_auth, subscription_id=mlsubscription, resource_group=mlresourcegroup)\n",
    "ws.get_details() #shows container registry, among other things"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Containerize the environment (only once, if new)\n",
    "For background on Docker containers, images, and \"Dockerfiles\", see my 'Docker' notes.  In brief, the steps are: \n",
    "1. Create a Dockerfile that describes the environment\n",
    "2. Build an image from it on the local machine (or VM)\n",
    "3. Upload the image to the AML workspace docker container repository\n",
    "\n",
    "#### Two warnings:\n",
    "**Docker images can quickly fill your Azure DSVM's operating disk**.  \n",
    "If you're working on an Azure Data Science Virtual Machine (DSVM), the default machines come with an operating disk that is almost full.  Docker puts images on it by default so you can quickly run out of memory when building Docker images, which is a _giant_ hassle.  The solution is to put the Docker images somewhere else, for example on a data disk.  You can set the default as follows:\n",
    "\n",
    "```bash\n",
    "sudo service docker stop\n",
    "vim /etc/docker/daemon.json\n",
    "```\n",
    "Change the following line to fix the path (leave everything else as-is)\n",
    "```json\n",
    "{ \"graph\": \"/new/image/repository/path\" }\n",
    "```\n",
    "Restart:\n",
    "```bash\n",
    "sudo service docker start\n",
    "```\n",
    "Changes won't take effect until you restart.  \n",
    "**2.  AML workspaces don't come with Docker repositories by default**\n",
    "By default, a new AML workspace doesn't include a Docker repository, and I never found a way to force it to instantiate one.  It's an annoying Catch-22 if you have just created a new Workspace.  The only thing that worked was to attempt to run a script (i.e., get all the way through the steps below), and as long as the script contained some indication that you were trying to use a custom image (for example, `trident_env.docker.enabled = True`, the repository would then be automatically created, even if the run totally failed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Create a Dockerfile (if a custom environment is needed)\n",
    "This is fairly complicated; see `/notes/Docker.md` for notes and `notes/Dockerfile17` for the actual file I used.\n",
    "\n",
    "### 2. Build a Docker image\n",
    "```bash\n",
    "cd <path to docker image on local machine>\n",
    "docker build -f <image_name> -t <image_repository>.azurecr.io/<image_name>:<img_version> .\n",
    "```\n",
    "### Optional: Run the container and drop into it for debugging\n",
    "```bash\n",
    "docker images #get the image ID\n",
    "#-v mounts a volume\n",
    "#<source_dir> = local path to the files that you want to mount inside the container\n",
    "#<dest_dir> = path to those files inside the container\n",
    "#-p port \n",
    "docker run -it -v <source_dir>:<dest_dir> -p 5678:5678  <image_id> /bin/bash\n",
    "```\n",
    "### 3. Push the image to your AML workspace repository\n",
    "I find the login process annoyingly opaque, but it works.\n",
    "```bash\n",
    "az login --tenant '<your_tenant_id>'  #Yes, you must do this step first!\n",
    "az acr login --name <image_repository>.azurecr.io \n",
    "docker push <image_repository>.azurecr.io/<image_name>:<image_version>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Register the environment with the AML workspace (once)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trident_env = Environment(name=\"trident\") #Instantiate an Environment object\n",
    "trident_env.python.user_managed_dependencies = True #CRITICAL!\n",
    "trident_env.docker.enabled = True\n",
    "trident_env.docker.base_image = 'tridentbase:v17'\n",
    "trident_env.docker.base_image_registry.address = full_mlcontainerregistry\n",
    "trident_env.inferencing_stack_version='latest'\n",
    "\n",
    "#Register the environment\n",
    "trident_env.register(ws)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I didn't use the \"conda_dependencies\" property because it was not flexible enough for my needs.  I leave it here in case it's useful to someone else. Note that azureml-defaults seems to be added automatically, even if you don't include it anywhere."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Get the existing conda dependencies\n",
    "#conda_dep = trident_env.python.conda_dependencies\n",
    "#conda_dep.add_pip_package(\"imgaug\")\n",
    "#conda_dep.add_pip_package(\"adabound\") #FAILED"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get a registered environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trident_env = Environment.get(ws,\"trident\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up an AML workspace dataset\n",
    "This is just a way of telling the AML workspace where to find your data. A `FileDataset` is really just a name for a blob, and nothing happens until it's mounted.  Once it's mounted, then you have to use other tools to get its paths.  Here we define a `FileDataset` for the `<sourcedir>` directory, which has subdirectories.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "datastore_paths = [(datastore, '<sourcedir>')]\n",
    "image_ds = Dataset.File.from_files(path=datastore_paths)\n",
    "\n",
    "#Register the dataset with the AML workspace\n",
    "image_ds.register(workspace=ws,\n",
    "                     name='image_ds',\n",
    "                     description='whatever',\n",
    "                     create_new_version=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get an existing dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_ds = Dataset.get_by_name(ws, name='image_ds') \n",
    "#or get by ID:\n",
    "Dataset.get_by_id(ws,id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check workspace and datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Workspace name: ' + ws.name, \n",
    "      'Azure region: ' + ws.location, \n",
    "      'Subscription id: ' + ws.subscription_id, \n",
    "      'Resource group: ' + ws.resource_group, sep='\\n')\n",
    "#ws.get_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#List all datastores registered in the current workspace:\n",
    "datastores = ws.datastores\n",
    "for name, datastore in datastores.items():\n",
    "    print(name, datastore, datastore.datastore_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional: Check the files\n",
    "1. The best way to interact with AML blobstores is via the [Microsoft Azure Storage Explorer](https://azure.microsoft.com/en-us/features/storage-explorer/#overview), which is a standalone program. It's worth taking a minute to install it. In Storage Explorer, the file display is paged but you can count files in a directory by right-clicking on a folder and clicking \"Selection Statistics\".\n",
    "2. Alternatively, the following `azureml-sdk` commands work, but are slow to execute.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Warning -- these are SLOW to execute\n",
    "fs = image_ds.to_path() #Get all filenames\n",
    "#Take a sample of 5\n",
    "image_ds.take(5).to_path()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deploy a cluster\n",
    "This will check to see if a cluster is already running before creating one.  If it finds a cluster of the same name, it will use it instead of creating a new cluster.  WARNING: starting a cluster from a script that is running on machine A (for example, your VM) and then trying to use it from a script running on machine B (for example, your local machine) will cause trouble.  If you need to switch, delete the cluster on A and recreate it on B.\n",
    "\n",
    "### Auto-stopping the cluster\n",
    "One of the nicest features of a cluster is that you can program it to shut down as soon as a run is over.\n",
    "On the `Compute` tab in AML Studio, you can edit the properties including the minimum nodes.  If you set the minimum nodes to 0, the cluster will power down when finished; if 1 or more, it will stay alive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#OPTIONAL: Get a list of supported VM sizes in your region (you'll need the name for the cluster)\n",
    "AmlCompute.supported_vmsizes(ws, location='eastus') #or 'westus2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found existing compute target.\n"
     ]
    }
   ],
   "source": [
    "from azureml.core.compute import ComputeTarget, AmlCompute\n",
    "from azureml.core.compute_target import ComputeTargetException\n",
    "\n",
    "# choose a name for your cluster\n",
    "cluster_name = \"gpu-cluster\"\n",
    "\n",
    "try:\n",
    "    mycompute_target = ComputeTarget(workspace=ws, name=cluster_name)\n",
    "    print('Found existing compute target.')\n",
    "except ComputeTargetException:\n",
    "    print('Creating a new compute target...')\n",
    "    #max_nodes is the number of VMs you are creating\n",
    "    #Try NC24r_Promo\n",
    "    compute_config = AmlCompute.provisioning_configuration(\n",
    "        vm_size= 'Standard_NC24rs_v3', #STANDARD_NC6S_V3', #'STANDARD_NC6', #'Standard_NC24rs_v2','Standard_NC24r','STANDARD_NC12S_V2',#'Standard_NC24r',\n",
    "        min_nodes = 0,#SET TO 0 FOR IT TO AUTO-STOP, OR TO 1 to keep alive\n",
    "        max_nodes=1) \n",
    "\n",
    "    # create the cluster\n",
    "    mycompute_target = ComputeTarget.create(ws, cluster_name, compute_config)\n",
    "    \n",
    "    mycompute_target.wait_for_completion(show_output=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get cluster status\n",
    "```python\n",
    "print(mycompute_target.get_status().serialize())\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Delete a cluster\n",
    "You can also delete it in the `Compute` tab of the AML Studio.\n",
    "```python\n",
    "mycompute_target.delete()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create or get an experiment\n",
    "An \"experiment\" is AML-speak for a run.  However, it's an inaccurate analogy, and storing all results from every experiment is not desirable, as I explain in `notes/00_azure_notes.ipynb`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This \"gets _or_ creates\" an experiment; i.e., if it already exists, it will return the existing one.\n",
    "experiment_name = 'expt10'\n",
    "experiment = Experiment(ws, name=experiment_name)\n",
    "experiment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Detectron2 conundrum: Resume or not?\n",
    ">\"If `resume==True` and `cfg.OUTPUT_DIR` contains the last checkpoint (defined by a last_checkpoint file), resume from the file. **Resuming means loading all available states (eg. optimizer and scheduler) and update iteration counter from the checkpoint.** `cfg.MODEL.WEIGHTS` will not be used.\" \n",
    "\n",
    "(I think because model weights are included in the checkpoint).\n",
    "\n",
    ">\"Otherwise, this is considered as an independent training. The method will load model weights from the file `cfg.MODEL.WEIGHTS` (but will not load other states) and start from iteration 0.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project script\n",
    "Okay, we've finally gotten to the important part, which is creating an `azureml-sdk` script that will call our main Python script and run all of this.  \n",
    "\n",
    "### Main module\n",
    "The Python 'main' module that runs our program (a.k.a. our \"project script\") is referred to by `azureml-sdk` as the `entry_script`. \n",
    "\n",
    "### Attaching files\n",
    "The way the script handles mountable files is important to understand.  When you submit the training run, a snapshot of the directory that contains your training scripts is created and sent to the compute target, and it may be mounted as a volume in your Docker container, depending on how you have it set up. In the cell below, it is called `project_folder`.  That means you have to think about what you want to put in that directory.  I use it for my own Python modules that I haven't turned into packages yet.\n",
    "\n",
    "The `project_folder` is also stored as part of the `Experiment` in your workspace. If you change files and submit the run again, only the changed files will be uploaded.  To prevent unnecessary files from being included in the snapshot, make an ignore file (.gitignore or .amlignore) in the directory, and add the files and directories to exclude to this file.\n",
    "\n",
    "### Adding command-line arguments\n",
    "`script_params` are regular Linux command-line arguments that are passed to the project script when it runs. They must be parsed and handled internally by your Python main module. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#'as_named_input()' looks for a dataset registered to the workspace under that name\n",
    "#At this stage, data_folder is a \"DatasetConsumptionConfig\" object.  It gets converted during the run to a directory name.\n",
    "\n",
    "script_params = {\n",
    "    # Mount image_ds and pass the mount point name as the data folder argument \n",
    "    '--data_folder': image_ds.as_named_input('image_ds').as_mount(),\n",
    "    \n",
    "    #To load the model *and optimizer state* from file, set 'resume':None.  \n",
    "    #To load only the model, omit the line (default is resume=False)\n",
    "    '--resume': None,\n",
    "    '--output_dir':  './outputs',\n",
    "    '--num_gpus_per_machine':4,\n",
    "    '--num_machines':1,\n",
    "    '--machine_rank':0,\n",
    "    '--dist_url':\"auto\",\n",
    "#    '--eval_after_training':None\n",
    "    '--write_annotated_images':None,\n",
    "    '--eval_only':None #Will trigger evaluation if present (omit the line for training)\n",
    "}\n",
    "\n",
    "project_folder = '...path/to/trident_dev/runfiles/' \n",
    "\n",
    "est = Estimator(source_directory=project_folder,\n",
    "              script_params=script_params,\n",
    "              compute_target=mycompute_target,\n",
    "              environment_definition=Environment.get(workspace=ws,name=\"trident\"),\n",
    "              entry_script='distrib_run_and_inference.py')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Finally, run the experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run = experiment.submit(est)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cancel a run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run.cancel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy the model weights between runs\n",
    "When training a model on an AML cluster, you have to replace the model weights in your `project_folder` with the weights from the latest run between runs, or you will be starting from scratch again.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing run output\n",
    "### From the portal\n",
    "You can check output simply by typing:\n",
    "```python\n",
    "run\n",
    "#or\n",
    "experiment\n",
    "```\n",
    "### From a notebook or script\n",
    "```python\n",
    "# access the run id for use later\n",
    "run_id = run.id\n",
    "\n",
    "#Attach to a run\n",
    "run = Run(<experiment>, run_id)\n",
    "#or\n",
    "run = <experiment>.get_runs(<run_id>)\n",
    "\n",
    "#Get all run metrics.  Detectron stores metrics in metrics.json, which is only available after the run.\n",
    "run.get_metrics()\n",
    "\n",
    "#Get a particular metric\n",
    "run.get_metrics(name = \"scale factor\")\n",
    "\n",
    "#Get the filenames of files that were uploaded to the run\n",
    "run.get_file_names()\n",
    "\n",
    "#Download those files to your local machine\n",
    "import os\n",
    "os.makedirs('files', exist_ok=True)\n",
    "\n",
    "for f in run.get_file_names():\n",
    "    dest = os.path.join('files', f.split('/')[-1]) #Use the filename; drop the path\n",
    "    print('Downloading file {} to {}...'.format(f, dest))\n",
    "    run.download_file(f, dest)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Livestream logs (every 10-15 seconds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from azureml.widgets import RunDetails\n",
    "RunDetails(run).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assess training progress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Understanding the Detectron2 output\n",
    "Reminder: don't interpret the slash in the name as division: it just identifies a model component.  For example, `fast_rcnn/cls_accuracy` means the \"class accuracy of the RCNN\"\n",
    "- `fast_rcnn/cls_accuracy` = num_accurate / num_instances (Want this to be 1)\n",
    "- `fast_rcnn/fg_cls_accuracy` = fg_num_accurate / num_fg (Want this to be 1)\n",
    "- `fast_rcnn/false_negative` = num_false_negative / num_fg) (Want this to be zero)\n",
    "- `roi_head/num_fg_samples` The number of fg samples that are selected for training ROI heads =mean(num_fg_samples)\n",
    "- `roi_head/num_bg_samples` The number of bg samples that are selected for training ROI heads =mean(num_bg_samples)\n",
    "- `rpn/num_pos_anchors` the number of positive anchors per-image used in training = num_pos_anchors/num_images\n",
    "- `rpn/num_neg_anchors` the number of negative anchors per-image used in training = num_neg_anchors/num_images\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where are my output files?\n",
    "Answer: The latest one is displayed in AML Studio, but earlier runs are very hard to find.  Use the Microsoft Azure Storage Explorer. They are in the workspace blobstore container:\n",
    "- `azureml-blobstore-<container>/azureml/<run_results>/outputs`  \n",
    "For `<run_results>`, choose one of the folders, noting that:   \n",
    "1. The files are in backwards date order (oldest on top)\n",
    "2. There are TWO folders for each run; one of them has a name that ends in '-setup' and the other is the results.  Look for the place where folders end and files start; your folder will be the latest one that doesn't end in '-setup'.\n",
    "3. There are also two files per run; one is a zip and the other has 0 bytes; I think the zip probably has everything but I haven't checked.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Register the model\n",
    "This is not necessary unless you are deploying a model for production (in an Azure Container or something similar).  Registering the model makes the workspace track it and version it.  There's nice documentation [here](https://docs.microsoft.com/en-us/azure/machine-learning/tutorial-train-models-with-aml) and in part 2 of the same tutorial, they do deployment.\n",
    "\n",
    "The `model_path` parameter takes in the relative path on the remote VM to the model file in your `outputs` directory. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from azureml.core.model import Model\n",
    "# Tip: When model_path is set to a directory, you can use the child_paths parameter to include\n",
    "#      only some of the files from the directory\n",
    "# Register model\n",
    "model = run.register_model(model_name='tridentmodel_expt7_run1',\n",
    "                           model_path='outputs/model_final.pth',\n",
    "                           description = \"Expt7_run1 on 25K dataset v2s 21Aug2020\")\n",
    "print(model.name, model.id, model.version, sep='\\t')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot training progress\n",
    "Detectron saves all results in a file called `metrics.json`, but AML Studio doesn't know about that.  To push the metrics to AML would have meant getting into the plumbing of the Detectron2 reporting, and I never bothered.  Instead, I just saved certain results from the metrics file after each run.  I'm not proud of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "traindir = Path('/Users/johntwo/Documents/tanzania_project/training_history/training_on_800x800')\n",
    "\n",
    "run5 = {'runmetricsfile': traindir/'metrics_run5_2020dec10.json', 'training_time_h': 0.78, 'nreps': 500, 'max_lr': 0.0005}\n",
    "run7 = {'runmetricsfile': traindir/'metrics_run7_2020dec10.json', 'training_time_h': 0.8, 'nreps': 500, 'max_lr': 0.005}\n",
    "run8 = {'runmetricsfile': traindir/'metrics_run8_2020dec10.json', 'training_time_h': 1.39, 'nreps': 1000, 'max_lr': 0.0005}\n",
    "run10 = {'runmetricsfile': traindir/'metrics_run10_2020dec10.json', 'training_time_h': 3.77, 'nreps': 7500, 'max_lr': 0.0005}\n",
    "run11 = {'runmetricsfile': traindir/'metrics_run11_2020dec11.json', 'training_time_h': 7.15, 'nreps': 18000, 'max_lr': 0.0004}\n",
    "run12 = {'runmetricsfile': traindir/'metrics_run12_2020dec11.json', 'training_time_h': 9.45, 'nreps': 25000, 'max_lr': 0.0003}\n",
    "run15 = {'runmetricsfile': traindir/'metrics_run15_2020dec12.json', 'training_time_h': 5.35, 'nreps': 12500, 'max_lr': 0.0005}\n",
    "run16 = {'runmetricsfile': traindir/'metrics_run16_2020dec12.json', 'training_time_h': 3.78, 'nreps': 7500, 'max_lr': 0.0001}\n",
    "run17 = {'runmetricsfile': traindir/'metrics_run17_2020dec13.json', 'training_time_h': 8.47, 'nreps': 22000, 'max_lr': 0.0003}\n",
    "run18 = {'runmetricsfile': traindir/'metrics_run18_2020dec14.json', 'training_time_h': 7.83, 'nreps': 20000, 'max_lr': 0.0003}\n",
    "x5_run16 = {'runmetricsfile': traindir/'metrics_x5_r16_2Jan2021.json', 'training_time_h': 7.19, 'nreps': 22000, 'max_lr': 0.005}\n",
    "x6_run5 = {'runmetricsfile': traindir/'metrics_x6_r5_24Jan2021.json', 'training_time_h': 1.23, 'nreps': 5000, 'max_lr': 0.005}\n",
    "x6_run7 = {'runmetricsfile': traindir/'metrics_x6_r7_24Jan2021.json', 'training_time_h': 3.2, 'nreps': 10000, 'max_lr': 0.005}\n",
    "x6_run8 = {'runmetricsfile': traindir/'metrics_x6_r8_25Jan2021.json', 'training_time_h': 3.15, 'nreps': 10000, 'max_lr': 0.005}\n",
    "x7_run1 = {'runmetricsfile': traindir/'metrics_x7_r1_26Jan2021.json', 'training_time_h': 3.15, 'nreps': 10000, 'max_lr': 0.01}\n",
    "x7_run2 = {'runmetricsfile': traindir/'metrics_x7_r2_27Jan2021.json', 'training_time_h': 3.15, 'nreps': 10000, 'max_lr': 0.005}\n",
    "x7_run4 = {'runmetricsfile': traindir/'metrics_x7_r4_27Jan2021.json', 'training_time_h': 3.15, 'nreps': 10000, 'max_lr': 0.005}\n",
    "x1_run4 = {'runmetricsfile': traindir/'metrics_x1_r4_6Feb2021.json', 'training_time_h': 7.9, 'nreps': 25000, 'max_lr': 0.004}\n",
    "x1_run5 = {'runmetricsfile': traindir/'metrics_x1_r5_6Feb2021.json', 'training_time_h': 0.62, 'nreps': 2000, 'max_lr': 0.0025}\n",
    "x1_run6 = {'runmetricsfile': traindir/'metrics_x1_r6_7Feb2021.json', 'training_time_h': 7.85, 'nreps': 25000, 'max_lr': 0.02}\n",
    "x1_run7 = {'runmetricsfile': traindir/'metrics_x1_r7_7Feb2021.json', 'training_time_h': 7.87, 'nreps': 25000, 'max_lr': 0.0025}\n",
    "x1_run8 = {'runmetricsfile': traindir/'metrics_x1_r8_8Feb2021.json', 'training_time_h': 11.08, 'nreps': 35000, 'max_lr': 0.0025}\n",
    "x1_run9 = {'runmetricsfile': traindir/'metrics_x1_r9_8Feb2021.json', 'training_time_h': 7.87, 'nreps': 25000, 'max_lr': 0.0025}\n",
    "x2_run1 = {'runmetricsfile': traindir/'metrics_x2_r1_9Feb2021.json', 'training_time_h': 12.57, 'nreps': 40000, 'max_lr': 0.0025}\n",
    "x2_run2 = {'runmetricsfile': traindir/'metrics_x2_r2_9Feb2021.json', 'training_time_h': 3.15, 'nreps': 10000, 'max_lr': 0.00125}\n",
    "x2_run3 = {'runmetricsfile': traindir/'metrics_x2_r3_9Feb2021.json', 'training_time_h': 3.13, 'nreps': 10000, 'max_lr': 0.0012}\n",
    "x2_run4 = {'runmetricsfile': traindir/'metrics_x2_r4_10Feb2021.json', 'training_time_h': 12.68, 'nreps': 40000, 'max_lr': 0.0012}\n",
    "x2_run5 = {'runmetricsfile': traindir/'metrics_x2_r5_10Feb2021.json', 'training_time_h': 3.15, 'nreps': 10000, 'max_lr': 0.0012}\n",
    "x2_run6 = {'runmetricsfile': traindir/'metrics_x2_r6_10Feb2021.json', 'training_time_h': 3.13, 'nreps': 10000, 'max_lr': 0.0012}\n",
    "x2_run7 = {'runmetricsfile': traindir/'metrics_x2_run7_11Feb2021.json', 'training_time_h': 7.9, 'nreps': 25000, 'max_lr': 0.0025}\n",
    "x2_run8 = {'runmetricsfile': traindir/'metrics_x2_r8_11Feb2021.json', 'training_time_h': 3.81, 'nreps': 10000, 'max_lr': 0.001}\n",
    "\n",
    "runlist = [run5, run7, run8, run10, run11, run12,run15,run16, run17,run18,x5_run16,x6_run5,x6_run7,x6_run8,x7_run1,x7_run2,x7_run4,\n",
    "           x1_run4,x1_run5,x1_run6,x1_run7,x1_run8,x1_run9,x2_run1,x2_run2,x2_run3,x2_run4,x2_run5,x2_run6,x2_run7,x2_run8]\n",
    "\n",
    "training_df = pd.DataFrame(runlist)\n",
    "training_df_last4 = pd.DataFrame(runlist[-4:])\n",
    "training_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total training hours:  165.70000000000005 ; NC machine cost: $ 2028.1680000000006\n"
     ]
    }
   ],
   "source": [
    "#Calculate training cost  The v3 x4GPU machine costs $12.24/hour\n",
    "training_hours = sum(training_df['training_time_h'])\n",
    "cost = 12.24 * training_hours\n",
    "print('Total training hours: ',training_hours,'; NC machine cost: $', cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_trainmetrics_files(training_df):\n",
    "    training_files = list(training_df['runmetricsfile'])\n",
    "    metdata = []\n",
    "    n = 0\n",
    "    for metricsfile in training_files:\n",
    "        mfile = open(metricsfile, 'r')\n",
    "        lines = mfile.readlines()\n",
    "        mfile.close()\n",
    "\n",
    "        for i in range(len(lines)):\n",
    "            n += 20\n",
    "            ld = json.loads(lines[i])\n",
    "            ld['iter_global'] = n\n",
    "            metdata.append(ld)\n",
    "\n",
    "    metdf = pd.DataFrame(metdata)\n",
    "    return metdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finally, get a look at the results\n",
    "The big reset in the middle happened when we decided to drop the 'boma' category and re-train, starting with the ROI heads with the rest of the model frozen.  It required a lot of experimentation with learning rate schedules to make progress, as shown in the lower panel.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAscAAAGoCAYAAACqvEg8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd3gUVffHv7MlZZPddNIoSSihhA4KiICgiAooKFiwgL3wqq9dbK+9/izYK1hQRBENFkQQQQSVYpCShJIASUhvu8mmbJnfH7OzO7s7OzszO7ubwP08T57szJx7z7l3ZnbP3Dn3XIqmaRAIBAKBQCAQCARAFW4DCAQCgUAgEAiErgJxjgkEAoFAIBAIBAfEOSYQCAQCgUAgEBwQ55hAIBAIBAKBQHBAnGMCgUAgEAgEAsGBJtwGSCE5OZnOysoKqc76+np0dnYCACIiIpCUlORXHoBfOTl2BKPeYOoVUzaU7QqFrq7QHqk2dHd5uWWUgtXNEg4buHaEsw/C1XapkL4KnFDcp6Svuk9fhVu/XHbt2lVH03SK5/5u5RxnZWVh586dIdW5fPlyHD9+HADQu3dvLFy40K88AL9ycuwIRr3B1CumbCjbFQpdXaE9Um3o7vJyyygFq5slHDZw7QhnH4Sr7VIhfRU4obhPSV91n74Kt365UBR1jG9/t3KOw4FOp4NarXZ+FiMfLDvCQSB6w9lf4dLVFdoj1YbuLi+3jFKEUzcX0gfiIX0VOKG4T0lfBVeHkoRbv9JQ3WkRkDFjxtChHjkmEAgEAoFAIJx8UBS1i6bpMZ77yYQ8AoFAIBAIBALBAQmr8MOGDRuwZ88eAMDw4cNx9tln+5UH4FdOjh3BqDeYesWUDWW7QqGrK7RHqg3dXV5uGaVgdbOEwwauHeHsg3C1XSqkrwInFPcp6avu01fh1q80xDn2Q3l5OVpbW52fxcgHy45wEIjecPZXuHR1hfZItaG7y8stoxTh1M2F9IF4SF8FTijuU9JXwdWhJOHWrzQkrIJAIBAIBAKBQHBAnGMCgUAgEAgEAsEBcY4JBAKBQCAQCAQHJObYDwaDARqNxvlZjHyw7AgHgegNZ3+FS1dXaI9UG7q7vNwyShFO3VxIH4iH9FXghOI+JX0VXB1KEm79ShOUPMcURX0EYCaAGpqm83iOUwBeA3A+ADOAhTRN7/ZXL8lzTCAQCAQCgUBQglDnOV4OYIbA8fMA9Hf83Qjg7SDZQSCcvDz0EDB0KPOfQCAQCASCIgQlrIKm6S0URWUJiFwI4BOaGbb+k6KoeIqi0mmarhSqt76+3rl+N8uQIUMwduxYWCwWrFixwqvMiBEjMGLECJjNZqxatcrr+JgxY5CXl4fm5masWbPG63hkZCTKy8tht9uh1WqRmJjodnzSpEnIyclBVVUV1q1bh4aGBgBwyk2bNg29evVCWVkZNm7c6FX/jBkzkJaWhpKSEmzZssXr+MyZM5GcnIwvvvgClZWVXvrnzJmDuLg47Nu3D3yj6vPnz4dOp0NBQQEKCgq8ji9YsABarRY7duzA/v37vY6npaUBYF6ZHDx40O2YVqvFggULAACbN29GaWmp23Gj0YgBAwZgxowZ2LBhg1eqF4PB4LbkZFVVldvxpKQkzJo1CwCwdu1a1NfXe9k2YwbzDPbNN9/AaDS6He/Zs6cz5+KqVauc+tk+zM7OxuTJkwEAK1asgMVicSs/YMAATJgwAQC8rjuA/9rjnv9Ar73x48cjNzcXdXV1+P77790PlpZCc+wYknr2xMiPPsI6jQbIznazYd68eaKuvS+//BIVFRVe1xZ77RUXF2P79u3O/Wz91113nahr79NPP0Vtba1X/b6uPbb+u+66CwCwbds2v9ferl27ALjOrU6nw/z58wHA57U3d+5cAMC6desCuvbeeOMNdHZ2Oo8lJiZ6XXtms9mtfLe+9hC67z3Pa48l0O+9Hj16QKVSISkpifd7b+HChQDEXXue33v+rr2Wlhb069cPM2bMCPjaE/O9F6xr78cff0RRUZHXfS107TU0NCA1NRULFiwQde198sknAOCmw/Pa86QrXnvc+8Pfby577S1btgyNjY1ubRe69hoaGqDRaHD77bcDCP73nue119DQgNjYWNx4440AQve9xyXQ7z0u4Yo5zgRQxtkud+zzco4piroRzOgyMjMzQ2Icl8bGRrS1tQEAxISgcH8klbYjWHULwd48cuKJOjo6vG4+X/WzTngwCUX/heoc2erq0JScDLNOh5EFBUB9vdM5lmqD1GtLav3Nzc1BrV9uGaVob2+H1WoNm36WcPZBOHXLobq6GhRFISkpKeS629vb/X4vdgeqq6sln/fOzk40NTVJkj8ZkNMOk8kk+XvTZrNJ1qMUnZ2dzjUhTgaCEnMMAI6R4+99xBz/AOBZmqa3OrY3AriPpuldQnWGI+Z4+fLlOH78OACgd+/ezqc6IXkAfuXk2BGMeoOpV0zZULYrFLpC1Z7mq6/Gilg91DYrbnrvPWDJEuDpp2XZ0N3l5ZZRCs8RjnDYwLUjnH0QrrZLhfRV4ITiPiV91X36Ktz65RLqmGN/lAPoxdnuCeBEmGwhELof8y9l/ms0bo4xgUAgEAiEwAiXc5wP4GqKYRyAZn/xxgQCgQetFjj99HBbQSAQCISTGIMBoCjX30mWuc2LoMQcUxT1BYApAJIpiioH8BgALQDQNP0OgB/BpHE7DCaV26Jg2KEESUlJzvgwMfFpwYphC0dsXKB6w9lf4dIVsvbs2gW9yQStpRO4/HLgiy+A2bNl2dDd5eWWUYpw6uZC+kA8pK8CJxT3aTj7ymAATCbXtl4PeMx9FI2Ydnjqmzs3CVIiFJTsK762m0wApe2ANrkCnZU5MJkYObZPWP1K9ls4CVrMcTAgeY4JBIbmSy7BiX37YTAakVl5ArjtNuCNN8JtFoFAIAjSFZ0nX86gNrEK6phmtJflAgCC6S5RFKCJqwWl7YSlLtNph9EY+j6jKCBu/Fr0umkJiu/+GZb6DABAr8V3Im7MRhTevgk2YzKvLRQFRGYcgTapEi17JwIIbr8FSleLOSYQCIEwdJjrs04HTJ8ePlsIhJMUz1fJgbxWDtdr6a72OtxkApKmfwJtcrlzmw8hu5Vuk8kEpF3+PPKWD3WzKfflc9DvyUt8ljMYAJW2E6qIdp/XCN9+Xwx8bSpyX5qBtCueB1RWpx0mE6Dr9w90A3Y6t8X0ASuj0nb6lfGsJ378DwCAyMzDTtm4MUxqvIyrn0Zkz2K3vmLrAoD+z1yErLtvce5X6h4KJcQ59sPatWvx3HPP4bnnnsPatWtFyYuRk2NHMOoNpl4xZUPZrlDoCll7xozGzrFj8fvMC9xCKuTY0N3l5ZZRClZ3OG3g2nGq6ZaDWHtNJiD96ifR88YHAQARaaXQj9roPCYFkwlQRZsw/86nMGv2d5LLe8LnePE5G64R0CZZdvtC6jk3GIDZs9di9tyvkX7Fi8i690ZBeZMJmHPVh5hz5TLnNts+kwmIGfQX8pYPRUTqUeaVvwSHy7PvACD53M/8lvOs32QC+j87G0PeHwsAUOmakbd8KBLOWuU8rtIZcfVL12De4hfc6hFymJOnf4Y5V32EWbPWOo/lPHw1cpa4IlDZ86hNYbLiTpmyFrNnr+XUSaOlow36Eb9hyAejEdXngLOf2D5QRbbBklAIw5hfoIpqdasXtEOQx5mPG7MB/Z9yPTRQFHNup0xZi6gs99zNceN+QI+5S5lzlV6CjGseR1Qvl2PdVZ3lcOU57jbU19c7cw16JsT2JR8sO8JBIHrD2V/h0hXK9pj0eqiTEt0cYzk2dHd5gwG4+GKmzOzZoX9NG6570xOl7JDzCjdYfSDVFrHyUuyN7FHmdBwGPMfca/sW7gXAPwqo1zP/Pe0AgNSLlyIltQoddKRo/VwMBqClwwzaEgnQaiROXYmMq59G6YvvonX/BJ+Ob+7L58DeGYkDN+50s1vMufXsU5aFC133nGddvsr06F0CACgBoI525cT1ZU/G4H8AAHHjU9C8faZbnezIZs+bHkRt/o0wjPoVFR896XSihR4C1LGNiD/zNxh3TIe9PQaauDrnMZXOCLvZ3UuL6lUMqzEJ1uZkZ72sIxeRUsG0QdOJiBRmNDxl5vto3MQsBJM4eTX0Fj30mced9SWevQIZVz4HACh791k0b5/pZWNinAlRA/+FrjgD5oOj3Y9N+xyWxlRQGgt633ovWg6cht4J0Wg9OMolc9YqZFzzFEz/ngEASJv3Cso/fBLWxjRnf+e+PBPaxBoAgPGfKTj+2usAgJiBO6AfvhUAkHHV0zi4ZxKSZnzsZWPssC3Q9f0XtlYDUjJMoGkVek14z02m180POD9n/fc2RPQoR+JZXwMASl94D1ZjEqJ7F6Np2yzFHtyUgDjHBAKh22IwAC1tnYjseRCW2p4AlBsZO1UxmYCo3kXQD9+C2rU3uo02sVBqC2ibFgCgjmnCVfPtAK3CokXKPpyYTIBaX4+o3sVO589gANojTsBSnw6ActNnarGj1233oG7d1Wg7MsLN9kDs0sTVQz98s/cByobIjBJYm5OhTT6B9qNDnNcfFdEGjaEBlrpM1z6N+4pgFCXNLpMJyFt+Ohq3zEHFR08g42omhWP2vTc5HXZfqCI6AACRmYfQ+z93ouTJz2EyxXk3iXuuKRsolR29b78bhlGb0PTneaAoO8refgnapErY23WgItpAd0a73XcmE5B57aPoqO6Nuh+uR8ygvxAz+C9E9TzEqZwJRFXHNEGbVIX24wO9Jnmx9LrpQacDyTqlsUMZ502Xsw997mRWhav46Emn/siMw+j/zBwcWrIGfe66DY2b56J27U0AgEFvTAIANOf9AUpjgWH0r05dWXffjJInP3fTz4ZW7FtUANBqaOPrYGvXI2+5K1R1yAej0XZ0EAAgIqkKPW++Dw2/zkfapS8DlcyqcIPfPQ0HbvobCWd+6yyXcv6HMBePhqUh3U1nVDqz+l3OkoUovse1EiAb+sEldvDfQOVkRPUudu4zjPmF6Z/+BYxM3p8Y+Mo5aC/rj8OPfIOUWe85HWMAMIz8DbmvTIU2odat7ojkE7w6ASDrrtucn6MdbdQYXA+emjiPunq4r9iXfZ/r7UHTNmZlPr7zHw5IWAWBQOgSsK86N29m/sS8YmtT12DIB6OhiTEiIvW4/wIEUfR7Yh5SL37duZ15/UPIWz4U2qQTiMrajyEfjkLs0N8Byo5Bb56JmAG7oUlksvqIfTgRiuflvmrOvu96ZN97E0Axq3916g8j9//ORdKMT5z6WHlNXB3ixv6C3ouZpcejs/eBdcK4cuw1JvQq17WfRkRKBfr8d7HzmDaxClBbkHrJa+j/9FwMemMS+v3vMudxtb4BQ947DbkvzeCtOzLtGFLnvSKpv1hbACBhkq+lb2lQKrtgfGv/p+ciMu04YvO2AeB/rZ23fCjylg/F4HfGY8iHo2AYtQkAED/uJ8Sd/jPzijy5AlE9GUebC1tHwqQ1SJv3GnrMeQPZ91+PHrPed5OjtJ2I7luAQW+eiX5PzGOuJ3DOk7bDTT7rvuudxwF4OXEAALUFhrHrkH71k+j/zBymvc/MQUTyCaRe/Abylg9F9oPXOMXjTv/ZzTEGAF3fvchbPhTJ533kVX3WvTciOudfDHztLPS65R6v49FZhc7P8eN+cguDAJgwhojUo4juU+TcF9XrMHJfnu6MweYjYfJqn8e4qKNakbd8KCIzjiB2yF/Mvmj3Veuieh1C3vKhbvc3C2+fSkQd47qgB742VXQ5VVQLgK4zuEGcY3/U1wN2e9eebkkgSMDTKdm6NdwWMZjRgJxHLwelYcKYuDGGvuAbiQoF3D7cvLnr9GGwSJiYDwDQDdiNmAG7AQCxQ/9AzMC/nTLaeM4olIjJQiYTEJFSBqhdo6nR/QoQO3wLIjNd5zUy84hbOXb0yambskE/8lcw55+5BlSRTKxl38cuR/pVTyP7oasAyuZwQGhoEqqhijQ77WDtVEV0gKJoaGKbYTLR0I/YBLW+ycv23JfPwZD3xiLlgmVu+2MGb0evW+/GoNcnO/clTvsCAI34id8icYrLyUm5wNv58gtlFzycde8NyFs2HFSEGXnLh6LP3TdDE1/tKs7pa0ptAaVhHFRdPyZ8wdRid9Ohimzza5J+6DbnZzacIaq3y0nsceG7vOXU0a3o+8hVzm1d/wLEn7nG6ZgPed89gUDs4L+gTaxE4rTPPatykvfhKPS+7V4kTV3lUyYmd7ffNgFA2qWveO2LHfw3+j66AABgGPWbqHo8GfD8LN79uS+d57OMYYQ0XYln++6jrkrapf8XbhPcIGEVQuTnI/n331GdmwsVTSPNbPZbJC0tLSimBKveYOoVUzaU7QqFLrk6pMZWUhSF+KZGRMR7vxb1Z4PJxDghcaetQ9XnD6CiIg1SzJbaRrHy8eO/hy5nH0xtfZ2xc0KjCAYDgD7M56aIJljamK8zNr4zmJhMgCahCobRG1FVxbQvVJeyr2tF6nkRe831mOsaYUqa9gV0/f51bFHoffudAJj+t9linXImE0BFmKEfug3GXWfzhmZo4mox4MXzAQAH71+Lzuos9H3Y5SwV3bEJ1uZkUCqPhx4VM4JMUcz+5POXIW3eazj++iuwNDPppdS6FkT0OO6w+UsAQN6yEQCA9hPZaItkvPWkGTFIueADHHnic/S66QHo+v2Lup+vRPK5n6Hqy7uYV+I+oNQ2r33c18QsGVc9g4yrnnFuN0U0eddFgXlIsKsAWu1TJ9QuxzVu3A9eh9nRwhjHq3T90D8w8NWzncdT57va0/PGh9Dzxoec24cfXYV+T8z3rdsDbjuis/eirXQocz2pLUiZ+YHfMp6otB3oed2jgvK5LzNZefTDt4i2sysg1G4xZaJ6HfItyCMv9HAQLOS0kUtEapkyhigEyXMsxOLFKNzAzEweVFxEcskSggZFAVFZ+xGZehzNfzEjCEK3pvHHH1Fx193QnzcDPV/xHuHwp4uNIWPjFLvC10DyuZ8i/QrXjO59C/8FQPm0jaIA/aiN6ONw0MxHhqHkyRUhmZBHUUDfJy5BdO9iFP33F1gb00I2EZCigKg++0FbItFxoh8A4fMnlDoqY9FjgF2FEx8/5rafvT4OP/oV+j0xj7dsa9EYxAx0fR931mXg4D0/O7d73vgg4id8j8OPfoX24wORde/1iB3yF4rv/hm21jhokyvQ/6mLAQDVX98Oc+kQJnzCQfPOaSh741WnLSXPLIf54GhXuq09E3HslbeRcc0TSDzrKzRtPx/x43/03VgBTHsnuI2AhgpXnDCNvOVMesaW/afj6Evvof+zs2BpSMfRFxhHU9d/N3IeusZHTe4cf/0V9P7Pf732Wxp6uMWZcmk7OsgtLEAq7RU56Cjvj7jTf/YvTCDwEI7fI195jsnIsRDTpwMO55jkkiUEGzZmkXWOTzk8Xhlrkyphqc8QnKDRY5ZrZrSuLzOiGaqYNY2+EQCginJ/PR+KL/Z+jzPXCvtjIjQ7n1JbkP3Q1Wj8bR4at8yFJqEKyed9jKov7kHi5G8AAHU/LcKAFy7AoYe/Rkd5rrNszMAdPm3gOsYMjpAGXTN6zHof8RO+Z7YdmR7YUc3c/zsXAFD7gyseM/WSpV71x43ZiNrertjMPv+9FVUrveM8E8/6CgBkO8aAaxQ61ETn/Iv4M/LRfnygc1/skL+Qt2w4ACAy7Tj6P38+IiWOqvE5xgB8OsYAAnKMASAqswRRmSUB1UEgdBWIcyzE7Nn4c80aVGRmQhUZiYFWK+b6KfLNN8yPzdy5/iSlEax6g6lXTNlQtisUuoKhg+/1d/lK4M/x46DV6XClRBs8ww7mzv0GF18M/PLLXFEjn1LbKFZe128PAGBsLZMztObMb1Hz7a28qZnYNkRnH3Ars0+URd5IDWvR6wFtAuNoLLjrKbQWjYW1MRUAQFFzQ55OzmQC5i98HzRN4feORtSuvQG21ngAQPwZa6HL2Qddzj60HR2M9CufQcyAf2Dac6azfL+nmHPT/6lLcOLTJc79SWevEKV/bO1Y0JYIlPf7BzkPX+12zDBqI2i7d6iAZ7wuHz1vut/5WR1tRuaiJ1wHKRpUhP+YWF/2AsCOFMb5j83bLqueQHWz8audtZk+5aU6xqHCsw+DUUaOjq7IqdBX4davNGRCnh/aonWwq9Ww0jSMIn7tjEajKDmpBKveYOoVUzaU7QqFLrk6PB1W7rbJBOhH/oq85UOh1tfDZAIuvYy5No/WqbwmO/mzgXsoIr0EhrgmGAxGvyOu7CSrtWuNWLvWKHrFJVZeaHKdwQDAMXqns+qgs+rQ46K33fogduhW9Ji71LnNhS0jF1OLHQmTVjsnh/nrC24f6qw6pPTbD0NCA+JTT4gqHwi+rpWU3D3oMbAAyTM+waA3z0Tua1MAAJnXukIm+j0xDzEDmMlXmdc86dzPpvkC4BYfG9GjQpRNOqsOMZTGyzEGgOQZn7rFEkvDd0yIftgfGPLeabJqDfR6CQQ+3Wyu3O6EnD6UWiac50lJToW+Crd+pSHOMYEQZvheiXNn0ANA0jnM7ONBr08BFWFG/Lgf3WTlMuDZC72yAfjCZAK0yeVQxzYJ6jaZmBG/fk9fCE18NVSRrpWXfMW/mkzMqkueZN1zI5Pih7Ih6+5b0GO2Ix0UZcPgd8f6tFXqqksJZ65B5rX/QzIn0T23LF/aMU+iexchmhMGEIzVnqSMcGvj6n3mJwW8c452RaJEXpsEAoGgJMQ5JhDCjMkEaJNOOLczr38IKh3j8UT33eP47IqJTDl/GfSOvKNKoNaJH+nOfek8RGUedltRio/48T8iKrMEA189G9FZhYjJ9Z5Iy3U4fRGbtx2G0RvRY85bbvsTp62EKrLdt/4zvkPe8qFQ6ZpFPTyoY5g+iOp5EP2enOtMf8WWZRZfGIqUC9/2VQVUEYw9kRlH3MoqiclEI2n6p5ztrrXkKoFAIJwMEOeYQOgCDHjRNQkvYWI+Br91BmLz/kDfR65E1t23OEMOAKDHRe9wSioxkYjxToVSoHk6YBpDg9dxf46uJyYTkP3gNYJ5S124t5NdetUT1jFNmv4ZAGZ1J8A1Cuwr/26kYzXf+PE/IarXISRM+sZZJ7dNqR5OOh8RqcdEtEc6BgOgy93pltEDYBZC0UvMg0ogEAgE35AJeX5Iqq+DSR8LTY8e6Nmzp195MTJyCFa9wdQbzv4Kly6pOljnjFJ5J/fPuudmAEwWhtbiUV7Hk+rr0GyJ9dov1YZ6bSPqyoTLsHHPAFAfVQ+LWeN1XDdgJ3KWLMLhR79yrz+qHr6Iyd2NmNzdMO6e6lueop3Ors82sGU8Ml6o9Y2IHbINLY6lh1VRrchbPg5l7z6D5u2znKEeyV4JQty9fMNoV8hHRFopOquyfdobmXYMSg0ae4ZRJHhMzmLDJtorclAfFb54P6Fz3BUJp73dra98IacdUsuQvgquDiUJVL/dEqGQJcpAnGM/DNvzL4bt+ReDisSluTn77LP9C8kgWPUGU6+YsqFsVyh0SdVhMgH9nprjV85rpSqauTZPmFMCtmFvXCEO/DoVoIXXte9zxx0AgH0J+4AE77wQ7BKzMYP/ctu/j0fWk4GvnONTXh3TDHWUcFYCZxkP5zjr7ltAqezYf8MO0JYoaBMrAQApMz9E8/ZZMIxZD9OeyZ7VAbT7SzVuaqwBz83m5Kf1tjft0n2o+2mRIouRmExMOrXM6x/C8ddfdZtcxyUqs0R2pg4lEHOOuxLhtLe79ZUv5LRDahnSV8HVoSTh1q80JKyC4IaYZV+7G3yTqcLVLk9bACCq52G/5aJ6HRQ87tk+Ke1URXSg3xPMYgxKxMkmTv5a8DjbB2JJv/wlt+2oPgd8yrKrqY0aSTm2GWdZ1/8fRPUqBsVmZaAp6HJ3oPfiu5F26f+BUlvd6tHE10CTUIX0q59EzBDvxSG4y+P6QqnEKJS2AxHJlaA0Fv/CBAKBQAgYMnLshz8mnoHK9HSonn4a/fv3x/z5wstrrlrFLNvoT04qwarXE8Y5ohHVuxjtxwfivPNWYdUq8Xq5r4Hnz18FjQZYscJ32VC0y2QCUi58GxeesRst+8dj5cfXKj5Zim33/PlMe376aT6vc2QyMSvhWZtSYG3qIbp+vqVq/5h4BtrssdB8W4WozCNo2XcGAODya9+FzWzAqpWXi2rnuJpxQCTg30XnyMM9pzB3lDQy/aigvMlEI2789zD+PUOw/j97/Ml7vN/jl/osc9gxclywB4js5TrutawvDaijWwAAMYP/BGh3b10V2YYBL1wAlbaTdylW7jK7rG4W1m6hUXghfC3ooev/j2A5f/0WTMKpWw6krwJHTjukliF91X36KlD99eu800CGEzJy7IfOiEjQKhVsNhvMZrNfebPZLEpOKkrXyzdCzI4yxk/8Dv2emAf9iN+g00nTazIBVEQbki/4ADpdKyIihMsGq788SZ3zFiJtkYjvLdYFlIbJBAx4aToS+u2DTmcWdEr7/e8y9H9uZmAKKebaRIwV/R6/1BmfrE0pQ2L/vYjPLvJTgYtIWyQibZGCMpqEKkF5oxGI8BEy5pRXMaOz2Q8uRK+blmDIh95x1GLt8VUmbd4rAGjYvZ8lvKBpZmGKqIxS75W97CqotJ2SdHvaLfcBjL2HUue9Akrbgch0xjaDn0l3cvpNKcKpWw6krwInkPs0mDq6IqdCX/nS31HVB7TV/zissYAnvC2MEOf4FIUdIY7uuwcADZPJMakqdwd6Xv8IACAiTd6s+x4XvoO0ea9BE9c1JlNoE6s4W8FbJjYiuRIafYN/QcAZQ8tmV5CNyu6WOUKtYzwyrxhlCfA9NLH1CrF4sfBxw+gN0MRXIyZ3t2zb/BGb9ydUkW1uuZj5oQC776+/hEnfKmmWZJLPW46UCz5Cz+sfQvoVLwIAYgbuCqtNBAIhdHQ2pIZUn6UpGc1/nat4vdamFFR9ebdoeSXmaigBcY5PYeLG/Yi+j1yJOM6CEtn3X8+RYBzJzZulxemqophFHzwnRwVCILHQar3LSQ933Kbnjd//mYsCq9Crj92dfzlfNNHZe0Fpmdhc9qFJyNlmz8nLL/sxVWNB/2cvlG6QRGiaeVARIqrXISZFXhdF5ej/uNN/DrMlBMKpTcVH/wuZruYd5/gX4lD5+b2ydRXe9rvz875Fe1B8568oe/sllL//FOrWXY3WQyN8l128RbQemqbQsEl82GQYFgLmpVvFHNfX12P58uVu+4YMGYKxY8fCYrFgxYoVXmVGjBiBESNGwGw2O+NbuYwZMwZ5eXlobm7GmjVrvI53RLreFVdVVXnpnzRpEnJyclBVVYV169ahqooZpWTlpk2bhl69eqGsrAwbN270qn/GjBlIS0tDSUkJtmzxvuAee2wmjh9Pxi23mBEXZ8T11y/HxImu43PmzEFcXBz27duHnTu9F1qYP38+dDodCgoKUFBQ4Ny/cCGgTa7A33Y1ItOOYezYHRgyZD901Wc6k1hZRx0BKBrW5iRMmLANAwYcBLf5Wq0WCxYsAABs3rwZpaWlWLgQ0PWrA1U5GbExHahuYhyn887bgPnz3VfkMnA8XG7fsSQlJWHWrFkAgClT1iI5vQK67H0wl+SBtkRh3bo0zJjBxK1+8803Xksm9+zZE2effTZiYph4qLjOOEfblztszsbkycyrnBUrVsBicXecBwwYgAkTJgCA13kH3K+9a296H9GVkxHXGQd9WiUWLlyOggLva2/pUmBnJaNTM/FXWAFEW6NxWq33MrgH4w6iUleJWEssRteNdu+7CBqdEVqoNBbEdcRhRMMIjL3hXVBqK+I646BWqXH8eJnz2nv88Y2wcUINJudORkFiAZojm6G1a6Gz6rBw4XJQmk7o+v4LizEJq9/7D+rrkzFgQDGmXr4CaofdbD8m5RxA+qOXImbdbRgUFYWIHu3QVrpejW3vsR2d6k5E2iIRZYvCvLEHEdk0Bmhijm9N3QqbyoYcYw56tboChNn6neeheQDSzelu+2wqG7ambgUADGoa5CwzuXIyJj9+Hzpqxjlj3/Ia85DUnuRW3qwxY0fKDgDA8PrhiO+Mdztu0pqwO5kZ4R5VNwp6i/tTRlNEE/Yk7QEA6C16qDjZLSZXTkbqtA34+28ma8iqVau8Qoeys31fe9ddB5Rp23GCU58nZTFlKDGUQG1XY2L1RLd+m1w5GUdjj+KY/hgibBEYXzPeq/wRwxGUx5TLuvYAoDC+EDXRNc5rj6sbYGau10fVI6k9CXmNeV7l2WuvR1sPDGoa5HV8V/IutGhbkG5Ox4DmAV7H/075G22aNvRs7Ym+xr5ex9lrr4+pD7JasryOs3heeyyb0zcDEHft9WhznzvQoe4QvPb0Fj1MWuZNTKDX3tjasV5L9tZH1TszB4yrGef1qrsmugaF8cyE0onVE6G2q92OV+oqcTCOmQAsdO0BzDXnKSN07cV1xqFdwyyWI+ba87yuAO9rzxOlr73Wfk2IceinbRrsSNuGNk0bIr94HOOm/OpVfnuP7Sh69gOcdccjyGrJQtuxQYhLP+Fsh6/vPQDojE7CdsfnWC2NaI/+9bz2xg2qRiTne5nm5MP39713zpSt6OsoO+aaTwAA9fVJWLuWGcCYNWstkiqnIDKjBJqYZgCua8/WkuB17cV1xsGqck1sZq89W4Qe7Vd+joj989GYudfntXfaOVtRlGoGIO43Nxj+HhcycuyH+MYmRLeaERsbi6ioKL/yUVFRouTE0trKjHzW1CWhrS3KzcEJBLX79yEiI733afSNaEg5CGO/7ZACO/O/U9eIskbm5un0Eb6ZnZ2N7Oxs/oMeaAz1jv/iQhcAZoS51TGQbVFZYFEFPnK8dSszmn7bbYzjHxMDqByTuywqCzpocaEbaZe/GJAdCY2NiDRVO7d1OXsByg6LygKzzYYzzmDsO+MMwGYDVNEmRGZ6x1w3RTS5+sUx8U9rqEe/J+Y5R90pjesEsv3Y84YljB1nfge1vtH1xsADo9bI1E+J6xc550mpcyuHdnW7U78SNkycCM80y6IIZx+EU7ccaqNqURNdExbd7er2sOlWktqoWln3abO2WZJ8qK8r466pOPKEt+PlSXv5AHQ2pPEeMx8eCQCgbWrY22NEt8PCqa+xWe+3DM15KLeoLGhX+1411AubiLFRuxod5f2dm+ZS74cNALA0psKisqBVw/8bAAC0x0NYV4eiRf6QdwXGjBlD842OBpPCgcyTpdg8x0pDUUyif6spHkX/YV6DKHXKel32JuLPewc1396Cmm9vhV4P9H5tmDMdFhc2r6s/3ay9LHXrF6Dq8wcAMK/4+SYpqQ11sBmTodf7fqVCUUCPua+jx+z3UP3NbajNv1lUP1AUkDrvFaRc8JFXW3zp88wW4ClHUcCgt09H7dobUffjdQCAXrfdhbixvwAAyj98Ak2/z/Fp39CPh/IfkMD4Qjv++60d2wdSeGWO95dO29FBOPK/VVAb6pBw5reo++E6DFw6GRpDIwr/sxmDXvceEdq3cC8iex5E/6cudu47/taLMP49A7mvTYHWI4bc0pzktY/AIPZ+8YS99rKXXI2YAcLZKQgEgngqlj2KzEVP+DzetP18xI//ESc+fhgNmy51/o4duPlPDH6HycRgNSZAY2gEwNzjnr8tANB6cCRKn/kE+hGb0F6WC0t9BiIzDyH9iucRO8SVA7527fVImfWBW1murn0L97r9lvKxb1EBks5ZgfQrXoTNrBc1N6Tyi3vQcaIvWvZOdNbP933F/R30lAOA3FemQZvAPOTV/rgIKecv49V37JU3YNozGaqoVmfb+Djy5GdoOzJcMf9GLBRF7aJpeoznfjJy3E3Q6JsUqccZu6u2otOR8lU/fDOYSXnCV6WY+FUhGZMJSJz2OSJ6HHfZM2Y9Bi09C7oBOwVn9zP10h7b4vD88sp59HKnPb7sTJn9DqKz9/qUU0ebkTb/Vec26xgD8EoLFgz8fX9EZzEPc71uXIK0ea8hOnu/6JFbT2IGb+d1goljrDwmEwCVlTjGBIJM6jdcjrK3n0ftTwsBALU/LMK+hXvRuHke9i3ci6I7N8BqTMThR91fu9vbY9y2244N9K7c4zu0aZt31qHqVcyCQaaCs2CpzwAAdFT0R8cJ9/Af094z0LCZGYgofe4jVK68x8sGPiz1nIl6tBr166/Gic8ewJEnVqBh81y/5et/vgYte5lQrJJnlqH2x0W8ckajy1m2muK95Gq/v56nlDv7Fu51LrJkb49BxcePuB2v+uoOTluoLjMZD+hmMcfhYMvkSahOTQX15JPIyclxxtj6go2D8ScnFvZimVg9EcMXrEB+vvx62SfB2CHbkHXvTTDtYW6Q6OwDyFs+jLcMG8+4D/4D5T1HXCdWT0RnpgUfOdrR0t6BjKuehaUpGcV3MqupXXLWn4ionojKrEKYD3o9vDkxGoGlu4H39wJPPkHhpuGim+3Vlq05W/3Kps59E6lz33Q+KVOU75FmTx3tI0qwfKv8PLdi2TJ5EppiKQB/eNkAMOeMDXVImPK184td16/Ap7wn6Vc8D218Ha88G/vmj2DLyy2jFKxulkBtSLngw4DsCGcfhEO3HEhfBU4o7lM5Oio/Y8K9tEmOSbkeYxXWplQU3c7ElDf9eR7ix/3EW0/p8x8g0mO5dk86KvoLHmdZsGAFIjMs+Ntj/4lPHkLtdzfD0pCG1qKxXmViKyfhj3T3uUiHHvoOg98ZB3uHK3yzYcMCLFiwAugcgD0eOpp3ToN++BaotN4hGuaDYwR/d1nYt9YsfE6sqHPFebZoP5GNuh+uh2HUr9D1ZX5nu8pkPICMHPvFptYAFAWapr0mbPFhsVhEyYmFvVjUdjXOPtsS0MVjMgE9b3wQWffeBADQD/f/haO2q70mbAjVnzBptVtZjduTNvOZ++pHQ0F0/YEipS0szGpsjN0mk/+V3dR2NWIyS6DWN3iNOEtdGc4fNrUGNOXdHr52Jk5eDU0sE+vHLgMtJM/i6Rj7k+cj2PJyyygFq9vTBimjINxrIyKlIiA7wkE4dcuB9JU4zId8j0IE8z5t+vM8FN6+SZT8/ht28O7vqMoCAHQ6/gM89yTn94l2xODSjjd/dnMc2krzQNspXnkh9Hpm1JX9O/tsC/p4zvu0qwGb1i3OmKW1aDS0Wgs6Do9A6XOuh+WDD+TD3h6DQ0u+RfG97k69VmuBlscBLnvjVRx57Cs0bZuJQ0tck9A8+8LX9xWfnNEIvPGG+36VJdLnuWL7AY7j9RsvxeEl+W4yOh1PwTBCnONTjPgJ3we1/pRZ77tts/lm/S+IIP6V/yOPiEvp5s8RFfNl0O/xS5G3fBgiMw859+kGeMS9c2boskSml7ptGwyAGfXo/Z87vGQJJydSHmRNJkA/4jekXfZC8AwiECTS2ZDOu9/07xmK6Wgv7+f8zL66t7XEw2ZM9pK1tsR57aMt/BPgTbun4cgTK9C4ZY5zHxsq4HTWOJPSqr9ZjPpfrkDT1ovc6+/U4cRnD7Bbftuz9Q/ve3/rVqCCk6ypdu31MB9xf/Bgf3f2LdqD0ucdoYA2LVqLTsOBm/7Cvut2o7OKmbzecaKvW//QNDBZYA2NjhN9Uf7es+g44eprz77w9X0lVq7t2CBYW+NQ9vbzKLx9E448+amXTNO2WahbvwDVq2937lNrmD791TvxR1ghznEXhZvXtzvDXWUsfqLjSVFlA0Aj2uP1Pouv1fueftpRPLINqRe/BkrT6dfpjhn0l89jQl8GnqRd+n/OzzlL3GOvovv4Xo2ObUN7ZAUGvT4FhtEh/gbo5tfPqQD7gNfnzv8gecanSJgknGKI0H3hTmgKJfaOaN68tYce/lq4IGf+xP4bXUEBx5cuhbl0iCjdbce9U/G563B9bNhwBewWLRp+u8RN5MCtW3Ho4dUoWrxVsA8P3OT+fd9WMgxCX4Jtx5m44qbt58FuNqByxYOgrUz6VqcDDaB5u3tscWuRd3pDITyzTFWvvgNwZJrgOp16PZj9tLtrZu/QATYtb91y4nSDEdtLWyLRUd4fzX+dD5sxGW1HRnjLWCNQ9fkDsJtdo1qjHQulUl3sx4rEHIvFbgfqQzcByWQCEs5a5VwMoLsg9Eo485onAQAqjRWGsevR+7Z7oKmY6iVnMgFx479Ha+FpsDb1cDrA8elHAQApM5nXTJamFDRsvELQHvdFTcRhMAB9Xnffp00+wSurH/krLHWZXvtzlizE/ut2g7ZpoYmvRs6SrrVuvC/Y0AtC4IiNOTeZgNhh4pPqE8TRsv90t+wAwcZ8aDh0/T0jPsOH3aJ1xpnazLGgeEY9O8pz/dZTfM86aOLqQHdGO/fR1gi3bV/sW7gXoGwY9OZEqHUtPqRcTpGlIQ0HbvBeQdNujkOH2XvU2NMZtncw7+ZZ588z65AvrM0pbttcWb0eMDvWWqIoGkV3bILNHOuzrolnAOpq73vf2uw9Eu5pE7cMm+Z3GX8SCMkENQuEQN2efSn2nIQb4hz7If1EBdqjIhHZ0YEBv/0G9O8PzJ7tU37AAD9PyRJgnUmAScweaN1yLsRKnfBKY+LK0ugx5023Y5GpTMaKqljHuyZOLJdKZ0Svmx5Ee1k/HH7ENYrmlhECrnzKvkbXNXHu8bJi28I3Gh2VUYqIlDJEeYwSZy56HMdee41XhyqmGTZjMga8eB7vZIhAoCnm2uyI8/6B4toQkVzudVxIvvft/sM+pF4TwZaXW0YpfOn2H0rkQj/0D/9CMu0IBeHU7UlnfRoOP7QG6Vc+61MmGPbStLgXsUrrtlsi3N7QuXB9MVpNCfIqpwFLXaZzAKD5r3MRlXUAAHDw4ACoytKBqzb7qUMNqzEJal2L4t8FrDPsVCXRAWwrYUa/Ww+O8lmH0Qg0dwATVzK/NXxOriee9/7Bg47fbs6aKP4meEv9vR8wYAA++cR9n7U5UVIdcqlffzUODmEWjhE6B57tNRiAv3fQ0OUAp58OaOq6zqQ84hz7YWBRMQYWFSOmpQW9K8qBvDxB55hdUU1pDsYdxBlnTBCVMUFpvXzw5QL2VVabUo4eF74run7KsSSyJqHWr33qmGbEDN4O057JGPLeaSj/4ElkXPMk74+Fpy7WqRbbpwNePJ93f8/rXelpuDrY+pV2jFkGFhWjJrEn4DH4zrVBE+d/wRSuvJg8mb6uiXDJyy2jFEroFutYBdsOLq1FoxEzcFdYdAfCkf99CXt7LGytvickyLG38PZNGLT0LK/95kPDoYpqhb3D/0gqAOw41AtxY7xXS/VH018zEH/6Oq/9rUVjoB+6jacE7bTP3qHzuUiPFMrefsn5eds25rdOV56InAevFSzXr78dZSam3+2dkX7jOWma+f48GHcQjX/M8toPCE8WFIv54BgULt4CW4vwwwPlUGqIo92cP4pi7Gg/0ReJk7/xWX7v3gkwmYC8G137/D08S/UlJkyYgJ07gT7XuPY1/cn/m6Uk9RsvhbU5Gdu2+X9o8MRkAlxj9pSkAYVgQ5xjkbTGOl6jxHm/2gkGvkZ5A7l4lLzwTCag3zOz0VE2AGVvvwSTCdAm8YceUDwzfOMnfutXh79X/DGD/0L6Fcwqc0f/720A7o6qELr+u6GJr4Vxx7lu/WIwAOrYRlF1AMxqfVJW7FMaJoyle8x8J7jj9oBp71rxdgDQ+Psc0c5xl8IRJ1u9+nYkn/uZYtXajMmo/eFar7zpJU8zOjRxtRj4mutJlbtgBACYjzALKfB9H/Lqa9NBHW1G45aLoI5tRv26q72c44pljyKq1yGAxzmmO6MArQW0TePMwMDW6QvPhSfY+FvA9yJO5uKx3jt9cPzNF2E+NAqRaUcRM/gv9Jj9Hmia8rki3f7rdvOurHbo4dWw1GV47RebcpOFaVOC2zYfQvGw7PmPzChBTP8CXhmjkbGt9Pn3YfExyVEJfP3GByN84e67gaT5getp+fdM6HL2w9Ik3bkOJmRCnh82TZ2Kry6dj68unY/lCxcCzcIO2/Lly3nXBJeK5809uXIyFi4MvF6pTK6c7La2O5eojFLEnf6zc5vSuI+QsmXZ8AcukWnH3ev39d3jGEXmLl/MYhjhitPkO+4Jty05D12D3rfd46rLMQnQZAIGvTHJb11idASbTVOnorq/90iWVBtYeXapaLHyUusPlrzcMkrB6pZqg8kEgLIjNu8PKDFzUuk+aN4x3Wsf36SuYOiWSsuB07320Z3RKLztd9T/4j0vYXLlZJx5zLt9LObD/HnfGzZe5rOMtTkFJz55yLWDomHviEJHZRYAoOKDpwAA5xn0IvvK4dCa9Ti+dCmsLfFeEo2b56Ht2CDe0s07zwHgviTxwft+FKGXofbHRahaea9z2zNrwbJly3Hddct5yx575Q2Uf+AKC2RX4r14xDFcedGPaC06DUaHfQAzcY6ZPOdCrweuuWoFFl7ziXObpaN8AOzt/HG/UgaBxGZi6NmT+d9spN2yJIl1BpcvX46FC5ejtXAcOqv7iC4jxZdgdXgi1K5AMFUwoTYdlUwGjYULl2PpUm/9/qj57hYU3bEJ1kb+pbjDBXGOpaBSAdN9f6F2ZYRSnkmtx2cGDR8rw6XMfkdEzfyjKX0fn4fonH+ReslrvMeVosVsQdZ91yE6m28pDHlokyvQ78k5/gW7CJEZJeE24ZQj6ZzPkHXPzTCM6lp5jFqLxoDujMbxN19y2+85qatyxf2hNIsXu0WLoy98wHvM1hqPyhUP8h8zu38pVix3vXUqeeozNGy6BIf/txJFd/yKwsWOB3GeUV+9nuMkeX0HUs7wDtou7ee2+c/zAACdjnhfX1+7Tb9f5Ja/1mZmjDE7HmSa/piNYy+/hZJnPhaoxYVx9xQAQPWqu2BrFX5TOnGiu4NYdOcG53LB3JRoNO/3O7vP3Sa2PqORSU82ebK7g8fnkBbf8xOOPOWdOkwpWkysja6c96yNYuOc1R4D4KGajKbUb78nLXsmoeTpj9GwQXhSvBBsdg42jrsrTdAjYRVSGDyYN96Y+3p04ULmJli4MHhmyFl5zWQCsh+8xr+gAKxTHNnzIDKufkp0uQg/qwx5EssZEIjufRB9H/W/KqCYWFkhIjMPI3bw31AvfDygerj0uf12UTG/XQV/cYME5YnoUe72v6vQWcMMlRl5Ro9ZGrfORv0vC5jFE84J32pvdY5lgj3xFQYAAK3FYxCRetxtn7uzTOHEx495leNb3tdkcjlIXxYBTzkSKCQl02g0AsffeAVxp60TPWIIAI1b5rhCGvwumkG55a9l6azp7Z72jIaX807TwNCPmc+HHmJiZo8vXer1ECDktBiNrjqsTakwNaV6yZQepRHheGuuVjN6o9nu4NgkxtH0/O2jKMBS1xOWup7+C8vEbokEANStW+hTpvmvGYjpX4BOnnAPgHmQ+ID/GU4xPB1wQNlwSk/Mh0b5FxKgq0y+44OMHEshKYl3t8lEI+u+66AfwSyJ7JnTkC9vrywcIQbsxe6rXl/7Y3K9U+TIof9TFyNmwD/izVbZ/AtxOHZM+ivm+AlrJZdhiepVjKx7bmY2RMYDiqE7OcaE8CCUhzuc2J1pujycKc42EyZAoeFX36EGSlC9+j9Ox40Xx2RGqynebbeUUT2x2Frj0Hbcf/ozLtamHqhffzXYvhSTu77ioydQveZW1P86H42/X+R2zNLomsLE57S2H8/F0f97Cx0V7g6zXg/U1fpW7loKmXL2KbvSmxwnhi3L4DoR7O9je3l/NP15Hsrfe0Z65R56hLYVwabFvoV7UfvdLT5FGjZcgf037ICV5+EgVEyc6F9GKTz7mc8x784Q51gJKDtiB/+N3rffyXvYZAIGvDADA5dOcm7LITp7v1e9UX0OIPm8ZW71mkzM5BAqwuza73Csg0Hc+LUQSnQY6chPLAQ7ScVgAJKSpdsaSD7TjGuecE6qExO7TAgu5iP88Z6+4K6w1d2IyuyioSw05fzxq/vpGlSuvIdHKDSTCC316RzHzRu+eGPPH+7qr2/HsVeXOrcnTwYyPQf4OF9h3DhUtxXVALQWipuAxpcWX6/3Ocbihd0ch8pPHnGuABcTyxhAO0YxAdcDALe9VlMCWvae6QyJ4Dq4WVnu54xvoIa79LEYp9izDj6H+tgrb6J+46VutsOuQfk7LwieWzGIjRsOBH8OOLNNOc9VVwoPCBae/R5KxzwUkLAKP/Q6fhwWDfNINGTmTD/SwP79/KsGRfTwvTgGi8EAtLS3A5QddKcOectdx8pi+EMT+j1+KQCg7qdFzjoAYOBrU9F2fACOPLoaAKAbIG/WOatXP2ojTLun8cr0umkJYFd7pTJiy6oi2/zWDzCvZ0wmIPXiT3zKB4KvPuQSlVHqVyZQHUrR6/hxlKZ6OyhSbehq8vv2jET6sB9Eyx9++BsMXnqRJB1KEspzLoSSdtC0K61S1Zf3QNff+60Td1T2wteD1we0j7kMALDvut2ulcMcD9i1tUCCx4rCtd/f4Lb94YdDEDmsDDjNta+ztpdsG8WEutE0I7fjRAeiern6q3DxFr+TgPV6ONvH1x/cAZfqVf91K8e1y3NghrstdZR9yJAhfutk6ajoj8pPH8b+sTvcbPOXDpTVEW78nVt/x+W0Q2oZVp7eR4FSuU5mqBz1rnKulII4x37od/gw+h0+DAAYtHQprwz34tuxY6zsi9FkAga+MQ2aWCP237DD7ViJwTXCxFd/ZM9idJTnun3ZRPc+yPlcLMsmVm/avFdh2j0Nve/4D69cr1u8J+ZwbfZXP5eYwX/zSAaOL3t0/f4Nuo5g0O/wYdSpKXimcisxlDC5REXmNZVqc7Dld+wYi7zbpJShQtrvnsjVrfSPVqB9wM2ja2/X8crwvTplVpQMYv8LOMfcJXXZcAXPtFt8scdbt45Fguo4MjnOsbWxhyhzGjbNR/wZa91STfI5hKaCyWg7Oth9nwko6miHwXGuWvaN95lj19NZjWQn83P6g01dBgDtJ7Jh2j3Vzcn3dtqUG+0fO9Y1gl763EewtvDHC3L7n/v7KGaEl6ujOyOnHVLLjB07FgYD0PtVFQAmdiUiAqgMUVzvyXKuWEhYhR+sajVaoqPREh0Ni4V/MYdGTlpcrdaC9naL26smKTFRmljmSs596Vy3/Wq7Gmq72m0kgFtP/6fc16Lnooo0I33B876VCsDqBZhQDcPI32SV9SdDaZh0bxEpZdD1Vc5Z9WdPVC95Dw1SdAQLq1oNmvLWpbarQbXpMfidcaLqkWpzsOW1WgtqPuPPMKCUDiVhdYfTBq4dcil/+wXn59q1rtUKaBrYupVxqsZ5RzDAZFK2/y1NyW4hEEIT2bivdRMdi4F5Zkbgvv5l0WotaNk+C4ce/pojKc5x7KzKRtHirSh/7xlUr17sduy/d7k+mw+ORsMG78nEzb9eBrVdDUtjD9g5eYQ98QxXsBqZBjb94T4pnHU8Dy/JR/XXdzr38/3O2M16HLhlG1oOnI6WfeK+H3xhsVicv4mtRWN9LkXN7f/OTgvq68UvisTV0Z2R0w6pZSwWxvdoLRrj3NcZwijBk+VcsZCRYz/8Pnky6lKYabb7V6zAQoE0FJTKjoV3vABLXSaWL3fJcWfzin115TmZa2I1E9DDHZ/h1uuLvOVDUfq8/CmyrN71VCk08TWyym5O9728KCvz24Vvo3btjeh1290yLZVnT9K5yoZwiGmzUvw+eTKMOgDY4rZ/YvVE2K1a/B63QVQ9Um0OtvyCBStARZqxw7+obB1KwupmEWuD0rPI/fUBbVeBUvHH8xsLJoPrHLKxk85tP19cSvS/vSMKqsh2lDz9CSyc0c+20jzZdfpiwQJm0Qnu97SY72buKGjTtllex80NBrhCivlfbc8ZcwjYcic2Z/wKusMj/oOD5/Vhb9Mzi2LYNGj640KfdrHbfCOzej0Fk0nvM/WdFFasWOGoc6Hf8AjPMkK/o4HId1XktENOXy1YAHyydCnSFzyLhEnfSrQyME6Wc8VCRo4VJiJJ2trxUpHzg5o45auA9bKLdgQLduQYPn68g0X8OPFJ8QnBp3kHszAA3cH/Wp8gH9M/U7z2NW65iPngI3TB09GhxKRakEnJU5+h4qPH3Rxjf7DZeAwG1wS4lGSKd6KZryxBNflMPLK9zZVD0ldWIb4JcIBru/mvGV75jH3l6C195hO35Zid9nx3E6+dej1A27QAKFga0twW9xA7Kc1oVD6cJxQT4gjisXfo0F4e2CRHAnGOpcE3/RjB/cEQwvvLmwal6YQ20cNBVzA92clGd+iZ2h8Wee1r+G1eGCyRh2fcJSE8sCtZcTHudix37PEd4cvR8TeCHAgdVX3QuGUu7zEhh85kYv7YxTYAij8G2MfAQs03/8G+63Y7R8s7azIF5QEhh5BC09YLBctNnuw77dWRpz5FzZrFvMf8OeZi4drOLRtQmlFCl4DvuiLnVR7EOZbCgQNAfr4oUb3ekW9YY/H5KjNQPL+8e8x5Ez1vWILcl4Ozip82vi4o9boTWndVxY5Yd2VoleO1twtfE6a6IvZO36+OvYXJV1KwaDvKN5s8uA/2npO07BYtr9yBm7d7hXL44siTn+HEZw/g2Kuvu+0/+uL7OPHpEsFV3SyNPXDiswec22wKLnZi38H7fsDh/30pyg4+mDRmlNs2HxMneqeIA4C2wyP8llVypFZMpglC94G9rjwh51U65JdICnY7sH69X7HJk5kvLJMJyPtwFPr891a3456LdLB/gdLjwncRd/rP3gcUGjnu81/+EQ2liBmyzS3DBsEBTaHs9VfcJlpYW+IFi1DqbuD080DT3e8riW9EtqvAzQFt8njAkoP0t2QU2o7nom49MzGto6Ifjr/xsk9p7sIRtjbXAyD3x73tyHA0bFgAU8EUt7KWukw0bLxc0Jri/250myTnOVmvs6Y37GbhJZOFMBqB669nPr/3Pi3bcfUVMxwMWosDW+WM0PVoLWRmzjrfDBEkE7QJeRRFzQDwGpg8Ux/QNP2cx/E4AJ8B6O2w4yWappcFyx65ZJWWMuF4NI0RBw4ADz0kKH809iiuH3G92z79sD/ctk0mIOmcz6CObULNmsWgNJ1Iu/wF1Hzj2/k8GnvUbVvKb1Tc2F/EC/vRq3RZrkywRtj5dHVFHfsW7kXe8qG8x2ibFqXPLXMdpylklZaiJM1b9mjsUdgtvmfB88lLQap8wb9DkTlKYIUzDjazHgX/jmA2pgTPJqVo3DIHe2t6Irn/prDo5+LZB807z0bbkWFIu9ThjPLEFXdU9wbApBQTw/btQFRf5jM3jZiv/u+s7o2SJz8HQIPuiEbD5ot9LvPr6RAW3/0LVFr/0+1ZG/xNCuNOWisoGIGoKN/HfdXhD4MB0F9CIXEycOONwLW7vZ3cESNG+CwfxKgVn5Q+95Gs716hdihVRo6Orkio+6q9LNd96fAQcLKcK5agOMcURakBvAngHADlAHZQFJVP0/QBjthtAA7QND2LoqgUAMUURa2gabpLLVGWXVqK7NJSUCoVBj73LDB7tqD8Mf0xURcJm1qtZs1ixI37AUnTvnRNSvNRLwvrGPe67S4f0srB1RuMslwZ/cjgOhiBtCXYOg4/ttLnMZrn1TcN5tqs0XrnOT6mP4bWQyMQkyhOt1Sbpcrv+XcYrCLLWBvSUFAwAno94DuBV+A2KUVr0Rjsb4lHVpj0c/Hsg/L3nkHiVOEQgc7KHBT+ZzNsJv5cuyxsejR26V8Wk4lxIn31/7FX33B8olC9+g7n/qI7N6Df4/PdsvJ4ZWcwG+DLZZMzsuouP8LPcXmYTID22EAAQGdNL7TyvM7uSk4E80CgBm1TO7fFQpxj8YS6r5R40JPKyXKuWIL1DvM0AIdpmi5xOLsrAXjOUqAB6CnmPV0sgAYAXe5dcEdEBOoSE1CXkACz1b95EbYImM3Mss1iLkhtYqVzNRtKYInnCFsEImwR0CaXIyL1GFQ6Y0AjwmJh9QarLFcmaeoqWXqUtCdcOtqPiVtdqHbt9bBbNQBNoSMiAja1t64IWwSiJMSSSrVZinzlynsQHdUmWp6mKeh0ZlRVmUXbI9UmpVE3pTn1h8sGgK8PxA1D2kyJ8Iw9FprEU/LUJ255iI1G/v7vqOrtqNsba1Mqiu7Y7Iz/9YxL9/fdGWgMpdlsdn5PK03Dr5fi0MNfO19th1K3VAKJX5bTDqllulJfBUKo+yocGUROlnPFEiznOBMAdz3Rcsc+Lm8AGATgBIC9AO6gaTq0ebxEsG3iRGw65xz8evY0rPr+e78T8sbXjMftt68CRYn7As99eToojf/B8vE14zG+ZjxyXzoPA56ficFvnSG2CQHB6g1W2UDqD4Y93UEH68ZsmzgRtX29r4PxNeMxNVb89GQpNu9bVCBJnu6IwvyL10jqk/nzV2HVKmkPSqG8jjyZM3WbU78YG9g5B0rjqZ+i4DNFW8Nm96wQ7Ov8jsos5z7u9xd31Tnz4ZEwFZzl3DYY+Pu/Za8r/zMbS+yZJaFhwwLm9a/d/SWm5487ABTd8SuK7/I/50MMq1ZJv8bEQ/lcEINPN/chpDtlFpDTh1LLBPc8hY5Toa/CrV9pguUc830jew5jnAugAEAGmHdcb1AU5fW1QFHUjRRF7aQoamdtba3SdkqCpmng3Xf9ytlsQOzQrTCM8R7Z5ftRTLucWZkqul9BoCYSujlVX93hvdNx5+j1wJIlFLRa4Hl5Cx4GDi1tFTS+kBDhAvzy+xbtga3VNZxYvdq1jHkoXhkqSZu6Gv2fneWdclEC+2/Y6V+IotGwyZXyj/sFfGLZ47wxiSVPfcob4sOGVXimiuJbmtmrLM/IFV++XX/n0dqcAktDurBQmJGTZo1kjCAQuh7Bco7LAXAzufcEM0LMZRGAb2iGwwBKAQz0rIim6fdomh5D0/SYlJSUIJkrDpqigOpqUbJZd9+C3ov5YoJpJF/gvjqRSsssuRiVURqoiYRuTsPGy3j3d9vk+jImGPHmgKVVbo/c7RV9nZ/D2S8fy1hgMeHM7xCZfhQJZ8lfnIe2RIqT69Q540l9wXXgbK3xvCE+M2Y4jlspZxkx16SQcyjl1W+guX1DhdzX2QcfyEfRneJWtCQQCMEnWM7xDgD9KYrKpigqAsBlADzjEY4DmAYAFEWlAsiF++rIXZPUVK9dUhLj6/oVIG3ea0paRDiZ4E27xzgkBgPw9DOAxUrj/vtDa5ZsfIwE++KF51WYONG/HJcwrcHD6BY5Ms5N38g+MfSY9b6itliak2Ft5b5887iWPM6Fp4Mr5IB6hhJ6jm5aeXILL/6P/FRmnpzsq7B1VmXD2uT920IgEMJDUJxjmqatABYD+BlAIYBVNE3vpyjqZoqibnaIPQlgAkVRewFsBHA/TdOhWGVCPioVcNNNXnmKE4QnershlJGCQIBAnl+TCRx/RxmP0GqKV6Qen0jMse3L2dTr4ebrUY56LU3Jci2TDF96PFrk0LjJBOiHb0Zkz2KlzXJhV6OjwpXX2Nn3Ps6Bp4Mr5ICajwxD81/nomLZ/7zq6aqjuN2F7jIqTiCcSgQtzzFN0z8C+NFj3zuczycABGcpNwXpe/gQVDbGoR0xeDAwezaTp3j6J2iv6IfW/RPcfmSOGI6gbMfNoKb4qlFeIssjhiOyygVKIHrFlA1lu0KhK1Ad9vYYNGy+GImTV6PlwGmIHfy3h4DG6aT1PXwIR9K9nUkpNhx79Q0cuesB/4Iy6weAHTtHo9dYcRM1HnqYws9PjWY2drn2G43AhC8AE2fu6vE3X0TbkeGybJJDw8bLkDzDO45ix44x0HeYYRi7AarINp/l2UV0LA09gmLf/kYNmv4+DZRjrQ+v0AuagmnPmWg/0de7sD9sWpS9/RLvIaMROOt+M6LSw/MdJYcxY8b4FwqR7u46Ci6nD6WWCed5UpJToa/CrV9pguYcnxTk56P38TL0Ps4k3sgaPtx5KP2KFwHAa1JLeUw59u/PQ57CppTHlCtcY/D1iikbynaFQpcSOk4s+x9OLPsfUma/zTjHnNfhNd/eippvb0V2zofofbwMVVHeeY6l2NB2ZLhkm/3Jl7//FHre8DAAZvGS/fuHgBKpo6MdyMvLg8EA9OGsDkxRwKA3AXUMs03TFEw7ZjiPb//sVvS6aYmkdigBBQr79+cB+/OQVB/r/F4QQptYo4jutmMDEd2nyLn99+pFsDSkOb97aCvzEFX21ktIPv8jgFbh2CtvydLlL29qqaUd+jB9R8khL0/pb+juoVtJ5LRDahnSV8HVoSTh1q803W+t1lCyfj3MOh0qMtJRkZEO444dXiKahCpEZxU6t6Ot0UgZtMtLjiX7getkmRJtjUa0NVpW2UAIRK+YsqFsVyh0KaqDMyjMF1dr1ulg1XrrkmqD0vI2sx5l7z6L9oocNG2bCYPBKChfv/FS1wZNobm5GRTVLGgD5REqQO+fJKoNR//vbb8yvoiI8H7rc/XVgMHQDIOhGdZd5/q0IRivykufXYaD93/v3I62RsFg8O43485zUPLEF/AMxZFik1DIhcEAxKiosHw/yaW5uRnNzcLX2MmoW0nktENqGdJX3aevwq1faYhzLMT06fhr3DhsO/NMbDvzTPyQkQHA/Udl4CvnoO9jlzu3T6s9DfOvVn4V7NNqT8NptacpXm8w9YopG8p2hUJXoDq4DojVmATA9Z97/Pnnafw1bhxqs8cFbIPi8jSF5u0zcfih7wCbFnPnfCcob9x5NurWX+ncXrNmDebOXYPC/2wGAHTWMfed50IRgCtn7ty5a0S1wdrsHaPs5pwL0Gnxdo7tVi3mzmXsnTP7B582KPHqvO34AHfd7bHorO6DypX3AADmzv0Wc+eucR7n5hNm4eYbVup1vskEnBkd79X2N97ounl716xZgzVr1vgXPMl0K4mcdkgtQ/qq+/RVuPUrDXGOhfBcKrq6GsjP77YxYoTuReNvl6Ds7efR8Ku38/boY2EwCMGcLMQ4npGRrtFNmykRTX/NAO2Ise6ozHaJc0aOA70f3erls8zqiD7jhLc075yG6m9ug3HHOQB8pJ9THP7JivXrruHNWQyELsuDrcX3rGSSt5dAIHQ3iHMsBbsdWK/MCk2E0NK0bSbsHd3ntS8AgFah+a/zeTNYdLR7O0ot+8ah/P2ngmqSFEeHu7qZP9iQhReeZ9oq1dmcPFmavBseKc6K7/3RuawxABT9dwOK7tzoJmNvj0Ft/s3ORVGkpp8LhJbCsc7Png8roXHSvbE2eeegN+05MwyWEAgEQuAQ51gIz6WiVSpgepdPsEHgob28n8w8IeFDaoqnsndeQNMfFwbPoCBisbqfHdbZtLUaYDUmehegKdmj2O0VOR573J1jS20vNGxY4Ny2tcbB2uQ7w4TLIVU+4fK+hf86PzdtmwUAqPjA9QDEHRmePDm0TjoLex5ou+vn5OCD36FlL3GOCQRC94Q4x0J4jhLr9TBcOTusiw4QZCIx325X4GRf+MANyg4AuP0/FLZude2u/OQRlD77sZf416vlLjBBo+wt/pRkvoswN7xb6IDjeqJpjkPq4xJj86LLg3Lmcm7+8zzsW7gXlnrvuQ/hhD0P5kOj0FHtWBjV5kqE1FXsJBAIBLGQVG5CTJ+O3FdfQ2R7HwDA2KHDYDIB2sRKn0UOxh0MiinBqjeYesWUDWW7CqlaRMR5rmKuLKFsT25REQ5mUsBQxw6HEyfVBuXl3T3BbdvGo89pnwuW6KxhnCpLYyp+L+uJe+/1Th/GrfeSSwC62OWYjR8/Hp//6q2jtWgMYgbudN8psGrfkSdWOD+XPv8+4sf/4Ayd6HDYCLhnyxg/fjwA4NWlNvQ47QvnftYpNJmA2GFbfOr0B23zjnnW670fllg78KdsVbL555/xaGsDqMFfAgBiYoCOLvw86uyrU0y3kshph9QypK+Cq0NJwq1faYhzLMTs2ci4735knGAcqixHkuvcl32HVlTqfDvOgRCseoOpV0zZULarnDIhOsj6QtmejBMnUBHjnedYqg3Blj94MBcRQmVoFerXX4X28v5o3T8eJlDIzfV2/rI9lszmOs65ubmo/JPRQVs1oDRWVH9zK2rzb0He8qFOOe6rfxZ2EmD9r/PRVjLMub+1cBxaC13ZQEy7psFm1kOtcw+8zs3NBQDs3GnFyE8dNng4hll33ea7/X44+tK7iJ/wvTPThq847tzcXLf80BTF70QHg4ICRne6Y7u1hYLB0HXfdrDn7FTTrSRy2iG1DOmr4OpQknDrVxoSVuEHo16Pw9nZOJydjfoXX8Qs5AvKx1piEWuJVdyOYNUbTL1iyoasXTSFOEQEVdehJd+GrD00KBj1enRGut5Zs4s+SLVBaXnTv+6Br0lJdbzyNd/egpr8G9FaPAagVWjdPwEAhaSkOtTV+V5JnrarYPr3DLd9dXUuHbRjAqO12XuSWEf5AO99beJiHmibFpWfPei1v66OsbdvToPTBiVTmHVW5qBm9e3wF9NcV1eHiAj3fgtVpghWNzvplQ6hbjmw5+xU060kctohtQzpq+7TV+HWrzTEOfbDrrFj8c9pzN/6s87CBVrhbBWj60ZjdN1oxe0IVr2eWBrdJx4FoldM2VC1CxSN0+nMoOrqONE3dO0Bc23WZzFvMzrr02Dv0AGQ3qdS5YcevMCnPG3VAHb3F1KzZn3PK2/cfRZqvvmPVzaOiy76Ht9//72XPMvRl94B3alz2/f99y4dThfSI3yi7dhAABRsrfHu+48OBgC0Hjjd1Q7a+8/XBMnvv2fsnXrWj27tZJ1DJWNuher6/vvvMWvW9zAWTELtD4uUUyoCVvexV99A9de3w1LbM6T6pcKes1NNt5LIaYfUMqSvuk9fhVu/0hDnWAoqFW76+uTNVmH8ZwpoW5hyQQUZujPKOemrq1Hx0f8CrqOjom/ghojEUp/u+6AjFleMQ9h+fJDzM3dxCl8ZFzzTlPnSERXFOMXvv+8eglD/89UAmIVAiu/5ybm/rXQoDtyyDcadwve20Qh88gnzecGV4icEKhFaIGVS5vFX30T1V3cFrlQGlvoM1H5/A4KRuYNAIBBCBXGOhfBM5Zaa6r0wyEmEzaxXNKsDLTDxKdRYTQnoij/Y5kPD0bjl4sArCmlfKzvTSqzTN2UK8/+XX4TL0D6Ccrm7LXXuI5v2Npen3Z2zK4h9gDjZdBMIBIKSEOdYCM9UbjZbeOwIIZRCjs+RJz9DZxd7tWpriQu3CV60nwjdiK8nTdvPlyTvXGbZ7v/tQjDjTWk/12h7B/P/hhvc434//ZQ/PAKQvqyyLwecj1Cmfpw4MXzp/8Kpm0AgEJSEOMdCeC74odQMmy6ArU0HS0MPlDztnUNWCdqODA9KvbKhaHTFkWMuEvwtRWj6Q9pbkNbiMY5P3v1o2sPEQtSsEZeVobMmU5JuRqvI88cZRec66VddBWcGBW5fS3HkKAFPN1gjp2QElkAgEEILSeUmxOzZGPx/L+N4bya/6dhF/ie5FMYXBsUUpes98cnDaN4+y20fRdFo+vs8pJy3XBG9O8sSkDhAeAJjsPrLk88+A55+QQNddnD1SW0PbdUy/yU6xjQoDN6/H8XOPMcup02qDVLlt2yZhKzTP3XbZ2+PAeCeC1hI3mb2/aA5adIkYQN4+mrSpEn4dP2n3gfcoIIyos3aO2kScIPDBu75VMc2BlS/WMfdb78FkXDqlgPpq8CR0w6pZUhfBVeHkoRbv9IQ59gPqdXVSK2uBgBkPfCAX/ma6Jqg2BGset2hUb3qTtiMCUi79JWA9ZY162D1Uz407WKYc50anx4Irj6p7alff5VsXanV1ThuYPIcn/j4Eek2OEZYpdpcUpIDnY8yFM+EPCF5vlHRnBzP5Z39k5OTI6IdwRma59rLZ4M6JjTxBXL67WTQLQfSV4Ej9z4Nto6uyKnQV+HWrzQkrMIPjfHxKBw4EIUDB6K6qcmvfFxHHOI6lI9tDVa9XtBq2NpcOWkD0Zsc0+G3bKjadeWVwCdv0kHXJbU9tCVStq7G+Hh0RMcDACwNrgwSUm0QK29pSAMApKVVecnTjpHrL77wDlPgk2fhGxWtqqpCVVWVSOtdZZw6PCYnSo2tFgM37pm1t29flw1K5jkWi5x+Oxl0y4H0VeDIvU+llCF91X36Ktz6lYY4x34oGDUK+4YPw77hw/BrQYFf+RENIzCiYYTidgSrXreRO8eoX2uhK9+rHL21a68HAJyRbvZbNljt4uOM1M6g65LTHrkxpQWjRqGh98iAbRAjbz4yDG2HGZkZM9ZJqt+XvK92r1u3DuvWrfPaLxRz/PDD3jref99TB+Xc5jquUhxZPhtYeydNcreBDeGIiRFXd6D46reTXbccSF8Fjpx2SC1D+qr79FW49SsNcY6F8EjlVvJPc0hnnocC7sgdm7+2s7pPQHVajUkA3NNjhRvz4S42QdDB8eNhnNUvIW1f7ffXCVclI2TBZBLvlBoMTAo3ADh3Bu1VzlciGaMRuPwKxrbPPnP1tWfssdhY5Osc3fDFF+Kd6s6I0IUOEQgEAiFwiHMshEcqt1i7EZnXPxQmY5TG28sXm2mgu7Fv4V5YansFK+Q0LNBeH4Kb1cD0z1SfxwoXb3F+Fp1Rgq1XpFNqMrnnzRYux2+Dp212qwatRWN4ZX3Rzi417Xiw8Gc/RQG6fgWSdBAIBAIhvBDnWAiPVG5GGJAwMd+HcPfCuPNsr320TatM5QouJKIoXXDUv5d3cgdR0DyNCcUINJ8DbmtJECzjmeKsZf/pqFj+mGTdDZvmAwDaywbwHmcWenEhlHYNAA5c/w9Kn1smyQbjrrPRuOUiVH1+nyh53YBdXfd+IBAIBAIvxDk+RWFTiPFB8qqGEJpSbOJWsCeA6fX+HXC+BTo8l4M++uIHaD86RLJ+0+5p2LdwL6zNKV7HGAecdYYZG66/3tEnPL6p5zUu9pqnrRGo+OhJXhu8dIz8FTlLFiLp7BXiKuerg9yLBAKBEHJIKjch1q/H0H/3oCKTWbCg5R8DMFm4yL6EfUExRfl6vUfVuLlZh34ciF6moo0bpyFn3HJByWD1l9MSu+v576+aCMTnKKOvozILkelHvfaLbU9r8SjE5O6GvTMaJrN0/RRoDP13D4p6UsAwZh/7il/IBlurHuoYRrC9vJ8km9n6+c4r30g2y7Rp07D8x+W8x/icv2nTpvHKcUMYPMs99tg0vPFPIdDIZNWITD8Ka0ucWxluWIXcUXY+O1h7n3sOSOP0S0TyCQCAJq5BnjK44rLF2MvXb6EinLrlQPoqcOS0Q2oZ0lfB1aEk4davNMQ5FiIuDsl19UiuqwcAZJ19Fl7zU6Q+qj4opgSr3mDqLSvrhTg/5YPdrsJb/3B+brCpYQuyPrHtOfbKm1DrG2EXWAzDH8l19YhMoFD29kuibTi0JB8DXzsLAGBtSvUrz4eY88qlV69evDp8LXzSiyfWxJ9z2KtXL9hL7EAjULv2RtgtETDt9h0nLRd+Oxh7i4qAoR8z7VRyxFdsXDZfv4WKcOqWA+mrwJHTDqllSF8FV4eShFu/0hDnWIjmZtQlJzlHjrWVlX6LJLUzmRqUdvqCVW8w9fbqVYak9iTBssFul72dydms1wOLr7Tjx1Jhe8RC0/wjpWLbQ1sjmEmCAVCXnIT2GAqd+93rEbLB2pzstc+fzXar+9cE33nVCnyTlJX5vw485Rk94vunrKwMVDNzTmibBsYd54ouGyisvQCc7TSZgNzzPwqZDVw7wvEjFU7dciB9FThy71MpZUhfdZ++Crd+pSExx0LExWHvsOE4OHAgDg4ciC2JiX6L5DXmIa8xT3FTglVvUPQ6JiBNn77Rb9lQtuvwhg7ldPlwjuW0R+4o495hw9GYOcyrHik26PXi5dn6xZxXLhs3SpffuHGjaHm2TGQJs6AK98ElFDG7rL2e7dQm1AZfOY8d4SCcuuVA+ipw5N6nUsqQvuo+fRVu/UpDnGMhmpvdt329B+6mBNNx6AoTibgro5lMAOzKvShp/G1eQOU72inQtPdqcmJRIluFVN2srOcEOwCwWKXpDiZfrkRAfSuXrVtDp4tAIBAIwYM4x0J4pHI72Qia4+Dw23wtzBAqyt993m3bUp8Ge0e0InWzSynLpgumleOj/US287OYbBh0F3yA5MugEQy413tU78KQ6CQQCASC8hDnWIjZs9027Z4JW08C5C6jKwwtehJRKHCNYlOwNPZQptIAc9dKXSzDk6hI9+1gjNTvu/YfmHa5ZiCz51SJEdKgvlnw0bX+8h4rSb8n5itWV1d4C0MgEAinEsQ5lkC9QaFFMroQcpfR7U4YjcFwMNyd4yNPfiapdKDOsRL4fRjyEYbC90aAnZAnxgENdbgDgUAgEAhSINkq/DBi925UpTGv0Evjq/3KFyQWBMWOYNULAJ01mYjoUaG43nXrZqDv+A8EZYLZLi5GI1BVNQPn3LIBGKl8/W1HhgMQ3x6NhoI+Vr6T2N7BXJuFvRhnlPtQI8YGS2OKs5yQfM13t6D2h+vd9ok5r1yefHIG0u93yfvL2ztjxgzRdXN16Ge+BCQAl86nQBe5dAQ7rIK198EHIalfxCL2gVVOvylFOHXLgfRV4Mhph9QypK+Cq0NJwq1faYhz7IeEpiYkNDUBAI6PpAAIh1Y0RzYLHpeL4vVyZvQfengNKE2nonr1eqCqKg3JfsrLrd/eEQ1VZBvvMfOh4bCavDOLpKWl4X/PR+N/22WpdMdHWIXo9tBUgKP0FBKamhCZTMEzjsCfDcX3/ghbq2vIWEietkaAtkYAcI2+V1WlIcFugRqApYEJUxGakFdSkgYdR4e/dqelSY/nLilJQy+bHXEeOgwGIP5KIO504LLLKNCFyo9as/ZWVcHv9S6F6m9uk2VHOAinbjmQvgocOe2QWob0VXB1KEm49SsNCavwQ3VqKnaMHYMdY8fAGpPqV75HWw/0aFMorjUE9er1AN0ZDbs5zrkdqF6KomE0Ajk5JX7Lym2XzewdJ8Huq//1UhxfutTreElJCVqqWiTrAgDj7ilu2+xIMQs7D01Mezoqs2TZ4K6QuTbNBu9r0p8NltpezvPtT57N+sANhRgypASpHUxu5JJnl/s1NSenBJofFvuVYykpKUFJSYloeVZH7L9MbmPzwVHO/aEIG2LtFXO9S6HjRI4sO8JBOHXLgfRV4Mhph9QypK+6T1+FW7/SkJFjPxwYMgR1KczCCap2A4AtgvKDmgYBAGqiaxS1Ixj1ilmWVo7eyEjGU5w0aQtimgYJllWyXTXf3gLQFJr/vMC5j+vsb9myBbVttYBOet2txWNgGPUbAGD/DTtAW6J45cS05+jLb0GJdBUHhgyBySP5hl7v24ba76/jrUfqObjnni3YcaIftsSXweYxQs+XrWLSpC3QxBnxp6jamfMEADk54p3DSZOYMssX7vU6Vv31HVDrm9CyZ5Lo+qTA2jtpEvxe73IQGy8vp9+UIpy65UD6KnDktENqGdJX3aevwq1facjI8SlMsCbfPfFkcOrl0rj1Qq99dksk6n+5EqCZyzrUE7/EZjFj3eJwZiFgR4OVQqvx7ezzJXlRJiuKbx3cvu2s7YWjL3wAe4eMp6IQc2jJt87P0dFk8iKBQCCEA+IcdwM6qnqH2wRJPPqI67OvZZYDpeYb4df0vhzPw4cC183G4AaCXh8cp0fogScigpLkFAs576wzajQy9V1ysW9ZZtEQ9+tA6QeziROByZO9Q0A829DV06LZO105+j75JIyGEAgEwikMCavoBtg7o4FulEWuo0OZemxmPdQ6lxdlLhmCig+ehjaxyjk67Ik/x89mUeCS96FbLIcPA70UHDntrEsXJ+fjvHTWpyMiqdJr/8kwYtnd2lBSApz3DfM5VIuXEAgEAsEdMnIsRH5+uC1gCNLoq1KjaMX3rEPJ0x+7dlA0DAZ2dDEA2z18g/J3n0PHib5o2XeGT3l/r+ttLQkybRFuB0Uxf6KqUsDpcatBpLNOg+LNbRzoqoEGA/DFSubzFVcInwPjP1MC0kUgEAgEQrAhI8dCrF+P0Tt2oCaZmZBXlFYPDBYusit5l/J2UHRw6hWBGL2WukxY6jKd27RVC5MJ+Pbbmej3xMcCJYXr54Zk7Fu0R5QTKPS6fubMmbjnHiB9yv/5rUcuYvqrf38gsi3wUc3RO3Zgf2/KK62cPxs8++jbz69G/+dmidb72GMzkXYv887fYADs7UAc57hn/TNnzsRzqzdCOxLOFHJCD2YzZ84UbUsgZZSC1X3PPUD/M94NqK6cHCD3Jebz/PmAcYf4MJiu0AfdBdJXgROK+5T0VXB1KEm49SsNcY6FmD4dhg0bYXD82hcn+89z3KKVlyrMH4rXS9EwmfiHOg0GoM/r8vU2/HoZAKC+PhmpmlbB1xNC9VNcp8/hGLOxuhQF1P60ECnnLXeKtB8bJGhXcnIyOvnTObtB21WgVHa3fZEeySm4zl3LgdNdn0X2lxIxtwaTCRHt3ufQlw0mH9ka6uuTkS7hPB8/noyotghE6OEcUa9e9V+otB0w/nOWl3xycjJeeDUaD20FrrrajmffF64/2fEwKgU5ZZSC1V1fD0n9yAdtifQv5MeOcBBO3XIgfRU4obhPSV8FV4eShFu/0pCwCiFmz8aJjAxsmzAe2yaMh1WX4bdIujkd6WZxMaBiqfn2FsXqbd55No6+/KbgKCzXcROj13MUkJ2wNmBAMdL95H0Vqr/tmPcwPXe0tfrLu52fD9y6FW2lQwV1FRcXIyenWFCmbv2VKHnGe7T7uWddTqhnBoFjL7/l/Cymv6wt8YLHxXIiIwOt8Rmgre4B6Xw27Fu4F22HR3jVodc7zpOEa2vAgGJovnwMFcsec2aAsDSk4/jrr4Hu9A7RKC4uRnM5sziGmJCS4uJiFBcLnyclyigFq3v4cGn9yIe1OcUV5iIxnKor9EF3gfRV4ITiPiV91X36Ktz6lYaMHPuheOBAZ55jqiMagPAS0gOaBwAAKnXeE5zk0nZkuGL1lr/7rM8cvVyK7twA2qbF5CWP+tXLNwqq1wMTJmyHrjUH1fHHfJYValfDxssQO/gvv7YC8LmICZft27dj5Ehgp0A9VZ/fj8ie0m5wbvYKf+dp/3W7QduUmV1ZPHAgTNGAvc290f5s4PaR0QgsWrQdMc0DvOQpij+rxoQJzBKDy5cv9Fs/wPR7fVs9oOPPg+zJ9u1M/bm5uX5lAymjFKzuO+8EdlZ596NUiu/5CT0ufJd3FF6MHeHsg3DolgPpq8AJxX1K+qr79FW49SsNGTkWogtMyGs/ka1YXfsW7nVzjIUcSWtTKmymRHQ2SF8SUqncrJ5p4Lj2eqYk80zhFQhiJ9Z56vbl93GXAWYd41CnFONb6U4MfA8+fDmF/dbv6FOSgcE/NlMSKj9bAij0EEUgEAgEaRDnWIj168NtAYy7zlakHq6DxjozvpwkruNmb4sRrLfqqzsEj9N27xjtEx8/LFiGhRtzHKy8wJ7QNFBQ4L3/v3e6e8zcjAx8GSC42Frj0Fo8CpVf3OPcF2hbXnnV9ZnrmCvhdNdvuAyHlqzxedxXTmEhKJd3TPABbae6XV5mAoFAOBkhzrEQ06eH2wLFYCf6iHEy2YUd9HpHjmUBGn+bJ3jcUu8ep33slTfQsGm+f4N5bAoVYkY32RFVa0uc2zYfDb/OR+mzH6P+52uUME8QJfqptWgsOk70C7wiHsjIsRCU895T8k0IgUAgEKRBnGMhZs8OtwWKwYYoSPmxNRrhNdmLp2YAAiNcHqERnfVpEJv72N/qelJGb1n4ljL2xE7b/QsBOPhAPg49sFZQpq10MEC7K1ViNJAKJH+0BJQeuSTOsW806tCcUwKBQCAIE7QJeRRFzQDwGpjcZx/QNP0cj8wUAK+CWf+tjqbpycGyRy6n//knGuOZ0UGzqhmrhLOF4e+Uv4NiR+D1er+yFcO335+H/s/4zt3KjiwbjcBQjyQP69fPgWrQz4gfybGCfbtu1YDSWHnbZWuPRskTXyAi7ahbOc9Rb8/RWn/p0ebMmYM5c4CJ3wrnOfZ04MyHhqNxy1ykL3jebX9nlXc8uGd7WAdf6bCQB+4HHov+E3v7ALOpfPymn+2sX+q1sn79HGROfMttn5C9c+bMkVT/nDlz8Fv5b8BOcQ8eUuuXW0YpuLrf+votAcnQ2XEq6ZYD6avACcV9SvoquDqUJNz6lSYozjFFUWoAbwI4B0A5gB0UReXTNH2AIxMP4C0AM2iaPk5RlHDOrzChM5uhM5s5e4S7rE3TprgNNB2cesVgNOkFdQvlZa2oiEPCmRGI5zlWfPcvGPjaWbx1W2oz0XGiLyit+3rHfM6vvSMKqsh2nzZwiYuL8y8EeMXFWpp6OFOWsej17vawDx6hOk99O/ZBR5uh6aTwBS7H5aYvAMyWZUNFRRyGfswtQwk+aIjuR458VKP/DCly65dbRim4ugM5/4G+DegqfdAdIH0VOKG4T0lfBVeHkoRbv9IEa+T4NACHaZouAQCKolYCuBDAAY7MFQC+oWn6OADQNF0TJFvkk5+P4717oTSbGSHMLi0FIJymqWdrTwBAeUy5oqYEXC8tb+GJwQOL0bO1p6BeXyPS+/btw5CejWjm7NPFAO0ArM3JsLXp0MeeCMC9XU3bmNXa2nnyHHtSdMcmUGqrXznWHjF4jW7yhHf4GlX1PE92M9M5Siz6wWUginC8dy+0JFKIQSHOwXqwzrHUa2Xfvn1+z7GnPADk5eWJlq+vrQcgLpWb1PrlllEK7nUlpR+9CDCqoiv0QTh0y4H0VeCE4j4lfdV9+irc+pUmWM5xJoAyznY5gNM9ZAYA0FIU9RsAPYDXaJr+xLMiiqJuBHAjAPTu3Tsoxvpk/Xoc6dffmefYrtbAn3Pc19gXgPLOsdx6O6p7ITK1zL+gD8YM34sYY1+feoVev+/cuRMXTaoHN9rC3Or6XPLUZ5i6+DUArnYxeYDFXZbM6G2s27YQO3c6MhwLOCEUBUTn0OjLpHdGw6Z5qPn2VlH2AN7nqSb/ZtFlpVCEgbD1a4UpGmjFVvyC6fiPDxsAJh5b6Dz1FTjHfPKA+C/BnTt3orG9EYgWF3MstX65ZZSC1b11K9C3n/h+9MTSEZh33BX6oLv8MJK+CpxQ3Kekr7pPX4Vbv9IEa0Ie37e856+iBsBoABcAOBfAIxRFDfAqRNPv0TQ9hqbpMSkpKcpbKkQXyVZhbxdOpyZE3Y+LAACdtT1l1hCcSUJ6ztLDXJg8wPw6PZ3foM3s56SQO/Hxo7A2y18WM5DlgIU4HOlaDfByfIHf9MKTR6WOXAcrhZiYkePuis0WWHk6RJMsCQQCgSBMsJzjcgC9ONs9AZzgkVlH03QrTdN1ALYAGB4ke7o1fEvyiqVx8yU48uSnMO2epqBFLqQ6XVZTAgD/jizfIh/BTmtVfM86VptidXIn5CnJ8y+4PufTs0X1jZhsHgDw9ddB6GuyCIgoxGZdIRAIBELwCJZzvANAf4qisimKigBwGQDP5ea+A3AmRVEaiqJ0YMIuCoNkjzy6wCIggUOh7ciIsGk/dMj1ufiuX2Btcs27pG0a2P2migsdlrpMAO6Lj7AEOuAZzny1HVV9ACgf9yyFwgOMd/xdPk0cQB+YCphkPeE8TwQCgUAIknNM07QVwGIAP4NxeFfRNL2foqibKYq62SFTCGAdgH8B/A0m3Zu4GVOhoouEVYihs4Zx7GxtOp8yckYvxeQFFsJmc70qtjiWombt6KzOQtuR4Wg/0TcwJUrD4xzLhg5OiMJ997k++3M2j736uqS6L7mYUtx5tTuuA9rGXFDEAXSn+K5fUP6uV7ZLAoFAIIQBqjvFAI4ZM4Z2TqoKEQXDhsMUy8T86ltacdXdwnlaI2wRAIBOdaci+iuWPYrGzfMw6sPRgvXuW7QHhtEb0HZsEHJfPN+1f+HegEY9zWYzzlx5pm+9jvoNBqDP60Od+/R6oKrKjJRUC3LemOjcD7hGYQ0GwGZj0uTlvHW6W1mjkb/OQEZgzY6UfKd/5Tk3lGHvNYx9Mbm7kLNkoZvNer04W0Z/5H6eVs5ciSFJQ+Qb7YOzcz7FS7EvYW8WhavXFgCA8zz0f9XdBrYNrIwnqalm9HzWdY6Pv/EyjDvP8XndsP2o0/l+EPOUT0mxwTD7HdT+uAg2Y7JPW+TUL7eMUrC6U1KAga/7vleE4J4jQN6biq7QB+HQLQfSV4ETivuU9FX36atw65cLRVG7aJoe47k/aIuAnBTk5yOysxORDdwfO+EuU8op7qjMgnHXNDRuvkRcvbQKxp3MSLelKRna+DrnIYqSHxag0+ncdJv2TIR++FY3GYOBf0EOnU4Hc4vvuhkHWOeVL5h1OqUu8uEPnU7ncLiF5dqODPPaJ9YWpc6/P2hQiOzshNrqPonLZPJtg68R7JoaHXpIsFvql59Op4PZDJhX3huU+uWWUQpWt9mszPmX+6ahK/RBd4H0VeCE4j4lfRVcHUoSbv1KQ5xjIdavR2l2NkpzHHmOS0rhnqHOmz4mJr7zmP5YQKoPPei+LLGkev0suyyFgoIC9DH1ceo99uobyFs2wk2GdRRLX3zXGbfLlh03DuD6x54//Fu2FAAArtrDbHuOxnbWp4nOY+yPgoIC9O0L+KqNXYWPyZjhzZGnPnXmLfaF53kaM5qCtiE4Mcel2dkw8iTSiN94I+JO+9nrWvFlw4gRBYhc/TBaL36K2eHn+ikoKHCUGyHKTvY6+PNPl7yQAyi1frlllMKlG8jk3CtSCfTNSNfog9DrlgPpq8AJxX1K+qr79FW49SsNcY6FmD4dR9f9jPpkxgOhaGDwsWM4lEHBouV3ILJasgAE7hxLrZcdGaYoOPMEtxZ5vSmQTEFBAbJasnj1Nmy6xG27df8Er7I33QSwizXzjV6zN5SvLFYH7/5FosW+KSgowIgRQP5nDyDjSv74TpPJ23FjV8NrOzzCrw6+8xSs+Nqj2dlo4UlkkhtnRZTjnDVtP99bwIMRIwoAAGzAEk0LLzUu50v7ppuA7dvFy0upX24ZpeA6xzE+7hUxBPoA1TX6IPS65UD6KnBOBYdPKU6Fvgq3fqUJVraKk4PZ3rlj//e5HdevF447VgJu/l7JIRF2FRr/mIXS55Ypb5hbDuDHnJ/5HMpACUadANCwYYHbdtuxgSh5yrX+DNdJYVPIybXF3hbrX0gOPkZ3Pe0qf/d5v1V5TrqMjg5vdo3ujtpGI8LSfeZyEAgEAsEdMnIsg561XfuH78SnD8PWEh+Uui0WYOSn7vt8vQ5evjwwXcFw0PiybzT/fS7Mh0cGxZbOmtCu6mg0Aq+8Axxpct8v5MxPZOZLOkeOP/88GJadOjy2woaBFcCnZ6mwdhwZfyAQTkYsFgvKy8vR3t7uV3bIEGZSdmGh+Gy1UsvI0aEk4dbvj6ioKPTs2RNarbj0scQ5FuKhh0SJqW00YtuB5pjgrHBFUcBtz4qXb9k70W07kGwVW7cCUf1c24mJNPq8Fni94WLiROCDD4Ch3DWtOaOwgYxOGwzA1Uvkl5eC0GpqhUVARJprO9BYVoIUaAysYD5dtclOnGMC4SSlvLwcer0eWVlZoCjh3/66OmaCfHKy+NVWpZaRo0NJwq1fCJqmUV9fj/LycmRnZ4sqQ765hcj3XLeEn8Vr7Xh/qQ1UF/AWlQ5F8FwS1ySQfaK74JnDl7Yy6fcCXYXPV2xxsJZi9oXdI+qH5BQOHSqZXwGhvkYIBEJgtLe3Iykpya9jTAg/FEUhKSlJ1Ci/swzJcyzAvHnYe6AQ7RGM8xTV2QmNzYZD6cBDC12D7iufs0JFA5fer4bKMRhvU9l4qxTLsf/sdTpqFAUM/2iEYL1sjl6liYiwYPC7Y5169123G3kfjhKl02KxAABGfe5bXoyMUrC6IiK0yFvO5Cyu+fYW1K69AbRN65Z/WU5+Zb7zxD2PSjI1+3O8pnsGe/tQWPCTe/7opNN/Qq+bH4RNZfPKLc2H5zl47azXMLX3VL/yYl9PBVtebhmlYHXHxACjlo7Bsldd6dzmPyju5ZwS131X6INw6JYD6avACcV92pX7qrCwEIMGDRIla3eMWKhU4scjpZaRo0NJwq1fDHznjOQ5lkNqKjR79yG2rU10ETlOcemL74K2RCBnySLnPs/RvkCdbblYLFp33Tbxl4yYLzStVuuWe5hNpxYMh5LPnppvb/XaF0h+Zc/zFKxwhogoChqbDSo7M2rBHXm02tWSrhepPzxdTV5uGaVgdVssAE3Ju08NhsCvla7QB90F0leBE4r79GTpKzkOo9Qy4XZKw61faYhzLMClH03HlVOPocSR5zinpBT9Dh8WLHNOcTaaYijs6FkiWk/r/gmI6HHcaz/3BzPHmAMAKDGIr1cJJk7cgURjDkoMJaj66g74zLnGw44dO0TJDBwIcB8/ghUG4LJnrNcxz9fax155A9aWOEn16/WhO0+v/B+Nw2/1Q2MS5TUqPLxPFRIc50wMnueJ8nOOWfmxY737MRzycssohUs30Ke1L4CDkutQ4prvGn0Qet1yIH0VOKG4T0+WvmptbQUAxMTEBK2MHB1KEm79SnNyufoKs6ptNsp690ZzQgKaExJQ1tt/5oF+Tb0wpqKndGU8qbnYH0yaBnq19kKv1l7S6w2Q3Nz9svXu378f+/fv9yszZMh+FN/9M4rvWSdLjxL2eI7amfZMRtuREZLqNxpDe57KeveGKclb14CMekk2iDlPXVlebhmlYHUPGbIfae0y7n2F7TjVdMuB9FXghOI+PVn6qq2tDW0S3kCLLbN06VIMGjQICxYskKVDScKtX2nIyHEYMRZMhumfKcyGI38wbVPj+Bsvh88oD7gT8uwdPCtOKISlPiNodUuFXfSDu9318D26S1tPjleR3REyNYdAIISKt956Cz/99BOys7Od2SK6ElarFRpN93QzychxGDH+fS4aN7uvMtdZlwHTP74nQ4UDqykBAGBrdQ8zoCjvzA9y8Mw9HApntP1ENio/v4/3mNHovgDLqZYGjcy+lsfkyfLLds0HMAKBoBTZ2YmgKDj/Av3tvPnmm1FSUoLZs2fjxRdfxCWXXIKpU6fipptuQp8+fQSd5YsuugijR4/GkCFD8N577zn3r1u3DqNGjcLw4cMxbdo0AEBLSwsWLVqEoUOHYtiwYVi9ejUAIDbWtcDV119/jcWLFwMAFi5ciLvuugtnnXUW7r//fvz999+YMGECRo4ciQkTJqC4uBgAYLPZcM899zjrff3117Fx40bMmTPHWe8vv/yCuXPnBtZRMumeLn2ICPYPVnu5K4EwX5hOl/nB9LEaG6BMrCSbeziUHF4iLk1fd0Tt8cjbZa6jk5ytW4GYHHllT7UHMALhVKOlxf2LOdDfznfeeQfr1q3Dpk2b8L///Q8TJ07EnXfeiZ07d7o5vHx89NFHSExMRFtbG8aOHYuLL74YdrsdN9xwA7Zs2YLs7Gw0NDQAAJ588knExcVh714mo05jY6Nf2w4ePIgNGzZArVbDaDRiy5Yt0Gg02LBhA5YsWYLVq1fjvffeQ2lpKf755x9oNBo0NDQgISEBt912G2pra5GSkoJly5Zh0aJFfvUFA+IcyyBJoQlj7ceZlCI0DRw3AhesAfr1Aw7KyK6nxGx3PtxGdTlOctNfM5RXFiK6R9iEHwQGd4cNA4qY7zVZC7X4m5BH4MczJ7gUgpmlhUAgnNxs3boVH374IQBgxowZSEhIEJRfunQp1qxZAwAoKyvDoUOHUFtbi0mTJjkXyUhMTAQAbNiwAStXrnSW9Vc3AMybNw9qh/PQ3NyMa665BocOHQJFUc70fBs2bMDNN9/sDLtg9V111VX47LPPsGjRImzfvh2ffPKJ6H5QEuIcC2AyAWf9+qvX/kSBhTBY+bdPF+5aW5sOgHjHbHP6ZsHjwcrw8MEHC3HflvuAUuCzFTRm9QX2X7cbtJ1nHWYPFi5cCAD4v4//z69MKGB1BVOlv/OkJGf9+iv+zfJ2ZCdcOAHvrntXdD1izhOfvNT6gyUvt4xSsLoXLQLOeOMl2fUEeg93hT7oLpC+CpxQ3KcnS1/JWTVOShmappGYmCiqzG+//YYNGzZg+/bt0Ol0mDJlCtrb20HTNG9Ina/93H3t7e2Iiopy6udmrHjkkUdw1llnYc2aNTh69CimTJkiWO+iRYswa9YsREVFYd68eWGLWSYxxwLMQnBfvSsdz6pE/C9fnV98zny+8krmP23TAjRz6XTLUdcgwdf/SsVl81YcJEjMsTxmIR+RFunlGrfM8S9EIBC6NUqvXstl4sSJWLVqFQBg/fr1gqEPzc3NSEhIgE6nQ1FREf78808AwPjx47F582aUlpYCgDOsYvr06XjjjTec5dm6U1NTUVhYCLvd7hyF9qUvMzMTALB8+XLn/unTp+Odd96B1Wp105eRkYGMjAw89dRTYX04Is6xAOdgPYoG5uKn88/DT+efh6KBuX7LFA3MFSUHuDtONITffw9oHoABzQMEZYIxejx06DYMjXE8uTnCKsROVtu2bRu2bdsmWL8YGaUIti6Tif88BeO83HknhaKBuahPz/VywI8UHPF7rXDZtm0bpk519csFM4Udeqn9GGx5uWWUgtU9ZeLvmPtvf8nl28ullxGyIxyEU7ccSF8FTiju05Olr1paWnDiRIukid4tLS1oaRF4Tc3hsccew08//YQRI0bgp59+Qnp6OvQ+vO8ZM2bAarVi2LBheOSRRzBu3DgAQEpKCt577z3MnTsXw4cPx6WXXgoAePjhh9HY2Ii8vDwMHz4cmzZtAgA899xzmDlzJqZOnYr09HRYLBZee++77z48+OCDOOOMM2DjxJ5df/316N27N4YNG4bhw4fj888/dx5bsGABevXqhcGDB4tqfzAgYRUCbI2ejskZP6PFcZFVZmRiYFGxYJnKjEzHpyOCcq2FpwNwOU4jRwKZjwKHD1Fe8YcGA3D1knQAwME47wUG7JYIkS2SzoABBxEZpUGZjLIHDzpsFRiIZGUmTJggQ4M8e4KpK7liOLQJNfhp6SNQaTv9F5BJewdzrbVEMdtcB7z6WDXSzenMtZKfD8yeLVjXwYMH0acPUMvZJ+TQS+3HYMvLLaMUrO6qAWnIjDEDKJJWAe29ymEgdoSzD8KhWw6krwInFPfpydJX7e3tANwzPChR5ujRowCAjo4OrFy5EhqNBocOHcKmTZsQGRnJWyYyMhI//fQT77HzzjsP5513ntu+2NhYfPzxx16yl1xyCS65xJVtq66uDu3t7W6jwwAzIu30BcBM8AMAjUaDl19+GS+/7J26duvWrbjhhht4bQwVxDkW4EvzbLx168+K13vw/rWwNKS57XMsLuOE65z4G3nsrPa/OAkhNHTW9EZnTW/JC4jIhfe5w9iMnnU0ptTagXcuB774wq+D7IaMSXwEoNaehEzIWxlRzsRJAoFAAIDjx49j7ty5oGka0dHReP/998NtkmxGjx6NmJgY/N//iZsDEyyIc6wgYiM1O6uzvPZZjcxMzcYtwjn9OuvTEJFUxZRpToQmrsF5LGjxv+SHWxS++j8450VgERCjEQYzcOGvdsBsBtavF+Uct5UORnT2ASWNPPUg9wqBQAgx/fv3d4Y7sJPi6uvrnbmKuWzcuBFJSUkhtU8Ku3btCrcJAIhzHHZYx8nepse+RXsEcwp7cuy119H30QUAgjzyROZnicJoBNg3SsuWBVeX5xszNwdcbwDqHLFfOh0wfbqoOjsqsxGdfQB0Z5QyRp6CkFuFQCB0BZKSklBQUBBuM7otxDn2g9pmdXqeaptVUJYWIeOU9XBmmdy7Krdt7mebyjuJqp11YoLoGFssWqhZYyU47gCg1TqWMRboEqdMCAiFrlC2R22zgrJ7n5N/ShNwuu04AGC2+Qv8duVswckfWq0WFgtw4suHYC4ZitaisYJ6pbYx2PJyyygFqzvZXo3ITveL/cy9dvw+VHjeMy3xvvJnRzgIp245kL4KnFDcpydLX8nJACS1TLizDIVbv9JQdDcKdhszZgy9c+fOkOkzGIC/MgbxHpv/oOu5YuVzVqho4NL71fjyeZvXcQBo2n4e4sczQfD7Fu6VPNI79OOhAABLfSrajg9CxUePQxNXh/5PXYzOE/1Q/KDvVCqBQFFAz1vuRfzp61D29vNo/ut82bbvvWZvECw8NZmUvQrvRj6GfX0ozF/PhEKw5yUmdxd2UkzevcHFhW7HfMH3vdaNvhq6BosXo3DDRrddu/tSeG6+cE7wxM8uwOZfngumZQQCQWEKCwsxaBC/f0DomvCdM4qidtE0PcZTlqRyE0DRFFwc5yPQGFSbKQE2U6JzO3TZTk6uJ8OTlc6aXpLLBDMH5ykDT/iK0PNFVhWNeb/bcA0+ZrKKEAgEAqFLQMIq/LB/yBCUOpZTzC4txZD9+/3KMxQjZvtwtI7f4yVjMklf7nlQE/O0s1fV4HVs316Auig4y89OmrQZcTFalMoou3mz/9XiWJnJkyfL0CCNUOgKZXv2DxmCmljv144ThhVif/IQv9cqy+bNm7F2rXibpbYx2PJyyyiF8zqPi0PtEPd+H32ExvL/s2Lh3e5ftVorjReWMW+ZdvW2iJ40KcaOcPZBOHTLgfRV4ITiPj1Z+srkGGnzlXtYiTJydChJuPUrDRk59kNNairaYnRoi9GhJjVVlHxNairSn7wJFch07m/49VI3Oamj0j3aeqBHWw9kZgLXXut45W1jfnBtbXpZdYqhf/9SZEQwr4VpmpI0olhaWupcbScQGaUIha5QtScikkJNaipaE5iZydzz0r9/qdu16u+cSbW5q8nLLaMUrO5PPy3l/Y7Q8aS7fukDzhwCjUb0pEkxdoSDcOqWA+mrwAnFfXqy9FVHRwc6OjoUL7N06VIMGjQICxYs4JX/7bffMHPmTMn2ykFOGz1pamrCW2+95dw+ceKEWy7lUEKcYwECeQD63eJKoVL27rMwHxyN8g+fQO3a6wOyibuSXkdlNio/vxdlbwYvH+DEiUBKCvP5y5XKj0wT5PH668x/jdp7taWJE12flV6inOAbm/ecWSf/XeN+MJ2zuis1YEDAo8YEAuHU46233sKPP/6IFStWhNsURfB0jjMyMvD111+HxRbiHAsQqFNR9+O1sDYnomUfs7pP0+9zUL36Dsn1cJfyrSgHPvmEjf2lUL/+alibUwIzVCwk5LjrcJLNDD7ZGV8kEH3czVf/IhAIIsnPBxYvVmSOwc0334ySkhLMnj0bzz//PM4//3ycddZZmDBhAoqLvVfy3bx5M0aMGIERI0Zg5MiRzjCIF198EWPHjsWwYcPw2GOP+dR39OhRDBo0CDfccAOGDBmC6dOno62tDQBw5MgRzJ8/H9OmTcOZZ56JoqIi5/5x48Zh7NixePTRR52r/bW0tGDatGkYNWoUhg4diu+++w4A8MADD+DIkSMYMWIE7r33Xhw9ehR5eXkAgNNPPx37OSFrU6ZMwa5du9Da2oprr70WY8eOxciRI511BQpxjmUS3eFv+j+N9rJcFN2x2W3yHIuUUWmTiZO2DYDFwl/HSRLqQxADSSVx0nDfp0PDbQKBQAgyEevWAZdfDrz5JvM/QAf5nXfeQUZGBjZt2oRbbrkF+fn52LRpE5544gksWbLES/6ll17Cm2++iYKCAvz++++Ijo7G+vXrcejQIfz9998oKCjArl27sGXLFp86Dx06hNtuuw379+9HfHw8Vq9eDQC48cYb8eyzz2Ljxo146aWXcOuttwIA7rjjDtxxxx3YsWMHMjIynPVERUVhzZo12L17NzZt2oS7774bNE3jueeeQ9++fVFQUIAXX3zRTfdll12GVatWAQAqKytx4sQJjB49Gk8//TSmTp2KHTt2YNOmTbj33nvR6rnksAzIhDwh8vMR0dkBym4HAER0uuJp7vjOjtdnAa3RrjRN9b8sQITuCABgEjZjPVxpJAKdLNdQOApQ24Axhc59oXhdrtPpQLcyjhglcehYp9MxH9pEyISAUOgKZXsiOjtg1XqnCdPpdLB2io/9kmpzV5OXW0YpWN1mMxChlh5z196urB3hIJy65UD6KnBCcZ+eLH2lUqkQ8dtvzJcEIGrlUpVK/Nhlc3OzcyRZo9HAwo6gcTjjjDNw1113YcGCBZg7dy569uyJ9evXY/369Rg5ciQAZkT30KFDmDRpEq+e7OxsjBgxAgCzzPPRo0fR0tKCbdu24frrmZBRtVrtjD3evn07vv32WwDAFVdcgXvuuQcAQNM0lixZgi1btkClUqGiogLV1dWCbZw/fz7OOeccPP7441i1ahXmzZsHAFi/fj3y8/Px0ksvAQDa29tx/PjxgNPsEedYiPXrccbWP3gPGVppPPhJDT7cvgz0wPsBADeubsAZ2Yz8SKxGJDKRTysTS/jlyisAALljlgOgQFHByU7hyfz587F903bguHTneP78+QCAJz9+0q9MKAiFrlC1hwaNM7b+gdIc7x+P+fPno/BR36/H+OSl0NXk5ZZRClb3pZcC/8sV3+/BsuNU0y0H0leBE4r79GTpq8TERMYR/uILxjEWsXJpYqL3G2dfPPLIIzj33HNx++234+jRo5gyZYqXzAMPPIALLrgAP/74I8aNG4cNGzaApmk8+OCDuOmmm0TpieQszapWq9HW1ga73Y74+Hjs3St+HYMVK1agtrYWu3btglarRVZWFtr9jBJkZmYiKSkJ//77L7788ku8++67ABhHe/Xq1cjNzRWtXwwkrEKI6dPx02jfDuFazMRauJzfy3u6FuKIRjvOwXpFzPAVLhGM7BR8sJMAT7YVcLozromZ5Jx0NyI73UNi8miyOA6BcNLDOse33cb8V3ASbnNzMzIzmexYy5cv55U5cuQIhg4divvvvx9jxoxBUVERzj33XHz00UdoaWkBAFRUVKCmpkaSboPBgOzsbHz11VcAGGd1zx4mhe24ceOcoRcrV650s7dHjx7QarXYtGkTjh07BoBJA2cScGwuu+wyvPDCC2hubsbQoUw42rnnnovXX38d7IJ2//zzjyT7fUGcYyFmz0ZL6lDkXzgb+RfOxr/DhzkPaexACfpCr3e5JzatFv8OH4Z/hw+DDSr8gsDTMwHM6PAvv2zAtGkbYG1Khq3V4L+QQmzYsAFRpUy8s9SR4w0bNmDDhg0ByyhFKHSFrD008O/wYSjvNZDXBu616g+pNnc1eblllILVPW2auH4fecTdOR6IIkXmV3aFPugukL4KnFDcpydLXxmNRhiNRsYhfuMNUY6xs4wI7rvvPtx///0YN24cbD7S5rz66qvIy8vD8OHDER0djfPOOw/Tp0/HFVdcgfHjx2Po0KG45JJLBJ1TX6xYsQLvvvsuhg4diiFDhjgnxb366qt4+eWXcdppp6GyshJxcXEAgAULFmDnzp0YM2YMVqxYgYEDmd+xpKQknHHGGcjLy8O9997rpeeSSy7BypUr3d4oPPLII7BYLBg2bBjy8vLwyCOPSLafDxJW4Qc6MhkdEYxzWJ+U7NyvsQF52ItNJvdVsFgZFeyYGPEXAGWeDsvLy9GrF7Dx8S8VqU+KXo1RAyTIKwtAcHDTKRMCQqErZO2hKNQnJaM92vv5try8HGbOteoPqTZ3NXm5ZZSC1Z2VBdRHiO93liJ4P+AEYkc4CKduOZC+CpxQ3KcnS191dvIkO1egzNGjRwEAycnJ+PPPP52fn3ySCWWcMmWKM8TidTb/pwfspDl/ZGVlYd++fc5tNn4YYGKR2ZHh5GTXd2BmZib+/PNPUBSFlStXYsyYMU6Z7du38+r5/PPP3ba5OlNTU2G1Wt2OR0dHO0MslIQ4xwFghsBkAVUE7ktfAeBpxfSpPeZehTo7hdSRY0LwoAUXJiaEg4kTAfPf0stt33278sYQCARCmNm1axcWL14MmqYRHx+Pjz76KNwmiYY4xzLpWQ/MTPweWXiI32WkNNhVlozR7HZ+PjM7dfp02bFGEycCH3wg02CZbN0KaNIAJABz5gI4JG0S4NatAM5kPodqEuGpAMnk1gWprxcl5vl9YW1MU94WAoFAkEF9fT2mTZvmtX/jxo1ISkqSVNeZZ57pjD/ubhDnOAC0tB3z+n0FO+2dTssKFR63P4p8AMjPR8Vti2GMicGgZcsUD8YPJjYboAPzemcsduBXk/dN4688l1BNIjzZufO/wMWTmf4lDx1dhIaGcFtAIBBCCE3TJ91E9aSkJBQUFITbDMWhJY4oEefYD5TVDJWa8fCi28xuxyJsGtg9Yh1YmXY6GqfBEXO8fj2MMTGMgIj8hnwYDKGbhMdFbzRiEMoQ3WjHrUeewX8wGGLjqA0GA4xGoPz9p9Bexp9mJZTtCoWuULWnvYNGdJsZnXbmFuY+dBgMBtAe16oQUm3uavJyyyiFU7daLdjvcZXRaE7nT/qtxJuALtEH3QTSV4ETivu0K/dVVFQU6uvrkZSU5NdBVnvGRIpAahk5OpQk3PqFoGka9fX1iIqK8i/sgJLqTYeTMWPG0Dt37gypzqeuHYyLt/H3UZm+Dr1M/BNwYk0m9DxRAWrJElhazTi8bh0AYFDZ8W41cvw6tRjzenyFxoREZFZU4OOWq/Ef+g3R5fm+M7rRJddlOaPfSnygeRz7k2Mw7w/mnuD2a+FAJgH6oKJCvuKEYLB4MQo3bPR5OLa5Buc/l4HxhXb891u7c39e8T7YeN4+EQiErovFYkF5ebnf/LyErkFUVBR69uwJrVbrtp+iqF00TY/xlCcjx0L4Wd7Rl2MMAC16PSgAbR9+iKPxnFQPd97ZbRxjANgaPR2zVUw/tKsisTV6Ov4jobxe7z6qSZa4VgbWD45EB2Yh3y3fNiFMTJ8OCDjHLXE9MLXAjrZInyIEAqGboNVqkZ2dHW4zCEGCOMdCrF8Pe8JIfDunNwCgz7FjGLlbOMH0P6OYZRhZuU6NRxc3N8syZd26dUBJCWYcOBDQpD6pLPomAjt+moMhP69H5J234cvHxetdt24dVq0CZsyYISgDCMsoRSh0hao9oyP+xT8jRsIUReOLPy7HtdFfgA13WbduHRpGjfR7rbJItbmrycstoxSsbkRE+O33m3+yw+bxNmUm1gK4SDE7wtkH4dAtB9JXgROK+5T0Vffpq3DrVxriHAsxfTro7T/DEhEBAGiK95/s101GowGmTgX+3uFWp5zMFVX798NeWIia775DyrJloEIUmlFVVYUOR+JuOBx/KWWVkFGKUOgKVXuun3AAf0RkokNLIwZmfHnterDOcVVVFcwirlUWqTZ3NXm5ZZSCq1tMv6s9woqYlTQvUtSOUBNO3XIgfRU4obhPSV8FV4eShFu/0pAV8oQI1PlcvRrUZZd57TYtuhYV33wDXH6539ANJydOoD0iAvVJybB1dDDOdX4+sHix+DoC5SSbldutGTzY9VmnYx60+AjVtUFg0hbK4I/oc5Q1hEAgEAgBQZzjYOPpUK5fj/KUFBgNca7MFf7Iz0dHayucGVIjIoC4OJivWYiO99+X5mQHAplJ13UY5limWKXynuDJzbcbqmuD4JW2UCyfG2cpawiBQCAQAoI4x8Hk4osBz+wa3BE+oRE/LuvXw6bizGY/cxLQ3Ixjqakoyc5hnOwgLJ/oifWDD4ij1UVwrpBHUd5vOLj5dsU+gBHCx9q14baAQCAQCByC5hxTFDWDoqhiiqIOUxT1gIDcWIqibBRFXRIsWwKBspigsVqhsVqhF7GChd5kcslZrcC//7oLcB0ZsXHD06e715s3BCgtdR62UxSwcWNQHNekpCTEOfTWHDoMWsJIZFJSkt8VdcTIKEUodIWyPXqTCVGtRq/zUXAg3XmttEKHSz8SfgCTanNXk5dbRilY3fX1SaK+I7y48kpF7t2u0AfdBdJXgROK+5T0Vffpq3DrV5qg5DmmKEoN4CCAcwCUA9gB4HKapg/wyP0CoB3ARzRNfy1Ub1fLc+yPQcVFMF59DSr++su1r6jQlYP2hefdJ+YJTNRjywCA1mqF2mpBe1Q0ACCuqQkZ1VXAbbcBb4jPQSyWiilnwegIth9YXAQqSHoI4il45UFEvvstypPsOKeg3O1Bi6KAA7nM9XJ/8fNYi9niImIUWOL8VOZSXT7+1/t+yeUyKk8g7qqryD1FIBAIIcZXnuNgjRyfBuAwTdMlNE13AlgJ4EIeuf8AWA2gJkh2hJ8tW9y3OSNELYsWwfjxJ8Dll8N+//0ovO9+NH32md84UYtG43SMAaA9Okp8iIYc0tNdn4OphyAa+oBjcQ8agqETovMf5+fDumABar5cJentAMHFl2fJC22yRkWTe4pAIBC6EMFyjjMBlHG2yx37nFAUlQlgDoB3hCqiKOpGiqJ2UhS1s7a2VnFD/WFPHIM1F8/FmovnYufYsX7ld44d65QzxupREemR8Z/jxJSl9EBFZiZgNsP6ww8AgLrEJF5nh1uvF4lJQVt1b+3atfg9J8e14/bbRetZu3Yt1vqJpxQjoxSh0BWq9nywfRB2jh2LI4NP8wqdmDVrrfNamQX/Tu7atWuxdts2VBriUJ+UhFZQgnHKUtsYbHm5ZZSC1b02K0vUd4QXV16pyL3bFfqgu0D6KnBCcZ+Svuo+fRVu/UoTrDzHfDm/PF/svgrgfpqmbULrktM0/R6A9wAmrEIpA8VCa/WwOhbyMIlY3o0rU5vsvYKevaTEu5BOB0yd5nJIeEZnBXVnZATtNXh9fT06WltcO5YuBcaPF6Wvnps1IQAZpZCkS2aIQajas9syFEP0RrRrKVyOL7C2bTa+dBwbmHIQpkjmevkC7guE8FFfXw+kpIBmF6yJihQcyZTaxmDLyy2jFE7dOTkwH+G5v/3BTcunhB1hIJy65UD6KnBCcZ+SvgquDiUJt36lCdbIcTmAXpztngBOeMiMAbCSoqijAC4B8BZFURcFyZ6w0Ok5agzg8MFD3oJffAHcfRfzOS5O+iiw0SjTQhHU18PWaXFtnwrZD/LzUXjvfShd+33XTYXmeJ60g/IKnRic5spW4VogxA9JScCIEczn++4nMcdyOIkmoxAIBMKpTLCc4x0A+lMUlU1RVASAywD397s0TWfTNJ1F03QWgK8B3ErT9LdBsqfLYPNcThpwd0RSUrwdE3/OWXlZ8Bw4blowgFn172SPj1y/HqAotEdHd9mHAYrnk5PERNfnSOFRYDdSewAA6NNPC8Q0AoFAIBC6NUEJq6Bp2kpR1GIAPwNQg8lEsZ+iqJsdxwXjjE952Ff6cXFAczOTtq1Plm95u52RD8ZoX2Ii0Njk2r733pN/VHH6dGDDRuZzF52AGBnlHmHkM+qGLNzS9dm/P9wWEAgEAoFDsGKOQdP0jwB+9NjH6xTTNL0wWHYECtXZBC0MAID4pka/8mJkBGltRcuiRdA1NqJVp0NsayuoiAjEX3yxgJGqoDlwaUOGoGHXLteOJ58UXzYtTVggPx9phYVAnz4yrZOGX3tYZs9mQgsAySEuonUEyIsvUTj4USO0Bq2X/5taXY1G9jrs7PT74CTV5q4mL7eMUnB1N8i5/z9fAUyZHPBDZ1fpg+4A6avACcV9SvoquDqUJNz6lSYoeY6DRXfLcyyWQUWF6Dx2DEfOneHaSdMARSGtqgoJzU0ozB3os3ykVoucvf/6PB4o3BzLA/ftBcUXGiKV/HxU3LYYsNmQ2dwUtGwbQvqFJtw5c1EXFYbOJgns3PA5YhY/iRNZsZi2bofbMctdd+Hwjz8BYHJtY8kS4Omn/dZ5/Kab0Lp5C3q+8zb0U6YEw+yTHu69IpYeNTVIuuJykueYQCAQQkyo8xwTpOKZscOxbdFqmFf7QnBjTLsL69fDGBMDo8HgiuvNzwcWLw7+BLj8fJgWLUL7+x/4n3DXFSfjAXAmf+F7bvNcpa25WWLV3eeB+aRAHbw3PwQCgUCQTtDCKk4W7EmnY/UlTIrmzIoKjNv+p6D8n+PHAYBfOTcWLwZGj+Y/NnoMcOst+HPNGt/1GvynmJPLN0uXonn8OJfetWuBOXPElf3mGwDA3LlzvQ864nr/HD8OhcOGYm5cHCxXXgm0tUG7bFlQRpKd9vz6K8pTegApjpFVj7AD64oVrkKXXy7JFsE2KwnFXGttMRpM8zj03cCBMFmtzDkTETPN2jyWNwOjb3mxbQy2vNwySsHqRnm5+70iliFDFLnWu0IfhEO3HEhfBU4o7lPSV92nr8KtX2nIyLEAFAXQGh3sajXsajXaov2M4AJoi9aJkuNCv/kmcMcd/AfPPReYPVu4XlML/34FMB475q73qafElzUaYfSVZs7hDLRF62AcNAjIz8fhjEwc7tvPPUOEgqPJTnu4ziKP89j5IydUXmK2CsE2KwgNpu86NJFefWMyGFznTIRjL9XmriYvt4xSsLq97hWR0LGxitoRDsKpWw6krwInFPcp6avu01fh1q80xDkWYBbyYVUHX09DQiLQ3s5/UMwr7rLj3s5jsEIU9uxRvs7yctSdqHRtR0QwGToeegiWK6+E5d13lc03zHUW+ZzH0zipzKRmq6ivBw4dAh56KKghIvS/TIw5Zbd79w03/d7JnlnkZKChsQuH7xAIBMKpB3GOBTgH69EYC9jFvW2WjU2lArRa+RXYaffRzfx8tCxaBOPHnwTsVNKpqe47bDZ5eX8FnHWLSoXalBTntjEmBuZNm4Dnn+cfTVaSd9/1tmniRNdnKeEd+fmwFhejvb4eNe+9h6qvvgraIiJ0cZFrw2Ok3XbkiJtN0isPzLZTlowMWcXshw523cVmCAQC4RSEOMcC/ILpACj+xbAVxu5rhPgwz4p6nlBwH91cvx5lKT1QkZkZuFPpOVFQpWLyL0shPx/05Zej4/33eZ0Aq8b9waCiRyqO9e7DOOIsSuYb5ugvK9gD22WX+XZMpIy8rl+PTo0WdpUa9UnJaExIDJ5Tz82KwO0bhw1cm0QjsIw7wT8HDsgrV5+U3GUXmyEQCIRTETIhT4C1mI3Lor6AvjMG8e1AUn2d3zJiZLyggKM9e/Ef+/ZbYMYM4XqTPVbVU3ARi541NWjg6C7qPwD9ly6F5vTT/TqOPXv2ZD58+y2qY/VoTEhAvyOHoeVMgBNsFzdLhwIT9Lj2sLTo9Whsb0Myd1KeXCdx+nQkcSfzAdJWqJPAfZ/k4db+a9EcqcJs8xf47crZzCrinjaUljKOv0DfOfsFf4nS7ZIXR7Dl5ZZRClZ39bFCJCXJuP8BRa6TrtAH3QXSV4ETivuU9FVwdShJuPUrDclz7IehHw9FShONN9+2+ReWiyOnMR9J9XXocemlKGSdXR60Wg369e4N+9ChoIxGUDNmoNCxiMWgF54PyKm0rfoKBx991G1f1rGjiL7uOvF5WfPzUXLnf9EREYHsqkpEffIJMHu235ywg1543tUOJfMN5+c76wWAlMYGJL//vrOfzLt349gVC2Tp9WzToL45wA8/BGiwN6cP+RTLbc+gOD4Wc/5i8hyztzLXhliTCZlNjVCJeLgou/kWtPz2G3q+9Rb0U89S3OaTnf3UIKhy5ZUN1nVCIBAIBN+QPMddGaGRSq3WbxiDxWJF3Z9/ofjb73D0x5+Y0AWWQCdknX8+v03siKQYZs92rYL33HPibQrWZDLPeq+4wmOfguEFN92kXF180MK2tuj1MIOS+Mq++zwwdyVyUCq/cLCvEwKBQCCIhoRV+GFczTikm9Pw9TwgvbISZ2z9Q1D+j4lnAIBfOdFceBHQ3Oy3XnZCW3tUFBO/yIVdDS4ujlkQwseqcHx8nf8dTBPPcNN7NCMTPbb/iaTffhMMd1i1ahVw4gTmHz7s2jl5sssmBKG/BFi1ahUAYP78+e4HZKxqxkt+vnd7OH1Df/st7OvWQX3++Yo4/n9MPAMtWg3wt/d+NxvUasFX9my/jBcZTuKzH8MkL7eMUrC66y+9FtrYzpBcy0J2hLMPwqFbDqSvAicU9ynpq+7TV+HWrzRk5NgPkbZIqKACrVKhMyLSr3xnRKQoOdEMGABMny6p3rrEJOdn++rVOHrHHWj74EMUrv4GVV99LWlmvLmtjVdvTY8eficRmcvKYN67F53vvQccO8bspGkmq8MCJmxB8f4SwGw2w+z54MDaxEXuwPH69b7bk5+PultuxcHfNsN2xRUBZyaIjKLQGREJu1aDWciHnrMOjJcN8+YJOuNe/eIn1MpnP4ZJXm4ZpWB1R884Tf61rMBkvK7QB90F0leBE4r7lPRV9+mrcOtXGuIcdwckjjJy06J1vPUW2iKjUOVIydaYkCBpZjzFzZnriUbjGpHMzwcuuID5Yx2/hgZYVCocyemLTg3zkoKmmbRzFQkSl7wOV5orKXr5RmfZ8u++i+boaACArbMzYGfohav3AQDUtB35EfNg/CzfXR+XgbmwrlgB+y23kHRhXRWyfDSBQCB0GYhzLIKwRmD+vI5ZUEJJpGSwaGryfey++xjHPT8flTffgsIjJTD/ugmYP59xwhITYVczq6jQKs6lNn06bBoRET1cR07JPLCe9bz1prtTv3WrPL08DzH2Sy9lFjPZtAm0ihmSpiMiAneGHDZqbRTQ2cnkawb4ne4VK3DoyadwjI1HJw5ycKivl1/2L3GZQggEAoEQfIhz3MVpKSoGnn9efgVzHOucp/Zw7ZOSFk0tsETg008z/9evR5PBAAA41qcP0NHBOGlJSYDn0ribtzC6e/f2q7p99WrXhtnMPCQo4dh5OJC1nRYYt2xxOfV/cYJ4A8w/a7XZmKWxe/dx5XMePz7gmGOfkR98TrdjSc/26Gjh9pA8x4Eh9JbFH+SBhUAgELoMZEKeH2qiaxBti0aPRqBHdbVfeTEyUuiIikJLVJT8en/6kfkv5OQKkHXiBOoam/gP9usH5OYCI0a473fkbM2Oi0Pzv3vdjy15EOiZCej1QFWVYLs6Oc6ajVKh89AhRF9+ueycx9nZ2cyHQ94Lq1RkZMJwsBhYvx7U6acBbMpAiXmiedszcCCwd59r+9LLpJjNz8SJ6LHFMdExMtKV7WD2bPT4+BN32bOmAn84JonxtMfZL38zKeH8xRw75UUSbHm5ZZTCqbuzE7VFxfIqGThQOTvCQDh1y4H0VeCE4j4lfRVcHUoSbv1KQ/Ic+2Hox0MBAKuetYZUL5f06ipUpqYFVEdUexvao5iY10Flx0U7mPbzzkNx6VHeYz1qqmFXqZDS0oLCLNeNwc2tfPzCi9Ba7HIYso6WIrp/f5QkJqHDj8OfOWwoKhzOdUxrC1pjYpF7sBiqW28Vn2PZk/x8NF13PSqTktz30zQGHTsKrFqFtt69cfSyy73aIqZubv5kAEiprUFyezsKe7lGynN+/BGROYF9kfy58TPE3caM3A+6eK5rFB/euZZ7TTwDZY4MCkLtKbttMVo2bkTm60thOOecgOw7VfGXu9sXg2JjXA9kBAKB8P/snXd4HNXVuN/Z1ar3Ysm2ZEtyxwaEC8aG2EkMwnFAhObEkARDEkgoCWmUOB/5Qn4mgRQICQQDiU3yGYKpEc0ITHEIhtiAARtbtiWr97Yqq7Jlfn/Mzmp2tWVmtUWy530ePdqdufeee+/Mzpw5c+45OhFBj3M8TrqToih83ZdD0IjilbkWV4HTTvO5q21KLh3ZOThGRtx3KJQvob7ebVdHdjb2zz4Dj+1eOb3E9XHQqdiLcXFjYyyXl8ONN6p7NV1RMVYxltmxQ+q70r1AY/poTyyJSWND673hO6GLag4oLNH33ed/7Hv2jH72N56WZun/3r3j6tpJy3hcI7y8zdDR0dHRiQ66chyAc1rP4ZKaS3j9gsvZvXpVwPK7V69SVU4bYujbDZBYROZxozGwXIN3l43t27fz6jL3B7L+5BSOzJnrenXvd1zKunFSiKza3Dxa9u4bXVhWXo64YQMDW7cGXGy2fft2thcXe98ZyN9WjQJeWup9PJ4uLT/+8fh9TA8dGpXl8bAzpg/KNNxe2L59O9v/8IdRt4rf/jbwPHqmyQ7UfhjLB1snVMiyt7//fhh++9r7cbLJDgZ9rsZPJH6n+lxNnrmKtvxQoyvHATA6nNEWELAbA7to240xqsppwfbR/vG3G+cRf3X/fnWyMzICy/3Jj71utlqtjPioKzvzqB2Xw+EAJB9sq8kkKYRbtsCmTXTFxVNXMIM+wX8mOKvVijXTRwg5URxVrj0V5fJyHFdcQdf27YiXXOI7ekhZ2ZjxDCQlYU70eO0wNDT+uLbz54/KUobUw8ucBog9abVasTY2gnOOsdlGo1/4Km+1qu5quMsHWydUyLKtmZnB/0bnzNH2BsRPP6JBNGUHgz5X4ycSv1N9ribPXEVbfqjRlePJgCJucbCIQS7Iw5cLgpIzzwyubS14+sYbDFjeeYeRykpGYqUoELbEpPGFSPPmblJeDps20Z6YRGtuHu0ZmXDPPZoUmKZp09w3xMePP5SbnFQFcNjt/kOBBbAcAzAywqAzDjMAIV5YelKg5rfii6Iihr/xDTqe+Kcebk9HR0cnyujKsR+c0cmiTyiexpRxhZXRDQKhJnbr669r7s6IpyXbG3tHFygJSuVeEOCMM6idOo2q4lmj27/9rfGFSJMjOSgsx7Yrr6StpQW7U35nVpZkWZWV6GCsfb/73fjTRysWbzkMBvDzOmuwtm70i69+2mzusaedSWN0IkRFBbVTcmnPycExOBiSjHk6Ojo6OsGhK8d+6OuLdg9CiDIJh7zwTA0tLYHLnHtucH0KxO9/N/rZbh/9vPxMuOMO19d+OZbyeAOv3Hyz9P+e37o2NaZn0JmVjVnpoy0r0eXlODZsYOjRR7VZ+774xXF2FPfjCaMPP1760KF0JfGmdB0/LmXtU+IZnk8nrDj6+nDID2WxsWMXnero6OjoRAw9znEAmhObibXHMrULpjY1BiyvpoxmYk3jb7enR3qdD5qslrMPHqRdrueLCy6An431w507dy6tzz/vt6rfcVlHw+e5hRw8XAl33un66kqucegzv7Lmzp3re6cgwG9+Q+WsWTgUCwyHvVm45TB4N95Ia0oqPenpzK46hmnLFqaaTH774BxM4DKBSEx0n7v0dOl/RYX/OfXizjH37bdplesDPWnppP7+97B8uddzxe88esFVvrxcUs5LS/2eg1rbD7ZOqJBl//zncFPq80G14TAYXG8sLAkJJL7yCoa33tIU03sizMFkQZ+r8ROJ36k+V+GVEUqiLT/U6HGO/SAIsGibFOd4y/02MgYiJtqNKVYrbWqULj/EDQ8xHCcpuQsOH1JXqbyc1m9/m65M/76UcwpncrRm1AdW2X6wcV8Bpjc20jh9+pjt8YODpPb10TZlitv2vEsuJuOuuwK266tPCyoPc2he4GQMC85d41Iyq2/+IcOxsRTV1RJ/yikc6g98khS/+AJxs2cHLOeP975UQtrxYQDmHDtKTEmJ5GrhJdayW9894xyXlzO4fj01ijjVscPDzKo5DjfcEHw8aU/Ky+m95hqGBANTLANBJ3KZyAgCfDYvuPN9zrGjHJs3H9H5hiS5r4+CpsbQHgMdHR0dHTf0OMfjRIxiZt3xKsaASzEGvEdb8OY7W1ERUDEG3BTjkOJjzocSEsYoxgCcdnp4+uFB32OPSW4UgOh06RgyxcKnn/qrNkooHkhTFGm5RXHURziQwunp/lFRQV9KythyHhEwxk1FBY3ZOZLP9jhTck9ULmQcbhAGg5urzHBcnObsjDo6Ojo6oUF3qwjA6ubVZA1n8fqXIae9gy+88Ybf8m86/UkDldNKSNu95x63V+bic8/RduONZLW0ELN166hVr7SUNx2idrnl5VBWxrbf/x7LF7/ot66/cTVOG2s19o9/pXPbtm3Q2clyXwUCxTp24jAYoL+fwT/+kRGnr27z1KmkVx5Wd5zefFMK3TUeVp7Nm9n9AMw9Xu22wNJvH2TFVFaiS0v518gI1hiTe3k/rg/btm0DYOPGjaq6um3bNigqGp33AEqf1vaDrRMqZNnLNx7lzQT/57tPHA53v/rUVLjvXk3W9YkwB9GQHQz6XI2fSPxO9bmaPHMVbfmhRrccn4wooy0Avdu305WSStuUXHernr/wYH4YvOoqSUHu6gpFb0NHZyfWI0d87h42xapqRgRITGSwvcN9h8pweeK776oqpxrPxXn+8FRMy8qkBWDeyoUSZZizE9ClAsA2DluDCO7nT1bWCTlHOjo6OpMBXTk+GYmNdVeQFkl+1aKAu/IUZLabAYNBUrBjIvxi4pNP/O/v6sLqJ0lDdVGRz31unHa6pOClergjqI3wsHKlunL+OHx49PPIiHo3hZtvHqt0eWRLHImLg+efD1+0hCAfukLOOJNueGISbIEL+aKwUPXDlY6Ojo5OeNGV45MRT/eBJYul/3Pmulv1srODa99gkBTs/v7g+xgML72EeMMNvpUdX9nxgqGiAjwXCyrCy/lFFMevlM1XLBxMSFDvm2o2j92mTP7hxGG3h9QvWDx2bPTLXXf5zjIYKcrLqfrhj2h89tmQJd2YtnAc55duJdbR0dGZMOjK8UmIODwspQeWLWcffCjtWLrU/SatVtnzZPXqqNzs+7q6OLzrDYa++c2wxohtbmvD9pe/wFtvBVX/+L330fLU0+NTyk5dNPr5r39VP99paWMtpoODY8sZjaMKdwgsrI7ubvcN4Yzhq6a/FRWMmEz0pqZNjAWCjz7q7nMcIOW3jo6Ojk740BfkBaA+qR6jw8jMdpGCurqA5dWUCYZQtjuQmETyzp0M/vvfxPX3S/6NWV6sxGVlFDz8SNByFiYm0lLp28cXQjyuJCmCwyAC8Vu2jFEYFx44QIunn3AwCAId2TnEeibOuPxyCs5TZ8Htzsggr63VfXGcRlxz96UvjW4sL/c/p/v3I953H0MOBwnOxZezGhsZ6PDIhOhU1Ia2bOH4vfdRUF9PsrP8woULNfVz4cKFDH/0kftGP2P22b6fOMmuOuXl2K+4gs6EBHK2bkXw5d9cWgqv75I+jzMqhEv2k0/SEuz5PDgoucfIb3Xa210LWzX3IwpEU3Yw6HM1foIZRzDXjhOBk2Guoi0/1OjKcQCqU6upTq1myzPq4hzPVr4+DiGhbLdp6lSKamuomTad1F4zyX5i8wYl9803YdMmlpnNHApQPxzzZTXFSErUl78sRXFwKhjL2to4VFUdOkExHj6iIyPaxjNOpcwlS+kms2ULswOMsT0xic6sLIpqjhNfUcGinh46vfV7yxYsTr/xvuRkkp3K/DKNcXeXLVtGv8VC/atO6+zPfgabN/stPwZnNsIBQSBFGVHFs86NN9KelEx3RgaxI02k+3r4KCsDOR70OBcIumQ3N3PoxZeCamMoLh5ReRwdDs0PTl7nLUJEU3Yw6HM1foIZh9Y6+lyFV0Yoibb8UKO7VfghJQWMDiMJIwkMxiVgU7FgxmY0qiqnlVC2a4+JkcKRId2UifMdpSFouf/3f1jT0gLWDcd8dWZlMywY6Hp3j5vrgvU73wmZrO6MDMYEYo6N1Taez39+XH1wybp8vZsLgd8+XHcdQ85IFLakJEhLw/rhh2PK9ycn43j11dEc6orFmlarFevzz0sPH0uXSv/9uDBYrVasSpcBP4qxq7zV6r6xooK25BQa8gsYlBVHb3VKS3HIccHj4tQ9fIzTBUiWbf3Sl4I+vzqyPOKJC8KYhZJq+xENoik7GPS5Gj/BjENrHX2uJs9cRVt+qNGVYz/09sI5refwpaYv8c55F/Lv1asD1vn36tWqymkl5O0KzkOfkSH5Z4ZQrt0YA42NbB8aClg3XPNVM3Mmrbm5iAp/0u09PaGVZfOITvDUU5rGY/73v7FdeWVw/refHnDJGt79Nlx6qdTOddf570NZGZx+mvT5ttvAbOZfF4w9txunTedocTHCxx9LGxYucllYt99/P39/8UUOVVXTVlvLwFtvwfr1Psexfft2ng0UScSj/HbPSCmlpYw405jbvVjcXXXKyuALn5c2XnttRHzfZdnb778/6PNryHNRpCjCffdpOje8zluEiKbsYNDnavwEMw6tdfS5mjxzFW35oUZXjk9W8p2RFnJzYfES72WCXDQ1FB8n+axGcVGRQ7bgGQxw/Hh4FoAZx/fzaZo2nRGbXYrcoLV/zz/n+tgwbbqkqG/ZErheeTl0Ov2LzzrLr2XVYTCC3SF9OeecUUWzpobh2DhAstLXFcyA4WH1i9qCORZlZXCaQqn3p/QWzJD+qw2tFyqamlwfv3fDON9QCIJroaD43HNYv/3t8C5i1NHR0dFxoSvHJysNjYHLBLmC35KYJH2YAK9YbAYDw6+/LrlXdHYGrqAFp4LoQo1y6kF3RgZVAwPaI1f0jYbJsyvjSQfog+OSS7A1OpW4994LbFmVE4QoU157i24RKN10b+9of4O1lufkSP9XhCBOdJjpTB1fvnkRpLlPS6Plpps49s5/sF9xha4g6+jo6EQAXTk+SRmKdfpltrePbty3b/TmW14uKU+TnGOzZlNdVCxZ4UKcsa/HW2Y5jfSmpjISG6c9nNi0ae7fBcEthbQvKmfPYdjpnuAK4eePuXOl/0rl2FtGvkBZ+hQxr3tMseMLnabsizfqnREj9u8PXkYweB6TcWAzmaS3Afv30xcvuVw4hoaiH3JOR0dH5yRAV45PUpqmOd0qOjvh/j9Kn48ehQ0bEH/2MzqvvRbHhyqUJ1/ExHhNLhEtRAh5xj6Xkikzntf4WiNXeCYg+dKXJCuwlj4sPiNwmYMHpP+1NaPbpk4dWy5Qlr7k5NHPMcbwubqUl8Obb0mfH3gwsslGPBfVjReHAz78cDQaScL4opvo6Ojo6KhDD+UWgJrkGkRRZG4TFB4/HrC8mjLBEK52EYCDByHVuTLeYqH3X/+iLT0Dm8MRvNxbbqGkrY2mAO4bYRuXB/1JSZTU1NDU1h64cLC8+iqFOVOCq+strbM/5s+j8NUDo99lpVhrH8rL/R6Djkynwqc4jiUXX0zT7T9zL+hHuS8pKWFIYWXvT0jE9O9/k/rWW17DqJUEUvA9Mzwq6zz6KNilhZLdqamk33MPLF+OY2QE4c03Ec4/P+SL9JT9bXpyR8jaPTRvPgsqDyMszJasyA8+6LfvAectjERTdjDoczV+ghmH1jr6XIVXRiiJtvxQoyvHAahNqaU2pZYrn1YX57goTMpeuNoFpNfBcqzjxEQcp50GH+3HYTAEL3f5ck7dsIE4eXGUD8I6LgWOhARKDh4kzk9M53HzwQcUzZsfuJw3vKV19seiRRQ99MLo9/vug+XLoa6OIrVjvPtuOOssv8fAJodF6+tzJaUoKSkhzrOOn1jBJSUl9HV00OD8bklIwJIwndTKw15j+fq+yPp2p3DVKS2FZ58FpAgQI4JA7JYtVFZVk2buYdq2beOOa+xTNoydl1AgR0UpPU91PyLNZLsx6nM1fk4GhS9UnAxzFW35oUZ3qwhArD2WjMEMetIzGI6NJXZo2G/54dhYhkPgixqpdkdi46C2VvoyZ46kOFz0Fen7woXBy/3Rj/h01qyAdcM1rjGsXYslArKCHo/W1+UHDrjLslikxXgzZqjvw7B0Lqsp39PXh+hcNGixWMaW96NsWiwWBr0tzvRhbbZYLFg0Rjpx1VFGtQA31x5zWrp3326ln32gtNNeysiyvc5LKPB03/FBMPMWKqIpOxj0uRo/4/qdhlHGRORkmKtoyw81unIcgBVtK/hC6xfYe855vHvOObQJuX7Lv3vOObx7zjkh70e42gVcShImk6RgPeDMgNbbF7zcxkbePedzAeuGdVxKamvZsWJFWGUNJCZGbjw7K9xkNUybBrt2wfnnq++DwQDXXae6vG1Y8ive8eCDmsa4Y8cOXnj77bE7fFhwd+zYwY4d3twTfEeAcKujDE145nJ3P2xZIVcqwBs2wKZNWK/8Oo4HH/QdOaS8nIGNG8eUkWXv2LEj9Md+1ixITVVV1Pe8hZ9oyg4Gfa7GTzDj0FpHn6vJM1fRlh9qdOXYD97uSVMcrZHvSJgZdK6G721ooObAQXrq6gGwNjcH36hngoxo09wMYchcqKRx6jiiFWiNQtDjHnmjLyVVesjREKFBdDjg/ffVy0xMgNJSRG9RP/xlyTt+nOHevrHbNbs2BIhS4YX+ffsklxMZWSFXzrfFAuXlHJs+XYoZ7SNyyMjzz1M3JZeW3DzvZUIdKhCkhYtyGLxAUTp0dHR0dEKCrhz7oc/L/Xx6a9PYjZOc7sxM1+fBhARXtq4BZYQBjTRlZY+7XyGltS3kodxCykcfaSvvJXSa3WCAykpt7Tz8sPqys2dL/9PTx+xyvPKK7yx5vpTGYKNVPPBn1XVbc3O9J6NRunMkJroU9YHkZJ/uHvYlkkV6OC7We5kwnF8jBqNbGDwdHR0dnfCjK8casdn0KVOD2YsCFW0c4ba8eYmioJo9e7Qpi8axa2mHY2Pdkm0EwmE0QkeH6vLigQOSO4EXZa0uv8B3ljxfIc40WstFZ6SRgV27NCVNEZV+wHI9pdX6iSdg8+bR75//vPeGVjlTQ+dM8e4SonjIDBVVs2aNWozVnr9qfKd1dHR0dHyia3oaqTQEGY1AJ+rYwuxWMS5EUVuGvRljo4B0ZmYhdnerbqJJoxtI6xSnFdaLJXgwMVF6OJCtqUoFrajIe4NpaZrk0yXJ7crMwiKKvpXrujq3r73Ll49+8eYO4aHkDrz1Flx++VhXEfnhp6DAu0tIqOMce8pVQ2cng9+8ipGHH9aedVFHR0dHBwhjKDdBENYCfwSMwKOiKP7GY/+VwK3Or/3A90RR/Dhc/QmGlBSoSq3C1mdjUY3IrKrjzHMcpp6ZPuvMOnY0LH0JV7vhlKumbqTG1Z+cxMyamrDLidhx6uxiVru7rP6UFMz9/Zr7oLb8UHwcxMSwZHCQ5oaGsQUuvVRSGsvLGfn61xkSIXXrVpb+6Ec0epPhwz966dKlXrcLWVnQJSn/Ng+3Bled8nLM+/a51RNnzAA5vrWKZCt1BTPI6uyE//6XKV5iMYsevs8u2R984H2c4yUlxXvKbg+WLl0KW7dSk5cHwAIfofLCga9jNlGJZn8n21z5IphxaK2jz1V4ZYSSaMsPNWFRjgVBMAIPAOcBDcBeQRDKRVH8TFHsOLBaFMVuQRC+BDwMLB/bWvTo7YVTH2ugIamB2FYHa+ocJDqG/NaZ4VzMFmrC1W445aqpG6lx9aamRUTWuGSoSP8sIw70M6N9bFhBW4xRcx/UlhcRID2dhU1NmLzV+cY3pP8VFdRMycUeE0Nq5WEWPf88RquXBZq7do11cQAWLVrkXX52Nhw9Jn354Q/d6rnqPPTQ2IoWhWL5xBM43n0X4WceSUw8LKyWhAQEUZTcTmQFUzbg1tW79Vsp2xiOc2xkRPoviojPPw8VFQhr13qft9WrOfTSy9IGrVkXx4GvYzZRiWZ/J9tc+SKYcWito89VeGWEkmjLDzXhcqs4EzgmimK1KIojwD+Bi5QFRFF8VxRF+R3we0B+mPoyLhJsCeQN5HFo9jQOTetjRDT5LW9JTMSSmBjyfoSr3XDKVVM3kuMKtyxxPDLy8tyUHfuTT/r3G50xw6ssu9GouQ+ays+cibmpyXt52V2htBS7nKo7MRHzqad6Lz88jPjQQzi++123cZrNZsyBkqIsXeb21Ww2Y960CV54YUxR4dRTR7+8/z6Vz/+Lwza7a9PID27m0C23uleSFzwqFExh924AbD09bi4Lcn97UlPdxvn8WZI2bbCPygoKWSl/7TUav/8DDr/xpleXCbPZjHn16tENIU524g9Vx2wCEc3+Tra58kUw49BaR5+ryTNX0ZYfasKlHE8HlCaUBuc2X3wLeMXbDkEQrhUEYZ8gCPva28OY+tcHZ7afycr2laxsX8mHp17B65zrt/z7Z53F+2edFfJ+hKvdcMpVUzeS44qErKBltLW5lJ3BBx7gyC/+l96//92332hqsk9ZWvugqfwdd/AvX+XT0iSFXskTT/BcWprP9rve/y+Vb72N9cqvu8b53HPP8dxzz/nvx6OPus3Lc3/4A8+0tNBgC6CIbt8+ZtPAP/4xttyCBZCf765gvvcegKT4K3yX5f4+PzzsNs7uZEmrNY5XOXaIrr73ycq3F9/pMfMWIcXYq+wJTjT7O9nmyhfBjENrHX2uJs9cRVt+qAmXcuxtBYnXpdaCIHwBSTm+1dt+URQfFkVxqSiKS3NyckLYxcB4xjlusU9nPyUYJ1oMX50JgWM8C/4cDpeyM/TaawAMJCaNZr7zJC5h7DYAg7Y+dGtZFCcI8I9/MORjnG2PPsrQI4/AxRe77/CWHQ8YMZloc/6mrTZr4OgV7aORNWyvv+b+4NDZyVBcPH0pKWPr/fG+0c8ei/UAEB3e5c2Z465grlgx+tlgGLOgUPSIJvHRLOkymNU1vvjHNoezf//5z+jGxMTRhxGti+7Ky3F873uhXazX2QlHj+oLAHV0dE4IwqUcNwAFiu/5wJgAwYIgnAY8ClwkimIYIuiPD884x/aBNNIwM+t4dcC6c48eYd4RjTFndU5uZGXrlIUA9KSn05adPeqbq2TY1wItbeHqWnLzVJe1G43w9NOIgvfLRmdGJseLiulOUTxVrl8PSUley1cXKqJYGAxSwgvPccpRLzZtggMHXJtbPRNx+IkUoXwA6PGmPHvj0Gdw8ADi9dd7VfhEhwN+8xupX/I2D9eRlkyBGZV1ZJjNFNbWqJPrD9n3GODmm+n86185+spO2LAB6w9/iHjkSOBEJOXlmL/1LSrffIuhb34zNMpseTniZ59ha2tzpRjX0dHRmcyESzneC8wRBKFIEIRY4GuA2xVTEIQZwLPAN0RRPBKmfoSc1yjFKAgU1tZQVHPcZzmjw4EhLi6CPdOZ9Mj+WiWnuzZ1ZmV7jR8szPMeUtDTehkNWvIUCvfwMMR4X/crKhKZmJNTOHbosKRcyQpeeTm911wjpWu++27wdE9QLjjzE81hMGFUaW32Er7O2wPCYHwClgELh994c1Th27PHtf/wvPkMmUxwzz1Sfzs7wUsYvQ08wYusIyEUxyVB8bbAbKYtPQObyQQWC1UvvYy1owM++8x3fYCKCvpN0rqJYYefcHhaqKjAGhPDiCkWi4j0wKAryDo6OpOYsCjHoijagBuBV4FDwA5RFA8KgvBdQRC+6yx2B5AFPCgIwn5BEPb5aG5C8QJlcOutJNhsmHy8LjY4nDfx3NwI9kxnUhMT4zuygIaoA0Nx8SHs1PhpmDbNq9LoSU9GBtbYWMTBQVemuaFnnqExO4fmvDxJMfaM9yv7A5eXM9gXxixysoXaI2NkX3KKlCa9qQlrZSV2L9eDFyjjQl6CH/8YAMHhoKjmeFCuWeI114x+UZ4PSjcXhw8XEWU9OYFMXGxoolmUliI6j40txkjf8Rq45BI3q3pIUMbO1hOd6OjohJGwxTkWRfFl4GWPbQ8pPn8b+Ha45IeClBQ4knaEgn7JQ+TddzdIOzZvhuXLMW7aBB4hquYdPszUlmbpS3Y29A+EpC/zDh8OSTuRlKumbiTHFQlZIZHhTQkESRlIS5MszMfeYd7IWFeCwcREbX0QBM191lK+LyWVFf/5Dw3TVQajMRpZMX8+nHkmDrMZ3v8vVpMJ4uJg5kxQLsqV/YErKpirNW22FmJisMXFIe581W2zKACxsaw4fJiGQf8hHjGbmVVdhcHhICbYBXqPPAIFzuQvSotvSQn09lHy0X7Shofwqx6XlcHjT0gxpm+4MTSL9srKWPj00ww3NNI0bXTd9ew//AHT8uWhkVFeTut3v4fd4WDaI4/Qk5yCaLeRsXVrUFE5Vij9xyNMNGWHkmDGobWOPlfjKF9eLl0nSksjsjj3RDlWMmFTjk8UmhObaU6UlN0jRxSvsuWTzSME1LSmJin4vsEAd9wxZn+wTGsa47IdEcYjV03dSI4rErKClmGzueLpCh7KsX1wkLrbbmdaYyMOg4GuzAxiMkSm2cfGOQ6mD+EuP+/IERw+/JTH8OMfM88ZL7n9T38GnG4Roghpqe7KsUxpKdNe36WpT5pYtoyjL70svSkyeYRydDiY19qKw89DcEqK1MfYrVslK7TRCPFxECiyhgd2hVXYumULzJoNQHN9A6SlUWg0MOX//T/3sHTebpD5+ZJy/OmnXuNMB8OMuHgGPM6LvvgEMmXrcTAylH2vqKDLuUJ6WmsLzc6FnBlBJjqZN2+e9v6EiGjKDiXBjENrHX2ugixfXs7QN79JnNmMEOQDpFZOlGMlo6eP9kNfHyRbkynsLaSwt5CsrA73Al5Ott6UFDqysqTXiiE8GXtTUuhVu5gohIxHrpq6kRxXJGSNS0Zrq/TfI3Nc/513MhQXR0d2Ng3Tp9ObmkaSPd2nLK190FLe7Cyrpf2OrCz15T/5hI4dO+jo6GBo/0ej20dGsB865F526VIpxTPhPbaWTz4FkCzYnthsdCQlueR79kEUpWRClJVJN6gbboBnn9UcVQSgVrYaAzUzR7N09mRkANCdm0fHkMKCXV6O9etflxRp5UI5Z3bDpoMHQ5Zi2tzTM2bsrbm5DB475l1GILeI8nL6rr6G7v/bLtVXRgaJjR39HGSik46ODjo6OgIXDAPRlB1KghmH1jr6XAU3V/2PP87xvKmYU9O8hn0MByfKsZLRleMALOlYwuKuxSzuWsyFF75IoHU1HyxbxosXXhhyf+MPli3jg2XLmFVVRXJ/GP0rfcgNV93xtB+O/kRVxn//i7huHc1PP+O22dHY6PpsUyhovmRp7YOW8k3Tpmtu/8ULL1Rd3lFRwYuvvsqLjz2GbcDi2t6flMSwKdat7KH+AVr37oP168N6bOvyfbmECBATQ/nixS75fvtQVgZ//rP0PzbWdzkfKBcw2mLcFXVRENhdUMC/lDfBH/2IY9Omc2zWbOkGeeed0nbZ7QvG3jiD8eUtL+ffOTlex14/PX9UhiLyiOOKK8Yq7UoqKmjIyZEWd1oso4tVAZ56avSzVouYsw8vPvYYL774ovp6IeTFF1+MmmwXIfDZDmYcWutMiLkKAZGeq+F8yRV0KC4uYpkyT5RjJaMrxxpxi33s68IiCGE7GWNtVgoaG5jWHB03C53wMGyK5VBCIpa33h6zryMrW/oQhEI12aiZMVNaVFZTw5AiAkV9foHX8l2ZmVJEjCggCoDRiBgfxCLIUEeyEQSsDjvDsaPtOqpHQ04emjcf8YMP4PLL3ddBKG+c5eV0fudaV3g41YpTIKuUMyaz9etfp+cf/4C776YmJ2dUafdWX3n99Ly5K5VhjYpx/9VXS0r5Z58FDnt3ouJ85T706KMhe3OgM8FYJIUD5fTTI5op80RCV4794O0trVvs44qKgCHdwsKSJaT19ZHpXNWvM/npdT511c2YMWafy1p8EkQ/scoPAH5Cs00ohofHhpiLGu6+6q1Txp4vjf95l17lmyfljbOigraM0fBwql/F+jMEGI2SDLOZ2uwcmqdOw+FwMCxHVVEovo5nnhlNTqK8mYfq5l5RQX3OlNEHsIl0/Yxk9I2KCo7nTeV4YVHEXrnrRAfhi1/QFeMg0ZVjP/T2BihQWkqCwUCcp+VK9B0/NKM7BBfkO+6A228nt0NdOu2EyaJo6PgnSosyo4EYKCTZhECQQpiNJzNiGLEo4yI76fVM+6m8cfqz1vrD383XaJT2l5Zic8a7rpyrWLhz882ucHyVP9tE5ZtvjQ0DF6qbu3M8NpNJWjCdmRmadseLM573wN/+Fp4QeJ4Ee5x1Jh0TIe79ZEVXjseDvMjm+uvdt8tuFd6sAH4yeammokIKJ3fppeNvS2dC0JGdHbBMr49McxMd0Ws2ef8MxvtIj+0Nz9B3EaIrM5Pm3FzvETQmACOerhsGL5d7X5bKUFlr7XbXoklvbkHiRx9JWQi3bHEdx6acKYj33DN+2Z4ox3PKKd6vxdGIn1xRQWN2DnUzZtKTlCxlXgyn/HBY5XV0TjD0UG5+SE2FZfccIr9fWpDzzu6rxrpalJXBBRe4Uv6ecvAgM1qa4StfkS74HggdnWMsFtkdHXRkZ5Pa2zvWsuPklIMHpQ9xcaNP+rm58OkB94KiOEZZGM+zo0tumOqOp32tRELWRBiP1j6Eu/yCgwcYUmSpC9j+gQNYEtU/CAzFxkZ03pWY09JZ9PEnDCaqHx8AQwHiIgdBwDnwZo3fsEGy3r76KoOHDo3GUdbCpk0+ZdsFga533yVz1y5EZbpwJ+379tFZfZz5x6uhqBgAc1oaOSrfigXLqosvHv0ih4xLS8Py4IOY+vsxhTH81apVq9w3lJaCMxRh89SppFeapXtHiOJDjwnlp1S8y8pwPPssYkUFxnXrNMkcM44w1AlGxkQkWnPlGRY0nJwox0pGV4790NcHbQlttCW0AVBdXew9WoViY25rK8VHjrjcKpL6+xlQZNbK6Okmub+f4bhYjHYHccPDDDkX9Ah+XiXnymG+fvzj0QuYMryRjJcfgziOH4hLbpjqjqd9rURC1kQYj9Y+hLv8tOZmBpKSAxd0ktLXT4qGjHfHC4siOu+epPb1keq2GEEFIyMh70egOTB7u15YLAzeey+Cw0GNUnnVEju4vJxcj2RISlpz80iorfG6rzNDMhQ4POsr3xz4icXseOYZHDt3EnPhhZoUu+LiYlfblqs2EtdrxigI1M6eg5DjYP7RI0HFT9Yq26W4hgHx+efpuu67ZLS3YXAq+/bBQY79zx2jbxE2baLmiX8yHBvLgn/8Q9MDgWscGtBaJxgZE5FozVUk3SpOlGMlo7tVBCBtOI05PXOY0zOHvLyWgOW709Ol8ENpaXDddcxobnJbsBdrtZI0aCGzp4e0vl7iR4ZJHegnvaebKX6sJd3p6XSnp7vHwDWbiVVxk00eCD5Ln0sukNbTE3Td8ZQJFZGQNRHGo7UP4S7fkZkV1vaDrRMqZNma+hDqaBUEnoPmvKljttkNBmpmzJQWZynxo7A5nn12dOEcQFlZQNnWGB92GPnB3eP5Xbj2O67Ptq9+ddQ1A9wsn3U/+SlH//2O5qgLLS0ttLS0IO7cSW1urhQNxbmwUjQYwuqL29LSQss//4nt8sux/O1v2JVWbJDOjeuu89+ICvePvu3bacvIoC0nZ3Th3Rtv4FC615SXMyy7u2hcnCfPoRa01glGxkTkZJiraMsPNbpyHICSrhJO7TmVU3tOZe3and4LvfCC6+OhRQvZuXatFJezrAxuu434kRFmVVcxq7pKKrRkiZQM4Gc/gxtuwHDrrUzt6/ObVnb/4sXsX7x4NFEEQGkpMTbvFpschR9kVlfwIYtccpGs3sHWVVNmVnUVCYMWv+XHg5r+TAYZgWRp7UO4y/93xVlhbT/YOqFClq2pD2EIyxfMHHSnZ3jfobQeKhWx8nKqb7lVWjgnK6SbNweULQbIkHhkzlz3DYrV0EdnFtKvCHEorl/v+jwoP2RoVOx27tzJzp07EZ1ubEOeDyth9MXduX07O19/naNFxdTOmDl27Mq3g94oL6fmBzdTU/6C+0OBh8LsWHCK9N9gHFX2v/hF97aUcoxG728jfY3DOYda0FonGBkRR8WDyskwV9GWH2p05dgPnv7FvhalC6+/TkFDPXOOHcVot7vHOd68GW6/nVhRJNZqlS5Sd9whJQPYvHn0/xNPwLp1xNhspGuw0Ppymcjq6mR6YyNTm5sxOhzEhiIW7JQp42/DD7FWKzkRzrATOzLMzNrasLQ9JopJhCmMdIhBHziCyAZ3spAd5YxSfSk+3F2WLnUpw8d/8AN6//53aQHw978/agXWoJA2TZumrWNf+ILb10FF5I3DXnyXiYuTFDtfSoqswHhgcf72Rc/Fis4IGmPaG++CvfJyOHgQmz9XN/ntoC9ZFRUMxsVJfu6KBCvN11+P+R//GFWYS0qk8vPnjSr7nq/ZN292fbQB3HdfcGOLxkLGiUB5OZarrmL4kUcmTszo8nKEZ5+Ndi8mPbpyHApKS0kWxVHLb0GB+xP55s3wzDOStdiXRaKszO1VWpaXAPVGh4dluaKCVKeFZWpz06hlGsBgILW/j/ReKbOUP6u0WuIGBogfGhsWLmTW3vR0xDPPDE1bajHGkOhlTKFgPBb7UJCgUTlPDRi7UCfUaH0bE2qGfEQFET/4QFKG77yTobh4GqdNZ0QQEJUPkrI1MhwKwd//rq38okX0PfQQ/du2SYlOvvxlN4tqz7e+jeVvfxtTbUSRhhvlokpn6m3xgQdGlZ5Nmxj4+tcZefhhbSHXlIpjRQUjMTGMmPy8OWhtdYV3O7pzJ9b160dllZfD8eNjy1dU0JOcQtPUaWMfWs5c7lL2O370Y59iq4qK3euqVXjLy3Fs2MCgmqQinZ1w9Kg0nhNBma6ooDY3j2rPuYsWnZ30b7yaob17pe+KREA62tCVYz94rrHxqV/KId1uuAEWLYIiL5YNZepYX1RUkDBoIXZkxLv/sSiC0qpcWkrGyDDzjlSS3tsrWaadCDExkvvGunWS+4Zh/KtWDfPnU1RfP2Z7YV2d33rJfX3MO1I51mqhwGizwcqVJM6fP+5+aiGhvz9smeeSBgbIb2wIS9uq8OXn6YNwurScrAiCR1ZNT0wmPzujR2dmJthsiEePurZVFc+iXRly8IknEO12Wr73vZDLt735ltv3QS8xmz1pyJlCfX4Bh4qKMSv9kLdsoTkri9oZCkX400+lPyXr1rk+Ol55hWPTpkt+2hYLbNnC0Sd3UDdtOlXFs2jOysbx29/6tlJ/+cvS36ZN9F5zDYdeex3HFVdAWtpYK7Unn30GW7bgsFqxxZhozcqSwrtt2sTgN7+J5c03R8c8dRri00+7u9vFxkoK9P6P3NutqKDLz8noMBrdHngGNm50fzjwRUUFLamp1BQWYR0Z8a0glpfjOHwYsbkZyx/+QN+2bRPH2qoCxzPPIN5wg3t/lX7p8rxHczxdXdRPmYI5LV36Xuv/3qzjG105DhWy8jueOMalpeT39JDlTBTiZgmWUf74ysoQnngCw/XXSwrwokVMb2wg0WKRVsOfdRa89BKYzWS1h+D17fCwZBX35Gc/81stpb8fg5cQc2NITMTwpS8F1bW81uAWAuS1toQlcgAAF1yImKrehy/k+PBH90VKv/oIETrq8RvI4q9/jVg/tNCenUNPWtqYTEgWpXW1ooK+++6jO8Wf9h8cxz0MDAOBYnx//LHb1/bsbLBYcHzrWzR/+NGY4pbBIYYGLO7hNp9+2vXR4Rxnf1KSy6JsUzxs9mRk0JOcDN//vpsVVHzuOTq+/R3M//63pKD/5je0p6RK6b2tVmktirfUqwpaUlJwvPKK63tfSqoUhm/7dmryprop+X2pqVLK8MOHR7clJjJS8Rr85SFpg3zd9bbA0FORc77ZHPjnk9RNyaUjKyugRVT88EOXMmY3GNwVdSUVFQyZYhmMT6B2ZiEN+QWIFovXkKcRRYWFXHz2WSo3/ZzWp592V+gVxq66vDz6du+OrsLvmdgmLjyGn5MBPZRbAA5kHGDqgLTK+z+7vh2w/Jo1a4IXJlugKyqgtZXYp58mfnCQoYQETv3kY6a2tEgXSWWIobKy0c/Ll5O6YQOp9XXuq61LS0neupUFlYc5NE+bZfbUTxQ3nf374eKLmfvsszgEgWOz57jk8sxYHye5bmqf8wZrNI4xv7u1f/iwNJZbbtXUR4D4wcBxY91kOTGIovvr1HHiJqOuDm64Hv7+j5C171OWiu1a25ks5YOtEyp8yb7i2WF8PjbKb1HOPx/u/FVY+xEUgkBz3tQxES4GFfGqrQ89JJnFp+RGdf4Brw+CvSkpNGZ5T64j97c1N8+1rXGqYqwPPggzCyEhAfEHP0B89dUxbXRkZtFqNDLbmbDE9MgjmHOm0K5QUNIqD49GhzCZEKurWZKRwaCfdQ7dGZn0JyWPdcvKzoZ+L5GHBGD+fFfM+4bcPPJoQZAf+t9/fzQcnue11VPpdX63zZ0LH37ISGysz8gda9asgS1b6D50CFzzKMB//zu2j053kFPNZrfNPenpZOzcKbnC5OaOynGGuBtzP/UWt3kciM8/j/naa0lrb0fwE9va4ZwXc1oaeW1tXsP8DSQkMjA9kQWVh8fsD0Yv0FpHLt//yKOjG/fukx7eFL7l4WJcus8ERFeO/ZCSAp3xnXTGSxep+voCUlP9p5Uu8GZZ1YJS2b38ckz/eZehhASyOzqZXVXlngTEW11ZuVZePJTbncHm1ZLdIY09dnhYUmxzczHedhv8619gcyq6d97pt65BFKV+e8Rxjh8acpVx9TOIJ+6c9jZV5dxkydxwgzRXQSjkAWU01MORIyFpN6AsH9tNVivWAK/u5fJqM9n5khut8sHWCRXeZH+y8QCbfavGo3hRukLZj3ByvLCIvLbWqMj2pDPDI+qGwUCfn9ja3vrbq3jLI8ouaqKD+v/bzoCXB2i705J8bNZsAKY2N9Oc7C7TnJIqpasGqvMLyNq7lykJiV7bU2KNjaVF8WBijYkhxl/MWo+EUCJO1zrAfvSo5CN9q5drnCIBCYB1yxZMjz4Kt98ubZgzF378I68KY8FHH9F///10ZIw+DDiMBmhokBQys9l1r+r49ndoz8zE81GlPSub9J4exGeewW4wEvPII3Smp5PZ3o5h61YKZGXV6R7Tvu8DDDYrWVu3SslrZBlBKsrmv/+d5swsbHY72V1dvmNbf+EL8Nbb0sQGCvPnZX8weoHWOgUFBVBeziHFNmtMDNx9t2TACkf0FcXDSsEJlmlRd6vwQ28vZA1lsahzEYs6F1FQUO//FSlQX19PvRe/3KDIzZWsxUBHdhb1y5bBjh3+T3Jfvs1lZZrC9Mh0ZGfRkZ3FzLpaKXB8aan0FHrHL0YLffSR5J7gcfGW6wKwZs2Y/Wlms3sZGGPJMClcHlL6Rp9K8hsbXFE9jKIIV29UPRY3QhzL1E2G2UzCW2+FtH2fsnxsN6oIAu+rnclSPtg6oUKWrezDCDH8D5K1xu9b9BCeH5GeA3tMjPRKPwqyPWmbkuv2XXA4/LpxBeqvy3VhaDigIivT4+X62u+hLHenZ1A7o0DzXB2bNZtuf4ur/uHxdmrhQvry8lx96I+Lh1//WpUchodh1xvShiVL3DLrOb70JcR162DTJur/8Ac+Ou00N3/w+un52IGmrduw/+UvkovBnXe6rOme826PiaElN5e6ggKOzZ6NOSGB9oxMOrIkt5j6N96g/vHHsV15Ja1799GRkUFbzhSwWOj9058YevRRbYsjPbA7szLajTH+lV7Z3S82NnCYPy/7g9EL/Nbx4gpSX19P/RtvuBXrT0mRjFphWChof/JJar//A6xbtsCGDdQ//njodJ8JgK4c+yE1FRZ1L2Ju31zm9s1lzZrAVtddu3axa5c266xPSksxJkjZ8z497XR2ffWr43v6275dc5VPTzudT087XbL+ZmW55Bvefmu0kMNBRm8vC45UusVdlusiCFBSMia0mclqHS0D0qITD3+1DHMPc44dZc6xo66EJznt7ZJ/rHzvO3+tprG4sWEDbNnClDZ11me1MuKGhzCOjGDKzmZB5WGmNjeHpH1vsvxud77SzfaTYGb0OI1PbrTKB1snVMiylX2Iy05HFKXnQa9vmuSHPr+r9YLrRyTpcC7Qi+b8e0MEev3MbaD+WoNZpKsyE2mwc6V0AVHSnZ7O0ewc942HK+lXuLB1ZmZiTvZiSb/sMu/CGkYXEos/+xnizJlYL7+cyuM1NH78Mf1//COvFxePGYfDaKQrIwNzaqq0qNNicfMH9zb2nvQMl7uOw2lldxgMEBvLLqORXR98QHNaGl0Kd5VD8+bTOG06xwuLsAqCZB1V89bRU6lcuFD6X1LiX+mVjQyJiYHvwV72u/QC5WLNAP31qUuUl2O78kocDz7o5t+8a9cudnmzNguCZBgLcbg98+OPY4mPpzNT8kvfdfBg6HSfCYCuHPtBa0bYkCO7Q8iMZ7EfQHY2M+rriFFEtVCLQRThO6NZq4Tzzx/dGRsLt90muSh4LggA6ce5fz8z6mrJa21h3pFKZtbVkjIwugAsp6NDcrtwLixJ6u9nfuVhMru6iLHbpVB0ciKBeXNhyRIMTm3O8PprmBQLWBZUji5O8UdeS7N08QayhodIcmYSzGsZq8jOrKtlzlH1LhIz6uulvPZ33AGXXUZ6Xy950cge5FSOkwYGpIggOpGhu9v3Tai8fFRjjvZipBOUoJRbL9g1RHzxFlHDM7mIw1ew/HHQk57hct2QGY5xl2NJSqJp2vQxdRs8lWqgLTuHJnn+Xn+dY0/u4HBCIk25knW+LyWV+vyCsYlTnNgVY6zNL+CQ0+1EFddcI/2fOZPulBRsZjN0d9Of7Pv1S1VRsWQddf6WxOeeQ7z++rHh4srLGbniCikmsRwe7zmN8YA9H4C8/cZ9WbE7O+m9aiM97/yHoV27EC++WJ3F21Oprajg6PR8qguLxi6W9PIkXjc9H373O+pu+j5NzzwTugWDCxaMfk5MlKIjnUBh+nSfY40EWGgceoJcoOaVO+4g6StfIaWvj25vSqw/4uN9O/ULwqhP0+rPj/2BOn2NY2JiyHC6QiQOuscWzjD3SIpcWRlz7r8fY38/QmwsnHuu9FRvNoNDhDfegG98Aw4eJOfBB4kZHia1uwth5kwWfPCBq730nh56AqTyTRwclH7U110HJSUYt24DIG5kBNPIiOsGGzc0NKa/gYix22HlylEf8vJy+Nvf4HClpnbGi5CdDV1dcNVVJJW/4NeaphNC5FeZ3qxMFRXkN9TTnZGJUY8QckIzEoY04WqwxqgLEdjn5XrQqTDC9I6MKMINuiuGvrIedjt9kB0GA5ZAUUY8sCtCB7Zk5zASG4chQBx60SMddtVPforVZGJ21TFEQSD2oYckf+v9+6nKlyyrCyoPY/njH+nPyISkJLrq6sj56lcxPPmk99+s0j1N9rNNS2PogQfAMy37XXdJ/5X3y85OOH6cxlyF+48ossC5mNOn7/Tx47TcdjvDJhMzZT9rZ5xrq7fFkl4ihQwkJcHICAMJCZCQwLSWltFr03gWOJ56Kjz/Lzh1ESxfjrW5BWtMDN2PbyfGbifFn194iBdWhgNBVOGTOFEoKioSf/GLX7htW7hwIcuWLcNqtbLdi9tASUkJJSUlWCwWduzYMWb/0qVLWbRoEWazmeeee85t39tvQ8acT0ixShrxyFAC8+a5v9patWoVxcXFtLS0sHPnTldu8Tynv9eaNWsoKCigvr7e6yuHtWvXkpeXR3V1Nbt37x6z/4ILLqD9nM+x80trGc7MJM/jtcnFF19MWloaBw4cYN++fWPqr1+/nsTERPbv38/+/fvhs88Y6enB5rx4fu7tt4mx2zk2ezb1M2aMqS9T0tPNEeWP8OhRhIYG1j/5JAnDw7z9059y/JRTGPzwQ0TnQj1zWipp5l6uf+RhXv/Tn2gYGICmJumVcmwsqf39tBil57Pi49W0zJ0LZ5whXUi6usiaOpULnVmtXnjhBVo+/hhrUzOm/OmY4uLIe+st1r74IiQm8uyvf01vZ6dU126HoSFyW1ooPF4DwH/OOZs254Upo6sLUTAwv6uTL15xBZSVsX3TJkaamrAbja6EKdmtbcyqriZhcJC3vvgFiIvDMTLiSpxQUFfH7GPHsBmN/Hv1agB6MtJBFJnW3ExJZiYlv/+969yztbUxUjO6Sn3WsaPMqKvHkpjI+2edNWbO5x0+zLSmJnpTUvhg2bIx+0diTcSOWCn58EO31L09GekAfOOll7BPyaXeMsDRZcsw9PQwHBsr+dcBJR9+SEZPD6+uPR9LUhJTm5sZVCSFWLJ3L6l9fTRNm0alIv603P75r+wk0WKhbkYBVXLkEgUr33mHuJERXvnyOobi40nv7nHb7+vck9u/2BkB5fD8eTR7WL2Mdhur3pZ+LwcXLuTI/HkALhmxI8Oc/c5/APjk9NPo9IhakDBo4aw97wHw0eIz6PFIo5zS18dSZyD9fcuW0efxVJze080ZzhBh/7r4K6MRCZx9mHukknMzMuCpp9ixYwcWiyKGdGcnRa+8wupduyAxkS1f/7rrmMhMbWpkvvNB6k3PlL/4Ofec8guPH6fo+HGGY2N595xzxtQf77l3ysGD5La20p2ezv7Fi91kgxQNIrujk47sLK8uBPK515qby2fyq20Fvs49meXvvafq3DteVESNl7jzogCCKM2jt+veF5y+m2rOvbZcd3/nQOdeb1oqqeZevvDGG+M+995bcZZbBBGArM4OTvv4E0C67o3EuivoU1pbWXjwIAC7V69Sfe4ZHHYcBqPr3HtjzRcxp6eP+V3L5541JoZ3Vq1y29eTkU784CBfevkVv+fewkOHqM3PZ1fpeRgcDlLNowYXz3MPkBI5ZWSAxcKsTz91O/fihocwOhwQH49FMFDy4YesfP893lq12u3cM1lHMKWmcsHtt5OdnU1lZSV79uwBQLTZGPzwIwSjgcuefpqM9nYOL1jAnhUrxjyIfO2Jx8m02dh///3sFwTo7KS5sxNEkTRzr9t1rzMn23VNThweglNOYeOPpUQt9//61wz09ZHWI0X4SBy04BAErnj8cY4XFnFw4UL6V66Q3ih3dtLS24txZIQLnnsecD/3EgctWBISSRi0cPXf/w5nnMHOdetobmpCFEXJheCUU8iaO5cLL7wQkO65nR7JyPLy8li7VnJj/Ofvf09XVTUxaanE9vXRlJZGjNXKpU89TdzwMO+s+hxdmVnS/DvbL1q6lNUVFdh+9zue+OpXpTczGRkwbRpkZTF37lxWrlwJwLZt28acG+HQ966++uoPRFFc6llWtxz7IQxvwLSjdLC3WCTlbzzuFSYTJmdweU14vjLMzCSmoUHKwpaYCLOdr868ZUo580xpf0ODe9937wblhVmum5U1+ueLrCxpkcTMmdLTp80m+W8WFUlzdPAgpkDuI+vXjz61ZmUhtLRIirHBAFlZJNfUjJadMQNSUzF89plbEzPrarHEx7ttE+QHzkWL/MsPNwkJ0muu6dMkHyFBIG5kBEuC75+9IDpcFqGA86fjn8M+3HuysqRzb/586dx96SW33SZrmOJu6+hEEEegZCd+K49GNhJV+HIPm0wwMIDDS1m70YggihiGhsD5IFHlLQU5wMCAdM+Nj5cWy06f7n4fsjuomzqN7uQUn0mt6gpm0NfTI4UD/NrXoKtLGoO3vhkMow8nDof0lk9mcNBt7JaERIx2G8dnFo6WcSrGfPYZTJniM1PZsMLNqDk7h9RDhyAnh6HCQkTBQOKgRbJI+3rT4TRYoXzId2Iz9xI7aHFf8C+MHn+ryYRxeBi6unB8+inVjz/BcFExloQEaeyDgyR+9hmccop32VFiUlmOly5dKnqzjoaTcx4+hymDUwB48KsPuizCvvC0HI+bG2+k+sWXGEhKJKeri7xLL5WiUQRLebkUU3JkhPasbNeCmumNjcTYbe5ZpJAWeyCKrPx4/9hIGV5ejRxdtAib03Lc7XRrWPn+e1KiEE+3jE2baHGmdM1rafFeRkHbfffR+dAWsr9/EznXXx94nFu2UPXZIderTbk/ua2tjMTFUfyjHxJ37bU+x2P54x+p/ctDJBQWUrjzFVefDzktmil9veQ3NQG44kd3p6eT09nBnJoa8FAuu594gpZfeg97FwzyeDKUWRMV21ce+ozhoSHasnPIb2pEWLcODh7kkEfKYLn80g8/QBBFjs2ajcFuJ6+1laZp03zKzeloV/WQ5aufoSofbJ1Q0e3hvpPR0yP5vQc4n2UOzZd89+YcPQKCgNFu57DGeOTKfkRzDqIhOxj0uRo/4fydZnR3052REdK5mlFfR12B77ejWZ2dOAwGpnR2gMGATQSTzYpw2WXYtmzh6Mqz3coX1RzHnOq+UFDJgsrDklElJ4d3nddJz3EYbTaXX/uCqmPwzDOue2nLP/9J9X1/9Dv2BZdeAmYzzU8/zfHCImbU10lJY1Qwq7qKquJZgHT/N9rtJAmMXZhYXs6hW24lvaebqX19rv1d27fT+qv/5yomH6uszk4cRiNJAwMMJCWRaBlgZmcnPPEE3ff8lpaOsQnJFlQeltYsjUe3CRJBEHTLcTCY48yY46TXGmoU3pApxTKlpRRv3Qq1lsDxFdVQVgZPPSXFJnYGos/q7CC13/vqw4L6enI62iVXCE8fSmVMZhnBAEjKcUZPDwVyaJfy8rGKwubN5Mn7rrkmtIHK5b4tXAh2h6s/bvz0FsjL855QBeDss6UsU0rLgTOIvWlkxKUYK18xZPT0kNPeLr0qCjO+Lpqu7aJIXEwMBU2No77VwILLL+eQM4SRsrzBbidGFCmsqSHGZsVktzPYnUC3x1jk8rEj6t5AaL2xBXMjjKai4VV2bKy681mxaCVGYS3L6ux08/0Muh8RYrIpevpcjZ9w/k6tToUxlHPV5mXxoRL592a02xmKi6M/JYXEgQFmPv20dO+b6m4oOO7L+uxk2BRLswi0t5Ph4foi47bg8ytfkRK2bNoEZWXkLV9Od4DxO+6+G6GwkJ70DDJ6elQrxgC1igeFxumS69B850O9AKP3QueCv570DKa2tkpZIb0gHyt50albVsubb0a02ehsblb4sCswGoMKNRtOdOU4AFMGp5Dfnw/ArFnVVFcX+3qbAkC1MxZlcXGx70JacEasqH7zTViyhOJQOK+XlUFFBckHDtKRlU1KXz/MmgVr145JEtKXloo1Po7ilhZ1ivnIsCuqhChAW14uydXVPp3uq7/1LfjWt9TNl7xYw9frak/Ky2Fo2PVjbHX6Bi7+8EMap0/H1Nfre9GUL0pLmbttG4L8eumyy+D4cdIaGjGnp9Oam4s11kS602/LjU8+US9HBa25ufTGO5hT2z5mO8ACmxX+8IexCx+eesptkaerfOVhmD+fhGPHpNdzBgNGu5244SGG4+LHlC/yF3fVS39yfaWVHWf5YOuEilYPn9Pc1lbvUVu8UVFBUc1xDM4HOBYtgvnzia14Leh+RHMOoiE7GPS5Gj/h/J32O/2sQzlXQ16iiXhDfpsKUpSPQ/Pmk+qR2U8N1Yp7mqpxvP46vTtfpSc9nYK77uL42WfTmpvrt057ZhY51dUwd57mufKMcAJweN58MtvayL3kErj4YsmN4sMPwZkefNgUy3BXF6nr10uL7RT4li/A9u10vfWWz4RUlthYEu++W/oSgWx+atCV4wAs6FlA1rD0RGlYtZvqav9KnLyoLmTKMUBZGbu7usBmI2StlpaS4EwpTWKipEQBca+8wrBp1D9pz5e+hDE+nmI1GXbKyxFsdjAZKKyt4cmvfQ1MJoq/9jWfJ7zq+Sovx/TUU5CZhemf/5SiWATqT0UFOe1tNDoX1MiLLz6/+21S5XFrtcSXlWF8/HF3hbO8nGkXX4w5PZ3PFi4kdmSE05YvH1M10SPW8dwjRzgyd642+Qo+W7iQtjQHC4+86rYq3jXOgX7v1n2PCCjKeSEmRnq151yNnXPffeR0dtCWneOyrMjl5x8+rGo1ulx+ekOD1wuyr/JabojB1AkVngvKcltbpVXjcspef5SWEr91q5R4ITFR+p2UlZEyezbdztTxWvsRzTmYLAqfPlfjJxK/04kyV73jtGqqGcfA8AiNzsWh/UnJ7J4zB0tCot86XZmZrtB5oZqrrswskiwWRl7fJSm8TsUYRhX+1MrD8Nhjbvt8yR+Ki6PVbMZw9JhPo0HtjJnMrKsl8Z57wpfNTyN6nOOTFTmG8g03jPoYVVQwo7bWvZzZLJ3Qak7WigryWlqIHR4mfmgIkpOlcGaheBKsqCC9vZ2ChnrS2tvVZfwpLSXVbmfOsdHwQHHDQ9KHmTMDZzqSqTrmHrPRMwthWZkUZcOJIDq8xq+Nu+QSFtTXub4bTTHjTj7iMOC20CPRadEWRIcUfF9rrMn580fHt3mzNEfr1pGqyE4ok9vWSvHxaikbmQqm+ElEEkpm1tUGLhRuRFHdOertdwgY//AHihpOnGxTOjo6/qlTRE1pnDYNi8oHY3MY3BHq8wvGvBFTYklIoFWhGPvDYTTSlZnJSIz/CAeNU6dJC+vDkM0vGHTl2A8nfEhYTyWvtJQYYErb6JOf0W53X0Hrj9JSkhGZVXMcITERCgtD19fSUoTERJIHBqS21Vh8nYpHjCJYuUEUJf+m++8PqBjHfPopAEnHqgIHTldcSIy+lMWysjGvoky28UWEEBHdIolMb2rEZB0hYWhI44XG6SvkuRq5rAxeegmTlwuwgBQT2uAx3kRnMpWxIkTmHjkSsmyEvoj1yMQIUqxqrcw7UknRcXWuI15R+1bCW8r3sjLJzUlHR+ekQ4rdrDJlaRTwXLivhsF4Fcq+IIx/XVWI0JVjP0Q9Q16kKSuDW28l0alIxA8OSierWv9JTyvYeDP6+Wtb7WsXp1uBW1bAiy9WVT/2gw+YXXWM7M6OsZmIPHEudgOkOVN+V2I2E2O1ktXZCSMjpHiEgdOKCDCoUGhFEZOcCS8uTvWFxmT1nz3PKIfq8yQ1VVp8piDJR8IUg0PEKIAhXVK001QuttGqTMc4HC4FOaW3lwWVhymurZEWSjqZe/QI+Y0NvpqQ+hsbS/zICMXBKsjvvx9cPZmSEtVWeR0dHZ2JTKCslTaTSXrjNt7rZojQlWONRDxDXqTZvBk2bgSCfG71ZgULFcG2bTYzrbkZg8MuxSD287rIjdJSTLGx0jwEslYr+1RQ4LuPpaXMaWmWXAwSExGcCRwC4cvyKRog2xkaJ81slqzWcXHSA41n6D0/xNhtUnxnX0q9l7SkgDQnHiHrBIf3WJvJA/2QnEzcD34AQEKAzFcyRrvGtNcGgyvWdHaXM4h9Xh7ZXZ0sqDzMgsrDbtb95P4+Erwp9MPDsHIlcSOjcYfVpF53xYceb/pUs5nZ1VVht7Tr6OjoTBi8JPeIBvqCvAB8kP0B2YPS6tU9f7rJp44gc8EFF4SlH+Fq1xvxgkBmVyeZ3d1cUF4e9BOBmj5HZFylpSRt3cplTz8tuSA88IC6erK1Wk2aS6citGTvXma1NMOSJd7Le7ZZUcGcZ58FQeCol0xfIPlJe7ouyLI++/wQaYODpFU6I3jExXHBF78IX/wiKFZd+2PJ3r0U1dbAbbf5HmNZGQvuuotD8+azxJm9C4MBLBayOjtpmzJFUdj9sUouLwDceCOJR48yq7oKk9VKi2fqVUV5FwaDW2iztJ4ezB6xhd3qOBzktrfRnDeV2JERWLdOSrRRXi6FMKyrk+KPLjoV3nsPREmhHXS6pyT39ZEihzbs7ZWOZb/kKlJYW0t/cjItipCNnv11WZrH+4BYWkrMI48Qp3ATmdbcRJNHSKmUvl4SBgfHzlsEiabsYNDnavwEMw6tdfS5Cq+MUBIy+SrvW+FGV479kJIC/aZ++k39AIyMBD5o2WE6sOFq1xvC+eeTu20b2GxkDw7CmjVBtaOmzxEZl1MhzQ4ml7u3aA/eqKigsLYGu8FIsmXAf4g4jzZjtm518/Utrq52rQqee/QIgihSn18wppnUvj7sWclSdAl5AeB115GtUSlL7etjSns77N/vu9DmzfDqq9A/QKrsb+RU2LMG+sk40k1fcgpN06YRNzzMrOoqREGgfnr+aHmQViIDsVu3IlqtpPd0MxwbR2Z3tyvWZqqnP1N2NlOOHXMpx9NaW7CaTG6RMuQ6RTXHAUgaGWF2dZVbfGfPeU+49joMdjvZXZ1YEhLpTU0lub9figstI5d3Jn4x2W1kmHsYio9zpf317K8gOv3Ax7sQtawMzj0XgzNL5vTGBmkNgIKZdbUkDg4ieulHJImm7GDQ52r8BDMOrXX0uQqvjFASMvl33BGadsaJ7lbhh95emGqZypltZ3Jm25ns3VsZsE5lZSWVlYHLaSVc7XpF4d9b+dBDVM6bF1QzavocsXGVlVF5001BjyUgpaUkGAw05k+n8tRTtS3Gkn2pncQp0gcbHQ4MxcVS9A8nec4sjE3TphEnTnUtmuOll6RxapzTpmnTqJw7Vwo/5o/zz3eVN6elSmHfrrsOnnoKw4wZpPX1Mqu6imTLALE2G3EjI0xvbqJp2rTRTHtbtrjGLCxZwtTWVgrr69yS0LiVB0mh/tnPRr+vXEmKx8JBuU788LC04PKWWwL6p8dc8GXmNTWSMDTkCvjhimaSmjqa4c5sZlZ1FQVypJGcHHIVrg6y7KZp0+jMypQs5F4yCwbFddeR6HCwoPIwqf39JA4NkdM+KjtxcBCMRoSEhLHzFkFk2QmDlsCFJwATYa4mO8GMQ2sdfa4mz1yFTL7uczw5mGueS74ln3xLPnv27AlYfs+eParKaSVc7frE6d+7x24PWq6aPkdyXGGV5VT49lx2GXuuukq7dVqpTDtz0ruyzSQkMEWhEKWbewConD+fJMv0Mb6tWsY5vamRusKZ7Fm5MrAvtjMQfuX8+Xxy+umjVviyMin6R2IisVarZK29/XbJnSHGROX8+VTOd6ZDlpX2sjLYt09SQJ0pVuOdPshyeZefdW2dy+IMSBbuc89165qbjOXLJaU2kH+64sEk/cwzyezqJLvT6aP8jW+MWn5LS4k1mUi2OLNUfuc7GBTxmivnz6d+5gzqCmdyTI5bHaqHMDmj5bp1sG4dwu23k630P1+yBJ59Fr78Zfc5cGJw2N0WFJoU/tOh9GWWZRfW1QUuPAHwNlcng+xQEsw4tNbR52ryzFXI5I93rUaI0N0qdHRCRVmZ+rB3nlRUkNzXJ2WGcjiYe7xaCsWWmAhlZQiHDjGtuYnutHQEoCu2hSPTIWlI1J7lT3HxSe3rk9wA/EXYkPEM51ZSMvrZh3923Ewp5I8gh4rzXNC2ebP0V15O2jXXMKQI95M80M9wfDymTz+BLVsoqjnOcGyc5ILiIyIG4HvxoDecyr2hvJzcDRukBxLPxZfexrZ8OTE//gk2RepweREgsbGB51IL3lx7nG4eHDok/fcMwedknjOrZEpfL30pqUxvbsJos9ORlUVmd5fLVzy110xvqnR8EwYtDPpId+sfafxzjx7hyJzgk9v4Il5jUhQdHZ1JyARIAAK6cqyjMzEoLaVg61ZoaoTERIw33yxZahWKZto995DW2wsxMdhjRGxGIbi4kBUVpPT10ScvtExKgqKiwBcls1kKQSfj6aPsRYkzfP3rJDQ1jS7R+/rXvbddVoa48Wp48UVAUjRzOjpIHhiQXAeAeKOR+L5eyUKdkw1HjnhvKxjrRaDFl55jKyuDu+6CHvNo1I2cHClV+VNPhfcCbzYTNzREjN3uFmJQEB0YHI6xymleHtObmhiK75LiXyP5bSMITGuS3F7SzL0Y7A56MjJI7e11KcfxQ4NuDyz+kB+yjA4HhbU1NOflMRwXT/HxamJsNkRBoC85xW0xo6uLLc0kDwxwbJZ7yMDZVcdc22bW19GWM4XujAzX/vSebpfv93jIaW+jPWdK4IIhZr5zIa0lIdEtCYSM4HBIvvPgc8GuN3La22nPyQlNJ3V0IomX7LLRQHer0MDbb58EiUF0ooNnHGdPt4DNm6WFdzfcIP3ftEnanpSsXRErLWV6T7eUOTAxUVKM1cSkLi3FqAxEsWtX4FdgmzcjzJghKeCyD68P4rpHre4JQ4MIOH1q5UV1ivlJTkigqOa4W+xil+VWbag+T7SGCpStq7m5sGgRnHIKzJkTfstHaSnF7W3MaKgftXJfdx0Jw8PEjYxgdDiYWVvjWpzI4sUIcXGSYhwXJx2HG26A228nedBCQUM98cNDZHV3ETsy7LawZkZ9Pck+Ftp4DX936aXws5+RMDREcU0NCyoPu/oUY7eT4XQJUpLT3ka62Twan9tJ0fFqaZvzuAqiSF5bK/kNUnzq5P5+prZKWRqNNhtZnR2jPuNe8BxHjCJEYFZ3N1M90rtHAgEQYmJIGrQw70ilK7tj8fFq4oaHKKyrJcZulx6EPJjhx4Ul3keYxGnKxaYeFNbWaOq7jk5Y8JJdNhrolmONnCCLZ3UmIoEiYyj3N+yGo7VjEnColSM88QQxspVUrStIWRmpJSWASIzNJsUBVuPSUVQk/TnjZ/si+b//Jb+xgUR5UVdKCnzzm+6WXIWs+EcewabwvxVEh7RIMNIZlgoLJaUzUviych89Kh3Ln/2MxPvuk6zK8oPFddd5tYobgeR77gG7Hex2Zh0/LtWR9xsMFDQ1cmieZI2f2txEV0Ymw/HxxA8NMq25iariWYDz4eSFF6T42v/6lxQ2r6MDli2THiDS0qC8nDlOV5CqomIcRiPZ8vnnYVGOsdsl/3t5teTixVLWwB07pO9OpTluZIS5VccAyOju5tjsOQgOB3mtrfSmphI7MkJ3Rgbp5h7yncrh+yvOcpMlmEzEFBXC0DBJAwPMaKhnKC6O44VFmg6NbCX35lYyv/IwLbmjYzTKDwO33ALLl2P40Y9IrKpigdOaXFxT4+ycADNmMKu6CktCIs1TpzrH7Z4JcmZdLQaHA6vJ5IrNnd7TQ3Znh8v6ntbXR5OPvguiSOLAgFsUGC3MPXqE+un55La3MWKK1bw4K7W3l+SBfmKsNq9WdJ0TG9cak0ALwyOEIMrWlknA0qVLxX379kVU5pl/PZO0YckX77+3P01vbxr+pszsXLSUFuJ85+FqN5xy1dSN5LgiIStS49ndsJufvPoTluUt44Evu8dt1toHTeXLyzFfey0MDpJms6nKVqi6/U2b4K67MDtfz6TdeKP/cGjl5Vi//32OxSdgSUwko7ub4rpaeO65iPitHT3rLGw9Zqb89CfEXHaZa3ukf6MybvNcXq4uPjeMlk1Lc7nyHLrlVgAWXHoJbN9OrUPEkpgoWZmHhqiZMZMZDfXEWq0cmjcfS2IiRTXHyezulqzSf/6zb1kbNoDFgkMQEJ1uGFx2GeTmYnvoIexGIzajUcq0uGQJh/r6QRCYX1+H8MQTiDt30vrMM2R3dkoK9Lp10sNXWhrWV17hmGUQo83mUphFYCg+XrKcp6ZCXBzmvDyw24mpqaEvOYW8tlaG1qzheEMjWZ2dTOloRzQaac6ZQl9yMg6jEcHhcKb1lSg+Xs1AYhKtijcV8ysPIwBHZs3GHuNue1pQeZjm3Fyapk0ncWCA2dVVkmVcOV/l5aOWs5KSUdcqcM3boXnzMdjtzDt21PXQAlK6c4MgSCEWY2NBsfhSLreguYlDeVNBEEi0WEi0WOhwhtMsrq4mzjrCsCnWFUpSmkBx9AHFyYy6Og473ZcKnUp8Vrf7Q7Ysc1Z1FU1TpzKYkIjF+eCVaLFgsNvJb2ykPSeHwYQEqf/Om2tfUjLNeXn0Oa8FiR4+9a71GR6kms30On9/bq5jTnJbW92OV7Ck9/RgMxq99sEbynH7wtO1R1mnoL6O+gL/DwzK8uHy+1crPxgK6uukRc9yXPoIIQjCB6IoLvXcrluO/ZCaCjP/NMhgjPSKqrc38E0vXDfGaN1wxyNXTd1IjisSsiI5nsGYQRxxY5ODaO2DpvJlZaSBesVLS/tORTitvFxqN1Cc4LIyTMCCSy5hxGAYzUyndYFiMJSXk9zQQE9yCuk334wxJyfqC0nc5lltfG5vZcvLEUQRURDgvvvg5psR/vF/0j6jkZjCQmbX1EjWZkGgoL6eGLttNIxeoEySTqu3QaGMU1YG5eXEPPIIMSMjxIFkjc/NJb2hQfIrdvpXC2vXkvfYY5J82TLu7H9MTw9J5eVkdToVtVmzEGpqRl1K/vGP0XPYqagntbVCYiLxcXEU1ta4wiYK55/PtIoK6mJicBgMFNbVuhS+3NYW4kZGiBsZIbOnG7vBgM0YI/nWx8eT19ZK49RpFNccx+BwSHMJIBhItFjIa22VFGNviz99HbcnnoBNm8htaCBpQFJAYoeHGXG+tTCIouTWkps72uaWLZIlzpnEhv5+5h+pdD0sDDhdg/JamqUQkitXEvfuu0xrasKclkZ2ZweJg4MMxcVhNZlomJ5PosVC0qCFJR996N6/uDj48Y+ltQhvvsnM2lqMDjuxVisz6utxGAxUFxYRNzyMJSkJAUgatJDkdCWR5keA3FxSWloYNJvHPGAU1RwnxmbD4HBQmTI2Isz0lmZEg0Dc8AjZnR30JSeT0t9PdVERmd3dZPT0kNnTTVVhESNxcRQ01HuNIT+1uYn03l63hw8ZWYm3xsRwTKEcz6irYyApyRWPHSC/scE1Z4FIN5vdlGO5TtzQkGvdBUBWRwedXvIDyOUTBwYwOhxeHw5kUnt76fXiI5rc309/cnLAvnojWKXYNDKCNTZWUowhtIuZx4GuHPuhrw/yB/KZ2SetuBcXHqCubpHfOgcOHABg0SL/5bQSrnbDKVdN3UiOKxKyIjWeyy+Hxd/I5/Br8QjnSR4IcpAGrX3QXL64GL773fC0v3kzBzZskMqrabysDG69lSMvvgh2O4uOH4+MW0VFBXmNjWTHxHBo3jxpQYLT2hbp36hMyM69igqKao4zkJgkKaT7949GGxEE+MMfXOVISyP5d7/jwJw5IAgsUqOU+yojh61TJLQByNuwgdy2NgRZkfSzeFI4/3xmbNsGg06XEmVfFWUPHDgAxcUsUrYDJLz1llReVrpLSkB+MACXFTWzp0eai8WLoacHY3U1RuuI5Nbzox+R+rvfkXrEI9a4wUBSfx+fnLqIwYR4Mmw26QFQy0MMkLlhA1hHwGhkZl0tR5UWwtxcd6t9WRnceCM5TzwhhVl0OBCMRulhISaGpCk5FFdXEyvHVj/jDPj850n79a9J6xuN+hJvtRI/PMy8I5Uu3/4D550HIyMsamiQQhcqHlIoLyfx0kuliDsGA4YzzsAAjNjtDCUmYBqxSnMZEwMZGZIlStnG0qXkfPABH51RAkDJ/v2IgkF6AAMQBJ+LMfObRh1HUvulBF6zjh8fLZCUxKya457VRus3NJAy0O+2bUZ9nZRtE+dDyPTpCPHxbmWSBi3E2KxuynFKfz/Fx6t5a/VqAM5/7TVGYkxUzZJckbI6O8nq6nRLZy8zkJTEUHwcZ+7d67KoA0zp7CCjp4f27GwcRiN9KSnktLdTWzgTwbkgF6QHnvihQexGI12ZWa7MonmtLWT09DC9uYmBxETq8gukh9yGepIHpIcoETjsfDDwp2RLY5D688YXvkDc0DD5DQ1YNbj7FdbWECOP/2c/i7qRQUZXjgMwq3cWWcPSyb5s2T4OHPB/45HdPkJ9gwxXu+GUq6ZuJMcVCVmRGo9lUDo3bbGJvIW7L7zWPkz28mzezL7MTOjqYtHy5ZG5uJaWImzdisliYd/y5VLSjyj9RmVCdu6VlhK3dStxPd0u/+OpTZKvcZLZLCmTyoWLy5ez7/33ITOTRT/+8fhke1GchSeeQPBUhP0p2N4UZ4+yrrnauNF9n2fdigpy2tpcGdHnHDs66lqxeLHrmI9xY1m+fKx7RFoaqffdR/P06TQXFLD4oou0n6vK8aWlEfO73zG/8rBkmY6L8/5gWFpKtpyFMzERlJFwgDhZ2VY+fCj7L1vyPKz9+5y+4ou8rSUoK5MWDnsch32//z1UV7N81xtk9HRLyvP69WPdcO64A+GSS2jKzwckpRIYXVNw3XXw4F+gpsal7Ln233KLa77d3FKUfdm0Cf7v/2BwkOLqKowOB8eKZyEaDKOKsTNjJ0CSbNU0mSQXoKeewnjDDWQ/+SQxNhtGu6TcxaWnM625xCsK6QAATQRJREFUCYPdgcN5nsSJIg0FBS4FONZmdYUlTO3rlbYbjXDxxfDpAZfMT08/DUEUOefddwFIsFhcbyBMsSamtbYgAubUVNJ6e3mx7EIAFu/fD7GxxAgC2V1dOAQBo91OVleXFKVGJj2dpJ4eFng+xCUkIAwNkWixYElMJLXXTG6b5AfsGU1G9o8HqJo9mxibjQLnglmQXI+qi0ZddOZXHsZmjOHYbKmduUeOYBQdMGuW9CA7QRRj0JVjHR2dE4GsLOkvUhdXpZKiNtrHZMFTwQRi3nqLKR3tY90A5PLBxvdW2x+tSXWCPQ8865aWkiArlrGxkoXLZpN8epVpbr2F+vPWh+XLpQxgmZmh6ePy5Qhbtki6u9Jy61neX5hCXw8T3sIZKtm2TX0/ZZy/kwXbtiHKyro3hd75RkhobpYszLGxUuIfeYzl5YgHDkByMhiMUjKc3Fzfc+DZf0V89TinL/es49UMyxbPdeugro609g6XLy0zZkDtqAuIcP755Dz66Khvd1wcfOc7pN1zj3SOyFx0EUZlDPRTT2X6x5/QnZFO3PCwFOlm82aoqCD39dexG2PI7O7i/ZUrpPCQixbB/PkUvvzy6APOE0/A++8j3H036c7wnmRmSvNxww1ubjWGXbukRa+xsVBQIPXtyitd4+fOO6GuThrfHXe45tf03e8BUpZWk8Mh+bI7yW1tHV04HRMDZ55J/PAwgiiS0d1Fa24egsNB3MgIWZ0ddGZlk9PehgCYRAcz6moZTEiUFOMI+xirRVeO/eD5JkER719HR+dkR775B1ISJiOeio0/5epExsuDwrjmIdQPEmofBPyVG8/DRDBkZUnp4wPN4+bN8PvfS/PlGTu8ooLU7m7Myckk9vfBWWf5XgTqD/n4btmCadcuTMoIL++/z7S77hot6xmj3ZsbkGx1lyO1yEqochxA7IYN5LY7HzYVrjWZW7eCpUdSNgoKpAfve+6R2vd8OyHL8ow69MtfuvfR3+JcX8e+ooLc1hbiB6VFm/LDQuHRo3SnZ5DR0y09kMXFSdFjysow/P730NREZn8/mT1Oi7LBwJTOTqZ0dEjfnZb9pPvuI6mrc3SuJyC6cuyH3l648Tej3885J3p90dFRkuiRl0HlomkdneCItAI1kfBmFdYZH2rPJ19vhEpLSd66VXqt78v6rLUv3pRPkLb7WiDsy8LuzWKuHIcva71yu+dDVCBZvh7Sg/ntlpZi3LpV8q1XKLAJGzaQ0NoihVg844xRS7NyjM88M9Ylx9sDxAR/2A6bciwIwlrgj0ihNB8VRfE3HvsF5/51gAXYKIrih+Hqj47OicRTT8GO/4OsTPyGFtTR0dE54QjkKhJsm57tyO4Xocafz3wgZTcS+JpfNXOuxiVnEjxshyXOsSAIRuAIcB7QAOwFNoii+JmizDrgJiTleDnwR1EU/eYNjHSc49RUmHPfEpJGkhAdBj786ctYLIl+lRGLHE5FEUg/FISr3XDKVVM3kuOKhKxIjSelZDdzv/9D+g+exZE/SHGO5fNSax8me/lg64QKi0cIo2j0QdmPaM5BtMauFX2uxk8kfqf6XE2euYq2/GCJdJzjM4FjoihWO4X/E7gI+ExR5iLg76Kknb8nCEK6IAhTRVH0mcOzs7OTbR5PUwsXLmTZsmVYrVa2b98+pk5JSQklJSVYLBZ2yJmVFCxdupRFixZhNpt57rnn3PZdeik0DmfRnNhM0mA669dL9ZVdWLVqFcXFxbS0tLBz584x7a9Zs4aCggLq6+vZtWvXmP1r164lLy+P6upqdu/ePWb/BRdcQHZ2NvX19ezZs2fM/osvvpi0tDQOHDiAtweH9evXk5iYyP79+9m/f/+Y/VdeeSUmk4m9e/dy8ODBMfs3Olciv/vuuxw5csRtn8lk4sorrwTg7bff5vhx9/A4iYmJrF+/HoDXX3+dBsUqVoDU1FQuueQSAHbu3ElLS4vb/qysLC68UFqB+8ILL9DZ2em2Py8vj7Vr1wLw7LPP0tvb67Y/Pz+fc889F4AdO3aMUWKKiopY7Qyxs337dqxynFwnc+fOZeXKlQBjzjsI77kHsGLFCubNm0dHRwcvvvii276vnmPm+Eg6naJIXl4La9fuHGNoUHvutbS0+D33Kisrx3XuHTly5IQ+93bu3HlSnXsQueveeM89/boXvnPPZDLp514Yz739+/fr554H4b7uKQmXcjwdqFd8b0CyDgcqMx1wU44FQbgWuBZguiK0SqRIObyKOXnNODoKiEnup7/ff4DsfmdcxeQgA2n7orq6mv7+/pC3GwhvP2619PT0sH//fkpKSsLSvlbCdWwiLQPAPpRE7mAu/ZVfpM5HH9RSVVWl6dzS2n5dXV1Y21fWifTvA6C7u5tBRZD+aPQBojsH0ZQdDJ988gnGKK2w7u7uDnhdnAx88sknmu9J/f391NTUqA43ONnOK18EM46mpibN180RRVbESNPf30/rBEn9HArC5VZxOXC+KIrfdn7/BnCmKIo3Kcq8BPxaFMV3nN93AbeIoviBr3Yj7VYhCLBx4zZmzJDUj7q6GWzbttGvW4X8tLPRW+zHcRCudsMpV03dSI4rErIiNR753JRkSrLk81JrHyZ7+WDrhApPC0c0+qDsRzTnIFpj14o+V+MnEr9Tfa4mz1xFW36w+HKrMHgrHAIaAGVOxnygKYgyUUWPAKCjo6Ojo6Ojc3IRLuV4LzBHEIQiQRBiga8B5R5lyoFvChJnAWZ//sbRoLcXVq+WQg4ajdJnPTKAzkRAFKXzUT4n9fNSR0dHR0cnNITF51gURZsgCDcCryKFcvubKIoHBUH4rnP/Q8DLSJEqjiGFcrs6HH3R0dHR0dHR0dHRUUvY4hyLovgykgKs3PaQ4rMI3BAu+To6Ojo6Ojo6OjpaCcuCvHAR6QV5AFar1S1+n8lkClgeCFgumH6Eo91wylVTN5LjioSsiTAerX2Y7OWDrRMqPMMRRaMPyn5Ecw6iNXat6HM1fiLxO9XnavLMVbTlB4uvBXm6cqyjo6Ojo6Ojo3PSEekkICcMe/fu5aOPPgLgjDPOYNmyZQHLAwHLBdOPcLQbTrlq6kZyXJGQNRHGo7UPk718sHVChSxbJhp9UPYjmnMQrbFrRZ+r8ROJ36k+V5NnrqItP9SEK1rFCcPBgwdpaWmhpaXFazYbb+XVlAumH+FoN5xy1dSN5LgiIWsijEdrHyZ7+WDrhApZdjT7oOzHySY7GPS5Gj+R+J3qczV55ira8kONrhzr6Ojo6Ojo6OjoONGVYx0dHR0dHR0dHR0nunKso6Ojo6Ojo6Oj40RXjnV0dHR0dHR0dHScTKpQboIgtAO1URCdDXREQa5OZNGP88mBfpxPDvTjfHKgH+eTg3Ad55miKOZ4bpxUynG0EARhn7c4eDonFvpxPjnQj/PJgX6cTw7043xyEOnjrLtV6Ojo6Ojo6Ojo6DjRlWMdHR0dHR0dHR0dJ7pyrI6Ho90BnYigH+eTA/04nxzox/nkQD/OJwcRPc66z7GOjo6Ojo6Ojo6OE91yrKOjo6Ojo6Ojo+NEV451dHR0dHR0dHR0nOjKsR8EQVgrCEKlIAjHBEG4Ldr90fGOIAh/EwShTRCEA4ptmYIgvCYIwlHn/wzFvtudx7RSEITzFduXCILwqXPf/YIgCM7tcYIgPOnc/r4gCIWKOlc5ZRwVBOGqCA35pEQQhAJBEN4UBOGQIAgHBUH4gXO7fqxPIARBiBcE4b+CIHzsPM6/dG7Xj/MJhiAIRkEQPhIE4UXnd/0Yn4AIglDjPEb7BUHY59w2sY+1KIr6n5c/wAhUAcVALPAxcEq0+6X/eT1Wq4DFwAHFtnuA25yfbwPudn4+xXks44Ai5zE2Ovf9F1gBCMArwJec268HHnJ+/hrwpPNzJlDt/J/h/JwR7fk4Uf+AqcBi5+cU4IjzeOrH+gT6cx6TZOdnE/A+cJZ+nE+8P+BHwOPAi87v+jE+Af+AGiDbY9uEPta65dg3ZwLHRFGsFkVxBPgncFGU+6TjBVEUdwNdHpsvAh5zfn4M+Ipi+z9FURwWRfE4cAw4UxCEqUCqKIp7ROlX9XePOnJbTwNrnE+s5wOviaLYJYpiN/AasDbU49OREEWxWRTFD52f+4BDwHT0Y31CIUr0O7+anH8i+nE+oRAEIR/4MvCoYrN+jE8eJvSx1pVj30wH6hXfG5zbdCYHuaIoNoOkVAFTnNt9Hdfpzs+e293qiKJoA8xAlp+2dMKM87XZGUhWRf1Yn2A4X7fvB9qQbm76cT7xuA+4BXAotunH+MREBCoEQfhAEIRrndsm9LGOUTWskxPByzY97t3kx9dx9Xe8g6mjEyYEQUgGngFuFkWx1+l25rWol236sZ4EiKJoB0oEQUgHnhMEYZGf4vpxnmQIgnAB0CaK4geCIHxeTRUv2/RjPHk4WxTFJkEQpgCvCYJw2E/ZCXGsdcuxbxqAAsX3fKApSn3R0U6r8zUMzv9tzu2+jmuD87Pndrc6giDEAGlIbhz6ORJhBEEwISnG20VRfNa5WT/WJyiiKPYAbyG9CtWP84nD2UCZIAg1SC6LXxQE4f/Qj/EJiSiKTc7/bcBzSG6rE/pY68qxb/YCcwRBKBIEIRbJybs8yn3SUU85IK9MvQr4l2L715yrW4uAOcB/na91+gRBOMvpq/RNjzpyW5cBbzh9nl4FSgVByHCutC11btMJA87j8lfgkCiKf1Ds0o/1CYQgCDlOizGCICQA5wKH0Y/zCYMoireLopgvimIh0r31DVEUv45+jE84BEFIEgQhRf6MNN8HmOjHOtSrEk+kP2Ad0or4KmBTtPuj//k8Tk8AzYAV6UnxW0j+RruAo87/mYrym5zHtBLnalfn9qXOH20V8GdGM0jGA08hLQz4L1CsqHONc/sx4Opoz8WJ/Aecg/RK7BNgv/NvnX6sT6w/4DTgI+dxPgDc4dyuH+cT8A/4PKPRKvRjfIL9IUX8+tj5dxCnLjXRj7WePlpHR0dHR0dHR0fHie5WoaOjo6Ojo6Ojo+NEV451dHR0dHR0dHR0nOjKsY6Ojo6Ojo6Ojo4TXTnW0dHR0dHR0dHRcaIrxzo6Ojo6Ojo6OjpOdOVYR0dHR0dHR0dHx4muHOvo6Ojo6Ojo6Og40ZVjHR0dHR0dHR0dHSeqlGNBENYKglApCMIxQRBu87JfEAThfuf+TwRBWByoriAIv3KW3S8IQoUgCNNCMyQdHR0dHR0dHR2d4AiYIU8QBCNSCuXzkFLz7gU2iKL4maLMOuAmpFSuy4E/iqK43F9dQRBSRVHsddb/PnCKKIrfDfUAdXR0dHR0dHR0dNSixnJ8JnBMFMVqURRHgH8CF3mUuQj4uyjxHpAuCMJUf3VlxdhJEqDnsdbR0dHR0dHR0YkqMSrKTAfqFd8bkKzDgcpMD1RXEITNwDcBM/AFb8IFQbgWuBYgKSlpyfz581V0OXR0dHQwMjICQFxcHFlZWX7Ld3Z2AgQsp5VwtRtOuWrqRnJckZDV2dnJ8PAwra2tnHHGGQHLf/bZZ8TGxjJ79mzNspqbmxkeHqagoACj0QhAVVWV63NeXh7x8fFe6/b09FBVVcWCBQsYGBhgYGCA1NRUMjMzvZa3Wq188sknzJgxA7vdztDQELm5uSQkJPjs34EDB0hKSiI1NRWLxYLFYmHevHk+yx87dgyr1cqUKVMYHh6mpaWFxYsX+yzf1NREc3MzS5YsoaWlhaGhIaZNm0ZsbKzPOqHk0KFDmEwmMjIyALDZbAwODpKTk0NSUlJYZHZ2dlJTU8Opp546ZpzRukZEW3Yw6HM1foIZh9Y6+lxNnrmKtvxg+eCDDzpEUczx3K5GORa8bPO08voq47euKIqbgE2CINwO3Aj8YkxhUXwYeBhg6dKl4r59+1R0OXT87W9/o7a2FoCioiI2btzot/y2bdsAApbTSrjaDadcNXUjOa5IyNq2bRtHjx7l4YcfRs25unjxYvLz8ykvL9cs61e/+hXV1dX86U9/Ijk5GYBLL72U1NRUAG6//Xbmzp3rtW55eTkXXXQR//d//8d7773H3r17KS0tZcOGDV7LNzU1MX36dDZt2oTZbOazzz7jpz/9KaeccorP/s2ePZuzzjqLc889l/3797N//37eeustn+UvvPBCmpqauOmmm6iqquLee+/1O4f/+7//yy9/+Uv27dvHXXfdxdGjR7nrrruYOnWqzzqhZMmSJUybNo1LL70UgK6uLj799FOuu+46zjrrrLDI3LZtG1dffTX/+te/KCoqGrMPIn+NiLbsYNDnavwEMw6tdfS5mjxzFW35wSIIQq237WrcKhqAAsX3fKBJZRk1dQEeBy5V0RcdnQmPw+HQZL0M5PcfqF5MjPdnXF/bPdsI1I6v8gaD+mA3oiiqbl9Lec8+yVbzSOHt2AmCN5tAaAhn2zo6Ojo6EmrubnuBOYIgFAmCEAt8DfA0c5UD33RGrTgLMIui2OyvriAIcxT1y4DD4xyLjs6EQBRF4uLiVJUdj7LjTSFUtudPUVSWU6NYeuunlr6LohhQcfXsk5byMpFUjj3ly/MYCQU22AcqHR0dHZ3ABDTNiKJoEwThRuBVwAj8TRTFg4IgfNe5/yHgZaRIFccAC3C1v7rOpn8jCMI8wAHUAnqkCp0TAq2W4/HiSyHUqiiqLR+M5Tic/VH2KdKWY2/olmMdHR2dyY2q95aiKL6MpAArtz2k+CwCN6it69w+KdwozjrrLJ5//nkArrrqqoDlV61aFZZ+hKvdcMpVUzeS44qErFWrVrFr1y7VlmMI3gpot9vZvXv3GCV19+7dgHo3iVmzZnHvvfdy2WWXqSqfnp7O7t27+fnPf66q/KpVq3jiiSdUzYlc/oMPPtDkVmEymdi9e3dU3Crk8+q9997jwQcf5Prrr4+IXE+idY2Ituxg0Odq/AQzDq119LkKrwwtWK1WGhoaGBoa8rp/yZIlgLRQeSISHx9Pfn4+JpNJVXl1d5+TmMLCQl544QUAVYumiouLw9KPcLUbTrlq6kZyXJGQVVxcTFdXl2rL8XgsgTabjbq6ujHtVVdXA+rdJNLT06murlZdPj4+nurq6oB9l/cXFxfT3NzMrFmzVJcfGBjQ7FYRaAyhRtlfgIMHD6qal1DI9KYcR+saEW3ZwaDP1fgJZhxa6+hzFV4ZWmhoaCAlJYXCwsJJ9wZLFEU6OztpaGgYs5DZF7pyHIDW1lZWrlwJQEtLC3l5eX7Lt7S0AAQsp5VwtRtOuWrqRnJckZDV0tJCTExMRNwqHA6H18gM8vjUKoo9PT3k5eWpLj88PExeXp5qt4qWlhZSUlJUt9/S0oLRaNSk6NpsNk1jCCXyeTUwMEBeXl7U3CqidY2Ituxg0Odq/AQzDq119LmaOHM1NDTkVzG2Wq0Aqi2zkUQQBLKysmhvb1ddR5vT4EnIG2+8wbnnnsu5557Lzp07A5bfuXOnqnJaCVe74ZSrpm4kxxUJWTt37qSoqCgibhUmk4nzzjtvzPa1a9eydu1a1W4VlZWVmsp3dXWxdu1a1crxzp07Of3001W3v3PnTjIzMzW5VdhsNtauXRsVtwr5vGpsbGTt2rVRW5AXrWtEtGUHgz5X4yeYcWito8/VxJorf9c2s9mM2WwOq/zxoPW6rCvHOjohRsuCvPFGq/CsH4loFcFEZQh3tIpoLMiT5e/fv5+3336bAwcOREzm3LlzEQQBQRAoLS1FEATefvttDh06RGlpKSaTybXf86+0tJTY2FjX91DR0dHhVV4gd5po8fbbb7v6GOnoHz09PT6Pjxbrlo6OTnjQlWMdnRCjJZTbePGn3IQzOgRMrGgVMtHwhfO0loSzD8uXeyYnhf7+ftfntrY2PvjgA2w2m882+vv7Xa9AQ0lHR4fX7bIP/EQmHPPhD38WtsrKygj2REdn8iAnu1Lyv//7v0yfPp2SkhJOOeUUnnjiiZDI0pVjHZ0QE8kkIP4UsYmQBERrUo/xJAGJhmIsR+9QptEOZz9mz57tGq/89+677/Lxxx+7yqxdu3ZMGc/yoijyjW98g8LCwpD1TRAECgoK3GRddtllLFiwIGQyQonyRhtpy3FiYiIgLeKU5+q5554DCFvqcR2dE5Uf/vCH7N+/n3/9619cd911IXnY1Rfk6eiEGIfDEbEkINFwq/C3zZ+MSLhVRBJf44/2Sm4t514o583beR8NlwW1KPsV6T46HA7A/Vj5i0SiozORuPnmm9m/f7/btvEuyCspKeG+++4bV7/mzJlDYmIi3d3dTJkyZVxt6cpxAM4++2z++c9/AvDtb387YPk1a9aEpR/hajecctXUjeS4IiFrzZo1/PnPf+a0004Lu6zu7m727t07ZvuuXbsA9UpaXl4ef/zjH/n+97+vqnxSUhK7du1S7VaxZs0a7r33XlasWKG6/CuvvKLJrWJoaIh33nlHdflQUlVVRVdXlyus3s033xyVfsjH/ctf/rKq8gaDIWSK2Jo1a3jjjTcmjXK8Zs0aHn74Ydf3SPZxzZo1rvCgyjdMk005DuZ6qrVOtO57oeZkmCu1b/rCyYcffsicOXPGrRiDrhwHZOrUqbz++usAFBQUBCyvpkwwhKvdcMqN5nxFS1ZBQQH19fUsXbpUdZ1gb4aDg4N0dXWN2V5fX6/66V0UReLj46mvr1ft9mA0Gqmvr1etHBcUFNDY2Ki6/YKCAsxmsya3ipGREVpbW1WVDyWiKGI2m+nu7qa+vh6InuVYlh8fH6+qvCAILgvmeCkoKKC7u3uMO1EoFfBQUlBQQENDg+t7JPuovA4pHybk39NEnC9vBHM91VonWve9UHOizdV4Lbyh5t577+WRRx6huro6ZBE7dJ/jADQ1NblCuck3H3/U19erKqeVcLUbTrlq6kZyXJGQVV9fT1ZWVkTcKmJiYsbEtJT9PmfMmKFabm9vLwUFBardKkZGRigoKFDd9/r6enJyclS7SdTX15OQkKDJrUIQBPLz81X1J1TI8lNSUsjJyaGgoEDTvIQaWX403Crq6+uJi4vzajkOlQIeSurr68nIyHB9j2Qf6+vrGRgYALy7VUzE+fJGMNdTrXWidd8LNSfDXI2MjDAyMhIV2T/84Q+prKzkySef5Jvf/KbPLH5a0JXjAPznP/9h5cqVrFy50vXa0h+7du1SVU4r4Wo3nHLV1I3kuCIha9euXaxYsSIiSUCysrJYvHjxmO1r1qxh9erVqttpb29nzZo1qt0YLBYLa9asUW053rVrF2effbZqS/CuXbsoLCzU5FaRmJjI2Wefrbp8qJDTby9atIg1a9awZs2aqCnHsvxoKMe7du0iPz9/0rhV7Nq1i2XLlrm+R7KPu3btYnBwEJjcbhXBXE+11onWfS/UnAxz1dvbS29vb9TkA1xyySUsXbqUxx57bNxtqbq7CYKwVhCESkEQjgmCcJuX/YIgCPc7938iCMLiQHUFQfitIAiHneWfEwQhfdyj0dGZAGhZkAehjVYhf1e7WC6YaBUyWqNVqFF2tUSr8DaGSDJRF+SpdasItcuDtxCGE1U5BvdzMtJ9lOXpC/J0dNRjsVjIz893/f3hD38YU+aOO+7gD3/4w7jfwAS8GwqCYAQeAM4DGoC9giCUi6L4maLYl4A5zr/lwF+A5QHqvgbcLoqiTRCEu4HbgVvHNRodnSgj39iilQQkmHaDTQISSDkOd7QKJdEK5SYTbYVYKV+L5TiUr/C9hTCcyMqxw+EgISGB/v7+qESriImJcfsN6cqxjo5/1FyvlixZEpJY4Wosx2cCx0RRrBZFcQT4J3CRR5mLgL+LEu8B6YIgTPVXVxTFClEU5Uj17wGRdRjU0QkDWpXj8cqKlHIcChlaVjNrVY619idUeFNkoq0oT6RQbhN1QZ7cJ9nKHg3LsbfFi9Hoi86JxW9/+1sEQeD++++PdlcmNWqU4+mA0su7wblNTRk1dQGuAV7xJlwQhGsFQdgnCMI+Pa2mzkTHW/zSQIzHrcKTieZWoSTcbhWRVkqV8j0XB0YTLdEqIuFWMREXmMl9kpO3RLqPvmJCR6MvOicWt9xyCwA/+MEPotyTyY0aU463K73nFdVXmYB1BUHYBNiA7d6Ei6L4MPAwwNKlSyP+SH3OOefwrW99C4BnnnkmYPm1a9eGpR/hajecctXUjeS4IiFr5cqV/M///I/qUG7jUaSOHz/udQHEzp07NcV5TEpKYufOndx9990+y3gmF9m5c6dq5fjcc8/l9ttv5/rrr/dbTpaxdu1atm7dSnp6uqr2QUqb/Omnn6ouH0o+++wzBEHgwIEDANx6a3S8w+QQRmrjnYbSqrt27Vruu+++MQtEJ6pbxcqVK/n5z39OamoqEFlr7dq1a/nVr37lUzmeiPPljWCup1rrROu+F2oiNVfKzHAXX3yxZpmB8GeESEtLC7m8UKL1d6VGOW4AlAH08oEmlWVi/dUVBOEq4AJgjThBrwg5OTm8++67AGPCZnlDTZlgCFe74ZQbzfmKlqzU1FRaWlo0WY6Dpa+vz7XqXYlW+YIg0NLSosmNoaWlRZViL4oiOTk5tLS0qHaryMvLo6uri6ysLNX9sVgsUVkpLcc5NplMtLS0RFy+Ell+NOIc5+Xl0dzcPGkW5KWkpNDS0uJ6iIxkH/Py8hgYGPDqnx3pvoyHYK6nWutE674XaiI1V8prYKjPo/j4eDo7O8nKyvJ67Q82M14kEEWRzs5O1ddGUKcc7wXmCIJQBDQCXwOu8ChTDtwoCMI/kRbkmUVRbBYEod1XXUEQ1iItwFstiqJFdY8jTF1dHRdeeCEA1dXVFBcX+y1fXV0NELCcVsLVbjjlqqkbyXFFQlZNTQ3FxcWafI6DvYilpKSQmJjotk0QBIqLi5k6darfusob8fDwMMXFxardKux2O8XFxaotx1VVVRQXF6t2q6iuriY7O1uTW0V8fDzTpk1T1Z9QIcvPysoiNjbWdV5Fy61Clh8Nn+Pq6mpyc3MnTRIQ+Xcqu1VEso/V1dXExMR49c+OdF/GQzDXU611onXfCzWRmqvu7m7X91C75+Tn59PQ0IAv91abTVpCNhEy5XkjPj5eUyz8gKNwRpO4EXgVMAJ/E0XxoCAI33Xufwh4GVgHHAMswNX+6jqb/jMQB7zmvJm8J4rid1X3PELs27ePM844A4Ddu3cHPFF3794NhP7HHK52wylXTd1IjisSsj755BNWrVoVkSQgM2bM8Fp/1apVrpu+GoaGhli1apXqaBUOh4NVq1apjlaxZ8+egO0ry+/evZsFCxa4XegDkZOTQ3JysuryoWTOnDkYjUaXpTtayvGqVauA6CjHu3fvZtmyZZPG51j+ndbU1ACR9fPdvXs3GRkZk97nOJjrqdY60brvhZpIzZUy+UWoH7JMJhNFRUU+92/btg2AjRs3hlRutFCl4oui+DKSAqzc9pDiswjcoLauc/tsTT3V0ZkEyDe2SEWr8KWgTqRoFVoW/CnraA3lFg0mSrQKpcxoxTn2tchsIlpC5d9ptKJV+Ap7F42+6Jw4KB+sJstD1kRFz5CnoxNCggnlNtmiVcjltSrHJ0u0imgTjTjH3pJayDImorIXbeXYV2SPaPRF58RB+XvWz6PxoSvHOjohRGsot4mQBERGrVuFVhlqlePJnARESbT7EQ23Cl/n/URXjqPhcyzL15VjnVCjW45Dh64cB0C/UOloIZJuFRAaRUxtxjvP8mrLBuNWAeFNShIqvFnRo60cRyPOsa83JhN1QV60Lcfe3Com24I8nYmHrhyHjom5rHACsXr1ajZs2ABARUVFwPIXXHBBWPoRrnbDKVdN3UiOKxKyZs6cyebNm/nud9WvLQ32Zrhv3z4KCwvdtgmCwAsvvMDpp5/ut67SSmW1Wnn55THLAnz21WazqSovy1ixYgWbNm3ic5/7nKr2L7jgAu666y7OPfdcVe2LokhlZaVrtXSkkOXv27ePvLw83nnnHQD+53/+J6L9kHnhhRcAuOOOO1SVD6XievbZZ3PbbbexfPlyt+0TdUHe9OnTueuuu/jqV78KRFaRuOCCC/jb3/42Jo73ZFuQF8z1VGudaN33Qk2k5kpexBeNNzYnyrGS0ZXjAKSlpfHRRx8BkJ2dHbC8mjLBEK52wyk3mvMVLVkGg4HOzk7VluPxWBnNZjN2u33M9s7OTrdVy4Gw2WyYzWa/ZTyjVfT09KhuPzk5mc7OTtU+xNnZ2XR0dGiyHPf390fNctzX10dGRgadnZ1A9CzHWuWHUnFNTEyks7Nz0rhVCIJAZ2dnVNwqsrOz6ezsJDc3d0yfIt2X8RDM9VRrnWjd90JNpOcqMTEx4g9ZJ8qxktGV4wDU1NRw2WWXAVBZWcm8efP8lq+srAQIWE4r4Wo3nHLV1I3kuCIhq7Ozk7lz50bErSI3N3dMViJBEJg7d+6YG68nngrU3LlzVcsVBIE5c+aoLl9bW8vcuXNVK7uVlZXMnDlTk49yRkZGxIPQy/KnTp1KZmampjkMB7L8jIwMVeVDHed47ty5k0Y5PnDgAHPnznUpEJHsY2VlJTk5OZM+WkUw11OtdaJ13ws1kZqrjo4OQFKOI30enSjHSkZXjgPwySefcMoppwBSvNZAB37Pnj1A6E+QcLUbTrlq6kZyXJGQ1dHRwcqVKzVlqAv2IjZ//nxX+lslK1euVJ16WRRFYmNjOfPMM1WXj4mJGfP63B+HDh1i5cqVqqNV7Nmzh8WLF6v2URZFUZUyHS7mzZtHQkICK1euBKIXyk2WrzbGdSgV188++4yVK1dOGp9jk8nEypUrXbGpI9nHPXv2MH/+fEZGRty2Tzaf42Cup1rrROu+F2oiNVfy26NoWI5PlGMloy/I09EJIVoX5E2EaBVqIj14RpLQgtoFeZMxWoVywaFMtBfkqbWgh1Jx9RetYiL60MrHSE4cE+k++otWMRHnS2dyIJ870bAcn2joyrGOTgjxFe81XLI8FTEt/qb+2tFS3x9K5VGrZVdr6LdI4ytCRbSVYy3ngNVqRRAE7r77br785S+TkZHBY4895lpcqBZfynF7ezu9vb3ExsZyyimncM455/C5z30OQRCYPn06q1atoqCggPnz5/OLX/yCZcuWIQiC6+/GG29k+vTprFixAkEQmDVrFqeffjq/+93vePLJJ3n00UdJSkriV7/6lab+ev5OZ82a5ZJ56NAhTW0Fg78kIFdeeSVxcXGcf/75XHLJJTzyyCN885vf5Cc/+QnTp0939TUmJoY///nPfOMb3+Caa64hOTmZdevWIQgCubm5xMfHIwgCZ5xxBiaTyW1eTz31VG644QaSkpL40Y9+hMFg4Prrr6e3t1fzWB5++GEEQeAnP/lJSOZGJ3iUyrH+kDU+dLeKAOhPXzpaCCaU23jOsfFajrUm0PBmKQ3Ut3AlAfHsU7SV0smGcgHNbbfd5vq8ceNGDAYDZrNZdUpuXw+Fra2tAFit1jFKZ1NTE01NTa7vd95555h2H3jgAVdZkHybAX7605+6lbvjjjs0RQmRf6fTp08fs++rX/0qn3zyieq2gsFbEhDZxUNWUOXoSM8995zXNux2OzfddJPbtldeeQWAtrY217b9+/ePqXvgwAEOHDgAwL333gvAX/7yFwoLC7nllltUj8NqtXLdddcB8Pvf/57f/e53AevYbDY2bdrEXXfdxbRp0/jKV77iehg4//zzvdb573//y6WXXsq0adP473//C8B3v/td7r33XtWhCycCv/3tb2ltbeXWW28lJycnYHm73c5zzz3HlClTOPvsswOW1y3HoUNXjnV0QohWy/FEcasIRLAWaiVa3Cpg8sQ59jwOk0VJ/8EPfsDSpUvZvXs3X/ziF2loaKChoYGWlhbuueeeMT6x/vBlOX7uuee4++67SU1NJSMjw2XNfP755/n85z9Peno6ZrMZk8nEggULqKqq4uOPP6a2tpaioiLOP/98jhw5QmpqKjU1NUyZMgWTycSiRYtITU1leHiYM844Q/PY5XP+ggsu4LXXXuPAgQP8z//8D/39/fT392tuTyve3CqKiop455136OzspLKykhkzZmAymSguLqahoYHExEQ+++wzjEYj3d3dGI1Gzj33XJqamjAYDBw+fJiCggI+/vhjcnNzGR4e5tChQ5xzzjm0t7e7oui88847fP3rX2fGjBl8+umnlJSUsHfvXm6//XYsFoumcVitVtdn2ec9EHV1ddx1112A9NDz4IMPAvDSSy+5FnV5ztXZZ5+NzWajoaHBtf2hhx7izDPP5Oqrr9bU52jhcDhcDx59fX1s2bIlYJ2Ghga+/e1vA9J6FvkByp8Mo9FIbGwsg4OD4+/0yYx8cff3B6wFKoFjwG1e9gvA/c79nwCLA9UFLgcOAg5gqZp+LFmyRIw0hw4dEufMmSPOmTNH7OnpCVi+p6dHVTmthKvdcMpVUzeS44qErF/+8pdiamqqaLVaVZX/3Oc+J37hC18ISlZBQYH4/e9/323bVVddJaamporr16/3W/eNN94QAfHtt98Wr7nmGnHBggV+y5vNZhEQf//734vf//73xRkzZgTs34IFC8TLL79c3LVrl5iamiru3LnTb/mvfe1r4ty5c8WOjg4xNTVV/NWvfuW3/O9+9zsREPv6+sTFixeLGzZsCNinULJ69Wpx9erV4qJFi8QrrrhCTE1NFVNTU8X6+vqI9kMURfHAgQMu+ePlz3/+swiIbW1tquvs2LFDTE1NFT/44INxy9fKTTfdJKanp2uqc+utt4rZ2dljtn/jG98QCwsLQ9U1r3R2dqo6vyONIAjiz3/+c9Xle3p6xLfeeksEREC8+uqrVdX59re/LQLiihUrxDvvvFN89tlnxfLycvHw4cNeyx85ckQExJKSEvH+++8XzznnHHH16tUiIN5///2axhgtenp6xMcee8w1V1dccYWqOjfeeKOrTkNDQ8DyP/7xj8WkpCTxvPPOE1esWBGq7qsiWjrKeAH2iV70zYCWY0EQjMADwHlAA7BXEIRyURQ/UxT7EjDH+bcc+AuwPEDdA8AlQODHpyiSnJzM0aNHAcaEzfKGmjLBEK52wyk3mvMVLVlWq5W+vj7Ni8mCwWw2e7VS9vb2qm5TFEVGRkYYHh5WXd5mszEwMKC6nyaTid7eXtVuFUlJSfT29mpyq+jv74+aj50sW34dHi3LcTD+ot6QoyZomU9RFOnt7Y2Ir70nRqNR87EfHh72ahkPpi2txMXFufywJxJax56WluZmOVZTNy0tje7ubhYuXMi7776rqnxLSwsAt9xyCxs2bOCmm26iu7ubzMzMSeNXm5aW5ubCo3aulPHkA9VJS0tjcHDQ9XYm0nMTLR0lXKhZkHcmcEwUxWpRFEeAfwIXeZS5CPi7UxF/D0gXBGGqv7qiKB4SRXHsO5QJRlVVFVdccQVXXHGFy0fLH0pfrlASrnbDKVdN3UiOKxKy7HY7p59+elAL47Qye/Zsr/52CxcuVB3KDaTQX8XFxX7LKPsZGxurOqZva2srr732GgsXLlTtVnHgwAEWLlyo6QEjPz8/KhdnURQpLCwkNTWVhQsXsnDhwqiFcpPljxdZOfaWYMYXnZ2dLFy4MCrKscFg0NRXkOZLDtE53ra0Ip/f0Zgrf2gd+4EDB6ivr3d9V1P3wIEDxMbGeg1B6av84cOHAdzqBHOORpMDBw64+dernSt5nBDYiHLgwAEEQSAhIQGDwUBPTw+1tbXBd1ojBw4c4NVXX2XNmjXs2LEjYnLDhRrTzHSgXvG9Ack6HKjMdJV1/SIIwrXAtQAzZszQUjUkHD58mNmzZwNSmthFixb5Lb9v3z6AgOW0Eq52wylXTd1IjisSsgwGA0uWLAlb+0pOP/10ryvely1bFjARhFKBS09P15TAIiEhQdUcpqamsnv3boqLi1m2bJlqZXf//v2qyivHMGfOHE0PBKFAjhM8b9480tLSWLZs2Zh+RRJZ/niR512L5amnp4dly5ZNGstxfHw8p512Wkja0srHH38ctbnyh9ax79u3z7Xwz2AwqKq7b98+srOz6erqUi2ju7sbcFeO5XN0sijH+/btczPMqOn3vn373K7jgeZ33759JCUlER8fT1paGpWVlZx//vmuh4tws2/fPt5++23eeOMN3njjDS6//PJJs/7CG2osx95G5/kI46uMmrp+EUXxYVEUl4qiuFTN6k4dnWgiiqLb077aOsESjWgVatv/17/+xe7du11xd7VEq4DAC/iC6VO4mIwL8nwRjFVOPgaTxXLscDi8/k4jYTkOJqJNJAhm7DabDZBeqatVrO12u2rLsVwevFuOJ4tbBeB6eM/KytI0VzJq6jgcDhISEtiyZQsXXnghZrM5qL4GS2JiouvzZHlw8YWau3gDUKD4ng80qSyjpu6EZjyKi87Jh8Ph0KQcTdZoFWrIzc3lc5/7nEthUutWIfdnsiQB8WSyK8fBWI6jqfAFY+31db5EwnIczQcJfwQzdlkBSk9PV60M2Ww2TcqxrIBPZssxjP5GsrOzNc2VjJrrtMPhcFmOp0+fHvH5UT5wTqZj4w01yvFeYI4gCEWCIMQCXwPKPcqUA98UJM4CzKIoNqusq6NzwhCM5TgY5AutrxBrWjPehTqjnmd5UK/sqi0/UZKAeM7HZFeOg7HK+QrlFgnUvtJX4s9yHG7lOJpz5Y9gxm632zGZTJqSToTCchzMA1y0sdvtGAwGkpKSNM1VSkoKoM1yDNIcRVpBVS7QPOGVY1EUbcCNwKvAIWCHKIoHBUH4riAI33UWexmoRgrX9ghwvb+6AIIgXCwIQgOwAnhJEIRXQzoyHZ0o4Oum649gFLtAF55wu1VoQYtyLPcHtLlVRMty7I2J0o9gCcYqF223CofDoenc9PWGR3er0O5WkZKSoqmuVuVYtp7KSqLcV7mtyYKs6GpRWm02m2uhsZrz2263uxZpR0M5Vlq6J9Ox8Yaqu7goii+LojhXFMVZoihudm57SBTFh5yfRVEUb3DuP1UUxX3+6jq3PyeKYr4oinGiKOaKoug9NU6U+fznP89f//pX/vrXv7J+/fqA5devX6+qnFbC1W445aqpG8lxRUJWVVWVK4OTGoJVpGw2Gzt27PB6g92xYwd9fX2q2zp06BAff/yx3zLKfra2tvLmm2+qbv/f//43O3bsUO1WsXr1anbs2KHJreLFF1+MSPIGT0RRpKKigu7ubnbs2MGOHTuiphzL8sdLMJbj4eFhnnnmmYi8NfFEPk+0KMeHDh3ymgUvEm4Vp556Kjt27JhwlmOtY1+/fj1NTU2kpqaqrvulL32JHTt2qFaO169fj8ViIT4+3u1aN9mU4/Xr11NZWYkgCKofJC666CKefPJJl69yoPldv3497733XtSU40svvZQnnnjCpcxPlmPjCz1DXgDi4uJobGwE3J3NfaGmTDCEq91wyo3mfEVL1uDgoGblKFjLscViGaNwCoKAxWIJqKQoXQKGh4dV3xTlOMfK12eBGBwcxGKxqLYcm0wmVeWVYxgYGIi4YibLHxwcRBRFV3axaIVy05rdzBfBKB4jIyNRuxkq+6v2HLBYLFGzHMvyJ5pyrHXsiYmJ9PT0aLIcW61WLBaLmxU4kIze3l6v5SPxIBMqEhMTefrppwH1/Zav8Wotx4mJiZjNZldYzkgrxyMjI1gsFmbNmoXZbNaV4xOdY8eOsXHjRkAKMVVSUuK3vJzHPlA5rYSr3XDKVVM3kuOKhKz09HSSkpLC1r6M3W6npKTE60W2pKTEa/xjX+Tk5GhSLJOSklzhDdVQWFhIcnKyajeJI0eOUFJSoro8wIIFC6KibIiiyNy5c0lKSnKdV9GyHIfqvJYfSpTh+mbNmsXy5ctJSkriN7/5DZmZmWGTrxU5nJhsWVyxYgV79uzh9NNPZ82aNfz2t78dc35nZ2d7/Y3s3LnTpTgnJSV5TXZz6qmn8umnn6rq26uvvkppaanbtvr6ekpKSiacWwXAww8/zMMPP+z6vmjRIq+x4VesWOFKT5ySkoLVauXDDz/0ee7fdttt3HXXXXzyySeUlJSMsRy3tbVRVVVFQ0MDg4ODFBUVceDAAQoLCwG8WprtdjubN2/GYrGwevVqDAYD5eXlXHjhhSxcuJCqqioyMzPp6uriyJEjpKSkkJmZiclkwmQyMTg4SH19PYsXL6a4uJhwRsPav38/X/va11zpr/v7+7FYLH4NNh999BElJSWuaD8vv/wyCxYs8CsjPz8/apbjffv2UVJSQlxcHFVVVbpyfKJTVVXliq+sK8ehr3uiKcdTpkyJSLQKm81GSUmJm4+X3J6aG69Sbl5enmpLM0g3qlmzZqnu66xZs8jPz1dtCT5+/DglJSWaFuQtXLgw4sqGLH/+/PkkJCRMCOU4FNbzU089dcy2qqoqhoeHaWho4KKLLuLLX/6y235BEDTFyg4lZ5xxhtv3PXv2AFI84Y8//pjvf//7zJw5063M1KlTvZ4vs2fP5uDBgwA+s0CqVYxBUjY9leO2tjaXEjGRuOiii9wUY8Bn0qQ9e/a4jEYHDhxg3bp1PP744z7b/s1vfsNPf/pTjh075lU5/vnPf84jjzwypt7GjRvJysry64Zx7733cu+997q+P/rooz7L+sJgMFBTU0NBQUHgwkGwf/9+cnJyMJvNOBwOXn31Vc4991y/WQIrKyspKSnhxRdfBOAnP/kJxcXFXHzxxT5lzJo1y3XdjLRyLBs12tvbgcnvVhF5B7FJhvJVhsPhoLGx0etfS0vLCR32ra2tzefYlX/yD+NkJZgFecPDw6rmVv5T8wpbrYLW3t7O8PCw6vI9PT2qU03LaFmQZ7VaGRoaAtQvyGtqaorKgryhoSH+85//jHExieaCvFAox3PnznUtclT+lZdLgYa8udRo8XEPNVdffbXX/j722GOA9/76iirz/PPPe20rmL/TTz/dq+yJGq1iy5YtmsYnvz1KTk7ml7/8JUePHvVa7oEHHgCk4+At8gTANddcw3XXXUdBQQGxsbFcddVVrn2+Qr/dfPPNrs+nnnqqKwnO6aefzt///ndKS0u55ZZbXA8nRqORxYsXs3r1ai666CLOPPNMAD73uc/hcDhcbyDChd1uJzk5mQceeICzzz7bLWOeN2TDh3KcgerIodxgVDmOVBIQz4WT8kPmZEW3HAegtrbWdRH797//zbe+9S2fZR966KEJd8ELBR0dHeTm5qou/9JLL7Fu3bow9mjiojXOcVxcHG+++Sb5+fmq63z+8593WWk8Zck3XjmrlD+5AF/72tfYuHFjQIXXaDRiMBj49a9/7bIYaSWQchwXF0d9fb3LMtfc3BywPEhW440bN6rOuhUq/vOf/7g+K29aEyUZSaiRX+96U/jkVfgTCX/9DeYhNhj5/pTjiehWEQyB/IeVx8FbzGKAs846i7POOsttW0JCAna73Wd0C0+LsSff+MY3VPX/lVde4d///remdRTBIEf2mDVrFvPmzeP48eN+y8sPEueffz7XX389mZmZAfuoDOUmu2wsWLCAjo4OsrKyQjAK38h9k1NWn3feeS7XkMmIrhwHoLW11S1t9YwZM/j5z38+pty1115LY2MjxcXF2Gw2Ojs7xy07MzNzQoSF6uvrw2g08uCDD/rtT3d3N7feeqtrAePJiNY4x/feey+XXHKJ6vKPPvoojY2NrpuM5/H41re+xaOPPsrIyIjfdpYsWcI///lPent7/b7ak4mLi+OVV16htrZWVXklakOz/eIXv2D58uV8+umn9PX1BVTwr7jiCuLj42ltbeXw4cNhv7l58tprr3HeeecBkmuFbKGZ7JZjX/hTNiMV31sLgfob7uPkSzmeqElAtCLPnxbl2Jfl2Fc9m82mOWmIVvydJ6FEGbPY17mhRPkgoaaPsqVethxfe+21/Pa3v6Wrq4v29vawK8dyf3/zm9+wevVqABobG3Xl+GRhzpw5fOc73xmz/Xvf+x52u52WlhYqKyu9ltHKpk2b+H//7/+Nu53xMjQ0xIwZM7j22mv9lmtububWW2+d9L5G40Gr5Xj+/PnMnz9fdfndu3fz7rvvuubYU1ZeXp7X7Z4YjUa++tWvAqhWduXXk8Eqx4EsiwUFBXznO9/hF7/4BX19fQGVrdTUVDZu3EhNTQ2//OUvNfUpFJx77rmIosi2bdsAJoRyHAnLsaefO2g/7yNBoP6GW5mPiYnxKRsmv3Is/67VKseyogvqleOBgQHNcZG1IlvwI6kcx8bGBpSnfJBQoxzL55WsHGdmZvLII49w6aWXBjSWhAL52C5btsy1PisScsOFrhwHYPv27a6TbWhoyKeVz2g0YrPZaG9v5+mnn+b+++8fl9w777yTmpoa1/crr7wSu93uc5GIWgRB0BTS7Morr+Tzn/+8KzyMPzyTB1x55ZWq2gfph6XVl1Ut8piV/bHb7S7f1lAQFxdHTEwMr7zyCueee27I2vVEPs9sNhvbt28fs4jF4XCwfft2ioqKVLe5fft2ALZu3RqW8s8//zxms5nf//73qsoPDQ2xfft27rzzTlXl7XY727dvH7PoKlLI55X88PinP/0p4n0QRZHt27eHdVGcbPm/6qqreO+990hPT+fXv/41ICky3hbyRRP5erRkyRKuvPJKPvroIxobGzGbzZhMpqDdg9RSXV1NY2Mjv/zlL4mLi6OlpYVzzz2X//3f/wVQ/XuYqMTExLB9+3Z+8IMfqCo/d+5cl5LnbfGdJ6Io8o9//AOAH/3oR8F3NAByn3p7exkYGKC7uxtBEFzxhUdGRujq6mJgYIDk5GTXvqamJjIzM0lJSaGvr4++vj7S0tIQBIEpU6a4yfjKV77Ctdde6zJ2mUwmenp62L9/P4WFhS5ZSgwGA9u3b+eBBx5w9fHYsWNYrVbXdyWrVq3ie9/7Htdcc41rm6z4R0JJ7e/v56mnnmLr1q0RlRsudOU4AFar1e1pzVe4l5iYGJfleMqUKdx0003jkvvAAw+4WR1MJhMrV65k3759fmqp4+677+aWW25RVdZkMnHs2DEuuuiigGXlm6fcb28/YG/t22w2Zs+e7fJVCge/+c1vuPXWW139W7hwIUeOHAlZ+0VFRVRXV2OxWFSNO1jk88xut3u9SDocDs0WkHCXHx4exmq1qvZJlcemtnwwYw4lnladaFhQ5etUOP1+5XirAH/5y1/GyP/www/DJjsYMjIyXJ/lBzoZq9XKM888MyY6QyiR3ctkZRjgj3/8o+vzZLccDwwMYLVaA1qOleOUfyNqFtsq/Ym9WeBDheyj6ysKRDB4Ls6Xr4HyXMky5UgrO3fu5Pzz3fOg9fX1uXyI5WvK1q1b+fvf/+51PuTrptINVFZS+/v7sdvtYb0+dHd3u1nGAVe4v8mIrhwHYNmyZa4T+KOPPvLptyOvDBUEwbVqdjzExMS43fB37dqFIAhccsklYxYuaOH//b//x9GjR1WXf+edd5g5c6YqS6Sn5Xjv3r0Afudj7969NDQ0UFtby1VXXcXChQtV900tmzdv5ujRo67+1NXVceTIEW688Ua3C0mw7Nq1i1dffRW73c78+fPD+gpQaTletmwZvb29bvvtdjvLli3TtIBS6/mqtfxpp53GyMiI6gtzTEwMy5YtU/3a2+FwsGzZsjHWmkjheZ5HY2HayMgIy5YtC1soKpCU47/85S988MEHLF26lKSkJK6//nqWL1+O2WwOm9xgWbFiBT/5yU/o6elh4cKFVFdX09XVRW1tLcPDw2FXTg8fPsyWLVtYvnw5JpOJ7u5uTj/9dK6//npg8ivHw8PDLFu2LKBy/JWvfIX777+fO++8U9Mbrccff9ylIIfTAnnaaafx8MMP09PTA+AyHN1zzz0AvP3227z00ktuddatW8fLL78MwK9//Wtuv/12vzI++OADli1bRnJyMiC5YW7e7EoYzNGjR8cox6+99hqLFy92KcY33ngjf/7zn30a6I4cOcL/b+/sY5u6rgD+O3ZioC6jBNKJhpW0auoUAwJGSRY+lI5BKZtgf9CoLYyGQWk0GjGmstAWIab+A1RFtBkKmgbVEDAKG9VQO8RQS4Um8dEyCOMzpQyxlgY0jZK0FLKEuz98n2s7dmInduI45yddvffuu/d9Hfu9c+8995xHH300zM2mo4Q/9thj7Ny5kyeffLLN6+wMJ0+eDL5/nPPOnz8ft9sd9+TIdEKV43bw+/1BO06/3x91+AO+tS8bMGBAUiKxRdqrnThxAr/fz4IFC5g4cWKHj7thw4aEXjS1tbX4/f64zCqc3gBHOXZcubSlTJ0+fTrolWDFihUJBZeIl5qaGpqamoLXs2XLFoYNG8b69euTosg4fiubmpooKChI6UfPaYS1tLTg9/tbudC6c+cOfr8/od9gog2SRMv7fL6EbDyzsrLw+/0J9TQnes/JxPldTZo0iaysrIQCsCSLpqYm/H5/ShtmABUVFWHbc+fOBQIfwXTD5XLx2muvtcq/du0aVVVVCQWZ6Qg+n49169a1ynf+P+nm3SNRXC4Xfr+/XeU4KyuLyspKKisrE/qdPP3009TV1XHp0qW4I+p1BJfLFTZHaNmyZWH7I7ejsXz5cgCWLl3Kpk2bWu2/ePFi2LPKy8sLRtX0er1Ro1uWlJSENTqrq6s5fvx4zPfL5cuX8fv9YfuLi4uprq6msbExLKhPKhg+fHhw/b777uOtt97iueee67Eu3dJrenEPwGn5ReIoLU1NTUlx0eOYGzg0NDQgIowdO7ZTx/V4PAkpx86wSCI2x4kOgTU0NDBo0KCEAkskQug937x5kwMHDlBRUZG0j1OofVWqJ/qEmlVAbFduqRzaHzduXKvAC22RiJ/jUBLpOU4HRo4c2WYEq1Ti2Ounm8eIdKQr/iPx0N3n7yzOOyjWNzGZ50ilcpxMjh49SmNjIyISlo4dOwa0NklzFNmqqqpWdaKNxtTV1QVHkWOdI7RednY2CxYsoLm5mdmzZwfLFhYWMmfOHPr06RMMmtNZvF5v2Mh6eXk5zc3NrFmzhn379iXlHF1JXG9SEZkuIudF5IKILI+yX0TkTbv/pIiMba+uiOSIyH4R+cQuB0YeNx2J9SLIysri9u3bNDc3J8XmNLLnuKGhAa/X2+nesXhmyYbiTFqLZzgssucYAsp1fn5+MGRnZDp48CD19fUUFRWl7GMRes9XrlzB4/G06a+6I8cHgq3/VH70Qs0qop3L6bVOZe+11+tNqIcy1Cl9PDj/n1Cb0bZw7rU7emzTBafx19MVrq7AeVbakOgcXaG4doUCnkwcU4lY35dI0y+Xy8Xq1atblYtl7udMZCwqKgrmVVZWUlBQENyO9Pf+zTffsHLlSs6cORPMO3/+PNu3b6epqYmSkhJ27drFe++9x9SpU/H5fDz//PNMmTIFEWHNmjUsXryYmpoaZsyYwYsvvhj12r7++uugaUok06dPZ9WqVbzxxhvU1NQwbdo0pk2bFoxam460O64kIm5gAzAV+Az4SET2GGPOhBR7AiiwqQioAYraqbsceN8Ys9oqzcuBquTdWnJwbGccvF5v1HIul4vNmzdTXl6eNOX4yJEjTJo0iZaWFnw+H4MHD+70cbOzszl+/DhLly4N5rndbioqKqIqwLdu3cLtdsflI9HtdiMirFq1ildffZU5c+ZgjOH69essW7Ys6ofbCZ7QGTvq9nDu+eGHH6a+vp6ysrKYdlsdPT7Ayy+/DKT2o+vxeGhsbGTixIk888wzrZ6pz+ejsLAwIZ+Wo0aNSqliOXr0aBoaGuIexr7//vvxeDxxeTuBgHvFRx55hJycnM5cZo+mKxpFmYLTSNNn1Tm057g1paWlwZGy0DDWa9eu5ezZs1HnRVRVVQUni4cSzQRl1qxZMSPxrlixgs8//7yV/jFw4ECam5uDI44ulwsRweVyMXnyZA4dOkRZWVlYndDJ6o7JiMPevXt5/fXXycnJCVPEy8vLW7lxbWlpYd68eWzbti2qu80xY8bQt29fbt26xf79+1Pq6SlR4vlajQcuGGMuAojIDmAWEKoczwK2mIDUDovIPSIyBMhvo+4soNTW/wPwIWmoHD/00ENhwxSxesxmzpzJxo0bgeREPpo3bx47duwAAkM1Pp8vKQpMSUkJW7duZfPmzUBgyLuxsTGmW6Hy8nK8Xm9cPVIiwqZNmzh37hwtLS3BQCjr16+PaWu2ePFibt68yYQJEzp4R+1TUlLCli1bqK+vB2DhwoVJPf6IESPIzc1l9+7dlJWVpfRjsXDhQlwuF3fu3OGuu+4K8yDgkMhkPIi/h7ajeDyehBp2IsKQIUMSamR012S8dKG0tJTDhw9323MYOXJkj+m5z8vLo7CwsNsaU+PHj+/Rs/gdhgwZwo0bNxKag+B2u6O+s2KRm5vL1atXOzXPJh3oiJKflZWVUPlhw4bR0tLS6lsrIrjd7qgjd7t27WLdunXk5+fTv39/lixZQkNDAxMmTKC2tpavvvqKRYsWUVdXR3FxcVgvd7SIpJGdMi6Xi+rqakaNGsXJkyfJzc2lX79+1NTUBHuZndHpurq6tFKOJVYrJFhAZDYw3Riz0G7/DCgyxrwQUuZdYLUx5u92+30Cim5+rLoi8qUx5p6QY1w3xrT6SovIIsCJPuEDznfwXjvDYOA/3XBepWtROfcOVM69A5Vz70Dl3DtIlZyHGWNaDSXH03McrcswUqOOVSaeum1ijPkdkDpnlHEgIh8bY8Z15zUoqUfl3DtQOfcOVM69A5Vz76Cr5RzPuOVnQKjzzKHAlTjLtFX3qjW9wC6vxX/ZiqIoiqIoipJ84lGOPwIKROQBEfEATwF7IsrsAeZZrxXFwA1jzBft1N0DPGvXnwX+0sl7URRFURRFUZRO0a5ZhTGmWUReAPYBbmCzMea0iFTY/RuBvwIzgAvATWB+W3XtoVcDO0VkAXAZSF3ols7TrWYdSpehcu4dqJx7Byrn3oHKuXfQpXJud0KeoiiKoiiKovQW1Au6oiiKoiiKolhUOVYURVEURVEUiyrHbdBe2GwlPRCRzSJyTUROheTFDE8uIi9ZmZ4XkcdD8r8vIv+0+94UG/lERPqIyNs2/4iI5IfUedae4xMRcSaYKilARL4nIgdE5KyInBaRJTZfZZ1BiEhfETkqIrVWzr+x+SrnDENE3CJy3MZKUBlnKCJyycrohIh8bPPSW9bGGE1REoEJhJ8CDwIeoBYY3t3XpSmqrCYDY4FTIXlrgeV2fTmwxq4Pt7LsAzxgZey2+44CPyDgn3sv8ITN/wWw0a4/Bbxt13OAi3Y50K4P7O7nkakJGAKMtev9gTorT5V1BiUrk7vtejZwBChWOWdeAn4FbAfetdsq4wxMwCVgcEReWstae45jEwybbYxpApzQ10qaYYw5CETGspxFICw5dvnTkPwdxpjbxph/EfCwMl4Cvra/Y4w5ZAL/qi0RdZxj/QmYYlusjwP7jTH/NcZcB/YD05N9f0oAY8wXxph/2PVG4CyQh8o6ozABvrKb2TYZVM4ZhYgMBX4M/D4kW2Xce0hrWatyHJs84N8h25/ZPKVn8F0T8LWNXd5r82PJNc+uR+aH1THGNAM3gEFtHEtJMXbYbAyBXkWVdYZhh9tPEAgOtd8Yo3LOPNYDvwbuhOSpjDMTA/xNRI6JyCKbl9ayjid8dG+l06GvlbSkI6HOUxYeXUkcEbkb+DPwS2NMgzU7i1o0Sp7KugdgjGkBRovIPcA7IjKijeIq5x6GiPwEuGaMOSYipfFUiZKnMu45TDDGXBGRe4H9InKujbJpIWvtOY5NPGGzlfQlVnjytkKdD42SH1ZHRLKAAQTMOPQ30sWISDYBxXibMWa3zVZZZyjGmC+BDwkMhaqcM4cJwEwRuUTAZPGHIrIVlXFGYoy5YpfXgHcImK2mtaxVOY5NPGGzlfQlVnjyPcBTdnbrA0ABcNQO6zSKSLG1VZoXUcc51mzgA2vztA+YJiID7UzbaTZPSQFWLpuAs8aYdSG7VNYZhIjk2h5jRKQf8CPgHCrnjMEY85IxZqgxJp/At/UDY8xcVMYZh4h4RaS/s07geZ8i3WWd7FmJmZQIhMSuIzBb8pXuvh5NMeX0R+AL4H8EWooLCNgbvQ98Ypc5IeVfsTI9j53tavPH2T/tp8Bv+TaCZF9gF4GJAUeBB0Pq/NzmXwDmd/ezyOQETCQwJHYSOGHTDJV1ZiVgFHDcyvkUsNLmq5wzMAGlfOutQmWcYYmAx69am05jdal0l7WGj1YURVEURVEUi5pVKIqiKIqiKIpFlWNFURRFURRFsahyrCiKoiiKoigWVY4VRVEURVEUxaLKsaIoiqIoiqJYVDlWFEVRFEVRFIsqx4qiKIqiKIpi+T/XhsG3XV2ahQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Full-length\n",
    "metdf = merge_trainmetrics_files(training_df)\n",
    "plot_metrics(metdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Just the most recent 4 runs\n",
    "metdf_last4 = merge_trainmetrics_files(training_df_last4)\n",
    "plot_metrics(metdf_last4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This little function plots the learning rate in a panel below the most important statistics.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_metrics(metdf):\n",
    "    #Define x and three y series\n",
    "    x = metdf['iter_global']    #.iteration\n",
    "    y1 = metdf['fast_rcnn/fg_cls_accuracy']\n",
    "    y2 = metdf['fast_rcnn/false_negative']\n",
    "    y3 = metdf.lr\n",
    "\n",
    "    gs = gridspec.GridSpec(2,1, height_ratios=[5, 1])\n",
    "    fig = plt.figure(figsize=(10, 6)) \n",
    "    ax1 = plt.subplot(gs[0])\n",
    "    ax1.scatter(x,y1, s=10, c='b', marker=\"s\", label='fg_accuracy')\n",
    "    ax1.scatter(x,y2, s=10, c='r', marker=\"o\", label='false_negative')\n",
    "    ax1.legend(loc='center right');\n",
    "    ax1.plot(x, y1, color='tab:green')\n",
    "    ax1.plot(x,y2,color='tab:red')\n",
    "    ax1.axhline(y=0, color='gray',linestyle = 'dashed')\n",
    "    ax1.axhline(y=0.1, color='gray',linestyle = 'dashed')\n",
    "    ax1.axhline(y=0.9, color='gray',linestyle = 'dashed')\n",
    "    ax1.axhline(y=1.0, color='gray',linestyle = 'dashed')\n",
    "\n",
    "    #ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis\n",
    "    ax2 = plt.subplot(gs[1])\n",
    "    ax2.plot(x,y3, color='black',label='LR')\n",
    "    ax2.legend(loc='upper right')\n",
    "    ax2.set_ylim([0, .003])\n",
    "\n",
    "    #Create a set of vertical lines to show where each restart is\n",
    "    vlines = list(metdf[metdf['iteration']==19]['iter_global'])\n",
    "    for i in range(len(vlines)):\n",
    "        ax1.axvline(x=vlines[i], color='gray',linestyle = 'dashed')\n",
    "        ax2.axvline(x=vlines[i], color='gray',linestyle = 'dashed')\n",
    "\n",
    "    fig.tight_layout()  # otherwise the right y-label is slightly clipped\n",
    "    plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}