From 3a362b3f2c5d856953ee991c5622f009dd5a1fef Mon Sep 17 00:00:00 2001 From: Eric Bezzam Date: Wed, 10 Jan 2024 19:59:35 +0100 Subject: [PATCH] Add scripts and notebook to demonstrate results for DigiCam HQ paper. --- configs/recon_digicam_celeba.yaml | 11 + lensless/recon/model_dict.py | 63 ++++ lensless/utils/dataset.py | 12 +- notebooks/digicam_hq.ipynb | 496 ++++++++++++++++++++++++++++++ scripts/recon/digicam_celeba.py | 328 ++++++++++++++++++++ 5 files changed, 906 insertions(+), 4 deletions(-) create mode 100644 configs/recon_digicam_celeba.yaml create mode 100644 lensless/recon/model_dict.py create mode 100644 notebooks/digicam_hq.ipynb create mode 100644 scripts/recon/digicam_celeba.py diff --git a/configs/recon_digicam_celeba.yaml b/configs/recon_digicam_celeba.yaml new file mode 100644 index 00000000..040dcad5 --- /dev/null +++ b/configs/recon_digicam_celeba.yaml @@ -0,0 +1,11 @@ +# python scripts/recon/digicam_celeba.py +defaults: + - defaults_recon + - _self_ + + +model: pre4M_unrolled_admm10_post4M # see "lensless/recon/model_dict.py" (digicam/celeba_26k) +device: cuda:1 +n_trials: 1 # more if you want to get average inference time +idx: 4 # index from test set to reconstruct +save: True diff --git a/lensless/recon/model_dict.py b/lensless/recon/model_dict.py new file mode 100644 index 00000000..cb0c0e87 --- /dev/null +++ b/lensless/recon/model_dict.py @@ -0,0 +1,63 @@ +""" +First key is camera, second key is training data, third key is model name. + +Download link corresponds to output folder from training +script, which contains the model checkpoint and config file, +and other intermediate files. Models are stored on Hugging Face. +""" + +import os +from huggingface_hub import snapshot_download + + +model_dir_path = os.path.join(os.path.dirname(__file__), "..", "..", "models") + +model_dict = { + "digicam": { + "celeba_26k": { + "unrolled_admm10": "bezzam/digicam-celeba-unrolled-admm10", + "unrolled_admm10_ft_psf": "bezzam/digicam-celeba-unrolled-admm10-ft-psf", + "unet8M": "bezzam/digicam-celeba-unet8M", + "unrolled_admm10_post8M": "bezzam/digicam-celeba-unrolled-admm10-post8M", + "unrolled_admm10_ft_psf_post8M": "bezzam/digicam-celeba-unrolled-admm10-ft-psf-post8M", + "pre8M_unrolled_admm10": "bezzam/digicam-celeba-pre8M-unrolled-admm10", + "pre4M_unrolled_admm10_post4M": "bezzam/digicam-celeba-pre4M-unrolled-admm10-post4M", + "pre4M_unrolled_admm10_post4M_OLD": "bezzam/digicam-celeba-pre4M-unrolled-admm10-post4M_OLD", + "pre4M_unrolled_admm10_ft_psf_post4M": "bezzam/digicam-celeba-pre4M-unrolled-admm10-ft-psf-post4M", + # baseline benchmarks which don't have model file but use ADMM + "admm_measured_psf": "bezzam/digicam-celeba-admm-measured-psf", + "admm_simulated_psf": "bezzam/digicam-celeba-admm-simulated-psf", + } + } +} + + +def download_model(camera, dataset, model): + + """ + Download model from model_dict (if needed). + + Parameters + ---------- + dataset : str + Dataset used for training. + model_name : str + Name of model. + """ + + if camera not in model_dict: + raise ValueError(f"Camera {camera} not found in model_dict.") + + if dataset not in model_dict[camera]: + raise ValueError(f"Dataset {dataset} not found in model_dict.") + + if model not in model_dict[camera][dataset]: + raise ValueError(f"Model {model} not found in model_dict.") + + repo_id = model_dict[camera][dataset][model] + model_dir = os.path.join(model_dir_path, camera, dataset, model) + + if not os.path.exists(model_dir): + snapshot_download(repo_id=repo_id, local_dir=model_dir) + + return model_dir diff --git a/lensless/utils/dataset.py b/lensless/utils/dataset.py index 6cd20cd0..38f2fd9c 100644 --- a/lensless/utils/dataset.py +++ b/lensless/utils/dataset.py @@ -10,6 +10,7 @@ import glob import os import torch +import warnings from abc import abstractmethod from torch.utils.data import Dataset from torchvision import transforms @@ -496,10 +497,13 @@ def __init__( # create simulator simulation_config["output_dim"] = tuple(self.psf.shape[-3:-1]) - simulator = FarFieldSimulator( - is_torch=True, - **simulation_config, - ) + # -- ignore warning about no PSF + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + simulator = FarFieldSimulator( + is_torch=True, + **simulation_config, + ) super().__init__( measured_dir=data_dir, diff --git a/notebooks/digicam_hq.ipynb b/notebooks/digicam_hq.ipynb new file mode 100644 index 00000000..4a08e110 --- /dev/null +++ b/notebooks/digicam_hq.ipynb @@ -0,0 +1,496 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DigiCam: Towards High-Quality Lensless Imaging with a Low-Cost Programmable Mask\n", + "\n", + "In this notebook, we visualize results for the paper \"DigiCam: Towards High-Quality Lensless Imaging with a Low-Cost Programmable Mask\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/bezzam/anaconda3/envs/lensless/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from lensless.recon.model_dict import model_dict, download_model\n", + "\n", + "CAMERA = \"digicam\"\n", + "DATASET = \"celeba_26k\"\n", + "\n", + "models_dict = model_dict[CAMERA][DATASET]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4.1 (ADMM, measured vs. simulated PSF)\n", + "\n", + "The purpose of this experiment is to show that it is equivalent to use a measured PSF or a simulated PSF for image reconstruction with DigiCam. In both cases, reconstructions are done on a **measured** dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL PATHS:\n", + "{'Measured PSF': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/admm_measured_psf',\n", + " 'Simulated PSF': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/admm_simulated_psf'}\n", + "--------------------------------------------------------------------------------\n", + "Measured PSF\n", + "--------------------------------------------------------------------------------\n", + "100 iterations\n", + "--------------------\n", + "PSNR: 9.31\n", + "SSIM: 0.292\n", + "LPIPS_Vgg: 0.698\n", + "\n", + "\n", + "10 iterations\n", + "--------------------\n", + "PSNR: 8.7\n", + "SSIM: 0.221\n", + "LPIPS_Vgg: 0.746\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Simulated PSF\n", + "--------------------------------------------------------------------------------\n", + "100 iterations\n", + "--------------------\n", + "PSNR: 9.98\n", + "SSIM: 0.343\n", + "LPIPS_Vgg: 0.746\n", + "\n", + "\n", + "10 iterations\n", + "--------------------\n", + "PSNR: 9.3\n", + "SSIM: 0.27\n", + "LPIPS_Vgg: 0.78\n", + "\n", + "\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "import os, json\n", + "\n", + "\n", + "model_paths = {\n", + " \"Measured PSF\": \"admm_measured_psf\",\n", + " \"Simulated PSF\": \"admm_simulated_psf\",\n", + "}\n", + "\n", + "# set model paths (and download if necessary)\n", + "for _model in model_paths.keys():\n", + "\n", + " model_key= model_paths[_model]\n", + " # overwrite with model path\n", + " model_paths[_model] = download_model(camera=CAMERA, dataset=DATASET, model=model_key)\n", + "\n", + "print(\"MODEL PATHS:\")\n", + "pprint(model_paths)\n", + "\n", + "\"\"\"\n", + "Print desired metrics.\n", + "\"\"\"\n", + "selected_iterations = [100, 10] # [10, 20, 100]\n", + "selected_metrics = [\"PSNR\", \"SSIM\", \"LPIPS_Vgg\"]\n", + "\n", + "for key, value in model_paths.items():\n", + "\n", + " print(\"-\" * 80)\n", + " print(f\"{key}\")\n", + " print(\"-\" * 80)\n", + "\n", + " _results_path = os.path.join(value, \"results.json\")\n", + " assert os.path.exists(_results_path), f\"Path {_results_path} does not exist\"\n", + " _test_metrics = json.load(open(_results_path))[\"ADMM\"]\n", + "\n", + " for iteration in selected_iterations:\n", + " print(f\"{iteration} iterations\")\n", + " print(\"-\" * 20)\n", + " for metric in selected_metrics:\n", + " print(f\"{metric}: {_test_metrics[str(iteration)][metric]:.3}\")\n", + " print(\"\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: reconstructions and show how PSF is simulated" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4.2 (Physics-based machine learning)\n", + "\n", + "The purpose of this experiment is to show that the physics-based machine learning reconstructions (with a simulated PSF) can improve image quality compared to the ADMM reconstructions. We use the same **measured dataset** as in the previous experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL PATHS:\n", + "{'FUS10': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/unrolled_admm10_ft_psf',\n", + " 'FUS10+P8': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/unrolled_admm10_ft_psf_post8M',\n", + " 'P4+FUS10+P4': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/pre4M_unrolled_admm10_ft_psf_post4M',\n", + " 'P4+US10+P4': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/pre4M_unrolled_admm10_post4M',\n", + " 'P8+US10': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/pre8M_unrolled_admm10',\n", + " 'U-Net': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/unet8M',\n", + " 'US10': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/unrolled_admm10',\n", + " 'US10+P8': '/home/bezzam/LenslessPiCam/lensless/recon/../../models/digicam/celeba_26k/unrolled_admm10_post8M'}\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "from matplotlib import pyplot as plt\n", + "import os\n", + "import json\n", + "import numpy as np\n", + "\n", + "\n", + "model_paths = {\n", + " \"US10\": \"unrolled_admm10\",\n", + " \"FUS10\": \"unrolled_admm10_ft_psf\",\n", + " \"U-Net\": \"unet8M\",\n", + " \"US10+P8\": \"unrolled_admm10_post8M\",\n", + " \"FUS10+P8\": \"unrolled_admm10_ft_psf_post8M\",\n", + " \"P8+US10\": \"pre8M_unrolled_admm10\",\n", + " \"P4+US10+P4\": \"pre4M_unrolled_admm10_post4M\",\n", + " \"P4+FUS10+P4\": \"pre4M_unrolled_admm10_ft_psf_post4M\",\n", + "}\n", + "\n", + "# set model paths (and download if necessary)\n", + "for _model in model_paths.keys():\n", + " model_key= model_paths[_model]\n", + " # overwrite with model path\n", + " model_paths[_model] = download_model(camera=CAMERA, dataset=DATASET, model=model_key)\n", + "\n", + "print(\"MODEL PATHS:\")\n", + "pprint(model_paths)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "-- US10 --\n", + "Best epoch (chosen from test loss): 23 / 25\n", + "PSNR: 8.63\n", + "SSIM: 0.293\n", + "LPIPS_Vgg: 0.671\n", + "Best test loss: 0.81\n", + "\n", + "-- FUS10 --\n", + "Best epoch (chosen from test loss): 24 / 25\n", + "PSNR: 11.6\n", + "SSIM: 0.434\n", + "LPIPS_Vgg: 0.623\n", + "Best test loss: 0.693\n", + "\n", + "-- U-Net --\n", + "Best epoch (chosen from test loss): 23 / 25\n", + "PSNR: 17.8\n", + "SSIM: 0.595\n", + "LPIPS_Vgg: 0.364\n", + "Best test loss: 0.381\n", + "\n", + "-- US10+P8 --\n", + "Best epoch (chosen from test loss): 23 / 25\n", + "PSNR: 19.8\n", + "SSIM: 0.658\n", + "LPIPS_Vgg: 0.331\n", + "Best test loss: 0.341\n", + "\n", + "-- FUS10+P8 --\n", + "Best epoch (chosen from test loss): 24 / 25\n", + "PSNR: 19.1\n", + "SSIM: 0.634\n", + "LPIPS_Vgg: 0.344\n", + "Best test loss: 0.356\n", + "\n", + "-- P8+US10 --\n", + "Best epoch (chosen from test loss): 23 / 25\n", + "PSNR: 16.5\n", + "SSIM: 0.519\n", + "LPIPS_Vgg: 0.418\n", + "Best test loss: 0.44\n", + "\n", + "-- P4+US10+P4 --\n", + "Best epoch (chosen from test loss): 22 / 25\n", + "PSNR: 21.6\n", + "SSIM: 0.687\n", + "LPIPS_Vgg: 0.291\n", + "Best test loss: 0.298\n", + "\n", + "-- P4+FUS10+P4 --\n", + "Best epoch (chosen from test loss): 24 / 25\n", + "PSNR: 21.2\n", + "SSIM: 0.673\n", + "LPIPS_Vgg: 0.301\n", + "Best test loss: 0.309\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "MAX_EPOCH = 25\n", + "\n", + "# available metrics: 'LOSS', 'MSE', 'MAE', 'LPIPS_Vgg', 'LPIPS_Alex', 'PSNR', 'SSIM', 'ReconstructionError'\n", + "selected_metrics = [\"PSNR\", \"SSIM\", \"LPIPS_Vgg\"]\n", + "\n", + "# plot train and test loss\n", + "import matplotlib.colors as mcolors\n", + "plot_colors = list(mcolors.TABLEAU_COLORS.keys())\n", + "plt.figure()\n", + "for key, value in model_paths.items():\n", + " _metrics_path = os.path.join(value, \"metrics.json\")\n", + " assert os.path.exists(_metrics_path), f\"Path {_metrics_path} does not exist\"\n", + " _test_metrics = json.load(open(_metrics_path))\n", + "\n", + " color = plot_colors.pop()\n", + " train_loss = np.array(_test_metrics[\"LOSS\"])\n", + " train_loss = train_loss[:MAX_EPOCH+1]\n", + " plt.plot(train_loss, label=key + \" (train)\", color=color, linestyle=\"--\")\n", + "\n", + " test_loss = np.array(_test_metrics[\"MSE\"]) + np.array(_test_metrics[\"LPIPS_Vgg\"])\n", + " test_loss = test_loss[:MAX_EPOCH+1]\n", + " plt.plot(test_loss, label=key + \" (test)\", linestyle=\"-\", color=color)\n", + "\n", + " best_epoch = np.argmin(test_loss)\n", + " print(f\"\\n-- {key} --\")\n", + " print(f\"Best epoch (chosen from test loss): {best_epoch} / {len(test_loss)-1}\")\n", + "\n", + " # print metrics\n", + " for _metric in selected_metrics:\n", + " print(f\"{_metric}: {np.array(_test_metrics[_metric])[best_epoch]:.3}\")\n", + "\n", + " print(f\"Best test loss: {test_loss[best_epoch]:.3}\")\n", + "\n", + "plt.xlabel(\"Epoch\")\n", + "plt.title(\"Train-test loss\")\n", + "\n", + "# legend outside\n", + "plt.legend(loc=\"upper right\", bbox_to_anchor=(1.45, 1.0))\n", + "plt.ylim([0.25, 0.95]);\n", + "plt.xlim([0, MAX_EPOCH])\n", + "# plt.legend()\n", + "plt.legend(loc=\"upper right\", bbox_to_anchor=(1.45, 1.0))\n", + "\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot metric over iterations" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "PSNR\n", + "--------------------------------------------------------------------------------\n", + "Max PSNR for US10 (epoch 4): 9.15\n", + "Max PSNR for FUS10 (epoch 25): 11.6\n", + "Max PSNR for U-Net (epoch 25): 18.0\n", + "Max PSNR for US10+P8 (epoch 24): 20.1\n", + "Max PSNR for FUS10+P8 (epoch 25): 19.3\n", + "Max PSNR for P8+US10 (epoch 29): 16.8\n", + "Max PSNR for P4+US10+P4 (epoch 23): 21.8\n", + "Max PSNR for P4+FUS10+P4 (epoch 25): 21.3\n", + "\n", + "SSIM\n", + "--------------------------------------------------------------------------------\n", + "Max SSIM for US10 (epoch 3): 0.329\n", + "Max SSIM for FUS10 (epoch 23): 0.436\n", + "Max SSIM for U-Net (epoch 25): 0.596\n", + "Max SSIM for US10+P8 (epoch 24): 0.66\n", + "Max SSIM for FUS10+P8 (epoch 22): 0.635\n", + "Max SSIM for P8+US10 (epoch 29): 0.525\n", + "Max SSIM for P4+US10+P4 (epoch 25): 0.688\n", + "Max SSIM for P4+FUS10+P4 (epoch 25): 0.678\n", + "\n", + "LPIPS_Vgg\n", + "--------------------------------------------------------------------------------\n", + "Min LPIPS_Vgg for US10 (epoch 25): 0.669\n", + "Min LPIPS_Vgg for FUS10 (epoch 24): 0.623\n", + "Min LPIPS_Vgg for U-Net (epoch 23): 0.364\n", + "Min LPIPS_Vgg for US10+P8 (epoch 29): 0.331\n", + "Min LPIPS_Vgg for FUS10+P8 (epoch 24): 0.344\n", + "Min LPIPS_Vgg for P8+US10 (epoch 28): 0.415\n", + "Min LPIPS_Vgg for P4+US10+P4 (epoch 22): 0.291\n", + "Min LPIPS_Vgg for P4+FUS10+P4 (epoch 24): 0.301\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAHHCAYAAAC83J6NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD6Q0lEQVR4nOzdd3hUZfrw8e/0lt4bJNSEACFIkdCbgtgBe6+ri7qIvxXFXbHtWtZdde3uy4K6CyguCgiiCAYEElpoIYSWhPTep5fz/jEwMAQkCWnA87muuSZz5sw5Z3KSmXueuZ/7lkmSJCEIgiAIgiAIlzl5Zx+AIAiCIAiCIHQFIjAWBEEQBEEQBERgLAiCIAiCIAiACIwFQRAEQRAEARCBsSAIgiAIgiAAIjAWBEEQBEEQBEAExoIgCIIgCIIAiMBYEARBEARBEAARGAuCIAiCIAgCIAJjQRAEQRAEQQBEYCwIwnksWrQImUzmuWi1Wvr27csTTzxBWVmZZ728vDweeOABevXqhVarJSIigrFjxzJ//nyv7Y0fPx6ZTMb111/fZF95eXnIZDLefvttz7LU1FSv/SsUCsLCwpg5cyYHDx5svycuCIIgXHaUnX0AgiBcHF555RV69OiBxWJh8+bNfPzxx6xZs4bMzEyKi4sZNmwYOp2OBx98kLi4OEpKSsjIyODNN9/k5ZdfbrK977//nl27djFkyJBm7f+pp55i2LBh2O129u3bxyeffEJqaiqZmZlERES09dMVBEEQLkMiMBYEoVmuueYahg4dCsDDDz9McHAw//jHP1ixYgWbN2+msbGRPXv2EBsb6/W48vLyJtvq3r07DQ0NvPzyy6xcubJZ+x8zZgwzZ8703I6Pj+fxxx/niy++4Nlnn72AZyYIgiAIbiKVQhCEVpk4cSIAubm5HDt2jJiYmCZBMUBYWFiTZb6+vjz99NOsWrWKjIyMVu1/zJgxABw7dqxVjxcEQRCEM4nAWBCEVjkZkAYHBxMbG0tBQQEbNmxo9uP/8Ic/EBgYyEsvvdSq/efl5QEQGBjYqscLgiAIwplEYCwIQrPU1dVRWVlJYWEhX331Fa+88go6nY7rrruOp556CrVazaRJkxg8eDCzZ89mxYoVmEymc27Pz8+P2bNnN3vUuKGhgcrKSkpKSvjxxx+ZPXs2MpmMGTNmtOXTFARBEC5jIjAWBKFZJk+eTGhoKN26deP222/Hx8eHb7/9lujoaPr378+ePXu4++67ycvL47333uOmm24iPDycf/3rX+fc5slR47NNzjvTgw8+SGhoKFFRUUydOpW6ujq+/PJLhg0b1pZPUxAEQbiMicl3giA0y4cffkjfvn1RKpWEh4cTHx+PXH7qs3Xfvn358ssvcTqdZGVl8f333/PWW2/x6KOP0qNHDyZPntxkm/7+/syePZv58+eze/fu30yLePHFFxkzZgyNjY18++23LF261Gv/giAIgnChxLuKIAjNMnz4cCZPnsz48ePp16/fOYNShULBwIEDef755/n2228B+O9//3vO7f7hD38gICDgvKPGAwcOZPLkydx00018/vnn3HDDDTzyyCMUFBS0/kkJgiAIwmlEYCwIQrs5Wd6tpKTknOucHDVesWIFu3fvbva233jjDSwWC3/5y18u+DgFQRAEAURgLAhCG/j111+x2+1Nlq9ZswZw1xz+LbNnzyYgIIBXXnml2fvs1asXM2bMYNGiRZSWlrbsgAVBEAThLERgLAjCBXvzzTfp3r07s2bN4tNPP+XTTz/ld7/7Hffddx9BQUHMnj37Nx/v7+/PH/7wB/bs2dOi/f7xj3/EarXy7rvvtvrYBUEQBOEkERgLgnDB5s2bx4wZM9i0aRNz587lySefZO3atdx+++3s2LGDHj16nHcbs2fPxt/fv0X7HTp0KOPHj+fjjz+mrq6utYcvCIIgCADIJEmSOvsgBEEQBEEQBKGziRFjQRAEQRAEQUAExoIgCIIgCIIAiMBYEARBEARBEAARGAuCIAiCIAgCIAJjQRAEQRAEQQBEYCwIgiAIgiAIACg7+wDO5HK5KC4uxtfXF5lM1tmHIwiCIAhCM0iSRENDA1FRUcjlYtxNuDh1ucC4uLiYbt26dfZhCIIgCILQCgUFBcTExHT2YQhCq3S5wNjX1xeA3NxcgoKCOvloBLvdzk8//cTVV1+NSqXq7MO5rIlz0XWIc9F1iHPRdVRXV9OjRw/P+7ggXIy6XGB8Mn3C19cXPz+/Tj4awW63o9fr8fPzE286nUyci65DnIuuQ5yLrsNutwOINEjhoiaSgARBEARBEAQBERgLgiAIgiAIAiACY0EQBEEQBEEAumCOsSAIgiAIly+n0+nJVxaEC6VSqVAoFM1eXwTGgiAIgiB0OkmSKC0tpba2trMPRbjEBAQEEBER0ayJoS0KjF9//XWWL19OdnY2Op2OkSNH8uabbxIfHw+4S7XMnz+fn376ifz8fEJDQ7npppt49dVX8ff3b92zEQRBEAThkncyKA4LC0Ov14vqFsIFkyQJk8lEeXk5AJGRked9TIsC440bNzJr1iyGDRuGw+Fg3rx5XH311WRlZWEwGCguLqa4uJi3336bxMREjh8/zmOPPUZxcTHffPNN656VIAiCIAiXNKfT6QmKg4ODO/twhEuITqcDoLy8nLCwsPOmVbQoMF67dq3X7UWLFhEWFsauXbsYO3YsAwYM4H//+5/n/l69evGXv/yFu+++G4fDgVIpMjcEQRAEQfB2MqdYr9d38pEIl6KTf1d2u/28gfEFVaWoq6sD+M0OdXV1dfj5+YmgWBAEQRCE3yTSJ4T20JK/q1ZHqy6Xi9mzZzNq1CgGDBhw1nUqKyt59dVXefTRR8+5HavVitVq9dyur68H3FG9mJXa+U6eA3EuOp84F12HOBddhzgXXYc4B8KloNWB8axZs8jMzGTz5s1nvb++vp5rr72WxMREXnrppXNu5/XXX+fll19usvyXX34RX6l0IevWrevsQxBOEOei6xDnousQ56LzmUymzj4EQbhgMkmSpJY+6IknnmDFihVs2rSJHj16NLm/oaGBKVOmoNfr+f7779Fqtefc1tlGjLt160ZJSYlIwO8C7HY769at46qrrkKlUnX24VzWxLnoOsS56DrEueg6qqqqiIyM9KRQtoTFYiE3N5cePXr8ZszQFY0fP57k5GTeffddr+WLFi1i9uzZ1NbWYjKZePXVV/n6668pKirC19eXxMRE5syZw4033gjA8uXL+eSTT9i1axfV1dXs3r2b5ORkr21aLBaeeeYZli5ditVqZcqUKXz00UeEh4d30LO9OLXk76tFI8aSJPHkk0/y7bffkpqaetaguL6+nilTpqDRaFi5cuV5D0Cj0aDRaJosV6lU4kWuCxHno+sQ56LrEOei67hczoXL5kSmknfJXNzL4fffWo899hjbtm3j/fffJzExkaqqKrZu3UpVVZVnHaPRyOjRo7n11lt55JFHzrqdp59+mtWrV7Ns2TL8/f154oknmD59Olu2bOmop3LJa1FgPGvWLBYvXsyKFSvw9fWltLQUAH9/f3Q6HfX19Vx99dWYTCb+85//UF9f78kZDg0NbVHnEUEQBEG4nEmShKPSjC2vHmtePbbj9TgqzagiDQTdFo8qwtDZhyg008qVK3nvvfeYNm0aAHFxcQwZMsRrnXvuuQeAvLy8s26jrq6OBQsWsHjxYiZOnAjAwoUL6devH+np6YwYMaL9nsBlpEWB8ccffwy4vzY43cKFC7n//vvJyMhg27ZtAPTu3dtrndzcXOLi4lp/pIIgCIJwCZOcLuzFRqx5de5AOK8el7HphDZ7iZGyD3YTMK0nhpTILjl63BYkScJsd3b4fnUqRZv/TiMiIlizZg3Tp0/H19e3VdvYtWsXdrudyZMne5YlJCTQvXt30tLSRGDcRlqcSvFbxo8ff951BEEQBEEAl8WBLb8Ba14dtrx6bAUNSHaX90pKGeoYXzRxfqjj/FEGa6n7PgfLoRpqVx7DcriGwJl9UPioO+dJtCOz3Uniiz92+H6zXpmCXt22JWY/++wz7rrrLoKDgxk0aBCjR49m5syZjBo1qtnbKC0tRa1WExAQ4LU8PDzc8w2+cOFEcWFBEAThoiK5JOxlJqzHajEfqaFfgR81VdmoQ/QogrUog3Uog7Qog7TIlBdUrr9NOeusWPPq3YHw8XrsJUY4YyxJrleijvXzBMLqaJ8mzyH4/v4YtxZT+0Muluxqyt7NIOiWvmjjz91TQOhcY8eOJScnh/T0dLZu3cr69et57733ePnll/nzn//c2YcnnEYExoIgCEKXdjLX1nqsFuuxOqw5tbiMDs/9epTYDtdiO1zr/UAZKPzUKIJ0KIO17svJn4O0yPVtM1lMkiQkmxOX2YHL5MBldiCZHZ7b9lJ3eoSzxtrksYogLZpYP9Rx7mBYGapHJv/tr/FlMhk+o6LR9Aqgakk2jjITlQsP4DMqCv+pPZCpOv7DgCRJWHPq2nSbOpWCrFemtOk2m7vflvDz8/M0PDtdbW0t/v7+ntsqlYoxY8YwZswY5s6dy2uvvcYrr7zC3LlzUavPP+IfERGBzWajtrbWa9S4rKyMiIiIFh2zcG4iMBYEQRC6HEeNxRMIW47V4qq3ed0vU8tRx/mj6uHL7uMHuKJPElKdDWeVBUe1BUeVBcnmxFlnw1lnw5bbNHCR6ZSeIPnkKLMiSItcp/QObs9xcd9vx2V2gqsZaYQyUEX5eAXCCr+mVZmaSxVhIPyJZGrX5GJMK6FxSzHWY3UE3RGPKrxjJuZJkoQlu5r6DQXUHW3br/NlMlmbpzS0h/j4eH766acmyzMyMujbt+85H5eYmIjD4cBisTQrMB4yZAgqlYr169czY8YMAA4dOkR+fj4pKSmtfwKCl67/FycIgiBc8pz1Nqw5tViO1mLNqcNZbfFeQSlD090PTa8ANL38Ucf4IlPKsdvt1NfvQT883KtcmCRJuIx2HCcCZWeV2fOzo9qMq8GOZHZgL2zEXtjYNk9CIUOuVyLXKZHrVCeule5R4Tg/1N19kWva9m1XplIQeGNvtPFB1Cw7jL3USNn7ewi4tgeGEe03MU9ySViyqqjfkI+92Ohe2Akj1V3B448/zgcffMBTTz3Fww8/jEajYfXq1SxZsoRVq1YB7jlYd9xxB0OHDiU4OJisrCzmzZvHhAkTPDWfq6uryc/Pp7i4GHAHveAeKY6IiMDf35+HHnqIOXPmEBQUhJ+fH08++SQpKSli4l0bEoGxIAjCRUpySUhWJy6T3Xsk0+pEGa5H3c23y1YscBrtWHPcaRHWY7U4ys3eK8hxTzrrFeC+xPoia8FX3DKZDIWPGoWPGk1s02YTLpsTZ7UFx+kBc5UZR7UFyer0BLUnLzLdaQGvXnnW+zuzvrAuIQj17CuoXnYY6+EaalecmJg3o20n5kkuCfP+Suo35OMoc3e6k6nlGFKiUCdq4W9ttquLRs+ePdm0aRMvvPACkydPxmazkZCQwLJly5g6dSoAU6ZM4fPPP2fevHmYTCaioqK47rrrePHFFz3bWblyJQ888IDn9u233w7A/PnzPR2E33nnHeRyOTNmzPBq8CG0nVZ1vmtP9fX1+Pv7U1lZKTrfdQF2u501a9Ywbdo0Uby9k4lz0XW09bmQ7C6cDbYTga397LmqZ/sq3+JoMnnrdIoADbqkUPRJIaiifTo1SJZcErbCBiwHq7FkV2MvPWPi2ck0g57+7kC4h1+zRlfF/4U3ySXRuLWYuh9ywSkh91URdGs82j6BF7Zdp4RpXwUNG/JxVLg/xMg0CnxGRuEzOhqFQUVVVRUhISGXXec7oetrt853giAIQtuQJAnb8XqMO8ow769AsrnO/6BzkKnkXqOaMpUc2/EGnLVWGjcV0ripEEWQFn1SCLqkUFSRhg4JkiW7E8vRWixZ1ZgPVuFq9K7JqwzTo+nlj7ZXAJqe/m02Ge5yJpPL8B0djaanP9VLD+EoN1G5IBOf0dH4T41rcZUOyenCtLuchl8KcFS501tkWiW+o6PwGRklzplwyRGBsSAIQgdyNtowZZRj3FHqGXkDQOkObs/2Nb0n6NWrzn7fWYIdye7EcqgG074KLAercVZbaEgtpCG1EGWIDl1SCPqk0DbvnuZstGE5WI35YDXWIzVedXllGgXa+EC0/YLR9g5A4Xvp1d7tKtRRPoQ/mUzt6lyM6SU0bi7CeqyWoDsSUIXpz/t4yeHCuKuMhtQCTzUNSSeHYYE4+mjJtzZQv2cH9fX1NDQ0UF9fT3l5eXs/LUFodyIwFgRBaGeSU8JypAbjjlIsB6s9FQxkKjm6pFAMw8JRx/q16SiuTKVANyAE3YAQXDYnluxqzHsrMB+qwVFppmFDAQ0bClCG6U+NJDcjYGry3CQJR4UZc1YVloPV2PLrvVIkFP4atIlB6PoFo+np36XqCl/qZCoFgTf1Rts3kJr/HcZeYqT8/d34X9cTw/AIz9+bJElYrVbq6+upr6mjYl8h1dnFNFhNGGVWTForJpUds90C23FfzsJqbVqOThAuNiIwFgRBaCeOKjPGnWUYd5V5lRtTdfPFMCwcfVIocm37vwzL1Qr0SaHok0JxWR1YDlZj2luB5XANjnIT9T/nU/9zPqoIA7pBIegHhqIM0Z1ze5LTnQbiDoarPF+xn6SK9kHXLwhtYnCHpW0I56ZLDEYdM4TqZYdoOFJJ1ood1G1zUhvuoLyynNraWuz2pq2nvSKEE3crFAr8/Pzw8/PD19fX62en08kbb7zRIc9JENqLCIwFQbhkuSwOLIdrMGdV4ay2oAzVo4rQowo3oIrQI/dVt3nQJtmdmDKrMO0o9Wp4INcr0Q8OwzAsos3TF1pCrlGiTw5DnxyGy+zAnFWFeV8FliO12EuN2EuN1P94HFW0j3skeWAoyiCtO6A+XIMlqxrLoWpcplMNNlDI0PQKQJcYhLZfMEr/1tfmFdqO2WympKSEkpISiouLKTGWUK2tdt9ZfeJyGo2kRC9pMCh1BEYFExgXjl+Anyf49fPzQ6fTnfN/pqqqqn2fkCB0ABEYC4JwSXHWWzFnVWPOqsJ6rBacp77Xt+U3eK0r0ylRhetRRRjc1ycD5lZMKLIVNWLcUYppTzmSxXliB6DpE4hhaDi6xOAul0Yg1ykxDAnHMCQcl8mO+UAVpn0VWI/VYi9qpK6okbof8lCG6dyjwqf9LuV6JdoEdyCs7RvQ5vV5hZYxmUyeIPhkIFxTU3PWdf19/Aiy6Ak2GwiWfPCT9BgkDZogA34TuqEfHNbl/lYFoaOIVzJBEC5qkiThKDe5Rz6zqrEXeAe/yhAd2v7BqKMMOCrM2MtM2EuNOKrMSGYHtrx6bHn1Xo+R+6q9RpZV4QaU4Xrkau86ui6zg8YdFRh3lGIvMXqWKwI0GIaGox8ajjKg40pPuVwu8vLyOHr0KMHBwQwcOLBZHbUA5HoVhmERGIZF4DTaMWdWYt5XgTWnzlNjWBmsRZsYjK5fsDsnWiFSJDrDySC4uLjYc11bW3vWdQMCAoiMjCQqKorIyEgiIyMxGAy4bE7qVudg3FaKMkSH74Ru6JPDxDkVLnsiMBYE4aIjuU7luJqzqnCenuMqA3U3X3cAlxh8zgllkt2FvcKEo8yEvcyIvdR97ayx4mqwYW2wYT1S6/UYRZAWVbgeRaiWHocNVOzYBY4To6gKGboBIRiGhqPpFYBM3jEBhiRJFBYWkpmZyYEDB2hsPNXFbd26dQwePJjhw4cTGNj8OrYKgwqfKyPxuTISZ4MNa149qnA9ytBzf41+KZAkiZKSEurr6wkLCyMgIAC5vHNHTk+mQxQXF3su5wqCAwMDmwTBev3Z//7lagWBN/fBb3IscoOqw/5eBaGrE4GxIAgXBZfNifVIrXvCV3YVLuNpOa5KGdpeAWj7u0czm1MGTKaSo47yQR3l470fqwN7mQnHiUD55Aizq9GOs9riblV8EILQABKqCAP6YeHok8NQGDqmpqskSZSVlbF//34yMzOpqzuVy6zVaunbty8FBQXU1NSQlpZGWloa8fHxDB8+nJ49e7YouFX4qtEPDGmPp9FlmEwm9u3bR0ZGhlfJMZVKRVhYGGFhYYSHh3uuDYb2yRG3Wq1NguDq6uqzrhsUFOQJfk8GwjrduSdMnosomScI3kRgLAhCl+VstLnLjB2ownq01rsmrk6JLsFd+UDbNxC5pvntgn+LXKNE090PTXfvzl3ORps7YC4zYS1pIK8gn343DUUXG9Bho6iVlZVkZmaSmZlJZWWlZ7lKpSIhIYGBAwfSs2dPlEolLpeLo0ePsm3bNo4dO8ahQ4c4dOgQISEhXHnllSQlJaHRXL6T5FwuFzk5OezevZvs7GycTndeuEKhICQkhMrKSux2O0VFRRQVFXk91sfHp0mwHBoa2qLOezabjbKyMk8AXFRU5HVOTxcQEEBUVJTn0togWBCE8xOBsSAIbU6SJCS768TFiWRzIdmc7tsnrl0nf7adWMfuvY6jxtq0Jm6ABl1iMNr+wWji/JApOu5rboWPGoWPGnoFoLHbKVyTTVIHtFmura3lwIEDZGZmUlJScup4FAr69u3LgAED6NOnT5NcYrlcTt++fenbty8VFRVs376dvXv3UllZyerVq/n5558ZPHgww4YNIzg4uF2fQ1dSU1PDnj172L17N/X1p3LLIyMjGTx4MAMHDkSn0+F0Oqmurqa8vJyysjLPdU1NDY2NjTQ2NpKTk+N5vEwmIygoyCtYDgsLIzAwEJfL5RUEFxcXU15ejiQ17eft5+fnFQRHRUWdMx1C6Bruv/9+Pv/88ybLjxw5wsMPP0xycjLvvvuu132LFi1i9uzZnrQYk8nEq6++ytdff01RURG+vr4kJiYyZ84cbrzxRgCWL1/OJ598wq5du6iurmb37t0kJyd7bddisfDMM8+wdOlSrFYrU6ZM4aOPPiI8PLw9nvolSQTGgiC0miRJ2AoaMO+pcJfwsjhOBLqtb298JlWUwR0MX0Y1cRsbG8nKymL//v0UFBR4lstkMnr16sWAAQNISEhAq23exL7Q0FCuvfZaJk2axJ49e9i+fTvV1dWkp6eTnp5Onz59uPLKK+nZs2en59S2B7vdTnZ2Nrt37/YKZrVaLUlJSQwePJjIyEivxygUCkJDQwkNDaV///6e5VarlYqKCq9guaysDLPZTFVVFVVVVWRlZXnWV6lUOJ1OXK6m/xMGg4GoqCiio6M9I8G+vr7t8BsQ2tvUqVNZuHCh17LQ0NBmP/6xxx5j27ZtvP/++yQmJlJVVcXWrVu9SuAZjUZGjx7NrbfeyiOPPHLW7Tz99NOsXr2aZcuW4e/vzxNPPMH06dPZsmVL657YZUgExoIgtJi93IRpTzmmPRXunNvfopQjV8uRqeTI1Ar3tUqBTH3qWn767RPryXUKNL0CUAZ2XFWHzmQ2m8nOzmb//v3k5uZ6jSbGxsYyYMAAEhMTLyi/VavVMmLECIYPH86xY8fYtm0bR48e5ciRIxw5coTg4GCGDx9OcnLyJZFmUVJSwu7du9m3bx8Wy6m/0549ezJ48GASEhJalP4AoNFoiImJISYmxrNMkiQaGxu9guXy8nLKy8s9jTN0Ol2TkWA/v7btdih0Ho1GQ0RERKsfv3LlSt577z2mTZsGQFxcHEOGDPFa55577gEgLy/vrNuoq6tjwYIFLF68mIkTJwKwcOFC+vXrR3p6OiNGjGj18V1ORGAsCEKzOOqsmPdWYNpd7lWaTKaWo+sfgi4pBGWQ1jvoVcnFbPezkCSJ+vp6T7mtoqIi8vLyPHmuAFFRUQwcOJD+/fvj5+f3G1trOblcTp8+fejTpw+VlZXs2LGD3bt3U1VVxQ8//MD69etJTk5m+PDhhIRcXBPvzGYz+/fvJyMjg9LSUs9yPz8/Bg8eTHJycosqdDSHTCbD19cXX19fevfu7VnudDqpqalBoVAQENBxueiXDEkCu6nj96vSQwefq4iICNasWcP06dNb/a3Brl27sNvtTJ482bMsISGB7t27k5aWJgLjZhKBsSAI5+Qy2TFlVmLaXYEtr+5Uvq9chjY+EH1yKNp+wbjkEjU1NQQGalAqxcvK6SRJoq6urkndWZOp6Rt+WFgYAwYMYMCAAQQFBXXI8YWEhHDNNdcwceJE9u7dy/bt26msrGT79u1s376d3r17M2zYMIKCgs6aE3vmsuasA+5UhbNdlEolcrm8RUGkJEnk5eWxb98+Dh48iMPh8OwjISGBwYMHd0qayMmJfEIr2U3w16iO3++8YlC37JuZ77//Hh+fUxVurrnmGpYtW9bsx3/22WfcddddBAcHM2jQIEaPHs3MmTMZNWpUs7dRWlqKWq0mICDAa3l4eLjXh0Tht4l3MEEQvLhsTiwHqzHtKcdyuMar25m6hx/65DB0A0KQ65WUlJSw5+cfyczMxGQyERwczDXXXOM1anY5ORkEnx4Al5SUnDUIlslkhIWFecptxcbGduoEGY1Gw/Dhwxk2bBg5OTls27aNw4cPc/ToUY4ePdrhx/NbgfPpt+VyOUVFRezZs8fz2LCwMK644gqSkpLExDWhQ0yYMIGPP/7Yc7ulKU9jx44lJyeH9PR0tm7dyvr163nvvfd4+eWX+fOf/9zWhyv8BhEYC4KA5JSwHq3BtKcC84EqJNupr/RVkQb0yaHoBoWiDNBSX19P2u5t7N27l4qKCq/tVFVV8Z///IeEhASmTJnS5l9ZdyUng+Dy8vLzBsFyuZzQ0FDPBKuoqCjCw8NbnN/aEU5O8OvVqxfV1dXs2LGDAwcOeHJlzzaSe+ay5qzjdDo9l5MjvGe7v7k0Gg0DBw5k8ODBREVFibSFS4FK7x697Yz9tpDBYDjrgICfn59XnfGTamtr8ff3996tSsWYMWMYM2YMc+fO5bXXXuOVV15h7ty5zepgGRERgc1mo7a21mvUuKys7ILyny83IjAWhMuUJEnY8hsw7SnHvK8Sl9HuuU8RqEGfHIY+ORRVuAGbzUZWdjZ7V+0lJyfH89W4UqkkISGBQYMGER0dzaZNm9i2bRvZ2dkcPXqUUaNGMWrUqGa3JW4PTqeTAwcOkJ+fj9PpdJeSkyRcLtdvXv/WfU6nk6qqKq9RypPkcrnXSHBkZGSXDYLPJygoiClTpjBlypR235fL5cLhcHgFzGdezna/zWZj37593HLLLWJ0+FIjk7U4paGriY+P56effmqyPCMjg759+/7mYxMTE3E4HFgslma9hg4ZMgSVSsX69euZMWMGAIcOHSI/P5+UlJTWPYHLkAiMBeEy46yzYtxZhnFXmVdFCblBiS4pFH1yGOru7skfx48fZ++Knzlw4AA2m82zbrdu3UhOTiYxMdGr0cDUqVO54oor+OGHH8jNzWXjxo3s2bOHqVOnkpCQ0KGjeBaLhYyMDNLT073q1balk0Hw6SPBYWFhF2UQ3NnkcnmrPkDZ7Xby8/PF71zokh5//HE++OADnnrqKR5++GE0Gg2rV69myZIlrFq1yrPe+PHjueOOOxg6dCjBwcFkZWUxb948JkyY4Jl8W11dTX5+PsXF7lH0Q4cOAe6R4oiICPz9/XnooYeYM2cOQUFB+Pn58eSTT5KSkiIm3rWACIwF4TIgOSUsh6oxbi/FcqjaM4nuZEUJfXIomt4ByBRyqqur2Zqayt69ez3F58HdfWvQoEEMGjToNyeGhYWFce+995KVlcWPP/5IXV0dX331FT179uSaa65pUW3P1qivr2fbtm3s3LkTq9UKuL/mHDRoEFqtFplM5pncdfL6bMvOdS2TyXC5XOzevZubbrpJdCATBOGcevbsyaZNm3jhhReYPHkyNpuNhIQEli1bxtSpUz3rTZkyhc8//5x58+ZhMpmIioriuuuu48UXX/Sss3LlSh544AHP7dtvvx2A+fPn89JLLwHwzjvvIJfLmTFjhleDD6H5ZNLZpgt3ovr6evz9/amsrLysujF1VXa7nTVr1jBt2jQxItPJWnMuHFVm9+jwzjJcDadGfNVxfhiGR7gn0akVWCwWDhw4wN69e8nPzz+1nlpN//79GTRoEN27d2/xrH6bzcbmzZvZsmULTqcTuVzOiBEjGDt2bLObUzRXeXk5W7duZd++fZ5mCsHBwYwcOZKkpKQ2/fsV/xddhzgXXUdVVRUhISHU1dW1uMSgxWIhNzeXHj16tPlrgyC05O9LjBgLwiVGcrgwH6jEuKMM69Faz3K5QYV+SBiGYRGoQvW4XC6OHTvG3r17yc7O9poA1atXLwYNGkRCQsIF5Qer1WomTpxIcnIya9eu5fDhw57g9aqrriIpKemC0itOlunaunUrR44c8Szv3r07I0eOpG/fvpdkJzdBEAShfYjAWBBw1+u1HKvFUWl2N6SQy5EpZKCQuW8rZO7bcvkZt93XMoXc8/Ppj5HrVMg1ig55DvYyI8YdZZgyynCZTgS5MtD0DnCPDvcLRqaUY7fbSU9PZ8uWLTQ0NHgeHxISQnJyMklJSW3eUCIoKIg777yTw4cPs3btWqqrq/n222/ZuXMn06ZNa9KO93ycTicHDx5k69atnnw7gH79+jFy5Ei6devWpscvCIIgXB5EYCxcliSXhK2gAcvhGqxHarAVNJxqXtHG5H5qVCE6lKE6lKF6lKE6VCE6FIHaC+4K57I5Me+rwLijDNvxUxPMFH5q9EPDMQyNQBnk/trIbrezK307mzdvprGxEXC3qR04cCCDBg3qkBJXffv2pWfPnqSlpbFp0yYKCgr47LPPGDJkCBMnTjxvVQGbzcbu3btJS0vz5D8rlUqSk5NJSUkR6VeCIAjCBRGBsXDZcNRasR6uwXKkBsuRWiSLd+1UZZgedYy7c5HklMAlnXbtAqeE5JJOu3Z5ree5zymB68R9TglXvQ1rvQ1rzhm1LBUylMHugFkVqkMZovf8LNf/dq6krbAB445STHsqkKwnar3KQZsQjGF4BNq+gZ6g2263s2vXLq+A2N/fn7FjxzJo0KAO71SnVCoZM2YMSUlJrFu3jszMTHbu3MmBAweYNGkSV1xxRZP0h8bGRrZv386OHTswm82AO6g/2ZDi9I5TgiAIgtBaIjAWLlmS3Yk1pw7LiWDYUW72ul+mVaLtE4C2byCaPoEoAzRtfgwukx17pRlHhRlHpRlHhQl7hRlHlRkcEo5yE45yE5YzHic3KD2BsjLEHSxLfipCSzVUfbQPR8mpJhKKIC2GYREYhoSj8DuVD9zVAuIz+fv7M3PmTIYMGcIPP/xAeXk533//Pbt27WLatGl069aNqqoqtm7dyt69ez050IGBgaSkpJCcnNyp9ZEFQRCES48IjIVLhiRJOMpMnkDYmlsHjtPyI2Sg7uaLpk8g2r6BqGN83TnB7UiuV6HprkLT3TtnV3JJOGutpwLlylOBs7POhsvowGas90qPAOiOAQcmUMjQDQjBMCwCTU9/r5QMu91ORkYGv/76q1dAPGbMGJKTkzs9ID5Tjx49+N3vfseOHTv45ZdfKCkpYcGCBURHR1NUVORZLyoqilGjRtGvXz8xoU4Q2oizsRG5Xo9M/E8JAtDCwPj1119n+fLlZGdno9PpGDlyJG+++Sbx8fGedSwWC8888wxLly71qqEXHh7e5gcvCE6jHevRWk+usLPe5nW/wl/tCYS1vQPOm6LQUWRyGcogLcogLdp47/tcVueJQNmEo8LsFTgbFVbCx/fCZ0gkCoP3c7nYAuLTKRQKRowYwYABA1i/fj27d+/2BMV9+vRh1KhRxMbGija/gtAGXEYj9T/8QO2ybzDv3Ys6NpbAe+4h4OabkBsu7k5zgnChWvROuXHjRmbNmsWwYcNwOBzMmzePq6++mqysLAwn/pmefvppVq9ezbJly/D39+eJJ55g+vTpbNmypV2egHD5cVkcmPdXYtpT7s7bPX3SnFKOpqc/2j6BaPsGoAzTX3TBlFyjQB3tgzraO2/2ZL3WHimRKE6r13oyIN68ebOnyoSfnx9jx47t8gHxmXx8fLjxxhsZMmQIR44coX///oSFhXX2YQnCRU+SJCyZmdQu+4b677/HZTqVjmU7fpyy116j4r33CLjlFoLuuhNVdHQnHq0gdJ4WvWOuXbvW6/aiRYsICwtj165djB07lrq6OhYsWMDixYuZOHEiAAsXLqRfv36kp6eLloRCq0kOF5ZDNZj2lGM+WOWVIqEM158IhAPR9PBDpuqY8mid7VIKiM8UExNDTExMZx+GIFz0nPX11K1aRe2yb7BmZ3uWq2K7EzBzJn5Tp9K4aRM1X3yJ7fhxqv/9b6oXLcL3qqsIuu8+dIOTL7rBBUG4EBf0zllX555lf7I97K5du7Db7UyePNmzTkJCAt27dyctLe2sgbHVavW0bQV35ztwv+nb7fYLOTyhDZw8B51xLiSXhL2gAcveSiyZ1UjmU1UkFKE6dINC0CYFowg81cXGgQvsrg4/1o5w8hyYzWZ27NjB1q1bPSkTfn5+jBo1iqSkJJRKJZIkif+fdtSZ/xeCN3EumpIkCUtGBvXLl9P40zoki3t6r0ytxjB5Mn4zZ6AbOtQT8Preeis+M2di2ryZ2i++xLxtGw0//kjDjz+iGTCAgLvvwufqq5Gdp7OgOAfCpaDVLaFdLhc33HADtbW1bN68GYDFixfzwAMPeAW6AMOHD2fChAm8+eabTbbz0ksv8fLLLzdZvnjx4vPWNBUuTVqTnKBKDUGVajTWU6O/NpWL6hAr1aE2zHonXGaDGC6Xi6qqKsrKyjxvQCqVioiICIKCgsSENOGypDt2DN99+3H6GHD4+XldnAYDXEb/F4rGRvwyMvDbvgNNRYVnuTU8nLrhw6i/4gpczXhfVZeUErhlM7679yA/UQ3G4edHzcgU6oYPx3WOPGSTycSdd9552bWEHj9+PMnJybz77rteyxctWsTs2bM9NdfPdP/99/P555/z+uuv89xzz3mWf/fdd9x88820JDyLi4tj9uzZzJ49uxXP4NLXIS2hZ82aRWZmpicobq3nn3+eOXPmeG7X19fTrVs3JkyYIIr1dwF2u51169Zx1VVXoTrPaMGFcNbbsOyvwrK3wqsUmUyjQJMYhHZQCOoefnS7wIYYFxuHw0FeXh6HDh3iyJEjmE7kBfr6+jJq1KguUXbtctRR/xfCb7McyKJo/nwki/XsKygUKIKDUYaHoQwNQxkaiiIsFGVo2InrUJRhYcj9/S/adAHJ5cKcvo36//2Pxg0b4EQgK9Np8Zl6Df4zpqNpTev1hx7EWV1N3dfLqFu6FKqqCF37I2GpG/G9/noC7r4Ldc+eXg+pqqpqq6d12dBqtbz55pv87ne/IzAwsLMPR6CVgfETTzzB999/z6ZNm7zyACMiIrDZbNTW1hIQEOBZXlZWRkRExFm3pdFo0Gia1o9VqVTiDacLaY/z4bI4MB+owrS7HOux2lOT6OQytPGB6AeHoesXdNnkDJ9ksVg4cuQI2dnZHDlyBJvtVKUNlUrFpEmTGDp0qAiIuwDxOtV57GXllD71FJLFijk2lvDhw3FVVuIoL3dfqqrA6cRZXo6zvJxzhM6AO8VAGRbmuai7d0c/fDj6IVcg1+k67Dm1hL2sjLpvv6X2m/9hLyz0LNcOGEDALbfgd+00FBfY+EYVHo72yScI/d2jNPzwA1Wff4416yD1y5ZRv2wZhtGjCbrvPgyjRyGTycT/QitMnjyZo0eP8vrrr/PWW2+dc73Nmzfz/PPPs3PnTkJCQrj55pt5/fXXMRgMjB8/nuPHj/P000/z9NNPA7RotFnw1qJ3VkmSePLJJ/n2229JTU2lR48eXvcPGTIElUrF+vXrmTFjBgCHDh0iPz+flJSUtjtq4aIlOVxYDp+YRJdVDY5T+cDqWD/0g0PRDQxtUorsUtfQ0MChQ4c4ePAgubm5uFynfi++vr4kJCTQu3dvDh48yJAhQ0RQLFzWXGYzhb//PY7yctS9enH0nnsYOGO6V2AmORw4qqpxlJd5gmX7yaC5vMKzzFlTg2SzYS8s9Aowqz77DFQq9IMGoU8ZgWHECHQDByLrpKYykiThKK/AvGcPdd99R+PGjXDidULu64v/9dcRcMstaPv1a/N9y9Vq/G+8Eb8bbsC8cyfVX3xBw8/rMW7ejHHzZtS9ehF0zz24Ro9q0/1KkoTZYT7/im1Mp9R12DcICoWCv/71r9x555089dRTZ510fOzYMaZOncprr73Gv//9byoqKnjiiSd44oknWLhwIcuXL2fQoEE8+uijPPLIIx1y3JeyFr27zpo1i8WLF7NixQp8fX0pLS0F3LVSdTod/v7+PPTQQ8yZM4egoCD8/Px48sknSUlJERUpLkMuiwN7mQlHmQl7mRF7uQl7USMu06lJdMpQHfrkMPTJoSiDu+bITHuprKwkOzub7OxsCk97QwYICQkhISGBhIQEoqKikMvl2O12sk+bVS4IlyPJ5aL4ueexHDiAIiCAyPffJ3P/vibryZRKVOFhqMJ/u9yfy2bDWVFxImiuwFFWhuXgQYzp6ThKSjDt3Ilp504q3/8AmV6PfsgQDCNGoB9xJdp+/dqlMYYkSTiKizEfOIAlK+vE5SDOykqv9XRDhhBwy0z8pkzpkJFtmUyGftgw9MOGYSsooOY//6H2m/9hO3aM0pdewuTTtjWQzQ4zVy6+sk232Rzb7tyGXtVxc5xuvvlmkpOTmT9/PgsWLGhy/+uvv85dd93lyR/u06cP//znPxk3bhwff/wxQUFBKBQKfH19z/ntvNB8LQqMP/74Y8CdaH66hQsXcv/99wPwzjvvIJfLmTFjhleDD+HS5bI4sJefDIBNJ3424qyznXV9uY8K/aBQ9IPDUEX7XLS5fS0lSRLFxcVkZ2dz8OBBKs94k4uOjqZfv37Ex8cTGhraSUcpCF1b5Qcf0PDjj6BSEfPB+6i6xcBZAuPmkqvVyKOjm9TtlSQJe34+xrR0jNvSMaVvw1lTg/HXXzH++isACn9/d8rFiRFldY8eLX49k1wu7AUFWE4Pgg9k4TxR9cn7YOVoevXEMGo0AbfMRNOrV6uf94VSd+tG+PPPE/Lkk9QtX071F1/iOn68046nK/v111+55pprPLc//fRT7rrrLq913nzzTSZOnMj//d//NXn83r172bdvH//97389yyRJwuVykZubS792+JbgctbiVIrz0Wq1fPjhh3z44YetPiiha7BareTn53sqILisThzlJ0Z/TwTBjjITzrpzZ+8p/NQow/WowvSowg0oI/Soo9u/FXNX4XQ6ycvL84wMn6w3DCCXy+nRowcJCQnEx8e3eBa3IFxu6lZ9T+VH7gGayJdfRj90aLuVCJPJZKhjY91d4W6/DcnlwnrkCKb0dIxp6Zh27MBZV0fDunU0rFsHgDIsDP2IKzGMSMEw4kpUUVFe25ScTmx5ee7gN/NEIHzwIK4TZRe9qFRo+vRGm5iINjERXWIimvj4LpfzrPDxIejeewm86y7yv1sBM2e02bZ1Sh3b7tzWZttryX5bws/Pz1O+9nS1tbX4+/szdOhQ9uzZ41l+tk7AY8eOZcqUKTz//POegcaTGhsb+d3vfsdTTz3V5HHdu3dv0bEK5ycSFQUvjY2NHDp0iOzsbHJycnA6nciR4ThYxwBTNAHS2b8qk/uqUYXrUYXr3YFwuAFVmB657uL/E3M4HFitVmw2GzabzfPzby07eV1cXIzlRA1RALVaTe/evUlISKBPnz7outibnCB0Vea9eyl54QUAgh56kIDpN3fo/mVyOdr4eLTx8QTddx+Sw4ElMxNj+jaM6emYMzJwlJdTv3IV9StXAe4mGoYrRyBTqdxBcHY2krlpzqxMrUaTkIA2sd+JQLg/mr59kHdSPnNryBQKfMaPa9ttymQdmtLQWvHx8fz0009NlmdkZNC3b190Oh29e/c+73beeOMNkpOTiY+P91p+xRVXkJWV9ZvbUKvVOJ3Olh+80MTFH7UIF6yqqsozollQUOB1n1ZSYZHZyXYWkK0uIE4exhUhiXTv1u1EAOweDZbrL77Jci6Xi7q6OsrKyigvL6esrIy6uromAe7pE+FaQ6/Xe/KFe/ToIWZuC0IL2YuLKZj1BJLNhs/EiYSdVuKzs8iUSnTJyeiSkwl57He4rFbMu3djTE/HlJaOOTMT+/F8ao/nez9Op0Pbr59nJFjbPxFNz57nbZ4hdF2PP/44H3zwAU899RQPP/wwGo2G1atXs2TJElatWtXs7QwcOJC77rqLf/7zn17L586dy4gRI3jiiSd4+OGHMRgMZGVlsW7dOj744APAXcd406ZN3H777Wg0GkJCQtr0OV5ORGB8GXK5XJSUlHiC4YrTCsEDRIZGEFPlR3dzEEF6f/YEFFKjM3G0MJc8qZy8inK6absxqu8o+nYPvygaS5hMJq8AuLy8nPLycq9SaOejVCpRq9VoNJqzXp9tWWBgIDExMRfF70gQuiKX0UjB72fhrKxEEx9P9N/eQqboeiUc5RoNhhHuXGNmg7OxEdOOHZi27wBJQtvfHQir4+K65PELrdezZ082bdrECy+8wOTJk7HZbCQkJLBs2TKmTp3aom298sorfPXVV17LkpKS2LhxIy+88AJjxoxBkiR69erFbbfd5vW43/3ud/Tq1Qur1SrKtV0AERhfJhwOB8ePHz9nrmtcXBwJCQnEqsJxfFuEZHOiDNcTcHc8jq3l3DbtJmpra9m6dSv79u2joKCApUuXEhwczMiRI0lKSuoSI6F2u52KigqvALisrMzTOvlMcrmc0NBQwsLCCA8PJygoyFNb+8ygVyHezAShQ0kuF0XPzsWanY0iOJhuH3+E/Bxd17oahY8PvhMm4DthQmcfitABhg0bdtZ0it+yaNGiJsvi4uKadA9uzvZHjBjB3r17W7R/4exEYHwJs1qtHD16lOzsbA4fPuz1z3a2XNfGbSXULjsKLtD0DiD47n44Fac+dYaGhnLjjTcyceJEtm3bxo4dO6iqqmLVqlVs2LCBK6+8kmHDhnVI3qwkSdTV1VFSUuIVBFdVVZ3zk3JAQIAnAD55HRwcfNkGvJLdjiRJF1UeY0tJDgfm3btpSE3FWVmJfvhwfMaORXkJVv1wNjRg3LKFxtSNmHZnoE8eTPjzz6E4rdnSxabinXdoXL8emVpNtw8/aDKZTRAEoa2JwPgSc7bJcycZDAbi4+Ob5LpKLom6H3Jp2OiupasfEk7gzb2RKeU4zzLj29fXl8mTJzNmzBgyMjJIS0ujvr6eDRs28OuvvzJkyBBGjBjh1f3wQtXX11NcXOx1Odke+Uw6na5JABwaGnre/uiXC0mSqPnyP5S/+y6SyQQqFXK9HrlBf+LacPbrc95nQG7Qo/DxQRES0unl9xw1NRg3b6YxdSONv/6Kq77ec1/dipUAaPv3x2fcOHzGj0M7YEC71KLtCNbcXPfzTE3FtGuXpx0wQN3xfIxbtxL517/gM2ZMJx5l69Qu/5aqf/0/ACL/8hd0ycmde0CCIFwWRGB8iSgqKiI9PZ0DBw54TRYLCgryTPw6W66rZHdRvewQ5n3umrp+k7vjO6l7s4IbjUZDSkoKw4cPJzMzk61bt1JWVkZ6ejrbtm1jwIABjBo1qsUFxxsbG5sEwWdLhZDL5U0C4LCwMHx9fTs9OOuqHDU1lDw/j8bU1FML7XZcdXW4zlY3tYUUgYFokwaiS0pClzQIXdJAFP7+F7zd3yJJEtYjR2jcuJHG1I2Yd+/2dAQDd61Zw7ixqKKiMG7egiUz010z9sABKj/6CEVwMD5jxuAzfhyGUaNQ+Pq26/FeCMlmw7RrF42pqTSkpmI/Y2KXumdPfMaNQzugP5UffoQtJ4eCRx4l4PbbCH/2WeT6rj/DH8C0axcl8+cDEPz4Y/hff10nH5EgCJcLERhfxFwuF9nZ2aSnp5Off+oNMjIykn79+pGQkEBoaOg5g0Sn0U7VF1nYjteDQkbg9D4YhjStr3g+CoWCQYMGkZSUxLFjx9iyZQu5ubns37+f/fv307NnT0aNGkXPnj2bHIvJZGoSBNefNsJ3kkwmIzQ0lKioKM8lPDy8S+Q1XyyM6dsofvZZHOXlyNRqwp59Fv8brsdlMrkvRiMuowmX6cS10eh939muT/+5sdHdAGHjJowbN3n2q46LQzcoCe2JYFkb3/eC2+q6rFZM27fT+Esqjamp2IuLve7X9O2Lz/jx+Iwfh27QoFOTnWbPxlFRQeOmX2ncuBHjli04q6qo++476r77DpRK9Fdcgc+4sfiMG4e6V69O/5DlqKx0H29qKsYtW3AZjafuVKkwDBuGz/hx7uONjfXc5TtpEuV//wc1X35J7dKvMKalEfXGG+gHD+6EZ9F8toICCp94Eux2fKdMIfTJJzv7kARBuIyIwPgiZLVa2b17N+np6dTW1gLu0dMBAwYwYsQIopqRh+eoMlO58ACOSjMyrYLguxPR9g64oOOSyWT07t2b3r17U1xczNatWzlw4AA5OTnk5OQQERHBsGHDMJvNniD45PGfKSQkxCsIjoiIQH0J58K2J8nhoOLDD6n65FOQJNQ9exL9j7+jTUgAQNFGjUVcNhvWgwcx792HeZ/7Ys/Px5aXhy0vz5PGIFOr3Q0LTgbLgwahio4+bwBqLyuncWMqjakbMaaledWDlanV6FNG4DNuHL7jxjXpYnY6ZWgoATOmEzBjunsENmO3e7R540ZsOTmYtm/HtH075X97G1V0tCflQj98OPIOSMeRJAlLVhaNqak0btyEZZ93VzdFSIgncDeMHIXiHG145VotES/Mw3fiBIqfn4f9eD7H77qb4EceIXTW7y/4w0l7cDY2UvD44zhratD270/UG693eJpLdYmR0mN1qHVKNPrTLyrUOiVyufg2CsBmcVBbZqKm1HTi2khhbnlnH5YgXDARGF9Eampq2L59OxkZGZ6JdDqdjqFDhzJs2LBmd06zHq+n6osDuIwOFAEaQh7ojyq8bWd6R0VFMXPmTCZNmkRaWhq7d++mtLT0rDUdg4KCvILgyMhINBpNmx7P5cpeVETRH5/FnJEBgP/MGUTMm9cuX6nL1Wp0gwahGzTIs8xRU4Nl375TwfL+/bjq6jDv2YP5tE5QiuBgdAMHnjaynITcYMCSmekOEFM3YsnK8tqfMizsxKjweAwjrmzVc5Kp1RhGXIlhxJWEz30WW0GBO2d340ZM27djLyqiZvFiahYvRqbVYhgxAp/x49CMHNnsfUiS5E7tcLmQTlyf/rPkcoHDgXnfPk8w7Cj3DjC0/ft7RsC1/fu3KFg0pKTQc+UKSl97jfqVq6j69FMaf91E9JtvounTp9nbaQuSJHFgUxGHt5cxdFoc3fsHn7rP4aBozhxsR4+hDAsj5qMPO7zL25GdZfy8MAuX89ylrtQ6JRqdEo3hVMCs0Z32s77pz37BOhSqiy+PXZIkjLU2asqM1Ja6g+CaUiO1ZSYaa5pWTjDbzj7vQxAuJjKpixW7q6+vx9/fn8rKSoKDg8//gMtAQUEBaWlpHDx40FNxITg4mBEjRjBo0KAWjaSa9ldS/dUhcLhQRfsQcn9/FL7nfrzdbmfNmjVMmzbtgtIWTCYTO3bs4PDhw/j7+3sFwaL7W/O09FzU//gTJX/+M676euQ+PkS8/BL+117bAUd6bpIkuVvinhYsWw4dgrNM8pT7+uI6rawgMhnapIH4ngiGNQkJ7Zrm4DKZMKanuwPlTZtwlJZ63e8wGFCr1chOD3IlCZxO7yC4FS+xMr0ew8gUfMePxzB2LKqwsDZ5TvVrf6T0pZdw1tYiU6sJffppgu67t0NGZa1mB798mc2xDHfQL5PLGHdHX/qPcY/ul73+OtWff4FMqyX2yy/RDRzQrO221WvU3g0FbF52BCQI7e6LUi3HanKcuNhx2Frf6Efnp2bUjN70HR7e6ak5Z+O0u6itMJ0Kfk8LhO3Wc3dT0/mqCIwwEBChJzBcD1obg8f0oa6ursUt7i0WC7m5ufTo0UNMlBbaXEv+vsSIcRfldDo5ePAgaWlpFBUVeZb37NmTESNG0Lt37xY1jZAkicZfi6j7IRck0CYEEXRHAnJNx5Qq0+v1jBs3jnHj2rZlqNCUy2Kh7PU3qD1RJF47KInot99G3a1bJx+ZO91G06MHmh498L/xRsCdL2zJyvIKlu2FhbgaGpAbDBhGj3anM4wdg7IDuznJ9Xp8J07Ed+JE9wS/w4c9o8nmPXtQGo3e+b4XSNWt24m0jfHohw9rlzJ6flOnoLtiMCV//jPGjZsof/NNGjdsIOqN138z/eRCVeQ3sPZfmdRXmJHLZUT08qf4SC2p/z1EQ5WFvpZdVH/+BQBRb7zR7KC4LUiSRPp3OWT8eByAAeOiGXNb3yYpE06HyxMkewJmsx2r8eTPp993ah1zox1zvY2fF2ZxcGsx4+6IJzCi82sxu1wS2Wkl7Pm5gNpS4zk/v8nkMvxDdQSE6wmMOHkxEBCuR2vw/iBSVVXVAUcuCO1LBMZdjNlsJiMjg23btnkmoSkUCgYOHMiIESNaXOEBQHJK1H5/DGNaCQCGlEgCru+FTOTKXXKsR45QNGcO1iNHAQh+5GFCn3qqS7eblWs06AcP9poU5qiqwl5SirZvny6RCyuTydDGx6ONj8d59e3s/fYQlcVlXHtLHIGhepDJ3BP85HL36KtcDjI5MsXJn0+7XyaDJuvKOmwkURUWRrdPPqH262WUvfkmph07yLnhRsJfeAH/m29q0+OQJIkDvxaz+esjOB0ufII0THlkAOFxfmz/Ppedq/PYtfY4heV59JMpCX/q9/hNndJm+z8fp9NF6pfZZKe7vw248oaeDLkm9qy/A4VSjt5Pjd6vZX+PTruL3evy2flDHkWHaln66nYGX9WdIdPiUKk7voa6JEkcz6wi7dtjVBef+mCn0ioIjDCcCn7D3SPB/qE6FMqLLw1EEFpLBMZdRFVVFdu2bWP37t3YT3ytrNfrGTZsGMOGDcPHx6dV23XZnFQvzsaSXQ0y8J/WA5/R55/oJFxcJEmi9quvKXv9dSSrFUVoCFFvvIHPqFGdfWitogwORtnFUqlqSo1sW5HDsd0nW6jr+f7raqY+Gk1MfGCnHltLyWQyAm+7FUPKCIrnPod5925K5s2jYcN6Il95BWVQ0AXvw2ZxkPqfbI7sdKdOxCWFMOm+fp5Rxiuv74leMvLr6lLKwobiiOhBz3tuvOD9Npfd6mTtZ5nkH6hCJpcx/q54Eke1fQMRhUrO0Glx9B0ezqavDnN8fxW71h7n8I4yxt7Wl7ikjvsWpPx4PVuXH6XoUC0AGr2SodPi6DMsHL2fWrwvCAIgPgZ2soKCApYsWcL777/P9u3bsdvthIWFccMNN/D0008zYcKEVgfFznobFZ/ucwfFSjlBd/bDd0yMePG7xDjr6ij6w2xKX3oJyWrFMGYMPb/77qINirsaY62VX/6bzZJXtnNsdwUyGfQdHobK34nV6GDle3vY90vhOTsudmXq7t2J/c+XhM6ZAyoVjT+vJ+f6G2jYsOGCtltZ2MDXf93BkZ3lyOUyRs7ozbTHB3p99e6sq0P/0bMM2vcRSslGlSuYb9/OoL7S/BtbbhvmRhvfvbOb/ANVKFVypj02sF2C4tP5hei49vdJXPPYQHwCNTRUWVj90T7WfLyPhmpLu+67vtLMTwsOsOz1nRQdqkWhlDP4qu7c/WoKyZO7Y/DXiPeFCzB+/Hhmz57dZPmiRYs8ja5MJhPPP/88vXr1QqvVEhoayrhx41ixYoVn/eXLl3P11VcTHByMTCZjz2kTlE+yWCzMmjWL4OBgfHx8mDFjBmVlZa0+9pdeegnZiW+slEolcXFxPP300169A3bs2MGkSZMICAggMDCQKVOmXNLtp8WIcSeRJIktW7awfv16zxtq7969SUlJOWu935aylxmpXHgAZ60VuUFJ8L390cS2TVkuoeswZWRQ9H//h6O4BFQqwubM6bDJVJc6q8lOxo/57NtQgMPunngVlxTCiJt64heqwbjqGLqaXhzdUc6vXx2msrCBcbfHX3TVB2QKBSGPPoLPmNEUPzsX65EjFP5+Fv4zphP+/PMoWvDBXJIksjYX8+vXR3DaXfgEulMnInp6N3mR7HYKZ8/GlpdHWGQkNz2RyA//LaCm1MQ3b+3iullJhLXT61V9pZlV7++ltsyExqDkulmDmhxfe5HJZPRMDiUmIZCdq/PYu76A3L2VFBysZti1PRg0uRsKRdv9/ViMdnb9kMe+1EJcDvf7TPyVEQy/oQd+wWLSc0d67LHH2LZtG++//z6JiYlUVVWxdetWr7xso9HI6NGjufXWW3nkkUfOup2nn36a1atXs2zZMvz9/XniiSeYPn06W7ZsOev6qamp3H///eTl5Z3z2Pr378/PP/+Mw+Fgy5YtPPjgg5hMJj799FMaGxuZOnUqN9xwAx999BEOh4P58+czZcoUCgoKLsleAiIw7gQ2m40VK1Zw4MABAAYMGMC4ceMIDQ1tk+1bjtZS9Z8sJIsTZYiOkPv7owy5NF8EJYcDmfLy+zOWnE6qPvuMig8+BKcTVWx3ot/+e4dOWrpUOWxO9qUWkrH2OFaTu8VyZC9/Um7uReSJWt92ux2ZAibc05ew7n6kLT/KwS0l1JQYmfq7gRj8L75yg9p+/Yj7ZhkV7/2T6oULqfvfckzp24h643X0w4ad9/E2i4ONiw9xeLt79Cp2QDCT709E6+P9xilJEqV//SumtHRkej3dPv4IbUJ3Zs4N5/sP91JV2Mi3f8/g6ocH0KON0wwqCxtY9c+9mOpt+ARpuP7JZIIiO34inFqrZOSM3sSPiGDjkkOUHK0j7dtjHNpWyrg74onqE3BB23fYnez/pYhda/M8f8MxCYGMnN6b0O5dt7PjpWzlypW89957TJs2DYC4uDiGDBnitc4999wDcM4gtq6ujgULFrB48WImTpwIwMKFC+nXrx/p6emMGDGiVcemVCo985duu+021q9fz8qVK/n000/Jzs6murqaV155hW4nJnDPnz+fpKQkjh8/Tu/evVu1z67s8osoOllNTQ1Lly6lrKwMuVzONddcw9ChQ9vsayzjrjJqlh8Bp4Q61o/gexNRGC69T3TmPXso+9vbmHftQhMfjyElBcPIFPRDh140bW9by1FWRvELf8K0bRsAfjdcT8SL88/Z6EFoHpfTRXZ6KTu+z/XUaA2KMjDipl7EDQw+6/+oTCZj8FXdCY4y8OP/O0BpTj3LXt/JtMcHttuIZ3uSazSEP/tHfCeMp3juc9iLijh+730E3X8/hpQRuCwWJKvVfW2xIlktuCxWautlpBXH0uDQIcNFP0U2vfZnUvaEFcliwWWzute3WHBZrTirqkAmI/rtv3kazfgEapj+zBX8+K9M8rOq+eHjfYy5rS8Dx8e0yXMrPFTDDx/vw2ZxEhRl4Ponk/EJ7NwPMMHRPtz8zBUcSi9ly/+OUl1s5Nu/Z5AwIoKRM3qj+41SmmcjuSQO7yhj24ocT3pGcLSBkdN70y0x6KJLl5AkyauRT0eR6XRt/ruKiIhgzZo1TJ8+Hd9Wtp3ftWsXdrudyZMne5YlJCTQvXt30tLSWh0Yn0mn02Gz2QCIj48nODiYBQsWMG/ePJxOJwsWLKBfv37ExcW1yf66GhEYd6Bjx47xzTffYDabMRgM3HrrrcSe1sL1QjgbbNSuOoZ5XyUAuqQQgm6JR3aRfa17Prbjxyn/xzs0/PijZ5n10CGshw5RvWgRqFTok5MxjEzBkJKCdsCAS2pE2XDwIPmvv4GrthaZXk/k/Bc9Zc+E1pEkidy9laR/d4yaUneDAp8gDVde35O+V0Y0q9NZ9/7B3PLcUNZ8vI+aUhPL385gwt0JxF/Z8ioyXYF+2DB6rFxB2euvU/e/5VQvXEj1woVnXbc4YgSH+9yGS6FGY62hf9ZCAuqO8ZuF7ORywp79I74nRr1OUuuUTJuVxMbFhzi4pYRNSw9TX2Vh5M0XVkXn6K5y1i08gMshEdUngGmPD0Sj7xoDBjKZjISUSOKSQkj/7hgHNheTnV5K7r5KUm7uReKoqGY998LsarYuP0ZFvrv2tyFAw5U39CR+RPP+hrsiyWzm0BVDzr9iG4vP2IWsjQdYPvvsM+666y6Cg4MZNGgQo0ePZubMmYxqwVyQ0tJS1Gq1J2/5pPDwcErPqLPeWrt27fIakfb19SU1NZWbbrqJV199FYA+ffrw448/oryE3ltPd2k+qy5GkiTS0tJYt24dkiQRFRXFbbfdhr//hee1SZKEaWcZtatzkSwOkIPv+G74TY69pMqxOWpqqPzoY2qWLnU3g5DJ8J9+M0H33Yft6FGMaWkYt2zFXlyMaccOTDt2UPHeP5H7+qK/cviJEeWRqOPiOn3URLLbcVksuExmJIvZPfpmdl+7zGb3qJrZgstiRjp5bbFgLSwk+oe1uABtYiLR//g76kv0E3tHKT5SQ9q3xyjNcZdG1BiUDL0mjgHjolGqWlZKKyBcz8y5Q1n37wPk7a/i54VZVBY2knJzr4syMFH4+BD1l7/gO3EiVf/6f0g2GzKtFrlWg0ytwakxsN81iHy7u/5xuL6eKxMr0Y+ejkyjca+n0SLTapBrtSeWua+VQUEoz5E6plDImXB3An7BOratzGHPunwaqixMfqBfi88JwL5fCvn168MgQc/BoVz1YGKrttPetAYV4+9KICElko1LDlFZ0Ejqfw9xcGsJ4+6IP2cKRFVRI1uXHyP/gDtXVaVVMGRqLEkTu3VKOTjh7MaOHUtOTg7p6els3bqV9evX89577/Hyyy/z5z//uU33dfqEfafTidVq9Vp2991388knn3hu79+/Hx8fH5xOJzabjWuvvZYPPvgAcJeQfeihhxg1ahRLlizB6XTy9ttvc+2117Jjx45LskGXCIzbmc1mY9WqVezfvx+AQYMGcd1117VJwrq9wkTN8qPYcusAUEX7EDi9D+ro1lWx6IpcFgvVX35J1Wf/8nRBM4wZQ9j//R/a+L4AaPv2xW/aNCRJwp6f7w6St6Zh3LYNV10djT+vp/Hn9QAoIyM9QbIhZcQFlwRzGY3Yy8txlFfgKC8/dakox15ejquu3h3weoJcCzgcF7RP/3vuIeKP/9cuDSAuF1VFjaR9d4zj+93BhFItZ9Ckbgy+OhaNrvUvi2qdkmmPJ7FtVQ67fjjOnnX5VBc1ctVD/Zs0Q7hY+E6ahO+kSV7LqouNrP1XJjUlRmQyGH5DT4ZMabsP4zKZjKHT4vAN1rLhi4McyyjHVGdl2uNJTXKWz0WSJLatyGHX2hONO8ZGM+b2po07upqInv7c8txQ9qcWsW1VDmW59Sx7fQcDJ8Rw5fU9UZ/4+2yssbJ9VQ7ZaSVIEsjlMvqPi2bYtLgWp2B0VTKdjviMXZ2y35bw8/Ojrq6uyfLa2lqvATCVSsWYMWMYM2YMc+fO5bXXXuOVV15h7ty5zepgGxERgc1mo7a21mvUuKyszKvHwenVLLZt28bcuXNJTU31Ot7TxcfHs3LlSpRKJVFRUV7HsnjxYvLy8khLS/M0FVu8eDGBgYGsWLGC22+//bzHfbERgXE7qq2tZenSpZSWliKTyZg6dSrDhw+/4BFLyeGiYVMh9RvywSEhU8nxuyoWn1HRyBRd+0W/uSSXi/rvv6f8nXdxlLgbk2j69SP8j/+HYeTIsz5GJpOhjo1FHRtL4O23IzmdWLKy3EFyWhrmXbtwlJRQt3w5dcuXu7cZH+8OkkemoB8yxJOf7LJYcFR4B7tnC4AvqPOZXI5cp0Om0yHXar1+lum0yLXeP0tqNftk0PuJJ5BfgjOBO0J9pZntq3I5tL0UJHdXr/6joxh6bVybTZiTyWWMuLEXwdE+bPjiIPlZ1Xzzxk6m/T6pUyZ6tbXs9BI2Lj6Ew+ZC76/m6of6E923feo4x18ZgSFAww+f7KfkWB3fvLWT658chH/ob3/N7XS6SP3vIbK3ul87rryhB0Ou6fxvi5pLrnB/UOs9JIzN3xzh6M5y9m0o5OiuckZO701NqZG9P5+qltLrilBG3NSLgLBLa36FTCZr85SG9hAfH89PP/3UZHlGRgZ9+/Y95+MSExNxOBxYLJZmBcZDhgxBpVKxfv16ZsyYAcChQ4fIz88nJSXFs97pE+IKCwtRKpW/OUlOrVaf836TyYT8ZGOiE07edrla3ya9KxOBcTvJzc1l2bJlmEwm9Ho9t9xyCz169Ljg7Vrz66n53xEcZe5cSE3fQAJv6o0y6NLpLW9MT6f8rb9hycoCQBkRQejsP+B/ww0tKkMmUyjQDRyIbuBAQn73KC6zGdOuDIxpWzFuTcN68OCp/OSFC5GpVKhiYnBUV+M6y6f/c5EbDCjDwk67hKI68bMiIMA74NXqkOu0yLVaUKla9EZtt9sxr1nT7PWFU0z1NnatzSNzU5GnbFXvIWFceUNPAsLb5423z9BwAsL1rPl4H3UVZr55cydXPdi/zSstdBS7zcmvSw9z8ESwGZMQyFUP9m9xJ7iWiokPZMYfh/D9B3upKzfzzZu7uPb3SecssWa3OvnxX5kcz6xCJoPxdyWQOLp9axS3F0OAhikPDyBxZDUblx6irtzMzwuzPPdH9vJn5IzeHVZuTji7xx9/nA8++ICnnnqKhx9+GI1Gw+rVq1myZAmrVq0C3LWO77jjDoYOHUpwcDBZWVnMmzePCRMmeEZwq6uryc/Pp7i4GHAHveAeKY6IiMDf35+HHnqIOXPmEBQUhJ+fH08++SQpKSltNvHuTFdddRV//OMfmTVrFk8++SQul4s33ngDpVLJhAkT2mWfnU0Exi3ksjhwGe0ogrRnDWokSSI9PZ2ffvoJSZKIjIzktttua5Is3+L9Wh3U/3icxrRikEBuUBJwXS90yaEXzSjI+VgOH6b87bcxbvoVALmPD8GPPkrQvfe4A8kLJNfp8Bk9Cp/R7skOjupqTOnpXvnJttxcz/oyrRZleBiqUHewqwwNaxIAK0PDRDUI3LPhK4saCYzQd6n8zfLj9ez/pZDDO8s8AXFMQiApN/fqkKoRod18ufX5Yaz9LJPiI7Ws+Xifu+3w1LO3He6qakqNrP0s091CWAbDr3OPwHZUWkJQlIEZc4ew+sN9VOQ38N07u7n6wf70HOydp2xutLH6w32U5dajUMmZ8nB/egxqmzKYnalbYhC3/3k4u3/KZ9fa4/gGaUm5uRc9BoVcVH9Hl6qePXuyadMmXnjhBSZPnozNZiMhIYFly5YxdepUAKZMmcLnn3/OvHnzMJlMREVFcd111/Hiiy96trNy5UoeeOABz+2TaQrz58/npZdeAuCdd95BLpczY8YMrFYrU6ZM4aOPPmq355aQkMCqVat4+eWXSUlJQS6XM3jwYNauXUtkZGS77bczyaQu1q6pvr4ef39/KisrCe5iLWElp0T5+7uxlxpRhurQDQhBNzAEVaQBmUyG3W5n1apV7Nu3D4CkpCSuv/76C84nNh+sova7Yzjr3CWk9FeE4X9tzw4pw2a321mzZg3Tpk1rt0Le9rJyKt7/J3XLvwWXC5RKAm+/nZDfP94mrWmb42R+sr2kBGVoKMqwMOQ+Pl3qTacjzkVr1Jab+OXLbIqP1KLRK+kzNJyElEjC4nw75ffndLrIyahg3y+FlOacGvkP7+HHldf3pFvihf9NtfRcOJ0uNn99hMyNRQD0uiKMSff1Q6XpOh8izlRfZaYwu4aCg9Xk7avEYXOh81Nz9YOJxCR0zP/lmWwWBz8tOODODZfB6Jl9SBzrLoM1ZsREfvjogLtxh17JtbMGEdnr0htJddicKJTyLjm5uqqqipCQEOrq6prksZ6PxWIhNzeXHj16oG2DgRBBOF1L/r7EiHELmDLKsJe6c0odFWYafimg4ZcClMFaHH31fF+widLKMmQyGVdffTUjRoy4oMDA2WCjduUxzPvdJdgUQVoCb+6Ntk/75PN1NGejkep/L6Bq4SJPrUrfq68mbM7THV5t4fT8ZKF5JJfEvl8KSf/umCfX0WpykLmpiMxNRQRGGkhIiXDniXZAwwtTvY0DvxZxYFMRxjp3DU65QkbvIWEMnBBDRI/OC5IUCjnj7ognJMaHTUsPcyyjnLoKE9c8NrDLdCCzmuwUHaqlILuagoPV1JV714+Njg/gqgf7d2rzErVWybTHBvLrV0fI3FTE5mVHqC03YnPIWfH3E407AjVc/1TnNO7oCEpRaUIQ2pUIjJtJcrioX58PgN/k7ihDdJj2VWI5XE1BdQnrM/ZjkdnRouLa+AnEx7S+A5kkSZh2lFG75lQJNp/RMfhN7o78EnhRlBwOar/5HxUffICz8kTd5eRkwp59Fv0Vgzv56ITmqC0zseHLg5QcdY/IRscHMOHuBOqrLGRvLeHY7gpqSoykLT9G+rfH6N4/mISUSHokhbR5y+Ty4/Xs21DIkV2n0iX0fmr6j42m/5ioLtWFrv+YaAIjDaz9dD+VBY0se30nUx8d0G6T136L0+GiLLeOgoPuUeHyvHpO//5QJpcRHudLTL8guiUEEdnLv0uMUsoVcsbe0RffYC1p3x4jc2MxoAdsJxp3DMInUIw4CoLQOiIwbibjthKctVbkfmp8x8UgUynQDQpl29Z0fvp5Dy7JRbDky2TbQHz3OCnfswdFgAbdQHe6hbpb875WvpRLsEmSROMvqZT//e/Yjh0DQBXbnbA5z+B79VVdKm1BODuXS2LfhgK2rcjBYXeh0igYOaM3/Ue7mxD4h+rplhDEWLODY7vKObi1hNKcOo5nVnE8swqNXknfYeEkjIwktHvrUy2cDhfHdpez/5dCTw1icKdLJE2IodcVYSiUXbO5TVTvAG55fhg/fLKfivwGVr67hzG39aH/2Oh2/R+QJInqEiOFJwLhoiO1OKxOr3UCwvV0Swgkpl8Q0fGBF1S6rj3JZDKumBKLb7CWnxdl4XJARC8/rv39oIu2LJ4gCF1D13zV62JcNif1vxQA4DepOzKVArvdzurVqz31AgcMGMD111yH81gD5sxKLAercdZaafy1iMZfi1D4nxEknzHycqmXYDPvz6T8rbcw7dgBgCIggJDf/57A229DJurxNktpTh32hs4L9mrLTKz//KAnbzcmIdDdiCGkaSqARqckcXQUiaOjqC0zkZ1WQnZ6KcZaK/s3FrF/YxFBUQYSUiKJvzKi2ZUNTqZLZG4qwnRaukSfoeEMnBBDeNzF0YbZN0jLzf93Bb98mc2RHWVsXHKY7PRS9H5qNDolap0StV7p+dmzTOe97Hyj78Y6K4UHq92jwtnVnt/ZSTpfFTEJQcQkBNKtXxC+F1l1mz5Dw/EJUrPh+zSmPTRSBMWCIFwwERg3Q+PWYlyN7koUhqHh1NXV8fXXX1NUVIRMJmPy5MmMHDnSPdqTpEWfFIrL5sR6uAbT/hNBcp2Vxs1FNG4uQuGndk/cSwpB3d0PW2FDm5Rgc9TUUPnhRyhDQgi88w4ULZz80B7sRUWUv/se9SdK1sjUaoLuu5fgRx9F0cp+8Zcbi9HOpqWHObKjDDCwonive1R0cMeMip4cJU5fkYPzxCjxqJm9SRwd1awRzoBwPSNu6sXwG3pSmF1NdlopOXsqqC42svV/R0n79hixA4JJSIkgbmDIWZ9TWV49+34p4Oiu8lPpEv5qBoyNJnF010qXaC6VWsFVDyYSEuND2nfHKMutP/+DzqBQyc8IlhWodSpUajnl+Q3uKhJnrB/VJ4BuCUHE9AskJNqnS6RHXIiQbj74xNpF7q0gCG1CBMbn4TI7aEgtBEA+JpTMrAOsXbsWo9GIVqvllltuoVevXk0eJ1cr3MHvgBAkuxPL4VrM+yswH6zGWW+jcWsxjVuLkfuocBntF1yCzZSxm6I5c3Cc6Jde9a9/EXjnnQTdf98Fd3drDWd9PVWffUb1F18i2dyjVP433kDoH/6AKurirCnaGY5nVvHLlwcx1tmQyUBCoiynnnU5WWz2O0r/0VH0HxPVbjmVNaVGNnxx0JOu0K1fIONPtOttKblcRvfEYLonBmM12Tmys5zstBLKcuvJ21dJ3r5KtAYVfYe7q1oERRk4llHOvl8KvYLGiJ5+DOzADwbt6WRKQNzAEKqKGrGaHdjMjlPXJgc2y2k/n7jPbnGnQDjtLsx2G+Z62zl24C4Z161fEN36BRLRy79LldMTBEHoakRgfA5Op5PS0lKOrNtHgTOPcl09DT+emqUdFhbG7bffTlAzyonJVAp0/YPR9Q9GcriwHK7BnFmJOasKV6MdaH0JNsnlonrhQsr/8Q44nahiuyPXaLEePkzVv/5F9ZdfEnDLLQQ/9CCq01pGthfJZqPmq6+p/PBDnLW1AOivvJKwZ/+Irn//dt//pcJmcbDlm6NkbXYXeg8I1zP+7j5sy9hClDaRg1tLMdXZ2Lkmj11rj9NjUAgDx0UTHR/YJnmqLpfE3p8L2LYyB6fDhUqrYPTMPvQbFdkm29foVQwYG82AsdHUlBo9qRamOhv7filk3y+FKNVyHDZ3tQu50p0ukTQhpkPqD3e0oCgDQVHNr6LgcknYLecKnJ3YLA4CwvTExAc2u4WyIAiC0IrAeNOmTfztb39j165dlJSU8O2333LTTTd57m9sbOS5557ju+++o6qqih49evDUU0/x2GOPteVxt7nGxkYKCgooLCykoKCA4uJiHA6H+04FcGK2dlhYGL1792b8+PHNauF4JplSji4xGF2iO0i25tYh16taNbnOUVNDyXPP07hxIwB+06YR8coryPU6GlNTqfzkUyz79lHz5ZfULF1KwE03Evzww+1SkkySJBp+/pmKt/+O7fhxANS9ehH2x//DZ9w4MbGuBYoO17D+84M0VFkASJoYw4ibeoHMhSJLYsi0WIZd15PcPZXsTy2k+EgtObsryNldQWCEngHjYkgYEYG6lROnakqNrP/8oGeUtntiEOPvTmi3/NPACAMpN/fmyht6UpBdQ/bWEnL2VnhaDg8cF03i6Oh277B2MZHLZWj0KjR6EfQKgiC0pRa/cxqNRgYNGsSDDz7I9OnTm9w/Z84cNmzYwH/+8x/i4uL46aef+P3vf09UVBQ33HBDmxz0hTo5GnwyCC4sLKT2xOjm6TQKNaE2XyJ9Q0mYMYzo6Og2LTwuU8pbXZP49NQJmVpN+AsvEHDrLZ4A1HfiRHwmTMCUlkblJ59i2r6d2mXfUPu/5fhdcw3Bv3sU7W/0cG8J8969lL35FuaMDAAUwcGEPvkkATNnIFOKLyWay2Fzkr4ih70bCkByT9CaeF8/YuLdfyN2+6m+9AqFnN5Dwug9JIyqokYyNxZxaFspNaUmfv3qMGnfHSP+yggGjosmuJkfulxOF3t+LmD7qlycDhdqrYJRt/Sh38i2GSU+H7lCTmz/YGL7B2Mx2qktNxHa3ReF4uJOlxAEQRAuHi2OWq655hquueaac96/detW7rvvPsaPHw/Ao48+yqeffsr27ds7LTD+zdHg04SFhRETE0O3bt2I9A/H/u9jyBwQctMAtL26RlMNyeWi+t//pvydd8HpRB0bS/R776JNSGiyrkwmwzByJIaRIzFl7Kby008wbtxE/erV1K9ejc+kSYQ89jt0Awe26lhshYVU/OMf1K/5wb0/rZagB+4n+KGHO6xNstPhQq6QXfQj0mV59axflEVNqXsCZr9RkYye2adZo77B0T6MuzOelJt7cWhbKftTC6kpNXFgk7vZRVSfAAaMi6bn4NBzBpnVxUbWf3GQ8rwTo8T9gxh/V/uNEp+P1qDq1IYcgiC0nNFuPP9KgtDFtflw3siRI1m5ciUPPvggUVFRpKamcvjwYd55552zrm+1WrFarZ7b9fXuN2a73Y7dbr/g49m6dSu//PJLk+VarZaoqChiYmKIjo4mKirKazS4fkUODgeo4nyRxxna5FgulLOmhrIX/oTp118B8LnmGsLmv4jccP7jUw0cQOQHH2A9eJCa/7eAxnXraFy/nsb169GlpBD0yCNohw5pEmCe3O7p23fW1VPzr8+oXbwE7HaQyfC98UaCZ/0eZUQELsDVAb+v9O9y2Le+CGSg0ihQqRWoNAqUGrn7tubkbcVp98u9l51x0fmqWp2C0BpOh4uMtfnsWVeA5AKdn4pxd/Sl+4AgQPL6vZ/tXJxOpoSEUeHEjwyj5EgdB34tJm9fFcVHaik+UoveT03CqAj6jTrVic7llNi3vpCdPxzH5ZBQ6xSkTO9J3yvDPW3OhabOdy6EjiPORefLq89j2eFlLM9c3tmH0inuv/9+Pv/88ybLjxw5wsMPP0xycjLvvvuu132LFi1i9uzZnm+rTSYTr776qqfila+vL4mJicyZM4cbb7wRgOXLl/PJJ5+wa9cuqqur2b17N8nJyV7btVgsPPPMMyxduhSr1cqUKVP46KOPCA8Pb9Vze+mll3j55ZcBUCgUxMTEcPPNN/Pqq6/i4+P+NnLHjh0899xz7Nq1C5lMxvDhw3nrrbcYNGhQq/bZ2do8Anj//fd59NFHiYmJQalUIpfL+de//sXYsWPPuv7rr7/u+aWf7pdffkGv11/w8Rw+fBgAjUaDj48PBoMBg8GARqNBJpPR0NBAdnY22dnZnsdozHL67/FHhoz9hiKMPxy/4OO4UNq8PCIXL0FVV4dLqaTihus5PHw4nMgvbpFJE1ENHEBQaip+u/dgTkujKC0Nc1wsVRMmYorvC2cEyOvWrUPmcOCflkbw+g0oTrRwNvbuTcW107BFRcGJVIqOYCpRUr3nRGUECewWp2em/oWRUAc50YU70IU7UOqk8z+klewNcqr3arE3uKsE6CLtBCQ2kJmfTmb+uR+3bt265u0gEsIDZBgLVBgLVJjqbWT8kE/G2uPu5xfhoCFXjb3OvX9tqIOA/o0cq87g2A8X+uwuD80+F0K7E+eiY7kkF4cdh0m3pnPUcRRwpylerqZOncrChQu9loWGhjb78Y899hjbtm3j/fffJzExkaqqKrZu3UpVVZVnHaPRyOjRo7n11lt55JFHzrqdp59+mtWrV7Ns2TL8/f154oknmD59Olu2bDnr+qmpqdx///3k5eWd89j69+/Pzz//jMPhYMuWLTz44IOYTCY+/fRTGhsbmTp1KjfccAMfffQRDoeD+fPnM2XKFAoKClCpLr55EO0SGKenp7Ny5UpiY2PZtGkTs2bNIioqismTJzdZ//nnn2fOnDme2/X19XTr1o0JEyYQ3AZlxvLy8jAajdx666107969WY+pW3YEC1Wo+wYw7vYRF3wMF0JyuahdtIiqz/7lrjoRF0vE22/TNz7+wjd+//3Yi4qoWbiQhm+/Q5d3nJiFC9H060fgIw9jmDQJh9PJup9+YqRMRu3Hn+AodJeuU/fuTfAzc9CPGtXhaQz1lWb+9+ZuwEnSpBiSJkbjsDqxW53Ybe4A2W51Yre6sFud7vtsJ5c5Tyxzed8+cb/N7MRWrcRWraTuoLtGalxSMHGDggmM0LdZxYd96wvZme4epdUYlIy+tTe9rvjtF1G73c66deu46qqrWvxi43S4yN1bSdamEkpz6jGXqjCXureh1ikYOaMXfYaHXfQpKR3lQs6F0Lba+lxIJ/pii/+Fs6u11rLi2AqWHVlGsdFdNUeGjLHRY5kSOoUb6BpziTqaRqMh4gIqP61cuZL33nuPadOmARAXF8eQIUO81rnnnnsAzhnE1tXVsWDBAhYvXszEiRMBWLhwIf369SM9PZ0RI1oXzyiVSs9zu+2221i/fj0rV67k008/JTs7m+rqal555RW6desGwPz580lKSuL48eP07t27VfvsTG0aGJvNZubNm8e3337LtddeC0BSUhJ79uzh7bffPmtgrNFo0GiaFudXqVRt8iJnPjGy6efn16zt2UuNWPa7P6EFTOnRqW967qoTz2HcuAkAv2uvJeLll9s0f1cVF4f+5Zexz5pF9cJF1Hz1FdaDBymd8wzqnj3xu2Um3ZYspTLfPYSpCA0h7A9/wP/mm5EpOr4eqtPhYsOiQ9gtTiJ6+jNyeu82nZxVX2kmd28lOXsqKDlaS2VBI5UFjexcfRz/MB09k0PpmRxKeJxfqxojuLvHZXnqAscNDGb83QktalDRmv8NlQr6jYim34hoKgsbydxYyJEdZUT1DWTcHfH4BF58DTK6grZ6nWpLJruJb49+S4xPDKOjR6OQX9p1i/dU7GGNeQ17du/BiROHy4HdZfdcPLedZ9z+jfv1Kj2JwYkMCB5A/5D+DAgZQJSheQ1t2pPFYSG/IZ9ATSCh+uaPRraFg1UHWZK9hDW5a7A63emPfmo/ZvSZwa3xtxLjG+M1utkWJEnylGzsSEq1vMPPdUREBGvWrGH69On4trL51a5du7Db7V6xVkJCAt27dyctLa3VgfGZdDodthP9CeLj4wkODmbBggXMmzcPp9PJggUL6NevH3FxcW2yv47WpoHxybxgudw7UFEoFLhcHf/H7XQ6sVjcJa+am5ZR99NxkHC3bm5FCbW2YsrIoGjOM6eqTvzpBQJuuaXd/llVYWGEz32W4EcfoebLL6n+z3+x5eRQ+eZb6ACZTkfwQw8R/MD9yA0dM7HubNK+PUb58QY0eiVXP9y/zSsW+IXoGDSpG4MmdcPcYCN3nztILjhYTV25md0/5bP7p3z0/mp6DnIHyVHxAec9DsklsX9jEWnLj+Kwu+sCj7m1DwkpHVPx4XQhMT6MvyuBcXfGd/obvdC2NhVu4rX01ygxlgAQZYjilvhbuLn3zQTrOr7RT3uyu+x8tOcjFuxfgIQER9tu20a7kR2lO9hRusOzLEgb5A6WQwZ4AuYQXUjb7fQ0VqeV3LpcjtYe5VjtMc+lsLEQl+R+L400RDIwZCBJoUkkhSbRL6gfWmXbTpa1O+38nP8ziw8uZk/FHs/yhKAE7ky4k6k9pqJTtrzZT3M5bC4++0Mr0gUv0KPvjUOladkHyu+//96TcwvuQgXLli1r9uM/++wz7rrrLoKDgxk0aBCjR49m5syZjBo1qtnbKC0tRa1WExAQ4LU8PDyc0hPNvy7Url27vEakfX19SU1N5aabbuLVV18FoE+fPvz4448oL9KqVC0+6sbGRo4ePfUKlJuby549ewgKCqJ79+6MGzeOP/7xj+h0OmJjY9m4cSNffPEF//jHP9r0wJvDZHLP8JfJZOh05//ntebXY8mqAhn4XdX2tX6bo0nVibg4ot9956xVJ9qDMjCQ0KeeIujBB6lZsoTa/y2nIiyM5DdeR9fJHety91awd30BAJPuT2z3igk6XzWJo6JIHBWFzeLgeGYVuXsqyMuswlRnI3NTEZmbitDolcQODKZncijdE4ObvKA2VFvY8MVBCrNrAIiOD2Tiva3rHteWRFB86ag0V/LG9jf4Me9HAML14VicFoqNxbyX8R4f7vmQq2Ov5vaE20kOTb7oz31BQwHPbXqOfZX7ABioGkhKfApalRaVXIVKoUIlV6GUK9235WfcVpxl2YnlSrmSKnMVmZWZZFZlcqDyAEdqjlBtqWZz0WY2F232HEeEIcJrVDkxOBE/dfMb0FidVvLq8jwB8NHao+TU5VDQUOAJgM/kq/al0dZIibGEEmMJPx3/CQClTEnfoL6nguWQJGL9Ylt1rstN5Xxz+BuWHV5GpbnSs/2r4q7izoQ7GRQ66KL/G2prEyZM4OOPP/bcNrRwAGns2LHk5OSQnp7O1q1bWb9+Pe+99x4vv/wyf/7zn9v0WE8P4J1OJ1ar1WvZ3XffzSeffOK5vX//fnx8fHA6ndhsNq699lo++OADwP2t/EMPPcSoUaNYsmQJTqeTt99+m2uvvZYdO3Y0K/bqalocGO/cuZMJEyZ4bp/MD77vvvtYtGgRS5cu5fnnn+euu+6iurqa2NhY/vKXv3RKg4+TgbFOp2syin029T+5J9nprwhHFXbhE/9aylFTQ3E7p040l8LHh5BHHsH//vs5sGYNyhZMImgPDdUW1n9+EIBBk7rRI6l9RmrORa1V0mdoOH2GhuO0uyg8VEPOngpy91ZgbrBzeFsZh7eVoVDJ6Z4YRM/kUOIGhpC7r5LNXx/GZnGiVMlJmd6bgeOiW5WGIQhnckkuvj3yLX/f9XcabA3IZXLuTbyXxwc9jlwmZ23eWr4+9DX7K/ezJncNa3LXEB8Yz20Jt3Ftj2vRqzr+de5CfZ/zPa+lv4bRbsRX7cufh/8ZW6aNaUnT2iytJUQXQnxQPDOYAbgD2EPVh8iszORA1QEyKzPJrcul1FhKqbGUn/N/9jw21i+W/sHuQHlAyAASghKQy+Tk1eV5gt9jtcc4VnfsNwNgP7UfvQN60yugF70Cenl+DtYGY3KYOFB5gH2V+9hXsY/9lfupNFeSVZVFVlUWXx36yrONgaEDSQpJ8gTM/pqzl0GUJInd5btZkr2En4//jENyeH4Xt/a9lZl9Z3Z4+oZSLefR98Z16D5P7relDAbDWfNp/fz8qKura7K8trYWf3/vc6FSqRgzZgxjxoxh7ty5vPbaa7zyyivMnTu3WQ3FIiIisNls1NbWeo0al5WVeeU/79mzx/Pztm3bmDt3LqmpqV7HfLr4+HhWrlyJUqkkKirK61gWL15MXl4eaWlpnjhr8eLFBAYGsmLFCm6//fbzHndX0+LAePz48Z7JCWcTERHRZGZmZzkZGDcnjcJyrBbr0VpQyPCb1LxJem2po1MnLiZOp4uf/t8BrCYHYbG+pNzcq1OPR6GSEzsgmNgBwYy7M57SnDp3kLyngvpKC7l7K8ndWwkyPB0Tw3v4Mfn+RALCL75AROiacupyeHnry2SUu6vBJAYnMj9lPonBiZ51bup9Ezf1vokDlQf46tBXrMldw6GaQ7yS9gr/2PkPru91PbfF30avgM79n2oOo93IX9L/wqqcVQBcEXYFb4x5gxBNCGsy17TrvjUKjSdl4aRGWyMHqw+6R5ZPBMxFjUUcrz/O8frjrMl1H5NCpkBC+s0R4JNB7+nXwdrgc77+G1QGhkcOZ3jkcMAd1JYYS9hXuY/9FfvZV7GPg9UHqbfVs6VoC1uKTlUkiPWL9RpV7u7XnXXH17EkewnZ1aeqM10RdgV3JNzBpO6TUCk6J49eJpO1OKWhq4mPj+enn35qsjwjI4O+52mylZiYiMPhwGKxNCswHjJkCCqVivXr1zNjhvtD3aFDh8jPzyclJcWz3ukBfGFhIUql8jcnyanV6nPebzKZkMu9c7JP3u6MFNq2cHEmgDST0eguNn6+wFiSJOp/zAPAMDwCZQc2Nejs1ImLwfaVOZTm1KHWKZnyyAAUyq7TCU0ulxHVO4Co3gGMmtGbqqJGd3vmPZVUFTUiV8q48vqeJF/VHbkYJRbagM1pY8H+Bfxr/7+wu+zolDqeSH6CO/vdiVJ+9pf0/iH9eSXkFZ4Z+gwrjq7gq0Nfkd+Qz5LsJSzJXsKwiGHcFn8bE7tPRCXvWpMJAfZX7Gfur3MpaChALpPzWNJjPJL0CEq5stPqF/uofRgWMYxhEcM8y6ot1RyoPMCBqgMcqDxAZlWmJxXBV+XbZPS3V0AvQnWhFzwAIpPJiPKJIsoniqlxUwF3fvDhmsOnguXKfZ6g/Xj9cb7P+b7JdrQKLdf2vJbbE24nIUi8B7WFxx9/nA8++ICnnnqKhx9+GI1Gw+rVq1myZAmrVq3yrDd+/HjuuOMOhg4dSnBwMFlZWcybN48JEyZ4RnCrq6vJz8+nuNhdDeTQoUOAe0AyIiICf39/HnroIebMmUNQUBB+fn48+eSTpKSktNnEuzNdddVV/PGPf2TWrFk8+eSTuFwu3njjDZRKpVd2wcXkkg6MT44Yny/Xx5JdjS2/AZlKjt+Ejhst7kqpE13V8QNVZPzorogx4e4E/EK6br6STCYjJMaXkBhfhl/fk4ZqC0q1HJ3P+T/pC0Jz7CrbxctpL5NblwvA6OjR/GnEn4j2iW7W4/01/tzb/17uTryb9JJ0vsr+itTCVM9Es1BdKDP6zmBmn5mEG1rXEKAtuSQX/878Nx/u/hCH5CDSEMkbY97givArOvvQzipIG8SYmDGMiRkDuAddyk3lAITpO7Ycokqhon9If/qH9OeOhDsAqLPWsb/SPaJ8MmCut9UT7RPNHQl3cFPvm86ZaiG0Ts+ePdm0aRMvvPACkydPxmazkZCQwLJly5g6dapnvSlTpvD5558zb948TCYTUVFRXHfddbz44ouedVauXMkDDzzguX0yTWH+/Pm89NJLALzzzjvI5XJmzJjh1eCjvSQkJLBq1SpefvllUlJSkMvlDB48mLVr1xIZGdlu+21PMum38iI6QX19Pf7+/lRWVl5wHePU1FRSU1MZMmQI119//VnXkVwS5e/vxl5ixGdcDAHX9LigfTaXKWM3RXPmdPnUCbvdzpo1a5g2re3y95rLWGtl6WvbsTTaGTAumnF3tEHt5otYZ54LwVtHn4t6Wz3v7HqHbw5/A7gDsOeHP8+UuCkX/JpRaixl2eFl/O/w/6iyuMttKWQKJnafyG3xtzE8YninvC6Vm8qZt3ke20q2AXB17NW8mPJik8BN/F+0niRJVFmqCNQEtklZv6qqKkJCQqirq2uSp3o+FouF3NxcevTo4dWFVhDaQkv+vi7pEePmpFKY91diLzEi0yjwHRvT7sckSRLV/15I+TvvgMOBOjaW6PfeFakTZ3A5Xfy04ACWRjsh3XwYNfPiKxIuCBdKkiR+Ov4Tb2x/w/OV/Iw+M3h6yNNtNrIXYYjgycFP8ljSY6zPX8/SQ0vZVbaLdcfXse74OuL84rgt/jam9pjabuXJzpRakMqft/yZWmstOqWO54Y/x829b+5yAwcXO5lM1mHnVBAuFpd0YHy+yXeSU6J+nbsShe+YaBSG9h1tcNbWUvz8PBp/+QUAv2nTiHjlFZE6cRY71uRRfKQWlUbBlIcHoFRd3BMwBKGlShpL+Mu2v7Cx0F3HNc4vjhdTXvTKaW1LKoWKqT2mMrXHVI7UHOGrQ1+x6tgq8urzeHPHm7y14y2SQpOY0G0CE7pNoId/jzYPVC0OC3/f+XeWHloKuOvlvjX2LXr4d8w3eYIgCJdFYHyuHGNTRhmOSjNygxKfMc3L0Wst8549FM6Zg6O4xJ06Me95Am67TYyAnEVhdjU71+QBMP7ueFHJQbisOF1OlmQv4Z+7/4nZYUYpV/LwwId5eODDaBQd06GwT2Af/jTiTzw95Gm+P/Y9y48uJ6sqi70Ve9lbsZd3M94l1i+W8THjmdB9AsmhyRf8VfzRmqP8cdMfOVrrrpN/T+I9zL5iNmqFyNEXBKHjXBaB8dlGjCWHi/r17kldvuO6Ide0z69CkiSqP/+c8rf/Dg4Hqu7diXn3HbSJied/8GXIVG9j3b+zQILEUZH0Hdb63vOCcLHJrs7mpa0vcaDqAACDwwYzP2V+p5VTM6gM3JZwG7cl3EapsZSNBRv5pfAXtpds53j9cT7P+pzPsz4nQBPA2JixTOw2kZSolBbVR5Ykia8Pfc3fdv4Nq9NKkDaIv4z+C6OjR7fjMxMEQTi7Szow/q0cY+O2Epy1VuR+anxS2mfmpLOujuJ5L9C4fj0AvlOnEvnaqyh8Oq/VdFcmuSTW/fsApnobQVEGRt/22zUeBeFSYXaY+Xjvx3xx4AuckhNflS+zh8xmZt+ZyGVdozxhhCHCEyQ32hrZWryVXwp+YVPhJmqttaw8tpKVx1ailqsZETWC8d3GMz5m/G82hai11DJ/63w2FGwAYFT0KF4b9ZrIexUEodNcsoGxJEnnTKVw2ZzU/+JuLew3qTuydshfNe/fT9Hsp7EXFSFTqQh7bi6Bd94pUid+w661xynMrkGpljPl4QGo1CKv+HJVbipnU+Emxncb3+WCpFpLLUuzl7LJuIkNv27AhQuny4lTcuJ0OXFIDve1y4FTOnXbKZ22zOXwWtfmsuFwuTuNXR17Nc8Nf67Du4y1hI/ah6vjrubquKtxuBzsLt/NhvwN/FLwC0WNRWwq3MSmwk28wisMDBnIhG4TGN9tPL0DenteA3eU7uC5X5+j3FSOUq7k6Sue5u7Eu7vMBwFBEC5Pl2xgbLVaPV1XzhwxbtxajKvRjiJIi2Fo29bqlCSJmv/8l7K33gK7HVVMDNHvvotuQP823c+lpvhILdtX5QAw9vZ4gqLEhMTWckkuTHYTDbYGGuwNNNoaPT832E7ctjdgdVi5psc1JIcld/YheylsKOTBHx+kxFjCX7f9let7Xc+9ifd2ene24sZivsj6guVHlmN2mN0LC9pu+xGGCF648gXGdxvfdhvtAEq50tPo4tlhz3K09iipBan8UvAL+yv3ey7/3P1PYnxiGN9tPAqZgi+yvkBCIs4vjrfGvkW/4H6d/VQEQRAu3cD45GixSqXyqm3pMjtoSC0EwO+qWGSKthudcDY0UPLCn2g40f7R96qriPzLayhaWM/xcmNutPHTggNIEsRfGUFCisgrPsnutFNqLKXYWExBXQHplnRy9+ZidBhptDfSaGuk3lbv+bnB1kCjvRGJ5pUnX3Z4GW+Pe5uJ3Se28zNpnqLGIh768SFKjCXolDrMDjPLjyxn+ZHljI0Zy/3972do+NAO/eblUPUhFh5YyNrctTglJwAJgQnEmeNIHpCMRqVBIVOglCtRyBQo5AqUMqX7tlzhdd/JZUqZ97oKuYIwfdg5O9ddLGQyGX0C+9AnsA+PJD1ChamC1MJUUgtSSS9Op7CxkP8c/I9n/el9pjN32NwW5SQLgiC0p4v7Vfg3nCu/uOHXQiSLA2WYHv2gtvuq0nzggDt1oqAAVCrC//hHAu+5W6ROnIfkkli/6CDGWisB4XrG3tH3svqdGe1GihuLKTGWUNxYTLGxmJLGEs91pbmyaZB7oHnbVslV+Kp98VX74qPyafLzsdpjbCnewjOpz/D6mNeZ2mPq+Tfajooai3hw7YMUG4uJ9Yvl31P+TXFjMZ8f+Jz1+es9X88nBidyf//7uSr2qnYLJCVJYkfpDv6d+W+2FG/xLB8ROYIHBjzA0JCh/PDDD0zrK5pK/JZQfSi39L2FW/regsluIq04jQ0FGyhuLOa2hNs87YsFQRC6iks2MD5bfrGz0Ubj5iIA/K+ORSa/8ABMkiRqliyh/PU3kOx2VFFRRL/7DrqkpAve9uVgz88FHM+sQqGUM+WRAai1l86fpCRJ1FprTwW7pwXAJUZ38FtnrTvvdrQKLZE+kUToIzBXmknokYCf1g9f1YlAV+3j/fOJAPh8pb0cLgcvbnmRVTmrmPvrXKxOKzf2vrGtnn6LFDcW89CPD3mC4gVXLyBMH0aYPozksGSO1x/ny6wvWXF0BVlVWTy76VkiDZHck3gP0/tMx6Bqm9Qbp8vJz/k/szBzoacyhFwmZ0rsFO4fcD+Jwe5qMna7vU32dznRq/RMip3EpNhJnX0ogiAI53TpRCFnOFuptoZfCpBsLlQxPmj7X1i7aQBnYyMlf/4zDT+sBcBn0iSi/voXFP6i13xzlObUkf7dMQBG39qHkJhLo1pHTm0Oq3JWsTpnNSXGkvOu76v2JcoQRaRPJFGGKKJ8oog0RBLtE02kTySBmkBkMtmp1rdD22aUUilX8tro19AoNXxz+Bv+tOVPWBwWbku47YK33RLFjcU8+OODFDUW0d23OwuuXkC4wTv3P9Yvlj+N+BOzkmfx1aGvWJK9hBJjCW/teIuP93zMLfG3cGfCnU0e11wWh4WVx1ay6MAiChrcicNahZabet/Evf3vpZtvtwt+noIgXJruv/9+Pv/8c8Cdvtm9e3fuvfde5s2bh1Kp5Mcff2T+/PkcOHAArVbL2LFj+fvf/05cXFyr9hcXF8fs2bOZPXu21/KXXnqJ7777jj179gBQUVHBiy++yOrVqykrKyMwMJBBgwbx4osvMmrUKAA+++wzFi9eTEZGBg0NDdTU1BAQEOC13erqap588klWrVqFXC5nxowZvPfee/hcohW2LtnA+MxUCketlcZt7iDF/+q4C/663nLwIIWzZ2M/ng9KJWHPPEPQ/fddVmkAF8JitPPj/8vE5ZLoPTSM/mOiOvuQLkiVuYq1eWtZeWwlWVVZXveF6EK8At8zr33UnffiIpfJeXHEi2gVWv5z8D+8tu01rE4r9/a/t0P2X9JY4gmKu/l2Y8GUpkHx6QK1gTw26DHu738/3+d8z+cHPievPo9/Z/6bL7K+YFqPadzX/z76Bjav1F+dtY6vDn3Ffw/+l2pLNQD+Gn/uSLiDOxLuIEgb1CbPUxCES9vUqVNZuHAhVquVNWvWMGvWLFQqFbfffjs33ngjc+bM4b///S91dXU8/fTTTJ8+nYyMjLNu66WXXiIvL49FixZd0DHNmDEDm83G559/Ts+ePSkrK2P9+vVUVVV51jGZTEydOpWpU6fy/PPPn3U7d911FyUlJaxbtw673c4DDzzAo48+yuLFiy/o+LqqSzYwPnPEuGFDPjgk1D380PQJaPV2JUmi9quvKfvrX5FsNpRRkcT84x/okpPb4KgvD5IkseGLgzRWW/EL1THhroSL8gOFxWEhtTCVVcdWsaVoi2dillKmZFT0KK7vdT1jY8aiU+o6+Uh/m0wm49lhz6JVavl/+/8ff9v5NyxOC48mPdqu+y01lnoFxf+e8m/+f3t3Hh9VefZ//DN7Jvu+koSw76CoiCiCsqrUvW6PglgXRK36tMVdUKzV+rT+tHVpq2Dr0tYFS1UUZFdAZd+XQBYSsodkss1+fn+cmUlCAiRhkpmE6/16hTnnzJkz1+QwyTf33Oe+k8PaduFliD6EGwbcwHX9r2NdwToW71nMlpItvrF0x6WOY+bQmVyYcmGr/7eKaov4+96/8+mhT30jTKSGpXLH0Du4tt+1cjGYEEFAURScNluXP6/eZGr37ySTyURysvrza86cOSxZsoSlS5fSv39/XC4XCxcuRKtVL/b/1a9+xdVXX43D4ei0axSqqqpYv349a9as4dJLLwUgMzOTCy64oNl+3lbnNWvWtHqcffv28fXXX/PTTz9x3nnnAfD6669zxRVX8Morr5Ca2r0btVrT44NxWFgYzvIG6jYXAxA1teOtxYrLRdEzz1D96WcAhE+YQOrvXkR3wscO4tR2ri4gZ0c5Wr2GaXcPw2juPv8N3YqbrSVb+eLIF3yT+w21jlrffUPjhjKj7wymZ03vdi2NGo2GX577S0J0Ifxp+594fdvrWJ1WHjznwU75o6W4rpg7v76TgtoCeoX3alcobkqr0aoTSaRPYFfZLt7b+x4r8lbw/bHv+f7Y9wyMGcjMoTOZljUNg9bAweMHWbx7MctyluFU1HGDB8YM5M5hdzKl9xQMWrmQTohg4bTZeG3mDV3+vA+99wmGkJAzOobZbKaiooLRo0ej1WpZtGgRs2bNora2ln/84x9MmjSpUy/cDQ8PJzw8nM8//5wLL7wQk6lj08lv3LiR6OhoXygGmDRpElqtlh9++IFrr73WXyUHje6TSNqpaYtx9bd54IaQgTGYenes/6+iKBQveE4NxTodiY8+Quydd6LRymD07VGaZ2HDp9kAjLu+HwkZEQGuqG1yq3P575H/8sXhLzhWd8y3PTksmRl9ZnBV36voE9UngBX6x70j7yVEH8Irm1/hr7v+SoOzgd+c/xu/hmNvS7E3FC+atqhDofhEwxOG88qlr1BQow4J9tmhzzhw/ABPfPcEr259lT5RfdhUtMm3/5jkMdw57E4uSr2oW35iIYQIPoqisHLlSr755hsefPBBsrKyWL58OT//+c+59957cblcjB07lq+++qpT69Dr9SxevJi7776bt956i3PPPZdLL72Um2++mRHtGByguLiYxMTEFseOjY2luLjY32UHhR4bjL19jE12HQ07ygCInNK7Q8dSFIXSl39P1b//DVotaa/8nsjp0/1V6lnDWuvgm7/uxu1S6DMqgeETegW6pFM6bj3O17lf89/D/2VX+S7f9jBDGFMypzCj7wxGJ43ucTN1zRw6kxBdCAt/WMj7+97H6rLy9IVP++V1ekPx0ZqjpIWndbil+FR6RfTisQseY87IOXx88GM+2PcBpfWllNaXotVomZQxidnDZjM0XibdESKY6U0mHnrvk4A8b3t98cUXhIeH43A4cLvd3HrrrcyfP5/i4mLuvvtuZs6cyS233EJNTQ3PPPMMN9xwAytWrECj0bB+/XqmN8kUdrsdRVH45JPG1/72229z2223taum66+/niuvvJL169ezadMmli1bxssvv8zf/vY3Zs2a1e7XeLboscHY22LM/lpQwDw8HmNaxy5yKn/zTSoXLQIg5fnnJBS3U0OtnR0rj7JrTSH2BicRsSFMvD04+xXbXXbWFqxl6eGlfFfwne/jdp1Gx0WpFzGj7wwmpE8I+n7DZ+qmQTdh0pt4dsOzfHLwE2xOG8+Ne+6Mxg0uqSvhrm/u8oXiRVMXkRKe4seqm4syRfGL4b/gjiF3sCxnGUV1RVyRdQUZkRmd9pxCCP/RaDRn3KWhq0ycOJE333wTo9FIamoqer36s/J3v/sdUVFRvPzyy75933//fdLT0/nhhx+48MILOe+883wjSQC89tprFBYW8tJLL/m2JSU1XpQcGRlJdXXLoT6rqqqIOmFUrJCQECZPnszkyZN5+umn+cUvfsGzzz7b5mCcnJxMaWlps21Op5PKykpfn+qepscHY321G9AQek7iqR9wEpXvvUf5a68DkPT4Y0Rff72/SvQrRVE4uq+SfRuKCAkzMGRcasC7KdRV29i+Ip/d6wpx2tXpuWNSwpg8ewghYcHVl7O8oZx3d7/L59mfU2Ov8W0fHDvY12843hwfwAq73jX9rsGkM/H4+sf575H/YnPZ+N0lv8Oga/+5K6krYfY3s8mvyfe1FHdmKG7KqDMGbHxmIcTZISwsjH79+rXYXl9f77vozkun0wHgdqu/F81mc7PHxsbGYrFYWj0ewMCBA9myZUuL7Vu3bmXgwIGnrHPIkCF8/vnnp9ynqbFjx1JVVcWWLVsYPXo0AKtWrcLtdjNmzJg2H6c76ZHB2Ol0YvNcyWqsVVsldVHt/2ik6pNPKHnxdwDEP/QgsTNn+q9IP3G73GRvLWXb8nzKjzZeCLZ7bSGJmREMHZ9G//OSMJh0XVaTpaKBbcvz2fd9ES6n+sZPyIhg9PRM+oxM8MvEKv7iDcT/PvBvbC71/0xSaBJX9rmSGX1m0C+m9R9MZ4vpWdMx6Uz8au2vWJ63HLvLzisTXjnt5CFNldaXctfyu8ivySc1LJV3pr5DanjPu5JZiLNdveX0Exadba688kr++Mc/8txzz/m6UjzxxBNkZmZyzjnndOiYjzzyCJdccgkvvPAC1113HS6Xi48++oiNGzfyxhtvAFBRUcGNN97I7NmzGTFiBBEREWzevJmXX36Zq69ubCgoLi6muLiY7Gz12p9du3YRERFBRkYGsbGxDB48mGnTpvn6KjscDh544AFuvvnmHjkiBfTQYOxtLdZoNBjqFECDLqJ9rVyWr76i6OlnAIidPZv4OXP8XeYZcdhc7NtwjO3fHqWmwgqA3qhl8EWpNNTaObKtjNK8Gkr/sZ/vPz7EwDHJDB2fRlwHu5O0RVVJPVu+yePgpmLcbnUa4+Q+UZx3RW8yhsYGVdeJ8oZyFu1exL8P/BurS/3+jUgYwb0j7mVc6jh02q77QyLYXZZxGa9d9hoPr36YNQVreHDlg/y/y/5fm7qTlNaXctc3d5FnySM1LJV3p71LWnhaF1QtRNdy2u3UVJZTU15OTUUZNRXl1FaWU1NRjkarJTIhkcj4xGa35ojIoPq52F4Om5XCfXvI3bWd/J3bOHr4UKBLCjqXXXYZH374IS+//DIvv/wyoaGhjB07lq+//hqzuWNd8i666CKWLVvGc889x//93/+h1WoZPnw4K1euZNiwYYA6KsWYMWP44x//yOHDh3E4HKSnp3P33XfzxBNP+I711ltvsWDBAt/6+PHjAXyjaAB88MEHPPDAA1x++eW+CT5ee+21Dn5Hgp9GURQl0EU0ZbFYiIqKory8nLi4js1OV1xczFtvvUVYaCi3VI4FDaQtvBiNrm0/gGrWrKHggQfB6ST65z8necH8oPnh1VBrZ9fqAnatKcRap05La44wMGJiL4aN70VIuPoHQL3Fzv6NRexZX4il3Op7fHKfSIaOT6PfuYnojacPf77Z1q44+WxrFYW1bPk6j+zNJXj/N/UaFMN503uTOiDa972zOq18f+x7hsYN9fsFV21V3lDO4t2L+deBfzUG4vgR3D/q/qAfnaAt56Iz/VT8E3NXzqXB2cDopNH8+fI/n3Iq5rL6MmZ/M5tcSy4pYSksmraox4TiQJ8L0agrzoXL6aC2skINvZ6w6w2/3iDcUGNp93H1JpMvJEclJBLRJDhHJSQSFh0TVCMfKW43JTmHydu1nfxd2yjcvxeX0+m73+pw8NSS5VRXVxMZGdmuY1utVnJycsjKyiKkm/QrFt1He/5/9egWY7NJ/WtMG2Zocyiu2/QDhQ/9EpxOIq+6iuRnnwmKsGQpb2D7inz2bSjC6VC7J0TGh3DO5AwGjU1pEXJDI42cOzWTcyZnULD/OHvWF5Kzo5ziIxaKj1j47t+HGHhhMkMvSSM25eTh5lRK8yxs/iqXnB3lvm29h8cxenpvkvs0vwDguPU4c1fO9Y3uMDJhJJMzJzMlc0qX9DWtaKhg0e5FLQLxnFFzGJc6LijOcbA7P/l8/jL5L8z5dg5bSrZwz/J7eGPSG0SZWg6BeGIofneqtBR3RzUV5RTu30NJzmEUtxudXo9Wb0BvMKDV69H5vgy++3R6PTqDd73p/Y3bDCEhhISFB9X7zmG3UZ6XS8mRbCqLCqitqPCF37rqKmhDG5LeZCIiLoGIuPhmX26XG0t5KZbSEvW2vIy645U4bTYqC49SWXi01ePp9Hoi4hKITEggMiGpSYtzAhHxiUTExaHTd+4fZtWlJeTt2kbezu3k796Btbam2f0RcQlkjhhF5vBRhKVl8NSS7j9spTi79exgbFD/KtBFGNv0uIbt2zl6//0odjvhl11G6ou/RaML7EfqZfk1bFueR/aWUt/P5YSMCM6ZkkHfcxPRnqa/rkarIX1ILOlDYqmrtrFvQxF71x+jptLKzlUF7FxVQEq/KIaNT6PvOYnoDKdvnTiWXcWWr3LJ31vpeRLoe04Co6f1bvWCv8LaQu5bcR+5llxCdCHYXDZ2lO1gR9kOXtn8CsPjhzM5czKTMyfTK8K/Q7hVNFSweI/aQuyd4Wx4/HDuH3W/BOIOGJU4ir9N/Rv3rriXneU7+cXyX/D25LebTWhS3lDOXcvvIteSS3JYMu9Mfcfv51X4n+J2U3msgIJ9eyg8sJfC/XuxlJV02vOZIyKJz+hNfEYmCRlZxGdkEt8rs0tGIXBYrZTm5VByJJvSnMOU5GRTUZCP4rkYqjU6g0ENurGewBvvDcAJhMfGERGf0K6w77Tbqakow1JWpoblshIsZWpori4robaiApfTSVVJEVUlRa0fRKMhPDqGiIREIuMSiIhP8AXnyPhEX03tYa2r5ejuneTt2k7erm1UFTd/bqM5lPShI3xhOCYlzfeam041LER31SODsXcMY7NWvUBI24ZgbD1wgPx77kWpryd07IWk/fEPaAL0EamiKBTsP8625Xkc3Xfctz1jSCznTMkgbWBMhwJdWJSJ86b35typmRzdW8me9YXk7iynKLuaouxq1ocdYtBYtRU5Oqn5lLjeUS82f5XLsUNVgBq6B5yfxLnTMk/a6nyg8gBzvp1DWUMZyWHJvD3pbcKN4Xyb9y0r8lawpWQLu8p3sat8F3/Y8geGxA1hSuYUpmROIT0yvd2v0auioYL39rzHPw/80xeIh8UN4/5R93Nx2sUSiM/A0LihvDv1Xe5Zfg/7K/cz++vZ/HXKX0kITaC8oZzZ38wmpzqH5LBk3p36LukRHT+PovO4nA5KjmRTuH+vLwif2Bqo0WhJzOpDSv9BGEwmXE4nLqcTt9OBy+HwrbucDs92z7JDvXW7PPc32dft2behxsLRPTs5umdn0yckOjFZDckZvYlP701CZm+ik1PQdrDfv72hntLcI5QcOUxpTjYlOYepLCxAUVqG4NCoaJKy+hKXnqm2ynpbf+MT/N4fWG80EpOSRkxK65+kuF0uaisrqPYF5lI1RJeVqIG6vAyXw0Ht8Upqj1dSxP5Wj2M0h3pamBvDctPgbI6MpCT7kK9VuPjwoWbfG41WS0r/QWQOH0XmiHNI6TcAbYAbjIToTD0yGHtbjEM0aiC2A4pbOeloCLacHPJn34XbYsE8ahTpf/oT2g5On3gm3C43h7eVsW15PmX56i8ojVZDv9GJnDMlg4R0/wy/ptVqyBwWR+awOGqP29i34Rh7vztG7XEb2789yvZvj5I2MJqhl6SRPiSahhIdn//fDsry1Jq0Og2DxqZw7tQMohJCT/o8PxX/xC9X/ZIaRw39ovvx5qQ3fX2Lbx18K7cOvpXyhnJW5q1kRd4Kfir5ib0Ve9lbsZdXt77K4NjBaneL3lPIjMxs02urtFayeM9i/rm/eSCeM2oOl6RdIoHYTwbEDGDRtEX8YvkvOFx9mFlfz+Kl8S/x5HdPklOdQ1JoEu9OkVAcTGz19RQd3Efhgb0U7N9D8aGDOB32ZvvojSZS+g8kbdBQ0gYNIbX/QIzmk7/HO8phs1JRcJTy/FzKj+ZSlp9HeX4u9dVVvhbS7J8aZynUG4zE9konIaM38eme0JzRm7DomBNeY52nBfgwJUfUEHy8qLDVbhBhMbEkZfUlMasfSX36kdSnL+ExcUHzM0Kr06mtvwmtDzWqKAr11VXUlJf5umc0XbaUl2GtsWBvqKf8aB7lR/Pa/Nyxqb3IHHEOmSNG0WvwcEyh/v8/IESw6pEX33355Zf89NNPXJA0jBF5SRy0uiiOMXP+Fb3pO7p59wNHYSG5/3M7zqIiTIMHk/neYnTtvGjgTDnsLvZvKGL7t/m+C+X0Bi2DL05l1OXpRMZ3/mQSbpebvD1qK3Le7grw/K/Q6TW4nOqKzqBl6MWpjJqcQUTsqT/u/DbvW+atm4fdbefcxHN57bLXWu2L2lRFQwWrjq5iee5yfir+CZfi8t03IGYAUzKnMLn35FanXm4tEA+NG8r9o+7vMYE4GC/4OlpzlLuX301hbaFvW1JoEoumLjqjFv9gF4zn4kS1xyvV1uD9eyjcv5eyvJwWraQhEZGkDRxCr0FDSBs0lMSsvuj0gWsvqa+uoiw/l/L8PMqP5qrBuSAfp2f4zROZIyKJS8/geE0deruV6pN0OQiPiycpqx9JWX1J6tOPxKy+hMfEtrpvT+KwWrFUlFFTVorF022jprxxubayHLfLhTkySm0RHj6KjOGjiIxP6NDzVVRUEB8fLxffiaBz1l985+1KEeJSX57VDceL6lj+zh5ivsxh9PTe9D8vEXdlBXmzZ+MsKsKYlUXG3/7apaG49riNvd8VsmttIdZadYSJkHDPCBOXpmEOb1vfaH/Q6rRkjYgna0Q8NZVW9n53jL3fH6O+2o5GpzBiYjrnTulNaOTpa/r3gX/zwg8v4FbcTEyfyMvjXyZEf/ofdHHmOG4ccCM3DriR49bjrMpfxYq8FfxQ9AMHjx/k4PGD/Gn7n+gX3U8NyZmTiTPHsXjPYj7a/1GPDcTBLD0incXTFnP38rvJteSSGJqodp/owaE4GDnsNspyj1B06CDFhw9SlH2A6pLiFvtFJSaRNnAIaYOHkjZwKLFpvYLqPRIaFe0LaF5ut4vq0hLK83LV0HxUDc5VxUU01Fgo2Lu72TEiExJJ7N3X0wqshuHQqOiufSFBwhASQlxaOnFprb8f3W4X1poatZtIEI1+IUQg9chg7O1KYbR7grGiMOiiFHK2l3G8uJ5vF+3lp/8eJvPgUmLzCzClpZGx6F30HWyhbg/FrfYf3r2ukJyd5Sie8X4j40MYNSmDQRelYGjDMGqdKSI2hDE/68N5V/amJLeKH7atZ8zVWadtGVMUhbd2vMUbO9QBxq/vfz1PXfhUh6YRjgmJ4foB13P9gOuptlWzKn8Vy/OWs6loE9lV2WRXZfPGjjfQa/S+aZuHxA3h/pH3M77X+KD6Zd/TJYcls3jaYr448kWXjTJyNlMvkitUA/ChAxQfPkhZXg5ul6v5jhoNCRm9fd0i0gYNISK2+83eqNXqiElOJSY5lf5jLvJtd9htVBYcpTjnMNt++pGLp0wjtd8AQiNP/cmUaKTV6s7aPxqEOJkeHYxNNvUvYJsbxszowyU39mfX2gK2L8+nutzGztipmMeez/nXDkJ7kn5c/mKtdbBvgzqucHVZg297av9ohl2aRt9zEtDqgusvdp1OS0JGBNrdp9/X5Xbxwg8v8PHBjwG4d8S9zB011y8BNcoUxbX9r+Xa/tdSbatmbcFalucuZ8OxDTjcDgbHDub+Ufdzaa9LJRAHSJw5jplDg29myJ6g9nglxdkHmwThQ9gb6lvsZ46MIqXfAFL6DSS53wBS+g/EFNqxoRi7A4PRRFKffsSmZ5JbayVz+Kig7dYihOg+2h2M161bx+9//3u2bNlCUVERS5Ys4Zprrmm2z759+5g3bx5r167F6XQyZMgQPv30UzIyMvxV9yn5Wozr1KBpVRTMkQZ0Oi3nTEgm+oPnOFQcRn7GZBqMsaz7spRtmyyMnpbJoLEp6PT+CaiKolB8xMLudQUc3lLmmx7ZGKJj4IUpDB2fSlxq581E11VsLhvz1s1jZf5KNGh4csyT3DTopk55rihTFD/r+zN+1vdn1NhrKK0vpU9UHwnEotN5P9KvKDhKWV4O5bt38aOtFlNoKMYQMwaTCX1ICEaTGUOICYMpBINnuzHEjN5oPO3H1XZrAyVHsinOVrtDFGcfoqairMV+eqOJpD59Se430BeGI+IT5H0ghBBnqN3BuK6ujpEjRzJ79myuu+66FvcfPnyYiy++mLvuuosFCxYQGRnJnj17uqwzvaIojaNSOD1dEsxqKFbsdgp++UvsP20kKyyMi16+l8PlkWxbnkdNhZU1Hxxg87JcRk/rzeCxKW0a07c19gYnB38sZve6QioK63zbEzIiGDY+jf7nJ2Ew9Yzhbix2Cw+ufJCtpVsxaA387pLfMaX3lC557ghjBBFG/4zUIYSX2+WiqqSIioJ8KgqOem7zqTxWgMvhaLbvpr072nVsvSckG0ze4Bziu60uLaHiaH7LYcQ0GuJ7ZfhCcHK/AcSnZ8qQWUIEiVmzZvHee+8BYDAYyMjI4I477uCJJ55A3+Ri1uzsbM455xx0Oh1VVVUdfj6NRtNqo+SsWbOoqqri888/ByAnJ4cnn3ySNWvWUFlZSXx8PKNHj+all15i0KBBALzwwgt8+eWXbN++HaPR2Gpd+fn5zJkzh9WrVxMeHs7MmTN58cUXm7229pgwYQJr164FwGQy0adPHx544AHuv//+Fvt+//33XHrppQwbNozt27d36Pnaq92vavr06UyfPv2k9z/55JNcccUVvPzyy75tffv27Vh1HWC1WnF7Bmk3YcChKJgiTSguF4W/mUfd2nVoQkJIf/stQs8ZxjnAsEvT2Lv+GFu/yaO20sbaDw+wZVku507NZPC4FPSGtv0CKjtaw551hRz8sQSHTe3vpzdo6X9+EkPHp5HUu2tHu+hspfWl3PftfRw6fohwQzivXfYa5yefH+iyhGgTl9NBVXHLAHy8qLDZNLdN6Q1GYtPSiUlNo7iikvTUVJx2Gw6bDYfNisPa0GTZ82VrnJLdabOddIQFr/C4eDUA91W7QyRl9e2UIdOEEP4zbdo0Fi1ahM1m46uvvmLu3LkYDAYef/xxQB3J5pZbbuGSSy5hw4YNpzzWrFmz6N27N/Pnz+9wPQ6Hg8mTJzNw4EA+++wzUlJSKCgoYNmyZc3Cr91u58Ybb2Ts2LG88847LY7jcrm48sorSU5OZsOGDRQVFXHHHXdgMBj47W9/2+pzz58/n9zcXBYvXnzS+u6++26ee+456uvr+fvf/87cuXOJiYnhlltu8e1TVVXFHXfcweWXX05JSedNNnQiv/YxdrvdfPnll/zmN79h6tSpbNu2jaysLB5//PEWf9l42Ww2bE1+UVgs6nzzDocDxwmtM23hfbxBb0CPjhq3Qki4nsInn6Lm669Bryf51T9iGDmy8fgaGDI+mQEXJrB/Ywk7vj1K7XEb6/55kM3Lchk1qReDLkpuMe0ygNPu4si2cvZ+V0RpbuPg+NFJZgZfnMKACxIxhRp8r6m78dZ8Yu25llzmrp5LUV0R8SHx/GninxgQM6Bbvsbu4mTn4lScdju2ulqsdbVYa2ux1tVgq1XXbXW1uJxOFEVBcbvVL0VBUZosu90o7hO2KQqK2+W59eyjNNm/6a3iBrfSynGVxsco6nPgWXa73b5xZ3V6gzq9sOdLbzD6tumNRs/0w0b0vn2aLjdZ1xtw2m1UHivwTMFbQFXxsZYXrHnoTSZiU9OJTetFbFq656sXkQmJaLU6HA4HK1as4JLJk09/UarbjdNuV8Oyzdo8ONusOG02HFYr5sgokvr2b3UYMXlfnVxH3heic5zN58BkMpGcrI7TP2fOHJYsWcLSpUt9wfipp55i0KBBXH755acNxv6wZ88eDh8+zMqVK8nMVOcByMzMZNy4cc32W7BgAcBJQ+zy5cvZu3cv3377LUlJSYwaNYrnn3+eefPmMX/+fIzGjo2eFRoa6vt+zZ8/nw8//JClS5c2C8b33Xcft956KzqdztcK3hX8GoxLS0upra3ld7/7HQsXLuSll17i66+/5rrrrmP16tVceumlLR7z4osv+k5MU6tXrya0A4OKe4dq0ymeC+8UhYYDO6hZ9zmKRkPRLTdzsLoavvrqpMeIvgAMBQZqjhipr7az4dMjbPoim4gsO2EZDrQ6cNRpqMs3Ul9owO3w9OvTKJiTnYSlOzDF1nC0vpSja9r9EoLSihUrfMtHnUf5R90/qFfqidPGcYfhDrI3ZpNNdgAr7F4URQ2CeIJm4627lW0K4AmTTgf/+cdi3HYbLpsNl93mWbbittubrNtw260oJwl+QqXRGzBGxWCMilZvI9VbvWdqXydQCpQWl0Fxy76+Td8XZ8xawYFSmVK3o/x6LkSHeLsx+ouiKCiOk0/T3Vk0Bu0Z99c3m82+KbJXrVrFxx9/zPbt2/nss8/8UeJpJSQkoNVq+eSTT3j44YfRdbDr1caNGxk+fDhJSUm+bVOnTmXOnDns2bOHc845xy/1ms1m7PbGCYcWLVrEkSNHeP/991m4cKFfnqOt/N5iDHD11VfzyCOPADBq1Cg2bNjAW2+91Wowfvzxx3n00Ud96xaLhfT0dCZOnNihCT4OHjzIwYMHiQqNgDp1DOOIwiMAJC18nv4/+1mbj+VyuDn4Ywnblh+lttJG9f4Q7IURRCeFUpJd7dsvPNbE4HEpDLwwqU3j/HYn3paxyZ6Wse+Pfc/C9QuxKlaGxA7h9QmvExMSc/oD9WC2+nqqS4vVr5Lmt7a6OhS32grqazF1d+0Peo1GiyksjJDwcExhEYSEhRESHoEpLAyd3oBGq/4S0Gi06rJW49nm2a5tcqvVotVqwbO/d9m3zbOvuu45lvfYGo1nvfm+jc+taVaLgoLb6cTpcOCy23E5Heqyw65OOeywe9YdjcueqYqdnv1dDgdOz/5anZbY1KYtwOmEx3ZsprMT3xcicORcBA9vEPQXxeHm2DOd37p6otTnLkLTwWFTFUVh5cqVfPPNNzz44INUVFQwa9Ys3n///XZPenIm0tLSeO211/jNb37DggULOO+885g4cSK33XYbffq0nCTrZIqLi5uFYsC3Xlzccqz09nK5XHz00Ufs3LmTe+65B4BDhw7x2GOPsX79+g73Yz4Tfn3G+Ph49Ho9Q4YMabZ98ODBfPfdd60+xmQyYWpl+mWDwdChH3LebhlmrXpMq1vB4LCQ8MuHiLv++nYdy2CAERMyGHpxLw78UMyWZblYyq001FSDBnoPi2Po+DQyhsY1m02vJzIYDCzLX8az3z+LU3EyLnUcf5jwB0INPb/vo6Io1FUdp6qkiOqSYnXK2uLG5YYaS6c8rzeEarQ6XzB1AdFx8YSER3i+wgkJj8AcHoEpLLzZuhqEwzGZQ2Xw/k7S0Z9Twv/kXATe2fz9/+KLLwgPD8fhcOB2u7n11luZP38+t99+O7feeivjx48/6WM/+OAD7r33Xt+6zWZDo9Hwyiuv+LYtW7aMSy65pF01zZ07lzvuuIM1a9awadMmPv74Y37729+ydOlSJk+e3P4XeRLr169vdu2Z3W5HURQ++eQT37a3336b2267zbf+xhtv8Le//Q273Y5Op+ORRx5hzpw5uFwubr31VhYsWMCAAQP8VmN7+DUYG41Gzj//fA4cONBs+8GDB319XDqbb0QK1DeoTQGjvYbQMWM6fEydXsuQcakMvDCZw1tKqauy03d0ApFxnT9Vc7D4+76/8+q2VwG4qs9VPHfRcxh0PeuHYL2lmtIj2VR5w29JMdUlRVSVFp/2gilzZBTRSclEJ6UQlZTiWw6NikKj1TVrWdU0+fKtazS+/bzrJ+oO0xALIYS/aAxaUp+76PQ7dsLzttfEiRN58803MRqNpKam+lo6V61axdKlS30hV1EU3G43er2ev/zlL8yePZuf/exnjGmSUebNm0daWhoPPfSQb1taWppvOSIigurqxk+tvaqqqoiKaj7BTUREBDNmzGDGjBksXLiQqVOnsnDhwjYH4+TkZH788cdm27wXwnn7CJ933nnNRox47bXXKCws5KWXXvJtO7HV+bbbbuPJJ5/EbDaTkpKi/o70vIbNmzezbds2HnjgAQDPJ64Ker2e5cuXc9lll7Wp9o5qdzCura0lO7uxL2lOTg7bt28nNjaWjIwMfv3rX3PTTTcxfvx4Jk6cyNdff81///tf1qxZ48+6T8oXjF1qcLC6FeLsFvQJHZv7vSmdTsuAC5LP+DjdiVtxs6xhGd9v+x6AmUNm8uh5j6LVdP8WSIfNSuG+PeTt3kHezm2U5eWcdF+NRktEfEKT8JtMdHKKupyYjKkD/eGFEEKcnEaj6XCXhq4WFhZGv379WmzfuHEjribXevznP//hpZdeYsOGDb6wGxERQURE49CjERERxMbGtno8gIEDB7JlyxZmzmycVMnlcrFjxw5+8YtfnLRGjUbDoEGD2nXx39ixY3nhhRcoLS0lMVGdCG3FihVERkb6egeYzeZmtcbGxmKxWE5aP0BUVFSr90dGRrJr165m29544w1WrVrFJ598QlZWVptr76h2B+PNmzczceJE37q3f/DMmTNZvHgx1157LW+99RYvvvgiDz30EAMHDuTTTz/l4osv9l/Vp+C9+M7kUN9M3hZjfXz3mwq1qzjdTuocddTYa6ix11DrqMVit1Brr2VN/hq+t6mh+H9H/y+zhs0KbLFnwO12UXIkm7yd28nftZ1jB/e1GJYrNrUXMalpRCcle1p+1dbfyIREdHpppRVCCNF2gwcPbra+efNmtFotw4YN6/AxH330Ue666y4GDRrE5MmTqaur4/XXX+f48eO+YLx9+3aeffZZbr/9doYMGYLRaGTt2rW8++67zJs3z3es/Px8Kisryc/Px+Vy+Vp++/XrR3h4OFOmTGHIkCHcfvvtvPzyyxQXF/PUU08xd+7cVrvBnqnWvjeJiYmEhISc0fesPdodjCdMmKBeKX8Ks2fPZvbs2R0u6kz4Zr2zqcHY6lYwGVxozWdHt4cjVUcorC30BdzWwu6J6/XOU19JrEXL/LHzuXbAtV30KvxDURSOFx0jf9d28nZt5+jendjq6prtExGXQOaIUWQMH0XG0BGERZ/dFxIKIYQIbrfccguKovCHP/yBxx57jNDQUEaPHs26det8XRZ69epF7969WbBgAbm5uWg0Gt+6d3AEgGeeecY3OQngG2Vi9erVTJgwAZ1OxxdffMGcOXMYO3YsYWFhzJw5k+eee65rX3QX0iinS7ldzGKxEBUVRXl5eYdGpfjrX/9KYWEhk+0jyHQn8FW1g4m5f6D/si86odrgYLFbWHZkGZ8e+pR9lfs6fByz3ky4IZxwY7g6q5xB/UotT+WBqx/oFv1a66uryNu9wxeGa8qbD7FlCg0jfegIMkecQ+bwkUQnp3abaXSlj3HwkHMRPORcBI+Kigri4+Oprq5u9wgMVquVnJwcsrKyumymXHH2aM//r64fB6OTebtShCgGXIoC9lqMCe0P2MFOURS2lm7ls0OfsTx3OVaXOruWQWugX3Q/33TJ4YbwVpcjjBFqADY0Lhu0LX+peH/pBCuH1UrB/j3k7dpO/s5tlOXnNrtfp9eTOnAImcNHkTF8JEl9+qHVdo8+a0IIIYToWj0uGDeOSmFs7F+c0HP6F5c3lPPfw//ls0OfkWvJ9W3vF92P6/tfz1V9riI6JDpg9XU2l9NBUfZBju7eSf7uHRw7uB+3q3k/4YTefcgcPorM4aNIGzQEg0laH4QQQghxej0qGDudTt/MKSGKgXq3gsFPI1IEksvtYsOxDXx26DPWHF2DU1GDoFlv5oqsK7iu/3UMjx/ebboEtIfidlOae4T8PWoQLty3B4fN2myfyIRET4vwKDKGjSQ0MuokRxNCCCGEOLkeFYy9rcUajQYjeioVBZPdgj6xewbjY7XHWJK9hCWHllBSX+LbPiJ+BNf1v45pWdMIM4QFsEL/UxSFymMFvhbho3t3Ya2tabaPOTKKjKEjyBg2kvRhI4hOSumRfxQIIYQQomv1qGDs7V9s1pvQoMHqdnuGahsU4MrazuFysOroKj479Bkbj21EQb02MsoUxYw+M7i2/7UMiAnMbDCdxVJeSr43CO/eQe3xymb3G81meg0eRsawUWQMG0F8eqbM5CaEEEIIv+tRwdjbYmzWeaeDBoOje3SlOFJ1hM8OfcbSw0s5bjvu2z4mZQzX97+eyzIuw6Tz/5iBgVBvqebonp3k79pB/p4dVBUXNbtfZzCQNnCI2iI8dATJffuj1ckFc0IIIYToXD0yGIdgBMCmKJjtNUEdjFfkreAfe//BttJtvm2J5kSu7nc11/a/lvSI9ABWd+YcViuleTmU5h6mNOcIxYcPUn7CyBEarZbkvv19LcKpAwajNxoDU7AQQgghzlo9Mxi7vdNBQ7Tdgi4IZ71TFIXXt73OX3f9FQCdRsf4XuO5vv/1jEsbh17b/U5NQ42F0pwjagjOPUJJzmGOFxVCK0NlJ2T0JmP4SNKHjqTX4GEypbIQQgghAq77pa9T8E0H7VRflk0Bo7sBXXR0AKtqyel28vym5/ns0GcAzBwyk5lDZ5IQGrwt200pikJtZQWluYcpOaKG4NLcwy0m0/AKj4klMasvib37kNi7L2mDh8rIEUIIIYQIOj0qGHtbjE2OxumgzZGGoBqxoMHZwG/W/oY1BWvQarQ8deFT3DjgxkCXdVKK243dUsXBTd9RcTSP0pzDlOYcpqHG0ur+0UkpjSHYcyvTLAshhBCiO+iRwTjEbUBRFGwKhEYHz0f0VdYqHlj1ADvKdmDSmXhp/EtcnnF5oMsC1FbguqrjlB/No+Jonuc2n/KCPBxWK/kn7K/RaonrlUFSk5bghN5ZmEJ71vBxQgghxKnMmjWL9957DwCDwUBGRgZ33HEHTzzxBHp9Y8zKzs7mnHPOQafTUVVV1eHn6927N3l5ec22paWlUVBQAKhD1i5ZsoRrrrmmRZ1VVVV8/vnnAOTk5PDkk0+yZs0aKisriY+PZ/To0bz00ksMGqSO5vXCCy/w5Zdfsn37doxGY6t15+fnM2fOHFavXk14eDgzZ87kxRdfbPba22PChAmsXbsWAJPJRJ8+fXjggQe4//77W+z7/fffc+mllzJs2DC2b9/eoec7UY8Kxk2ng7YroHcEz3TQxXXF3LviXo5UHyHCGMGfLvsT5yadG5BaGmprqMjPo7wgv1kQPnG8YC+NTkdi774k9+nraQXuS3x6plwgJ4QQQgDTpk1j0aJF2Gw2vvrqK+bOnYvBYODxxx8HwOFwcMstt3DJJZewYcOGUx5r1qxZ9O7dm/nz5590n+eee467777bt65r58hNDoeDyZMnM3DgQD777DNSUlIoKChg2bJlzcKv3W7nxhtvZOzYsbzzzjstjuNyubjyyitJTk5mw4YNFBUVcccdd2AwGPjtb3/b6nPPnz+f3NxcFi9efNL67r77bp577jnq6+v5+9//zty5c4mJieGWW27x7VNVVcUdd9zB5ZdfTklJyUmP1V49Khg3HZXC6p0OOj3wF95lH8/m3m/vpbS+lKTQJN6a9Bb9Yvp1+vParQ1UNAu/6nLdCeMEe2k0WqJTUolPzyA+PZP49EyiklPZuG0HV151FQaDodNrFkIIIbobk8lEcnIyAHPmzGHJkiUsXbrUF4yfeuopBg0axOWXX37aYNwWERERvufriD179nD48GFWrlxJZmYmAJmZmYwbN67ZfgsWLAA4aYhdvnw5e/fu5dtvvyUpKYlRo0bx/PPPM2/ePObPn4+xgw1ooaGhvtc3f/58PvzwQ5YuXdosGN93333ceuut6HQ6Xyu4P/TMYKwYsAXJdNBbS7bywKoHqLHX0CeqD29PfpvksI7/Zz4Vh83K1mX/5diBvZQfzcdSdvK/oCITkohPzyDOE4Dj0zOJTe3VohXY4XCg2bGrU+oVQgghTkZRFBwOR5c/r8Fw5tcmmc1mKioqAFi1ahUff/wx27dv57PPPvNHiWcsISEBrVbLJ598wsMPP9zuFmevjRs3Mnz4cJKSknzbpk6dypw5c9izZw/nnHOOX+o1m83Y7Xbf+qJFizhy5Ajvv/8+Cxcu9MtzePWYYOx2u5sEYyMVCup00PFZAatpZf5K5q2bh81lY1TCKP50+Z+IMnXOaAyF+/fyzVuvcrzoWLPtYdExzcJvfHomcb3SMZqDp++1EEIIcSKHw3HSj+M70xNPPNHhlk5FUVi5ciXffPMNDz74IBUVFcyaNYv333+fyMhIv9U4b948nnrqKd/6b3/7Wx566KE2Pz4tLY3XXnuN3/zmNyxYsIDzzjuPiRMnctttt9GnT582H6e4uLhZKAZ868XFxW0+zsm4XC4++ugjdu7cyT333APAoUOHeOyxx1i/fn2H+zGfSo8JxlarFcUzXm4IBqxuRe1KEaAW448PfszCTQtxK24m9JrAy5e+jFlv9vvzOOw2vv/X+2z58nNQFMJj4zh/xnUk9O5DXK8MGRZNCCGE6GRffPEF4eHhOBwO3G43t956K/Pnz+f222/n1ltvZfz48Sd97AcffMC9997rW7fZbGg0Gl555RXftmXLlnHJJZf41n/9618za9Ys33p8B+ZrmDt3LnfccQdr1qxh06ZNfPzxx/z2t79l6dKlTJ48ud3HO5n169czffp037rdbkdRFD755BPftrfffpvbbrvNt/7GG2/wt7/9Dbvdjk6n45FHHmHOnDm4XC5uvfVWFixYwIABA/xWY1M9Jhh7W4uNWgM6tNjcroBMB60oCm/teIs3drwBwHX9r+PpC5/ulAk7ig4d4Os3/kjlMfVK1KGXTmLCzF8QEhbu9+cSQgghupLBYOCJJ54IyPO218SJE3nzzTcxGo2kpqb6WjJXrVrF0qVLfSFXURTcbjd6vZ6//OUvzJ49m5/97GeMGTPGd6x58+aRlpbWrAU4LS2t2fPFx8fTr1/r1ypFRERQXV3dYntVVRVRUVEt9p0xYwYzZsxg4cKFTJ06lYULF7Y5GCcnJ/Pjjz822+a9EM7bR/i8885rNmLEa6+9RmFhIS+99JJv24mtzrfddhtPPvkkZrOZlJQUtFqt7zVs3ryZbdu28cADDwBqjwFFUdDr9SxfvpzLLrusTbWfTI8LxiEa9eMPq6IQaa9Bn9B1F9+53C5e+OEFPj74MQD3jLiHB0Y94PdxlJ0OBxs//oCfln6GorgJi45h8j0P0Hf0mNM/WAghhOgGNBpNh7s0dLWwsLBWg+rGjRtxuVy+9f/85z+89NJLbNiwwRd2IyIiiIiI8O0TERFBbGzsSYPv6QwcOJAtW7Ywc+ZM3zaXy8WOHTv4xS9+cdLHaTQaBg0a1K6LA8eOHcsLL7xAaWkpiYmJAKxYsYLIyEiGDBkCqP2Dm76W2NhYLBbLKV9fVFRUq/dHRkaya1fz657eeOMNVq1axSeffEJW1pl3n+15wVhpnA46wVGDPq5rhmuzOq3MWzePVUdXoUHDE2Oe4OZBN/v9eUqOZLPsz3+gokAdWXjwxROYeOe9mMMjTvNIIYQQQnSlwYMHN1vfvHkzWq2WYcOGddpzPvroo9x1110MGjSIyZMnU1dXx+uvv87x48d9wXj79u08++yz3H777QwZMgSj0cjatWt59913mTdvnu9Y+fn5VFZWkp+fj8vl8rX89uvXj/DwcKZMmcKQIUO4/fbbefnllykuLuapp55i7ty5mEwmv7+21r53iYmJhISE+O172mOCsW86aJd3OmiFkBDQdMEQY9W2ah5a9RBbS7di0Bp4afxLTM70X/8cAJfTwabP/sUPS/6N4nZjjoxi8t1z6X/BRX59HiGEEEJ0X7fccguKovCHP/yBxx57jNDQUEaPHs26det8XRZ69epF7969WbBgAbm5uWg0Gt/6I4884jvWM88845u8BPCNMrF69WomTJiATqfjiy++YM6cOYwdO5awsDBmzpzJc88917Uv2o80iveKtSBhsViIioqivLycuHa09q5fv56VK1fS35nCpc4hfFHlYHzx3xjy+YedWK06ccecb+eQXZVNuCGc1y57jfOTz/frc5TmHuHrN/5IWV4OAAPGXsLls+/rkgvrHA4HX331FVdccYWMYxxgci6Ch5yL4CHnInhUVFQQHx9PdXV1u0dgsFqt5OTkkJWVRUhISCdVKM5W7fn/1WNajBsn9zDgVBRcQGhc505PfKTqCPd+ey/FdcUkmBN4c9KbDIwd6Lfju5xOfvzPx2z69J+4XS5CIiKZdNccBo695PQPFkIIIYQQ7dLzgrFixOoGg6MWYydeeLe9dDtzV87FYrfQO7I3b09+m9TwVL8dvzw/l6/ffJWSI9kA9Dt/LJN+cT9h0TF+ew4hhBBCCNGoxwRjbx/jEAxYFe8Yxp0TjNccXcOv1/4aq8vKiPgR/OnyPxET4p/A6na5+Om/n7Hx4w9wOZ2EhIVz2ez7GDTuUr+PbiGEEEIIIRr1mGDcfDpoOm066P9k/4dnNzyLS3FxSdolvHLpK4Qa/DOLXEXBUb5+848UZx8EoM+55zP5ngcJj4n1y/GFEEIIIcTJ9cBgbKRWUdTpoBN6+/U59lfuZ/7G+bgUF1f3vZpnL3oWg/bML/Zwu11s/fI/fPevf+ByODCFhjFx1j0MGX+ZtBILIYQQQnSRHhOMm3alKHejdqXowBSJJ2Nz2Xh8/eM43U4mpk/k+XHP+yW0Hi8q5Os3XuXYwX0A9B41min3PEhEXNdNTCKEEEIEgyAbKEv0EO35f9UjgrHD4cDhcABgVozY3Irfp4P+87Y/k12VTWxILM+OffaMQ7HTbufH/3zCj//5GJfDgdFsZsIddzNs4mRpJRZCCHFW8Q61V19fj9lsDnA1oqfx9ipoy5COPSIYe1+wFg0GdFgVF2H2Gr8F483Fm1m8ZzEAz459ljjzmc2ml7N9C6vefYuqkiIAMkecw5R7HiQyIfFMSxVCCCG6HZ1OR3R0NKWlpQCEhoZKI5E4Y4qiUF9fT2lpKdHR0eh0utM+pkcF4xCMaNBgdSuYNDa0YWc+jnGdo46nvn8KBYVr+l3DZRmXdfhYlvIy1vz9rxz6QZ2HPDwmlkvv+AUDx14iPwCEEEKc1ZKTkwF84VgIf4mOjvb9/zqdHhGMfdNBu9UmcpsCoeH+eWkv//QyhbWFpIalMu/8ead/QCtcTidbv/oPGz/5CIfNikar5dzpP+OiG2/FaPbPiBZCCCFEd6bRaEhJSSExMdHXPVKIM2UwGNrUUuzV7vS4bt06fv/737NlyxaKiopYsmQJ11xzTav73nfffbz99tv88Y9/5OGHH27vU7WZt8XYrBhwKwp2BUKjz3xKyTVH1/DZoc/QoGHhxQsJN4a3+xgFe3fz7TtvUFGQD0DqwCFMumsOCZlZZ1yfEEII0dPodLp2BRkh/Kndwbiuro6RI0cye/ZsrrvuupPut2TJEjZt2kRqqv9mgzsZbzA2YcDmufAwNLb9IbapSmslz254FoA7htzB+cnnt+vxdVXHWff+u+xdvxoAc0Qk4/9nNkPHX4ZGqz2j2oQQQgghhP+1OxhPnz6d6dOnn3KfwsJCHnzwQb755huuvPLKDhfXVo0txkasbkWdDjq948OdKYrCcxufo9JaSb/ofjx47oNtfqzb7WLHimV8/89/YKuvA42GkZOmMe7mOzCHR3S4JiGEEEII0bn83sfY7XZz++238+tf/5qhQ4f6+/Ct8vUxxoBV8YxhfAYjUvz3yH9Zmb8SvUbPby/+LSadqU2PK8o+wLd/e4PSnMMAJPXpx6S77ie534AO1yKEEEIIIbqG34PxSy+9hF6v56GHHmrT/jabDZvN5lu3WCxA87GJT8cbjM2KQR3D2G5BE5vQoc77RXVFvPjDiwDcM/we+kX2O+1xrLU1bPj3++xevQIUBWNoKBfd+D8Mu3wKWq2uW19E4K29O7+GnkLORfCQcxE85FwEDzkHoifwazDesmUL/+///T+2bt3a5uHHXnzxRRYsWNBi++rVqwkNbduIDQUFBQCYFCNWBUx2C1uP1FL/1VdtLx5wK24W1S2i1llLui6dpLwkvso/+TEURaHmyEHKt/+I22YFICKrP3GjLqDAoVDw9Tftev5gtmLFikCXIDzkXAQPORfBQ85F4Hm7NQrRnfk1GK9fv57S0lIyMjJ821wuF//7v//Lq6++Sm5ubovHPP744zz66KO+dYvFQnp6OhMnTiQurm0Tabz99tvU1tZixkCtZzrosVfcgmlg+7owfLj/Q3K25hCiC+H16a+TEZlx0n3L83NZvehtSg/tByC2VzoTZ91L2qCu6T7SVRwOBytWrGDy5MltmjFGdB45F8FDzkXwkHMRPCoqKgJdghBnzK/B+Pbbb2fSpEnNtk2dOpXbb7+dO++8s9XHmEwmTKaWfXgNBkObf8j5RqVQDFjdCqEOCyGpKejb8UPySNURXt/xOgD/e97/0jeub6v72err2fjJB2xd9l8UtxuDKYSxN97KudN/hk7fI4aFblV7zofoXHIugoeci+Ah5yLw5PsveoJ2J7na2lqys7N96zk5OWzfvp3Y2FgyMjJatPIaDAaSk5MZOHDgmVfbCrfbTUNDA+AZlUKBGGcduujoNh/D4Xbw+HePY3PZGJc6jpsG3tTqfgX7dvPVn/6PmvIyAAaMGceEmXcTEdfxETCEEEIIIURwaHcw3rx5MxMnTvSte7tBzJw5k8WLF/utsLayWq0oijp4cQgGrG4XISGado0V/Jedf2FvxV4ijZEsuGhBi/7RbpeLjZ/+kx8++xeK4iYqKZlJs+fQe9Rov74WIYQQQggROO0OxhMmTPAF0bZorV+xP3lHpDAqerRosSkuQiPa/nHOrrJd/HXnXwF46sKnSApLanZ/dWkxX77+CkUH1b7EQy+9nMvuvFemchZCCCGE6GG6fadYb//iEM9QbQoQGtO26aAbnA088d0TuBQX03pPY3pW84lL9n23hm//9gb2hnqM5lAm3z2XQeMu9fdLEEIIIYQQQaDnBOMm00GHxUe26bGvbnmVXEsuCeYEnrrwKd92W309K999k32e6ZxTBw7higf+l6jEpJMdSgghhBBCdHM9Jxg3nQ468fQXw208tpEP938IwHPjniPKFAXAsYP7+er131NdWoJGo+XC62/mwutuQqvTdd6LEEIIIYQQAdftg7G3j3GIorYYq9NBnzoYW+wWnv7+aQBuGngTF6ddjNvt4sclH7Phkw9R3G4iExK54oFfkTZoSKe/BiGEEEIIEXjdPhg3dqXwtBjbLegT+p/yMS/+8CIl9SVkRGTw6OhHsZSX8tXr/0fh/j0ADLxoPJPvnospNKzT6xdCCCGEEMGh5wRjxeCbDlqfkHDS/ZfnLueLI1+g1Wh54eIXOLp5Kyv++jq2ujoMIWYun30fQ8Zf1uYprYUQQgghRM/Qc4IxBixuRe1KEd96V4qy+jKe3/Q8ALMHzKTks7XsXr0CgOR+A7jywV8TnZzSNYULIYQQQoig0u2DcWMfYyOlbohyWNC10mKsKArPbniWKlsVo5UBhH+0j93FRaDRMOaaGxl7w609ekpnIYQQQghxat0+CTbvSqGQrHOiNRpb7PfpoU9ZX7CekTkxjDjooMpdRHhcPFfMfZT0oSO6umwhhBBCCBFkek4wxoDNDSFhLaeCPmo5yuvrXmHK1kRSK8wouOk/5iIm3/Mg5vCIri5ZCCGEEEIEoW4djO12Ow6HAwCD24ATCI00NdvH5Xbx0oe/Zsp3MYQ4dOhNJibOvIfhl02RC+yEEEIIIYRPtw7G3tZiraLB5dYBLkJjQ5vt87e/LyBrdS2gIzojnWsfeZLY1F5dX6wQQgghhAhqPSIYh2BsnA46ofl00CU/bicMMI/uy8xHXkFvMHRxlUIIIYQQojto2SG3G2l24Z0bz3TQjSNSKIqCweIE4IIrrpVQLIQQQgghTqpbB+Pm00F7xjBuMlRbcWUBRof6Egf2HhWIEoUQQgghRDfRrYNx8+mgwXjCrHcHc3YAYDMpRIRHB6JEIYQQQgjRTfSMYOxrMbagT2ic9S4//wAArqiW4xoLIYQQQgjRVI8JxmqLcfOuFGVF+QAY46ICUp8QQgghhOg+unUw9vUxxojVrWBUGtCGh/vury0rAyAqMSkg9QkhhBBCiO6jWwfj5tNBg9mkNJu0w1FZA0BSau9AlCeEEEIIIbqRbh2M62rVFmOTYsCugDm8cVhmt+L2DdWWmTEoIPUJIYQQQojuo1sHY2+Lsc6tjk8cGhXiu+9YVQGhDerL69t7eNcXJ4QQQgghupVuG4zdbjcN1gbPitpSHBYX5rv/YN5ONGhw6SEyJi4QJQohhBBCiG6k2wbjhoYG37Lb02Icltw4+kT+Uc9QbZGGZv2OhRBCCCGEaE23DcbebhQmRY/drW0xHXTpMXWoNkOsDNUmhBBCCCFOr9sGY+9Qbaam00HHN07uUVNaAkBkYmJA6hNCCCGEEN1Ltw3Gp5sOWoZqE0IIIYQQ7dH9g3Gz6aDVYOxwOdDLUG1CCCGEEKIdekAw9rQYO2rRxcYCcLTmKBH1OgAyMgYGrEYhhBBCCNF9dNtg3DgdtAGrW8FkcKLRqWH4cOFe9G4tigaiEqSPsRBCCCGEOL1uG4zrazzBWDFgU8BsbhySLS/fM1RbuAGd3hCQ+oQQQgghRPfSbYNxXU0tAAbFgBswhzcG4JJjuep9sREBqEwIIYQQQnRH3TcY1zWfDjosxuy7zyJDtQkhhBBCiHZqdzBet24dM2bMIDU1FY1Gw+eff+67z+FwMG/ePIYPH05YWBipqanccccdHDt2zJ81A1DfoAZjXJ5gHB/eWEeFBYCE1Ey/P68QQgghhOiZ2h2M6+rqGDlyJH/+859b3FdfX8/WrVt5+umn2bp1K5999hkHDhzgZz/7mV+KbarBpk4JrXhbjJNi1Boc9RhqXABkpsuIFEIIIYQQom307X3A9OnTmT59eqv3RUVFsWLFimbb/vSnP3HBBReQn59PRkZGx6o8gd1ux+lWw6/bpVeng05SxzDOs+QRUa++rJReff3yfEIIIYQQoudrdzBur+rqajQaDdHR0a3eb7PZsNlsvnWLRe0G4XA4cDgcrT7Gu49O0eJUdBjtNRCbgsPh4FDxPsx2ddi2sNi4kx5DtI33+yffx8CTcxE85FwEDzkXwUPOgegJOjUYW61W5s2bxy233EJkZGSr+7z44ossWLCgxfbVq1cTGhra6mMap4M2YPNMB71+926cx47xXfEKkgGnUcPKNWv99lrOdid+EiACR85F8JBzETzkXASe93ezEN1ZpwVjh8PBz3/+cxRF4c033zzpfo8//jiPPvqob91isZCens7EiROJi4tr9THZ2dkcOHDAN4ax0W5h0g3/gzYkhC3/+BoAY1wUV1xxhX9f1FnI4XCwYsUKJk+ejMEgY0IHkpyL4CHnInjIuQgeFRUVgS5BiDPWKcHYG4rz8vJYtWrVSVuLAUwmEyaTqcV2g8Fw0h9ydrsd8E4HrRCDDVOEOmZxTXkZUUBEYqL8kPSjU50P0bXkXAQPORfBQ85F4Mn3X/QEfh/H2BuKDx06xLfffnvSVt8zUWtRJ/dQp4MGs9ENgKIo2CuqAEhI8c+FfkIIIYQQ4uzQ7hbj2tpasrOzfes5OTls376d2NhYUlJSuOGGG9i6dStffPEFLpeL4uJiAGJjYzEajX4puq6qBgCTYsACmEPVfF9lq8JUqwCQnjHAL88lhBBCCCHODu0Oxps3b2bixIm+dW//4JkzZzJ//nyWLl0KwKhRo5o9bvXq1UyYMKHjlTZR52kx1ivqxzahkWpXjKZDtSVKi7EQQgghhGiHdgfjCRMmoCjKSe8/1X3+Uu+bDlotPzRWHb0i5/gRwhvUbVFJyZ1ehxBCCHHWUhRwWsFaDdZqNEX5ga5IiDPW6eMYd4b6+jp1wTMddHiieuFdXuEBtIoGRachPCY2UOUJIYQQwc/tBkc92Cy+cNvmL+9jXHbf4fS2zm8YE6Kzdc9gbFWng8at9lkOS1FDcElhLvGAPiYCjdbv1xUKIYQQgaEoUF8B1QVqKLXXg6MOHA0nLNepYbcty06rn4rTQEgUiikM2OenYwoRGN0yGDc4PG9ml6HZdNDVpSXEA+EJ8YErTgghhGgvex1UF0L1UbAUqgG46Zel0I9B9gQaHYREtfIVCSHRLbebIpuvG8NBq8VZUQFPyO9f0b11u2Dscrmwej66cbn1GO1V6OMH41bc2CuqgTASUuXCOyGEEEHC5YSaosaAW33UE4K9obcAGo637VjhSWCOAYMZDGFgDD3FsufrpMthnv1DQaPp3O+BEN1EtwvGDQ0NvmWny4DRbkGfkEBpfSlmdbAK0nr1C1B1QghxApfT0x+zqrF/ZkNVyz6b2pO12p3QUqfVBfoVnV1cDrDVqOfQVtP4ZbU02XbifdVN1i1qFwjFffrnMkZAVK8mX2kQlQ6Raep6ZCroW06IJYTwn24XjL1zsZsUPXYFQpy1aKOiyC3eT0SDejFebHJaIEsUQgQL78VF3v6Ubqe6TXGB23XCbdu3a5x2Mip+RPtDLthrmwTcqpaB117r39d04sfYJwvQpnD1I25vy6D3y7uu8+MsZYrS+H3whf6q1tet1er5CImG0DgIi4fQeAiL89x61kNj/VsjqH+k1FdAXZnnqxzqy5uv15WprbdWT9h1Npz+uG2hNajBNirdE3h7eQJvemMIDonyz3MJITqs2wXjulp1RAp1OmiI0jvRaDTkVuX6xjCOSpSh2kQ34nI0/rKuLW385dz0F3VdGfq6MiY3NKAv/J0n+ESc8OUJQy22NVk3hgdHi6PLCS4bOD1fLhs47Wp4dXlunVbPRUX1jRcLedd9y3Un2cez3V+h5gR64ByA9oxOZQw/SZCNVvtyKu5TjwLgUBsF1NZJi/px/JnQGT1B2fOxu2+5lXWD+fTBV3GdWT2tCYlqHpa94blpoDZFEW4tRJO/EWzHW7xv1GVv4K3seC16s/oeCok84f11wnss5MRtkWq94UkgF4ULEfS6XTCurbQA6nTQNgXMJnV4mLySQxidWhQgKjEpgBWKHkVRWmlBdKkhxu1SWyBP1bpoqz3hF3Rpy1/cbexbqAFCAUrLz+w1GcI8v7DD1XCEBjRatY9hs1ttk/u0Te7TtH4fqKHWF2ztnsDbdNnz1Rkh6nT0IaDVqxcaabWeW12TW8/raLat9X3daCg7biEhvT/a0JgTQu5Jgu+Ztn467U2G1apqJTw3HXKrSv1DwfvlqFeDrb1O/T8L6nlqsLe9b2tbaA1gjm75/fBt89waQtUafS225Z4/Dj3r9ZWA0vh6Kg+f9CkNwOXQ9sEQNFo1qHoDd1hCky/PNnNskwDsufV367UQIih1u2Bcd1ydDtqoGLAC5nD1JRQX5tIL0EeGovfT1NOiB1AUzy9gT4us75dw+QnbKtRbq6V5sG1Lv0B/0Gg9v6gTTvhlHQ/hiRCWgNMUzYYNG7lo9HD0rnpP/8Xa1vs42mubb7NawO1Qn8tRp375+RP+DtNo1dCqM6q3eiPoTOqyselFQt4Lh8JOs72V+w1mv15c5HI42PTVV1xxxRVoDV0UmPRG0HuC25lw2j0t6p5WdXttY4t7iyDdpCXeGH760Ouv77PbpbZEN3u/egLzCe9hpa4MR4MFQ1QymrDEVsJuXPN1c0xwfGoihAhK3S4Y11arv80NnmAcGqVeiFBdWkwvNITJUG09k6Ko4282vaDF23p2YmtTXVlj0K2vaGwh6wyaJq2JrbVGGkJ9wbZF4A1LgLDEJr+sT/0xq+JwcDysFKXPBOhIGHPamodnW42nxdsNKOqtcuJt0/vcTe5TWrlP8YRbY5OgazpJ6PV86Uyg63Y/hro3veccmWMCXcnJaXWeQBsHCQNPuavT4WCZ548UQ1f9kSKE6LG63W+k+lo1GOtcaulhceE43A4clRYgioSU9ABWd5Zyu9XWSLdT7S/rdqnrLs8233bPrb3pVd01rbR4nmT5TAKuMaLJxT0JLS/0CfP0WwyJUgOu72NzfePH7E0/YtfqG7sWdBfeMHqmLY5CCCFED9XtgnFdnXoBisY7611SFIU1hYTXqR+NJadlBay2HsFpg+LdcGwrFG5FX7STSVWl6A8/4Qm53oDbZLmruhsAoGl+YUtIZOtXtIc1WQ6NA0NIF9YohBBCiO6o2wXjBt900OpHZuEpsWy35BHuGZEiOiklUKV1P24XlO2Hwq2+IEzJnsa+qKgXfIUB2Nt5bI1WvRBHq1c/KvctG08xcsIJgbfFqAqRatcEubJbCCGEEJ2g2wXjeltjMFang+5DrmVL41BtSTJUW6sUBSqPwLFtjUG4aEfjEFBNhcZB6rmQdi7OxGFs2H6Qiy6+BL3R7Am3npDrWzao3Qt8y3oJr0IIIYTodrpdMG5w2gBwe2e9S0wg72AOYTZpMW7Gcqx5S/CxberoDCcyhkPKKEg7xxeGic709Z1VHA6OZysoqed27IIvIYQQQohuolsFY0VRsLrVYOxyGTDaa9DHxlJUmEM/QBtiJCQ8IrBFdjVHA5QfhNL9ULZPvT22DWqLW+6rM0Ly8MYAnHouxPeXoYuEEEIIIehmwdhut+NCvdDL6dITjg2NwUBVyTHARFh8HJruNEpAezhtLQNw2T44ntv6xW8aLSQMbt4SnDhUHaZJCCGEEEK00K2CsXfWO52ixebWEmJwUe+ox328DjAR3xOGanPaoSK7efgt3a/O/HSy0R9CoiFxMCQMUm+Th0PKSHVyAyGEEEII0SbdKxiXN04HraDBbNaQX5Pvu/AuPjWj857caYfsFbDzX1B2QL3ITOf9Mjbeekde0BnV0Rh8y54L05ru6318bVnzAHyy8XpNUZA4qDEAe2/Dk7rXeLpCCCGEEEGoewVjT4uxSVEvAjOH68m15DYZqs3PI1Ioinrh2s5/wq5PoKHSv8c/GWNE6wE4IkUCsBBCCCFEJ+lWwbiuugYAvduAAoTGmNlZnUdkvRqUoxL9FIyrjqotwzv+CRWHGreHJ8HwG6Hf5eq6ywEuu+fL2WTZ4Zn5zd5kH0fz/d2e/Z02T1eIQWqf4MRBEJkmAVgIIYQQoot1r2BsUaeD1rsNOICw+Ajyq3cS1eCHodqsFti3VA3Duesbt+vNMPgqGHkzZE1Qu0cIIYQQQogep1ulvLraOgC0nq4U4clRFJbkEOvWgFZLRHx8+w7ocsKRNbDjI9j/JTgbGu/rfQmMvAUGz1BnYRNCCCGEED1atwrG9Q1qcNW41SHHwnvFU/VDERBOaFws2raOx1u8S20Z3vUx1JY0bo/rr7YMj/g5RHfihXxCCCGEECLodK9g7J0O2qXH4KjFGp2AttoGhBOXnHbqB1uK1CC8819QsrtxuzkWht+gBuLUc6VvrxBCCCHEWapbBeMGhxUAt1udDrrAWOcbqi02pVfrDyrdD988AUdWN44DrDPCgGlqV4l+k2TSCyGEEEII0c2CsUudDtrt0mN0HifPWeILxtGJSS0foCjw8Sx1jGCA9DEw4iYYei2ExnZR1UIIIYQQojvoNsFYcbixKXbQgNNlJETnIM+S5wvGUcmtjEiRt0ENxYZQuHcdxPfv4qqFEEIIIUR3oQ10AW1lr2rAplFnhHO79IQY3eRachtbjFsbqm3zO+rt8BskFAshhBBCiFPqNsG4rkKd9Q4FNIoBc6iWgrJcTA51JIroEyf3qC2FvUvV5fPu6sJKhRBCCCFEd9RtgnGtJxgb0aNBgznSSHVpMQCmyAgMISHNH7DtH+rsc2mjIXVUF1crhBBCCCG6m+4TjKvU6aCNbnVyD22EBmONC4DYE4dqc7tg82J1WVqLhRBCCCFEG7Q7GK9bt44ZM2aQmpqKRqPh888/b3a/oig888wzpKSkYDabmTRpEocOHTrjQuuqPdNBe2a9s0U4iKhT+xfHnNi/OPtbqM6HkGgYdt0ZP7cQQgghhOj52h2M6+rqGDlyJH/+859bvf/ll1/mtdde46233uKHH34gLCyMqVOnYrVaz6jQuhp1OmidZ9a74xF1RDR4RqRIOqF/8eZ31dtRt4HBfEbPK4QQQgghzg7tHq5t+vTpTJ8+vdX7FEXh1Vdf5amnnuLqq68G4O9//ztJSUl8/vnn3HzzzR0utL6hHgCNpytFQWglEfXqcrMRKary4eA36vJ5szv8fEIIIYQQ4uzi13GMc3JyKC4uZtKkSb5tUVFRjBkzho0bN7YajG02GzabzbdusagX2TkcDhwOh29702BscNSyX1dKlKcrRXhcgm9f7Y/vokPB3Xs8rqhMaHIM0X7e76tDvo8BJ+cieMi5CB5yLoKHnAPRE/g1GBcXq6NEJCU1n4UuKSnJd9+JXnzxRRYsWNBi++rVqwkNDfWt1zbUgRYUtx6j3cJ2SzZXWMMB+GnXbvTZR9C4nUzZ8w46YDMjKPrqKz+9MrFixYpAlyA85FwEDzkXwUPOReDV19cHugQhzljAZ757/PHHefTRR33rFouF9PR0Jk6cSFxcHACKW2HxljcBcLsMmKjDUV+Hhgj0JhMzrrsejUaDZu8S9DssKOFJnHPzk5yjMwTkNfUkDoeDFStWMHnyZAwG+X4GkpyL4CHnInjIuQgeFRUVgS5BiDPm12CcnKxeBFdSUkJKSmO/35KSEkaNGtXqY0wmEyaTqcV2g8Hg+yHnqrFjRf2IxuUyYNDaCavTABCdlIzRqF6Qx9b3ANCcOxNDSGiLY4qOa3o+RGDJuQgeci6Ch5yLwJPvv+gJ/DqOcVZWFsnJyaxcudK3zWKx8MMPPzB27NgOH9dVY8eqUYOxxm1Aa7C3nAq6dD/kfQcaLYye2fEXIYQQQgghzkrtbjGura0lOzvbt56Tk8P27duJjY0lIyODhx9+mIULF9K/f3+ysrJ4+umnSU1N5ZprrulwkU6LDSt2ALRuA26j1TciRZR3Kugti9TbAdMhqleHn0sIIYQQQpyd2h2MN2/ezMSJE33r3v7BM2fOZPHixfzmN7+hrq6Oe+65h6qqKi6++GK+/vprQk6csrkdrMfrcGsUQA3GDSG1zVuM7XWw/SN15/NliDYhhBBCCNF+7Q7GEyZMQFGUk96v0Wh47rnneO65586osKZqj6tDuOkULRp0HDceJ6LCG4yTYfenYKuGmN7Q5zK/Pa8QQgghhDh7+LWPcWepq/JMB+2Z3KPQWOxrMY5KToGf3lF3HH0naLvFSxJCCCGEEEGmW6TIuhpPMFY8wVhTjN6tRaPREGk7CkXbQWeEc/4ngFUKIYQQQojurFsE4/o6ddBwrafFuN6oXogXEZ+Ibtvf1Z2GXANh8YEoTwghhBBC9ADdIxifMB20t+zohHi1fzHA+XcFqDohhBBCCNETBH0wVhSFeptVXXYbMDhrCLN6hmrTWsDZAIlDIX1MIMsUQgghhBDdXPAHY5sLq9umLrsM6JS6xqHaaveqO50/GzSaQJUohBBCCCF6gKAPxk1nvcNtwE2tb3KPaEcBGMNhxE0BrFAIIYQQQvQEwR+MLXasmsZZ72zaqsah2owNMPxGMEUEskQhhBBCCNEDBH0wdtfYsaK2GGvdBmq1lZjtOgCiDVa56E4IIYQQQvhF0AdjV43D15VC4zbQoKsGIETnwJQ5GpKHB7I8IYQQQgjRQ7R7SuiuZq+2Ytc4AbXFuEFXhxmINjTA+fcHtrgAcbkV6u1O6u0u6mzNb+vtLnrFmBmWFoVOKxckCiGEEEK0VdAH4/qqGnVBAY2ix65rAHREmRV1Uo9OZne6qbU5qbU6qbE5qLU6sTrduBUFRVFwu1GXUYeWcyvqultR15Um625FgRPWFUXB5nSr4dbupN52wq0n9DbdZnW4T1t3lNnAuH5xXNwvgUv6x5MeG9rp3yshhBBCiO4s6INx0+mgNWhw4wB0RGcMAEPIaR/vdivsLbJQ3eCgxur0hFwHtTYnNZ7AW2tzUmdzNt7vC8JO7M7Th9BA0WogzKQnzKgn1KQjzKjHpNdyoLiG6gYHX+0q5qtdxQBkxoVycb94LumfwNi+cUSZDQGuXgghhBAiuAR/MK6tAxqng9a6FACiR1x22sc22F3cufhHNh2pPOM6zAYd4SF6Ikx6TAYdOi1oNRo0Gg0a1JCq1Wg82zzLnn3Ae1/jYxqXwaDTegKujtATb416wk2NwTfUqCPMpN6a9Fo0rYzf7HS52VFQzXeHyvkuu4yt+VXkVdSTV5HPBz/ko9XAyPRoLukXz8X9EzgnIxqDLui7m7eb0+WmxuqkusGBxepQbxtOXHdg8e7T4MDmdGPSa9Uvg65xWa/DZGiyrNd61nWEGJpsO+FxRr0Wo069NTS99SxLdxe1a5DV4aLB4cLq+Wqwu7E6XThdCi63gktRcLndvnWnW8GtKM3WXYqCy+VWl737eO874TFupfk+Ls96s68m23zP5X2cy02dRcfymp0kRoWQEGEiMUK9TQg3kRhpIjbUiLaTzq/brXC83k5ZrY2ymhO+am1U1NqJCNHTK8ZMr5hQ321ajJlwU9D/2BdCiIAJ+p+Q9fXqdNBatwG9o4ZQt2dyjz4jT/k4u9PNfe9vYdORSkIMWjJjwwgPUUOmN+B6l8NPWI4I0RNuMvjWw4w69N0oOOp1WkZnxjA6M4ZfTupPjdXBpiOVfHeojPXZ5Rwpq2NbfhXb8qt4bVU24SY9F/aJ5WJPUO6bENZq4O5KDpfb14pfZ29swa+1Nm/Rr20RfBvDbq3NGdDX0BZazx9G3gDdGJ41GHRquDbovF9QWa7la8sOTAZd86Dd5PEGvaZ5GNdpMfgCuqbZNkWhefjzBsUmQfJ0YbFpyLR5Am5Dk3BrtTfd5g2/bt+2YP5U5tQ0ZO8uPum9Oq2GuDAjiZFqWE6IMDUP0BEmEj23oUY9iqJQY3NS3iTgnhh4vcsVdXZcbqVDVceEGtSQHG32BGZPeI5VbyU4CyHOZkH9E1BxummwN4ABcBvQOqoJt3vGME5KPunjXG6FR/61nbUHyzAbdPzjrgs4r3dsF1UdfCJCDEweksTkIUkAFFY18P2hctYdKuP77HKO1zv4dl8p3+4rBSAlKkTtdjEggQsyo3ArqK14LvUPDofLjcOpYHepy95t6rqCw+k+4T7Ft2x3NfbZbtptxbusdmdxtKkfdVuFGnVEmQ1EhhjUW7OeSM96pNmzLURPlNmAyaDD7nRjc7qwOdzYvMtOt2fd1bjtlPc37tP0+2B3NX9dbgXf/m2jZffxEr99b4JNiEGL2aAjxPOl02rQazXNbnW+da1vu/aE/RrXtS0ep9Nq0GlOvc33eE3jsu9WowG3i40/baFX/yFU1Dl9wbXUYqW8tjG4ltbYKK2xnfZ1hxl16h8W7fgjQaOB2FCjL2Q3Dd+xYUYsDQ4KjjeoX1X1FBxvoKrewfF6B8frq9lVWN3qcaNDDWpYjlZbmtNizKRGmzHptZ7nVT8l89bgXVOXvXe0vl3j+0QNTHodZqMOs0FHqFE93yf7FEwIIbpKUAdjV23jGMa4DbiVMrSKBp3BQHhM60FXURQe/2wnX+4qwqjT8vbto8/qUNyatGgzPz8/nZ+fn+7rg73e0+3ip9zjFFVb+XhLAR9vKfA8Qg+bVgak1hCDtkWLfrjJ4GnV1xNmUgOtL/D6wq96GxGiD6puIoqi+P5QaPrHgsOlNPsDw/cHiG8fhQabna3bdzJoyFBcikZ9nFPB7nL5Hq9ua3ocpdkfLw6XGsK992s1J4S/EwNjK2FR3Qf0Wi1arQadBnRaLTothBh0vmDrDT1mg9oNxdxkm/d+7/5mTyjqrK4H/uZwOLDlKFwxNhODoWV/fafLTUWd3dfCW1pjbdbyW2ppvG1wuKizu3yPjTDpSYgwEd9K4G26HhtmbPf/7Rqrg8KqBgoqGyg4Xq8ue8Pz8XqO1zuo8nztLrSc8fepvTQafP8ffP9/mvw/CfX+/2nyf8uog8PHNOSuOYJLAZv3PeNsfH81Xbad4j7vcly4kZ+NTOX60b0YkCQTSAlxNgnuYGxpnA5a6zbgVMoBiEpMRqNt+QtBURQWfrmPf28uQKuB124ZxfgBCV1ac3ej1WoYlhbFsLQo5kzoS4PdxU+5law/VMb6Q+XsL65p8Rjvx/zNPqpvbZvnY/vmH/Vr1G4qJp0n6Boau7Y06dYSEaKG3mAKtf6g0Wgw6jUY9e1/XQ6Hg5CiHVwxJqPVMCaCh16nJSkyhKTI018gXGtTW5x1Gg0JESbMRl2n1RURYmBQsoFByZEnraXQE5ILmtweq7bicrtRFFA8PTi8I/F4NW5XWt1H8f0DLsXTr9yudqvxfpKiKPiGnaSuPa9MB3nZ7XnAKRVVW3l73RHeXneEEb2iuP7cXvxsZCoxYUa/PYcQIjgFdTB21zROB61xG7BrjgMQfZJuFP9v5SHe+S4HgJdvGMm0YSldU2gPYjbqGD8gwfcHRWVNPV9/s4Irpk0hNMSEQaeRjzqF8CPvH4PBINykZ2ByBAOTu7aV1Olq7HNutavL9Xan74LMBs+2Bs+2put1Nie5+UfJykwnxKBX/whvctHriRfBnrhs0msx6nSN9+m17C6s5pMtBazeX8rOgmp2FlSz8Mu9XD4oiRtG9+LSgQk97o92IYQqOH4an4SrxtFsOmiHphYdrfcvfue7HF799hAAz84Ywg2je3VlqT1WRIiBMIM6LJyhA62cQghxOnqdlgidloiQ9n8S4nA4+OqrPK64YqjfPklJizYzdWgyFbU2/rP9GJ9uLWDPMQtf7ynm6z3FxIcbuXpUGtef24shqa23vgcbRVH7vOdV1JNfWU9+RR35lfUUW6wMT4viyhGpjOwVJQ0f4qwX5MHYToOvK4UeOw3ogOik5i3B//7pKM9/sReARycP4M5xWV1dqhBCiB4mLtzE7IuzmH1xFvuKLHy6pYDPtxdSXmvnne9yeOe7HAanRHLD6F5cPSqV+HBTQOu1OV0crWzgaGU9eRV15Fc2kF9ZR15FPUeP15/0ouZNRyr56/oc0qLNXDUihStHpDA8TUKyODsFdTB219ix+bpSGFEUdblpMP5yZxGPfbYTgLsvyeLBy/p1faFCCCF6tMEpkTx11RDmTR/EuoNlfLq1gG/3lrKvyMLzX+zlxa/2MWFgIjeMTuOyQUkduo7gdJwuN1UNDgqPN5BXWe8LwHkV6nKRxYpyilH8dFoNqdEhZMSGkhEbRmZcKLGhRr7LLufbfSUUVjX4+lanx5q5cngqV41IYWhqpIRkcdYI6mDsrLb6ulJoXHr0TvUdH5WodqVYc6CUh/+1DbcCN5+fzhNXDJY3rxBCiE5j0Gm5fHASlw9Ooqrezn93HOOTrYXsOFrFt/tK+HZfCTGhBn42MpUbRqczLK31UOlwuTleb6eq3kFlnZ2qejuVdQ6O19s5Xmf3DKtnb7Ze3eA4bX1hRh0ZcWFkxJrJjAsjPTaUzNhQMuNCSY02t9o3+ufnp2N1uFhzoJQvdhaxcl8pRysbeGvtYd5ae5jMuFCuHK62JA9JkZAseragDsYNlRW4NWoY1rqc6NyARkNUYhI/5lRy3/tbcLgUrhqRwgvXDpc3qxBCiC4THWrk9rG9uX1sb7JLa/hkSyFLthVQYrHx3sY83tuYx4CkcIamRjUPvHV2as5gAqKkSFOzVt+M2FAyPLdxYcYO/S4MMeiYNiyFacNSaLC7WH2glC93FrFyfwl5FfW8seYwb6w5TFZ8mC8kD0qOkN+7oscJ6mBcX1UFOtAoWnCrw4aFx8axv6yBuxb/hNXhZuLABP7w81Eyta4QQoiA6ZcYwWPTB/HrqQP5LrucT7YUsHxPMQdLajlYUtvqYzQaiDYbiAkzEhPq/TIQG2YkOtRIbJjBc6tujwk1EmU2dPpMrGajjiuGp3DF8BTq7U5W7VdD8qr9peSU1/Gn1dn8aXU2fRLCuGp4CleOSGVAUnin1iREVwnaYKzUVVLv1IBOHZFCY1enXjXFxHPHuz9SY3NyQVYsb9w2ulP6cgkhhBDtpdNquHRAApcOSKC6wcE3e4o5XmcnJsxIbKiRmDCDLwRHmg1B36gTatRz1YhUrhqRSq3Nycp9JXy5s4g1B8s4UlbHa6uyeW1VNv0Sw5nYOzTQ5QpxxoI2GLP9PzRo+gDqGMaKqwyAzRU6KqPtjOgVxTszz+vUwfCFEEKIjooyG/j5eemBLsNvwk16rh6VxtWj0qixOli5T+2TvO5gGdmltRw8WhroEoU4Y8EbjHctx6a5C1BbjN1KFQDFhNE/MZzFd17QoTEvhRBCCHFmIkIMXHNOGteck4bF6uDbvSV8uukgHwa6MCHOUND2QXBXN9DgHZHCbcClWADQR8fz/i/GECtTcwohhBABFxli4Lpze/HaTSMDXYoQZyxog7FLifZNB611G1CUBgAeu/FikiJDAlmaEEIIIYTogYI3GBPdZAxjHSjq8sABvQNYlRBCCCGE6KmCNhg7Qwdi1XiDsTreoyk0jJDwiECWJYQQQggheii/B2OXy8XTTz9NVlYWZrOZvn378vzzz6Ocap7KVuQ5snxdKTROK6DOeCeDiQshhBBCiM7g91EpXnrpJd58803ee+89hg4dyubNm7nzzjuJiorioYceavNxShsisUYUAKBxqv2Lo5OS/V2uEEIIIYQQQCcE4w0bNnD11Vdz5ZVXAtC7d28++ugjfvzxx3YdJwYtBz0txjjVWe+iklP8WqsQQgghhBBefu9KcdFFF7Fy5UoOHjwIwI4dO/juu++YPn16u46ToNPi0LjUFbs6VFt0orQYCyGEEEKIzuH3FuPHHnsMi8XCoEGD0Ol0uFwuXnjhBW677bZW97fZbNhsNt+6xaKGYKfL01qsAM4KAMLjEnA4HP4uWZyC9/st3/fAk3MRPORcBA85F8FDzoHoCfwejP/973/zwQcf8OGHHzJ06FC2b9/Oww8/TGpqKjNnzmyx/4svvsiCBQtabPeNSOE2gFvtSrF17z525Rf4u2TRBitWrAh0CcJDzkXwkHMRPORcBF59fX2gSxDijGmU9g4XcRrp6ek89thjzJ0717dt4cKFvP/+++zfv7/F/q21GKenp7Py0Q9ZF3EAnSOE0Ozv0Op03L/oX2i1On+WK07D4XCwYsUKJk+ejMEgU3AHkpyL4CHnInjIuQgeFRUVpKSkUF1dTWRkZKDLEaJD/N5iXF9fj1bbvOuyTqfD7Xa3ur/JZMJkMrXYbsUzVJunm3FkQiImk8x4FygGg0F+6QQJORfBQ85F8JBzEXjy/Rc9gd+D8YwZM3jhhRfIyMhg6NChbNu2jT/84Q/Mnj27XcdpnNxDTcbRSTIihRBCCCGE6Dx+D8avv/46Tz/9NPfffz+lpaWkpqZy77338swzz7TrODaNOtudxqUG5CgJxkIIIYQQohP5PRhHRETw6quv8uqrr57RcXxdKZxq/+PoxKQzLU0IIYQQQoiT8vs4xv5i83alcKpXucrkHkIIIYQQojMFbTC2onalwKEO1SZ9jIUQQgghRGcK2mBs03i7UjQAMuudEEIIIYToXEEbjBtHpXASGhWNIUSGahNCCCGEEJ0neIMxjcFYulEIIYQQQojOFrTBGI3nxuUkOkm6UQghhBBCiM4VvMEYwK2gURSiJBgLIYQQQohOFtTBWGa9E0IIIYQQXSW4g7FTZr0TQgghhBBdI7iDsUsdsk36GAshhBBCiM4W3MHY6UCnMxAaFR3oUoQQQgghRA8X3MHY5SQsOh6NRhPoUoQQQgghRA8X9ME4Kik10GUIIYQQQoizQFAHY63TQUyqBGMhhBBCCNH5gjoYa1xO4tLTAl2GEEIIIYQ4CwR9MI5NlqHahBBCCCFE5wvuYOx0EiXBWAghhBBCdIHgDsYuF5HxCYEuQwghhBBCnAWCNxgrbgxaMzq9IdCVCCGEEEKIs0DwBmOXkxBzdKCrEEIIIYQQZ4mgDcYap5OwyLhAlyGEEEIIIc4SwRuMXU4iE5MDXYYQQgghhDhLBHEwdhGbkRnoMoQQQgghxFkiiIOxk/gsCcZCCCGEEKJrBHUwTuzdK9BlCCGEEEKIs0TQBmN9bQNRidGBLkMIIYQQQpwlgjYYG5wGdLqgLU8IIYQQQvQwQZs89bqIQJcghBBCCCHOIkEbjE2myECXIIQQQgghziJBG4xj+owMdAlCCCGEEOIsErTBOD5jYKBLEEIIIYQQZ5GgDcYhEfpAlyCEEEIIIc4iQRuMh41PC3QJQgghhBDiLNIpwbiwsJD/+Z//IS4uDrPZzPDhw9m8eXP7CtNpOqM0IYQQQgghWuX3/grHjx9n3LhxTJw4kWXLlpGQkMChQ4eIiYnx91MJIYQQQgjhN34Pxi+99BLp6eksWrTIty0rK8vfTyOEEEIIIYRf+T0YL126lKlTp3LjjTeydu1a0tLSuP/++7n77rtb3d9ms2Gz2XzrFosFAIfDgcPh8Hd5op2850DOReDJuQgeci6Ch5yL4CHnQPQEGkVRFH8eMCQkBIBHH32UG2+8kZ9++olf/vKXvPXWW8ycObPF/vPnz2fBggUttn/44YeEhob6szQhhBBCdJL6+npuvfVWqquriYyUSbpE9+T3YGw0GjnvvPPYsGGDb9tDDz3ETz/9xMaNG1vs31qLcXp6OkVFRcTFxfmzNNEBDoeDFStWMHnyZAwGQ6DLOavJuQgeci6Ch5yL4FFRUUFKSooEY9Gt+b0rRUpKCkOGDGm2bfDgwXz66aet7m8ymTCZTC22GwwG+SEXROR8BA85F8FDzkXwkHMRePL9Fz2B34drGzduHAcOHGi27eDBg2RmZvr7qYQQQgghhPAbvwfjRx55hE2bNvHb3/6W7OxsPvzwQ/7yl78wd+5cfz+VEEIIIYQQfuP3YHz++eezZMkSPvroI4YNG8bzzz/Pq6++ym233ebvpxJCCCGEEMJv/N7HGOCqq67iqquu6oxDCyGEEEII0Sk6ZUpoIYQQQgghuhsJxkIIIYQQQiDBWAghhBBCCKCT+hifCe98IzU1NTImYhBwOBzU19djsVjkfASYnIvgIecieMi5CB41NTVA4+9xIbqjoAvGFRUVAGRlZQW4EiGEEEK0V0VFBVFRUYEuQ4gOCbpgHBsbC0B+fr68sYKAd4ruo0ePyhSfASbnInjIuQgeci6CR3V1NRkZGb7f40J0R0EXjLVatdtzVFSU/JALIpGRkXI+goSci+Ah5yJ4yLkIHt7f40J0R/K/VwghhBBCCCQYCyGEEEIIAQRhMDaZTDz77LOYTKZAlyKQ8xFM5FwEDzkXwUPORfCQcyF6Ao0i46oIIYQQQggRfC3GQgghhBBCBIIEYyGEEEIIIZBgLIQQQgghBCDBWAghhBBCCCAIg/Gf//xnevfuTUhICGPGjOHHH38MdElnnfnz56PRaJp9DRo0KNBlnTXWrVvHjBkzSE1NRaPR8Pnnnze7X1EUnnnmGVJSUjCbzUyaNIlDhw4Fptge7nTnYtasWS3eK9OmTQtMsT3ciy++yPnnn09ERASJiYlcc801HDhwoNk+VquVuXPnEhcXR3h4ONdffz0lJSUBqrjnasu5mDBhQov3xn333RegioVou6AKxv/617949NFHefbZZ9m6dSsjR45k6tSplJaWBrq0s87QoUMpKiryfX333XeBLumsUVdXx8iRI/nzn//c6v0vv/wyr732Gm+99RY//PADYWFhTJ06FavV2sWV9nynOxcA06ZNa/Ze+eijj7qwwrPH2rVrmTt3Lps2bWLFihU4HA6mTJlCXV2db59HHnmE//73v3z88cesXbuWY8eOcd111wWw6p6pLecC4O6772723nj55ZcDVLEQ7aAEkQsuuECZO3eub93lcimpqanKiy++GMCqzj7PPvusMnLkyECXIRRFAZQlS5b41t1ut5KcnKz8/ve/922rqqpSTCaT8tFHHwWgwrPHiedCURRl5syZytVXXx2Qes52paWlCqCsXbtWURT1fWAwGJSPP/7Yt8++ffsUQNm4cWOgyjwrnHguFEVRLr30UuWXv/xl4IoSooOCpsXYbrezZcsWJk2a5Num1WqZNGkSGzduDGBlZ6dDhw6RmppKnz59uO2228jPzw90SQLIycmhuLi42fskKiqKMWPGyPskQNasWUNiYiIDBw5kzpw5VFRUBLqks0J1dTUAsbGxAGzZsgWHw9HsvTFo0CAyMjLkvdHJTjwXXh988AHx8fEMGzaMxx9/nPr6+kCUJ0S76ANdgFd5eTkul4ukpKRm25OSkti/f3+Aqjo7jRkzhsWLFzNw4ECKiopYsGABl1xyCbt37yYiIiLQ5Z3ViouLAVp9n3jvE11n2rRpXHfddWRlZXH48GGeeOIJpk+fzsaNG9HpdIEur8dyu908/PDDjBs3jmHDhgHqe8NoNBIdHd1sX3lvdK7WzgXArbfeSmZmJqmpqezcuZN58+Zx4MABPvvsswBWK8TpBU0wFsFj+vTpvuURI0YwZswYMjMz+fe//81dd90VwMqECC4333yzb3n48OGMGDGCvn37smbNGi6//PIAVtazzZ07l927d8u1D0HgZOfinnvu8S0PHz6clJQULr/8cg4fPkzfvn27ukwh2ixoulLEx8ej0+laXEFcUlJCcnJygKoSANHR0QwYMIDs7OxAl3LW874X5H0SnPr06UN8fLy8VzrRAw88wBdffMHq1avp1auXb3tycjJ2u52qqqpm+8t7o/Oc7Fy0ZsyYMQDy3hBBL2iCsdFoZPTo0axcudK3ze12s3LlSsaOHRvAykRtbS2HDx8mJSUl0KWc9bKyskhOTm72PrFYLPzwww/yPgkCBQUFVFRUyHulEyiKwgMPPMCSJUtYtWoVWVlZze4fPXo0BoOh2XvjwIED5Ofny3vDz053Llqzfft2AHlviKAXVF0pHn30UWbOnMl5553HBRdcwKuvvkpdXR133nlnoEs7q/zqV79ixowZZGZmcuzYMZ599ll0Oh233HJLoEs7K9TW1jZrVcnJyWH79u3ExsaSkZHBww8/zMKFC+nfvz9ZWVk8/fTTpKamcs011wSu6B7qVOciNjaWBQsWcP3115OcnMzhw4f5zW9+Q79+/Zg6dWoAq+6Z5s6dy4cffsh//vMfIiIifP2Go6KiMJvNREVFcdddd/Hoo48SGxtLZGQkDz74IGPHjuXCCy8McPU9y+nOxeHDh/nwww+54ooriIuLY+fOnTzyyCOMHz+eESNGBLh6IU4j0MNinOj1119XMjIyFKPRqFxwwQXKpk2bAl3SWeemm25SUlJSFKPRqKSlpSk33XSTkp2dHeiyzhqrV69WgBZfM2fOVBRFHbLt6aefVpKSkhSTyaRcfvnlyoEDBwJbdA91qnNRX1+vTJkyRUlISFAMBoOSmZmp3H333UpxcXGgy+6RWjsPgLJo0SLfPg0NDcr999+vxMTEKKGhocq1116rFBUVBa7oHup05yI/P18ZP368Ehsbq5hMJqVfv37Kr3/9a6W6ujqwhQvRBhpFUZSuDOJCCCGEEEIEo6DpYyyEEEIIIUQgSTAWQgghhBACCcZCCCGEEEIAEoyFEEIIIYQAJBgLIYQQQggBSDAWQgghhBACkGAshBBCCCEEIMFYCNFNaDQaPv/880CXIYQQogeTYCyEOK1Zs2ah0WhafE2bNi3QpQkhhBB+ow90AUKI7mHatGksWrSo2TaTyRSgaoQQQgj/kxZjIUSbmEwmkpOTm33FxMQAajeHN998k+nTp2M2m+nTpw+ffPJJs8fv2rWLyy67DLPZTFxcHPfccw+1tbXN9nn33XcZOnQoJpOJlJQUHnjggWb3l5eXc+211xIaGkr//v1ZunRp575oIYQQZxUJxkIIv3j66ae5/vrr2bFjB7fddhs333wz+/btA6Curo6pU6cSExPDTz/9xMcff8y3337bLPi++eabzJ07l3vuuYddu3axdOlS+vXr1+w5FixYwM9//nN27tzJFVdcwW233UZlZWWXvk4hhBA9l0ZRFCXQRQghgtusWbN4//33CQkJabb9iSee4IknnkCj0XDffffx5ptv+u678MILOffcc3njjTf461//yrx58zh69ChhYWEAfPXVV8yYMYNjx46RlJREWload955JwsXLmy1Bo1Gw1NPPcXzzz8PqGE7PDycZcuWSV9nIYQQfiF9jIUQbTJx4sRmwRcgNjbWtzx27Nhm940dO5bt27cDsG/fPkaOHOkLxQDjxo3D7XZz4MABNBoNx44d4/LLLz9lDSNGjPAth4WFERkZSWlpaUdfkhBCCNGMBGMhRJuEhYW16NrgL2azuU37GQyGZusajQa3290ZJQkhhDgLSR9jIYRfbNq0qcX64MGDARg8eDA7duygrq7Od//333+PVqtl4MCBRERE0Lt3b1auXNmlNQshhBBNSYuxEKJNbDYbxcXFzbbp9Xri4+MB+PjjjznvvPO4+OKL+eCDD/jxxx955513ALjtttt49tlnmTlzJvPnz6esrIwHH3yQ22+/naSkJADmz5/PfffdR2JiItOnT6empobvv/+eBx98sGtfqBBCiLOWBGMhRJt8/fXXpKSkNNs2cOBA9u/fD6gjRvzzn//k/vvvJyUlhY8++oghQ4YAEBoayjfffMMvf/lLzj//fEJDQ7n++uv5wx/+4DvWzJkzsVqt/PGPf+RXv/oV8fHx3HDDDV33AoUQQpz1ZFQKIcQZ02g0LFmyhGuuuSbQpQghhBAdJn2MhRBCCCGEQIKxEEIIIYQQgPQxFkL4gfTIEkII0RNIi7EQQgghhBBIMBZCCCGEEAKQYCyEEEIIIQQgwVgIIYQQQghAgrEQQgghhBCABGMhhBBCCCEACcZCCCGEEEIAEoyFEEIIIYQAJBgLIYQQQggBwP8HIHlNm9RWtikAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# metrics: 'LOSS', 'MSE', 'MAE', 'LPIPS_Vgg', 'LPIPS_Alex', 'PSNR', 'SSIM', 'ReconstructionError'\n", + "for metric in selected_metrics:\n", + " print(f\"\\n{metric}\")\n", + " print(\"-\" * 80)\n", + "\n", + " plt.figure()\n", + " for key, value in model_paths.items():\n", + " _metrics_path = os.path.join(value, \"metrics.json\")\n", + " assert os.path.exists(_metrics_path), f\"Path {_metrics_path} does not exist\"\n", + " _test_metrics = json.load(open(_metrics_path))\n", + "\n", + " _test_metrics = np.array(_test_metrics[metric])\n", + " plt.plot(_test_metrics, label=key)\n", + "\n", + " # print three significant digits\n", + " if metric == \"PSNR\" or metric == \"SSIM\":\n", + " \n", + " print(f\"Max {metric} for {key} (epoch {np.argmax(_test_metrics)}): {np.max(_test_metrics):.3}\")\n", + " else:\n", + " print(f\"Min {metric} for {key} (epoch {np.argmin(_test_metrics)}): {np.min(_test_metrics):.3}\")\n", + "\n", + " plt.xlabel(\"Epoch\")\n", + " plt.title(metric)\n", + " plt.grid()\n", + " plt.xlim(0, MAX_EPOCH)\n", + " plt.legend(loc=\"upper right\", bbox_to_anchor=(1.35, 1.0))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# TODO : example reconstructions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Section 4.3 (Learning mask)\n", + "\n", + "The purpose of this experiment is to jointly learn the physical mask and digital reconstruction parameters through *hardware-in-the-loop* (HITL) training. For this experiment, the data has to be re-simulated / re-measured whenever the mask pattern changes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "lensless_class", + "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.11.5" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scripts/recon/digicam_celeba.py b/scripts/recon/digicam_celeba.py new file mode 100644 index 00000000..f3cab385 --- /dev/null +++ b/scripts/recon/digicam_celeba.py @@ -0,0 +1,328 @@ +import hydra +import yaml +import torch +from lensless.recon.utils import create_process_network +from lensless.recon.unrolled_admm import UnrolledADMM +from lensless.utils.plot import plot_image +from lensless.utils.dataset import DigiCamCelebA +import numpy as np +import os +from lensless.utils.io import save_image +import time +from lensless.recon.model_dict import download_model + + +@hydra.main(version_base=None, config_path="../../configs", config_name="recon_digicam_celeba") +def apply_unrolled(config): + idx = config.idx + save = config.save + device = config.device + n_trials = config.n_trials + model_name = config.model + + # load config + model_path = download_model(camera="digicam", dataset="celeba_26k", model=model_name) + config_path = os.path.join(model_path, ".hydra", "config.yaml") + with open(config_path, "r") as stream: + config = yaml.safe_load(stream) + + # -- set seed + seed = config["seed"] + torch.manual_seed(seed) + np.random.seed(seed) + generator = torch.Generator().manual_seed(seed) + + # load PSF + # TODO don't use PSF from config + psf_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-25/09-40-03/adafruit_random_pattern_20231004_174047_SIM_psf.png" + # psf_path = os.path.join(config["files"]["psf"]) + print("PSF path : ", psf_path) + if not os.path.exists(psf_path): + raise FileNotFoundError("PSF file not found") + + # load dataset + dataset = DigiCamCelebA( + data_dir=config["files"]["dataset"], + celeba_root=config["files"]["celeba_root"], + psf_path=psf_path, + downsample=config["files"]["downsample"], + simulation_config=config["simulation"], + crop=config["files"]["crop"], + ) + dataset.psf = dataset.psf.to(device) + print(f"Data shape : {dataset[0][0].shape}") + + # -- train-test split + train_size = int((1 - config["files"]["test_size"]) * len(dataset)) + test_size = len(dataset) - train_size + _, test_set = torch.utils.data.random_split( + dataset, [train_size, test_size], generator=generator + ) + print("Test set size: ", len(test_set)) + + if "skip_unrolled" not in config["reconstruction"].keys(): + config["reconstruction"]["skip_unrolled"] = False + + # load best model + model_checkpoint = os.path.join(model_path, "recon_epochBEST") + model_state_dict = torch.load(model_checkpoint, map_location=device) + + pre_process = None + post_process = None + + if config["reconstruction"]["pre_process"]["network"] is not None: + + pre_process, _ = create_process_network( + network=config["reconstruction"]["pre_process"]["network"], + depth=config["reconstruction"]["pre_process"]["depth"], + nc=config["reconstruction"]["pre_process"]["nc"] + if "nc" in config["reconstruction"]["pre_process"].keys() + else None, + device=device, + ) + + if config["reconstruction"]["post_process"]["network"] is not None: + + post_process, _ = create_process_network( + network=config["reconstruction"]["post_process"]["network"], + depth=config["reconstruction"]["post_process"]["depth"], + nc=config["reconstruction"]["post_process"]["nc"] + if "nc" in config["reconstruction"]["post_process"].keys() + else None, + device=device, + ) + + if config["reconstruction"]["method"] == "unrolled_admm": + recon = UnrolledADMM( + dataset.psf, + pre_process=pre_process, + post_process=post_process, + n_iter=config["reconstruction"]["unrolled_admm"]["n_iter"], + skip_unrolled=config["reconstruction"]["skip_unrolled"], + ) + + recon.load_state_dict(model_state_dict) + + # apply reconstruction + lensless, lensed = test_set[idx] + + start_time = time.time() + for _ in range(n_trials): + with torch.no_grad(): + + recon.set_data(lensless.to(device)) + res = recon.apply( + disp_iter=-1, + save=False, + gamma=None, + plot=False, + ) + end_time = time.time() + avg_time_ms = (end_time - start_time) / n_trials * 1000 + print(f"Avg inference [ms] : {avg_time_ms} ms") + + img = res[0].cpu().numpy().squeeze() + + plot_image(img) + plot_image(lensed) + + if save: + print(f"Saving images to {os.getcwd()}") + crop = dataset.crop + res_np = img[ + crop["vertical"][0] : crop["vertical"][1], + crop["horizontal"][0] : crop["horizontal"][1], + ] + lensed_np = lensed[0].cpu().numpy() + lensed_np = lensed_np[ + crop["vertical"][0] : crop["vertical"][1], + crop["horizontal"][0] : crop["horizontal"][1], + ] + save_image(lensed_np, f"original_idx{idx}.png") + save_image(res_np, f"{model_name}_idx{idx}.png") + save_image(lensless[0].cpu().numpy(), f"lensless_idx{idx}.png") + + +if __name__ == "__main__": + apply_unrolled() + + +# #### OLD STUFF + + +# # apply reconstruction on a test image +# idx = 9 +# save = True +# device = "cuda:0" +# n_trials = 1 + + +# # -- unrolled10 +# model_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-24/19-30-13" + +# # # -- Unet +# # model_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-29/12-47-05" + +# # unrolled10 + P8 +# model_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-25/17-59-47" + +# # # fine-tuned unrolled10 + P8 +# # model_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-28/05-28-17" + +# # # P8 + unrolled10 +# # model_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-26/11-52-05" + +# # # P4 + unrolled10 + P4 +# # model_path = "/home/bezzam/LenslessPiCam/outputs/2023-10-31/18-26-08" + +# # # pre + unrolled10 + post + FT +# # model_path = "/home/bezzam/LenslessPiCam/outputs/2023-11-01/12-35-20" + +# # model_path = metrics_dict["unrolled10"] +# # model_path = metrics_dict["unrolled10_sim"] +# # model_path = metrics_dict["unrolled10_sim_post"] +# # model_path = metrics_dict["unrolled10_ft_mask+cf"] +# # model_path = metrics_dict["unet"] +# # model_path = metrics_dict["unrolled10_sim_pre"] +# # model_path = metrics_dict["unrolled10_pre_post"] + +# # Read YAML file +# config_path = os.path.join(model_path, ".hydra", "config.yaml") +# with open(config_path, "r") as stream: +# config = yaml.safe_load(stream) + + +# seed = config["seed"] +# torch.manual_seed(seed) +# np.random.seed(seed) +# generator = torch.Generator().manual_seed(seed) + +# # TODO hack +# # # -- bad +# # psf_path = "outputs/2023-11-26/18-35-03/adafruit_random_pattern_20230719_SIM_psf.png" +# # # -- almost good +# # psf_path = "outputs/2023-11-26/22-38-52/adafruit_random_pattern_20231004_174047_SIM_psf.png" +# # # -- good +# # psf_path = "outputs/2023-11-26/22-43-43/adafruit_random_pattern_20231004_174047_SIM_psf.png" +# # # -- zero one line +# # psf_path = "outputs/2023-11-26/22-48-43/adafruit_random_pattern_20231004_174047_SIM_psf.png" +# # # -- 5% different +# # psf_path = "outputs/2023-11-26/22-57-46/adafruit_random_pattern_20231004_174047_SIM_psf.png" +# psf_path = os.path.join(config["files"]["psf"]) +# print("PSF path : ", psf_path) +# if not os.path.exists(psf_path): +# raise FileNotFoundError("PSF file not found") + +# dataset = DigiCamCelebA( +# data_dir=config["files"]["dataset"], +# celeba_root=config["files"]["celeba_root"], +# psf_path=psf_path, +# downsample=config["files"]["downsample"], +# simulation_config=config["simulation"], +# crop=config["files"]["crop"], +# ) +# dataset.psf = dataset.psf.to(device) +# print(f"Data shape : {dataset[0][0].shape}") + +# # import pudb; pudb.set_trace() + +# # train-test split +# train_size = int((1 - config["files"]["test_size"]) * len(dataset)) +# test_size = len(dataset) - train_size +# train_set, test_set = torch.utils.data.random_split( +# dataset, [train_size, test_size], generator=generator +# ) +# print("Test set size: ", len(test_set)) + + +# if "skip_unrolled" not in config["reconstruction"].keys(): +# config["reconstruction"]["skip_unrolled"] = False + + +# # load best model +# model_checkpoint = os.path.join(model_path, "recon_epochBEST") +# # assert os.path.exists(model_checkpoint), "Checkpoint does not exist" +# # print("Loading checkpoint from : ", model_checkpoint) +# model_state_dict = torch.load(model_checkpoint, map_location=device) +# # assert "_mu1_p" in model_state_dict.keys() + +# pre_process = None +# post_process = None + +# if config["reconstruction"]["pre_process"]["network"] is not None: + +# pre_process, _ = lensless.recon.utils.create_process_network( +# network=config["reconstruction"]["pre_process"]["network"], +# depth=config["reconstruction"]["pre_process"]["depth"], +# nc=config["reconstruction"]["pre_process"]["nc"] +# if "nc" in config["reconstruction"]["pre_process"].keys() +# else None, +# device=device, +# ) + +# if config["reconstruction"]["post_process"]["network"] is not None: + +# post_process, _ = lensless.recon.utils.create_process_network( +# network=config["reconstruction"]["post_process"]["network"], +# depth=config["reconstruction"]["post_process"]["depth"], +# nc=config["reconstruction"]["post_process"]["nc"] +# if "nc" in config["reconstruction"]["post_process"].keys() +# else None, +# device=device, +# ) + +# if config["reconstruction"]["method"] == "unrolled_admm": +# recon = UnrolledADMM( +# dataset.psf, +# pre_process=pre_process, +# post_process=post_process, +# n_iter=config["reconstruction"]["unrolled_admm"]["n_iter"], +# skip_unrolled=config["reconstruction"]["skip_unrolled"], +# ) + +# recon.load_state_dict(model_state_dict) + +# # apply reconstruction + +# # import pudb; pudb.set_trace() + +# # lensless, lensed = train_set[idx] +# lensless, lensed = test_set[idx] +# # lensless, lensed = dataset[idx] + + +# start_time = time.time() +# for _ in range(n_trials): +# with torch.no_grad(): + +# recon.set_data(lensless.to(device)) +# res = recon.apply( +# disp_iter=-1, +# save=False, +# gamma=None, +# plot=False, +# ) +# end_time = time.time() +# avg_time_ms = (end_time - start_time) / n_trials * 1000 +# print(f"Avg inference [ms] : {avg_time_ms} ms") + +# img = res[0].cpu().numpy().squeeze() +# print(img.shape) + +# plot_image(img) +# plot_image(lensed) + +# if save: +# crop = dataset.crop +# res_np = img[ +# crop["vertical"][0] : crop["vertical"][1], +# crop["horizontal"][0] : crop["horizontal"][1], +# ] +# lensed_np = lensed[0].cpu().numpy() +# lensed_np = lensed_np[ +# crop["vertical"][0] : crop["vertical"][1], +# crop["horizontal"][0] : crop["horizontal"][1], +# ] +# save_image(lensed_np, f"original_{idx}.png") +# save_image(res_np, f"{idx}.png") +# save_image(lensless[0].cpu().numpy(), f"lensless_{idx}.png")